// File: /workspace/github_cpp_makefile_star2_O2/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 $0xc8, %rsp
movq %r9, -0xa8(%rbp)
movq %r8, %r14
movq %rcx, -0x68(%rbp)
movq %rdx, %r9
movq %rsi, %r15
movq %rdi, -0x88(%rbp)
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
movq %rax, %rdx
movq %rax, -0x58(%rbp)
leaq 0x1(%rax), %r13
leaq 0x4(,%rax,4), %rcx
movq %rcx, -0x78(%rbp)
subq %rcx, %r9
movq %r9, -0x90(%rbp)
andq $0x0, -0xb0(%rbp)
leaq 0x2(,%rax,2), %rax
movq %rax, -0x80(%rbp)
leaq 0x2(%rdx), %rcx
movq %rcx, -0x60(%rbp)
imulq $0x50, %rcx, %rsi
cmpq $0x7f00, %rsi           # imm = 0x7F00
ja 0x1e216
movq %rsp, %rax
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %rax
movq %rax, %rsp
subq -0x80(%rbp), %r14
movq %r14, -0x40(%rbp)
movq -0x60(%rbp), %rdx
leaq (%rax,%rdx,8), %rsi
leaq (%rsi,%rdx,8), %r14
leaq (%r14,%rdx,8), %r12
leaq (%r12,%rdx,8), %rbx
leaq (%rbx,%rdx,8), %rcx
movq %rcx, -0x98(%rbp)
leaq (%rcx,%rdx,8), %rcx
movq %rcx, -0xa0(%rbp)
subq $0x8, %rsp
pushq $0x4
popq %rdx
movq %rax, -0xe8(%rbp)
movq %rax, %rdi
movq %rsi, -0xe0(%rbp)
movq %r15, %rcx
movq %r13, %r8
movq -0x90(%rbp), %r9
pushq -0x88(%rbp)
callq 0x227d0
popq %rcx
popq %rdx
andl $0x2, %eax
movl %eax, -0x50(%rbp)
subq $0x8, %rsp
movq %r14, -0xc8(%rbp)
movq %r14, %rdi
movq %r12, -0xd0(%rbp)
movq %r12, %rsi
pushq $0x4
popq %rdx
movq %r15, %rcx
movq %r13, %r8
movq -0x90(%rbp), %r9
pushq -0x88(%rbp)
callq 0x22924
popq %rcx
popq %rdx
andl $0x1, %eax
movl %eax, -0x2c(%rbp)
leaq (%r15,%r13,8), %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r13, %rcx
callq 0x291c0
movq %rax, %r12
movq -0x80(%rbp), %rax
leaq (%r15,%rax,8), %rsi
movq %rbx, %rdi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x291c0
shlq $0x2, %r12
leaq (%r12,%rax,2), %r14
imulq $0x18, %r13, %rsi
addq %r15, %rsi
movq %rbx, %rdi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x291c0
movq %rax, %r12
addq %r14, %r12
movq -0x58(%rbp), %r14
movq -0x90(%rbp), %rax
cmpq %r14, %rax
movq %r15, -0xf0(%rbp)
movq %rbx, -0xd8(%rbp)
jle 0x1dddf
movq -0x78(%rbp), %rax
leaq (%r15,%rax,8), %rsi
movq %rbx, %rdi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x291c0
leaq (%rax,%r12,2), %rax
movq %rax, 0x8(%rbx,%r14,8)
jmp 0x1de35
movq %rax, %rcx
movq -0x78(%rbp), %rax
leaq (%r15,%rax,8), %rsi
movq %rbx, %rdi
movq %rbx, %rdx
movq %rcx, %r15
callq 0x291c0
movq %rax, -0x38(%rbp)
leaq (%rbx,%r15,8), %r14
movq %r13, %rdx
subq %r15, %rdx
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %r14, %rsi
callq 0x181a0
leaq (%rax,%r12,2), %rax
movq -0x58(%rbp), %rcx
movq %rax, 0x8(%rbx,%rcx,8)
movq -0x38(%rbp), %rax
addq %rax, (%r14)
jae 0x1de35
addq $0x1, 0x8(%r14)
leaq 0x8(%r14), %r14
jb 0x1de2a
movq -0x60(%rbp), %rax
movq -0xa0(%rbp), %r12
leaq (%r12,%rax,8), %rax
movq %rax, -0x38(%rbp)
movl -0x2c(%rbp), %eax
addl -0x50(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x68(%rbp), %r15
movq -0x80(%rbp), %rax
leaq (%r15,%rax,8), %rcx
movq -0x98(%rbp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %rcx, -0x50(%rbp)
movq -0x40(%rbp), %r8
callq 0x17c54
movq %rax, %r14
movq -0x58(%rbp), %rax
movq %r14, 0x8(%rbx,%rax,8)
leaq (%r15,%r13,8), %r15
testq %r14, %r14
jne 0x1deac
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x1ac5c
testl %eax, %eax
movq -0x98(%rbp), %rbx
js 0x1e1f2
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0x17ed0
subq %rax, %r14
movq -0x58(%rbp), %rax
movq %r14, 0x8(%r12,%rax,8)
movq %rax, %r14
movq -0x38(%rbp), %r12
movq -0x60(%rbp), %rax
leaq (%r12,%rax,8), %rax
movq %rax, -0x70(%rbp)
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, -0x48(%rbp)
movq %r15, %rdx
movq %r13, %rcx
callq 0x17cf0
addq %rax, 0x8(%rbx,%r14,8)
movq %r12, %rdi
movq -0x68(%rbp), %r15
movq %r15, %rsi
movq -0x50(%rbp), %rdx
movq -0x40(%rbp), %rbx
movq %rbx, %rcx
callq 0x29760
cmpq %r14, %rbx
jg 0x1df2b
leaq (%r12,%rbx,8), %rdi
leaq (%r15,%rbx,8), %rsi
movq %r13, %rdx
subq %rbx, %rdx
movq %rax, %rcx
callq 0x29e1c
movq %r12, %r15
movq %r13, %rdx
movq -0x70(%rbp), %rbx
movq -0x60(%rbp), %r14
leaq (%rbx,%r14,8), %rcx
movq %rcx, -0xc0(%rbp)
movq -0x58(%rbp), %r13
movq %rax, 0x8(%r12,%r13,8)
pushq $0x1
popq %rcx
movq -0x88(%rbp), %r12
movq %r12, %rdi
movq -0x48(%rbp), %rsi
movq %rdx, -0x38(%rbp)
callq 0x181a0
movq %rax, 0x8(%r12,%r13,8)
movq %r12, %r13
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x1ac5c
movq %rbx, %rdi
testl %eax, %eax
js 0x1df94
movq %r15, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x17ed0
jmp 0x1dfa6
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x17ed0
xorl $0x1, -0x2c(%rbp)
movq -0x40(%rbp), %r12
movq -0x68(%rbp), %rbx
movq %r15, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x17cf0
movq -0xc0(%rbp), %r13
movq %r13, %rdi
movq -0x48(%rbp), %rsi
movq %rbx, %rdx
movq -0x38(%rbp), %rcx
callq 0x291c0
movq %rax, -0x48(%rbp)
movq -0x58(%rbp), %rbx
movq %r13, %rdi
cmpq %rbx, %r12
jle 0x1e008
movq -0x50(%rbp), %rsi
movq %r13, %rdx
movq -0x38(%rbp), %rcx
callq 0x291c0
movq -0x48(%rbp), %rcx
leaq (%rax,%rcx,2), %rax
movq %rax, 0x8(%r13,%rbx,8)
jmp 0x1e068
movq -0x50(%rbp), %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x291c0
movq %rax, -0xb8(%rbp)
movq %r12, %rax
leaq (,%r12,8), %r12
addq %r13, %r12
movq -0x38(%rbp), %rdx
subq %rax, %rdx
pushq $0x1
popq %rcx
movq %r12, %rdi
movq %r12, %rsi
callq 0x181a0
movq -0x48(%rbp), %rcx
leaq (%rax,%rcx,2), %rax
movq %rax, 0x8(%r13,%rbx,8)
movq -0xb8(%rbp), %rax
addq %rax, (%r12)
jae 0x1e068
addq $0x1, 0x8(%r12)
leaq 0x8(%r12), %r12
jb 0x1e05b
movq -0xa8(%rbp), %r12
movq %r12, %rdi
movq -0xc8(%rbp), %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x19500
movq %r14, %r15
movq -0x80(%rbp), %r14
leaq (%r12,%r14,8), %rdi
addq $0x8, %rdi
movq %rdi, -0x48(%rbp)
movq -0xd0(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq %r15, %rcx
callq 0x19500
movq -0x78(%rbp), %rax
leaq (%r12,%rax,8), %rdi
addq $0x10, %rdi
movq %rdi, -0x70(%rbp)
movq -0xd8(%rbp), %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x19500
movq -0x38(%rbp), %r13
imulq $0x30, %r13, %r15
leaq (%r12,%r15), %rax
andq $0x0, 0x18(%rax,%r14,8)
leaq (%r12,%r15), %rdi
addq $0x18, %rdi
movq -0xa0(%rbp), %rdx
movq 0x8(%rdx,%rbx,8), %rax
xorl %ecx, %ecx
movq -0xe0(%rbp), %rsi
orq 0x8(%rsi,%rbx,8), %rax
setne %cl
addq %r13, %rcx
movq %rdi, -0x60(%rbp)
callq 0x19500
movq -0x88(%rbp), %r12
leaq (%r12,%r14,8), %rdi
andq $0x0, (%rdi,%r14,8)
movq -0x98(%rbp), %rdx
movq 0x8(%rdx,%rbx,8), %rax
xorl %ecx, %ecx
movq -0xe8(%rbp), %rsi
orq 0x8(%rsi,%rbx,8), %rax
setne %cl
addq %r13, %rcx
callq 0x19500
movq %r12, %rdi
movq -0xf0(%rbp), %rbx
movq %rbx, %rsi
movq -0x68(%rbp), %rdx
movq %r13, %rcx
callq 0x19500
addq %r12, %r15
movq -0x78(%rbp), %rax
leaq (%rbx,%rax,8), %rcx
movq -0x90(%rbp), %rbx
cmpq -0x40(%rbp), %rbx
jle 0x1e188
movq %r15, %rdi
movq %rcx, %rsi
movq %rbx, %rdx
movq -0x50(%rbp), %rcx
movq -0x40(%rbp), %r8
jmp 0x1e196
movq %r15, %rdi
movq -0x50(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rbx, %r8
callq 0x18a58
addq -0x40(%rbp), %rbx
movq %r13, %rax
shlq $0x6, %rax
movq -0xa8(%rbp), %r9
addq %r9, %rax
addq $0x20, %rax
subq $0x8, %rsp
movq %r12, %rdi
movq %r13, %rsi
movl -0x2c(%rbp), %edx
movq -0x48(%rbp), %rcx
movq -0x60(%rbp), %r8
pushq %rax
pushq %rbx
pushq -0x70(%rbp)
callq 0x23460
addq $0x20, %rsp
movq -0xb0(%rbp), %rdi
testq %rdi, %rdi
jne 0x1e227
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x17ed0
movq -0x58(%rbp), %r14
andq $0x0, 0x8(%r12,%r14,8)
xorl $0x2, -0x2c(%rbp)
jmp 0x1decc
leaq -0xb0(%rbp), %rdi
callq 0x29dc0
jmp 0x1dcad
callq 0x29df3
jmp 0x1e1e3
nop