pollution: pthread
struct pthread; 

pollution: pthread_attr
struct pthread_attr; 

pollution: pthread_cond
struct pthread_cond; 

pollution: pthread_cond_attr
struct pthread_cond_attr; 

pollution: pthread_mutex
struct pthread_mutex; 

pollution: pthread_mutex_attr
struct pthread_mutex_attr; 

pollution: pthread_once
struct pthread_once; 

pollution: pthread_rwlock
struct pthread_rwlock; 

pollution: pthread_rwlockattr
struct pthread_rwlockattr; 

pollution: pthread_barrier
struct pthread_barrier; 

pollution: pthread_barrier_attr
struct pthread_barrier_attr; 

pollution: pthread_spinlock
struct pthread_spinlock; 

pollution: pthread
typedef struct pthread *pthread_t; 

pollution: pthread_attr
typedef struct pthread_attr *pthread_attr_t; 

pollution: pthread_mutex
typedef struct pthread_mutex *pthread_mutex_t; 

pollution: pthread_mutex_attr
typedef struct pthread_mutex_attr *pthread_mutexattr_t; 

pollution: pthread_cond
typedef struct pthread_cond *pthread_cond_t; 

pollution: pthread_cond_attr
typedef struct pthread_cond_attr *pthread_condattr_t; 

pollution: pthread_once
typedef struct pthread_once pthread_once_t; 

pollution: pthread_rwlock
typedef struct pthread_rwlock *pthread_rwlock_t; 

pollution: pthread_rwlockattr
typedef struct pthread_rwlockattr *pthread_rwlockattr_t; 

pollution: pthread_barrier
typedef struct pthread_barrier *pthread_barrier_t; 

pollution: pthread_barrierattr
typedef struct pthread_barrierattr *pthread_barrierattr_t; 

pollution: pthread_spinlock
typedef struct pthread_spinlock *pthread_spinlock_t; 

pollution: state
int state; 

pollution: mutex
pthread_mutex_t mutex; 

pollution: pthread_once
struct pthread_once { int state; pthread_mutex_t mutex; }; 

pollution: cap_rights
struct cap_rights; 

pollution: cap_rights
typedef struct cap_rights cap_rights_t; 

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: itimerval
struct itimerval { struct timeval it_interval; struct timeval it_value; }; 

pollution: hz
int hz; 

pollution: tick
int tick; 

pollution: spare
int spare; 

pollution: stathz
int stathz; 

pollution: profhz
int profhz; 

pollution: clockinfo
struct clockinfo { int hz; int tick; int spare; int stathz; int profhz; }; 

pollution: asctime_r
char *asctime_r(const struct tm *, char *); 

pollution: ctime_r
char *ctime_r(const time_t *, char *); 

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

pollution: itimerval
pollution: itimerval
pollution: setitimer
int setitimer(int, const struct itimerval *, struct itimerval *); 

pollution: itimerval
pollution: getitimer
int getitimer(int, struct itimerval *); 

wrong type: struct: expected external: timezone
pollution: gettimeofday
int gettimeofday(struct timeval *, struct timezone *); 

pollution: BIG_ENDIAN
#define BIG_ENDIAN _BIG_ENDIAN

pollution: BYTE_ORDER
#define BYTE_ORDER _BYTE_ORDER

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

pollution: ITIMER_REAL
#define ITIMER_REAL 0

pollution: ITIMER_VIRTUAL
#define ITIMER_VIRTUAL 1

pollution: LITTLE_ENDIAN
#define LITTLE_ENDIAN _LITTLE_ENDIAN

pollution: PDP_ENDIAN
#define PDP_ENDIAN _PDP_ENDIAN

pollution: be16toh
#define be16toh(x) __bswap16((x))

pollution: be32toh
#define be32toh(x) __bswap32((x))

pollution: be64toh
#define be64toh(x) __bswap64((x))

pollution: htobe16
#define htobe16(x) __bswap16((x))

pollution: htobe32
#define htobe32(x) __bswap32((x))

pollution: htobe64
#define htobe64(x) __bswap64((x))

pollution: htole16
#define htole16(x) ((uint16_t)(x))

pollution: htole32
#define htole32(x) ((uint32_t)(x))

pollution: htole64
#define htole64(x) ((uint64_t)(x))

pollution: le16toh
#define le16toh(x) ((uint16_t)(x))

pollution: le32toh
#define le32toh(x) ((uint32_t)(x))

pollution: le64toh
#define le64toh(x) ((uint64_t)(x))

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: 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(tvp) ((tvp)->tv_sec = (tvp)->tv_nsec = 0)

pollution: timespeccmp
#define timespeccmp(tvp,uvp,cmp) (((tvp)->tv_sec == (uvp)->tv_sec) ? ((tvp)->tv_nsec cmp (uvp)->tv_nsec) : ((tvp)->tv_sec cmp (uvp)->tv_sec))

pollution: timespecisset
#define timespecisset(tvp) ((tvp)->tv_sec || (tvp)->tv_nsec)

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)

pollution: timespecvalid_interval
#define timespecvalid_interval(tsp) ((tsp)->tv_sec >= 0 && (tsp)->tv_nsec >= 0 && (tsp)->tv_nsec < 1000000000L)