(line   6)
* Initialization functions <4>:          Simultaneous Float Init & Assign.
                                                              (line   6)
* Initialization functions <5>:          Simultaneous Integer Init & Assign.
                                                              (line   6)
* Initialization functions:              Initializing Floats. (line   6)
* Initializing and clearing:             Efficiency.          (line  21)
* Input functions <1>:                   I/O of Integers.     (line   6)
* Input functions <2>:                   I/O of Rationals.    (line   6)
* Input functions <3>:                   I/O of Floats.       (line   6)
* Input functions:                       Formatted Input Functions.
                                                              (line   6)
* Install prefix:                        Build Options.       (line  32)
* Installing GMP:                        Installing GMP.      (line   6)
* Instruction Set Architecture:          ABI and ISA.         (line   6)
* instrument-functions:                  Profiling.           (line  66)
* Integer:                               Nomenclature and Types.
                                                              (line   6)
* Integer arithmetic functions:          Integer Arithmetic.  (line   6)
* Integer assignment functions <1>:      Simultaneous Integer Init & Assign.
                                                              (line   6)
* Integer assignment functions:          Assigning Integers.  (line   6)
* Integer bit manipulation functions:    Integer Logic and Bit Fiddling.
                                                              (line   6)
* Integer comparison functions:          Integer Comparisons. (line   6)
* Integer conversion functions:          Converting Integers. (line   6)
* Integer division functions:            Integer Division.    (line   6)
* Integer exponentiation functions:      Integer Exponentiation.
                                                              (line   6)
* Integer export:                        Integer Import and Export.
                                                              (line  45)
* Integer functions:                     Integer Functions.   (line   6)
* Integer import:                        Integer Import and Export.
                                                              (line  11)
* Integer initialization functions <1>:  Simultaneous Integer Init & Assign.
                                                              (line   6)
* Integer initialization functions:      Initializing Integers.
                                                              (line   6)
* Integer input and output functions:    I/O of Integers.     (line   6)
* Integer internals:                     Integer Internals.   (line   6)
* Integer logical functions:             Integer Logic and Bit Fiddling.
                                                              (line   6)
* Integer miscellaneous functions:       Miscellaneous Integer Functions.
                                                              (line   6)
* Integer random number functions:       Integer Random Numbers.
                                                              (line   6)
* Integer root functions:                Integer Roots.       (line   6)
* Integer sign tests:                    Integer Comparisons. (line  28)
* Integer special functions:             Integer Special Functions.
                                                              (line   6)
* Interix:                               Notes for Particular Systems.
                                                              (line  51)
* Internals:                             Internals.           (line   6)
* Introduction:                          Introduction to GMP. (line   6)
* Inverse modulo functions:              Number Theoretic Functions.
                                                              (line  60)
* IRIX <1>:                              Known Build Problems.
                                                              (line  38)
* IRIX:                                  ABI and ISA.         (line 132)
* ISA:                                   ABI and ISA.         (line   6)
* istream input:                         C++ Formatted Input. (line   6)
* Jacobi symbol algorithm:               Jacobi Symbol.       (line   6)
* Jacobi symbol functions:               Number Theoretic Functions.
                                                              (line  66)
* Karatsuba multiplication:              Karatsuba Multiplication.
                                                              (line   6)
* Karatsuba square root algorithm:       Square Root Algorithm.
                                                              (line   6)
* Kronecker symbol functions:            Number Theoretic Functions.
                                                              (line  78)
* Language bindings:                     Language Bindings.   (line   6)
* Latest version of GMP:                 Introduction to GMP. (line  38)
* LCM functions:                         Number Theoretic Functions.
                                                              (line  55)
* Least common multiple functions:       Number Theoretic Functions.
                                                              (line  55)
* Legendre symbol functions:             Number Theoretic Functions.
                                                              (line  69)
* libgmp:                                Headers and Libraries.
                                                              (line  22)
* libgmpxx:                              Headers and Libraries.
                                                              (line  27)
* Libraries:                             Headers and Libraries.
                                                              (line  22)
* Libtool:                               Headers and Libraries.
                                                              (line  33)
* Libtool versioning:                    Notes for Package Builds.
                                                              (line   9)
* License conditions:                    Copying.             (line   6)
* Limb:                                  Nomenclature and Types.
                                                              (line  31)
* Limb size:                             Useful Macros and Constants.
                                                              (line   7)
* Linear congruential algorithm:         Random Number Algorithms.
                                                              (line  25)
* Linear congruential random numbers:    Random State Initialization.
                                                              (line  32)
* Linking:                               Headers and Libraries.
                                                              (line  22)
* Logical functions:                     Integer Logic and Bit Fiddling.
                                                              (line   6)
* Low-level functions:                   Low-level Functions. (line   6)
* Lucas number algorithm:                Lucas Numbers Algorithm.
                                                              (line   6)
* Lucas number functions:                Number Theoretic Functions.
                                                              (line 119)
* MacOS X:                               Known Build Problems.
                                                              (line  51)
* Mailing lists:                         Introduction to GMP. (line  45)
* Malloc debugger:                       Debugging.           (line  30)
* Malloc problems:                       Debugging.           (line  24)
* Memory allocation:                     Custom Allocation.   (line   6)
* Memory management:                     Memory Management.   (line   6)
* Mersenne twister algorithm:            Random Number Algorithms.
                                                              (line  17)
* Mersenne twister random numbers:       Random State Initialization.
                                                              (line  13)
* MINGW:                                 Notes for Particular Systems.
                                                              (line  43)
* MIPS:                                  ABI and ISA.         (line 132)
* Miscellaneous float functions:         Miscellaneous Float Functions.
                                                              (line   6)
* Miscellaneous integer functions:       Miscellaneous Integer Functions.
                                                              (line   6)
* MMX:                                   Notes for Particular Systems.
                                                              (line 132)
* Modular inverse functions:             Number Theoretic Functions.
                                                              (line  60)
* Most significant bit:                  Miscellaneous Integer Functions.
                                                              (line  34)
* mp.h:                                  BSD Compatible Functions.
                                                              (line  21)
* MPN_PATH:                              Build Options.       (line 335)
* MS Windows:                            Notes for Particular Systems.
                                                              (line  56)
* MS-DOS:                                Notes for Particular Systems.
                                                              (line  43)
* Multi-threading:                       Reentrancy.          (line   6)
* Multiplication algorithms:             Multiplication Algorithms.
                                                              (line   6)
* Nails:                                 Low-level Functions. (line 478)
* Native compilation:                    Build Options.       (line  52)
* NeXT:                                  Known Build Problems.
                                                              (line  57)
* Next prime function:                   Number Theoretic Functions.
                                                              (line  23)
* Nomenclature:                          Nomenclature and Types.
                                                              (line   6)
* Non-Unix systems:                      Build Options.       (line  11)
* Nth root algorithm:                    Nth Root Algorithm.  (line   6)
* Number sequences:                      Efficiency.          (line 147)
* Number theoretic functions:            Number Theoretic Functions.
                                                              (line   6)
* Numerator and denominator:             Applying Integer Functions.
                                                              (line   6)
* obstack output:                        Formatted Output Functions.
                                                              (line  81)
* OpenBSD:                               Notes for Particular Systems.
                                                              (line  86)
* Optimizing performance:                Performance optimization.
                                                              (line   6)
* ostream output:                        C++ Formatted Output.
                                                              (line   6)
* Other languages:                       Language Bindings.   (line   6)
* Output functions <1>:                  I/O of Floats.       (line   6)
* Output functions <2>:                  I/O of Rationals.    (line   6)
* Output functions <3>:                  Formatted Output Functions.
                                                              (line   6)
* Output functions:                      I/O of Integers.     (line   6)
* Packaged builds:                       Notes for Package Builds.
                                                              (line   6)
* Parameter conventions:                 Parameter Conventions.
                                                              (line   6)
* Parsing expressions demo:              Demonstration Programs.
                                                              (line  21)
* Particular systems:                    Notes for Particular Systems.
                                                              (line   6)
* Past GMP versions:                     Compatibility with older versions.
                                                              (line   6)
* PDF:                                   Build Options.       (line 350)
* Perfect power algorithm:               Perfect Power Algorithm.
                                                              (line   6)
* Perfect power functions:               Integer Roots.       (line  27)
* Perfect square algorithm:              Perfect Square Algorithm.
                                                              (line   6)
* Perfect square functions:              Integer Roots.       (line  36)
* perl:                                  Demonstration Programs.
                                                              (line  35)
* Perl module:                           Demonstration Programs.
                                                              (line  35)
* Postscript:                            Build Options.       (line 350)
* Power/PowerPC <1>:                     Known Build Problems.
                                                              (line  63)
* Power/PowerPC:                         Notes for Particular Systems.
                                                              (line  92)
* Powering algorithms:                   Powering Algorithms. (line   6)
* Powering functions <1>:                Float Arithmetic.    (line  41)
* Powering functions:                    Integer Exponentiation.
                                                              (line   6)
* PowerPC:                               ABI and ISA.         (line 167)
* Precision of floats:                   Floating-point Functions.
                                                              (line   6)
* Precision of hardware floating point:  Notes for Particular Systems.
                                                              (line  34)
* Prefix:                                Build Options.       (line  32)
* Prime testing algorithms:              Prime Testing Algorithm.
                                                              (line   6)
* Prime testing functions:               Number Theoretic Functions.
                                                              (line   7)
* printf formatted output:               Formatted Output.    (line   6)
* Probable prime testing functions:      Number Theoretic Functions.
                                                              (line   7)
* prof:                                  Profiling.           (line  24)
* Profiling:                             Profiling.           (line   6)
* Radix conversion algorithms:           Radix Conversion Algorithms.
                                                              (line   6)
* Random number algorithms:              Random Number Algorithms.
                                                              (line   6)
* Random number functions <1>:           Integer Random Numbers.
                                                              (line   6)
* Random number functions <2>:           Miscellaneous Float Functions.
                                                              (line  27)
* Random number functions:               Random Number Functions.
                                                              (line   6)
* Random number seeding:                 Random State Seeding.
                                                              (line   6)
* Random number state:                   Random State Initialization.
                                                              (line   6)
* Random state:                          Nomenclature and Types.
                                                              (line  46)
* Rational arithmetic:                   Efficiency.          (line 113)
* Rational arithmetic functions:         Rational Arithmetic. (line   6)
* Rational assignment functions:         Initializing Rationals.
                                                              (line   6)
* Rational comparison functions:         Comparing Rationals. (line   6)
* Rational conversion functions:         Rational Conversions.
                                                              (line   6)
* Rational initialization functions:     Initializing Rationals.
                                                              (line   6)
* Rational input and output functions:   I/O of Rationals.    (line   6)
* Rational internals:                    Rational Internals.  (line   6)
* Rational number:                       Nomenclature and Types.
                                                              (line  16)
* Rational number functions:             Rational Number Functions.
                                                              (line   6)
* Rational numerator and denominator:    Applying Integer Functions.
                                                              (line   6)
* Rational sign tests:                   Comparing Rationals. (line  27)
* Raw output internals:                  Raw Output Internals.
                                                              (line   6)
* Reallocations:                         Efficiency.          (line  30)
* Reentrancy:                            Reentrancy.          (line   6)
* References:                            References.          (line   6)
* Remove factor functions:               Number Theoretic Functions.
                                                              (line  90)
* Reporting bugs:                        Reporting Bugs.      (line   6)
* Root extraction algorithm:             Nth Root Algorithm.  (line   6)
* Root extraction algorithms:            Root Extraction Algorithms.
                                                              (line   6)
* Root extraction functions <1>:         Float Arithmetic.    (line  37)
* Root extraction functions:             Integer Roots.       (line   6)
* Root testing functions:                Integer Roots.       (line  36)
* Rounding functions:                    Miscellaneous Float Functions.
                                                              (line   9)
* Sample programs:                       Demonstration Programs.
                                                              (line   6)
* Scan bit functions:                    Integer Logic and Bit Fiddling.
                                                              (line  38)
* scanf formatted input:                 Formatted Input.     (line   6)
* SCO:                                   Known Build Problems.
                                                              (line  38)
* Seeding random numbers:                Random State Seeding.
                                                              (line   6)
* Segmentation violation:                Debugging.           (line   7)
* Sequent Symmetry:                      Known Build Problems.
                                                              (line  68)
* Services for Unix:                     Notes for Particular Systems.
                                                              (line  51)
* Shared library versioning:             Notes for Package Builds.
                                                              (line   9)
* Sign tests <1>:                        Float Comparison.    (line  33)
* Sign tests <2>:                        Integer Comparisons. (line  28)
* Sign tests:                            Comparing Rationals. (line  27)
* Size in digits:                        Miscellaneous Integer Functions.
                                                              (line  23)
* Small operands:                        Efficiency.          (line   7)
* Solaris <1>:                           ABI and ISA.         (line 201)
* Solaris:                               Known Build Problems.
                                                              (line  78)
* Sparc:                                 Notes for Particular Systems.
                                                              (line 108)
* Sparc V9:                              ABI and ISA.         (line 201)
* Special integer functions:             Integer Special Functions.
                                                              (line   6)
* Square root algorithm:                 Square Root Algorithm.
                                                              (line   6)
* SSE2:                                  Notes for Particular Systems.
                                                              (line 132)
* Stack backtrace:                       Debugging.           (line  50)
* Stack overflow <1>:                    Debugging.           (line   7)
* Stack overflow:                        Build Options.       (line 278)
* Static linking:                        Efficiency.          (line  14)
* stdarg.h:                              Headers and Libraries.
                                                              (line  17)
* stdio.h:                               Headers and Libraries.
                                                              (line  11)
* Stripped libraries:                    Known Build Problems.
                                                              (line  28)
* Sun:                                   ABI and ISA.         (line 201)
* SunOS:                                 Notes for Particular Systems.
                                                              (line 120)
* Systems:                               Notes for Particular Systems.
                                                              (line   6)
* Temporary memory:                      Build Options.       (line 278)
* Texinfo:                               Build Options.       (line 347)
* Text input/output:                     Efficiency.          (line 153)
* Thread safety:                         Reentrancy.          (line   6)
* Toom multiplication <1>:               Other Multiplication.
                                                              (line   6)
* Toom multiplication <2>:               Toom 4-Way Multiplication.
                                                              (line   6)
* Toom multiplication:                   Toom 3-Way Multiplication.
                                                              (line   6)
* Types:                                 Nomenclature and Types.
                                                              (line   6)
* ui and si functions:                   Efficiency.          (line  50)
* Unbalanced multiplication:             Unbalanced Multiplication.
                                                              (line   6)
* Upward compatibility:                  Compatibility with older versions.
                                                              (line   6)
* Useful macros and constants:           Useful Macros and Constants.
                                                              (line   6)
* User-defined precision:                Floating-point Functions.
                                                              (line   6)
* Valgrind:                              Debugging.           (line 130)
* Variable conventions:                  Variable Conventions.
                                                              (line   6)
* Version number:                        Useful Macros and Constants.
                                                              (line  12)
* Web page:                              Introduction to GMP. (line  34)
* Windows:                               Notes for Particular Systems.
                                                              (line  56)
* x86:                                   Notes for Particular Systems.
                                                              (line 126)
* x87:                                   Notes for Particular Systems.
                                                              (line  34)
* XML:                                   Build Options.       (line 354)


File: gmp.info,  Node: Function Index,  Prev: Concept Index,  Up: Top

Function and Type Index
***********************

[index]
* Menu:

* __GMP_CC:                              Useful Macros and Constants.
                                                              (line  23)
* __GMP_CFLAGS:                          Useful Macros and Constants.
                                                              (line  24)
* __GNU_MP_VERSION:                      Useful Macros and Constants.
                                                              (line  10)
* __GNU_MP_VERSION_MINOR:                Useful Macros and Constants.
                                                              (line  11)
* __GNU_MP_VERSION_PATCHLEVEL:           Useful Macros and Constants.
                                                              (line  12)
* _mpz_realloc:                          Integer Special Functions.
                                                              (line  51)
* abs <1>:                               C++ Interface Rationals.
                                                              (line  43)
* abs <2>:                               C++ Interface Integers.
                                                              (line  42)
* abs:                                   C++ Interface Floats.
                                                              (line  70)
* ceil:                                  C++ Interface Floats.
                                                              (line  71)
* cmp <1>:                               C++ Interface Floats.
                                                              (line  72)
* cmp <2>:                               C++ Interface Rationals.
                                                              (line  44)
* cmp <3>:                               C++ Interface Integers.
                                                              (line  44)
* cmp:                                   C++ Interface Rationals.
                                                              (line  45)
* floor:                                 C++ Interface Floats.
                                                              (line  80)
* gcd:                                   BSD Compatible Functions.
                                                              (line  82)
* gmp_asprintf:                          Formatted Output Functions.
                                                              (line  65)
* gmp_errno:                             Random State Initialization.
                                                              (line  55)
* GMP_ERROR_INVALID_ARGUMENT:            Random State Initialization.
                                                              (line  55)
* GMP_ERROR_UNSUPPORTED_ARGUMENT:        Random State Initialization.
                                                              (line  55)
* gmp_fprintf:                           Formatted Output Functions.
                                                              (line  29)
* gmp_fscanf:                            Formatted Input Functions.
                                                              (line  25)
* GMP_LIMB_BITS:                         Low-level Functions. (line 508)
* GMP_NAIL_BITS:                         Low-level Functions. (line 506)
* GMP_NAIL_MASK:                         Low-level Functions. (line 516)
* GMP_NUMB_BITS:                         Low-level Functions. (line 507)
* GMP_NUMB_MASK:                         Low-level Functions. (line 517)
* GMP_NUMB_MAX:                          Low-level Functions. (line 525)
* gmp_obstack_printf:                    Formatted Output Functions.
                                                              (line  79)
* gmp_obstack_vprintf:                   Formatted Output Functions.
                                                              (line  81)
* gmp_printf:                            Formatted Output Functions.
                                                              (line  24)
* GMP_RAND_ALG_DEFAULT:                  Random State Initialization.
                                                              (line  49)
* GMP_RAND_ALG_LC:                       Random State Initialization.
                                                              (line  49)
* gmp_randclass:                         C++ Interface Random Numbers.
                                                              (line   7)
* gmp_randclass::get_f:                  C++ Interface Random Numbers.
                                                              (line  45)
* gmp_randclass::get_z_bits:             C++ Interface Random Numbers.
                                                              (line  39)
* gmp_randclass::get_z_range:            C++ Interface Random Numbers.
                                                              (line  42)
* gmp_randclass::gmp_randclass:          C++ Interface Random Numbers.
                                                              (line  13)
* gmp_randclass::seed:                   C++ Interface Random Numbers.
                                                              (line  33)
* gmp_randclear:                         Random State Initialization.
                                                              (line  62)
* gmp_randinit:                          Random State Initialization.
                                                              (line  47)
* gmp_randinit_default:                  Random State Initialization.
                                                              (line   7)
* gmp_randinit_lc_2exp:                  Random State Initialization.
                                                              (line  18)
* gmp_randinit_lc_2exp_size:             Random State Initialization.
                                                              (line  32)
* gmp_randinit_mt:                       Random State Initialization.
                                                              (line  13)
* gmp_randinit_set:                      Random State Initialization.
                                                              (line  43)
* gmp_randseed:                          Random State Seeding.
                                                              (line   7)
* gmp_randseed_ui:                       Random State Seeding.
                                                              (line   9)
* gmp_randstate_t:                       Nomenclature and Types.
                                                              (line  46)
* gmp_scanf:                             Formatted Input Functions.
                                                              (line  21)
* gmp_snprintf:                          Formatted Output Functions.
                                                              (line  46)
* gmp_sprintf:                           Formatted Output Functions.
                                                              (line  34)
* gmp_sscanf:                            Formatted Input Functions.
                                                              (line  29)
* gmp_urandomb_ui:                       Random State Miscellaneous.
                                                              (line   8)
* gmp_urandomm_ui:                       Random State Miscellaneous.
                                                              (line  14)
* gmp_vasprintf:                         Formatted Output Functions.
                                                              (line  66)
* gmp_version:                           Useful Macros and Constants.
                                                              (line  18)
* gmp_vfprintf:                          Formatted Output Functions.
                                                              (line  30)
* gmp_vfscanf:                           Formatted Input Functions.
                                                              (line  26)
* gmp_vprintf:                           Formatted Output Functions.
                                                              (line  25)
* gmp_vscanf:                            Formatted Input Functions.
                                                              (line  22)
* gmp_vsnprintf:                         Formatted Output Functions.
                                                              (line  48)
* gmp_vsprintf:                          Formatted Output Functions.
                                                              (line  35)
* gmp_vsscanf:                           Formatted Input Functions.
                                                              (line  31)
* hypot:                                 C++ Interface Floats.
                                                              (line  81)
* itom:                                  BSD Compatible Functions.
                                                              (line  29)
* madd:                                  BSD Compatible Functions.
                                                              (line  43)
* mcmp:                                  BSD Compatible Functions.
                                                              (line  85)
* mdiv:                                  BSD Compatible Functions.
                                                              (line  53)
* mfree:                                 BSD Compatible Functions.
                                                              (line 105)
* min:                                   BSD Compatible Functions.
                                                              (line  89)
* MINT:                                  BSD Compatible Functions.
                                                              (line  21)
* mout:                                  BSD Compatible Functions.
                                                              (line  94)
* move:                                  BSD Compatible Functions.
                                                              (line  39)
* mp_bitcnt_t:                           Nomenclature and Types.
                                                              (line  42)
* mp_bits_per_limb:                      Useful Macros and Constants.
                                                              (line   7)
* mp_exp_t:                              Nomenclature and Types.
                                                              (line  27)
* mp_get_memory_functions:               Custom Allocation.   (line  93)
* mp_limb_t:                             Nomenclature and Types.
                                                              (line  31)
* mp_set_memory_functions:               Custom Allocation.   (line  21)
* mp_size_t:                             Nomenclature and Types.
                                                              (line  37)
* mpf_abs:                               Float Arithmetic.    (line  47)
* mpf_add:                               Float Arithmetic.    (line   7)
* mpf_add_ui:                            Float Arithmetic.    (line   9)
* mpf_ceil:                              Miscellaneous Float Functions.
                                                              (line   7)
* mpf_class:                             C++ Interface General.
                                                              (line  20)
* mpf_class::fits_sint_p:                C++ Interface Floats.
                                                              (line  74)
* mpf_class::fits_slong_p:               C++ Interface Floats.
                                                              (line  75)
* mpf_class::fits_sshort_p:              C++ Interface Floats.
                                                              (line  76)
* mpf_class::fits_uint_p:                C++ Interface Floats.
                                                              (line  77)
* mpf_class::fits_ulong_p:               C++ Interface Floats.
                                                              (line  78)
* mpf_class::fits_ushort_p:              C++ Interface Floats.
                                                              (line  79)
* mpf_class::get_d:                      C++ Interface Floats.
                                                              (line  82)
* mpf_class::get_mpf_t:                  C++ Interface General.
                                                              (line  66)
* mpf_class::get_prec:                   C++ Interface Floats.
                                                              (line 100)
* mpf_class::get_si:                     C++ Interface Floats.
                                                              (line  83)
* mpf_class::get_str:                    C++ Interface Floats.
                                                              (line  85)
* mpf_class::get_ui:                     C++ Interface Floats.
                                                              (line  86)
* mpf_class::mpf_class:                  C++ Interface Floats.
                                                              (line  38)
* mpf_class::operator=:                  C++ Interface Floats.
                                                              (line  47)
* mpf_class::set_prec:                   C++ Interface Floats.
                                                              (line 101)
* mpf_class::set_prec_raw:               C++ Interface Floats.
                                                              (line 102)
* mpf_class::set_str:                    C++ Interface Floats.
                                                              (line  88)
* mpf_clear:                             Initializing Floats. (line  37)
* mpf_clears:                            Initializing Floats. (line  41)
* mpf_cmp:                               Float Comparison.    (line   7)
* mpf_cmp_d:                             Float Comparison.    (line   8)
* mpf_cmp_si:                            Float Comparison.    (line  10)
* mpf_cmp_ui:                            Float Comparison.    (line   9)
* mpf_div:                               Float Arithmetic.    (line  29)
* mpf_div_2exp:                          Float Arithmetic.    (line  53)
* mpf_div_ui:                            Float Arithmetic.    (line  33)
* mpf_eq:                                Float Comparison.    (line  17)
* mpf_fits_sint_p:                       Miscellaneous Float Functions.
                                                              (line  20)
* mpf_fits_slong_p:                      Miscellaneous Float Functions.
                                                              (line  18)
* mpf_fits_sshort_p:                     Miscellaneous Float Functions.
                                                              (line  22)
* mpf_fits_uint_p:                       Miscellaneous Float Functions.
                                                              (line  19)
* mpf_fits_ulong_p:                      Miscellaneous Float Functions.
                                                              (line  17)
* mpf_fits_ushort_p:                     Miscellaneous Float Functions.
                                                              (line  21)
* mpf_floor:                             Miscellaneous Float Functions.
                                                              (line   8)
* mpf_get_d:                             Converting Floats.   (line   7)
* mpf_get_d_2exp:                        Converting Floats.   (line  16)
* mpf_get_default_prec:                  Initializing Floats. (line  12)
* mpf_get_prec:                          Initializing Floats. (line  62)
* mpf_get_si:                            Converting Floats.   (line  27)
* mpf_get_str:                           Converting Floats.   (line  37)
* mpf_get_ui:                            Converting Floats.   (line  28)
* mpf_init:                              Initializing Floats. (line  19)
* mpf_init2:                             Initializing Floats. (line  26)
* mpf_init_set:                          Simultaneous Float Init & Assign.
                                                              (line  16)
* mpf_init_set_d:                        Simultaneous Float Init & Assign.
                                                              (line  19)
* mpf_init_set_si:                       Simultaneous Float Init & Assign.
                                                              (line  18)
* mpf_init_set_str:                      Simultaneous Float Init & Assign.
                                                              (line  25)
* mpf_init_set_ui:                       Simultaneous Float Init & Assign.
                                                              (line  17)
* mpf_inits:                             Initializing Floats. (line  31)
* mpf_inp_str:                           I/O of Floats.       (line  37)
* mpf_integer_p:                         Miscellaneous Float Functions.
                                                              (line  14)
* mpf_mul:                               Float Arithmetic.    (line  19)
* mpf_mul_2exp:                          Float Arithmetic.    (line  50)
* mpf_mul_ui:                            Float Arithmetic.    (line  21)
* mpf_neg:                               Float Arithmetic.    (line  44)
* mpf_out_str:                           I/O of Floats.       (line  17)
* mpf_pow_ui:                            Float Arithmetic.    (line  41)
* mpf_random2:                           Miscellaneous Float Functions.
                                                              (line  36)
* mpf_reldiff:                           Float Comparison.    (line  29)
* mpf_set:                               Assigning Floats.    (line  10)
* mpf_set_d:                             Assigning Floats.    (line  13)
* mpf_set_default_prec:                  Initializing Floats. (line   7)
* mpf_set_prec:                          Initializing Floats. (line  65)
* mpf_set_prec_raw:                      Initializing Floats. (line  72)
* mpf_set_q:                             Assigning Floats.    (line  15)
* mpf_set_si:                            Assigning Floats.    (line  12)
* mpf_set_str:                           Assigning Floats.    (line  18)
* mpf_set_ui:                            Assigning Floats.    (line  11)
* mpf_set_z:                             Assigning Floats.    (line  14)
* mpf_sgn:                               Float Comparison.    (line  33)
* mpf_sqrt:                              Float Arithmetic.    (line  36)
* mpf_sqrt_ui:                           Float Arithmetic.    (line  37)
* mpf_sub:                               Float Arithmetic.    (line  12)
* mpf_sub_ui:                            Float Arithmetic.    (line  16)
* mpf_swap:                              Assigning Floats.    (line  52)
* mpf_t:                                 Nomenclature and Types.
                                                              (line  21)
* mpf_trunc:                             Miscellaneous Float Functions.
                                                              (line   9)
* mpf_ui_div:                            Float Arithmetic.    (line  31)
* mpf_ui_sub:                            Float Arithmetic.    (line  14)
* mpf_urandomb:                          Miscellaneous Float Functions.
                                                              (line  27)
* mpn_add:                               Low-level Functions. (line  69)
* mpn_add_1:                             Low-level Functions. (line  64)
* mpn_add_n:                             Low-level Functions. (line  54)
* mpn_addmul_1:                          Low-level Functions. (line 148)
* mpn_and_n:                             Low-level Functions. (line 420)
* mpn_andn_n:                            Low-level Functions. (line 435)
* mpn_cmp:                               Low-level Functions. (line 284)
* mpn_com:                               Low-level Functions. (line 460)
* mpn_copyd:                             Low-level Functions. (line 469)
* mpn_copyi:                             Low-level Functions. (line 465)
* mpn_divexact_by3:                      Low-level Functions. (line 229)
* mpn_divexact_by3c:                     Low-level Functions. (line 231)
* mpn_divmod:                            Low-level Functions. (line 224)
* mpn_divmod_1:                          Low-level Functions. (line 208)
* mpn_divrem:                            Low-level Functions. (line 182)
* mpn_divrem_1:                          Low-level Functions. (line 206)
* mpn_gcd:                               Low-level Functions. (line 289)
* mpn_gcd_1:                             Low-level Functions. (line 299)
* mpn_gcdext:                            Low-level Functions. (line 305)
* mpn_get_str:                           Low-level Functions. (line 346)
* mpn_hamdist:                           Low-level Functions. (line 410)
* mpn_ior_n:                             Low-level Functions. (line 425)
* mpn_iorn_n:                            Low-level Functions. (line 440)
* mpn_lshift:                            Low-level Functions. (line 260)
* mpn_mod_1:                             Low-level Functions. (line 255)
* mpn_mul:                               Low-level Functions. (line 114)
* mpn_mul_1:                             Low-level Functions. (line 133)
* mpn_mul_n:                             Low-level Functions. (line 103)
* mpn_nand_n:                            Low-level Functions. (line 445)
* mpn_neg:                               Low-level Functions. (line  98)
* mpn_nior_n:                            Low-level Functions. (line 450)
* mpn_perfect_square_p:                  Low-level Functions. (line 416)
* mpn_popcount:                          Low-level Functions. (line 406)
* mpn_random:                            Low-level Functions. (line 395)
* mpn_random2:                           Low-level Functions. (line 396)
* mpn_rshift:                            Low-level Functions. (line 272)
* mpn_scan0:                             Low-level Functions. (line 380)
* mpn_scan1:                             Low-level Functions. (line 388)
* mpn_set_str:                           Low-level Functions. (line 361)
* mpn_sqr:                               Low-level Functions. (line 125)
* mpn_sqrtrem:                           Low-level Functions. (line 328)
* mpn_sub:                               Low-level Functions. (line  90)
* mpn_sub_1:                             Low-level Functions. (line  85)
* mpn_sub_n:                             Low-level Functions. (line  76)
* mpn_submul_1:                          Low-level Functions. (line 159)
* mpn_tdiv_qr:                           Low-level Functions. (line 171)
* mpn_xnor_n:                            Low-level Functions. (line 455)
* mpn_xor_n:                             Low-level Functions. (line 430)
* mpn_zero:                              Low-level Functions. (line 472)
* mpq_abs:                               Rational Arithmetic. (line  31)
* mpq_add:                               Rational Arithmetic. (line   7)
* mpq_canonicalize:                      Rational Number Functions.
                                                              (line  22)
* mpq_class:                             C++ Interface General.
                                                              (line  19)
* mpq_class::canonicalize:               C++ Interface Rationals.
                                                              (line  37)
* mpq_class::get_d:                      C++ Interface Rationals.
                                                              (line  46)
* mpq_class::get_den:                    C++ Interface Rationals.
                                                              (line  58)
* mpq_class::get_den_mpz_t:              C++ Interface Rationals.
                                                              (line  68)
* mpq_class::get_mpq_t:                  C++ Interface General.
                                                              (line  65)
* mpq_class::get_num:                    C++ Interface Rationals.
                                                              (line  57)
* mpq_class::get_num_mpz_t:              C++ Interface Rationals.
                                                              (line  67)
* mpq_class::get_str:                    C++ Interface Rationals.
                                                              (line  47)
* mpq_class::mpq_class:                  C++ Interface Rationals.
                                                              (line  22)
* mpq_class::set_str:                    C++ Interface Rationals.
                                                              (line  49)
* mpq_clear:                             Initializing Rationals.
                                                              (line  16)
* mpq_clears:                            Initializing Rationals.
                                                              (line  20)
* mpq_cmp:                               Comparing Rationals. (line   7)
* mpq_cmp_si:                            Comparing Rationals. (line  17)
* mpq_cmp_ui:                            Comparing Rationals. (line  15)
* mpq_denref:                            Applying Integer Functions.
                                                              (line  18)
* mpq_div:                               Rational Arithmetic. (line  22)
* mpq_div_2exp:                          Rational Arithmetic. (line  25)
* mpq_equal:                             Comparing Rationals. (line  33)
* mpq_get_d:                             Rational Conversions.
                                                              (line   7)
* mpq_get_den:                           Applying Integer Functions.
                                                              (line  24)
* mpq_get_num:                           Applying Integer Functions.
                                                              (line  23)
* mpq_get_str:                           Rational Conversions.
                                                              (line  22)
* mpq_init:                              Initializing Rationals.
                                                              (line   7)
* mpq_inits:                             Initializing Rationals.
                                                              (line  12)
* mpq_inp_str:                           I/O of Rationals.    (line  23)
* mpq_inv:                               Rational Arithmetic. (line  34)
* mpq_mul:                               Rational Arithmetic. (line  15)
* mpq_mul_2exp:                          Rational Arithmetic. (line  18)
* mpq_neg:                               Rational Arithmetic. (line  28)
* mpq_numref:                            Applying Integer Functions.
                                                              (line  17)
* mpq_out_str:                           I/O of Rationals.    (line  15)
* mpq_set:                               Initializing Rationals.
                                                              (line  24)
* mpq_set_d:                             Rational Conversions.
                                                              (line  17)
* mpq_set_den:                           Applying Integer Functions.
                                                              (line  26)
* mpq_set_f:                             Rational Conversions.
                                                              (line  18)
* mpq_set_num:                           Applying Integer Functions.
                                                              (line  25)
* mpq_set_si:                            Initializing Rationals.
                                                              (line  31)
* mpq_set_str:                           Initializing Rationals.
                                                              (line  36)
* mpq_set_ui:                            Initializing Rationals.
                                                              (line  29)
* mpq_set_z:                             Initializing Rationals.
                                                              (line  25)
* mpq_sgn:                               Comparing Rationals. (line  27)
* mpq_sub:                               Rational Arithmetic. (line  11)
* mpq_swap:                              Initializing Rationals.
                                                              (line  56)
* mpq_t:                                 Nomenclature and Types.
                                                              (line  16)
* mpz_abs:                               Integer Arithmetic.  (line  42)
* mpz_add:                               Integer Arithmetic.  (line   7)
* mpz_add_ui:                            Integer Arithmetic.  (line   9)
* mpz_addmul:                            Integer Arithmetic.  (line  25)
* mpz_addmul_ui:                         Integer Arithmetic.  (line  27)
* mpz_and:                               Integer Logic and Bit Fiddling.
                                                              (line  11)
* mpz_array_init:                        Integer Special Functions.
                                                              (line  11)
* mpz_bin_ui:                            Number Theoretic Functions.
                                                              (line  98)
* mpz_bin_uiui:                          Number Theoretic Functions.
                                                              (line 100)
* mpz_cdiv_q:                            Integer Division.    (line  13)
* mpz_cdiv_q_2exp:                       Integer Division.    (line  24)
* mpz_cdiv_q_ui:                         Integer Division.    (line  17)
* mpz_cdiv_qr:                           Integer Division.    (line  15)
* mpz_cdiv_qr_ui:                        Integer Division.    (line  21)
* mpz_cdiv_r:                            Integer Division.    (line  14)
* mpz_cdiv_r_2exp:                       Integer Division.    (line  25)
* mpz_cdiv_r_ui:                         Integer Division.    (line  19)
* mpz_cdiv_ui:                           Integer Division.    (line  23)
* mpz_class:                             C++ Interface General.
                                                              (line  18)
* mpz_class::fits_sint_p:                C++ Interface Integers.
                                                              (line  45)
* mpz_class::fits_slong_p:               C++ Interface Integers.
                                                              (line  46)
* mpz_class::fits_sshort_p:              C++ Interface Integers.
                                                              (line  47)
* mpz_class::fits_uint_p:                C++ Interface Integers.
                                                              (line  48)
* mpz_class::fits_ulong_p:               C++ Interface Integers.
                                                              (line  49)
* mpz_class::fits_ushort_p:              C++ Interface Integers.
                                                              (line  50)
* mpz_class::get_d:                      C++ Interface Integers.
                                                              (line  51)
* mpz_class::get_mpz_t:                  C++ Interface General.
                                                              (line  64)
* mpz_class::get_si:                     C++ Interface Integers.
                                                              (line  52)
* mpz_class::get_str:                    C++ Interface Integers.
                                                              (line  53)
* mpz_class::get_ui:                     C++ Interface Integers.
                                                              (line  54)
* mpz_class::mpz_class:                  C++ Interface Integers.
                                                              (line   7)
* mpz_class::set_str:                    C++ Interface Integers.
                                                              (line  56)
* mpz_clear:                             Initializing Integers.
                                                              (line  44)
* mpz_clears:                            Initializing Integers.
                                                              (line  48)
* mpz_clrbit:                            Integer Logic and Bit Fiddling.
                                                              (line  54)
* mpz_cmp:                               Integer Comparisons. (line   7)
* mpz_cmp_d:                             Integer Comparisons. (line   8)
* mpz_cmp_si:                            Integer Comparisons. (line   9)
* mpz_cmp_ui:                            Integer Comparisons. (line  10)
* mpz_cmpabs:                            Integer Comparisons. (line  18)
* mpz_cmpabs_d:                          Integer Comparisons. (line  19)
* mpz_cmpabs_ui:                         Integer Comparisons. (line  20)
* mpz_com:                               Integer Logic and Bit Fiddling.
                                                              (line  20)
* mpz_combit:                            Integer Logic and Bit Fiddling.
                                                              (line  57)
* mpz_congruent_2exp_p:                  Integer Division.    (line 124)
* mpz_congruent_p:                       Integer Division.    (line 121)
* mpz_congruent_ui_p:                    Integer Division.    (line 123)
* mpz_divexact:                          Integer Division.    (line 101)
* mpz_divexact_ui:                       Integer Division.    (line 102)
* mpz_divisible_2exp_p:                  Integer Division.    (line 112)
* mpz_divisible_p:                       Integer Division.    (line 110)
* mpz_divisible_ui_p:                    Integer Division.    (line 111)
* mpz_even_p:                            Miscellaneous Integer Functions.
                                                              (line  18)
* mpz_export:                            Integer Import and Export.
                                                              (line  45)
* mpz_fac_ui:                            Number Theoretic Functions.
                                                              (line  95)
* mpz_fdiv_q:                            Integer Division.    (line  27)
* mpz_fdiv_q_2exp:                       Integer Division.    (line  38)
* mpz_fdiv_q_ui:                         Integer Division.    (line  31)
* mpz_fdiv_qr:                           Integer Division.    (line  29)
* mpz_fdiv_qr_ui:                        Integer Division.    (line  35)
* mpz_fdiv_r:                            Integer Division.    (line  28)
* mpz_fdiv_r_2exp:                       Integer Division.    (line  39)
* mpz_fdiv_r_ui:                         Integer Division.    (line  33)
* mpz_fdiv_ui:                           Integer Division.    (line  37)
* mpz_fib2_ui:                           Number Theoretic Functions.
                                                              (line 108)
* mpz_fib_ui:                            Number Theoretic Functions.
                                                              (line 106)
* mpz_fits_sint_p:                       Miscellaneous Integer Functions.
                                                              (line  10)
* mpz_fits_slong_p:                      Miscellaneous Integer Functions.
                                                              (line   8)
* mpz_fits_sshort_p:                     Miscellaneous Integer Functions.
                                                              (line  12)
* mpz_fits_uint_p:                       Miscellaneous Integer Functions.
                                                              (line   9)
* mpz_fits_ulong_p:                      Miscellaneous Integer Functions.
                                                              (line   7)
* mpz_fits_ushort_p:                     Miscellaneous Integer Functions.
                                                              (line  11)
* mpz_gcd:                               Number Theoretic Functions.
                                                              (line  30)
* mpz_gcd_ui:                            Number Theoretic Functions.
                                                              (line  35)
* mpz_gcdext:                            Number Theoretic Functions.
                                                              (line  45)
* mpz_get_d:                             Converting Integers. (line  27)
* mpz_get_d_2exp:                        Converting Integers. (line  35)
* mpz_get_si:                            Converting Integers. (line  18)
* mpz_get_str:                           Converting Integers. (line  46)
* mpz_get_ui:                            Converting Integers. (line  11)
* mpz_getlimbn:                          Integer Special Functions.
                                                              (line  60)
* mpz_hamdist:                           Integer Logic and Bit Fiddling.
                                                              (line  29)
* mpz_import:                            Integer Import and Export.
                                                              (line  11)
* mpz_init:                              Initializing Integers.
                                                              (line  26)
* mpz_init2:                             Initializing Integers.
                                                              (line  33)
* mpz_init_set:                          Simultaneous Integer Init & Assign.
                                                              (line  27)
* mpz_init_set_d:                        Simultaneous Integer Init & Assign.
                                                              (line  30)
* mpz_init_set_si:                       Simultaneous Integer Init & Assign.
                                                              (line  29)
* mpz_init_set_str:                      Simultaneous Integer Init & Assign.
                                                              (line  34)
* mpz_init_set_ui:                       Simultaneous Integer Init & Assign.
                                                              (line  28)
* mpz_inits:                             Initializing Integers.
                                                              (line  29)
* mpz_inp_raw:                           I/O of Integers.     (line  59)
* mpz_inp_str:                           I/O of Integers.     (line  28)
* mpz_invert:                            Number Theoretic Functions.
                                                              (line  60)
* mpz_ior:                               Integer Logic and Bit Fiddling.
                                                              (line  14)
* mpz_jacobi:                            Number Theoretic Functions.
                                                              (line  66)
* mpz_kronecker:                         Number Theoretic Functions.
                                                              (line  74)
* mpz_kronecker_si:                      Number Theoretic Functions.
                                                              (line  75)
* mpz_kronecker_ui:                      Number Theoretic Functions.
                                                              (line  76)
* mpz_lcm:                               Number Theoretic Functions.
                                                              (line  54)
* mpz_lcm_ui:                            Number Theoretic Functions.
                                                              (line  55)
* mpz_legendre:                          Number Theoretic Functions.
                                                              (line  69)
* mpz_lucnum2_ui:                        Number Theoretic Functions.
                                                              (line 119)
* mpz_lucnum_ui:                         Number Theoretic Functions.
                                                              (line 117)
* mpz_mod:                               Integer Division.    (line  91)
* mpz_mod_ui:                            Integer Division.    (line  93)
* mpz_mul:                               Integer Arithmetic.  (line  1