pollution: x
static __inline __uint16_t __swap16md(__uint16_t x) { return ((__uint16_t)(((__uint16_t)(x) & 0xffU) << 8 | ((__uint16_t)(x) & 0xff00U) >> 8)); }

pollution: x
static __inline __uint32_t __swap32md(__uint32_t x) { return ((__uint32_t)(((__uint32_t)(x) & 0xff) << 24 | ((__uint32_t)(x) & 0xff00) << 8 | ((__uint32_t)(x) & 0xff0000) >> 8 | ((__uint32_t)(x) & 0xff000000) >> 24)); }

pollution: x
static __inline __uint64_t __swap64md(__uint64_t x) { return ((__uint64_t)((((__uint64_t)(x) & 0xff) << 56) | ((__uint64_t)(x) & 0xff00ULL) << 40 | ((__uint64_t)(x) & 0xff0000ULL) << 24 | ((__uint64_t)(x) & 0xff000000ULL) << 8 | ((__uint64_t)(x) & 0xff00000000ULL) >> 8 | ((__uint64_t)(x) & 0xff0000000000ULL) >> 24 | ((__uint64_t)(x) & 0xff000000000000ULL) >> 40 | ((__uint64_t)(x) & 0xff00000000000000ULL) >> 56)); }

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

pollution: fds_bits
__fd_mask fds_bits[(((1024) + ((((unsigned)(sizeof(__fd_mask) * 8))) - 1)) / (((unsigned)(sizeof(__fd_mask) * 8))))]; 

pollution: fd_set
pollution: fd_set
typedef struct fd_set { __fd_mask fds_bits[(((1024) + ((((unsigned)(sizeof(__fd_mask) * 8))) - 1)) / (((unsigned)(sizeof(__fd_mask) * 8))))]; } fd_set; 

pollution: fd
pollution: p
static __inline void __fd_set(int fd, fd_set *p) { p->fds_bits[fd / ((unsigned)(sizeof(__fd_mask) * 8))] |= (1U << (fd % ((unsigned)(sizeof(__fd_mask) * 8)))); }

pollution: fd
pollution: p
static __inline void __fd_clr(int fd, fd_set *p) { p->fds_bits[fd / ((unsigned)(sizeof(__fd_mask) * 8))] &= ~(1U << (fd % ((unsigned)(sizeof(__fd_mask) * 8)))); }

pollution: fd
pollution: p
static __inline int __fd_isset(int fd, const fd_set *p) { return (p->fds_bits[fd / ((unsigned)(sizeof(__fd_mask) * 8))] & (1U << (fd % ((unsigned)(sizeof(__fd_mask) * 8))))); }

pollution: timeval
pollution: select
int select(int, fd_set * __restrict, fd_set * __restrict, fd_set * __restrict, struct timeval * __restrict); 

pollution: pselect
int pselect(int, fd_set * __restrict, fd_set * __restrict, fd_set * __restrict, const struct timespec * __restrict, const sigset_t * __restrict); 

pollution: tz_minuteswest
int tz_minuteswest; 

pollution: tz_dsttime
int tz_dsttime; 

pollution: timezone
struct timezone { int tz_minuteswest; int tz_dsttime; }; 

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: daylight
extern int daylight; 

pollution: timezone
extern long timezone; 

pollution: strptime
char *strptime(const char *__restrict, const char *__restrict, struct tm *__restrict); 

pollution: asctime_r
char *asctime_r(const struct tm *__restrict, char *__restrict) __attribute__ ((__bounded__(__minbytes__,2,26))); 

pollution: ctime_r
char *ctime_r(const time_t *, char *) __attribute__ ((__bounded__(__minbytes__,2,26))); 

pollution: timeval
pollution: futimes
int futimes(int, const struct timeval *); 

pollution: itimerval
pollution: getitimer
int getitimer(int, struct itimerval *); 

pollution: timeval
pollution: timezone
pollution: gettimeofday
int gettimeofday(struct timeval *, struct timezone *); 

pollution: itimerval
pollution: itimerval
pollution: setitimer
int setitimer(int, const struct itimerval *, struct itimerval *); 

pollution: timeval
pollution: timezone
pollution: settimeofday
int settimeofday(const struct timeval *, const struct timezone *); 

pollution: timeval
pollution: utimes
int utimes(const char *, const struct timeval *); 

pollution: sc_rdi
long sc_rdi; 

pollution: sc_rsi
long sc_rsi; 

pollution: sc_rdx
long sc_rdx; 

pollution: sc_rcx
long sc_rcx; 

pollution: sc_r8
long sc_r8; 

pollution: sc_r9
long sc_r9; 

pollution: sc_r10
long sc_r10; 

pollution: sc_r11
long sc_r11; 

pollution: sc_r12
long sc_r12; 

pollution: sc_r13
long sc_r13; 

pollution: sc_r14
long sc_r14; 

pollution: sc_r15
long sc_r15; 

pollution: sc_rbp
long sc_rbp; 

pollution: sc_rbx
long sc_rbx; 

pollution: sc_rax
long sc_rax; 

pollution: sc_gs
long sc_gs; 

pollution: sc_fs
long sc_fs; 

pollution: sc_es
long sc_es; 

pollution: sc_ds
long sc_ds; 

pollution: sc_trapno
long sc_trapno; 

pollution: sc_err
long sc_err; 

pollution: sc_rip
long sc_rip; 

pollution: sc_cs
long sc_cs; 

pollution: sc_rflags
long sc_rflags; 

pollution: sc_rsp
long sc_rsp; 

pollution: sc_ss
long sc_ss; 

pollution: fxsave64
pollution: sc_fpstate
struct fxsave64 *sc_fpstate; 

pollution: sc_mask
int sc_mask; 

pollution: sc_cookie
long sc_cookie; 

pollution: sigcontext
struct sigcontext { long sc_rdi; long sc_rsi; long sc_rdx; long sc_rcx; long sc_r8; long sc_r9; long sc_r10; long sc_r11; long sc_r12; long sc_r13; long sc_r14; long sc_r15; long sc_rbp; long sc_rbx; long sc_rax; long sc_gs; long sc_fs; long sc_es; long sc_ds; long sc_trapno; long sc_err; long sc_rip; long sc_cs; long sc_rflags; long sc_rsp; long sc_ss; struct fxsave64 *sc_fpstate; int __sc_unused; int sc_mask; long sc_cookie; }; 

pollution: sigaltstack
typedef struct sigaltstack { void *ss_sp; size_t ss_size; int ss_flags; } stack_t; 

pollution: sigcontext
typedef struct sigcontext ucontext_t; 

pollution: pthread
struct pthread; 

pollution: pthread
typedef struct pthread *pthread_t; 

pollution: state
int state; 

pollution: mutex
pthread_mutex_t mutex; 

pollution: routine_arg
void pthread_cleanup_push(void (*) (void *), void *routine_arg); 

pollution: pthread
int pthread_getschedparam(pthread_t pthread, int *, struct sched_param *); 

pollution: ARG_MAX
#define ARG_MAX (512 * 1024)

pollution: BC_BASE_MAX
#define BC_BASE_MAX INT_MAX

pollution: BC_DIM_MAX
#define BC_DIM_MAX 65535

pollution: BC_SCALE_MAX
#define BC_SCALE_MAX INT_MAX

pollution: BC_STRING_MAX
#define BC_STRING_MAX INT_MAX

pollution: CHAR_BIT
#define CHAR_BIT 8

pollution: CHAR_MAX
#define CHAR_MAX 0x7f

pollution: CHAR_MIN
#define CHAR_MIN (-0x7f-1)

pollution: CHILD_MAX
#define CHILD_MAX 80

pollution: COLL_WEIGHTS_MAX
#define COLL_WEIGHTS_MAX 2

pollution: DST_AUST
#define DST_AUST 2

pollution: DST_CAN
#define DST_CAN 6

pollution: DST_EET
#define DST_EET 5

pollution: DST_MET
#define DST_MET 4

pollution: DST_NONE
#define DST_NONE 0

pollution: DST_USA
#define DST_USA 1

pollution: DST_WET
#define DST_WET 3

pollution: EMT_TAGOVF
#define EMT_TAGOVF 1

pollution: EXPR_NEST_MAX
#define EXPR_NEST_MAX 32

pollution: FD_CLR
#define FD_CLR(n,p) __fd_clr((n), (p))

pollution: FD_ISSET
#define FD_ISSET(n,p) __fd_isset((n), (p))

pollution: FD_SET
#define FD_SET(n,p) __fd_set((n), (p))

pollution: FD_SETSIZE
#define FD_SETSIZE 1024

pollution: FD_ZERO
#define FD_ZERO(p) do { fd_set *_p = (p); __size_t _n = __howmany(FD_SETSIZE, __NFDBITS); while (_n > 0) _p->fds_bits[--_n] = 0; } while (0)

pollution: GETENTROPY_MAX
#define GETENTROPY_MAX 256

pollution: HOST_NAME_MAX
#define HOST_NAME_MAX 255

pollution: INT_MAX
#define INT_MAX 0x7fffffff

pollution: INT_MIN
#define INT_MIN (-0x7fffffff-1)

pollution: IOV_MAX
#define IOV_MAX 1024

pollution: ITIMER_PROF
#define ITIMER_PROF 2

pollution: ITIMER_REAL
#define ITIMER_REAL 0

pollution: ITIMER_VIRTUAL
#define ITIMER_VIRTUAL 1

pollution: LINE_MAX
#define LINE_MAX 2048

pollution: LINK_MAX
#define LINK_MAX 32767

pollution: LLONG_MAX
#define LLONG_MAX 0x7fffffffffffffffLL

pollution: LLONG_MIN
#define LLONG_MIN (-0x7fffffffffffffffLL-1)

pollution: LOGIN_NAME_MAX
#define LOGIN_NAME_MAX 32

pollution: LONG_BIT
#define LONG_BIT 64

pollution: LONG_MAX
#define LONG_MAX 0x7fffffffffffffffL

pollution: LONG_MIN
#define LONG_MIN (-0x7fffffffffffffffL-1)

pollution: MAX_CANON
#define MAX_CANON 255

pollution: MAX_INPUT
#define MAX_INPUT 255

pollution: MB_LEN_MAX
#define MB_LEN_MAX 4

pollution: MINSIGSTKSZ
#define MINSIGSTKSZ (3U << _MAX_PAGE_SHIFT)

pollution: NAME_MAX
#define NAME_MAX 255

pollution: NGROUPS_MAX
#define NGROUPS_MAX 16

pollution: NL_ARGMAX
#define NL_ARGMAX 9

pollution: NL_LANGMAX
#define NL_LANGMAX 14

pollution: NL_MSGMAX
#define NL_MSGMAX 32767

pollution: NL_SETMAX
#define NL_SETMAX 255

pollution: NL_TEXTMAX
#define NL_TEXTMAX 255

pollution: NSIGBUS
#define NSIGBUS 3

pollution: NSIGCLD
#define NSIGCLD 6

pollution: NSIGEMT
#define NSIGEMT 1

pollution: NSIGFPE
#define NSIGFPE 8

pollution: NSIGILL
#define NSIGILL 9

pollution: NSIGSEGV
#define NSIGSEGV 2

pollution: NSIGTRAP
#define NSIGTRAP 2

pollution: NZERO
#define NZERO 20

pollution: OPEN_MAX
#define OPEN_MAX 64

pollution: PATH_MAX
#define PATH_MAX 1024

pollution: PIPE_BUF
#define PIPE_BUF 512

pollution: RE_DUP_MAX
#define RE_DUP_MAX 255

pollution: SCHAR_MAX
#define SCHAR_MAX 0x7f

pollution: SCHAR_MIN
#define SCHAR_MIN (-0x7f-1)

pollution: SEM_VALUE_MAX
#define SEM_VALUE_MAX UINT_MAX

pollution: SHRT_MAX
#define SHRT_MAX 0x7fff

pollution: SHRT_MIN
#define SHRT_MIN (-0x7fff-1)

pollution: SSIZE_MAX
#define SSIZE_MAX LONG_MAX

pollution: SS_DISABLE
#define SS_DISABLE 0x0004

pollution: SS_ONSTACK
#define SS_ONSTACK 0x0001

pollution: SYMLINK_MAX
#define SYMLINK_MAX PATH_MAX

pollution: SYMLOOP_MAX
#define SYMLOOP_MAX 32

pollution: TIMESPEC_TO_TIMEVAL
#define TIMESPEC_TO_TIMEVAL(tv,ts) do { (tv)->tv_sec = (ts)->tv_sec; (tv)->tv_usec = (ts)->tv_nsec / 1000; } while (0)

pollution: TIMEVAL_TO_TIMESPEC
#define TIMEVAL_TO_TIMESPEC(tv,ts) do { (ts)->tv_sec = (tv)->tv_sec; (ts)->tv_nsec = (tv)->tv_usec * 1000; } while (0)

pollution: TRAP_BRKPT
#define TRAP_BRKPT 1

pollution: TRAP_TRACE
#define TRAP_TRACE 2

pollution: TTY_NAME_MAX
#define TTY_NAME_MAX 260

pollution: UCHAR_MAX
#define UCHAR_MAX 0xff

pollution: UINT_MAX
#define UINT_MAX 0xffffffffU

pollution: ULLONG_MAX
#define ULLONG_MAX 0xffffffffffffffffULL

pollution: ULONG_MAX
#define ULONG_MAX 0xffffffffffffffffUL

pollution: USHRT_MAX
#define USHRT_MAX 0xffff

pollution: WORD_BIT
#define WORD_BIT 32

pollution: timeradd
#define timeradd(tvp,uvp,vvp) do { (vvp)->tv_sec = (tvp)->tv_sec + (uvp)->tv_sec; (vvp)->tv_usec = (tvp)->tv_usec + (uvp)->tv_usec; if ((vvp)->tv_usec >= 1000000) { (vvp)->tv_sec++; (vvp)->tv_usec -= 1000000; } } while (0)

pollution: timerclear
#define timerclear(tvp) (tvp)->tv_sec = (tvp)->tv_usec = 0

pollution: timercmp
#define timercmp(tvp,uvp,cmp) (((tvp)->tv_sec == (uvp)->tv_sec) ? ((tvp)->tv_usec cmp (uvp)->tv_usec) : ((tvp)->tv_sec cmp (uvp)->tv_sec))

pollution: timerisset
#define timerisset(tvp) ((tvp)->tv_sec || (tvp)->tv_usec)

pollution: timerisvalid
#define timerisvalid(tvp) ((tvp)->tv_usec >= 0 && (tvp)->tv_usec < 1000000)

pollution: timersub
#define timersub(tvp,uvp,vvp) do { (vvp)->tv_sec = (tvp)->tv_sec - (uvp)->tv_sec; (vvp)->tv_usec = (tvp)->tv_usec - (uvp)->tv_usec; if ((vvp)->tv_usec < 0) { (vvp)->tv_sec--; (vvp)->tv_usec += 1000000; } } while (0)

pollution: timespecadd
#define timespecadd(tsp,usp,vsp) do { (vsp)->tv_sec = (tsp)->tv_sec + (usp)->tv_sec; (vsp)->tv_nsec = (tsp)->tv_nsec + (usp)->tv_nsec; if ((vsp)->tv_nsec >= 1000000000L) { (vsp)->tv_sec++; (vsp)->tv_nsec -= 1000000000L; } } while (0)

pollution: timespecclear
#define timespecclear(tsp) (tsp)->tv_sec = (tsp)->tv_nsec = 0

pollution: timespeccmp
#define timespeccmp(tsp,usp,cmp) (((tsp)->tv_sec == (usp)->tv_sec) ? ((tsp)->tv_nsec cmp (usp)->tv_nsec) : ((tsp)->tv_sec cmp (usp)->tv_sec))

pollution: timespecisset
#define timespecisset(tsp) ((tsp)->tv_sec || (tsp)->tv_nsec)

pollution: timespecisvalid
#define timespecisvalid(tsp) ((tsp)->tv_nsec >= 0 && (tsp)->tv_nsec < 1000000000L)

pollution: timespecsub
#define timespecsub(tsp,usp,vsp) do { (vsp)->tv_sec = (tsp)->tv_sec - (usp)->tv_sec; (vsp)->tv_nsec = (tsp)->tv_nsec - (usp)->tv_nsec; if ((vsp)->tv_nsec < 0) { (vsp)->tv_sec--; (vsp)->tv_nsec += 1000000000L; } } while (0)