SYMBOL INDEX (481 symbols across 32 files)

FILE: examples/basecvt.c
  function main (line 35) | int main(int argc, char* argv[]) {

FILE: examples/findprime.c
  function main (line 35) | int main(int argc, char* argv[]) {

FILE: examples/imcalc.c
  type cstate_t (line 48) | typedef struct {
  type mp_result (line 75) | typedef mp_result (*op_func)(cstate_t*);
  type calcop_t (line 121) | typedef struct {
  type token_t (line 193) | typedef enum { t_eof, t_symbol, t_number, t_error } token_t;
  function main (line 207) | int main(int argc, char* argv[]) {
  function token_t (line 281) | static token_t next_token(FILE* ifp, char* buf, int size) {
  function mp_result (line 324) | static mp_result read_number(char* buf, mp_int* out) {
  function find_command (line 371) | static int find_command(cstate_t* op) {
  function print_value (line 389) | static void print_value(mp_int v) {
  function mp_result (line 420) | static mp_result run_file(FILE* ifp, cstate_t* op_state) {
  function mp_result (line 462) | static mp_result state_init(cstate_t* sp, mp_size n_elts) {
  function state_clear (line 500) | static void state_clear(cstate_t* sp) {
  function stack_flush (line 544) | static void stack_flush(cstate_t* sp) {
  function mp_result (line 557) | static mp_result stack_push(cstate_t* sp, mp_int elt) {
  function mp_result (line 578) | static mp_result stack_pop(cstate_t* sp) {
  function mp_result (line 590) | static mp_result mem_insert(cstate_t* sp, const char* name, mp_int value) {
  function mp_result (line 638) | static mp_result mem_recall(cstate_t* sp, const char* name, mp_int value) {
  function mp_result (line 650) | static mp_result mem_clear(cstate_t* sp) {
  function mp_result (line 662) | static mp_result cf_abs(cstate_t* sp) {
  function mp_result (line 668) | static mp_result cf_neg(cstate_t* sp) {
  function mp_result (line 674) | static mp_result cf_add(cstate_t* sp) {
  function mp_result (line 684) | static mp_result cf_sub(cstate_t* sp) {
  function mp_result (line 694) | static mp_result cf_mul(cstate_t* sp) {
  function mp_result (line 704) | static mp_result cf_divmod(cstate_t* sp) {
  function mp_result (line 711) | static mp_result cf_div(cstate_t* sp) {
  function mp_result (line 721) | static mp_result cf_mod(cstate_t* sp) {
  function mp_result (line 731) | static mp_result cf_expt(cstate_t* sp) {
  function mp_result (line 743) | static mp_result cf_exptmod(cstate_t* sp) {
  function mp_result (line 757) | static mp_result cf_square(cstate_t* sp) {
  function mp_result (line 763) | static mp_result cf_invmod(cstate_t* sp) {
  function mp_result (line 773) | static mp_result cf_gcd(cstate_t* sp) {
  function mp_result (line 783) | static mp_result cf_xgcd(cstate_t* sp) {
  function mp_result (line 800) | static mp_result cf_sqrt(cstate_t* sp) {
  function mp_result (line 806) | static mp_result cf_root(cstate_t* sp) {
  function mp_result (line 818) | static mp_result cf_cmplt(cstate_t* sp) {
  function mp_result (line 828) | static mp_result cf_cmpgt(cstate_t* sp) {
  function mp_result (line 838) | static mp_result cf_cmple(cstate_t* sp) {
  function mp_result (line 848) | static mp_result cf_cmpge(cstate_t* sp) {
  function mp_result (line 858) | static mp_result cf_cmpeq(cstate_t* sp) {
  function mp_result (line 868) | static mp_result cf_cmpne(cstate_t* sp) {
  function mp_result (line 878) | static mp_result cf_inc(cstate_t* sp) {
  function mp_result (line 884) | static mp_result cf_dec(cstate_t* sp) {
  function mp_result (line 890) | static mp_result cf_fact(cstate_t* sp) {
  function mp_result (line 911) | static mp_result cf_pprint(cstate_t* sp) {
  function mp_result (line 917) | static mp_result cf_print(cstate_t* sp) {
  function mp_result (line 922) | static mp_result cf_pstack(cstate_t* sp) {
  function mp_result (line 937) | static mp_result cf_clstk(cstate_t* sp) {
  function mp_result (line 943) | static mp_result cf_pop(cstate_t* sp) { return stack_pop(sp); }
  function mp_result (line 945) | static mp_result cf_dup(cstate_t* sp) {
  function mp_result (line 961) | static mp_result cf_copy(cstate_t* sp) {
  function mp_result (line 989) | static mp_result cf_swap(cstate_t* sp) {
  function mp_result (line 998) | static mp_result cf_rot(cstate_t* sp) {
  function mp_result (line 1008) | static mp_result cf_pick(cstate_t* sp) {
  function mp_result (line 1020) | static mp_result cf_setr(cstate_t* sp) {
  function mp_result (line 1034) | static mp_result cf_setbin(cstate_t* sp) {
  function mp_result (line 1039) | static mp_result cf_help(cstate_t* sp) {
  function mp_result (line 1062) | static mp_result cf_store(cstate_t* sp) {
  function mp_result (line 1073) | static mp_result cf_recall(cstate_t* sp) {
  function mp_result (line 1088) | static mp_result cf_cmem(cstate_t* sp) { return mem_clear(sp); }
  function mp_result (line 1090) | static mp_result cf_pmem(cstate_t* sp) {
  function mp_result (line 1119) | static mp_result cf_qrecall(cstate_t* sp) {

FILE: examples/input.c
  function main (line 36) | int main(int argc, char* argv[]) {

FILE: examples/pi.c
  function main (line 42) | int main(int argc, char* argv[]) {
  function mp_result (line 131) | mp_result arctan(mp_small radix, mp_small mul, mp_small x, mp_small prec,

FILE: examples/randprime.c
  type mp_result (line 58) | typedef mp_result (*find_f)(mp_int, FILE*);
  function main (line 60) | int main(int argc, char* argv[]) {
  function randomize (line 138) | int randomize(unsigned char* buf, size_t len) {
  function mp_result (line 150) | mp_result mp_int_randomize(mp_int a, mp_size n_bits) {
  function mp_result (line 183) | mp_result find_prime(mp_int seed, FILE* fb) {
  function mp_result (line 209) | mp_result find_strong_prime(mp_int seed, FILE* fb) {

FILE: examples/rounding.c
  function main (line 36) | int main(int argc, char* argv[]) {

FILE: examples/rsakey.c
  type rsa_key (line 49) | typedef struct {
  function main (line 71) | int main(int argc, char* argv[]) {
  function randomize (line 200) | int randomize(unsigned char* buf, size_t len) {
  function mp_result (line 212) | mp_result mp_int_randomize(mp_int a, mp_size n_bits) {
  function mp_result (line 245) | mp_result find_prime(mp_int seed, FILE* fb) {
  function mp_result (line 265) | mp_result rsa_key_init(rsa_key* kp) {
  function rsa_key_clear (line 275) | void rsa_key_clear(rsa_key* kp) {
  function rsa_key_write (line 283) | void rsa_key_write(rsa_key* kp, FILE* ofp) {

FILE: gmp_compat.c
  type SSIZE_T (line 36) | typedef SSIZE_T ssize_t;
  function mp_int (line 141) | mp_int GMPQAPI(denref)(mp_rat op) { return mp_rat_denom_ref(op); }
  function mp_int (line 144) | mp_int GMPQAPI(numref)(mp_rat op) { return mp_rat_numer_ref(op); }
  function get_long_bits (line 391) | static unsigned long get_long_bits(mp_int op) {

FILE: imath.c
  function mp_size (line 87) | static inline mp_size s_round_prec(mp_size P) { return 2 * ((P + 1) / 2); }
  function ZERO (line 90) | static inline void ZERO(mp_digit* P, mp_size S) {
  function COPY (line 97) | static inline void COPY(mp_digit* P, mp_digit* Q, mp_size S) {
  function REV (line 105) | static inline void REV(unsigned char* A, int N) {
  function CLAMP (line 116) | static inline void CLAMP(mp_int z_) {
  function MIN (line 124) | static inline int MIN(int A, int B) { return (B < A ? B : A); }
  function mp_size (line 125) | static inline mp_size MAX(mp_size A, mp_size B) { return (B > A ? B : A); }
  function CMPZ (line 137) | static inline int CMPZ(mp_int Z) {
  function mp_word (line 142) | static inline mp_word UPPER_HALF(mp_word W) { return (W >> MP_DIGIT_BIT); }
  function mp_digit (line 143) | static inline mp_digit LOWER_HALF(mp_word W) { return (mp_digit)(W); }
  function HIGH_BIT_SET (line 146) | static inline bool HIGH_BIT_SET(mp_word W) {
  function ADD_WILL_OVERFLOW (line 151) | static inline bool ADD_WILL_OVERFLOW(mp_word W, mp_word V) {
  function mp_int_default_precision (line 158) | void mp_int_default_precision(mp_size size) {
  function mp_int_multiply_threshold (line 166) | void mp_int_multiply_threshold(mp_size thresh) {
  function mp_result (line 183) | static inline mp_result GROW(mp_int Z, mp_size N) {
  function UMUL (line 306) | static inline void UMUL(mp_int X, mp_int Y, mp_int Z) {
  function USQR (line 317) | static inline void USQR(mp_int X, mp_int Z) {
  function mp_result (line 326) | mp_result mp_int_init(mp_int z) {
  function mp_int (line 338) | mp_int mp_int_alloc(void) {
  function mp_result (line 346) | mp_result mp_int_init_size(mp_int z, mp_size prec) {
  function mp_result (line 368) | mp_result mp_int_init_copy(mp_int z, mp_int old) {
  function mp_result (line 387) | mp_result mp_int_init_value(mp_int z, mp_small value) {
  function mp_result (line 395) | mp_result mp_int_init_uvalue(mp_int z, mp_usmall uvalue) {
  function mp_result (line 403) | mp_result mp_int_set_value(mp_int z, mp_small value) {
  function mp_result (line 411) | mp_result mp_int_set_uvalue(mp_int z, mp_usmall uvalue) {
  function mp_int_clear (line 419) | void mp_int_clear(mp_int z) {
  function mp_int_free (line 429) | void mp_int_free(mp_int z) {
  function mp_result (line 436) | mp_result mp_int_copy(mp_int a, mp_int c) {
  function mp_int_swap (line 456) | void mp_int_swap(mp_int a, mp_int c) {
  function mp_int_zero (line 468) | void mp_int_zero(mp_int z) {
  function mp_result (line 476) | mp_result mp_int_abs(mp_int a, mp_int c) {
  function mp_result (line 486) | mp_result mp_int_neg(mp_int a, mp_int c) {
  function mp_result (line 497) | mp_result mp_int_add(mp_int a, mp_int b, mp_int c) {
  function mp_result (line 554) | mp_result mp_int_add_value(mp_int a, mp_small value, mp_int c) {
  function mp_result (line 563) | mp_result mp_int_sub(mp_int a, mp_int b, mp_int c) {
  function mp_result (line 616) | mp_result mp_int_sub_value(mp_int a, mp_small value, mp_int c) {
  function mp_result (line 625) | mp_result mp_int_mul(mp_int a, mp_int b, mp_int c) {
  function mp_result (line 675) | mp_result mp_int_mul_value(mp_int a, mp_small value, mp_int c) {
  function mp_result (line 684) | mp_result mp_int_mul_pow2(mp_int a, mp_small p2, mp_int c) {
  function mp_result (line 697) | mp_result mp_int_sqr(mp_int a, mp_int c) {
  function mp_result (line 734) | mp_result mp_int_div(mp_int a, mp_int b, mp_int q, mp_int r) {
  function mp_result (line 819) | mp_result mp_int_mod(mp_int a, mp_int m, mp_int c) {
  function mp_result (line 836) | mp_result mp_int_div_value(mp_int a, mp_small value, mp_int q, mp_small*...
  function mp_result (line 850) | mp_result mp_int_div_pow2(mp_int a, mp_small p2, mp_int q, mp_int r) {
  function mp_result (line 865) | mp_result mp_int_expt(mp_int a, mp_small b, mp_int c) {
  function mp_result (line 889) | mp_result mp_int_expt_value(mp_small a, mp_small b, mp_int c) {
  function mp_result (line 913) | mp_result mp_int_expt_full(mp_int a, mp_int b, mp_int c) {
  function mp_int_compare (line 939) | int mp_int_compare(mp_int a, mp_int b) {
  function mp_int_compare_unsigned (line 960) | int mp_int_compare_unsigned(mp_int a, mp_int b) {
  function mp_int_compare_zero (line 966) | int mp_int_compare_zero(mp_int z) {
  function mp_int_compare_value (line 978) | int mp_int_compare_value(mp_int z, mp_small value) {
  function mp_int_compare_uvalue (line 991) | int mp_int_compare_uvalue(mp_int z, mp_usmall uv) {
  function mp_result (line 1001) | mp_result mp_int_exptmod(mp_int a, mp_int b, mp_int m, mp_int c) {
  function mp_result (line 1030) | mp_result mp_int_exptmod_evalue(mp_int a, mp_small value, mp_int m, mp_i...
  function mp_result (line 1039) | mp_result mp_int_exptmod_bvalue(mp_small value, mp_int b, mp_int m, mp_i...
  function mp_result (line 1048) | mp_result mp_int_exptmod_known(mp_int a, mp_int b, mp_int m, mp_int mu,
  function mp_result (line 1076) | mp_result mp_int_redux_const(mp_int m, mp_int c) {
  function mp_result (line 1082) | mp_result mp_int_invmod(mp_int a, mp_int m, mp_int c) {
  function mp_result (line 1114) | mp_result mp_int_gcd(mp_int a, mp_int b, mp_int c) {
  function mp_result (line 1175) | mp_result mp_int_egcd(mp_int a, mp_int b, mp_int c, mp_int x, mp_int y) {
  function mp_result (line 1272) | mp_result mp_int_lcm(mp_int a, mp_int b, mp_int c) {
  function mp_int_divisible_value (line 1291) | bool mp_int_divisible_value(mp_int a, mp_small v) {
  function mp_int_is_pow2 (line 1300) | int mp_int_is_pow2(mp_int z) {
  function mp_result (line 1310) | mp_result mp_int_root(mp_int a, mp_small b, mp_int c) {
  function mp_result (line 1357) | mp_result mp_int_to_int(mp_int z, mp_small* out) {
  function mp_result (line 1381) | mp_result mp_int_to_uint(mp_int z, mp_usmall* out) {
  function mp_result (line 1405) | mp_result mp_int_to_string(mp_int z, mp_size radix, char* str, int limit) {
  function mp_size (line 1454) | mp_size mp_int_string_len(mp_int z, mp_size radix) {
  function mp_result (line 1467) | mp_result mp_int_read_string(mp_int z, mp_size radix, const char* str) {
  function mp_result (line 1471) | mp_result mp_int_read_cstring(mp_int z, mp_size radix, const char* str,
  function mp_size (line 1524) | mp_size mp_int_count_bits(mp_int z) {
  function mp_result (line 1542) | mp_result mp_int_to_binary(mp_int z, unsigned char* buf, int limit) {
  function mp_result (line 1555) | mp_result mp_int_read_binary(mp_int z, unsigned char* buf, int len) {
  function mp_size (line 1584) | mp_size mp_int_binary_len(mp_int z) {
  function mp_result (line 1598) | mp_result mp_int_to_unsigned(mp_int z, unsigned char* buf, int limit) {
  function mp_result (line 1606) | mp_result mp_int_read_unsigned(mp_int z, unsigned char* buf, int len) {
  function mp_size (line 1624) | mp_size mp_int_unsigned_len(mp_int z) {
  function mp_digit (line 1651) | static mp_digit* s_alloc(mp_size num) {
  function mp_digit (line 1661) | static mp_digit* s_realloc(mp_digit* old, mp_size osize, mp_size nsize) {
  function s_free (line 1676) | static void s_free(void* ptr) { free(ptr); }
  function s_pad (line 1678) | static bool s_pad(mp_int z, mp_size min) {
  function s_fake (line 1698) | static void s_fake(mp_int z, mp_small value, mp_digit vbuf[]) {
  function s_ufake (line 1704) | static void s_ufake(mp_int z, mp_usmall value, mp_digit vbuf[]) {
  function s_cdig (line 1713) | static int s_cdig(mp_digit* da, mp_digit* db, mp_size len) {
  function s_uvpack (line 1727) | static int s_uvpack(mp_usmall uv, mp_digit t[]) {
  function s_ucmp (line 1743) | static int s_ucmp(mp_int a, mp_int b) {
  function s_vcmp (line 1755) | static int s_vcmp(mp_int a, mp_small v) {
  function s_uvcmp (line 1760) | static int s_uvcmp(mp_int a, mp_usmall uv) {
  function mp_digit (line 1768) | static mp_digit s_uadd(mp_digit* da, mp_digit* db, mp_digit* dc, mp_size...
  function s_usub (line 1798) | static void s_usub(mp_digit* da, mp_digit* db, mp_digit* dc, mp_size siz...
  function s_kmul (line 1830) | static int s_kmul(mp_digit* da, mp_digit* db, mp_digit* dc, mp_size size_a,
  function s_umul (line 1909) | static void s_umul(mp_digit* da, mp_digit* db, mp_digit* dc, mp_size siz...
  function s_ksqr (line 1932) | static int s_ksqr(mp_digit* da, mp_digit* dc, mp_size size_a) {
  function s_usqr (line 1982) | static void s_usqr(mp_digit* da, mp_digit* dc, mp_size size_a) {
  function s_dadd (line 2032) | static void s_dadd(mp_int a, mp_digit b) {
  function s_dmul (line 2054) | static void s_dmul(mp_int a, mp_digit b) {
  function s_dbmul (line 2072) | static void s_dbmul(mp_digit* da, mp_digit b, mp_digit* dc, mp_size size...
  function mp_digit (line 2086) | static mp_digit s_ddiv(mp_int a, mp_digit b) {
  function s_qdiv (line 2108) | static void s_qdiv(mp_int z, mp_size p2) {
  function s_qmod (line 2151) | static void s_qmod(mp_int z, mp_size p2) {
  function s_qmul (line 2163) | static int s_qmul(mp_int z, mp_size p2) {
  function s_qsub (line 2223) | static int s_qsub(mp_int z, mp_size p2) {
  function s_dp2k (line 2248) | static int s_dp2k(mp_int z) {
  function s_isp2 (line 2268) | static int s_isp2(mp_int z) {
  function s_2expt (line 2288) | static int s_2expt(mp_int z, mp_small k) {
  function s_norm (line 2305) | static int s_norm(mp_int a, mp_int b) {
  function mp_result (line 2323) | static mp_result s_brmu(mp_int z, mp_int m) {
  function s_reduce (line 2332) | static int s_reduce(mp_int x, mp_int m, mp_int mu, mp_int q1, mp_int q2) {
  function mp_result (line 2375) | static mp_result s_embar(mp_int a, mp_int b, mp_int m, mp_int mu, mp_int...
  function mp_result (line 2461) | static mp_result s_udiv_knuth(mp_int u, mp_int v) {
  function s_outlen (line 2634) | static int s_outlen(mp_int z, mp_size r) {
  function mp_size (line 2643) | static mp_size s_inlen(int len, mp_size r) {
  function s_ch2val (line 2650) | static int s_ch2val(char c, int r) {
  function s_val2ch (line 2669) | static char s_val2ch(int v, int caps) {
  function s_2comp (line 2685) | static void s_2comp(unsigned char* buf, int len) {
  function mp_result (line 2701) | static mp_result s_tobin(mp_int z, unsigned char* buf, int* limpos, int ...

FILE: imath.h
  type mp_sign (line 38) | typedef unsigned char  mp_sign;
  type mp_size (line 39) | typedef unsigned int   mp_size;
  type mp_result (line 40) | typedef int            mp_result;
  type mp_small (line 41) | typedef long           mp_small;
  type mp_usmall (line 42) | typedef unsigned long  mp_usmall;
  type mp_digit (line 47) | typedef uint16_t        mp_digit;
  type mp_word (line 48) | typedef uint32_t        mp_word;
  type mp_digit (line 52) | typedef uint32_t        mp_digit;
  type mp_word (line 53) | typedef uint64_t        mp_word;
  type mpz_t (line 58) | typedef struct {
  function mp_digit (line 66) | static inline mp_digit* MP_DIGITS(mp_int Z) { return Z->digits; }
  function mp_size (line 67) | static inline mp_size   MP_ALLOC(mp_int Z)  { return Z->alloc; }
  function mp_size (line 68) | static inline mp_size   MP_USED(mp_int Z)   { return Z->used; }
  function mp_sign (line 69) | static inline mp_sign   MP_SIGN(mp_int Z)   { return Z->sign; }
  function mp_int_is_odd (line 108) | static inline bool mp_int_is_odd(mp_int z) { return (z->digits[0] & 1) !...
  function mp_int_is_even (line 111) | static inline bool mp_int_is_even(mp_int z) { return (z->digits[0] & 1) ...
  function mp_result (line 227) | static inline
  function mp_result (line 311) | static inline

FILE: imdrover.c
  function mp_result (line 104) | static mp_result read_int_value(mp_int z, char* str) {
  function mp_result (line 135) | static mp_result read_rat_value(mp_rat q, char* str) {
  function read_long (line 169) | static bool read_long(long* z, char* str) {
  function parse_int_values (line 202) | static bool parse_int_values(testspec_t* t, mp_int* in, mp_int* out,
  function parse_rat_values (line 279) | static bool parse_rat_values(testspec_t* t, mp_rat* in, mp_rat* out,
  function parse_result_code (line 357) | static bool parse_result_code(char* str, mp_result* code) {
  function parse_binary (line 396) | static int parse_binary(char* str, unsigned char* buf, int limit) {
  function done_testing (line 414) | static void done_testing(void) {
  function init_testing (line 427) | void init_testing(void) {
  function reset_registers (line 443) | void reset_registers(void) {
  function test_init (line 450) | bool test_init(testspec_t* t, FILE* ofp) {
  function test_set (line 474) | bool test_set(testspec_t* t, FILE* ofp) {
  function test_neg (line 498) | bool test_neg(testspec_t* t, FILE* ofp) {
  function test_abs (line 513) | bool test_abs(testspec_t* t, FILE* ofp) {
  function test_add (line 528) | bool test_add(testspec_t* t, FILE* ofp) {
  function test_sub (line 550) | bool test_sub(testspec_t* t, FILE* ofp) {
  function test_mul (line 571) | bool test_mul(testspec_t* t, FILE* ofp) {
  function test_mulp2 (line 585) | bool test_mulp2(testspec_t* t, FILE* ofp) {
  function test_mulv (line 601) | bool test_mulv(testspec_t* t, FILE* ofp) {
  function test_sqr (line 617) | bool test_sqr(testspec_t* t, FILE* ofp) {
  function test_div (line 631) | bool test_div(testspec_t* t, FILE* ofp) {
  function test_divp2 (line 652) | bool test_divp2(testspec_t* t, FILE* ofp) {
  function test_divv (line 675) | bool test_divv(testspec_t* t, FILE* ofp) {
  function test_expt (line 698) | bool test_expt(testspec_t* t, FILE* ofp) {
  function test_exptv (line 714) | bool test_exptv(testspec_t* t, FILE* ofp) {
  function test_exptf (line 731) | bool test_exptf(testspec_t* t, FILE* ofp) {
  function test_mod (line 745) | bool test_mod(testspec_t* t, FILE* ofp) {
  function test_gcd (line 759) | bool test_gcd(testspec_t* t, FILE* ofp) {
  function test_egcd (line 773) | bool test_egcd(testspec_t* t, FILE* ofp) {
  function test_lcm (line 809) | bool test_lcm(testspec_t* t, FILE* ofp) {
  function test_sqrt (line 823) | bool test_sqrt(testspec_t* t, FILE* ofp) {
  function test_root (line 837) | bool test_root(testspec_t* t, FILE* ofp) {
  function test_invmod (line 853) | bool test_invmod(testspec_t* t, FILE* ofp) {
  function test_exptmod (line 867) | bool test_exptmod(testspec_t* t, FILE* ofp) {
  function test_exptmod_ev (line 881) | bool test_exptmod_ev(testspec_t* t, FILE* ofp) {
  function test_exptmod_bv (line 897) | bool test_exptmod_bv(testspec_t* t, FILE* ofp) {
  function test_comp (line 913) | bool test_comp(testspec_t* t, FILE* ofp) {
  function test_ucomp (line 927) | bool test_ucomp(testspec_t* t, FILE* ofp) {
  function test_zcomp (line 941) | bool test_zcomp(testspec_t* t, FILE* ofp) {
  function test_vcomp (line 955) | bool test_vcomp(testspec_t* t, FILE* ofp) {
  function test_uvcomp (line 971) | bool test_uvcomp(testspec_t* t, FILE* ofp) {
  function test_tostr (line 987) | bool test_tostr(testspec_t* t, FILE* ofp) {
  function test_tobin (line 1007) | bool test_tobin(testspec_t* t, FILE* ofp) {
  function test_to_int (line 1037) | bool test_to_int(testspec_t* t, FILE* ofp) {
  function test_to_uint (line 1052) | bool test_to_uint(testspec_t* t, FILE* ofp) {
  function test_read_binary (line 1067) | bool test_read_binary(testspec_t* t, FILE* ofp) {
  function test_to_uns (line 1087) | bool test_to_uns(testspec_t* t, FILE* ofp) {
  function test_read_uns (line 1117) | bool test_read_uns(testspec_t* t, FILE* ofp) {
  function test_meta (line 1137) | bool test_meta(testspec_t* t, FILE* ofp) {
  function test_qset (line 1182) | bool test_qset(testspec_t* t, FILE* ofp) {
  function test_qneg (line 1201) | bool test_qneg(testspec_t* t, FILE* ofp) {
  function test_qrecip (line 1215) | bool test_qrecip(testspec_t* t, FILE* ofp) {
  function test_qabs (line 1229) | bool test_qabs(testspec_t* t, FILE* ofp) {
  function test_qadd (line 1243) | bool test_qadd(testspec_t* t, FILE* ofp) {
  function test_qsub (line 1257) | bool test_qsub(testspec_t* t, FILE* ofp) {
  function test_qmul (line 1271) | bool test_qmul(testspec_t* t, FILE* ofp) {
  function test_qdiv (line 1285) | bool test_qdiv(testspec_t* t, FILE* ofp) {
  function test_qaddz (line 1299) | bool test_qaddz(testspec_t* t, FILE* ofp) {
  function test_qsubz (line 1321) | bool test_qsubz(testspec_t* t, FILE* ofp) {
  function test_qmulz (line 1343) | bool test_qmulz(testspec_t* t, FILE* ofp) {
  function test_qdivz (line 1365) | bool test_qdivz(testspec_t* t, FILE* ofp) {
  function test_qexpt (line 1387) | bool test_qexpt(testspec_t* t, FILE* ofp) {
  function test_qtostr (line 1411) | bool test_qtostr(testspec_t* t, FILE* ofp) {
  function test_qtodec (line 1435) | bool test_qtodec(testspec_t* t, FILE* ofp) {
  function test_qrdec (line 1471) | bool test_qrdec(testspec_t* t, FILE* ofp) {
  function test_qdecompose (line 1488) | bool test_qdecompose(testspec_t* t, FILE* ofp) {
  function test_is_prime (line 1527) | bool test_is_prime(testspec_t* t, FILE* OFP) {

FILE: imdrover.h
  type testspec_t (line 33) | typedef struct {

FILE: imrat.c
  function mp_result (line 49) | mp_result mp_rat_init(mp_rat r) {
  function mp_rat (line 61) | mp_rat mp_rat_alloc(void) {
  function mp_result (line 74) | mp_result mp_rat_reduce(mp_rat r) { return s_rat_reduce(r); }
  function mp_result (line 76) | mp_result mp_rat_init_size(mp_rat r, mp_size n_prec, mp_size d_prec) {
  function mp_result (line 90) | mp_result mp_rat_init_copy(mp_rat r, mp_rat old) {
  function mp_result (line 102) | mp_result mp_rat_set(mp_rat r, mp_int numer, mp_int denom) {
  function mp_result (line 124) | mp_result mp_rat_set_value(mp_rat r, mp_small numer, mp_small denom) {
  function mp_result (line 139) | mp_result mp_rat_set_uvalue(mp_rat r, mp_usmall numer, mp_usmall denom) {
  function mp_rat_clear (line 154) | void mp_rat_clear(mp_rat r) {
  function mp_rat_free (line 159) | void mp_rat_free(mp_rat r) {
  function mp_result (line 167) | mp_result mp_rat_numer(mp_rat r, mp_int z) {
  function mp_int (line 171) | mp_int mp_rat_numer_ref(mp_rat r) { return MP_NUMER_P(r); }
  function mp_result (line 173) | mp_result mp_rat_denom(mp_rat r, mp_int z) {
  function mp_int (line 177) | mp_int mp_rat_denom_ref(mp_rat r) { return MP_DENOM_P(r); }
  function mp_sign (line 179) | mp_sign mp_rat_sign(mp_rat r) { return MP_NUMER_SIGN(r); }
  function mp_result (line 181) | mp_result mp_rat_copy(mp_rat a, mp_rat c) {
  function mp_rat_zero (line 192) | void mp_rat_zero(mp_rat r) {
  function mp_result (line 197) | mp_result mp_rat_abs(mp_rat a, mp_rat c) {
  function mp_result (line 208) | mp_result mp_rat_neg(mp_rat a, mp_rat c) {
  function mp_result (line 219) | mp_result mp_rat_recip(mp_rat a, mp_rat c) {
  function mp_result (line 239) | mp_result mp_rat_add(mp_rat a, mp_rat b, mp_rat c) {
  function mp_result (line 243) | mp_result mp_rat_sub(mp_rat a, mp_rat b, mp_rat c) {
  function mp_result (line 247) | mp_result mp_rat_mul(mp_rat a, mp_rat b, mp_rat c) {
  function mp_result (line 263) | mp_result mp_rat_div(mp_rat a, mp_rat b, mp_rat c) {
  function mp_result (line 300) | mp_result mp_rat_add_int(mp_rat a, mp_int b, mp_rat c) {
  function mp_result (line 324) | mp_result mp_rat_sub_int(mp_rat a, mp_int b, mp_rat c) {
  function mp_result (line 348) | mp_result mp_rat_mul_int(mp_rat a, mp_int b, mp_rat c) {
  function mp_result (line 361) | mp_result mp_rat_div_int(mp_rat a, mp_int b, mp_rat c) {
  function mp_result (line 377) | mp_result mp_rat_expt(mp_rat a, mp_small b, mp_rat c) {
  function mp_result (line 396) | mp_result mp_rat_decompose(mp_rat r, mp_int ipart, mp_rat fpart) {
  function mp_rat_compare (line 446) | int mp_rat_compare(mp_rat a, mp_rat b) {
  function mp_rat_compare_unsigned (line 468) | int mp_rat_compare_unsigned(mp_rat a, mp_rat b) {
  function mp_rat_compare_zero (line 493) | int mp_rat_compare_zero(mp_rat r) { return mp_int_compare_zero(MP_NUMER_...
  function mp_rat_compare_value (line 495) | int mp_rat_compare_value(mp_rat r, mp_small n, mp_small d) {
  function mp_rat_is_integer (line 514) | bool mp_rat_is_integer(mp_rat r) {
  function mp_result (line 518) | mp_result mp_rat_to_ints(mp_rat r, mp_small* num, mp_small* den) {
  function mp_result (line 529) | mp_result mp_rat_to_string(mp_rat r, mp_size radix, char* str, int limit) {
  function mp_result (line 555) | mp_result mp_rat_to_decimal(mp_rat r, mp_size radix, mp_size prec,
  function mp_size (line 683) | mp_size mp_rat_string_len(mp_rat r, mp_size radix) {
  function mp_size (line 699) | mp_size mp_rat_decimal_len(mp_rat r, mp_size radix, mp_size prec) {
  function mp_result (line 712) | mp_result mp_rat_read_string(mp_rat r, mp_size radix, const char* str) {
  function mp_result (line 716) | mp_result mp_rat_read_cstring(mp_rat r, mp_size radix, const char* str,
  function mp_result (line 759) | mp_result mp_rat_read_ustring(mp_rat r, mp_size radix, const char* str,
  function mp_result (line 774) | mp_result mp_rat_read_decimal(mp_rat r, mp_size radix, const char* str) {
  function mp_result (line 778) | mp_result mp_rat_read_cdecimal(mp_rat r, mp_size radix, const char* str,
  function mp_result (line 911) | static mp_result s_rat_reduce(mp_rat r) {
  function mp_result (line 951) | static mp_result s_rat_combine(mp_rat a, mp_rat b, mp_rat c,

FILE: imrat.h
  type mpq_t (line 38) | typedef struct {
  function mp_int (line 44) | static inline mp_int MP_NUMER_P(mp_rat Q) { return &(Q->num); }
  function mp_int (line 47) | static inline mp_int MP_DENOM_P(mp_rat Q) { return &(Q->den); }
  type mp_round_mode (line 50) | typedef enum {

FILE: imtest.c
  type test_t (line 87) | typedef struct {
  function main (line 181) | int main(int argc, char* argv[]) {
  function process_file (line 211) | bool process_file(char* file_name, FILE* ifp, FILE* ofp) {
  function read_line (line 242) | int read_line(FILE* ifp, char* line, int limit) {
  function trim_line (line 262) | void trim_line(char* line) {
  function is_blank (line 279) | int is_blank(char* line) {
  function parse_line (line 285) | int parse_line(char* line, testspec_t* t) {
  function count_fields (line 316) | int count_fields(char* line, int delim) {
  function parse_fields (line 328) | void parse_fields(char* line, int delim, char** start) {
  function run_test (line 344) | int run_test(int test_num, testspec_t* t, FILE* ofp) {
  function find_test (line 391) | int find_test(char* code, test_t* info) {
  function free_test (line 405) | void free_test(testspec_t* t) {

FILE: imtimer.c
  function main (line 47) | int main(int argc, char* argv[]) {
  function clocks_to_seconds (line 129) | double clocks_to_seconds(clock_t start, clock_t end) {
  function mp_int (line 133) | mp_int alloc_values(int nt, int prec) {
  function randomize_values (line 149) | void randomize_values(mp_int values, int nt, int prec) {
  function release_values (line 155) | void release_values(mp_int values, int nt) {
  function get_multiply_time (line 163) | double get_multiply_time(int nt, int prec) {
  function get_exptmod_time (line 180) | double get_exptmod_time(int nt, int prec) {
  function mp_int_random (line 198) | void mp_int_random(mp_int z, int prec) {

FILE: iprime.c
  function mp_result (line 46) | mp_result mp_int_is_prime(mp_int z) {
  function mp_result (line 84) | mp_result mp_int_find_prime(mp_int z) {

FILE: rsamath.c
  function mp_result (line 36) | mp_result rsa_i2osp(mp_int z, unsigned char* out, int len) {
  function mp_result (line 50) | mp_result rsa_os2ip(mp_int z, unsigned char* in, int len) {
  function mp_result (line 55) | mp_result rsa_rsaep(mp_int msg, mp_int exp, mp_int mod, mp_int cipher) {
  function mp_result (line 60) | mp_result rsa_rsadp(mp_int cipher, mp_int exp, mp_int mod, mp_int msg) {
  function mp_result (line 65) | mp_result rsa_rsasp(mp_int msg, mp_int exp, mp_int mod, mp_int signature) {
  function mp_result (line 70) | mp_result rsa_rsavp(mp_int signature, mp_int exp, mp_int mod, mp_int msg) {
  function rsa_max_message_len (line 76) | int rsa_max_message_len(mp_int mod) {
  function mp_result (line 87) | mp_result rsa_pkcs1v15_encode(unsigned char* buf, int msg_len, int buf_len,
  function mp_result (line 114) | mp_result rsa_pkcs1v15_decode(unsigned char* buf, int buf_len, int tag,
  function mp_result (line 139) | static mp_result s_rsa_transform(mp_int msg, mp_int exp, mp_int mod,

FILE: tests/bintest.c
  function main (line 33) | int main(int argc, char* argv[]) {

FILE: tests/bug-qread.c
  type test (line 5) | struct test {
  function main (line 11) | int main(int arch, char* argv[]) {

FILE: tests/bug-swap.c
  function main (line 6) | int main(int argc, char* argv[]) {

FILE: tests/gmp-compat-test/genctest.py
  class APITest (line 8) | class APITest(object):
    method __init__ (line 10) | def __init__(self, gmpapi):
    method test_prefix (line 13) | def test_prefix(self):
    method test_param_name (line 16) | def test_param_name(self, ty, i):
    method test_param_type (line 33) | def test_param_type(self, ty):
    method test_var_name (line 40) | def test_var_name(self, ty, i):
    method test_var_type (line 59) | def test_var_type(self, ty):
    method init_var_from_param (line 67) | def init_var_from_param(self, ty, var, param):
    method init_vars_from_params (line 80) | def init_vars_from_params(self):
    method make_api_call (line 91) | def make_api_call(self):
    method normalize_cmp (line 108) | def normalize_cmp(self, ty):
    method extract_result (line 119) | def extract_result(self, ty, pos):
    method extract_results (line 148) | def extract_results(self):
    method clear_local_vars (line 173) | def clear_local_vars(self):
    method print_test_code (line 182) | def print_test_code(self, outf):
  class GMPTest (line 200) | class GMPTest(APITest):
    method __init__ (line 202) | def __init__(self, gmpapi):
    method api_call_prefix (line 205) | def api_call_prefix(self, kind):
    method mpz_type (line 213) | def mpz_type(self):
    method mpq_type (line 216) | def mpq_type(self):
  class ImathTest (line 220) | class ImathTest(APITest):
    method __init__ (line 222) | def __init__(self, gmpapi):
    method api_call_prefix (line 225) | def api_call_prefix(self, kind):
    method mpz_type (line 233) | def mpz_type(self):
    method mpq_type (line 236) | def mpq_type(self):
  function print_gmp_header (line 240) | def print_gmp_header(outf):
  function print_imath_header (line 249) | def print_imath_header(outf):
  function print_gmp_tests (line 260) | def print_gmp_tests(outf):
  function print_imath_tests (line 267) | def print_imath_tests(outf):
  function main (line 274) | def main():

FILE: tests/gmp-compat-test/gendata.py
  function plus1 (line 17) | def plus1(x):
  function minus1 (line 21) | def minus1(x):
  function apply (line 25) | def apply(fun, lst):
  function gen_random_mpz (line 52) | def gen_random_mpz(mindigits=1, maxdigits=100, allowneg=True):
  function gen_random_si (line 59) | def gen_random_si():
  function gen_random_ui (line 66) | def gen_random_ui():
  function gen_digits (line 73) | def gen_digits(length):
  function gen_mpzs (line 84) | def gen_mpzs(mindigits=1, maxdigits=100, count=10):
  function gen_sis (line 94) | def gen_sis(count=default_count):
  function gen_uis (line 98) | def gen_uis(count=default_count):
  function gen_small_mpzs (line 102) | def gen_small_mpzs(count=default_count):
  function is_small_mpz (line 106) | def is_small_mpz(s):
  function gen_medium_mpzs (line 110) | def gen_medium_mpzs(count=default_count):
  function is_medium_mpz (line 114) | def is_medium_mpz(s):
  function gen_large_mpzs (line 118) | def gen_large_mpzs(count=default_count):
  function is_large_mpz (line 122) | def is_large_mpz(s):
  function gen_mpz_spread (line 126) | def gen_mpz_spread(count=default_count):
  function gen_mpz_args (line 131) | def gen_mpz_args(count=default_count):
  function gen_mpq_args (line 135) | def gen_mpq_args(count=4):
  function gen_si_args (line 141) | def gen_si_args():
  function gen_ui_args (line 145) | def gen_ui_args():
  function gen_list_for_type (line 149) | def gen_list_for_type(t, is_write_only):
  function gen_args (line 164) | def gen_args(api):
  function mul_mpzs (line 194) | def mul_mpzs(a, b):
  function mpz_divexact_data (line 198) | def mpz_divexact_data(args):
  function mpz_divisible_p_data (line 204) | def mpz_divisible_p_data(args):
  function mpz_div3_data (line 209) | def mpz_div3_data(args):
  function mpz_pow_data (line 215) | def mpz_pow_data(args, alwaysallowbase1=True):
  function mpz_mul_2exp_data (line 233) | def mpz_mul_2exp_data(args):
  function mpz_gcd_data (line 237) | def mpz_gcd_data(args):
  function mpz_export_data (line 254) | def mpz_export_data(api):
  function mpz_sizeinbase_data (line 276) | def mpz_sizeinbase_data(api):
  function get_str_data (line 283) | def get_str_data(ty):
  function mpz_get_str_data (line 295) | def mpz_get_str_data(api):
  function mpq_get_str_data (line 299) | def mpq_get_str_data(api):
  function mpq_set_str_data (line 303) | def mpq_set_str_data(api):
  function get_div_data (line 323) | def get_div_data(n, d, rate=0.2):
  function allow (line 330) | def allow(name, args):
  function fixup_args (line 340) | def fixup_args(name, args):

FILE: tests/gmp-compat-test/genpytest.py
  function print_header (line 8) | def print_header(outf):
  function print_cmp (line 21) | def print_cmp(outf):
  function print_api (line 108) | def print_api(name, outf):
  function print_api_map (line 120) | def print_api_map(outf):

FILE: tests/gmp-compat-test/gmp_custom_test.c
  function test_mpz_export (line 2) | void test_mpz_export(char** out, char* rop, size_t* countp, int order,
  function test_mpz_import (line 12) | void test_mpz_import(char* out, void* unused, size_t count, int order,

FILE: tests/gmp-compat-test/gmpapi.py
  class CType (line 4) | class CType:
    method __init__ (line 6) | def __init__(self, name):
    method __str__ (line 9) | def __str__(self):
  class GMPAPI (line 13) | class GMPAPI:
    method __init__ (line 15) | def __init__(self, ret_ty, name, *params, **kw):
    method is_write_only (line 32) | def is_write_only(self, pos):
    method __str__ (line 37) | def __str__(self):
    method __repr__ (line 41) | def __repr__(self):
  function get_api (line 125) | def get_api(name):

FILE: tests/gmp-compat-test/imath_custom_test.c
  function test_mpz_export (line 2) | void test_mpz_export(char** out, char* rop, size_t* countp, int order,
  function test_mpz_import (line 12) | void test_mpz_import(char* out, void* unused, size_t count, int order,

FILE: tests/gmp-compat-test/runtest.py
  function print_failure (line 13) | def print_failure(line, test):
  function run_tests (line 17) | def run_tests(test_file, options):
  function parse_args (line 74) | def parse_args():

FILE: tests/rtest.c
  function main (line 38) | int main(int argc, char* argv[]) {
  function random_fill (line 96) | void random_fill(unsigned char* buf, int len) {
  function print_buf (line 108) | void print_buf(unsigned char* buf, int len, int brk, FILE* ofp) {

FILE: tools/findthreshold.py
  function get_timing_stats (line 29) | def get_timing_stats(num_tests, precision, threshold, seed=None):
  function check_binary (line 54) | def check_binary(name):
  function compute_stats (line 63) | def compute_stats():

FILE: tools/mkdoc.py
  function last_word (line 39) | def last_word(s):
  function typeset (line 44) | def typeset(text):
  class LIndex (line 63) | class LIndex(object):
    method __init__ (line 66) | def __init__(self, text):
    method linecol (line 86) | def linecol(self, pos):
  class Decl (line 111) | class Decl(object):
    method __init__ (line 114) | def __init__(self, com, decl, line=None):
    method __repr__ (line 131) | def __repr__(self):
    method markdown (line 134) | def markdown(self, path):
  function parse_decls (line 151) | def parse_decls(text):
  function load_file (line 162) | def load_file(path):
  function main (line 170) | def main(args):