// File: /workspace/github_cpp_makefile_star2_O3/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 $0xf8, %rsp
movq %rdi, %r14
movslq 0x4(%rsi), %rax
testq %rax, %rax
je 0x1aa37
movslq 0x4(%rdx), %rdi
testl %edi, %edi
je 0x1aa50
movq %rdi, %rcx
xorq %rax, %rcx
js 0x1aa6f
movq $0x0, -0x118(%rbp)
movl %eax, %ecx
shrl $0x1f, %ecx
movq 0x8(%rsi), %r15
movq 0x8(%rdx), %r8
cmpq %r8, %r15
movq %r15, -0xe8(%rbp)
movq %r8, -0xe0(%rbp)
jge 0x1aa9b
xorl $0x1, %ecx
movl %ecx, -0x2c(%rbp)
movq %r15, %r10
movq %r8, %r15
movq %rax, %r8
movq %rsi, %r9
jmp 0x1aaad
movq %r14, %rdi
movq %rdx, %rsi
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1b9c0
cmpq %rsi, %r14
je 0x1aebe
movq %r14, %rdi
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x19a48
negl %edi
leaq -0x118(%rbp), %rax
movl %edi, 0x4(%rax)
movq 0x8(%rdx), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rdx), %rcx
movq %rcx, 0x10(%rax)
movq %r14, %rdi
movq %rax, %rdx
callq 0x1a380
jmp 0x1aebe
movl %ecx, -0x2c(%rbp)
movq %r8, %r10
movq %rdi, %r8
movq %rax, %rdi
movq %rdx, %r9
movq %rsi, %rdx
movq %rdi, %rcx
negq %rcx
movq %rdi, %rbx
cmovnsq %rcx, %rbx
movq %r8, %rsi
negq %rsi
movq %r8, %rax
cmovnsq %rsi, %rax
movq 0x10(%rdx), %r13
movq 0x10(%r9), %r12
movq 0x10(%r14), %r9
movl (%r14), %edx
incl %edx
movslq %edx, %r11
movq %r15, %rdx
subq %r10, %rdx
movq %rdx, -0x90(%rbp)
cmpq $0x1, %rdx
movq %r9, -0x50(%rbp)
movq %r15, -0xc8(%rbp)
jg 0x1ab7f
movq -0xe0(%rbp), %rdx
cmpq -0xe8(%rbp), %rdx
jne 0x1ab87
movq %r10, -0x38(%rbp)
movq %r11, -0x40(%rbp)
cmpq %rsi, %r8
movq %rsi, %rax
cmovgq %r8, %rax
leaq (%r12,%rax,8), %rdx
addq $-0x8, %rdx
cmpq %rcx, %rdi
movq %rcx, %r9
cmovgq %rdi, %r9
leaq -0x8(,%r9,8), %r10
addq %r13, %r10
xorl %r11d, %r11d
movq %r11, %r15
movq (%r10,%r11,8), %r11
movq (%rdx,%r15,8), %rbx
cmpq %rbx, %r11
jne 0x1addd
leaq (%r9,%r15), %r11
cmpq $0x1, %r11
je 0x1ae14
leaq -0x1(%r15), %r11
movq %rax, %rbx
addq %r11, %rbx
jne 0x1ab3f
cmpq %rcx, %rdi
cmovgq %rdi, %rcx
addq %r11, %rcx
movq %r13, %r12
jmp 0x1ae26
movq %r12, %rsi
movq %r13, %r8
jmp 0x1aba1
movq %r13, %r8
cmpq $0x1, -0x8(%r13,%rbx,8)
jne 0x1ab9e
cmpq $-0x1, -0x8(%r12,%rax,8)
je 0x1aecd
movq %r12, %rsi
xorl %ecx, %ecx
movq %rbx, %rdx
subq %r11, %rdx
movq %r11, %r12
movq %rbx, -0xd8(%rbp)
cmovlq %rbx, %r12
cmovleq %rcx, %rdx
movq -0x90(%rbp), %rdi
leaq (%rax,%rdi), %r13
movq %r11, %r9
subq %rdi, %r11
movq %r13, %rbx
subq %r9, %rbx
cmovleq %rax, %r11
movq %r11, -0xb0(%rbp)
cmovleq %rcx, %rbx
leaq (%r8,%rdx,8), %rcx
cmpq %rdi, %r9
jle 0x1acd1
movq %rsi, -0x38(%rbp)
leaq (,%r9,8), %rsi
cmpq $0x7f00, %rsi           # imm = 0x7F00
movq %r15, -0x68(%rbp)
movq %rsi, -0xa8(%rbp)
ja 0x1b412
movq %rsp, %rdi
leaq 0xf(%rsi), %rax
andq $-0x10, %rax
subq %rax, %rdi
movq %rdi, %rsp
cmpq $0x0, -0xb0(%rbp)
movq -0x38(%rbp), %rax
je 0x1acb9
leaq (%rax,%rbx,8), %rsi
leaq (,%r12,8), %rax
cmpq %r9, %r13
movq %r9, %rbx
movq %r13, -0xd0(%rbp)
cmovlq %r13, %rbx
leaq (,%rbx,8), %rdx
movq %rax, -0xc0(%rbp)
movq %rdx, -0xb8(%rbp)
subq %rdx, %rax
movq %rax, -0x40(%rbp)
leaq (%r10,%rbx), %r11
subq %r12, %r11
movq -0xc8(%rbp), %rax
subq %rax, %r11
addq %r12, %rax
subq %r10, %rax
subq %rbx, %rax
movq %r12, %rdx
subq %rbx, %rdx
xorl %r13d, %r13d
movq %rax, -0x100(%rbp)
xorl %r15d, %r15d
cmpq $0x0, (%rsi,%r15,8)
jne 0x1acee
incq %r15
addq $-0x8, %r13
incq %rax
incq %rdx
cmpq %r15, -0xb0(%rbp)
jne 0x1ac9c
movq -0x50(%rbp), %rdi
movq %rcx, %rsi
movq %r12, %rdx
callq 0x2f106
movq -0x68(%rbp), %r15
jmp 0x1ae81
movq -0x50(%rbp), %rdi
cmpq %rcx, %rdi
je 0x1ae81
movq %rcx, %rsi
movq %r12, %rdx
callq 0x2f106
jmp 0x1ae81
movq %rbx, -0x88(%rbp)
movq %r14, -0x58(%rbp)
subq %r13, %rsi
movq -0xb0(%rbp), %rbx
subq %r15, %rbx
movq %rbx, -0x98(%rbp)
movq %r12, -0x70(%rbp)
testq %r12, %r12
je 0x1adb7
movq %rcx, -0x60(%rbp)
leaq (,%r10,8), %rcx
movq %r11, -0xf0(%rbp)
movq -0xb8(%rbp), %r11
leaq (%r11,%r10,8), %r12
movq -0xc0(%rbp), %r14
subq %r14, %r12
movq %r8, -0xa0(%rbp)
movq %rsi, -0x78(%rbp)
movq -0xc8(%rbp), %rsi
leaq (,%rsi,8), %r8
movq %r8, -0xf8(%rbp)
subq %r8, %r12
addq %r13, %r12
leaq (%r14,%rsi,8), %r14
movq -0x78(%rbp), %rsi
subq %rcx, %r14
movq -0x60(%rbp), %rcx
subq %r11, %r14
subq %r13, %r14
subq %r13, -0x40(%rbp)
movq -0x88(%rbp), %r8
subq -0x70(%rbp), %r8
xorl %r11d, %r11d
xorl %ebx, %ebx
cmpq $0x0, (%rcx,%rbx,8)
jne 0x1af96
incq %rbx
addq $0x8, %r11
addq $-0x8, -0x40(%rbp)
addq $-0x8, %r14
addq $0x8, %r12
cmpq %rbx, -0x70(%rbp)
jne 0x1ad92
movq -0x50(%rbp), %rdi
movq -0x98(%rbp), %r12
movq %r12, %rdx
callq 0x2f106
movl -0x2c(%rbp), %ebx
xorl $0x1, %ebx
movq -0x58(%rbp), %r14
movq -0x68(%rbp), %r15
jmp 0x1ae84
cmpq %rsi, %r8
cmovgq %r8, %rsi
addq %r15, %rsi
cmpq %rcx, %rdi
cmovgq %rdi, %rcx
addq %r15, %rcx
cmpq %rbx, %r11
movq -0x38(%rbp), %r10
jae 0x1aee7
xorl $0x1, -0x2c(%rbp)
movq %rcx, %rax
movq -0x40(%rbp), %r11
movq %rsi, %rbx
movq %r13, %rsi
jmp 0x1aef7
xorl $0x1, -0x2c(%rbp)
cmpq %rsi, %r8
cmovgq %r8, %rsi
leaq (%rsi,%r15), %rcx
decq %rcx
movq -0x38(%rbp), %rax
leaq (%rax,%r15), %rbx
decq %rbx
testq %rcx, %rcx
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rdx
je 0x1ae5d
subq %rcx, %rax
addq %r15, %rax
decq %rax
cmpq $0x0, -0x8(%r12,%rcx,8)
jne 0x1ae5f
decq %rcx
decq %rbx
testq %rcx, %rcx
jne 0x1ae47
movq %rax, %rbx
xorl %ecx, %ecx
xorl %eax, %eax
movq %rcx, %rsi
subq %rdx, %rsi
cmovlq %rcx, %rdx
cmovgq %rsi, %rax
leaq (%r12,%rax,8), %rsi
movq %rdx, %r13
callq 0x2f106
movq %rbx, %r15
movq %r13, %r12
movl -0x2c(%rbp), %ebx
movq -0x118(%rbp), %rdi
testq %rdi, %rdi
jne 0x1b408
testq %r12, %r12
je 0x1aeae
movl %r12d, %eax
negl %eax
testl %ebx, %ebx
cmovel %r12d, %eax
movl %eax, 0x4(%r14)
movq %r15, 0x8(%r14)
jmp 0x1aebe
movl $0x0, 0x4(%r14)
movq $0x0, 0x8(%r14)
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x2, %rbx
jb 0x1aedf
cmpq $0x0, -0x10(%r8,%rbx,8)
jne 0x1ab9e
movq %r12, %rsi
movq %r8, %r12
jmp 0x1af10
movq %rsi, %rax
movq %rcx, %rbx
movq %r12, %rsi
movq %r13, %r12
movq -0x40(%rbp), %r11
addq %r10, %r15
movq -0x8(%rsi,%rax,8), %rcx
incq %rcx
cmpq %rcx, -0x8(%r12,%rbx,8)
jne 0x1af8e
decq %rax
movq %rsi, -0x38(%rbp)
leaq (%rsi,%rax,8), %rdi
addq $-0x8, %rdi
leaq (,%r11,8), %r9
leaq (%r12,%rbx,8), %rdx
xorl %r10d, %r10d
movq %r10, %r8
movq %r9, %rsi
movq %rax, %rcx
addq %r10, %rcx
je 0x1af5c
leaq (%rbx,%r8), %r9
decq %r9
testq %r9, %r9
je 0x1af5c
cmpq $0x0, -0x10(%rdx,%r8,8)
jne 0x1af5c
leaq -0x1(%r8), %r10
leaq 0x8(%rsi), %r9
cmpq $-0x1, (%rdi,%r8,8)
je 0x1af2b
addq %r8, %rbx
movq %rbx, %rdi
leaq (%r15,%r8), %r13
decq %r13
decq %rbx
movq %r14, -0x58(%rbp)
je 0x1b057
cmpq %r11, %rdi
jle 0x1b12f
leaq -0x1(%r11), %rbx
subq %rsi, %rdx
movq %rdx, %r12
jmp 0x1b12f
movq %r12, %r8
jmp 0x1aba1
movq %rcx, %rsi
movq -0x70(%rbp), %rcx
subq %rbx, %rcx
addq %r11, %rsi
movq %rsi, -0x60(%rbp)
movq %rcx, -0x48(%rbp)
cmpq -0x90(%rbp), %rcx
movq %rdi, -0x80(%rbp)
jle 0x1b08d
movq -0xe0(%rbp), %rcx
cmpq -0xe8(%rbp), %rcx
movq -0x98(%rbp), %rcx
jne 0x1b243
movq %r9, -0x40(%rbp)
cmpq %rcx, -0x48(%rbp)
jge 0x1b2f4
movq -0xf0(%rbp), %r12
movq %r12, %rdx
subq %r15, %rdx
addq %rbx, %rdx
movq %rdi, %rbx
movq -0x78(%rbp), %rsi
movq -0x38(%rbp), %r15
movq %r11, %r13
callq 0x1bd78
movq %rbx, %rdi
subq %r14, %rdi
movq -0x40(%rbp), %rax
movq -0xd0(%rbp), %rcx
cmpq %rax, %rcx
cmovgq %rcx, %rax
shlq $0x3, %r12
leaq (%r12,%rax,8), %rax
subq -0xa8(%rbp), %rax
addq %r13, %r15
addq %rax, %r15
movl $0x1, %r8d
movq -0x60(%rbp), %rsi
movq %r15, %rdx
movq -0x48(%rbp), %rcx
callq 0x1bc80
movq -0x98(%rbp), %rdx
jmp 0x1b117
testq %rcx, %rcx
je 0x1b12b
notq %rax
addq %rax, %r15
xorl %ebx, %ebx
movq -0x38(%rbp), %rdx
cmpq $-0x1, -0x8(%rdx,%rcx,8)
jne 0x1b133
decq %rcx
decq %r13
testq %rcx, %rcx
jne 0x1b06c
movq %r15, %r13
xorl %ecx, %ecx
jmp 0x1b133
movq %r11, -0x90(%rbp)
movq %r10, -0x38(%rbp)
movq %r8, %r14
subq %r15, %r14
addq %rbx, %r14
movq %rdi, %rbx
movq -0x78(%rbp), %rsi
movq -0x98(%rbp), %r12
movq %r12, %rdx
callq 0x1bd78
cmpq %r14, %r12
jge 0x1b0f1
movq -0xb0(%rbp), %rax
leaq (%rbx,%rax,8), %rdi
addq %r13, %rdi
movq -0x38(%rbp), %r14
addq -0x70(%rbp), %r14
shlq $0x3, %r14
movq -0xf8(%rbp), %rdx
subq %r14, %rdx
addq -0x90(%rbp), %rdx
movl $0xff, %esi
callq 0x6170
movq -0x88(%rbp), %r14
subq %r15, %r14
movq %rbx, %rdi
subq -0x40(%rbp), %rdi
movl $0x1, %ecx
movq -0x60(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x1bbe4
movq %r14, %rdx
movq -0x58(%rbp), %r14
movl -0x2c(%rbp), %ebx
movq -0x50(%rbp), %rdi
movq -0x68(%rbp), %r15
jmp 0x1b3cc
xorl %ecx, %ecx
xorl %ebx, %ebx
movq -0x38(%rbp), %rdx
leaq -0x1(%r11), %r8
movq %rcx, %rax
subq %r8, %rax
xorl %r14d, %r14d
cmpq %r11, %rcx
cmovlq %rcx, %r8
cmovgeq %rax, %r14
shlq $0x3, %r11
cmpq $0x7f00, %r11           # imm = 0x7F00
ja 0x1b450
movq %rsp, %rdi
addq $0xf, %r11
andq $-0x10, %r11
subq %r11, %rdi
movq %rdi, %rsp
testq %r8, %r8
je 0x1b1b8
leaq (%rdx,%r14,8), %r14
testq %rbx, %rbx
movq %rdi, -0x80(%rbp)
movq %r8, -0x48(%rbp)
je 0x1b1d0
movq %rbx, %r15
subq %r8, %r15
jge 0x1b1dd
movq %r8, %r15
subq %rbx, %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x1bd78
movq -0x80(%rbp), %rcx
leaq (%rcx,%r15,8), %rdi
leaq (%r14,%r15,8), %rdx
movq %r12, %rsi
movq %rbx, %rcx
movq %rax, %r8
callq 0x1bc80
jmp 0x1b204
movq %rdi, %r15
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2f106
movq -0x58(%rbp), %r14
movq -0x50(%rbp), %rdi
jmp 0x1b224
movq %r14, %rsi
movq %r8, %rdx
callq 0x1bd78
jmp 0x1b204
movq %r12, %rsi
movq %r15, %rdx
callq 0x2f106
movq -0x80(%rbp), %rax
leaq (%rax,%r15,8), %rdi
leaq (%r12,%r15,8), %rsi
movq %r14, %rdx
movq -0x48(%rbp), %rcx
callq 0x1bca0
movq %rbx, -0x48(%rbp)
testq %rax, %rax
movq -0x58(%rbp), %r14
movq -0x50(%rbp), %rdi
je 0x1b21c
movq %r13, %r15
movl -0x2c(%rbp), %ebx
jmp 0x1b3c8
movq -0x48(%rbp), %rbx
movq -0x80(%rbp), %r15
movq $0x1, (%r15,%rbx,8)
incq %rbx
incq %r13
movq %r15, %rsi
movq %r13, %r15
movq %rbx, %rdx
movl -0x2c(%rbp), %ebx
jmp 0x1b3fb
movq %r9, %r14
movq -0x88(%rbp), %rax
subq %r15, %rax
movq %rax, -0x88(%rbp)
cmpq -0x48(%rbp), %rax
jle 0x1b356
subq %r15, %r8
addq %rbx, %r8
movq %rdi, %r13
movq -0x78(%rbp), %rsi
movq %r8, %rdx
movq -0x38(%rbp), %r15
movq %r10, %r12
movq %r11, -0x90(%rbp)
callq 0x1bd78
subq -0x40(%rbp), %r13
movq -0xd0(%rbp), %rax
cmpq %r14, %rax
cmovgq %rax, %r14
movq -0xb8(%rbp), %rax
leaq (%rax,%r14,8), %rax
subq -0xc0(%rbp), %rax
subq -0xa8(%rbp), %rax
addq -0x90(%rbp), %r15
addq %rax, %r15
addq -0x70(%rbp), %r12
subq -0xc8(%rbp), %r12
subq %rbx, %r12
movq %r13, %rdi
movq -0x60(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x1bb58
subq $0x1, (%r13)
leaq 0x8(%r13), %r13
jb 0x1b2dd
movq -0x88(%rbp), %rdx
jmp 0x1b117
subq %rbx, %rax
movq %rdi, %rbx
movq -0xa0(%rbp), %r14
movq -0x60(%rbp), %rsi
movq %rax, %rdx
callq 0x2f106
movq %rbx, %rdi
subq %r12, %rdi
movq -0x40(%rbp), %rax
movq -0xd8(%rbp), %rcx
cmpq %rax, %rcx
cmovgq %rcx, %rax
movq -0x100(%rbp), %rcx
shlq $0x3, %rcx
leaq (%rcx,%rax,8), %rax
subq -0xa8(%rbp), %rax
addq %rax, %r14
subq %r13, %r14
movq %r14, %rsi
movq -0x78(%rbp), %rdx
movq -0x98(%rbp), %rcx
callq 0x1bca0
jmp 0x1b3b9
subq %rbx, %rdx
movq %rdi, %rbx
movq -0xa0(%rbp), %r15
movq %rcx, %r12
movq -0x60(%rbp), %rsi
callq 0x2f106
movq -0x40(%rbp), %rdi
addq %rbx, %rdi
movq -0xd8(%rbp), %rax
cmpq %r14, %rax
cmovgq %rax, %r14
movq -0xc0(%rbp), %rax
leaq (%rax,%r14,8), %rax
subq -0xb8(%rbp), %rax
subq -0xa8(%rbp), %rax
addq %rax, %r15
subq %r13, %r15
movq %r15, %rsi
movq -0x88(%rbp), %rdx
movq -0x78(%rbp), %rcx
movq %r12, %r8
callq 0x1bb58
movq -0x58(%rbp), %r14
movl -0x2c(%rbp), %ebx
movq -0x50(%rbp), %rdi
movq -0x68(%rbp), %r15
movq -0x48(%rbp), %rdx
testq %rdx, %rdx
je 0x1b3f5
movq %r15, %rax
subq %rdx, %rax
movq -0x80(%rbp), %rsi
cmpq $0x0, -0x8(%rsi,%rdx,8)
jne 0x1b3fb
decq %rdx
decq %r15
testq %rdx, %rdx
jne 0x1b3db
movq %rax, %r15
xorl %edx, %edx
jmp 0x1b3fb
xorl %edx, %edx
movq -0x80(%rbp), %rsi
movq %rdx, %r12
callq 0x2f106
jmp 0x1ae84
callq 0x2fde3
jmp 0x1ae94
leaq -0x118(%rbp), %rdi
movq %r8, -0xa0(%rbp)
movq %r9, -0x40(%rbp)
movq %r10, %r15
movq %r12, -0x70(%rbp)
movq %rcx, %r12
callq 0x2fdb0
movq %r12, %rcx
movq -0x70(%rbp), %r12
movq -0xa0(%rbp), %r8
movq %r15, %r10
movq -0x40(%rbp), %r9
movq %rax, %rdi
jmp 0x1ac23
leaq -0x118(%rbp), %rdi
movq %r11, %rsi
movq %r8, %r15
callq 0x2fdb0
movq %r15, %r8
movq -0x38(%rbp), %rdx
movq %rax, %rdi
jmp 0x1b16d
nopl (%rax)