pollution: u_char
pollution: uchar
typedef unsigned char u_char, uchar; 

pollution: u_short
pollution: ushort
typedef unsigned short u_short, ushort; 

pollution: u_int
pollution: uint
typedef unsigned int u_int, uint; 

pollution: u_long
pollution: ulong
typedef unsigned long u_long, ulong; 

pollution: fd_mask
typedef unsigned long fd_mask; 

pollution: fds_bits
unsigned long fds_bits[1024 / 8 / sizeof(long)]; 

pollution: fd_set
typedef struct { unsigned long fds_bits[1024 / 8 / sizeof(long)]; } fd_set; 

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

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: 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: which
pollution: itimerval
pollution: value
pollution: getitimer
[[deprecated]] int getitimer(int which, struct itimerval *value); 

pollution: timeval
pollution: tp
wrong type: struct: expected external: timezone
pollution: tzp
pollution: gettimeofday
[[deprecated]] int gettimeofday(struct timeval *tp, struct timezone *tzp); 

pollution: which
pollution: itimerval
pollution: value
pollution: itimerval
pollution: ovalue
pollution: setitimer
[[deprecated]] int setitimer(int which, const struct itimerval *value, struct itimerval *ovalue); 

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

pollution: siginfo
typedef struct siginfo siginfo_t; 

pollution: ucontext
typedef struct ucontext ucontext_t; 

pollution: mcontext
typedef struct mcontext mcontext_t; 

pollution: TzName
typedef char *TzName[2]; 

pollution: timeptr
[[deprecated]] char *asctime(const struct tm *timeptr); 

pollution: buf
pollution: asctime_r
[[deprecated]] char *asctime_r(const struct tm *tm, char *buf); 

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

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

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

pollution: buf
pollution: ctime_r
[[deprecated]] char *ctime_r(const time_t *clock, char *buf); 

pollution: time1
pollution: time0
double difftime(time_t time1, time_t time0); 

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

pollution: result
struct tm *gmtime_r(const time_t *clock, struct tm *result); 

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

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

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

pollution: s
pollution: maxsize
pollution: format
pollution: timeptr
size_t strftime(char *s, size_t maxsize, const char *format, const struct tm *timeptr); 

pollution: tloc
time_t time(time_t *tloc); 

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

pollution: timelocal
[[deprecated]] time_t timelocal(struct tm *tm); 

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

pollution: siginfo
struct siginfo { int si_signo; int si_errno; int si_code; pid_t si_pid; uid_t si_uid; void *si_addr; int si_status; union sigval si_value; }; 

wrong type: struct: expected maybe define or function: sigaltstack
struct sigaltstack { void *ss_sp; int ss_flags; size_t ss_size; }; 

wrong type: struct: expected maybe define or function: sigaltstack
typedef struct sigaltstack stack_t; 

pollution: ymm_upper
uint64_t ymm_upper[16][2]; 

pollution: fxsave
uint64_t fxsave[29][2]; 

pollution: r15
uintptr_t r15; 

pollution: r14
uintptr_t r14; 

pollution: r13
uintptr_t r13; 

pollution: r12
uintptr_t r12; 

pollution: rbp
uintptr_t rbp; 

pollution: rbx
uintptr_t rbx; 

pollution: r11
uintptr_t r11; 

pollution: r10
uintptr_t r10; 

pollution: r9
uintptr_t r9; 

pollution: r8
uintptr_t r8; 

pollution: rax
uintptr_t rax; 

pollution: rcx
uintptr_t rcx; 

pollution: rdx
uintptr_t rdx; 

pollution: rsi
uintptr_t rsi; 

pollution: rdi
uintptr_t rdi; 

pollution: rflags
uintptr_t rflags; 

pollution: rip
uintptr_t rip; 

pollution: rsp
uintptr_t rsp; 

pollution: mcontext
struct mcontext { uint64_t ymm_upper[16][2]; uint64_t fxsave[29][2]; uintptr_t r15; uintptr_t r14; uintptr_t r13; uintptr_t r12; uintptr_t rbp; uintptr_t rbx; uintptr_t r11; uintptr_t r10; uintptr_t r9; uintptr_t r8; uintptr_t rax; uintptr_t rcx; uintptr_t rdx; uintptr_t rsi; uintptr_t rdi; uintptr_t rflags; uintptr_t rip; uintptr_t rsp; }; 

pollution: mcontext
typedef struct mcontext mcontext_t; 

pollution: ucontext
struct ucontext { uintptr_t _pad[1] ; ; ucontext_t *uc_link; stack_t uc_stack; sigset_t uc_sigmask; uintptr_t _sival; uint32_t _sigcode; uint32_t _signum; mcontext_t uc_mcontext; }; 

pollution: ucontext
typedef struct ucontext ucontext_t; 

pollution: siginfo
pollution: a
void _cbindgen_export_siginfo(struct siginfo a); 

pollution: jb
pollution: savemask
pollution: sigsetjmp
extern int32_t sigsetjmp(uint64_t *jb, int32_t savemask); 

pollution: jb
pollution: ret
int32_t __sigsetjmp_tail(uint64_t *jb, int32_t ret); 

pollution: jb
pollution: ret
pollution: siglongjmp
void siglongjmp(uint64_t *jb, int32_t ret); 

pollution: sig
int kill(pid_t pid, int sig); 

pollution: sig
pollution: val
int sigqueue(pid_t pid, int sig, union sigval val); 

pollution: pgrp
pollution: sig
int killpg(pid_t pgrp, int sig); 

pollution: thread
pollution: sig
int pthread_kill(pthread_t thread, int sig); 

pollution: how
pollution: set
pollution: oldset
int pthread_sigmask(int how, const sigset_t *set, sigset_t *oldset); 

pollution: sig
int raise(int sig); 

pollution: sig
pollution: act
pollution: oact
int sigaction(int sig, const struct sigaction *act, struct sigaction *oact); 

pollution: set
pollution: signo
int sigaddset(sigset_t *set, int signo); 

pollution: ss
pollution: old_ss
int sigaltstack(const stack_t *ss, stack_t *old_ss); 

pollution: set
pollution: signo
int sigdelset(sigset_t *set, int signo); 

pollution: set
int sigemptyset(sigset_t *set); 

pollution: set
int sigfillset(sigset_t *set); 

pollution: sig
pollution: sighold
int sighold(int sig); 

pollution: sig
pollution: sigignore
int sigignore(int sig); 

pollution: sig
pollution: flag
pollution: siginterrupt
int siginterrupt(int sig, int flag); 

pollution: set
pollution: signo
int sigismember(const sigset_t *set, int signo); 

pollution: sig
pollution: func
void (*signal(int sig, void (*func)(int)))(int); 

pollution: sig
pollution: sigpause
int sigpause(int sig); 

pollution: set
int sigpending(sigset_t *set); 

pollution: how
pollution: set
pollution: oset
int sigprocmask(int how, const sigset_t *set, sigset_t *oset); 

pollution: sig
pollution: sigrelse
int sigrelse(int sig); 

pollution: sig
pollution: func
pollution: sigset
void (*sigset(int sig, void (*func)(int)))(int); 

pollution: sigmask
int sigsuspend(const sigset_t *sigmask); 

pollution: set
pollution: sig
int sigwait(const sigset_t *set, int *sig); 

pollution: set
pollution: siginfo
pollution: sig
pollution: tp
int sigtimedwait(const sigset_t *set, struct siginfo *sig, const struct timespec *tp); 

pollution: set
pollution: sig
int sigwaitinfo(const sigset_t *set, siginfo_t *sig); 

pollution: sig
pollution: prefix
void psignal(int sig, const char *prefix); 

pollution: info
pollution: prefix
void psiginfo(const siginfo_t *info, const char *prefix); 

pollution: a
pollution: b
void __completely_unused_cbindgen_workaround_fn_ucontext_mcontext(const ucontext_t *a, const mcontext_t *b); 

pollution: nfds
pollution: readfds
pollution: writefds
pollution: exceptfds
pollution: timeval
pollution: timeout
pollution: select
int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout); 

pollution: prepare
pollution: parent
pollution: child
pollution: pthread_atfork
extern int pthread_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void)); 

pollution: status
void _exit(int status) __attribute__((__noreturn__)); 

pollution: path
pollution: mode
int access(const char *path, int mode); 

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

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

pollution: path
pollution: owner
pollution: group
int chown(const char *path, uid_t owner, gid_t group); 

pollution: path
pollution: chroot
[[deprecated]] int chroot(const char *path); 

pollution: fildes
int close(int fildes); 

pollution: name
pollution: buf
pollution: len
size_t confstr(int name, char *buf, size_t len); 

pollution: key
pollution: salt
char *crypt(const char *key, const char *salt); 

pollution: nochdir
pollution: noclose
pollution: daemon
int daemon(int nochdir, int noclose); 

pollution: fildes
int dup(int fildes); 

pollution: fildes
pollution: fildes2
int dup2(int fildes, int fildes2); 

pollution: path
pollution: arg0
int execl(const char *path, const char *arg0, ...); 

pollution: path
pollution: arg0
int execle(const char *path, const char *arg0, ...); 

pollution: file
pollution: arg0
int execlp(const char *file, const char *arg0, ...); 

pollution: path
pollution: argv
int execv(const char *path, char *const *argv); 

pollution: path
pollution: argv
pollution: envp
int execve(const char *path, char *const *argv, char *const *envp); 

pollution: file
pollution: argv
int execvp(const char *file, char *const *argv); 

pollution: fildes
int fchdir(int fildes); 

pollution: fildes
pollution: owner
pollution: group
int fchown(int fildes, uid_t owner, gid_t group); 

pollution: fildes
int fdatasync(int fildes); 

pollution: fildes
int fsync(int fildes); 

pollution: fildes
pollution: length
int ftruncate(int fildes, off_t length); 

pollution: buf
pollution: size
char *getcwd(char *buf, size_t size); 

pollution: getdtablesize
[[deprecated]] int getdtablesize(void); 

pollution: size
pollution: list
int getgroups(int size, gid_t *list); 

pollution: name
pollution: len
int gethostname(char *name, size_t len); 

pollution: name
pollution: namesize
int getlogin_r(char *name, size_t namesize); 

pollution: getpagesize
[[deprecated]] int getpagesize(void); 

pollution: rgid
pollution: egid
pollution: sgid
int getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid); 

pollution: ruid
pollution: euid
pollution: suid
int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid); 

pollution: path_name
pollution: getwd
[[deprecated]] char *getwd(char *path_name); 

pollution: fd
int isatty(int fd); 

pollution: path
pollution: owner
pollution: group
int lchown(const char *path, uid_t owner, gid_t group); 

pollution: path1
pollution: path2
int link(const char *path1, const char *path2); 

pollution: fildes
pollution: function
pollution: size
int lockf(int fildes, int function, off_t size); 

pollution: fildes
pollution: offset
pollution: whence
off_t lseek(int fildes, off_t offset, int whence); 

pollution: fildes
int pipe(int *fildes); 

pollution: fildes
pollution: flags
int pipe2(int *fildes, int flags); 

pollution: fildes
pollution: buf
pollution: nbyte
pollution: offset
ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset); 

pollution: fildes
pollution: buf
pollution: nbyte
pollution: offset
ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset); 

pollution: fildes
pollution: buf
pollution: nbyte
ssize_t read(int fildes, const void *buf, size_t nbyte); 

pollution: path
pollution: buf
pollution: bufsize
ssize_t readlink(const char *path, char *buf, size_t bufsize); 

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

pollution: scheme
pollution: set_default_scheme
int set_default_scheme(const char *scheme); 

pollution: gid
int setegid(gid_t gid); 

pollution: uid
int seteuid(uid_t uid); 

pollution: gid
int setgid(gid_t gid); 

pollution: size
pollution: list
pollution: setgroups
int setgroups(size_t size, const gid_t *list); 

pollution: pgid
int setpgid(pid_t pid, pid_t pgid); 

pollution: setpgrp
[[deprecated]] pid_t setpgrp(void); 

pollution: rgid
pollution: egid
int setregid(gid_t rgid, gid_t egid); 

pollution: rgid
pollution: egid
pollution: sgid
int setresgid(gid_t rgid, gid_t egid, gid_t sgid); 

pollution: ruid
pollution: euid
pollution: suid
int setresuid(uid_t ruid, uid_t euid, uid_t suid); 

pollution: ruid
pollution: euid
int setreuid(uid_t ruid, uid_t euid); 

pollution: uid
int setuid(uid_t uid); 

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

pollution: src
pollution: dest
pollution: nbytes
void swab(const void *src, void *dest, ssize_t nbytes); 

pollution: path1
pollution: path2
int symlink(const char *path1, const char *path2); 

pollution: fd
pid_t tcgetpgrp(int fd); 

pollution: fd
pollution: pgrp
int tcsetpgrp(int fd, pid_t pgrp); 

pollution: path
pollution: length
int truncate(const char *path, off_t length); 

pollution: fildes
char *ttyname(int fildes); 

pollution: fildes
pollution: name
pollution: namesize
int ttyname_r(int fildes, char *name, size_t namesize); 

pollution: usecs
pollution: interval
pollution: ualarm
[[deprecated]] useconds_t ualarm(useconds_t usecs, useconds_t interval); 

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

pollution: useconds
pollution: usleep
[[deprecated]] int usleep(useconds_t useconds); 

pollution: fildes
pollution: buf
pollution: nbyte
ssize_t write(int fildes, const void *buf, size_t nbyte); 

pollution: addr
pollution: brk
[[deprecated]] int brk(void *addr); 

pollution: incr
pollution: sbrk
[[deprecated]] void *sbrk(intptr_t incr); 

pollution: argc
pollution: argv
pollution: optstring
int getopt(int argc, char *const *argv, const char *optstring); 

pollution: prompt
pollution: getpass
[[deprecated]] char *getpass(const char *prompt); 

pollution: name
long fpathconf(int _fildes, int name); 

pollution: name
long pathconf(const char *_path, int name); 

pollution: name
long sysconf(int name); 

pollution: ITIMER_VIRTUAL
#define ITIMER_VIRTUAL 1

pollution: NSIG
#define NSIG 32

pollution: PTHREAD_COND_INITIALIZER
#define PTHREAD_COND_INITIALIZER ((pthread_cond_t){0})

pollution: FD_SET
#define FD_SET(d,s) ((s)->fds_bits[(d)/(8*sizeof(long))] |= (1UL<<((d)%(8*sizeof(long)))))

pollution: pthread_cleanup_pop
#define pthread_cleanup_pop(EXECUTE) __relibc_internal_pthread_cleanup_pop((EXECUTE)); } while(0)

pollution: ITIMER_PROF
#define ITIMER_PROF 2

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

pollution: pthread_cleanup_push
#define pthread_cleanup_push(ROUTINE,ARG) do { struct { void (*routine)(void *); void *arg; void *prev; } __relibc_internal_pthread_ll_entry = { .routine = (void (*)(void *))(ROUTINE), .arg = (void *)(ARG), }; __relibc_internal_pthread_cleanup_push(&__relibc_internal_pthread_ll_entry);

pollution: PTHREAD_RWLOCK_INITIALIZER
#define PTHREAD_RWLOCK_INITIALIZER ((pthread_rwlock_t){0})

pollution: ITIMER_REAL
#define ITIMER_REAL 0

pollution: FD_SETSIZE
#define FD_SETSIZE 1024

pollution: timerclear
#define timerclear(t) (void) ( (t)->tv_sec = 0, (t)->tv_usec = 0 )

pollution: timercmp
#define timercmp(x,y,op) ((x)->tv_sec == (y)->tv_sec ? (x)->tv_usec op (y)->tv_usec : (x)->tv_sec op (y)->tv_sec)

pollution: L_cuserid
#define L_cuserid 9

pollution: PTHREAD_ONCE_INIT
#define PTHREAD_ONCE_INIT ((pthread_once_t){0})

pollution: timeradd
#define timeradd(x,y,res) (void) ( (res)->tv_sec = (x)->tv_sec + (y)->tv_sec + (((x)->tv_usec + (y)->tv_usec) / 1000000), (res)->tv_usec = ((x)->tv_usec + (y)->tv_usec) % 1000000 )

pollution: FD_CLR
#define FD_CLR(d,s) ((s)->fds_bits[(d)/(8*sizeof(long))] &= ~(1UL<<((d)%(8*sizeof(long)))))

pollution: timersub
#define timersub(x,y,res) (void) ( (res)->tv_sec = (x)->tv_sec - (y)->tv_sec, (res)->tv_usec = ((x)->tv_usec - (y)->tv_usec), ((res)->tv_usec < 0) && ((res)->tv_sec -= 1, (res)->tv_usec += 1000000) )