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: 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: 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: timespec
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
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: 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 *); 

pollution: difftime
double difftime(time_t, time_t); 

pollution: tm
pollution: gmtime
struct tm *gmtime(const time_t *); 

pollution: tm
pollution: localtime
struct tm *localtime(const time_t *); 

pollution: tm
pollution: mktime
time_t mktime(struct tm *); 

pollution: tm
pollution: strftime
size_t strftime(char *__restrict, size_t, const char *__restrict, const struct tm *__restrict) __attribute__ ((__bounded__(__string__,1,2))); 

pollution: time
time_t time(time_t *); 

pollution: daylight
extern int daylight; 

pollution: timezone
extern long timezone; 

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

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

pollution: tm
pollution: tm
pollution: localtime_r
struct tm *localtime_r(const time_t *__restrict, struct tm *__restrict); 

pollution: tzname
extern char *tzname[2]; 

pollution: tzset
void tzset(void); 

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

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

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

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

pollution: clock_getcpuclockid
int clock_getcpuclockid(pid_t, clockid_t *); 

pollution: tm
pollution: strftime_l
size_t strftime_l(char *__restrict, size_t, const char *__restrict, const struct tm *__restrict, locale_t) __attribute__ ((__bounded__(__string__,1,2))); 

pollution: timespec
pollution: timespec_get
int timespec_get(struct timespec *_ts, int _base); 

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: st_mode
mode_t st_mode; 

pollution: st_dev
dev_t st_dev; 

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: st_size
off_t st_size; 

pollution: st_blocks
blkcnt_t st_blocks; 

pollution: st_blksize
blksize_t st_blksize; 

pollution: st_flags
u_int32_t st_flags; 

pollution: st_gen
u_int32_t st_gen; 

pollution: timespec
struct timespec __st_birthtim; 

pollution: stat
struct stat { mode_t st_mode; dev_t st_dev; 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; off_t st_size; blkcnt_t st_blocks; blksize_t st_blksize; u_int32_t st_flags; u_int32_t st_gen; struct timespec __st_birthtim; }; 

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

pollution: stat
pollution: fstat
int fstat(int, struct stat *); 

pollution: mknod
int mknod(const char *, mode_t, dev_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 *); 

pollution: umask
mode_t umask(mode_t); 

pollution: fchmod
int fchmod(int, mode_t); 

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

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 [2], int); 

pollution: timespec
pollution: futimens
int futimens(int, const struct timespec [2]); 

pollution: stat
struct stat; 

pollution: stat
struct stat **gl_statv; 

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

pollution: CLOCK_BOOTTIME
#define CLOCK_BOOTTIME 6

pollution: CLOCK_MONOTONIC
#define CLOCK_MONOTONIC 3

pollution: CLOCK_PROCESS_CPUTIME_ID
#define CLOCK_PROCESS_CPUTIME_ID 2

pollution: CLOCK_REALTIME
#define CLOCK_REALTIME 0

pollution: CLOCK_THREAD_CPUTIME_ID
#define CLOCK_THREAD_CPUTIME_ID 4

pollution: CLOCK_UPTIME
#define CLOCK_UPTIME 5

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

pollution: ITIMER_REAL
#define ITIMER_REAL 0

pollution: ITIMER_VIRTUAL
#define ITIMER_VIRTUAL 1

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

pollution: S_IFBLK
#define S_IFBLK 0060000

pollution: S_IFCHR
#define S_IFCHR 0020000

pollution: S_IFDIR
#define S_IFDIR 0040000

pollution: S_IFIFO
#define S_IFIFO 0010000

pollution: S_IFLNK
#define S_IFLNK 0120000

pollution: S_IFMT
#define S_IFMT 0170000

pollution: S_IFREG
#define S_IFREG 0100000

pollution: S_IFSOCK
#define S_IFSOCK 0140000

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 & 0170000) == 0060000)

pollution: S_ISCHR
#define S_ISCHR(m) ((m & 0170000) == 0020000)

pollution: S_ISDIR
#define S_ISDIR(m) ((m & 0170000) == 0040000)

pollution: S_ISFIFO
#define S_ISFIFO(m) ((m & 0170000) == 0010000)

pollution: S_ISGID
#define S_ISGID 0002000

pollution: S_ISLNK
#define S_ISLNK(m) ((m & 0170000) == 0120000)

pollution: S_ISREG
#define S_ISREG(m) ((m & 0170000) == 0100000)

pollution: S_ISSOCK
#define S_ISSOCK(m) ((m & 0170000) == 0140000)

pollution: S_ISUID
#define S_ISUID 0004000

pollution: S_ISVTX
#define S_ISVTX 0001000

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: S_TYPEISMQ
#define S_TYPEISMQ(m) 0

pollution: S_TYPEISSEM
#define S_TYPEISSEM(m) 0

pollution: S_TYPEISSHM
#define S_TYPEISSHM(m) 0

pollution: TIMER_ABSTIME
#define TIMER_ABSTIME 0x1

pollution: TIMER_RELTIME
#define TIMER_RELTIME 0x0

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: TIME_UTC
#define TIME_UTC 1

pollution: UTIME_NOW
#define UTIME_NOW -2L

pollution: UTIME_OMIT
#define UTIME_OMIT -1L

pollution: st_atime
#define st_atime st_atim.tv_sec

pollution: st_ctime
#define st_ctime st_ctim.tv_sec

pollution: st_mtime
#define st_mtime st_mtim.tv_sec

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)