// File: /workspace/github_cpp_makefile_star2_O3/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 $0x138, %rsp            # imm = 0x138
movq %r8, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
cmpq %r8, %rdx
jne 0x1c87c
movq %r15, %rdi
movq %r14, %rsi
cmpq %rcx, %r14
je 0x1c907
movq %rcx, %rdx
movq %r12, %rcx
callq 0x1d348
jmp 0x1d06f
cmpq $0x1b, %rbx
jg 0x1c8ad
cmpq $0x1f5, %r12            # imm = 0x1F5
setge %al
cmpq $0x3, %rbx
setge %dl
testb %dl, %al
jne 0x1c914
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %r8
callq 0x1d680
jmp 0x1d06f
cmpq $0x50, %rbx
movq %rbx, -0x40(%rbp)
jbe 0x1c9f3
leaq (%rbx,%r12), %rax
cmpq $0x5a00, %rax           # imm = 0x5A00
jl 0x1ca4f
cmpq $0xeff, %rbx            # imm = 0xEFF
jbe 0x1ca4f
movq %rcx, -0x38(%rbp)
leaq (,%rbx,8), %r13
cmpq %r12, %r13
jle 0x1cf98
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq -0x38(%rbp), %rcx
movq %rbx, %r8
callq 0x1e360
jmp 0x1d06f
movq %r12, %rdx
callq 0x1d514
jmp 0x1d06f
movl $0x1f4, %edx            # imm = 0x1F4
movq %r15, %rdi
movq %r14, %rsi
movq %rcx, %r13
movq %rbx, %r8
callq 0x1d680
movl $0xfa0, %eax            # imm = 0xFA0
addq %rax, %r15
leaq -0x160(%rbp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2f106
movl $0xfa0, %eax            # imm = 0xFA0
addq %rax, %r14
cmpq $0x3e9, %r12            # imm = 0x3E9
jb 0x1cb6d
leaq (,%rbx,8), %rax
movq %rax, -0x48(%rbp)
movq %r13, -0x38(%rbp)
movl $0x1f4, %edx            # imm = 0x1F4
movq %r15, %rdi
movq %r14, %r13
movq %r14, %rsi
movq -0x38(%rbp), %rcx
movq %rbx, %r8
callq 0x1d680
movq %r15, %rdi
movq %r15, %rsi
leaq -0x160(%rbp), %r14
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1ba80
movq -0x48(%rbp), %rcx
addq %r15, %rcx
addq %rax, (%rcx)
jae 0x1c9b2
addq $0x1, 0x8(%rcx)
leaq 0x8(%rcx), %rcx
jb 0x1c9a7
movl $0xfa0, %eax            # imm = 0xFA0
addq %rax, %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2f106
movl $0xfa0, %eax            # imm = 0xFA0
addq %rax, %r13
movq %r13, %r14
addq $-0x1f4, %r12           # imm = 0xFE0C
cmpq $0x3e8, %r12            # imm = 0x3E8
ja 0x1c969
addq $-0x1f4, %r12           # imm = 0xFE0C
movq -0x38(%rbp), %rcx
jmp 0x1cb77
leal (,%rbx,4), %eax
leal (%rax,%rax,8), %eax
andl $0x1ff8, %eax           # imm = 0x1FF8
addl $0x40f, %eax            # imm = 0x40F
andl $-0x10, %eax
movq %rsp, %r9
subq %rax, %r9
movq %r9, %rsp
leaq (%rbx,%rbx,2), %rdx
movq %rdx, -0x30(%rbp)
cmpq %r12, %rdx
jle 0x1cb8a
leaq (,%r12,4), %rax
leaq (%rbx,%rbx,4), %rdx
cmpq %rdx, %rax
jge 0x1cc8f
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %r8
callq 0x203ac
jmp 0x1d06f
cmpq $0xf2, %rbx
jb 0x1caeb
leaq (%r12,%r12,2), %rsi
addq $0xc, %rsi
leaq (,%rbx,4), %rdx
cmpq %rdx, %rsi
jge 0x1caeb
movq $0x0, -0x160(%rbp)
cmpq $0x158, %rbx            # imm = 0x158
jbe 0x1d086
cmpq $0x1e1, %rbx            # imm = 0x1E1
jbe 0x1d255
shrq %rax
movabsq $0x4924924924924925, %rdx # imm = 0x4924924924924925
mulq %rdx
shrq %rdx
imulq $0x78, %rdx, %rsi
leaq 0x78(%rsi), %rax
addq $0xf28, %rsi            # imm = 0xF28
cmpq $0x7057, %rax           # imm = 0x7057
ja 0x1d32d
movq %rsp, %r9
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %r9
movq %r9, %rsp
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %r8
callq 0x24380
jmp 0x1cf7e
movq $0x0, -0x160(%rbp)
movq %rbx, %rsi
shlq $0x5, %rsi
addq $0x200, %rsi            # imm = 0x200
cmpq $0x7f00, %rsi           # imm = 0x7F00
ja 0x1d2f7
movq %rsp, %rax
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %rax
movq %rax, -0x30(%rbp)
movq %rax, %rsp
leaq (%r12,%r12), %rsi
leaq (%rbx,%rbx,4), %rdx
movq %rdx, -0x58(%rbp)
cmpq %rdx, %rsi
jge 0x1cc2b
leaq (%rsi,%rsi,2), %rdi
leaq (,%rbx,8), %rax
subq %rbx, %rax
cmpq %rax, %rdi
jge 0x1cdbc
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %r8
movq -0x30(%rbp), %r9
callq 0x210f0
jmp 0x1cf7e
addq $-0x1f4, %r12           # imm = 0xFE0C
movq %r13, %rcx
movq %r15, %rdi
cmpq %rbx, %r12
jle 0x1cbec
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %r8
jmp 0x1cbf8
movq %rbx, %rax
shlq $0x5, %rax
movq %rsp, %r13
subq %rax, %r13
movq %r13, %rsp
leaq (%rbx,%rbx), %rdx
movq %rdx, -0x78(%rbp)
movq %r15, %rdi
movq %r14, %rsi
movq %rcx, -0x38(%rbp)
movq %rbx, %r8
movq %r9, -0x58(%rbp)
callq 0x208fc
movq -0x78(%rbp), %rdx
movq %r12, %rcx
movq %rbx, %rdi
shlq $0x4, %rdi
leaq (%r15,%rdi), %rax
addq %rdi, %r14
movq %r14, %rsi
subq %rdx, %rcx
movq %rcx, %r12
cmpq -0x30(%rbp), %rcx
jge 0x1ccb9
movq %rax, %r15
movq -0x38(%rbp), %rcx
jmp 0x1cd63
movq %rcx, %rsi
movq %rbx, %rdx
movq %r14, %rcx
movq %r12, %r8
callq 0x1d680
leaq -0x160(%rbp), %rdx
movq %r15, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x1ba80
leaq (%r15,%rbx,8), %rcx
addq %rax, (%rcx)
jae 0x1cc26
addq $0x1, 0x8(%rcx)
leaq 0x8(%rcx), %rcx
jb 0x1cc1b
jmp 0x1d06f
movq %rsi, -0x68(%rbp)
leaq (%rbx,%rbx,8), %rax
leaq (%rax,%rax,2), %rsi
addq %rbx, %rsi
andq $-0x8, %rsi
cmpq $0x7f00, %rsi           # imm = 0x7F00
ja 0x1d312
movq %rsp, %rax
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %rax
movq %rax, -0x50(%rbp)
movq %rax, %rsp
leaq (%rbx,%rbx), %rdx
cmpq $0xae, %rbx
movq %rcx, -0x38(%rbp)
movq %r15, %rdi
movq %r14, %rsi
movq %rdx, %r13
movq %rbx, %r8
jbe 0x1cded
movq -0x30(%rbp), %r9
callq 0x22774
jmp 0x1cdf6
leaq (,%rbx,8), %rdx
subq %rbx, %rdx
movq %r15, %rdi
movq %r14, %rsi
cmpq %rdx, %rax
jae 0x1d014
movq %r12, %rdx
movq %rbx, %r8
callq 0x66de
jmp 0x1d06f
leaq (,%rbx,8), %rcx
addq %r13, %rcx
movq %rcx, -0x70(%rbp)
movq -0x30(%rbp), %rcx
leaq (%r15,%rcx,8), %rbx
movq %rax, %r15
movq -0x38(%rbp), %rcx
movq %rdi, -0x50(%rbp)
movq %r12, -0x48(%rbp)
movq %rsi, -0x68(%rbp)
movq %r13, %r12
movq %r13, %rdi
movq %rdx, %r14
movq -0x40(%rbp), %r13
movq %r13, %r8
movq -0x58(%rbp), %r9
callq 0x208fc
movq %r15, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x1ba80
movq %rax, -0x60(%rbp)
movq %rbx, %rdi
movq -0x70(%rbp), %rsi
movq %r14, %rdx
callq 0x2f106
movq -0x50(%rbp), %rdi
movq %r14, %rdx
movq %r12, %r13
movq -0x48(%rbp), %r12
movq %rbx, %rax
movq -0x60(%rbp), %rcx
addq %rcx, (%rax)
jae 0x1cd45
addq $0x1, 0x8(%rax)
leaq 0x8(%rax), %rax
jb 0x1cd3a
movq -0x38(%rbp), %rcx
movq -0x68(%rbp), %rsi
subq %r14, %r12
addq %rdi, %rsi
addq %rdi, %r15
addq %rdi, %rbx
cmpq -0x30(%rbp), %r12
jge 0x1ccdb
leaq (,%r12,4), %rax
movq -0x40(%rbp), %r14
leaq (%r14,%r14,4), %rdx
cmpq %rdx, %rax
movq -0x58(%rbp), %r9
jge 0x1cd92
movq %r13, %rbx
movq %r13, %rdi
movq %r12, %rdx
movq %r14, %r8
callq 0x203ac
jmp 0x1d02c
leaq (,%r14,8), %rdx
subq %r14, %rdx
movq %r13, %rbx
movq %r13, %rdi
cmpq %rdx, %rax
jge 0x1d021
movq %r12, %rdx
movq %r14, %r8
callq 0x66de
jmp 0x1d02c
leaq (%rbx,%rbx,2), %rdx
cmpq %rdx, %rsi
jge 0x1d0b2
cmpq $0x60, %rbx
jbe 0x1d0e1
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %r8
movq -0x30(%rbp), %r9
callq 0x218f4
jmp 0x1cf7e
movq -0x30(%rbp), %r9
callq 0x208fc
leaq (%r15,%r13,8), %rax
movq %r13, %rsi
leaq (%r14,%r13,8), %r13
subq %rsi, %r12
movq %r12, -0x48(%rbp)
leaq (%r12,%r12), %rcx
cmpq -0x58(%rbp), %rcx
movq -0x68(%rbp), %rdx
jge 0x1ce1e
movq %rax, %r15
jmp 0x1cf00
movq %rsi, %r14
movq -0x50(%rbp), %rcx
leaq (%rcx,%rbx,8), %rcx
movq %rcx, -0x70(%rbp)
leaq (,%rbx,4), %rcx
movq %rcx, -0x78(%rbp)
subq %rcx, %rdx
movq %rbx, %rcx
shlq $0x4, %rcx
movq %rcx, -0x80(%rbp)
leaq (%rbx,%rbx,2), %rcx
leaq (%r15,%rcx,8), %r12
movq %rax, %r15
movq %rdx, -0x68(%rbp)
movq %r15, -0x60(%rbp)
cmpq $0xae, %rbx
jbe 0x1ce82
movq -0x50(%rbp), %r15
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq -0x38(%rbp), %rcx
movq %rbx, %r8
movq -0x30(%rbp), %r9
callq 0x22774
jmp 0x1ce9f
movq -0x50(%rbp), %r15
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq -0x38(%rbp), %rcx
movq %rbx, %r8
movq -0x30(%rbp), %r9
callq 0x208fc
movq -0x60(%rbp), %rdi
movq %rdi, %rsi
movq %r15, %rdx
movq %rdi, %r15
movq %rbx, %rcx
callq 0x1ba80
movq %rax, %rbx
movq %r12, %rdi
movq -0x70(%rbp), %rsi
movq %r14, %rdx
callq 0x2f106
movq %r12, %rax
addq %rbx, (%rax)
jae 0x1ced9
addq $0x1, 0x8(%rax)
leaq 0x8(%rax), %rax
jb 0x1cece
movq -0x40(%rbp), %rbx
subq %r14, -0x48(%rbp)
movq -0x68(%rbp), %rdx
subq -0x78(%rbp), %rdx
movq -0x80(%rbp), %rax
addq %rax, %r13
addq %rax, %r15
addq %rax, %r12
cmpq -0x58(%rbp), %rdx
jge 0x1ce52
movq -0x48(%rbp), %r12
cmpq %rbx, %r12
jge 0x1cf1f
movq -0x50(%rbp), %r14
movq %r14, %rdi
movq -0x38(%rbp), %rsi
movq %rbx, %rdx
movq %r13, %rcx
movq %r12, %r8
jmp 0x1cf33
movq -0x50(%rbp), %r14
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq -0x38(%rbp), %rcx
movq %rbx, %r8
callq 0x1c838
movq %r15, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1ba80
movq %rax, %rbx
movq -0x40(%rbp), %rax
movq %r14, %rcx
leaq (%r15,%rax,8), %r14
movq -0x40(%rbp), %rax
leaq (%rcx,%rax,8), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x2f106
addq %rbx, (%r14)
jae 0x1cf7a
addq $0x1, 0x8(%r14)
leaq 0x8(%r14), %r14
jb 0x1cf6f
movq -0x40(%rbp), %rbx
movq -0x160(%rbp), %rdi
testq %rdi, %rdi
je 0x1d06f
callq 0x2fde3
jmp 0x1d06f
movq %r15, -0x60(%rbp)
leaq (%rbx,%rbx,2), %r15
leaq -0x160(%rbp), %rdi
movq $0x0, (%rdi)
leaq (,%rbx,4), %rax
leaq (%rax,%rax,8), %rsi
andq $-0x8, %rsi
callq 0x2fdb0
movq %rax, -0x48(%rbp)
movq -0x60(%rbp), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq -0x38(%rbp), %rcx
movq %rbx, %r8
callq 0x1e360
movq %r15, %rdx
movq -0x60(%rbp), %rdi
movq %r13, %r9
subq %rbx, %r9
leaq (%rdi,%r15,8), %r15
leaq (%r14,%rdx,8), %r10
movq %r12, %rax
subq %rdx, %rax
leaq (%rax,%rax), %rsi
cmpq %r9, %rsi
jge 0x1d0fb
movq %rax, %rcx
movq %rbx, %r8
movq -0x48(%rbp), %r13
jmp 0x1d1cb
movq %r12, %rdx
movq %rbx, %r8
callq 0x208fc
jmp 0x1d06f
movq %r12, %rdx
movq %r14, %r8
callq 0x208fc
movq %r15, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1ba80
movq %rax, %r13
movq -0x40(%rbp), %rax
leaq (%r15,%rax,8), %r14
movq -0x40(%rbp), %rax
leaq (%rbx,%rax,8), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x2f106
addq %r13, (%r14)
jae 0x1d06b
addq $0x1, 0x8(%r14)
leaq 0x8(%r14), %r14
jb 0x1d060
movq -0x40(%rbp), %rbx
addq %r12, %rbx
movq -0x8(%r15,%rbx,8), %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq (%r12,%r12,2), %rax
movq %rsp, %r9
leaq 0x20f(,%rax,8), %rax
andq $-0x10, %rax
subq %rax, %r9
movq %r9, %rsp
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %r8
callq 0x22f0c
jmp 0x1d06f
movq -0x58(%rbp), %rdx
leaq (%rbx,%rdx,2), %rdx
cmpq %rdx, %rdi
jae 0x1d297
leaq (,%r12,4), %rdx
cmpq %rax, %rdx
jge 0x1d2ba
cmpq $0x98, %rbx
ja 0x1d2c3
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %r8
movq -0x30(%rbp), %r9
callq 0x66de
jmp 0x1cf7e
movq -0x48(%rbp), %r11
leaq (%r11,%rbx,8), %rsi
movq %rsi, -0x58(%rbp)
addq %r12, %r12
leaq (%rbx,%rbx), %rsi
leaq (%rsi,%rsi,2), %rsi
movq %rsi, -0x50(%rbp)
subq %rsi, %r12
leaq (,%r13,2), %rsi
addq %r13, %rsi
movq %rsi, -0x70(%rbp)
movq %rbx, %rsi
shlq $0x5, %rsi
addq %rsi, %rdi
movq %r12, %r14
movq %rdi, %r12
movq %rax, %rcx
movq %rbx, %r8
movq %r11, %r13
movq %r9, -0x30(%rbp)
movq %rcx, -0x48(%rbp)
movq %r10, -0x68(%rbp)
movq %r13, %rdi
movq %r10, %rsi
movq -0x38(%rbp), %rcx
movq %rdx, %rbx
callq 0x1e360
movq %r15, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq -0x40(%rbp), %rcx
callq 0x1ba80
movq %rax, -0x60(%rbp)
movq %r12, %rdi
movq -0x58(%rbp), %rsi
movq %rbx, %rdx
callq 0x2f106
movq -0x48(%rbp), %rcx
movq -0x30(%rbp), %r9
movq -0x68(%rbp), %r10
movq %rbx, %rdx
movq %r12, %rax
movq -0x60(%rbp), %rsi
addq %rsi, (%rax)
jae 0x1d1aa
addq $0x1, 0x8(%rax)
leaq 0x8(%rax), %rax
jb 0x1d19f
movq -0x40(%rbp), %r8
subq %rbx, %rcx
subq -0x50(%rbp), %r14
movq -0x70(%rbp), %rax
addq %rax, %r10
addq %rax, %r15
addq %rax, %r12
cmpq %r9, %r14
jge 0x1d145
cmpq %r8, %rcx
movq %rcx, %r12
movq %r13, %rdi
jge 0x1d1e8
movq -0x38(%rbp), %rsi
movq %r8, %rbx
movq %r8, %rdx
movq %r10, %rcx
movq %r12, %r8
jmp 0x1d1f5
movq %r10, %rsi
movq %r12, %rdx
movq -0x38(%rbp), %rcx
movq %r8, %rbx
callq 0x1c838
movq %r15, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x1ba80
movq %rbx, %rcx
movq %rax, %rbx
leaq (%r15,%rcx,8), %r14
leaq (,%rcx,8), %rsi
addq %r13, %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x2f106
addq %rbx, (%r14)
jae 0x1d23b
addq $0x1, 0x8(%r14)
leaq 0x8(%r14), %r14
jb 0x1d230
movq -0x160(%rbp), %rdi
testq %rdi, %rdi
je 0x1d06b
callq 0x2fde3
jmp 0x1d06b
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
mulq %rdx
shrq $0x3, %rdx
leaq (%rdx,%rdx,2), %rax
shlq $0x5, %rax
addq $0xd37, %rax            # imm = 0xD37
andq $-0x10, %rax
movq %rsp, %r9
subq %rax, %r9
movq %r9, %rsp
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %r8
callq 0x2346c
jmp 0x1d06f
cmpq $0xae, %rbx
jbe 0x1d2dd
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %r8
movq -0x30(%rbp), %r9
callq 0x22774
jmp 0x1cf7e
cmpq $0xa0, %rbx
jbe 0x1d2dd
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %r8
movq -0x30(%rbp), %r9
callq 0x21ee8
jmp 0x1cf7e
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %r8
movq -0x30(%rbp), %r9
callq 0x208fc
jmp 0x1cf7e
leaq -0x160(%rbp), %rdi
movq %rcx, %r13
callq 0x2fdb0
movq %r13, %rcx
movq %rax, -0x30(%rbp)
jmp 0x1cb26
leaq -0x160(%rbp), %rdi
movq %rcx, %r13
callq 0x2fdb0
movq %r13, %rcx
movq %rax, -0x50(%rbp)
jmp 0x1cc60
leaq -0x160(%rbp), %rdi
movq %rcx, %r13
callq 0x2fdb0
movq %r13, %rcx
movq %rax, %r9
jmp 0x1cad5
nop