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: 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: tz_minuteswest
int tz_minuteswest; 

pollution: tz_dsttime
int tz_dsttime; 

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

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: futimes
int futimes(int, const struct timeval *); 

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

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: timezone
pollution: settimeofday
int settimeofday(const struct timeval *, const struct timezone *); 

pollution: ru_utime
struct timeval ru_utime; 

pollution: ru_stime
struct timeval ru_stime; 

pollution: ru_maxrss
long ru_maxrss; 

pollution: ru_ixrss
long ru_ixrss; 

pollution: ru_idrss
long ru_idrss; 

pollution: ru_isrss
long ru_isrss; 

pollution: ru_minflt
long ru_minflt; 

pollution: ru_majflt
long ru_majflt; 

pollution: ru_nswap
long ru_nswap; 

pollution: ru_inblock
long ru_inblock; 

pollution: ru_oublock
long ru_oublock; 

pollution: ru_msgsnd
long ru_msgsnd; 

pollution: ru_msgrcv
long ru_msgrcv; 

pollution: ru_nsignals
long ru_nsignals; 

pollution: ru_nvcsw
long ru_nvcsw; 

pollution: ru_nivcsw
long ru_nivcsw; 

pollution: rusage
struct rusage { struct timeval ru_utime; struct timeval ru_stime; long ru_maxrss; long ru_ixrss; long ru_idrss; long ru_isrss; long ru_minflt; long ru_majflt; long ru_nswap; long ru_inblock; long ru_oublock; long ru_msgsnd; long ru_msgrcv; long ru_nsignals; long ru_nvcsw; long ru_nivcsw; }; 

pollution: getpriority
int getpriority(int, id_t); 

pollution: rusage
pollution: getrusage
int getrusage(int, struct rusage *); 

pollution: setpriority
int setpriority(int, id_t, int); 

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: ITIMER_PROF
#define ITIMER_PROF 2

pollution: ITIMER_REAL
#define ITIMER_REAL 0

pollution: ITIMER_VIRTUAL
#define ITIMER_VIRTUAL 1

pollution: PRIO_MAX
#define PRIO_MAX 20

pollution: PRIO_MIN
#define PRIO_MIN (-20)

pollution: PRIO_PGRP
#define PRIO_PGRP 1

pollution: PRIO_PROCESS
#define PRIO_PROCESS 0

pollution: PRIO_USER
#define PRIO_USER 2

pollution: RLIMIT_CPU
#define RLIMIT_CPU 0

pollution: RLIMIT_MEMLOCK
#define RLIMIT_MEMLOCK 6

pollution: RLIMIT_NPROC
#define RLIMIT_NPROC 7

pollution: RLIMIT_RSS
#define RLIMIT_RSS 5

pollution: RLIM_NLIMITS
#define RLIM_NLIMITS 9

pollution: RUSAGE_CHILDREN
#define RUSAGE_CHILDREN (-1)

pollution: RUSAGE_SELF
#define RUSAGE_SELF 0

pollution: RUSAGE_THREAD
#define RUSAGE_THREAD 1

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: ru_first
#define ru_first ru_ixrss

pollution: ru_last
#define ru_last ru_nivcsw

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)