LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/loop.cpp
// Function: ForeachLoopNode::Provision()
bool ForeachLoopNode::Provision()
{
        VariableDef * key = new VariableDef(this->Key);
        VariableDef * value = new VariableDef(this->Value);

        key->SetVarType(String);
        value->SetVarType(Null);

        this->AddVariable(key);
        this->AddVariable(value);
        
        this->KeyIndex   = key->GetVarIndex();
        this->ValueIndex = value->GetVarIndex();
        
        if(ForLoopNode::Provision()!=true)
        {
                return false;
        }

        CollectionExpr->SetParentNode(this);
        if(CollectionExpr->Provision()==false)
        {
                return false;
        }

        return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
movl $0x40, %edi
callq 0x6260
movq %rax, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x80(%r14), %rsi
movq 0x88(%r14), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x99a6
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x1884e
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x19466
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6270
movl $0x40, %edi
callq 0x6260
movq %rax, %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0xa0(%r14), %rsi
movq 0xa8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x99a6
movq %rsp, %rsi
movq %r15, %rdi
callq 0x1884e
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x194b7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6270
movq %rbx, %rdi
movl $0x4, %esi
callq 0x18964
xorl %ebp, %ebp
movq %r15, %rdi
xorl %esi, %esi
callq 0x18964
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc34c
movq %r14, %rdi
movq %r15, %rsi
callq 0xc34c
movq %rbx, %rdi
callq 0x189a0
movq %rax, 0xc0(%r14)
movq %r15, %rdi
callq 0x189a0
movq %rax, 0xc8(%r14)
movq %r14, %rdi
callq 0x19004
testb %al, %al
je 0x1952e
movq 0xd0(%r14), %rdi
movq %r14, %rsi
callq 0x9fb8
movq 0xd0(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ebp
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1955b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0x1955b
movq %rax, %r14
movq %r15, %rbx
jmp 0x1957f
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x1957f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0x1957f
movq %rax, %r14
movl $0x40, %esi
movq %rbx, %rdi
callq 0x6270
movq %r14, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/3rdparty/gmp/mpf/init.c
// Function: _gmpf_init
void
mpf_init (mpf_ptr r)
{
  mp_size_t prec = __gmp_default_fp_limb_precision;
  r->_mp_size = 0;
  r->_mp_exp = 0;
  r->_mp_prec = prec;
  r->_mp_d = __GMP_ALLOCATE_FUNC_LIMBS (prec + 1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x2d86d(%rip), %rax     # 0x47288
movq (%rax), %rax
movl $0x0, 0x4(%rdi)
movq $0x0, 0x8(%rdi)
movl %eax, (%rdi)
leaq 0x2d85a(%rip), %rcx     # 0x47290
leaq 0x8(,%rax,8), %rdi
callq *(%rcx)
movq %rax, 0x10(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/3rdparty/gmp/mpf/iset_ui.c
// Function: _gmpf_init_set_ui
void
mpf_init_set_ui (mpf_ptr r, unsigned long int val)
{
  mp_size_t prec = __gmp_default_fp_limb_precision;
  mp_size_t size;

  r->_mp_prec = prec;
  r->_mp_d = __GMP_ALLOCATE_FUNC_LIMBS (prec + 1);
  r->_mp_d[0] = val & GMP_NUMB_MASK;
  size = (val != 0);

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

  r->_mp_size = size;
  r->_mp_exp = size;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2d013(%rip), %rax     # 0x47288
movq (%rax), %rax
movl %eax, (%rdi)
leaq 0x2d00f(%rip), %rcx     # 0x47290
leaq 0x8(,%rax,8), %rdi
callq *(%rcx)
movq %rax, 0x10(%r14)
movq %rbx, (%rax)
xorl %eax, %eax
testq %rbx, %rbx
setne %al
movl %eax, 0x4(%r14)
movq %rax, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/3rdparty/gmp/mpf/iset_si.c
// Function: _gmpf_init_set_si
void
mpf_init_set_si (mpf_ptr r, long int val)
{
  mp_size_t prec = __gmp_default_fp_limb_precision;
  mp_size_t size;
  mp_limb_t vl;

  r->_mp_prec = prec;
  r->_mp_d = __GMP_ALLOCATE_FUNC_LIMBS (prec + 1);

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
testq %rsi, %rsi
setne %r15b
movl %r15d, %ebp
negl %ebp
testq %rsi, %rsi
leaq 0x2cfb6(%rip), %rax     # 0x47288
movq (%rax), %rax
movl %eax, (%rdi)
leaq 0x2cfb2(%rip), %rcx     # 0x47290
leaq 0x8(,%rax,8), %rdi
cmovnsl %r15d, %ebp
callq *(%rcx)
movq %r14, %rcx
negq %rcx
cmovsq %r14, %rcx
movq %rax, 0x10(%rbx)
movq %rcx, (%rax)
movq %r15, 0x8(%rbx)
movl %ebp, 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/3rdparty/gmp/mpf/iset_str.c
// Function: _gmpf_init_set_str
int
mpf_init_set_str (mpf_ptr r, const char *s, int base)
{
  mp_size_t prec = __gmp_default_fp_limb_precision;
  r->_mp_size = 0;
  r->_mp_exp = 0;
  r->_mp_prec = prec;
  r->_mp_d = __GMP_ALLOCATE_FUNC_LIMBS (prec + 1);

  return mpf_set_str (r, s, base);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x2cf64(%rip), %rax     # 0x47288
movq (%rax), %rax
movl $0x0, 0x4(%rdi)
movq $0x0, 0x8(%rdi)
movl %eax, (%rdi)
leaq 0x2cf51(%rip), %rcx     # 0x47290
leaq 0x8(,%rax,8), %rdi
callq *(%rcx)
movq %rax, 0x10(%r15)
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x19a98
nop
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/3rdparty/gmp/mpf/cmp.c
// Function: _gmpf_cmp
int
mpf_cmp (mpf_srcptr u, mpf_srcptr v) __GMP_NOTHROW
{
  mp_srcptr up, vp;
  mp_size_t usize, vsize;
  mp_exp_t uexp, vexp;
  int cmp;
  int usign;

  usize = SIZ(u);
  vsize = SIZ(v);
  usign = usize >= 0 ? 1 : -1;

  /* 1. Are the signs different?  */
  if ((usize ^ vsize) >= 0)
    {
      /* U and V are both non-negative or both negative.  */
      if (usize == 0)
	/* vsize >= 0 */
	return -(vsize != 0);
      if (vsize == 0)
	/* usize >= 0 */
	return usize != 0;
      /* Fall out.  */
    }
  else
    {
      /* Either U or V is negative, but not both.  */
      return usign;
    }

  /* U and V have the same sign and are both non-zero.  */

  uexp = EXP(u);
  vexp = EXP(v);

  /* 2. Are the exponents different?  */
  if (uexp > vexp)
    return usign;
  if (uexp < vexp)
    return -usign;

  usize = ABS (usize);
  vsize = ABS (vsize);

  up = PTR (u);
  vp = PTR (v);

#define STRICT_MPF_NORMALIZATION 0
#if ! STRICT_MPF_NORMALIZATION
  /* Ignore zeroes at the low end of U and V.  */
  do {
    mp_limb_t tl;
    tl = up[0];
    MPN_STRIP_LOW_ZEROS_NOT_ZERO (up, usize, tl);
    tl = vp[0];
    MPN_STRIP_LOW_ZEROS_NOT_ZERO (vp, vsize, tl);
  } while (0);
#endif

  if (usize > vsize)
    {
      cmp = mpn_cmp (up + usize - vsize, vp, vsize);
      /* if (cmp == 0) */
      /*	return usign; */
      ++cmp;
    }
  else if (vsize > usize)
    {
      cmp = mpn_cmp (up, vp + vsize - usize, usize);
      /* if (cmp == 0) */
      /*	return -usign; */
    }
  else
    {
      cmp = mpn_cmp (up, vp, usize);
      if (cmp == 0)
	return 0;
    }
  return cmp > 0 ? usign : -usign;
}

// Assembly:
movslq 0x4(%rdi), %r8
movslq 0x4(%rsi), %r9
movl %r8d, %ecx
sarl $0x1f, %ecx
orl $0x1, %ecx
movq %r9, %rax
xorq %r8, %rax
js 0x1b8e0
testl %r8d, %r8d
je 0x1b8e3
testl %r9d, %r9d
je 0x1b8eb
movl %r8d, %eax
notl %eax
sarl $0x1f, %eax
orl $0x1, %eax
movq 0x8(%rsi), %rdx
cmpq %rdx, 0x8(%rdi)
jle 0x1b8f1
movl %ecx, %eax
retq
xorl %eax, %eax
negl %r9d
sbbl %eax, %eax
retq
movl $0x1, %eax
retq
jge 0x1b8f4
retq
movq %r8, %rdx
negq %rdx
cmovsq %r8, %rdx
movq %r9, %r8
negq %r8
cmovsq %r9, %r8
movq 0x10(%rdi), %rdi
movq 0x10(%rsi), %r9
cmpq $0x0, (%rdi)
je 0x1b91b
movq %rdi, %rsi
jmp 0x1b92c
decq %rdx
leaq 0x8(%rdi), %rsi
cmpq $0x0, 0x8(%rdi)
movq %rsi, %rdi
je 0x1b91b
cmpq $0x0, (%r9)
je 0x1b937
movq %r9, %rdi
jmp 0x1b948
decq %r8
leaq 0x8(%r9), %rdi
cmpq $0x0, 0x8(%r9)
movq %rdi, %r9
je 0x1b937
cmpq %r8, %rdx
jle 0x1b970
leaq (%rsi,%rdx,8), %rdx
addq $-0x8, %rdx
testq %r8, %r8
jle 0x1b8e0
movq -0x8(%rdi,%r8,8), %rsi
decq %r8
leaq -0x8(%rdx), %r9
cmpq %rsi, (%rdx)
movq %r9, %rdx
je 0x1b955
jmp 0x1b9b2
jge 0x1b99a
leaq (%rdi,%r8,8), %rdi
addq $-0x8, %rdi
testq %rdx, %rdx
jle 0x1b8f3
leaq -0x1(%rdx), %r8
movq (%rdi), %r9
addq $-0x8, %rdi
cmpq %r9, -0x8(%rsi,%rdx,8)
movq %r8, %rdx
je 0x1b97a
jmp 0x1b9b2
testq %rdx, %rdx
jle 0x1b9bd
movq -0x8(%rdi,%rdx,8), %r8
leaq -0x1(%rdx), %r9
cmpq %r8, -0x8(%rsi,%rdx,8)
movq %r9, %rdx
je 0x1b99a
ja 0x1b8e0
jmp 0x1b8f3
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/3rdparty/gmp/mpn/../gmp.h
// Function: _gmpn_neg
mp_limb_t
mpn_neg (mp_ptr __gmp_rp, mp_srcptr __gmp_up, mp_size_t __gmp_n)
{
  while (*__gmp_up == 0) /* Low zero limbs are unchanged by negation. */
    {
      *__gmp_rp = 0;
      if (!--__gmp_n) /* All zero */
	return 0;
      ++__gmp_up; ++__gmp_rp;
    }

  *__gmp_rp = (- *__gmp_up) & GMP_NUMB_MASK;

  if (--__gmp_n) /* Higher limbs get complemented. */
    mpn_com (++__gmp_rp, ++__gmp_up, __gmp_n);

  return 1;
}

// Assembly:
pushq %rbx
movq (%rsi), %rax
testq %rax, %rax
jne 0x1bdb3
leaq -0x1(%rdx), %r8
xorl %ebx, %ebx
xorl %ecx, %ecx
xorl %r9d, %r9d
movq $0x0, (%rdi,%r9,8)
cmpq %r9, %r8
je 0x1bdd0
movq 0x8(%rsi,%r9,8), %rax
incq %r9
addq $-0x8, %rcx
testq %rax, %rax
je 0x1bd8c
subq %r9, %rdx
subq %rcx, %rsi
subq %rcx, %rdi
negq %rax
movq %rax, (%rdi)
movl $0x1, %ebx
decq %rdx
je 0x1bdd0
addq $0x8, %rdi
addq $0x8, %rsi
callq 0x1bde0
movq %rbx, %rax
popq %rbx
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq $0x0, -0x30(%rbp)
movq %rsi, %rax
xorq %rcx, %rax
movq %rdx, %rcx
xorq %r8, %rcx
orq %rax, %rcx
jne 0x1e3ec
leaq (%rbx,%rbx), %rdi
callq 0x2afcf
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 0x1e476
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 0x2abd8
jmp 0x1e457
movq %r8, %r12
leaq (%r8,%rbx), %rdi
callq 0x2ab71
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 0x1e487
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 0x2a51a
addq $0x10, %rsp
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
jne 0x1e46f
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2fde3
jmp 0x1e460
leaq -0x30(%rbp), %rdi
callq 0x2fdb0
movq %rax, %r8
jmp 0x1e3d8
leaq -0x30(%rbp), %rdi
callq 0x2fdb0
jmp 0x1e436
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
xorl %ebp, %ebp
testq %rcx, %rcx
jle 0x22eed
movq %rbx, %rcx
movq -0x8(%r14,%rcx,8), %rax
cmpq %rax, -0x8(%r15,%rcx,8)
jne 0x22ece
movq $0x0, -0x8(%rdi,%rcx,8)
decq %rcx
leaq 0x1(%rcx), %rax
cmpq $0x1, %rax
ja 0x22eaa
jmp 0x22eed
jbe 0x22edd
movq %r15, %rsi
movq %r14, %rdx
callq 0x1bca0
jmp 0x22eed
movq %r14, %rsi
movq %r15, %rdx
callq 0x1bca0
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %r15, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1ba80
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %ebp
movq %r8, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, %rdi
movq %r12, %rsi
testl %ecx, %ecx
je 0x26a26
movq %r15, %rcx
callq 0x2f670
jmp 0x26a2e
movq %r15, %rcx
callq 0x2f530
movl 0x40(%rsp), %r13d
movq %r12, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
cmpl $0x1, %ebp
jne 0x26a4b
callq 0x2f670
jmp 0x26a64
callq 0x1bca0
testl %ebp, %ebp
jle 0x26a64
movq %r12, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x300c0
testl %r13d, %r13d
jle 0x26a7a
movq %r14, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %r13d, %ecx
callq 0x300c0
leaq (%r12,%rbx,8), %rdi
leaq (,%rbx,8), %r13
movq %r15, %rcx
subq %rbx, %rcx
movq %rdi, %rsi
movq %r14, %rdx
callq 0x1ba80
leaq (%r12,%r15,8), %rcx
movq %rax, (%rcx)
leaq (%r14,%r15,8), %rdx
subq %r13, %rdx
addq (%rdx), %rax
movq %rax, (%rcx)
jae 0x26b01
cmpq $0x2, %rbx
movl $0x1, %edi
movl $0x1, %esi
cmovgeq %rbx, %rsi
cmpq %rdi, %rsi
je 0x26b29
movq (%rdx,%rdi,8), %r8
leaq 0x1(%rdi), %rax
incq %r8
movq %r8, (%rcx,%rdi,8)
movq %rax, %rdi
je 0x26abf
cmpq %rcx, %rdx
setne %sil
cmpq %rbx, %rax
setl %dil
andb %sil, %dil
cmpb $0x1, %dil
jne 0x26b29
movq (%rdx,%rax,8), %rsi
movq %rsi, (%rcx,%rax,8)
incq %rax
cmpq %rbx, %rax
jl 0x26aef
jmp 0x26b29
cmpq %rcx, %rdx
sete %al
cmpq $0x2, %rbx
setl %sil
orb %al, %sil
jne 0x26b29
movl $0x1, %eax
movq (%rdx,%rax,8), %rsi
movq %rsi, (%rcx,%rax,8)
incq %rax
cmpq %rax, %rbx
jne 0x26b19
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1ba80
movq %rax, (%r15,%r14,8)
leaq (%r12,%r14,8), %r13
testq %rbp, %rbp
je 0x275b8
leaq (%r14,%r14,2), %rax
leaq (%r12,%rax,8), %rdx
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rcx
callq 0x1ba80
testq %rax, %rax
je 0x275bc
cmpq %r14, %rbp
jge 0x275e7
movq (%r13,%rbp,8), %rcx
leaq 0x1(%rbp), %rax
incq %rcx
movq %rcx, (%rbx,%rbp,8)
movq %rax, %rbp
je 0x2759c
jmp 0x275bf
xorl %eax, %eax
jmp 0x275bf
movq %rbp, %rax
cmpq %rbx, %r13
setne %cl
cmpq %r14, %rax
setl %dl
andb %cl, %dl
xorl %ecx, %ecx
cmpb $0x1, %dl
jne 0x275ec
movq (%r13,%rax,8), %rdx
movq %rdx, (%rbx,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0x275d4
jmp 0x275ec
movl $0x1, %ecx
movq %rcx, (%rbx,%r14,8)
incq %r14
movq %r14, %rax
testq %rax, %rax
jle 0x27610
movq -0x8(%rbx,%rax,8), %rcx
leaq -0x1(%rax), %rdx
cmpq %rcx, -0x8(%r15,%rax,8)
movq %rdx, %rax
je 0x275f6
jbe 0x27626
movq (%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1bca0
xorl %ebp, %ebp
jmp 0x2763d
movq (%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1bca0
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %r15, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1ba80
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_O3/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 0x2abd3
cmpq $0x44, %rbx
jbe 0x2abb5
cmpq $0x88, %rbx
jbe 0x2abbf
cmpq $0x51a, %rbx            # imm = 0x51A
jbe 0x2abca
incq %rbx
shrq %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x302e8
movq %rbx, %rdi
movl %eax, %esi
callq 0x30321
movq %rax, %rbx
addq %rax, %rbx
jmp 0x2abd3
incl %ebx
andl $0xfe, %ebx
jmp 0x2abd3
addl $0x3, %ebx
andl $0x1fc, %ebx            # imm = 0x1FC
jmp 0x2abd3
addl $0x7, %ebx
andl $0xff8, %ebx            # imm = 0xFF8
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2b034
cmpq $0x54, %rbx
jbe 0x2b016
cmpq $0xa8, %rbx
jbe 0x2b020
cmpq $0x472, %rbx            # imm = 0x472
jbe 0x2b02b
incq %rbx
shrq %rbx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x302e8
movq %rbx, %rdi
movl %eax, %esi
callq 0x30321
movq %rax, %rbx
addq %rax, %rbx
jmp 0x2b034
incl %ebx
andl $0xfe, %ebx
jmp 0x2b034
addl $0x3, %ebx
andl $0x1fc, %ebx            # imm = 0x1FC
jmp 0x2b034
addl $0x7, %ebx
andl $0xff8, %ebx            # imm = 0xFF8
movq %rbx, %rax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2e270
cmpq %rdi, %rsi
cmovlq %rsi, %rdi
decq %rdi
movslq %edx, %rcx
jmp 0x2e286
cmpq %rsi, %rdi
jle 0x2e298
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 0x2e294
leaq -0x1(%rdi), %rax
shrq $0x3f, %rax
addq %rax, %rdi
decq %rdi
sarq %rdi
jmp 0x2e291
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2e25d
movq %rax, %r14
leaq 0x1(%rbx), %rdi
callq 0x2ab71
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_O3/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 0x2fb0a
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 0x1721b(%rip), %rdi     # 0x46d58
movq %rax, %rsi
callq 0x32788
addq $0xe8, %rsp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2fbd0
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 0x2fc3c
cmpl $0x81, %eax
movl $0x80, %r15d
cmovael %eax, %r15d
movq %r13, 0x8(%rsp)
leal (%r15,%r15), %r14d
movslq %r14d, %r12
movq %r12, %rdi
leaq 0x176aa(%rip), %rax     # 0x47290
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 0x17680(%rip), %rax     # 0x472a0
callq *(%rax)
leal -0x1(,%r15,2), %eax
cmpl %eax, %ebp
sete %al
cmpl $-0x1, %ebp
sete %cl
orb %al, %cl
movl %r14d, %r15d
jne 0x2fbd5
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_O3/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 0x2fcb9
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_O3/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 0x174cb(%rip), %rax     # 0x47290
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_O3/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 0x2fe0b
pushq %r14
pushq %rbx
pushq %rax
leaq 0x174ad(%rip), %rbx     # 0x472a0
movq (%rdi), %r14
movq 0x8(%rdi), %rsi
callq *(%rbx)
movq %r14, %rdi
testq %r14, %r14
jne 0x2fdf3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x319c2
cmpq $0x0, (%r14,%rbx,8)
je 0x32171
movq %r14, %rax
subq $0x1, (%rax)
leaq 0x8(%rax), %rax
jb 0x3213a
cmpq $0x0, (%r14,%rbx,8)
je 0x32150
xorl %r15d, %r15d
jmp 0x3216d
movl $0x1, %r15d
testq %rbx, %rbx
je 0x3216d
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_O3/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 0x3267f
movq (%r14), %rdi
callq 0x2f170
movq %rax, (%rbx)
xorl %r12d, %r12d
jmp 0x3274e
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 0x1bde0
cmpq $0x2, %r12
jne 0x326cc
xorl %r12d, %r12d
movl $0x4, %ecx
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %r8
callq 0x1c700
jmp 0x3274e
movq -0x8(%r14,%r12,8), %r13
movq %r13, %rdi
callq 0x2f170
movq %rax, %r9
movq %rax, %rsi
imulq %r13, %rsi
movq -0x10(%r14,%r12,8), %rcx
addq %rcx, %rsi
jae 0x3270b
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 0x32729
leaq -0x1(%r9), %rsi
cmpq %r13, %rdx
jae 0x3275f
movq %rsi, %r9
leaq (%r12,%r12), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
movq %r12, %r8
callq 0x2be5c
subq $0x1, (%rbx)
leaq 0x8(%rbx), %rbx
jb 0x3273e
movl $0x1, %r12d
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 0x32729
// File: /workspace/github_cpp_makefile_star2_O3/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 0x340f3
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 0x34104
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 0x1d514
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 0x340d4
leaq (%r12,%r15,8), %rsi
movq %r12, %rdi
movq %rbp, %rdx
movq 0x20(%rsp), %rcx
callq 0x1be66
movq %rax, (%r12,%rbp,8)
cmpq $0x1, %rax
sbbq $-0x1, %rbp
xorl %eax, %eax
jmp 0x340d7
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 0x34066
jmp 0x34111
movq $0x1, (%rdi)
movl $0x1, %ebx
xorl %r13d, %r13d
jmp 0x34148
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 0x34143
movq %rbx, %rdx
callq 0x2f106
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
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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 0x343ce
xorl %ebx, %ebx
jmp 0x34491
movq %rdx, %r14
movq %rdi, %rbx
testq %rdi, %rdi
je 0x343de
xorl %r12d, %r12d
jmp 0x3442e
movl %r15d, %eax
negl %eax
cmovsl %r15d, %eax
leaq (%rax,%rax,4), %rax
leaq 0x2d2e(%rip), %rcx      # 0x37120
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 0x12e6a(%rip), %rax     # 0x47290
movq %r12, %rdi
callq *(%rax)
movq %rax, %rbx
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x34160
movq %rbx, %rdi
callq 0x6120
movq %rax, %r13
cmpl $0x1, 0x14(%r14)
jne 0x34458
movq 0x18(%r14), %rax
cmpq $0x1, (%rax)
je 0x34484
addq $0x10, %r14
movb $0x2f, (%rbx,%r13)
leaq (%rbx,%r13), %rbp
incq %rbp
movq %rbp, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x34160
movq %rbp, %rdi
callq 0x6120
addq %rax, %r13
incq %r13
testq %r12, %r12
je 0x34491
incq %r13
cmpq %r13, %r12
jne 0x344a3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x12dee(%rip), %rax     # 0x47298
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_O3/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 %r8, %rbx
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %rbp
cmpq $0x11, %rcx
jl 0x34edf
movq %r9, %r13
leaq -0x8(%rdx), %rax
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq %rbp, 0x20(%rsp)
movq 0x10(%rsp), %rax
leaq (%rax,%r14,8), %rcx
movq %rbx, %r15
movq 0x8(%r15), %rbx
movq 0x10(%r15), %rax
leaq (%rax,%rbx), %rsi
cmpq %r14, %rsi
jg 0x34e62
movq (%r15), %r9
jne 0x34e68
movq %r14, %rbp
subq %rax, %rbp
movq %rcx, %r10
movq %rbp, %rsi
testq %rsi, %rsi
jle 0x34e71
movq -0x8(%r9,%rsi,8), %rdi
decq %rsi
leaq -0x8(%r10), %r8
cmpq %rdi, (%r10)
movq %r8, %r10
je 0x34e47
ja 0x34e71
addq $-0x28, %r15
jmp 0x34e25
subq %rax, %r14
movq %r14, %rbp
movq %rsi, %r14
leaq (%rdx,%rax,8), %rcx
movq %rbx, (%rsp)
movq %r13, %rdi
movq %rcx, %rsi
xorl %edx, %edx
movq %rbp, %r8
callq 0x1f79c
subq %rbx, %rbp
cmpq $0x1, (%r13,%rbp,8)
sbbq $-0x1, %rbp
movl $0x0, %esi
testq %r12, %r12
je 0x34ea7
subq 0x18(%r15), %r12
movq %r12, %rsi
leaq -0x28(%r15), %rbx
leaq (,%rbp,8), %r9
addq %r13, %r9
movq 0x20(%rsp), %rdi
movq %r13, %rdx
movq %rbp, %rcx
movq %rbx, %r8
callq 0x34ddf
movq %rax, %rbp
movq 0x18(%r15), %r12
cmpq $0x10, %r14
movq 0x18(%rsp), %rdx
jg 0x34e14
testq %r14, %r14
je 0x34f04
movl 0x20(%rbx), %r8d
movq %rbp, %rdi
movq %r12, %rsi
movq %r14, %rcx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34ad8
testq %r12, %r12
je 0x34f19
movq %rbp, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x6170
addq %r12, %rbp
movq %rbp, %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)
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2868
leaq -0x38(%rbp), %r15
movq 0x5b4e(%rip), %r14      # 0x7fc8
leaq -0x48(%rbp), %r13
leaq -0x88(%rbp), %rbx
movq %rbx, %r12
movl $0x26, %edx
movq %r14, %rdi
leaq 0x2b6d(%rip), %rsi      # 0x5004
callq 0x21e0
movq %r15, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
movq 0x5b25(%rip), %rdi      # 0x7fd8
movq %r13, %rsi
callq 0x2210
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0x24d0
xorl %ebx, %ebx
jmp 0x2564
movq %r13, %rdi
leaq 0x2b51(%rip), %rsi      # 0x502b
callq 0x2080
testl %eax, %eax
je 0x24c9
movq %rbx, %rdi
leaq -0xc8(%rbp), %rsi
movq %r13, %rdx
callq 0x2bda
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2efc
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 0x2538
callq 0x2748
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x2546
callq 0x2748
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x2562
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x21b0
movb $0x1, %bl
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x2579
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21b0
testb %bl, %bl
movq %r12, %rbx
jne 0x2488
leaq -0xb8(%rbp), %rbx
movq %rbx, %rdi
callq 0x27c2
movq -0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x25a1
callq 0x2748
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x25cb
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x26d4
jmp 0x25ce
movq %rax, %rbx
jmp 0x25e3
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x25e3
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21b0
leaq -0xc8(%rbp), %rdi
callq 0x271e
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2647
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 0x26ac
movq 0x59a2(%rip), %rbx      # 0x7ff0
leaq 0x29d8(%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 0x5970(%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 0x244c
jmp 0x2692
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1e029(%rip), %rsi     # 0x2a1d4
movl $0x38, %edx
movq %r14, %rdi
callq 0x95c0
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
testq %rax, %rax
je 0xc1e1
movq %rax, %r15
movq %rax, %rdi
callq 0x91e0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x95c0
jmp 0xc1fa
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 0x32d69(%rip), %rsi     # 0x3efa0
leaq 0x8(%rsp), %rdi
callq 0x9470
leaq 0x88(%rsp), %rdi
callq 0x9420
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x32d3b(%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_O3/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 0xc2cd
movq %rdi, %r14
movq 0x32d26(%rip), %rbx     # 0x3efc0
leaq 0x1e00f(%rip), %rsi     # 0x2a2b0
movl $0x2f, %edx
movq %rbx, %rdi
callq 0x95c0
movq (%r14), %r14
testq %r14, %r14
je 0xc2e7
movq %r14, %rdi
callq 0x91e0
movq 0x32cfb(%rip), %rdi     # 0x3efc0
movq %r14, %rsi
movq %rax, %rdx
jmp 0xc2e0
movq 0x32cec(%rip), %rdi     # 0x3efc0
leaq 0x1deca(%rip), %rsi     # 0x2a1a5
movl $0x2e, %edx
callq 0x95c0
jmp 0xc2fe
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x9690
movq 0x32cbb(%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