LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: marxn[P]pupp/3rdparty/gmp/mpn/toom63_mul.c
// Function: abs_sub_n
static int
abs_sub_n (mp_ptr rp, mp_srcptr ap, mp_srcptr bp, mp_size_t n)
{
  mp_limb_t  x, y;
  while (--n >= 0)
    {
      x = ap[n];
      y = bp[n];
      if (x != y)
	{
	  n++;
	  if (x > y)
	    {
	      mpn_sub_n (rp, ap, bp, n);
	      return 0;
	    }
	  else
	    {
	      mpn_sub_n (rp, bp, ap, n);
	      return ~0;
	    }
	}
      rp[n] = 0;
    }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jl 0x4291f
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x4290a
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jbe 0x428ec
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x36fe0
movl $0x0, -0x4(%rbp)
jmp 0x42926
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x36fe0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x42926
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
jmp 0x42878
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: marxn[P]pupp/3rdparty/gmp/mpn/toom_couple_handling.c
// Function: _gmpn_toom_couple_handling
void
mpn_toom_couple_handling (mp_ptr pp, mp_size_t n, mp_ptr np,
			  int nsign, mp_size_t off, int ps, int ns)
{
  if (nsign) {
#ifdef HAVE_NATIVE_mpn_rsh1sub_n
    mpn_rsh1sub_n (np, pp, np, n);
#else
    mpn_sub_n (np, pp, np, n);
    mpn_rshift (np, np, n, 1);
#endif
  } else {
#ifdef HAVE_NATIVE_mpn_rsh1add_n
    mpn_rsh1add_n (np, pp, np, n);
#else
    mpn_add_n (np, pp, np, n);
    mpn_rshift (np, np, n, 1);
#endif
  }

#ifdef HAVE_NATIVE_mpn_rsh1sub_n
  if (ps == 1)
    mpn_rsh1sub_n (pp, pp, np, n);
  else
#endif
  {
    mpn_sub_n (pp, pp, np, n);
    if (ps > 0)
      mpn_rshift (pp, pp, n, ps);
  }
  if (ns > 0)
    mpn_rshift (np, np, n, ns);
  pp[n] = mpn_add_n (pp+off, pp+off, np, n-off);
  ASSERT_NOCARRY (mpn_add_1(pp+n, np+n-off, off, pp[n]) );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x48bff
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x55a30
jmp 0x48c14
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x558f0
cmpl $0x1, -0x2c(%rbp)
jne 0x48c31
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x55a30
jmp 0x48c62
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x36fe0
cmpl $0x0, -0x2c(%rbp)
jle 0x48c60
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x56880
jmp 0x48c62
cmpl $0x0, 0x10(%rbp)
jle 0x48c7c
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl 0x10(%rbp), %ecx
callq 0x56880
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
subq -0x28(%rbp), %rcx
callq 0x36c80
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
xorl %eax, %eax
subq -0x28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
callq 0x564f0
addq $0x30, %rsp
popq %rbp
retq
// File: marxn[P]pupp/3rdparty/gmp/mpn/toom_eval_dgr3_pm1.c
// Function: _gmpn_toom_eval_dgr3_pm1
int
mpn_toom_eval_dgr3_pm1 (mp_ptr xp1, mp_ptr xm1,
			mp_srcptr xp, mp_size_t n, mp_size_t x3n, mp_ptr tp)
{
  int neg;

  ASSERT (x3n > 0);
  ASSERT (x3n <= n);

  xp1[n] = mpn_add_n (xp1, xp, xp + 2*n, n);
  tp[n] = mpn_add (tp, xp + n, n, xp + 3*n, x3n);

  neg = (mpn_cmp (xp1, tp, n + 1) < 0) ? ~0 : 0;

#if HAVE_NATIVE_mpn_add_n_sub_n
  if (neg)
    mpn_add_n_sub_n (xp1, xm1, tp, xp1, n + 1);
  else
    mpn_add_n_sub_n (xp1, xm1, xp1, tp, n + 1);
#else
  if (neg)
    mpn_sub_n (xm1, tp, xp1, n + 1);
  else
    mpn_sub_n (xm1, xp1, tp, n + 1);

  mpn_add_n (xp1, xp1, tp, n + 1);
#endif

  ASSERT (xp1[n] <= 3);
  ASSERT (xm1[n] <= 1);

  return neg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
jmp 0x49ae2
jmp 0x49ae4
jmp 0x49ae6
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
shlq %rax
shlq $0x3, %rax
addq %rax, %rdx
movq -0x20(%rbp), %rcx
callq 0x36c80
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
imulq $0x3, -0x20(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x28(%rbp), %r8
callq 0x36b60
movq %rax, %rdx
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x1, %rdx
callq 0x3b060
movl %eax, %edx
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x0, %edx
cmovll %ecx, %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x49b9f
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq -0x20(%rbp), %rcx
addq $0x1, %rcx
callq 0x36fe0
jmp 0x49bb8
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rcx
addq $0x1, %rcx
callq 0x36fe0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rcx
addq $0x1, %rcx
callq 0x36c80
jmp 0x49bd3
jmp 0x49bd5
jmp 0x49bd7
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: marxn[P]pupp/3rdparty/gmp/mpn/mulmod_bnm1.c
// Function: _gmpn_bc_mulmod_bnm1
void
mpn_bc_mulmod_bnm1 (mp_ptr rp, mp_srcptr ap, mp_srcptr bp, mp_size_t rn,
		    mp_ptr tp)
{
  mp_limb_t cy;

  ASSERT (0 < rn);

  mpn_mul_n (tp, ap, bp, rn);
  cy = mpn_add_n (rp, tp, tp + rn, rn);
  /* If cy == 1, then the value of rp is at most B^rn - 2, so there can
   * be no overflow when adding in the carry. */
  MPN_INCR_U (rp, rn, cy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
jmp 0x4e0ee
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x39000
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
movq -0x20(%rbp), %rcx
callq 0x36c80
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
addq %rcx, (%rax)
jae 0x4e13f
addq $0x1, 0x8(%rax)
leaq 0x8(%rax), %rax
jb 0x4e134
movq %rax, -0x38(%rbp)
jmp 0x4e145
jmp 0x4e147
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: marxn[P]pupp/3rdparty/gmp/mpn/mulmod_bnm1.c
// Function: mpn_bc_mulmod_bnp1
static void
mpn_bc_mulmod_bnp1 (mp_ptr rp, mp_srcptr ap, mp_srcptr bp, mp_size_t rn,
		    mp_ptr tp)
{
  mp_limb_t cy;

  ASSERT (0 < rn);

  mpn_mul_n (tp, ap, bp, rn + 1);
  ASSERT (tp[2*rn+1] == 0);
  ASSERT (tp[2*rn] < GMP_NUMB_MAX);
  cy = tp[2*rn] + mpn_sub_n (rp, tp, tp+rn, rn);
  rp[rn] = 0;
  MPN_INCR_U (rp, rn+1, cy );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
jmp 0x4ea9e
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
addq $0x1, %rcx
callq 0x39000
jmp 0x4eab9
jmp 0x4eabb
jmp 0x4eabd
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
movq -0x20(%rbp), %rcx
callq 0x36fe0
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
addq %rcx, (%rax)
jae 0x4eb26
addq $0x1, 0x8(%rax)
leaq 0x8(%rax), %rax
jb 0x4eb1b
movq %rax, -0x38(%rbp)
jmp 0x4eb2c
jmp 0x4eb2e
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/mpn/mulmod_bnm1.c
// Function: _gmpn_mulmod_bnm1_next_size
mp_size_t
mpn_mulmod_bnm1_next_size (mp_size_t n)
{
  mp_size_t nh;

  if (BELOW_THRESHOLD (n,     MULMOD_BNM1_THRESHOLD))
    return n;
  if (BELOW_THRESHOLD (n, 4 * (MULMOD_BNM1_THRESHOLD - 1) + 1))
    return (n + (2-1)) & (-2);
  if (BELOW_THRESHOLD (n, 8 * (MULMOD_BNM1_THRESHOLD - 1) + 1))
    return (n + (4-1)) & (-4);

  nh = (n + 1) >> 1;

  if (BELOW_THRESHOLD (nh, MUL_FFT_MODF_THRESHOLD))
    return (n + (8-1)) & (-8);

  return 2 * mpn_fft_next_size (nh, mpn_fft_best_k (nh, 0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x12, -0x10(%rbp)
jge 0x4eb60
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4ebe5
cmpq $0x45, -0x10(%rbp)
jge 0x4eb79
movq -0x10(%rbp), %rax
addq $0x1, %rax
andq $-0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x4ebe5
cmpq $0x89, -0x10(%rbp)
jge 0x4eb95
movq -0x10(%rbp), %rax
addq $0x3, %rax
andq $-0x4, %rax
movq %rax, -0x8(%rbp)
jmp 0x4ebe5
movq -0x10(%rbp), %rax
addq $0x1, %rax
sarq %rax
movq %rax, -0x18(%rbp)
cmpq $0x28e, -0x18(%rbp)     # imm = 0x28E
jge 0x4ebc0
movq -0x10(%rbp), %rax
addq $0x7, %rax
andq $-0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x4ebe5
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x56ab0
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x56b40
shlq %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: marxn[P]pupp/3rdparty/gmp/mpn/sqrmod_bnm1.c
// Function: mpn_bc_sqrmod_bnm1
static void
mpn_bc_sqrmod_bnm1 (mp_ptr rp, mp_srcptr ap, mp_size_t rn, mp_ptr tp)
{
  mp_limb_t cy;

  ASSERT (0 < rn);

  mpn_sqr (tp, ap, rn);
  cy = mpn_add_n (rp, tp, tp + rn, rn);
  /* If cy == 1, then the value of rp is at most B^rn - 2, so there can
   * be no overflow when adding in the carry. */
  MPN_INCR_U (rp, rn, cy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0x4f29a
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x392b0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
movq -0x18(%rbp), %rcx
callq 0x36c80
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
addq %rcx, (%rax)
jae 0x4f2e7
addq $0x1, 0x8(%rax)
leaq 0x8(%rax), %rax
jb 0x4f2dc
movq %rax, -0x30(%rbp)
jmp 0x4f2ed
jmp 0x4f2ef
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/mpn/sqrmod_bnm1.c
// Function: mpn_bc_sqrmod_bnp1
static void
mpn_bc_sqrmod_bnp1 (mp_ptr rp, mp_srcptr ap, mp_size_t rn, mp_ptr tp)
{
  mp_limb_t cy;

  ASSERT (0 < rn);

  mpn_sqr (tp, ap, rn + 1);
  ASSERT (tp[2*rn+1] == 0);
  ASSERT (tp[2*rn] < GMP_NUMB_MAX);
  cy = tp[2*rn] + mpn_sub_n (rp, tp, tp+rn, rn);
  rp[rn] = 0;
  MPN_INCR_U (rp, rn+1, cy );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0x4f31a
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x1, %rdx
callq 0x392b0
jmp 0x4f331
jmp 0x4f333
jmp 0x4f335
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
shlq %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
movq -0x18(%rbp), %rcx
callq 0x36fe0
movq %rax, %rcx
movq -0x38(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
addq %rcx, (%rax)
jae 0x4f39e
addq $0x1, 0x8(%rax)
leaq 0x8(%rax), %rax
jb 0x4f393
movq %rax, -0x30(%rbp)
jmp 0x4f3a4
jmp 0x4f3a6
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: marxn[P]pupp/3rdparty/gmp/mpn/sqrmod_bnm1.c
// Function: _gmpn_sqrmod_bnm1_next_size
mp_size_t
mpn_sqrmod_bnm1_next_size (mp_size_t n)
{
  mp_size_t nh;

  if (BELOW_THRESHOLD (n,     SQRMOD_BNM1_THRESHOLD))
    return n;
  if (BELOW_THRESHOLD (n, 4 * (SQRMOD_BNM1_THRESHOLD - 1) + 1))
    return (n + (2-1)) & (-2);
  if (BELOW_THRESHOLD (n, 8 * (SQRMOD_BNM1_THRESHOLD - 1) + 1))
    return (n + (4-1)) & (-4);

  nh = (n + 1) >> 1;

  if (BELOW_THRESHOLD (nh, SQR_FFT_MODF_THRESHOLD))
    return (n + (8-1)) & (-8);

  return 2 * mpn_fft_next_size (nh, mpn_fft_best_k (nh, 1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x16, -0x10(%rbp)
jge 0x4f3d0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4f458
cmpq $0x55, -0x10(%rbp)
jge 0x4f3e9
movq -0x10(%rbp), %rax
addq $0x1, %rax
andq $-0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x4f458
cmpq $0xa9, -0x10(%rbp)
jge 0x4f405
movq -0x10(%rbp), %rax
addq $0x3, %rax
andq $-0x4, %rax
movq %rax, -0x8(%rbp)
jmp 0x4f458
movq -0x10(%rbp), %rax
addq $0x1, %rax
sarq %rax
movq %rax, -0x18(%rbp)
cmpq $0x23a, -0x18(%rbp)     # imm = 0x23A
jge 0x4f430
movq -0x10(%rbp), %rax
addq $0x7, %rax
andq $-0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x4f458
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x56ab0
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x56b40
shlq %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: marxn[P]pupp/3rdparty/gmp/mpn/mu_div_qr.c
// Function: _gmpn_mu_div_qr_choose_in
mp_size_t
mpn_mu_div_qr_choose_in (mp_size_t qn, mp_size_t dn, int k)
{
  mp_size_t in;

  if (k == 0)
    {
      mp_size_t b;
      if (qn > dn)
	{
	  /* Compute an inverse size that is a nice partition of the quotient.  */
	  b = (qn - 1) / dn + 1;	/* ceil(qn/dn), number of blocks */
	  in = (qn - 1) / b + 1;	/* ceil(qn/b) = ceil(qn / ceil(qn/dn)) */
	}
      else if (3 * qn > dn)
	{
	  in = (qn - 1) / 2 + 1;	/* b = 2 */
	}
      else
	{
	  in = (qn - 1) / 1 + 1;	/* b = 1 */
	}
    }
  else
    {
      mp_size_t xn;
      xn = MIN (dn, qn);
      in = (xn - 1) / k + 1;
    }

  return in;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x54152
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jle 0x5410d
movq -0x8(%rbp), %rax
subq $0x1, %rax
cqto
idivq -0x10(%rbp)
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
subq $0x1, %rax
cqto
idivq -0x28(%rbp)
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x54150
imulq $0x3, -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jle 0x54134
movq -0x8(%rbp), %rax
subq $0x1, %rax
movl $0x2, %ecx
cqto
idivq %rcx
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5414e
movq -0x8(%rbp), %rax
subq $0x1, %rax
movl $0x1, %ecx
cqto
idivq %rcx
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x54150
jmp 0x5418f
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
jge 0x54166
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x5416e
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
subq $0x1, %rax
movslq -0x14(%rbp), %rcx
cqto
idivq %rcx
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/mpn/mu_div_qr.c
// Function: _gmpn_mu_div_qr_itch
mp_size_t
mpn_mu_div_qr_itch (mp_size_t nn, mp_size_t dn, int mua_k)
{
  mp_size_t in = mpn_mu_div_qr_choose_in (nn - dn, dn, mua_k);
  mp_size_t itch_preinv = mpn_preinv_mu_div_qr_itch (nn, dn, in);
  mp_size_t itch_invapp = mpn_invertappr_itch (in + 1) + in + 2; /* 3in + 4 */

  ASSERT (itch_preinv >= itch_invapp);
  return in + MAX (itch_invapp, itch_preinv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
subq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x540c0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x54230
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
shlq %rax
addq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x30(%rbp)
jmp 0x541f9
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jle 0x54215
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x5421d
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
addq %rcx, %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: marxn[P]pupp/3rdparty/gmp/mpn/mu_divappr_q.c
// Function: _gmpn_mu_divappr_q_itch
mp_size_t
mpn_mu_divappr_q_itch (mp_size_t nn, mp_size_t dn, int mua_k)
{
  mp_size_t qn, in, itch_local, itch_out, itch_invapp;

  qn = nn - dn;
  if (qn + 1 < dn)
    {
      dn = qn + 1;
    }
  in = mpn_mu_divappr_q_choose_in (qn, dn, mua_k);

  itch_local = mpn_mulmod_bnm1_next_size (dn + 1);
  itch_out = mpn_mulmod_bnm1_itch (itch_local, dn, in);
  itch_invapp = mpn_invertappr_itch (in + 1) + in + 2; /* 3in + 4 */

  ASSERT (dn + itch_local + itch_out >= itch_invapp);
  return in + MAX (dn + itch_local + itch_out, itch_invapp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
subq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
cmpq -0x10(%rbp), %rax
jge 0x54d09
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x545a0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0x4eb40
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x54db0
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
shlq %rax
addq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x40(%rbp)
jmp 0x54d5c
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
addq -0x30(%rbp), %rax
addq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jle 0x54d88
movq -0x10(%rbp), %rax
addq -0x30(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x54d90
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rcx
addq %rcx, %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/mpn/mu_div_q.c
// Function: _gmpn_mu_div_q_itch
mp_size_t
mpn_mu_div_q_itch (mp_size_t nn, mp_size_t dn, int mua_k)
{
  mp_size_t qn;

  qn = nn - dn;
  if (qn >= dn)
    {
      return mpn_mu_divappr_q_itch (nn + 1, dn, mua_k);
    }
  else
    {
      return mpn_mu_divappr_q_itch (2 * qn + 2, qn + 1, mua_k);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jl 0x55323
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x54cd0
movq %rax, -0x8(%rbp)
jmp 0x55342
movq -0x28(%rbp), %rdi
shlq %rdi
addq $0x2, %rdi
movq -0x28(%rbp), %rsi
addq $0x1, %rsi
movl -0x1c(%rbp), %edx
callq 0x54cd0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: marxn[P]pupp/3rdparty/gmp/printf/snprintf.c
// Function: _gmp_snprintf
int
gmp_snprintf (char *buf, size_t size, const char *fmt, ...)
{
  struct gmp_snprintf_t d;
  va_list  ap;
  int      ret;

  va_start (ap, fmt);
  d.buf = buf;
  d.size = size;

  ASSERT (! MEM_OVERLAP_P (buf, size, fmt, strlen(fmt)+1));

  ret = __gmp_doprnt (&__gmp_snprintf_funs, &d, fmt, ap);
  va_end (ap);
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x55ebe
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x40(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x55f15
movq -0x18(%rbp), %rdx
leaq 0x1fe38(%rip), %rdi     # 0x75d58
leaq -0x28(%rbp), %rsi
leaq -0x40(%rbp), %rcx
callq 0x59d30
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopl (%rax)
// File: marxn[P]pupp/3rdparty/gmp/printf/snprntffuns.c
// Function: gmp_snprintf_memory
static int
gmp_snprintf_memory (struct gmp_snprintf_t *d, const char *str, size_t len)
{
  size_t n;

  ASSERT (d->size >= 0);

  if (d->size > 1)
    {
      n = MIN (d->size-1, len);
      memcpy (d->buf, str, n);
      d->buf += n;
      d->size -= n;
    }
  return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x560f6
movq -0x8(%rbp), %rax
cmpq $0x1, 0x8(%rax)
jbe 0x5616a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
subq $0x1, %rax
cmpq -0x18(%rbp), %rax
jae 0x56125
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
subq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x5612d
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x6270
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/printf/snprntffuns.c
// Function: gmp_snprintf_reps
static int
gmp_snprintf_reps (struct gmp_snprintf_t *d, int c, int reps)
{
  size_t n;

  ASSERT (reps >= 0);
  ASSERT (d->size >= 0);

  if (d->size > 1)
    {
      n = MIN (d->size-1, reps);
      memset (d->buf, c, n);
      d->buf += n;
      d->size -= n;
    }
  return reps;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
jmp 0x56194
jmp 0x56196
jmp 0x56198
movq -0x8(%rbp), %rax
cmpq $0x1, 0x8(%rax)
jbe 0x56211
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
subq $0x1, %rax
movslq -0x10(%rbp), %rcx
cmpq %rcx, %rax
jae 0x561ca
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
subq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x561d2
movslq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rdx
movzbl %al, %esi
callq 0x61a0
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/assert.c
// Function: _gmp_assert_header
void
__gmp_assert_header (const char *filename, int linenum)
{
  if (filename != NULL && filename[0] != '\0')
    {
      fprintf (stderr, "%s:", filename);
      if (linenum != -1)
        fprintf (stderr, "%d: ", linenum);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x562b1
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x562b1
movq 0x1fd57(%rip), %rax     # 0x75fd0
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0xd8d4(%rip), %rsi      # 0x63b5b
movb $0x0, %al
callq 0x6490
cmpl $-0x1, -0xc(%rbp)
je 0x562af
movq 0x1fd35(%rip), %rax     # 0x75fd0
movq (%rax), %rdi
movl -0xc(%rbp), %edx
leaq 0xd8b7(%rip), %rsi      # 0x63b5f
movb $0x0, %al
callq 0x6490
jmp 0x562b1
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/tal-reent.c
// Function: _gmp_tmp_reentrant_alloc
void *
__gmp_tmp_reentrant_alloc (struct tmp_reentrant_t **markp, size_t size)
{
  char    *p;
  size_t  total_size;

#define P   ((struct tmp_reentrant_t *) p)

  total_size = size + HSIZ;
  p = (char *) (*__gmp_allocate_func) (total_size);
  P->size = total_size;
  P->next = *markp;
  *markp = P;
  return p + HSIZ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
leaq 0x1fecd(%rip), %rax     # 0x76320
movq (%rax), %rax
movq -0x20(%rbp), %rdi
callq *%rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x10, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/tal-reent.c
// Function: _gmp_tmp_reentrant_free
void
__gmp_tmp_reentrant_free (struct tmp_reentrant_t *mark)
{
  struct tmp_reentrant_t  *next;

  while (mark != NULL)
    {
      next = mark->next;
      (*__gmp_free_func) ((char *) mark, mark->size);
      mark = next;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x564e0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
leaq 0x1fe6b(%rip), %rax     # 0x76330
movq (%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rsi
callq *%rax
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x564ac
addq $0x10, %rsp
popq %rbp
retq
nop
nopl (%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/mpn/mul_fft.c
// Function: _gmpn_fft_best_k
int
mpn_fft_best_k (mp_size_t n, int sqr)
{
  const struct fft_table_nk *fft_tab, *tab;
  mp_size_t tab_n, thres;
  int last_k;

  fft_tab = mpn_fft_table3[sqr];
  last_k = fft_tab->k;
  for (tab = fft_tab + 1; ; tab++)
    {
      tab_n = tab->n;
      thres = tab_n << last_k;
      if (n <= thres)
	break;
      last_k = tab->k;
    }
  return last_k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0xd5fa(%rip), %rax      # 0x640c0
imulq $0x358, %rcx, %rcx      # imm = 0x358
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x1b, %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
andl $0x7ffffff, %eax        # imm = 0x7FFFFFF
movl %eax, %eax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl -0x34(%rbp), %ecx
shlq %cl, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x30(%rbp), %rax
jg 0x56b17
jmp 0x56b31
movq -0x20(%rbp), %rax
movl (%rax), %eax
shrl $0x1b, %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
jmp 0x56aec
movl -0x34(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/mpn/mul_fft.c
// Function: mpn_fft_initl
static void
mpn_fft_initl (int **l, int k)
{
  int i, j, K;
  int *li;

  l[0][0] = 0;
  for (i = 1, K = 1; i <= k; i++, K *= 2)
    {
      li = l[i];
      for (j = 0; j < K; j++)
	{
	  li[j] = 2 * l[i - 1][j];
	  li[K + j] = 1 + li[j];
	}
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl $0x0, (%rax)
movl $0x1, -0x10(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x57157
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x5713f
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edx
shll %edx
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
addl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x570e9
jmp 0x57141
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x18(%rbp), %eax
shll %eax
movl %eax, -0x18(%rbp)
jmp 0x570c6
popq %rbp
retq
nopl (%rax)
// File: marxn[P]pupp/3rdparty/gmp/mpn/mul_fft.c
// Function: mpn_mul_fft_lcm
static mp_bitcnt_t
mpn_mul_fft_lcm (mp_bitcnt_t a, int k)
{
  mp_bitcnt_t l = k;

  while (a % 2 == 0 && k > 0)
    {
      a >>= 1;
      k --;
    }
  return a << l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
andq $0x1, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x19(%rbp)
jne 0x57190
cmpl $0x0, -0xc(%rbp)
setg %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x57199
jmp 0x571af
movq -0x8(%rbp), %rax
shrq %rax
movq %rax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x57173
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
shlq %cl, %rax
popq %rbp
retq
nopl (%rax)
// File: marxn[P]pupp/3rdparty/gmp/mpn/mul_fft.c
// Function: mpn_fft_div_2exp_modF
static void
mpn_fft_div_2exp_modF (mp_ptr r, mp_srcptr a, mp_bitcnt_t k, mp_size_t n)
{
  mp_bitcnt_t i;

  ASSERT (r != a);
  i = (mp_bitcnt_t) 2 * n * GMP_NUMB_BITS - k;
  mpn_fft_mul_2exp_modF (r, a, i, n);
  /* 1/2^k = 2^(2nL-k) mod 2^(n*GMP_NUMB_BITS)+1 */
  /* normalize so that R < 2^(n*GMP_NUMB_BITS)+1 */
  mpn_fft_normalize (r, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0x58cfa
movq -0x20(%rbp), %rax
shlq %rax
shlq $0x6, %rax
subq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x57c90
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x59020
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/mpn/mul_fft.c
// Function: mpn_fft_norm_modF
static mp_size_t
mpn_fft_norm_modF (mp_ptr rp, mp_size_t n, mp_ptr ap, mp_size_t an)
{
  mp_size_t l, m, rpn;
  mp_limb_t cc;

  ASSERT ((n <= an) && (an <= 3 * n));
  m = an - 2 * n;
  if (m > 0)
    {
      l = n;
      /* add {ap, m} and {ap+2n, m} in {rp, m} */
      cc = mpn_add_n (rp, ap, ap + 2 * n, m);
      /* copy {ap+m, n-m} to {rp+m, n-m} */
      rpn = mpn_add_1 (rp + m, ap + m, n - m, cc);
    }
  else
    {
      l = an - n; /* l <= n */
      MPN_COPY (rp, ap, n);
      rpn = 0;
    }

  /* remains to subtract {ap+n, l} from {rp, n+1} */
  cc = mpn_sub_n (rp, rp, ap + n, l);
  rpn -= mpn_sub_1 (rp + l, rp + l, n - l, cc);
  if (rpn < 0) /* necessarily rpn = -1 */
    rpn = mpn_add_1 (rp, rp, n, CNST_LIMB(1));
  return rpn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0x58d5a
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
shlq %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jle 0x58dd7
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
shlq %rax
shlq $0x3, %rax
addq %rax, %rdx
movq -0x30(%rbp), %rcx
callq 0x36c80
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x10(%rbp), %rdx
subq -0x30(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0x564f0
movq %rax, -0x38(%rbp)
jmp 0x58e0c
movq -0x20(%rbp), %rax
subq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x58de5
jmp 0x58de7
jmp 0x58de9
jmp 0x58deb
jmp 0x58ded
jmp 0x58def
jmp 0x58df1
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x554c6
jmp 0x58e04
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
movq -0x28(%rbp), %rcx
callq 0x36fe0
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x10(%rbp), %rdx
subq -0x28(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0x36e60
movq %rax, %rcx
movq -0x38(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jge 0x58e8e
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl $0x1, %ecx
callq 0x564f0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/mpn/mul_fft.c
// Function: mpn_fft_sub_modF
static inline void
mpn_fft_sub_modF (mp_ptr r, mp_srcptr a, mp_srcptr b, mp_size_t n)
{
  mp_limb_t c, x;

  c = a[n] - b[n] - mpn_sub_n (r, a, b, n);
  /* -2 <= c <= 1 */

#if 1
  /* GCC 4.1 outsmarts most expressions here, and generates a 50% branch.  The
     result is slower code, of course.  But the following outsmarts GCC.  */
  x = (-c) & -((c & GMP_LIMB_HIGHBIT) != 0);
  r[n] = x + c;
  MPN_INCR_U (r, n + 1, x);
#endif
#if 0
  if ((c & GMP_LIMB_HIGHBIT) != 0)
    {
      r[n] = 0;
      MPN_INCR_U (r, n + 1, -c);
    }
  else
    {
      r[n] = c;
    }
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rdx
subq (%rcx,%rdx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x36fe0
movq %rax, %rcx
movq -0x40(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
subq -0x28(%rbp), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
andq -0x28(%rbp), %rcx
cmpq $0x0, %rcx
setne %cl
andb $0x1, %cl
movzbl %cl, %edx
xorl %ecx, %ecx
subl %edx, %ecx
movslq %ecx, %rcx
andq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdx
addq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
addq %rcx, (%rax)
jae 0x58f52
addq $0x1, 0x8(%rax)
leaq 0x8(%rax), %rax
jb 0x58f47
movq %rax, -0x38(%rbp)
jmp 0x58f58
jmp 0x58f5a
addq $0x40, %rsp
popq %rbp
retq
// File: marxn[P]pupp/3rdparty/gmp/mpn/mul_fft.c
// Function: mpn_fft_add_modF
static inline void
mpn_fft_add_modF (mp_ptr r, mp_srcptr a, mp_srcptr b, mp_size_t n)
{
  mp_limb_t c, x;

  c = a[n] + b[n] + mpn_add_n (r, a, b, n);
  /* 0 <= c <= 3 */

#if 1
  /* GCC 4.1 outsmarts most expressions here, and generates a 50% branch.  The
     result is slower code, of course.  But the following outsmarts GCC.  */
  x = (c - 1) & -(c != 0);
  r[n] = c - x;
  MPN_DECR_U (r, n + 1, x);
#endif
#if 0
  if (c > 1)
    {
      r[n] = 1;                       /* r[n] - c = 1 */
      MPN_DECR_U (r, n + 1, c - 1);
    }
  else
    {
      r[n] = c;
    }
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rdx
addq (%rcx,%rdx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x36c80
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
subq $0x1, %rax
cmpq $0x0, -0x28(%rbp)
setne %cl
andb $0x1, %cl
movzbl %cl, %edx
xorl %ecx, %ecx
subl %edx, %ecx
movslq %ecx, %rcx
andq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdx
subq -0x30(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, (%rax)
jae 0x59007
subq $0x1, 0x8(%rax)
leaq 0x8(%rax), %rax
jb 0x58ffc
movq %rax, -0x38(%rbp)
jmp 0x5900d
jmp 0x5900f
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/mpn/mul_fft.c
// Function: mpn_fft_normalize
static inline void
mpn_fft_normalize (mp_ptr ap, mp_size_t n)
{
  if (ap[n] != 0)
    {
      MPN_DECR_U (ap, n + 1, CNST_LIMB(1));
      if (ap[n] == 0)
	{
	  /* This happens with very low probability; we have yet to trigger it,
	     and thereby make sure this code is correct.  */
	  MPN_ZERO (ap, n);
	  ap[n] = 1;
	}
      else
	ap[n] = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x590d7
jmp 0x59041
movq -0x8(%rbp), %rax
subq $0x1, (%rax)
leaq 0x8(%rax), %rax
jb 0x59045
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x590c5
jmp 0x59064
jmp 0x59066
jmp 0x59068
cmpq $0x0, -0x10(%rbp)
je 0x590b1
jmp 0x59071
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x59083
jmp 0x59085
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x20(%rbp)
movq $0x0, (%rax)
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x59085
jmp 0x590af
jmp 0x590b1
jmp 0x590b3
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq $0x1, (%rax,%rcx,8)
jmp 0x590d5
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
jmp 0x590d7
popq %rbp
retq
nopl (%rax)
// File: marxn[P]pupp/3rdparty/gmp/mpn/../gmp.h
// Function: _gmpn_zero_p
int
mpn_zero_p (mp_srcptr __gmp_p, mp_size_t __gmp_n) __GMP_NOTHROW
{
  /* if (__GMP_LIKELY (__gmp_n > 0)) */
    do {
      if (__gmp_p[--__gmp_n] != 0)
	return 0;
    } while (__gmp_n != 0);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $-0x1, %rdx
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rax,%rcx,8)
je 0x59110
movl $0x0, -0x4(%rbp)
jmp 0x59120
jmp 0x59112
cmpq $0x0, -0x18(%rbp)
jne 0x590ec
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: marxn[P]pupp/3rdparty/gmp/mpn/invertappr.c
// Function: _gmpn_invertappr
mp_limb_t
mpn_invertappr (mp_ptr ip, mp_srcptr dp, mp_size_t n, mp_ptr scratch)
{
  ASSERT (n > 0);
  ASSERT (dp[n-1] & GMP_NUMB_HIGHBIT);
  ASSERT (! MPN_OVERLAP_P (ip, n, dp, n));
  ASSERT (! MPN_OVERLAP_P (ip, n, scratch, mpn_invertappr_itch(n)));
  ASSERT (! MPN_OVERLAP_P (dp, n, scratch, mpn_invertappr_itch(n)));

  if (BELOW_THRESHOLD (n, INV_NEWTON_THRESHOLD))
    return mpn_bc_invertappr (ip, dp, n, scratch);
  else
    return mpn_ni_invertappr (ip, dp, n, scratch);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
jmp 0x59cca
jmp 0x59ccc
jmp 0x59cce
jmp 0x59cd0
jmp 0x59cd2
jmp 0x59cd4
jmp 0x59cd6
jmp 0x59cd8
jmp 0x59cda
cmpq $0xf6, -0x20(%rbp)
jge 0x59cff
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x59960
movq %rax, -0x8(%rbp)
jmp 0x59d18
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x59130
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: marxn[P]pupp/3rdparty/gmp/mpf/set_si.c
// Function: _gmpf_set_si
void
mpf_set_si (mpf_ptr dest, long val)
{
  mp_size_t size;
  mp_limb_t vl;

  vl = (mp_limb_t) ABS_CAST (unsigned long int, val);

  dest->_mp_d[0] = vl & GMP_NUMB_MASK;
  size = vl != 0;

#if BITS_PER_ULONG > GMP_NUMB_BITS
  vl >>= GMP_NUMB_BITS;
  dest->_mp_d[1] = vl;
  size += (vl != 0);
#endif

  dest->_mp_exp = size;
  dest->_mp_size = val >= 0 ? size : -size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0x5c49d
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x5c4b2
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
subq $0x1, %rcx
xorl %eax, %eax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
andq $-0x1, %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x20(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x10(%rbp)
jl 0x5c4fd
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x5c507
xorl %eax, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/mpz/set_si.c
// Function: _gmpz_set_si
void
mpz_set_si (mpz_ptr dest, signed long int val)
{
  mp_size_t size;
  mp_limb_t vl;

  vl = (mp_limb_t) ABS_CAST (unsigned long int, val);

  PTR (dest)[0] = vl & GMP_NUMB_MASK;
  size = vl != 0;

#if GMP_NAIL_BITS != 0
  if (vl > GMP_NUMB_MAX)
    {
      MPZ_REALLOC (dest, 2);
      PTR (dest)[1] = vl >> GMP_NUMB_BITS;
      size = 2;
    }
#endif

  SIZ (dest) = val >= 0 ? size : -size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0x5d72d
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x5d742
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
subq $0x1, %rcx
xorl %eax, %eax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
andq $-0x1, %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x20(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0x5d781
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x5d78b
xorl %eax, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/mpq/set_si.c
// Function: _gmpq_set_si
void
mpq_set_si (mpq_t dest, signed long int num, unsigned long int den)
{
  unsigned long int abs_num;

  if (GMP_NUMB_BITS < BITS_PER_ULONG)
    {
      if (num == 0)  /* Canonicalize 0/d to 0/1.  */
        den = 1;
      mpz_set_si (mpq_numref (dest), num);
      mpz_set_ui (mpq_denref (dest), den);
      return;
    }

  abs_num = ABS_CAST (unsigned long, num);

  if (num == 0)
    {
      /* Canonicalize 0/d to 0/1.  */
      den = 1;
      SIZ(NUM(dest)) = 0;
    }
  else
    {
      PTR(NUM(dest))[0] = abs_num;
      SIZ(NUM(dest)) = num > 0 ? 1 : -1;
    }

  PTR(DEN(dest))[0] = den;
  SIZ(DEN(dest)) = (den != 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0x5d981
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x5d996
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
subq $0x1, %rcx
xorl %eax, %eax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5d9ba
movq $0x1, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
jmp 0x5d9e5
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0x1, %eax
cmpq $0x0, %rdx
cmovgl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x18(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopw %cs:(%rax,%rax)
nop
// File: iZhangHui[P]CppPrimer/CH06_Functions/examples/mainmath.cc
// Function: main
int main()
{
	// pass a literal to fact
    int f = fact(5);  // f equals 120, i.e., the result of fact(5)
	cout << "5! is " << f << endl;

    // call fact on i and print the result
	int i = 5;
    int j = fact(i);
	cout << i << "! is " << j << endl;

	// call fact on a const int
    const int ci = 3;
    int k = fact(ci);   
	cout << ci << "! is " << k << endl;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl $0x5, %edi
callq 0x12e0
movl %eax, -0x8(%rbp)
movq 0x2df5(%rip), %rdi      # 0x3fd8
leaq 0xe1a(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movl -0x8(%rbp), %esi
callq 0x1070
movq %rax, %rdi
movq 0x2dc4(%rip), %rsi      # 0x3fc8
callq 0x1050
movl $0x5, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x12e0
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %esi
movq 0x2db3(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
leaq 0xdd1(%rip), %rsi       # 0x2005
callq 0x1040
movq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x1070
movq %rax, %rdi
movq 0x2d7a(%rip), %rsi      # 0x3fc8
callq 0x1050
movl $0x3, -0x14(%rbp)
movl $0x3, %edi
callq 0x12e0
movl %eax, -0x18(%rbp)
movq 0x2d6a(%rip), %rdi      # 0x3fd8
movl $0x3, %esi
callq 0x1070
movq %rax, %rdi
leaq 0xd83(%rip), %rsi       # 0x2005
callq 0x1040
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0x1070
movq %rax, %rdi
movq 0x2d2c(%rip), %rsi      # 0x3fc8
callq 0x1050
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Czxck001[P]algorithms/src/bisection.cc
// Function: bisection(int*, int, int)
int bisection(int *a, int n, int val) {
  // Return the index of val in a. If not found, return -1.

  // Convention of range: left-closed and right-open.
  int l = 0, r = n;

  // End condition: a[l:r] size is equal to one
  // => Loop Condition: a[l:r] size is more than one
  while (r - l > 1) {
    // When the size is odd, a[l:m] is one element smaller than a[m:r].
    int m = (l + r) / 2;

    // CRITICAL POINT: always keep val in a[l:r].
    // Note that a[m] locates in a[m:r], so the condition should determine
    // whether val locates in a[m:r], too.
    if (a[m] <= val) {
      l = m;
    } else {
      r = m;
    }
  }

  // Finally, a[l:r] only has one element a[l].
  if (a[l] == val) {
    return l;
  } else {
    return -1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
subl -0x1c(%rbp), %eax
cmpl $0x1, %eax
jle 0x1217
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x18(%rbp), %eax
jg 0x120f
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x1215
movl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x11db
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x18(%rbp), %eax
jne 0x122f
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1236
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: Czxck001[P]algorithms/src/bisection.cc
// Function: main
int main() {
  int a[ARRAY_SIZE] = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512};
  std::cout << bisection(a, ARRAY_SIZE, 4) << std::endl;  // 2
  std::cout << bisection(a, ARRAY_SIZE, 128) << std::endl;  // 7
  std::cout << bisection(a, ARRAY_SIZE, 500) << std::endl;  // -1
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq -0x30(%rbp), %rdi
leaq 0xdbd(%rip), %rsi       # 0x2010
movl $0x28, %edx
callq 0x1030
leaq -0x30(%rbp), %rdi
movl $0xa, %esi
movl $0x4, %edx
callq 0x11c0
movl %eax, %esi
movq 0x2d5f(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
movq 0x2d40(%rip), %rsi      # 0x3fc8
callq 0x1050
leaq -0x30(%rbp), %rdi
movl $0xa, %esi
movl $0x80, %edx
callq 0x11c0
movl %eax, %esi
movq 0x2d2f(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
movq 0x2d10(%rip), %rsi      # 0x3fc8
callq 0x1050
leaq -0x30(%rbp), %rdi
movl $0xa, %esi
movl $0x1f4, %edx            # imm = 0x1F4
callq 0x11c0
movl %eax, %esi
movq 0x2cff(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
movq 0x2ce0(%rip), %rsi      # 0x3fc8
callq 0x1050
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq