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: cbindgen_stupid_alias_timespec
void cbindgen_stupid_alias_timespec(struct timespec); 

pollution: cbindgen_stupid_struct_user_for_sched_param
void cbindgen_stupid_struct_user_for_sched_param(struct sched_param); 

pollution: TzName
typedef char *TzName[2]; 

pollution: daylight
extern int daylight; 

pollution: timezone
extern long timezone; 

pollution: getdate_err
extern int getdate_err; 

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: res
int clock_getres(clockid_t clock_id, struct timespec *res); 

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: evp
pollution: timerid
int timer_create(clockid_t clock_id, struct sigevent *evp, timer_t *timerid); 

pollution: timerid
int timer_delete(timer_t timerid); 

pollution: timerid
pollution: value
int timer_gettime(timer_t timerid, struct itimerspec *value); 

pollution: timerid
pollution: flags
pollution: value
pollution: ovalue
int timer_settime(timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue); 

pollution: tp
pollution: base
int timespec_get(struct timespec *tp, int base); 

pollution: res
pollution: base
pollution: timespec_getres
int timespec_getres(struct timespec *res, int base); 

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

pollution: value
pollution: Dtor
typedef void (*Dtor)(void *value); 

pollution: thread
int pthread_cancel(pthread_t thread); 

pollution: pthread
pollution: attr
pollution: arg
pollution: start_routine
pollution: arg
int pthread_create(pthread_t *pthread, const pthread_attr_t *attr, void *(*start_routine)(void *arg), void *arg); 

pollution: pthread
int pthread_detach(pthread_t pthread); 

pollution: pthread1
pollution: pthread2
int pthread_equal(pthread_t pthread1, pthread_t pthread2); 

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

pollution: retval
void pthread_exit(void *retval) __attribute__((__noreturn__)); 

pollution: thread
int pthread_getcpuclockid(pthread_t thread, clockid_t *clock_out); 

pollution: thread
pollution: policy_out
pollution: param_out
int pthread_getschedparam(pthread_t thread, int *policy_out, struct sched_param *param_out); 

pollution: thread
pollution: retval
int pthread_join(pthread_t thread, void **retval); 

pollution: state
pollution: oldstate
int pthread_setcancelstate(int state, int *oldstate); 

pollution: ty
pollution: oldty
int pthread_setcanceltype(int ty, int *oldty); 

pollution: concurrency
int pthread_setconcurrency(int concurrency); 

pollution: thread
pollution: policy
pollution: param
int pthread_setschedparam(pthread_t thread, int policy, const struct sched_param *param); 

pollution: thread
pollution: prio
int pthread_setschedprio(pthread_t thread, int prio); 

pollution: new_entry
void __relibc_internal_pthread_cleanup_push(void *new_entry); 

pollution: execute
void __relibc_internal_pthread_cleanup_pop(int execute); 

pollution: attr
int pthread_attr_destroy(pthread_attr_t *attr); 

pollution: attr
pollution: detachstate
int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate); 

pollution: attr
pollution: size
int pthread_attr_getguardsize(const pthread_attr_t *attr, size_t *size); 

pollution: attr
pollution: inheritsched
int pthread_attr_getinheritsched(const pthread_attr_t *attr, int *inheritsched); 

pollution: attr
pollution: param
int pthread_attr_getschedparam(const pthread_attr_t *attr, struct sched_param *param); 

pollution: attr
pollution: policy
int pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy); 

pollution: attr
pollution: scope
int pthread_attr_getscope(const pthread_attr_t *attr, int *scope); 

pollution: attr
pollution: stackaddr
pollution: stacksize
int pthread_attr_getstack(const pthread_attr_t *attr, void **stackaddr, size_t *stacksize); 

pollution: attr
pollution: stacksize
int pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize); 

pollution: attr
int pthread_attr_init(pthread_attr_t *attr); 

pollution: attr
pollution: detachstate
int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate); 

pollution: attr
pollution: guardsize
int pthread_attr_setguardsize(pthread_attr_t *attr, int guardsize); 

pollution: attr
pollution: inheritsched
int pthread_attr_setinheritsched(pthread_attr_t *attr, int inheritsched); 

pollution: attr
pollution: param
int pthread_attr_setschedparam(pthread_attr_t *attr, const struct sched_param *param); 

pollution: attr
pollution: policy
int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy); 

pollution: attr
pollution: scope
int pthread_attr_setscope(pthread_attr_t *attr, int scope); 

pollution: attr
pollution: stackaddr
pollution: stacksize
int pthread_attr_setstack(pthread_attr_t *attr, void *stackaddr, size_t stacksize); 

pollution: attr
pollution: stacksize
int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize); 

pollution: thread_ptr
pollution: attr_ptr
int pthread_getattr_np(pthread_t thread_ptr, pthread_attr_t *attr_ptr); 

pollution: barrier
int pthread_barrier_destroy(pthread_barrier_t *barrier); 

pollution: barrier
pollution: attr
pollution: count
int pthread_barrier_init(pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count); 

pollution: barrier
int pthread_barrier_wait(pthread_barrier_t *barrier); 

pollution: attr
int pthread_barrierattr_init(pthread_barrierattr_t *attr); 

pollution: attr
pollution: pshared
int pthread_barrierattr_setpshared(pthread_barrierattr_t *attr, int pshared); 

pollution: attr
pollution: pshared
int pthread_barrierattr_getpshared(const pthread_barrierattr_t *attr, int *pshared); 

pollution: attr
int pthread_barrierattr_destroy(pthread_barrierattr_t *attr); 

pollution: cond
int pthread_cond_broadcast(pthread_cond_t *cond); 

pollution: cond
int pthread_cond_destroy(pthread_cond_t *cond); 

pollution: cond
pollution: attr
int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr); 

pollution: cond
int pthread_cond_signal(pthread_cond_t *cond); 

pollution: cond
pollution: mutex
pollution: timeout
int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *timeout); 

pollution: cond
pollution: mutex
pollution: timeout
int pthread_cond_clockwait(pthread_cond_t *cond, pthread_mutex_t *mutex, clockid_t clock_id, const struct timespec *timeout); 

pollution: cond
pollution: mutex
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex); 

pollution: condattr
int pthread_condattr_destroy(pthread_condattr_t *condattr); 

pollution: condattr
int pthread_condattr_getclock(const pthread_condattr_t *condattr, clockid_t *clock); 

pollution: condattr
pollution: pshared
int pthread_condattr_getpshared(const pthread_condattr_t *condattr, int *pshared); 

pollution: condattr
int pthread_condattr_init(pthread_condattr_t *condattr); 

pollution: condattr
int pthread_condattr_setclock(pthread_condattr_t *condattr, clockid_t clock); 

pollution: condattr
pollution: pshared
int pthread_condattr_setpshared(pthread_condattr_t *condattr, int pshared); 

pollution: key
void *pthread_getspecific(pthread_key_t key); 

pollution: key
pollution: value
int pthread_setspecific(pthread_key_t key, const void *value); 

pollution: key_ptr
pollution: destructor
int pthread_key_create(pthread_key_t *key_ptr, Dtor destructor); 

pollution: key
int pthread_key_delete(pthread_key_t key); 

pollution: mutex
int pthread_mutex_consistent(pthread_mutex_t *mutex); 

pollution: mutex
int pthread_mutex_destroy(pthread_mutex_t *mutex); 

pollution: mutex
pollution: prioceiling
int pthread_mutex_getprioceiling(const pthread_mutex_t *mutex, int *prioceiling); 

pollution: mutex
pollution: attr
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr); 

pollution: mutex
int pthread_mutex_lock(pthread_mutex_t *mutex); 

pollution: mutex
pollution: prioceiling
pollution: old_prioceiling
int pthread_mutex_setprioceiling(pthread_mutex_t *mutex, int prioceiling, int *old_prioceiling); 

pollution: mutex
pollution: abstime
int pthread_mutex_timedlock(pthread_mutex_t *mutex, const struct timespec *abstime); 

pollution: mutex
int pthread_mutex_trylock(pthread_mutex_t *mutex); 

pollution: mutex
int pthread_mutex_unlock(pthread_mutex_t *mutex); 

pollution: attr
int pthread_mutexattr_destroy(pthread_mutexattr_t *attr); 

pollution: attr
pollution: prioceiling
int pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *attr, int *prioceiling); 

pollution: attr
pollution: protocol
int pthread_mutexattr_getprotocol(const pthread_mutexattr_t *attr, int *protocol); 

pollution: attr
pollution: pshared
int pthread_mutexattr_getpshared(const pthread_mutexattr_t *attr, int *pshared); 

pollution: attr
pollution: robust
int pthread_mutexattr_getrobust(const pthread_mutexattr_t *attr, int *robust); 

pollution: attr
pollution: ty
int pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *ty); 

pollution: attr
int pthread_mutexattr_init(pthread_mutexattr_t *attr); 

pollution: attr
pollution: prioceiling
int pthread_mutexattr_setprioceiling(pthread_mutexattr_t *attr, int prioceiling); 

pollution: attr
pollution: protocol
int pthread_mutexattr_setprotocol(pthread_mutexattr_t *attr, int protocol); 

pollution: attr
pollution: pshared
int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int pshared); 

pollution: attr
pollution: robust
int pthread_mutexattr_setrobust(pthread_mutexattr_t *attr, int robust); 

pollution: attr
pollution: ty
int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int ty); 

pollution: once
pollution: constructor
int pthread_once(pthread_once_t *once, void (*constructor)(void)); 

pollution: rwlock
pollution: attr
int pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr); 

pollution: rwlock
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock); 

pollution: rwlock
pollution: abstime
int pthread_rwlock_clockrdlock(pthread_rwlock_t *rwlock, clockid_t clock_id, const struct timespec *abstime); 

pollution: rwlock
pollution: abstime
int pthread_rwlock_timedrdlock(pthread_rwlock_t *rwlock, const struct timespec *abstime); 

pollution: rwlock
pollution: abstime
int pthread_rwlock_clockwrlock(pthread_rwlock_t *rwlock, clockid_t clock_id, const struct timespec *abstime); 

pollution: rwlock
pollution: abstime
int pthread_rwlock_timedwrlock(pthread_rwlock_t *rwlock, const struct timespec *abstime); 

pollution: rwlock
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock); 

pollution: rwlock
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock); 

pollution: rwlock
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock); 

pollution: rwlock
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock); 

pollution: attr
int pthread_rwlockattr_init(pthread_rwlockattr_t *attr); 

pollution: attr
pollution: pshared_out
int pthread_rwlockattr_getpshared(const pthread_rwlockattr_t *attr, int *pshared_out); 

pollution: attr
pollution: pshared
int pthread_rwlockattr_setpshared(pthread_rwlockattr_t *attr, int pshared); 

pollution: attr
int pthread_rwlockattr_destroy(pthread_rwlockattr_t *attr); 

pollution: rwlock
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock); 

pollution: spinlock
int pthread_spin_destroy(pthread_spinlock_t *spinlock); 

pollution: spinlock
int pthread_spin_init(pthread_spinlock_t *spinlock, int _pshared); 

pollution: spinlock
int pthread_spin_lock(pthread_spinlock_t *spinlock); 

pollution: spinlock
int pthread_spin_trylock(pthread_spinlock_t *spinlock); 

pollution: spinlock
int pthread_spin_unlock(pthread_spinlock_t *spinlock); 

pollution: INT_LEAST16_MIN
#define INT_LEAST16_MIN (-INT_LEAST16_MAX - 1)

pollution: INT16_C
#define INT16_C(c) __INT16_C(c)

pollution: INT8_MAX
#define INT8_MAX __INT8_MAX__

pollution: UINT_LEAST64_MAX
#define UINT_LEAST64_MAX __UINT_LEAST64_MAX__

pollution: INT16_MAX
#define INT16_MAX __INT16_MAX__

pollution: INT8_MIN
#define INT8_MIN (-INT8_MAX - 1)

pollution: INT16_MIN
#define INT16_MIN (-INT16_MAX - 1)

pollution: INT_FAST8_MAX
#define INT_FAST8_MAX __INT_FAST8_MAX__

pollution: WCHAR_MAX
#define WCHAR_MAX __WCHAR_MAX__

pollution: INT_LEAST8_MAX
#define INT_LEAST8_MAX __INT_LEAST8_MAX__

pollution: INT_FAST8_MIN
#define INT_FAST8_MIN (-INT_FAST8_MAX - 1)

pollution: WCHAR_MIN
#define WCHAR_MIN __WCHAR_MIN__

pollution: UINT16_C
#define UINT16_C(c) __UINT16_C(c)

pollution: INT32_MIN
#define INT32_MIN (-INT32_MAX - 1)

pollution: INT64_C
#define INT64_C(c) __INT64_C(c)

pollution: UINT_LEAST8_MAX
#define UINT_LEAST8_MAX __UINT_LEAST8_MAX__

pollution: offsetof
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)

pollution: INT_FAST16_MIN
#define INT_FAST16_MIN (-INT_FAST16_MAX - 1)

pollution: PTRDIFF_MIN
#define PTRDIFF_MIN (-PTRDIFF_MAX - 1)

pollution: SIZE_MAX
#define SIZE_MAX __SIZE_MAX__

pollution: UINT64_C
#define UINT64_C(c) __UINT64_C(c)

pollution: WINT_MAX
#define WINT_MAX __WINT_MAX__

pollution: UINTPTR_MAX
#define UINTPTR_MAX __UINTPTR_MAX__

pollution: UINT_LEAST16_MAX
#define UINT_LEAST16_MAX __UINT_LEAST16_MAX__

pollution: INT64_MAX
#define INT64_MAX __INT64_MAX__

pollution: UINT32_MAX
#define UINT32_MAX __UINT32_MAX__

pollution: WINT_MIN
#define WINT_MIN __WINT_MIN__

pollution: INT_LEAST32_MAX
#define INT_LEAST32_MAX __INT_LEAST32_MAX__

pollution: INT_LEAST8_MIN
#define INT_LEAST8_MIN (-INT_LEAST8_MAX - 1)

pollution: INT_LEAST32_MIN
#define INT_LEAST32_MIN (-INT_LEAST32_MAX - 1)

pollution: UINT64_MAX
#define UINT64_MAX __UINT64_MAX__

pollution: INTPTR_MAX
#define INTPTR_MAX __INTPTR_MAX__

pollution: INT_LEAST64_MAX
#define INT_LEAST64_MAX __INT_LEAST64_MAX__

pollution: INTPTR_MIN
#define INTPTR_MIN (-INTPTR_MAX - 1)

pollution: INT8_C
#define INT8_C(c) __INT8_C(c)

pollution: UINT_FAST32_MAX
#define UINT_FAST32_MAX __UINT_FAST32_MAX__

pollution: INT_LEAST64_MIN
#define INT_LEAST64_MIN (-INT_LEAST64_MAX - 1)

pollution: UINTMAX_MAX
#define UINTMAX_MAX __UINTMAX_MAX__

pollution: INT32_C
#define INT32_C(c) __INT32_C(c)

pollution: INT_FAST16_MAX
#define INT_FAST16_MAX __INT_FAST16_MAX__

pollution: INT_FAST32_MAX
#define INT_FAST32_MAX __INT_FAST32_MAX__

pollution: UINT_FAST8_MAX
#define UINT_FAST8_MAX __UINT_FAST8_MAX__

pollution: UINT8_MAX
#define UINT8_MAX __UINT8_MAX__

pollution: UINT32_C
#define UINT32_C(c) __UINT32_C(c)

pollution: UINT_FAST64_MAX
#define UINT_FAST64_MAX __UINT_FAST64_MAX__

pollution: INT_FAST32_MIN
#define INT_FAST32_MIN (-INT_FAST32_MAX - 1)

pollution: INTMAX_MAX
#define INTMAX_MAX __INTMAX_MAX__

pollution: INTMAX_MIN
#define INTMAX_MIN (-INTMAX_MAX - 1)

pollution: INT_FAST64_MAX
#define INT_FAST64_MAX __INT_FAST64_MAX__

pollution: UINT_LEAST32_MAX
#define UINT_LEAST32_MAX __UINT_LEAST32_MAX__

pollution: UINTMAX_C
#define UINTMAX_C(c) __UINTMAX_C(c)

pollution: INTMAX_C
#define INTMAX_C(c) __INTMAX_C(c)

pollution: INT_FAST64_MIN
#define INT_FAST64_MIN (-INT_FAST64_MAX - 1)

pollution: UINT16_MAX
#define UINT16_MAX __UINT16_MAX__

pollution: PTRDIFF_MAX
#define PTRDIFF_MAX __PTRDIFF_MAX__

pollution: INT_LEAST16_MAX
#define INT_LEAST16_MAX __INT_LEAST16_MAX__

pollution: INT64_MIN
#define INT64_MIN (-INT64_MAX - 1)

