int main(int argc, char *argv[]);
void abort(void);
int abs(int j);
double acos(double x);
float acosf(float x);
double acosh(double x);
float acoshf(float x);
long double acoshl(long double x);
long double acosl(long double x);
char *asctime(const struct tm *timeptr);
double asin(double x);
float asinf(float x);
double asinh(double x);
float asinhf(float x);
long double asinhl(long double x);
long double asinl(long double x);
void assert(scalar expression);
double atan(double x);
double atan2(double y, double x);
float atan2f(float y, float x);
long double atan2l(long double y, long double x);
float atanf(float x);
double atanh(double x);
float atanhf(float x);
long double atanhl(long double x);
long double atanl(long double x);
int atexit(void (*func)(void));
double atof(const char *nptr);
int atoi(const char *nptr);
long int atol(const char *nptr);
long long int atoll(const char *nptr);
void *bsearch(const void *key, const void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *));
wint_t btowc(int c);
double cabs(double complex z);
float cabsf(float complex z);
long double cabsl(long double complex z);
double complex cacos(double complex z);
float complex cacosf(float complex z);
double complex cacosh(double complex z);
float complex cacoshf(float complex z);
long double complex cacoshl(long double complex z);
long double complex cacosl(long double complex z);
void *calloc(size_t nmemb, size_t size);
double carg(double complex z);
float cargf(float complex z);
long double cargl(long double complex z);
double complex casin(double complex z);
float complex casinf(float complex z);
double complex casinh(double complex z);
float complex casinhf(float complex z);
long double complex casinhl(long double complex z);
long double complex casinl(long double complex z);
double complex catan(double complex z);
float complex catanf(float complex z);
double complex catanh(double complex z);
float complex catanhf(float complex z);
long double complex catanhl(long double complex z);
long double complex catanl(long double complex z);
double cbrt(double x);
float cbrtf(float x);
long double cbrtl(long double x);
double complex ccos(double complex z);
float complex ccosf(float complex z);
double complex ccosh(double complex z);
float complex ccoshf(float complex z);
long double complex ccoshl(long double complex z);
long double complex ccosl(long double complex z);
double ceil(double x);
float ceilf(float x);
long double ceill(long double x);
double complex cexp(double complex z);
float complex cexpf(float complex z);
long double complex cexpl(long double complex z);
double cimag(double complex z);
float cimagf(float complex z);
long double cimagl(long double complex z);
void clearerr(FILE *stream);
clock_t clock(void);
double complex clog(double complex z);
float complex clogf(float complex z);
long double complex clogl(long double complex z);
double complex conj(double complex z);
float complex conjf(float complex z);
long double complex conjl(long double complex z);
double copysign(double x, double y);
float copysignf(float x, float y);
long double copysignl(long double x, long double y);
double cos(double x);
float cosf(float x);
double cosh(double x);
float coshf(float x);
long double coshl(long double x);
long double cosl(long double x);
double complex cpow(double complex x, double complex y);
float complex cpowf(float complex x, float complex y);
long double complex cpowl(long double complex x, long double complex y);
double complex cproj(double complex z);
float complex cprojf(float complex z);
long double complex cprojl(long double complex z);
double creal(double complex z);
float crealf(float complex z);
long double creall(long double complex z);
double complex csin(double complex z);
float complex csinf(float complex z);
double complex csinh(double complex z);
float complex csinhf(float complex z);
long double complex csinhl(long double complex z);
long double complex csinl(long double complex z);
double complex csqrt(double complex z);
float complex csqrtf(float complex z);
long double complex csqrtl(long double complex z);
double complex ctan(double complex z);
float complex ctanf(float complex z);
double complex ctanh(double complex z);
float complex ctanhf(float complex z);
long double complex ctanhl(long double complex z);
long double complex ctanl(long double complex z);
char *ctime(const time_t *timer);
double difftime(time_t time1, time_t time0);
div_t div(int numer, int denom);
ldiv_t div(long int numer, long int denom);
lldiv_t div(long long int numer, long long int denom);
double erf(double x);
double erfc(double x);
float erfcf(float x);
long double erfcl(long double x);
float erff(float x);
long double erfl(long double x);
void exit(int status);
double exp(double x);
double exp2(double x);
float exp2f(float x);
long double exp2l(long double x);
float expf(float x);
long double expl(long double x);
double expm1(double x);
float expm1f(float x);
long double expm1l(long double x);
double fabs(double x);
float fabsf(float x);
long double fabsl(long double x);
int fclose(FILE *stream);
double fdim(double x, double y);
float fdimf(float x, float y);
long double fdiml(long double x, long double y);
void feclearexcept(int excepts);
void fegetenv(fenv_t *envp);
void fegetexceptflag(fexcept_t *flagp, int excepts);
int fegetround(void);
int feholdexcept(fenv_t *envp);
int feof(FILE *stream);
void feraiseexcept(int excepts);
int ferror(FILE *stream);
void fesetenv(const fenv_t *envp);
void fesetexceptflag(const fexcept_t *flagp, int excepts);
int fesetround(int round);
int fetestexcept(int excepts);
void feupdateenv(const fenv_t *envp);
int fflush(FILE *stream);
int fgetc(FILE *stream);
int fgetpos(FILE * stream, fpos_t * pos);
char *fgets(char * s, int n, FILE * stream);
wint_t fgetwc(FILE *stream);
wchar_t *fgetws(wchar_t * s, int n, FILE * stream);
double floor(double x);
float floorf(float x);
long double floorl(long double x);
double fma(double x, double y, double z);
float fmaf(float x, float y, float z);
long double fmal(long double x, long double y, long double z);
double fmax(double x, double y);
float fmaxf(float x, float y);
long double fmaxl(long double x, long double y);
double fmin(double x, double y);
float fminf(float x, float y);
long double fminl(long double x, long double y);
double fmod(double x, double y);
float fmodf(float x, float y);
long double fmodl(long double x, long double y);
FILE *fopen(const char * filename, const char * mode);
int fpclassify(real-floating x);
int fprintf(FILE * stream, const char * format, ...);
int fputc(int c, FILE *stream);
int fputs(const char * s, FILE * stream);
wint_t fputwc(wchar_t c, FILE *stream);
int fputws(const wchar_t * s, FILE * stream);
size_t fread(void * ptr, size_t size, size_t nmemb, FILE * stream);
void free(void *ptr);
FILE *freopen(const char * filename, const char * mode, FILE * stream);
double frexp(double value, int *exp);
float frexpf(float value, int *exp);
long double frexpl(long double value, int *exp);
int fscanf(FILE * stream, const char * format, ...);
int fseek(FILE *stream, long int offset, int whence);
int fsetpos(FILE *stream, const fpos_t *pos);
long int ftell(FILE *stream);
int fwide(FILE *stream, int mode);
int fwprintf(FILE * stream, const wchar_t * format, ...);
size_t fwrite(const void * ptr, size_t size, size_t nmemb, FILE * stream);
int fwscanf(FILE * stream, const wchar_t * format, ...);
int getc(FILE *stream);
int getchar(void);
char *getenv(const char *name);
char *gets(char *s);
wint_t getwc(FILE *stream);
wint_t getwchar(void);
struct tm *gmtime(const time_t *timer);
double hypot(double x, double y);
float hypotf(float x, float y);
long double hypotl(long double x, long double y);
int ilogb(double x);
int ilogbf(float x);
int ilogbl(long double x);
int isalnum(int c);
int isalpha(int c);
int iscntrl(int c);
int isdigit(int c);
int isfinite(real-floating x);
int isgraph(int c);
int isgreater(real-floating x, real-floating y);
int isgreaterequal(real-floating x, real-floating y);
int isinf(real-floating x);
int isless(real-floating x, real-floating y);
int islessequal(real-floating x, real-floating y);
int islessgreater(real-floating x, real-floating y);
int islower(int c);
int isnan(real-floating x);
int isnormal(real-floating x);
int isprint(int c);
int ispunct(int c);
int isspace(int c);
int isunordered(real-floating x, real-floating y);
int isupper(int c);
int iswalnum(wint_t wc);
int iswalpha(wint_t wc);
int iswcntrl(wint_t wc);
int iswctype(wint_t wc, wctype_t desc);
int iswdigit(wint_t wc);
int iswgraph(wint_t wc);
int iswlower(wint_t wc);
int iswprint(wint_t wc);
int iswpunct(wint_t wc);
int iswspace(wint_t wc);
int iswupper(wint_t wc);
int iswxdigit(wint_t wc);
int isxdigit(int c);
long int labs(long int j);
double ldexp(double x, int exp);
float ldexpf(float x, int exp);
long double ldexpl(long double x, int exp);
double lgamma(double x);
float lgammaf(float x);
long double lgammal(long double x);
long long int llabs(long long int j);
long long int llrint(double x);
long long int llrintf(float x);
long long int llrintl(long double x);
long long int llround(double x);
long long int llroundf(float x);
long long int llroundl(long double x);
struct lconv *localeconv(void);
struct tm *localtime(const time_t *timer);
double log(double x);
double log10(double x);
float log10f(float x);
long double log10l(long double x);
double log1p(double x);
float log1pf(float x);
long double log1pl(long double x);
double log2(double x);
float log2f(float x);
long double log2l(long double x);
double logb(double x);
float logbf(float x);
long double logbl(long double x);
float logf(float x);
long double logl(long double x);
void longjmp(jmp_buf env, int val);
long int lrint(double x);
long int lrintf(float x);
long int lrintl(long double x);
long int lround(double x);
long int lroundf(float x);
long int lroundl(long double x);
void *malloc(size_t size);
size_t mbrlen(const char * s, size_t n, mbstate_t * ps);
size_t mbrtowc(wchar_t * pwc, const char * s, size_t n, mbstate_t * ps);
int mbsinit(const mbstate_t *ps);
size_t mbsrtowcs(wchar_t * dst, const char ** src, size_t len, mbstate_t * ps);
size_t mbstowcs(wchar_t * pwcs, const char * s, size_t n);
int mbtowc(wchar_t * pwc, const char * s, size_t n);
void *memchr(const void *s, int c, size_t n);
int memcmp(const void *s1, const void *s2, size_t n);
void *memcpy(void * s1, const void * s2, size_t n);
void *memmove(void *s1, const void *s2, size_t n);
void *memset(void *s, int c, size_t n);
time_t mktime(struct tm *timeptr);
double modf(double value, double *iptr);
float modff(float value, float *iptr);
long double modfl(long double value, long double *iptr);
double nan(const char *tagp);
float nanf(const char *tagp);
long double nanl(const char *tagp);
double nearbyint(double x);
float nearbyintf(float x);
long double nearbyintl(long double x);
double nextafter(double x, double y);
float nextafterf(float x, float y);
long double nextafterl(long double x, long double y);
double nexttoward(double x, long double y);
float nexttowardf(float x, long double y);
long double nexttowardl(long double x, long double y);
void perror(const char *s);
double pow(double x, double y);
float powf(float x, float y);
long double powl(long double x, long double y);
int printf(const char * format, ...);
int putc(int c, FILE *stream);
int putchar(int c);
int puts(const char *s);
wint_t putwc(wchar_t c, FILE *stream);
wint_t putwchar(wchar_t c);
void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *));
int raise(int sig);
int rand(void);
void *realloc(void *ptr, size_t size);
double remainder(double x, double y);
float remainderf(float x, float y);
long double remainderl(long double x, long double y);
int remove(const char *filename);
double remquo(double x, double y, int *quo);
float remquof(float x, float y, int *quo);
long double remquol(long double x, long double y, int *quo);
int rename(const char *old, const char *new);
void rewind(FILE *stream);
double rint(double x);
float rintf(float x);
long double rintl(long double x);
double round(double x);
float roundf(float x);
long double roundl(long double x);
double scalbln(double x, long int n);
float scalblnf(float x, long int n);
long double scalblnl(long double x, long int n);
double scalbn(double x, int n);
float scalbnf(float x, int n);
long double scalbnl(long double x, int n);
int scanf(const char * format, ...);
void setbuf(FILE * stream, char * buf);
int setjmp(jmp_buf env);
char *setlocale(int category, const char *locale);
int setvbuf(FILE * stream, char * buf, int mode, size_t size);
int signbit(real-floating x);
double sin(double x);
float sinf(float x);
double sinh(double x);
float sinhf(float x);
long double sinhl(long double x);
long double sinl(long double x);
int snprintf(char * s, size_t n, const char * format, ...);
int sprintf(char * s, const char * format, ...);
double sqrt(double x);
float sqrtf(float x);
long double sqrtl(long double x);
void srand(unsigned int seed);
int sscanf(const char * s, const char * format, ...);
char *strcat(char * s1, const char * s2);
char *strchr(const char *s, int c);
int strcmp(const char *s1, const char *s2);
int strcoll(const char *s1, const char *s2);
char *strcpy(char * s1, const char * s2);
size_t strcspn(const char *s1, const char *s2);
char *strerror(int errnum);
size_t strftime(char * s, size_t maxsize, const char * format, const struct tm * timeptr);
size_t strlen(const char *s);
char *strncat(char * s1, const char * s2, size_t n);
int strncmp(const char *s1, const char *s2, size_t n);
char *strncpy(char * s1, const char * s2, size_t n);
char *strpbrk(const char *s1, const char *s2);
char *strrchr(const char *s, int c);
size_t strspn(const char *s1, const char *s2);
char *strstr(const char *s1, const char *s2);
double strtod(const char * nptr, char ** endptr);
float strtof(const char * nptr, char ** endptr);
intmax_t strtoimax(const char * nptr, char ** endptr, int base);
char *strtok(char * s1, const char * s2);
long int strtol( const char * nptr, char ** endptr, int base);
long double strtold(const char * nptr, char ** endptr);
long long int strtoll( const char * nptr, char ** endptr, int base);
unsigned long int strtoul( const char * nptr, char ** endptr, int base);
unsigned long long int strtoull( const char * nptr, char ** endptr, int base);
uintmax_t strtoumax(const char * nptr, char ** endptr, int base);
size_t strxfrm(char * s1, const char * s2, size_t n);
int swprintf(wchar_t * s, size_t n, const wchar_t * format, ...);
int swscanf(const wchar_t * s, const wchar_t * format, ...);
int system(const char *string);
double tan(double x);
float tanf(float x);
double tanh(double x);
float tanhf(float x);
long double tanhl(long double x);
long double tanl(long double x);
double tgamma(double x);
float tgammaf(float x);
long double tgammal(long double x);
time_t time(time_t *timer);
FILE *tmpfile(void);
char *tmpnam(char *s);
int tolower(int c);
int toupper(int c);
wint_t towctrans(wint_t wc, wctrans_t desc);
wint_t towlower(wint_t wc);
wint_t towupper(wint_t wc);
double trunc(double x);
float truncf(float x);
long double truncl(long double x);
int ungetc(int c, FILE *stream);
wint_t ungetwc(wint_t c, FILE *stream);
type va_arg(va_list ap, type);
void va_copy(va_list dest, va_list src);
void va_end(va_list ap);
void va_start(va_list ap, parmN);
int vfprintf(FILE * stream, const char * format, va_list arg);
int vfscanf(FILE * stream, const char * format, va_list arg);
int vfwprintf(FILE * stream, const wchar_t * format, va_list arg);
int vfwscanf(FILE * stream, const wchar_t * format, va_list arg);
int vprintf(const char * format, va_list arg);
int vscanf(const char * format, va_list arg);
int vsprintf(char * s, const char * format, va_list arg);
int vsprintf(char * s, size_t n, const char * format, va_list arg);
int vsscanf(const char * s, const char * format, va_list arg);
int vswprintf(wchar_t * s, size_t n, const wchar_t * format, va_list arg);
int vswscanf(const wchar_t * s, const wchar_t * format, va_list arg);
int vwprintf(const wchar_t * format, va_list arg);
int vwscanf(const wchar_t * format, va_list arg);
size_t wcrtomb(char * s, wchar_t wc, mbstate_t * ps);
wchar_t *wcscat(wchar_t * s1, const wchar_t * s2);
wchar_t *wcschr(const wchar_t *s, wchar_t c);
int wcscmp(const wchar_t *s1, const wchar_t *s2);
int wcscoll(const wchar_t *s1, const wchar_t *s2);
wchar_t *wcscpy(wchar_t * s1, const wchar_t * s2);
size_t wcscspn(const wchar_t *s1, const wchar_t *s2);
size_t wcsftime(wchar_t * s, size_t maxsize, const wchar_t * format, const struct tm * timeptr);
size_t wcslen(const wchar_t *s);
wchar_t *wcsncat(wchar_t * s1, const wchar_t * s2, size_t n);
int wcsncmp(const wchar_t *s1, const wchar_t *s2, size_t n);
wchar_t *wcsncpy(wchar_t * s1, const wchar_t * s2, size_t n);
wchar_t *wcspbrk(const wchar_t *s1, const wchar_t *s2);
wchar_t *wcsrchr(const wchar_t *s, wchar_t c);
size_t wcsrtombs(char * dst, const wchar_t ** src, size_t len, mbstate_t * ps);
size_t wcsspn(const wchar_t *s1, const wchar_t *s2);
wchar_t *wcsstr(const wchar_t *s1, const wchar_t *s2);
double wcstod(const wchar_t * nptr, wchar_t ** endptr);
float wcstof(const wchar_t * nptr, wchar_t ** endptr);
intmax_t wcstoimax(const wchar_t * nptr, wchar_t ** endptr, int base);
wchar_t *wcstok(wchar_t * s1, const wchar_t * s2, wchar_t ** ptr);
long int wcstol( const wchar_t * nptr, wchar_t ** endptr, int base);
long double wcstold(const wchar_t * nptr, wchar_t ** endptr);
long long int wcstoll( const wchar_t * nptr, wchar_t ** endptr, int base);
size_t wcstombs(char * s, const wchar_t * pwcs, size_t n);
unsigned long int wcstoul( const wchar_t * nptr, wchar_t ** endptr, int base);
unsigned long long int wcstoull( const wchar_t * nptr, wchar_t ** endptr, int base);
uintmax_t wcstoumax(const wchar_t * nptr, wchar_t ** endptr, int base);
size_t wcsxfrm(wchar_t * s1, const wchar_t * s2, size_t n);
int wctob(wint_t c);
int wctomb(char *s, wchar_t wchar);
wctrans_t wctrans(const char *property);
wctype_t wctype(const char *property);
wchar_t *wmemchr(const wchar_t *s, wchar_t c, size_t n);
int wmemcmp(const wchar_t * s1, const wchar_t * s2, size_t n);
wchar_t *wmemcpy(wchar_t * s1, const wchar_t * s2, size_t n);
wchar_t *wmemmove(wchar_t *s1, const wchar_t *s2, size_t n);
wchar_t *wmemset(wchar_t *s, wchar_t c, size_t n);
int wprintf(const wchar_t * format, ...);
int wscanf(const wchar_t * format, ...);
