pollution: FILE
typedef struct _IO_FILE FILE; 

pollution: va_list
typedef __gnuc_va_list va_list; 

pollution: stdin
extern FILE *stdin; 

pollution: stdout
extern FILE *stdout; 

pollution: stderr
extern FILE *stderr; 

pollution: remove
extern int remove (const char *__filename) __attribute__ ((__nothrow__ , __leaf__)); 

pollution: rename
extern int rename (const char *__old, const char *__new) __attribute__ ((__nothrow__ , __leaf__)); 

pollution: renameat
extern int renameat (int __oldfd, const char *__old, int __newfd, const char *__new) __attribute__ ((__nothrow__ , __leaf__)); 

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

pollution: tmpfile
extern FILE *tmpfile (void) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ; 

pollution: tmpnam
extern char *tmpnam (char[20]) __attribute__ ((__nothrow__ , __leaf__)) ; 

pollution: tempnam
extern char *tempnam (const char *__dir, const char *__pfx) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (__builtin_free, 1))); 

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

pollution: fopen
extern FILE *fopen (const char *__restrict __filename, const char *__restrict __modes) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ; 

pollution: freopen
extern FILE *freopen (const char *__restrict __filename, const char *__restrict __modes, FILE *__restrict __stream) ; 

pollution: fdopen
extern FILE *fdopen (int __fd, const char *__modes) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ; 

pollution: fmemopen
extern FILE *fmemopen (void *__s, size_t __len, const char *__modes) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ; 

pollution: open_memstream
extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ; 

pollution: setbuf
extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__)); 

pollution: setvbuf
extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf, int __modes, size_t __n) __attribute__ ((__nothrow__ , __leaf__)); 

pollution: fprintf
extern int fprintf (FILE *__restrict __stream, const char *__restrict __format, ...); 

pollution: printf
extern int printf (const char *__restrict __format, ...); 

pollution: sprintf
extern int sprintf (char *__restrict __s, const char *__restrict __format, ...) __attribute__ ((__nothrow__)); 

pollution: vfprintf
extern int vfprintf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg); 

pollution: vprintf
extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg); 

pollution: vsprintf
extern int vsprintf (char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __attribute__ ((__nothrow__)); 

pollution: snprintf
extern int snprintf (char *__restrict __s, size_t __maxlen, const char *__restrict __format, ...) __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 4))); 

pollution: vsnprintf
extern int vsnprintf (char *__restrict __s, size_t __maxlen, const char *__restrict __format, __gnuc_va_list __arg) __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 0))); 

pollution: vdprintf
extern int vdprintf (int __fd, const char *__restrict __fmt, __gnuc_va_list __arg) __attribute__ ((__format__ (__printf__, 2, 0))); 

pollution: dprintf
extern int dprintf (int __fd, const char *__restrict __fmt, ...) __attribute__ ((__format__ (__printf__, 2, 3))); 

pollution: fscanf
extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) ; 

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

pollution: sscanf
extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) __attribute__ ((__nothrow__ , __leaf__)); 

pollution: fscanf
extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __asm__ ("" "__isoc99_fscanf") ; 

pollution: scanf
extern int scanf (const char *__restrict __format, ...) __asm__ ("" "__isoc99_scanf") ; 

pollution: sscanf
extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) __asm__ ("" "__isoc99_sscanf") __attribute__ ((__nothrow__ , __leaf__)) ; 

pollution: vfscanf
extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __attribute__ ((__format__ (__scanf__, 2, 0))) ; 

pollution: vscanf
extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __attribute__ ((__format__ (__scanf__, 1, 0))) ; 

pollution: vsscanf
extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__format__ (__scanf__, 2, 0))); 

pollution: vfscanf
extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vfscanf") __attribute__ ((__format__ (__scanf__, 2, 0))) ; 

pollution: vscanf
extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vscanf") __attribute__ ((__format__ (__scanf__, 1, 0))) ; 

pollution: vsscanf
extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vsscanf") __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__format__ (__scanf__, 2, 0))); 

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

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

pollution: getchar
extern int getchar (void); 

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

pollution: getchar_unlocked
extern int getchar_unlocked (void); 

pollution: fputc
extern int fputc (int __c, FILE *__stream); 

pollution: putc
extern int putc (int __c, FILE *__stream); 

pollution: putchar
extern int putchar (int __c); 

pollution: putc_unlocked
extern int putc_unlocked (int __c, FILE *__stream); 

pollution: putchar_unlocked
extern int putchar_unlocked (int __c); 

pollution: fgets
extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream) __attribute__ ((__access__ (__write_only__, 1, 2))); 

pollution: getdelim
extern __ssize_t getdelim (char **__restrict __lineptr, size_t *__restrict __n, int __delimiter, FILE *__restrict __stream) ; 

pollution: getline
extern __ssize_t getline (char **__restrict __lineptr, size_t *__restrict __n, FILE *__restrict __stream) ; 

pollution: fputs
extern int fputs (const char *__restrict __s, FILE *__restrict __stream); 

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

pollution: ungetc
extern int ungetc (int __c, FILE *__stream); 

pollution: fread
extern size_t fread (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) ; 

pollution: fwrite
extern size_t fwrite (const void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __s); 

pollution: fseek
extern int fseek (FILE *__stream, long int __off, int __whence); 

pollution: ftell
extern long int ftell (FILE *__stream) ; 

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

pollution: fseeko
extern int fseeko (FILE *__stream, __off_t __off, int __whence); 

pollution: ftello
extern __off_t ftello (FILE *__stream) ; 

pollution: fgetpos
extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos); 

pollution: fsetpos
extern int fsetpos (FILE *__stream, const fpos_t *__pos); 

pollution: clearerr
extern void clearerr (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)); 

pollution: feof
extern int feof (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ; 

pollution: ferror
extern int ferror (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ; 

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

pollution: fileno
extern int fileno (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ; 

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

pollution: popen
extern FILE *popen (const char *__command, const char *__modes) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (pclose, 1))) ; 

pollution: ctermid
extern char *ctermid (char *__s) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__access__ (__write_only__, 1))); 

pollution: flockfile
extern void flockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)); 

pollution: ftrylockfile
extern int ftrylockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ; 

pollution: funlockfile
extern void funlockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)); 

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: 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: 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: stderr
#define stderr stderr

pollution: GDBM_SETCACHESIZE
#define GDBM_SETCACHESIZE 1

pollution: GDBM_XVERIFY
#define GDBM_XVERIFY 0x0800

pollution: GDBM_NOLOCK
#define GDBM_NOLOCK 0x0040

pollution: GDBM_CACHE_AUTO
#define GDBM_CACHE_AUTO 0

pollution: GDBM_GETCENTFREE
#define GDBM_GETCENTFREE 12

pollution: GDBM_CACHESIZE
#define GDBM_CACHESIZE GDBM_SETCACHESIZE

pollution: GDBM_CENTFREE
#define GDBM_CENTFREE GDBM_SETCENTFREE

pollution: GDBM_VERSION_MINOR
#define GDBM_VERSION_MINOR 23

pollution: GDBM_SETMMAP
#define GDBM_SETMMAP 7

pollution: GDBM_RCVR_BACKUP
#define GDBM_RCVR_BACKUP 0x10

pollution: TMP_MAX
#define TMP_MAX 238328

pollution: GDBM_VERSION_MAJOR
#define GDBM_VERSION_MAJOR 1

pollution: GDBM_GETDBFORMAT
#define GDBM_GETDBFORMAT 17

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

pollution: L_tmpnam
#define L_tmpnam 20

pollution: GDBM_SYNC
#define GDBM_SYNC 0x0020

pollution: GDBM_READER
#define GDBM_READER 0

pollution: L_ctermid
#define L_ctermid 9

pollution: GDBM_NUMSYNC
#define GDBM_NUMSYNC 0x2000

pollution: SEEK_CUR
#define SEEK_CUR 1

pollution: GDBM_GETMMAP
#define GDBM_GETMMAP 9

pollution: stdin
#define stdin stdin

pollution: GDBM_RCVR_MAX_FAILURES
#define GDBM_RCVR_MAX_FAILURES 0x08

pollution: GDBM_REPLACE
#define GDBM_REPLACE 1

pollution: GDBM_GETCOALESCEBLKS
#define GDBM_GETCOALESCEBLKS 13

pollution: GDBM_UNKNOWN_UPDATE
#define GDBM_UNKNOWN_UPDATE GDBM_UNKNOWN_ERROR

pollution: GDBM_SETMAXMAPSIZE
#define GDBM_SETMAXMAPSIZE 6

pollution: GDBM_DUMP_FMT_BINARY
#define GDBM_DUMP_FMT_BINARY 0

pollution: GDBM_CLOERROR
#define GDBM_CLOERROR 0x0400

pollution: GDBM_RCVR_FORCE
#define GDBM_RCVR_FORCE 0x20

pollution: GDBM_META_MASK_MODE
#define GDBM_META_MASK_MODE 0x01

pollution: GDBM_INSERT
#define GDBM_INSERT 0

pollution: GDBM_GETFLAGS
#define GDBM_GETFLAGS 8

pollution: GDBM_GETDBNAME
#define GDBM_GETDBNAME 15

pollution: GDBM_CLOEXEC
#define GDBM_CLOEXEC 0x0100

pollution: SEEK_SET
#define SEEK_SET 0

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

pollution: GDBM_SETSYNCMODE
#define GDBM_SETSYNCMODE 3

pollution: GDBM_VERSION_PATCH
#define GDBM_VERSION_PATCH 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 1024

pollution: GDBM_RCVR_MAX_FAILED_BUCKETS
#define GDBM_RCVR_MAX_FAILED_BUCKETS 0x04

pollution: GDBM_FAST
#define GDBM_FAST 0x0010

pollution: BUFSIZ
#define BUFSIZ 8192

pollution: stdout
#define stdout stdout

pollution: EOF
#define EOF (-1)

pollution: GDBM_GETBUCKETSIZE
#define GDBM_GETBUCKETSIZE 19

pollution: GDBM_FASTMODE
#define GDBM_FASTMODE 2

pollution: GDBM_OPENMASK
#define GDBM_OPENMASK 7

pollution: P_tmpdir
#define P_tmpdir "/tmp"

pollution: FOPEN_MAX
#define FOPEN_MAX 16

pollution: GDBM_SETCENTFREE
#define GDBM_SETCENTFREE 4

pollution: GDBM_SETCACHEAUTO
#define GDBM_SETCACHEAUTO 21

pollution: GDBM_NOMMAP
#define GDBM_NOMMAP 0x0080

pollution: GDBM_DUMP_FMT_ASCII
#define GDBM_DUMP_FMT_ASCII 1

pollution: GDBM_SYNCMODE
#define GDBM_SYNCMODE GDBM_SETSYNCMODE

pollution: GDBM_BSEXACT
#define GDBM_BSEXACT 0x0200

pollution: GDBM_SETCOALESCEBLKS
#define GDBM_SETCOALESCEBLKS 5