// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/mpn/sbpi1_div_q.c
// Function: _gmpn_sbpi1_div_q
mp_limb_t
mpn_sbpi1_div_q (mp_ptr qp,
		 mp_ptr np, mp_size_t nn,
		 mp_srcptr dp, mp_size_t dn,
		 mp_limb_t dinv)
{
  mp_limb_t qh;
  mp_size_t qn, i;
  mp_limb_t n1, n0;
  mp_limb_t d1, d0;
  mp_limb_t cy, cy1;
  mp_limb_t q;
  mp_limb_t flag;

  mp_size_t dn_orig = dn;
  mp_srcptr dp_orig = dp;
  mp_ptr np_orig = np;

  ASSERT (dn > 2);
  ASSERT (nn >= dn);
  ASSERT ((dp[dn-1] & GMP_NUMB_HIGHBIT) != 0);

  np += nn;

  qn = nn - dn;
  if (qn + 1 < dn)
    {
      dp += dn - (qn + 1);
      dn = qn + 1;
    }

  qh = mpn_cmp (np - dn, dp, dn) >= 0;
  if (qh != 0)
    mpn_sub_n (np - dn, np - dn, dp, dn);

  qp += qn;

  dn -= 2;			/* offset dn by 2 for main division loops,
				   saving two iterations in mpn_submul_1.  */
  d1 = dp[dn + 1];
  d0 = dp[dn + 0];

  np -= 2;

  n1 = np[1];

  for (i = qn - (dn + 2); i >= 0; i--)
    {
      np--;
      if (UNLIKELY (n1 == d1) && np[1] == d0)
	{
	  q = GMP_NUMB_MASK;
	  mpn_submul_1 (np - dn, dp, dn + 2, q);
	  n1 = np[1];		/* update n1, last loop's value will now be invalid */
	}
      else
	{
	  udiv_qr_3by2 (q, n1, n0, n1, np[1], np[0], d1, d0, dinv);

	  cy = mpn_submul_1 (np - dn, dp, dn, q);

	  cy1 = n0 < cy;
	  n0 = (n0 - cy) & GMP_NUMB_MASK;
	  cy = n1 < cy1;
	  n1 -= cy1;
	  np[0] = n0;

	  if (UNLIKELY (cy != 0))
	    {
	      n1 += d1 + mpn_add_n (np - dn, np - dn, dp, dn + 1);
	      q--;
	    }
	}

      *--qp = q;
    }

  flag = ~CNST_LIMB(0);

  if (dn >= 0)
    {
      for (i = dn; i > 0; i--)
	{
	  np--;
	  if (UNLIKELY (n1 >= (d1 & flag)))
	    {
	      q = GMP_NUMB_MASK;
	      cy = mpn_submul_1 (np - dn, dp, dn + 2, q);

	      if (UNLIKELY (n1 != cy))
		{
		  if (n1 < (cy & flag))
		    {
		      q--;
		      mpn_add_n (np - dn, np - dn, dp, dn + 2);
		    }
		  else
		    flag = 0;
		}
	      n1 = np[1];
	    }
	  else
	    {
	      udiv_qr_3by2 (q, n1, n0, n1, np[1], np[0], d1, d0, dinv);

	      cy = mpn_submul_1 (np - dn, dp, dn, q);

	      cy1 = n0 < cy;
	      n0 = (n0 - cy) & GMP_NUMB_MASK;
	      cy = n1 < cy1;
	      n1 -= cy1;
	      np[0] = n0;

	      if (UNLIKELY (cy != 0))
		{
		  n1 += d1 + mpn_add_n (np - dn, np - dn, dp, dn + 1);
		  q--;
		}
	    }

	  *--qp = q;

	  /* Truncate operands.  */
	  dn--;
	  dp++;
	}

      np--;
      if (UNLIKELY (n1 >= (d1 & flag)))
	{
	  q = GMP_NUMB_MASK;
	  cy = mpn_submul_1 (np, dp, 2, q);

	  if (UNLIKELY (n1 != cy))
	    {
	      if (n1 < (cy & flag))
		{
		  q--;
		  add_ssaaaa (np[1], np[0], np[1], np[0], dp[1], dp[0]);
		}
	      else
		flag = 0;
	    }
	  n1 = np[1];
	}
      else
	{
	  udiv_qr_3by2 (q, n1, n0, n1, np[1], np[0], d1, d0, dinv);

	  np[0] = n0;
	  np[1] = n1;
	}

      *--qp = q;
    }
  ASSERT_ALWAYS (np[1] == n1);
  np += 2;


  dn = dn_orig;
  if (UNLIKELY (n1 < (dn & flag)))
    {
      mp_limb_t q, x;

      /* The quotient may be too large if the remainder is small.  Recompute
	 for above ignored operand parts, until the remainder spills.

	 FIXME: The quality of this code isn't the same as the code above.
	 1. We don't compute things in an optimal order, high-to-low, in order
	    to terminate as quickly as possible.
	 2. We mess with pointers and sizes, adding and subtracting and
	    adjusting to get things right.  It surely could be streamlined.
	 3. The only termination criteria are that we determine that the
	    quotient needs to be adjusted, or that we have recomputed
	    everything.  We should stop when the remainder is so large
	    that no additional subtracting could make it spill.
	 4. If nothing else, we should not do two loops of submul_1 over the
	    data, instead handle both the triangularization and chopping at
	    once.  */

      x = n1;

      if (dn > 2)
	{
	  /* Compensate for triangularization.  */
	  mp_limb_t y;

	  dp = dp_orig;
	  if (qn + 1 < dn)
	    {
	      dp += dn - (qn + 1);
	      dn = qn + 1;
	    }

	  y = np[-2];

	  for (i = dn - 3; i >= 0; i--)
	    {
	      q = qp[i];
	      cy = mpn_submul_1 (np - (dn - i), dp, dn - i - 2, q);

	      if (y < cy)
		{
		  if (x == 0)
		    {
		      cy = mpn_sub_1 (qp, qp, qn, 1);
		      ASSERT_ALWAYS (cy == 0);
		      return qh - cy;
		    }
		  x--;
		}
	      y -= cy;
	    }
	  np[-2] = y;
	}

      dn = dn_orig;
      if (qn + 1 < dn)
	{
	  /* Compensate for ignored dividend and divisor tails.  */

	  dp = dp_orig;
	  np = np_orig;

	  if (qh != 0)
	    {
	      cy = mpn_sub_n (np + qn, np + qn, dp, dn - (qn + 1));
	      if (cy != 0)
		{
		  if (x == 0)
		    {
		      if (qn != 0)
			cy = mpn_sub_1 (qp, qp, qn, 1);
		      return qh - cy;
		    }
		  x--;
		}
	    }

	  if (qn == 0)
	    return qh;

	  for (i = dn - qn - 2; i >= 0; i--)
	    {
	      cy = mpn_submul_1 (np + i, qp, qn, dp[i]);
	      cy = mpn_sub_1 (np + qn + i, np + qn + i, dn - qn - i - 1, cy);
	      if (cy != 0)
		{
		  if (x == 0)
		    {
		      cy = mpn_sub_1 (qp, qp, qn, 1);
		      return qh;
		    }
		  x--;
		}
	    }
	}
    }

  return qh;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %r9, 0x70(%rsp)
movq %r8, %rbx
leaq (%rsi,%rdx,8), %r15
movq %rdx, %r14
subq %r8, %r14
leaq 0x1(%r14), %r10
movq %r10, %r8
subq %rbx, %r8
movq %rbx, %r12
cmovlq %r10, %r12
negq %r8
leaq (,%r12,8), %rax
movq %r15, %r9
movq %rax, 0x40(%rsp)
subq %rax, %r9
xorl %eax, %eax
cmpq %r10, %rbx
movq %r8, 0x60(%rsp)
cmovgq %r8, %rax
movq %rdi, %r13
movq %r10, 0xa0(%rsp)
movq %r10, %rdi
cmovgq %rbx, %rdi
leaq (%rcx,%rax,8), %rax
movq %rax, 0x28(%rsp)
addq %rbx, %rdi
shlq $0x3, %rdi
leaq (,%rdx,8), %r10
subq %r10, %rdi
movq %rcx, 0x90(%rsp)
leaq (%rdi,%rcx), %rax
addq $-0x10, %rax
movq %rsi, 0x80(%rsp)
movq %rdx, 0x88(%rsp)
leaq (%rsi,%rdx,8), %rcx
addq $-0x8, %rcx
movq %r12, %rdx
testq %rdx, %rdx
jle 0x2b49e
movq (%rax,%rdx,8), %rdi
decq %rdx
leaq -0x8(%rcx), %r8
cmpq %rdi, (%rcx)
movq %r8, %rcx
je 0x2b480
seta %bpl
jmp 0x2b4a1
movb $0x1, %bpl
testb %bpl, %bpl
movq %r10, 0x68(%rsp)
je 0x2b4c3
movq %r9, %rdi
movq %r9, %rsi
movq 0x28(%rsp), %rdx
movq %r12, %rcx
callq 0x1c1c0
movq 0x68(%rsp), %r10
movb %bpl, 0x1f(%rsp)
movq 0x28(%rsp), %rax
movq -0x10(%rax,%r12,8), %r11
movq -0x8(%rax,%r12,8), %r9
movq -0x8(%r15), %r8
movq %r14, %rbp
subq %r12, %rbp
movq %r9, 0x30(%rsp)
movq %r11, 0x58(%rsp)
movq %r14, 0x20(%rsp)
movq %rbx, 0x78(%rsp)
movq %r12, 0x48(%rsp)
js 0x2b772
leaq -0x2(%r12), %rax
movq %rax, 0x50(%rsp)
leaq -0x1(%r12), %rax
movq %rax, 0x38(%rsp)
leaq (,%rbx,8), %rax
subq %rax, %r13
movq 0x80(%rsp), %rcx
leaq -0x10(%rcx), %r12
movq 0x40(%rsp), %rax
negq %rax
leaq (%rcx,%rax), %r15
addq $-0x8, %r15
incq %rbp
cmpq %r9, %r8
je 0x2b6a9
movq %r13, 0x8(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x1d0(%rsp)
movq %r8, %rax
mulq 0x1d0(%rsp)
movq %rax, %rcx
movq %rdx, %rbx
movq (%r12,%r10), %rsi
movq %rsi, 0x1c0(%rsp)
movq %r8, 0x1c8(%rsp)
addq 0x1c0(%rsp), %rcx
adcq 0x1c8(%rsp), %rbx
movq %rbx, %rax
imulq %r9, %rax
subq %rax, %rsi
movq -0x8(%r12,%r10), %r13
movq %r9, 0x1b8(%rsp)
movq %r11, 0x1b0(%rsp)
subq 0x1b0(%rsp), %r13
sbbq 0x1b8(%rsp), %rsi
movq %rbx, 0x1a8(%rsp)
movq %r11, %rax
mulq 0x1a8(%rsp)
movq %rdx, 0x1a0(%rsp)
movq %rax, 0x198(%rsp)
subq 0x198(%rsp), %r13
sbbq 0x1a0(%rsp), %rsi
cmpq %rcx, %rsi
adcq $-0x1, %rbx
cmpq %rcx, %rsi
movl $0x0, %eax
cmovaeq %r9, %rax
movl $0x0, %ecx
cmovaeq %r11, %rcx
incq %rbx
movq %rax, 0x190(%rsp)
movq %rcx, 0x188(%rsp)
addq 0x188(%rsp), %r13
adcq 0x190(%rsp), %rsi
movq %rsi, %r14
cmpq %r9, %rsi
movq %rbp, 0x10(%rsp)
jae 0x2b6e4
leaq (%r15,%r10), %rbp
movq %rbp, %rdi
movq 0x28(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq %rbx, %rcx
callq 0x30370
movq 0x68(%rsp), %r10
subq %rax, %r13
movq %r14, %r8
sbbq $0x0, %r8
movq %r13, -0x8(%r12,%r10)
jb 0x2b717
movq 0x30(%rsp), %r9
movq 0x8(%rsp), %r13
movq 0x10(%rsp), %rbp
movq %rbx, -0x8(%r13,%r10)
addq $-0x8, %r13
addq $-0x8, %r12
addq $-0x8, %r15
decq %rbp
testq %rbp, %rbp
movq 0x58(%rsp), %r11
jg 0x2b53e
jmp 0x2b74a
cmpq %r11, (%r12,%r10)
jne 0x2b547
leaq (%r15,%r10), %rdi
movq $-0x1, %rbx
movq 0x28(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq $-0x1, %rcx
callq 0x30370
movq 0x30(%rsp), %r9
movq 0x68(%rsp), %r10
movq (%r12,%r10), %r8
jmp 0x2b682
ja 0x2b6ef
cmpq %r11, %r13
jb 0x2b640
incq %rbx
movq %r11, 0x178(%rsp)
movq %r9, 0x180(%rsp)
subq 0x178(%rsp), %r13
sbbq 0x180(%rsp), %r14
jmp 0x2b640
movq %rbp, %rdi
movq %rbp, %rsi
movq 0x28(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq %r8, %r14
callq 0x1bfa0
movq %r14, %r8
movq 0x68(%rsp), %r10
movq 0x30(%rsp), %r9
addq %r9, %r8
addq %rax, %r8
decq %rbx
jmp 0x2b678
movq 0x88(%rsp), %rax
leaq (,%rax,8), %rcx
addq %r13, %rcx
movq %rcx, 0x10(%rsp)
leaq (%r12,%rax,8), %r15
movq 0x20(%rsp), %r14
movq 0x48(%rsp), %r12
jmp 0x2b786
leaq (,%r14,8), %rax
addq %r13, %rax
movq %rax, 0x10(%rsp)
addq $-0x10, %r15
movq $-0x1, 0x8(%rsp)
cmpq $0x2, %r12
jl 0x2b7aa
movq $-0x1, 0x8(%rsp)
jne 0x2b7b7
movq 0x28(%rsp), %r13
jmp 0x2ba5d
movq %r15, %rdi
movq 0x78(%rsp), %r12
jmp 0x2bb7f
movq %r15, %rax
subq 0x40(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x50(%rsp)
movq $-0x1, 0x8(%rsp)
xorl %ebp, %ebp
xorl %r13d, %r13d
movq %r15, 0x40(%rsp)
movq 0x28(%rsp), %rax
leaq (%rax,%r13), %r12
movq 0x48(%rsp), %rax
leaq (%rax,%rbp), %r10
addq $-0x2, %r10
movq 0x8(%rsp), %rax
andq %r9, %rax
cmpq %rax, %r8
jae 0x2b950
movq 0x70(%rsp), %rax
movq %rax, 0x170(%rsp)
movq %r8, %rax
mulq 0x170(%rsp)
movq %rax, %rcx
movq %rdx, %rbx
movq (%r15,%rbp,8), %rsi
movq %rsi, 0x160(%rsp)
movq %r8, 0x168(%rsp)
addq 0x160(%rsp), %rcx
adcq 0x168(%rsp), %rbx
movq %rbx, %rax
imulq %r9, %rax
subq %rax, %rsi
movq -0x8(%r15,%rbp,8), %r14
movq %r9, 0x158(%rsp)
movq %r11, 0x150(%rsp)
subq 0x150(%rsp), %r14
sbbq 0x158(%rsp), %rsi
movq %rbx, 0x148(%rsp)
movq %r11, %rax
mulq 0x148(%rsp)
movq %rdx, 0x140(%rsp)
movq %rax, 0x138(%rsp)
subq 0x138(%rsp), %r14
sbbq 0x140(%rsp), %rsi
cmpq %rcx, %rsi
adcq $-0x1, %rbx
cmpq %rcx, %rsi
movl $0x0, %eax
cmovaeq %r9, %rax
movl $0x0, %ecx
cmovaeq %r11, %rcx
incq %rbx
movq %rax, 0x130(%rsp)
movq %rcx, 0x128(%rsp)
addq 0x128(%rsp), %r14
adcq 0x130(%rsp), %rsi
movq %rsi, %r15
cmpq %r9, %rsi
jae 0x2b99e
movq 0x50(%rsp), %rdi
movq %r12, %rsi
movq %r12, 0x38(%rsp)
movq %r10, %r12
movq %r10, %rdx
movq %rbx, %rcx
callq 0x30370
subq %rax, %r14
movq %r15, %r8
sbbq $0x0, %r8
movq 0x40(%rsp), %r15
movq %r14, -0x8(%r15,%rbp,8)
jb 0x2b9d1
movq 0x30(%rsp), %r9
movq 0x58(%rsp), %r11
movq 0x10(%rsp), %rax
movq %rbx, -0x8(%rax,%rbp,8)
addq $0x8, %r13
decq %rbp
cmpq $0x1, %r12
jg 0x2b7db
jmp 0x2ba50
movq %r10, 0x38(%rsp)
movq 0x48(%rsp), %rax
leaq (%rax,%rbp), %rdx
movq $-0x1, %rbx
movq 0x50(%rsp), %rdi
movq %r12, %rsi
movq %rdx, 0x98(%rsp)
movq $-0x1, %rcx
movq %r8, %r14
callq 0x30370
cmpq %rax, %r14
jne 0x2ba08
movq 0x30(%rsp), %r9
movq 0x58(%rsp), %r11
movq 0x38(%rsp), %r12
movq (%r15,%rbp,8), %r8
jmp 0x2b930
ja 0x2b9a9
cmpq %r11, %r14
jb 0x2b8f1
incq %rbx
movq %r11, 0x118(%rsp)
movq %r9, 0x120(%rsp)
subq 0x118(%rsp), %r14
sbbq 0x120(%rsp), %r15
jmp 0x2b8f1
movq 0x48(%rsp), %rax
leaq (%rax,%rbp), %rcx
decq %rcx
movq 0x50(%rsp), %rdi
movq %rdi, %rsi
movq 0x38(%rsp), %rdx
movq %r8, %r14
callq 0x1bfa0
movq %r14, %r8
movq 0x30(%rsp), %r9
addq %r9, %r8
addq %rax, %r8
decq %rbx
jmp 0x2b92b
movq 0x98(%rsp), %rcx
andq 0x8(%rsp), %rax
cmpq %rax, %r14
jae 0x2ba33
movq 0x50(%rsp), %rdi
movq %rdi, %rsi
movq %r12, %rdx
callq 0x1bfa0
movq $-0x2, %rbx
jmp 0x2ba3c
movq $0x0, 0x8(%rsp)
movq 0x30(%rsp), %r9
movq 0x58(%rsp), %r11
movq 0x40(%rsp), %r15
jmp 0x2b993
subq %r13, 0x10(%rsp)
subq %r13, %r15
addq 0x28(%rsp), %r13
movq 0x78(%rsp), %r12
leaq -0x8(%r15), %rdi
movq 0x8(%rsp), %rax
andq %r9, %rax
cmpq %rax, %r8
jae 0x2bc4e
movq 0x70(%rsp), %rax
movq %rax, 0x100(%rsp)
movq %r8, %rax
mulq 0x100(%rsp)
movq %rax, %rcx
movq %rdx, %rbx
movq (%r15), %rsi
movq %rsi, 0xf0(%rsp)
movq %r8, 0xf8(%rsp)
addq 0xf0(%rsp), %rcx
adcq 0xf8(%rsp), %rbx
movq %rbx, %rax
imulq %r9, %rax
subq %rax, %rsi
movq -0x8(%r15), %r8
movq %r9, 0xe8(%rsp)
movq %r11, 0xe0(%rsp)
subq 0xe0(%rsp), %r8
sbbq 0xe8(%rsp), %rsi
movq %rbx, 0xd8(%rsp)
movq %r11, %rax
mulq 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq %rax, 0xc8(%rsp)
subq 0xc8(%rsp), %r8
sbbq 0xd0(%rsp), %rsi
cmpq %rcx, %rsi
adcq $-0x1, %rbx
xorl %eax, %eax
cmpq %rcx, %rsi
movl $0x0, %ecx
cmovaeq %r9, %rcx
cmovaeq %r11, %rax
incq %rbx
movq %rcx, 0xc0(%rsp)
movq %rax, 0xb8(%rsp)
addq 0xb8(%rsp), %r8
adcq 0xc0(%rsp), %rsi
cmpq %r9, %rsi
jae 0x2bc88
movq 0x20(%rsp), %r14
movq %r8, -0x8(%r15)
movq %rsi, (%r15)
movq 0x10(%rsp), %rax
movq %rbx, -0x8(%rax)
addq $-0x8, %rax
movq %rax, 0x10(%rsp)
movq %rsi, %r8
cmpq %r8, 0x8(%rdi)
jne 0x2bbaf
movzbl 0x1f(%rsp), %ebp
movq 0x8(%rsp), %rax
andq %r12, %rax
cmpq %rax, %r8
jb 0x2bbb4
movq %rbp, %rbx
movq %rbx, %rax
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x742f
cmpq $0x3, %r12
jl 0x2bcc0
movq (%rdi), %r13
cmpq $0x2, %r14
setl %dl
jl 0x2bc39
movq 0x48(%rsp), %rax
addq $-0x3, %rax
leaq -0x8(%rdi), %rbx
movl $0x1, %r14d
movb %dl, 0x70(%rsp)
movq %rdi, %r15
movq %r8, 0x8(%rsp)
movq %rax, %r12
movq 0x10(%rsp), %rcx
movq (%rcx,%rax,8), %rcx
movq %rbx, %rdi
movq 0x28(%rsp), %rsi
movq %r14, %rdx
callq 0x30370
subq %rax, %r13
jae 0x2bc1d
movq 0x8(%rsp), %r8
testq %r8, %r8
je 0x2bd19
decq %r8
jmp 0x2bc22
movq 0x8(%rsp), %r8
movq %r15, %rdi
leaq -0x1(%r12), %rax
incq %r14
addq $-0x8, %rbx
testq %r12, %r12
setle %dl
jg 0x2bbdd
movq %r13, (%rdi)
testb $0x1, %dl
movq 0x78(%rsp), %r12
jne 0x2bcc0
xorl %r15d, %r15d
jmp 0x2be30
movq $-0x1, %rbx
movl $0x2, %edx
movq %rdi, %rbp
movq %r13, %rsi
movq $-0x1, %rcx
movq %r8, %r14
callq 0x30370
cmpq %rax, %r14
jne 0x2bef0
movq %rbp, %rdi
movq (%r15), %rsi
movq 0x20(%rsp), %r14
jmp 0x2bb6a
movq 0x20(%rsp), %r14
ja 0x2bc98
cmpq %r11, %r8
jb 0x2bb63
incq %rbx
movq %r11, 0xa8(%rsp)
movq %r9, 0xb0(%rsp)
subq 0xa8(%rsp), %r8
sbbq 0xb0(%rsp), %rsi
jmp 0x2bb63
movb $0x1, %r15b
cmpq 0xa0(%rsp), %r12
jle 0x2be30
testq %rbp, %rbp
je 0x2bd65
movq %r8, %r14
movq 0x20(%rsp), %rax
movq 0x80(%rsp), %rcx
leaq (%rcx,%rax,8), %rdi
movq %rdi, %rsi
movq 0x90(%rsp), %rdx
movq 0x60(%rsp), %rcx
callq 0x1c1c0
testq %rax, %rax
je 0x2bd62
testq %r14, %r14
je 0x2be3e
movq %r14, %r8
decq %r8
jmp 0x2bd65
movq 0x10(%rsp), %rax
subq $0x1, (%rax)
jae 0x2be8c
movq 0x20(%rsp), %rax
cmpq $0x2, %rax
movl $0x1, %edx
movl $0x1, %ecx
cmovgeq %rax, %rcx
xorl %ebx, %ebx
movq 0x10(%rsp), %rsi
cmpq %rdx, %rcx
setne %al
je 0x2bed4
subq $0x1, (%rsi,%rdx,8)
leaq 0x1(%rdx), %rdx
jb 0x2bd46
jmp 0x2bedb
movq %r14, %r8
cmpq %r12, 0x88(%rsp)
jne 0x2bd7a
xorl %r15d, %r15d
movq %rbp, %rbx
jmp 0x2be30
movq %r8, 0x8(%rsp)
movq %r12, %rax
subq 0x20(%rsp), %rax
cmpq $0x2, %rax
jl 0x2be30
movq 0x80(%rsp), %rax
leaq (%rax,%r12,8), %r14
addq $-0x10, %r14
shlq $0x4, %r12
subq 0x68(%rsp), %r12
addq %rax, %r12
addq $-0x10, %r12
movl $0x1, %r13d
movq 0x60(%rsp), %rcx
movq 0x90(%rsp), %rax
movq %rcx, 0x60(%rsp)
movq -0x8(%rax,%rcx,8), %rcx
movq %r12, %rdi
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x30370
movq %r14, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rax, %rcx
callq 0x1c104
testq %rax, %rax
je 0x2be0e
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x2be92
decq %rax
movq 0x60(%rsp), %rcx
jmp 0x2be18
movq 0x60(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
decq %rcx
addq $-0x8, %r14
addq $-0x8, %r12
incq %r13
testq %rcx, %rcx
jg 0x2bdbc
testb %r15b, %r15b
jne 0x2bb97
jmp 0x2bb9a
cmpq %r12, 0x88(%rsp)
je 0x2be81
movq 0x10(%rsp), %rax
subq $0x1, (%rax)
jae 0x2be7f
movq 0x20(%rsp), %rdx
cmpq $0x2, %rdx
movl $0x1, %eax
cmovlq %rax, %rdx
movl $0x1, %ecx
movq 0x10(%rsp), %rsi
cmpq %rcx, %rdx
je 0x2be81
subq $0x1, (%rsi,%rcx,8)
leaq 0x1(%rcx), %rcx
jb 0x2be6f
xorl %eax, %eax
movq %rbp, %rbx
subq %rax, %rbx
jmp 0x2bc46
movb $0x1, %al
xorl %ebx, %ebx
jmp 0x2bedb
movq 0x10(%rsp), %rax
subq $0x1, (%rax)
jae 0x2bd6f
movq 0x20(%rsp), %rcx
cmpq $0x2, %rcx
movl $0x1, %eax
cmovlq %rax, %rcx
xorl %r15d, %r15d
movq 0x10(%rsp), %rdx
cmpq %rax, %rcx
je 0x2bd6f
subq $0x1, (%rdx,%rax,8)
leaq 0x1(%rax), %rax
jb 0x2bebb
jmp 0x2bd72
movq $-0x1, %rbx
testb %al, %al
je 0x2bf4d
addq %rbp, %rbx
movq 0x8(%rsp), %r8
movb 0x70(%rsp), %dl
jmp 0x2bc3c
movq %r12, %rdi
andq 0x8(%rsp), %rax
cmpq %rax, %r14
jae 0x2bf3c
movq -0x8(%r15), %rax
movq (%r15), %rcx
movq (%r13), %rdx
movq 0x8(%r13), %rsi
movq %rdx, 0x108(%rsp)
movq %rsi, 0x110(%rsp)
addq 0x108(%rsp), %rax
adcq 0x110(%rsp), %rcx
movq %rcx, (%r15)
movq %rax, -0x8(%r15)
movq $-0x2, %rbx
jmp 0x2bf45
movq $0x0, 0x8(%rsp)
movq %rdi, %r12
jmp 0x2bc78
callq 0x7448
nop