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: ptqh_first
struct __pthread_st *ptqh_first; 

pollution: ptqh_last
struct __pthread_st **ptqh_last; 

pollution: pta_magic
unsigned int pta_magic; 

pollution: pta_flags
int pta_flags; 

pollution: pta_private
void *pta_private; 

pollution: ptm_magic
unsigned int ptm_magic; 

pollution: ptm_errorcheck
__pthread_spin_t ptm_errorcheck; 

pollution: ptm_pad1
uint8_t ptm_pad1[3]; 

pollution: ptm_ceiling
unsigned char ptm_ceiling; 

pollution: ptm_unused
__pthread_spin_t ptm_unused; 

pollution: ptm_pad2
uint8_t ptm_pad2[3]; 

pollution: ptm_owner
volatile pthread_t ptm_owner; 

pollution: ptm_waiters
void * volatile ptm_waiters; 

pollution: ptm_recursed
unsigned int ptm_recursed; 

pollution: ptm_spare2
void *ptm_spare2; 

pollution: ptma_magic
unsigned int ptma_magic; 

pollution: ptma_private
void *ptma_private; 

pollution: ptc_magic
unsigned int ptc_magic; 

pollution: ptc_lock
__pthread_spin_t ptc_lock; 

pollution: ptc_waiters
void *volatile ptc_waiters; 

pollution: ptc_spare
void *ptc_spare; 

pollution: ptc_mutex
pthread_mutex_t *ptc_mutex; 

pollution: ptc_private
void *ptc_private; 

pollution: ptca_magic
unsigned int ptca_magic; 

pollution: ptca_private
void *ptca_private; 

pollution: pto_mutex
pthread_mutex_t pto_mutex; 

pollution: pto_done
int pto_done; 

pollution: pts_magic
unsigned int pts_magic; 

pollution: pts_spin
__pthread_spin_t pts_spin; 

pollution: pts_flags
int pts_flags; 

pollution: ptr_magic
unsigned int ptr_magic; 

pollution: ptr_interlock
__pthread_spin_t ptr_interlock; 

pollution: ptr_rblocked
pthread_queue_t ptr_rblocked; 

pollution: ptr_wblocked
pthread_queue_t ptr_wblocked; 

pollution: ptr_nreaders
unsigned int ptr_nreaders; 

pollution: ptr_owner
volatile pthread_t ptr_owner; 

pollution: ptr_private
void *ptr_private; 

pollution: ptra_magic
unsigned int ptra_magic; 

pollution: ptra_private
void *ptra_private; 

pollution: ptb_magic
unsigned int ptb_magic; 

pollution: ptb_lock
pthread_spin_t ptb_lock; 

pollution: ptb_waiters
pthread_queue_t ptb_waiters; 

pollution: ptb_initcount
unsigned int ptb_initcount; 

pollution: ptb_curcount
unsigned int ptb_curcount; 

pollution: ptb_generation
unsigned int ptb_generation; 

pollution: ptb_private
void *ptb_private; 

pollution: ptba_magic
unsigned int ptba_magic; 

pollution: ptba_private
void *ptba_private; 

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

pollution: ss_onstack
int ss_onstack; 

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)] |= (1U << (((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)] &= ~(1U << (((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)] & (1U << (((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: killpg
int killpg(__pid_t, int); 

pollution: siginterrupt
int siginterrupt(int, int); 

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

pollution: sigaltstack
int sigaltstack(const stack_t * restrict, stack_t * restrict) __asm("__sigaltstack14"); 

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: 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[(((256) + ((32) - 1)) / (32))]; 

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

pollution: pselect
int pselect(int, fd_set * restrict, fd_set * restrict, fd_set * restrict, const struct timespec * restrict, const sigset_t * restrict) __asm("__pselect50"); 

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: 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: ts
pollution: base
int timespec_get(struct timespec *ts, int base); 

pollution: TRAP_SCE
#define TRAP_SCE 7

pollution: POLL_MSG
#define POLL_MSG 3

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

pollution: POLL_ERR
#define POLL_ERR 4

pollution: TRAP_EXEC
#define TRAP_EXEC 3

pollution: TRAP_LWP
#define TRAP_LWP 5

pollution: SS_DISABLE
#define SS_DISABLE 0x0004

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

pollution: ITIMER_REAL
#define ITIMER_REAL 0

pollution: ITIMER_MONOTONIC
#define ITIMER_MONOTONIC 3

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

pollution: TRAP_TRACE
#define TRAP_TRACE 2

pollution: SS_ONSTACK
#define SS_ONSTACK 0x0001

pollution: TRAP_BRKPT
#define TRAP_BRKPT 1

pollution: TRAP_DBREG
#define TRAP_DBREG 6

pollution: POLL_OUT
#define POLL_OUT 2

pollution: MINSIGSTKSZ
#define MINSIGSTKSZ 8192

pollution: POLL_HUP
#define POLL_HUP 6

pollution: POLL_PRI
#define POLL_PRI 5

pollution: FD_SETSIZE
#define FD_SETSIZE 256

pollution: TRAP_CHLD
#define TRAP_CHLD 4

pollution: TRAP_SCX
#define TRAP_SCX 8

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

pollution: POLL_IN
#define POLL_IN 1

pollution: ITIMER_VIRTUAL
#define ITIMER_VIRTUAL 1

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