LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_abs_add
static mp_size_t
mpz_abs_add (mpz_t r, const mpz_t a, const mpz_t b)
{
  mp_size_t an = GMP_ABS (a->_mp_size);
  mp_size_t bn = GMP_ABS (b->_mp_size);
  mp_ptr rp;
  mp_limb_t cy;

  if (an < bn)
    {
      MPZ_SRCPTR_SWAP (a, b);
      MP_SIZE_T_SWAP (an, bn);
    }

  rp = MPZ_REALLOC (r, an + 1);
  cy = mpn_add (rp, a->_mp_d, an, b->_mp_d, bn);

  rp[an] = cy;

  return an + cy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jl 0x495a
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x4c(%rbp)
jmp 0x4966
movq -0x10(%rbp), %rcx
xorl %eax, %eax
subl 0x4(%rcx), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cltq
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jl 0x4985
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x50(%rbp)
jmp 0x4991
movq -0x18(%rbp), %rcx
xorl %eax, %eax
subl 0x4(%rcx), %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
cltq
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x49da
jmp 0x49a6
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x49c0
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x49da
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
cmpq %rcx, %rax
jle 0x4a05
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x1, %rsi
callq 0x3440
movq %rax, -0x58(%rbp)
jmp 0x4a11
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %r8
callq 0x16d0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_mul_si
void
mpz_mul_si (mpz_t r, const mpz_t u, long int v)
{
  if (v < 0)
    {
      mpz_mul_ui (r, u, GMP_NEG_CAST (unsigned long int, v));
      mpz_neg (r, r);
    }
  else
    mpz_mul_ui (r, u, (unsigned long int) v);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0x4d2a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
addq $0x1, %rax
subq $0x1, %rax
xorl %ecx, %ecx
movl %ecx, %edx
subq %rax, %rdx
callq 0x4d50
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x4440
jmp 0x4d3b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4d50
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_mul_ui
void
mpz_mul_ui (mpz_t r, const mpz_t u, unsigned long int v)
{
  mp_size_t un, us;
  mp_ptr tp;
  mp_limb_t cy;

  us = u->_mp_size;

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

  un = GMP_ABS (us);

  tp = MPZ_REALLOC (r, un + 1);
  cy = mpn_mul_1 (tp, u->_mp_d, un, v);
  tp[un] = cy;

  un += (cy > 0);
  r->_mp_size = (us < 0) ? - un : un;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x4d7e
cmpq $0x0, -0x18(%rbp)
jne 0x4d8e
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
jmp 0x4e5c
cmpq $0x0, -0x28(%rbp)
jl 0x4d9f
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x4da9
xorl %eax, %eax
subq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
cmpq %rcx, %rax
jle 0x4ddc
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x1, %rsi
callq 0x3440
movq %rax, -0x48(%rbp)
jmp 0x4de8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x19a0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
cmpq $0x0, -0x38(%rbp)
seta %al
andb $0x1, %al
movzbl %al, %eax
cltq
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0x4e47
xorl %eax, %eax
subq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x4e4f
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_mul
void
mpz_mul (mpz_t r, const mpz_t u, const mpz_t v)
{
  int sign;
  mp_size_t un, vn, rn;
  mpz_t t;
  mp_ptr tp;

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

  if (un == 0 || vn == 0)
    {
      r->_mp_size = 0;
      return;
    }

  sign = (un ^ vn) < 0;

  un = GMP_ABS (un);
  vn = GMP_ABS (vn);

  mpz_init2 (t, (un + vn) * GMP_LIMB_BITS);

  tp = t->_mp_d;
  if (un >= vn)
    mpn_mul (tp, u->_mp_d, un, v->_mp_d, vn);
  else
    mpn_mul (tp, v->_mp_d, vn, u->_mp_d, un);

  rn = un + vn;
  rn -= tp[rn-1] == 0;

  t->_mp_size = sign ? - rn : rn;
  mpz_swap (r, t);
  mpz_clear (t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x4eaa
cmpq $0x0, -0x30(%rbp)
jne 0x4eba
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
jmp 0x4fec
movq -0x28(%rbp), %rax
xorq -0x30(%rbp), %rax
cmpq $0x0, %rax
setl %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x28(%rbp)
jl 0x4ee2
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x4eec
xorl %eax, %eax
subq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x30(%rbp)
jl 0x4f05
movq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x4f0f
xorl %eax, %eax
subq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq -0x30(%rbp), %rsi
shlq $0x6, %rsi
callq 0x3250
movq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jl 0x4f61
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x30(%rbp), %r8
callq 0x1f30
jmp 0x4f82
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %r8
callq 0x1f30
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x58(%rbp), %rax
movq -0x38(%rbp), %rcx
subq $0x1, %rcx
cmpq $0x0, (%rax,%rcx,8)
sete %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
movq -0x38(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x4fc7
xorl %eax, %eax
subq -0x38(%rbp), %rax
movq %rax, -0x70(%rbp)
jmp 0x4fcf
movq -0x38(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movl %eax, -0x4c(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x4480
leaq -0x50(%rbp), %rdi
callq 0x32c0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_mul_2exp
void
mpz_mul_2exp (mpz_t r, const mpz_t u, mp_bitcnt_t bits)
{
  mp_size_t un, rn;
  mp_size_t limbs;
  unsigned shift;
  mp_ptr rp;

  un = GMP_ABS (u->_mp_size);
  if (un == 0)
    {
      r->_mp_size = 0;
      return;
    }

  limbs = bits / GMP_LIMB_BITS;
  shift = bits % GMP_LIMB_BITS;

  rn = un + limbs + (shift > 0);
  rp = MPZ_REALLOC (r, rn);
  if (shift > 0)
    {
      mp_limb_t cy = mpn_lshift (rp + limbs, u->_mp_d, un, shift);
      rp[rn-1] = cy;
      rn -= (cy == 0);
    }
  else
    mpn_copyd (rp + limbs, u->_mp_d, un);

  mpn_zero (rp, limbs);

  r->_mp_size = (u->_mp_size < 0) ? - rn : rn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jl 0x502a
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x4c(%rbp)
jmp 0x5036
movq -0x10(%rbp), %rcx
xorl %eax, %eax
subl 0x4(%rcx), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cltq
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5056
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
jmp 0x5179
movq -0x18(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
andq $0x3f, %rax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
addq -0x30(%rbp), %rax
cmpl $0x0, -0x34(%rbp)
seta %cl
andb $0x1, %cl
movzbl %cl, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
cmpq %rcx, %rax
jle 0x50af
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3440
movq %rax, -0x58(%rbp)
jmp 0x50bb
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, -0x34(%rbp)
jbe 0x5121
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
movl -0x34(%rbp), %ecx
callq 0x20b0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdx
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
cmpq $0x0, -0x48(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x5141
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x13e0
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1520
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jge 0x5164
xorl %eax, %eax
subq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x516c
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
addq $0x60, %rsp
popq %rbp
retq
nop
// File: marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_addmul_ui
void
mpz_addmul_ui (mpz_t r, const mpz_t u, unsigned long int v)
{
  mpz_t t;
  mpz_init (t);
  mpz_mul_ui (t, u, v);
  mpz_add (r, r, t);
  mpz_clear (t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31e0
leaq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4d50
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x48a0
leaq -0x30(%rbp), %rdi
callq 0x32c0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4030
cmpl $0x0, %eax
jne 0x60df
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x41b0
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x6118
leaq -0x30(%rbp), %rdi
callq 0x31e0
leaq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4c50
leaq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6060
movl %eax, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x32c0
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x67c1
cmpq $0x0, -0x8(%rbp)
je 0x67bf
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x43f0
jmp 0x6832
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jl 0x67d7
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x67e3
movq -0x10(%rbp), %rcx
xorl %eax, %eax
subl 0x4(%rcx), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cltq
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x681c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edi
callq 0x6a30
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x6840
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6830
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3350
jmp 0x6832
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0x6a54
jmp 0x6a73
leaq 0x8d61(%rip), %rdi      # 0xf7bc
leaq 0x7672(%rip), %rsi      # 0xe0d4
movl $0x37f, %edx            # imm = 0x37F
leaq 0x8d54(%rip), %rcx      # 0xf7c2
callq 0x1070
movq -0x28(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
jne 0x6b80
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
andq %rcx, %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6b76
cmpq $0x1, -0x28(%rbp)
ja 0x6aca
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1390
jmp 0x6b74
jmp 0x6acc
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movq -0x40(%rbp), %rax
xorl %ecx, %ecx
subq -0x40(%rbp), %rcx
andq %rcx, %rax
movq %rax, -0x50(%rbp)
movl $0x0, -0x54(%rbp)
movabsq $-0x100000000000000, %rax # imm = 0xFF00000000000000
andq -0x50(%rbp), %rax
cmpq $0x0, %rax
jne 0x6b1e
movq -0x50(%rbp), %rax
shlq $0x8, %rax
movq %rax, -0x50(%rbp)
movl -0x54(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x54(%rbp)
jmp 0x6af3
jmp 0x6b20
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq -0x50(%rbp), %rax
cmpq $0x0, %rax
jne 0x6b4a
movq -0x50(%rbp), %rax
shlq %rax
movq %rax, -0x50(%rbp)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x6b20
movl -0x54(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, %ecx
movl $0x3f, %eax
subq %rcx, %rax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x34(%rbp), %ecx
callq 0x2230
jmp 0x6b76
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6ba6
movq -0x28(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0xa2a0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x78(%rbp), %rcx
callq 0xa390
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jle 0x6da8
jmp 0x6dc7
leaq 0x8a53(%rip), %rdi      # 0xf802
leaq 0x731e(%rip), %rsi      # 0xe0d4
movl $0xaa0, %edx            # imm = 0xAA0
leaq 0x8a50(%rip), %rcx      # 0xf812
callq 0x1070
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rsi
movq %r8, %rcx
callq 0x23e0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x5b80
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8ce0
cmpl $0x0, %eax
jne 0x746a
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jl 0x745b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8df0
jmp 0x7468
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8fc0
jmp 0x746a
addq $0x10, %rsp
popq %rbp
retq
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x7498
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x74a5
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
jmp 0x74f7
leaq -0x30(%rbp), %rdi
callq 0x31e0
leaq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x6bc0
leaq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x5ff0
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4e70
leaq -0x30(%rbp), %rdi
callq 0x32c0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x43f0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7525
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x7532
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
jmp 0x7571
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %edi
callq 0x6790
movq %rax, %rcx
movq -0x18(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4d50
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x43f0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x75b1
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x4250
cmpl $0x0, %eax
jg 0x75bd
movl $0x0, -0x4(%rbp)
jmp 0x7665
leaq -0x30(%rbp), %rdi
callq 0x31e0
leaq -0x40(%rbp), %rdi
callq 0x31e0
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
xorl %eax, %eax
movl %eax, %edx
callq 0x6e10
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x4120
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0x764d
cmpl $0x0, -0x3c(%rbp)
jge 0x7640
movq -0x20(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jl 0x762d
leaq -0x40(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x48a0
jmp 0x763e
leaq -0x40(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4c50
jmp 0x7640
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4480
leaq -0x30(%rbp), %rdi
callq 0x32c0
leaq -0x40(%rbp), %rdi
callq 0x32c0
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x3520
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x4e70
movq -0x18(%rbp), %rax
andq -0x20(%rbp), %rax
cmpq $0x0, %rax
je 0x76d0
leaq -0x30(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x4e70
movq -0x20(%rbp), %rax
shrq %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
ja 0x76a0
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4480
leaq -0x30(%rbp), %rdi
callq 0x32c0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31e0
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x7ff0
cmpl $0x0, -0x2c(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x32c0
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jle 0x8621
jmp 0x8640
leaq 0x700d(%rip), %rdi      # 0xf635
leaq 0x5aa5(%rip), %rsi      # 0xe0d4
movl $0xce5, %edx            # imm = 0xCE5
leaq 0x603e(%rip), %rcx      # 0xe679
callq 0x1070
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x8655
jmp 0x8674
leaq 0x6010(%rip), %rdi      # 0xe66c
leaq 0x5a71(%rip), %rsi      # 0xe0d4
movl $0xce6, %edx            # imm = 0xCE6
leaq 0x600a(%rip), %rcx      # 0xe679
callq 0x1070
leaq -0x40(%rbp), %rdi
callq 0x31e0
leaq -0x30(%rbp), %rdi
callq 0x31e0
leaq -0x30(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3920
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq %rax, %rdx
movl $0x2, %ecx
callq 0x7ff0
movslq -0x2c(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jne 0x86e4
jmp 0x8703
leaq 0x5fca(%rip), %rdi      # 0xe6b5
leaq 0x59e2(%rip), %rsi      # 0xe0d4
movl $0xcec, %edx            # imm = 0xCEC
leaq 0x5f7b(%rip), %rcx      # 0xe679
callq 0x1070
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movslq -0x2c(%rbp), %rdx
callq 0x13e0
leaq -0x30(%rbp), %rdi
callq 0x32c0
movslq -0x3c(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x873d
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x13e0
leaq -0x40(%rbp), %rdi
callq 0x32c0
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
setbe %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rsi
callq 0x3350
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
shrq %rcx
cmpq %rcx, %rax
jbe 0x8818
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0x8808
movq -0x10(%rbp), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x8810
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x8810
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31e0
leaq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8750
cmpq $0x0, -0x18(%rbp)
jbe 0x885f
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq %rdx, %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
callq 0x4d50
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x882e
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x5ff0
leaq -0x30(%rbp), %rdi
callq 0x32c0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jl 0x8add
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x8ae7
xorl %eax, %eax
subq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jl 0x8b2e
cmpq $0x0, -0x28(%rbp)
jl 0x8b19
movq $-0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x8b21
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8bd6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8bb9
cmpq $0x0, -0x28(%rbp)
jge 0x8b9f
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x14a0
cltq
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
xorq $-0x1, %rax
addq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
setae %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
xorl %eax, %eax
subq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rcx
andq $0x3f, %rcx
movq $-0x1, %rax
shlq %cl, %rax
andq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x48(%rbp), %r8
callq 0x23e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
// File: marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: gmp_millerrabin
static int
gmp_millerrabin (const mpz_t n, const mpz_t nm1, mpz_t y,
		 const mpz_t q, mp_bitcnt_t k)
{
  assert (k > 0);

  /* Caller must initialize y to the base. */
  mpz_powm (y, y, q, n);

  if (mpz_cmp_ui (y, 1) == 0 || mpz_cmp (y, nm1) == 0)
    return 1;

  while (--k > 0)
    {
      mpz_powm_ui (y, y, 2, n);
      if (mpz_cmp (y, nm1) == 0)
	return 1;
      /* y == 1 means that the previous y was a non-trivial square root
	 of 1 (mod n). y == 0 means that n is a power of the base.
	 In either case, n is not prime. */
      if (mpz_cmp_ui (y, 1) <= 0)
	return 0;
    }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jbe 0x8c05
jmp 0x8c24
leaq 0x6e87(%rip), %rdi      # 0xfa93
leaq 0x54c1(%rip), %rsi      # 0xe0d4
movl $0xd1a, %edx            # imm = 0xD1A
leaq 0x6e7a(%rip), %rcx      # 0xfa99
callq 0x1070
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x7750
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x4120
cmpl $0x0, %eax
je 0x8c5e
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x41b0
cmpl $0x0, %eax
jne 0x8c67
movl $0x1, -0x4(%rbp)
jmp 0x8cd1
jmp 0x8c69
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jbe 0x8cca
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rcx
movl $0x2, %edx
callq 0x7f90
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x41b0
cmpl $0x0, %eax
jne 0x8cac
movl $0x1, -0x4(%rbp)
jmp 0x8cd1
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x4120
cmpl $0x0, %eax
jg 0x8cc8
movl $0x0, -0x4(%rbp)
jmp 0x8cd1
jmp 0x8c69
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jl 0x8d09
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x8d13
xorl %eax, %eax
subq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x38(%rbp), %rax
jl 0x8d46
cmpq $0x0, -0x30(%rbp)
setl %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x8de4
movq -0x18(%rbp), %rax
andq $0x3f, %rax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl -0x24(%rbp), %ecx
shrq %cl, %rax
andq $0x1, %rax
movl %eax, -0x44(%rbp)
cmpq $0x0, -0x30(%rbp)
jge 0x8dde
cmpl $0x0, -0x24(%rbp)
jbe 0x8da8
movq -0x40(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
movl $0x40, %ecx
subq %rdx, %rcx
shlq %cl, %rax
cmpq $0x0, %rax
jbe 0x8da8
movl -0x44(%rbp), %eax
xorl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x8de4
jmp 0x8daa
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jl 0x8ddc
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jbe 0x8dda
movl -0x44(%rbp), %eax
xorl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x8de4
jmp 0x8daa
jmp 0x8dde
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jl 0x8fe6
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x3c(%rbp)
jmp 0x8ff2
movq -0x8(%rbp), %rcx
xorl %eax, %eax
subl 0x4(%rcx), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cltq
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x9033
jmp 0x9052
leaq 0x6ad2(%rip), %rdi      # 0xfb0c
leaq 0x5093(%rip), %rsi      # 0xe0d4
movl $0xde4, %edx            # imm = 0xDE4
leaq 0x6acf(%rip), %rcx      # 0xfb1c
callq 0x1070
jmp 0x9054
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
subq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x1780
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x9090
jmp 0x90af
leaq 0x540e(%rip), %rdi      # 0xe4a5
leaq 0x5036(%rip), %rsi      # 0xe0d4
movl $0xde7, %edx            # imm = 0xDE7
leaq 0x6a72(%rip), %rcx      # 0xfb1c
callq 0x1070
jmp 0x90b1
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x14d0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jge 0x90d8
xorl %eax, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x90e0
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8ce0
cmpl $0x0, %eax
je 0x914a
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jl 0x913b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8fc0
jmp 0x9148
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8df0
jmp 0x914a
addq $0x10, %rsp
popq %rbp
retq
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x9d73
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x9d80
movl %eax, %eax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x9d40
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jbe 0x9e14
movq -0x8(%rbp), %rax
shrq %rax
andq $0x5555, %rax           # imm = 0x5555
movq -0x8(%rbp), %rcx
andq $0x5555, %rcx           # imm = 0x5555
addq %rcx, %rax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
shrl $0x2, %eax
andl $0x3333, %eax           # imm = 0x3333
movl -0x10(%rbp), %ecx
andl $0x3333, %ecx           # imm = 0x3333
addl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
shrl $0x4, %eax
andl $0xf0f, %eax            # imm = 0xF0F
movl -0x10(%rbp), %ecx
andl $0xf0f, %ecx            # imm = 0xF0F
addl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
shrl $0x8, %eax
movl -0x10(%rbp), %ecx
andl $0xff, %ecx
addl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
shrq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0x9d8f
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_popcount
mp_bitcnt_t
mpz_popcount (const mpz_t u)
{
  mp_size_t un;

  un = u->_mp_size;

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

  return mpn_popcount (u->_mp_d, un);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0x9e49
movq $-0x1, -0x8(%rbp)
jmp 0x9e5e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x9d20
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
setge %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
xorl %eax, %eax
subq %rcx, %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x28(%rbp)
jl 0xa106
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0xa110
xorl %eax, %eax
subq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jl 0xa156
cmpq $0x0, -0x48(%rbp)
je 0xa13f
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0xa14c
movq $-0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0xa14c
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa1cf
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
xorq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0xa198
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x14a0
movslq %eax, %rcx
movq -0x40(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rcx
andq $0x3f, %rcx
movq $-0x1, %rax
shlq %cl, %rax
andq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x48(%rbp), %r8
callq 0x23e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jbe 0xa2b9
jmp 0xa2d8
leaq 0x54fc(%rip), %rdi      # 0xf7bc
leaq 0x3e0d(%rip), %rsi      # 0xe0d4
movl $0x320, %edx            # imm = 0x320
leaq 0x58b0(%rip), %rcx      # 0xfb83
callq 0x1070
jmp 0xa2da
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movabsq $-0x100000000000000, %rax # imm = 0xFF00000000000000
andq -0x20(%rbp), %rax
cmpq $0x0, %rax
jne 0xa314
movq -0x20(%rbp), %rax
shlq $0x8, %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x24(%rbp)
jmp 0xa2e9
jmp 0xa316
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq -0x20(%rbp), %rax
cmpq $0x0, %rax
jne 0xa340
movq -0x20(%rbp), %rax
shlq %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xa316
movl -0x24(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
shlq %cl, %rax
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x25e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %edi
callq 0xa680
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1050
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x10d0
movq %rax, -0x28(%rbp)
movq 0x8373(%rip), %rax      # 0x13098
movq -0x20(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
callq *%rax
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: marxn[P]pupp/3rdparty/gmp/./bootstrap.c
// Function: isprime
int
isprime (unsigned long int t)
{
  unsigned long int q, r, d;

  if (t < 32)
    return (0xa08a28acUL >> t) & 1;
  if ((t & 1) == 0)
    return 0;

  if (t % 3 == 0)
    return 0;
  if (t % 5 == 0)
    return 0;
  if (t % 7 == 0)
    return 0;

  for (d = 11;;)
    {
      q = t / d;
      r = t - q * d;
      if (q < d)
	return 1;
      if (r == 0)
	break;
      d += 2;
      q = t / d;
      r = t - q * d;
      if (q < d)
	return 1;
      if (r == 0)
	break;
      d += 4;
    }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x20, -0x10(%rbp)
jae 0xb3d7
movq -0x10(%rbp), %rcx
movl $0xa08a28ac, %eax       # imm = 0xA08A28AC
shrq %cl, %rax
andq $0x1, %rax
movl %eax, -0x4(%rbp)
jmp 0xb4fd
movq -0x10(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0xb3f1
movl $0x0, -0x4(%rbp)
jmp 0xb4fd
movq -0x10(%rbp), %rax
movl $0x3, %ecx
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
jne 0xb411
movl $0x0, -0x4(%rbp)
jmp 0xb4fd
movq -0x10(%rbp), %rax
movl $0x5, %ecx
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
jne 0xb431
movl $0x0, -0x4(%rbp)
jmp 0xb4fd
movq -0x10(%rbp), %rax
movl $0x7, %ecx
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
jne 0xb451
movl $0x0, -0x4(%rbp)
jmp 0xb4fd
movq $0xb, -0x28(%rbp)
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x28(%rbp)
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
imulq -0x28(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0xb490
movl $0x1, -0x4(%rbp)
jmp 0xb4fd
cmpq $0x0, -0x20(%rbp)
jne 0xb499
jmp 0xb4f6
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x28(%rbp)
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
imulq -0x28(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0xb4dc
movl $0x1, -0x4(%rbp)
jmp 0xb4fd
cmpq $0x0, -0x20(%rbp)
jne 0xb4e5
jmp 0xb4f6
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
jmp 0xb459
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/./bootstrap.c
// Function: log2_ceil
int
log2_ceil (int n)
{
  int  e;
  assert (n >= 1);
  for (e = 0; ; e++)
    if ((1 << e) >= n)
      break;
  return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x1, -0x4(%rbp)
jl 0xb523
jmp 0xb542
leaq 0x2ddc(%rip), %rdi      # 0xe306
leaq 0x3554(%rip), %rsi      # 0xea85
movl $0x51, %edx
leaq 0x3556(%rip), %rcx      # 0xea93
callq 0x1070
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
cmpl -0x4(%rbp), %eax
jl 0xb55a
jmp 0xb567
jmp 0xb55c
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xb549
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq