resulting "readelf.i"

readelf.i (text/plain), 516.63 KB, created by AlexStar on 2006-05-22 11:22:32 UTC

# 1 "readelf.c"
# 1 "<built-in>"
#define __STDC_VERSION__ 199901L
#define __GXX_ABI_VERSION 102
#define __SIZE_TYPE__ unsigned int
#define __PTRDIFF_TYPE__ int
#define __WCHAR_TYPE__ long int
#define __WINT_TYPE__ unsigned int
#define __SCHAR_MAX__ 127
#define __SHRT_MAX__ 32767
#define __INT_MAX__ 2147483647
#define __LONG_MAX__ 2147483647L
#define __LONG_LONG_MAX__ 9223372036854775807LL
#define __WCHAR_MAX__ 2147483647
#define __CHAR_BIT__ 8
#define __FLT_EVAL_METHOD__ 2
#define __FLT_RADIX__ 2
#define __FLT_MANT_DIG__ 24
#define __FLT_DIG__ 6
#define __FLT_MIN_EXP__ (-125)
#define __FLT_MIN_10_EXP__ (-37)
#define __FLT_MAX_EXP__ 128
#define __FLT_MAX_10_EXP__ 38
#define __FLT_MAX__ 3.40282347e+38F
#define __FLT_MIN__ 1.17549435e-38F
#define __FLT_EPSILON__ 1.19209290e-7F
#define __FLT_DENORM_MIN__ 1.40129846e-45F
#define __DBL_MANT_DIG__ 53
#define __DBL_DIG__ 15
#define __DBL_MIN_EXP__ (-1021)
#define __DBL_MIN_10_EXP__ (-307)
#define __DBL_MAX_EXP__ 1024
#define __DBL_MAX_10_EXP__ 308
#define __DBL_MAX__ 1.7976931348623157e+308
#define __DBL_MIN__ 2.2250738585072014e-308
#define __DBL_EPSILON__ 2.2204460492503131e-16
#define __DBL_DENORM_MIN__ 4.9406564584124654e-324
#define __LDBL_MANT_DIG__ 64
#define __LDBL_DIG__ 18
#define __LDBL_MIN_EXP__ (-16381)
#define __LDBL_MIN_10_EXP__ (-4931)
#define __LDBL_MAX_EXP__ 16384
#define __LDBL_MAX_10_EXP__ 4932
#define __DECIMAL_DIG__ 21
#define __LDBL_MAX__ 1.18973149535723176502e+4932L
#define __LDBL_MIN__ 3.36210314311209350626e-4932L
#define __LDBL_EPSILON__ 1.08420217248550443401e-19L
#define __LDBL_DENORM_MIN__ 3.64519953188247460253e-4951L
#define __REGISTER_PREFIX__ 
#define __USER_LABEL_PREFIX__ 
#define __VERSION__ "3.3.6 (Gentoo 3.3.6, ssp-3.3.6-1.0, pie-8.7.8)"
#define __OPTIMIZE__ 1
#define __STDC_HOSTED__ 1
#define __FINITE_MATH_ONLY__ 0


#define __i386 1
#define __i386__ 1
#define i386 1
#define __tune_athlon__ 1
#define __tune_athlon_sse__ 1
#define __MMX__ 1
#define __3dNOW__ 1
#define __3dNOW_A__ 1
#define __SSE__ 1
#define __athlon 1
#define __athlon__ 1
#define __athlon_sse__ 1
#define __linux 1
#define __linux__ 1
#define linux 1
#define __unix 1
#define __unix__ 1
#define unix 1
#define __ELF__ 1
#define __gnu_linux__ 1
# 1 "<command line>"
#define __GNUC__ 3
#define __GNUC_MINOR__ 3
#define __GNUC_PATCHLEVEL__ 6
#define _GNU_SOURCE 1
#define HAVE_CONFIG_H 1
# 1 "readelf.c"
# 16 "readelf.c"
# 1 "../config.h" 1




#define LIBEBL_SUBDIR "elfutils"


#define LOCALEDIR "/usr/share"


#define MODVERSION "Build on Gentoo2 2006-05-21T13:40:57+0000"





#define PACKAGE "elfutils"


#define PACKAGE_BUGREPORT "http://bugzilla.redhat.com/bugzilla/"


#define PACKAGE_NAME "Red Hat elfutils"


#define PACKAGE_STRING "Red Hat elfutils 0.118"


#define PACKAGE_TARNAME "elfutils"


#define PACKAGE_VERSION "0.118"





#define VERSION "0.118"



#define YYTEXT_POINTER 1


#define _FILE_OFFSET_BITS 64
# 54 "../config.h"
#define lock_lock(lock) ((void) (lock))
#define rwlock_define(class,name) class int name
#define rwlock_init(lock) ((void) (lock))
#define rwlock_fini(lock) ((void) (lock))
#define rwlock_rdlock(lock) ((void) (lock))
#define rwlock_wrlock(lock) ((void) (lock))
#define rwlock_unlock(lock) ((void) (lock))
#define tls_key_t void *
#define key_create(keyp,freefct) (1)
#define getspecific(key) key
#define setspecific(key,val) key = val
#define once_define(class,name) class int name
#define once_execute(name,fct) do { if (name == 0) fct (); name = 1; } while (0)







#define N_(Str) Str


#define strong_alias(name,aliasname) extern __typeof (name) aliasname __attribute__ ((alias (#name)));



#define internal_function_def __attribute__ ((regparm (3), stdcall))




#define internal_function internal_function_def __attribute__ ((visibility ("internal")))

#define internal_strong_alias(name,aliasname) extern __typeof (name) aliasname __attribute__ ((alias (#name), visibility ("internal"))) internal_function_def;


#define attribute_hidden __attribute__ ((visibility ("hidden")))





#define ALLOW_UNALIGNED 1




#define unlikely(expr) __builtin_expect (expr, 0)
#define likely(expr) __builtin_expect (expr, 1)

#define obstack_calloc(ob,size) ({ size_t _s = (size); memset (obstack_alloc (ob, _s), '\0', _s); })

#define obstack_strdup(ob,str) ({ const char *_s = (str); obstack_copy0 (ob, _s, strlen (_s)); })

#define obstack_strndup(ob,str,n) ({ const char *_s = (str); obstack_copy0 (ob, _s, strnlen (_s, n)); })



#define flexarr_size 






#define CALLING_CONVENTION regparm (3), stdcall
#define AND_CALLING_CONVENTION , regparm (3), stdcall
# 138 "../config.h"
#define INTUSE(name) name
#define INTDEF(name) 
#define INTDECL(name) 



#define ELFUTILS_HEADER(name) <lib ##name.h>
# 17 "readelf.c" 2


# 1 "/usr/include/argp.h" 1 3 4
# 22 "/usr/include/argp.h" 3 4
#define _ARGP_H 

# 1 "/usr/include/stdio.h" 1 3 4
# 27 "/usr/include/stdio.h" 3 4
#define _STDIO_H 1
# 1 "/usr/include/features.h" 1 3 4
# 20 "/usr/include/features.h" 3 4
#define _FEATURES_H 1
# 114 "/usr/include/features.h" 3 4
#define __KERNEL_STRICT_NAMES 



#define __USE_ANSI 1
# 128 "/usr/include/features.h" 3 4
#define __GNUC_PREREQ(maj,min) ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))
# 146 "/usr/include/features.h" 3 4
#define _ISOC99_SOURCE 1

#define _POSIX_SOURCE 1

#define _POSIX_C_SOURCE 199506L

#define _XOPEN_SOURCE 600

#define _XOPEN_SOURCE_EXTENDED 1

#define _LARGEFILE64_SOURCE 1

#define _BSD_SOURCE 1

#define _SVID_SOURCE 1
# 179 "/usr/include/features.h" 3 4
#define __USE_ISOC99 1
# 195 "/usr/include/features.h" 3 4
#define __USE_POSIX 1



#define __USE_POSIX2 1



#define __USE_POSIX199309 1



#define __USE_POSIX199506 1







#define __USE_XOPEN 1

#define __USE_XOPEN_EXTENDED 1
#define __USE_UNIX98 1

#define _LARGEFILE_SOURCE 1

#define __USE_XOPEN2K 1
#undef __USE_ISOC99
#define __USE_ISOC99 1
# 234 "/usr/include/features.h" 3 4
#define __USE_LARGEFILE 1



#define __USE_LARGEFILE64 1



#define __USE_FILE_OFFSET64 1



#define __USE_MISC 1



#define __USE_BSD 1



#define __USE_SVID 1



#define __USE_GNU 1
# 274 "/usr/include/features.h" 3 4
#define __STDC_IEC_559__ 1
#define __STDC_IEC_559_COMPLEX__ 1


#define __STDC_ISO_10646__ 200009L
# 287 "/usr/include/features.h" 3 4
#define __GNU_LIBRARY__ 6



#define __GLIBC__ 2
#define __GLIBC_MINOR__ 3

#define __GLIBC_PREREQ(maj,min) ((__GLIBC__ << 16) + __GLIBC_MINOR__ >= ((maj) << 16) + (min))
# 303 "/usr/include/features.h" 3 4
#define __GLIBC_HAVE_LONG_LONG 1





# 1 "/usr/include/sys/cdefs.h" 1 3 4
# 20 "/usr/include/sys/cdefs.h" 3 4
#define _SYS_CDEFS_H 1
# 46 "/usr/include/sys/cdefs.h" 3 4
#define __THROW __attribute__ ((__nothrow__))
#define __NTH(fct) __attribute__ ((__nothrow__)) fct
# 73 "/usr/include/sys/cdefs.h" 3 4
#define __P(args) args
#define __PMT(args) args




#define __CONCAT(x,y) x ## y
#define __STRING(x) #x


#define __ptr_t void *
#define __long_double_t long double







#define __BEGIN_DECLS 
#define __END_DECLS 
# 113 "/usr/include/sys/cdefs.h" 3 4
#define __BEGIN_NAMESPACE_STD 
#define __END_NAMESPACE_STD 
#define __USING_NAMESPACE_STD(name) 
#define __BEGIN_NAMESPACE_C99 
#define __END_NAMESPACE_C99 
#define __USING_NAMESPACE_C99(name) 





#define __bounded 
#define __unbounded 
#define __ptrvalue 




#define __bos(ptr) __builtin_object_size (ptr, __USE_FORTIFY_LEVEL > 1)
#define __bos0(ptr) __builtin_object_size (ptr, 0)





#define __flexarr []
# 165 "/usr/include/sys/cdefs.h" 3 4
#define __REDIRECT(name,proto,alias) name proto __asm__ (__ASMNAME (#alias))




#define __REDIRECT_NTH(name,proto,alias) name proto __asm__ (__ASMNAME (#alias)) __THROW


#define __ASMNAME(cname) __ASMNAME2 (__USER_LABEL_PREFIX__, cname)
#define __ASMNAME2(prefix,cname) __STRING (prefix) cname
# 195 "/usr/include/sys/cdefs.h" 3 4
#define __attribute_malloc__ __attribute__ ((__malloc__))
# 204 "/usr/include/sys/cdefs.h" 3 4
#define __attribute_pure__ __attribute__ ((__pure__))
# 213 "/usr/include/sys/cdefs.h" 3 4
#define __attribute_used__ __attribute__ ((__used__))
#define __attribute_noinline__ __attribute__ ((__noinline__))







#define __attribute_deprecated__ __attribute__ ((__deprecated__))
# 234 "/usr/include/sys/cdefs.h" 3 4
#define __attribute_format_arg__(x) __attribute__ ((__format_arg__ (x)))
# 244 "/usr/include/sys/cdefs.h" 3 4
#define __attribute_format_strfmon__(a,b) __attribute__ ((__format__ (__strfmon__, a, b)))
# 253 "/usr/include/sys/cdefs.h" 3 4
#define __nonnull(params) __attribute__ ((__nonnull__ params))
# 275 "/usr/include/sys/cdefs.h" 3 4
#define __restrict_arr __restrict
# 310 "/usr/include/features.h" 2 3 4
# 324 "/usr/include/features.h" 3 4
#define __USE_EXTERN_INLINES 1







# 1 "/usr/include/gnu/stubs.h" 1 3 4
# 10 "/usr/include/gnu/stubs.h" 3 4
#define __stub___kernel_cosl 
#define __stub___kernel_sinl 
#define __stub___kernel_tanl 
#define __stub_chflags 
#define __stub_fattach 
#define __stub_fchflags 
#define __stub_fdetach 
#define __stub_gtty 
#define __stub_lchmod 
#define __stub_lutimes 
#define __stub_revoke 
#define __stub_setlogin 
#define __stub_sstk 
#define __stub_stty 
# 333 "/usr/include/features.h" 2 3 4
# 29 "/usr/include/stdio.h" 2 3 4



#define __need_size_t 
#define __need_NULL 
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 1 3 4
# 188 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#define __size_t__ 
#define __SIZE_T__ 
#define _SIZE_T 
#define _SYS_SIZE_T_H 
#define _T_SIZE_ 
#define _T_SIZE 
#define __SIZE_T 
#define _SIZE_T_ 
#define _BSD_SIZE_T_ 
#define _SIZE_T_DEFINED_ 
#define _SIZE_T_DEFINED 
#define _BSD_SIZE_T_DEFINED_ 
#define _SIZE_T_DECLARED 
#define ___int_size_t_h 
#define _GCC_SIZE_T 
#define _SIZET_ 



#define __size_t 





typedef unsigned int size_t;
# 235 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#undef __need_size_t
# 402 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#define NULL ((void *)0)





#undef __need_NULL
# 35 "/usr/include/stdio.h" 2 3 4

# 1 "/usr/include/bits/types.h" 1 3 4
# 25 "/usr/include/bits/types.h" 3 4
#define _BITS_TYPES_H 1


# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 19 "/usr/include/bits/wordsize.h" 3 4
#define __WORDSIZE 32
# 29 "/usr/include/bits/types.h" 2 3 4

#define __need_size_t 
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 1 3 4
# 235 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#undef __need_size_t
# 32 "/usr/include/bits/types.h" 2 3 4


typedef unsigned char __u_char;
typedef unsigned short int __u_short;
typedef unsigned int __u_int;
typedef unsigned long int __u_long;


typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;




__extension__ typedef signed long long int __int64_t;
__extension__ typedef unsigned long long int __uint64_t;







__extension__ typedef long long int __quad_t;
__extension__ typedef unsigned long long int __u_quad_t;
# 102 "/usr/include/bits/types.h" 3 4
#define __S16_TYPE short int
#define __U16_TYPE unsigned short int
#define __S32_TYPE int
#define __U32_TYPE unsigned int
#define __SLONGWORD_TYPE long int
#define __ULONGWORD_TYPE unsigned long int

#define __SQUAD_TYPE __quad_t
#define __UQUAD_TYPE __u_quad_t
#define __SWORD_TYPE int
#define __UWORD_TYPE unsigned int
#define __SLONG32_TYPE long int
#define __ULONG32_TYPE unsigned long int
#define __S64_TYPE __quad_t
#define __U64_TYPE __u_quad_t
# 129 "/usr/include/bits/types.h" 3 4
# 1 "/usr/include/bits/typesizes.h" 1 3 4
# 25 "/usr/include/bits/typesizes.h" 3 4
#define _BITS_TYPESIZES_H 1




#define __DEV_T_TYPE __UQUAD_TYPE
#define __UID_T_TYPE __U32_TYPE
#define __GID_T_TYPE __U32_TYPE
#define __INO_T_TYPE __ULONGWORD_TYPE
#define __INO64_T_TYPE __UQUAD_TYPE
#define __MODE_T_TYPE __U32_TYPE
#define __NLINK_T_TYPE __UWORD_TYPE
#define __OFF_T_TYPE __SLONGWORD_TYPE
#define __OFF64_T_TYPE __SQUAD_TYPE
#define __PID_T_TYPE __S32_TYPE
#define __RLIM_T_TYPE __ULONGWORD_TYPE
#define __RLIM64_T_TYPE __UQUAD_TYPE
#define __BLKCNT_T_TYPE __SLONGWORD_TYPE
#define __BLKCNT64_T_TYPE __SQUAD_TYPE
#define __FSBLKCNT_T_TYPE __ULONGWORD_TYPE
#define __FSBLKCNT64_T_TYPE __UQUAD_TYPE
#define __FSFILCNT_T_TYPE __ULONGWORD_TYPE
#define __FSFILCNT64_T_TYPE __UQUAD_TYPE
#define __ID_T_TYPE __U32_TYPE
#define __CLOCK_T_TYPE __SLONGWORD_TYPE
#define __TIME_T_TYPE __SLONGWORD_TYPE
#define __USECONDS_T_TYPE __U32_TYPE
#define __SUSECONDS_T_TYPE __SLONGWORD_TYPE
#define __DADDR_T_TYPE __S32_TYPE
#define __SWBLK_T_TYPE __SLONGWORD_TYPE
#define __KEY_T_TYPE __S32_TYPE
#define __CLOCKID_T_TYPE __S32_TYPE
#define __TIMER_T_TYPE void *
#define __BLKSIZE_T_TYPE __SLONGWORD_TYPE
#define __FSID_T_TYPE struct { int __val[2]; }
#define __SSIZE_T_TYPE __SWORD_TYPE


#define __FD_SETSIZE 1024
# 130 "/usr/include/bits/types.h" 2 3 4



#define __STD_TYPE __extension__ typedef


__extension__ typedef __u_quad_t __dev_t;
__extension__ typedef unsigned int __uid_t;
__extension__ typedef unsigned int __gid_t;
__extension__ typedef unsigned long int __ino_t;
__extension__ typedef __u_quad_t __ino64_t;
__extension__ typedef unsigned int __mode_t;
__extension__ typedef unsigned int __nlink_t;
__extension__ typedef long int __off_t;
__extension__ typedef __quad_t __off64_t;
__extension__ typedef int __pid_t;
__extension__ typedef struct { int __val[2]; } __fsid_t;
__extension__ typedef long int __clock_t;
__extension__ typedef unsigned long int __rlim_t;
__extension__ typedef __u_quad_t __rlim64_t;
__extension__ typedef unsigned int __id_t;
__extension__ typedef long int __time_t;
__extension__ typedef unsigned int __useconds_t;
__extension__ typedef long int __suseconds_t;

__extension__ typedef int __daddr_t;
__extension__ typedef long int __swblk_t;
__extension__ typedef int __key_t;


__extension__ typedef int __clockid_t;


__extension__ typedef void * __timer_t;


__extension__ typedef long int __blksize_t;




__extension__ typedef long int __blkcnt_t;
__extension__ typedef __quad_t __blkcnt64_t;


__extension__ typedef unsigned long int __fsblkcnt_t;
__extension__ typedef __u_quad_t __fsblkcnt64_t;


__extension__ typedef unsigned long int __fsfilcnt_t;
__extension__ typedef __u_quad_t __fsfilcnt64_t;

__extension__ typedef int __ssize_t;



typedef __off64_t __loff_t;
typedef __quad_t *__qaddr_t;
typedef char *__caddr_t;


__extension__ typedef int __intptr_t;


__extension__ typedef unsigned int __socklen_t;


#undef __STD_TYPE
# 37 "/usr/include/stdio.h" 2 3 4
#define __need_FILE 
#define __need___FILE 







typedef struct _IO_FILE FILE;







#define __FILE_defined 1

#undef __need_FILE





typedef struct _IO_FILE __FILE;

#define ____FILE_defined 1

#undef __need___FILE



#define _STDIO_USES_IOSTREAM 

# 1 "/usr/include/libio.h" 1 3 4
# 30 "/usr/include/libio.h" 3 4
#define _IO_STDIO_H 

# 1 "/usr/include/_G_config.h" 1 3 4




#define _G_config_h 1




#define __need_size_t 
#define __need_wchar_t 
#define __need_wint_t 
#define __need_NULL 
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 1 3 4
# 235 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#undef __need_size_t
# 264 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#define __wchar_t__ 
#define __WCHAR_T__ 
#define _WCHAR_T 
#define _T_WCHAR_ 
#define _T_WCHAR 
#define __WCHAR_T 
#define _WCHAR_T_ 
#define _BSD_WCHAR_T_ 
#define _WCHAR_T_DEFINED_ 
#define _WCHAR_T_DEFINED 
#define _WCHAR_T_H 
#define ___int_wchar_t_h 
#define __INT_WCHAR_T_H 
#define _GCC_WCHAR_T 
#define _WCHAR_T_DECLARED 
# 291 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#undef _BSD_WCHAR_T_
# 325 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
typedef long int wchar_t;
# 344 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#undef __need_wchar_t




#define _WINT_T 




typedef unsigned int wint_t;

#undef __need_wint_t
# 397 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#undef NULL




#define NULL ((void *)0)





#undef __need_NULL
# 15 "/usr/include/_G_config.h" 2 3 4
# 23 "/usr/include/_G_config.h" 3 4
#define __need_mbstate_t 
# 1 "/usr/include/wchar.h" 1 3 4
# 47 "/usr/include/wchar.h" 3 4
#define __need_wint_t 
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 1 3 4
# 356 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#undef __need_wint_t
# 49 "/usr/include/wchar.h" 2 3 4

# 1 "/usr/include/bits/wchar.h" 1 3 4
# 21 "/usr/include/bits/wchar.h" 3 4
#define _BITS_WCHAR_H 1

#define __WCHAR_MIN (-2147483647l - 1l)
#define __WCHAR_MAX (2147483647l)
# 51 "/usr/include/wchar.h" 2 3 4
# 74 "/usr/include/wchar.h" 3 4
#define __mbstate_t_defined 1

typedef struct
{
  int __count;
  union
  {
    wint_t __wch;
    char __wchb[4];
  } __value;
} __mbstate_t;

#undef __need_mbstate_t
# 25 "/usr/include/_G_config.h" 2 3 4
#define _G_size_t size_t
typedef struct
{
  __off_t __pos;
  __mbstate_t __state;
} _G_fpos_t;
typedef struct
{
  __off64_t __pos;
  __mbstate_t __state;
} _G_fpos64_t;
#define _G_ssize_t __ssize_t
#define _G_off_t __off_t
#define _G_off64_t __off64_t
#define _G_pid_t __pid_t
#define _G_uid_t __uid_t
#define _G_wchar_t wchar_t
#define _G_wint_t wint_t
#define _G_stat64 stat64
# 1 "/usr/include/gconv.h" 1 3 4
# 24 "/usr/include/gconv.h" 3 4
#define _GCONV_H 1


#define __need_mbstate_t 
# 1 "/usr/include/wchar.h" 1 3 4
# 47 "/usr/include/wchar.h" 3 4
#define __need_wint_t 
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 1 3 4
# 356 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#undef __need_wint_t
# 49 "/usr/include/wchar.h" 2 3 4
# 86 "/usr/include/wchar.h" 3 4
#undef __need_mbstate_t
# 29 "/usr/include/gconv.h" 2 3 4
#define __need_size_t 
#define __need_wchar_t 
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 1 3 4
# 235 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#undef __need_size_t
# 344 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#undef __need_wchar_t
# 32 "/usr/include/gconv.h" 2 3 4


#define __UNKNOWN_10646_CHAR ((wchar_t) 0xfffd)


enum
{
  __GCONV_OK = 0,
  __GCONV_NOCONV,
  __GCONV_NODB,
  __GCONV_NOMEM,

  __GCONV_EMPTY_INPUT,
  __GCONV_FULL_OUTPUT,
  __GCONV_ILLEGAL_INPUT,
  __GCONV_INCOMPLETE_INPUT,

  __GCONV_ILLEGAL_DESCRIPTOR,
  __GCONV_INTERNAL_ERROR
};



enum
{
  __GCONV_IS_LAST = 0x0001,
  __GCONV_IGNORE_ERRORS = 0x0002
};



struct __gconv_step;
struct __gconv_step_data;
struct __gconv_loaded_object;
struct __gconv_trans_data;



typedef int (*__gconv_fct) (struct __gconv_step *, struct __gconv_step_data *,
                            __const unsigned char **, __const unsigned char *,
                            unsigned char **, size_t *, int, int);


typedef wint_t (*__gconv_btowc_fct) (struct __gconv_step *, unsigned char);


typedef int (*__gconv_init_fct) (struct __gconv_step *);
typedef void (*__gconv_end_fct) (struct __gconv_step *);



typedef int (*__gconv_trans_fct) (struct __gconv_step *,
                                  struct __gconv_step_data *, void *,
                                  __const unsigned char *,
                                  __const unsigned char **,
                                  __const unsigned char *, unsigned char **,
                                  size_t *);


typedef int (*__gconv_trans_context_fct) (void *, __const unsigned char *,
                                          __const unsigned char *,
                                          unsigned char *, unsigned char *);


typedef int (*__gconv_trans_query_fct) (__const char *, __const char ***,
                                        size_t *);


typedef int (*__gconv_trans_init_fct) (void **, const char *);
typedef void (*__gconv_trans_end_fct) (void *);

struct __gconv_trans_data
{

  __gconv_trans_fct __trans_fct;
  __gconv_trans_context_fct __trans_context_fct;
  __gconv_trans_end_fct __trans_end_fct;
  void *__data;
  struct __gconv_trans_data *__next;
};



struct __gconv_step
{
  struct __gconv_loaded_object *__shlib_handle;
  __const char *__modname;

  int __counter;

  char *__from_name;
  char *__to_name;

  __gconv_fct __fct;
  __gconv_btowc_fct __btowc_fct;
  __gconv_init_fct __init_fct;
  __gconv_end_fct __end_fct;



  int __min_needed_from;
  int __max_needed_from;
  int __min_needed_to;
  int __max_needed_to;


  int __stateful;

  void *__data;
};



struct __gconv_step_data
{
  unsigned char *__outbuf;
  unsigned char *__outbufend;



  int __flags;



  int __invocation_counter;



  int __internal_use;

  __mbstate_t *__statep;
  __mbstate_t __state;



  struct __gconv_trans_data *__trans;
};



typedef struct __gconv_info
{
  size_t __nsteps;
  struct __gconv_step *__steps;
  __extension__ struct __gconv_step_data __data [];
} *__gconv_t;
# 45 "/usr/include/_G_config.h" 2 3 4
typedef union
{
  struct __gconv_info __cd;
  struct
  {
    struct __gconv_info __cd;
    struct __gconv_step_data __data;
  } __combined;
} _G_iconv_t;

typedef int _G_int16_t __attribute__ ((__mode__ (__HI__)));
typedef int _G_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int _G_uint32_t __attribute__ ((__mode__ (__SI__)));

#define _G_HAVE_BOOL 1



#define _G_HAVE_ATEXIT 1
#define _G_HAVE_SYS_CDEFS 1
#define _G_HAVE_SYS_WAIT 1
#define _G_NEED_STDARG_H 1
#define _G_va_list __gnuc_va_list

#define _G_HAVE_PRINTF_FP 1
#define _G_HAVE_MMAP 1
#define _G_HAVE_MREMAP 1
#define _G_HAVE_LONG_DOUBLE_IO 1
#define _G_HAVE_IO_FILE_OPEN 1
#define _G_HAVE_IO_GETLINE_INFO 1

#define _G_IO_IO_FILE_VERSION 0x20001

#define _G_OPEN64 __open64
#define _G_LSEEK64 __lseek64
#define _G_MMAP64 __mmap64
#define _G_FSTAT64(fd,buf) __fxstat64 (_STAT_VER, fd, buf)


#define _G_HAVE_ST_BLKSIZE defined (_STATBUF_ST_BLKSIZE)

#define _G_BUFSIZ 8192


#define _G_NAMES_HAVE_UNDERSCORE 0
#define _G_VTABLE_LABEL_HAS_LENGTH 1
#define _G_USING_THUNKS 1
#define _G_VTABLE_LABEL_PREFIX "__vt_"
#define _G_VTABLE_LABEL_PREFIX_ID __vt_



#define _G_ARGS(ARGLIST) ARGLIST
# 33 "/usr/include/libio.h" 2 3 4

#define _IO_pos_t _G_fpos_t
#define _IO_fpos_t _G_fpos_t
#define _IO_fpos64_t _G_fpos64_t
#define _IO_size_t _G_size_t
#define _IO_ssize_t _G_ssize_t
#define _IO_off_t _G_off_t
#define _IO_off64_t _G_off64_t
#define _IO_pid_t _G_pid_t
#define _IO_uid_t _G_uid_t
#define _IO_iconv_t _G_iconv_t
#define _IO_HAVE_SYS_WAIT _G_HAVE_SYS_WAIT
#define _IO_HAVE_ST_BLKSIZE _G_HAVE_ST_BLKSIZE
#define _IO_BUFSIZ _G_BUFSIZ
#define _IO_va_list _G_va_list
#define _IO_wint_t _G_wint_t



#define __need___va_list 
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stdarg.h" 1 3 4
# 37 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stdarg.h" 3 4
#undef __need___va_list




#define __GNUC_VA_LIST 
typedef __builtin_va_list __gnuc_va_list;
# 54 "/usr/include/libio.h" 2 3 4

#undef _IO_va_list
#define _IO_va_list __gnuc_va_list
# 76 "/usr/include/libio.h" 3 4
#define _PARAMS(protos) __P(protos)







#define _IO_UNIFIED_JUMPTABLES 1





#define EOF (-1)
# 105 "/usr/include/libio.h" 3 4
#define _IOS_INPUT 1
#define _IOS_OUTPUT 2
#define _IOS_ATEND 4
#define _IOS_APPEND 8
#define _IOS_TRUNC 16
#define _IOS_NOCREATE 32
#define _IOS_NOREPLACE 64
#define _IOS_BIN 128







#define _IO_MAGIC 0xFBAD0000
#define _OLD_STDIO_MAGIC 0xFABC0000
#define _IO_MAGIC_MASK 0xFFFF0000
#define _IO_USER_BUF 1
#define _IO_UNBUFFERED 2
#define _IO_NO_READS 4
#define _IO_NO_WRITES 8
#define _IO_EOF_SEEN 0x10
#define _IO_ERR_SEEN 0x20
#define _IO_DELETE_DONT_CLOSE 0x40
#define _IO_LINKED 0x80
#define _IO_IN_BACKUP 0x100
#define _IO_LINE_BUF 0x200
#define _IO_TIED_PUT_GET 0x400
#define _IO_CURRENTLY_PUTTING 0x800
#define _IO_IS_APPENDING 0x1000
#define _IO_IS_FILEBUF 0x2000
#define _IO_BAD_SEEN 0x4000
#define _IO_USER_LOCK 0x8000

#define _IO_FLAGS2_MMAP 1
#define _IO_FLAGS2_NOTCANCEL 2





#define _IO_SKIPWS 01
#define _IO_LEFT 02
#define _IO_RIGHT 04
#define _IO_INTERNAL 010
#define _IO_DEC 020
#define _IO_OCT 040
#define _IO_HEX 0100
#define _IO_SHOWBASE 0200
#define _IO_SHOWPOINT 0400
#define _IO_UPPERCASE 01000
#define _IO_SHOWPOS 02000
#define _IO_SCIENTIFIC 04000
#define _IO_FIXED 010000
#define _IO_UNITBUF 020000
#define _IO_STDIO 040000
#define _IO_DONT_CLOSE 0100000
#define _IO_BOOLALPHA 0200000


struct _IO_jump_t; struct _IO_FILE;
# 176 "/usr/include/libio.h" 3 4
typedef void _IO_lock_t;





struct _IO_marker {
  struct _IO_marker *_next;
  struct _IO_FILE *_sbuf;



  int _pos;
# 199 "/usr/include/libio.h" 3 4
};


enum __codecvt_result
{
  __codecvt_ok,
  __codecvt_partial,
  __codecvt_error,
  __codecvt_noconv
};
# 267 "/usr/include/libio.h" 3 4
struct _IO_FILE {
  int _flags;
#define _IO_file_flags _flags



  char* _IO_read_ptr;
  char* _IO_read_end;
  char* _IO_read_base;
  char* _IO_write_base;
  char* _IO_write_ptr;
  char* _IO_write_end;
  char* _IO_buf_base;
  char* _IO_buf_end;

  char *_IO_save_base;
  char *_IO_backup_base;
  char *_IO_save_end;

  struct _IO_marker *_markers;

  struct _IO_FILE *_chain;

  int _fileno;



  int _flags2;

  __off_t _old_offset;

#define __HAVE_COLUMN 

  unsigned short _cur_column;
  signed char _vtable_offset;
  char _shortbuf[1];



  _IO_lock_t *_lock;
# 315 "/usr/include/libio.h" 3 4
  __off64_t _offset;





  void *__pad1;
  void *__pad2;

  int _mode;

  char _unused2[15 * sizeof (int) - 2 * sizeof (void *)];

};


typedef struct _IO_FILE _IO_FILE;


struct _IO_FILE_plus;

extern struct _IO_FILE_plus _IO_2_1_stdin_;
extern struct _IO_FILE_plus _IO_2_1_stdout_;
extern struct _IO_FILE_plus _IO_2_1_stderr_;

#define _IO_stdin ((_IO_FILE*)(&_IO_2_1_stdin_))
#define _IO_stdout ((_IO_FILE*)(&_IO_2_1_stdout_))
#define _IO_stderr ((_IO_FILE*)(&_IO_2_1_stderr_))
# 354 "/usr/include/libio.h" 3 4
typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);







typedef __ssize_t __io_write_fn (void *__cookie, __const char *__buf,
                                 size_t __n);







typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);


typedef int __io_close_fn (void *__cookie);




typedef __io_read_fn cookie_read_function_t;
typedef __io_write_fn cookie_write_function_t;
typedef __io_seek_fn cookie_seek_function_t;
typedef __io_close_fn cookie_close_function_t;


typedef struct
{
  __io_read_fn *read;
  __io_write_fn *write;
  __io_seek_fn *seek;
  __io_close_fn *close;
} _IO_cookie_io_functions_t;
typedef _IO_cookie_io_functions_t cookie_io_functions_t;

struct _IO_cookie_file;


extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write,
                             void *__cookie, _IO_cookie_io_functions_t __fns);







extern int __underflow (_IO_FILE *) __attribute__ ((__nothrow__));
extern int __uflow (_IO_FILE *) __attribute__ ((__nothrow__));
extern int __overflow (_IO_FILE *, int) __attribute__ ((__nothrow__));
extern wint_t __wunderflow (_IO_FILE *) __attribute__ ((__nothrow__));
extern wint_t __wuflow (_IO_FILE *) __attribute__ ((__nothrow__));
extern wint_t __woverflow (_IO_FILE *, wint_t) __attribute__ ((__nothrow__));


#define _IO_BE(expr,res) __builtin_expect (expr, res)




#define _IO_getc_unlocked(_fp) (_IO_BE ((_fp)->_IO_read_ptr >= (_fp)->_IO_read_end, 0) ? __uflow (_fp) : *(unsigned char *) (_fp)->_IO_read_ptr++)


#define _IO_peekc_unlocked(_fp) (_IO_BE ((_fp)->_IO_read_ptr >= (_fp)->_IO_read_end, 0) && __underflow (_fp) == EOF ? EOF : *(unsigned char *) (_fp)->_IO_read_ptr)



#define _IO_putc_unlocked(_ch,_fp) (_IO_BE ((_fp)->_IO_write_ptr >= (_fp)->_IO_write_end, 0) ? __overflow (_fp, (unsigned char) (_ch)) : (unsigned char) (*(_fp)->_IO_write_ptr++ = (_ch)))




#define _IO_getwc_unlocked(_fp) (_IO_BE ((_fp)->_wide_data->_IO_read_ptr >= (_fp)->_wide_data->_IO_read_end, 0) ? __wuflow (_fp) : (_IO_wint_t) *(_fp)->_wide_data->_IO_read_ptr++)



#define _IO_putwc_unlocked(_wch,_fp) (_IO_BE ((_fp)->_wide_data->_IO_write_ptr >= (_fp)->_wide_data->_IO_write_end, 0) ? __woverflow (_fp, _wch) : (_IO_wint_t) (*(_fp)->_wide_data->_IO_write_ptr++ = (_wch)))





#define _IO_feof_unlocked(__fp) (((__fp)->_flags & _IO_EOF_SEEN) != 0)
#define _IO_ferror_unlocked(__fp) (((__fp)->_flags & _IO_ERR_SEEN) != 0)

extern int _IO_getc (_IO_FILE *__fp) __attribute__ ((__nothrow__));
extern int _IO_putc (int __c, _IO_FILE *__fp) __attribute__ ((__nothrow__));
extern int _IO_feof (_IO_FILE *__fp) __attribute__ ((__nothrow__));
extern int _IO_ferror (_IO_FILE *__fp) __attribute__ ((__nothrow__));

extern int _IO_peekc_locked (_IO_FILE *__fp) __attribute__ ((__nothrow__));


#define _IO_PENDING_OUTPUT_COUNT(_fp) ((_fp)->_IO_write_ptr - (_fp)->_IO_write_base)


extern void _IO_flockfile (_IO_FILE *) __attribute__ ((__nothrow__));
extern void _IO_funlockfile (_IO_FILE *) __attribute__ ((__nothrow__));
extern int _IO_ftrylockfile (_IO_FILE *) __attribute__ ((__nothrow__));
# 466 "/usr/include/libio.h" 3 4
#define _IO_peekc(_fp) _IO_peekc_unlocked (_fp)
#define _IO_flockfile(_fp) 
#define _IO_funlockfile(_fp) 
#define _IO_ftrylockfile(_fp) 
#define _IO_cleanup_region_start(_fct,_fp) 
#define _IO_cleanup_region_end(_Doit) 


extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
                        __gnuc_va_list, int *__restrict) __attribute__ ((__nothrow__));
extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
                         __gnuc_va_list) __attribute__ ((__nothrow__));
extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t) __attribute__ ((__nothrow__));
extern size_t _IO_sgetn (_IO_FILE *, void *, size_t) __attribute__ ((__nothrow__));

extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int) __attribute__ ((__nothrow__));
extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int) __attribute__ ((__nothrow__));

extern void _IO_free_backup_area (_IO_FILE *) __attribute__ ((__nothrow__));
# 73 "/usr/include/stdio.h" 2 3 4




typedef __gnuc_va_list va_list;
#define _VA_LIST_DEFINED 











typedef _G_fpos64_t fpos_t;



typedef _G_fpos64_t fpos64_t;



#define _IOFBF 0
#define _IOLBF 1
#define _IONBF 2




#define BUFSIZ _IO_BUFSIZ
# 118 "/usr/include/stdio.h" 3 4
#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2




#define P_tmpdir "/tmp"
# 138 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
# 24 "/usr/include/bits/stdio_lim.h" 3 4
#define L_tmpnam 20
#define TMP_MAX 238328
#define FILENAME_MAX 4096


#define L_ctermid 9
#define L_cuserid 9





#define FOPEN_MAX 16
# 139 "/usr/include/stdio.h" 2 3 4



extern struct _IO_FILE *stdin;
extern struct _IO_FILE *stdout;
extern struct _IO_FILE *stderr;

#define stdin stdin
#define stdout stdout
#define stderr stderr



extern int remove (__const char *__filename) __attribute__ ((__nothrow__));

extern int rename (__const char *__old, __const char *__new) __attribute__ ((__nothrow__));




# 167 "/usr/include/stdio.h" 3 4
extern FILE *tmpfile (void) __asm__ ("" "tmpfile64");






extern FILE *tmpfile64 (void);



extern char *tmpnam (char *__s) __attribute__ ((__nothrow__));





extern char *tmpnam_r (char *__s) __attribute__ ((__nothrow__));
# 196 "/usr/include/stdio.h" 3 4
extern char *tempnam (__const char *__dir, __const char *__pfx)
     __attribute__ ((__nothrow__)) __attribute__ ((__malloc__));








extern int fclose (FILE *__stream);




extern int fflush (FILE *__stream);

# 221 "/usr/include/stdio.h" 3 4
extern int fflush_unlocked (FILE *__stream);
# 231 "/usr/include/stdio.h" 3 4
extern int fcloseall (void);




# 252 "/usr/include/stdio.h" 3 4
extern FILE *fopen (__const char *__restrict __filename, __const char *__restrict __modes) __asm__ ("" "fopen64");

extern FILE *freopen (__const char *__restrict __filename, __const char *__restrict __modes, FILE *__restrict __stream) __asm__ ("" "freopen64");









extern FILE *fopen64 (__const char *__restrict __filename,
                      __const char *__restrict __modes);
extern FILE *freopen64 (__const char *__restrict __filename,
                        __const char *__restrict __modes,
                        FILE *__restrict __stream);




extern FILE *fdopen (int __fd, __const char *__modes) __attribute__ ((__nothrow__));





extern FILE *fopencookie (void *__restrict __magic_cookie,
                          __const char *__restrict __modes,
                          _IO_cookie_io_functions_t __io_funcs) __attribute__ ((__nothrow__));


extern FILE *fmemopen (void *__s, size_t __len, __const char *__modes) __attribute__ ((__nothrow__));




extern FILE *open_memstream (char **__restrict __bufloc,
                             size_t *__restrict __sizeloc) __attribute__ ((__nothrow__));






extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) __attribute__ ((__nothrow__));



extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
                    int __modes, size_t __n) __attribute__ ((__nothrow__));





extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
                       size_t __size) __attribute__ ((__nothrow__));


extern void setlinebuf (FILE *__stream) __attribute__ ((__nothrow__));








extern int fprintf (FILE *__restrict __stream,
                    __const char *__restrict __format, ...);




extern int printf (__const char *__restrict __format, ...);

extern int sprintf (char *__restrict __s,
                    __const char *__restrict __format, ...) __attribute__ ((__nothrow__));





extern int vfprintf (FILE *__restrict __s, __const char *__restrict __format,
                     __gnuc_va_list __arg);




extern int vprintf (__const char *__restrict __format, __gnuc_va_list __arg);

extern int vsprintf (char *__restrict __s, __const char *__restrict __format,
                     __gnuc_va_list __arg) __attribute__ ((__nothrow__));





extern int snprintf (char *__restrict __s, size_t __maxlen,
                     __const char *__restrict __format, ...)
     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 4)));

extern int vsnprintf (char *__restrict __s, size_t __maxlen,
                      __const char *__restrict __format, __gnuc_va_list __arg)
     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 0)));






extern int vasprintf (char **__restrict __ptr, __const char *__restrict __f,
                      __gnuc_va_list __arg)
     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 0)));
extern int __asprintf (char **__restrict __ptr,
                       __const char *__restrict __fmt, ...)
     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 3)));
extern int asprintf (char **__restrict __ptr,
                     __const char *__restrict __fmt, ...)
     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 3)));







extern int vdprintf (int __fd, __const char *__restrict __fmt,
                     __gnuc_va_list __arg)
     __attribute__ ((__format__ (__printf__, 2, 0)));
extern int dprintf (int __fd, __const char *__restrict __fmt, ...)
     __attribute__ ((__format__ (__printf__, 2, 3)));








extern int fscanf (FILE *__restrict __stream,
                   __const char *__restrict __format, ...);




extern int scanf (__const char *__restrict __format, ...);

extern int sscanf (__const char *__restrict __s,
                   __const char *__restrict __format, ...) __attribute__ ((__nothrow__));








extern int vfscanf (FILE *__restrict __s, __const char *__restrict __format,
                    __gnuc_va_list __arg)
     __attribute__ ((__format__ (__scanf__, 2, 0)));





extern int vscanf (__const char *__restrict __format, __gnuc_va_list __arg)
     __attribute__ ((__format__ (__scanf__, 1, 0)));


extern int vsscanf (__const char *__restrict __s,
                    __const char *__restrict __format, __gnuc_va_list __arg)
     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__scanf__, 2, 0)));









extern int fgetc (FILE *__stream);
extern int getc (FILE *__stream);





extern int getchar (void);




#define getc(_fp) _IO_getc (_fp)






extern int getc_unlocked (FILE *__stream);
extern int getchar_unlocked (void);
# 465 "/usr/include/stdio.h" 3 4
extern int fgetc_unlocked (FILE *__stream);











extern int fputc (int __c, FILE *__stream);
extern int putc (int __c, FILE *__stream);





extern int putchar (int __c);




#define putc(_ch,_fp) _IO_putc (_ch, _fp)
# 498 "/usr/include/stdio.h" 3 4
extern int fputc_unlocked (int __c, FILE *__stream);







extern int putc_unlocked (int __c, FILE *__stream);
extern int putchar_unlocked (int __c);






extern int getw (FILE *__stream);


extern int putw (int __w, FILE *__stream);








extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream);






extern char *gets (char *__s);

# 543 "/usr/include/stdio.h" 3 4
extern char *fgets_unlocked (char *__restrict __s, int __n,
                             FILE *__restrict __stream);
# 559 "/usr/include/stdio.h" 3 4
extern __ssize_t __getdelim (char **__restrict __lineptr,
                               size_t *__restrict __n, int __delimiter,
                               FILE *__restrict __stream);
extern __ssize_t getdelim (char **__restrict __lineptr,
                             size_t *__restrict __n, int __delimiter,
                             FILE *__restrict __stream);







extern __ssize_t getline (char **__restrict __lineptr,
                            size_t *__restrict __n,
                            FILE *__restrict __stream);








extern int fputs (__const char *__restrict __s, FILE *__restrict __stream);





extern int puts (__const char *__s);






extern int ungetc (int __c, FILE *__stream);






extern size_t fread (void *__restrict __ptr, size_t __size,
                     size_t __n, FILE *__restrict __stream);




extern size_t fwrite (__const void *__restrict __ptr, size_t __size,
                      size_t __n, FILE *__restrict __s);

# 620 "/usr/include/stdio.h" 3 4
extern int fputs_unlocked (__const char *__restrict __s,
                           FILE *__restrict __stream);
# 631 "/usr/include/stdio.h" 3 4
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
                              size_t __n, FILE *__restrict __stream);
extern size_t fwrite_unlocked (__const void *__restrict __ptr, size_t __size,
                               size_t __n, FILE *__restrict __stream);








extern int fseek (FILE *__stream, long int __off, int __whence);




extern long int ftell (FILE *__stream);




extern void rewind (FILE *__stream);

# 675 "/usr/include/stdio.h" 3 4
extern int fseeko (FILE *__stream, __off64_t __off, int __whence) __asm__ ("" "fseeko64");


extern __off64_t ftello (FILE *__stream) __asm__ ("" "ftello64");








# 700 "/usr/include/stdio.h" 3 4
extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos) __asm__ ("" "fgetpos64");

extern int fsetpos (FILE *__stream, __const fpos_t *__pos) __asm__ ("" "fsetpos64");









extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
extern __off64_t ftello64 (FILE *__stream);
extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
extern int fsetpos64 (FILE *__stream, __const fpos64_t *__pos);




extern void clearerr (FILE *__stream) __attribute__ ((__nothrow__));

extern int feof (FILE *__stream) __attribute__ ((__nothrow__));

extern int ferror (FILE *__stream) __attribute__ ((__nothrow__));




extern void clearerr_unlocked (FILE *__stream) __attribute__ ((__nothrow__));
extern int feof_unlocked (FILE *__stream) __attribute__ ((__nothrow__));
extern int ferror_unlocked (FILE *__stream) __attribute__ ((__nothrow__));








extern void perror (__const char *__s);






# 1 "/usr/include/bits/sys_errlist.h" 1 3 4
# 27 "/usr/include/bits/sys_errlist.h" 3 4
extern int sys_nerr;
extern __const char *__const sys_errlist[];


extern int _sys_nerr;
extern __const char *__const _sys_errlist[];
# 748 "/usr/include/stdio.h" 2 3 4




extern int fileno (FILE *__stream) __attribute__ ((__nothrow__));




extern int fileno_unlocked (FILE *__stream) __attribute__ ((__nothrow__));
# 767 "/usr/include/stdio.h" 3 4
extern FILE *popen (__const char *__command, __const char *__modes);





extern int pclose (FILE *__stream);





extern char *ctermid (char *__s) __attribute__ ((__nothrow__));





extern char *cuserid (char *__s);




struct obstack;


extern int obstack_printf (struct obstack *__restrict __obstack,
                           __const char *__restrict __format, ...)
     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 3)));
extern int obstack_vprintf (struct obstack *__restrict __obstack,
                            __const char *__restrict __format,
                            __gnuc_va_list __args)
     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 2, 0)));







extern void flockfile (FILE *__stream) __attribute__ ((__nothrow__));



extern int ftrylockfile (FILE *__stream) __attribute__ ((__nothrow__));


extern void funlockfile (FILE *__stream) __attribute__ ((__nothrow__));
# 828 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/bits/stdio.h" 1 3 4
# 27 "/usr/include/bits/stdio.h" 3 4
#define __STDIO_INLINE extern __inline





extern __inline int
vprintf (__const char *__restrict __fmt, __gnuc_va_list __arg)
{
  return vfprintf (stdout, __fmt, __arg);
}


extern __inline int
getchar (void)
{
  return _IO_getc (stdin);
}




extern __inline int
getc_unlocked (FILE *__fp)
{
  return (__builtin_expect ((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end, 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
}


extern __inline int
getchar_unlocked (void)
{
  return (__builtin_expect ((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end, 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++);
}




extern __inline int
putchar (int __c)
{
  return _IO_putc (__c, stdout);
}




extern __inline int
fputc_unlocked (int __c, FILE *__stream)
{
  return (__builtin_expect ((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end, 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}





extern __inline int
putc_unlocked (int __c, FILE *__stream)
{
  return (__builtin_expect ((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end, 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}


extern __inline int
putchar_unlocked (int __c)
{
  return (__builtin_expect ((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end, 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c)));
}





extern __inline __ssize_t
getline (char **__lineptr, size_t *__n, FILE *__stream)
{
  return __getdelim (__lineptr, __n, '\n', __stream);
}





extern __inline int
__attribute__ ((__nothrow__)) feof_unlocked (FILE *__stream)
{
  return (((__stream)->_flags & 0x10) != 0);
}


extern __inline int
__attribute__ ((__nothrow__)) ferror_unlocked (FILE *__stream)
{
  return (((__stream)->_flags & 0x20) != 0);
}







#define fread_unlocked(ptr,size,n,stream) (__extension__ ((__builtin_constant_p (size) && __builtin_constant_p (n) && (size_t) (size) * (size_t) (n) <= 8 && (size_t) (size) != 0) ? ({ char *__ptr = (char *) (ptr); FILE *__stream = (stream); size_t __cnt; for (__cnt = (size_t) (size) * (size_t) (n); __cnt > 0; --__cnt) { int __c = _IO_getc_unlocked (__stream); if (__c == EOF) break; *__ptr++ = __c; } ((size_t) (size) * (size_t) (n) - __cnt) / (size_t) (size); }) : (((__builtin_constant_p (size) && (size_t) (size) == 0) || (__builtin_constant_p (n) && (size_t) (n) == 0)) ? ((void) (ptr), (void) (stream), (void) (size), (void) (n), (size_t) 0) : fread_unlocked (ptr, size, n, stream))))
# 154 "/usr/include/bits/stdio.h" 3 4
#define fwrite_unlocked(ptr,size,n,stream) (__extension__ ((__builtin_constant_p (size) && __builtin_constant_p (n) && (size_t) (size) * (size_t) (n) <= 8 && (size_t) (size) != 0) ? ({ const char *__ptr = (const char *) (ptr); FILE *__stream = (stream); size_t __cnt; for (__cnt = (size_t) (size) * (size_t) (n); __cnt > 0; --__cnt) if (_IO_putc_unlocked (*__ptr++, __stream) == EOF) break; ((size_t) (size) * (size_t) (n) - __cnt) / (size_t) (size); }) : (((__builtin_constant_p (size) && (size_t) (size) == 0) || (__builtin_constant_p (n) && (size_t) (n) == 0)) ? ((void) (ptr), (void) (stream), (void) (size), (void) (n), (size_t) 0) : fwrite_unlocked (ptr, size, n, stream))))
# 176 "/usr/include/bits/stdio.h" 3 4
#undef __STDIO_INLINE
# 829 "/usr/include/stdio.h" 2 3 4






# 25 "/usr/include/argp.h" 2 3 4
# 1 "/usr/include/ctype.h" 1 3 4
# 25 "/usr/include/ctype.h" 3 4
#define _CTYPE_H 1





# 41 "/usr/include/ctype.h" 3 4
# 1 "/usr/include/endian.h" 1 3 4
# 20 "/usr/include/endian.h" 3 4
#define _ENDIAN_H 1
# 32 "/usr/include/endian.h" 3 4
#define __LITTLE_ENDIAN 1234
#define __BIG_ENDIAN 4321
#define __PDP_ENDIAN 3412


# 1 "/usr/include/bits/endian.h" 1 3 4






#define __BYTE_ORDER __LITTLE_ENDIAN
# 38 "/usr/include/endian.h" 2 3 4




#define __FLOAT_WORD_ORDER __BYTE_ORDER



#define LITTLE_ENDIAN __LITTLE_ENDIAN
#define BIG_ENDIAN __BIG_ENDIAN
#define PDP_ENDIAN __PDP_ENDIAN
#define BYTE_ORDER __BYTE_ORDER



#define __LONG_LONG_PAIR(HI,LO) LO, HI
# 42 "/usr/include/ctype.h" 2 3 4



#define _ISbit(bit) ((bit) < 8 ? ((1 << (bit)) << 8) : ((1 << (bit)) >> 8))


enum
{
  _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
  _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
  _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
  _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
  _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
  _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
  _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
  _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
  _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
  _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
  _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
  _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
};
# 81 "/usr/include/ctype.h" 3 4
extern __const unsigned short int **__ctype_b_loc (void)
     __attribute__ ((__const));
extern __const __int32_t **__ctype_tolower_loc (void)
     __attribute__ ((__const));
extern __const __int32_t **__ctype_toupper_loc (void)
     __attribute__ ((__const));

#define __isctype(c,type) ((*__ctype_b_loc ())[(int) (c)] & (unsigned short int) type)


#define __isascii(c) (((c) & ~0x7f) == 0)
#define __toascii(c) ((c) & 0x7f)

#define __exctype(name) extern int name (int) __THROW







extern int isalnum (int) __attribute__ ((__nothrow__));
extern int isalpha (int) __attribute__ ((__nothrow__));
extern int iscntrl (int) __attribute__ ((__nothrow__));
extern int isdigit (int) __attribute__ ((__nothrow__));
extern int islower (int) __attribute__ ((__nothrow__));
extern int isgraph (int) __attribute__ ((__nothrow__));
extern int isprint (int) __attribute__ ((__nothrow__));
extern int ispunct (int) __attribute__ ((__nothrow__));
extern int isspace (int) __attribute__ ((__nothrow__));
extern int isupper (int) __attribute__ ((__nothrow__));
extern int isxdigit (int) __attribute__ ((__nothrow__));



extern int tolower (int __c) __attribute__ ((__nothrow__));


extern int toupper (int __c) __attribute__ ((__nothrow__));








extern int isblank (int) __attribute__ ((__nothrow__));






extern int isctype (int __c, int __mask) __attribute__ ((__nothrow__));






extern int isascii (int __c) __attribute__ ((__nothrow__));



extern int toascii (int __c) __attribute__ ((__nothrow__));



extern int _toupper (int) __attribute__ ((__nothrow__));
extern int _tolower (int) __attribute__ ((__nothrow__));



#define __tobody(c,f,a,args) (__extension__ ({ int __res; if (sizeof (c) > 1) { if (__builtin_constant_p (c)) { int __c = (c); __res = __c < -128 || __c > 255 ? __c : (a)[__c]; } else __res = f args; } else __res = (a)[(int) (c)]; __res; }))
# 173 "/usr/include/ctype.h" 3 4
#define isalnum(c) __isctype((c), _ISalnum)
#define isalpha(c) __isctype((c), _ISalpha)
#define iscntrl(c) __isctype((c), _IScntrl)
#define isdigit(c) __isctype((c), _ISdigit)
#define islower(c) __isctype((c), _ISlower)
#define isgraph(c) __isctype((c), _ISgraph)
#define isprint(c) __isctype((c), _ISprint)
#define ispunct(c) __isctype((c), _ISpunct)
#define isspace(c) __isctype((c), _ISspace)
#define isupper(c) __isctype((c), _ISupper)
#define isxdigit(c) __isctype((c), _ISxdigit)


#define isblank(c) __isctype((c), _ISblank)



extern __inline int
__attribute__ ((__nothrow__)) tolower (int __c)
{
  return __c >= -128 && __c < 256 ? (*__ctype_tolower_loc ())[__c] : __c;
}

extern __inline int
__attribute__ ((__nothrow__)) toupper (int __c)
{
  return __c >= -128 && __c < 256 ? (*__ctype_toupper_loc ())[__c] : __c;
}



#define tolower(c) __tobody (c, tolower, *__ctype_tolower_loc (), (c))
#define toupper(c) __tobody (c, toupper, *__ctype_toupper_loc (), (c))



#define isascii(c) __isascii (c)
#define toascii(c) __toascii (c)

#define _tolower(c) ((int) (*__ctype_tolower_loc ())[(int) (c)])
#define _toupper(c) ((int) (*__ctype_toupper_loc ())[(int) (c)])
# 233 "/usr/include/ctype.h" 3 4
# 1 "/usr/include/xlocale.h" 1 3 4
# 22 "/usr/include/xlocale.h" 3 4
#define _XLOCALE_H 1





typedef struct __locale_struct
{

  struct locale_data *__locales[13];


  const unsigned short int *__ctype_b;
  const int *__ctype_tolower;
  const int *__ctype_toupper;


  const char *__names[13];
} *__locale_t;
# 234 "/usr/include/ctype.h" 2 3 4



#define __isctype_l(c,type,locale) ((locale)->__ctype_b[(int) (c)] & (unsigned short int) type)


#define __exctype_l(name) extern int name (int, __locale_t) __THROW






extern int isalnum_l (int, __locale_t) __attribute__ ((__nothrow__));
extern int isalpha_l (int, __locale_t) __attribute__ ((__nothrow__));
extern int iscntrl_l (int, __locale_t) __attribute__ ((__nothrow__));
extern int isdigit_l (int, __locale_t) __attribute__ ((__nothrow__));
extern int islower_l (int, __locale_t) __attribute__ ((__nothrow__));
extern int isgraph_l (int, __locale_t) __attribute__ ((__nothrow__));
extern int isprint_l (int, __locale_t) __attribute__ ((__nothrow__));
extern int ispunct_l (int, __locale_t) __attribute__ ((__nothrow__));
extern int isspace_l (int, __locale_t) __attribute__ ((__nothrow__));
extern int isupper_l (int, __locale_t) __attribute__ ((__nothrow__));
extern int isxdigit_l (int, __locale_t) __attribute__ ((__nothrow__));

extern int isblank_l (int, __locale_t) __attribute__ ((__nothrow__));



extern int __tolower_l (int __c, __locale_t __l) __attribute__ ((__nothrow__));
extern int tolower_l (int __c, __locale_t __l) __attribute__ ((__nothrow__));


extern int __toupper_l (int __c, __locale_t __l) __attribute__ ((__nothrow__));
extern int toupper_l (int __c, __locale_t __l) __attribute__ ((__nothrow__));


#define __tolower_l(c,locale) __tobody (c, __tolower_l, (locale)->__ctype_tolower, (c, locale))

#define __toupper_l(c,locale) __tobody (c, __toupper_l, (locale)->__ctype_toupper, (c, locale))

#define tolower_l(c,locale) __tolower_l ((c), (locale))
#define toupper_l(c,locale) __toupper_l ((c), (locale))




#define __isalnum_l(c,l) __isctype_l((c), _ISalnum, (l))
#define __isalpha_l(c,l) __isctype_l((c), _ISalpha, (l))
#define __iscntrl_l(c,l) __isctype_l((c), _IScntrl, (l))
#define __isdigit_l(c,l) __isctype_l((c), _ISdigit, (l))
#define __islower_l(c,l) __isctype_l((c), _ISlower, (l))
#define __isgraph_l(c,l) __isctype_l((c), _ISgraph, (l))
#define __isprint_l(c,l) __isctype_l((c), _ISprint, (l))
#define __ispunct_l(c,l) __isctype_l((c), _ISpunct, (l))
#define __isspace_l(c,l) __isctype_l((c), _ISspace, (l))
#define __isupper_l(c,l) __isctype_l((c), _ISupper, (l))
#define __isxdigit_l(c,l) __isctype_l((c), _ISxdigit, (l))

#define __isblank_l(c,l) __isctype_l((c), _ISblank, (l))


#define __isascii_l(c,l) ((l), __isascii (c))
#define __toascii_l(c,l) ((l), __toascii (c))


#define isalnum_l(c,l) __isalnum_l ((c), (l))
#define isalpha_l(c,l) __isalpha_l ((c), (l))
#define iscntrl_l(c,l) __iscntrl_l ((c), (l))
#define isdigit_l(c,l) __isdigit_l ((c), (l))
#define islower_l(c,l) __islower_l ((c), (l))
#define isgraph_l(c,l) __isgraph_l ((c), (l))
#define isprint_l(c,l) __isprint_l ((c), (l))
#define ispunct_l(c,l) __ispunct_l ((c), (l))
#define isspace_l(c,l) __isspace_l ((c), (l))
#define isupper_l(c,l) __isupper_l ((c), (l))
#define isxdigit_l(c,l) __isxdigit_l ((c), (l))

#define isblank_l(c,l) __isblank_l ((c), (l))


#define isascii_l(c,l) __isascii_l ((c), (l))
#define toascii_l(c,l) __toascii_l ((c), (l))







# 26 "/usr/include/argp.h" 2 3 4
# 1 "/usr/include/getopt.h" 1 3 4
# 24 "/usr/include/getopt.h" 3 4
#define _GETOPT_H 1
# 59 "/usr/include/getopt.h" 3 4
extern char *optarg;
# 73 "/usr/include/getopt.h" 3 4
extern int optind;




extern int opterr;



extern int optopt;
# 106 "/usr/include/getopt.h" 3 4
struct option
{
  const char *name;


  int has_arg;
  int *flag;
  int val;
};



#define no_argument 0
#define required_argument 1
#define optional_argument 2
# 152 "/usr/include/getopt.h" 3 4
extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
       __attribute__ ((__nothrow__));





extern int getopt_long (int ___argc, char *const *___argv,
                        const char *__shortopts,
                        const struct option *__longopts, int *__longind)
       __attribute__ ((__nothrow__));
extern int getopt_long_only (int ___argc, char *const *___argv,
                             const char *__shortopts,
                             const struct option *__longopts, int *__longind)
       __attribute__ ((__nothrow__));
# 27 "/usr/include/argp.h" 2 3 4

#define __need_error_t 
# 1 "/usr/include/errno.h" 1 3 4
# 28 "/usr/include/errno.h" 3 4
#define _ERRNO_H 1







# 1 "/usr/include/bits/errno.h" 1 3 4
# 25 "/usr/include/bits/errno.h" 3 4
# 1 "/usr/include/linux/errno.h" 1 3 4

#define _LINUX_ERRNO_H 

# 1 "/usr/include/asm/errno.h" 1 3 4

#define _I386_ERRNO_H 

# 1 "/usr/include/asm-generic/errno.h" 1 3 4

#define _ASM_GENERIC_ERRNO_H 

# 1 "/usr/include/asm-generic/errno-base.h" 1 3 4

#define _ASM_GENERIC_ERRNO_BASE_H 

#define EPERM 1
#define ENOENT 2
#define ESRCH 3
#define EINTR 4
#define EIO 5
#define ENXIO 6
#define E2BIG 7
#define ENOEXEC 8
#define EBADF 9
#define ECHILD 10
#define EAGAIN 11
#define ENOMEM 12
#define EACCES 13
#define EFAULT 14
#define ENOTBLK 15
#define EBUSY 16
#define EEXIST 17
#define EXDEV 18
#define ENODEV 19
#define ENOTDIR 20
#define EISDIR 21
#define EINVAL 22
#define ENFILE 23
#define EMFILE 24
#define ENOTTY 25
#define ETXTBSY 26
#define EFBIG 27
#define ENOSPC 28
#define ESPIPE 29
#define EROFS 30
#define EMLINK 31
#define EPIPE 32
#define EDOM 33
#define ERANGE 34
# 5 "/usr/include/asm-generic/errno.h" 2 3 4

#define EDEADLK 35
#define ENAMETOOLONG 36
#define ENOLCK 37
#define ENOSYS 38
#define ENOTEMPTY 39
#define ELOOP 40
#define EWOULDBLOCK EAGAIN
#define ENOMSG 42
#define EIDRM 43
#define ECHRNG 44
#define EL2NSYNC 45
#define EL3HLT 46
#define EL3RST 47
#define ELNRNG 48
#define EUNATCH 49
#define ENOCSI 50
#define EL2HLT 51
#define EBADE 52
#define EBADR 53
#define EXFULL 54
#define ENOANO 55
#define EBADRQC 56
#define EBADSLT 57

#define EDEADLOCK EDEADLK

#define EBFONT 59
#define ENOSTR 60
#define ENODATA 61
#define ETIME 62
#define ENOSR 63
#define ENONET 64
#define ENOPKG 65
#define EREMOTE 66
#define ENOLINK 67
#define EADV 68
#define ESRMNT 69
#define ECOMM 70
#define EPROTO 71
#define EMULTIHOP 72
#define EDOTDOT 73
#define EBADMSG 74
#define EOVERFLOW 75
#define ENOTUNIQ 76
#define EBADFD 77
#define EREMCHG 78
#define ELIBACC 79
#define ELIBBAD 80
#define ELIBSCN 81
#define ELIBMAX 82
#define ELIBEXEC 83
#define EILSEQ 84
#define ERESTART 85
#define ESTRPIPE 86
#define EUSERS 87
#define ENOTSOCK 88
#define EDESTADDRREQ 89
#define EMSGSIZE 90
#define EPROTOTYPE 91
#define ENOPROTOOPT 92
#define EPROTONOSUPPORT 93
#define ESOCKTNOSUPPORT 94
#define EOPNOTSUPP 95
#define EPFNOSUPPORT 96
#define EAFNOSUPPORT 97
#define EADDRINUSE 98
#define EADDRNOTAVAIL 99
#define ENETDOWN 100
#define ENETUNREACH 101
#define ENETRESET 102
#define ECONNABORTED 103
#define ECONNRESET 104
#define ENOBUFS 105
#define EISCONN 106
#define ENOTCONN 107
#define ESHUTDOWN 108
#define ETOOMANYREFS 109
#define ETIMEDOUT 110
#define ECONNREFUSED 111
#define EHOSTDOWN 112
#define EHOSTUNREACH 113
#define EALREADY 114
#define EINPROGRESS 115
#define ESTALE 116
#define EUCLEAN 117
#define ENOTNAM 118
#define ENAVAIL 119
#define EISNAM 120
#define EREMOTEIO 121
#define EDQUOT 122

#define ENOMEDIUM 123
#define EMEDIUMTYPE 124
#define ECANCELED 125
#define ENOKEY 126
#define EKEYEXPIRED 127
#define EKEYREVOKED 128
#define EKEYREJECTED 129
# 5 "/usr/include/asm/errno.h" 2 3 4
# 5 "/usr/include/linux/errno.h" 2 3 4
# 26 "/usr/include/bits/errno.h" 2 3 4


#define ENOTSUP EOPNOTSUPP
# 38 "/usr/include/bits/errno.h" 3 4
extern int *__errno_location (void) __attribute__ ((__nothrow__)) __attribute__ ((__const__));



#define errno (*__errno_location ())
# 37 "/usr/include/errno.h" 2 3 4
# 55 "/usr/include/errno.h" 3 4
extern char *program_invocation_name, *program_invocation_short_name;




# 69 "/usr/include/errno.h" 3 4
typedef int error_t;
#define __error_t_defined 1

#undef __need_error_t
# 30 "/usr/include/argp.h" 2 3 4


#define __const const
# 81 "/usr/include/argp.h" 3 4
struct argp_option
{


  const char *name;



  int key;



  const char *arg;


  int flags;





  const char *doc;
# 111 "/usr/include/argp.h" 3 4
  int group;
};


#define OPTION_ARG_OPTIONAL 0x1


#define OPTION_HIDDEN 0x2




#define OPTION_ALIAS 0x4
# 135 "/usr/include/argp.h" 3 4
#define OPTION_DOC 0x8
# 144 "/usr/include/argp.h" 3 4
#define OPTION_NO_USAGE 0x10

struct argp;
struct argp_state;
struct argp_child;


typedef error_t (*argp_parser_t) (int key, char *arg,
                                  struct argp_state *state);






#define ARGP_ERR_UNKNOWN E2BIG
# 187 "/usr/include/argp.h" 3 4
#define ARGP_KEY_ARG 0





#define ARGP_KEY_ARGS 0x1000006

#define ARGP_KEY_END 0x1000001





#define ARGP_KEY_NO_ARGS 0x1000002



#define ARGP_KEY_INIT 0x1000003

#define ARGP_KEY_FINI 0x1000007


#define ARGP_KEY_SUCCESS 0x1000004

#define ARGP_KEY_ERROR 0x1000005







struct argp
{


  const struct argp_option *options;
# 233 "/usr/include/argp.h" 3 4
  argp_parser_t parser;






  const char *args_doc;




  const char *doc;







  const struct argp_child *children;
# 265 "/usr/include/argp.h" 3 4
  char *(*help_filter) (int __key, const char *__text, void *__input);




  const char *argp_domain;
};


#define ARGP_KEY_HELP_PRE_DOC 0x2000001
#define ARGP_KEY_HELP_POST_DOC 0x2000002
#define ARGP_KEY_HELP_HEADER 0x2000003
#define ARGP_KEY_HELP_EXTRA 0x2000004



#define ARGP_KEY_HELP_DUP_ARGS_NOTE 0x2000005
#define ARGP_KEY_HELP_ARGS_DOC 0x2000006



struct argp_child
{

  const struct argp *argp;


  int flags;





  const char *header;







  int group;
};



struct argp_state
{

  const struct argp *root_argp;


  int argc;
  char **argv;


  int next;


  unsigned flags;





  unsigned arg_num;




  int quoted;


  void *input;


  void **child_inputs;


  void *hook;



  char *name;


  FILE *err_stream;
  FILE *out_stream;

  void *pstate;
};
# 364 "/usr/include/argp.h" 3 4
#define ARGP_PARSE_ARGV0 0x01





#define ARGP_NO_ERRS 0x02
# 382 "/usr/include/argp.h" 3 4
#define ARGP_NO_ARGS 0x04



#define ARGP_IN_ORDER 0x08



#define ARGP_NO_HELP 0x10


#define ARGP_NO_EXIT 0x20


#define ARGP_LONG_ONLY 0x40


#define ARGP_SILENT (ARGP_NO_EXIT | ARGP_NO_ERRS | ARGP_NO_HELP)
# 408 "/usr/include/argp.h" 3 4
extern error_t argp_parse (const struct argp *__restrict __argp,
                           int __argc, char **__restrict __argv,
                           unsigned __flags, int *__restrict __arg_index,
                           void *__restrict __input);
extern error_t __argp_parse (const struct argp *__restrict __argp,
                             int __argc, char **__restrict __argv,
                             unsigned __flags, int *__restrict __arg_index,
                             void *__restrict __input);







extern const char *argp_program_version;






extern void (*argp_program_version_hook) (FILE *__restrict __stream,
                                          struct argp_state *__restrict
                                          __state);






extern const char *argp_program_bug_address;




extern error_t argp_err_exit_status;


#define ARGP_HELP_USAGE 0x01
#define ARGP_HELP_SHORT_USAGE 0x02
#define ARGP_HELP_SEE 0x04
#define ARGP_HELP_LONG 0x08
#define ARGP_HELP_PRE_DOC 0x10
#define ARGP_HELP_POST_DOC 0x20
#define ARGP_HELP_DOC (ARGP_HELP_PRE_DOC | ARGP_HELP_POST_DOC)
#define ARGP_HELP_BUG_ADDR 0x40
#define ARGP_HELP_LONG_ONLY 0x80



#define ARGP_HELP_EXIT_ERR 0x100
#define ARGP_HELP_EXIT_OK 0x200



#define ARGP_HELP_STD_ERR (ARGP_HELP_SEE | ARGP_HELP_EXIT_ERR)



#define ARGP_HELP_STD_USAGE (ARGP_HELP_SHORT_USAGE | ARGP_HELP_SEE | ARGP_HELP_EXIT_ERR)


#define ARGP_HELP_STD_HELP (ARGP_HELP_SHORT_USAGE | ARGP_HELP_LONG | ARGP_HELP_EXIT_OK | ARGP_HELP_DOC | ARGP_HELP_BUG_ADDR)





extern void argp_help (const struct argp *__restrict __argp,
                       FILE *__restrict __stream,
                       unsigned __flags, char *__restrict __name);
extern void __argp_help (const struct argp *__restrict __argp,
                         FILE *__restrict __stream, unsigned __flags,
                         char *__name);
# 494 "/usr/include/argp.h" 3 4
extern void argp_state_help (const struct argp_state *__restrict __state,
                             FILE *__restrict __stream,
                             unsigned int __flags);
extern void __argp_state_help (const struct argp_state *__restrict __state,
                               FILE *__restrict __stream,
                               unsigned int __flags);


extern void argp_usage (const struct argp_state *__state);
extern void __argp_usage (const struct argp_state *__state);




extern void argp_error (const struct argp_state *__restrict __state,
                        const char *__restrict __fmt, ...)
     __attribute__ ((__format__ (__printf__, 2, 3)));
extern void __argp_error (const struct argp_state *__restrict __state,
                          const char *__restrict __fmt, ...)
     __attribute__ ((__format__ (__printf__, 2, 3)));
# 523 "/usr/include/argp.h" 3 4
extern void argp_failure (const struct argp_state *__restrict __state,
                          int __status, int __errnum,
                          const char *__restrict __fmt, ...)
     __attribute__ ((__format__ (__printf__, 4, 5)));
extern void __argp_failure (const struct argp_state *__restrict __state,
                            int __status, int __errnum,
                            const char *__restrict __fmt, ...)
     __attribute__ ((__format__ (__printf__, 4, 5)));


extern int _option_is_short (const struct argp_option *__opt) __attribute__ ((__nothrow__));
extern int __option_is_short (const struct argp_option *__opt) __attribute__ ((__nothrow__));



extern int _option_is_end (const struct argp_option *__opt) __attribute__ ((__nothrow__));
extern int __option_is_end (const struct argp_option *__opt) __attribute__ ((__nothrow__));



extern void *_argp_input (const struct argp *__restrict __argp,
                          const struct argp_state *__restrict __state)
     __attribute__ ((__nothrow__));
extern void *__argp_input (const struct argp *__restrict __argp,
                           const struct argp_state *__restrict __state)
     __attribute__ ((__nothrow__));




#define __argp_usage argp_usage
#define __argp_state_help argp_state_help
#define __option_is_short _option_is_short
#define __option_is_end _option_is_end



#define ARGP_EI extern __inline__


extern __inline__ void
__attribute__ ((__nothrow__)) argp_usage (const struct argp_state *__state)
{
  argp_state_help (__state, stderr, (0x02 | 0x04 | 0x100));
}

extern __inline__ int
__attribute__ ((__nothrow__)) _option_is_short (const struct argp_option *__opt)
{
  if (__opt->flags & 0x8)
    return 0;
  else
    {
      int __key = __opt->key;
      return __key > 0 && ((*__ctype_b_loc ())[(int) ((__key))] & (unsigned short int) _ISprint);
    }
}

extern __inline__ int
__attribute__ ((__nothrow__)) _option_is_end (const struct argp_option *__opt)
{
  return !__opt->key && !__opt->name && !__opt->doc && !__opt->group;
}


#undef __argp_usage
#undef __argp_state_help
#undef __option_is_short
#undef __option_is_end
# 20 "readelf.c" 2
# 1 "/usr/include/assert.h" 1 3 4
# 35 "/usr/include/assert.h" 3 4
#define _ASSERT_H 1





#define __ASSERT_VOID_CAST (void)
# 65 "/usr/include/assert.h" 3 4



extern void __assert_fail (const char *__assertion, const char *__file,
                           unsigned int __line, const char *__function)
     __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
                                  unsigned int __line,
                                  const char *__function)
     __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));




#define assert(expr) (__ASSERT_VOID_CAST ((expr) ? 0 : (__assert_fail (__STRING(expr), __FILE__, __LINE__, __ASSERT_FUNCTION), 0)))





#define assert_perror(errnum) (__ASSERT_VOID_CAST (!(errnum) ? 0 : (__assert_perror_fail ((errnum), __FILE__, __LINE__, __ASSERT_FUNCTION), 0)))
# 105 "/usr/include/assert.h" 3 4
#define __ASSERT_FUNCTION __PRETTY_FUNCTION__
# 21 "readelf.c" 2
# 1 "../libdw/dwarf.h" 1
# 15 "../libdw/dwarf.h"
#define _DWARF_H 1


enum
  {
    DW_TAG_array_type = 0x01,
    DW_TAG_class_type = 0x02,
    DW_TAG_entry_point = 0x03,
    DW_TAG_enumeration_type = 0x04,
    DW_TAG_formal_parameter = 0x05,
    DW_TAG_imported_declaration = 0x08,
    DW_TAG_label = 0x0a,
    DW_TAG_lexical_block = 0x0b,
    DW_TAG_member = 0x0d,
    DW_TAG_pointer_type = 0x0f,
    DW_TAG_reference_type = 0x10,
    DW_TAG_compile_unit = 0x11,
    DW_TAG_string_type = 0x12,
    DW_TAG_structure_type = 0x13,
    DW_TAG_subroutine_type = 0x15,
    DW_TAG_typedef = 0x16,
    DW_TAG_union_type = 0x17,
    DW_TAG_unspecified_parameters = 0x18,
    DW_TAG_variant = 0x19,
    DW_TAG_common_block = 0x1a,
    DW_TAG_common_inclusion = 0x1b,
    DW_TAG_inheritance = 0x1c,
    DW_TAG_inlined_subroutine = 0x1d,
    DW_TAG_module = 0x1e,
    DW_TAG_ptr_to_member_type = 0x1f,
    DW_TAG_set_type = 0x20,
    DW_TAG_subrange_type = 0x21,
    DW_TAG_with_stmt = 0x22,
    DW_TAG_access_declaration = 0x23,
    DW_TAG_base_type = 0x24,
    DW_TAG_catch_block = 0x25,
    DW_TAG_const_type = 0x26,
    DW_TAG_constant = 0x27,
    DW_TAG_enumerator = 0x28,
    DW_TAG_file_type = 0x29,
    DW_TAG_friend = 0x2a,
    DW_TAG_namelist = 0x2b,
    DW_TAG_namelist_item = 0x2c,
    DW_TAG_packed_type = 0x2d,
    DW_TAG_subprogram = 0x2e,
    DW_TAG_template_type_param = 0x2f,
    DW_TAG_template_value_param = 0x30,
    DW_TAG_thrown_type = 0x31,
    DW_TAG_try_block = 0x32,
    DW_TAG_variant_part = 0x33,
    DW_TAG_variable = 0x34,
    DW_TAG_volatile_type = 0x35,
    DW_TAG_dwarf_procedure = 0x36,
    DW_TAG_restrict_type = 0x37,
    DW_TAG_interface_type = 0x38,
    DW_TAG_namespace = 0x39,
    DW_TAG_imported_module = 0x3a,
    DW_TAG_unspecified_type = 0x3b,
    DW_TAG_partial_unit = 0x3c,
    DW_TAG_imported_unit = 0x3d,
    DW_TAG_mutable_type = 0x3e,
    DW_TAG_lo_user = 0x4080,
    DW_TAG_MIPS_loop = 0x4081,
    DW_TAG_format_label = 0x4101,
    DW_TAG_function_template = 0x4102,
    DW_TAG_class_template = 0x4103,
    DW_TAG_hi_user = 0xffff
  };



enum
  {
    DW_CHILDREN_no = 0,
    DW_CHILDREN_yes = 1
  };



enum
  {
    DW_AT_sibling = 0x01,
    DW_AT_location = 0x02,
    DW_AT_name = 0x03,
    DW_AT_ordering = 0x09,
    DW_AT_subscr_data = 0x0a,
    DW_AT_byte_size = 0x0b,
    DW_AT_bit_offset = 0x0c,
    DW_AT_bit_size = 0x0d,
    DW_AT_element_list = 0x0f,
    DW_AT_stmt_list = 0x10,
    DW_AT_low_pc = 0x11,
    DW_AT_high_pc = 0x12,
    DW_AT_language = 0x13,
    DW_AT_member = 0x14,
    DW_AT_discr = 0x15,
    DW_AT_discr_value = 0x16,
    DW_AT_visibility = 0x17,
    DW_AT_import = 0x18,
    DW_AT_string_length = 0x19,
    DW_AT_common_reference = 0x1a,
    DW_AT_comp_dir = 0x1b,
    DW_AT_const_value = 0x1c,
    DW_AT_containing_type = 0x1d,
    DW_AT_default_value = 0x1e,
    DW_AT_inline = 0x20,
    DW_AT_is_optional = 0x21,
    DW_AT_lower_bound = 0x22,
    DW_AT_producer = 0x25,
    DW_AT_prototyped = 0x27,
    DW_AT_return_addr = 0x2a,
    DW_AT_start_scope = 0x2c,
    DW_AT_stride_size = 0x2e,
    DW_AT_upper_bound = 0x2f,
    DW_AT_abstract_origin = 0x31,
    DW_AT_accessibility = 0x32,
    DW_AT_address_class = 0x33,
    DW_AT_artificial = 0x34,
    DW_AT_base_types = 0x35,
    DW_AT_calling_convention = 0x36,
    DW_AT_count = 0x37,
    DW_AT_data_member_location = 0x38,
    DW_AT_decl_column = 0x39,
    DW_AT_decl_file = 0x3a,
    DW_AT_decl_line = 0x3b,
    DW_AT_declaration = 0x3c,
    DW_AT_discr_list = 0x3d,
    DW_AT_encoding = 0x3e,
    DW_AT_external = 0x3f,
    DW_AT_frame_base = 0x40,
    DW_AT_friend = 0x41,
    DW_AT_identifier_case = 0x42,
    DW_AT_macro_info = 0x43,
    DW_AT_namelist_items = 0x44,
    DW_AT_priority = 0x45,
    DW_AT_segment = 0x46,
    DW_AT_specification = 0x47,
    DW_AT_static_link = 0x48,
    DW_AT_type = 0x49,
    DW_AT_use_location = 0x4a,
    DW_AT_variable_parameter = 0x4b,
    DW_AT_virtuality = 0x4c,
    DW_AT_vtable_elem_location = 0x4d,
    DW_AT_allocated = 0x4e,
    DW_AT_associated = 0x4f,
    DW_AT_data_location = 0x50,
    DW_AT_stride = 0x51,
    DW_AT_entry_pc = 0x52,
    DW_AT_use_UTF8 = 0x53,
    DW_AT_extension = 0x54,
    DW_AT_ranges = 0x55,
    DW_AT_trampoline = 0x56,
    DW_AT_call_column = 0x57,
    DW_AT_call_file = 0x58,
    DW_AT_call_line = 0x59,
    DW_AT_description = 0x5a,
    DW_AT_lo_user = 0x2000,
    DW_AT_MIPS_fde = 0x2001,
    DW_AT_MIPS_loop_begin = 0x2002,
    DW_AT_MIPS_tail_loop_begin = 0x2003,
    DW_AT_MIPS_epilog_begin = 0x2004,
    DW_AT_MIPS_loop_unroll_factor = 0x2005,
    DW_AT_MIPS_software_pipeline_depth = 0x2006,
    DW_AT_MIPS_linkage_name = 0x2007,
    DW_AT_MIPS_stride = 0x2008,
    DW_AT_MIPS_abstract_name = 0x2009,
    DW_AT_MIPS_clone_origin = 0x200a,
    DW_AT_MIPS_has_inlines = 0x200b,
    DW_AT_MIPS_stride_byte = 0x200c,
    DW_AT_MIPS_stride_elem = 0x200d,
    DW_AT_MIPS_ptr_dopetype = 0x200e,
    DW_AT_MIPS_allocatable_dopetype = 0x200f,
    DW_AT_MIPS_assumed_shape_dopetype = 0x2010,
    DW_AT_MIPS_assumed_size = 0x2011,
    DW_AT_sf_names = 0x2101,
    DW_AT_src_info = 0x2102,
    DW_AT_mac_info = 0x2103,
    DW_AT_src_coords = 0x2104,
    DW_AT_body_begin = 0x2105,
    DW_AT_body_end = 0x2106,
    DW_AT_hi_user = 0x3fff
  };



enum
  {
    DW_FORM_addr = 0x01,
    DW_FORM_block2 = 0x03,
    DW_FORM_block4 = 0x04,
    DW_FORM_data2 = 0x05,
    DW_FORM_data4 = 0x06,
    DW_FORM_data8 = 0x07,
    DW_FORM_string = 0x08,
    DW_FORM_block = 0x09,
    DW_FORM_block1 = 0x0a,
    DW_FORM_data1 = 0x0b,
    DW_FORM_flag = 0x0c,
    DW_FORM_sdata = 0x0d,
    DW_FORM_strp = 0x0e,
    DW_FORM_udata = 0x0f,
    DW_FORM_ref_addr = 0x10,
    DW_FORM_ref1 = 0x11,
    DW_FORM_ref2 = 0x12,
    DW_FORM_ref4 = 0x13,
    DW_FORM_ref8 = 0x14,
    DW_FORM_ref_udata = 0x15,
    DW_FORM_indirect = 0x16
  };



enum
  {
    DW_OP_addr = 0x03,
    DW_OP_deref = 0x06,
    DW_OP_const1u = 0x08,
    DW_OP_const1s = 0x09,
    DW_OP_const2u = 0x0a,
    DW_OP_const2s = 0x0b,
    DW_OP_const4u = 0x0c,
    DW_OP_const4s = 0x0d,
    DW_OP_const8u = 0x0e,
    DW_OP_const8s = 0x0f,
    DW_OP_constu = 0x10,
    DW_OP_consts = 0x11,
    DW_OP_dup = 0x12,
    DW_OP_drop = 0x13,
    DW_OP_over = 0x14,
    DW_OP_pick = 0x15,
    DW_OP_swap = 0x16,
    DW_OP_rot = 0x17,
    DW_OP_xderef = 0x18,
    DW_OP_abs = 0x19,
    DW_OP_and = 0x1a,
    DW_OP_div = 0x1b,
    DW_OP_minus = 0x1c,
    DW_OP_mod = 0x1d,
    DW_OP_mul = 0x1e,
    DW_OP_neg = 0x1f,
    DW_OP_not = 0x20,
    DW_OP_or = 0x21,
    DW_OP_plus = 0x22,
    DW_OP_plus_uconst = 0x23,
    DW_OP_shl = 0x24,
    DW_OP_shr = 0x25,
    DW_OP_shra = 0x26,
    DW_OP_xor = 0x27,
    DW_OP_bra = 0x28,
    DW_OP_eq = 0x29,
    DW_OP_ge = 0x2a,
    DW_OP_gt = 0x2b,
    DW_OP_le = 0x2c,
    DW_OP_lt = 0x2d,
    DW_OP_ne = 0x2e,
    DW_OP_skip = 0x2f,
    DW_OP_lit0 = 0x30,
    DW_OP_lit1 = 0x31,
    DW_OP_lit2 = 0x32,
    DW_OP_lit3 = 0x33,
    DW_OP_lit4 = 0x34,
    DW_OP_lit5 = 0x35,
    DW_OP_lit6 = 0x36,
    DW_OP_lit7 = 0x37,
    DW_OP_lit8 = 0x38,
    DW_OP_lit9 = 0x39,
    DW_OP_lit10 = 0x3a,
    DW_OP_lit11 = 0x3b,
    DW_OP_lit12 = 0x3c,
    DW_OP_lit13 = 0x3d,
    DW_OP_lit14 = 0x3e,
    DW_OP_lit15 = 0x3f,
    DW_OP_lit16 = 0x40,
    DW_OP_lit17 = 0x41,
    DW_OP_lit18 = 0x42,
    DW_OP_lit19 = 0x43,
    DW_OP_lit20 = 0x44,
    DW_OP_lit21 = 0x45,
    DW_OP_lit22 = 0x46,
    DW_OP_lit23 = 0x47,
    DW_OP_lit24 = 0x48,
    DW_OP_lit25 = 0x49,
    DW_OP_lit26 = 0x4a,
    DW_OP_lit27 = 0x4b,
    DW_OP_lit28 = 0x4c,
    DW_OP_lit29 = 0x4d,
    DW_OP_lit30 = 0x4e,
    DW_OP_lit31 = 0x4f,
    DW_OP_reg0 = 0x50,
    DW_OP_reg1 = 0x51,
    DW_OP_reg2 = 0x52,
    DW_OP_reg3 = 0x53,
    DW_OP_reg4 = 0x54,
    DW_OP_reg5 = 0x55,
    DW_OP_reg6 = 0x56,
    DW_OP_reg7 = 0x57,
    DW_OP_reg8 = 0x58,
    DW_OP_reg9 = 0x59,
    DW_OP_reg10 = 0x5a,
    DW_OP_reg11 = 0x5b,
    DW_OP_reg12 = 0x5c,
    DW_OP_reg13 = 0x5d,
    DW_OP_reg14 = 0x5e,
    DW_OP_reg15 = 0x5f,
    DW_OP_reg16 = 0x60,
    DW_OP_reg17 = 0x61,
    DW_OP_reg18 = 0x62,
    DW_OP_reg19 = 0x63,
    DW_OP_reg20 = 0x64,
    DW_OP_reg21 = 0x65,
    DW_OP_reg22 = 0x66,
    DW_OP_reg23 = 0x67,
    DW_OP_reg24 = 0x68,
    DW_OP_reg25 = 0x69,
    DW_OP_reg26 = 0x6a,
    DW_OP_reg27 = 0x6b,
    DW_OP_reg28 = 0x6c,
    DW_OP_reg29 = 0x6d,
    DW_OP_reg30 = 0x6e,
    DW_OP_reg31 = 0x6f,
    DW_OP_breg0 = 0x70,
    DW_OP_breg1 = 0x71,
    DW_OP_breg2 = 0x72,
    DW_OP_breg3 = 0x73,
    DW_OP_breg4 = 0x74,
    DW_OP_breg5 = 0x75,
    DW_OP_breg6 = 0x76,
    DW_OP_breg7 = 0x77,
    DW_OP_breg8 = 0x78,
    DW_OP_breg9 = 0x79,
    DW_OP_breg10 = 0x7a,
    DW_OP_breg11 = 0x7b,
    DW_OP_breg12 = 0x7c,
    DW_OP_breg13 = 0x7d,
    DW_OP_breg14 = 0x7e,
    DW_OP_breg15 = 0x7f,
    DW_OP_breg16 = 0x80,
    DW_OP_breg17 = 0x81,
    DW_OP_breg18 = 0x82,
    DW_OP_breg19 = 0x83,
    DW_OP_breg20 = 0x84,
    DW_OP_breg21 = 0x85,
    DW_OP_breg22 = 0x86,
    DW_OP_breg23 = 0x87,
    DW_OP_breg24 = 0x88,
    DW_OP_breg25 = 0x89,
    DW_OP_breg26 = 0x8a,
    DW_OP_breg27 = 0x8b,
    DW_OP_breg28 = 0x8c,
    DW_OP_breg29 = 0x8d,
    DW_OP_breg30 = 0x8e,
    DW_OP_breg31 = 0x8f,
    DW_OP_regx = 0x90,
    DW_OP_fbreg = 0x91,
    DW_OP_bregx = 0x92,
    DW_OP_piece = 0x93,
    DW_OP_deref_size = 0x94,
    DW_OP_xderef_size = 0x95,
    DW_OP_nop = 0x96,
    DW_OP_push_object_address = 0x97,
    DW_OP_call2 = 0x98,
    DW_OP_call4 = 0x99,
    DW_OP_call_ref = 0x9a,

    DW_OP_lo_user = 0xe0,
    DW_OP_hi_user = 0xff
  };



enum
  {
    DW_ATE_void = 0x0,
    DW_ATE_address = 0x1,
    DW_ATE_boolean = 0x2,
    DW_ATE_complex_float = 0x3,
    DW_ATE_float = 0x4,
    DW_ATE_signed = 0x5,
    DW_ATE_signed_char = 0x6,
    DW_ATE_unsigned = 0x7,
    DW_ATE_unsigned_char = 0x8,
    DW_ATE_imaginary_float = 0x9,

    DW_ATE_lo_user = 0x80,
    DW_ATE_hi_user = 0xff
  };



enum
  {
    DW_ACCESS_public = 1,
    DW_ACCESS_protected = 2,
    DW_ACCESS_private = 3
  };



enum
  {
    DW_VIS_local = 1,
    DW_VIS_exported = 2,
    DW_VIS_qualified = 3
  };



enum
  {
    DW_VIRTUALITY_none = 0,
    DW_VIRTUALITY_virtual = 1,
    DW_VIRTUALITY_pure_virtual = 2
  };



enum
  {
    DW_LANG_C89 = 0x0001,
    DW_LANG_C = 0x0002,
    DW_LANG_Ada83 = 0x0003,
    DW_LANG_C_plus_plus = 0x0004,
    DW_LANG_Cobol74 = 0x0005,
    DW_LANG_Cobol85 = 0x0006,
    DW_LANG_Fortran77 = 0x0007,
    DW_LANG_Fortran90 = 0x0008,
    DW_LANG_Pascal83 = 0x0009,
    DW_LANG_Modula2 = 0x000a,
    DW_LANG_Java = 0x000b,
    DW_LANG_C99 = 0x000c,
    DW_LANG_Ada95 = 0x000d,
    DW_LANG_Fortran95 = 0x000e,
    DW_LANG_PL1 = 0x000f,
    DW_LANG_lo_user = 0x8000,
    DW_LANG_Mips_Assembler = 0x8001,
    DW_LANG_hi_user = 0xffff
  };



enum
  {
    DW_ID_case_sensitive = 0,
    DW_ID_up_case = 1,
    DW_ID_down_case = 2,
    DW_ID_case_insensitive = 3
  };



enum
  {
    DW_CC_normal = 0x1,
    DW_CC_program = 0x2,
    DW_CC_nocall = 0x3,
    DW_CC_lo_user = 0x40,
    DW_CC_hi_user = 0xff
  };



enum
  {
    DW_INL_not_inlined = 0,
    DW_INL_inlined = 1,
    DW_INL_declared_not_inlined = 2,
    DW_INL_declared_inlined = 3
  };



enum
  {
    DW_ORD_row_major = 0,
    DW_ORD_col_major = 1
  };



enum
  {
    DW_DSC_label = 0,
    DW_DSC_range = 1
  };



enum
  {
    DW_LNS_copy = 1,
    DW_LNS_advance_pc = 2,
    DW_LNS_advance_line = 3,
    DW_LNS_set_file = 4,
    DW_LNS_set_column = 5,
    DW_LNS_negate_stmt = 6,
    DW_LNS_set_basic_block = 7,
    DW_LNS_const_add_pc = 8,
    DW_LNS_fixed_advance_pc = 9,
    DW_LNS_set_prologue_end = 10,
    DW_LNS_set_epilogue_begin = 11,
    DW_LNS_set_isa = 12
  };



enum
  {
    DW_LNE_end_sequence = 1,
    DW_LNE_set_address = 2,
    DW_LNE_define_file = 3,

    DW_LNE_lo_user = 128,
    DW_LNE_hi_user = 255
  };



enum
  {
    DW_MACINFO_define = 1,
    DW_MACINFO_undef = 2,
    DW_MACINFO_start_file = 3,
    DW_MACINFO_end_file = 4,
    DW_MACINFO_vendor_ext = 255
  };



enum
  {
    DW_CFA_advance_loc = 0x40,
    DW_CFA_offset = 0x80,
    DW_CFA_restore = 0xc0,
    DW_CFA_extended = 0,

    DW_CFA_nop = 0x00,
    DW_CFA_set_loc = 0x01,
    DW_CFA_advance_loc1 = 0x02,
    DW_CFA_advance_loc2 = 0x03,
    DW_CFA_advance_loc4 = 0x04,
    DW_CFA_offset_extended = 0x05,
    DW_CFA_restore_extended = 0x06,
    DW_CFA_undefined = 0x07,
    DW_CFA_same_value = 0x08,
    DW_CFA_register = 0x09,
    DW_CFA_remember_state = 0x0a,
    DW_CFA_restore_state = 0x0b,
    DW_CFA_def_cfa = 0x0c,
    DW_CFA_def_cfa_register = 0x0d,
    DW_CFA_def_cfa_offset = 0x0e,
    DW_CFA_def_cfa_expression = 0x0f,
    DW_CFA_expression = 0x10,
    DW_CFA_offset_extended_sf = 0x11,
    DW_CFA_def_cfa_sf = 0x12,
    DW_CFA_def_cfa_offset_sf = 0x13,
    DW_CFA_low_user = 0x1c,
    DW_CFA_MIPS_advance_loc8 = 0x1d,
    DW_CFA_GNU_window_save = 0x2d,
    DW_CFA_GNU_args_size = 0x2e,
    DW_CFA_high_user = 0x3f
  };



#define DW_ADDR_none 0
# 22 "readelf.c" 2
# 1 "/usr/include/errno.h" 1 3 4
# 23 "readelf.c" 2
# 1 "/usr/local/include/error.h" 1 3

#define _ERROR_H 1






#define E_WARNING 0
#define E_FATAL 1
#define E_CAUTION 2
#define E_INFORMATION 3
#define E_MEMORY 4

extern void libcgi_error(int error_code, const char *msg, ...);
extern const char *libcgi_error_type[];
# 24 "readelf.c" 2
# 1 "/usr/include/fcntl.h" 1 3 4
# 24 "/usr/include/fcntl.h" 3 4
#define _FCNTL_H 1








# 1 "/usr/include/bits/fcntl.h" 1 3 4
# 26 "/usr/include/bits/fcntl.h" 3 4
# 1 "/usr/include/sys/types.h" 1 3 4
# 25 "/usr/include/sys/types.h" 3 4
#define _SYS_TYPES_H 1









typedef __u_char u_char;
typedef __u_short u_short;
typedef __u_int u_int;
typedef __u_long u_long;
typedef __quad_t quad_t;
typedef __u_quad_t u_quad_t;
typedef __fsid_t fsid_t;
#define __u_char_defined 



typedef __loff_t loff_t;





typedef __ino64_t ino_t;

#define __ino_t_defined 


typedef __ino64_t ino64_t;
#define __ino64_t_defined 



typedef __dev_t dev_t;
#define __dev_t_defined 



typedef __gid_t gid_t;
#define __gid_t_defined 



typedef __mode_t mode_t;
#define __mode_t_defined 



typedef __nlink_t nlink_t;
#define __nlink_t_defined 



typedef __uid_t uid_t;
#define __uid_t_defined 






typedef __off64_t off_t;

#define __off_t_defined 


typedef __off64_t off64_t;
#define __off64_t_defined 



typedef __pid_t pid_t;
#define __pid_t_defined 



typedef __id_t id_t;
#define __id_t_defined 



typedef __ssize_t ssize_t;
#define __ssize_t_defined 




typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;
#define __daddr_t_defined 




typedef __key_t key_t;
#define __key_t_defined 



#define __need_clock_t 

#define __need_time_t 
#define __need_timer_t 
#define __need_clockid_t 
# 1 "/usr/include/time.h" 1 3 4
# 54 "/usr/include/time.h" 3 4
#define __clock_t_defined 1





typedef __clock_t clock_t;






#undef __need_clock_t


#define __time_t_defined 1





typedef __time_t time_t;






#undef __need_time_t



#define __clockid_t_defined 1




typedef __clockid_t clockid_t;






#define __timer_t_defined 1




typedef __timer_t timer_t;


#undef __need_timer_t
# 134 "/usr/include/sys/types.h" 2 3 4



typedef __useconds_t useconds_t;
#define __useconds_t_defined 


typedef __suseconds_t suseconds_t;
#define __suseconds_t_defined 



#define __need_size_t 
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 1 3 4
# 235 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#undef __need_size_t
# 148 "/usr/include/sys/types.h" 2 3 4



typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
# 184 "/usr/include/sys/types.h" 3 4
#define __intN_t(N,MODE) typedef int int ##N ##_t __attribute__ ((__mode__ (MODE)))

#define __u_intN_t(N,MODE) typedef unsigned int u_int ##N ##_t __attribute__ ((__mode__ (MODE)))



#define __int8_t_defined 
typedef int int8_t __attribute__ ((__mode__ (__QI__)));
typedef int int16_t __attribute__ ((__mode__ (__HI__)));
typedef int int32_t __attribute__ ((__mode__ (__SI__)));
typedef int int64_t __attribute__ ((__mode__ (__DI__)));


typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));

typedef int register_t __attribute__ ((__mode__ (__word__)));





#define __BIT_TYPES_DEFINED__ 1







# 1 "/usr/include/sys/select.h" 1 3 4
# 23 "/usr/include/sys/select.h" 3 4
#define _SYS_SELECT_H 1







# 1 "/usr/include/bits/select.h" 1 3 4
# 26 "/usr/include/bits/select.h" 3 4
#define __FD_ZERO(fdsp) do { int __d0, __d1; __asm__ __volatile__ ("cld; rep; stosl" : "=c" (__d0), "=D" (__d1) : "a" (0), "0" (sizeof (fd_set) / sizeof (__fd_mask)), "1" (&__FDS_BITS (fdsp)[0]) : "memory"); } while (0)
# 37 "/usr/include/bits/select.h" 3 4
#define __FD_SET(fd,fdsp) __asm__ __volatile__ ("btsl %1,%0" : "=m" (__FDS_BITS (fdsp)[__FDELT (fd)]) : "r" (((int) (fd)) % __NFDBITS) : "cc","memory")




#define __FD_CLR(fd,fdsp) __asm__ __volatile__ ("btrl %1,%0" : "=m" (__FDS_BITS (fdsp)[__FDELT (fd)]) : "r" (((int) (fd)) % __NFDBITS) : "cc","memory")




#define __FD_ISSET(fd,fdsp) (__extension__ ({register char __result; __asm__ __volatile__ ("btl %1,%2 ; setcb %b0" : "=q" (__result) : "r" (((int) (fd)) % __NFDBITS), "m" (__FDS_BITS (fdsp)[__FDELT (fd)]) : "cc"); __result; }))
# 32 "/usr/include/sys/select.h" 2 3 4


# 1 "/usr/include/bits/sigset.h" 1 3 4
# 21 "/usr/include/bits/sigset.h" 3 4
#define _SIGSET_H_types 1

typedef int __sig_atomic_t;



#define _SIGSET_NWORDS (1024 / (8 * sizeof (unsigned long int)))
typedef struct
  {
    unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
  } __sigset_t;
# 35 "/usr/include/sys/select.h" 2 3 4


#define __sigset_t_defined 
typedef __sigset_t sigset_t;



#define __need_time_t 
#define __need_timespec 
# 1 "/usr/include/time.h" 1 3 4
# 83 "/usr/include/time.h" 3 4
#undef __need_time_t
# 114 "/usr/include/time.h" 3 4
#define __timespec_defined 1



struct timespec
  {
    __time_t tv_sec;
    long int tv_nsec;
  };


#undef __need_timespec
# 45 "/usr/include/sys/select.h" 2 3 4
#define __need_timeval 
# 1 "/usr/include/bits/time.h" 1 3 4
# 62 "/usr/include/bits/time.h" 3 4
#undef __need_timeval

#define _STRUCT_TIMEVAL 1




struct timeval
  {
    __time_t tv_sec;
    __suseconds_t tv_usec;
  };
# 47 "/usr/include/sys/select.h" 2 3 4
# 55 "/usr/include/sys/select.h" 3 4
typedef long int __fd_mask;






#define __NFDBITS (8 * sizeof (__fd_mask))
#define __FDELT(d) ((d) / __NFDBITS)
#define __FDMASK(d) ((__fd_mask) 1 << ((d) % __NFDBITS))


typedef struct
  {



    __fd_mask fds_bits[1024 / (8 * sizeof (__fd_mask))];
#define __FDS_BITS(set) ((set)->fds_bits)




  } fd_set;


#define FD_SETSIZE __FD_SETSIZE



typedef __fd_mask fd_mask;


#define NFDBITS __NFDBITS




#define FD_SET(fd,fdsetp) __FD_SET (fd, fdsetp)
#define FD_CLR(fd,fdsetp) __FD_CLR (fd, fdsetp)
#define FD_ISSET(fd,fdsetp) __FD_ISSET (fd, fdsetp)
#define FD_ZERO(fdsetp) __FD_ZERO (fdsetp)



# 109 "/usr/include/sys/select.h" 3 4
extern int select (int __nfds, fd_set *__restrict __readfds,
                   fd_set *__restrict __writefds,
                   fd_set *__restrict __exceptfds,
                   struct timeval *__restrict __timeout);
# 121 "/usr/include/sys/select.h" 3 4
extern int pselect (int __nfds, fd_set *__restrict __readfds,
                    fd_set *__restrict __writefds,
                    fd_set *__restrict __exceptfds,
                    const struct timespec *__restrict __timeout,
                    const __sigset_t *__restrict __sigmask);



# 217 "/usr/include/sys/types.h" 2 3 4


# 1 "/usr/include/sys/sysmacros.h" 1 3 4
# 21 "/usr/include/sys/sysmacros.h" 3 4
#define _SYS_SYSMACROS_H 1







__extension__
extern __inline unsigned int gnu_dev_major (unsigned long long int __dev)
     __attribute__ ((__nothrow__));
__extension__
extern __inline unsigned int gnu_dev_minor (unsigned long long int __dev)
     __attribute__ ((__nothrow__));
__extension__
extern __inline unsigned long long int gnu_dev_makedev (unsigned int __major,
                                                        unsigned int __minor)
     __attribute__ ((__nothrow__));


__extension__ extern __inline unsigned int
__attribute__ ((__nothrow__)) gnu_dev_major (unsigned long long int __dev)
{
  return ((__dev >> 8) & 0xfff) | ((unsigned int) (__dev >> 32) & ~0xfff);
}

__extension__ extern __inline unsigned int
__attribute__ ((__nothrow__)) gnu_dev_minor (unsigned long long int __dev)
{
  return (__dev & 0xff) | ((unsigned int) (__dev >> 12) & ~0xff);
}

__extension__ extern __inline unsigned long long int
__attribute__ ((__nothrow__)) gnu_dev_makedev (unsigned int __major, unsigned int __minor)
{
  return ((__minor & 0xff) | ((__major & 0xfff) << 8)
          | (((unsigned long long int) (__minor & ~0xff)) << 12)
          | (((unsigned long long int) (__major & ~0xfff)) << 32));
}




#define major(dev) gnu_dev_major (dev)
#define minor(dev) gnu_dev_minor (dev)
#define makedev(maj,min) gnu_dev_makedev (maj, min)
# 220 "/usr/include/sys/types.h" 2 3 4




typedef __blksize_t blksize_t;
#define __blksize_t_defined 
# 244 "/usr/include/sys/types.h" 3 4
typedef __blkcnt64_t blkcnt_t;
#define __blkcnt_t_defined 


typedef __fsblkcnt64_t fsblkcnt_t;
#define __fsblkcnt_t_defined 


typedef __fsfilcnt64_t fsfilcnt_t;
#define __fsfilcnt_t_defined 




typedef __blkcnt64_t blkcnt64_t;
typedef __fsblkcnt64_t fsblkcnt64_t;
typedef __fsfilcnt64_t fsfilcnt64_t;





# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
# 20 "/usr/include/bits/pthreadtypes.h" 3 4
#define _BITS_PTHREADTYPES_H 1

#define __SIZEOF_PTHREAD_ATTR_T 36
#define __SIZEOF_PTHREAD_MUTEX_T 24
#define __SIZEOF_PTHREAD_MUTEXATTR_T 4
#define __SIZEOF_PTHREAD_COND_T 48
#define __SIZEOF_PTHREAD_COND_COMPAT_T 12
#define __SIZEOF_PTHREAD_CONDATTR_T 4
#define __SIZEOF_PTHREAD_RWLOCK_T 32
#define __SIZEOF_PTHREAD_RWLOCKATTR_T 8
#define __SIZEOF_PTHREAD_BARRIER_T 20
#define __SIZEOF_PTHREAD_BARRIERATTR_T 4




typedef unsigned long int pthread_t;


typedef union
{
  char __size[36];
  long int __align;
} pthread_attr_t;




typedef union
{
  struct
  {
    int __lock;
    unsigned int __count;
    int __owner;


    int __kind;
    unsigned int __nusers;
    int __spins;
  } __data;
  char __size[24];
  long int __align;
} pthread_mutex_t;

typedef union
{
  char __size[4];
  long int __align;
} pthread_mutexattr_t;




typedef union
{
  struct
  {
    int __lock;
    unsigned int __futex;
    __extension__ unsigned long long int __total_seq;
    __extension__ unsigned long long int __wakeup_seq;
    __extension__ unsigned long long int __woken_seq;
    void *__mutex;
    unsigned int __nwaiters;
    unsigned int __broadcast_seq;
  } __data;
  char __size[48];
  __extension__ long long int __align;
} pthread_cond_t;

typedef union
{
  char __size[4];
  long int __align;
} pthread_condattr_t;



typedef unsigned int pthread_key_t;



typedef int pthread_once_t;





typedef union
{
  struct
  {
    int __lock;
    unsigned int __nr_readers;
    unsigned int __readers_wakeup;
    unsigned int __writer_wakeup;
    unsigned int __nr_readers_queued;
    unsigned int __nr_writers_queued;


    unsigned int __flags;
    int __writer;
  } __data;
  char __size[32];
  long int __align;
} pthread_rwlock_t;

typedef union
{
  char __size[8];
  long int __align;
} pthread_rwlockattr_t;





typedef volatile int pthread_spinlock_t;




typedef union
{
  char __size[20];
  long int __align;
} pthread_barrier_t;

typedef union
{
  char __size[4];
  int __align;
} pthread_barrierattr_t;




#define __cleanup_fct_attribute __attribute ((regparm (1)))
# 267 "/usr/include/sys/types.h" 2 3 4



# 27 "/usr/include/bits/fcntl.h" 2 3 4



#define O_ACCMODE 0003
#define O_RDONLY 00
#define O_WRONLY 01
#define O_RDWR 02
#define O_CREAT 0100
#define O_EXCL 0200
#define O_NOCTTY 0400
#define O_TRUNC 01000
#define O_APPEND 02000
#define O_NONBLOCK 04000
#define O_NDELAY O_NONBLOCK
#define O_SYNC 010000
#define O_FSYNC O_SYNC
#define O_ASYNC 020000


#define O_DIRECT 040000
#define O_DIRECTORY 0200000
#define O_NOFOLLOW 0400000
#define O_NOATIME 01000000






#define O_DSYNC O_SYNC
#define O_RSYNC O_SYNC



#define O_LARGEFILE 0100000



#define F_DUPFD 0
#define F_GETFD 1
#define F_SETFD 2
#define F_GETFL 3
#define F_SETFL 4





#define F_GETLK F_GETLK64
#define F_SETLK F_SETLK64
#define F_SETLKW F_SETLKW64

#define F_GETLK64 12
#define F_SETLK64 13
#define F_SETLKW64 14


#define F_SETOWN 8
#define F_GETOWN 9



#define F_SETSIG 10
#define F_GETSIG 11



#define F_SETLEASE 1024
#define F_GETLEASE 1025
#define F_NOTIFY 1026



#define FD_CLOEXEC 1


#define F_RDLCK 0
#define F_WRLCK 1
#define F_UNLCK 2


#define F_EXLCK 4
#define F_SHLCK 8



#define LOCK_SH 1
#define LOCK_EX 2
#define LOCK_NB 4

#define LOCK_UN 8



#define LOCK_MAND 32
#define LOCK_READ 64
#define LOCK_WRITE 128
#define LOCK_RW 192




#define DN_ACCESS 0x00000001
#define DN_MODIFY 0x00000002
#define DN_CREATE 0x00000004
#define DN_DELETE 0x00000008
#define DN_RENAME 0x00000010
#define DN_ATTRIB 0x00000020
#define DN_MULTISHOT 0x80000000


struct flock
  {
    short int l_type;
    short int l_whence;




    __off64_t l_start;
    __off64_t l_len;

    __pid_t l_pid;
  };


struct flock64
  {
    short int l_type;
    short int l_whence;
    __off64_t l_start;
    __off64_t l_len;
    __pid_t l_pid;
  };





#define FAPPEND O_APPEND
#define FFSYNC O_FSYNC
#define FASYNC O_ASYNC
#define FNONBLOCK O_NONBLOCK
#define FNDELAY O_NDELAY




#define POSIX_FADV_NORMAL 0
#define POSIX_FADV_RANDOM 1
#define POSIX_FADV_SEQUENTIAL 2
#define POSIX_FADV_WILLNEED 3
#define POSIX_FADV_DONTNEED 4
#define POSIX_FADV_NOREUSE 5





extern ssize_t readahead (int __fd, __off64_t __offset, size_t __count)
    __attribute__ ((__nothrow__));


# 34 "/usr/include/fcntl.h" 2 3 4



# 1 "/usr/include/sys/stat.h" 1 3 4
# 24 "/usr/include/sys/stat.h" 3 4
#define _SYS_STAT_H 1







#define __need_time_t 


#define __need_timespec 

# 1 "/usr/include/time.h" 1 3 4
# 83 "/usr/include/time.h" 3 4
#undef __need_time_t
# 125 "/usr/include/time.h" 3 4
#undef __need_timespec
# 38 "/usr/include/sys/stat.h" 2 3 4
# 103 "/usr/include/sys/stat.h" 3 4


# 1 "/usr/include/bits/stat.h" 1 3 4
# 24 "/usr/include/bits/stat.h" 3 4
#define _STAT_VER_LINUX_OLD 1
#define _STAT_VER_KERNEL 1
#define _STAT_VER_SVR4 2
#define _STAT_VER_LINUX 3
#define _STAT_VER _STAT_VER_LINUX


#define _MKNOD_VER_LINUX 1
#define _MKNOD_VER_SVR4 2
#define _MKNOD_VER _MKNOD_VER_LINUX


struct stat
  {
    __dev_t st_dev;
    unsigned short int __pad1;



    __ino_t __st_ino;

    __mode_t st_mode;
    __nlink_t st_nlink;
    __uid_t st_uid;
    __gid_t st_gid;
    __dev_t st_rdev;
    unsigned short int __pad2;



    __off64_t st_size;

    __blksize_t st_blksize;




    __blkcnt64_t st_blocks;
# 70 "/usr/include/bits/stat.h" 3 4
    struct timespec st_atim;
    struct timespec st_mtim;
    struct timespec st_ctim;
#define st_atime st_atim.tv_sec
#define st_mtime st_mtim.tv_sec
#define st_ctime st_ctim.tv_sec
# 88 "/usr/include/bits/stat.h" 3 4
    __ino64_t st_ino;

  };


struct stat64
  {
    __dev_t st_dev;
    unsigned int __pad1;

    __ino_t __st_ino;
    __mode_t st_mode;
    __nlink_t st_nlink;
    __uid_t st_uid;
    __gid_t st_gid;
    __dev_t st_rdev;
    unsigned int __pad2;
    __off64_t st_size;
    __blksize_t st_blksize;

    __blkcnt64_t st_blocks;







    struct timespec st_atim;
    struct timespec st_mtim;
    struct timespec st_ctim;
# 127 "/usr/include/bits/stat.h" 3 4
    __ino64_t st_ino;
  };



#define _STATBUF_ST_BLKSIZE 
#define _STATBUF_ST_RDEV 

#define _STATBUF_ST_NSEC 



#define __S_IFMT 0170000


#define __S_IFDIR 0040000
#define __S_IFCHR 0020000
#define __S_IFBLK 0060000
#define __S_IFREG 0100000
#define __S_IFIFO 0010000
#define __S_IFLNK 0120000
#define __S_IFSOCK 0140000



#define __S_TYPEISMQ(buf) ((buf)->st_mode - (buf)->st_mode)
#define __S_TYPEISSEM(buf) ((buf)->st_mode - (buf)->st_mode)
#define __S_TYPEISSHM(buf) ((buf)->st_mode - (buf)->st_mode)



#define __S_ISUID 04000
#define __S_ISGID 02000
#define __S_ISVTX 01000
#define __S_IREAD 0400
#define __S_IWRITE 0200
#define __S_IEXEC 0100
# 106 "/usr/include/sys/stat.h" 2 3 4


#define S_IFMT __S_IFMT
#define S_IFDIR __S_IFDIR
#define S_IFCHR __S_IFCHR
#define S_IFBLK __S_IFBLK
#define S_IFREG __S_IFREG

#define S_IFIFO __S_IFIFO


#define S_IFLNK __S_IFLNK



#define S_IFSOCK __S_IFSOCK





#define __S_ISTYPE(mode,mask) (((mode) & __S_IFMT) == (mask))

#define S_ISDIR(mode) __S_ISTYPE((mode), __S_IFDIR)
#define S_ISCHR(mode) __S_ISTYPE((mode), __S_IFCHR)
#define S_ISBLK(mode) __S_ISTYPE((mode), __S_IFBLK)
#define S_ISREG(mode) __S_ISTYPE((mode), __S_IFREG)

#define S_ISFIFO(mode) __S_ISTYPE((mode), __S_IFIFO)


#define S_ISLNK(mode) __S_ISTYPE((mode), __S_IFLNK)
# 146 "/usr/include/sys/stat.h" 3 4
#define S_ISSOCK(mode) __S_ISTYPE((mode), __S_IFSOCK)







#define S_TYPEISMQ(buf) __S_TYPEISMQ(buf)
#define S_TYPEISSEM(buf) __S_TYPEISSEM(buf)
#define S_TYPEISSHM(buf) __S_TYPEISSHM(buf)





#define S_ISUID __S_ISUID
#define S_ISGID __S_ISGID



#define S_ISVTX __S_ISVTX


#define S_IRUSR __S_IREAD
#define S_IWUSR __S_IWRITE
#define S_IXUSR __S_IEXEC

#define S_IRWXU (__S_IREAD|__S_IWRITE|__S_IEXEC)


#define S_IREAD S_IRUSR
#define S_IWRITE S_IWUSR
#define S_IEXEC S_IXUSR


#define S_IRGRP (S_IRUSR >> 3)
#define S_IWGRP (S_IWUSR >> 3)
#define S_IXGRP (S_IXUSR >> 3)

#define S_IRWXG (S_IRWXU >> 3)

#define S_IROTH (S_IRGRP >> 3)
#define S_IWOTH (S_IWGRP >> 3)
#define S_IXOTH (S_IXGRP >> 3)

#define S_IRWXO (S_IRWXG >> 3)




#define ACCESSPERMS (S_IRWXU|S_IRWXG|S_IRWXO)
#define ALLPERMS (S_ISUID|S_ISGID|S_ISVTX|S_IRWXU|S_IRWXG|S_IRWXO)
#define DEFFILEMODE (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH)

#define S_BLKSIZE 512
# 215 "/usr/include/sys/stat.h" 3 4
extern int stat (const char *__restrict __file, struct stat *__restrict __buf) __asm__ ("" "stat64") __attribute__ ((__nothrow__))

     __attribute__ ((__nonnull__ (1, 2)));
extern int fstat (int __fd, struct stat *__buf) __asm__ ("" "fstat64") __attribute__ ((__nothrow__))
     __attribute__ ((__nonnull__ (2)));






extern int stat64 (const char *__restrict __file,
                   struct stat64 *__restrict __buf) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
extern int fstat64 (int __fd, struct stat64 *__buf) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
# 239 "/usr/include/sys/stat.h" 3 4
extern int lstat (const char *__restrict __file, struct stat *__restrict __buf) __asm__ ("" "lstat64") __attribute__ ((__nothrow__))


     __attribute__ ((__nonnull__ (1, 2)));





extern int lstat64 (const char *__restrict __file,
                    struct stat64 *__restrict __buf)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));





extern int chmod (const char *__file, __mode_t __mode)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));





extern int lchmod (const char *__file, __mode_t __mode)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));




extern int fchmod (int __fd, __mode_t __mode) __attribute__ ((__nothrow__));





extern __mode_t umask (__mode_t __mask) __attribute__ ((__nothrow__));




extern __mode_t getumask (void) __attribute__ ((__nothrow__));



extern int mkdir (const char *__path, __mode_t __mode)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));





extern int mknod (const char *__path, __mode_t __mode, __dev_t __dev)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));




extern int mkfifo (const char *__path, __mode_t __mode)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
# 332 "/usr/include/sys/stat.h" 3 4
extern int __fxstat (int __ver, int __fildes, struct stat *__stat_buf) __asm__ ("" "__fxstat64") __attribute__ ((__nothrow__))

     __attribute__ ((__nonnull__ (3)));
extern int __xstat (int __ver, const char *__filename, struct stat *__stat_buf) __asm__ ("" "__xstat64") __attribute__ ((__nothrow__))

     __attribute__ ((__nonnull__ (2, 3)));
extern int __lxstat (int __ver, const char *__filename, struct stat *__stat_buf) __asm__ ("" "__lxstat64") __attribute__ ((__nothrow__))

     __attribute__ ((__nonnull__ (2, 3)));
# 350 "/usr/include/sys/stat.h" 3 4
extern int __fxstat64 (int __ver, int __fildes, struct stat64 *__stat_buf)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3)));
extern int __xstat64 (int __ver, const char *__filename,
                      struct stat64 *__stat_buf) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 3)));
extern int __lxstat64 (int __ver, const char *__filename,
                       struct stat64 *__stat_buf) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 3)));

extern int __xmknod (int __ver, const char *__path, __mode_t __mode,
                     __dev_t *__dev) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 4)));




extern __inline__ int
__attribute__ ((__nothrow__)) stat (const char *__path, struct stat *__statbuf)
{
  return __xstat (3, __path, __statbuf);
}


extern __inline__ int
__attribute__ ((__nothrow__)) lstat (const char *__path, struct stat *__statbuf)
{
  return __lxstat (3, __path, __statbuf);
}


extern __inline__ int
__attribute__ ((__nothrow__)) fstat (int __fd, struct stat *__statbuf)
{
  return __fxstat (3, __fd, __statbuf);
}


extern __inline__ int
__attribute__ ((__nothrow__)) mknod (const char *__path, __mode_t __mode, __dev_t __dev)
{
  return __xmknod (1, __path, __mode, &__dev);
}





extern __inline__ int
__attribute__ ((__nothrow__)) stat64 (const char *__path, struct stat64 *__statbuf)
{
  return __xstat64 (3, __path, __statbuf);
}


extern __inline__ int
__attribute__ ((__nothrow__)) lstat64 (const char *__path, struct stat64 *__statbuf)
{
  return __lxstat64 (3, __path, __statbuf);
}


extern __inline__ int
__attribute__ ((__nothrow__)) fstat64 (int __fd, struct stat64 *__statbuf)
{
  return __fxstat64 (3, __fd, __statbuf);
}





# 38 "/usr/include/fcntl.h" 2 3 4






#define R_OK 4
#define W_OK 2
#define X_OK 1
#define F_OK 0





#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2







extern int fcntl (int __fd, int __cmd, ...);
# 75 "/usr/include/fcntl.h" 3 4
extern int open (const char *__file, int __oflag, ...) __asm__ ("" "open64")
     __attribute__ ((__nonnull__ (1)));





extern int open64 (const char *__file, int __oflag, ...) __attribute__ ((__nonnull__ (1)));
# 94 "/usr/include/fcntl.h" 3 4
extern int creat (const char *__file, __mode_t __mode) __asm__ ("" "creat64") __attribute__ ((__nonnull__ (1)));






extern int creat64 (const char *__file, __mode_t __mode) __attribute__ ((__nonnull__ (1)));
# 114 "/usr/include/fcntl.h" 3 4
#define F_ULOCK 0
#define F_LOCK 1
#define F_TLOCK 2
#define F_TEST 3





extern int lockf (int __fd, int __cmd, __off64_t __len) __asm__ ("" "lockf64");





extern int lockf64 (int __fd, int __cmd, __off64_t __len);
# 141 "/usr/include/fcntl.h" 3 4
extern int posix_fadvise (int __fd, __off64_t __offset, __off64_t __len, int __advise) __asm__ ("" "posix_fadvise64") __attribute__ ((__nothrow__));







extern int posix_fadvise64 (int __fd, __off64_t __offset, __off64_t __len,
                            int __advise) __attribute__ ((__nothrow__));
# 162 "/usr/include/fcntl.h" 3 4
extern int posix_fallocate (int __fd, __off64_t __offset, __off64_t __len) __asm__ ("" "posix_fallocate64");







extern int posix_fallocate64 (int __fd, __off64_t __offset, __off64_t __len);




# 25 "readelf.c" 2
# 1 "../libelf/gelf.h" 1
# 18 "../libelf/gelf.h"
#define _GELF_H 1

# 1 "../libelf/libelf.h" 1
# 18 "../libelf/libelf.h"
#define _LIBELF_H 1




# 1 "../libelf/elf.h" 1
# 21 "../libelf/elf.h"
#define _ELF_H 1







# 1 "/usr/include/stdint.h" 1 3 4
# 24 "/usr/include/stdint.h" 3 4
#define _STDINT_H 1



# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 19 "/usr/include/bits/wordsize.h" 3 4
#define __WORDSIZE 32
# 29 "/usr/include/stdint.h" 2 3 4
# 49 "/usr/include/stdint.h" 3 4
typedef unsigned char uint8_t;
typedef unsigned short int uint16_t;

typedef unsigned int uint32_t;
#define __uint32_t_defined 




__extension__
typedef unsigned long long int uint64_t;






typedef signed char int_least8_t;
typedef short int int_least16_t;
typedef int int_least32_t;



__extension__
typedef long long int int_least64_t;



typedef unsigned char uint_least8_t;
typedef unsigned short int uint_least16_t;
typedef unsigned int uint_least32_t;



__extension__
typedef unsigned long long int uint_least64_t;






typedef signed char int_fast8_t;





typedef int int_fast16_t;
typedef int int_fast32_t;
__extension__
typedef long long int int_fast64_t;



typedef unsigned char uint_fast8_t;





typedef unsigned int uint_fast16_t;
typedef unsigned int uint_fast32_t;
__extension__
typedef unsigned long long int uint_fast64_t;
# 126 "/usr/include/stdint.h" 3 4
typedef int intptr_t;
#define __intptr_t_defined 

typedef unsigned int uintptr_t;
# 138 "/usr/include/stdint.h" 3 4
__extension__
typedef long long int intmax_t;
__extension__
typedef unsigned long long int uintmax_t;
# 153 "/usr/include/stdint.h" 3 4
#define __INT64_C(c) c ## LL
#define __UINT64_C(c) c ## ULL





#define INT8_MIN (-128)
#define INT16_MIN (-32767-1)
#define INT32_MIN (-2147483647-1)
#define INT64_MIN (-__INT64_C(9223372036854775807)-1)

#define INT8_MAX (127)
#define INT16_MAX (32767)
#define INT32_MAX (2147483647)
#define INT64_MAX (__INT64_C(9223372036854775807))


#define UINT8_MAX (255)
#define UINT16_MAX (65535)
#define UINT32_MAX (4294967295U)
#define UINT64_MAX (__UINT64_C(18446744073709551615))



#define INT_LEAST8_MIN (-128)
#define INT_LEAST16_MIN (-32767-1)
#define INT_LEAST32_MIN (-2147483647-1)
#define INT_LEAST64_MIN (-__INT64_C(9223372036854775807)-1)

#define INT_LEAST8_MAX (127)
#define INT_LEAST16_MAX (32767)
#define INT_LEAST32_MAX (2147483647)
#define INT_LEAST64_MAX (__INT64_C(9223372036854775807))


#define UINT_LEAST8_MAX (255)
#define UINT_LEAST16_MAX (65535)
#define UINT_LEAST32_MAX (4294967295U)
#define UINT_LEAST64_MAX (__UINT64_C(18446744073709551615))



#define INT_FAST8_MIN (-128)




#define INT_FAST16_MIN (-2147483647-1)
#define INT_FAST32_MIN (-2147483647-1)

#define INT_FAST64_MIN (-__INT64_C(9223372036854775807)-1)

#define INT_FAST8_MAX (127)




#define INT_FAST16_MAX (2147483647)
#define INT_FAST32_MAX (2147483647)

#define INT_FAST64_MAX (__INT64_C(9223372036854775807))


#define UINT_FAST8_MAX (255)




#define UINT_FAST16_MAX (4294967295U)
#define UINT_FAST32_MAX (4294967295U)

#define UINT_FAST64_MAX (__UINT64_C(18446744073709551615))
# 234 "/usr/include/stdint.h" 3 4
#define INTPTR_MIN (-2147483647-1)
#define INTPTR_MAX (2147483647)
#define UINTPTR_MAX (4294967295U)




#define INTMAX_MIN (-__INT64_C(9223372036854775807)-1)

#define INTMAX_MAX (__INT64_C(9223372036854775807))


#define UINTMAX_MAX (__UINT64_C(18446744073709551615))
# 256 "/usr/include/stdint.h" 3 4
#define PTRDIFF_MIN (-2147483647-1)
#define PTRDIFF_MAX (2147483647)



#define SIG_ATOMIC_MIN (-2147483647-1)
#define SIG_ATOMIC_MAX (2147483647)





#define SIZE_MAX (4294967295U)





#define WCHAR_MIN __WCHAR_MIN
#define WCHAR_MAX __WCHAR_MAX



#define WINT_MIN (0u)
#define WINT_MAX (4294967295u)
# 290 "/usr/include/stdint.h" 3 4
#define INT8_C(c) c
#define INT16_C(c) c
#define INT32_C(c) c



#define INT64_C(c) c ## LL



#define UINT8_C(c) c ## U
#define UINT16_C(c) c ## U
#define UINT32_C(c) c ## U



#define UINT64_C(c) c ## ULL







#define INTMAX_C(c) c ## LL
#define UINTMAX_C(c) c ## ULL
# 30 "../libelf/elf.h" 2


typedef uint16_t Elf32_Half;
typedef uint16_t Elf64_Half;


typedef uint32_t Elf32_Word;
typedef int32_t Elf32_Sword;
typedef uint32_t Elf64_Word;
typedef int32_t Elf64_Sword;


typedef uint64_t Elf32_Xword;
typedef int64_t Elf32_Sxword;
typedef uint64_t Elf64_Xword;
typedef int64_t Elf64_Sxword;


typedef uint32_t Elf32_Addr;
typedef uint64_t Elf64_Addr;


typedef uint32_t Elf32_Off;
typedef uint64_t Elf64_Off;


typedef uint16_t Elf32_Section;
typedef uint16_t Elf64_Section;


typedef Elf32_Half Elf32_Versym;
typedef Elf64_Half Elf64_Versym;




#define EI_NIDENT (16)

typedef struct
{
  unsigned char e_ident[(16)];
  Elf32_Half e_type;
  Elf32_Half e_machine;
  Elf32_Word e_version;
  Elf32_Addr e_entry;
  Elf32_Off e_phoff;
  Elf32_Off e_shoff;
  Elf32_Word e_flags;
  Elf32_Half e_ehsize;
  Elf32_Half e_phentsize;
  Elf32_Half e_phnum;
  Elf32_Half e_shentsize;
  Elf32_Half e_shnum;
  Elf32_Half e_shstrndx;
} Elf32_Ehdr;

typedef struct
{
  unsigned char e_ident[(16)];
  Elf64_Half e_type;
  Elf64_Half e_machine;
  Elf64_Word e_version;
  Elf64_Addr e_entry;
  Elf64_Off e_phoff;
  Elf64_Off e_shoff;
  Elf64_Word e_flags;
  Elf64_Half e_ehsize;
  Elf64_Half e_phentsize;
  Elf64_Half e_phnum;
  Elf64_Half e_shentsize;
  Elf64_Half e_shnum;
  Elf64_Half e_shstrndx;
} Elf64_Ehdr;





#define EI_MAG0 0
#define ELFMAG0 0x7f

#define EI_MAG1 1
#define ELFMAG1 'E'

#define EI_MAG2 2
#define ELFMAG2 'L'

#define EI_MAG3 3
#define ELFMAG3 'F'


#define ELFMAG "\177ELF"
#define SELFMAG 4

#define EI_CLASS 4
#define ELFCLASSNONE 0
#define ELFCLASS32 1
#define ELFCLASS64 2
#define ELFCLASSNUM 3

#define EI_DATA 5
#define ELFDATANONE 0
#define ELFDATA2LSB 1
#define ELFDATA2MSB 2
#define ELFDATANUM 3

#define EI_VERSION 6


#define EI_OSABI 7
#define ELFOSABI_NONE 0
#define ELFOSABI_SYSV 0
#define ELFOSABI_HPUX 1
#define ELFOSABI_NETBSD 2
#define ELFOSABI_LINUX 3
#define ELFOSABI_SOLARIS 6
#define ELFOSABI_AIX 7
#define ELFOSABI_IRIX 8
#define ELFOSABI_FREEBSD 9
#define ELFOSABI_TRU64 10
#define ELFOSABI_MODESTO 11
#define ELFOSABI_OPENBSD 12
#define ELFOSABI_ARM 97
#define ELFOSABI_STANDALONE 255

#define EI_ABIVERSION 8

#define EI_PAD 9



#define ET_NONE 0
#define ET_REL 1
#define ET_EXEC 2
#define ET_DYN 3
#define ET_CORE 4
#define ET_NUM 5
#define ET_LOOS 0xfe00
#define ET_HIOS 0xfeff
#define ET_LOPROC 0xff00
#define ET_HIPROC 0xffff



#define EM_NONE 0
#define EM_M32 1
#define EM_SPARC 2
#define EM_386 3
#define EM_68K 4
#define EM_88K 5
#define EM_860 7
#define EM_MIPS 8
#define EM_S370 9
#define EM_MIPS_RS3_LE 10

#define EM_PARISC 15
#define EM_VPP500 17
#define EM_SPARC32PLUS 18
#define EM_960 19
#define EM_PPC 20
#define EM_PPC64 21
#define EM_S390 22

#define EM_V800 36
#define EM_FR20 37
#define EM_RH32 38
#define EM_RCE 39
#define EM_ARM 40
#define EM_FAKE_ALPHA 41
#define EM_SH 42
#define EM_SPARCV9 43
#define EM_TRICORE 44
#define EM_ARC 45
#define EM_H8_300 46
#define EM_H8_300H 47
#define EM_H8S 48
#define EM_H8_500 49
#define EM_IA_64 50
#define EM_MIPS_X 51
#define EM_COLDFIRE 52
#define EM_68HC12 53
#define EM_MMA 54
#define EM_PCP 55
#define EM_NCPU 56
#define EM_NDR1 57
#define EM_STARCORE 58
#define EM_ME16 59
#define EM_ST100 60
#define EM_TINYJ 61
#define EM_X86_64 62
#define EM_PDSP 63

#define EM_FX66 66
#define EM_ST9PLUS 67
#define EM_ST7 68
#define EM_68HC16 69
#define EM_68HC11 70
#define EM_68HC08 71
#define EM_68HC05 72
#define EM_SVX 73
#define EM_ST19 74
#define EM_VAX 75
#define EM_CRIS 76
#define EM_JAVELIN 77
#define EM_FIREPATH 78
#define EM_ZSP 79
#define EM_MMIX 80
#define EM_HUANY 81
#define EM_PRISM 82
#define EM_AVR 83
#define EM_FR30 84
#define EM_D10V 85
#define EM_D30V 86
#define EM_V850 87
#define EM_M32R 88
#define EM_MN10300 89
#define EM_MN10200 90
#define EM_PJ 91
#define EM_OPENRISC 92
#define EM_ARC_A5 93
#define EM_XTENSA 94
#define EM_NUM 95





#define EM_ALPHA 0x9026



#define EV_NONE 0
#define EV_CURRENT 1
#define EV_NUM 2



typedef struct
{
  Elf32_Word sh_name;
  Elf32_Word sh_type;
  Elf32_Word sh_flags;
  Elf32_Addr sh_addr;
  Elf32_Off sh_offset;
  Elf32_Word sh_size;
  Elf32_Word sh_link;
  Elf32_Word sh_info;
  Elf32_Word sh_addralign;
  Elf32_Word sh_entsize;
} Elf32_Shdr;

typedef struct
{
  Elf64_Word sh_name;
  Elf64_Word sh_type;
  Elf64_Xword sh_flags;
  Elf64_Addr sh_addr;
  Elf64_Off sh_offset;
  Elf64_Xword sh_size;
  Elf64_Word sh_link;
  Elf64_Word sh_info;
  Elf64_Xword sh_addralign;
  Elf64_Xword sh_entsize;
} Elf64_Shdr;



#define SHN_UNDEF 0
#define SHN_LORESERVE 0xff00
#define SHN_LOPROC 0xff00
#define SHN_BEFORE 0xff00

#define SHN_AFTER 0xff01

#define SHN_HIPROC 0xff1f
#define SHN_LOOS 0xff20
#define SHN_HIOS 0xff3f
#define SHN_ABS 0xfff1
#define SHN_COMMON 0xfff2
#define SHN_XINDEX 0xffff
#define SHN_HIRESERVE 0xffff



#define SHT_NULL 0
#define SHT_PROGBITS 1
#define SHT_SYMTAB 2
#define SHT_STRTAB 3
#define SHT_RELA 4
#define SHT_HASH 5
#define SHT_DYNAMIC 6
#define SHT_NOTE 7
#define SHT_NOBITS 8
#define SHT_REL 9
#define SHT_SHLIB 10
#define SHT_DYNSYM 11
#define SHT_INIT_ARRAY 14
#define SHT_FINI_ARRAY 15
#define SHT_PREINIT_ARRAY 16
#define SHT_GROUP 17
#define SHT_SYMTAB_SHNDX 18
#define SHT_NUM 19
#define SHT_LOOS 0x60000000
#define SHT_GNU_LIBLIST 0x6ffffff7
#define SHT_CHECKSUM 0x6ffffff8
#define SHT_LOSUNW 0x6ffffffa
#define SHT_SUNW_move 0x6ffffffa
#define SHT_SUNW_COMDAT 0x6ffffffb
#define SHT_SUNW_syminfo 0x6ffffffc
#define SHT_GNU_verdef 0x6ffffffd
#define SHT_GNU_verneed 0x6ffffffe
#define SHT_GNU_versym 0x6fffffff
#define SHT_HISUNW 0x6fffffff
#define SHT_HIOS 0x6fffffff
#define SHT_LOPROC 0x70000000
#define SHT_HIPROC 0x7fffffff
#define SHT_LOUSER 0x80000000
#define SHT_HIUSER 0x8fffffff



#define SHF_WRITE (1 << 0)
#define SHF_ALLOC (1 << 1)
#define SHF_EXECINSTR (1 << 2)
#define SHF_MERGE (1 << 4)
#define SHF_STRINGS (1 << 5)
#define SHF_INFO_LINK (1 << 6)
#define SHF_LINK_ORDER (1 << 7)
#define SHF_OS_NONCONFORMING (1 << 8)

#define SHF_GROUP (1 << 9)
#define SHF_TLS (1 << 10)
#define SHF_MASKOS 0x0ff00000
#define SHF_MASKPROC 0xf0000000
#define SHF_ORDERED (1 << 30)

#define SHF_EXCLUDE (1 << 31)



#define GRP_COMDAT 0x1



typedef struct
{
  Elf32_Word st_name;
  Elf32_Addr st_value;
  Elf32_Word st_size;
  unsigned char st_info;
  unsigned char st_other;
  Elf32_Section st_shndx;
} Elf32_Sym;

typedef struct
{
  Elf64_Word st_name;
  unsigned char st_info;
  unsigned char st_other;
  Elf64_Section st_shndx;
  Elf64_Addr st_value;
  Elf64_Xword st_size;
} Elf64_Sym;




typedef struct
{
  Elf32_Half si_boundto;
  Elf32_Half si_flags;
} Elf32_Syminfo;

typedef struct
{
  Elf64_Half si_boundto;
  Elf64_Half si_flags;
} Elf64_Syminfo;


#define SYMINFO_BT_SELF 0xffff
#define SYMINFO_BT_PARENT 0xfffe
#define SYMINFO_BT_LOWRESERVE 0xff00


#define SYMINFO_FLG_DIRECT 0x0001
#define SYMINFO_FLG_PASSTHRU 0x0002
#define SYMINFO_FLG_COPY 0x0004
#define SYMINFO_FLG_LAZYLOAD 0x0008


#define SYMINFO_NONE 0
#define SYMINFO_CURRENT 1
#define SYMINFO_NUM 2




#define ELF32_ST_BIND(val) (((unsigned char) (val)) >> 4)
#define ELF32_ST_TYPE(val) ((val) & 0xf)
#define ELF32_ST_INFO(bind,type) (((bind) << 4) + ((type) & 0xf))


#define ELF64_ST_BIND(val) ELF32_ST_BIND (val)
#define ELF64_ST_TYPE(val) ELF32_ST_TYPE (val)
#define ELF64_ST_INFO(bind,type) ELF32_ST_INFO ((bind), (type))



#define STB_LOCAL 0
#define STB_GLOBAL 1
#define STB_WEAK 2
#define STB_NUM 3
#define STB_LOOS 10
#define STB_HIOS 12
#define STB_LOPROC 13
#define STB_HIPROC 15



#define STT_NOTYPE 0
#define STT_OBJECT 1
#define STT_FUNC 2
#define STT_SECTION 3
#define STT_FILE 4
#define STT_COMMON 5
#define STT_TLS 6
#define STT_NUM 7
#define STT_LOOS 10
#define STT_HIOS 12
#define STT_LOPROC 13
#define STT_HIPROC 15






#define STN_UNDEF 0




#define ELF32_ST_VISIBILITY(o) ((o) & 0x03)


#define ELF64_ST_VISIBILITY(o) ELF32_ST_VISIBILITY (o)


#define STV_DEFAULT 0
#define STV_INTERNAL 1
#define STV_HIDDEN 2
#define STV_PROTECTED 3




typedef struct
{
  Elf32_Addr r_offset;
  Elf32_Word r_info;
} Elf32_Rel;






typedef struct
{
  Elf64_Addr r_offset;
  Elf64_Xword r_info;
} Elf64_Rel;



typedef struct
{
  Elf32_Addr r_offset;
  Elf32_Word r_info;
  Elf32_Sword r_addend;
} Elf32_Rela;

typedef struct
{
  Elf64_Addr r_offset;
  Elf64_Xword r_info;
  Elf64_Sxword r_addend;
} Elf64_Rela;



#define ELF32_R_SYM(val) ((val) >> 8)
#define ELF32_R_TYPE(val) ((val) & 0xff)
#define ELF32_R_INFO(sym,type) (((sym) << 8) + ((type) & 0xff))

#define ELF64_R_SYM(i) ((i) >> 32)
#define ELF64_R_TYPE(i) ((i) & 0xffffffff)
#define ELF64_R_INFO(sym,type) ((((Elf64_Xword) (sym)) << 32) + (type))



typedef struct
{
  Elf32_Word p_type;
  Elf32_Off p_offset;
  Elf32_Addr p_vaddr;
  Elf32_Addr p_paddr;
  Elf32_Word p_filesz;
  Elf32_Word p_memsz;
  Elf32_Word p_flags;
  Elf32_Word p_align;
} Elf32_Phdr;

typedef struct
{
  Elf64_Word p_type;
  Elf64_Word p_flags;
  Elf64_Off p_offset;
  Elf64_Addr p_vaddr;
  Elf64_Addr p_paddr;
  Elf64_Xword p_filesz;
  Elf64_Xword p_memsz;
  Elf64_Xword p_align;
} Elf64_Phdr;



#define PT_NULL 0
#define PT_LOAD 1
#define PT_DYNAMIC 2
#define PT_INTERP 3
#define PT_NOTE 4
#define PT_SHLIB 5
#define PT_PHDR 6
#define PT_TLS 7
#define PT_NUM 8
#define PT_LOOS 0x60000000
#define PT_GNU_EH_FRAME 0x6474e550
#define PT_GNU_STACK 0x6474e551
#define PT_GNU_RELRO 0x6474e552
#define PT_PAX_FLAGS 0x65041580
#define PT_LOSUNW 0x6ffffffa
#define PT_SUNWBSS 0x6ffffffa
#define PT_SUNWSTACK 0x6ffffffb
#define PT_HISUNW 0x6fffffff
#define PT_HIOS 0x6fffffff
#define PT_LOPROC 0x70000000
#define PT_HIPROC 0x7fffffff



#define PF_X (1 << 0)
#define PF_W (1 << 1)
#define PF_R (1 << 2)
#define PF_MASKOS 0x0ff00000
#define PF_MASKPROC 0xf0000000



#define NT_PRSTATUS 1
#define NT_FPREGSET 2
#define NT_PRPSINFO 3
#define NT_PRXREG 4
#define NT_TASKSTRUCT 4
#define NT_PLATFORM 5
#define NT_AUXV 6
#define NT_GWINDOWS 7
#define NT_ASRS 8
#define NT_PSTATUS 10
#define NT_PSINFO 13
#define NT_PRCRED 14
#define NT_UTSNAME 15
#define NT_LWPSTATUS 16
#define NT_LWPSINFO 17
#define NT_PRFPXREG 20



#define NT_VERSION 1




typedef struct
{
  Elf32_Sword d_tag;
  union
    {
      Elf32_Word d_val;
      Elf32_Addr d_ptr;
    } d_un;
} Elf32_Dyn;

typedef struct
{
  Elf64_Sxword d_tag;
  union
    {
      Elf64_Xword d_val;
      Elf64_Addr d_ptr;
    } d_un;
} Elf64_Dyn;



#define DT_NULL 0
#define DT_NEEDED 1
#define DT_PLTRELSZ 2
#define DT_PLTGOT 3
#define DT_HASH 4
#define DT_STRTAB 5
#define DT_SYMTAB 6
#define DT_RELA 7
#define DT_RELASZ 8
#define DT_RELAENT 9
#define DT_STRSZ 10
#define DT_SYMENT 11
#define DT_INIT 12
#define DT_FINI 13
#define DT_SONAME 14
#define DT_RPATH 15
#define DT_SYMBOLIC 16
#define DT_REL 17
#define DT_RELSZ 18
#define DT_RELENT 19
#define DT_PLTREL 20
#define DT_DEBUG 21
#define DT_TEXTREL 22
#define DT_JMPREL 23
#define DT_BIND_NOW 24
#define DT_INIT_ARRAY 25
#define DT_FINI_ARRAY 26
#define DT_INIT_ARRAYSZ 27
#define DT_FINI_ARRAYSZ 28
#define DT_RUNPATH 29
#define DT_FLAGS 30
#define DT_ENCODING 32
#define DT_PREINIT_ARRAY 32
#define DT_PREINIT_ARRAYSZ 33
#define DT_NUM 34
#define DT_LOOS 0x6000000d
#define DT_HIOS 0x6ffff000
#define DT_LOPROC 0x70000000
#define DT_HIPROC 0x7fffffff
#define DT_PROCNUM DT_MIPS_NUM




#define DT_VALRNGLO 0x6ffffd00
#define DT_GNU_PRELINKED 0x6ffffdf5
#define DT_GNU_CONFLICTSZ 0x6ffffdf6
#define DT_GNU_LIBLISTSZ 0x6ffffdf7
#define DT_CHECKSUM 0x6ffffdf8
#define DT_PLTPADSZ 0x6ffffdf9
#define DT_MOVEENT 0x6ffffdfa
#define DT_MOVESZ 0x6ffffdfb
#define DT_FEATURE_1 0x6ffffdfc
#define DT_POSFLAG_1 0x6ffffdfd

#define DT_SYMINSZ 0x6ffffdfe
#define DT_SYMINENT 0x6ffffdff
#define DT_VALRNGHI 0x6ffffdff
#define DT_VALTAGIDX(tag) (DT_VALRNGHI - (tag))
#define DT_VALNUM 12






#define DT_ADDRRNGLO 0x6ffffe00
#define DT_GNU_CONFLICT 0x6ffffef8
#define DT_GNU_LIBLIST 0x6ffffef9
#define DT_CONFIG 0x6ffffefa
#define DT_DEPAUDIT 0x6ffffefb
#define DT_AUDIT 0x6ffffefc
#define DT_PLTPAD 0x6ffffefd
#define DT_MOVETAB 0x6ffffefe
#define DT_SYMINFO 0x6ffffeff
#define DT_ADDRRNGHI 0x6ffffeff
#define DT_ADDRTAGIDX(tag) (DT_ADDRRNGHI - (tag))
#define DT_ADDRNUM 10



#define DT_VERSYM 0x6ffffff0

#define DT_RELACOUNT 0x6ffffff9
#define DT_RELCOUNT 0x6ffffffa


#define DT_FLAGS_1 0x6ffffffb
#define DT_VERDEF 0x6ffffffc

#define DT_VERDEFNUM 0x6ffffffd
#define DT_VERNEED 0x6ffffffe

#define DT_VERNEEDNUM 0x6fffffff
#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag))
#define DT_VERSIONTAGNUM 16



#define DT_AUXILIARY 0x7ffffffd
#define DT_FILTER 0x7fffffff
#define DT_EXTRATAGIDX(tag) ((Elf32_Word)-((Elf32_Sword) (tag) <<1>>1)-1)
#define DT_EXTRANUM 3


#define DF_ORIGIN 0x00000001
#define DF_SYMBOLIC 0x00000002
#define DF_TEXTREL 0x00000004
#define DF_BIND_NOW 0x00000008
#define DF_STATIC_TLS 0x00000010



#define DF_1_NOW 0x00000001
#define DF_1_GLOBAL 0x00000002
#define DF_1_GROUP 0x00000004
#define DF_1_NODELETE 0x00000008
#define DF_1_LOADFLTR 0x00000010
#define DF_1_INITFIRST 0x00000020
#define DF_1_NOOPEN 0x00000040
#define DF_1_ORIGIN 0x00000080
#define DF_1_DIRECT 0x00000100
#define DF_1_TRANS 0x00000200
#define DF_1_INTERPOSE 0x00000400
#define DF_1_NODEFLIB 0x00000800
#define DF_1_NODUMP 0x00001000
#define DF_1_CONFALT 0x00002000
#define DF_1_ENDFILTEE 0x00004000
#define DF_1_DISPRELDNE 0x00008000
#define DF_1_DISPRELPND 0x00010000


#define DTF_1_PARINIT 0x00000001
#define DTF_1_CONFEXP 0x00000002


#define DF_P1_LAZYLOAD 0x00000001
#define DF_P1_GROUPPERM 0x00000002




typedef struct
{
  Elf32_Half vd_version;
  Elf32_Half vd_flags;
  Elf32_Half vd_ndx;
  Elf32_Half vd_cnt;
  Elf32_Word vd_hash;
  Elf32_Word vd_aux;
  Elf32_Word vd_next;

} Elf32_Verdef;

typedef struct
{
  Elf64_Half vd_version;
  Elf64_Half vd_flags;
  Elf64_Half vd_ndx;
  Elf64_Half vd_cnt;
  Elf64_Word vd_hash;
  Elf64_Word vd_aux;
  Elf64_Word vd_next;

} Elf64_Verdef;



#define VER_DEF_NONE 0
#define VER_DEF_CURRENT 1
#define VER_DEF_NUM 2


#define VER_FLG_BASE 0x1
#define VER_FLG_WEAK 0x2


#define VER_NDX_LOCAL 0
#define VER_NDX_GLOBAL 1
#define VER_NDX_LORESERVE 0xff00
#define VER_NDX_ELIMINATE 0xff01



typedef struct
{
  Elf32_Word vda_name;
  Elf32_Word vda_next;

} Elf32_Verdaux;

typedef struct
{
  Elf64_Word vda_name;
  Elf64_Word vda_next;

} Elf64_Verdaux;




typedef struct
{
  Elf32_Half vn_version;
  Elf32_Half vn_cnt;
  Elf32_Word vn_file;

  Elf32_Word vn_aux;
  Elf32_Word vn_next;

} Elf32_Verneed;

typedef struct
{
  Elf64_Half vn_version;
  Elf64_Half vn_cnt;
  Elf64_Word vn_file;

  Elf64_Word vn_aux;
  Elf64_Word vn_next;

} Elf64_Verneed;



#define VER_NEED_NONE 0
#define VER_NEED_CURRENT 1
#define VER_NEED_NUM 2



typedef struct
{
  Elf32_Word vna_hash;
  Elf32_Half vna_flags;
  Elf32_Half vna_other;
  Elf32_Word vna_name;
  Elf32_Word vna_next;

} Elf32_Vernaux;

typedef struct
{
  Elf64_Word vna_hash;
  Elf64_Half vna_flags;
  Elf64_Half vna_other;
  Elf64_Word vna_name;
  Elf64_Word vna_next;

} Elf64_Vernaux;



#define VER_FLG_WEAK 0x2
# 901 "../libelf/elf.h"
typedef struct
{
  uint32_t a_type;
  union
    {
      uint32_t a_val;



    } a_un;
} Elf32_auxv_t;

typedef struct
{
  uint64_t a_type;
  union
    {
      uint64_t a_val;



    } a_un;
} Elf64_auxv_t;



#define AT_NULL 0
#define AT_IGNORE 1
#define AT_EXECFD 2
#define AT_PHDR 3
#define AT_PHENT 4
#define AT_PHNUM 5
#define AT_PAGESZ 6
#define AT_BASE 7
#define AT_FLAGS 8
#define AT_ENTRY 9
#define AT_NOTELF 10
#define AT_UID 11
#define AT_EUID 12
#define AT_GID 13
#define AT_EGID 14
#define AT_CLKTCK 17


#define AT_PLATFORM 15
#define AT_HWCAP 16




#define AT_FPUCW 18


#define AT_DCACHEBSIZE 19
#define AT_ICACHEBSIZE 20
#define AT_UCACHEBSIZE 21



#define AT_IGNOREPPC 22

#define AT_SECURE 23



#define AT_SYSINFO 32
#define AT_SYSINFO_EHDR 33



#define AT_L1I_CACHESHAPE 34
#define AT_L1D_CACHESHAPE 35
#define AT_L2_CACHESHAPE 36
#define AT_L3_CACHESHAPE 37




typedef struct
{
  Elf32_Word n_namesz;
  Elf32_Word n_descsz;
  Elf32_Word n_type;
} Elf32_Nhdr;

typedef struct
{
  Elf64_Word n_namesz;
  Elf64_Word n_descsz;
  Elf64_Word n_type;
} Elf64_Nhdr;




#define ELF_NOTE_SOLARIS "SUNW Solaris"


#define ELF_NOTE_GNU "GNU"





#define ELF_NOTE_PAGESIZE_HINT 1
# 1016 "../libelf/elf.h"
#define ELF_NOTE_ABI 1



#define ELF_NOTE_OS_LINUX 0
#define ELF_NOTE_OS_GNU 1
#define ELF_NOTE_OS_SOLARIS2 2
#define ELF_NOTE_OS_FREEBSD 3



typedef struct
{
  Elf32_Xword m_value;
  Elf32_Word m_info;
  Elf32_Word m_poffset;
  Elf32_Half m_repeat;
  Elf32_Half m_stride;
} Elf32_Move;

typedef struct
{
  Elf64_Xword m_value;
  Elf64_Xword m_info;
  Elf64_Xword m_poffset;
  Elf64_Half m_repeat;
  Elf64_Half m_stride;
} Elf64_Move;


#define ELF32_M_SYM(info) ((info) >> 8)
#define ELF32_M_SIZE(info) ((unsigned char) (info))
#define ELF32_M_INFO(sym,size) (((sym) << 8) + (unsigned char) (size))

#define ELF64_M_SYM(info) ELF32_M_SYM (info)
#define ELF64_M_SIZE(info) ELF32_M_SIZE (info)
#define ELF64_M_INFO(sym,size) ELF32_M_INFO (sym, size)





#define EF_CPU32 0x00810000



#define R_68K_NONE 0
#define R_68K_32 1
#define R_68K_16 2
#define R_68K_8 3
#define R_68K_PC32 4
#define R_68K_PC16 5
#define R_68K_PC8 6
#define R_68K_GOT32 7
#define R_68K_GOT16 8
#define R_68K_GOT8 9
#define R_68K_GOT32O 10
#define R_68K_GOT16O 11
#define R_68K_GOT8O 12
#define R_68K_PLT32 13
#define R_68K_PLT16 14
#define R_68K_PLT8 15
#define R_68K_PLT32O 16
#define R_68K_PLT16O 17
#define R_68K_PLT8O 18
#define R_68K_COPY 19
#define R_68K_GLOB_DAT 20
#define R_68K_JMP_SLOT 21
#define R_68K_RELATIVE 22

#define R_68K_NUM 23





#define R_386_NONE 0
#define R_386_32 1
#define R_386_PC32 2
#define R_386_GOT32 3
#define R_386_PLT32 4
#define R_386_COPY 5
#define R_386_GLOB_DAT 6
#define R_386_JMP_SLOT 7
#define R_386_RELATIVE 8
#define R_386_GOTOFF 9
#define R_386_GOTPC 10
#define R_386_32PLT 11
#define R_386_TLS_TPOFF 14
#define R_386_TLS_IE 15

#define R_386_TLS_GOTIE 16

#define R_386_TLS_LE 17

#define R_386_TLS_GD 18

#define R_386_TLS_LDM 19


#define R_386_16 20
#define R_386_PC16 21
#define R_386_8 22
#define R_386_PC8 23
#define R_386_TLS_GD_32 24

#define R_386_TLS_GD_PUSH 25
#define R_386_TLS_GD_CALL 26

#define R_386_TLS_GD_POP 27
#define R_386_TLS_LDM_32 28

#define R_386_TLS_LDM_PUSH 29
#define R_386_TLS_LDM_CALL 30

#define R_386_TLS_LDM_POP 31
#define R_386_TLS_LDO_32 32
#define R_386_TLS_IE_32 33

#define R_386_TLS_LE_32 34

#define R_386_TLS_DTPMOD32 35
#define R_386_TLS_DTPOFF32 36
#define R_386_TLS_TPOFF32 37

#define R_386_NUM 38





#define STT_SPARC_REGISTER 13



#define EF_SPARCV9_MM 3
#define EF_SPARCV9_TSO 0
#define EF_SPARCV9_PSO 1
#define EF_SPARCV9_RMO 2
#define EF_SPARC_LEDATA 0x800000
#define EF_SPARC_EXT_MASK 0xFFFF00
#define EF_SPARC_32PLUS 0x000100
#define EF_SPARC_SUN_US1 0x000200
#define EF_SPARC_HAL_R1 0x000400
#define EF_SPARC_SUN_US3 0x000800



#define R_SPARC_NONE 0
#define R_SPARC_8 1
#define R_SPARC_16 2
#define R_SPARC_32 3
#define R_SPARC_DISP8 4
#define R_SPARC_DISP16 5
#define R_SPARC_DISP32 6
#define R_SPARC_WDISP30 7
#define R_SPARC_WDISP22 8
#define R_SPARC_HI22 9
#define R_SPARC_22 10
#define R_SPARC_13 11
#define R_SPARC_LO10 12
#define R_SPARC_GOT10 13
#define R_SPARC_GOT13 14
#define R_SPARC_GOT22 15
#define R_SPARC_PC10 16
#define R_SPARC_PC22 17
#define R_SPARC_WPLT30 18
#define R_SPARC_COPY 19
#define R_SPARC_GLOB_DAT 20
#define R_SPARC_JMP_SLOT 21
#define R_SPARC_RELATIVE 22
#define R_SPARC_UA32 23



#define R_SPARC_PLT32 24
#define R_SPARC_HIPLT22 25
#define R_SPARC_LOPLT10 26
#define R_SPARC_PCPLT32 27
#define R_SPARC_PCPLT22 28
#define R_SPARC_PCPLT10 29
#define R_SPARC_10 30
#define R_SPARC_11 31
#define R_SPARC_64 32
#define R_SPARC_OLO10 33
#define R_SPARC_HH22 34
#define R_SPARC_HM10 35
#define R_SPARC_LM22 36
#define R_SPARC_PC_HH22 37
#define R_SPARC_PC_HM10 38
#define R_SPARC_PC_LM22 39
#define R_SPARC_WDISP16 40
#define R_SPARC_WDISP19 41
#define R_SPARC_7 43
#define R_SPARC_5 44
#define R_SPARC_6 45
#define R_SPARC_DISP64 46
#define R_SPARC_PLT64 47
#define R_SPARC_HIX22 48
#define R_SPARC_LOX10 49
#define R_SPARC_H44 50
#define R_SPARC_M44 51
#define R_SPARC_L44 52
#define R_SPARC_REGISTER 53
#define R_SPARC_UA64 54
#define R_SPARC_UA16 55
#define R_SPARC_TLS_GD_HI22 56
#define R_SPARC_TLS_GD_LO10 57
#define R_SPARC_TLS_GD_ADD 58
#define R_SPARC_TLS_GD_CALL 59
#define R_SPARC_TLS_LDM_HI22 60
#define R_SPARC_TLS_LDM_LO10 61
#define R_SPARC_TLS_LDM_ADD 62
#define R_SPARC_TLS_LDM_CALL 63
#define R_SPARC_TLS_LDO_HIX22 64
#define R_SPARC_TLS_LDO_LOX10 65
#define R_SPARC_TLS_LDO_ADD 66
#define R_SPARC_TLS_IE_HI22 67
#define R_SPARC_TLS_IE_LO10 68
#define R_SPARC_TLS_IE_LD 69
#define R_SPARC_TLS_IE_LDX 70
#define R_SPARC_TLS_IE_ADD 71
#define R_SPARC_TLS_LE_HIX22 72
#define R_SPARC_TLS_LE_LOX10 73
#define R_SPARC_TLS_DTPMOD32 74
#define R_SPARC_TLS_DTPMOD64 75
#define R_SPARC_TLS_DTPOFF32 76
#define R_SPARC_TLS_DTPOFF64 77
#define R_SPARC_TLS_TPOFF32 78
#define R_SPARC_TLS_TPOFF64 79

#define R_SPARC_NUM 80



#define DT_SPARC_REGISTER 0x70000001
#define DT_SPARC_NUM 2



#define HWCAP_SPARC_FLUSH 1
#define HWCAP_SPARC_STBAR 2
#define HWCAP_SPARC_SWAP 4
#define HWCAP_SPARC_MULDIV 8
#define HWCAP_SPARC_V9 16
#define HWCAP_SPARC_ULTRA3 32





#define EF_MIPS_NOREORDER 1
#define EF_MIPS_PIC 2
#define EF_MIPS_CPIC 4
#define EF_MIPS_XGOT 8
#define EF_MIPS_64BIT_WHIRL 16
#define EF_MIPS_ABI2 32
#define EF_MIPS_ABI_ON32 64
#define EF_MIPS_ARCH 0xf0000000



#define EF_MIPS_ARCH_1 0x00000000
#define EF_MIPS_ARCH_2 0x10000000
#define EF_MIPS_ARCH_3 0x20000000
#define EF_MIPS_ARCH_4 0x30000000
#define EF_MIPS_ARCH_5 0x40000000
#define EF_MIPS_ARCH_32 0x60000000
#define EF_MIPS_ARCH_64 0x70000000



#define E_MIPS_ARCH_1 0x00000000
#define E_MIPS_ARCH_2 0x10000000
#define E_MIPS_ARCH_3 0x20000000
#define E_MIPS_ARCH_4 0x30000000
#define E_MIPS_ARCH_5 0x40000000
#define E_MIPS_ARCH_32 0x60000000
#define E_MIPS_ARCH_64 0x70000000



#define SHN_MIPS_ACOMMON 0xff00
#define SHN_MIPS_TEXT 0xff01
#define SHN_MIPS_DATA 0xff02
#define SHN_MIPS_SCOMMON 0xff03
#define SHN_MIPS_SUNDEFINED 0xff04



#define SHT_MIPS_LIBLIST 0x70000000
#define SHT_MIPS_MSYM 0x70000001
#define SHT_MIPS_CONFLICT 0x70000002
#define SHT_MIPS_GPTAB 0x70000003
#define SHT_MIPS_UCODE 0x70000004
#define SHT_MIPS_DEBUG 0x70000005
#define SHT_MIPS_REGINFO 0x70000006
#define SHT_MIPS_PACKAGE 0x70000007
#define SHT_MIPS_PACKSYM 0x70000008
#define SHT_MIPS_RELD 0x70000009
#define SHT_MIPS_IFACE 0x7000000b
#define SHT_MIPS_CONTENT 0x7000000c
#define SHT_MIPS_OPTIONS 0x7000000d
#define SHT_MIPS_SHDR 0x70000010
#define SHT_MIPS_FDESC 0x70000011
#define SHT_MIPS_EXTSYM 0x70000012
#define SHT_MIPS_DENSE 0x70000013
#define SHT_MIPS_PDESC 0x70000014
#define SHT_MIPS_LOCSYM 0x70000015
#define SHT_MIPS_AUXSYM 0x70000016
#define SHT_MIPS_OPTSYM 0x70000017
#define SHT_MIPS_LOCSTR 0x70000018
#define SHT_MIPS_LINE 0x70000019
#define SHT_MIPS_RFDESC 0x7000001a
#define SHT_MIPS_DELTASYM 0x7000001b
#define SHT_MIPS_DELTAINST 0x7000001c
#define SHT_MIPS_DELTACLASS 0x7000001d
#define SHT_MIPS_DWARF 0x7000001e
#define SHT_MIPS_DELTADECL 0x7000001f
#define SHT_MIPS_SYMBOL_LIB 0x70000020
#define SHT_MIPS_EVENTS 0x70000021
#define SHT_MIPS_TRANSLATE 0x70000022
#define SHT_MIPS_PIXIE 0x70000023
#define SHT_MIPS_XLATE 0x70000024
#define SHT_MIPS_XLATE_DEBUG 0x70000025
#define SHT_MIPS_WHIRL 0x70000026
#define SHT_MIPS_EH_REGION 0x70000027
#define SHT_MIPS_XLATE_OLD 0x70000028
#define SHT_MIPS_PDR_EXCEPTION 0x70000029



#define SHF_MIPS_GPREL 0x10000000
#define SHF_MIPS_MERGE 0x20000000
#define SHF_MIPS_ADDR 0x40000000
#define SHF_MIPS_STRINGS 0x80000000
#define SHF_MIPS_NOSTRIP 0x08000000
#define SHF_MIPS_LOCAL 0x04000000
#define SHF_MIPS_NAMES 0x02000000
#define SHF_MIPS_NODUPE 0x01000000





#define STO_MIPS_DEFAULT 0x0
#define STO_MIPS_INTERNAL 0x1
#define STO_MIPS_HIDDEN 0x2
#define STO_MIPS_PROTECTED 0x3
#define STO_MIPS_SC_ALIGN_UNUSED 0xff


#define STB_MIPS_SPLIT_COMMON 13



typedef union
{
  struct
    {
      Elf32_Word gt_current_g_value;
      Elf32_Word gt_unused;
    } gt_header;
  struct
    {
      Elf32_Word gt_g_value;
      Elf32_Word gt_bytes;
    } gt_entry;
} Elf32_gptab;



typedef struct
{
  Elf32_Word ri_gprmask;
  Elf32_Word ri_cprmask[4];
  Elf32_Sword ri_gp_value;
} Elf32_RegInfo;



typedef struct
{
  unsigned char kind;

  unsigned char size;
  Elf32_Section section;

  Elf32_Word info;
} Elf_Options;



#define ODK_NULL 0
#define ODK_REGINFO 1
#define ODK_EXCEPTIONS 2
#define ODK_PAD 3
#define ODK_HWPATCH 4
#define ODK_FILL 5
#define ODK_TAGS 6
#define ODK_HWAND 7
#define ODK_HWOR 8



#define OEX_FPU_MIN 0x1f
#define OEX_FPU_MAX 0x1f00
#define OEX_PAGE0 0x10000
#define OEX_SMM 0x20000
#define OEX_FPDBUG 0x40000
#define OEX_PRECISEFP OEX_FPDBUG
#define OEX_DISMISS 0x80000

#define OEX_FPU_INVAL 0x10
#define OEX_FPU_DIV0 0x08
#define OEX_FPU_OFLO 0x04
#define OEX_FPU_UFLO 0x02
#define OEX_FPU_INEX 0x01



#define OHW_R4KEOP 0x1
#define OHW_R8KPFETCH 0x2
#define OHW_R5KEOP 0x4
#define OHW_R5KCVTL 0x8

#define OPAD_PREFIX 0x1
#define OPAD_POSTFIX 0x2
#define OPAD_SYMBOL 0x4



typedef struct
{
  Elf32_Word hwp_flags1;
  Elf32_Word hwp_flags2;
} Elf_Options_Hw;



#define OHWA0_R4KEOP_CHECKED 0x00000001
#define OHWA1_R4KEOP_CLEAN 0x00000002



#define R_MIPS_NONE 0
#define R_MIPS_16 1
#define R_MIPS_32 2
#define R_MIPS_REL32 3
#define R_MIPS_26 4
#define R_MIPS_HI16 5
#define R_MIPS_LO16 6
#define R_MIPS_GPREL16 7
#define R_MIPS_LITERAL 8
#define R_MIPS_GOT16 9
#define R_MIPS_PC16 10
#define R_MIPS_CALL16 11
#define R_MIPS_GPREL32 12

#define R_MIPS_SHIFT5 16
#define R_MIPS_SHIFT6 17
#define R_MIPS_64 18
#define R_MIPS_GOT_DISP 19
#define R_MIPS_GOT_PAGE 20
#define R_MIPS_GOT_OFST 21
#define R_MIPS_GOT_HI16 22
#define R_MIPS_GOT_LO16 23
#define R_MIPS_SUB 24
#define R_MIPS_INSERT_A 25
#define R_MIPS_INSERT_B 26
#define R_MIPS_DELETE 27
#define R_MIPS_HIGHER 28
#define R_MIPS_HIGHEST 29
#define R_MIPS_CALL_HI16 30
#define R_MIPS_CALL_LO16 31
#define R_MIPS_SCN_DISP 32
#define R_MIPS_REL16 33
#define R_MIPS_ADD_IMMEDIATE 34
#define R_MIPS_PJUMP 35
#define R_MIPS_RELGOT 36
#define R_MIPS_JALR 37
#define R_MIPS_TLS_DTPMOD32 38
#define R_MIPS_TLS_DTPREL32 39
#define R_MIPS_TLS_DTPMOD64 40
#define R_MIPS_TLS_DTPREL64 41
#define R_MIPS_TLS_GD 42
#define R_MIPS_TLS_LDM 43
#define R_MIPS_TLS_DTPREL_HI16 44
#define R_MIPS_TLS_DTPREL_LO16 45
#define R_MIPS_TLS_GOTTPREL 46
#define R_MIPS_TLS_TPREL32 47
#define R_MIPS_TLS_TPREL64 48
#define R_MIPS_TLS_TPREL_HI16 49
#define R_MIPS_TLS_TPREL_LO16 50

#define R_MIPS_NUM 51



#define PT_MIPS_REGINFO 0x70000000
#define PT_MIPS_RTPROC 0x70000001
#define PT_MIPS_OPTIONS 0x70000002



#define PF_MIPS_LOCAL 0x10000000



#define DT_MIPS_RLD_VERSION 0x70000001
#define DT_MIPS_TIME_STAMP 0x70000002
#define DT_MIPS_ICHECKSUM 0x70000003
#define DT_MIPS_IVERSION 0x70000004
#define DT_MIPS_FLAGS 0x70000005
#define DT_MIPS_BASE_ADDRESS 0x70000006
#define DT_MIPS_MSYM 0x70000007
#define DT_MIPS_CONFLICT 0x70000008
#define DT_MIPS_LIBLIST 0x70000009
#define DT_MIPS_LOCAL_GOTNO 0x7000000a
#define DT_MIPS_CONFLICTNO 0x7000000b
#define DT_MIPS_LIBLISTNO 0x70000010
#define DT_MIPS_SYMTABNO 0x70000011
#define DT_MIPS_UNREFEXTNO 0x70000012
#define DT_MIPS_GOTSYM 0x70000013
#define DT_MIPS_HIPAGENO 0x70000014
#define DT_MIPS_RLD_MAP 0x70000016
#define DT_MIPS_DELTA_CLASS 0x70000017
#define DT_MIPS_DELTA_CLASS_NO 0x70000018

#define DT_MIPS_DELTA_INSTANCE 0x70000019
#define DT_MIPS_DELTA_INSTANCE_NO 0x7000001a

#define DT_MIPS_DELTA_RELOC 0x7000001b
#define DT_MIPS_DELTA_RELOC_NO 0x7000001c

#define DT_MIPS_DELTA_SYM 0x7000001d

#define DT_MIPS_DELTA_SYM_NO 0x7000001e

#define DT_MIPS_DELTA_CLASSSYM 0x70000020

#define DT_MIPS_DELTA_CLASSSYM_NO 0x70000021

#define DT_MIPS_CXX_FLAGS 0x70000022
#define DT_MIPS_PIXIE_INIT 0x70000023
#define DT_MIPS_SYMBOL_LIB 0x70000024
#define DT_MIPS_LOCALPAGE_GOTIDX 0x70000025
#define DT_MIPS_LOCAL_GOTIDX 0x70000026
#define DT_MIPS_HIDDEN_GOTIDX 0x70000027
#define DT_MIPS_PROTECTED_GOTIDX 0x70000028
#define DT_MIPS_OPTIONS 0x70000029
#define DT_MIPS_INTERFACE 0x7000002a
#define DT_MIPS_DYNSTR_ALIGN 0x7000002b
#define DT_MIPS_INTERFACE_SIZE 0x7000002c
#define DT_MIPS_RLD_TEXT_RESOLVE_ADDR 0x7000002d

#define DT_MIPS_PERF_SUFFIX 0x7000002e

#define DT_MIPS_COMPACT_SIZE 0x7000002f
#define DT_MIPS_GP_VALUE 0x70000030
#define DT_MIPS_AUX_DYNAMIC 0x70000031
#define DT_MIPS_NUM 0x32



#define RHF_NONE 0
#define RHF_QUICKSTART (1 << 0)
#define RHF_NOTPOT (1 << 1)
#define RHF_NO_LIBRARY_REPLACEMENT (1 << 2)
#define RHF_NO_MOVE (1 << 3)
#define RHF_SGI_ONLY (1 << 4)
#define RHF_GUARANTEE_INIT (1 << 5)
#define RHF_DELTA_C_PLUS_PLUS (1 << 6)
#define RHF_GUARANTEE_START_INIT (1 << 7)
#define RHF_PIXIE (1 << 8)
#define RHF_DEFAULT_DELAY_LOAD (1 << 9)
#define RHF_REQUICKSTART (1 << 10)
#define RHF_REQUICKSTARTED (1 << 11)
#define RHF_CORD (1 << 12)
#define RHF_NO_UNRES_UNDEF (1 << 13)
#define RHF_RLD_ORDER_SAFE (1 << 14)



typedef struct
{
  Elf32_Word l_name;
  Elf32_Word l_time_stamp;
  Elf32_Word l_checksum;
  Elf32_Word l_version;
  Elf32_Word l_flags;
} Elf32_Lib;

typedef struct
{
  Elf64_Word l_name;
  Elf64_Word l_time_stamp;
  Elf64_Word l_checksum;
  Elf64_Word l_version;
  Elf64_Word l_flags;
} Elf64_Lib;




#define LL_NONE 0
#define LL_EXACT_MATCH (1 << 0)
#define LL_IGNORE_INT_VER (1 << 1)
#define LL_REQUIRE_MINOR (1 << 2)
#define LL_EXPORTS (1 << 3)
#define LL_DELAY_LOAD (1 << 4)
#define LL_DELTA (1 << 5)



typedef Elf32_Addr Elf32_Conflict;






#define EF_PARISC_TRAPNIL 0x00010000
#define EF_PARISC_EXT 0x00020000
#define EF_PARISC_LSB 0x00040000
#define EF_PARISC_WIDE 0x00080000
#define EF_PARISC_NO_KABP 0x00100000

#define EF_PARISC_LAZYSWAP 0x00400000
#define EF_PARISC_ARCH 0x0000ffff



#define EFA_PARISC_1_0 0x020b
#define EFA_PARISC_1_1 0x0210
#define EFA_PARISC_2_0 0x0214



#define SHN_PARISC_ANSI_COMMON 0xff00

#define SHN_PARISC_HUGE_COMMON 0xff01



#define SHT_PARISC_EXT 0x70000000
#define SHT_PARISC_UNWIND 0x70000001
#define SHT_PARISC_DOC 0x70000002



#define SHF_PARISC_SHORT 0x20000000
#define SHF_PARISC_HUGE 0x40000000
#define SHF_PARISC_SBP 0x80000000



#define STT_PARISC_MILLICODE 13

#define STT_HP_OPAQUE (STT_LOOS + 0x1)
#define STT_HP_STUB (STT_LOOS + 0x2)



#define R_PARISC_NONE 0
#define R_PARISC_DIR32 1
#define R_PARISC_DIR21L 2
#define R_PARISC_DIR17R 3
#define R_PARISC_DIR17F 4
#define R_PARISC_DIR14R 6
#define R_PARISC_PCREL32 9
#define R_PARISC_PCREL21L 10
#define R_PARISC_PCREL17R 11
#define R_PARISC_PCREL17F 12
#define R_PARISC_PCREL14R 14
#define R_PARISC_DPREL21L 18
#define R_PARISC_DPREL14R 22
#define R_PARISC_GPREL21L 26
#define R_PARISC_GPREL14R 30
#define R_PARISC_LTOFF21L 34
#define R_PARISC_LTOFF14R 38
#define R_PARISC_SECREL32 41
#define R_PARISC_SEGBASE 48
#define R_PARISC_SEGREL32 49
#define R_PARISC_PLTOFF21L 50
#define R_PARISC_PLTOFF14R 54
#define R_PARISC_LTOFF_FPTR32 57
#define R_PARISC_LTOFF_FPTR21L 58
#define R_PARISC_LTOFF_FPTR14R 62
#define R_PARISC_FPTR64 64
#define R_PARISC_PLABEL32 65
#define R_PARISC_PCREL64 72
#define R_PARISC_PCREL22F 74
#define R_PARISC_PCREL14WR 75
#define R_PARISC_PCREL14DR 76
#define R_PARISC_PCREL16F 77
#define R_PARISC_PCREL16WF 78
#define R_PARISC_PCREL16DF 79
#define R_PARISC_DIR64 80
#define R_PARISC_DIR14WR 83
#define R_PARISC_DIR14DR 84
#define R_PARISC_DIR16F 85
#define R_PARISC_DIR16WF 86
#define R_PARISC_DIR16DF 87
#define R_PARISC_GPREL64 88
#define R_PARISC_GPREL14WR 91
#define R_PARISC_GPREL14DR 92
#define R_PARISC_GPREL16F 93
#define R_PARISC_GPREL16WF 94
#define R_PARISC_GPREL16DF 95
#define R_PARISC_LTOFF64 96
#define R_PARISC_LTOFF14WR 99
#define R_PARISC_LTOFF14DR 100
#define R_PARISC_LTOFF16F 101
#define R_PARISC_LTOFF16WF 102
#define R_PARISC_LTOFF16DF 103
#define R_PARISC_SECREL64 104
#define R_PARISC_SEGREL64 112
#define R_PARISC_PLTOFF14WR 115
#define R_PARISC_PLTOFF14DR 116
#define R_PARISC_PLTOFF16F 117
#define R_PARISC_PLTOFF16WF 118
#define R_PARISC_PLTOFF16DF 119
#define R_PARISC_LTOFF_FPTR64 120
#define R_PARISC_LTOFF_FPTR14WR 123
#define R_PARISC_LTOFF_FPTR14DR 124
#define R_PARISC_LTOFF_FPTR16F 125
#define R_PARISC_LTOFF_FPTR16WF 126
#define R_PARISC_LTOFF_FPTR16DF 127
#define R_PARISC_LORESERVE 128
#define R_PARISC_COPY 128
#define R_PARISC_IPLT 129
#define R_PARISC_EPLT 130
#define R_PARISC_TPREL32 153
#define R_PARISC_TPREL21L 154
#define R_PARISC_TPREL14R 158
#define R_PARISC_LTOFF_TP21L 162
#define R_PARISC_LTOFF_TP14R 166
#define R_PARISC_LTOFF_TP14F 167
#define R_PARISC_TPREL64 216
#define R_PARISC_TPREL14WR 219
#define R_PARISC_TPREL14DR 220
#define R_PARISC_TPREL16F 221
#define R_PARISC_TPREL16WF 222
#define R_PARISC_TPREL16DF 223
#define R_PARISC_LTOFF_TP64 224
#define R_PARISC_LTOFF_TP14WR 227
#define R_PARISC_LTOFF_TP14DR 228
#define R_PARISC_LTOFF_TP16F 229
#define R_PARISC_LTOFF_TP16WF 230
#define R_PARISC_LTOFF_TP16DF 231
#define R_PARISC_HIRESERVE 255



#define PT_HP_TLS (PT_LOOS + 0x0)
#define PT_HP_CORE_NONE (PT_LOOS + 0x1)
#define PT_HP_CORE_VERSION (PT_LOOS + 0x2)
#define PT_HP_CORE_KERNEL (PT_LOOS + 0x3)
#define PT_HP_CORE_COMM (PT_LOOS + 0x4)
#define PT_HP_CORE_PROC (PT_LOOS + 0x5)
#define PT_HP_CORE_LOADABLE (PT_LOOS + 0x6)
#define PT_HP_CORE_STACK (PT_LOOS + 0x7)
#define PT_HP_CORE_SHM (PT_LOOS + 0x8)
#define PT_HP_CORE_MMF (PT_LOOS + 0x9)
#define PT_HP_PARALLEL (PT_LOOS + 0x10)
#define PT_HP_FASTBIND (PT_LOOS + 0x11)
#define PT_HP_OPT_ANNOT (PT_LOOS + 0x12)
#define PT_HP_HSL_ANNOT (PT_LOOS + 0x13)
#define PT_HP_STACK (PT_LOOS + 0x14)

#define PT_PARISC_ARCHEXT 0x70000000
#define PT_PARISC_UNWIND 0x70000001



#define PF_PARISC_SBP 0x08000000

#define PF_HP_PAGE_SIZE 0x00100000
#define PF_HP_FAR_SHARED 0x00200000
#define PF_HP_NEAR_SHARED 0x00400000
#define PF_HP_CODE 0x01000000
#define PF_HP_MODIFY 0x02000000
#define PF_HP_LAZYSWAP 0x04000000
#define PF_HP_SBP 0x08000000






#define EF_ALPHA_32BIT 1
#define EF_ALPHA_CANRELAX 2




#define SHT_ALPHA_DEBUG 0x70000001
#define SHT_ALPHA_REGINFO 0x70000002



#define SHF_ALPHA_GPREL 0x10000000


#define STO_ALPHA_NOPV 0x80
#define STO_ALPHA_STD_GPLOAD 0x88



#define R_ALPHA_NONE 0
#define R_ALPHA_REFLONG 1
#define R_ALPHA_REFQUAD 2
#define R_ALPHA_GPREL32 3
#define R_ALPHA_LITERAL 4
#define R_ALPHA_LITUSE 5
#define R_ALPHA_GPDISP 6
#define R_ALPHA_BRADDR 7
#define R_ALPHA_HINT 8
#define R_ALPHA_SREL16 9
#define R_ALPHA_SREL32 10
#define R_ALPHA_SREL64 11
#define R_ALPHA_GPRELHIGH 17
#define R_ALPHA_GPRELLOW 18
#define R_ALPHA_GPREL16 19
#define R_ALPHA_COPY 24
#define R_ALPHA_GLOB_DAT 25
#define R_ALPHA_JMP_SLOT 26
#define R_ALPHA_RELATIVE 27
#define R_ALPHA_TLS_GD_HI 28
#define R_ALPHA_TLSGD 29
#define R_ALPHA_TLS_LDM 30
#define R_ALPHA_DTPMOD64 31
#define R_ALPHA_GOTDTPREL 32
#define R_ALPHA_DTPREL64 33
#define R_ALPHA_DTPRELHI 34
#define R_ALPHA_DTPRELLO 35
#define R_ALPHA_DTPREL16 36
#define R_ALPHA_GOTTPREL 37
#define R_ALPHA_TPREL64 38
#define R_ALPHA_TPRELHI 39
#define R_ALPHA_TPRELLO 40
#define R_ALPHA_TPREL16 41

#define R_ALPHA_NUM 46


#define LITUSE_ALPHA_ADDR 0
#define LITUSE_ALPHA_BASE 1
#define LITUSE_ALPHA_BYTOFF 2
#define LITUSE_ALPHA_JSR 3
#define LITUSE_ALPHA_TLS_GD 4
#define LITUSE_ALPHA_TLS_LDM 5


#define DT_ALPHA_PLTRO (DT_LOPROC + 0)
#define DT_ALPHA_NUM 1




#define EF_PPC_EMB 0x80000000


#define EF_PPC_RELOCATABLE 0x00010000
#define EF_PPC_RELOCATABLE_LIB 0x00008000



#define R_PPC_NONE 0
#define R_PPC_ADDR32 1
#define R_PPC_ADDR24 2
#define R_PPC_ADDR16 3
#define R_PPC_ADDR16_LO 4
#define R_PPC_ADDR16_HI 5
#define R_PPC_ADDR16_HA 6
#define R_PPC_ADDR14 7
#define R_PPC_ADDR14_BRTAKEN 8
#define R_PPC_ADDR14_BRNTAKEN 9
#define R_PPC_REL24 10
#define R_PPC_REL14 11
#define R_PPC_REL14_BRTAKEN 12
#define R_PPC_REL14_BRNTAKEN 13
#define R_PPC_GOT16 14
#define R_PPC_GOT16_LO 15
#define R_PPC_GOT16_HI 16
#define R_PPC_GOT16_HA 17
#define R_PPC_PLTREL24 18
#define R_PPC_COPY 19
#define R_PPC_GLOB_DAT 20
#define R_PPC_JMP_SLOT 21
#define R_PPC_RELATIVE 22
#define R_PPC_LOCAL24PC 23
#define R_PPC_UADDR32 24
#define R_PPC_UADDR16 25
#define R_PPC_REL32 26
#define R_PPC_PLT32 27
#define R_PPC_PLTREL32 28
#define R_PPC_PLT16_LO 29
#define R_PPC_PLT16_HI 30
#define R_PPC_PLT16_HA 31
#define R_PPC_SDAREL16 32
#define R_PPC_SECTOFF 33
#define R_PPC_SECTOFF_LO 34
#define R_PPC_SECTOFF_HI 35
#define R_PPC_SECTOFF_HA 36


#define R_PPC_TLS 67
#define R_PPC_DTPMOD32 68
#define R_PPC_TPREL16 69
#define R_PPC_TPREL16_LO 70
#define R_PPC_TPREL16_HI 71
#define R_PPC_TPREL16_HA 72
#define R_PPC_TPREL32 73
#define R_PPC_DTPREL16 74
#define R_PPC_DTPREL16_LO 75
#define R_PPC_DTPREL16_HI 76
#define R_PPC_DTPREL16_HA 77
#define R_PPC_DTPREL32 78
#define R_PPC_GOT_TLSGD16 79
#define R_PPC_GOT_TLSGD16_LO 80
#define R_PPC_GOT_TLSGD16_HI 81
#define R_PPC_GOT_TLSGD16_HA 82
#define R_PPC_GOT_TLSLD16 83
#define R_PPC_GOT_TLSLD16_LO 84
#define R_PPC_GOT_TLSLD16_HI 85
#define R_PPC_GOT_TLSLD16_HA 86
#define R_PPC_GOT_TPREL16 87
#define R_PPC_GOT_TPREL16_LO 88
#define R_PPC_GOT_TPREL16_HI 89
#define R_PPC_GOT_TPREL16_HA 90
#define R_PPC_GOT_DTPREL16 91
#define R_PPC_GOT_DTPREL16_LO 92
#define R_PPC_GOT_DTPREL16_HI 93
#define R_PPC_GOT_DTPREL16_HA 94


#define R_PPC_NUM 95



#define R_PPC_EMB_NADDR32 101
#define R_PPC_EMB_NADDR16 102
#define R_PPC_EMB_NADDR16_LO 103
#define R_PPC_EMB_NADDR16_HI 104
#define R_PPC_EMB_NADDR16_HA 105
#define R_PPC_EMB_SDAI16 106
#define R_PPC_EMB_SDA2I16 107
#define R_PPC_EMB_SDA2REL 108
#define R_PPC_EMB_SDA21 109
#define R_PPC_EMB_MRKREF 110
#define R_PPC_EMB_RELSEC16 111
#define R_PPC_EMB_RELST_LO 112
#define R_PPC_EMB_RELST_HI 113
#define R_PPC_EMB_RELST_HA 114
#define R_PPC_EMB_BIT_FLD 115
#define R_PPC_EMB_RELSDA 116


#define R_PPC_DIAB_SDA21_LO 180
#define R_PPC_DIAB_SDA21_HI 181
#define R_PPC_DIAB_SDA21_HA 182
#define R_PPC_DIAB_RELSDA_LO 183
#define R_PPC_DIAB_RELSDA_HI 184
#define R_PPC_DIAB_RELSDA_HA 185


#define R_PPC_REL16 249
#define R_PPC_REL16_LO 250
#define R_PPC_REL16_HI 251
#define R_PPC_REL16_HA 252



#define R_PPC_TOC16 255


#define DT_PPC_GOT (DT_LOPROC + 0)
#define DT_PPC_NUM 1


#define R_PPC64_NONE R_PPC_NONE
#define R_PPC64_ADDR32 R_PPC_ADDR32
#define R_PPC64_ADDR24 R_PPC_ADDR24
#define R_PPC64_ADDR16 R_PPC_ADDR16
#define R_PPC64_ADDR16_LO R_PPC_ADDR16_LO
#define R_PPC64_ADDR16_HI R_PPC_ADDR16_HI
#define R_PPC64_ADDR16_HA R_PPC_ADDR16_HA
#define R_PPC64_ADDR14 R_PPC_ADDR14
#define R_PPC64_ADDR14_BRTAKEN R_PPC_ADDR14_BRTAKEN
#define R_PPC64_ADDR14_BRNTAKEN R_PPC_ADDR14_BRNTAKEN
#define R_PPC64_REL24 R_PPC_REL24
#define R_PPC64_REL14 R_PPC_REL14
#define R_PPC64_REL14_BRTAKEN R_PPC_REL14_BRTAKEN
#define R_PPC64_REL14_BRNTAKEN R_PPC_REL14_BRNTAKEN
#define R_PPC64_GOT16 R_PPC_GOT16
#define R_PPC64_GOT16_LO R_PPC_GOT16_LO
#define R_PPC64_GOT16_HI R_PPC_GOT16_HI
#define R_PPC64_GOT16_HA R_PPC_GOT16_HA

#define R_PPC64_COPY R_PPC_COPY
#define R_PPC64_GLOB_DAT R_PPC_GLOB_DAT
#define R_PPC64_JMP_SLOT R_PPC_JMP_SLOT
#define R_PPC64_RELATIVE R_PPC_RELATIVE

#define R_PPC64_UADDR32 R_PPC_UADDR32
#define R_PPC64_UADDR16 R_PPC_UADDR16
#define R_PPC64_REL32 R_PPC_REL32
#define R_PPC64_PLT32 R_PPC_PLT32
#define R_PPC64_PLTREL32 R_PPC_PLTREL32
#define R_PPC64_PLT16_LO R_PPC_PLT16_LO
#define R_PPC64_PLT16_HI R_PPC_PLT16_HI
#define R_PPC64_PLT16_HA R_PPC_PLT16_HA

#define R_PPC64_SECTOFF R_PPC_SECTOFF
#define R_PPC64_SECTOFF_LO R_PPC_SECTOFF_LO
#define R_PPC64_SECTOFF_HI R_PPC_SECTOFF_HI
#define R_PPC64_SECTOFF_HA R_PPC_SECTOFF_HA
#define R_PPC64_ADDR30 37
#define R_PPC64_ADDR64 38
#define R_PPC64_ADDR16_HIGHER 39
#define R_PPC64_ADDR16_HIGHERA 40
#define R_PPC64_ADDR16_HIGHEST 41
#define R_PPC64_ADDR16_HIGHESTA 42
#define R_PPC64_UADDR64 43
#define R_PPC64_REL64 44
#define R_PPC64_PLT64 45
#define R_PPC64_PLTREL64 46
#define R_PPC64_TOC16 47
#define R_PPC64_TOC16_LO 48
#define R_PPC64_TOC16_HI 49
#define R_PPC64_TOC16_HA 50
#define R_PPC64_TOC 51
#define R_PPC64_PLTGOT16 52
#define R_PPC64_PLTGOT16_LO 53
#define R_PPC64_PLTGOT16_HI 54
#define R_PPC64_PLTGOT16_HA 55

#define R_PPC64_ADDR16_DS 56
#define R_PPC64_ADDR16_LO_DS 57
#define R_PPC64_GOT16_DS 58
#define R_PPC64_GOT16_LO_DS 59
#define R_PPC64_PLT16_LO_DS 60
#define R_PPC64_SECTOFF_DS 61
#define R_PPC64_SECTOFF_LO_DS 62
#define R_PPC64_TOC16_DS 63
#define R_PPC64_TOC16_LO_DS 64
#define R_PPC64_PLTGOT16_DS 65
#define R_PPC64_PLTGOT16_LO_DS 66


#define R_PPC64_TLS 67
#define R_PPC64_DTPMOD64 68
#define R_PPC64_TPREL16 69
#define R_PPC64_TPREL16_LO 70
#define R_PPC64_TPREL16_HI 71
#define R_PPC64_TPREL16_HA 72
#define R_PPC64_TPREL64 73
#define R_PPC64_DTPREL16 74
#define R_PPC64_DTPREL16_LO 75
#define R_PPC64_DTPREL16_HI 76
#define R_PPC64_DTPREL16_HA 77
#define R_PPC64_DTPREL64 78
#define R_PPC64_GOT_TLSGD16 79
#define R_PPC64_GOT_TLSGD16_LO 80
#define R_PPC64_GOT_TLSGD16_HI 81
#define R_PPC64_GOT_TLSGD16_HA 82
#define R_PPC64_GOT_TLSLD16 83
#define R_PPC64_GOT_TLSLD16_LO 84
#define R_PPC64_GOT_TLSLD16_HI 85
#define R_PPC64_GOT_TLSLD16_HA 86
#define R_PPC64_GOT_TPREL16_DS 87
#define R_PPC64_GOT_TPREL16_LO_DS 88
#define R_PPC64_GOT_TPREL16_HI 89
#define R_PPC64_GOT_TPREL16_HA 90
#define R_PPC64_GOT_DTPREL16_DS 91
#define R_PPC64_GOT_DTPREL16_LO_DS 92
#define R_PPC64_GOT_DTPREL16_HI 93
#define R_PPC64_GOT_DTPREL16_HA 94
#define R_PPC64_TPREL16_DS 95
#define R_PPC64_TPREL16_LO_DS 96
#define R_PPC64_TPREL16_HIGHER 97
#define R_PPC64_TPREL16_HIGHERA 98
#define R_PPC64_TPREL16_HIGHEST 99
#define R_PPC64_TPREL16_HIGHESTA 100
#define R_PPC64_DTPREL16_DS 101
#define R_PPC64_DTPREL16_LO_DS 102
#define R_PPC64_DTPREL16_HIGHER 103
#define R_PPC64_DTPREL16_HIGHERA 104
#define R_PPC64_DTPREL16_HIGHEST 105
#define R_PPC64_DTPREL16_HIGHESTA 106


#define R_PPC64_NUM 107


#define DT_PPC64_GLINK (DT_LOPROC + 0)
#define DT_PPC64_OPD (DT_LOPROC + 1)
#define DT_PPC64_OPDSZ (DT_LOPROC + 2)
#define DT_PPC64_NUM 3





#define EF_ARM_RELEXEC 0x01
#define EF_ARM_HASENTRY 0x02
#define EF_ARM_INTERWORK 0x04
#define EF_ARM_APCS_26 0x08
#define EF_ARM_APCS_FLOAT 0x10
#define EF_ARM_PIC 0x20
#define EF_ARM_ALIGN8 0x40
#define EF_ARM_NEW_ABI 0x80
#define EF_ARM_OLD_ABI 0x100



#define EF_ARM_SYMSARESORTED 0x04
#define EF_ARM_DYNSYMSUSESEGIDX 0x08
#define EF_ARM_MAPSYMSFIRST 0x10
#define EF_ARM_EABIMASK 0XFF000000

#define EF_ARM_EABI_VERSION(flags) ((flags) & EF_ARM_EABIMASK)
#define EF_ARM_EABI_UNKNOWN 0x00000000
#define EF_ARM_EABI_VER1 0x01000000
#define EF_ARM_EABI_VER2 0x02000000


#define STT_ARM_TFUNC 0xd


#define SHF_ARM_ENTRYSECT 0x10000000
#define SHF_ARM_COMDEF 0x80000000



#define PF_ARM_SB 0x10000000



#define PT_ARM_EXIDX 0x70000001



#define R_ARM_NONE 0
#define R_ARM_PC24 1
#define R_ARM_ABS32 2
#define R_ARM_REL32 3
#define R_ARM_PC13 4
#define R_ARM_ABS16 5
#define R_ARM_ABS12 6
#define R_ARM_THM_ABS5 7
#define R_ARM_ABS8 8
#define R_ARM_SBREL32 9
#define R_ARM_THM_PC22 10
#define R_ARM_THM_PC8 11
#define R_ARM_AMP_VCALL9 12
#define R_ARM_SWI24 13
#define R_ARM_THM_SWI8 14
#define R_ARM_XPC25 15
#define R_ARM_THM_XPC22 16
#define R_ARM_TLS_DTPMOD32 17
#define R_ARM_TLS_DTPOFF32 18
#define R_ARM_TLS_TPOFF32 19
#define R_ARM_COPY 20
#define R_ARM_GLOB_DAT 21
#define R_ARM_JUMP_SLOT 22
#define R_ARM_RELATIVE 23
#define R_ARM_GOTOFF 24
#define R_ARM_GOTPC 25
#define R_ARM_GOT32 26
#define R_ARM_PLT32 27
#define R_ARM_ALU_PCREL_7_0 32
#define R_ARM_ALU_PCREL_15_8 33
#define R_ARM_ALU_PCREL_23_15 34
#define R_ARM_LDR_SBREL_11_0 35
#define R_ARM_ALU_SBREL_19_12 36
#define R_ARM_ALU_SBREL_27_20 37
#define R_ARM_GNU_VTENTRY 100
#define R_ARM_GNU_VTINHERIT 101
#define R_ARM_THM_PC11 102
#define R_ARM_THM_PC9 103
#define R_ARM_TLS_GD32 104

#define R_ARM_TLS_LDM32 105

#define R_ARM_TLS_LDO32 106

#define R_ARM_TLS_IE32 107

#define R_ARM_TLS_LE32 108

#define R_ARM_RXPC25 249
#define R_ARM_RSBREL32 250
#define R_ARM_THM_RPC22 251
#define R_ARM_RREL32 252
#define R_ARM_RABS22 253
#define R_ARM_RPC24 254
#define R_ARM_RBASE 255

#define R_ARM_NUM 256




#define EF_IA_64_MASKOS 0x0000000f
#define EF_IA_64_ABI64 0x00000010
#define EF_IA_64_ARCH 0xff000000


#define PT_IA_64_ARCHEXT (PT_LOPROC + 0)
#define PT_IA_64_UNWIND (PT_LOPROC + 1)
#define PT_IA_64_HP_OPT_ANOT (PT_LOOS + 0x12)
#define PT_IA_64_HP_HSL_ANOT (PT_LOOS + 0x13)
#define PT_IA_64_HP_STACK (PT_LOOS + 0x14)


#define PF_IA_64_NORECOV 0x80000000


#define SHT_IA_64_EXT (SHT_LOPROC + 0)
#define SHT_IA_64_UNWIND (SHT_LOPROC + 1)


#define SHF_IA_64_SHORT 0x10000000
#define SHF_IA_64_NORECOV 0x20000000


#define DT_IA_64_PLT_RESERVE (DT_LOPROC + 0)
#define DT_IA_64_NUM 1


#define R_IA64_NONE 0x00
#define R_IA64_IMM14 0x21
#define R_IA64_IMM22 0x22
#define R_IA64_IMM64 0x23
#define R_IA64_DIR32MSB 0x24
#define R_IA64_DIR32LSB 0x25
#define R_IA64_DIR64MSB 0x26
#define R_IA64_DIR64LSB 0x27
#define R_IA64_GPREL22 0x2a
#define R_IA64_GPREL64I 0x2b
#define R_IA64_GPREL32MSB 0x2c
#define R_IA64_GPREL32LSB 0x2d
#define R_IA64_GPREL64MSB 0x2e
#define R_IA64_GPREL64LSB 0x2f
#define R_IA64_LTOFF22 0x32
#define R_IA64_LTOFF64I 0x33
#define R_IA64_PLTOFF22 0x3a
#define R_IA64_PLTOFF64I 0x3b
#define R_IA64_PLTOFF64MSB 0x3e
#define R_IA64_PLTOFF64LSB 0x3f
#define R_IA64_FPTR64I 0x43
#define R_IA64_FPTR32MSB 0x44
#define R_IA64_FPTR32LSB 0x45
#define R_IA64_FPTR64MSB 0x46
#define R_IA64_FPTR64LSB 0x47
#define R_IA64_PCREL60B 0x48
#define R_IA64_PCREL21B 0x49
#define R_IA64_PCREL21M 0x4a
#define R_IA64_PCREL21F 0x4b
#define R_IA64_PCREL32MSB 0x4c
#define R_IA64_PCREL32LSB 0x4d
#define R_IA64_PCREL64MSB 0x4e
#define R_IA64_PCREL64LSB 0x4f
#define R_IA64_LTOFF_FPTR22 0x52
#define R_IA64_LTOFF_FPTR64I 0x53
#define R_IA64_LTOFF_FPTR32MSB 0x54
#define R_IA64_LTOFF_FPTR32LSB 0x55
#define R_IA64_LTOFF_FPTR64MSB 0x56
#define R_IA64_LTOFF_FPTR64LSB 0x57
#define R_IA64_SEGREL32MSB 0x5c
#define R_IA64_SEGREL32LSB 0x5d
#define R_IA64_SEGREL64MSB 0x5e
#define R_IA64_SEGREL64LSB 0x5f
#define R_IA64_SECREL32MSB 0x64
#define R_IA64_SECREL32LSB 0x65
#define R_IA64_SECREL64MSB 0x66
#define R_IA64_SECREL64LSB 0x67
#define R_IA64_REL32MSB 0x6c
#define R_IA64_REL32LSB 0x6d
#define R_IA64_REL64MSB 0x6e
#define R_IA64_REL64LSB 0x6f
#define R_IA64_LTV32MSB 0x74
#define R_IA64_LTV32LSB 0x75
#define R_IA64_LTV64MSB 0x76
#define R_IA64_LTV64LSB 0x77
#define R_IA64_PCREL21BI 0x79
#define R_IA64_PCREL22 0x7a
#define R_IA64_PCREL64I 0x7b
#define R_IA64_IPLTMSB 0x80
#define R_IA64_IPLTLSB 0x81
#define R_IA64_COPY 0x84
#define R_IA64_SUB 0x85
#define R_IA64_LTOFF22X 0x86
#define R_IA64_LDXMOV 0x87
#define R_IA64_TPREL14 0x91
#define R_IA64_TPREL22 0x92
#define R_IA64_TPREL64I 0x93
#define R_IA64_TPREL64MSB 0x96
#define R_IA64_TPREL64LSB 0x97
#define R_IA64_LTOFF_TPREL22 0x9a
#define R_IA64_DTPMOD64MSB 0xa6
#define R_IA64_DTPMOD64LSB 0xa7
#define R_IA64_LTOFF_DTPMOD22 0xaa
#define R_IA64_DTPREL14 0xb1
#define R_IA64_DTPREL22 0xb2
#define R_IA64_DTPREL64I 0xb3
#define R_IA64_DTPREL32MSB 0xb4
#define R_IA64_DTPREL32LSB 0xb5
#define R_IA64_DTPREL64MSB 0xb6
#define R_IA64_DTPREL64LSB 0xb7
#define R_IA64_LTOFF_DTPREL22 0xba




#define R_SH_NONE 0
#define R_SH_DIR32 1
#define R_SH_REL32 2
#define R_SH_DIR8WPN 3
#define R_SH_IND12W 4
#define R_SH_DIR8WPL 5
#define R_SH_DIR8WPZ 6
#define R_SH_DIR8BP 7
#define R_SH_DIR8W 8
#define R_SH_DIR8L 9
#define R_SH_SWITCH16 25
#define R_SH_SWITCH32 26
#define R_SH_USES 27
#define R_SH_COUNT 28
#define R_SH_ALIGN 29
#define R_SH_CODE 30
#define R_SH_DATA 31
#define R_SH_LABEL 32
#define R_SH_SWITCH8 33
#define R_SH_GNU_VTINHERIT 34
#define R_SH_GNU_VTENTRY 35
#define R_SH_TLS_GD_32 144
#define R_SH_TLS_LD_32 145
#define R_SH_TLS_LDO_32 146
#define R_SH_TLS_IE_32 147
#define R_SH_TLS_LE_32 148
#define R_SH_TLS_DTPMOD32 149
#define R_SH_TLS_DTPOFF32 150
#define R_SH_TLS_TPOFF32 151
#define R_SH_GOT32 160
#define R_SH_PLT32 161
#define R_SH_COPY 162
#define R_SH_GLOB_DAT 163
#define R_SH_JMP_SLOT 164
#define R_SH_RELATIVE 165
#define R_SH_GOTOFF 166
#define R_SH_GOTPC 167

#define R_SH_NUM 256



#define R_390_NONE 0
#define R_390_8 1
#define R_390_12 2
#define R_390_16 3
#define R_390_32 4
#define R_390_PC32 5
#define R_390_GOT12 6
#define R_390_GOT32 7
#define R_390_PLT32 8
#define R_390_COPY 9
#define R_390_GLOB_DAT 10
#define R_390_JMP_SLOT 11
#define R_390_RELATIVE 12
#define R_390_GOTOFF32 13
#define R_390_GOTPC 14
#define R_390_GOT16 15
#define R_390_PC16 16
#define R_390_PC16DBL 17
#define R_390_PLT16DBL 18
#define R_390_PC32DBL 19
#define R_390_PLT32DBL 20
#define R_390_GOTPCDBL 21
#define R_390_64 22
#define R_390_PC64 23
#define R_390_GOT64 24
#define R_390_PLT64 25
#define R_390_GOTENT 26
#define R_390_GOTOFF16 27
#define R_390_GOTOFF64 28
#define R_390_GOTPLT12 29
#define R_390_GOTPLT16 30
#define R_390_GOTPLT32 31
#define R_390_GOTPLT64 32
#define R_390_GOTPLTENT 33
#define R_390_PLTOFF16 34
#define R_390_PLTOFF32 35
#define R_390_PLTOFF64 36
#define R_390_TLS_LOAD 37
#define R_390_TLS_GDCALL 38

#define R_390_TLS_LDCALL 39

#define R_390_TLS_GD32 40

#define R_390_TLS_GD64 41

#define R_390_TLS_GOTIE12 42

#define R_390_TLS_GOTIE32 43

#define R_390_TLS_GOTIE64 44

#define R_390_TLS_LDM32 45

#define R_390_TLS_LDM64 46

#define R_390_TLS_IE32 47

#define R_390_TLS_IE64 48

#define R_390_TLS_IEENT 49

#define R_390_TLS_LE32 50

#define R_390_TLS_LE64 51

#define R_390_TLS_LDO32 52

#define R_390_TLS_LDO64 53

#define R_390_TLS_DTPMOD 54
#define R_390_TLS_DTPOFF 55
#define R_390_TLS_TPOFF 56

#define R_390_20 57
#define R_390_GOT20 58
#define R_390_GOTPLT20 59
#define R_390_TLS_GOTIE20 60


#define R_390_NUM 61



#define R_CRIS_NONE 0
#define R_CRIS_8 1
#define R_CRIS_16 2
#define R_CRIS_32 3
#define R_CRIS_8_PCREL 4
#define R_CRIS_16_PCREL 5
#define R_CRIS_32_PCREL 6
#define R_CRIS_GNU_VTINHERIT 7
#define R_CRIS_GNU_VTENTRY 8
#define R_CRIS_COPY 9
#define R_CRIS_GLOB_DAT 10
#define R_CRIS_JUMP_SLOT 11
#define R_CRIS_RELATIVE 12
#define R_CRIS_16_GOT 13
#define R_CRIS_32_GOT 14
#define R_CRIS_16_GOTPLT 15
#define R_CRIS_32_GOTPLT 16
#define R_CRIS_32_GOTREL 17
#define R_CRIS_32_PLT_GOTREL 18
#define R_CRIS_32_PLT_PCREL 19

#define R_CRIS_NUM 20



#define R_X86_64_NONE 0
#define R_X86_64_64 1
#define R_X86_64_PC32 2
#define R_X86_64_GOT32 3
#define R_X86_64_PLT32 4
#define R_X86_64_COPY 5
#define R_X86_64_GLOB_DAT 6
#define R_X86_64_JUMP_SLOT 7
#define R_X86_64_RELATIVE 8
#define R_X86_64_GOTPCREL 9

#define R_X86_64_32 10
#define R_X86_64_32S 11
#define R_X86_64_16 12
#define R_X86_64_PC16 13
#define R_X86_64_8 14
#define R_X86_64_PC8 15
#define R_X86_64_DTPMOD64 16
#define R_X86_64_DTPOFF64 17
#define R_X86_64_TPOFF64 18
#define R_X86_64_TLSGD 19

#define R_X86_64_TLSLD 20

#define R_X86_64_DTPOFF32 21
#define R_X86_64_GOTTPOFF 22

#define R_X86_64_TPOFF32 23

#define R_X86_64_NUM 24



#define R_MN10300_NONE 0
#define R_MN10300_32 1
#define R_MN10300_16 2
#define R_MN10300_8 3
#define R_MN10300_PCREL32 4
#define R_MN10300_PCREL16 5
#define R_MN10300_PCREL8 6
#define R_MN10300_GNU_VTINHERIT 7
#define R_MN10300_GNU_VTENTRY 8
#define R_MN10300_24 9
#define R_MN10300_GOTPC32 10
#define R_MN10300_GOTPC16 11
#define R_MN10300_GOTOFF32 12
#define R_MN10300_GOTOFF24 13
#define R_MN10300_GOTOFF16 14
#define R_MN10300_PLT32 15
#define R_MN10300_PLT16 16
#define R_MN10300_GOT32 17
#define R_MN10300_GOT24 18
#define R_MN10300_GOT16 19
#define R_MN10300_COPY 20
#define R_MN10300_GLOB_DAT 21
#define R_MN10300_JMP_SLOT 22
#define R_MN10300_RELATIVE 23

#define R_MN10300_NUM 24



#define R_M32R_NONE 0
#define R_M32R_16 1
#define R_M32R_32 2
#define R_M32R_24 3
#define R_M32R_10_PCREL 4
#define R_M32R_18_PCREL 5
#define R_M32R_26_PCREL 6
#define R_M32R_HI16_ULO 7
#define R_M32R_HI16_SLO 8
#define R_M32R_LO16 9
#define R_M32R_SDA16 10
#define R_M32R_GNU_VTINHERIT 11
#define R_M32R_GNU_VTENTRY 12

#define R_M32R_16_RELA 33
#define R_M32R_32_RELA 34
#define R_M32R_24_RELA 35
#define R_M32R_10_PCREL_RELA 36
#define R_M32R_18_PCREL_RELA 37
#define R_M32R_26_PCREL_RELA 38
#define R_M32R_HI16_ULO_RELA 39
#define R_M32R_HI16_SLO_RELA 40
#define R_M32R_LO16_RELA 41
#define R_M32R_SDA16_RELA 42
#define R_M32R_RELA_GNU_VTINHERIT 43
#define R_M32R_RELA_GNU_VTENTRY 44
#define R_M32R_REL32 45

#define R_M32R_GOT24 48
#define R_M32R_26_PLTREL 49
#define R_M32R_COPY 50
#define R_M32R_GLOB_DAT 51
#define R_M32R_JMP_SLOT 52
#define R_M32R_RELATIVE 53
#define R_M32R_GOTOFF 54
#define R_M32R_GOTPC24 55
#define R_M32R_GOT16_HI_ULO 56

#define R_M32R_GOT16_HI_SLO 57

#define R_M32R_GOT16_LO 58
#define R_M32R_GOTPC_HI_ULO 59

#define R_M32R_GOTPC_HI_SLO 60

#define R_M32R_GOTPC_LO 61

#define R_M32R_GOTOFF_HI_ULO 62

#define R_M32R_GOTOFF_HI_SLO 63

#define R_M32R_GOTOFF_LO 64
#define R_M32R_NUM 256



# 24 "../libelf/libelf.h" 2



typedef enum
{
  ELF_T_BYTE,
  ELF_T_ADDR,
  ELF_T_DYN,
  ELF_T_EHDR,
  ELF_T_HALF,
  ELF_T_OFF,
  ELF_T_PHDR,
  ELF_T_RELA,
  ELF_T_REL,
  ELF_T_SHDR,
  ELF_T_SWORD,
  ELF_T_SYM,
  ELF_T_WORD,
  ELF_T_XWORD,
  ELF_T_SXWORD,
  ELF_T_VDEF,
  ELF_T_VDAUX,
  ELF_T_VNEED,
  ELF_T_VNAUX,
  ELF_T_NHDR,
  ELF_T_SYMINFO,
  ELF_T_MOVE,
  ELF_T_LIB,

  ELF_T_NUM
} Elf_Type;


typedef struct
{
  void *d_buf;
  Elf_Type d_type;
  unsigned int d_version;
  size_t d_size;
  off_t d_off;
  size_t d_align;
} Elf_Data;



typedef enum
{
  ELF_C_NULL,
  ELF_C_READ,
  ELF_C_RDWR,
  ELF_C_WRITE,
  ELF_C_CLR,
  ELF_C_SET,
  ELF_C_FDDONE,

  ELF_C_FDREAD,


  ELF_C_READ_MMAP,
  ELF_C_RDWR_MMAP,
  ELF_C_WRITE_MMAP,
  ELF_C_READ_MMAP_PRIVATE,

  ELF_C_EMPTY,

  ELF_C_NUM
} Elf_Cmd;



enum
{
  ELF_F_DIRTY = 0x1,
#define ELF_F_DIRTY ELF_F_DIRTY
  ELF_F_LAYOUT = 0x4,
#define ELF_F_LAYOUT ELF_F_LAYOUT
  ELF_F_PERMISSIVE = 0x8
#define ELF_F_PERMISSIVE ELF_F_PERMISSIVE
};



typedef enum
{
  ELF_K_NONE,
  ELF_K_AR,
  ELF_K_COFF,
  ELF_K_ELF,

  ELF_K_NUM
} Elf_Kind;



typedef struct
{
  char *ar_name;
  time_t ar_date;
  uid_t ar_uid;
  gid_t ar_gid;
  mode_t ar_mode;
  off_t ar_size;
  char *ar_rawname;
} Elf_Arhdr;



typedef struct
{
  char *as_name;
  size_t as_off;
  unsigned long int as_hash;
} Elf_Arsym;



typedef struct Elf Elf;


typedef struct Elf_Scn Elf_Scn;







extern Elf *elf_begin (int __fildes, Elf_Cmd __cmd, Elf *__ref);


  extern Elf *elf_clone (Elf *__elf, Elf_Cmd __cmd);


extern Elf *elf_memory (char *__image, size_t __size);


extern Elf_Cmd elf_next (Elf *__elf);


extern int elf_end (Elf *__elf);


extern off_t elf_update (Elf *__elf, Elf_Cmd __cmd);


extern Elf_Kind elf_kind (Elf *__elf) __attribute__ ((__pure__));


extern off_t elf_getbase (Elf *__elf);



extern char *elf_getident (Elf *__elf, size_t *__ptr);


extern Elf32_Ehdr *elf32_getehdr (Elf *__elf);

extern Elf64_Ehdr *elf64_getehdr (Elf *__elf);


extern Elf32_Ehdr *elf32_newehdr (Elf *__elf);

extern Elf64_Ehdr *elf64_newehdr (Elf *__elf);


extern Elf32_Phdr *elf32_getphdr (Elf *__elf);

extern Elf64_Phdr *elf64_getphdr (Elf *__elf);


extern Elf32_Phdr *elf32_newphdr (Elf *__elf, size_t __cnt);

extern Elf64_Phdr *elf64_newphdr (Elf *__elf, size_t __cnt);



extern Elf_Scn *elf_getscn (Elf *__elf, size_t __index);


extern Elf_Scn *elf32_offscn (Elf *__elf, Elf32_Off __offset);

extern Elf_Scn *elf64_offscn (Elf *__elf, Elf64_Off __offset);


extern size_t elf_ndxscn (Elf_Scn *__scn);


extern Elf_Scn *elf_nextscn (Elf *__elf, Elf_Scn *__scn);


extern Elf_Scn *elf_newscn (Elf *__elf);





extern int elf_getshnum (Elf *__elf, size_t *__dst);






extern int elf_getshstrndx (Elf *__elf, size_t *__dst);



extern Elf32_Shdr *elf32_getshdr (Elf_Scn *__scn);

extern Elf64_Shdr *elf64_getshdr (Elf_Scn *__scn);



extern unsigned int elf_flagelf (Elf *__elf, Elf_Cmd __cmd,
                                 unsigned int __flags);

extern unsigned int elf_flagehdr (Elf *__elf, Elf_Cmd __cmd,
                                  unsigned int __flags);

extern unsigned int elf_flagphdr (Elf *__elf, Elf_Cmd __cmd,
                                  unsigned int __flags);

extern unsigned int elf_flagscn (Elf_Scn *__scn, Elf_Cmd __cmd,
                                 unsigned int __flags);

extern unsigned int elf_flagdata (Elf_Data *__data, Elf_Cmd __cmd,
                                  unsigned int __flags);

extern unsigned int elf_flagshdr (Elf_Scn *__scn, Elf_Cmd __cmd,
                                  unsigned int __flags);




extern Elf_Data *elf_getdata (Elf_Scn *__scn, Elf_Data *__data);


extern Elf_Data *elf_rawdata (Elf_Scn *__scn, Elf_Data *__data);


extern Elf_Data *elf_newdata (Elf_Scn *__scn);



extern char *elf_strptr (Elf *__elf, size_t __index, size_t __offset);



extern Elf_Arhdr *elf_getarhdr (Elf *__elf);


extern off_t elf_getaroff (Elf *__elf);


extern size_t elf_rand (Elf *__elf, size_t __offset);


extern Elf_Arsym *elf_getarsym (Elf *__elf, size_t *__ptr);



extern int elf_cntl (Elf *__elf, Elf_Cmd __cmd);


extern char *elf_rawfile (Elf *__elf, size_t *__ptr);





extern size_t elf32_fsize (Elf_Type __type, size_t __count,
                           unsigned int __version)
       __attribute__ ((__const__));

extern size_t elf64_fsize (Elf_Type __type, size_t __count,
                           unsigned int __version)
       __attribute__ ((__const__));




extern Elf_Data *elf32_xlatetom (Elf_Data *__dest, const Elf_Data *__src,
                                 unsigned int __encode);

extern Elf_Data *elf64_xlatetom (Elf_Data *__dest, const Elf_Data *__src,
                                 unsigned int __encode);



extern Elf_Data *elf32_xlatetof (Elf_Data *__dest, const Elf_Data *__src,
                                 unsigned int __encode);

extern Elf_Data *elf64_xlatetof (Elf_Data *__dest, const Elf_Data *__src,
                                 unsigned int __encode);




extern int elf_errno (void);





extern const char *elf_errmsg (int __error);



extern unsigned int elf_version (unsigned int __version);


extern void elf_fill (int __fill);


extern unsigned long int elf_hash (const char *__string)
       __attribute__ ((__pure__));



extern long int elf32_checksum (Elf *__elf);

extern long int elf64_checksum (Elf *__elf);
# 21 "../libelf/gelf.h" 2
# 32 "../libelf/gelf.h"
typedef Elf64_Half GElf_Half;


typedef Elf64_Word GElf_Word;
typedef Elf64_Sword GElf_Sword;


typedef Elf64_Xword GElf_Xword;
typedef Elf64_Sxword GElf_Sxword;


typedef Elf64_Addr GElf_Addr;


typedef Elf64_Off GElf_Off;



typedef Elf64_Ehdr GElf_Ehdr;


typedef Elf64_Shdr GElf_Shdr;




typedef Elf64_Section GElf_Section;


typedef Elf64_Sym GElf_Sym;



typedef Elf64_Syminfo GElf_Syminfo;


typedef Elf64_Rel GElf_Rel;


typedef Elf64_Rela GElf_Rela;


typedef Elf64_Phdr GElf_Phdr;


typedef Elf64_Dyn GElf_Dyn;



typedef Elf64_Verdef GElf_Verdef;


typedef Elf64_Verdaux GElf_Verdaux;


typedef Elf64_Verneed GElf_Verneed;


typedef Elf64_Vernaux GElf_Vernaux;



typedef Elf64_Versym GElf_Versym;



typedef Elf64_auxv_t GElf_auxv_t;



typedef Elf64_Nhdr GElf_Nhdr;



typedef Elf64_Move GElf_Move;



typedef Elf64_Lib GElf_Lib;




#define GELF_ST_BIND(val) ELF64_ST_BIND (val)
#define GELF_ST_TYPE(val) ELF64_ST_TYPE (val)
#define GELF_ST_INFO(bind,type) ELF64_ST_INFO (bind, type)



#define GELF_ST_VISIBILITY(val) ELF64_ST_VISIBILITY (val)




#define GELF_R_SYM(info) ELF64_R_SYM (info)
#define GELF_R_TYPE(info) ELF64_R_TYPE (info)
#define GELF_R_INFO(sym,type) ELF64_R_INFO (sym, type)



#define GELF_M_SYM(info) ELF64_M_SYM (info)
#define GELF_M_SIZE(info) ELF64_M_SIZE (info)
#define GELF_M_INFO(sym,size) ELF64_M_INFO (sym, size)



extern int gelf_getclass (Elf *__elf);





extern size_t gelf_fsize (Elf *__elf, Elf_Type __type, size_t __count,
                          unsigned int __version);


extern GElf_Ehdr *gelf_getehdr (Elf *__elf, GElf_Ehdr *__dest);


extern int gelf_update_ehdr (Elf *__elf, GElf_Ehdr *__src);


extern unsigned long int gelf_newehdr (Elf *__elf, int __class);


extern Elf_Scn *gelf_offscn (Elf *__elf, GElf_Off __offset);


extern GElf_Shdr *gelf_getshdr (Elf_Scn *__scn, GElf_Shdr *__dst);


extern int gelf_update_shdr (Elf_Scn *__scn, GElf_Shdr *__src);


extern GElf_Phdr *gelf_getphdr (Elf *__elf, int __ndx, GElf_Phdr *__dst);


extern int gelf_update_phdr (Elf *__elf, int __ndx, GElf_Phdr *__src);


extern unsigned long int gelf_newphdr (Elf *__elf, size_t __phnum);




extern Elf_Data *gelf_xlatetom (Elf *__elf, Elf_Data *__dest,
                                const Elf_Data *__src, unsigned int __encode);



extern Elf_Data *gelf_xlatetof (Elf *__elf, Elf_Data *__dest,
                                const Elf_Data *__src, unsigned int __encode);



extern GElf_Rel *gelf_getrel (Elf_Data *__data, int __ndx, GElf_Rel *__dst);


extern GElf_Rela *gelf_getrela (Elf_Data *__data, int __ndx, GElf_Rela *__dst);


extern int gelf_update_rel (Elf_Data *__dst, int __ndx, GElf_Rel *__src);


extern int gelf_update_rela (Elf_Data *__dst, int __ndx, GElf_Rela *__src);



extern GElf_Sym *gelf_getsym (Elf_Data *__data, int __ndx, GElf_Sym *__dst);


extern int gelf_update_sym (Elf_Data *__data, int __ndx, GElf_Sym *__src);




extern GElf_Sym *gelf_getsymshndx (Elf_Data *__symdata, Elf_Data *__shndxdata,
                                   int __ndx, GElf_Sym *__sym,
                                   Elf32_Word *__xshndx);



extern int gelf_update_symshndx (Elf_Data *__symdata, Elf_Data *__shndxdata,
                                 int __ndx, GElf_Sym *__sym,
                                 Elf32_Word __xshndx);




extern GElf_Syminfo *gelf_getsyminfo (Elf_Data *__data, int __ndx,
                                      GElf_Syminfo *__dst);



extern int gelf_update_syminfo (Elf_Data *__data, int __ndx,
                                GElf_Syminfo *__src);



extern GElf_Dyn *gelf_getdyn (Elf_Data *__data, int __ndx, GElf_Dyn *__dst);


extern int gelf_update_dyn (Elf_Data *__dst, int __ndx, GElf_Dyn *__src);



extern GElf_Move *gelf_getmove (Elf_Data *__data, int __ndx, GElf_Move *__dst);


extern int gelf_update_move (Elf_Data *__data, int __ndx,
                             GElf_Move *__src);



extern GElf_Lib *gelf_getlib (Elf_Data *__data, int __ndx, GElf_Lib *__dst);


extern int gelf_update_lib (Elf_Data *__data, int __ndx, GElf_Lib *__src);




extern GElf_Versym *gelf_getversym (Elf_Data *__data, int __ndx,
                                    GElf_Versym *__dst);


extern int gelf_update_versym (Elf_Data *__data, int __ndx,
                               GElf_Versym *__src);



extern GElf_Verneed *gelf_getverneed (Elf_Data *__data, int __offset,
                                      GElf_Verneed *__dst);


extern int gelf_update_verneed (Elf_Data *__data, int __offset,
                                GElf_Verneed *__src);


extern GElf_Vernaux *gelf_getvernaux (Elf_Data *__data, int __offset,
                                      GElf_Vernaux *__dst);


extern int gelf_update_vernaux (Elf_Data *__data, int __offset,
                                GElf_Vernaux *__src);



extern GElf_Verdef *gelf_getverdef (Elf_Data *__data, int __offset,
                                    GElf_Verdef *__dst);


extern int gelf_update_verdef (Elf_Data *__data, int __offset,
                               GElf_Verdef *__src);



extern GElf_Verdaux *gelf_getverdaux (Elf_Data *__data, int __offset,
                                      GElf_Verdaux *__dst);


extern int gelf_update_verdaux (Elf_Data *__data, int __offset,
                                GElf_Verdaux *__src);



extern char *gelf_rawchunk (Elf *__elf, GElf_Off __offset, GElf_Word __size);


extern void gelf_freechunk (Elf *__elf, char *__ptr);



extern long int gelf_checksum (Elf *__elf);
# 26 "readelf.c" 2
# 1 "/usr/include/inttypes.h" 1 3 4
# 24 "/usr/include/inttypes.h" 3 4
#define _INTTYPES_H 1
# 35 "/usr/include/inttypes.h" 3 4
typedef long int __gwchar_t;





#define ____gwchar_t_defined 1
# 53 "/usr/include/inttypes.h" 3 4
#define __PRI64_PREFIX "ll"
#define __PRIPTR_PREFIX 





#define PRId8 "d"
#define PRId16 "d"
#define PRId32 "d"
#define PRId64 __PRI64_PREFIX "d"

#define PRIdLEAST8 "d"
#define PRIdLEAST16 "d"
#define PRIdLEAST32 "d"
#define PRIdLEAST64 __PRI64_PREFIX "d"

#define PRIdFAST8 "d"
#define PRIdFAST16 __PRIPTR_PREFIX "d"
#define PRIdFAST32 __PRIPTR_PREFIX "d"
#define PRIdFAST64 __PRI64_PREFIX "d"


#define PRIi8 "i"
#define PRIi16 "i"
#define PRIi32 "i"
#define PRIi64 __PRI64_PREFIX "i"

#define PRIiLEAST8 "i"
#define PRIiLEAST16 "i"
#define PRIiLEAST32 "i"
#define PRIiLEAST64 __PRI64_PREFIX "i"

#define PRIiFAST8 "i"
#define PRIiFAST16 __PRIPTR_PREFIX "i"
#define PRIiFAST32 __PRIPTR_PREFIX "i"
#define PRIiFAST64 __PRI64_PREFIX "i"


#define PRIo8 "o"
#define PRIo16 "o"
#define PRIo32 "o"
#define PRIo64 __PRI64_PREFIX "o"

#define PRIoLEAST8 "o"
#define PRIoLEAST16 "o"
#define PRIoLEAST32 "o"
#define PRIoLEAST64 __PRI64_PREFIX "o"

#define PRIoFAST8 "o"
#define PRIoFAST16 __PRIPTR_PREFIX "o"
#define PRIoFAST32 __PRIPTR_PREFIX "o"
#define PRIoFAST64 __PRI64_PREFIX "o"


#define PRIu8 "u"
#define PRIu16 "u"
#define PRIu32 "u"
#define PRIu64 __PRI64_PREFIX "u"

#define PRIuLEAST8 "u"
#define PRIuLEAST16 "u"
#define PRIuLEAST32 "u"
#define PRIuLEAST64 __PRI64_PREFIX "u"

#define PRIuFAST8 "u"
#define PRIuFAST16 __PRIPTR_PREFIX "u"
#define PRIuFAST32 __PRIPTR_PREFIX "u"
#define PRIuFAST64 __PRI64_PREFIX "u"


#define PRIx8 "x"
#define PRIx16 "x"
#define PRIx32 "x"
#define PRIx64 __PRI64_PREFIX "x"

#define PRIxLEAST8 "x"
#define PRIxLEAST16 "x"
#define PRIxLEAST32 "x"
#define PRIxLEAST64 __PRI64_PREFIX "x"

#define PRIxFAST8 "x"
#define PRIxFAST16 __PRIPTR_PREFIX "x"
#define PRIxFAST32 __PRIPTR_PREFIX "x"
#define PRIxFAST64 __PRI64_PREFIX "x"


#define PRIX8 "X"
#define PRIX16 "X"
#define PRIX32 "X"
#define PRIX64 __PRI64_PREFIX "X"

#define PRIXLEAST8 "X"
#define PRIXLEAST16 "X"
#define PRIXLEAST32 "X"
#define PRIXLEAST64 __PRI64_PREFIX "X"

#define PRIXFAST8 "X"
#define PRIXFAST16 __PRIPTR_PREFIX "X"
#define PRIXFAST32 __PRIPTR_PREFIX "X"
#define PRIXFAST64 __PRI64_PREFIX "X"



#define PRIdMAX __PRI64_PREFIX "d"
#define PRIiMAX __PRI64_PREFIX "i"
#define PRIoMAX __PRI64_PREFIX "o"
#define PRIuMAX __PRI64_PREFIX "u"
#define PRIxMAX __PRI64_PREFIX "x"
#define PRIXMAX __PRI64_PREFIX "X"



#define PRIdPTR __PRIPTR_PREFIX "d"
#define PRIiPTR __PRIPTR_PREFIX "i"
#define PRIoPTR __PRIPTR_PREFIX "o"
#define PRIuPTR __PRIPTR_PREFIX "u"
#define PRIxPTR __PRIPTR_PREFIX "x"
#define PRIXPTR __PRIPTR_PREFIX "X"





#define SCNd8 "hhd"
#define SCNd16 "hd"
#define SCNd32 "d"
#define SCNd64 __PRI64_PREFIX "d"

#define SCNdLEAST8 "hhd"
#define SCNdLEAST16 "hd"
#define SCNdLEAST32 "d"
#define SCNdLEAST64 __PRI64_PREFIX "d"

#define SCNdFAST8 "hhd"
#define SCNdFAST16 __PRIPTR_PREFIX "d"
#define SCNdFAST32 __PRIPTR_PREFIX "d"
#define SCNdFAST64 __PRI64_PREFIX "d"


#define SCNi8 "hhi"
#define SCNi16 "hi"
#define SCNi32 "i"
#define SCNi64 __PRI64_PREFIX "i"

#define SCNiLEAST8 "hhi"
#define SCNiLEAST16 "hi"
#define SCNiLEAST32 "i"
#define SCNiLEAST64 __PRI64_PREFIX "i"

#define SCNiFAST8 "hhi"
#define SCNiFAST16 __PRIPTR_PREFIX "i"
#define SCNiFAST32 __PRIPTR_PREFIX "i"
#define SCNiFAST64 __PRI64_PREFIX "i"


#define SCNu8 "hhu"
#define SCNu16 "hu"
#define SCNu32 "u"
#define SCNu64 __PRI64_PREFIX "u"

#define SCNuLEAST8 "hhu"
#define SCNuLEAST16 "hu"
#define SCNuLEAST32 "u"
#define SCNuLEAST64 __PRI64_PREFIX "u"

#define SCNuFAST8 "hhu"
#define SCNuFAST16 __PRIPTR_PREFIX "u"
#define SCNuFAST32 __PRIPTR_PREFIX "u"
#define SCNuFAST64 __PRI64_PREFIX "u"


#define SCNo8 "hho"
#define SCNo16 "ho"
#define SCNo32 "o"
#define SCNo64 __PRI64_PREFIX "o"

#define SCNoLEAST8 "hho"
#define SCNoLEAST16 "ho"
#define SCNoLEAST32 "o"
#define SCNoLEAST64 __PRI64_PREFIX "o"

#define SCNoFAST8 "hho"
#define SCNoFAST16 __PRIPTR_PREFIX "o"
#define SCNoFAST32 __PRIPTR_PREFIX "o"
#define SCNoFAST64 __PRI64_PREFIX "o"


#define SCNx8 "hhx"
#define SCNx16 "hx"
#define SCNx32 "x"
#define SCNx64 __PRI64_PREFIX "x"

#define SCNxLEAST8 "hhx"
#define SCNxLEAST16 "hx"
#define SCNxLEAST32 "x"
#define SCNxLEAST64 __PRI64_PREFIX "x"

#define SCNxFAST8 "hhx"
#define SCNxFAST16 __PRIPTR_PREFIX "x"
#define SCNxFAST32 __PRIPTR_PREFIX "x"
#define SCNxFAST64 __PRI64_PREFIX "x"



#define SCNdMAX __PRI64_PREFIX "d"
#define SCNiMAX __PRI64_PREFIX "i"
#define SCNoMAX __PRI64_PREFIX "o"
#define SCNuMAX __PRI64_PREFIX "u"
#define SCNxMAX __PRI64_PREFIX "x"


#define SCNdPTR __PRIPTR_PREFIX "d"
#define SCNiPTR __PRIPTR_PREFIX "i"
#define SCNoPTR __PRIPTR_PREFIX "o"
#define SCNuPTR __PRIPTR_PREFIX "u"
#define SCNxPTR __PRIPTR_PREFIX "x"





# 288 "/usr/include/inttypes.h" 3 4
typedef struct
  {
    long long int quot;
    long long int rem;
  } imaxdiv_t;





extern intmax_t imaxabs (intmax_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__const__));


extern imaxdiv_t imaxdiv (intmax_t __numer, intmax_t __denom)
      __attribute__ ((__nothrow__)) __attribute__ ((__const__));


extern intmax_t strtoimax (const char *__restrict __nptr,
                           char **__restrict __endptr, int __base) __attribute__ ((__nothrow__));


extern uintmax_t strtoumax (const char *__restrict __nptr,
                            char ** __restrict __endptr, int __base) __attribute__ ((__nothrow__));


extern intmax_t wcstoimax (const __gwchar_t *__restrict __nptr,
                           __gwchar_t **__restrict __endptr, int __base)
     __attribute__ ((__nothrow__));


extern uintmax_t wcstoumax (const __gwchar_t *__restrict __nptr,
                            __gwchar_t ** __restrict __endptr, int __base)
     __attribute__ ((__nothrow__));
# 390 "/usr/include/inttypes.h" 3 4
__extension__
extern long long int __strtoll_internal (const char *__restrict __nptr,
                                         char **__restrict __endptr,
                                         int __base, int __group) __attribute__ ((__nothrow__));
#define __strtoll_internal_defined 1

extern __inline intmax_t
__attribute__ ((__nothrow__)) strtoimax (const char *__restrict nptr, char **__restrict endptr, int base)

{
  return __strtoll_internal (nptr, endptr, base, 0);
}



__extension__
extern unsigned long long int __strtoull_internal (const char *
                                                   __restrict __nptr,
                                                   char **
                                                   __restrict __endptr,
                                                   int __base,
                                                   int __group) __attribute__ ((__nothrow__));
#define __strtoull_internal_defined 1

extern __inline uintmax_t
__attribute__ ((__nothrow__)) strtoumax (const char *__restrict nptr, char **__restrict endptr, int base)

{
  return __strtoull_internal (nptr, endptr, base, 0);
}



__extension__
extern long long int __wcstoll_internal (const __gwchar_t *
                                         __restrict __nptr,
                                         __gwchar_t **__restrict __endptr,
                                         int __base, int __group) __attribute__ ((__nothrow__));
#define __wcstoll_internal_defined 1

extern __inline intmax_t
__attribute__ ((__nothrow__)) wcstoimax (const __gwchar_t *__restrict nptr, __gwchar_t **__restrict endptr, int base)

{
  return __wcstoll_internal (nptr, endptr, base, 0);
}




__extension__
extern unsigned long long int __wcstoull_internal (const __gwchar_t *
                                                   __restrict __nptr,
                                                   __gwchar_t **
                                                   __restrict __endptr,
                                                   int __base,
                                                   int __group) __attribute__ ((__nothrow__));
#define __wcstoull_internal_defined 1

extern __inline uintmax_t
__attribute__ ((__nothrow__)) wcstoumax (const __gwchar_t *__restrict nptr, __gwchar_t **__restrict endptr, int base)

{
  return __wcstoull_internal (nptr, endptr, base, 0);
}





# 27 "readelf.c" 2
# 1 "/usr/include/langinfo.h" 1 3 4
# 21 "/usr/include/langinfo.h" 3 4
#define _LANGINFO_H 1


# 1 "/usr/include/nl_types.h" 1 3 4
# 20 "/usr/include/nl_types.h" 3 4
#define _NL_TYPES_H 1




#define NL_SETD 1


#define NL_CAT_LOCALE 1





typedef void *nl_catd;


typedef int nl_item;





extern nl_catd catopen (const char *__cat_name, int __flag) __attribute__ ((__nonnull__ (1)));



extern char *catgets (nl_catd __catalog, int __set, int __number,
                      const char *__string) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));


extern int catclose (nl_catd __catalog) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));


# 25 "/usr/include/langinfo.h" 2 3 4

# 1 "/usr/include/bits/locale.h" 1 3 4
# 25 "/usr/include/bits/locale.h" 3 4
#define _BITS_LOCALE_H 1

enum
{
  __LC_CTYPE = 0,
  __LC_NUMERIC = 1,
  __LC_TIME = 2,
  __LC_COLLATE = 3,
  __LC_MONETARY = 4,
  __LC_MESSAGES = 5,
  __LC_ALL = 6,
  __LC_PAPER = 7,
  __LC_NAME = 8,
  __LC_ADDRESS = 9,
  __LC_TELEPHONE = 10,
  __LC_MEASUREMENT = 11,
  __LC_IDENTIFICATION = 12
};
# 27 "/usr/include/langinfo.h" 2 3 4








#define _NL_ITEM(category,index) (((category) << 16) | (index))


#define _NL_ITEM_CATEGORY(item) ((int) (item) >> 16)
#define _NL_ITEM_INDEX(item) ((int) (item) & 0xffff)



enum
{



  ABDAY_1 = (((__LC_TIME) << 16) | (0)),
#define ABDAY_1 ABDAY_1
  ABDAY_2,
#define ABDAY_2 ABDAY_2
  ABDAY_3,
#define ABDAY_3 ABDAY_3
  ABDAY_4,
#define ABDAY_4 ABDAY_4
  ABDAY_5,
#define ABDAY_5 ABDAY_5
  ABDAY_6,
#define ABDAY_6 ABDAY_6
  ABDAY_7,
#define ABDAY_7 ABDAY_7


  DAY_1,
#define DAY_1 DAY_1
  DAY_2,
#define DAY_2 DAY_2
  DAY_3,
#define DAY_3 DAY_3
  DAY_4,
#define DAY_4 DAY_4
  DAY_5,
#define DAY_5 DAY_5
  DAY_6,
#define DAY_6 DAY_6
  DAY_7,
#define DAY_7 DAY_7


  ABMON_1,
#define ABMON_1 ABMON_1
  ABMON_2,
#define ABMON_2 ABMON_2
  ABMON_3,
#define ABMON_3 ABMON_3
  ABMON_4,
#define ABMON_4 ABMON_4
  ABMON_5,
#define ABMON_5 ABMON_5
  ABMON_6,
#define ABMON_6 ABMON_6
  ABMON_7,
#define ABMON_7 ABMON_7
  ABMON_8,
#define ABMON_8 ABMON_8
  ABMON_9,
#define ABMON_9 ABMON_9
  ABMON_10,
#define ABMON_10 ABMON_10
  ABMON_11,
#define ABMON_11 ABMON_11
  ABMON_12,
#define ABMON_12 ABMON_12


  MON_1,
#define MON_1 MON_1
  MON_2,
#define MON_2 MON_2
  MON_3,
#define MON_3 MON_3
  MON_4,
#define MON_4 MON_4
  MON_5,
#define MON_5 MON_5
  MON_6,
#define MON_6 MON_6
  MON_7,
#define MON_7 MON_7
  MON_8,
#define MON_8 MON_8
  MON_9,
#define MON_9 MON_9
  MON_10,
#define MON_10 MON_10
  MON_11,
#define MON_11 MON_11
  MON_12,
#define MON_12 MON_12

  AM_STR,
#define AM_STR AM_STR
  PM_STR,
#define PM_STR PM_STR

  D_T_FMT,
#define D_T_FMT D_T_FMT
  D_FMT,
#define D_FMT D_FMT
  T_FMT,
#define T_FMT T_FMT
  T_FMT_AMPM,
#define T_FMT_AMPM T_FMT_AMPM

  ERA,
#define ERA ERA
  __ERA_YEAR,

#define ERA_YEAR __ERA_YEAR

  ERA_D_FMT,
#define ERA_D_FMT ERA_D_FMT
  ALT_DIGITS,
#define ALT_DIGITS ALT_DIGITS
  ERA_D_T_FMT,
#define ERA_D_T_FMT ERA_D_T_FMT
  ERA_T_FMT,
#define ERA_T_FMT ERA_T_FMT

  _NL_TIME_ERA_NUM_ENTRIES,
  _NL_TIME_ERA_ENTRIES,

  _NL_WABDAY_1,
  _NL_WABDAY_2,
  _NL_WABDAY_3,
  _NL_WABDAY_4,
  _NL_WABDAY_5,
  _NL_WABDAY_6,
  _NL_WABDAY_7,


  _NL_WDAY_1,
  _NL_WDAY_2,
  _NL_WDAY_3,
  _NL_WDAY_4,
  _NL_WDAY_5,
  _NL_WDAY_6,
  _NL_WDAY_7,


  _NL_WABMON_1,
  _NL_WABMON_2,
  _NL_WABMON_3,
  _NL_WABMON_4,
  _NL_WABMON_5,
  _NL_WABMON_6,
  _NL_WABMON_7,
  _NL_WABMON_8,
  _NL_WABMON_9,
  _NL_WABMON_10,
  _NL_WABMON_11,
  _NL_WABMON_12,


  _NL_WMON_1,
  _NL_WMON_2,
  _NL_WMON_3,
  _NL_WMON_4,
  _NL_WMON_5,
  _NL_WMON_6,
  _NL_WMON_7,
  _NL_WMON_8,
  _NL_WMON_9,
  _NL_WMON_10,
  _NL_WMON_11,
  _NL_WMON_12,

  _NL_WAM_STR,
  _NL_WPM_STR,

  _NL_WD_T_FMT,
  _NL_WD_FMT,
  _NL_WT_FMT,
  _NL_WT_FMT_AMPM,

  _NL_WERA_YEAR,
  _NL_WERA_D_FMT,
  _NL_WALT_DIGITS,
  _NL_WERA_D_T_FMT,
  _NL_WERA_T_FMT,

  _NL_TIME_WEEK_NDAYS,
  _NL_TIME_WEEK_1STDAY,
  _NL_TIME_WEEK_1STWEEK,
  _NL_TIME_FIRST_WEEKDAY,
  _NL_TIME_FIRST_WORKDAY,
  _NL_TIME_CAL_DIRECTION,
  _NL_TIME_TIMEZONE,

  _DATE_FMT,
#define _DATE_FMT _DATE_FMT
  _NL_W_DATE_FMT,

  _NL_TIME_CODESET,

  _NL_NUM_LC_TIME,




  _NL_COLLATE_NRULES = (((__LC_COLLATE) << 16) | (0)),
  _NL_COLLATE_RULESETS,
  _NL_COLLATE_TABLEMB,
  _NL_COLLATE_WEIGHTMB,
  _NL_COLLATE_EXTRAMB,
  _NL_COLLATE_INDIRECTMB,
  _NL_COLLATE_GAP1,
  _NL_COLLATE_GAP2,
  _NL_COLLATE_GAP3,
  _NL_COLLATE_TABLEWC,
  _NL_COLLATE_WEIGHTWC,
  _NL_COLLATE_EXTRAWC,
  _NL_COLLATE_INDIRECTWC,
  _NL_COLLATE_SYMB_HASH_SIZEMB,
  _NL_COLLATE_SYMB_TABLEMB,
  _NL_COLLATE_SYMB_EXTRAMB,
  _NL_COLLATE_COLLSEQMB,
  _NL_COLLATE_COLLSEQWC,
  _NL_COLLATE_CODESET,
  _NL_NUM_LC_COLLATE,




  _NL_CTYPE_CLASS = (((__LC_CTYPE) << 16) | (0)),
  _NL_CTYPE_TOUPPER,
  _NL_CTYPE_GAP1,
  _NL_CTYPE_TOLOWER,
  _NL_CTYPE_GAP2,
  _NL_CTYPE_CLASS32,
  _NL_CTYPE_GAP3,
  _NL_CTYPE_GAP4,
  _NL_CTYPE_GAP5,
  _NL_CTYPE_GAP6,
  _NL_CTYPE_CLASS_NAMES,
  _NL_CTYPE_MAP_NAMES,
  _NL_CTYPE_WIDTH,
  _NL_CTYPE_MB_CUR_MAX,
  _NL_CTYPE_CODESET_NAME,
  CODESET = _NL_CTYPE_CODESET_NAME,
#define CODESET CODESET
  _NL_CTYPE_TOUPPER32,
  _NL_CTYPE_TOLOWER32,
  _NL_CTYPE_CLASS_OFFSET,
  _NL_CTYPE_MAP_OFFSET,
  _NL_CTYPE_INDIGITS_MB_LEN,
  _NL_CTYPE_INDIGITS0_MB,
  _NL_CTYPE_INDIGITS1_MB,
  _NL_CTYPE_INDIGITS2_MB,
  _NL_CTYPE_INDIGITS3_MB,
  _NL_CTYPE_INDIGITS4_MB,
  _NL_CTYPE_INDIGITS5_MB,
  _NL_CTYPE_INDIGITS6_MB,
  _NL_CTYPE_INDIGITS7_MB,
  _NL_CTYPE_INDIGITS8_MB,
  _NL_CTYPE_INDIGITS9_MB,
  _NL_CTYPE_INDIGITS_WC_LEN,
  _NL_CTYPE_INDIGITS0_WC,
  _NL_CTYPE_INDIGITS1_WC,
  _NL_CTYPE_INDIGITS2_WC,
  _NL_CTYPE_INDIGITS3_WC,
  _NL_CTYPE_INDIGITS4_WC,
  _NL_CTYPE_INDIGITS5_WC,
  _NL_CTYPE_INDIGITS6_WC,
  _NL_CTYPE_INDIGITS7_WC,
  _NL_CTYPE_INDIGITS8_WC,
  _NL_CTYPE_INDIGITS9_WC,
  _NL_CTYPE_OUTDIGIT0_MB,
  _NL_CTYPE_OUTDIGIT1_MB,
  _NL_CTYPE_OUTDIGIT2_MB,
  _NL_CTYPE_OUTDIGIT3_MB,
  _NL_CTYPE_OUTDIGIT4_MB,
  _NL_CTYPE_OUTDIGIT5_MB,
  _NL_CTYPE_OUTDIGIT6_MB,
  _NL_CTYPE_OUTDIGIT7_MB,
  _NL_CTYPE_OUTDIGIT8_MB,
  _NL_CTYPE_OUTDIGIT9_MB,
  _NL_CTYPE_OUTDIGIT0_WC,
  _NL_CTYPE_OUTDIGIT1_WC,
  _NL_CTYPE_OUTDIGIT2_WC,
  _NL_CTYPE_OUTDIGIT3_WC,
  _NL_CTYPE_OUTDIGIT4_WC,
  _NL_CTYPE_OUTDIGIT5_WC,
  _NL_CTYPE_OUTDIGIT6_WC,
  _NL_CTYPE_OUTDIGIT7_WC,
  _NL_CTYPE_OUTDIGIT8_WC,
  _NL_CTYPE_OUTDIGIT9_WC,
  _NL_CTYPE_TRANSLIT_TAB_SIZE,
  _NL_CTYPE_TRANSLIT_FROM_IDX,
  _NL_CTYPE_TRANSLIT_FROM_TBL,
  _NL_CTYPE_TRANSLIT_TO_IDX,
  _NL_CTYPE_TRANSLIT_TO_TBL,
  _NL_CTYPE_TRANSLIT_DEFAULT_MISSING_LEN,
  _NL_CTYPE_TRANSLIT_DEFAULT_MISSING,
  _NL_CTYPE_TRANSLIT_IGNORE_LEN,
  _NL_CTYPE_TRANSLIT_IGNORE,
  _NL_CTYPE_MAP_TO_NONASCII,
  _NL_CTYPE_EXTRA_MAP_1,
  _NL_CTYPE_EXTRA_MAP_2,
  _NL_CTYPE_EXTRA_MAP_3,
  _NL_CTYPE_EXTRA_MAP_4,
  _NL_CTYPE_EXTRA_MAP_5,
  _NL_CTYPE_EXTRA_MAP_6,
  _NL_CTYPE_EXTRA_MAP_7,
  _NL_CTYPE_EXTRA_MAP_8,
  _NL_CTYPE_EXTRA_MAP_9,
  _NL_CTYPE_EXTRA_MAP_10,
  _NL_CTYPE_EXTRA_MAP_11,
  _NL_CTYPE_EXTRA_MAP_12,
  _NL_CTYPE_EXTRA_MAP_13,
  _NL_CTYPE_EXTRA_MAP_14,
  _NL_NUM_LC_CTYPE,




  __INT_CURR_SYMBOL = (((__LC_MONETARY) << 16) | (0)),

#define INT_CURR_SYMBOL __INT_CURR_SYMBOL

  __CURRENCY_SYMBOL,

#define CURRENCY_SYMBOL __CURRENCY_SYMBOL

  __MON_DECIMAL_POINT,

#define MON_DECIMAL_POINT __MON_DECIMAL_POINT

  __MON_THOUSANDS_SEP,

#define MON_THOUSANDS_SEP __MON_THOUSANDS_SEP

  __MON_GROUPING,

#define MON_GROUPING __MON_GROUPING

  __POSITIVE_SIGN,

#define POSITIVE_SIGN __POSITIVE_SIGN

  __NEGATIVE_SIGN,

#define NEGATIVE_SIGN __NEGATIVE_SIGN

  __INT_FRAC_DIGITS,

#define INT_FRAC_DIGITS __INT_FRAC_DIGITS

  __FRAC_DIGITS,

#define FRAC_DIGITS __FRAC_DIGITS

  __P_CS_PRECEDES,

#define P_CS_PRECEDES __P_CS_PRECEDES

  __P_SEP_BY_SPACE,

#define P_SEP_BY_SPACE __P_SEP_BY_SPACE

  __N_CS_PRECEDES,

#define N_CS_PRECEDES __N_CS_PRECEDES

  __N_SEP_BY_SPACE,

#define N_SEP_BY_SPACE __N_SEP_BY_SPACE

  __P_SIGN_POSN,

#define P_SIGN_POSN __P_SIGN_POSN

  __N_SIGN_POSN,

#define N_SIGN_POSN __N_SIGN_POSN

  _NL_MONETARY_CRNCYSTR,
#define CRNCYSTR _NL_MONETARY_CRNCYSTR
  __INT_P_CS_PRECEDES,

#define INT_P_CS_PRECEDES __INT_P_CS_PRECEDES

  __INT_P_SEP_BY_SPACE,

#define INT_P_SEP_BY_SPACE __INT_P_SEP_BY_SPACE

  __INT_N_CS_PRECEDES,

#define INT_N_CS_PRECEDES __INT_N_CS_PRECEDES

  __INT_N_SEP_BY_SPACE,

#define INT_N_SEP_BY_SPACE __INT_N_SEP_BY_SPACE

  __INT_P_SIGN_POSN,

#define INT_P_SIGN_POSN __INT_P_SIGN_POSN

  __INT_N_SIGN_POSN,

#define INT_N_SIGN_POSN __INT_N_SIGN_POSN

  _NL_MONETARY_DUO_INT_CURR_SYMBOL,
  _NL_MONETARY_DUO_CURRENCY_SYMBOL,
  _NL_MONETARY_DUO_INT_FRAC_DIGITS,
  _NL_MONETARY_DUO_FRAC_DIGITS,
  _NL_MONETARY_DUO_P_CS_PRECEDES,
  _NL_MONETARY_DUO_P_SEP_BY_SPACE,
  _NL_MONETARY_DUO_N_CS_PRECEDES,
  _NL_MONETARY_DUO_N_SEP_BY_SPACE,
  _NL_MONETARY_DUO_INT_P_CS_PRECEDES,
  _NL_MONETARY_DUO_INT_P_SEP_BY_SPACE,
  _NL_MONETARY_DUO_INT_N_CS_PRECEDES,
  _NL_MONETARY_DUO_INT_N_SEP_BY_SPACE,
  _NL_MONETARY_DUO_P_SIGN_POSN,
  _NL_MONETARY_DUO_N_SIGN_POSN,
  _NL_MONETARY_DUO_INT_P_SIGN_POSN,
  _NL_MONETARY_DUO_INT_N_SIGN_POSN,
  _NL_MONETARY_UNO_VALID_FROM,
  _NL_MONETARY_UNO_VALID_TO,
  _NL_MONETARY_DUO_VALID_FROM,
  _NL_MONETARY_DUO_VALID_TO,
  _NL_MONETARY_CONVERSION_RATE,
  _NL_MONETARY_DECIMAL_POINT_WC,
  _NL_MONETARY_THOUSANDS_SEP_WC,
  _NL_MONETARY_CODESET,
  _NL_NUM_LC_MONETARY,



  __DECIMAL_POINT = (((__LC_NUMERIC) << 16) | (0)),

#define DECIMAL_POINT __DECIMAL_POINT

  RADIXCHAR = __DECIMAL_POINT,
#define RADIXCHAR RADIXCHAR
  __THOUSANDS_SEP,

#define THOUSANDS_SEP __THOUSANDS_SEP

  THOUSEP = __THOUSANDS_SEP,
#define THOUSEP THOUSEP
  __GROUPING,

#define GROUPING __GROUPING

  _NL_NUMERIC_DECIMAL_POINT_WC,
  _NL_NUMERIC_THOUSANDS_SEP_WC,
  _NL_NUMERIC_CODESET,
  _NL_NUM_LC_NUMERIC,

  __YESEXPR = (((__LC_MESSAGES) << 16) | (0)),
#define YESEXPR __YESEXPR
  __NOEXPR,
#define NOEXPR __NOEXPR
  __YESSTR,

#define YESSTR __YESSTR

  __NOSTR,

#define NOSTR __NOSTR

  _NL_MESSAGES_CODESET,
  _NL_NUM_LC_MESSAGES,

  _NL_PAPER_HEIGHT = (((__LC_PAPER) << 16) | (0)),
  _NL_PAPER_WIDTH,
  _NL_PAPER_CODESET,
  _NL_NUM_LC_PAPER,

  _NL_NAME_NAME_FMT = (((__LC_NAME) << 16) | (0)),
  _NL_NAME_NAME_GEN,
  _NL_NAME_NAME_MR,
  _NL_NAME_NAME_MRS,
  _NL_NAME_NAME_MISS,
  _NL_NAME_NAME_MS,
  _NL_NAME_CODESET,
  _NL_NUM_LC_NAME,

  _NL_ADDRESS_POSTAL_FMT = (((__LC_ADDRESS) << 16) | (0)),
  _NL_ADDRESS_COUNTRY_NAME,
  _NL_ADDRESS_COUNTRY_POST,
  _NL_ADDRESS_COUNTRY_AB2,
  _NL_ADDRESS_COUNTRY_AB3,
  _NL_ADDRESS_COUNTRY_CAR,
  _NL_ADDRESS_COUNTRY_NUM,
  _NL_ADDRESS_COUNTRY_ISBN,
  _NL_ADDRESS_LANG_NAME,
  _NL_ADDRESS_LANG_AB,
  _NL_ADDRESS_LANG_TERM,
  _NL_ADDRESS_LANG_LIB,
  _NL_ADDRESS_CODESET,
  _NL_NUM_LC_ADDRESS,

  _NL_TELEPHONE_TEL_INT_FMT = (((__LC_TELEPHONE) << 16) | (0)),
  _NL_TELEPHONE_TEL_DOM_FMT,
  _NL_TELEPHONE_INT_SELECT,
  _NL_TELEPHONE_INT_PREFIX,
  _NL_TELEPHONE_CODESET,
  _NL_NUM_LC_TELEPHONE,

  _NL_MEASUREMENT_MEASUREMENT = (((__LC_MEASUREMENT) << 16) | (0)),
  _NL_MEASUREMENT_CODESET,
  _NL_NUM_LC_MEASUREMENT,

  _NL_IDENTIFICATION_TITLE = (((__LC_IDENTIFICATION) << 16) | (0)),
  _NL_IDENTIFICATION_SOURCE,
  _NL_IDENTIFICATION_ADDRESS,
  _NL_IDENTIFICATION_CONTACT,
  _NL_IDENTIFICATION_EMAIL,
  _NL_IDENTIFICATION_TEL,
  _NL_IDENTIFICATION_FAX,
  _NL_IDENTIFICATION_LANGUAGE,
  _NL_IDENTIFICATION_TERRITORY,
  _NL_IDENTIFICATION_AUDIENCE,
  _NL_IDENTIFICATION_APPLICATION,
  _NL_IDENTIFICATION_ABBREVIATION,
  _NL_IDENTIFICATION_REVISION,
  _NL_IDENTIFICATION_DATE,
  _NL_IDENTIFICATION_CATEGORY,
  _NL_IDENTIFICATION_CODESET,
  _NL_NUM_LC_IDENTIFICATION,


  _NL_NUM
};
# 576 "/usr/include/langinfo.h" 3 4
extern char *nl_langinfo (nl_item __item) __attribute__ ((__nothrow__));
# 587 "/usr/include/langinfo.h" 3 4
extern char *nl_langinfo_l (nl_item __item, __locale_t l);



# 28 "readelf.c" 2
# 1 "../libdw/libdw.h" 1
# 16 "../libdw/libdw.h"
#define _LIBDW_H 1


# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stdbool.h" 1 3 4
# 32 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stdbool.h" 3 4
#define _STDBOOL_H 



#define bool _Bool
#define true 1
#define false 0
# 51 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stdbool.h" 3 4
#define __bool_true_false_are_defined 1
# 20 "../libdw/libdw.h" 2
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 1 3 4
# 42 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#define _STDDEF_H 
#define _STDDEF_H_ 

#define _ANSI_STDDEF_H 

#define __STDDEF_H__ 
# 140 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#define _PTRDIFF_T 
#define _T_PTRDIFF_ 
#define _T_PTRDIFF 
#define __PTRDIFF_T 
#define _PTRDIFF_T_ 
#define _BSD_PTRDIFF_T_ 
#define ___int_ptrdiff_t_h 
#define _GCC_PTRDIFF_T 



typedef int ptrdiff_t;
# 397 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#undef NULL




#define NULL ((void *)0)
# 414 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#define offsetof(TYPE,MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
# 21 "../libdw/libdw.h" 2



#define __nonnull_attribute__(...) __attribute__ ((__nonnull__ (__VA_ARGS__)))






typedef enum
  {
    DWARF_C_READ,
    DWARF_C_RDWR,
    DWARF_C_WRITE,
  }
Dwarf_Cmd;



enum
{
  DWARF_CB_OK = 0,
  DWARF_CB_ABORT
};



enum
  {
    DW_TAG_invalid = 0
#define DW_TAG_invalid DW_TAG_invalid
  };



typedef GElf_Off Dwarf_Off;


typedef GElf_Addr Dwarf_Addr;


typedef GElf_Xword Dwarf_Word;
typedef GElf_Sxword Dwarf_Sword;

typedef GElf_Half Dwarf_Half;



typedef struct Dwarf_Abbrev Dwarf_Abbrev;


#define DWARF_END_ABBREV ((Dwarf_Abbrev *) -1l)


typedef struct Dwarf_Lines_s Dwarf_Lines;


typedef struct Dwarf_Line_s Dwarf_Line;


typedef struct Dwarf_Files_s Dwarf_Files;


typedef struct Dwarf_Arange_s Dwarf_Arange;


typedef struct Dwarf_Aranges_s Dwarf_Aranges;


struct Dwarf_CU;


typedef struct Dwarf_Macro_s Dwarf_Macro;


typedef struct
{
  unsigned int code;
  unsigned int form;
  unsigned char *valp;
  struct Dwarf_CU *cu;
} Dwarf_Attribute;



typedef struct
{
  Dwarf_Word length;
  unsigned char *data;
} Dwarf_Block;



typedef struct
{

  void *addr;
  struct Dwarf_CU *cu;
  Dwarf_Abbrev *abbrev;

  long int padding__;
} Dwarf_Die;


#define DWARF_END_DIE ((Dwarf_Die *) -1l)



typedef struct
{
  Dwarf_Off cu_offset;
  Dwarf_Off die_offset;
  const char *name;
} Dwarf_Global;




typedef struct
{
  uint8_t atom;
  Dwarf_Word number;
  Dwarf_Word number2;
  Dwarf_Word offset;
} Dwarf_Op;



typedef struct Dwarf Dwarf;




typedef void (*Dwarf_OOM) (void);






extern Dwarf *dwarf_begin (int fildes, Dwarf_Cmd cmd);


extern Dwarf *dwarf_begin_elf (Elf *elf, Dwarf_Cmd cmd, Elf_Scn *scngrp);


extern Elf *dwarf_getelf (Dwarf *dwarf);


extern int dwarf_end (Dwarf *dwarf);



extern Elf_Data *dwarf_getscn_info (Dwarf *dwarf);


extern int dwarf_nextcu (Dwarf *dwarf, Dwarf_Off off, Dwarf_Off *next_off,
                         size_t *header_sizep, Dwarf_Off *abbrev_offsetp,
                         uint8_t *address_sizep, uint8_t *offset_sizep)
     __attribute__ ((__nonnull__ (3)));



extern Dwarf_Die *dwarf_offdie (Dwarf *dbg, Dwarf_Off offset,
                                Dwarf_Die *result) __attribute__ ((__nonnull__ (3)));


extern Dwarf_Off dwarf_dieoffset (Dwarf_Die *die);


extern Dwarf_Off dwarf_cuoffset (Dwarf_Die *die);


extern Dwarf_Die *dwarf_diecu (Dwarf_Die *die, Dwarf_Die *result,
                               uint8_t *address_sizep, uint8_t *offset_sizep);


extern Dwarf_Die *dwarf_addrdie (Dwarf *dbg, Dwarf_Addr addr,
                                 Dwarf_Die *result) __attribute__ ((__nonnull__ (3)));


extern int dwarf_child (Dwarf_Die *die, Dwarf_Die *result)
     __attribute__ ((__nonnull__ (2)));


extern int dwarf_siblingof (Dwarf_Die *die, Dwarf_Die *result)
     __attribute__ ((__nonnull__ (2)));


extern int dwarf_haschildren (Dwarf_Die *die);


extern ptrdiff_t dwarf_getattrs (Dwarf_Die *die,
                                 int (*callback) (Dwarf_Attribute *, void *),
                                 void *arg, ptrdiff_t offset);


extern int dwarf_tag (Dwarf_Die *die);



extern Dwarf_Attribute *dwarf_attr (Dwarf_Die *die, unsigned int search_name,
                                    Dwarf_Attribute *result)
     __attribute__ ((__nonnull__ (3)));


extern int dwarf_hasattr (Dwarf_Die *die, unsigned int search_name);



extern Dwarf_Attribute *dwarf_attr_integrate (Dwarf_Die *die,
                                              unsigned int search_name,
                                              Dwarf_Attribute *result)
     __attribute__ ((__nonnull__ (3)));
extern int dwarf_hasattr_integrate (Dwarf_Die *die, unsigned int search_name);





extern int dwarf_hasform (Dwarf_Attribute *attr, unsigned int search_form);


extern unsigned int dwarf_whatattr (Dwarf_Attribute *attr);


extern unsigned int dwarf_whatform (Dwarf_Attribute *attr);



extern const char *dwarf_formstring (Dwarf_Attribute *attrp);


extern int dwarf_formudata (Dwarf_Attribute *attr, Dwarf_Word *return_uval)
     __attribute__ ((__nonnull__ (2)));


extern int dwarf_formsdata (Dwarf_Attribute *attr, Dwarf_Sword *return_uval)
     __attribute__ ((__nonnull__ (2)));


extern int dwarf_formaddr (Dwarf_Attribute *attr, Dwarf_Addr *return_addr)
     __attribute__ ((__nonnull__ (2)));


extern int dwarf_formref (Dwarf_Attribute *attr, Dwarf_Off *return_offset)
     __attribute__ ((__nonnull__ (2)));


extern Dwarf_Die *dwarf_formref_die (Dwarf_Attribute *attr, Dwarf_Die *die_mem)
     __attribute__ ((__nonnull__ (2)));


extern int dwarf_formblock (Dwarf_Attribute *attr, Dwarf_Block *return_block)
     __attribute__ ((__nonnull__ (2)));


extern int dwarf_formflag (Dwarf_Attribute *attr, _Bool *return_bool)
     __attribute__ ((__nonnull__ (2)));





extern const char *dwarf_diename (Dwarf_Die *die);


extern int dwarf_highpc (Dwarf_Die *die, Dwarf_Addr *return_addr)
     __attribute__ ((__nonnull__ (2)));


extern int dwarf_lowpc (Dwarf_Die *die, Dwarf_Addr *return_addr)
     __attribute__ ((__nonnull__ (2)));


extern int dwarf_entrypc (Dwarf_Die *die, Dwarf_Addr *return_addr)
     __attribute__ ((__nonnull__ (2)));



extern int dwarf_haspc (Dwarf_Die *die, Dwarf_Addr pc);
# 311 "../libdw/libdw.h"
extern ptrdiff_t dwarf_ranges (Dwarf_Die *die,
                               ptrdiff_t offset, Dwarf_Addr *basep,
                               Dwarf_Addr *startp, Dwarf_Addr *endp);



extern int dwarf_bytesize (Dwarf_Die *die);


extern int dwarf_bitsize (Dwarf_Die *die);


extern int dwarf_bitoffset (Dwarf_Die *die);


extern int dwarf_arrayorder (Dwarf_Die *die);


extern int dwarf_srclang (Dwarf_Die *die);



extern Dwarf_Abbrev *dwarf_getabbrev (Dwarf_Die *die, Dwarf_Off offset,
                                      size_t *lengthp);


extern int dwarf_offabbrev (Dwarf *dbg, Dwarf_Off offset, size_t *lengthp,
                            Dwarf_Abbrev *abbrevp)
     __attribute__ ((__nonnull__ (4)));


extern unsigned int dwarf_getabbrevcode (Dwarf_Abbrev *abbrev);


extern unsigned int dwarf_getabbrevtag (Dwarf_Abbrev *abbrev);


extern int dwarf_abbrevhaschildren (Dwarf_Abbrev *abbrev);


extern int dwarf_getattrcnt (Dwarf_Abbrev *abbrev, size_t *attrcntp)
     __attribute__ ((__nonnull__ (2)));


extern int dwarf_getabbrevattr (Dwarf_Abbrev *abbrev, size_t idx,
                                unsigned int *namep, unsigned int *formp,
                                Dwarf_Off *offset);



extern const char *dwarf_getstring (Dwarf *dbg, Dwarf_Off offset,
                                    size_t *lenp);



extern ptrdiff_t dwarf_getpubnames (Dwarf *dbg,
                                    int (*callback) (Dwarf *, Dwarf_Global *,
                                                     void *),
                                    void *arg, ptrdiff_t offset)
     __attribute__ ((__nonnull__ (2)));



extern int dwarf_getsrclines (Dwarf_Die *cudie, Dwarf_Lines **lines,
                              size_t *nlines) __attribute__ ((__nonnull__ (2, 3)));


extern Dwarf_Line *dwarf_onesrcline (Dwarf_Lines *lines, size_t idx);


extern int dwarf_getsrcfiles (Dwarf_Die *cudie, Dwarf_Files **files,
                              size_t *nfiles)
     __attribute__ ((__nonnull__ (2)));



extern Dwarf_Line *dwarf_getsrc_die (Dwarf_Die *cudie, Dwarf_Addr addr);


extern int dwarf_getsrc_file (Dwarf *dbg, const char *fname, int line, int col,
                              Dwarf_Line ***srcsp, size_t *nsrcs)
     __attribute__ ((__nonnull__ (2, 5, 6)));



extern int dwarf_lineaddr (Dwarf_Line *line, Dwarf_Addr *addrp);


extern int dwarf_lineno (Dwarf_Line *line, int *linep)
     __attribute__ ((__nonnull__ (2)));


extern int dwarf_linecol (Dwarf_Line *line, int *colp)
     __attribute__ ((__nonnull__ (2)));


extern int dwarf_linebeginstatement (Dwarf_Line *line, _Bool *flagp)
     __attribute__ ((__nonnull__ (2)));


extern int dwarf_lineendsequence (Dwarf_Line *line, _Bool *flagp)
     __attribute__ ((__nonnull__ (2)));


extern int dwarf_lineblock (Dwarf_Line *line, _Bool *flagp)
     __attribute__ ((__nonnull__ (2)));


extern int dwarf_lineprologueend (Dwarf_Line *line, _Bool *flagp)
     __attribute__ ((__nonnull__ (2)));


extern int dwarf_lineepiloguebegin (Dwarf_Line *line, _Bool *flagp)
     __attribute__ ((__nonnull__ (2)));



extern const char *dwarf_linesrc (Dwarf_Line *line,
                                  Dwarf_Word *mtime, Dwarf_Word *length);


extern const char *dwarf_filesrc (Dwarf_Files *file, size_t idx,
                                  Dwarf_Word *mtime, Dwarf_Word *length);



extern int dwarf_getlocation (Dwarf_Attribute *attr, Dwarf_Op **expr,
                              size_t *exprlen) __attribute__ ((__nonnull__ (2, 3)));
# 448 "../libdw/libdw.h"
extern int dwarf_getlocation_addr (Dwarf_Attribute *attr, Dwarf_Addr address,
                                   Dwarf_Op **exprs, size_t *exprlens,
                                   size_t nlocs);
# 459 "../libdw/libdw.h"
extern int dwarf_getscopes (Dwarf_Die *cudie, Dwarf_Addr pc,
                            Dwarf_Die **scopes);







extern int dwarf_getscopes_die (Dwarf_Die *die, Dwarf_Die **scopes);
# 480 "../libdw/libdw.h"
extern int dwarf_getscopevar (Dwarf_Die *scopes, int nscopes,
                              const char *name, int skip_shadows,
                              const char *match_file,
                              int match_lineno, int match_linecol,
                              Dwarf_Die *result);




extern int dwarf_getaranges (Dwarf *dbg, Dwarf_Aranges **aranges,
                             size_t *naranges)
     __attribute__ ((__nonnull__ (2)));


extern Dwarf_Arange *dwarf_onearange (Dwarf_Aranges *aranges, size_t idx);


extern int dwarf_getarangeinfo (Dwarf_Arange *arange, Dwarf_Addr *addrp,
                                Dwarf_Word *lengthp, Dwarf_Off *offsetp);


extern Dwarf_Arange *dwarf_getarange_addr (Dwarf_Aranges *aranges,
                                           Dwarf_Addr addr);




extern ptrdiff_t dwarf_getfuncs (Dwarf_Die *cudie,
                                 int (*callback) (Dwarf_Die *, void *),
                                 void *arg, ptrdiff_t offset);



extern const char *dwarf_decl_file (Dwarf_Die *decl);


extern int dwarf_decl_line (Dwarf_Die *decl, int *linep)
     __attribute__ ((__nonnull__ (2)));


extern int dwarf_decl_column (Dwarf_Die *decl, int *colp)
     __attribute__ ((__nonnull__ (2)));



extern int dwarf_func_inline (Dwarf_Die *func);


extern int dwarf_func_inline_instances (Dwarf_Die *func,
                                        int (*callback) (Dwarf_Die *, void *),
                                        void *arg);






extern int dwarf_entry_breakpoints (Dwarf_Die *die, Dwarf_Addr **bkpts);




extern ptrdiff_t dwarf_getmacros (Dwarf_Die *cudie,
                                  int (*callback) (Dwarf_Macro *, void *),
                                  void *arg, ptrdiff_t offset)
     __attribute__ ((__nonnull__ (2)));


extern int dwarf_macro_opcode (Dwarf_Macro *macro, unsigned int *opcodep)
     __attribute__ ((__nonnull__ (2)));


extern int dwarf_macro_param1 (Dwarf_Macro *macro, Dwarf_Word *paramp)
     __attribute__ ((__nonnull__ (2)));


extern int dwarf_macro_param2 (Dwarf_Macro *macro, Dwarf_Word *paramp,
                               const char **strp);




extern int dwarf_errno (void);





extern const char *dwarf_errmsg (int err);



extern Dwarf_OOM dwarf_new_oom_handler (Dwarf *dbg, Dwarf_OOM handler);





extern inline unsigned int
dwarf_whatattr (Dwarf_Attribute *attr)
{
  return attr == ((void *)0) ? 0 : attr->code;
}


extern inline unsigned int
dwarf_whatform (Dwarf_Attribute *attr)
{
  return attr == ((void *)0) ? 0 : attr->form;
}
# 29 "readelf.c" 2
# 1 "/usr/include/libintl.h" 1 3 4
# 22 "/usr/include/libintl.h" 3 4
#define _LIBINTL_H 1





#define __USE_GNU_GETTEXT 1



#define __GNU_GETTEXT_SUPPORTED_REVISION(major) ((major) == 0 ? 1 : -1)







extern char *gettext (const char *__msgid) __attribute__ ((__nothrow__));



extern char *dgettext (const char *__domainname, const char *__msgid)
     __attribute__ ((__nothrow__));
extern char *__dgettext (const char *__domainname, const char *__msgid)
     __attribute__ ((__nothrow__)) __attribute__ ((__format_arg__ (2)));



extern char *dcgettext (const char *__domainname,
                        const char *__msgid, int __category) __attribute__ ((__nothrow__));
extern char *__dcgettext (const char *__domainname,
                          const char *__msgid, int __category)
     __attribute__ ((__nothrow__)) __attribute__ ((__format_arg__ (2)));




extern char *ngettext (const char *__msgid1, const char *__msgid2,
                       unsigned long int __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__format_arg__ (1))) __attribute__ ((__format_arg__ (2)));



extern char *dngettext (const char *__domainname, const char *__msgid1,
                        const char *__msgid2, unsigned long int __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));



extern char *dcngettext (const char *__domainname, const char *__msgid1,
                         const char *__msgid2, unsigned long int __n,
                         int __category)
     __attribute__ ((__nothrow__)) __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));





extern char *textdomain (const char *__domainname) __attribute__ ((__nothrow__));



extern char *bindtextdomain (const char *__domainname,
                             const char *__dirname) __attribute__ ((__nothrow__));



extern char *bind_textdomain_codeset (const char *__domainname,
                                      const char *__codeset) __attribute__ ((__nothrow__));






#define __need_NULL 
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 1 3 4
# 397 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#undef NULL




#define NULL ((void *)0)





#undef __need_NULL





#define offsetof(TYPE,MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
# 100 "/usr/include/libintl.h" 2 3 4


# 1 "/usr/include/locale.h" 1 3 4
# 24 "/usr/include/locale.h" 3 4
#define _LOCALE_H 1



#define __need_NULL 
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 1 3 4
# 397 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#undef NULL




#define NULL ((void *)0)





#undef __need_NULL





#define offsetof(TYPE,MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
# 30 "/usr/include/locale.h" 2 3 4
# 1 "/usr/include/bits/locale.h" 1 3 4
# 31 "/usr/include/locale.h" 2 3 4





#define LC_CTYPE __LC_CTYPE
#define LC_NUMERIC __LC_NUMERIC
#define LC_TIME __LC_TIME
#define LC_COLLATE __LC_COLLATE
#define LC_MONETARY __LC_MONETARY
#define LC_MESSAGES __LC_MESSAGES
#define LC_ALL __LC_ALL
#define LC_PAPER __LC_PAPER
#define LC_NAME __LC_NAME
#define LC_ADDRESS __LC_ADDRESS
#define LC_TELEPHONE __LC_TELEPHONE
#define LC_MEASUREMENT __LC_MEASUREMENT
#define LC_IDENTIFICATION __LC_IDENTIFICATION



struct lconv
{


  char *decimal_point;
  char *thousands_sep;





  char *grouping;





  char *int_curr_symbol;
  char *currency_symbol;
  char *mon_decimal_point;
  char *mon_thousands_sep;
  char *mon_grouping;
  char *positive_sign;
  char *negative_sign;
  char int_frac_digits;
  char frac_digits;

  char p_cs_precedes;

  char p_sep_by_space;

  char n_cs_precedes;

  char n_sep_by_space;






  char p_sign_posn;
  char n_sign_posn;


  char int_p_cs_precedes;

  char int_p_sep_by_space;

  char int_n_cs_precedes;

  char int_n_sep_by_space;






  char int_p_sign_posn;
  char int_n_sign_posn;
# 119 "/usr/include/locale.h" 3 4
};





extern char *setlocale (int __category, const char *__locale) __attribute__ ((__nothrow__));


extern struct lconv *localeconv (void) __attribute__ ((__nothrow__));


# 148 "/usr/include/locale.h" 3 4
typedef __locale_t locale_t;





extern __locale_t newlocale (int __category_mask, const char *__locale,
                             __locale_t __base) __attribute__ ((__nothrow__));





#define LC_CTYPE_MASK (1 << __LC_CTYPE)
#define LC_NUMERIC_MASK (1 << __LC_NUMERIC)
#define LC_TIME_MASK (1 << __LC_TIME)
#define LC_COLLATE_MASK (1 << __LC_COLLATE)
#define LC_MONETARY_MASK (1 << __LC_MONETARY)
#define LC_MESSAGES_MASK (1 << __LC_MESSAGES)
#define LC_PAPER_MASK (1 << __LC_PAPER)
#define LC_NAME_MASK (1 << __LC_NAME)
#define LC_ADDRESS_MASK (1 << __LC_ADDRESS)
#define LC_TELEPHONE_MASK (1 << __LC_TELEPHONE)
#define LC_MEASUREMENT_MASK (1 << __LC_MEASUREMENT)
#define LC_IDENTIFICATION_MASK (1 << __LC_IDENTIFICATION)
#define LC_ALL_MASK (LC_CTYPE_MASK | LC_NUMERIC_MASK | LC_TIME_MASK | LC_COLLATE_MASK | LC_MONETARY_MASK | LC_MESSAGES_MASK | LC_PAPER_MASK | LC_NAME_MASK | LC_ADDRESS_MASK | LC_TELEPHONE_MASK | LC_MEASUREMENT_MASK | LC_IDENTIFICATION_MASK )
# 189 "/usr/include/locale.h" 3 4
extern __locale_t duplocale (__locale_t __dataset) __attribute__ ((__nothrow__));



extern void freelocale (__locale_t __dataset) __attribute__ ((__nothrow__));






extern __locale_t uselocale (__locale_t __dataset) __attribute__ ((__nothrow__));



#define LC_GLOBAL_LOCALE ((__locale_t) -1L)




# 103 "/usr/include/libintl.h" 2 3 4





#define gettext(msgid) dgettext (NULL, msgid)

#define dgettext(domainname,msgid) dcgettext (domainname, msgid, LC_MESSAGES)


#define ngettext(msgid1,msgid2,n) dngettext (NULL, msgid1, msgid2, n)

#define dngettext(domainname,msgid1,msgid2,n) dcngettext (domainname, msgid1, msgid2, n, LC_MESSAGES)





# 30 "readelf.c" 2


# 1 "/usr/include/stdlib.h" 1 3 4
# 28 "/usr/include/stdlib.h" 3 4
#define __need_size_t 

#define __need_wchar_t 
#define __need_NULL 

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 1 3 4
# 235 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#undef __need_size_t
# 344 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#undef __need_wchar_t
# 397 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#undef NULL




#define NULL ((void *)0)





#undef __need_NULL





#define offsetof(TYPE,MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
# 34 "/usr/include/stdlib.h" 2 3 4




#define _STDLIB_H 1



# 1 "/usr/include/bits/waitflags.h" 1 3 4
# 26 "/usr/include/bits/waitflags.h" 3 4
#define WNOHANG 1
#define WUNTRACED 2


#define WSTOPPED 2
#define WEXITED 4
#define WCONTINUED 8
#define WNOWAIT 0x01000000

#define __WALL 0x40000000
#define __WCLONE 0x80000000
# 43 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/bits/waitstatus.h" 1 3 4
# 29 "/usr/include/bits/waitstatus.h" 3 4
#define __WEXITSTATUS(status) (((status) & 0xff00) >> 8)


#define __WTERMSIG(status) ((status) & 0x7f)


#define __WSTOPSIG(status) __WEXITSTATUS(status)


#define __WIFEXITED(status) (__WTERMSIG(status) == 0)


#define __WIFSIGNALED(status) (((signed char) (((status) & 0x7f) + 1) >> 1) > 0)



#define __WIFSTOPPED(status) (((status) & 0xff) == 0x7f)




#define __WIFCONTINUED(status) ((status) == __W_CONTINUED)



#define __WCOREDUMP(status) ((status) & __WCOREFLAG)


#define __W_EXITCODE(ret,sig) ((ret) << 8 | (sig))
#define __W_STOPCODE(sig) ((sig) << 8 | 0x7f)
#define __W_CONTINUED 0xffff
#define __WCOREFLAG 0x80






union wait
  {
    int w_status;
    struct
      {

        unsigned int __w_termsig:7;
        unsigned int __w_coredump:1;
        unsigned int __w_retcode:8;
        unsigned int:16;







      } __wait_terminated;
    struct
      {

        unsigned int __w_stopval:8;
        unsigned int __w_stopsig:8;
        unsigned int:16;






      } __wait_stopped;
  };

#define w_termsig __wait_terminated.__w_termsig
#define w_coredump __wait_terminated.__w_coredump
#define w_retcode __wait_terminated.__w_retcode
#define w_stopsig __wait_stopped.__w_stopsig
#define w_stopval __wait_stopped.__w_stopval
# 44 "/usr/include/stdlib.h" 2 3 4







#define __WAIT_INT(status) (__extension__ ({ union { __typeof(status) __in; int __i; } __u; __u.__in = (status); __u.__i; }))
# 68 "/usr/include/stdlib.h" 3 4
typedef union
  {
    union wait *__uptr;
    int *__iptr;
  } __WAIT_STATUS __attribute__ ((__transparent_union__));
#define __WAIT_STATUS_DEFN int *
# 85 "/usr/include/stdlib.h" 3 4
#define WEXITSTATUS(status) __WEXITSTATUS(__WAIT_INT(status))
#define WTERMSIG(status) __WTERMSIG(__WAIT_INT(status))
#define WSTOPSIG(status) __WSTOPSIG(__WAIT_INT(status))
#define WIFEXITED(status) __WIFEXITED(__WAIT_INT(status))
#define WIFSIGNALED(status) __WIFSIGNALED(__WAIT_INT(status))
#define WIFSTOPPED(status) __WIFSTOPPED(__WAIT_INT(status))

#define WIFCONTINUED(status) __WIFCONTINUED(__WAIT_INT(status))





typedef struct
  {
    int quot;
    int rem;
  } div_t;



typedef struct
  {
    long int quot;
    long int rem;
  } ldiv_t;
#define __ldiv_t_defined 1






__extension__ typedef struct
  {
    long long int quot;
    long long int rem;
  } lldiv_t;
#define __lldiv_t_defined 1





#define RAND_MAX 2147483647




#define EXIT_FAILURE 1
#define EXIT_SUCCESS 0



#define MB_CUR_MAX (__ctype_get_mb_cur_max ())
extern size_t __ctype_get_mb_cur_max (void) __attribute__ ((__nothrow__));




extern double atof (const char *__nptr)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern int atoi (const char *__nptr)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern long int atol (const char *__nptr)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





__extension__ extern long long int atoll (const char *__nptr)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





extern double strtod (const char *__restrict __nptr,
                      char **__restrict __endptr) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));





extern float strtof (const char *__restrict __nptr,
                     char **__restrict __endptr) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));

extern long double strtold (const char *__restrict __nptr,
                            char **__restrict __endptr)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));





extern long int strtol (const char *__restrict __nptr,
                        char **__restrict __endptr, int __base)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));

extern unsigned long int strtoul (const char *__restrict __nptr,
                                  char **__restrict __endptr, int __base)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));




__extension__
extern long long int strtoq (const char *__restrict __nptr,
                             char **__restrict __endptr, int __base)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));

__extension__
extern unsigned long long int strtouq (const char *__restrict __nptr,
                                       char **__restrict __endptr, int __base)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));





__extension__
extern long long int strtoll (const char *__restrict __nptr,
                              char **__restrict __endptr, int __base)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));

__extension__
extern unsigned long long int strtoull (const char *__restrict __nptr,
                                        char **__restrict __endptr, int __base)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));

# 239 "/usr/include/stdlib.h" 3 4
extern long int strtol_l (const char *__restrict __nptr,
                          char **__restrict __endptr, int __base,
                          __locale_t __loc) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 4)));

extern unsigned long int strtoul_l (const char *__restrict __nptr,
                                    char **__restrict __endptr,
                                    int __base, __locale_t __loc)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 4)));

__extension__
extern long long int strtoll_l (const char *__restrict __nptr,
                                char **__restrict __endptr, int __base,
                                __locale_t __loc)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 4)));

__extension__
extern unsigned long long int strtoull_l (const char *__restrict __nptr,
                                          char **__restrict __endptr,
                                          int __base, __locale_t __loc)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 4)));

extern double strtod_l (const char *__restrict __nptr,
                        char **__restrict __endptr, __locale_t __loc)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 3)));

extern float strtof_l (const char *__restrict __nptr,
                       char **__restrict __endptr, __locale_t __loc)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 3)));

extern long double strtold_l (const char *__restrict __nptr,
                              char **__restrict __endptr,
                              __locale_t __loc) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 3)));






extern double __strtod_internal (const char *__restrict __nptr,
                                 char **__restrict __endptr, int __group)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
extern float __strtof_internal (const char *__restrict __nptr,
                                char **__restrict __endptr, int __group)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
extern long double __strtold_internal (const char *__restrict __nptr,
                                       char **__restrict __endptr,
                                       int __group) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));

extern long int __strtol_internal (const char *__restrict __nptr,
                                   char **__restrict __endptr,
                                   int __base, int __group)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
#define __strtol_internal_defined 1


extern unsigned long int __strtoul_internal (const char *__restrict __nptr,
                                             char **__restrict __endptr,
                                             int __base, int __group)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
#define __strtoul_internal_defined 1
# 323 "/usr/include/stdlib.h" 3 4

extern __inline double
__attribute__ ((__nothrow__)) strtod (const char *__restrict __nptr, char **__restrict __endptr)
{
  return __strtod_internal (__nptr, __endptr, 0);
}
extern __inline long int
__attribute__ ((__nothrow__)) strtol (const char *__restrict __nptr, char **__restrict __endptr, int __base)

{
  return __strtol_internal (__nptr, __endptr, __base, 0);
}
extern __inline unsigned long int
__attribute__ ((__nothrow__)) strtoul (const char *__restrict __nptr, char **__restrict __endptr, int __base)

{
  return __strtoul_internal (__nptr, __endptr, __base, 0);
}




extern __inline float
__attribute__ ((__nothrow__)) strtof (const char *__restrict __nptr, char **__restrict __endptr)
{
  return __strtof_internal (__nptr, __endptr, 0);
}
extern __inline long double
__attribute__ ((__nothrow__)) strtold (const char *__restrict __nptr, char **__restrict __endptr)
{
  return __strtold_internal (__nptr, __endptr, 0);
}




__extension__ extern __inline long long int
__attribute__ ((__nothrow__)) strtoq (const char *__restrict __nptr, char **__restrict __endptr, int __base)

{
  return __strtoll_internal (__nptr, __endptr, __base, 0);
}
__extension__ extern __inline unsigned long long int
__attribute__ ((__nothrow__)) strtouq (const char *__restrict __nptr, char **__restrict __endptr, int __base)

{
  return __strtoull_internal (__nptr, __endptr, __base, 0);
}




__extension__ extern __inline long long int
__attribute__ ((__nothrow__)) strtoll (const char *__restrict __nptr, char **__restrict __endptr, int __base)

{
  return __strtoll_internal (__nptr, __endptr, __base, 0);
}
__extension__ extern __inline unsigned long long int
__attribute__ ((__nothrow__)) strtoull (const char * __restrict __nptr, char **__restrict __endptr, int __base)

{
  return __strtoull_internal (__nptr, __endptr, __base, 0);
}




extern __inline double
__attribute__ ((__nothrow__)) atof (const char *__nptr)
{
  return strtod (__nptr, (char **) ((void *)0));
}
extern __inline int
__attribute__ ((__nothrow__)) atoi (const char *__nptr)
{
  return (int) strtol (__nptr, (char **) ((void *)0), 10);
}
extern __inline long int
__attribute__ ((__nothrow__)) atol (const char *__nptr)
{
  return strtol (__nptr, (char **) ((void *)0), 10);
}




__extension__ extern __inline long long int
__attribute__ ((__nothrow__)) atoll (const char *__nptr)
{
  return strtoll (__nptr, (char **) ((void *)0), 10);
}

# 424 "/usr/include/stdlib.h" 3 4
extern char *l64a (long int __n) __attribute__ ((__nothrow__));


extern long int a64l (const char *__s)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 440 "/usr/include/stdlib.h" 3 4
extern long int random (void) __attribute__ ((__nothrow__));


extern void srandom (unsigned int __seed) __attribute__ ((__nothrow__));





extern char *initstate (unsigned int __seed, char *__statebuf,
                        size_t __statelen) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));



extern char *setstate (char *__statebuf) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));







struct random_data
  {
    int32_t *fptr;
    int32_t *rptr;
    int32_t *state;
    int rand_type;
    int rand_deg;
    int rand_sep;
    int32_t *end_ptr;
  };

extern int random_r (struct random_data *__restrict __buf,
                     int32_t *__restrict __result) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));

extern int srandom_r (unsigned int __seed, struct random_data *__buf)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));

extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
                        size_t __statelen,
                        struct random_data *__restrict __buf)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 4)));

extern int setstate_r (char *__restrict __statebuf,
                       struct random_data *__restrict __buf)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));






extern int rand (void) __attribute__ ((__nothrow__));

extern void srand (unsigned int __seed) __attribute__ ((__nothrow__));




extern int rand_r (unsigned int *__seed) __attribute__ ((__nothrow__));







extern double drand48 (void) __attribute__ ((__nothrow__));
extern double erand48 (unsigned short int __xsubi[3]) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));


extern long int lrand48 (void) __attribute__ ((__nothrow__));
extern long int nrand48 (unsigned short int __xsubi[3])
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));


extern long int mrand48 (void) __attribute__ ((__nothrow__));
extern long int jrand48 (unsigned short int __xsubi[3])
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));


extern void srand48 (long int __seedval) __attribute__ ((__nothrow__));
extern unsigned short int *seed48 (unsigned short int __seed16v[3])
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
extern void lcong48 (unsigned short int __param[7]) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));





struct drand48_data
  {
    unsigned short int __x[3];
    unsigned short int __old_x[3];
    unsigned short int __c;
    unsigned short int __init;
    unsigned long long int __a;
  };


extern int drand48_r (struct drand48_data *__restrict __buffer,
                      double *__restrict __result) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
extern int erand48_r (unsigned short int __xsubi[3],
                      struct drand48_data *__restrict __buffer,
                      double *__restrict __result) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));


extern int lrand48_r (struct drand48_data *__restrict __buffer,
                      long int *__restrict __result)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
extern int nrand48_r (unsigned short int __xsubi[3],
                      struct drand48_data *__restrict __buffer,
                      long int *__restrict __result)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));


extern int mrand48_r (struct drand48_data *__restrict __buffer,
                      long int *__restrict __result)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
extern int jrand48_r (unsigned short int __xsubi[3],
                      struct drand48_data *__restrict __buffer,
                      long int *__restrict __result)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));


extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));

extern int seed48_r (unsigned short int __seed16v[3],
                     struct drand48_data *__buffer) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));

extern int lcong48_r (unsigned short int __param[7],
                      struct drand48_data *__buffer)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));






#define __malloc_and_calloc_defined 


extern void *malloc (size_t __size) __attribute__ ((__nothrow__)) __attribute__ ((__malloc__));

extern void *calloc (size_t __nmemb, size_t __size)
     __attribute__ ((__nothrow__)) __attribute__ ((__malloc__));







extern void *realloc (void *__ptr, size_t __size) __attribute__ ((__nothrow__)) __attribute__ ((__malloc__));

extern void free (void *__ptr) __attribute__ ((__nothrow__));




extern void cfree (void *__ptr) __attribute__ ((__nothrow__));



# 1 "/usr/include/alloca.h" 1 3 4
# 20 "/usr/include/alloca.h" 3 4
#define _ALLOCA_H 1



#define __need_size_t 
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 1 3 4
# 235 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#undef __need_size_t
# 397 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#undef NULL




#define NULL ((void *)0)
# 414 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#define offsetof(TYPE,MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
# 26 "/usr/include/alloca.h" 2 3 4







extern void *alloca (size_t __size) __attribute__ ((__nothrow__));


#define alloca(size) __builtin_alloca (size)



# 607 "/usr/include/stdlib.h" 2 3 4




extern void *valloc (size_t __size) __attribute__ ((__nothrow__)) __attribute__ ((__malloc__));




extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));




extern void abort (void) __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));



extern int atexit (void (*__func) (void)) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));





extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));






extern void exit (int __status) __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));






extern void _Exit (int __status) __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));






extern char *getenv (const char *__name) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));




extern char *__secure_getenv (const char *__name) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));





extern int putenv (char *__string) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));





extern int setenv (const char *__name, const char *__value, int __replace)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));


extern int unsetenv (const char *__name) __attribute__ ((__nothrow__));






extern int clearenv (void) __attribute__ ((__nothrow__));
# 691 "/usr/include/stdlib.h" 3 4
extern char *mktemp (char *__template) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
# 705 "/usr/include/stdlib.h" 3 4
extern int mkstemp (char *__template) __asm__ ("" "mkstemp64") __attribute__ ((__nonnull__ (1)));





extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1)));
# 721 "/usr/include/stdlib.h" 3 4
extern char *mkdtemp (char *__template) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));








extern int system (const char *__command);







extern char *canonicalize_file_name (const char *__name)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
# 749 "/usr/include/stdlib.h" 3 4
extern char *realpath (const char *__restrict __name,
                       char *__restrict __resolved) __attribute__ ((__nothrow__));





#define __COMPAR_FN_T 
typedef int (*__compar_fn_t) (const void *, const void *);


typedef __compar_fn_t comparison_fn_t;






extern void *bsearch (const void *__key, const void *__base,
                      size_t __nmemb, size_t __size, __compar_fn_t __compar)
     __attribute__ ((__nonnull__ (1, 2, 5)));



extern void qsort (void *__base, size_t __nmemb, size_t __size,
                   __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));



extern int abs (int __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
extern long int labs (long int __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__));



__extension__ extern long long int llabs (long long int __x)
     __attribute__ ((__nothrow__)) __attribute__ ((__const__));







extern div_t div (int __numer, int __denom)
     __attribute__ ((__nothrow__)) __attribute__ ((__const__));
extern ldiv_t ldiv (long int __numer, long int __denom)
     __attribute__ ((__nothrow__)) __attribute__ ((__const__));




__extension__ extern lldiv_t lldiv (long long int __numer,
                                    long long int __denom)
     __attribute__ ((__nothrow__)) __attribute__ ((__const__));

# 814 "/usr/include/stdlib.h" 3 4
extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
                   int *__restrict __sign) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4)));




extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
                   int *__restrict __sign) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4)));




extern char *gcvt (double __value, int __ndigit, char *__buf)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3)));




extern char *qecvt (long double __value, int __ndigit,
                    int *__restrict __decpt, int *__restrict __sign)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4)));
extern char *qfcvt (long double __value, int __ndigit,
                    int *__restrict __decpt, int *__restrict __sign)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4)));
extern char *qgcvt (long double __value, int __ndigit, char *__buf)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3)));




extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
                   int *__restrict __sign, char *__restrict __buf,
                   size_t __len) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4, 5)));
extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
                   int *__restrict __sign, char *__restrict __buf,
                   size_t __len) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4, 5)));

extern int qecvt_r (long double __value, int __ndigit,
                    int *__restrict __decpt, int *__restrict __sign,
                    char *__restrict __buf, size_t __len)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4, 5)));
extern int qfcvt_r (long double __value, int __ndigit,
                    int *__restrict __decpt, int *__restrict __sign,
                    char *__restrict __buf, size_t __len)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4, 5)));







extern int mblen (const char *__s, size_t __n) __attribute__ ((__nothrow__));


extern int mbtowc (wchar_t *__restrict __pwc,
                   const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__));


extern int wctomb (char *__s, wchar_t __wchar) __attribute__ ((__nothrow__));



extern size_t mbstowcs (wchar_t *__restrict __pwcs,
                        const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__));

extern size_t wcstombs (char *__restrict __s,
                        const wchar_t *__restrict __pwcs, size_t __n)
     __attribute__ ((__nothrow__));








extern int rpmatch (const char *__response) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
# 902 "/usr/include/stdlib.h" 3 4
extern int getsubopt (char **__restrict __optionp,
                      char *const *__restrict __tokens,
                      char **__restrict __valuep)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2, 3)));





extern void setkey (const char *__key) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));







extern int posix_openpt (int __oflag);







extern int grantpt (int __fd) __attribute__ ((__nothrow__));



extern int unlockpt (int __fd) __attribute__ ((__nothrow__));




extern char *ptsname (int __fd) __attribute__ ((__nothrow__));






extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));


extern int getpt (void);






extern int getloadavg (double __loadavg[], int __nelem)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));






# 33 "readelf.c" 2
# 1 "/usr/include/string.h" 1 3 4
# 24 "/usr/include/string.h" 3 4
#define _STRING_H 1






#define __need_size_t 
#define __need_NULL 
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 1 3 4
# 235 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#undef __need_size_t
# 397 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#undef NULL




#define NULL ((void *)0)





#undef __need_NULL





#define offsetof(TYPE,MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
# 34 "/usr/include/string.h" 2 3 4




extern void *memcpy (void *__restrict __dest,
                     const void *__restrict __src, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));


extern void *memmove (void *__dest, const void *__src, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));






extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
                      int __c, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));





extern void *memset (void *__s, int __c, size_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));


extern int memcmp (const void *__s1, const void *__s2, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern void *memchr (const void *__s, int __c, size_t __n)
      __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





extern void *rawmemchr (const void *__s, int __c)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));


extern void *memrchr (const void *__s, int __c, size_t __n)
      __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));

extern char *strncpy (char *__restrict __dest,
                      const char *__restrict __src, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));


extern char *strcat (char *__restrict __dest, const char *__restrict __src)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));

extern char *strncat (char *__restrict __dest, const char *__restrict __src,
                      size_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));


extern int strcmp (const char *__s1, const char *__s2)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern int strncmp (const char *__s1, const char *__s2, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern int strcoll (const char *__s1, const char *__s2)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern size_t strxfrm (char *__restrict __dest,
                       const char *__restrict __src, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));

# 121 "/usr/include/string.h" 3 4
extern int strcoll_l (const char *__s1, const char *__s2, __locale_t __l)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));

extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n,
                         __locale_t __l) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 4)));




extern char *strdup (const char *__s)
     __attribute__ ((__nothrow__)) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));






extern char *strndup (const char *__string, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));




#define strdupa(s) (__extension__ ({ __const char *__old = (s); size_t __len = strlen (__old) + 1; char *__new = (char *) __builtin_alloca (__len); (char *) memcpy (__new, __old, __len); }))
# 154 "/usr/include/string.h" 3 4
#define strndupa(s,n) (__extension__ ({ __const char *__old = (s); size_t __len = strnlen (__old, (n)); char *__new = (char *) __builtin_alloca (__len + 1); __new[__len] = '\0'; (char *) memcpy (__new, __old, __len); }))
# 165 "/usr/include/string.h" 3 4


extern char *strchr (const char *__s, int __c)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern char *strrchr (const char *__s, int __c)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





extern char *strchrnul (const char *__s, int __c)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





extern size_t strcspn (const char *__s, const char *__reject)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern size_t strspn (const char *__s, const char *__accept)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern char *strpbrk (const char *__s, const char *__accept)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern char *strstr (const char *__haystack, const char *__needle)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));



extern char *strtok (char *__restrict __s, const char *__restrict __delim)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));




extern char *__strtok_r (char *__restrict __s,
                         const char *__restrict __delim,
                         char **__restrict __save_ptr)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 3)));

extern char *strtok_r (char *__restrict __s, const char *__restrict __delim,
                       char **__restrict __save_ptr)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 3)));




extern char *strcasestr (const char *__haystack, const char *__needle)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));






extern void *memmem (const void *__haystack, size_t __haystacklen,
                     const void *__needle, size_t __needlelen)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));



extern void *__mempcpy (void *__restrict __dest,
                        const void *__restrict __src, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
extern void *mempcpy (void *__restrict __dest,
                      const void *__restrict __src, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));





extern size_t strlen (const char *__s)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





extern size_t strnlen (const char *__string, size_t __maxlen)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





extern char *strerror (int __errnum) __attribute__ ((__nothrow__));

# 281 "/usr/include/string.h" 3 4
extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));





extern void __bzero (void *__s, size_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));



extern void bcopy (const void *__src, void *__dest, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));


extern void bzero (void *__s, size_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));


extern int bcmp (const void *__s1, const void *__s2, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern char *index (const char *__s, int __c)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));


extern char *rindex (const char *__s, int __c)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));



extern int ffs (int __i) __attribute__ ((__nothrow__)) __attribute__ ((__const__));




extern int ffsl (long int __l) __attribute__ ((__nothrow__)) __attribute__ ((__const__));

__extension__ extern int ffsll (long long int __ll)
     __attribute__ ((__nothrow__)) __attribute__ ((__const__));




extern int strcasecmp (const char *__s1, const char *__s2)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern int strncasecmp (const char *__s1, const char *__s2, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));





extern int strcasecmp_l (const char *__s1, const char *__s2,
                         __locale_t __loc)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));

extern int strncasecmp_l (const char *__s1, const char *__s2,
                          size_t __n, __locale_t __loc)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));





extern char *strsep (char **__restrict __stringp,
                     const char *__restrict __delim)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));




extern int strverscmp (const char *__s1, const char *__s2)
     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern char *strsignal (int __sig) __attribute__ ((__nothrow__));


extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
extern char *stpcpy (char *__restrict __dest, const char *__restrict __src)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));



extern char *__stpncpy (char *__restrict __dest,
                        const char *__restrict __src, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
extern char *stpncpy (char *__restrict __dest,
                      const char *__restrict __src, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));


extern char *strfry (char *__string) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));


extern void *memfrob (void *__s, size_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));






extern char *basename (const char *__filename) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
# 414 "/usr/include/string.h" 3 4
# 1 "/usr/include/bits/string.h" 1 3 4
# 26 "/usr/include/bits/string.h" 3 4
#define _STRING_ARCH_unaligned 1
# 415 "/usr/include/string.h" 2 3 4


# 1 "/usr/include/bits/string2.h" 1 3 4
# 46 "/usr/include/bits/string2.h" 3 4
#define __STRING_INLINE extern __inline
# 56 "/usr/include/bits/string2.h" 3 4
#define __STRING2_SMALL_GET16(src,idx) (((__const unsigned char *) (__const char *) (src))[idx + 1] << 8 | ((__const unsigned char *) (__const char *) (src))[idx])


#define __STRING2_SMALL_GET32(src,idx) (((((__const unsigned char *) (__const char *) (src))[idx + 3] << 8 | ((__const unsigned char *) (__const char *) (src))[idx + 2]) << 8 | ((__const unsigned char *) (__const char *) (src))[idx + 1]) << 8 | ((__const unsigned char *) (__const char *) (src))[idx])
# 93 "/usr/include/bits/string2.h" 3 4
#define __string2_1bptr_p(__x) ((size_t)(const void *)((__x) + 1) - (size_t)(const void *)(__x) == 1)
# 195 "/usr/include/bits/string2.h" 3 4
#define __bzero(s,n) __builtin_memset (s, '\0', n)
# 209 "/usr/include/bits/string2.h" 3 4
#define __mempcpy(dest,src,n) (__extension__ (__builtin_constant_p (src) && __builtin_constant_p (n) && __string2_1bptr_p (src) && n <= 8 ? __builtin_memcpy (dest, src, n) + (n) : __mempcpy (dest, src, n)))
# 223 "/usr/include/bits/string2.h" 3 4
#define mempcpy(dest,src,n) __mempcpy (dest, src, n)
# 394 "/usr/include/bits/string2.h" 3 4
extern void *__rawmemchr (const void *__s, int __c);

#define strchr(s,c) (__extension__ (__builtin_constant_p (c) && !__builtin_constant_p (s) && (c) == '\0' ? (char *) __rawmemchr (s, c) : __builtin_strchr (s, c)))
# 579 "/usr/include/bits/string2.h" 3 4
#define __stpcpy(dest,src) (__extension__ (__builtin_constant_p (src) ? (__string2_1bptr_p (src) && strlen (src) + 1 <= 8 ? __builtin_strcpy (dest, src) + strlen (src) : ((char *) (__mempcpy) (dest, src, strlen (src) + 1) - 1)) : __stpcpy (dest, src)))
# 598 "/usr/include/bits/string2.h" 3 4
#define stpcpy(dest,src) __stpcpy (dest, src)
# 761 "/usr/include/bits/string2.h" 3 4
#define strncpy(dest,src,n) __builtin_strncpy (dest, src, n)
# 785 "/usr/include/bits/string2.h" 3 4
#define strncat(dest,src,n) __builtin_strncat (dest, src, n)
# 800 "/usr/include/bits/string2.h" 3 4
#define strcmp(s1,s2) __extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (s1) && __builtin_constant_p (s2) && (__s1_len = strlen (s1), __s2_len = strlen (s2), (!__string2_1bptr_p (s1) || __s1_len >= 4) && (!__string2_1bptr_p (s2) || __s2_len >= 4)) ? __builtin_strcmp (s1, s2) : (__builtin_constant_p (s1) && __string2_1bptr_p (s1) && (__s1_len = strlen (s1), __s1_len < 4) ? (__builtin_constant_p (s2) && __string2_1bptr_p (s2) ? __builtin_strcmp (s1, s2) : __strcmp_cg (s1, s2, __s1_len)) : (__builtin_constant_p (s2) && __string2_1bptr_p (s2) && (__s2_len = strlen (s2), __s2_len < 4) ? (__builtin_constant_p (s1) && __string2_1bptr_p (s1) ? __builtin_strcmp (s1, s2) : __strcmp_gc (s1, s2, __s2_len)) : __builtin_strcmp (s1, s2)))); })
# 842 "/usr/include/bits/string2.h" 3 4
#define __strcmp_cc(s1,s2,l) (__extension__ ({ register int __result = (((__const unsigned char *) (__const char *) (s1))[0] - ((__const unsigned char *) (__const char *)(s2))[0]); if (l > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (s1))[1] - ((__const unsigned char *) (__const char *) (s2))[1]); if (l > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (s1))[2] - ((__const unsigned char *) (__const char *) (s2))[2]); if (l > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (s1))[3] - ((__const unsigned char *) (__const char *) (s2))[3]); } } __result; }))
# 869 "/usr/include/bits/string2.h" 3 4
#define __strcmp_cg(s1,s2,l1) (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) (s2); register int __result = (((__const unsigned char *) (__const char *) (s1))[0] - __s2[0]); if (l1 > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (s1))[1] - __s2[1]); if (l1 > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (s1))[2] - __s2[2]); if (l1 > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (s1))[3] - __s2[3]); } } __result; }))
# 891 "/usr/include/bits/string2.h" 3 4
#define __strcmp_gc(s1,s2,l2) (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (s1); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) (s2))[0]; if (l2 > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) (s2))[1]); if (l2 > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) (s2))[2]); if (l2 > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) (s2))[3]); } } __result; }))
# 920 "/usr/include/bits/string2.h" 3 4
#define strncmp(s1,s2,n) (__extension__ (__builtin_constant_p (n) && ((__builtin_constant_p (s1) && strlen (s1) < ((size_t) (n))) || (__builtin_constant_p (s2) && strlen (s2) < ((size_t) (n)))) ? strcmp (s1, s2) : strncmp (s1, s2, n)))
# 935 "/usr/include/bits/string2.h" 3 4
#define strcspn(s,reject) __extension__ ({ char __r0, __r1, __r2; (__builtin_constant_p (reject) && __string2_1bptr_p (reject) ? ((__builtin_constant_p (s) && __string2_1bptr_p (s)) ? __builtin_strcspn (s, reject) : ((__r0 = ((__const char *) (reject))[0], __r0 == '\0') ? strlen (s) : ((__r1 = ((__const char *) (reject))[1], __r1 == '\0') ? __strcspn_c1 (s, __r0) : ((__r2 = ((__const char *) (reject))[2], __r2 == '\0') ? __strcspn_c2 (s, __r0, __r1) : (((__const char *) (reject))[3] == '\0' ? __strcspn_c3 (s, __r0, __r1, __r2) : __builtin_strcspn (s, reject)))))) : __builtin_strcspn (s, reject)); })
# 969 "/usr/include/bits/string2.h" 3 4
extern __inline size_t __strcspn_c1 (const char *__s, int __reject);
extern __inline size_t
__strcspn_c1 (const char *__s, int __reject)
{
  register size_t __result = 0;
  while (__s[__result] != '\0' && __s[__result] != __reject)
    ++__result;
  return __result;
}

extern __inline size_t __strcspn_c2 (const char *__s, int __reject1,
                                     int __reject2);
extern __inline size_t
__strcspn_c2 (const char *__s, int __reject1, int __reject2)
{
  register size_t __result = 0;
  while (__s[__result] != '\0' && __s[__result] != __reject1
         && __s[__result] != __reject2)
    ++__result;
  return __result;
}

extern __inline size_t __strcspn_c3 (const char *__s, int __reject1,
                                     int __reject2, int __reject3);
extern __inline size_t
__strcspn_c3 (const char *__s, int __reject1, int __reject2,
              int __reject3)
{
  register size_t __result = 0;
  while (__s[__result] != '\0' && __s[__result] != __reject1
         && __s[__result] != __reject2 && __s[__result] != __reject3)
    ++__result;
  return __result;
}
# 1011 "/usr/include/bits/string2.h" 3 4
#define strspn(s,accept) __extension__ ({ char __a0, __a1, __a2; (__builtin_constant_p (accept) && __string2_1bptr_p (accept) ? ((__builtin_constant_p (s) && __string2_1bptr_p (s)) ? __builtin_strspn (s, accept) : ((__a0 = ((__const char *) (accept))[0], __a0 == '\0') ? ((void) (s), 0) : ((__a1 = ((__const char *) (accept))[1], __a1 == '\0') ? __strspn_c1 (s, __a0) : ((__a2 = ((__const char *) (accept))[2], __a2 == '\0') ? __strspn_c2 (s, __a0, __a1) : (((__const char *) (accept))[3] == '\0' ? __strspn_c3 (s, __a0, __a1, __a2) : __builtin_strspn (s, accept)))))) : __builtin_strspn (s, accept)); })
# 1045 "/usr/include/bits/string2.h" 3 4
extern __inline size_t __strspn_c1 (const char *__s, int __accept);
extern __inline size_t
__strspn_c1 (const char *__s, int __accept)
{
  register size_t __result = 0;

  while (__s[__result] == __accept)
    ++__result;
  return __result;
}

extern __inline size_t __strspn_c2 (const char *__s, int __accept1,
                                    int __accept2);
extern __inline size_t
__strspn_c2 (const char *__s, int __accept1, int __accept2)
{
  register size_t __result = 0;

  while (__s[__result] == __accept1 || __s[__result] == __accept2)
    ++__result;
  return __result;
}

extern __inline size_t __strspn_c3 (const char *__s, int __accept1,
                                    int __accept2, int __accept3);
extern __inline size_t
__strspn_c3 (const char *__s, int __accept1, int __accept2, int __accept3)
{
  register size_t __result = 0;

  while (__s[__result] == __accept1 || __s[__result] == __accept2
         || __s[__result] == __accept3)
    ++__result;
  return __result;
}







#define strpbrk(s,accept) __extension__ ({ char __a0, __a1, __a2; (__builtin_constant_p (accept) && __string2_1bptr_p (accept) ? ((__builtin_constant_p (s) && __string2_1bptr_p (s)) ? __builtin_strpbrk (s, accept) : ((__a0 = ((__const char *) (accept))[0], __a0 == '\0') ? ((void) (s), (char *) NULL) : ((__a1 = ((__const char *) (accept))[1], __a1 == '\0') ? __builtin_strchr (s, __a0) : ((__a2 = ((__const char *) (accept))[2], __a2 == '\0') ? __strpbrk_c2 (s, __a0, __a1) : (((__const char *) (accept))[3] == '\0' ? __strpbrk_c3 (s, __a0, __a1, __a2) : __builtin_strpbrk (s, accept)))))) : __builtin_strpbrk (s, accept)); })
# 1121 "/usr/include/bits/string2.h" 3 4
extern __inline char *__strpbrk_c2 (const char *__s, int __accept1,
                                     int __accept2);
extern __inline char *
__strpbrk_c2 (const char *__s, int __accept1, int __accept2)
{

  while (*__s != '\0' && *__s != __accept1 && *__s != __accept2)
    ++__s;
  return *__s == '\0' ? ((void *)0) : (char *) (size_t) __s;
}

extern __inline char *__strpbrk_c3 (const char *__s, int __accept1,
                                     int __accept2, int __accept3);
extern __inline char *
__strpbrk_c3 (const char *__s, int __accept1, int __accept2,
              int __accept3)
{

  while (*__s != '\0' && *__s != __accept1 && *__s != __accept2
         && *__s != __accept3)
    ++__s;
  return *__s == '\0' ? ((void *)0) : (char *) (size_t) __s;
}
# 1164 "/usr/include/bits/string2.h" 3 4
#define __strtok_r(s,sep,nextp) (__extension__ (__builtin_constant_p (sep) && __string2_1bptr_p (sep) ? (((__const char *) (sep))[0] != '\0' && ((__const char *) (sep))[1] == '\0' ? __strtok_r_1c (s, ((__const char *) (sep))[0], nextp) : __strtok_r (s, sep, nextp)) : __strtok_r (s, sep, nextp)))
# 1173 "/usr/include/bits/string2.h" 3 4
extern __inline char *__strtok_r_1c (char *__s, char __sep, char **__nextp);
extern __inline char *
__strtok_r_1c (char *__s, char __sep, char **__nextp)
{
  char *__result;
  if (__s == ((void *)0))
    __s = *__nextp;
  while (*__s == __sep)
    ++__s;
  __result = ((void *)0);
  if (*__s != '\0')
    {
      __result = __s++;
      while (*__s != '\0')
        if (*__s++ == __sep)
          {
            __s[-1] = '\0';
            break;
          }
      *__nextp = __s;
    }
  return __result;
}

#define strtok_r(s,sep,nextp) __strtok_r (s, sep, nextp)







extern char *__strsep_g (char **__stringp, const char *__delim);
#define __strsep(s,reject) __extension__ ({ char __r0, __r1, __r2; (__builtin_constant_p (reject) && __string2_1bptr_p (reject) && (__r0 = ((__const char *) (reject))[0], ((__const char *) (reject))[0] != '\0') ? ((__r1 = ((__const char *) (reject))[1], ((__const char *) (reject))[1] == '\0') ? __strsep_1c (s, __r0) : ((__r2 = ((__const char *) (reject))[2], __r2 == '\0') ? __strsep_2c (s, __r0, __r1) : (((__const char *) (reject))[3] == '\0' ? __strsep_3c (s, __r0, __r1, __r2) : __strsep_g (s, reject)))) : __strsep_g (s, reject)); })
# 1223 "/usr/include/bits/string2.h" 3 4
extern __inline char *__strsep_1c (char **__s, char __reject);
extern __inline char *
__strsep_1c (char **__s, char __reject)
{
  register char *__retval = *__s;
  if (__retval != ((void *)0) && (*__s = (__extension__ (__builtin_constant_p (__reject) && !__builtin_constant_p (__retval) && (__reject) == '\0' ? (char *) __rawmemchr (__retval, __reject) : __builtin_strchr (__retval, __reject)))) != ((void *)0))
    *(*__s)++ = '\0';
  return __retval;
}

extern __inline char *__strsep_2c (char **__s, char __reject1, char __reject2);
extern __inline char *
__strsep_2c (char **__s, char __reject1, char __reject2)
{
  register char *__retval = *__s;
  if (__retval != ((void *)0))
    {
      register char *__cp = __retval;
      while (1)
        {
          if (*__cp == '\0')
            {
              __cp = ((void *)0);
          break;
            }
          if (*__cp == __reject1 || *__cp == __reject2)
            {
              *__cp++ = '\0';
              break;
            }
          ++__cp;
        }
      *__s = __cp;
    }
  return __retval;
}

extern __inline char *__strsep_3c (char **__s, char __reject1, char __reject2,
                                   char __reject3);
extern __inline char *
__strsep_3c (char **__s, char __reject1, char __reject2, char __reject3)
{
  register char *__retval = *__s;
  if (__retval != ((void *)0))
    {
      register char *__cp = __retval;
      while (1)
        {
          if (*__cp == '\0')
            {
              __cp = ((void *)0);
          break;
            }
          if (*__cp == __reject1 || *__cp == __reject2 || *__cp == __reject3)
            {
              *__cp++ = '\0';
              break;
            }
          ++__cp;
        }
      *__s = __cp;
    }
  return __retval;
}

#define strsep(s,reject) __strsep (s, reject)
# 1298 "/usr/include/bits/string2.h" 3 4
#define __need_malloc_and_calloc 





extern char *__strdup (const char *__string) __attribute__ ((__nothrow__)) __attribute__ ((__malloc__));
#define __strdup(s) (__extension__ (__builtin_constant_p (s) && __string2_1bptr_p (s) ? (((__const char *) (s))[0] == '\0' ? (char *) calloc (1, 1) : ({ size_t __len = strlen (s) + 1; char *__retval = (char *) malloc (__len); if (__retval != NULL) __retval = (char *) memcpy (__retval, s, __len); __retval; })) : __strdup (s)))
# 1317 "/usr/include/bits/string2.h" 3 4
#define strdup(s) __strdup (s)





extern char *__strndup (const char *__string, size_t __n)
     __attribute__ ((__nothrow__)) __attribute__ ((__malloc__));
#define __strndup(s,n) (__extension__ (__builtin_constant_p (s) && __string2_1bptr_p (s) ? (((__const char *) (s))[0] == '\0' ? (char *) calloc (1, 1) : ({ size_t __len = strlen (s) + 1; size_t __n = (n); char *__retval; if (__n < __len) __len = __n + 1; __retval = (char *) malloc (__len); if (__retval != NULL) { __retval[__len - 1] = '\0'; __retval = (char *) memcpy (__retval, s, __len - 1); } __retval; })) : __strndup (s, n)))
# 1345 "/usr/include/bits/string2.h" 3 4
#define strndup(s,n) __strndup (s, n)






#undef __STRING_INLINE
# 418 "/usr/include/string.h" 2 3 4
# 426 "/usr/include/string.h" 3 4

# 34 "readelf.c" 2
# 1 "/usr/include/time.h" 1 3 4
# 27 "/usr/include/time.h" 3 4
#define _TIME_H 1








#define __need_size_t 
#define __need_NULL 
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 1 3 4
# 235 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#undef __need_size_t
# 397 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#undef NULL




#define NULL ((void *)0)





#undef __need_NULL





#define offsetof(TYPE,MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
# 39 "/usr/include/time.h" 2 3 4



# 1 "/usr/include/bits/time.h" 1 3 4
# 26 "/usr/include/bits/time.h" 3 4
#define _BITS_TIME_H 1







#define CLOCKS_PER_SEC 1000000l
# 46 "/usr/include/bits/time.h" 3 4
#define CLOCK_REALTIME 0

#define CLOCK_MONOTONIC 1

#define CLOCK_PROCESS_CPUTIME_ID 2

#define CLOCK_THREAD_CPUTIME_ID 3


#define TIMER_ABSTIME 1
# 43 "/usr/include/time.h" 2 3 4
# 129 "/usr/include/time.h" 3 4


struct tm
{
  int tm_sec;
  int tm_min;
  int tm_hour;
  int tm_mday;
  int tm_mon;
  int tm_year;
  int tm_wday;
  int tm_yday;
  int tm_isdst;


  long int tm_gmtoff;
  const char *tm_zone;




};








struct itimerspec
  {
    struct timespec it_interval;
    struct timespec it_value;
  };


struct sigevent;
# 178 "/usr/include/time.h" 3 4



extern clock_t clock (void) __attribute__ ((__nothrow__));


extern time_t time (time_t *__timer) __attribute__ ((__nothrow__));


extern double difftime (time_t __time1, time_t __time0)
     __attribute__ ((__nothrow__)) __attribute__ ((__const__));


extern time_t mktime (struct tm *__tp) __attribute__ ((__nothrow__));





extern size_t strftime (char *__restrict __s, size_t __maxsize,
                        const char *__restrict __format,
                        const struct tm *__restrict __tp) __attribute__ ((__nothrow__));





extern char *strptime (const char *__restrict __s,
                       const char *__restrict __fmt, struct tm *__tp)
     __attribute__ ((__nothrow__));







extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
                          const char *__restrict __format,
                          const struct tm *__restrict __tp,
                          __locale_t __loc) __attribute__ ((__nothrow__));

extern char *strptime_l (const char *__restrict __s,
                         const char *__restrict __fmt, struct tm *__tp,
                         __locale_t __loc) __attribute__ ((__nothrow__));






extern struct tm *gmtime (const time_t *__timer) __attribute__ ((__nothrow__));



extern struct tm *localtime (const time_t *__timer) __attribute__ ((__nothrow__));





extern struct tm *gmtime_r (const time_t *__restrict __timer,
                            struct tm *__restrict __tp) __attribute__ ((__nothrow__));



extern struct tm *localtime_r (const time_t *__restrict __timer,
                               struct tm *__restrict __tp) __attribute__ ((__nothrow__));





extern char *asctime (const struct tm *__tp) __attribute__ ((__nothrow__));


extern char *ctime (const time_t *__timer) __attribute__ ((__nothrow__));







extern char *asctime_r (const struct tm *__restrict __tp,
                        char *__restrict __buf) __attribute__ ((__nothrow__));


extern char *ctime_r (const time_t *__restrict __timer,
                      char *__restrict __buf) __attribute__ ((__nothrow__));




extern char *__tzname[2];
extern int __daylight;
extern long int __timezone;




extern char *tzname[2];



extern void tzset (void) __attribute__ ((__nothrow__));



extern int daylight;
extern long int timezone;





extern int stime (const time_t *__when) __attribute__ ((__nothrow__));





#define __isleap(year) ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
# 309 "/usr/include/time.h" 3 4
extern time_t timegm (struct tm *__tp) __attribute__ ((__nothrow__));


extern time_t timelocal (struct tm *__tp) __attribute__ ((__nothrow__));


extern int dysize (int __year) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
# 324 "/usr/include/time.h" 3 4
extern int nanosleep (const struct timespec *__requested_time,
                      struct timespec *__remaining);



extern int clock_getres (clockid_t __clock_id, struct timespec *__res) __attribute__ ((__nothrow__));


extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) __attribute__ ((__nothrow__));


extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
     __attribute__ ((__nothrow__));






extern int clock_nanosleep (clockid_t __clock_id, int __flags,
                            const struct timespec *__req,
                            struct timespec *__rem);


extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) __attribute__ ((__nothrow__));




extern int timer_create (clockid_t __clock_id,
                         struct sigevent *__restrict __evp,
                         timer_t *__restrict __timerid) __attribute__ ((__nothrow__));


extern int timer_delete (timer_t __timerid) __attribute__ ((__nothrow__));


extern int timer_settime (timer_t __timerid, int __flags,
                          const struct itimerspec *__restrict __value,
                          struct itimerspec *__restrict __ovalue) __attribute__ ((__nothrow__));


extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
     __attribute__ ((__nothrow__));


extern int timer_getoverrun (timer_t __timerid) __attribute__ ((__nothrow__));
# 386 "/usr/include/time.h" 3 4
extern int getdate_err;
# 395 "/usr/include/time.h" 3 4
extern struct tm *getdate (const char *__string);
# 409 "/usr/include/time.h" 3 4
extern int getdate_r (const char *__restrict __string,
                      struct tm *__restrict __resbufp);



# 35 "readelf.c" 2
# 1 "/usr/include/unistd.h" 1 3 4
# 24 "/usr/include/unistd.h" 3 4
#define _UNISTD_H 1









#define _POSIX_VERSION 200112L





#define _POSIX2_VERSION 200112L



#define _POSIX2_C_BIND 200112L



#define _POSIX2_C_DEV 200112L



#define _POSIX2_SW_DEV 200112L



#define _POSIX2_LOCALEDEF 200112L



#define _XOPEN_VERSION 500





#define _XOPEN_XCU_VERSION 4


#define _XOPEN_XPG2 1
#define _XOPEN_XPG3 1
#define _XOPEN_XPG4 1


#define _XOPEN_UNIX 1


#define _XOPEN_CRYPT 1



#define _XOPEN_ENH_I18N 1


#define _XOPEN_LEGACY 1
# 171 "/usr/include/unistd.h" 3 4
# 1 "/usr/include/bits/posix_opt.h" 1 3 4
# 21 "/usr/include/bits/posix_opt.h" 3 4
#define _POSIX_OPT_H 1


#define _POSIX_JOB_CONTROL 1


#define _POSIX_SAVED_IDS 1


#define _POSIX_PRIORITY_SCHEDULING 200112L


#define _POSIX_SYNCHRONIZED_IO 200112L


#define _POSIX_FSYNC 200112L


#define _POSIX_MAPPED_FILES 200112L


#define _POSIX_MEMLOCK 200112L


#define _POSIX_MEMLOCK_RANGE 200112L


#define _POSIX_MEMORY_PROTECTION 200112L


#define _POSIX_CHOWN_RESTRICTED 1



#define _POSIX_VDISABLE '\0'


#define _POSIX_NO_TRUNC 1


#define _XOPEN_REALTIME 1


#define _XOPEN_SHM 1


#define _POSIX_THREADS 200112L


#define _POSIX_REENTRANT_FUNCTIONS 1
#define _POSIX_THREAD_SAFE_FUNCTIONS 200112L


#define _POSIX_THREAD_PRIORITY_SCHEDULING 200112L


#define _POSIX_THREAD_ATTR_STACKSIZE 200112L


#define _POSIX_THREAD_ATTR_STACKADDR 200112L


#define _POSIX_SEMAPHORES 200112L


#define _POSIX_REALTIME_SIGNALS 200112L


#define _POSIX_ASYNCHRONOUS_IO 200112L
#define _POSIX_ASYNC_IO 1

#define _LFS_ASYNCHRONOUS_IO 1

#define _POSIX_PRIORITIZED_IO 200112L


#define _LFS64_ASYNCHRONOUS_IO 1


#define _LFS_LARGEFILE 1
#define _LFS64_LARGEFILE 1
#define _LFS64_STDIO 1


#define _POSIX_SHARED_MEMORY_OBJECTS 200112L


#define _POSIX_CPUTIME 0


#define _POSIX_THREAD_CPUTIME 0


#define _POSIX_REGEXP 1


#define _POSIX_READER_WRITER_LOCKS 200112L


#define _POSIX_SHELL 1


#define _POSIX_TIMEOUTS 200112L


#define _POSIX_SPIN_LOCKS 200112L


#define _POSIX_SPAWN 200112L


#define _POSIX_TIMERS 200112L


#define _POSIX_BARRIERS 200112L


#define _POSIX_MESSAGE_PASSING 200112L


#define _POSIX_THREAD_PROCESS_SHARED 200112L


#define _POSIX_MONOTONIC_CLOCK 0


#define _POSIX_CLOCK_SELECTION 200112L


#define _POSIX_ADVISORY_INFO 200112L


#define _POSIX_IPV6 200112L


#define _POSIX_RAW_SOCKETS 200112L


#define _POSIX2_CHAR_TERM 200112L


#define _POSIX_SPORADIC_SERVER -1
#define _POSIX_THREAD_SPORADIC_SERVER -1


#define _POSIX_TRACE -1
#define _POSIX_TRACE_EVENT_FILTER -1
#define _POSIX_TRACE_INHERIT -1
#define _POSIX_TRACE_LOG -1


#define _POSIX_TYPED_MEMORY_OBJECTS -1


#define _POSIX_THREAD_PRIO_INHERIT -1
#define _POSIX_THREAD_PRIO_PROTECT -1
# 172 "/usr/include/unistd.h" 2 3 4



# 1 "/usr/include/bits/environments.h" 1 3 4
# 41 "/usr/include/bits/environments.h" 3 4
#define _POSIX_V6_ILP32_OFF32 1
#define _POSIX_V6_ILP32_OFFBIG 1
#define _XBS5_ILP32_OFF32 1
#define _XBS5_ILP32_OFFBIG 1
# 57 "/usr/include/bits/environments.h" 3 4
#define __ILP32_OFF32_CFLAGS "-m32"
#define __ILP32_OFFBIG_CFLAGS "-m32 -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64"
#define __ILP32_OFF32_LDFLAGS "-m32"
#define __ILP32_OFFBIG_LDFLAGS "-m32"
#define __LP64_OFF64_CFLAGS "-m64"
#define __LP64_OFF64_LDFLAGS "-m64"
# 176 "/usr/include/unistd.h" 2 3 4



#define STDIN_FILENO 0
#define STDOUT_FILENO 1
#define STDERR_FILENO 2
# 193 "/usr/include/unistd.h" 3 4
#define __need_size_t 
#define __need_NULL 
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 1 3 4
# 235 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#undef __need_size_t
# 397 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 3 4
#undef NULL




#define NULL ((void *)0)





#undef __need_NULL





#define offsetof(TYPE,MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
# 196 "/usr/include/unistd.h" 2 3 4
# 243 "/usr/include/unistd.h" 3 4
typedef __socklen_t socklen_t;
#define __socklen_t_defined 





#define R_OK 4
#define W_OK 2
#define X_OK 1
#define F_OK 0


extern int access (const char *__name, int __type) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));




extern int euidaccess (const char *__name, int __type)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
# 275 "/usr/include/unistd.h" 3 4
#define L_SET SEEK_SET
#define L_INCR SEEK_CUR
#define L_XTND SEEK_END
# 290 "/usr/include/unistd.h" 3 4
extern __off64_t lseek (int __fd, __off64_t __offset, int __whence) __asm__ ("" "lseek64") __attribute__ ((__nothrow__));







extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence) __attribute__ ((__nothrow__));






extern int close (int __fd);






extern ssize_t read (int __fd, void *__buf, size_t __nbytes);





extern ssize_t write (int __fd, const void *__buf, size_t __n);
# 340 "/usr/include/unistd.h" 3 4
extern ssize_t pread (int __fd, void *__buf, size_t __nbytes, __off64_t __offset) __asm__ ("" "pread64");


extern ssize_t pwrite (int __fd, const void *__buf, size_t __nbytes, __off64_t __offset) __asm__ ("" "pwrite64");
# 356 "/usr/include/unistd.h" 3 4
extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes,
                        __off64_t __offset);


extern ssize_t pwrite64 (int __fd, const void *__buf, size_t __n,
                         __off64_t __offset);







extern int pipe (int __pipedes[2]) __attribute__ ((__nothrow__));
# 378 "/usr/include/unistd.h" 3 4
extern unsigned int alarm (unsigned int __seconds) __attribute__ ((__nothrow__));
# 390 "/usr/include/unistd.h" 3 4
extern unsigned int sleep (unsigned int __seconds);






extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
     __attribute__ ((__nothrow__));






extern int usleep (__useconds_t __useconds);
# 414 "/usr/include/unistd.h" 3 4
extern int pause (void);



extern int chown (const char *__file, __uid_t __owner, __gid_t __group)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));



extern int fchown (int __fd, __uid_t __owner, __gid_t __group) __attribute__ ((__nothrow__));




extern int lchown (const char *__file, __uid_t __owner, __gid_t __group)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));




extern int chdir (const char *__path) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));



extern int fchdir (int __fd) __attribute__ ((__nothrow__));
# 448 "/usr/include/unistd.h" 3 4
extern char *getcwd (char *__buf, size_t __size) __attribute__ ((__nothrow__));





extern char *get_current_dir_name (void) __attribute__ ((__nothrow__));






extern char *getwd (char *__buf) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));




extern int dup (int __fd) __attribute__ ((__nothrow__));


extern int dup2 (int __fd, int __fd2) __attribute__ ((__nothrow__));


extern char **__environ;

extern char **environ;





extern int execve (const char *__path, char *const __argv[],
                   char *const __envp[]) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));




extern int fexecve (int __fd, char *const __argv[], char *const __envp[])
     __attribute__ ((__nothrow__));




extern int execv (const char *__path, char *const __argv[])
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));



extern int execle (const char *__path, const char *__arg, ...)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));



extern int execl (const char *__path, const char *__arg, ...)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));



extern int execvp (const char *__file, char *const __argv[])
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));




extern int execlp (const char *__file, const char *__arg, ...)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));




extern int nice (int __inc) __attribute__ ((__nothrow__));




extern void _exit (int __status) __attribute__ ((__noreturn__));





# 1 "/usr/include/bits/confname.h" 1 3 4
# 26 "/usr/include/bits/confname.h" 3 4
enum
  {
    _PC_LINK_MAX,
#define _PC_LINK_MAX _PC_LINK_MAX
    _PC_MAX_CANON,
#define _PC_MAX_CANON _PC_MAX_CANON
    _PC_MAX_INPUT,
#define _PC_MAX_INPUT _PC_MAX_INPUT
    _PC_NAME_MAX,
#define _PC_NAME_MAX _PC_NAME_MAX
    _PC_PATH_MAX,
#define _PC_PATH_MAX _PC_PATH_MAX
    _PC_PIPE_BUF,
#define _PC_PIPE_BUF _PC_PIPE_BUF
    _PC_CHOWN_RESTRICTED,
#define _PC_CHOWN_RESTRICTED _PC_CHOWN_RESTRICTED
    _PC_NO_TRUNC,
#define _PC_NO_TRUNC _PC_NO_TRUNC
    _PC_VDISABLE,
#define _PC_VDISABLE _PC_VDISABLE
    _PC_SYNC_IO,
#define _PC_SYNC_IO _PC_SYNC_IO
    _PC_ASYNC_IO,
#define _PC_ASYNC_IO _PC_ASYNC_IO
    _PC_PRIO_IO,
#define _PC_PRIO_IO _PC_PRIO_IO
    _PC_SOCK_MAXBUF,
#define _PC_SOCK_MAXBUF _PC_SOCK_MAXBUF
    _PC_FILESIZEBITS,
#define _PC_FILESIZEBITS _PC_FILESIZEBITS
    _PC_REC_INCR_XFER_SIZE,
#define _PC_REC_INCR_XFER_SIZE _PC_REC_INCR_XFER_SIZE
    _PC_REC_MAX_XFER_SIZE,
#define _PC_REC_MAX_XFER_SIZE _PC_REC_MAX_XFER_SIZE
    _PC_REC_MIN_XFER_SIZE,
#define _PC_REC_MIN_XFER_SIZE _PC_REC_MIN_XFER_SIZE
    _PC_REC_XFER_ALIGN,
#define _PC_REC_XFER_ALIGN _PC_REC_XFER_ALIGN
    _PC_ALLOC_SIZE_MIN,
#define _PC_ALLOC_SIZE_MIN _PC_ALLOC_SIZE_MIN
    _PC_SYMLINK_MAX,
#define _PC_SYMLINK_MAX _PC_SYMLINK_MAX
    _PC_2_SYMLINKS
#define _PC_2_SYMLINKS _PC_2_SYMLINKS
  };


enum
  {
    _SC_ARG_MAX,
#define _SC_ARG_MAX _SC_ARG_MAX
    _SC_CHILD_MAX,
#define _SC_CHILD_MAX _SC_CHILD_MAX
    _SC_CLK_TCK,
#define _SC_CLK_TCK _SC_CLK_TCK
    _SC_NGROUPS_MAX,
#define _SC_NGROUPS_MAX _SC_NGROUPS_MAX
    _SC_OPEN_MAX,
#define _SC_OPEN_MAX _SC_OPEN_MAX
    _SC_STREAM_MAX,
#define _SC_STREAM_MAX _SC_STREAM_MAX
    _SC_TZNAME_MAX,
#define _SC_TZNAME_MAX _SC_TZNAME_MAX
    _SC_JOB_CONTROL,
#define _SC_JOB_CONTROL _SC_JOB_CONTROL
    _SC_SAVED_IDS,
#define _SC_SAVED_IDS _SC_SAVED_IDS
    _SC_REALTIME_SIGNALS,
#define _SC_REALTIME_SIGNALS _SC_REALTIME_SIGNALS
    _SC_PRIORITY_SCHEDULING,
#define _SC_PRIORITY_SCHEDULING _SC_PRIORITY_SCHEDULING
    _SC_TIMERS,
#define _SC_TIMERS _SC_TIMERS
    _SC_ASYNCHRONOUS_IO,
#define _SC_ASYNCHRONOUS_IO _SC_ASYNCHRONOUS_IO
    _SC_PRIORITIZED_IO,
#define _SC_PRIORITIZED_IO _SC_PRIORITIZED_IO
    _SC_SYNCHRONIZED_IO,
#define _SC_SYNCHRONIZED_IO _SC_SYNCHRONIZED_IO
    _SC_FSYNC,
#define _SC_FSYNC _SC_FSYNC
    _SC_MAPPED_FILES,
#define _SC_MAPPED_FILES _SC_MAPPED_FILES
    _SC_MEMLOCK,
#define _SC_MEMLOCK _SC_MEMLOCK
    _SC_MEMLOCK_RANGE,
#define _SC_MEMLOCK_RANGE _SC_MEMLOCK_RANGE
    _SC_MEMORY_PROTECTION,
#define _SC_MEMORY_PROTECTION _SC_MEMORY_PROTECTION
    _SC_MESSAGE_PASSING,
#define _SC_MESSAGE_PASSING _SC_MESSAGE_PASSING
    _SC_SEMAPHORES,
#define _SC_SEMAPHORES _SC_SEMAPHORES
    _SC_SHARED_MEMORY_OBJECTS,
#define _SC_SHARED_MEMORY_OBJECTS _SC_SHARED_MEMORY_OBJECTS
    _SC_AIO_LISTIO_MAX,
#define _SC_AIO_LISTIO_MAX _SC_AIO_LISTIO_MAX
    _SC_AIO_MAX,
#define _SC_AIO_MAX _SC_AIO_MAX
    _SC_AIO_PRIO_DELTA_MAX,
#define _SC_AIO_PRIO_DELTA_MAX _SC_AIO_PRIO_DELTA_MAX
    _SC_DELAYTIMER_MAX,
#define _SC_DELAYTIMER_MAX _SC_DELAYTIMER_MAX
    _SC_MQ_OPEN_MAX,
#define _SC_MQ_OPEN_MAX _SC_MQ_OPEN_MAX
    _SC_MQ_PRIO_MAX,
#define _SC_MQ_PRIO_MAX _SC_MQ_PRIO_MAX
    _SC_VERSION,
#define _SC_VERSION _SC_VERSION
    _SC_PAGESIZE,
#define _SC_PAGESIZE _SC_PAGESIZE
#define _SC_PAGE_SIZE _SC_PAGESIZE
    _SC_RTSIG_MAX,
#define _SC_RTSIG_MAX _SC_RTSIG_MAX
    _SC_SEM_NSEMS_MAX,
#define _SC_SEM_NSEMS_MAX _SC_SEM_NSEMS_MAX
    _SC_SEM_VALUE_MAX,
#define _SC_SEM_VALUE_MAX _SC_SEM_VALUE_MAX
    _SC_SIGQUEUE_MAX,
#define _SC_SIGQUEUE_MAX _SC_SIGQUEUE_MAX
    _SC_TIMER_MAX,
#define _SC_TIMER_MAX _SC_TIMER_MAX



    _SC_BC_BASE_MAX,
#define _SC_BC_BASE_MAX _SC_BC_BASE_MAX
    _SC_BC_DIM_MAX,
#define _SC_BC_DIM_MAX _SC_BC_DIM_MAX
    _SC_BC_SCALE_MAX,
#define _SC_BC_SCALE_MAX _SC_BC_SCALE_MAX
    _SC_BC_STRING_MAX,
#define _SC_BC_STRING_MAX _SC_BC_STRING_MAX
    _SC_COLL_WEIGHTS_MAX,
#define _SC_COLL_WEIGHTS_MAX _SC_COLL_WEIGHTS_MAX
    _SC_EQUIV_CLASS_MAX,
#define _SC_EQUIV_CLASS_MAX _SC_EQUIV_CLASS_MAX
    _SC_EXPR_NEST_MAX,
#define _SC_EXPR_NEST_MAX _SC_EXPR_NEST_MAX
    _SC_LINE_MAX,
#define _SC_LINE_MAX _SC_LINE_MAX
    _SC_RE_DUP_MAX,
#define _SC_RE_DUP_MAX _SC_RE_DUP_MAX
    _SC_CHARCLASS_NAME_MAX,
#define _SC_CHARCLASS_NAME_MAX _SC_CHARCLASS_NAME_MAX

    _SC_2_VERSION,
#define _SC_2_VERSION _SC_2_VERSION
    _SC_2_C_BIND,
#define _SC_2_C_BIND _SC_2_C_BIND
    _SC_2_C_DEV,
#define _SC_2_C_DEV _SC_2_C_DEV
    _SC_2_FORT_DEV,
#define _SC_2_FORT_DEV _SC_2_FORT_DEV
    _SC_2_FORT_RUN,
#define _SC_2_FORT_RUN _SC_2_FORT_RUN
    _SC_2_SW_DEV,
#define _SC_2_SW_DEV _SC_2_SW_DEV
    _SC_2_LOCALEDEF,
#define _SC_2_LOCALEDEF _SC_2_LOCALEDEF

    _SC_PII,
#define _SC_PII _SC_PII
    _SC_PII_XTI,
#define _SC_PII_XTI _SC_PII_XTI
    _SC_PII_SOCKET,
#define _SC_PII_SOCKET _SC_PII_SOCKET
    _SC_PII_INTERNET,
#define _SC_PII_INTERNET _SC_PII_INTERNET
    _SC_PII_OSI,
#define _SC_PII_OSI _SC_PII_OSI
    _SC_POLL,
#define _SC_POLL _SC_POLL
    _SC_SELECT,
#define _SC_SELECT _SC_SELECT
    _SC_UIO_MAXIOV,
#define _SC_UIO_MAXIOV _SC_UIO_MAXIOV
    _SC_IOV_MAX = _SC_UIO_MAXIOV,
#define _SC_IOV_MAX _SC_IOV_MAX
    _SC_PII_INTERNET_STREAM,
#define _SC_PII_INTERNET_STREAM _SC_PII_INTERNET_STREAM
    _SC_PII_INTERNET_DGRAM,
#define _SC_PII_INTERNET_DGRAM _SC_PII_INTERNET_DGRAM
    _SC_PII_OSI_COTS,
#define _SC_PII_OSI_COTS _SC_PII_OSI_COTS
    _SC_PII_OSI_CLTS,
#define _SC_PII_OSI_CLTS _SC_PII_OSI_CLTS
    _SC_PII_OSI_M,
#define _SC_PII_OSI_M _SC_PII_OSI_M
    _SC_T_IOV_MAX,
#define _SC_T_IOV_MAX _SC_T_IOV_MAX


    _SC_THREADS,
#define _SC_THREADS _SC_THREADS
    _SC_THREAD_SAFE_FUNCTIONS,
#define _SC_THREAD_SAFE_FUNCTIONS _SC_THREAD_SAFE_FUNCTIONS
    _SC_GETGR_R_SIZE_MAX,
#define _SC_GETGR_R_SIZE_MAX _SC_GETGR_R_SIZE_MAX
    _SC_GETPW_R_SIZE_MAX,
#define _SC_GETPW_R_SIZE_MAX _SC_GETPW_R_SIZE_MAX
    _SC_LOGIN_NAME_MAX,
#define _SC_LOGIN_NAME_MAX _SC_LOGIN_NAME_MAX
    _SC_TTY_NAME_MAX,
#define _SC_TTY_NAME_MAX _SC_TTY_NAME_MAX
    _SC_THREAD_DESTRUCTOR_ITERATIONS,
#define _SC_THREAD_DESTRUCTOR_ITERATIONS _SC_THREAD_DESTRUCTOR_ITERATIONS
    _SC_THREAD_KEYS_MAX,
#define _SC_THREAD_KEYS_MAX _SC_THREAD_KEYS_MAX
    _SC_THREAD_STACK_MIN,
#define _SC_THREAD_STACK_MIN _SC_THREAD_STACK_MIN
    _SC_THREAD_THREADS_MAX,
#define _SC_THREAD_THREADS_MAX _SC_THREAD_THREADS_MAX
    _SC_THREAD_ATTR_STACKADDR,
#define _SC_THREAD_ATTR_STACKADDR _SC_THREAD_ATTR_STACKADDR
    _SC_THREAD_ATTR_STACKSIZE,
#define _SC_THREAD_ATTR_STACKSIZE _SC_THREAD_ATTR_STACKSIZE
    _SC_THREAD_PRIORITY_SCHEDULING,
#define _SC_THREAD_PRIORITY_SCHEDULING _SC_THREAD_PRIORITY_SCHEDULING
    _SC_THREAD_PRIO_INHERIT,
#define _SC_THREAD_PRIO_INHERIT _SC_THREAD_PRIO_INHERIT
    _SC_THREAD_PRIO_PROTECT,
#define _SC_THREAD_PRIO_PROTECT _SC_THREAD_PRIO_PROTECT
    _SC_THREAD_PROCESS_SHARED,
#define _SC_THREAD_PROCESS_SHARED _SC_THREAD_PROCESS_SHARED

    _SC_NPROCESSORS_CONF,
#define _SC_NPROCESSORS_CONF _SC_NPROCESSORS_CONF
    _SC_NPROCESSORS_ONLN,
#define _SC_NPROCESSORS_ONLN _SC_NPROCESSORS_ONLN
    _SC_PHYS_PAGES,
#define _SC_PHYS_PAGES _SC_PHYS_PAGES
    _SC_AVPHYS_PAGES,
#define _SC_AVPHYS_PAGES _SC_AVPHYS_PAGES
    _SC_ATEXIT_MAX,
#define _SC_ATEXIT_MAX _SC_ATEXIT_MAX
    _SC_PASS_MAX,
#define _SC_PASS_MAX _SC_PASS_MAX

    _SC_XOPEN_VERSION,
#define _SC_XOPEN_VERSION _SC_XOPEN_VERSION
    _SC_XOPEN_XCU_VERSION,
#define _SC_XOPEN_XCU_VERSION _SC_XOPEN_XCU_VERSION
    _SC_XOPEN_UNIX,
#define _SC_XOPEN_UNIX _SC_XOPEN_UNIX
    _SC_XOPEN_CRYPT,
#define _SC_XOPEN_CRYPT _SC_XOPEN_CRYPT
    _SC_XOPEN_ENH_I18N,
#define _SC_XOPEN_ENH_I18N _SC_XOPEN_ENH_I18N
    _SC_XOPEN_SHM,
#define _SC_XOPEN_SHM _SC_XOPEN_SHM

    _SC_2_CHAR_TERM,
#define _SC_2_CHAR_TERM _SC_2_CHAR_TERM
    _SC_2_C_VERSION,
#define _SC_2_C_VERSION _SC_2_C_VERSION
    _SC_2_UPE,
#define _SC_2_UPE _SC_2_UPE

    _SC_XOPEN_XPG2,
#define _SC_XOPEN_XPG2 _SC_XOPEN_XPG2
    _SC_XOPEN_XPG3,
#define _SC_XOPEN_XPG3 _SC_XOPEN_XPG3
    _SC_XOPEN_XPG4,
#define _SC_XOPEN_XPG4 _SC_XOPEN_XPG4

    _SC_CHAR_BIT,
#define _SC_CHAR_BIT _SC_CHAR_BIT
    _SC_CHAR_MAX,
#define _SC_CHAR_MAX _SC_CHAR_MAX
    _SC_CHAR_MIN,
#define _SC_CHAR_MIN _SC_CHAR_MIN
    _SC_INT_MAX,
#define _SC_INT_MAX _SC_INT_MAX
    _SC_INT_MIN,
#define _SC_INT_MIN _SC_INT_MIN
    _SC_LONG_BIT,
#define _SC_LONG_BIT _SC_LONG_BIT
    _SC_WORD_BIT,
#define _SC_WORD_BIT _SC_WORD_BIT
    _SC_MB_LEN_MAX,
#define _SC_MB_LEN_MAX _SC_MB_LEN_MAX
    _SC_NZERO,
#define _SC_NZERO _SC_NZERO
    _SC_SSIZE_MAX,
#define _SC_SSIZE_MAX _SC_SSIZE_MAX
    _SC_SCHAR_MAX,
#define _SC_SCHAR_MAX _SC_SCHAR_MAX
    _SC_SCHAR_MIN,
#define _SC_SCHAR_MIN _SC_SCHAR_MIN
    _SC_SHRT_MAX,
#define _SC_SHRT_MAX _SC_SHRT_MAX
    _SC_SHRT_MIN,
#define _SC_SHRT_MIN _SC_SHRT_MIN
    _SC_UCHAR_MAX,
#define _SC_UCHAR_MAX _SC_UCHAR_MAX
    _SC_UINT_MAX,
#define _SC_UINT_MAX _SC_UINT_MAX
    _SC_ULONG_MAX,
#define _SC_ULONG_MAX _SC_ULONG_MAX
    _SC_USHRT_MAX,
#define _SC_USHRT_MAX _SC_USHRT_MAX

    _SC_NL_ARGMAX,
#define _SC_NL_ARGMAX _SC_NL_ARGMAX
    _SC_NL_LANGMAX,
#define _SC_NL_LANGMAX _SC_NL_LANGMAX
    _SC_NL_MSGMAX,
#define _SC_NL_MSGMAX _SC_NL_MSGMAX
    _SC_NL_NMAX,
#define _SC_NL_NMAX _SC_NL_NMAX
    _SC_NL_SETMAX,
#define _SC_NL_SETMAX _SC_NL_SETMAX
    _SC_NL_TEXTMAX,
#define _SC_NL_TEXTMAX _SC_NL_TEXTMAX

    _SC_XBS5_ILP32_OFF32,
#define _SC_XBS5_ILP32_OFF32 _SC_XBS5_ILP32_OFF32
    _SC_XBS5_ILP32_OFFBIG,
#define _SC_XBS5_ILP32_OFFBIG _SC_XBS5_ILP32_OFFBIG
    _SC_XBS5_LP64_OFF64,
#define _SC_XBS5_LP64_OFF64 _SC_XBS5_LP64_OFF64
    _SC_XBS5_LPBIG_OFFBIG,
#define _SC_XBS5_LPBIG_OFFBIG _SC_XBS5_LPBIG_OFFBIG

    _SC_XOPEN_LEGACY,
#define _SC_XOPEN_LEGACY _SC_XOPEN_LEGACY
    _SC_XOPEN_REALTIME,
#define _SC_XOPEN_REALTIME _SC_XOPEN_REALTIME
    _SC_XOPEN_REALTIME_THREADS,
#define _SC_XOPEN_REALTIME_THREADS _SC_XOPEN_REALTIME_THREADS

    _SC_ADVISORY_INFO,
#define _SC_ADVISORY_INFO _SC_ADVISORY_INFO
    _SC_BARRIERS,
#define _SC_BARRIERS _SC_BARRIERS
    _SC_BASE,
#define _SC_BASE _SC_BASE
    _SC_C_LANG_SUPPORT,
#define _SC_C_LANG_SUPPORT _SC_C_LANG_SUPPORT
    _SC_C_LANG_SUPPORT_R,
#define _SC_C_LANG_SUPPORT_R _SC_C_LANG_SUPPORT_R
    _SC_CLOCK_SELECTION,
#define _SC_CLOCK_SELECTION _SC_CLOCK_SELECTION
    _SC_CPUTIME,
#define _SC_CPUTIME _SC_CPUTIME
    _SC_THREAD_CPUTIME,
#define _SC_THREAD_CPUTIME _SC_THREAD_CPUTIME
    _SC_DEVICE_IO,
#define _SC_DEVICE_IO _SC_DEVICE_IO
    _SC_DEVICE_SPECIFIC,
#define _SC_DEVICE_SPECIFIC _SC_DEVICE_SPECIFIC
    _SC_DEVICE_SPECIFIC_R,
#define _SC_DEVICE_SPECIFIC_R _SC_DEVICE_SPECIFIC_R
    _SC_FD_MGMT,
#define _SC_FD_MGMT _SC_FD_MGMT
    _SC_FIFO,
#define _SC_FIFO _SC_FIFO
    _SC_PIPE,
#define _SC_PIPE _SC_PIPE
    _SC_FILE_ATTRIBUTES,
#define _SC_FILE_ATTRIBUTES _SC_FILE_ATTRIBUTES
    _SC_FILE_LOCKING,
#define _SC_FILE_LOCKING _SC_FILE_LOCKING
    _SC_FILE_SYSTEM,
#define _SC_FILE_SYSTEM _SC_FILE_SYSTEM
    _SC_MONOTONIC_CLOCK,
#define _SC_MONOTONIC_CLOCK _SC_MONOTONIC_CLOCK
    _SC_MULTI_PROCESS,
#define _SC_MULTI_PROCESS _SC_MULTI_PROCESS
    _SC_SINGLE_PROCESS,
#define _SC_SINGLE_PROCESS _SC_SINGLE_PROCESS
    _SC_NETWORKING,
#define _SC_NETWORKING _SC_NETWORKING
    _SC_READER_WRITER_LOCKS,
#define _SC_READER_WRITER_LOCKS _SC_READER_WRITER_LOCKS
    _SC_SPIN_LOCKS,
#define _SC_SPIN_LOCKS _SC_SPIN_LOCKS
    _SC_REGEXP,
#define _SC_REGEXP _SC_REGEXP
    _SC_REGEX_VERSION,
#define _SC_REGEX_VERSION _SC_REGEX_VERSION
    _SC_SHELL,
#define _SC_SHELL _SC_SHELL
    _SC_SIGNALS,
#define _SC_SIGNALS _SC_SIGNALS
    _SC_SPAWN,
#define _SC_SPAWN _SC_SPAWN
    _SC_SPORADIC_SERVER,
#define _SC_SPORADIC_SERVER _SC_SPORADIC_SERVER
    _SC_THREAD_SPORADIC_SERVER,
#define _SC_THREAD_SPORADIC_SERVER _SC_THREAD_SPORADIC_SERVER
    _SC_SYSTEM_DATABASE,
#define _SC_SYSTEM_DATABASE _SC_SYSTEM_DATABASE
    _SC_SYSTEM_DATABASE_R,
#define _SC_SYSTEM_DATABASE_R _SC_SYSTEM_DATABASE_R
    _SC_TIMEOUTS,
#define _SC_TIMEOUTS _SC_TIMEOUTS
    _SC_TYPED_MEMORY_OBJECTS,
#define _SC_TYPED_MEMORY_OBJECTS _SC_TYPED_MEMORY_OBJECTS
    _SC_USER_GROUPS,
#define _SC_USER_GROUPS _SC_USER_GROUPS
    _SC_USER_GROUPS_R,
#define _SC_USER_GROUPS_R _SC_USER_GROUPS_R
    _SC_2_PBS,
#define _SC_2_PBS _SC_2_PBS
    _SC_2_PBS_ACCOUNTING,
#define _SC_2_PBS_ACCOUNTING _SC_2_PBS_ACCOUNTING
    _SC_2_PBS_LOCATE,
#define _SC_2_PBS_LOCATE _SC_2_PBS_LOCATE
    _SC_2_PBS_MESSAGE,
#define _SC_2_PBS_MESSAGE _SC_2_PBS_MESSAGE
    _SC_2_PBS_TRACK,
#define _SC_2_PBS_TRACK _SC_2_PBS_TRACK
    _SC_SYMLOOP_MAX,
#define _SC_SYMLOOP_MAX _SC_SYMLOOP_MAX
    _SC_STREAMS,
#define _SC_STREAMS _SC_STREAMS
    _SC_2_PBS_CHECKPOINT,
#define _SC_2_PBS_CHECKPOINT _SC_2_PBS_CHECKPOINT

    _SC_V6_ILP32_OFF32,
#define _SC_V6_ILP32_OFF32 _SC_V6_ILP32_OFF32
    _SC_V6_ILP32_OFFBIG,
#define _SC_V6_ILP32_OFFBIG _SC_V6_ILP32_OFFBIG
    _SC_V6_LP64_OFF64,
#define _SC_V6_LP64_OFF64 _SC_V6_LP64_OFF64
    _SC_V6_LPBIG_OFFBIG,
#define _SC_V6_LPBIG_OFFBIG _SC_V6_LPBIG_OFFBIG

    _SC_HOST_NAME_MAX,
#define _SC_HOST_NAME_MAX _SC_HOST_NAME_MAX
    _SC_TRACE,
#define _SC_TRACE _SC_TRACE
    _SC_TRACE_EVENT_FILTER,
#define _SC_TRACE_EVENT_FILTER _SC_TRACE_EVENT_FILTER
    _SC_TRACE_INHERIT,
#define _SC_TRACE_INHERIT _SC_TRACE_INHERIT
    _SC_TRACE_LOG,
#define _SC_TRACE_LOG _SC_TRACE_LOG

    _SC_LEVEL1_ICACHE_SIZE,
#define _SC_LEVEL1_ICACHE_SIZE _SC_LEVEL1_ICACHE_SIZE
    _SC_LEVEL1_ICACHE_ASSOC,
#define _SC_LEVEL1_ICACHE_ASSOC _SC_LEVEL1_ICACHE_ASSOC
    _SC_LEVEL1_ICACHE_LINESIZE,
#define _SC_LEVEL1_ICACHE_LINESIZE _SC_LEVEL1_ICACHE_LINESIZE
    _SC_LEVEL1_DCACHE_SIZE,
#define _SC_LEVEL1_DCACHE_SIZE _SC_LEVEL1_DCACHE_SIZE
    _SC_LEVEL1_DCACHE_ASSOC,
#define _SC_LEVEL1_DCACHE_ASSOC _SC_LEVEL1_DCACHE_ASSOC
    _SC_LEVEL1_DCACHE_LINESIZE,
#define _SC_LEVEL1_DCACHE_LINESIZE _SC_LEVEL1_DCACHE_LINESIZE
    _SC_LEVEL2_CACHE_SIZE,
#define _SC_LEVEL2_CACHE_SIZE _SC_LEVEL2_CACHE_SIZE
    _SC_LEVEL2_CACHE_ASSOC,
#define _SC_LEVEL2_CACHE_ASSOC _SC_LEVEL2_CACHE_ASSOC
    _SC_LEVEL2_CACHE_LINESIZE,
#define _SC_LEVEL2_CACHE_LINESIZE _SC_LEVEL2_CACHE_LINESIZE
    _SC_LEVEL3_CACHE_SIZE,
#define _SC_LEVEL3_CACHE_SIZE _SC_LEVEL3_CACHE_SIZE
    _SC_LEVEL3_CACHE_ASSOC,
#define _SC_LEVEL3_CACHE_ASSOC _SC_LEVEL3_CACHE_ASSOC
    _SC_LEVEL3_CACHE_LINESIZE,
#define _SC_LEVEL3_CACHE_LINESIZE _SC_LEVEL3_CACHE_LINESIZE
    _SC_LEVEL4_CACHE_SIZE,
#define _SC_LEVEL4_CACHE_SIZE _SC_LEVEL4_CACHE_SIZE
    _SC_LEVEL4_CACHE_ASSOC,
#define _SC_LEVEL4_CACHE_ASSOC _SC_LEVEL4_CACHE_ASSOC
    _SC_LEVEL4_CACHE_LINESIZE,
#define _SC_LEVEL4_CACHE_LINESIZE _SC_LEVEL4_CACHE_LINESIZE


    _SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50,
#define _SC_IPV6 _SC_IPV6
    _SC_RAW_SOCKETS
#define _SC_RAW_SOCKETS _SC_RAW_SOCKETS
  };


enum
  {
    _CS_PATH,
#define _CS_PATH _CS_PATH

    _CS_V6_WIDTH_RESTRICTED_ENVS,
#define _CS_V6_WIDTH_RESTRICTED_ENVS _CS_V6_WIDTH_RESTRICTED_ENVS

    _CS_GNU_LIBC_VERSION,
#define _CS_GNU_LIBC_VERSION _CS_GNU_LIBC_VERSION
    _CS_GNU_LIBPTHREAD_VERSION,
#define _CS_GNU_LIBPTHREAD_VERSION _CS_GNU_LIBPTHREAD_VERSION

    _CS_LFS_CFLAGS = 1000,
#define _CS_LFS_CFLAGS _CS_LFS_CFLAGS
    _CS_LFS_LDFLAGS,
#define _CS_LFS_LDFLAGS _CS_LFS_LDFLAGS
    _CS_LFS_LIBS,
#define _CS_LFS_LIBS _CS_LFS_LIBS
    _CS_LFS_LINTFLAGS,
#define _CS_LFS_LINTFLAGS _CS_LFS_LINTFLAGS
    _CS_LFS64_CFLAGS,
#define _CS_LFS64_CFLAGS _CS_LFS64_CFLAGS
    _CS_LFS64_LDFLAGS,
#define _CS_LFS64_LDFLAGS _CS_LFS64_LDFLAGS
    _CS_LFS64_LIBS,
#define _CS_LFS64_LIBS _CS_LFS64_LIBS
    _CS_LFS64_LINTFLAGS,
#define _CS_LFS64_LINTFLAGS _CS_LFS64_LINTFLAGS

    _CS_XBS5_ILP32_OFF32_CFLAGS = 1100,
#define _CS_XBS5_ILP32_OFF32_CFLAGS _CS_XBS5_ILP32_OFF32_CFLAGS
    _CS_XBS5_ILP32_OFF32_LDFLAGS,
#define _CS_XBS5_ILP32_OFF32_LDFLAGS _CS_XBS5_ILP32_OFF32_LDFLAGS
    _CS_XBS5_ILP32_OFF32_LIBS,
#define _CS_XBS5_ILP32_OFF32_LIBS _CS_XBS5_ILP32_OFF32_LIBS
    _CS_XBS5_ILP32_OFF32_LINTFLAGS,
#define _CS_XBS5_ILP32_OFF32_LINTFLAGS _CS_XBS5_ILP32_OFF32_LINTFLAGS
    _CS_XBS5_ILP32_OFFBIG_CFLAGS,
#define _CS_XBS5_ILP32_OFFBIG_CFLAGS _CS_XBS5_ILP32_OFFBIG_CFLAGS
    _CS_XBS5_ILP32_OFFBIG_LDFLAGS,
#define _CS_XBS5_ILP32_OFFBIG_LDFLAGS _CS_XBS5_ILP32_OFFBIG_LDFLAGS
    _CS_XBS5_ILP32_OFFBIG_LIBS,
#define _CS_XBS5_ILP32_OFFBIG_LIBS _CS_XBS5_ILP32_OFFBIG_LIBS
    _CS_XBS5_ILP32_OFFBIG_LINTFLAGS,
#define _CS_XBS5_ILP32_OFFBIG_LINTFLAGS _CS_XBS5_ILP32_OFFBIG_LINTFLAGS
    _CS_XBS5_LP64_OFF64_CFLAGS,
#define _CS_XBS5_LP64_OFF64_CFLAGS _CS_XBS5_LP64_OFF64_CFLAGS
    _CS_XBS5_LP64_OFF64_LDFLAGS,
#define _CS_XBS5_LP64_OFF64_LDFLAGS _CS_XBS5_LP64_OFF64_LDFLAGS
    _CS_XBS5_LP64_OFF64_LIBS,
#define _CS_XBS5_LP64_OFF64_LIBS _CS_XBS5_LP64_OFF64_LIBS
    _CS_XBS5_LP64_OFF64_LINTFLAGS,
#define _CS_XBS5_LP64_OFF64_LINTFLAGS _CS_XBS5_LP64_OFF64_LINTFLAGS
    _CS_XBS5_LPBIG_OFFBIG_CFLAGS,
#define _CS_XBS5_LPBIG_OFFBIG_CFLAGS _CS_XBS5_LPBIG_OFFBIG_CFLAGS
    _CS_XBS5_LPBIG_OFFBIG_LDFLAGS,
#define _CS_XBS5_LPBIG_OFFBIG_LDFLAGS _CS_XBS5_LPBIG_OFFBIG_LDFLAGS
    _CS_XBS5_LPBIG_OFFBIG_LIBS,
#define _CS_XBS5_LPBIG_OFFBIG_LIBS _CS_XBS5_LPBIG_OFFBIG_LIBS
    _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS,
#define _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS

    _CS_POSIX_V6_ILP32_OFF32_CFLAGS,
#define _CS_POSIX_V6_ILP32_OFF32_CFLAGS _CS_POSIX_V6_ILP32_OFF32_CFLAGS
    _CS_POSIX_V6_ILP32_OFF32_LDFLAGS,
#define _CS_POSIX_V6_ILP32_OFF32_LDFLAGS _CS_POSIX_V6_ILP32_OFF32_LDFLAGS
    _CS_POSIX_V6_ILP32_OFF32_LIBS,
#define _CS_POSIX_V6_ILP32_OFF32_LIBS _CS_POSIX_V6_ILP32_OFF32_LIBS
    _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS,
#define _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS
    _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS,
#define _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS
    _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS,
#define _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS
    _CS_POSIX_V6_ILP32_OFFBIG_LIBS,
#define _CS_POSIX_V6_ILP32_OFFBIG_LIBS _CS_POSIX_V6_ILP32_OFFBIG_LIBS
    _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS,
#define _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS
    _CS_POSIX_V6_LP64_OFF64_CFLAGS,
#define _CS_POSIX_V6_LP64_OFF64_CFLAGS _CS_POSIX_V6_LP64_OFF64_CFLAGS
    _CS_POSIX_V6_LP64_OFF64_LDFLAGS,
#define _CS_POSIX_V6_LP64_OFF64_LDFLAGS _CS_POSIX_V6_LP64_OFF64_LDFLAGS
    _CS_POSIX_V6_LP64_OFF64_LIBS,
#define _CS_POSIX_V6_LP64_OFF64_LIBS _CS_POSIX_V6_LP64_OFF64_LIBS
    _CS_POSIX_V6_LP64_OFF64_LINTFLAGS,
#define _CS_POSIX_V6_LP64_OFF64_LINTFLAGS _CS_POSIX_V6_LP64_OFF64_LINTFLAGS
    _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS,
#define _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS
    _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS,
#define _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS
    _CS_POSIX_V6_LPBIG_OFFBIG_LIBS,
#define _CS_POSIX_V6_LPBIG_OFFBIG_LIBS _CS_POSIX_V6_LPBIG_OFFBIG_LIBS
    _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS
#define _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS
  };
# 531 "/usr/include/unistd.h" 2 3 4


extern long int pathconf (const char *__path, int __name)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));


extern long int fpathconf (int __fd, int __name) __attribute__ ((__nothrow__));


extern long int sysconf (int __name) __attribute__ ((__nothrow__)) __attribute__ ((__const__));



extern size_t confstr (int __name, char *__buf, size_t __len) __attribute__ ((__nothrow__));




extern __pid_t getpid (void) __attribute__ ((__nothrow__));


extern __pid_t getppid (void) __attribute__ ((__nothrow__));




extern __pid_t getpgrp (void) __attribute__ ((__nothrow__));
# 567 "/usr/include/unistd.h" 3 4
extern __pid_t __getpgid (__pid_t __pid) __attribute__ ((__nothrow__));

extern __pid_t getpgid (__pid_t __pid) __attribute__ ((__nothrow__));






extern int setpgid (__pid_t __pid, __pid_t __pgid) __attribute__ ((__nothrow__));
# 593 "/usr/include/unistd.h" 3 4
extern int setpgrp (void) __attribute__ ((__nothrow__));
# 610 "/usr/include/unistd.h" 3 4
extern __pid_t setsid (void) __attribute__ ((__nothrow__));



extern __pid_t getsid (__pid_t __pid) __attribute__ ((__nothrow__));



extern __uid_t getuid (void) __attribute__ ((__nothrow__));


extern __uid_t geteuid (void) __attribute__ ((__nothrow__));


extern __gid_t getgid (void) __attribute__ ((__nothrow__));


extern __gid_t getegid (void) __attribute__ ((__nothrow__));




extern int getgroups (int __size, __gid_t __list[]) __attribute__ ((__nothrow__));



extern int group_member (__gid_t __gid) __attribute__ ((__nothrow__));






extern int setuid (__uid_t __uid) __attribute__ ((__nothrow__));




extern int setreuid (__uid_t __ruid, __uid_t __euid) __attribute__ ((__nothrow__));




extern int seteuid (__uid_t __uid) __attribute__ ((__nothrow__));






extern int setgid (__gid_t __gid) __attribute__ ((__nothrow__));




extern int setregid (__gid_t __rgid, __gid_t __egid) __attribute__ ((__nothrow__));




extern int setegid (__gid_t __gid) __attribute__ ((__nothrow__));





extern int getresuid (__uid_t *__euid, __uid_t *__ruid, __uid_t *__suid);



extern int getresgid (__gid_t *__egid, __gid_t *__rgid, __gid_t *__sgid);



extern int setresuid (__uid_t __euid, __uid_t __ruid, __uid_t __suid);



extern int setresgid (__gid_t __egid, __gid_t __rgid, __gid_t __sgid);






extern __pid_t fork (void) __attribute__ ((__nothrow__));






extern __pid_t vfork (void) __attribute__ ((__nothrow__));





extern char *ttyname (int __fd) __attribute__ ((__nothrow__));



extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));



extern int isatty (int __fd) __attribute__ ((__nothrow__));





extern int ttyslot (void) __attribute__ ((__nothrow__));




extern int link (const char *__from, const char *__to)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));



extern int symlink (const char *__from, const char *__to)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));




extern int readlink (const char *__restrict __path, char *__restrict __buf,
                     size_t __len) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));



extern int unlink (const char *__name) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));


extern int rmdir (const char *__path) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));



extern __pid_t tcgetpgrp (int __fd) __attribute__ ((__nothrow__));


extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) __attribute__ ((__nothrow__));






extern char *getlogin (void);







extern int getlogin_r (char *__name, size_t __name_len) __attribute__ ((__nonnull__ (1)));




extern int setlogin (const char *__name) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));







#define __need_getopt 
# 791 "/usr/include/unistd.h" 3 4
extern int gethostname (char *__name, size_t __len) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));






extern int sethostname (const char *__name, size_t __len)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));



extern int sethostid (long int __id) __attribute__ ((__nothrow__));





extern int getdomainname (char *__name, size_t __len)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
extern int setdomainname (const char *__name, size_t __len)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));





extern int vhangup (void) __attribute__ ((__nothrow__));


extern int revoke (const char *__file) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));







extern int profil (unsigned short int *__sample_buffer, size_t __size,
                   size_t __offset, unsigned int __scale)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));





extern int acct (const char *__name) __attribute__ ((__nothrow__));



extern char *getusershell (void) __attribute__ ((__nothrow__));
extern void endusershell (void) __attribute__ ((__nothrow__));
extern void setusershell (void) __attribute__ ((__nothrow__));





extern int daemon (int __nochdir, int __noclose) __attribute__ ((__nothrow__));






extern int chroot (const char *__path) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));



extern char *getpass (const char *__prompt) __attribute__ ((__nonnull__ (1)));
# 869 "/usr/include/unistd.h" 3 4
extern int fsync (int __fd);






extern long int gethostid (void);


extern void sync (void) __attribute__ ((__nothrow__));




extern int getpagesize (void) __attribute__ ((__nothrow__)) __attribute__ ((__const__));




extern int getdtablesize (void) __attribute__ ((__nothrow__));
# 898 "/usr/include/unistd.h" 3 4
extern int truncate (const char *__file, __off64_t __length) __asm__ ("" "truncate64") __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));







extern int truncate64 (const char *__file, __off64_t __length)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
# 919 "/usr/include/unistd.h" 3 4
extern int ftruncate (int __fd, __off64_t __length) __asm__ ("" "ftruncate64") __attribute__ ((__nothrow__));






extern int ftruncate64 (int __fd, __off64_t __length) __attribute__ ((__nothrow__));
# 936 "/usr/include/unistd.h" 3 4
extern int brk (void *__addr) __attribute__ ((__nothrow__));





extern void *sbrk (intptr_t __delta) __attribute__ ((__nothrow__));
# 957 "/usr/include/unistd.h" 3 4
extern long int syscall (long int __sysno, ...) __attribute__ ((__nothrow__));
# 1000 "/usr/include/unistd.h" 3 4
#define TEMP_FAILURE_RETRY(expression) (__extension__ ({ long int __result; do __result = (long int) (expression); while (__result == -1L && errno == EINTR); __result; }))
# 1011 "/usr/include/unistd.h" 3 4
extern int fdatasync (int __fildes) __attribute__ ((__nothrow__));







extern char *crypt (const char *__key, const char *__salt)
     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));



extern void encrypt (char *__block, int __edflag) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));






extern void swab (const void *__restrict __from, void *__restrict __to,
                  ssize_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));







extern char *ctermid (char *__s) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));



# 36 "readelf.c" 2
# 1 "/usr/include/sys/param.h" 1 3 4
# 20 "/usr/include/sys/param.h" 3 4
#define _SYS_PARAM_H 1

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/limits.h" 1 3 4






#define _GCC_LIMITS_H_ 



# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/syslimits.h" 1 3 4





#define _GCC_NEXT_LIMITS_H 
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/limits.h" 1 3 4
# 122 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/limits.h" 3 4
# 1 "/usr/include/limits.h" 1 3 4
# 24 "/usr/include/limits.h" 3 4
#define _LIBC_LIMITS_H_ 1







#define MB_LEN_MAX 16
# 144 "/usr/include/limits.h" 3 4
# 1 "/usr/include/bits/posix1_lim.h" 1 3 4
# 26 "/usr/include/bits/posix1_lim.h" 3 4
#define _BITS_POSIX1_LIM_H 1





#define _POSIX_AIO_LISTIO_MAX 2


#define _POSIX_AIO_MAX 1


#define _POSIX_ARG_MAX 4096



#define _POSIX_CHILD_MAX 25





#define _POSIX_DELAYTIMER_MAX 32



#define _POSIX_HOST_NAME_MAX 255


#define _POSIX_LINK_MAX 8


#define _POSIX_LOGIN_NAME_MAX 9


#define _POSIX_MAX_CANON 255



#define _POSIX_MAX_INPUT 255


#define _POSIX_MQ_OPEN_MAX 8


#define _POSIX_MQ_PRIO_MAX 32


#define _POSIX_NAME_MAX 14



#define _POSIX_NGROUPS_MAX 8






#define _POSIX_OPEN_MAX 20






#define _POSIX_FD_SETSIZE _POSIX_OPEN_MAX


#define _POSIX_PATH_MAX 256


#define _POSIX_PIPE_BUF 512



#define _POSIX_RE_DUP_MAX 255


#define _POSIX_RTSIG_MAX 8


#define _POSIX_SEM_NSEMS_MAX 256


#define _POSIX_SEM_VALUE_MAX 32767


#define _POSIX_SIGQUEUE_MAX 32


#define _POSIX_SSIZE_MAX 32767


#define _POSIX_STREAM_MAX 8


#define _POSIX_SYMLINK_MAX 255



#define _POSIX_SYMLOOP_MAX 8


#define _POSIX_TIMER_MAX 32


#define _POSIX_TTY_NAME_MAX 9


#define _POSIX_TZNAME_MAX 6


#define _POSIX_QLIMIT 1



#define _POSIX_HIWAT _POSIX_PIPE_BUF


#define _POSIX_UIO_MAXIOV 16


#define _POSIX_CLOCKRES_MIN 20000000



# 1 "/usr/include/bits/local_lim.h" 1 3 4
# 26 "/usr/include/bits/local_lim.h" 3 4
#define __undef_NR_OPEN 


#define __undef_LINK_MAX 


#define __undef_OPEN_MAX 



# 1 "/usr/include/linux/limits.h" 1 3 4

#define _LINUX_LIMITS_H 

#define NR_OPEN 1024

#define NGROUPS_MAX 65536
#define ARG_MAX 131072
#define CHILD_MAX 999
#define OPEN_MAX 256
#define LINK_MAX 127
#define MAX_CANON 255
#define MAX_INPUT 255
#define NAME_MAX 255
#define PATH_MAX 4096
#define PIPE_BUF 4096
#define XATTR_NAME_MAX 255
#define XATTR_SIZE_MAX 65536
#define XATTR_LIST_MAX 65536

#define RTSIG_MAX 32
# 37 "/usr/include/bits/local_lim.h" 2 3 4



#undef NR_OPEN
#undef __undef_NR_OPEN



#undef LINK_MAX
#undef __undef_LINK_MAX



#undef OPEN_MAX
#undef __undef_OPEN_MAX



#define _POSIX_THREAD_KEYS_MAX 128

#define PTHREAD_KEYS_MAX 1024


#define _POSIX_THREAD_DESTRUCTOR_ITERATIONS 4

#define PTHREAD_DESTRUCTOR_ITERATIONS _POSIX_THREAD_DESTRUCTOR_ITERATIONS


#define _POSIX_THREAD_THREADS_MAX 64





#define AIO_PRIO_DELTA_MAX 20


#define PTHREAD_STACK_MIN 16384


#define DELAYTIMER_MAX 2147483647


#define TTY_NAME_MAX 32


#define LOGIN_NAME_MAX 256


#define HOST_NAME_MAX 64


#define MQ_PRIO_MAX 32768
# 154 "/usr/include/bits/posix1_lim.h" 2 3 4



#define SSIZE_MAX LONG_MAX
# 145 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/bits/posix2_lim.h" 1 3 4
# 24 "/usr/include/bits/posix2_lim.h" 3 4
#define _BITS_POSIX2_LIM_H 1



#define _POSIX2_BC_BASE_MAX 99


#define _POSIX2_BC_DIM_MAX 2048


#define _POSIX2_BC_SCALE_MAX 99


#define _POSIX2_BC_STRING_MAX 1000



#define _POSIX2_COLL_WEIGHTS_MAX 2



#define _POSIX2_EXPR_NEST_MAX 32


#define _POSIX2_LINE_MAX 2048



#define _POSIX2_RE_DUP_MAX 255



#define _POSIX2_CHARCLASS_NAME_MAX 14







#define BC_BASE_MAX _POSIX2_BC_BASE_MAX


#define BC_DIM_MAX _POSIX2_BC_DIM_MAX


#define BC_SCALE_MAX _POSIX2_BC_SCALE_MAX


#define BC_STRING_MAX _POSIX2_BC_STRING_MAX


#define COLL_WEIGHTS_MAX 255


#define EXPR_NEST_MAX _POSIX2_EXPR_NEST_MAX


#define LINE_MAX _POSIX2_LINE_MAX


#define CHARCLASS_NAME_MAX 2048



#define RE_DUP_MAX (0x7fff)
# 149 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/bits/xopen_lim.h" 1 3 4
# 31 "/usr/include/bits/xopen_lim.h" 3 4
#define _XOPEN_LIM_H 1

#define __need_IOV_MAX 
# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
# 24 "/usr/include/bits/stdio_lim.h" 3 4
#define L_tmpnam 20
#define TMP_MAX 238328
#define FILENAME_MAX 4096


#define L_ctermid 9
#define L_cuserid 9




#undef FOPEN_MAX
#define FOPEN_MAX 16



#define IOV_MAX 1024
# 35 "/usr/include/bits/xopen_lim.h" 2 3 4
# 66 "/usr/include/bits/xopen_lim.h" 3 4
#define _XOPEN_IOV_MAX _POSIX_UIO_MAXIOV




#define NL_ARGMAX _POSIX_ARG_MAX


#define NL_LANGMAX _POSIX2_LINE_MAX


#define NL_MSGMAX INT_MAX



#define NL_NMAX INT_MAX


#define NL_SETMAX INT_MAX


#define NL_TEXTMAX INT_MAX


#define NZERO 20
# 110 "/usr/include/bits/xopen_lim.h" 3 4
#define WORD_BIT 32
# 130 "/usr/include/bits/xopen_lim.h" 3 4
#define LONG_BIT 32
# 153 "/usr/include/limits.h" 2 3 4
# 123 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/limits.h" 2 3 4
# 8 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/syslimits.h" 2 3 4
#undef _GCC_NEXT_LIMITS_H
# 12 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/limits.h" 2 3 4


#define _LIMITS_H___ 



#define CHAR_BIT __CHAR_BIT__
# 27 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/limits.h" 3 4
#define SCHAR_MIN (-SCHAR_MAX - 1)

#define SCHAR_MAX __SCHAR_MAX__






#define UCHAR_MAX (SCHAR_MAX * 2 + 1)
# 51 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/limits.h" 3 4
#define CHAR_MIN SCHAR_MIN

#define CHAR_MAX SCHAR_MAX




#define SHRT_MIN (-SHRT_MAX - 1)

#define SHRT_MAX __SHRT_MAX__






#define USHRT_MAX (SHRT_MAX * 2 + 1)




#define INT_MIN (-INT_MAX - 1)

#define INT_MAX __INT_MAX__



#define UINT_MAX (INT_MAX * 2U + 1U)




#define LONG_MIN (-LONG_MAX - 1L)

#define LONG_MAX __LONG_MAX__



#define ULONG_MAX (LONG_MAX * 2UL + 1UL)




#define LLONG_MIN (-LLONG_MAX - 1LL)

#define LLONG_MAX __LONG_LONG_MAX__



#define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)





#define LONG_LONG_MIN (-LONG_LONG_MAX - 1LL)

#define LONG_LONG_MAX __LONG_LONG_MAX__



#define ULONG_LONG_MAX (LONG_LONG_MAX * 2ULL + 1ULL)
# 23 "/usr/include/sys/param.h" 2 3 4

# 1 "/usr/include/linux/param.h" 1 3 4

#define _LINUX_PARAM_H 

# 1 "/usr/include/asm/param.h" 1 3 4

#define _ASMi386_PARAM_H 
# 11 "/usr/include/asm/param.h" 3 4
#define HZ 100



#define USER_HZ 100


#define EXEC_PAGESIZE 4096


#define NOGROUP (-1)


#define MAXHOSTNAMELEN 64
#define COMMAND_LINE_SIZE 256
# 5 "/usr/include/linux/param.h" 2 3 4
# 25 "/usr/include/sys/param.h" 2 3 4



#define NBBY CHAR_BIT

#define NGROUPS NGROUPS_MAX

#define MAXSYMLINKS 20
#define CANBSIZ MAX_CANON
#define NCARGS ARG_MAX
#define MAXPATHLEN PATH_MAX



#define NOFILE 256





#define setbit(a,i) ((a)[(i)/NBBY] |= 1<<((i)%NBBY))
#define clrbit(a,i) ((a)[(i)/NBBY] &= ~(1<<((i)%NBBY)))
#define isset(a,i) ((a)[(i)/NBBY] & (1<<((i)%NBBY)))
#define isclr(a,i) (((a)[(i)/NBBY] & (1<<((i)%NBBY))) == 0)



#define howmany(x,y) (((x) + ((y) - 1)) / (y))


#define roundup(x,y) (__builtin_constant_p (y) && powerof2 (y) ? (((x) + (y) - 1) & ~((y) - 1)) : ((((x) + ((y) - 1)) / (y)) * (y)))





#define powerof2(x) ((((x) - 1) & (x)) == 0)


#define MIN(a,b) (((a)<(b))?(a):(b))
#define MAX(a,b) (((a)>(b))?(a):(b))



#define DEV_BSIZE 512
# 37 "readelf.c" 2

# 1 "../lib/system.h" 1
# 17 "../lib/system.h"
#define LIB_SYSTEM_H 1

# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 1 3 4
# 20 "../lib/system.h" 2


extern void *xmalloc (size_t) __attribute__ ((__malloc__));
extern void *xcalloc (size_t, size_t) __attribute__ ((__malloc__));
extern void *xrealloc (void *, size_t) __attribute__ ((__malloc__));

extern char *xstrdup (const char *) __attribute__ ((__malloc__));
extern char *xstrndup (const char *, size_t) __attribute__ ((__malloc__));


extern uint32_t crc32 (uint32_t crc, unsigned char *buf, size_t len);
extern int crc32_file (int fd, uint32_t *resp);


#define sgettext(Str) ({ const char *__res = strrchr (gettext (Str), '|'); __res ? __res + 1 : Str; })



#define gettext_noop(Str) Str


#define pwrite_retry(fd,buf,len,off) TEMP_FAILURE_RETRY (pwrite (fd, buf, len, off))

#define write_retry(fd,buf,n) TEMP_FAILURE_RETRY (write (fd, buf, n))

#define pread_retry(fd,buf,len,off) TEMP_FAILURE_RETRY (pread (fd, buf, len, off))
# 39 "readelf.c" 2
# 1 "../libebl/libeblP.h" 1
# 15 "../libebl/libeblP.h"
#define _LIBEBLP_H 1


# 1 "../libebl/libebl.h" 1
# 15 "../libebl/libebl.h"
#define _LIBEBL_H 1




# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 1 3 4
# 21 "../libebl/libebl.h" 2


# 1 "../libelf/elf-knowledge.h" 1
# 19 "../libelf/elf-knowledge.h"
#define _ELF_KNOWLEDGE_H 1





#define SECTION_STRIP_P(shdr,name,remove_comment) (((shdr)->sh_flags & SHF_ALLOC) == 0 && (shdr)->sh_type != SHT_NOTE && (((shdr)->sh_type) != SHT_PROGBITS || (strncmp (name, ".gnu.warning.", sizeof ".gnu.warning." - 1) != 0 && (remove_comment || strcmp (name, ".comment") != 0))) && (shdr)->sh_type < SHT_NUM)
# 50 "../libelf/elf-knowledge.h"
#define SH_INFO_LINK_P(Shdr) ((Shdr)->sh_type == SHT_REL || (Shdr)->sh_type == SHT_RELA || ((Shdr)->sh_flags & SHF_INFO_LINK) != 0)
# 65 "../libelf/elf-knowledge.h"
#define SH_FLAGS_COMBINE(Flags1,Flags2) (((Flags1 | Flags2) & (SHF_WRITE | SHF_ALLOC | SHF_EXECINSTR | SHF_LINK_ORDER | SHF_OS_NONCONFORMING | SHF_GROUP)) | (Flags1 & Flags2 & (SHF_MERGE | SHF_STRINGS | SHF_INFO_LINK)))
# 75 "../libelf/elf-knowledge.h"
#define SH_FLAGS_IMPORTANT(Flags) ((Flags) & ~((GElf_Xword) 0 | SHF_LINK_ORDER | SHF_OS_NONCONFORMING))
# 89 "../libelf/elf-knowledge.h"
#define SH_ENTSIZE_HASH(Ehdr) ((Ehdr)->e_machine == EM_ALPHA || ((Ehdr)->e_machine == EM_S390 && (Ehdr)->e_ident[EI_CLASS] == ELFCLASS64) ? 8 : 4)
# 24 "../libebl/libebl.h" 2



typedef struct ebl Ebl;



extern Ebl *ebl_openbackend (Elf *elf);

extern Ebl *ebl_openbackend_machine (GElf_Half machine);

extern Ebl *ebl_openbackend_emulation (const char *emulation);


extern void ebl_closebackend (Ebl *bh);





extern int ebl_get_elfmachine (Ebl *ebl) __attribute__ ((__pure__));


extern int ebl_get_elfclass (Ebl *ebl) __attribute__ ((__pure__));


extern int ebl_get_elfdata (Ebl *ebl) __attribute__ ((__pure__));






extern const char *ebl_backend_name (Ebl *ebl);


extern const char *ebl_object_type_name (Ebl *ebl, int object,
                                         char *buf, size_t len);


extern const char *ebl_reloc_type_name (Ebl *ebl, int reloc,
                                        char *buf, size_t len);


extern _Bool ebl_reloc_type_check (Ebl *ebl, int reloc);


extern _Bool ebl_reloc_valid_use (Ebl *ebl, int reloc);



extern Elf_Type ebl_reloc_simple_type (Ebl *ebl, int reloc);



extern _Bool ebl_gotpc_reloc_check (Ebl *ebl, int reloc);


extern const char *ebl_segment_type_name (Ebl *ebl, int segment,
                                          char *buf, size_t len);


extern const char *ebl_section_type_name (Ebl *ebl, int section,
                                          char *buf, size_t len);


extern const char *ebl_section_name (Ebl *ebl, int section, int xsection,
                                     char *buf, size_t len,
                                     const char *scnnames[], size_t shnum);


extern const char *ebl_machine_flag_name (Ebl *ebl, GElf_Word flags,
                                          char *buf, size_t len);


extern _Bool ebl_machine_flag_check (Ebl *ebl, GElf_Word flags);


extern const char *ebl_symbol_type_name (Ebl *ebl, int symbol,
                                         char *buf, size_t len);


extern const char *ebl_symbol_binding_name (Ebl *ebl, int binding,
                                            char *buf, size_t len);


extern const char *ebl_dynamic_tag_name (Ebl *ebl, int64_t tag,
                                         char *buf, size_t len);


extern _Bool ebl_dynamic_tag_check (Ebl *ebl, int64_t tag);



extern _Bool ebl_check_special_symbol (Ebl *ebl, GElf_Ehdr *ehdr,
                                      const GElf_Sym *sym, const char *name,
                                      const GElf_Shdr *destshdr);


extern GElf_Word ebl_sh_flags_combine (Ebl *ebl, GElf_Word flags1,
                                       GElf_Word flags2);


extern const char *ebl_osabi_name (Ebl *ebl, int osabi, char *buf, size_t len);



extern const char *ebl_core_note_type_name (Ebl *ebl, uint32_t type, char *buf,
                                            size_t len);


extern const char *ebl_object_note_type_name (Ebl *ebl, uint32_t type,
                                              char *buf, size_t len);


extern void ebl_core_note (Ebl *ebl, const char *name, uint32_t type,
                           uint32_t descsz, const char *desc);


extern void ebl_object_note (Ebl *ebl, const char *name, uint32_t type,
                             uint32_t descsz, const char *desc);


extern _Bool ebl_debugscn_p (Ebl *ebl, const char *name);


extern _Bool ebl_copy_reloc_p (Ebl *ebl, int reloc);


extern _Bool ebl_section_strip_p (Ebl *ebl, const GElf_Ehdr *ehdr,
                                 const GElf_Shdr *shdr, const char *name,
                                 _Bool remove_comment, _Bool only_remove_debug);


extern _Bool ebl_bss_plt_p (Ebl *ebl, GElf_Ehdr *ehdr);
# 169 "../libebl/libebl.h"
extern int ebl_return_value_location (Ebl *ebl,
                                      Dwarf_Die *functypedie,
                                      const Dwarf_Op **locops);
# 183 "../libebl/libebl.h"
extern ssize_t ebl_register_name (Ebl *ebl,
                                  int regno, char *name, size_t namelen,
                                  const char **prefix, const char **setname);



struct Ebl_Strtab;
struct Ebl_Strent;


extern struct Ebl_Strtab *ebl_strtabinit (_Bool nullstr);


extern void ebl_strtabfree (struct Ebl_Strtab *st);


extern struct Ebl_Strent *ebl_strtabadd (struct Ebl_Strtab *st,
                                         const char *str, size_t len);



extern void ebl_strtabfinalize (struct Ebl_Strtab *st, Elf_Data *data);


extern size_t ebl_strtaboffset (struct Ebl_Strent *se);


extern const char *ebl_string (struct Ebl_Strent *se);



struct Ebl_WStrtab;
struct Ebl_WStrent;


extern struct Ebl_WStrtab *ebl_wstrtabinit (_Bool nullstr);


extern void ebl_wstrtabfree (struct Ebl_WStrtab *st);


extern struct Ebl_WStrent *ebl_wstrtabadd (struct Ebl_WStrtab *st,
                                           const wchar_t *str, size_t len);



extern void ebl_wstrtabfinalize (struct Ebl_WStrtab *st, Elf_Data *data);


extern size_t ebl_wstrtaboffset (struct Ebl_WStrent *se);



struct Ebl_GStrtab;
struct Ebl_GStrent;


extern struct Ebl_GStrtab *ebl_gstrtabinit (unsigned int width, _Bool nullstr);


extern void ebl_gstrtabfree (struct Ebl_GStrtab *st);


extern struct Ebl_GStrent *ebl_gstrtabadd (struct Ebl_GStrtab *st,
                                           const char *str, size_t len);



extern void ebl_gstrtabfinalize (struct Ebl_GStrtab *st, Elf_Data *data);


extern size_t ebl_gstrtaboffset (struct Ebl_GStrent *se);
# 19 "../libebl/libeblP.h" 2




struct ebl
{

  const char *name;


  const char *emulation;


  uint_fast16_t machine;
  uint_fast8_t class;
  uint_fast8_t data;


  Elf *elf;


#define EBLHOOK(name) (*name)
# 1 "../libebl/ebl-hooks.h" 1
# 15 "../libebl/ebl-hooks.h"
const char *(*object_type_name) (int, char *, size_t);


const char *(*reloc_type_name) (int, char *, size_t);


_Bool (*reloc_type_check) (int);


Elf_Type (*reloc_simple_type) (Ebl *, int);


_Bool (*reloc_valid_use) (Elf *, int);


_Bool (*gotpc_reloc_check) (Elf *, int);


const char *(*segment_type_name) (int, char *, size_t);


const char *(*section_type_name) (int, char *, size_t);


const char *(*section_name) (int, int, char *, size_t);


const char *(*machine_flag_name) (GElf_Word *);


_Bool (*machine_flag_check) (GElf_Word);


const char *(*symbol_type_name) (int, char *, size_t);


const char *(*symbol_binding_name) (int, char *, size_t);


const char *(*dynamic_tag_name) (int64_t, char *, size_t);


_Bool (*dynamic_tag_check) (int64_t);


GElf_Word (*sh_flags_combine) (GElf_Word, GElf_Word);


const char *(*osabi_name) (int, char *, size_t);


const char *(*core_note_type_name) (uint32_t, char *, size_t);


const char *(*object_note_type_name) (uint32_t, char *, size_t);


_Bool (*core_note) (const char *, uint32_t, uint32_t, const char *);


_Bool (*object_note) (const char *, uint32_t, uint32_t, const char *);


_Bool (*debugscn_p) (const char *);


_Bool (*copy_reloc_p) (int);


_Bool (*check_special_symbol) (Elf *, GElf_Ehdr *, const GElf_Sym *,
                              const char *, const GElf_Shdr *);


_Bool (*bss_plt_p) (Elf *, GElf_Ehdr *);



int (*return_value_location) (Dwarf_Die *functypedie,
                                    const Dwarf_Op **locp);


ssize_t (*register_name) (Ebl *ebl,
                                int regno, char *name, size_t namelen,
                                const char **prefix, const char **setname);



void (*destr) (struct ebl *);
# 42 "../libebl/libeblP.h" 2
#undef EBLHOOK


  void *dlhandle;
};



typedef const char *(*ebl_bhinit_t) (Elf *, GElf_Half, Ebl *, size_t);



#define _(Str) dgettext ("elfutils", Str)
# 40 "readelf.c" 2
# 1 "../libdw/libdwP.h" 1
# 16 "../libdw/libdwP.h"
#define _LIBDWP_H 1
# 25 "../libdw/libdwP.h"
#define _(Str) dgettext ("elfutils", Str)



#define DWARF_VERSION 2


#define CIE_VERSION 1



struct loc_s
{
  void *addr;
  Dwarf_Op *loc;
  size_t nloc;
};


enum
  {
    IDX_debug_info = 0,
    IDX_debug_abbrev,
    IDX_debug_aranges,
    IDX_debug_line,
    IDX_debug_frame,
    IDX_eh_frame,
    IDX_debug_loc,
    IDX_debug_pubnames,
    IDX_debug_str,
    IDX_debug_funcnames,
    IDX_debug_typenames,
    IDX_debug_varnames,
    IDX_debug_weaknames,
    IDX_debug_macinfo,
    IDX_debug_ranges,
    IDX_last
  };



enum
{
  DWARF_E_NOERROR = 0,
  DWARF_E_UNKNOWN_ERROR,
  DWARF_E_INVALID_ACCESS,
  DWARF_E_NO_REGFILE,
  DWARF_E_IO_ERROR,
  DWARF_E_INVALID_ELF,
  DWARF_E_NO_DWARF,
  DWARF_E_NOELF,
  DWARF_E_GETEHDR_ERROR,
  DWARF_E_NOMEM,
  DWARF_E_UNIMPL,
  DWARF_E_INVALID_CMD,
  DWARF_E_INVALID_VERSION,
  DWARF_E_INVALID_FILE,
  DWARF_E_NO_ENTRY,
  DWARF_E_INVALID_DWARF,
  DWARF_E_NO_STRING,
  DWARF_E_NO_ADDR,
  DWARF_E_NO_CONSTANT,
  DWARF_E_NO_REFERENCE,
  DWARF_E_INVALID_REFERENCE,
  DWARF_E_NO_DEBUG_LINE,
  DWARF_E_INVALID_DEBUG_LINE,
  DWARF_E_TOO_BIG,
  DWARF_E_VERSION,
  DWARF_E_INVALID_DIR_IDX,
  DWARF_E_ADDR_OUTOFRANGE,
  DWARF_E_NO_LOCLIST,
  DWARF_E_NO_BLOCK,
  DWARF_E_INVALID_LINE_IDX,
  DWARF_E_INVALID_ARANGE_IDX,
  DWARF_E_NO_MATCH,
  DWARF_E_NO_FLAG,
  DWARF_E_INVALID_OFFSET,
  DWARF_E_NO_DEBUG_RANGES,
};



struct Dwarf
{

  Elf *elf;


  Elf_Data *sectiondata[IDX_last];


  _Bool other_byte_order;


  _Bool free_elf;



  struct pubnames_s
  {
    Dwarf_Off cu_offset;
    Dwarf_Off set_start;
    unsigned int cu_header_size;
    int address_len;
  } *pubnames_sets;
  size_t pubnames_nsets;


  void *cu_tree;
  Dwarf_Off next_cu_offset;


  Dwarf_Aranges *aranges;




  struct libdw_memblock
  {
    size_t size;
    size_t remaining;
    struct libdw_memblock *prev;
    char mem[0];
  } *mem_tail;


  size_t mem_default_size;


  Dwarf_OOM oom_handler;
};



struct Dwarf_Abbrev
{
  unsigned int code;
  unsigned int tag;
  int has_children;
  unsigned int attrcnt;
  unsigned char *attrp;
  Dwarf_Off offset;
};

# 1 "../libdw/dwarf_abbrev_hash.h" 1
# 16 "../libdw/dwarf_abbrev_hash.h"
#define _DWARF_ABBREV_HASH_H 1

#define NAME Dwarf_Abbrev_Hash
#define TYPE Dwarf_Abbrev *
#define COMPARE(a,b) (0)

# 1 "../lib/dynamicsizehash.h" 1
# 14 "../lib/dynamicsizehash.h"
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/stddef.h" 1 3 4
# 15 "../lib/dynamicsizehash.h" 2
# 32 "../lib/dynamicsizehash.h"
#define FIRST(name) 
#define NEXT(name) 




extern size_t next_prime (size_t seed);



#define _DYNHASHENTTYPE(name) typedef struct name ##_ent { unsigned long int hashval; TYPE data; NEXT (name) } name ##_ent






#define DYNHASHENTTYPE(name) _DYNHASHENTTYPE (name)
typedef struct Dwarf_Abbrev_Hash_ent { unsigned long int hashval; Dwarf_Abbrev * data; } Dwarf_Abbrev_Hash_ent;



#define _DYNHASHTYPE(name) typedef struct { unsigned long int size; unsigned long int filled; name ##_ent *table; FIRST (name) } name







#define DYNHASHTYPE(name) _DYNHASHTYPE (name)
typedef struct { unsigned long int size; unsigned long int filled; Dwarf_Abbrev_Hash_ent *table; } Dwarf_Abbrev_Hash;



#define _FUNCTIONS(name) extern int name ##_init (name *htab, unsigned long int init_size); extern int name ##_free (name *htab); extern int name ##_insert (name *htab, unsigned long int hval, TYPE data); extern int name ##_overwrite (name *htab, unsigned long int hval, TYPE data); extern TYPE name ##_find (name *htab, unsigned long int hval, TYPE val);
# 82 "../lib/dynamicsizehash.h"
#define FUNCTIONS(name) _FUNCTIONS (name)
extern int Dwarf_Abbrev_Hash_init (Dwarf_Abbrev_Hash *htab, unsigned long int init_size); extern int Dwarf_Abbrev_Hash_free (Dwarf_Abbrev_Hash *htab); extern int Dwarf_Abbrev_Hash_insert (Dwarf_Abbrev_Hash *htab, unsigned long int hval, Dwarf_Abbrev * data); extern int Dwarf_Abbrev_Hash_overwrite (Dwarf_Abbrev_Hash *htab, unsigned long int hval, Dwarf_Abbrev * data); extern Dwarf_Abbrev * Dwarf_Abbrev_Hash_find (Dwarf_Abbrev_Hash *htab, unsigned long int hval, Dwarf_Abbrev * val);
# 95 "../lib/dynamicsizehash.h"
#undef DYNHASHENTTYPE
#undef DYNHASHTYPE
#undef FUNCTIONS
#undef _FUNCTIONS


#undef NAME
#undef TYPE

#undef COMPARE
#undef FIRST
#undef NEXT
# 23 "../libdw/dwarf_abbrev_hash.h" 2
# 170 "../libdw/libdwP.h" 2



struct Dwarf_Files_s
  {
    Dwarf *dbg;
    unsigned int nfiles;
    struct Dwarf_Fileinfo_s
    {
      char *name;
      Dwarf_Word mtime;
      Dwarf_Word length;
    } info[0];
  };
typedef struct Dwarf_Fileinfo_s Dwarf_Fileinfo;



struct Dwarf_Lines_s
  {
    size_t nlines;

    struct Dwarf_Line_s
    {
      Dwarf_Addr addr;
      unsigned int file;
      int line;
      unsigned short int column;
      unsigned int is_stmt:1;
      unsigned int basic_block:1;
      unsigned int end_sequence:1;
      unsigned int prologue_end:1;
      unsigned int epilogue_begin:1;

      Dwarf_Files *files;
    } info[0];
  };



struct Dwarf_Aranges_s
{
  Dwarf *dbg;
  size_t naranges;

  struct Dwarf_Arange_s
  {
    Dwarf_Addr addr;
    Dwarf_Word length;
    Dwarf_Off offset;
  } info[0];
};



struct Dwarf_CU
{
  Dwarf *dbg;
  Dwarf_Off start;
  Dwarf_Off end;
  uint8_t address_size;
  uint8_t offset_size;


  Dwarf_Abbrev_Hash abbrev_hash;

  size_t orig_abbrev_offset;

  size_t last_abbrev_offset;


  Dwarf_Lines *lines;


  Dwarf_Files *files;


  void *locs;
};

#define CUDIE(fromcu) ((Dwarf_Die) { .cu = (fromcu), .addr = ((char *) (fromcu)->dbg->sectiondata[IDX_debug_info]->d_buf + (fromcu)->start + 3 * (fromcu)->offset_size - 4 + 3), })
# 260 "../libdw/libdwP.h"
struct Dwarf_Macro_s
{
  unsigned int opcode;
  Dwarf_Word param1;
  union
  {
    Dwarf_Word u;
    const char *s;
  } param2;
};




# 1 "../libdw/memory-access.h" 1
# 16 "../libdw/memory-access.h"
#define _MEMORY_ACCESS_H 1

# 1 "/usr/include/byteswap.h" 1 3 4
# 20 "/usr/include/byteswap.h" 3 4
#define _BYTESWAP_H 1


# 1 "/usr/include/bits/byteswap.h" 1 3 4
# 25 "/usr/include/bits/byteswap.h" 3 4
#define _BITS_BYTESWAP_H 1


#define __bswap_constant_16(x) ((((x) >> 8) & 0xff) | (((x) & 0xff) << 8))




#define __bswap_16(x) (__extension__ ({ register unsigned short int __v, __x = (x); if (__builtin_constant_p (__x)) __v = __bswap_constant_16 (__x); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; }))
# 59 "/usr/include/bits/byteswap.h" 3 4
#define __bswap_constant_32(x) ((((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >> 8) | (((x) & 0x0000ff00) << 8) | (((x) & 0x000000ff) << 24))
# 69 "/usr/include/bits/byteswap.h" 3 4
#define __bswap_32(x) (__extension__ ({ register unsigned int __v, __x = (x); if (__builtin_constant_p (__x)) __v = __bswap_constant_32 (__x); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; }))
# 108 "/usr/include/bits/byteswap.h" 3 4
#define __bswap_constant_64(x) ((((x) & 0xff00000000000000ull) >> 56) | (((x) & 0x00ff000000000000ull) >> 40) | (((x) & 0x0000ff0000000000ull) >> 24) | (((x) & 0x000000ff00000000ull) >> 8) | (((x) & 0x00000000ff000000ull) << 8) | (((x) & 0x0000000000ff0000ull) << 24) | (((x) & 0x000000000000ff00ull) << 40) | (((x) & 0x00000000000000ffull) << 56))
# 118 "/usr/include/bits/byteswap.h" 3 4
#define __bswap_64(x) (__extension__ ({ union { __extension__ unsigned long long int __ll; unsigned long int __l[2]; } __w, __r; if (__builtin_constant_p (x)) __r.__ll = __bswap_constant_64 (x); else { __w.__ll = (x); __r.__l[0] = __bswap_32 (__w.__l[1]); __r.__l[1] = __bswap_32 (__w.__l[0]); } __r.__ll; }))
# 24 "/usr/include/byteswap.h" 2 3 4






#define bswap_16(x) __bswap_16 (x)


#define bswap_32(x) __bswap_32 (x)



#define bswap_64(x) __bswap_64 (x)
# 19 "../libdw/memory-access.h" 2
# 1 "/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/limits.h" 1 3 4
# 20 "../libdw/memory-access.h" 2





#define get_uleb128_step(var,addr,nth,break) __b = *(addr)++; var |= (uintmax_t) (__b & 0x7f) << (nth * 7); if (likely ((__b & 0x80) == 0)) break





#define get_uleb128(var,addr) do { unsigned char __b; var = 0; get_uleb128_step (var, addr, 0, break); var = __libdw_get_uleb128 (var, 1, &(addr)); } while (0)







#define get_uleb128_rest_return(var,i,addrp) do { for (; i < 10; ++i) { get_uleb128_step (var, *addrp, i, return var); } return UINT64_MAX; } while (0)
# 52 "../libdw/memory-access.h"
#define get_sleb128_step(var,addr,nth,break) __b = *(addr)++; _v |= (uint64_t) (__b & 0x7f) << (nth * 7); if (likely ((__b & 0x80) == 0)) { var = (_v << (64 - (nth * 7) - 7) >> (64 - (nth * 7) - 7)); break; } else do {} while (0)
# 62 "../libdw/memory-access.h"
#define get_sleb128(var,addr) do { unsigned char __b; int64_t _v = 0; get_sleb128_step (var, addr, 0, break); var = __libdw_get_sleb128 (_v, 1, &(addr)); } while (0)







#define get_sleb128_rest_return(var,i,addrp) do { for (; i < 9; ++i) { get_sleb128_step (var, *addrp, i, return var); } return INT64_MAX; } while (0)
# 89 "../libdw/memory-access.h"
static uint64_t
__attribute__ ((unused))
__libdw_get_uleb128 (uint64_t acc, unsigned int i, const unsigned char **addrp)
{
  unsigned char __b;
  do { for (; i < 10; ++i) { __b = *(*addrp)++; acc |= (uintmax_t) (__b & 0x7f) << (i * 7); if (__builtin_expect ((__b & 0x80) == 0, 1)) return acc; } return (18446744073709551615ULL); } while (0);
}
static int64_t
__attribute__ ((unused))
__libdw_get_sleb128 (int64_t acc, unsigned int i, const unsigned char **addrp)
{
  unsigned char __b;
  int64_t _v = acc;
  do { for (; i < 9; ++i) { __b = *(*addrp)++; _v |= (uint64_t) (__b & 0x7f) << (i * 7); if (__builtin_expect ((__b & 0x80) == 0, 1)) { acc = (_v << (64 - (i * 7) - 7) >> (64 - (i * 7) - 7)); return acc; } else do {} while (0); } return (9223372036854775807LL); } while (0);
}







#define read_2ubyte_unaligned(Dbg,Addr) (unlikely ((Dbg)->other_byte_order) ? bswap_16 (*((const uint16_t *) (Addr))) : *((const uint16_t *) (Addr)))



#define read_2sbyte_unaligned(Dbg,Addr) (unlikely ((Dbg)->other_byte_order) ? (int16_t) bswap_16 (*((const int16_t *) (Addr))) : *((const int16_t *) (Addr)))




#define read_4ubyte_unaligned_noncvt(Addr) *((const uint32_t *) (Addr))

#define read_4ubyte_unaligned(Dbg,Addr) (unlikely ((Dbg)->other_byte_order) ? bswap_32 (*((const uint32_t *) (Addr))) : *((const uint32_t *) (Addr)))



#define read_4sbyte_unaligned(Dbg,Addr) (unlikely ((Dbg)->other_byte_order) ? (int32_t) bswap_32 (*((const int32_t *) (Addr))) : *((const int32_t *) (Addr)))




#define read_8ubyte_unaligned(Dbg,Addr) (unlikely ((Dbg)->other_byte_order) ? bswap_64 (*((const uint64_t *) (Addr))) : *((const uint64_t *) (Addr)))



#define read_8sbyte_unaligned(Dbg,Addr) (unlikely ((Dbg)->other_byte_order) ? (int64_t) bswap_64 (*((const int64_t *) (Addr))) : *((const int64_t *) (Addr)))
# 213 "../libdw/memory-access.h"
#define read_2ubyte_unaligned_inc(Dbg,Addr) ({ uint16_t t_ = read_2ubyte_unaligned (Dbg, Addr); Addr = (__typeof (Addr)) (((uintptr_t) (Addr)) + 2); t_; })



#define read_2sbyte_unaligned_inc(Dbg,Addr) ({ int16_t t_ = read_2sbyte_unaligned (Dbg, Addr); Addr = (__typeof (Addr)) (((uintptr_t) (Addr)) + 2); t_; })




#define read_4ubyte_unaligned_inc(Dbg,Addr) ({ uint32_t t_ = read_4ubyte_unaligned (Dbg, Addr); Addr = (__typeof (Addr)) (((uintptr_t) (Addr)) + 4); t_; })



#define read_4sbyte_unaligned_inc(Dbg,Addr) ({ int32_t t_ = read_4sbyte_unaligned (Dbg, Addr); Addr = (__typeof (Addr)) (((uintptr_t) (Addr)) + 4); t_; })




#define read_8ubyte_unaligned_inc(Dbg,Addr) ({ uint64_t t_ = read_8ubyte_unaligned (Dbg, Addr); Addr = (__typeof (Addr)) (((uintptr_t) (Addr)) + 8); t_; })



#define read_8sbyte_unaligned_inc(Dbg,Addr) ({ int64_t t_ = read_8sbyte_unaligned (Dbg, Addr); Addr = (__typeof (Addr)) (((uintptr_t) (Addr)) + 8); t_; })
# 275 "../libdw/libdwP.h" 2



extern void __libdw_seterrno (int value) __attribute__ ((regparm (3), stdcall)) __attribute__ ((visibility ("internal")));



#define libdw_alloc(dbg,type,tsize,cnt) ({ struct libdw_memblock *_tail = (dbg)->mem_tail; size_t _required = (tsize) * (cnt); type *_result = (type *) (_tail->mem + (_tail->size - _tail->remaining)); size_t _padding = ((__alignof (type) - ((uintptr_t) _result & (__alignof (type) - 1))) & (__alignof (type) - 1)); if (unlikely (_tail->remaining < _required + _padding)) { _result = (type *) __libdw_allocate (dbg, _required); _tail = (dbg)->mem_tail; } else { _required += _padding; _result = (type *) ((char *) _result + _padding); } _tail->remaining -= _required; _result; })
# 302 "../libdw/libdwP.h"
#define libdw_typed_alloc(dbg,type) libdw_alloc (dbg, type, sizeof (type), 1)



extern void *__libdw_allocate (Dwarf *dbg, size_t minsize)
     __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));


extern void __libdw_oom (void) __attribute ((noreturn, visibility ("hidden")));


extern struct Dwarf_CU *__libdw_findcu (Dwarf *dbg, Dwarf_Off offset)
     __attribute__ ((__nonnull__ (1))) __attribute__ ((regparm (3), stdcall)) __attribute__ ((visibility ("internal")));


extern Dwarf_Abbrev *__libdw_findabbrev (struct Dwarf_CU *cu,
                                         unsigned int code)
     __attribute__ ((__nonnull__ (1))) __attribute__ ((regparm (3), stdcall)) __attribute__ ((visibility ("internal")));


extern Dwarf_Abbrev *__libdw_getabbrev (Dwarf *dbg, struct Dwarf_CU *cu,
                                        Dwarf_Off offset, size_t *lengthp,
                                        Dwarf_Abbrev *result)
     __attribute__ ((__nonnull__ (1))) __attribute__ ((regparm (3), stdcall)) __attribute__ ((visibility ("internal")));


extern size_t __libdw_form_val_len (Dwarf *dbg, struct Dwarf_CU *cu,
                                    unsigned int form,
                                    const unsigned char *valp)
     __attribute__ ((__nonnull__ (1, 2, 4))) __attribute__ ((regparm (3), stdcall)) __attribute__ ((visibility ("internal")));


extern unsigned char *__libdw_find_attr (Dwarf_Die *die,
                                         unsigned int search_name,
                                         unsigned int *codep,
                                         unsigned int *formp)
     __attribute__ ((__nonnull__ (1))) __attribute__ ((regparm (3), stdcall)) __attribute__ ((visibility ("internal")));


extern int __libdw_attr_intval (Dwarf_Die *die, int *valp, int attval)
     __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((regparm (3), stdcall)) __attribute__ ((visibility ("internal")));


struct Dwarf_Die_Chain
{
  Dwarf_Die die;
  struct Dwarf_Die_Chain *parent;
  _Bool prune;
};
extern int __libdw_visit_scopes (unsigned int depth,
                                 struct Dwarf_Die_Chain *root,
                                 int (*previsit) (unsigned int depth,
                                                  struct Dwarf_Die_Chain *,
                                                  void *arg),
                                 int (*postvisit) (unsigned int depth,
                                                   struct Dwarf_Die_Chain *,
                                                   void *arg),
                                 void *arg)
  __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((regparm (3), stdcall)) __attribute__ ((visibility ("internal")));



extern int __dwarf_errno_internal (void);


































# 41 "readelf.c" 2




static void print_version (FILE *stream, struct argp_state *state);
void (*argp_program_version_hook) (FILE *, struct argp_state *) = print_version;


const char *argp_program_bug_address = "http://bugzilla.redhat.com/bugzilla/";


static const struct argp_option options[] =
{
  { ((void *)0), 0, ((void *)0), 0, "Output selection:", 0 },
  { "all", 'a', ((void *)0), 0, "Equivalent to: -h -l", 0 },
  { "dynamic", 'd', ((void *)0), 0, "Display the dynamic segment", 0 },
  { "file-header", 'h', ((void *)0), 0, "Display the ELF file header", 0 },
  { "histogram", 'I', ((void *)0), 0,
    "Display histogram of bucket list lengths", 0 },
  { "program-headers", 'l', ((void *)0), 0, "Display the program headers", 0 },
  { "relocs", 'r', ((void *)0), 0, "Display relocations", 0 },
  { "section-headers", 'S', ((void *)0), 0, "Display the sections' header", 0 },
  { "symbols", 's', ((void *)0), 0, "Display the symbol table", 0 },
  { "version-info", 'V', ((void *)0), 0, "Display versioning information", 0 },
  { "debug-dump", 'w', "SECTION", 0x1,
    "Display DWARF section content.  SECTION can be one of abbrev, " "aranges, frame, info, loc, line, ranges, pubnames, str, or macinfo.",

    0 },
  { "notes", 'n', ((void *)0), 0, "Display the core notes", 0 },
  { "arch-specific", 'A', ((void *)0), 0,
    "Display architecture specific information (if any)", 0 },

  { ((void *)0), 0, ((void *)0), 0, "Output control:", 0 },

  { ((void *)0), 0, ((void *)0), 0, ((void *)0), 0 }
};


static const char doc[] = "Print information from ELF file in human-readable form.";



static const char args_doc[] = "FILE...";


static error_t parse_opt (int key, char *arg, struct argp_state *state);


static struct argp argp =
{
  options, parse_opt, args_doc, doc, ((void *)0), ((void *)0), ((void *)0)
};





static _Bool print_dynamic_table;


static _Bool print_file_header;


static _Bool print_program_header;


static _Bool print_relocations;


static _Bool print_section_header;


static _Bool print_symbol_table;


static _Bool print_version_info;


static _Bool print_section_groups;


static _Bool print_histogram;


static _Bool print_arch;


static _Bool print_notes;


static enum section_e
{
  section_abbrev = 1,
  section_aranges = 2,
  section_frame = 4,
  section_info = 8,
  section_line = 16,
  section_loc = 32,
  section_pubnames = 64,
  section_str = 128,
  section_macinfo = 256,
  section_ranges = 512,
  section_all = (section_abbrev | section_aranges | section_frame
                 | section_info | section_line | section_loc
                 | section_pubnames | section_str | section_macinfo
                 | section_ranges)
} print_debug_sections;


static size_t shnum;



static void process_file (int fd, Elf *elf, const char *prefix,
                          const char *fname, _Bool only_one);
static void process_elf_file (Elf *elf, const char *prefix, const char *fname,
                              _Bool only_one);
static void print_ehdr (Ebl *ebl, GElf_Ehdr *ehdr);
static void print_shdr (Ebl *ebl, GElf_Ehdr *ehdr);
static void print_phdr (Ebl *ebl, GElf_Ehdr *ehdr);
static void print_scngrp (Ebl *ebl);
static void print_dynamic (Ebl *ebl, GElf_Ehdr *ehdr);
static void print_relocs (Ebl *ebl);
static void handle_relocs_rel (Ebl *ebl, Elf_Scn *scn, GElf_Shdr *shdr);
static void handle_relocs_rela (Ebl *ebl, Elf_Scn *scn, GElf_Shdr *shdr);
static void print_symtab (Ebl *ebl, int type);
static void handle_symtab (Ebl *ebl, Elf_Scn *scn, GElf_Shdr *shdr);
static void print_verinfo (Ebl *ebl);
static void handle_verneed (Ebl *ebl, Elf_Scn *scn, GElf_Shdr *shdr);
static void handle_verdef (Ebl *ebl, Elf_Scn *scn, GElf_Shdr *shdr);
static void handle_versym (Ebl *ebl, Elf_Scn *scn,
                           GElf_Shdr *shdr);
static void print_debug (Ebl *ebl, GElf_Ehdr *ehdr);
static void handle_hash (Ebl *ebl);
static void handle_notes (Ebl *ebl, GElf_Ehdr *ehdr);
static void print_liblist (Ebl *ebl);


int
main (int argc, char *argv[])
{

  setlocale (__LC_ALL, "");


  textdomain ("elfutils");


  int remaining;
  argp_parse (&argp, argc, argv, 0, &remaining, ((void *)0));


  elf_version (1);


  _Bool only_one = remaining + 1 == argc;
  do
    {

      int fd = open (argv[remaining], 00);
      if (fd == -1)
        {
          error (0, (*__errno_location ()), dcgettext (((void *)0), "cannot open input file", __LC_MESSAGES));
          continue;
        }


      Elf *elf = elf_begin (fd, ELF_C_READ_MMAP, ((void *)0));
      if (elf == ((void *)0))
        error (0, 0, dcgettext (((void *)0), "cannot generate Elf descriptor: %s\n", __LC_MESSAGES),
               elf_errmsg (-1));
      else
        {
          process_file (fd, elf, ((void *)0), argv[remaining], only_one);


          if (elf_end (elf) != 0)
            error (0, 0, dcgettext (((void *)0), "error while closing Elf descriptor: %s", __LC_MESSAGES),
                   elf_errmsg (-1));
        }

      close (fd);
    }
  while (++remaining < argc);

  return error_message_count != 0;
}



static error_t
parse_opt (int key, char *arg,
           struct argp_state *state __attribute__ ((unused)))
{

  static _Bool any_control_option;

  switch (key)
    {
    case 'a':
      print_file_header = 1;
      print_program_header = 1;
      print_relocations = 1;
      print_section_header = 1;
      print_symbol_table = 1;
      print_version_info = 1;
      print_dynamic_table = 1;
      print_section_groups = 1;
      print_histogram = 1;
      print_arch = 1;
      print_notes = 1;
      any_control_option = 1;
      break;
    case 'A':
      print_arch = 1;
      any_control_option = 1;
      break;
    case 'd':
      print_dynamic_table = 1;
      any_control_option = 1;
      break;
    case 'g':
      print_section_groups = 1;
      any_control_option = 1;
      break;
    case 'h':
      print_file_header = 1;
      any_control_option = 1;
      break;
    case 'I':
      print_histogram = 1;
      any_control_option = 1;
      break;
    case 'l':
      print_program_header = 1;
      any_control_option = 1;
      break;
    case 'n':
      print_notes = 1;
      any_control_option = 1;
      break;
    case 'r':
      print_relocations = 1;
      any_control_option = 1;
     break;
    case 'S':
      print_section_header = 1;
      any_control_option = 1;
      break;
    case 's':
      print_symbol_table = 1;
      any_control_option = 1;
      break;
    case 'V':
      print_version_info = 1;
      any_control_option = 1;
      break;
    case 'w':
      if (arg == ((void *)0))
        print_debug_sections = section_all;
      else if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (arg) && __builtin_constant_p ("abbrev") && (__s1_len = strlen (arg), __s2_len = strlen ("abbrev"), (!((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("abbrev") + 1) - (size_t)(const void *)("abbrev") == 1) || __s2_len >= 4)) ? __builtin_strcmp (arg, "abbrev") : (__builtin_constant_p (arg) && ((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) && (__s1_len = strlen (arg), __s1_len < 4) ? (__builtin_constant_p ("abbrev") && ((size_t)(const void *)(("abbrev") + 1) - (size_t)(const void *)("abbrev") == 1) ? __builtin_strcmp (arg, "abbrev") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("abbrev"); register int __result = (((const unsigned char *) (const char *) (arg))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (arg))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (arg))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (arg))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("abbrev") && ((size_t)(const void *)(("abbrev") + 1) - (size_t)(const void *)("abbrev") == 1) && (__s2_len = strlen ("abbrev"), __s2_len < 4) ? (__builtin_constant_p (arg) && ((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) ? __builtin_strcmp (arg, "abbrev") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (arg); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("abbrev"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("abbrev"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("abbrev"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("abbrev"))[3]); } } __result; }))) : __builtin_strcmp (arg, "abbrev")))); }) == 0)
        print_debug_sections |= section_abbrev;
      else if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (arg) && __builtin_constant_p ("aranges") && (__s1_len = strlen (arg), __s2_len = strlen ("aranges"), (!((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("aranges") + 1) - (size_t)(const void *)("aranges") == 1) || __s2_len >= 4)) ? __builtin_strcmp (arg, "aranges") : (__builtin_constant_p (arg) && ((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) && (__s1_len = strlen (arg), __s1_len < 4) ? (__builtin_constant_p ("aranges") && ((size_t)(const void *)(("aranges") + 1) - (size_t)(const void *)("aranges") == 1) ? __builtin_strcmp (arg, "aranges") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("aranges"); register int __result = (((const unsigned char *) (const char *) (arg))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (arg))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (arg))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (arg))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("aranges") && ((size_t)(const void *)(("aranges") + 1) - (size_t)(const void *)("aranges") == 1) && (__s2_len = strlen ("aranges"), __s2_len < 4) ? (__builtin_constant_p (arg) && ((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) ? __builtin_strcmp (arg, "aranges") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (arg); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("aranges"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("aranges"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("aranges"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("aranges"))[3]); } } __result; }))) : __builtin_strcmp (arg, "aranges")))); }) == 0)
        print_debug_sections |= section_aranges;
      else if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (arg) && __builtin_constant_p ("ranges") && (__s1_len = strlen (arg), __s2_len = strlen ("ranges"), (!((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("ranges") + 1) - (size_t)(const void *)("ranges") == 1) || __s2_len >= 4)) ? __builtin_strcmp (arg, "ranges") : (__builtin_constant_p (arg) && ((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) && (__s1_len = strlen (arg), __s1_len < 4) ? (__builtin_constant_p ("ranges") && ((size_t)(const void *)(("ranges") + 1) - (size_t)(const void *)("ranges") == 1) ? __builtin_strcmp (arg, "ranges") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("ranges"); register int __result = (((const unsigned char *) (const char *) (arg))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (arg))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (arg))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (arg))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("ranges") && ((size_t)(const void *)(("ranges") + 1) - (size_t)(const void *)("ranges") == 1) && (__s2_len = strlen ("ranges"), __s2_len < 4) ? (__builtin_constant_p (arg) && ((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) ? __builtin_strcmp (arg, "ranges") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (arg); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("ranges"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("ranges"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("ranges"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("ranges"))[3]); } } __result; }))) : __builtin_strcmp (arg, "ranges")))); }) == 0)
        print_debug_sections |= section_ranges;
      else if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (arg) && __builtin_constant_p ("frame") && (__s1_len = strlen (arg), __s2_len = strlen ("frame"), (!((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("frame") + 1) - (size_t)(const void *)("frame") == 1) || __s2_len >= 4)) ? __builtin_strcmp (arg, "frame") : (__builtin_constant_p (arg) && ((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) && (__s1_len = strlen (arg), __s1_len < 4) ? (__builtin_constant_p ("frame") && ((size_t)(const void *)(("frame") + 1) - (size_t)(const void *)("frame") == 1) ? __builtin_strcmp (arg, "frame") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("frame"); register int __result = (((const unsigned char *) (const char *) (arg))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (arg))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (arg))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (arg))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("frame") && ((size_t)(const void *)(("frame") + 1) - (size_t)(const void *)("frame") == 1) && (__s2_len = strlen ("frame"), __s2_len < 4) ? (__builtin_constant_p (arg) && ((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) ? __builtin_strcmp (arg, "frame") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (arg); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("frame"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("frame"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("frame"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("frame"))[3]); } } __result; }))) : __builtin_strcmp (arg, "frame")))); }) == 0)
        print_debug_sections |= section_frame;
      else if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (arg) && __builtin_constant_p ("info") && (__s1_len = strlen (arg), __s2_len = strlen ("info"), (!((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("info") + 1) - (size_t)(const void *)("info") == 1) || __s2_len >= 4)) ? __builtin_strcmp (arg, "info") : (__builtin_constant_p (arg) && ((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) && (__s1_len = strlen (arg), __s1_len < 4) ? (__builtin_constant_p ("info") && ((size_t)(const void *)(("info") + 1) - (size_t)(const void *)("info") == 1) ? __builtin_strcmp (arg, "info") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("info"); register int __result = (((const unsigned char *) (const char *) (arg))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (arg))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (arg))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (arg))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("info") && ((size_t)(const void *)(("info") + 1) - (size_t)(const void *)("info") == 1) && (__s2_len = strlen ("info"), __s2_len < 4) ? (__builtin_constant_p (arg) && ((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) ? __builtin_strcmp (arg, "info") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (arg); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("info"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("info"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("info"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("info"))[3]); } } __result; }))) : __builtin_strcmp (arg, "info")))); }) == 0)
        print_debug_sections |= section_info;
      else if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (arg) && __builtin_constant_p ("loc") && (__s1_len = strlen (arg), __s2_len = strlen ("loc"), (!((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("loc") + 1) - (size_t)(const void *)("loc") == 1) || __s2_len >= 4)) ? __builtin_strcmp (arg, "loc") : (__builtin_constant_p (arg) && ((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) && (__s1_len = strlen (arg), __s1_len < 4) ? (__builtin_constant_p ("loc") && ((size_t)(const void *)(("loc") + 1) - (size_t)(const void *)("loc") == 1) ? __builtin_strcmp (arg, "loc") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("loc"); register int __result = (((const unsigned char *) (const char *) (arg))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (arg))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (arg))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (arg))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("loc") && ((size_t)(const void *)(("loc") + 1) - (size_t)(const void *)("loc") == 1) && (__s2_len = strlen ("loc"), __s2_len < 4) ? (__builtin_constant_p (arg) && ((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) ? __builtin_strcmp (arg, "loc") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (arg); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("loc"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("loc"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("loc"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("loc"))[3]); } } __result; }))) : __builtin_strcmp (arg, "loc")))); }) == 0)
        print_debug_sections |= section_loc;
      else if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (arg) && __builtin_constant_p ("line") && (__s1_len = strlen (arg), __s2_len = strlen ("line"), (!((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("line") + 1) - (size_t)(const void *)("line") == 1) || __s2_len >= 4)) ? __builtin_strcmp (arg, "line") : (__builtin_constant_p (arg) && ((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) && (__s1_len = strlen (arg), __s1_len < 4) ? (__builtin_constant_p ("line") && ((size_t)(const void *)(("line") + 1) - (size_t)(const void *)("line") == 1) ? __builtin_strcmp (arg, "line") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("line"); register int __result = (((const unsigned char *) (const char *) (arg))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (arg))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (arg))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (arg))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("line") && ((size_t)(const void *)(("line") + 1) - (size_t)(const void *)("line") == 1) && (__s2_len = strlen ("line"), __s2_len < 4) ? (__builtin_constant_p (arg) && ((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) ? __builtin_strcmp (arg, "line") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (arg); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("line"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("line"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("line"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("line"))[3]); } } __result; }))) : __builtin_strcmp (arg, "line")))); }) == 0)
        print_debug_sections |= section_line;
      else if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (arg) && __builtin_constant_p ("pubnames") && (__s1_len = strlen (arg), __s2_len = strlen ("pubnames"), (!((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("pubnames") + 1) - (size_t)(const void *)("pubnames") == 1) || __s2_len >= 4)) ? __builtin_strcmp (arg, "pubnames") : (__builtin_constant_p (arg) && ((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) && (__s1_len = strlen (arg), __s1_len < 4) ? (__builtin_constant_p ("pubnames") && ((size_t)(const void *)(("pubnames") + 1) - (size_t)(const void *)("pubnames") == 1) ? __builtin_strcmp (arg, "pubnames") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("pubnames"); register int __result = (((const unsigned char *) (const char *) (arg))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (arg))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (arg))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (arg))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("pubnames") && ((size_t)(const void *)(("pubnames") + 1) - (size_t)(const void *)("pubnames") == 1) && (__s2_len = strlen ("pubnames"), __s2_len < 4) ? (__builtin_constant_p (arg) && ((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) ? __builtin_strcmp (arg, "pubnames") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (arg); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("pubnames"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("pubnames"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("pubnames"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("pubnames"))[3]); } } __result; }))) : __builtin_strcmp (arg, "pubnames")))); }) == 0)
        print_debug_sections |= section_pubnames;
      else if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (arg) && __builtin_constant_p ("str") && (__s1_len = strlen (arg), __s2_len = strlen ("str"), (!((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("str") + 1) - (size_t)(const void *)("str") == 1) || __s2_len >= 4)) ? __builtin_strcmp (arg, "str") : (__builtin_constant_p (arg) && ((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) && (__s1_len = strlen (arg), __s1_len < 4) ? (__builtin_constant_p ("str") && ((size_t)(const void *)(("str") + 1) - (size_t)(const void *)("str") == 1) ? __builtin_strcmp (arg, "str") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("str"); register int __result = (((const unsigned char *) (const char *) (arg))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (arg))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (arg))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (arg))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("str") && ((size_t)(const void *)(("str") + 1) - (size_t)(const void *)("str") == 1) && (__s2_len = strlen ("str"), __s2_len < 4) ? (__builtin_constant_p (arg) && ((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) ? __builtin_strcmp (arg, "str") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (arg); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("str"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("str"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("str"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("str"))[3]); } } __result; }))) : __builtin_strcmp (arg, "str")))); }) == 0)
        print_debug_sections |= section_str;
      else if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (arg) && __builtin_constant_p ("macinfo") && (__s1_len = strlen (arg), __s2_len = strlen ("macinfo"), (!((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("macinfo") + 1) - (size_t)(const void *)("macinfo") == 1) || __s2_len >= 4)) ? __builtin_strcmp (arg, "macinfo") : (__builtin_constant_p (arg) && ((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) && (__s1_len = strlen (arg), __s1_len < 4) ? (__builtin_constant_p ("macinfo") && ((size_t)(const void *)(("macinfo") + 1) - (size_t)(const void *)("macinfo") == 1) ? __builtin_strcmp (arg, "macinfo") : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) ("macinfo"); register int __result = (((const unsigned char *) (const char *) (arg))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (arg))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (arg))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (arg))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("macinfo") && ((size_t)(const void *)(("macinfo") + 1) - (size_t)(const void *)("macinfo") == 1) && (__s2_len = strlen ("macinfo"), __s2_len < 4) ? (__builtin_constant_p (arg) && ((size_t)(const void *)((arg) + 1) - (size_t)(const void *)(arg) == 1) ? __builtin_strcmp (arg, "macinfo") : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (arg); register int __result = __s1[0] - ((const unsigned char *) (const char *) ("macinfo"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) ("macinfo"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) ("macinfo"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) ("macinfo"))[3]); } } __result; }))) : __builtin_strcmp (arg, "macinfo")))); }) == 0)
        print_debug_sections |= section_macinfo;
      else
        {
          fprintf (stderr, dcgettext (((void *)0), "Unknown DWARF debug section `%s'.\n", __LC_MESSAGES),
                   arg);
          argp_help (&argp, stderr, 0x04,
                     program_invocation_short_name);
          exit (1);
        }
      any_control_option = 1;
      break;
    case 0x1000002:
      fputs (dcgettext (((void *)0), "Missing file name.\n", __LC_MESSAGES), stderr);
      goto do_argp_help;
    case 0x1000007:
      if (! any_control_option)
        {
          fputs (dcgettext (((void *)0), "No operation specified.\n", __LC_MESSAGES), stderr);
        do_argp_help:
          argp_help (&argp, stderr, 0x04 | 0x100,
                     program_invocation_short_name);
          exit (1);
        }
      break;
    default:
      return 7;
    }
  return 0;
}



static void
print_version (FILE *stream, struct argp_state *state __attribute__ ((unused)))
{
  fprintf (stream, "readelf (%s) %s\n", "Red Hat elfutils", "0.118");
  fprintf (stream, dcgettext (((void *)0), "Copyright (C) %s Red Hat, Inc.\nThis is free software; see the source for copying conditions.  There is NO\nwarranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n", __LC_MESSAGES), "2005");




  fprintf (stream, dcgettext (((void *)0), "Written by %s.\n", __LC_MESSAGES), "Ulrich Drepper");
}



static void
process_file (int fd, Elf *elf, const char *prefix, const char *fname,
              _Bool only_one)
{

  Elf_Kind kind = elf_kind (elf);
  struct stat64 st;

  switch (kind)
    {
    case ELF_K_ELF:

      process_elf_file (elf, prefix, fname, only_one);
      break;

    case ELF_K_AR:
      {
        size_t prefix_len = prefix == ((void *)0) ? 0 : strlen (prefix);
        size_t fname_len = strlen (fname) + 1;
        char new_prefix[prefix_len + 1 + fname_len];
        char *cp = new_prefix;


        if (prefix != ((void *)0))
          {
            cp = (__extension__ (__builtin_constant_p (prefix) && __builtin_constant_p (prefix_len) && ((size_t)(const void *)((prefix) + 1) - (size_t)(const void *)(prefix) == 1) && prefix_len <= 8 ? __builtin_memcpy (cp, prefix, prefix_len) + (prefix_len) : __mempcpy (cp, prefix, prefix_len)));
            *cp++ = ':';
          }
        memcpy (cp, fname, fname_len);


        Elf *subelf;
        Elf_Cmd cmd = ELF_C_READ_MMAP;
        while ((subelf = elf_begin (fd, cmd, elf)) != ((void *)0))
          {
            kind = elf_kind (subelf);


            if (kind == ELF_K_ELF || kind == ELF_K_AR)
              {
                Elf_Arhdr *arhdr = elf_getarhdr (subelf);
                ((void) ((arhdr != ((void *)0)) ? 0 : (__assert_fail ("arhdr != ((void *)0)", "readelf.c", 407, __PRETTY_FUNCTION__), 0)));

                process_file (fd, subelf, new_prefix, arhdr->ar_name, 0);
              }


            cmd = elf_next (subelf);
            if (elf_end (subelf) != 0)
              error (0, 0,
                     dcgettext (((void *)0), " error while freeing sub-ELF descriptor: %s\n", __LC_MESSAGES),
                     elf_errmsg (-1));
          }
      }
      break;

    default:
      if (fstat64 (fd, &st) != 0)
        error (0, (*__errno_location ()), dcgettext (((void *)0), "cannot stat input file", __LC_MESSAGES));
      else if (st.st_size == 0)
        error (0, 0, dcgettext (((void *)0), "input file is empty", __LC_MESSAGES));
      else

        error (0, 0, dcgettext (((void *)0), "Not an ELF file - it has the wrong magic bytes at the start", __LC_MESSAGES));

      break;
    }
}



static void
process_elf_file (Elf *elf, const char *prefix, const char *fname,
                  _Bool only_one)
{
  GElf_Ehdr ehdr_mem;
  GElf_Ehdr *ehdr = gelf_getehdr (elf, &ehdr_mem);


  if (!only_one)
    {
      if (prefix != ((void *)0))
        printf ("\n%s(%s):\n\n", prefix, fname);
      else
        printf ("\n%s:\n\n", fname);
    }

  if (ehdr == ((void *)0))
    {
      error (0, 0, dcgettext (((void *)0), "cannot read ELF header: %s", __LC_MESSAGES), elf_errmsg (-1));
      return;
    }

  Ebl *ebl = ebl_openbackend (elf);
  if (ebl == ((void *)0))
    {
      error (0, (*__errno_location ()), dcgettext (((void *)0), "cannot create EBL handle", __LC_MESSAGES));
      return;
    }


  if (elf_getshnum (ebl->elf, &shnum) < 0)
    error (1, 0,
           dcgettext (((void *)0), "cannot determine number of sections: %s", __LC_MESSAGES),
           elf_errmsg (-1));

  if (print_file_header)
    print_ehdr (ebl, ehdr);
  if (print_section_header)
    print_shdr (ebl, ehdr);
  if (print_program_header)
    print_phdr (ebl, ehdr);
  if (print_section_groups)
    print_scngrp (ebl);
  if (print_dynamic_table)
    print_dynamic (ebl, ehdr);
  if (print_relocations)
    print_relocs (ebl);
  if (print_histogram)
    handle_hash (ebl);
  if (print_symbol_table)
    print_symtab (ebl, 11);
  if (print_version_info)
    print_verinfo (ebl);
  if (print_symbol_table)
    print_symtab (ebl, 2);
  if (print_arch)
    print_liblist (ebl);
  if (print_debug_sections != 0)
    print_debug (ebl, ehdr);
  if (print_notes)
    handle_notes (ebl, ehdr);

  ebl_closebackend (ebl);
}



static void
print_file_type (unsigned short int e_type)
{
  if (e_type <= 4)
    {
      static const char *knowntypes[] =
      {
        "NONE (None)",
        "REL (Relocatable file)",
        "EXEC (Executable file)",
        "DYN (Shared object file)",
        "CORE (Core file)"
      };
      puts (dcgettext (((void *)0), knowntypes[e_type], __LC_MESSAGES));
    }
  else if (e_type >= 0xfe00 && e_type <= 0xfeff)
    printf (dcgettext (((void *)0), "OS Specific: (%x)\n", __LC_MESSAGES), e_type);
  else if (e_type >= 0xff00 )
    printf (dcgettext (((void *)0), "Processor Specific: (%x)\n", __LC_MESSAGES), e_type);
  else
    puts ("???");
}



static void
print_ehdr (Ebl *ebl, GElf_Ehdr *ehdr)
{
  fputs_unlocked (dcgettext (((void *)0), "ELF Header:\n  Magic:  ", __LC_MESSAGES), stdout);
  for (size_t cnt = 0; cnt < (16); ++cnt)
    printf (" %02hhx", ehdr->e_ident[cnt]);

  printf (dcgettext (((void *)0), "\n  Class:                             %s\n", __LC_MESSAGES),
          ehdr->e_ident[4] == 1 ? "ELF32"
          : ehdr->e_ident[4] == 2 ? "ELF64"
          : "\?\?\?");

  printf (dcgettext (((void *)0), "  Data:                              %s\n", __LC_MESSAGES),
          ehdr->e_ident[5] == 1
          ? "2's complement, little endian"
          : ehdr->e_ident[5] == 2
          ? "2's complement, big endian" : "\?\?\?");

  printf (dcgettext (((void *)0), "  Version:                           %hhd %s\n", __LC_MESSAGES),
          ehdr->e_ident[6],
          ehdr->e_ident[6] == 1 ? dcgettext (((void *)0), "(current)", __LC_MESSAGES)
          : "(\?\?\?)");

  char buf[512];
  printf (dcgettext (((void *)0), "  OS/ABI:                            %s\n", __LC_MESSAGES),
          ebl_osabi_name (ebl, ehdr->e_ident[7], buf, sizeof (buf)));

  printf (dcgettext (((void *)0), "  ABI Version:                       %hhd\n", __LC_MESSAGES),
          ehdr->e_ident[8]);

  fputs_unlocked (dcgettext (((void *)0), "  Type:                              ", __LC_MESSAGES), stdout);
  print_file_type (ehdr->e_type);

  printf (dcgettext (((void *)0), "  Machine:                           %s\n", __LC_MESSAGES), ebl->name);

  printf (dcgettext (((void *)0), "  Version:                           %d %s\n", __LC_MESSAGES),
          ehdr->e_version,
          ehdr->e_version == 1 ? dcgettext (((void *)0), "(current)", __LC_MESSAGES) : "(\?\?\?)");

  printf (dcgettext (((void *)0), "  Entry point address:               %#" "ll" "x" "\n", __LC_MESSAGES),
          ehdr->e_entry);

  printf (dcgettext (((void *)0), "  Start of program headers:          %" "ll" "d" " %s\n", __LC_MESSAGES),
          ehdr->e_phoff, dcgettext (((void *)0), "(bytes into file)", __LC_MESSAGES));

  printf (dcgettext (((void *)0), "  Start of section headers:          %" "ll" "d" " %s\n", __LC_MESSAGES),
          ehdr->e_shoff, dcgettext (((void *)0), "(bytes into file)", __LC_MESSAGES));

  printf (dcgettext (((void *)0), "  Flags:                             %s\n", __LC_MESSAGES),
          ebl_machine_flag_name (ebl, ehdr->e_flags, buf, sizeof (buf)));

  printf (dcgettext (((void *)0), "  Size of this header:               %" "d" " %s\n", __LC_MESSAGES),
          ehdr->e_ehsize, dcgettext (((void *)0), "(bytes)", __LC_MESSAGES));

  printf (dcgettext (((void *)0), "  Size of program header entries:    %" "d" " %s\n", __LC_MESSAGES),
          ehdr->e_phentsize, dcgettext (((void *)0), "(bytes)", __LC_MESSAGES));

  printf (dcgettext (((void *)0), "  Number of program headers entries: %" "d" "\n", __LC_MESSAGES),
          ehdr->e_phnum);

  printf (dcgettext (((void *)0), "  Size of section header entries:    %" "d" " %s\n", __LC_MESSAGES),
          ehdr->e_shentsize, dcgettext (((void *)0), "(bytes)", __LC_MESSAGES));

  printf (dcgettext (((void *)0), "  Number of section headers entries: %" "d", __LC_MESSAGES),
          ehdr->e_shnum);
  if (ehdr->e_shnum == 0)
    {
      GElf_Shdr shdr_mem;
      GElf_Shdr *shdr = gelf_getshdr (elf_getscn (ebl->elf, 0), &shdr_mem);
      if (shdr != ((void *)0))
        printf (dcgettext (((void *)0), " (%" "u" " in [0].sh_size)", __LC_MESSAGES),
                (uint32_t) shdr->sh_size);
      else
        fputs_unlocked (dcgettext (((void *)0), " ([0] not available)", __LC_MESSAGES), stdout);
    }
  fputc_unlocked ('\n', stdout);

  if (ehdr->e_shstrndx == 0xffff)
    {
      GElf_Shdr shdr_mem;
      GElf_Shdr *shdr = gelf_getshdr (elf_getscn (ebl->elf, 0), &shdr_mem);
      if (shdr != ((void *)0))

        snprintf (buf, sizeof (buf), dcgettext (((void *)0), " (%" "u" " in [0].sh_link)", __LC_MESSAGES),
                  (uint32_t) shdr->sh_link);
      else
        {
          __builtin_strncpy (buf, dcgettext (((void *)0), " ([0] not available)", __LC_MESSAGES), sizeof (buf));
          buf[sizeof (buf) - 1] = '\0';
        }

      printf (dcgettext (((void *)0), "  Section header string table index: XINDEX%s\n\n", __LC_MESSAGES),
              buf);
    }
  else
    printf (dcgettext (((void *)0), "  Section header string table index: %" "d" "\n\n", __LC_MESSAGES),
            ehdr->e_shstrndx);
}


static const char *
get_visibility_type (int value)
{
  switch (value)
    {
    case 0:
      return "DEFAULT";
    case 1:
      return "INTERNAL";
    case 2:
      return "HIDDEN";
    case 3:
      return "PROTECTED";
    default:
      return "???";
    }
}



static void
print_shdr (Ebl *ebl, GElf_Ehdr *ehdr)
{
  size_t cnt;
  size_t shstrndx;

  if (! print_file_header)
    printf (dcgettext (((void *)0), "There are %d section headers, starting at offset %#" "ll" "x" ":\n\n", __LC_MESSAGES),


            ehdr->e_shnum, ehdr->e_shoff);


  if (elf_getshstrndx (ebl->elf, &shstrndx) < 0)
    error (1, 0,
           dcgettext (((void *)0), "cannot get section header string table index", __LC_MESSAGES));

  puts (dcgettext (((void *)0), "Section Headers:", __LC_MESSAGES));

  if (ehdr->e_ident[4] == 1)
    puts (dcgettext (((void *)0), "[Nr] Name                 Type         Addr     Off    Size   ES Flags Lk Inf Al", __LC_MESSAGES));
  else
    puts (dcgettext (((void *)0), "[Nr] Name                 Type         Addr             Off      Size     ES Flags Lk Inf Al", __LC_MESSAGES));

  for (cnt = 0; cnt < shnum; ++cnt)
    {
      Elf_Scn *scn = elf_getscn (ebl->elf, cnt);

      if (scn == ((void *)0))
        error (1, 0, dcgettext (((void *)0), "cannot get section: %s", __LC_MESSAGES),
               elf_errmsg (-1));


      GElf_Shdr shdr_mem;
      GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
      if (shdr == ((void *)0))
        error (1, 0, dcgettext (((void *)0), "cannot get section header: %s", __LC_MESSAGES),
               elf_errmsg (-1));

      char flagbuf[20];
      char *cp = flagbuf;
      if (shdr->sh_flags & (1 << 0))
        *cp++ = 'W';
      if (shdr->sh_flags & (1 << 1))
        *cp++ = 'A';
      if (shdr->sh_flags & (1 << 2))
        *cp++ = 'X';
      if (shdr->sh_flags & (1 << 4))
        *cp++ = 'M';
      if (shdr->sh_flags & (1 << 5))
        *cp++ = 'S';
      if (shdr->sh_flags & (1 << 6))
        *cp++ = 'I';
      if (shdr->sh_flags & (1 << 7))
        *cp++ = 'L';
      if (shdr->sh_flags & (1 << 8))
        *cp++ = 'N';
      if (shdr->sh_flags & (1 << 9))
        *cp++ = 'G';
      if (shdr->sh_flags & (1 << 10))
        *cp++ = 'T';
      if (shdr->sh_flags & (1 << 30))
        *cp++ = 'O';
      if (shdr->sh_flags & (1 << 31))
        *cp++ = 'E';
      *cp = '\0';

      char buf[128];
      printf ("[%2zu] %-20s %-12s %0*" "ll" "x" " %0*" "ll" "x" " %0*" "ll" "x"
              " %2" "ll" "d" " %-5s %2" "d" " %3" "d"
              " %2" "ll" "d" "\n",
              cnt,
              elf_strptr (ebl->elf, shstrndx, shdr->sh_name)
              ?: "<corrupt>",
              ebl_section_type_name (ebl, shdr->sh_type, buf, sizeof (buf)),
              ehdr->e_ident[4] == 1 ? 8 : 16, shdr->sh_addr,
              ehdr->e_ident[4] == 1 ? 6 : 8, shdr->sh_offset,
              ehdr->e_ident[4] == 1 ? 6 : 8, shdr->sh_size,
              shdr->sh_entsize, flagbuf, shdr->sh_link, shdr->sh_info,
              shdr->sh_addralign);
    }

  fputc_unlocked ('\n', stdout);
}



static void
print_phdr (Ebl *ebl, GElf_Ehdr *ehdr)
{
  if (ehdr->e_phnum == 0)

    return;

  puts (dcgettext (((void *)0), "Program Headers:", __LC_MESSAGES));
  if (ehdr->e_ident[4] == 1)
    puts (dcgettext (((void *)0), "  Type           Offset   VirtAddr   PhysAddr   FileSiz  MemSiz   Flg Align", __LC_MESSAGES));

  else
    puts (dcgettext (((void *)0), "  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align", __LC_MESSAGES));



  _Bool has_relro = 0;
  GElf_Addr relro_from = 0;
  GElf_Addr relro_to = 0;
  for (size_t cnt = 0; cnt < ehdr->e_phnum; ++cnt)
    {
      char buf[128];
      GElf_Phdr mem;
      GElf_Phdr *phdr = gelf_getphdr (ebl->elf, cnt, &mem);


      if (phdr == ((void *)0))
        {
          puts ("  ???");
          continue;
        }

      printf ("  %-14s 0x%06" "ll" "x" " 0x%0*" "ll" "x" " 0x%0*" "ll" "x"
              " 0x%06" "ll" "x" " 0x%06" "ll" "x" " %c%c%c 0x%" "ll" "x" "\n",
              ebl_segment_type_name (ebl, phdr->p_type, buf, sizeof (buf)),
              phdr->p_offset,
              ehdr->e_ident[4] == 1 ? 8 : 16, phdr->p_vaddr,
              ehdr->e_ident[4] == 1 ? 8 : 16, phdr->p_paddr,
              phdr->p_filesz,
              phdr->p_memsz,
              phdr->p_flags & (1 << 2) ? 'R' : ' ',
              phdr->p_flags & (1 << 1) ? 'W' : ' ',
              phdr->p_flags & (1 << 0) ? 'E' : ' ',
              phdr->p_align);

      if (phdr->p_type == 3)
        {

          size_t maxsize;
          char *filedata = elf_rawfile (ebl->elf, &maxsize);

          if (filedata != ((void *)0) && phdr->p_offset < maxsize)
            printf (dcgettext (((void *)0), "\t[Requesting program interpreter: %s]\n", __LC_MESSAGES),
                    filedata + phdr->p_offset);
        }
      else if (phdr->p_type == 0x6474e552)
        {
          has_relro = 1;
          relro_from = phdr->p_vaddr;
          relro_to = relro_from + phdr->p_memsz;
        }
    }


  size_t shstrndx;
  if (elf_getshstrndx (ebl->elf, &shstrndx) < 0)
    error (1, 0,
           dcgettext (((void *)0), "cannot get section header string table index", __LC_MESSAGES));

  puts (dcgettext (((void *)0), "\n Section to Segment mapping:\n  Segment Sections...", __LC_MESSAGES));

  for (size_t cnt = 0; cnt < ehdr->e_phnum; ++cnt)
    {

      printf ("   %2.2zu     ", cnt);

      GElf_Phdr phdr_mem;
      GElf_Phdr *phdr = gelf_getphdr (ebl->elf, cnt, &phdr_mem);

      if (phdr == ((void *)0))
        error (1, 0, dcgettext (((void *)0), "cannot get program header: %s", __LC_MESSAGES),
               elf_errmsg (-1));


      _Bool in_relro = 0;
      _Bool in_ro = 0;
      for (size_t inner = 1; inner < shnum; ++inner)
        {
          Elf_Scn *scn = elf_getscn (ebl->elf, inner);

          if (scn == ((void *)0))
            error (1, 0, dcgettext (((void *)0), "cannot get section: %s", __LC_MESSAGES),
                   elf_errmsg (-1));


          GElf_Shdr shdr_mem;
          GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
          if (shdr == ((void *)0))
            error (1, 0,
                   dcgettext (((void *)0), "cannot get section header: %s", __LC_MESSAGES),
                   elf_errmsg (-1));

          if (shdr->sh_size > 0


              && (shdr->sh_flags & (1 << 1)
                  ? (shdr->sh_addr >= phdr->p_vaddr
                     && (shdr->sh_addr + shdr->sh_size
                         <= phdr->p_vaddr + phdr->p_memsz))
                  : (shdr->sh_offset >= phdr->p_offset
                     && (shdr->sh_offset + shdr->sh_size
                         <= phdr->p_offset + phdr->p_filesz))))
            {
              if (has_relro && !in_relro
                  && shdr->sh_addr >= relro_from
                  && shdr->sh_addr + shdr->sh_size <= relro_to)
                {
                  fputs_unlocked (" [RELRO:", stdout);
                  in_relro = 1;
                }
              else if (has_relro && in_relro && shdr->sh_addr >= relro_to)
                {
                  fputs_unlocked ("]", stdout);
                  in_relro = 0;
                }
              else if (has_relro && in_relro
                       && shdr->sh_addr + shdr->sh_size > relro_to)
                fputs_unlocked ("] <RELRO:", stdout);
              else if (phdr->p_type == 1 && (phdr->p_flags & (1 << 1)) == 0)
                {
                  if (!in_ro)
                    {
                      fputs_unlocked (" [RO:", stdout);
                      in_ro = 1;
                    }
                }
              else
                {

                  size_t cnt2;
                  GElf_Phdr *phdr2 = ((void *)0);
                  for (cnt2 = 0; cnt2 < ehdr->e_phnum; ++cnt2)
                    {
                      GElf_Phdr phdr2_mem;
                      phdr2 = gelf_getphdr (ebl->elf, cnt2, &phdr2_mem);

                      if (phdr2 != ((void *)0) && phdr2->p_type == 1
                          && shdr->sh_addr >= phdr2->p_vaddr
                          && (shdr->sh_addr + shdr->sh_size
                              <= phdr2->p_vaddr + phdr2->p_memsz))
                        break;
                    }

                  if (cnt2 < ehdr->e_phnum)
                    {
                      if ((phdr2->p_flags & (1 << 1)) == 0 && !in_ro)
                        {
                          fputs_unlocked (" [RO:", stdout);
                          in_ro = 1;
                        }
                      else if ((phdr2->p_flags & (1 << 1)) != 0 && in_ro)
                        {
                          fputs_unlocked ("]", stdout);
                          in_ro = 0;
                        }
                    }
                }

              printf (" %s",
                      elf_strptr (ebl->elf, shstrndx, shdr->sh_name));


              if (has_relro && in_relro
                       && shdr->sh_addr + shdr->sh_size > relro_to)
                {
                  fputs_unlocked (">", stdout);
                  in_relro = 0;
                }
            }
        }
      if (in_relro || in_ro)
        fputs_unlocked ("]", stdout);


      fputc_unlocked ('\n', stdout);
    }
}


static void
handle_scngrp (Ebl *ebl, Elf_Scn *scn, GElf_Shdr *shdr)
{

  Elf_Data *data = elf_getdata (scn, ((void *)0));

  Elf_Scn *symscn = elf_getscn (ebl->elf, shdr->sh_link);
  GElf_Shdr symshdr_mem;
  GElf_Shdr *symshdr = gelf_getshdr (symscn, &symshdr_mem);
  Elf_Data *symdata = elf_getdata (symscn, ((void *)0));

  if (data == ((void *)0) || data->d_size < sizeof (Elf32_Word) || symshdr == ((void *)0)
      || symdata == ((void *)0))
    return;


  size_t shstrndx;
  if (elf_getshstrndx (ebl->elf, &shstrndx) < 0)
    error (1, 0,
           dcgettext (((void *)0), "cannot get section header string table index", __LC_MESSAGES));

  Elf32_Word *grpref = (Elf32_Word *) data->d_buf;

  GElf_Sym sym_mem;
  GElf_Sym *sym = gelf_getsym (symdata, shdr->sh_info, &sym_mem);

  printf ((grpref[0] & 0x1)
          ? dcngettext (((void *)0), "\nCOMDAT section group [%2zu] '%s' with signature '%s' contains %zu entry:\n", "\nCOMDAT section group [%2zu] '%s' with signature '%s' contains %zu entries:\n", data->d_size / sizeof (Elf32_Word) - 1, __LC_MESSAGES)




          : dcngettext (((void *)0), "\nSection group [%2zu] '%s' with signature '%s' contains %zu entry:\n", "\nSection group [%2zu] '%s' with signature '%s' contains %zu entries:\n", data->d_size / sizeof (Elf32_Word) - 1, __LC_MESSAGES),



          elf_ndxscn (scn),
          elf_strptr (ebl->elf, shstrndx, shdr->sh_name),
          (sym == ((void *)0) ? ((void *)0)
           : elf_strptr (ebl->elf, symshdr->sh_link, sym->st_name))
          ?: dcgettext (((void *)0), "<INVALID SYMBOL>", __LC_MESSAGES),
          data->d_size / sizeof (Elf32_Word) - 1);

  for (size_t cnt = 1; cnt < data->d_size / sizeof (Elf32_Word); ++cnt)
    {
      GElf_Shdr grpshdr_mem;
      GElf_Shdr *grpshdr = gelf_getshdr (elf_getscn (ebl->elf, grpref[cnt]),
                                         &grpshdr_mem);

      const char *str;
      printf ("  [%2u] %s\n",
              grpref[cnt],
              grpshdr != ((void *)0)
              && (str = elf_strptr (ebl->elf, shstrndx, grpshdr->sh_name))
              ? str : dcgettext (((void *)0), "<INVALID SECTION>", __LC_MESSAGES));
    }
}


static void
print_scngrp (Ebl *ebl)
{

  Elf_Scn *scn = ((void *)0);

  while ((scn = elf_nextscn (ebl->elf, scn)) != ((void *)0))
    {

      GElf_Shdr shdr_mem;
      GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);

      if (shdr != ((void *)0) && shdr->sh_type == 17)
        handle_scngrp (ebl, scn, shdr);
    }
}


static const struct flags
{
  int mask;
  const char *str;
} dt_flags[] =
  {
    { 0x00000001, "ORIGIN" },
    { 0x00000002, "SYMBOLIC" },
    { 0x00000004, "TEXTREL" },
    { 0x00000008, "BIND_NOW" },
    { 0x00000010, "STATIC_TLS" }
  };
static const int ndt_flags = sizeof (dt_flags) / sizeof (dt_flags[0]);

static const struct flags dt_flags_1[] =
  {
    { 0x00000001, "NOW" },
    { 0x00000002, "GLOBAL" },
    { 0x00000004, "GROUP" },
    { 0x00000008, "NODELETE" },
    { 0x00000010, "LOADFLTR" },
    { 0x00000020, "INITFIRST" },
    { 0x00000040, "NOOPEN" },
    { 0x00000080, "ORIGIN" },
    { 0x00000100, "DIRECT" },
    { 0x00000200, "TRANS" },
    { 0x00000400, "INTERPOSE" },
    { 0x00000800, "NODEFLIB" },
    { 0x00001000, "NODUMP" },
    { 0x00002000, "CONFALT" },
    { 0x00004000, "ENDFILTEE" },
    { 0x00008000, "DISPRELDNE" },
    { 0x00010000, "DISPRELPND" },
  };
static const int ndt_flags_1 = sizeof (dt_flags_1) / sizeof (dt_flags_1[0]);

static const struct flags dt_feature_1[] =
  {
    { 0x00000001, "PARINIT" },
    { 0x00000002, "CONFEXP" }
  };
static const int ndt_feature_1 = (sizeof (dt_feature_1)
                                  / sizeof (dt_feature_1[0]));

static const struct flags dt_posflag_1[] =
  {
    { 0x00000001, "LAZYLOAD" },
    { 0x00000002, "GROUPPERM" }
  };
static const int ndt_posflag_1 = (sizeof (dt_posflag_1)
                                  / sizeof (dt_posflag_1[0]));


static void
print_flags (int class, GElf_Xword d_val, const struct flags *flags,
                int nflags)
{
  _Bool first = 1;
  int cnt;

  for (cnt = 0; cnt < nflags; ++cnt)
    if (d_val & flags[cnt].mask)
      {
        if (!first)
          putchar_unlocked (' ');
        fputs_unlocked (flags[cnt].str, stdout);
        d_val &= ~flags[cnt].mask;
        first = 0;
      }

  if (d_val != 0)
    {
      if (!first)
        putchar_unlocked (' ');
      printf ("%#0*" "ll" "x", class == 1 ? 10 : 18, d_val);
    }

  putchar_unlocked ('\n');
}


static void
print_dt_flags (int class, GElf_Xword d_val)
{
  print_flags (class, d_val, dt_flags, ndt_flags);
}


static void
print_dt_flags_1 (int class, GElf_Xword d_val)
{
  print_flags (class, d_val, dt_flags_1, ndt_flags_1);
}


static void
print_dt_feature_1 (int class, GElf_Xword d_val)
{
  print_flags (class, d_val, dt_feature_1, ndt_feature_1);
}


static void
print_dt_posflag_1 (int class, GElf_Xword d_val)
{
  print_flags (class, d_val, dt_posflag_1, ndt_posflag_1);
}


static void
handle_dynamic (Ebl *ebl, Elf_Scn *scn, GElf_Shdr *shdr)
{
  int class = gelf_getclass (ebl->elf);
  GElf_Shdr glink_mem;
  GElf_Shdr *glink;
  Elf_Data *data;
  size_t cnt;
  size_t shstrndx;


  data = elf_getdata (scn, ((void *)0));
  if (data == ((void *)0))
    return;


  if (elf_getshstrndx (ebl->elf, &shstrndx) < 0)
    error (1, 0,
           dcgettext (((void *)0), "cannot get section header string table index", __LC_MESSAGES));

  glink = gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link), &glink_mem);
  if (glink == ((void *)0))
    error (1, 0, dcgettext (((void *)0), "invalid sh_link value in section %Zu", __LC_MESSAGES),
           elf_ndxscn (scn));

  printf (dcngettext (((void *)0), "\nDynamic segment contains %lu entry:\n Addr: %#0*" "ll" "x" "  Offset: %#08" "ll" "x" "  Link to section: [%2u] '%s'\n", "\nDynamic segment contains %lu entries:\n Addr: %#0*" "ll" "x" "  Offset: %#08" "ll" "x" "  Link to section: [%2u] '%s'\n", shdr->sh_size / shdr->sh_entsize, __LC_MESSAGES),




          (unsigned long int) (shdr->sh_size / shdr->sh_entsize),
          class == 1 ? 10 : 18, shdr->sh_addr,
          shdr->sh_offset,
          (int) shdr->sh_link,
          elf_strptr (ebl->elf, shstrndx, glink->sh_name));
  fputs_unlocked (dcgettext (((void *)0), "  Type              Value\n", __LC_MESSAGES), stdout);

  for (cnt = 0; cnt < shdr->sh_size / shdr->sh_entsize; ++cnt)
    {
      GElf_Dyn dynmem;
      GElf_Dyn *dyn = gelf_getdyn (data, cnt, &dynmem);
      if (dyn == ((void *)0))
        break;

      char buf[64];
      printf ("  %-17s ",
              ebl_dynamic_tag_name (ebl, dyn->d_tag, buf, sizeof (buf)));

      switch (dyn->d_tag)
        {
        case 0:
        case 21:
        case 24:
        case 22:

          fputc_unlocked ('\n', stdout);
          break;

        case 1:
          printf (dcgettext (((void *)0), "Shared library: [%s]\n", __LC_MESSAGES),
                  elf_strptr (ebl->elf, shdr->sh_link, dyn->d_un.d_val));
          break;

        case 14:
          printf (dcgettext (((void *)0), "Library soname: [%s]\n", __LC_MESSAGES),
                  elf_strptr (ebl->elf, shdr->sh_link, dyn->d_un.d_val));
          break;

        case 15:
          printf (dcgettext (((void *)0), "Library rpath: [%s]\n", __LC_MESSAGES),
                  elf_strptr (ebl->elf, shdr->sh_link, dyn->d_un.d_val));
          break;

        case 29:
          printf (dcgettext (((void *)0), "Library runpath: [%s]\n", __LC_MESSAGES),
                  elf_strptr (ebl->elf, shdr->sh_link, dyn->d_un.d_val));
          break;

        case 2:
        case 8:
        case 10:
        case 18:
        case 9:
        case 11:
        case 19:
        case 0x6ffffdf9:
        case 0x6ffffdfa:
        case 0x6ffffdfb:
        case 27:
        case 28:
        case 0x6ffffdfe:
        case 0x6ffffdff:
        case 0x6ffffdf6:
        case 0x6ffffdf7:
          printf (dcgettext (((void *)0), "%" "ll" "d" " (bytes)\n", __LC_MESSAGES), dyn->d_un.d_val);
          break;

        case 0x6ffffffd:
        case 0x6fffffff:
        case 0x6ffffff9:
        case 0x6ffffffa:
          printf ("%" "ll" "d" "\n", dyn->d_un.d_val);
          break;

        case 20:
          puts (ebl_dynamic_tag_name (ebl, dyn->d_un.d_val, ((void *)0), 0));
          break;

        case 30:
          print_dt_flags (class, dyn->d_un.d_val);
          break;

        case 0x6ffffffb:
          print_dt_flags_1 (class, dyn->d_un.d_val);
          break;

        case 0x6ffffdfc:
          print_dt_feature_1 (class, dyn->d_un.d_val);
          break;

        case 0x6ffffdfd:
          print_dt_posflag_1 (class, dyn->d_un.d_val);
          break;

        default:
          printf ("%#0*" "ll" "x" "\n",
                  class == 1 ? 10 : 18, dyn->d_un.d_val);
          break;
        }
    }
}



static void
print_dynamic (Ebl *ebl, GElf_Ehdr *ehdr)
{
  for (int i = 0; i < ehdr->e_phnum; ++i)
    {
      GElf_Phdr phdr_mem;
      GElf_Phdr *phdr = gelf_getphdr (ebl->elf, i, &phdr_mem);

      if (phdr != ((void *)0) && phdr->p_type == 2)
        {
          Elf_Scn *scn = gelf_offscn (ebl->elf, phdr->p_offset);
          GElf_Shdr shdr_mem;
          GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
          if (shdr != ((void *)0) && shdr->sh_type == 6)
            handle_dynamic (ebl, scn, shdr);
          break;
        }
    }
}



static void
print_relocs (Ebl *ebl)
{

  Elf_Scn *scn = ((void *)0);

  while ((scn = elf_nextscn (ebl->elf, scn)) != ((void *)0))
    {

      GElf_Shdr shdr_mem;
      GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);

      if (shdr != ((void *)0))
        {
          if (shdr->sh_type == 9)
            handle_relocs_rel (ebl, scn, shdr);
          else if (shdr->sh_type == 4)
            handle_relocs_rela (ebl, scn, shdr);
        }
    }
}



static void
handle_relocs_rel (Ebl *ebl, Elf_Scn *scn, GElf_Shdr *shdr)
{
  int class = gelf_getclass (ebl->elf);
  int nentries = shdr->sh_size / shdr->sh_entsize;


  Elf_Data *data = elf_getdata (scn, ((void *)0));
  if (data == ((void *)0))
    return;


  Elf_Scn *symscn = elf_getscn (ebl->elf, shdr->sh_link);
  GElf_Shdr symshdr_mem;
  GElf_Shdr *symshdr = gelf_getshdr (symscn, &symshdr_mem);
  Elf_Data *symdata = elf_getdata (symscn, ((void *)0));


  GElf_Shdr destshdr_mem;
  GElf_Shdr *destshdr = gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_info),
                                      &destshdr_mem);

  if (symshdr == ((void *)0) || symdata == ((void *)0) || destshdr == ((void *)0))
    {
      printf (dcgettext (((void *)0), "\nInvalid symbol table at offset %#0" "ll" "x" "\n", __LC_MESSAGES),
              shdr->sh_offset);
      return;
    }


  Elf_Scn *xndxscn = ((void *)0);
  Elf_Data *xndxdata = ((void *)0);
  while ((xndxscn = elf_nextscn (ebl->elf, xndxscn)) != ((void *)0))
    {
      GElf_Shdr xndxshdr_mem;
      GElf_Shdr *xndxshdr = gelf_getshdr (xndxscn, &xndxshdr_mem);
      if (xndxshdr != ((void *)0) && xndxshdr->sh_type == 18
          && xndxshdr->sh_link == elf_ndxscn (symscn))
        {

          xndxdata = elf_getdata (xndxscn, ((void *)0));
          break;
        }
    }


  size_t shstrndx;
  if (elf_getshstrndx (ebl->elf, &shstrndx) < 0)
    error (1, 0,
           dcgettext (((void *)0), "cannot get section header string table index", __LC_MESSAGES));

  if (shdr->sh_info != 0)
    printf (dcngettext (((void *)0), "\nRelocation section [%2u] '%s' for section [%2u] '%s' at offset %#0" "ll" "x" " contains %d entry:\n", "\nRelocation section [%2u] '%s' for section [%2u] '%s' at offset %#0" "ll" "x" " contains %d entries:\n", nentries, __LC_MESSAGES),




            (unsigned int) elf_ndxscn (scn),
            elf_strptr (ebl->elf, shstrndx, shdr->sh_name),
            (unsigned int) shdr->sh_info,
            elf_strptr (ebl->elf, shstrndx, destshdr->sh_name),
            shdr->sh_offset,
            nentries);
  else



    printf (dcngettext (((void *)0), "\nRelocation section [%2u] '%s' at offset %#0" "ll" "x" " contains %d entry:\n", "\nRelocation section [%2u] '%s' at offset %#0" "ll" "x" " contains %d entries:\n", nentries, __LC_MESSAGES),




            (unsigned int) elf_ndxscn (scn),
            elf_strptr (ebl->elf, shstrndx, shdr->sh_name),
            shdr->sh_offset,
            nentries);
  fputs_unlocked (class == 1
                  ? dcgettext (((void *)0), "  Offset      Type                 Value       Name\n", __LC_MESSAGES)

                  : dcgettext (((void *)0), "  Offset              Type                 Value               Name\n", __LC_MESSAGES),

         stdout);

  for (int cnt = 0; cnt < nentries; ++cnt)
    {
      GElf_Rel relmem;
      GElf_Rel *rel = gelf_getrel (data, cnt, &relmem);
      if (rel != ((void *)0))
        {
          char buf[128];
          GElf_Sym symmem;
          Elf32_Word xndx;
          GElf_Sym *sym = gelf_getsymshndx (symdata, xndxdata,
                                            ((rel->r_info) >> 32),
                                            &symmem, &xndx);
          if (sym == ((void *)0))
            printf ("  %#0*" "ll" "x" "  %-20s <%s %ld>\n",
                    class == 1 ? 10 : 18, rel->r_offset,
                    ebl_reloc_type_check (ebl, ((rel->r_info) & 0xffffffff))


                    ? ebl_reloc_type_name (ebl, ((rel->r_info) & 0xffffffff),
                                           buf, sizeof (buf)) + 2
                    : dcgettext (((void *)0), "<INVALID RELOC>", __LC_MESSAGES),
                    dcgettext (((void *)0), "INVALID SYMBOL", __LC_MESSAGES),
                    (long int) ((rel->r_info) >> 32));
          else if (((sym->st_info) & 0xf) != 3)
            printf ("  %#0*" "ll" "x" "  %-20s %#0*" "ll" "x" "  %s\n",
                    class == 1 ? 10 : 18, rel->r_offset,
                    ebl_reloc_type_check (ebl, ((rel->r_info) & 0xffffffff))


                    ? ebl_reloc_type_name (ebl, ((rel->r_info) & 0xffffffff),
                                           buf, sizeof (buf)) + 2
                    : dcgettext (((void *)0), "<INVALID RELOC>", __LC_MESSAGES),
                    class == 1 ? 10 : 18, sym->st_value,
                    elf_strptr (ebl->elf, symshdr->sh_link, sym->st_name));
          else
            {
              destshdr = gelf_getshdr (elf_getscn (ebl->elf,
                                                   sym->st_shndx == 0xffff
                                                   ? xndx : sym->st_shndx),
                                       &destshdr_mem);

              if (shdr == ((void *)0))
                printf ("  %#0*" "ll" "x" "  %-20s <%s %ld>\n",
                        class == 1 ? 10 : 18, rel->r_offset,
                        ebl_reloc_type_check (ebl, ((rel->r_info) & 0xffffffff))


                        ? ebl_reloc_type_name (ebl, ((rel->r_info) & 0xffffffff),
                                               buf, sizeof (buf)) + 2
                        : dcgettext (((void *)0), "<INVALID RELOC>", __LC_MESSAGES),
                        dcgettext (((void *)0), "INVALID SECTION", __LC_MESSAGES),
                        (long int) (sym->st_shndx == 0xffff
                                    ? xndx : sym->st_shndx));
              else
                printf ("  %#0*" "ll" "x" "  %-20s %#0*" "ll" "x" "  %s\n",
                        class == 1 ? 10 : 18, rel->r_offset,
                        ebl_reloc_type_check (ebl, ((rel->r_info) & 0xffffffff))


                        ? ebl_reloc_type_name (ebl, ((rel->r_info) & 0xffffffff),
                                               buf, sizeof (buf)) + 2
                        : dcgettext (((void *)0), "<INVALID RELOC>", __LC_MESSAGES),
                        class == 1 ? 10 : 18, sym->st_value,
                        elf_strptr (ebl->elf, shstrndx, destshdr->sh_name));
            }
        }
    }
}



static void
handle_relocs_rela (Ebl *ebl, Elf_Scn *scn, GElf_Shdr *shdr)
{
  int class = gelf_getclass (ebl->elf);
  int nentries = shdr->sh_size / shdr->sh_entsize;


  Elf_Data *data = elf_getdata (scn, ((void *)0));
  if (data == ((void *)0))
    return;


  Elf_Scn *symscn = elf_getscn (ebl->elf, shdr->sh_link);
  GElf_Shdr symshdr_mem;
  GElf_Shdr *symshdr = gelf_getshdr (symscn, &symshdr_mem);
  Elf_Data *symdata = elf_getdata (symscn, ((void *)0));


  GElf_Shdr destshdr_mem;
  GElf_Shdr *destshdr = gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_info),
                                      &destshdr_mem);

  if (symshdr == ((void *)0) || symdata == ((void *)0) || destshdr == ((void *)0))
    {
      printf (dcgettext (((void *)0), "\nInvalid symbol table at offset %#0" "ll" "x" "\n", __LC_MESSAGES),
              shdr->sh_offset);
      return;
    }


  Elf_Data *xndxdata = ((void *)0);
  Elf_Scn *xndxscn = ((void *)0);
  while ((xndxscn = elf_nextscn (ebl->elf, xndxscn)) != ((void *)0))
    {
      GElf_Shdr xndxshdr_mem;
      GElf_Shdr *xndxshdr = gelf_getshdr (xndxscn, &xndxshdr_mem);
      if (xndxshdr != ((void *)0) && xndxshdr->sh_type == 18
          && xndxshdr->sh_link == elf_ndxscn (symscn))
        {

          xndxdata = elf_getdata (xndxscn, ((void *)0));
          break;
        }
    }


  size_t shstrndx;
  if (elf_getshstrndx (ebl->elf, &shstrndx) < 0)
    error (1, 0,
           dcgettext (((void *)0), "cannot get section header string table index", __LC_MESSAGES));

  printf (dcngettext (((void *)0), "\nRelocation section [%2zu] '%s' for section [%2u] '%s' at offset %#0" "ll" "x" " contains %d entry:\n", "\nRelocation section [%2zu] '%s' for section [%2u] '%s' at offset %#0" "ll" "x" " contains %d entries:\n", nentries, __LC_MESSAGES),




          elf_ndxscn (scn),
          elf_strptr (ebl->elf, shstrndx, shdr->sh_name),
          (unsigned int) shdr->sh_info,
          elf_strptr (ebl->elf, shstrndx, destshdr->sh_name),
          shdr->sh_offset,
          nentries);
  fputs_unlocked (class == 1
                  ? dcgettext (((void *)0), "  Offset      Type            Value       Addend Name\n", __LC_MESSAGES)

                  : dcgettext (((void *)0), "  Offset              Type            Value               Addend Name\n", __LC_MESSAGES),

                  stdout);

  for (int cnt = 0; cnt < nentries; ++cnt)
    {
      GElf_Rela relmem;
      GElf_Rela *rel = gelf_getrela (data, cnt, &relmem);
      if (rel != ((void *)0))
        {
          char buf[64];
          GElf_Sym symmem;
          Elf32_Word xndx;
          GElf_Sym *sym = gelf_getsymshndx (symdata, xndxdata,
                                            ((rel->r_info) >> 32),
                                            &symmem, &xndx);

          if (sym == ((void *)0))
            printf ("  %#0*" "ll" "x" "  %-15s <%s %ld>\n",
                    class == 1 ? 10 : 18, rel->r_offset,
                    ebl_reloc_type_check (ebl, ((rel->r_info) & 0xffffffff))


                    ? ebl_reloc_type_name (ebl, ((rel->r_info) & 0xffffffff),
                                           buf, sizeof (buf)) + 2
                    : dcgettext (((void *)0), "<INVALID RELOC>", __LC_MESSAGES),
                    dcgettext (((void *)0), "INVALID SYMBOL", __LC_MESSAGES),
                    (long int) ((rel->r_info) >> 32));
          else if (((sym->st_info) & 0xf) != 3)
            printf ("  %#0*" "ll" "x" "  %-15s %#0*" "ll" "x" "  +%5" "ll" "d" " %s\n",

                    class == 1 ? 10 : 18, rel->r_offset,
                    ebl_reloc_type_check (ebl, ((rel->r_info) & 0xffffffff))


                    ? ebl_reloc_type_name (ebl, ((rel->r_info) & 0xffffffff),
                                           buf, sizeof (buf)) + 2
                    : dcgettext (((void *)0), "<INVALID RELOC>", __LC_MESSAGES),
                    class == 1 ? 10 : 18, sym->st_value,
                    rel->r_addend,
                    elf_strptr (ebl->elf, symshdr->sh_link, sym->st_name));
          else
            {
              destshdr = gelf_getshdr (elf_getscn (ebl->elf,
                                                   sym->st_shndx == 0xffff
                                                   ? xndx : sym->st_shndx),
                                       &destshdr_mem);

              if (shdr == ((void *)0))
                printf ("  %#0*" "ll" "x" "  %-15s <%s %ld>\n",
                        class == 1 ? 10 : 18, rel->r_offset,
                        ebl_reloc_type_check (ebl, ((rel->r_info) & 0xffffffff))


                        ? ebl_reloc_type_name (ebl, ((rel->r_info) & 0xffffffff),
                                               buf, sizeof (buf)) + 2
                        : dcgettext (((void *)0), "<INVALID RELOC>", __LC_MESSAGES),
                        dcgettext (((void *)0), "INVALID SECTION", __LC_MESSAGES),
                        (long int) (sym->st_shndx == 0xffff
                                    ? xndx : sym->st_shndx));
              else
                printf ("  %#0*" "ll" "x" "  %-15s %#0*" "ll" "x" "  +%5" "ll" "d" " %s\n",

                        class == 1 ? 10 : 18, rel->r_offset,
                        ebl_reloc_type_check (ebl, ((rel->r_info) & 0xffffffff))


                        ? ebl_reloc_type_name (ebl, ((rel->r_info) & 0xffffffff),
                                               buf, sizeof (buf)) + 2
                        : dcgettext (((void *)0), "<INVALID RELOC>", __LC_MESSAGES),
                        class == 1 ? 10 : 18, sym->st_value,
                        rel->r_addend,
                        elf_strptr (ebl->elf, shstrndx, destshdr->sh_name));
            }
        }
    }
}



static void
print_symtab (Ebl *ebl, int type)
{


  Elf_Scn *scn = ((void *)0);

  while ((scn = elf_nextscn (ebl->elf, scn)) != ((void *)0))
    {

      GElf_Shdr shdr_mem;
      GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);

      if (shdr != ((void *)0) && shdr->sh_type == (GElf_Word) type)
        handle_symtab (ebl, scn, shdr);
    }
}


static void
handle_symtab (Ebl *ebl, Elf_Scn *scn, GElf_Shdr *shdr)
{
  Elf_Data *versym_data = ((void *)0);
  Elf_Data *verneed_data = ((void *)0);
  Elf_Data *verdef_data = ((void *)0);
  Elf_Data *xndx_data = ((void *)0);
  int class = gelf_getclass (ebl->elf);
  Elf32_Word verneed_stridx = 0;
  Elf32_Word verdef_stridx = 0;


  Elf_Data *data = elf_getdata (scn, ((void *)0));
  if (data == ((void *)0))
    return;


  Elf_Scn *runscn = ((void *)0);
  while ((runscn = elf_nextscn (ebl->elf, runscn)) != ((void *)0))
    {
      GElf_Shdr runshdr_mem;
      GElf_Shdr *runshdr = gelf_getshdr (runscn, &runshdr_mem);

      if (runshdr != ((void *)0))
        {
          if (runshdr->sh_type == 0x6fffffff
              && runshdr->sh_link == elf_ndxscn (scn))

            versym_data = elf_getdata (runscn, ((void *)0));
          else if (runshdr->sh_type == 0x6ffffffe)
            {

              verneed_data = elf_getdata (runscn, ((void *)0));
              verneed_stridx = runshdr->sh_link;
            }
          else if (runshdr->sh_type == 0x6ffffffd)
            {

              verdef_data = elf_getdata (runscn, ((void *)0));
              verdef_stridx = runshdr->sh_link;
            }
          else if (runshdr->sh_type == 18
              && runshdr->sh_link == elf_ndxscn (scn))

            xndx_data = elf_getdata (runscn, ((void *)0));
        }
    }


  size_t shstrndx;
  if (elf_getshstrndx (ebl->elf, &shstrndx) < 0)
    error (1, 0,
           dcgettext (((void *)0), "cannot get section header string table index", __LC_MESSAGES));

  GElf_Shdr glink_mem;
  GElf_Shdr *glink = gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link),
                                   &glink_mem);
  if (glink == ((void *)0))
    error (1, 0, dcgettext (((void *)0), "invalid sh_link value in section %Zu", __LC_MESSAGES),
           elf_ndxscn (scn));


  unsigned int nsyms = data->d_size / (class == 1
                                       ? sizeof (Elf32_Sym)
                                       : sizeof (Elf64_Sym));

  printf (dcngettext (((void *)0), "\nSymbol table [%2u] '%s' contains %u entry:\n", "\nSymbol table [%2u] '%s' contains %u entries:\n", nsyms, __LC_MESSAGES),


          (unsigned int) elf_ndxscn (scn),
          elf_strptr (ebl->elf, shstrndx, shdr->sh_name), nsyms);
  printf (dcngettext (((void *)0), " %lu local symbol  String table: [%2u] '%s'\n", " %lu local symbols  String table: [%2u] '%s'\n", shdr->sh_info, __LC_MESSAGES),


          (unsigned long int) shdr->sh_info,
          (unsigned int) shdr->sh_link,
          elf_strptr (ebl->elf, shstrndx, glink->sh_name));

  fputs_unlocked (class == 1
                  ? dcgettext (((void *)0), "  Num:    Value   Size Type    Bind   Vis          Ndx Name\n", __LC_MESSAGES)

                  : dcgettext (((void *)0), "  Num:            Value   Size Type    Bind   Vis          Ndx Name\n", __LC_MESSAGES),

                  stdout);

  for (unsigned int cnt = 0; cnt < nsyms; ++cnt)
    {
      char typebuf[64];
      char bindbuf[64];
      char scnbuf[64];
      Elf32_Word xndx;
      GElf_Sym sym_mem;
      GElf_Sym *sym = gelf_getsymshndx (data, xndx_data, cnt, &sym_mem, &xndx);

      if (sym == ((void *)0))
        continue;


      if (sym->st_shndx != 0xffff)
        xndx = sym->st_shndx;

      printf (dcgettext (((void *)0), "%5u: %0*" "ll" "x" " %6" "ll" "d" " %-7s %-6s %-9s %6s %s", __LC_MESSAGES),

              cnt,
              class == 1 ? 8 : 16,
              sym->st_value,
              sym->st_size,
              ebl_symbol_type_name (ebl, ((sym->st_info) & 0xf),
                                    typebuf, sizeof (typebuf)),
              ebl_symbol_binding_name (ebl, (((unsigned char) (sym->st_info)) >> 4),
                                       bindbuf, sizeof (bindbuf)),
              get_visibility_type (((sym->st_other) & 0x03)),
              ebl_section_name (ebl, sym->st_shndx, xndx, scnbuf,
                                sizeof (scnbuf), ((void *)0), shnum),
              elf_strptr (ebl->elf, shdr->sh_link, sym->st_name));

      if (versym_data != ((void *)0))
        {

          GElf_Versym versym_mem;
          GElf_Versym *versym = gelf_getversym (versym_data, cnt, &versym_mem);

          if (versym != ((void *)0) && ((*versym & 0x8000) != 0 || *versym > 1))
            {
              _Bool is_nobits = 0;
              _Bool check_def = xndx != 0;

              if (xndx < 0xff00 || sym->st_shndx == 0xffff)
                {
                  GElf_Shdr symshdr_mem;
                  GElf_Shdr *symshdr =
                    gelf_getshdr (elf_getscn (ebl->elf, xndx), &symshdr_mem);

                  is_nobits = (symshdr != ((void *)0)
                               && symshdr->sh_type == 8);
                }

              if (is_nobits || ! check_def)
                {

                  GElf_Vernaux vernaux_mem;
                  GElf_Vernaux *vernaux = ((void *)0);
                  size_t vn_offset = 0;

                  GElf_Verneed verneed_mem;
                  GElf_Verneed *verneed = gelf_getverneed (verneed_data, 0,
                                                           &verneed_mem);
                  while (verneed != ((void *)0))
                    {
                      size_t vna_offset = vn_offset;

                      vernaux = gelf_getvernaux (verneed_data,
                                                 vna_offset += verneed->vn_aux,
                                                 &vernaux_mem);
                      while (vernaux != ((void *)0)
                             && vernaux->vna_other != *versym
                             && vernaux->vna_next != 0)
                        {

                          vna_offset += vernaux->vna_next;

                          vernaux = (vernaux->vna_next == 0
                                     ? ((void *)0)
                                     : gelf_getvernaux (verneed_data,
                                                        vna_offset,
                                                        &vernaux_mem));
                        }


                      if (vernaux != ((void *)0) && vernaux->vna_other == *versym)

                        break;

                      vn_offset += verneed->vn_next;
                      verneed = (verneed->vn_next == 0
                                 ? ((void *)0)
                                 : gelf_getverneed (verneed_data, vn_offset,
                                                    &verneed_mem));
                    }

                  if (vernaux != ((void *)0) && vernaux->vna_other == *versym)
                    {
                      printf ("@%s (%u)",
                              elf_strptr (ebl->elf, verneed_stridx,
                                          vernaux->vna_name),
                              (unsigned int) vernaux->vna_other);
                      check_def = 0;
                    }
                  else if (! is_nobits)
                    error (0, 0, dcgettext (((void *)0), "bad dynamic symbol", __LC_MESSAGES));
                  else
                    check_def = 1;
                }

              if (check_def && *versym != 0x8001)
                {

                  size_t vd_offset = 0;

                  GElf_Verdef verdef_mem;
                  GElf_Verdef *verdef = gelf_getverdef (verdef_data, 0,
                                                        &verdef_mem);
                  while (verdef != ((void *)0))
                    {
                      if (verdef->vd_ndx == (*versym & 0x7fff))

                        break;

                      vd_offset += verdef->vd_next;
                      verdef = (verdef->vd_next == 0
                                ? ((void *)0)
                                : gelf_getverdef (verdef_data, vd_offset,
                                                  &verdef_mem));
                    }

                  if (verdef != ((void *)0))
                    {
                      GElf_Verdaux verdaux_mem;
                      GElf_Verdaux *verdaux
                        = gelf_getverdaux (verdef_data,
                                           vd_offset + verdef->vd_aux,
                                           &verdaux_mem);

                      if (verdaux != ((void *)0))
                        printf ((*versym & 0x8000) ? "@%s" : "@@%s",
                                elf_strptr (ebl->elf, verdef_stridx,
                                            verdaux->vda_name));
                    }
                }
            }
        }

      putchar_unlocked ('\n');
    }
}



static void
print_verinfo (Ebl *ebl)
{


  Elf_Scn *scn = ((void *)0);

  while ((scn = elf_nextscn (ebl->elf, scn)) != ((void *)0))
    {

      GElf_Shdr shdr_mem;
      GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);

      if (shdr != ((void *)0))
        {
          if (shdr->sh_type == 0x6ffffffe)
            handle_verneed (ebl, scn, shdr);
          else if (shdr->sh_type == 0x6ffffffd)
            handle_verdef (ebl, scn, shdr);
          else if (shdr->sh_type == 0x6fffffff)
            handle_versym (ebl, scn, shdr);
        }
    }
}


static const char *
get_ver_flags (unsigned int flags)
{
  static char buf[32];
  char *endp;

  if (flags == 0)
    return dcgettext (((void *)0), "none", __LC_MESSAGES);

  if (flags & 0x1)
    endp = (__extension__ (__builtin_constant_p ("BASE ") ? (((size_t)(const void *)(("BASE ") + 1) - (size_t)(const void *)("BASE ") == 1) && strlen ("BASE ") + 1 <= 8 ? __builtin_strcpy (buf, "BASE ") + strlen ("BASE ") : ((char *) (__mempcpy) (buf, "BASE ", strlen ("BASE ") + 1) - 1)) : __stpcpy (buf, "BASE ")));
  else
    endp = buf;

  if (flags & 0x2)
    {
      if (endp != buf)
        endp = (__extension__ (__builtin_constant_p ("| ") ? (((size_t)(const void *)(("| ") + 1) - (size_t)(const void *)("| ") == 1) && strlen ("| ") + 1 <= 8 ? __builtin_strcpy (endp, "| ") + strlen ("| ") : ((char *) (__mempcpy) (endp, "| ", strlen ("| ") + 1) - 1)) : __stpcpy (endp, "| ")));

      endp = (__extension__ (__builtin_constant_p ("WEAK ") ? (((size_t)(const void *)(("WEAK ") + 1) - (size_t)(const void *)("WEAK ") == 1) && strlen ("WEAK ") + 1 <= 8 ? __builtin_strcpy (endp, "WEAK ") + strlen ("WEAK ") : ((char *) (__mempcpy) (endp, "WEAK ", strlen ("WEAK ") + 1) - 1)) : __stpcpy (endp, "WEAK ")));
    }

  if (flags & ~(0x1 | 0x2))
    {
      __builtin_strncpy (endp, dcgettext (((void *)0), "| <unknown>", __LC_MESSAGES), buf + sizeof (buf) - endp);
      buf[sizeof (buf) - 1] = '\0';
    }

  return buf;
}


static void
handle_verneed (Ebl *ebl, Elf_Scn *scn, GElf_Shdr *shdr)
{
  int class = gelf_getclass (ebl->elf);


  Elf_Data *data = elf_getdata (scn, ((void *)0));
  if (data == ((void *)0))
    return;


  size_t shstrndx;
  if (elf_getshstrndx (ebl->elf, &shstrndx) < 0)
    error (1, 0,
           dcgettext (((void *)0), "cannot get section header string table index", __LC_MESSAGES));

  GElf_Shdr glink_mem;
  GElf_Shdr *glink = gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link),
                                   &glink_mem);
  if (glink == ((void *)0))
    error (1, 0, dcgettext (((void *)0), "invalid sh_link value in section %Zu", __LC_MESSAGES),
           elf_ndxscn (scn));

  printf (dcngettext (((void *)0), "\nVersion needs section [%2u] '%s' contains %d entry:\n Addr: %#0*" "ll" "x" "  Offset: %#08" "ll" "x" "  Link to section: [%2u] '%s'\n", "\nVersion needs section [%2u] '%s' contains %d entries:\n Addr: %#0*" "ll" "x" "  Offset: %#08" "ll" "x" "  Link to section: [%2u] '%s'\n", shdr->sh_info, __LC_MESSAGES),




          (unsigned int) elf_ndxscn (scn),
          elf_strptr (ebl->elf, shstrndx, shdr->sh_name), shdr->sh_info,
          class == 1 ? 10 : 18, shdr->sh_addr,
          shdr->sh_offset,
          (unsigned int) shdr->sh_link,
          elf_strptr (ebl->elf, shstrndx, glink->sh_name));

  unsigned int offset = 0;
  for (int cnt = shdr->sh_info; --cnt >= 0; )
    {

      GElf_Verneed needmem;
      GElf_Verneed *need = gelf_getverneed (data, offset, &needmem);
      if (need == ((void *)0))
        break;

      printf (dcgettext (((void *)0), "  %#06x: Version: %hu  File: %s  Cnt: %hu\n", __LC_MESSAGES),
              offset, (unsigned short int) need->vn_version,
              elf_strptr (ebl->elf, shdr->sh_link, need->vn_file),
              (unsigned short int) need->vn_cnt);

      unsigned int auxoffset = offset + need->vn_aux;
      for (int cnt2 = need->vn_cnt; --cnt2 >= 0; )
        {
          GElf_Vernaux auxmem;
          GElf_Vernaux *aux = gelf_getvernaux (data, auxoffset, &auxmem);
          if (aux == ((void *)0))
            break;

          printf (dcgettext (((void *)0), "  %#06x: Name: %s  Flags: %s  Version: %hu\n", __LC_MESSAGES),
                  auxoffset,
                  elf_strptr (ebl->elf, shdr->sh_link, aux->vna_name),
                  get_ver_flags (aux->vna_flags),
                  (unsigned short int) aux->vna_other);

          auxoffset += aux->vna_next;
        }


      offset += need->vn_next;
    }
}


static void
handle_verdef (Ebl *ebl, Elf_Scn *scn, GElf_Shdr *shdr)
{

  Elf_Data *data = elf_getdata (scn, ((void *)0));
  if (data == ((void *)0))
    return;


  size_t shstrndx;
  if (elf_getshstrndx (ebl->elf, &shstrndx) < 0)
    error (1, 0,
           dcgettext (((void *)0), "cannot get section header string table index", __LC_MESSAGES));

  GElf_Shdr glink_mem;
  GElf_Shdr *glink = gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link),
                                   &glink_mem);
  if (glink == ((void *)0))
    error (1, 0, dcgettext (((void *)0), "invalid sh_link value in section %Zu", __LC_MESSAGES),
           elf_ndxscn (scn));

  int class = gelf_getclass (ebl->elf);
  printf (dcngettext (((void *)0), "\nVersion definition section [%2u] '%s' contains %d entry:\n Addr: %#0*" "ll" "x" "  Offset: %#08" "ll" "x" "  Link to section: [%2u] '%s'\n", "\nVersion definition section [%2u] '%s' contains %d entries:\n Addr: %#0*" "ll" "x" "  Offset: %#08" "ll" "x" "  Link to section: [%2u] '%s'\n", shdr->sh_info, __LC_MESSAGES),




          (unsigned int) elf_ndxscn (scn),
          elf_strptr (ebl->elf, shstrndx, shdr->sh_name),
          shdr->sh_info,
          class == 1 ? 10 : 18, shdr->sh_addr,
          shdr->sh_offset,
          (unsigned int) shdr->sh_link,
          elf_strptr (ebl->elf, shstrndx, glink->sh_name));

  unsigned int offset = 0;
  for (int cnt = shdr->sh_info; --cnt >= 0; )
    {

      GElf_Verdef defmem;
      GElf_Verdef *def = gelf_getverdef (data, offset, &defmem);
      if (def == ((void *)0))
        break;

      unsigned int auxoffset = offset + def->vd_aux;
      GElf_Verdaux auxmem;
      GElf_Verdaux *aux = gelf_getverdaux (data, auxoffset, &auxmem);
      if (aux == ((void *)0))
        break;

      printf (dcgettext (((void *)0), "  %#06x: Version: %hd  Flags: %s  Index: %hd  Cnt: %hd  Name: %s\n", __LC_MESSAGES),

              offset, def->vd_version,
              get_ver_flags (def->vd_flags),
              def->vd_ndx,
              def->vd_cnt,
              elf_strptr (ebl->elf, shdr->sh_link, aux->vda_name));

      auxoffset += aux->vda_next;
      for (int cnt2 = 1; cnt2 < def->vd_cnt; ++cnt2)
        {
          aux = gelf_getverdaux (data, auxoffset, &auxmem);
          if (aux == ((void *)0))
            break;

          printf (dcgettext (((void *)0), "  %#06x: Parent %d: %s\n", __LC_MESSAGES),
                  auxoffset, cnt2,
                  elf_strptr (ebl->elf, shdr->sh_link, aux->vda_name));

          auxoffset += aux->vda_next;
        }


      offset += def->vd_next;
    }
}


static void
handle_versym (Ebl *ebl, Elf_Scn *scn, GElf_Shdr *shdr)
{
  int class = gelf_getclass (ebl->elf);
  const char **vername;
  const char **filename;


  Elf_Data *data = elf_getdata (scn, ((void *)0));
  if (data == ((void *)0))
    return;


  size_t shstrndx;
  if (elf_getshstrndx (ebl->elf, &shstrndx) < 0)
    error (1, 0,
           dcgettext (((void *)0), "cannot get section header string table index", __LC_MESSAGES));



  Elf_Scn *defscn = ((void *)0);
  Elf_Scn *needscn = ((void *)0);

  Elf_Scn *verscn = ((void *)0);
  while ((verscn = elf_nextscn (ebl->elf, verscn)) != ((void *)0))
    {
      GElf_Shdr vershdr_mem;
      GElf_Shdr *vershdr = gelf_getshdr (verscn, &vershdr_mem);

      if (vershdr != ((void *)0))
        {
          if (vershdr->sh_type == 0x6ffffffd)
            defscn = verscn;
          else if (vershdr->sh_type == 0x6ffffffe)
            needscn = verscn;
        }
    }

  size_t nvername;
  if (defscn != ((void *)0) || needscn != ((void *)0))
    {


      nvername = 0;
      if (defscn != ((void *)0))
        {


          unsigned int offset = 0;
          Elf_Data *defdata;
          GElf_Shdr defshdrmem;
          GElf_Shdr *defshdr;

          defdata = elf_getdata (defscn, ((void *)0));
          if (defdata == ((void *)0))
            return;

          defshdr = gelf_getshdr (defscn, &defshdrmem);
          if (defshdr == ((void *)0))
            return;

          for (unsigned int cnt = 0; cnt < defshdr->sh_info; ++cnt)
            {
              GElf_Verdef defmem;
              GElf_Verdef *def;


              def = gelf_getverdef (defdata, offset, &defmem);
              if (def == ((void *)0))
                break;

              nvername = (((nvername)>((size_t) (def->vd_ndx & 0x7fff)))?(nvername):((size_t) (def->vd_ndx & 0x7fff)));

              offset += def->vd_next;
            }
        }
      if (needscn != ((void *)0))
        {
          unsigned int offset = 0;
          Elf_Data *needdata;
          GElf_Shdr needshdrmem;
          GElf_Shdr *needshdr;

          needdata = elf_getdata (needscn, ((void *)0));
          if (needdata == ((void *)0))
            return;

          needshdr = gelf_getshdr (needscn, &needshdrmem);
          if (needshdr == ((void *)0))
            return;

          for (unsigned int cnt = 0; cnt < needshdr->sh_info; ++cnt)
            {
              GElf_Verneed needmem;
              GElf_Verneed *need;
              unsigned int auxoffset;
              int cnt2;


              need = gelf_getverneed (needdata, offset, &needmem);
              if (need == ((void *)0))
                break;


              auxoffset = offset + need->vn_aux;
              for (cnt2 = need->vn_cnt; --cnt2 >= 0; )
                {
                  GElf_Vernaux auxmem;
                  GElf_Vernaux *aux;

                  aux = gelf_getvernaux (needdata, auxoffset, &auxmem);
                  if (aux == ((void *)0))
                    break;

                  nvername = (((nvername)>((size_t) (aux->vna_other & 0x7fff)))?(nvername):((size_t) (aux->vna_other & 0x7fff)));


                  auxoffset += aux->vna_next;
                }

              offset += need->vn_next;
            }
        }


      ++nvername;


      vername = (const char **) __builtin_alloca (nvername * sizeof (const char *));
      filename = (const char **) __builtin_alloca (nvername * sizeof (const char *));


      if (defscn != ((void *)0))
        {


          unsigned int offset = 0;
          Elf_Data *defdata;
          GElf_Shdr defshdrmem;
          GElf_Shdr *defshdr;

          defdata = elf_getdata (defscn, ((void *)0));
          if (defdata == ((void *)0))
            return;

          defshdr = gelf_getshdr (defscn, &defshdrmem);
          if (defshdr == ((void *)0))
            return;

          for (unsigned int cnt = 0; cnt < defshdr->sh_info; ++cnt)
            {


              GElf_Verdef defmem;
              GElf_Verdef *def = gelf_getverdef (defdata, offset, &defmem);
              GElf_Verdaux auxmem;
              GElf_Verdaux *aux = gelf_getverdaux (defdata,
                                                   offset + def->vd_aux,
                                                   &auxmem);
              if (def == ((void *)0) || aux == ((void *)0))
                break;

              vername[def->vd_ndx & 0x7fff]
                = elf_strptr (ebl->elf, defshdr->sh_link, aux->vda_name);
              filename[def->vd_ndx & 0x7fff] = ((void *)0);

              offset += def->vd_next;
            }
        }
      if (needscn != ((void *)0))
        {
          unsigned int offset = 0;

          Elf_Data *needdata = elf_getdata (needscn, ((void *)0));
          GElf_Shdr needshdrmem;
          GElf_Shdr *needshdr = gelf_getshdr (needscn, &needshdrmem);
          if (needdata == ((void *)0) || needshdr == ((void *)0))
            return;

          for (unsigned int cnt = 0; cnt < needshdr->sh_info; ++cnt)
            {

              GElf_Verneed needmem;
              GElf_Verneed *need = gelf_getverneed (needdata, offset,
                                                    &needmem);
              if (need == ((void *)0))
                break;


              unsigned int auxoffset = offset + need->vn_aux;
              for (int cnt2 = need->vn_cnt; --cnt2 >= 0; )
                {
                  GElf_Vernaux auxmem;
                  GElf_Vernaux *aux = gelf_getvernaux (needdata, auxoffset,
                                                       &auxmem);
                  if (aux == ((void *)0))
                    break;

                  vername[aux->vna_other & 0x7fff]
                    = elf_strptr (ebl->elf, needshdr->sh_link, aux->vna_name);
                  filename[aux->vna_other & 0x7fff]
                    = elf_strptr (ebl->elf, needshdr->sh_link, need->vn_file);

                  auxoffset += aux->vna_next;
                }

              offset += need->vn_next;
            }
        }
    }
  else
    {
      vername = ((void *)0);
      nvername = 1;
      filename = ((void *)0);
    }

  GElf_Shdr glink_mem;
  GElf_Shdr *glink = gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link),
                                   &glink_mem);
  if (glink == ((void *)0))
    error (1, 0, dcgettext (((void *)0), "invalid sh_link value in section %Zu", __LC_MESSAGES),
           elf_ndxscn (scn));


  printf (dcngettext (((void *)0), "\nVersion symbols section [%2u] '%s' contains %d entry:\n Addr: %#0*" "ll" "x" "  Offset: %#08" "ll" "x" "  Link to section: [%2u] '%s'", "\nVersion symbols section [%2u] '%s' contains %d entries:\n Addr: %#0*" "ll" "x" "  Offset: %#08" "ll" "x" "  Link to section: [%2u] '%s'", shdr->sh_size / shdr->sh_entsize, __LC_MESSAGES),




          (unsigned int) elf_ndxscn (scn),
          elf_strptr (ebl->elf, shstrndx, shdr->sh_name),
          (int) (shdr->sh_size / shdr->sh_entsize),
          class == 1 ? 10 : 18, shdr->sh_addr,
          shdr->sh_offset,
          (unsigned int) shdr->sh_link,
          elf_strptr (ebl->elf, shstrndx, glink->sh_name));


  for (unsigned int cnt = 0; cnt < shdr->sh_size / shdr->sh_entsize; ++cnt)
    {
      if (cnt % 2 == 0)
        printf ("\n %4d:", cnt);

      GElf_Versym symmem;
      GElf_Versym *sym = gelf_getversym (data, cnt, &symmem);
      if (sym == ((void *)0))
        break;

      switch (*sym)
        {
          ssize_t n;
        case 0:
          fputs_unlocked (dcgettext (((void *)0), "   0 *local*                     ", __LC_MESSAGES),
                          stdout);
          break;

        case 1:
          fputs_unlocked (dcgettext (((void *)0), "   1 *global*                    ", __LC_MESSAGES),
                          stdout);
          break;

        default:
          n = printf ("%4d%c%s",
                      *sym & 0x7fff, *sym & 0x8000 ? 'h' : ' ',
                      (unsigned int) (*sym & 0x7fff) < nvername
                      ? vername[*sym & 0x7fff] : "???");
          if ((unsigned int) (*sym & 0x7fff) < nvername
              && filename[*sym & 0x7fff] != ((void *)0))
            n += printf ("(%s)", filename[*sym & 0x7fff]);
          printf ("%*s", (((0)>(33 - (int) n))?(0):(33 - (int) n)), " ");
          break;
        }
    }
  putchar_unlocked ('\n');
}




static void
handle_hash (Ebl *ebl)
{

  size_t shstrndx;
  if (elf_getshstrndx (ebl->elf, &shstrndx) < 0)
    error (1, 0,
           dcgettext (((void *)0), "cannot get section header string table index", __LC_MESSAGES));

  Elf_Scn *scn = ((void *)0);
  while ((scn = elf_nextscn (ebl->elf, scn)) != ((void *)0))
    {

      GElf_Shdr shdr_mem;
      GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);

      if (shdr != ((void *)0) && shdr->sh_type == 5)
        {
          Elf_Data *data = elf_getdata (scn, ((void *)0));
          if (data == ((void *)0))
            {
              error (0, 0, dcgettext (((void *)0), "cannot get data for section %d: %s", __LC_MESSAGES),
                     (int) elf_ndxscn (scn), elf_errmsg (-1));
              continue;
            }

          Elf32_Word nbucket = ((Elf32_Word *) data->d_buf)[0];
          Elf32_Word nchain = ((Elf32_Word *) data->d_buf)[1];
          Elf32_Word *bucket = &((Elf32_Word *) data->d_buf)[2];
          Elf32_Word *chain = &((Elf32_Word *) data->d_buf)[2 + nbucket];

          GElf_Shdr glink_mem;
          GElf_Shdr *glink = gelf_getshdr (elf_getscn (ebl->elf,
                                                       shdr->sh_link),
                                           &glink_mem);
          if (glink == ((void *)0))
            {
              error (0, 0, dcgettext (((void *)0), "invalid sh_link value in section %Zu", __LC_MESSAGES),
                     elf_ndxscn (scn));
              continue;
            }

          printf (dcngettext (((void *)0), "\nHistogram for bucket list length in section [%2u] '%s' (total of %d bucket):\n Addr: %#0*" "ll" "x" "  Offset: %#08" "ll" "x" "  Link to section: [%2u] '%s'\n", "\nHistogram for bucket list length in section [%2u] '%s' (total of %d buckets):\n Addr: %#0*" "ll" "x" "  Offset: %#08" "ll" "x" "  Link to section: [%2u] '%s'\n", nbucket, __LC_MESSAGES),




                  (unsigned int) elf_ndxscn (scn),
                  elf_strptr (ebl->elf, shstrndx, shdr->sh_name),
                  (int) nbucket,
                  gelf_getclass (ebl->elf) == 1 ? 10 : 18,
                  shdr->sh_addr,
                  shdr->sh_offset,
                  (unsigned int) shdr->sh_link,
                  elf_strptr (ebl->elf, shstrndx, glink->sh_name));

          uint32_t *lengths = (uint32_t *) xcalloc (nbucket,
                                                    sizeof (uint32_t));

          Elf32_Word maxlength = 0;
          Elf32_Word nsyms = 0;
          for (Elf32_Word cnt = 0; cnt < nbucket; ++cnt)
            if (bucket[cnt] != 0)
              {
                Elf32_Word inner = bucket[cnt];
                while (inner > 0 && inner < nchain)
                  {
                    ++nsyms;
                    if (maxlength < ++lengths[cnt])
                      ++maxlength;

                    inner = chain[inner];
                  }
              }

          uint32_t *counts = (uint32_t *) xcalloc (maxlength + 1,
                                                   sizeof (uint32_t));

          for (Elf32_Word cnt = 0; cnt < nbucket; ++cnt)
            ++counts[lengths[cnt]];

          if (nbucket > 0)
            {
              uint64_t success = 0;

              fputs_unlocked (dcgettext (((void *)0), " Length  Number  % of total  Coverage\n", __LC_MESSAGES), stdout);

              printf (dcgettext (((void *)0), "      0  %6" "u" "      %5.1f%%\n", __LC_MESSAGES),
                      counts[0], (counts[0] * 100.0) / nbucket);

              uint64_t nzero_counts = 0;
              for (Elf32_Word cnt = 1; cnt <= maxlength; ++cnt)
                {
                  nzero_counts += counts[cnt] * cnt;
                  printf (dcgettext (((void *)0), "%7d  %6" "u" "      %5.1f%%    %5.1f%%\n", __LC_MESSAGES),

                          (int) cnt,
                          counts[cnt], (counts[cnt] * 100.0) / nbucket,
                          (nzero_counts * 100.0) / nsyms);
                }

              Elf32_Word acc = 0;
              for (Elf32_Word cnt = 1; cnt <= maxlength; ++cnt)
                {
                  acc += cnt;
                  success += counts[cnt] * acc;
                }

              printf (dcgettext (((void *)0), " Average number of tests:   successful lookup: %f\n                          unsuccessful lookup: %f\n", __LC_MESSAGES),


                      (double) success / (double) nzero_counts,
                      (double) nzero_counts / (double) nbucket);
            }

          free (counts);
          free (lengths);
        }
    }
}


static void
print_liblist (Ebl *ebl)
{


  Elf_Scn *scn = ((void *)0);


  size_t shstrndx;
  if (elf_getshstrndx (ebl->elf, &shstrndx) < 0)
    error (1, 0,
           dcgettext (((void *)0), "cannot get section header string table index", __LC_MESSAGES));

  while ((scn = elf_nextscn (ebl->elf, scn)) != ((void *)0))
    {
      GElf_Shdr shdr_mem;
      GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);

      if (shdr != ((void *)0) && shdr->sh_type == 0x6ffffff7)
        {
          int nentries = shdr->sh_size / shdr->sh_entsize;
          printf (dcngettext (((void *)0), "\nLibrary list section [%2zu] '%s' at offset %#0" "ll" "x" " contains %d entry:\n", "\nLibrary list section [%2zu] '%s' at offset %#0" "ll" "x" " contains %d entries:\n", nentries, __LC_MESSAGES),




                  elf_ndxscn (scn),
                  elf_strptr (ebl->elf, shstrndx, shdr->sh_name),
                  shdr->sh_offset,
                  nentries);

          Elf_Data *data = elf_getdata (scn, ((void *)0));
          if (data == ((void *)0))
            return;

          puts (dcgettext (((void *)0), "       Library                       Time Stamp          Checksum Version Flags", __LC_MESSAGES));


          for (int cnt = 0; cnt < nentries; ++cnt)
            {
              GElf_Lib lib_mem;
              GElf_Lib *lib = gelf_getlib (data, cnt, &lib_mem);
              if (lib == ((void *)0))
                continue;

              time_t t = (time_t) lib->l_time_stamp;
              struct tm *tm = gmtime (&t);
              if (tm == ((void *)0))
                continue;

              printf ("  [%2d] %-29s %04u-%02u-%02uT%02u:%02u:%02u %08x %-7u %u\n",
                      cnt, elf_strptr (ebl->elf, shdr->sh_link, lib->l_name),
                      tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
                      tm->tm_hour, tm->tm_min, tm->tm_sec,
                      (unsigned int) lib->l_checksum,
                      (unsigned int) lib->l_version,
                      (unsigned int) lib->l_flags);
            }
        }
    }
}


static const char *
dwarf_tag_string (unsigned int tag)
{
  static const char *known_tags[] =
    {
      [DW_TAG_array_type] = "array_type",
      [DW_TAG_class_type] = "class_type",
      [DW_TAG_entry_point] = "entry_point",
      [DW_TAG_enumeration_type] = "enumeration_type",
      [DW_TAG_formal_parameter] = "formal_parameter",
      [DW_TAG_imported_declaration] = "imported_declaration",
      [DW_TAG_label] = "label",
      [DW_TAG_lexical_block] = "lexical_block",
      [DW_TAG_member] = "member",
      [DW_TAG_pointer_type] = "pointer_type",
      [DW_TAG_reference_type] = "reference_type",
      [DW_TAG_compile_unit] = "compile_unit",
      [DW_TAG_string_type] = "string_type",
      [DW_TAG_structure_type] = "structure_type",
      [DW_TAG_subroutine_type] = "subroutine_type",
      [DW_TAG_typedef] = "typedef",
      [DW_TAG_union_type] = "union_type",
      [DW_TAG_unspecified_parameters] = "unspecified_parameters",
      [DW_TAG_variant] = "variant",
      [DW_TAG_common_block] = "common_block",
      [DW_TAG_common_inclusion] = "common_inclusion",
      [DW_TAG_inheritance] = "inheritance",
      [DW_TAG_inlined_subroutine] = "inlined_subroutine",
      [DW_TAG_module] = "module",
      [DW_TAG_ptr_to_member_type] = "ptr_to_member_type",
      [DW_TAG_set_type] = "set_type",
      [DW_TAG_subrange_type] = "subrange_type",
      [DW_TAG_with_stmt] = "with_stmt",
      [DW_TAG_access_declaration] = "access_declaration",
      [DW_TAG_base_type] = "base_type",
      [DW_TAG_catch_block] = "catch_block",
      [DW_TAG_const_type] = "const_type",
      [DW_TAG_constant] = "constant",
      [DW_TAG_enumerator] = "enumerator",
      [DW_TAG_file_type] = "file_type",
      [DW_TAG_friend] = "friend",
      [DW_TAG_namelist] = "namelist",
      [DW_TAG_namelist_item] = "namelist_item",
      [DW_TAG_packed_type] = "packed_type",
      [DW_TAG_subprogram] = "subprogram",
      [DW_TAG_template_type_param] = "template_type_param",
      [DW_TAG_template_value_param] = "template_value_param",
      [DW_TAG_thrown_type] = "thrown_type",
      [DW_TAG_try_block] = "try_block",
      [DW_TAG_variant_part] = "variant_part",
      [DW_TAG_variable] = "variable",
      [DW_TAG_volatile_type] = "volatile_type",
      [DW_TAG_dwarf_procedure] = "dwarf_procedure",
      [DW_TAG_restrict_type] = "restrict_type",
      [DW_TAG_interface_type] = "interface_type",
      [DW_TAG_namespace] = "namespace",
      [DW_TAG_imported_module] = "imported_module",
      [DW_TAG_unspecified_type] = "unspecified_type",
      [DW_TAG_partial_unit] = "partial_unit",
      [DW_TAG_imported_unit] = "imported_unit",
      [DW_TAG_unspecified_type] = "unspecified_type",
      [DW_TAG_partial_unit] = "partial_unit",
      [DW_TAG_imported_unit] = "imported_unit",
      [DW_TAG_mutable_type] = "mutable_type",
    };
  const unsigned int nknown_tags = (sizeof (known_tags)
                                    / sizeof (known_tags[0]));
  static char buf[40];
  const char *result = ((void *)0);

  if (tag < nknown_tags)
    result = known_tags[tag];

  if (result == ((void *)0))

    switch (tag)
      {
      case DW_TAG_MIPS_loop:
        result = "MIPS_loop";
        break;

      case DW_TAG_format_label:
        result = "format_label";
        break;

      case DW_TAG_function_template:
        result = "function_template";
        break;

      case DW_TAG_class_template:
        result = "class_template";
        break;

      default:
        if (tag < DW_TAG_lo_user)
          snprintf (buf, sizeof buf, dcgettext (((void *)0), "unknown tag %hx", __LC_MESSAGES), tag);
        else
          snprintf (buf, sizeof buf, dcgettext (((void *)0), "unknown user tag %hx", __LC_MESSAGES), tag);
        result = buf;
        break;
      }

  return result;
}


static const char *
dwarf_attr_string (unsigned int attrnum)
{
  static const char *known_attrs[] =
    {
      [DW_AT_sibling] = "sibling",
      [DW_AT_location] = "location",
      [DW_AT_name] = "name",
      [DW_AT_ordering] = "ordering",
      [DW_AT_subscr_data] = "subscr_data",
      [DW_AT_byte_size] = "byte_size",
      [DW_AT_bit_offset] = "bit_offset",
      [DW_AT_bit_size] = "bit_size",
      [DW_AT_element_list] = "element_list",
      [DW_AT_stmt_list] = "stmt_list",
      [DW_AT_low_pc] = "low_pc",
      [DW_AT_high_pc] = "high_pc",
      [DW_AT_language] = "language",
      [DW_AT_member] = "member",
      [DW_AT_discr] = "discr",
      [DW_AT_discr_value] = "discr_value",
      [DW_AT_visibility] = "visibility",
      [DW_AT_import] = "import",
      [DW_AT_string_length] = "string_length",
      [DW_AT_common_reference] = "common_reference",
      [DW_AT_comp_dir] = "comp_dir",
      [DW_AT_const_value] = "const_value",
      [DW_AT_containing_type] = "containing_type",
      [DW_AT_default_value] = "default_value",
      [DW_AT_inline] = "inline",
      [DW_AT_is_optional] = "is_optional",
      [DW_AT_lower_bound] = "lower_bound",
      [DW_AT_producer] = "producer",
      [DW_AT_prototyped] = "prototyped",
      [DW_AT_return_addr] = "return_addr",
      [DW_AT_start_scope] = "start_scope",
      [DW_AT_stride_size] = "stride_size",
      [DW_AT_upper_bound] = "upper_bound",
      [DW_AT_abstract_origin] = "abstract_origin",
      [DW_AT_accessibility] = "accessibility",
      [DW_AT_address_class] = "address_class",
      [DW_AT_artificial] = "artificial",
      [DW_AT_base_types] = "base_types",
      [DW_AT_calling_convention] = "calling_convention",
      [DW_AT_count] = "count",
      [DW_AT_data_member_location] = "data_member_location",
      [DW_AT_decl_column] = "decl_column",
      [DW_AT_decl_file] = "decl_file",
      [DW_AT_decl_line] = "decl_line",
      [DW_AT_declaration] = "declaration",
      [DW_AT_discr_list] = "discr_list",
      [DW_AT_encoding] = "encoding",
      [DW_AT_external] = "external",
      [DW_AT_frame_base] = "frame_base",
      [DW_AT_friend] = "friend",
      [DW_AT_identifier_case] = "identifier_case",
      [DW_AT_macro_info] = "macro_info",
      [DW_AT_namelist_items] = "namelist_items",
      [DW_AT_priority] = "priority",
      [DW_AT_segment] = "segment",
      [DW_AT_specification] = "specification",
      [DW_AT_static_link] = "static_link",
      [DW_AT_type] = "type",
      [DW_AT_use_location] = "use_location",
      [DW_AT_variable_parameter] = "variable_parameter",
      [DW_AT_virtuality] = "virtuality",
      [DW_AT_vtable_elem_location] = "vtable_elem_location",
      [DW_AT_allocated] = "allocated",
      [DW_AT_associated] = "associated",
      [DW_AT_data_location] = "data_location",
      [DW_AT_stride] = "stride",
      [DW_AT_entry_pc] = "entry_pc",
      [DW_AT_use_UTF8] = "use_UTF8",
      [DW_AT_extension] = "extension",
      [DW_AT_ranges] = "ranges",
      [DW_AT_trampoline] = "trampoline",
      [DW_AT_call_column] = "call_column",
      [DW_AT_call_file] = "call_file",
      [DW_AT_call_line] = "call_line",
      [DW_AT_description] = "description"
    };
  const unsigned int nknown_attrs = (sizeof (known_attrs)
                                     / sizeof (known_attrs[0]));
  static char buf[40];
  const char *result = ((void *)0);

  if (attrnum < nknown_attrs)
    result = known_attrs[attrnum];

  if (result == ((void *)0))

    switch (attrnum)
      {
      case DW_AT_MIPS_fde:
        result = "MIPS_fde";
        break;

      case DW_AT_MIPS_loop_begin:
        result = "MIPS_loop_begin";
        break;

      case DW_AT_MIPS_tail_loop_begin:
        result = "MIPS_tail_loop_begin";
        break;

      case DW_AT_MIPS_epilog_begin:
        result = "MIPS_epilog_begin";
        break;

      case DW_AT_MIPS_loop_unroll_factor:
        result = "MIPS_loop_unroll_factor";
        break;

      case DW_AT_MIPS_software_pipeline_depth:
        result = "MIPS_software_pipeline_depth";
        break;

      case DW_AT_MIPS_linkage_name:
        result = "MIPS_linkage_name";
        break;

      case DW_AT_MIPS_stride:
        result = "MIPS_stride";
        break;

      case DW_AT_MIPS_abstract_name:
        result = "MIPS_abstract_name";
        break;

      case DW_AT_MIPS_clone_origin:
        result = "MIPS_clone_origin";
        break;

      case DW_AT_MIPS_has_inlines:
        result = "MIPS_has_inlines";
        break;

      case DW_AT_MIPS_stride_byte:
        result = "MIPS_stride_byte";
        break;

      case DW_AT_MIPS_stride_elem:
        result = "MIPS_stride_elem";
        break;

      case DW_AT_MIPS_ptr_dopetype:
        result = "MIPS_ptr_dopetype";
        break;

      case DW_AT_MIPS_allocatable_dopetype:
        result = "MIPS_allocatable_dopetype";
        break;

      case DW_AT_MIPS_assumed_shape_dopetype:
        result = "MIPS_assumed_shape_dopetype";
        break;

      case DW_AT_MIPS_assumed_size:
        result = "MIPS_assumed_size";
        break;

      case DW_AT_sf_names:
        result = "sf_names";
        break;

      case DW_AT_src_info:
        result = "src_info";
        break;

      case DW_AT_mac_info:
        result = "mac_info";
        break;

      case DW_AT_src_coords:
        result = "src_coords";
        break;

      case DW_AT_body_begin:
        result = "body_begin";
        break;

      case DW_AT_body_end:
        result = "body_end";
        break;

      default:
        if (attrnum < DW_AT_lo_user)
          snprintf (buf, sizeof buf, dcgettext (((void *)0), "unknown attribute %hx", __LC_MESSAGES),
                    attrnum);
        else
          snprintf (buf, sizeof buf, dcgettext (((void *)0), "unknown user attribute %hx", __LC_MESSAGES),
                    attrnum);
        result = buf;
        break;
      }

  return result;
}


static const char *
dwarf_form_string (unsigned int form)
{
  static const char *known_forms[] =
    {
      [DW_FORM_addr] = "addr",
      [DW_FORM_block2] = "block2",
      [DW_FORM_block4] = "block4",
      [DW_FORM_data2] = "data2",
      [DW_FORM_data4] = "data4",
      [DW_FORM_data8] = "data8",
      [DW_FORM_string] = "string",
      [DW_FORM_block] = "block",
      [DW_FORM_block1] = "block1",
      [DW_FORM_data1] = "data1",
      [DW_FORM_flag] = "flag",
      [DW_FORM_sdata] = "sdata",
      [DW_FORM_strp] = "strp",
      [DW_FORM_udata] = "udata",
      [DW_FORM_ref_addr] = "ref_addr",
      [DW_FORM_ref1] = "ref1",
      [DW_FORM_ref2] = "ref2",
      [DW_FORM_ref4] = "ref4",
      [DW_FORM_ref8] = "ref8",
      [DW_FORM_ref_udata] = "ref_udata",
      [DW_FORM_indirect] = "indirect"
    };
  const unsigned int nknown_forms = (sizeof (known_forms)
                                     / sizeof (known_forms[0]));
  static char buf[40];
  const char *result = ((void *)0);

  if (form < nknown_forms)
    result = known_forms[form];

  if (result == ((void *)0))
    snprintf (buf, sizeof buf, dcgettext (((void *)0), "unknown form %" "ll" "x", __LC_MESSAGES),
              (uint64_t) form);

  return result;
}


static const char *
dwarf_lang_string (unsigned int lang)
{
  static const char *known[] =
    {
      [DW_LANG_C89] = "ISO C89",
      [DW_LANG_C] = "C",
      [DW_LANG_Ada83] = "Ada83",
      [DW_LANG_C_plus_plus ] = "C++",
      [DW_LANG_Cobol74] = "Cobol74",
      [DW_LANG_Cobol85] = "Cobol85",
      [DW_LANG_Fortran77] = "Fortran77",
      [DW_LANG_Fortran90] = "Fortran90",
      [DW_LANG_Pascal83] = "Pascal83",
      [DW_LANG_Modula2] = "Modula2",
      [DW_LANG_Java] = "Java",
      [DW_LANG_C99] = "ISO C99",
      [DW_LANG_Ada95] = "Ada95",
      [DW_LANG_Fortran95] = "Fortran95",
      [DW_LANG_PL1] = "PL1"
    };

  if (lang < sizeof (known) / sizeof (known[0]))
    return known[lang];
  else if (lang == DW_LANG_Mips_Assembler)

    return "Assembler";

  if (lang >= DW_LANG_lo_user && lang <= DW_LANG_hi_user)
    {
      static char buf[30];
      snprintf (buf, sizeof (buf), "lo_user+%u", lang - DW_LANG_lo_user);
      return buf;
    }

  return "???";
}


static const char *
dwarf_inline_string (unsigned int code)
{
  static const char *known[] =
    {
      [DW_INL_not_inlined] = "not_inlined",
      [DW_INL_inlined] = "inlined",
      [DW_INL_declared_not_inlined] = "declared_not_inlined",
      [DW_INL_declared_inlined] = "declared_inlined"
    };

  if (code < sizeof (known) / sizeof (known[0]))
    return known[code];

  return "???";
}


static const char *
dwarf_encoding_string (unsigned int code)
{
  static const char *known[] =
    {
      [DW_ATE_void] = "void",
      [DW_ATE_address] = "address",
      [DW_ATE_boolean] = "boolean",
      [DW_ATE_complex_float] = "complex_float",
      [DW_ATE_float] = "float",
      [DW_ATE_signed] = "signed",
      [DW_ATE_signed_char] = "signed_char",
      [DW_ATE_unsigned] = "unsigned",
      [DW_ATE_unsigned_char] = "unsigned_char",
      [DW_ATE_imaginary_float] = "imaginary_float"
    };

  if (code < sizeof (known) / sizeof (known[0]))
    return known[code];

  if (code >= DW_ATE_lo_user && code <= DW_ATE_hi_user)
    {
      static char buf[30];
      snprintf (buf, sizeof (buf), "lo_user+%u", code - DW_ATE_lo_user);
      return buf;
    }

  return "???";
}


static const char *
dwarf_access_string (unsigned int code)
{
  static const char *known[] =
    {
      [DW_ACCESS_public] = "public",
      [DW_ACCESS_protected] = "protected",
      [DW_ACCESS_private] = "private"
    };

  if (code < sizeof (known) / sizeof (known[0]))
    return known[code];

  return "???";
}


static const char *
dwarf_visibility_string (unsigned int code)
{
  static const char *known[] =
    {
      [DW_VIS_local] = "local",
      [DW_VIS_exported] = "exported",
      [DW_VIS_qualified] = "qualified"
    };

  if (code < sizeof (known) / sizeof (known[0]))
    return known[code];

  return "???";
}


static const char *
dwarf_virtuality_string (unsigned int code)
{
  static const char *known[] =
    {
      [DW_VIRTUALITY_none] = "none",
      [DW_VIRTUALITY_virtual] = "virtual",
      [DW_VIRTUALITY_pure_virtual] = "pure_virtual"
    };

  if (code < sizeof (known) / sizeof (known[0]))
    return known[code];

  return "???";
}


static const char *
dwarf_identifier_case_string (unsigned int code)
{
  static const char *known[] =
    {
      [DW_ID_case_sensitive] = "sensitive",
      [DW_ID_up_case] = "up_case",
      [DW_ID_down_case] = "down_case",
      [DW_ID_case_insensitive] = "insensitive"
    };

  if (code < sizeof (known) / sizeof (known[0]))
    return known[code];

  return "???";
}


static const char *
dwarf_calling_convention_string (unsigned int code)
{
  static const char *known[] =
    {
      [DW_CC_normal] = "normal",
      [DW_CC_program] = "program",
      [DW_CC_nocall] = "nocall",
    };

  if (code < sizeof (known) / sizeof (known[0]))
    return known[code];

  if (code >= DW_CC_lo_user && code <= DW_CC_hi_user)
    {
      static char buf[30];
      snprintf (buf, sizeof (buf), "lo_user+%u", code - DW_CC_lo_user);
      return buf;
    }

  return "???";
}


static const char *
dwarf_ordering_string (unsigned int code)
{
  static const char *known[] =
    {
      [DW_ORD_row_major] = "row_major",
      [DW_ORD_col_major] = "col_major"
    };

  if (code < sizeof (known) / sizeof (known[0]))
    return known[code];

  return "???";
}


static const char *
dwarf_discr_list_string (unsigned int code)
{
  static const char *known[] =
    {
      [DW_DSC_label] = "label",
      [DW_DSC_range] = "range"
    };

  if (code < sizeof (known) / sizeof (known[0]))
    return known[code];

  return "???";
}


static void
print_ops (Dwarf *dbg, int indent, int indentrest,
           unsigned int addrsize, Dwarf_Word len, const unsigned char *data)
{
  static const char *known[] =
    {
      [DW_OP_addr] = "addr",
      [DW_OP_deref] = "deref",
      [DW_OP_const1u] = "const1u",
      [DW_OP_const1s] = "const1s",
      [DW_OP_const2u] = "const2u",
      [DW_OP_const2s] = "const2s",
      [DW_OP_const4u] = "const4u",
      [DW_OP_const4s] = "const4s",
      [DW_OP_const8u] = "const8u",
      [DW_OP_const8s] = "const8s",
      [DW_OP_constu] = "constu",
      [DW_OP_consts] = "consts",
      [DW_OP_dup] = "dup",
      [DW_OP_drop] = "drop",
      [DW_OP_over] = "over",
      [DW_OP_pick] = "pick",
      [DW_OP_swap] = "swap",
      [DW_OP_rot] = "rot",
      [DW_OP_xderef] = "xderef",
      [DW_OP_abs] = "abs",
      [DW_OP_and] = "and",
      [DW_OP_div] = "div",
      [DW_OP_minus] = "minus",
      [DW_OP_mod] = "mod",
      [DW_OP_mul] = "mul",
      [DW_OP_neg] = "neg",
      [DW_OP_not] = "not",
      [DW_OP_or] = "or",
      [DW_OP_plus] = "plus",
      [DW_OP_plus_uconst] = "plus_uconst",
      [DW_OP_shl] = "shl",
      [DW_OP_shr] = "shr",
      [DW_OP_shra] = "shra",
      [DW_OP_xor] = "xor",
      [DW_OP_bra] = "bra",
      [DW_OP_eq] = "eq",
      [DW_OP_ge] = "ge",
      [DW_OP_gt] = "gt",
      [DW_OP_le] = "le",
      [DW_OP_lt] = "lt",
      [DW_OP_ne] = "ne",
      [DW_OP_skip] = "skip",
      [DW_OP_lit0] = "lit0",
      [DW_OP_lit1] = "lit1",
      [DW_OP_lit2] = "lit2",
      [DW_OP_lit3] = "lit3",
      [DW_OP_lit4] = "lit4",
      [DW_OP_lit5] = "lit5",
      [DW_OP_lit6] = "lit6",
      [DW_OP_lit7] = "lit7",
      [DW_OP_lit8] = "lit8",
      [DW_OP_lit9] = "lit9",
      [DW_OP_lit10] = "lit10",
      [DW_OP_lit11] = "lit11",
      [DW_OP_lit12] = "lit12",
      [DW_OP_lit13] = "lit13",
      [DW_OP_lit14] = "lit14",
      [DW_OP_lit15] = "lit15",
      [DW_OP_lit16] = "lit16",
      [DW_OP_lit17] = "lit17",
      [DW_OP_lit18] = "lit18",
      [DW_OP_lit19] = "lit19",
      [DW_OP_lit20] = "lit20",
      [DW_OP_lit21] = "lit21",
      [DW_OP_lit22] = "lit22",
      [DW_OP_lit23] = "lit23",
      [DW_OP_lit24] = "lit24",
      [DW_OP_lit25] = "lit25",
      [DW_OP_lit26] = "lit26",
      [DW_OP_lit27] = "lit27",
      [DW_OP_lit28] = "lit28",
      [DW_OP_lit29] = "lit29",
      [DW_OP_lit30] = "lit30",
      [DW_OP_lit31] = "lit31",
      [DW_OP_reg0] = "reg0",
      [DW_OP_reg1] = "reg1",
      [DW_OP_reg2] = "reg2",
      [DW_OP_reg3] = "reg3",
      [DW_OP_reg4] = "reg4",
      [DW_OP_reg5] = "reg5",
      [DW_OP_reg6] = "reg6",
      [DW_OP_reg7] = "reg7",
      [DW_OP_reg8] = "reg8",
      [DW_OP_reg9] = "reg9",
      [DW_OP_reg10] = "reg10",
      [DW_OP_reg11] = "reg11",
      [DW_OP_reg12] = "reg12",
      [DW_OP_reg13] = "reg13",
      [DW_OP_reg14] = "reg14",
      [DW_OP_reg15] = "reg15",
      [DW_OP_reg16] = "reg16",
      [DW_OP_reg17] = "reg17",
      [DW_OP_reg18] = "reg18",
      [DW_OP_reg19] = "reg19",
      [DW_OP_reg20] = "reg20",
      [DW_OP_reg21] = "reg21",
      [DW_OP_reg22] = "reg22",
      [DW_OP_reg23] = "reg23",
      [DW_OP_reg24] = "reg24",
      [DW_OP_reg25] = "reg25",
      [DW_OP_reg26] = "reg26",
      [DW_OP_reg27] = "reg27",
      [DW_OP_reg28] = "reg28",
      [DW_OP_reg29] = "reg29",
      [DW_OP_reg30] = "reg30",
      [DW_OP_reg31] = "reg31",
      [DW_OP_breg0] = "breg0",
      [DW_OP_breg1] = "breg1",
      [DW_OP_breg2] = "breg2",
      [DW_OP_breg3] = "breg3",
      [DW_OP_breg4] = "breg4",
      [DW_OP_breg5] = "breg5",
      [DW_OP_breg6] = "breg6",
      [DW_OP_breg7] = "breg7",
      [DW_OP_breg8] = "breg8",
      [DW_OP_breg9] = "breg9",
      [DW_OP_breg10] = "breg10",
      [DW_OP_breg11] = "breg11",
      [DW_OP_breg12] = "breg12",
      [DW_OP_breg13] = "breg13",
      [DW_OP_breg14] = "breg14",
      [DW_OP_breg15] = "breg15",
      [DW_OP_breg16] = "breg16",
      [DW_OP_breg17] = "breg17",
      [DW_OP_breg18] = "breg18",
      [DW_OP_breg19] = "breg19",
      [DW_OP_breg20] = "breg20",
      [DW_OP_breg21] = "breg21",
      [DW_OP_breg22] = "breg22",
      [DW_OP_breg23] = "breg23",
      [DW_OP_breg24] = "breg24",
      [DW_OP_breg25] = "breg25",
      [DW_OP_breg26] = "breg26",
      [DW_OP_breg27] = "breg27",
      [DW_OP_breg28] = "breg28",
      [DW_OP_breg29] = "breg29",
      [DW_OP_breg30] = "breg30",
      [DW_OP_breg31] = "breg31",
      [DW_OP_regx] = "regx",
      [DW_OP_fbreg] = "fbreg",
      [DW_OP_bregx] = "bregx",
      [DW_OP_piece] = "piece",
      [DW_OP_deref_size] = "deref_size",
      [DW_OP_xderef_size] = "xderef_size",
      [DW_OP_nop] = "nop",
      [DW_OP_push_object_address] = "push_object_address",
      [DW_OP_call2] = "call2",
      [DW_OP_call4] = "call4",
      [DW_OP_call_ref] = "call_ref",
    };

  Dwarf_Word offset = 0;
  while (len-- > 0)
    {
      size_t op = *data++;

      switch (op)
        {
        case DW_OP_call_ref:
        case DW_OP_addr:;

          Dwarf_Word addr;
          if (addrsize == 4)
            addr = (__builtin_expect ((dbg)->other_byte_order, 0) ? (__extension__ ({ register unsigned int __v, __x = (*((const uint32_t *) (data))); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })) : *((const uint32_t *) (data)));
          else
            {
              ((void) ((addrsize == 8) ? 0 : (__assert_fail ("addrsize == 8", "readelf.c", 3254, __PRETTY_FUNCTION__), 0)));
              addr = (__builtin_expect ((dbg)->other_byte_order, 0) ? (__extension__ ({ union { __extension__ unsigned long long int __ll; unsigned long int __l[2]; } __w, __r; if (__builtin_constant_p (*((const uint64_t *) (data)))) __r.__ll = ((((*((const uint64_t *) (data))) & 0xff00000000000000ull) >> 56) | (((*((const uint64_t *) (data))) & 0x00ff000000000000ull) >> 40) | (((*((const uint64_t *) (data))) & 0x0000ff0000000000ull) >> 24) | (((*((const uint64_t *) (data))) & 0x000000ff00000000ull) >> 8) | (((*((const uint64_t *) (data))) & 0x00000000ff000000ull) << 8) | (((*((const uint64_t *) (data))) & 0x0000000000ff0000ull) << 24) | (((*((const uint64_t *) (data))) & 0x000000000000ff00ull) << 40) | (((*((const uint64_t *) (data))) & 0x00000000000000ffull) << 56)); else { __w.__ll = (*((const uint64_t *) (data))); __r.__l[0] = (__extension__ ({ register unsigned int __v, __x = (__w.__l[1]); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })); __r.__l[1] = (__extension__ ({ register unsigned int __v, __x = (__w.__l[0]); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })); } __r.__ll; })) : *((const uint64_t *) (data)));
            }
          data += addrsize;
          len -= addrsize;

          printf ("%*s[%4" "ll" "u" "] %s %" "ll" "u" "\n",
                  indent, "", (uintmax_t) offset,
                  known[op] ?: "???", (uintmax_t) addr);
          offset += 1 + addrsize;
          break;

        case DW_OP_deref_size:
        case DW_OP_xderef_size:
        case DW_OP_pick:
        case DW_OP_const1u:
          printf ("%*s[%4" "ll" "u" "] %s %" "u" "\n",
                  indent, "", (uintmax_t) offset,
                  known[op] ?: "???", *((uint8_t *) data));
          ++data;
          --len;
          offset += 2;
          break;

        case DW_OP_const2u:
          printf ("%*s[%4" "ll" "u" "] %s %" "u" "\n",
                  indent, "", (uintmax_t) offset,
                  known[op] ?: "???", (__builtin_expect ((dbg)->other_byte_order, 0) ? (__extension__ ({ register unsigned short int __v, __x = (*((const uint16_t *) (data))); if (__builtin_constant_p (__x)) __v = ((((__x) >> 8) & 0xff) | (((__x) & 0xff) << 8)); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })) : *((const uint16_t *) (data))));
          len -= 2;
          data += 2;
          offset += 3;
          break;

        case DW_OP_const4u:
          printf ("%*s[%4" "ll" "u" "] %s %" "u" "\n",
                  indent, "", (uintmax_t) offset,
                  known[op] ?: "???", (__builtin_expect ((dbg)->other_byte_order, 0) ? (__extension__ ({ register unsigned int __v, __x = (*((const uint32_t *) (data))); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })) : *((const uint32_t *) (data))));
          len -= 4;
          data += 4;
          offset += 5;
          break;

        case DW_OP_const8u:
          printf ("%*s[%4" "ll" "u" "] %s %" "ll" "u" "\n",
                  indent, "", (uintmax_t) offset,
                  known[op] ?: "???", (__builtin_expect ((dbg)->other_byte_order, 0) ? (__extension__ ({ union { __extension__ unsigned long long int __ll; unsigned long int __l[2]; } __w, __r; if (__builtin_constant_p (*((const uint64_t *) (data)))) __r.__ll = ((((*((const uint64_t *) (data))) & 0xff00000000000000ull) >> 56) | (((*((const uint64_t *) (data))) & 0x00ff000000000000ull) >> 40) | (((*((const uint64_t *) (data))) & 0x0000ff0000000000ull) >> 24) | (((*((const uint64_t *) (data))) & 0x000000ff00000000ull) >> 8) | (((*((const uint64_t *) (data))) & 0x00000000ff000000ull) << 8) | (((*((const uint64_t *) (data))) & 0x0000000000ff0000ull) << 24) | (((*((const uint64_t *) (data))) & 0x000000000000ff00ull) << 40) | (((*((const uint64_t *) (data))) & 0x00000000000000ffull) << 56)); else { __w.__ll = (*((const uint64_t *) (data))); __r.__l[0] = (__extension__ ({ register unsigned int __v, __x = (__w.__l[1]); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })); __r.__l[1] = (__extension__ ({ register unsigned int __v, __x = (__w.__l[0]); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })); } __r.__ll; })) : *((const uint64_t *) (data))));
          len -= 8;
          data += 8;
          offset += 9;
          break;

        case DW_OP_const1s:
          printf ("%*s[%4" "ll" "u" "] %s %" "d" "\n",
                  indent, "", (uintmax_t) offset,
                  known[op] ?: "???", *((int8_t *) data));
          ++data;
          --len;
          offset += 2;
          break;

        case DW_OP_const2s:
          printf ("%*s[%4" "ll" "u" "] %s %" "d" "\n",
                  indent, "", (uintmax_t) offset,
                  known[op] ?: "???", (__builtin_expect ((dbg)->other_byte_order, 0) ? (int16_t) (__extension__ ({ register unsigned short int __v, __x = (*((const int16_t *) (data))); if (__builtin_constant_p (__x)) __v = ((((__x) >> 8) & 0xff) | (((__x) & 0xff) << 8)); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })) : *((const int16_t *) (data))));
          len -= 2;
          data += 2;
          offset += 3;
          break;

        case DW_OP_const4s:
          printf ("%*s[%4" "ll" "u" "] %s %" "d" "\n",
                  indent, "", (uintmax_t) offset,
                  known[op] ?: "???", (__builtin_expect ((dbg)->other_byte_order, 0) ? (int32_t) (__extension__ ({ register unsigned int __v, __x = (*((const int32_t *) (data))); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })) : *((const int32_t *) (data))));
          len -= 4;
          data += 4;
          offset += 5;
          break;

        case DW_OP_const8s:
          printf ("%*s[%4" "ll" "u" "] %s %" "ll" "d" "\n",
                  indent, "", (uintmax_t) offset,
                  known[op] ?: "???", (__builtin_expect ((dbg)->other_byte_order, 0) ? (int64_t) (__extension__ ({ union { __extension__ unsigned long long int __ll; unsigned long int __l[2]; } __w, __r; if (__builtin_constant_p (*((const int64_t *) (data)))) __r.__ll = ((((*((const int64_t *) (data))) & 0xff00000000000000ull) >> 56) | (((*((const int64_t *) (data))) & 0x00ff000000000000ull) >> 40) | (((*((const int64_t *) (data))) & 0x0000ff0000000000ull) >> 24) | (((*((const int64_t *) (data))) & 0x000000ff00000000ull) >> 8) | (((*((const int64_t *) (data))) & 0x00000000ff000000ull) << 8) | (((*((const int64_t *) (data))) & 0x0000000000ff0000ull) << 24) | (((*((const int64_t *) (data))) & 0x000000000000ff00ull) << 40) | (((*((const int64_t *) (data))) & 0x00000000000000ffull) << 56)); else { __w.__ll = (*((const int64_t *) (data))); __r.__l[0] = (__extension__ ({ register unsigned int __v, __x = (__w.__l[1]); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })); __r.__l[1] = (__extension__ ({ register unsigned int __v, __x = (__w.__l[0]); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })); } __r.__ll; })) : *((const int64_t *) (data))));
          len -= 8;
          data += 8;
          offset += 9;
          break;

        case DW_OP_piece:
        case DW_OP_regx:
        case DW_OP_plus_uconst:
        case DW_OP_constu:;
          const unsigned char *start = data;
          unsigned int uleb;
          do { unsigned char __b; uleb = 0; __b = *(data)++; uleb |= (uintmax_t) (__b & 0x7f) << (0 * 7); if (__builtin_expect ((__b & 0x80) == 0, 1)) break; uleb = __libdw_get_uleb128 (uleb, 1, &(data)); } while (0);
          printf ("%*s[%4" "ll" "u" "] %s %u\n",
                  indent, "", (uintmax_t) offset,
                  known[op] ?: "???", uleb);
          len -= data - start;
          offset += 1 + (data - start);
          break;

        case DW_OP_fbreg:
        case DW_OP_breg0 ... DW_OP_breg31:
        case DW_OP_consts:
          start = data;
          unsigned int sleb;
          do { unsigned char __b; int64_t _v = 0; __b = *(data)++; _v |= (uint64_t) (__b & 0x7f) << (0 * 7); if (__builtin_expect ((__b & 0x80) == 0, 1)) { sleb = (_v << (64 - (0 * 7) - 7) >> (64 - (0 * 7) - 7)); break; } else do {} while (0); sleb = __libdw_get_sleb128 (_v, 1, &(data)); } while (0);
          printf ("%*s[%4" "ll" "u" "] %s %d\n",
                  indent, "", (uintmax_t) offset,
                  known[op] ?: "???", sleb);
          len -= data - start;
          offset += 1 + (data - start);
          break;

        case DW_OP_bregx:
          start = data;
          do { unsigned char __b; uleb = 0; __b = *(data)++; uleb |= (uintmax_t) (__b & 0x7f) << (0 * 7); if (__builtin_expect ((__b & 0x80) == 0, 1)) break; uleb = __libdw_get_uleb128 (uleb, 1, &(data)); } while (0);
          do { unsigned char __b; int64_t _v = 0; __b = *(data)++; _v |= (uint64_t) (__b & 0x7f) << (0 * 7); if (__builtin_expect ((__b & 0x80) == 0, 1)) { sleb = (_v << (64 - (0 * 7) - 7) >> (64 - (0 * 7) - 7)); break; } else do {} while (0); sleb = __libdw_get_sleb128 (_v, 1, &(data)); } while (0);
          printf ("%*s[%4" "ll" "u" "] %s %u %d\n",
                  indent, "", (uintmax_t) offset,
                  known[op] ?: "???", uleb, sleb);
          len -= data - start;
          offset += 1 + (data - start);
          break;

        case DW_OP_call2:
        case DW_OP_call4:
        case DW_OP_skip:
        case DW_OP_bra:
          printf ("%*s[%4" "ll" "u" "] %s %" "ll" "u" "\n",
                  indent, "", (uintmax_t) offset,
                  known[op] ?: "???",
                  (uintmax_t) (offset + (__builtin_expect ((dbg)->other_byte_order, 0) ? (int16_t) (__extension__ ({ register unsigned short int __v, __x = (*((const int16_t *) (data))); if (__builtin_constant_p (__x)) __v = ((((__x) >> 8) & 0xff) | (((__x) & 0xff) << 8)); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })) : *((const int16_t *) (data)))));
          len -= 2;
          data += 2;
          offset += 3;
          break;

        default:

          printf ("%*s[%4" "ll" "u" "] %s\n",
                  indent, "", (uintmax_t) offset,
                  known[op] ?: "???");
          ++offset;
          break;
        }

      indent = indentrest;
    }
}


static void
print_debug_abbrev_section (Ebl *ebl __attribute__ ((unused)),
                            GElf_Ehdr *ehdr __attribute__ ((unused)),
                            Elf_Scn *scn __attribute__ ((unused)),
                            GElf_Shdr *shdr, Dwarf *dbg)
{
  printf (dcgettext (((void *)0), "\nDWARF section '%s' at offset %#" "ll" "x" ":\n" " [ Code]\n", __LC_MESSAGES),

          ".debug_abbrev", (uint64_t) shdr->sh_offset);

  Dwarf_Off offset = 0;
  while (offset < shdr->sh_size)
    {
      printf (dcgettext (((void *)0), "\nAbbreviation section at offset %" "ll" "u" ":\n", __LC_MESSAGES),
              offset);

      while (1)
        {
          size_t length;
          Dwarf_Abbrev abbrev;

          int res = dwarf_offabbrev (dbg, offset, &length, &abbrev);
          if (res != 0)
            {
              if (res < 0)
                {
                  printf (dcgettext (((void *)0), " *** error while reading abbreviation: %s\n", __LC_MESSAGES),

                          dwarf_errmsg (-1));
                  return;
                }


              ++offset;
              break;
            }


          unsigned int code = dwarf_getabbrevcode (&abbrev);
          unsigned int tag = dwarf_getabbrevtag (&abbrev);
          int has_children = dwarf_abbrevhaschildren (&abbrev);

          printf (dcgettext (((void *)0), " [%5u] offset: %" "ll" "d" ", children: %s, tag: %s\n", __LC_MESSAGES),

                  code, (int64_t) offset,
                  has_children ? dcgettext (((void *)0), "yes", __LC_MESSAGES) : dcgettext (((void *)0), "no", __LC_MESSAGES),
                  dwarf_tag_string (tag));

          size_t cnt = 0;
          unsigned int name;
          unsigned int form;
          Dwarf_Off enoffset;
          while (dwarf_getabbrevattr (&abbrev, cnt,
                                      &name, &form, &enoffset) == 0)
            {
              printf ("          attr: %s, form: %s, offset: %#" "ll" "x" "\n",
                      dwarf_attr_string (name), dwarf_form_string (form),
                      (uint64_t) enoffset);

              ++cnt;
            }

          offset += length;
        }
    }
}





static void
print_debug_aranges_section (Ebl *ebl __attribute__ ((unused)),
                             GElf_Ehdr *ehdr __attribute__ ((unused)),
                             Elf_Scn *scn __attribute__ ((unused)),
                             GElf_Shdr *shdr, Dwarf *dbg)
{
  Dwarf_Aranges *aranges;
  size_t cnt;
  if (dwarf_getaranges (dbg, &aranges, &cnt) != 0)
    {
      error (0, 0, dcgettext (((void *)0), "cannot get .debug_aranges content: %s", __LC_MESSAGES),
             dwarf_errmsg (-1));
      return;
    }

  GElf_Shdr glink_mem;
  GElf_Shdr *glink;
  glink = gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link), &glink_mem);
  if (glink == ((void *)0))
    {
      error (0, 0, dcgettext (((void *)0), "invalid sh_link value in section %Zu", __LC_MESSAGES),
             elf_ndxscn (scn));
      return;
    }

  printf (dcngettext (((void *)0), "\nDWARF section '%s' at offset %#" "ll" "x" " contains %zu entry:\n", "\nDWARF section '%s' at offset %#" "ll" "x" " contains %zu entries:\n", cnt, __LC_MESSAGES),




          ".debug_aranges", (uint64_t) shdr->sh_offset, cnt);


  size_t tmp = cnt;
  int digits = 1;
  while (tmp >= 16)
    {
      ++digits;
      tmp >>= 4;
    }

  for (size_t n = 0; n < cnt; ++n)
    {
      Dwarf_Arange *runp = dwarf_onearange (aranges, n);
      if (runp == ((void *)0))
        {
          printf ("cannot get arange %zu: %s\n", n, dwarf_errmsg (-1));
          return;
        }

      Dwarf_Addr start;
      Dwarf_Word length;
      Dwarf_Off offset;

      if (dwarf_getarangeinfo (runp, &start, &length, &offset) != 0)
        printf (dcgettext (((void *)0), " [%*zu] ???\n", __LC_MESSAGES), digits, n);
      else
        printf (dcgettext (((void *)0), " [%*zu] start: %0#*" "ll" "x" ", length: %5" "ll" "u" ", CU DIE offset: %6" "ll" "d" "\n", __LC_MESSAGES),


                digits, n, ehdr->e_ident[4] == 1 ? 10 : 18,
                (uint64_t) start, (uint64_t) length, (int64_t) offset);
    }
}


static void
print_debug_ranges_section (Ebl *ebl __attribute__ ((unused)),
                            GElf_Ehdr *ehdr, Elf_Scn *scn, GElf_Shdr *shdr,
                            Dwarf *dbg)
{
  Elf_Data *data = elf_rawdata (scn, ((void *)0));

  if (data == ((void *)0))
    {
      error (0, 0, dcgettext (((void *)0), "cannot get .debug_ranges content: %s", __LC_MESSAGES),
             elf_errmsg (-1));
      return;
    }

  printf (dcgettext (((void *)0), "\nDWARF section '%s' at offset %#" "ll" "x" ":\n", __LC_MESSAGES),

          ".debug_ranges", (uint64_t) shdr->sh_offset);

  size_t address_size = ehdr->e_ident[4] == 1 ? 4 : 8;

  _Bool first = 1;
  unsigned char *readp = data->d_buf;
  while (readp < (unsigned char *) data->d_buf + data->d_size)
    {
      ptrdiff_t offset = readp - (unsigned char *) data->d_buf;

      if (data->d_size - offset < address_size * 2)
        {
          printf (" [%6tx]  <INVALID DATA>\n", offset);
          break;
        }

      Dwarf_Addr begin;
      Dwarf_Addr end;
      if (address_size == 8)
        {
          begin = ({ uint64_t t_ = (__builtin_expect ((dbg)->other_byte_order, 0) ? (__extension__ ({ union { __extension__ unsigned long long int __ll; unsigned long int __l[2]; } __w, __r; if (__builtin_constant_p (*((const uint64_t *) (readp)))) __r.__ll = ((((*((const uint64_t *) (readp))) & 0xff00000000000000ull) >> 56) | (((*((const uint64_t *) (readp))) & 0x00ff000000000000ull) >> 40) | (((*((const uint64_t *) (readp))) & 0x0000ff0000000000ull) >> 24) | (((*((const uint64_t *) (readp))) & 0x000000ff00000000ull) >> 8) | (((*((const uint64_t *) (readp))) & 0x00000000ff000000ull) << 8) | (((*((const uint64_t *) (readp))) & 0x0000000000ff0000ull) << 24) | (((*((const uint64_t *) (readp))) & 0x000000000000ff00ull) << 40) | (((*((const uint64_t *) (readp))) & 0x00000000000000ffull) << 56)); else { __w.__ll = (*((const uint64_t *) (readp))); __r.__l[0] = (__extension__ ({ register unsigned int __v, __x = (__w.__l[1]); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })); __r.__l[1] = (__extension__ ({ register unsigned int __v, __x = (__w.__l[0]); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })); } __r.__ll; })) : *((const uint64_t *) (readp))); readp = (__typeof (readp)) (((uintptr_t) (readp)) + 8); t_; });
          end = ({ uint64_t t_ = (__builtin_expect ((dbg)->other_byte_order, 0) ? (__extension__ ({ union { __extension__ unsigned long long int __ll; unsigned long int __l[2]; } __w, __r; if (__builtin_constant_p (*((const uint64_t *) (readp)))) __r.__ll = ((((*((const uint64_t *) (readp))) & 0xff00000000000000ull) >> 56) | (((*((const uint64_t *) (readp))) & 0x00ff000000000000ull) >> 40) | (((*((const uint64_t *) (readp))) & 0x0000ff0000000000ull) >> 24) | (((*((const uint64_t *) (readp))) & 0x000000ff00000000ull) >> 8) | (((*((const uint64_t *) (readp))) & 0x00000000ff000000ull) << 8) | (((*((const uint64_t *) (readp))) & 0x0000000000ff0000ull) << 24) | (((*((const uint64_t *) (readp))) & 0x000000000000ff00ull) << 40) | (((*((const uint64_t *) (readp))) & 0x00000000000000ffull) << 56)); else { __w.__ll = (*((const uint64_t *) (readp))); __r.__l[0] = (__extension__ ({ register unsigned int __v, __x = (__w.__l[1]); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })); __r.__l[1] = (__extension__ ({ register unsigned int __v, __x = (__w.__l[0]); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })); } __r.__ll; })) : *((const uint64_t *) (readp))); readp = (__typeof (readp)) (((uintptr_t) (readp)) + 8); t_; });
        }
      else
        {
          begin = ({ uint32_t t_ = (__builtin_expect ((dbg)->other_byte_order, 0) ? (__extension__ ({ register unsigned int __v, __x = (*((const uint32_t *) (readp))); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })) : *((const uint32_t *) (readp))); readp = (__typeof (readp)) (((uintptr_t) (readp)) + 4); t_; });
          end = ({ uint32_t t_ = (__builtin_expect ((dbg)->other_byte_order, 0) ? (__extension__ ({ register unsigned int __v, __x = (*((const uint32_t *) (readp))); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })) : *((const uint32_t *) (readp))); readp = (__typeof (readp)) (((uintptr_t) (readp)) + 4); t_; });
          if (begin == (Dwarf_Addr) (uint32_t) -1)
            begin = (Dwarf_Addr) -1l;
        }

      if (begin == (Dwarf_Addr) -1l)
        printf (" [%6tx]  base address %#0*" "ll" "x" "\n", offset,
                2 + (int) (address_size * 2), (uintmax_t) end);
      else if (begin == 0 && end == 0)
        first = 1;
      else
        {

          if (first)
            printf (" [%6tx]  %#0*" "ll" "x" "..%#0*" "ll" "x" "\n", offset,
                    2 + (int) (address_size * 2), (uintmax_t) begin,
                    2 + (int) (address_size * 2), (uintmax_t) end);
          else
            printf ("           %#0*" "ll" "x" "..%#0*" "ll" "x" "\n",
                    2 + (int) (address_size * 2), (uintmax_t) begin,
                    2 + (int) (address_size * 2), (uintmax_t) end);

          first = 0;
        }
    }
}


static void
print_debug_frame_section (Ebl *ebl __attribute__ ((unused)),
                           GElf_Ehdr *ehdr __attribute__ ((unused)),
                           Elf_Scn *scn __attribute__ ((unused)),
                           GElf_Shdr *shdr __attribute__ ((unused)),
                           Dwarf *dbg __attribute__ ((unused)))
{
}


struct attrcb_args
{
  Dwarf *dbg;
  int level;
  unsigned int addrsize;
  Dwarf_Off cu_offset;
};


static int
attr_callback (Dwarf_Attribute *attrp, void *arg)
{
  struct attrcb_args *cbargs = (struct attrcb_args *) arg;
  const int level = cbargs->level;

  unsigned int attr = dwarf_whatattr (attrp);
  if (__builtin_expect (attr == 0, 0))
    {
      error (0, 0, dcgettext (((void *)0), "cannot get attribute code: %s", __LC_MESSAGES),
             dwarf_errmsg (-1));
      return DWARF_CB_ABORT;
    }

  unsigned int form = dwarf_whatform (attrp);
  if (__builtin_expect (form == 0, 0))
    {
      error (0, 0, dcgettext (((void *)0), "cannot get attribute form: %s", __LC_MESSAGES),
             dwarf_errmsg (-1));
      return DWARF_CB_ABORT;
    }

  switch (form)
    {
    case DW_FORM_addr:;
      Dwarf_Addr addr;
      if (__builtin_expect (dwarf_formaddr (attrp, &addr) != 0, 0))
        {
        attrval_out:
          error (0, 0, dcgettext (((void *)0), "cannot get attribute value: %s", __LC_MESSAGES),
                 dwarf_errmsg (-1));
          return DWARF_CB_ABORT;
        }
      printf ("           %*s%-20s %#0*" "ll" "x" "\n",
              (int) (level * 2), "", dwarf_attr_string (attr),
              2 + (int) (cbargs->addrsize * 2), (uintmax_t) addr);
      break;

    case DW_FORM_indirect:
    case DW_FORM_strp:
    case DW_FORM_string:;
      const char *str = dwarf_formstring (attrp);
      if (__builtin_expect (str == ((void *)0), 0))
        goto attrval_out;
      printf ("           %*s%-20s \"%s\"\n",
              (int) (level * 2), "", dwarf_attr_string (attr), str);
      break;

    case DW_FORM_ref_addr:
    case DW_FORM_ref_udata:
    case DW_FORM_ref8:
    case DW_FORM_ref4:
    case DW_FORM_ref2:
    case DW_FORM_ref1:;
      Dwarf_Off ref;
      if (__builtin_expect (dwarf_formref (attrp, &ref) != 0, 0))
        goto attrval_out;

      printf ("           %*s%-20s [%6" "ll" "x" "]\n",
              (int) (level * 2), "", dwarf_attr_string (attr),
              (uintmax_t) (ref + cbargs->cu_offset));
      break;

    case DW_FORM_udata:
    case DW_FORM_sdata:
    case DW_FORM_data8:
    case DW_FORM_data4:
    case DW_FORM_data2:
    case DW_FORM_data1:;
      Dwarf_Word num;
      if (__builtin_expect (dwarf_formudata (attrp, &num) != 0, 0))
        goto attrval_out;

      const char *valuestr = ((void *)0);
      switch (attr)
        {
        case DW_AT_location:
        case DW_AT_data_member_location:
        case DW_AT_vtable_elem_location:
        case DW_AT_string_length:
        case DW_AT_use_location:
        case DW_AT_frame_base:
        case DW_AT_return_addr:
        case DW_AT_static_link:
          printf ("           %*s%-20s location list [%6" "ll" "x" "]\n",
                  (int) (level * 2), "", dwarf_attr_string (attr),
                  (uintmax_t) num);
          return DWARF_CB_OK;

        case DW_AT_ranges:
          printf ("           %*s%-20s range list [%6" "ll" "x" "]\n",
                  (int) (level * 2), "", dwarf_attr_string (attr),
                  (uintmax_t) num);
          return DWARF_CB_OK;

        case DW_AT_language:
          valuestr = dwarf_lang_string (num);
          break;
        case DW_AT_encoding:
          valuestr = dwarf_encoding_string (num);
          break;
        case DW_AT_accessibility:
          valuestr = dwarf_access_string (num);
          break;
        case DW_AT_visibility:
          valuestr = dwarf_visibility_string (num);
          break;
        case DW_AT_virtuality:
          valuestr = dwarf_virtuality_string (num);
          break;
        case DW_AT_identifier_case:
          valuestr = dwarf_identifier_case_string (num);
          break;
        case DW_AT_calling_convention:
          valuestr = dwarf_calling_convention_string (num);
          break;
        case DW_AT_inline:
          valuestr = dwarf_inline_string (num);
          break;
        case DW_AT_ordering:
          valuestr = dwarf_ordering_string (num);
          break;
        case DW_AT_discr_list:
          valuestr = dwarf_discr_list_string (num);
          break;
        default:

          break;
        }

      if (valuestr == ((void *)0))
        printf ("           %*s%-20s %" "ll" "u" "\n",
                (int) (level * 2), "", dwarf_attr_string (attr),
                (uintmax_t) num);
      else
        printf ("           %*s%-20s %s (%" "ll" "u" ")\n",
                (int) (level * 2), "", dwarf_attr_string (attr),
                valuestr, (uintmax_t) num);
      break;

    case DW_FORM_flag:;
      _Bool flag;
      if (__builtin_expect (dwarf_formflag (attrp, &flag) != 0, 0))
        goto attrval_out;

      printf ("           %*s%-20s %s\n",
              (int) (level * 2), "", dwarf_attr_string (attr),
              nl_langinfo (flag ? __YESSTR : __NOSTR));
      break;

    case DW_FORM_block4:
    case DW_FORM_block2:
    case DW_FORM_block1:
    case DW_FORM_block:;
      Dwarf_Block block;
      if (__builtin_expect (dwarf_formblock (attrp, &block) != 0, 0))
        goto attrval_out;

      printf ("           %*s%-20s %" "ll" "x" " byte block\n",
              (int) (level * 2), "", dwarf_attr_string (attr),
              (uintmax_t) block.length);

      switch (attr)
        {
        case DW_AT_location:
        case DW_AT_data_member_location:
        case DW_AT_vtable_elem_location:
        case DW_AT_string_length:
        case DW_AT_use_location:
        case DW_AT_frame_base:
        case DW_AT_return_addr:
        case DW_AT_static_link:
          print_ops (cbargs->dbg, 12 + level * 2, 12 + level * 2,
                     cbargs->addrsize, block.length, block.data);
          break;
        }
      break;

    default:
      printf ("           %*s%-20s [form: %d] ???\n",
              (int) (level * 2), "", dwarf_attr_string (attr),
              (int) form);
      break;
    }

  return DWARF_CB_OK;
}


static void
print_debug_info_section (Ebl *ebl __attribute__ ((unused)),
                          GElf_Ehdr *ehdr __attribute__ ((unused)),
                          Elf_Scn *scn __attribute__ ((unused)),
                          GElf_Shdr *shdr, Dwarf *dbg)
{
  printf (dcgettext (((void *)0), "\nDWARF section '%s' at offset %#" "ll" "x" ":\n [Offset]\n", __LC_MESSAGES),

          ".debug_info", (uint64_t) shdr->sh_offset);


  if (shdr->sh_size == 0)
    return;

  int maxdies = 20;
  Dwarf_Die *dies = (Dwarf_Die *) xmalloc (maxdies * sizeof (Dwarf_Die));

  Dwarf_Off offset = 0;


  size_t cuhl;

  Dwarf_Off abbroffset;
  uint8_t addrsize;
  uint8_t offsize;
  Dwarf_Off nextcu;
 next_cu:
  if (dwarf_nextcu (dbg, offset, &nextcu, &cuhl, &abbroffset, &addrsize,
                    &offsize) != 0)
    goto do_return;

  printf (dcgettext (((void *)0), " Compilation unit at offset %" "ll" "u" ":\n" " Version: %" "u" ", Abbreviation section offset: %" "ll" "u" ", Address size: %" "u" ", Offset size: %" "u" "\n", __LC_MESSAGES),


          (uint64_t) offset, 2, abbroffset, addrsize, offsize);


  struct attrcb_args args;
  args.dbg = dbg;
  args.addrsize = addrsize;
  args.cu_offset = offset;

  offset += cuhl;

  int level = 0;

  if (__builtin_expect (dwarf_offdie (dbg, offset, &dies[level]) == ((void *)0), 0))
    {
      error (0, 0, dcgettext (((void *)0), "cannot get DIE at offset %" "ll" "u" " in section '%s': %s", __LC_MESSAGES),

             (uint64_t) offset, ".debug_info", dwarf_errmsg (-1));
      goto do_return;
    }

  do
    {
      offset = dwarf_dieoffset (&dies[level]);
      if (offset == ~0ul)
        {
          error (0, 0, dcgettext (((void *)0), "cannot get DIE offset: %s", __LC_MESSAGES),
                 dwarf_errmsg (-1));
          goto do_return;
        }

      int tag = dwarf_tag (&dies[level]);
      if (tag == DW_TAG_invalid)
        {
          error (0, 0, dcgettext (((void *)0), "cannot get tag of DIE at offset %" "ll" "u" " in section '%s': %s", __LC_MESSAGES),

                 (uint64_t) offset, ".debug_info", dwarf_errmsg (-1));
          goto do_return;
        }


      const char *tagstr = dwarf_tag_string (tag);
# 3983 "readelf.c"
      printf (" [%6" "ll" "x" "]  %*s%s\n",
              (uint64_t) offset, (int) (level * 2), "", tagstr);


      args.level = level;
      (void) dwarf_getattrs (&dies[level], attr_callback, &args, 0);


      if (level + 1 == maxdies)
        dies = (Dwarf_Die *) xrealloc (dies,
                                       (maxdies += 10)
                                       * sizeof (Dwarf_Die));

      int res = dwarf_child (&dies[level], &dies[level + 1]);
      if (res > 0)
        {
          while ((res = dwarf_siblingof (&dies[level], &dies[level])) == 1)
            if (level-- == 0)
              break;

          if (res == -1)
            {
              error (0, 0, dcgettext (((void *)0), "cannot get next DIE: %s\n", __LC_MESSAGES),
                     dwarf_errmsg (-1));
              goto do_return;
            }
        }
      else if (__builtin_expect (res < 0, 0))
        {
          error (0, 0, dcgettext (((void *)0), "cannot get next DIE: %s", __LC_MESSAGES),
                 dwarf_errmsg (-1));
          goto do_return;
        }
      else
        ++level;
    }
  while (level >= 0);

  offset = nextcu;
  if (offset != 0)
     goto next_cu;

 do_return:
  free (dies);
}


static void
print_debug_line_section (Ebl *ebl, GElf_Ehdr *ehdr __attribute__ ((unused)),
                          Elf_Scn *scn, GElf_Shdr *shdr, Dwarf *dbg)
{
  printf (dcgettext (((void *)0), "\nDWARF section '%s' at offset %#" "ll" "x" ":\n", __LC_MESSAGES),

          ".debug_line", (uint64_t) shdr->sh_offset);

  if (shdr->sh_size == 0)
    return;



  Elf_Data *data = elf_getdata (scn, ((void *)0));
  if (data == ((void *)0) || data->d_buf == ((void *)0))
    {
      error (0, 0, dcgettext (((void *)0), "cannot get line data section data: %s", __LC_MESSAGES),
             elf_errmsg (-1));
      return;
    }

  const unsigned char *linep = (const unsigned char *) data->d_buf;
  const unsigned char *lineendp;

  while (linep
         < (lineendp = (const unsigned char *) data->d_buf + data->d_size))
    {
      size_t start_offset = linep - (const unsigned char *) data->d_buf;

      printf (dcgettext (((void *)0), "\nTable at offset %Zu:\n", __LC_MESSAGES), start_offset);

      Dwarf_Word unit_length = ({ uint32_t t_ = (__builtin_expect ((dbg)->other_byte_order, 0) ? (__extension__ ({ register unsigned int __v, __x = (*((const uint32_t *) (linep))); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })) : *((const uint32_t *) (linep))); linep = (__typeof (linep)) (((uintptr_t) (linep)) + 4); t_; });
      unsigned int length = 4;
      if (__builtin_expect (unit_length == 0xffffffff, 0))
        {
          if (__builtin_expect (linep + 8 > lineendp, 0))
            {
            invalid_data:
              error (0, 0, dcgettext (((void *)0), "invalid data in section [%zu] '%s'", __LC_MESSAGES),
                     elf_ndxscn (scn), ".debug_line");
              return;
            }
          unit_length = ({ uint64_t t_ = (__builtin_expect ((dbg)->other_byte_order, 0) ? (__extension__ ({ union { __extension__ unsigned long long int __ll; unsigned long int __l[2]; } __w, __r; if (__builtin_constant_p (*((const uint64_t *) (linep)))) __r.__ll = ((((*((const uint64_t *) (linep))) & 0xff00000000000000ull) >> 56) | (((*((const uint64_t *) (linep))) & 0x00ff000000000000ull) >> 40) | (((*((const uint64_t *) (linep))) & 0x0000ff0000000000ull) >> 24) | (((*((const uint64_t *) (linep))) & 0x000000ff00000000ull) >> 8) | (((*((const uint64_t *) (linep))) & 0x00000000ff000000ull) << 8) | (((*((const uint64_t *) (linep))) & 0x0000000000ff0000ull) << 24) | (((*((const uint64_t *) (linep))) & 0x000000000000ff00ull) << 40) | (((*((const uint64_t *) (linep))) & 0x00000000000000ffull) << 56)); else { __w.__ll = (*((const uint64_t *) (linep))); __r.__l[0] = (__extension__ ({ register unsigned int __v, __x = (__w.__l[1]); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })); __r.__l[1] = (__extension__ ({ register unsigned int __v, __x = (__w.__l[0]); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })); } __r.__ll; })) : *((const uint64_t *) (linep))); linep = (__typeof (linep)) (((uintptr_t) (linep)) + 8); t_; });
          length = 8;
        }


      if (unit_length < 2 + length + 5 * 1
          || __builtin_expect (linep + unit_length > lineendp, 0))
        goto invalid_data;
      lineendp = linep + unit_length;


      uint_fast16_t version = ({ uint16_t t_ = (__builtin_expect ((dbg)->other_byte_order, 0) ? (__extension__ ({ register unsigned short int __v, __x = (*((const uint16_t *) (linep))); if (__builtin_constant_p (__x)) __v = ((((__x) >> 8) & 0xff) | (((__x) & 0xff) << 8)); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })) : *((const uint16_t *) (linep))); linep = (__typeof (linep)) (((uintptr_t) (linep)) + 2); t_; });


      Dwarf_Word header_length;
      if (length == 4)
        header_length = ({ uint32_t t_ = (__builtin_expect ((dbg)->other_byte_order, 0) ? (__extension__ ({ register unsigned int __v, __x = (*((const uint32_t *) (linep))); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })) : *((const uint32_t *) (linep))); linep = (__typeof (linep)) (((uintptr_t) (linep)) + 4); t_; });
      else
        header_length = ({ uint64_t t_ = (__builtin_expect ((dbg)->other_byte_order, 0) ? (__extension__ ({ union { __extension__ unsigned long long int __ll; unsigned long int __l[2]; } __w, __r; if (__builtin_constant_p (*((const uint64_t *) (linep)))) __r.__ll = ((((*((const uint64_t *) (linep))) & 0xff00000000000000ull) >> 56) | (((*((const uint64_t *) (linep))) & 0x00ff000000000000ull) >> 40) | (((*((const uint64_t *) (linep))) & 0x0000ff0000000000ull) >> 24) | (((*((const uint64_t *) (linep))) & 0x000000ff00000000ull) >> 8) | (((*((const uint64_t *) (linep))) & 0x00000000ff000000ull) << 8) | (((*((const uint64_t *) (linep))) & 0x0000000000ff0000ull) << 24) | (((*((const uint64_t *) (linep))) & 0x000000000000ff00ull) << 40) | (((*((const uint64_t *) (linep))) & 0x00000000000000ffull) << 56)); else { __w.__ll = (*((const uint64_t *) (linep))); __r.__l[0] = (__extension__ ({ register unsigned int __v, __x = (__w.__l[1]); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })); __r.__l[1] = (__extension__ ({ register unsigned int __v, __x = (__w.__l[0]); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })); } __r.__ll; })) : *((const uint64_t *) (linep))); linep = (__typeof (linep)) (((uintptr_t) (linep)) + 8); t_; });



      uint_fast8_t minimum_instr_len = *linep++;



      uint_fast8_t default_is_stmt = *linep++;


      int_fast8_t line_base = *((const int_fast8_t *) linep);
      ++linep;


      uint_fast8_t line_range = *linep++;


      uint_fast8_t opcode_base = *linep++;


      printf (dcgettext (((void *)0), "\n" " Length:                     %" "ll" "u" "\n" " DWARF version:              %" "u" "\n" " Prologue length:            %" "ll" "u" "\n" " Minimum instruction length: %" "u" "\n" " Initial value if '%s': %" "u" "\n" " Line base:                  %" "d" "\n" " Line range:                 %" "u" "\n" " Opcode base:                %" "u" "\n" "\n" "Opcodes:\n", __LC_MESSAGES),
# 4122 "readelf.c"
              (uint64_t) unit_length, version, (uint64_t) header_length,
              minimum_instr_len, "is_stmt", default_is_stmt, line_base,
              line_range, opcode_base);

      if (__builtin_expect (linep + opcode_base - 1 >= lineendp, 0))
        goto invalid_data;
      int opcode_base_l10 = 1;
      unsigned int tmp = opcode_base;
      while (tmp > 10)
        {
          tmp /= 10;
          ++opcode_base_l10;
        }
      const uint8_t *standard_opcode_lengths = linep - 1;
      for (uint_fast8_t cnt = 1; cnt < opcode_base; ++cnt)
        printf (dcngettext (((void *)0), "  [%*" "u" "]  %hhu argument\n", "  [%*" "u" "]  %hhu arguments\n", (int) linep[cnt - 1], __LC_MESSAGES),


                opcode_base_l10, cnt, linep[cnt - 1]);
      linep += opcode_base - 1;
      if (__builtin_expect (linep >= lineendp, 0))
        goto invalid_data;

      puts (dcgettext (((void *)0), "\nDirectory table:", __LC_MESSAGES));
      while (*linep != 0)
        {
          unsigned char *endp = memchr (linep, '\0', lineendp - linep);
          if (endp == ((void *)0))
            goto invalid_data;

          printf (" %s\n", (char *) linep);

          linep = endp + 1;
        }

      ++linep;

      if (__builtin_expect (linep >= lineendp, 0))
        goto invalid_data;
      puts (dcgettext (((void *)0), "\nFile name table:\n" " Entry Dir   Time      Size      Name", __LC_MESSAGES));

      for (unsigned int cnt = 1; *linep != 0; ++cnt)
        {

          char *fname = (char *) linep;
          unsigned char *endp = memchr (fname, '\0', lineendp - linep);
          if (endp == ((void *)0))
            goto invalid_data;
          linep = endp + 1;


          unsigned int diridx;
          do { unsigned char __b; diridx = 0; __b = *(linep)++; diridx |= (uintmax_t) (__b & 0x7f) << (0 * 7); if (__builtin_expect ((__b & 0x80) == 0, 1)) break; diridx = __libdw_get_uleb128 (diridx, 1, &(linep)); } while (0);


          unsigned int mtime;
          do { unsigned char __b; mtime = 0; __b = *(linep)++; mtime |= (uintmax_t) (__b & 0x7f) << (0 * 7); if (__builtin_expect ((__b & 0x80) == 0, 1)) break; mtime = __libdw_get_uleb128 (mtime, 1, &(linep)); } while (0);


          unsigned int fsize;
          do { unsigned char __b; fsize = 0; __b = *(linep)++; fsize |= (uintmax_t) (__b & 0x7f) << (0 * 7); if (__builtin_expect ((__b & 0x80) == 0, 1)) break; fsize = __libdw_get_uleb128 (fsize, 1, &(linep)); } while (0);

          printf (" %-5u %-5u %-9u %-9u %s\n",
                  cnt, diridx, mtime, fsize, fname);
        }

      ++linep;

      puts (dcgettext (((void *)0), "\nLine number statements:", __LC_MESSAGES));
      Dwarf_Word address = 0;
      size_t line = 1;
      uint_fast8_t is_stmt = default_is_stmt;


      size_t address_size
        = elf_getident (ebl->elf, ((void *)0))[4] == 1 ? 4 : 8;


      Dwarf_Off cuoffset;
      Dwarf_Off ncuoffset = 0;
      size_t hsize;
      while (dwarf_nextcu (dbg, cuoffset = ncuoffset, &ncuoffset, &hsize,
                           ((void *)0), ((void *)0), ((void *)0)) == 0)
        {
          Dwarf_Die cudie;
          if (dwarf_offdie (dbg, cuoffset + hsize, &cudie) == ((void *)0))
            continue;
          Dwarf_Attribute stmt_list;
          if (dwarf_attr (&cudie, DW_AT_stmt_list, &stmt_list) == ((void *)0))
            continue;
          Dwarf_Word lineoff;
          if (dwarf_formudata (&stmt_list, &lineoff) != 0)
            continue;
          if (lineoff == start_offset)
            {

              address_size = cudie.cu->address_size;
              break;
            }
        }

      while (linep < lineendp)
        {
          unsigned int u128;
          int s128;


          unsigned int opcode = *linep++;


          if (__builtin_expect (opcode >= opcode_base, 1))
            {






              int line_increment = (line_base
                                    + (opcode - opcode_base) % line_range);
              unsigned int address_increment = (minimum_instr_len
                                                * ((opcode - opcode_base)
                                                   / line_range));


              line += line_increment;
              address += address_increment;

              printf (dcgettext (((void *)0), " special opcode %u: address+%u = %#" "ll" "x" ", line%+d = %zu\n", __LC_MESSAGES),

                      opcode, address_increment, (uint64_t) address,
                      line_increment, line);
            }
          else if (opcode == 0)
            {

              if (__builtin_expect (linep + 2 > lineendp, 0))
                goto invalid_data;


              unsigned int len = *linep++;

              if (__builtin_expect (linep + len > lineendp, 0))
                goto invalid_data;


              opcode = *linep++;

              printf (dcgettext (((void *)0), " extended opcode %u: ", __LC_MESSAGES), opcode);

              switch (opcode)
                {
                case DW_LNE_end_sequence:
                  puts (dcgettext (((void *)0), "end of sequence", __LC_MESSAGES));


                  address = 0;
                  line = 1;
                  is_stmt = default_is_stmt;
                  break;

                case DW_LNE_set_address:
                  if (address_size == 4)
                    address = ({ uint32_t t_ = (__builtin_expect ((dbg)->other_byte_order, 0) ? (__extension__ ({ register unsigned int __v, __x = (*((const uint32_t *) (linep))); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })) : *((const uint32_t *) (linep))); linep = (__typeof (linep)) (((uintptr_t) (linep)) + 4); t_; });
                  else
                    address = ({ uint64_t t_ = (__builtin_expect ((dbg)->other_byte_order, 0) ? (__extension__ ({ union { __extension__ unsigned long long int __ll; unsigned long int __l[2]; } __w, __r; if (__builtin_constant_p (*((const uint64_t *) (linep)))) __r.__ll = ((((*((const uint64_t *) (linep))) & 0xff00000000000000ull) >> 56) | (((*((const uint64_t *) (linep))) & 0x00ff000000000000ull) >> 40) | (((*((const uint64_t *) (linep))) & 0x0000ff0000000000ull) >> 24) | (((*((const uint64_t *) (linep))) & 0x000000ff00000000ull) >> 8) | (((*((const uint64_t *) (linep))) & 0x00000000ff000000ull) << 8) | (((*((const uint64_t *) (linep))) & 0x0000000000ff0000ull) << 24) | (((*((const uint64_t *) (linep))) & 0x000000000000ff00ull) << 40) | (((*((const uint64_t *) (linep))) & 0x00000000000000ffull) << 56)); else { __w.__ll = (*((const uint64_t *) (linep))); __r.__l[0] = (__extension__ ({ register unsigned int __v, __x = (__w.__l[1]); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })); __r.__l[1] = (__extension__ ({ register unsigned int __v, __x = (__w.__l[0]); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })); } __r.__ll; })) : *((const uint64_t *) (linep))); linep = (__typeof (linep)) (((uintptr_t) (linep)) + 8); t_; });
                  printf (dcgettext (((void *)0), "set address to %#" "ll" "x" "\n", __LC_MESSAGES),
                          (uint64_t) address);
                  break;

                case DW_LNE_define_file:
                  {
                    char *fname = (char *) linep;
                    unsigned char *endp = memchr (linep, '\0',
                                                  lineendp - linep);
                    if (endp == ((void *)0))
                      goto invalid_data;
                    linep = endp + 1;

                    unsigned int diridx;
                    do { unsigned char __b; diridx = 0; __b = *(linep)++; diridx |= (uintmax_t) (__b & 0x7f) << (0 * 7); if (__builtin_expect ((__b & 0x80) == 0, 1)) break; diridx = __libdw_get_uleb128 (diridx, 1, &(linep)); } while (0);
                    Dwarf_Word mtime;
                    do { unsigned char __b; mtime = 0; __b = *(linep)++; mtime |= (uintmax_t) (__b & 0x7f) << (0 * 7); if (__builtin_expect ((__b & 0x80) == 0, 1)) break; mtime = __libdw_get_uleb128 (mtime, 1, &(linep)); } while (0);
                    Dwarf_Word filelength;
                    do { unsigned char __b; filelength = 0; __b = *(linep)++; filelength |= (uintmax_t) (__b & 0x7f) << (0 * 7); if (__builtin_expect ((__b & 0x80) == 0, 1)) break; filelength = __libdw_get_uleb128 (filelength, 1, &(linep)); } while (0);

                    printf (dcgettext (((void *)0), "define new file: dir=%u, mtime=%" "ll" "u" ", length=%" "ll" "u" ", name=%s\n", __LC_MESSAGES),

                            diridx, (uint64_t) mtime, (uint64_t) filelength,
                            fname);
                  }
                  break;

                default:

                  puts (dcgettext (((void *)0), "unknown opcode", __LC_MESSAGES));
                  linep += len - 1;
                  break;
                }
            }
          else if (opcode <= DW_LNS_set_epilogue_begin)
            {

              switch (opcode)
                {
                case DW_LNS_copy:

                  puts (dcgettext (((void *)0), " copy", __LC_MESSAGES));
                  break;

                case DW_LNS_advance_pc:


                  do { unsigned char __b; u128 = 0; __b = *(linep)++; u128 |= (uintmax_t) (__b & 0x7f) << (0 * 7); if (__builtin_expect ((__b & 0x80) == 0, 1)) break; u128 = __libdw_get_uleb128 (u128, 1, &(linep)); } while (0);
                  address += minimum_instr_len * u128;
                  printf (dcgettext (((void *)0), " advance address by %u to %#" "ll" "x" "\n", __LC_MESSAGES),

                          u128, (uint64_t) address);
                  break;

                case DW_LNS_advance_line:


                  do { unsigned char __b; int64_t _v = 0; __b = *(linep)++; _v |= (uint64_t) (__b & 0x7f) << (0 * 7); if (__builtin_expect ((__b & 0x80) == 0, 1)) { s128 = (_v << (64 - (0 * 7) - 7) >> (64 - (0 * 7) - 7)); break; } else do {} while (0); s128 = __libdw_get_sleb128 (_v, 1, &(linep)); } while (0);
                  line += s128;
                  printf (dcgettext (((void *)0), " advance line by constant %d to %" "ll" "d" "\n", __LC_MESSAGES),

                          s128, (int64_t) line);
                  break;

                case DW_LNS_set_file:

                  do { unsigned char __b; u128 = 0; __b = *(linep)++; u128 |= (uintmax_t) (__b & 0x7f) << (0 * 7); if (__builtin_expect ((__b & 0x80) == 0, 1)) break; u128 = __libdw_get_uleb128 (u128, 1, &(linep)); } while (0);
                  printf (dcgettext (((void *)0), " set file to %" "ll" "u" "\n", __LC_MESSAGES),
                          (uint64_t) u128);
                  break;

                case DW_LNS_set_column:

                  if (__builtin_expect (standard_opcode_lengths[opcode] != 1, 0))
                    goto invalid_data;

                  do { unsigned char __b; u128 = 0; __b = *(linep)++; u128 |= (uintmax_t) (__b & 0x7f) << (0 * 7); if (__builtin_expect ((__b & 0x80) == 0, 1)) break; u128 = __libdw_get_uleb128 (u128, 1, &(linep)); } while (0);
                  printf (dcgettext (((void *)0), " set column to %" "ll" "u" "\n", __LC_MESSAGES),
                          (uint64_t) u128);
                  break;

                case DW_LNS_negate_stmt:

                  is_stmt = 1 - is_stmt;
                  printf (dcgettext (((void *)0), " set '%s' to %" "u" "\n", __LC_MESSAGES),
                          "is_stmt", is_stmt);
                  break;

                case DW_LNS_set_basic_block:

                  puts (dcgettext (((void *)0), " set basic block flag", __LC_MESSAGES));
                  break;

                case DW_LNS_const_add_pc:

                  u128 = (minimum_instr_len
                          * ((255 - opcode_base) / line_range));
                  address += u128;
                  printf (dcgettext (((void *)0), " advance address by constant %u to %#" "ll" "x" "\n", __LC_MESSAGES),

                          u128, (uint64_t) address);
                  break;

                case DW_LNS_fixed_advance_pc:


                  if (__builtin_expect (standard_opcode_lengths[opcode] != 1, 0))
                    goto invalid_data;

                  u128 = ({ uint16_t t_ = (__builtin_expect ((dbg)->other_byte_order, 0) ? (__extension__ ({ register unsigned short int __v, __x = (*((const uint16_t *) (linep))); if (__builtin_constant_p (__x)) __v = ((((__x) >> 8) & 0xff) | (((__x) & 0xff) << 8)); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })) : *((const uint16_t *) (linep))); linep = (__typeof (linep)) (((uintptr_t) (linep)) + 2); t_; });
                  address += u128;
                  printf (dcgettext (((void *)0), " advance address by fixed value %u to %#" "ll" "x" "\n", __LC_MESSAGES),

                          u128, (uint64_t) address);
                  break;

                case DW_LNS_set_prologue_end:

                  puts (dcgettext (((void *)0), " set prologue end flag", __LC_MESSAGES));
                  break;

                case DW_LNS_set_epilogue_begin:

                  puts (dcgettext (((void *)0), " set epilogue begin flag", __LC_MESSAGES));
                  break;
                }
            }
          else
            {



              printf (dcngettext (((void *)0), " unknown opcode with %" "u" " parameter:", " unknown opcode with %" "u" " parameters:", standard_opcode_lengths[opcode], __LC_MESSAGES),


                      standard_opcode_lengths[opcode]);
              for (int n = standard_opcode_lengths[opcode]; n > 0; --n)
                {
                  do { unsigned char __b; u128 = 0; __b = *(linep)++; u128 |= (uintmax_t) (__b & 0x7f) << (0 * 7); if (__builtin_expect ((__b & 0x80) == 0, 1)) break; u128 = __libdw_get_uleb128 (u128, 1, &(linep)); } while (0);
                  if (n != standard_opcode_lengths[opcode])
                    putc_unlocked (',', stdout);
                  printf (" %u", u128);
                }


              continue;
            }
        }
    }


  ((void) ((elf_getdata (scn, data) == ((void *)0)) ? 0 : (__assert_fail ("elf_getdata (scn, data) == ((void *)0)", "readelf.c", 4439, __PRETTY_FUNCTION__), 0)));
}


static void
print_debug_loc_section (Ebl *ebl __attribute__ ((unused)),
                         GElf_Ehdr *ehdr __attribute__ ((unused)),
                         Elf_Scn *scn __attribute__ ((unused)),
                         GElf_Shdr *shdr,
                         Dwarf *dbg __attribute__ ((unused)))
{
  Elf_Data *data = elf_rawdata (scn, ((void *)0));

  if (data == ((void *)0))
    {
      error (0, 0, dcgettext (((void *)0), "cannot get .debug_loc content: %s", __LC_MESSAGES),
             elf_errmsg (-1));
      return;
    }

  printf (dcgettext (((void *)0), "\nDWARF section '%s' at offset %#" "ll" "x" ":\n", __LC_MESSAGES),

          ".debug_loc", (uint64_t) shdr->sh_offset);

  size_t address_size = ehdr->e_ident[4] == 1 ? 4 : 8;

  _Bool first = 1;
  unsigned char *readp = data->d_buf;
  while (readp < (unsigned char *) data->d_buf + data->d_size)
    {
      ptrdiff_t offset = readp - (unsigned char *) data->d_buf;

      if (data->d_size - offset < address_size * 2)
        {
          printf (" [%6tx]  <INVALID DATA>\n", offset);
          break;
        }

      Dwarf_Addr begin;
      Dwarf_Addr end;
      if (address_size == 8)
        {
          begin = ({ uint64_t t_ = (__builtin_expect ((dbg)->other_byte_order, 0) ? (__extension__ ({ union { __extension__ unsigned long long int __ll; unsigned long int __l[2]; } __w, __r; if (__builtin_constant_p (*((const uint64_t *) (readp)))) __r.__ll = ((((*((const uint64_t *) (readp))) & 0xff00000000000000ull) >> 56) | (((*((const uint64_t *) (readp))) & 0x00ff000000000000ull) >> 40) | (((*((const uint64_t *) (readp))) & 0x0000ff0000000000ull) >> 24) | (((*((const uint64_t *) (readp))) & 0x000000ff00000000ull) >> 8) | (((*((const uint64_t *) (readp))) & 0x00000000ff000000ull) << 8) | (((*((const uint64_t *) (readp))) & 0x0000000000ff0000ull) << 24) | (((*((const uint64_t *) (readp))) & 0x000000000000ff00ull) << 40) | (((*((const uint64_t *) (readp))) & 0x00000000000000ffull) << 56)); else { __w.__ll = (*((const uint64_t *) (readp))); __r.__l[0] = (__extension__ ({ register unsigned int __v, __x = (__w.__l[1]); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })); __r.__l[1] = (__extension__ ({ register unsigned int __v, __x = (__w.__l[0]); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })); } __r.__ll; })) : *((const uint64_t *) (readp))); readp = (__typeof (readp)) (((uintptr_t) (readp)) + 8); t_; });
          end = ({ uint64_t t_ = (__builtin_expect ((dbg)->other_byte_order, 0) ? (__extension__ ({ union { __extension__ unsigned long long int __ll; unsigned long int __l[2]; } __w, __r; if (__builtin_constant_p (*((const uint64_t *) (readp)))) __r.__ll = ((((*((const uint64_t *) (readp))) & 0xff00000000000000ull) >> 56) | (((*((const uint64_t *) (readp))) & 0x00ff000000000000ull) >> 40) | (((*((const uint64_t *) (readp))) & 0x0000ff0000000000ull) >> 24) | (((*((const uint64_t *) (readp))) & 0x000000ff00000000ull) >> 8) | (((*((const uint64_t *) (readp))) & 0x00000000ff000000ull) << 8) | (((*((const uint64_t *) (readp))) & 0x0000000000ff0000ull) << 24) | (((*((const uint64_t *) (readp))) & 0x000000000000ff00ull) << 40) | (((*((const uint64_t *) (readp))) & 0x00000000000000ffull) << 56)); else { __w.__ll = (*((const uint64_t *) (readp))); __r.__l[0] = (__extension__ ({ register unsigned int __v, __x = (__w.__l[1]); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })); __r.__l[1] = (__extension__ ({ register unsigned int __v, __x = (__w.__l[0]); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })); } __r.__ll; })) : *((const uint64_t *) (readp))); readp = (__typeof (readp)) (((uintptr_t) (readp)) + 8); t_; });
        }
      else
        {
          begin = ({ uint32_t t_ = (__builtin_expect ((dbg)->other_byte_order, 0) ? (__extension__ ({ register unsigned int __v, __x = (*((const uint32_t *) (readp))); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })) : *((const uint32_t *) (readp))); readp = (__typeof (readp)) (((uintptr_t) (readp)) + 4); t_; });
          end = ({ uint32_t t_ = (__builtin_expect ((dbg)->other_byte_order, 0) ? (__extension__ ({ register unsigned int __v, __x = (*((const uint32_t *) (readp))); if (__builtin_constant_p (__x)) __v = ((((__x) & 0xff000000) >> 24) | (((__x) & 0x00ff0000) >> 8) | (((__x) & 0x0000ff00) << 8) | (((__x) & 0x000000ff) << 24)); else __asm__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })) : *((const uint32_t *) (readp))); readp = (__typeof (readp)) (((uintptr_t) (readp)) + 4); t_; });
          if (begin == (Dwarf_Addr) (uint32_t) -1)
            begin = (Dwarf_Addr) -1l;
        }

      if (begin == (Dwarf_Addr) -1l)
        printf (" [%6tx]  base address %#0*" "ll" "x" "\n", offset,
                2 + (int) (address_size * 2), (uintmax_t) end);
      else if (begin == 0 && end == 0)
        first = 1;
      else
        {

          uint_fast16_t len = ({ uint16_t t_ = (__builtin_expect ((dbg)->other_byte_order, 0) ? (__extension__ ({ register unsigned short int __v, __x = (*((const uint16_t *) (readp))); if (__builtin_constant_p (__x)) __v = ((((__x) >> 8) & 0xff) | (((__x) & 0xff) << 8)); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; })) : *((const uint16_t *) (readp))); readp = (__typeof (readp)) (((uintptr_t) (readp)) + 2); t_; });

          if (first)
            printf (" [%6tx]  %#0*" "ll" "x" "..%#0*" "ll" "x",
                    offset,
                    2 + (int) (address_size * 2), (uintmax_t) begin,
                    2 + (int) (address_size * 2), (uintmax_t) end);
          else
            printf ("           %#0*" "ll" "x" "..%#0*" "ll" "x",
                    2 + (int) (address_size * 2), (uintmax_t) begin,
                    2 + (int) (address_size * 2), (uintmax_t) end);

          print_ops (dbg, 1, 18 + (address_size * 4),
                     address_size, len, readp);

          first = 0;
          readp += len;
        }
    }
}

struct mac_culist
{
  Dwarf_Die die;
  Dwarf_Off offset;
  Dwarf_Files *files;
  struct mac_culist *next;
};


static int
mac_compare (const void *p1, const void *p2)
{
  struct mac_culist *m1 = (struct mac_culist *) p1;
  struct mac_culist *m2 = (struct mac_culist *) p2;

  if (m1->offset < m2->offset)
    return -1;
  if (m1->offset > m2->offset)
    return 1;
  return 0;
}


static void
print_debug_macinfo_section (Ebl *ebl __attribute__ ((unused)),
                             GElf_Ehdr *ehdr __attribute__ ((unused)),
                             Elf_Scn *scn, GElf_Shdr *shdr, Dwarf *dbg)
{
  printf (dcgettext (((void *)0), "\nDWARF section '%s' at offset %#" "ll" "x" ":\n", __LC_MESSAGES),

          ".debug_macinfo", (uint64_t) shdr->sh_offset);
  putc_unlocked ('\n', stdout);



  Elf_Data *data = elf_getdata (scn, ((void *)0));
  if (data == ((void *)0) || data->d_buf == ((void *)0))
    {
      error (0, 0, dcgettext (((void *)0), "cannot get macro information section data: %s", __LC_MESSAGES),
             elf_errmsg (-1));
      return;
    }


  Dwarf_Off offset;
  Dwarf_Off ncu = 0;
  size_t hsize;
  struct mac_culist *culist = ((void *)0);
  size_t nculist = 0;
  while (dwarf_nextcu (dbg, offset = ncu, &ncu, &hsize, ((void *)0), ((void *)0), ((void *)0)) == 0)
    {
      Dwarf_Die cudie;
      if (dwarf_offdie (dbg, offset + hsize, &cudie) == ((void *)0))
        continue;

      Dwarf_Attribute attr;
      if (dwarf_attr (&cudie, DW_AT_macro_info, &attr) == ((void *)0))
        continue;

      Dwarf_Word macoff;
      if (dwarf_formudata (&attr, &macoff) != 0)
        continue;

      struct mac_culist *newp = (struct mac_culist *) __builtin_alloca (sizeof (*newp));
      newp->die = cudie;
      newp->offset = macoff;
      newp->files = ((void *)0);
      newp->next = culist;
      culist = newp;
      ++nculist;
    }


  struct mac_culist *cus = (struct mac_culist *) __builtin_alloca ((nculist + 1) * sizeof (*cus));


  cus[nculist].offset = data->d_size;
  if (nculist > 0)
    {
      for (size_t cnt = nculist - 1; culist != ((void *)0); --cnt)
        {
          ((void) ((cnt < nculist) ? 0 : (__assert_fail ("cnt < nculist", "readelf.c", 4602, __PRETTY_FUNCTION__), 0)));
          cus[cnt] = *culist;
          culist = culist->next;
        }



      qsort (cus, nculist, sizeof (*cus), mac_compare);
    }

  const unsigned char *readp = (const unsigned char *) data->d_buf;
  const unsigned char *readendp = readp + data->d_size;
  int level = 1;

  while (readp < readendp)
    {
      unsigned int opcode = *readp++;
      unsigned int u128;
      unsigned int u128_2;
      const unsigned char *endp;

      switch (opcode)
        {
        case DW_MACINFO_define:
        case DW_MACINFO_undef:
        case DW_MACINFO_vendor_ext:





          do { unsigned char __b; u128 = 0; __b = *(readp)++; u128 |= (uintmax_t) (__b & 0x7f) << (0 * 7); if (__builtin_expect ((__b & 0x80) == 0, 1)) break; u128 = __libdw_get_uleb128 (u128, 1, &(readp)); } while (0);

          endp = memchr (readp, '\0', readendp - readp);
          if (endp == ((void *)0))
            {
              printf (dcgettext (((void *)0), "%*s*** non-terminated string at end of section", __LC_MESSAGES),

                      level, "");
              return;
            }

          if (opcode == DW_MACINFO_define)
            printf ("%*s#define %s, line %u\n",
                    level, "", (char *) readp, u128);
          else if (opcode == DW_MACINFO_undef)
            printf ("%*s#undef %s, line %u\n",
                    level, "", (char *) readp, u128);
          else
            printf (" #vendor-ext %s, number %u\n", (char *) readp, u128);

          readp = endp + 1;
          break;

        case DW_MACINFO_start_file:

          do { unsigned char __b; u128 = 0; __b = *(readp)++; u128 |= (uintmax_t) (__b & 0x7f) << (0 * 7); if (__builtin_expect ((__b & 0x80) == 0, 1)) break; u128 = __libdw_get_uleb128 (u128, 1, &(readp)); } while (0);
          do { unsigned char __b; u128_2 = 0; __b = *(readp)++; u128_2 |= (uintmax_t) (__b & 0x7f) << (0 * 7); if (__builtin_expect ((__b & 0x80) == 0, 1)) break; u128_2 = __libdw_get_uleb128 (u128_2, 1, &(readp)); } while (0);


          size_t macoff = readp - (const unsigned char *) data->d_buf;
          const char *fname = "???";
          if (macoff >= cus[0].offset)
            {
              while (macoff >= cus[1].offset)
                ++cus;

              if (cus[0].files == ((void *)0)
                && dwarf_getsrcfiles (&cus[0].die, &cus[0].files, ((void *)0)) != 0)
                cus[0].files = (Dwarf_Files *) -1l;

              if (cus[0].files != (Dwarf_Files *) -1l)
                fname = (dwarf_filesrc (cus[0].files, u128_2, ((void *)0), ((void *)0))
                         ?: "???");
            }

          printf ("%*sstart_file %u, [%u] %s\n",
                  level, "", u128, u128_2, fname);
          ++level;
          break;

        case DW_MACINFO_end_file:
          --level;
          printf ("%*send_file\n", level, "");

          break;

        default:

          if (opcode != 0 || readp != readendp)
            printf ("%*s*** invalid opcode %u\n", level, "", opcode);
          break;
        }
    }
}



static int
print_pubnames (Dwarf *dbg __attribute__ ((unused)), Dwarf_Global *global,
                void *arg)
{
  int *np = (int *) arg;

  printf (dcgettext (((void *)0), " [%5d] DIE offset: %6" "ll" "d" ", CU DIE offset: %6" "ll" "d" ", name: %s\n", __LC_MESSAGES),

          (*np)++, global->die_offset, global->cu_offset, global->name);

  return 0;
}



static void
print_debug_pubnames_section (Ebl *ebl __attribute__ ((unused)),
                              GElf_Ehdr *ehdr __attribute__ ((unused)),
                              Elf_Scn *scn __attribute__ ((unused)),
                              GElf_Shdr *shdr, Dwarf *dbg)
{
  printf (dcgettext (((void *)0), "\nDWARF section '%s' at offset %#" "ll" "x" ":\n", __LC_MESSAGES),
          ".debug_pubnames", (uint64_t) shdr->sh_offset);

  int n = 0;
  (void) dwarf_getpubnames (dbg, print_pubnames, &n, 0);
}


static void
print_debug_str_section (Ebl *ebl __attribute__ ((unused)),
                         GElf_Ehdr *ehdr __attribute__ ((unused)),
                         Elf_Scn *scn __attribute__ ((unused)),
                         GElf_Shdr *shdr, Dwarf *dbg)
{

  GElf_Addr tmp = shdr->sh_size;
  int digits = 1;
  while (tmp >= 16)
    {
      ++digits;
      tmp >>= 4;
    }
  digits = (((4)>(digits))?(4):(digits));

  printf (dcgettext (((void *)0), "\nDWARF section '%s' at offset %#" "ll" "x" ":\n" " %*s  String\n", __LC_MESSAGES),

          ".debug_str", (uint64_t) shdr->sh_offset,

          digits + 2, ({ const char *__res = strrchr (dcgettext (((void *)0), "debugstr|Offset", __LC_MESSAGES), '|'); __res ? __res + 1 : "debugstr|Offset"; }));

  Dwarf_Off offset = 0;
  while (offset < shdr->sh_size)
    {
      size_t len;
      const char *str = dwarf_getstring (dbg, offset, &len);
      if (str == ((void *)0))
        {
          printf (dcgettext (((void *)0), " *** error while reading strings: %s\n", __LC_MESSAGES),
                  dwarf_errmsg (-1));
          break;
        }

      printf (" [%*" "ll" "x" "]  \"%s\"\n", digits, (uint64_t) offset, str);

      offset += len + 1;
    }
}


static void
print_debug (Ebl *ebl, GElf_Ehdr *ehdr)
{


  Dwarf *dbg;
  Elf_Scn *scn;
  size_t shstrndx;


  dbg = dwarf_begin_elf (ebl->elf, DWARF_C_READ, ((void *)0));
  if (dbg == ((void *)0))
    {
      error (0, 0, dcgettext (((void *)0), "cannot get debug context descriptor: %s", __LC_MESSAGES),
             dwarf_errmsg (-1));
      return;
    }


  if (elf_getshstrndx (ebl->elf, &shstrndx) < 0)
    error (1, 0,
           dcgettext (((void *)0), "cannot get section header string table index", __LC_MESSAGES));

  scn = ((void *)0);
  while ((scn = elf_nextscn (ebl->elf, scn)) != ((void *)0))
    {

      GElf_Shdr shdr_mem;
      GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);

      if (shdr != ((void *)0) || shdr->sh_type != 1)
        {
          static const struct
          {
            const char *name;
            enum section_e bitmask;
            void (*fp) (Ebl *, GElf_Ehdr *, Elf_Scn *, GElf_Shdr *, Dwarf *);
          } debug_sections[] =
            {
#define NEW_SECTION(name) { ".debug_" #name, section_ ##name, print_debug_ ##name ##_section }

              { ".debug_" "abbrev", section_abbrev, print_debug_abbrev_section },
              { ".debug_" "aranges", section_aranges, print_debug_aranges_section },
              { ".debug_" "frame", section_frame, print_debug_frame_section },
              { ".debug_" "info", section_info, print_debug_info_section },
              { ".debug_" "line", section_line, print_debug_line_section },
              { ".debug_" "loc", section_loc, print_debug_loc_section },
              { ".debug_" "pubnames", section_pubnames, print_debug_pubnames_section },
              { ".debug_" "str", section_str, print_debug_str_section },
              { ".debug_" "macinfo", section_macinfo, print_debug_macinfo_section },
              { ".debug_" "ranges", section_ranges, print_debug_ranges_section },
              { ".eh_frame", section_frame, print_debug_frame_section }
            };
          const int ndebug_sections = (sizeof (debug_sections)
                                       / sizeof (debug_sections[0]));
          const char *name = elf_strptr (ebl->elf, shstrndx,
                                         shdr->sh_name);
          int n;

          for (n = 0; n < ndebug_sections; ++n)
            if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (name) && __builtin_constant_p (debug_sections[n].name) && (__s1_len = strlen (name), __s2_len = strlen (debug_sections[n].name), (!((size_t)(const void *)((name) + 1) - (size_t)(const void *)(name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((debug_sections[n].name) + 1) - (size_t)(const void *)(debug_sections[n].name) == 1) || __s2_len >= 4)) ? __builtin_strcmp (name, debug_sections[n].name) : (__builtin_constant_p (name) && ((size_t)(const void *)((name) + 1) - (size_t)(const void *)(name) == 1) && (__s1_len = strlen (name), __s1_len < 4) ? (__builtin_constant_p (debug_sections[n].name) && ((size_t)(const void *)((debug_sections[n].name) + 1) - (size_t)(const void *)(debug_sections[n].name) == 1) ? __builtin_strcmp (name, debug_sections[n].name) : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (debug_sections[n].name); register int __result = (((const unsigned char *) (const char *) (name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (debug_sections[n].name) && ((size_t)(const void *)((debug_sections[n].name) + 1) - (size_t)(const void *)(debug_sections[n].name) == 1) && (__s2_len = strlen (debug_sections[n].name), __s2_len < 4) ? (__builtin_constant_p (name) && ((size_t)(const void *)((name) + 1) - (size_t)(const void *)(name) == 1) ? __builtin_strcmp (name, debug_sections[n].name) : (__extension__ ({ const unsigned char *__s1 = (const unsigned char *) (const char *) (name); register int __result = __s1[0] - ((const unsigned char *) (const char *) (debug_sections[n].name))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((const unsigned char *) (const char *) (debug_sections[n].name))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((const unsigned char *) (const char *) (debug_sections[n].name))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((const unsigned char *) (const char *) (debug_sections[n].name))[3]); } } __result; }))) : __builtin_strcmp (name, debug_sections[n].name)))); }) == 0)
              {
                if (print_debug_sections & debug_sections[n].bitmask)
                  debug_sections[n].fp (ebl, ehdr, scn, shdr, dbg);
                break;
              }
        }
    }


  dwarf_end (dbg);
}


static void
handle_notes (Ebl *ebl, GElf_Ehdr *ehdr)
{
  int class = gelf_getclass (ebl->elf);
  size_t cnt;



  for (cnt = 0; cnt < ehdr->e_phnum; ++cnt)
    {
      GElf_Phdr mem;
      GElf_Phdr *phdr = gelf_getphdr (ebl->elf, cnt, &mem);

      if (phdr == ((void *)0) || phdr->p_type != 4)

        continue;

      printf (dcgettext (((void *)0), "\nNote segment of %" "ll" "d" " bytes at offset %#0" "ll" "x" ":\n", __LC_MESSAGES),

              phdr->p_filesz, phdr->p_offset);

      char *notemem = gelf_rawchunk (ebl->elf, phdr->p_offset, phdr->p_filesz);
      if (notemem == ((void *)0))
        error (1, 0,
               dcgettext (((void *)0), "cannot get content of note section: %s", __LC_MESSAGES),
               elf_errmsg (-1));

      fputs_unlocked (dcgettext (((void *)0), "  Owner          Data size  Type\n", __LC_MESSAGES), stdout);
# 4887 "readelf.c"
      size_t align = class == 1 ? 4 : 4;
#define ALIGNED_LEN(len) (((len) + align - 1) & ~(align - 1))

      size_t idx = 0;
      while (idx < phdr->p_filesz)
        {

          struct
          {
            uint32_t namesz;
            uint32_t descsz;
            uint32_t type;
            char name[0];
          } *noteentry = (__typeof (noteentry)) (notemem + idx);

          if (idx + 12 > phdr->p_filesz
              || (idx + 12 + (((noteentry->namesz) + align - 1) & ~(align - 1))
                  + (((noteentry->descsz) + align - 1) & ~(align - 1)) > phdr->p_filesz))


            break;

          char buf[100];
          char buf2[100];
          printf (dcgettext (((void *)0), "  %-13.*s  %9" "d" "  %s\n", __LC_MESSAGES),
                  (int) noteentry->namesz, noteentry->name,
                  noteentry->descsz,
                  ehdr->e_type == 4
                  ? ebl_core_note_type_name (ebl, noteentry->type,
                                             buf, sizeof (buf))
                  : ebl_object_note_type_name (ebl, noteentry->type,
                                               buf2, sizeof (buf2)));


          if (memchr (noteentry->name, '\0', noteentry->namesz) != ((void *)0)

              || 1)
            {
              if (ehdr->e_type == 4)
                ebl_core_note (ebl, noteentry->name, noteentry->type,
                               noteentry->descsz,
                               &noteentry->name[(((noteentry->namesz) + align - 1) & ~(align - 1))]);
              else
                ebl_object_note (ebl, noteentry->name, noteentry->type,
                                 noteentry->descsz,
                                 &noteentry->name[(((noteentry->namesz) + align - 1) & ~(align - 1))]);
            }


          idx += (12 + (((noteentry->namesz) + align - 1) & ~(align - 1))
                  + (((noteentry->descsz) + align - 1) & ~(align - 1)));
        }

      gelf_freechunk (ebl->elf, notemem);
    }
}