pollution: isalnum
int isalnum(int); 

pollution: isalpha
int isalpha(int); 

pollution: iscntrl
int iscntrl(int); 

pollution: isdigit
int isdigit(int); 

pollution: isgraph
int isgraph(int); 

pollution: islower
int islower(int); 

pollution: isprint
int isprint(int); 

pollution: ispunct
int ispunct(int); 

pollution: isspace
int isspace(int); 

pollution: isupper
int isupper(int); 

pollution: isxdigit
int isxdigit(int); 

pollution: tolower
int tolower(int); 

pollution: toupper
int toupper(int); 

pollution: isblank
int isblank(int); 

pollution: isalnum_l
inline int isalnum_l(int, locale_t); 

pollution: isalnum_l
inline int isalnum_l(int __c, locale_t __l) { return __sbistype_l(__c, 0x00000100L|0x00000400L|0x00400000L, __l); }

pollution: isalpha_l
inline int isalpha_l(int, locale_t); 

pollution: isalpha_l
inline int isalpha_l(int __c, locale_t __l) { return __sbistype_l(__c, 0x00000100L, __l); }

pollution: isblank_l
inline int isblank_l(int, locale_t); 

pollution: isblank_l
inline int isblank_l(int __c, locale_t __l) { return __sbistype_l(__c, 0x00020000L, __l); }

pollution: iscntrl_l
inline int iscntrl_l(int, locale_t); 

pollution: iscntrl_l
inline int iscntrl_l(int __c, locale_t __l) { return __sbistype_l(__c, 0x00000200L, __l); }

pollution: isdigit_l
inline int isdigit_l(int, locale_t); 

pollution: isdigit_l
inline int isdigit_l(int __c, locale_t __l) { return __sbistype_l(__c, 0x00000400L, __l); }

pollution: isgraph_l
inline int isgraph_l(int, locale_t); 

pollution: isgraph_l
inline int isgraph_l(int __c, locale_t __l) { return __sbistype_l(__c, 0x00000800L, __l); }

pollution: ishexnumber_l
inline int ishexnumber_l(int, locale_t); 

pollution: ishexnumber_l
inline int ishexnumber_l(int __c, locale_t __l) { return __sbistype_l(__c, 0x00010000L, __l); }

pollution: isideogram_l
inline int isideogram_l(int, locale_t); 

pollution: isideogram_l
inline int isideogram_l(int __c, locale_t __l) { return __sbistype_l(__c, 0x00080000L, __l); }

pollution: islower_l
inline int islower_l(int, locale_t); 

pollution: islower_l
inline int islower_l(int __c, locale_t __l) { return __sbistype_l(__c, 0x00001000L, __l); }

pollution: isnumber_l
inline int isnumber_l(int, locale_t); 

pollution: isnumber_l
inline int isnumber_l(int __c, locale_t __l) { return __sbistype_l(__c, 0x00000400L|0x00400000L, __l); }

pollution: isphonogram_l
inline int isphonogram_l(int, locale_t); 

pollution: isphonogram_l
inline int isphonogram_l(int __c, locale_t __l) { return __sbistype_l(__c, 0x00200000L, __l); }

pollution: isprint_l
inline int isprint_l(int, locale_t); 

pollution: isprint_l
inline int isprint_l(int __c, locale_t __l) { return __sbistype_l(__c, 0x00040000L, __l); }

pollution: ispunct_l
inline int ispunct_l(int, locale_t); 

pollution: ispunct_l
inline int ispunct_l(int __c, locale_t __l) { return __sbistype_l(__c, 0x00002000L, __l); }

pollution: isrune_l
inline int isrune_l(int, locale_t); 

pollution: isrune_l
inline int isrune_l(int __c, locale_t __l) { return __sbistype_l(__c, 0xFFFFFF00L, __l); }

pollution: isspace_l
inline int isspace_l(int, locale_t); 

pollution: isspace_l
inline int isspace_l(int __c, locale_t __l) { return __sbistype_l(__c, 0x00004000L, __l); }

pollution: isspecial_l
inline int isspecial_l(int, locale_t); 

pollution: isspecial_l
inline int isspecial_l(int __c, locale_t __l) { return __sbistype_l(__c, 0x00100000L, __l); }

pollution: isupper_l
inline int isupper_l(int, locale_t); 

pollution: isupper_l
inline int isupper_l(int __c, locale_t __l) { return __sbistype_l(__c, 0x00008000L, __l); }

pollution: isxdigit_l
inline int isxdigit_l(int, locale_t); 

pollution: isxdigit_l
inline int isxdigit_l(int __c, locale_t __l) { return __sbistype_l(__c, 0x00010000L, __l); }

pollution: digittoint_l
inline int digittoint_l(int, locale_t); 

pollution: tolower_l
inline int tolower_l(int, locale_t); 

pollution: toupper_l
inline int toupper_l(int, locale_t); 

pollution: digittoint_l
inline int digittoint_l(int __c, locale_t __l) { return __sbmaskrune_l((__c), 0xFF, __l); }

pollution: tolower_l
inline int tolower_l(int __c, locale_t __l) { int __limit; _RuneLocale *__runes = __runes_for_locale(__l, &__limit); return (__c < 0 || __c >= __limit) ? __c : __runes->__maplower[__c]; }

pollution: toupper_l
inline int toupper_l(int __c, locale_t __l) { int __limit; _RuneLocale *__runes = __runes_for_locale(__l, &__limit); return (__c < 0 || __c >= __limit) ? __c : __runes->__mapupper[__c]; }

pollution: va_list
typedef __va_list va_list; 

pollution: FILE
typedef struct __FILE FILE; 

pollution: tm
struct tm; 

pollution: btowc
wint_t btowc(int); 

pollution: fgetwc
wint_t fgetwc(FILE *); 

pollution: fgetws
wchar_t * fgetws(wchar_t * __restrict, int, FILE * __restrict); 

pollution: fputwc
wint_t fputwc(wchar_t, FILE *); 

pollution: fputws
int fputws(const wchar_t * __restrict, FILE * __restrict); 

pollution: fwide
int fwide(FILE *, int); 

pollution: fwprintf
int fwprintf(FILE * __restrict, const wchar_t * __restrict, ...); 

pollution: fwscanf
int fwscanf(FILE * __restrict, const wchar_t * __restrict, ...); 

pollution: getwc
wint_t getwc(FILE *); 

pollution: getwchar
wint_t getwchar(void); 

pollution: mbrlen
size_t mbrlen(const char * __restrict, size_t, mbstate_t * __restrict); 

pollution: mbrtowc
size_t mbrtowc(wchar_t * __restrict, const char * __restrict, size_t, mbstate_t * __restrict); 

pollution: mbsinit
int mbsinit(const mbstate_t *); 

pollution: mbsrtowcs
size_t mbsrtowcs(wchar_t * __restrict, const char ** __restrict, size_t, mbstate_t * __restrict); 

pollution: putwc
wint_t putwc(wchar_t, FILE *); 

pollution: putwchar
wint_t putwchar(wchar_t); 

pollution: n
pollution: swprintf
int swprintf(wchar_t * __restrict, size_t n, const wchar_t * __restrict, ...); 

pollution: swscanf
int swscanf(const wchar_t * __restrict, const wchar_t * __restrict, ...); 

pollution: ungetwc
wint_t ungetwc(wint_t, FILE *); 

pollution: vfwprintf
int vfwprintf(FILE * __restrict, const wchar_t * __restrict, __va_list); 

pollution: n
pollution: vswprintf
int vswprintf(wchar_t * __restrict, size_t n, const wchar_t * __restrict, __va_list); 

pollution: vwprintf
int vwprintf(const wchar_t * __restrict, __va_list); 

pollution: wcrtomb
size_t wcrtomb(char * __restrict, wchar_t, mbstate_t * __restrict); 

pollution: wcscat
wchar_t *wcscat(wchar_t * __restrict, const wchar_t * __restrict); 

pollution: wcschr
wchar_t *wcschr(const wchar_t *, wchar_t) __attribute__((__pure__)); 

pollution: wcscmp
int wcscmp(const wchar_t *, const wchar_t *) __attribute__((__pure__)); 

pollution: wcscoll
int wcscoll(const wchar_t *, const wchar_t *); 

pollution: wcscpy
wchar_t *wcscpy(wchar_t * __restrict, const wchar_t * __restrict); 

pollution: wcscspn
size_t wcscspn(const wchar_t *, const wchar_t *) __attribute__((__pure__)); 

pollution: tm
pollution: wcsftime
size_t wcsftime(wchar_t * __restrict, size_t, const wchar_t * __restrict, const struct tm * __restrict); 

pollution: wcslen
size_t wcslen(const wchar_t *) __attribute__((__pure__)); 

pollution: wcsncat
wchar_t *wcsncat(wchar_t * __restrict, const wchar_t * __restrict, size_t); 

pollution: wcsncmp
int wcsncmp(const wchar_t *, const wchar_t *, size_t) __attribute__((__pure__)); 

pollution: wcsncpy
wchar_t *wcsncpy(wchar_t * __restrict , const wchar_t * __restrict, size_t); 

pollution: wcspbrk
wchar_t *wcspbrk(const wchar_t *, const wchar_t *) __attribute__((__pure__)); 

pollution: wcsrchr
wchar_t *wcsrchr(const wchar_t *, wchar_t) __attribute__((__pure__)); 

pollution: wcsrtombs
size_t wcsrtombs(char * __restrict, const wchar_t ** __restrict, size_t, mbstate_t * __restrict); 

pollution: wcsspn
size_t wcsspn(const wchar_t *, const wchar_t *) __attribute__((__pure__)); 

pollution: wcsstr
wchar_t *wcsstr(const wchar_t * __restrict, const wchar_t * __restrict) __attribute__((__pure__)); 

pollution: wcsxfrm
size_t wcsxfrm(wchar_t * __restrict, const wchar_t * __restrict, size_t); 

pollution: wctob
int wctob(wint_t); 

pollution: wcstod
double wcstod(const wchar_t * __restrict, wchar_t ** __restrict); 

pollution: wcstok
wchar_t *wcstok(wchar_t * __restrict, const wchar_t * __restrict, wchar_t ** __restrict); 

pollution: wcstol
long wcstol(const wchar_t * __restrict, wchar_t ** __restrict, int); 

pollution: wcstoul
unsigned long wcstoul(const wchar_t * __restrict, wchar_t ** __restrict, int); 

pollution: wmemchr
wchar_t *wmemchr(const wchar_t *, wchar_t, size_t) __attribute__((__pure__)); 

pollution: wmemcmp
int wmemcmp(const wchar_t *, const wchar_t *, size_t) __attribute__((__pure__)); 

pollution: wmemcpy
wchar_t *wmemcpy(wchar_t * __restrict, const wchar_t * __restrict, size_t); 

pollution: wmemmove
wchar_t *wmemmove(wchar_t *, const wchar_t *, size_t); 

pollution: wmemset
wchar_t *wmemset(wchar_t *, wchar_t, size_t); 

pollution: wprintf
int wprintf(const wchar_t * __restrict, ...); 

pollution: wscanf
int wscanf(const wchar_t * __restrict, ...); 

pollution: vfwscanf
int vfwscanf(FILE * __restrict, const wchar_t * __restrict, __va_list); 

pollution: vswscanf
int vswscanf(const wchar_t * __restrict, const wchar_t * __restrict, __va_list); 

pollution: vwscanf
int vwscanf(const wchar_t * __restrict, __va_list); 

pollution: wcstof
float wcstof(const wchar_t * __restrict, wchar_t ** __restrict); 

pollution: wcstold
long double wcstold(const wchar_t * __restrict, wchar_t ** __restrict); 

pollution: wcstoll
long long wcstoll(const wchar_t * __restrict, wchar_t ** __restrict, int); 

pollution: wcstoull
unsigned long long wcstoull(const wchar_t * __restrict, wchar_t ** __restrict, int); 

pollution: mbsnrtowcs
size_t mbsnrtowcs(wchar_t * __restrict, const char ** __restrict, size_t, size_t, mbstate_t * __restrict); 

pollution: open_wmemstream
FILE *open_wmemstream(wchar_t **, size_t *); 

pollution: wcpcpy
wchar_t *wcpcpy(wchar_t * __restrict, const wchar_t * __restrict); 

pollution: wcpncpy
wchar_t *wcpncpy(wchar_t * __restrict, const wchar_t * __restrict, size_t); 

pollution: wcsdup
wchar_t *wcsdup(const wchar_t *) __attribute__((__malloc__)); 

pollution: wcscasecmp
int wcscasecmp(const wchar_t *, const wchar_t *); 

pollution: n
pollution: wcsncasecmp
int wcsncasecmp(const wchar_t *, const wchar_t *, size_t n); 

pollution: wcsnlen
size_t wcsnlen(const wchar_t *, size_t) __attribute__((__pure__)); 

pollution: wcsnrtombs
size_t wcsnrtombs(char * __restrict, const wchar_t ** __restrict, size_t, size_t, mbstate_t * __restrict); 

pollution: wcscoll_l
int wcscoll_l(const wchar_t *, const wchar_t *, locale_t); 

pollution: wcsxfrm_l
size_t wcsxfrm_l(wchar_t * __restrict, const wchar_t * __restrict, size_t, locale_t); 

pollution: decimal_point
char *decimal_point; 

pollution: thousands_sep
char *thousands_sep; 

pollution: grouping
char *grouping; 

pollution: int_curr_symbol
char *int_curr_symbol; 

pollution: currency_symbol
char *currency_symbol; 

pollution: mon_decimal_point
char *mon_decimal_point; 

pollution: mon_thousands_sep
char *mon_thousands_sep; 

pollution: mon_grouping
char *mon_grouping; 

pollution: positive_sign
char *positive_sign; 

pollution: negative_sign
char *negative_sign; 

pollution: int_frac_digits
char int_frac_digits; 

pollution: frac_digits
char frac_digits; 

pollution: p_cs_precedes
char p_cs_precedes; 

pollution: p_sep_by_space
char p_sep_by_space; 

pollution: n_cs_precedes
char n_cs_precedes; 

pollution: n_sep_by_space
char n_sep_by_space; 

pollution: p_sign_posn
char p_sign_posn; 

pollution: n_sign_posn
char n_sign_posn; 

pollution: int_p_cs_precedes
char int_p_cs_precedes; 

pollution: int_n_cs_precedes
char int_n_cs_precedes; 

pollution: int_p_sep_by_space
char int_p_sep_by_space; 

pollution: int_n_sep_by_space
char int_n_sep_by_space; 

pollution: int_p_sign_posn
char int_p_sign_posn; 

pollution: int_n_sign_posn
char int_n_sign_posn; 

pollution: lconv
struct lconv { char *decimal_point; char *thousands_sep; char *grouping; char *int_curr_symbol; char *currency_symbol; char *mon_decimal_point; char *mon_thousands_sep; char *mon_grouping; char *positive_sign; char *negative_sign; char int_frac_digits; char frac_digits; char p_cs_precedes; char p_sep_by_space; char n_cs_precedes; char n_sep_by_space; char p_sign_posn; char n_sign_posn; char int_p_cs_precedes; char int_n_cs_precedes; char int_p_sep_by_space; char int_n_sep_by_space; char int_p_sign_posn; char int_n_sign_posn; }; 

pollution: lconv
pollution: localeconv
struct lconv *localeconv(void); 

pollution: setlocale
char *setlocale(int, const char *); 

pollution: base
pollution: duplocale
locale_t duplocale(locale_t base); 

pollution: loc
pollution: freelocale
void freelocale(locale_t loc); 

pollution: mask
pollution: locale
pollution: base
pollution: newlocale
locale_t newlocale(int mask, const char *locale, locale_t base); 

pollution: mask
pollution: loc
pollution: querylocale
const char *querylocale(int mask, locale_t loc); 

pollution: loc
pollution: uselocale
locale_t uselocale(locale_t loc); 

pollution: btowc_l
wint_t btowc_l(int, locale_t); 

pollution: fgetwc_l
wint_t fgetwc_l(FILE *, locale_t); 

pollution: fgetws_l
wchar_t *fgetws_l(wchar_t * __restrict, int, FILE * __restrict, locale_t); 

pollution: fputwc_l
wint_t fputwc_l(wchar_t, FILE *, locale_t); 

pollution: fputws_l
int fputws_l(const wchar_t * __restrict, FILE * __restrict, locale_t); 

pollution: fwprintf_l
int fwprintf_l(FILE * __restrict, locale_t, const wchar_t * __restrict, ...); 

pollution: fwscanf_l
int fwscanf_l(FILE * __restrict, locale_t, const wchar_t * __restrict, ...); 

pollution: getwc_l
wint_t getwc_l(FILE *, locale_t); 

pollution: getwchar_l
wint_t getwchar_l(locale_t); 

pollution: mbrlen_l
size_t mbrlen_l(const char * __restrict, size_t, mbstate_t * __restrict, locale_t); 

pollution: mbrtowc_l
size_t mbrtowc_l(wchar_t * __restrict, const char * __restrict, size_t, mbstate_t * __restrict, locale_t); 

pollution: mbsinit_l
int mbsinit_l(const mbstate_t *, locale_t); 

pollution: mbsrtowcs_l
size_t mbsrtowcs_l(wchar_t * __restrict, const char ** __restrict, size_t, mbstate_t * __restrict, locale_t); 

pollution: dlen
pollution: mbintowcr_l
size_t mbintowcr_l(wchar_t * __restrict, const char * __restrict, size_t dlen, size_t *, locale_t, int); 

pollution: putwc_l
wint_t putwc_l(wchar_t, FILE *, locale_t); 

pollution: putwchar_l
wint_t putwchar_l(wchar_t, locale_t); 

pollution: n
pollution: swprintf_l
int swprintf_l(wchar_t * __restrict, size_t n, locale_t, const wchar_t * __restrict, ...); 

pollution: swscanf_l
int swscanf_l(const wchar_t * __restrict, locale_t, const wchar_t * __restrict, ...); 

pollution: ungetwc_l
wint_t ungetwc_l(wint_t, FILE *, locale_t); 

pollution: vfwprintf_l
int vfwprintf_l(FILE * __restrict, locale_t, const wchar_t * __restrict, __va_list); 

pollution: n
pollution: vswprintf_l
int vswprintf_l(wchar_t * __restrict, size_t n, locale_t, const wchar_t * __restrict, __va_list); 

pollution: vwprintf_l
int vwprintf_l(locale_t, const wchar_t * __restrict, __va_list); 

pollution: wcrtomb_l
size_t wcrtomb_l(char * __restrict, wchar_t, mbstate_t * __restrict, locale_t); 

pollution: tm
pollution: wcsftime_l
size_t wcsftime_l(wchar_t * __restrict, size_t, const wchar_t * __restrict, const struct tm * __restrict, locale_t); 

pollution: wcsrtombs_l
size_t wcsrtombs_l(char * __restrict, const wchar_t ** __restrict, size_t, mbstate_t * __restrict, locale_t); 

pollution: wcrtombin_l
size_t wcrtombin_l(char * __restrict, const wchar_t * __restrict, size_t, size_t *, locale_t, int); 

pollution: wcstod_l
double wcstod_l(const wchar_t * __restrict, wchar_t ** __restrict, locale_t); 

pollution: wcstol_l
long wcstol_l(const wchar_t * __restrict, wchar_t ** __restrict, int, locale_t); 

pollution: wcstoul_l
unsigned long wcstoul_l(const wchar_t * __restrict, wchar_t ** __restrict, int, locale_t); 

pollution: wcswidth_l
int wcswidth_l(const wchar_t *, size_t, locale_t); 

pollution: wctob_l
int wctob_l(wint_t, locale_t); 

pollution: wcwidth_l
int wcwidth_l(wchar_t, locale_t); 

pollution: wprintf_l
int wprintf_l(locale_t, const wchar_t * __restrict, ...); 

pollution: wscanf_l
int wscanf_l(locale_t, const wchar_t * __restrict, ...); 

pollution: vfwscanf_l
int vfwscanf_l(FILE * __restrict, locale_t, const wchar_t * __restrict, __va_list); 

pollution: vswscanf_l
int vswscanf_l(const wchar_t * __restrict, locale_t, const wchar_t *__restrict, __va_list); 

pollution: vwscanf_l
int vwscanf_l(locale_t, const wchar_t * __restrict, __va_list); 

pollution: wcstof_l
float wcstof_l(const wchar_t * __restrict, wchar_t ** __restrict, locale_t); 

pollution: wcstold_l
long double wcstold_l(const wchar_t * __restrict, wchar_t ** __restrict, locale_t); 

pollution: wcstoll_l
long long wcstoll_l(const wchar_t * __restrict, wchar_t ** __restrict, int, locale_t); 

pollution: wcstoull_l
unsigned long long wcstoull_l(const wchar_t * __restrict, wchar_t ** __restrict, int, locale_t); 

pollution: mbsnrtowcs_l
size_t mbsnrtowcs_l(wchar_t * __restrict, const char ** __restrict, size_t, size_t, mbstate_t * __restrict, locale_t); 

pollution: wcsnrtombs_l
size_t wcsnrtombs_l(char * __restrict, const wchar_t ** __restrict, size_t, size_t, mbstate_t * __restrict, locale_t); 

pollution: lconv
pollution: localeconv_l
struct lconv *localeconv_l(locale_t); 

pollution: TRE_CONFIG_APPROX
pollution: TRE_CONFIG_WCHAR
pollution: TRE_CONFIG_MULTIBYTE
pollution: TRE_CONFIG_SYSTEM_ABI
pollution: TRE_CONFIG_VERSION
pollution: value
void *value; 

pollution: cost_ins
int cost_ins; 

pollution: cost_del
int cost_del; 

pollution: cost_subst
int cost_subst; 

pollution: max_cost
int max_cost; 

pollution: max_ins
int max_ins; 

pollution: max_del
int max_del; 

pollution: max_subst
int max_subst; 

pollution: max_err
int max_err; 

pollution: nmatch
size_t nmatch; 

pollution: pmatch
regmatch_t *pmatch; 

pollution: cost
int cost; 

pollution: num_ins
int num_ins; 

pollution: num_del
int num_del; 

pollution: num_subst
int num_subst; 

pollution: c
pollution: pos_add
pollution: context
pollution: get_next_char
int (*get_next_char)(tre_char_t *c, unsigned int *pos_add, void *context); 

pollution: pos
pollution: context
pollution: rewind
void (*rewind)(size_t pos, void *context); 

pollution: pos1
pollution: pos2
pollution: len
pollution: context
pollution: compare
int (*compare)(size_t pos1, size_t pos2, size_t len, void *context); 

pollution: context
void *context; 

pollution: tre_str_source
typedef struct { int (*get_next_char)(tre_char_t *c, unsigned int *pos_add, void *context); void (*rewind)(size_t pos, void *context); int (*compare)(size_t pos1, size_t pos2, size_t len, void *context); void *context; } tre_str_source; 

pollution: preg
pollution: regex
pollution: cflags
int regcomp(regex_t * __restrict preg, const char * __restrict regex, int cflags); 

pollution: preg
pollution: string
pollution: nmatch
pollution: pmatch
pollution: eflags
int regexec(const regex_t * __restrict preg, const char * __restrict string, size_t nmatch, regmatch_t pmatch[__restrict], int eflags); 

pollution: errcode
pollution: preg
pollution: errbuf
pollution: errbuf_size
size_t regerror(int errcode, const regex_t * __restrict preg, char * __restrict errbuf, size_t errbuf_size); 

pollution: preg
void regfree(regex_t *preg); 

pollution: preg
pollution: regex
pollution: cflags
pollution: regwcomp
int regwcomp(regex_t *preg, const wchar_t *regex, int cflags); 

pollution: preg
pollution: string
pollution: nmatch
pollution: pmatch
pollution: eflags
pollution: regwexec
int regwexec(const regex_t *preg, const wchar_t *string, size_t nmatch, regmatch_t pmatch[], int eflags); 

pollution: preg
pollution: regex
pollution: len
pollution: cflags
pollution: regncomp
int regncomp(regex_t *preg, const char *regex, size_t len, int cflags); 

pollution: preg
pollution: string
pollution: len
pollution: nmatch
pollution: pmatch
pollution: eflags
pollution: regnexec
int regnexec(const regex_t *preg, const char *string, size_t len, size_t nmatch, regmatch_t pmatch[], int eflags); 

pollution: preg
pollution: regex
pollution: len
pollution: cflags
pollution: regwncomp
int regwncomp(regex_t *preg, const wchar_t *regex, size_t len, int cflags); 

pollution: preg
pollution: string
pollution: len
pollution: nmatch
pollution: pmatch
pollution: eflags
pollution: regwnexec
int regwnexec(const regex_t *preg, const wchar_t *string, size_t len, size_t nmatch, regmatch_t pmatch[], int eflags); 

pollution: tre_version
char * tre_version(void); 

pollution: query
pollution: result
pollution: tre_config
int tre_config(int query, void *result); 

pollution: preg
pollution: tre_have_backrefs
int tre_have_backrefs(const regex_t *preg); 

pollution: preg
pollution: tre_have_approx
int tre_have_approx(const regex_t *preg); 

pollution: preg
pollution: regex
pollution: cflags
pollution: locale
pollution: regcomp_l
int regcomp_l(regex_t *preg, const char *regex, int cflags, locale_t locale); 

pollution: preg
pollution: regex
pollution: len
pollution: cflags
pollution: locale
pollution: regncomp_l
int regncomp_l(regex_t *preg, const char *regex, size_t len, int cflags, locale_t locale); 

pollution: preg
pollution: regex
pollution: cflags
pollution: locale
pollution: regwcomp_l
int regwcomp_l(regex_t *preg, const wchar_t *regex, int cflags, locale_t locale); 

pollution: preg
pollution: regex
pollution: len
pollution: cflags
pollution: locale
pollution: regwncomp_l
int regwncomp_l(regex_t *preg, const wchar_t *regex, size_t len, int cflags, locale_t locale); 

pollution: RE_DUP_MAX
#define RE_DUP_MAX 255

pollution: INT_LEAST16_MIN
#define INT_LEAST16_MIN INT16_MIN

pollution: tre_regexec
#define tre_regexec regexec

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

pollution: INT8_MAX
#define INT8_MAX 0x7f

pollution: UINT_LEAST64_MAX
#define UINT_LEAST64_MAX UINT64_MAX

pollution: LC_ALL
#define LC_ALL 0

pollution: INT16_MAX
#define INT16_MAX 0x7fff

pollution: LC_GLOBAL_LOCALE
#define LC_GLOBAL_LOCALE ((locale_t)-1)

pollution: tre_regwexec
#define tre_regwexec regwexec

pollution: LC_CTYPE_MASK
#define LC_CTYPE_MASK (1<<1)

pollution: INT8_MIN
#define INT8_MIN (-0x7f-1)

pollution: INT16_MIN
#define INT16_MIN (-0x7fff-1)

pollution: INT_FAST8_MAX
#define INT_FAST8_MAX INT32_MAX

pollution: WCHAR_MAX
#define WCHAR_MAX __WCHAR_MAX

pollution: WCHAR_MIN
#define WCHAR_MIN __WCHAR_MIN

pollution: UINT_FAST16_MAX
#define UINT_FAST16_MAX UINT32_MAX

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

pollution: UINT8_MAX
#define UINT8_MAX 0xff

pollution: INT_FAST16_MAX
#define INT_FAST16_MAX INT32_MAX

pollution: getwchar
#define getwchar() fgetwc(__stdinp)

pollution: LC_TIME
#define LC_TIME 5

pollution: PTRDIFF_MAX
#define PTRDIFF_MAX INT64_MAX

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

pollution: tre_regncomp_l
#define tre_regncomp_l regncomp_l

pollution: getwc
#define getwc(fp) fgetwc(fp)

pollution: isupper
#define isupper(c) __sbistype((c), _CTYPE_U)

pollution: toupper
#define toupper(c) __sbtoupper(c)

pollution: INT_FAST16_MIN
#define INT_FAST16_MIN INT32_MIN

pollution: PTRDIFF_MIN
#define PTRDIFF_MIN INT64_MIN

pollution: tre_regcomp_l
#define tre_regcomp_l regcomp_l

pollution: putwc
#define putwc(wc,fp) fputwc(wc, fp)

pollution: UINT_LEAST8_MAX
#define UINT_LEAST8_MAX UINT8_MAX

pollution: LC_TIME_MASK
#define LC_TIME_MASK (1<<4)

pollution: SIZE_MAX
#define SIZE_MAX UINT64_MAX

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

pollution: INT32_MIN
#define INT32_MIN (-0x7fffffff-1)

pollution: WINT_MAX
#define WINT_MAX __WINT_MAX

pollution: UINTPTR_MAX
#define UINTPTR_MAX UINT64_MAX

pollution: LC_MONETARY
#define LC_MONETARY 3

pollution: UINT_LEAST16_MAX
#define UINT_LEAST16_MAX UINT16_MAX

pollution: UINT32_MAX
#define UINT32_MAX 0xffffffffU

pollution: tre_regerror
#define tre_regerror regerror

pollution: WINT_MIN
#define WINT_MIN __WINT_MIN

pollution: isxdigit
#define isxdigit(c) __sbistype((c), _CTYPE_X)

pollution: isblank
#define isblank(c) __sbistype((c), _CTYPE_B)

pollution: LC_MONETARY_MASK
#define LC_MONETARY_MASK (1<<2)

pollution: putwchar
#define putwchar(wc) fputwc(wc, __stdoutp)

pollution: LC_COLLATE
#define LC_COLLATE 1

pollution: INT_LEAST8_MAX
#define INT_LEAST8_MAX INT8_MAX

pollution: INT_LEAST32_MAX
#define INT_LEAST32_MAX INT32_MAX

pollution: INT_LEAST8_MIN
#define INT_LEAST8_MIN INT8_MIN

pollution: isprint
#define isprint(c) __sbistype((c), _CTYPE_R)

pollution: INT_LEAST32_MIN
#define INT_LEAST32_MIN INT32_MIN

pollution: WEOF
#define WEOF ((wint_t)(-1))

pollution: islower
#define islower(c) __sbistype((c), _CTYPE_L)

pollution: tolower
#define tolower(c) __sbtolower(c)

pollution: LC_MESSAGES_MASK
#define LC_MESSAGES_MASK (1<<5)

pollution: INT32_MAX
#define INT32_MAX 0x7fffffff

pollution: tre_regwncomp
#define tre_regwncomp regwncomp

pollution: LC_ALL_MASK
#define LC_ALL_MASK (LC_COLLATE_MASK | LC_CTYPE_MASK | LC_MESSAGES_MASK | LC_MONETARY_MASK | LC_NUMERIC_MASK | LC_TIME_MASK)

pollution: UINT64_MAX
#define UINT64_MAX 0xffffffffffffffffUL

pollution: SIG_ATOMIC_MIN
#define SIG_ATOMIC_MIN INT32_MIN

pollution: tre_regncomp
#define tre_regncomp regncomp

pollution: LC_NUMERIC_MASK
#define LC_NUMERIC_MASK (1<<3)

pollution: LC_NUMERIC
#define LC_NUMERIC 4

pollution: isdigit
#define isdigit(c) __sbistype((c), _CTYPE_D)

pollution: INTPTR_MAX
#define INTPTR_MAX INT64_MAX

pollution: INT_LEAST64_MAX
#define INT_LEAST64_MAX INT64_MAX

pollution: INTPTR_MIN
#define INTPTR_MIN INT64_MIN

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

pollution: UINT_FAST32_MAX
#define UINT_FAST32_MAX UINT32_MAX

pollution: INT_LEAST64_MIN
#define INT_LEAST64_MIN INT64_MIN

pollution: UINTMAX_MAX
#define UINTMAX_MAX UINT64_MAX

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

pollution: INT64_MAX
#define INT64_MAX 0x7fffffffffffffffL

pollution: tre_regwcomp_l
#define tre_regwcomp_l regwcomp_l

pollution: tre_regwnexec
#define tre_regwnexec regwnexec

pollution: INT64_MIN
#define INT64_MIN (-0x7fffffffffffffffL-1)

pollution: tre_regnexec
#define tre_regnexec regnexec

pollution: LC_COLLATE_MASK
#define LC_COLLATE_MASK (1<<0)

pollution: tre_regfree
#define tre_regfree regfree

pollution: INT_FAST32_MAX
#define INT_FAST32_MAX INT32_MAX

pollution: LC_MESSAGES
#define LC_MESSAGES 6

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

pollution: UINT_FAST64_MAX
#define UINT_FAST64_MAX UINT64_MAX

pollution: INT_FAST32_MIN
#define INT_FAST32_MIN INT32_MIN

pollution: LC_CTYPE
#define LC_CTYPE 2

pollution: tre_regwncomp_l
#define tre_regwncomp_l regwncomp_l

pollution: isalnum
#define isalnum(c) __sbistype((c), _CTYPE_A|_CTYPE_D|_CTYPE_N)

pollution: ispunct
#define ispunct(c) __sbistype((c), _CTYPE_P)

pollution: INT_FAST64_MAX
#define INT_FAST64_MAX INT64_MAX

pollution: UINT_LEAST32_MAX
#define UINT_LEAST32_MAX UINT32_MAX

pollution: UINT8_C
#define UINT8_C(c) (c)

pollution: tre_regwcomp
#define tre_regwcomp regwcomp

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

pollution: INT_FAST64_MIN
#define INT_FAST64_MIN INT64_MIN

pollution: UINT16_MAX
#define UINT16_MAX 0xffff

pollution: isgraph
#define isgraph(c) __sbistype((c), _CTYPE_G)

pollution: INT_LEAST16_MAX
#define INT_LEAST16_MAX INT16_MAX