// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
testq %rdx, %rdx
jne 0x1c31d
movq %r8, %r11
movq %rcx, %r10
movq %rsi, %r13
movq %rdi, %r15
movq 0x10(%rbp), %rbx
cmpq $0x1, %rbx
je 0x1bb75
pushq $0x40
popq %rdi
cmpq $0x2, %rbx
je 0x1ba96
testq %rbx, %rbx
je 0x1c481
andq $0x0, -0x48(%rbp)
movq -0x8(%r10,%r11,8), %rdi
movq -0x8(%r9,%rbx,8), %r12
xorl %eax, %eax
cmpq %r12, %rdi
setae %al
leaq (%rax,%r11), %rdx
leaq (%rbx,%rbx), %rcx
movq %r11, %r14
subq %rbx, %r14
andq $0x0, (%r15,%r14,8)
cmpq %rcx, %rdx
movq %r13, -0x58(%rbp)
jge 0x1bb91
addq %rax, %r14
je 0x1bc97
leaq (%r10,%r11,8), %rcx
movq %rbx, %rax
subq %r14, %rax
movq %rax, -0x50(%rbp)
movq -0x8(%r9,%rbx,8), %rax
testq %rax, %rax
movq %r15, -0x40(%rbp)
movq %r10, -0x70(%rbp)
movq %r9, -0x68(%rbp)
movq %r11, -0x60(%rbp)
js 0x1bdf8
movq %rax, -0xb0(%rbp)
bsrq -0xb0(%rbp), %r13
xorl $0x3f, %r13d
leaq (,%r14,8), %rsi
cmpq $0x7f00, %rsi           # imm = 0x7F00
movq %rdi, -0x90(%rbp)
movq %rcx, -0x88(%rbp)
ja 0x1c3d0
movq %rsp, %rbx
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %rbx
movq %rbx, %rsp
movq -0x50(%rbp), %rax
leaq (%r9,%rax,8), %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %r13d, %ecx
callq 0x181a0
movq -0x8(%r15), %rax
movq %r13, -0x30(%rbp)
movl %r13d, %ecx
negl %ecx
shrq %cl, %rax
orq %rax, (%rbx)
leaq (%r14,%r14), %r13
movq %r14, %rsi
shlq $0x4, %rsi
orq $0x8, %rsi
cmpq $0x7f00, %rsi           # imm = 0x7F00
movq %rbx, -0x38(%rbp)
ja 0x1c3e7
movq %rsp, %r15
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %r15
movq %r15, %rsp
movq -0x88(%rbp), %rsi
leaq (,%r13,8), %rax
subq %rax, %rsi
movq %r15, %rdi
movq %r13, %rdx
movq -0x30(%rbp), %rbx
movl %ebx, %ecx
callq 0x181a0
cmpq %r12, -0x90(%rbp)
jb 0x1be65
movq %rax, (%r15,%r13,8)
jmp 0x1be5f
andq $0x0, -0x48(%rbp)
movq 0x8(%r9), %rax
testq %rax, %rax
js 0x1bc35
movq %r15, %rbx
movq %rax, -0xc8(%rbp)
bsrq -0xc8(%rbp), %r14
xorl $0x3f, %r14d
movq (%r9), %rdx
subl %r14d, %edi
movl %r14d, %ecx
shldq %cl, %rdx, %rax
shlq %cl, %rdx
movq %rax, -0x78(%rbp)
movq %rdx, -0x80(%rbp)
leaq 0x8(,%r11,8), %rsi
cmpq $0x7f00, %rsi           # imm = 0x7F00
movq %r13, -0x58(%rbp)
movq %rdi, -0x30(%rbp)
ja 0x1c33a
movq %rsp, %r15
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %r15
movq %r15, %rsp
movq %r15, %rdi
movq %r10, %rsi
movq %r11, %rdx
movl %r14d, %ecx
movq %r11, %r13
callq 0x181a0
movq %rax, %r12
movq %rax, (%r15,%r13,8)
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
addq %r13, %rcx
leaq -0x80(%rbp), %r8
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x18920
testq %r12, %r12
jne 0x1bb45
movq %rax, -0x10(%rbx,%r13,8)
movq (%r15), %rax
movq 0x8(%r15), %rdx
movl %r14d, %ecx
shrq %cl, %rax
movq %rdx, %rsi
movq -0x30(%rbp), %rcx
shlq %cl, %rsi
orq %rax, %rsi
movq -0x58(%rbp), %rax
movq %rsi, (%rax)
movl %r14d, %ecx
shrq %cl, %rdx
movq %rdx, 0x8(%rax)
jmp 0x1c2d1
movq (%r9), %r8
movq %r15, %rdi
xorl %esi, %esi
movq %r10, %rdx
movq %r11, %rcx
callq 0x18700
movq %rax, (%r13)
jmp 0x1c2da
movq -0x8(%r9,%rbx,8), %rax
testq %rax, %rax
movq %r15, -0x40(%rbp)
movq %rdx, -0x30(%rbp)
js 0x1bcaa
movq %rax, -0xc0(%rbp)
bsrq -0xc0(%rbp), %r14
xorl $0x3f, %r14d
leaq (,%rbx,8), %rsi
cmpq $0x7f00, %rsi           # imm = 0x7F00
movq %r10, -0x70(%rbp)
movq %r11, %r12
ja 0x1c374
movq %rsp, %r13
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %r13
movq %r13, %rsp
movq %r13, %rdi
movq %r9, %rsi
movq %rbx, %rdx
movl %r14d, %ecx
callq 0x181a0
leaq 0x8(,%r12,8), %rsi
cmpq $0x7f00, %rsi           # imm = 0x7F00
ja 0x1c38b
movq %rsp, %r15
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %r15
movq %r15, %rsp
movq -0x70(%rbp), %rsi
movq %r15, %rdi
movq %r12, %rdx
movl %r14d, %ecx
callq 0x181a0
jmp 0x1bce9
movq %r9, %r12
leaq (,%r11,8), %rsi
cmpq $0x7f00, %rsi           # imm = 0x7F00
ja 0x1c357
movq %rsp, %r14
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %r14
movq %r14, %rsp
movq %r14, %rdi
movq %r10, %rsi
movq %r11, %rdx
movq %r11, %rbx
callq 0x290c6
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
movq %r12, %r8
callq 0x18920
movq %rax, -0x10(%r15,%rbx,8)
movupd (%r14), %xmm0
movupd %xmm0, (%r13)
jmp 0x1c2d1
movq %r13, %rdi
movq %r10, %rsi
movq %rbx, %rdx
callq 0x290c6
jmp 0x1c2da
leaq 0x8(,%r11,8), %rsi
movq %r9, %r13
cmpq $0x7f00, %rsi           # imm = 0x7F00
ja 0x1c3f8
movq %rsp, %r15
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %r15
movq %r15, %rsp
movq %r15, %rdi
movq %r10, %rsi
movq %r11, %rdx
movq %r11, %r12
callq 0x290c6
xorl %eax, %eax
xorl %r14d, %r14d
movq %rax, (%r15,%r12,8)
movq %rbx, %r12
movq -0x8(%r13,%rbx,8), %rbx
movq %rbx, %rdi
callq 0x29130
movq %rax, %r9
movq %rax, %rsi
imulq %rbx, %rsi
movq -0x10(%r13,%r12,8), %rcx
addq %rcx, %rsi
jae 0x1bd2f
xorl %eax, %eax
cmpq %rbx, %rsi
movl $0x0, %edx
adcq $-0x2, %rdx
cmpq %rbx, %rsi
cmovaeq %rbx, %rax
addq %rdx, %r9
addq %rbx, %rax
subq %rax, %rsi
movq %r9, -0xb8(%rbp)
movq %rcx, %rax
mulq -0xb8(%rbp)
addq %rsi, %rdx
jae 0x1bd55
leaq -0x1(%r9), %rsi
cmpq %rbx, %rdx
jae 0x1c3b9
movq %rsi, %r9
movq %r9, -0x80(%rbp)
movq 0x10(%rbp), %r8
cmpq $0x32, %r8
movq -0x30(%rbp), %rdx
jle 0x1bdbf
cmpq $0x5d, %r8
jb 0x1bdaa
cmpq $0x1052, %rdx           # imm = 0x1052
jl 0x1bdaa
cvtsi2sd %r8, %xmm0
cvtsi2sd %rdx, %xmm1
movsd 0x17bf8(%rip), %xmm2    # 0x33980
mulsd %xmm1, %xmm2
movsd 0x17bfc(%rip), %xmm3    # 0x33990
mulsd %xmm0, %xmm3
addsd %xmm2, %xmm3
mulsd %xmm1, %xmm0
ucomisd %xmm0, %xmm3
jbe 0x1bffa
leaq -0x80(%rbp), %r9
movq -0x40(%rbp), %rdi
movq %r15, %rsi
movq %r13, %rcx
callq 0x27132
jmp 0x1bdce
movq -0x40(%rbp), %rdi
movq %r15, %rsi
movq %r13, %rcx
callq 0x26308
movq -0x58(%rbp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq 0x10(%rbp), %rdx
testl %r14d, %r14d
je 0x1bdee
movl %r14d, %ecx
callq 0x2a0a0
jmp 0x1c2d1
callq 0x290c6
jmp 0x1c2d1
leaq (%r14,%r14), %r13
movq %r14, %rsi
shlq $0x4, %rsi
orq $0x8, %rsi
movq %rdi, %rbx
cmpq $0x7f00, %rsi           # imm = 0x7F00
ja 0x1c415
movq %rsp, %r15
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %r15
movq %r15, %rsp
movq -0x50(%rbp), %rax
leaq (%r9,%rax,8), %rax
movq %rax, -0x38(%rbp)
leaq (,%r13,8), %rax
subq %rax, %rcx
movq %r15, %rdi
movq %rcx, %rsi
movq %r13, %rdx
callq 0x290c6
movq $0x0, -0x30(%rbp)
cmpq %r12, %rbx
jb 0x1be83
andq $0x0, (%r15,%r13,8)
addq $0x8, %r15
jmp 0x1be83
pushq $0x40
popq %rcx
subl %ebx, %ecx
notq %r13
movq -0x70(%rbp), %rbx
leaq (%rbx,%r13,8), %rax
movq -0x60(%rbp), %rdx
movq (%rax,%rdx,8), %rax
shrq %cl, %rax
orq %rax, (%r15)
movq -0x68(%rbp), %r9
movq -0x50(%rbp), %r12
cmpq $0x2, %r14
je 0x1bec2
cmpq $0x1, %r14
jne 0x1bee8
movq (%r15), %rax
movq 0x8(%r15), %rdx
movq -0x38(%rbp), %rbx
movq (%rbx), %rcx
movq %rcx, -0xa8(%rbp)
divq -0xa8(%rbp)
movq %rdx, (%r15)
movq -0x40(%rbp), %rcx
movq %rax, (%rcx)
jmp 0x1c09a
pushq $0x4
popq %rcx
movq -0x40(%rbp), %rdi
xorl %esi, %esi
movq %r15, %rdx
movq -0x38(%rbp), %r13
movq %r13, %r8
movq %r9, %rbx
callq 0x18920
movq %rbx, %r9
movq %r13, %rbx
jmp 0x1c09a
movq %r9, %r12
movq -0x38(%rbp), %rbx
movq -0x8(%rbx,%r14,8), %r13
movq %r13, %rdi
callq 0x29130
movq %rax, %r9
movq %rax, %rsi
imulq %r13, %rsi
movq -0x10(%rbx,%r14,8), %rcx
addq %rcx, %rsi
jae 0x1bf2e
xorl %eax, %eax
cmpq %r13, %rsi
movl $0x0, %edx
adcq $-0x2, %rdx
cmpq %r13, %rsi
cmovaeq %r13, %rax
addq %rdx, %r9
addq %r13, %rax
subq %rax, %rsi
movq %r9, -0xa0(%rbp)
movq %rcx, %rax
mulq -0xa0(%rbp)
addq %rsi, %rdx
jae 0x1bf54
leaq -0x1(%r9), %rsi
cmpq %r13, %rdx
jae 0x1c45c
movq %rsi, %r9
movq %r9, -0x80(%rbp)
cmpq $0x32, %r14
jle 0x1c05a
leaq (%r14,%r14), %r13
cmpq $0x828, %r14            # imm = 0x828
jbe 0x1c076
movq %r13, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x285b4
movq %rax, %rsi
shlq $0x3, %rsi
cmpq $0x7f00, %rsi           # imm = 0x7F00
ja 0x1c473
movq %rsp, %rax
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %rax
movq %rax, %rsp
movq -0x70(%rbp), %rsi
movq -0x60(%rbp), %rbx
subq %r14, %rbx
xorl %ecx, %ecx
movq -0x58(%rbp), %rdx
cmpq %rdx, %rsi
cmoveq %rbx, %rcx
leaq (%rdx,%rcx,8), %rbx
subq $0x8, %rsp
movq -0x40(%rbp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r13, %rcx
movq -0x38(%rbp), %r13
movq %r13, %r8
movq %r14, %r9
pushq %rax
callq 0x27f00
popq %rcx
popq %rdx
movq %r15, %rdi
movq %rbx, %rsi
movq %r13, %rbx
movq %r14, %rdx
callq 0x290c6
jmp 0x1c093
movq %rdx, %rbx
movq %rdx, %rdi
movq %r8, %rsi
xorl %edx, %edx
callq 0x285b4
shlq $0x3, %rax
cmpq $0x7f00, %rax           # imm = 0x7F00
ja 0x1c448
movq %rsp, %r10
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %r10
movq %r10, %rsp
subq $0x8, %rsp
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %r15, %rdx
movq %rbx, %rcx
movq %r13, %r8
movq %rsi, %rbx
movq 0x10(%rbp), %r9
pushq %r10
callq 0x27f00
addq $0x10, %rsp
movq %rbx, %r15
jmp 0x1bdd2
leaq (%r14,%r14), %rdx
movq -0x40(%rbp), %rdi
movq %r15, %rsi
movq -0x38(%rbp), %rbx
movq %rbx, %rcx
movq %r14, %r8
callq 0x26308
jmp 0x1c093
leaq -0x80(%rbp), %r9
movq -0x40(%rbp), %rdi
movq %r15, %rsi
movq %r13, %rdx
movq -0x38(%rbp), %rbx
movq %rbx, %rcx
movq %r14, %r8
callq 0x27132
movq %r12, %r9
movq -0x50(%rbp), %r12
movq -0x30(%rbp), %r13
cmpq $0x2, %r12
jge 0x1c0a8
xorl %eax, %eax
jmp 0x1c0b0
movq -0x10(%r9,%r12,8), %rax
shrq %rax
movq -0x8(%r9,%r12,8), %rdx
movl %r13d, %ecx
shlq %cl, %rdx
notb %cl
shrq %cl, %rax
orq %rdx, %rax
movq -0x40(%rbp), %rcx
movq -0x8(%rcx,%r14,8), %rcx
movq %rcx, -0x98(%rbp)
mulq -0x98(%rbp)
movq %r14, -0x30(%rbp)
cmpq %rdx, -0x8(%r15,%r14,8)
jae 0x1c11f
movq -0x40(%rbp), %rax
subq $0x1, (%rax)
leaq 0x8(%rax), %rax
jb 0x1c0e9
movq %r15, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
movq %r9, %rbx
callq 0x17cf0
movq %rbx, %r9
movq %r14, -0x30(%rbp)
testq %rax, %rax
je 0x1c11f
movq %rax, (%r15,%r14,8)
leaq 0x1(%r14), %rax
movq %rax, -0x30(%rbp)
testl %r13d, %r13d
je 0x1c1b2
movl %r13d, %ecx
movq %rcx, -0x38(%rbp)
leaq -0x1(%r12), %rcx
movq %rcx, -0x60(%rbp)
pushq $0x40
popq %rcx
subl %r13d, %ecx
movq %r15, %rdi
movq %r15, %rsi
movq -0x30(%rbp), %r13
movq %r13, %rdx
movq %r12, %rbx
movq %r9, %r12
callq 0x181a0
pushq $-0x1
popq %r8
movq -0x38(%rbp), %rcx
shrq %cl, %r8
movq -0x70(%rbp), %rcx
movq -0x8(%rcx,%rbx,8), %rcx
andq %r8, %rcx
orq %rcx, (%r15)
movq %rax, -0x38(%rbp)
andq -0x8(%r12,%rbx,8), %r8
movq %r15, %rdi
movq -0x40(%rbp), %rsi
movq %r14, %rdx
movq %r8, %rcx
callq 0x29f90
cmpq %r13, %r14
jne 0x1c1bc
xorl %ecx, %ecx
movq -0x38(%rbp), %rdx
subq %rax, %rdx
setb %cl
movq %rcx, -0x38(%rbp)
movq %rdx, (%r15,%r14,8)
leaq 0x1(%r14), %rax
movq %rax, -0x30(%rbp)
movq -0x60(%rbp), %r12
jmp 0x1c1d9
movq $0x0, -0x38(%rbp)
jmp 0x1c1dd
movq -0x60(%rbp), %r12
movq (%r15,%r14,8), %rcx
subq %rax, %rcx
jb 0x1c430
movq %rcx, (%r15,%r14,8)
movq $0x0, -0x38(%rbp)
movq -0x68(%rbp), %r9
movq 0x10(%rbp), %rbx
leaq (,%rbx,8), %rsi
cmpq $0x7f00, %rsi           # imm = 0x7F00
ja 0x1c39c
movq %rsp, %r13
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %r13
movq %r13, %rsp
cmpq %r14, %r12
jge 0x1c227
testq %r12, %r12
je 0x1c2e9
movq %r13, %rdi
movq -0x40(%rbp), %rsi
movq %r14, %rdx
movq %r9, %rcx
movq %r12, %r8
jmp 0x1c237
movq %r13, %rdi
movq %r9, %rsi
movq %r12, %rdx
movq -0x40(%rbp), %rcx
movq %r14, %r8
callq 0x18a58
leaq (,%r12,8), %rcx
addq %r13, %rcx
movq %r15, %rdi
movq %r15, %rsi
movq %r15, -0x60(%rbp)
movq -0x30(%rbp), %r15
movq %r15, %rdx
movq %r14, %r8
callq 0x17dc8
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %r14
leaq (%r14,%r12,8), %rbx
movq 0x10(%rbp), %rdx
subq %r12, %rdx
movq %rbx, %rdi
movq -0x60(%rbp), %rsi
callq 0x290c6
movq %r14, %rdi
movq -0x70(%rbp), %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x17ed0
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x17e44
orq -0x38(%rbp), %rax
orq -0x50(%rbp), %rax
testq %rax, %rax
movq -0x40(%rbp), %rax
movq -0x68(%rbp), %rdx
je 0x1c2d1
subq $0x1, (%rax)
leaq 0x8(%rax), %rax
jb 0x1c2b7
movq -0x58(%rbp), %rdi
movq %rdi, %rsi
movq 0x10(%rbp), %rcx
callq 0x17cf0
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
jne 0x1c333
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x58(%rbp), %rdi
movq %r15, %rsi
movq -0x30(%rbp), %r14
movq %r14, %rdx
callq 0x290c6
cmpq %rbx, %r14
movq -0x38(%rbp), %rax
je 0x1c2aa
leaq 0x1768c(%rip), %rdi     # 0x33998
leaq 0x176a7(%rip), %rdx     # 0x339ba
movl $0x16c, %esi            # imm = 0x16C
callq 0x29ce6
leaq 0x17674(%rip), %rdi     # 0x33998
leaq 0x17677(%rip), %rdx     # 0x339a2
pushq $0x33
popq %rsi
callq 0x29ce6
callq 0x29df3
jmp 0x1c2da
leaq -0x48(%rbp), %rdi
movq %r10, %r15
movq %r11, %r12
callq 0x29dc0
movq %r12, %r11
movq %r15, %r10
movq %rax, %r15
jmp 0x1bb04
leaq -0x48(%rbp), %rdi
movq %r10, %rbx
movq %r11, %r14
callq 0x29dc0
movq %r14, %r11
movq %rbx, %r10
movq %rax, %r14
jmp 0x1bc5e
leaq -0x48(%rbp), %rdi
movq %r9, %r13
callq 0x29dc0
movq %r13, %r9
movq %rax, %r13
jmp 0x1bbe7
leaq -0x48(%rbp), %rdi
callq 0x29dc0
movq %rax, %r15
jmp 0x1bc1e
leaq -0x48(%rbp), %rdi
movq %r12, %r13
movq %r9, %r12
callq 0x29dc0
movq %r12, %r9
movq %r13, %r12
movq %rax, %r13
jmp 0x1c207
addq $-0x2, %r9
cmpq %rcx, %rax
cmovaeq %r9, %rsi
cmpq %rbx, %rdx
cmovbeq %rsi, %r9
jmp 0x1bd55
leaq -0x48(%rbp), %rdi
movq %r9, %r15
callq 0x29dc0
movq %r15, %r9
movq %rax, %rbx
jmp 0x1ba00
leaq -0x48(%rbp), %rdi
callq 0x29dc0
movq %rax, %r15
jmp 0x1ba5d
leaq -0x48(%rbp), %rdi
movq %r10, %r14
movq %r11, %r15
callq 0x29dc0
movq %r15, %r11
movq %r14, %r10
movq %rax, %r15
jmp 0x1bcd3
leaq -0x48(%rbp), %rdi
movq %rcx, %r15
callq 0x29dc0
movq %r15, %rcx
movq -0x68(%rbp), %r9
movq %rax, %r15
jmp 0x1be28
leaq 0x17561(%rip), %rdi     # 0x33998
leaq 0x1756d(%rip), %rdx     # 0x339ab
movl $0x157, %esi            # imm = 0x157
callq 0x29ce6
leaq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x29dc0
movq %rax, %r10
jmp 0x1c02b
addq $-0x2, %r9
cmpq %rcx, %rax
cmovaeq %r9, %rsi
cmpq %r13, %rdx
cmovbeq %rsi, %r9
jmp 0x1bf54
leaq -0x48(%rbp), %rdi
callq 0x29dc0
jmp 0x1bfa5
callq 0x29d3c
nop