// File: /workspace/github_cpp_makefile_star2_O1/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 $0xe8, %rsp
movslq 0x4(%rsi), %rax
testq %rax, %rax
je 0x1ae8a
movslq 0x4(%rdx), %r13
testl %r13d, %r13d
je 0x1aea0
movq %r13, %rcx
xorq %rax, %rcx
js 0x1aebc
movq $0x0, -0x108(%rbp)
movl %eax, %r8d
shrl $0x1f, %r8d
movq 0x8(%rsi), %rcx
cmpq 0x8(%rdx), %rcx
jge 0x1aee7
xorl $0x1, %r8d
movl %r8d, -0x2c(%rbp)
movq %rax, %r14
movq %rsi, %rcx
jmp 0x1aef7
movq %rdx, %rsi
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1bee4
cmpq %rsi, %rdi
je 0x1b360
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x19e00
negl %r13d
leaq -0x108(%rbp), %rax
movl %r13d, 0x4(%rax)
movq 0x8(%rdx), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rdx), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdx
callq 0x1a7ec
jmp 0x1b360
movl %r8d, -0x2c(%rbp)
movq %r13, %r14
movq %rax, %r13
movq %rdx, %rcx
movq %rsi, %rdx
movq %r13, %rsi
negq %rsi
movq %r13, %r15
cmovnsq %rsi, %r15
movq %r14, %r9
negq %r9
movq %r14, %rax
cmovnsq %r9, %rax
movq 0x8(%rdx), %rbx
movq 0x10(%rdx), %r12
movq 0x8(%rcx), %rdx
movq 0x10(%rcx), %r8
movq 0x10(%rdi), %r10
movq %rdi, -0x40(%rbp)
movl (%rdi), %ecx
incl %ecx
movslq %ecx, %r11
movq %rbx, %rdi
subq %rdx, %rdi
cmpq $0x1, %rdi
movq %rdx, -0xa0(%rbp)
movq %rbx, -0x80(%rbp)
jg 0x1afbf
cmpq %rdx, %rbx
jne 0x1b129
movq %r11, -0x60(%rbp)
movq %r10, -0x38(%rbp)
cmpq %r9, %r14
movq %r9, %rax
cmovgq %r14, %rax
leaq (%r8,%rax,8), %rdx
addq $-0x8, %rdx
cmpq %rsi, %r13
movq %rsi, %r10
cmovgq %r13, %r10
leaq (%r12,%r10,8), %r11
addq $-0x8, %r11
xorl %ebx, %ebx
movq %rbx, %rcx
movq (%r11,%rbx,8), %rbx
movq (%rdx,%rcx,8), %r15
cmpq %r15, %rbx
jne 0x1b26c
leaq (%r10,%rcx), %rbx
cmpq $0x1, %rbx
je 0x1b2aa
leaq -0x1(%rcx), %rbx
movq %rax, %r15
addq %rbx, %r15
jne 0x1af7e
cmpq %rsi, %r13
cmovgq %r13, %rsi
addq %rbx, %rsi
movl -0x2c(%rbp), %r13d
jmp 0x1b2c3
movq %r15, -0x78(%rbp)
movq %rbx, %r15
movq %r8, %r14
movq %r12, %r9
movl -0x2c(%rbp), %r13d
xorl %ecx, %ecx
movq -0x78(%rbp), %rsi
movq %rsi, %rdx
subq %r11, %rdx
movq %r11, %r8
cmovlq %rsi, %r8
movq %r8, -0x48(%rbp)
cmovleq %rcx, %rdx
leaq (%rax,%rdi), %r12
movq %r11, %rsi
subq %rdi, %rsi
movq %r12, %rbx
subq %r11, %rbx
cmovleq %rax, %rsi
movq %rsi, -0x60(%rbp)
cmovleq %rcx, %rbx
leaq (%r9,%rdx,8), %r8
cmpq %rdi, %r11
jle 0x1b10c
movq %rdi, -0xf0(%rbp)
leaq (,%r11,8), %rsi
cmpq $0x7f00, %rsi           # imm = 0x7F00
movl %r13d, -0x2c(%rbp)
movq %r14, -0x68(%rbp)
movq %rsi, -0xc0(%rbp)
ja 0x1b915
movq %rsp, %rdi
leaq 0xf(%rsi), %rax
andq $-0x10, %rax
subq %rax, %rdi
movq %rdi, %rsp
movq -0x48(%rbp), %rcx
cmpq $0x0, -0x60(%rbp)
je 0x1b0f5
movq -0x68(%rbp), %rax
leaq (%rax,%rbx,8), %rbx
leaq (,%rcx,8), %r13
cmpq %r11, %r12
movq %r11, %rsi
movq %r12, -0xd8(%rbp)
cmovlq %r12, %rsi
leaq (,%rsi,8), %rax
movq %r13, -0xc8(%rbp)
movq %rax, -0xb8(%rbp)
subq %rax, %r13
movq -0xa0(%rbp), %rcx
leaq (%rcx,%rsi), %rdx
movq -0x80(%rbp), %rax
subq %rax, %rdx
subq -0x48(%rbp), %rdx
movq %rdx, -0x70(%rbp)
movq -0x48(%rbp), %rdx
addq %rdx, %rax
subq %rcx, %rax
movq -0x48(%rbp), %rcx
subq %rsi, %rax
movq %rcx, %rdx
subq %rsi, %rdx
xorl %r12d, %r12d
movq %rax, -0xe8(%rbp)
xorl %r14d, %r14d
cmpq $0x0, (%rbx,%r14,8)
jne 0x1b162
incq %r14
addq $-0x8, %r12
incq %rax
incq %rdx
cmpq %r14, -0x60(%rbp)
jne 0x1b0d7
movq %r10, %rdi
movq %r8, %rsi
movq %rcx, %rdx
callq 0x2f4c6
movl -0x2c(%rbp), %r13d
jmp 0x1b31f
cmpq %r8, %r10
je 0x1b31f
movq %r10, %rdi
movq %r8, %rsi
movq -0x48(%rbp), %rdx
callq 0x2f4c6
jmp 0x1b31f
movq %r12, %r9
cmpq $0x1, -0x8(%r12,%r15,8)
jne 0x1b153
cmpq $-0x1, -0x8(%r8,%rax,8)
movl -0x2c(%rbp), %r13d
je 0x1b36f
movq %r15, -0x78(%rbp)
movq %rbx, %r15
movq %r8, %r14
jmp 0x1afd0
movq %r15, -0x78(%rbp)
movq %rbx, %r15
movq %r8, %r14
jmp 0x1afcc
movq %r13, -0xa8(%rbp)
movq %r15, -0x58(%rbp)
subq %r12, %rbx
movq %rbx, -0x88(%rbp)
movq -0x60(%rbp), %rbx
subq %r14, %rbx
movq %rbx, -0x90(%rbp)
testq %rcx, %rcx
je 0x1b23a
movq %rsi, -0xb0(%rbp)
movq -0xa0(%rbp), %rsi
leaq (,%rsi,8), %rcx
movq -0xb8(%rbp), %rbx
leaq (%rbx,%rsi,8), %r13
movq -0x80(%rbp), %rsi
leaq (,%rsi,8), %rbx
movq %rbx, -0xe0(%rbp)
subq %rbx, %r13
movq -0xc8(%rbp), %rbx
subq %rbx, %r13
addq %r12, %r13
leaq (%rbx,%rsi,8), %r15
movq -0xb0(%rbp), %rsi
subq %rcx, %r15
movq -0x48(%rbp), %rcx
subq -0xb8(%rbp), %r15
subq %r12, %r15
subq %r12, -0xa8(%rbp)
movq %rsi, %rbx
subq %rcx, %rbx
movq %rbx, -0xd0(%rbp)
movq $0x0, -0x98(%rbp)
xorl %ebx, %ebx
cmpq $0x0, (%r8,%rbx,8)
jne 0x1b44e
incq %rbx
addq $0x8, -0x98(%rbp)
addq $-0x8, -0xa8(%rbp)
addq $-0x8, %r15
addq $0x8, %r13
cmpq %rbx, %rcx
jne 0x1b20f
movq %r10, %rdi
movq -0x88(%rbp), %rsi
movq -0x90(%rbp), %rbx
movq %rbx, %rdx
callq 0x2f4c6
movl -0x2c(%rbp), %r13d
xorl $0x1, %r13d
movq %rbx, -0x48(%rbp)
movq -0x40(%rbp), %r14
movq -0x58(%rbp), %r15
jmp 0x1b323
cmpq %r9, %r14
cmovgq %r14, %r9
addq %rcx, %r9
cmpq %rsi, %r13
cmovgq %r13, %rsi
addq %rcx, %rsi
cmpq %r15, %rbx
movq -0x60(%rbp), %r11
jae 0x1b38d
xorl $0x1, -0x2c(%rbp)
movq %rsi, %rax
movq %r12, %r14
movq -0x38(%rbp), %r10
movq %r9, %r15
movq -0x80(%rbp), %rdx
movq %r8, %r9
jmp 0x1b3a1
movl -0x2c(%rbp), %r13d
xorl $0x1, %r13d
cmpq %r9, %r14
cmovgq %r14, %r9
leaq (%r9,%rcx), %rsi
decq %rsi
movq %r8, %r12
movq -0x80(%rbp), %r8
leaq (%r8,%rcx), %rax
decq %rax
testq %rsi, %rsi
movq -0x38(%rbp), %rdi
movq -0x60(%rbp), %rdx
je 0x1b2fc
subq %rsi, %r8
leaq (%r8,%rcx), %r15
decq %r15
cmpq $0x0, -0x8(%r12,%rsi,8)
jne 0x1b2fc
decq %rsi
decq %rax
testq %rsi, %rsi
jne 0x1b2e5
xorl %esi, %esi
jmp 0x1b2ff
movq %rax, %r15
xorl %eax, %eax
movq %rsi, %rcx
subq %rdx, %rcx
cmovlq %rsi, %rdx
cmovgq %rcx, %rax
leaq (%r12,%rax,8), %rsi
movq %rdx, %rbx
callq 0x2f4c6
movq %rbx, -0x48(%rbp)
movq -0x40(%rbp), %r14
movq -0x108(%rbp), %rdi
testq %rdi, %rdi
jne 0x1b90b
movq -0x48(%rbp), %rcx
testq %rcx, %rcx
je 0x1b350
movl %ecx, %eax
negl %eax
testl %r13d, %r13d
cmovel %ecx, %eax
movl %eax, 0x4(%r14)
movq %r15, 0x8(%r14)
jmp 0x1b360
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, %r15
jb 0x1b381
cmpq $0x0, -0x10(%r9,%r15,8)
jne 0x1b144
movq %r10, -0x38(%rbp)
movq %rbx, %rcx
movq %r8, %r14
jmp 0x1b3be
movq %r9, %rax
movq %rsi, %r15
movq %r8, %r14
movq %r12, %r9
movq -0x38(%rbp), %r10
movq -0x80(%rbp), %rdx
addq %rdx, %rcx
movq -0x8(%r14,%rax,8), %rdx
incq %rdx
cmpq %rdx, -0x8(%r9,%r15,8)
jne 0x1b442
decq %rax
movl -0x2c(%rbp), %r13d
movq %r14, -0x68(%rbp)
leaq (%r14,%rax,8), %r8
addq $-0x8, %r8
movq %r11, %rsi
leaq (,%r11,8), %r10
movq %r9, %r12
leaq (%r9,%r15,8), %rbx
xorl %r11d, %r11d
movq %r11, %r9
movq %r10, %rdi
movq %rax, %rdx
addq %r11, %rdx
je 0x1b410
leaq (%r15,%r9), %r10
decq %r10
testq %r10, %r10
je 0x1b410
cmpq $0x0, -0x10(%rbx,%r9,8)
jne 0x1b410
leaq -0x1(%r9), %r11
leaq 0x8(%rdi), %r10
cmpq $-0x1, (%r8,%r9,8)
je 0x1b3df
addq %r9, %r15
movq %r15, %r10
leaq (%rcx,%r9), %r8
decq %r8
decq %r10
je 0x1b512
cmpq %rsi, %r15
movq %r8, -0x58(%rbp)
jle 0x1b5f2
leaq -0x1(%rsi), %r10
subq %rdi, %rbx
movq %rbx, %r12
jmp 0x1b5f2
movq %r15, -0x78(%rbp)
movq %rcx, %r15
jmp 0x1afcc
subq %rbx, %rcx
addq -0x98(%rbp), %r8
movq %rcx, -0x50(%rbp)
cmpq -0xf0(%rbp), %rcx
movq %r10, -0x38(%rbp)
jle 0x1b547
movq -0xa0(%rbp), %rcx
cmpq %rcx, -0x80(%rbp)
jne 0x1b728
movq %r11, -0x60(%rbp)
movq -0x90(%rbp), %rcx
cmpq %rcx, -0x50(%rbp)
jge 0x1b7f8
movq -0x70(%rbp), %r13
movq %r13, %rdx
subq %r14, %rdx
addq %rbx, %rdx
movq -0x88(%rbp), %rsi
movq %rdi, %rbx
movq -0x68(%rbp), %r14
movq %r8, %r12
callq 0x1c298
movq %rbx, %rdi
subq %r15, %rdi
movq -0x60(%rbp), %rax
movq -0xd8(%rbp), %rcx
cmpq %rax, %rcx
cmovgq %rcx, %rax
shlq $0x3, %r13
leaq (,%rax,8), %rax
addq %r13, %rax
subq -0xc0(%rbp), %rax
addq -0x98(%rbp), %r14
addq %rax, %r14
movl $0x1, %r8d
movq %r12, %rsi
movq %r14, %rdx
movq -0x50(%rbp), %rcx
callq 0x1c1a0
movq %rbx, %rsi
movq -0x90(%rbp), %rdx
jmp 0x1b7da
testq %rdx, %rdx
je 0x1b5ec
notq %rax
addq %rax, %rcx
movq -0x68(%rbp), %r9
cmpq $-0x1, -0x8(%r9,%rdx,8)
jne 0x1b7ef
decq %rdx
decq %r8
testq %rdx, %rdx
jne 0x1b525
movq %rcx, -0x58(%rbp)
xorl %edx, %edx
jmp 0x1b5f6
movq %r8, -0x70(%rbp)
movq -0xd0(%rbp), %r13
subq %r14, %r13
addq %rbx, %r13
movq -0x88(%rbp), %rsi
movq -0x90(%rbp), %r15
movq %r15, %rdx
movq %rdi, %rbx
callq 0x1c298
cmpq %r13, %r15
jge 0x1b5ab
movq -0x60(%rbp), %rax
leaq (%rbx,%rax,8), %rdi
addq %r12, %rdi
movq -0xa0(%rbp), %rax
addq -0x48(%rbp), %rax
shlq $0x3, %rax
movq -0xe0(%rbp), %rdx
subq %rax, %rdx
addq -0x98(%rbp), %rdx
movl $0xff, %esi
callq 0x6170
movq -0xb0(%rbp), %r12
subq %r14, %r12
movq %rbx, %rdi
subq -0xa8(%rbp), %rdi
movl $0x1, %ecx
movq -0x70(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x1c104
movq %r12, %rdx
movq -0x40(%rbp), %r8
movl -0x2c(%rbp), %r13d
movq -0x38(%rbp), %rdi
movq -0x58(%rbp), %r15
movq %rbx, %rsi
jmp 0x1b8ca
movq %r8, -0x58(%rbp)
xorl %edx, %edx
movq -0x68(%rbp), %r9
leaq -0x1(%rsi), %rbx
movq %rdx, %rax
subq %rbx, %rax
xorl %r15d, %r15d
cmpq %rsi, %rdx
cmovlq %rdx, %rbx
cmovgeq %rax, %r15
shlq $0x3, %rsi
cmpq $0x7f00, %rsi           # imm = 0x7F00
ja 0x1b945
movq %rsp, %rdi
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %rdi
movq %rdi, %rsp
testq %rbx, %rbx
je 0x1b682
leaq (%r9,%r15,8), %r15
testq %r10, %r10
movq %rdi, -0x60(%rbp)
je 0x1b6a7
movl %r13d, -0x2c(%rbp)
movq %r10, %r13
subq %rbx, %r13
movq %r10, -0x50(%rbp)
jge 0x1b6bb
movq %rbx, %r13
subq %r10, %r13
movq %r15, %rsi
movq %r13, %rdx
movq %rdi, %r14
callq 0x1c298
leaq (%r14,%r13,8), %rdi
leaq (%r15,%r13,8), %rdx
movq %r12, %rsi
movq -0x50(%rbp), %rcx
movq %rax, %r8
callq 0x1c1a0
movq %rbx, %rdx
jmp 0x1b6e0
movq %r12, %rsi
movq %r10, %rdx
movq %rdi, %rbx
movq %r10, %r14
callq 0x2f4c6
movq -0x40(%rbp), %r8
movq %r14, %rdx
movq %rbx, %rsi
movq -0x38(%rbp), %rdi
movq -0x58(%rbp), %r15
jmp 0x1b6fe
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1c298
movq -0x40(%rbp), %r8
movq %rbx, %rdx
jmp 0x1b6e8
movq %r12, %rsi
movq %r13, %rdx
movq %rdi, %r14
callq 0x2f4c6
leaq (%r14,%r13,8), %rdi
leaq (%r12,%r13,8), %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x1c1c0
movq -0x50(%rbp), %rdx
movq -0x40(%rbp), %r8
movl -0x2c(%rbp), %r13d
movl $0x2e, %ecx
testq %rax, %rax
movq -0x38(%rbp), %rdi
movq -0x58(%rbp), %r15
movq -0x60(%rbp), %rsi
jne 0x1b711
movq $0x1, (%rsi,%rdx,8)
incq %rdx
incq %r15
movl $0x23, %ecx
cmpl $0x23, %ecx
je 0x1b8f0
cmpl $0x2e, %ecx
je 0x1b8ca
jmp 0x1b360
movq %r11, %r13
subq %r14, %rsi
cmpq -0x50(%rbp), %rsi
movq %rsi, %r15
jle 0x1b855
movq -0xd0(%rbp), %rdx
subq %r14, %rdx
addq %rbx, %rdx
movq -0x88(%rbp), %rsi
movq %rdi, %r12
movq %r15, -0xb0(%rbp)
movq -0x68(%rbp), %r15
movq %r8, -0x70(%rbp)
callq 0x1c298
movq %r12, %r14
subq -0xa8(%rbp), %r14
movq -0xd8(%rbp), %rax
cmpq %r13, %rax
cmovgq %rax, %r13
movq -0xb8(%rbp), %rax
leaq (%rax,%r13,8), %rax
subq -0xc8(%rbp), %rax
subq -0xc0(%rbp), %rax
addq -0x98(%rbp), %r15
addq %rax, %r15
movq -0xa0(%rbp), %r8
addq -0x48(%rbp), %r8
subq -0x80(%rbp), %r8
subq %rbx, %r8
movq %r14, %rdi
movq -0x70(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq %r15, %rcx
callq 0x1c078
movq %r12, %rsi
subq $0x1, (%r14)
leaq 0x8(%r14), %r14
jb 0x1b7c9
movq -0xb0(%rbp), %rdx
movq -0x40(%rbp), %r8
movl -0x2c(%rbp), %r13d
movq -0x38(%rbp), %rdi
movq -0x58(%rbp), %r15
jmp 0x1b8ca
movq %r8, -0x58(%rbp)
jmp 0x1b5f6
subq %rbx, %rax
movq %r8, %rsi
movq %rax, %rdx
movq %rdi, %rbx
movq %r9, %r14
callq 0x2f4c6
movq %rbx, %rdi
subq %r13, %rdi
movq -0x60(%rbp), %rax
movq -0x78(%rbp), %rcx
cmpq %rax, %rcx
cmovgq %rcx, %rax
movq -0xe8(%rbp), %rcx
shlq $0x3, %rcx
leaq (%rcx,%rax,8), %rax
subq -0xc0(%rbp), %rax
addq %rax, %r14
subq %r12, %r14
movq %r14, %rsi
movq -0x88(%rbp), %rdx
movq -0x90(%rbp), %rcx
callq 0x1c1c0
jmp 0x1b8b3
subq %rbx, %rdx
movq %r8, %rsi
movq %rdi, %rbx
movq %r9, %r14
callq 0x2f4c6
movq -0xa8(%rbp), %rdi
addq %rbx, %rdi
movq -0x78(%rbp), %rax
cmpq %r13, %rax
cmovgq %rax, %r13
movq -0xc8(%rbp), %rax
leaq (%rax,%r13,8), %rax
subq -0xb8(%rbp), %rax
subq -0xc0(%rbp), %rax
addq %rax, %r14
subq %r12, %r14
movq %r14, %rsi
movq %r15, %rdx
movq -0x88(%rbp), %rcx
movq -0x90(%rbp), %r8
callq 0x1c078
movq %rbx, %rsi
movq -0x40(%rbp), %r8
movl -0x2c(%rbp), %r13d
movq -0x38(%rbp), %rdi
movq -0x58(%rbp), %r15
movq -0x50(%rbp), %rdx
testq %rdx, %rdx
je 0x1b8f5
movq %r15, %rax
subq %rdx, %rax
cmpq $0x0, -0x8(%rsi,%rdx,8)
jne 0x1b8f0
decq %rdx
decq %r15
testq %rdx, %rdx
jne 0x1b8d5
movq %r8, %r14
movq %rax, %r15
jmp 0x1b8f8
movq %r8, %r14
jmp 0x1b8fa
movq %r8, %r14
xorl %edx, %edx
movq %rdx, %rbx
callq 0x2f4c6
movq %rbx, -0x48(%rbp)
jmp 0x1b323
callq 0x301a3
jmp 0x1b333
leaq -0x108(%rbp), %rdi
movq %r10, -0x38(%rbp)
movq %r11, %r13
movq %r9, %r14
movq %r8, -0x70(%rbp)
callq 0x30170
movq -0x70(%rbp), %r8
movq %r14, %r9
movq %r13, %r11
movq -0x38(%rbp), %r10
movq %rax, %rdi
jmp 0x1b050
leaq -0x108(%rbp), %rdi
movq %r10, -0x50(%rbp)
callq 0x30170
movq -0x68(%rbp), %r9
movq -0x50(%rbp), %r10
movq %rax, %rdi
jmp 0x1b630
nopl (%rax)