%assert
Defined in:   assert.h
Prototype:    assert(int expression)
Summary:      if expression is FALSE, exits with diagnostic message

%imaginary
Defined in:   complex.h
Definition:   #define imaginary    _Imaginary
Summary:      a program may undefine and perhaps then redefine the macro
              imaginary

%complex
Defined in:   complex.h
Definition:   #define complex      _Complex
Summary:      a program may undefine and perhaps then redefine the macro
              complex

%_Imaginary_I
Defined in:   complex.h
Definition:   #define _Imaginary_I ___i
Summary:      a constant expression of type const float _Imaginary, with the
              value of the imaginary unit

%_Complex_I
Defined in:   complex.h
Definition:   #define _Complex_I   (0.0F+___i)
Summary:      a constant expression of type const float _Complex, with 
              the value of the imaginary unit

%I
Defined in:   complex.h
Definition:   #define I            _Imaginary_I
Summary:      I is imaginary. On an implementation without imaginary types, I 
              would expand to _Complex_I
              a program may undefine and perhaps then redefine the macro I

%cacos
Defined in:   complex.h
Prototype:    double complex cacos(double complex /*z*/)
Summary:      computes the complex arc cosine of z, with branch cuts outside
              the interval [-1,+1] along the real axis

%cacosf
Defined in:   complex.h
Prototype:    float complex cacosf(float complex /*z*/)
Summary:      computes the complex arc cosine of z, with branch cuts outside
              the interval [-1,+1] along the real axis

%cacosl
Defined in:   complex.h
Prototype:    long double complex cacosl(long double complex /*z*/)
Summary:      computes the complex arc cosine of z, with branch cuts outside
              the interval [-1,+1] along the real axis

%casin
Defined in:   complex.h
Prototype:    double complex casin(double complex /*z*/)
Summary:      computes the complex arc sine of z, with branch cuts outside the
              interval [-1,+1] along the real axis

%casinf
Defined in:   complex.h
Prototype:    float complex casinf(float complex /*z*/);
Summary:      computes the complex arc sine of z, with branch cuts outside the
              interval [-1,+1] along the real axis

%casinl
Defined in:   complex.h
Prototype:    long double complex casinl(long double complex /*z*/)
Summary:      computes the complex arc sine of z, with branch cuts outside the
              interval [-1,+1] along the real axis

%catan
Defined in:   complex.h
Prototype:    double complex catan(double complex /*z*/)
Summary:      computes the complex arc tangent of z, with branch cuts outside
              the interval [-i,+i] along the imaginary axis

%catanf
Defined in:   complex.h
Prototype:    float complex catanf(float complex /*z*/)
Summary:      computes the complex arc tangent of z, with branch cuts outside
              the interval [-i,+i] along the imaginary axis

%catanl
Defined in:   complex.h
Prototype:    long double complex catanl(long double complex /*z*/)
Summary:      computes the complex arc tangent of z, with branch cuts outside
              the interval [-i,+i] along the imaginary axis

%ccos
Defined in:   complex.h
Prototype:    double complex ccos(double complex /*z*/)
Summary:      computes the complex cosine of z

%ccosf
Defined in:   complex.h
Prototype:    float complex ccosf(float complex /*z*/)
Summary:      computes the complex cosine of z

%ccosl
Defined in:   complex.h
Prototype:    long double complex ccosl(long double complex /*z*/);
Summary:      computes the complex cosine of z

%csin
Defined in:   complex.h
Prototype:    double complex csin(double complex /*z*/)
Summary:      computes the complex sine of z

%csinf
Defined in:   complex.h
Prototype:    float complex csinf(float complex /*z*/);
Summary:      computes the complex sine of z

%csinl
Defined in:   complex.h
Prototype:    long double complex csinl(long double complex /*z*/)
Summary:      computes the complex sine of z

%ctan
Defined in:   complex.h
Prototype:    double complex ctan(double complex /*z*/);
Summary:      computes the complex tangent of z

%ctanf
Defined in:   complex.h
Prototype:    float complex ctanf(float complex /*z*/);
Summary:      computes the complex tangent of z

%ctanl
Defined in:   complex.h
Prototype:    long double complex ctanl(long double complex /*z*/);
Summary:      computes the complex tangent of z

%cacosh
Defined in:   complex.h
Prototype:    double complex cacosh(double complex /*z*/)
Summary:      computes the complex arc hyperbolic cosine of z, with a branch
              cut at values less than 1 along the real axis

%cacoshf
Defined in:   complex.h
Prototype:    float complex cacoshf(float complex /*z*/)
Summary:      computes the complex arc hyperbolic cosine of z, with a branch
              cut at values less than 1 along the real axis

%cacoshl
Defined in:   complex.h
Prototype:    long double complex cacoshl(long double complex /*z*/)
Summary:      computes the complex arc hyperbolic cosine of z, with a branch
              cut at values less than 1 along the real axis

%casinh
Defined in:   complex.h
Prototype:    double complex casinh(double complex /*z*/)
Summary:      computes the complex arc hyperbolic sine of z, with branch cuts 
              outside the interval [-i,+i] along the imaginary axis

%casinhf
Defined in:   complex.h
Prototype:    float complex casinhf(float complex /*z*/)
Summary:      computes the complex arc hyperbolic sine of z, with branch cuts 
              outside the interval [-i,+i] along the imaginary axis

%casinhl
Defined in:   complex.h
Prototype:    long double complex casinhl(long double complex /*z*/);
Summary:      computes the complex arc hyperbolic sine of z, with branch cuts 
              outside the interval [-i,+i] along the imaginary axis

%catanh
Defined in:   complex.h
Prototype:    double complex catanh(double complex /*z*/)
Summary:      computes the complex arc hyperbolic tangent of z, with branch
              cuts outside the interval [-1,+1] along the real axis

%catanhf
Defined in:   complex.h
Prototype:    float complex catanhf(float complex /*z*/);
Summary:      computes the complex arc hyperbolic tangent of z, with branch
              cuts outside the interval [-1,+1] along the real axis

%catanhl
Defined in:   complex.h
Prototype:    long double complex catanhl(long double complex /*z*/)
Summary:      computes the complex arc hyperbolic tangent of z, with branch
              cuts outside the interval [-1,+1] along the real axis

%ccosh
Defined in:   complex.h
Prototype:    double complex ccosh(double complex /*z*/)
Summary:      computes the complex hyperbolic cosine of z

%ccoshf
Defined in:   complex.h
Prototype:    float complex ccoshf(float complex /*z*/)
Summary:      computes the complex hyperbolic cosine of z

%ccoshl
Defined in:   complex.h
Prototype:    long double complex ccoshl(long double complex /*z*/)
Summary:      computes the complex hyperbolic cosine of z

%csinh
Defined in:   complex.h
Prototype:    double complex csinh(double complex /*z*/)
Summary:      computes the complex hyperbolic sine of z

%csinhf
Defined in:   complex.h
Prototype:    float complex csinhf(float complex /*z*/)
Summary:      computes the complex hyperbolic sine of z

%csinhl
Defined in:   complex.h
Prototype:    long double complex csinhl(long double complex /*z*/)
Summary:      computes the complex hyperbolic sine of z

%ctanh
Defined in:   complex.h
Prototype:    double complex ctanh(double complex /*z*/)
Summary:      computes the complex hyperbolic tangent of z

%ctanhf
Defined in:   complex.h
Prototype:    float complex ctanhf(float complex /*z*/)
Summary:      computes the complex hyperbolic tangent of z

%ctanhl
Defined in:   complex.h
Prototype:    long double complex ctanhl(long double complex /*z*/)
Summary:      computes the complex hyperbolic tangent of z

%cexp
Defined in:   complex.h
Prototype:    double complex cexp(double complex /*z*/);
Summary:      computes the complex base-e exponential of z

%cexpf
Defined in:   complex.h
Prototype:    float complex cexpf(float complex /*z*/)
Summary:      computes the complex base-e exponential of z

%cexpl
Defined in:   complex.h
Prototype:    long double complex cexpl(long double complex /*z*/)
Summary:      computes the complex base-e exponential of z

%clog
Defined in:   complex.h
Prototype:    double complex clog(double complex /*z*/);
Summary:      computes the complex natural (base-e) logarithm of z, with a
              branch cut along the negative real axis

%clogf
Defined in:   complex.h
Prototype:    float complex clogf(float complex /*z*/);
Summary:      computes the complex natural (base-e) logarithm of z, with a
              branch cut along the negative real axis

%clogl
Defined in:   complex.h
Prototype:    long double complex clogl(long double complex /*z*/)
Summary:      computes the complex natural (base-e) logarithm of z, with a
              branch cut along the negative real axis

%cabs
Defined in:   complex.h
Prototype:    double cabs(double complex /*z*/)
Summary:      computes the complex absolute value (also called norm, modulus,
              or magnitude) of z

%cabsf
Defined in:   complex.h
Prototype:    float cabsf(float complex /*z*/);
Summary:      computes the complex absolute value (also called norm, modulus,
              or magnitude) of z

%cabsl
Defined in:   complex.h
Prototype:    long double cabsl(long double complex /*z*/)
Summary:      computes the complex absolute value (also called norm, modulus,
              or magnitude) of z

%cpow
Defined in:   complex.h
Prototype:    double complex cpow(double complex /*x*/, double complex /*y*/);
Summary:      computes the complex power function x^y, with a branch cut for
              the first parameter along the negative real axis

%cpowf
Defined in:   complex.h
Prototype:    float complex cpowf(float complex /*x*/, float complex /*y*/);
Summary:      computes the complex power function x^y, with a branch cut for
              the first parameter along the negative real axis


%cpowl
Defined in:   complex.h
Prototype:    long double complex cpowl(long double complex /*x*/,
                                        long double complex /*y*/);
Summary:      computes the complex power function x^y, with a branch cut for
              the first parameter along the negative real axis

%csqrt
Defined in:   complex.h
Prototype:    double complex csqrt(double complex /*z*/)
Summary:      computes the complex square root of z, with a branch cut along
              the negative real axis

%csqrtf
Defined in:   complex.h
Prototype:    float complex csqrtf(float complex /*z*/);
Summary:      computes the complex square root of z, with a branch cut along
              the negative real axis

%csqrtl
Defined in:   complex.h
Prototype:    long double complex csqrtl(long double complex /*z*/);
Summary:      computes the complex square root of z, with a branch cut along
              the negative real axis

%carg
Defined in:   complex.h
Prototype:    double carg(double complex /*z*/);
Summary:      computes the argument (also called phase angle) of z, with a 
              branch cut along the negative real axis

%cargf
Defined in:   complex.h
Prototype:    float cargf(float complex /*z*/)
Summary:      computes the argument (also called phase angle) of z, with a 
              branch cut along the negative real axis

%cargl
Defined in:   complex.h
Prototype:    long double cargl(long double complex /*z*/)
Summary:      computes the argument (also called phase angle) of z, with a 
              branch cut along the negative real axis

%cimag
Defined in:   complex.h
Prototype:    double cimag(double complex /*z*/);
Definition:   #define cimag(z) ((void) sizeof cimag(z),\
                                (double _Imaginary)(z)/_Imaginary_I)
Summary:      computes the imaginary part of z

%cimagf
Defined in:   complex.h
Prototype:    float cimagf(float complex /*z*/)
Definition:   #define cimagf(z) ((void) sizeof cimagf(z), \
                                 (float _Imaginary)(z)/_Imaginary_I)
Summary:      computes the imaginary part of z

%cimagl
Defined in:   complex.h
Prototype:    long double cimagl(long double complex /*z*/);
Definition:   #define cimagl(z) ((void) sizeof cimagl(z), \
                                 (long double _Imaginary)(z)/_Imaginary_I)
Summary:      computes the imaginary part of z

%conj
Defined in:   complex.h
Prototype:    double complex conj(double complex /*z*/)
Definition:   #define conj(z) ((void) sizeof conj(z), \
                               __conj (double _Complex)(z)) 
Summary:      computes the complex conjugate of z, by reversing the sign of its 
              imaginary part 

%conjf
Defined in:   complex.h
Prototype:    float complex conjf(float complex /*z*/)
Definition:   #define conjf(z) ((void) sizeof conjf(z), \
                                __conj (float _Complex)(z))
Summary:      computes the complex conjugate of z, by reversing the sign of its 
              imaginary part 

%conjl
Defined in:   complex.h
Prototype:    long double complex conjl(long double complex /*z*/);
Definition:   #define conjl(z) ((void) sizeof conjl(z), \
                                    __conj (long double _Complex)(z))
Summary:      computes the complex conjugate of z, by reversing the sign of its 
              imaginary part 

%cproj
Defined in:   complex.h
Prototype:    double complex cproj(double complex /*z*/)
Summary:      computes a projection of z onto the Riemann sphere: z projects 
              to z except that all complex infinities (even those with one
              infinite part and one NaN part) project to positive infinity on
              the real axis. If z has an infinite part, then cproj(z) is
              equivalent to INFINITY + I * copysign(0.0, cimag(z)

%cprojf
Defined in:   complex.h
Prototype:    float complex cprojf(float complex /*z*/)
Summary:      computes a projection of z onto the Riemann sphere: z projects 
              to z except that all complex infinities (even those with one
              infinite part and one NaN part) project to positive infinity on
              the real axis. If z has an infinite part, then cproj(z) is
              equivalent to INFINITY + I * copysign(0.0, cimag(z)

%cprojl
Defined in:   complex.h
Prototype:    long double complex cprojl(long double complex /*z*/)
Summary:      computes a projection of z onto the Riemann sphere: z projects 
              to z except that all complex infinities (even those with one
              infinite part and one NaN part) project to positive infinity on
              the real axis. If z has an infinite part, then cproj(z) is
              equivalent to INFINITY + I * copysign(0.0, cimag(z)

%creal
Defined in:   complex.h
Prototype:    double creal(double complex /*z*/)
Definition:   #define creal(z) ((void) sizeof creal(z), (double)(z))
Summary:      computes the real part of z

%crealf
Defined in:   complex.h
Prototype:    float crealf(float complex /*z*/);
Definition:   #define crealf(z) ((void) sizeof crealf(z), (float)(z))
Summary:      computes the real part of z

%creall
Defined in:   complex.h
Prototype:    long double creall(long double complex /*z*/)
Definition:   #define creall(z) ((void) sizeof creall(z), (long double)(z))
Summary:      computes the real part of z

%isalnum
Defined in:   ctype.h
Prototype:    int isalnum(int c)
Summary:      returns non-0 iff c is alphabetic or numeric

%isalpha
Defined in:   ctype.h
Prototype:    int isalpha(int c)
Summary:      returns non-0 iff c is alphabetic

%isblank
Defined in:   ctype.h
Prototype:    int isblank(int c)
Summary:      returns non-0 iff c is any character that is a standard
              blank character for separating words in a line of text

%iscntrl
Defined in:   ctype.h
Prototype:    int iscntrl(int c)
Summary:      returns non-0 iff c is a control character
              this means (c < ' ') || (c > '~') in the ASCII locale

%isdigit
Defined in:   ctype.h
Prototype:    int isdigit(int c)
Summary:      returns non-0 iff c is a decimal digit

%isgraph
Defined in:   ctype.h
Prototype:    int isgraph(int c)
Summary:      returns non-0 iff c is any printing character other than ' '

%islower
Defined in:   ctype.h
Prototype:    int islower(int c)
Summary:      returns non-0 iff c is a lower-case letter

%isprint
Defined in:   ctype.h
Prototype:    int isprint(int c)
Summary:      returns non-0 iff c is a printing character
              this means 0x20 (space) -> 0x7E (tilde) in the ASCII locale

%ispunct
Defined in:   ctype.h
Prototype:    int ispunct(int c)
Summary:      returns non-0 iff c is a non-space, non-alpha-numeric, 
              printing character

%isspace
Defined in:   ctype.h
Prototype:    int isspace(int c)
Summary:      returns non-0 iff c is a white-space char
              ie ' ', '\f', '\n', '\r', '\t', '\v'.

%isupper
Defined in:   ctype.h
Prototype:    int isupper(int c)
Summary:      returns non-0 iff c is an upper-case letter

%isxdigit
Defined in:   ctype.h
Prototype:    int isxdigit(int c)
Summary:      returns non-0 iff c is a digit, in 'a'..'f', or in 'A'..'F'

%tolower
Defined in:   ctype.h
Prototype:    int tolower(int c)
Summary:      if c is an upper-case letter then return the corresponding
              lower-case letter, otherwise return c.

%toupper
Defined in:   ctype.h
Prototype:    int toupper(int c)
Summary:      if c is a lower-case letter then return the corresponding
              upper-case letter, otherwise return c.

%errno
Defined in:   errno.h
Declaration:  extern volatile int errno
Summary:      Set by several library functions for error conditions

%EDOM
Defined in:   errno.h
Definition:   #define EDOM      1
Summary:      Value taken by errno to indicate domain error

%ERANGE              
Defined in:   errno.h
Definition:   #define ERANGE    2
Summary:      Value taken by errno to indicate range error

%ESIGNUM                
Defined in:   errno.h
Definition:   #define ESIGNUM   3
Summary:      Value taken by errno to indicate signal

%EILSEQ
Defined in:   errno.h
Definition:   #define EILSEQ    4
Summary:      Value taken by errno to indicate an illegal sequence error
              indicates that a multibyte character encoding

%EOVERFLOW
Defined in:   errno.h
Definition:   #define EOVERFLOW 5
Summary:      Value taken by errno to indicate one or more fields of
              a data structure is not large enough to hold the values
              required

%EFBIG
Defined in:   errno.h
Definition:   #define EFBIG     6
Summary:      Value taken by errno to indicate a file operation would
              have resulted in a write occurring at or beyond the
              maximum file pointer for this file descriptor signal

%fenv_t
Defined in:   fenv.h
Definition:   typedef struct fenv_t
Summary:      represents the entire floating-point environment

%fexcept_t
Defined in:   fenv.h
Definition:   typedef unsigned int fexcept_t;
Summary:      represents the floating-point status flags collectively

%FE_INVALID   
Defined in:   fenv.h
Summary:      represents a floating point exception status

%FE_DIVBYZERO
Defined in:   fenv.h
Summary:      represents a floating point exception status

%FE_OVERFLOW
Defined in:   fenv.h
Summary:      represents a floating point exception status

%FE_UNDERFLOW
Defined in:   fenv.h
Summary:      represents a floating point exception status

%FE_INEXACT
Defined in:   fenv.h
Summary:      represents a floating point exception status

%FE_ALL_EXCEPT
Defined in:   fenv.h
Summary:      represents all possible floating point exception status flags

%FE_TONEAREST
Defined in:   fenv.h
Summary:      a constant to determine the rounding direction

%FE_DFL_ENV
Defined in:   fenv.h
Summary:      represents the default floating-point environment - the
              one installed at program startup. It can be used as an argument
              to <fenv.h> functions that manage the floating point environment.

%feclearexcept
Defined in:   fenv.h
Prototype:    int feclearexcept(int /*excepts*/)
Summary:      attempts to clear the supported floating-point exceptions
              represented by its argument, returning zero if all the
              specified exceptions were successfully cleared.

%fegetexceptflag
Defined in:   fenv.h
Prototype:    int fegetexceptflag(fexcept_t */*flagp*/, int /*excepts*/)
Summary:      attempts to store an implementation-defined representation of
              the states of the floating-point status flags indicated by the
              argument excepts in the object pointed to by the argument flagp,
              returning zero if the representation was successfully stored.

%feraiseexcept
Defined in:   fenv.h
Prototype:    int feraiseexcept(int /*excepts*/)
Summary:      attempts to raise the supported floating-point exceptions
              represented by its argument, returning zero if all the specified
              exceptions were successfully raised.

%fesetexceptflag
Defined in:   fenv.h
Prototype:    int fesetexceptflag(const fexcept_t */*flagp*/, int /*excepts*/)
Summary:      attempts to set the floating-point status flags indicated by
              the argument excepts to the states stored in the object pointed
              to by flagp, returning zero if all the specified flags were
              successfully set to the appropriate state.

%fetestexcept
Defined in:   fenv.h
Prototype:    int fetestexcept(int /*excepts*/)
Summary:      determines which of a specified subset of the floating-point
              exception flags are currently set. The excepts argument
              specifies the floating-point status flags to be queried,
              returning the value of the bitwise OR of the floating-point
              exception status bits.

%fegetround
Defined in:   fenv.h
Prototype:    int fegetround(void)
Summary:      gets the current rounding direction.

%fesetround
Defined in:   fenv.h
Prototype:    int fesetround(int /*round*/)
Summary:      establishes the rounding direction represented by its argument
              round.

%fegetenv
Defined in:   fenv.h
Prototype:    int fegetenv(fenv_t */*envp*/)
Summary:      attempts to store the current floating-point environment in the
              object pointed to by envp, returning zero zero if the
              environment was successfully stored.

%feholdexcept
Defined in:   fenv.h
Prototype:    int feholdexcept(fenv_t */*envp*/)
Summary:      saves the current floating-point environment in the object
              pointed to by envp, clears the floating-point status flags, and
              then installs a non-stop (continue on floating-point exceptions)
              mode for all floating-point exceptions, returning zero iff
              non-stop floating-point exception handling was successfully
              installed.

%fesetenv
Defined in:   fenv.h
Prototype:    int fesetenv(const fenv_t */*envp*/)
Summary:      attempts to establish the floating-point environment
              represented by the object pointed to by envp, returning zero
              if the environment was successfully established.

%feupdateenv
Defined in:   fenv.h
Prototype:    int feupdateenv(const fenv_t */*envp*/)
Summary:      attempts to save the currently raised floating-point exceptions
              in its automatic storage, install the floating-point environment
              represented by the object pointed to by envp, and then raise
              the saved floating-point exceptions, returning zero if all
              the actions were successfully carried out.

%FLT_RADIX
Defined in:   float.h
Definition:   #define FLT_RADIX     2
Summary:      radix of exponent representation

%FLT_ROUNDS
Defined in:   float.h
Definition:   #define FLT_ROUNDS    1
Summary:      The rounding mode for floating-point addition (to nearest).

%FLT_MANT_DIG
Defined in:   float.h
Definition:   #define FLT_MANT_DIG        24
Summary:      number of base-FLT_RADIX digits in the floating point mantissa
              for floats

%DBL_MANT_DIG
Defined in:   float.h
Definition:   #define DBL_MANT_DIG        53
Summary:      number of base-FLT_RADIX digits in the floating point mantissa
              for doubles

%LDBL_MANT_DIG
Defined in:   float.h
Definition:   #define LDBL_MANT_DIG        53
Summary:      number of base-FLT_RADIX digits in the floating point mantissa
              for long doubles

%FLT_DIG
Defined in:   float.h
Definition:   #define FLT_DIG      6
Summary:      number of decimal digits of precision for floats

%DBL_DIG
Defined in:   float.h
Definition:   #define DBL_DIG      15
Summary:      number of decimal digits of precision for doubles

%LDBL_DIG
Defined in:   float.h
Definition:   #define LDBL_DIG      15
Summary:      number of decimal digits of precision for long doubles

%FLT_MIN_EXP
Defined in:   float.h
Definition:   #define FLT_MIN_EXP  (-125)
Summary:      minimum negative integer such that FLT_RADIX raised to that 
              power minus 1 is a normalised floating-point number, for floats

%DBL_MIN_EXP
Defined in:   float.h
Definition:   #define DBL_MIN_EXP  (-1021)
Summary:      minimum negative integer such that FLT_RADIX raised to that 
              power minus 1 is a normalised floating-point number, for 
              doubles

%LDBL_MIN_EXP
Defined in:   float.h
Definition:   #define LDBL_MIN_EXP  (-1021)
Summary:      minimum negative integer such that FLT_RADIX raised to that 
              power minus 1 is a normalised floating-point number, for long 
              doubles

%FLT_MIN_10_EXP
Defined in:   float.h
Definition:   #define FLT_MIN_10_EXP  (-37)
Summary:      minimum negative integer such that 10 raised to that 
              power minus 1 is a normalised floating-point number, for floats

%DBL_MIN_10_EXP
Defined in:   float.h
Definition:   #define DBL_MIN_10_EXP  (-307)
Summary:      minimum negative integer such that 10 raised to that 
              power minus 1 is a normalised floating-point number, for 
              doubles

%LDBL_MIN_10_EXP
Defined in:   float.h
Definition:   #define LDBL_MIN_10_EXP  (-307)
Summary:      minimum negative integer such that 10 raised to that 
              power minus 1 is a normalised floating-point number, for long 
              doubles

%FLT_MAX_EXP
Defined in:   float.h
Definition:   #define FLT_MAX_EXP  (128)
Summary:      maximum integer such that FLT_RADIX raised to that power 
              minus 1 is a representable finite floating-point number, for 
              floats

%DBL_MAX_EXP
Defined in:   float.h
Definition:   #define DBL_MAX_EXP  (1024)
Summary:      maximum integer such that FLT_RADIX raised to that power 
              minus 1 is a representable finite floating-point number, for 
              doubles

%LDBL_MAX_EXP
Defined in:   float.h
Definition:   #define LDBL_MAX_EXP  (1024)
Summary:      maximum integer such that FLT_RADIX raised to that power 
              minus 1 is a representable finite floating-point number, for 
              long doubles

%FLT_MAX_10_EXP
Defined in:   float.h
Definition:   #define FLT_MAX_10_EXP  (38)
Summary:      maximum integer such that 10 raised to that power is in the 
              range of representable finite floating-point numbers, for 
              floats

%DBL_MAX_10_EXP
Defined in:   float.h
Definition:   #define DBL_MAX_10_EXP  (308)
Summary:      maximum integer such that 10 raised to that power is in the 
              range of representable finite floating-point numbers, for 
              doubles

%LDBL_MAX_10_EXP
Defined in:   float.h
Definition:   #define LDBL_MAX_10_EXP  (308)
Summary:      maximum integer such that 10 raised to that power is in the 
              range of representable finite floating-point numbers, for long 
              doubles

%FLT_MAX
Defined in:   float.h
Definition:   #define FLT_MAX  3.40282347e+38F
Summary:      maximum representable finite floating-point number, for floats

%DBL_MAX
Defined in:   float.h
Definition:   #define DBL_MAX  1.79769313486231571e+308
Summary:      maximum representable finite floating-point number, for doubles

%LDBL_MAX
Defined in:   float.h
Definition:   #define LDBL_MAX 1.79769313486231571e+308L
Summary:      maximum representable finite floating-point number, for long 
              doubles

%FLT_EPSILON
Defined in:   float.h
Definition:   #define FLT_EPSILON         1.19209290e-7F
Summary:      minimum positive floating point number x such that 
              1.0 + x != 1.0 for floats

%DBL_EPSILON
Defined in:   float.h
Definition:   #define DBL_EPSILON         2.2204460492503131e-16
Summary:      minimum positive floating point number x such that 
              1.0 + x != 1.0 for doubles

%LDBL_EPSILON
Defined in:   float.h
Definition:   #define LDBL_EPSILON        2.2204460492503131e-16L
Summary:      minimum positive floating point number x such that 
              1.0 + x != 1.0 for long doubles
                             
%FLT_MIN
Defined in:   float.h
Definition:   #define FLT_MIN  1.17549435e-38F
Summary:      minimum normalised positive floating-point number for floats

%DBL_MIN
Defined in:   float.h
Definition:   #define DBL_MIN  2.22507385850720138e-308
Summary:      minimum normalised positive floating-point number for doubles

%LDBL_MIN
Defined in:   float.h
Definition:   #define LDBL_MIN 2.22507385850720138e-308L
Summary:      minimum normalised positive floating-point number for long 
              doubles

%PRId8
Defined in:   inttypes.h
Definition:   #define PRId8       "d"
Summary:      printf format specifier macro to print a int8_t integer
              type in decimal

%PRId16
Defined in:   inttypes.h
Definition:   #define PRId16      "d"
Summary:      printf format specifier macro to print a int16_t integer
              type in decimal
              decimal

%PRId32
Defined in:   inttypes.h
Definition:   #define PRId32      "d"
Summary:      printf format specifier macro to print a int32_t integer
              type in decimal

%PRIdLEAST8
Defined in:   inttypes.h
Definition:   #define PRIdLEAST8  "d"
Summary:      printf format specifier macro to print a int_least8_t integer
              type in decimal

%PRIdLEAST16
Defined in:   inttypes.h
Definition:   #define PRIdLEAST16 "d"
Summary:      printf format specifier macro to print a int_least16_t integer
              type in decimal

%PRIdLEAST32
Defined in:   inttypes.h
Definition:   #define PRIdLEAST32 "d"
Summary:      printf format specifier macro to print a int_least32_t integer
              type in decimal

%PRIdFAST8
Defined in:   inttypes.h
Definition:   #define PRIdFAST8   "d"
Summary:      printf format specifier macro to print a int_fast8_t integer
              type in decimal

%PRIdFAST16
Defined in:   inttypes.h
Definition:   #define PRIdFAST16  "d"
Summary:      printf format specifier macro to print a int_fast16_t integer
              type in decimal

%PRIdFAST32
Defined in:   inttypes.h
Definition:   #define PRIdFAST32  "d"
Summary:      printf format specifier macro to print a int_fast32_t integer
              type in decimal

%PRIdPTR
Defined in:   inttypes.h
Definition:   #define PRIdPTR     "d"
Summary:      printf format specifier macro to print a intptr_t integer
              type in decimal

%PRIi8
Defined in:   inttypes.h
Definition:   #define PRIi8       "i"
Summary:      printf format specifier macro to print a int8_t integer 
              type in decimal

%PRIi16
Defined in:   inttypes.h
Definition:   #define PRIi16      "i"
Summary:      printf format specifier macro to print a int16_t integer 
              type in decimal

%PRIi32
Defined in:   inttypes.h
Definition:   #define PRIi32      "i"
Summary:      printf format specifier macro to print a int32_t integer 
              type in decimal

%PRIiLEAST8
Defined in:   inttypes.h
Definition:   #define PRIiLEAST8  "i"
Summary:      printf format specifier macro to print a int_least8_t integer 
              type in decimal

%PRIiLEAST16
Defined in:   inttypes.h
Definition:   #define PRIiLEAST16 "i"
Summary:      printf format specifier macro to print a int_least16_t integer 
              type in decimal

%PRIiLEAST32
Defined in:   inttypes.h
Definition:   #define PRIiLEAST32 "i"
Summary:      printf format specifier macro to print a int_least32_t integer 
              type in decimal

%PRIiFAST8
Defined in:   inttypes.h
Definition:   #define PRIiFAST8   "i"
Summary:      printf format specifier macro to print a int_fast8_t integer 
              type in decimal

%PRIiFAST16
Defined in:   inttypes.h
Definition:   #define PRIiFAST16  "i"
Summary:      printf format specifier macro to print a int_fast16_t integer 
              type in decimal

%PRIiFAST32
Defined in:   inttypes.h
Definition:   #define PRIiFAST32  "i"
Summary:      printf format specifier macro to print a int_fast32_t integer 
              type in decimal

%PRIiPTR
Defined in:   inttypes.h
Definition:   #define PRIiPTR     "i"
Summary:      printf format specifier macro to print a intptr_t integer 
              type in decimal


%PRIo8
Defined in:   inttypes.h
Definition:   #define PRIo8       "o"
Summary:      printf format specifier macro to print a uint8_t integer 
              type in octal

%PRIo16
Defined in:   inttypes.h
Definition:   #define PRIo16      "o"
Summary:      printf format specifier macro to print a uint16_t integer 
              type in octal

%PRIo32
Defined in:   inttypes.h
Definition:   #define PRIo32      "o"
Summary:      printf format specifier macro to print a uint32_t integer 
              type in octal

%PRIoLEAST8
Defined in:   inttypes.h
Definition:   #define PRIoLEAST8  "o"
Summary:      printf format specifier macro to print a uint_least8_t integer 
              type in octal

%PRIoLEAST16
Defined in:   inttypes.h
Definition:   #define PRIoLEAST16 "o"
Summary:      printf format specifier macro to print a uint_least16_t integer 
              type in octal

%PRIoLEAST32
Defined in:   inttypes.h
Definition:   #define PRIoLEAST32 "o"
Summary:      printf format specifier macro to print a uint_least32_t integer 
              type in octal

%PRIoFAST8
Defined in:   inttypes.h
Definition:   #define PRIoFAST8   "o"
Summary:      printf format specifier macro to print a uint_fast8_t integer 
              type in octal

%PRIoFAST16
Defined in:   inttypes.h
Definition:   #define PRIoFAST16  "o"
Summary:      printf format specifier macro to print a uint_fast16_t integer 
              type in octal

%PRIoFAST32
Defined in:   inttypes.h
Definition:   #define PRIoFAST32  "o"
Summary:      printf format specifier macro to print a uint_fast32_t integer 
              type in octal

%PRIoPTR
Defined in:   inttypes.h
Definition:   #define PRIoPTR     "o"
Summary:      printf format specifier macro to print a uintptr_t integer 
              type in octal


%PRIu8
Defined in:   inttypes.h
Definition:   #define PRIu8       "u"
Summary:      printf format specifier macro to print a uint8_t integer 
              type in decimal

%PRIu16
Defined in:   inttypes.h
Definition:   #define PRIu16      "u"
Summary:      printf format specifier macro to print a uint16_t integer 
              type in decimal

%PRIu32
Defined in:   inttypes.h
Definition:   #define PRIu32      "u"
Summary:      printf format specifier macro to print a uint32_t integer 
              type in decimal

%PRIuLEAST8
Defined in:   inttypes.h
Definition:   #define PRIuLEAST8  "u"
Summary:      printf format specifier macro to print a uint_least8_t integer 
              type in decimal

%PRIuLEAST16
Defined in:   inttypes.h
Definition:   #define PRIuLEAST16 "u"
Summary:      printf format specifier macro to print a uint_least16_t integer 
              type in decimal

%PRIuLEAST32
Defined in:   inttypes.h
Definition:   #define PRIuLEAST32 "u"
Summary:      printf format specifier macro to print a uint_least32_t integer 
              type in decimal

%PRIuFAST8
Defined in:   inttypes.h
Definition:   #define PRIuFAST8   "u"
Summary:      printf format specifier macro to print a uint_fast8_t integer 
              type in decimal

%PRIuFAST16
Defined in:   inttypes.h
Definition:   #define PRIuFAST16  "u"
Summary:      printf format specifier macro to print a uint_fast16_t integer 
              type in decimal

%PRIuFAST32
Defined in:   inttypes.h
Definition:   #define PRIuFAST32  "u"
Summary:      printf format specifier macro to print a uint_fast32_t integer 
              type in decimal

%PRIuPTR
Defined in:   inttypes.h
Definition:   #define PRIuPTR     "u"
Summary:      printf format specifier macro to print a uintptr_t integer 
              type in decimal


%PRIx8
Defined in:   inttypes.h
Definition:   #define PRIx8       "x"
Summary:      printf format specifier macro to print a uint8_t integer 
              type in lowercase hexadecimal

%PRIx16
Defined in:   inttypes.h
Definition:   #define PRIx16      "x"
Summary:      printf format specifier macro to print a uint16_t integer 
              type in lowercase hexadecimal

%PRIx32
Defined in:   inttypes.h
Definition:   #define PRIx32      "x"
Summary:      printf format specifier macro to print a uint32_t integer 
              type in lowercase hexadecimal

%PRIxLEAST8
Defined in:   inttypes.h
Definition:   #define PRIxLEAST8  "x"
Summary:      printf format specifier macro to print a uint_least8_t integer 
              type in lowercase hexadecimal

%PRIxLEAST16
Defined in:   inttypes.h
Definition:   #define PRIxLEAST16 "x"
Summary:      printf format specifier macro to print a uint_least16_t integer 
              type in lowercase hexadecimal

%PRIxLEAST32
Defined in:   inttypes.h
Definition:   #define PRIxLEAST32 "x"
Summary:      printf format specifier macro to print a uint_least32_t integer 
              type in lowercase hexadecimal

%PRIxFAST8
Defined in:   inttypes.h
Definition:   #define PRIxFAST8   "x"
Summary:      printf format specifier macro to print a uint_fast8_t integer 
              type in lowercase hexadecimal

%PRIxFAST16
Defined in:   inttypes.h
Definition:   #define PRIxFAST16  "x"
Summary:      printf format specifier macro to print a uint_fast16_t integer 
              type in lowercase hexadecimal

%PRIxFAST32
Defined in:   inttypes.h
Definition:   #define PRIxFAST32  "x"
Summary:      printf format specifier macro to print a uint_fast32_t integer 
              type in lowercase hexadecimal

%PRIxPTR
Defined in:   inttypes.h
Definition:   #define PRIxPTR     "x"
Summary:      printf format specifier macro to print a uintptr_t integer 
              type in lowercase hexadecimal


%PRIX8
Defined in:   inttypes.h
Definition:   #define PRIX8       "X"
Summary:      printf format specifier macro to print a uint8_t integer 
              type in UPPERCASE hexadecimal

%PRIX16
Defined in:   inttypes.h
Definition:   #define PRIX16      "X"
Summary:      printf format specifier macro to print a uint16_t integer 
              type in UPPERCASE hexadecimal

%PRIX32
Defined in:   inttypes.h
Definition:   #define PRIX32      "X"
Summary:      printf format specifier macro to print a uint32_t integer 
              type in UPPERCASE hexadecimal

%PRIXLEAST8
Defined in:   inttypes.h
Definition:   #define PRIXLEAST8  "X"
Summary:      printf format specifier macro to print a uint_least8_t integer 
              type in UPPERCASE hexadecimal

%PRIXLEAST16
Defined in:   inttypes.h
Definition:   #define PRIXLEAST16 "X"
Summary:      printf format specifier macro to print a uint_least16_t integer 
              type in UPPERCASE hexadecimal

%PRIXLEAST32
Defined in:   inttypes.h
Definition:   #define PRIXLEAST32 "X"
Summary:      printf format specifier macro to print a uint_least32_t integer 
              type in UPPERCASE hexadecimal

%PRIXFAST8
Defined in:   inttypes.h
Definition:   #define PRIXFAST8   "X"
Summary:      printf format specifier macro to print a uint_fast8_t integer 
              type in UPPERCASE hexadecimal

%PRIXFAST16
Defined in:   inttypes.h
Definition:   #define PRIXFAST16  "X"
Summary:      printf format specifier macro to print a uint_fast16_t integer 
              type in UPPERCASE hexadecimal

%PRIXFAST32
Defined in:   inttypes.h
Definition:   #define PRIXFAST32  "X"
Summary:      printf format specifier macro to print a uint_fast32_t integer 
              type in UPPERCASE hexadecimal

%PRIXPTR
Defined in:   inttypes.h
Definition:   #define PRIXPTR     "X"
Summary:      printf format specifier macro to print a uinptr_t integer 
              type in UPPERCASE hexadecimal


%SCNd8
Defined in:   inttypes.h
Definition:   #define SCNd8       "hhd"
Summary:      scanf format specifier macro to scan a decimal
              int8_t integer 

%SCNd16
Defined in:   inttypes.h
Definition:   #define SCNd16      "hd"
Summary:      scanf format specifier macro to scan a decimal
              int16_t integer 

%SCNd32
Defined in:   inttypes.h
Definition:   #define SCNd32      "d"
Summary:      scanf format specifier macro to scan a decimal
              int32_t integer 

%SCNdLEAST8
Defined in:   inttypes.h
Definition:   #define SCNdLEAST8  "hhd"
Summary:      scanf format specifier macro to scan a decimal
              int_least8_t integer 

%SCNdLEAST16
Defined in:   inttypes.h
Definition:   #define SCNdLEAST16 "hd"
Summary:      scanf format specifier macro to scan a decimal
              int_least16_t integer 

%SCNdLEAST32
Defined in:   inttypes.h
Definition:   #define SCNdLEAST32 "d"
Summary:      scanf format specifier macro to scan a decimal
              int_least32_t integer 

%SCNdFAST8
Defined in:   inttypes.h
Definition:   #define SCNdFAST8   "d"
Summary:      scanf format specifier macro to scan a decimal
              int_fast8_t integer 

%SCNdFAST16
Defined in:   inttypes.h
Definition:   #define SCNdFAST16  "d"
Summary:      scanf format specifier macro to scan a decimal
              int_fast16_t integer 

%SCNdFAST32
Defined in:   inttypes.h
Definition:   #define SCNdFAST32  "d"
Summary:      scanf format specifier macro to scan a decimal
              int_fast32_t integer 

%SCNdPTR
Defined in:   inttypes.h
Definition:   #define SCNdPTR     "d"
Summary:      scanf format specifier macro to scan a decimal
              intptr_t integer 

%SCNi8
Defined in:   inttypes.h
Definition:   #define SCNi8       "hhi"
Summary:      scanf format specifier macro to scan a decimal
              int8_t integer 

%SCNi16
Defined in:   inttypes.h
Definition:   #define SCNi16      "hi"
Summary:      scanf format specifier macro to scan a decimal
              int16_t integer 

%SCNi32
Defined in:   inttypes.h
Definition:   #define SCNi32      "i"
Summary:      scanf format specifier macro to scan a decimal
              int32_t integer 

%SCNiLEAST8
Defined in:   inttypes.h
Definition:   #define SCNiLEAST8  "hhi"
Summary:      scanf format specifier macro to scan a decimal
              int_least8_t integer 

%SCNiLEAST16
Defined in:   inttypes.h
Definition:   #define SCNiLEAST16 "hi"
Summary:      scanf format specifier macro to scan a decimal
              int_least16_t integer 

%SCNiLEAST32
Defined in:   inttypes.h
Definition:   #define SCNiLEAST32 "i"
Summary:      scanf format specifier macro to scan a decimal
              int_least32_t integer 

%SCNiFAST8
Defined in:   inttypes.h
Definition:   #define SCNiFAST8   "i"
Summary:      scanf format specifier macro to scan a decimal
              int_fast8_t integer 

%SCNiFAST16
Defined in:   inttypes.h
Definition:   #define SCNiFAST16  "i"
Summary:      scanf format specifier macro to scan a decimal
              int_fast16_t integer 

%SCNiFAST32
Defined in:   inttypes.h
Definition:   #define SCNiFAST32  "i"
Summary:      scanf format specifier macro to scan a decimal
              int_fast32_t integer 

%SCNiPTR
Defined in:   inttypes.h
Definition:   #define SCNiPTR     "i"
Summary:      scanf format specifier macro to scan a decimal
              intptr_t integer 


%SCNo8
Defined in:   inttypes.h
Definition:   #define SCNo8       "hho"
Summary:      scanf format specifier macro to scan an octal
              uint8_t integer 

%SCNo16
Defined in:   inttypes.h
Definition:   #define SCNo16      "ho"
Summary:      scanf format specifier macro to scan an octal
              uint16_t integer 

%SCNo32
Defined in:   inttypes.h
Definition:   #define SCNo32      "o"
Summary:      scanf format specifier macro to scan an octal
              uint32_t integer 

%SCNoLEAST8
Defined in:   inttypes.h
Definition:   #define SCNoLEAST8  "hho"
Summary:      scanf format specifier macro to scan an octal
              uint_least8_t integer 

%SCNoLEAST16
Defined in:   inttypes.h
Definition:   #define SCNoLEAST16 "ho"
Summary:      scanf format specifier macro to scan an octal
              uint_least16_t integer 

%SCNoLEAST32
Defined in:   inttypes.h
Definition:   #define SCNoLEAST32 "o"
Summary:      scanf format specifier macro to scan an octal
              uint_least32_t integer 

%SCNoFAST8
Defined in:   inttypes.h
Definition:   #define SCNoFAST8   "o"
Summary:      scanf format specifier macro to scan an octal
              uint_fast8_t integer 

%SCNoFAST16
Defined in:   inttypes.h
Definition:   #define SCNoFAST16  "o"
Summary:      scanf format specifier macro to scan an octal
              uint_fast16_t integer 

%SCNoFAST32
Defined in:   inttypes.h
Definition:   #define SCNoFAST32  "o"
Summary:      scanf format specifier macro to scan an octal
              uint_fast32_t integer 

%SCNoPTR
Defined in:   inttypes.h
Definition:   #define SCNoPTR     "o"
Summary:      scanf format specifier macro to scan an octal
              uintptr_t integer 


%SCNu8
Defined in:   inttypes.h
Definition:   #define SCNu8       "hhu"
Summary:      scanf format specifier macro to scan a decimal
              uint8_t integer 

%SCNu16
Defined in:   inttypes.h
Definition:   #define SCNu16      "hu"
Summary:      scanf format specifier macro to scan a decimal
              uint16_t integer 

%SCNu32
Defined in:   inttypes.h
Definition:   #define SCNu32      "u"
Summary:      scanf format specifier macro to scan a decimal
              uint32_t integer 

%SCNuLEAST8
Defined in:   inttypes.h
Definition:   #define SCNuLEAST8  "hhu"
Summary:      scanf format specifier macro to scan a decimal
              uint_least8_t integer 

%SCNuLEAST16
Defined in:   inttypes.h
Definition:   #define SCNuLEAST16 "hu"
Summary:      scanf format specifier macro to scan a decimal
              uint_least16_t integer 

%SCNuLEAST32
Defined in:   inttypes.h
Definition:   #define SCNuLEAST32 "u"
Summary:      scanf format specifier macro to scan a decimal
              uint_least32_t integer 

%SCNuFAST8
Defined in:   inttypes.h
Definition:   #define SCNuFAST8   "u"
Summary:      scanf format specifier macro to scan a decimal
              uint_fast8_t integer 

%SCNuFAST16
Defined in:   inttypes.h
Definition:   #define SCNuFAST16  "u"
Summary:      scanf format specifier macro to scan a decimal
              uint_fast16_t integer 

%SCNuFAST32
Defined in:   inttypes.h
Definition:   #define SCNuFAST32  "u"
Summary:      scanf format specifier macro to scan a decimal
              uint_fast32_t integer 

%SCNuPTR
Defined in:   inttypes.h
Definition:   #define SCNuPTR     "u"
Summary:      scanf format specifier macro to scan a decimal
              uintptr_t integer 

%SCNx8
Defined in:   inttypes.h
Definition:   #define SCNx8       "hhx"
Summary:      scanf format specifier macro to scan a hexadecimal
              uint8_t integer 

%SCNx16
Defined in:   inttypes.h
Definition:   #define SCNx16      "hx"
Summary:      scanf format specifier macro to scan a hexadecimal
              uint16_t integer 

%SCNx32
Defined in:   inttypes.h
Definition:   #define SCNx32      "x"
Summary:      scanf format specifier macro to scan a hexadecimal
              uint32_t integer 

%SCNxLEAST8
Defined in:   inttypes.h
Definition:   #define SCNxLEAST8  "hhx"
Summary:      scanf format specifier macro to scan a hexadecimal
              uint_least8_t integer 

%SCNxLEAST16
Defined in:   inttypes.h
Definition:   #define SCNxLEAST16 "hx"
Summary:      scanf format specifier macro to scan a hexadecimal
              uint_least16_t integer 

%SCNxLEAST32
Defined in:   inttypes.h
Definition:   #define SCNxLEAST32 "x"
Summary:      scanf format specifier macro to scan a hexadecimal
              uint_least32_t integer 

%SCNxFAST8
Defined in:   inttypes.h
Definition:   #define SCNxFAST8   "x"
Summary:      scanf format specifier macro to scan a hexadecimal
              uint_fast8_t integer 

%SCNxFAST16
Defined in:   inttypes.h
Definition:   #define SCNxFAST16  "x"
Summary:      scanf format specifier macro to scan a hexadecimal
              uint_fast16_t integer 

%SCNxFAST32
Defined in:   inttypes.h
Definition:   #define SCNxFAST32  "x"
Summary:      scanf format specifier macro to scan a hexadecimal
              uint_fast32_t integer 

%SCNxPTR
Defined in:   inttypes.h
Definition:   #define SCNxPTR     "x"
Summary:      scanf format specifier macro to scan a hexadecimal
              uintptr_t integer 


%PRId64
Defined in:   inttypes.h
Definition:   #define PRId64      "lld"
Summary:      printf format specifier macro to print a int64_t integer 
              type in decimal

%PRIdLEAST64
Defined in:   inttypes.h
Definition:   #define PRIdLEAST64 "lld"
Summary:      printf format specifier macro to print a int_least64_t integer 
              type in decimal

%PRIdFAST64
Defined in:   inttypes.h
Definition:   #define PRIdFAST64  "lld"
Summary:      printf format specifier macro to print a int_fast64_t integer 
              type in decimal

%PRIdMAX
Defined in:   inttypes.h
Definition:   #define PRIdMAX     "jd"
Summary:      printf format specifier macro to print a intmax_t integer 
              type in decimal

%PRIi64
Defined in:   inttypes.h
Definition:   
Summary:      printf format specifier macro to print a int64_t integer 
              type in decimal

%PRIi64
Defined in:   inttypes.h
Definition:   #define PRIi64      "lli"
Summary:      printf format specifier macro to print a int_least64_t integer 
              type in decimal

%PRIiFAST64
Defined in:   inttypes.h
Definition:   #define PRIiFAST64  "lli"
Summary:      printf format specifier macro to print a int_fast64_t integer 
              type in decimal

%PRIiMAX
Defined in:   inttypes.h
Definition:   #define PRIiMAX     "ji"
Summary:      printf format specifier macro to print a intmax_t integer 
              type in decimal

%PRIo64
Defined in:   inttypes.h
Definition:   #define PRIo64      "llo"
Summary:      printf format specifier macro to print a uint64_t integer 
              type in octal

%PRIoLEAST64
Defined in:   inttypes.h
Definition:   #define PRIoLEAST64 "llo"
Summary:      printf format specifier macro to print a uint_least64_t integer 
              type in octal

%PRIoFAST64
Defined in:   inttypes.h
Definition:   #define PRIoFAST64  "llo"
Summary:      printf format specifier macro to print a uint_fast64_t integer 
              type in octal

%PRIoMAX
Defined in:   inttypes.h
Definition:   #define PRIoMAX     "jo"
Summary:      printf format specifier macro to print a uintmax_t integer 
              type in octal

%PRIu64
Defined in:   inttypes.h
Definition:   #define PRIu64      "llu"
Summary:      printf format specifier macro to print a uint64_t integer 
              type in decimal

%PRIuLEAST64
Defined in:   inttypes.h
Definition:   #define PRIuLEAST64 "llu"
Summary:      printf format specifier macro to print a uint_least64_t integer 
              type in decimal

%PRIuFAST64
Defined in:   inttypes.h
Definition:   #define PRIuFAST64  "llu"
Summary:      printf format specifier macro to print a uint_fast64_t integer 
              type in decimal

%PRIuMAX
Defined in:   inttypes.h
Definition:   #define PRIuMAX     "ju"
Summary:      printf format specifier macro to print a uintmax_t integer 
              type in decimal

%PRIx64
Defined in:   inttypes.h
Definition:   #define PRIx64      "llx"
Summary:      printf format specifier macro to print a uint64_t integer 
              type in lowercase hexadecimal

%PRIxLEAST64
Defined in:   inttypes.h
Definition:   #define PRIxLEAST64 "llx"
Summary:      printf format specifier macro to print a uint_least64_t integer 
              type in lowercase hexadecimal

%PRIxFAST64
Defined in:   inttypes.h
Definition:   #define PRIxFAST64  "llx"
Summary:      printf format specifier macro to print a uint_fast64_t integer 
              type in lowercase hexadecimal

%PRIxMAX
Defined in:   inttypes.h
Definition:   #define PRIxMAX     "jx"
Summary:      printf format specifier macro to print a uintmax_t integer 
              type in lowercase hexadecimal

%PRIX64
Defined in:   inttypes.h
Definition:   #define PRIX64      "llX"
Summary:      printf format specifier macro to print a uint64_t integer 
              type in UPPERCASE hexadecimal

%PRIXLEAST64
Defined in:   inttypes.h
Definition:   #define PRIXLEAST64 "llX"
Summary:      printf format specifier macro to print a uint_least64_t integer 
              type in UPPERCASE hexadecimal

%PRIXFAST64
Defined in:   inttypes.h
Definition:   #define PRIXFAST64  "llX"
Summary:      printf format specifier macro to print a uint_fast64_t integer 
              type in UPPERCASE hexadecimal

%PRIXMAX
Defined in:   inttypes.h
Definition:   #define PRIXMAX     "jX"
Summary:      printf format specifier macro to print a uintmax_t integer 
              type in UPPERCASE hexadecimal

%SCNd64
Defined in:   inttypes.h
Definition:   #define SCNd64      "lld"
Summary:      scanf format specifier macro to scan a decimal
              int64_t integer 

%SCNdLEAST64
Defined in:   inttypes.h
Definition:   #define SCNdLEAST64 "lld"
Summary:      scanf format specifier macro to scan a decimal
              int_least64_t integer 

%SCNdFAST64
Defined in:   inttypes.h
Definition:   #define SCNdFAST64  "lld"
Summary:      scanf format specifier macro to scan a decimal
              int_fast64_t integer 

%SCNdMAX
Defined in:   inttypes.h
Definition:   #define SCNdMAX     "jd"
Summary:      scanf format specifier macro to scan a decimal
              intmax_t integer 

%SCNi64
Defined in:   inttypes.h
Definition:   #define SCNi64      "lli"
Summary:      scanf format specifier macro to scan a decimal
              int64_t integer 

%SCNiLEAST64
Defined in:   inttypes.h
Definition:   #define SCNiLEAST64 "lli"
Summary:      scanf format specifier macro to scan a decimal
              int_least64_t integer 

%SCNiFAST64
Defined in:   inttypes.h
Definition:   #define SCNiFAST64  "lli"
Summary:      scanf format specifier macro to scan a decimal
              int_fast64_t integer 

%SCNiMAX
Defined in:   inttypes.h
Definition:   #define SCNiMAX     "ji"
Summary:      scanf format specifier macro to scan a decimal
              intmax_t integer 

%SCNo64
Defined in:   inttypes.h
Definition:   #define SCNo64      "llo"
Summary:      scanf format specifier macro to scan an octal
              uint64_t integer 

%SCNoLEAST64
Defined in:   inttypes.h
Definition:   #define SCNoLEAST64 "llo"
Summary:      scanf format specifier macro to scan an octal
              uint_least64_t integer 

%SCNoFAST64
Defined in:   inttypes.h
Definition:   #define SCNoFAST64  "llo"
Summary:      scanf format specifier macro to scan an octal
              uint_fast64_t integer 

%SCNoMAX
Defined in:   inttypes.h
Definition:   #define SCNoMAX     "jo"
Summary:      scanf format specifier macro to scan an octal
              uintmax_t integer 

%SCNu64
Defined in:   inttypes.h
Definition:   #define SCNu64      "llu"
Summary:      scanf format specifier macro to scan a decimal
              uint64_t integer 

%SCNuLEAST64
Defined in:   inttypes.h
Definition:   #define SCNuLEAST64 "llu"
Summary:      scanf format specifier macro to scan a decimal
              uint_least64_t integer 

%SCNuFAST64
Defined in:   inttypes.h
Definition:   #define SCNuFAST64  "llu"
Summary:      scanf format specifier macro to scan a decimal
              uint_fast64_t integer 

%SCNuMAX
Defined in:   inttypes.h
Definition:   #define SCNuMAX     "ju"
Summary:      scanf format specifier macro to scan a decimal
              uintmax_t integer 

%SCNx64
Defined in:   inttypes.h
Definition:   #define SCNx64      "llx"
Summary:      scanf format specifier macro to scan a hexadecimal
              uint64_t integer 

%SCNxLEAST64
Defined in:   inttypes.h
Definition:   #define SCNxLEAST64 "llx"
Summary:      scanf format specifier macro to scan a hexadecimal
              uint_least64_t integer 

%SCNxFAST64
Defined in:   inttypes.h
Definition:   #define SCNxFAST64  "llx"
Summary:      scanf format specifier macro to scan a hexadecimal
              uint_fast64_t integer 

%SCNxMAX
Defined in:   inttypes.h
Definition:   #define SCNxMAX     "jx"
Summary:      scanf format specifier macro to scan a hexadecimal
              uintmax_t integer 

%imaxdiv_t
Defined in:   inttypes.h
Definition:   typedef struct imaxdiv_t { intmax_t quot, rem; } imaxdiv_t
Summary:      type of the value returned by the imaxdiv function

%imaxabs
Defined in:   inttypes.h
Prototype:    intmax_t imaxabs(intmax_t /*j*/)
Summary:      computes the absolute value of an integer j. If the result cannot
              be represented, the behaviour is undefined

%imaxdiv
Defined in:   inttypes.h
Prototype:    imaxdiv_t imaxdiv(intmax_t /*numer*/, intmax_t /*denom*/)
Summary:      computes numer / denom and numer % denom in a single operation

%strtoimax
Defined in:   inttypes.h
Prototype:    intmax_t strtoimax(const char * restrict /*nptr*/,
                         char ** restrict /*endptr*/, int /*base*/)
Summary:      equivalent to the strtoll function, except that the initial 
              portion of the string is converted to intmax_t representation
              If no conversion could be performed, zero is returned. If the
              correct value is outside the range of representable values,
              INTMAX_MAX or INTMAX_MIN is returned (according to the sign of
              the value), and the value of the macro ERANGE is stored in errno.

%strtoumax
Defined in:   inttypes.h
Prototype:    uintmax_t strtoumax(const char * restrict /*nptr*/,
                          char ** restrict /*endptr*/, int /*base*/);
Summary:      equivalent to the strtoull function, except that the initial
              portion of the string is converted to uintmax_t representation.
              If the correct value is outside the range of representable
              values, UINTMAX_MAX is returned, and the value of the macro
              ERANGE is stored in errno.

%and
Defined in:   iso646.h
Definition:   #define and    &&
Summary:      alias for operator &&

%and_eq
Defined in:   iso646.h
Definition:   #define and_eq &=
Summary:      alias for operator &=

%bitand
Defined in:   iso646.h
Definition:   #define bitand &
Summary:      alias for operator &

%bitor
Defined in:   iso646.h
Definition:   #define bitor  |
Summary:      alias for operator |

%compl
Defined in:   iso646.h
Definition:   #define compl  ~
Summary:      alias for operator ~

%not
Defined in:   iso646.h
Definition:   #define not    !
Summary:      alias for operator !

%not_eq
Defined in:   iso646.h
Definition:   #define not_eq !=
Summary:      alias for operator !=

%or
Defined in:   iso646.h
Definition:   #define or     ||
Summary:      alias for operator ||

%or_eq
Defined in:   iso646.h
Definition:   #define or_eq  |=
Summary:      alias for operator |=

%xor
Defined in:   iso646.h
Definition:   #define xor    ^
Summary:      alias for operator ^

%xor_eq
Defined in:   iso646.h
Definition:   #define xor_eq ^=
Summary:      alias for operator ^=

%CHAR_BIT
Defined in:   limits.h
Definition:   #define CHAR_BIT 8
Summary:      max number of bits for smallest object that is not a bit-field 
              (byte)

%SCHAR_MIN
Defined in:   limits.h
Definition:   #define SCHAR_MIN (-128)
Summary:      mimimum value for an object of type signed char

%SCHAR_MAX
Defined in:   limits.h
Definition:   #define SCHAR_MAX 127
Summary:      maximum value for an object of type signed char

%UCHAR_MAX
Defined in:   limits.h
Definition:   #define UCHAR_MAX 255
Summary:      maximum value for an object of type unsigned char

%CHAR_MIN
Defined in:   limits.h
Definition:   #define CHAR_MIN 0
Summary:      minimum value for an object of type char

%CHAR_MAX
Defined in:   limits.h
Definition:   #define CHAR_MAX 255
Summary:      maximum value for an object of type char

%MB_LEN_MAX
Defined in:   limits.h
Summary:      maximum number of bytes in a multibyte character,
              for any supported locale

%SHRT_MIN
Defined in:   limits.h
Definition:   #define SHRT_MIN  (-0x8000)
Summary:      minimum value for an object of type short int

%SHRT_MAX
Defined in:   limits.h
Definition:   #define SHRT_MAX  0x7fff
Summary:      maximum value for an object of type short int

%USHRT_MAX
Defined in:   limits.h
Definition:   #define USHRT_MAX 65535U
Summary:      maximum value for an object of type unsigned short int

%INT_MIN
Defined in:   limits.h
Definition:   #define INT_MIN   (~0x7fffffff)
Summary:      minimum value for an object of type int

%INT_MAX
Defined in:   limits.h
Definition:   #define INT_MAX   0x7fffffff
Summary:      maximum value for an object of type int

%UINT_MAX
Defined in:   limits.h
Definition:   #define UINT_MAX  0xffffffff
Summary:      maximum value for an object of type unsigned int

%LONG_MIN
Defined in:   limits.h
Definition:   #define LONG_MIN  (~0x7fffffff)
Summary:      minimum value for an object of type long int

%LONG_MAX
Defined in:   limits.h
Definition:   #define LONG_MAX  0x7fffffff
Summary:      maximum value for an object of type long int

%ULONG_MAX
Defined in:   limits.h
Definition:   #define ULONG_MAX 0xffffffffU
Summary:      maximum value for an object of type unsigned long int

%LLONG_MIN
Defined in:   limits.h
Definition:   #define LLONG_MIN  (~0x7fffffffffffffffLL)
Summary:      minimum value for an object of type long long int

%LLONG_MAX
Defined in:   limits.h
Definition:   #define LLONG_MAX  0x7fffffffffffffffLL
Summary:      maximum value for an object of type long long int

%ULLONG_MAX
Defined in:   limits.h
Definition:   #define ULLONG_MAX 0xffffffffffffffffULL
Summary:      maximum value for an object of type unsigned long long int

%LC_COLLATE
Defined in:   locale.h
Definition:   #define LC_COLLATE  1
Summary:      bit flag for category parameter to setlocale
              affects the behaviour of the strcoll function

%LC_CTYPE
Defined in:   locale.h
Definition:   #define LC_CTYPE    2
Summary:      bit flag for category parameter to setlocale
              affects the behaviour of the character handling functions

%LC_MONETARY
Defined in:   locale.h
Definition:   #define LC_MONETARY 4
Summary:      bit flag for category parameter to setlocale, affects the 
              monetary formatting information returned by the localeconv 
              function

%LC_NUMERIC
Defined in:   locale.h
Definition:   #define LC_NUMERIC  8
Summary:      bit flag for category parameter to setlocale, affects the 
              decimal-point character for the formatted input/output and 
              string conversion functions

%LC_TIME
Defined in:   locale.h
Definition:   #define LC_TIME    16
Summary:      bit flag for category parameter to setlocale
              affects the behaviour of the strftime function

%LC_ALL
Defined in:   locale.h
Definition:   #define LC_ALL     31
Summary:      bit flag for category parameter to setlocale
              affects the entire locale

%setlocale
Defined in:   locale.h
Prototype:    extern char *setlocale(int /*category*/, 
                                     const char * /*locale*/)
Summary:      Selects the appropriate piece of the program's locale as 
              specified by the category and locale arguments

%localeconv
Defined in:   locale.h
Prototype:    extern struct lconv *localeconv(void)
Summary:      Returns pointer to struct with object set up appropriately for
              current locale for formatting numeric quantities

%HUGE_VAL
Defined in:   math.h
Summary:      double constant used to indicate error

%HUGE_VALF
Defined in:   math.h
Summary:      float constant used to indicate error

%HUGE_VALL
Defined in:   math.h
Summary:      long double constant used to indicate error

%INFINITY
Defined in:   math.h
Summary:      float constant representing positive or unsigned infinity

%NAN
Defined in:   math.h
Summary:      float constant expression representing a quiet not-a-number

%FP_ZERO
Defined in:   math.h
Summary:      mutually exclusive kind of floating-point value from fpclassify

%FP_SUBNORMAL
Defined in:   math.h
Summary:      mutually exclusive kind of floating-point value from fpclassify

%FP_NORMAL
Defined in:   math.h
Summary:      mutually exclusive kind of floating-point value from fpclassify

%FP_INFINITE
Defined in:   math.h
Summary:      mutually exclusive kind of floating-point value from fpclassify

%FP_NAN
Defined in:   math.h
Summary:      mutually exclusive kind of floating-point value from fpclassify

%FP_FAST_FMA
Defined in:   math.h
Summary:      indicates that the fma function generally executes about as
              fast as a multiply and an add of float operands.

%FP_FAST_FMAF
Defined in:   math.h
Summary:      indicates that the fmaf function generally executes about as
              fast as a multiply and an add of float operands.

%FP_FAST_FMAL
Defined in:   math.h
Summary:      indicates that the fmaf function generally executes about as
              fast as a multiply and an add of long double operands.

%FP_ILOGB0
Defined in:   math.h
Summary:      integer constant expression whose values are returned by ilogb(x)
              if x is zero.

%FP_ILOGBNAN
Defined in:   math.h
Summary:      integer constant expression whose values are returned by ilogb(x)
              if x is not-a-number.

%fpclassify
Defined in:   math.h
Prototype:    int fpclassify(real-floating x)
Summary:      this macro evaluates x and returns an integer value FP_ZERO, 
              FP_SUBNORMAL, FP_NORMAL, FP_INFINITE, or FP_NAN.

%isfinite
Defined in:   math.h
Prototype:    int isfinite(real-floating x)
Summary:      this macro returns non-0 if x is finite.

%isinf
Defined in:   math.h
Prototype:    int isinf(real-floating x)
Summary:      this macro returns non-0 if x is infinite.

%isnan
Defined in:   math.h
Prototype:    int isnan(real-floating x)
Summary:      this macro returns non-0 if x is not-a-number.

%isnormal
Defined in:   math.h
Prototype:    int isnormal(real-floating x)
Summary:      this macro returns non-0 if x is normal.

%signbit
Defined in:   math.h
Prototype:    int signbit(real-floating x)
Summary:      this macro returns non-0 if the sign of x is negative.

%acos
Defined in:   math.h
Prototype:    extern double acos(double /*x*/)
Summary:      computes the principal value of the arc cosine of x in the 
              range 0 to Pi

%acosf
Defined in:   math.h
Prototype:    extern float acosf(float /*x*/)
Summary:      computes the principal value of the arc cosine of x in the 
              range 0 to Pi

%acosl
Defined in:   math.h
Prototype:    extern long double acosl(long double /*x*/)
Summary:      computes the principal value of the arc cosine of x in the 
              range 0 to Pi

%asin
Defined in:   math.h
Prototype:    extern double asin(double /*x*/)
Summary:      computes the principal value of the arc sine of x in the range 
              -Pi/2 to Pi/2

%asinf
Defined in:   math.h
Prototype:    extern float asinf(float /*x*/)
Summary:      computes the principal value of the arc sine of x in the range 
              -Pi/2 to Pi/2

%asinl
Defined in:   math.h
Prototype:    extern long double asinl(long double /*x*/)
Summary:      computes the principal value of the arc sine of x in the range 
              -Pi/2 to Pi/2

%atan
Defined in:   math.h
Prototype:    extern double atan(double /*x*/)
Summary:      computes the principal value of the arc tangent of x in the 
              range -Pi/2 to Pi/2

%atanf
Defined in:   math.h
Prototype:    extern float atanf(float /*x*/)
Summary:      computes the principal value of the arc tangent of x in the 
              range -Pi/2 to Pi/2

%atanl
Defined in:   math.h
Prototype:    extern long double atanl(long double /*x*/)
Summary:      computes the principal value of the arc tangent of x in the 
              range -Pi/2 to Pi/2

%atan2
Defined in:   math.h
Prototype:    extern double atan2(double /*x*/, double /*y*/)
Summary:      computes the principal value of the arc tangent of y/x in the 
              range -Pi to Pi
              using the signs of both arguments to determine the quadrant of 
              the return value

%atan2f
Defined in:   math.h
Prototype:    extern float atan2f(float /*x*/, float /*y*/)
Summary:      computes the principal value of the arc tangent of y/x in the 
              range -Pi to Pi
              using the signs of both arguments to determine the quadrant of 
              the return value

%atan2l
Defined in:   math.h
Prototype:    extern long double atan2l(long double /*x*/, long double /*y*/)
Summary:      computes the principal value of the arc tangent of y/x in the 
              range -Pi to Pi
              using the signs of both arguments to determine the quadrant of 
              the return value

%cos
Defined in:   math.h
Prototype:    extern double cos(double /*x*/)
Summary:      computes the cosine of x (measured in radians)

%cosf
Defined in:   math.h
Prototype:    extern float cosf(float /*x*/)
Summary:      computes the cosine of x (measured in radians)

%cosl
Defined in:   math.h
Prototype:    extern long double cosl(long double /*x*/)
Summary:      computes the cosine of x (measured in radians)

%sin
Defined in:   math.h
Prototype:    extern double sin(double /*x*/)
Summary:      computes the sine of x (measured in radians)

%sinf
Defined in:   math.h
Prototype:    extern float sinf(float /*x*/)
Summary:      computes the sine of x (measured in radians)

%sinl
Defined in:   math.h
Prototype:    extern long double sinl(long double /*x*/)
Summary:      computes the sine of x (measured in radians)

%tan
Defined in:   math.h
Prototype:    extern double tan(double /*x*/)
Summary:      computes the tangent of x (measured in radians)

%tanf
Defined in:   math.h
Prototype:    extern float tanf(float /*x*/)
Summary:      computes the tangent of x (measured in radians)

%tanl
Defined in:   math.h
Prototype:    extern long double tanl(long double /*x*/)
Summary:      computes the tangent of x (measured in radians)

%acosh
Defined in:   math.h
Prototype:    extern double acosh(double /*x*/)
Summary:      computes the hyperbolic arc cosine of x

%acoshf
Defined in:   math.h
Prototype:    extern float acoshf(float /*x*/)
Summary:      computes the hyperbolic arc cosine of x

%acoshl
Defined in:   math.h
Prototype:    extern long double acoshl(long double /*x*/)
Summary:      computes the hyperbolic arc cosine of x

%asinh
Defined in:   math.h
Prototype:    extern double asinh(double /*x*/)
Summary:      computes the hyperbolic arc sine of x

%asinhf
Defined in:   math.h
Prototype:    extern float asinhf(float /*x*/)
Summary:      computes the hyperbolic arc sine of x

%asinhl
Defined in:   math.h
Prototype:    extern long double asinhl(long double /*x*/)
Summary:      computes the hyperbolic arc sine of x

%atanh
Defined in:   math.h
Prototype:    extern double atanh(double /*x*/)
Summary:      computes the hyperbolic arc tangent of x

%atanhf
Defined in:   math.h
Prototype:    extern float atanhf(float /*x*/)
Summary:      computes the hyperbolic arc tangent of x

%atanhl
Defined in:   math.h
Prototype:    extern long double atanhl(long double /*x*/)
Summary:      computes the hyperbolic arc tangent of x

%cosh
Defined in:   math.h
Prototype:    extern double cosh(double /*x*/)
Summary:      computes the hyperbolic cosine of x

%coshf
Defined in:   math.h
Prototype:    extern float coshf(float /*x*/)
Summary:      computes the hyperbolic cosine of x

%coshl
Defined in:   math.h
Prototype:    extern long double coshl(long double /*x*/)
Summary:      computes the hyperbolic cosine of x

%sinh
Defined in:   math.h
Prototype:    extern double sinh(double /*x*/)
Summary:      computes the hyperbolic sine of x

%sinhf
Defined in:   math.h
Prototype:    extern float sinhf(float /*x*/)
Summary:      computes the hyperbolic sine of x

%sinhl
Defined in:   math.h
Prototype:    extern long double sinhl(long double /*x*/)
Summary:      computes the hyperbolic sine of x

%tanh
Defined in:   math.h
Prototype:    extern double tanh(double /*x*/)
Summary:      computes the hyperbolic tangent of x

%tanhf
Defined in:   math.h
Prototype:    extern float tanh(float /*x*/)
Summary:      computes the hyperbolic tangent of x

%tanhl
Defined in:   math.h
Prototype:    extern long double tanhl(long double /*x*/)
Summary:      computes the hyperbolic tangent of x

%exp
Defined in:   math.h
Prototype:    extern double exp(double /*x*/)
Summary:      computes the base-e exponential function of x

%expf
Defined in:   math.h
Prototype:    extern float expf(float /*x*/)
Summary:      computes the base-e exponential function of x

%expl
Defined in:   math.h
Prototype:    extern long double expl(long double /*x*/)
Summary:      computes the base-e exponential function of x

%exp2
Defined in:   math.h
Prototype:    double exp2(double /*x*/)
Summary:      computes the base-2 exponential function of x

%exp2f
Defined in:   math.h
Prototype:    float exp2f(float /*x*/)
Summary:      computes the base-2 exponential function of x

%exp2l
Defined in:   math.h
Prototype:    long double exp2l(long double /*x*/);
Summary:      computes the base-2 exponential function of x

%expml
Defined in:   math.h
Prototype:    double expm1(double /*x*/)
Summary:      computes the base-e exponential of x, minus 1

%expmlf
Defined in:   math.h
Prototype:    float expm1f(float /*x*/)
Summary:      computes the base-e exponential of x, minus 1

%expmll
Defined in:   math.h
Prototype:    long double expm1l(long double /*x*/)
Summary:      computes the base-e exponential of x, minus 1

%frexp
Defined in:   math.h
Prototype:    extern double frexp(double /*x*/, int * /*exp*/)
Summary:      breaks a floating-point number into a normalised fraction and 
              an integral power of 2 (stored in the int object exp)

%frexpf
Defined in:   math.h
Prototype:    extern float frexp(float /*x*/, int * /*exp*/)
Summary:      breaks a floating-point number into a normalised fraction and 
              an integral power of 2 (stored in the int object exp)

%frexpl
Defined in:   math.h
Prototype:    extern long double frexp(long double /*x*/, int * /*exp*/)
Summary:      breaks a floating-point number into a normalised fraction and 
              an integral power of 2 (stored in the int object exp)

%ilogb
Defined in:   math.h
Prototype:    int ilogb(double /*x*/)
Summary:      extracts the exponent of x as a signed int value

%ilogbf
Defined in:   math.h
Prototype:    int ilogbf(float /*x*/)
Summary:      extracts the exponent of x as a signed int value

%ilogbl
Defined in:   math.h
Prototype:    int ilogbl(long double /*x*/)
Summary:      extracts the exponent of x as a signed int value

%ldexp
Defined in:   math.h
Prototype:    extern double ldexp(double /*x*/, int /*exp*/)
Summary:      multiplies a floating-point number by an integral power of 2

%ldexpf
Defined in:   math.h
Prototype:    extern float ldexpf(float /*x*/, int /*exp*/)
Summary:      multiplies a floating-point number by an integral power of 2

%ldexpl
Defined in:   math.h
Prototype:    extern long double ldexpl(long double /*x*/, int /*exp*/)
Summary:      multiplies a floating-point number by an integral power of 2

%log
Defined in:   math.h
Prototype:    extern double log(double /*x*/)
Summary:      computes the natural logarithm of x

%logf
Defined in:   math.h
Prototype:    extern float logf(float /*x*/)
Summary:      computes the natural logarithm of x

%logl
Defined in:   math.h
Prototype:    extern long double log(long double /*x*/)
Summary:      computes the natural logarithm of x

%log10
Defined in:   math.h
Prototype:    extern double log10(double /*x*/)
Summary:      computes the base-ten logarithm of x

%log10f
Defined in:   math.h
Prototype:    extern float log10f(float /*x*/)
Summary:      computes the base-ten logarithm of x

%log10l
Defined in:   math.h
Prototype:    extern long double log10(long double /*x*/)
Summary:      computes the base-ten logarithm of x

%loglp
Defined in:   math.h
Prototype:    double log1p(double /*x*/)
Summary:      computes the base-e (natural) logarithm of 1 plus the argument

%loglpf
Defined in:   math.h
Prototype:    float log1pf(float /*x*/)
Summary:      computes the base-e (natural) logarithm of 1 plus the argument

%loglpl
Defined in:   math.h
Prototype:    long double log1pl(long double /*x*/)
Summary:      computes the base-e (natural) logarithm of 1 plus the argument

%log2
Defined in:   math.h
Prototype:    double log2(double /*x*/)
Summary:      computes the base-two logarithm of x

%log2f
Defined in:   math.h
Prototype:    float log2f(float /*x*/)
Summary:      computes the base-two logarithm of x

%log2l
Defined in:   math.h
Prototype:    long double log2l(long double /*x*/)
Summary:      computes the base-two logarithm of x

%logb
Defined in:   math.h
Prototype:    double logb(double /*x*/)
Summary:      extracts the exponent of x, as a signed integer value in floating
              point format

%logbf
Defined in:   math.h
Prototype:    float logbf(float /*x*/)
Summary:      extracts the exponent of x, as a signed integer value in floating
              point format

%logbl
Defined in:   math.h
Prototype:    long double logbl(long double /*x*/)
Summary:      extracts the exponent of x, as a signed integer value in floating
              point format

%modf
Defined in:   math.h
Prototype:    extern double modf(double /*value*/, double * /*iptr*/)
Summary:      breaks the argument value into integral and fraction parts, 
              integral part in iptr

%modff
Defined in:   math.h
Prototype:    extern float modff(float /*value*/, float * /*iptr*/)
Summary:      breaks the argument value into integral and fraction parts, 
              integral part in iptr

%modfl
Defined in:   math.h
Prototype:    extern long double modfl(long double /*value*/,
                                      long double * /*iptr*/)
Summary:      breaks the argument value into integral and fraction parts, 
              integral part in iptr

%scalbn
Defined in:   math.h
Prototype:    double scalbn(double /*x*/, int /*n*/)
Summary:      computes x * FLT_RADIX^n efficiently

%scalbnf
Defined in:   math.h
Prototype:    float scalbnf(float /*x*/, int /*n*/)
Summary:      computes x * FLT_RADIX^n efficiently

%scalbnl
Defined in:   math.h
Prototype:    long double scalbnl(long double /*x*/, int /*n*/)
Summary:      computes x * FLT_RADIX^n efficiently

%scalbln
Defined in:   math.h
Prototype:    double scalbln(double /*x*/, long int /*n*/)
Summary:      computes x * FLT_RADIX^n efficiently

%scalblnf
Defined in:   math.h
Prototype:    float scalblnf(float /*x*/, long int /*n*/)
Summary:      computes x * FLT_RADIX^n efficiently

%scalblnl
Defined in:   math.h
Prototype:    long double scalblnl(long double /*x*/, long int /*n*/)
Summary:      computes x * FLT_RADIX^n efficiently

%cbrt
Defined in:   math.h
Prototype:    double cbrt(double /*x*/)
Summary:      computes the real cube root of x

%cbrtf
Defined in:   math.h
Prototype:    float cbrtf(float /*x*/)
Summary:      computes the real cube root of x

%cbrtl
Defined in:   math.h
Prototype:    long double cbrtl(long double /*x*/)
Summary:      computes the real cube root of x

%fabs
Defined in:   math.h
Prototype:    extern double fabs(double /*x*/)
Summary:      computes the absolute value of the floating-point number x

%fabsf
Defined in:   math.h
Prototype:    extern float fabsf(float /*x*/)
Summary:      computes the absolute value of the floating-point number x

%fabsl
Defined in:   math.h
Prototype:    extern long double fabsl(long double /*x*/)
Summary:      computes the absolute value of the floating-point number x

%hypot
Defined in:   math.h
Prototype:    double hypot(double /*x*/, double /*y*/)
Summary:      computes the square root of the sum of the squares of x and y,
              without undue overflow or underflow

%hypotf
Defined in:   math.h
Prototype:    float hypotf(float /*x*/, float /*y*/)
Summary:      computes the square root of the sum of the squares of x and y,
              without undue overflow or underflow

%hypotl
Defined in:   math.h
Prototype:    long double hypotl(long double /*x*/, long double /*y*/)
Summary:      computes the square root of the sum of the squares of x and y,
              without undue overflow or underflow

%pow
Defined in:   math.h
Prototype:    extern double pow(double /*x*/, double /*y*/)
Summary:      computes x raised to the power of y

%powf
Defined in:   math.h
Prototype:    extern float powf(float /*x*/, float /*y*/)
Summary:      computes x raised to the power of y

%powl
Defined in:   math.h
Prototype:    extern long double powl(long double /*x*/, long double /*y*/)
Summary:      computes x raised to the power of y

%sqrt
Defined in:   math.h
Prototype:    extern double sqrt(double /*x*/)
Summary:      computes the non-negative square root of x

%sqrtf
Defined in:   math.h
Prototype:    extern float sqrtf(float /*x*/)
Summary:      computes the non-negative square root of x

%sqrtl
Defined in:   math.h
Prototype:    extern long double sqrtl(long double /*x*/)
Summary:      computes the non-negative square root of x

%erf
Defined in:   math.h
Prototype:    double erf(double /*x*/)
Summary:      computes the error function of x

%erff
Defined in:   math.h
Prototype:    float erff(float /*x*/)
Summary:      computes the error function of x

%erfl
Defined in:   math.h
Prototype:    long double erfl(long double /*x*/)
Summary:      computes the error function of x

%erfc
Defined in:   math.h
Prototype:    double erfc(double /*x*/)
Summary:      computes the complementary error function of x

%erfcf
Defined in:   math.h
Prototype:    float erfcf(float /*x*/)
Summary:      computes the complementary error function of x

%erfcl
Defined in:   math.h
Prototype:    long double erfcl(long double /*x*/)
Summary:      computes the complementary error function of x

%lgamma
Defined in:   math.h
Prototype:    double lgamma(double /*x*/)
Summary:      computes the natural logarithm of the absolute value of
              gamma of x

%lgammaf
Defined in:   math.h
Prototype:    float lgammaf(float /*x*/)
Summary:      computes the natural logarithm of the absolute value of
              gamma of x

%lgammal
Defined in:   math.h
Prototype:    long double lgammal(long double /*x*/)
Summary:      computes the natural logarithm of the absolute value of
              gamma of x

%tgamma
Defined in:   math.h
Prototype:    double tgamma(double /*x*/)
Summary:      computes the gamma function of x

%tgammaf
Defined in:   math.h
Prototype:    float tgammaf(float /*x*/)
Summary:      computes the gamma function of x

%tgammal
Defined in:   math.h
Prototype:    long double tgammal(long double /*x*/)
Summary:      computes the gamma function of x

%ceil
Defined in:   math.h
Prototype:    extern double ceil(double /*x*/)
Summary:      computes the smallest integer not less than x

%ceilf
Defined in:   math.h
Prototype:    extern float ceilf(float /*x*/)
Summary:      computes the smallest integer not less than x

%ceill
Defined in:   math.h
Prototype:    extern long double ceill(long double /*x*/)
Summary:      computes the smallest integer not less than x

%floor
Defined in:   math.h
Prototype:    extern double floor(double /*d*/)
Summary:      computes the largest integer not greater than x

%floorf
Defined in:   math.h
Prototype:    extern float floorf(float /*d*/)
Summary:      computes the largest integer not greater than x

%floorl
Defined in:   math.h
Prototype:    extern long double floorl(long double /*d*/)
Summary:      computes the largest integer not greater than x

%nearbyint
Defined in:   math.h
Prototype:    double nearbyint(double /*x*/)
Summary:      rounds its argument to an integer value, using the current 
              rounding direction. Does not raise the inexact exception.

%nearbyintf
Defined in:   math.h
Prototype:    float nearbyintf(float /*x*/)
Summary:      rounds its argument to an integer value, using the current 
              rounding direction. Does not raise the inexact exception.

%nearbyintl
Defined in:   math.h
Prototype:    long double nearbyintl(long double /*x*/)
Summary:      rounds its argument to an integer value, using the current 
              rounding direction. Does not raise the inexact exception

%rint
Defined in:   math.h
Prototype:    double rint(double /*x*/)
Summary:      rounds its argument to an integer value, using the current 
              rounding direction. Raises inexact exception

%rintf
Defined in:   math.h
Prototype:    float rintf(float /*x*/)
Summary:      rounds its argument to an integer value, using the current 
              rounding direction. Raises inexact exception

%rintl
Defined in:   math.h
Prototype:    long double rintl(long double /*x*/)
Summary:      rounds its argument to an integer value, using the current 
              rounding direction. Raises inexact exception

%lrint
Defined in:   math.h
Prototype:    long int lrint(double /*x*/)
Summary:      rounds its argument to an integer value, using the current 
              rounding direction. Raises inexact exception

%lrintf
Defined in:   math.h
Prototype:    long int lrintf(float /*x*/)
Summary:      rounds its argument to an integer value, using the current 
              rounding direction. Raises inexact exception

%lrintl
Defined in:   math.h
Prototype:    long int lrintl(long double /*x*/)
Summary:      rounds its argument to an integer value, using the current 
              rounding direction. Raises inexact exception

%llrint
Defined in:   math.h
Prototype:    long long int llrint(double /*x*/)
Summary:      rounds its argument to an integer value, using the current 
              rounding direction. Raises inexact exception


%llrintf
Defined in:   math.h
Prototype:    long long int llrintf(float /*x*/)
Summary:      rounds its argument to an integer value, using the current 
              rounding direction. Raises inexact exception


%llrintl
Defined in:   math.h
Prototype:    long long int llrintl(long double /*x*/)
Summary:      rounds its argument to an integer value, using the current 
              rounding direction. Raises inexact exception


%round
Defined in:   math.h
Prototype:    double round(double /*x*/)
Summary:      rounds its argument to the nearest integer value, rounding halfway
              cases away from zero

%roundf
Defined in:   math.h
Prototype:    float roundf(float /*x*/)
Summary:      rounds its argument to the nearest integer value, rounding halfway
              cases away from zero


%roundl
Defined in:   math.h
Prototype:    long double roundl(long double /*x*/)
Summary:      rounds its argument to the nearest integer value, rounding halfway
              cases away from zero


%lround
Defined in:   math.h
Prototype:    long int lround(double /*x*/)
Summary:      rounds its argument to the nearest integer value, rounding halfway
              cases away from zero


%lroundf
Defined in:   math.h
Prototype:    long int lroundf(float /*x*/)
Summary:      rounds its argument to the nearest integer value, rounding halfway
              cases away from zero


%lroundl
Defined in:   math.h
Prototype:    long int lroundl(long double /*x*/)
Summary:      rounds its argument to the nearest integer value, rounding halfway
              cases away from zero


%llround
Defined in:   math.h
Prototype:    long long int llround(double /*x*/)
Summary:      rounds its argument to the nearest integer value, rounding halfway
              cases away from zero


%llroundf
Defined in:   math.h
Prototype:    long long int llroundf(float /*x*/)
Summary:      rounds its argument to the nearest integer value, rounding halfway
              cases away from zero


%llroundl
Defined in:   math.h
Prototype:    long long int llroundl(long double /*x*/)
Summary:      rounds its argument to the nearest integer value, rounding halfway
              cases away from zero

%trunc
Defined in:   math.h
Prototype:    double trunc(double /*x*/)
Summary:      rounds its argument to the integer value, nearest to but no larger
              in magnitude than the argument

%truncf
Defined in:   math.h
Prototype:    float truncf(float /*x*/)
Summary:      rounds its argument to the integer value, nearest to but no larger
              in magnitude than the argument

%truncl
Defined in:   math.h
Prototype:    long double truncl(long double /*x*/)
Summary:      rounds its argument to the integer value, nearest to but no larger
              in magnitude than the argument

%fmod
Defined in:   math.h
Prototype:    extern double fmod(double /*x*/, double /*y*/)
Summary:      computes the floating-point remainder of x/y

%fmodf
Defined in:   math.h
Prototype:    extern float fmodf(float /*x*/, float /*y*/)
Summary:      computes the floating-point remainder of x/y

%fmodl
Defined in:   math.h
Prototype:    extern long double fmodl(long double /*x*/, long double /*y*/)
Summary:      computes the floating-point remainder of x/y

%remainder
Defined in:   math.h
Prototype:    double remainder(double /*x*/, double /*y*/)
Summary:      computes the remainder x REM y required by IEEE 754

%remainderf
Defined in:   math.h
Prototype:    float remainderf(float /*x*/, float /*y*/)
Summary:      computes the remainder x REM y required by IEEE 754

%remainderl
Defined in:   math.h
Prototype:    long double remainderl(long double /*x*/, long double /*y*/)
Summary:      computes the remainder x REM y required by IEEE 754

%remquo
Defined in:   math.h
Prototype:    double remquo(double /*x*/, double /*y*/, int * /*quo*/)
Summary:      compute the same remainder as the remainder functions. In the 
              object pointed to by quo they store a value whose sign is the sign
              of x/y and whose magnitude is congruent modulo 2^n to the 
              magnitude of the integral quotient of x/y, where n is an
              implementation-defined integer greater than or equal to 3 (n=31 
              under RISC OS)

%remquof
Defined in:   math.h
Prototype:    float remquof(float /*x*/, float /*y*/, int * /*quo*/)
Summary:      compute the same remainder as the remainder functions. In the 
              object pointed to by quo they store a value whose sign is the sign
              of x/y and whose magnitude is congruent modulo 2^n to the 
              magnitude of the integral quotient of x/y, where n is an
              implementation-defined integer greater than or equal to 3 (n=31 
              under RISC OS)

%remquol
Defined in:   math.h
Prototype:    long double remquol(long double /*x*/,
                                  long double /*y*/,
                                  int * /*quo*/)
Summary:      compute the same remainder as the remainder functions. In the 
              object pointed to by quo they store a value whose sign is the sign
              of x/y and whose magnitude is congruent modulo 2^n to the 
              magnitude of the integral quotient of x/y, where n is an
              implementation-defined integer greater than or equal to 3 (n=31 
              under RISC OS)

%copysign
Defined in:   math.h
Prototype:    double copysign(double /*x*/, double /*y*/)
Summary:      produce a value with the magnitude of x and the sign of y

%copysignf
Defined in:   math.h
Prototype:    float copysignf(float /*x*/, float /*y*/)
Summary:      produce a value with the magnitude of x and the sign of y

%copysignl
Defined in:   math.h
Prototype:    long double copysignl(long double /*x*/, long double /*y*/)
Summary:      produce a value with the magnitude of x and the sign of y

%nan
Defined in:   math.h
Prototype:    double nan(const char * /*tagp*/)
Summary:      Returns: a quiet NaN, with content indicated through tagp

%nanf
Defined in:   math.h
Prototype:    float nanf(const char * /*tagp*/)
Summary:      Returns: a quiet NaN, with content indicated through tagp

%nanl
Defined in:   math.h
Prototype:    long double nanl(const char * /*tagp*/)
Summary:      Returns: a quiet NaN, with content indicated through tagp

%nextafter
Defined in:   math.h
Prototype:    double nextafter(double /*x*/, double /*y*/)
Summary:      Returns: the next representable value in the specified format 
              after x in the direction of y

%nextafterf
Defined in:   math.h
Prototype:    float nextafterf(float /*x*/, float /*y*/)
Summary:      Returns: the next representable value in the specified format 
              after x in the direction of y

%nextafterl
Defined in:   math.h
Prototype:    long double nextafterl(long double /*x*/, long double /*y*/)
Summary:      Returns: the next representable value in the specified format 
              after x in the direction of y

%nexttoward
Defined in:   math.h
Prototype:    double nexttoward(double /*x*/, long double /*y*/)
Summary:      Returns: the next representable value in the specified format 
              after x in the direction of y


%nexttowardf
Defined in:   math.h
Prototype:    float nextafterf(float /*x*/, float /*y*/)
Summary:      Returns: the next representable value in the specified format 
              after x in the direction of y


%nexttowardl
Defined in:   math.h
Prototype:    long double nextafterl(long double /*x*/, long double /*y*/)
Summary:      Returns: the next representable value in the specified format 
              after x in the direction of y


%fdim
Defined in:   math.h
Prototype:    double fdim(double /*x*/, double /*y*/)
Summary:      determine the positive difference between the arguments

%fdimf
Defined in:   math.h
Prototype:    float fdimf(float /*x*/, float /*y*/)
Summary:      determine the positive difference between the arguments

%fdiml
Defined in:   math.h
Prototype:    long double fdiml(long double /*x*/, long double /*y*/)
Summary:      determine the positive difference between the arguments

%fmax
Defined in:   math.h
Prototype:    double fmax(double /*x*/, double /*y*/)
Summary:      Returns: the maximum numeric value of the arguments

%fmaxf
Defined in:   math.h
Prototype:    float fmaxf(float /*x*/, float /*y*/)
Summary:      Returns: the maximum numeric value of the arguments

%fmaxl
Defined in:   math.h
Prototype:    long double fmaxl(long double /*x*/, long double /*y*/)
Summary:      Returns: the maximum numeric value of the arguments

%fmin
Defined in:   math.h
Prototype:    double fmin(double /*x*/, double /*y*/)
Summary:      Returns: the minimum numeric value of the arguments

%fminf
Defined in:   math.h
Prototype:    float fminf(float /*x*/, float /*y*/)
Summary:      Returns: the minimum numeric value of the arguments

%fminl
Defined in:   math.h
Prototype:    long double fminl(long double /*x*/, long double /*y*/)
Summary:      Returns: the minimum numeric value of the arguments

%fma
Defined in:   math.h
Prototype:    double fma(double /*x*/, double /*y*/, double /*z*/)
Summary:      computes (x*y)+z, rounded as one ternary operation: it computes
              the value (as if) to infinite precision and rounds once to the
              result format, according to the rounding mode characterised by the 
              value of FLT_ROUNDS

%fmaf
Defined in:   math.h
Prototype:    float fmaf(float /*x*/, float /*y*/, float /*z*/)
Summary:      computes (x*y)+z, rounded as one ternary operation: it computes
              the value (as if) to infinite precision and rounds once to the
              result format, according to the rounding mode characterised by the 
              value of FLT_ROUNDS

%fmal
Defined in:   math.h
Prototype:    long double fmal(long double /*x*/,
                               long double /*y*/, 
                               long double /*z*/)
Summary:      computes (x*y)+z, rounded as one ternary operation: it computes
              the value (as if) to infinite precision and rounds once to the
              result format, according to the rounding mode characterised by the 
              value of FLT_ROUNDS

%isgreater
Defined in:   math.h
Prototype:    int isgreater(real-floating x, real-floating y)
Summary:      this macro returns the value of x > y, without risking causing
              a floating point exception when values are not-a-number

%isgreaterequal
Defined in:   math.h
Prototype:    int isgreaterequal(real-floating x, real-floating y)
Summary:      this macro returns the value of x >= y, without risking causing
              a floating point exception when values are not-a-number

%isless
Defined in:   math.h
Prototype:    int isless(real-floating x, real-floating y)
Summary:      this macro returns the value of x < y, without risking causing
              a floating point exception when values are not-a-number

%islessequal
Defined in:   math.h
Prototype:    int islessequal(real-floating x, real-floating y)
Summary:      this macro returns the value of x <= y, without risking causing
              a floating point exception when values are not-a-number

%islessgreater
Defined in:   math.h
Prototype:    int islessgreater(real-floating x, real-floating y)
Summary:      this macro returns the value of x < y | x > y, without risking
              causing a floating point exception when values are not-a-number

%isunordered
Defined in:   math.h
Prototype:    int isunordered(real-floating x, real-floating y)
Summary:      this macro returns 1 if its arguments are unordered and 0
              otherwise

%setjmp
Defined in:   setjmp.h
Prototype:    extern int setjmp(jmp_buf /*env*/)
Summary:      saves its calling environment in its jmp_buf argument, for 
              later use by the longjmp function

%longjmp
Defined in:   setjmp.h
Prototype:    extern void longjmp(jmp_buf /*env*/, int /*val*/)
Summary:      restores the environment saved by the most recent call to 
              setjmp in the same invocation of the program, with the 
              corresponding jmp_buf argument

%SIG_DFL
Defined in:   signal.h
Summary:      default action on signal raise

%SIG_ERR
Defined in:   signal.h
Summary:      returned by signal() to indicate error

%SIG_IGN
Defined in:   signal.h
Summary:      ignore a particular signal
 
%SIGABRT
Defined in:   signal.h
Definition:   #define SIGABRT 1
Summary:      signal raised on abort

%SIGFPE
Defined in:   signal.h
Definition:   #define SIGFPE  2
Summary:      signal raised on arithmetic exception
              under RISC OS, this means Divide by Zero, or illegal FP op or 
              overflow  

%SIGILL
Defined in:   signal.h
Definition:   #define SIGILL  3
Summary:      signal raised on illegal instruction 
              under RISC OS, this means ARM exceptions Illegal Instruction, 
              Prefetch Abort and Branch Through Zero

%SIGINT
Defined in:   signal.h
Definition:   #define SIGINT  4
Summary:      signal raised on attention request from user
              under RISC OS, typically ESCAPE has been pressed

%SIGSEGV
Defined in:   signal.h
Definition:   #define SIGSEGV 5
Summary:      signal raised on bad memory access
              under RISC OS, this means ARM exceptions Data Abort and 
              Address Exception or Read/Write memory error

%SIGTERM
Defined in:   signal.h
Definition:   #define SIGTERM 6
Summary:      signal raised on termination request

%SIGSTAK
Defined in:   signal.h
Definition:   #define SIGSTAK 7
Summary:      signal raised on stack overflow 

%SIGUSR1
Defined in:   signal.h
Definition:   #define SIGUSR1 8
Summary:      user-defined signal 1 
 
%SIGUSR2
Defined in:   signal.h
Definition:   #define SIGUSR1 9
Summary:      user-defined signal 2

%SIGOSERROR
Defined in:   signal.h
Definition:   #define SIGOSERROR 10
Summary:

%signal
Defined in:   signal.h
Prototype:    extern void (*signal (int /*sig*/, 
                           void (* /*func*/ )(int)))(int)
Summary:      choose one of three ways to handle given signal
              SIG_IGN, SIG_DFL or your own function

%raise
Defined in:   signal.h
Prototype:    extern int raise(int /*sig*/)
Summary:      sends the signal sig to the executing program

%va_start
Defined in:   stdarg.h
Definition:   va_start(ap, parmN)  where ap is of type va_list, and parmN is 
              rightmost 'normal' parameter
Summary:      start access to variable parameter list

%va_arg
Defined in:   stdarg.h
Definition:   va_arg(ap, type)  where ap is of type va_list, and type is 
              type of this argument in the list
Summary:      gets next parameter in variable parameter list (after va_start)

%va_copy
Defined in:   stdarg.h
Definition:   va_copy(dest, src)  where dest and src are of type va_list
Summary:      initialises dest as a copy of src

%va_end
Defined in:   stdarg.h
Definition:   va_end(ap)  where ap is of type va_list
Summary:      allow normal return from function having variable parameter 
              list

%false
Defined in:   stdbool.h
Definition:   #define false 0
Summary:      Boolean value of bool type

%true
Defined in:   stdbool.h
Definition:   #define true 1
Summary:      Boolean value of bool type

%bool
Defined in:   stdbool.h
Definition:   #define bool _Bool
Summary:      Boolean type

%ptrdiff_t
Defined in:   stddef.h
Definition:   typedef int ptrdiff_t
Summary:      the signed integral type of the result of subtracting two 
              pointers

%size_t
Defined in:   stddef.h
Definition:   typedef unsigned int size_t
Summary:      the unsigned integral type of the result of the sizeof operator

%wchar_t
Defined in:   stddef.h
Definition:   typedef int wchar_t
Summary:      An integral type whose range of values can represent distinct 
              codes for all members of the largest extended character set 
              specified among the supported locales

%offsetof
Defined in:   stddef.h
Definition:   offsetof(type, member)
Summary:      gives the offset in bytes, from the beginning of a structure
              designated by type, of the member designated by the identifier

%int8_t
Defined in:   stdint.h
Definition:   typedef signed char int8_t
Summary:      signed integer type exactly 8 bits wide

%uint8_t
Defined in:   stdint.h
Definition:   typedef unsigned char uint8_t
Summary:      unsigned integer type exactly 8 bits wide

%int16_t
Defined in:   stdint.h
Definition:   typedef signed short int16_t
Summary:      signed integer type exactly 16 bits wide

%uint16_t
Defined in:   stdint.h
Definition:   typedef unsigned short uint16_t
Summary:      unsigned integer type exactly 16 bits wide

%int32_t
Defined in:   stdint.h
Definition:   typedef signed int int32_t
Summary:      signed integer type exactly 32 bits wide

%uint32_t
Defined in:   stdint.h
Definition:   typedef unsigned int uint32_t
Summary:      unsigned integer type exactly 32 bits wide

%int_least8_t
Defined in:   stdint.h
Definition:   typedef signed char int_least8_t
Summary:      smallest signed integer type which is at least 8 bits wide

%uint_least8_t
Defined in:   stdint.h
Definition:   typedef unsigned char uint_least8_t
Summary:      smallest unsigned integer type which is at least 8 bits wide

%int_least16_t
Defined in:   stdint.h
Definition:   typedef signed short int_least16_t
Summary:      smallest signed integer type which is at least 16 bits wide

%uint_least16_t
Defined in:   stdint.h
Definition:   typedef unsigned short uint_least16_t
Summary:      smallest unsigned integer type which is at least 16 bits wide

%int_least32_t
Defined in:   stdint.h
Definition:   typedef signed int int_least32_t
Summary:      smallest signed integer type which is at least 32 bits wide

%uint_least32_t
Defined in:   stdint.h
Definition:   typedef unsigned int uint_least32_t
Summary:      smallest unsigned integer type which is at least 32 bits wide

%int_fast8_t
Defined in:   stdint.h
Definition:   typedef signed char int_fast8_t
Summary:      fastest signed integer type which is at least 8 bits wide

%uint_fast8_t
Defined in:   stdint.h
Definition:   typedef unsigned char uint_fast8_t
Summary:      fastest unsigned integer type which is at least 8 bits wide

%int_fast16_t
Defined in:   stdint.h
Definition:   typedef signed short int_fast16_t
Summary:      fastest signed integer type which is at least 16 bits wide

%uint_fast16_t
Defined in:   stdint.h
Definition:   typedef unsigned short uint_fast16_t
Summary:      fastest unsigned integer type which is at least 16 bits wide

%int_fast32_t
Defined in:   stdint.h
Definition:   typedef signed int int_fast32_t
Summary:      fastest signed integer type which is at least 32 bits wide

%uint_fast32_t
Defined in:   stdint.h
Definition:   typedef unsigned int uint32_t
Summary:      fastest unsigned integer type which is at least 32 bits wide

%intptr_t
Defined in:   stdint.h
Definition:   typedef signed int intptr_t;
Summary:      signed integer type capable of holding a pointer 

%uintptr_t
Defined in:   stdint.h
Definition:   typedef unsigned int uintptr_t;
Summary:      unsigned integer type capable of holding a pointer 

%int64_t
Defined in:   stdint.h
Definition:   typedef signed long long int64_t
Summary:      signed integer type exactly 64 bits wide

%uint64_t
Defined in:   stdint.h
Definition:   typedef unsigned long long uint64_t
Summary:      unsigned integer type exactly 64 bits wide

%int_least64_t
Defined in:   stdint.h
Definition:   typedef signed long long int_least64_t
Summary:      smallest signed integer type which is a least 64 bits wide

%uint_least64_t
Defined in:   stdint.h
Definition:   typedef unsigned long long uint_least64_t
Summary:      smallest unsigned integer type which is a least 64 bits wide

%int_fast64_t
Defined in:   stdint.h
Definition:   typedef signed long long int_fast64_t
Summary:      fastest signed integer type which is a least 64 bits wide

%uint_fast64_t
Defined in:   stdint.h
Definition:   typedef unsigned long long uint_fast64_t
Summary:      fastest unsigned integer type which is a least 64 bits wide

%intmax_t
Defined in:   stdint.h
Definition:   typedef signed long long intmax_t
Summary:      signed integer type that can hold the value of any other signed
              integer type

%uintmax_t
Defined in:   stdint.h
Definition:   typedef unsigned long long uintmax_t
Summary:      unsigned integer type that can hold the value of any other
              unsigned integer type

%INT8_MIN
Defined in:   stdint.h
Definition:   #define INT8_MIN         (-0x80) 
Summary:      minimum int8_t value 

%INT8_MAX
Defined in:   stdint.h
Definition:   #define INT8_MAX         0x7F
Summary:      maximum int8_t value

%UINT8_MAX
Defined in:   stdint.h
Definition:   #define UINT8_MAX        0xFF
Summary:      maximum unit8_t value

%INT16_MIN
Defined in:   stdint.h
Definition:   #define INT16_MIN        (-0x8000)
Summary:      minimum int16_t value

%INT16_MAX
Defined in:   stdint.h
Definition:   #define INT16_MAX        0x7FFF
Summary:      maximum int16_t value

%UINT16_MAX
Defined in:   stdint.h
Definition:   #define UINT16_MAX       0xFFFF
Summary:      maximum uint16_t value

%INT32_MIN
Defined in:   stdint.h
Definition:   #define INT32_MIN        (~0x7FFFFFFF)
Summary:      minimum it32_t value

%INT32_MAX
Defined in:   stdint.h
Definition:   #define INT32_MAX        0x7FFFFFFF
Summary:      maximum int32_t value

%UINT32_MAX
Defined in:   stdint.h
Definition:   #define UINT32_MAX       0xFFFFFFFF
Summary:      maximum uint32_t value

%INT_LEAST8_MIN
Defined in:   stdint.h
Definition:   #define INT_LEAST8_MIN   (-0x80)
Summary:      minimum int_least8_t value

%INT_LEAST8_MAX
Defined in:   stdint.h
Definition:   #define INT_LEAST8_MAX   0x7F
Summary:      maximum int_least8_t value

%UINT_LEAST8_MAX
Defined in:   stdint.h
Definition:   #define UINT_LEAST8_MAX  0xFF
Summary:      maximum uint_least8_t value

%INT_LEAST16_MIN
Defined in:   stdint.h
Definition:   #define INT_LEAST16_MIN  (-0x8000)
Summary:      minimum int_least16_t value

%INT_LEAST16_MAX
Defined in:   stdint.h
Definition:   #define INT_LEAST16_MAX  0x7FFF
Summary:      maximum int_least16_t value

%UINT_LEAST16_MAX
Defined in:   stdint.h
Definition:   #define UINT_LEAST16_MAX 0xFFFF
Summary:      maximum uint_least16_t value

%INT_LEAST32_MIN
Defined in:   stdint.h
Definition:   #define INT_LEAST32_MIN  (~0x7FFFFFFF)
Summary:      minimum int_least32_t value

%INT_LEAST32_MAX
Defined in:   stdint.h
Definition:   #define INT_LEAST32_MAX  0x7FFFFFFF
Summary:      maximum int_least32_t value

%UINT_LEAST32_MAX
Defined in:   stdint.h
Definition:   #define UINT_LEAST32_MAX 0xFFFFFFFF
Summary:      maximum uint_least32_t value

%INT_FAST8_MIN
Defined in:   stdint.h
Definition:   #define INT_FAST8_MIN    (~0x7FFFFFFF)
Summary:      minimum int_fast8_t value

%INT_FAST8_MAX
Defined in:   stdint.h
Definition:   #define INT_FAST8_MAX    0x7FFFFFFF
Summary:      maximum int_fast8_t value

%UINT_FAST8_MAX
Defined in:   stdint.h
Definition:   #define UINT_FAST8_MAX   0xFFFFFFFF
Summary:      maximum uint_fast8_t value

%INT_FAST16_MIN
Defined in:   stdint.h
Definition:   #define INT_FAST16_MIN   (~0x7FFFFFFF)
Summary:      minimum int_fast16_t value

%INT_FAST16_MAX
Defined in:   stdint.h
Definition:   #define INT_FAST16_MAX   0x7FFFFFFF
Summary:      maximum int_fast16_t value

%UINT_FAST16_MAX
Defined in:   stdint.h
Definition:   #define UINT_FAST16_MAX  0xFFFFFFFF
Summary:      maximum uint_fast16_t value

%INT_FAST32_MIN
Defined in:   stdint.h
Definition:   #define INT_FAST32_MIN   (~0x7FFFFFFF)
Summary:      minimum int_fast32_t value

%INT_FAST32_MAX
Defined in:   stdint.h
Definition:   #define INT_FAST32_MAX   0x7FFFFFFF
Summary:      maximum int_fast32_t value

%UINT_FAST32_MAX
Defined in:   stdint.h
Definition:   #define UINT_FAST32_MAX  0xFFFFFFFF
Summary:      maximum uint_fast32_t value

%INTPTR_MIN
Defined in:   stdint.h
Definition:   #define INTPTR_MIN       (~0x7FFFFFFF)
Summary:      minimum intptr_t value

%INTPTR_MAX
Defined in:   stdint.h
Definition:   #define INTPTR_MAX       0x7FFFFFFF
Summary:      maximum intptr_t value

%UINTPTR_MAX
Defined in:   stdint.h
Definition:   #define UINTPTR_MAX      0xFFFFFFFF
Summary:      maximum uintptr_t value

%INT64_MIN
Defined in:   stdint.h
Definition:   #define INT64_MIN        (~0x7FFFFFFFFFFFFFFF)
Summary:      minimum int64_t value

%INT64_MAX
Defined in:   stdint.h
Definition:   #define INT64_MAX        0x7FFFFFFFFFFFFFFF
Summary:      maximum int64_t value

%UINT64_MAX
Defined in:   stdint.h
Definition:   #define UINT64_MAX       0xFFFFFFFFFFFFFFFF
Summary:      maximum uint64_t value

%INT_LEAST64_MIN
Defined in:   stdint.h
Definition:   #define INT_LEAST64_MIN  (~0x7FFFFFFFFFFFFFFF)
Summary:      minimum int_least64_t value

%INT_LEAST64_MAX
Defined in:   stdint.h
Definition:   #define INT_LEAST64_MAX  0x7FFFFFFFFFFFFFFF
Summary:      maximum int_least64_t value

%UINT_LEAST64_MAX
Defined in:   stdint.h
Definition:   #define UINT_LEAST64_MAX 0xFFFFFFFFFFFFFFFF
Summary:      maximum uint_least64_t value

%INT_FAST64_MIN
Defined in:   stdint.h
Definition:   #define INT_FAST64_MIN   (~0x7FFFFFFFFFFFFFFF)
Summary:      minimum int_fast64_t value

%INT_FAST64_MAX
Defined in:   stdint.h
Definition:   #define INT_FAST64_MAX   0x7FFFFFFFFFFFFFFF
Summary:      maximum int_fast64_t value

%UINT_FAST64_MAX
Defined in:   stdint.h
Definition:   #define UINT_FAST64_MAX  0xFFFFFFFFFFFFFFFF
Summary:      maximum uint_fast64_t value

%INTMAX_MIN
Defined in:   stdint.h
Definition:   #define INTMAX_MIN       (~0x7FFFFFFFFFFFFFFF)
Summary:      minimum intmax_t value

%INTMAX_MAX
Defined in:   stdint.h
Definition:   #define INTMAX_MAX       0x7FFFFFFFFFFFFFFF
Summary:      maximum intmax_t value

%UINTMAX_MAX
Defined in:   stdint.h
Definition:   #define UINTMAX_MAX      0xFFFFFFFFFFFFFFFF
Summary:      maximum uintmax_t value

%PTRDIFF_MIN
Defined in:   stdint.h
Definition:   #define PTRDIFF_MIN      (~0x7FFFFFFF)
Summary:      minimum ptrdiff_t value

%PTRDIFF_MAX
Defined in:   stdint.h
Definition:   #define PTRDIFF_MAX      0x7FFFFFFF
Summary:      maximum ptrdiff_t value


%SIG_ATOMIC_MIN
Defined in:   stdint.h
Definition:   #define SIG_ATOMIC_MIN   (~0x7FFFFFFF)
Summary:      minimum sig_atomic_t value

%SIG_ATOMIC_MAX
Defined in:   stdint.h
Definition:   #define SIG_ATOMIC_MAX   0x7FFFFFFF
Summary:      maximum sig_atomic_t value

%SIZE_MAX
Defined in:   stdint.h
Definition:   #define SIZE_MAX         0xFFFFFFFF
Summary:      maximum size_t value

%WCHAR_MIN
Defined in:   stdint.h
Definition:   #define WCHAR_MIN        (~0x7FFFFFFF)
Summary:      minimum wchar_t value

%WCHAR_MAX
Defined in:   stdint.h
Definition:   #define WCHAR_MAX        0x7FFFFFFF
Summary:      maximum wchar_t value

%INT8_C
Defined in:   stdint.h
Definition:   #define INT8_C(n)    n
Summary:      macro for creating int8_t constants

%UINT8_C
Defined in:   stdint.h
Definition:   #define UINT8_C(n)   n##u
Summary:      macro for creating uint8_t constants

%INT16_C
Defined in:   stdint.h
Definition:   #define INT16_C(n)   n
Summary:      macro for creating int16_t constants

%UINT16_C
Defined in:   stdint.h
Definition:   #define UINT16_C(n)  n##u
Summary:      macro for creating uint16_t constants

%INT32_C
Defined in:   stdint.h
Definition:   #define INT32_C(n)   n
Summary:      macro for creating int32_t constants

%UINT32_C
Defined in:   stdint.h
Definition:   #define UINT32_C(n)  n##u
Summary:      macro for creating uint32_t constants

%INT64_C
Defined in:   stdint.h
Definition:   #define INT64_C(n)   n##ll
Summary:      macro for creating int64_t constants

%UINT64_C
Defined in:   stdint.h
Definition:   #define UINT64_C(n)  n##ull
Summary:      macro for creating uint64_t constants

%INTMAX_C
Defined in:   stdint.h
Definition:   #define INTMAX_C(n)  n##ll
Summary:      macro for creating intmax_t constants

%UINTMAX_C
Defined in:   stdint.h
Definition:   #define UINTMAX_C(n) n##ull
Summary:      macro for creating uintmax_t constants

%fpos_t
Defined in:   stdio.h
Summary:      type used to describe position in file

%FILE
Defined in:   stdio.h
Summary:      type used to describe a stream

%BUFSIZ
Defined in:   stdio.h
Summary:      system buffer size (as used by setbuf)

%EOF
Defined in:   stdio.h
Definition:   #define EOF      (-1)
Summary:      negative integral constant, indicates end-of-file

%FOPEN_MAX
Defined in:   stdio.h
Summary:      an integral constant expression that is the minimum number of
              files that this implementation guarantees can be open
              simultaneously

%FILENAME_MAX
Defined in:   stdio.h
Summary:      an integral constant expression that is the size of an array 
              of char large enough to hold the longest filename string

%L_tmpnam
Defined in:   stdio.h
Definition:   #define L_tmpnam 80
Summary:      an integral constant expression that is the size of an array 
              of char large enough to hold a temporary file name string 
              generated by the tmpnam function

%TMP_MAX
Defined in:   stdio.h
Summary:      an integral constant expression that is the minimum number of 
              unique file names that shall be generated by the tmpnam 
              function

%stdin
Defined in:   stdio.h
Definition:   #define stdin  (&__iob[0])
Summary:      standard input stream pointer

%stdout
Defined in:   stdio.h
Definition:   #define stdout  (&__iob[1])
Summary:      standard output stream pointer

%stderr
Defined in:   stdio.h
Definition:   #define stderr  (&__iob[2])
Summary:      standard error stream pointer

%remove
Defined in:   stdio.h
Prototype:    extern int remove(const char * /*filename*/)
Summary:      causes the file whose name is the string pointed to by 
              filename to be removed. Subsequent attempts to open the file 
              will fail, unless it is created anew. If the file is open, the 
              behaviour of the remove function is implementation-defined 
              (under RISC OS the operation fails).
              
%rename
Defined in:   stdio.h
Prototype:    extern int rename(const char * /*old*/, const char * /*new*/)
Summary:      causes the file whose name is the string pointed to by old to 
              be henceforth known by the name given by the string pointed to 
              by new. The file named old is effectively removed. If a file 
              named by the string pointed to by new exists prior to the call 
              of the rename function, the behaviour is implementation-
              defined (under RISC OS, the operation fails).
              
%tmpfile
Defined in:   stdio.h
Prototype:    extern FILE *tmpfile(void)
Summary:      creates a temporary binary file that will be automatically 
              removed when it is closed or at program termination. The file 
              is opened for update.
              
%tmpnam
Defined in:   stdio.h
Prototype:    extern char *tmpnam(char * /*s*/)
Summary:      generates a string that is not the same as the name of an 
              existing file.
              The tmpnam function generates a different string each time it 
              is called, up to TMP_MAX times. If it is called more than 
              TMP_MAX times, the behaviour is implementation-defined (under 
              RISC OS the algorithm for the name generation 
              works just as well after tmpnam has been called more than 
              TMP_MAX times as before; a name clash is impossible in any 
              single half year period).
              
%fclose
Defined in:   stdio.h
Prototype:    extern int fclose(FILE * /*stream*/)
Summary:      causes the stream pointed to by stream to be flushed and the 
              associated file to be closed. Any unwritten buffered data for 
              the stream are delivered to the host environment to be written 
              to the file; any unread buffered data are discarded. The 
              stream is disassociated from the file.  If the associated 
              buffer was automatically allocated, it is deallocated.
              
%fflush
Defined in:   stdio.h
Prototype:    extern int fflush(FILE * /*stream*/)
Summary:      If the stream points to an output or update stream in which 
              the most recent operation was output, the fflush function 
              causes any unwritten data for that stream to be delivered to 
              the host environment to be written to the file. If the stream 
              points to an input or update stream, the fflush function 
              undoes the effect of any preceding ungetc operation on the 
              stream.
              
%fopen
Defined in:   stdio.h
Prototype:    extern FILE *fopen(const char * /*filename*/, 
                                 const char * /*mode*/)
Summary:      opens the file whose name is the string pointed to by 
              filename, and associates a stream with it.
              The argument mode points to a string beginning with one of 
              the following sequences:
              "r"         open text file for reading
              "w"         create text file for writing, or truncate to zero 
                          length
              "a"         append; open text file or create for writing at eof
              "rb"        open binary file for reading
              "wb"        create binary file for writing, or truncate to 
                          zero length
              "ab"        append; open binary file or create for writing at 
                          eof
              "r+"        open text file for update (reading and writing)
              "w+"        create text file for update, or truncate to zero 
                          length
              "a+"        append; open text file or create for update, 
                          writing at eof
              "r+b"/"rb+" open binary file for update (reading and writing)
              "w+b"/"wb+" create binary file for update, or truncate to 
                          zero length
              "a+b"/"ab+" append; open binary file or create for update, 
                          writing at eof
             
              Opening a file with read mode ('r' as the first character in 
              the mode argument) fails if the file does not exist or cannot 
              be read.
              Opening a file with append mode ('a' as the first character in 
              the mode argument) causes all subsequent writes to be forced 
              to the current end of file, regardless of intervening calls to 
              the fseek function. In some implementations, opening a binary 
              file with append mode ('b' as the second or third character in 
              the mode argument) may initially position the file position 
              indicator beyond the last data written, because of the NUL 
              padding (but not under RISC OS).
              When a file is opened with update mode ('+' as the second or 
              third character in the mode argument), both input and output 
              may be performed on the associated stream. However, output may 
              not be directly followed by input without an intervening call 
              to the fflush fuction or to a file positioning function 
              (fseek, fsetpos, or rewind), and input be not be directly 
              followed by output without an intervening call to the fflush 
              fuction or to a file positioning function, unless the input 
              operation encounters end-of-file. Opening a file with update 
              mode may open or create a binary stream in some 
              implementations (but not under RISC OS). When 
              opened, a stream is fully buffered if and only if it does not 
              refer to an interactive device. The error and end-of-file
              indicators for the stream are cleared.
              
%freopen
Defined in:   stdio.h
Prototype:    extern FILE *freopen(const char * /*filename*/, 
                                   const char * /*mode*/,
                                   FILE * /*stream*/)
Summary:      opens the file whose name is the string pointed to by filename 
              and associates the stream pointed to by stream with it. The 
              mode argument is used just as in the fopen function.
              The freopen function first attempts to close any file that is 
              associated with the specified stream. Failure to close the 
              file successfully is ignored. The error and end-of-file 
              indicators for the stream are cleared.
              
%setbuf
Defined in:   stdio.h
Prototype:    extern void setbuf(FILE * /*stream*/, char * /*buf*/)
Summary:      Except that it returns no value, the setbuf function is 
              equivalent to the setvbuf function invoked with the values 
              _IOFBF for mode and BUFSIZ for size, or (if buf is a null 
              pointer), with the value _IONBF for mode.
              
%setvbuf
Defined in:   stdio.h
Prototype:    extern int setvbuf(FILE * /*stream*/, char * /*buf*/,
                                 int /*mode*/, size_t /*size*/)
Summary:      may be used after the stream pointed to by stream has been 
              associated with an open file but before it is read or written. 
              The argument mode determines how stream will be buffered, as 
              follows: _IOFBF causes input/output to be fully buffered; 
              _IOLBF causes output to be line buffered (the buffer will be 
              flushed when a new-line character is written, when the buffer 
              is full, or when input is requested); _IONBF causes 
              input/output to be completely unbuffered. If buf is not the 
              null pointer, the array it points to may be used instead of 
              an automatically allocated buffer (the buffer must have a 
              lifetime at least as great as the open stream, so the stream 
              should be closed before a buffer that has automatic storage 
              duration is deallocated upon block exit). The argument
              size specifies the size of the array. The contents of the 
              array at any time are indeterminate.
              
%fprintf
Defined in:   stdio.h
Prototype:    extern int fprintf(FILE * /*stream*/, 
                                 const char * /*format*/, ...)
Summary:      writes output to the stream pointed to by stream, under 
              control of the string pointed to by format that specifies how 
              subsequent arguments are converted for output. If there are 
              insufficient arguments for the format, the behaviour is 
              undefined. If the format is exhausted while arguments remain, 
              the excess arguments are evaluated but otherwise ignored. The
              fprintf function returns when the end of the format string is 
              reached.  The format shall be a multibyte character sequence, 
              beginning and ending in its initial shift state. The format is 
              composed of zero or more directives: ordinary multibyte 
              characters (not %), which are copied unchanged to the output 
              stream; and conversion specifiers, each of which results in 
              fetching zero or more subsequent arguments. Each conversion
              specification is introduced by the character %. For a 
              description of the available conversion specifiers refer to
              section 7.19.6.1 of standard ISO9899:1999 or to any modern
              textbook on C.
              The minimum value for the maximum number of characters 
              producable by any single conversion is at least 509.
              
%printf
Defined in:   stdio.h 
Prototype:    extern int printf(const char * /*format*/, ...) 
Summary:      is equivalent to fprintf with the argument stdout interposed 
              before the arguments to printf.
              
%sprintf
Defined in:   stdio.h
Prototype:    extern int sprintf(char * /*s*/, const char * /*format*/, ...)
Summary:      is equivalent to fprintf, except that the argument s specifies 
              an array into which the generated output is to be written, 
              rather than to a stream. A null character is written at the 
              end of the characters written; it is not counted as part of 
              the returned sum.

%snprintf
Defined in:   stdio.h
Prototype:    extern int snprintf(char * /*s*/, size_t /*n*/,
                                  const char * /*format*/, ...)
Summary:      is equivalent to sprintf, except that the argument n specifies
              the maximum size of the array into which the generated output is
              to be written, including the null terminator. A null character
              is written at the end of the characters written; it is not
              counted as part of the returned sum.
              
%fscanf
Defined in:   stdio.h
Prototype:    extern int fscanf(FILE * /*stream*/, 
                                const char * /*format*/, ...)
Summary:      reads input from the stream pointed to by stream, under 
              control of the string pointed to by format that specifies the 
              admissible input sequences and how thay are to be converted 
              for assignment, using subsequent arguments as pointers to the 
              objects to receive the converted input. If there are 
              insufficient arguments for the format, the behaviour is
              undefined. If the format is exhausted while arguments remain, 
              the excess arguments are evaluated but otherwise ignored.
              The format is composed of zero or more directives: one or more
              white-space characters; an ordinary character (not %); or a 
              conversion specification. Each conversion specification is 
              introduced by the character %. For a description of the 
              available conversion specifiers refer to section 7.19.6.2 of
              standard ISO9899:1999 or to any modern textbook on C.
              If end-of-file is encountered during input, conversion is 
              terminated. If end-of-file occurs before any characters 
              matching the current directive have been read (other than 
              leading white space, where permitted), execution of the 
              current directive terminates with an input failure; otherwise, 
              unless execution of the current directive is terminated with a
              matching failure, execution of the following directive (if 
              any) is terminated with an input failure.
              If conversions terminates on a conflicting input character, 
              the offending input character is left unread in the input 
              stream. Trailing white space (including new-line characters) 
              is left unread unless matched by a directive. The success of 
              literal matches and suppressed asignments is not directly 
              determinable other than via the %n directive.
              
%scanf
Defined in:   stdio.h
Prototype:    extern int scanf(const char * /*format*/, ...)
Summary:      is equivalent to fscanf with the argument stdin interposed 
              before the arguments to scanf.
              
%sscanf
Defined in:   stdio.h
Prototype:    extern int sscanf(const char * /*s*/, 
                                const char * /*format*/, ...)
Summary:      is equivalent to fscanf except that the argument s specifies a 
              string from which the input is to be obtained, rather than 
              from a stream.
              Reaching the end of the string is equivalent to encountering 
              end-of-file for the fscanf function.
              
%vprintf
Defined in:   stdio.h
Prototype:    extern int vprintf(const char * /*format*/, __va_list /*arg*/)
Summary:      is equivalent to printf, with the variable argument list 
              replaced by arg, which has been initialised by the va_start 
              macro (and possibly subsequent va_arg calls). The vprintf 
              function does not invoke the va_end function.
              
%vfprintf
Defined in:   stdio.h
Prototype:    extern int vfprintf(FILE * /*stream*/,
                   const char * /*format*/, __va_list /*arg*/)
Summary:      is equivalent to fprintf, with the variable argument list 
              replaced by arg, which has been initialised by the va_start 
              macro (and possibly subsequent va_arg calls). The vfprintf 
              function does not invoke the va_end function.
              
%vsprintf
Defined in:   stdio.h
Prototype:    extern int vsprintf(char * /*s*/, const char * /*format*/, 
                                  __va_list /*arg*/)
Summary:      is equivalent to sprintf, with the variable argument list 
              replaced by arg, which has been initialised by the va_start 
              macro (and possibly subsequent va_arg calls). The vsprintf 
              function does not invoke the va_end function.

%vsnprintf
Defined in:   stdio.h
Prototype:    extern int vsnprintf(char * /*s*/, size_t /*n*/,
                                   const char * /*format*/, __va_list /*arg*/)
Summary:      is equivalent to snprintf, with the variable argument list
              replaced by arg, which has been initialised by the va_start 
              macro (and possibly subsequent va_arg calls). The vsnprintf 
              function does not invoke the va_end function.

%vfscanf
Defined in:   stdio.h
Prototype:    extern int vfscanf(FILE * /*stream*/, const char * /*format*/,
                                 __va_list /*arg*/)
Summary:      is equivalent to fscanf, with the variable argument list
              replaced by arg, which has been initialised by the va_start 
              macro (and possibly subsequent va_arg calls). The vfscanf 
              function does not invoke the va_end function.

%vscanf
Defined in:   stdio.h
Prototype:    extern int vscanf(const char * /*format*/, __va_list /*arg*/)
Summary:      is equivalent to scanf, with the variable argument list
              replaced by arg, which has been initialised by the va_start 
              macro (and possibly subsequent va_arg calls). The vscanf
              function does not invoke the va_end function.

%vsscanf
Defined in:   stdio.h
Prototype:    extern int vsscanf(const char * /*s*/, 
                                 const char * /*format*/, __va_list /*arg*/)
Summary:      is equivalent to sscanf, with the variable argument list
              replaced by arg, which has been initialised by the va_start 
              macro (and possibly subsequent va_arg calls). The vsscanf
              function does not invoke the va_end function.

%fgetc
Defined in:   stdio.h
Prototype:    extern int fgetc(FILE * /*stream*/)
Summary:      obtains the next character (if present) as an unsigned char 
              converted to an int, from the input stream pointed to by 
              stream, and advances the associated file position indicator 
              (if defined).
              
%fgets
Defined in:   stdio.h
Prototype:    extern char *fgets(char * /*s*/, int /*n*/, FILE * /*stream*/)
Summary:      reads at most one less than the number of characters specified 
              by n from the stream pointed to by stream into the array 
              pointed to by s. No additional characters are read after a 
              new-line character (which is retained) or after end-of-file. 
              A null character is written immediately after the last 
              character read into the array.
              
%fputc
Defined in:   stdio.h
Prototype:    extern int fputc(int /*c*/, FILE * /*stream*/)
Summary:      writes the character specified by c (converted to an unsigned 
              char) to the output stream pointed to by stream, at the 
              position indicated by the asociated file position indicator 
              (if defined), and advances the indicator appropriately. If the 
              file position indicator is not defined, the character is 
              appended to the output stream.
              
%fputs
Defined in:   stdio.h
Prototype:    extern int fputs(const char * /*s*/, FILE * /*stream*/)
Summary:      writes the string pointed to by s to the stream pointed to by 
              stream.  The terminating null character is not written.
              
%getc
Defined in:   stdio.h
Prototype:    extern int (getc)(FILE * /*stream*/)
Summary:      is equivalent to fgetc except that it may be (and is under
              RISC OS) implemented as a macro. stream may be 
              evaluated more than once, so the argument should never be an 
              expression with side effects.
              
%getchar
Defined in:   stdio.h
Prototype:    extern int (getchar)(void)
Summary:      is equivalent to getc with the argument stdin.
              
%gets
Defined in:   stdio.h
Prototype:    extern char *gets(char * /*s*/)
Summary:      reads characters from the input stream pointed to by stdin 
              into the array pointed to by s, until end-of-file is 
              encountered or a new-line character is read. Any new-line 
              character is discarded, and a null character is written 
              immediately after the last character read into the array.
              
%putc
Defined in:   stdio.h
Prototype:    extern int (putc)(int /*c*/, FILE * /*stream*/)
Summary:      is equivalent to fputc except that it may be (and is under
              RISC OS) implemented as a macro. stream may be 
              evaluated more than once, so the argument should never be an 
              expression with side effects.
              
%putchar
Defined in:   stdio.h
Prototype:    extern int (putchar)(int /*c*/)
Summary:      is equivalent to putc with the second argument stdout.
              
%puts
Defined in:   stdio.h
Prototype:    extern int puts(const char * /*s*/)
Summary:      writes the string pointed to by s to the stream pointed to by 
              stdout, and appends a new-line character to the output. The 
              terminating null character is not written.
              
%ungetc
Defined in:   stdio.h
Prototype:    extern int ungetc(int /*c*/, FILE * /*stream*/)
Summary:      pushes the character specified by c (converted to an unsigned 
              char) back onto the input stream pointed to by stream. The 
              character will be returned by the next read on that stream. An 
              intervening call to the fflush function or to a file 
              positioning function (fseek, fsetpos, rewind) discards any 
              pushed-back characters. The external storage corresponding to 
              the stream is unchanged.
              One character pushback is guaranteed. If the unget function is 
              called too many times on the same stream without an 
              intervening read or file positioning operation on that stream, 
              the operation may fail.  If the value of c equals that of the 
              macro EOF, the operation fails and the input stream is 
              unchanged.  A successful call to the ungetc function clears 
              the end-of-file indicator. The value of the file position 
              indicator after reading or discarding all pushed-back 
              characters shall be the same as it was before the characters 
              were pushed back. For a text stream, the value of the file
              position indicator after a successful call to the ungetc 
              function is unspecified until all pushed-back characters are 
              read or discarded. For a binary stream, the file position 
              indicator is decremented by each successful call to the ungetc 
              function; if its value was zero before a call, it is 
              indeterminate after the call.
              
%fread
Defined in:   stdio.h
Prototype:    extern size_t fread(void * /*ptr*/,
                    size_t /*size*/, size_t /*nmemb*/, FILE * /*stream*/)
Summary:      reads into the array pointed to by ptr, up to nmemb members 
              whose size is specified by size, from the stream pointed to by 
              stream. The file position indicator (if defined) is advanced 
              by the number of characters successfully read. If an error 
              occurs, the resulting value of the file position indicator is 
              indeterminate. If a partial member is read, its value is 
              indeterminate. The ferror or feof function shall be used to
              distinguish between a read error and end-of-file.
              
%fwrite
Defined in:   stdio.h
Prototype:    extern size_t fwrite(const void * /*ptr*/,
                    size_t /*size*/, size_t /*nmemb*/, FILE * /*stream*/)
Summary:      writes, from the array pointed to by ptr up to nmemb members 
              whose size is specified by size, to the stream pointed to by 
              stream. The file position indicator (if defined) is advanced 
              by the number of characters successfully written. If an error 
              occurs, the resulting value of the file position indicator is 
              indeterminate.
              
%fgetpos
Defined in:   stdio.h
Prototype:    extern int fgetpos(FILE * /*stream*/, fpos_t * /*pos*/)
Summary:      stores the current value of the file position indicator for 
              the stream pointed to by stream in the object pointed to by 
              pos. The value stored contains unspecified information usable 
              by the fsetpos function for repositioning the stream to its 
              position at the time  of the call to the fgetpos function.
              
%fseek
Defined in:   stdio.h
Prototype:    extern int fseek(FILE * /*stream*/, long int /*offset*/, 
                               int /*whence*/)
Summary:      sets the file position indicator for the stream pointed to by 
              stream.  For a binary stream, the new position is at the 
              signed number of characters specified by offset away from the 
              point specified by whence.  The specified point is the 
              beginning of the file for SEEK_SET, the current position in 
              the file for SEEK_CUR, or end-of-file for SEEK_END.
              A binary stream need not meaningfully support fseek calls with 
              a whence value of SEEK_END.
              For a text stream, either offset shall be zero, or offset 
              shall be a value returned by an earlier call to the ftell 
              function on the same stream and whence shall be SEEK_SET.
              The fseek function clears the end-of-file indicator and undoes 
              any effects of the ungetc function on the same stream. After 
              an fseek call, the next operation on an update stream may be 
              either input or output.
              
%fsetpos
Defined in:   stdio.h
Prototype:    extern int fsetpos(FILE * /*stream*/, const fpos_t * /*pos*/)
Summary:      sets the file position indicator for the stream pointed to by 
              stream according to the value of the object pointed to by pos, 
              which shall be a value returned by an earlier call to the 
              fgetpos function on the same stream.
              The fsetpos function clears the end-of-file indicator and 
              undoes any effects of the ungetc function on the same stream. 
              After an fsetpos call, the next operation on an update stream 
              may be either input or output.
              
%ftell
Defined in:   stdio.h
Prototype:    extern long int ftell(FILE * /*stream*/)
Summary:      obtains the current value of the file position indicator for 
              the stream pointed to by stream. For a binary stream, the 
              value is the number of characters from the beginning of the 
              file. For a text stream, the file position indicator contains 
              unspecified information, usable by the fseek function for 
              returning the file position indicator to its position at the
              time of the ftell call; the difference between two such return 
              values is not necessarily a meaningful measure of the number 
              of characters written or read.

%rewind
Defined in:   stdio.h
Prototype:    extern void rewind(FILE * /*stream*/)
Summary:      sets the file position indicator for the stream pointed to by
              stream to the beginning of the file.

%fname
Defined in:   stdio.h
Prototype:    extern void rewind(FILE * /*stream*/)
Summary:      sets the file position indicator for the stream pointed to by 
              stream to the beginning of the file. It is equivalent to
              (void)fseek(stream, 0L, SEEK_SET) except that the error 
              indicator for the stream is also cleared.
              
%clearerr
Defined in:   stdio.h
Prototype:    extern void clearerr(FILE * /*stream*/)
Summary:      clears the end-of-file and error indicators for the stream 
              pointed to by stream. These indicators are cleared only when 
              the file is opened or by an explicit call to the clearerr 
              function or to the rewind function.
              
%feof
Defined in:   stdio.h
Prototype:    extern int (feof)(FILE * /*stream*/)
Summary:      tests the end-of-file indicator for the stream pointed to by 
              stream.
              
%ferror
Defined in:   stdio.h
Prototype:    extern int (ferror)(FILE * /*stream*/)
Summary:      tests the error indicator for the stream pointed to by stream.
              
%perror
Defined in:   stdio.h
Prototype:    extern void perror(const char * /*s*/)
Summary:      maps the error number  in the integer expression errno to an 
              error message. It writes a sequence of characters to the 
              standard error stream thus: first (if s is not a null pointer 
              and the character pointed to by s is not the null character), 
              the string pointed to by s followed by a colon and a space; 
              then an appropriate error message string followed by a 
              new-line character. The contents of the error message strings 
              are the same as those returned by the strerror function with 
              argument errno, which are implementation-defined.

%div_t
Defined in:   stdlib.h
Definition:   typedef struct div_t { int quot, rem; } div_t
Summary:      type of the value returned by the div function

%ldiv_t
Defined in:   stdlib.h
Definition:   typedef struct ldiv_t { long int quot, rem; } ldiv_t
Summary:      type of the value returned by the ldiv function

%lldiv_t
Defined in:   stdlib.h
Definition:   typedef struct lldiv_t { long long int quot, rem; } lldiv_t
Summary:      type of the value returned by the lldiv function

%EXIT_FAILURE
Defined in:   stdlib.h
Definition:   #define EXIT_FAILURE 1
Summary:      an integral expression which may be used as an argument to the 
              exit function to return unsuccessful termination status to the 
              host environment

%EXIT_SUCCESS
Defined in:   stdlib.h
Definition:   #define EXIT_SUCCESS 0
Summary:      an integral expression which may be used as an argument to the 
              exit function to return successful termination status to the 
              host environment.

%RAND_MAX
Defined in:   stdlib.h
Summary:      an integral constant expression, the value of which is the 
              maximum value returned by the rand function.

%_ANSI_RAND_MAX
Defined in:   stdlib.h
Summary:      an integral constant expression, the value of which is the 
              maximum value returned by the _ANSI_rand function.

%MB_CUR_MAX
Defined in:   stdlib.h
Summary:      a positive integer expression whose value is the maximum 
              number of bytes in a multibyte character for the extended 
              character set specified by the current locale (category 
              LC_CTYPE), and whose value is never greater than MB_LEN_MAX.

%atof
Defined in:   stdlib.h
Prototype:    extern double atof(const char * /*nptr*/)
Summary:      converts the initial part of the string pointed to by nptr to 
              double representation.

%atoi
Defined in:   stdlib.h
Prototype:    extern int atoi(const char * /*nptr*/)
Summary:      converts the initial part of the string pointed to by nptr to 
              int representation.

%atol
Defined in:   stdlib.h
Prototype:    extern long int atol(const char * /*nptr*/)
Summary:      converts the initial part of the string pointed to by nptr to 
              long int representation.

%atoll
Defined in:   stdlib.h
Prototype:    extern long long int atoll(const char * /*nptr*/)
Summary:      converts the initial part of the string pointed to by nptr to 
              long long int representation.

%strtod
Defined in:   stdlib.h
Prototype:    extern double strtod(const char * /*nptr*/, char ** /*endptr*/)
Summary:      converts the initial part of the string pointed to by nptr to 
              double representation. First it decomposes the input string 
              into three parts: an initial, possibly empty, sequence of 
              white-space characters (as specified by the isspace function), 
              a subject sequence resembling a floating point constant; and a 
              final string of one or more unrecognised characters, including 
              the terminating null character of the input string.
              Then it attempts to convert the subject sequence to a floating 
              point number, and returns the result. A pointer to the final 
              string is stored in the object pointed to by endptr, provided 
              that endptr is not a null pointer.

%strtof
Defined in:   stdlib.h
Prototype:    extern float strtof(const char * /*nptr*/, char ** /*endptr*/)
Summary:      converts the initial part of the string pointed to by nptr to 
              float representation. First it decomposes the input string
              into three parts: an initial, possibly empty, sequence of 
              white-space characters (as specified by the isspace function), 
              a subject sequence resembling a floating point constant; and a 
              final string of one or more unrecognised characters, including 
              the terminating null character of the input string.
              Then it attempts to convert the subject sequence to a floating 
              point number, and returns the result. A pointer to the final 
              string is stored in the object pointed to by endptr, provided 
              that endptr is not a null pointer.

%strtold
Defined in:   stdlib.h
Prototype:    extern long double strtod(const char * /*nptr*/,
                                        char ** /*endptr*/)
Summary:      converts the initial part of the string pointed to by nptr to 
              long double representation. First it decomposes the input string
              into three parts: an initial, possibly empty, sequence of 
              white-space characters (as specified by the isspace function), 
              a subject sequence resembling a floating point constant; and a 
              final string of one or more unrecognised characters, including 
              the terminating null character of the input string.
              Then it attempts to convert the subject sequence to a floating 
              point number, and returns the result. A pointer to the final 
              string is stored in the object pointed to by endptr, provided 
              that endptr is not a null pointer.

%strtol
Defined in:   stdlib.h
Prototype:    extern long int strtol(const char * /*nptr*/, 
                                     char **/*endptr*/, int /*base*/)
Summary:      converts the initial part of the string pointed to by nptr to 
              long int representation. First it decomposes the input string 
              into three parts: an initial, possibly empty, sequence of 
              white-space characters (as specified by the isspace function), 
              a subject sequence resembling an integer represented in some 
              radix determined by the value of base, and a final string of 
              one or more unrecognised characters, including the terminating 
              null character of the input string. Then it attempts to 
              convert the subject sequence to an integer, and returns the 
              result.
              If the value of base is 0, the expected form of the subject 
              sequence is that of an integer constant (described in ANSI 
              Draft, section 3.1.3.2), optionally preceeded by a '+' or '-' 
              sign, but not including an integer suffix. If the value of 
              base is between 2 and 36, the expected form of the subject 
              sequence is a sequence of letters and digits representing an
              integer with the radix specified by base, optionally preceeded 
              by a plus or minus sign, but not including an integer suffix. 
              The letters from a (or A) through z (or Z) are ascribed the 
              values 10 to 35; only letters whose ascribed values are less 
              than that of the base are permitted. If the value of base is 
              16, the characters 0x or 0X may optionally precede the 
              sequence of letters and digits following the sign if present.
              A pointer to the final string is stored in the object pointed 
              to by endptr, provided that endptr is not a null pointer.

%strtoll
Defined in:   stdlib.h
Prototype:    extern long long int strtoll(const char * /*nptr*/, 
                                           char **/*endptr*/, int /*base*/)
Summary:      converts the initial part of the string pointed to by nptr to 
              long long int representation. First it decomposes the
              input string into three parts: an initial, possibly empty,
              sequence of white-space characters (as specified by the
              isspace function), a subject sequence resembling an integer
              represented in some radix determined by the value of base, and
              a final string of one or more unrecognised characters,
              including the terminating null character of the input string.
              Then it attempts to convert the subject sequence to an integer,
              and returns the result.
              If the value of base is 0, the expected form of the subject 
              sequence is that of an integer constant (described in ANSI 
              Draft, section 3.1.3.2), optionally preceeded by a '+' or '-' 
              sign, but not including an integer suffix. If the value of 
              base is between 2 and 36, the expected form of the subject 
              sequence is a sequence of letters and digits representing an
              integer with the radix specified by base, optionally preceeded 
              by a plus or minus sign, but not including an integer suffix. 
              The letters from a (or A) through z (or Z) are ascribed the 
              values 10 to 35; only letters whose ascribed values are less 
              than that of the base are permitted. If the value of base is 
              16, the characters 0x or 0X may optionally precede the 
              sequence of letters and digits following the sign if present.
              A pointer to the final string is stored in the object pointed 
              to by endptr, provided that endptr is not a null pointer.

%strtoul
Defined in:   stdlib.h
Prototype:    extern unsigned long int strtoul(const char * /*nptr*/,
                                       char ** /*endptr*/, int /*base*/)
Summary:      converts the initial part of the string pointed to by nptr to 
              unsigned long int representation. First it decomposes the 
              input string into three parts: an initial, possibly empty, 
              sequence of white-space characters (as determined by the 
              isspace function), a subject sequence resembling an unsigned 
              integer represented in some radix determined by the value of
              base, and a final string of one or more unrecognised 
              characters, including the terminating null character of the 
              input string. Then it attempts to convert the subject sequence 
              to an unsigned integer, and returns the result. If the value 
              of base is zero, the expected form of the subject sequence is 
              that of an integer constant (described in ANSI Draft, section 
              3.1.3.2), optionally preceeded by a '+' or '-' sign, but not 
              including an integer suffix. If the value of base is between 2 
              and 36, the expected form of the subject sequence is a 
              sequence of letters and digits representing an integer with 
              the radix specified by base, optionally preceeded by a '+' or 
              '-' sign, but not including an integer suffix. The letters 
              from a (or A) through z (or Z) stand for the values 10 to 35; 
              only letters whose ascribed values are less than that of the
              base are permitted. If the value of base is 16, the characters 
              0x or 0X may optionally precede the sequence of letters and 
              digits following the sign, if present. A pointer to the final 
              string is stored in the object pointed to by endptr, provided 
              that endptr is not a null pointer.

%strtoull
Defined in:   stdlib.h
Prototype:    extern unsigned long long int strtoull(const char * /*nptr*/,
                                       char ** /*endptr*/, int /*base*/)
Summary:      converts the initial part of the string pointed to by nptr to 
              unsigned long long int representation. First it decomposes the
              input string into three parts: an initial, possibly empty, 
              sequence of white-space characters (as determined by the 
              isspace function), a subject sequence resembling an unsigned 
              integer represented in some radix determined by the value of
              base, and a final string of one or more unrecognised 
              characters, including the terminating null character of the 
              input string. Then it attempts to convert the subject sequence 
              to an unsigned integer, and returns the result. If the value 
              of base is zero, the expected form of the subject sequence is 
              that of an integer constant (described in ANSI Draft, section 
              3.1.3.2), optionally preceeded by a '+' or '-' sign, but not 
              including an integer suffix. If the value of base is between 2 
              and 36, the expected form of the subject sequence is a 
              sequence of letters and digits representing an integer with 
              the radix specified by base, optionally preceeded by a '+' or 
              '-' sign, but not including an integer suffix. The letters 
              from a (or A) through z (or Z) stand for the values 10 to 35; 
              only letters whose ascribed values are less than that of the
              base are permitted. If the value of base is 16, the characters 
              0x or 0X may optionally precede the sequence of letters and 
              digits following the sign, if present. A pointer to the final 
              string is stored in the object pointed to by endptr, provided 
              that endptr is not a null pointer.

%rand
Defined in:   stdlib.h
Prototype:    extern int rand(void)
Summary:      Computes a sequence of pseudo-random integers in the range 0 
              to RAND_MAX.  Uses an additive generator (Mitchell & Moore) of 
              the form:
                Xn = (X[n-24] + X[n-55]) MOD 2^31
              This is described in section 3.2.2 of Knuth, vol 2. It's 
              period is in excess of 2^55 and its randomness properties, 
              though unproven, are conjectured to be good. Empirical testing 
              since 1958 has shown no flaws.

%srand
Defined in:   stdlib.h
Prototype:    extern void srand(unsigned int /*seed*/)
Summary:      uses its argument as a seed for a new sequence of 
              pseudo-random numbers to be returned by subsequent calls to 
              rand. If srand is then called with the same seed value, the 
              sequence of pseudo-random numbers is repeated.
              If rand is called before any calls to srand have been made, 
              the same sequence is generated as when srand is first called 
              with a seed value of 1.
    
%_ANSI_rand
Defined in:   stdlib.h
Prototype:    extern int _ANSI_rand(void)
Summary:      The ANSI-defined 16-bit random number generator which computes
              a sequence of pseudo-random integers in the range 0 to 
              _ANSI_RAND_MAX.
              Its properties are poor, though it IS very portable.
              *** NOT AVAILABLE IN THE SHARED C LIBRARY ***

%_ANSI_srand
Defined in:   stdlib.h
Prototype:    extern void _ANSI_srand(unsigned int /*seed*/)
Summary:      Uses its argument as a seed for a new sequence of 
              pseudo-random numbers to be returned by subsequent calls to 
              _ANSI_rand. If _ANSI_srand is then called with the same seed 
              value, the sequence of pseudo-random numbers is repeated. If 
              _ANSI_rand is called before any calls to _ANSI_srand have
              been made, the same sequence is generated as when _ANSI_srand 
              is first called with a seed value of 1.
              *** NOT AVAILABLE IN THE SHARED C LIBRARY ***
    
%calloc
Defined in:   stdlib.h
Prototype:    extern void *calloc(size_t /*nmemb*/, size_t /*size*/)
Summary:      allocates space for an array of nmemb objects, each of whose 
              size is 'size'. The space is initialised to all bits zero.

%free
Defined in:   stdlib.h
Prototype:    extern void free(void * /*ptr*/)
Summary:      causes the space pointed to by ptr to be deallocated (i.e., 
              made available for further allocation). If ptr is a null 
              pointer, no action occurs. Otherwise, if ptr does not match a 
              pointer earlier returned by calloc, malloc or realloc or if 
              the space has been deallocated by a call to free or realloc, 
              the behaviour is undefined.
    
%malloc
Defined in:   stdlib.h
Prototype:    extern void *malloc(size_t /*size*/)
Summary:      allocates space for an object whose size is specified by 
              'size' and whose value is indeterminate.

%realloc
Defined in:   stdlib.h
Prototype:    extern void *realloc(void * /*ptr*/, size_t /*size*/)
Summary:      changes the size of the object pointed to by ptr to the size 
              specified by size. The contents of the object shall be 
              unchanged up to the lesser of the new and old sizes. If the 
              new size is larger, the value of the newly allocated portion 
              of the object is indeterminate. If ptr is a null pointer, the 
              realloc function behaves like a call to malloc for the 
              specified size. Otherwise, if ptr does not match a pointer 
              earlier returned by calloc, malloc or realloc, or if the space 
              has been deallocated by a call to free or realloc, the 
              behaviour is undefined.
              If the space cannot be allocated, the object pointed to by ptr 
              is unchanged. If size is zero and ptr is not a null pointer, 
              the object it points to is freed.

%abort
Defined in:   stdlib.h
Prototype:    extern void abort(void)
Summary:      causes abnormal program termination to occur, unless the 
              signal SIGABRT is being caught and the signal handler does not 
              return. Whether open output streams are flushed or open 
              streams are closed or temporary files removed is 
              implementation-defined (under RISC OS all these occur).
              An implementation-defined form of the status 'unsuccessful 
              termination' (1 under RISC OS) is returned to the host 
              environment by means of a call to raise(SIGABRT).
    
%atexit
Defined in:   stdlib.h
Prototype:    extern int atexit(void (* /*func*/)(void))
Summary:      registers the function pointed to by func, to be called 
              without its arguments at normal program termination. It is 
              possible to register at least 32 functions.

%exit
Defined in:   stdlib.h
Prototype:    extern void exit(int /*status*/)
Summary:      causes normal program termination to occur. If more than one 
              call to the exit function is executed by a program, the 
              behaviour is undefined.
              First, all functions registered by the atexit function are 
              called, in the reverse order of their registration.
              Next, all open output streams are flushed, all open streams 
              are closed, and all files created by the tmpfile function are 
              removed.
              Finally, control is returned to the host environment. If the 
              value of status is zero or EXIT_SUCCESS, an 
              implementation-defined form of the status 'successful 
              termination' (0 under RISC OS) is returned. If the value 
              of status is EXIT_FAILURE, an implementation-defined form of
              the status 'unsuccessful termination' (1 under RISC OS) 
              is returned. Otherwise the status returned is 
              implementation-defined (the value of status is returned under 
              RISC OS).
    
%getenv
Defined in:   stdlib.h
Prototype:    extern char *getenv(const char * /*name*/)
Summary:      searches the environment list, provided by the host 
              environment, for a string that matches the string pointed to 
              by name. The set of environment names and the method for 
              altering the environment list are implementation-defined.

%system
Defined in:   stdlib.h
Prototype:    extern int system(const char * /*string*/)
Summary:      passes the string pointed to by string to the host environment 
              to be executed by a command processor in an 
              implementation-defined manner.  A null pointer may be used for 
              string, to inquire whether a command processor exists.
             
              Under RISC OS care must be taken when executing a
              command, that the command does not overwrite the calling 
              program. The string 'chain:' or 'call:' may immediately 
              precede the actual command. The effect of 'call:' is the same 
              as if 'call:' were not present, which is to attempt to return
              to the calling program. The effect of 'chain:' is to make no 
              attempt to return to the calling program, but an attempt is 
              made to call exit.
             
%bsearch
Defined in:   stdlib.h
Prototype:    extern void *bsearch(const void *key, const void * /*base*/,
                                   size_t /*nmemb*/, size_t /*size*/,
                                   int (* /*compar*/)(const void *, 
                                   const void *))
Summary:      searches an array of nmemb objects, the initial member of 
              which is pointed to by base, for a member that matches the 
              object pointed to by key. The size of each member of the array 
              is specified by size.  The contents of the array shall be in 
              ascending sorted order according to a comparison function 
              pointed to by compar, which is called with two arguments that 
              point to the key object and to an array member, in that order. 
              The function shall return an integer less than, equal to, or
              greater than zero if the key object is considered, 
              respectively, to be less than, to match, or to be greater than 
              the array member.

%qsort
Defined in:   stdlib.h
Prototype:    extern void qsort(void * /*base*/, size_t /*nmemb*/, 
                                size_t /*size*/,
                              int (* /*compar*/)(const void *, const void *))
Summary:      sorts an array of nmemb objects, the initial member of which 
              is pointed to by base. The size of each object is specified by 
              size.
              The contents of the array shall be in ascending order 
              according to a comparison function pointed to by compar, which 
              is called with two arguments that point to the objects being 
              compared. The function shall return an integer less than, 
              equal to, or greater than zero if the first argument is 
              considered to be respectively less than, equal to, or greater
              than the second. If two members compare as equal, their order 
              in the sorted array is unspecified.
    
%abs
Defined in:   stdlib.h
Prototype:    extern int abs(int /*j*/)
Summary:      computes the absolute value of an integer j. If the result 
              cannot be represented, the behaviour is undefined.

%labs
Defined in:   stdlib.h
Prototype:    extern long int labs(long int /*j*/)
Summary:      computes the absolute value of a long integer j. If the result 
              cannot be represented, the behaviour is undefined.

%llabs
Defined in:   stdlib.h
Prototype:    extern long long int llabs(long long int /*j*/)
Summary:      computes the absolute value of a long long integer j. If the
              result cannot be represented, the behaviour is undefined.

%div
Defined in:   stdlib.h
Prototype:    extern div_t div(int /*numer*/, int /*denom*/)
Summary:      computes the quotient and remainder of the division of the 
              numerator numer by the denominator denom. If the division is 
              inexact, the resulting quotient is the integer of lesser 
              magnitude that is the nearest to the algebraic quotient. If 
              the result cannot be represented, the behaviour is undefined; 
              otherwise, quot * demon + rem shall equal numer.

%ldiv
Defined in:   stdlib.h
Prototype:    extern ldiv_t ldiv(long int /*numer*/, long int /*denom*/)
Summary:      computes the quotient and remainder of the division of the 
              numerator numer by the denominator denom. If the division is 
              inexact, the sign of the resulting quotient is that of the 
              algebraic quotient, and the magnitude of the resulting 
              quotient is the largest integer less than the magnitude of the 
              algebraic quotient. If the result cannot be represented, the 
              behaviour is undefined; otherwise, quot * demon + rem shall 
              equal numer.

%lldiv
Defined in:   stdlib.h
Prototype:    extern lldiv_t lldiv(long long int /*numer*/,
                                   long long int /*denom*/)
Summary:      computes the quotient and remainder of the division of the 
              numerator numer by the denominator denom. If the division is 
              inexact, the sign of the resulting quotient is that of the 
              algebraic quotient, and the magnitude of the resulting 
              quotient is the largest integer less than the magnitude of the 
              algebraic quotient. If the result cannot be represented, the 
              behaviour is undefined; otherwise, quot * demon + rem shall 
              equal numer.

%mblen
Defined in:   stdlib.h
Prototype:    extern int mblen(const char * /*s*/, size_t /*n*/)
Summary:      If s is not a null pointer, the mblen function determines the 
              number of bytes compromising the multibyte character pointed 
              to by s. Except that the shift state of the mbtowc function is 
              not affected, it is equivalent to   mbtowc((wchar_t *)0, s, n);

%mbtowc
Defined in:   stdlib.h
Prototype:    extern int mbtowc(wchar_t * /*pwc*/, 
                                const char * /*s*/, size_t /*n*/)
Summary:      If s is not a null pointer, the mbtowc function determines the 
              number of bytes that compromise the multibyte character 
              pointed to by s. It then determines the code for value of type 
              wchar_t that corresponds to that multibyte character. (The 
              value of the code corresponding to the null character is zero).
              If the multibyte character is valid and pwc is not a null 
              pointer, the mbtowc function stores the code in the object 
              pointed to by pwc. At most n bytes of the array pointed to by 
              s will be examined.

%wctomb
Defined in:   stdlib.h
Prototype:    extern int wctomb(char * /*s*/, wchar_t /*wchar*/)
Summary:      determines the number of bytes need to represent the multibyte 
              character corresponding to the code whose value is wchar 
              (including any change in shift state). It stores the multibyte 
              character representation in the array object pointed to by s 
              (if s is not a null pointer). At most MB_CUR_MAX characters 
              are stored. If the value of wchar is zero, the wctomb function 
              is left in the initial shift state).

%mbstowcs
Defined in:   stdlib.h
Prototype:    extern size_t mbstowcs(wchar_t * /*pwcs*/, 
                                     const char * /*s*/, size_t /*n*/)
Summary:      converts a sequence of multibyte character that begins in the 
              initial shift state from the array pointed to by s into a 
              sequence of corresponding codes and stores not more than n 
              codes into the array pointed to by pwcs. No multibyte 
              character that follow a null character (which is converted 
              into a code with value zero) will be examined or converted. 
              Each multibyte character is converted as if by a call to 
              mbtowc function, except that the shift state of the mbtowc 
              function is not affected. No more than n elements will be 
              modified in the array pointed to by pwcs. If copying takes 
              place between objects that overlap, the behaviour is 
              undefined.

%wcstombs
Defined in:   stdlib.h
Prototype:    extern size_t wcstombs(char * /*s*/, 
                                     const wchar_t * /*pwcs*/, size_t /*n*/)
Summary:      converts a sequence of codes that correspond to multibyte 
              characters from the array pointed to by pwcs into a sequence 
              of multibyte characters that begins in the initial shift state 
              and stores these multibyte characters into the array pointed 
              to by s, stopping if a multibyte character would exceed the 
              limit of n total bytes or if a null character is stored. Each 
              code is converted as if by a call to the wctomb function, 
              except that the shift state of the wctomb function is not 
              affected. No more than n elements will be modified in the 
              array pointed to by s. If copying takes place between objects 
              that overlap, the behaviour is undefined. 

%memcpy
Defined in:   string.h
Prototype:    extern void *memcpy(void * /*s1*/, const void * /*s2*/, 
                                  size_t /*n*/)
Summary:      copies n characters from the object pointed to by s2 into the 
              object pointed to by s1. If copying takes place between 
              objects that overlap, the behaviour is undefined.

%memmove
Defined in:   string.h
Prototype:    extern void *memmove(void * /*s1*/, const void * /*s2*/, 
                                   size_t /*n*/)
Summary:      copies n characters from the object pointed to by s2 into the 
              object pointed to by s1. Copying takes place as if the n 
              characters from the object pointed to by s2 are first copied 
              into a temporary array of n characters that does not overlap 
              the objects pointed to by s1 and s2, and then the n characters 
              from the temporary array are copied into the object pointed to 
              by s1.

%strcpy
Defined in:   string.h
Prototype:    extern char *strcpy(char * /*s1*/, const char * /*s2*/)
Summary:      copies the string pointed to by s2 (including the terminating 
              nul character) into the array pointed to by s1. If copying 
              takes place between objects that overlap, the behaviour is 
              undefined.

%strncpy
Defined in:   string.h
Prototype:    extern char *strncpy(char * /*s1*/, const char * /*s2*/, 
                                   size_t /*n*/)
Summary:      copies not more than n characters (characters that follow a 
              null character are not copied) from the array pointed to by 
              s2 into the array pointed to by s1. If copying takes place 
              between objects that overlap, the behaviour is undefined.

%strcat
Defined in:   string.h
Prototype:    extern char *strcat(char * /*s1*/, const char * /*s2*/)
Summary:      appends a copy of the string pointed to by s2 (including the 
              terminating null character) to the end of the string pointed 
              to by s1. The initial character of s2 overwrites the null 
              character at the end of s1.

%strncat
Defined in:   string.h
Prototype:    extern char *strncat(char * /*s1*/, const char * /*s2*/, 
                                   size_t /*n*/)
Summary:      appends not more than n characters (a null character and 
              characters that follow it are not appended) from the array 
              pointed to by s2 to the end of the string pointed to by s1. 
              The initial character of s2 overwrites the null character at 
              the end of s1. A terminating null character is always appended 
              to the result.

%memcmp
Defined in:   string.h
Prototype:    extern int memcmp(const void * /*s1*/, 
                                const void * /*s2*/, size_t /*n*/)
Summary:      compares the first n characters of the object pointed to by s1 
              to the first n characters of the object pointed to by s2.

%strcmp
Defined in:   string.h
Prototype:    extern int strcmp(const char * /*s1*/, const char * /*s2*/)
Summary:      compares the string pointed to by s1 to the string pointed to 
              by s2.

%strncmp
Defined in:   string.h
Prototype:    extern int strncmp(const char * /*s1*/, const char * /*s2*/, 
                                 size_t /*n*/)
Summary:      compares not more than n characters (characters that follow a 
              null character are not compared) from the array pointed to by 
              s1 to the array pointed to by s2.

%strcoll
Defined in:   string.h
Prototype:    extern int strcoll(const char * /*s1*/, const char * /*s2*/)
Summary:      compares the string pointed to by s1 to the string pointed to 
              by s2, both interpreted as appropriate to the LC_COLLATE 
              category of the current locale.

%strxfrm
Defined in:   string.h
Prototype:    extern size_t strxfrm(char * /*s1*/, const char * /*s2*/, 
                                    size_t /*n*/)
Summary:      transforms the string pointed to by s2 and places the 
              resulting string into the array pointed to by s1. The 
              transformation function is such that if the strcmp function is 
              applied to two transformed strings, it returns a value greater 
              than, equal to or less than zero, corresponding to the result 
              of the strcoll function applied to the same two original 
              strings.  No more than n characters are placed into the 
              resulting array pointed to by s1, including the terminating 
              null character. If n is zero, s1 is permitted to be a null 
              pointer. If copying takes place between objects that overlap, 
              the behaviour is undefined.

%memchr
Defined in:   string.h
Prototype:    extern void *memchr(const void * /*s*/, int /*c*/, 
                                  size_t /*n*/)
Summary:      locates the first occurence of c (converted to an unsigned 
              char) in the initial n characters (each interpreted as 
              unsigned char) of the object pointed to by s.

%strchr
Defined in:   string.h
Prototype:    extern char *strchr(const char * /*s*/, int /*c*/)
Summary:      locates the first occurence of c (converted to an char) in 
              the string pointed to by s (including the terminating null 
              character).

%strcspn
Defined in:   string.h
Prototype:    extern size_t strcspn(const char * /*s1*/, const char * /*s2*/)
Summary:      computes the length of the initial segment of the string 
              pointed to by s1 which consists entirely of characters not 
              from the string pointed to by s2. The terminating null 
              character is not considered part of s2.

%strpbrk
Defined in:   string.h
Prototype:    extern char *strpbrk(const char * /*s1*/, const char * /*s2*/)
Summary:      locates the first occurence in the string pointed to by s1 of 
              any character from the string pointed to by s2.

%strrchr
Defined in:   string.h
Prototype:    extern char *strrchr(const char * /*s*/, int /*c*/)
Summary:      locates the last occurence of c (converted to a char) in the 
              string pointed to by s. The terminating null character is 
              considered part of the string.

%strspn
Defined in:   string.h
Prototype:    extern size_t strspn(const char * /*s1*/, const char * /*s2*/)
Summary:      computes the length of the initial segment of the string 
              pointed to by s1 which consists entirely of characters from 
              the string pointed to by S2

%strstr
Defined in:   string.h
Prototype:    extern char *strstr(const char * /*s1*/, const char * /*s2*/)
Summary:      locates the first occurence in the string pointed to by s1 of 
              the sequence of characters (excluding the terminating null 
              character) in the string pointed to by s2.

%strtok
Defined in:   string.h
Prototype:    extern char *strtok(char * /*s1*/, const char * /*s2*/)
Summary:      A sequence of calls to the strtok function breaks the string 
              pointed to by s1 into a sequence of tokens, each of which is 
              delimited by a character from the string pointed to by s2. 
              The first call in the sequence has s1 as its first argument, 
              and is followed by calls with a null pointer as their first 
              argument. The separator string pointed to by s2 may be 
              different from call to call.
              The first call in the sequence searches for the first 
              character that is not contained in the current separator 
              string s2. If no such character is found, then there are no 
              tokens in s1 and the strtok function returns a null pointer. 
              If such a character is found, it is the start of the first 
              token.  The strtok function then searches from there for a 
              character that is contained in the current separator string. 
              If no such character is found, the current token extends to 
              the end of the string pointed to by s1, and subsequent 
              searches for a token will fail. If such a character is found,
              it is overwritten by a null character, which terminates the 
              current token. The strtok function saves a pointer to the 
              following character, from which the next search for a token 
              will start.
              Each subsequent call, with a null pointer as the value for the 
              first argument, starts searching from the saved pointer and 
              behaves as described above.

%memset
Defined in:   string.h
Prototype:    extern void *memset(void * /*s*/, int /*c*/, size_t /*n*/)
Summary:      copies the value of c (converted to an unsigned char) into 
              each of the first n charactes of the object pointed to by s.

%strerror
Defined in:   string.h
Prototype:    extern char *strerror(int /*errnum*/)
Summary:      maps the error number in errnum to an error message string.

%strlen
Defined in:   string.h
Prototype:    extern size_t strlen(const char * /*s*/)
Summary:      computes the length of the string pointed to by s.

# tgmath.h    this sets up various macros that map to the functions
#             already defined from <complex.h> or <math.h>

%CLOCKS_PER_SEC
Defined in:   time.h
Summary:      real time clock ticks per second, this is the rate at which
              the processor time from clock() increments at.

%clock_t
Defined in:   time.h
Definition:   typedef unsigned int clock_t
Summary:      processor time type

%time_t
Defined in:   time.h
Definition:   typedef unsigned int time_t
Summary:      date/time in UNIX seconds past 01-Jan-1970

%clock
Defined in:   time.h
Prototype:    extern clock_t clock(void)
Summary:      determines the processor time used.

%difftime
Defined in:   time.h
Prototype:    extern double difftime(time_t /*time1*/, time_t /*time0*/)
Summary:      computes the difference between two calendar 
              times: time1 - time0.

%mktime
Defined in:   time.h
Prototype:    extern time_t mktime(struct tm * /*timeptr*/)
Summary:      converts the broken-down time, expressed as local time, in the 
              structure pointed to by timeptr into a calendar time value 
              with the same encoding as that of the values returned by the 
              time function. The original values of the tm_wday and tm_yday 
              components of the structure are ignored, and the original 
              values of the other components are not restricted to the
              ranges indicated above. On successful completion, the values 
              of the tm_wday and tm_yday structure components are set 
              appropriately, and the other components are set to represent 
              the specified calendar time, but with their values forced to 
              the ranges indicated above; the final value of tm_mday is not 
              set until tm_mon and tm_year are determined.

%time
Defined in:   time.h
Prototype:    extern time_t time(time_t * /*timer*/)
Summary:      determines the current calendar time. The encoding of the 
              value is unspecified.

%asctime
Defined in:   time.h
Prototype:    extern char *asctime(const struct tm * /*timeptr*/)
Summary:      converts the broken-down time in the structure pointed to by 
              timeptr into a string in the form Sun Sep 16 01:03:52 1973\n\0.

%ctime
Defined in:   time.h
Prototype:    extern char *ctime(const time_t * /*timer*/)
Summary:      converts the calendar time pointed to by timer to local time 
              in the form of a string. It is equivalent to 
              asctime(localtime(timer));

%gmtime
Defined in:   time.h
Prototype:    extern struct tm *gmtime(const time_t * /*timer*/)
Summary:      converts the calendar time pointed to by timer into a 
              broken-down time, expressed as Greenwich Mean Time (GMT).

%localtime
Defined in:   time.h
Prototype:    extern struct tm *localtime(const time_t * /*timer*/)
Summary:      converts the calendar time pointed to by timer into a 
              broken-down time, expressed a local time.

%strftime
Defined in:   time.h
Prototype:    extern size_t strftime(char * /*s*/, size_t /*maxsize*/,
                                     const char * /*format*/, 
                                     const struct tm * /*timeptr*/)
Summary:      places characters into the array pointed to by s as controlled 
              by the string pointed to by format. The format string consists 
              of zero or more directives and ordinary characters. A 
              directive consists of a % character followed by a character 
              that determines the directive's behaviour. All ordinary 
              characters (including the terminating null character) are 
              copied unchanged into the array. No more than maxsize 
              characters are placed into the array. Each directive is 
              replaced by appropriate characters  as described in the 
              following list. The appropriate characters are determined by 
              the LC_TIME category of the current locale and by the values 
              contained in the structure pointed to by timeptr.
              %a is replaced by the locale's abbreviated weekday name.
              %A is replaced by the locale's full weekday name.
              %b is replaced by the locale's abbreviated month name.
              %B is replaced by the locale's full month name.
              %c is replaced by the locale's appropriate date and time 
                 representation.
              %d is replaced by the day of the month as a decimal number 
                 (01-31).
              %H is replaced by the hour (24-hour clock) as a decimal number 
                 (00-23).
              %I is replaced by the hour (12-hour clock) as a decimal number 
                 (01-12).
              %j is replaced by the day of the year as a decimal number 
                 (001-366).
              %m is replaced by the month as a decimal number (01-12).
              %M is replaced by the minute as a decimal number (00-59).
              %p is replaced by the locale's equivalent of either AM or PM 
                 designations associated with a 12-hour clock.
              %S is replaced by the second as a decimal number (00-61).
              %U is replaced by the week number of the year (Sunday as the 
                 first day of week 1) as a decimal number (00-53).
              %w is replaced by the weekday as a decimal number 
                 (0(Sunday) - 6).
              %W is replaced by the week number of the year (Monday as the 
                 first day of week 1) as a decimal number (00-53).
              %x is replaced by the locale's appropriate date representation.
              %X is replaced by the locale's appropriate time representation.
              %y is replaced by the year without century as a decimal number 
                 (00-99).
              %Y is replaced by the year with century as a decimal number.
              %Z is replaced by the timezone name or abbreviation, or by no 
                 characters if no time zone is determinable.
              %% is replaced by %.
              If a directive is not one of the above, the behaviour is 
              undefined.
              
# wchar.h     provided with the compiler, but not currently implemented
# wctype.h    provided with the compiler, but not currently implemented
