// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/mpf/sub.c
// Function: _gmpf_sub
void
mpf_sub (mpf_ptr r, mpf_srcptr u, mpf_srcptr v)
{
  mp_srcptr up, vp;
  mp_ptr rp, tp;
  mp_size_t usize, vsize, rsize;
  mp_size_t prec;
  mp_exp_t exp;
  mp_size_t ediff;
  int negate;
  TMP_DECL;

  usize = SIZ (u);
  vsize = SIZ (v);

  /* Handle special cases that don't work in generic code below.  */
  if (usize == 0)
    {
      mpf_neg (r, v);
      return;
    }
  if (vsize == 0)
    {
      if (r != u)
        mpf_set (r, u);
      return;
    }

  /* If signs of U and V are different, perform addition.  */
  if ((usize ^ vsize) < 0)
    {
      __mpf_struct v_negated;
      v_negated._mp_size = -vsize;
      v_negated._mp_exp = EXP (v);
      v_negated._mp_d = PTR (v);
      mpf_add (r, u, &v_negated);
      return;
    }

  TMP_MARK;

  /* Signs are now known to be the same.  */
  negate = usize < 0;

  /* Make U be the operand with the largest exponent.  */
  if (EXP (u) < EXP (v))
    {
      mpf_srcptr t;
      t = u; u = v; v = t;
      negate ^= 1;
      usize = SIZ (u);
      vsize = SIZ (v);
    }

  usize = ABS (usize);
  vsize = ABS (vsize);
  up = PTR (u);
  vp = PTR (v);
  rp = PTR (r);
  prec = PREC (r) + 1;
  exp = EXP (u);
  ediff = exp - EXP (v);

  /* If ediff is 0 or 1, we might have a situation where the operands are
     extremely close.  We need to scan the operands from the most significant
     end ignore the initial parts that are equal.  */
  if (ediff <= 1)
    {
      if (ediff == 0)
	{
	  /* Skip leading limbs in U and V that are equal.  */
	      /* This loop normally exits immediately.  Optimize for that.  */
	      while (up[usize - 1] == vp[vsize - 1])
		{
		  usize--;
		  vsize--;
		  exp--;

		  if (usize == 0)
		    {
                      /* u cancels high limbs of v, result is rest of v */
		      negate ^= 1;
                    cancellation:
                      /* strip high zeros before truncating to prec */
                      while (vsize != 0 && vp[vsize - 1] == 0)
                        {
                          vsize--;
                          exp--;
                        }
		      if (vsize > prec)
			{
			  vp += vsize - prec;
			  vsize = prec;
			}
                      MPN_COPY_INCR (rp, vp, vsize);
                      rsize = vsize;
                      goto done;
		    }
		  if (vsize == 0)
		    {
                      vp = up;
                      vsize = usize;
                      goto cancellation;
		    }
		}

	  if (up[usize - 1] < vp[vsize - 1])
	    {
	      /* For simplicity, swap U and V.  Note that since the loop above
		 wouldn't have exited unless up[usize - 1] and vp[vsize - 1]
		 were non-equal, this if-statement catches all cases where U
		 is smaller than V.  */
	      MPN_SRCPTR_SWAP (up,usize, vp,vsize);
	      negate ^= 1;
	      /* negating ediff not necessary since it is 0.  */
	    }

	  /* Check for
	     x+1 00000000 ...
	      x  ffffffff ... */
	  if (up[usize - 1] != vp[vsize - 1] + 1)
	    goto general_case;
	  usize--;
	  vsize--;
	  exp--;
	}
      else /* ediff == 1 */
	{
	  /* Check for
	     1 00000000 ...
	     0 ffffffff ... */

	  if (up[usize - 1] != 1 || vp[vsize - 1] != GMP_NUMB_MAX
	      || (usize >= 2 && up[usize - 2] != 0))
	    goto general_case;

	  usize--;
	  exp--;
	}

      /* Skip sequences of 00000000/ffffffff */
      while (vsize != 0 && usize != 0 && up[usize - 1] == 0
	     && vp[vsize - 1] == GMP_NUMB_MAX)
	{
	  usize--;
	  vsize--;
	  exp--;
	}

      if (usize == 0)
	{
	  while (vsize != 0 && vp[vsize - 1] == GMP_NUMB_MAX)
	    {
	      vsize--;
	      exp--;
	    }
	}
      else if (usize > prec - 1)
	{
	  up += usize - (prec - 1);
	  usize = prec - 1;
	}
      if (vsize > prec - 1)
	{
	  vp += vsize - (prec - 1);
	  vsize = prec - 1;
	}

      tp = TMP_ALLOC_LIMBS (prec);
      {
	mp_limb_t cy_limb;
	if (vsize == 0)
	  {
	    MPN_COPY (tp, up, usize);
	    tp[usize] = 1;
	    rsize = usize + 1;
	    exp++;
	    goto normalized;
	  }
	if (usize == 0)
	  {
	    cy_limb = mpn_neg (tp, vp, vsize);
	    rsize = vsize;
	  }
	else if (usize >= vsize)
	  {
	    /* uuuu     */
	    /* vv       */
	    mp_size_t size;
	    size = usize - vsize;
	    MPN_COPY (tp, up, size);
	    cy_limb = mpn_sub_n (tp + size, up + size, vp, vsize);
	    rsize = usize;
	  }
	else /* (usize < vsize) */
	  {
	    /* uuuu     */
	    /* vvvvvvv  */
	    mp_size_t size;
	    size = vsize - usize;
	    cy_limb = mpn_neg (tp, vp, size);
	    cy_limb = mpn_sub_nc (tp + size, up, vp + size, usize, cy_limb);
	    rsize = vsize;
	  }
	if (cy_limb == 0)
	  {
	    tp[rsize] = 1;
	    rsize++;
	    exp++;
	    goto normalized;
	  }
	goto normalize;
      }
    }

general_case:
  /* If U extends beyond PREC, ignore the part that does.  */
  if (usize > prec)
    {
      up += usize - prec;
      usize = prec;
    }

  /* If V extends beyond PREC, ignore the part that does.
     Note that this may make vsize negative.  */
  if (vsize + ediff > prec)
    {
      vp += vsize + ediff - prec;
      vsize = prec - ediff;
    }

  if (ediff >= prec)
    {
      /* V completely cancelled.  */
      if (rp != up)
	MPN_COPY (rp, up, usize);
      rsize = usize;
    }
  else
    {
      /* Allocate temp space for the result.  Allocate
	 just vsize + ediff later???  */
      tp = TMP_ALLOC_LIMBS (prec);

      /* Locate the least significant non-zero limb in (the needed
	 parts of) U and V, to simplify the code below.  */
      for (;;)
	{
	  if (vsize == 0)
	    {
	      MPN_COPY (rp, up, usize);
	      rsize = usize;
	      goto done;
	    }
	  if (vp[0] != 0)
	    break;
	  vp++, vsize--;
	}
      for (;;)
	{
	  if (usize == 0)
	    {
	      MPN_COPY (rp, vp, vsize);
	      rsize = vsize;
	      negate ^= 1;
	      goto done;
	    }
	  if (up[0] != 0)
	    break;
	  up++, usize--;
	}

      /* uuuu     |  uuuu     |  uuuu     |  uuuu     |  uuuu    */
      /* vvvvvvv  |  vv       |    vvvvv  |    v      |       vv */

      if (usize > ediff)
	{
	  /* U and V partially overlaps.  */
	  if (ediff == 0)
	    {
	      /* Have to compare the leading limbs of u and v
		 to determine whether to compute u - v or v - u.  */
	      if (usize >= vsize)
		{
		  /* uuuu     */
		  /* vv       */
		  mp_size_t size;
		  size = usize - vsize;
		  MPN_COPY (tp, up, size);
		  mpn_sub_n (tp + size, up + size, vp, vsize);
		  rsize = usize;
		}
	      else /* (usize < vsize) */
		{
		  /* uuuu     */
		  /* vvvvvvv  */
		  mp_size_t size;
		  size = vsize - usize;
		  ASSERT_CARRY (mpn_neg (tp, vp, size));
		  mpn_sub_nc (tp + size, up, vp + size, usize, CNST_LIMB (1));
		  rsize = vsize;
		}
	    }
	  else
	    {
	      if (vsize + ediff <= usize)
		{
		  /* uuuu     */
		  /*   v      */
		  mp_size_t size;
		  size = usize - ediff - vsize;
		  MPN_COPY (tp, up, size);
		  mpn_sub (tp + size, up + size, usize - size, vp, vsize);
		  rsize = usize;
		}
	      else
		{
		  /* uuuu     */
		  /*   vvvvv  */
		  mp_size_t size;
		  rsize = vsize + ediff;
		  size = rsize - usize;
		  ASSERT_CARRY (mpn_neg (tp, vp, size));
		  mpn_sub (tp + size, up, usize, vp + size, usize - ediff);
		  /* Should we use sub_nc then sub_1? */
		  MPN_DECR_U (tp + size, usize, CNST_LIMB (1));
		}
	    }
	}
      else
	{
	  /* uuuu     */
	  /*      vv  */
	  mp_size_t size, i;
	  size = vsize + ediff - usize;
	  ASSERT_CARRY (mpn_neg (tp, vp, vsize));
	  for (i = vsize; i < size; i++)
	    tp[i] = GMP_NUMB_MAX;
	  mpn_sub_1 (tp + size, up, usize, (mp_limb_t) 1);
	  rsize = size + usize;
	}

    normalize:
      /* Full normalize.  Optimize later.  */
      while (rsize != 0 && tp[rsize - 1] == 0)
	{
	  rsize--;
	  exp--;
	}
    normalized:
      MPN_COPY (rp, tp, rsize);
    }

 done:
  TMP_FREE;
  if (rsize == 0) {
    SIZ (r) = 0;
    EXP (r) = 0;
  } else {
    SIZ (r) = negate ? -rsize : rsize;
    EXP (r) = exp;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movslq 0x4(%rsi), %rax
testq %rax, %rax
je 0x16c7b
movslq 0x4(%rdx), %rcx
testl %ecx, %ecx
je 0x16c91
movq %rcx, %r8
xorq %rax, %r8
js 0x16cad
andq $0x0, -0xf0(%rbp)
movl %eax, %r8d
shrl $0x1f, %r8d
movq 0x8(%rsi), %r13
movq 0x8(%rdx), %rbx
cmpq %rbx, %r13
jge 0x16cd6
xorl $0x1, %r8d
movl %r8d, -0x2c(%rbp)
movq %r13, %r12
movq %rbx, %r10
movq %rax, %r14
movq %rsi, %r8
jmp 0x16cec
movq %rdx, %rsi
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17bc0
cmpq %rsi, %rdi
je 0x175e6
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x15fe4
negl %ecx
leaq -0xf0(%rbp), %rax
movl %ecx, 0x4(%rax)
movq 0x8(%rdx), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rdx), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdx
callq 0x168e4
jmp 0x175e6
movl %r8d, -0x2c(%rbp)
movq %rbx, %r12
movq %r13, %r10
movq %rcx, %r14
movq %rax, %rcx
movq %rdx, %r8
movq %rsi, %rdx
movq %rcx, %rax
negq %rax
movq %rcx, %rsi
cmovnsq %rax, %rsi
movq %rsi, -0x58(%rbp)
movq %r14, %rsi
negq %rsi
movq %r14, %r9
cmovnsq %rsi, %r9
movq 0x10(%rdx), %rdx
movq %rdx, -0x70(%rbp)
movq 0x10(%r8), %r11
movq 0x10(%rdi), %r15
movq %rdi, -0xb8(%rbp)
movl (%rdi), %edx
incl %edx
movslq %edx, %r8
movq %r10, %rdx
subq %r12, %rdx
movq %rdx, -0x68(%rbp)
cmpq $0x1, %rdx
movq %r12, %rdx
movq %r13, -0xd8(%rbp)
movq %rbx, -0xd0(%rbp)
movq %r10, -0x60(%rbp)
jg 0x16dd9
movq %r11, -0x40(%rbp)
cmpq %r13, %rbx
jne 0x16df1
movq %rdx, %rdi
movq %r8, -0x80(%rbp)
movq %r15, -0x48(%rbp)
cmpq %rsi, %r14
movq %rsi, %rdx
cmovgq %r14, %rdx
movq -0x40(%rbp), %r8
leaq (%r8,%rdx,8), %r8
addq $-0x8, %r8
cmpq %rax, %rcx
movq %rax, %r9
cmovgq %rcx, %r9
movq -0x70(%rbp), %r10
leaq (%r10,%r9,8), %r10
addq $-0x8, %r10
xorl %r11d, %r11d
movq %r11, %r15
movq (%r10,%r11,8), %r11
movq (%r8,%r15,8), %rbx
cmpq %rbx, %r11
jne 0x17100
leaq (%r9,%r15), %r11
cmpq $0x1, %r11
je 0x1714a
leaq -0x1(%r15), %r11
movq %rdx, %rbx
addq %r11, %rbx
jne 0x16d98
cmpq %rax, %rcx
cmovgq %rcx, %rax
addq %r11, %rax
movq -0x70(%rbp), %r14
jmp 0x17160
movq %r10, -0x38(%rbp)
movq %r11, -0x50(%rbp)
movq %r9, %rdi
movq %r15, %r9
movl -0x2c(%rbp), %r15d
movq -0x70(%rbp), %r11
jmp 0x16e38
movq -0x70(%rbp), %r11
movq -0x58(%rbp), %rax
cmpq $0x1, -0x8(%r11,%rax,8)
jne 0x16e22
movq %r9, %rdi
movq -0x40(%rbp), %rcx
cmpq $-0x1, -0x8(%rcx,%r9,8)
je 0x171bb
movq -0x60(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rcx, -0x50(%rbp)
jmp 0x16e31
movq %r10, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %r9, %rdi
movq %r15, %r9
movl -0x2c(%rbp), %r15d
movq -0x58(%rbp), %r10
xorl %eax, %eax
movq %r10, %rcx
subq %r8, %rcx
movq %r8, %r14
cmovlq %r10, %r14
cmovleq %rax, %rcx
leaq (%r11,%rcx,8), %r12
movq -0x68(%rbp), %rcx
addq %rcx, %rdi
movq %rdi, %rbx
subq %r8, %rbx
cmovleq %rax, %rbx
cmpq %r8, %rcx
jge 0x16f49
movq %rdi, -0xa0(%rbp)
leaq (,%r8,8), %rsi
cmpq $0x7f00, %rsi           # imm = 0x7F00
movl %r15d, -0x2c(%rbp)
movq %r9, -0x48(%rbp)
movq %r11, -0x70(%rbp)
movq %rsi, -0x98(%rbp)
ja 0x175fc
movq %rsp, %rdi
leaq 0xf(%rsi), %rax
andq $-0x10, %rax
subq %rax, %rdi
movq %rdi, %rsp
movq -0x50(%rbp), %rax
leaq (%rax,%rbx,8), %rsi
movq -0xa0(%rbp), %rax
cmpq %r8, %rax
movq %r8, %r13
cmovlq %rax, %r13
leaq (,%r14,8), %rax
leaq (,%r13,8), %rcx
movq %rax, -0xb0(%rbp)
movq %rcx, -0xa8(%rbp)
subq %rcx, %rax
movq %rax, -0x88(%rbp)
leaq (%rdx,%r13), %r15
subq %r14, %r15
movq -0x60(%rbp), %rax
subq %rax, %r15
movq %rdx, %rcx
movq %r14, %r11
leaq (%r14,%rax), %rdx
subq %rcx, %rdx
movq %rdx, %r9
subq %r13, %r9
movq %r9, -0xc0(%rbp)
negq %r13
movq %rcx, %r14
movq %rax, %r9
subq %rax, %rcx
xorl %ebx, %ebx
movq %r15, -0xc8(%rbp)
movq %r15, %rax
movq %rcx, %r15
subq %r13, %r15
je 0x16f65
cmpq $0x0, (%rsi,%rbx)
jne 0x16f80
addq $0x8, %rbx
incq %r13
decq %rax
jmp 0x16f2e
cmpq %r12, %r9
je 0x17050
movq %r9, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x290c6
jmp 0x17050
movq -0x48(%rbp), %rdi
movq %r12, %rsi
movq %r11, %r14
movq %r11, %rdx
callq 0x290c6
movl -0x2c(%rbp), %r15d
jmp 0x17050
movq %r10, -0x58(%rbp)
movq %r12, -0x40(%rbp)
movq %rdi, -0x78(%rbp)
movq %r8, -0x80(%rbp)
movq -0xa8(%rbp), %r8
leaq (%r8,%r14,8), %r10
shlq $0x3, %r14
movq -0xb0(%rbp), %r12
subq %r12, %r10
leaq (,%r9,8), %rcx
subq %rcx, %r10
subq %rbx, %r10
leaq (%r12,%r9,8), %rcx
subq %r14, %rcx
subq %r8, %rcx
movq -0x78(%rbp), %rdi
addq %rbx, %rcx
movq %rcx, -0x60(%rbp)
movq -0x88(%rbp), %r14
addq %rbx, %r14
movq %r13, %r8
negq %r8
addq %rbx, %rsi
xorl %ecx, %ecx
movq -0x68(%rbp), %r9
movq %r9, -0x88(%rbp)
xorl %r9d, %r9d
movq %r13, -0x90(%rbp)
movq %r11, %r12
addq %rcx, %r12
je 0x17038
movq %r12, %r13
movq %r10, %r12
movq %r9, %r10
movq -0x40(%rbp), %r9
cmpq $0x0, (%r9,%r10)
movq %r10, %r9
jne 0x17059
incq %r8
addq $-0x8, %r14
addq $0x8, %r9
incq -0x88(%rbp)
decq %rcx
addq $-0x8, -0x60(%rbp)
movq %r12, %r10
addq $0x8, %r10
jmp 0x16ff6
movq -0x48(%rbp), %rdi
movq %r15, %rdx
callq 0x290c6
movl -0x2c(%rbp), %eax
xorl $0x1, %eax
movq %r15, %r14
movl %eax, %r15d
movq -0x38(%rbp), %rbx
jmp 0x175a9
addq %r9, -0x40(%rbp)
cmpq -0x68(%rbp), %r13
movq -0x58(%rbp), %r10
jle 0x171ed
movq %rsi, -0x68(%rbp)
movq -0xd0(%rbp), %rsi
cmpq -0xd8(%rbp), %rsi
jne 0x1729b
movq %r13, -0x88(%rbp)
cmpq %r15, %r13
jge 0x1733c
subq %rcx, %rax
movq %rdi, %rbx
movq -0x68(%rbp), %rsi
movq %rax, %rdx
movq -0x50(%rbp), %r13
movq %r9, %r14
callq 0x17fa8
movq %rbx, %rdi
subq -0x60(%rbp), %rdi
movq -0x80(%rbp), %rax
movq -0xa0(%rbp), %rcx
cmpq %rax, %rcx
cmovgq %rcx, %rax
movq -0xc8(%rbp), %rcx
shlq $0x3, %rcx
leaq (%rcx,%rax,8), %rax
subq -0x98(%rbp), %rax
addq %r14, %r13
addq %rax, %r13
pushq $0x1
popq %r8
movq -0x40(%rbp), %rsi
movq %r13, %rdx
movq -0x88(%rbp), %rcx
callq 0x17eb0
movq %r15, %r12
jmp 0x1722e
cmpq %rsi, %r14
cmovgq %r14, %rsi
movq %rsi, %r10
addq %r15, %r10
cmpq %rax, %rcx
cmovgq %rcx, %rax
movq %r15, %rsi
addq %r15, %rax
cmpq %rbx, %r11
movq %rdi, %rdx
jae 0x1723f
movl -0x2c(%rbp), %r15d
xorl $0x1, %r15d
movq %rax, %rdi
movq -0x70(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %r9
movq -0x80(%rbp), %r8
movq -0x40(%rbp), %r14
jmp 0x1725d
xorl $0x1, -0x2c(%rbp)
cmpq %rsi, %r14
cmovgq %r14, %rsi
leaq (%rsi,%r15), %rax
decq %rax
movq -0x40(%rbp), %r14
movq %rax, %rbx
notq %rbx
addq %rdi, %rbx
addq %r15, %rbx
leaq (%rdi,%r15), %rcx
decq %rcx
movq %rax, %rsi
movq -0x48(%rbp), %rdi
movl -0x2c(%rbp), %r15d
movq -0x80(%rbp), %rdx
subq $0x1, %rsi
jb 0x1719a
cmpq $0x0, (%r14,%rsi,8)
jne 0x17197
decq %rcx
movq %rsi, %rax
jmp 0x17182
movq %rcx, %rbx
xorl %ecx, %ecx
movq %rax, %rsi
subq %rdx, %rsi
cmovlq %rax, %rdx
cmovgq %rsi, %rcx
leaq (%r14,%rcx,8), %rsi
movq %rdx, %r14
callq 0x290c6
jmp 0x175a9
movq -0x58(%rbp), %r10
cmpq $0x2, %r10
movq %r15, %r9
jb 0x17287
cmpq $0x0, -0x10(%r11,%r10,8)
movl -0x2c(%rbp), %r15d
je 0x173df
movq -0x60(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rcx, -0x50(%rbp)
jmp 0x16e3c
negq -0x90(%rbp)
subq %r11, %r8
movq %r15, %rdx
movq %r8, %rbx
callq 0x17fa8
movq -0x78(%rbp), %rdi
cmpq %rbx, %r15
jge 0x17215
orq $-0x1, (%rdi,%r15,8)
incq %r15
jmp 0x17206
subq %r14, %rdi
pushq $0x1
popq %rcx
movq -0x40(%rbp), %rsi
movq %r13, %rdx
callq 0x17e44
movq -0x90(%rbp), %r12
movl -0x2c(%rbp), %r15d
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rbx
jmp 0x1755c
movq %r10, %rdi
movq %rax, %r10
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x70(%rbp), %r14
movq -0x48(%rbp), %r9
movl -0x2c(%rbp), %r15d
movq -0x80(%rbp), %r8
addq %rdx, %rsi
movq -0x50(%rbp), %rax
movq -0x8(%rax,%rdi,8), %rax
incq %rax
cmpq %rax, -0x8(%r14,%r10,8)
jne 0x1727b
decq %rdi
jmp 0x173ea
movq %rsi, -0x38(%rbp)
movq %r14, %r11
jmp 0x16e3c
movq -0x60(%rbp), %rsi
movq %rcx, -0x50(%rbp)
movq %r11, %r14
movl -0x2c(%rbp), %r15d
jmp 0x173ea
movq -0x90(%rbp), %rax
negq %rax
movq %r13, %r12
movq %rax, %r13
cmpq %r12, %rax
jle 0x173aa
subq %r11, %r8
movq %r13, -0x90(%rbp)
movq %r11, %r13
movq -0x68(%rbp), %rsi
movq %r8, %rdx
movq -0x80(%rbp), %r15
movq -0x50(%rbp), %rbx
movq %r9, -0x60(%rbp)
callq 0x17fa8
movq -0x78(%rbp), %rax
subq %r14, %rax
movq %rax, %r14
movq -0xa0(%rbp), %rax
cmpq %r15, %rax
cmovgq %rax, %r15
movq -0xa8(%rbp), %rax
leaq (%rax,%r15,8), %rax
subq -0xb0(%rbp), %rax
subq -0x98(%rbp), %rax
addq -0x60(%rbp), %rbx
addq %rax, %rbx
subq -0x88(%rbp), %r13
movq %r14, %rdi
movq -0x40(%rbp), %rsi
movq %r12, %rdx
movq %rbx, %rcx
movq %r13, %r8
callq 0x17dc8
subq $0x1, (%r14)
leaq 0x8(%r14), %r14
jb 0x1732d
jmp 0x17227
addq -0x90(%rbp), %rdx
addq %rcx, %rdx
movq %rdi, %r13
movq -0x40(%rbp), %rsi
movq %r10, %r14
callq 0x290c6
movq %r13, %rdi
subq %r12, %rdi
movq -0x80(%rbp), %rax
cmpq %rax, %r14
cmovgq %r14, %rax
movq -0xc0(%rbp), %rcx
shlq $0x3, %rcx
leaq (%rcx,%rax,8), %rax
subq -0x98(%rbp), %rax
movq -0x70(%rbp), %rsi
addq %rbx, %rsi
addq %rax, %rsi
movq -0x68(%rbp), %rdx
movq %r15, %rcx
callq 0x17ed0
movl -0x2c(%rbp), %r15d
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rbx
movq -0x88(%rbp), %r12
jmp 0x1755c
movq %r11, %rbx
subq %r8, %rbx
movq -0x40(%rbp), %rsi
movq %rbx, %rdx
callq 0x290c6
addq -0x78(%rbp), %r14
movq -0x40(%rbp), %rax
leaq (%rax,%rbx,8), %rsi
movq %r14, %rdi
movq %r13, %rdx
movq -0x68(%rbp), %rcx
movq %r15, %r8
callq 0x17dc8
jmp 0x1722e
movq -0x60(%rbp), %rsi
movq %rcx, -0x50(%rbp)
movq %r11, %r14
movq -0x50(%rbp), %r11
movq %r10, %rdx
movq %rdi, %rax
movq %rsi, %rcx
decq %r10
decq %rsi
testq %rdi, %rdi
je 0x1741b
testq %r10, %r10
je 0x1741b
cmpq $0x0, -0x10(%r14,%rdx,8)
jne 0x1741b
leaq -0x1(%rax), %rdi
cmpq $-0x1, -0x8(%r11,%rax,8)
je 0x173ee
testq %r10, %r10
je 0x17433
subq %r8, %rdx
movq %rsi, -0x38(%rbp)
jle 0x1745e
leaq -0x1(%r8), %r10
leaq (%r14,%rdx,8), %r14
jmp 0x1745e
pushq $0x1
popq %rdx
movq %rax, %rsi
movq -0x50(%rbp), %rdi
subq $0x1, %rsi
jb 0x17452
cmpq $-0x1, (%rdi,%rsi,8)
jne 0x17454
incq %rdx
movq %rsi, %rax
jmp 0x1743d
xorl %eax, %eax
subq %rdx, %rcx
xorl %r10d, %r10d
movq %rcx, -0x38(%rbp)
leaq -0x1(%r8), %r12
movq %rax, %rcx
subq %r12, %rcx
xorl %ebx, %ebx
cmpq %r8, %rax
cmovlq %rax, %r12
cmovgeq %rcx, %rbx
shlq $0x3, %r8
cmpq $0x7f00, %r8            # imm = 0x7F00
ja 0x1762a
movq %rsp, %rdi
addq $0xf, %r8
andq $-0x10, %r8
subq %r8, %rdi
movq %rdi, %rsp
testq %r12, %r12
je 0x174f5
movq -0x50(%rbp), %rax
leaq (%rax,%rbx,8), %rbx
testq %r10, %r10
movq %r9, -0x48(%rbp)
movq %rdi, -0x78(%rbp)
je 0x17512
movl %r15d, -0x2c(%rbp)
movq %r10, %r15
subq %r12, %r15
movq %r10, -0x58(%rbp)
jge 0x1751f
movq %r12, %r15
subq %r10, %r15
movq %rdi, %r13
movq %rbx, %rsi
movq %r15, %rdx
callq 0x17fa8
leaq (,%r15,8), %rdi
addq %r13, %rdi
leaq (%rbx,%r15,8), %rdx
movq %r14, %rsi
movq -0x58(%rbp), %rcx
movq %rax, %r8
callq 0x17eb0
jmp 0x1754b
movq %rdi, %r13
movq %r14, %rsi
movq %r10, %rdx
movq %r9, %rbx
movq %r10, %r12
callq 0x290c6
movq %rbx, %rdi
movq -0x38(%rbp), %rbx
jmp 0x1758c
movq %rbx, %rsi
movq %r12, %rdx
callq 0x17fa8
jmp 0x1754f
movq %rdi, %r13
movq %r14, %rsi
movq %r15, %rdx
callq 0x290c6
leaq (,%r15,8), %rdi
addq %r13, %rdi
leaq (%r14,%r15,8), %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x17ed0
movq -0x58(%rbp), %r12
movl -0x2c(%rbp), %r15d
testq %rax, %rax
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rbx
je 0x17588
movq %rbx, %rcx
subq %r12, %rbx
movq %r12, %rax
movq -0x78(%rbp), %rsi
subq $0x1, %rax
jb 0x1757e
cmpq $0x0, (%rsi,%rax,8)
jne 0x17583
decq %rcx
movq %rax, %r12
jmp 0x17569
xorl %r12d, %r12d
jmp 0x1759e
movq %rcx, %rbx
jmp 0x1759e
movq -0x78(%rbp), %r13
movq $0x1, (%r13,%r12,8)
incq %r12
incq %rbx
movq %r13, %rsi
movq %r12, %rdx
callq 0x290c6
movq %r12, %r14
movq -0xf0(%rbp), %rdi
testq %rdi, %rdi
jne 0x175f5
testq %r14, %r14
je 0x175d6
movl %r14d, %eax
negl %eax
testl %r15d, %r15d
cmovel %r14d, %eax
movq -0xb8(%rbp), %rcx
movl %eax, 0x4(%rcx)
movq %rbx, 0x8(%rcx)
jmp 0x175e6
movq -0xb8(%rbp), %rax
andl $0x0, 0x4(%rax)
andq $0x0, 0x8(%rax)
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x29df3
jmp 0x175b5
leaq -0xf0(%rbp), %rdi
movq %r8, %r15
movq %r10, %r13
movq %r12, -0x40(%rbp)
movq %rdx, %r12
callq 0x29dc0
movq %r12, %rdx
movq -0x40(%rbp), %r12
movq %r13, %r10
movq %r15, %r8
movq %rax, %rdi
jmp 0x16ead
leaq -0xf0(%rbp), %rdi
movq %r8, %rsi
movq %r9, -0x48(%rbp)
movq %r10, -0x58(%rbp)
callq 0x29dc0
movq -0x58(%rbp), %r10
movq -0x48(%rbp), %r9
movq %rax, %rdi
jmp 0x17497
nopl (%rax)