LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jl 0x1f58
jmp 0x1f77
leaq 0xc357(%rip), %rdi      # 0xe2b6
leaq 0xc16e(%rip), %rsi      # 0xe0d4
movl $0x23f, %edx            # imm = 0x23F
leaq 0xc34d(%rip), %rcx      # 0xe2bf
callq 0x1070
cmpq $0x1, -0x28(%rbp)
jl 0x1f80
jmp 0x1f9f
leaq 0xc37e(%rip), %rdi      # 0xe305
leaq 0xc146(%rip), %rsi      # 0xe0d4
movl $0x240, %edx            # imm = 0x240
leaq 0xc325(%rip), %rcx      # 0xe2bf
callq 0x1070
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movq (%rax), %rcx
callq 0x19a0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
cmpq $0x1, %rax
jl 0x2019
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movq (%rax), %rcx
callq 0x1b50
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x1fc6
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x1, -0x18(%rbp)
jl 0x20d0
jmp 0x20ef
leaq 0xc22f(%rip), %rdi      # 0xe306
leaq 0xbff6(%rip), %rsi      # 0xe0d4
movl $0x266, %edx            # imm = 0x266
leaq 0xc223(%rip), %rcx      # 0xe30d
callq 0x1070
cmpl $0x1, -0x1c(%rbp)
jb 0x20f7
jmp 0x2116
leaq 0xc250(%rip), %rdi      # 0xe34e
leaq 0xbfcf(%rip), %rsi      # 0xe0d4
movl $0x267, %edx            # imm = 0x267
leaq 0xc1fc(%rip), %rcx      # 0xe30d
callq 0x1070
movl -0x1c(%rbp), %eax
cmpq $0x40, %rax
jae 0x2121
jmp 0x2140
leaq 0xc22f(%rip), %rdi      # 0xe357
leaq 0xbfa5(%rip), %rsi      # 0xe0d4
movl $0x268, %edx            # imm = 0x268
leaq 0xc1d2(%rip), %rcx      # 0xe30d
callq 0x1070
movq -0x18(%rbp), %rax
shlq $0x3, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
shlq $0x3, %rax
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
movl $0x40, %eax
subq %rcx, %rax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x8, %rcx
movq %rcx, -0x10(%rbp)
movq -0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl -0x34(%rbp), %ecx
shrq %cl, %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
shlq %cl, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x2208
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x8, %rcx
movq %rcx, -0x10(%rbp)
movq -0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movl -0x34(%rbp), %ecx
shrq %cl, %rax
movq -0x48(%rbp), %rcx
orq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, -0x8(%rbp)
movq %rcx, -0x8(%rax)
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
shlq %cl, %rax
movq %rax, -0x28(%rbp)
jmp 0x21a3
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, -0x8(%rbp)
movq %rcx, -0x8(%rax)
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x1, -0x18(%rbp)
jl 0x2250
jmp 0x226f
leaq 0xc0af(%rip), %rdi      # 0xe306
leaq 0xbe76(%rip), %rsi      # 0xe0d4
movl $0x284, %edx            # imm = 0x284
leaq 0xc101(%rip), %rcx      # 0xe36b
callq 0x1070
cmpl $0x1, -0x1c(%rbp)
jb 0x2277
jmp 0x2296
leaq 0xc0d0(%rip), %rdi      # 0xe34e
leaq 0xbe4f(%rip), %rsi      # 0xe0d4
movl $0x285, %edx            # imm = 0x285
leaq 0xc0da(%rip), %rcx      # 0xe36b
callq 0x1070
movl -0x1c(%rbp), %eax
cmpq $0x40, %rax
jae 0x22a1
jmp 0x22c0
leaq 0xc0af(%rip), %rdi      # 0xe357
leaq 0xbe25(%rip), %rsi      # 0xe0d4
movl $0x286, %edx            # imm = 0x286
leaq 0xc0b0(%rip), %rcx      # 0xe36b
callq 0x1070
movl -0x1c(%rbp), %eax
movl %eax, %ecx
movl $0x40, %eax
subq %rcx, %rax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl -0x34(%rbp), %ecx
shlq %cl, %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
shrq %cl, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x2365
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movl -0x34(%rbp), %ecx
shlq %cl, %rax
movq -0x48(%rbp), %rcx
orq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x8(%rbp)
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
shrq %cl, %rax
movq %rax, -0x30(%rbp)
jmp 0x2302
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_scan1
mp_bitcnt_t
mpn_scan1 (mp_srcptr ptr, mp_bitcnt_t bit)
{
  mp_size_t i;
  i = bit / GMP_LIMB_BITS;

  return mpn_common_scan ( ptr[i] & (GMP_LIMB_MAX << (bit % GMP_LIMB_BITS)),
			  i, ptr, i, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rcx
andq $0x3f, %rcx
movq $-0x1, %rax
shlq %cl, %rax
andq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x23e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x60, %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)
je 0x240a
cmpq $-0x1, -0x30(%rbp)
jne 0x240c
jmp 0x242b
leaq 0xcfc3(%rip), %rdi      # 0xf3d6
leaq 0xbcba(%rip), %rsi      # 0xe0d4
movl $0x29e, %edx            # imm = 0x29E
leaq 0xcfce(%rip), %rcx      # 0xf3f4
callq 0x1070
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jg 0x243f
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jg 0x243f
jmp 0x245e
leaq 0xd001(%rip), %rdi      # 0xf447
leaq 0xbc87(%rip), %rsi      # 0xe0d4
movl $0x29f, %edx            # imm = 0x29F
leaq 0xcf9b(%rip), %rcx      # 0xf3f4
callq 0x1070
jmp 0x2460
cmpq $0x0, -0x10(%rbp)
jne 0x24c0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x24aa
cmpq $0x0, -0x30(%rbp)
jne 0x2491
movq $-0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x249d
movq -0x28(%rbp), %rax
shlq $0x6, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2568
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rdx
xorq (%rcx,%rdx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0x2460
jmp 0x24c2
movq -0x10(%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 0x2514
movq -0x50(%rbp), %rax
shlq $0x8, %rax
movq %rax, -0x50(%rbp)
movl -0x54(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x54(%rbp)
jmp 0x24e9
jmp 0x2516
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq -0x50(%rbp), %rax
cmpq $0x0, %rax
jne 0x2540
movq -0x50(%rbp), %rax
shlq %rax
movq %rax, -0x50(%rbp)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x2516
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 -0x18(%rbp), %rax
shlq $0x6, %rax
movl -0x34(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_scan0
mp_bitcnt_t
mpn_scan0 (mp_srcptr ptr, mp_bitcnt_t bit)
{
  mp_size_t i;
  i = bit / GMP_LIMB_BITS;

  return mpn_common_scan (~ptr[i] & (GMP_LIMB_MAX << (bit % GMP_LIMB_BITS)),
			  i, ptr, i, GMP_LIMB_MAX);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
xorq $-0x1, %rdi
movq -0x10(%rbp), %rcx
andq $0x3f, %rcx
movq $-0x1, %rax
shlq %cl, %rax
andq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq $-0x1, %r8
callq 0x23e0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jle 0x2990
jmp 0x29af
leaq 0xba5c(%rip), %rdi      # 0xe3f3
leaq 0xb736(%rip), %rsi      # 0xe0d4
movl $0x4e9, %edx            # imm = 0x4E9
leaq 0xba50(%rip), %rcx      # 0xe3fa
callq 0x1070
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
cmpq $0x0, (%rax,%rcx,8)
jbe 0x29c4
jmp 0x29e3
leaq 0xba6b(%rip), %rdi      # 0xe436
leaq 0xb702(%rip), %rsi      # 0xe0d4
movl $0x4ea, %edx            # imm = 0x4EA
leaq 0xba1c(%rip), %rcx      # 0xe3fa
callq 0x1070
movl -0x14(%rbp), %edi
callq 0x2a50
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x2a0e
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x2b10
movq %rax, -0x8(%rbp)
jmp 0x2a37
movslq -0x14(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x2c40
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq -0x40(%rbp), %rdx
callq 0x2cb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x2, %eax
je 0x2aae
jmp 0x2a64
movl -0xc(%rbp), %eax
subl $0x4, %eax
je 0x2ab7
jmp 0x2a6e
movl -0xc(%rbp), %eax
subl $0x8, %eax
je 0x2ac0
jmp 0x2a78
movl -0xc(%rbp), %eax
subl $0x10, %eax
je 0x2ac9
jmp 0x2a82
movl -0xc(%rbp), %eax
subl $0x20, %eax
je 0x2ad2
jmp 0x2a8c
movl -0xc(%rbp), %eax
subl $0x40, %eax
je 0x2adb
jmp 0x2a96
movl -0xc(%rbp), %eax
subl $0x80, %eax
je 0x2ae4
jmp 0x2aa2
movl -0xc(%rbp), %eax
subl $0x100, %eax            # imm = 0x100
je 0x2aed
jmp 0x2af6
movl $0x1, -0x4(%rbp)
jmp 0x2afd
movl $0x2, -0x4(%rbp)
jmp 0x2afd
movl $0x3, -0x4(%rbp)
jmp 0x2afd
movl $0x4, -0x4(%rbp)
jmp 0x2afd
movl $0x5, -0x4(%rbp)
jmp 0x2afd
movl $0x6, -0x4(%rbp)
jmp 0x2afd
movl $0x7, -0x4(%rbp)
jmp 0x2afd
movl $0x8, -0x4(%rbp)
jmp 0x2afd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
subq $0x1, %rax
shlq $0x6, %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdi
callq 0xa1e0
movq %rax, %rcx
movq -0x50(%rbp), %rax
addq %rcx, %rax
movl -0xc(%rbp), %ecx
addq %rcx, %rax
subq $0x1, %rax
movl -0xc(%rbp), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
movb %al, -0x21(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x44(%rbp)
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x38(%rbp)
cmpq $0x0, %rax
jbe 0x2c31
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x44(%rbp), %ecx
shrq %cl, %rax
movb %al, -0x45(%rbp)
movl -0xc(%rbp), %eax
addl -0x44(%rbp), %eax
movl %eax, -0x44(%rbp)
movslq -0x44(%rbp), %rax
cmpq $0x40, %rax
jb 0x2c15
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
cmpq -0x20(%rbp), %rax
jge 0x2c15
movslq -0x44(%rbp), %rax
subq $0x40, %rax
movl %eax, -0x44(%rbp)
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0xc(%rbp), %ecx
subl -0x44(%rbp), %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, %rcx
movzbl -0x45(%rbp), %eax
orq %rcx, %rax
movb %al, -0x45(%rbp)
movzbl -0x45(%rbp), %eax
movzbl -0x21(%rbp), %ecx
andl %ecx, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x2b93
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $-0x1, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq %rax, -0x18(%rbp)
movl $0x1, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0x2c90
movq -0x10(%rbp), %rax
imulq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2c6e
movl -0x24(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movslq -0xc(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0xa2a0
movq $0x0, -0x50(%rbp)
cmpq $0x1, -0x28(%rbp)
jle 0x2db6
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x78(%rbp), %rdi
callq 0xa2a0
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x78(%rbp), %rcx
callq 0xa390
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
cmpq $0x0, (%rax,%rcx,8)
sete %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
addq -0x50(%rbp), %rdi
movq -0x80(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0xc240
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
addq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x88(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
cmpq %rcx, %rax
jae 0x2da7
movq -0x8(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x50(%rbp)
movb $0x0, (%rax,%rcx)
movq -0x88(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x88(%rbp)
jmp 0x2d6a
jmp 0x2da9
cmpq $0x1, -0x28(%rbp)
jg 0x2cff
jmp 0x2db6
movq -0x8(%rbp), %rdi
addq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
leaq -0x48(%rbp), %rdx
callq 0xc240
addq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x58(%rbp), %rax
shlq %rax
addq $0x1, %rax
cmpq -0x50(%rbp), %rax
jae 0x2e45
movq -0x8(%rbp), %rax
movq -0x58(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x89(%rbp)
movq -0x8(%rbp), %rax
movq -0x50(%rbp), %rcx
subq -0x58(%rbp), %rcx
subq $0x1, %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq -0x58(%rbp), %rcx
movb %dl, (%rax,%rcx)
movb -0x89(%rbp), %dl
movq -0x8(%rbp), %rax
movq -0x50(%rbp), %rcx
subq -0x58(%rbp), %rcx
subq $0x1, %rcx
movb %dl, (%rax,%rcx)
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x2dde
movq -0x50(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2e88
movq $0x0, -0x8(%rbp)
jmp 0x2edd
movl -0x24(%rbp), %edi
callq 0x2a50
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x2eb3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x28(%rbp), %ecx
callq 0x2ef0
movq %rax, -0x8(%rbp)
jmp 0x2edd
movslq -0x24(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x2c40
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movslq -0x24(%rbp), %rcx
leaq -0x38(%rbp), %r8
callq 0x3020
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x30(%rbp)
cmpq $0x0, %rax
jbe 0x2ff7
cmpl $0x0, -0x34(%rbp)
jne 0x2f70
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %edx
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x28(%rbp)
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x2ff2
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %edx
movl -0x34(%rbp), %eax
movl %eax, %ecx
shlq %cl, %rdx
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpq $0x40, %rax
jb 0x2ff0
movl -0x34(%rbp), %eax
subq $0x40, %rax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jbe 0x2fee
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %edx
movl -0x1c(%rbp), %eax
subl -0x34(%rbp), %eax
movl %eax, %eax
movl %eax, %ecx
shrq %cl, %rdx
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x28(%rbp)
movq %rdx, (%rax,%rcx,8)
jmp 0x2ff0
jmp 0x2ff2
jmp 0x2f1e
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x14d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq -0x28(%rbp), %rcx
movl (%rcx), %ecx
xorl %edx, %edx
divq %rcx
addq $0x1, %rdx
movl %edx, %eax
movl %eax, -0x3c(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x48(%rbp)
movzbl (%rax,%rcx), %eax
movq %rax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
je 0x30b2
movq -0x38(%rbp), %rax
imulq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x48(%rbp), %rdx
movq %rdx, %rsi
addq $0x1, %rsi
movq %rsi, -0x48(%rbp)
movzbl (%rcx,%rdx), %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x307b
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x38(%rbp)
seta %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x319e
movq -0x10(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x48(%rbp)
movzbl (%rax,%rcx), %eax
movq %rax, -0x38(%rbp)
movl $0x1, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x313d
movq -0x38(%rbp), %rax
imulq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x48(%rbp), %rdx
movq %rdx, %rsi
addq $0x1, %rsi
movq %rsi, -0x48(%rbp)
movzbl (%rcx,%rdx), %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x3100
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
callq 0x19a0
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x1560
addq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jbe 0x3199
movq -0x50(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x30(%rbp)
movq %rdx, (%rax,%rcx,8)
jmp 0x30d0
movq -0x48(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x31aa
jmp 0x31c9
leaq 0xc326(%rip), %rdi      # 0xf4d7
leaq 0xaf1c(%rip), %rsi      # 0xe0d4
movl $0x536, %edx            # imm = 0x536
leaq 0xc31b(%rip), %rcx      # 0xf4df
callq 0x1070
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
movq -0x10(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0x6, %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x18(%rbp), %rdi
callq 0x3220
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0x3316
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3350
jmp 0x333d
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
addq $0x1, %rax
subq $0x1, %rax
xorl %ecx, %ecx
subq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_set_ui
void
mpz_set_ui (mpz_t r, unsigned long int x)
{
  if (x > 0)
    {
      r->_mp_size = 1;
      r->_mp_d[0] = x;
    }
  else
    r->_mp_size = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jbe 0x337f
movq -0x8(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
jmp 0x338a
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x3433
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jl 0x33c4
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x33d0
movq -0x10(%rbp), %rcx
xorl %eax, %eax
subl 0x4(%rcx), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cltq
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
cmpq %rcx, %rax
jle 0x33fc
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3440
movq %rax, -0x30(%rbp)
jmp 0x3408
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x1390
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x1, -0x10(%rbp)
jle 0x3461
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x346c
movl $0x1, %eax
movq %rax, -0x18(%rbp)
jmp 0x346c
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xc510
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jl 0x34b2
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x34be
movq -0x8(%rbp), %rcx
xorl %eax, %eax
subl 0x4(%rcx), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cltq
cmpq -0x10(%rbp), %rax
jle 0x34d4
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x1, -0x18(%rbp)
jne 0x35bd
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
cmpq %rcx, (%rax)
setb %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x35f6
cmpq $-0x1, -0x18(%rbp)
jne 0x35e6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
cmpq %rcx, (%rax)
setbe %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x35f6
cmpq $0x0, -0x18(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jle 0x3676
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
andq (%rcx), %rax
movq %rax, -0x8(%rbp)
jmp 0x36a5
cmpq $0x0, -0x18(%rbp)
jge 0x369d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
xorl %eax, %eax
subq (%rcx), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
orq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x36a5
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_getlimbn
mp_limb_t
mpz_getlimbn (const mpz_t u, mp_size_t n)
{
  if (n >= 0 && n < GMP_ABS (u->_mp_size))
    return u->_mp_d[n];
  else
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0x3782
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jl 0x3751
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x375d
movq -0x10(%rbp), %rcx
xorl %eax, %eax
subl 0x4(%rcx), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x3782
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x378a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x38a0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movsd 0xa388(%rip), %xmm0     # 0xe018
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jl 0x3cab
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x3cb7
movq -0x10(%rbp), %rcx
xorl %eax, %eax
subl 0x4(%rcx), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cltq
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3cd4
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x3daa
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
decq %rdx
movq %rdx, -0x18(%rbp)
movq -0x8(%rax,%rcx,8), %xmm0
movaps 0xa339(%rip), %xmm1     # 0xe030
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xa33d(%rip), %xmm1     # 0xe040
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jle 0x3d75
movsd -0x28(%rbp), %xmm0
movsd -0x20(%rbp), %xmm2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
decq %rdx
movq %rdx, -0x18(%rbp)
movq -0x8(%rax,%rcx,8), %xmm1
movaps 0xa2e5(%rip), %xmm3     # 0xe030
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
movapd 0xa2e9(%rip), %xmm3     # 0xe040
subpd %xmm3, %xmm1
movaps %xmm1, %xmm3
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x3d17
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jge 0x3da0
movsd -0x20(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jge 0x3ffb
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x3fe2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x401f
movq -0x10(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
callq 0x3dc0
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x401f
xorps %xmm0, %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0x400e
movl $0x1, -0x4(%rbp)
jmp 0x401f
movq -0x10(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
callq 0x3dc0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
jge 0x409c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4114
cmpq $0x0, -0x18(%rbp)
jl 0x40b5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4120
movl %eax, -0x4(%rbp)
jmp 0x4114
cmpq $0x0, -0x20(%rbp)
jl 0x40c5
movl $0x1, -0x4(%rbp)
jmp 0x4114
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
subq $0x1, %rcx
xorl %eax, %eax
subq %rcx, %rax
cmpq -0x28(%rbp), %rax
jae 0x40f4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4114
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
subq $0x1, %rcx
xorl %eax, %eax
subq %rcx, %rax
cmpq -0x28(%rbp), %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x1, -0x20(%rbp)
jle 0x4148
movl $0x1, -0x4(%rbp)
jmp 0x41a6
cmpq $0x0, -0x20(%rbp)
jge 0x4158
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x41a6
cmpq $0x0, -0x20(%rbp)
jle 0x4170
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x4178
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x4178
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movq -0x28(%rbp), %rcx
cmpq -0x18(%rbp), %rcx
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x41ff
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rsi
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rsi, %rdx
cmovll %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x4244
cmpq $0x0, -0x20(%rbp)
jl 0x4224
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x1420
movl %eax, -0x4(%rbp)
jmp 0x4244
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
subq -0x20(%rbp), %rdx
callq 0x1420
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jl 0x4272
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x427e
movq -0x10(%rbp), %rcx
xorl %eax, %eax
subl 0x4(%rcx), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cltq
movq %rax, -0x20(%rbp)
cmpq $0x1, -0x20(%rbp)
jle 0x4297
movl $0x1, -0x4(%rbp)
jmp 0x42e5
cmpq $0x1, -0x20(%rbp)
jne 0x42af
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x42b7
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x42b7
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movq -0x28(%rbp), %rcx
cmpq -0x18(%rbp), %rcx
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jl 0x45aa
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x3c(%rbp)
jmp 0x45b6
movq -0x18(%rbp), %rcx
xorl %eax, %eax
subl 0x4(%rcx), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cltq
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x45ed
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x20(%rbp)
seta %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x8(%rbp)
jmp 0x466d
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
cmpq %rcx, %rax
jle 0x4618
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x1, %rsi
callq 0x3440
movq %rax, -0x48(%rbp)
jmp 0x4624
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x1560
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x38(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jl 0x46aa
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x3c(%rbp)
jmp 0x46b6
movq -0x18(%rbp), %rcx
xorl %eax, %eax
subl 0x4(%rcx), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cltq
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
cmpq %rcx, %rax
jle 0x46e2
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3440
movq %rax, -0x48(%rbp)
jmp 0x46ee
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4724
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x20(%rbp)
seta %al
andb $0x1, %al
movzbl %al, %ecx
xorl %eax, %eax
subl %ecx, %eax
cltq
movq %rax, -0x8(%rbp)
jmp 0x47b6
cmpq $0x1, -0x28(%rbp)
jne 0x475c
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
jae 0x475c
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
subq (%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq $-0x1, -0x8(%rbp)
jmp 0x47b6
jmp 0x475e
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x1780
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x4784
jmp 0x47a3
leaq 0x9d1a(%rip), %rdi      # 0xe4a5
leaq 0x9942(%rip), %rsi      # 0xe0d4
movl $0x746, %edx            # imm = 0x746
leaq 0xadda(%rip), %rcx      # 0xf578
callq 0x1070
jmp 0x47a5
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x14d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
xorl 0x4(%rcx), %eax
cmpl $0x0, %eax
jl 0x48de
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4930
movq %rax, -0x20(%rbp)
jmp 0x48f3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4a60
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jl 0x4907
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x4911
xorl %eax, %eax
subq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)