LCOV - code coverage report
Current view: top level - usr/include - stdlib.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 2 2 100.0 %
Date: 2021-10-13 02:24:04 Functions: 0 0 -

          Line data    Source code
       1             : /* Copyright (C) 1991-2020 Free Software Foundation, Inc.
       2             :    This file is part of the GNU C Library.
       3             : 
       4             :    The GNU C Library is free software; you can redistribute it and/or
       5             :    modify it under the terms of the GNU Lesser General Public
       6             :    License as published by the Free Software Foundation; either
       7             :    version 2.1 of the License, or (at your option) any later version.
       8             : 
       9             :    The GNU C Library is distributed in the hope that it will be useful,
      10             :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      11             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      12             :    Lesser General Public License for more details.
      13             : 
      14             :    You should have received a copy of the GNU Lesser General Public
      15             :    License along with the GNU C Library; if not, see
      16             :    <https://www.gnu.org/licenses/>.  */
      17             : 
      18             : /*
      19             :  *      ISO C99 Standard: 7.20 General utilities        <stdlib.h>
      20             :  */
      21             : 
      22             : #ifndef _STDLIB_H
      23             : 
      24             : #define __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION
      25             : #include <bits/libc-header-start.h>
      26             : 
      27             : /* Get size_t, wchar_t and NULL from <stddef.h>.  */
      28             : #define __need_size_t
      29             : #define __need_wchar_t
      30             : #define __need_NULL
      31             : #include <stddef.h>
      32             : 
      33             : __BEGIN_DECLS
      34             : 
      35             : #define _STDLIB_H       1
      36             : 
      37             : #if (defined __USE_XOPEN || defined __USE_XOPEN2K8) && !defined _SYS_WAIT_H
      38             : /* XPG requires a few symbols from <sys/wait.h> being defined.  */
      39             : # include <bits/waitflags.h>
      40             : # include <bits/waitstatus.h>
      41             : 
      42             : /* Define the macros <sys/wait.h> also would define this way.  */
      43             : # define WEXITSTATUS(status)    __WEXITSTATUS (status)
      44             : # define WTERMSIG(status)       __WTERMSIG (status)
      45             : # define WSTOPSIG(status)       __WSTOPSIG (status)
      46             : # define WIFEXITED(status)      __WIFEXITED (status)
      47             : # define WIFSIGNALED(status)    __WIFSIGNALED (status)
      48             : # define WIFSTOPPED(status)     __WIFSTOPPED (status)
      49             : # ifdef __WIFCONTINUED
      50             : #  define WIFCONTINUED(status)  __WIFCONTINUED (status)
      51             : # endif
      52             : #endif  /* X/Open or XPG7 and <sys/wait.h> not included.  */
      53             : 
      54             : /* _FloatN API tests for enablement.  */
      55             : #include <bits/floatn.h>
      56             : 
      57             : /* Returned by `div'.  */
      58             : typedef struct
      59             :   {
      60             :     int quot;                   /* Quotient.  */
      61             :     int rem;                    /* Remainder.  */
      62             :   } div_t;
      63             : 
      64             : /* Returned by `ldiv'.  */
      65             : #ifndef __ldiv_t_defined
      66             : typedef struct
      67             :   {
      68             :     long int quot;              /* Quotient.  */
      69             :     long int rem;               /* Remainder.  */
      70             :   } ldiv_t;
      71             : # define __ldiv_t_defined       1
      72             : #endif
      73             : 
      74             : #if defined __USE_ISOC99 && !defined __lldiv_t_defined
      75             : /* Returned by `lldiv'.  */
      76             : __extension__ typedef struct
      77             :   {
      78             :     long long int quot;         /* Quotient.  */
      79             :     long long int rem;          /* Remainder.  */
      80             :   } lldiv_t;
      81             : # define __lldiv_t_defined      1
      82             : #endif
      83             : 
      84             : 
      85             : /* The largest number rand will return (same as INT_MAX).  */
      86             : #define RAND_MAX        2147483647
      87             : 
      88             : 
      89             : /* We define these the same for all machines.
      90             :    Changes from this to the outside world should be done in `_exit'.  */
      91             : #define EXIT_FAILURE    1       /* Failing exit status.  */
      92             : #define EXIT_SUCCESS    0       /* Successful exit status.  */
      93             : 
      94             : 
      95             : /* Maximum length of a multibyte character in the current locale.  */
      96             : #define MB_CUR_MAX      (__ctype_get_mb_cur_max ())
      97             : extern size_t __ctype_get_mb_cur_max (void) __THROW __wur;
      98             : 
      99             : 
     100             : /* Convert a string to a floating-point number.  */
     101             : extern double atof (const char *__nptr)
     102             :      __THROW __attribute_pure__ __nonnull ((1)) __wur;
     103             : /* Convert a string to an integer.  */
     104             : extern int atoi (const char *__nptr)
     105             :      __THROW __attribute_pure__ __nonnull ((1)) __wur;
     106             : /* Convert a string to a long integer.  */
     107             : extern long int atol (const char *__nptr)
     108             :      __THROW __attribute_pure__ __nonnull ((1)) __wur;
     109             : 
     110             : #ifdef __USE_ISOC99
     111             : /* Convert a string to a long long integer.  */
     112             : __extension__ extern long long int atoll (const char *__nptr)
     113             :      __THROW __attribute_pure__ __nonnull ((1)) __wur;
     114             : #endif
     115             : 
     116             : /* Convert a string to a floating-point number.  */
     117             : extern double strtod (const char *__restrict __nptr,
     118             :                       char **__restrict __endptr)
     119             :      __THROW __nonnull ((1));
     120             : 
     121             : #ifdef  __USE_ISOC99
     122             : /* Likewise for `float' and `long double' sizes of floating-point numbers.  */
     123             : extern float strtof (const char *__restrict __nptr,
     124             :                      char **__restrict __endptr) __THROW __nonnull ((1));
     125             : 
     126             : extern long double strtold (const char *__restrict __nptr,
     127             :                             char **__restrict __endptr)
     128             :      __THROW __nonnull ((1));
     129             : #endif
     130             : 
     131             : /* Likewise for '_FloatN' and '_FloatNx'.  */
     132             : 
     133             : #if __HAVE_FLOAT16 && __GLIBC_USE (IEC_60559_TYPES_EXT)
     134             : extern _Float16 strtof16 (const char *__restrict __nptr,
     135             :                           char **__restrict __endptr)
     136             :      __THROW __nonnull ((1));
     137             : #endif
     138             : 
     139             : #if __HAVE_FLOAT32 && __GLIBC_USE (IEC_60559_TYPES_EXT)
     140             : extern _Float32 strtof32 (const char *__restrict __nptr,
     141             :                           char **__restrict __endptr)
     142             :      __THROW __nonnull ((1));
     143             : #endif
     144             : 
     145             : #if __HAVE_FLOAT64 && __GLIBC_USE (IEC_60559_TYPES_EXT)
     146             : extern _Float64 strtof64 (const char *__restrict __nptr,
     147             :                           char **__restrict __endptr)
     148             :      __THROW __nonnull ((1));
     149             : #endif
     150             : 
     151             : #if __HAVE_FLOAT128 && __GLIBC_USE (IEC_60559_TYPES_EXT)
     152             : extern _Float128 strtof128 (const char *__restrict __nptr,
     153             :                             char **__restrict __endptr)
     154             :      __THROW __nonnull ((1));
     155             : #endif
     156             : 
     157             : #if __HAVE_FLOAT32X && __GLIBC_USE (IEC_60559_TYPES_EXT)
     158             : extern _Float32x strtof32x (const char *__restrict __nptr,
     159             :                             char **__restrict __endptr)
     160             :      __THROW __nonnull ((1));
     161             : #endif
     162             : 
     163             : #if __HAVE_FLOAT64X && __GLIBC_USE (IEC_60559_TYPES_EXT)
     164             : extern _Float64x strtof64x (const char *__restrict __nptr,
     165             :                             char **__restrict __endptr)
     166             :      __THROW __nonnull ((1));
     167             : #endif
     168             : 
     169             : #if __HAVE_FLOAT128X && __GLIBC_USE (IEC_60559_TYPES_EXT)
     170             : extern _Float128x strtof128x (const char *__restrict __nptr,
     171             :                               char **__restrict __endptr)
     172             :      __THROW __nonnull ((1));
     173             : #endif
     174             : 
     175             : /* Convert a string to a long integer.  */
     176             : extern long int strtol (const char *__restrict __nptr,
     177             :                         char **__restrict __endptr, int __base)
     178             :      __THROW __nonnull ((1));
     179             : /* Convert a string to an unsigned long integer.  */
     180             : extern unsigned long int strtoul (const char *__restrict __nptr,
     181             :                                   char **__restrict __endptr, int __base)
     182             :      __THROW __nonnull ((1));
     183             : 
     184             : #ifdef __USE_MISC
     185             : /* Convert a string to a quadword integer.  */
     186             : __extension__
     187             : extern long long int strtoq (const char *__restrict __nptr,
     188             :                              char **__restrict __endptr, int __base)
     189             :      __THROW __nonnull ((1));
     190             : /* Convert a string to an unsigned quadword integer.  */
     191             : __extension__
     192             : extern unsigned long long int strtouq (const char *__restrict __nptr,
     193             :                                        char **__restrict __endptr, int __base)
     194             :      __THROW __nonnull ((1));
     195             : #endif /* Use misc.  */
     196             : 
     197             : #ifdef __USE_ISOC99
     198             : /* Convert a string to a quadword integer.  */
     199             : __extension__
     200             : extern long long int strtoll (const char *__restrict __nptr,
     201             :                               char **__restrict __endptr, int __base)
     202             :      __THROW __nonnull ((1));
     203             : /* Convert a string to an unsigned quadword integer.  */
     204             : __extension__
     205             : extern unsigned long long int strtoull (const char *__restrict __nptr,
     206             :                                         char **__restrict __endptr, int __base)
     207             :      __THROW __nonnull ((1));
     208             : #endif /* ISO C99 or use MISC.  */
     209             : 
     210             : /* Convert a floating-point number to a string.  */
     211             : #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X)
     212             : extern int strfromd (char *__dest, size_t __size, const char *__format,
     213             :                      double __f)
     214             :      __THROW __nonnull ((3));
     215             : 
     216             : extern int strfromf (char *__dest, size_t __size, const char *__format,
     217             :                      float __f)
     218             :      __THROW __nonnull ((3));
     219             : 
     220             : extern int strfroml (char *__dest, size_t __size, const char *__format,
     221             :                      long double __f)
     222             :      __THROW __nonnull ((3));
     223             : #endif
     224             : 
     225             : #if __HAVE_FLOAT16 && __GLIBC_USE (IEC_60559_TYPES_EXT)
     226             : extern int strfromf16 (char *__dest, size_t __size, const char * __format,
     227             :                        _Float16 __f)
     228             :      __THROW __nonnull ((3));
     229             : #endif
     230             : 
     231             : #if __HAVE_FLOAT32 && __GLIBC_USE (IEC_60559_TYPES_EXT)
     232             : extern int strfromf32 (char *__dest, size_t __size, const char * __format,
     233             :                        _Float32 __f)
     234             :      __THROW __nonnull ((3));
     235             : #endif
     236             : 
     237             : #if __HAVE_FLOAT64 && __GLIBC_USE (IEC_60559_TYPES_EXT)
     238             : extern int strfromf64 (char *__dest, size_t __size, const char * __format,
     239             :                        _Float64 __f)
     240             :      __THROW __nonnull ((3));
     241             : #endif
     242             : 
     243             : #if __HAVE_FLOAT128 && __GLIBC_USE (IEC_60559_TYPES_EXT)
     244             : extern int strfromf128 (char *__dest, size_t __size, const char * __format,
     245             :                         _Float128 __f)
     246             :      __THROW __nonnull ((3));
     247             : #endif
     248             : 
     249             : #if __HAVE_FLOAT32X && __GLIBC_USE (IEC_60559_TYPES_EXT)
     250             : extern int strfromf32x (char *__dest, size_t __size, const char * __format,
     251             :                         _Float32x __f)
     252             :      __THROW __nonnull ((3));
     253             : #endif
     254             : 
     255             : #if __HAVE_FLOAT64X && __GLIBC_USE (IEC_60559_TYPES_EXT)
     256             : extern int strfromf64x (char *__dest, size_t __size, const char * __format,
     257             :                         _Float64x __f)
     258             :      __THROW __nonnull ((3));
     259             : #endif
     260             : 
     261             : #if __HAVE_FLOAT128X && __GLIBC_USE (IEC_60559_TYPES_EXT)
     262             : extern int strfromf128x (char *__dest, size_t __size, const char * __format,
     263             :                          _Float128x __f)
     264             :      __THROW __nonnull ((3));
     265             : #endif
     266             : 
     267             : 
     268             : #ifdef __USE_GNU
     269             : /* Parallel versions of the functions above which take the locale to
     270             :    use as an additional parameter.  These are GNU extensions inspired
     271             :    by the POSIX.1-2008 extended locale API.  */
     272             : # include <bits/types/locale_t.h>
     273             : 
     274             : extern long int strtol_l (const char *__restrict __nptr,
     275             :                           char **__restrict __endptr, int __base,
     276             :                           locale_t __loc) __THROW __nonnull ((1, 4));
     277             : 
     278             : extern unsigned long int strtoul_l (const char *__restrict __nptr,
     279             :                                     char **__restrict __endptr,
     280             :                                     int __base, locale_t __loc)
     281             :      __THROW __nonnull ((1, 4));
     282             : 
     283             : __extension__
     284             : extern long long int strtoll_l (const char *__restrict __nptr,
     285             :                                 char **__restrict __endptr, int __base,
     286             :                                 locale_t __loc)
     287             :      __THROW __nonnull ((1, 4));
     288             : 
     289             : __extension__
     290             : extern unsigned long long int strtoull_l (const char *__restrict __nptr,
     291             :                                           char **__restrict __endptr,
     292             :                                           int __base, locale_t __loc)
     293             :      __THROW __nonnull ((1, 4));
     294             : 
     295             : extern double strtod_l (const char *__restrict __nptr,
     296             :                         char **__restrict __endptr, locale_t __loc)
     297             :      __THROW __nonnull ((1, 3));
     298             : 
     299             : extern float strtof_l (const char *__restrict __nptr,
     300             :                        char **__restrict __endptr, locale_t __loc)
     301             :      __THROW __nonnull ((1, 3));
     302             : 
     303             : extern long double strtold_l (const char *__restrict __nptr,
     304             :                               char **__restrict __endptr,
     305             :                               locale_t __loc)
     306             :      __THROW __nonnull ((1, 3));
     307             : 
     308             : # if __HAVE_FLOAT16
     309             : extern _Float16 strtof16_l (const char *__restrict __nptr,
     310             :                             char **__restrict __endptr,
     311             :                             locale_t __loc)
     312             :      __THROW __nonnull ((1, 3));
     313             : # endif
     314             : 
     315             : # if __HAVE_FLOAT32
     316             : extern _Float32 strtof32_l (const char *__restrict __nptr,
     317             :                             char **__restrict __endptr,
     318             :                             locale_t __loc)
     319             :      __THROW __nonnull ((1, 3));
     320             : # endif
     321             : 
     322             : # if __HAVE_FLOAT64
     323             : extern _Float64 strtof64_l (const char *__restrict __nptr,
     324             :                             char **__restrict __endptr,
     325             :                             locale_t __loc)
     326             :      __THROW __nonnull ((1, 3));
     327             : # endif
     328             : 
     329             : # if __HAVE_FLOAT128
     330             : extern _Float128 strtof128_l (const char *__restrict __nptr,
     331             :                               char **__restrict __endptr,
     332             :                               locale_t __loc)
     333             :      __THROW __nonnull ((1, 3));
     334             : # endif
     335             : 
     336             : # if __HAVE_FLOAT32X
     337             : extern _Float32x strtof32x_l (const char *__restrict __nptr,
     338             :                               char **__restrict __endptr,
     339             :                               locale_t __loc)
     340             :      __THROW __nonnull ((1, 3));
     341             : # endif
     342             : 
     343             : # if __HAVE_FLOAT64X
     344             : extern _Float64x strtof64x_l (const char *__restrict __nptr,
     345             :                               char **__restrict __endptr,
     346             :                               locale_t __loc)
     347             :      __THROW __nonnull ((1, 3));
     348             : # endif
     349             : 
     350             : # if __HAVE_FLOAT128X
     351             : extern _Float128x strtof128x_l (const char *__restrict __nptr,
     352             :                                 char **__restrict __endptr,
     353             :                                 locale_t __loc)
     354             :      __THROW __nonnull ((1, 3));
     355             : # endif
     356             : #endif /* GNU */
     357             : 
     358             : 
     359             : #ifdef __USE_EXTERN_INLINES
     360             : __extern_inline int
     361             : __NTH (atoi (const char *__nptr))
     362             : {
     363      144337 :   return (int) strtol (__nptr, (char **) NULL, 10);
     364             : }
     365             : __extern_inline long int
     366             : __NTH (atol (const char *__nptr))
     367             : {
     368          17 :   return strtol (__nptr, (char **) NULL, 10);
     369             : }
     370             : 
     371             : # ifdef __USE_ISOC99
     372             : __extension__ __extern_inline long long int
     373             : __NTH (atoll (const char *__nptr))
     374             : {
     375             :   return strtoll (__nptr, (char **) NULL, 10);
     376             : }
     377             : # endif
     378             : #endif /* Optimizing and Inlining.  */
     379             : 
     380             : 
     381             : #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED
     382             : /* Convert N to base 64 using the digits "./0-9A-Za-z", least-significant
     383             :    digit first.  Returns a pointer to static storage overwritten by the
     384             :    next call.  */
     385             : extern char *l64a (long int __n) __THROW __wur;
     386             : 
     387             : /* Read a number from a string S in base 64 as above.  */
     388             : extern long int a64l (const char *__s)
     389             :      __THROW __attribute_pure__ __nonnull ((1)) __wur;
     390             : 
     391             : #endif  /* Use misc || extended X/Open.  */
     392             : 
     393             : #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED
     394             : # include <sys/types.h>   /* we need int32_t... */
     395             : 
     396             : /* These are the functions that actually do things.  The `random', `srandom',
     397             :    `initstate' and `setstate' functions are those from BSD Unices.
     398             :    The `rand' and `srand' functions are required by the ANSI standard.
     399             :    We provide both interfaces to the same random number generator.  */
     400             : /* Return a random long integer between 0 and 2^31-1 inclusive.  */
     401             : extern long int random (void) __THROW;
     402             : 
     403             : /* Seed the random number generator with the given number.  */
     404             : extern void srandom (unsigned int __seed) __THROW;
     405             : 
     406             : /* Initialize the random number generator to use state buffer STATEBUF,
     407             :    of length STATELEN, and seed it with SEED.  Optimal lengths are 8, 16,
     408             :    32, 64, 128 and 256, the bigger the better; values less than 8 will
     409             :    cause an error and values greater than 256 will be rounded down.  */
     410             : extern char *initstate (unsigned int __seed, char *__statebuf,
     411             :                         size_t __statelen) __THROW __nonnull ((2));
     412             : 
     413             : /* Switch the random number generator to state buffer STATEBUF,
     414             :    which should have been previously initialized by `initstate'.  */
     415             : extern char *setstate (char *__statebuf) __THROW __nonnull ((1));
     416             : 
     417             : 
     418             : # ifdef __USE_MISC
     419             : /* Reentrant versions of the `random' family of functions.
     420             :    These functions all use the following data structure to contain
     421             :    state, rather than global state variables.  */
     422             : 
     423             : struct random_data
     424             :   {
     425             :     int32_t *fptr;              /* Front pointer.  */
     426             :     int32_t *rptr;              /* Rear pointer.  */
     427             :     int32_t *state;             /* Array of state values.  */
     428             :     int rand_type;              /* Type of random number generator.  */
     429             :     int rand_deg;               /* Degree of random number generator.  */
     430             :     int rand_sep;               /* Distance between front and rear.  */
     431             :     int32_t *end_ptr;           /* Pointer behind state table.  */
     432             :   };
     433             : 
     434             : extern int random_r (struct random_data *__restrict __buf,
     435             :                      int32_t *__restrict __result) __THROW __nonnull ((1, 2));
     436             : 
     437             : extern int srandom_r (unsigned int __seed, struct random_data *__buf)
     438             :      __THROW __nonnull ((2));
     439             : 
     440             : extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
     441             :                         size_t __statelen,
     442             :                         struct random_data *__restrict __buf)
     443             :      __THROW __nonnull ((2, 4));
     444             : 
     445             : extern int setstate_r (char *__restrict __statebuf,
     446             :                        struct random_data *__restrict __buf)
     447             :      __THROW __nonnull ((1, 2));
     448             : # endif /* Use misc.  */
     449             : #endif  /* Use extended X/Open || misc. */
     450             : 
     451             : 
     452             : /* Return a random integer between 0 and RAND_MAX inclusive.  */
     453             : extern int rand (void) __THROW;
     454             : /* Seed the random number generator with the given number.  */
     455             : extern void srand (unsigned int __seed) __THROW;
     456             : 
     457             : #ifdef __USE_POSIX199506
     458             : /* Reentrant interface according to POSIX.1.  */
     459             : extern int rand_r (unsigned int *__seed) __THROW;
     460             : #endif
     461             : 
     462             : 
     463             : #if defined __USE_MISC || defined __USE_XOPEN
     464             : /* System V style 48-bit random number generator functions.  */
     465             : 
     466             : /* Return non-negative, double-precision floating-point value in [0.0,1.0).  */
     467             : extern double drand48 (void) __THROW;
     468             : extern double erand48 (unsigned short int __xsubi[3]) __THROW __nonnull ((1));
     469             : 
     470             : /* Return non-negative, long integer in [0,2^31).  */
     471             : extern long int lrand48 (void) __THROW;
     472             : extern long int nrand48 (unsigned short int __xsubi[3])
     473             :      __THROW __nonnull ((1));
     474             : 
     475             : /* Return signed, long integers in [-2^31,2^31).  */
     476             : extern long int mrand48 (void) __THROW;
     477             : extern long int jrand48 (unsigned short int __xsubi[3])
     478             :      __THROW __nonnull ((1));
     479             : 
     480             : /* Seed random number generator.  */
     481             : extern void srand48 (long int __seedval) __THROW;
     482             : extern unsigned short int *seed48 (unsigned short int __seed16v[3])
     483             :      __THROW __nonnull ((1));
     484             : extern void lcong48 (unsigned short int __param[7]) __THROW __nonnull ((1));
     485             : 
     486             : # ifdef __USE_MISC
     487             : /* Data structure for communication with thread safe versions.  This
     488             :    type is to be regarded as opaque.  It's only exported because users
     489             :    have to allocate objects of this type.  */
     490             : struct drand48_data
     491             :   {
     492             :     unsigned short int __x[3];  /* Current state.  */
     493             :     unsigned short int __old_x[3]; /* Old state.  */
     494             :     unsigned short int __c;     /* Additive const. in congruential formula.  */
     495             :     unsigned short int __init;  /* Flag for initializing.  */
     496             :     __extension__ unsigned long long int __a;   /* Factor in congruential
     497             :                                                    formula.  */
     498             :   };
     499             : 
     500             : /* Return non-negative, double-precision floating-point value in [0.0,1.0).  */
     501             : extern int drand48_r (struct drand48_data *__restrict __buffer,
     502             :                       double *__restrict __result) __THROW __nonnull ((1, 2));
     503             : extern int erand48_r (unsigned short int __xsubi[3],
     504             :                       struct drand48_data *__restrict __buffer,
     505             :                       double *__restrict __result) __THROW __nonnull ((1, 2));
     506             : 
     507             : /* Return non-negative, long integer in [0,2^31).  */
     508             : extern int lrand48_r (struct drand48_data *__restrict __buffer,
     509             :                       long int *__restrict __result)
     510             :      __THROW __nonnull ((1, 2));
     511             : extern int nrand48_r (unsigned short int __xsubi[3],
     512             :                       struct drand48_data *__restrict __buffer,
     513             :                       long int *__restrict __result)
     514             :      __THROW __nonnull ((1, 2));
     515             : 
     516             : /* Return signed, long integers in [-2^31,2^31).  */
     517             : extern int mrand48_r (struct drand48_data *__restrict __buffer,
     518             :                       long int *__restrict __result)
     519             :      __THROW __nonnull ((1, 2));
     520             : extern int jrand48_r (unsigned short int __xsubi[3],
     521             :                       struct drand48_data *__restrict __buffer,
     522             :                       long int *__restrict __result)
     523             :      __THROW __nonnull ((1, 2));
     524             : 
     525             : /* Seed random number generator.  */
     526             : extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
     527             :      __THROW __nonnull ((2));
     528             : 
     529             : extern int seed48_r (unsigned short int __seed16v[3],
     530             :                      struct drand48_data *__buffer) __THROW __nonnull ((1, 2));
     531             : 
     532             : extern int lcong48_r (unsigned short int __param[7],
     533             :                       struct drand48_data *__buffer)
     534             :      __THROW __nonnull ((1, 2));
     535             : # endif /* Use misc.  */
     536             : #endif  /* Use misc or X/Open.  */
     537             : 
     538             : /* Allocate SIZE bytes of memory.  */
     539             : extern void *malloc (size_t __size) __THROW __attribute_malloc__
     540             :      __attribute_alloc_size__ ((1)) __wur;
     541             : /* Allocate NMEMB elements of SIZE bytes each, all initialized to 0.  */
     542             : extern void *calloc (size_t __nmemb, size_t __size)
     543             :      __THROW __attribute_malloc__ __attribute_alloc_size__ ((1, 2)) __wur;
     544             : 
     545             : /* Re-allocate the previously allocated block
     546             :    in PTR, making the new block SIZE bytes long.  */
     547             : /* __attribute_malloc__ is not used, because if realloc returns
     548             :    the same pointer that was passed to it, aliasing needs to be allowed
     549             :    between objects pointed by the old and new pointers.  */
     550             : extern void *realloc (void *__ptr, size_t __size)
     551             :      __THROW __attribute_warn_unused_result__ __attribute_alloc_size__ ((2));
     552             : 
     553             : #ifdef __USE_MISC
     554             : /* Re-allocate the previously allocated block in PTR, making the new
     555             :    block large enough for NMEMB elements of SIZE bytes each.  */
     556             : /* __attribute_malloc__ is not used, because if reallocarray returns
     557             :    the same pointer that was passed to it, aliasing needs to be allowed
     558             :    between objects pointed by the old and new pointers.  */
     559             : extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size)
     560             :      __THROW __attribute_warn_unused_result__
     561             :      __attribute_alloc_size__ ((2, 3));
     562             : #endif
     563             : 
     564             : /* Free a block allocated by `malloc', `realloc' or `calloc'.  */
     565             : extern void free (void *__ptr) __THROW;
     566             : 
     567             : #ifdef __USE_MISC
     568             : # include <alloca.h>
     569             : #endif /* Use misc.  */
     570             : 
     571             : #if (defined __USE_XOPEN_EXTENDED && !defined __USE_XOPEN2K) \
     572             :     || defined __USE_MISC
     573             : /* Allocate SIZE bytes on a page boundary.  The storage cannot be freed.  */
     574             : extern void *valloc (size_t __size) __THROW __attribute_malloc__
     575             :      __attribute_alloc_size__ ((1)) __wur;
     576             : #endif
     577             : 
     578             : #ifdef __USE_XOPEN2K
     579             : /* Allocate memory of SIZE bytes with an alignment of ALIGNMENT.  */
     580             : extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
     581             :      __THROW __nonnull ((1)) __wur;
     582             : #endif
     583             : 
     584             : #ifdef __USE_ISOC11
     585             : /* ISO C variant of aligned allocation.  */
     586             : extern void *aligned_alloc (size_t __alignment, size_t __size)
     587             :      __THROW __attribute_malloc__ __attribute_alloc_size__ ((2)) __wur;
     588             : #endif
     589             : 
     590             : /* Abort execution and generate a core-dump.  */
     591             : extern void abort (void) __THROW __attribute__ ((__noreturn__));
     592             : 
     593             : 
     594             : /* Register a function to be called when `exit' is called.  */
     595             : extern int atexit (void (*__func) (void)) __THROW __nonnull ((1));
     596             : 
     597             : #if defined __USE_ISOC11 || defined __USE_ISOCXX11
     598             : /* Register a function to be called when `quick_exit' is called.  */
     599             : # ifdef __cplusplus
     600             : extern "C++" int at_quick_exit (void (*__func) (void))
     601             :      __THROW __asm ("at_quick_exit") __nonnull ((1));
     602             : # else
     603             : extern int at_quick_exit (void (*__func) (void)) __THROW __nonnull ((1));
     604             : # endif
     605             : #endif
     606             : 
     607             : #ifdef  __USE_MISC
     608             : /* Register a function to be called with the status
     609             :    given to `exit' and the given argument.  */
     610             : extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
     611             :      __THROW __nonnull ((1));
     612             : #endif
     613             : 
     614             : /* Call all functions registered with `atexit' and `on_exit',
     615             :    in the reverse of the order in which they were registered,
     616             :    perform stdio cleanup, and terminate program execution with STATUS.  */
     617             : extern void exit (int __status) __THROW __attribute__ ((__noreturn__));
     618             : 
     619             : #if defined __USE_ISOC11 || defined __USE_ISOCXX11
     620             : /* Call all functions registered with `at_quick_exit' in the reverse
     621             :    of the order in which they were registered and terminate program
     622             :    execution with STATUS.  */
     623             : extern void quick_exit (int __status) __THROW __attribute__ ((__noreturn__));
     624             : #endif
     625             : 
     626             : #ifdef __USE_ISOC99
     627             : /* Terminate the program with STATUS without calling any of the
     628             :    functions registered with `atexit' or `on_exit'.  */
     629             : extern void _Exit (int __status) __THROW __attribute__ ((__noreturn__));
     630             : #endif
     631             : 
     632             : 
     633             : /* Return the value of envariable NAME, or NULL if it doesn't exist.  */
     634             : extern char *getenv (const char *__name) __THROW __nonnull ((1)) __wur;
     635             : 
     636             : #ifdef __USE_GNU
     637             : /* This function is similar to the above but returns NULL if the
     638             :    programs is running with SUID or SGID enabled.  */
     639             : extern char *secure_getenv (const char *__name)
     640             :      __THROW __nonnull ((1)) __wur;
     641             : #endif
     642             : 
     643             : #if defined __USE_MISC || defined __USE_XOPEN
     644             : /* The SVID says this is in <stdio.h>, but this seems a better place.     */
     645             : /* Put STRING, which is of the form "NAME=VALUE", in the environment.
     646             :    If there is no `=', remove NAME from the environment.  */
     647             : extern int putenv (char *__string) __THROW __nonnull ((1));
     648             : #endif
     649             : 
     650             : #ifdef __USE_XOPEN2K
     651             : /* Set NAME to VALUE in the environment.
     652             :    If REPLACE is nonzero, overwrite an existing value.  */
     653             : extern int setenv (const char *__name, const char *__value, int __replace)
     654             :      __THROW __nonnull ((2));
     655             : 
     656             : /* Remove the variable NAME from the environment.  */
     657             : extern int unsetenv (const char *__name) __THROW __nonnull ((1));
     658             : #endif
     659             : 
     660             : #ifdef  __USE_MISC
     661             : /* The `clearenv' was planned to be added to POSIX.1 but probably
     662             :    never made it.  Nevertheless the POSIX.9 standard (POSIX bindings
     663             :    for Fortran 77) requires this function.  */
     664             : extern int clearenv (void) __THROW;
     665             : #endif
     666             : 
     667             : 
     668             : #if defined __USE_MISC \
     669             :     || (defined __USE_XOPEN_EXTENDED && !defined __USE_XOPEN2K8)
     670             : /* Generate a unique temporary file name from TEMPLATE.
     671             :    The last six characters of TEMPLATE must be "XXXXXX";
     672             :    they are replaced with a string that makes the file name unique.
     673             :    Always returns TEMPLATE, it's either a temporary file name or a null
     674             :    string if it cannot get a unique file name.  */
     675             : extern char *mktemp (char *__template) __THROW __nonnull ((1));
     676             : #endif
     677             : 
     678             : #if defined __USE_XOPEN_EXTENDED || defined __USE_XOPEN2K8
     679             : /* Generate a unique temporary file name from TEMPLATE.
     680             :    The last six characters of TEMPLATE must be "XXXXXX";
     681             :    they are replaced with a string that makes the filename unique.
     682             :    Returns a file descriptor open on the file for reading and writing,
     683             :    or -1 if it cannot create a uniquely-named file.
     684             : 
     685             :    This function is a possible cancellation point and therefore not
     686             :    marked with __THROW.  */
     687             : # ifndef __USE_FILE_OFFSET64
     688             : extern int mkstemp (char *__template) __nonnull ((1)) __wur;
     689             : # else
     690             : #  ifdef __REDIRECT
     691             : extern int __REDIRECT (mkstemp, (char *__template), mkstemp64)
     692             :      __nonnull ((1)) __wur;
     693             : #  else
     694             : #   define mkstemp mkstemp64
     695             : #  endif
     696             : # endif
     697             : # ifdef __USE_LARGEFILE64
     698             : extern int mkstemp64 (char *__template) __nonnull ((1)) __wur;
     699             : # endif
     700             : #endif
     701             : 
     702             : #ifdef __USE_MISC
     703             : /* Similar to mkstemp, but the template can have a suffix after the
     704             :    XXXXXX.  The length of the suffix is specified in the second
     705             :    parameter.
     706             : 
     707             :    This function is a possible cancellation point and therefore not
     708             :    marked with __THROW.  */
     709             : # ifndef __USE_FILE_OFFSET64
     710             : extern int mkstemps (char *__template, int __suffixlen) __nonnull ((1)) __wur;
     711             : # else
     712             : #  ifdef __REDIRECT
     713             : extern int __REDIRECT (mkstemps, (char *__template, int __suffixlen),
     714             :                        mkstemps64) __nonnull ((1)) __wur;
     715             : #  else
     716             : #   define mkstemps mkstemps64
     717             : #  endif
     718             : # endif
     719             : # ifdef __USE_LARGEFILE64
     720             : extern int mkstemps64 (char *__template, int __suffixlen)
     721             :      __nonnull ((1)) __wur;
     722             : # endif
     723             : #endif
     724             : 
     725             : #ifdef __USE_XOPEN2K8
     726             : /* Create a unique temporary directory from TEMPLATE.
     727             :    The last six characters of TEMPLATE must be "XXXXXX";
     728             :    they are replaced with a string that makes the directory name unique.
     729             :    Returns TEMPLATE, or a null pointer if it cannot get a unique name.
     730             :    The directory is created mode 700.  */
     731             : extern char *mkdtemp (char *__template) __THROW __nonnull ((1)) __wur;
     732             : #endif
     733             : 
     734             : #ifdef __USE_GNU
     735             : /* Generate a unique temporary file name from TEMPLATE similar to
     736             :    mkstemp.  But allow the caller to pass additional flags which are
     737             :    used in the open call to create the file..
     738             : 
     739             :    This function is a possible cancellation point and therefore not
     740             :    marked with __THROW.  */
     741             : # ifndef __USE_FILE_OFFSET64
     742             : extern int mkostemp (char *__template, int __flags) __nonnull ((1)) __wur;
     743             : # else
     744             : #  ifdef __REDIRECT
     745             : extern int __REDIRECT (mkostemp, (char *__template, int __flags), mkostemp64)
     746             :      __nonnull ((1)) __wur;
     747             : #  else
     748             : #   define mkostemp mkostemp64
     749             : #  endif
     750             : # endif
     751             : # ifdef __USE_LARGEFILE64
     752             : extern int mkostemp64 (char *__template, int __flags) __nonnull ((1)) __wur;
     753             : # endif
     754             : 
     755             : /* Similar to mkostemp, but the template can have a suffix after the
     756             :    XXXXXX.  The length of the suffix is specified in the second
     757             :    parameter.
     758             : 
     759             :    This function is a possible cancellation point and therefore not
     760             :    marked with __THROW.  */
     761             : # ifndef __USE_FILE_OFFSET64
     762             : extern int mkostemps (char *__template, int __suffixlen, int __flags)
     763             :      __nonnull ((1)) __wur;
     764             : # else
     765             : #  ifdef __REDIRECT
     766             : extern int __REDIRECT (mkostemps, (char *__template, int __suffixlen,
     767             :                                    int __flags), mkostemps64)
     768             :      __nonnull ((1)) __wur;
     769             : #  else
     770             : #   define mkostemps mkostemps64
     771             : #  endif
     772             : # endif
     773             : # ifdef __USE_LARGEFILE64
     774             : extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
     775             :      __nonnull ((1)) __wur;
     776             : # endif
     777             : #endif
     778             : 
     779             : 
     780             : /* Execute the given line as a shell command.
     781             : 
     782             :    This function is a cancellation point and therefore not marked with
     783             :    __THROW.  */
     784             : extern int system (const char *__command) __wur;
     785             : 
     786             : 
     787             : #ifdef  __USE_GNU
     788             : /* Return a malloc'd string containing the canonical absolute name of the
     789             :    existing named file.  */
     790             : extern char *canonicalize_file_name (const char *__name)
     791             :      __THROW __nonnull ((1)) __wur;
     792             : #endif
     793             : 
     794             : #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED
     795             : /* Return the canonical absolute name of file NAME.  If RESOLVED is
     796             :    null, the result is malloc'd; otherwise, if the canonical name is
     797             :    PATH_MAX chars or more, returns null with `errno' set to
     798             :    ENAMETOOLONG; if the name fits in fewer than PATH_MAX chars,
     799             :    returns the name in RESOLVED.  */
     800             : extern char *realpath (const char *__restrict __name,
     801             :                        char *__restrict __resolved) __THROW __wur;
     802             : #endif
     803             : 
     804             : 
     805             : /* Shorthand for type of comparison functions.  */
     806             : #ifndef __COMPAR_FN_T
     807             : # define __COMPAR_FN_T
     808             : typedef int (*__compar_fn_t) (const void *, const void *);
     809             : 
     810             : # ifdef __USE_GNU
     811             : typedef __compar_fn_t comparison_fn_t;
     812             : # endif
     813             : #endif
     814             : #ifdef __USE_GNU
     815             : typedef int (*__compar_d_fn_t) (const void *, const void *, void *);
     816             : #endif
     817             : 
     818             : /* Do a binary search for KEY in BASE, which consists of NMEMB elements
     819             :    of SIZE bytes each, using COMPAR to perform the comparisons.  */
     820             : extern void *bsearch (const void *__key, const void *__base,
     821             :                       size_t __nmemb, size_t __size, __compar_fn_t __compar)
     822             :      __nonnull ((1, 2, 5)) __wur;
     823             : 
     824             : #ifdef __USE_EXTERN_INLINES
     825             : # include <bits/stdlib-bsearch.h>
     826             : #endif
     827             : 
     828             : /* Sort NMEMB elements of BASE, of SIZE bytes each,
     829             :    using COMPAR to perform the comparisons.  */
     830             : extern void qsort (void *__base, size_t __nmemb, size_t __size,
     831             :                    __compar_fn_t __compar) __nonnull ((1, 4));
     832             : #ifdef __USE_GNU
     833             : extern void qsort_r (void *__base, size_t __nmemb, size_t __size,
     834             :                      __compar_d_fn_t __compar, void *__arg)
     835             :   __nonnull ((1, 4));
     836             : #endif
     837             : 
     838             : 
     839             : /* Return the absolute value of X.  */
     840             : extern int abs (int __x) __THROW __attribute__ ((__const__)) __wur;
     841             : extern long int labs (long int __x) __THROW __attribute__ ((__const__)) __wur;
     842             : 
     843             : #ifdef __USE_ISOC99
     844             : __extension__ extern long long int llabs (long long int __x)
     845             :      __THROW __attribute__ ((__const__)) __wur;
     846             : #endif
     847             : 
     848             : 
     849             : /* Return the `div_t', `ldiv_t' or `lldiv_t' representation
     850             :    of the value of NUMER over DENOM. */
     851             : /* GCC may have built-ins for these someday.  */
     852             : extern div_t div (int __numer, int __denom)
     853             :      __THROW __attribute__ ((__const__)) __wur;
     854             : extern ldiv_t ldiv (long int __numer, long int __denom)
     855             :      __THROW __attribute__ ((__const__)) __wur;
     856             : 
     857             : #ifdef __USE_ISOC99
     858             : __extension__ extern lldiv_t lldiv (long long int __numer,
     859             :                                     long long int __denom)
     860             :      __THROW __attribute__ ((__const__)) __wur;
     861             : #endif
     862             : 
     863             : 
     864             : #if (defined __USE_XOPEN_EXTENDED && !defined __USE_XOPEN2K8) \
     865             :     || defined __USE_MISC
     866             : /* Convert floating point numbers to strings.  The returned values are
     867             :    valid only until another call to the same function.  */
     868             : 
     869             : /* Convert VALUE to a string with NDIGIT digits and return a pointer to
     870             :    this.  Set *DECPT with the position of the decimal character and *SIGN
     871             :    with the sign of the number.  */
     872             : extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
     873             :                    int *__restrict __sign) __THROW __nonnull ((3, 4)) __wur;
     874             : 
     875             : /* Convert VALUE to a string rounded to NDIGIT decimal digits.  Set *DECPT
     876             :    with the position of the decimal character and *SIGN with the sign of
     877             :    the number.  */
     878             : extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
     879             :                    int *__restrict __sign) __THROW __nonnull ((3, 4)) __wur;
     880             : 
     881             : /* If possible convert VALUE to a string with NDIGIT significant digits.
     882             :    Otherwise use exponential representation.  The resulting string will
     883             :    be written to BUF.  */
     884             : extern char *gcvt (double __value, int __ndigit, char *__buf)
     885             :      __THROW __nonnull ((3)) __wur;
     886             : #endif
     887             : 
     888             : #ifdef __USE_MISC
     889             : /* Long double versions of above functions.  */
     890             : extern char *qecvt (long double __value, int __ndigit,
     891             :                     int *__restrict __decpt, int *__restrict __sign)
     892             :      __THROW __nonnull ((3, 4)) __wur;
     893             : extern char *qfcvt (long double __value, int __ndigit,
     894             :                     int *__restrict __decpt, int *__restrict __sign)
     895             :      __THROW __nonnull ((3, 4)) __wur;
     896             : extern char *qgcvt (long double __value, int __ndigit, char *__buf)
     897             :      __THROW __nonnull ((3)) __wur;
     898             : 
     899             : 
     900             : /* Reentrant version of the functions above which provide their own
     901             :    buffers.  */
     902             : extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
     903             :                    int *__restrict __sign, char *__restrict __buf,
     904             :                    size_t __len) __THROW __nonnull ((3, 4, 5));
     905             : extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
     906             :                    int *__restrict __sign, char *__restrict __buf,
     907             :                    size_t __len) __THROW __nonnull ((3, 4, 5));
     908             : 
     909             : extern int qecvt_r (long double __value, int __ndigit,
     910             :                     int *__restrict __decpt, int *__restrict __sign,
     911             :                     char *__restrict __buf, size_t __len)
     912             :      __THROW __nonnull ((3, 4, 5));
     913             : extern int qfcvt_r (long double __value, int __ndigit,
     914             :                     int *__restrict __decpt, int *__restrict __sign,
     915             :                     char *__restrict __buf, size_t __len)
     916             :      __THROW __nonnull ((3, 4, 5));
     917             : #endif  /* misc */
     918             : 
     919             : 
     920             : /* Return the length of the multibyte character
     921             :    in S, which is no longer than N.  */
     922             : extern int mblen (const char *__s, size_t __n) __THROW;
     923             : /* Return the length of the given multibyte character,
     924             :    putting its `wchar_t' representation in *PWC.  */
     925             : extern int mbtowc (wchar_t *__restrict __pwc,
     926             :                    const char *__restrict __s, size_t __n) __THROW;
     927             : /* Put the multibyte character represented
     928             :    by WCHAR in S, returning its length.  */
     929             : extern int wctomb (char *__s, wchar_t __wchar) __THROW;
     930             : 
     931             : 
     932             : /* Convert a multibyte string to a wide char string.  */
     933             : extern size_t mbstowcs (wchar_t *__restrict  __pwcs,
     934             :                         const char *__restrict __s, size_t __n) __THROW
     935             :     __attr_access ((__read_only__, 2));
     936             : /* Convert a wide char string to multibyte string.  */
     937             : extern size_t wcstombs (char *__restrict __s,
     938             :                         const wchar_t *__restrict __pwcs, size_t __n)
     939             :      __THROW
     940             :   __attr_access ((__write_only__, 1, 3)) __attr_access ((__read_only__, 2));
     941             : 
     942             : #ifdef __USE_MISC
     943             : /* Determine whether the string value of RESPONSE matches the affirmation
     944             :    or negative response expression as specified by the LC_MESSAGES category
     945             :    in the program's current locale.  Returns 1 if affirmative, 0 if
     946             :    negative, and -1 if not matching.  */
     947             : extern int rpmatch (const char *__response) __THROW __nonnull ((1)) __wur;
     948             : #endif
     949             : 
     950             : 
     951             : #if defined __USE_XOPEN_EXTENDED || defined __USE_XOPEN2K8
     952             : /* Parse comma separated suboption from *OPTIONP and match against
     953             :    strings in TOKENS.  If found return index and set *VALUEP to
     954             :    optional value introduced by an equal sign.  If the suboption is
     955             :    not part of TOKENS return in *VALUEP beginning of unknown
     956             :    suboption.  On exit *OPTIONP is set to the beginning of the next
     957             :    token or at the terminating NUL character.  */
     958             : extern int getsubopt (char **__restrict __optionp,
     959             :                       char *const *__restrict __tokens,
     960             :                       char **__restrict __valuep)
     961             :      __THROW __nonnull ((1, 2, 3)) __wur;
     962             : #endif
     963             : 
     964             : 
     965             : /* X/Open pseudo terminal handling.  */
     966             : 
     967             : #ifdef __USE_XOPEN2KXSI
     968             : /* Return a master pseudo-terminal handle.  */
     969             : extern int posix_openpt (int __oflag) __wur;
     970             : #endif
     971             : 
     972             : #ifdef __USE_XOPEN_EXTENDED
     973             : /* The next four functions all take a master pseudo-tty fd and
     974             :    perform an operation on the associated slave:  */
     975             : 
     976             : /* Chown the slave to the calling user.  */
     977             : extern int grantpt (int __fd) __THROW;
     978             : 
     979             : /* Release an internal lock so the slave can be opened.
     980             :    Call after grantpt().  */
     981             : extern int unlockpt (int __fd) __THROW;
     982             : 
     983             : /* Return the pathname of the pseudo terminal slave associated with
     984             :    the master FD is open on, or NULL on errors.
     985             :    The returned storage is good until the next call to this function.  */
     986             : extern char *ptsname (int __fd) __THROW __wur;
     987             : #endif
     988             : 
     989             : #ifdef __USE_GNU
     990             : /* Store at most BUFLEN characters of the pathname of the slave pseudo
     991             :    terminal associated with the master FD is open on in BUF.
     992             :    Return 0 on success, otherwise an error number.  */
     993             : extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
     994             :      __THROW __nonnull ((2)) __attr_access ((__write_only__, 2, 3));
     995             : 
     996             : /* Open a master pseudo terminal and return its file descriptor.  */
     997             : extern int getpt (void);
     998             : #endif
     999             : 
    1000             : #ifdef __USE_MISC
    1001             : /* Put the 1 minute, 5 minute and 15 minute load averages into the first
    1002             :    NELEM elements of LOADAVG.  Return the number written (never more than
    1003             :    three, but may be less than NELEM), or -1 if an error occurred.  */
    1004             : extern int getloadavg (double __loadavg[], int __nelem)
    1005             :      __THROW __nonnull ((1));
    1006             : #endif
    1007             : 
    1008             : #if defined __USE_XOPEN_EXTENDED && !defined __USE_XOPEN2K
    1009             : /* Return the index into the active-logins file (utmp) for
    1010             :    the controlling terminal.  */
    1011             : extern int ttyslot (void) __THROW;
    1012             : #endif
    1013             : 
    1014             : #include <bits/stdlib-float.h>
    1015             : 
    1016             : /* Define some macros helping to catch buffer overflows.  */
    1017             : #if __USE_FORTIFY_LEVEL > 0 && defined __fortify_function
    1018             : # include <bits/stdlib.h>
    1019             : #endif
    1020             : 
    1021             : #include <bits/floatn.h>
    1022             : #if defined __LDBL_COMPAT || __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1
    1023             : # include <bits/stdlib-ldbl.h>
    1024             : #endif
    1025             : 
    1026             : __END_DECLS
    1027             : 
    1028             : #endif /* stdlib.h  */

Generated by: LCOV version 1.14