The LibTom license

This is free and unencumbered software released into the public domain.


Anyone is free to copy, modify, publish, use, compile, sell, or
distribute this software, either in source code form or as a compiled
binary, for any purpose, commercial or non-commercial, and by any
means.

In jurisdictions that recognize copyright laws, the author or authors
of this software dedicate any and all copyright interest in the
software to the public domain. We make this dedication for the benefit
of the public at large and to the detriment of our heirs and
successors. We intend this dedication to be an overt act of


relinquishment in perpetuity of all present and future rights to this
software under copyright law.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.



For more information, please refer to <http://unlicense.org/>

#include "tommath_private.h"
#ifdef BN_ERROR_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

static const struct {
   int code;
   const char *msg;
} msgs[] = {
   { MP_OKAY, "Successful" },

#include "tommath_private.h"
#ifdef BN_FAST_MP_INVMOD_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* computes the modular inverse via binary extended euclidean algorithm,
 * that is c = 1/a mod b
 *
 * Based on slow invmod except this is optimized for the case where b is
 * odd as per HAC Note 14.64 on pp. 610

#include "tommath_private.h"
#ifdef BN_FAST_MP_MONTGOMERY_REDUCE_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* computes xR**-1 == x (mod N) via Montgomery Reduction
 *
 * This is an optimized implementation of montgomery_reduce
 * which uses the comba method to quickly calculate the columns of the
 * reduction.

#include "tommath_private.h"
#ifdef BN_FAST_S_MP_MUL_DIGS_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* Fast (comba) multiplier
 *
 * This is the fast column-array [comba] multiplier.  It is
 * designed to compute the columns of the product first
 * then handle the carries afterwards.  This has the effect

#include "tommath_private.h"
#ifdef BN_FAST_S_MP_MUL_HIGH_DIGS_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* this is a modified version of fast_s_mul_digs that only produces
 * output digits *above* digs.  See the comments for fast_s_mul_digs
 * to see how it works.
 *
 * This is used in the Barrett reduction since for one of the multiplications

#include "tommath_private.h"
#ifdef BN_FAST_S_MP_SQR_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* the jist of squaring...
 * you do like mult except the offset of the tmpx [one that
 * starts closer to zero] can't equal the offset of tmpy.
 * So basically you set up iy like before then you min it with
 * (ty-tx) so that it never happens.  You double all those

#include "tommath_private.h"
#ifdef BN_MP_2EXPT_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* computes a = 2**b
 *
 * Simple algorithm which zeroes the int, grows it then just sets one bit
 * as required.
 */

#include "tommath_private.h"
#ifdef BN_MP_ABS_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* b = |a|
 *
 * Simple function copies the input and fixes the sign to positive
 */
int mp_abs(const mp_int *a, mp_int *b)

#include "tommath_private.h"
#ifdef BN_MP_ADD_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* high level addition (handles signs) */
int mp_add(const mp_int *a, const mp_int *b, mp_int *c)
{
   int     sa, sb, res;

#include "tommath_private.h"
#ifdef BN_MP_ADD_D_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* single digit addition */
int mp_add_d(const mp_int *a, mp_digit b, mp_int *c)
{
   int     res, ix, oldused;
   mp_digit *tmpa, *tmpc, mu;

#include "tommath_private.h"
#ifdef BN_MP_ADDMOD_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* d = a + b (mod c) */
int mp_addmod(const mp_int *a, const mp_int *b, const mp_int *c, mp_int *d)
{
   int     res;
   mp_int  t;

#include "tommath_private.h"
#ifdef BN_MP_AND_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* AND two ints together */
int mp_and(const mp_int *a, const mp_int *b, mp_int *c)
{
   int     res, ix, px;
   mp_int  t;

#include "tommath_private.h"
#ifdef BN_MP_CLAMP_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* trim unused digits
 *
 * This is used to ensure that leading zero digits are
 * trimed and the leading "used" digit will be non-zero
 * Typically very fast.  Also fixes the sign if there

#include "tommath_private.h"
#ifdef BN_MP_CLEAR_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* clear one (frees)  */
void mp_clear(mp_int *a)
{
   int i;

#include "tommath_private.h"
#ifdef BN_MP_CLEAR_MULTI_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

#include <stdarg.h>

void mp_clear_multi(mp_int *mp, ...)
{
   mp_int *next_mp = mp;

#include "tommath_private.h"
#ifdef BN_MP_CMP_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* compare two ints (signed)*/
int mp_cmp(const mp_int *a, const mp_int *b)
{
   /* compare based on sign */
   if (a->sign != b->sign) {

#include "tommath_private.h"
#ifdef BN_MP_CMP_D_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* compare a digit */
int mp_cmp_d(const mp_int *a, mp_digit b)
{
   /* compare based on sign */
   if (a->sign == MP_NEG) {

#include "tommath_private.h"
#ifdef BN_MP_CMP_MAG_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* compare maginitude of two ints (unsigned) */
int mp_cmp_mag(const mp_int *a, const mp_int *b)
{
   int     n;
   mp_digit *tmpa, *tmpb;

#include "tommath_private.h"
#ifdef BN_MP_CNT_LSB_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

static const int lnz[16] = {
   4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0
};

/* Counts the number of lsbs which are zero before the first zero bit */

#include "tommath_private.h"
#ifdef BN_MP_COMPLEMENT_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* b = ~a */
int mp_complement(const mp_int *a, mp_int *b)
{
   int res = mp_neg(a, b);
   return (res == MP_OKAY) ? mp_sub_d(b, 1uL, b) : res;

#include "tommath_private.h"
#ifdef BN_MP_COPY_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* copy, b = a */
int mp_copy(const mp_int *a, mp_int *b)
{
   int     res, n;

#include "tommath_private.h"
#ifdef BN_MP_COUNT_BITS_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* returns the number of bits in an int */
int mp_count_bits(const mp_int *a)
{
   int     r;
   mp_digit q;

#include "tommath_private.h"
#ifdef BN_MP_DIV_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

#ifdef BN_MP_DIV_SMALL

/* slower bit-bang division... also smaller */
int mp_div(const mp_int *a, const mp_int *b, mp_int *c, mp_int *d)
{

#include "tommath_private.h"
#ifdef BN_MP_DIV_2_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* b = a/2 */
int mp_div_2(const mp_int *a, mp_int *b)
{
   int     x, res, oldused;

#include "tommath_private.h"
#ifdef BN_MP_DIV_2D_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* shift right by a certain bit count (store quotient in c, optional remainder in d) */
int mp_div_2d(const mp_int *a, int b, mp_int *c, mp_int *d)
{
   mp_digit D, r, rr;
   int     x, res;

#include "tommath_private.h"
#ifdef BN_MP_DIV_3_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* divide by three (based on routine from MPI and the GMP manual) */
int mp_div_3(const mp_int *a, mp_int *c, mp_digit *d)
{
   mp_int   q;
   mp_word  w, t;

#include "tommath_private.h"
#ifdef BN_MP_DIV_D_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

static int s_is_power_of_two(mp_digit b, int *p)
{
   int x;

   /* fast return if no power of two */

#include "tommath_private.h"
#ifdef BN_MP_DR_IS_MODULUS_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* determines if a number is a valid DR modulus */
int mp_dr_is_modulus(const mp_int *a)
{
   int ix;

#include "tommath_private.h"
#ifdef BN_MP_DR_REDUCE_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* reduce "x" in place modulo "n" using the Diminished Radix algorithm.
 *
 * Based on algorithm from the paper
 *
 * "Generating Efficient Primes for Discrete Log Cryptosystems"

#include "tommath_private.h"
#ifdef BN_MP_DR_SETUP_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* determines the setup value */
void mp_dr_setup(const mp_int *a, mp_digit *d)
{
   /* the casts are required if DIGIT_BIT is one less than
    * the number of bits in a mp_digit [e.g. DIGIT_BIT==31]

#include "tommath_private.h"
#ifdef BN_MP_EXCH_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* swap the elements of two integers, for cases where you can't simply swap the
 * mp_int pointers around
 */
void mp_exch(mp_int *a, mp_int *b)
{

#include "tommath_private.h"
#ifdef BN_MP_EXPORT_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* based on gmp's mpz_export.
 * see http://gmplib.org/manual/Integer-Import-and-Export.html
 */
int mp_export(void *rop, size_t *countp, int order, size_t size,
              int endian, size_t nails, const mp_int *op)

#include "tommath_private.h"
#ifdef BN_MP_EXPT_D_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* wrapper function for mp_expt_d_ex() */
int mp_expt_d(const mp_int *a, mp_digit b, mp_int *c)
{
   return mp_expt_d_ex(a, b, c, 0);
}

#include "tommath_private.h"
#ifdef BN_MP_EXPT_D_EX_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* calculate c = a**b  using a square-multiply algorithm */
int mp_expt_d_ex(const mp_int *a, mp_digit b, mp_int *c, int fast)
{
   int     res;
   unsigned int x;

#include "tommath_private.h"
#ifdef BN_MP_EXPTMOD_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */


/* this is a shell function that calls either the normal or Montgomery
 * exptmod functions.  Originally the call to the montgomery code was
 * embedded in the normal function but that wasted alot of stack space
 * for nothing (since 99% of the time the Montgomery code would be called)

#include "tommath_private.h"
#ifdef BN_MP_EXPTMOD_FAST_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* computes Y == G**X mod P, HAC pp.616, Algorithm 14.85
 *
 * Uses a left-to-right k-ary sliding window to compute the modular exponentiation.
 * The value of k changes based on the size of the exponent.
 *

      mp_set(&res, 1uL);
      if ((err = mp_mod(G, P, &M[1])) != MP_OKAY) {
         goto LBL_RES;
      }
   }

   /* compute the value at M[1<<(winsize-1)] by squaring M[1] (winsize-1) times */
   if ((err = mp_copy(&M[1], &M[(size_t)1 << (winsize - 1)])) != MP_OKAY) {
      goto LBL_RES;
   }

   for (x = 0; x < (winsize - 1); x++) {
      if ((err = mp_sqr(&M[(size_t)1 << (winsize - 1)], &M[(size_t)1 << (winsize - 1)])) != MP_OKAY) {
         goto LBL_RES;
      }
      if ((err = redux(&M[(size_t)1 << (winsize - 1)], P, mp)) != MP_OKAY) {
         goto LBL_RES;
      }
   }

   /* create upper table */
   for (x = (1 << (winsize - 1)) + 1; x < (1 << winsize); x++) {
      if ((err = mp_mul(&M[x - 1], &M[1], &M[x])) != MP_OKAY) {

#include "tommath_private.h"
#ifdef BN_MP_EXTEUCLID_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* Extended euclidean algorithm of (a, b) produces
   a*u1 + b*u2 = u3
 */
int mp_exteuclid(const mp_int *a, const mp_int *b, mp_int *U1, mp_int *U2, mp_int *U3)
{

#include "tommath_private.h"
#ifdef BN_MP_FREAD_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

#ifndef LTM_NO_FILE
/* read a bigint from a file stream in ASCII */
int mp_fread(mp_int *a, int radix, FILE *stream)
{
   int err, ch, neg, y;

#include "tommath_private.h"
#ifdef BN_MP_FWRITE_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

#ifndef LTM_NO_FILE
int mp_fwrite(const mp_int *a, int radix, FILE *stream)
{
   char *buf;
   int err, len, x;

#include "tommath_private.h"
#ifdef BN_MP_GCD_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* Greatest Common Divisor using the binary method */
int mp_gcd(const mp_int *a, const mp_int *b, mp_int *c)
{
   mp_int  u, v;
   int     k, u_lsb, v_lsb, res;

#include "tommath_private.h"
#ifdef BN_MP_GET_BIT_C

/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense
 */

/* Checks the bit at position b and returns MP_YES
   if the bit is 1, MP_NO if it is 0 and MP_VAL
   in case of error */
int mp_get_bit(const mp_int *a, int b)
{
   int limb;
   mp_digit bit, isset;

   if (b < 0) {
      return MP_VAL;
   }

   limb = b / DIGIT_BIT;

   /*
    * Zero is a special value with the member "used" set to zero.
    * Needs to be tested before the check for the upper boundary
    * otherwise (limb >= a->used) would be true for a = 0
    */

   if (mp_iszero(a) != MP_NO) {
      return MP_NO;
   }

   if (limb >= a->used) {
      return MP_VAL;
   }

   bit = (mp_digit)(1) << (b % DIGIT_BIT);

   isset = a->dp[limb] & bit;
   return (isset != 0u) ? MP_YES : MP_NO;
}

#endif

/* ref:         $Format:%D$ */
/* git commit:  $Format:%H$ */
/* commit time: $Format:%ai$ */

#include "tommath_private.h"
#ifdef BN_MP_GET_DOUBLE_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense
 */

double mp_get_double(const mp_int *a)
{
   int i;
   double d = 0.0, fac = 1.0;
   for (i = 0; i < DIGIT_BIT; ++i) {
      fac *= 2.0;
   }
   for (i = USED(a); i --> 0;) {
      d = (d * fac) + (double)DIGIT(a, i);
   }
   return (mp_isneg(a) != MP_NO) ? -d : d;
}
#endif

/* ref:         $Format:%D$ */
/* git commit:  $Format:%H$ */
/* commit time: $Format:%ai$ */

#include "tommath_private.h"
#ifdef BN_MP_GET_INT_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* get the lower 32-bits of an mp_int */
unsigned long mp_get_int(const mp_int *a)
{
   int i;
   mp_min_u32 res;

#include "tommath_private.h"
#ifdef BN_MP_GET_LONG_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* get the lower unsigned long of an mp_int, platform dependent */
unsigned long mp_get_long(const mp_int *a)
{
   int i;
   unsigned long res;

   while (--i >= 0) {
      res = (res << DIGIT_BIT) | DIGIT(a, i);
   }
#endif
   return res;
}
#endif

/* ref:         $Format:%D$ */
/* git commit:  $Format:%H$ */
/* commit time: $Format:%ai$ */

#include "tommath_private.h"
#ifdef BN_MP_GET_LONG_LONG_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* get the lower unsigned long long of an mp_int, platform dependent */
unsigned long long mp_get_long_long(const mp_int *a)
{
   int i;
   unsigned long long res;

   while (--i >= 0) {
      res = (res << DIGIT_BIT) | DIGIT(a, i);
   }
#endif
   return res;
}
#endif

/* ref:         $Format:%D$ */
/* git commit:  $Format:%H$ */
/* commit time: $Format:%ai$ */

#include "tommath_private.h"
#ifdef BN_MP_GROW_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* grow as required */
int mp_grow(mp_int *a, int size)
{
   int     i;
   mp_digit *tmp;

#include "tommath_private.h"
#ifdef BN_MP_IMPORT_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* based on gmp's mpz_import.
 * see http://gmplib.org/manual/Integer-Import-and-Export.html
 */
int mp_import(mp_int *rop, size_t count, int order, size_t size,
              int endian, size_t nails, const void *op)

#include "tommath_private.h"
#ifdef BN_MP_INIT_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* init a new mp_int */
int mp_init(mp_int *a)
{
   int i;

#include "tommath_private.h"
#ifdef BN_MP_INIT_COPY_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* creates "a" then copies b into it */
int mp_init_copy(mp_int *a, const mp_int *b)
{
   int     res;

#include "tommath_private.h"
#ifdef BN_MP_INIT_MULTI_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

#include <stdarg.h>

int mp_init_multi(mp_int *mp, ...)
{
   mp_err res = MP_OKAY;      /* Assume ok until proven otherwise */

#include "tommath_private.h"
#ifdef BN_MP_INIT_SET_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* initialize and set a digit */
int mp_init_set(mp_int *a, mp_digit b)
{
   int err;
   if ((err = mp_init(a)) != MP_OKAY) {

#include "tommath_private.h"
#ifdef BN_MP_INIT_SET_INT_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* initialize and set a digit */
int mp_init_set_int(mp_int *a, unsigned long b)
{
   int err;
   if ((err = mp_init(a)) != MP_OKAY) {

#include "tommath_private.h"
#ifdef BN_MP_INIT_SIZE_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* init an mp_init for a given size */
int mp_init_size(mp_int *a, int size)
{
   int x;

#include "tommath_private.h"
#ifdef BN_MP_INVMOD_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* hac 14.61, pp608 */
int mp_invmod(const mp_int *a, const mp_int *b, mp_int *c)
{
   /* b cannot be negative and has to be >1 */
   if ((b->sign == MP_NEG) || (mp_cmp_d(b, 1uL) != MP_GT)) {

#include "tommath_private.h"
#ifdef BN_MP_INVMOD_SLOW_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* hac 14.61, pp608 */
int mp_invmod_slow(const mp_int *a, const mp_int *b, mp_int *c)
{
   mp_int  x, y, u, v, A, B, C, D;
   int     res;

#include "tommath_private.h"
#ifdef BN_MP_IS_SQUARE_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* Check if remainders are possible squares - fast exclude non-squares */
static const char rem_128[128] = {
   0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,
   0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,
   1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,

#include "tommath_private.h"
#ifdef BN_MP_JACOBI_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* computes the jacobi c = (a | n) (or Legendre if n is prime)
 * Kept for legacy reasons, please use mp_kronecker() instead


 */
int mp_jacobi(const mp_int *a, const mp_int *n, int *c)
{




   /* if a < 0 return MP_VAL */
   if (mp_isneg(a) == MP_YES) {
      return MP_VAL;
   }

   /* if n <= 0 return MP_VAL */
   if (mp_cmp_d(n, 0uL) != MP_GT) {
      return MP_VAL;
   }























   return mp_kronecker(a, n, c);




















































}
#endif

/* ref:         $Format:%D$ */
/* git commit:  $Format:%H$ */
/* commit time: $Format:%ai$ */

#include "tommath_private.h"
#ifdef BN_MP_KARATSUBA_MUL_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* c = |a| * |b| using Karatsuba Multiplication using
 * three half size multiplications
 *
 * Let B represent the radix [e.g. 2**DIGIT_BIT] and
 * let n represent half of the number of digits in

#include "tommath_private.h"
#ifdef BN_MP_KARATSUBA_SQR_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* Karatsuba squaring, computes b = a*a using three
 * half size squarings
 *
 * See comments of karatsuba_mul for details.  It
 * is essentially the same algorithm but merely

#include "tommath_private.h"
#ifdef BN_MP_KRONECKER_C

/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense
 */

/*
   Kronecker symbol (a|p)
   Straightforward implementation of algorithm 1.4.10 in
   Henri Cohen: "A Course in Computational Algebraic Number Theory"

   @book{cohen2013course,
     title={A course in computational algebraic number theory},
     author={Cohen, Henri},
     volume={138},
     year={2013},
     publisher={Springer Science \& Business Media}
    }
 */
int mp_kronecker(const mp_int *a, const mp_int *p, int *c)
{
   mp_int a1, p1, r;

   int e = MP_OKAY;
   int v, k;

   static const int table[8] = {0, 1, 0, -1, 0, -1, 0, 1};

   if (mp_iszero(p) != MP_NO) {
      if ((a->used == 1) && (a->dp[0] == 1u)) {
         *c = 1;
         return e;
      } else {
         *c = 0;
         return e;
      }
   }

   if ((mp_iseven(a) != MP_NO) && (mp_iseven(p) != MP_NO)) {
      *c = 0;
      return e;
   }

   if ((e = mp_init_copy(&a1, a)) != MP_OKAY) {
      return e;
   }
   if ((e = mp_init_copy(&p1, p)) != MP_OKAY) {
      goto LBL_KRON_0;
   }

   v = mp_cnt_lsb(&p1);
   if ((e = mp_div_2d(&p1, v, &p1, NULL)) != MP_OKAY) {
      goto LBL_KRON_1;
   }

   if ((v & 0x1) == 0) {
      k = 1;
   } else {
      k = table[a->dp[0] & 7u];
   }

   if (p1.sign == MP_NEG) {
      p1.sign = MP_ZPOS;
      if (a1.sign == MP_NEG) {
         k = -k;
      }
   }

   if ((e = mp_init(&r)) != MP_OKAY) {
      goto LBL_KRON_1;
   }

   for (;;) {
      if (mp_iszero(&a1) != MP_NO) {
         if (mp_cmp_d(&p1, 1uL) == MP_EQ) {
            *c = k;
            goto LBL_KRON;
         } else {
            *c = 0;
            goto LBL_KRON;
         }
      }

      v = mp_cnt_lsb(&a1);
      if ((e = mp_div_2d(&a1, v, &a1, NULL)) != MP_OKAY) {
         goto LBL_KRON;
      }

      if ((v & 0x1) == 1) {
         k = k * table[p1.dp[0] & 7u];
      }

      if (a1.sign == MP_NEG) {
         /*
          * Compute k = (-1)^((a1)*(p1-1)/4) * k
          * a1.dp[0] + 1 cannot overflow because the MSB
          * of the type mp_digit is not set by definition
          */
         if (((a1.dp[0] + 1u) & p1.dp[0] & 2u) != 0u) {
            k = -k;
         }
      } else {
         /* compute k = (-1)^((a1-1)*(p1-1)/4) * k */
         if ((a1.dp[0] & p1.dp[0] & 2u) != 0u) {
            k = -k;
         }
      }

      if ((e = mp_copy(&a1, &r)) != MP_OKAY) {
         goto LBL_KRON;
      }
      r.sign = MP_ZPOS;
      if ((e = mp_mod(&p1, &r, &a1)) != MP_OKAY) {
         goto LBL_KRON;
      }
      if ((e = mp_copy(&r, &p1)) != MP_OKAY) {
         goto LBL_KRON;
      }
   }

LBL_KRON:
   mp_clear(&r);
LBL_KRON_1:
   mp_clear(&p1);
LBL_KRON_0:
   mp_clear(&a1);

   return e;
}

#endif

/* ref:         $Format:%D$ */
/* git commit:  $Format:%H$ */
/* commit time: $Format:%ai$ */

#include "tommath_private.h"
#ifdef BN_MP_LCM_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* computes least common multiple as |a*b|/(a, b) */
int mp_lcm(const mp_int *a, const mp_int *b, mp_int *c)
{
   int     res;
   mp_int  t1, t2;

#include "tommath_private.h"
#ifdef BN_MP_LSHD_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* shift left a certain amount of digits */
int mp_lshd(mp_int *a, int b)
{
   int     x, res;

#include "tommath_private.h"
#ifdef BN_MP_MOD_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* c = a mod b, 0 <= c < b if b > 0, b < c <= 0 if b < 0 */
int mp_mod(const mp_int *a, const mp_int *b, mp_int *c)
{
   mp_int  t;
   int     res;

#include "tommath_private.h"
#ifdef BN_MP_MOD_2D_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* calc a value mod 2**b */
int mp_mod_2d(const mp_int *a, int b, mp_int *c)
{
   int     x, res;

#include "tommath_private.h"
#ifdef BN_MP_MOD_D_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

int mp_mod_d(const mp_int *a, mp_digit b, mp_digit *c)
{
   return mp_div_d(a, b, NULL, c);
}
#endif

#include "tommath_private.h"
#ifdef BN_MP_MONTGOMERY_CALC_NORMALIZATION_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/*
 * shifts with subtractions when the result is greater than b.
 *
 * The method is slightly modified to shift B unconditionally upto just under
 * the leading bit of b.  This saves alot of multiple precision shifting.

#include "tommath_private.h"
#ifdef BN_MP_MONTGOMERY_REDUCE_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* computes xR**-1 == x (mod N) via Montgomery Reduction */
int mp_montgomery_reduce(mp_int *x, const mp_int *n, mp_digit rho)
{
   int     ix, res, digs;
   mp_digit mu;

#include "tommath_private.h"
#ifdef BN_MP_MONTGOMERY_SETUP_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* setups the montgomery reduction stuff */
int mp_montgomery_setup(const mp_int *n, mp_digit *rho)
{
   mp_digit x, b;

#include "tommath_private.h"
#ifdef BN_MP_MUL_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* high level multiplication (handles sign) */
int mp_mul(const mp_int *a, const mp_int *b, mp_int *c)
{
   int     res, neg;
   neg = (a->sign == b->sign) ? MP_ZPOS : MP_NEG;

#include "tommath_private.h"
#ifdef BN_MP_MUL_2_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* b = a*2 */
int mp_mul_2(const mp_int *a, mp_int *b)
{
   int     x, res, oldused;

#include "tommath_private.h"
#ifdef BN_MP_MUL_2D_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* shift left by a certain bit count */
int mp_mul_2d(const mp_int *a, int b, mp_int *c)
{
   mp_digit d;
   int      res;

#include "tommath_private.h"
#ifdef BN_MP_MUL_D_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* multiply by a digit */
int mp_mul_d(const mp_int *a, mp_digit b, mp_int *c)
{
   mp_digit u, *tmpa, *tmpc;
   mp_word  r;

#include "tommath_private.h"
#ifdef BN_MP_MULMOD_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* d = a * b (mod c) */
int mp_mulmod(const mp_int *a, const mp_int *b, const mp_int *c, mp_int *d)
{
   int     res;
   mp_int  t;

#include "tommath_private.h"
#ifdef BN_MP_N_ROOT_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* wrapper function for mp_n_root_ex()
 * computes c = (a)**(1/b) such that (c)**b <= a and (c+1)**b > a
 */
int mp_n_root(const mp_int *a, mp_digit b, mp_int *c)
{

#include "tommath_private.h"
#ifdef BN_MP_N_ROOT_EX_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* find the n'th root of an integer
 *
 * Result found such that (c)**b <= a and (c+1)**b > a
 *
 * This algorithm uses Newton's approximation

#include "tommath_private.h"
#ifdef BN_MP_NEG_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* b = -a */
int mp_neg(const mp_int *a, mp_int *b)
{
   int     res;
   if (a != b) {

#include "tommath_private.h"
#ifdef BN_MP_OR_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* OR two ints together */
int mp_or(const mp_int *a, const mp_int *b, mp_int *c)
{
   int     res, ix, px;
   mp_int  t;

#include "tommath_private.h"
#ifdef BN_MP_PRIME_FERMAT_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* performs one Fermat test.
 *
 * If "a" were prime then b**a == b (mod a) since the order of
 * the multiplicative sub-group would be phi(a) = a-1.  That means
 * it would be the same as b**(a mod (a-1)) == b**1 == b (mod a).

#include "tommath_private.h"
#ifdef BN_MP_PRIME_FROBENIUS_UNDERWOOD_C

/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense
 */

/*
 *  See file bn_mp_prime_is_prime.c or the documentation in doc/bn.tex for the details
 */
#ifndef LTM_USE_FIPS_ONLY

#ifdef MP_8BIT
/*
 * floor of positive solution of
 * (2^16)-1 = (a+4)*(2*a+5)
 * TODO: Both values are smaller than N^(1/4), would have to use a bigint
 *       for a instead but any a biger than about 120 are already so rare that
 *       it is possible to ignore them and still get enough pseudoprimes.
 *       But it is still a restriction of the set of available pseudoprimes
 *       which makes this implementation less secure if used stand-alone.
 */
#define LTM_FROBENIUS_UNDERWOOD_A 177
#else
#define LTM_FROBENIUS_UNDERWOOD_A 32764
#endif
int mp_prime_frobenius_underwood(const mp_int *N, int *result)
{
   mp_int T1z, T2z, Np1z, sz, tz;

   int a, ap2, length, i, j, isset;
   int e;

   *result = MP_NO;

   if ((e = mp_init_multi(&T1z, &T2z, &Np1z, &sz, &tz, NULL)) != MP_OKAY) {
      return e;
   }

   for (a = 0; a < LTM_FROBENIUS_UNDERWOOD_A; a++) {
      /* TODO: That's ugly! No, really, it is! */
      if ((a==2) || (a==4) || (a==7) || (a==8) || (a==10) ||
          (a==14) || (a==18) || (a==23) || (a==26) || (a==28)) {
         continue;
      }
      /* (32764^2 - 4) < 2^31, no bigint for >MP_8BIT needed) */
      if ((e = mp_set_long(&T1z, (unsigned long)a)) != MP_OKAY) {
         goto LBL_FU_ERR;
      }

      if ((e = mp_sqr(&T1z, &T1z)) != MP_OKAY) {
         goto LBL_FU_ERR;
      }

      if ((e = mp_sub_d(&T1z, 4uL, &T1z)) != MP_OKAY) {
         goto LBL_FU_ERR;
      }

      if ((e = mp_kronecker(&T1z, N, &j)) != MP_OKAY) {
         goto LBL_FU_ERR;
      }

      if (j == -1) {
         break;
      }

      if (j == 0) {
         /* composite */
         goto LBL_FU_ERR;
      }
   }
   /* Tell it a composite and set return value accordingly */
   if (a >= LTM_FROBENIUS_UNDERWOOD_A) {
      e = MP_ITER;
      goto LBL_FU_ERR;
   }
   /* Composite if N and (a+4)*(2*a+5) are not coprime */
   if ((e = mp_set_long(&T1z, (unsigned long)((a+4)*((2*a)+5)))) != MP_OKAY) {
      goto LBL_FU_ERR;
   }

   if ((e = mp_gcd(N, &T1z, &T1z)) != MP_OKAY) {
      goto LBL_FU_ERR;
   }

   if (!((T1z.used == 1) && (T1z.dp[0] == 1u))) {
      goto LBL_FU_ERR;
   }

   ap2 = a + 2;
   if ((e = mp_add_d(N, 1uL, &Np1z)) != MP_OKAY) {
      goto LBL_FU_ERR;
   }

   mp_set(&sz, 1uL);
   mp_set(&tz, 2uL);
   length = mp_count_bits(&Np1z);

   for (i = length - 2; i >= 0; i--) {
      /*
       * temp = (sz*(a*sz+2*tz))%N;
       * tz   = ((tz-sz)*(tz+sz))%N;
       * sz   = temp;
       */
      if ((e = mp_mul_2(&tz, &T2z)) != MP_OKAY) {
         goto LBL_FU_ERR;
      }

      /* a = 0 at about 50% of the cases (non-square and odd input) */
      if (a != 0) {
         if ((e = mp_mul_d(&sz, (mp_digit)a, &T1z)) != MP_OKAY) {
            goto LBL_FU_ERR;
         }
         if ((e = mp_add(&T1z, &T2z, &T2z)) != MP_OKAY) {
            goto LBL_FU_ERR;
         }
      }

      if ((e = mp_mul(&T2z, &sz, &T1z)) != MP_OKAY) {
         goto LBL_FU_ERR;
      }
      if ((e = mp_sub(&tz, &sz, &T2z)) != MP_OKAY) {
         goto LBL_FU_ERR;
      }
      if ((e = mp_add(&sz, &tz, &sz)) != MP_OKAY) {
         goto LBL_FU_ERR;
      }
      if ((e = mp_mul(&sz, &T2z, &tz)) != MP_OKAY) {
         goto LBL_FU_ERR;
      }
      if ((e = mp_mod(&tz, N, &tz)) != MP_OKAY) {
         goto LBL_FU_ERR;
      }
      if ((e = mp_mod(&T1z, N, &sz)) != MP_OKAY) {
         goto LBL_FU_ERR;
      }
      if ((isset = mp_get_bit(&Np1z, i)) == MP_VAL) {
         e = isset;
         goto LBL_FU_ERR;
      }
      if (isset == MP_YES) {
         /*
          *  temp = (a+2) * sz + tz
          *  tz   = 2 * tz - sz
          *  sz   = temp
          */
         if (a == 0) {
            if ((e = mp_mul_2(&sz, &T1z)) != MP_OKAY) {
               goto LBL_FU_ERR;
            }
         } else {
            if ((e = mp_mul_d(&sz, (mp_digit)ap2, &T1z)) != MP_OKAY) {
               goto LBL_FU_ERR;
            }
         }
         if ((e = mp_add(&T1z, &tz, &T1z)) != MP_OKAY) {
            goto LBL_FU_ERR;
         }
         if ((e = mp_mul_2(&tz, &T2z)) != MP_OKAY) {
            goto LBL_FU_ERR;
         }
         if ((e = mp_sub(&T2z, &sz, &tz)) != MP_OKAY) {
            goto LBL_FU_ERR;
         }
         mp_exch(&sz, &T1z);
      }
   }

   if ((e = mp_set_long(&T1z, (unsigned long)((2 * a) + 5))) != MP_OKAY) {
      goto LBL_FU_ERR;
   }
   if ((e = mp_mod(&T1z, N, &T1z)) != MP_OKAY) {
      goto LBL_FU_ERR;
   }
   if ((mp_iszero(&sz) != MP_NO) && (mp_cmp(&tz, &T1z) == MP_EQ)) {
      *result = MP_YES;
      goto LBL_FU_ERR;
   }

LBL_FU_ERR:
   mp_clear_multi(&tz, &sz, &Np1z, &T2z, &T1z, NULL);
   return e;
}

#endif
#endif

/* ref:         $Format:%D$ */
/* git commit:  $Format:%H$ */
/* commit time: $Format:%ai$ */

#include "tommath_private.h"
#ifdef BN_MP_PRIME_IS_DIVISIBLE_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* determines if an integers is divisible by one
 * of the first PRIME_SIZE primes or not
 *
 * sets result to 0 if not, 1 if yes
 */

#include "tommath_private.h"
#ifdef BN_MP_PRIME_IS_PRIME_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* portable integer log of two with small footprint */
static unsigned int s_floor_ilog2(int value)

{
   unsigned int r = 0;
   while ((value >>= 1) != 0) {
      r++;
   }
   return r;
}



int mp_prime_is_prime(const mp_int *a, int t, int *result)
{
   mp_int  b;
   int     ix, err, res, p_max = 0, size_a, len;
   unsigned int fips_rand, mask;

   /* default to no */
   *result = MP_NO;

   /* valid value of t? */
   if (t > PRIME_SIZE) {
      return MP_VAL;
   }

   /* Some shortcuts */
   /* N > 3 */
   if (a->used == 1) {
      if ((a->dp[0] == 0u) || (a->dp[0] == 1u)) {
         *result = 0;
         return MP_OKAY;
      }
      if (a->dp[0] == 2u) {
         *result = 1;
         return MP_OKAY;
      }
   }

   /* N must be odd */
   if (mp_iseven(a) == MP_YES) {
      return MP_OKAY;
   }
   /* N is not a perfect square: floor(sqrt(N))^2 != N */
   if ((err = mp_is_square(a, &res)) != MP_OKAY) {
      return err;
   }
   if (res != 0) {
      return MP_OKAY;
   }

   /* is the input equal to one of the primes in the table? */
   for (ix = 0; ix < PRIME_SIZE; ix++) {
      if (mp_cmp_d(a, ltm_prime_tab[ix]) == MP_EQ) {
         *result = MP_YES;
         return MP_OKAY;
      }
   }
#ifdef MP_8BIT
   /* The search in the loop above was exhaustive in this case */
   if (a->used == 1 && PRIME_SIZE >= 31) {
      return MP_OKAY;
   }
#endif

   /* first perform trial division */
   if ((err = mp_prime_is_divisible(a, &res)) != MP_OKAY) {
      return err;
   }

   /* return if it was trivially divisible */
   if (res == MP_YES) {
      return MP_OKAY;
   }

   /*
       Run the Miller-Rabin test with base 2 for the BPSW test.
    */
   if ((err = mp_init_set(&b, 2uL)) != MP_OKAY) {
      return err;
   }



   if ((err = mp_prime_miller_rabin(a, &b, &res)) != MP_OKAY) {
      goto LBL_B;
   }
   if (res == MP_NO) {
      goto LBL_B;
   }
   /*
      Rumours have it that Mathematica does a second M-R test with base 3.
      Other rumours have it that their strong L-S test is slightly different.
      It does not hurt, though, beside a bit of extra runtime.
   */
   b.dp[0]++;
   if ((err = mp_prime_miller_rabin(a, &b, &res)) != MP_OKAY) {
      goto LBL_B;
   }
   if (res == MP_NO) {
      goto LBL_B;
   }

   /*
    * Both, the Frobenius-Underwood test and the the Lucas-Selfridge test are quite
    * slow so if speed is an issue, define LTM_USE_FIPS_ONLY to use M-R tests with
    * bases 2, 3 and t random bases.
    */
#ifndef LTM_USE_FIPS_ONLY
   if (t >= 0) {
      /*
       * Use a Frobenius-Underwood test instead of the Lucas-Selfridge test for
       * MP_8BIT (It is unknown if the Lucas-Selfridge test works with 16-bit
       * integers but the necesssary analysis is on the todo-list).
       */
#if defined (MP_8BIT) || defined (LTM_USE_FROBENIUS_TEST)
      err = mp_prime_frobenius_underwood(a, &res);
      if (err != MP_OKAY && err != MP_ITER) {
         goto LBL_B;
      }
      if (res == MP_NO) {
         goto LBL_B;
      }
#else
      if ((err = mp_prime_strong_lucas_selfridge(a, &res)) != MP_OKAY) {
         goto LBL_B;
      }
      if (res == MP_NO) {
         goto LBL_B;
      }
#endif
   }
#endif

   /* run at least one Miller-Rabin test with a random base */
   if (t == 0) {
      t = 1;
   }

   /*
      abs(t) extra rounds of M-R to extend the range of primes it can find if t < 0.
      Only recommended if the input range is known to be < 3317044064679887385961981

      It uses the bases for a deterministic M-R test if input < 3317044064679887385961981
      The caller has to check the size.

      Not for cryptographic use because with known bases strong M-R pseudoprimes can
      be constructed. Use at least one M-R test with a random base (t >= 1).

      The 1119 bit large number

      80383745745363949125707961434194210813883768828755814583748891752229742737653\
      33652186502336163960045457915042023603208766569966760987284043965408232928738\
      79185086916685732826776177102938969773947016708230428687109997439976544144845\
      34115587245063340927902227529622941498423068816854043264575340183297861112989\
      60644845216191652872597534901

      has been constructed by F. Arnault (F. Arnault, "Rabin-Miller primality test:
      composite numbers which pass it.",  Mathematics of Computation, 1995, 64. Jg.,
      Nr. 209, S. 355-361), is a semiprime with the two factors

      40095821663949960541830645208454685300518816604113250877450620473800321707011\
      96242716223191597219733582163165085358166969145233813917169287527980445796800\
      452592031836601

      20047910831974980270915322604227342650259408302056625438725310236900160853505\
      98121358111595798609866791081582542679083484572616906958584643763990222898400\
      226296015918301

      and it is a strong pseudoprime to all forty-six prime M-R bases up to 200

      It does not fail the strong Bailley-PSP test as implemented here, it is just
      given as an example, if not the reason to use the BPSW-test instead of M-R-tests
      with a sequence of primes 2...n.

   */
   if (t < 0) {
      t = -t;
      /*
          Sorenson, Jonathan; Webster, Jonathan (2015).
           "Strong Pseudoprimes to Twelve Prime Bases".
       */
      /* 0x437ae92817f9fc85b7e5 = 318665857834031151167461 */
      if ((err =   mp_read_radix(&b, "437ae92817f9fc85b7e5", 16)) != MP_OKAY) {
         goto LBL_B;
      }

      if (mp_cmp(a, &b) == MP_LT) {
         p_max = 12;
      } else {
         /* 0x2be6951adc5b22410a5fd = 3317044064679887385961981 */
         if ((err = mp_read_radix(&b, "2be6951adc5b22410a5fd", 16)) != MP_OKAY) {
            goto LBL_B;
         }

         if (mp_cmp(a, &b) == MP_LT) {
            p_max = 13;
         } else {
            err = MP_VAL;
            goto LBL_B;
         }
      }

      /* for compatibility with the current API (well, compatible within a sign's width) */
      if (p_max < t) {
         p_max = t;
      }

      if (p_max > PRIME_SIZE) {
         err = MP_VAL;
         goto LBL_B;
      }
      /* we did bases 2 and 3  already, skip them */
      for (ix = 2; ix < p_max; ix++) {
         mp_set(&b, ltm_prime_tab[ix]);
         if ((err = mp_prime_miller_rabin(a, &b, &res)) != MP_OKAY) {
            goto LBL_B;
         }
         if (res == MP_NO) {
            goto LBL_B;
         }
      }
   }
   /*
       Do "t" M-R tests with random bases between 3 and "a".
       See Fips 186.4 p. 126ff
   */
   else if (t > 0) {
      /*
       * The mp_digit's have a defined bit-size but the size of the
       * array a.dp is a simple 'int' and this library can not assume full
       * compliance to the current C-standard (ISO/IEC 9899:2011) because
       * it gets used for small embeded processors, too. Some of those MCUs
       * have compilers that one cannot call standard compliant by any means.
       * Hence the ugly type-fiddling in the following code.
       */
      size_a = mp_count_bits(a);
      mask = (1u << s_floor_ilog2(size_a)) - 1u;
      /*
         Assuming the General Rieman hypothesis (never thought to write that in a
         comment) the upper bound can be lowered to  2*(log a)^2.
         E. Bach, "Explicit bounds for primality testing and related problems,"
         Math. Comp. 55 (1990), 355-380.

            size_a = (size_a/10) * 7;
            len = 2 * (size_a * size_a);

         E.g.: a number of size 2^2048 would be reduced to the upper limit

            floor(2048/10)*7 = 1428
            2 * 1428^2       = 4078368

         (would have been ~4030331.9962 with floats and natural log instead)
         That number is smaller than 2^28, the default bit-size of mp_digit.
      */

      /*
        How many tests, you might ask? Dana Jacobsen of Math::Prime::Util fame
        does exactly 1. In words: one. Look at the end of _GMP_is_prime() in
        Math-Prime-Util-GMP-0.50/primality.c if you do not believe it.

        The function mp_rand() goes to some length to use a cryptographically
        good PRNG. That also means that the chance to always get the same base
        in the loop is non-zero, although very low.
        If the BPSW test and/or the addtional Frobenious test have been
        performed instead of just the Miller-Rabin test with the bases 2 and 3,
        a single extra test should suffice, so such a very unlikely event
        will not do much harm.

        To preemptivly answer the dangling question: no, a witness does not
        need to be prime.
      */
      for (ix = 0; ix < t; ix++) {
         /* mp_rand() guarantees the first digit to be non-zero */
         if ((err = mp_rand(&b, 1)) != MP_OKAY) {
            goto LBL_B;
         }
         /*
          * Reduce digit before casting because mp_digit might be bigger than
          * an unsigned int and "mask" on the other side is most probably not.
          */
         fips_rand = (unsigned int)(b.dp[0] & (mp_digit) mask);
#ifdef MP_8BIT
         /*
          * One 8-bit digit is too small, so concatenate two if the size of
          * unsigned int allows for it.
          */
         if ((sizeof(unsigned int) * CHAR_BIT)/2 >= (sizeof(mp_digit) * CHAR_BIT)) {
            if ((err = mp_rand(&b, 1)) != MP_OKAY) {
               goto LBL_B;
            }
            fips_rand <<= sizeof(mp_digit) * CHAR_BIT;
            fips_rand |= (unsigned int) b.dp[0];
            fips_rand &= mask;
         }
#endif
         if (fips_rand > ((unsigned int) INT_MAX - DIGIT_BIT)) {
            len = INT_MAX / DIGIT_BIT;
         }
         else {
            len = (((int)fips_rand + DIGIT_BIT) / DIGIT_BIT);
         }
         /*  Unlikely. */
         if (len < 0) {
            ix--;
            continue;
         }
         /*
          * As mentioned above, one 8-bit digit is too small and
          * although it can only happen in the unlikely case that
          * an "unsigned int" is smaller than 16 bit a simple test
          * is cheap and the correction even cheaper.
          */
#ifdef MP_8BIT
         /* All "a" < 2^8 have been caught before */
         if (len == 1) {
            len++;
         }
#endif
         if ((err = mp_rand(&b, len)) != MP_OKAY) {
            goto LBL_B;
         }
         /*
          * That number might got too big and the witness has to be
          * smaller than or equal to "a"
          */
         len = mp_count_bits(&b);
         if (len > size_a) {
            len = len - size_a;
            if ((err = mp_div_2d(&b, len, &b, NULL)) != MP_OKAY) {
               goto LBL_B;
            }
         }

         /* Although the chance for b <= 3 is miniscule, try again. */
         if (mp_cmp_d(&b, 3uL) != MP_GT) {
            ix--;
            continue;
         }
         if ((err = mp_prime_miller_rabin(a, &b, &res)) != MP_OKAY) {
            goto LBL_B;
         }
         if (res == MP_NO) {
            goto LBL_B;
         }
      }
   }

   /* passed the test */
   *result = MP_YES;
LBL_B:
   mp_clear(&b);
   return err;
}

#endif

/* ref:         $Format:%D$ */
/* git commit:  $Format:%H$ */
/* commit time: $Format:%ai$ */

#include "tommath_private.h"
#ifdef BN_MP_PRIME_MILLER_RABIN_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* Miller-Rabin test of "a" to the base of "b" as described in
 * HAC pp. 139 Algorithm 4.24
 *
 * Sets result to 0 if definitely composite or 1 if probably prime.
 * Randomly the chance of error is no more than 1/4 and often

#include "tommath_private.h"
#ifdef BN_MP_PRIME_NEXT_PRIME_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* finds the next prime after the number "a" using "t" trials
 * of Miller-Rabin.
 *
 * bbs_style = 1 means the prime must be congruent to 3 mod 4
 */
int mp_prime_next_prime(mp_int *a, int t, int bbs_style)
{
   int      err, res = MP_NO, x, y;
   mp_digit res_tab[PRIME_SIZE], step, kstep;
   mp_int   b;






   /* force positive */
   a->sign = MP_ZPOS;

   /* simple algo if a is less than the largest prime in the table */
   if (mp_cmp_d(a, ltm_prime_tab[PRIME_SIZE-1]) == MP_LT) {
      /* find which prime it is bigger than */
      for (x = PRIME_SIZE - 2; x >= 0; x--) {

      }

      /* if didn't pass sieve and step == MAX then skip test */
      if ((y == 1) && (step >= (((mp_digit)1 << DIGIT_BIT) - kstep))) {
         continue;
      }




      if ((err = mp_prime_is_prime(a, t, &res)) != MP_OKAY) {
         goto LBL_ERR;
      }





      if (res == MP_YES) {
         break;
      }
   }

   err = MP_OKAY;
LBL_ERR:

#include "tommath_private.h"
#ifdef BN_MP_PRIME_RABIN_MILLER_TRIALS_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */


static const struct {
   int k, t;
} sizes[] = {
   {    80,    -1 }, /* Use deterministic algorithm for size <= 80 bits */
   {    81,    39 },
   {    96,    37 },
   {   128,    32 },
   {   160,    27 },
   {   192,    21 },
   {   256,    16 },
   {   384,    10 },
   {   512,     7 },
   {   640,     6 },
   {   768,     5 },
   {   896,     4 },
   {  1024,     4 },
   {  2048,     2 },
   {  4096,     1 },
};

/* returns # of RM trials required for a given bit size and max. error of 2^(-96)*/
int mp_prime_rabin_miller_trials(int size)
{
   int x;

   for (x = 0; x < (int)(sizeof(sizes)/(sizeof(sizes[0]))); x++) {
      if (sizes[x].k == size) {
         return sizes[x].t;

#include "tommath_private.h"
#ifdef BN_MP_PRIME_RANDOM_EX_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* makes a truly random prime of a given size (bits),
 *
 * Flags are as follows:
 *
 *   LTM_PRIME_BBS      - make prime congruent to 3 mod 4

#include "tommath_private.h"
#ifdef BN_MP_PRIME_STRONG_LUCAS_SELFRIDGE_C

/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense
 */

/*
 *  See file bn_mp_prime_is_prime.c or the documentation in doc/bn.tex for the details
 */
#ifndef LTM_USE_FIPS_ONLY

/*
 *  8-bit is just too small. You can try the Frobenius test
 *  but that frobenius test can fail, too, for the same reason.
 */
#ifndef MP_8BIT

/*
 * multiply bigint a with int d and put the result in c
 * Like mp_mul_d() but with a signed long as the small input
 */
static int s_mp_mul_si(const mp_int *a, long d, mp_int *c)
{
   mp_int t;
   int err, neg = 0;

   if ((err = mp_init(&t)) != MP_OKAY) {
      return err;
   }
   if (d < 0) {
      neg = 1;
      d = -d;
   }

   /*
    * mp_digit might be smaller than a long, which excludes
    * the use of mp_mul_d() here.
    */
   if ((err = mp_set_long(&t, (unsigned long) d)) != MP_OKAY) {
      goto LBL_MPMULSI_ERR;
   }
   if ((err = mp_mul(a, &t, c)) != MP_OKAY) {
      goto LBL_MPMULSI_ERR;
   }
   if (neg ==  1) {
      c->sign = (a->sign == MP_NEG) ? MP_ZPOS: MP_NEG;
   }
LBL_MPMULSI_ERR:
   mp_clear(&t);
   return err;
}
/*
    Strong Lucas-Selfridge test.
    returns MP_YES if it is a strong L-S prime, MP_NO if it is composite

    Code ported from  Thomas Ray Nicely's implementation of the BPSW test
    at http://www.trnicely.net/misc/bpsw.html

    Freeware copyright (C) 2016 Thomas R. Nicely <http://www.trnicely.net>.
    Released into the public domain by the author, who disclaims any legal
    liability arising from its use

    The multi-line comments are made by Thomas R. Nicely and are copied verbatim.
    Additional comments marked "CZ" (without the quotes) are by the code-portist.

    (If that name sounds familiar, he is the guy who found the fdiv bug in the
     Pentium (P5x, I think) Intel processor)
*/
int mp_prime_strong_lucas_selfridge(const mp_int *a, int *result)
{
   /* CZ TODO: choose better variable names! */
   mp_int Dz, gcd, Np1, Uz, Vz, U2mz, V2mz, Qmz, Q2mz, Qkdz, T1z, T2z, T3z, T4z, Q2kdz;
   /* CZ TODO: Some of them need the full 32 bit, hence the (temporary) exclusion of MP_8BIT */
   int32_t D, Ds, J, sign, P, Q, r, s, u, Nbits;
   int e;
   int isset, oddness;

   *result = MP_NO;
   /*
   Find the first element D in the sequence {5, -7, 9, -11, 13, ...}
   such that Jacobi(D,N) = -1 (Selfridge's algorithm). Theory
   indicates that, if N is not a perfect square, D will "nearly
   always" be "small." Just in case, an overflow trap for D is
   included.
   */

   if ((e = mp_init_multi(&Dz, &gcd, &Np1, &Uz, &Vz, &U2mz, &V2mz, &Qmz, &Q2mz, &Qkdz, &T1z, &T2z, &T3z, &T4z, &Q2kdz,
                          NULL)) != MP_OKAY) {
      return e;
   }

   D = 5;
   sign = 1;

   for (;;) {
      Ds   = sign * D;
      sign = -sign;
      if ((e = mp_set_long(&Dz, (unsigned long)D)) != MP_OKAY) {
         goto LBL_LS_ERR;
      }
      if ((e = mp_gcd(a, &Dz, &gcd)) != MP_OKAY) {
         goto LBL_LS_ERR;
      }
      /* if 1 < GCD < N then N is composite with factor "D", and
         Jacobi(D,N) is technically undefined (but often returned
         as zero). */
      if ((mp_cmp_d(&gcd, 1uL) == MP_GT) && (mp_cmp(&gcd, a) == MP_LT)) {
         goto LBL_LS_ERR;
      }
      if (Ds < 0) {
         Dz.sign = MP_NEG;
      }
      if ((e = mp_kronecker(&Dz, a, &J)) != MP_OKAY) {
         goto LBL_LS_ERR;
      }

      if (J == -1) {
         break;
      }
      D += 2;

      if (D > (INT_MAX - 2)) {
         e = MP_VAL;
         goto LBL_LS_ERR;
      }
   }



   P = 1;              /* Selfridge's choice */
   Q = (1 - Ds) / 4;   /* Required so D = P*P - 4*Q */

   /* NOTE: The conditions (a) N does not divide Q, and
      (b) D is square-free or not a perfect square, are included by
      some authors; e.g., "Prime numbers and computer methods for
      factorization," Hans Riesel (2nd ed., 1994, Birkhauser, Boston),
      p. 130. For this particular application of Lucas sequences,
      these conditions were found to be immaterial. */

   /* Now calculate N - Jacobi(D,N) = N + 1 (even), and calculate the
      odd positive integer d and positive integer s for which
      N + 1 = 2^s*d (similar to the step for N - 1 in Miller's test).
      The strong Lucas-Selfridge test then returns N as a strong
      Lucas probable prime (slprp) if any of the following
      conditions is met: U_d=0, V_d=0, V_2d=0, V_4d=0, V_8d=0,
      V_16d=0, ..., etc., ending with V_{2^(s-1)*d}=V_{(N+1)/2}=0
      (all equalities mod N). Thus d is the highest index of U that
      must be computed (since V_2m is independent of U), compared
      to U_{N+1} for the standard Lucas-Selfridge test; and no
      index of V beyond (N+1)/2 is required, just as in the
      standard Lucas-Selfridge test. However, the quantity Q^d must
      be computed for use (if necessary) in the latter stages of
      the test. The result is that the strong Lucas-Selfridge test
      has a running time only slightly greater (order of 10 %) than
      that of the standard Lucas-Selfridge test, while producing
      only (roughly) 30 % as many pseudoprimes (and every strong
      Lucas pseudoprime is also a standard Lucas pseudoprime). Thus
      the evidence indicates that the strong Lucas-Selfridge test is
      more effective than the standard Lucas-Selfridge test, and a
      Baillie-PSW test based on the strong Lucas-Selfridge test
      should be more reliable. */

   if ((e = mp_add_d(a, 1uL, &Np1)) != MP_OKAY) {
      goto LBL_LS_ERR;
   }
   s = mp_cnt_lsb(&Np1);

   /* CZ
    * This should round towards zero because
    * Thomas R. Nicely used GMP's mpz_tdiv_q_2exp()
    * and mp_div_2d() is equivalent. Additionally:
    * dividing an even number by two does not produce
    * any leftovers.
    */
   if ((e = mp_div_2d(&Np1, s, &Dz, NULL)) != MP_OKAY) {
      goto LBL_LS_ERR;
   }
   /* We must now compute U_d and V_d. Since d is odd, the accumulated
      values U and V are initialized to U_1 and V_1 (if the target
      index were even, U and V would be initialized instead to U_0=0
      and V_0=2). The values of U_2m and V_2m are also initialized to
      U_1 and V_1; the FOR loop calculates in succession U_2 and V_2,
      U_4 and V_4, U_8 and V_8, etc. If the corresponding bits
      (1, 2, 3, ...) of t are on (the zero bit having been accounted
      for in the initialization of U and V), these values are then
      combined with the previous totals for U and V, using the
      composition formulas for addition of indices. */

   mp_set(&Uz, 1uL);    /* U=U_1 */
   mp_set(&Vz, (mp_digit)P);    /* V=V_1 */
   mp_set(&U2mz, 1uL);  /* U_1 */
   mp_set(&V2mz, (mp_digit)P);  /* V_1 */

   if (Q < 0) {
      Q = -Q;
      if ((e = mp_set_long(&Qmz, (unsigned long)Q)) != MP_OKAY) {
         goto LBL_LS_ERR;
      }
      if ((e = mp_mul_2(&Qmz, &Q2mz)) != MP_OKAY) {
         goto LBL_LS_ERR;
      }
      /* Initializes calculation of Q^d */
      if ((e = mp_set_long(&Qkdz, (unsigned long)Q)) != MP_OKAY) {
         goto LBL_LS_ERR;
      }
      Qmz.sign = MP_NEG;
      Q2mz.sign = MP_NEG;
      Qkdz.sign = MP_NEG;
      Q = -Q;
   } else {
      if ((e = mp_set_long(&Qmz, (unsigned long)Q)) != MP_OKAY) {
         goto LBL_LS_ERR;
      }
      if ((e = mp_mul_2(&Qmz, &Q2mz)) != MP_OKAY) {
         goto LBL_LS_ERR;
      }
      /* Initializes calculation of Q^d */
      if ((e = mp_set_long(&Qkdz, (unsigned long)Q)) != MP_OKAY) {
         goto LBL_LS_ERR;
      }
   }

   Nbits = mp_count_bits(&Dz);

   for (u = 1; u < Nbits; u++) { /* zero bit off, already accounted for */
      /* Formulas for doubling of indices (carried out mod N). Note that
       * the indices denoted as "2m" are actually powers of 2, specifically
       * 2^(ul-1) beginning each loop and 2^ul ending each loop.
       *
       * U_2m = U_m*V_m
       * V_2m = V_m*V_m - 2*Q^m
       */

      if ((e = mp_mul(&U2mz, &V2mz, &U2mz)) != MP_OKAY) {
         goto LBL_LS_ERR;
      }
      if ((e = mp_mod(&U2mz, a, &U2mz)) != MP_OKAY) {
         goto LBL_LS_ERR;
      }
      if ((e = mp_sqr(&V2mz, &V2mz)) != MP_OKAY) {
         goto LBL_LS_ERR;
      }
      if ((e = mp_sub(&V2mz, &Q2mz, &V2mz)) != MP_OKAY) {
         goto LBL_LS_ERR;
      }
      if ((e = mp_mod(&V2mz, a, &V2mz)) != MP_OKAY) {
         goto LBL_LS_ERR;
      }
      /* Must calculate powers of Q for use in V_2m, also for Q^d later */
      if ((e = mp_sqr(&Qmz, &Qmz)) != MP_OKAY) {
         goto LBL_LS_ERR;
      }
      /* prevents overflow */ /* CZ  still necessary without a fixed prealloc'd mem.? */
      if ((e = mp_mod(&Qmz, a, &Qmz)) != MP_OKAY) {
         goto LBL_LS_ERR;
      }
      if ((e = mp_mul_2(&Qmz, &Q2mz)) != MP_OKAY) {
         goto LBL_LS_ERR;
      }
      if ((isset = mp_get_bit(&Dz, u)) == MP_VAL) {
         e = isset;
         goto LBL_LS_ERR;
      }
      if (isset == MP_YES) {
         /* Formulas for addition of indices (carried out mod N);
          *
          * U_(m+n) = (U_m*V_n + U_n*V_m)/2
          * V_(m+n) = (V_m*V_n + D*U_m*U_n)/2
          *
          * Be careful with division by 2 (mod N)!
          */
         if ((e = mp_mul(&U2mz, &Vz, &T1z)) != MP_OKAY) {
            goto LBL_LS_ERR;
         }
         if ((e = mp_mul(&Uz, &V2mz, &T2z)) != MP_OKAY) {
            goto LBL_LS_ERR;
         }
         if ((e = mp_mul(&V2mz, &Vz, &T3z)) != MP_OKAY) {
            goto LBL_LS_ERR;
         }
         if ((e = mp_mul(&U2mz, &Uz, &T4z)) != MP_OKAY) {
            goto LBL_LS_ERR;
         }
         if ((e = s_mp_mul_si(&T4z, (long)Ds, &T4z)) != MP_OKAY) {
            goto LBL_LS_ERR;
         }
         if ((e = mp_add(&T1z, &T2z, &Uz)) != MP_OKAY) {
            goto LBL_LS_ERR;
         }
         if (mp_isodd(&Uz) != MP_NO) {
            if ((e = mp_add(&Uz, a, &Uz)) != MP_OKAY) {
               goto LBL_LS_ERR;
            }
         }
         /* CZ
          * This should round towards negative infinity because
          * Thomas R. Nicely used GMP's mpz_fdiv_q_2exp().
          * But mp_div_2() does not do so, it is truncating instead.
          */
         oddness = mp_isodd(&Uz);
         if ((e = mp_div_2(&Uz, &Uz)) != MP_OKAY) {
            goto LBL_LS_ERR;
         }
         if ((Uz.sign == MP_NEG) && (oddness != MP_NO)) {
            if ((e = mp_sub_d(&Uz, 1uL, &Uz)) != MP_OKAY) {
               goto LBL_LS_ERR;
            }
         }
         if ((e = mp_add(&T3z, &T4z, &Vz)) != MP_OKAY) {
            goto LBL_LS_ERR;
         }
         if (mp_isodd(&Vz) != MP_NO) {
            if ((e = mp_add(&Vz, a, &Vz)) != MP_OKAY) {
               goto LBL_LS_ERR;
            }
         }
         oddness = mp_isodd(&Vz);
         if ((e = mp_div_2(&Vz, &Vz)) != MP_OKAY) {
            goto LBL_LS_ERR;
         }
         if ((Vz.sign == MP_NEG) && (oddness != MP_NO)) {
            if ((e = mp_sub_d(&Vz, 1uL, &Vz)) != MP_OKAY) {
               goto LBL_LS_ERR;
            }
         }
         if ((e = mp_mod(&Uz, a, &Uz)) != MP_OKAY) {
            goto LBL_LS_ERR;
         }
         if ((e = mp_mod(&Vz, a, &Vz)) != MP_OKAY) {
            goto LBL_LS_ERR;
         }
         /* Calculating Q^d for later use */
         if ((e = mp_mul(&Qkdz, &Qmz, &Qkdz)) != MP_OKAY) {
            goto LBL_LS_ERR;
         }
         if ((e = mp_mod(&Qkdz, a, &Qkdz)) != MP_OKAY) {
            goto LBL_LS_ERR;
         }
      }
   }

   /* If U_d or V_d is congruent to 0 mod N, then N is a prime or a
      strong Lucas pseudoprime. */
   if ((mp_iszero(&Uz) != MP_NO) || (mp_iszero(&Vz) != MP_NO)) {
      *result = MP_YES;
      goto LBL_LS_ERR;
   }

   /* NOTE: Ribenboim ("The new book of prime number records," 3rd ed.,
      1995/6) omits the condition V0 on p.142, but includes it on
      p. 130. The condition is NECESSARY; otherwise the test will
      return false negatives---e.g., the primes 29 and 2000029 will be
      returned as composite. */

   /* Otherwise, we must compute V_2d, V_4d, V_8d, ..., V_{2^(s-1)*d}
      by repeated use of the formula V_2m = V_m*V_m - 2*Q^m. If any of
      these are congruent to 0 mod N, then N is a prime or a strong
      Lucas pseudoprime. */

   /* Initialize 2*Q^(d*2^r) for V_2m */
   if ((e = mp_mul_2(&Qkdz, &Q2kdz)) != MP_OKAY) {
      goto LBL_LS_ERR;
   }

   for (r = 1; r < s; r++) {
      if ((e = mp_sqr(&Vz, &Vz)) != MP_OKAY) {
         goto LBL_LS_ERR;
      }
      if ((e = mp_sub(&Vz, &Q2kdz, &Vz)) != MP_OKAY) {
         goto LBL_LS_ERR;
      }
      if ((e = mp_mod(&Vz, a, &Vz)) != MP_OKAY) {
         goto LBL_LS_ERR;
      }
      if (mp_iszero(&Vz) != MP_NO) {
         *result = MP_YES;
         goto LBL_LS_ERR;
      }
      /* Calculate Q^{d*2^r} for next r (final iteration irrelevant). */
      if (r < (s - 1)) {
         if ((e = mp_sqr(&Qkdz, &Qkdz)) != MP_OKAY) {
            goto LBL_LS_ERR;
         }
         if ((e = mp_mod(&Qkdz, a, &Qkdz)) != MP_OKAY) {
            goto LBL_LS_ERR;
         }
         if ((e = mp_mul_2(&Qkdz, &Q2kdz)) != MP_OKAY) {
            goto LBL_LS_ERR;
         }
      }
   }
LBL_LS_ERR:
   mp_clear_multi(&Q2kdz, &T4z, &T3z, &T2z, &T1z, &Qkdz, &Q2mz, &Qmz, &V2mz, &U2mz, &Vz, &Uz, &Np1, &gcd, &Dz, NULL);
   return e;
}
#endif
#endif
#endif

/* ref:         $Format:%D$ */
/* git commit:  $Format:%H$ */
/* commit time: $Format:%ai$ */

#include "tommath_private.h"
#ifdef BN_MP_RADIX_SIZE_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* returns size of ASCII reprensentation */
int mp_radix_size(const mp_int *a, int radix, int *size)
{
   int     res, digs;
   mp_int  t;

#include "tommath_private.h"
#ifdef BN_MP_RADIX_SMAP_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* chars used in radix conversions */
const char *const mp_s_rmap = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/";
const uint8_t mp_s_rmap_reverse[] = {
   0xff, 0xff, 0xff, 0x3e, 0xff, 0xff, 0xff, 0x3f, /* ()*+,-./ */
   0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, /* 01234567 */

#include "tommath_private.h"
#ifdef BN_MP_RAND_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* First the OS-specific special cases
 * - *BSD
 * - Windows
 */
#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__DragonFly__)

   if (ret == MP_OKAY) return ret;
#endif

   return ret;
}

/* makes a pseudo-random int of a given size */
int mp_rand_digit(mp_digit *r)
{
   int ret = s_rand_digit(r);
   *r &= MP_MASK;
   return ret;
}

int mp_rand(mp_int *a, int digits)
{
   int     res;
   mp_digit d;

   mp_zero(a);
   if (digits <= 0) {
      return MP_OKAY;
   }

   /* first place a random non-zero digit */
   do {
      if (mp_rand_digit(&d) != MP_OKAY) {
         return MP_VAL;
      }
   } while (d == 0u);

   if ((res = mp_add_d(a, d, a)) != MP_OKAY) {
      return res;
   }

   while (--digits > 0) {
      if ((res = mp_lshd(a, 1)) != MP_OKAY) {
         return res;
      }

      if (mp_rand_digit(&d) != MP_OKAY) {
         return MP_VAL;
      }
      if ((res = mp_add_d(a, d, a)) != MP_OKAY) {
         return res;
      }
   }

#include "tommath_private.h"
#ifdef BN_MP_READ_RADIX_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* read a string [ASCII] in a given radix */
int mp_read_radix(mp_int *a, const char *str, int radix)
{
   int     y, res, neg;
   unsigned pos;

#include "tommath_private.h"
#ifdef BN_MP_READ_SIGNED_BIN_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* read signed bin, big endian, first byte is 0==positive or 1==negative */
int mp_read_signed_bin(mp_int *a, const unsigned char *b, int c)
{
   int     res;

#include "tommath_private.h"
#ifdef BN_MP_READ_UNSIGNED_BIN_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* reads a unsigned char array, assumes the msb is stored first [big endian] */
int mp_read_unsigned_bin(mp_int *a, const unsigned char *b, int c)
{
   int     res;

#include "tommath_private.h"
#ifdef BN_MP_REDUCE_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* reduces x mod m, assumes 0 < x < m**2, mu is
 * precomputed via mp_reduce_setup.
 * From HAC pp.604 Algorithm 14.42
 */
int mp_reduce(mp_int *x, const mp_int *m, const mp_int *mu)

#include "tommath_private.h"
#ifdef BN_MP_REDUCE_2K_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* reduces a modulo n where n is of the form 2**p - d */
int mp_reduce_2k(mp_int *a, const mp_int *n, mp_digit d)
{
   mp_int q;
   int    p, res;

#include "tommath_private.h"
#ifdef BN_MP_REDUCE_2K_L_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* reduces a modulo n where n is of the form 2**p - d
   This differs from reduce_2k since "d" can be larger
   than a single digit.
*/
int mp_reduce_2k_l(mp_int *a, const mp_int *n, const mp_int *d)

#include "tommath_private.h"
#ifdef BN_MP_REDUCE_2K_SETUP_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* determines the setup value */
int mp_reduce_2k_setup(const mp_int *a, mp_digit *d)
{
   int res, p;
   mp_int tmp;

#include "tommath_private.h"
#ifdef BN_MP_REDUCE_2K_SETUP_L_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* determines the setup value */
int mp_reduce_2k_setup_l(const mp_int *a, mp_int *d)
{
   int    res;
   mp_int tmp;

#include "tommath_private.h"
#ifdef BN_MP_REDUCE_IS_2K_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* determines if mp_reduce_2k can be used */
int mp_reduce_is_2k(const mp_int *a)
{
   int ix, iy, iw;
   mp_digit iz;

#include "tommath_private.h"
#ifdef BN_MP_REDUCE_IS_2K_L_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* determines if reduce_2k_l can be used */
int mp_reduce_is_2k_l(const mp_int *a)
{
   int ix, iy;

#include "tommath_private.h"
#ifdef BN_MP_REDUCE_SETUP_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* pre-calculate the value required for Barrett reduction
 * For a given modulus "b" it calulates the value required in "a"
 */
int mp_reduce_setup(mp_int *a, const mp_int *b)
{

#include "tommath_private.h"
#ifdef BN_MP_RSHD_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* shift right a certain amount of digits */
void mp_rshd(mp_int *a, int b)
{
   int     x;

#include "tommath_private.h"
#ifdef BN_MP_SET_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* set to a digit */
void mp_set(mp_int *a, mp_digit b)
{
   mp_zero(a);
   a->dp[0] = b & MP_MASK;

#include "tommath_private.h"
#ifdef BN_MP_SET_DOUBLE_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense
 */

#if defined(__STDC_IEC_559__) || defined(__GCC_IEC_559)
int mp_set_double(mp_int *a, double b)
{
   uint64_t frac;
   int exp, res;
   union {
      double   dbl;
      uint64_t bits;
   } cast;
   cast.dbl = b;

   exp = (int)((unsigned)(cast.bits >> 52) & 0x7FFU);
   frac = (cast.bits & ((1ULL << 52) - 1ULL)) | (1ULL << 52);

   if (exp == 0x7FF) { /* +-inf, NaN */
      return MP_VAL;
   }
   exp -= 1023 + 52;

   res = mp_set_long_long(a, frac);
   if (res != MP_OKAY) {
      return res;
   }

   res = (exp < 0) ? mp_div_2d(a, -exp, a, NULL) : mp_mul_2d(a, exp, a);
   if (res != MP_OKAY) {
      return res;
   }

   if (((cast.bits >> 63) != 0ULL) && (mp_iszero(a) == MP_NO)) {
      SIGN(a) = MP_NEG;
   }

   return MP_OKAY;
}
#else
/* pragma message() not supported by several compilers (in mostly older but still used versions) */
#  ifdef _MSC_VER
#    pragma message("mp_set_double implementation is only available on platforms with IEEE754 floating point format")
#  else
#    warning "mp_set_double implementation is only available on platforms with IEEE754 floating point format"
#  endif
#endif
#endif

/* ref:         $Format:%D$ */
/* git commit:  $Format:%H$ */
/* commit time: $Format:%ai$ */

#include "tommath_private.h"
#ifdef BN_MP_SET_INT_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* set a 32-bit const */
int mp_set_int(mp_int *a, unsigned long b)
{
   int     x, res;

#include "tommath_private.h"
#ifdef BN_MP_SET_LONG_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* set a platform dependent unsigned long int */
MP_SET_XLONG(mp_set_long, unsigned long)
#endif

/* ref:         $Format:%D$ */

#include "tommath_private.h"
#ifdef BN_MP_SET_LONG_LONG_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* set a platform dependent unsigned long long int */
MP_SET_XLONG(mp_set_long_long, unsigned long long)
#endif

/* ref:         $Format:%D$ */

#include "tommath_private.h"
#ifdef BN_MP_SHRINK_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* shrink a bignum */
int mp_shrink(mp_int *a)
{
   mp_digit *tmp;
   int used = 1;

#include "tommath_private.h"
#ifdef BN_MP_SIGNED_BIN_SIZE_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* get the size for an signed equivalent */
int mp_signed_bin_size(const mp_int *a)
{
   return 1 + mp_unsigned_bin_size(a);
}

#include "tommath_private.h"
#ifdef BN_MP_SQR_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* computes b = a*a */
int mp_sqr(const mp_int *a, mp_int *b)
{
   int     res;

#include "tommath_private.h"
#ifdef BN_MP_SQRMOD_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* c = a * a (mod b) */
int mp_sqrmod(const mp_int *a, const mp_int *b, mp_int *c)
{
   int     res;
   mp_int  t;

#include "tommath_private.h"
#ifdef BN_MP_SQRT_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* this function is less generic than mp_n_root, simpler and faster */
int mp_sqrt(const mp_int *arg, mp_int *ret)
{
   int res;
   mp_int t1, t2;

#include "tommath_private.h"
#ifdef BN_MP_SQRTMOD_PRIME_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense
 */

/* Tonelli-Shanks algorithm
 * https://en.wikipedia.org/wiki/Tonelli%E2%80%93Shanks_algorithm
 * https://gmplib.org/list-archives/gmp-discuss/2013-April/005300.html
 *
 */

cleanup:
   mp_clear_multi(&t1, &C, &Q, &S, &Z, &M, &T, &R, &two, NULL);
   return res;
}

#endif

/* ref:         $Format:%D$ */
/* git commit:  $Format:%H$ */
/* commit time: $Format:%ai$ */

#include "tommath_private.h"
#ifdef BN_MP_SUB_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* high level subtraction (handles signs) */
int mp_sub(const mp_int *a, const mp_int *b, mp_int *c)
{
   int     sa, sb, res;

#include "tommath_private.h"
#ifdef BN_MP_SUB_D_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* single digit subtraction */
int mp_sub_d(const mp_int *a, mp_digit b, mp_int *c)
{
   mp_digit *tmpa, *tmpc, mu;
   int       res, ix, oldused;

#include "tommath_private.h"
#ifdef BN_MP_SUBMOD_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* d = a - b (mod c) */
int mp_submod(const mp_int *a, const mp_int *b, const mp_int *c, mp_int *d)
{
   int     res;
   mp_int  t;

#include "tommath_private.h"
#ifdef BN_MP_TC_AND_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* two complement and */
int mp_tc_and(const mp_int *a, const mp_int *b, mp_int *c)
{
   int res = MP_OKAY, bits, abits, bbits;
   int as = mp_isneg(a), bs = mp_isneg(b);
   mp_int *mx = NULL, _mx, acpy, bcpy;

   if ((as != MP_NO) || (bs != MP_NO)) {
      abits = mp_count_bits(a);
      bbits = mp_count_bits(b);
      bits = MAX(abits, bbits);
      res = mp_init_set_int(&_mx, 1uL);
      if (res != MP_OKAY) {
         goto end;
      }

      mx = &_mx;
      res = mp_mul_2d(mx, bits + 1, mx);

#include "tommath_private.h"
#ifdef BN_MP_TC_DIV_2D_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* two complement right shift */
int mp_tc_div_2d(const mp_int *a, int b, mp_int *c)
{
   int res;
   if (mp_isneg(a) == MP_NO) {

#include "tommath_private.h"
#ifdef BN_MP_TC_OR_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* two complement or */
int mp_tc_or(const mp_int *a, const mp_int *b, mp_int *c)
{
   int res = MP_OKAY, bits, abits, bbits;
   int as = mp_isneg(a), bs = mp_isneg(b);
   mp_int *mx = NULL, _mx, acpy, bcpy;

   if ((as != MP_NO) || (bs != MP_NO)) {
      abits = mp_count_bits(a);
      bbits = mp_count_bits(b);
      bits = MAX(abits, bbits);
      res = mp_init_set_int(&_mx, 1uL);
      if (res != MP_OKAY) {
         goto end;
      }

      mx = &_mx;
      res = mp_mul_2d(mx, bits + 1, mx);

#include "tommath_private.h"
#ifdef BN_MP_TC_XOR_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* two complement xor */
int mp_tc_xor(const mp_int *a, const mp_int *b, mp_int *c)
{
   int res = MP_OKAY, bits, abits, bbits;
   int as = mp_isneg(a), bs = mp_isneg(b);
   mp_int *mx = NULL, _mx, acpy, bcpy;

   if ((as != MP_NO) || (bs != MP_NO)) {
      abits = mp_count_bits(a);
      bbits = mp_count_bits(b);
      bits = MAX(abits, bbits);
      res = mp_init_set_int(&_mx, 1uL);
      if (res != MP_OKAY) {
         goto end;
      }

      mx = &_mx;
      res = mp_mul_2d(mx, bits + 1, mx);

#include "tommath_private.h"
#ifdef BN_MP_TO_SIGNED_BIN_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* store in signed [big endian] format */
int mp_to_signed_bin(const mp_int *a, unsigned char *b)
{
   int     res;

#include "tommath_private.h"
#ifdef BN_MP_TO_SIGNED_BIN_N_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* store in signed [big endian] format */
int mp_to_signed_bin_n(const mp_int *a, unsigned char *b, unsigned long *outlen)
{
   if (*outlen < (unsigned long)mp_signed_bin_size(a)) {
      return MP_VAL;

#include "tommath_private.h"
#ifdef BN_MP_TO_UNSIGNED_BIN_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* store in unsigned [big endian] format */
int mp_to_unsigned_bin(const mp_int *a, unsigned char *b)
{
   int     x, res;
   mp_int  t;

#include "tommath_private.h"
#ifdef BN_MP_TO_UNSIGNED_BIN_N_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* store in unsigned [big endian] format */
int mp_to_unsigned_bin_n(const mp_int *a, unsigned char *b, unsigned long *outlen)
{
   if (*outlen < (unsigned long)mp_unsigned_bin_size(a)) {
      return MP_VAL;

#include "tommath_private.h"
#ifdef BN_MP_TOOM_MUL_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* multiplication using the Toom-Cook 3-way algorithm
 *
 * Much more complicated than Karatsuba but has a lower
 * asymptotic running time of O(N**1.464).  This algorithm is
 * only particularly useful on VERY large inputs

#include "tommath_private.h"
#ifdef BN_MP_TOOM_SQR_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* squaring using Toom-Cook 3-way algorithm */
int mp_toom_sqr(const mp_int *a, mp_int *b)
{
   mp_int w0, w1, w2, w3, w4, tmp1, a0, a1, a2;
   int res, B;

#include "tommath_private.h"
#ifdef BN_MP_TORADIX_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* stores a bignum as a ASCII string in a given radix (2..64) */
int mp_toradix(const mp_int *a, char *str, int radix)
{
   int     res, digs;
   mp_int  t;

#include "tommath_private.h"
#ifdef BN_MP_TORADIX_N_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* stores a bignum as a ASCII string in a given radix (2..64)
 *
 * Stores upto maxlen-1 chars and always a NULL byte
 */
int mp_toradix_n(const mp_int *a, char *str, int radix, int maxlen)

#include "tommath_private.h"
#ifdef BN_MP_UNSIGNED_BIN_SIZE_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* get the size for an unsigned equivalent */
int mp_unsigned_bin_size(const mp_int *a)
{
   int     size = mp_count_bits(a);
   return (size / 8) + ((((unsigned)size & 7u) != 0u) ? 1 : 0);

#include "tommath_private.h"
#ifdef BN_MP_XOR_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* XOR two ints together */
int mp_xor(const mp_int *a, const mp_int *b, mp_int *c)
{
   int     res, ix, px;
   mp_int  t;

#include "tommath_private.h"
#ifdef BN_MP_ZERO_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* set to zero */
void mp_zero(mp_int *a)
{
   int       n;
   mp_digit *tmp;

#include "tommath_private.h"
#ifdef BN_PRIME_TAB_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

const mp_digit ltm_prime_tab[] = {
   0x0002, 0x0003, 0x0005, 0x0007, 0x000B, 0x000D, 0x0011, 0x0013,
   0x0017, 0x001D, 0x001F, 0x0025, 0x0029, 0x002B, 0x002F, 0x0035,
   0x003B, 0x003D, 0x0043, 0x0047, 0x0049, 0x004F, 0x0053, 0x0059,
   0x0061, 0x0065, 0x0067, 0x006B, 0x006D, 0x0071, 0x007F,

#include "tommath_private.h"
#ifdef BN_REVERSE_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* reverse an array, used for radix code */
void bn_reverse(unsigned char *s, int len)
{
   int     ix, iy;
   unsigned char t;

#include "tommath_private.h"
#ifdef BN_S_MP_ADD_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* low level addition, based on HAC pp.594, Algorithm 14.7 */
int s_mp_add(const mp_int *a, const mp_int *b, mp_int *c)
{
   const mp_int *x;
   int     olduse, res, min, max;

#include "tommath_private.h"
#ifdef BN_S_MP_EXPTMOD_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

#ifdef MP_LOW_MEM
#   define TAB_SIZE 32
#else
#   define TAB_SIZE 256
#endif

   if ((err = mp_mod(G, P, &M[1])) != MP_OKAY) {
      goto LBL_MU;
   }

   /* compute the value at M[1<<(winsize-1)] by squaring
    * M[1] (winsize-1) times
    */
   if ((err = mp_copy(&M[1], &M[(size_t)1 << (winsize - 1)])) != MP_OKAY) {
      goto LBL_MU;
   }

   for (x = 0; x < (winsize - 1); x++) {
      /* square it */
      if ((err = mp_sqr(&M[(size_t)1 << (winsize - 1)],
                        &M[(size_t)1 << (winsize - 1)])) != MP_OKAY) {
         goto LBL_MU;
      }

      /* reduce modulo P */
      if ((err = redux(&M[(size_t)1 << (winsize - 1)], P, &mu)) != MP_OKAY) {
         goto LBL_MU;
      }
   }

   /* create upper table, that is M[x] = M[x-1] * M[1] (mod P)
    * for x = (2**(winsize - 1) + 1) to (2**winsize - 1)
    */

#include "tommath_private.h"
#ifdef BN_S_MP_MUL_DIGS_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* multiplies |a| * |b| and only computes upto digs digits of result
 * HAC pp. 595, Algorithm 14.12  Modified so you can control how
 * many digits of output are created.
 */
int s_mp_mul_digs(const mp_int *a, const mp_int *b, mp_int *c, int digs)

#include "tommath_private.h"
#ifdef BN_S_MP_MUL_HIGH_DIGS_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* multiplies |a| * |b| and does not compute the lower digs digits
 * [meant to get the higher part of the product]
 */
int s_mp_mul_high_digs(const mp_int *a, const mp_int *b, mp_int *c, int digs)
{

#include "tommath_private.h"
#ifdef BN_S_MP_SQR_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* low level squaring, b = a*a, HAC pp.596-597, Algorithm 14.16 */
int s_mp_sqr(const mp_int *a, mp_int *b)
{
   mp_int  t;
   int     res, ix, iy, pa;

#include "tommath_private.h"
#ifdef BN_S_MP_SUB_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* low level subtraction (assumes |a| > |b|), HAC pp.595 Algorithm 14.9 */
int s_mp_sub(const mp_int *a, const mp_int *b, mp_int *c)
{
   int     olduse, res, min, max;

#include "tommath_private.h"
#ifdef BNCORE_C
/* LibTomMath, multiple-precision integer library -- Tom St Denis
 *
 * LibTomMath is a library that provides multiple-precision
 * integer arithmetic as well as number theoretic functionality.
 *
 * The library was designed directly after the MPI library by
 * Michael Fromberger but has been written from scratch with
 * additional optimizations in place.
 *
 * SPDX-License-Identifier: Unlicense

 */

/* Known optimal configurations

 CPU                    /Compiler     /MUL CUTOFF/SQR CUTOFF
-------------------------------------------------------------
 Intel P4 Northwood     /GCC v3.4.1   /        88/       128/LTM 0.32 ;-)

|   +--->BN_S_MP_ADD_C
|   |   +--->BN_MP_GROW_C
|   |   +--->BN_MP_CLAMP_C
|   +--->BN_MP_CMP_MAG_C
|   +--->BN_S_MP_SUB_C
|   |   +--->BN_MP_GROW_C
|   |   +--->BN_MP_CLAMP_C
+--->BN_MP_CMP_MAG_C
+--->BN_MP_EXCH_C
+--->BN_MP_CLEAR_MULTI_C
|   +--->BN_MP_CLEAR_C


BN_FAST_MP_MONTGOMERY_REDUCE_C
+--->BN_MP_GROW_C

|   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_CMP_MAG_C
|   |   +--->BN_MP_EXCH_C
|   |   +--->BN_MP_CLEAR_MULTI_C
|   |   |   +--->BN_MP_CLEAR_C
|   +--->BN_MP_INVMOD_SLOW_C
|   |   +--->BN_MP_INIT_MULTI_C
|   |   |   +--->BN_MP_CLEAR_C
|   |   +--->BN_MP_MOD_C

|   +--->BN_MP_GROW_C
|   +--->BN_MP_LSHD_C
|   |   +--->BN_MP_RSHD_C
|   |   |   +--->BN_MP_ZERO_C
|   +--->BN_MP_CLAMP_C
+--->BN_MP_CLEAR_C


BN_MP_GET_BIT_C


BN_MP_GET_DOUBLE_C


BN_MP_GET_INT_C


BN_MP_GET_LONG_C

|   |   +--->BN_S_MP_ADD_C
|   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_CMP_MAG_C
|   |   +--->BN_S_MP_SUB_C
|   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_CLAMP_C
|   +--->BN_MP_CMP_MAG_C
|   +--->BN_MP_EXCH_C
|   +--->BN_MP_CLEAR_MULTI_C
|   |   +--->BN_MP_CLEAR_C
+--->BN_MP_INVMOD_SLOW_C
|   +--->BN_MP_INIT_MULTI_C
|   |   +--->BN_MP_INIT_C
|   |   +--->BN_MP_CLEAR_C

|   |   +--->BN_MP_EXCH_C
|   |   +--->BN_MP_CLEAR_C
+--->BN_MP_CMP_MAG_C
+--->BN_MP_CLEAR_C


BN_MP_JACOBI_C
+--->BN_MP_KRONECKER_C
|   +--->BN_MP_INIT_COPY_C
|   |   +--->BN_MP_INIT_SIZE_C

|   |   +--->BN_MP_COPY_C




|   |   |   +--->BN_MP_GROW_C


|   |   +--->BN_MP_CLEAR_C
|   +--->BN_MP_CNT_LSB_C


|   +--->BN_MP_DIV_2D_C


|   |   +--->BN_MP_COPY_C
|   |   |   +--->BN_MP_GROW_C
|   |   +--->BN_MP_ZERO_C
|   |   +--->BN_MP_MOD_2D_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_RSHD_C
|   |   +--->BN_MP_CLAMP_C
|   +--->BN_MP_CMP_D_C
|   +--->BN_MP_COPY_C
|   |   +--->BN_MP_GROW_C
|   +--->BN_MP_MOD_C
|   |   +--->BN_MP_INIT_SIZE_C
|   |   +--->BN_MP_DIV_C
|   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   +--->BN_MP_ZERO_C
|   |   |   +--->BN_MP_INIT_MULTI_C
|   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   +--->BN_MP_SET_C
|   |   |   +--->BN_MP_COUNT_BITS_C
|   |   |   +--->BN_MP_ABS_C
|   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_CMP_C
|   |   |   +--->BN_MP_SUB_C
|   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_ADD_C
|   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_EXCH_C
|   |   |   +--->BN_MP_CLEAR_MULTI_C
|   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   +--->BN_MP_LSHD_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_RSHD_C
|   |   |   +--->BN_MP_RSHD_C
|   |   |   +--->BN_MP_MUL_D_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_CLEAR_C
|   |   +--->BN_MP_CLEAR_C
|   |   +--->BN_MP_EXCH_C
|   |   +--->BN_MP_ADD_C
|   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLAMP_C












|   +--->BN_MP_CLEAR_C









+--->BN_MP_CMP_D_C


BN_MP_KARATSUBA_MUL_C
+--->BN_MP_MUL_C
|   +--->BN_MP_TOOM_MUL_C
|   |   +--->BN_MP_INIT_MULTI_C
|   |   |   +--->BN_MP_INIT_C

|   +--->BN_MP_GROW_C
|   +--->BN_MP_RSHD_C
|   |   +--->BN_MP_ZERO_C
+--->BN_MP_ADD_C
|   +--->BN_MP_CMP_MAG_C
+--->BN_MP_CLEAR_C


BN_MP_KRONECKER_C
+--->BN_MP_INIT_COPY_C
|   +--->BN_MP_INIT_SIZE_C
|   +--->BN_MP_COPY_C
|   |   +--->BN_MP_GROW_C
|   +--->BN_MP_CLEAR_C
+--->BN_MP_CNT_LSB_C
+--->BN_MP_DIV_2D_C
|   +--->BN_MP_COPY_C
|   |   +--->BN_MP_GROW_C
|   +--->BN_MP_ZERO_C
|   +--->BN_MP_MOD_2D_C
|   |   +--->BN_MP_CLAMP_C
|   +--->BN_MP_RSHD_C
|   +--->BN_MP_CLAMP_C
+--->BN_MP_CMP_D_C
+--->BN_MP_COPY_C
|   +--->BN_MP_GROW_C
+--->BN_MP_MOD_C
|   +--->BN_MP_INIT_SIZE_C
|   +--->BN_MP_DIV_C
|   |   +--->BN_MP_CMP_MAG_C
|   |   +--->BN_MP_ZERO_C
|   |   +--->BN_MP_INIT_MULTI_C
|   |   |   +--->BN_MP_CLEAR_C
|   |   +--->BN_MP_SET_C
|   |   +--->BN_MP_COUNT_BITS_C
|   |   +--->BN_MP_ABS_C
|   |   +--->BN_MP_MUL_2D_C
|   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_LSHD_C
|   |   |   |   +--->BN_MP_RSHD_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_CMP_C
|   |   +--->BN_MP_SUB_C
|   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_ADD_C
|   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_EXCH_C
|   |   +--->BN_MP_CLEAR_MULTI_C
|   |   |   +--->BN_MP_CLEAR_C
|   |   +--->BN_MP_LSHD_C
|   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_RSHD_C
|   |   +--->BN_MP_RSHD_C
|   |   +--->BN_MP_MUL_D_C
|   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_CLEAR_C
|   +--->BN_MP_CLEAR_C
|   +--->BN_MP_EXCH_C
|   +--->BN_MP_ADD_C
|   |   +--->BN_S_MP_ADD_C
|   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_CMP_MAG_C
|   |   +--->BN_S_MP_SUB_C
|   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_CLAMP_C
+--->BN_MP_CLEAR_C


BN_MP_LCM_C
+--->BN_MP_INIT_MULTI_C
|   +--->BN_MP_INIT_C
|   +--->BN_MP_CLEAR_C
+--->BN_MP_GCD_C
|   +--->BN_MP_ABS_C

|   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   +--->BN_MP_EXCH_C
|   |   |   +--->BN_MP_CLEAR_MULTI_C
|   |   |   |   +--->BN_MP_CLEAR_C
|   |   +--->BN_MP_INVMOD_SLOW_C
|   |   |   +--->BN_MP_INIT_MULTI_C
|   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   +--->BN_MP_MOD_C

|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_EXCH_C
|   |   +--->BN_MP_EXCH_C
+--->BN_MP_CMP_C
|   +--->BN_MP_CMP_MAG_C
+--->BN_MP_CLEAR_C


BN_MP_PRIME_FROBENIUS_UNDERWOOD_C
+--->BN_MP_PRIME_IS_PRIME_C
|   +--->BN_MP_IS_SQUARE_C
|   |   +--->BN_MP_MOD_D_C
|   |   |   +--->BN_MP_DIV_D_C
|   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_DIV_2D_C
|   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   +--->BN_MP_MOD_2D_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_DIV_3_C
|   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   +--->BN_MP_INIT_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   +--->BN_MP_INIT_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   +--->BN_MP_CLEAR_C
|   |   +--->BN_MP_INIT_SET_INT_C
|   |   |   +--->BN_MP_INIT_C
|   |   |   +--->BN_MP_SET_INT_C
|   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_MOD_C
|   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   +--->BN_MP_INIT_C
|   |   |   +--->BN_MP_DIV_C
|   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   +--->BN_MP_INIT_MULTI_C
|   |   |   |   |   +--->BN_MP_INIT_C
|   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   +--->BN_MP_SET_C
|   |   |   |   +--->BN_MP_COUNT_BITS_C
|   |   |   |   +--->BN_MP_ABS_C
|   |   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_CMP_C
|   |   |   |   +--->BN_MP_SUB_C
|   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_DIV_2D_C
|   |   |   |   |   +--->BN_MP_MOD_2D_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   +--->BN_MP_CLEAR_MULTI_C
|   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   +--->BN_MP_INIT_C
|   |   |   |   +--->BN_MP_INIT_COPY_C
|   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   +--->BN_MP_MUL_D_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   +--->BN_MP_CLEAR_C
|   |   |   +--->BN_MP_EXCH_C
|   |   |   +--->BN_MP_ADD_C
|   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_GET_INT_C
|   |   +--->BN_MP_SQRT_C
|   |   |   +--->BN_MP_N_ROOT_C
|   |   |   |   +--->BN_MP_N_ROOT_EX_C
|   |   |   |   |   +--->BN_MP_INIT_C
|   |   |   |   |   +--->BN_MP_SET_C
|   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_EXPT_D_EX_C
|   |   |   |   |   |   +--->BN_MP_INIT_COPY_C
|   |   |   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   |   |   +--->BN_MP_MUL_C
|   |   |   |   |   |   |   +--->BN_MP_TOOM_MUL_C
|   |   |   |   |   |   |   |   +--->BN_MP_INIT_MULTI_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   |   |   |   |   +--->BN_MP_MOD_2D_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   |   |   +--->BN_MP_MUL_2_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_MP_SUB_C
|   |   |   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_MP_DIV_2_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_MP_MUL_D_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_MP_DIV_3_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLEAR_MULTI_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   |   |   |   +--->BN_MP_KARATSUBA_MUL_C
|   |   |   |   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   |   |   |   +--->BN_FAST_S_MP_MUL_DIGS_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_S_MP_MUL_DIGS_C
|   |   |   |   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   |   |   +--->BN_MP_SQR_C
|   |   |   |   |   |   |   +--->BN_MP_TOOM_SQR_C
|   |   |   |   |   |   |   |   +--->BN_MP_INIT_MULTI_C
|   |   |   |   |   |   |   |   +--->BN_MP_MOD_2D_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   |   |   +--->BN_MP_MUL_2_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_MP_SUB_C
|   |   |   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_MP_DIV_2_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_MP_MUL_D_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_MP_DIV_3_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLEAR_MULTI_C
|   |   |   |   |   |   |   +--->BN_MP_KARATSUBA_SQR_C
|   |   |   |   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   +--->BN_FAST_S_MP_SQR_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_S_MP_SQR_C
|   |   |   |   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   +--->BN_MP_MUL_C
|   |   |   |   |   |   +--->BN_MP_TOOM_MUL_C
|   |   |   |   |   |   |   +--->BN_MP_INIT_MULTI_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   |   |   |   +--->BN_MP_MOD_2D_C
|   |   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   |   +--->BN_MP_MUL_2_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_DIV_2_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_MUL_D_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_DIV_3_C
|   |   |   |   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLEAR_MULTI_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   |   |   +--->BN_MP_KARATSUBA_MUL_C
|   |   |   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   |   |   +--->BN_FAST_S_MP_MUL_DIGS_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_S_MP_MUL_DIGS_C
|   |   |   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   |   +--->BN_MP_SUB_C
|   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_MUL_D_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_DIV_C
|   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   +--->BN_MP_INIT_MULTI_C
|   |   |   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   |   |   +--->BN_MP_COUNT_BITS_C
|   |   |   |   |   |   +--->BN_MP_ABS_C
|   |   |   |   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_CMP_C
|   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_DIV_2D_C
|   |   |   |   |   |   |   +--->BN_MP_MOD_2D_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   |   +--->BN_MP_CLEAR_MULTI_C
|   |   |   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   +--->BN_MP_INIT_COPY_C
|   |   |   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   |   +--->BN_MP_CMP_C
|   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   +--->BN_MP_SUB_D_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_ADD_D_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   +--->BN_MP_ZERO_C
|   |   |   +--->BN_MP_INIT_COPY_C
|   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   +--->BN_MP_RSHD_C
|   |   |   +--->BN_MP_DIV_C
|   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_INIT_MULTI_C
|   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   +--->BN_MP_SET_C
|   |   |   |   +--->BN_MP_COUNT_BITS_C
|   |   |   |   +--->BN_MP_ABS_C
|   |   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_CMP_C
|   |   |   |   +--->BN_MP_SUB_C
|   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_DIV_2D_C
|   |   |   |   |   +--->BN_MP_MOD_2D_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   +--->BN_MP_CLEAR_MULTI_C
|   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_MUL_D_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   +--->BN_MP_ADD_C
|   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_DIV_2_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   +--->BN_MP_EXCH_C
|   |   |   +--->BN_MP_CLEAR_C
|   |   +--->BN_MP_SQR_C
|   |   |   +--->BN_MP_TOOM_SQR_C
|   |   |   |   +--->BN_MP_INIT_MULTI_C
|   |   |   |   |   +--->BN_MP_INIT_C
|   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   +--->BN_MP_MOD_2D_C
|   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   +--->BN_MP_MUL_2_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_SUB_C
|   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_DIV_2_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_MUL_D_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_DIV_3_C
|   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   +--->BN_MP_INIT_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLEAR_MULTI_C
|   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   +--->BN_MP_KARATSUBA_SQR_C
|   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   +--->BN_MP_INIT_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   +--->BN_FAST_S_MP_SQR_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_S_MP_SQR_C
|   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   +--->BN_MP_INIT_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   +--->BN_MP_CLEAR_C
|   |   +--->BN_MP_CMP_MAG_C
|   |   +--->BN_MP_CLEAR_C
|   +--->BN_MP_CMP_D_C
|   +--->BN_MP_PRIME_IS_DIVISIBLE_C
|   |   +--->BN_MP_MOD_D_C
|   |   |   +--->BN_MP_DIV_D_C
|   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_DIV_2D_C
|   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   +--->BN_MP_MOD_2D_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_DIV_3_C
|   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   +--->BN_MP_INIT_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   +--->BN_MP_INIT_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   +--->BN_MP_CLEAR_C
|   +--->BN_MP_INIT_SET_C
|   |   +--->BN_MP_INIT_C
|   |   +--->BN_MP_SET_C
|   |   |   +--->BN_MP_ZERO_C
|   +--->BN_MP_PRIME_MILLER_RABIN_C
|   |   +--->BN_MP_INIT_COPY_C
|   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   +--->BN_MP_COPY_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_CLEAR_C
|   |   +--->BN_MP_SUB_D_C
|   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_ADD_D_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_CNT_LSB_C
|   |   +--->BN_MP_DIV_2D_C
|   |   |   +--->BN_MP_COPY_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_ZERO_C
|   |   |   +--->BN_MP_MOD_2D_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_RSHD_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_EXPTMOD_C
|   |   |   +--->BN_MP_INVMOD_C
|   |   |   |   +--->BN_FAST_MP_INVMOD_C
|   |   |   |   |   +--->BN_MP_INIT_MULTI_C
|   |   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_MOD_C
|   |   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   +--->BN_MP_DIV_C
|   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   |   +--->BN_MP_SET_C
|   |   |   |   |   |   |   +--->BN_MP_COUNT_BITS_C
|   |   |   |   |   |   |   +--->BN_MP_ABS_C
|   |   |   |   |   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_CMP_C
|   |   |   |   |   |   |   +--->BN_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   |   |   +--->BN_MP_CLEAR_MULTI_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   +--->BN_MP_MUL_D_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_SET_C
|   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   +--->BN_MP_DIV_2_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_SUB_C
|   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_CMP_C
|   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   +--->BN_MP_CLEAR_MULTI_C
|   |   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   +--->BN_MP_INVMOD_SLOW_C
|   |   |   |   |   +--->BN_MP_INIT_MULTI_C
|   |   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   |   +--->BN_MP_MOD_C
|   |   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   +--->BN_MP_DIV_C
|   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   |   +--->BN_MP_SET_C
|   |   |   |   |   |   |   +--->BN_MP_COUNT_BITS_C
|   |   |   |   |   |   |   +--->BN_MP_ABS_C
|   |   |   |   |   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_CMP_C
|   |   |   |   |   |   |   +--->BN_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   |   |   +--->BN_MP_CLEAR_MULTI_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   +--->BN_MP_MUL_D_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_SET_C
|   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   +--->BN_MP_DIV_2_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_SUB_C
|   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_CMP_C
|   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   +--->BN_MP_CLEAR_MULTI_C
|   |   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   +--->BN_MP_CLEAR_C
|   |   |   +--->BN_MP_ABS_C
|   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_CLEAR_MULTI_C
|   |   |   +--->BN_MP_REDUCE_IS_2K_L_C
|   |   |   +--->BN_S_MP_EXPTMOD_C
|   |   |   |   +--->BN_MP_COUNT_BITS_C
|   |   |   |   +--->BN_MP_REDUCE_SETUP_C
|   |   |   |   |   +--->BN_MP_2EXPT_C
|   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_DIV_C
|   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   +--->BN_MP_INIT_MULTI_C
|   |   |   |   |   |   +--->BN_MP_SET_C
|   |   |   |   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_CMP_C
|   |   |   |   |   |   +--->BN_MP_SUB_C
|   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   +--->BN_MP_MUL_D_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_REDUCE_C
|   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   +--->BN_MP_MUL_C
|   |   |   |   |   |   +--->BN_MP_TOOM_MUL_C
|   |   |   |   |   |   |   +--->BN_MP_INIT_MULTI_C
|   |   |   |   |   |   |   +--->BN_MP_MOD_2D_C
|   |   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_MUL_2_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_DIV_2_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_MUL_D_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_DIV_3_C
|   |   |   |   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_KARATSUBA_MUL_C
|   |   |   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_FAST_S_MP_MUL_DIGS_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_S_MP_MUL_DIGS_C
|   |   |   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   +--->BN_S_MP_MUL_HIGH_DIGS_C
|   |   |   |   |   |   +--->BN_FAST_S_MP_MUL_HIGH_DIGS_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   +--->BN_FAST_S_MP_MUL_HIGH_DIGS_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_MOD_2D_C
|   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_S_MP_MUL_DIGS_C
|   |   |   |   |   |   +--->BN_FAST_S_MP_MUL_DIGS_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   +--->BN_MP_SUB_C
|   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_SET_C
|   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_CMP_C
|   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_REDUCE_2K_SETUP_L_C
|   |   |   |   |   +--->BN_MP_2EXPT_C
|   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_REDUCE_2K_L_C
|   |   |   |   |   +--->BN_MP_MUL_C
|   |   |   |   |   |   +--->BN_MP_TOOM_MUL_C
|   |   |   |   |   |   |   +--->BN_MP_INIT_MULTI_C
|   |   |   |   |   |   |   +--->BN_MP_MOD_2D_C
|   |   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   |   +--->BN_MP_MUL_2_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_DIV_2_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_MUL_D_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_DIV_3_C
|   |   |   |   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_KARATSUBA_MUL_C
|   |   |   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   +--->BN_FAST_S_MP_MUL_DIGS_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_S_MP_MUL_DIGS_C
|   |   |   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_MOD_C
|   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   +--->BN_MP_DIV_C
|   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   +--->BN_MP_INIT_MULTI_C
|   |   |   |   |   |   +--->BN_MP_SET_C
|   |   |   |   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_CMP_C
|   |   |   |   |   |   +--->BN_MP_SUB_C
|   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   +--->BN_MP_MUL_D_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_SQR_C
|   |   |   |   |   +--->BN_MP_TOOM_SQR_C
|   |   |   |   |   |   +--->BN_MP_INIT_MULTI_C
|   |   |   |   |   |   +--->BN_MP_MOD_2D_C
|   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   +--->BN_MP_MUL_2_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_SUB_C
|   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_DIV_2_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_MUL_D_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_DIV_3_C
|   |   |   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_KARATSUBA_SQR_C
|   |   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   +--->BN_FAST_S_MP_SQR_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_S_MP_SQR_C
|   |   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   +--->BN_MP_MUL_C
|   |   |   |   |   +--->BN_MP_TOOM_MUL_C
|   |   |   |   |   |   +--->BN_MP_INIT_MULTI_C
|   |   |   |   |   |   +--->BN_MP_MOD_2D_C
|   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   +--->BN_MP_MUL_2_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_SUB_C
|   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_DIV_2_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_MUL_D_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_DIV_3_C
|   |   |   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_KARATSUBA_MUL_C
|   |   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   +--->BN_FAST_S_MP_MUL_DIGS_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_S_MP_MUL_DIGS_C
|   |   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   +--->BN_MP_SET_C
|   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   +--->BN_MP_EXCH_C
|   |   |   +--->BN_MP_DR_IS_MODULUS_C
|   |   |   +--->BN_MP_REDUCE_IS_2K_C
|   |   |   |   +--->BN_MP_REDUCE_2K_C
|   |   |   |   |   +--->BN_MP_COUNT_BITS_C
|   |   |   |   |   +--->BN_MP_MUL_D_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_COUNT_BITS_C
|   |   |   +--->BN_MP_EXPTMOD_FAST_C
|   |   |   |   +--->BN_MP_COUNT_BITS_C
|   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   +--->BN_MP_MONTGOMERY_SETUP_C
|   |   |   |   +--->BN_FAST_MP_MONTGOMERY_REDUCE_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   +--->BN_MP_MONTGOMERY_REDUCE_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   +--->BN_MP_DR_SETUP_C
|   |   |   |   +--->BN_MP_DR_REDUCE_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   +--->BN_MP_REDUCE_2K_SETUP_C
|   |   |   |   |   +--->BN_MP_2EXPT_C
|   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_REDUCE_2K_C
|   |   |   |   |   +--->BN_MP_MUL_D_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_MONTGOMERY_CALC_NORMALIZATION_C
|   |   |   |   |   +--->BN_MP_2EXPT_C
|   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_SET_C
|   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   +--->BN_MP_MUL_2_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_MULMOD_C
|   |   |   |   |   +--->BN_MP_MUL_C
|   |   |   |   |   |   +--->BN_MP_TOOM_MUL_C
|   |   |   |   |   |   |   +--->BN_MP_INIT_MULTI_C
|   |   |   |   |   |   |   +--->BN_MP_MOD_2D_C
|   |   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   |   +--->BN_MP_MUL_2_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_DIV_2_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_MUL_D_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_DIV_3_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_KARATSUBA_MUL_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   +--->BN_FAST_S_MP_MUL_DIGS_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_S_MP_MUL_DIGS_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   +--->BN_MP_MOD_C
|   |   |   |   |   |   +--->BN_MP_DIV_C
|   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   |   +--->BN_MP_INIT_MULTI_C
|   |   |   |   |   |   |   +--->BN_MP_SET_C
|   |   |   |   |   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_CMP_C
|   |   |   |   |   |   |   +--->BN_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   +--->BN_MP_MUL_D_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_SET_C
|   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   +--->BN_MP_MOD_C
|   |   |   |   |   +--->BN_MP_DIV_C
|   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   +--->BN_MP_INIT_MULTI_C
|   |   |   |   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_CMP_C
|   |   |   |   |   |   +--->BN_MP_SUB_C
|   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   +--->BN_MP_MUL_D_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_SQR_C
|   |   |   |   |   +--->BN_MP_TOOM_SQR_C
|   |   |   |   |   |   +--->BN_MP_INIT_MULTI_C
|   |   |   |   |   |   +--->BN_MP_MOD_2D_C
|   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   +--->BN_MP_MUL_2_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_SUB_C
|   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_DIV_2_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_MUL_D_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_DIV_3_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_KARATSUBA_SQR_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   +--->BN_FAST_S_MP_SQR_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_S_MP_SQR_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   +--->BN_MP_MUL_C
|   |   |   |   |   +--->BN_MP_TOOM_MUL_C
|   |   |   |   |   |   +--->BN_MP_INIT_MULTI_C
|   |   |   |   |   |   +--->BN_MP_MOD_2D_C
|   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   +--->BN_MP_MUL_2_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_SUB_C
|   |   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_DIV_2_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_MUL_D_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_DIV_3_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_KARATSUBA_MUL_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   +--->BN_FAST_S_MP_MUL_DIGS_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_S_MP_MUL_DIGS_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   +--->BN_MP_EXCH_C
|   |   +--->BN_MP_CMP_C
|   |   |   +--->BN_MP_CMP_MAG_C
|   |   +--->BN_MP_SQRMOD_C
|   |   |   +--->BN_MP_SQR_C
|   |   |   |   +--->BN_MP_TOOM_SQR_C
|   |   |   |   |   +--->BN_MP_INIT_MULTI_C
|   |   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   |   +--->BN_MP_MOD_2D_C
|   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   +--->BN_MP_MUL_2_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_SUB_C
|   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_DIV_2_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_MUL_D_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_DIV_3_C
|   |   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CLEAR_MULTI_C
|   |   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   +--->BN_MP_KARATSUBA_SQR_C
|   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   +--->BN_FAST_S_MP_SQR_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_S_MP_SQR_C
|   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   +--->BN_MP_CLEAR_C
|   |   |   +--->BN_MP_MOD_C
|   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   +--->BN_MP_DIV_C
|   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   +--->BN_MP_INIT_MULTI_C
|   |   |   |   |   +--->BN_MP_SET_C
|   |   |   |   |   +--->BN_MP_COUNT_BITS_C
|   |   |   |   |   +--->BN_MP_ABS_C
|   |   |   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_SUB_C
|   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   +--->BN_MP_CLEAR_MULTI_C
|   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   +--->BN_MP_MUL_D_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_CLEAR_C
|   +--->BN_MP_PRIME_STRONG_LUCAS_SELFRIDGE_C
|   |   +--->BN_MP_MUL_D_C
|   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_INIT_C
|   |   +--->BN_MP_SET_LONG_C
|   |   +--->BN_MP_MUL_C
|   |   |   +--->BN_MP_TOOM_MUL_C
|   |   |   |   +--->BN_MP_INIT_MULTI_C
|   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   +--->BN_MP_MOD_2D_C
|   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   +--->BN_MP_MUL_2_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_SUB_C
|   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_DIV_2_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_DIV_3_C
|   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLEAR_MULTI_C
|   |   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   +--->BN_MP_KARATSUBA_MUL_C
|   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   +--->BN_FAST_S_MP_MUL_DIGS_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_S_MP_MUL_DIGS_C
|   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   +--->BN_MP_CLEAR_C
|   |   +--->BN_MP_CLEAR_C
|   |   +--->BN_MP_INIT_MULTI_C
|   |   +--->BN_MP_GCD_C
|   |   |   +--->BN_MP_ABS_C
|   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_INIT_COPY_C
|   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_CNT_LSB_C
|   |   |   +--->BN_MP_DIV_2D_C
|   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   +--->BN_MP_MOD_2D_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   +--->BN_MP_EXCH_C
|   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_CMP_C
|   |   |   +--->BN_MP_CMP_MAG_C
|   |   +--->BN_MP_KRONECKER_C
|   |   |   +--->BN_MP_INIT_COPY_C
|   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_CNT_LSB_C
|   |   |   +--->BN_MP_DIV_2D_C
|   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   +--->BN_MP_MOD_2D_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_COPY_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_MOD_C
|   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   +--->BN_MP_DIV_C
|   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   +--->BN_MP_SET_C
|   |   |   |   |   +--->BN_MP_COUNT_BITS_C
|   |   |   |   |   +--->BN_MP_ABS_C
|   |   |   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_SUB_C
|   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   |   +--->BN_MP_CLEAR_MULTI_C
|   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_ADD_D_C
|   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_SUB_D_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_CNT_LSB_C
|   |   +--->BN_MP_DIV_2D_C
|   |   |   +--->BN_MP_COPY_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_ZERO_C
|   |   |   +--->BN_MP_MOD_2D_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_RSHD_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_SET_C
|   |   |   +--->BN_MP_ZERO_C
|   |   +--->BN_MP_MUL_2_C
|   |   |   +--->BN_MP_GROW_C
|   |   +--->BN_MP_COUNT_BITS_C
|   |   +--->BN_MP_MOD_C
|   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   +--->BN_MP_DIV_C
|   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   +--->BN_MP_ABS_C
|   |   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_SUB_C
|   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   +--->BN_MP_CLEAR_MULTI_C
|   |   |   |   +--->BN_MP_INIT_COPY_C
|   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_EXCH_C
|   |   |   +--->BN_MP_ADD_C
|   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_SQR_C
|   |   |   +--->BN_MP_TOOM_SQR_C
|   |   |   |   +--->BN_MP_MOD_2D_C
|   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_COPY_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_SUB_C
|   |   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_DIV_2_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_DIV_3_C
|   |   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   |   +--->BN_MP_EXCH_C
|   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLEAR_MULTI_C
|   |   |   +--->BN_MP_KARATSUBA_SQR_C
|   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   |   |   +--->BN_MP_ZERO_C
|   |   |   |   +--->BN_MP_ADD_C
|   |   |   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   +--->BN_FAST_S_MP_SQR_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_S_MP_SQR_C
|   |   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_MP_EXCH_C
|   |   +--->BN_MP_SUB_C
|   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_GET_BIT_C
|   |   +--->BN_MP_ADD_C
|   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_DIV_2_C
|   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_SUB_D_C
|   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_CLEAR_MULTI_C
|   +--->BN_MP_READ_RADIX_C
|   |   +--->BN_MP_ZERO_C
|   |   +--->BN_MP_MUL_D_C
|   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_ADD_D_C
|   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_SUB_D_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_CLAMP_C
|   +--->BN_MP_CMP_C
|   |   +--->BN_MP_CMP_MAG_C
|   +--->BN_MP_SET_C
|   |   +--->BN_MP_ZERO_C
|   +--->BN_MP_COUNT_BITS_C
|   +--->BN_MP_RAND_C
|   |   +--->BN_MP_ZERO_C
|   |   +--->BN_MP_ADD_D_C
|   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_SUB_D_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_LSHD_C
|   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_RSHD_C
|   +--->BN_MP_DIV_2D_C
|   |   +--->BN_MP_COPY_C
|   |   |   +--->BN_MP_GROW_C
|   |   +--->BN_MP_ZERO_C
|   |   +--->BN_MP_MOD_2D_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_RSHD_C
|   |   +--->BN_MP_CLAMP_C
|   +--->BN_MP_CLEAR_C
+--->BN_MP_INIT_MULTI_C
|   +--->BN_MP_INIT_C
|   +--->BN_MP_CLEAR_C
+--->BN_MP_SET_LONG_C
+--->BN_MP_SQR_C
|   +--->BN_MP_TOOM_SQR_C
|   |   +--->BN_MP_MOD_2D_C
|   |   |   +--->BN_MP_ZERO_C
|   |   |   +--->BN_MP_COPY_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_COPY_C
|   |   |   +--->BN_MP_GROW_C
|   |   +--->BN_MP_RSHD_C
|   |   |   +--->BN_MP_ZERO_C
|   |   +--->BN_MP_MUL_2_C
|   |   |   +--->BN_MP_GROW_C
|   |   +--->BN_MP_ADD_C
|   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_SUB_C
|   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_DIV_2_C
|   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_MUL_2D_C
|   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_LSHD_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_MUL_D_C
|   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_DIV_3_C
|   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   +--->BN_MP_INIT_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_EXCH_C
|   |   |   +--->BN_MP_CLEAR_C
|   |   +--->BN_MP_LSHD_C
|   |   |   +--->BN_MP_GROW_C
|   |   +--->BN_MP_CLEAR_MULTI_C
|   |   |   +--->BN_MP_CLEAR_C
|   +--->BN_MP_KARATSUBA_SQR_C
|   |   +--->BN_MP_INIT_SIZE_C
|   |   |   +--->BN_MP_INIT_C
|   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_S_MP_ADD_C
|   |   |   +--->BN_MP_GROW_C
|   |   +--->BN_S_MP_SUB_C
|   |   |   +--->BN_MP_GROW_C
|   |   +--->BN_MP_LSHD_C
|   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_RSHD_C
|   |   |   |   +--->BN_MP_ZERO_C
|   |   +--->BN_MP_ADD_C
|   |   |   +--->BN_MP_CMP_MAG_C
|   |   +--->BN_MP_CLEAR_C
|   +--->BN_FAST_S_MP_SQR_C
|   |   +--->BN_MP_GROW_C
|   |   +--->BN_MP_CLAMP_C
|   +--->BN_S_MP_SQR_C
|   |   +--->BN_MP_INIT_SIZE_C
|   |   |   +--->BN_MP_INIT_C
|   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_EXCH_C
|   |   +--->BN_MP_CLEAR_C
+--->BN_MP_SUB_D_C
|   +--->BN_MP_GROW_C
|   +--->BN_MP_ADD_D_C
|   |   +--->BN_MP_CLAMP_C
|   +--->BN_MP_CLAMP_C
+--->BN_MP_KRONECKER_C
|   +--->BN_MP_INIT_COPY_C
|   |   +--->BN_MP_INIT_SIZE_C
|   |   +--->BN_MP_COPY_C
|   |   |   +--->BN_MP_GROW_C
|   |   +--->BN_MP_CLEAR_C
|   +--->BN_MP_CNT_LSB_C
|   +--->BN_MP_DIV_2D_C
|   |   +--->BN_MP_COPY_C
|   |   |   +--->BN_MP_GROW_C
|   |   +--->BN_MP_ZERO_C
|   |   +--->BN_MP_MOD_2D_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_RSHD_C
|   |   +--->BN_MP_CLAMP_C
|   +--->BN_MP_CMP_D_C
|   +--->BN_MP_COPY_C
|   |   +--->BN_MP_GROW_C
|   +--->BN_MP_MOD_C
|   |   +--->BN_MP_INIT_SIZE_C
|   |   +--->BN_MP_DIV_C
|   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   +--->BN_MP_ZERO_C
|   |   |   +--->BN_MP_SET_C
|   |   |   +--->BN_MP_COUNT_BITS_C
|   |   |   +--->BN_MP_ABS_C
|   |   |   +--->BN_MP_MUL_2D_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_LSHD_C
|   |   |   |   |   +--->BN_MP_RSHD_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_CMP_C
|   |   |   +--->BN_MP_SUB_C
|   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_ADD_C
|   |   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_EXCH_C
|   |   |   +--->BN_MP_CLEAR_MULTI_C
|   |   |   |   +--->BN_MP_CLEAR_C
|   |   |   +--->BN_MP_LSHD_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_RSHD_C
|   |   |   +--->BN_MP_RSHD_C
|   |   |   +--->BN_MP_MUL_D_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_CLEAR_C
|   |   +--->BN_MP_CLEAR_C
|   |   +--->BN_MP_EXCH_C
|   |   +--->BN_MP_ADD_C
|   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   +--->BN_MP_CLEAR_C
+--->BN_MP_GCD_C
|   +--->BN_MP_ABS_C
|   |   +--->BN_MP_COPY_C
|   |   |   +--->BN_MP_GROW_C
|   +--->BN_MP_INIT_COPY_C
|   |   +--->BN_MP_INIT_SIZE_C
|   |   +--->BN_MP_COPY_C
|   |   |   +--->BN_MP_GROW_C
|   |   +--->BN_MP_CLEAR_C
|   +--->BN_MP_CNT_LSB_C
|   +--->BN_MP_DIV_2D_C
|   |   +--->BN_MP_COPY_C
|   |   |   +--->BN_MP_GROW_C
|   |   +--->BN_MP_ZERO_C
|   |   +--->BN_MP_MOD_2D_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_RSHD_C
|   |   +--->BN_MP_CLAMP_C
|   +--->BN_MP_CMP_MAG_C
|   +--->BN_MP_EXCH_C
|   +--->BN_S_MP_SUB_C
|   |   +--->BN_MP_GROW_C
|   |   +--->BN_MP_CLAMP_C
|   +--->BN_MP_MUL_2D_C
|   |   +--->BN_MP_COPY_C
|   |   |   +--->BN_MP_GROW_C
|   |   +--->BN_MP_GROW_C
|   |   +--->BN_MP_LSHD_C
|   |   |   +--->BN_MP_RSHD_C
|   |   |   |   +--->BN_MP_ZERO_C
|   |   +--->BN_MP_CLAMP_C
|   +--->BN_MP_CLEAR_C
+--->BN_MP_ADD_D_C
|   +--->BN_MP_GROW_C
|   +--->BN_MP_CLAMP_C
+--->BN_MP_SET_C
|   +--->BN_MP_ZERO_C
+--->BN_MP_COUNT_BITS_C
+--->BN_MP_MUL_2_C
|   +--->BN_MP_GROW_C
+--->BN_MP_MUL_D_C
|   +--->BN_MP_GROW_C
|   +--->BN_MP_CLAMP_C
+--->BN_MP_ADD_C
|   +--->BN_S_MP_ADD_C
|   |   +--->BN_MP_GROW_C
|   |   +--->BN_MP_CLAMP_C
|   +--->BN_MP_CMP_MAG_C
|   +--->BN_S_MP_SUB_C
|   |   +--->BN_MP_GROW_C
|   |   +--->BN_MP_CLAMP_C
+--->BN_MP_MUL_C
|   +--->BN_MP_TOOM_MUL_C
|   |   +--->BN_MP_MOD_2D_C
|   |   |   +--->BN_MP_ZERO_C
|   |   |   +--->BN_MP_COPY_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_COPY_C
|   |   |   +--->BN_MP_GROW_C
|   |   +--->BN_MP_RSHD_C
|   |   |   +--->BN_MP_ZERO_C
|   |   +--->BN_MP_SUB_C
|   |   |   +--->BN_S_MP_ADD_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_CMP_MAG_C
|   |   |   +--->BN_S_MP_SUB_C
|   |   |   |   +--->BN_MP_GROW_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_DIV_2_C
|   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_MUL_2D_C
|   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_LSHD_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_DIV_3_C
|   |   |   +--->BN_MP_INIT_SIZE_C
|   |   |   |   +--->BN_MP_INIT_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_EXCH_C
|   |   |   +--->BN_MP_CLEAR_C
|   |   +--->BN_MP_LSHD_C
|   |   |   +--->BN_MP_GROW_C
|   |   +--->BN_MP_CLEAR_MULTI_C
|   |   |   +--->BN_MP_CLEAR_C
|   +--->BN_MP_KARATSUBA_MUL_C
|   |   +--->BN_MP_INIT_SIZE_C
|   |   |   +--->BN_MP_INIT_C
|   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_S_MP_ADD_C
|   |   |   +--->BN_MP_GROW_C
|   |   +--->BN_S_MP_SUB_C
|   |   |   +--->BN_MP_GROW_C
|   |   +--->BN_MP_LSHD_C
|   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_RSHD_C
|   |   |   |   +--->BN_MP_ZERO_C
|   |   +--->BN_MP_CLEAR_C
|   +--->BN_FAST_S_MP_MUL_DIGS_C
|   |   +--->BN_MP_GROW_C
|   |   +--->BN_MP_CLAMP_C
|   +--->BN_S_MP_MUL_DIGS_C
|   |   +--->BN_MP_INIT_SIZE_C
|   |   |   +--->BN_MP_INIT_C
|   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_EXCH_C
|   |   +--->BN_MP_CLEAR_C
+--->BN_MP_SUB_C
|   +--->BN_S_MP_ADD_C
|   |   +--->BN_MP_GROW_C
|   |   +--->BN_MP_CLAMP_C
|   +--->BN_MP_CMP_MAG_C
|   +--->BN_S_MP_SUB_C
|   |   +--->BN_MP_GROW_C
|   |   +--->BN_MP_CLAMP_C
+--->BN_MP_MOD_C
|   +--->BN_MP_INIT_SIZE_C
|   |   +--->BN_MP_INIT_C
|   +--->BN_MP_DIV_C
|   |   +--->BN_MP_CMP_MAG_C
|   |   +--->BN_MP_COPY_C
|   |   |   +--->BN_MP_GROW_C
|   |   +--->BN_MP_ZERO_C
|   |   +--->BN_MP_ABS_C
|   |   +--->BN_MP_MUL_2D_C
|   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_LSHD_C
|   |   |   |   +--->BN_MP_RSHD_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_CMP_C
|   |   +--->BN_MP_DIV_2D_C
|   |   |   +--->BN_MP_MOD_2D_C
|   |   |   |   +--->BN_MP_CLAMP_C
|   |   |   +--->BN_MP_RSHD_C
|   |   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_EXCH_C
|   |   +--->BN_MP_CLEAR_MULTI_C
|   |   |   +--->BN_MP_CLEAR_C
|   |   +--->BN_MP_INIT_C
|   |   +--->BN_MP_INIT_COPY_C
|   |   |   +--->BN_MP_CLEAR_C
|   |   +--->BN_MP_LSHD_C
|   |   |   +--->BN_MP_GROW_C
|   |   |   +--->BN_MP_RSHD_C
|   |   +--->BN_MP_RSHD_C
|   |   +--->BN_MP_CLAMP_C
|   |   +--->BN_MP_CLEAR_C
|   +--->BN_MP_CLEAR_C
|   +--->BN_MP_EXCH_C
+--->BN_MP_GET_BIT_C
+--->BN_MP_EXCH_C
+--->BN_MP_CMP_C
|   +--->BN_MP_CMP_MAG_C
+--->BN_MP_CLEAR_MULTI_C
|   +--->BN_MP_CLEAR_C


BN_MP_PRIME_IS_DIVISIBLE_C
+--->BN_MP_MOD_D_C
|   +--->BN_MP_DIV_D_C
|   |   +--->BN_MP_COPY_C
|   |   |   +--->BN_MP_GROW_C
|   |   +--->BN_MP_DIV_2D_C