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: sigevent
struct sigevent; 

pollution: tv_sec
time_t tv_sec; 

pollution: tv_nsec
long tv_nsec; 

pollution: timespec
struct timespec { time_t tv_sec; long tv_nsec; }; 

pollution: timespec
pollution: it_interval
struct timespec it_interval; 

pollution: timespec
pollution: it_value
struct timespec it_value; 

pollution: itimerspec
struct itimerspec { struct timespec it_interval; struct timespec it_value; }; 

pollution: tm_sec
int tm_sec; 

pollution: tm_min
int tm_min; 

pollution: tm_hour
int tm_hour; 

pollution: tm_mday
int tm_mday; 

pollution: tm_mon
int tm_mon; 

pollution: tm_year
int tm_year; 

pollution: tm_wday
int tm_wday; 

pollution: tm_yday
int tm_yday; 

pollution: tm_isdst
int tm_isdst; 

pollution: tm_gmtoff
int tm_gmtoff; 

pollution: tm_zone
char *tm_zone; 

pollution: tm
struct tm { int tm_sec; int tm_min; int tm_hour; int tm_mday; int tm_mon; int tm_year; int tm_wday; int tm_yday; int tm_isdst; int tm_gmtoff; char *tm_zone; }; 

pollution: tzname
extern char *tzname[2]; 

pollution: daylight
extern int daylight; 

pollution: timezone
extern long timezone; 

pollution: clock
extern clock_t clock(void); 

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

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

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

pollution: tm
pollution: tm
pollution: asctime
extern char *asctime(const struct tm *tm); 

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

pollution: timer
pollution: ctime
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: tm
pollution: timer
pollution: gmtime
extern struct tm *gmtime(const time_t *timer); 

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

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

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

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

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

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

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

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

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

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

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

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

pollution: clockID
pollution: sigevent
pollution: event
pollution: timerID
pollution: timer_create
int timer_create(clockid_t clockID, struct sigevent* event, timer_t* timerID); 

pollution: timerID
pollution: timer_delete
int timer_delete(timer_t timerID); 

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

pollution: timerID
pollution: flags
pollution: itimerspec
pollution: value
pollution: itimerspec
pollution: oldValue
pollution: timer_settime
int timer_settime(timer_t timerID, int flags, const struct itimerspec* value, struct itimerspec* oldValue); 

pollution: timerID
pollution: timer_getoverrun
int timer_getoverrun(timer_t timerID); 

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

pollution: tzset
extern void tzset(void); 

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

pollution: va_list
typedef __gnuc_va_list va_list; 

pollution: FILE
typedef struct _IO_FILE FILE; 

pollution: stdin
extern FILE *stdin; 

pollution: stdout
extern FILE *stdout; 

pollution: stderr
extern FILE *stderr; 

pollution: name
pollution: mode
pollution: fopen
extern FILE *fopen(const char *name, const char *mode); 

pollution: name
pollution: mode
pollution: stream
pollution: freopen
extern FILE *freopen(const char *name, const char *mode, FILE *stream); 

pollution: fd
pollution: mode
pollution: fdopen
extern FILE *fdopen(int fd, const char *mode); 

pollution: stream
pollution: fclose
extern int fclose(FILE *stream); 

pollution: stream
pollution: fileno
extern int fileno(FILE *stream); 

pollution: stream
pollution: fileno_unlocked
extern int fileno_unlocked(FILE *stream); 

pollution: stream
pollution: ferror
extern int ferror(FILE *stream); 

pollution: stream
pollution: ferror_unlocked
extern int ferror_unlocked(FILE *stream); 

pollution: stream
pollution: clearerr
extern void clearerr(FILE *stream); 

pollution: stream
pollution: clearerr_unlocked
extern void clearerr_unlocked(FILE *stream); 

pollution: stream
pollution: feof
extern int feof(FILE *stream); 

pollution: stream
pollution: feof_unlocked
extern int feof_unlocked(FILE *stream); 

pollution: stream
pollution: flockfile
extern void flockfile(FILE *stream); 

pollution: stream
pollution: funlockfile
extern void funlockfile(FILE *stream); 

pollution: stream
pollution: ftrylockfile
extern int ftrylockfile(FILE *stream); 

pollution: name
pollution: remove
extern int remove(const char *name); 

pollution: from
pollution: to
pollution: rename
extern int rename(const char *from, const char *to); 

pollution: fromFD
pollution: from
pollution: toFD
pollution: to
pollution: renameat
extern int renameat(int fromFD, const char *from, int toFD, const char *to); 

pollution: command
pollution: mode
pollution: popen
extern FILE *popen(const char *command, const char *mode); 

pollution: stream
pollution: pclose
extern int pclose(FILE *stream); 

pollution: errorPrefix
pollution: perror
extern void perror(const char *errorPrefix); 

pollution: buf
pollution: size
pollution: mode
pollution: fmemopen
extern FILE *fmemopen(void *buf, size_t size, const char *mode); 

pollution: buf
pollution: size
pollution: open_memstream
extern FILE *open_memstream(char **buf, size_t *size); 

pollution: stream
pollution: fflush
extern int fflush(FILE *stream); 

pollution: stream
pollution: fflush_unlocked
extern int fflush_unlocked(FILE *stream); 

pollution: stream
pollution: position
pollution: fgetpos
extern int fgetpos(FILE *stream, fpos_t *position); 

pollution: stream
pollution: position
pollution: fsetpos
extern int fsetpos(FILE *stream, const fpos_t *position); 

pollution: stream
pollution: offset
pollution: seekType
pollution: fseek
extern int fseek(FILE *stream, long offset, int seekType); 

pollution: stream
pollution: offset
pollution: seekType
pollution: fseeko
extern int fseeko(FILE *stream, off_t offset, int seekType); 

pollution: stream
pollution: offset
pollution: seekType
extern int _fseek(FILE *stream, fpos_t offset, int seekType); 

pollution: stream
pollution: ftell
extern long ftell(FILE *stream); 

pollution: stream
pollution: ftello
extern off_t ftello(FILE *stream); 

pollution: stream
extern fpos_t _ftell(FILE *stream); 

pollution: stream
pollution: rewind
extern void rewind(FILE *stream); 

pollution: file
pollution: buff
pollution: setbuf
extern void setbuf (FILE *file, char *buff); 

pollution: file
pollution: buff
pollution: mode
pollution: size
pollution: setvbuf
extern int setvbuf(FILE *file, char *buff, int mode, size_t size); 

pollution: stream
pollution: buf
pollution: size
pollution: setbuffer
extern int setbuffer(FILE *stream, char *buf, size_t size); 

pollution: stream
pollution: setlinebuf
extern int setlinebuf(FILE *stream); 

pollution: buffer
pollution: size
pollution: numItems
pollution: stream
pollution: fwrite
extern size_t fwrite(const void *buffer, size_t size, size_t numItems, FILE *stream); 

pollution: buffer
pollution: size
pollution: numItems
pollution: stream
pollution: fwrite_unlocked
extern size_t fwrite_unlocked(const void *buffer, size_t size, size_t numItems, FILE *stream); 

pollution: buffer
pollution: size
pollution: numItems
pollution: stream
pollution: fread
extern size_t fread(void *buffer, size_t size, size_t numItems, FILE *stream); 

pollution: buffer
pollution: size
pollution: numItems
pollution: stream
pollution: fread_unlocked
extern size_t fread_unlocked(void *buffer, size_t size, size_t numItems, FILE *stream); 

pollution: c
pollution: stream
pollution: putc
extern int putc(int c, FILE *stream); 

pollution: c
pollution: putchar
extern int putchar(int c); 

pollution: c
pollution: stream
pollution: putc_unlocked
extern int putc_unlocked(int c, FILE *stream); 

pollution: c
pollution: putchar_unlocked
extern int putchar_unlocked(int c); 

pollution: c
pollution: stream
pollution: fputc
extern int fputc(int c, FILE *stream); 

pollution: c
pollution: stream
pollution: fputc_unlocked
extern int fputc_unlocked(int c, FILE *stream); 

pollution: string
pollution: puts
extern int puts(const char *string); 

pollution: string
pollution: stream
pollution: fputs
extern int fputs(const char *string, FILE *stream); 

pollution: string
pollution: stream
pollution: fputs_unlocked
extern int fputs_unlocked(const char *string, FILE *stream); 

pollution: stream
pollution: getc
extern int getc(FILE *stream); 

pollution: stream
pollution: getc_unlocked
extern int getc_unlocked(FILE *stream); 

pollution: c
pollution: stream
pollution: ungetc
extern int ungetc(int c, FILE *stream); 

pollution: getchar
extern int getchar(void); 

pollution: getchar_unlocked
extern int getchar_unlocked(void); 

pollution: stream
pollution: fgetc
extern int fgetc(FILE *stream); 

pollution: stream
pollution: fgetc_unlocked
extern int fgetc_unlocked(FILE *stream); 

pollution: buffer
pollution: gets
extern char *gets(char *buffer); 

pollution: string
pollution: stringLength
pollution: stream
pollution: fgets
extern char *fgets(char *string, int stringLength, FILE *stream); 

pollution: string
pollution: stringLength
pollution: stream
pollution: fgets_unlocked
extern char *fgets_unlocked(char *string, int stringLength, FILE *stream); 

pollution: delimiter
pollution: stream
pollution: getdelim
extern ssize_t getdelim(char **_line, size_t *_length, int delimiter, FILE *stream); 

pollution: stream
pollution: getline
extern ssize_t getline(char **_line, size_t *_length, FILE *stream); 

pollution: ret
pollution: format
pollution: asprintf
extern int asprintf(char **ret, char const *format, ...) __attribute__((format(__printf__, 2, 3))); 

pollution: format
pollution: printf
extern int printf(char const *format, ...) __attribute__((format(__printf__, 1, 2))); 

pollution: fd
pollution: format
pollution: dprintf
extern int dprintf(int fd, char const *format, ...) __attribute__((format(__printf__, 2, 3))); 

pollution: stream
pollution: format
pollution: fprintf
extern int fprintf(FILE *stream, char const *format, ...) __attribute__((format(__printf__, 2, 3))); 

pollution: string
pollution: format
pollution: sprintf
extern int sprintf(char *string, char const *format, ...) __attribute__((format(__printf__, 2, 3))); 

pollution: string
pollution: size
pollution: format
pollution: snprintf
extern int snprintf(char *string, size_t size, char const *format, ...) __attribute__((format(__printf__, 3, 4))); 

pollution: ret
pollution: format
pollution: ap
pollution: vasprintf
extern int vasprintf(char **ret, char const *format, va_list ap); 

pollution: format
pollution: ap
pollution: vprintf
extern int vprintf(char const *format, va_list ap); 

pollution: stream
pollution: format
pollution: ap
pollution: vfprintf
extern int vfprintf(FILE *stream, char const *format, va_list ap); 

pollution: string
pollution: format
pollution: ap
pollution: vsprintf
extern int vsprintf(char *string, char const *format, va_list ap); 

pollution: string
pollution: size
pollution: format
pollution: ap
pollution: vsnprintf
extern int vsnprintf(char *string, size_t size, char const *format, va_list ap); 

pollution: format
pollution: scanf
extern int scanf(char const *format, ...); 

pollution: stream
pollution: format
pollution: fscanf
extern int fscanf(FILE *stream, char const *format, ...); 

pollution: str
pollution: format
pollution: sscanf
extern int sscanf(char const *str, char const *format, ...); 

pollution: format
pollution: ap
pollution: vscanf
extern int vscanf(char const *format, va_list ap); 

pollution: str
pollution: format
pollution: ap
pollution: vsscanf
extern int vsscanf(char const *str, char const *format, va_list ap); 

pollution: stream
pollution: format
pollution: ap
pollution: vfscanf
extern int vfscanf(FILE *stream, char const *format, va_list ap); 

pollution: controllingTerminal
pollution: ctermid
extern char *ctermid(char *controllingTerminal); 

pollution: s
pollution: cuserid
extern char *cuserid(char *s); 

pollution: path
pollution: prefix
pollution: tempnam
extern char *tempnam(char const *path, char const *prefix); 

pollution: tmpfile
extern FILE *tmpfile(void); 

pollution: nameBuffer
pollution: tmpnam
extern char *tmpnam(char *nameBuffer); 

pollution: nameBuffer
pollution: tmpnam_r
extern char *tmpnam_r(char *nameBuffer); 

pollution: gdbm_file_info
pollution: GDBM_FILE
typedef struct gdbm_file_info *GDBM_FILE; 

pollution: gdbm_version
extern const char *gdbm_version; 

pollution: gdbm_version_number
extern int const gdbm_version_number[3]; 

pollution: GDBM_LOCKWAIT_NONE
pollution: GDBM_LOCKWAIT_RETRY
pollution: GDBM_LOCKWAIT_SIGNAL
pollution: fd
int fd; 

pollution: mode
int mode; 

pollution: block_size
int block_size; 

pollution: lock_wait
int lock_wait; 

pollution: timespec
pollution: lock_timeout
struct timespec lock_timeout; 

pollution: timespec
pollution: lock_interval
struct timespec lock_interval; 

pollution: fatal_func
void (*fatal_func) (const char *); 

pollution: gdbm_open_spec
struct gdbm_open_spec { int fd; int mode; int block_size; int lock_wait; struct timespec lock_timeout; struct timespec lock_interval; void (*fatal_func) (const char *); }; 

pollution: gdbm_open_spec
pollution: spec
pollution: gdbm_open_spec_init
extern void gdbm_open_spec_init (struct gdbm_open_spec *spec); 

pollution: file_name
pollution: flags
pollution: gdbm_open_spec
pollution: op
pollution: gdbm_open_ext
extern GDBM_FILE gdbm_open_ext (char const *file_name, int flags, struct gdbm_open_spec const *op); 

pollution: fd
pollution: file_name
pollution: block_size
pollution: flags
pollution: fatal_func
pollution: gdbm_fd_open
extern GDBM_FILE gdbm_fd_open (int fd, const char *file_name, int block_size, int flags, void (*fatal_func) (const char *)); 

pollution: gdbm_open
extern GDBM_FILE gdbm_open (const char *, int, int, int, void (*)(const char *)); 

pollution: gdbm_close
extern int gdbm_close (GDBM_FILE); 

pollution: gdbm_store
extern int gdbm_store (GDBM_FILE, datum, datum, int); 

pollution: gdbm_fetch
extern datum gdbm_fetch (GDBM_FILE, datum); 

pollution: gdbm_delete
extern int gdbm_delete (GDBM_FILE, datum); 

pollution: gdbm_firstkey
extern datum gdbm_firstkey (GDBM_FILE); 

pollution: gdbm_nextkey
extern datum gdbm_nextkey (GDBM_FILE, datum); 

pollution: gdbm_reorganize
extern int gdbm_reorganize (GDBM_FILE); 

pollution: gdbm_sync
extern int gdbm_sync (GDBM_FILE); 

pollution: gdbm_failure_atomic
extern int gdbm_failure_atomic (GDBM_FILE, const char *, const char *); 

pollution: dbf
pollution: flag
pollution: gdbm_convert
extern int gdbm_convert (GDBM_FILE dbf, int flag); 

pollution: GDBM_SNAPSHOT_OK
pollution: GDBM_SNAPSHOT_BAD
pollution: GDBM_SNAPSHOT_ERR
pollution: GDBM_SNAPSHOT_SAME
pollution: GDBM_SNAPSHOT_SUSPICIOUS
pollution: gdbm_latest_snapshot_status
enum gdbm_latest_snapshot_status { GDBM_SNAPSHOT_OK, GDBM_SNAPSHOT_BAD, GDBM_SNAPSHOT_ERR, GDBM_SNAPSHOT_SAME, GDBM_SNAPSHOT_SUSPICIOUS }; 

pollution: gdbm_latest_snapshot
extern int gdbm_latest_snapshot (const char *, const char *, const char **); 

pollution: gdbm_exists
extern int gdbm_exists (GDBM_FILE, datum); 

pollution: gdbm_setopt
extern int gdbm_setopt (GDBM_FILE, int, void *, int); 

pollution: gdbm_fdesc
extern int gdbm_fdesc (GDBM_FILE); 

pollution: gdbm_export
extern int gdbm_export (GDBM_FILE, const char *, int, int); 

pollution: dbf
pollution: fp
pollution: gdbm_export_to_file
extern int gdbm_export_to_file (GDBM_FILE dbf, FILE *fp); 

pollution: gdbm_import
extern int gdbm_import (GDBM_FILE, const char *, int); 

pollution: dbf
pollution: fp
pollution: flag
pollution: gdbm_import_from_file
extern int gdbm_import_from_file (GDBM_FILE dbf, FILE *fp, int flag); 

pollution: dbf
pollution: pcount
pollution: gdbm_count
extern int gdbm_count (GDBM_FILE dbf, gdbm_count_t *pcount); 

pollution: dbf
pollution: pcount
pollution: gdbm_bucket_count
extern int gdbm_bucket_count (GDBM_FILE dbf, size_t *pcount); 

pollution: dbf
pollution: gdbm_avail_verify
extern int gdbm_avail_verify (GDBM_FILE dbf); 

pollution: data
pollution: fmt
pollution: errfun
void (*errfun) (void *data, char const *fmt, ...); 

pollution: data
void *data; 

pollution: max_failed_keys
size_t max_failed_keys; 

pollution: max_failed_buckets
size_t max_failed_buckets; 

pollution: max_failures
size_t max_failures; 

pollution: recovered_keys
size_t recovered_keys; 

pollution: recovered_buckets
size_t recovered_buckets; 

pollution: failed_keys
size_t failed_keys; 

pollution: failed_buckets
size_t failed_buckets; 

pollution: duplicate_keys
size_t duplicate_keys; 

pollution: backup_name
char *backup_name; 

pollution: gdbm_recovery_s
pollution: gdbm_recovery
typedef struct gdbm_recovery_s { void (*errfun) (void *data, char const *fmt, ...); void *data; size_t max_failed_keys; size_t max_failed_buckets; size_t max_failures; size_t recovered_keys; size_t recovered_buckets; size_t failed_keys; size_t failed_buckets; size_t duplicate_keys; char *backup_name; } gdbm_recovery; 

pollution: dbf
pollution: rcvr
pollution: flags
pollution: gdbm_recover
extern int gdbm_recover (GDBM_FILE dbf, gdbm_recovery *rcvr, int flags); 

pollution: fmt
pollution: open_flags
pollution: mode
pollution: gdbm_dump
extern int gdbm_dump (GDBM_FILE, const char *, int fmt, int open_flags, int mode); 

pollution: fmt
pollution: gdbm_dump_to_file
extern int gdbm_dump_to_file (GDBM_FILE, FILE *, int fmt); 

pollution: replace
pollution: meta_flags
pollution: line
pollution: gdbm_load
extern int gdbm_load (GDBM_FILE *, const char *, int replace, int meta_flags, unsigned long *line); 

pollution: replace
pollution: meta_flags
pollution: line
pollution: gdbm_load_from_file
extern int gdbm_load_from_file (GDBM_FILE *, FILE *, int replace, int meta_flags, unsigned long *line); 

pollution: pdbf
pollution: fp
pollution: mode
pollution: replace
pollution: meta_mask
pollution: line
pollution: gdbm_load_from_file_ext
extern int gdbm_load_from_file_ext (GDBM_FILE *pdbf, FILE *fp, int mode, int replace, int meta_mask, unsigned long *line); 

pollution: dst
pollution: src
pollution: gdbm_copy_meta
extern int gdbm_copy_meta (GDBM_FILE dst, GDBM_FILE src); 

pollution: GDBM_NO_ERROR
pollution: GDBM_MALLOC_ERROR
pollution: GDBM_BLOCK_SIZE_ERROR
pollution: GDBM_FILE_OPEN_ERROR
pollution: GDBM_FILE_WRITE_ERROR
pollution: GDBM_FILE_SEEK_ERROR
pollution: GDBM_FILE_READ_ERROR
pollution: GDBM_BAD_MAGIC_NUMBER
pollution: GDBM_EMPTY_DATABASE
pollution: GDBM_CANT_BE_READER
pollution: GDBM_CANT_BE_WRITER
pollution: GDBM_READER_CANT_DELETE
pollution: GDBM_READER_CANT_STORE
pollution: GDBM_READER_CANT_REORGANIZE
pollution: GDBM_UNKNOWN_ERROR
pollution: GDBM_ITEM_NOT_FOUND
pollution: GDBM_REORGANIZE_FAILED
pollution: GDBM_CANNOT_REPLACE
pollution: GDBM_MALFORMED_DATA
pollution: GDBM_ILLEGAL_DATA
pollution: GDBM_OPT_ALREADY_SET
pollution: GDBM_OPT_BADVAL
pollution: GDBM_OPT_ILLEGAL
pollution: GDBM_BYTE_SWAPPED
pollution: GDBM_BAD_FILE_OFFSET
pollution: GDBM_BAD_OPEN_FLAGS
pollution: GDBM_FILE_STAT_ERROR
pollution: GDBM_FILE_EOF
pollution: GDBM_NO_DBNAME
pollution: GDBM_ERR_FILE_OWNER
pollution: GDBM_ERR_FILE_MODE
pollution: GDBM_NEED_RECOVERY
pollution: GDBM_BACKUP_FAILED
pollution: GDBM_DIR_OVERFLOW
pollution: GDBM_BAD_BUCKET
pollution: GDBM_BAD_HEADER
pollution: GDBM_BAD_AVAIL
pollution: GDBM_BAD_HASH_TABLE
pollution: GDBM_BAD_DIR_ENTRY
pollution: GDBM_FILE_CLOSE_ERROR
pollution: GDBM_FILE_SYNC_ERROR
pollution: GDBM_FILE_TRUNCATE_ERROR
pollution: GDBM_BUCKET_CACHE_CORRUPTED
pollution: GDBM_BAD_HASH_ENTRY
pollution: GDBM_ERR_SNAPSHOT_CLONE
pollution: GDBM_ERR_REALPATH
pollution: GDBM_ERR_USAGE
pollution: gdbm_error
typedef int gdbm_error; 

pollution: gdbm_errno_location
extern int *gdbm_errno_location (void); 

pollution: gdbm_errlist
extern const char * const gdbm_errlist[]; 

pollution: gdbm_syserr
extern int const gdbm_syserr[]; 

pollution: dbf
pollution: gdbm_last_errno
extern gdbm_error gdbm_last_errno (GDBM_FILE dbf); 

pollution: dbf
pollution: gdbm_last_syserr
extern int gdbm_last_syserr (GDBM_FILE dbf); 

pollution: dbf
pollution: ec
pollution: fatal
pollution: gdbm_set_errno
extern void gdbm_set_errno (GDBM_FILE dbf, gdbm_error ec, int fatal); 

pollution: dbf
pollution: gdbm_clear_error
extern void gdbm_clear_error (GDBM_FILE dbf); 

pollution: dbf
pollution: gdbm_needs_recovery
extern int gdbm_needs_recovery (GDBM_FILE dbf); 

pollution: n
pollution: gdbm_check_syserr
extern int gdbm_check_syserr (gdbm_error n); 

pollution: gdbm_strerror
extern const char *gdbm_strerror (gdbm_error); 

pollution: dbf
pollution: gdbm_db_strerror
extern const char *gdbm_db_strerror (GDBM_FILE dbf); 

pollution: a
pollution: b
pollution: gdbm_version_cmp
extern int gdbm_version_cmp (int const a[], int const b[]); 

pollution: adr
off_t adr; 

pollution: hits
size_t hits; 

pollution: gdbm_cache_stat
struct gdbm_cache_stat { off_t adr; size_t hits; }; 

pollution: dbf
pollution: access_count
pollution: cache_hits
pollution: cache_count
pollution: gdbm_cache_stat
pollution: bstat
pollution: nstat
pollution: gdbm_get_cache_stats
void gdbm_get_cache_stats (GDBM_FILE dbf, size_t *access_count, size_t *cache_hits, size_t *cache_count, struct gdbm_cache_stat *bstat, size_t nstat); 

pollution: file
GDBM_FILE file; 

pollution: dirfd
int dirfd; 

pollution: file
pollution: flags
pollution: mode
extern DBM *dbm_open (char *file, int flags, int mode); 

pollution: dbf
extern void dbm_close (DBM *dbf); 

pollution: dbf
pollution: key
extern datum dbm_fetch (DBM *dbf, datum key); 

pollution: dbf
pollution: key
pollution: content
pollution: flags
extern int dbm_store (DBM *dbf, datum key, datum content, int flags); 

pollution: dbf
pollution: key
extern int dbm_delete (DBM *dbf, datum key); 

pollution: dbf
extern datum dbm_firstkey (DBM *dbf); 

pollution: dbf
extern datum dbm_nextkey (DBM *dbf); 

pollution: dbf
extern int dbm_error (DBM *dbf); 

pollution: dbf
extern void dbm_clearerr (DBM *dbf); 

pollution: dbf
extern int dbm_dirfno (DBM *dbf); 

pollution: dbf
extern int dbm_pagfno (DBM *dbf); 

pollution: dbf
extern int dbm_rdonly (DBM *dbf); 

pollution: GDBM_GETSYNCMODE
#define GDBM_GETSYNCMODE 11

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

pollution: TIME_UTC
#define TIME_UTC 1

pollution: B_HAIKU_64_BIT
#define B_HAIKU_64_BIT 1

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

pollution: CLK_TCK
#define CLK_TCK CLOCKS_PER_SEC

pollution: GDBM_NOLOCK
#define GDBM_NOLOCK 0x0040

pollution: GDBM_CACHE_AUTO
#define GDBM_CACHE_AUTO 0

pollution: B_HAIKU_PHYSICAL_BITS
#define B_HAIKU_PHYSICAL_BITS __HAIKU_ARCH_PHYSICAL_BITS

pollution: NULL
#define NULL ((void *)0)

pollution: CLOCK_THREAD_CPUTIME_ID
#define CLOCK_THREAD_CPUTIME_ID ((clockid_t)-3)

pollution: getc
#define getc(stream) (_single_threaded ? getc_unlocked(stream) : getc(stream))

pollution: GDBM_FAST
#define GDBM_FAST 0x0010

pollution: GDBM_OPEN_SPEC_INITIALIZER
#define GDBM_OPEN_SPEC_INITIALIZER { .fd = -1, .mode = 0600, .lock_wait = GDBM_LOCKWAIT_NONE }

pollution: B_BEOS_VERSION_4_5
#define B_BEOS_VERSION_4_5 0x0450

pollution: GDBM_CENTFREE
#define GDBM_CENTFREE GDBM_SETCENTFREE

pollution: GDBM_VERSION_MINOR
#define GDBM_VERSION_MINOR 26

pollution: B_HAIKU_BITS
#define B_HAIKU_BITS __HAIKU_ARCH_BITS

pollution: CLOCK_REALTIME
#define CLOCK_REALTIME ((clockid_t)-1)

pollution: GDBM_SETMMAP
#define GDBM_SETMMAP 7

pollution: GDBM_PREREAD
#define GDBM_PREREAD 0x1000

pollution: GDBM_RCVR_BACKUP
#define GDBM_RCVR_BACKUP 0x10

pollution: GDBM_GETCENTFREE
#define GDBM_GETCENTFREE 12

pollution: TMP_MAX
#define TMP_MAX 32768

pollution: GDBM_VERSION_MAJOR
#define GDBM_VERSION_MAJOR 1

pollution: B_BEOS_VERSION_4
#define B_BEOS_VERSION_4 0x0400

pollution: B_BEOS_VERSION_5
#define B_BEOS_VERSION_5 0x0500

pollution: GDBM_WRITER
#define GDBM_WRITER 1

pollution: gdbm_errno
#define gdbm_errno (*gdbm_errno_location ())

pollution: GDBM_META_MASK_OWNER
#define GDBM_META_MASK_OWNER 0x02

pollution: GDBM_WRCREAT
#define GDBM_WRCREAT 2

pollution: B_BEOS_VERSION_MAUI
#define B_BEOS_VERSION_MAUI B_BEOS_VERSION_5

pollution: L_tmpnam
#define L_tmpnam 512

pollution: GDBM_SYNC
#define GDBM_SYNC 0x0020

pollution: GDBM_READER
#define GDBM_READER 0

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

pollution: GDBM_NUMSYNC
#define GDBM_NUMSYNC 0x2000

pollution: SEEK_CUR
#define SEEK_CUR 1

pollution: L_ctermid
#define L_ctermid 32

pollution: GDBM_RCVR_MAX_FAILURES
#define GDBM_RCVR_MAX_FAILURES 0x08

pollution: GDBM_GETBLOCKSIZE
#define GDBM_GETBLOCKSIZE 16

pollution: GDBM_REPLACE
#define GDBM_REPLACE 1

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: GDBM_SETMAXMAPSIZE
#define GDBM_SETMAXMAPSIZE 6

pollution: STREAM_MAX
#define STREAM_MAX FOPEN_MAX

pollution: B_HAIKU_ABI_NAME
#define B_HAIKU_ABI_NAME __HAIKU_ARCH_ABI

pollution: GDBM_DUMP_FMT_BINARY
#define GDBM_DUMP_FMT_BINARY 0

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

pollution: GDBM_DUMP_FMT_ASCII
#define GDBM_DUMP_FMT_ASCII 1

pollution: GDBM_CLOERROR
#define GDBM_CLOERROR 0x0400

pollution: GDBM_RCVR_FORCE
#define GDBM_RCVR_FORCE 0x20

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: B_HAIKU_PHYSICAL_64_BIT
#define B_HAIKU_PHYSICAL_64_BIT 1

pollution: B_HAIKU_VERSION_BEOS
#define B_HAIKU_VERSION_BEOS 0x00000001

pollution: GDBM_INSERT
#define GDBM_INSERT 0

pollution: GDBM_GETFLAGS
#define GDBM_GETFLAGS 8

pollution: GDBM_GETDBNAME
#define GDBM_GETDBNAME 15

pollution: GDBM_NEWDB
#define GDBM_NEWDB 3

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: GDBM_RCVR_DEFAULT
#define GDBM_RCVR_DEFAULT 0x00

pollution: SEEK_SET
#define SEEK_SET 0

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: GDBM_RCVR_ERRFUN
#define GDBM_RCVR_ERRFUN 0x01

pollution: va_copy
#define va_copy(d,s) __builtin_va_copy(d,s)

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: TIMER_ABSTIME
#define TIMER_ABSTIME 1

pollution: GDBM_GETCOALESCEBLKS
#define GDBM_GETCOALESCEBLKS 13

pollution: GDBM_VERSION_PATCH
#define GDBM_VERSION_PATCH 0

pollution: CLOCK_MONOTONIC
#define CLOCK_MONOTONIC ((clockid_t)0)

pollution: GDBM_COALESCEBLKS
#define GDBM_COALESCEBLKS GDBM_SETCOALESCEBLKS

pollution: GDBM_GETDIRDEPTH
#define GDBM_GETDIRDEPTH 18

pollution: GDBM_GETCACHESIZE
#define GDBM_GETCACHESIZE 10

pollution: FILENAME_MAX
#define FILENAME_MAX 256

pollution: L_cuserid
#define L_cuserid 32

pollution: GDBM_RCVR_MAX_FAILED_BUCKETS
#define GDBM_RCVR_MAX_FAILED_BUCKETS 0x04

pollution: putc
#define putc(c,stream) (_single_threaded ? putc_unlocked(c, stream) : putc(c, stream))

pollution: BUFSIZ
#define BUFSIZ 8192

pollution: CLOCK_PROCESS_CPUTIME_ID
#define CLOCK_PROCESS_CPUTIME_ID ((clockid_t)-2)

pollution: B_HAIKU_ABI_GCC_2_BEOS
#define B_HAIKU_ABI_GCC_2_BEOS 0x00020001

pollution: GDBM_RCVR_MAX_FAILED_KEYS
#define GDBM_RCVR_MAX_FAILED_KEYS 0x02

pollution: EOF
#define EOF (-1)

pollution: GDBM_GETBUCKETSIZE
#define GDBM_GETBUCKETSIZE 19

pollution: GDBM_XVERIFY
#define GDBM_XVERIFY 0x0800

pollution: GDBM_OPENMASK
#define GDBM_OPENMASK 7

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

pollution: P_tmpdir
#define P_tmpdir "/tmp/"

pollution: B_HAIKU_VERSION_1_ALPHA_3
#define B_HAIKU_VERSION_1_ALPHA_3 0x00000300

pollution: CLOCKS_PER_SEC
#define CLOCKS_PER_SEC 1000000

pollution: B_HAIKU_ABI
#define B_HAIKU_ABI B_HAIKU_ABI_GCC_4

pollution: FOPEN_MAX
#define FOPEN_MAX 128

pollution: MAX_TIMESTR
#define MAX_TIMESTR 70

pollution: GDBM_SETCENTFREE
#define GDBM_SETCENTFREE 4

pollution: GDBM_SETCACHEAUTO
#define GDBM_SETCACHEAUTO 21

pollution: GDBM_NOMMAP
#define GDBM_NOMMAP 0x0080

pollution: GDBM_SETCACHESIZE
#define GDBM_SETCACHESIZE 1

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

pollution: B_HAIKU_ABI_GCC_2_ANCIENT
#define B_HAIKU_ABI_GCC_2_ANCIENT 0x00020000

pollution: B_HAIKU_ABI_MAJOR
#define B_HAIKU_ABI_MAJOR 0xffff0000

pollution: GDBM_GETMAXMAPSIZE
#define GDBM_GETMAXMAPSIZE 14

pollution: GDBM_SYNCMODE
#define GDBM_SYNCMODE GDBM_SETSYNCMODE

pollution: GDBM_BSEXACT
#define GDBM_BSEXACT 0x0200

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

pollution: GDBM_SETCOALESCEBLKS
#define GDBM_SETCOALESCEBLKS 5

pollution: GDBM_GETCACHEAUTO
#define GDBM_GETCACHEAUTO 20