// File: /workspace/github_cpp_makefile_star2_O3/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, 0x78(%rsp)
movq %r8, %rbx
leaq (%rsi,%rdx,8), %r11
movq %rdx, %r12
subq %r8, %r12
leaq 0x1(%r12), %r8
movq %r8, %r10
subq %rbx, %r10
movq %rbx, %r15
cmovlq %r8, %r15
negq %r10
leaq (,%r15,8), %rax
movq %r11, %r13
movq %rax, 0x28(%rsp)
subq %rax, %r11
xorl %eax, %eax
cmpq %r8, %rbx
cmovgq %r10, %rax
movq %rdi, %rbp
movq %r8, 0xa0(%rsp)
movq %r8, %rdi
cmovgq %rbx, %rdi
leaq (%rcx,%rax,8), %r14
addq %rbx, %rdi
shlq $0x3, %rdi
leaq (,%rdx,8), %rax
movq %rax, 0x48(%rsp)
subq %rax, %rdi
leaq (%rdi,%rcx), %rax
addq $-0x10, %rax
movq %rsi, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
leaq (%rsi,%rdx,8), %r9
addq $-0x8, %r9
movq %r15, %rdx
movq %rcx, 0x90(%rsp)
movq %r10, 0x80(%rsp)
testq %rdx, %rdx
jle 0x2b104
movq (%r9), %rdi
movq (%rax,%rdx,8), %r8
decq %rdx
addq $-0x8, %r9
cmpq %r8, %rdi
je 0x2b0ea
jbe 0x2b12b
movq %r11, %rdi
movq %r11, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x1bca0
movb $0x1, %al
movq %rax, 0x88(%rsp)
movl $0x1, %eax
movq %rax, 0x8(%rsp)
jmp 0x2b140
movq $0x0, 0x8(%rsp)
movq $0x0, 0x88(%rsp)
movq 0x48(%rsp), %rdi
movq -0x10(%r14,%r15,8), %r10
movq %r14, 0x38(%rsp)
movq -0x8(%r14,%r15,8), %r9
movq %r13, %r11
movq -0x8(%r13), %r8
movq %r12, %r13
subq %r15, %r13
movq %r15, 0x30(%rsp)
movq %r9, 0x18(%rsp)
movq %r10, 0x50(%rsp)
movq %rbx, 0x70(%rsp)
js 0x2b3ee
movq %r12, 0x68(%rsp)
leaq -0x2(%r15), %rax
movq %rax, (%rsp)
leaq -0x1(%r15), %rax
movq %rax, 0x20(%rsp)
leaq (,%rbx,8), %rax
subq %rax, %rbp
movq 0x58(%rsp), %rcx
leaq -0x10(%rcx), %r15
movq 0x28(%rsp), %rax
negq %rax
leaq (%rcx,%rax), %r12
addq $-0x8, %r12
incq %r13
cmpq %r9, %r8
je 0x2b325
movq 0x78(%rsp), %rax
movq %rax, 0x1d0(%rsp)
movq %r8, %rax
mulq 0x1d0(%rsp)
movq %rax, %rcx
movq %rdx, %rbx
movq (%r15,%rdi), %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(%r15,%rdi), %r14
movq %r9, 0x1b8(%rsp)
movq %r10, 0x1b0(%rsp)
subq 0x1b0(%rsp), %r14
sbbq 0x1b8(%rsp), %rsi
movq %rbx, 0x1a8(%rsp)
movq %r10, %rax
mulq 0x1a8(%rsp)
movq %rdx, 0x1a0(%rsp)
movq %rax, 0x198(%rsp)
subq 0x198(%rsp), %r14
sbbq 0x1a0(%rsp), %rsi
cmpq %rcx, %rsi
adcq $-0x1, %rbx
cmpq %rcx, %rsi
movl $0x0, %eax
cmovaeq %r9, %rax
movl $0x0, %ecx
cmovaeq %r10, %rcx
incq %rbx
movq %rax, 0x190(%rsp)
movq %rcx, 0x188(%rsp)
addq 0x188(%rsp), %r14
adcq 0x190(%rsp), %rsi
movq %rsi, %rax
cmpq %r9, %rsi
movq %rbp, 0x40(%rsp)
movq %r13, 0x10(%rsp)
jae 0x2b35f
movq %rax, %rbp
leaq (%r12,%rdi), %r13
movq %r13, %rdi
movq 0x38(%rsp), %rsi
movq (%rsp), %rdx
movq %rbx, %rcx
callq 0x2ffb0
movq 0x48(%rsp), %rdi
subq %rax, %r14
movq %rbp, %r8
sbbq $0x0, %r8
movq %r14, -0x8(%r15,%rdi)
jb 0x2b392
movq 0x18(%rsp), %r9
movq 0x40(%rsp), %rbp
movq 0x10(%rsp), %r13
movq %rbx, -0x8(%rbp,%rdi)
addq $-0x8, %rbp
addq $-0x8, %r15
addq $-0x8, %r12
decq %r13
testq %r13, %r13
movq 0x50(%rsp), %r10
jg 0x2b1b8
jmp 0x2b3c5
cmpq %r10, (%r15,%rdi)
jne 0x2b1c1
addq %r12, %rdi
movq $-0x1, %rbx
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq $-0x1, %rcx
callq 0x2ffb0
movq 0x18(%rsp), %r9
movq 0x48(%rsp), %rdi
movq (%r15,%rdi), %r8
jmp 0x2b2fe
ja 0x2b36a
cmpq %r10, %r14
jb 0x2b2ba
incq %rbx
movq %r10, 0x178(%rsp)
movq %r9, 0x180(%rsp)
subq 0x178(%rsp), %r14
sbbq 0x180(%rsp), %rax
jmp 0x2b2ba
movq %r13, %rdi
movq %r13, %rsi
movq 0x38(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq %r8, %r14
callq 0x1ba80
movq %r14, %r8
movq 0x48(%rsp), %rdi
movq 0x18(%rsp), %r9
addq %r9, %r8
addq %rax, %r8
decq %rbx
jmp 0x2b2f4
movq 0x60(%rsp), %rax
leaq (,%rax,8), %rcx
addq %rbp, %rcx
movq %rcx, (%rsp)
leaq (%r15,%rax,8), %r11
movq 0x68(%rsp), %r12
movq 0x70(%rsp), %rbx
movq 0x30(%rsp), %r15
jmp 0x2b401
leaq (,%r12,8), %rax
addq %rbp, %rax
movq %rax, (%rsp)
addq $-0x10, %r11
movq $-0x1, 0x10(%rsp)
cmpq $0x2, %r15
movq 0x38(%rsp), %rbp
jl 0x2b6b8
movq $-0x1, 0x10(%rsp)
je 0x2b6d1
movq %r12, 0x68(%rsp)
movq %r11, %rax
subq 0x28(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x28(%rsp)
movq $-0x1, 0x10(%rsp)
xorl %ebx, %ebx
xorl %ebp, %ebp
movq %r11, 0x20(%rsp)
movq 0x38(%rsp), %rax
leaq (%rax,%rbp), %r14
leaq (%r15,%rbx), %rax
addq $-0x2, %rax
movq %rax, 0x40(%rsp)
movq 0x10(%rsp), %rax
andq %r9, %rax
cmpq %rax, %r8
jae 0x2b5c5
movq 0x78(%rsp), %rax
movq %rax, 0x170(%rsp)
movq %r8, %rax
mulq 0x170(%rsp)
movq %rax, %rcx
movq %rdx, %r13
movq (%r11,%rbx,8), %rsi
movq %rsi, 0x160(%rsp)
movq %r8, 0x168(%rsp)
addq 0x160(%rsp), %rcx
adcq 0x168(%rsp), %r13
movq %r13, %rax
imulq %r9, %rax
subq %rax, %rsi
movq -0x8(%r11,%rbx,8), %r15
movq %r9, 0x158(%rsp)
movq %r10, 0x150(%rsp)
subq 0x150(%rsp), %r15
sbbq 0x158(%rsp), %rsi
movq %r13, 0x148(%rsp)
movq %r10, %rax
mulq 0x148(%rsp)
movq %rdx, 0x140(%rsp)
movq %rax, 0x138(%rsp)
subq 0x138(%rsp), %r15
sbbq 0x140(%rsp), %rsi
cmpq %rcx, %rsi
adcq $-0x1, %r13
cmpq %rcx, %rsi
movl $0x0, %eax
cmovaeq %r9, %rax
movl $0x0, %ecx
cmovaeq %r10, %rcx
incq %r13
movq %rax, 0x130(%rsp)
movq %rcx, 0x128(%rsp)
addq 0x128(%rsp), %r15
adcq 0x130(%rsp), %rsi
movq %rsi, %r12
cmpq %r9, %rsi
jae 0x2b60d
movq 0x28(%rsp), %rdi
movq %r14, %rsi
movq 0x40(%rsp), %rdx
movq %r13, %rcx
callq 0x2ffb0
subq %rax, %r15
movq %r12, %r8
sbbq $0x0, %r8
movq 0x20(%rsp), %r11
movq %r15, -0x8(%r11,%rbx,8)
jb 0x2b640
movq 0x30(%rsp), %r15
movq 0x18(%rsp), %r9
movq 0x50(%rsp), %r10
movq (%rsp), %rax
movq %r13, -0x8(%rax,%rbx,8)
addq $0x8, %rbp
decq %rbx
cmpq $0x1, 0x40(%rsp)
jg 0x2b450
jmp 0x2b6c0
leaq (%r15,%rbx), %rdx
movq $-0x1, %r13
movq 0x28(%rsp), %rdi
movq %r14, %rsi
movq %rdx, 0x98(%rsp)
movq $-0x1, %rcx
movq %r8, %r12
callq 0x2ffb0
cmpq %rax, %r12
jne 0x2b67a
movq 0x18(%rsp), %r9
movq 0x50(%rsp), %r10
movq 0x20(%rsp), %r11
movq (%r11,%rbx,8), %r8
jmp 0x2b5a4
ja 0x2b618
cmpq %r10, %r15
jb 0x2b566
incq %r13
movq %r10, 0x118(%rsp)
movq %r9, 0x120(%rsp)
subq 0x118(%rsp), %r15
sbbq 0x120(%rsp), %r12
jmp 0x2b566
movq 0x30(%rsp), %r15
leaq (%r15,%rbx), %rcx
decq %rcx
movq 0x28(%rsp), %rdi
movq %rdi, %rsi
movq %r14, %rdx
movq %r8, %r12
callq 0x1ba80
movq 0x20(%rsp), %r11
movq %r12, %r8
movq 0x18(%rsp), %r9
addq %r9, %r8
addq %rax, %r8
decq %r13
jmp 0x2b59f
movq 0x98(%rsp), %rcx
andq 0x10(%rsp), %rax
cmpq %rax, %r12
jae 0x2b6a5
movq 0x28(%rsp), %rdi
movq %rdi, %rsi
movq %r14, %rdx
callq 0x1ba80
movq $-0x2, %r13
jmp 0x2b6ae
movq $0x0, 0x10(%rsp)
movq 0x30(%rsp), %r15
jmp 0x2b5f8
movq %r11, %r13
jmp 0x2b7ec
subq %rbp, (%rsp)
subq %rbp, %r11
addq 0x38(%rsp), %rbp
movq 0x68(%rsp), %r12
leaq -0x8(%r11), %r13
movq 0x10(%rsp), %rax
andq %r9, %rax
cmpq %rax, %r8
jae 0x2b8ff
movq 0x78(%rsp), %rax
movq %rax, 0x100(%rsp)
movq %r8, %rax
mulq 0x100(%rsp)
movq %rax, %rcx
movq %rdx, %rbx
movq (%r11), %rdi
movq %rdi, 0xf0(%rsp)
movq %r8, 0xf8(%rsp)
addq 0xf0(%rsp), %rcx
adcq 0xf8(%rsp), %rbx
movq %rbx, %rax
imulq %r9, %rax
subq %rax, %rdi
movq -0x8(%r11), %rsi
movq %r9, 0xe8(%rsp)
movq %r10, 0xe0(%rsp)
subq 0xe0(%rsp), %rsi
sbbq 0xe8(%rsp), %rdi
movq %rbx, 0xd8(%rsp)
movq %r10, %rax
mulq 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq %rax, 0xc8(%rsp)
subq 0xc8(%rsp), %rsi
sbbq 0xd0(%rsp), %rdi
cmpq %rcx, %rdi
adcq $-0x1, %rbx
xorl %eax, %eax
cmpq %rcx, %rdi
movl $0x0, %ecx
cmovaeq %r9, %rcx
cmovaeq %r10, %rax
incq %rbx
movq %rcx, 0xc0(%rsp)
movq %rax, 0xb8(%rsp)
addq 0xb8(%rsp), %rsi
adcq 0xc0(%rsp), %rdi
movq %rdi, %r8
cmpq %r9, %rdi
jae 0x2b934
movq %rsi, -0x8(%r11)
movq %r8, (%r11)
movq (%rsp), %rax
movq %rbx, -0x8(%rax)
addq $-0x8, %rax
movq %rax, (%rsp)
movq 0x70(%rsp), %rbx
cmpq %r8, 0x8(%r13)
jne 0x2b819
movq 0x10(%rsp), %rax
andq %rbx, %rax
cmpq %rax, %r8
jb 0x2b81e
movq 0x8(%rsp), %rcx
movq %rcx, %rax
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x73fe
cmpq $0x3, %rbx
jl 0x2b8a3
movq (%r13), %r15
movq %r13, %rcx
movq %r12, %r13
cmpq $0x2, %r12
movq %rcx, 0x40(%rsp)
jl 0x2b893
movq 0x30(%rsp), %rax
addq $-0x3, %rax
leaq -0x8(%rcx), %rbx
movl $0x1, %r14d
movq %r8, %r12
movq %rax, %rbp
movq (%rsp), %rcx
movq (%rcx,%rax,8), %rcx
movq %rbx, %rdi
movq 0x38(%rsp), %rsi
movq %r14, %rdx
callq 0x2ffb0
subq %rax, %r15
jae 0x2b880
testq %r12, %r12
je 0x2ba11
movq %r12, %r8
decq %r8
jmp 0x2b883
movq %r12, %r8
leaq -0x1(%rbp), %rax
incq %r14
addq $-0x8, %rbx
testq %rbp, %rbp
jg 0x2b84c
movq 0x40(%rsp), %rax
movq %r15, (%rax)
movq 0x70(%rsp), %rbx
movq %r13, %r12
cmpq 0xa0(%rsp), %rbx
jle 0x2b7ff
movq %rbx, %r14
cmpb $0x0, 0x88(%rsp)
je 0x2b967
movq %r8, %r15
movq %r12, %rbx
movq 0x58(%rsp), %rax
leaq (%rax,%r12,8), %rdi
movq %rdi, %rsi
movq 0x90(%rsp), %rdx
movq 0x80(%rsp), %rcx
callq 0x1bca0
testq %rax, %rax
je 0x2b96c
testq %r15, %r15
je 0x2ba41
movq %r15, %r8
decq %r8
jmp 0x2b96f
movq %r11, %r15
movq $-0x1, %rbx
movl $0x2, %edx
movq %r13, %rdi
movq %rbp, %rsi
movq $-0x1, %rcx
movq %r8, %r14
callq 0x2ffb0
cmpq %rax, %r14
jne 0x2bac2
movq (%r15), %r8
jmp 0x2b7d7
ja 0x2b93f
cmpq %r10, %rsi
jb 0x2b7d0
incq %rbx
movq %r10, 0xa8(%rsp)
movq %r9, 0xb0(%rsp)
subq 0xa8(%rsp), %rsi
sbbq 0xb0(%rsp), %r8
jmp 0x2b7d0
movq %r12, %rbx
jmp 0x2b96f
movq %r15, %r8
cmpq %r14, 0x60(%rsp)
je 0x2b7ff
movq %r14, %rax
subq %rbx, %rax
cmpq $0x2, %rax
jl 0x2b7ff
movq %r8, %r13
movq %rbx, %r12
movq 0x58(%rsp), %rax
leaq (%rax,%r14,8), %rbx
addq $-0x10, %rbx
shlq $0x4, %r14
subq 0x48(%rsp), %r14
addq %rax, %r14
addq $-0x10, %r14
movl $0x1, %r15d
movq 0x80(%rsp), %rbp
movq 0x90(%rsp), %rax
movq -0x8(%rax,%rbp,8), %rcx
movq %r14, %rdi
movq (%rsp), %rsi
movq %r12, %rdx
callq 0x2ffb0
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x1bbe4
testq %rax, %rax
je 0x2b9f9
testq %r13, %r13
je 0x2ba8a
decq %r13
decq %rbp
addq $-0x8, %rbx
addq $-0x8, %r14
incq %r15
testq %rbp, %rbp
jg 0x2b9bb
jmp 0x2b7ff
movq (%rsp), %rax
subq $0x1, (%rax)
jae 0x2b7ff
movl $0x1, %eax
movq (%rsp), %rdx
cmpq %rax, %r13
je 0x2bb1f
subq $0x1, (%rdx,%rax,8)
leaq 0x1(%rax), %rax
jb 0x2ba28
jmp 0x2b7ff
cmpq %r14, 0x60(%rsp)
je 0x2ba7d
movq (%rsp), %rax
subq $0x1, (%rax)
jae 0x2ba7b
cmpq $0x2, %rbx
movl $0x1, %eax
cmovlq %rax, %rbx
movq %rbx, %rdx
movl $0x1, %ecx
movq (%rsp), %rsi
cmpq %rcx, %rdx
je 0x2ba7d
subq $0x1, (%rsi,%rcx,8)
leaq 0x1(%rcx), %rcx
jb 0x2ba6b
xorl %eax, %eax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
jmp 0x2b804
movq (%rsp), %rax
subq $0x1, (%rax)
jae 0x2b7ff
cmpq $0x2, %r12
movl $0x1, %eax
cmovlq %rax, %r12
movq (%rsp), %rdx
cmpq %rax, %r12
je 0x2b7ff
subq $0x1, (%rdx,%rax,8)
leaq 0x1(%rax), %rax
jb 0x2baa9
jmp 0x2b7ff
movq %r12, %rsi
andq 0x10(%rsp), %rax
cmpq %rax, %r14
movq (%r15), %r8
jae 0x2bb0e
movq (%rbp), %rax
movq 0x8(%rbp), %rcx
movq -0x8(%r15), %rdx
movq %rax, 0x108(%rsp)
movq %rcx, 0x110(%rsp)
addq 0x108(%rsp), %rdx
adcq 0x110(%rsp), %r8
movq %r8, (%r15)
movq %rdx, -0x8(%r15)
movq $-0x2, %rbx
jmp 0x2bb17
movq $0x0, 0x10(%rsp)
movq %rsi, %r12
jmp 0x2b7d7
leaq 0xde9d(%rip), %rdi      # 0x399c3
leaq 0xdeb0(%rip), %rdx      # 0x399dd
movl $0xf9, %esi
callq 0x2fcea
nop