crypto/bn/bn_gf2m.c:699: error: INTEGER_OVERFLOW_L2
  ([0, +oo] - 1):unsigned32 by call to `BN_GF2m_mod_mul`.
Showing all 17 steps of the trace


crypto/bn/bn_gf2m.c:698:7: Call
696.   	if (xinv == NULL) goto err;
697.   	
698.   	if (!BN_GF2m_mod_inv(xinv, x, p, ctx)) goto err;
             ^
699.   	if (!BN_GF2m_mod_mul(r, y, xinv, p, ctx)) goto err;
700.   	bn_check_top(r);

crypto/bn/bn_gf2m.c:652:4: Call
  650.           bn_correct_top(v);
  651.   #endif
  652.     	BN_CTX_end(ctx);
            ^
  653.   	return ret;
  654.   	}

crypto/bn/bn_ctx.c:272:1: Parameter `ctx->pool.used`
    270.   	}
    271.   
    272. > void BN_CTX_end(BN_CTX *ctx)
    273.   	{
    274.   	CTXDBG_ENTRY("BN_CTX_end", ctx);

crypto/bn/bn_gf2m.c:699:7: Call
697.   	
698.   	if (!BN_GF2m_mod_inv(xinv, x, p, ctx)) goto err;
699.   	if (!BN_GF2m_mod_mul(r, y, xinv, p, ctx)) goto err;
             ^
700.   	bn_check_top(r);
701.   	ret = 1;

crypto/bn/bn_gf2m.c:442:1: Parameter `ctx->pool.used`
  440.    * BN_GF2m_mod_mul_arr function.
  441.    */
  442. > int	BN_GF2m_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *p, BN_CTX *ctx)
  443.   	{
  444.   	int ret = 0;

crypto/bn/bn_gf2m.c:457:8: Call
  455.   		goto err;
  456.   		}
  457.   	ret = BN_GF2m_mod_mul_arr(r, a, b, arr, ctx);
                ^
  458.   	bn_check_top(r);
  459.   err:

crypto/bn/bn_gf2m.c:389:1: Parameter `ctx->pool.used`
    387.    * the result in r.  r could be a or b; a could be b.
    388.    */
    389. > int	BN_GF2m_mod_mul_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const int p[], BN_CTX *ctx)
    390.   	{
    391.   	int zlen, i, j, k, ret = 0;

crypto/bn/bn_gf2m.c:400:10: Call
    398.   	if (a == b)
    399.   		{
    400.   		return BN_GF2m_mod_sqr_arr(r, a, p, ctx);
                    ^
    401.   		}
    402.   

crypto/bn/bn_gf2m.c:466:1: Parameter `ctx->pool.used`
      464.   
      465.   /* Square a, reduce the result mod p, and store it in a.  r could be a. */
      466. > int	BN_GF2m_mod_sqr_arr(BIGNUM *r, const BIGNUM *a, const int p[], BN_CTX *ctx)
      467.   	{
      468.   	int i, ret = 0;

crypto/bn/bn_gf2m.c:473:11: Call
      471.   	bn_check_top(a);
      472.   	BN_CTX_start(ctx);
      473.   	if ((s = BN_CTX_get(ctx)) == NULL) return 0;
                       ^
      474.   	if (!bn_wexpand(s, 2 * a->top)) goto err;
      475.   

crypto/bn/bn_ctx.c:290:1: Parameter `ctx->pool.used`
        288.   	}
        289.   
        290. > BIGNUM *BN_CTX_get(BN_CTX *ctx)
        291.   	{
        292.   	BIGNUM *ret;

crypto/bn/bn_gf2m.c:488:2: Call
      486.   	ret = 1;
      487.   err:
      488.   	BN_CTX_end(ctx);
              ^
      489.   	return ret;
      490.   	}

crypto/bn/bn_ctx.c:272:1: Parameter `ctx->pool.used`
        270.   	}
        271.   
        272. > void BN_CTX_end(BN_CTX *ctx)
        273.   	{
        274.   	CTXDBG_ENTRY("BN_CTX_end", ctx);

crypto/bn/bn_ctx.c:282:4: Call
        280.   		/* Does this stack frame have anything to release? */
        281.   		if(fp < ctx->used)
        282.   			BN_POOL_release(&ctx->pool, ctx->used - fp);
                  ^
        283.   		ctx->used = fp;
        284.   		/* Unjam "too_many" in case "get" had failed */

crypto/bn/bn_ctx.c:440:1: <LHS trace>
438.   	}
439.   
440. > static void BN_POOL_release(BN_POOL *p, unsigned int num)
441.   	{
442.   	unsigned int offset = (p->used - 1) % BN_CTX_POOL_SIZE;

crypto/bn/bn_ctx.c:440:1: Parameter `p->used`
          438.   	}
          439.   
          440. > static void BN_POOL_release(BN_POOL *p, unsigned int num)
          441.   	{
          442.   	unsigned int offset = (p->used - 1) % BN_CTX_POOL_SIZE;

crypto/bn/bn_ctx.c:442:2: Binary operation: ([0, +oo] - 1):unsigned32 by call to `BN_GF2m_mod_mul` 
          440.   static void BN_POOL_release(BN_POOL *p, unsigned int num)
          441.   	{
          442.   	unsigned int offset = (p->used - 1) % BN_CTX_POOL_SIZE;
                  ^
          443.   	p->used -= num;
          444.   	while(num--)
