// File: /workspace/github_cpp_makefile_star2_O2/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, 0x80(%rsp)
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
leaq (%rsi,%rdx,8), %r15
subq %r8, %rdx
movq %rdx, 0x40(%rsp)
leaq 0x1(%rdx), %rsi
movq %rsi, %rdx
subq %r8, %rdx
movq %r8, %r12
cmovlq %rsi, %r12
negq %rdx
xorl %eax, %eax
movq %r8, 0x8(%rsp)
movq %rsi, 0x78(%rsp)
cmpq %rsi, %r8
movq %rdx, 0xa0(%rsp)
cmovgq %rdx, %rax
movq %rcx, 0x70(%rsp)
leaq (%rcx,%rax,8), %rbp
leaq (,%r12,8), %rax
movq %r15, 0x18(%rsp)
subq %rax, %r15
movq %r15, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x1ac5c
xorl %ecx, %ecx
movl %eax, 0x8c(%rsp)
testl %eax, %eax
setns %cl
movq %rcx, 0x38(%rsp)
js 0x258de
movq %r15, %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r12, %rcx
callq 0x17ed0
movq %r12, %rax
movq 0x40(%rsp), %r12
leaq (%rbx,%r12,8), %rbx
leaq -0x2(%rax), %rcx
movq %rcx, 0x50(%rsp)
leaq -0x1(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq -0x10(%rbp,%rax,8), %r11
movq %rbp, 0x58(%rsp)
movq -0x8(%rbp,%rax,8), %r10
movq 0x18(%rsp), %r9
addq $-0x10, %r9
movq %r14, 0x68(%rsp)
movq %r13, 0x90(%rsp)
leaq -0x18(,%r14,8), %rdi
addq %r13, %rdi
movq 0x10(%rdi), %r8
subq %rax, %r12
pushq $0x2
popq %rcx
movq %rax, 0x28(%rsp)
subq %rax, %rcx
movq %rcx, 0x60(%rsp)
movq %r10, 0x30(%rsp)
movq %r11, 0x48(%rsp)
testq %r12, %r12
js 0x25b48
leaq -0x8(%r9), %r14
cmpq %r10, %r8
movq %rdi, 0x10(%rsp)
je 0x25ab4
movq %rbx, (%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x100(%rsp)
movq %r8, %rax
mulq 0x100(%rsp)
movq %rax, %rcx
movq %rdx, %r13
movq (%r9), %r15
movq %r15, 0xf0(%rsp)
movq %r8, 0xf8(%rsp)
addq 0xf0(%rsp), %rcx
adcq 0xf8(%rsp), %r13
movq %r13, %rax
imulq %r10, %rax
subq %rax, %r15
movq -0x8(%r9), %rbx
movq %r10, 0xe8(%rsp)
movq %r11, 0xe0(%rsp)
subq 0xe0(%rsp), %rbx
sbbq 0xe8(%rsp), %r15
movq %r13, 0xd8(%rsp)
movq %r11, %rax
mulq 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq %rax, 0xc8(%rsp)
subq 0xc8(%rsp), %rbx
sbbq 0xd0(%rsp), %r15
cmpq %rcx, %r15
adcq $-0x1, %r13
cmpq %rcx, %r15
movl $0x0, %eax
cmovaeq %r10, %rax
movl $0x0, %ecx
cmovaeq %r11, %rcx
incq %r13
movq %rax, 0xc0(%rsp)
movq %rcx, 0xb8(%rsp)
addq 0xb8(%rsp), %rbx
adcq 0xc0(%rsp), %r15
cmpq %r10, %r15
jae 0x25ae9
movq 0x60(%rsp), %rax
leaq (%r14,%rax,8), %rbp
movq %rbp, %rdi
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq %r13, %rcx
callq 0x29f90
subq %rax, %rbx
sbbq $0x0, %r15
movq %rbx, (%r14)
jb 0x25b1c
movq (%rsp), %rbx
movq 0x30(%rsp), %r10
movq %r13, -0x8(%rbx)
addq $-0x8, %rbx
decq %r12
movq 0x10(%rsp), %rdi
addq $-0x8, %rdi
movq %r15, %r8
movq %r14, %r9
movq 0x48(%rsp), %r11
jmp 0x2594d
cmpq %r11, (%r9)
jne 0x25968
movq 0x60(%rsp), %rax
leaq (%r14,%rax,8), %rdi
movq 0x58(%rsp), %rsi
movq 0x28(%rsp), %rdx
pushq $-0x1
popq %r13
movq %r13, %rcx
movq %r9, %r15
callq 0x29f90
movq 0x30(%rsp), %r10
movq (%r15), %r15
jmp 0x25a90
ja 0x25af4
cmpq %r11, %rbx
jb 0x25a59
incq %r13
movq %r11, 0xa8(%rsp)
movq %r10, 0xb0(%rsp)
subq 0xa8(%rsp), %rbx
sbbq 0xb0(%rsp), %r15
jmp 0x25a59
movq %rbp, %rdi
movq %rbp, %rsi
movq 0x58(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x17cf0
movq 0x30(%rsp), %r10
addq %r10, %r15
addq %rax, %r15
decq %r13
movq (%rsp), %rbx
jmp 0x25a90
movq 0x28(%rsp), %r12
pushq $-0x1
popq %rax
cmpq $0x2, %r12
jl 0x25e19
xorl %r14d, %r14d
xorl %r15d, %r15d
movq %rax, 0x20(%rsp)
movq %r9, 0x18(%rsp)
leaq (%r12,%r15), %rcx
addq $-0x2, %rcx
movq 0x58(%rsp), %rax
leaq (%rax,%r14), %rbp
movq 0x20(%rsp), %rax
andq %r10, %rax
testq %rcx, %rcx
movq %r15, (%rsp)
jle 0x25e2b
cmpq %rax, %r8
movq %r14, 0x50(%rsp)
jae 0x25d06
movq 0x80(%rsp), %rax
movq %rax, 0x160(%rsp)
movq %r8, %rax
mulq 0x160(%rsp)
movq %rax, %rsi
movq %rdx, %r13
movq %r8, %rax
movq (%r9,%r15,8), %r8
movq %r8, 0x150(%rsp)
movq %rax, 0x158(%rsp)
addq 0x150(%rsp), %rsi
adcq 0x158(%rsp), %r13
movq %r13, %rax
imulq %r10, %rax
subq %rax, %r8
movq -0x8(%r9,%r15,8), %r15
movq %r10, 0x148(%rsp)
movq %r11, 0x140(%rsp)
subq 0x140(%rsp), %r15
sbbq 0x148(%rsp), %r8
movq %r13, 0x138(%rsp)
movq %r11, %rax
mulq 0x138(%rsp)
movq %rdx, 0x130(%rsp)
movq %rax, 0x128(%rsp)
subq 0x128(%rsp), %r15
sbbq 0x130(%rsp), %r8
cmpq %rsi, %r8
adcq $-0x1, %r13
cmpq %rsi, %r8
movl $0x0, %eax
cmovaeq %r10, %rax
movl $0x0, %edx
cmovaeq %r11, %rdx
incq %r13
movq %rax, 0x120(%rsp)
movq %rdx, 0x118(%rsp)
addq 0x118(%rsp), %r15
adcq 0x120(%rsp), %r8
movq %r8, 0x10(%rsp)
cmpq %r10, %r8
jae 0x25d63
movq %rdi, %r14
movq 0x60(%rsp), %rax
leaq (%rdi,%rax,8), %r12
movq %r12, %rdi
movq %rbp, %rsi
movq %rcx, %rdx
movq %r13, %rcx
callq 0x29f90
subq %rax, %r15
movq 0x10(%rsp), %r8
sbbq $0x0, %r8
movq 0x18(%rsp), %r9
movq (%rsp), %rax
movq %r15, -0x8(%r9,%rax,8)
movq %rax, %r15
jb 0x25da0
movq 0x28(%rsp), %r12
movq %r14, %rdi
movq 0x30(%rsp), %r10
movq 0x48(%rsp), %r11
movq 0x50(%rsp), %r14
movq %r13, -0x8(%rbx,%r15,8)
incq 0x60(%rsp)
decq %r15
addq $0x8, %r14
addq $-0x8, %rdi
jmp 0x25b6a
movq %rdi, 0x10(%rsp)
movq 0x60(%rsp), %rax
leaq (%rdi,%rax,8), %rdi
addq %r12, %r15
movq %rdi, 0x98(%rsp)
movq %rbp, %rsi
movq %r15, %rdx
pushq $-0x1
popq %r13
movq %r13, %rcx
movq %r8, %r14
callq 0x29f90
cmpq %rax, %r14
jne 0x25dde
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %r9
movq 0x30(%rsp), %r10
movq 0x48(%rsp), %r11
movq (%rsp), %rax
movq (%r9,%rax,8), %r8
movq 0x50(%rsp), %r14
movq %rax, %r15
jmp 0x25cec
ja 0x25d6e
cmpq %r11, %r15
jb 0x25c95
incq %r13
movq %r11, 0x108(%rsp)
movq %r10, 0x110(%rsp)
movq 0x10(%rsp), %rax
subq 0x108(%rsp), %r15
sbbq 0x110(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x25c95
movq 0x28(%rsp), %rax
leaq (%rax,%r15), %rcx
decq %rcx
movq %r12, %rdi
movq %r12, %rsi
movq %rax, %r12
movq %rbp, %rdx
movq %r8, %rbp
callq 0x17cf0
movq %rbp, %r8
movq 0x18(%rsp), %r9
movq 0x30(%rsp), %r10
addq %r10, %r8
addq %rax, %r8
decq %r13
movq %r14, %rdi
jmp 0x25ce2
movq 0x98(%rsp), %rdi
andq 0x20(%rsp), %rax
cmpq %rax, %r14
jae 0x25e02
movq %rdi, %rsi
movq %rbp, %rdx
movq %r15, %rcx
callq 0x17cf0
pushq $-0x2
jmp 0x25e0d
movq $0x0, 0x20(%rsp)
pushq $-0x1
popq %r13
movq 0x28(%rsp), %r12
jmp 0x25d3d
movq %rax, 0x20(%rsp)
movq %r9, %rdi
movq 0x8(%rsp), %rcx
jmp 0x25f65
movq %rbx, %r15
movq 0x8(%rsp), %rcx
movq 0x78(%rsp), %rbx
cmpq %rbx, %rcx
cmovgq %rcx, %rbx
cmpq %rax, %r8
jae 0x26023
movq 0x80(%rsp), %rax
movq %rax, 0x1c0(%rsp)
movq %r8, %rax
mulq 0x1c0(%rsp)
movq %rax, %rcx
movq %rdx, %r13
movq (%rsp), %rdx
movq %r8, %rax
movq (%r9,%rdx,8), %r8
movq %r8, 0x1b0(%rsp)
movq %rax, 0x1b8(%rsp)
addq 0x1b0(%rsp), %rcx
adcq 0x1b8(%rsp), %r13
movq %r13, %rax
imulq %r10, %rax
subq %rax, %r8
movq -0x8(%r9,%rdx,8), %rsi
movq %r10, 0x1a8(%rsp)
movq %r11, 0x1a0(%rsp)
subq 0x1a0(%rsp), %rsi
sbbq 0x1a8(%rsp), %r8
movq %r13, 0x198(%rsp)
movq %r11, %rax
mulq 0x198(%rsp)
movq %rdx, 0x190(%rsp)
movq %rax, 0x188(%rsp)
subq 0x188(%rsp), %rsi
sbbq 0x190(%rsp), %r8
cmpq %rcx, %r8
adcq $-0x1, %r13
xorl %eax, %eax
cmpq %rcx, %r8
movl $0x0, %ecx
cmovaeq %r10, %rcx
cmovaeq %r11, %rax
incq %r13
movq %rcx, 0x180(%rsp)
movq %rax, 0x178(%rsp)
addq 0x178(%rsp), %rsi
adcq 0x180(%rsp), %r8
movq %r8, %rbx
movq %r15, %rax
cmpq %r10, %r8
jae 0x26065
movq 0x8(%rsp), %rcx
movq (%rsp), %rdx
movq %rbx, %r8
movq %rsi, -0x8(%r9,%rdx,8)
movq %r8, (%r9,%rdx,8)
movq %r13, -0x8(%rax,%rdx,8)
subq %r14, %rax
addq $-0x8, %rax
movq %rax, %rbx
cmpq %r8, 0x8(%rdi)
jne 0x25f92
movq 0x20(%rsp), %rax
andq %rcx, %rax
cmpq %rax, %r8
jb 0x25faa
movq 0x38(%rsp), %rcx
movq %rcx, %rax
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xda2a(%rip), %rdi      # 0x339c3
leaq 0xda31(%rip), %rdx      # 0x339d1
movl $0xc6, %esi
callq 0x29ce6
cmpq $0x3, %rcx
jl 0x260ab
movq %rbx, (%rsp)
movq (%rdi), %r14
addq $-0x3, %r12
leaq -0x8(%rdi), %rbx
pushq $0x1
popq %r13
testq %r12, %r12
js 0x260a4
movq %r8, %rbp
movq %rdi, %r15
movq (%rsp), %rax
movq (%rax,%r12,8), %rcx
movq %rbx, %rdi
movq 0x58(%rsp), %rsi
movq %r13, %rdx
callq 0x29f90
subq %rax, %r14
jae 0x2600c
testq %rbp, %rbp
je 0x26108
movq %rbp, %r8
decq %r8
movq 0x8(%rsp), %rcx
movq %r15, %rdi
jmp 0x26017
movq 0x8(%rsp), %rcx
movq %r15, %rdi
movq %rbp, %r8
decq %r12
incq %r13
addq $-0x8, %rbx
jmp 0x25fc7
pushq $0x2
popq %rdx
pushq $-0x1
popq %r13
movq %rdi, 0x10(%rsp)
movq %rbp, %rsi
movq %r13, %rcx
movq %r8, %rbp
callq 0x29f90
cmpq %rax, %rbp
jne 0x2622f
movq 0x18(%rsp), %rax
movq (%rsp), %rdx
movq (%rax,%rdx,8), %r8
movq %r15, %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdi
jmp 0x25f56
ja 0x26070
cmpq %r11, %rsi
jb 0x25f41
incq %r13
movq %r11, 0x168(%rsp)
movq %r10, 0x170(%rsp)
movq %rbx, %r8
subq 0x168(%rsp), %rsi
sbbq 0x170(%rsp), %r8
movq 0x8(%rsp), %rcx
movq (%rsp), %rdx
jmp 0x25f4d
movq %r14, (%rdi)
movq (%rsp), %rbx
cmpq 0x78(%rsp), %rcx
jle 0x25f78
cmpl $0x0, 0x8c(%rsp)
js 0x2614a
movq %r8, %r14
movq 0x40(%rsp), %rax
movq 0x90(%rsp), %rcx
leaq (%rcx,%rax,8), %rdi
movq %rdi, %rsi
movq 0x70(%rsp), %rdx
movq 0xa0(%rsp), %rcx
callq 0x17ed0
testq %rax, %rax
je 0x26142
testq %r14, %r14
je 0x26203
movq %r14, %r8
decq %r8
movq 0x8(%rsp), %rcx
jmp 0x2614a
pushq $0x1
popq %rcx
movq (%rsp), %rdi
movq %rdi, %rsi
movq 0x40(%rsp), %rdx
callq 0x17e44
testq %rax, %rax
movq 0x38(%rsp), %rcx
je 0x25f7d
leaq 0xd892(%rip), %rdi      # 0x339c3
leaq 0xd8a5(%rip), %rdx      # 0x339dd
movl $0xf9, %esi
callq 0x29ce6
movq 0x8(%rsp), %rcx
movq %r14, %r8
movq 0x68(%rsp), %rdx
cmpq %rcx, %rdx
je 0x25f78
movq %rbx, %r12
pushq $0x1
popq %rbx
movq %rcx, %r15
subq 0x40(%rsp), %r15
addq $-0x2, %r15
movq %rcx, %rax
shlq $0x4, %rax
shlq $0x3, %rdx
subq %rdx, %rax
movq 0x90(%rsp), %rdx
leaq (%rax,%rdx), %r14
addq $-0x10, %r14
leaq (%rdx,%rcx,8), %r13
addq $-0x10, %r13
testq %r15, %r15
js 0x25f78
movq %r8, %rbp
movq 0x70(%rsp), %rax
movq (%rax,%r15,8), %rcx
movq %r14, %rdi
movq %r12, %rsi
movq 0x40(%rsp), %rdx
callq 0x29f90
movq %r13, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x17e44
testq %rax, %rax
je 0x261d8
testq %rbp, %rbp
je 0x261eb
movq %rbp, %r8
decq %r8
jmp 0x261db
movq %rbp, %r8
decq %r15
incq %rbx
addq $-0x8, %r14
addq $-0x8, %r13
jmp 0x26190
pushq $0x1
popq %rcx
movq %r12, %rdi
movq %r12, %rsi
movq 0x40(%rsp), %rdx
callq 0x17e44
jmp 0x25f78
movq 0x68(%rsp), %rcx
cmpq 0x8(%rsp), %rcx
je 0x26222
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %rbx, %rsi
movq 0x40(%rsp), %rdx
callq 0x17e44
movq 0x38(%rsp), %rcx
subq %rax, %rcx
jmp 0x25f7d
andq 0x20(%rsp), %rax
cmpq %rax, %rbp
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %r9
jae 0x262e1
movq 0x8(%rsp), %rsi
addq %rsi, %rbx
shlq $0x3, %rbx
movq 0x68(%rsp), %rax
leaq (,%rax,8), %rax
subq %rax, %rbx
movq 0x70(%rsp), %rdx
addq %rdx, %rbx
movq 0x78(%rsp), %rcx
cmpq %rcx, %rsi
cmovgq %rsi, %rcx
addq %rsi, %rcx
shlq $0x3, %rcx
subq %rax, %rcx
addq %rdx, %rcx
movq (%r14,%rcx), %rax
movq 0x18(%rsp), %rdi
movq (%rsp), %r8
movq -0x8(%rdi,%r8,8), %rcx
movq -0x8(%rbx,%r14), %rdx
movq %rdx, 0x1c8(%rsp)
movq %rax, 0x1d0(%rsp)
addq 0x1c8(%rsp), %rcx
adcq 0x1d0(%rsp), %r9
movq %r9, (%rdi,%r8,8)
movq %rcx, -0x8(%rdi,%r8,8)
movq %rsi, %rcx
pushq $-0x2
popq %r13
movq %r15, %rax
movq %r8, %rdx
movq %r9, %r8
movq 0x28(%rsp), %r12
jmp 0x2605b
movq $0x0, 0x20(%rsp)
movq %r15, %rax
movq 0x8(%rsp), %rcx
movq 0x28(%rsp), %r12
movq 0x10(%rsp), %rdi
movq (%rsp), %rdx
movq %r9, %r8
jmp 0x25f56