// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/3rdparty/gmp/mpn/toom53_mul.c
// Function: _gmpn_toom53_mul
void
mpn_toom53_mul (mp_ptr pp,
		mp_srcptr ap, mp_size_t an,
		mp_srcptr bp, mp_size_t bn,
		mp_ptr scratch)
{
  mp_size_t n, s, t;
  mp_limb_t cy;
  mp_ptr gp;
  mp_ptr as1, asm1, as2, asm2, ash;
  mp_ptr bs1, bsm1, bs2, bsm2, bsh;
  mp_ptr tmp;
  enum toom7_flags flags;
  TMP_DECL;

#define a0  ap
#define a1  (ap + n)
#define a2  (ap + 2*n)
#define a3  (ap + 3*n)
#define a4  (ap + 4*n)
#define b0  bp
#define b1  (bp + n)
#define b2  (bp + 2*n)

  n = 1 + (3 * an >= 5 * bn ? (an - 1) / (size_t) 5 : (bn - 1) / (size_t) 3);

  s = an - 4 * n;
  t = bn - 2 * n;

  ASSERT (0 < s && s <= n);
  ASSERT (0 < t && t <= n);

  TMP_MARK;

  tmp = TMP_ALLOC_LIMBS (10 * (n + 1));
  as1  = tmp; tmp += n + 1;
  asm1 = tmp; tmp += n + 1;
  as2  = tmp; tmp += n + 1;
  asm2 = tmp; tmp += n + 1;
  ash  = tmp; tmp += n + 1;
  bs1  = tmp; tmp += n + 1;
  bsm1 = tmp; tmp += n + 1;
  bs2  = tmp; tmp += n + 1;
  bsm2 = tmp; tmp += n + 1;
  bsh  = tmp; tmp += n + 1;

  gp = pp;

  /* Compute as1 and asm1.  */
  flags = (enum toom7_flags) (toom7_w3_neg & mpn_toom_eval_pm1 (as1, asm1, 4, ap, n, s, gp));

  /* Compute as2 and asm2. */
  flags = (enum toom7_flags) (flags | (toom7_w1_neg & mpn_toom_eval_pm2 (as2, asm2, 4, ap, n, s, gp)));

  /* Compute ash = 16 a0 + 8 a1 + 4 a2 + 2 a3 + a4
     = 2*(2*(2*(2*a0 + a1) + a2) + a3) + a4  */
#if HAVE_NATIVE_mpn_addlsh1_n
  cy = mpn_addlsh1_n (ash, a1, a0, n);
  cy = 2*cy + mpn_addlsh1_n (ash, a2, ash, n);
  cy = 2*cy + mpn_addlsh1_n (ash, a3, ash, n);
  if (s < n)
    {
      mp_limb_t cy2;
      cy2 = mpn_addlsh1_n (ash, a4, ash, s);
      ash[n] = 2*cy + mpn_lshift (ash + s, ash + s, n - s, 1);
      MPN_INCR_U (ash + s, n+1-s, cy2);
    }
  else
    ash[n] = 2*cy + mpn_addlsh1_n (ash, a4, ash, n);
#else
  cy = mpn_lshift (ash, a0, n, 1);
  cy += mpn_add_n (ash, ash, a1, n);
  cy = 2*cy + mpn_lshift (ash, ash, n, 1);
  cy += mpn_add_n (ash, ash, a2, n);
  cy = 2*cy + mpn_lshift (ash, ash, n, 1);
  cy += mpn_add_n (ash, ash, a3, n);
  cy = 2*cy + mpn_lshift (ash, ash, n, 1);
  ash[n] = cy + mpn_add (ash, ash, n, a4, s);
#endif

  /* Compute bs1 and bsm1.  */
  bs1[n] = mpn_add (bs1, b0, n, b2, t);		/* b0 + b2 */
#if HAVE_NATIVE_mpn_add_n_sub_n
  if (bs1[n] == 0 && mpn_cmp (bs1, b1, n) < 0)
    {
      bs1[n] = mpn_add_n_sub_n (bs1, bsm1, b1, bs1, n) >> 1;
      bsm1[n] = 0;
      flags = (enum toom7_flags) (flags ^ toom7_w3_neg);
    }
  else
    {
      cy = mpn_add_n_sub_n (bs1, bsm1, bs1, b1, n);
      bsm1[n] = bs1[n] - (cy & 1);
      bs1[n] += (cy >> 1);
    }
#else
  if (bs1[n] == 0 && mpn_cmp (bs1, b1, n) < 0)
    {
      mpn_sub_n (bsm1, b1, bs1, n);
      bsm1[n] = 0;
      flags = (enum toom7_flags) (flags ^ toom7_w3_neg);
    }
  else
    {
      bsm1[n] = bs1[n] - mpn_sub_n (bsm1, bs1, b1, n);
    }
  bs1[n] += mpn_add_n (bs1, bs1, b1, n);  /* b0+b1+b2 */
#endif

  /* Compute bs2 and bsm2. */
#if HAVE_NATIVE_mpn_addlsh_n || HAVE_NATIVE_mpn_addlsh2_n
#if HAVE_NATIVE_mpn_addlsh2_n
  cy = mpn_addlsh2_n (bs2, b0, b2, t);
#else /* HAVE_NATIVE_mpn_addlsh_n */
  cy = mpn_addlsh_n (bs2, b0, b2, t, 2);
#endif
  if (t < n)
    cy = mpn_add_1 (bs2 + t, b0 + t, n - t, cy);
  bs2[n] = cy;
#else
  cy = mpn_lshift (gp, b2, t, 2);
  bs2[n] = mpn_add (bs2, b0, n, gp, t);
  MPN_INCR_U (bs2 + t, n+1-t, cy);
#endif

  gp[n] = mpn_lshift (gp, b1, n, 1);

#if HAVE_NATIVE_mpn_add_n_sub_n
  if (mpn_cmp (bs2, gp, n+1) < 0)
    {
      ASSERT_NOCARRY (mpn_add_n_sub_n (bs2, bsm2, gp, bs2, n+1));
      flags = (enum toom7_flags) (flags ^ toom7_w1_neg);
    }
  else
    {
      ASSERT_NOCARRY (mpn_add_n_sub_n (bs2, bsm2, bs2, gp, n+1));
    }
#else
  if (mpn_cmp (bs2, gp, n+1) < 0)
    {
      ASSERT_NOCARRY (mpn_sub_n (bsm2, gp, bs2, n+1));
      flags = (enum toom7_flags) (flags ^ toom7_w1_neg);
    }
  else
    {
      ASSERT_NOCARRY (mpn_sub_n (bsm2, bs2, gp, n+1));
    }
  mpn_add_n (bs2, bs2, gp, n+1);
#endif

  /* Compute bsh = 4 b0 + 2 b1 + b2 = 2*(2*b0 + b1)+b2.  */
#if HAVE_NATIVE_mpn_addlsh1_n
  cy = mpn_addlsh1_n (bsh, b1, b0, n);
  if (t < n)
    {
      mp_limb_t cy2;
      cy2 = mpn_addlsh1_n (bsh, b2, bsh, t);
      bsh[n] = 2*cy + mpn_lshift (bsh + t, bsh + t, n - t, 1);
      MPN_INCR_U (bsh + t, n+1-t, cy2);
    }
  else
    bsh[n] = 2*cy + mpn_addlsh1_n (bsh, b2, bsh, n);
#else
  cy = mpn_lshift (bsh, b0, n, 1);
  cy += mpn_add_n (bsh, bsh, b1, n);
  cy = 2*cy + mpn_lshift (bsh, bsh, n, 1);
  bsh[n] = cy + mpn_add (bsh, bsh, n, b2, t);
#endif

  ASSERT (as1[n] <= 4);
  ASSERT (bs1[n] <= 2);
  ASSERT (asm1[n] <= 2);
  ASSERT (bsm1[n] <= 1);
  ASSERT (as2[n] <= 30);
  ASSERT (bs2[n] <= 6);
  ASSERT (asm2[n] <= 20);
  ASSERT (bsm2[n] <= 4);
  ASSERT (ash[n] <= 30);
  ASSERT (bsh[n] <= 6);

#define v0    pp				/* 2n */
#define v1    (pp + 2 * n)			/* 2n+1 */
#define vinf  (pp + 6 * n)			/* s+t */
#define v2    scratch				/* 2n+1 */
#define vm2   (scratch + 2 * n + 1)		/* 2n+1 */
#define vh    (scratch + 4 * n + 2)		/* 2n+1 */
#define vm1   (scratch + 6 * n + 3)		/* 2n+1 */
#define scratch_out (scratch + 8 * n + 4)		/* 2n+1 */
  /* Total scratch need: 10*n+5 */

  /* Must be in allocation order, as they overwrite one limb beyond
   * 2n+1. */
  mpn_mul_n (v2, as2, bs2, n + 1);		/* v2, 2n+1 limbs */
  mpn_mul_n (vm2, asm2, bsm2, n + 1);		/* vm2, 2n+1 limbs */
  mpn_mul_n (vh, ash, bsh, n + 1);		/* vh, 2n+1 limbs */

  /* vm1, 2n+1 limbs */
#ifdef SMALLER_RECURSION
  mpn_mul_n (vm1, asm1, bsm1, n);
  if (asm1[n] == 1)
    {
      cy = bsm1[n] + mpn_add_n (vm1 + n, vm1 + n, bsm1, n);
    }
  else if (asm1[n] == 2)
    {
#if HAVE_NATIVE_mpn_addlsh1_n
      cy = 2 * bsm1[n] + mpn_addlsh1_n (vm1 + n, vm1 + n, bsm1, n);
#else
      cy = 2 * bsm1[n] + mpn_addmul_1 (vm1 + n, bsm1, n, CNST_LIMB(2));
#endif
    }
  else
    cy = 0;
  if (bsm1[n] != 0)
    cy += mpn_add_n (vm1 + n, vm1 + n, asm1, n);
  vm1[2 * n] = cy;
#else /* SMALLER_RECURSION */
  vm1[2 * n] = 0;
  mpn_mul_n (vm1, asm1, bsm1, n + ((asm1[n] | bsm1[n]) != 0));
#endif /* SMALLER_RECURSION */

  /* v1, 2n+1 limbs */
#ifdef SMALLER_RECURSION
  mpn_mul_n (v1, as1, bs1, n);
  if (as1[n] == 1)
    {
      cy = bs1[n] + mpn_add_n (v1 + n, v1 + n, bs1, n);
    }
  else if (as1[n] == 2)
    {
#if HAVE_NATIVE_mpn_addlsh1_n
      cy = 2 * bs1[n] + mpn_addlsh1_n (v1 + n, v1 + n, bs1, n);
#else
      cy = 2 * bs1[n] + mpn_addmul_1 (v1 + n, bs1, n, CNST_LIMB(2));
#endif
    }
  else if (as1[n] != 0)
    {
      cy = as1[n] * bs1[n] + mpn_addmul_1 (v1 + n, bs1, n, as1[n]);
    }
  else
    cy = 0;
  if (bs1[n] == 1)
    {
      cy += mpn_add_n (v1 + n, v1 + n, as1, n);
    }
  else if (bs1[n] == 2)
    {
#if HAVE_NATIVE_mpn_addlsh1_n
      cy += mpn_addlsh1_n (v1 + n, v1 + n, as1, n);
#else
      cy += mpn_addmul_1 (v1 + n, as1, n, CNST_LIMB(2));
#endif
    }
  v1[2 * n] = cy;
#else /* SMALLER_RECURSION */
  v1[2 * n] = 0;
  mpn_mul_n (v1, as1, bs1, n + ((as1[n] | bs1[n]) != 0));
#endif /* SMALLER_RECURSION */

  mpn_mul_n (v0, a0, b0, n);			/* v0, 2n limbs */

  /* vinf, s+t limbs */
  if (s > t)  mpn_mul (vinf, a4, s, b2, t);
  else        mpn_mul (vinf, b2, t, a4, s);

  mpn_toom_interpolate_7pts (pp, n, flags, vm2, vm1, v2, vh, s + t,
			     scratch_out);

  TMP_FREE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %r9, -0xd0(%rbp)
movq %r8, %rbx
movq %rcx, -0x68(%rbp)
movq %rdx, %r9
movq %rsi, -0xc0(%rbp)
movq %rdi, %r10
leaq (%rdx,%rdx,2), %rax
leaq (%r8,%r8,4), %rcx
xorl %edx, %edx
cmpq %rcx, %rax
setge %dl
movq %r9, %rax
cmovlq %r8, %rax
leaq 0x3(,%rdx,2), %rcx
decq %rax
xorl %edx, %edx
divq %rcx
leaq 0x1(%rax), %r13
leaq 0x4(,%rax,4), %rdx
movq %rdx, -0xb8(%rbp)
subq %rdx, %r9
leaq 0x2(,%rax,2), %rcx
movq %rcx, -0x90(%rbp)
movq $0x0, -0xd8(%rbp)
movq %rax, -0x50(%rbp)
leaq 0x2(%rax), %r14
movq %r14, %rax
shlq $0x4, %rax
leaq (%rax,%rax,4), %rsi
cmpq $0x7f00, %rsi           # imm = 0x7F00
ja 0x2274d
movq %rsp, %rdi
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %rdi
movq %rdi, %rsp
movq %r10, -0x70(%rbp)
movq %rbx, -0x60(%rbp)
subq -0x90(%rbp), %rbx
movq %rbx, -0x98(%rbp)
leaq (%rdi,%r14,8), %rsi
leaq (%rsi,%r14,8), %rbx
leaq (%rbx,%r14,8), %r15
leaq (%r15,%r14,8), %r12
leaq (%r12,%r14,8), %rax
movq %rax, -0x88(%rbp)
movq %r14, -0x40(%rbp)
leaq (%rax,%r14,8), %rax
movq %rax, -0x80(%rbp)
subq $0x8, %rsp
movq %rdi, -0x48(%rbp)
movq %rsi, -0xf8(%rbp)
movl $0x4, %edx
movq -0xc0(%rbp), %r14
movq %r14, %rcx
movq %r13, %r8
movq %r9, -0xc8(%rbp)
pushq %r10
callq 0x277e4
addq $0x10, %rsp
andl $0x2, %eax
movl %eax, -0x58(%rbp)
subq $0x8, %rsp
movq %rbx, -0xe0(%rbp)
movq %rbx, %rdi
movq %r15, -0xe8(%rbp)
movq %r15, %rsi
movl $0x4, %edx
movq %r14, %rcx
movq %r13, %r8
movq -0xc8(%rbp), %r15
movq %r15, %r9
pushq -0x70(%rbp)
callq 0x279c8
addq $0x10, %rsp
andl $0x1, %eax
movl %eax, -0x2c(%rbp)
leaq (%r14,%r13,8), %rsi
movq %r12, %rdi
movq %r14, %rdx
movq %r13, %rcx
callq 0x2f200
movq %rax, %rbx
movq -0x90(%rbp), %rax
leaq (%r14,%rax,8), %rsi
movq %r12, %rdi
movq %r12, %rdx
movq %r13, %rcx
callq 0x2f200
shlq $0x2, %rbx
leaq (%rbx,%rax,2), %rax
movq %rax, -0x38(%rbp)
leaq (,%r13,2), %rax
addq %r13, %rax
leaq (%r14,%rax,8), %rsi
movq %r12, %rdi
movq %r12, %rdx
movq %r13, %rcx
callq 0x2f200
movq %rax, %rbx
addq -0x38(%rbp), %rbx
movq -0xb8(%rbp), %rax
leaq (%r14,%rax,8), %rsi
movq -0x50(%rbp), %r14
cmpq %r14, %r15
movq %rsi, -0xa0(%rbp)
movq %r12, %rdi
movq %r12, %rdx
jle 0x220e6
movq %r13, %rcx
callq 0x2f200
leaq (%rax,%rbx,2), %rax
movq %rax, 0x8(%r12,%r14,8)
jmp 0x22129
movq %r15, %rcx
callq 0x2f200
movq %rax, -0x38(%rbp)
leaq (%r12,%r15,8), %rdi
movq %r13, %rdx
subq %r15, %rdx
movq %rdi, %rsi
movq %rdi, %r15
movl $0x1, %ecx
callq 0x1bf80
leaq (%rax,%rbx,2), %rax
movq %rax, 0x8(%r12,%r14,8)
movq -0x38(%rbp), %rax
addq %rax, (%r15)
jae 0x22129
addq $0x1, 0x8(%r15)
leaq 0x8(%r15), %r15
jb 0x2211e
movq -0x68(%rbp), %r10
movq %r14, %rbx
movq -0x40(%rbp), %rax
movq -0x80(%rbp), %rcx
leaq (%rcx,%rax,8), %rax
movq %rax, -0x38(%rbp)
movl -0x2c(%rbp), %r15d
addl -0x58(%rbp), %r15d
movq -0x90(%rbp), %rax
leaq (%r10,%rax,8), %rdx
movq -0x98(%rbp), %r14
testq %r14, %r14
movq -0x88(%rbp), %r9
movq %rdx, -0x58(%rbp)
movq %r12, -0xf0(%rbp)
movl %r15d, -0x2c(%rbp)
je 0x221dc
movq %r9, %rdi
movq %r10, %rsi
movq %r14, %rcx
movq %r10, %r12
callq 0x1ba80
movq %r12, %r10
movl -0x2c(%rbp), %r15d
movq -0x88(%rbp), %r9
movq %r14, %rcx
testq %rax, %rax
je 0x221de
leaq (%rbx,%rbx,2), %rax
movq -0x60(%rbp), %rcx
leaq (,%rcx,8), %rcx
leaq (%rcx,%rax,8), %rax
movq -0x48(%rbp), %rcx
addq %rcx, %rax
addq $0x40, %rax
movq %r14, %rcx
cmpq %rbx, %rcx
jg 0x22279
movq (%r10,%rcx,8), %rdx
incq %rcx
incq %rdx
movq %rdx, (%rax)
leaq 0x8(%rax), %rax
je 0x221be
jmp 0x221de
xorl %ecx, %ecx
cmpq %r10, %r9
je 0x22224
cmpq %rbx, %rcx
jg 0x22224
leaq (%rbx,%rbx,4), %rax
leaq (,%rcx,8), %rdx
leaq (%rdx,%rax,8), %rax
movq -0x48(%rbp), %rdx
leaq (%rdx,%rax), %rdi
addq $0x50, %rdi
leaq (%r10,%rcx,8), %rsi
movq %r13, %rdx
subq %rcx, %rdx
shlq $0x3, %rdx
movq %r10, %r14
callq 0x6200
movq %r14, %r10
movq -0x88(%rbp), %r9
movq $0x0, 0x8(%r9,%rbx,8)
leaq (%r10,%r13,8), %rsi
movq %rbx, %rax
shlq $0x4, %rax
addq %r10, %rax
addq $0x8, %rax
leaq (%rbx,%rbx,2), %rcx
shlq $0x4, %rcx
movq -0x48(%rbp), %rdx
addq %rdx, %rcx
addq $0x50, %rcx
xorl %ebx, %ebx
xorl %edx, %edx
leaq (%rdx,%r13), %rdi
testq %rdi, %rdi
jle 0x22287
movq (%rcx,%rdx,8), %rdi
movq (%rax,%rdx,8), %r8
decq %rdx
cmpq %r8, %rdi
je 0x22256
jbe 0x22718
xorl %ebx, %ebx
jmp 0x22287
movq $0x1, 0x8(%r9,%rbx,8)
movl $0x1, %ebx
leaq (%r10,%r13,8), %rdx
movq %r13, %r12
movq -0x80(%rbp), %r15
movq %r15, %rdi
movq %r9, %rsi
movq %r13, %rcx
movq %r9, %r14
callq 0x1bca0
subq %rax, %rbx
movq -0x50(%rbp), %rax
movq %rbx, 0x8(%r15,%rax,8)
movq %rax, %rbx
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %r13
leaq (,%rax,8), %rax
addq %r13, %rax
movq %rax, -0x78(%rbp)
movq -0x68(%rbp), %r15
leaq (%r15,%r12,8), %rdx
movq %r14, %rdi
movq %r14, %rsi
movq %rdx, -0xb0(%rbp)
movq %r12, %rcx
callq 0x1ba80
addq %rax, 0x8(%r14,%rbx,8)
movq %r13, %rdi
movq %r15, %rsi
movq -0x58(%rbp), %rdx
movq -0x98(%rbp), %r14
movq %r14, %rcx
callq 0x2f7a0
cmpq %rbx, %r14
movq %r12, -0xa8(%rbp)
jle 0x2231d
movq -0x40(%rbp), %r14
movq -0x70(%rbp), %r12
jmp 0x2243e
movq %r12, %rcx
subq %r14, %rcx
movq -0x68(%rbp), %r9
addq (%r9,%r14,8), %rax
movq %rax, (%r13,%r14,8)
movq -0x70(%rbp), %r12
jae 0x223e4
cmpq $0x2, %rcx
movl $0x1, %edi
cmovgeq %rcx, %rdi
movl $0x1, %eax
movq -0x60(%rbp), %rdx
leaq (,%rdx,8), %rdx
movq %rbx, %r8
shlq $0x4, %r8
leaq (%rbx,%rbx,4), %rsi
leaq (%rdx,%rsi,8), %rsi
subq %r8, %rdx
movq %r9, %r13
addq %rdx, %r9
addq $-0x8, %r9
movq -0x48(%rbp), %r8
leaq (%r8,%rsi), %r10
addq $0x68, %r10
decq %rdi
xorl %r11d, %r11d
movq -0x40(%rbp), %r14
cmpq %r11, %rdi
je 0x2243e
movq (%r9,%r11,8), %rbx
leaq 0x1(%r11), %r8
incq %rbx
movq %rbx, (%r10,%r11,8)
movq -0x50(%rbp), %rbx
movq %r8, %r11
je 0x2238a
xorl %eax, %eax
cmpq %r13, -0x38(%rbp)
je 0x2243e
leaq 0x1(%r8), %rdi
cmpq %rcx, %rdi
jge 0x2243e
addq -0x48(%rbp), %rsi
leaq (%rsi,%r8,8), %rdi
addq $0x68, %rdi
addq %r13, %rdx
leaq (%rdx,%r8,8), %rsi
addq $-0x8, %rsi
leaq (%rbx,%rbx,2), %rax
subq -0x60(%rbp), %rax
subq %r8, %rax
jmp 0x2242f
xorl %eax, %eax
cmpq $0x2, %rcx
movq -0x40(%rbp), %r14
jl 0x2243e
cmpq %r9, -0x38(%rbp)
je 0x2243e
leaq (%rbx,%rbx,4), %rax
movq -0x60(%rbp), %rdx
leaq (,%rdx,8), %rcx
leaq (%rcx,%rax,8), %rax
movq -0x48(%rbp), %rsi
leaq (%rsi,%rax), %rdi
addq $0x68, %rdi
movq %rbx, %rax
shlq $0x4, %rax
subq %rax, %rcx
leaq (%rcx,%r9), %rsi
addq $-0x8, %rsi
leaq (%rbx,%rbx,2), %rax
subq %rdx, %rax
leaq 0x10(,%rax,8), %rdx
callq 0x6200
xorl %eax, %eax
movq -0x78(%rbp), %rcx
leaq (%rcx,%r14,8), %r15
movq -0x38(%rbp), %rcx
movq %rax, 0x8(%rcx,%rbx,8)
movq %r12, %rdi
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movl $0x1, %ecx
callq 0x1bf80
movq %rax, 0x8(%r12,%rbx,8)
movq %rbx, %rax
shlq $0x6, %rax
movq -0x48(%rbp), %rcx
addq %rcx, %rax
addq $0x78, %rax
movq %r14, %rcx
testq %rcx, %rcx
jle 0x2249f
movq -0x8(%r12,%rcx,8), %rdx
decq %rcx
leaq -0x8(%rax), %rsi
cmpq %rdx, (%rax)
movq %rsi, %rax
je 0x22484
jbe 0x224b7
movq -0x78(%rbp), %rdi
movq -0x38(%rbp), %r13
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x1bca0
jmp 0x224d1
movq -0x78(%rbp), %rdi
movq %r12, %rsi
movq -0x38(%rbp), %r13
movq %r13, %rdx
movq %r14, %rcx
callq 0x1bca0
xorl $0x1, -0x2c(%rbp)
movq %r13, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x1ba80
movq %r15, %r12
movq %r15, %rdi
movq -0xb0(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq -0xa8(%rbp), %r15
movq %r15, %rcx
callq 0x2f200
movq %rax, %r13
movq -0x98(%rbp), %r14
cmpq %rbx, %r14
movq %r12, -0x60(%rbp)
movq %r12, %rdi
jle 0x22535
movq -0x58(%rbp), %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x2f200
leaq (%rax,%r13,2), %rax
movq %rax, 0x8(%r12,%rbx,8)
movq %rbx, %r14
jmp 0x22585
movq -0x58(%rbp), %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x2f200
movq %rax, -0x50(%rbp)
movq %r14, %rax
movq %rbx, %r14
leaq (%r12,%rax,8), %rbx
movq %r15, %rdx
subq %rax, %rdx
movq %rbx, %rdi
movq %rbx, %rsi
movl $0x1, %ecx
callq 0x1bf80
leaq (%rax,%r13,2), %rax
movq %rax, 0x8(%r12,%r14,8)
movq -0x50(%rbp), %rax
addq %rax, (%rbx)
jae 0x22585
addq $0x1, 0x8(%rbx)
leaq 0x8(%rbx), %rbx
jb 0x2257a
movq %r15, %r12
movq -0xd0(%rbp), %rbx
movq %rbx, %rdi
movq -0xe0(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %r13
movq %r13, %rcx
callq 0x1d348
movq -0x90(%rbp), %r15
leaq (%rbx,%r15,8), %rdi
addq $0x8, %rdi
movq %rdi, -0x50(%rbp)
movq -0xe8(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq %r13, %rcx
callq 0x1d348
movq -0xb8(%rbp), %rax
leaq (%rbx,%rax,8), %rdi
addq $0x10, %rdi
movq %rdi, -0x38(%rbp)
movq -0xf0(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq %r13, %rcx
callq 0x1d348
movq %r12, %rax
shlq $0x4, %rax
leaq (%rax,%rax,2), %r13
leaq (%rbx,%r13), %rax
leaq (%rbx,%r13), %rdi
addq $0x18, %rdi
xorl %ecx, %ecx
movq %rcx, 0x18(%rax,%r15,8)
movq -0x80(%rbp), %rdx
movq 0x8(%rdx,%r14,8), %rax
xorl %ecx, %ecx
movq -0xf8(%rbp), %rsi
orq 0x8(%rsi,%r14,8), %rax
setne %cl
addq %r12, %rcx
movq %rdi, -0x40(%rbp)
callq 0x1d348
movq -0x70(%rbp), %rbx
leaq (%rbx,%r15,8), %rdi
xorl %eax, %eax
movq %rax, (%rdi,%r15,8)
movq -0x88(%rbp), %rdx
movq 0x8(%rdx,%r14,8), %rax
xorl %ecx, %ecx
movq -0x48(%rbp), %rsi
orq 0x8(%rsi,%r14,8), %rax
setne %cl
addq %r12, %rcx
callq 0x1d348
movq %rbx, %rdi
movq -0xc0(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq %r12, %rcx
callq 0x1d348
addq %rbx, %r13
movq -0xc8(%rbp), %rbx
movq -0x98(%rbp), %r14
movq %r13, %rdi
cmpq %r14, %rbx
jle 0x226ab
movq -0xa0(%rbp), %rsi
movq %rbx, %rdx
movq -0x58(%rbp), %rcx
movq %r14, %r8
jmp 0x226bc
movq -0x58(%rbp), %rsi
movq %r14, %rdx
movq -0xa0(%rbp), %rcx
movq %rbx, %r8
callq 0x1c838
movl -0x2c(%rbp), %edx
addq %r14, %rbx
movq %r12, %rax
shlq $0x6, %rax
movq -0xd0(%rbp), %r9
addq %r9, %rax
addq $0x20, %rax
subq $0x8, %rsp
movq -0x70(%rbp), %rdi
movq %r12, %rsi
movq -0x50(%rbp), %rcx
movq -0x40(%rbp), %r8
pushq %rax
pushq %rbx
pushq -0x38(%rbp)
callq 0x286ac
addq $0x20, %rsp
movq -0xd8(%rbp), %rdi
testq %rdi, %rdi
jne 0x2276d
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %r12
movl %r15d, %r13d
movq -0x80(%rbp), %r15
movq %r15, %rdi
movq %r9, %rdx
movq %r12, %rcx
movq %r9, %r14
callq 0x1bca0
movq -0x50(%rbp), %rbx
movq $0x0, 0x8(%r15,%rbx,8)
xorl $0x2, %r13d
movl %r13d, -0x2c(%rbp)
jmp 0x222b2
leaq -0xd8(%rbp), %rdi
movq %r9, %r15
movq %r10, %r12
callq 0x2fdb0
movq %r12, %r10
movq %r15, %r9
movq %rax, %rdi
jmp 0x21f9f
callq 0x2fde3
jmp 0x22709