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

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

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

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; 

wrong type: struct: expected external: 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: hz
int hz; 

pollution: tick
int tick; 

pollution: tickadj
int tickadj; 

pollution: stathz
int stathz; 

pollution: profhz
int profhz; 

pollution: clockinfo
struct clockinfo { int hz; int tick; int tickadj; int stathz; int profhz; }; 

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

pollution: ctime_r
char *ctime_r(const time_t *, char *); 

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

pollution: timeval
wrong type: struct: expected external: timezone
pollution: gettimeofday
int gettimeofday(struct timeval * __restrict, struct timezone * __restrict); 

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

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

pollution: INT_LEAST16_MIN
#define INT_LEAST16_MIN INT16_MIN

pollution: SHRT_MAX
#define SHRT_MAX 0x7fff

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

pollution: INT16_C
#define INT16_C(c) (c)

pollution: INT8_MAX
#define INT8_MAX 0x7f

pollution: UINT_LEAST64_MAX
#define UINT_LEAST64_MAX UINT64_MAX

pollution: ITIMER_VIRTUAL
#define ITIMER_VIRTUAL 1

pollution: INT16_MAX
#define INT16_MAX 0x7fff

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

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

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

pollution: DST_AUST
#define DST_AUST 2

pollution: INT_FAST8_MAX
#define INT_FAST8_MAX INT32_MAX

pollution: WCHAR_MAX
#define WCHAR_MAX __WCHAR_MAX

pollution: WCHAR_MIN
#define WCHAR_MIN __WCHAR_MIN

pollution: FD_SETSIZE
#define FD_SETSIZE 1024

pollution: UINT_FAST16_MAX
#define UINT_FAST16_MAX UINT32_MAX

pollution: UINT16_C
#define UINT16_C(c) (c)

pollution: USHRT_MAX
#define USHRT_MAX 0xffff

pollution: UINT8_MAX
#define UINT8_MAX 0xff

pollution: INT_FAST16_MAX
#define INT_FAST16_MAX INT32_MAX

pollution: PTRDIFF_MAX
#define PTRDIFF_MAX INT64_MAX

pollution: INT64_C
#define INT64_C(c) (c ## L)

pollution: UINT8_C
#define UINT8_C(c) (c)

pollution: FD_SET
#define FD_SET(n,p) ((p)->fds_bits[(unsigned int)(n)/__NFDBITS] |= _fdset_mask(n))

pollution: INT_FAST16_MIN
#define INT_FAST16_MIN INT32_MIN

pollution: SSIZE_MAX
#define SSIZE_MAX LONG_MAX

pollution: PTRDIFF_MIN
#define PTRDIFF_MIN INT64_MIN

pollution: LONG_MAX
#define LONG_MAX 0x7fffffffffffffffL

pollution: ITIMER_PROF
#define ITIMER_PROF 2

pollution: LONG_BIT
#define LONG_BIT 64

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

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

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

pollution: SIZE_MAX
#define SIZE_MAX UINT64_MAX

pollution: timespeccmp
#define timespeccmp(tvp,uvp,cmp) (((tvp)->tv_sec == (uvp)->tv_sec) ? ((tvp)->tv_nsec cmp (uvp)->tv_nsec) : ((tvp)->tv_sec cmp (uvp)->tv_sec))

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

pollution: WINT_MAX
#define WINT_MAX __WINT_MAX

pollution: UINTPTR_MAX
#define UINTPTR_MAX UINT64_MAX

pollution: UINT_LEAST16_MAX
#define UINT_LEAST16_MAX UINT16_MAX

pollution: ITIMER_REAL
#define ITIMER_REAL 0

pollution: UINT32_MAX
#define UINT32_MAX 0xffffffffU

pollution: WINT_MIN
#define WINT_MIN __WINT_MIN

pollution: DST_WET
#define DST_WET 3

pollution: CHAR_MAX
#define CHAR_MAX SCHAR_MAX

pollution: INT_LEAST8_MAX
#define INT_LEAST8_MAX INT8_MAX

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

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

pollution: INT_LEAST32_MAX
#define INT_LEAST32_MAX INT32_MAX

pollution: CHAR_BIT
#define CHAR_BIT 8

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: CHAR_MIN
#define CHAR_MIN SCHAR_MIN

pollution: INT_LEAST8_MIN
#define INT_LEAST8_MIN INT8_MIN

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

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

pollution: INT_LEAST32_MIN
#define INT_LEAST32_MIN INT32_MIN

pollution: DST_EET
#define DST_EET 5

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: timespecisset
#define timespecisset(tvp) ((tvp)->tv_sec || (tvp)->tv_nsec)

pollution: DST_NONE
#define DST_NONE 0

pollution: INT32_MAX
#define INT32_MAX 0x7fffffff

pollution: UINT64_MAX
#define UINT64_MAX 0xffffffffffffffffUL

pollution: INTPTR_MAX
#define INTPTR_MAX INT64_MAX

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

pollution: INT_LEAST64_MAX
#define INT_LEAST64_MAX INT64_MAX

pollution: UCHAR_MAX
#define UCHAR_MAX 0xff

pollution: INTPTR_MIN
#define INTPTR_MIN INT64_MIN

pollution: INT8_C
#define INT8_C(c) (c)

pollution: UINT_FAST32_MAX
#define UINT_FAST32_MAX UINT32_MAX

pollution: INT_MAX
#define INT_MAX 0x7fffffff

pollution: ULLONG_MAX
#define ULLONG_MAX 0xffffffffffffffffULL

pollution: INT_LEAST64_MIN
#define INT_LEAST64_MIN INT64_MIN

pollution: UINTMAX_MAX
#define UINTMAX_MAX UINT64_MAX

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

pollution: INT64_MAX
#define INT64_MAX 0x7fffffffffffffffL

pollution: DST_MET
#define DST_MET 4

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

pollution: INT_FAST32_MAX
#define INT_FAST32_MAX INT32_MAX

pollution: UINT_FAST8_MAX
#define UINT_FAST8_MAX UINT32_MAX

pollution: UINT_MAX
#define UINT_MAX 0xffffffffU

pollution: LLONG_MAX
#define LLONG_MAX 0x7fffffffffffffffLL

pollution: UINT32_C
#define UINT32_C(c) (c ## U)

pollution: UINT_FAST64_MAX
#define UINT_FAST64_MAX UINT64_MAX

pollution: INT_FAST32_MIN
#define INT_FAST32_MIN INT32_MIN

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

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

pollution: OFF_MAX
#define OFF_MAX LONG_MAX

pollution: INTMAX_MAX
#define INTMAX_MAX INT64_MAX

pollution: OFF_MIN
#define OFF_MIN LONG_MIN

pollution: INTMAX_MIN
#define INTMAX_MIN INT64_MIN

pollution: FD_ISSET
#define FD_ISSET(n,p) ((p)->fds_bits[(unsigned int)(n)/__NFDBITS] & _fdset_mask(n))

pollution: INT_FAST64_MAX
#define INT_FAST64_MAX INT64_MAX

pollution: UINT_LEAST32_MAX
#define UINT_LEAST32_MAX UINT32_MAX

pollution: WORD_BIT
#define WORD_BIT 32

pollution: SIZE_T_MAX
#define SIZE_T_MAX ULONG_MAX

pollution: INT_FAST64_MIN
#define INT_FAST64_MIN INT64_MIN

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: UINT16_MAX
#define UINT16_MAX 0xffff

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: FD_CLR
#define FD_CLR(n,p) ((p)->fds_bits[(unsigned int)(n)/__NFDBITS] &= ~_fdset_mask(n))

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: DST_CAN
#define DST_CAN 6

pollution: DST_USA
#define DST_USA 1

pollution: INT_LEAST16_MAX
#define INT_LEAST16_MAX INT16_MAX