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: tv_sec
time_t tv_sec; 

pollution: tv_usec
suseconds_t tv_usec; 

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

pollution: tv_sec
time_t tv_sec; 

pollution: tv_nsec
long tv_nsec; 

pollution: timespec
struct timespec { time_t tv_sec; long tv_nsec; }; 

pollution: timeval
pollution: it_interval
struct timeval it_interval; 

pollution: timeval
pollution: it_value
struct timeval it_value; 

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

pollution: timespec
pollution: it_interval
struct timespec it_interval; 

pollution: timespec
pollution: it_value
struct timespec it_value; 

pollution: itimerspec
struct itimerspec { struct timespec it_interval; struct timespec 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: ss_sp
void *ss_sp; 

pollution: ss_size
size_t ss_size; 

pollution: ss_flags
int ss_flags; 

pollution: tm_sec
int tm_sec; 

pollution: tm_min
int tm_min; 

pollution: tm_hour
int tm_hour; 

pollution: tm_mday
int tm_mday; 

pollution: tm_mon
int tm_mon; 

pollution: tm_year
int tm_year; 

pollution: tm_wday
int tm_wday; 

pollution: tm_yday
int tm_yday; 

pollution: tm_isdst
int tm_isdst; 

pollution: tm_gmtoff
long tm_gmtoff; 

pollution: tm_zone
char *tm_zone; 

pollution: tm
struct tm { int tm_sec; int tm_min; int tm_hour; int tm_mday; int tm_mon; int tm_year; int tm_wday; int tm_yday; int tm_isdst; long tm_gmtoff; char *tm_zone; }; 

pollution: tm
pollution: asctime
char *asctime(const struct tm *); 

pollution: clock
clock_t clock(void); 

pollution: ctime
char *ctime(const time_t *) __asm("__ctime50"); 

pollution: difftime
double difftime(time_t, time_t) __asm("__difftime50"); 

pollution: tm
pollution: gmtime
struct tm *gmtime(const time_t *) __asm("__gmtime50"); 

pollution: tm
pollution: localtime
struct tm *localtime(const time_t *) __asm("__locatime50"); 

pollution: time
time_t time(time_t *) __asm("__time50"); 

pollution: tm
pollution: mktime
time_t mktime(struct tm *) __asm("__mktime50"); 

pollution: tm
pollution: strftime
size_t strftime(char * restrict, size_t, const char * restrict, const struct tm * restrict) __attribute__((__format__(__strftime__, 3, 0))); 

pollution: tzname
extern char *tzname[2]; 

pollution: tzset
void tzset(void) __asm("__tzset50"); 

pollution: daylight
extern int daylight; 

pollution: timezone
extern long int timezone __asm("__timezone13"); 

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

pollution: sigevent
struct sigevent; 

pollution: itimerspec
struct itimerspec; 

pollution: timespec
pollution: timespec
pollution: clock_nanosleep
int clock_nanosleep(clockid_t, int, const struct timespec *, struct timespec *); 

pollution: timespec
pollution: clock_getres
int clock_getres(clockid_t, struct timespec *) __asm("__clock_getres50"); 

pollution: timespec
pollution: clock_gettime
int clock_gettime(clockid_t, struct timespec *) __asm("__clock_gettime50"); 

pollution: timespec
pollution: clock_settime
int clock_settime(clockid_t, const struct timespec *) __asm("__clock_settime50"); 

pollution: timespec
pollution: timespec
pollution: nanosleep
int nanosleep(const struct timespec *, struct timespec *) __asm("__nanosleep50"); 

pollution: itimerspec
pollution: timer_gettime
int timer_gettime(timer_t, struct itimerspec *) __asm("__timer_gettime50"); 

pollution: itimerspec
pollution: itimerspec
pollution: timer_settime
int timer_settime(timer_t, int, const struct itimerspec * restrict, struct itimerspec * restrict) __asm("__timer_settime50"); 

pollution: sigevent
pollution: timer_create
int timer_create(clockid_t, struct sigevent * restrict, timer_t * restrict); 

pollution: timer_delete
int timer_delete(timer_t); 

pollution: timer_getoverrun
int timer_getoverrun(timer_t); 

pollution: tm
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: tm
pollution: tm
pollution: gmtime_r
struct tm *gmtime_r(const time_t * restrict, struct tm * restrict) __asm("__gmtime_r50"); 

pollution: tm
pollution: tm
pollution: localtime_r
struct tm *localtime_r(const time_t * restrict, struct tm * restrict) __asm("__localtime_r50"); 

pollution: tm
pollution: strftime_l
size_t strftime_l(char * restrict, size_t, const char * restrict, const struct tm * restrict, locale_t) __attribute__((__format__(__strftime__, 3, 0))); 

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: st_dev
dev_t st_dev; 

pollution: st_mode
__mode_t st_mode; 

pollution: st_ino
ino_t st_ino; 

pollution: st_nlink
nlink_t st_nlink; 

pollution: st_uid
__uid_t st_uid; 

pollution: st_gid
__gid_t st_gid; 

pollution: st_rdev
dev_t st_rdev; 

pollution: timespec
pollution: st_atim
struct timespec st_atim; 

pollution: timespec
pollution: st_mtim
struct timespec st_mtim; 

pollution: timespec
pollution: st_ctim
struct timespec st_ctim; 

pollution: timespec
pollution: st_birthtim
struct timespec st_birthtim; 

pollution: st_size
__off_t st_size; 

pollution: st_blocks
blkcnt_t st_blocks; 

pollution: st_blksize
blksize_t st_blksize; 

pollution: st_flags
__uint32_t st_flags; 

pollution: st_gen
__uint32_t st_gen; 

pollution: st_spare
__uint32_t st_spare[2]; 

pollution: stat
struct stat { dev_t st_dev; __mode_t st_mode; ino_t st_ino; nlink_t st_nlink; __uid_t st_uid; __gid_t st_gid; dev_t st_rdev; struct timespec st_atim; struct timespec st_mtim; struct timespec st_ctim; struct timespec st_birthtim; __off_t st_size; blkcnt_t st_blocks; blksize_t st_blksize; __uint32_t st_flags; __uint32_t st_gen; __uint32_t st_spare[2]; }; 

pollution: chmod
int chmod(const char *, __mode_t); 

pollution: mkdir
int mkdir(const char *, __mode_t); 

pollution: mkfifo
int mkfifo(const char *, __mode_t); 

pollution: stat
pollution: stat
int stat(const char *, struct stat *) __asm("__stat50"); 

pollution: stat
pollution: fstat
int fstat(int, struct stat *) __asm("__fstat50"); 

pollution: umask
__mode_t umask(__mode_t); 

pollution: stat
pollution: lstat
int lstat(const char *, struct stat *) __asm("__lstat50"); 

pollution: fchmod
int fchmod(int, __mode_t); 

pollution: mknod
int mknod(const char *, __mode_t, dev_t) __asm("__mknod50"); 

pollution: fchmodat
int fchmodat(int, const char *, __mode_t, int); 

pollution: stat
pollution: fstatat
int fstatat(int, const char *, struct stat *, int); 

pollution: mkdirat
int mkdirat(int, const char *, __mode_t); 

pollution: mkfifoat
int mkfifoat(int, const char *, __mode_t); 

pollution: mknodat
int mknodat(int, const char *, __mode_t, dev_t); 

pollution: timespec
pollution: utimensat
int utimensat(int, const char *, const struct timespec *, int); 

pollution: timespec
pollution: futimens
int futimens(int, const struct timespec *); 

pollution: dirent
struct dirent *(*gl_readdir)(void *); 

pollution: stat
int (*gl_lstat)(const char *, struct stat *); 

pollution: stat
int (*gl_stat)(const char *, struct stat *); 

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: CLOCKS_PER_SEC
#define CLOCKS_PER_SEC 100

pollution: CLOCK_MONOTONIC
#define CLOCK_MONOTONIC 3

pollution: CLOCK_REALTIME
#define CLOCK_REALTIME 0

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: 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: INT16_C
#define INT16_C(c) __int_join(c, __INT16_C_SUFFIX__)

pollution: INT16_MAX
#define INT16_MAX __INT16_MAX__

pollution: INT16_MIN
#define INT16_MIN (-__INT16_MAX__-1)

pollution: INT32_C
#define INT32_C(c) __int_join(c, __INT32_C_SUFFIX__)

pollution: INT32_MAX
#define INT32_MAX __INT32_MAX__

pollution: INT32_MIN
#define INT32_MIN (-__INT32_MAX__-1)

pollution: INT64_C
#define INT64_C(c) __int_join(c, __INT64_C_SUFFIX__)

pollution: INT64_MAX
#define INT64_MAX __INT64_MAX__

pollution: INT64_MIN
#define INT64_MIN (-__INT64_MAX__-1)

pollution: INT8_C
#define INT8_C(c) __int_join(c, __INT8_C_SUFFIX__)

pollution: INT8_MAX
#define INT8_MAX __INT8_MAX__

pollution: INT8_MIN
#define INT8_MIN (-__INT8_MAX__-1)

pollution: INTMAX_C
#define INTMAX_C(c) __int_join(c, __INTMAX_C_SUFFIX__)

pollution: INTMAX_MAX
#define INTMAX_MAX __INTMAX_MAX__

pollution: INTMAX_MIN
#define INTMAX_MIN (-__INTMAX_MAX__-1)

pollution: INTPTR_MAX
#define INTPTR_MAX __INTPTR_MAX__

pollution: INTPTR_MIN
#define INTPTR_MIN (-__INTPTR_MAX__-1)

pollution: INT_FAST16_MAX
#define INT_FAST16_MAX __INT_FAST16_MAX__

pollution: INT_FAST16_MIN
#define INT_FAST16_MIN (-__INT_FAST16_MAX__-1)

pollution: INT_FAST32_MAX
#define INT_FAST32_MAX __INT_FAST32_MAX__

pollution: INT_FAST32_MIN
#define INT_FAST32_MIN (-__INT_FAST32_MAX__-1)

pollution: INT_FAST64_MAX
#define INT_FAST64_MAX __INT_FAST64_MAX__

pollution: INT_FAST64_MIN
#define INT_FAST64_MIN (-__INT_FAST64_MAX__-1)

pollution: INT_FAST8_MAX
#define INT_FAST8_MAX __INT_FAST8_MAX__

pollution: INT_FAST8_MIN
#define INT_FAST8_MIN (-__INT_FAST8_MAX__-1)

pollution: INT_LEAST16_MAX
#define INT_LEAST16_MAX __INT_LEAST16_MAX__

pollution: INT_LEAST16_MIN
#define INT_LEAST16_MIN (-__INT_LEAST16_MAX__-1)

pollution: INT_LEAST32_MAX
#define INT_LEAST32_MAX __INT_LEAST32_MAX__

pollution: INT_LEAST32_MIN
#define INT_LEAST32_MIN (-__INT_LEAST32_MAX__-1)

pollution: INT_LEAST64_MAX
#define INT_LEAST64_MAX __INT_LEAST64_MAX__

pollution: INT_LEAST64_MIN
#define INT_LEAST64_MIN (-__INT_LEAST64_MAX__-1)

pollution: INT_LEAST8_MAX
#define INT_LEAST8_MAX __INT_LEAST8_MAX__

pollution: INT_LEAST8_MIN
#define INT_LEAST8_MIN (-__INT_LEAST8_MAX__-1)

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: NTOHL
#define NTOHL(x) (x) = ntohl(__CAST(uint32_t, (x)))

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

pollution: NULL
#define NULL ((void *)0)

pollution: PDP_ENDIAN
#define PDP_ENDIAN 3412

pollution: PRIxREGISTER
#define PRIxREGISTER "x"

pollution: PTRDIFF_MAX
#define PTRDIFF_MAX __PTRDIFF_MAX__

pollution: PTRDIFF_MIN
#define PTRDIFF_MIN (-__PTRDIFF_MAX__-1)

pollution: SIG_ATOMIC_MAX
#define SIG_ATOMIC_MAX __SIG_ATOMIC_MAX__

pollution: SIG_ATOMIC_MIN
#define SIG_ATOMIC_MIN (-__SIG_ATOMIC_MAX__-1)

pollution: SIZE_MAX
#define SIZE_MAX __SIZE_MAX__

pollution: S_IFBLK
#define S_IFBLK _S_IFBLK

pollution: S_IFCHR
#define S_IFCHR _S_IFCHR

pollution: S_IFDIR
#define S_IFDIR _S_IFDIR

pollution: S_IFIFO
#define S_IFIFO _S_IFIFO

pollution: S_IFLNK
#define S_IFLNK _S_IFLNK

pollution: S_IFMT
#define S_IFMT _S_IFMT

pollution: S_IFREG
#define S_IFREG _S_IFREG

pollution: S_IFSOCK
#define S_IFSOCK _S_IFSOCK

pollution: S_IRGRP
#define S_IRGRP 0000040

pollution: S_IROTH
#define S_IROTH 0000004

pollution: S_IRUSR
#define S_IRUSR 0000400

pollution: S_IRWXG
#define S_IRWXG 0000070

pollution: S_IRWXO
#define S_IRWXO 0000007

pollution: S_IRWXU
#define S_IRWXU 0000700

pollution: S_ISBLK
#define S_ISBLK(m) (((m) & _S_IFMT) == _S_IFBLK)

pollution: S_ISCHR
#define S_ISCHR(m) (((m) & _S_IFMT) == _S_IFCHR)

pollution: S_ISDIR
#define S_ISDIR(m) (((m) & _S_IFMT) == _S_IFDIR)

pollution: S_ISFIFO
#define S_ISFIFO(m) (((m) & _S_IFMT) == _S_IFIFO)

pollution: S_ISGID
#define S_ISGID 0002000

pollution: S_ISLNK
#define S_ISLNK(m) (((m) & _S_IFMT) == _S_IFLNK)

pollution: S_ISREG
#define S_ISREG(m) (((m) & _S_IFMT) == _S_IFREG)

pollution: S_ISSOCK
#define S_ISSOCK(m) (((m) & _S_IFMT) == _S_IFSOCK)

pollution: S_ISUID
#define S_ISUID 0004000

pollution: S_ISVTX
#define S_ISVTX _S_ISVTX

pollution: S_IWGRP
#define S_IWGRP 0000020

pollution: S_IWOTH
#define S_IWOTH 0000002

pollution: S_IWUSR
#define S_IWUSR 0000200

pollution: S_IXGRP
#define S_IXGRP 0000010

pollution: S_IXOTH
#define S_IXOTH 0000001

pollution: S_IXUSR
#define S_IXUSR 0000100

pollution: TIMER_ABSTIME
#define TIMER_ABSTIME 0x1

pollution: UINT16_C
#define UINT16_C(c) __int_join(c, __UINT16_C_SUFFIX__)

pollution: UINT16_MAX
#define UINT16_MAX __UINT16_MAX__

pollution: UINT32_C
#define UINT32_C(c) __int_join(c, __UINT32_C_SUFFIX__)

pollution: UINT32_MAX
#define UINT32_MAX __UINT32_MAX__

pollution: UINT64_C
#define UINT64_C(c) __int_join(c, __UINT64_C_SUFFIX__)

pollution: UINT64_MAX
#define UINT64_MAX __UINT64_MAX__

pollution: UINT8_C
#define UINT8_C(c) __int_join(c, __UINT8_C_SUFFIX__)

pollution: UINT8_MAX
#define UINT8_MAX __UINT8_MAX__

pollution: UINTMAX_C
#define UINTMAX_C(c) __int_join(c, __UINTMAX_C_SUFFIX__)

pollution: UINTMAX_MAX
#define UINTMAX_MAX __UINTMAX_MAX__

pollution: UINTPTR_MAX
#define UINTPTR_MAX __UINTPTR_MAX__

pollution: UINT_FAST16_MAX
#define UINT_FAST16_MAX __UINT_FAST16_MAX__

pollution: UINT_FAST32_MAX
#define UINT_FAST32_MAX __UINT_FAST32_MAX__

pollution: UINT_FAST64_MAX
#define UINT_FAST64_MAX __UINT_FAST64_MAX__

pollution: UINT_FAST8_MAX
#define UINT_FAST8_MAX __UINT_FAST8_MAX__

pollution: UINT_LEAST16_MAX
#define UINT_LEAST16_MAX __UINT_LEAST16_MAX__

pollution: UINT_LEAST32_MAX
#define UINT_LEAST32_MAX __UINT_LEAST32_MAX__

pollution: UINT_LEAST64_MAX
#define UINT_LEAST64_MAX __UINT_LEAST64_MAX__

pollution: UINT_LEAST8_MAX
#define UINT_LEAST8_MAX __UINT_LEAST8_MAX__

pollution: UTIME_NOW
#define UTIME_NOW ((1 << 30) - 1)

pollution: UTIME_OMIT
#define UTIME_OMIT ((1 << 30) - 2)

pollution: WCHAR_MAX
#define WCHAR_MAX 0x7fffffff

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

pollution: WINT_MAX
#define WINT_MAX 0x7fffffff

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

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)))

pollution: st_atime
#define st_atime st_atim.tv_sec

pollution: st_birthtime
#define st_birthtime st_birthtim.tv_sec

pollution: st_ctime
#define st_ctime st_ctim.tv_sec

pollution: st_mtime
#define st_mtime st_mtim.tv_sec