// File: /workspace/github_cpp_makefile_star2_O1/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 0x1cd9c
movq %r15, %rdi
movq %r14, %rsi
cmpq %rcx, %r14
je 0x1ce27
movq %rcx, %rdx
movq %r12, %rcx
callq 0x1d864
jmp 0x1d7f4
cmpq $0x1b, %rbx
jg 0x1cdcd
cmpq $0x1f5, %r12            # imm = 0x1F5
setge %al
cmpq $0x3, %rbx
setge %dl
testb %dl, %al
jne 0x1ce34
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %r8
callq 0x1dbb0
jmp 0x1d7f4
cmpq $0x50, %rbx
movq %rbx, -0x40(%rbp)
jle 0x1cf13
leaq (%rbx,%r12), %rax
cmpq $0x5a00, %rax           # imm = 0x5A00
jl 0x1cf72
cmpq $0xeff, %rbx            # imm = 0xEFF
jle 0x1cf72
movq %rcx, -0x38(%rbp)
leaq (,%rbx,8), %r13
cmpq %r12, %r13
jle 0x1d4a3
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq -0x38(%rbp), %rcx
movq %rbx, %r8
callq 0x1e890
jmp 0x1d7f4
movq %r12, %rdx
callq 0x1da3c
jmp 0x1d7f4
movl $0x1f4, %edx            # imm = 0x1F4
movq %r15, %rdi
movq %r14, %rsi
movq %rcx, %r13
movq %rbx, %r8
callq 0x1dbb0
movl $0xfa0, %eax            # imm = 0xFA0
addq %rax, %r15
leaq -0x160(%rbp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2f4c6
movl $0xfa0, %eax            # imm = 0xFA0
addq %rax, %r14
cmpq $0x3e9, %r12            # imm = 0x3E9
jl 0x1d090
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 0x1dbb0
movq %r15, %rdi
movq %r15, %rsi
leaq -0x160(%rbp), %r14
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1bfa0
movq -0x48(%rbp), %rcx
addq %r15, %rcx
addq %rax, (%rcx)
jae 0x1ced2
addq $0x1, 0x8(%rcx)
leaq 0x8(%rcx), %rcx
jb 0x1cec7
movl $0xfa0, %eax            # imm = 0xFA0
addq %rax, %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2f4c6
movl $0xfa0, %eax            # imm = 0xFA0
addq %rax, %r13
movq %r13, %r14
addq $-0x1f4, %r12           # imm = 0xFE0C
cmpq $0x3e8, %r12            # imm = 0x3E8
jg 0x1ce89
addq $-0x1f4, %r12           # imm = 0xFE0C
movq -0x38(%rbp), %rcx
jmp 0x1d09a
leaq (,%rbx,4), %rax
leaq (%rax,%rax,8), %rax
andq $-0x8, %rax
movq %rsp, %r9
addq $0x40f, %rax            # imm = 0x40F
andq $-0x10, %rax
subq %rax, %r9
movq %r9, %rsp
leaq (%rbx,%rbx,2), %rdx
movq %rdx, -0x30(%rbp)
cmpq %r12, %rdx
jle 0x1d0ad
leaq (,%r12,4), %rax
leaq (%rbx,%rbx,4), %rdx
cmpq %rdx, %rax
jge 0x1d1b2
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %r8
callq 0x20908
jmp 0x1d7f4
cmpq $0xf2, %rbx
jl 0x1d00e
leaq (%r12,%r12,2), %rsi
addq $0xc, %rsi
leaq (,%rbx,4), %rdx
cmpq %rdx, %rsi
jge 0x1d00e
movq $0x0, -0x160(%rbp)
cmpq $0x158, %rbx            # imm = 0x158
jle 0x1d582
cmpq $0x1e1, %rbx            # imm = 0x1E1
jle 0x1d754
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 0x1d848
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 0x24860
jmp 0x1d7e8
movq $0x0, -0x160(%rbp)
movq %rbx, %rsi
shlq $0x5, %rsi
addq $0x200, %rsi            # imm = 0x200
cmpq $0x7f00, %rsi           # imm = 0x7F00
ja 0x1d812
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 0x1d14e
leaq (%rsi,%rsi,2), %rdi
leaq (,%rbx,8), %rax
subq %rbx, %rax
cmpq %rax, %rdi
jge 0x1d2df
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %r8
movq -0x30(%rbp), %r9
callq 0x2169c
jmp 0x1d7e8
addq $-0x1f4, %r12           # imm = 0xFE0C
movq %r13, %rcx
movq %r15, %rdi
cmpq %rbx, %r12
jle 0x1d10f
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %r8
jmp 0x1d11b
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 0x20e88
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 0x1d1dc
movq %rax, %r15
movq -0x38(%rbp), %rcx
jmp 0x1d286
movq %rcx, %rsi
movq %rbx, %rdx
movq %r14, %rcx
movq %r12, %r8
callq 0x1dbb0
leaq -0x160(%rbp), %rdx
movq %r15, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x1bfa0
leaq (%r15,%rbx,8), %rcx
addq %rax, (%rcx)
jae 0x1d149
addq $0x1, 0x8(%rcx)
leaq 0x8(%rcx), %rcx
jb 0x1d13e
jmp 0x1d7f4
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 0x1d82d
movq %rsp, %rax
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %rax
movq %rax, -0x50(%rbp)
movq %rax, %rsp
leaq (%rbx,%rbx), %r13
cmpq $0xae, %rbx
movq %rcx, -0x38(%rbp)
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rbx, %r8
jle 0x1d310
movq -0x30(%rbp), %r9
callq 0x22d28
jmp 0x1d319
leaq (,%rbx,8), %rdx
subq %rbx, %rdx
movq %r15, %rdi
movq %r14, %rsi
cmpq %rdx, %rax
jge 0x1d51f
movq %r12, %rdx
movq %rbx, %r8
callq 0x66c6
jmp 0x1d7f4
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 0x20e88
movq %r15, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x1bfa0
movq %rax, -0x60(%rbp)
movq %rbx, %rdi
movq -0x70(%rbp), %rsi
movq %r14, %rdx
callq 0x2f4c6
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 0x1d268
addq $0x1, 0x8(%rax)
leaq 0x8(%rax), %rax
jb 0x1d25d
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 0x1d1fe
leaq (,%r12,4), %rax
movq -0x40(%rbp), %r14
leaq (%r14,%r14,4), %rdx
cmpq %rdx, %rax
movq -0x58(%rbp), %r9
jge 0x1d2b5
movq %r13, %rbx
movq %r13, %rdi
movq %r12, %rdx
movq %r14, %r8
callq 0x20908
jmp 0x1d53a
leaq (,%r14,8), %rdx
subq %r14, %rdx
movq %r13, %rbx
movq %r13, %rdi
cmpq %rdx, %rax
jge 0x1d52f
movq %r12, %rdx
movq %r14, %r8
callq 0x66c6
jmp 0x1d53a
leaq (%rbx,%rbx,2), %rdx
cmpq %rdx, %rsi
jge 0x1d5b1
cmpq $0x60, %rbx
jle 0x1d5e0
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %r8
movq -0x30(%rbp), %r9
callq 0x21e74
jmp 0x1d7e8
movq -0x30(%rbp), %r9
callq 0x20e88
movq %rbx, %rcx
shlq $0x4, %rcx
leaq (%r15,%rcx), %rax
movq %rcx, -0x70(%rbp)
addq %rcx, %r14
subq %r13, %r12
movq %r12, -0x48(%rbp)
leaq (%r12,%r12), %rcx
cmpq -0x58(%rbp), %rcx
movq -0x68(%rbp), %rdx
jge 0x1d348
movq %rax, %r15
jmp 0x1d41c
movq -0x50(%rbp), %rcx
leaq (%rcx,%rbx,8), %rcx
movq %rcx, -0x78(%rbp)
leaq (,%rbx,4), %rcx
movq %rcx, -0x80(%rbp)
subq %rcx, %rdx
leaq (%rbx,%rbx,2), %rcx
leaq (%r15,%rcx,8), %r12
movq %rax, %r15
movq %rdx, -0x68(%rbp)
movq %r15, -0x60(%rbp)
cmpq $0xae, %rbx
jle 0x1d39e
movq -0x50(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq -0x38(%rbp), %rcx
movq %rbx, %r8
movq -0x30(%rbp), %r9
callq 0x22d28
jmp 0x1d3bb
movq -0x50(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq -0x38(%rbp), %rcx
movq %rbx, %r8
movq -0x30(%rbp), %r9
callq 0x20e88
movq -0x60(%rbp), %rdi
movq %rdi, %rsi
movq %r15, %rdx
movq %rdi, %r15
movq %rbx, %rcx
callq 0x1bfa0
movq %rax, %rbx
movq %r12, %rdi
movq -0x78(%rbp), %rsi
movq %r13, %rdx
callq 0x2f4c6
movq %r12, %rax
addq %rbx, (%rax)
jae 0x1d3f5
addq $0x1, 0x8(%rax)
leaq 0x8(%rax), %rax
jb 0x1d3ea
movq -0x40(%rbp), %rbx
subq %r13, -0x48(%rbp)
movq -0x68(%rbp), %rdx
subq -0x80(%rbp), %rdx
movq -0x70(%rbp), %rax
addq %rax, %r14
addq %rax, %r15
addq %rax, %r12
cmpq -0x58(%rbp), %rdx
jge 0x1d36e
movq -0x48(%rbp), %r12
cmpq %rbx, %r12
jge 0x1d43b
movq -0x50(%rbp), %r13
movq %r13, %rdi
movq -0x38(%rbp), %rsi
movq %rbx, %rdx
movq %r14, %rcx
movq %r12, %r8
jmp 0x1d44f
movq -0x50(%rbp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq -0x38(%rbp), %rcx
movq %rbx, %r8
callq 0x1cd58
movq %r15, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x1bfa0
movq %rax, %rbx
movq -0x40(%rbp), %rax
leaq (%r15,%rax,8), %r14
movq -0x40(%rbp), %rax
leaq (,%rax,8), %rsi
addq %r13, %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x2f4c6
addq %rbx, (%r14)
jae 0x1d49a
addq $0x1, 0x8(%r14)
leaq 0x8(%r14), %r14
jb 0x1d48f
movq -0x40(%rbp), %rbx
jmp 0x1d7e8
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 0x30170
movq %rax, -0x48(%rbp)
movq -0x60(%rbp), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq -0x38(%rbp), %rcx
movq %rbx, %r8
callq 0x1e890
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 0x1d5fa
movq %rax, %rcx
movq %rbx, %r8
movq -0x48(%rbp), %r13
jmp 0x1d6ca
movq %r12, %rdx
movq %rbx, %r8
callq 0x20e88
jmp 0x1d7f4
movq %r12, %rdx
movq %r14, %r8
callq 0x20e88
movq %r15, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1bfa0
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 0x2f4c6
addq %r13, (%r14)
jae 0x1d579
addq $0x1, 0x8(%r14)
leaq 0x8(%r14), %r14
jb 0x1d56e
movq -0x40(%rbp), %rbx
jmp 0x1d7f4
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 0x2347c
jmp 0x1d7e8
movq -0x58(%rbp), %rdx
leaq (%rbx,%rdx,2), %rdx
cmpq %rdx, %rdi
jge 0x1d793
leaq (,%r12,4), %rdx
cmpq %rax, %rdx
jge 0x1d7b3
cmpq $0x98, %rbx
jg 0x1d7bc
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %r8
movq -0x30(%rbp), %r9
callq 0x66c6
jmp 0x1d7e8
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 0x1e890
movq %r15, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq -0x40(%rbp), %rcx
callq 0x1bfa0
movq %rax, -0x60(%rbp)
movq %r12, %rdi
movq -0x58(%rbp), %rsi
movq %rbx, %rdx
callq 0x2f4c6
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 0x1d6a9
addq $0x1, 0x8(%rax)
leaq 0x8(%rax), %rax
jb 0x1d69e
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 0x1d644
cmpq %r8, %rcx
movq %rcx, %r12
movq %r13, %rdi
jge 0x1d6e7
movq -0x38(%rbp), %rsi
movq %r8, %rbx
movq %r8, %rdx
movq %r10, %rcx
movq %r12, %r8
jmp 0x1d6f4
movq %r10, %rsi
movq %r12, %rdx
movq -0x38(%rbp), %rcx
movq %r8, %rbx
callq 0x1cd58
movq %r15, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x1bfa0
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 0x2f4c6
addq %rbx, (%r14)
jae 0x1d73a
addq $0x1, 0x8(%r14)
leaq 0x8(%r14), %r14
jb 0x1d72f
movq -0x160(%rbp), %rdi
testq %rdi, %rdi
je 0x1d579
callq 0x301a3
jmp 0x1d579
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 0x239ac
jmp 0x1d7e8
cmpq $0xae, %rbx
jle 0x1d7d3
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %r8
movq -0x30(%rbp), %r9
callq 0x22d28
jmp 0x1d7e8
cmpq $0xa0, %rbx
jle 0x1d7d3
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %r8
movq -0x30(%rbp), %r9
callq 0x22468
jmp 0x1d7e8
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %r8
movq -0x30(%rbp), %r9
callq 0x20e88
movq -0x160(%rbp), %rdi
testq %rdi, %rdi
jne 0x1d80b
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
callq 0x301a3
jmp 0x1d7f4
leaq -0x160(%rbp), %rdi
movq %rcx, %r13
callq 0x30170
movq %r13, %rcx
movq %rax, -0x30(%rbp)
jmp 0x1d049
leaq -0x160(%rbp), %rdi
movq %rcx, %r13
callq 0x30170
movq %r13, %rcx
movq %rax, -0x50(%rbp)
jmp 0x1d183
leaq -0x160(%rbp), %rdi
movq %rcx, %r13
callq 0x30170
movq %r13, %rcx
movq %rax, %r9
jmp 0x1cff8
nop