// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/mpn/mul.c
// Function: _gmpn_mul
mp_limb_t
mpn_mul (mp_ptr prodp,
	 mp_srcptr up, mp_size_t un,
	 mp_srcptr vp, mp_size_t vn)
{
  ASSERT (un >= vn);
  ASSERT (vn >= 1);
  ASSERT (! MPN_OVERLAP_P (prodp, un+vn, up, un));
  ASSERT (! MPN_OVERLAP_P (prodp, un+vn, vp, vn));

  if (un == vn)
    {
      if (up == vp)
	mpn_sqr (prodp, up, un);
      else
	mpn_mul_n (prodp, up, vp, un);
    }
  else if (vn < MUL_TOOM22_THRESHOLD)
    { /* plain schoolbook multiplication */

      /* Unless un is very large, or else if have an applicable mpn_mul_N,
	 perform basecase multiply directly.  */
      if (un <= MUL_BASECASE_MAX_UN
#if HAVE_NATIVE_mpn_mul_2
	  || vn <= 2
#else
	  || vn == 1
#endif
	  )
	mpn_mul_basecase (prodp, up, un, vp, vn);
      else
	{
	  /* We have un >> MUL_BASECASE_MAX_UN > vn.  For better memory
	     locality, split up[] into MUL_BASECASE_MAX_UN pieces and multiply
	     these pieces with the vp[] operand.  After each such partial
	     multiplication (but the last) we copy the most significant vn
	     limbs into a temporary buffer since that part would otherwise be
	     overwritten by the next multiplication.  After the next
	     multiplication, we add it back.  This illustrates the situation:

                                                    -->vn<--
                                                      |  |<------- un ------->|
                                                         _____________________|
                                                        X                    /|
                                                      /XX__________________/  |
                                    _____________________                     |
                                   X                    /                     |
                                 /XX__________________/                       |
               _____________________                                          |
              /                    /                                          |
            /____________________/                                            |
	    ==================================================================

	    The parts marked with X are the parts whose sums are copied into
	    the temporary buffer.  */

	  mp_limb_t tp[MUL_TOOM22_THRESHOLD_LIMIT];
	  mp_limb_t cy;
	  ASSERT (MUL_TOOM22_THRESHOLD <= MUL_TOOM22_THRESHOLD_LIMIT);

	  mpn_mul_basecase (prodp, up, MUL_BASECASE_MAX_UN, vp, vn);
	  prodp += MUL_BASECASE_MAX_UN;
	  MPN_COPY (tp, prodp, vn);		/* preserve high triangle */
	  up += MUL_BASECASE_MAX_UN;
	  un -= MUL_BASECASE_MAX_UN;
	  while (un > MUL_BASECASE_MAX_UN)
	    {
	      mpn_mul_basecase (prodp, up, MUL_BASECASE_MAX_UN, vp, vn);
	      cy = mpn_add_n (prodp, prodp, tp, vn); /* add back preserved triangle */
	      mpn_incr_u (prodp + vn, cy);
	      prodp += MUL_BASECASE_MAX_UN;
	      MPN_COPY (tp, prodp, vn);		/* preserve high triangle */
	      up += MUL_BASECASE_MAX_UN;
	      un -= MUL_BASECASE_MAX_UN;
	    }
	  if (un > vn)
	    {
	      mpn_mul_basecase (prodp, up, un, vp, vn);
	    }
	  else
	    {
	      ASSERT (un > 0);
	      mpn_mul_basecase (prodp, vp, vn, up, un);
	    }
	  cy = mpn_add_n (prodp, prodp, tp, vn); /* add back preserved triangle */
	  mpn_incr_u (prodp + vn, cy);
	}
    }
  else if (BELOW_THRESHOLD (vn, MUL_TOOM33_THRESHOLD))
    {
      /* Use ToomX2 variants */
      mp_ptr scratch;
      TMP_SDECL; TMP_SMARK;

#define ITCH_TOOMX2 (9 * vn / 2 + GMP_NUMB_BITS * 2)
      scratch = TMP_SALLOC_LIMBS (ITCH_TOOMX2);
      ASSERT (mpn_toom22_mul_itch ((5*vn-1)/4, vn) <= ITCH_TOOMX2); /* 5vn/2+ */
      ASSERT (mpn_toom32_mul_itch ((7*vn-1)/4, vn) <= ITCH_TOOMX2); /* 7vn/6+ */
      ASSERT (mpn_toom42_mul_itch (3 * vn - 1, vn) <= ITCH_TOOMX2); /* 9vn/2+ */
#undef ITCH_TOOMX2

      /* FIXME: This condition (repeated in the loop below) leaves from a vn*vn
	 square to a (3vn-1)*vn rectangle.  Leaving such a rectangle is hardly
	 wise; we would get better balance by slightly moving the bound.  We
	 will sometimes end up with un < vn, like in the X3 arm below.  */
      if (un >= 3 * vn)
	{
	  mp_limb_t cy;
	  mp_ptr ws;

	  /* The maximum ws usage is for the mpn_mul result.  */
	  ws = TMP_SALLOC_LIMBS (4 * vn);

	  mpn_toom42_mul (prodp, up, 2 * vn, vp, vn, scratch);
	  un -= 2 * vn;
	  up += 2 * vn;
	  prodp += 2 * vn;

	  while (un >= 3 * vn)
	    {
	      mpn_toom42_mul (ws, up, 2 * vn, vp, vn, scratch);
	      un -= 2 * vn;
	      up += 2 * vn;
	      cy = mpn_add_n (prodp, prodp, ws, vn);
	      MPN_COPY (prodp + vn, ws + vn, 2 * vn);
	      mpn_incr_u (prodp + vn, cy);
	      prodp += 2 * vn;
	    }

	  /* vn <= un < 3vn */

	  if (4 * un < 5 * vn)
	    mpn_toom22_mul (ws, up, un, vp, vn, scratch);
	  else if (4 * un < 7 * vn)
	    mpn_toom32_mul (ws, up, un, vp, vn, scratch);
	  else
	    mpn_toom42_mul (ws, up, un, vp, vn, scratch);

	  cy = mpn_add_n (prodp, prodp, ws, vn);
	  MPN_COPY (prodp + vn, ws + vn, un);
	  mpn_incr_u (prodp + vn, cy);
	}
      else
	{
	  if (4 * un < 5 * vn)
	    mpn_toom22_mul (prodp, up, un, vp, vn, scratch);
	  else if (4 * un < 7 * vn)
	    mpn_toom32_mul (prodp, up, un, vp, vn, scratch);
	  else
	    mpn_toom42_mul (prodp, up, un, vp, vn, scratch);
	}
      TMP_SFREE;
    }
  else if (BELOW_THRESHOLD ((un + vn) >> 1, MUL_FFT_THRESHOLD) ||
	   BELOW_THRESHOLD (3 * vn, MUL_FFT_THRESHOLD))
    {
      /* Handle the largest operands that are not in the FFT range.  The 2nd
	 condition makes very unbalanced operands avoid the FFT code (except
	 perhaps as coefficient products of the Toom code.  */

      if (BELOW_THRESHOLD (vn, MUL_TOOM44_THRESHOLD) || !TOOM44_OK (un, vn))
	{
	  /* Use ToomX3 variants */
	  mp_ptr scratch;
	  TMP_DECL; TMP_MARK;

#define ITCH_TOOMX3 (4 * vn + GMP_NUMB_BITS)
	  scratch = TMP_ALLOC_LIMBS (ITCH_TOOMX3);
	  ASSERT (mpn_toom33_mul_itch ((7*vn-1)/6, vn) <= ITCH_TOOMX3); /* 7vn/2+ */
	  ASSERT (mpn_toom43_mul_itch ((3*vn-1)/2, vn) <= ITCH_TOOMX3); /* 9vn/4+ */
	  ASSERT (mpn_toom32_mul_itch ((7*vn-1)/4, vn) <= ITCH_TOOMX3); /* 7vn/6+ */
	  ASSERT (mpn_toom53_mul_itch ((11*vn-1)/6, vn) <= ITCH_TOOMX3); /* 11vn/3+ */
	  ASSERT (mpn_toom42_mul_itch ((5*vn-1)/2, vn) <= ITCH_TOOMX3); /* 15vn/4+ */
	  ASSERT (mpn_toom63_mul_itch ((5*vn-1)/2, vn) <= ITCH_TOOMX3); /* 15vn/4+ */
#undef ITCH_TOOMX3

	  if (2 * un >= 5 * vn)
	    {
	      mp_limb_t cy;
	      mp_ptr ws;

	      /* The maximum ws usage is for the mpn_mul result.  */
	      ws = TMP_ALLOC_LIMBS (7 * vn >> 1);

	      if (BELOW_THRESHOLD (vn, MUL_TOOM42_TO_TOOM63_THRESHOLD))
		mpn_toom42_mul (prodp, up, 2 * vn, vp, vn, scratch);
	      else
		mpn_toom63_mul (prodp, up, 2 * vn, vp, vn, scratch);
	      un -= 2 * vn;
	      up += 2 * vn;
	      prodp += 2 * vn;

	      while (2 * un >= 5 * vn)	/* un >= 2.5vn */
		{
		  if (BELOW_THRESHOLD (vn, MUL_TOOM42_TO_TOOM63_THRESHOLD))
		    mpn_toom42_mul (ws, up, 2 * vn, vp, vn, scratch);
		  else
		    mpn_toom63_mul (ws, up, 2 * vn, vp, vn, scratch);
		  un -= 2 * vn;
		  up += 2 * vn;
		  cy = mpn_add_n (prodp, prodp, ws, vn);
		  MPN_COPY (prodp + vn, ws + vn, 2 * vn);
		  mpn_incr_u (prodp + vn, cy);
		  prodp += 2 * vn;
		}

	      /* vn / 2 <= un < 2.5vn */

	      if (un < vn)
		mpn_mul (ws, vp, vn, up, un);
	      else
		mpn_mul (ws, up, un, vp, vn);

	      cy = mpn_add_n (prodp, prodp, ws, vn);
	      MPN_COPY (prodp + vn, ws + vn, un);
	      mpn_incr_u (prodp + vn, cy);
	    }
	  else
	    {
	      if (6 * un < 7 * vn)
		mpn_toom33_mul (prodp, up, un, vp, vn, scratch);
	      else if (2 * un < 3 * vn)
		{
		  if (BELOW_THRESHOLD (vn, MUL_TOOM32_TO_TOOM43_THRESHOLD))
		    mpn_toom32_mul (prodp, up, un, vp, vn, scratch);
		  else
		    mpn_toom43_mul (prodp, up, un, vp, vn, scratch);
		}
	      else if (6 * un < 11 * vn)
		{
		  if (4 * un < 7 * vn)
		    {
		      if (BELOW_THRESHOLD (vn, MUL_TOOM32_TO_TOOM53_THRESHOLD))
			mpn_toom32_mul (prodp, up, un, vp, vn, scratch);
		      else
			mpn_toom53_mul (prodp, up, un, vp, vn, scratch);
		    }
		  else
		    {
		      if (BELOW_THRESHOLD (vn, MUL_TOOM42_TO_TOOM53_THRESHOLD))
			mpn_toom42_mul (prodp, up, un, vp, vn, scratch);
		      else
			mpn_toom53_mul (prodp, up, un, vp, vn, scratch);
		    }
		}
	      else
		{
		  if (BELOW_THRESHOLD (vn, MUL_TOOM42_TO_TOOM63_THRESHOLD))
		    mpn_toom42_mul (prodp, up, un, vp, vn, scratch);
		  else
		    mpn_toom63_mul (prodp, up, un, vp, vn, scratch);
		}
	    }
	  TMP_FREE;
	}
      else
	{
	  mp_ptr scratch;
	  TMP_DECL; TMP_MARK;

	  if (BELOW_THRESHOLD (vn, MUL_TOOM6H_THRESHOLD))
	    {
	      scratch = TMP_SALLOC_LIMBS (mpn_toom44_mul_itch (un, vn));
	      mpn_toom44_mul (prodp, up, un, vp, vn, scratch);
	    }
	  else if (BELOW_THRESHOLD (vn, MUL_TOOM8H_THRESHOLD))
	    {
	      scratch = TMP_SALLOC_LIMBS (mpn_toom6h_mul_itch (un, vn));
	      mpn_toom6h_mul (prodp, up, un, vp, vn, scratch);
	    }
	  else
	    {
	      scratch = TMP_ALLOC_LIMBS (mpn_toom8h_mul_itch (un, vn));
	      mpn_toom8h_mul (prodp, up, un, vp, vn, scratch);
	    }
	  TMP_FREE;
	}
    }
  else
    {
      if (un >= 8 * vn)
	{
	  mp_limb_t cy;
	  mp_ptr ws;
	  TMP_DECL; TMP_MARK;

	  /* The maximum ws usage is for the mpn_mul result.  */
	  ws = TMP_BALLOC_LIMBS (9 * vn >> 1);

	  mpn_fft_mul (prodp, up, 3 * vn, vp, vn);
	  un -= 3 * vn;
	  up += 3 * vn;
	  prodp += 3 * vn;

	  while (2 * un >= 7 * vn)	/* un >= 3.5vn  */
	    {
	      mpn_fft_mul (ws, up, 3 * vn, vp, vn);
	      un -= 3 * vn;
	      up += 3 * vn;
	      cy = mpn_add_n (prodp, prodp, ws, vn);
	      MPN_COPY (prodp + vn, ws + vn, 3 * vn);
	      mpn_incr_u (prodp + vn, cy);
	      prodp += 3 * vn;
	    }

	  /* vn / 2 <= un < 3.5vn */

	  if (un < vn)
	    mpn_mul (ws, vp, vn, up, un);
	  else
	    mpn_mul (ws, up, un, vp, vn);

	  cy = mpn_add_n (prodp, prodp, ws, vn);
	  MPN_COPY (prodp + vn, ws + vn, un);
	  mpn_incr_u (prodp + vn, cy);

	  TMP_FREE;
	}
      else
	mpn_fft_mul (prodp, up, un, vp, vn);
    }

  return prodp[un + vn - 1];	/* historic */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %r8, %r13
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
cmpq %r8, %rdx
jne 0x18a9c
movq %r14, %rdi
movq %rbx, %rsi
cmpq %rcx, %rbx
je 0x18b1f
movq %rcx, %rdx
movq %r12, %rcx
callq 0x19500
jmp 0x19327
cmpq $0x1b, %r13
jg 0x18acd
cmpq $0x1f5, %r12            # imm = 0x1F5
setge %al
cmpq $0x3, %r13
setge %dl
testb %dl, %al
jne 0x18b2c
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r13, %r8
callq 0x19820
jmp 0x19327
cmpq $0x50, %r13
movq %r13, -0x70(%rbp)
jbe 0x18bf0
leaq (%r12,%r13), %rax
cmpq $0x5a00, %rax           # imm = 0x5A00
jl 0x18c54
cmpq $0xeff, %r13            # imm = 0xEFF
jbe 0x18c54
leaq (,%r13,8), %rax
cmpq %r12, %rax
jle 0x19176
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r13, %r8
callq 0x1a500
jmp 0x19327
movq %r12, %rdx
callq 0x196c0
jmp 0x19327
movl $0x1f4, %edx            # imm = 0x1F4
movq %r14, %rdi
movq %rbx, %rsi
movq %rcx, -0x38(%rbp)
movq %r13, %r8
callq 0x19820
movl $0xfa0, %eax            # imm = 0xFA0
addq %rax, %r14
leaq (,%r13,8), %rcx
movq %rcx, -0x50(%rbp)
addq %rax, %rbx
leaq -0x170(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x290c6
cmpq $0x3e9, %r12            # imm = 0x3E9
jb 0x18bcb
movl $0x1f4, %edx            # imm = 0x1F4
movq %r14, %rdi
movq %rbx, %rsi
movq -0x38(%rbp), %rcx
movq %r13, %r8
callq 0x19820
movq %r14, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0x17cf0
movq -0x50(%rbp), %rcx
addq %r14, %rcx
addq %rax, (%rcx)
jae 0x18bb7
addq $0x1, 0x8(%rcx)
leaq 0x8(%rcx), %rcx
jb 0x18bac
movl $0xfa0, %eax            # imm = 0xFA0
addq %rax, %r14
addq %rax, %rbx
addq $-0x1f4, %r12           # imm = 0xFE0C
jmp 0x18b61
addq $-0x1f4, %r12           # imm = 0xFE0C
movq %r14, %rdi
cmpq %r13, %r12
jle 0x18d61
movq %rbx, %rsi
movq %r12, %rdx
movq -0x38(%rbp), %rcx
movq %r13, %r8
jmp 0x18d6e
imull $0x24, %r13d, %eax
andl $0x1ff8, %eax           # imm = 0x1FF8
movq %rsp, %r9
addl $0x40f, %eax            # imm = 0x40F
andl $-0x10, %eax
subq %rax, %r9
movq %r9, %rsp
leaq (,%r13,2), %rax
addq %r13, %rax
movq %rax, -0x30(%rbp)
cmpq %r12, %rax
jle 0x18da1
leaq (,%r12,4), %rax
leaq (,%r13,4), %rdx
addq %r13, %rdx
cmpq %rdx, %rax
jge 0x18f66
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r13, %r8
callq 0x1c488
jmp 0x19327
cmpq $0xf2, %r13
jb 0x18ce2
leaq (%r12,%r12,2), %rsi
addq $0xc, %rsi
leaq (,%r13,4), %rdx
cmpq %rdx, %rsi
jge 0x18ce2
andq $0x0, -0x170(%rbp)
cmpq $0x158, %r13            # imm = 0x158
jbe 0x1933e
cmpq $0x1e1, %r13            # imm = 0x1E1
jbe 0x19412
pushq $0xe
popq %rsi
xorl %edx, %edx
divq %rsi
imulq $0x78, %rax, %rsi
leaq 0x78(%rsi), %rax
addq $0xf28, %rsi            # imm = 0xF28
cmpq $0x7057, %rax           # imm = 0x7057
ja 0x194e3
movq %rsp, %r9
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %r9
movq %r9, %rsp
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r13, %r8
callq 0x1fad0
jmp 0x1915c
andq $0x0, -0x170(%rbp)
movq %r13, %rsi
shlq $0x5, %rsi
addq $0x200, %rsi            # imm = 0x200
cmpq $0x7f00, %rsi           # imm = 0x7F00
ja 0x194a7
movq %rsp, %rax
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %rax
movq %rax, -0x30(%rbp)
movq %rax, %rsp
leaq (%r12,%r12), %rsi
leaq (,%r13,4), %rax
addq %r13, %rax
movq %rax, -0x68(%rbp)
cmpq %rax, %rsi
jge 0x18f05
imulq $0x6, %r12, %rdi
imulq $0x7, %r13, %rax
cmpq %rax, %rdi
jge 0x18fa9
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r13, %r8
movq -0x30(%rbp), %r9
callq 0x1d2dc
jmp 0x1915c
movq -0x38(%rbp), %rsi
movq %r13, %rdx
movq %rbx, %rcx
movq %r12, %r8
callq 0x19820
leaq -0x170(%rbp), %rdx
movq %r14, %rdi
movq %r14, %rsi
movq %r13, %rcx
callq 0x17cf0
leaq (%r14,%r13,8), %rcx
addq %rax, (%rcx)
jae 0x18d9c
addq $0x1, 0x8(%rcx)
leaq 0x8(%rcx), %rcx
jb 0x18d91
jmp 0x19327
movq %r13, %rax
shlq $0x5, %rax
movq %rsp, %r15
subq %rax, %r15
movq %r15, %rsp
movq %r14, %rdi
movq %r14, -0x88(%rbp)
leaq (,%r13,2), %r14
movq %rbx, %rsi
movq %r14, %rdx
movq %rcx, -0x38(%rbp)
movq %r13, %r8
movq %r9, -0x48(%rbp)
callq 0x1ce04
movq %r15, -0x68(%rbp)
leaq (%r15,%r13,8), %rax
movq %rax, -0x60(%rbp)
movq %r12, %rax
movq %r14, -0x80(%rbp)
subq %r14, %rax
shlq $0x2, %r12
leaq (,%r13,8), %rcx
movq %rcx, -0x78(%rbp)
subq %rcx, %r12
movq %r13, %rdi
shlq $0x4, %rdi
addq %rdi, %rbx
movq %rbx, %rsi
movq -0x88(%rbp), %rdx
imulq $0x18, %r13, %rcx
addq %rdx, %rcx
movq %rcx, -0x40(%rbp)
movq %rdi, -0x90(%rbp)
leaq (%rdx,%rdi), %rbx
movq %r12, %rdx
movq %rax, %r12
movq -0x80(%rbp), %r15
cmpq -0x30(%rbp), %r12
jl 0x18ece
movq -0x68(%rbp), %r13
movq %r13, %rdi
movq %rsi, %r14
movq %rdx, -0x58(%rbp)
movq %r15, %rdx
movq -0x38(%rbp), %rcx
movq %r12, -0x50(%rbp)
movq -0x70(%rbp), %r12
movq %r12, %r8
movq -0x48(%rbp), %r9
callq 0x1ce04
movq %rbx, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x17cf0
movq %rax, %r12
movq -0x40(%rbp), %r13
movq %r13, %rdi
movq -0x60(%rbp), %rsi
movq %r15, %rdx
callq 0x290c6
movq -0x58(%rbp), %rdx
movq %r13, %rax
addq %r12, (%rax)
jae 0x18ea7
addq $0x1, 0x8(%rax)
leaq 0x8(%rax), %rax
jb 0x18e9c
movq -0x50(%rbp), %r12
subq %r15, %r12
subq -0x78(%rbp), %rdx
movq -0x90(%rbp), %rax
addq %rax, %r14
movq %r14, %rsi
addq %rax, %rbx
addq %rax, %r13
movq %r13, -0x40(%rbp)
jmp 0x18e36
movq -0x70(%rbp), %r13
leaq (,%r13,4), %rax
addq %r13, %rax
cmpq %rax, %rdx
movq -0x38(%rbp), %rcx
movq -0x48(%rbp), %r9
movq -0x68(%rbp), %r14
jge 0x18f89
movq %r14, %rdi
movq %r12, %rdx
movq %r13, %r8
callq 0x1c488
jmp 0x192ea
movq %rsi, -0x40(%rbp)
imulq $0x1c, %r13, %rsi
andq $-0x8, %rsi
cmpq $0x7f00, %rsi           # imm = 0x7F00
ja 0x194c2
movq %rsp, %rax
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %rax
movq %rax, %rsp
movq %rax, -0x48(%rbp)
leaq (,%r13,2), %rdx
cmpq $0xae, %r13
movq %rcx, -0x38(%rbp)
movq %r14, %rdi
movq %rbx, %rsi
movq %rdx, %r15
movq %r13, %r8
jbe 0x18fe1
movq -0x30(%rbp), %r9
callq 0x1e230
jmp 0x18fea
imulq $0x7, %r13, %rdx
movq %r14, %rdi
movq %rbx, %rsi
cmpq %rdx, %rax
jae 0x192a8
movq %r12, %rdx
movq %r13, %r8
callq 0x1c8ac
jmp 0x19327
imulq $0x7, %r13, %rax
movq %r14, %rdi
cmpq %rax, %rdx
jge 0x192df
movq %r12, %rdx
movq %r13, %r8
callq 0x1c8ac
jmp 0x192ea
leaq (,%r13,2), %rdx
addq %r13, %rdx
cmpq %rdx, %rsi
jge 0x19368
cmpq $0x60, %r13
jbe 0x19393
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r13, %r8
movq -0x30(%rbp), %r9
callq 0x1d7dc
jmp 0x1915c
movq -0x30(%rbp), %r9
callq 0x1ce04
movq -0x48(%rbp), %rcx
leaq (%rcx,%r13,8), %rcx
movq %rcx, -0x60(%rbp)
subq %r15, %r12
movq %r12, -0x50(%rbp)
leaq (,%r13,4), %rdx
movq -0x40(%rbp), %rcx
movq %rdx, -0x80(%rbp)
subq %rdx, %rcx
movq %r13, %rsi
shlq $0x4, %rsi
addq %rsi, %rbx
imulq $0x18, %r13, %rdx
addq %r14, %rdx
movq %rdx, -0x58(%rbp)
movq %rsi, -0x78(%rbp)
leaq (%r14,%rsi), %rax
movq %r15, %r12
movq %rax, %r15
cmpq -0x68(%rbp), %rcx
jl 0x190e6
movq %rcx, -0x40(%rbp)
movq -0x70(%rbp), %r13
cmpq $0xae, %r13
jbe 0x1906d
movq -0x48(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq -0x38(%rbp), %rcx
movq %r13, %r8
movq -0x30(%rbp), %r9
callq 0x1e230
jmp 0x1908a
movq -0x48(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq -0x38(%rbp), %rcx
movq %r13, %r8
movq -0x30(%rbp), %r9
callq 0x1ce04
movq %r15, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0x17cf0
movq %rax, %r13
movq -0x58(%rbp), %r14
movq %r14, %rdi
movq -0x60(%rbp), %rsi
movq %r12, %rdx
callq 0x290c6
movq %r14, %rax
addq %r13, (%rax)
jae 0x190c4
addq $0x1, 0x8(%rax)
leaq 0x8(%rax), %rax
jb 0x190b9
subq %r12, -0x50(%rbp)
movq -0x40(%rbp), %rcx
subq -0x80(%rbp), %rcx
movq -0x78(%rbp), %rax
addq %rax, %rbx
addq %rax, %r15
addq %rax, %r14
movq %r14, -0x58(%rbp)
jmp 0x19033
movq -0x50(%rbp), %r12
movq -0x70(%rbp), %r13
cmpq %r13, %r12
jge 0x19109
movq -0x48(%rbp), %r14
movq %r14, %rdi
movq -0x38(%rbp), %rsi
movq %r13, %rdx
movq %rbx, %rcx
movq %r12, %r8
jmp 0x1911d
movq -0x48(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq -0x38(%rbp), %rcx
movq %r13, %r8
callq 0x18a58
movq %r15, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0x17cf0
movq %rax, %rbx
movq -0x58(%rbp), %r14
movq %r14, %rdi
movq -0x60(%rbp), %rsi
movq %r12, %rdx
callq 0x290c6
addq %rbx, (%r14)
jae 0x19159
addq $0x1, 0x8(%r14)
leaq 0x8(%r14), %r14
jb 0x1914e
movq %r15, %r14
movq -0x170(%rbp), %rdi
testq %rdi, %rdi
je 0x19327
callq 0x29df3
jmp 0x19327
leaq -0x170(%rbp), %rdi
andq $0x0, (%rdi)
movq %rbx, -0x40(%rbp)
movq %r14, -0x88(%rbp)
leaq (,%r13,2), %rbx
addq %r13, %rbx
imulq $0x24, %r13, %rsi
andq $-0x8, %rsi
movq %rcx, %r15
callq 0x29dc0
movq %rax, %r14
movq -0x88(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rbx, %rdx
movq %r15, -0x38(%rbp)
movq %r15, %rcx
movq %r13, %r8
callq 0x1a500
imulq $0x7, %r13, %rax
movq %rax, -0x68(%rbp)
movq %r14, -0x30(%rbp)
leaq (%r14,%r13,8), %rax
movq %rax, -0x48(%rbp)
movq %r12, %rax
movq %rbx, -0x60(%rbp)
subq %rbx, %rax
addq %r12, %r12
imulq $0x6, %r13, %rcx
movq %rcx, -0x80(%rbp)
subq %rcx, %r12
imulq $0x18, %r13, %rcx
addq %rcx, -0x40(%rbp)
shlq $0x5, %r13
movq -0x88(%rbp), %rdx
addq %rdx, %r13
movq %r13, -0x58(%rbp)
movq %rcx, -0x78(%rbp)
leaq (%rdx,%rcx), %r14
movq -0x40(%rbp), %r8
movq %rax, -0x50(%rbp)
movq -0x60(%rbp), %r15
cmpq -0x68(%rbp), %r12
jl 0x192b5
movq -0x30(%rbp), %r13
movq %r13, %rdi
movq %r8, %rsi
movq %r15, %rdx
movq -0x38(%rbp), %rcx
movq %r8, -0x40(%rbp)
movq -0x70(%rbp), %rbx
movq %rbx, %r8
callq 0x1a500
movq %r14, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x17cf0
movq %rax, %rbx
movq -0x58(%rbp), %r13
movq %r13, %rdi
movq -0x48(%rbp), %rsi
movq %r15, %rdx
callq 0x290c6
movq %r13, %rax
addq %rbx, (%rax)
jae 0x19286
addq $0x1, 0x8(%rax)
leaq 0x8(%rax), %rax
jb 0x1927b
movq -0x40(%rbp), %r8
subq %r15, -0x50(%rbp)
subq -0x80(%rbp), %r12
movq -0x78(%rbp), %rax
addq %rax, %r8
addq %rax, %r14
addq %rax, %r13
movq %r13, -0x58(%rbp)
jmp 0x19221
movq %r12, %rdx
movq %r13, %r8
callq 0x1ce04
jmp 0x19327
movq -0x70(%rbp), %r13
movq -0x50(%rbp), %r15
cmpq %r13, %r15
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
jge 0x193ad
movq -0x38(%rbp), %rsi
movq %r13, %rdx
movq %r8, %rcx
movq %r15, %r8
jmp 0x193ba
movq %r12, %rdx
movq %r13, %r8
callq 0x1ce04
movq %rbx, %r15
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0x17cf0
movq %rax, %rbx
movq -0x40(%rbp), %r14
movq %r14, %rdi
movq -0x60(%rbp), %rsi
movq %r12, %rdx
callq 0x290c6
addq %rbx, (%r14)
jae 0x19324
addq $0x1, 0x8(%r14)
leaq 0x8(%r14), %r14
jb 0x19319
movq %r15, %r14
addq %r12, %r13
movq -0x8(%r14,%r13,8), %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
imulq $0x18, %r12, %rax
movq %rsp, %r9
addq $0x20f, %rax            # imm = 0x20F
andq $-0x10, %rax
subq %rax, %r9
movq %r9, %rsp
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r13, %r8
callq 0x1e7c4
jmp 0x19327
imulq $0xb, %r13, %rdx
cmpq %rdx, %rdi
jae 0x19447
leaq (,%r12,4), %rdx
cmpq %rax, %rdx
jge 0x1946a
cmpq $0x98, %r13
ja 0x19473
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r13, %r8
movq -0x30(%rbp), %r9
callq 0x1c8ac
jmp 0x1915c
movq %r8, %rsi
movq %r15, %rdx
movq -0x38(%rbp), %rcx
movq %r13, %r8
callq 0x18a58
movq %r14, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x17cf0
movq %rax, %rbx
movq -0x58(%rbp), %r12
movq %r12, %rdi
movq -0x48(%rbp), %rsi
movq %r15, %rdx
callq 0x290c6
addq %rbx, (%r12)
jae 0x193f9
addq $0x1, 0x8(%r12)
leaq 0x8(%r12), %r12
jb 0x193ec
movq -0x170(%rbp), %rdi
testq %rdi, %rdi
jne 0x194d9
movq -0x50(%rbp), %r12
jmp 0x19327
pushq $0xa
popq %rsi
xorl %edx, %edx
divq %rsi
imulq $0x60, %rax, %rax
addq $0xd37, %rax            # imm = 0xD37
andq $-0x10, %rax
movq %rsp, %r9
subq %rax, %r9
movq %r9, %rsp
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r13, %r8
callq 0x1ed30
jmp 0x19327
cmpq $0xae, %r13
jbe 0x1948d
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r13, %r8
movq -0x30(%rbp), %r9
callq 0x1e230
jmp 0x1915c
cmpq $0xa0, %r13
jbe 0x1948d
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r13, %r8
movq -0x30(%rbp), %r9
callq 0x1dbf8
jmp 0x1915c
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r13, %r8
movq -0x30(%rbp), %r9
callq 0x1ce04
jmp 0x1915c
leaq -0x170(%rbp), %rdi
movq %rcx, %r15
callq 0x29dc0
movq %r15, %rcx
movq %rax, -0x30(%rbp)
jmp 0x18d1a
leaq -0x170(%rbp), %rdi
movq %rcx, %r15
callq 0x29dc0
movq %r15, %rcx
jmp 0x18f2f
callq 0x29df3
jmp 0x19409
leaq -0x170(%rbp), %rdi
movq %rcx, %r15
callq 0x29dc0
movq %r15, %rcx
movq %rax, %r9
jmp 0x18ccc
nopl (%rax)