LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbp
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 0x1bfa0
movq %rax, (%r15,%r14,8)
leaq (%r12,%r14,8), %r13
testq %rbp, %rbp
je 0x27904
leaq (%r14,%r14,2), %rax
leaq (%r12,%rax,8), %rdx
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rcx
callq 0x1bfa0
testq %rax, %rax
je 0x27908
cmpq %r14, %rbp
jge 0x27933
movq (%r13,%rbp,8), %rcx
leaq 0x1(%rbp), %rax
incq %rcx
movq %rcx, (%rbx,%rbp,8)
movq %rax, %rbp
je 0x278e8
jmp 0x2790b
xorl %eax, %eax
jmp 0x2790b
movq %rbp, %rax
cmpq %rbx, %r13
setne %cl
cmpq %r14, %rax
setl %dl
andb %cl, %dl
xorl %ecx, %ecx
cmpb $0x1, %dl
jne 0x27938
movq (%r13,%rax,8), %rdx
movq %rdx, (%rbx,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0x27920
jmp 0x27938
movl $0x1, %ecx
movq %rcx, (%rbx,%r14,8)
incq %r14
movq %r14, %rax
testq %rax, %rax
jle 0x27966
movq -0x8(%r15,%rax,8), %rcx
movq -0x8(%rbx,%rax,8), %rdx
decq %rax
cmpq %rdx, %rcx
je 0x27942
xorl %ebp, %ebp
cmpq %rcx, %rdx
adcl $-0x1, %ebp
orl $0x1, %ebp
jmp 0x27968
xorl %ebp, %ebp
testl %ebp, %ebp
js 0x27978
movq (%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
jmp 0x27982
movq (%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1c1c0
sarl $0x1f, %ebp
movq %r15, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1bfa0
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_O1/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 0x2af4b
cmpq $0x44, %rbx
jle 0x2af27
cmpq $0x88, %rbx
jle 0x2af3a
cmpq $0x51a, %rbx            # imm = 0x51A
jbe 0x2af50
incq %rbx
shrq %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x306a8
movq %rbx, %rdi
movl %eax, %esi
callq 0x306e1
movq %rax, %rbx
addq %rax, %rbx
jmp 0x2af4b
incq %rbx
movabsq $0x7ffffffffffffffc, %rax # imm = 0x7FFFFFFFFFFFFFFC
orq $0x2, %rax
jmp 0x2af48
addq $0x3, %rbx
movabsq $0x7ffffffffffffffc, %rax # imm = 0x7FFFFFFFFFFFFFFC
andq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
addl $0x7, %ebx
andl $0xff8, %ebx            # imm = 0xFF8
jmp 0x2af4b
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2b3c0
cmpq $0x54, %rbx
jle 0x2b39c
cmpq $0xa8, %rbx
jle 0x2b3af
cmpq $0x472, %rbx            # imm = 0x472
jbe 0x2b3c5
incq %rbx
shrq %rbx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x306a8
movq %rbx, %rdi
movl %eax, %esi
callq 0x306e1
movq %rax, %rbx
addq %rax, %rbx
jmp 0x2b3c0
incq %rbx
movabsq $0x7ffffffffffffffc, %rax # imm = 0x7FFFFFFFFFFFFFFC
orq $0x2, %rax
jmp 0x2b3bd
addq $0x3, %rbx
movabsq $0x7ffffffffffffffc, %rax # imm = 0x7FFFFFFFFFFFFFFC
andq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
addl $0x7, %ebx
andl $0xff8, %ebx            # imm = 0xFF8
jmp 0x2b3c0
// File: /workspace/github_cpp_makefile_star2_O1/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:
testl %edx, %edx
je 0x2e622
cmpq %rdi, %rsi
cmovlq %rsi, %rdi
decq %rdi
movslq %edx, %rcx
jmp 0x2e638
cmpq %rsi, %rdi
jle 0x2e64a
decq %rdi
movq %rdi, %rax
cqto
idivq %rsi
movq %rax, %rcx
incq %rcx
movq %rdi, %rax
cqto
idivq %rcx
movq %rax, %rdi
incq %rdi
movq %rdi, %rax
retq
leaq (%rdi,%rdi,2), %rax
cmpq %rsi, %rax
jle 0x2e646
leaq -0x1(%rdi), %rax
shrq $0x3f, %rax
addq %rax, %rdi
decq %rdi
sarq %rdi
jmp 0x2e643
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2e60f
movq %rax, %r14
leaq 0x1(%rbx), %rdi
callq 0x2aee3
movq %rax, %rcx
sarq %rcx
cmpq %r14, %rcx
movq %rcx, %rdx
cmovlq %rax, %rdx
xorl %esi, %esi
cmpq %rbx, %rcx
cmovlq %rdx, %rsi
leaq (%rsi,%rax,2), %rax
addq $0x4, %rax
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_O1/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 0x2e917
movq %rax, %r14
leaq 0x1(%rbx), %rdi
callq 0x2aee3
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_O1/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 0x2feca
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 0x17e5b(%rip), %rdi     # 0x47d58
movq %rax, %rsi
callq 0x32b5c
addq $0xe8, %rsp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ff91
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 0x2fffd
cmpl $0x81, %ebp
movl $0x80, %r15d
cmovgel %ebp, %r15d
movq %r13, 0x8(%rsp)
leal (%r15,%r15), %r14d
movslq %r14d, %r12
movq %r12, %rdi
leaq 0x182f1(%rip), %rax     # 0x48298
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 0x182c7(%rip), %rax     # 0x482a8
callq *(%rax)
leal -0x1(,%r15,2), %eax
cmpl %eax, %ebp
sete %al
cmpl $-0x1, %ebp
sete %cl
orb %al, %cl
movl %r14d, %r15d
jne 0x2ff96
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_O1/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 0x3003f
movq %rdi, %r14
decq %r15
cmpq %rbx, %r15
cmovaeq %rbx, %r15
movq (%rdi), %rdi
movq %r15, %rdx
callq 0x6200
addq %r15, (%r14)
subq %r15, 0x8(%r14)
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3007a
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_O1/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 0x18113(%rip), %rax     # 0x48298
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_O1/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:
testq %rdi, %rdi
je 0x301cb
pushq %r14
pushq %rbx
pushq %rax
leaq 0x180f5(%rip), %rbx     # 0x482a8
movq (%rdi), %r14
movq 0x8(%rdi), %rsi
callq *(%rbx)
movq %r14, %rdi
testq %r14, %r14
jne 0x301b3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x0, (%rax)
testl %esi, %esi
jle 0x30ac9
incl %esi
movl $0x1, %eax
movl $0x1, %ecx
movq -0x8(%rdi,%rcx,8), %rdx
movq (%rdi,%rcx,8), %r8
movslq %eax, %r10
cmpl $0x1, %r10d
leaq (%r8,%r10,4), %r9
adcl $0x0, %r10d
xorl %r11d, %r11d
movl (%rdx,%r11,4), %ebx
leal (%rbx,%rbx), %ebp
movl %ebp, (%r8,%r11,4)
leal 0x1(,%rbx,2), %ebx
movl %ebx, (%r9,%r11,4)
incq %r11
cmpq %r11, %r10
jne 0x30aa1
incq %rcx
addl %eax, %eax
cmpq %rsi, %rcx
jne 0x30a86
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdi, %r14
movq %rcx, %rax
shlq $0x7, %rax
subq %rdx, %rax
movq %rax, %rdx
callq 0x31d86
cmpq $0x0, (%r14,%rbx,8)
je 0x32520
movq %r14, %rax
subq $0x1, (%rax)
leaq 0x8(%rax), %rax
jb 0x324e9
cmpq $0x0, (%r14,%rbx,8)
je 0x324ff
xorl %r15d, %r15d
jmp 0x3251c
movl $0x1, %r15d
testq %rbx, %rbx
je 0x3251c
leaq (,%rbx,8), %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x6170
movq %r15, (%r14,%rbx,8)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rdi, %r14
cmpq $0x1, %rdx
jne 0x32a56
movq (%r15), %rdi
callq 0x2f530
movq %rax, (%r14)
jmp 0x32b24
movq %rcx, %r12
movq %rdx, %rbx
leaq (,%rdx,8), %rdx
movq %rcx, %rdi
movl $0xff, %esi
callq 0x6170
leaq (%r12,%rbx,8), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1c300
cmpq $0x2, %rbx
jne 0x32a9d
movl $0x4, %ecx
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %r8
callq 0x1cc20
jmp 0x32b19
movq -0x8(%r15,%rbx,8), %r13
movq %r13, %rdi
callq 0x2f530
movq %rax, %r9
movq %rax, %rsi
imulq %r13, %rsi
movq -0x10(%r15,%rbx,8), %rcx
addq %rcx, %rsi
jae 0x32adc
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 0x32afa
leaq -0x1(%r9), %rsi
cmpq %r13, %rdx
jae 0x32b34
movq %rsi, %r9
leaq (%rbx,%rbx), %rdx
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rcx
movq %rbx, %r8
callq 0x2c274
subq $0x1, (%r14)
leaq 0x8(%r14), %r14
jb 0x32b0f
movl $0x1, %eax
cmpq $0x2, %rbx
jne 0x32b26
xorl %eax, %eax
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 0x32afa
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3458a
movq %r8, 0x10(%rsp)
movq %rdx, (%rdi)
movq %rcx, 0x30(%rsp)
bsrq 0x30(%rsp), %rax
xorl $-0x40, %eax
addl $0x3f, %eax
movq %rsi, 0x8(%rsp)
movq %rdi, 0x18(%rsp)
js 0x3459b
movq %r9, %r14
movq %rdx, 0x20(%rsp)
movq %rcx, 0x28(%rsp)
movl %eax, %ebx
movl $0x1, %r15d
movq %rdi, %rcx
xorl %r13d, %r13d
xorl %eax, %eax
movq %r14, %r12
movq %rcx, %r14
leaq (%rcx,%rax,8), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x1da3c
leaq (%r15,%r15), %rbp
shlq $0x4, %r15
cmpq $0x1, -0x8(%r15,%r12)
sbbq $0x0, %rbp
movq %rbp, %r15
movq 0x10(%rsp), %rax
subq %rax, %r15
movl $0x0, %ecx
cmovleq %rcx, %r15
cmovgeq %rax, %rbp
movq 0x28(%rsp), %rax
btq %rbx, %rax
jae 0x3456b
leaq (%r12,%r15,8), %rsi
movq %r12, %rdi
movq %rbp, %rdx
movq 0x20(%rsp), %rcx
callq 0x1c386
movq %rax, (%r12,%rbp,8)
cmpq $0x1, %rax
sbbq $-0x1, %rbp
xorl %eax, %eax
jmp 0x3456e
movq %r15, %rax
leaq (%r15,%r13,2), %r13
leaq -0x1(%rbx), %rdx
movq %r12, %rcx
movq %rbp, %r15
testq %rbx, %rbx
movq %rdx, %rbx
jg 0x344fd
jmp 0x345a8
movq $0x1, (%rdi)
movl $0x1, %ebx
xorl %r13d, %r13d
jmp 0x345df
xorl %eax, %eax
movl $0x1, %ebp
xorl %r13d, %r13d
movq %rdi, %r12
xorl %ecx, %ecx
movq %rbp, %rdx
movq 0x10(%rsp), %rbx
subq %rbx, %rdx
cmovlq %rbp, %rbx
cmovgq %rdx, %rcx
addq %rcx, %r13
leaq (%r12,%rcx,8), %rcx
leaq (%rcx,%rax,8), %rsi
movq 0x18(%rsp), %rdi
cmpq %rdi, %rsi
je 0x345da
movq %rbx, %rdx
callq 0x2f4c6
movq 0x8(%rsp), %rsi
movq %r13, (%rsi)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x34856
xorl %ebx, %ebx
jmp 0x34919
movq %rdx, %r14
movq %rdi, %rbx
testq %rdi, %rdi
je 0x34866
xorl %r12d, %r12d
jmp 0x348b6
movl %r15d, %eax
negl %eax
cmovsl %r15d, %eax
leaq (%rax,%rax,4), %rax
leaq 0x38b6(%rip), %rcx      # 0x38130
movq 0x8(%rcx,%rax,8), %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 0x139ea(%rip), %rax     # 0x48298
movq %r12, %rdi
callq *(%rax)
movq %rax, %rbx
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x345f4
movq %rbx, %rdi
callq 0x6120
movq %rax, %r13
cmpl $0x1, 0x14(%r14)
jne 0x348e0
movq 0x18(%r14), %rax
cmpq $0x1, (%rax)
je 0x3490c
addq $0x10, %r14
movb $0x2f, (%rbx,%r13)
leaq (%rbx,%r13), %rbp
incq %rbp
movq %rbp, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x345f4
movq %rbp, %rdi
callq 0x6120
addq %rax, %r13
incq %r13
testq %r12, %r12
je 0x34919
incq %r13
cmpq %r13, %r12
jne 0x3492b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1396e(%rip), %rax     # 0x482a0
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_O1/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 $0x28, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %r15
movq %rcx, %rbp
movq %rsi, %r12
movq %rdi, %rax
movq %rdx, 0x8(%rsp)
leaq -0x8(%rdx), %rcx
movq %rcx, 0x18(%rsp)
movq 0x10(%rsp), %r13
movq 0x18(%rsp), %rcx
leaq (%rcx,%rbp,8), %r10
cmpq $0x10, %rbp
jle 0x35351
movq 0x8(%r15), %r14
movq 0x10(%r15), %rdx
leaq (%rdx,%r14), %rbx
cmpq %rbp, %rbx
jg 0x352dc
movq (%r15), %r9
jne 0x352e2
movq %rbp, %rcx
subq %rdx, %rcx
movq %r10, %rsi
testq %rcx, %rcx
jle 0x352e2
movq -0x8(%r9,%rcx,8), %rdi
decq %rcx
leaq -0x8(%rsi), %r8
cmpq %rdi, (%rsi)
movq %r8, %rsi
je 0x352c1
ja 0x352e2
addq $-0x28, %r15
jmp 0x35298
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rax
leaq (%rax,%rdx,8), %rcx
subq %rdx, %rbp
movq %r14, (%rsp)
movq %r13, %rdi
movq %rcx, %rsi
xorl %edx, %edx
movq %rbp, %r8
callq 0x1fcb0
subq %r14, %rbp
cmpq $0x1, (%r13,%rbp,8)
sbbq $-0x1, %rbp
movl $0x0, %esi
testq %r12, %r12
je 0x35325
subq 0x18(%r15), %r12
movq %r12, %rsi
leaq -0x28(%r15), %r14
movq 0x10(%rsp), %rdx
leaq (%rdx,%rbp,8), %r9
movq 0x20(%rsp), %rdi
movq %rbp, %rcx
movq %r14, %r8
callq 0x3525d
movq 0x18(%r15), %r12
movq %rbx, %rbp
movq %r14, %r15
jmp 0x3528f
testq %rbp, %rbp
je 0x3537b
movl 0x20(%r15), %r8d
movq %rax, %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rdx
movq %rbp, %rcx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34f56
testq %r12, %r12
je 0x35396
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %rax, %rbx
callq 0x6170
movq %rbx, %rax
addq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x5, %edi
callq 0x133b
movl %eax, %r14d
movq 0x2ddd(%rip), %rbx      # 0x3fd8
leaq 0xe02(%rip), %rsi       # 0x2004
movl $0x6, %edx
movq %rbx, %rdi
callq 0x1070
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1090
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movl $0x5, %edi
callq 0x133b
movl %eax, %r15d
movq %rbx, %rdi
movl $0x5, %esi
callq 0x1090
movq %rax, %r12
leaq 0xd9d(%rip), %r14       # 0x2005
movl $0x5, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1070
movq %r12, %rdi
movl %r15d, %esi
callq 0x1090
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r15, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movl $0x3, %edi
callq 0x133b
movl %eax, %r15d
movq %rbx, %rdi
movl $0x3, %esi
callq 0x1090
movq %rax, %rbx
movl $0x5, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1070
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1090
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
xorl %eax, %eax
movl $0xa, %ecx
leaq 0xde9(%rip), %r14       # 0x2010
leal (%rax,%rcx), %esi
movl %esi, %edx
shrl $0x1f, %edx
addl %esi, %edx
sarl %edx
movslq %edx, %rsi
cmpl $0x5, (%r14,%rsi,4)
jge 0x1241
movl %edx, %eax
jmp 0x1243
movl %edx, %ecx
movl %ecx, %edx
subl %eax, %edx
cmpl $0x1, %edx
jg 0x1227
movslq %eax, %rcx
cmpl $0x4, (%r14,%rcx,4)
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
cmovel %eax, %esi
movq 0x2d75(%rip), %rdi      # 0x3fd8
callq 0x1080
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %r15d
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
xorl %eax, %eax
leal (%rax,%r15), %edx
movl %edx, %ecx
shrl $0x1f, %ecx
addl %edx, %ecx
sarl %ecx
movslq %ecx, %rdx
cmpl $0x81, (%r14,%rdx,4)
jge 0x12b8
movl %ecx, %eax
jmp 0x12bb
movl %ecx, %r15d
movl %r15d, %ecx
subl %eax, %ecx
cmpl $0x1, %ecx
jg 0x129a
movslq %eax, %rcx
cmpl $0x80, (%r14,%rcx,4)
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
cmovel %eax, %esi
movq 0x2cf9(%rip), %rdi      # 0x3fd8
callq 0x1080
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %r15d
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
xorl %eax, %eax
leal (%rax,%r15), %edx
movl %edx, %ecx
shrl $0x1f, %ecx
addl %edx, %ecx
sarl %ecx
movslq %ecx, %rdx
cmpl $0x1f5, (%r14,%rdx,4)   # imm = 0x1F5
jge 0x1334
movl %ecx, %eax
jmp 0x1337
movl %ecx, %r15d
movl %r15d, %ecx
subl %eax, %ecx
cmpl $0x1, %ecx
jg 0x1316
movslq %eax, %rcx
cmpl $0x1f4, (%r14,%rcx,4)   # imm = 0x1F4
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
cmovel %eax, %esi
movq 0x2c7d(%rip), %rdi      # 0x3fd8
callq 0x1080
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 -0xc8(%rbp), %rdi
callq 0x28a8
leaq -0x38(%rbp), %r15
movq 0x5b0e(%rip), %r14      # 0x7fc8
leaq -0x48(%rbp), %r13
leaq -0x88(%rbp), %rbx
movq %rbx, %r12
movl $0x26, %edx
movq %r14, %rdi
leaq 0x2b2d(%rip), %rsi      # 0x5004
callq 0x21e0
movq %r15, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
movq 0x5ae5(%rip), %rdi      # 0x7fd8
movq %r13, %rsi
callq 0x2210
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0x2510
xorl %ebx, %ebx
jmp 0x25a4
movq %r13, %rdi
leaq 0x2b11(%rip), %rsi      # 0x502b
callq 0x2080
testl %eax, %eax
je 0x2509
movq %rbx, %rdi
leaq -0xc8(%rbp), %rsi
movq %r13, %rdx
callq 0x2bfc
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2f1e
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x2578
callq 0x2788
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x2586
callq 0x2788
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x25a2
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x21b0
movb $0x1, %bl
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x25b9
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21b0
testb %bl, %bl
movq %r12, %rbx
jne 0x24c8
leaq -0xb8(%rbp), %rbx
movq %rbx, %rdi
callq 0x2802
movq -0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x25e1
callq 0x2788
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x260b
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x2714
jmp 0x260e
movq %rax, %rbx
jmp 0x2623
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x2623
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21b0
leaq -0xc8(%rbp), %rdi
callq 0x275e
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH12_DynamicMemory/examples/querymain.cc
// Function: main
int main(int argc, char **argv)
{
    // open the file from which user will query words
    ifstream infile;
	// open returns void, so we use the comma operator XREF(commaOp)
	// to check the state of infile after the open
    if (argc < 2 || !(infile.open(argv[1]), infile)) {
        cerr << "No input file!" << endl;
        return EXIT_FAILURE;
    }
	runQueries(infile);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rsi, %rbx
movl %edi, %r14d
leaq -0x218(%rbp), %rdi
callq 0x21d0
cmpl $0x2, %r14d
jl 0x2687
movq 0x8(%rbx), %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x20e0
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x1f8(%rbp,%rax)
je 0x26ec
movq 0x5962(%rip), %rbx      # 0x7ff0
leaq 0x2998(%rip), %rsi      # 0x502d
movl $0xe, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq 0x5930(%rip), %rdi      # 0x7ff0
callq 0x2030
movl $0x1, %ebx
movq %rax, %rdi
callq 0x2120
leaq -0x218(%rbp), %rdi
callq 0x2060
movl %ebx, %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %rbp
retq
xorl %ebx, %ebx
leaq -0x218(%rbp), %rdi
callq 0x248c
jmp 0x26d2
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O1/errantlinguist[P]Forecast/src/main.cpp
// Function: createJsonParseErrorMessage[abi:cxx11](std::exception const&)
static std::string createJsonParseErrorMessage(const std::exception& e)
{
	std::stringstream errorMessage(std::stringstream::out);
	errorMessage << "There was an error parsing the server response as JSON: ";
	errorMessage << e.what() << std::endl;
	return errorMessage.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x9220
leaq 0x18(%rsp), %r14
leaq 0x1e016(%rip), %rsi     # 0x2a1d4
movl $0x38, %edx
movq %r14, %rdi
callq 0x95c0
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
testq %rax, %rax
je 0xc1f4
movq %rax, %r15
movq %rax, %rdi
callq 0x91e0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x95c0
jmp 0xc20d
movq 0x18(%rsp), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x38(%rsp,%rax), %esi
orl $0x1, %esi
callq 0x9690
movq 0x18(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x9650
movsbl %al, %esi
movq %r14, %rdi
callq 0x9320
movq %rax, %rdi
callq 0x92b0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x91d0
movq 0x32d56(%rip), %rsi     # 0x3efa0
leaq 0x8(%rsp), %rdi
callq 0x9470
leaq 0x88(%rsp), %rdi
callq 0x9420
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x32d25(%rip), %rsi     # 0x3efa0
leaq 0x8(%rsp), %rdi
callq 0x9470
leaq 0x88(%rsp), %rdi
callq 0x9420
movq %rbx, %rdi
callq 0x9390
// File: /workspace/github_cpp_makefile_star2_O1/errantlinguist[P]Forecast/src/main.cpp
// Function: printCurlErrorMessage(char const* const&)
static void printCurlErrorMessage(const char* const& pCurlErrorMessage)
{
	if (std::strcmp(pCurlErrorMessage, "") == 0)
	{
		std::cerr << DEFAULT_URL_GETTER_ERROR_MESSAGE << std::endl;
	} else
	{
		std::cerr << "An error occurred while getting the given URL: " << pCurlErrorMessage << std::endl;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
cmpb $0x0, (%rax)
je 0xc2e3
movq %rdi, %r14
movq 0x32d10(%rip), %rbx     # 0x3efc0
leaq 0x1dff9(%rip), %rsi     # 0x2a2b0
movl $0x2f, %edx
movq %rbx, %rdi
callq 0x95c0
movq (%r14), %r14
testq %r14, %r14
je 0xc2fd
movq %r14, %rdi
callq 0x91e0
movq 0x32ce5(%rip), %rdi     # 0x3efc0
movq %r14, %rsi
movq %rax, %rdx
jmp 0xc2f6
movq 0x32cd6(%rip), %rdi     # 0x3efc0
leaq 0x1deb4(%rip), %rsi     # 0x2a1a5
movl $0x2e, %edx
callq 0x95c0
jmp 0xc314
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x9690
movq 0x32ca5(%rip), %rbx     # 0x3efc0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x9650
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9320
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x92b0
// File: /workspace/github_cpp_makefile_star2_O1/errantlinguist[P]Forecast/src/main.cpp
// Function: isLastResponseContentInvalid(curl::CallbackClient const&, char* const&)
static bool isLastResponseContentInvalid(const curl::CallbackClient& curlClient, char* const& pInfoBuffer)
{
	bool result(false);

	CURLcode infoGetterCode = curlClient.getInfo(CURLINFO_CONTENT_TYPE, pInfoBuffer);
	if (CURLE_OK == infoGetterCode && pInfoBuffer != NULL)
	{
		const std::string infoType(pInfoBuffer);
		std::smatch jsonMatch;
		result = (!std::regex_match(infoType, jsonMatch, VALID_CONTENT_TYPE_REGEX));
	}

	return result;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq (%rsi), %rdx
movl $0x100012, %esi         # imm = 0x100012
callq 0x1b90a
testl %eax, %eax
setne %al
movq (%rbx), %rsi
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0xc376
xorl %ebx, %ebx
jmp 0xc3e7
leaq 0x28(%rsp), %rbx
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0xc420
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
addq %rdi, %rsi
leaq 0x334ea(%rip), %rcx     # 0x3f890
movq %rsp, %rdx
xorl %r8d, %r8d
callq 0xc954
movl %eax, %ebx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xc3c9
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x90a0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc3e4
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x90a0
xorb $0x1, %bl
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xc40a
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x90a0
movq %rsp, %rdi
leaq 0x28(%rsp), %rsi
callq 0x9712
movq %rbx, %rdi
callq 0x9390
nop
// File: /workspace/github_cpp_makefile_star2_O1/errantlinguist[P]Forecast/src/common/TimeWriter.cpp
// Function: common::TimeWriter::write(tm const*, std::ostream&)
void TimeWriter::write(const struct tm* value, std::ostream& output)
{
	std::unique_ptr<char[]> pBuffer(new char[maxLength]);
	char* const rawpBuffer = pBuffer.get();
	std::strftime(rawpBuffer, maxLength, format, value);
	output << rawpBuffer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x10(%rdi), %r13
movq %r13, %rdi
callq 0x9250
movq %rax, %rbx
movq 0x8(%r12), %rdx
movq %rax, %rdi
movq %r13, %rsi
movq %r15, %rcx
callq 0x9520
movq %rbx, %rdi
callq 0x91e0
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x95c0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x91b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x91b0
movq %r14, %rdi
callq 0x9390
// File: /workspace/github_cpp_makefile_star2_O1/errantlinguist[P]Forecast/src/common/to_string.cpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> common::to_quoted_string<char>(char const&)
std::string to_quoted_string(const char& value)
{
	std::stringstream ss(std::stringstream::out);

	ss << CHAR_VALUE_DELIMITER;
	ss << value;
	ss << CHAR_VALUE_DELIMITER;

	return ss.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x9220
leaq 0x18(%rsp), %r14
leaq 0x7(%rsp), %rsi
movb $0x27, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x95c0
movb (%r15), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x95c0
leaq 0x7(%rsp), %rsi
movb $0x27, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x95c0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x91d0
movq 0x25165(%rip), %rsi     # 0x3efa0
leaq 0x8(%rsp), %rdi
callq 0x9470
leaq 0x88(%rsp), %rdi
callq 0x9420
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x25134(%rip), %rsi     # 0x3efa0
leaq 0x8(%rsp), %rdi
callq 0x9470
leaq 0x88(%rsp), %rdi
callq 0x9420
movq %rbx, %rdi
callq 0x9390
// File: /workspace/github_cpp_makefile_star2_O1/errantlinguist[P]Forecast/src/common/to_string.cpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> common::to_quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string to_quoted_string(const std::string& value)
{
	std::stringstream ss(std::stringstream::out);

	ss << STRING_VALUE_DELIMITER;
	ss << value;
	ss << STRING_VALUE_DELIMITER;

	return ss.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x9220
leaq 0x18(%rsp), %r14
leaq 0x7(%rsp), %rsi
movb $0x22, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x95c0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x95c0
leaq 0x7(%rsp), %rsi
movb $0x22, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x95c0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x91d0
movq 0x250a2(%rip), %rsi     # 0x3efa0
leaq 0x8(%rsp), %rdi
callq 0x9470
leaq 0x88(%rsp), %rdi
callq 0x9420
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x25071(%rip), %rsi     # 0x3efa0
leaq 0x8(%rsp), %rdi
callq 0x9470
leaq 0x88(%rsp), %rdi
callq 0x9420
movq %rbx, %rdi
callq 0x9390
// File: /workspace/github_cpp_makefile_star2_O1/errantlinguist[P]Forecast/src/console_weather/ForecastServiceClient.cpp
// Function: console_weather::ForecastServiceClient::get(char const*)
std::unique_ptr<forecast_io::Forecast> ForecastServiceClient::get(const char* url)
{
    // Create parsers
    std::unique_ptr<forecast_io::factories::ForecastFactory> pForecastFactory(
        new forecast_io::factories::ForecastFactory(measurementUnits));
    std::unique_ptr<forecast_io::factories::FlagsFactory> pFlagsFactory(
        new forecast_io::factories::FlagsFactory(measurementUnits));
    std::unique_ptr<forecast_io::parsers::ParserManager> pParserManager(
        new forecast_io::parsers::ParserManager(pForecastFactory.get(), pFlagsFactory.get()));

    forecast_io::parsers::NotifyingForecastParser& forecastParser =
        pParserManager->getForecastParser();
    json::TokenerParser tokenerParser(forecastParser);
    const CURLcode responseCode =
        curlClient.read(
            url,
            parseJson, &tokenerParser);

    std::unique_ptr<forecast_io::Forecast> result = nullptr;
    if (CURLE_OK == responseCode)
    {
        result = pForecastFactory->create();
    }
    else
    {
		throw responseCode;
    }
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r15
movl $0x78, %edi
callq 0x90e0
movq %rax, %rbx
movq 0x8(%rbp), %rsi
movq %rax, %rdi
callq 0x1fb70
movl $0xa0, %edi
callq 0x90e0
movq %rax, %r14
movq 0x8(%rbp), %rsi
movq %rax, %rdi
callq 0x1f8dc
movl $0x348, %edi            # imm = 0x348
callq 0x90e0
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x28df0
movq (%r12), %rax
movq %r12, %rdi
callq *0x48(%rax)
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x2929c
movq (%rbp), %rdi
leaq 0xf5(%rip), %rdx        # 0x1a107
leaq 0x10(%rsp), %rcx
movl $0x1e, %r8d
movq %r13, %rsi
callq 0x1b916
movl %eax, %ebp
movq $0x0, (%r15)
testl %eax, %eax
jne 0x1a099
movq (%rbx), %rax
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq *0x10(%rax)
leaq 0x8(%rsp), %r13
movq (%r13), %rsi
movq $0x0, (%r13)
movq %r15, %rdi
callq 0x1a186
movq %r13, %rdi
callq 0xc4f0
leaq 0x10(%rsp), %rdi
callq 0x292c6
movq (%r12), %rax
movq %r12, %rdi
callq *0x8(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x4, %edi
callq 0x91c0
movl %ebp, (%rax)
leaq 0x22fbc(%rip), %rsi     # 0x3d068
movq %rax, %rdi
xorl %edx, %edx
callq 0x9370
jmp 0x1a0b8
movq %rax, %r13
movq %r15, %rdi
callq 0xc4f0
jmp 0x1a0c8
movq %rax, %r13
leaq 0x10(%rsp), %rdi
callq 0x292c6
jmp 0x1a0d9
jmp 0x1a0d6
movq %rax, %r13
movq (%r12), %rax
movq %r12, %rdi
callq *0x8(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r13, %rdi
callq 0x9390
movq %rax, %r13
jmp 0x1a0e3
movq %rax, %r13
jmp 0x1a0ec
// File: /workspace/github_cpp_makefile_star2_O1/errantlinguist[P]Forecast/src/console_weather/ForecastServiceClient.cpp
// Function: console_weather::parseJson(char*, unsigned long, unsigned long, void*)
static size_t parseJson(char* readBuffer, size_t size, size_t nmemb,
                        void* pUserData)
{
    size_t result(0);
    if(pUserData)
    {
        json::TokenerParser* const pTokenerParser =
            static_cast<json::TokenerParser*>(pUserData);
        // Calculate the amount of bytes to be parsed
        result = size * nmemb;
        // Check that the size does not overflow as an int type
        if(result <= MAX_PARSER_INPUT_SIZE)
        {
			const int inputSize = static_cast<int>(result);
            pTokenerParser->parse(readBuffer, inputSize);
        }
        else
        {
            throw std::out_of_range("Amount of bytes to read cannot be stored as an int.");
        }

    }

    return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
testq %rcx, %rcx
je 0x1a133
movq %rdx, %rbx
imulq %rsi, %rbx
cmpq $0x7fffffff, %rbx       # imm = 0x7FFFFFFF
ja 0x1a140
movq %rsp, %rsi
movq %rcx, %rdi
movl %ebx, %edx
callq 0x292fc
jmp 0x1a135
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x91c0
movq %rax, %rbx
leaq 0x10ff2(%rip), %rsi     # 0x2b146
movq %rax, %rdi
callq 0x9140
movq 0x24de5(%rip), %rsi     # 0x3ef48
movq 0x24e1e(%rip), %rdx     # 0x3ef88
movq %rbx, %rdi
callq 0x9370
movq %rax, %r14
movq %rbx, %rdi
callq 0x9510
movq %r14, %rdi
callq 0x9390
nop