pollution: access
int access(const char *__path, int __mode); 

pollution: alarm
unsigned int alarm(unsigned int __seconds); 

pollution: chdir
int chdir(const char *__path); 

pollution: chown
int chown(const char *__path, uid_t __uid, gid_t __gid); 

pollution: close
int close(int __fd); 

pollution: confstr
size_t confstr(int __name, char *__buf, size_t __size); 

pollution: ctermid
char *ctermid(char *__s); 

pollution: dup
int dup(int __fd); 

pollution: dup2
int dup2(int __src_fd, int __dest_fd); 

pollution: dup3
int dup3(int __fd, int __newfd, int __flags); 

pollution: execl
int execl(const char *__path, const char *__arg, ...); 

pollution: execle
int execle(const char *__path, const char *__arg, ...); 

pollution: execlp
int execlp(const char *__file, const char *__arg, ...); 

pollution: execv
int execv(const char *__path, char *const __argv[]); 

pollution: execve
int execve(const char *__path, char *const __argv[], char *const __envp[]); 

pollution: execvp
int execvp(const char *__file, char *const __argv[]); 

pollution: faccessat
int faccessat(int __fd, const char *__path, int __mode, int __flags); 

pollution: fchdir
int fchdir(int __fd); 

pollution: fchown
int fchown(int __fd, uid_t __uid, gid_t __gid); 

pollution: fchownat
int fchownat(int __fd, const char *__path, uid_t __uid, gid_t __gid, int __flags); 

pollution: fdatasync
int fdatasync(int __fd); 

pollution: fexecve
int fexecve(int __fd, char *const __argv[], char *const __envp[]); 

pollution: fork
pid_t fork(void); 

pollution: fpathconf
long fpathconf(int __fd, int __name); 

pollution: fsync
int fsync(int __fd); 

pollution: ftruncate
int ftruncate(int __fd, off_t __size); 

pollution: getcwd
char *getcwd(char *__buffer, size_t __size); 

pollution: getegid
gid_t getegid(void); 

pollution: geteuid
uid_t geteuid(void); 

pollution: getgid
gid_t getgid(void); 

pollution: getgroups
int getgroups(int __size, gid_t __list[]); 

pollution: gethostname
int gethostname(char *__buffer, size_t __max_length); 

pollution: getlogin
char *getlogin(void); 

pollution: getlogin_r
int getlogin_r(char *__buffer, size_t __size); 

pollution: getopt
int getopt(int __argc, char *const __argv[], const char *__optstring); 

pollution: getpgid
pid_t getpgid(pid_t __pid); 

pollution: getpgrp
pid_t getpgrp(void); 

pollution: getpid
pid_t getpid(void); 

pollution: getppid
pid_t getppid(void); 

pollution: getsid
pid_t getsid(pid_t __pid); 

pollution: getuid
uid_t getuid(void); 

pollution: isatty
int isatty(int __fd); 

pollution: lchown
int lchown(const char *__path, uid_t __uid, gid_t __gid); 

pollution: link
int link(const char *__oldpath, const char *__newpath); 

pollution: linkat
int linkat(int __olddirfd, const char *__oldpath, int __newdirfd, const char *__newpath, int __flags); 

pollution: lockf
int lockf(int __fd, int __op, off_t __size); 

pollution: lseek
off_t lseek(int __fd, off_t __offset, int __whence); 

pollution: nice
int nice(int __increment); 

pollution: pathconf
long pathconf(const char *__path, int __name); 

pollution: pause
int pause(void); 

pollution: pipe
int pipe(int __pipefd[2]); 

pollution: pread
ssize_t pread(int __fd, void *__buf, size_t __size, off_t __offset); 

pollution: pwrite
ssize_t pwrite(int __fd, const void *__buf, size_t __size, off_t __offset); 

pollution: read
ssize_t read(int __fd, void *__buffer, size_t __size); 

pollution: readlink
ssize_t readlink(const char *__restrict __path, char *__restrict __buf, size_t __size); 

pollution: readlinkat
ssize_t readlinkat(int __dirfd, const char *__restrict __path, char *__restrict __buf, size_t __size); 

pollution: rmdir
int rmdir(const char *__path); 

pollution: setegid
int setegid(gid_t __egid); 

pollution: seteuid
int seteuid(uid_t __euid); 

pollution: setgid
int setgid(gid_t __gid); 

pollution: setpgid
int setpgid(pid_t __pid, pid_t __pgid); 

pollution: gethostid
long gethostid(void); 

pollution: sync
void sync(void); 

pollution: setregid
int setregid(gid_t __rgid, gid_t __egid); 

pollution: setreuid
int setreuid(uid_t __ruid, uid_t __euid); 

pollution: setsid
pid_t setsid(void); 

pollution: setuid
int setuid(uid_t __uid); 

pollution: sleep
unsigned int sleep(unsigned int __seconds); 

pollution: swab
void swab(const void *__restrict __from, void *__restrict __to, ssize_t __size); 

pollution: symlink
int symlink(const char *__target, const char *__linkpath); 

pollution: symlinkat
int symlinkat(const char *__target, int __newdirfd, const char *__linkpath); 

pollution: sysconf
long sysconf(int __name); 

pollution: tcgetpgrp
pid_t tcgetpgrp(int __fd); 

pollution: tcsetpgrp
int tcsetpgrp(int __fd, pid_t __pgrp); 

pollution: truncate
int truncate(const char *__path, off_t __size); 

pollution: ttyname
char *ttyname(int __fd); 

pollution: ttyname_r
int ttyname_r(int __fd, char *__buf, size_t __size); 

pollution: unlink
int unlink(const char *__path); 

pollution: unlinkat
int unlinkat(int __dirfd, const char *__path, int __flags); 

pollution: write
ssize_t write(int __fd, const void *__buffer, size_t __size); 

pollution: optarg
extern char *optarg; 

pollution: optind
extern int optind; 

pollution: opterr
extern int opterr; 

pollution: optopt
extern int optopt; 

pollution: getentropy
int getentropy(void *__buffer, size_t __size); 

pollution: pipe2
int pipe2(int *__pipefd, int __flags); 

pollution: setresuid
int setresuid(uid_t __ruid, uid_t __euid, uid_t __suid); 

pollution: setresgid
int setresgid(gid_t __rgid, gid_t __egid, gid_t __sgid); 

pollution: getresuid
int getresuid(uid_t *__ruid, uid_t *__euid, uid_t *__suid); 

pollution: getresgid
int getresgid(gid_t *__rgid, gid_t *__egid, gid_t *__sgid); 

pollution: ipc64_perm
struct ipc64_perm { key_t __ipc_perm_key; uid_t uid; gid_t gid; uid_t cuid; gid_t cgid; mode_t mode; int __ipc_perm_seq; long __unused[2]; }; 

pollution: ipc64_perm
struct ipc64_perm shm_perm; 

pollution: used_ids
int used_ids; 

pollution: swap_attempts
unsigned long swap_attempts; 

pollution: swap_successes
unsigned long swap_successes; 

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

pollution: tm_zone
const 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 int tm_gmtoff; const char *tm_zone; }; 

pollution: clock
clock_t clock(void); 

pollution: difftime
double difftime(time_t __a, time_t __b); 

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

pollution: time
time_t time(time_t *__timer); 

pollution: timespec
pollution: timespec_get
int timespec_get(struct timespec *__ptr, int __base); 

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

pollution: ctime
char *ctime(const time_t *__timer); 

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

pollution: tm
pollution: tm
pollution: gmtime_r
struct tm *gmtime_r(const time_t *__restrict __timer, struct tm *__restrict __result); 

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

pollution: tm
pollution: strftime
size_t strftime(char *__restrict __dest, size_t __max_size, const char *__restrict __format, const struct tm *__restrict __ptr); 

pollution: tzset
void tzset(void); 

pollution: sival_int
int sival_int; 

pollution: sival_ptr
void *sival_ptr; 

pollution: sigval
union sigval { int sival_int; void *sival_ptr; }; 

pollution: sigval
pollution: sigev_value
union sigval sigev_value; 

pollution: sigev_notify
int sigev_notify; 

pollution: sigev_signo
int sigev_signo; 

pollution: sigval
pollution: sigev_notify_function
void (*sigev_notify_function)(union sigval); 

pollution: sigev_notify_attributes
struct __mlibc_threadattr *sigev_notify_attributes; 

pollution: sigev_notify_thread_id
pid_t sigev_notify_thread_id; 

pollution: sigevent
struct sigevent { union sigval sigev_value; int sigev_notify; int sigev_signo; void (*sigev_notify_function)(union sigval); struct __mlibc_threadattr *sigev_notify_attributes; pid_t sigev_notify_thread_id; }; 

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: timer_getoverrun
int timer_getoverrun(timer_t __timerid); 

pollution: sigevent
pollution: timer_create
int timer_create(clockid_t __clockid, struct sigevent *__restrict __sevp, timer_t *__restrict __timerid); 

pollution: itimerspec
pollution: itimerspec
pollution: timer_settime
int timer_settime(timer_t __timerid, int __flags, const struct itimerspec *__restrict __new_value, struct itimerspec *__restrict __old_value); 

pollution: itimerspec
pollution: timer_gettime
int timer_gettime(timer_t __timerid, struct itimerspec *__curr_value); 

pollution: timer_delete
int timer_delete(timer_t __timerid); 

pollution: tm
pollution: strftime_l
size_t strftime_l(char *__restrict __s, size_t __maxsize, const char *__restrict __format, const struct tm *__restrict __timeptr, locale_t __locale); 

pollution: daylight
extern int daylight; 

pollution: timezone
extern long timezone; 

pollution: tzname
extern char *tzname[2]; 

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

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

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

pollution: timespec
pollution: timespec
pollution: clock_nanosleep
int clock_nanosleep(clockid_t __clockid, int __flags, const struct timespec *__req, struct timespec *__rem); 

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

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

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

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

pollution: CLOCK_THREAD_CPUTIME_ID
#define CLOCK_THREAD_CPUTIME_ID 3

pollution: CLOCK_REALTIME
#define CLOCK_REALTIME 0

pollution: TIME_UTC
#define TIME_UTC 1

pollution: CLOCK_BOOTTIME_ALARM
#define CLOCK_BOOTTIME_ALARM 9

pollution: SEEK_CUR
#define SEEK_CUR 1

pollution: STDERR_FILENO
#define STDERR_FILENO 2

pollution: L_ctermid
#define L_ctermid 20

pollution: F_ULOCK
#define F_ULOCK 4

pollution: F_LOCK
#define F_LOCK 1

pollution: CLOCK_REALTIME_COARSE
#define CLOCK_REALTIME_COARSE 5

pollution: CLOCK_REALTIME_ALARM
#define CLOCK_REALTIME_ALARM 8

pollution: F_OK
#define F_OK 0

pollution: CLOCK_MONOTONIC_RAW
#define CLOCK_MONOTONIC_RAW 4

pollution: F_TEST
#define F_TEST 2

pollution: SEEK_SET
#define SEEK_SET 0

pollution: CLOCK_TAI
#define CLOCK_TAI 11

pollution: W_OK
#define W_OK 2

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

pollution: SEEK_HOLE
#define SEEK_HOLE 4

pollution: TIMER_ABSTIME
#define TIMER_ABSTIME 1

pollution: CLOCK_MONOTONIC
#define CLOCK_MONOTONIC 1

pollution: STDOUT_FILENO
#define STDOUT_FILENO 1

pollution: CLOCK_BOOTTIME
#define CLOCK_BOOTTIME 7

pollution: STDIN_FILENO
#define STDIN_FILENO 0

pollution: CLOCK_PROCESS_CPUTIME_ID
#define CLOCK_PROCESS_CPUTIME_ID 2

pollution: SEEK_END
#define SEEK_END 2

pollution: R_OK
#define R_OK 4

pollution: CLOCKS_PER_SEC
#define CLOCKS_PER_SEC ((clock_t)1000000)

pollution: F_TLOCK
#define F_TLOCK 3

pollution: X_OK
#define X_OK 1

pollution: CLOCK_MONOTONIC_COARSE
#define CLOCK_MONOTONIC_COARSE 6