Ticket #34232: clang_print_objc.pp.c

# 1 "print_objc.c"
# 1 "print_objc.c" 1
# 1 "<built-in>" 1
# 1 "<built-in>" 3
# 119 "<built-in>" 3
# 1 "<command line>" 1
# 1 "<built-in>" 2
# 1 "print_objc.c" 2
# 31 "print_objc.c"
# 1 "/usr/include/stdio.h" 1 3 4
# 64 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/_types.h" 1 3 4
# 27 "/usr/include/_types.h" 3 4
# 1 "/usr/include/sys/_types.h" 1 3 4
# 32 "/usr/include/sys/_types.h" 3 4
# 1 "/usr/include/sys/cdefs.h" 1 3 4
# 33 "/usr/include/sys/_types.h" 2 3 4
# 1 "/usr/include/machine/_types.h" 1 3 4
# 34 "/usr/include/machine/_types.h" 3 4
# 1 "/usr/include/i386/_types.h" 1 3 4
# 37 "/usr/include/i386/_types.h" 3 4
typedef signed char __int8_t;



typedef unsigned char __uint8_t;
typedef short __int16_t;
typedef unsigned short __uint16_t;
typedef int __int32_t;
typedef unsigned int __uint32_t;
typedef long long __int64_t;
typedef unsigned long long __uint64_t;

typedef long __darwin_intptr_t;
typedef unsigned int __darwin_natural_t;
# 70 "/usr/include/i386/_types.h" 3 4
typedef int __darwin_ct_rune_t;





typedef union {
 char __mbstate8[128];
 long long _mbstateL;
} __mbstate_t;

typedef __mbstate_t __darwin_mbstate_t;


typedef long int __darwin_ptrdiff_t;





typedef long unsigned int __darwin_size_t;





typedef __builtin_va_list __darwin_va_list;





typedef int __darwin_wchar_t;




typedef __darwin_wchar_t __darwin_rune_t;


typedef int __darwin_wint_t;




typedef unsigned long __darwin_clock_t;
typedef __uint32_t __darwin_socklen_t;
typedef long __darwin_ssize_t;
typedef long __darwin_time_t;
# 35 "/usr/include/machine/_types.h" 2 3 4
# 34 "/usr/include/sys/_types.h" 2 3 4
# 58 "/usr/include/sys/_types.h" 3 4
struct __darwin_pthread_handler_rec
{
 void (*__routine)(void *);
 void *__arg;
 struct __darwin_pthread_handler_rec *__next;
};
struct _opaque_pthread_attr_t { long __sig; char __opaque[56]; };
struct _opaque_pthread_cond_t { long __sig; char __opaque[40]; };
struct _opaque_pthread_condattr_t { long __sig; char __opaque[8]; };
struct _opaque_pthread_mutex_t { long __sig; char __opaque[56]; };
struct _opaque_pthread_mutexattr_t { long __sig; char __opaque[8]; };
struct _opaque_pthread_once_t { long __sig; char __opaque[8]; };
struct _opaque_pthread_rwlock_t { long __sig; char __opaque[192]; };
struct _opaque_pthread_rwlockattr_t { long __sig; char __opaque[16]; };
struct _opaque_pthread_t { long __sig; struct __darwin_pthread_handler_rec *__cleanup_stack; char __opaque[1168]; };
# 94 "/usr/include/sys/_types.h" 3 4
typedef __int64_t __darwin_blkcnt_t;
typedef __int32_t __darwin_blksize_t;
typedef __int32_t __darwin_dev_t;
typedef unsigned int __darwin_fsblkcnt_t;
typedef unsigned int __darwin_fsfilcnt_t;
typedef __uint32_t __darwin_gid_t;
typedef __uint32_t __darwin_id_t;
typedef __uint64_t __darwin_ino64_t;

typedef __darwin_ino64_t __darwin_ino_t;



typedef __darwin_natural_t __darwin_mach_port_name_t;
typedef __darwin_mach_port_name_t __darwin_mach_port_t;
typedef __uint16_t __darwin_mode_t;
typedef __int64_t __darwin_off_t;
typedef __int32_t __darwin_pid_t;
typedef struct _opaque_pthread_attr_t
   __darwin_pthread_attr_t;
typedef struct _opaque_pthread_cond_t
   __darwin_pthread_cond_t;
typedef struct _opaque_pthread_condattr_t
   __darwin_pthread_condattr_t;
typedef unsigned long __darwin_pthread_key_t;
typedef struct _opaque_pthread_mutex_t
   __darwin_pthread_mutex_t;
typedef struct _opaque_pthread_mutexattr_t
   __darwin_pthread_mutexattr_t;
typedef struct _opaque_pthread_once_t
   __darwin_pthread_once_t;
typedef struct _opaque_pthread_rwlock_t
   __darwin_pthread_rwlock_t;
typedef struct _opaque_pthread_rwlockattr_t
   __darwin_pthread_rwlockattr_t;
typedef struct _opaque_pthread_t
   *__darwin_pthread_t;
typedef __uint32_t __darwin_sigset_t;
typedef __int32_t __darwin_suseconds_t;
typedef __uint32_t __darwin_uid_t;
typedef __uint32_t __darwin_useconds_t;
typedef unsigned char __darwin_uuid_t[16];
typedef char __darwin_uuid_string_t[37];
# 28 "/usr/include/_types.h" 2 3 4
# 39 "/usr/include/_types.h" 3 4
typedef int __darwin_nl_item;
typedef int __darwin_wctrans_t;

typedef __uint32_t __darwin_wctype_t;
# 65 "/usr/include/stdio.h" 2 3 4





typedef __darwin_va_list va_list;




typedef __darwin_off_t off_t;




typedef __darwin_size_t size_t;






typedef __darwin_off_t fpos_t;
# 98 "/usr/include/stdio.h" 3 4
struct __sbuf {
 unsigned char *_base;
 int _size;
};


struct __sFILEX;
# 132 "/usr/include/stdio.h" 3 4
typedef struct __sFILE {
 unsigned char *_p;
 int _r;
 int _w;
 short _flags;
 short _file;
 struct __sbuf _bf;
 int _lbfsize;


 void *_cookie;
 int (*_close)(void *);
 int (*_read) (void *, char *, int);
 fpos_t (*_seek) (void *, fpos_t, int);
 int (*_write)(void *, const char *, int);


 struct __sbuf _ub;
 struct __sFILEX *_extra;
 int _ur;


 unsigned char _ubuf[3];
 unsigned char _nbuf[1];


 struct __sbuf _lb;


 int _blksize;
 fpos_t _offset;
} FILE;



extern FILE *__stdinp;
extern FILE *__stdoutp;
extern FILE *__stderrp;
# 249 "/usr/include/stdio.h" 3 4
void clearerr(FILE *);
int fclose(FILE *);
int feof(FILE *);
int ferror(FILE *);
int fflush(FILE *);
int fgetc(FILE *);
int fgetpos(FILE * restrict, fpos_t *);
char *fgets(char * restrict, int, FILE *);



FILE *fopen(const char * restrict, const char * restrict) __asm("_" "fopen" );

int fprintf(FILE * restrict, const char * restrict, ...) ;
int fputc(int, FILE *);
int fputs(const char * restrict, FILE * restrict) __asm("_" "fputs" );
size_t fread(void * restrict, size_t, size_t, FILE * restrict);
FILE *freopen(const char * restrict, const char * restrict,
     FILE * restrict) __asm("_" "freopen" );
int fscanf(FILE * restrict, const char * restrict, ...) ;
int fseek(FILE *, long, int);
int fsetpos(FILE *, const fpos_t *);
long ftell(FILE *);
size_t fwrite(const void * restrict, size_t, size_t, FILE * restrict) __asm("_" "fwrite" );
int getc(FILE *);
int getchar(void);
char *gets(char *);

extern const int sys_nerr;
extern const char *const sys_errlist[];

void perror(const char *);
int printf(const char * restrict, ...) ;
int putc(int, FILE *);
int putchar(int);
int puts(const char *);
int remove(const char *);
int rename (const char *, const char *);
void rewind(FILE *);
int scanf(const char * restrict, ...) ;
void setbuf(FILE * restrict, char * restrict);
int setvbuf(FILE * restrict, char * restrict, int, size_t);
int sprintf(char * restrict, const char * restrict, ...) ;
int sscanf(const char * restrict, const char * restrict, ...) ;
FILE *tmpfile(void);
char *tmpnam(char *);
int ungetc(int, FILE *);
int vfprintf(FILE * restrict, const char * restrict, va_list) ;
int vprintf(const char * restrict, va_list) ;
int vsprintf(char * restrict, const char * restrict, va_list) ;

int asprintf(char **, const char *, ...) ;
int vasprintf(char **, const char *, va_list) ;
# 312 "/usr/include/stdio.h" 3 4
char *ctermid(char *);

char *ctermid_r(char *);




FILE *fdopen(int, const char *) __asm("_" "fdopen" );


char *fgetln(FILE *, size_t *);

int fileno(FILE *);
void flockfile(FILE *);

const char
 *fmtcheck(const char *, const char *);
int fpurge(FILE *);

int fseeko(FILE *, off_t, int);
off_t ftello(FILE *);
int ftrylockfile(FILE *);
void funlockfile(FILE *);
int getc_unlocked(FILE *);
int getchar_unlocked(void);

int getw(FILE *);

int pclose(FILE *);



FILE *popen(const char *, const char *) __asm("_" "popen" );

int putc_unlocked(int, FILE *);
int putchar_unlocked(int);

int putw(int, FILE *);
void setbuffer(FILE *, char *, int);
int setlinebuf(FILE *);

int snprintf(char * restrict, size_t, const char * restrict, ...) ;
char *tempnam(const char *, const char *) __asm("_" "tempnam" );
int vfscanf(FILE * restrict, const char * restrict, va_list) ;
int vscanf(const char * restrict, va_list) ;
int vsnprintf(char * restrict, size_t, const char * restrict, va_list) ;
int vsscanf(const char * restrict, const char * restrict, va_list) ;

FILE *zopen(const char *, const char *, int);
# 369 "/usr/include/stdio.h" 3 4
FILE *funopen(const void *,
  int (*)(void *, char *, int),
  int (*)(void *, const char *, int),
  fpos_t (*)(void *, fpos_t, int),
  int (*)(void *));
# 384 "/usr/include/stdio.h" 3 4
int __srget(FILE *);
int __svfscanf(FILE *, const char *, va_list) ;
int __swbuf(int, FILE *);
# 395 "/usr/include/stdio.h" 3 4
static __inline int __sputc(int _c, FILE *_p) {
 if (--_p->_w >= 0 || (_p->_w >= _p->_lbfsize && (char)_c != '\n'))
  return (*_p->_p++ = _c);
 else
  return (__swbuf(_c, _p));
}
# 443 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/secure/_stdio.h" 1 3 4
# 31 "/usr/include/secure/_stdio.h" 3 4
# 1 "/usr/include/secure/_common.h" 1 3 4
# 32 "/usr/include/secure/_stdio.h" 2 3 4
# 42 "/usr/include/secure/_stdio.h" 3 4
extern int __sprintf_chk (char * restrict, int, size_t,
     const char * restrict, ...)
                                      ;




extern int __snprintf_chk (char * restrict, size_t, int, size_t,
      const char * restrict, ...)
                                       ;




extern int __vsprintf_chk (char * restrict, int, size_t,
      const char * restrict, va_list)
                                       ;




extern int __vsnprintf_chk (char * restrict, size_t, int, size_t,
       const char * restrict, va_list)
                                        ;
# 444 "/usr/include/stdio.h" 2 3 4
# 32 "print_objc.c" 2
# 1 "/usr/include/string.h" 1 3 4
# 70 "/usr/include/string.h" 3 4
typedef __darwin_ssize_t ssize_t;
# 81 "/usr/include/string.h" 3 4
void *memchr(const void *, int, size_t);
int memcmp(const void *, const void *, size_t);
void *memcpy(void *, const void *, size_t);
void *memmove(void *, const void *, size_t);
void *memset(void *, int, size_t);

char *stpcpy(char *, const char *);
char *strcasestr(const char *, const char *);

char *strcat(char *, const char *);
char *strchr(const char *, int);
int strcmp(const char *, const char *);
int strcoll(const char *, const char *);
char *strcpy(char *, const char *);
size_t strcspn(const char *, const char *);
char *strerror(int) __asm("_" "strerror" );
int strerror_r(int, char *, size_t);
size_t strlen(const char *);
char *strncat(char *, const char *, size_t);
int strncmp(const char *, const char *, size_t);
char *strncpy(char *, const char *, size_t);

char *strnstr(const char *, const char *, size_t);

char *strpbrk(const char *, const char *);
char *strrchr(const char *, int);
size_t strspn(const char *, const char *);
char *strstr(const char *, const char *);
char *strtok(char *, const char *);
size_t strxfrm(char *, const char *, size_t);



void *memccpy(void *, const void *, int, size_t);
char *strtok_r(char *, const char *, char **);
char *strdup(const char *);

int bcmp(const void *, const void *, size_t);
void bcopy(const void *, void *, size_t);
void bzero(void *, size_t);
int ffs(int);
int ffsl(long);
int fls(int);
int flsl(long);
char *index(const char *, int);
void memset_pattern4(void *, const void *, size_t);
void memset_pattern8(void *, const void *, size_t);
void memset_pattern16(void *, const void *, size_t);
char *rindex(const char *, int);
int strcasecmp(const char *, const char *);
size_t strlcat(char *, const char *, size_t);
size_t strlcpy(char *, const char *, size_t);
void strmode(int, char *);
int strncasecmp(const char *, const char *, size_t);
char *strsep(char **, const char *);
char *strsignal(int sig);
void swab(const void * restrict, void * restrict, ssize_t);
# 148 "/usr/include/string.h" 3 4
# 1 "/usr/include/secure/_string.h" 1 3 4
# 55 "/usr/include/secure/_string.h" 3 4
static __inline void *
__inline_memcpy_chk (void *__dest, const void *__src, size_t __len)
{
  return __builtin___memcpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
}






static __inline void *
__inline_memmove_chk (void *__dest, const void *__src, size_t __len)
{
  return __builtin___memmove_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
}






static __inline void *
__inline_memset_chk (void *__dest, int __val, size_t __len)
{
  return __builtin___memset_chk (__dest, __val, __len, __builtin_object_size (__dest, 0));
}






static __inline char *
__inline_strcpy_chk (char *restrict __dest, const char *restrict __src)
{
  return __builtin___strcpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
}







static __inline char *
__inline_stpcpy_chk (char *__dest, const char *__src)
{
  return __builtin___stpcpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
}







static __inline char *
__inline_strncpy_chk (char *restrict __dest, const char *restrict __src,
        size_t __len)
{
  return __builtin___strncpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 2 > 1));
}






static __inline char *
__inline_strcat_chk (char *restrict __dest, const char *restrict __src)
{
  return __builtin___strcat_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
}






static __inline char *
__inline_strncat_chk (char *restrict __dest, const char *restrict __src,
        size_t __len)
{
  return __builtin___strncat_chk (__dest, __src, __len, __builtin_object_size (__dest, 2 > 1));
}
# 149 "/usr/include/string.h" 2 3 4
# 33 "print_objc.c" 2
# 1 "./../include/mach-o/loader.h" 1
# 29 "./../include/mach-o/loader.h"
# 1 "/usr/lib/clang/1.5/include/stdint.h" 1 3 4
# 33 "/usr/lib/clang/1.5/include/stdint.h" 3 4
# 1 "/usr/include/stdint.h" 1 3 4
# 20 "/usr/include/stdint.h" 3 4
typedef signed char int8_t;




typedef short int16_t;




typedef int int32_t;




typedef long long int64_t;




typedef unsigned char uint8_t;




typedef unsigned short uint16_t;




typedef unsigned int uint32_t;




typedef unsigned long long uint64_t;



typedef int8_t int_least8_t;
typedef int16_t int_least16_t;
typedef int32_t int_least32_t;
typedef int64_t int_least64_t;
typedef uint8_t uint_least8_t;
typedef uint16_t uint_least16_t;
typedef uint32_t uint_least32_t;
typedef uint64_t uint_least64_t;



typedef int8_t int_fast8_t;
typedef int16_t int_fast16_t;
typedef int32_t int_fast32_t;
typedef int64_t int_fast64_t;
typedef uint8_t uint_fast8_t;
typedef uint16_t uint_fast16_t;
typedef uint32_t uint_fast32_t;
typedef uint64_t uint_fast64_t;






typedef long intptr_t;




typedef unsigned long uintptr_t;







typedef long int intmax_t;
# 106 "/usr/include/stdint.h" 3 4
typedef long unsigned int uintmax_t;
# 34 "/usr/lib/clang/1.5/include/stdint.h" 2 3 4
# 30 "./../include/mach-o/loader.h" 2





# 1 "./../include/mach/machine.h" 1
# 83 "./../include/mach/machine.h"
# 1 "/usr/include/mach/machine/vm_types.h" 1 3 4
# 35 "/usr/include/mach/machine/vm_types.h" 3 4
# 1 "/usr/include/mach/i386/vm_types.h" 1 3 4
# 73 "/usr/include/mach/i386/vm_types.h" 3 4
# 1 "/usr/include/mach/i386/vm_param.h" 1 3 4
# 74 "/usr/include/mach/i386/vm_types.h" 2 3 4
# 93 "/usr/include/mach/i386/vm_types.h" 3 4
typedef __darwin_natural_t natural_t;
typedef int integer_t;






typedef uintptr_t vm_offset_t;
# 112 "/usr/include/mach/i386/vm_types.h" 3 4
typedef uintptr_t vm_size_t;
# 124 "/usr/include/mach/i386/vm_types.h" 3 4
typedef uint64_t mach_vm_address_t;
typedef uint64_t mach_vm_offset_t;
typedef uint64_t mach_vm_size_t;

typedef uint64_t vm_map_offset_t;
typedef uint64_t vm_map_address_t;
typedef uint64_t vm_map_size_t;
# 36 "/usr/include/mach/machine/vm_types.h" 2 3 4
# 84 "./../include/mach/machine.h" 2
# 1 "/usr/include/mach/boolean.h" 1 3 4
# 73 "/usr/include/mach/boolean.h" 3 4
# 1 "/usr/include/mach/machine/boolean.h" 1 3 4
# 35 "/usr/include/mach/machine/boolean.h" 3 4
# 1 "/usr/include/mach/i386/boolean.h" 1 3 4
# 69 "/usr/include/mach/i386/boolean.h" 3 4
typedef unsigned int boolean_t;
# 36 "/usr/include/mach/machine/boolean.h" 2 3 4
# 74 "/usr/include/mach/boolean.h" 2 3 4
# 85 "./../include/mach/machine.h" 2
# 95 "./../include/mach/machine.h"
struct machine_info {
 int major_version;
 int minor_version;
 int max_cpus;
 int avail_cpus;
 vm_size_t memory_size;
};

typedef struct machine_info *machine_info_t;
typedef struct machine_info machine_info_data_t;

typedef int cpu_type_t;
typedef int cpu_subtype_t;
typedef integer_t cpu_threadtype_t;







struct machine_slot {
 boolean_t is_cpu;
 cpu_type_t cpu_type;
 cpu_subtype_t cpu_subtype;
 volatile boolean_t running;
 long cpu_ticks[3];
 int clock_freq;
};

typedef struct machine_slot *machine_slot_t;
typedef struct machine_slot machine_slot_data_t;
# 36 "./../include/mach-o/loader.h" 2





# 1 "/usr/include/mach/vm_prot.h" 1 3 4
# 75 "/usr/include/mach/vm_prot.h" 3 4
typedef int vm_prot_t;
# 42 "./../include/mach-o/loader.h" 2





# 1 "/usr/include/mach/machine/thread_status.h" 1 3 4
# 35 "/usr/include/mach/machine/thread_status.h" 3 4
# 1 "/usr/include/mach/i386/thread_status.h" 1 3 4
# 70 "/usr/include/mach/i386/thread_status.h" 3 4
# 1 "/usr/include/mach/i386/_structs.h" 1 3 4
# 43 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_i386_thread_state
{
    unsigned int __eax;
    unsigned int __ebx;
    unsigned int __ecx;
    unsigned int __edx;
    unsigned int __edi;
    unsigned int __esi;
    unsigned int __ebp;
    unsigned int __esp;
    unsigned int __ss;
    unsigned int __eflags;
    unsigned int __eip;
    unsigned int __cs;
    unsigned int __ds;
    unsigned int __es;
    unsigned int __fs;
    unsigned int __gs;
};
# 89 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_fp_control
{
    unsigned short __invalid :1,
        __denorm :1,
    __zdiv :1,
    __ovrfl :1,
    __undfl :1,
    __precis :1,
      :2,
    __pc :2,





    __rc :2,






             :1,
      :3;
};
typedef struct __darwin_fp_control __darwin_fp_control_t;
# 147 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_fp_status
{
    unsigned short __invalid :1,
        __denorm :1,
    __zdiv :1,
    __ovrfl :1,
    __undfl :1,
    __precis :1,
    __stkflt :1,
    __errsumm :1,
    __c0 :1,
    __c1 :1,
    __c2 :1,
    __tos :3,
    __c3 :1,
    __busy :1;
};
typedef struct __darwin_fp_status __darwin_fp_status_t;
# 191 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_mmst_reg
{
 char __mmst_reg[10];
 char __mmst_rsrv[6];
};
# 210 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_xmm_reg
{
 char __xmm_reg[16];
};
# 232 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_i386_float_state
{
 int __fpu_reserved[2];
 struct __darwin_fp_control __fpu_fcw;
 struct __darwin_fp_status __fpu_fsw;
 __uint8_t __fpu_ftw;
 __uint8_t __fpu_rsrv1;
 __uint16_t __fpu_fop;
 __uint32_t __fpu_ip;
 __uint16_t __fpu_cs;
 __uint16_t __fpu_rsrv2;
 __uint32_t __fpu_dp;
 __uint16_t __fpu_ds;
 __uint16_t __fpu_rsrv3;
 __uint32_t __fpu_mxcsr;
 __uint32_t __fpu_mxcsrmask;
 struct __darwin_mmst_reg __fpu_stmm0;
 struct __darwin_mmst_reg __fpu_stmm1;
 struct __darwin_mmst_reg __fpu_stmm2;
 struct __darwin_mmst_reg __fpu_stmm3;
 struct __darwin_mmst_reg __fpu_stmm4;
 struct __darwin_mmst_reg __fpu_stmm5;
 struct __darwin_mmst_reg __fpu_stmm6;
 struct __darwin_mmst_reg __fpu_stmm7;
 struct __darwin_xmm_reg __fpu_xmm0;
 struct __darwin_xmm_reg __fpu_xmm1;
 struct __darwin_xmm_reg __fpu_xmm2;
 struct __darwin_xmm_reg __fpu_xmm3;
 struct __darwin_xmm_reg __fpu_xmm4;
 struct __darwin_xmm_reg __fpu_xmm5;
 struct __darwin_xmm_reg __fpu_xmm6;
 struct __darwin_xmm_reg __fpu_xmm7;
 char __fpu_rsrv4[14*16];
 int __fpu_reserved1;
};
# 308 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_i386_exception_state
{
    unsigned int __trapno;
    unsigned int __err;
    unsigned int __faultvaddr;
};
# 326 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_x86_debug_state32
{
 unsigned int __dr0;
 unsigned int __dr1;
 unsigned int __dr2;
 unsigned int __dr3;
 unsigned int __dr4;
 unsigned int __dr5;
 unsigned int __dr6;
 unsigned int __dr7;
};
# 358 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_x86_thread_state64
{
 __uint64_t __rax;
 __uint64_t __rbx;
 __uint64_t __rcx;
 __uint64_t __rdx;
 __uint64_t __rdi;
 __uint64_t __rsi;
 __uint64_t __rbp;
 __uint64_t __rsp;
 __uint64_t __r8;
 __uint64_t __r9;
 __uint64_t __r10;
 __uint64_t __r11;
 __uint64_t __r12;
 __uint64_t __r13;
 __uint64_t __r14;
 __uint64_t __r15;
 __uint64_t __rip;
 __uint64_t __rflags;
 __uint64_t __cs;
 __uint64_t __fs;
 __uint64_t __gs;
};
# 413 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_x86_float_state64
{
 int __fpu_reserved[2];
 struct __darwin_fp_control __fpu_fcw;
 struct __darwin_fp_status __fpu_fsw;
 __uint8_t __fpu_ftw;
 __uint8_t __fpu_rsrv1;
 __uint16_t __fpu_fop;


 __uint32_t __fpu_ip;
 __uint16_t __fpu_cs;

 __uint16_t __fpu_rsrv2;


 __uint32_t __fpu_dp;
 __uint16_t __fpu_ds;

 __uint16_t __fpu_rsrv3;
 __uint32_t __fpu_mxcsr;
 __uint32_t __fpu_mxcsrmask;
 struct __darwin_mmst_reg __fpu_stmm0;
 struct __darwin_mmst_reg __fpu_stmm1;
 struct __darwin_mmst_reg __fpu_stmm2;
 struct __darwin_mmst_reg __fpu_stmm3;
 struct __darwin_mmst_reg __fpu_stmm4;
 struct __darwin_mmst_reg __fpu_stmm5;
 struct __darwin_mmst_reg __fpu_stmm6;
 struct __darwin_mmst_reg __fpu_stmm7;
 struct __darwin_xmm_reg __fpu_xmm0;
 struct __darwin_xmm_reg __fpu_xmm1;
 struct __darwin_xmm_reg __fpu_xmm2;
 struct __darwin_xmm_reg __fpu_xmm3;
 struct __darwin_xmm_reg __fpu_xmm4;
 struct __darwin_xmm_reg __fpu_xmm5;
 struct __darwin_xmm_reg __fpu_xmm6;
 struct __darwin_xmm_reg __fpu_xmm7;
 struct __darwin_xmm_reg __fpu_xmm8;
 struct __darwin_xmm_reg __fpu_xmm9;
 struct __darwin_xmm_reg __fpu_xmm10;
 struct __darwin_xmm_reg __fpu_xmm11;
 struct __darwin_xmm_reg __fpu_xmm12;
 struct __darwin_xmm_reg __fpu_xmm13;
 struct __darwin_xmm_reg __fpu_xmm14;
 struct __darwin_xmm_reg __fpu_xmm15;
 char __fpu_rsrv4[6*16];
 int __fpu_reserved1;
};
# 517 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_x86_exception_state64
{
    unsigned int __trapno;
    unsigned int __err;
    __uint64_t __faultvaddr;
};
# 535 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_x86_debug_state64
{
 __uint64_t __dr0;
 __uint64_t __dr1;
 __uint64_t __dr2;
 __uint64_t __dr3;
 __uint64_t __dr4;
 __uint64_t __dr5;
 __uint64_t __dr6;
 __uint64_t __dr7;
};
# 71 "/usr/include/mach/i386/thread_status.h" 2 3 4
# 1 "/usr/include/mach/message.h" 1 3 4
# 75 "/usr/include/mach/message.h" 3 4
# 1 "/usr/include/mach/port.h" 1 3 4
# 106 "/usr/include/mach/port.h" 3 4
typedef natural_t mach_port_name_t;
typedef mach_port_name_t *mach_port_name_array_t;
# 128 "/usr/include/mach/port.h" 3 4
typedef mach_port_name_t mach_port_t;



typedef mach_port_t *mach_port_array_t;
# 190 "/usr/include/mach/port.h" 3 4
typedef natural_t mach_port_right_t;
# 200 "/usr/include/mach/port.h" 3 4
typedef natural_t mach_port_type_t;
typedef mach_port_type_t *mach_port_type_array_t;
# 233 "/usr/include/mach/port.h" 3 4
typedef natural_t mach_port_urefs_t;
typedef integer_t mach_port_delta_t;



typedef natural_t mach_port_seqno_t;
typedef natural_t mach_port_mscount_t;
typedef natural_t mach_port_msgcount_t;
typedef natural_t mach_port_rights_t;






typedef unsigned int mach_port_srights_t;

typedef struct mach_port_status {
 mach_port_rights_t mps_pset;
 mach_port_seqno_t mps_seqno;
 mach_port_mscount_t mps_mscount;
 mach_port_msgcount_t mps_qlimit;
 mach_port_msgcount_t mps_msgcount;
 mach_port_rights_t mps_sorights;
 boolean_t mps_srights;
 boolean_t mps_pdrequest;
 boolean_t mps_nsrequest;
 natural_t mps_flags;
} mach_port_status_t;
# 273 "/usr/include/mach/port.h" 3 4
typedef struct mach_port_limits {
 mach_port_msgcount_t mpl_qlimit;
} mach_port_limits_t;

typedef integer_t *mach_port_info_t;


typedef int mach_port_flavor_t;
# 295 "/usr/include/mach/port.h" 3 4
typedef struct mach_port_qos {
 unsigned int name:1;
 unsigned int prealloc:1;
 boolean_t pad1:30;
 natural_t len;
} mach_port_qos_t;
# 76 "/usr/include/mach/message.h" 2 3 4

# 1 "/usr/include/mach/kern_return.h" 1 3 4
# 70 "/usr/include/mach/kern_return.h" 3 4
# 1 "/usr/include/mach/machine/kern_return.h" 1 3 4
# 35 "/usr/include/mach/machine/kern_return.h" 3 4
# 1 "/usr/include/mach/i386/kern_return.h" 1 3 4
# 71 "/usr/include/mach/i386/kern_return.h" 3 4
typedef int kern_return_t;
# 36 "/usr/include/mach/machine/kern_return.h" 2 3 4
# 71 "/usr/include/mach/kern_return.h" 2 3 4
# 78 "/usr/include/mach/message.h" 2 3 4
# 89 "/usr/include/mach/message.h" 3 4
typedef natural_t mach_msg_timeout_t;
# 172 "/usr/include/mach/message.h" 3 4
typedef unsigned int mach_msg_bits_t;
typedef natural_t mach_msg_size_t;
typedef integer_t mach_msg_id_t;




typedef unsigned int mach_msg_type_name_t;
# 189 "/usr/include/mach/message.h" 3 4
typedef unsigned int mach_msg_copy_options_t;
# 211 "/usr/include/mach/message.h" 3 4
typedef unsigned int mach_msg_descriptor_type_t;






#pragma pack(4)


typedef struct
{
  natural_t pad1;
  mach_msg_size_t pad2;
  unsigned int pad3 : 24;
  mach_msg_descriptor_type_t type : 8;
} mach_msg_type_descriptor_t;

typedef struct
{
  mach_port_t name;


  mach_msg_size_t pad1;

  unsigned int pad2 : 16;
  mach_msg_type_name_t disposition : 8;
  mach_msg_descriptor_type_t type : 8;
} mach_msg_port_descriptor_t;

typedef struct
{
  uint32_t address;
  mach_msg_size_t size;
  boolean_t deallocate: 8;
  mach_msg_copy_options_t copy: 8;
  unsigned int pad1: 8;
  mach_msg_descriptor_type_t type: 8;
} mach_msg_ool_descriptor32_t;

typedef struct
{
  uint64_t address;
  boolean_t deallocate: 8;
  mach_msg_copy_options_t copy: 8;
  unsigned int pad1: 8;
  mach_msg_descriptor_type_t type: 8;
  mach_msg_size_t size;
} mach_msg_ool_descriptor64_t;

typedef struct
{
  void* address;



  boolean_t deallocate: 8;
  mach_msg_copy_options_t copy: 8;
  unsigned int pad1: 8;
  mach_msg_descriptor_type_t type: 8;

  mach_msg_size_t size;




} mach_msg_ool_descriptor_t;

typedef struct
{
  uint32_t address;
  mach_msg_size_t count;
  boolean_t deallocate: 8;
  mach_msg_copy_options_t copy: 8;
  mach_msg_type_name_t disposition : 8;
  mach_msg_descriptor_type_t type : 8;
} mach_msg_ool_ports_descriptor32_t;

typedef struct
{
  uint64_t address;
  boolean_t deallocate: 8;
  mach_msg_copy_options_t copy: 8;
  mach_msg_type_name_t disposition : 8;
  mach_msg_descriptor_type_t type : 8;
  mach_msg_size_t count;
} mach_msg_ool_ports_descriptor64_t;

typedef struct
{
  void* address;



  boolean_t deallocate: 8;
  mach_msg_copy_options_t copy: 8;
  mach_msg_type_name_t disposition : 8;
  mach_msg_descriptor_type_t type : 8;

  mach_msg_size_t count;




} mach_msg_ool_ports_descriptor_t;
# 330 "/usr/include/mach/message.h" 3 4
typedef union
{
  mach_msg_port_descriptor_t port;
  mach_msg_ool_descriptor_t out_of_line;
  mach_msg_ool_ports_descriptor_t ool_ports;
  mach_msg_type_descriptor_t type;
} mach_msg_descriptor_t;


typedef struct
{
        mach_msg_size_t msgh_descriptor_count;
} mach_msg_body_t;




typedef struct
{
  mach_msg_bits_t msgh_bits;
  mach_msg_size_t msgh_size;
  mach_port_t msgh_remote_port;
  mach_port_t msgh_local_port;
  mach_msg_size_t msgh_reserved;
  mach_msg_id_t msgh_id;
} mach_msg_header_t;



typedef struct
{
        mach_msg_header_t header;
        mach_msg_body_t body;
} mach_msg_base_t;

typedef unsigned int mach_msg_trailer_type_t;



typedef unsigned int mach_msg_trailer_size_t;

typedef struct
{
  mach_msg_trailer_type_t msgh_trailer_type;
  mach_msg_trailer_size_t msgh_trailer_size;
} mach_msg_trailer_t;

typedef struct
{
  mach_msg_trailer_type_t msgh_trailer_type;
  mach_msg_trailer_size_t msgh_trailer_size;
  mach_port_seqno_t msgh_seqno;
} mach_msg_seqno_trailer_t;

typedef struct
{
  unsigned int val[2];
} security_token_t;

typedef struct
{
  mach_msg_trailer_type_t msgh_trailer_type;
  mach_msg_trailer_size_t msgh_trailer_size;
  mach_port_seqno_t msgh_seqno;
  security_token_t msgh_sender;
} mach_msg_security_trailer_t;
# 406 "/usr/include/mach/message.h" 3 4
typedef struct
{
  unsigned int val[8];
} audit_token_t;

typedef struct
{
  mach_msg_trailer_type_t msgh_trailer_type;
  mach_msg_trailer_size_t msgh_trailer_size;
  mach_port_seqno_t msgh_seqno;
  security_token_t msgh_sender;
  audit_token_t msgh_audit;
} mach_msg_audit_trailer_t;

typedef struct
{
  mach_msg_trailer_type_t msgh_trailer_type;
  mach_msg_trailer_size_t msgh_trailer_size;
  mach_port_seqno_t msgh_seqno;
  security_token_t msgh_sender;
  audit_token_t msgh_audit;
  mach_vm_address_t msgh_context;
} mach_msg_context_trailer_t;


typedef struct
{
  mach_port_name_t sender;
} msg_labels_t;






typedef struct
{
  mach_msg_trailer_type_t msgh_trailer_type;
  mach_msg_trailer_size_t msgh_trailer_size;
  mach_port_seqno_t msgh_seqno;
  security_token_t msgh_sender;
  audit_token_t msgh_audit;
  mach_vm_address_t msgh_context;
  int msgh_ad;
  msg_labels_t msgh_labels;
} mach_msg_mac_trailer_t;
# 464 "/usr/include/mach/message.h" 3 4
typedef mach_msg_mac_trailer_t mach_msg_max_trailer_t;
# 474 "/usr/include/mach/message.h" 3 4
typedef mach_msg_security_trailer_t mach_msg_format_0_trailer_t;







extern security_token_t KERNEL_SECURITY_TOKEN;


extern audit_token_t KERNEL_AUDIT_TOKEN;

typedef integer_t mach_msg_options_t;

typedef struct
{
  mach_msg_header_t header;
} mach_msg_empty_send_t;

typedef struct
{
  mach_msg_header_t header;
  mach_msg_trailer_t trailer;
} mach_msg_empty_rcv_t;

typedef union
{
  mach_msg_empty_send_t send;
  mach_msg_empty_rcv_t rcv;
} mach_msg_empty_t;

#pragma pack()

# 527 "/usr/include/mach/message.h" 3 4
typedef natural_t mach_msg_type_size_t;
typedef natural_t mach_msg_type_number_t;
# 571 "/usr/include/mach/message.h" 3 4
typedef integer_t mach_msg_option_t;
# 648 "/usr/include/mach/message.h" 3 4
typedef kern_return_t mach_msg_return_t;
# 750 "/usr/include/mach/message.h" 3 4
extern mach_msg_return_t mach_msg_overwrite(
     mach_msg_header_t *msg,
     mach_msg_option_t option,
     mach_msg_size_t send_size,
     mach_msg_size_t rcv_size,
     mach_port_name_t rcv_name,
     mach_msg_timeout_t timeout,
     mach_port_name_t notify,
     mach_msg_header_t *rcv_msg,
     mach_msg_size_t rcv_limit);
# 770 "/usr/include/mach/message.h" 3 4
extern mach_msg_return_t mach_msg(
     mach_msg_header_t *msg,
     mach_msg_option_t option,
     mach_msg_size_t send_size,
     mach_msg_size_t rcv_size,
     mach_port_name_t rcv_name,
     mach_msg_timeout_t timeout,
     mach_port_name_t notify);
# 72 "/usr/include/mach/i386/thread_status.h" 2 3 4
# 1 "/usr/include/mach/i386/fp_reg.h" 1 3 4
# 64 "/usr/include/mach/i386/fp_reg.h" 3 4
struct x86_fx_save {
        unsigned short fx_control;
        unsigned short fx_status;
        unsigned char fx_tag;
        unsigned char fx_bbz1;
        unsigned short fx_opcode;
        unsigned int fx_eip;
        unsigned short fx_cs;
        unsigned short fx_bbz2;
        unsigned int fx_dp;
        unsigned short fx_ds;
        unsigned short fx_bbz3;
        unsigned int fx_MXCSR;
        unsigned int fx_MXCSR_MASK;
        unsigned short fx_reg_word[8][8];
        unsigned short fx_XMM_reg[8][16];

        unsigned char fx_reserved[16*6];
};
# 73 "/usr/include/mach/i386/thread_status.h" 2 3 4
# 1 "/usr/include/mach/i386/thread_state.h" 1 3 4
# 74 "/usr/include/mach/i386/thread_status.h" 2 3 4
# 1 "/usr/include/i386/eflags.h" 1 3 4
# 75 "/usr/include/mach/i386/thread_status.h" 2 3 4
# 141 "/usr/include/mach/i386/thread_status.h" 3 4
struct x86_state_hdr {
 int flavor;
 int count;
};
typedef struct x86_state_hdr x86_state_hdr_t;
# 159 "/usr/include/mach/i386/thread_status.h" 3 4
typedef struct __darwin_i386_thread_state i386_thread_state_t;



typedef struct __darwin_i386_thread_state x86_thread_state32_t;






typedef struct __darwin_i386_float_state i386_float_state_t;



typedef struct __darwin_i386_float_state x86_float_state32_t;






typedef struct __darwin_i386_exception_state i386_exception_state_t;



typedef struct __darwin_i386_exception_state x86_exception_state32_t;





typedef struct __darwin_x86_debug_state32 x86_debug_state32_t;





typedef struct __darwin_x86_thread_state64 x86_thread_state64_t;



typedef struct __darwin_x86_float_state64 x86_float_state64_t;



typedef struct __darwin_x86_exception_state64 x86_exception_state64_t;





typedef struct __darwin_x86_debug_state64 x86_debug_state64_t;
# 220 "/usr/include/mach/i386/thread_status.h" 3 4
struct x86_thread_state {
 x86_state_hdr_t tsh;
 union {
     x86_thread_state32_t ts32;
     x86_thread_state64_t ts64;
 } uts;
};

struct x86_float_state {
 x86_state_hdr_t fsh;
 union {
  x86_float_state32_t fs32;
  x86_float_state64_t fs64;
 } ufs;
};

struct x86_exception_state {
 x86_state_hdr_t esh;
 union {
  x86_exception_state32_t es32;
  x86_exception_state64_t es64;
 } ues;
};

struct x86_debug_state {
 x86_state_hdr_t dsh;
 union {
  x86_debug_state32_t ds32;
  x86_debug_state64_t ds64;
 } uds;
};

typedef struct x86_thread_state x86_thread_state_t;



typedef struct x86_float_state x86_float_state_t;



typedef struct x86_exception_state x86_exception_state_t;



typedef struct x86_debug_state x86_debug_state_t;
# 288 "/usr/include/mach/i386/thread_status.h" 3 4
struct x86_seg_load_fault32 {
 unsigned int trapno;
 unsigned int err;
 unsigned int eip;
 unsigned int cs;
 unsigned int efl;
};
# 36 "/usr/include/mach/machine/thread_status.h" 2 3 4
# 48 "./../include/mach-o/loader.h" 2
# 1 "/usr/include/architecture/byte_order.h" 1 3 4
# 38 "/usr/include/architecture/byte_order.h" 3 4
# 1 "/usr/include/libkern/OSByteOrder.h" 1 3 4
# 33 "/usr/include/libkern/OSByteOrder.h" 3 4
# 1 "/usr/include/libkern/_OSByteOrder.h" 1 3 4
# 66 "/usr/include/libkern/_OSByteOrder.h" 3 4
# 1 "/usr/include/libkern/i386/_OSByteOrder.h" 1 3 4
# 44 "/usr/include/libkern/i386/_OSByteOrder.h" 3 4
static inline
__uint16_t
_OSSwapInt16(
    __uint16_t _data
)
{
    return ((_data << 8) | (_data >> 8));
}

static inline
__uint32_t
_OSSwapInt32(
    __uint32_t _data
)
{

    return __builtin_bswap32(_data);




}


static inline
__uint64_t
_OSSwapInt64(
    __uint64_t _data
)
{
    return __builtin_bswap64(_data);
}
# 67 "/usr/include/libkern/_OSByteOrder.h" 2 3 4
# 34 "/usr/include/libkern/OSByteOrder.h" 2 3 4
# 45 "/usr/include/libkern/OSByteOrder.h" 3 4
# 1 "/usr/include/libkern/i386/OSByteOrder.h" 1 3 4
# 41 "/usr/include/libkern/i386/OSByteOrder.h" 3 4
static inline
uint16_t
OSReadSwapInt16(
    const volatile void * base,
    uintptr_t byteOffset
)
{
    uint16_t result;

    result = *(volatile uint16_t *)((uintptr_t)base + byteOffset);
    return _OSSwapInt16(result);
}

static inline
uint32_t
OSReadSwapInt32(
    const volatile void * base,
    uintptr_t byteOffset
)
{
    uint32_t result;

    result = *(volatile uint32_t *)((uintptr_t)base + byteOffset);
    return _OSSwapInt32(result);
}

static inline
uint64_t
OSReadSwapInt64(
    const volatile void * base,
    uintptr_t byteOffset
)
{
    uint64_t result;

    result = *(volatile uint64_t *)((uintptr_t)base + byteOffset);
    return _OSSwapInt64(result);
}



static inline
void
OSWriteSwapInt16(
    volatile void * base,
    uintptr_t byteOffset,
    uint16_t data
)
{
    *(volatile uint16_t *)((uintptr_t)base + byteOffset) = _OSSwapInt16(data);
}

static inline
void
OSWriteSwapInt32(
    volatile void * base,
    uintptr_t byteOffset,
    uint32_t data
)
{
    *(volatile uint32_t *)((uintptr_t)base + byteOffset) = _OSSwapInt32(data);
}

static inline
void
OSWriteSwapInt64(
    volatile void * base,
    uintptr_t byteOffset,
    uint64_t data
)
{
    *(volatile uint64_t *)((uintptr_t)base + byteOffset) = _OSSwapInt64(data);
}
# 46 "/usr/include/libkern/OSByteOrder.h" 2 3 4
# 62 "/usr/include/libkern/OSByteOrder.h" 3 4
enum {
    OSUnknownByteOrder,
    OSLittleEndian,
    OSBigEndian
};

static inline
int32_t
OSHostByteOrder(void) {

    return OSLittleEndian;





}
# 91 "/usr/include/libkern/OSByteOrder.h" 3 4
static inline
uint16_t
_OSReadInt16(
    const volatile void * base,
    uintptr_t byteOffset
)
{
    return *(volatile uint16_t *)((uintptr_t)base + byteOffset);
}

static inline
uint32_t
_OSReadInt32(
    const volatile void * base,
    uintptr_t byteOffset
)
{
    return *(volatile uint32_t *)((uintptr_t)base + byteOffset);
}

static inline
uint64_t
_OSReadInt64(
    const volatile void * base,
    uintptr_t byteOffset
)
{
    return *(volatile uint64_t *)((uintptr_t)base + byteOffset);
}



static inline
void
_OSWriteInt16(
    volatile void * base,
    uintptr_t byteOffset,
    uint16_t data
)
{
    *(volatile uint16_t *)((uintptr_t)base + byteOffset) = data;
}

static inline
void
_OSWriteInt32(
    volatile void * base,
    uintptr_t byteOffset,
    uint32_t data
)
{
    *(volatile uint32_t *)((uintptr_t)base + byteOffset) = data;
}

static inline
void
_OSWriteInt64(
    volatile void * base,
    uintptr_t byteOffset,
    uint64_t data
)
{
    *(volatile uint64_t *)((uintptr_t)base + byteOffset) = data;
}
# 39 "/usr/include/architecture/byte_order.h" 2 3 4

typedef unsigned long NXSwappedFloat;
typedef unsigned long long NXSwappedDouble;

static __inline__ __attribute__((deprecated))
unsigned short
NXSwapShort(
    unsigned short inv
)
{
    return (unsigned short)(__builtin_constant_p((uint16_t)inv) ? ((__uint16_t)((((__uint16_t)((uint16_t)inv) & 0xff00) >> 8) | (((__uint16_t)((uint16_t)inv) & 0x00ff) << 8))) : _OSSwapInt16((uint16_t)inv));
}

static __inline__ __attribute__((deprecated))
unsigned int
NXSwapInt(
    unsigned int inv
)
{
    return (unsigned int)(__builtin_constant_p((uint32_t)inv) ? ((__uint32_t)((((__uint32_t)((uint32_t)inv) & 0xff000000) >> 24) | (((__uint32_t)((uint32_t)inv) & 0x00ff0000) >> 8) | (((__uint32_t)((uint32_t)inv) & 0x0000ff00) << 8) | (((__uint32_t)((uint32_t)inv) & 0x000000ff) << 24))) : _OSSwapInt32((uint32_t)inv));
}

static __inline__ __attribute__((deprecated))
unsigned long
NXSwapLong(
    unsigned long inv
)
{
    return (unsigned long)(__builtin_constant_p((uint32_t)inv) ? ((__uint32_t)((((__uint32_t)((uint32_t)inv) & 0xff000000) >> 24) | (((__uint32_t)((uint32_t)inv) & 0x00ff0000) >> 8) | (((__uint32_t)((uint32_t)inv) & 0x0000ff00) << 8) | (((__uint32_t)((uint32_t)inv) & 0x000000ff) << 24))) : _OSSwapInt32((uint32_t)inv));
}

static __inline__ __attribute__((deprecated))
unsigned long long
NXSwapLongLong(
    unsigned long long inv
)
{
    return (unsigned long long)(__builtin_constant_p((uint64_t)inv) ? ((__uint64_t)((((__uint64_t)((uint64_t)inv) & 0xff00000000000000ULL) >> 56) | (((__uint64_t)((uint64_t)inv) & 0x00ff000000000000ULL) >> 40) | (((__uint64_t)((uint64_t)inv) & 0x0000ff0000000000ULL) >> 24) | (((__uint64_t)((uint64_t)inv) & 0x000000ff00000000ULL) >> 8) | (((__uint64_t)((uint64_t)inv) & 0x00000000ff000000ULL) << 8) | (((__uint64_t)((uint64_t)inv) & 0x0000000000ff0000ULL) << 24) | (((__uint64_t)((uint64_t)inv) & 0x000000000000ff00ULL) << 40) | (((__uint64_t)((uint64_t)inv) & 0x00000000000000ffULL) << 56))) : _OSSwapInt64((uint64_t)inv));
}

static __inline__ __attribute__((deprecated))
NXSwappedFloat
NXConvertHostFloatToSwapped(float x)
{
    union fconv {
        float number;
        NXSwappedFloat sf;
    } u;
    u.number = x;
    return u.sf;
}

static __inline__ __attribute__((deprecated))
float
NXConvertSwappedFloatToHost(NXSwappedFloat x)
{
    union fconv {
        float number;
        NXSwappedFloat sf;
    } u;
    u.sf = x;
    return u.number;
}

static __inline__ __attribute__((deprecated))
NXSwappedDouble
NXConvertHostDoubleToSwapped(double x)
{
    union dconv {
        double number;
        NXSwappedDouble sd;
    } u;
    u.number = x;
    return u.sd;
}

static __inline__ __attribute__((deprecated))
double
NXConvertSwappedDoubleToHost(NXSwappedDouble x)
{
    union dconv {
        double number;
        NXSwappedDouble sd;
    } u;
    u.sd = x;
    return u.number;
}

static __inline__ __attribute__((deprecated))
NXSwappedFloat
NXSwapFloat(NXSwappedFloat x)
{
    return (NXSwappedFloat)(__builtin_constant_p((uint32_t)x) ? ((__uint32_t)((((__uint32_t)((uint32_t)x) & 0xff000000) >> 24) | (((__uint32_t)((uint32_t)x) & 0x00ff0000) >> 8) | (((__uint32_t)((uint32_t)x) & 0x0000ff00) << 8) | (((__uint32_t)((uint32_t)x) & 0x000000ff) << 24))) : _OSSwapInt32((uint32_t)x));
}

static __inline__ __attribute__((deprecated))
NXSwappedDouble
NXSwapDouble(NXSwappedDouble x)
{
    return (NXSwappedDouble)(__builtin_constant_p((uint64_t)x) ? ((__uint64_t)((((__uint64_t)((uint64_t)x) & 0xff00000000000000ULL) >> 56) | (((__uint64_t)((uint64_t)x) & 0x00ff000000000000ULL) >> 40) | (((__uint64_t)((uint64_t)x) & 0x0000ff0000000000ULL) >> 24) | (((__uint64_t)((uint64_t)x) & 0x000000ff00000000ULL) >> 8) | (((__uint64_t)((uint64_t)x) & 0x00000000ff000000ULL) << 8) | (((__uint64_t)((uint64_t)x) & 0x0000000000ff0000ULL) << 24) | (((__uint64_t)((uint64_t)x) & 0x000000000000ff00ULL) << 40) | (((__uint64_t)((uint64_t)x) & 0x00000000000000ffULL) << 56))) : _OSSwapInt64((uint64_t)x));
}






enum NXByteOrder {
    NX_UnknownByteOrder,
    NX_LittleEndian,
    NX_BigEndian
};

static __inline__
enum NXByteOrder
NXHostByteOrder(void)
{

    return NX_LittleEndian;





}

static __inline__ __attribute__((deprecated))
unsigned short
NXSwapBigShortToHost(
    unsigned short x
)
{
    return (unsigned short)(__builtin_constant_p((uint16_t)x) ? ((__uint16_t)((((__uint16_t)((uint16_t)x) & 0xff00) >> 8) | (((__uint16_t)((uint16_t)x) & 0x00ff) << 8))) : _OSSwapInt16((uint16_t)x));
}

static __inline__ __attribute__((deprecated))
unsigned int
NXSwapBigIntToHost(
    unsigned int x
)
{
    return (unsigned int)(__builtin_constant_p((uint32_t)x) ? ((__uint32_t)((((__uint32_t)((uint32_t)x) & 0xff000000) >> 24) | (((__uint32_t)((uint32_t)x) & 0x00ff0000) >> 8) | (((__uint32_t)((uint32_t)x) & 0x0000ff00) << 8) | (((__uint32_t)((uint32_t)x) & 0x000000ff) << 24))) : _OSSwapInt32((uint32_t)x));
}

static __inline__ __attribute__((deprecated))
unsigned long
NXSwapBigLongToHost(
    unsigned long x
)
{
    return (unsigned long)(__builtin_constant_p((uint32_t)x) ? ((__uint32_t)((((__uint32_t)((uint32_t)x) & 0xff000000) >> 24) | (((__uint32_t)((uint32_t)x) & 0x00ff0000) >> 8) | (((__uint32_t)((uint32_t)x) & 0x0000ff00) << 8) | (((__uint32_t)((uint32_t)x) & 0x000000ff) << 24))) : _OSSwapInt32((uint32_t)x));
}

static __inline__ __attribute__((deprecated))
unsigned long long
NXSwapBigLongLongToHost(
    unsigned long long x
)
{
    return (unsigned long long)(__builtin_constant_p((uint64_t)x) ? ((__uint64_t)((((__uint64_t)((uint64_t)x) & 0xff00000000000000ULL) >> 56) | (((__uint64_t)((uint64_t)x) & 0x00ff000000000000ULL) >> 40) | (((__uint64_t)((uint64_t)x) & 0x0000ff0000000000ULL) >> 24) | (((__uint64_t)((uint64_t)x) & 0x000000ff00000000ULL) >> 8) | (((__uint64_t)((uint64_t)x) & 0x00000000ff000000ULL) << 8) | (((__uint64_t)((uint64_t)x) & 0x0000000000ff0000ULL) << 24) | (((__uint64_t)((uint64_t)x) & 0x000000000000ff00ULL) << 40) | (((__uint64_t)((uint64_t)x) & 0x00000000000000ffULL) << 56))) : _OSSwapInt64((uint64_t)x));
}

static __inline__ __attribute__((deprecated))
double
NXSwapBigDoubleToHost(
    NXSwappedDouble x
)
{
    return NXConvertSwappedDoubleToHost((NXSwappedDouble)(__builtin_constant_p((uint64_t)x) ? ((__uint64_t)((((__uint64_t)((uint64_t)x) & 0xff00000000000000ULL) >> 56) | (((__uint64_t)((uint64_t)x) & 0x00ff000000000000ULL) >> 40) | (((__uint64_t)((uint64_t)x) & 0x0000ff0000000000ULL) >> 24) | (((__uint64_t)((uint64_t)x) & 0x000000ff00000000ULL) >> 8) | (((__uint64_t)((uint64_t)x) & 0x00000000ff000000ULL) << 8) | (((__uint64_t)((uint64_t)x) & 0x0000000000ff0000ULL) << 24) | (((__uint64_t)((uint64_t)x) & 0x000000000000ff00ULL) << 40) | (((__uint64_t)((uint64_t)x) & 0x00000000000000ffULL) << 56))) : _OSSwapInt64((uint64_t)x)));
}

static __inline__ __attribute__((deprecated))
float
NXSwapBigFloatToHost(
    NXSwappedFloat x
)
{
    return NXConvertSwappedFloatToHost((NXSwappedFloat)(__builtin_constant_p((uint32_t)x) ? ((__uint32_t)((((__uint32_t)((uint32_t)x) & 0xff000000) >> 24) | (((__uint32_t)((uint32_t)x) & 0x00ff0000) >> 8) | (((__uint32_t)((uint32_t)x) & 0x0000ff00) << 8) | (((__uint32_t)((uint32_t)x) & 0x000000ff) << 24))) : _OSSwapInt32((uint32_t)x)));
}

static __inline__ __attribute__((deprecated))
unsigned short
NXSwapHostShortToBig(
    unsigned short x
)
{
    return (unsigned short)(__builtin_constant_p((uint16_t)x) ? ((__uint16_t)((((__uint16_t)((uint16_t)x) & 0xff00) >> 8) | (((__uint16_t)((uint16_t)x) & 0x00ff) << 8))) : _OSSwapInt16((uint16_t)x));
}

static __inline__ __attribute__((deprecated))
unsigned int
NXSwapHostIntToBig(
    unsigned int x
)
{
    return (unsigned int)(__builtin_constant_p((uint32_t)x) ? ((__uint32_t)((((__uint32_t)((uint32_t)x) & 0xff000000) >> 24) | (((__uint32_t)((uint32_t)x) & 0x00ff0000) >> 8) | (((__uint32_t)((uint32_t)x) & 0x0000ff00) << 8) | (((__uint32_t)((uint32_t)x) & 0x000000ff) << 24))) : _OSSwapInt32((uint32_t)x));
}

static __inline__ __attribute__((deprecated))
unsigned long
NXSwapHostLongToBig(
    unsigned long x
)
{
    return (unsigned long)(__builtin_constant_p((uint32_t)x) ? ((__uint32_t)((((__uint32_t)((uint32_t)x) & 0xff000000) >> 24) | (((__uint32_t)((uint32_t)x) & 0x00ff0000) >> 8) | (((__uint32_t)((uint32_t)x) & 0x0000ff00) << 8) | (((__uint32_t)((uint32_t)x) & 0x000000ff) << 24))) : _OSSwapInt32((uint32_t)x));
}

static __inline__ __attribute__((deprecated))
unsigned long long
NXSwapHostLongLongToBig(
    unsigned long long x
)
{
    return (unsigned long long)(__builtin_constant_p((uint64_t)x) ? ((__uint64_t)((((__uint64_t)((uint64_t)x) & 0xff00000000000000ULL) >> 56) | (((__uint64_t)((uint64_t)x) & 0x00ff000000000000ULL) >> 40) | (((__uint64_t)((uint64_t)x) & 0x0000ff0000000000ULL) >> 24) | (((__uint64_t)((uint64_t)x) & 0x000000ff00000000ULL) >> 8) | (((__uint64_t)((uint64_t)x) & 0x00000000ff000000ULL) << 8) | (((__uint64_t)((uint64_t)x) & 0x0000000000ff0000ULL) << 24) | (((__uint64_t)((uint64_t)x) & 0x000000000000ff00ULL) << 40) | (((__uint64_t)((uint64_t)x) & 0x00000000000000ffULL) << 56))) : _OSSwapInt64((uint64_t)x));
}

static __inline__ __attribute__((deprecated))
NXSwappedDouble
NXSwapHostDoubleToBig(
    double x
)
{
    return (NXSwappedDouble)(__builtin_constant_p((uint64_t)NXConvertHostDoubleToSwapped(x)) ? ((__uint64_t)((((__uint64_t)((uint64_t)NXConvertHostDoubleToSwapped(x)) & 0xff00000000000000ULL) >> 56) | (((__uint64_t)((uint64_t)NXConvertHostDoubleToSwapped(x)) & 0x00ff000000000000ULL) >> 40) | (((__uint64_t)((uint64_t)NXConvertHostDoubleToSwapped(x)) & 0x0000ff0000000000ULL) >> 24) | (((__uint64_t)((uint64_t)NXConvertHostDoubleToSwapped(x)) & 0x000000ff00000000ULL) >> 8) | (((__uint64_t)((uint64_t)NXConvertHostDoubleToSwapped(x)) & 0x00000000ff000000ULL) << 8) | (((__uint64_t)((uint64_t)NXConvertHostDoubleToSwapped(x)) & 0x0000000000ff0000ULL) << 24) | (((__uint64_t)((uint64_t)NXConvertHostDoubleToSwapped(x)) & 0x000000000000ff00ULL) << 40) | (((__uint64_t)((uint64_t)NXConvertHostDoubleToSwapped(x)) & 0x00000000000000ffULL) << 56))) : _OSSwapInt64((uint64_t)NXConvertHostDoubleToSwapped(x)));
}

static __inline__ __attribute__((deprecated))
NXSwappedFloat
NXSwapHostFloatToBig(
    float x
)
{
    return (NXSwappedFloat)(__builtin_constant_p((uint32_t)NXConvertHostFloatToSwapped(x)) ? ((__uint32_t)((((__uint32_t)((uint32_t)NXConvertHostFloatToSwapped(x)) & 0xff000000) >> 24) | (((__uint32_t)((uint32_t)NXConvertHostFloatToSwapped(x)) & 0x00ff0000) >> 8) | (((__uint32_t)((uint32_t)NXConvertHostFloatToSwapped(x)) & 0x0000ff00) << 8) | (((__uint32_t)((uint32_t)NXConvertHostFloatToSwapped(x)) & 0x000000ff) << 24))) : _OSSwapInt32((uint32_t)NXConvertHostFloatToSwapped(x)));
}

static __inline__ __attribute__((deprecated))
unsigned short
NXSwapLittleShortToHost(
    unsigned short x
)
{
    return (unsigned short)((uint16_t)((uint16_t)x));
}

static __inline__ __attribute__((deprecated))
unsigned int
NXSwapLittleIntToHost(
    unsigned int x
)
{
    return (unsigned int)((uint32_t)((uint32_t)x));
}

static __inline__ __attribute__((deprecated))
unsigned long
NXSwapLittleLongToHost(
    unsigned long x
)
{
    return (unsigned long)((uint32_t)((uint32_t)x));
}

static __inline__ __attribute__((deprecated))
unsigned long long
NXSwapLittleLongLongToHost(
    unsigned long long x
)
{
    return (unsigned long long)((uint64_t)((uint64_t)x));
}

static __inline__ __attribute__((deprecated))
double
NXSwapLittleDoubleToHost(
    NXSwappedDouble x
)
{
    return NXConvertSwappedDoubleToHost((NXSwappedDouble)((uint64_t)((uint64_t)x)));
}

static __inline__ __attribute__((deprecated))
float
NXSwapLittleFloatToHost(
    NXSwappedFloat x
)
{
    return NXConvertSwappedFloatToHost((NXSwappedFloat)((uint32_t)((uint32_t)x)));
}

static __inline__ __attribute__((deprecated))
unsigned short
NXSwapHostShortToLittle(
    unsigned short x
)
{
    return (unsigned short)((uint16_t)((uint16_t)x));
}

static __inline__ __attribute__((deprecated))
unsigned int
NXSwapHostIntToLittle(
    unsigned int x
)
{
    return (unsigned int)((uint32_t)((uint32_t)x));
}

static __inline__ __attribute__((deprecated))
unsigned long
NXSwapHostLongToLittle(
    unsigned long x
)
{
    return (unsigned long)((uint32_t)((uint32_t)x));
}

static __inline__ __attribute__((deprecated))
unsigned long long
NXSwapHostLongLongToLittle(
    unsigned long long x
)
{
    return (unsigned long long)((uint64_t)((uint64_t)x));
}

static __inline__ __attribute__((deprecated))
NXSwappedDouble
NXSwapHostDoubleToLittle(
    double x
)
{
    return (NXSwappedDouble)((uint64_t)((uint64_t)NXConvertHostDoubleToSwapped(x)));
}

static __inline__ __attribute__((deprecated))
NXSwappedFloat
NXSwapHostFloatToLittle(
    float x
)
{
    return (NXSwappedFloat)((uint32_t)((uint32_t)NXConvertHostFloatToSwapped(x)));
}
# 49 "./../include/mach-o/loader.h" 2





struct mach_header {
 uint32_t magic;
 cpu_type_t cputype;
 cpu_subtype_t cpusubtype;
 uint32_t filetype;
 uint32_t ncmds;
 uint32_t sizeofcmds;
 uint32_t flags;
};
# 72 "./../include/mach-o/loader.h"
struct mach_header_64 {
 uint32_t magic;
 cpu_type_t cputype;
 cpu_subtype_t cpusubtype;
 uint32_t filetype;
 uint32_t ncmds;
 uint32_t sizeofcmds;
 uint32_t flags;
 uint32_t reserved;
};
# 227 "./../include/mach-o/loader.h"
struct load_command {
 uint32_t cmd;
 uint32_t cmdsize;
};
# 307 "./../include/mach-o/loader.h"
union lc_str {
 uint32_t offset;



};
# 326 "./../include/mach-o/loader.h"
struct segment_command {
 uint32_t cmd;
 uint32_t cmdsize;
 char segname[16];
 uint32_t vmaddr;
 uint32_t vmsize;
 uint32_t fileoff;
 uint32_t filesize;
 vm_prot_t maxprot;
 vm_prot_t initprot;
 uint32_t nsects;
 uint32_t flags;
};







struct segment_command_64 {
 uint32_t cmd;
 uint32_t cmdsize;
 char segname[16];
 uint64_t vmaddr;
 uint64_t vmsize;
 uint64_t fileoff;
 uint64_t filesize;
 vm_prot_t maxprot;
 vm_prot_t initprot;
 uint32_t nsects;
 uint32_t flags;
};
# 403 "./../include/mach-o/loader.h"
struct section {
 char sectname[16];
 char segname[16];
 uint32_t addr;
 uint32_t size;
 uint32_t offset;
 uint32_t align;
 uint32_t reloff;
 uint32_t nreloc;
 uint32_t flags;
 uint32_t reserved1;
 uint32_t reserved2;
};

struct section_64 {
 char sectname[16];
 char segname[16];
 uint64_t addr;
 uint64_t size;
 uint32_t offset;
 uint32_t align;
 uint32_t reloff;
 uint32_t nreloc;
 uint32_t flags;
 uint32_t reserved1;
 uint32_t reserved2;
 uint32_t reserved3;
};
# 605 "./../include/mach-o/loader.h"
struct fvmlib {
 union lc_str name;
 uint32_t minor_version;
 uint32_t header_addr;
};
# 618 "./../include/mach-o/loader.h"
struct fvmlib_command {
 uint32_t cmd;
 uint32_t cmdsize;
 struct fvmlib fvmlib;
};
# 633 "./../include/mach-o/loader.h"
struct dylib {
    union lc_str name;
    uint32_t timestamp;
    uint32_t current_version;
    uint32_t compatibility_version;
};
# 647 "./../include/mach-o/loader.h"
struct dylib_command {
 uint32_t cmd;

 uint32_t cmdsize;
 struct dylib dylib;
};
# 664 "./../include/mach-o/loader.h"
struct sub_framework_command {
 uint32_t cmd;
 uint32_t cmdsize;
 union lc_str umbrella;
};
# 679 "./../include/mach-o/loader.h"
struct sub_client_command {
 uint32_t cmd;
 uint32_t cmdsize;
 union lc_str client;
};
# 698 "./../include/mach-o/loader.h"
struct sub_umbrella_command {
 uint32_t cmd;
 uint32_t cmdsize;
 union lc_str sub_umbrella;
};
# 719 "./../include/mach-o/loader.h"
struct sub_library_command {
 uint32_t cmd;
 uint32_t cmdsize;
 union lc_str sub_library;
};
# 734 "./../include/mach-o/loader.h"
struct prebound_dylib_command {
 uint32_t cmd;
 uint32_t cmdsize;
 union lc_str name;
 uint32_t nmodules;
 union lc_str linked_modules;
};
# 750 "./../include/mach-o/loader.h"
struct dylinker_command {
 uint32_t cmd;

 uint32_t cmdsize;
 union lc_str name;
};
# 778 "./../include/mach-o/loader.h"
struct thread_command {
 uint32_t cmd;
 uint32_t cmdsize;




};
# 795 "./../include/mach-o/loader.h"
struct routines_command {
 uint32_t cmd;
 uint32_t cmdsize;
 uint32_t init_address;
 uint32_t init_module;

 uint32_t reserved1;
 uint32_t reserved2;
 uint32_t reserved3;
 uint32_t reserved4;
 uint32_t reserved5;
 uint32_t reserved6;
};




struct routines_command_64 {
 uint32_t cmd;
 uint32_t cmdsize;
 uint64_t init_address;
 uint64_t init_module;

 uint64_t reserved1;
 uint64_t reserved2;
 uint64_t reserved3;
 uint64_t reserved4;
 uint64_t reserved5;
 uint64_t reserved6;
};






struct symtab_command {
 uint32_t cmd;
 uint32_t cmdsize;
 uint32_t symoff;
 uint32_t nsyms;
 uint32_t stroff;
 uint32_t strsize;
};
# 880 "./../include/mach-o/loader.h"
struct dysymtab_command {
    uint32_t cmd;
    uint32_t cmdsize;
# 899 "./../include/mach-o/loader.h"
    uint32_t ilocalsym;
    uint32_t nlocalsym;

    uint32_t iextdefsym;
    uint32_t nextdefsym;

    uint32_t iundefsym;
    uint32_t nundefsym;
# 916 "./../include/mach-o/loader.h"
    uint32_t tocoff;
    uint32_t ntoc;
# 928 "./../include/mach-o/loader.h"
    uint32_t modtaboff;
    uint32_t nmodtab;
# 940 "./../include/mach-o/loader.h"
    uint32_t extrefsymoff;
    uint32_t nextrefsyms;
# 953 "./../include/mach-o/loader.h"
    uint32_t indirectsymoff;
    uint32_t nindirectsyms;
# 983 "./../include/mach-o/loader.h"
    uint32_t extreloff;
    uint32_t nextrel;






    uint32_t locreloff;
    uint32_t nlocrel;

};
# 1008 "./../include/mach-o/loader.h"
struct dylib_table_of_contents {
    uint32_t symbol_index;

    uint32_t module_index;

};


struct dylib_module {
    uint32_t module_name;

    uint32_t iextdefsym;
    uint32_t nextdefsym;
    uint32_t irefsym;
    uint32_t nrefsym;
    uint32_t ilocalsym;
    uint32_t nlocalsym;

    uint32_t iextrel;
    uint32_t nextrel;

    uint32_t iinit_iterm;


    uint32_t ninit_nterm;



    uint32_t
 objc_module_info_addr;
    uint32_t
 objc_module_info_size;
};


struct dylib_module_64 {
    uint32_t module_name;

    uint32_t iextdefsym;
    uint32_t nextdefsym;
    uint32_t irefsym;
    uint32_t nrefsym;
    uint32_t ilocalsym;
    uint32_t nlocalsym;

    uint32_t iextrel;
    uint32_t nextrel;

    uint32_t iinit_iterm;


    uint32_t ninit_nterm;



    uint32_t
        objc_module_info_size;
    uint64_t
        objc_module_info_addr;
};
# 1077 "./../include/mach-o/loader.h"
struct dylib_reference {
    uint32_t isym:24,
        flags:8;
};





struct twolevel_hints_command {
    uint32_t cmd;
    uint32_t cmdsize;
    uint32_t offset;
    uint32_t nhints;
};
# 1109 "./../include/mach-o/loader.h"
struct twolevel_hint {
    uint32_t
 isub_image:8,
 itoc:24;
};
# 1125 "./../include/mach-o/loader.h"
struct prebind_cksum_command {
    uint32_t cmd;
    uint32_t cmdsize;
    uint32_t cksum;
};





struct uuid_command {
    uint32_t cmd;
    uint32_t cmdsize;
    uint8_t uuid[16];
};





struct rpath_command {
    uint32_t cmd;
    uint32_t cmdsize;
    union lc_str path;
};





struct linkedit_data_command {
    uint32_t cmd;


    uint32_t cmdsize;
    uint32_t dataoff;
    uint32_t datasize;
};





struct encryption_info_command {
   uint32_t cmd;
   uint32_t cmdsize;
   uint32_t cryptoff;
   uint32_t cryptsize;
   uint32_t cryptid;

};





struct version_min_command {
    uint32_t cmd;

    uint32_t cmdsize;
    uint32_t version;
    uint32_t sdk;
};
# 1197 "./../include/mach-o/loader.h"
struct dyld_info_command {
   uint32_t cmd;
   uint32_t cmdsize;
# 1212 "./../include/mach-o/loader.h"
    uint32_t rebase_off;
    uint32_t rebase_size;
# 1227 "./../include/mach-o/loader.h"
    uint32_t bind_off;
    uint32_t bind_size;
# 1245 "./../include/mach-o/loader.h"
    uint32_t weak_bind_off;
    uint32_t weak_bind_size;
# 1260 "./../include/mach-o/loader.h"
    uint32_t lazy_bind_off;
    uint32_t lazy_bind_size;
# 1296 "./../include/mach-o/loader.h"
    uint32_t export_off;
    uint32_t export_size;
};
# 1371 "./../include/mach-o/loader.h"
struct symseg_command {
 uint32_t cmd;
 uint32_t cmdsize;
 uint32_t offset;
 uint32_t size;
};







struct ident_command {
 uint32_t cmd;
 uint32_t cmdsize;
};







struct fvmfile_command {
 uint32_t cmd;
 uint32_t cmdsize;
 union lc_str name;
 uint32_t header_addr;
};
# 1409 "./../include/mach-o/loader.h"
struct entry_point_command {
    uint32_t cmd;
    uint32_t cmdsize;
    uint64_t entryoff;
    uint64_t stacksize;
};






struct source_version_command {
    uint32_t cmd;
    uint32_t cmdsize;
    uint64_t version;
};
# 1434 "./../include/mach-o/loader.h"
struct data_in_code_entry {
    uint32_t offset;
    uint16_t length;
    uint16_t kind;
};
# 1451 "./../include/mach-o/loader.h"
struct tlv_descriptor
{
 void* (*thunk)(struct tlv_descriptor*);
 unsigned long key;
 unsigned long offset;
};
# 34 "print_objc.c" 2
# 1 "/usr/include/objc/objc-runtime.h" 1 3 4
# 1 "/opt/local/include/objc/runtime.h" 1 3 4
# 29 "/opt/local/include/objc/runtime.h" 3 4
# 1 "/usr/lib/clang/1.5/include/stdarg.h" 1 3 4
# 48 "/usr/lib/clang/1.5/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 30 "/opt/local/include/objc/runtime.h" 2 3 4


# 1 "/usr/include/ctype.h" 1 3 4
# 69 "/usr/include/ctype.h" 3 4
# 1 "/usr/include/runetype.h" 1 3 4
# 53 "/usr/include/runetype.h" 3 4
typedef __darwin_ct_rune_t ct_rune_t;




typedef __darwin_rune_t rune_t;





typedef __darwin_wchar_t wchar_t;





typedef __darwin_wint_t wint_t;
# 81 "/usr/include/runetype.h" 3 4
typedef struct {
 __darwin_rune_t __min;
 __darwin_rune_t __max;
 __darwin_rune_t __map;
 __uint32_t *__types;
} _RuneEntry;

typedef struct {
 int __nranges;
 _RuneEntry *__ranges;
} _RuneRange;

typedef struct {
 char __name[14];
 __uint32_t __mask;
} _RuneCharClass;

typedef struct {
 char __magic[8];
 char __encoding[32];

 __darwin_rune_t (*__sgetrune)(const char *, __darwin_size_t, char const **);
 int (*__sputrune)(__darwin_rune_t, char *, __darwin_size_t, char **);
 __darwin_rune_t __invalid_rune;

 __uint32_t __runetype[(1 <<8 )];
 __darwin_rune_t __maplower[(1 <<8 )];
 __darwin_rune_t __mapupper[(1 <<8 )];






 _RuneRange __runetype_ext;
 _RuneRange __maplower_ext;
 _RuneRange __mapupper_ext;

 void *__variable;
 int __variable_len;




 int __ncharclasses;
 _RuneCharClass *__charclasses;
} _RuneLocale;




extern _RuneLocale _DefaultRuneLocale;
extern _RuneLocale *_CurrentRuneLocale;
# 70 "/usr/include/ctype.h" 2 3 4
# 146 "/usr/include/ctype.h" 3 4
unsigned long ___runetype(__darwin_ct_rune_t);
__darwin_ct_rune_t ___tolower(__darwin_ct_rune_t);
__darwin_ct_rune_t ___toupper(__darwin_ct_rune_t);


static __inline int
isascii(int _c)
{
 return ((_c & ~0x7F) == 0);
}
# 165 "/usr/include/ctype.h" 3 4
int __maskrune(__darwin_ct_rune_t, unsigned long);



static __inline int
__istype(__darwin_ct_rune_t _c, unsigned long _f)
{



 return (isascii(_c) ? !!(_DefaultRuneLocale.__runetype[_c] & _f)
  : !!__maskrune(_c, _f));

}

static __inline __darwin_ct_rune_t
__isctype(__darwin_ct_rune_t _c, unsigned long _f)
{



 return (_c < 0 || _c >= (1 <<8 )) ? 0 :
  !!(_DefaultRuneLocale.__runetype[_c] & _f);

}
# 205 "/usr/include/ctype.h" 3 4
__darwin_ct_rune_t __toupper(__darwin_ct_rune_t);
__darwin_ct_rune_t __tolower(__darwin_ct_rune_t);



static __inline int
__wcwidth(__darwin_ct_rune_t _c)
{
 unsigned int _x;

 if (_c == 0)
  return (0);
 _x = (unsigned int)__maskrune(_c, 0xe0000000L|0x00040000L);
 if ((_x & 0xe0000000L) != 0)
  return ((_x & 0xe0000000L) >> 30);
 return ((_x & 0x00040000L) != 0 ? 1 : -1);
}






static __inline int
isalnum(int _c)
{
 return (__istype(_c, 0x00000100L|0x00000400L));
}

static __inline int
isalpha(int _c)
{
 return (__istype(_c, 0x00000100L));
}

static __inline int
isblank(int _c)
{
 return (__istype(_c, 0x00020000L));
}

static __inline int
iscntrl(int _c)
{
 return (__istype(_c, 0x00000200L));
}


static __inline int
isdigit(int _c)
{
 return (__isctype(_c, 0x00000400L));
}

static __inline int
isgraph(int _c)
{
 return (__istype(_c, 0x00000800L));
}

static __inline int
islower(int _c)
{
 return (__istype(_c, 0x00001000L));
}

static __inline int
isprint(int _c)
{
 return (__istype(_c, 0x00040000L));
}

static __inline int
ispunct(int _c)
{
 return (__istype(_c, 0x00002000L));
}

static __inline int
isspace(int _c)
{
 return (__istype(_c, 0x00004000L));
}

static __inline int
isupper(int _c)
{
 return (__istype(_c, 0x00008000L));
}


static __inline int
isxdigit(int _c)
{
 return (__isctype(_c, 0x00010000L));
}

static __inline int
toascii(int _c)
{
 return (_c & 0x7F);
}

static __inline int
tolower(int _c)
{
        return (__tolower(_c));
}

static __inline int
toupper(int _c)
{
        return (__toupper(_c));
}


static __inline int
digittoint(int _c)
{
 return (__maskrune(_c, 0x0F));
}

static __inline int
ishexnumber(int _c)
{
 return (__istype(_c, 0x00010000L));
}

static __inline int
isideogram(int _c)
{
 return (__istype(_c, 0x00080000L));
}

static __inline int
isnumber(int _c)
{
 return (__istype(_c, 0x00000400L));
}

static __inline int
isphonogram(int _c)
{
 return (__istype(_c, 0x00200000L));
}

static __inline int
isrune(int _c)
{
 return (__istype(_c, 0xFFFFFFF0L));
}

static __inline int
isspecial(int _c)
{
 return (__istype(_c, 0x00100000L));
}
# 33 "/opt/local/include/objc/runtime.h" 2 3 4

# 1 "/usr/lib/clang/1.5/include/stddef.h" 1 3 4
# 29 "/usr/lib/clang/1.5/include/stddef.h" 3 4
typedef __typeof__(((int*)0)-((int*)0)) ptrdiff_t;
# 35 "/opt/local/include/objc/runtime.h" 2 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 36 "/opt/local/include/objc/runtime.h" 2 3 4

# 1 "/opt/local/include/objc/objc.h" 1 3 4
# 42 "/opt/local/include/objc/objc.h" 3 4
typedef unsigned char BOOL;
# 51 "/opt/local/include/objc/objc.h" 3 4
typedef const struct objc_selector
{
  void *sel_id;
  const char *sel_types;
} *SEL;

inline static BOOL
sel_eq (SEL s1, SEL s2)
{
  if (s1 == 0 || s2 == 0)
    return s1 == s2;
  else
    return s1->sel_id == s2->sel_id;
}





typedef struct objc_object {
  struct objc_class* class_pointer;
} *id;





typedef id (*IMP)(id, SEL, ...);






typedef char *STR;
# 97 "/opt/local/include/objc/objc.h" 3 4
typedef struct objc_class *MetaClass;
typedef struct objc_class *Class;
struct objc_class {
  MetaClass class_pointer;

  struct objc_class* super_class;


  const char* name;
  long version;
  unsigned long info;

  long instance_size;



  struct objc_ivar_list* ivars;






  struct objc_method_list* methods;


  struct sarray * dtable;

  struct objc_class* subclass_list;
  struct objc_class* sibling_class;

  struct objc_protocol_list *protocols;
  void* gc_object_type;
};


typedef struct objc_protocol {
  struct objc_class* class_pointer;
  char *protocol_name;
  struct objc_protocol_list *protocol_list;
  struct objc_method_description_list *instance_methods, *class_methods;
} Protocol;





typedef void* retval_t;
typedef void(*apply_t)(void);
typedef union {
  char *arg_ptr;
  char arg_regs[sizeof (char*)];
} *arglist_t;


IMP objc_msg_lookup (id receiver, SEL op);
# 38 "/opt/local/include/objc/runtime.h" 2 3 4
# 1 "/opt/local/include/objc/objc-api.h" 1 3 4
# 35 "/opt/local/include/objc/objc-api.h" 3 4
# 1 "/opt/local/include/objc/hash.h" 1 3 4
# 33 "/opt/local/include/objc/hash.h" 3 4
# 1 "/opt/local/include/objc/externvar.h" 1 3 4
# 34 "/opt/local/include/objc/hash.h" 2 3 4
# 43 "/opt/local/include/objc/hash.h" 3 4
typedef struct cache_node
{
  struct cache_node *next;

  const void *key;



  void *value;
} *node_ptr;
# 64 "/opt/local/include/objc/hash.h" 3 4
typedef unsigned int (*hash_func_type)(void *, const void *);
# 73 "/opt/local/include/objc/hash.h" 3 4
typedef int (*compare_func_type)(const void *, const void *);
# 82 "/opt/local/include/objc/hash.h" 3 4
typedef struct
{

  node_ptr *node_table;


  unsigned int size;


  unsigned int used;
  unsigned int mask;



  unsigned int last_bucket;



  hash_func_type hash_func;

  compare_func_type compare_func;
} cache_t;

typedef cache_t *cache_ptr;



extern cache_ptr module_hash_table, class_hash_table;



cache_ptr hash_new (unsigned int size,
      hash_func_type hash_func,
      compare_func_type compare_func);



void hash_delete (cache_ptr cache);






void hash_add (cache_ptr *cachep, const void *key, void *value);




void hash_remove (cache_ptr cache, const void *key);
# 142 "/opt/local/include/objc/hash.h" 3 4
node_ptr hash_next (cache_ptr cache, node_ptr node);



void *hash_value_for_key (cache_ptr cache, const void *key);



BOOL hash_is_key_in_hash (cache_ptr cache, const void *key);
# 164 "/opt/local/include/objc/hash.h" 3 4
static inline unsigned int
hash_ptr (cache_ptr cache, const void *key)
{
  return ((size_t)key / sizeof (void *)) & cache->mask;
}





static inline unsigned int
hash_string (cache_ptr cache, const void *key)
{
  unsigned int ret = 0;
  unsigned int ctr = 0;


  while (*(char*)key) {
    ret ^= *(char*)key++ << ctr;
    ctr = (ctr + 1) % sizeof (void *);
  }

  return ret & cache->mask;
}



static inline int
compare_ptrs (const void *k1, const void *k2)
{
  return !(k1 - k2);
}



static inline int
compare_strings (const void *k1, const void *k2)
{
  if (k1 == k2)
    return 1;
  else if (k1 == 0 || k2 == 0)
    return 0;
  else
    return !strcmp (k1, k2);
}
# 36 "/opt/local/include/objc/objc-api.h" 2 3 4
# 1 "/opt/local/include/objc/thr.h" 1 3 4
# 47 "/opt/local/include/objc/thr.h" 3 4
extern int __objc_thread_exit_status;
# 59 "/opt/local/include/objc/thr.h" 3 4
typedef void * objc_thread_t;


struct objc_mutex
{
  volatile objc_thread_t owner;
  volatile int depth;
  void * backend;
};
typedef struct objc_mutex *objc_mutex_t;


struct objc_condition
{
  void * backend;
};
typedef struct objc_condition *objc_condition_t;


objc_mutex_t objc_mutex_allocate(void);
int objc_mutex_deallocate(objc_mutex_t mutex);
int objc_mutex_lock(objc_mutex_t mutex);
int objc_mutex_unlock(objc_mutex_t mutex);
int objc_mutex_trylock(objc_mutex_t mutex);


objc_condition_t objc_condition_allocate(void);
int objc_condition_deallocate(objc_condition_t condition);
int objc_condition_wait(objc_condition_t condition, objc_mutex_t mutex);
int objc_condition_signal(objc_condition_t condition);
int objc_condition_broadcast(objc_condition_t condition);


objc_thread_t objc_thread_detach(SEL selector, id object, id argument);
void objc_thread_yield(void);
int objc_thread_exit(void);
int objc_thread_set_priority(int priority);
int objc_thread_get_priority(void);
void * objc_thread_get_data(void);
int objc_thread_set_data(void *value);
objc_thread_t objc_thread_id(void);
# 113 "/opt/local/include/objc/thr.h" 3 4
typedef void (*objc_thread_callback)();
objc_thread_callback objc_set_thread_callback(objc_thread_callback func);


int __objc_init_thread_system(void);
int __objc_fini_thread_system(void);


int __objc_mutex_allocate(objc_mutex_t mutex);
int __objc_mutex_deallocate(objc_mutex_t mutex);
int __objc_mutex_lock(objc_mutex_t mutex);
int __objc_mutex_trylock(objc_mutex_t mutex);
int __objc_mutex_unlock(objc_mutex_t mutex);


int __objc_condition_allocate(objc_condition_t condition);
int __objc_condition_deallocate(objc_condition_t condition);
int __objc_condition_wait(objc_condition_t condition, objc_mutex_t mutex);
int __objc_condition_broadcast(objc_condition_t condition);
int __objc_condition_signal(objc_condition_t condition);


objc_thread_t __objc_thread_detach(void (*func)(void *arg), void *arg);
int __objc_thread_set_priority(int priority);
int __objc_thread_get_priority(void);
void __objc_thread_yield(void);
int __objc_thread_exit(void);
objc_thread_t __objc_thread_id(void);
int __objc_thread_set_data(void *value);
void * __objc_thread_get_data(void);
# 37 "/opt/local/include/objc/objc-api.h" 2 3 4
# 50 "/opt/local/include/objc/objc-api.h" 3 4
struct objc_method_description
{
    SEL name;
    char *types;
};
# 106 "/opt/local/include/objc/objc-api.h" 3 4
extern void objc_error (id object, int code, const char* fmt, ...);
extern void objc_verror (id object, int code, const char* fmt, va_list ap);
typedef BOOL (*objc_error_handler) (id, int code, const char *fmt, va_list ap);
objc_error_handler objc_set_error_handler (objc_error_handler func);
# 147 "/opt/local/include/objc/objc-api.h" 3 4
struct objc_static_instances
{
  char *class_name;
  id instances[0];
};
# 162 "/opt/local/include/objc/objc-api.h" 3 4
typedef struct objc_symtab {
  unsigned long sel_ref_cnt;
  SEL refs;
  unsigned short cls_def_cnt;

  unsigned short cat_def_cnt;



  void *defs[1];





} Symtab, *Symtab_t;
# 189 "/opt/local/include/objc/objc-api.h" 3 4
typedef struct objc_module {
  unsigned long version;
  unsigned long size;
  const char* name;



  Symtab_t symtab;





} Module, *Module_t;






typedef struct objc_ivar* Ivar_t;
typedef struct objc_ivar_list {
  int ivar_count;




  struct objc_ivar {
    const char* ivar_name;


    const char* ivar_type;


    int ivar_offset;



  } ivar_list[1];

} IvarList, *IvarList_t;
# 240 "/opt/local/include/objc/objc-api.h" 3 4
struct objc_method {
  SEL method_name;





  const char* method_types;


  IMP method_imp;

};

typedef struct objc_method Method;

typedef Method* Method_t;
typedef struct objc_method_list {
  struct objc_method_list* method_next;


  int method_count;

  struct objc_method method_list[1];

} MethodList, *MethodList_t;

struct objc_protocol_list {
  struct objc_protocol_list *next;
  int count;
  Protocol *list[1];
};
# 324 "/opt/local/include/objc/objc-api.h" 3 4
typedef struct objc_category {
  const char* category_name;


  const char* class_name;

  MethodList_t instance_methods;



  MethodList_t class_methods;



  struct objc_protocol_list *protocols;

} Category, *Category_t;






typedef struct objc_super {
  id self;

  Class class_type;
} Super, *Super_t;

IMP objc_msg_lookup_super(Super_t super, SEL sel);

retval_t objc_msg_sendv(id, SEL, arglist_t);
# 364 "/opt/local/include/objc/objc-api.h" 3 4
extern Class (*_objc_lookup_class) (const char *name);







extern void (*_objc_load_callback) (Class class_type, Category* category);




extern id (*_objc_object_alloc) (Class class_type);
extern id (*_objc_object_copy) (id object);
extern id (*_objc_object_dispose) (id object);







void *objc_malloc (size_t size);

void *objc_atomic_malloc (size_t size);

void *objc_valloc (size_t size);

void *objc_realloc (void *mem, size_t size);

void *objc_calloc (size_t nelem, size_t size);

void objc_free (void *mem);
# 409 "/opt/local/include/objc/objc-api.h" 3 4
extern void *(*_objc_malloc) (size_t);
extern void *(*_objc_atomic_malloc) (size_t);
extern void *(*_objc_valloc) (size_t);
extern void *(*_objc_realloc) (void *, size_t);
extern void *(*_objc_calloc) (size_t, size_t);
extern void (*_objc_free) (void *);

Method_t class_get_class_method (MetaClass class_type, SEL aSel);

Method_t class_get_instance_method (Class class_type, SEL aSel);

Class class_pose_as (Class impostor, Class superclass);

Class objc_get_class (const char *name);

Class objc_lookup_class (const char *name);

Class objc_next_class (void **enum_state);

const char *sel_get_name (SEL selector);

const char *sel_get_type (SEL selector);

SEL sel_get_uid (const char *name);

SEL sel_get_any_uid (const char *name);

SEL sel_get_any_typed_uid (const char *name);

SEL sel_get_typed_uid (const char *name, const char*);

SEL sel_register_name (const char *name);

SEL sel_register_typed_name (const char *name, const char*type);


BOOL sel_is_mapped (SEL aSel);

extern id class_create_instance (Class class_type);

static inline const char *
class_get_class_name (Class class_type)
{
  return ((class_type)&&((((class_type)->info) & 0x1L) == 0x1L))?class_type->name:((class_type==(Class)0)?"Nil":0);
}

static inline long
class_get_instance_size (Class class_type)
{
  return ((class_type)&&((((class_type)->info) & 0x1L) == 0x1L)) ? class_type->instance_size : 0;
}

static inline MetaClass
class_get_meta_class (Class class_type)
{
  return ((class_type)&&((((class_type)->info) & 0x1L) == 0x1L)) ? class_type->class_pointer : (Class)0;
}

static inline Class
class_get_super_class (Class class_type)
{
  return ((class_type)&&((((class_type)->info) & 0x1L) == 0x1L)) ? class_type->super_class : (Class)0;
}

static inline int
class_get_version (Class class_type)
{
  return ((class_type)&&((((class_type)->info) & 0x1L) == 0x1L)) ? class_type->version : -1;
}

static inline BOOL
class_is_class (Class class_type)
{
  return ((class_type)&&((((class_type)->info) & 0x1L) == 0x1L));
}

static inline BOOL
class_is_meta_class (Class class_type)
{
  return ((class_type)&&((((class_type)->info) & 0x2L) == 0x2L));
}


static inline void
class_set_version (Class class_type, long version)
{
  if (((class_type)&&((((class_type)->info) & 0x1L) == 0x1L)))
    class_type->version = version;
}

static inline void *
class_get_gc_object_type (Class class_type)
{
  return ((class_type)&&((((class_type)->info) & 0x1L) == 0x1L)) ? class_type->gc_object_type : ((void*)0);
}


extern void class_ivar_set_gcinvisible (Class class_type,
     const char* ivarname,
     BOOL gcInvisible);

static inline IMP
method_get_imp (Method_t method)
{
  return (method != (Method_t)0) ? method->method_imp : (IMP) 0;
}

IMP get_imp (Class class_type, SEL sel);







id object_copy (id object);

id object_dispose (id object);

static inline Class
object_get_class (id object)
{
  return ((object != (id)0)
   ? (((object->class_pointer)&&((((object->class_pointer)->info) & 0x1L) == 0x1L))
      ? object->class_pointer
      : (((object->class_pointer)&&((((object->class_pointer)->info) & 0x2L) == 0x2L))
  ? (Class) object
  : (Class)0))
   : (Class)0);
}

static inline const char *
object_get_class_name (id object)
{
  return ((object!=(id)0) ? (((object->class_pointer)&&((((object->class_pointer)->info) & 0x1L) == 0x1L))
                         ? object->class_pointer->name
                         : ((Class) object)->name)
                       :"Nil");
}

static inline MetaClass
object_get_meta_class(id object)
{
  return ((object!=(id)0) ? (((object->class_pointer)&&((((object->class_pointer)->info) & 0x1L) == 0x1L))
                           ? object->class_pointer->class_pointer
                           : (((object->class_pointer)&&((((object->class_pointer)->info) & 0x2L) == 0x2L))
                              ? object->class_pointer
                              :(Class)0))
          : (Class)0);
}

static inline Class
object_get_super_class (id object)
{
  return ((object!=(id)0) ? (((object->class_pointer)&&((((object->class_pointer)->info) & 0x1L) == 0x1L))
                           ? object->class_pointer->super_class
                           : (((object->class_pointer)&&((((object->class_pointer)->info) & 0x2L) == 0x2L))
                           ?((Class) object)->super_class
                              : (Class)0))
          : (Class)0);
}

static inline BOOL
object_is_class (id object)
{
  return (((Class) object)&&(((((Class) object)->info) & 0x1L) == 0x1L));
}

static inline BOOL
object_is_instance(id object)
{
  return (object != (id)0) && ((object->class_pointer)&&((((object->class_pointer)->info) & 0x1L) == 0x1L));
}

static inline BOOL
object_is_meta_class (id object)
{
  return (((Class) object)&&(((((Class) object)->info) & 0x2L) == 0x2L));
}

struct sarray* objc_get_uninstalled_dtable (void);
# 39 "/opt/local/include/objc/runtime.h" 2 3 4




# 1 "/opt/local/include/objc/objc-list.h" 1 3 4
# 31 "/opt/local/include/objc/objc-list.h" 3 4
struct objc_list {
  void *head;
  struct objc_list *tail;
};



static inline struct objc_list*
list_cons(void* head, struct objc_list* tail)
{
  struct objc_list* cell;

  cell = (struct objc_list*)objc_malloc(sizeof(struct objc_list));
  cell->head = head;
  cell->tail = tail;
  return cell;
}



static inline int
list_length(struct objc_list* list)
{
  int i = 0;
  while(list)
    {
      i += 1;
      list = list->tail;
    }
  return i;
}




static inline void*
list_nth(int index, struct objc_list* list)
{
  while(index-- != 0)
    {
      if(list->tail)
 list = list->tail;
      else
 return 0;
    }
  return list->head;
}



static inline void
list_remove_head(struct objc_list** list)
{
  if ((*list)->tail)
    {
      struct objc_list* tail = (*list)->tail;
      *(*list) = *tail;
      objc_free(tail);
    }
  else
    {
      objc_free(*list);
      (*list) = 0;
    }
}




static inline void
list_remove_elem(struct objc_list** list, void* elem)
{
  while (*list) {
    if ((*list)->head == elem)
      list_remove_head(list);
    list = &((*list)->tail);
  }
}



static inline void
list_mapcar(struct objc_list* list, void(*function)(void*))
{
  while(list)
    {
      (*function)(list->head);
      list = list->tail;
    }
}



static inline struct objc_list**
list_find(struct objc_list** list, void* elem)
{
  while(*list)
    {
    if ((*list)->head == elem)
      return list;
    list = &((*list)->tail);
    }
  return ((void*)0);
}



static void
list_free(struct objc_list* list)
{
  if(list)
    {
      list_free(list->tail);
      objc_free(list);
    }
}
# 44 "/opt/local/include/objc/runtime.h" 2 3 4



extern void __objc_add_class_to_hash (Class);
extern void __objc_init_selector_tables (void);
extern void __objc_init_class_tables (void);
extern void __objc_init_dispatch_tables (void);
extern void __objc_install_premature_dtable (Class);
extern void __objc_resolve_class_links (void);
extern void __objc_register_selectors_from_class (Class);
extern void __objc_update_dispatch_table_for_class (Class);

extern int __objc_init_thread_system (void);
extern int __objc_fini_thread_system (void);
extern void __objc_print_dtable_stats (void);

extern void class_add_method_list (Class, MethodList_t);


extern void __objc_register_instance_methods_to_class (Class);
extern Method_t search_for_method_in_list(MethodList_t list, SEL op);


extern BOOL __objc_class_links_resolved;


extern int __objc_selector_max_index;


extern objc_mutex_t __objc_runtime_mutex;


extern int __objc_runtime_threads_alive;







BOOL __objc_responds_to (id object, SEL sel);
SEL __sel_register_typed_name (const char*, const char*,
    struct objc_selector*, BOOL is_const);
# 2 "/usr/include/objc/objc-runtime.h" 2 3 4
# 1 "/usr/include/objc/message.h" 1 3 4
# 33 "/usr/include/objc/message.h" 3 4
struct objc_super {
    id receiver;

    Class class;




};
# 53 "/usr/include/objc/message.h" 3 4
OBJC_EXPORT id objc_msgSend(id self, SEL op, ...);
OBJC_EXPORT id objc_msgSendSuper(struct objc_super *super, SEL op, ...);
# 75 "/usr/include/objc/message.h" 3 4
OBJC_EXPORT void objc_msgSend_stret(void * stretAddr, id self, SEL op, ...);
OBJC_EXPORT void objc_msgSendSuper_stret(void * stretAddr, struct objc_super *super, SEL op, ...);
# 99 "/usr/include/objc/message.h" 3 4
OBJC_EXPORT long double objc_msgSend_fpret(id self, SEL op, ...);
# 114 "/usr/include/objc/message.h" 3 4
OBJC_EXPORT id method_invoke(id receiver, Method m, ...)
     AVAILABLE_MAC_OS_X_VERSION_10_5_AND_LATER;
OBJC_EXPORT void method_invoke_stret(id receiver, Method m, ...)
     AVAILABLE_MAC_OS_X_VERSION_10_5_AND_LATER;
# 135 "/usr/include/objc/message.h" 3 4
OBJC_EXPORT id _objc_msgForward(id receiver, SEL sel, ...)
     AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER;
OBJC_EXPORT void _objc_msgForward_stret(id receiver, SEL sel, ...)
     AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER;
# 154 "/usr/include/objc/message.h" 3 4
typedef void* marg_list;

OBJC_EXPORT id objc_msgSendv(id self, SEL op, size_t arg_size, marg_list arg_frame) OBJC2_UNAVAILABLE;
OBJC_EXPORT void objc_msgSendv_stret(void *stretAddr, id self, SEL op, size_t arg_size, marg_list arg_frame) OBJC2_UNAVAILABLE;
# 3 "/usr/include/objc/objc-runtime.h" 2 3 4
# 35 "print_objc.c" 2
# 1 "./../include/stuff/allocate.h" 1
# 29 "./../include/stuff/allocate.h"
__private_extern__ void *allocate(
    size_t size);

__private_extern__ void *reallocate(
    void *,
    size_t size);

__private_extern__ char *savestr(
    const char *s);

__private_extern__ char *makestr(
    const char *args, ...);
# 36 "print_objc.c" 2
# 1 "./../include/stuff/bytesex.h" 1
# 36 "./../include/stuff/bytesex.h"
# 1 "./../include/mach-o/fat.h" 1
# 51 "./../include/mach-o/fat.h"
struct fat_header {
 uint32_t magic;
 uint32_t nfat_arch;
};

struct fat_arch {
 cpu_type_t cputype;
 cpu_subtype_t cpusubtype;
 uint32_t offset;
 uint32_t size;
 uint32_t align;
};
# 37 "./../include/stuff/bytesex.h" 2

# 1 "./../include/mach/m68k/thread_status.h" 1
# 68 "./../include/mach/m68k/thread_status.h"
struct m68k_thread_state_regs {
 int dreg[8];
 int areg[8];
 short pad0;
 short sr;
 int pc;
};




struct m68k_thread_state_68882 {
 struct {
  int fp[3];
 } regs[8];
 int cr;
 int sr;
 int iar;
 int state;
};




struct m68k_thread_state_user_reg {
 int user_reg;
};
# 39 "./../include/stuff/bytesex.h" 2




# 1 "./../include/mach/ppc/thread_status.h" 1
# 35 "./../include/mach/ppc/thread_status.h"
# 1 "./../include/mach/ppc/_structs.h" 1
# 45 "./../include/mach/ppc/_structs.h"
struct __darwin_ppc_thread_state
{
 unsigned int __srr0;
 unsigned int __srr1;
 unsigned int __r0;
 unsigned int __r1;
 unsigned int __r2;
 unsigned int __r3;
 unsigned int __r4;
 unsigned int __r5;
 unsigned int __r6;
 unsigned int __r7;
 unsigned int __r8;
 unsigned int __r9;
 unsigned int __r10;
 unsigned int __r11;
 unsigned int __r12;
 unsigned int __r13;
 unsigned int __r14;
 unsigned int __r15;
 unsigned int __r16;
 unsigned int __r17;
 unsigned int __r18;
 unsigned int __r19;
 unsigned int __r20;
 unsigned int __r21;
 unsigned int __r22;
 unsigned int __r23;
 unsigned int __r24;
 unsigned int __r25;
 unsigned int __r26;
 unsigned int __r27;
 unsigned int __r28;
 unsigned int __r29;
 unsigned int __r30;
 unsigned int __r31;

 unsigned int __cr;
 unsigned int __xer;
 unsigned int __lr;
 unsigned int __ctr;
 unsigned int __mq;

 unsigned int __vrsave;
};
# 141 "./../include/mach/ppc/_structs.h"
#pragma pack(4)




struct __darwin_ppc_thread_state64
{
 unsigned long long __srr0;
 unsigned long long __srr1;
 unsigned long long __r0;
 unsigned long long __r1;
 unsigned long long __r2;
 unsigned long long __r3;
 unsigned long long __r4;
 unsigned long long __r5;
 unsigned long long __r6;
 unsigned long long __r7;
 unsigned long long __r8;
 unsigned long long __r9;
 unsigned long long __r10;
 unsigned long long __r11;
 unsigned long long __r12;
 unsigned long long __r13;
 unsigned long long __r14;
 unsigned long long __r15;
 unsigned long long __r16;
 unsigned long long __r17;
 unsigned long long __r18;
 unsigned long long __r19;
 unsigned long long __r20;
 unsigned long long __r21;
 unsigned long long __r22;
 unsigned long long __r23;
 unsigned long long __r24;
 unsigned long long __r25;
 unsigned long long __r26;
 unsigned long long __r27;
 unsigned long long __r28;
 unsigned long long __r29;
 unsigned long long __r30;
 unsigned long long __r31;

 unsigned int __cr;
 unsigned long long __xer;
 unsigned long long __lr;
 unsigned long long __ctr;

 unsigned int __vrsave;
};
# 237 "./../include/mach/ppc/_structs.h"
#pragma pack()








struct __darwin_ppc_float_state
{
 double __fpregs[32];

 unsigned int __fpscr_pad;
 unsigned int __fpscr;
};
# 263 "./../include/mach/ppc/_structs.h"
#pragma pack(4)




struct __darwin_ppc_vector_state
{

 unsigned int __save_vr[32][4];
 unsigned int __save_vscr[4];




 unsigned int __save_pad5[4];
 unsigned int __save_vrvalid;
 unsigned int __save_pad6[7];
};
# 297 "./../include/mach/ppc/_structs.h"
#pragma pack()
# 316 "./../include/mach/ppc/_structs.h"
#pragma pack(4)




struct __darwin_ppc_exception_state
{

 unsigned int __dar;
 unsigned int __dsisr;
 unsigned int __exception;
 unsigned int __pad0;
 unsigned int __pad1[4];







};
# 359 "./../include/mach/ppc/_structs.h"
struct __darwin_ppc_exception_state64
{
 unsigned long long __dar;

 unsigned int __dsisr;
 unsigned int __exception;
 unsigned int __pad1[4];





};
# 390 "./../include/mach/ppc/_structs.h"
#pragma pack()
# 36 "./../include/mach/ppc/thread_status.h" 2
# 72 "./../include/mach/ppc/thread_status.h"
typedef struct __darwin_ppc_thread_state ppc_thread_state_t;

typedef struct __darwin_ppc_thread_state64 ppc_thread_state64_t;

typedef struct __darwin_ppc_float_state ppc_float_state_t;
typedef struct __darwin_ppc_vector_state ppc_vector_state_t;
# 94 "./../include/mach/ppc/thread_status.h"
typedef struct ppc_thread_state ppc_saved_state_t;
# 115 "./../include/mach/ppc/thread_status.h"
typedef struct __darwin_ppc_exception_state ppc_exception_state_t;

typedef struct __darwin_ppc_exception_state64 ppc_exception_state64_t;
# 44 "./../include/stuff/bytesex.h" 2




# 1 "./../include/mach/m88k/thread_status.h" 1
# 52 "./../include/mach/m88k/thread_status.h"
# 1 "./../include/architecture/m88k/fp_regs.h" 1
# 44 "./../include/architecture/m88k/fp_regs.h"
# 1 "./../include/architecture/m88k/reg_help.h" 1
# 44 "./../include/architecture/m88k/reg_help.h"
# 1 "./../include/architecture/nrw/reg_help.h" 1
# 45 "./../include/architecture/m88k/reg_help.h" 2
# 45 "./../include/architecture/m88k/fp_regs.h" 2





typedef union {
 float f;
 double d;






 long double e;


 unsigned x[4] __attribute__(( aligned(16) ));



} m88k_xrf_t;




typedef struct {
 unsigned :((31)-(17)+1);
 unsigned xmod:(1);
 unsigned :((15)-(5)+1);
 unsigned afinv:(1);
 unsigned afdvz:(1);
 unsigned afunf:(1);
 unsigned afovf:(1);
 unsigned afinx:(1);
} m88k_fpsr_t;






typedef enum {
 M88K_RM_NEAREST = 0,
 M88K_RM_ZERO = 1,
 M88K_RM_NEGINF = 2,
 M88K_RM_POSINF =3
} m88k_fpcr_rm_t;

typedef struct {
 unsigned :((31)-(16)+1);
 m88k_fpcr_rm_t rm:((15)-(14)+1);
 unsigned :((13)-(5)+1);
 unsigned efinv:(1);
 unsigned efdvz:(1);
 unsigned efunf:(1);
 unsigned efovf:(1);
 unsigned efinx:(1);
} m88k_fpcr_t;





typedef struct {
 unsigned :((31)-(22)+1);
 unsigned tcfp:(1);
 unsigned :((20)-(19)+1);
 unsigned tcfpunf:(1);
 unsigned tcfpovf:(1);
 unsigned :(1);
 m88k_fpcr_rm_t rm:((15)-(14)+1);
 unsigned :((13)-(5)+1);
 unsigned efinv:(1);
 unsigned efdvz:(1);
 unsigned efunf:(1);
 unsigned efovf:(1);
 unsigned efinx:(1);
} m88110_fpcr_t;
# 53 "./../include/mach/m88k/thread_status.h" 2
# 70 "./../include/mach/m88k/thread_status.h"
typedef struct _m88k_thread_state_grf {
 unsigned r1;
 unsigned r2;
 unsigned r3;
 unsigned r4;
 unsigned r5;
 unsigned r6;
 unsigned r7;
 unsigned r8;
 unsigned r9;
 unsigned r10;
 unsigned r11;
 unsigned r12;
 unsigned r13;
 unsigned r14;
 unsigned r15;
 unsigned r16;
 unsigned r17;
 unsigned r18;
 unsigned r19;
 unsigned r20;
 unsigned r21;
 unsigned r22;
 unsigned r23;
 unsigned r24;
 unsigned r25;
 unsigned r26;
 unsigned r27;
 unsigned r28;
 unsigned r29;
 unsigned r30;
 unsigned r31;
 unsigned xip;
 unsigned xip_in_bd;



 unsigned nip;
} m88k_thread_state_grf_t;
# 117 "./../include/mach/m88k/thread_status.h"
typedef struct _m88k_thread_state_xrf {
 m88k_xrf_t x1;
 m88k_xrf_t x2;
 m88k_xrf_t x3;
 m88k_xrf_t x4;
 m88k_xrf_t x5;
 m88k_xrf_t x6;
 m88k_xrf_t x7;
 m88k_xrf_t x8;
 m88k_xrf_t x9;
 m88k_xrf_t x10;
 m88k_xrf_t x11;
 m88k_xrf_t x12;
 m88k_xrf_t x13;
 m88k_xrf_t x14;
 m88k_xrf_t x15;
 m88k_xrf_t x16;
 m88k_xrf_t x17;
 m88k_xrf_t x18;
 m88k_xrf_t x19;
 m88k_xrf_t x20;
 m88k_xrf_t x21;
 m88k_xrf_t x22;
 m88k_xrf_t x23;
 m88k_xrf_t x24;
 m88k_xrf_t x25;
 m88k_xrf_t x26;
 m88k_xrf_t x27;
 m88k_xrf_t x28;
 m88k_xrf_t x29;
 m88k_xrf_t x30;
 m88k_xrf_t x31;
 m88k_fpsr_t fpsr;
 m88k_fpcr_t fpcr;
} m88k_thread_state_xrf_t;




typedef struct _m88k_thread_state_user {
 int user;
} m88k_thread_state_user_t;
# 174 "./../include/mach/m88k/thread_status.h"
typedef enum {
 M88110_MATCH_BYTE = 0,
 M88110_MATCH_SHORT = 0x1,
 M88110_MATCH_WORD = 0x3,
 M88110_MATCH_DOUBLE = 0x7,
 M88110_MATCH_QUAD = 0xf,
 M88110_MATCH_32 = 0x1f,
 M88110_MATCH_64 = 0x3f,
 M88110_MATCH_128 = 0x7f,
 M88110_MATCH_256 = 0xff,
 M88110_MATCH_512 = 0x1ff,
 M88110_MATCH_1024 = 0x3ff,
 M88110_MATCH_2048 = 0x7ff,
 M88110_MATCH_4096 = 0xfff
} m88110_match_t;




typedef struct {
 unsigned :((31)-(29)+1);
 unsigned rw:(1);
 unsigned rwm:(1);
 unsigned :((26)-(13)+1);
 m88110_match_t addr_match:((12)-(1)+1);
 unsigned v:(1);
} m88110_bp_ctrl_t;




typedef struct {
 unsigned addr;
 m88110_bp_ctrl_t ctrl;
} m88110_data_bp_t;






typedef struct {
 unsigned supr:(1);
 unsigned le:(1);
 unsigned se:(1);
 unsigned c:(1);
 unsigned :(1);
 unsigned sgn_imd:(1);
 unsigned sm:(1);
 unsigned :(1);
 unsigned trace:(1);
 unsigned :((22)-(5)+1);
 unsigned sfu2dis:(1);
 unsigned sfu1dis:(1);
 unsigned mxm_dis:(1);
 unsigned :((1)-(0)+1);
} m88110_psr_t;




typedef enum {
 M88110_IRESULT_SIZE_NONE = 0,
 M88110_IRESULT_SIZE_SINGLE = 1,
 M88110_IRESULT_SIZE_DOUBLE = 2,
 M88110_IRESULT_SIZE_EXTENDED = 3
} m88110_iresult_size_t;

typedef struct {
 unsigned :((31)-(16)+1);
 m88110_iresult_size_t iresult_size:((15)-(14)+1);

 unsigned :((13)-(9)+1);
 unsigned sfu1_disabled:(1);
 unsigned int:(1);
 unsigned unimp:(1);
 unsigned priv:(1);
 unsigned efinv:(1);
 unsigned efdvz:(1);
 unsigned efunf:(1);
 unsigned efovf:(1);
 unsigned efinx:(1);
} m88110_fp_trap_status_t;





typedef struct _m88110_thread_state_impl {
 m88110_data_bp_t data_bp[2];




 m88110_psr_t psr;
# 277 "./../include/mach/m88k/thread_status.h"
 m88k_xrf_t intermediate_result;
 m88110_fp_trap_status_t fp_trap_status;
} m88110_thread_state_impl_t;
# 49 "./../include/stuff/bytesex.h" 2
# 1 "./../include/mach/i860/thread_status.h" 1
# 44 "./../include/mach/i860/thread_status.h"
struct i860_thread_state_regs {
 int ireg[31];
 int freg[30];
 int psr;
 int epsr;
 int db;
 int pc;
 int _padding_;

 double Mres3;
 double Ares3;
 double Mres2;
 double Ares2;
 double Mres1;
 double Ares1;
 double Ires1;
 double Lres3m;
 double Lres2m;
 double Lres1m;
 double KR;
 double KI;
 double T;
 int Fsr3;
 int Fsr2;
 int Fsr1;
 int Mergelo32;
 int Mergehi32;
};
# 50 "./../include/stuff/bytesex.h" 2

# 1 "./../include/mach/hppa/thread_status.h" 1
# 73 "./../include/mach/hppa/thread_status.h"
struct hp_pa_frame_thread_state {
 uint32_t ts_pcsq_front;
 uint32_t ts_pcsq_back;
 uint32_t ts_pcoq_front;
 uint32_t ts_pcoq_back;
 uint32_t ts_psw;
 uint32_t ts_unaligned_faults;
 uint32_t ts_fault_address;
# 96 "./../include/mach/hppa/thread_status.h"
 uint32_t ts_step_range_start;
 uint32_t ts_step_range_stop;


 boolean_t ts_alignment_trap_reflect;


 boolean_t ts_execution_trap_reflect;
};





struct hp_pa_old_frame_thread_state {
 uint32_t ts_pcsq_front;
 uint32_t ts_pcsq_back;
 uint32_t ts_pcoq_front;
 uint32_t ts_pcoq_back;
 uint32_t ts_psw;
};





typedef struct hp_pa_integer_thread_state {
 uint32_t ts_gr1;
 uint32_t ts_gr2;
 uint32_t ts_gr3;
 uint32_t ts_gr4;
 uint32_t ts_gr5;
 uint32_t ts_gr6;
 uint32_t ts_gr7;
 uint32_t ts_gr8;
 uint32_t ts_gr9;
 uint32_t ts_gr10;
 uint32_t ts_gr11;
 uint32_t ts_gr12;
 uint32_t ts_gr13;
 uint32_t ts_gr14;
 uint32_t ts_gr15;
 uint32_t ts_gr16;
 uint32_t ts_gr17;
 uint32_t ts_gr18;
 uint32_t ts_gr19;
 uint32_t ts_gr20;
 uint32_t ts_gr21;
 uint32_t ts_gr22;
 uint32_t ts_gr23;
 uint32_t ts_gr24;
 uint32_t ts_gr25;
 uint32_t ts_gr26;
 uint32_t ts_gr27;
 uint32_t ts_gr28;
 uint32_t ts_gr29;
 uint32_t ts_gr30;
 uint32_t ts_gr31;
 uint32_t ts_sr0;
 uint32_t ts_sr1;
 uint32_t ts_sr2;
 uint32_t ts_sr3;
 uint32_t ts_sar;
} hp_pa_integer_thread_state_t;





typedef struct hp_pa_fp_thread_state {
 double ts_fp0;
 double ts_fp1;
 double ts_fp2;
 double ts_fp3;
 double ts_fp4;
 double ts_fp5;
 double ts_fp6;
 double ts_fp7;
 double ts_fp8;
 double ts_fp9;
 double ts_fp10;
 double ts_fp11;
 double ts_fp12;
 double ts_fp13;
 double ts_fp14;
 double ts_fp15;
 double ts_fp16;
 double ts_fp17;
 double ts_fp18;
 double ts_fp19;
 double ts_fp20;
 double ts_fp21;
 double ts_fp22;
 double ts_fp23;
 double ts_fp24;
 double ts_fp25;
 double ts_fp26;
 double ts_fp27;
 double ts_fp28;
 double ts_fp29;
 double ts_fp30;
 double ts_fp31;
} hp_pa_fp_thread_state_t;
# 52 "./../include/stuff/bytesex.h" 2
# 1 "./../include/mach/sparc/thread_status.h" 1
# 35 "./../include/mach/sparc/thread_status.h"
# 1 "./../include/architecture/sparc/reg.h" 1
# 72 "./../include/architecture/sparc/reg.h"
struct regs {
 int r_psr;
 int r_pc;
 int r_npc;
 int r_y;
 int r_g1;
 int r_g2;
 int r_g3;
 int r_g4;
 int r_g5;
 int r_g6;
 int r_g7;
 int r_o0;
 int r_o1;
 int r_o2;
 int r_o3;
 int r_o4;
 int r_o5;
 int r_o6;
 int r_o7;
};
# 116 "./../include/architecture/sparc/reg.h"
struct fpq {
 unsigned int *addr;
 unsigned int instr;
};
struct fq {
 union {
  double whole;
  struct fpq fpq;
 } FQu;
};





struct fpu {
 union {
  unsigned Fpu_regs[32];
  double Fpu_dregs[16];
 } fpu_fr;
 unsigned Fpu_fsr;
 unsigned Fpu_flags;
 unsigned Fpu_extra;
 unsigned Fpu_qcnt;
 struct fq Fpu_q[16];
};
# 268 "./../include/architecture/sparc/reg.h"
struct rwindow {
 int rw_local[8];
 int rw_in[8];
};
# 288 "./../include/architecture/sparc/reg.h"
struct p_status {
  union {
    unsigned int psr;
    struct {
 unsigned int
 impl:4,
 ver:4,
 icc:4,
 reserved:6,
 ec:1,
 ef:1,
 pil:4,
 s:1,
 ps:1,
 et:1,
 cwp:5;
      } psr_bits;
  } PSRREG;
};

struct f_status {
  union {
    unsigned Fpu_fsr;
    struct {
      unsigned int
      rd:2,
      rp:2,
      tem:5,
      res:6,
      ftt:3,
      qne:1,
      pr:1,
      fcc:2,
      aexc:5,
      cexc:5;
    } Fpu_fsr_bits;
  } FPUREG;
};
# 36 "./../include/mach/sparc/thread_status.h" 2
# 55 "./../include/mach/sparc/thread_status.h"
struct sparc_thread_state_regs {
 struct regs regs;
};
# 69 "./../include/mach/sparc/thread_status.h"
struct sparc_thread_state_fpu {
 struct fpu fpu;
};
# 53 "./../include/stuff/bytesex.h" 2
# 1 "./../include/mach/arm/thread_status.h" 1
# 12 "./../include/mach/arm/thread_status.h"
# 1 "./../include/mach/arm/_structs.h" 1
# 12 "./../include/mach/arm/_structs.h"
struct __darwin_arm_exception_state
{
 __uint32_t __exception;
 __uint32_t __fsr;
 __uint32_t __far;
};
# 30 "./../include/mach/arm/_structs.h"
struct __darwin_arm_thread_state
{
 __uint32_t __r[13];
 __uint32_t __sp;
 __uint32_t __lr;
 __uint32_t __pc;
 __uint32_t __cpsr;
};
# 52 "./../include/mach/arm/_structs.h"
struct __darwin_arm_vfp_state
{
 __uint32_t __r[64];
 __uint32_t __fpscr;

};
# 68 "./../include/mach/arm/_structs.h"
struct __darwin_arm_debug_state
{
 __uint32_t __bvr[16];
 __uint32_t __bcr[16];
 __uint32_t __wvr[16];
 __uint32_t __wcr[16];
};
# 13 "./../include/mach/arm/thread_status.h" 2

# 1 "./../include/mach/arm/thread_state.h" 1
# 15 "./../include/mach/arm/thread_status.h" 2
# 38 "./../include/mach/arm/thread_status.h"
typedef struct __darwin_arm_thread_state arm_thread_state_t;
typedef struct __darwin_arm_vfp_state arm_vfp_state_t;
typedef struct __darwin_arm_exception_state arm_exception_state_t;
typedef struct __darwin_arm_debug_state arm_debug_state_t;
# 54 "./../include/stuff/bytesex.h" 2
# 1 "./../include/mach-o/nlist.h" 1
# 76 "./../include/mach-o/nlist.h"
struct nlist {
 union {



  uint32_t n_strx;
 } n_un;
 uint8_t n_type;
 uint8_t n_sect;
 int16_t n_desc;
 uint32_t n_value;
};




struct nlist_64 {
    union {
        uint32_t n_strx;
    } n_un;
    uint8_t n_type;
    uint8_t n_sect;
    uint16_t n_desc;
    uint64_t n_value;
};
# 306 "./../include/mach-o/nlist.h"
extern int nlist (const char *filename, struct nlist *list);
# 55 "./../include/stuff/bytesex.h" 2
# 1 "./../include/mach-o/reloc.h" 1
# 64 "./../include/mach-o/reloc.h"
struct relocation_info {
   int32_t r_address;

   uint32_t r_symbolnum:24,

  r_pcrel:1,
  r_length:2,
  r_extern:1,
  r_type:4;
};
# 151 "./../include/mach-o/reloc.h"
struct scattered_relocation_info {
# 163 "./../include/mach-o/reloc.h"
   uint32_t
     r_address:24,

  r_type:4,
  r_length:2,
  r_pcrel:1,
  r_scattered:1;
   int32_t r_value;


};
# 193 "./../include/mach-o/reloc.h"
enum reloc_type_generic
{
    GENERIC_RELOC_VANILLA,
    GENERIC_RELOC_PAIR,
    GENERIC_RELOC_SECTDIFF,
    GENERIC_RELOC_PB_LA_PTR,
    GENERIC_RELOC_LOCAL_SECTDIFF,
    GENERIC_RELOC_TLV
};
# 56 "./../include/stuff/bytesex.h" 2
# 1 "./../include/mach-o/ranlib.h" 1
# 28 "./../include/mach-o/ranlib.h"
# 1 "/usr/include/sys/types.h" 1 3 4
# 72 "/usr/include/sys/types.h" 3 4
# 1 "/usr/include/sys/appleapiopts.h" 1 3 4
# 73 "/usr/include/sys/types.h" 2 3 4





# 1 "/usr/include/machine/types.h" 1 3 4
# 37 "/usr/include/machine/types.h" 3 4
# 1 "/usr/include/i386/types.h" 1 3 4
# 80 "/usr/include/i386/types.h" 3 4
typedef unsigned char u_int8_t;




typedef unsigned short u_int16_t;




typedef unsigned int u_int32_t;




typedef unsigned long long u_int64_t;


typedef int64_t register_t;
# 114 "/usr/include/i386/types.h" 3 4
typedef u_int64_t user_addr_t;
typedef u_int64_t user_size_t;
typedef int64_t user_ssize_t;
typedef int64_t user_long_t;
typedef u_int64_t user_ulong_t;
typedef int64_t user_time_t;
typedef int64_t user_off_t;







typedef u_int64_t syscall_arg_t;
# 38 "/usr/include/machine/types.h" 2 3 4
# 79 "/usr/include/sys/types.h" 2 3 4


# 1 "/usr/include/machine/endian.h" 1 3 4
# 37 "/usr/include/machine/endian.h" 3 4
# 1 "/usr/include/i386/endian.h" 1 3 4
# 99 "/usr/include/i386/endian.h" 3 4
# 1 "/usr/include/sys/_endian.h" 1 3 4
# 100 "/usr/include/i386/endian.h" 2 3 4
# 38 "/usr/include/machine/endian.h" 2 3 4
# 82 "/usr/include/sys/types.h" 2 3 4


typedef unsigned char u_char;
typedef unsigned short u_short;
typedef unsigned int u_int;

typedef unsigned long u_long;


typedef unsigned short ushort;
typedef unsigned int uint;


typedef u_int64_t u_quad_t;
typedef int64_t quad_t;
typedef quad_t * qaddr_t;

typedef char * caddr_t;
typedef int32_t daddr_t;


typedef __darwin_dev_t dev_t;



typedef u_int32_t fixpt_t;


typedef __darwin_blkcnt_t blkcnt_t;




typedef __darwin_blksize_t blksize_t;




typedef __darwin_gid_t gid_t;





typedef __uint32_t in_addr_t;




typedef __uint16_t in_port_t;



typedef __darwin_ino_t ino_t;





typedef __darwin_ino64_t ino64_t;






typedef __int32_t key_t;



typedef __darwin_mode_t mode_t;




typedef __uint16_t nlink_t;





typedef __darwin_id_t id_t;



typedef __darwin_pid_t pid_t;
# 176 "/usr/include/sys/types.h" 3 4
typedef int32_t segsz_t;
typedef int32_t swblk_t;


typedef __darwin_uid_t uid_t;
# 223 "/usr/include/sys/types.h" 3 4
typedef __darwin_clock_t clock_t;
# 240 "/usr/include/sys/types.h" 3 4
typedef __darwin_time_t time_t;




typedef __darwin_useconds_t useconds_t;




typedef __darwin_suseconds_t suseconds_t;
# 260 "/usr/include/sys/types.h" 3 4
# 1 "/usr/include/sys/_structs.h" 1 3 4
# 184 "/usr/include/sys/_structs.h" 3 4
typedef struct fd_set {
 __int32_t fds_bits[((((1024) % ((sizeof(__int32_t) * 8))) == 0) ? ((1024) / ((sizeof(__int32_t) * 8))) : (((1024) / ((sizeof(__int32_t) * 8))) + 1))];
} fd_set;



static __inline int
__darwin_fd_isset(int _n, const struct fd_set *_p)
{
 return (_p->fds_bits[_n/(sizeof(__int32_t) * 8)] & (1<<(_n % (sizeof(__int32_t) * 8))));
}
# 261 "/usr/include/sys/types.h" 2 3 4




typedef __int32_t fd_mask;
# 318 "/usr/include/sys/types.h" 3 4
typedef __darwin_pthread_attr_t pthread_attr_t;



typedef __darwin_pthread_cond_t pthread_cond_t;



typedef __darwin_pthread_condattr_t pthread_condattr_t;



typedef __darwin_pthread_mutex_t pthread_mutex_t;



typedef __darwin_pthread_mutexattr_t pthread_mutexattr_t;



typedef __darwin_pthread_once_t pthread_once_t;



typedef __darwin_pthread_rwlock_t pthread_rwlock_t;



typedef __darwin_pthread_rwlockattr_t pthread_rwlockattr_t;



typedef __darwin_pthread_t pthread_t;






typedef __darwin_pthread_key_t pthread_key_t;





typedef __darwin_fsblkcnt_t fsblkcnt_t;




typedef __darwin_fsfilcnt_t fsfilcnt_t;
# 29 "./../include/mach-o/ranlib.h" 2
# 58 "./../include/mach-o/ranlib.h"
struct ranlib {
    union {
 uint32_t ran_strx;



    } ran_un;
    uint32_t ran_off;
};
# 57 "./../include/stuff/bytesex.h" 2
# 1 "./../include/stuff/bool.h" 1
# 41 "./../include/stuff/bool.h"
enum bool {
    FALSE,
    TRUE
};
# 58 "./../include/stuff/bytesex.h" 2

enum byte_sex {
    UNKNOWN_BYTE_SEX,
    BIG_ENDIAN_BYTE_SEX,
    LITTLE_ENDIAN_BYTE_SEX
};
# 79 "./../include/stuff/bytesex.h"
__private_extern__ long long SWAP_LONG_LONG(
    long long ll);

__private_extern__ float SWAP_FLOAT(
    float f);

__private_extern__ double SWAP_DOUBLE(
    double d);

__private_extern__ enum byte_sex get_host_byte_sex(
    void);

__private_extern__ void swap_fat_header(
    struct fat_header *fat_header,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_fat_arch(
    struct fat_arch *fat_archs,
    uint32_t nfat_arch,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_mach_header(
    struct mach_header *mh,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_mach_header_64(
    struct mach_header_64 *mh,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_load_command(
    struct load_command *lc,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_segment_command(
    struct segment_command *sg,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_segment_command_64(
    struct segment_command_64 *sg,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_section(
    struct section *s,
    uint32_t nsects,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_section_64(
    struct section_64 *s,
    uint32_t nsects,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_symtab_command(
    struct symtab_command *st,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_dysymtab_command(
    struct dysymtab_command *dyst,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_symseg_command(
    struct symseg_command *ss,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_fvmlib_command(
    struct fvmlib_command *fl,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_dylib_command(
    struct dylib_command *dl,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_sub_framework_command(
    struct sub_framework_command *sub,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_sub_umbrella_command(
    struct sub_umbrella_command *usub,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_sub_library_command(
    struct sub_library_command *lsub,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_sub_client_command(
    struct sub_client_command *csub,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_prebound_dylib_command(
    struct prebound_dylib_command *pbdylib,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_dylinker_command(
    struct dylinker_command *dyld,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_fvmfile_command(
    struct fvmfile_command *ff,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_thread_command(
    struct thread_command *ut,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_m68k_thread_state_regs(
    struct m68k_thread_state_regs *cpu,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_m68k_thread_state_68882(
    struct m68k_thread_state_68882 *fpu,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_m68k_thread_state_user_reg(
    struct m68k_thread_state_user_reg *user_reg,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_ppc_thread_state_t(
    ppc_thread_state_t *cpu,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_ppc_thread_state64_t(
    ppc_thread_state64_t *cpu,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_ppc_float_state_t(
    ppc_float_state_t *fpu,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_ppc_exception_state_t(
    ppc_exception_state_t *state,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_m88k_thread_state_grf_t(
    m88k_thread_state_grf_t *cpu,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_m88k_thread_state_xrf_t(
    m88k_thread_state_xrf_t *fpu,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_m88k_thread_state_user_t(
    m88k_thread_state_user_t *user,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_m88110_thread_state_impl_t(
    m88110_thread_state_impl_t *spu,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_i860_thread_state_regs(
    struct i860_thread_state_regs *cpu,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_i386_thread_state(
    i386_thread_state_t *cpu,
    enum byte_sex target_byte_sex);



__private_extern__ void swap_i386_float_state(
    struct __darwin_i386_float_state *fpu,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_i386_exception_state(
    i386_exception_state_t *exc,
    enum byte_sex target_byte_sex);
# 261 "./../include/stuff/bytesex.h"
__private_extern__ void swap_x86_thread_state64(
    x86_thread_state64_t *cpu,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_x86_float_state64(
    x86_float_state64_t *fpu,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_x86_state_hdr(
    struct x86_state_hdr *hdr,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_x86_exception_state64(
    x86_exception_state64_t *exc,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_x86_debug_state32(
    x86_debug_state32_t *debug,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_x86_debug_state64(
    x86_debug_state64_t *debug,
    enum byte_sex target_byte_sex);


__private_extern__ void swap_hppa_integer_thread_state(
    struct hp_pa_integer_thread_state *regs,
    enum byte_sex target_byte_order);

__private_extern__ void swap_hppa_frame_thread_state(
  struct hp_pa_frame_thread_state *frame,
  enum byte_sex target_byte_order);

__private_extern__ void swap_hppa_fp_thread_state(
  struct hp_pa_fp_thread_state *fp,
  enum byte_sex target_byte_order);

__private_extern__ void swap_sparc_thread_state_regs(
  struct sparc_thread_state_regs *cpu,
  enum byte_sex target_byte_order);

__private_extern__ void swap_sparc_thread_state_fpu(
  struct sparc_thread_state_fpu *fpu,
  enum byte_sex target_byte_order);

__private_extern__ void swap_arm_thread_state_t(
    arm_thread_state_t *cpu,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_ident_command(
    struct ident_command *id_cmd,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_routines_command(
    struct routines_command *r_cmd,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_routines_command_64(
    struct routines_command_64 *r_cmd,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_twolevel_hints_command(
    struct twolevel_hints_command *hints_cmd,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_prebind_cksum_command(
    struct prebind_cksum_command *cksum_cmd,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_uuid_command(
    struct uuid_command *uuid_cmd,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_linkedit_data_command(
    struct linkedit_data_command *ld,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_version_min_command(
    struct version_min_command *ver_cmd,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_rpath_command(
    struct rpath_command *rpath_cmd,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_encryption_command(
    struct encryption_info_command *ec,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_dyld_info_command(
    struct dyld_info_command *dc,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_entry_point_command(
    struct entry_point_command *ep,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_source_version_command(
    struct source_version_command *sv,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_nlist(
    struct nlist *symbols,
    uint32_t nsymbols,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_nlist_64(
    struct nlist_64 *symbols,
    uint32_t nsymbols,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_ranlib(
    struct ranlib *ranlibs,
    uint32_t nranlibs,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_relocation_info(
    struct relocation_info *relocs,
    uint32_t nrelocs,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_indirect_symbols(
    uint32_t *indirect_symbols,
    uint32_t nindirect_symbols,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_dylib_reference(
    struct dylib_reference *refs,
    uint32_t nrefs,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_dylib_module(
    struct dylib_module *mods,
    uint32_t nmods,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_dylib_module_64(
    struct dylib_module_64 *mods,
    uint32_t nmods,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_dylib_table_of_contents(
    struct dylib_table_of_contents *tocs,
    uint32_t ntocs,
    enum byte_sex target_byte_sex);

__private_extern__ void swap_twolevel_hint(
    struct twolevel_hint *hints,
    uint32_t nhints,
    enum byte_sex target_byte_sex);







__private_extern__ enum bool swap_object_headers(
    void *mach_header,
    struct load_command *load_commands);







__private_extern__ enum byte_sex get_toc_byte_sex(
    char *addr,
    uint32_t size);
# 37 "print_objc.c" 2
# 1 "./../include/stuff/symbol.h" 1





struct symbol {
    char *name;
    char *indr_name;
    uint64_t n_value;
    int is_thumb;
};
# 38 "print_objc.c" 2
# 1 "./ofile_print.h" 1
# 31 "./ofile_print.h"
# 1 "/usr/include/ar.h" 1 3 4
# 56 "/usr/include/ar.h" 3 4
struct ar_hdr {
 char ar_name[16];
 char ar_date[12];
 char ar_uid[6];
 char ar_gid[6];
 char ar_mode[8];
 char ar_size[10];

 char ar_fmag[2];
};
# 32 "./ofile_print.h" 2








extern void print_fat_headers(
    struct fat_header *fat_header,
    struct fat_arch *fat_archs,
    uint32_t size,
    enum bool verbose);

extern void print_ar_hdr(
    struct ar_hdr *ar_hdr,
    char *member_name,
    uint32_t member_name_size,
    uint32_t member_offset,
    enum bool verbose,
    enum bool print_offset);

extern void print_library_toc(
    struct ar_hdr *toc_ar_hdr,
    char *toc_name,
    uint32_t toc_name_size,
    char *toc_addr,
    uint32_t toc_size,
    enum byte_sex toc_byte_sex,
    char *library_name,
    char *library_addr,
    uint32_t library_size,
    char *arch_name,
    enum bool verbose);

extern void print_mach_header(
    uint32_t magic,
    cpu_type_t cputype,
    cpu_subtype_t cpusubtype,
    uint32_t filetype,
    uint32_t ncmds,
    uint32_t sizeofcmds,
    uint32_t flags,
    enum bool verbose);

extern void print_loadcmds(
    struct load_command *load_commands,
    uint32_t ncmds,
    uint32_t sizeofcmds,
    cpu_type_t cputype,
    uint32_t filetype,
    enum byte_sex load_commands_byte_sex,
    uint32_t object_size,
    enum bool verbose,
    enum bool very_verbose);

extern void print_libraries(
    struct load_command *load_commands,
    uint32_t ncmds,
    uint32_t sizeofcmds,
    enum byte_sex load_commands_byte_sex,
    enum bool just_id,
    enum bool verbose);

extern void print_reloc(
    struct load_command *load_commands,
    uint32_t ncmds,
    uint32_t sizeofcmds,
    cpu_type_t cputype,
    enum byte_sex load_commands_byte_sex,
    char *object_addr,
    uint32_t object_size,
    struct nlist *symbols,
    struct nlist_64 *symbols64,
    uint32_t nsymbols,
    char *strings,
    uint32_t strings_size,
    enum bool verbose);

extern void print_toc(
    struct load_command *load_commands,
    uint32_t ncmds,
    uint32_t sizeofcmds,
    enum byte_sex load_commands_byte_sex,
    char *object_addr,
    uint32_t object_size,
    struct dylib_table_of_contents *tocs,
    uint32_t ntocs,
    struct dylib_module *mods,
    struct dylib_module_64 *mods64,
    uint32_t nmods,
    struct nlist *symbols,
    struct nlist_64 *symbols64,
    uint32_t nsymbols,
    char *strings,
    uint32_t strings_size,
    enum bool verbose);

extern void print_module_table(
    struct dylib_module *mods,
    uint32_t nmods,
    char *strings,
    uint32_t strings_size,
    enum bool verbose);

extern void print_module_table_64(
    struct dylib_module_64 *mods64,
    uint32_t nmods,
    char *strings,
    uint32_t strings_size,
    enum bool verbose);

void print_refs(
    struct dylib_reference *refs,
    uint32_t nrefs,
    struct dylib_module *mods,
    struct dylib_module_64 *mods64,
    uint32_t nmods,
    struct nlist *symbols,
    struct nlist_64 *symbols64,
    uint32_t nsymbols,
    char *strings,
    uint32_t strings_size,
    enum bool verbose);

extern void print_indirect_symbols(
    struct load_command *load_commands,
    uint32_t ncmds,
    uint32_t sizeofcmds,
    cpu_type_t cputype,
    enum byte_sex load_commands_byte_sex,
    uint32_t *indirect_symbols,
    uint32_t nindirect_symbols,
    struct nlist *symbols,
    struct nlist_64 *symbols64,
    uint32_t nsymbols,
    char *strings,
    uint32_t strings_size,
    enum bool verbose);

extern void print_hints(
    struct load_command *load_commands,
    uint32_t ncmds,
    uint32_t sizeofcmds,
    enum byte_sex load_commands_byte_sex,
    struct twolevel_hint *hints,
    uint32_t nhints,
    struct nlist *symbols,
    struct nlist_64 *symbols64,
    uint32_t nsymbols,
    char *strings,
    uint32_t strings_size,
    enum bool verbose);

extern void print_segment_command(
    uint32_t cmd,
    uint32_t cmdsize,
    char *segname,
    uint64_t vmaddr,
    uint64_t vmsize,
    uint64_t fileoff,
    uint64_t filesize,
    vm_prot_t maxprot,
    vm_prot_t initprot,
    uint32_t nsects,
    uint32_t flags,
    uint32_t object_size,
    enum bool verbose);

extern void print_section(
    char *sectname,
    char *segname,
    uint64_t addr,
    uint64_t size,
    uint32_t offset,
    uint32_t align,
    uint32_t reloff,
    uint32_t nreloc,
    uint32_t flags,
    uint32_t reserved1,
    uint32_t reserved2,
    uint32_t cmd,
    char *sg_segname,
    uint32_t filetype,
    uint32_t object_size,
    enum bool verbose);

extern void print_symtab_command(
    struct symtab_command *sg,
    cpu_type_t cputype,
    uint32_t object_size);

extern void print_dysymtab_command(
    struct dysymtab_command *dyst,
    uint32_t nsyms,
    uint32_t object_size,
    cpu_type_t cputype);

extern void print_symseg_command(
    struct symseg_command *ss,
    uint32_t object_size);

extern void print_fvmlib_command(
    struct fvmlib_command *fl,
    struct load_command *lc);

extern void print_dylib_command(
    struct dylib_command *dl,
    struct load_command *lc);

extern void print_sub_framework_command(
    struct sub_framework_command *sub,
    struct load_command *lc);

extern void print_sub_umbrella_command(
    struct sub_umbrella_command *usub,
    struct load_command *lc);

extern void print_sub_library_command(
    struct sub_library_command *lsub,
    struct load_command *lc);

extern void print_sub_client_command(
    struct sub_client_command *csub,
    struct load_command *lc);

extern void print_prebound_dylib_command(
    struct prebound_dylib_command *pbdylib,
    struct load_command *lc,
    enum bool verbose);

extern void print_dylinker_command(
    struct dylinker_command *dyld,
    struct load_command *lc);

extern void print_fvmfile_command(
    struct fvmfile_command *ff,
    struct load_command *lc);

extern void print_routines_command(
    struct routines_command *rc);

extern void print_routines_command_64(
    struct routines_command_64 *rc64);

extern void print_twolevel_hints_command(
    struct twolevel_hints_command *hints,
    uint32_t object_size);

extern void print_prebind_cksum_command(
    struct prebind_cksum_command *cksum);

extern void print_uuid_command(
    struct uuid_command *uuid);

extern void print_linkedit_data_command(
    struct linkedit_data_command *ld,
    uint32_t object_size);

extern void print_version_min_command(
    struct version_min_command *vd);

extern void print_source_version_command(
    struct source_version_command *sv);

extern void print_entry_point_command(
    struct entry_point_command *ep);

extern void print_rpath_command(
    struct rpath_command *rpath,
    struct load_command *lc);

extern void print_encryption_info_command(
    struct encryption_info_command *ec,
    uint32_t object_size);

extern void print_dyld_info_info_command(
    struct dyld_info_command *dc,
    uint32_t object_size);

extern void print_thread_states(
    char *begin,
    char *end,
    cpu_type_t cputype,
    enum byte_sex thread_states_byte_sex);

extern void print_cstring_section(
    cpu_type_t cputype,
    char *sect,
    uint32_t sect_size,
    uint64_t sect_addr,
    enum bool print_addresses);

extern void print_literal4_section(
    char *sect,
    uint32_t sect_size,
    uint32_t sect_addr,
    enum byte_sex literal_byte_sex,
    enum bool print_addresses);

extern void print_literal8_section(
    char *sect,
    uint32_t sect_size,
    uint32_t sect_addr,
    enum byte_sex literal_byte_sex,
    enum bool print_addresses);

extern void print_literal16_section(
    char *sect,
    uint32_t sect_size,
    uint32_t sect_addr,
    enum byte_sex literal_byte_sex,
    enum bool print_addresses);

extern void print_literal_pointer_section(
    struct load_command *lc,
    uint32_t ncmds,
    uint32_t sizeofcmds,
    enum byte_sex object_byte_sex,
    char *addr,
    uint32_t size,
    char *sect,
    uint32_t sect_size,
    uint32_t sect_addr,
    struct nlist *symbols,
    struct nlist_64 *symbols64,
    uint32_t nsymbols,
    char *strings,
    uint32_t strings_size,
    struct relocation_info *relocs,
    uint32_t nrelocs,
    enum bool print_addresses);

extern void print_init_term_pointer_section(
    cpu_type_t cputype,
    char *sect,
    uint32_t sect_size,
    uint64_t sect_addr,
    enum byte_sex object_byte_sex,
    struct symbol *sorted_symbols,
    uint32_t nsorted_symbols,
    enum bool verbose);

extern void print_shlib_init(
    enum byte_sex object_byte_sex,
    char *sect,
    uint32_t sect_size,
    uint32_t sect_addr,
    struct symbol *sorted_symbols,
    uint32_t nsorted_symbols,
    struct nlist *symbols,
    struct nlist_64 *symbols64,
    uint32_t nsymbols,
    char *strings,
    uint32_t strings_size,
    struct relocation_info *relocs,
    uint32_t nrelocs,
    enum bool verbose);

extern enum bool print_symbol(
    uint64_t value,
    uint32_t r_address,
    uint32_t dot_value,
    struct relocation_info *sorted_relocs,
    uint32_t nsorted_relocs,
    struct nlist *symbols,
    struct nlist_64 *symbols64,
    uint32_t nsymbols,
    struct symbol *sorted_symbols,
    uint32_t nsorted_symbols,
    char *strings,
    uint32_t strings_size,
    enum bool verbose);

extern const char *guess_symbol(
    const uint64_t value,
    const struct symbol *sorted_symbols,
    const uint32_t nsorted_symbols,
    const enum bool verbose);

extern const char * guess_indirect_symbol(
    const uint64_t value,
    const uint32_t ncmds,
    const uint32_t sizeofcmds,
    const struct load_command *load_commands,
    const enum byte_sex load_commands_byte_sex,
    const uint32_t *indirect_symbols,
    const uint32_t nindirect_symbols,
    const struct nlist *symbols,
    const struct nlist_64 *symbols64,
    const uint32_t nsymbols,
    const char *strings,
    const uint32_t strings_size);

extern void print_sect(
    cpu_type_t cputype,
    enum byte_sex object_byte_sex,
    char *sect,
    uint64_t size,
    uint64_t addr);

extern enum bool print_objc_segment(
    cpu_type_t mh_cputype,
    struct load_command *load_commands,
    uint32_t ncmds,
    uint32_t sizeofcmds,
    enum byte_sex object_byte_sex,
    char *object_addr,
    uint32_t object_size,
    struct symbol *sorted_symbols,
    uint32_t nsorted_symbols,
    enum bool verbose);

extern void print_objc2_64bit(
    cpu_type_t cputype,
    struct load_command *load_commands,
    uint32_t ncmds,
    uint32_t sizeofcmds,
    enum byte_sex object_byte_sex,
    char *object_addr,
    uint32_t object_size,
    struct nlist_64 *symbols64,
    uint32_t nsymbols,
    char *strings,
    uint32_t strings_size,
    struct symbol *sorted_symbols,
    uint32_t nsorted_symbols,
    struct relocation_info *ext_relocs,
    uint32_t next_relocs,
    struct relocation_info *loc_relocs,
    uint32_t nloc_relocs,
    enum bool verbose,
    enum bool Vflag);

extern void print_objc2_32bit(
    cpu_type_t cputype,
    struct load_command *load_commands,
    uint32_t ncmds,
    uint32_t sizeofcmds,
    enum byte_sex object_byte_sex,
    char *object_addr,
    uint32_t object_size,
    struct nlist *symbols,
    uint32_t nsymbols,
    char *strings,
    uint32_t strings_size,
    struct symbol *sorted_symbols,
    uint32_t nsorted_symbols,
    struct relocation_info *ext_relocs,
    uint32_t next_relocs,
    struct relocation_info *loc_relocs,
    uint32_t nloc_relocs,
    enum bool verbose);

extern void print_objc_protocol_section(
    struct load_command *load_commands,
    uint32_t ncmds,
    uint32_t sizeofcmds,
    enum byte_sex object_byte_sex,
    char *object_addr,
    uint32_t object_size,
    enum bool verbose);

extern void print_objc_string_object_section(
    char *sectname,
    struct load_command *load_commands,
    uint32_t ncmds,
    uint32_t sizeofcmds,
    enum byte_sex object_byte_sex,
    char *object_addr,
    uint32_t object_size,
    enum bool verbose);

extern void print_objc_string_object_section_64(
    char *sectname,
    struct load_command *load_commands,
    uint32_t ncmds,
    uint32_t sizeofcmds,
    enum byte_sex object_byte_sex,
    char *object_addr,
    uint32_t object_size,
    cpu_type_t cputype,
    struct nlist_64 *symbols64,
    uint32_t nsymbols,
    char *strings,
    const uint32_t strings_size,
    struct symbol *sorted_symbols,
    uint32_t nsorted_symbols,
    enum bool verbose);

extern void print_objc_runtime_setup_section(
    struct load_command *load_commands,
    uint32_t ncmds,
    uint32_t sizeofcmds,
    enum byte_sex object_byte_sex,
    char *object_addr,
    uint32_t object_size,
    enum bool verbose);

extern void print_coff_reloc_section(
    struct load_command *load_commands,
    uint32_t ncmds,
    uint32_t sizeofcmds,
    uint32_t filetype,
    enum byte_sex object_byte_sex,
    char *object_addr,
    uint32_t object_size,
    enum bool verbose);

extern void print_label(
    uint64_t addr,
    enum bool colon_and_newline,
    struct symbol *sorted_symbols,
    uint32_t nsorted_symbols);

extern enum bool get_sect_info(
    char *segname,
    char *sectname,
    struct load_command *load_commands,
    uint32_t ncmds,
    uint32_t sizeofcmds,
    uint32_t filetype,
    enum byte_sex load_commands_byte_sex,
    char *object_addr,
    uint32_t object_size,
    char **sect_pointer,
    uint64_t *sect_size,
    uint64_t *sect_addr,
    struct relocation_info **sect_relocs,
    uint32_t *sect_nrelocs,
    uint32_t *sect_flags);
# 39 "print_objc.c" 2
# 49 "print_objc.c"
struct objc_module_t {
    uint32_t version;
    uint32_t size;
    uint32_t name;
    uint32_t symtab;
};

struct objc_symtab_t {
    uint32_t sel_ref_cnt;
    uint32_t refs;
    uint16_t cls_def_cnt;
    uint16_t cat_def_cnt;
    uint32_t defs[1];
};

struct objc_class_t {
    uint32_t isa;
    uint32_t super_class;
    uint32_t name;
    int32_t version;
    int32_t info;
    int32_t instance_size;
    uint32_t ivars;
    uint32_t methodLists;
    uint32_t cache;
    uint32_t protocols;
};

struct objc_category_t {
    uint32_t category_name;
    uint32_t class_name;
    uint32_t instance_methods;
    uint32_t class_methods;
    uint32_t protocols;
};

struct objc_ivar_t {
    uint32_t ivar_name;
    uint32_t ivar_type;
    int32_t ivar_offset;
};

struct objc_ivar_list_t {
    int32_t ivar_count;
    struct objc_ivar_t ivar_list[1];
};

struct objc_method_t {
    uint32_t method_name;
    uint32_t method_types;
    uint32_t method_imp;

};

struct objc_method_list_t {
    uint32_t obsolete;
    int32_t method_count;
    struct objc_method_t method_list[1];
};

struct objc_protocol_t {
    uint32_t isa;
    uint32_t protocol_name;
    uint32_t protocol_list;

    uint32_t instance_methods;

    uint32_t class_methods;

};

struct objc_protocol_list_t {
    uint32_t next;
    int32_t count;
    uint32_t list[1];

};

struct objc_method_description_t {
    uint32_t name;
    uint32_t types;
};

struct objc_method_description_list_t {
    int32_t count;
    struct objc_method_description_t list[1];
};






struct objc_string_object_t {
    uint32_t isa;
    uint32_t characters;
    uint32_t _length;
};
typedef struct objc_string_object_t NXConstantString;


struct _hashEntry_t {
    uint32_t next;
    uint32_t sel;
};

struct imageInfo_t {
    uint32_t version;
    uint32_t flags;
};

static
void
swap_imageInfo_t(
struct imageInfo_t *o,
enum byte_sex target_byte_sex)
{
 o->version = ( ((o->version) << 24) | (((o->version) << 8) & 0x00ff0000) | (((o->version) >> 8) & 0x0000ff00) | ((unsigned int)(o->version) >> 24) );
 o->flags = ( ((o->flags) << 24) | (((o->flags) << 8) & 0x00ff0000) | (((o->flags) >> 8) & 0x0000ff00) | ((unsigned int)(o->flags) >> 24) );
}

void
swap_objc_module_t(
struct objc_module_t *module,
enum byte_sex target_byte_sex)
{
 module->version = ( ((module->version) << 24) | (((module->version) << 8) & 0x00ff0000) | (((module->version) >> 8) & 0x0000ff00) | ((unsigned int)(module->version) >> 24) );
 module->size = ( ((module->size) << 24) | (((module->size) << 8) & 0x00ff0000) | (((module->size) >> 8) & 0x0000ff00) | ((unsigned int)(module->size) >> 24) );
 module->name = ( ((module->name) << 24) | (((module->name) << 8) & 0x00ff0000) | (((module->name) >> 8) & 0x0000ff00) | ((unsigned int)(module->name) >> 24) );
 module->symtab = ( ((module->symtab) << 24) | (((module->symtab) << 8) & 0x00ff0000) | (((module->symtab) >> 8) & 0x0000ff00) | ((unsigned int)(module->symtab) >> 24) );
}

void
swap_objc_symtab_t(
struct objc_symtab_t *symtab,
enum byte_sex target_byte_sex)
{
 symtab->sel_ref_cnt = ( ((symtab->sel_ref_cnt) << 24) | (((symtab->sel_ref_cnt) << 8) & 0x00ff0000) | (((symtab->sel_ref_cnt) >> 8) & 0x0000ff00) | ((unsigned int)(symtab->sel_ref_cnt) >> 24) );
 symtab->refs = ( ((symtab->refs) << 24) | (((symtab->refs) << 8) & 0x00ff0000) | (((symtab->refs) >> 8) & 0x0000ff00) | ((unsigned int)(symtab->refs) >> 24) );
 symtab->cls_def_cnt = ( ((symtab->cls_def_cnt & 0xff) << 8) | ((unsigned short)(symtab->cls_def_cnt) >> 8) );
 symtab->cat_def_cnt = ( ((symtab->cat_def_cnt & 0xff) << 8) | ((unsigned short)(symtab->cat_def_cnt) >> 8) );
}

void
swap_objc_class_t(
struct objc_class_t *objc_class,
enum byte_sex target_byte_sex)
{
 objc_class->isa = ( ((objc_class->isa) << 24) | (((objc_class->isa) << 8) & 0x00ff0000) | (((objc_class->isa) >> 8) & 0x0000ff00) | ((unsigned int)(objc_class->isa) >> 24) );
 objc_class->super_class = ( ((objc_class->super_class) << 24) | (((objc_class->super_class) << 8) & 0x00ff0000) | (((objc_class->super_class) >> 8) & 0x0000ff00) | ((unsigned int)(objc_class->super_class) >> 24) );
 objc_class->name = ( ((objc_class->name) << 24) | (((objc_class->name) << 8) & 0x00ff0000) | (((objc_class->name) >> 8) & 0x0000ff00) | ((unsigned int)(objc_class->name) >> 24) );
 objc_class->version = ( ((objc_class->version) << 24) | (((objc_class->version) << 8) & 0x00ff0000) | (((objc_class->version) >> 8) & 0x0000ff00) | ((unsigned int)(objc_class->version) >> 24) );
 objc_class->info = ( ((objc_class->info) << 24) | (((objc_class->info) << 8) & 0x00ff0000) | (((objc_class->info) >> 8) & 0x0000ff00) | ((unsigned int)(objc_class->info) >> 24) );
 objc_class->instance_size = ( ((objc_class->instance_size) << 24) | (((objc_class->instance_size) << 8) & 0x00ff0000) | (((objc_class->instance_size) >> 8) & 0x0000ff00) | ((unsigned int)(objc_class->instance_size) >> 24) );
 objc_class->ivars = ( ((objc_class->ivars) << 24) | (((objc_class->ivars) << 8) & 0x00ff0000) | (((objc_class->ivars) >> 8) & 0x0000ff00) | ((unsigned int)(objc_class->ivars) >> 24) );
 objc_class->methodLists = ( ((objc_class->methodLists) << 24) | (((objc_class->methodLists) << 8) & 0x00ff0000) | (((objc_class->methodLists) >> 8) & 0x0000ff00) | ((unsigned int)(objc_class->methodLists) >> 24) );
 objc_class->cache = ( ((objc_class->cache) << 24) | (((objc_class->cache) << 8) & 0x00ff0000) | (((objc_class->cache) >> 8) & 0x0000ff00) | ((unsigned int)(objc_class->cache) >> 24) );
 objc_class->protocols = ( ((objc_class->protocols) << 24) | (((objc_class->protocols) << 8) & 0x00ff0000) | (((objc_class->protocols) >> 8) & 0x0000ff00) | ((unsigned int)(objc_class->protocols) >> 24) );
}

void
swap_objc_category_t(
struct objc_category_t *objc_category,
enum byte_sex target_byte_sex)
{
 objc_category->category_name = ( ((objc_category->category_name) << 24) | (((objc_category->category_name) << 8) & 0x00ff0000) | (((objc_category->category_name) >> 8) & 0x0000ff00) | ((unsigned int)(objc_category->category_name) >> 24) );
 objc_category->class_name = ( ((objc_category->class_name) << 24) | (((objc_category->class_name) << 8) & 0x00ff0000) | (((objc_category->class_name) >> 8) & 0x0000ff00) | ((unsigned int)(objc_category->class_name) >> 24) );
 objc_category->instance_methods =
  ( ((objc_category->instance_methods) << 24) | (((objc_category->instance_methods) << 8) & 0x00ff0000) | (((objc_category->instance_methods) >> 8) & 0x0000ff00) | ((unsigned int)(objc_category->instance_methods) >> 24) );
 objc_category->class_methods =
  ( ((objc_category->class_methods) << 24) | (((objc_category->class_methods) << 8) & 0x00ff0000) | (((objc_category->class_methods) >> 8) & 0x0000ff00) | ((unsigned int)(objc_category->class_methods) >> 24) );
 objc_category->protocols =
  ( ((objc_category->protocols) << 24) | (((objc_category->protocols) << 8) & 0x00ff0000) | (((objc_category->protocols) >> 8) & 0x0000ff00) | ((unsigned int)(objc_category->protocols) >> 24) );
}

void
swap_objc_ivar_list_t(
struct objc_ivar_list_t *objc_ivar_list,
enum byte_sex target_byte_sex)
{
 objc_ivar_list->ivar_count = ( ((objc_ivar_list->ivar_count) << 24) | (((objc_ivar_list->ivar_count) << 8) & 0x00ff0000) | (((objc_ivar_list->ivar_count) >> 8) & 0x0000ff00) | ((unsigned int)(objc_ivar_list->ivar_count) >> 24) );
}

void
swap_objc_ivar_t(
struct objc_ivar_t *objc_ivar,
enum byte_sex target_byte_sex)
{
 objc_ivar->ivar_name = ( ((objc_ivar->ivar_name) << 24) | (((objc_ivar->ivar_name) << 8) & 0x00ff0000) | (((objc_ivar->ivar_name) >> 8) & 0x0000ff00) | ((unsigned int)(objc_ivar->ivar_name) >> 24) );
 objc_ivar->ivar_type = ( ((objc_ivar->ivar_type) << 24) | (((objc_ivar->ivar_type) << 8) & 0x00ff0000) | (((objc_ivar->ivar_type) >> 8) & 0x0000ff00) | ((unsigned int)(objc_ivar->ivar_type) >> 24) );
 objc_ivar->ivar_offset = ( ((objc_ivar->ivar_offset) << 24) | (((objc_ivar->ivar_offset) << 8) & 0x00ff0000) | (((objc_ivar->ivar_offset) >> 8) & 0x0000ff00) | ((unsigned int)(objc_ivar->ivar_offset) >> 24) );
}

void
swap_objc_method_list_t(
struct objc_method_list_t *method_list,
enum byte_sex target_byte_sex)
{
 method_list->obsolete = ( ((method_list->obsolete) << 24) | (((method_list->obsolete) << 8) & 0x00ff0000) | (((method_list->obsolete) >> 8) & 0x0000ff00) | ((unsigned int)(method_list->obsolete) >> 24) );
 method_list->method_count = ( ((method_list->method_count) << 24) | (((method_list->method_count) << 8) & 0x00ff0000) | (((method_list->method_count) >> 8) & 0x0000ff00) | ((unsigned int)(method_list->method_count) >> 24) );
}

void
swap_objc_method_t(
struct objc_method_t *method,
enum byte_sex target_byte_sex)
{
 method->method_name = ( ((method->method_name) << 24) | (((method->method_name) << 8) & 0x00ff0000) | (((method->method_name) >> 8) & 0x0000ff00) | ((unsigned int)(method->method_name) >> 24) );
 method->method_types = ( ((method->method_types) << 24) | (((method->method_types) << 8) & 0x00ff0000) | (((method->method_types) >> 8) & 0x0000ff00) | ((unsigned int)(method->method_types) >> 24) );
 method->method_imp = ( ((method->method_imp) << 24) | (((method->method_imp) << 8) & 0x00ff0000) | (((method->method_imp) >> 8) & 0x0000ff00) | ((unsigned int)(method->method_imp) >> 24) );
}

void
swap_objc_protocol_list_t(
struct objc_protocol_list_t *protocol_list,
enum byte_sex target_byte_sex)
{
 protocol_list->next = ( ((protocol_list->next) << 24) | (((protocol_list->next) << 8) & 0x00ff0000) | (((protocol_list->next) >> 8) & 0x0000ff00) | ((unsigned int)(protocol_list->next) >> 24) );
 protocol_list->count = ( ((protocol_list->count) << 24) | (((protocol_list->count) << 8) & 0x00ff0000) | (((protocol_list->count) >> 8) & 0x0000ff00) | ((unsigned int)(protocol_list->count) >> 24) );
}

void
swap_objc_protocol_t(
struct objc_protocol_t *protocol,
enum byte_sex target_byte_sex)
{
 protocol->isa = ( ((protocol->isa) << 24) | (((protocol->isa) << 8) & 0x00ff0000) | (((protocol->isa) >> 8) & 0x0000ff00) | ((unsigned int)(protocol->isa) >> 24) );
 protocol->protocol_name = ( ((protocol->protocol_name) << 24) | (((protocol->protocol_name) << 8) & 0x00ff0000) | (((protocol->protocol_name) >> 8) & 0x0000ff00) | ((unsigned int)(protocol->protocol_name) >> 24) );
 protocol->protocol_list = ( ((protocol->protocol_list) << 24) | (((protocol->protocol_list) << 8) & 0x00ff0000) | (((protocol->protocol_list) >> 8) & 0x0000ff00) | ((unsigned int)(protocol->protocol_list) >> 24) );
 protocol->instance_methods = ( ((protocol->instance_methods) << 24) | (((protocol->instance_methods) << 8) & 0x00ff0000) | (((protocol->instance_methods) >> 8) & 0x0000ff00) | ((unsigned int)(protocol->instance_methods) >> 24) );
 protocol->class_methods = ( ((protocol->class_methods) << 24) | (((protocol->class_methods) << 8) & 0x00ff0000) | (((protocol->class_methods) >> 8) & 0x0000ff00) | ((unsigned int)(protocol->class_methods) >> 24) );
}

void
swap_objc_method_description_list_t(
struct objc_method_description_list_t *mdl,
enum byte_sex target_byte_sex)
{
 mdl->count = ( ((mdl->count) << 24) | (((mdl->count) << 8) & 0x00ff0000) | (((mdl->count) >> 8) & 0x0000ff00) | ((unsigned int)(mdl->count) >> 24) );
}

void
swap_objc_method_description_t(
struct objc_method_description_t *md,
enum byte_sex target_byte_sex)
{
 md->name = ( ((md->name) << 24) | (((md->name) << 8) & 0x00ff0000) | (((md->name) >> 8) & 0x0000ff00) | ((unsigned int)(md->name) >> 24) );
 md->types = ( ((md->types) << 24) | (((md->types) << 8) & 0x00ff0000) | (((md->types) >> 8) & 0x0000ff00) | ((unsigned int)(md->types) >> 24) );
}

void
swap_string_object_t(
struct objc_string_object_t *string_object,
enum byte_sex target_byte_sex)
{
 string_object->isa = ( ((string_object->isa) << 24) | (((string_object->isa) << 8) & 0x00ff0000) | (((string_object->isa) >> 8) & 0x0000ff00) | ((unsigned int)(string_object->isa) >> 24) );
 string_object->characters = ( ((string_object->characters) << 24) | (((string_object->characters) << 8) & 0x00ff0000) | (((string_object->characters) >> 8) & 0x0000ff00) | ((unsigned int)(string_object->characters) >> 24) );
 string_object->_length = ( ((string_object->_length) << 24) | (((string_object->_length) << 8) & 0x00ff0000) | (((string_object->_length) >> 8) & 0x0000ff00) | ((unsigned int)(string_object->_length) >> 24) );
}

void
swap_hashEntry_t(
struct _hashEntry_t *_hashEntry,
enum byte_sex target_byte_sex)
{
 _hashEntry->next = ( ((_hashEntry->next) << 24) | (((_hashEntry->next) << 8) & 0x00ff0000) | (((_hashEntry->next) >> 8) & 0x0000ff00) | ((unsigned int)(_hashEntry->next) >> 24) );
 _hashEntry->sel = ( ((_hashEntry->sel) << 24) | (((_hashEntry->sel) << 8) & 0x00ff0000) | (((_hashEntry->sel) >> 8) & 0x0000ff00) | ((unsigned int)(_hashEntry->sel) >> 24) );
}

struct section_info {
    char *contents;
    uint32_t addr;
    uint32_t size;
    uint32_t offset;
    enum bool protected;
    enum bool zerofill;
};

static void get_objc_sections(
    struct load_command *load_commands,
    uint32_t ncmds,
    uint32_t sizeofcmds,
    enum byte_sex object_byte_sex,
    char *object_addr,
    uint32_t object_size,
    struct section_info **objc_sections,
    uint32_t *nobjc_sections,
    char *sectname,
    char **sect,
    uint32_t *sect_addr,
    uint32_t *sect_size);

static void get_cstring_section(
    struct load_command *load_commands,
    uint32_t ncmds,
    uint32_t sizeofcmds,
    enum byte_sex object_byte_sex,
    char *object_addr,
    uint32_t object_size,
    struct section_info *cstring_section_ptr);

static enum bool print_method_list(
    uint32_t addr,
    struct section_info *objc_sections,
    uint32_t nobjc_sections,
    struct section_info *cstring_section_ptr,
    enum byte_sex host_byte_sex,
    enum bool swapped,
    struct symbol *sorted_symbols,
    uint32_t nsorted_symbols,
    enum bool verbose);

static enum bool print_protocol_list(
    uint32_t indent,
    uint32_t addr,
    struct section_info *objc_sections,
    uint32_t nobjc_sections,
    struct section_info *cstring_section_ptr,
    enum byte_sex host_byte_sex,
    enum bool swapped,
    enum bool verbose);

static void print_protocol(
    uint32_t indent,
    struct objc_protocol_t *protocol,
    struct section_info *objc_sections,
    uint32_t nobjc_sections,
    struct section_info *cstring_section_ptr,
    enum byte_sex host_byte_sex,
    enum bool swapped,
    enum bool verbose);

static enum bool print_method_description_list(
    uint32_t indent,
    uint32_t addr,
    struct section_info *objc_sections,
    uint32_t nobjc_sections,
    struct section_info *cstring_section_ptr,
    enum byte_sex host_byte_sex,
    enum bool swapped,
    enum bool verbose);

static enum bool print_PHASH(
    uint32_t indent,
    uint32_t addr,
    struct section_info *objc_sections,
    uint32_t nobjc_sections,
    struct section_info *cstring_section_ptr,
    enum byte_sex host_byte_sex,
    enum bool swapped,
    enum bool verbose);

static void print_indent(
    uint32_t indent);

static void *get_pointer(
    uint32_t addr,
    uint32_t *left,
    struct section_info *objc_sections,
    uint32_t nobjc_sections,
    struct section_info *cstring_section_ptr);

static enum bool get_symtab(
    uint32_t addr,
    struct objc_symtab_t *symtab,
    uint32_t **defs,
    uint32_t *left,
    enum bool *trunc,
    struct section_info *objc_sections,
    uint32_t nobjc_sections,
    enum byte_sex host_byte_sex,
    enum bool swapped);

static enum bool get_objc_class(
    uint32_t addr,
    struct objc_class_t *objc_class,
    enum bool *trunc,
    struct section_info *objc_sections,
    uint32_t nobjc_sections,
    enum byte_sex host_byte_sex,
    enum bool swapped);

static enum bool get_objc_category(
    uint32_t addr,
    struct objc_category_t *objc_category,
    enum bool *trunc,
    struct section_info *objc_sections,
    uint32_t nobjc_sections,
    enum byte_sex host_byte_sex,
    enum bool swapped);

static enum bool get_ivar_list(
    uint32_t addr,
    struct objc_ivar_list_t *objc_ivar_list,
    struct objc_ivar_t **ivar_list,
    uint32_t *left,
    enum bool *trunc,
    struct section_info *objc_sections,
    uint32_t nobjc_sections,
    enum byte_sex host_byte_sex,
    enum bool swapped);

static enum bool get_method_list(
    uint32_t addr,
    struct objc_method_list_t *method_list,
    struct objc_method_t **methods,
    uint32_t *left,
    enum bool *trunc,
    struct section_info *objc_sections,
    uint32_t nobjc_sections,
    enum byte_sex host_byte_sex,
    enum bool swapped);

static enum bool get_protocol_list(
    uint32_t addr,
    struct objc_protocol_list_t *protocol_list,
    uint32_t **list,
    uint32_t *left,
    enum bool *trunc,
    struct section_info *objc_sections,
    uint32_t nobjc_sections,
    enum byte_sex host_byte_sex,
    enum bool swapped);

static enum bool get_protocol(
    uint32_t addr,
    struct objc_protocol_t *protocol,
    enum bool *trunc,
    struct section_info *objc_sections,
    uint32_t nobjc_sections,
    enum byte_sex host_byte_sex,
    enum bool swapped);

static enum bool get_method_description_list(
    uint32_t addr,
    struct objc_method_description_list_t *mdl,
    struct objc_method_description_t **list,
    uint32_t *left,
    enum bool *trunc,
    struct section_info *objc_sections,
    uint32_t nobjc_sections,
    enum byte_sex host_byte_sex,
    enum bool swapped);

static enum bool get_hashEntry(
    uint32_t addr,
    struct _hashEntry_t *_hashEntry,
    enum bool *trunc,
    struct section_info *objc_sections,
    uint32_t nobjc_sections,
    enum byte_sex host_byte_sex,
    enum bool swapped);




enum bool
print_objc_segment(
cpu_type_t mh_cputype,
struct load_command *load_commands,
uint32_t ncmds,
uint32_t sizeofcmds,
enum byte_sex object_byte_sex,
char *object_addr,
uint32_t object_size,
struct symbol *sorted_symbols,
uint32_t nsorted_symbols,
enum bool verbose)
{
    enum byte_sex host_byte_sex;
    enum bool swapped, trunc;
    uint32_t i, j, left, size, defs_left, def, ivar_list_left;
    char *p;
    struct section_info *objc_sections;
    uint32_t nobjc_sections;
    struct section_info cstring_section;

    struct objc_module_t *modules, *m, module;
    uint32_t modules_addr, modules_size;
    struct objc_symtab_t symtab;
    uint32_t *defs;
    struct objc_class_t objc_class;
    struct objc_ivar_list_t objc_ivar_list;
    struct objc_ivar_t *ivar_list, ivar;
    struct objc_category_t objc_category;

    struct imageInfo_t *imageInfo, info;
    uint32_t imageInfo_addr, imageInfo_size;

 printf("Objective-C segment\n");
 get_objc_sections(load_commands, ncmds, sizeofcmds, object_byte_sex,
     object_addr, object_size, &objc_sections,
     &nobjc_sections, "__module_info", (char **)&modules,
     &modules_addr, &modules_size);

 if(modules == ((void*)0)){
     if(mh_cputype == ((cpu_type_t) 7))
  return(FALSE);
     printf("can't print objective-C information no (" "__OBJC" ","
     "__module_info" ") section\n");
     return(TRUE);
 }

    if (verbose)
        get_cstring_section(load_commands, ncmds, sizeofcmds, object_byte_sex,
                            object_addr, object_size, &cstring_section);

    host_byte_sex = get_host_byte_sex();
 swapped = host_byte_sex != object_byte_sex;

 ((__builtin_object_size (&module, 0) != (size_t) -1) ? __builtin___memset_chk (&module, '\0', sizeof(struct objc_module_t), __builtin_object_size (&module, 0)) : __inline_memset_chk (&module, '\0', sizeof(struct objc_module_t)));

 for(m = modules;
     (char *)m < (char *)modules + modules_size;
     m = (struct objc_module_t *)((char *)m + module.size) ){

     ((__builtin_object_size (&module, 0) != (size_t) -1) ? __builtin___memset_chk (&module, '\0', sizeof(struct objc_module_t), __builtin_object_size (&module, 0)) : __inline_memset_chk (&module, '\0', sizeof(struct objc_module_t)));
     left = modules_size - (m - modules);
     size = left < sizeof(struct objc_module_t) ?
     left : sizeof(struct objc_module_t);
     ((__builtin_object_size (&module, 0) != (size_t) -1) ? __builtin___memcpy_chk (&module, m, size, __builtin_object_size (&module, 0)) : __inline_memcpy_chk (&module, m, size));
     if(swapped)
  swap_objc_module_t(&module, host_byte_sex);

     if((char *)m + module.size > (char *)m + modules_size)
  printf("module extends past end of " "__module_info"
         " section\n");
     printf("Module 0x%x\n", (unsigned int)
     (modules_addr + (char *)m - (char *)modules));

     printf("    version %u\n", module.version);
     printf("       size %u\n", module.size);
     if(verbose){
  p = get_pointer(module.name, &left,
      objc_sections, nobjc_sections, &cstring_section);
  if(p != ((void*)0))
      printf("       name %.*s\n", (int)left, p);
  else
      printf("       name 0x%08x (not in an " "__OBJC"
      " section)\n", (unsigned int)module.name);
     }
     else
  printf("       name 0x%08x\n", (unsigned int)(module.name));

     if(get_symtab(module.symtab, &symtab, &defs, &defs_left, &trunc,
      objc_sections, nobjc_sections,
      host_byte_sex, swapped) == FALSE){
  printf("     symtab 0x%08x (not in an " "__OBJC"
         " section)\n", (unsigned int)module.symtab);
  continue;
     }
     printf("     symtab 0x%08x\n", (unsigned int)module.symtab);
     if(trunc == TRUE)
  printf("\tsymtab extends past end of an " "__OBJC"
         " section\n");
     printf("\tsel_ref_cnt %u\n", symtab.sel_ref_cnt);
     p = get_pointer(symtab.refs, &left,
                     objc_sections, nobjc_sections, &cstring_section);
     if(p != ((void*)0))
  printf("\trefs 0x%08x", symtab.refs);
     else
  printf("\trefs 0x%08x (not in an " "__OBJC" " section)\n",
         symtab.refs);

     printf("\tcls_def_cnt %d\n", symtab.cls_def_cnt);
     printf("\tcat_def_cnt %d\n", symtab.cat_def_cnt);
     if(symtab.cls_def_cnt > 0)
  printf("\tClass Definitions\n");
     for(i = 0; i < symtab.cls_def_cnt; i++){
  if((i + 1) * sizeof(uint32_t) > defs_left){
      printf("\t(remaining class defs entries entends past "
      "the end of the section)\n");
      break;
  }

  ((__builtin_object_size (&def, 0) != (size_t) -1) ? __builtin___memcpy_chk (&def, defs + i, sizeof(uint32_t), __builtin_object_size (&def, 0)) : __inline_memcpy_chk (&def, defs + i, sizeof(uint32_t)));
  if(swapped)
      def = ( ((def) << 24) | (((def) << 8) & 0x00ff0000) | (((def) >> 8) & 0x0000ff00) | ((unsigned int)(def) >> 24) );

  if(get_objc_class(def, &objc_class, &trunc, objc_sections,
     nobjc_sections, host_byte_sex, swapped) == TRUE){
      printf("\tdefs[%u] 0x%08x", i, def);
print_objc_class:
      if(trunc == TRUE)
   printf(" (entends past the end of the section)\n");
      else
   printf("\n");
      printf("\t\t      isa 0x%08x", objc_class.isa);

      if(verbose && CLS_GETINFO(&objc_class, CLS_META)){
   p = get_pointer(objc_class.isa, &left, objc_sections,
     nobjc_sections, &cstring_section);
   if(p != ((void*)0))
       printf(" %.*s\n", (int)left, p);
   else
       printf(" (not in an " "__OBJC" " section)\n");
      }
      else
   printf("\n");

      printf("\t      super_class 0x%08x",objc_class.super_class);
      if(verbose){
   p = get_pointer(objc_class.super_class, &left,
     objc_sections, nobjc_sections, &cstring_section);
   if(p != ((void*)0))
       printf(" %.*s\n", (int)left, p);
   else
       printf(" (not in an " "__OBJC" " section)\n");
      }
      else
   printf("\n");

      printf("\t\t     name 0x%08x", objc_class.name);
      if(verbose){
   p = get_pointer(objc_class.name, &left,
     objc_sections, nobjc_sections, &cstring_section);
   if(p != ((void*)0))
       printf(" %.*s\n", (int)left, p);
   else
       printf(" (not in an " "__OBJC" " section)\n");
      }
      else
   printf("\n");
      printf("\t\t  version 0x%08x\n",
      (unsigned int)objc_class.version);
      printf("\t\t     info 0x%08x",
      (unsigned int)objc_class.info);
      if(verbose){
   if(CLS_GETINFO(&objc_class, CLS_CLASS))
       printf(" CLS_CLASS\n");
   else if(CLS_GETINFO(&objc_class, CLS_META))
       printf(" CLS_META\n");
   else
       printf("\n");
      }
      else
   printf("\n");
      printf("\t    instance_size 0x%08x\n",
      (unsigned int)objc_class.instance_size);

      if(get_ivar_list(objc_class.ivars, &objc_ivar_list,
       &ivar_list, &ivar_list_left, &trunc,
       objc_sections, nobjc_sections, host_byte_sex,
       swapped) == TRUE){
   printf("\t\t    ivars 0x%08x\n",
          (unsigned int)objc_class.ivars);
   if(trunc == TRUE)
       printf("\t\t objc_ivar_list extends past end "
       "of " "__symbol_table" " section\n");
   printf("\t\t       ivar_count %d\n",
        objc_ivar_list.ivar_count);
   for(j = 0;
       j < (uint32_t)objc_ivar_list.ivar_count;
       j++){
       if((j + 1) * sizeof(struct objc_ivar_t) >
          ivar_list_left){
    printf("\t\t remaining ivar's extend past "
           "the of the section\n");
    break;
       }
       ((__builtin_object_size (&ivar, 0) != (size_t) -1) ? __builtin___memcpy_chk (&ivar, ivar_list + j, sizeof(struct objc_ivar_t), __builtin_object_size (&ivar, 0)) : __inline_memcpy_chk (&ivar, ivar_list + j, sizeof(struct objc_ivar_t)));

       if(swapped)
    swap_objc_ivar_t(&ivar, host_byte_sex);

       printf("\t\t\tivar_name 0x%08x",
       (unsigned int)ivar.ivar_name);
       if(verbose){
    p = get_pointer(ivar.ivar_name, &left,
         objc_sections, nobjc_sections, &cstring_section);
    if(p != ((void*)0))
        printf(" %.*s\n", (int)left, p);
    else
        printf(" (not in an " "__OBJC"
        " section)\n");
       }
       else
    printf("\n");
       printf("\t\t\tivar_type 0x%08x",
       (unsigned int)ivar.ivar_type);
       if(verbose){
    p = get_pointer(ivar.ivar_type, &left,
         objc_sections, nobjc_sections, &cstring_section);
    if(p != ((void*)0))
        printf(" %.*s\n", (int)left, p);
    else
        printf(" (not in an " "__OBJC"
        " section)\n");
       }
       else
    printf("\n");
       printf("\t\t      ivar_offset 0x%08x\n",
       (unsigned int)ivar.ivar_offset);
   }
      }
      else{
   printf("\t\t    ivars 0x%08x (not in an " "__OBJC"
          " section)\n",
          (unsigned int)objc_class.ivars);
      }

      printf("\t\t  methods 0x%08x",
      (unsigned int)objc_class.methodLists);
      if(print_method_list(objc_class.methodLists,
      objc_sections, nobjc_sections,
      &cstring_section,
      host_byte_sex, swapped, sorted_symbols,
      nsorted_symbols, verbose) == FALSE)
   printf(" (not in an " "__OBJC" " section)\n");

      printf("\t\t    cache 0x%08x\n",
      (unsigned int)objc_class.cache);

      printf("\t\tprotocols 0x%08x",
      (unsigned int)objc_class.protocols);
      if(print_protocol_list(16, objc_class.protocols,
   objc_sections, nobjc_sections, &cstring_section,
   host_byte_sex, swapped, verbose) == FALSE)
   printf(" (not in an " "__OBJC" " section)\n");

      if(CLS_GETINFO((&objc_class), CLS_CLASS)){
   printf("\tMeta Class");
   if(get_objc_class((uint32_t)objc_class.isa,
        &objc_class, &trunc, objc_sections, nobjc_sections,
        host_byte_sex, swapped) == TRUE){
       goto print_objc_class;
   }
   else
       printf(" (not in " "__symbol_table"
       " section)\n");
      }
  }
  else
      printf("\tdefs[%u] 0x%08x (not in an " "__OBJC"
      " section)\n", i, (unsigned int)def);
     }
     if(symtab.cat_def_cnt > 0)
  printf("\tCategory Definitions\n");
     for(i = 0; i < symtab.cat_def_cnt; i++){
  if((i + symtab.cls_def_cnt + 1) * sizeof(uint32_t) >
             defs_left){
      printf("\t(remaining category defs entries entends "
      "past the end of the section)\n");
      break;
  }

  ((__builtin_object_size (&def, 0) != (size_t) -1) ? __builtin___memcpy_chk (&def, defs + i + symtab.cls_def_cnt, sizeof(uint32_t), __builtin_object_size (&def, 0)) : __inline_memcpy_chk (&def, defs + i + symtab.cls_def_cnt, sizeof(uint32_t)));
  if(swapped)
      def = ( ((def) << 24) | (((def) << 8) & 0x00ff0000) | (((def) >> 8) & 0x0000ff00) | ((unsigned int)(def) >> 24) );

  if(get_objc_category(def, &objc_category, &trunc,
     objc_sections, nobjc_sections,
              host_byte_sex, swapped) == TRUE){
      printf("\tdefs[%u] 0x%08x", i + symtab.cls_def_cnt,
      (unsigned int)def);
      if(trunc == TRUE)
   printf(" (entends past the end of the section)\n");
      else
   printf("\n");
      printf("\t       category name 0x%08x",
      objc_category.category_name);
      if(verbose){
   p = get_pointer(objc_category.category_name, &left,
     objc_sections, nobjc_sections,
     &cstring_section);
   if(p != ((void*)0))
       printf(" %.*s\n", (int)left, p);
   else
       printf(" (not in an " "__OBJC" " section)\n");
      }
      else
   printf("\n");

      printf("\t\t  class name 0x%08x", objc_category.class_name);
      if(verbose){
   p = get_pointer(objc_category.class_name, &left,
     objc_sections, nobjc_sections,
     &cstring_section);
   if(p != ((void*)0))
       printf(" %.*s\n", (int)left, p);
   else
       printf(" (not in an " "__OBJC" " section)\n");
      }
      else
   printf("\n");

      printf("\t    instance methods 0x%08x",
      objc_category.instance_methods);
      if(print_method_list(objc_category.instance_methods,
      objc_sections, nobjc_sections,
      &cstring_section,
      host_byte_sex, swapped,
      sorted_symbols, nsorted_symbols,
      verbose) == FALSE)
   printf(" (not in an " "__OBJC" " section)\n");

      printf("\t       class methods 0x%08x",
      objc_category.class_methods);
      if(print_method_list(objc_category.class_methods,
   objc_sections, nobjc_sections, &cstring_section,
   host_byte_sex, swapped, sorted_symbols, nsorted_symbols,
   verbose) == FALSE)
   printf(" (not in an " "__OBJC" " section)\n");
  }
  else
      printf("\tdefs[%u] 0x%08x (not in an " "__OBJC"
      " section)\n", i + symtab.cls_def_cnt,
      (unsigned int)def);
     }
 }

 printf("Contents of (%s,%s) section\n", "__OBJC", "__image_info");
 get_objc_sections(load_commands, ncmds, sizeofcmds, object_byte_sex,
     object_addr, object_size, &objc_sections,
     &nobjc_sections, "__image_info", (char **)&imageInfo,
     &imageInfo_addr, &imageInfo_size);
 ((__builtin_object_size (&info, 0) != (size_t) -1) ? __builtin___memset_chk (&info, '\0', sizeof(struct imageInfo_t), __builtin_object_size (&info, 0)) : __inline_memset_chk (&info, '\0', sizeof(struct imageInfo_t)));
 if(imageInfo_size < sizeof(struct imageInfo_t)){
     ((__builtin_object_size (&info, 0) != (size_t) -1) ? __builtin___memcpy_chk (&info, imageInfo, imageInfo_size, __builtin_object_size (&info, 0)) : __inline_memcpy_chk (&info, imageInfo, imageInfo_size));
     printf(" (imageInfo entends past the end of the section)\n");
 }
 else
     ((__builtin_object_size (&info, 0) != (size_t) -1) ? __builtin___memcpy_chk (&info, imageInfo, sizeof(struct imageInfo_t), __builtin_object_size (&info, 0)) : __inline_memcpy_chk (&info, imageInfo, sizeof(struct imageInfo_t)));
 if(swapped)
     swap_imageInfo_t(&info, host_byte_sex);
 printf("  version %u\n", info.version);
 printf("    flags 0x%x", info.flags);
 if(info.flags & 0x1)
     printf("  F&C");
 if(info.flags & 0x2)
     printf(" GC");
 if(info.flags & 0x4)
     printf(" GC-only");
 else
     printf(" RR");
 printf("\n");
 return(TRUE);
}

void
print_objc_protocol_section(
struct load_command *load_commands,
uint32_t ncmds,
uint32_t sizeofcmds,
enum byte_sex object_byte_sex,
char *object_addr,
uint32_t object_size,
enum bool verbose)
{
    enum byte_sex host_byte_sex;
    enum bool swapped;
    struct section_info *objc_sections, cstring_section;
    uint32_t nobjc_sections;
    struct objc_protocol_t *protocols, *p, protocol;
    uint32_t protocols_addr, protocols_size;
    uint32_t size, left;

 printf("Contents of (" "__OBJC" ",__protocol) section\n");
 get_objc_sections(load_commands, ncmds, sizeofcmds, object_byte_sex,
     object_addr, object_size, &objc_sections,
     &nobjc_sections, "__protocol", (char **)&protocols,
     &protocols_addr, &protocols_size);

    if (verbose)
        get_cstring_section(load_commands, ncmds, sizeofcmds, object_byte_sex,
                            object_addr, object_size, &cstring_section);

    host_byte_sex = get_host_byte_sex();
 swapped = host_byte_sex != object_byte_sex;

 for(p = protocols; (char *)p < (char *)protocols + protocols_size; p++){

     ((__builtin_object_size (&protocol, 0) != (size_t) -1) ? __builtin___memset_chk (&protocol, '\0', sizeof(struct objc_protocol_t), __builtin_object_size (&protocol, 0)) : __inline_memset_chk (&protocol, '\0', sizeof(struct objc_protocol_t)));
     left = protocols_size - (p - protocols);
     size = left < sizeof(struct objc_protocol_t) ?
     left : sizeof(struct objc_protocol_t);
     ((__builtin_object_size (&protocol, 0) != (size_t) -1) ? __builtin___memcpy_chk (&protocol, p, size, __builtin_object_size (&protocol, 0)) : __inline_memcpy_chk (&protocol, p, size));

     if((char *)p + sizeof(struct objc_protocol_t) >
        (char *)p + protocols_size)
  printf("Protocol extends past end of __protocol section\n");
     printf("Protocol 0x%x\n", (unsigned int)
     (protocols_addr + (char *)p - (char *)protocols));

     print_protocol(0, &protocol,
         objc_sections, nobjc_sections, &cstring_section,
         host_byte_sex, swapped, verbose);
 }
}

void
print_objc_string_object_section(
char *sectname,
struct load_command *load_commands,
uint32_t ncmds,
uint32_t sizeofcmds,
enum byte_sex object_byte_sex,
char *object_addr,
uint32_t object_size,
enum bool verbose)
{
    enum byte_sex host_byte_sex;
    enum bool swapped;
    struct section_info *objc_sections;
    uint32_t nobjc_sections;
    struct section_info cstring_section;
    struct objc_string_object_t *string_objects, *s, string_object;
    uint32_t string_objects_addr, string_objects_size;
    uint32_t size, left;
    char *p;

 printf("Contents of (" "__OBJC" ",%s) section\n", sectname);
 get_objc_sections(load_commands, ncmds, sizeofcmds, object_byte_sex,
     object_addr, object_size, &objc_sections,
     &nobjc_sections, sectname, (char **)&string_objects,
     &string_objects_addr, &string_objects_size);

 get_cstring_section(load_commands, ncmds, sizeofcmds, object_byte_sex,
       object_addr, object_size, &cstring_section);

 host_byte_sex = get_host_byte_sex();
 swapped = host_byte_sex != object_byte_sex;

 for(s = string_objects;
     (char *)s < (char *)string_objects + string_objects_size;
     s++){

     ((__builtin_object_size (&string_object, 0) != (size_t) -1) ? __builtin___memset_chk (&string_object, '\0', sizeof(struct objc_string_object_t), __builtin_object_size (&string_object, 0)) : __inline_memset_chk (&string_object, '\0', sizeof(struct objc_string_object_t)));
     left = string_objects_size - (s - string_objects);
     size = left < sizeof(struct objc_string_object_t) ?
     left : sizeof(struct objc_string_object_t);
     ((__builtin_object_size (&string_object, 0) != (size_t) -1) ? __builtin___memcpy_chk (&string_object, s, size, __builtin_object_size (&string_object, 0)) : __inline_memcpy_chk (&string_object, s, size));

     if((char *)s + sizeof(struct objc_string_object_t) >
        (char *)s + string_objects_size)
  printf("String Object extends past end of %s section\n",
         sectname);
     printf("String Object 0x%x\n", (unsigned int)
     (string_objects_addr + (char *)s - (char *)string_objects));

     if(swapped)
  swap_string_object_t(&string_object, host_byte_sex);
     printf("           isa 0x%x\n", string_object.isa);
     printf("    characters 0x%x",
     (unsigned int)string_object.characters);
     if(verbose){
  p = get_pointer(string_object.characters, &left,
           &cstring_section, 1, &cstring_section);
  if(p != ((void*)0))
      printf(" %.*s\n", (int)left, p);
  else
      printf(" (not in the (" "__TEXT" ",__cstring) section)\n");
     }
     else
  printf("\n");
     printf("       _length %u\n", string_object._length);
 }
}





void
print_objc_runtime_setup_section(
struct load_command *load_commands,
uint32_t ncmds,
uint32_t sizeofcmds,
enum byte_sex object_byte_sex,
char *object_addr,
uint32_t object_size,
enum bool verbose)
{

    enum byte_sex host_byte_sex;
    enum bool swapped;
    struct section_info *objc_sections, cstring_section;
    uint32_t i, nobjc_sections, left;
    struct _hashEntry_t **PHASH, *HASH, _hashEntry;
    char *sect, *p;
    uint32_t sect_addr, sect_size, phash;

 printf("Contents of (" "__OBJC" ",__runtime_setup) section\n");
 get_objc_sections(load_commands, ncmds, sizeofcmds, object_byte_sex,
     object_addr, object_size, &objc_sections,
     &nobjc_sections, "__runtime_setup", &sect, &sect_addr,
     &sect_size);

    if (verbose)
        get_cstring_section(load_commands, ncmds, sizeofcmds, object_byte_sex,
                            object_addr, object_size, &cstring_section);

    host_byte_sex = get_host_byte_sex();
 swapped = host_byte_sex != object_byte_sex;

 PHASH = (struct _hashEntry_t **)sect;
 for(i = 0;
     i < 821 && (i + 1) * sizeof(uint32_t) < sect_size;
     i++){

     ((__builtin_object_size (&phash, 0) != (size_t) -1) ? __builtin___memcpy_chk (&phash, PHASH + i, sizeof(uint32_t), __builtin_object_size (&phash, 0)) : __inline_memcpy_chk (&phash, PHASH + i, sizeof(uint32_t)));
     if(swapped)
  phash = ( ((phash) << 24) | (((phash) << 8) & 0x00ff0000) | (((phash) >> 8) & 0x0000ff00) | ((unsigned int)(phash) >> 24) );

     if(phash == 0)
  continue;

     printf("PHASH[%3u] 0x%x", i, (unsigned int)phash);
     if(print_PHASH(4, phash,
      objc_sections, nobjc_sections, &cstring_section,
      host_byte_sex, swapped, verbose) == FALSE)
  printf(" (not in an " "__OBJC" " section)\n");
 }

 HASH = (struct _hashEntry_t *)(PHASH + 821);
 for(i = 0; (char *)(HASH + i) < sect + sect_size; i++){
     ((__builtin_object_size ((char *)&_hashEntry, 0) != (size_t) -1) ? __builtin___memcpy_chk ((char *)&_hashEntry, HASH + i, sizeof(struct _hashEntry_t), __builtin_object_size ((char *)&_hashEntry, 0)) : __inline_memcpy_chk ((char *)&_hashEntry, HASH + i, sizeof(struct _hashEntry_t)));
     if(swapped)
  swap_hashEntry_t(&_hashEntry, host_byte_sex);

     printf("HASH at 0x%08x\n",
     (unsigned int)(sect_addr + (char *)(HASH + i) - sect));
     printf("     sel 0x%08x", (unsigned int)_hashEntry.sel);
     if(verbose){
  p = get_pointer(_hashEntry.sel, &left, objc_sections,
    nobjc_sections, &cstring_section);
  if(p != ((void*)0))
      printf(" %.*s\n", (int)left, p);
  else
      printf(" (not in an " "__OBJC" " section)\n");
     }
     else
  printf("\n");

     printf("    next 0x%08x", (unsigned int)_hashEntry.next);
     if(_hashEntry.next == 0){
  printf("\n");
     }
     else{
  if((uint32_t)_hashEntry.next < sect_addr ||
     (uint32_t)_hashEntry.next >= sect_addr + sect_size)
      printf(" (not in the (""__OBJC" ",__runtime_setup "
      "section)\n");
  else
      printf("\n");
     }
 }
}

static
void
get_objc_sections(
struct load_command *load_commands,
uint32_t ncmds,
uint32_t sizeofcmds,
enum byte_sex object_byte_sex,
char *object_addr,
uint32_t object_size,
struct section_info **objc_sections,
uint32_t *nobjc_sections,
char *sectname,
char **sect,
uint32_t *sect_addr,
uint32_t *sect_size)
{
    enum byte_sex host_byte_sex;
    enum bool swapped, encrypt_found;

    uint32_t i, j, left, size;
    struct load_command lcmd, *lc;
    char *p;
    struct segment_command sg;
    struct section s;
    struct encryption_info_command encrypt;

 host_byte_sex = get_host_byte_sex();
 swapped = host_byte_sex != object_byte_sex;

 *objc_sections = ((void*)0);
 *nobjc_sections = 0;
 *sect = ((void*)0);
 *sect_addr = 0;
 *sect_size = 0;
 encrypt_found = FALSE;

 lc = load_commands;
 for(i = 0 ; i < ncmds; i++){
     ((__builtin_object_size ((char *)&lcmd, 0) != (size_t) -1) ? __builtin___memcpy_chk ((char *)&lcmd, (char *)lc, sizeof(struct load_command), __builtin_object_size ((char *)&lcmd, 0)) : __inline_memcpy_chk ((char *)&lcmd, (char *)lc, sizeof(struct load_command)));
     if(swapped)
  swap_load_command(&lcmd, host_byte_sex);
     if(lcmd.cmdsize % sizeof(int32_t) != 0)
  printf("load command %u size not a multiple of "
         "sizeof(int32_t)\n", i);
     if((char *)lc + lcmd.cmdsize >
        (char *)load_commands + sizeofcmds)
  printf("load command %u extends past end of load "
         "commands\n", i);
     left = sizeofcmds - ((char *)lc - (char *)load_commands);

     switch(lcmd.cmd){
     case 0x1:
  ((__builtin_object_size ((char *)&sg, 0) != (size_t) -1) ? __builtin___memset_chk ((char *)&sg, '\0', sizeof(struct segment_command), __builtin_object_size ((char *)&sg, 0)) : __inline_memset_chk ((char *)&sg, '\0', sizeof(struct segment_command)));
  size = left < sizeof(struct segment_command) ?
         left : sizeof(struct segment_command);
  ((__builtin_object_size ((char *)&sg, 0) != (size_t) -1) ? __builtin___memcpy_chk ((char *)&sg, (char *)lc, size, __builtin_object_size ((char *)&sg, 0)) : __inline_memcpy_chk ((char *)&sg, (char *)lc, size));
  if(swapped)
      swap_segment_command(&sg, host_byte_sex);

  p = (char *)lc + sizeof(struct segment_command);
  for(j = 0 ; j < sg.nsects ; j++){
      if(p + sizeof(struct section) >
         (char *)load_commands + sizeofcmds){
   printf("section structure command extends past "
          "end of load commands\n");
      }
      left = sizeofcmds - (p - (char *)load_commands);
      ((__builtin_object_size ((char *)&s, 0) != (size_t) -1) ? __builtin___memset_chk ((char *)&s, '\0', sizeof(struct section), __builtin_object_size ((char *)&s, 0)) : __inline_memset_chk ((char *)&s, '\0', sizeof(struct section)));
      size = left < sizeof(struct section) ?
      left : sizeof(struct section);
      ((__builtin_object_size ((char *)&s, 0) != (size_t) -1) ? __builtin___memcpy_chk ((char *)&s, p, size, __builtin_object_size ((char *)&s, 0)) : __inline_memcpy_chk ((char *)&s, p, size));
      if(swapped)
   swap_section(&s, 1, host_byte_sex);

      if(strcmp(s.segname, "__OBJC") == 0){
   *objc_sections = reallocate(*objc_sections,
      sizeof(struct section_info) * (*nobjc_sections + 1));
   (*objc_sections)[*nobjc_sections].addr = s.addr;
   (*objc_sections)[*nobjc_sections].contents =
        object_addr + s.offset;
   (*objc_sections)[*nobjc_sections].offset = s.offset;
          (*objc_sections)[*nobjc_sections].zerofill =
     (s.flags & 0x000000ff) == 0x1 ? TRUE : FALSE;
   if(s.offset > object_size){
       printf("section contents of: (%.16s,%.16s) is past "
       "end of file\n", s.segname, s.sectname);
       (*objc_sections)[*nobjc_sections].size = 0;
   }
   else if(s.offset + s.size > object_size){
       printf("part of section contents of: (%.16s,%.16s) "
       "is past end of file\n",
       s.segname, s.sectname);
       (*objc_sections)[*nobjc_sections].size =
    object_size - s.offset;
   }
   else
       (*objc_sections)[*nobjc_sections].size = s.size;

   if(strncmp(s.sectname, sectname, 16) == 0){
       if(*sect != ((void*)0))
    printf("more than one (" "__OBJC" ",%s) "
           "section\n", sectname);
       else{
    *sect = (object_addr + s.offset);
    *sect_size = s.size;
    *sect_addr = s.addr;
       }
   }
   if(sg.flags & 0x8)
       (*objc_sections)[*nobjc_sections].protected = TRUE;
   else
       (*objc_sections)[*nobjc_sections].protected = FALSE;
   (*nobjc_sections)++;
      }

      if(p + sizeof(struct section) >
         (char *)load_commands + sizeofcmds)
   break;
      p += size;
  }
  break;
     case 0x21:
  ((__builtin_object_size ((char *)&encrypt, 0) != (size_t) -1) ? __builtin___memset_chk ((char *)&encrypt, '\0', sizeof(struct encryption_info_command), __builtin_object_size ((char *)&encrypt, 0)) : __inline_memset_chk ((char *)&encrypt, '\0', sizeof(struct encryption_info_command)));

  size = left < sizeof(struct encryption_info_command) ?
         left : sizeof(struct encryption_info_command);
  ((__builtin_object_size ((char *)&encrypt, 0) != (size_t) -1) ? __builtin___memcpy_chk ((char *)&encrypt, (char *)lc, size, __builtin_object_size ((char *)&encrypt, 0)) : __inline_memcpy_chk ((char *)&encrypt, (char *)lc, size));
  if(swapped)
      swap_encryption_command(&encrypt, host_byte_sex);
  encrypt_found = TRUE;
  break;
     }
     if(lcmd.cmdsize == 0){
  printf("load command %u size zero (can't advance to other "
         "load commands)\n", i);
  break;
     }
     lc = (struct load_command *)((char *)lc + lcmd.cmdsize);
     if((char *)lc > (char *)load_commands + sizeofcmds)
  break;
 }

 if(encrypt_found == TRUE && encrypt.cryptid != 0){
     for(i = 0; i < *nobjc_sections; i++){
  if((*objc_sections)[i].size > 0 &&
     (*objc_sections)[i].zerofill == FALSE){
      if((*objc_sections)[i].offset >
         encrypt.cryptoff + encrypt.cryptsize){
                                             ;
      }
      else if((*objc_sections)[i].offset +
       (*objc_sections)[i].size < encrypt.cryptoff){
                                             ;
      }
      else{

   (*objc_sections)[i].protected = TRUE;
      }
  }
     }
 }
}

static
void
get_cstring_section(
struct load_command *load_commands,
uint32_t ncmds,
uint32_t sizeofcmds,
enum byte_sex object_byte_sex,
char *object_addr,
uint32_t object_size,
struct section_info *cstring_section)
{
    enum byte_sex host_byte_sex;
    enum bool swapped;

    uint32_t i, j, left, size;
    struct load_command lcmd, *lc;
    char *p;
    struct segment_command sg;
    struct section s;

 host_byte_sex = get_host_byte_sex();
 swapped = host_byte_sex != object_byte_sex;

 ((__builtin_object_size (cstring_section, 0) != (size_t) -1) ? __builtin___memset_chk (cstring_section, '\0', sizeof(struct section_info), __builtin_object_size (cstring_section, 0)) : __inline_memset_chk (cstring_section, '\0', sizeof(struct section_info)));

 lc = load_commands;
 for(i = 0 ; i < ncmds; i++){
     ((__builtin_object_size ((char *)&lcmd, 0) != (size_t) -1) ? __builtin___memcpy_chk ((char *)&lcmd, (char *)lc, sizeof(struct load_command), __builtin_object_size ((char *)&lcmd, 0)) : __inline_memcpy_chk ((char *)&lcmd, (char *)lc, sizeof(struct load_command)));
     if(swapped)
  swap_load_command(&lcmd, host_byte_sex);
     if(lcmd.cmdsize % sizeof(int32_t) != 0)
  printf("load command %u size not a multiple of "
         "sizeof(int32_t)\n", i);
     if((char *)lc + lcmd.cmdsize >
        (char *)load_commands + sizeofcmds)
  printf("load command %u extends past end of load "
         "commands\n", i);
     left = sizeofcmds - ((char *)lc - (char *)load_commands);

     switch(lcmd.cmd){
     case 0x1:
  ((__builtin_object_size ((char *)&sg, 0) != (size_t) -1) ? __builtin___memset_chk ((char *)&sg, '\0', sizeof(struct segment_command), __builtin_object_size ((char *)&sg, 0)) : __inline_memset_chk ((char *)&sg, '\0', sizeof(struct segment_command)));
  size = left < sizeof(struct segment_command) ?
         left : sizeof(struct segment_command);
  ((__builtin_object_size ((char *)&sg, 0) != (size_t) -1) ? __builtin___memcpy_chk ((char *)&sg, (char *)lc, size, __builtin_object_size ((char *)&sg, 0)) : __inline_memcpy_chk ((char *)&sg, (char *)lc, size));
  if(swapped)
      swap_segment_command(&sg, host_byte_sex);

  p = (char *)lc + sizeof(struct segment_command);
  for(j = 0 ; j < sg.nsects ; j++){
      if(p + sizeof(struct section) >
         (char *)load_commands + sizeofcmds){
   printf("section structure command extends past "
          "end of load commands\n");
      }
      left = sizeofcmds - (p - (char *)load_commands);
      ((__builtin_object_size ((char *)&s, 0) != (size_t) -1) ? __builtin___memset_chk ((char *)&s, '\0', sizeof(struct section), __builtin_object_size ((char *)&s, 0)) : __inline_memset_chk ((char *)&s, '\0', sizeof(struct section)));
      size = left < sizeof(struct section) ?
      left : sizeof(struct section);
      ((__builtin_object_size ((char *)&s, 0) != (size_t) -1) ? __builtin___memcpy_chk ((char *)&s, p, size, __builtin_object_size ((char *)&s, 0)) : __inline_memcpy_chk ((char *)&s, p, size));
      if(swapped)
   swap_section(&s, 1, host_byte_sex);

      if(strcmp(s.segname, "__TEXT") == 0 &&
         strcmp(s.sectname, "__cstring") == 0){
   cstring_section->addr = s.addr;
   cstring_section->contents = object_addr + s.offset;
   if(s.offset > object_size){
       printf("section contents of: (%.16s,%.16s) is past "
       "end of file\n", s.segname, s.sectname);
       cstring_section->size = 0;
   }
   else if(s.offset + s.size > object_size){
       printf("part of section contents of: (%.16s,%.16s) "
       "is past end of file\n",
       s.segname, s.sectname);
       cstring_section->size = object_size - s.offset;
   }
   else
       cstring_section->size = s.size;
   if(sg.flags & 0x8)
       cstring_section->protected = TRUE;
   else
       cstring_section->protected = FALSE;
   return;
      }

      if(p + sizeof(struct section) >
         (char *)load_commands + sizeofcmds)
   break;
      p += size;
  }
  break;
     }
     if(lcmd.cmdsize == 0){
  printf("load command %u size zero (can't advance to other "
         "load commands)\n", i);
  break;
     }
     lc = (struct load_command *)((char *)lc + lcmd.cmdsize);
     if((char *)lc > (char *)load_commands + sizeofcmds)
  break;
 }
}

static
enum bool
print_method_list(
uint32_t addr,
struct section_info *objc_sections,
uint32_t nobjc_sections,
struct section_info *cstring_section_ptr,
enum byte_sex host_byte_sex,
enum bool swapped,
struct symbol *sorted_symbols,
uint32_t nsorted_symbols,
enum bool verbose)
{
    struct objc_method_t *methods, method;
    struct objc_method_list_t method_list;
    enum bool trunc;
    uint32_t i, methods_left, left;
    char *p;

 if(get_method_list(addr, &method_list, &methods, &methods_left, &trunc,
      objc_sections, nobjc_sections,
      host_byte_sex, swapped) == FALSE)
     return(FALSE);

 printf("\n");
 if(trunc == TRUE)
     printf("\t\t objc_method_list extends past end of the section\n");

 printf("\t\t         obsolete 0x%08x\n",
        (unsigned int)method_list.obsolete);
 printf("\t\t     method_count %d\n",
        method_list.method_count);

 for(i = 0; i < (uint32_t)method_list.method_count; i++){
     if((i + 1) * sizeof(struct objc_method_t) > methods_left){
  printf("\t\t remaining method's extend past the of the "
         "section\n");
  break;
     }
     ((__builtin_object_size (&method, 0) != (size_t) -1) ? __builtin___memcpy_chk (&method, methods + i, sizeof(struct objc_method_t), __builtin_object_size (&method, 0)) : __inline_memcpy_chk (&method, methods + i, sizeof(struct objc_method_t)));
     if(swapped)
  swap_objc_method_t(&method, host_byte_sex);

     printf("\t\t      method_name 0x%08x", method.method_name);
     if(verbose){
  p = get_pointer(method.method_name, &left, objc_sections,
    nobjc_sections, cstring_section_ptr);
  if(p != ((void*)0))
      printf(" %.*s\n", (int)left, p);
  else
      printf(" (not in an " "__OBJC" " section)\n");
     }
     else
  printf("\n");

     printf("\t\t     method_types 0x%08x", method.method_types);
     if(verbose){
  p = get_pointer(method.method_types, &left, objc_sections,
    nobjc_sections, cstring_section_ptr);
  if(p != ((void*)0))
      printf(" %.*s\n", (int)left, p);
  else
      printf(" (not in an " "__OBJC" " section)\n");
     }
     else
  printf("\n");
     printf("\t\t       method_imp 0x%08x ", method.method_imp);
     if(verbose)
  print_label(method.method_imp, FALSE, sorted_symbols,
       nsorted_symbols);
     printf("\n");
 }
 return(TRUE);
}

static
enum bool
print_protocol_list(
uint32_t indent,
uint32_t addr,
struct section_info *objc_sections,
uint32_t nobjc_sections,
struct section_info *cstring_section_ptr,
enum byte_sex host_byte_sex,
enum bool swapped,
enum bool verbose)
{
    uint32_t *list;
    struct objc_protocol_t protocol;
    struct objc_protocol_list_t protocol_list;
    enum bool trunc;
    uint32_t l, i, list_left;

 if(get_protocol_list(addr, &protocol_list, &list, &list_left, &trunc,
        objc_sections, nobjc_sections,
        host_byte_sex, swapped) == FALSE)
     return(FALSE);

 printf("\n");
 if(trunc == TRUE){
     print_indent(indent);
     printf(" objc_protocol_list extends past end of the section\n");
 }

 print_indent(indent);
 printf("         next 0x%08x\n",
        (unsigned int)protocol_list.next);
 print_indent(indent);
 printf("        count %u\n", protocol_list.count);

 for(i = 0; i < protocol_list.count; i++){
     if((i + 1) * sizeof(uint32_t) > list_left){
  print_indent(indent);
  printf(" remaining list entries extend past the of the "
         "section\n");
  break;
     }
     ((__builtin_object_size (&l, 0) != (size_t) -1) ? __builtin___memcpy_chk (&l, list + i, sizeof(uint32_t), __builtin_object_size (&l, 0)) : __inline_memcpy_chk (&l, list + i, sizeof(uint32_t)));
     if(swapped)
  l = ( ((l) << 24) | (((l) << 8) & 0x00ff0000) | (((l) >> 8) & 0x0000ff00) | ((unsigned int)(l) >> 24) );

     print_indent(indent);
     printf("      list[%u] 0x%08x", i, l);
     if(get_protocol(l, &protocol, &trunc, objc_sections, nobjc_sections,
   host_byte_sex, swapped) == FALSE){
  printf(" (not in an " "__OBJC" " section)\n");
  continue;
     }
     printf("\n");
     if(trunc == TRUE){
  print_indent(indent);
  printf("            Protocol extends past end of the "
   "section\n");
     }
     print_protocol(indent, &protocol,
      objc_sections, nobjc_sections, cstring_section_ptr,
      host_byte_sex, swapped, verbose);
 }
 return(TRUE);
}

static
void
print_protocol(
uint32_t indent,
struct objc_protocol_t *protocol,
struct section_info *objc_sections,
uint32_t nobjc_sections,
struct section_info *cstring_section_ptr,
enum byte_sex host_byte_sex,
enum bool swapped,
enum bool verbose)
{
    uint32_t left;
    char *p;

 print_indent(indent);
 printf("              isa 0x%08x\n",
  (unsigned int)protocol->isa);
 print_indent(indent);
 printf("    protocol_name 0x%08x",
  (unsigned int)protocol->protocol_name);
 if(verbose){
     p = get_pointer(protocol->protocol_name, &left,
      objc_sections, nobjc_sections, cstring_section_ptr);
     if(p != ((void*)0))
  printf(" %.*s\n", (int)left, p);
     else
  printf(" (not in an " "__OBJC" " section)\n");
 }
 else
     printf("\n");
 print_indent(indent);
 printf("    protocol_list 0x%08x",
  (unsigned int)protocol->protocol_list);
 if(print_protocol_list(indent + 4, protocol->protocol_list,
      objc_sections, nobjc_sections, cstring_section_ptr,
      host_byte_sex, swapped, verbose) == FALSE)
     printf(" (not in an " "__OBJC" " section)\n");

 print_indent(indent);
 printf(" instance_methods 0x%08x",
  (unsigned int)protocol->instance_methods);
 if(print_method_description_list(indent, protocol->instance_methods,
      objc_sections, nobjc_sections, cstring_section_ptr,
      host_byte_sex, swapped, verbose) == FALSE)
     printf(" (not in an " "__OBJC" " section)\n");

 print_indent(indent);
 printf("    class_methods 0x%08x",
  (unsigned int)protocol->class_methods);
 if(print_method_description_list(indent, protocol->class_methods,
      objc_sections, nobjc_sections, cstring_section_ptr,
      host_byte_sex, swapped, verbose) == FALSE)
     printf(" (not in an " "__OBJC" " section)\n");
}

static
enum bool
print_method_description_list(
 uint32_t indent,
 uint32_t addr,
 struct section_info *objc_sections,
 uint32_t nobjc_sections,
 struct section_info *cstring_section_ptr,
 enum byte_sex host_byte_sex,
 enum bool swapped,
 enum bool verbose)
{
    struct objc_method_description_list_t mdl;
    struct objc_method_description_t *list, md;
    enum bool trunc;
    uint32_t i, list_left, left;
    char *p;

    if(get_method_description_list(addr, &mdl, &list, &list_left,
  &trunc, objc_sections, nobjc_sections,
  host_byte_sex, swapped) == FALSE)
 return(FALSE);

    printf("\n");
    if(trunc == TRUE){
 print_indent(indent);
 printf(" objc_method_description_list extends past end of the "
  "section\n");
    }

    print_indent(indent);
    printf("        count %d\n", mdl.count);

    for(i = 0; i < (uint32_t)mdl.count; i++){
 if((i + 1) * sizeof(struct objc_method_description_t) > list_left){
  print_indent(indent);
  printf(" remaining list entries extend past the of the "
         "section\n");
  break;
     }
     print_indent(indent);
     printf("        list[%u]\n", i);
     ((__builtin_object_size (&md, 0) != (size_t) -1) ? __builtin___memcpy_chk (&md, list + i, sizeof(struct objc_method_description_t), __builtin_object_size (&md, 0)) : __inline_memcpy_chk (&md, list + i, sizeof(struct objc_method_description_t)));
     if(swapped)
  swap_objc_method_description_t(&md, host_byte_sex);

     print_indent(indent);
     printf("             name 0x%08x", (unsigned int)md.name);
     if(verbose){
  p = get_pointer(md.name, &left,
      objc_sections, nobjc_sections, cstring_section_ptr);
  if(p != ((void*)0))
      printf(" %.*s\n", (int)left, p);
  else
      printf(" (not in an " "__OBJC" " section)\n");
     }
     else
  printf("\n");

     print_indent(indent);
     printf("            types 0x%08x", (unsigned int)md.types);
     if(verbose){
  p = get_pointer(md.types, &left,
      objc_sections, nobjc_sections, cstring_section_ptr);
  if(p != ((void*)0))
      printf(" %.*s\n", (int)left, p);
  else
      printf(" (not in an " "__OBJC" " section)\n");
     }
     else
  printf("\n");
 }
 return(TRUE);
}

static enum bool
print_PHASH(
uint32_t indent,
uint32_t addr,
struct section_info *objc_sections,
uint32_t nobjc_sections,
struct section_info *cstring_section_ptr,
enum byte_sex host_byte_sex,
enum bool swapped,
enum bool verbose)
{
    struct _hashEntry_t _hashEntry;
    enum bool trunc;
    uint32_t left;
    char *p;

 if(get_hashEntry(addr, &_hashEntry, &trunc, objc_sections,
     nobjc_sections, host_byte_sex, swapped) == FALSE)
     return(FALSE);

 printf("\n");
 if(trunc == TRUE){
     print_indent(indent);
     printf("_hashEntry extends past end of the section\n");
 }

 print_indent(indent);
 printf(" sel 0x%08x", (unsigned int)_hashEntry.sel);
 if(verbose){
     p = get_pointer(_hashEntry.sel, &left,
         objc_sections, nobjc_sections, cstring_section_ptr);
     if(p != ((void*)0))
  printf(" %.*s\n", (int)left, p);
     else
  printf(" (not in an " "__OBJC" " section)\n");
 }
 else
     printf("\n");

 print_indent(indent);
 printf("next 0x%08x", (unsigned int)_hashEntry.next);
 if(_hashEntry.next == 0){
     printf("\n");
     return(TRUE);
 }
 if(print_PHASH(indent+4, _hashEntry.next,
     objc_sections, nobjc_sections, cstring_section_ptr,
     host_byte_sex, swapped, verbose) == FALSE)
     printf(" (not in an " "__OBJC" " section)\n");
 return(TRUE);
}

static
void
print_indent(
uint32_t indent)
{
     uint32_t i;

 for(i = 0; i < indent; ){
     if(indent - i >= 8){
  printf("\t");
  i += 8;
     }
     else{
  printf("%.*s", (int)(indent - i), "        ");
  return;
     }
 }
}

static
void *
get_pointer(
uint32_t addr,
uint32_t *left,
struct section_info *objc_sections,
uint32_t nobjc_sections,
struct section_info *cstring_section_ptr)
{
    void* returnValue = ((void*)0);
    uint32_t i;

 if(addr >= cstring_section_ptr->addr &&
    addr < cstring_section_ptr->addr + cstring_section_ptr->size){
     *left = cstring_section_ptr->size -
     (addr - cstring_section_ptr->addr);
     if(cstring_section_ptr->protected == TRUE)
  returnValue = "some string from a protected section";
     else
  returnValue = (cstring_section_ptr->contents +
          (addr - cstring_section_ptr->addr));
 }
 for(i = 0; returnValue != ((void*)0) && i < nobjc_sections; i++){
     if(addr >= objc_sections[i].addr &&
        addr < objc_sections[i].addr + objc_sections[i].size){
  *left = objc_sections[i].size -
          (addr - objc_sections[i].addr);
  returnValue = (objc_sections[i].contents +
         (addr - objc_sections[i].addr));
     }
 }
 return(returnValue);
}

static
enum bool
get_symtab(
uint32_t addr,
struct objc_symtab_t *symtab,
uint32_t **defs,
uint32_t *left,
enum bool *trunc,
struct section_info *objc_sections,
uint32_t nobjc_sections,
enum byte_sex host_byte_sex,
enum bool swapped)
{
    uint32_t i;

 ((__builtin_object_size (symtab, 0) != (size_t) -1) ? __builtin___memset_chk (symtab, '\0', sizeof(struct objc_symtab_t), __builtin_object_size (symtab, 0)) : __inline_memset_chk (symtab, '\0', sizeof(struct objc_symtab_t)));
 if(addr == 0)
     return(0);
 for(i = 0; i < nobjc_sections; i++){
     if(addr >= objc_sections[i].addr &&
        addr < objc_sections[i].addr + objc_sections[i].size){

  *left = objc_sections[i].size -
          (addr - objc_sections[i].addr);
  if(*left >= sizeof(struct objc_symtab_t) - sizeof(uint32_t)){
      ((__builtin_object_size (symtab, 0) != (size_t) -1) ? __builtin___memcpy_chk (symtab, objc_sections[i].contents + (addr - objc_sections[i].addr), sizeof(struct objc_symtab_t) - sizeof(uint32_t), __builtin_object_size (symtab, 0)) : __inline_memcpy_chk (symtab, objc_sections[i].contents + (addr - objc_sections[i].addr), sizeof(struct objc_symtab_t) - sizeof(uint32_t)));



      *left -= sizeof(struct objc_symtab_t) - sizeof(uint32_t);
      *defs = (uint32_t *)(objc_sections[i].contents +
         (addr - objc_sections[i].addr) +
            sizeof(struct objc_symtab_t) -
         sizeof(uint32_t));
      *trunc = FALSE;
  }
  else{
      ((__builtin_object_size (symtab, 0) != (size_t) -1) ? __builtin___memcpy_chk (symtab, objc_sections[i].contents + (addr - objc_sections[i].addr), *left, __builtin_object_size (symtab, 0)) : __inline_memcpy_chk (symtab, objc_sections[i].contents + (addr - objc_sections[i].addr), *left));



      *left = 0;
      *defs = ((void*)0);
      *trunc = TRUE;
  }
  if(swapped)
      swap_objc_symtab_t(symtab, host_byte_sex);
  return(TRUE);
     }
 }
 return(FALSE);
}

static
enum bool
get_objc_class(
uint32_t addr,
struct objc_class_t *objc_class,
enum bool *trunc,
struct section_info *objc_sections,
uint32_t nobjc_sections,
enum byte_sex host_byte_sex,
enum bool swapped)
{
    uint32_t left, i;

 ((__builtin_object_size (objc_class, 0) != (size_t) -1) ? __builtin___memset_chk (objc_class, '\0', sizeof(struct objc_class_t), __builtin_object_size (objc_class, 0)) : __inline_memset_chk (objc_class, '\0', sizeof(struct objc_class_t)));
 if(addr == 0)
     return(FALSE);
 for(i = 0; i < nobjc_sections; i++){
     if(addr >= objc_sections[i].addr &&
        addr < objc_sections[i].addr + objc_sections[i].size){

  left = objc_sections[i].size -
          (addr - objc_sections[i].addr);
  if(left >= sizeof(struct objc_class_t)){
      ((__builtin_object_size (objc_class, 0) != (size_t) -1) ? __builtin___memcpy_chk (objc_class, objc_sections[i].contents + (addr - objc_sections[i].addr), sizeof(struct objc_class_t), __builtin_object_size (objc_class, 0)) : __inline_memcpy_chk (objc_class, objc_sections[i].contents + (addr - objc_sections[i].addr), sizeof(struct objc_class_t)));



      *trunc = FALSE;
  }
  else{
      ((__builtin_object_size (objc_class, 0) != (size_t) -1) ? __builtin___memcpy_chk (objc_class, objc_sections[i].contents + (addr - objc_sections[i].addr), left, __builtin_object_size (objc_class, 0)) : __inline_memcpy_chk (objc_class, objc_sections[i].contents + (addr - objc_sections[i].addr), left));



      *trunc = TRUE;
  }
  if(swapped)
      swap_objc_class_t(objc_class, host_byte_sex);
  return(TRUE);
     }
 }
 return(FALSE);
}

static
enum bool
get_objc_category(
uint32_t addr,
struct objc_category_t *objc_category,
enum bool *trunc,
struct section_info *objc_sections,
uint32_t nobjc_sections,
enum byte_sex host_byte_sex,
enum bool swapped)
{
    uint32_t left, i;

 ((__builtin_object_size (objc_category, 0) != (size_t) -1) ? __builtin___memset_chk (objc_category, '\0', sizeof(struct objc_category_t), __builtin_object_size (objc_category, 0)) : __inline_memset_chk (objc_category, '\0', sizeof(struct objc_category_t)));
 if(addr == 0)
     return(FALSE);
 for(i = 0; i < nobjc_sections; i++){
     if(addr >= objc_sections[i].addr &&
        addr < objc_sections[i].addr + objc_sections[i].size){

  left = objc_sections[i].size -
          (addr - objc_sections[i].addr);
  if(left >= sizeof(struct objc_category_t)){
      ((__builtin_object_size (objc_category, 0) != (size_t) -1) ? __builtin___memcpy_chk (objc_category, objc_sections[i].contents + (addr - objc_sections[i].addr), sizeof(struct objc_category_t), __builtin_object_size (objc_category, 0)) : __inline_memcpy_chk (objc_category, objc_sections[i].contents + (addr - objc_sections[i].addr), sizeof(struct objc_category_t)));



      *trunc = FALSE;
  }
  else{
      ((__builtin_object_size (objc_category, 0) != (size_t) -1) ? __builtin___memcpy_chk (objc_category, objc_sections[i].contents + (addr - objc_sections[i].addr), left, __builtin_object_size (objc_category, 0)) : __inline_memcpy_chk (objc_category, objc_sections[i].contents + (addr - objc_sections[i].addr), left));



      *trunc = TRUE;
  }
  if(swapped)
      swap_objc_category_t(objc_category, host_byte_sex);
  return(TRUE);
     }
 }
 return(FALSE);
}

static
enum bool
get_ivar_list(
uint32_t addr,
struct objc_ivar_list_t *objc_ivar_list,
struct objc_ivar_t **ivar_list,
uint32_t *left,
enum bool *trunc,
struct section_info *objc_sections,
uint32_t nobjc_sections,
enum byte_sex host_byte_sex,
enum bool swapped)
{
    uint32_t i;

 ((__builtin_object_size (objc_ivar_list, 0) != (size_t) -1) ? __builtin___memset_chk (objc_ivar_list, '\0', sizeof(struct objc_ivar_list_t), __builtin_object_size (objc_ivar_list, 0)) : __inline_memset_chk (objc_ivar_list, '\0', sizeof(struct objc_ivar_list_t)));
 if(addr == 0)
     return(FALSE);
 for(i = 0; i < nobjc_sections; i++){
     if(addr >= objc_sections[i].addr &&
        addr < objc_sections[i].addr + objc_sections[i].size){

  *left = objc_sections[i].size -
          (addr - objc_sections[i].addr);
  if(*left >= sizeof(struct objc_ivar_list_t) -
       sizeof(struct objc_ivar_t)){
      ((__builtin_object_size (objc_ivar_list, 0) != (size_t) -1) ? __builtin___memcpy_chk (objc_ivar_list, objc_sections[i].contents + (addr - objc_sections[i].addr), sizeof(struct objc_ivar_list_t) - sizeof(struct objc_ivar_t), __builtin_object_size (objc_ivar_list, 0)) : __inline_memcpy_chk (objc_ivar_list, objc_sections[i].contents + (addr - objc_sections[i].addr), sizeof(struct objc_ivar_list_t) - sizeof(struct objc_ivar_t)));




      *left -= sizeof(struct objc_ivar_list_t) -
        sizeof(struct objc_ivar_t);
      *ivar_list = (struct objc_ivar_t *)
     (objc_sections[i].contents +
         (addr - objc_sections[i].addr) +
      sizeof(struct objc_ivar_list_t) -
          sizeof(struct objc_ivar_t));
      *trunc = FALSE;
  }
  else{
      ((__builtin_object_size (objc_ivar_list, 0) != (size_t) -1) ? __builtin___memcpy_chk (objc_ivar_list, objc_sections[i].contents + (addr - objc_sections[i].addr), *left, __builtin_object_size (objc_ivar_list, 0)) : __inline_memcpy_chk (objc_ivar_list, objc_sections[i].contents + (addr - objc_sections[i].addr), *left));



      *left = 0;
      *ivar_list = ((void*)0);
      *trunc = TRUE;
  }
  if(swapped)
      swap_objc_ivar_list_t(objc_ivar_list, host_byte_sex);
  return(TRUE);
     }
 }
 return(FALSE);
}

static
enum bool
get_method_list(
uint32_t addr,
struct objc_method_list_t *method_list,
struct objc_method_t **methods,
uint32_t *left,
enum bool *trunc,
struct section_info *objc_sections,
uint32_t nobjc_sections,
enum byte_sex host_byte_sex,
enum bool swapped)
{
    uint32_t i;

 ((__builtin_object_size (method_list, 0) != (size_t) -1) ? __builtin___memset_chk (method_list, '\0', sizeof(struct objc_method_list_t), __builtin_object_size (method_list, 0)) : __inline_memset_chk (method_list, '\0', sizeof(struct objc_method_list_t)));
 if(addr == 0)
     return(FALSE);
 for(i = 0; i < nobjc_sections; i++){
     if(addr >= objc_sections[i].addr &&
        addr < objc_sections[i].addr + objc_sections[i].size){

  *left = objc_sections[i].size -
          (addr - objc_sections[i].addr);
  if(*left >= sizeof(struct objc_method_list_t) -
       sizeof(struct objc_method_t)){
      ((__builtin_object_size (method_list, 0) != (size_t) -1) ? __builtin___memcpy_chk (method_list, objc_sections[i].contents + (addr - objc_sections[i].addr), sizeof(struct objc_method_list_t) - sizeof(struct objc_method_t), __builtin_object_size (method_list, 0)) : __inline_memcpy_chk (method_list, objc_sections[i].contents + (addr - objc_sections[i].addr), sizeof(struct objc_method_list_t) - sizeof(struct objc_method_t)));




      *left -= sizeof(struct objc_method_list_t) -
        sizeof(struct objc_method_t);
      *methods = (struct objc_method_t *)
     (objc_sections[i].contents +
         (addr - objc_sections[i].addr) +
      sizeof(struct objc_method_list_t) -
          sizeof(struct objc_method_t));
      *trunc = FALSE;
  }
  else{
      ((__builtin_object_size (method_list, 0) != (size_t) -1) ? __builtin___memcpy_chk (method_list, objc_sections[i].contents + (addr - objc_sections[i].addr), *left, __builtin_object_size (method_list, 0)) : __inline_memcpy_chk (method_list, objc_sections[i].contents + (addr - objc_sections[i].addr), *left));



      *left = 0;
      *methods = ((void*)0);
      *trunc = TRUE;
  }
  if(swapped)
      swap_objc_method_list_t(method_list, host_byte_sex);
  return(TRUE);
     }
 }
 return(FALSE);
}

static
enum bool
get_protocol_list(
uint32_t addr,
struct objc_protocol_list_t *protocol_list,
uint32_t **list,
uint32_t *left,
enum bool *trunc,
struct section_info *objc_sections,
uint32_t nobjc_sections,
enum byte_sex host_byte_sex,
enum bool swapped)
{
    uint32_t i;

 ((__builtin_object_size (protocol_list, 0) != (size_t) -1) ? __builtin___memset_chk (protocol_list, '\0', sizeof(struct objc_protocol_list_t), __builtin_object_size (protocol_list, 0)) : __inline_memset_chk (protocol_list, '\0', sizeof(struct objc_protocol_list_t)));
 if(addr == 0)
     return(FALSE);
 for(i = 0; i < nobjc_sections; i++){
     if(addr >= objc_sections[i].addr &&
        addr < objc_sections[i].addr + objc_sections[i].size){

  *left = objc_sections[i].size -
          (addr - objc_sections[i].addr);
  if(*left >= sizeof(struct objc_protocol_list_t) -
       sizeof(uint32_t)){
      ((__builtin_object_size (protocol_list, 0) != (size_t) -1) ? __builtin___memcpy_chk (protocol_list, objc_sections[i].contents + (addr - objc_sections[i].addr), sizeof(struct objc_protocol_list_t) - sizeof(uint32_t), __builtin_object_size (protocol_list, 0)) : __inline_memcpy_chk (protocol_list, objc_sections[i].contents + (addr - objc_sections[i].addr), sizeof(struct objc_protocol_list_t) - sizeof(uint32_t)));




      *left -= sizeof(struct objc_protocol_list_t) -
        sizeof(uint32_t);
      *list = (uint32_t *)
     (objc_sections[i].contents +
         (addr - objc_sections[i].addr) +
      sizeof(struct objc_protocol_list_t) -
          sizeof(uint32_t));
      *trunc = FALSE;
  }
  else{
      ((__builtin_object_size (protocol_list, 0) != (size_t) -1) ? __builtin___memcpy_chk (protocol_list, objc_sections[i].contents + (addr - objc_sections[i].addr), *left, __builtin_object_size (protocol_list, 0)) : __inline_memcpy_chk (protocol_list, objc_sections[i].contents + (addr - objc_sections[i].addr), *left));



      *left = 0;
      *list = ((void*)0);
      *trunc = TRUE;
  }
  if(swapped)
      swap_objc_protocol_list_t(protocol_list, host_byte_sex);
  return(TRUE);
     }
 }
 return(FALSE);
}

static
enum bool
get_protocol(
uint32_t addr,
struct objc_protocol_t *protocol,
enum bool *trunc,
struct section_info *objc_sections,
uint32_t nobjc_sections,
enum byte_sex host_byte_sex,
enum bool swapped)
{
    uint32_t left, i;

 ((__builtin_object_size (protocol, 0) != (size_t) -1) ? __builtin___memset_chk (protocol, '\0', sizeof(struct objc_protocol_t), __builtin_object_size (protocol, 0)) : __inline_memset_chk (protocol, '\0', sizeof(struct objc_protocol_t)));
 if(addr == 0)
     return(FALSE);
 for(i = 0; i < nobjc_sections; i++){
     if(addr >= objc_sections[i].addr &&
        addr < objc_sections[i].addr + objc_sections[i].size){

  left = objc_sections[i].size -
          (addr - objc_sections[i].addr);
  if(left >= sizeof(struct objc_protocol_t)){
      ((__builtin_object_size (protocol, 0) != (size_t) -1) ? __builtin___memcpy_chk (protocol, objc_sections[i].contents + (addr - objc_sections[i].addr), sizeof(struct objc_protocol_t), __builtin_object_size (protocol, 0)) : __inline_memcpy_chk (protocol, objc_sections[i].contents + (addr - objc_sections[i].addr), sizeof(struct objc_protocol_t)));



      *trunc = FALSE;
  }
  else{
      ((__builtin_object_size (protocol, 0) != (size_t) -1) ? __builtin___memcpy_chk (protocol, objc_sections[i].contents + (addr - objc_sections[i].addr), left, __builtin_object_size (protocol, 0)) : __inline_memcpy_chk (protocol, objc_sections[i].contents + (addr - objc_sections[i].addr), left));



      *trunc = TRUE;
  }
  if(swapped)
      swap_objc_protocol_t(protocol, host_byte_sex);
  return(TRUE);
     }
 }
 return(FALSE);
}

static
enum bool
get_method_description_list(
uint32_t addr,
struct objc_method_description_list_t *mdl,
struct objc_method_description_t **list,
uint32_t *left,
enum bool *trunc,
struct section_info *objc_sections,
uint32_t nobjc_sections,
enum byte_sex host_byte_sex,
enum bool swapped)
{
    uint32_t i;

 ((__builtin_object_size (mdl, 0) != (size_t) -1) ? __builtin___memset_chk (mdl, '\0', sizeof(struct objc_method_description_list_t), __builtin_object_size (mdl, 0)) : __inline_memset_chk (mdl, '\0', sizeof(struct objc_method_description_list_t)));
 if(addr == 0)
     return(FALSE);
 for(i = 0; i < nobjc_sections; i++){
     if(addr >= objc_sections[i].addr &&
        addr < objc_sections[i].addr + objc_sections[i].size){

  *left = objc_sections[i].size -
          (addr - objc_sections[i].addr);
  if(*left >= sizeof(struct objc_method_description_list_t) -
       sizeof(struct objc_method_description_t)){
      ((__builtin_object_size (mdl, 0) != (size_t) -1) ? __builtin___memcpy_chk (mdl, objc_sections[i].contents + (addr - objc_sections[i].addr), sizeof(struct objc_method_description_list_t) - sizeof(struct objc_method_description_t), __builtin_object_size (mdl, 0)) : __inline_memcpy_chk (mdl, objc_sections[i].contents + (addr - objc_sections[i].addr), sizeof(struct objc_method_description_list_t) - sizeof(struct objc_method_description_t)));




      *left -= sizeof(struct objc_method_description_list_t) -
        sizeof(struct objc_method_description_t);
      *list = (struct objc_method_description_t *)
     (objc_sections[i].contents +
         (addr - objc_sections[i].addr) +
     sizeof(struct objc_method_description_list_t) -
          sizeof(struct objc_method_description_t));
      *trunc = FALSE;
  }
  else{
      ((__builtin_object_size (mdl, 0) != (size_t) -1) ? __builtin___memcpy_chk (mdl, objc_sections[i].contents + (addr - objc_sections[i].addr), *left, __builtin_object_size (mdl, 0)) : __inline_memcpy_chk (mdl, objc_sections[i].contents + (addr - objc_sections[i].addr), *left));



      *left = 0;
      *list = ((void*)0);
      *trunc = TRUE;
  }
  if(swapped)
      swap_objc_method_description_list_t(mdl, host_byte_sex);
  return(TRUE);
     }
 }
 return(FALSE);
}

static
enum bool
get_hashEntry(
uint32_t addr,
struct _hashEntry_t *_hashEntry,
enum bool *trunc,
struct section_info *objc_sections,
uint32_t nobjc_sections,
enum byte_sex host_byte_sex,
enum bool swapped)
{
    uint32_t left, i;

 ((__builtin_object_size (_hashEntry, 0) != (size_t) -1) ? __builtin___memset_chk (_hashEntry, '\0', sizeof(struct _hashEntry_t), __builtin_object_size (_hashEntry, 0)) : __inline_memset_chk (_hashEntry, '\0', sizeof(struct _hashEntry_t)));
 if(addr == 0)
     return(FALSE);
 for(i = 0; i < nobjc_sections; i++){
     if(addr >= objc_sections[i].addr &&
        addr < objc_sections[i].addr + objc_sections[i].size){

  left = objc_sections[i].size -
          (addr - objc_sections[i].addr);
  if(left >= sizeof(struct _hashEntry_t)){
      ((__builtin_object_size (_hashEntry, 0) != (size_t) -1) ? __builtin___memcpy_chk (_hashEntry, objc_sections[i].contents + (addr - objc_sections[i].addr), sizeof(struct _hashEntry_t), __builtin_object_size (_hashEntry, 0)) : __inline_memcpy_chk (_hashEntry, objc_sections[i].contents + (addr - objc_sections[i].addr), sizeof(struct _hashEntry_t)));



      *trunc = FALSE;
  }
  else{
      ((__builtin_object_size (_hashEntry, 0) != (size_t) -1) ? __builtin___memcpy_chk (_hashEntry, objc_sections[i].contents + (addr - objc_sections[i].addr), left, __builtin_object_size (_hashEntry, 0)) : __inline_memcpy_chk (_hashEntry, objc_sections[i].contents + (addr - objc_sections[i].addr), left));



      *trunc = TRUE;
  }
  if(swapped)
      swap_hashEntry_t(_hashEntry, host_byte_sex);
  return(TRUE);
     }
 }
 return(FALSE);
}