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: path
pollution: mode
int creat(const char *path, mode_t mode); 

pollution: fildes
pollution: cmd
int fcntl(int fildes, int cmd, ...); 

pollution: path
pollution: oflag
int open(const char *path, int oflag, ...); 

pollution: a
pollution: cbindgen_stupid_struct_user_for_fcntl
void cbindgen_stupid_struct_user_for_fcntl(struct flock a); 

pollution: va_start
#define va_start(v,l) __builtin_va_start(v,l)

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_MUTEX_INITIALIZER
#define PTHREAD_MUTEX_INITIALIZER ((pthread_mutex_t){0})

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: FD_ZERO
#define FD_ZERO(s) do { int __i; unsigned long *__b=(s)->fds_bits; for(__i=sizeof (fd_set)/sizeof (long); __i; __i--) *__b++=0; } while(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: va_copy
#define va_copy(d,s) __builtin_va_copy(d,s)

pollution: va_arg
#define va_arg(v,l) __builtin_va_arg(v,l)

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

pollution: va_end
#define va_end(v) __builtin_va_end(v)

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

pollution: AT_EMPTY_PATH
#define AT_EMPTY_PATH 16384