test/bntest.c:605: error: INTEGER_OVERFLOW_L2
  ([0, +oo] - 1):unsigned64 by call to `BN_div_recp`.
Showing all 16 steps of the trace


test/bntest.c:604:9: Call
602.           a->neg = rand_neg();
603.           b->neg = rand_neg();
604.           BN_RECP_CTX_set(recp, b, ctx);
               ^
605.           BN_div_recp(d, c, a, recp, ctx);
606.           if (bp != NULL) {

crypto/bn/bn_recp.c:95:10: Call
  93.   int BN_RECP_CTX_set(BN_RECP_CTX *recp, const BIGNUM *d, BN_CTX *ctx)
  94.   {
  95.       if (!BN_copy(&(recp->N), d))
                 ^
  96.           return 0;
  97.       BN_zero(&(recp->Nr));

crypto/bn/bn_lib.c:426:1: Parameter `*a->d`
    424.   }
    425.   
    426. > BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b)
    427.   {
    428.       int i;

test/bntest.c:605:9: Call
603.           b->neg = rand_neg();
604.           BN_RECP_CTX_set(recp, b, ctx);
605.           BN_div_recp(d, c, a, recp, ctx);
               ^
606.           if (bp != NULL) {
607.               if (!results) {

crypto/bn/bn_recp.c:132:1: Parameter `*m->d`
  130.   }
  131.   
  132. > int BN_div_recp(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m,
  133.                   BN_RECP_CTX *recp, BN_CTX *ctx)
  134.   {

crypto/bn/bn_recp.c:152:9: Call
  150.           goto err;
  151.   
  152.       if (BN_ucmp(m, &(recp->N)) < 0) {
                 ^
  153.           BN_zero(d);
  154.           if (!BN_copy(r, m)) {

crypto/bn/bn_lib.c:599:1: Parameter `*a->d`
    597.   }
    598.   
    599. > int BN_ucmp(const BIGNUM *a, const BIGNUM *b)
    600.   {
    601.       int i;

crypto/bn/bn_recp.c:168:9: Call
  166.   
  167.       /* i := max(BN_num_bits(m), 2*BN_num_bits(N)) */
  168.       i = BN_num_bits(m);
                 ^
  169.       j = recp->num_bits << 1;
  170.       if (j > i)

crypto/bn/bn_lib.c:214:1: Parameter `*a->d`
    212.   }
    213.   
    214. > int BN_num_bits(const BIGNUM *a)
    215.   {
    216.       int i = a->top - 1;

crypto/bn/bn_recp.c:186:10: Call
  184.        *    = |m/N|
  185.        */
  186.       if (!BN_rshift(a, m, recp->num_bits))
                  ^
  187.           goto err;
  188.       if (!BN_mul(b, a, &(recp->Nr), ctx))

crypto/bn/bn_shift.c:169:1: Parameter `*a->d`
    167.   }
    168.   
    169. > int BN_rshift(BIGNUM *r, const BIGNUM *a, int n)
    170.   {
    171.       int i, j, nw, lb, rb;

crypto/bn/bn_recp.c:196:10: Call
  194.       if (!BN_mul(b, &(recp->N), d, ctx))
  195.           goto err;
  196.       if (!BN_usub(r, m, b))
                  ^
  197.           goto err;
  198.       r->neg = 0;

crypto/bn/bn_add.c:166:1: <LHS trace>
164.   
165.   /* unsigned subtraction of b from a, a must be larger than b. */
166. > int BN_usub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b)
167.   {
168.       int max, min, dif;

crypto/bn/bn_add.c:166:1: Parameter `*a->d`
    164.   
    165.   /* unsigned subtraction of b from a, a must be larger than b. */
    166. > int BN_usub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b)
    167.   {
    168.       int max, min, dif;

crypto/bn/bn_add.c:218:13: Assignment
    216.           while (dif) {
    217.               dif--;
    218.               t1 = *(ap++);
                       ^
    219.               t2 = (t1 - 1) & BN_MASK2;
    220.               *(rp++) = t2;

crypto/bn/bn_add.c:219:13: Binary operation: ([0, +oo] - 1):unsigned64 by call to `BN_div_recp` 
    217.               dif--;
    218.               t1 = *(ap++);
    219.               t2 = (t1 - 1) & BN_MASK2;
                       ^
    220.               *(rp++) = t2;
    221.               if (t1)
