LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_mul_1
mp_limb_t
mpn_mul_1 (mp_ptr rp, mp_srcptr up, mp_size_t n, mp_limb_t vl)
{
  mp_limb_t ul, cl, hpl, lpl;

  assert (n >= 1);

  cl = 0;
  do
    {
      ul = *up++;
      gmp_umul_ppmm (hpl, lpl, ul, vl);

      lpl += cl;
      cl = (lpl < cl) + hpl;

      *rp++ = lpl;
    }
  while (--n != 0);

  return cl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdx, %rdx
jle 0x161d
movq %rcx, %r8
shrq $0x20, %r8
movl %ecx, %ecx
xorl %r9d, %r9d
movabsq $0x100000000, %r10      # imm = 0x100000000
xorl %eax, %eax
movq (%rsi,%r9,8), %rbx
movl %ebx, %r11d
shrq $0x20, %rbx
movq %r11, %r14
imulq %rcx, %r14
imulq %r8, %r11
movq %rbx, %r15
imulq %rcx, %r15
imulq %r8, %rbx
movl %r14d, %r12d
shrq $0x20, %r14
addq %r15, %r11
addq %r14, %r11
leaq (%rbx,%r10), %r14
cmpq %r15, %r11
cmovaeq %rbx, %r14
movq %r11, %rbx
shrq $0x20, %rbx
shlq $0x20, %r11
addq %rax, %r12
addq %r11, %r12
cmpq %rax, %r12
movq %rbx, %rax
adcq %r14, %rax
movq %r12, (%rdi,%r9,8)
incq %r9
cmpq %r9, %rdx
jne 0x15b5
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7c72(%rip), %rdi      # 0x9296
leaq 0x7a39(%rip), %rsi      # 0x9064
leaq 0x7b57(%rip), %rcx      # 0x9189
movl $0x1f6, %edx            # imm = 0x1F6
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_addmul_1
mp_limb_t
mpn_addmul_1 (mp_ptr rp, mp_srcptr up, mp_size_t n, mp_limb_t vl)
{
  mp_limb_t ul, cl, hpl, lpl, rl;

  assert (n >= 1);

  cl = 0;
  do
    {
      ul = *up++;
      gmp_umul_ppmm (hpl, lpl, ul, vl);

      lpl += cl;
      cl = (lpl < cl) + hpl;

      rl = *rp;
      lpl = rl + lpl;
      cl += lpl < rl;
      *rp++ = lpl;
    }
  while (--n != 0);

  return cl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdx, %rdx
jle 0x16da
movq %rcx, %r8
shrq $0x20, %r8
movl %ecx, %ecx
xorl %r9d, %r9d
movabsq $0x100000000, %r10      # imm = 0x100000000
xorl %eax, %eax
movq (%rsi,%r9,8), %rbx
movl %ebx, %r11d
shrq $0x20, %rbx
movq %r11, %r14
imulq %rcx, %r14
imulq %r8, %r11
movq %rbx, %r15
imulq %rcx, %r15
imulq %r8, %rbx
movl %r14d, %r12d
shrq $0x20, %r14
addq %r15, %r11
addq %r14, %r11
leaq (%rbx,%r10), %r14
cmpq %r15, %r11
cmovaeq %rbx, %r14
movq %r11, %rbx
shrq $0x20, %rbx
addq %r14, %rbx
shlq $0x20, %r11
addq %rax, %r12
addq %r11, %r12
xorl %r11d, %r11d
cmpq %rax, %r12
setb %r11b
addq %r12, (%rdi,%r9,8)
movq %r11, %rax
adcq %rbx, %rax
incq %r9
cmpq %r9, %rdx
jne 0x1668
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7bb5(%rip), %rdi      # 0x9296
leaq 0x797c(%rip), %rsi      # 0x9064
leaq 0x7ad7(%rip), %rcx      # 0x91c6
movl $0x20d, %edx            # imm = 0x20D
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_mul
mp_limb_t
mpn_mul (mp_ptr rp, mp_srcptr up, mp_size_t un, mp_srcptr vp, mp_size_t vn)
{
  assert (un >= vn);
  assert (vn >= 1);

  /* We first multiply by the low order limb. This result can be
     stored, not added, to rp. We also avoid a loop for zeroing this
     way. */

  rp[un] = mpn_mul_1 (rp, up, un, vp[0]);

  /* Now accumulate the product of up[] and the next higher limb from
     vp[]. */

  while (--vn >= 1)
    {
      rp += 1, vp += 1;
      rp[un] = mpn_addmul_1 (rp, up, un, vp[0]);
    }
  return rp[un];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq %r8, %rdx
jl 0x181d
movq %r8, %rbx
testq %r8, %r8
jle 0x183c
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq (%rcx), %rcx
callq 0x1589
addq $0x8, %r13
addq $0x8, %r14
movq %rax, -0x8(%r13,%r15,8)
cmpq $0x2, %rbx
jl 0x180e
decq %rbx
movq (%r14), %rcx
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x163c
jmp 0x17e5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7a22(%rip), %rdi      # 0x9246
leaq 0x7839(%rip), %rsi      # 0x9064
leaq 0x7a1d(%rip), %rcx      # 0x924f
movl $0x23f, %edx            # imm = 0x23F
callq 0x1090
leaq 0x7a52(%rip), %rdi      # 0x9295
leaq 0x781a(%rip), %rsi      # 0x9064
leaq 0x79fe(%rip), %rcx      # 0x924f
movl $0x240, %edx            # imm = 0x240
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_lshift
mp_limb_t
mpn_lshift (mp_ptr rp, mp_srcptr up, mp_size_t n, unsigned int cnt)
{
  mp_limb_t high_limb, low_limb;
  unsigned int tnc;
  mp_limb_t retval;

  assert (n >= 1);
  assert (cnt >= 1);
  assert (cnt < GMP_LIMB_BITS);

  up += n;
  rp += n;

  tnc = GMP_LIMB_BITS - cnt;
  low_limb = *--up;
  retval = low_limb >> tnc;
  high_limb = (low_limb << cnt);

  while (--n != 0)
    {
      low_limb = *--up;
      *--rp = high_limb | (low_limb >> tnc);
      high_limb = (low_limb << cnt);
    }
  *--rp = high_limb;

  return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdx, %rdx
jle 0x18e4
testl %ecx, %ecx
je 0x1903
cmpl $0x40, %ecx
jae 0x1922
movl %ecx, %r9d
pushq $0x40
popq %r8
subl %ecx, %r8d
movq -0x8(%rsi,%rdx,8), %rax
movq %rax, %r10
movl %r9d, %ecx
shlq %cl, %r10
cmpq $0x1, %rdx
je 0x18d2
movq -0x10(%rsi,%rdx,8), %r11
movq %r11, %rbx
movl %r8d, %ecx
shrq %cl, %rbx
orq %r10, %rbx
movq %rbx, -0x8(%rdi,%rdx,8)
decq %rdx
movq %r11, %r10
jmp 0x18a8
movl %r8d, %ecx
shrq %cl, %rax
movq %r10, -0x8(%rdi,%rdx,8)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x79ab(%rip), %rdi      # 0x9296
leaq 0x7772(%rip), %rsi      # 0x9064
leaq 0x79a4(%rip), %rcx      # 0x929d
movl $0x266, %edx            # imm = 0x266
callq 0x1090
leaq 0x79d4(%rip), %rdi      # 0x92de
leaq 0x7753(%rip), %rsi      # 0x9064
leaq 0x7985(%rip), %rcx      # 0x929d
movl $0x267, %edx            # imm = 0x267
callq 0x1090
leaq 0x79be(%rip), %rdi      # 0x92e7
leaq 0x7734(%rip), %rsi      # 0x9064
leaq 0x7966(%rip), %rcx      # 0x929d
movl $0x268, %edx            # imm = 0x268
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_rshift
mp_limb_t
mpn_rshift (mp_ptr rp, mp_srcptr up, mp_size_t n, unsigned int cnt)
{
  mp_limb_t high_limb, low_limb;
  unsigned int tnc;
  mp_limb_t retval;

  assert (n >= 1);
  assert (cnt >= 1);
  assert (cnt < GMP_LIMB_BITS);

  tnc = GMP_LIMB_BITS - cnt;
  high_limb = *up++;
  retval = (high_limb << tnc);
  low_limb = high_limb >> cnt;

  while (--n != 0)
    {
      high_limb = *up++;
      *rp++ = low_limb | (high_limb << tnc);
      low_limb = high_limb >> cnt;
    }
  *rp = low_limb;

  return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdx, %rdx
jle 0x19a7
testl %ecx, %ecx
je 0x19c6
cmpl $0x40, %ecx
jae 0x19e5
movl %ecx, %r9d
pushq $0x40
popq %r8
subl %ecx, %r8d
movq (%rsi), %rax
decq %rdx
xorl %r10d, %r10d
movq %rax, %r11
movl %r9d, %ecx
shrq %cl, %r11
cmpq %r10, %rdx
je 0x1998
movq 0x8(%rsi,%r10,8), %rbx
movq %rbx, %r14
movl %r8d, %ecx
shlq %cl, %r14
orq %r11, %r14
movq %r14, (%rdi,%r10,8)
incq %r10
movq %rbx, %r11
jmp 0x1970
movl %r8d, %ecx
shlq %cl, %rax
movq %r11, (%rdi,%r10,8)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x78e8(%rip), %rdi      # 0x9296
leaq 0x76af(%rip), %rsi      # 0x9064
leaq 0x793f(%rip), %rcx      # 0x92fb
movl $0x284, %edx            # imm = 0x284
callq 0x1090
leaq 0x7911(%rip), %rdi      # 0x92de
leaq 0x7690(%rip), %rsi      # 0x9064
leaq 0x7920(%rip), %rcx      # 0x92fb
movl $0x285, %edx            # imm = 0x285
callq 0x1090
leaq 0x78fb(%rip), %rdi      # 0x92e7
leaq 0x7671(%rip), %rsi      # 0x9064
leaq 0x7901(%rip), %rcx      # 0x92fb
movl $0x286, %edx            # imm = 0x286
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_common_scan
static mp_bitcnt_t
mpn_common_scan (mp_limb_t limb, mp_size_t i, mp_srcptr up, mp_size_t un,
		 mp_limb_t ux)
{
  unsigned cnt;

  assert (ux == 0 || ux == GMP_LIMB_MAX);
  assert (0 <= i && i <= un );

  while (limb == 0)
    {
      i++;
      if (i == un)
	return (ux == 0 ? ~(mp_bitcnt_t) 0 : un * GMP_LIMB_BITS);
      limb = ux ^ up[i];
    }
  gmp_ctz (cnt, limb);
  return (mp_bitcnt_t) i * GMP_LIMB_BITS + cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1(%r8), %rax
cmpq $0x2, %rax
jae 0x1aa1
cmpq %rcx, %rsi
jg 0x1ac0
movq %rsi, %r9
shlq $0x6, %r9
negq %r9
incq %rsi
testq %rdi, %rdi
jne 0x1a60
cmpq %rsi, %rcx
je 0x1a8f
movq (%rdx,%rsi,8), %rdi
xorq %r8, %rdi
addq $-0x40, %r9
jmp 0x1a46
movq %rdi, %rax
negq %rax
andq %rdi, %rax
pushq $0x3f
popq %rcx
movq %rax, %rdx
shrq $0x38, %rdx
jne 0x1a83
shlq $0x8, %rax
addl $-0x8, %ecx
jmp 0x1a6c
addq %rax, %rax
decl %ecx
testq %rax, %rax
jns 0x1a7e
movl %ecx, %eax
subq %r9, %rax
jmp 0x1a9f
shlq $0x6, %rcx
xorl %eax, %eax
cmpq $0x1, %r8
sbbq %rax, %rax
orq %rcx, %rax
popq %rbp
retq
leaq 0x84e6(%rip), %rdi      # 0x9f8e
leaq 0x75b5(%rip), %rsi      # 0x9064
leaq 0x84f6(%rip), %rcx      # 0x9fac
movl $0x29e, %edx            # imm = 0x29E
callq 0x1090
leaq 0x8538(%rip), %rdi      # 0x9fff
leaq 0x7596(%rip), %rsi      # 0x9064
leaq 0x84d7(%rip), %rcx      # 0x9fac
movl $0x29f, %edx            # imm = 0x29F
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_get_str
size_t
mpn_get_str (unsigned char *sp, int base, mp_ptr up, mp_size_t un)
{
  unsigned bits;

  assert (un > 0);
  assert (up[un-1] > 0);

  bits = mpn_base_power_of_two_p (base);
  if (bits)
    return mpn_get_str_bits (sp, bits, up, un);
  else
    {
      struct mpn_base_info info;

      mpn_get_base_info (&info, base);
      return mpn_get_str_other (sp, base, &info, up, un);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rcx, %rcx
jle 0x1d1e
movq %rcx, %rbx
movq %rdx, %r14
cmpq $0x0, -0x8(%rdx,%rcx,8)
je 0x1d3d
movl %esi, %r12d
movq %rdi, %r15
movl %esi, %edi
callq 0x1d5c
testl %eax, %eax
je 0x1cec
movq %r15, %rdi
movl %eax, %esi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1dca
movslq %r12d, %rsi
leaq -0x38(%rbp), %r13
movq %r13, %rdi
callq 0x1e6c
movq %r15, %rdi
movl %r12d, %esi
movq %r13, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x1e93
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x765e(%rip), %rdi      # 0x9383
leaq 0x7338(%rip), %rsi      # 0x9064
leaq 0x7657(%rip), %rcx      # 0x938a
movl $0x4e9, %edx            # imm = 0x4E9
callq 0x1090
leaq 0x7682(%rip), %rdi      # 0x93c6
leaq 0x7319(%rip), %rsi      # 0x9064
leaq 0x7638(%rip), %rcx      # 0x938a
movl $0x4ea, %edx            # imm = 0x4EA
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_base_power_of_two_p
static unsigned
mpn_base_power_of_two_p (unsigned b)
{
  switch (b)
    {
    case 2: return 1;
    case 4: return 2;
    case 8: return 3;
    case 16: return 4;
    case 32: return 5;
    case 64: return 6;
    case 128: return 7;
    case 256: return 8;
    default: return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x2, %edi
je 0x1dc3
cmpl $0x100, %edi            # imm = 0x100
je 0x1daa
cmpl $0x8, %edi
je 0x1dbc
cmpl $0x10, %edi
je 0x1db5
cmpl $0x20, %edi
je 0x1d95
cmpl $0x40, %edi
je 0x1da3
cmpl $0x80, %edi
je 0x1d9c
cmpl $0x4, %edi
jne 0x1db1
movl $0x2, %eax
jmp 0x1dc8
movl $0x5, %eax
jmp 0x1dc8
movl $0x7, %eax
jmp 0x1dc8
movl $0x6, %eax
jmp 0x1dc8
movl $0x8, %eax
jmp 0x1dc8
xorl %eax, %eax
jmp 0x1dc8
movl $0x4, %eax
jmp 0x1dc8
movl $0x3, %eax
jmp 0x1dc8
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_get_str_bits
static size_t
mpn_get_str_bits (unsigned char *sp, unsigned bits, mp_srcptr up, mp_size_t un)
{
  unsigned char mask;
  size_t sn, j;
  mp_size_t i;
  int shift;

  sn = ((un - 1) * GMP_LIMB_BITS + mpn_limb_size_in_base_2 (up[un-1])
	+ bits - 1) / bits;

  mask = (1U << bits) - 1;

  for (i = 0, j = sn, shift = 0; j-- > 0;)
    {
      unsigned char digit = up[i] >> shift;

      shift += bits;

      if (shift >= GMP_LIMB_BITS && ++i < un)
	{
	  shift -= GMP_LIMB_BITS;
	  digit |= up[i] << (bits - shift);
	}
      sp[j] = digit & mask;
    }
  return sn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
leaq -0x1(%rcx), %r13
shlq $0x6, %r13
movq -0x8(%rdx,%rcx,8), %rdi
callq 0x6ab4
movl %r15d, %ecx
addq %rcx, %r13
addq %r13, %rax
decq %rax
xorl %r8d, %r8d
xorl %edx, %edx
divq %rcx
pushq $-0x1
popq %rsi
movl %r15d, %ecx
shll %cl, %esi
notl %esi
movq %rax, %rdi
xorl %edx, %edx
subq $0x1, %rdi
jb 0x1e5d
movq (%r14,%r8,8), %r9
movl %edx, %ecx
shrq %cl, %r9
addl %r15d, %edx
cmpl $0x40, %edx
jb 0x1e4e
leaq 0x1(%r8), %r10
cmpq %rbx, %r10
jge 0x1e51
addl $-0x40, %edx
movq 0x8(%r14,%r8,8), %r8
movl %r15d, %ecx
subl %edx, %ecx
shlq %cl, %r8
orq %r8, %r9
jmp 0x1e51
movq %r8, %r10
andl %esi, %r9d
movb %r9b, (%r12,%rdi)
movq %r10, %r8
jmp 0x1e19
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_get_base_info
static void
mpn_get_base_info (struct mpn_base_info *info, mp_limb_t b)
{
  mp_limb_t m;
  mp_limb_t p;
  unsigned exp;

  m = GMP_LIMB_MAX / b;
  for (exp = 1, p = b; p <= m; exp++)
    p *= b;

  info->exp = exp;
  info->bb = p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, %r8d
movq %rsi, %rcx
movq %rsi, %rax
mulq %rcx
jo 0x1e8a
imulq %rsi, %rcx
incl %r8d
jmp 0x1e79
movl %r8d, (%rdi)
movq %rcx, 0x8(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_get_str_other
static size_t
mpn_get_str_other (unsigned char *sp,
		   int base, const struct mpn_base_info *info,
		   mp_ptr up, mp_size_t un)
{
  struct gmp_div_inverse binv;
  size_t sn;
  size_t i;

  mpn_div_qr_1_invert (&binv, base);

  sn = 0;

  if (un > 1)
    {
      struct gmp_div_inverse bbinv;
      mpn_div_qr_1_invert (&bbinv, info->bb);

      do
	{
	  mp_limb_t w;
	  size_t done;
	  w = mpn_div_qr_1_preinv (up, up, un, &bbinv);
	  un -= (up[un-1] == 0);
	  done = mpn_limb_get_str (sp + sn, w, &binv);

	  for (sn += done; done < info->exp; done++)
	    sp[sn++] = 0;
	}
      while (un > 1);
    }
  sn += mpn_limb_get_str (sp + sn, up[0], &binv);

  /* Reverse order */
  for (i = 0; 2*i + 1 < sn; i++)
    {
      unsigned char t = sp[i];
      sp[i] = sp[sn - i - 1];
      sp[sn - i - 1] = t;
    }

  return sn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r15
movq %rcx, -0x30(%rbp)
movq %rdx, %r12
movq %rdi, %rbx
movslq %esi, %rsi
leaq -0x50(%rbp), %rdi
callq 0x6b03
cmpq $0x2, %r15
jl 0x1f2d
movq 0x8(%r12), %rsi
leaq -0x70(%rbp), %rdi
callq 0x6b03
xorl %r13d, %r13d
movq -0x30(%rbp), %r14
movq %r14, %rdi
movq %r14, %rsi
movq %r15, %rdx
leaq -0x70(%rbp), %rcx
callq 0x6b6f
cmpq $0x1, -0x8(%r14,%r15,8)
movl $0x0, %r14d
sbbq %r14, %r14
leaq (%rbx,%r13), %rdi
movq %rax, %rsi
leaq -0x50(%rbp), %rdx
callq 0x81ae
addq %rax, %r13
movl (%r12), %ecx
cmpq %rcx, %rax
jae 0x1f22
movb $0x0, (%rbx,%r13)
incq %r13
incq %rax
jmp 0x1f0c
addq %r14, %r15
cmpq $0x1, %r15
jg 0x1ed4
jmp 0x1f30
xorl %r13d, %r13d
leaq (%rbx,%r13), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
leaq -0x50(%rbp), %rdx
callq 0x81ae
addq %r13, %rax
leaq (%rbx,%rax), %rcx
decq %rcx
pushq $0x1
popq %rdx
cmpq %rax, %rdx
jae 0x1f6e
movb (%rbx), %sil
movb (%rcx), %dil
movb %dil, (%rbx)
movb %sil, (%rcx)
decq %rcx
addq $0x2, %rdx
incq %rbx
jmp 0x1f51
addq $0x48, %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_set_str
mp_size_t
mpn_set_str (mp_ptr rp, const unsigned char *sp, size_t sn, int base)
{
  unsigned bits;

  if (sn == 0)
    return 0;

  bits = mpn_base_power_of_two_p (base);
  if (bits)
    return mpn_set_str_bits (rp, sp, sn, bits);
  else
    {
      struct mpn_base_info info;

      mpn_get_base_info (&info, base);
      return mpn_set_str_other (rp, sp, sn, base, &info);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdx, %rdx
je 0x1fc5
movl %ecx, %r12d
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl %ecx, %edi
callq 0x1d5c
testl %eax, %eax
je 0x1fc9
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %eax, %ecx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1ffe
xorl %eax, %eax
jmp 0x1fef
movslq %r12d, %r12
leaq -0x38(%rbp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x1e6c
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
movq %r13, %r8
callq 0x206d
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: mpn_set_str_bits
static mp_size_t
mpn_set_str_bits (mp_ptr rp, const unsigned char *sp, size_t sn,
		  unsigned bits)
{
  mp_size_t rn;
  size_t j;
  unsigned shift;

  for (j = sn, rn = 0, shift = 0; j-- > 0; )
    {
      if (shift == 0)
	{
	  rp[rn++] = sp[j];
	  shift += bits;
	}
      else
	{
	  rp[rn-1] |= (mp_limb_t) sp[j] << shift;
	  shift += bits;
	  if (shift >= GMP_LIMB_BITS)
	    {
	      shift -= GMP_LIMB_BITS;
	      if (shift > 0)
		rp[rn++] = (mp_limb_t) sp[j] >> (bits - shift);
	    }
	}
    }
  rn = mpn_normalized_size (rp, rn);
  return rn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %ecx, %eax
movq %rsi, %r8
xorl %esi, %esi
xorl %r9d, %r9d
decq %rdx
cmpq $-0x1, %rdx
je 0x2067
movzbl (%r8,%rdx), %r10d
testl %r9d, %r9d
je 0x2048
movl %r9d, %ecx
shlq %cl, %r10
orq %r10, -0x8(%rdi,%rsi,8)
addl %eax, %r9d
cmpl $0x3f, %r9d
jbe 0x203d
xorl %ecx, %ecx
addl $-0x40, %r9d
je 0x2040
jmp 0x2051
movl %r9d, %ecx
decq %rdx
movl %ecx, %r9d
jmp 0x200f
movq %r10, (%rdi,%rsi,8)
movl %eax, %r9d
jmp 0x2062
movzbl (%r8,%rdx), %r10d
movl %eax, %ecx
subl %r9d, %ecx
shrq %cl, %r10
movq %r10, (%rdi,%rsi,8)
incq %rsi
jmp 0x200c
popq %rbp
jmp 0x1369
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_set_str_other
static mp_size_t
mpn_set_str_other (mp_ptr rp, const unsigned char *sp, size_t sn,
		   mp_limb_t b, const struct mpn_base_info *info)
{
  mp_size_t rn;
  mp_limb_t w;
  unsigned k;
  size_t j;

  k = 1 + (sn - 1) % info->exp;

  j = 0;
  w = sp[j++];
  while (--k != 0)
    w = w * b + sp[j++];

  rp[0] = w;

  for (rn = (w > 0); j < sn;)
    {
      mp_limb_t cy;

      w = sp[j++];
      for (k = 1; k < info->exp; k++)
	w = w * b + sp[j++];

      cy = mpn_mul_1 (rp, rp, rn, info->bb);
      cy += mpn_add_1 (rp, rp, rn, w);
      if (cy > 0)
	rp[rn++] = cy;
    }
  assert (j == sn);

  return rn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, -0x38(%rbp)
movq %rdx, -0x48(%rbp)
leaq -0x1(%rdx), %rax
movl (%r8), %ecx
xorl %edx, %edx
divq %rcx
incl %edx
movzbl (%rsi), %eax
pushq $0x1
popq %r13
decl %edx
je 0x20b6
imulq %r14, %rax
movzbl (%r12,%r13), %ecx
incq %r13
addq %rcx, %rax
jmp 0x20a1
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
movq %rcx, -0x30(%rbp)
movq %r8, -0x40(%rbp)
movq -0x38(%rbp), %r15
cmpq -0x48(%rbp), %r13
jae 0x2144
movzbl (%r12,%r13), %ebx
movl (%r8), %eax
incq %r13
pushq $0x1
popq %rcx
cmpl %eax, %ecx
jae 0x20fc
imulq %r14, %rbx
movzbl (%r12,%r13), %edx
addq %rdx, %rbx
incl %ecx
incq %r13
jmp 0x20e5
movq 0x8(%r8), %rcx
movq %r15, %rdi
movq %r15, %rsi
movq -0x30(%rbp), %rdx
callq 0x1589
movq %rax, -0x50(%rbp)
movq %r15, %rdi
movq %r15, %rsi
movq -0x30(%rbp), %rdx
movq %rbx, %rcx
callq 0x13a4
movq -0x40(%rbp), %r8
addq -0x50(%rbp), %rax
je 0x20d1
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rdx
movq %rax, (%rcx,%rdx,8)
incq %rdx
movq %rdx, -0x30(%rbp)
jmp 0x20d1
jne 0x2159
movq -0x30(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7f2f(%rip), %rdi      # 0xa08f
leaq 0x6efd(%rip), %rsi      # 0x9064
leaq 0x7f29(%rip), %rcx      # 0xa097
movl $0x536, %edx            # imm = 0x536
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_init2
void
mpz_init2 (mpz_t r, mp_bitcnt_t bits)
{
  mp_size_t rn;

  bits -= (bits != 0);		/* Round down, except if 0 */
  rn = 1 + bits / GMP_LIMB_BITS;

  r->_mp_alloc = rn;
  r->_mp_size = 0;
  r->_mp_d = gmp_xalloc_limbs (rn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpq $0x1, %rsi
adcq $-0x1, %rsi
movq %rdi, %rbx
shrq $0x6, %rsi
leaq 0x1(%rsi), %rax
movl %eax, (%rdi)
andl $0x0, 0x4(%rdi)
leaq 0x8(,%rsi,8), %rdi
callq *0xcecf(%rip)           # 0xf098
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_set_si
void
mpz_set_si (mpz_t r, signed long int x)
{
  if (x >= 0)
    mpz_set_ui (r, x);
  else /* (x < 0) */
    {
      r->_mp_size = -1;
      r->_mp_d[0] = GMP_NEG_CAST (unsigned long int, x);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rsi, %rsi
js 0x2201
je 0x2211
movq 0x8(%rdi), %rax
movq %rsi, (%rax)
movl $0x1, %eax
jmp 0x2213
orl $-0x1, 0x4(%rdi)
negq %rsi
movq 0x8(%rdi), %rax
movq %rsi, (%rax)
jmp 0x2216
xorl %eax, %eax
movl %eax, 0x4(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_set
void
mpz_set (mpz_t r, const mpz_t x)
{
  /* Allow the NOP r == x */
  if (r != x)
    {
      mp_size_t n;
      mp_ptr rp;

      n = GMP_ABS (x->_mp_size);
      rp = MPZ_REALLOC (r, n);

      mpn_copyi (rp, x->_mp_d, n);
      r->_mp_size = x->_mp_size;
    }
}

// Assembly:
cmpq %rsi, %rdi
je 0x228e
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%rsi), %eax
movl %eax, %r15d
negl %r15d
cmovsl %eax, %r15d
cmpl (%rdi), %r15d
jle 0x226d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x228f
movq %rax, %rdi
jmp 0x2271
movq 0x8(%rbx), %rdi
movq 0x8(%r14), %rsi
movq %r15, %rdx
callq 0x12ed
movl 0x4(%r14), %eax
movl %eax, 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_realloc
static mp_ptr
mpz_realloc (mpz_t r, mp_size_t size)
{
  size = GMP_MAX (size, 1);

  r->_mp_d = gmp_xrealloc_limbs (r->_mp_d, size);
  r->_mp_alloc = size;

  if (GMP_ABS (r->_mp_size) > size)
    r->_mp_size = 0;

  return r->_mp_d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x2, %rsi
pushq $0x1
popq %r14
cmovgeq %rsi, %r14
movq 0x8(%rdi), %rdi
leaq (,%r14,8), %rdx
xorl %esi, %esi
callq *0xcde7(%rip)           # 0xf0a0
movq %rax, 0x8(%rbx)
movl %r14d, (%rbx)
movl 0x4(%rbx), %ecx
movl %ecx, %edx
negl %edx
cmovsl %ecx, %edx
cmpq %rdx, %r14
jae 0x22d3
andl $0x0, 0x4(%rbx)
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: mpz_fits_slong_p
int
mpz_fits_slong_p (const mpz_t u)
{
  mp_size_t us = u->_mp_size;

  if (us == 1)
    return u->_mp_d[0] < GMP_LIMB_HIGHBIT;
  else if (us == -1)
    return u->_mp_d[0] <= GMP_LIMB_HIGHBIT;
  else
    return (us == 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x4(%rdi), %eax
cmpl $-0x1, %eax
je 0x2396
testl %eax, %eax
je 0x2392
cmpl $0x1, %eax
jne 0x23ac
movq 0x8(%rdi), %rax
cmpq $0x0, (%rax)
setns %al
jmp 0x23ae
movb $0x1, %al
jmp 0x23ae
movq 0x8(%rdi), %rax
movabsq $-0x7fffffffffffffff, %rcx # imm = 0x8000000000000001
cmpq %rcx, (%rax)
setb %al
jmp 0x23ae
xorl %eax, %eax
movzbl %al, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_get_si
long int
mpz_get_si (const mpz_t u)
{
  mp_size_t us = u->_mp_size;

  if (us > 0)
    return (long) (u->_mp_d[0] & ~GMP_LIMB_HIGHBIT);
  else if (us < 0)
    return (long) (- u->_mp_d[0] | GMP_LIMB_HIGHBIT);
  else
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x4(%rdi), %eax
testl %eax, %eax
jle 0x23eb
movq 0x8(%rdi), %rcx
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
andq (%rcx), %rax
jmp 0x240a
js 0x23f1
xorl %eax, %eax
jmp 0x240a
movq 0x8(%rdi), %rax
xorl %ecx, %ecx
subq (%rax), %rcx
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
incq %rax
orq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_roinit_n
mpz_srcptr
mpz_roinit_n (mpz_t x, mp_srcptr xp, mp_size_t xs)
{
  x->_mp_alloc = 0;
  x->_mp_d = (mp_ptr) xp;
  mpz_limbs_finish (x, xs);
  return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
andl $0x0, (%rdi)
movq %rsi, 0x8(%rdi)
movq %rdx, %rsi
callq 0x24bd
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_get_d
double
mpz_get_d (const mpz_t u)
{
  mp_size_t un;
  double x;
  double B = 2.0 * (double) GMP_LIMB_HIGHBIT;

  un = GMP_ABS (u->_mp_size);

  if (un == 0)
    return 0.0;

  x = u->_mp_d[--un];
  while (un > 0)
    x = B*x + u->_mp_d[--un];

  if (u->_mp_size < 0)
    x = -x;

  return x;
}

// Assembly:
movl 0x4(%rdi), %eax
testl %eax, %eax
je 0x27a7
pushq %rbp
movq %rsp, %rbp
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
movq 0x8(%rdi), %rdx
movsd -0x8(%rdx,%rcx,8), %xmm1
decq %rcx
unpcklps 0x68fe(%rip), %xmm1     # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x6906(%rip), %xmm1     # 0x9050
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movsd 0x68e2(%rip), %xmm1     # 0x9040
movapd 0x68ea(%rip), %xmm2     # 0x9050
movsd 0x68aa(%rip), %xmm3     # 0x9018
testq %rcx, %rcx
jle 0x2799
movsd -0x8(%rdx,%rcx,8), %xmm4
decq %rcx
unpcklps %xmm1, %xmm4            # xmm4 = xmm4[0],xmm1[0],xmm4[1],xmm1[1]
subpd %xmm2, %xmm4
movapd %xmm4, %xmm5
unpckhpd %xmm4, %xmm5            # xmm5 = xmm5[1],xmm4[1]
addsd %xmm4, %xmm5
mulsd %xmm3, %xmm0
addsd %xmm5, %xmm0
jmp 0x276e
testl %eax, %eax
jns 0x27a5
xorpd 0x688b(%rip), %xmm0     # 0x9030
popq %rbp
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_cmpabs_d
int
mpz_cmpabs_d (const mpz_t x, double d)
{
  mp_size_t xn;
  double B, Bi;
  mp_size_t i;

  xn = x->_mp_size;
  d = GMP_ABS (d);

  if (xn != 0)
    {
      xn = GMP_ABS (xn);

      B = 2.0 * (double) GMP_LIMB_HIGHBIT;
      Bi = 1.0 / B;

      /* Scale d so it can be compared with the top limb. */
      for (i = 1; i < xn; i++)
	d *= Bi;

      if (d >= B)
	return -1;

      /* Compare floor(d) to top limb, subtract and cancel when equal. */
      for (i = xn; i-- > 0;)
	{
	  mp_limb_t f, xl;

	  f = (mp_limb_t) d;
	  xl = x->_mp_d[i];
	  if (xl > f)
	    return 1;
	  else if (xl < f)
	    return -1;
	  d = B * (d - f);
	}
    }
  return - (d > 0.0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x4(%rdi), %eax
movapd 0x6876(%rip), %xmm2     # 0x9030
xorpd %xmm0, %xmm2
movapd %xmm2, %xmm1
cmplesd %xmm0, %xmm1
andpd %xmm1, %xmm0
andnpd %xmm2, %xmm1
orpd %xmm0, %xmm1
testl %eax, %eax
je 0x2889
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
leaq -0x1(%rcx), %rax
movsd 0x6832(%rip), %xmm0     # 0x9020
subq $0x1, %rax
jb 0x27fa
mulsd %xmm0, %xmm1
jmp 0x27ee
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
ucomisd 0x6811(%rip), %xmm1     # 0x9018
jae 0x2898
movq 0x8(%rdi), %rdx
movsd 0x680f(%rip), %xmm0     # 0x9028
movl $0x1, %esi
movq 0x681a(%rip), %xmm2     # 0x9040
movapd 0x6822(%rip), %xmm3     # 0x9050
movsd 0x67e2(%rip), %xmm4     # 0x9018
testq %rcx, %rcx
jle 0x2889
cvttsd2si %xmm1, %r8
movq %r8, %r9
sarq $0x3f, %r9
movapd %xmm1, %xmm5
subsd %xmm0, %xmm5
cvttsd2si %xmm5, %rdi
andq %r9, %rdi
orq %r8, %rdi
cmpq %rdi, -0x8(%rdx,%rcx,8)
ja 0x289a
jb 0x2898
movq %rdi, %xmm5
punpckldq %xmm2, %xmm5    # xmm5 = xmm5[0],xmm2[0],xmm5[1],xmm2[1]
subpd %xmm3, %xmm5
movapd %xmm5, %xmm6
unpckhpd %xmm5, %xmm6            # xmm6 = xmm6[1],xmm5[1]
addsd %xmm5, %xmm6
subsd %xmm6, %xmm1
mulsd %xmm4, %xmm1
decq %rcx
jmp 0x2836
xorpd %xmm0, %xmm0
xorl %eax, %eax
ucomisd %xmm0, %xmm1
seta %al
negl %eax
popq %rbp
retq
movl %esi, %eax
jmp 0x2898
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_cmp_d
int
mpz_cmp_d (const mpz_t x, double d)
{
  if (x->_mp_size < 0)
    {
      if (d >= 0.0)
	return -1;
      else
	return -mpz_cmpabs_d (x, d);
    }
  else
    {
      if (d < 0.0)
	return 1;
      else
	return mpz_cmpabs_d (x, d);
    }
}

// Assembly:
cmpl $0x0, 0x4(%rdi)
js 0x28b6
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x27ab
pushq $0x1
jmp 0x28cf
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jae 0x28cd
pushq %rbp
movq %rsp, %rbp
callq 0x27ab
negl %eax
popq %rbp
retq
pushq $-0x1
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_cmp_si
int
mpz_cmp_si (const mpz_t u, long v)
{
  mp_size_t usize = u->_mp_size;

  if (usize < -1)
    return -1;
  else if (v >= 0)
    return mpz_cmp_ui (u, v);
  else if (usize >= 0)
    return 1;
  else /* usize == -1 */
    {
      mp_limb_t ul = u->_mp_d[0];
      if ((mp_limb_t)GMP_NEG_CAST (unsigned long int, v) < ul)
	return -1;
      else
	return (mp_limb_t)GMP_NEG_CAST (unsigned long int, v) > ul;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x4(%rdi), %eax
cmpl $-0x1, %eax
jge 0x28fb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbp
retq
testq %rsi, %rsi
js 0x2906
popq %rbp
jmp 0x292a
testl %eax, %eax
js 0x2911
movl $0x1, %eax
jmp 0x28f9
movq 0x8(%rdi), %rax
negq %rsi
xorl %ecx, %ecx
cmpq %rsi, (%rax)
setb %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovbel %ecx, %eax
jmp 0x28f9
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_cmp_ui
int
mpz_cmp_ui (const mpz_t u, unsigned long v)
{
  mp_size_t usize = u->_mp_size;

  if (usize > 1)
    return 1;
  else if (usize < 0)
    return -1;
  else
    {
      mp_limb_t ul = (usize > 0) ? u->_mp_d[0] : 0;
      return (ul > v) - (ul < v);
    }
}

// Assembly:
movl 0x4(%rdi), %eax
cmpl $0x1, %eax
jle 0x2938
movl $0x1, %eax
retq
testl %eax, %eax
js 0x294e
pushq %rbp
movq %rsp, %rbp
cmpl $0x1, %eax
jne 0x2954
movq 0x8(%rdi), %rax
movq (%rax), %rcx
jmp 0x2956
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
xorl %ecx, %ecx
xorl %eax, %eax
cmpq %rsi, %rcx
seta %al
sbbl $0x0, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_cmp
int
mpz_cmp (const mpz_t a, const mpz_t b)
{
  mp_size_t asize = a->_mp_size;
  mp_size_t bsize = b->_mp_size;

  if (asize != bsize)
    return (asize < bsize) ? -1 : 1;
  else if (asize >= 0)
    return mpn_cmp (a->_mp_d, b->_mp_d, asize);
  else
    return mpn_cmp (b->_mp_d, a->_mp_d, -asize);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0x4(%rdi), %rdx
movl 0x4(%rsi), %eax
cmpl %eax, %edx
jne 0x2980
testl %edx, %edx
js 0x2990
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rsi
jmp 0x299e
xorl %ecx, %ecx
cmpl %eax, %edx
setge %cl
leal -0x1(,%rcx,2), %eax
popq %rbp
retq
movq 0x8(%rsi), %rax
movq 0x8(%rdi), %rsi
negq %rdx
movq %rax, %rdi
popq %rbp
jmp 0x1328
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_cmpabs_ui
int
mpz_cmpabs_ui (const mpz_t u, unsigned long v)
{
  mp_size_t un = GMP_ABS (u->_mp_size);
  mp_limb_t ul;

  if (un > 1)
    return 1;

  ul = (un == 1) ? u->_mp_d[0] : 0;

  return (ul > v) - (ul < v);
}

// Assembly:
movl 0x4(%rdi), %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cmpl $0x1, %ecx
jbe 0x29b9
movl $0x1, %eax
retq
pushq %rbp
movq %rsp, %rbp
jne 0x29c8
movq 0x8(%rdi), %rax
movq (%rax), %rcx
jmp 0x29ca
xorl %ecx, %ecx
xorl %eax, %eax
cmpq %rsi, %rcx
seta %al
sbbl $0x0, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_abs_add_ui
static mp_size_t
mpz_abs_add_ui (mpz_t r, const mpz_t a, unsigned long b)
{
  mp_size_t an;
  mp_ptr rp;
  mp_limb_t cy;

  an = GMP_ABS (a->_mp_size);
  if (an == 0)
    {
      r->_mp_d[0] = b;
      return b > 0;
    }

  rp = MPZ_REALLOC (r, an + 1);

  cy = mpn_add_1 (rp, a->_mp_d, an, b);
  rp[an] = cy;
  an += cy;

  return an;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl 0x4(%rsi), %eax
movl %eax, %r14d
negl %r14d
cmovsl %eax, %r14d
jae 0x2ae6
movq %rsi, %r15
cmpl (%rdi), %r14d
jge 0x2af7
movq 0x8(%rdi), %r12
jmp 0x2b03
movq 0x8(%rdi), %rax
movq %rbx, (%rax)
xorl %eax, %eax
testq %rbx, %rbx
setne %al
jmp 0x2b1c
leaq 0x1(%r14), %rsi
callq 0x228f
movq %rax, %r12
movq 0x8(%r15), %rsi
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x13a4
movq %rax, (%r12,%r14,8)
addq %r14, %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: mpz_abs_sub_ui
static mp_size_t
mpz_abs_sub_ui (mpz_t r, const mpz_t a, unsigned long b)
{
  mp_size_t an = GMP_ABS (a->_mp_size);
  mp_ptr rp = MPZ_REALLOC (r, an);

  if (an == 0)
    {
      rp[0] = b;
      return -(b > 0);
    }
  else if (an == 1 && a->_mp_d[0] < b)
    {
      rp[0] = b - a->_mp_d[0];
      return -1;
    }
  else
    {
      gmp_assert_nocarry (mpn_sub_1 (rp, a->_mp_d, an, b));
      return mpn_normalized_size (rp, an);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r12
movl 0x4(%rsi), %eax
movl %eax, %r14d
negl %r14d
cmovsl %eax, %r14d
cmpl (%rdi), %r14d
jle 0x2b55
movq %r14, %rsi
callq 0x228f
movq %rax, %r15
jmp 0x2b59
movq 0x8(%rdi), %r15
testq %r14, %r14
je 0x2b79
cmpl $0x1, %r14d
jne 0x2b8d
movq 0x8(%r12), %rsi
movq %rbx, %rax
subq (%rsi), %rax
jbe 0x2b92
movq %rax, (%r15)
pushq $-0x1
popq %rax
jmp 0x2b84
movq %rbx, (%r15)
xorl %eax, %eax
negq %rbx
sbbq %rax, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r12), %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1497
testq %rax, %rax
jne 0x2bb8
movq %r15, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1369
leaq 0x6876(%rip), %rdi      # 0x9435
leaq 0x649e(%rip), %rsi      # 0x9064
leaq 0x7536(%rip), %rcx      # 0xa103
movl $0x746, %edx            # imm = 0x746
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_add
void
mpz_add (mpz_t r, const mpz_t a, const mpz_t b)
{
  mp_size_t rn;

  if ( (a->_mp_size ^ b->_mp_size) >= 0)
    rn = mpz_abs_add (r, a, b);
  else
    rn = mpz_abs_sub (r, a, b);

  r->_mp_size = a->_mp_size >= 0 ? rn : - rn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%rdx), %eax
xorl 0x4(%rsi), %eax
js 0x2c5f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2c7e
jmp 0x2c6a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2d01
movl %eax, %ecx
negl %ecx
cmpl $0x0, 0x4(%r14)
cmovnsl %eax, %ecx
movl %ecx, 0x4(%rbx)
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: 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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl 0x4(%rsi), %ecx
movl %ecx, %eax
negl %eax
cmovsl %ecx, %eax
movl 0x4(%rdx), %ecx
movl %ecx, %ebx
negl %ebx
cmovsl %ecx, %ebx
cmpl %ebx, %eax
jae 0x2caf
movq %rax, %r15
movq %rsi, %r13
jmp 0x2cbb
movq %rbx, %r15
movq %rax, %rbx
movq %r14, %r13
movq %rsi, %r14
movslq (%rdi), %rax
cmpq %rax, %rbx
jge 0x2cc9
movq 0x8(%rdi), %r12
jmp 0x2cd5
leaq 0x1(%rbx), %rsi
callq 0x228f
movq %rax, %r12
movq 0x8(%r14), %rsi
movq 0x8(%r13), %rcx
movq %r12, %rdi
movq %rbx, %rdx
movq %r15, %r8
callq 0x1428
movq %rax, (%r12,%rbx,8)
addq %rbx, %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: mpz_abs_sub
static mp_size_t
mpz_abs_sub (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);
  int cmp;
  mp_ptr rp;

  cmp = mpn_cmp4 (a->_mp_d, an, b->_mp_d, bn);
  if (cmp > 0)
    {
      rp = MPZ_REALLOC (r, an);
      gmp_assert_nocarry (mpn_sub (rp, a->_mp_d, an, b->_mp_d, bn));
      return mpn_normalized_size (rp, an);
    }
  else if (cmp < 0)
    {
      rp = MPZ_REALLOC (r, bn);
      gmp_assert_nocarry (mpn_sub (rp, b->_mp_d, bn, a->_mp_d, an));
      return -mpn_normalized_size (rp, bn);
    }
  else
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r13
movq %rsi, %r15
movl 0x4(%rsi), %eax
movl %eax, %ebx
negl %ebx
cmovsl %eax, %ebx
movq %rdi, %r12
movl 0x4(%rdx), %eax
movl %eax, %r14d
negl %r14d
cmovsl %eax, %r14d
movq 0x8(%rsi), %rdi
movq 0x8(%rdx), %rdx
movq %rdi, -0x38(%rbp)
movq %rbx, %rsi
movq %rdx, -0x30(%rbp)
movq %r14, %rcx
callq 0x2a03
testl %eax, %eax
jle 0x2d6f
cmpl (%r12), %ebx
jle 0x2d78
movq %r12, %rdi
movq %rbx, %rsi
callq 0x228f
movq %rax, %r12
movq 0x8(%r15), %rsi
movq 0x8(%r13), %rcx
jmp 0x2d85
js 0x2db1
xorl %eax, %eax
jmp 0x2dfd
movq 0x8(%r12), %r12
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rcx
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %r8
callq 0x151a
testq %rax, %rax
jne 0x2e0c
movq %r12, %rdi
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1369
cmpl (%r12), %r14d
jle 0x2dcf
movq %r12, %rdi
movq %r14, %rsi
callq 0x228f
movq %rax, %r12
movq 0x8(%r13), %rsi
movq 0x8(%r15), %rcx
jmp 0x2ddc
movq 0x8(%r12), %r12
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rsi
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %r8
callq 0x151a
testq %rax, %rax
jne 0x2e2b
movq %r12, %rdi
movq %r14, %rsi
callq 0x1369
negq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6622(%rip), %rdi      # 0x9435
leaq 0x624a(%rip), %rsi      # 0x9064
leaq 0x7330(%rip), %rcx      # 0xa151
movl $0x788, %edx            # imm = 0x788
callq 0x1090
leaq 0x6603(%rip), %rdi      # 0x9435
leaq 0x622b(%rip), %rsi      # 0x9064
leaq 0x7311(%rip), %rcx      # 0xa151
movl $0x78e, %edx            # imm = 0x78E
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdx, %rdx
js 0x2ea7
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2ec3
negq %rdx
movq %rbx, %rdi
callq 0x2ec3
movq %rbx, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2a4c
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movl 0x4(%rsi), %r13d
testl %r13d, %r13d
sete %cl
testq %rdx, %rdx
sete %dl
xorl %eax, %eax
orb %cl, %dl
jne 0x2f42
movq %rsi, %r12
movl %r13d, %r15d
negl %r15d
cmovsl %r13d, %r15d
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0x2f08
movq 0x8(%rbx), %rax
jmp 0x2f14
leaq 0x1(%r15), %rsi
movq %rbx, %rdi
callq 0x228f
movq 0x8(%r12), %rsi
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1589
movq %rax, (%r12,%r15,8)
cmpq $0x1, %rax
sbbl $-0x1, %r15d
movl %r15d, %eax
negl %eax
testl %r13d, %r13d
cmovnsl %r15d, %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_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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movslq 0x4(%rsi), %rax
testq %rax, %rax
sete %dl
movl 0x4(%r14), %ecx
testl %ecx, %ecx
sete %sil
orb %dl, %sil
cmpb $0x1, %sil
jne 0x2f9b
andl $0x0, 0x4(%rdi)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, -0x38(%rbp)
movslq %ecx, %rcx
movq %rcx, %rdx
xorq %rax, %rdx
movq %rdx, -0x30(%rbp)
movq %rax, %r13
negq %r13
cmovsq %rax, %r13
movq %rcx, %r12
negq %r12
cmovsq %rcx, %r12
leaq (%r12,%r13), %rbx
movq %rbx, %rsi
shlq $0x6, %rsi
leaq -0x50(%rbp), %rdi
callq 0x219c
leaq -0x50(%rbp), %rax
movq 0x8(%rax), %rdi
cmpq %r12, %r13
jae 0x2ff4
movq 0x8(%r14), %rsi
movq 0x8(%r15), %rcx
movq %rdi, %r14
movq %r12, %rdx
movq %r13, %r8
jmp 0x3005
movq 0x8(%r15), %rsi
movq 0x8(%r14), %rcx
movq %rdi, %r14
movq %r13, %rdx
movq %r12, %r8
callq 0x17b6
cmpq $0x1, -0x8(%r14,%rbx,8)
sbbl $0x0, %ebx
movl %ebx, %eax
negl %eax
cmpq $0x0, -0x30(%rbp)
cmovnsl %ebx, %eax
movq -0x38(%rbp), %rcx
movl %eax, 0x4(%rcx)
movl -0x50(%rbp), %eax
movl %eax, (%rcx)
movq 0x8(%rcx), %rdi
movq %r14, 0x8(%rcx)
movq 0xc06e(%rip), %rax      # 0xf0a8
xorl %esi, %esi
addq $0x28, %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: 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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0x4(%rsi), %eax
movl %eax, %ebx
negl %ebx
cmovsl %eax, %ebx
jae 0x30a3
movq %rdx, %r13
movq %rdx, %r12
shrq $0x6, %r12
xorl %r15d, %r15d
andl $0x3f, %r13d
setne %r15b
addq %r12, %r15
addq %rbx, %r15
movslq (%rdi), %rax
cmpq %rax, %r15
movq %rdi, -0x38(%rbp)
jle 0x30a7
movq %rsi, %r14
movq %r15, %rsi
callq 0x228f
movq %r14, %rsi
movq %rax, %r14
jmp 0x30ab
xorl %eax, %eax
jmp 0x30fb
movq 0x8(%rdi), %r14
leaq (%r14,%r12,8), %rdi
movq %rsi, -0x30(%rbp)
movq 0x8(%rsi), %rsi
movq %rbx, %rdx
testl %r13d, %r13d
je 0x30d6
movl %r13d, %ecx
callq 0x187e
movq %rax, -0x8(%r14,%r15,8)
cmpq $0x1, %rax
sbbq $0x0, %r15
jmp 0x30db
callq 0x130e
movq %r14, %rdi
movq %r12, %rsi
callq 0x138e
movl %r15d, %eax
negl %eax
movq -0x30(%rbp), %rcx
cmpl $0x0, 0x4(%rcx)
cmovnsl %r15d, %eax
movq -0x38(%rbp), %rdi
movl %eax, 0x4(%rdi)
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_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
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 *0xbf5e(%rip)           # 0xf098
movq %rax, 0x8(%r12)
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2ec3
movq %r15, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2c3d
movq 0xbf46(%rip), %rax      # 0xf0a8
movq 0x8(%r12), %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_submul_ui
void
mpz_submul_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_sub (r, r, t);
  mpz_clear (t);
}

// 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 *0xbef4(%rip)           # 0xf098
movq %rax, 0x8(%r12)
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2ec3
movq %r15, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2e4a
movq 0xbedc(%rip), %rax      # 0xf0a8
movq 0x8(%r12), %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_addmul
void
mpz_addmul (mpz_t r, const mpz_t u, const mpz_t v)
{
  mpz_t t;
  mpz_init (t);
  mpz_mul (t, u, v);
  mpz_add (r, r, t);
  mpz_clear (t);
}

// 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 *0xbe8a(%rip)           # 0xf098
movq %rax, 0x8(%r12)
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2f54
movq %r15, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2c3d
movq 0xbe72(%rip), %rax      # 0xf0a8
movq 0x8(%r12), %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_submul
void
mpz_submul (mpz_t r, const mpz_t u, const mpz_t v)
{
  mpz_t t;
  mpz_init (t);
  mpz_mul (t, u, v);
  mpz_sub (r, r, t);
  mpz_clear (t);
}

// 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 *0xbe20(%rip)           # 0xf098
movq %rax, 0x8(%r12)
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2f54
movq %r15, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2e4a
movq 0xbe08(%rip), %rax      # 0xf0a8
movq 0x8(%r12), %rdi
xorl %esi, %esi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax