_Z7to_charPKh:
   11|    586|char *to_char(const uint8_t *x) {
   12|    586|  return reinterpret_cast<char *>(const_cast<unsigned char *>(x));
   13|    586|}
_Z11check_equalP9bignum_stP6mp_intm:
   22|    586|void check_equal(BIGNUM *b, mp_int *m, size_t max_size) {
   23|    586|  char *bnBc = BN_bn2hex(b);
   24|    586|  char mpiMc[max_size];
   25|    586|  mp_tohex(m, mpiMc);
  ------------------
  |  |  294|    586|#define mp_tohex(M, S) mp_toradix((M), (S), 16)
  ------------------
   26|    586|  std::string bnA(bnBc);
   27|    586|  std::string mpiA(mpiMc);
   28|    586|  OPENSSL_free(bnBc);
   29|       |  // We have to strip leading zeros from bignums, ignoring the sign.
   30|    586|  if (bnA.at(0) != '-') {
  ------------------
  |  Branch (30:7): [True: 586, False: 0]
  ------------------
   31|    586|    bnA.erase(0, std::min(bnA.find_first_not_of('0'), bnA.size() - 1));
   32|    586|  } else if (bnA.at(1) == '0') {
  ------------------
  |  Branch (32:14): [True: 0, False: 0]
  ------------------
   33|      0|    bnA.erase(1, std::min(bnA.find_first_not_of('0', 1) - 1, bnA.size() - 1));
   34|      0|  }
   35|       |
   36|    586|  if (mpiA != bnA) {
  ------------------
  |  Branch (36:7): [True: 0, False: 586]
  ------------------
   37|      0|    std::cout << "openssl: " << std::hex << bnA << std::endl;
   38|      0|    std::cout << "nss:     " << std::hex << mpiA << std::endl;
   39|      0|  }
   40|       |
   41|    586|  assert(mpiA == bnA);
   42|    586|}
_Z11parse_inputPKhmP9bignum_stP6mp_int:
   65|    586|void parse_input(const uint8_t *data, size_t size, BIGNUM *A, mp_int *a) {
   66|    586|  assert(mp_read_raw(a, to_char(data), size) == MP_OKAY);
   67|       |
   68|       |  // Force a positive sign.
   69|       |  // TODO: add tests for negatives.
   70|    586|  MP_SIGN(a) = MP_ZPOS;
  ------------------
  |  |  144|    586|#define MP_SIGN(MP) ((MP)->sign)
  ------------------
                MP_SIGN(a) = MP_ZPOS;
  ------------------
  |  |   37|    586|#define MP_ZPOS 0
  ------------------
   71|       |
   72|       |  // Skip the first byte as it's interpreted as sign by NSS.
   73|    586|  assert(BN_bin2bn(data + 1, size - 1, A) != nullptr);
   74|       |
   75|    586|  check_equal(A, a, 4 * size + 1);
   76|    586|}

LLVMFuzzerTestOneInput:
   12|    588|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   13|       |  // We require at least size 3 to get two integers from Data.
   14|    588|  if (size < 3) {
  ------------------
  |  Branch (14:7): [True: 2, False: 586]
  ------------------
   15|      2|    return 0;
   16|      2|  }
   17|       |
   18|  2.34k|  INIT_THREE_NUMBERS
  ------------------
  |  |   52|    586|  mp_int a, b, c;                 \
  |  |   53|    586|  BN_CTX *ctx = BN_CTX_new();     \
  |  |   54|    586|  BN_CTX_start(ctx);              \
  |  |   55|    586|  BIGNUM *A = BN_CTX_get(ctx);    \
  |  |   56|    586|  BIGNUM *B = BN_CTX_get(ctx);    \
  |  |   57|    586|  BIGNUM *C = BN_CTX_get(ctx);    \
  |  |   58|    586|  assert(mp_init(&a) == MP_OKAY); \
  |  |   59|    586|  assert(mp_init(&b) == MP_OKAY); \
  |  |   60|    586|  assert(mp_init(&c) == MP_OKAY); \
  |  |   61|    586|  size_t max_size = 4 * size + 1; \
  |  |   62|    586|  parse_input(data, size, A, &a); \
  |  |   63|    586|  do {                            \
  |  |   64|    586|    (void)(B);                    \
  |  |   65|    586|  } while (0);
  |  |  ------------------
  |  |  |  Branch (65:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
   19|       |
   20|       |  // We can't divide by 0.
   21|  2.34k|  if (mp_cmp_z(&b) == 0) {
  ------------------
  |  Branch (21:7): [True: 586, False: 0]
  ------------------
   22|    586|    mp_clear(&a);
   23|    586|    mp_clear(&b);
   24|    586|    mp_clear(&c);
   25|    586|    BN_CTX_end(ctx);
   26|    586|    BN_CTX_free(ctx);
   27|    586|    return 0;
   28|    586|  }
   29|       |
   30|       |  // Compare with OpenSSL square mod
   31|      0|  assert(mp_sqrmod(&a, &b, &c) == MP_OKAY);
   32|      0|  (void)BN_mod_sqr(C, A, B, ctx);
   33|      0|  check_equal(C, &c, max_size);
   34|       |
   35|      0|  CLEANUP_AND_RETURN_THREE
  ------------------
  |  |   80|      0|  mp_clear(&a);                  \
  |  |   81|      0|  mp_clear(&b);                  \
  |  |   82|      0|  mp_clear(&c);                  \
  |  |   83|      0|  BN_CTX_end(ctx);               \
  |  |   84|      0|  BN_CTX_free(ctx);              \
  |  |   85|      0|  return 0;
  ------------------
   36|      0|}

mp_init:
  121|  1.75k|{
  122|  1.75k|    return mp_init_size(mp, s_mp_defprec);
  123|       |
  124|  1.75k|} /* end mp_init() */
mp_init_size:
  140|  1.75k|{
  141|  1.75k|    ARGCHK(mp != NULL && prec > 0, MP_BADARG);
  ------------------
  |  |  350|  1.75k|#define ARGCHK(X, Y) assert(X)
  ------------------
  142|       |
  143|  1.75k|    prec = MP_ROUNDUP(prec, s_mp_defprec);
  ------------------
  |  |   89|  1.75k|#define MP_ROUNDUP(a, b) (MP_HOWMANY(a, b) * (b))
  |  |  ------------------
  |  |  |  |   88|  1.75k|#define MP_HOWMANY(a, b) (((a) + (b)-1) / (b))
  |  |  ------------------
  ------------------
  144|  1.75k|    if ((DIGITS(mp) = s_mp_alloc(prec, sizeof(mp_digit))) == NULL)
  ------------------
  |  |  330|  1.75k|#define DIGITS(MP) MP_DIGITS(MP)
  |  |  ------------------
  |  |  |  |  147|  1.75k|#define MP_DIGITS(MP) ((MP)->dp)
  |  |  ------------------
  ------------------
  |  Branch (144:9): [True: 0, False: 1.75k]
  ------------------
  145|      0|        return MP_MEM;
  ------------------
  |  |   42|      0|#define MP_MEM -2    /* out of memory         */
  ------------------
  146|       |
  147|  1.75k|    SIGN(mp) = ZPOS;
  ------------------
  |  |  327|  1.75k|#define SIGN(MP) MP_SIGN(MP)
  |  |  ------------------
  |  |  |  |  144|  1.75k|#define MP_SIGN(MP) ((MP)->sign)
  |  |  ------------------
  ------------------
                  SIGN(mp) = ZPOS;
  ------------------
  |  |  321|  1.75k|#define ZPOS MP_ZPOS
  |  |  ------------------
  |  |  |  |   37|  1.75k|#define MP_ZPOS 0
  |  |  ------------------
  ------------------
  148|  1.75k|    USED(mp) = 1;
  ------------------
  |  |  328|  1.75k|#define USED(MP) MP_USED(MP)
  |  |  ------------------
  |  |  |  |  145|  1.75k|#define MP_USED(MP) ((MP)->used)
  |  |  ------------------
  ------------------
  149|  1.75k|    ALLOC(mp) = prec;
  ------------------
  |  |  329|  1.75k|#define ALLOC(MP) MP_ALLOC(MP)
  |  |  ------------------
  |  |  |  |  146|  1.75k|#define MP_ALLOC(MP) ((MP)->alloc)
  |  |  ------------------
  ------------------
  150|       |
  151|  1.75k|    return MP_OKAY;
  ------------------
  |  |   39|  1.75k|#define MP_OKAY 0    /* no error, all is well */
  ------------------
  152|       |
  153|  1.75k|} /* end mp_init_size() */
mp_init_copy:
  169|  75.9k|{
  170|  75.9k|    ARGCHK(mp != NULL && from != NULL, MP_BADARG);
  ------------------
  |  |  350|  75.9k|#define ARGCHK(X, Y) assert(X)
  ------------------
  171|       |
  172|  75.9k|    if (mp == from)
  ------------------
  |  Branch (172:9): [True: 0, False: 75.9k]
  ------------------
  173|      0|        return MP_OKAY;
  ------------------
  |  |   39|      0|#define MP_OKAY 0    /* no error, all is well */
  ------------------
  174|       |
  175|  75.9k|    if ((DIGITS(mp) = s_mp_alloc(ALLOC(from), sizeof(mp_digit))) == NULL)
  ------------------
  |  |  330|  75.9k|#define DIGITS(MP) MP_DIGITS(MP)
  |  |  ------------------
  |  |  |  |  147|  75.9k|#define MP_DIGITS(MP) ((MP)->dp)
  |  |  ------------------
  ------------------
                  if ((DIGITS(mp) = s_mp_alloc(ALLOC(from), sizeof(mp_digit))) == NULL)
  ------------------
  |  |  329|  75.9k|#define ALLOC(MP) MP_ALLOC(MP)
  |  |  ------------------
  |  |  |  |  146|  75.9k|#define MP_ALLOC(MP) ((MP)->alloc)
  |  |  ------------------
  ------------------
  |  Branch (175:9): [True: 0, False: 75.9k]
  ------------------
  176|      0|        return MP_MEM;
  ------------------
  |  |   42|      0|#define MP_MEM -2    /* out of memory         */
  ------------------
  177|       |
  178|  75.9k|    s_mp_copy(DIGITS(from), DIGITS(mp), USED(from));
  ------------------
  |  |  330|  75.9k|#define DIGITS(MP) MP_DIGITS(MP)
  |  |  ------------------
  |  |  |  |  147|  75.9k|#define MP_DIGITS(MP) ((MP)->dp)
  |  |  ------------------
  ------------------
                  s_mp_copy(DIGITS(from), DIGITS(mp), USED(from));
  ------------------
  |  |  330|  75.9k|#define DIGITS(MP) MP_DIGITS(MP)
  |  |  ------------------
  |  |  |  |  147|  75.9k|#define MP_DIGITS(MP) ((MP)->dp)
  |  |  ------------------
  ------------------
                  s_mp_copy(DIGITS(from), DIGITS(mp), USED(from));
  ------------------
  |  |  328|  75.9k|#define USED(MP) MP_USED(MP)
  |  |  ------------------
  |  |  |  |  145|  75.9k|#define MP_USED(MP) ((MP)->used)
  |  |  ------------------
  ------------------
  179|  75.9k|    USED(mp) = USED(from);
  ------------------
  |  |  328|  75.9k|#define USED(MP) MP_USED(MP)
  |  |  ------------------
  |  |  |  |  145|  75.9k|#define MP_USED(MP) ((MP)->used)
  |  |  ------------------
  ------------------
                  USED(mp) = USED(from);
  ------------------
  |  |  328|  75.9k|#define USED(MP) MP_USED(MP)
  |  |  ------------------
  |  |  |  |  145|  75.9k|#define MP_USED(MP) ((MP)->used)
  |  |  ------------------
  ------------------
  180|  75.9k|    ALLOC(mp) = ALLOC(from);
  ------------------
  |  |  329|  75.9k|#define ALLOC(MP) MP_ALLOC(MP)
  |  |  ------------------
  |  |  |  |  146|  75.9k|#define MP_ALLOC(MP) ((MP)->alloc)
  |  |  ------------------
  ------------------
                  ALLOC(mp) = ALLOC(from);
  ------------------
  |  |  329|  75.9k|#define ALLOC(MP) MP_ALLOC(MP)
  |  |  ------------------
  |  |  |  |  146|  75.9k|#define MP_ALLOC(MP) ((MP)->alloc)
  |  |  ------------------
  ------------------
  181|  75.9k|    SIGN(mp) = SIGN(from);
  ------------------
  |  |  327|  75.9k|#define SIGN(MP) MP_SIGN(MP)
  |  |  ------------------
  |  |  |  |  144|  75.9k|#define MP_SIGN(MP) ((MP)->sign)
  |  |  ------------------
  ------------------
                  SIGN(mp) = SIGN(from);
  ------------------
  |  |  327|  75.9k|#define SIGN(MP) MP_SIGN(MP)
  |  |  ------------------
  |  |  |  |  144|  75.9k|#define MP_SIGN(MP) ((MP)->sign)
  |  |  ------------------
  ------------------
  182|       |
  183|  75.9k|    return MP_OKAY;
  ------------------
  |  |   39|  75.9k|#define MP_OKAY 0    /* no error, all is well */
  ------------------
  184|       |
  185|  75.9k|} /* end mp_init_copy() */
mp_copy:
  201|   224k|{
  202|   224k|    ARGCHK(from != NULL && to != NULL, MP_BADARG);
  ------------------
  |  |  350|   224k|#define ARGCHK(X, Y) assert(X)
  ------------------
  203|       |
  204|   224k|    if (from == to)
  ------------------
  |  Branch (204:9): [True: 224k, False: 0]
  ------------------
  205|   224k|        return MP_OKAY;
  ------------------
  |  |   39|   224k|#define MP_OKAY 0    /* no error, all is well */
  ------------------
  206|       |
  207|      0|    { /* copy */
  208|      0|        mp_digit *tmp;
  209|       |
  210|       |        /*
  211|       |          If the allocated buffer in 'to' already has enough space to hold
  212|       |          all the used digits of 'from', we'll re-use it to avoid hitting
  213|       |          the memory allocater more than necessary; otherwise, we'd have
  214|       |          to grow anyway, so we just allocate a hunk and make the copy as
  215|       |          usual
  216|       |         */
  217|      0|        if (ALLOC(to) >= USED(from)) {
  ------------------
  |  |  329|      0|#define ALLOC(MP) MP_ALLOC(MP)
  |  |  ------------------
  |  |  |  |  146|      0|#define MP_ALLOC(MP) ((MP)->alloc)
  |  |  ------------------
  ------------------
                      if (ALLOC(to) >= USED(from)) {
  ------------------
  |  |  328|      0|#define USED(MP) MP_USED(MP)
  |  |  ------------------
  |  |  |  |  145|      0|#define MP_USED(MP) ((MP)->used)
  |  |  ------------------
  ------------------
  |  Branch (217:13): [True: 0, False: 0]
  ------------------
  218|      0|            s_mp_setz(DIGITS(to) + USED(from), ALLOC(to) - USED(from));
  ------------------
  |  |  330|      0|#define DIGITS(MP) MP_DIGITS(MP)
  |  |  ------------------
  |  |  |  |  147|      0|#define MP_DIGITS(MP) ((MP)->dp)
  |  |  ------------------
  ------------------
                          s_mp_setz(DIGITS(to) + USED(from), ALLOC(to) - USED(from));
  ------------------
  |  |  328|      0|#define USED(MP) MP_USED(MP)
  |  |  ------------------
  |  |  |  |  145|      0|#define MP_USED(MP) ((MP)->used)
  |  |  ------------------
  ------------------
                          s_mp_setz(DIGITS(to) + USED(from), ALLOC(to) - USED(from));
  ------------------
  |  |  329|      0|#define ALLOC(MP) MP_ALLOC(MP)
  |  |  ------------------
  |  |  |  |  146|      0|#define MP_ALLOC(MP) ((MP)->alloc)
  |  |  ------------------
  ------------------
                          s_mp_setz(DIGITS(to) + USED(from), ALLOC(to) - USED(from));
  ------------------
  |  |  328|      0|#define USED(MP) MP_USED(MP)
  |  |  ------------------
  |  |  |  |  145|      0|#define MP_USED(MP) ((MP)->used)
  |  |  ------------------
  ------------------
  219|      0|            s_mp_copy(DIGITS(from), DIGITS(to), USED(from));
  ------------------
  |  |  330|      0|#define DIGITS(MP) MP_DIGITS(MP)
  |  |  ------------------
  |  |  |  |  147|      0|#define MP_DIGITS(MP) ((MP)->dp)
  |  |  ------------------
  ------------------
                          s_mp_copy(DIGITS(from), DIGITS(to), USED(from));
  ------------------
  |  |  330|      0|#define DIGITS(MP) MP_DIGITS(MP)
  |  |  ------------------
  |  |  |  |  147|      0|#define MP_DIGITS(MP) ((MP)->dp)
  |  |  ------------------
  ------------------
                          s_mp_copy(DIGITS(from), DIGITS(to), USED(from));
  ------------------
  |  |  328|      0|#define USED(MP) MP_USED(MP)
  |  |  ------------------
  |  |  |  |  145|      0|#define MP_USED(MP) ((MP)->used)
  |  |  ------------------
  ------------------
  220|       |
  221|      0|        } else {
  222|      0|            if ((tmp = s_mp_alloc(ALLOC(from), sizeof(mp_digit))) == NULL)
  ------------------
  |  |  329|      0|#define ALLOC(MP) MP_ALLOC(MP)
  |  |  ------------------
  |  |  |  |  146|      0|#define MP_ALLOC(MP) ((MP)->alloc)
  |  |  ------------------
  ------------------
  |  Branch (222:17): [True: 0, False: 0]
  ------------------
  223|      0|                return MP_MEM;
  ------------------
  |  |   42|      0|#define MP_MEM -2    /* out of memory         */
  ------------------
  224|       |
  225|      0|            s_mp_copy(DIGITS(from), tmp, USED(from));
  ------------------
  |  |  330|      0|#define DIGITS(MP) MP_DIGITS(MP)
  |  |  ------------------
  |  |  |  |  147|      0|#define MP_DIGITS(MP) ((MP)->dp)
  |  |  ------------------
  ------------------
                          s_mp_copy(DIGITS(from), tmp, USED(from));
  ------------------
  |  |  328|      0|#define USED(MP) MP_USED(MP)
  |  |  ------------------
  |  |  |  |  145|      0|#define MP_USED(MP) ((MP)->used)
  |  |  ------------------
  ------------------
  226|       |
  227|      0|            if (DIGITS(to) != NULL) {
  ------------------
  |  |  330|      0|#define DIGITS(MP) MP_DIGITS(MP)
  |  |  ------------------
  |  |  |  |  147|      0|#define MP_DIGITS(MP) ((MP)->dp)
  |  |  ------------------
  ------------------
  |  Branch (227:17): [True: 0, False: 0]
  ------------------
  228|      0|                s_mp_setz(DIGITS(to), ALLOC(to));
  ------------------
  |  |  330|      0|#define DIGITS(MP) MP_DIGITS(MP)
  |  |  ------------------
  |  |  |  |  147|      0|#define MP_DIGITS(MP) ((MP)->dp)
  |  |  ------------------
  ------------------
                              s_mp_setz(DIGITS(to), ALLOC(to));
  ------------------
  |  |  329|      0|#define ALLOC(MP) MP_ALLOC(MP)
  |  |  ------------------
  |  |  |  |  146|      0|#define MP_ALLOC(MP) ((MP)->alloc)
  |  |  ------------------
  ------------------
  229|      0|                s_mp_free(DIGITS(to));
  ------------------
  |  |  330|      0|#define DIGITS(MP) MP_DIGITS(MP)
  |  |  ------------------
  |  |  |  |  147|      0|#define MP_DIGITS(MP) ((MP)->dp)
  |  |  ------------------
  ------------------
  230|      0|            }
  231|       |
  232|      0|            DIGITS(to) = tmp;
  ------------------
  |  |  330|      0|#define DIGITS(MP) MP_DIGITS(MP)
  |  |  ------------------
  |  |  |  |  147|      0|#define MP_DIGITS(MP) ((MP)->dp)
  |  |  ------------------
  ------------------
  233|      0|            ALLOC(to) = ALLOC(from);
  ------------------
  |  |  329|      0|#define ALLOC(MP) MP_ALLOC(MP)
  |  |  ------------------
  |  |  |  |  146|      0|#define MP_ALLOC(MP) ((MP)->alloc)
  |  |  ------------------
  ------------------
                          ALLOC(to) = ALLOC(from);
  ------------------
  |  |  329|      0|#define ALLOC(MP) MP_ALLOC(MP)
  |  |  ------------------
  |  |  |  |  146|      0|#define MP_ALLOC(MP) ((MP)->alloc)
  |  |  ------------------
  ------------------
  234|      0|        }
  235|       |
  236|       |        /* Copy the precision and sign from the original */
  237|      0|        USED(to) = USED(from);
  ------------------
  |  |  328|      0|#define USED(MP) MP_USED(MP)
  |  |  ------------------
  |  |  |  |  145|      0|#define MP_USED(MP) ((MP)->used)
  |  |  ------------------
  ------------------
                      USED(to) = USED(from);
  ------------------
  |  |  328|      0|#define USED(MP) MP_USED(MP)
  |  |  ------------------
  |  |  |  |  145|      0|#define MP_USED(MP) ((MP)->used)
  |  |  ------------------
  ------------------
  238|      0|        SIGN(to) = SIGN(from);
  ------------------
  |  |  327|      0|#define SIGN(MP) MP_SIGN(MP)
  |  |  ------------------
  |  |  |  |  144|      0|#define MP_SIGN(MP) ((MP)->sign)
  |  |  ------------------
  ------------------
                      SIGN(to) = SIGN(from);
  ------------------
  |  |  327|      0|#define SIGN(MP) MP_SIGN(MP)
  |  |  ------------------
  |  |  |  |  144|      0|#define MP_SIGN(MP) ((MP)->sign)
  |  |  ------------------
  ------------------
  239|      0|    } /* end copy */
  240|       |
  241|      0|    return MP_OKAY;
  ------------------
  |  |   39|      0|#define MP_OKAY 0    /* no error, all is well */
  ------------------
  242|       |
  243|      0|} /* end mp_copy() */
mp_clear:
  285|  77.6k|{
  286|  77.6k|    if (mp == NULL)
  ------------------
  |  Branch (286:9): [True: 0, False: 77.6k]
  ------------------
  287|      0|        return;
  288|       |
  289|  77.6k|    if (DIGITS(mp) != NULL) {
  ------------------
  |  |  330|  77.6k|#define DIGITS(MP) MP_DIGITS(MP)
  |  |  ------------------
  |  |  |  |  147|  77.6k|#define MP_DIGITS(MP) ((MP)->dp)
  |  |  ------------------
  ------------------
  |  Branch (289:9): [True: 77.6k, False: 0]
  ------------------
  290|  77.6k|        s_mp_setz(DIGITS(mp), ALLOC(mp));
  ------------------
  |  |  330|  77.6k|#define DIGITS(MP) MP_DIGITS(MP)
  |  |  ------------------
  |  |  |  |  147|  77.6k|#define MP_DIGITS(MP) ((MP)->dp)
  |  |  ------------------
  ------------------
                      s_mp_setz(DIGITS(mp), ALLOC(mp));
  ------------------
  |  |  329|  77.6k|#define ALLOC(MP) MP_ALLOC(MP)
  |  |  ------------------
  |  |  |  |  146|  77.6k|#define MP_ALLOC(MP) ((MP)->alloc)
  |  |  ------------------
  ------------------
  291|  77.6k|        s_mp_free(DIGITS(mp));
  ------------------
  |  |  330|  77.6k|#define DIGITS(MP) MP_DIGITS(MP)
  |  |  ------------------
  |  |  |  |  147|  77.6k|#define MP_DIGITS(MP) ((MP)->dp)
  |  |  ------------------
  ------------------
  292|  77.6k|        DIGITS(mp) = NULL;
  ------------------
  |  |  330|  77.6k|#define DIGITS(MP) MP_DIGITS(MP)
  |  |  ------------------
  |  |  |  |  147|  77.6k|#define MP_DIGITS(MP) ((MP)->dp)
  |  |  ------------------
  ------------------
  293|  77.6k|    }
  294|       |
  295|  77.6k|    USED(mp) = 0;
  ------------------
  |  |  328|  77.6k|#define USED(MP) MP_USED(MP)
  |  |  ------------------
  |  |  |  |  145|  77.6k|#define MP_USED(MP) ((MP)->used)
  |  |  ------------------
  ------------------
  296|  77.6k|    ALLOC(mp) = 0;
  ------------------
  |  |  329|  77.6k|#define ALLOC(MP) MP_ALLOC(MP)
  |  |  ------------------
  |  |  |  |  146|  77.6k|#define MP_ALLOC(MP) ((MP)->alloc)
  |  |  ------------------
  ------------------
  297|       |
  298|  77.6k|} /* end mp_clear() */
mp_zero:
  312|    586|{
  313|    586|    if (mp == NULL)
  ------------------
  |  Branch (313:9): [True: 0, False: 586]
  ------------------
  314|      0|        return;
  315|       |
  316|    586|    s_mp_setz(DIGITS(mp), ALLOC(mp));
  ------------------
  |  |  330|    586|#define DIGITS(MP) MP_DIGITS(MP)
  |  |  ------------------
  |  |  |  |  147|    586|#define MP_DIGITS(MP) ((MP)->dp)
  |  |  ------------------
  ------------------
                  s_mp_setz(DIGITS(mp), ALLOC(mp));
  ------------------
  |  |  329|    586|#define ALLOC(MP) MP_ALLOC(MP)
  |  |  ------------------
  |  |  |  |  146|    586|#define MP_ALLOC(MP) ((MP)->alloc)
  |  |  ------------------
  ------------------
  317|    586|    USED(mp) = 1;
  ------------------
  |  |  328|    586|#define USED(MP) MP_USED(MP)
  |  |  ------------------
  |  |  |  |  145|    586|#define MP_USED(MP) ((MP)->used)
  |  |  ------------------
  ------------------
  318|    586|    SIGN(mp) = ZPOS;
  ------------------
  |  |  327|    586|#define SIGN(MP) MP_SIGN(MP)
  |  |  ------------------
  |  |  |  |  144|    586|#define MP_SIGN(MP) ((MP)->sign)
  |  |  ------------------
  ------------------
                  SIGN(mp) = ZPOS;
  ------------------
  |  |  321|    586|#define ZPOS MP_ZPOS
  |  |  ------------------
  |  |  |  |   37|    586|#define MP_ZPOS 0
  |  |  ------------------
  ------------------
  319|       |
  320|    586|} /* end mp_zero() */
mp_add_d:
  408|  75.3k|{
  409|  75.3k|    mp_int tmp;
  410|  75.3k|    mp_err res;
  411|       |
  412|  75.3k|    ARGCHK(a != NULL && b != NULL, MP_BADARG);
  ------------------
  |  |  350|  75.3k|#define ARGCHK(X, Y) assert(X)
  ------------------
  413|       |
  414|  75.3k|    if ((res = mp_init_copy(&tmp, a)) != MP_OKAY)
  ------------------
  |  |   39|  75.3k|#define MP_OKAY 0    /* no error, all is well */
  ------------------
  |  Branch (414:9): [True: 0, False: 75.3k]
  ------------------
  415|      0|        return res;
  416|       |
  417|  75.3k|    if (SIGN(&tmp) == ZPOS) {
  ------------------
  |  |  327|  75.3k|#define SIGN(MP) MP_SIGN(MP)
  |  |  ------------------
  |  |  |  |  144|  75.3k|#define MP_SIGN(MP) ((MP)->sign)
  |  |  ------------------
  ------------------
                  if (SIGN(&tmp) == ZPOS) {
  ------------------
  |  |  321|  75.3k|#define ZPOS MP_ZPOS
  |  |  ------------------
  |  |  |  |   37|  75.3k|#define MP_ZPOS 0
  |  |  ------------------
  ------------------
  |  Branch (417:9): [True: 75.3k, False: 0]
  ------------------
  418|  75.3k|        if ((res = s_mp_add_d(&tmp, d)) != MP_OKAY)
  ------------------
  |  |   39|  75.3k|#define MP_OKAY 0    /* no error, all is well */
  ------------------
  |  Branch (418:13): [True: 0, False: 75.3k]
  ------------------
  419|      0|            goto CLEANUP;
  420|  75.3k|    } else if (s_mp_cmp_d(&tmp, d) >= 0) {
  ------------------
  |  Branch (420:16): [True: 0, False: 0]
  ------------------
  421|      0|        if ((res = s_mp_sub_d(&tmp, d)) != MP_OKAY)
  ------------------
  |  |   39|      0|#define MP_OKAY 0    /* no error, all is well */
  ------------------
  |  Branch (421:13): [True: 0, False: 0]
  ------------------
  422|      0|            goto CLEANUP;
  423|      0|    } else {
  424|      0|        mp_neg(&tmp, &tmp);
  425|       |
  426|      0|        DIGIT(&tmp, 0) = d - DIGIT(&tmp, 0);
  ------------------
  |  |  331|      0|#define DIGIT(MP, N) MP_DIGIT(MP, N)
  |  |  ------------------
  |  |  |  |  148|      0|#define MP_DIGIT(MP, N) (MP)->dp[(N)]
  |  |  ------------------
  ------------------
                      DIGIT(&tmp, 0) = d - DIGIT(&tmp, 0);
  ------------------
  |  |  331|      0|#define DIGIT(MP, N) MP_DIGIT(MP, N)
  |  |  ------------------
  |  |  |  |  148|      0|#define MP_DIGIT(MP, N) (MP)->dp[(N)]
  |  |  ------------------
  ------------------
  427|      0|    }
  428|       |
  429|  75.3k|    if (s_mp_cmp_d(&tmp, 0) == 0)
  ------------------
  |  Branch (429:9): [True: 879, False: 74.4k]
  ------------------
  430|    879|        SIGN(&tmp) = ZPOS;
  ------------------
  |  |  327|    879|#define SIGN(MP) MP_SIGN(MP)
  |  |  ------------------
  |  |  |  |  144|    879|#define MP_SIGN(MP) ((MP)->sign)
  |  |  ------------------
  ------------------
                      SIGN(&tmp) = ZPOS;
  ------------------
  |  |  321|    879|#define ZPOS MP_ZPOS
  |  |  ------------------
  |  |  |  |   37|    879|#define MP_ZPOS 0
  |  |  ------------------
  ------------------
  431|       |
  432|  75.3k|    s_mp_exch(&tmp, b);
  433|       |
  434|  75.3k|CLEANUP:
  435|  75.3k|    mp_clear(&tmp);
  436|  75.3k|    return res;
  437|       |
  438|  75.3k|} /* end mp_add_d() */
mp_mul_d:
  499|  75.3k|{
  500|  75.3k|    mp_err res;
  501|       |
  502|  75.3k|    ARGCHK(a != NULL && b != NULL, MP_BADARG);
  ------------------
  |  |  350|  75.3k|#define ARGCHK(X, Y) assert(X)
  ------------------
  503|       |
  504|  75.3k|    if (d == 0) {
  ------------------
  |  Branch (504:9): [True: 0, False: 75.3k]
  ------------------
  505|      0|        mp_zero(b);
  506|      0|        return MP_OKAY;
  ------------------
  |  |   39|      0|#define MP_OKAY 0    /* no error, all is well */
  ------------------
  507|      0|    }
  508|       |
  509|  75.3k|    if ((res = mp_copy(a, b)) != MP_OKAY)
  ------------------
  |  |   39|  75.3k|#define MP_OKAY 0    /* no error, all is well */
  ------------------
  |  Branch (509:9): [True: 0, False: 75.3k]
  ------------------
  510|      0|        return res;
  511|       |
  512|  75.3k|    res = s_mp_mul_d(b, d);
  513|       |
  514|  75.3k|    return res;
  515|       |
  516|  75.3k|} /* end mp_mul_d() */
mp_div_d:
  550|   148k|{
  551|   148k|    mp_err res;
  552|   148k|    mp_int qp;
  553|   148k|    mp_digit rem = 0;
  554|   148k|    int pow;
  555|       |
  556|   148k|    ARGCHK(a != NULL, MP_BADARG);
  ------------------
  |  |  350|   148k|#define ARGCHK(X, Y) assert(X)
  ------------------
  557|       |
  558|   148k|    if (d == 0)
  ------------------
  |  Branch (558:9): [True: 0, False: 148k]
  ------------------
  559|      0|        return MP_RANGE;
  ------------------
  |  |   43|      0|#define MP_RANGE -3  /* argument out of range */
  ------------------
  560|       |
  561|       |    /* Shortcut for powers of two ... */
  562|   148k|    if ((pow = s_mp_ispow2d(d)) >= 0) {
  ------------------
  |  Branch (562:9): [True: 148k, False: 0]
  ------------------
  563|   148k|        mp_digit mask;
  564|       |
  565|   148k|        mask = ((mp_digit)1 << pow) - 1;
  566|   148k|        rem = DIGIT(a, 0) & mask;
  ------------------
  |  |  331|   148k|#define DIGIT(MP, N) MP_DIGIT(MP, N)
  |  |  ------------------
  |  |  |  |  148|   148k|#define MP_DIGIT(MP, N) (MP)->dp[(N)]
  |  |  ------------------
  ------------------
  567|       |
  568|   148k|        if (q) {
  ------------------
  |  Branch (568:13): [True: 148k, False: 0]
  ------------------
  569|   148k|            if ((res = mp_copy(a, q)) != MP_OKAY) {
  ------------------
  |  |   39|   148k|#define MP_OKAY 0    /* no error, all is well */
  ------------------
  |  Branch (569:17): [True: 0, False: 148k]
  ------------------
  570|      0|                return res;
  571|      0|            }
  572|   148k|            s_mp_div_2d(q, pow);
  573|   148k|        }
  574|       |
  575|   148k|        if (r)
  ------------------
  |  Branch (575:13): [True: 148k, False: 0]
  ------------------
  576|   148k|            *r = rem;
  577|       |
  578|   148k|        return MP_OKAY;
  ------------------
  |  |   39|   148k|#define MP_OKAY 0    /* no error, all is well */
  ------------------
  579|   148k|    }
  580|       |
  581|      0|    if ((res = mp_init_copy(&qp, a)) != MP_OKAY)
  ------------------
  |  |   39|      0|#define MP_OKAY 0    /* no error, all is well */
  ------------------
  |  Branch (581:9): [True: 0, False: 0]
  ------------------
  582|      0|        return res;
  583|       |
  584|      0|    res = s_mp_div_d(&qp, d, &rem);
  585|       |
  586|      0|    if (s_mp_cmp_d(&qp, 0) == 0)
  ------------------
  |  Branch (586:9): [True: 0, False: 0]
  ------------------
  587|      0|        SIGN(q) = ZPOS;
  ------------------
  |  |  327|      0|#define SIGN(MP) MP_SIGN(MP)
  |  |  ------------------
  |  |  |  |  144|      0|#define MP_SIGN(MP) ((MP)->sign)
  |  |  ------------------
  ------------------
                      SIGN(q) = ZPOS;
  ------------------
  |  |  321|      0|#define ZPOS MP_ZPOS
  |  |  ------------------
  |  |  |  |   37|      0|#define MP_ZPOS 0
  |  |  ------------------
  ------------------
  588|       |
  589|      0|    if (r) {
  ------------------
  |  Branch (589:9): [True: 0, False: 0]
  ------------------
  590|      0|        *r = rem;
  591|      0|    }
  592|       |
  593|      0|    if (q)
  ------------------
  |  Branch (593:9): [True: 0, False: 0]
  ------------------
  594|      0|        s_mp_exch(&qp, q);
  595|       |
  596|      0|    mp_clear(&qp);
  597|      0|    return res;
  598|       |
  599|      0|} /* end mp_div_d() */
mp_cmp_z:
 1790|   150k|{
 1791|   150k|    ARGMPCHK(a != NULL);
  ------------------
  |  |  349|   150k|#define ARGMPCHK(X) assert(X)
  ------------------
 1792|       |
 1793|   150k|    if (SIGN(a) == NEG)
  ------------------
  |  |  327|   150k|#define SIGN(MP) MP_SIGN(MP)
  |  |  ------------------
  |  |  |  |  144|   150k|#define MP_SIGN(MP) ((MP)->sign)
  |  |  ------------------
  ------------------
                  if (SIGN(a) == NEG)
  ------------------
  |  |  320|   150k|#define NEG MP_NEG
  |  |  ------------------
  |  |  |  |   36|   150k|#define MP_NEG 1
  |  |  ------------------
  ------------------
  |  Branch (1793:9): [True: 0, False: 150k]
  ------------------
 1794|      0|        return MP_LT;
  ------------------
  |  |   95|      0|#define MP_LT -1
  ------------------
 1795|   150k|    else if (USED(a) == 1 && DIGIT(a, 0) == 0)
  ------------------
  |  |  328|   150k|#define USED(MP) MP_USED(MP)
  |  |  ------------------
  |  |  |  |  145|   150k|#define MP_USED(MP) ((MP)->used)
  |  |  ------------------
  ------------------
                  else if (USED(a) == 1 && DIGIT(a, 0) == 0)
  ------------------
  |  |  331|  9.64k|#define DIGIT(MP, N) MP_DIGIT(MP, N)
  |  |  ------------------
  |  |  |  |  148|  9.64k|#define MP_DIGIT(MP, N) (MP)->dp[(N)]
  |  |  ------------------
  ------------------
  |  Branch (1795:14): [True: 9.64k, False: 140k]
  |  Branch (1795:30): [True: 1.17k, False: 8.47k]
  ------------------
 1796|  1.17k|        return MP_EQ;
  ------------------
  |  |   96|  1.17k|#define MP_EQ 0
  ------------------
 1797|   149k|    else
 1798|   149k|        return MP_GT;
  ------------------
  |  |   97|   149k|#define MP_GT 1
  ------------------
 1799|       |
 1800|   150k|} /* end mp_cmp_z() */
mp_read_raw:
 2735|    586|{
 2736|    586|    int ix;
 2737|    586|    mp_err res;
 2738|    586|    unsigned char *ustr = (unsigned char *)str;
 2739|       |
 2740|    586|    ARGCHK(mp != NULL && str != NULL && len > 0, MP_BADARG);
  ------------------
  |  |  350|    586|#define ARGCHK(X, Y) assert(X)
  ------------------
 2741|       |
 2742|    586|    mp_zero(mp);
 2743|       |
 2744|       |    /* Read the rest of the digits */
 2745|  75.9k|    for (ix = 1; ix < len; ix++) {
  ------------------
  |  Branch (2745:18): [True: 75.3k, False: 586]
  ------------------
 2746|  75.3k|        if ((res = mp_mul_d(mp, 256, mp)) != MP_OKAY)
  ------------------
  |  |   39|  75.3k|#define MP_OKAY 0    /* no error, all is well */
  ------------------
  |  Branch (2746:13): [True: 0, False: 75.3k]
  ------------------
 2747|      0|            return res;
 2748|  75.3k|        if ((res = mp_add_d(mp, ustr[ix], mp)) != MP_OKAY)
  ------------------
  |  |   39|  75.3k|#define MP_OKAY 0    /* no error, all is well */
  ------------------
  |  Branch (2748:13): [True: 0, False: 75.3k]
  ------------------
 2749|      0|            return res;
 2750|  75.3k|    }
 2751|       |
 2752|       |    /* Get sign from first byte */
 2753|    586|    if (ustr[0])
  ------------------
  |  Branch (2753:9): [True: 524, False: 62]
  ------------------
 2754|    524|        SIGN(mp) = NEG;
  ------------------
  |  |  327|    524|#define SIGN(MP) MP_SIGN(MP)
  |  |  ------------------
  |  |  |  |  144|    524|#define MP_SIGN(MP) ((MP)->sign)
  |  |  ------------------
  ------------------
                      SIGN(mp) = NEG;
  ------------------
  |  |  320|    524|#define NEG MP_NEG
  |  |  ------------------
  |  |  |  |   36|    524|#define MP_NEG 1
  |  |  ------------------
  ------------------
 2755|     62|    else
 2756|     62|        SIGN(mp) = ZPOS;
  ------------------
  |  |  327|     62|#define SIGN(MP) MP_SIGN(MP)
  |  |  ------------------
  |  |  |  |  144|     62|#define MP_SIGN(MP) ((MP)->sign)
  |  |  ------------------
  ------------------
                      SIGN(mp) = ZPOS;
  ------------------
  |  |  321|     62|#define ZPOS MP_ZPOS
  |  |  ------------------
  |  |  |  |   37|     62|#define MP_ZPOS 0
  |  |  ------------------
  ------------------
 2757|       |
 2758|    586|    return MP_OKAY;
  ------------------
  |  |   39|    586|#define MP_OKAY 0    /* no error, all is well */
  ------------------
 2759|       |
 2760|    586|} /* end mp_read_raw() */
mp_toradix:
 2924|    586|{
 2925|    586|    int ix, pos = 0;
 2926|       |
 2927|    586|    ARGCHK(mp != NULL && str != NULL, MP_BADARG);
  ------------------
  |  |  350|    586|#define ARGCHK(X, Y) assert(X)
  ------------------
 2928|    586|    ARGCHK(radix > 1 && radix <= MAX_RADIX, MP_RANGE);
  ------------------
  |  |  350|    586|#define ARGCHK(X, Y) assert(X)
  ------------------
 2929|       |
 2930|    586|    if (mp_cmp_z(mp) == MP_EQ) {
  ------------------
  |  |   96|    586|#define MP_EQ 0
  ------------------
  |  Branch (2930:9): [True: 11, False: 575]
  ------------------
 2931|     11|        str[0] = '0';
 2932|     11|        str[1] = '\0';
 2933|    575|    } else {
 2934|    575|        mp_err res;
 2935|    575|        mp_int tmp;
 2936|    575|        mp_sign sgn;
 2937|    575|        mp_digit rem, rdx = (mp_digit)radix;
 2938|    575|        char ch;
 2939|       |
 2940|    575|        if ((res = mp_init_copy(&tmp, mp)) != MP_OKAY)
  ------------------
  |  |   39|    575|#define MP_OKAY 0    /* no error, all is well */
  ------------------
  |  Branch (2940:13): [True: 0, False: 575]
  ------------------
 2941|      0|            return res;
 2942|       |
 2943|       |        /* Save sign for later, and take absolute value */
 2944|    575|        sgn = SIGN(&tmp);
  ------------------
  |  |  327|    575|#define SIGN(MP) MP_SIGN(MP)
  |  |  ------------------
  |  |  |  |  144|    575|#define MP_SIGN(MP) ((MP)->sign)
  |  |  ------------------
  ------------------
 2945|    575|        SIGN(&tmp) = ZPOS;
  ------------------
  |  |  327|    575|#define SIGN(MP) MP_SIGN(MP)
  |  |  ------------------
  |  |  |  |  144|    575|#define MP_SIGN(MP) ((MP)->sign)
  |  |  ------------------
  ------------------
                      SIGN(&tmp) = ZPOS;
  ------------------
  |  |  321|    575|#define ZPOS MP_ZPOS
  |  |  ------------------
  |  |  |  |   37|    575|#define MP_ZPOS 0
  |  |  ------------------
  ------------------
 2946|       |
 2947|       |        /* Generate output digits in reverse order      */
 2948|   149k|        while (mp_cmp_z(&tmp) != 0) {
  ------------------
  |  Branch (2948:16): [True: 148k, False: 575]
  ------------------
 2949|   148k|            if ((res = mp_div_d(&tmp, rdx, &tmp, &rem)) != MP_OKAY) {
  ------------------
  |  |   39|   148k|#define MP_OKAY 0    /* no error, all is well */
  ------------------
  |  Branch (2949:17): [True: 0, False: 148k]
  ------------------
 2950|      0|                mp_clear(&tmp);
 2951|      0|                return res;
 2952|      0|            }
 2953|       |
 2954|       |            /* Generate digits, use capital letters */
 2955|   148k|            ch = s_mp_todigit(rem, radix, 0);
 2956|       |
 2957|   148k|            str[pos++] = ch;
 2958|   148k|        }
 2959|       |
 2960|       |        /* Add - sign if original value was negative */
 2961|    575|        if (sgn == NEG)
  ------------------
  |  |  320|    575|#define NEG MP_NEG
  |  |  ------------------
  |  |  |  |   36|    575|#define MP_NEG 1
  |  |  ------------------
  ------------------
  |  Branch (2961:13): [True: 0, False: 575]
  ------------------
 2962|      0|            str[pos++] = '-';
 2963|       |
 2964|       |        /* Add trailing NUL to end the string        */
 2965|    575|        str[pos--] = '\0';
 2966|       |
 2967|       |        /* Reverse the digits and sign indicator     */
 2968|    575|        ix = 0;
 2969|  74.9k|        while (ix < pos) {
  ------------------
  |  Branch (2969:16): [True: 74.3k, False: 575]
  ------------------
 2970|  74.3k|            char tmpc = str[ix];
 2971|       |
 2972|  74.3k|            str[ix] = str[pos];
 2973|  74.3k|            str[pos] = tmpc;
 2974|  74.3k|            ++ix;
 2975|  74.3k|            --pos;
 2976|  74.3k|        }
 2977|       |
 2978|    575|        mp_clear(&tmp);
 2979|    575|    }
 2980|       |
 2981|    586|    return MP_OKAY;
  ------------------
  |  |   39|    586|#define MP_OKAY 0    /* no error, all is well */
  ------------------
 2982|       |
 2983|    586|} /* end mp_toradix() */
s_mp_grow:
 3038|     75|{
 3039|     75|    ARGCHK(mp != NULL, MP_BADARG);
  ------------------
  |  |  350|     75|#define ARGCHK(X, Y) assert(X)
  ------------------
 3040|       |
 3041|     75|    if (min > ALLOC(mp)) {
  ------------------
  |  |  329|     75|#define ALLOC(MP) MP_ALLOC(MP)
  |  |  ------------------
  |  |  |  |  146|     75|#define MP_ALLOC(MP) ((MP)->alloc)
  |  |  ------------------
  ------------------
  |  Branch (3041:9): [True: 75, False: 0]
  ------------------
 3042|     75|        mp_digit *tmp;
 3043|       |
 3044|       |        /* Set min to next nearest default precision block size */
 3045|     75|        min = MP_ROUNDUP(min, s_mp_defprec);
  ------------------
  |  |   89|     75|#define MP_ROUNDUP(a, b) (MP_HOWMANY(a, b) * (b))
  |  |  ------------------
  |  |  |  |   88|     75|#define MP_HOWMANY(a, b) (((a) + (b)-1) / (b))
  |  |  ------------------
  ------------------
 3046|       |
 3047|     75|        if ((tmp = s_mp_alloc(min, sizeof(mp_digit))) == NULL)
  ------------------
  |  Branch (3047:13): [True: 0, False: 75]
  ------------------
 3048|      0|            return MP_MEM;
  ------------------
  |  |   42|      0|#define MP_MEM -2    /* out of memory         */
  ------------------
 3049|       |
 3050|     75|        s_mp_copy(DIGITS(mp), tmp, USED(mp));
  ------------------
  |  |  330|     75|#define DIGITS(MP) MP_DIGITS(MP)
  |  |  ------------------
  |  |  |  |  147|     75|#define MP_DIGITS(MP) ((MP)->dp)
  |  |  ------------------
  ------------------
                      s_mp_copy(DIGITS(mp), tmp, USED(mp));
  ------------------
  |  |  328|     75|#define USED(MP) MP_USED(MP)
  |  |  ------------------
  |  |  |  |  145|     75|#define MP_USED(MP) ((MP)->used)
  |  |  ------------------
  ------------------
 3051|       |
 3052|     75|        s_mp_setz(DIGITS(mp), ALLOC(mp));
  ------------------
  |  |  330|     75|#define DIGITS(MP) MP_DIGITS(MP)
  |  |  ------------------
  |  |  |  |  147|     75|#define MP_DIGITS(MP) ((MP)->dp)
  |  |  ------------------
  ------------------
                      s_mp_setz(DIGITS(mp), ALLOC(mp));
  ------------------
  |  |  329|     75|#define ALLOC(MP) MP_ALLOC(MP)
  |  |  ------------------
  |  |  |  |  146|     75|#define MP_ALLOC(MP) ((MP)->alloc)
  |  |  ------------------
  ------------------
 3053|     75|        s_mp_free(DIGITS(mp));
  ------------------
  |  |  330|     75|#define DIGITS(MP) MP_DIGITS(MP)
  |  |  ------------------
  |  |  |  |  147|     75|#define MP_DIGITS(MP) ((MP)->dp)
  |  |  ------------------
  ------------------
 3054|     75|        DIGITS(mp) = tmp;
  ------------------
  |  |  330|     75|#define DIGITS(MP) MP_DIGITS(MP)
  |  |  ------------------
  |  |  |  |  147|     75|#define MP_DIGITS(MP) ((MP)->dp)
  |  |  ------------------
  ------------------
 3055|     75|        ALLOC(mp) = min;
  ------------------
  |  |  329|     75|#define ALLOC(MP) MP_ALLOC(MP)
  |  |  ------------------
  |  |  |  |  146|     75|#define MP_ALLOC(MP) ((MP)->alloc)
  |  |  ------------------
  ------------------
 3056|     75|    }
 3057|       |
 3058|     75|    return MP_OKAY;
  ------------------
  |  |   39|     75|#define MP_OKAY 0    /* no error, all is well */
  ------------------
 3059|       |
 3060|     75|} /* end s_mp_grow() */
s_mp_pad:
 3069|  75.3k|{
 3070|  75.3k|    ARGCHK(mp != NULL, MP_BADARG);
  ------------------
  |  |  350|  75.3k|#define ARGCHK(X, Y) assert(X)
  ------------------
 3071|       |
 3072|  75.3k|    if (min > USED(mp)) {
  ------------------
  |  |  328|  75.3k|#define USED(MP) MP_USED(MP)
  |  |  ------------------
  |  |  |  |  145|  75.3k|#define MP_USED(MP) ((MP)->used)
  |  |  ------------------
  ------------------
  |  Branch (3072:9): [True: 8.97k, False: 66.3k]
  ------------------
 3073|  8.97k|        mp_err res;
 3074|       |
 3075|       |        /* Make sure there is room to increase precision  */
 3076|  8.97k|        if (min > ALLOC(mp)) {
  ------------------
  |  |  329|  8.97k|#define ALLOC(MP) MP_ALLOC(MP)
  |  |  ------------------
  |  |  |  |  146|  8.97k|#define MP_ALLOC(MP) ((MP)->alloc)
  |  |  ------------------
  ------------------
  |  Branch (3076:13): [True: 75, False: 8.90k]
  ------------------
 3077|     75|            if ((res = s_mp_grow(mp, min)) != MP_OKAY)
  ------------------
  |  |   39|     75|#define MP_OKAY 0    /* no error, all is well */
  ------------------
  |  Branch (3077:17): [True: 0, False: 75]
  ------------------
 3078|      0|                return res;
 3079|  8.90k|        } else {
 3080|  8.90k|            s_mp_setz(DIGITS(mp) + USED(mp), min - USED(mp));
  ------------------
  |  |  330|  8.90k|#define DIGITS(MP) MP_DIGITS(MP)
  |  |  ------------------
  |  |  |  |  147|  8.90k|#define MP_DIGITS(MP) ((MP)->dp)
  |  |  ------------------
  ------------------
                          s_mp_setz(DIGITS(mp) + USED(mp), min - USED(mp));
  ------------------
  |  |  328|  8.90k|#define USED(MP) MP_USED(MP)
  |  |  ------------------
  |  |  |  |  145|  8.90k|#define MP_USED(MP) ((MP)->used)
  |  |  ------------------
  ------------------
                          s_mp_setz(DIGITS(mp) + USED(mp), min - USED(mp));
  ------------------
  |  |  328|  8.90k|#define USED(MP) MP_USED(MP)
  |  |  ------------------
  |  |  |  |  145|  8.90k|#define MP_USED(MP) ((MP)->used)
  |  |  ------------------
  ------------------
 3081|  8.90k|        }
 3082|       |
 3083|       |        /* Increase precision; should already be 0-filled */
 3084|  8.97k|        USED(mp) = min;
  ------------------
  |  |  328|  8.97k|#define USED(MP) MP_USED(MP)
  |  |  ------------------
  |  |  |  |  145|  8.97k|#define MP_USED(MP) ((MP)->used)
  |  |  ------------------
  ------------------
 3085|  8.97k|    }
 3086|       |
 3087|  75.3k|    return MP_OKAY;
  ------------------
  |  |   39|  75.3k|#define MP_OKAY 0    /* no error, all is well */
  ------------------
 3088|       |
 3089|  75.3k|} /* end s_mp_pad() */
s_mp_setz:
 3098|  87.2k|{
 3099|  87.2k|    memset(dp, 0, count * sizeof(mp_digit));
 3100|  87.2k|} /* end s_mp_setz() */
s_mp_copy:
 3109|  75.9k|{
 3110|  75.9k|    memcpy(dp, sp, count * sizeof(mp_digit));
 3111|  75.9k|} /* end s_mp_copy() */
s_mp_alloc:
 3120|  77.7k|{
 3121|  77.7k|    return calloc(nb, ni);
 3122|       |
 3123|  77.7k|} /* end s_mp_alloc() */
s_mp_free:
 3132|  77.7k|{
 3133|  77.7k|    if (ptr) {
  ------------------
  |  Branch (3133:9): [True: 77.7k, False: 0]
  ------------------
 3134|  77.7k|        free(ptr);
 3135|  77.7k|    }
 3136|  77.7k|} /* end s_mp_free() */
s_mp_clamp:
 3145|   224k|{
 3146|   224k|    mp_size used = MP_USED(mp);
  ------------------
  |  |  145|   224k|#define MP_USED(MP) ((MP)->used)
  ------------------
 3147|   233k|    while (used > 1 && DIGIT(mp, used - 1) == 0)
  ------------------
  |  |  331|   219k|#define DIGIT(MP, N) MP_DIGIT(MP, N)
  |  |  ------------------
  |  |  |  |  148|   219k|#define MP_DIGIT(MP, N) (MP)->dp[(N)]
  |  |  ------------------
  ------------------
  |  Branch (3147:12): [True: 219k, False: 13.7k]
  |  Branch (3147:24): [True: 8.97k, False: 210k]
  ------------------
 3148|  8.97k|        --used;
 3149|   224k|    MP_USED(mp) = used;
  ------------------
  |  |  145|   224k|#define MP_USED(MP) ((MP)->used)
  ------------------
 3150|   224k|    if (used == 1 && DIGIT(mp, 0) == 0)
  ------------------
  |  |  331|  13.7k|#define DIGIT(MP, N) MP_DIGIT(MP, N)
  |  |  ------------------
  |  |  |  |  148|  13.7k|#define MP_DIGIT(MP, N) (MP)->dp[(N)]
  |  |  ------------------
  ------------------
  |  Branch (3150:9): [True: 13.7k, False: 210k]
  |  Branch (3150:22): [True: 2.02k, False: 11.6k]
  ------------------
 3151|  2.02k|        MP_SIGN(mp) = ZPOS;
  ------------------
  |  |  144|  2.02k|#define MP_SIGN(MP) ((MP)->sign)
  ------------------
                      MP_SIGN(mp) = ZPOS;
  ------------------
  |  |  321|  2.02k|#define ZPOS MP_ZPOS
  |  |  ------------------
  |  |  |  |   37|  2.02k|#define MP_ZPOS 0
  |  |  ------------------
  ------------------
 3152|   224k|} /* end s_mp_clamp() */
s_mp_exch:
 3161|  75.3k|{
 3162|  75.3k|    mp_int tmp;
 3163|  75.3k|    if (!a || !b) {
  ------------------
  |  Branch (3163:9): [True: 0, False: 75.3k]
  |  Branch (3163:15): [True: 0, False: 75.3k]
  ------------------
 3164|      0|        return;
 3165|      0|    }
 3166|       |
 3167|  75.3k|    tmp = *a;
 3168|  75.3k|    *a = *b;
 3169|  75.3k|    *b = tmp;
 3170|       |
 3171|  75.3k|} /* end s_mp_exch() */
s_mp_mul_2d:
 3227|  75.3k|{
 3228|  75.3k|    mp_err res;
 3229|  75.3k|    mp_digit dshift, rshift, mask, x, prev = 0;
 3230|  75.3k|    mp_digit *pa = NULL;
 3231|  75.3k|    int i;
 3232|       |
 3233|  75.3k|    ARGCHK(mp != NULL, MP_BADARG);
  ------------------
  |  |  350|  75.3k|#define ARGCHK(X, Y) assert(X)
  ------------------
 3234|       |
 3235|  75.3k|    dshift = d / MP_DIGIT_BIT;
  ------------------
  |  |  132|  75.3k|#define MP_DIGIT_BIT (CHAR_BIT * MP_DIGIT_SIZE)
  |  |  ------------------
  |  |  |  |  131|  75.3k|#define MP_DIGIT_SIZE sizeof(mp_digit)
  |  |  ------------------
  ------------------
 3236|  75.3k|    d %= MP_DIGIT_BIT;
  ------------------
  |  |  132|  75.3k|#define MP_DIGIT_BIT (CHAR_BIT * MP_DIGIT_SIZE)
  |  |  ------------------
  |  |  |  |  131|  75.3k|#define MP_DIGIT_SIZE sizeof(mp_digit)
  |  |  ------------------
  ------------------
 3237|       |    /* mp_digit >> rshift is undefined behavior for rshift >= MP_DIGIT_BIT */
 3238|       |    /* mod and corresponding mask logic avoid that when d = 0 */
 3239|  75.3k|    rshift = MP_DIGIT_BIT - d;
  ------------------
  |  |  132|  75.3k|#define MP_DIGIT_BIT (CHAR_BIT * MP_DIGIT_SIZE)
  |  |  ------------------
  |  |  |  |  131|  75.3k|#define MP_DIGIT_SIZE sizeof(mp_digit)
  |  |  ------------------
  ------------------
 3240|  75.3k|    rshift %= MP_DIGIT_BIT;
  ------------------
  |  |  132|  75.3k|#define MP_DIGIT_BIT (CHAR_BIT * MP_DIGIT_SIZE)
  |  |  ------------------
  |  |  |  |  131|  75.3k|#define MP_DIGIT_SIZE sizeof(mp_digit)
  |  |  ------------------
  ------------------
 3241|       |    /* mask = (2**d - 1) * 2**(w-d) mod 2**w */
 3242|  75.3k|    mask = (DIGIT_MAX << rshift) + 1;
  ------------------
  |  |  322|  75.3k|#define DIGIT_MAX MP_DIGIT_MAX
  |  |  ------------------
  |  |  |  |   74|  75.3k|#define MP_DIGIT_MAX ULONG_MAX
  |  |  ------------------
  ------------------
 3243|  75.3k|    mask &= DIGIT_MAX - 1;
  ------------------
  |  |  322|  75.3k|#define DIGIT_MAX MP_DIGIT_MAX
  |  |  ------------------
  |  |  |  |   74|  75.3k|#define MP_DIGIT_MAX ULONG_MAX
  |  |  ------------------
  ------------------
 3244|       |    /* bits to be shifted out of the top word */
 3245|  75.3k|    x = MP_DIGIT(mp, MP_USED(mp) - 1) & mask;
  ------------------
  |  |  148|  75.3k|#define MP_DIGIT(MP, N) (MP)->dp[(N)]
  ------------------
 3246|       |
 3247|  75.3k|    if (MP_OKAY != (res = s_mp_pad(mp, MP_USED(mp) + dshift + (x != 0))))
  ------------------
  |  |   39|  75.3k|#define MP_OKAY 0    /* no error, all is well */
  ------------------
                  if (MP_OKAY != (res = s_mp_pad(mp, MP_USED(mp) + dshift + (x != 0))))
  ------------------
  |  |  145|  75.3k|#define MP_USED(MP) ((MP)->used)
  ------------------
  |  Branch (3247:9): [True: 0, False: 75.3k]
  ------------------
 3248|      0|        return res;
 3249|       |
 3250|  75.3k|    if (dshift && MP_OKAY != (res = s_mp_lshd(mp, dshift)))
  ------------------
  |  |   39|      0|#define MP_OKAY 0    /* no error, all is well */
  ------------------
  |  Branch (3250:9): [True: 0, False: 75.3k]
  |  Branch (3250:19): [True: 0, False: 0]
  ------------------
 3251|      0|        return res;
 3252|       |
 3253|  75.3k|    pa = MP_DIGITS(mp) + dshift;
  ------------------
  |  |  147|  75.3k|#define MP_DIGITS(MP) ((MP)->dp)
  ------------------
 3254|       |
 3255|  5.46M|    for (i = MP_USED(mp) - dshift; i > 0; i--) {
  ------------------
  |  |  145|  75.3k|#define MP_USED(MP) ((MP)->used)
  ------------------
  |  Branch (3255:36): [True: 5.38M, False: 75.3k]
  ------------------
 3256|  5.38M|        x = *pa;
 3257|  5.38M|        *pa++ = (x << d) | prev;
 3258|  5.38M|        prev = (x & mask) >> rshift;
 3259|  5.38M|    }
 3260|       |
 3261|  75.3k|    s_mp_clamp(mp);
 3262|  75.3k|    return MP_OKAY;
  ------------------
  |  |   39|  75.3k|#define MP_OKAY 0    /* no error, all is well */
  ------------------
 3263|  75.3k|} /* end s_mp_mul_2d() */
s_mp_rshd:
 3275|   148k|{
 3276|   148k|    mp_size ix;
 3277|   148k|    mp_digit *src, *dst;
 3278|       |
 3279|   148k|    if (p == 0)
  ------------------
  |  Branch (3279:9): [True: 148k, False: 0]
  ------------------
 3280|   148k|        return;
 3281|       |
 3282|       |    /* Shortcut when all digits are to be shifted off */
 3283|      0|    if (p >= USED(mp)) {
  ------------------
  |  |  328|      0|#define USED(MP) MP_USED(MP)
  |  |  ------------------
  |  |  |  |  145|      0|#define MP_USED(MP) ((MP)->used)
  |  |  ------------------
  ------------------
  |  Branch (3283:9): [True: 0, False: 0]
  ------------------
 3284|      0|        s_mp_setz(DIGITS(mp), ALLOC(mp));
  ------------------
  |  |  330|      0|#define DIGITS(MP) MP_DIGITS(MP)
  |  |  ------------------
  |  |  |  |  147|      0|#define MP_DIGITS(MP) ((MP)->dp)
  |  |  ------------------
  ------------------
                      s_mp_setz(DIGITS(mp), ALLOC(mp));
  ------------------
  |  |  329|      0|#define ALLOC(MP) MP_ALLOC(MP)
  |  |  ------------------
  |  |  |  |  146|      0|#define MP_ALLOC(MP) ((MP)->alloc)
  |  |  ------------------
  ------------------
 3285|      0|        USED(mp) = 1;
  ------------------
  |  |  328|      0|#define USED(MP) MP_USED(MP)
  |  |  ------------------
  |  |  |  |  145|      0|#define MP_USED(MP) ((MP)->used)
  |  |  ------------------
  ------------------
 3286|      0|        SIGN(mp) = ZPOS;
  ------------------
  |  |  327|      0|#define SIGN(MP) MP_SIGN(MP)
  |  |  ------------------
  |  |  |  |  144|      0|#define MP_SIGN(MP) ((MP)->sign)
  |  |  ------------------
  ------------------
                      SIGN(mp) = ZPOS;
  ------------------
  |  |  321|      0|#define ZPOS MP_ZPOS
  |  |  ------------------
  |  |  |  |   37|      0|#define MP_ZPOS 0
  |  |  ------------------
  ------------------
 3287|      0|        return;
 3288|      0|    }
 3289|       |
 3290|       |    /* Shift all the significant figures over as needed */
 3291|      0|    dst = MP_DIGITS(mp);
  ------------------
  |  |  147|      0|#define MP_DIGITS(MP) ((MP)->dp)
  ------------------
 3292|      0|    src = dst + p;
 3293|      0|    for (ix = USED(mp) - p; ix > 0; ix--)
  ------------------
  |  |  328|      0|#define USED(MP) MP_USED(MP)
  |  |  ------------------
  |  |  |  |  145|      0|#define MP_USED(MP) ((MP)->used)
  |  |  ------------------
  ------------------
  |  Branch (3293:29): [True: 0, False: 0]
  ------------------
 3294|      0|        *dst++ = *src++;
 3295|       |
 3296|      0|    MP_USED(mp) -= p;
  ------------------
  |  |  145|      0|#define MP_USED(MP) ((MP)->used)
  ------------------
 3297|       |    /* Fill the top digits with zeroes */
 3298|      0|    while (p-- > 0)
  ------------------
  |  Branch (3298:12): [True: 0, False: 0]
  ------------------
 3299|      0|        *dst++ = 0;
 3300|       |
 3301|      0|} /* end s_mp_rshd() */
s_mp_div_2d:
 3395|   148k|{
 3396|   148k|    int ix;
 3397|   148k|    mp_digit save, next, mask, lshift;
 3398|       |
 3399|   148k|    s_mp_rshd(mp, d / DIGIT_BIT);
  ------------------
  |  |  323|   148k|#define DIGIT_BIT MP_DIGIT_BIT
  |  |  ------------------
  |  |  |  |  132|   148k|#define MP_DIGIT_BIT (CHAR_BIT * MP_DIGIT_SIZE)
  |  |  |  |  ------------------
  |  |  |  |  |  |  131|   148k|#define MP_DIGIT_SIZE sizeof(mp_digit)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3400|   148k|    d %= DIGIT_BIT;
  ------------------
  |  |  323|   148k|#define DIGIT_BIT MP_DIGIT_BIT
  |  |  ------------------
  |  |  |  |  132|   148k|#define MP_DIGIT_BIT (CHAR_BIT * MP_DIGIT_SIZE)
  |  |  |  |  ------------------
  |  |  |  |  |  |  131|   148k|#define MP_DIGIT_SIZE sizeof(mp_digit)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3401|       |    /* mp_digit << lshift is undefined behavior for lshift >= MP_DIGIT_BIT */
 3402|       |    /* mod and corresponding mask logic avoid that when d = 0 */
 3403|   148k|    lshift = DIGIT_BIT - d;
  ------------------
  |  |  323|   148k|#define DIGIT_BIT MP_DIGIT_BIT
  |  |  ------------------
  |  |  |  |  132|   148k|#define MP_DIGIT_BIT (CHAR_BIT * MP_DIGIT_SIZE)
  |  |  |  |  ------------------
  |  |  |  |  |  |  131|   148k|#define MP_DIGIT_SIZE sizeof(mp_digit)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3404|   148k|    lshift %= DIGIT_BIT;
  ------------------
  |  |  323|   148k|#define DIGIT_BIT MP_DIGIT_BIT
  |  |  ------------------
  |  |  |  |  132|   148k|#define MP_DIGIT_BIT (CHAR_BIT * MP_DIGIT_SIZE)
  |  |  |  |  ------------------
  |  |  |  |  |  |  131|   148k|#define MP_DIGIT_SIZE sizeof(mp_digit)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3405|   148k|    mask = ((mp_digit)1 << d) - 1;
 3406|   148k|    save = 0;
 3407|  10.9M|    for (ix = USED(mp) - 1; ix >= 0; ix--) {
  ------------------
  |  |  328|   148k|#define USED(MP) MP_USED(MP)
  |  |  ------------------
  |  |  |  |  145|   148k|#define MP_USED(MP) ((MP)->used)
  |  |  ------------------
  ------------------
  |  Branch (3407:29): [True: 10.7M, False: 148k]
  ------------------
 3408|  10.7M|        next = DIGIT(mp, ix) & mask;
  ------------------
  |  |  331|  10.7M|#define DIGIT(MP, N) MP_DIGIT(MP, N)
  |  |  ------------------
  |  |  |  |  148|  10.7M|#define MP_DIGIT(MP, N) (MP)->dp[(N)]
  |  |  ------------------
  ------------------
 3409|  10.7M|        DIGIT(mp, ix) = (save << lshift) | (DIGIT(mp, ix) >> d);
  ------------------
  |  |  331|  10.7M|#define DIGIT(MP, N) MP_DIGIT(MP, N)
  |  |  ------------------
  |  |  |  |  148|  10.7M|#define MP_DIGIT(MP, N) (MP)->dp[(N)]
  |  |  ------------------
  ------------------
                      DIGIT(mp, ix) = (save << lshift) | (DIGIT(mp, ix) >> d);
  ------------------
  |  |  331|  10.7M|#define DIGIT(MP, N) MP_DIGIT(MP, N)
  |  |  ------------------
  |  |  |  |  148|  10.7M|#define MP_DIGIT(MP, N) (MP)->dp[(N)]
  |  |  ------------------
  ------------------
 3410|  10.7M|        save = next;
 3411|  10.7M|    }
 3412|   148k|    s_mp_clamp(mp);
 3413|       |
 3414|   148k|} /* end s_mp_div_2d() */
s_mp_add_d:
 3471|  75.3k|{
 3472|       |#if !defined(MP_NO_MP_WORD) && !defined(MP_NO_ADD_WORD)
 3473|       |    mp_word w, k = 0;
 3474|       |    mp_size ix = 1;
 3475|       |
 3476|       |    w = (mp_word)DIGIT(mp, 0) + d;
 3477|       |    DIGIT(mp, 0) = ACCUM(w);
 3478|       |    k = CARRYOUT(w);
 3479|       |
 3480|       |    while (ix < USED(mp) && k) {
 3481|       |        w = (mp_word)DIGIT(mp, ix) + k;
 3482|       |        DIGIT(mp, ix) = ACCUM(w);
 3483|       |        k = CARRYOUT(w);
 3484|       |        ++ix;
 3485|       |    }
 3486|       |
 3487|       |    if (k != 0) {
 3488|       |        mp_err res;
 3489|       |
 3490|       |        if ((res = s_mp_pad(mp, USED(mp) + 1)) != MP_OKAY)
 3491|       |            return res;
 3492|       |
 3493|       |        DIGIT(mp, ix) = (mp_digit)k;
 3494|       |    }
 3495|       |
 3496|       |    return MP_OKAY;
 3497|       |#else
 3498|  75.3k|    mp_digit *pmp = MP_DIGITS(mp);
  ------------------
  |  |  147|  75.3k|#define MP_DIGITS(MP) ((MP)->dp)
  ------------------
 3499|  75.3k|    mp_digit sum, mp_i, carry = 0;
 3500|  75.3k|    mp_err res = MP_OKAY;
  ------------------
  |  |   39|  75.3k|#define MP_OKAY 0    /* no error, all is well */
  ------------------
 3501|  75.3k|    int used = (int)MP_USED(mp);
  ------------------
  |  |  145|  75.3k|#define MP_USED(MP) ((MP)->used)
  ------------------
 3502|       |
 3503|  75.3k|    mp_i = *pmp;
 3504|  75.3k|    *pmp++ = sum = d + mp_i;
 3505|  75.3k|    carry = (sum < d);
 3506|  75.3k|    while (carry && --used > 0) {
  ------------------
  |  Branch (3506:12): [True: 0, False: 75.3k]
  |  Branch (3506:21): [True: 0, False: 0]
  ------------------
 3507|      0|        mp_i = *pmp;
 3508|      0|        *pmp++ = sum = carry + mp_i;
 3509|      0|        carry = !sum;
 3510|      0|    }
 3511|  75.3k|    if (carry && !used) {
  ------------------
  |  Branch (3511:9): [True: 0, False: 75.3k]
  |  Branch (3511:18): [True: 0, False: 0]
  ------------------
 3512|       |        /* mp is growing */
 3513|      0|        used = MP_USED(mp);
  ------------------
  |  |  145|      0|#define MP_USED(MP) ((MP)->used)
  ------------------
 3514|      0|        MP_CHECKOK(s_mp_pad(mp, used + 1));
  ------------------
  |  |  314|      0|    if (MP_OKAY > (res = (x))) \
  |  |  ------------------
  |  |  |  |   39|      0|#define MP_OKAY 0    /* no error, all is well */
  |  |  ------------------
  |  |  |  Branch (314:9): [True: 0, False: 0]
  |  |  ------------------
  |  |  315|      0|    goto CLEANUP
  ------------------
 3515|      0|        MP_DIGIT(mp, used) = carry;
  ------------------
  |  |  148|      0|#define MP_DIGIT(MP, N) (MP)->dp[(N)]
  ------------------
 3516|      0|    }
 3517|  75.3k|CLEANUP:
 3518|  75.3k|    return res;
 3519|  75.3k|#endif
 3520|  75.3k|} /* end s_mp_add_d() */
s_mp_mul_d:
 3580|  75.3k|{
 3581|  75.3k|    mp_err res;
 3582|  75.3k|    mp_size used;
 3583|  75.3k|    int pow;
 3584|       |
 3585|  75.3k|    if (!d) {
  ------------------
  |  Branch (3585:9): [True: 0, False: 75.3k]
  ------------------
 3586|      0|        mp_zero(a);
 3587|      0|        return MP_OKAY;
  ------------------
  |  |   39|      0|#define MP_OKAY 0    /* no error, all is well */
  ------------------
 3588|      0|    }
 3589|  75.3k|    if (d == 1)
  ------------------
  |  Branch (3589:9): [True: 0, False: 75.3k]
  ------------------
 3590|      0|        return MP_OKAY;
  ------------------
  |  |   39|      0|#define MP_OKAY 0    /* no error, all is well */
  ------------------
 3591|  75.3k|    if (0 <= (pow = s_mp_ispow2d(d))) {
  ------------------
  |  Branch (3591:9): [True: 75.3k, False: 0]
  ------------------
 3592|  75.3k|        return s_mp_mul_2d(a, (mp_digit)pow);
 3593|  75.3k|    }
 3594|       |
 3595|      0|    used = MP_USED(a);
  ------------------
  |  |  145|      0|#define MP_USED(MP) ((MP)->used)
  ------------------
 3596|      0|    MP_CHECKOK(s_mp_pad(a, used + 1));
  ------------------
  |  |  314|      0|    if (MP_OKAY > (res = (x))) \
  |  |  ------------------
  |  |  |  |   39|      0|#define MP_OKAY 0    /* no error, all is well */
  |  |  ------------------
  |  |  |  Branch (314:9): [True: 0, False: 0]
  |  |  ------------------
  |  |  315|      0|    goto CLEANUP
  ------------------
 3597|       |
 3598|      0|    s_mpv_mul_d(MP_DIGITS(a), used, d, MP_DIGITS(a));
  ------------------
  |  |  189|      0|    ((mp_digit *)c)[a_len] = s_mpv_mul_set_vec64(c, a, a_len, b)
  ------------------
 3599|       |
 3600|      0|    s_mp_clamp(a);
 3601|       |
 3602|      0|CLEANUP:
 3603|      0|    return res;
 3604|       |
 3605|      0|} /* end s_mp_mul_d() */
s_mp_cmp_d:
 4795|  75.3k|{
 4796|  75.3k|    ARGMPCHK(a != NULL);
  ------------------
  |  |  349|  75.3k|#define ARGMPCHK(X) assert(X)
  ------------------
 4797|       |
 4798|  75.3k|    if (USED(a) > 1)
  ------------------
  |  |  328|  75.3k|#define USED(MP) MP_USED(MP)
  |  |  ------------------
  |  |  |  |  145|  75.3k|#define MP_USED(MP) ((MP)->used)
  |  |  ------------------
  ------------------
  |  Branch (4798:9): [True: 70.3k, False: 5.03k]
  ------------------
 4799|  70.3k|        return MP_GT;
  ------------------
  |  |   97|  70.3k|#define MP_GT 1
  ------------------
 4800|       |
 4801|  5.03k|    if (DIGIT(a, 0) < d)
  ------------------
  |  |  331|  5.03k|#define DIGIT(MP, N) MP_DIGIT(MP, N)
  |  |  ------------------
  |  |  |  |  148|  5.03k|#define MP_DIGIT(MP, N) (MP)->dp[(N)]
  |  |  ------------------
  ------------------
  |  Branch (4801:9): [True: 0, False: 5.03k]
  ------------------
 4802|      0|        return MP_LT;
  ------------------
  |  |   95|      0|#define MP_LT -1
  ------------------
 4803|  5.03k|    else if (DIGIT(a, 0) > d)
  ------------------
  |  |  331|  5.03k|#define DIGIT(MP, N) MP_DIGIT(MP, N)
  |  |  ------------------
  |  |  |  |  148|  5.03k|#define MP_DIGIT(MP, N) (MP)->dp[(N)]
  |  |  ------------------
  ------------------
  |  Branch (4803:14): [True: 4.15k, False: 879]
  ------------------
 4804|  4.15k|        return MP_GT;
  ------------------
  |  |   97|  4.15k|#define MP_GT 1
  ------------------
 4805|    879|    else
 4806|    879|        return MP_EQ;
  ------------------
  |  |   96|    879|#define MP_EQ 0
  ------------------
 4807|       |
 4808|  5.03k|} /* end s_mp_cmp_d() */
s_mp_ispow2d:
 4849|   224k|{
 4850|   224k|    if ((d != 0) && ((d & (d - 1)) == 0)) { /* d is a power of 2 */
  ------------------
  |  Branch (4850:9): [True: 224k, False: 0]
  |  Branch (4850:21): [True: 224k, False: 0]
  ------------------
 4851|   224k|        int pow = 0;
 4852|       |#if defined(MP_USE_UINT_DIGIT)
 4853|       |        if (d & 0xffff0000U)
 4854|       |            pow += 16;
 4855|       |        if (d & 0xff00ff00U)
 4856|       |            pow += 8;
 4857|       |        if (d & 0xf0f0f0f0U)
 4858|       |            pow += 4;
 4859|       |        if (d & 0xccccccccU)
 4860|       |            pow += 2;
 4861|       |        if (d & 0xaaaaaaaaU)
 4862|       |            pow += 1;
 4863|       |#elif defined(MP_USE_LONG_LONG_DIGIT)
 4864|       |        if (d & 0xffffffff00000000ULL)
 4865|       |            pow += 32;
 4866|       |        if (d & 0xffff0000ffff0000ULL)
 4867|       |            pow += 16;
 4868|       |        if (d & 0xff00ff00ff00ff00ULL)
 4869|       |            pow += 8;
 4870|       |        if (d & 0xf0f0f0f0f0f0f0f0ULL)
 4871|       |            pow += 4;
 4872|       |        if (d & 0xccccccccccccccccULL)
 4873|       |            pow += 2;
 4874|       |        if (d & 0xaaaaaaaaaaaaaaaaULL)
 4875|       |            pow += 1;
 4876|       |#elif defined(MP_USE_LONG_DIGIT)
 4877|   224k|        if (d & 0xffffffff00000000UL)
  ------------------
  |  Branch (4877:13): [True: 0, False: 224k]
  ------------------
 4878|      0|            pow += 32;
 4879|   224k|        if (d & 0xffff0000ffff0000UL)
  ------------------
  |  Branch (4879:13): [True: 0, False: 224k]
  ------------------
 4880|      0|            pow += 16;
 4881|   224k|        if (d & 0xff00ff00ff00ff00UL)
  ------------------
  |  Branch (4881:13): [True: 75.3k, False: 148k]
  ------------------
 4882|  75.3k|            pow += 8;
 4883|   224k|        if (d & 0xf0f0f0f0f0f0f0f0UL)
  ------------------
  |  Branch (4883:13): [True: 148k, False: 75.3k]
  ------------------
 4884|   148k|            pow += 4;
 4885|   224k|        if (d & 0xccccccccccccccccUL)
  ------------------
  |  Branch (4885:13): [True: 0, False: 224k]
  ------------------
 4886|      0|            pow += 2;
 4887|   224k|        if (d & 0xaaaaaaaaaaaaaaaaUL)
  ------------------
  |  Branch (4887:13): [True: 0, False: 224k]
  ------------------
 4888|      0|            pow += 1;
 4889|       |#else
 4890|       |#error "unknown type for mp_digit"
 4891|       |#endif
 4892|   224k|        return pow;
 4893|   224k|    }
 4894|      0|    return -1;
 4895|       |
 4896|   224k|} /* end s_mp_ispow2d() */
s_mp_todigit:
 4959|   148k|{
 4960|   148k|    char ch;
 4961|       |
 4962|   148k|    if (val >= r)
  ------------------
  |  Branch (4962:9): [True: 0, False: 148k]
  ------------------
 4963|      0|        return 0;
 4964|       |
 4965|   148k|    ch = s_dmap_1[val];
 4966|       |
 4967|   148k|    if (r <= 36 && low)
  ------------------
  |  Branch (4967:9): [True: 148k, False: 0]
  |  Branch (4967:20): [True: 0, False: 148k]
  ------------------
 4968|      0|        ch = tolower(ch);
 4969|       |
 4970|   148k|    return ch;
 4971|       |
 4972|   148k|} /* end s_mp_todigit() */