LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/mpn/nussbaumer_mul.c
// Function: _gmpn_nussbaumer_mul
void
mpn_nussbaumer_mul (mp_ptr pp,
		    mp_srcptr ap, mp_size_t an,
		    mp_srcptr bp, mp_size_t bn)
{
  mp_size_t rn;
  mp_ptr tp;
  TMP_DECL;

  ASSERT (an >= bn);
  ASSERT (bn > 0);

  TMP_MARK;

  if ((ap == bp) && (an == bn))
    {
      rn = mpn_sqrmod_bnm1_next_size (2*an);
      tp = TMP_ALLOC_LIMBS (mpn_sqrmod_bnm1_itch (rn, an));
      mpn_sqrmod_bnm1 (pp, rn, ap, an, tp);
    }
  else
    {
      rn = mpn_mulmod_bnm1_next_size (an + bn);
      tp = TMP_ALLOC_LIMBS (mpn_mulmod_bnm1_itch (rn, an, bn));
      mpn_mulmod_bnm1 (pp, rn, ap, an, bp, bn, tp);
    }

  TMP_FREE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, -0x38(%rbp)
andq $0x0, -0x30(%rbp)
movq %rsi, %rax
xorq %rcx, %rax
movq %rdx, %rcx
xorq %r8, %rcx
orq %rax, %rcx
jne 0x1a589
leaq (%rbx,%rbx), %rdi
callq 0x257c9
movq %rax, %r15
sarq %rax
xorl %ecx, %ecx
cmpq %rbx, %rax
cmovlq %rbx, %rcx
addq %r15, %rcx
leaq 0x18(,%rcx,8), %rsi
cmpq $0x7f00, %rsi           # imm = 0x7F00
ja 0x1a611
movq %rsp, %r8
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %r8
movq %r8, %rsp
movq -0x38(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x25434
jmp 0x1a5f2
movq %r8, %r12
leaq (%r8,%rbx), %rdi
callq 0x253ca
movq %rax, %r15
sarq %rax
cmpq %r12, %rax
movq %rax, %rcx
cmovlq %r15, %rcx
xorl %edx, %edx
cmpq %rbx, %rax
cmovlq %rcx, %rdx
addq %r15, %rdx
leaq 0x20(,%rdx,8), %rsi
cmpq $0x7f00, %rsi           # imm = 0x7F00
ja 0x1a622
movq %rsp, %rax
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %rax
movq %rax, %rsp
subq $0x8, %rsp
movq -0x38(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
movq %r12, %r9
pushq %rax
callq 0x24f3e
popq %rax
popq %rcx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
jne 0x1a60a
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x29df3
jmp 0x1a5fb
leaq -0x30(%rbp), %rdi
callq 0x29dc0
movq %rax, %r8
jmp 0x1a575
leaq -0x30(%rbp), %rdi
callq 0x29dc0
jmp 0x1a5d3
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/mpn/toom63_mul.c
// Function: abs_sub_add_n
static int
abs_sub_add_n (mp_ptr rm, mp_ptr rp, mp_srcptr rs, mp_size_t n) {
  int result;
  result = abs_sub_n (rm, rp, rs, n);
  ASSERT_NOCARRY(mpn_add_n (rp, rp, rs, n));
  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq -0x1(%rcx), %rax
xorl %ebp, %ebp
leaq 0x1(%rax), %rcx
testq %rcx, %rcx
jle 0x1e7a3
movq (%r14,%rax,8), %rdx
cmpq %rdx, (%r15,%rax,8)
jne 0x1e786
andq $0x0, (%rdi,%rax,8)
decq %rax
jmp 0x1e769
jbe 0x1e795
movq %r15, %rsi
movq %r14, %rdx
callq 0x17ed0
jmp 0x1e7a3
movq %r14, %rsi
movq %r15, %rdx
callq 0x17ed0
pushq $-0x1
popq %rbp
movq %r15, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x17cf0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r13d
movq %r8, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl 0x40(%rsp), %ebp
movq %rdx, %rdi
movq %r12, %rsi
testl %ecx, %ecx
je 0x21dee
movq %r15, %rcx
callq 0x29630
jmp 0x21df6
movq %r15, %rcx
callq 0x294f0
movq %r12, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
cmpl $0x1, %r13d
jne 0x21e0f
callq 0x29630
jmp 0x21e2a
callq 0x17ed0
testl %r13d, %r13d
jle 0x21e2a
movq %r12, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %r13d, %ecx
callq 0x2a0a0
testl %ebp, %ebp
jle 0x21e3e
movq %r14, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x2a0a0
leaq (%r12,%rbx,8), %rdi
leaq (,%rbx,8), %r13
movq %r15, %rcx
subq %rbx, %rcx
movq %rdi, %rsi
movq %r14, %rdx
callq 0x17cf0
leaq (%r12,%r15,8), %rdi
movq %rax, (%rdi)
leaq (%r14,%r15,8), %rsi
subq %r13, %rsi
movq %rbx, %rdx
movq %rax, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x29e1c
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %rbp
movq %rsi, %r12
movq %rdi, %r15
movq %rcx, %rdx
shlq $0x4, %rdx
addq %rbp, %rdx
movq %rbp, %rsi
callq 0x17cf0
movq %rax, (%r15,%r14,8)
leaq (,%r14,8), %rsi
addq %rbp, %rsi
imulq $0x18, %r14, %rcx
addq %rbp, %rcx
movq %rbx, %rdi
movq %r14, %rdx
movq %r13, %r8
callq 0x17c54
movq %rax, (%rbx,%r14,8)
incq %r14
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1ac5c
movl %eax, %ebp
movq %r12, %rdi
testl %eax, %eax
js 0x226c1
movq %r15, %rsi
movq %rbx, %rdx
jmp 0x226c7
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x17ed0
sarl $0x1f, %ebp
movq %r15, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x17cf0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/mpn/toom_eval_dgr3_pm2.c
// Function: _gmpn_toom_eval_dgr3_pm2
int
mpn_toom_eval_dgr3_pm2 (mp_ptr xp2, mp_ptr xm2,
			mp_srcptr xp, mp_size_t n, mp_size_t x3n, mp_ptr tp)
{
  mp_limb_t cy;
  int neg;

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

  /* (x0 + 4 * x2) +/- (2 x1 + 8 x_3) */
#if HAVE_NATIVE_mpn_addlsh_n || HAVE_NATIVE_mpn_addlsh2_n
#if HAVE_NATIVE_mpn_addlsh2_n
  xp2[n] = mpn_addlsh2_n (xp2, xp, xp + 2*n, n);

  cy = mpn_addlsh2_n (tp, xp + n, xp + 3*n, x3n);
#else /* HAVE_NATIVE_mpn_addlsh_n */
  xp2[n] = mpn_addlsh_n (xp2, xp, xp + 2*n, n, 2);

  cy = mpn_addlsh_n (tp, xp + n, xp + 3*n, x3n, 2);
#endif
  if (x3n < n)
    cy = mpn_add_1 (tp + x3n, xp + n + x3n, n - x3n, cy);
  tp[n] = cy;
#else
  cy = mpn_lshift (tp, xp + 2*n, n, 2);
  xp2[n] = cy + mpn_add_n (xp2, tp, xp, n);

  tp[x3n] = mpn_lshift (tp, xp + 3*n, x3n, 2);
  if (x3n < n)
    tp[n] = mpn_add (tp, xp + n, n, tp, x3n + 1);
  else
    tp[n] += mpn_add_n (tp, xp + n, tp, n);
#endif
  mpn_lshift (tp, tp, n+1, 1);

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

#if HAVE_NATIVE_mpn_add_n_sub_n
  if (neg)
    mpn_add_n_sub_n (xp2, xm2, tp, xp2, n + 1);
  else
    mpn_add_n_sub_n (xp2, xm2, xp2, tp, n + 1);
#else
  if (neg)
    mpn_sub_n (xm2, tp, xp2, n + 1);
  else
    mpn_sub_n (xm2, xp2, tp, n + 1);

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

  ASSERT (xp2[n] < 15);
  ASSERT (xm2[n] < 10);

  return neg;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, (%rsp)
movq %rdi, %r15
movq %rcx, %rdx
shlq $0x4, %rdx
addq %r12, %rdx
movq %r12, %rsi
callq 0x29760
movq %rax, (%r15,%r14,8)
leaq (%r12,%r14,8), %rbp
imulq $0x18, %r14, %rdx
addq %r12, %rdx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rcx
callq 0x29760
movq %r14, %rdx
subq %r13, %rdx
jle 0x22760
leaq (%rbx,%r13,8), %rdi
leaq (,%r13,8), %rsi
addq %rbp, %rsi
movq %rax, %rcx
callq 0x29e1c
movq %rax, (%rbx,%r14,8)
incq %r14
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x181a0
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1ac5c
movl %eax, %ebp
testl %eax, %eax
js 0x22798
movq (%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
jmp 0x227a2
movq (%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x17ed0
sarl $0x1f, %ebp
movq %r15, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x17cf0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/mpn/toom_eval_pm1.c
// Function: _gmpn_toom_eval_pm1
int
mpn_toom_eval_pm1 (mp_ptr xp1, mp_ptr xm1, unsigned k,
		   mp_srcptr xp, mp_size_t n, mp_size_t hn, mp_ptr tp)
{
  unsigned i;
  int neg;

  ASSERT (k >= 4);

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

  /* The degree k is also the number of full-size coefficients, so
   * that last coefficient, of size hn, starts at xp + k*n. */

  xp1[n] = mpn_add_n (xp1, xp, xp + 2*n, n);
  for (i = 4; i < k; i += 2)
    ASSERT_NOCARRY (mpn_add (xp1, xp1, n+1, xp+i*n, n));

  tp[n] = mpn_add_n (tp, xp + n, xp + 3*n, n);
  for (i = 5; i < k; i += 2)
    ASSERT_NOCARRY (mpn_add (tp, tp, n+1, xp+i*n, n));

  if (k & 1)
    ASSERT_NOCARRY (mpn_add (tp, tp, n+1, xp+k*n, hn));
  else
    ASSERT_NOCARRY (mpn_add (xp1, xp1, n+1, xp+k*n, hn));

  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] <= k);
  ASSERT (xm1[n] <= k/2 + 1);

  return neg;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %r13
movq %rcx, %r12
movl %edx, %ebp
movq %rsi, 0x10(%rsp)
movq %rdi, %rbx
movq %r8, %rdx
shlq $0x4, %rdx
addq %rcx, %rdx
movq %rcx, %rsi
movq %r8, %rcx
callq 0x17cf0
movq %rax, (%rbx,%r13,8)
leaq 0x1(%r13), %r15
pushq $0x4
popq %r14
cmpl %ebp, %r14d
jae 0x2283b
movl %r14d, %eax
imulq %r13, %rax
leaq (%r12,%rax,8), %rcx
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r13, %r8
callq 0x17c54
addl $0x2, %r14d
jmp 0x22814
leaq (%r12,%r13,8), %rsi
imulq $0x18, %r13, %rdx
addq %r12, %rdx
movq 0x50(%rsp), %r14
movq %r14, %rdi
movq %r13, %rcx
callq 0x17cf0
movq %rax, (%r14,%r13,8)
pushq $0x5
popq %r14
cmpl %ebp, %r14d
jae 0x22887
movl %r14d, %eax
imulq %r13, %rax
leaq (%r12,%rax,8), %rcx
movq 0x50(%rsp), %rdi
movq %rdi, %rsi
movq %r15, %rdx
movq %r13, %r8
callq 0x17c54
addl $0x2, %r14d
jmp 0x2285e
movl %ebp, %eax
imulq %r13, %rax
leaq (%r12,%rax,8), %rcx
testb $0x1, %bpl
jne 0x228b1
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq 0x8(%rsp), %r8
callq 0x17c54
movq 0x50(%rsp), %r14
jmp 0x228c9
movq 0x50(%rsp), %r14
movq %r14, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq 0x8(%rsp), %r8
callq 0x17c54
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1ac5c
movl %eax, %ebp
testl %eax, %eax
js 0x228ea
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
jmp 0x228f5
movq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x17ed0
sarl $0x1f, %ebp
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x17cf0
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
cmpq $0x12, %rdi
jl 0x2542c
cmpq $0x44, %rbx
jbe 0x2540e
cmpq $0x88, %rbx
jbe 0x25418
cmpq $0x51a, %rbx            # imm = 0x51A
jbe 0x25423
incq %rbx
shrq %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2a2c8
movq %rbx, %rdi
movl %eax, %esi
callq 0x2a301
movq %rax, %rbx
addq %rax, %rbx
jmp 0x2542c
incl %ebx
andl $0xfe, %ebx
jmp 0x2542c
addl $0x3, %ebx
andl $0x1fc, %ebx            # imm = 0x1FC
jmp 0x2542c
addl $0x7, %ebx
andl $0xff8, %ebx            # imm = 0xFF8
movq %rbx, %rax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
cmpq $0x16, %rdi
jl 0x2582c
cmpq $0x54, %rbx
jbe 0x2580e
cmpq $0xa8, %rbx
jbe 0x25818
cmpq $0x472, %rbx            # imm = 0x472
jbe 0x25823
incq %rbx
shrq %rbx
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x2a2c8
movq %rbx, %rdi
movl %eax, %esi
callq 0x2a301
movq %rax, %rbx
addq %rax, %rbx
jmp 0x2582c
incl %ebx
andl $0xfe, %ebx
jmp 0x2582c
addl $0x3, %ebx
andl $0x1fc, %ebx            # imm = 0x1FC
jmp 0x2582c
addl $0x7, %ebx
andl $0xff8, %ebx            # imm = 0xFF8
movq %rbx, %rax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/mpn/dcpi1_div_q.c
// Function: _gmpn_dcpi1_div_q
mp_limb_t
mpn_dcpi1_div_q (mp_ptr qp, mp_ptr np, mp_size_t nn,
		 mp_srcptr dp, mp_size_t dn, gmp_pi1_t *dinv)
{
  mp_ptr tp, wp;
  mp_limb_t qh;
  mp_size_t qn;
  TMP_DECL;

  TMP_MARK;

  ASSERT (dn >= 6);
  ASSERT (nn - dn >= 3);
  ASSERT (dp[dn-1] & GMP_NUMB_HIGHBIT);

  tp = TMP_ALLOC_LIMBS (nn + 1);
  MPN_COPY (tp + 1, np, nn);
  tp[0] = 0;

  qn = nn - dn;
  wp = TMP_ALLOC_LIMBS (qn + 1);

  qh = mpn_dcpi1_divappr_q (wp, tp, nn + 1, dp, dn, dinv);

  if (wp[0] == 0)
    {
      mp_limb_t cy;

      if (qn > dn)
	mpn_mul (tp, wp + 1, qn, dp, dn);
      else
	mpn_mul (tp, dp, dn, wp + 1, qn);

      cy = (qh != 0) ? mpn_add_n (tp + qn, tp + qn, dp, dn) : 0;

      if (cy || mpn_cmp (tp, np, nn) > 0) /* At most is wrong by one, no cycle. */
	qh -= mpn_sub_1 (qp, wp + 1, qn, 1);
      else /* Same as below */
	MPN_COPY (qp, wp + 1, qn);
    }
  else
    MPN_COPY (qp, wp + 1, qn);

  TMP_FREE;
  return qh;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, -0x30(%rbp)
movq %r8, -0x48(%rbp)
movq %rcx, %rbx
movq %rdx, %r13
andq $0x0, -0x50(%rbp)
movq %rsi, %r14
movq %rdi, -0x40(%rbp)
leaq 0x8(,%rdx,8), %rsi
cmpq $0x7f00, %rsi           # imm = 0x7F00
ja 0x26ec3
movq %rsp, %r15
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %r15
movq %r15, %rsp
leaq 0x1(%r13), %r12
leaq 0x8(%r15), %rdi
movq %r14, -0x60(%rbp)
movq %r14, %rsi
movq %r13, %rdx
callq 0x290c6
andq $0x0, (%r15)
movq %r13, -0x58(%rbp)
movq %r13, %r14
movq -0x48(%rbp), %r8
subq %r8, %r14
leaq 0x8(,%r14,8), %rsi
cmpq $0x7f00, %rsi           # imm = 0x7F00
ja 0x26ed4
movq %rsp, %r13
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %r13
movq %r13, %rsp
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
movq %r8, %r12
movq -0x30(%rbp), %r9
callq 0x2791d
movq %rax, -0x30(%rbp)
cmpq $0x0, (%r13)
je 0x26e1b
addq $0x8, %r13
movq -0x40(%rbp), %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x290c6
movq -0x30(%rbp), %rbx
jmp 0x26ea8
movq %rbx, -0x38(%rbp)
addq $0x8, %r13
movq %r15, %rdi
cmpq %r12, %r14
jle 0x26e3a
movq %r13, %rsi
movq %r14, %rdx
movq -0x38(%rbp), %rcx
movq %r12, %r8
jmp 0x26e47
movq -0x38(%rbp), %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %r14, %r8
callq 0x18a58
movq -0x30(%rbp), %rbx
testq %rbx, %rbx
je 0x26e6e
leaq (%r15,%r14,8), %rdi
movq %rdi, %rsi
movq -0x38(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0x17cf0
testq %rax, %rax
jne 0x26e82
movq %r15, %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x1ac5c
testl %eax, %eax
jle 0x26e99
pushq $0x1
popq %rcx
movq -0x40(%rbp), %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x17e44
subq %rax, %rbx
jmp 0x26ea8
movq -0x40(%rbp), %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x290c6
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
jne 0x26ee9
movq %rbx, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x50(%rbp), %rdi
callq 0x29dc0
movq %rax, %r15
jmp 0x26d8d
leaq -0x50(%rbp), %rdi
callq 0x29dc0
movq -0x48(%rbp), %r8
movq %rax, %r13
jmp 0x26ddc
callq 0x29df3
jmp 0x26eb1
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
subq %rsi, %rdi
callq 0x28568
movq %rax, %r14
movq %rbx, %rsi
movq %rax, %rdx
callq 0x285eb
leaq (%r14,%r14,2), %rcx
addq $0x4, %rcx
cmpq %rax, %rcx
cmovgq %rcx, %rax
addq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
subq %rsi, %rdi
leaq 0x1(%rdi), %rax
cmpq %rsi, %rax
cmovlq %rax, %rbx
movq %rbx, %rsi
callq 0x28775
movq %rax, %r14
leaq 0x1(%rbx), %rdi
callq 0x253ca
movq %rax, %rcx
sarq %rcx
cmpq %r14, %rcx
movq %rcx, %rdx
cmovlq %rax, %rdx
xorl %esi, %esi
cmpq %rbx, %rcx
cmovlq %rdx, %rsi
leaq (%r14,%r14,2), %rcx
addq $0x4, %rcx
leaq (%rbx,%rax,2), %rax
addq %rsi, %rax
addq $0x4, %rax
cmpq %rcx, %rax
cmovgq %rax, %rcx
addq %r14, %rcx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
subq $0xe8, %rsp
leaq 0x30(%rsp), %r10
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x29aca
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
leaq 0x10(%rsp), %rcx
movq %r10, 0x10(%rcx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rcx)
movq %rsp, %rax
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
leaq 0x1925b(%rip), %rdi     # 0x42d58
movq %rax, %rsi
callq 0x2bf40
addq $0xe8, %rsp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/printf/snprntffuns.c
// Function: gmp_snprintf_format
static int
gmp_snprintf_format (struct gmp_snprintf_t *d, const char *fmt,
                     va_list orig_ap)
{
  int      ret, step, alloc, avail;
  va_list  ap;
  char     *p;

  ASSERT (d->size >= 0);

  avail = d->size;
  if (avail > 1)
    {
      va_copy (ap, orig_ap);
      ret = vsnprintf (d->buf, avail, fmt, ap);
      if (ret == -1)
        {
          ASSERT (strlen (d->buf) == avail-1);
          ret = avail-1;
        }

      step = MIN (ret, avail-1);
      d->size -= step;
      d->buf += step;

      if (ret != avail-1)
        return ret;

      /* probably glibc 2.0.x truncated output, probe for actual size */
      alloc = MAX (128, ret);
    }
  else
    {
      /* no space to write anything, just probe for size */
      alloc = 128;
    }

  do
    {
      alloc *= 2;
      p = __GMP_ALLOCATE_FUNC_TYPE (alloc, char);
      va_copy (ap, orig_ap);
      ret = vsnprintf (p, alloc, fmt, ap);
      (*__gmp_free_func) (p, alloc);
    }
  while (ret == alloc-1 || ret == -1);

  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r13
movq 0x8(%rdi), %r14
movl $0x80, %r15d
cmpl $0x2, %r14d
jl 0x29b90
movq %rdi, %r12
movq 0x10(%rbx), %rax
leaq 0x10(%rsp), %rcx
movq %rax, 0x10(%rcx)
movups (%rbx), %xmm0
movaps %xmm0, (%rcx)
movq (%rdi), %rdi
movl %r14d, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movq %r13, %rdx
callq 0x61a0
movl %eax, %ebp
leal -0x1(%r14), %eax
cmpl $-0x1, %ebp
cmovel %eax, %ebp
cmpl %eax, %ebp
movl %eax, %ecx
cmovll %ebp, %ecx
movslq %ecx, %rcx
subq %rcx, 0x8(%r12)
addq %rcx, (%r12)
cmpl %eax, %ebp
jne 0x29bfc
cmpl $0x81, %eax
movl $0x80, %r15d
cmovael %eax, %r15d
movq %r13, 0x8(%rsp)
leal (%r15,%r15), %r14d
movslq %r14d, %r12
movq %r12, %rdi
leaq 0x196f2(%rip), %rax     # 0x43298
callq *(%rax)
movq %rax, %r13
movups (%rbx), %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x10(%rbx), %rax
movq %rax, 0x20(%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq 0x61a0
movl %eax, %ebp
movq %r13, %rdi
movq %r12, %rsi
leaq 0x196c8(%rip), %rax     # 0x432a8
callq *(%rax)
leal -0x1(,%r15,2), %eax
cmpl %eax, %ebp
sete %al
cmpl $-0x1, %ebp
sete %cl
orb %al, %cl
movl %r14d, %r15d
jne 0x29b95
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq 0x8(%rdi), %r15
cmpq $0x2, %r15
jb 0x29c3e
movq %rdi, %r14
decq %r15
cmpq %rbx, %r15
cmovaeq %rbx, %r15
movq (%rdi), %rdi
movq %r15, %rdx
callq 0x61f0
addq %r15, (%r14)
subq %r15, 0x8(%r14)
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq 0x8(%rdi), %r15
cmpq $0x2, %r15
jb 0x29c79
movq %rdi, %r14
decq %r15
movslq %ebx, %rax
cmpq %rax, %r15
cmovaeq %rax, %r15
movq (%rdi), %rdi
movq %r15, %rdx
callq 0x6170
addq %r15, (%r14)
subq %r15, 0x8(%r14)
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x29ca5
movq %rdi, %rdx
cmpb $0x0, (%rdi)
jne 0x29cad
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %esi, %ebx
movq 0x1931a(%rip), %r14     # 0x42fd0
movq (%r14), %rdi
leaq 0x9d5b(%rip), %rsi      # 0x33a1b
xorl %eax, %eax
callq 0x63a0
cmpl $-0x1, %ebx
je 0x29ca5
movq (%r14), %rdi
leaq 0x9d49(%rip), %rsi      # 0x33a1f
movl %ebx, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x63a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x10, %rbx
leaq 0x194c3(%rip), %rax     # 0x43298
movq %rbx, %rdi
callq *(%rax)
movq %rbx, 0x8(%rax)
movq (%r14), %rcx
movq %rcx, (%rax)
movq %rax, (%r14)
addq $0x10, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
leaq 0x194aa(%rip), %rbx     # 0x432a8
testq %rdi, %rdi
je 0x29e11
movq (%rdi), %r14
movq 0x8(%rdi), %rsi
callq *(%rbx)
movq %r14, %rdi
jmp 0x29dfe
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
movq (%rdi), %rax
andl $0x0, (%rax)
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
incl %esi
movl $0x1, %eax
movabsq $0x1, %rcx
cmpq %rsi, %rcx
je 0x2a6ba
movq -0x8(%rdi,%rcx,8), %rdx
movq (%rdi,%rcx,8), %r8
movslq %eax, %r10
movl %r10d, %r9d
leaq (%r8,%r10,4), %r10
xorl %r11d, %r11d
cmpq %r11, %r9
je 0x2a6b3
movl (%rdx,%r11,4), %ebx
leal (%rbx,%rbx), %ebp
movl %ebp, (%r8,%r11,4)
leal 0x1(,%rbx,2), %ebx
movl %ebx, (%r10,%r11,4)
incq %r11
jmp 0x2a693
incq %rcx
addl %eax, %eax
jmp 0x2a678
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/mpn/mul_fft.c
// Function: mpn_fft_fftinv
static void
mpn_fft_fftinv (mp_ptr *Ap, mp_size_t K, mp_size_t omega, mp_size_t n, mp_ptr tp)
{
  if (K == 2)
    {
      mp_limb_t cy;
#if HAVE_NATIVE_mpn_add_n_sub_n
      cy = mpn_add_n_sub_n (Ap[0], Ap[1], Ap[0], Ap[1], n + 1) & 1;
#else
      MPN_COPY (tp, Ap[0], n + 1);
      mpn_add_n (Ap[0], Ap[0], Ap[1], n + 1);
      cy = mpn_sub_n (Ap[1], tp, Ap[1], n + 1);
#endif
      if (Ap[0][n] > 1) /* can be 2 or 3 */
	Ap[0][n] = 1 - mpn_sub_1 (Ap[0], Ap[0], n, Ap[0][n] - 1);
      if (cy) /* Ap[1][n] can be -1 or -2 */
	Ap[1][n] = mpn_add_1 (Ap[1], Ap[1], n, ~Ap[1][n] + 1);
    }
  else
    {
      mp_size_t j, K2 = K >> 1;

      mpn_fft_fftinv (Ap,      K2, 2 * omega, n, tp);
      mpn_fft_fftinv (Ap + K2, K2, 2 * omega, n, tp);
      /* A[j]     <- A[j] + omega^j A[j+K/2]
	 A[j+K/2] <- A[j] + omega^(j+K/2) A[j+K/2] */
      for (j = 0; j < K2; j++, Ap++)
	{
	  /* Ap[K2] <- Ap[0] + Ap[K2] * 2^((j + K2) * omega)
	     Ap[0]  <- Ap[0] + Ap[K2] * 2^(j * omega) */
	  mpn_fft_mul_2exp_modF (tp, Ap[K2], j * omega, n);
	  mpn_fft_sub_modF (Ap[K2], Ap[0], tp, n);
	  mpn_fft_add_modF (Ap[0],  Ap[0], tp, n);
	}
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %rbx
movq %rdi, %r14
cmpq $0x2, %rsi
jne 0x2b7af
movq (%r14), %rsi
leaq 0x1(%rbx), %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x290c6
movq (%r14), %rdi
movq 0x8(%r14), %rdx
movq %rdi, %rsi
movq %r12, %rcx
callq 0x17cf0
movq 0x8(%r14), %rdi
movq %r15, %rsi
movq %rdi, %rdx
movq %r12, %rcx
callq 0x17ed0
movq %rax, %r15
movq (%r14), %rdi
movq (%rdi,%rbx,8), %rcx
cmpq $0x2, %rcx
jb 0x2b77e
decq %rcx
movq %rdi, %rsi
movq %rbx, %rdx
callq 0x17e44
pushq $0x1
popq %rcx
subq %rax, %rcx
movq (%r14), %rax
movq %rcx, (%rax,%rbx,8)
testq %r15, %r15
je 0x2b7a0
movq 0x8(%r14), %rdi
xorl %ecx, %ecx
subq (%rdi,%rbx,8), %rcx
movq %rdi, %rsi
movq %rbx, %rdx
callq 0x29e1c
movq 0x8(%r14), %rcx
movq %rax, (%rcx,%rbx,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r13
sarq %r13
movq %rdx, (%rsp)
leaq (%rdx,%rdx), %rbp
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %rbx, %rcx
movq %r15, %r8
callq 0x2b6ff
leaq (%r14,%r13,8), %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %rbx, %rcx
movq %r15, %r8
callq 0x2b6ff
xorl %ebp, %ebp
testq %r13, %r13
movl $0x0, %r12d
cmovgq %r13, %r12
subq $0x1, %r12
jb 0x2b7a0
movq (%r14,%r13,8), %rsi
movq %r15, %rdi
movq %rbp, %rdx
movq %rbx, %rcx
callq 0x2b34f
movq (%r14,%r13,8), %rdi
movq (%r14), %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x2b868
movq (%r14), %rdi
movq %rdi, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x2b8bc
addq $0x8, %r14
addq (%rsp), %rbp
jmp 0x2b7f5
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movq (%rsi,%rcx,8), %r15
movq (%rdx,%rcx,8), %r12
callq 0x17ed0
addq %r12, %rax
subq %rax, %r15
movq %r15, %rax
negq %rax
movq %r15, %rcx
sarq $0x3f, %rcx
andq %rax, %rcx
addq %rcx, %r15
movq %r15, (%r14,%rbx,8)
addq %rcx, (%r14)
jae 0x2b8b0
addq $0x1, 0x8(%r14)
leaq 0x8(%r14), %r14
jb 0x2b8a5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpq $0x0, (%rdi,%rsi,8)
je 0x2b950
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, %rax
subq $0x1, (%rax)
leaq 0x8(%rax), %rax
jb 0x2b916
cmpq $0x0, (%rdi,%rsi,8)
je 0x2b92c
xorl %r15d, %r15d
jmp 0x2b947
pushq $0x1
popq %r15
testq %rbx, %rbx
je 0x2b947
leaq (,%rbx,8), %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x6170
movq %r15, (%r14,%rbx,8)
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/mpn/invertappr.c
// Function: mpn_bc_invertappr
static mp_limb_t
mpn_bc_invertappr (mp_ptr ip, mp_srcptr dp, mp_size_t n, mp_ptr xp)
{
  ASSERT (n > 0);
  ASSERT (dp[n-1] & GMP_NUMB_HIGHBIT);
  ASSERT (! MPN_OVERLAP_P (ip, n, dp, n));
  ASSERT (! MPN_OVERLAP_P (ip, n, xp, mpn_invertappr_itch(n)));
  ASSERT (! MPN_OVERLAP_P (dp, n, xp, mpn_invertappr_itch(n)));

  /* Compute a base value of r limbs. */
  if (n == 1)
    invert_limb (*ip, *dp);
  else {
    mp_size_t i;

    /* n > 1 here */
    i = n;
    do
      xp[--i] = GMP_NUMB_MAX;
    while (i);
    mpn_com (xp + n, dp, n);

    /* Now xp contains B^2n - {dp,n}*B^n - 1 */

    /* FIXME: if mpn_*pi1_divappr_q handles n==2, use it! */
    if (n == 2) {
      mpn_divrem_2 (ip, 0, xp, 4, dp);
    } else {
      gmp_pi1_t inv;
      invert_pi1 (inv, dp[n-1], dp[n-2]);
      if (! MAYBE_dcpi1_divappr
	  || BELOW_THRESHOLD (n, DC_DIVAPPR_Q_THRESHOLD))
	mpn_sbpi1_divappr_q (ip, xp, 2 * n, dp, n, inv.inv32);
      else
	mpn_dcpi1_divappr_q (ip, xp, 2 * n, dp, n, &inv);
      MPN_DECR_U(ip, n, CNST_LIMB (1));
      return 1;
    }
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x1, %rdx
jne 0x2be3e
movq (%r14), %rdi
callq 0x29130
movq %rax, (%rbx)
xorl %r12d, %r12d
jmp 0x2bf09
movq %rcx, %r15
movq %rdx, %r12
leaq (,%rdx,8), %rdx
movq %rcx, %rdi
movl $0xff, %esi
callq 0x6170
leaq (%r15,%r12,8), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x18000
cmpq $0x2, %r12
jne 0x2be89
xorl %r12d, %r12d
pushq $0x4
popq %rcx
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %r8
callq 0x18920
jmp 0x2bf09
movq -0x8(%r14,%r12,8), %r13
movq %r13, %rdi
callq 0x29130
movq %rax, %r9
movq %rax, %rsi
imulq %r13, %rsi
movq -0x10(%r14,%r12,8), %rcx
addq %rcx, %rsi
jae 0x2bec8
xorl %eax, %eax
cmpq %r13, %rsi
movl $0x0, %edx
adcq $-0x2, %rdx
cmpq %r13, %rsi
cmovaeq %r13, %rax
addq %rdx, %r9
addq %r13, %rax
subq %rax, %rsi
movq %r9, 0x8(%rsp)
movq %rcx, %rax
mulq 0x8(%rsp)
addq %rsi, %rdx
jae 0x2bee6
leaq -0x1(%r9), %rsi
cmpq %r13, %rdx
jae 0x2bf1a
movq %rsi, %r9
leaq (%r12,%r12), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
movq %r12, %r8
callq 0x265b0
subq $0x1, (%rbx)
leaq 0x8(%rbx), %rbx
jb 0x2befb
pushq $0x1
popq %r12
movq %r12, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
addq $-0x2, %r9
cmpq %rcx, %rax
cmovaeq %r9, %rsi
cmpq %r13, %rdx
cmovbeq %rsi, %r9
jmp 0x2bee6
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/mpf/get_str.c
// Function: mpn_pow_1_highpart
static mp_size_t
mpn_pow_1_highpart (mp_ptr rp, mp_size_t *ignp,
		    mp_limb_t base, unsigned long exp,
		    mp_size_t prec, mp_ptr tp)
{
  mp_size_t ign;		/* counts number of ignored low limbs in r */
  mp_size_t off;		/* keeps track of offset where value starts */
  mp_ptr passed_rp = rp;
  mp_size_t rn;
  int cnt;
  int i;

  if (exp == 0)
    {
      rp[0] = 1;
      *ignp = 0;
      return 1;
    }

  rp[0] = base;
  rn = 1;
  off = 0;
  ign = 0;
  count_leading_zeros (cnt, exp);
  for (i = GMP_LIMB_BITS - cnt - 2; i >= 0; i--)
    {
      mpn_sqr (tp, rp + off, rn);
      rn = 2 * rn;
      rn -= tp[rn - 1] == 0;
      ign <<= 1;

      off = 0;
      if (rn > prec)
	{
	  ign += rn - prec;
	  off = rn - prec;
	  rn = prec;
	}
      MP_PTR_SWAP (rp, tp);

      if (((exp >> i) & 1) != 0)
	{
	  mp_limb_t cy;
	  cy = mpn_mul_1 (rp, rp + off, rn, base);
	  rp[rn] = cy;
	  rn += cy != 0;
	  off = 0;
	}
    }

  if (rn > prec)
    {
      ASSERT (rn == prec + 1);

      ign += rn - prec;
      rp += rn - prec;
      rn = prec;
    }

  /* With somewhat less than 50% probability, we can skip this copy.  */
  if (passed_rp != rp + off)
    MPN_COPY_INCR (passed_rp, rp + off, rn);
  *ignp = ign;
  return rn;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
testq %rcx, %rcx
je 0x2d7f2
movq %rsi, 0x8(%rsp)
movq %r8, 0x10(%rsp)
movq %rdx, 0x20(%rsp)
movq %rdx, (%rdi)
movq %rcx, 0x28(%rsp)
movq %rcx, 0x30(%rsp)
bsrq 0x30(%rsp), %r12
xorl $-0x40, %r12d
addl $0x3f, %r12d
pushq $0x1
popq %r15
xorl %eax, %eax
xorl %r13d, %r13d
movq %rdi, 0x18(%rsp)
movq %rdi, %rbx
testl %r12d, %r12d
js 0x2d7b9
movq %r9, %rbp
leaq (%rbx,%rax,8), %rsi
movq %r9, %rdi
movq %r15, %rdx
callq 0x196c0
leaq (%r15,%r15), %r14
shlq $0x4, %r15
cmpq $0x1, -0x8(%r15,%rbp)
sbbq $0x0, %r14
movq %r14, %r15
movq 0x10(%rsp), %rax
subq %rax, %r15
movl $0x0, %ecx
cmovleq %rcx, %r15
cmovgeq %rax, %r14
movq 0x28(%rsp), %rax
btq %r12, %rax
jae 0x2d7a1
leaq (,%r15,8), %rsi
addq %rbp, %rsi
movq %rbp, %rdi
movq %r14, %rdx
movq 0x20(%rsp), %rcx
callq 0x18086
movq %rax, (%rbp,%r14,8)
cmpq $0x1, %rax
sbbq $-0x1, %r14
xorl %eax, %eax
jmp 0x2d7a4
movq %r15, %rax
leaq (%r15,%r13,2), %r13
decl %r12d
movq %r14, %r15
movq %rbx, %r9
movq %rbp, %rbx
jmp 0x2d725
xorl %ecx, %ecx
movq %r15, %rdx
movq 0x10(%rsp), %r14
subq %r14, %rdx
cmovlq %r15, %r14
cmovgq %rdx, %rcx
addq %rcx, %r13
leaq (%rbx,%rcx,8), %rcx
leaq (%rcx,%rax,8), %rsi
movq 0x18(%rsp), %rdi
cmpq %rdi, %rsi
je 0x2d7eb
movq %r14, %rdx
callq 0x290c6
movq 0x8(%rsp), %rsi
jmp 0x2d800
movq $0x1, (%rdi)
pushq $0x1
popq %r14
xorl %r13d, %r13d
movq %r13, (%rsi)
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/mpq/get_str.c
// Function: _gmpq_get_str
char *
mpq_get_str (char *str, int base, mpq_srcptr q)
{
  size_t  str_alloc, len;

  if (base > 62 || base < -36)
    return NULL;

  str_alloc = 0;
  if (str == NULL)
    {
      /* This is an overestimate since we don't bother checking how much of
	 the high limbs of num and den are used.  +2 for rounding up the
	 chars per bit of num and den.  +3 for sign, slash and '\0'.  */
      DIGITS_IN_BASE_PER_LIMB (str_alloc, ABSIZ(NUM(q)) + SIZ(DEN(q)), ABS(base));
      str_alloc += 6;

      str = (char *) (*__gmp_allocate_func) (str_alloc);
    }

  mpz_get_str (str, base, mpq_numref(q));
  len = strlen (str);
  if (! MPZ_EQUAL_1_P (mpq_denref (q)))
    {
      str[len++] = '/';
      mpz_get_str (str+len, base, mpq_denref(q));
      len += strlen (str+len);
    }

  ASSERT (len == strlen(str));
  ASSERT (str_alloc == 0 || len+1 <= str_alloc);
  ASSERT (len+1 <=  /* size recommended to applications */
	  mpz_sizeinbase (mpq_numref(q), ABS(base)) +
	  mpz_sizeinbase (mpq_denref(q), ABS(base)) + 3);

  if (str_alloc != 0)
    __GMP_REALLOCATE_FUNC_MAYBE_TYPE (str, str_alloc, len+1, char);

  return str;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r15d
leal -0x3f(%r15), %eax
cmpl $-0x63, %eax
jae 0x2da7a
xorl %ebx, %ebx
jmp 0x2db3d
movq %rdx, %r14
movq %rdi, %rbx
testq %rdi, %rdi
je 0x2da8a
xorl %r12d, %r12d
jmp 0x2dada
movl %r15d, %eax
negl %eax
cmovsl %r15d, %eax
imulq $0x28, %rax, %rax
leaq 0x3682(%rip), %rcx      # 0x31120
movq 0x8(%rcx,%rax), %rax
movl 0x4(%r14), %ecx
movl %ecx, %edx
negl %edx
cmovsl %ecx, %edx
movslq 0x14(%r14), %rcx
movslq %edx, %rdx
addq %rcx, %rdx
shlq $0x6, %rdx
movq %rdx, (%rsp)
mulq (%rsp)
movq %rdx, %r12
addq $0x6, %r12
leaq 0x157c6(%rip), %rax     # 0x43298
movq %r12, %rdi
callq *(%rax)
movq %rax, %rbx
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x2d818
movq %rbx, %rdi
callq 0x6110
movq %rax, %r13
cmpl $0x1, 0x14(%r14)
jne 0x2db04
movq 0x18(%r14), %rax
cmpq $0x1, (%rax)
je 0x2db30
addq $0x10, %r14
movb $0x2f, (%rbx,%r13)
leaq (%rbx,%r13), %rbp
incq %rbp
movq %rbp, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x2d818
movq %rbp, %rdi
callq 0x6110
addq %rax, %r13
incq %r13
testq %r12, %r12
je 0x2db3d
incq %r13
cmpq %r13, %r12
jne 0x2db4f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1574a(%rip), %rax     # 0x432a0
movq (%rax), %rax
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
nop
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/mpn/get_str.c
// Function: mpn_dc_get_str
static unsigned char *
mpn_dc_get_str (unsigned char *str, size_t len,
		mp_ptr up, mp_size_t un,
		const powers_t *powtab, mp_ptr tmp)
{
  if (BELOW_THRESHOLD (un, GET_STR_DC_THRESHOLD))
    {
      if (un != 0)
	str = mpn_sb_get_str (str, len, up, un, powtab->base);
      else
	{
	  while (len != 0)
	    {
	      *str++ = 0;
	      len--;
	    }
	}
    }
  else
    {
      mp_ptr pwp, qp, rp;
      mp_size_t pwn, qn;
      mp_size_t sn;

      pwp = powtab->p;
      pwn = powtab->n;
      sn = powtab->shift;

      if (un < pwn + sn || (un == pwn + sn && mpn_cmp (up + sn, pwp, un - sn) < 0))
	{
	  str = mpn_dc_get_str (str, len, up, un, powtab - 1, tmp);
	}
      else
	{
	  qp = tmp;		/* (un - pwn + 1) limbs for qp */
	  rp = up;		/* pwn limbs for rp; overwrite up area */

	  mpn_tdiv_qr (qp, rp + sn, 0L, up + sn, un - sn, pwp, pwn);
	  qn = un - sn - pwn; qn += qp[qn] != 0;		/* quotient size */

	  ASSERT (qn < pwn + sn || (qn == pwn + sn && mpn_cmp (qp + sn, pwp, pwn) < 0));

	  if (len != 0)
	    len = len - powtab->digits_in_base;

	  str = mpn_dc_get_str (str, len, qp, qn, powtab - 1, tmp + qn);
	  str = mpn_dc_get_str (str, powtab->digits_in_base, rp, pwn + sn, powtab - 1, tmp);
	}
    }
  return str;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, 0x20(%rsp)
movq %rcx, %r13
movq %rdx, 0x28(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, 0x18(%rsp)
movq %r8, 0x30(%rsp)
leaq -0x28(%r8), %rbp
cmpq $0x10, %r13
jle 0x2e49c
movq 0x30(%rbp), %r14
movq 0x38(%rbp), %rax
leaq (%rax,%r14), %rcx
cmpq %r13, %rcx
jg 0x2e41b
movq 0x28(%rbp), %r12
movq 0x28(%rsp), %rdx
leaq (%rdx,%rax,8), %rbx
jne 0x2e421
movq %r13, %r15
subq %rax, %r15
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1ac5c
testl %eax, %eax
jns 0x2e42a
addq $-0x28, %rbp
jmp 0x2e3d9
subq %rax, %r13
movq %r13, %r15
movq %rcx, %r13
movq %r14, (%rsp)
movq 0x20(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %rbx, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0x1b900
subq %r14, %r15
movq 0x20(%rsp), %rax
cmpq $0x1, (%rax,%r15,8)
sbbq $-0x1, %r15
movl $0x0, %esi
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2e46d
subq 0x40(%rbp), %rax
movq %rax, %rsi
movq 0x20(%rsp), %rdx
leaq (%rdx,%r15,8), %r9
movq 0x18(%rsp), %rdi
movq %r15, %rcx
movq %rbp, %r8
callq 0x2e3ab
movq %rax, 0x18(%rsp)
movq 0x40(%rbp), %rax
movq %rax, 0x10(%rsp)
movq %rbp, %r8
jmp 0x2e3d0
testq %r13, %r13
je 0x2e4cf
movq 0x30(%rsp), %rax
movl 0x20(%rax), %r8d
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %r13, %rcx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2e155
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
subq $0x1, %rcx
jb 0x2e4e7
movb $0x0, (%rax)
incq %rax
jmp 0x2e4d9
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq $0x5
popq %r14
movl %r14d, %edi
callq 0x1297
movl %eax, %r15d
movq 0x2dfb(%rip), %rbx      # 0x3fd8
leaq 0xe20(%rip), %rsi       # 0x2004
movq %rbx, %rdi
callq 0x1050
movq %rax, %rdi
movl %r15d, %esi
callq 0x1070
movq %rax, %rdi
callq 0x1030
movl %r14d, %edi
callq 0x1297
movl %eax, %r15d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1070
leaq 0xde9(%rip), %r14       # 0x2005
movq %rax, %rdi
movq %r14, %rsi
callq 0x1050
movq %rax, %rdi
movl %r15d, %esi
callq 0x1070
movq %rax, %rdi
callq 0x1030
pushq $0x3
popq %r15
movl %r15d, %edi
callq 0x1297
movl %eax, %r12d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1070
movq %rax, %rdi
movq %r14, %rsi
callq 0x1050
movq %rax, %rdi
movl %r12d, %esi
callq 0x1070
movq %rax, %rdi
callq 0x1030
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0xe13(%rip), %rbx       # 0x2010
pushq $0xa
popq %r14
pushq $0x4
popq %rdx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x11ac
movq 0x2dc2(%rip), %r15      # 0x3fd8
movq %r15, %rdi
movl %eax, %esi
callq 0x1060
movq %rax, %rdi
callq 0x1030
movq %rbx, %rdi
movl %r14d, %esi
movl $0x80, %edx
callq 0x11ac
movq %r15, %rdi
movl %eax, %esi
callq 0x1060
movq %rax, %rdi
callq 0x1030
movq %rbx, %rdi
movl %r14d, %esi
movl $0x1f4, %edx            # imm = 0x1F4
callq 0x11ac
movq %r15, %rdi
movl %eax, %esi
callq 0x1060
movq %rax, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH12_DynamicMemory/examples/querymain.cc
// Function: runQueries(std::basic_ifstream<char, std::char_traits<char>>&)
void runQueries(ifstream& infile)
{
	// infile is an ifstream that is the file we want to query
    TextQuery tq(infile);  // store the file and build the query map
    // iterate with the user: prompt for a word to find and print results
    while (true) {
        cout << "enter word to look for, or q to quit: ";
        string s;
        // stop if we hit end-of-file on the input or if a 'q' is entered
        if (!(cin >> s) || s == "q") break;
		// run the query and print the results
        print(cout, tq.query(s)) << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rsi
leaq -0x88(%rbp), %rdi
callq 0x2794
movq 0x4b72(%rip), %r14      # 0x6fc8
leaq 0x1ba7(%rip), %r15      # 0x4004
movq 0x4b74(%rip), %r12      # 0x6fd8
leaq -0x48(%rbp), %r13
leaq -0xc8(%rbp), %rbx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2190
leaq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
andq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x2200
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x24ee
movq %r13, %rdi
leaq 0x1b7d(%rip), %rsi      # 0x402b
callq 0x25fa
testb %al, %al
jne 0x24ee
movq %rbx, %rdi
leaq -0x88(%rbp), %rsi
movq %r13, %rdx
callq 0x2a2e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2c2f
movq %rax, %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x260a
movq %r13, %rdi
callq 0x20c0
jmp 0x246f
leaq -0x48(%rbp), %rdi
callq 0x20c0
leaq -0x88(%rbp), %rdi
callq 0x2634
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2517
movq %rax, %rbx
jmp 0x2530
movq %rax, %rbx
jmp 0x2539
movq %rax, %rbx
leaq -0xc8(%rbp), %rdi
callq 0x260a
leaq -0x48(%rbp), %rdi
callq 0x20c0
leaq -0x88(%rbp), %rdi
callq 0x2634
movq %rbx, %rdi
callq 0x2280