pollution: htonl
__uint32_t htonl(__uint32_t) __attribute__((__const__)); 

pollution: htons
__uint16_t htons(__uint16_t) __attribute__((__const__)); 

pollution: ntohl
__uint32_t ntohl(__uint32_t) __attribute__((__const__)); 

pollution: ntohs
__uint16_t ntohs(__uint16_t) __attribute__((__const__)); 

pollution: x
static __inline __uint32_t __byte_swap_u32_variable(__uint32_t x) { __asm volatile ( "bswap %1" : "=r" (x) : "0" (x)); return (x); }

pollution: x
static __inline __uint16_t __byte_swap_u16_variable(__uint16_t x) { __asm volatile ("rorw $8, %w1" : "=r" (x) : "0" (x)); return (x); }

pollution: bswap16
__uint16_t bswap16(__uint16_t) __asm("__bswap16") __attribute__((__const__)); 

pollution: bswap32
__uint32_t bswap32(__uint32_t) __asm("__bswap32") __attribute__((__const__)); 

pollution: bswap64
__uint64_t bswap64(__uint64_t) __attribute__((__const__)); 

pollution: dst
pollution: u
pollution: be16enc
static __inline __attribute__((__unused__)) void be16enc(void *dst, __uint16_t u) { u = ((__uint16_t)(__builtin_constant_p((((__uint16_t)((u))))) ? (((__uint16_t)(((((((__uint16_t)((u)))) & 0xff00) >> 8) | (((((__uint16_t)((u)))) & 0x00ff) << 8))))) : __byte_swap_u16_variable(((__uint16_t)((u)))))); __builtin_memcpy(dst, &u, sizeof(u)); }

pollution: dst
pollution: u
pollution: be32enc
static __inline __attribute__((__unused__)) void be32enc(void *dst, __uint32_t u) { u = ((__uint32_t)(__builtin_constant_p((((__uint32_t)((u))))) ? (((__uint32_t)(((((((__uint32_t)((u)))) & 0xff000000) >> 24) | (((((__uint32_t)((u)))) & 0x00ff0000) >> 8) | (((((__uint32_t)((u)))) & 0x0000ff00) << 8) | (((((__uint32_t)((u)))) & 0x000000ff) << 24))))) : __byte_swap_u32_variable(((__uint32_t)((u)))))); __builtin_memcpy(dst, &u, sizeof(u)); }

pollution: dst
pollution: u
pollution: be64enc
static __inline __attribute__((__unused__)) void be64enc(void *dst, __uint64_t u) { u = ((__uint64_t)(__builtin_constant_p((((__uint64_t)((u))))) ? (((__uint64_t)(((((((__uint64_t)((u)))) & 0xff00000000000000ull) >> 56) | (((((__uint64_t)((u)))) & 0x00ff000000000000ull) >> 40) | (((((__uint64_t)((u)))) & 0x0000ff0000000000ull) >> 24) | (((((__uint64_t)((u)))) & 0x000000ff00000000ull) >> 8) | (((((__uint64_t)((u)))) & 0x00000000ff000000ull) << 8) | (((((__uint64_t)((u)))) & 0x0000000000ff0000ull) << 24) | (((((__uint64_t)((u)))) & 0x000000000000ff00ull) << 40) | (((((__uint64_t)((u)))) & 0x00000000000000ffull) << 56))))) : bswap64(((__uint64_t)((u)))))); __builtin_memcpy(dst, &u, sizeof(u)); }

pollution: dst
pollution: u
pollution: le16enc
static __inline __attribute__((__unused__)) void le16enc(void *dst, __uint16_t u) { u = (u); __builtin_memcpy(dst, &u, sizeof(u)); }

pollution: dst
pollution: u
pollution: le32enc
static __inline __attribute__((__unused__)) void le32enc(void *dst, __uint32_t u) { u = (u); __builtin_memcpy(dst, &u, sizeof(u)); }

pollution: dst
pollution: u
pollution: le64enc
static __inline __attribute__((__unused__)) void le64enc(void *dst, __uint64_t u) { u = (u); __builtin_memcpy(dst, &u, sizeof(u)); }

pollution: buf
pollution: be16dec
static __inline __attribute__((__unused__)) __uint16_t be16dec(const void *buf) { __uint16_t u; __builtin_memcpy(&u, buf, sizeof(u)); return ((__uint16_t)(__builtin_constant_p((((__uint16_t)((u))))) ? (((__uint16_t)(((((((__uint16_t)((u)))) & 0xff00) >> 8) | (((((__uint16_t)((u)))) & 0x00ff) << 8))))) : __byte_swap_u16_variable(((__uint16_t)((u)))))); }

pollution: buf
pollution: be32dec
static __inline __attribute__((__unused__)) __uint32_t be32dec(const void *buf) { __uint32_t u; __builtin_memcpy(&u, buf, sizeof(u)); return ((__uint32_t)(__builtin_constant_p((((__uint32_t)((u))))) ? (((__uint32_t)(((((((__uint32_t)((u)))) & 0xff000000) >> 24) | (((((__uint32_t)((u)))) & 0x00ff0000) >> 8) | (((((__uint32_t)((u)))) & 0x0000ff00) << 8) | (((((__uint32_t)((u)))) & 0x000000ff) << 24))))) : __byte_swap_u32_variable(((__uint32_t)((u)))))); }

pollution: buf
pollution: be64dec
static __inline __attribute__((__unused__)) __uint64_t be64dec(const void *buf) { __uint64_t u; __builtin_memcpy(&u, buf, sizeof(u)); return ((__uint64_t)(__builtin_constant_p((((__uint64_t)((u))))) ? (((__uint64_t)(((((((__uint64_t)((u)))) & 0xff00000000000000ull) >> 56) | (((((__uint64_t)((u)))) & 0x00ff000000000000ull) >> 40) | (((((__uint64_t)((u)))) & 0x0000ff0000000000ull) >> 24) | (((((__uint64_t)((u)))) & 0x000000ff00000000ull) >> 8) | (((((__uint64_t)((u)))) & 0x00000000ff000000ull) << 8) | (((((__uint64_t)((u)))) & 0x0000000000ff0000ull) << 24) | (((((__uint64_t)((u)))) & 0x000000000000ff00ull) << 40) | (((((__uint64_t)((u)))) & 0x00000000000000ffull) << 56))))) : bswap64(((__uint64_t)((u)))))); }

pollution: buf
pollution: le16dec
static __inline __attribute__((__unused__)) __uint16_t le16dec(const void *buf) { __uint16_t u; __builtin_memcpy(&u, buf, sizeof(u)); return (u); }

pollution: buf
pollution: le32dec
static __inline __attribute__((__unused__)) __uint32_t le32dec(const void *buf) { __uint32_t u; __builtin_memcpy(&u, buf, sizeof(u)); return (u); }

pollution: buf
pollution: le64dec
static __inline __attribute__((__unused__)) __uint64_t le64dec(const void *buf) { __uint64_t u; __builtin_memcpy(&u, buf, sizeof(u)); return (u); }

pollution: timeval
struct timeval { time_t tv_sec; suseconds_t tv_usec; }; 

pollution: timeval
struct timeval it_interval; 

pollution: timeval
struct timeval it_value; 

pollution: itimerval
struct itimerval { struct timeval it_interval; struct timeval it_value; }; 

pollution: fds_bits
__fd_mask fds_bits[(((255) + ((32) - 1)) / (32))]; 

pollution: fd_set
pollution: fd_set
typedef struct fd_set { __fd_mask fds_bits[(((255) + ((32) - 1)) / (32))]; } fd_set; 

pollution: asctime_r
char *asctime_r(const struct tm * restrict, char * restrict); 

pollution: ctime_r
char *ctime_r(const time_t *, char *) __asm("__ctime_r50"); 

pollution: timeval
pollution: select
int select(int, fd_set * restrict, fd_set * restrict, fd_set * restrict, struct timeval * restrict) __asm("__select50"); 

pollution: itimerval
pollution: getitimer
int getitimer(int, struct itimerval *) __asm("__getitimer50"); 

pollution: timeval
pollution: gettimeofday
int gettimeofday(struct timeval * restrict, void *restrict) __asm("__gettimeofday50"); 

pollution: itimerval
pollution: itimerval
pollution: setitimer
int setitimer(int, const struct itimerval * restrict, struct itimerval * restrict) __asm("__setitimer50"); 

pollution: timeval
pollution: utimes
int utimes(const char *, const struct timeval [2]) __asm("__utimes50"); 

pollution: fp_control
__uint16_t fp_control; 

pollution: fp_unused_1
__uint16_t fp_unused_1; 

pollution: fp_status
__uint16_t fp_status; 

pollution: fp_unused_2
__uint16_t fp_unused_2; 

pollution: fp_tag
__uint16_t fp_tag; 

pollution: fp_unused_3
__uint16_t fp_unused_3; 

pollution: fp_eip
__uint32_t fp_eip; 

pollution: fp_cs
__uint16_t fp_cs; 

pollution: fp_opcode
__uint16_t fp_opcode; 

pollution: fp_dp
__uint32_t fp_dp; 

pollution: fp_ds
__uint16_t fp_ds; 

pollution: fp_unused_4
__uint16_t fp_unused_4; 

pollution: fp_st_regs
__uint16_t fp_st_regs[8][5]; 

pollution: fpu_regs_s
struct fpu_regs_s { __uint16_t fp_control; __uint16_t fp_unused_1; __uint16_t fp_status; __uint16_t fp_unused_2; __uint16_t fp_tag; __uint16_t fp_unused_3; __uint32_t fp_eip; __uint16_t fp_cs; __uint16_t fp_opcode; __uint32_t fp_dp; __uint16_t fp_ds; __uint16_t fp_unused_4; __uint16_t fp_st_regs[8][5]; }; 

pollution: fp_control
__uint16_t fp_control; 

pollution: fp_status
__uint16_t fp_status; 

pollution: fp_tag
__uint16_t fp_tag; 

pollution: fp_opcode
__uint16_t fp_opcode; 

pollution: fp_eip
__uint32_t fp_eip; 

pollution: fp_cs
__uint16_t fp_cs; 

pollution: fp_unused_1
__uint16_t fp_unused_1; 

pollution: fp_dp
__uint32_t fp_dp; 

pollution: fp_ds
__uint16_t fp_ds; 

pollution: fp_unused_2
__uint16_t fp_unused_2; 

pollution: fp_mxcsr
__uint32_t fp_mxcsr; 

pollution: fp_mxcsr_mask
__uint32_t fp_mxcsr_mask; 

pollution: fp_st_regs
__uint16_t fp_st_regs[8][8]; 

pollution: fp_xreg_word
__uint32_t fp_xreg_word[32]; 

pollution: fp_padding
__uint32_t fp_padding[56]; 

pollution: xfp_save
struct xfp_save { __uint16_t fp_control; __uint16_t fp_status; __uint16_t fp_tag; __uint16_t fp_opcode; __uint32_t fp_eip; __uint16_t fp_cs; __uint16_t fp_unused_1; __uint32_t fp_dp; __uint16_t fp_ds; __uint16_t fp_unused_2; __uint32_t fp_mxcsr; __uint32_t fp_mxcsr_mask; __uint16_t fp_st_regs[8][8]; __uint32_t fp_xreg_word[32]; __uint32_t fp_padding[56]; }; 

pollution: fpu_regs_s
pollution: fpu_regs
struct fpu_regs_s fpu_regs; 

pollution: xfp_save
pollution: xfp_regs
struct xfp_save xfp_regs; 

pollution: fpu_state_u
union fpu_state_u { struct fpu_regs_s fpu_regs; struct xfp_save xfp_regs; }; 

pollution: siginfo
typedef union siginfo { char si_pad[128]; struct _ksiginfo _info; } siginfo_t; 

pollution: mc_magic
int mc_magic; 

pollution: mc_flags
int mc_flags; 

pollution: mcp
pollution: setmcontext
int setmcontext(const mcontext_t *mcp); 

pollution: mcp
pollution: getmcontext
int getmcontext(mcontext_t *mcp); 

pollution: ucp
pollution: resumecontext
void resumecontext(ucontext_t *ucp); 

pollution: ucp
pollution: getuctx
int getuctx(ucontext_t *ucp); 

pollution: ucp
pollution: setuctx
int setuctx(const ucontext_t *ucp); 

pollution: sigstack
struct sigstack { void *ss_sp; int ss_onstack; }; 

pollution: set
pollution: signo
extern __attribute__((__gnu_inline__)) __inline int sigaddset(sigset_t *set, int signo) { if (signo <= 0 || signo >= 64) { (*__errno()) = 22; return (-1); } ((set)->__bits[(((unsigned int)(signo) - 1) >> 5)] |= (1 << (((unsigned int)(signo) - 1) & 31))); return (0); }

pollution: set
pollution: signo
extern __attribute__((__gnu_inline__)) __inline int sigdelset(sigset_t *set, int signo) { if (signo <= 0 || signo >= 64) { (*__errno()) = 22; return (-1); } ((set)->__bits[(((unsigned int)(signo) - 1) >> 5)] &= ~(1 << (((unsigned int)(signo) - 1) & 31))); return (0); }

pollution: set
pollution: signo
extern __attribute__((__gnu_inline__)) __inline int sigismember(const sigset_t *set, int signo) { if (signo <= 0 || signo >= 64) { (*__errno()) = 22; return (-1); } return ((((set)->__bits[(((unsigned int)(signo) - 1) >> 5)] & (1 << (((unsigned int)(signo) - 1) & 31))) != 0)); }

pollution: set
extern __attribute__((__gnu_inline__)) __inline int sigemptyset(sigset_t *set) { ((set)->__bits[0] = 0x00000000, (set)->__bits[1] = 0x00000000, (set)->__bits[2] = 0x00000000, (set)->__bits[3] = 0x00000000); return (0); }

pollution: set
extern __attribute__((__gnu_inline__)) __inline int sigfillset(sigset_t *set) { ((set)->__bits[0] = 0xffffffff, (set)->__bits[1] = 0xffffffff, (set)->__bits[2] = 0xffffffff, (set)->__bits[3] = 0xffffffff); return (0); }

pollution: siginterrupt
int siginterrupt(int, int); 

pollution: sigstack
pollution: sigstack
pollution: sigstack
int sigstack(const struct sigstack *, struct sigstack *); 

pollution: sighold
int sighold(int); 

pollution: sigignore
int sigignore(int); 

pollution: sigpause
int sigpause(int); 

pollution: sigrelse
int sigrelse(int); 

pollution: sigset
void (*sigset (int, void (*)(int)))(int); 

pollution: BE16TOH
#define BE16TOH(x) HTOBE16(x)

pollution: BE32TOH
#define BE32TOH(x) HTOBE32(x)

pollution: BE64TOH
#define BE64TOH(x) HTOBE64(x)

pollution: BIG_ENDIAN
#define BIG_ENDIAN 4321

pollution: BYTE_ORDER
#define BYTE_ORDER _BYTE_ORDER

pollution: CLK_TCK
#define CLK_TCK (__sysconf(39))

pollution: FD_CLR
#define FD_CLR(n,p) ((p)->fds_bits[(unsigned)(n) >> __NFDSHIFT] &= ~(1 << ((n) & __NFDMASK)))

pollution: FD_ISSET
#define FD_ISSET(n,p) ((p)->fds_bits[(unsigned)(n) >> __NFDSHIFT] & (1 << ((n) & __NFDMASK)))

pollution: FD_SET
#define FD_SET(n,p) ((p)->fds_bits[(unsigned)(n) >> __NFDSHIFT] |= (1 << ((n) & __NFDMASK)))

pollution: FD_SETSIZE
#define FD_SETSIZE 255

pollution: FD_ZERO
#define FD_ZERO(p) (void)__builtin_memset((p), 0, sizeof(*(p)))

pollution: FPU_H
#define FPU_H #define FPU_XFP_SIZE 512

pollution: HTOBE16
#define HTOBE16(x) (x) = bswap16(__CAST(uint16_t, (x)))

pollution: HTOBE32
#define HTOBE32(x) (x) = bswap32(__CAST(uint32_t, (x)))

pollution: HTOBE64
#define HTOBE64(x) (x) = bswap64(__CAST(uint64_t, (x)))

pollution: HTOLE16
#define HTOLE16(x) __CAST(void, (x))

pollution: HTOLE32
#define HTOLE32(x) __CAST(void, (x))

pollution: HTOLE64
#define HTOLE64(x) __CAST(void, (x))

pollution: HTONL
#define HTONL(x) (x) = htonl(__CAST(uint32_t, (x)))

pollution: HTONS
#define HTONS(x) (x) = htons(__CAST(uint16_t, (x)))

pollution: ITIMER_MONOTONIC
#define ITIMER_MONOTONIC 3

pollution: ITIMER_PROF
#define ITIMER_PROF 2

pollution: ITIMER_REAL
#define ITIMER_REAL 0

pollution: ITIMER_VIRTUAL
#define ITIMER_VIRTUAL 1

pollution: LE16TOH
#define LE16TOH(x) HTOLE16(x)

pollution: LE32TOH
#define LE32TOH(x) HTOLE32(x)

pollution: LE64TOH
#define LE64TOH(x) HTOLE64(x)

pollution: LITTLE_ENDIAN
#define LITTLE_ENDIAN 1234

pollution: MCF_MAGIC
#define MCF_MAGIC 0xc0ffee

pollution: NTOHL
#define NTOHL(x) (x) = ntohl(__CAST(uint32_t, (x)))

pollution: NTOHS
#define NTOHS(x) (x) = ntohs(__CAST(uint16_t, (x)))

pollution: PDP_ENDIAN
#define PDP_ENDIAN 3412

pollution: POLL_ERR
#define POLL_ERR 4

pollution: POLL_HUP
#define POLL_HUP 6

pollution: POLL_IN
#define POLL_IN 1

pollution: POLL_MSG
#define POLL_MSG 3

pollution: POLL_OUT
#define POLL_OUT 2

pollution: POLL_PRI
#define POLL_PRI 5

pollution: PRIxREGISTER
#define PRIxREGISTER "x"

pollution: be16toh
#define be16toh(x) htobe16(x)

pollution: be32toh
#define be32toh(x) htobe32(x)

pollution: be64toh
#define be64toh(x) htobe64(x)

pollution: bswap16
#define bswap16(x) __CAST(uint16_t, __builtin_constant_p((x)) ? __byte_swap_u16_constant(x) : __BYTE_SWAP_U16_VARIABLE(x))

pollution: bswap32
#define bswap32(x) __CAST(uint32_t, __builtin_constant_p((x)) ? __byte_swap_u32_constant(x) : __BYTE_SWAP_U32_VARIABLE(x))

pollution: bswap64
#define bswap64(x) __CAST(uint64_t, __builtin_constant_p((x)) ? __byte_swap_u64_constant(x) : __BYTE_SWAP_U64_VARIABLE(x))

pollution: htobe16
#define htobe16(x) bswap16(__CAST(uint16_t, (x)))

pollution: htobe32
#define htobe32(x) bswap32(__CAST(uint32_t, (x)))

pollution: htobe64
#define htobe64(x) bswap64(__CAST(uint64_t, (x)))

pollution: htole16
#define htole16(x) (x)

pollution: htole32
#define htole32(x) (x)

pollution: htole64
#define htole64(x) (x)

pollution: htonl
#define htonl(x) bswap32(__CAST(uint32_t, (x)))

pollution: htons
#define htons(x) bswap16(__CAST(uint16_t, (x)))

pollution: le16toh
#define le16toh(x) htole16(x)

pollution: le32toh
#define le32toh(x) htole32(x)

pollution: le64toh
#define le64toh(x) htole64(x)

pollution: ntohl
#define ntohl(x) bswap32(__CAST(uint32_t, (x)))

pollution: ntohs
#define ntohs(x) bswap16(__CAST(uint16_t, (x)))