pollution: u_long
typedef unsigned long u_long; 

pollution: u_int
typedef unsigned int u_int; 

pollution: u_short
typedef unsigned short u_short; 

pollution: u_char
typedef unsigned char u_char; 

pollution: ulong
typedef unsigned long ulong; 

pollution: ushort
typedef unsigned short ushort; 

pollution: uint
typedef unsigned int uint; 

pollution: unchar
typedef unsigned char unchar; 

pollution: flags
__haiku_std_uint32 flags; 

pollution: lock
__haiku_std_int32 lock; 

pollution: unused
__haiku_std_int32 unused; 

pollution: owner
__haiku_std_int32 owner; 

pollution: owner_count
__haiku_std_int32 owner_count; 

pollution: flags
__haiku_std_uint32 flags; 

pollution: lock
__haiku_std_int32 lock; 

pollution: mutex
__haiku_std_int32 mutex; 

pollution: waiter_count
__haiku_std_int32 waiter_count; 

pollution: waiter_max
__haiku_std_int32 waiter_max; 

pollution: flags
__haiku_std_uint32 flags; 

pollution: unused
__haiku_std_int32 unused; 

pollution: mutex
pthread_mutex_t* mutex; 

pollution: waiter_count
__haiku_std_int32 waiter_count; 

pollution: lock
__haiku_std_int32 lock; 

pollution: state
__haiku_std_int32 state; 

pollution: flags
__haiku_std_uint32 flags; 

pollution: owner
__haiku_std_int32 owner; 

pollution: mutex
__haiku_std_int32 mutex; 

pollution: unused
__haiku_std_int32 unused; 

pollution: reader_count
__haiku_std_int32 reader_count; 

pollution: writer_count
__haiku_std_int32 writer_count; 

pollution: waiters
void* waiters[2]; 

pollution: local
struct { __haiku_std_int32 mutex; __haiku_std_int32 unused; __haiku_std_int32 reader_count; __haiku_std_int32 writer_count; void* waiters[2]; } local; 

pollution: sem
__haiku_std_int32 sem; 

pollution: shared
struct { __haiku_std_int32 sem; } shared; 

pollution: u
union { struct { __haiku_std_int32 mutex; __haiku_std_int32 unused; __haiku_std_int32 reader_count; __haiku_std_int32 writer_count; void* waiters[2]; } local; struct { __haiku_std_int32 sem; } shared; } u; 

pollution: lock
__haiku_std_int32 lock; 

pollution: time1
pollution: time2
extern double difftime(time_t time1, time_t time2); 

pollution: timer
extern time_t time(time_t *timer); 

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

pollution: timer
extern char *ctime(const time_t *timer); 

pollution: timer
pollution: buffer
pollution: ctime_r
extern char *ctime_r(const time_t *timer, char *buffer); 

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

pollution: timer
extern struct tm *gmtime_r(const time_t *timer, struct tm *tm); 

pollution: timer
extern struct tm *localtime(const time_t *timer); 

pollution: timer
extern struct tm *localtime_r(const time_t *timer, struct tm *tm); 

pollution: buffer
pollution: maxSize
pollution: format
extern size_t strftime(char *buffer, size_t maxSize, const char *format, const struct tm *tm); 

pollution: buffer
pollution: maxSize
pollution: format
pollution: locale
extern size_t strftime_l(char *buffer, size_t maxSize, const char *format, const struct tm *tm, locale_t locale); 

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

pollution: clockID
pollution: resolution
int clock_getres(clockid_t clockID, struct timespec* resolution); 

pollution: clockID
int clock_gettime(clockid_t clockID, struct timespec* _time); 

pollution: clockID
int clock_settime(clockid_t clockID, const struct timespec* _time); 

pollution: clockID
pollution: flags
pollution: remainingTime
int clock_nanosleep(clockid_t clockID, int flags, const struct timespec* _time, struct timespec* remainingTime); 

pollution: pid
int clock_getcpuclockid(pid_t pid, clockid_t* _clockID); 

pollution: clockID
pollution: event
pollution: timerID
int timer_create(clockid_t clockID, struct sigevent* event, 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: oldValue
int timer_settime(timer_t timerID, int flags, const struct itimerspec* value, struct itimerspec* oldValue); 

pollution: timerID
int timer_getoverrun(timer_t timerID); 

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

pollution: t
pollution: stime
extern int stime(const time_t *t); 

pollution: sys_siglist
extern const char* const sys_siglist[(64 + 1)]; 

pollution: signalHandler
__sighandler_t signal(int _signal, __sighandler_t signalHandler); 

pollution: action
pollution: oldAction
int sigaction(int _signal, const struct sigaction* action, struct sigaction* oldAction); 

pollution: signalHandler
pollution: sigset
__sighandler_t sigset(int _signal, __sighandler_t signalHandler); 

pollution: sigignore
int sigignore(int _signal); 

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

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

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

pollution: sighold
int sighold(int _signal); 

pollution: sigrelse
int sigrelse(int _signal); 

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

pollution: processGroupID
int killpg(pid_t processGroupID, int _signal); 

pollution: pid
pollution: userValue
int sigqueue(pid_t pid, int _signal, const union sigval userValue); 

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

pollution: set
int sigpending(sigset_t* set); 

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

pollution: sigpause
int sigpause(int _signal); 

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

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

pollution: set
pollution: info
pollution: timeout
int sigtimedwait(const sigset_t* set, siginfo_t* info, const struct timespec* timeout); 

pollution: stack
pollution: oldStack
int sigaltstack(const stack_t* stack, stack_t* oldStack); 

pollution: set
int sigemptyset(sigset_t* set); 

pollution: set
int sigfillset(sigset_t* set); 

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

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

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

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

pollution: message
void psignal(int _signal, const char* message); 

pollution: vregs
pollution: vregs
typedef struct vregs vregs; 

pollution: value
unsigned char value[10]; 

pollution: reserved
unsigned char reserved[6]; 

pollution: x86_64_fp_register
struct x86_64_fp_register { unsigned char value[10]; unsigned char reserved[6]; }; 

pollution: value
unsigned char value[16]; 

pollution: x86_64_xmm_register
struct x86_64_xmm_register { unsigned char value[16]; }; 

pollution: control
unsigned short control; 

pollution: status
unsigned short status; 

pollution: tag
unsigned short tag; 

pollution: opcode
unsigned short opcode; 

pollution: rip
unsigned long rip; 

pollution: rdp
unsigned long rdp; 

pollution: mxcsr
unsigned int mxcsr; 

pollution: mxcsr_mask
unsigned int mxcsr_mask; 

pollution: x86_64_fp_register
pollution: fp
struct x86_64_fp_register fp[8]; 

pollution: x86_64_fp_register
pollution: mmx
struct x86_64_fp_register mmx[8]; 

pollution: x86_64_xmm_register
pollution: xmm
struct x86_64_xmm_register xmm[16]; 

pollution: fault_address
unsigned long fault_address; 

pollution: error_code
unsigned long error_code; 

pollution: cs
unsigned short cs; 

pollution: ss
unsigned short ss; 

pollution: trap_number
unsigned char trap_number; 

pollution: fpu_state
struct fpu_state { unsigned short control; unsigned short status; unsigned short tag; unsigned short opcode; unsigned long rip; unsigned long rdp; unsigned int mxcsr; unsigned int mxcsr_mask; union { struct x86_64_fp_register fp[8]; struct x86_64_fp_register mmx[8]; }; struct x86_64_xmm_register xmm[16]; unsigned char _reserved_416_463[48]; unsigned long fault_address; unsigned long error_code; unsigned short cs; unsigned short ss; unsigned char trap_number; unsigned char _available_485_511[27]; }; 

pollution: bv
unsigned long bv; 

pollution: xcomp_bv
unsigned long xcomp_bv; 

pollution: xstate_hdr
struct xstate_hdr { unsigned long bv; unsigned long xcomp_bv; unsigned char _reserved[48]; }; 

pollution: fpu_state
pollution: fp_fxsave
struct fpu_state fp_fxsave; 

pollution: xstate_hdr
pollution: fp_xstate
struct xstate_hdr fp_xstate; 

pollution: x86_64_xmm_register
pollution: fp_ymm
struct x86_64_xmm_register fp_ymm[16]; 

pollution: savefpu
struct savefpu { struct fpu_state fp_fxsave; struct xstate_hdr fp_xstate; struct x86_64_xmm_register fp_ymm[16]; }; 

pollution: rax
unsigned long rax; 

pollution: rbx
unsigned long rbx; 

pollution: rcx
unsigned long rcx; 

pollution: rdx
unsigned long rdx; 

pollution: rdi
unsigned long rdi; 

pollution: rsi
unsigned long rsi; 

pollution: rbp
unsigned long rbp; 

pollution: r8
unsigned long r8; 

pollution: r9
unsigned long r9; 

pollution: r10
unsigned long r10; 

pollution: r11
unsigned long r11; 

pollution: r12
unsigned long r12; 

pollution: r13
unsigned long r13; 

pollution: r14
unsigned long r14; 

pollution: r15
unsigned long r15; 

pollution: rsp
unsigned long rsp; 

pollution: rip
unsigned long rip; 

pollution: rflags
unsigned long rflags; 

pollution: savefpu
pollution: fpu
struct savefpu fpu; 

pollution: vregs
struct vregs { unsigned long rax; unsigned long rbx; unsigned long rcx; unsigned long rdx; unsigned long rdi; unsigned long rsi; unsigned long rbp; unsigned long r8; unsigned long r9; unsigned long r10; unsigned long r11; unsigned long r12; unsigned long r13; unsigned long r14; unsigned long r15; unsigned long rsp; unsigned long rip; unsigned long rflags; struct savefpu fpu; }; 

pollution: vregs
typedef struct vregs mcontext_t; 

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

pollution: source
pollution: value
pollution: length
pollution: memchr
extern void *memchr(const void *source, int value, size_t length); 

pollution: buffer1
pollution: buffer2
pollution: length
pollution: memcmp
extern int memcmp(const void *buffer1, const void *buffer2, size_t length); 

pollution: dest
pollution: source
pollution: length
pollution: memcpy
extern void *memcpy(void *dest, const void *source, size_t length); 

pollution: dest
pollution: source
pollution: stopByte
pollution: length
pollution: memccpy
extern void *memccpy(void *dest, const void *source, int stopByte, size_t length); 

pollution: dest
pollution: source
pollution: length
pollution: memmove
extern void *memmove(void *dest, const void *source, size_t length); 

pollution: dest
pollution: value
pollution: length
pollution: memset
extern void *memset(void *dest, int value, size_t length); 

pollution: source
pollution: sourceLength
pollution: search
pollution: searchLength
pollution: memmem
extern void *memmem(const void *source, size_t sourceLength, const void *search, size_t searchLength); 

pollution: dest
pollution: source
pollution: strcpy
extern char *strcpy(char *dest, const char *source); 

pollution: dest
pollution: source
pollution: length
pollution: strncpy
extern char *strncpy(char *dest, const char *source, size_t length); 

pollution: dest
pollution: source
pollution: strcat
extern char *strcat(char *dest, const char *source); 

pollution: dest
pollution: source
pollution: length
pollution: strncat
extern char *strncat(char *dest, const char *source, size_t length); 

pollution: string
pollution: strlen
extern size_t strlen(const char *string); 

pollution: string1
pollution: string2
pollution: strcmp
extern int strcmp(const char *string1, const char *string2); 

pollution: string1
pollution: string2
pollution: length
pollution: strncmp
extern int strncmp(const char *string1, const char *string2, size_t length); 

pollution: string
pollution: character
pollution: strchr
extern char *strchr(const char *string, int character); 

pollution: string
pollution: character
pollution: strrchr
extern char *strrchr(const char *string, int character); 

pollution: string
pollution: searchString
pollution: strstr
extern char *strstr(const char *string, const char *searchString); 

pollution: string
pollution: set
pollution: strpbrk
extern char *strpbrk(const char *string, const char *set); 

pollution: string
pollution: set
pollution: strtok
extern char *strtok(char *string, const char *set); 

pollution: string
pollution: set
pollution: savePointer
pollution: strtok_r
extern char *strtok_r(char *string, const char *set, char **savePointer); 

pollution: string
pollution: set
pollution: strspn
extern size_t strspn(const char *string, const char *set); 

pollution: string
pollution: set
pollution: strcspn
extern size_t strcspn(const char *string, const char *set); 

pollution: string1
pollution: string2
pollution: strcoll
extern int strcoll(const char *string1, const char *string2); 

pollution: string1
pollution: string2
pollution: length
pollution: strxfrm
extern size_t strxfrm(char *string1, const char *string2, size_t length); 

pollution: errorCode
pollution: strerror
extern char *strerror(int errorCode); 

pollution: errorCode
pollution: buffer
pollution: bufferSize
pollution: strerror_r
extern int strerror_r(int errorCode, char *buffer, size_t bufferSize); 

pollution: string
pollution: searchString
pollution: strcasestr
extern char *strcasestr(const char *string, const char *searchString); 

pollution: string
pollution: strdup
extern char *strdup(const char *string); 

pollution: string
pollution: size
pollution: strndup
extern char *strndup(const char* string, size_t size); 

pollution: dest
pollution: source
pollution: stpcpy
extern char *stpcpy(char *dest, const char *source); 

pollution: dest
pollution: source
pollution: size
pollution: stpncpy
extern char *stpncpy(char *dest, const char *source, size_t size); 

pollution: dest
pollution: source
pollution: length
pollution: strlcat
extern size_t strlcat(char *dest, const char *source, size_t length); 

pollution: dest
pollution: source
pollution: length
pollution: strlcpy
extern size_t strlcpy(char *dest, const char *source, size_t length); 

pollution: string
pollution: count
pollution: strnlen
extern size_t strnlen(const char *string, size_t count); 

pollution: string
pollution: strlwr
extern char *strlwr(char *string); 

pollution: string
pollution: strupr
extern char *strupr(char *string); 

pollution: signum
pollution: strsignal
extern const char *strsignal(int signum); 

pollution: string1
pollution: string2
pollution: locale
pollution: strcoll_l
extern int strcoll_l(const char *string1, const char *string2, locale_t locale); 

pollution: errorCode
pollution: locale
pollution: strerror_l
extern char *strerror_l(int errorCode, locale_t locale); 

pollution: string1
pollution: string2
pollution: length
pollution: locale
pollution: strxfrm_l
extern size_t strxfrm_l(char *string1, const char *string2, size_t length, locale_t locale); 

pollution: i
pollution: ffs
extern int ffs(int i); 

pollution: i
pollution: ffsl
extern int ffsl(long i); 

pollution: i
pollution: ffsll
extern int ffsll(long long i); 

pollution: string1
pollution: string2
pollution: strcasecmp
extern int strcasecmp(const char *string1, const char *string2); 

pollution: string1
pollution: string2
pollution: length
pollution: strncasecmp
extern int strncasecmp(const char *string1, const char *string2, size_t length); 

pollution: string1
pollution: string2
pollution: locale
pollution: strcasecmp_l
extern int strcasecmp_l(const char *string1, const char *string2, locale_t locale); 

pollution: string1
pollution: string2
pollution: length
pollution: locale
pollution: strncasecmp_l
extern int strncasecmp_l(const char *string1, const char *string2, size_t length, locale_t locale); 

pollution: s
pollution: c
pollution: index
extern char *index(const char *s, int c); 

pollution: s
pollution: c
pollution: rindex
extern char *rindex(char const *s, int c); 

pollution: fd_mask
typedef __haiku_uint32 fd_mask; 

pollution: bits
fd_mask bits[((1024) + (((sizeof(fd_mask) * 8)) - 1)) / ((sizeof(fd_mask) * 8))]; 

pollution: fd_set
pollution: fd_set
typedef struct fd_set { fd_mask bits[((1024) + (((sizeof(fd_mask) * 8)) - 1)) / ((sizeof(fd_mask) * 8))]; } fd_set; 

pollution: numBits
pollution: fd_set
pollution: readBits
pollution: fd_set
pollution: writeBits
pollution: fd_set
pollution: errorBits
pollution: timeout
pollution: sigMask
pollution: pselect
extern int pselect(int numBits, struct fd_set *readBits, struct fd_set *writeBits, struct fd_set *errorBits, const struct timespec *timeout, const sigset_t *sigMask); 

pollution: numBits
pollution: fd_set
pollution: readBits
pollution: fd_set
pollution: writeBits
pollution: fd_set
pollution: errorBits
pollution: timeval
pollution: timeout
pollution: select
extern int select(int numBits, struct fd_set *readBits, struct fd_set *writeBits, struct fd_set *errorBits, struct timeval *timeout); 

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: timeval
struct timeval it_interval; 

pollution: timeval
struct timeval it_value; 

pollution: itimerval
struct itimerval { struct timeval it_interval; struct timeval it_value; }; 

pollution: which
pollution: itimerval
pollution: value
pollution: getitimer
extern int getitimer(int which, struct itimerval *value); 

pollution: which
pollution: itimerval
pollution: value
pollution: itimerval
pollution: oldValue
pollution: setitimer
extern int setitimer(int which, const struct itimerval *value, struct itimerval *oldValue); 

pollution: timeval
pollution: tv
pollution: tz
pollution: gettimeofday
extern int gettimeofday(struct timeval *tv, void *tz); 

pollution: path
pollution: timeval
pollution: times
pollution: utimes
extern int utimes(const char *path, const struct timeval times[2]); 

pollution: fds
pollution: numfds
pollution: timeout
extern int poll(struct pollfd *fds, nfds_t numfds, int timeout); 

pollution: fds
pollution: numfds
pollution: timeout
pollution: sigMask
extern int ppoll(struct pollfd *fds, nfds_t numfds, const struct timespec *timeout, const sigset_t *sigMask); 

pollution: FD_COPY
#define FD_COPY(source,target) (*(target) = *(source))

pollution: bzero
#define bzero(buffer,length) memset((buffer), 0, (length))

pollution: B_DEFINE_WEAK_ALIAS
#define B_DEFINE_WEAK_ALIAS(name,alias_name) __typeof(name) alias_name __attribute__((weak, alias(#name)))

pollution: B_HAIKU_64_BIT
#define B_HAIKU_64_BIT 1

pollution: ITIMER_VIRTUAL
#define ITIMER_VIRTUAL 2

pollution: NSIG
#define NSIG (__MAX_SIGNO + 1)

pollution: CLK_TCK
#define CLK_TCK CLOCKS_PER_SEC

pollution: NFDBITS
#define NFDBITS (sizeof(fd_mask) * 8)

pollution: B_HAIKU_PHYSICAL_BITS
#define B_HAIKU_PHYSICAL_BITS __HAIKU_ARCH_PHYSICAL_BITS

pollution: bcopy
#define bcopy(source,dest,length) memmove((dest), (source), (length))

pollution: B_BEOS_VERSION_4_5
#define B_BEOS_VERSION_4_5 0x0450

pollution: B_HAIKU_BITS
#define B_HAIKU_BITS __HAIKU_ARCH_BITS

pollution: B_BEOS_VERSION_5
#define B_BEOS_VERSION_5 0x0500

pollution: B_BEOS_VERSION_MAUI
#define B_BEOS_VERSION_MAUI B_BEOS_VERSION_5

pollution: FD_SET
#define FD_SET(fd,set) ((set)->bits[_FD_BITSINDEX(fd)] |= _FD_BIT(fd))

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

pollution: ITIMER_PROF
#define ITIMER_PROF 3

pollution: B_HAIKU_VERSION_1_PRE_BETA_2
#define B_HAIKU_VERSION_1_PRE_BETA_2 0x00000501

pollution: B_HAIKU_VERSION_1_PRE_BETA_3
#define B_HAIKU_VERSION_1_PRE_BETA_3 0x00000601

pollution: B_HAIKU_VERSION_1_PRE_BETA_4
#define B_HAIKU_VERSION_1_PRE_BETA_4 0x00000701

pollution: B_HAIKU_VERSION_1_PRE_BETA_5
#define B_HAIKU_VERSION_1_PRE_BETA_5 0x00000801

pollution: B_HAIKU_VERSION_1_PRE_BETA_6
#define B_HAIKU_VERSION_1_PRE_BETA_6 0x00000901

pollution: B_HAIKU_VERSION
#define B_HAIKU_VERSION B_HAIKU_VERSION_1_PRE_BETA_6

pollution: timerisset
#define timerisset(a) ((a)->tv_sec != 0 || (a)->tv_usec != 0)

pollution: B_DEFINE_SYMBOL_VERSION
#define B_DEFINE_SYMBOL_VERSION(function,versionedSymbol) __asm__(".symver " function "," versionedSymbol)

pollution: ITIMER_REAL
#define ITIMER_REAL 1

pollution: FD_SETSIZE
#define FD_SETSIZE 1024

pollution: B_HAIKU_ABI_GCC_2
#define B_HAIKU_ABI_GCC_2 0x00020000

pollution: B_HAIKU_ABI_GCC_4
#define B_HAIKU_ABI_GCC_4 0x00040000

pollution: timerclear
#define timerclear(a) ((a)->tv_sec = (a)->tv_usec = 0)

pollution: B_HAIKU_PHYSICAL_64_BIT
#define B_HAIKU_PHYSICAL_64_BIT 1

pollution: FD_ZERO
#define FD_ZERO(set) memset((set), 0, sizeof(fd_set))

pollution: B_HAIKU_VERSION_BEOS
#define B_HAIKU_VERSION_BEOS 0x00000001

pollution: timercmp
#define timercmp(a,b,cmp) ((a)->tv_sec == (b)->tv_sec ? (a)->tv_usec cmp (b)->tv_usec : (a)->tv_sec cmp (b)->tv_sec)

pollution: B_HAIKU_VERSION_DANO
#define B_HAIKU_VERSION_DANO 0x00000003

pollution: B_HAIKU_VERSION_1_PRE_ALPHA_2
#define B_HAIKU_VERSION_1_PRE_ALPHA_2 0x00000101

pollution: B_HAIKU_VERSION_1_PRE_ALPHA_3
#define B_HAIKU_VERSION_1_PRE_ALPHA_3 0x00000201

pollution: B_HAIKU_VERSION_1_PRE_ALPHA_4
#define B_HAIKU_VERSION_1_PRE_ALPHA_4 0x00000301

pollution: B_HAIKU_VERSION_1_PRE_BETA_1
#define B_HAIKU_VERSION_1_PRE_BETA_1 0x00000401

pollution: B_HAIKU_VERSION_1_ALPHA_1
#define B_HAIKU_VERSION_1_ALPHA_1 0x00000100

pollution: B_HAIKU_VERSION_1_ALPHA_2
#define B_HAIKU_VERSION_1_ALPHA_2 0x00000200

pollution: B_HAIKU_VERSION_1_ALPHA_4
#define B_HAIKU_VERSION_1_ALPHA_4 0x00000400

pollution: B_HAIKU_VERSION_1_BETA_1
#define B_HAIKU_VERSION_1_BETA_1 0x00000500

pollution: B_HAIKU_ABI_GCC_2_HAIKU
#define B_HAIKU_ABI_GCC_2_HAIKU 0x00020002

pollution: B_HAIKU_ABI_GCC_2_BEOS
#define B_HAIKU_ABI_GCC_2_BEOS 0x00020001

pollution: bcmp
#define bcmp(a,b,length) memcmp((a), (b), (length))

pollution: B_HAIKU_VERSION_1_ALPHA_3
#define B_HAIKU_VERSION_1_ALPHA_3 0x00000300

pollution: B_HAIKU_ABI
#define B_HAIKU_ABI B_HAIKU_ABI_GCC_4

pollution: MAX_TIMESTR
#define MAX_TIMESTR 70

pollution: B_HAIKU_ABI_GCC_2_ANCIENT
#define B_HAIKU_ABI_GCC_2_ANCIENT 0x00020000

pollution: timeradd
#define timeradd(a,b,res) do { (res)->tv_sec = (a)->tv_sec + (b)->tv_sec; (res)->tv_usec = (a)->tv_usec + (b)->tv_usec; if ((res)->tv_usec >= 1000000) { (res)->tv_usec -= 1000000; (res)->tv_sec++; } } while (0)

pollution: FD_CLR
#define FD_CLR(fd,set) ((set)->bits[_FD_BITSINDEX(fd)] &= ~_FD_BIT(fd))

pollution: timersub
#define timersub(a,b,res) do { (res)->tv_sec = (a)->tv_sec - (b)->tv_sec; (res)->tv_usec = (a)->tv_usec - (b)->tv_usec; if ((res)->tv_usec < 0) { (res)->tv_usec += 1000000; (res)->tv_sec--; } } while (0)

pollution: B_HAIKU_VERSION_1
#define B_HAIKU_VERSION_1 0x00010000

pollution: B_HAIKU_ABI_MAJOR
#define B_HAIKU_ABI_MAJOR 0xffff0000

pollution: B_HAIKU_VERSION_1_BETA_2
#define B_HAIKU_VERSION_1_BETA_2 0x00000600

pollution: B_HAIKU_VERSION_1_BETA_3
#define B_HAIKU_VERSION_1_BETA_3 0x00000700

pollution: B_HAIKU_VERSION_1_BETA_4
#define B_HAIKU_VERSION_1_BETA_4 0x00000800

pollution: B_HAIKU_VERSION_1_BETA_5
#define B_HAIKU_VERSION_1_BETA_5 0x00000900