// File: marxn[P]pupp/3rdparty/gmp/mpn/tdiv_qr.c
// Function: _gmpn_tdiv_qr
void
mpn_tdiv_qr (mp_ptr qp, mp_ptr rp, mp_size_t qxn,
	     mp_srcptr np, mp_size_t nn, mp_srcptr dp, mp_size_t dn)
{
  ASSERT_ALWAYS (qxn == 0);

  ASSERT (nn >= 0);
  ASSERT (dn >= 0);
  ASSERT (dn == 0 || dp[dn - 1] != 0);
  ASSERT (! MPN_OVERLAP_P (qp, nn - dn + 1 + qxn, np, nn));
  ASSERT (! MPN_OVERLAP_P (qp, nn - dn + 1 + qxn, dp, dn));

  switch (dn)
    {
    case 0:
      DIVIDE_BY_ZERO;

    case 1:
      {
	rp[0] = mpn_divrem_1 (qp, (mp_size_t) 0, np, nn, dp[0]);
	return;
      }

    case 2:
      {
	mp_ptr n2p, d2p;
	mp_limb_t qhl, cy;
	TMP_DECL;
	TMP_MARK;
	if ((dp[1] & GMP_NUMB_HIGHBIT) == 0)
	  {
	    int cnt;
	    mp_limb_t dtmp[2];
	    count_leading_zeros (cnt, dp[1]);
	    cnt -= GMP_NAIL_BITS;
	    d2p = dtmp;
	    d2p[1] = (dp[1] << cnt) | (dp[0] >> (GMP_NUMB_BITS - cnt));
	    d2p[0] = (dp[0] << cnt) & GMP_NUMB_MASK;
	    n2p = TMP_ALLOC_LIMBS (nn + 1);
	    cy = mpn_lshift (n2p, np, nn, cnt);
	    n2p[nn] = cy;
	    qhl = mpn_divrem_2 (qp, 0L, n2p, nn + (cy != 0), d2p);
	    if (cy == 0)
	      qp[nn - 2] = qhl;	/* always store nn-2+1 quotient limbs */
	    rp[0] = (n2p[0] >> cnt)
	      | ((n2p[1] << (GMP_NUMB_BITS - cnt)) & GMP_NUMB_MASK);
	    rp[1] = (n2p[1] >> cnt);
	  }
	else
	  {
	    d2p = (mp_ptr) dp;
	    n2p = TMP_ALLOC_LIMBS (nn);
	    MPN_COPY (n2p, np, nn);
	    qhl = mpn_divrem_2 (qp, 0L, n2p, nn, d2p);
	    qp[nn - 2] = qhl;	/* always store nn-2+1 quotient limbs */
	    rp[0] = n2p[0];
	    rp[1] = n2p[1];
	  }
	TMP_FREE;
	return;
      }

    default:
      {
	int adjust;
	gmp_pi1_t dinv;
	TMP_DECL;
	TMP_MARK;
	adjust = np[nn - 1] >= dp[dn - 1];	/* conservative tests for quotient size */
	if (nn + adjust >= 2 * dn)
	  {
	    mp_ptr n2p, d2p;
	    mp_limb_t cy;
	    int cnt;

	    qp[nn - dn] = 0;			  /* zero high quotient limb */
	    if ((dp[dn - 1] & GMP_NUMB_HIGHBIT) == 0) /* normalize divisor */
	      {
		count_leading_zeros (cnt, dp[dn - 1]);
		cnt -= GMP_NAIL_BITS;
		d2p = TMP_ALLOC_LIMBS (dn);
		mpn_lshift (d2p, dp, dn, cnt);
		n2p = TMP_ALLOC_LIMBS (nn + 1);
		cy = mpn_lshift (n2p, np, nn, cnt);
		n2p[nn] = cy;
		nn += adjust;
	      }
	    else
	      {
		cnt = 0;
		d2p = (mp_ptr) dp;
		n2p = TMP_ALLOC_LIMBS (nn + 1);
		MPN_COPY (n2p, np, nn);
		n2p[nn] = 0;
		nn += adjust;
	      }

	    invert_pi1 (dinv, d2p[dn - 1], d2p[dn - 2]);
	    if (BELOW_THRESHOLD (dn, DC_DIV_QR_THRESHOLD))
	      mpn_sbpi1_div_qr (qp, n2p, nn, d2p, dn, dinv.inv32);
	    else if (BELOW_THRESHOLD (dn, MUPI_DIV_QR_THRESHOLD) ||   /* fast condition */
		     BELOW_THRESHOLD (nn, 2 * MU_DIV_QR_THRESHOLD) || /* fast condition */
		     (double) (2 * (MU_DIV_QR_THRESHOLD - MUPI_DIV_QR_THRESHOLD)) * dn /* slow... */
		     + (double) MUPI_DIV_QR_THRESHOLD * nn > (double) dn * nn)    /* ...condition */
	      mpn_dcpi1_div_qr (qp, n2p, nn, d2p, dn, &dinv);
	    else
	      {
		mp_size_t itch = mpn_mu_div_qr_itch (nn, dn, 0);
		mp_ptr scratch = TMP_ALLOC_LIMBS (itch);
		mpn_mu_div_qr (qp, rp, n2p, nn, d2p, dn, scratch);
		n2p = rp;
	      }

	    if (cnt != 0)
	      mpn_rshift (rp, n2p, dn, cnt);
	    else
	      MPN_COPY (rp, n2p, dn);
	    TMP_FREE;
	    return;
	  }

	/* When we come here, the numerator/partial remainder is less
	   than twice the size of the denominator.  */

	  {
	    /* Problem:

	       Divide a numerator N with nn limbs by a denominator D with dn
	       limbs forming a quotient of qn=nn-dn+1 limbs.  When qn is small
	       compared to dn, conventional division algorithms perform poorly.
	       We want an algorithm that has an expected running time that is
	       dependent only on qn.

	       Algorithm (very informally stated):

	       1) Divide the 2 x qn most significant limbs from the numerator
		  by the qn most significant limbs from the denominator.  Call
		  the result qest.  This is either the correct quotient, but
		  might be 1 or 2 too large.  Compute the remainder from the
		  division.  (This step is implemented by an mpn_divrem call.)

	       2) Is the most significant limb from the remainder < p, where p
		  is the product of the most significant limb from the quotient
		  and the next(d)?  (Next(d) denotes the next ignored limb from
		  the denominator.)  If it is, decrement qest, and adjust the
		  remainder accordingly.

	       3) Is the remainder >= qest?  If it is, qest is the desired
		  quotient.  The algorithm terminates.

	       4) Subtract qest x next(d) from the remainder.  If there is
		  borrow out, decrement qest, and adjust the remainder
		  accordingly.

	       5) Skip one word from the denominator (i.e., let next(d) denote
		  the next less significant limb.  */

	    mp_size_t qn;
	    mp_ptr n2p, d2p;
	    mp_ptr tp;
	    mp_limb_t cy;
	    mp_size_t in, rn;
	    mp_limb_t quotient_too_large;
	    unsigned int cnt;

	    qn = nn - dn;
	    qp[qn] = 0;				/* zero high quotient limb */
	    qn += adjust;			/* qn cannot become bigger */

	    if (qn == 0)
	      {
		MPN_COPY (rp, np, dn);
		TMP_FREE;
		return;
	      }

	    in = dn - qn;		/* (at least partially) ignored # of limbs in ops */
	    /* Normalize denominator by shifting it to the left such that its
	       most significant bit is set.  Then shift the numerator the same
	       amount, to mathematically preserve quotient.  */
	    if ((dp[dn - 1] & GMP_NUMB_HIGHBIT) == 0)
	      {
		count_leading_zeros (cnt, dp[dn - 1]);
		cnt -= GMP_NAIL_BITS;

		d2p = TMP_ALLOC_LIMBS (qn);
		mpn_lshift (d2p, dp + in, qn, cnt);
		d2p[0] |= dp[in - 1] >> (GMP_NUMB_BITS - cnt);

		n2p = TMP_ALLOC_LIMBS (2 * qn + 1);
		cy = mpn_lshift (n2p, np + nn - 2 * qn, 2 * qn, cnt);
		if (adjust)
		  {
		    n2p[2 * qn] = cy;
		    n2p++;
		  }
		else
		  {
		    n2p[0] |= np[nn - 2 * qn - 1] >> (GMP_NUMB_BITS - cnt);
		  }
	      }
	    else
	      {
		cnt = 0;
		d2p = (mp_ptr) dp + in;

		n2p = TMP_ALLOC_LIMBS (2 * qn + 1);
		MPN_COPY (n2p, np + nn - 2 * qn, 2 * qn);
		if (adjust)
		  {
		    n2p[2 * qn] = 0;
		    n2p++;
		  }
	      }

	    /* Get an approximate quotient using the extracted operands.  */
	    if (qn == 1)
	      {
		mp_limb_t q0, r0;
		udiv_qrnnd (q0, r0, n2p[1], n2p[0] << GMP_NAIL_BITS, d2p[0] << GMP_NAIL_BITS);
		n2p[0] = r0 >> GMP_NAIL_BITS;
		qp[0] = q0;
	      }
	    else if (qn == 2)
	      mpn_divrem_2 (qp, 0L, n2p, 4L, d2p); /* FIXME: obsolete function */
	    else
	      {
		invert_pi1 (dinv, d2p[qn - 1], d2p[qn - 2]);
		if (BELOW_THRESHOLD (qn, DC_DIV_QR_THRESHOLD))
		  mpn_sbpi1_div_qr (qp, n2p, 2 * qn, d2p, qn, dinv.inv32);
		else if (BELOW_THRESHOLD (qn, MU_DIV_QR_THRESHOLD))
		  mpn_dcpi1_div_qr (qp, n2p, 2 * qn, d2p, qn, &dinv);
		else
		  {
		    mp_size_t itch = mpn_mu_div_qr_itch (2 * qn, qn, 0);
		    mp_ptr scratch = TMP_ALLOC_LIMBS (itch);
		    mp_ptr r2p = rp;
		    if (np == r2p)	/* If N and R share space, put ... */
		      r2p += nn - qn;	/* intermediate remainder at N's upper end. */
		    mpn_mu_div_qr (qp, r2p, n2p, 2 * qn, d2p, qn, scratch);
		    MPN_COPY (n2p, r2p, qn);
		  }
	      }

	    rn = qn;
	    /* Multiply the first ignored divisor limb by the most significant
	       quotient limb.  If that product is > the partial remainder's
	       most significant limb, we know the quotient is too large.  This
	       test quickly catches most cases where the quotient is too large;
	       it catches all cases where the quotient is 2 too large.  */
	    {
	      mp_limb_t dl, x;
	      mp_limb_t h, dummy;

	      if (in - 2 < 0)
		dl = 0;
	      else
		dl = dp[in - 2];

#if GMP_NAIL_BITS == 0
	      x = (dp[in - 1] << cnt) | ((dl >> 1) >> ((~cnt) % GMP_LIMB_BITS));
#else
	      x = (dp[in - 1] << cnt) & GMP_NUMB_MASK;
	      if (cnt != 0)
		x |= dl >> (GMP_NUMB_BITS - cnt);
#endif
	      umul_ppmm (h, dummy, x, qp[qn - 1] << GMP_NAIL_BITS);

	      if (n2p[qn - 1] < h)
		{
		  mp_limb_t cy;

		  mpn_decr_u (qp, (mp_limb_t) 1);
		  cy = mpn_add_n (n2p, n2p, d2p, qn);
		  if (cy)
		    {
		      /* The partial remainder is safely large.  */
		      n2p[qn] = cy;
		      ++rn;
		    }
		}
	    }

	    quotient_too_large = 0;
	    if (cnt != 0)
	      {
		mp_limb_t cy1, cy2;

		/* Append partially used numerator limb to partial remainder.  */
		cy1 = mpn_lshift (n2p, n2p, rn, GMP_NUMB_BITS - cnt);
		n2p[0] |= np[in - 1] & (GMP_NUMB_MASK >> cnt);

		/* Update partial remainder with partially used divisor limb.  */
		cy2 = mpn_submul_1 (n2p, qp, qn, dp[in - 1] & (GMP_NUMB_MASK >> cnt));
		if (qn != rn)
		  {
		    ASSERT_ALWAYS (n2p[qn] >= cy2);
		    n2p[qn] -= cy2;
		  }
		else
		  {
		    n2p[qn] = cy1 - cy2; /* & GMP_NUMB_MASK; */

		    quotient_too_large = (cy1 < cy2);
		    ++rn;
		  }
		--in;
	      }
	    /* True: partial remainder now is neutral, i.e., it is not shifted up.  */

	    tp = TMP_ALLOC_LIMBS (dn);

	    if (in < qn)
	      {
		if (in == 0)
		  {
		    MPN_COPY (rp, n2p, rn);
		    ASSERT_ALWAYS (rn == dn);
		    goto foo;
		  }
		mpn_mul (tp, qp, qn, dp, in);
	      }
	    else
	      mpn_mul (tp, dp, in, qp, qn);

	    cy = mpn_sub (n2p, n2p, rn, tp + in, qn);
	    MPN_COPY (rp + in, n2p, dn - in);
	    quotient_too_large |= cy;
	    cy = mpn_sub_n (rp, np, tp, in);
	    cy = mpn_sub_1 (rp + in, rp + in, rn, cy);
	    quotient_too_large |= cy;
	  foo:
	    if (quotient_too_large)
	      {
		mpn_decr_u (qp, (mp_limb_t) 1);
		mpn_add_n (rp, rp, dp, dn);
	      }
	  }
	TMP_FREE;
	return;
      }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
sete %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3ce41
leaq 0x26ca8(%rip), %rdi     # 0x63ad8
movl $0x33, %esi
leaq 0x26ca6(%rip), %rdx     # 0x63ae2
callq 0x562c0
jmp 0x3ce43
jmp 0x3ce45
jmp 0x3ce47
jmp 0x3ce49
jmp 0x3ce4b
jmp 0x3ce4d
jmp 0x3ce4f
jmp 0x3ce51
jmp 0x3ce53
jmp 0x3ce55
jmp 0x3ce57
movq 0x10(%rbp), %rax
movq %rax, -0x218(%rbp)
testq %rax, %rax
je 0x3ce8a
jmp 0x3ce69
movq -0x218(%rbp), %rax
subq $0x1, %rax
je 0x3ce8f
jmp 0x3ce78
movq -0x218(%rbp), %rax
subq $0x2, %rax
je 0x3ceba
jmp 0x3d1cd
callq 0x56350
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq (%rax), %r8
xorl %eax, %eax
movl %eax, %esi
callq 0x37ba0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x3e7f3
movq $0x0, -0x58(%rbp)
movq -0x30(%rbp), %rcx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq 0x8(%rcx), %rax
cmpq $0x0, %rax
jne 0x3d0b5
jmp 0x3cee0
jmp 0x3cee2
jmp 0x3cee4
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x1e0(%rbp)
bsrq -0x1e0(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
xorq $0x3f, %rax
movl %eax, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
subl $0x0, %eax
movl %eax, -0x5c(%rbp)
leaq -0x70(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x5c(%rbp), %ecx
shlq %cl, %rax
movq %rax, -0x220(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl $0x40, %ecx
subl -0x5c(%rbp), %ecx
movl %ecx, %ecx
shrq %cl, %rax
movq -0x220(%rbp), %rcx
orq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl -0x5c(%rbp), %ecx
shlq %cl, %rax
movq %rax, %rcx
andq $-0x1, %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
shlq $0x3, %rax
cmpq $0x7f00, %rax           # imm = 0x7F00
setbe %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3cfc0
movq -0x28(%rbp), %rax
leaq 0x17(,%rax,8), %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x228(%rbp)
jmp 0x3cfdc
movq -0x28(%rbp), %rsi
addq $0x1, %rsi
shlq $0x3, %rsi
leaq -0x58(%rbp), %rdi
callq 0x56430
movq %rax, -0x228(%rbp)
movq -0x228(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x5c(%rbp), %ecx
callq 0x37320
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdx
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq -0x28(%rbp), %rcx
cmpq $0x0, -0x50(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
addq %rax, %rcx
movq -0x40(%rbp), %r8
xorl %eax, %eax
movl %eax, %esi
callq 0x37dc0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x3d059
movq -0x48(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x2, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movl -0x5c(%rbp), %ecx
shrq %cl, %rax
movq %rax, -0x230(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movl $0x40, %ecx
subl -0x5c(%rbp), %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq -0x230(%rbp), %rcx
andq $-0x1, %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x5c(%rbp), %ecx
shrq %cl, %rax
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x3d19b
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
shlq $0x3, %rax
cmpq $0x7f00, %rax           # imm = 0x7F00
setbe %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3d108
movq -0x28(%rbp), %rax
leaq 0xf(,%rax,8), %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x238(%rbp)
jmp 0x3d120
movq -0x28(%rbp), %rsi
shlq $0x3, %rsi
leaq -0x58(%rbp), %rdi
callq 0x56430
movq %rax, -0x238(%rbp)
movq -0x238(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x3d12d
jmp 0x3d12f
jmp 0x3d131
jmp 0x3d133
jmp 0x3d135
jmp 0x3d137
jmp 0x3d139
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x554c6
jmp 0x3d14c
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %r8
xorl %eax, %eax
movl %eax, %esi
callq 0x37dc0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x2, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x3d19d
cmpq $0x0, -0x58(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3d1c6
movq -0x58(%rbp), %rdi
callq 0x564a0
jmp 0x3d1c8
jmp 0x3e7f3
movq $0x0, -0x90(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq -0x30(%rbp), %rcx
movq 0x10(%rbp), %rdx
subq $0x1, %rdx
cmpq (%rcx,%rdx,8), %rax
setae %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x7c(%rbp)
movq -0x28(%rbp), %rax
movslq -0x7c(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rbp), %rcx
shlq %rcx
cmpq %rcx, %rax
jl 0x3d8fe
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
subq 0x10(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x30(%rbp), %rcx
movq 0x10(%rbp), %rdx
subq $0x1, %rdx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq (%rcx,%rdx,8), %rax
cmpq $0x0, %rax
jne 0x3d3f4
jmp 0x3d258
jmp 0x3d25a
jmp 0x3d25c
movq -0x30(%rbp), %rax
movq 0x10(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x208(%rbp)
bsrq -0x208(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
xorq $0x3f, %rax
movl %eax, -0xac(%rbp)
movl -0xac(%rbp), %eax
subl $0x0, %eax
movl %eax, -0xac(%rbp)
movq 0x10(%rbp), %rax
shlq $0x3, %rax
cmpq $0x7f00, %rax           # imm = 0x7F00
setbe %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3d2ed
movq 0x10(%rbp), %rax
leaq 0xf(,%rax,8), %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x240(%rbp)
jmp 0x3d308
movq 0x10(%rbp), %rsi
shlq $0x3, %rsi
leaq -0x90(%rbp), %rdi
callq 0x56430
movq %rax, -0x240(%rbp)
movq -0x240(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq 0x10(%rbp), %rdx
movl -0xac(%rbp), %ecx
callq 0x37320
movq -0x28(%rbp), %rax
addq $0x1, %rax
shlq $0x3, %rax
cmpq $0x7f00, %rax           # imm = 0x7F00
setbe %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3d37f
movq -0x28(%rbp), %rax
leaq 0x17(,%rax,8), %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x248(%rbp)
jmp 0x3d39e
movq -0x28(%rbp), %rsi
addq $0x1, %rsi
shlq $0x3, %rsi
leaq -0x90(%rbp), %rdi
callq 0x56430
movq %rax, -0x248(%rbp)
movq -0x248(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0xac(%rbp), %ecx
callq 0x37320
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rdx
movq -0x98(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movslq -0x7c(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x3d4c8
movl $0x0, -0xac(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
shlq $0x3, %rax
cmpq $0x7f00, %rax           # imm = 0x7F00
setbe %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3d458
movq -0x28(%rbp), %rax
leaq 0x17(,%rax,8), %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x250(%rbp)
jmp 0x3d477
movq -0x28(%rbp), %rsi
addq $0x1, %rsi
shlq $0x3, %rsi
leaq -0x90(%rbp), %rdi
callq 0x56430
movq %rax, -0x250(%rbp)
movq -0x250(%rbp), %rax
movq %rax, -0x98(%rbp)
jmp 0x3d487
jmp 0x3d489
jmp 0x3d48b
jmp 0x3d48d
jmp 0x3d48f
jmp 0x3d491
jmp 0x3d493
movq -0x98(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x554c6
jmp 0x3d4a9
movq -0x98(%rbp), %rax
movq -0x28(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movslq -0x7c(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x3d4ca
jmp 0x3d4cc
movq -0xa0(%rbp), %rax
movq 0x10(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x55530
movq %rax, -0xc0(%rbp)
movq -0xa0(%rbp), %rax
movq 0x10(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
imulq -0xc0(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0xa0(%rbp), %rax
movq 0x10(%rbp), %rcx
subq $0x2, %rcx
movq (%rax,%rcx,8), %rax
addq -0xc8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0xc8(%rbp), %rax
movq -0xa0(%rbp), %rcx
movq 0x10(%rbp), %rdx
subq $0x2, %rdx
cmpq (%rcx,%rdx,8), %rax
jae 0x3d5f5
movq -0xc0(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0xc0(%rbp)
movq -0xc8(%rbp), %rax
movq -0xa0(%rbp), %rcx
movq 0x10(%rbp), %rdx
subq $0x1, %rdx
cmpq (%rcx,%rdx,8), %rax
setae %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
xorl %eax, %eax
subq %rcx, %rax
movq %rax, -0xe0(%rbp)
movq -0xa0(%rbp), %rax
movq 0x10(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rcx
movq -0xc8(%rbp), %rax
subq %rcx, %rax
movq %rax, -0xc8(%rbp)
movq -0xe0(%rbp), %rax
addq -0xc0(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0xe0(%rbp), %rcx
movq -0xa0(%rbp), %rax
movq 0x10(%rbp), %rdx
subq $0x1, %rdx
andq (%rax,%rdx,8), %rcx
movq -0xc8(%rbp), %rax
subq %rcx, %rax
movq %rax, -0xc8(%rbp)
movq -0xa0(%rbp), %rax
movq 0x10(%rbp), %rcx
subq $0x2, %rcx
movq (%rax,%rcx,8), %rax
movq -0xc0(%rbp), %rcx
movq %rcx, -0x210(%rbp)
mulq -0x210(%rbp)
movq %rax, -0xd8(%rbp)
movq %rdx, -0xd0(%rbp)
movq -0xd0(%rbp), %rax
addq -0xc8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0xc8(%rbp), %rax
cmpq -0xd0(%rbp), %rax
jae 0x3d6e9
movq -0xc0(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0xc0(%rbp)
movq -0xc8(%rbp), %rax
movq -0xa0(%rbp), %rcx
movq 0x10(%rbp), %rdx
subq $0x1, %rdx
cmpq (%rcx,%rdx,8), %rax
setae %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3d6e7
movq -0xc8(%rbp), %rax
movq -0xa0(%rbp), %rcx
movq 0x10(%rbp), %rdx
subq $0x1, %rdx
cmpq (%rcx,%rdx,8), %rax
ja 0x3d6d3
movq -0xd8(%rbp), %rax
movq -0xa0(%rbp), %rcx
movq 0x10(%rbp), %rdx
subq $0x2, %rdx
cmpq (%rcx,%rdx,8), %rax
jb 0x3d6e5
movq -0xc0(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0xc0(%rbp)
jmp 0x3d6e7
jmp 0x3d6e9
movq -0xc0(%rbp), %rax
movq %rax, -0x88(%rbp)
cmpq $0x33, 0x10(%rbp)
jge 0x3d729
movq -0x8(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0xa0(%rbp), %rcx
movq 0x10(%rbp), %r8
movq -0x88(%rbp), %r9
callq 0x505f0
jmp 0x3d879
cmpq $0x5d, 0x10(%rbp)
jl 0x3d778
cmpq $0x1052, -0x28(%rbp)    # imm = 0x1052
jl 0x3d778
cvtsi2sdq 0x10(%rbp), %xmm0
cvtsi2sdq -0x28(%rbp), %xmm2
movsd 0x2637a(%rip), %xmm1    # 0x63ac8
mulsd %xmm2, %xmm1
movsd 0x26376(%rip), %xmm2    # 0x63ad0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtsi2sdq 0x10(%rbp), %xmm1
cvtsi2sdq -0x28(%rbp), %xmm2
mulsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x3d7a3
movq -0x8(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0xa0(%rbp), %rcx
movq 0x10(%rbp), %r8
leaq -0x88(%rbp), %r9
callq 0x51dd0
jmp 0x3d877
movq -0x28(%rbp), %rdi
movq 0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x541a0
movq %rax, -0xe8(%rbp)
movq -0xe8(%rbp), %rax
shlq $0x3, %rax
cmpq $0x7f00, %rax           # imm = 0x7F00
setbe %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3d80a
movq -0xe8(%rbp), %rax
leaq 0xf(,%rax,8), %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x258(%rbp)
jmp 0x3d828
movq -0xe8(%rbp), %rsi
shlq $0x3, %rsi
leaq -0x90(%rbp), %rdi
callq 0x56430
movq %rax, -0x258(%rbp)
movq -0x258(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x98(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0xa0(%rbp), %r8
movq 0x10(%rbp), %r9
movq -0xf0(%rbp), %rax
subq $0x10, %rsp
movq %rax, (%rsp)
callq 0x536f0
addq $0x10, %rsp
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
jmp 0x3d879
cmpl $0x0, -0xac(%rbp)
je 0x3d89e
movq -0x10(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq 0x10(%rbp), %rdx
movl -0xac(%rbp), %ecx
callq 0x56880
jmp 0x3d8c6
jmp 0x3d8a0
jmp 0x3d8a2
jmp 0x3d8a4
jmp 0x3d8a6
jmp 0x3d8a8
jmp 0x3d8aa
jmp 0x3d8ac
jmp 0x3d8ae
movq -0x10(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq 0x10(%rbp), %rdx
callq 0x554c6
jmp 0x3d8c4
jmp 0x3d8c6
jmp 0x3d8c8
cmpq $0x0, -0x90(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3d8f7
movq -0x90(%rbp), %rdi
callq 0x564a0
jmp 0x3d8f9
jmp 0x3e7f3
movq -0x28(%rbp), %rax
subq 0x10(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq -0x8(%rbp), %rax
movq -0xf8(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movslq -0x7c(%rbp), %rax
addq -0xf8(%rbp), %rax
movq %rax, -0xf8(%rbp)
cmpq $0x0, -0xf8(%rbp)
jne 0x3d997
jmp 0x3d93e
jmp 0x3d940
jmp 0x3d942
jmp 0x3d944
jmp 0x3d946
jmp 0x3d948
jmp 0x3d94a
jmp 0x3d94c
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq 0x10(%rbp), %rdx
callq 0x554c6
jmp 0x3d95f
jmp 0x3d961
cmpq $0x0, -0x90(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3d990
movq -0x90(%rbp), %rdi
callq 0x564a0
jmp 0x3d992
jmp 0x3e7f3
movq 0x10(%rbp), %rax
subq -0xf8(%rbp), %rax
movq %rax, -0x120(%rbp)
movq -0x30(%rbp), %rcx
movq 0x10(%rbp), %rdx
subq $0x1, %rdx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq (%rcx,%rdx,8), %rax
cmpq $0x0, %rax
jne 0x3dc3f
jmp 0x3d9cf
jmp 0x3d9d1
jmp 0x3d9d3
movq -0x30(%rbp), %rax
movq 0x10(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x1e8(%rbp)
bsrq -0x1e8(%rbp), %rax
movq %rax, -0x140(%rbp)
movq -0x140(%rbp), %rax
xorq $0x3f, %rax
movl %eax, -0x134(%rbp)
movl -0x134(%rbp), %eax
subl $0x0, %eax
movl %eax, -0x134(%rbp)
movq -0xf8(%rbp), %rax
shlq $0x3, %rax
cmpq $0x7f00, %rax           # imm = 0x7F00
setbe %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3da6a
movq -0xf8(%rbp), %rax
leaq 0xf(,%rax,8), %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x260(%rbp)
jmp 0x3da88
movq -0xf8(%rbp), %rsi
shlq $0x3, %rsi
leaq -0x90(%rbp), %rdi
callq 0x56430
movq %rax, -0x260(%rbp)
movq -0x260(%rbp), %rax
movq %rax, -0x108(%rbp)
movq -0x108(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x120(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0xf8(%rbp), %rdx
movl -0x134(%rbp), %ecx
callq 0x37320
movq -0x30(%rbp), %rax
movq -0x120(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movl $0x40, %ecx
subl -0x134(%rbp), %ecx
movl %ecx, %ecx
shrq %cl, %rax
movq %rax, %rcx
movq -0x108(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movq -0xf8(%rbp), %rax
shlq %rax
addq $0x1, %rax
shlq $0x3, %rax
cmpq $0x7f00, %rax           # imm = 0x7F00
setbe %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3db4c
movq -0xf8(%rbp), %rcx
shlq $0x4, %rcx
addq $0x17, %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x268(%rbp)
jmp 0x3db71
movq -0xf8(%rbp), %rsi
shlq %rsi
addq $0x1, %rsi
shlq $0x3, %rsi
leaq -0x90(%rbp), %rdi
callq 0x56430
movq %rax, -0x268(%rbp)
movq -0x268(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x100(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0xf8(%rbp), %rcx
shlq %rcx
xorl %eax, %eax
subq %rcx, %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0xf8(%rbp), %rdx
shlq %rdx
movl -0x134(%rbp), %ecx
callq 0x37320
movq %rax, -0x118(%rbp)
cmpl $0x0, -0x7c(%rbp)
je 0x3dbfd
movq -0x118(%rbp), %rdx
movq -0x100(%rbp), %rax
movq -0xf8(%rbp), %rcx
shlq %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x100(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x100(%rbp)
jmp 0x3dc3a
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq -0xf8(%rbp), %rdx
shlq %rdx
subq %rdx, %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movl $0x40, %ecx
subl -0x134(%rbp), %ecx
movl %ecx, %ecx
shrq %cl, %rax
movq %rax, %rcx
movq -0x100(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x3dd6b
movl $0x0, -0x134(%rbp)
movq -0x30(%rbp), %rax
movq -0x120(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x108(%rbp)
movq -0xf8(%rbp), %rax
shlq %rax
addq $0x1, %rax
shlq $0x3, %rax
cmpq $0x7f00, %rax           # imm = 0x7F00
setbe %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3dcba
movq -0xf8(%rbp), %rcx
shlq $0x4, %rcx
addq $0x17, %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x270(%rbp)
jmp 0x3dcdf
movq -0xf8(%rbp), %rsi
shlq %rsi
addq $0x1, %rsi
shlq $0x3, %rsi
leaq -0x90(%rbp), %rdi
callq 0x56430
movq %rax, -0x270(%rbp)
movq -0x270(%rbp), %rax
movq %rax, -0x100(%rbp)
jmp 0x3dcef
jmp 0x3dcf1
jmp 0x3dcf3
jmp 0x3dcf5
jmp 0x3dcf7
jmp 0x3dcf9
jmp 0x3dcfb
movq -0x100(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0xf8(%rbp), %rcx
shlq %rcx
xorl %eax, %eax
subq %rcx, %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0xf8(%rbp), %rdx
shlq %rdx
callq 0x554c6
jmp 0x3dd38
cmpl $0x0, -0x7c(%rbp)
je 0x3dd69
movq -0x100(%rbp), %rax
movq -0xf8(%rbp), %rcx
shlq %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x100(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x100(%rbp)
jmp 0x3dd6b
cmpq $0x1, -0xf8(%rbp)
jne 0x3dde0
movq -0x100(%rbp), %rax
movq (%rax), %rax
shlq $0x0, %rax
movq -0x100(%rbp), %rcx
movq 0x8(%rcx), %rdx
movq -0x108(%rbp), %rcx
movq (%rcx), %rcx
shlq $0x0, %rcx
movq %rcx, -0x1f8(%rbp)
divq -0x1f8(%rbp)
movq %rax, -0x148(%rbp)
movq %rdx, -0x150(%rbp)
movq -0x150(%rbp), %rcx
shrq $0x0, %rcx
movq -0x100(%rbp), %rax
movq %rcx, (%rax)
movq -0x148(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x3e223
cmpq $0x2, -0xf8(%rbp)
jne 0x3de0f
movq -0x8(%rbp), %rdi
movq -0x100(%rbp), %rdx
movq -0x108(%rbp), %r8
xorl %eax, %eax
movl %eax, %esi
movl $0x4, %ecx
callq 0x37dc0
jmp 0x3e221
jmp 0x3de11
jmp 0x3de13
movq -0x108(%rbp), %rax
movq -0xf8(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x55530
movq %rax, -0x158(%rbp)
movq -0x108(%rbp), %rax
movq -0xf8(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
imulq -0x158(%rbp), %rax
movq %rax, -0x160(%rbp)
movq -0x108(%rbp), %rax
movq -0xf8(%rbp), %rcx
subq $0x2, %rcx
movq (%rax,%rcx,8), %rax
addq -0x160(%rbp), %rax
movq %rax, -0x160(%rbp)
movq -0x160(%rbp), %rax
movq -0x108(%rbp), %rcx
movq -0xf8(%rbp), %rdx
subq $0x2, %rdx
cmpq (%rcx,%rdx,8), %rax
jae 0x3df51
movq -0x158(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x158(%rbp)
movq -0x160(%rbp), %rax
movq -0x108(%rbp), %rcx
movq -0xf8(%rbp), %rdx
subq $0x1, %rdx
cmpq (%rcx,%rdx,8), %rax
setae %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
xorl %eax, %eax
subq %rcx, %rax
movq %rax, -0x178(%rbp)
movq -0x108(%rbp), %rax
movq -0xf8(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rcx
movq -0x160(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x160(%rbp)
movq -0x178(%rbp), %rax
addq -0x158(%rbp), %rax
movq %rax, -0x158(%rbp)
movq -0x178(%rbp), %rcx
movq -0x108(%rbp), %rax
movq -0xf8(%rbp), %rdx
subq $0x1, %rdx
andq (%rax,%rdx,8), %rcx
movq -0x160(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x160(%rbp)
movq -0x108(%rbp), %rax
movq -0xf8(%rbp), %rcx
subq $0x2, %rcx
movq (%rax,%rcx,8), %rax
movq -0x158(%rbp), %rcx
movq %rcx, -0x1f0(%rbp)
mulq -0x1f0(%rbp)
movq %rax, -0x170(%rbp)
movq %rdx, -0x168(%rbp)
movq -0x168(%rbp), %rax
addq -0x160(%rbp), %rax
movq %rax, -0x160(%rbp)
movq -0x160(%rbp), %rax
cmpq -0x168(%rbp), %rax
jae 0x3e051
movq -0x158(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x158(%rbp)
movq -0x160(%rbp), %rax
movq -0x108(%rbp), %rcx
movq -0xf8(%rbp), %rdx
subq $0x1, %rdx
cmpq (%rcx,%rdx,8), %rax
setae %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3e04f
movq -0x160(%rbp), %rax
movq -0x108(%rbp), %rcx
movq -0xf8(%rbp), %rdx
subq $0x1, %rdx
cmpq (%rcx,%rdx,8), %rax
ja 0x3e03b
movq -0x170(%rbp), %rax
movq -0x108(%rbp), %rcx
movq -0xf8(%rbp), %rdx
subq $0x2, %rdx
cmpq (%rcx,%rdx,8), %rax
jb 0x3e04d
movq -0x158(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x158(%rbp)
jmp 0x3e04f
jmp 0x3e051
movq -0x158(%rbp), %rax
movq %rax, -0x88(%rbp)
cmpq $0x33, -0xf8(%rbp)
jge 0x3e09d
movq -0x8(%rbp), %rdi
movq -0x100(%rbp), %rsi
movq -0xf8(%rbp), %rdx
shlq %rdx
movq -0x108(%rbp), %rcx
movq -0xf8(%rbp), %r8
movq -0x88(%rbp), %r9
callq 0x505f0
jmp 0x3e21f
cmpq $0x829, -0xf8(%rbp) # imm = 0x829
jge 0x3e0de
movq -0x8(%rbp), %rdi
movq -0x100(%rbp), %rsi
movq -0xf8(%rbp), %rdx
shlq %rdx
movq -0x108(%rbp), %rcx
movq -0xf8(%rbp), %r8
leaq -0x88(%rbp), %r9
callq 0x51dd0
jmp 0x3e21d
movq -0xf8(%rbp), %rdi
shlq %rdi
movq -0xf8(%rbp), %rsi
xorl %edx, %edx
callq 0x541a0
movq %rax, -0x180(%rbp)
movq -0x180(%rbp), %rax
shlq $0x3, %rax
cmpq $0x7f00, %rax           # imm = 0x7F00
setbe %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3e14e
movq -0x180(%rbp), %rax
leaq 0xf(,%rax,8), %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x278(%rbp)
jmp 0x3e16c
movq -0x180(%rbp), %rsi
shlq $0x3, %rsi
leaq -0x90(%rbp), %rdi
callq 0x56430
movq %rax, -0x278(%rbp)
movq -0x278(%rbp), %rax
movq %rax, -0x188(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x190(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x190(%rbp), %rax
jne 0x3e1af
movq -0x28(%rbp), %rax
subq -0xf8(%rbp), %rax
shlq $0x3, %rax
addq -0x190(%rbp), %rax
movq %rax, -0x190(%rbp)
movq -0x8(%rbp), %rdi
movq -0x190(%rbp), %rsi
movq -0x100(%rbp), %rdx
movq -0xf8(%rbp), %rcx
shlq %rcx
movq -0x108(%rbp), %r8
movq -0xf8(%rbp), %r9
movq -0x188(%rbp), %rax
subq $0x10, %rsp
movq %rax, (%rsp)
callq 0x536f0
addq $0x10, %rsp
jmp 0x3e1f3
jmp 0x3e1f5
jmp 0x3e1f7
jmp 0x3e1f9
jmp 0x3e1fb
jmp 0x3e1fd
jmp 0x3e1ff
movq -0x100(%rbp), %rdi
movq -0x190(%rbp), %rsi
movq -0xf8(%rbp), %rdx
callq 0x554c6
jmp 0x3e21b
jmp 0x3e21d
jmp 0x3e21f
jmp 0x3e221
jmp 0x3e223
movq -0xf8(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0x120(%rbp), %rax
subq $0x2, %rax
cmpq $0x0, %rax
jge 0x3e24f
movq $0x0, -0x198(%rbp)
jmp 0x3e269
movq -0x30(%rbp), %rax
movq -0x120(%rbp), %rcx
subq $0x2, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x198(%rbp)
movq -0x30(%rbp), %rax
movq -0x120(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movl -0x134(%rbp), %ecx
shlq %cl, %rax
movq -0x198(%rbp), %rdx
shrq %rdx
movl -0x134(%rbp), %ecx
xorl $-0x1, %ecx
andl $0x3f, %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x1a0(%rbp)
movq -0x1a0(%rbp), %rax
movq -0x8(%rbp), %rcx
movq -0xf8(%rbp), %rdx
subq $0x1, %rdx
movq (%rcx,%rdx,8), %rcx
shlq $0x0, %rcx
movq %rcx, -0x200(%rbp)
mulq -0x200(%rbp)
movq %rax, -0x1b0(%rbp)
movq %rdx, -0x1a8(%rbp)
movq -0x100(%rbp), %rax
movq -0xf8(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x1a8(%rbp), %rax
jae 0x3e37c
jmp 0x3e308
movq -0x8(%rbp), %rax
subq $0x1, (%rax)
leaq 0x8(%rax), %rax
jb 0x3e30c
movq %rax, -0x1c0(%rbp)
movq -0x100(%rbp), %rdi
movq -0x100(%rbp), %rsi
movq -0x108(%rbp), %rdx
movq -0xf8(%rbp), %rcx
callq 0x36c80
movq %rax, -0x1b8(%rbp)
cmpq $0x0, -0x1b8(%rbp)
je 0x3e37a
movq -0x1b8(%rbp), %rdx
movq -0x100(%rbp), %rax
movq -0xf8(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x128(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x128(%rbp)
jmp 0x3e37c
movq $0x0, -0x130(%rbp)
cmpl $0x0, -0x134(%rbp)
je 0x3e53e
movq -0x100(%rbp), %rdi
movq -0x100(%rbp), %rsi
movq -0x128(%rbp), %rdx
movl $0x40, %ecx
subl -0x134(%rbp), %ecx
callq 0x37320
movq %rax, -0x1c8(%rbp)
movq -0x20(%rbp), %rax
movq -0x120(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x288(%rbp)
movl -0x134(%rbp), %eax
movl %eax, %ecx
movq $-0x1, %rax
shrq %cl, %rax
movq -0x288(%rbp), %rcx
andq %rax, %rcx
movq -0x100(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movq -0x100(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0xf8(%rbp), %rdx
movq -0x30(%rbp), %rax
movq -0x120(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x280(%rbp)
movl -0x134(%rbp), %eax
movl %eax, %ecx
movq $-0x1, %rax
shrq %cl, %rax
movq -0x280(%rbp), %rcx
andq %rax, %rcx
callq 0x56760
movq %rax, -0x1d0(%rbp)
movq -0xf8(%rbp), %rax
cmpq -0x128(%rbp), %rax
je 0x3e4db
jmp 0x3e469
movq -0x100(%rbp), %rax
movq -0xf8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x1d0(%rbp), %rax
setae %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3e4b7
leaq 0x25632(%rip), %rdi     # 0x63ad8
movl $0x157, %esi            # imm = 0x157
leaq 0x25639(%rip), %rdx     # 0x63aeb
callq 0x562c0
jmp 0x3e4b9
movq -0x1d0(%rbp), %rsi
movq -0x100(%rbp), %rax
movq -0xf8(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
subq %rsi, %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x3e52c
movq -0x1c8(%rbp), %rdx
subq -0x1d0(%rbp), %rdx
movq -0x100(%rbp), %rax
movq -0xf8(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x1c8(%rbp), %rax
cmpq -0x1d0(%rbp), %rax
setb %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x130(%rbp)
movq -0x128(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x128(%rbp)
movq -0x120(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x120(%rbp)
movq 0x10(%rbp), %rax
shlq $0x3, %rax
cmpq $0x7f00, %rax           # imm = 0x7F00
setbe %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3e589
movq 0x10(%rbp), %rax
leaq 0xf(,%rax,8), %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x290(%rbp)
jmp 0x3e5a4
movq 0x10(%rbp), %rsi
shlq $0x3, %rsi
leaq -0x90(%rbp), %rdi
callq 0x56430
movq %rax, -0x290(%rbp)
movq -0x290(%rbp), %rax
movq %rax, -0x110(%rbp)
movq -0x120(%rbp), %rax
cmpq -0xf8(%rbp), %rax
jge 0x3e666
cmpq $0x0, -0x120(%rbp)
jne 0x3e642
jmp 0x3e5d2
jmp 0x3e5d4
jmp 0x3e5d6
jmp 0x3e5d8
jmp 0x3e5da
jmp 0x3e5dc
jmp 0x3e5de
jmp 0x3e5e0
movq -0x10(%rbp), %rdi
movq -0x100(%rbp), %rsi
movq -0x128(%rbp), %rdx
callq 0x554c6
jmp 0x3e5f9
jmp 0x3e5fb
movq -0x128(%rbp), %rax
cmpq 0x10(%rbp), %rax
sete %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3e63b
leaq 0x254ae(%rip), %rdi     # 0x63ad8
movl $0x16c, %esi            # imm = 0x16C
leaq 0x254c4(%rip), %rdx     # 0x63afa
callq 0x562c0
jmp 0x3e63d
jmp 0x3e788
movq -0x110(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0xf8(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x120(%rbp), %r8
callq 0x37f00
jmp 0x3e688
movq -0x110(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x120(%rbp), %rdx
movq -0x8(%rbp), %rcx
movq -0xf8(%rbp), %r8
callq 0x37f00
movq -0x100(%rbp), %rdi
movq -0x100(%rbp), %rsi
movq -0x128(%rbp), %rdx
movq -0x110(%rbp), %rcx
movq -0x120(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0xf8(%rbp), %r8
callq 0x36d60
movq %rax, -0x118(%rbp)
jmp 0x3e6c7
jmp 0x3e6c9
jmp 0x3e6cb
jmp 0x3e6cd
jmp 0x3e6cf
jmp 0x3e6d1
jmp 0x3e6d3
movq -0x10(%rbp), %rdi
movq -0x120(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x100(%rbp), %rsi
movq 0x10(%rbp), %rdx
subq -0x120(%rbp), %rdx
callq 0x554c6
jmp 0x3e6fe
movq -0x118(%rbp), %rax
orq -0x130(%rbp), %rax
movq %rax, -0x130(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x110(%rbp), %rdx
movq -0x120(%rbp), %rcx
callq 0x36fe0
movq %rax, -0x118(%rbp)
movq -0x10(%rbp), %rdi
movq -0x120(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x120(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x128(%rbp), %rdx
movq -0x118(%rbp), %rcx
callq 0x36e60
movq %rax, -0x118(%rbp)
movq -0x118(%rbp), %rax
orq -0x130(%rbp), %rax
movq %rax, -0x130(%rbp)
cmpq $0x0, -0x130(%rbp)
je 0x3e7be
jmp 0x3e794
movq -0x8(%rbp), %rax
subq $0x1, (%rax)
leaq 0x8(%rax), %rax
jb 0x3e798
movq %rax, -0x1d8(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x10(%rbp), %rcx
callq 0x36c80
jmp 0x3e7c0
cmpq $0x0, -0x90(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3e7ef
movq -0x90(%rbp), %rdi
callq 0x564a0
jmp 0x3e7f1
jmp 0x3e7f3
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax,%rax)