LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_div_q_2exp
static void
mpz_div_q_2exp (mpz_t q, const mpz_t u, mp_bitcnt_t bit_index,
		enum mpz_div_round_mode mode)
{
  mp_size_t un, qn;
  mp_size_t limb_cnt;
  mp_ptr qp;
  int adjust;

  un = u->_mp_size;
  if (un == 0)
    {
      q->_mp_size = 0;
      return;
    }
  limb_cnt = bit_index / GMP_LIMB_BITS;
  qn = GMP_ABS (un) - limb_cnt;
  bit_index %= GMP_LIMB_BITS;

  if (mode == ((un > 0) ? GMP_DIV_CEIL : GMP_DIV_FLOOR)) /* un != 0 here. */
    /* Note: Below, the final indexing at limb_cnt is valid because at
       that point we have qn > 0. */
    adjust = (qn <= 0
	      || !mpn_zero_p (u->_mp_d, limb_cnt)
	      || (u->_mp_d[limb_cnt]
		  & (((mp_limb_t) 1 << bit_index) - 1)));
  else
    adjust = 0;

  if (qn <= 0)
    qn = 0;

  else
    {
      qp = MPZ_REALLOC (q, qn);

      if (bit_index != 0)
	{
	  mpn_rshift (qp, u->_mp_d + limb_cnt, qn, bit_index);
	  qn -= qp[qn - 1] == 0;
	}
      else
	{
	  mpn_copyi (qp, u->_mp_d + limb_cnt, qn);
	}
    }

  q->_mp_size = qn;

  if (adjust)
    mpz_add_ui (q, q, 1);
  if (un < 0)
    mpz_neg (q, q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x4(%rsi), %r13d
testl %r13d, %r13d
je 0x37cc
movq %rdx, %r15
movq %rdx, %r12
shrq $0x6, %r12
movl %r13d, %r14d
negl %r14d
cmovsl %r13d, %r14d
subq %r12, %r14
andl $0x3f, %r15d
xorl %eax, %eax
testl %r13d, %r13d
setg %al
cmpl %ecx, %eax
jne 0x37d5
testq %r14, %r14
jle 0x37e5
movq %rsi, -0x30(%rbp)
movq 0x8(%rsi), %rdi
movq %rdi, -0x38(%rbp)
movq %r12, %rsi
callq 0x1354
testl %eax, %eax
je 0x37eb
pushq $-0x1
popq %rax
movl %r15d, %ecx
shlq %cl, %rax
notq %rax
movq -0x38(%rbp), %rcx
testq %rax, (%rcx,%r12,8)
sete %al
jmp 0x37ed
andl $0x0, 0x4(%rbx)
jmp 0x3872
movb $0x1, %al
testq %r14, %r14
jg 0x37f1
andl $0x0, 0x4(%rbx)
jmp 0x386d
andl $0x0, 0x4(%rbx)
jmp 0x385f
xorl %eax, %eax
movq -0x30(%rbp), %rsi
movl %eax, -0x38(%rbp)
movslq (%rbx), %rax
cmpq %rax, %r14
jle 0x3811
movq %rbx, %rdi
movq %rsi, -0x30(%rbp)
movq %r14, %rsi
callq 0x228f
movq -0x30(%rbp), %rsi
jmp 0x3815
movq 0x8(%rbx), %rax
shlq $0x3, %r12
addq 0x8(%rsi), %r12
testq %r15, %r15
je 0x3847
movq %rax, %rdi
movq %rax, -0x30(%rbp)
movq %r12, %rsi
movq %r14, %rdx
movl %r15d, %ecx
callq 0x1941
movq -0x30(%rbp), %rax
cmpq $0x1, -0x8(%rax,%r14,8)
sbbl $0x0, %r14d
jmp 0x3855
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x12ed
movl %r14d, 0x4(%rbx)
cmpb $0x0, -0x38(%rbp)
jne 0x386d
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x2a8e
testl %r13d, %r13d
js 0x3881
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2a4c
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_congruent_p
int
mpz_congruent_p (const mpz_t a, const mpz_t b, const mpz_t m)
{
  mpz_t t;
  int res;

  /* a == b (mod 0) iff a == b */
  if (mpz_sgn (m) == 0)
    return (mpz_cmp (a, b) == 0);

  mpz_init (t);
  mpz_sub (t, a, b);
  res = mpz_divisible_p (t, m);
  mpz_clear (t);

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x4(%rdx), %eax
movl %eax, %ecx
sarl $0x1f, %ecx
xorl %edx, %edx
testl %eax, %eax
setne %dl
orl %ecx, %edx
je 0x3bd1
leaq -0x30(%rbp), %r12
movq $0x1, (%r12)
pushq $0x8
popq %rdi
callq *0xb4f6(%rip)           # 0xf098
movq %rax, 0x8(%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2e4a
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3b46
movl %eax, %ebx
movq 0x8(%r12), %rdi
xorl %esi, %esi
callq *0xb4d9(%rip)           # 0xf0a8
jmp 0x3be3
movq %r15, %rdi
movq %r14, %rsi
callq 0x2963
xorl %ebx, %ebx
testl %eax, %eax
sete %bl
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_gcd_ui
unsigned long
mpz_gcd_ui (mpz_t g, const mpz_t u, unsigned long v)
{
  mp_size_t un;

  if (v == 0)
    {
      if (g)
	mpz_abs (g, u);
    }
  else
    {
      un = GMP_ABS (u->_mp_size);
      if (un != 0)
	v = mpn_gcd_11 (mpn_div_qr_1 (NULL, u->_mp_d, un, v), v);

      if (g)
	mpz_set_ui (g, v);
    }

  return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x3f75
movq %rdx, %rbx
movl 0x4(%rsi), %eax
testl %eax, %eax
je 0x3f5f
movl %eax, %edx
negl %edx
cmovsl %eax, %edx
movq 0x8(%rsi), %rsi
xorl %edi, %edi
movq %rbx, %rcx
callq 0x4062
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3f94
movq %rax, %rbx
testq %r14, %r14
je 0x3f8c
testq %rbx, %rbx
je 0x3f86
movq 0x8(%r14), %rax
movq %rbx, (%rax)
pushq $0x1
popq %rax
jmp 0x3f88
testq %r14, %r14
je 0x3f82
movq %r14, %rdi
callq 0x2a2a
xorl %ebx, %ebx
jmp 0x3f8c
xorl %eax, %eax
movl %eax, 0x4(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_gcd_11
static mp_limb_t
mpn_gcd_11 (mp_limb_t u, mp_limb_t v)
{
  unsigned shift;

  assert ( (u | v) > 0);

  if (u == 0)
    return v;
  else if (v == 0)
    return u;

  gmp_ctz (shift, u | v);

  u >>= shift;
  v >>= shift;

  if ( (u & 1) == 0)
    MP_LIMB_T_SWAP (u, v);

  while ( (v & 1) == 0)
    v >>= 1;

  while (u != v)
    {
      if (u > v)
	{
	  u -= v;
	  do
	    u >>= 1;
	  while ( (u & 1) == 0);
	}
      else
	{
	  v -= u;
	  do
	    v >>= 1;
	  while ( (v & 1) == 0);
	}
    }
  return u << shift;
}

// Assembly:
movq %rsi, %rcx
orq %rdi, %rcx
je 0x403f
testq %rdi, %rdi
je 0x403b
testq %rsi, %rsi
je 0x4038
movq %rcx, %rax
negq %rax
andq %rcx, %rax
pushq $0x3f
popq %rcx
movq %rax, %rdx
shrq $0x38, %rdx
jne 0x3fd5
shlq $0x8, %rax
addl $-0x8, %ecx
jmp 0x3fbe
addq %rax, %rax
decl %ecx
testq %rax, %rax
jns 0x3fd0
movl %ecx, %eax
movq %rdi, %r8
shrq %cl, %r8
shrq %cl, %rsi
btq %rcx, %rdi
movq %rsi, %rcx
cmovaeq %r8, %rcx
movq %rcx, %rdx
shrq %rcx
testb $0x1, %dl
je 0x3ff0
testb $0x1, %r8b
cmovneq %r8, %rsi
movq %rsi, %rcx
subq %rdx, %rcx
je 0x402e
jbe 0x401e
movq %rcx, %rsi
shrq %rcx
testb $0x2, %sil
je 0x400d
movq %rcx, %rsi
jmp 0x4003
subq %rsi, %rdx
movq %rdx, %rcx
shrq %rdx
testb $0x2, %cl
je 0x4021
jmp 0x4003
movl %eax, %ecx
shlq %cl, %rdx
movq %rdx, %rsi
jmp 0x403b
movq %rdi, %rsi
movq %rsi, %rax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x62c6(%rip), %rdi      # 0xa310
leaq 0x5013(%rip), %rsi      # 0x9064
leaq 0x62c4(%rip), %rcx      # 0xa31c
movl $0xa5e, %edx            # imm = 0xA5E
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_div_qr_1
static mp_limb_t
mpn_div_qr_1 (mp_ptr qp, mp_srcptr np, mp_size_t nn, mp_limb_t d)
{
  assert (d > 0);

  /* Special case for powers of two. */
  if ((d & (d-1)) == 0)
    {
      mp_limb_t r = np[0] & (d-1);
      if (qp)
	{
	  if (d <= 1)
	    mpn_copyi (qp, np, nn);
	  else
	    {
	      unsigned shift;
	      gmp_ctz (shift, d);
	      mpn_rshift (qp, np, nn, shift);
	    }
	}
      return r;
    }
  else
    {
      struct gmp_div_inverse inv;
      mpn_div_qr_1_invert (&inv, d);
      return mpn_div_qr_1_preinv (qp, np, nn, &inv);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
testq %rcx, %rcx
je 0x4118
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq -0x1(%rcx), %r14
testq %r14, %rcx
jne 0x40ad
andq (%r15), %r14
testq %r12, %r12
je 0x4108
cmpq $0x1, %rcx
jne 0x40d2
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x12ed
xorl %r14d, %r14d
jmp 0x4108
leaq -0x40(%rbp), %r14
movq %r14, %rdi
movq %rcx, %rsi
callq 0x6b03
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x6b6f
movq %rax, %r14
jmp 0x4108
movq %rcx, %rax
negq %rax
andq %rcx, %rax
pushq $0x3f
popq %rcx
movq %rax, %rdx
shrq $0x38, %rdx
jne 0x40f5
shlq $0x8, %rax
addl $-0x8, %ecx
jmp 0x40de
addq %rax, %rax
decl %ecx
testq %rax, %rax
jns 0x40f0
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1941
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6228(%rip), %rdi      # 0xa347
leaq 0x4f3e(%rip), %rsi      # 0x9064
leaq 0x6220(%rip), %rcx      # 0xa34d
movl $0x37f, %edx            # imm = 0x37F
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_make_odd
static mp_bitcnt_t
mpz_make_odd (mpz_t r)
{
  mp_bitcnt_t shift;

  assert (r->_mp_size > 0);
  /* Count trailing zeros, equivalent to mpn_scan1, because we know that there is a 1 */
  shift = mpn_common_scan (r->_mp_d[0], 0, r->_mp_d, 0, 0);
  mpz_tdiv_q_2exp (r, r, shift);

  return shift;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl $0x0, 0x4(%rdi)
jle 0x438a
movq %rdi, %rbx
movq 0x8(%rdi), %rdx
movq (%rdx), %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x1a25
movq %rax, %r14
movq %rbx, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x38a6
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x5ffc(%rip), %rdi      # 0xa38d
leaq 0x4ccc(%rip), %rsi      # 0x9064
leaq 0x5ffe(%rip), %rcx      # 0xa39d
movl $0xaa0, %edx            # imm = 0xAA0
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_setbit
void
mpz_setbit (mpz_t d, mp_bitcnt_t bit_index)
{
  if (!mpz_tstbit (d, bit_index))
    {
      if (d->_mp_size >= 0)
	mpz_abs_add_bit (d, bit_index);
      else
	mpz_abs_sub_bit (d, bit_index);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6059
testl %eax, %eax
je 0x498a
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x0, 0x4(%r14)
js 0x49a0
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x60bb
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x6183
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_lcm
void
mpz_lcm (mpz_t r, const mpz_t u, const mpz_t v)
{
  mpz_t g;

  if (u->_mp_size == 0 || v->_mp_size == 0)
    {
      r->_mp_size = 0;
      return;
    }

  mpz_init (g);

  mpz_gcd (g, u, v);
  mpz_divexact (g, u, g);
  mpz_mul (r, g, v);

  mpz_clear (g);
  mpz_abs (r, r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x4(%rsi)
je 0x4a31
movq %rdx, %r14
cmpl $0x0, 0x4(%rdx)
je 0x4a31
movq %rsi, %r15
leaq -0x30(%rbp), %r12
movq $0x1, (%r12)
pushq $0x8
popq %rdi
callq *0xa6b0(%rip)           # 0xf098
movq %rax, 0x8(%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4137
movq %r12, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3b0c
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x2f54
movq 0x8(%r12), %rdi
xorl %esi, %esi
callq *0xa684(%rip)           # 0xf0a8
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x2a2a
jmp 0x4a35
andl $0x0, 0x4(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_lcm_ui
void
mpz_lcm_ui (mpz_t r, const mpz_t u, unsigned long v)
{
  if (v == 0 || u->_mp_size == 0)
    {
      r->_mp_size = 0;
      return;
    }

  v /= mpz_gcd_ui (NULL, u, v);
  mpz_mul_ui (r, u, v);

  mpz_abs (r, r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdx, %rdx
je 0x4a98
movq %rsi, %r14
cmpl $0x0, 0x4(%rsi)
je 0x4a98
movq %rdx, %r15
xorl %edi, %edi
movq %r14, %rsi
callq 0x3f23
movq %rax, %rcx
movq %r15, %rax
xorl %edx, %edx
divq %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2ec3
movq %rbx, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2a2a
andl $0x0, 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_invert
int
mpz_invert (mpz_t r, const mpz_t u, const mpz_t m)
{
  mpz_t g, tr;
  int invertible;

  if (u->_mp_size == 0 || mpz_cmpabs_ui (m, 1) <= 0)
    return 0;

  mpz_init (g);
  mpz_init (tr);

  mpz_gcdext (g, tr, NULL, u, m);
  invertible = (mpz_cmp_ui (g, 1) == 0);

  if (invertible)
    {
      if (tr->_mp_size < 0)
	{
	  if (m->_mp_size >= 0)
	    mpz_add (tr, tr, m);
	  else
	    mpz_sub (tr, tr, m);
	}
      mpz_swap (r, tr);
    }

  mpz_clear (g);
  mpz_clear (tr);
  return invertible;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
xorl %r14d, %r14d
cmpl $0x0, 0x4(%rsi)
je 0x4bab
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
pushq $0x1
popq %r13
movq %rdx, %rdi
movq %r13, %rsi
callq 0x29a4
testl %eax, %eax
jle 0x4bab
movq %rbx, -0x48(%rbp)
leaq -0x60(%rbp), %r14
movq %r13, (%r14)
pushq $0x8
popq %rdi
callq *0xa59f(%rip)           # 0xf098
movq %rax, 0x8(%r14)
leaq -0x40(%rbp), %rbx
movq %r13, (%rbx)
pushq $0x8
popq %rdi
callq *0xa58b(%rip)           # 0xf098
movq %rax, 0x8(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %r12, %rcx
movq %r15, %r8
callq 0x43a9
movq %r14, %rdi
movq %r13, %rsi
callq 0x292a
xorl %r14d, %r14d
testl %eax, %eax
sete %bl
jne 0x4b90
cmpl $0x0, -0x3c(%rbp)
jns 0x4b66
cmpl $0x0, 0x4(%r15)
js 0x4b57
leaq -0x40(%rbp), %rdi
movq %rdi, %rsi
movq %r15, %rdx
callq 0x2c3d
jmp 0x4b66
leaq -0x40(%rbp), %rdi
movq %rdi, %rsi
movq %r15, %rdx
callq 0x2e4a
movq -0x48(%rbp), %rdx
movl 0x4(%rdx), %eax
movl -0x3c(%rbp), %ecx
movl %ecx, 0x4(%rdx)
movl %eax, -0x3c(%rbp)
movl (%rdx), %eax
movl -0x40(%rbp), %ecx
movl %ecx, (%rdx)
movl %eax, -0x40(%rbp)
movq 0x8(%rdx), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rdx)
movq %rax, -0x38(%rbp)
movb %bl, %r14b
movq -0x58(%rbp), %rdi
xorl %esi, %esi
callq *0xa509(%rip)           # 0xf0a8
movq -0x38(%rbp), %rdi
xorl %esi, %esi
callq *0xa4fd(%rip)           # 0xf0a8
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_pow_ui
void
mpz_pow_ui (mpz_t r, const mpz_t b, unsigned long e)
{
  unsigned long bit;
  mpz_t tr;
  mpz_init_set_ui (tr, 1);

  bit = GMP_ULONG_HIGHBIT;
  do
    {
      mpz_mul (tr, tr, tr);
      if (e & bit)
	mpz_mul (tr, tr, b);
      bit >>= 1;
    }
  while (bit > 0);

  mpz_swap (r, tr);
  mpz_clear (tr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x1
popq %r13
leaq -0x40(%rbp), %r12
movl %r13d, (%r12)
pushq $0x8
popq %rdi
callq *0xa4ac(%rip)           # 0xf098
movq %rax, 0x8(%r12)
movq $0x1, (%rax)
movl %r13d, 0x4(%r12)
movabsq $-0x8000000000000000, %r13 # imm = 0x8000000000000000
movq %r12, %rdi
movq %r12, %rsi
movq %r12, %rdx
callq 0x2f54
testq %r14, %r13
je 0x4c28
movq %r12, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2f54
movq %r13, %rax
shrq %rax
cmpq $0x1, %r13
movq %rax, %r13
ja 0x4c07
movl -0x3c(%rbp), %eax
movl %eax, 0x4(%rbx)
movl -0x40(%rbp), %eax
movl %eax, (%rbx)
movq 0x8(%rbx), %rdi
movq -0x38(%rbp), %rax
movq %rax, 0x8(%rbx)
movq 0xa453(%rip), %rax      # 0xf0a8
xorl %esi, %esi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_div_qr_invert
static void
mpn_div_qr_invert (struct gmp_div_inverse *inv,
		   mp_srcptr dp, mp_size_t dn)
{
  assert (dn > 0);

  if (dn == 1)
    mpn_div_qr_1_invert (inv, dp[0]);
  else if (dn == 2)
    mpn_div_qr_2_invert (inv, dp[1], dp[0]);
  else
    {
      unsigned shift;
      mp_limb_t d1, d0;

      d1 = dp[dn-1];
      d0 = dp[dn-2];
      assert (d1 > 0);
      gmp_clz (shift, d1);
      inv->shift = shift;
      if (shift > 0)
	{
	  d1 = (d1 << shift) | (d0 >> (GMP_LIMB_BITS - shift));
	  d0 = (d0 << shift) | (dp[dn-3] >> (GMP_LIMB_BITS - shift));
	}
      inv->d1 = d1;
      inv->d0 = d0;
      inv->di = mpn_invert_3by2 (d1, d0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdx, %rdx
jle 0x50e7
movq %rdi, %rbx
cmpq $0x2, %rdx
je 0x5031
cmpq $0x1, %rdx
jne 0x507f
movq (%rsi), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6b03
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0x5106
movq (%rsi), %rsi
xorl %ecx, %ecx
movabsq $0x100000000000000, %rdx # imm = 0x100000000000000
movq %rdi, %rax
cmpq %rdx, %rax
jae 0x5063
shlq $0x8, %rax
addl $0x8, %ecx
jmp 0x5050
addq %rax, %rax
incl %ecx
testq %rax, %rax
jns 0x505e
movl %ecx, (%rbx)
testl %ecx, %ecx
je 0x5075
shldq %cl, %rsi, %rdi
shlq %cl, %rsi
movq %rdi, 0x8(%rbx)
movq %rsi, 0x10(%rbx)
jmp 0x50d7
movq -0x8(%rsi,%rdx,8), %rdi
testq %rdi, %rdi
je 0x5125
movq -0x10(%rsi,%rdx,8), %rax
xorl %ecx, %ecx
movabsq $0x100000000000000, %r9 # imm = 0x100000000000000
movq %rdi, %r8
cmpq %r9, %r8
jae 0x50b4
shlq $0x8, %r8
addl $-0x8, %ecx
jmp 0x50a1
addq %r8, %r8
decl %ecx
testq %r8, %r8
jns 0x50af
negl %ecx
movl %ecx, (%rbx)
jae 0x50cc
shldq %cl, %rax, %rdi
movq -0x18(%rsi,%rdx,8), %rdx
shldq %cl, %rdx, %rax
movq %rdi, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rax, %rsi
callq 0x1b0d
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x50d1(%rip), %rdi      # 0xa1bf
leaq 0x3f6f(%rip), %rsi      # 0x9064
leaq 0x52ce(%rip), %rcx      # 0xa3ca
movl $0x33e, %edx            # imm = 0x33E
callq 0x1090
leaq 0x5304(%rip), %rdi      # 0xa411
leaq 0x3f50(%rip), %rsi      # 0x9064
leaq 0x52fd(%rip), %rcx      # 0xa418
movl $0x32d, %edx            # imm = 0x32D
callq 0x1090
leaq 0x52e5(%rip), %rdi      # 0xa411
leaq 0x3f31(%rip), %rsi      # 0x9064
leaq 0x5290(%rip), %rcx      # 0xa3ca
movl $0x34b, %edx            # imm = 0x34B
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_sizeinbase
size_t
mpz_sizeinbase (const mpz_t u, int base)
{
  mp_size_t un;
  mp_srcptr up;
  mp_ptr tp;
  mp_bitcnt_t bits;
  struct gmp_div_inverse bi;
  size_t ndigits;

  assert (base >= 2);
  assert (base <= 36);

  un = GMP_ABS (u->_mp_size);
  if (un == 0)
    return 1;

  up = u->_mp_d;

  bits = (un - 1) * GMP_LIMB_BITS + mpn_limb_size_in_base_2 (up[un-1]);
  switch (base)
    {
    case 2:
      return bits;
    case 4:
      return (bits + 1) / 2;
    case 8:
      return (bits + 2) / 3;
    case 16:
      return (bits + 3) / 4;
    case 32:
      return (bits + 4) / 5;
      /* FIXME: Do something more clever for the common case of base
	 10. */
    }

  tp = gmp_xalloc_limbs (un);
  mpn_copyi (tp, up, un);
  mpn_div_qr_1_invert (&bi, base);

  ndigits = 0;
  do
    {
      ndigits++;
      mpn_div_qr_1_preinv (tp, tp, un, &bi);
      un -= (tp[un-1] == 0);
    }
  while (un > 0);

  gmp_free (tp);
  return ndigits;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x1, %esi
jle 0x5960
movl %esi, %r15d
cmpl $0x25, %esi
jae 0x597f
movl 0x4(%rdi), %eax
movl %eax, %r14d
negl %r14d
cmovsl %eax, %r14d
jae 0x58c2
movq 0x8(%rdi), %r13
leaq -0x1(%r14), %r12
shlq $0x6, %r12
movq -0x8(%r13,%r14,8), %rdi
callq 0x6ab4
movq %rax, %rbx
addq %r12, %rbx
cmpl $0x2, %r15d
je 0x594e
cmpl $0x20, %r15d
je 0x58ca
cmpl $0x8, %r15d
je 0x58dc
cmpl $0x10, %r15d
je 0x58d2
cmpl $0x4, %r15d
jne 0x58f0
incq %rbx
shrq %rbx
jmp 0x594e
pushq $0x1
popq %rbx
jmp 0x594e
addq $0x4, %rbx
pushq $0x5
jmp 0x58e2
addq $0x3, %rbx
shrq $0x2, %rbx
jmp 0x594e
addq $0x2, %rbx
pushq $0x3
popq %rcx
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %rbx
jmp 0x594e
leaq (,%r14,8), %rdi
callq *0x979a(%rip)           # 0xf098
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x12ed
movl %r15d, %esi
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x6b03
xorl %ebx, %ebx
incq %rbx
movq %r12, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x6b6f
cmpq $0x1, -0x8(%r12,%r14,8)
sbbq $0x0, %r14
testq %r14, %r14
jg 0x5920
movq %r12, %rdi
xorl %esi, %esi
callq *0x975a(%rip)           # 0xf0a8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3e5d(%rip), %rdi      # 0x97c4
leaq 0x36f6(%rip), %rsi      # 0x9064
leaq 0x3e59(%rip), %rcx      # 0x97ce
movl $0xf95, %edx            # imm = 0xF95
callq 0x1090
leaq 0x3e79(%rip), %rdi      # 0x97ff
leaq 0x36d7(%rip), %rsi      # 0x9064
leaq 0x3e3a(%rip), %rcx      # 0x97ce
movl $0xf96, %edx            # imm = 0xF96
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_root
int
mpz_root (mpz_t x, const mpz_t y, unsigned long z)
{
  int res;
  mpz_t r;

  mpz_init (r);
  mpz_rootrem (x, r, y, z);
  res = r->_mp_size == 0;
  mpz_clear (r);

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x30(%rbp), %r12
movq $0x1, (%r12)
pushq $0x8
popq %rdi
callq *0x96cd(%rip)           # 0xf098
movq %rax, 0x8(%r12)
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x5586
xorl %ebx, %ebx
cmpl $0x0, 0x4(%r12)
sete %bl
movq 0x8(%r12), %rdi
xorl %esi, %esi
callq *0x96af(%rip)           # 0xf0a8
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_perfect_square_p
int
mpn_perfect_square_p (mp_srcptr p, mp_size_t n)
{
  mpz_t t;

  assert (n > 0);
  assert (p [n-1] != 0);
  return mpz_root (NULL, mpz_roinit_n (t, p, n), 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rdx
testq %rsi, %rsi
jle 0x5a98
movq %rdi, %rsi
cmpq $0x0, -0x8(%rdi,%rdx,8)
je 0x5ab7
leaq -0x20(%rbp), %rbx
movq %rbx, %rdi
callq 0x24ed
pushq $0x2
popq %rdx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x599e
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
leaq 0x4721(%rip), %rdi      # 0xa1c0
leaq 0x35be(%rip), %rsi      # 0x9064
leaq 0x3b20(%rip), %rcx      # 0x95cd
movl $0xcda, %edx            # imm = 0xCDA
callq 0x1090
leaq 0x3b3e(%rip), %rdi      # 0x95fc
leaq 0x359f(%rip), %rsi      # 0x9064
leaq 0x3b01(%rip), %rcx      # 0x95cd
movl $0xcdb, %edx            # imm = 0xCDB
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_sqrtrem
mp_size_t
mpn_sqrtrem (mp_ptr sp, mp_ptr rp, mp_srcptr p, mp_size_t n)
{
  mpz_t s, r, u;
  mp_size_t res;

  assert (n > 0);
  assert (p [n-1] != 0);

  mpz_init (r);
  mpz_init (s);
  mpz_rootrem (s, r, mpz_roinit_n (u, p, n), 2);

  assert (s->_mp_size == (n+1)/2);
  mpn_copyd (sp, s->_mp_d, s->_mp_size);
  mpz_clear (s);
  res = r->_mp_size;
  if (rp)
    mpn_copyd (rp, r->_mp_d, res);
  mpz_clear (r);
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
testq %rcx, %rcx
jle 0x5bc5
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, -0x48(%rbp)
movq %rsi, -0x50(%rbp)
cmpq $0x0, -0x8(%rdx,%rcx,8)
je 0x5be4
pushq $0x1
popq %r13
leaq -0x40(%rbp), %rbx
movq %r13, (%rbx)
pushq $0x8
popq %r14
movq %r14, %rdi
callq *0x9576(%rip)           # 0xf098
movq %rax, 0x8(%rbx)
leaq -0x60(%rbp), %rbx
movq %r13, (%rbx)
movq %r14, %rdi
callq *0x9562(%rip)           # 0xf098
movq %rax, 0x8(%rbx)
leaq -0x70(%rbp), %r14
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x24ed
pushq $0x2
popq %rcx
movq %rbx, %rdi
leaq -0x40(%rbp), %rsi
movq %r14, %rdx
callq 0x5586
movslq 0x4(%rbx), %rdx
incq %r15
shrq %r15
cmpq %rdx, %r15
jne 0x5c03
movq -0x58(%rbp), %rbx
movq -0x48(%rbp), %rdi
movq %rbx, %rsi
callq 0x130e
movq %rbx, %rdi
xorl %esi, %esi
callq *0x951c(%rip)           # 0xf0a8
movslq -0x3c(%rbp), %r14
movq -0x38(%rbp), %r15
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x5ba8
movq %r15, %rsi
movq %r14, %rdx
callq 0x130e
movq %r15, %rdi
xorl %esi, %esi
callq *0x94f5(%rip)           # 0xf0a8
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x45f4(%rip), %rdi      # 0xa1c0
leaq 0x3491(%rip), %rsi      # 0x9064
leaq 0x3a2f(%rip), %rcx      # 0x9609
movl $0xce5, %edx            # imm = 0xCE5
callq 0x1090
leaq 0x3a11(%rip), %rdi      # 0x95fc
leaq 0x3472(%rip), %rsi      # 0x9064
leaq 0x3a10(%rip), %rcx      # 0x9609
movl $0xce6, %edx            # imm = 0xCE6
callq 0x1090
leaq 0x3a3b(%rip), %rdi      # 0x9645
leaq 0x3453(%rip), %rsi      # 0x9064
leaq 0x39f1(%rip), %rcx      # 0x9609
movl $0xcec, %edx            # imm = 0xCEC
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_bin_uiui
void
mpz_bin_uiui (mpz_t r, unsigned long n, unsigned long k)
{
  mpz_t t;

  mpz_set_ui (r, k <= n);

  if (k > (n >> 1))
    k = (k <= n) ? n - k : 0;

  mpz_init (t);
  mpz_fac_ui (t, k);

  for (; k > 0; k--)
      mpz_mul_ui (r, r, n--);

  mpz_divexact (r, r, t);
  mpz_clear (t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
cmpq %rsi, %rdx
ja 0x5c90
movq 0x8(%rbx), %rax
movq $0x1, (%rax)
pushq $0x1
popq %rax
movl %eax, 0x4(%rbx)
movq %r14, %rax
shrq %rax
xorl %r15d, %r15d
movq %r14, %rcx
subq %rdx, %rcx
cmovaeq %rcx, %r15
cmpq %rdx, %rax
cmovaeq %rdx, %r15
leaq -0x30(%rbp), %r12
movq $0x1, (%r12)
pushq $0x8
popq %rdi
callq *0x93d6(%rip)           # 0xf098
movq %rax, 0x8(%r12)
movq %r12, %rdi
movq %r15, %rsi
callq 0x5c22
subq $0x1, %r15
jb 0x5cef
leaq -0x1(%r14), %r12
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2ec3
movq %r12, %r14
jmp 0x5cd2
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3b0c
movq 0x93a0(%rip), %rax      # 0xf0a8
movq 0x8(%r14), %rdi
xorl %esi, %esi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_scan1
mp_bitcnt_t
mpz_scan1 (const mpz_t u, mp_bitcnt_t starting_bit)
{
  mp_ptr up;
  mp_size_t us, un, i;
  mp_limb_t limb, ux;

  us = u->_mp_size;
  un = GMP_ABS (us);
  i = starting_bit / GMP_LIMB_BITS;

  /* Past the end there's no 1 bits for u>=0, or an immediate 1 bit
     for u<0. Notice this test picks up any u==0 too. */
  if (i >= un)
    return (us >= 0 ? ~(mp_bitcnt_t) 0 : starting_bit);

  up = u->_mp_d;
  ux = 0;
  limb = up[i];

  if (starting_bit != 0)
    {
      if (us < 0)
	{
	  ux = mpn_zero_p (up, i);
	  limb = ~ limb + ux;
	  ux = - (mp_limb_t) (limb >= ux);
	}

      /* Mask to 0 all bits before starting_bit, thus ignoring them. */
      limb &= (GMP_LIMB_MAX << (starting_bit % GMP_LIMB_BITS));
    }

  return mpn_common_scan (limb, i, up, un, ux);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x4(%rdi), %eax
movl %eax, %ebx
negl %ebx
cmovsl %eax, %ebx
movq %rsi, %r12
movq %rsi, %r14
shrq $0x6, %r14
cmpq %rbx, %r14
jae 0x5ff4
movq 0x8(%rdi), %r15
movq (%r15,%r14,8), %r13
testq %r12, %r12
je 0x600f
testl %eax, %eax
js 0x6014
xorl %r8d, %r8d
jmp 0x6031
testl %eax, %eax
pushq $-0x1
popq %rax
cmovnsq %rax, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r8d, %r8d
jmp 0x603a
movq %r15, %rdi
movq %r14, %rsi
callq 0x1354
movl %eax, %eax
notq %r13
addq %rax, %r13
xorl %r8d, %r8d
cmpq %rax, %r13
adcq $-0x1, %r8
movl %r12d, %ecx
shrq %cl, %r13
shlq %cl, %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1a25
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_tstbit
int
mpz_tstbit (const mpz_t d, mp_bitcnt_t bit_index)
{
  mp_size_t limb_index;
  unsigned shift;
  mp_size_t ds;
  mp_size_t dn;
  mp_limb_t w;
  int bit;

  ds = d->_mp_size;
  dn = GMP_ABS (ds);
  limb_index = bit_index / GMP_LIMB_BITS;
  if (limb_index >= dn)
    return ds < 0;

  shift = bit_index % GMP_LIMB_BITS;
  w = d->_mp_d[limb_index];
  bit = (w >> shift) & 1;

  if (ds < 0)
    {
      /* d < 0. Check if any of the bits below is set: If so, our bit
	 must be complemented. */
      if (shift > 0 && (w << (GMP_LIMB_BITS - shift)) > 0)
	return bit ^ 1;
      while (--limb_index >= 0)
	if (d->_mp_d[limb_index] > 0)
	  return bit ^ 1;
    }
  return bit;
}

// Assembly:
movl 0x4(%rdi), %ecx
movl %ecx, %eax
negl %eax
cmovsl %ecx, %eax
movq %rsi, %rdx
shrq $0x6, %rdx
cmpq %rax, %rdx
jae 0x60b5
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rdi
movq (%rdi,%rdx,8), %r8
andl $0x3f, %esi
xorl %eax, %eax
btq %rsi, %r8
setb %al
testl %ecx, %ecx
jns 0x60b3
testq %rsi, %rsi
je 0x60ae
negb %sil
movl %esi, %ecx
shlq %cl, %r8
testq %r8, %r8
je 0x60ae
xorl $0x1, %eax
jmp 0x60b3
cmpq $0x0, -0x8(%rdi,%rdx,8)
leaq -0x1(%rdx), %rdx
jne 0x609d
testq %rdx, %rdx
jg 0x60a2
popq %rbp
retq
shrl $0x1f, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_abs_add_bit
static void
mpz_abs_add_bit (mpz_t d, mp_bitcnt_t bit_index)
{
  mp_size_t dn, limb_index;
  mp_limb_t bit;
  mp_ptr dp;

  dn = GMP_ABS (d->_mp_size);

  limb_index = bit_index / GMP_LIMB_BITS;
  bit = (mp_limb_t) 1 << (bit_index % GMP_LIMB_BITS);

  if (limb_index >= dn)
    {
      mp_size_t i;
      /* The bit should be set outside of the end of the number.
	 We have to increase the size of the number. */
      dp = MPZ_REALLOC (d, limb_index + 1);

      dp[limb_index] = bit;
      for (i = dn; i < limb_index; i++)
	dp[i] = 0;
      dn = limb_index + 1;
    }
  else
    {
      mp_limb_t cy;

      dp = d->_mp_d;

      cy = mpn_add_1 (dp + limb_index, dp + limb_index, dn - limb_index, bit);
      if (cy > 0)
	{
	  dp = MPZ_REALLOC (d, dn + 1);
	  dp[dn++] = cy;
	}
    }

  d->_mp_size = (d->_mp_size < 0) ? - dn : dn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movl 0x4(%rdi), %eax
movl %eax, %r13d
negl %r13d
cmovsl %eax, %r13d
pushq $0x1
popq %r12
movl %r15d, %ecx
shlq %cl, %r12
shrq $0x6, %r15
movq %r13, %rdx
subq %r15, %rdx
jbe 0x611c
shlq $0x3, %r15
addq 0x8(%rbx), %r15
movq %r15, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x13a4
testq %rax, %rax
je 0x614c
leaq 0x1(%r13), %r14
cmpl (%rbx), %r13d
jge 0x6151
movq 0x8(%rbx), %rax
jmp 0x615c
leaq 0x1(%r15), %r14
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0x612e
movq 0x8(%rbx), %rax
jmp 0x6139
movq %rbx, %rdi
movq %r14, %rsi
callq 0x228f
movq %r12, (%rax,%r15,8)
cmpq %r15, %r13
jae 0x6164
andq $0x0, (%rax,%r13,8)
incq %r13
jmp 0x613d
movq %r13, %r14
jmp 0x6164
movq %rbx, %rdi
movq %r14, %rsi
callq 0x228f
movq $0x1, (%rax,%r13,8)
movl %r14d, %eax
negl %eax
cmpl $0x0, 0x4(%rbx)
cmovnsl %r14d, %eax
movl %eax, 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_abs_sub_bit
static void
mpz_abs_sub_bit (mpz_t d, mp_bitcnt_t bit_index)
{
  mp_size_t dn, limb_index;
  mp_ptr dp;
  mp_limb_t bit;

  dn = GMP_ABS (d->_mp_size);
  dp = d->_mp_d;

  limb_index = bit_index / GMP_LIMB_BITS;
  bit = (mp_limb_t) 1 << (bit_index % GMP_LIMB_BITS);

  assert (limb_index < dn);

  gmp_assert_nocarry (mpn_sub_1 (dp + limb_index, dp + limb_index,
				 dn - limb_index, bit));
  dn = mpn_normalized_size (dp, dn);
  d->_mp_size = (d->_mp_size < 0) ? - dn : dn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x4(%rdi), %eax
movl %eax, %r14d
negl %r14d
cmovsl %eax, %r14d
movq %rsi, %rdi
shrq $0x6, %rdi
movq %r14, %rdx
subq %rdi, %rdx
jbe 0x61f0
movq 0x8(%rbx), %r15
pushq $0x1
popq %rax
movl %esi, %ecx
shlq %cl, %rax
leaq (%r15,%rdi,8), %rdi
movq %rdi, %rsi
movq %rax, %rcx
callq 0x1497
testq %rax, %rax
jne 0x620f
movq %r15, %rdi
movq %r14, %rsi
callq 0x1369
movl %eax, %ecx
negl %ecx
cmpl $0x0, 0x4(%rbx)
cmovnsl %eax, %ecx
movl %ecx, 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4491(%rip), %rdi      # 0xa688
leaq 0x2e66(%rip), %rsi      # 0x9064
leaq 0x4493(%rip), %rcx      # 0xa698
movl $0xde4, %edx            # imm = 0xDE4
callq 0x1090
leaq 0x321f(%rip), %rdi      # 0x9435
leaq 0x2e47(%rip), %rsi      # 0x9064
leaq 0x4474(%rip), %rcx      # 0xa698
movl $0xde7, %edx            # imm = 0xDE7
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_clrbit
void
mpz_clrbit (mpz_t d, mp_bitcnt_t bit_index)
{
  if (mpz_tstbit (d, bit_index))
    {
      if (d->_mp_size >= 0)
	mpz_abs_sub_bit (d, bit_index);
      else
	mpz_abs_add_bit (d, bit_index);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6059
testl %eax, %eax
je 0x625a
cmpl $0x0, 0x4(%r14)
js 0x625f
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x6183
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x60bb
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_combit
void
mpz_combit (mpz_t d, mp_bitcnt_t bit_index)
{
  if (mpz_tstbit (d, bit_index) ^ (d->_mp_size < 0))
    mpz_abs_sub_bit (d, bit_index);
  else
    mpz_abs_add_bit (d, bit_index);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6059
movl 0x4(%r14), %ecx
shrl $0x1f, %ecx
movq %r14, %rdi
movq %rbx, %rsi
cmpl %ecx, %eax
jne 0x629a
popq %rbx
popq %r14
popq %rbp
jmp 0x60bb
popq %rbx
popq %r14
popq %rbp
jmp 0x6183
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_popcount
mp_bitcnt_t
mpn_popcount (mp_srcptr p, mp_size_t n)
{
  mp_size_t i;
  mp_bitcnt_t c;

  for (c = 0, i = 0; i < n; i++)
    c += gmp_popcount_limb (p[i]);

  return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
testq %rsi, %rsi
cmovleq %r12, %rbx
xorl %r15d, %r15d
cmpq %r12, %rbx
je 0x6815
movq (%r14,%r12,8), %rdi
callq 0x6821
movl %eax, %eax
addq %rax, %r15
incq %r12
jmp 0x67fd
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: gmp_popcount_limb
static unsigned
gmp_popcount_limb (mp_limb_t x)
{
  unsigned c;

  /* Do 16 bits at a time, to avoid limb-sized constants. */
  for (c = 0; x > 0; x >>= 16)
    {
      unsigned w = ((x >> 1) & 0x5555) + (x & 0x5555);
      w = ((w >> 2) & 0x3333) + (w & 0x3333);
      w = ((w >> 4) & 0x0f0f) + (w & 0x0f0f);
      w = (w >> 8) + (w & 0x00ff);
      c += w;
    }
  return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movl $0x5555, %ecx           # imm = 0x5555
movl $0x3333, %edx           # imm = 0x3333
movl $0x707, %esi            # imm = 0x707
testq %rdi, %rdi
je 0x6884
movl %edi, %r8d
shrl %r8d
andl %ecx, %r8d
movl %edi, %r9d
andl %ecx, %r9d
addl %r8d, %r9d
movl %r9d, %r8d
shrl $0x2, %r8d
andl %edx, %r8d
andl %edx, %r9d
addl %r8d, %r9d
movl %r9d, %r8d
shrl $0x4, %r8d
andl %esi, %r8d
andl %esi, %r9d
addl %r8d, %r9d
movzbl %r9b, %r8d
shrl $0x8, %r9d
addl %eax, %r8d
addl %r9d, %r8d
shrq $0x10, %rdi
movl %r8d, %eax
jmp 0x6836
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_hamdist
mp_bitcnt_t
mpz_hamdist (const mpz_t u, const mpz_t v)
{
  mp_size_t un, vn, i;
  mp_limb_t uc, vc, ul, vl, comp;
  mp_srcptr up, vp;
  mp_bitcnt_t c;

  un = u->_mp_size;
  vn = v->_mp_size;

  if ( (un ^ vn) < 0)
    return ~(mp_bitcnt_t) 0;

  comp = - (uc = vc = (un < 0));
  if (uc)
    {
      assert (vn < 0);
      un = -un;
      vn = -vn;
    }

  up = u->_mp_d;
  vp = v->_mp_d;

  if (un < vn)
    MPN_SRCPTR_SWAP (up, un, vp, vn);

  for (i = 0, c = 0; i < vn; i++)
    {
      ul = (up[i] ^ comp) + uc;
      uc = ul < uc;

      vl = (vp[i] ^ comp) + vc;
      vc = vl < vc;

      c += gmp_popcount_limb (ul ^ vl);
    }
  assert (vc == 0);

  for (; i < un; i++)
    {
      ul = (up[i] ^ comp) + uc;
      uc = ul < uc;

      c += gmp_popcount_limb (ul ^ comp);
    }

  return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movslq 0x4(%rdi), %rax
movslq 0x4(%rsi), %r15
movq %r15, %rcx
xorq %rax, %rcx
js 0x68d3
testl %eax, %eax
js 0x68e8
movq %rax, %rcx
jmp 0x68fa
pushq $-0x1
popq %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %r15d, %r15d
jns 0x69f8
movq %rax, %rcx
negq %rcx
negq %r15
shrl $0x1f, %eax
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rdx
cmpq %r15, %rcx
jge 0x6916
movq %r15, -0x30(%rbp)
movq %rcx, %r15
movq %rdx, %r13
jmp 0x6920
movq %rdi, %r13
movq %rdx, %rdi
movq %rcx, -0x30(%rbp)
movq %rax, %rcx
negq %rcx
movq %rcx, -0x40(%rbp)
xorl %r14d, %r14d
testq %r15, %r15
cmovleq %r14, %r15
movq %rax, %rcx
movq $0x0, -0x38(%rbp)
movq %r13, -0x48(%rbp)
cmpq %r14, %r15
je 0x6998
movq (%r13,%r14,8), %rdx
movq -0x40(%rbp), %rsi
xorq %rsi, %rdx
xorl %r12d, %r12d
addq %rax, %rdx
setb %r12b
movq %r15, %rbx
movq %rdi, %r15
movq (%rdi,%r14,8), %rdi
xorq %rsi, %rdi
xorl %r13d, %r13d
addq %rcx, %rdi
setb %r13b
xorq %rdx, %rdi
callq 0x6821
movq %r15, %rdi
movq %rbx, %r15
movl %eax, %eax
addq %rax, -0x38(%rbp)
incq %r14
movq %r12, %rax
movq %r13, %rcx
movq -0x48(%rbp), %r13
jmp 0x6943
testq %rcx, %rcx
movq -0x30(%rbp), %r12
jne 0x69d9
movq -0x38(%rbp), %rbx
cmpq %r12, %r15
jge 0x68d6
movq (%r13,%r15,8), %rdi
movq -0x40(%rbp), %rcx
xorq %rcx, %rdi
xorl %r14d, %r14d
addq %rax, %rdi
setb %r14b
xorq %rcx, %rdi
callq 0x6821
movl %eax, %eax
addq %rax, %rbx
incq %r15
movq %r14, %rax
jmp 0x69a5
leaq 0x2cb6(%rip), %rdi      # 0x9696
leaq 0x267d(%rip), %rsi      # 0x9064
leaq 0x2d92(%rip), %rcx      # 0x9780
movl $0xf3a, %edx            # imm = 0xF3A
callq 0x1090
leaq 0x2d7a(%rip), %rdi      # 0x9779
leaq 0x265e(%rip), %rsi      # 0x9064
leaq 0x2d73(%rip), %rcx      # 0x9780
movl $0xf25, %edx            # imm = 0xF25
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_scan0
mp_bitcnt_t
mpz_scan0 (const mpz_t u, mp_bitcnt_t starting_bit)
{
  mp_ptr up;
  mp_size_t us, un, i;
  mp_limb_t limb, ux;

  us = u->_mp_size;
  ux = - (mp_limb_t) (us >= 0);
  un = GMP_ABS (us);
  i = starting_bit / GMP_LIMB_BITS;

  /* When past end, there's an immediate 0 bit for u>=0, or no 0 bits for
     u<0.  Notice this test picks up all cases of u==0 too. */
  if (i >= un)
    return (ux ? starting_bit : ~(mp_bitcnt_t) 0);

  up = u->_mp_d;
  limb = up[i] ^ ux;

  if (ux == 0)
    limb -= mpn_zero_p (up, i); /* limb = ~(~limb + zero_p) */

  /* Mask all bits before starting_bit, thus ignoring them. */
  limb &= (GMP_LIMB_MAX << (starting_bit % GMP_LIMB_BITS));

  return mpn_common_scan (limb, i, up, un, ux);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x4(%rdi), %eax
xorl %ebx, %ebx
testl %eax, %eax
setns %cl
movl %eax, %r14d
negl %r14d
cmovsl %eax, %r14d
movq %rsi, %r15
movq %rsi, %r12
shrq $0x6, %r12
cmpq %r14, %r12
jae 0x6a9c
movb %cl, %bl
negq %rbx
movq 0x8(%rdi), %rdx
movq (%rdx,%r12,8), %r13
xorq %rbx, %r13
testl %eax, %eax
jns 0x6a74
movq %rdx, %rdi
movq %r12, %rsi
movq %rdx, -0x30(%rbp)
callq 0x1354
movq -0x30(%rbp), %rdx
movl %eax, %eax
subq %rax, %r13
movl %r15d, %ecx
shrq %cl, %r13
shlq %cl, %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rcx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1a25
testl %eax, %eax
pushq $-0x1
popq %rax
cmovnsq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_limb_size_in_base_2
static mp_bitcnt_t
mpn_limb_size_in_base_2 (mp_limb_t u)
{
  unsigned shift;

  assert (u > 0);
  gmp_clz (shift, u);
  return GMP_LIMB_BITS - shift;
}

// Assembly:
testq %rdi, %rdi
je 0x6ae0
xorl %eax, %eax
movq %rdi, %rcx
shrq $0x38, %rcx
jne 0x6ad2
shlq $0x8, %rdi
addl $0x8, %eax
jmp 0x6abb
addq %rdi, %rdi
incl %eax
testq %rdi, %rdi
jns 0x6acd
movl %eax, %ecx
pushq $0x40
popq %rax
subq %rcx, %rax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x3bdf(%rip), %rdi      # 0xa6ca
leaq 0x2572(%rip), %rsi      # 0x9064
leaq 0x3bd7(%rip), %rcx      # 0xa6d0
movl $0x47f, %edx            # imm = 0x47F
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_div_qr_1_invert
static void
mpn_div_qr_1_invert (struct gmp_div_inverse *inv, mp_limb_t d)
{
  unsigned shift;

  assert (d > 0);
  gmp_clz (shift, d);
  inv->shift = shift;
  inv->d1 = d << shift;
  inv->di = mpn_invert_limb (inv->d1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x6b50
movq %rdi, %rbx
xorl %ecx, %ecx
movq %rsi, %rax
movq %rax, %rdx
shrq $0x38, %rdx
jne 0x6b2d
shlq $0x8, %rax
addl $0x8, %ecx
jmp 0x6b16
addq %rax, %rax
incl %ecx
testq %rax, %rax
jns 0x6b28
movl %ecx, (%rbx)
shlq %cl, %rsi
movq %rsi, 0x8(%rbx)
movq %rsi, %rdi
xorl %esi, %esi
callq 0x1b0d
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x37f0(%rip), %rdi      # 0xa347
leaq 0x2506(%rip), %rsi      # 0x9064
leaq 0x3b9a(%rip), %rcx      # 0xa6ff
movl $0x320, %edx            # imm = 0x320
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_div_qr_1_preinv
static mp_limb_t
mpn_div_qr_1_preinv (mp_ptr qp, mp_srcptr np, mp_size_t nn,
		     const struct gmp_div_inverse *inv)
{
  mp_limb_t d, di;
  mp_limb_t r;
  mp_ptr tp = NULL;

  if (inv->shift > 0)
    {
      tp = gmp_xalloc_limbs (nn);
      r = mpn_lshift (tp, np, nn, inv->shift);
      np = tp;
    }
  else
    r = 0;

  d = inv->d1;
  di = inv->di;
  while (--nn >= 0)
    {
      mp_limb_t q;

      gmp_udiv_qrnnd_preinv (q, r, r, np[nn], d, di);
      if (qp)
	qp[nn] = q;
    }
  if (inv->shift > 0)
    gmp_free (tp);

  return r >> inv->shift;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
cmpl $0x0, (%rcx)
je 0x6bca
leaq (,%r14,8), %rdi
callq *0x84f9(%rip)           # 0xf098
movq %rbx, -0x38(%rbp)
movq %rax, %rbx
movq -0x38(%rbp), %rax
movl (%rax), %ecx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x187e
movq %rax, %r13
movq %rbx, -0x30(%rbp)
movq %rbx, %r12
movq -0x38(%rbp), %rbx
jmp 0x6bd5
movq $0x0, -0x30(%rbp)
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rdx
movl %edx, %ecx
shrq $0x20, %rdx
movabsq $0x100000000, %rsi      # imm = 0x100000000
testq %r14, %r14
jle 0x6c96
movq %r13, %r9
shrq $0x20, %r9
movl %r13d, %edi
movq %rdi, %r10
imulq %rcx, %r10
imulq %rdx, %rdi
movq %r9, %r11
imulq %rcx, %r11
imulq %rdx, %r9
movl %r10d, %r8d
shrq $0x20, %r10
addq %r11, %rdi
addq %r10, %rdi
leaq (%r9,%rsi), %r10
cmpq %r11, %rdi
cmovaeq %r9, %r10
movq %rdi, %r11
shrq $0x20, %r11
shlq $0x20, %rdi
orq %rdi, %r8
movq -0x8(%r12,%r14,8), %r9
addq %r9, %r8
leaq 0x1(%r13,%r11), %rdi
adcq %r10, %rdi
movq %rdi, %r10
imulq %rax, %r10
subq %r10, %r9
cmpq %r8, %r9
movl $0x0, %r13d
cmovaq %rax, %r13
addq %r9, %r13
cmpq %rax, %r13
movl $0x0, %r10d
cmovaeq %rax, %r10
testq %r15, %r15
je 0x6c8b
cmpq %r9, %r8
sbbq $0x0, %rdi
cmpq %rax, %r13
sbbq $-0x1, %rdi
movq %rdi, -0x8(%r15,%r14,8)
subq %r10, %r13
decq %r14
jmp 0x6bed
cmpl $0x0, (%rbx)
je 0x6cab
movq -0x30(%rbp), %rdi
xorl %esi, %esi
callq *0x8401(%rip)           # 0xf0a8
movl (%rbx), %ecx
jmp 0x6cad
xorl %ecx, %ecx
shrq %cl, %r13
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_get_str
char *
mpz_get_str (char *sp, int base, const mpz_t u)
{
  unsigned bits;
  const char *digits;
  mp_size_t un;
  size_t i, sn;

  if (base >= 0)
    {
      digits = "0123456789abcdefghijklmnopqrstuvwxyz";
    }
  else
    {
      base = -base;
      digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    }
  if (base <= 1)
    base = 10;
  if (base > 36)
    return NULL;

  sn = 1 + mpz_sizeinbase (u, base);
  if (!sp)
    sp = (char *) gmp_xalloc (1 + sn);

  un = GMP_ABS (u->_mp_size);

  if (un == 0)
    {
      sp[0] = '0';
      sp[1] = '\0';
      return sp;
    }

  i = 0;

  if (u->_mp_size < 0)
    sp[i++] = '-';

  bits = mpn_base_power_of_two_p (base);

  if (bits)
    /* Not modified in this case. */
    sn = i + mpn_get_str_bits ((unsigned char *) sp + i, bits, u->_mp_d, un);
  else
    {
      struct mpn_base_info info;
      mp_ptr tp;

      mpn_get_base_info (&info, base);
      tp = gmp_xalloc_limbs (un);
      mpn_copyi (tp, u->_mp_d, un);

      sn = i + mpn_get_str_other ((unsigned char *) sp + i, base, &info, tp, un);
      gmp_free (tp);
    }

  for (; i < sn; i++)
    sp[i] = digits[(unsigned char) sp[i]];

  sp[sn] = '\0';
  return sp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %eax
negl %eax
cmovsl %esi, %eax
testl %esi, %esi
leaq 0x2b27(%rip), %rcx      # 0x980a
leaq 0x2b45(%rip), %r13      # 0x982f
cmovnsq %rcx, %r13
cmpl $0x2, %eax
pushq $0xa
popq %r15
cmovael %eax, %r15d
cmpl $0x24, %r15d
jbe 0x6d03
xorl %ebx, %ebx
jmp 0x6d53
movq %rdx, %r12
movq %rdi, %rbx
movq %rdx, %rdi
movl %r15d, %esi
callq 0x5844
testq %rbx, %rbx
jne 0x6d29
addq $0x2, %rax
movq %rax, %rdi
callq *0x8372(%rip)           # 0xf098
movq %rax, %rbx
movl 0x4(%r12), %eax
movl %eax, %r14d
negl %r14d
cmovsl %eax, %r14d
jae 0x6d47
movq %r12, -0x30(%rbp)
testl %eax, %eax
js 0x6d65
xorl %r12d, %r12d
jmp 0x6d6c
movb $0x30, (%rbx)
pushq $0x1
popq %r14
movb $0x0, (%rbx,%r14)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x2d, (%rbx)
pushq $0x1
popq %r12
movl %r15d, %edi
callq 0x1d5c
testl %eax, %eax
je 0x6d93
leaq (%rbx,%r12), %rdi
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rdx
movl %eax, %esi
movq %r14, %rcx
callq 0x1dca
movq %rax, %r14
jmp 0x6dec
movl %r15d, %esi
leaq -0x48(%rbp), %rdi
callq 0x1e6c
leaq (,%r14,8), %rdi
callq *0x82eb(%rip)           # 0xf098
movq %rax, %rdi
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rsi
movq %r14, %rdx
callq 0x12ed
leaq (%rbx,%r12), %rdi
movl %r15d, %esi
leaq -0x48(%rbp), %rdx
movq -0x38(%rbp), %r15
movq %r15, %rcx
movq %r14, %r8
callq 0x1e93
movq %rax, %r14
movq %r15, %rdi
xorl %esi, %esi
callq *0x82bc(%rip)           # 0xf0a8
addq %r12, %r14
cmpq %r14, %r12
jae 0x6d4e
movzbl (%rbx,%r12), %eax
movb (%r13,%rax), %al
movb %al, (%rbx,%r12)
incq %r12
jmp 0x6def
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_out_str
size_t
mpz_out_str (FILE *stream, int base, const mpz_t x)
{
  char *str;
  size_t len;

  str = mpz_get_str (NULL, base, x);
  len = strlen (str);
  len = fwrite (str, 1, len, stream);
  gmp_free (str);
  return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %edi, %edi
callq 0x6cc2
movq %rax, %r14
movq %rax, %rdi
callq 0x1070
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x10f0
movq %rax, %rbx
movq %r14, %rdi
xorl %esi, %esi
callq *0x7fd7(%rip)           # 0xf0a8
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq