LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7a94
cmpq $0x2, %r15
jl 0x216b
movq 0x8(%r12), %rsi
leaq -0x70(%rbp), %rdi
callq 0x7a94
xorl %r14d, %r14d
movq -0x30(%rbp), %r13
movq %r13, %rdi
movq %r13, %rsi
movq %r15, %rdx
leaq -0x70(%rbp), %rcx
callq 0x7b11
cmpq $0x1, -0x8(%r13,%r15,8)
sbbq $0x0, %r15
leaq (%rbx,%r14), %r13
movq %r13, %rdi
movq %rax, %rsi
leaq -0x50(%rbp), %rdx
callq 0x9557
movl (%r12), %ecx
cmpq %rcx, %rax
jae 0x2160
movb $0x0, (%r13,%rax)
incq %rax
jmp 0x214c
addq %rax, %r14
cmpq $0x1, %r15
jg 0x2119
jmp 0x216e
xorl %r14d, %r14d
leaq (%rbx,%r14), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
leaq -0x50(%rbp), %rdx
callq 0x9557
movq %rax, %rcx
addq %r14, %rax
cmpq $0x2, %rax
jb 0x21bd
addq %r14, %rcx
addq $-0x2, %rcx
shrq %rcx
notq %rcx
leaq (%rbx,%rax), %rdx
decq %rdx
xorl %esi, %esi
movb (%rbx), %dil
movb (%rdx,%rsi), %r8b
movb %r8b, (%rbx)
movb %dil, (%rdx,%rsi)
decq %rsi
incq %rbx
cmpq %rsi, %rcx
jne 0x21a4
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x10, %rsp
testq %rdx, %rdx
je 0x2210
movl %ecx, %r12d
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl %ecx, %edi
callq 0x1fb0
testl %eax, %eax
je 0x2214
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %eax, %ecx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2258
xorl %eax, %eax
jmp 0x224b
movslq %r12d, %rcx
movl $0x1, %esi
movq %rcx, %rdi
testl %r12d, %r12d
js 0x2232
imulq %rcx, %rdi
incl %esi
movq %rcx, %rax
mulq %rdi
jno 0x2224
leaq -0x30(%rbp), %r8
movl %esi, (%r8)
movq %rdi, 0x8(%r8)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x22dc
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
xorl %r9d, %r9d
testq %rdx, %rdx
je 0x22bc
movl %ecx, %r8d
xorl %eax, %eax
movzbl -0x1(%rsi,%rdx), %r10d
testl %r9d, %r9d
je 0x22a6
movl %r9d, %ecx
shlq %cl, %r10
orq %r10, -0x8(%rdi,%rax,8)
addl %r8d, %r9d
cmpl $0x40, %r9d
jb 0x22b5
addl $-0x40, %r9d
je 0x22b2
movzbl -0x1(%rsi,%rdx), %r10d
movl %r8d, %ecx
subl %r9d, %ecx
shrq %cl, %r10
movq %r10, (%rdi,%rax,8)
incq %rax
jmp 0x22b5
movq %r10, (%rdi,%rax,8)
incq %rax
movl %r8d, %r9d
jmp 0x22b5
xorl %r9d, %r9d
decq %rdx
jne 0x2269
jmp 0x22be
xorl %eax, %eax
testq %rax, %rax
jle 0x22da
cmpq $0x0, -0x8(%rdi,%rax,8)
jne 0x22da
leaq -0x1(%rax), %rcx
cmpq $0x1, %rax
movq %rcx, %rax
jg 0x22c3
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rdi, %rbx
movq %rdx, -0x30(%rbp)
leaq -0x1(%rdx), %rax
movl (%r8), %ecx
xorl %edx, %edx
divq %rcx
movzbl (%rsi), %eax
movl $0x1, %r13d
testq %rdx, %rdx
je 0x2324
imulq %r15, %rax
movzbl (%rsi,%r13), %ecx
incq %r13
addq %rcx, %rax
decl %edx
jne 0x2311
movq %rax, (%rbx)
xorl %r12d, %r12d
testq %rax, %rax
setne %r12b
cmpq -0x30(%rbp), %r13
jae 0x23c1
movq %rsi, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movzbl (%rsi,%r13), %r14d
movl (%r8), %eax
cmpq $0x2, %rax
jb 0x237c
leal -0x2(%rax), %ecx
leaq (%rsi,%r13), %r10
movl $0x1, %esi
movq %r14, %r9
imulq %r15, %r9
movzbl (%r10,%rsi), %r14d
addq %r9, %r14
incq %rsi
cmpl %esi, %eax
jne 0x235d
addq %rcx, %r13
addq $0x2, %r13
jmp 0x237f
incq %r13
movq 0x8(%r8), %rcx
movq %rbx, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1754
movq %rax, -0x48(%rbp)
movq %rbx, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x155d
addq -0x48(%rbp), %rax
je 0x23b3
movq %rax, (%rbx,%r12,8)
incq %r12
movq -0x38(%rbp), %rsi
cmpq -0x30(%rbp), %r13
movq -0x40(%rbp), %r8
jb 0x2343
cmpq -0x30(%rbp), %r13
jne 0x23d9
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8caf(%rip), %rdi      # 0xb08f
leaq 0x7c7d(%rip), %rsi      # 0xa064
leaq 0x8ca9(%rip), %rcx      # 0xb097
movl $0x536, %edx            # imm = 0x536
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
cmpq $0x1, %rsi
adcq $-0x1, %rsi
shrq $0x6, %rsi
leaq 0x1(%rsi), %rax
movl %eax, (%rdi)
movl $0x0, 0x4(%rdi)
leaq 0x8(,%rsi,8), %rdi
callq *0xdc52(%rip)           # 0x100a0
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2481
je 0x2494
movl $0x1, 0x4(%rdi)
jmp 0x248b
movl $0xffffffff, 0x4(%rdi)  # imm = 0xFFFFFFFF
negq %rsi
movq 0x8(%rdi), %rax
movq %rsi, (%rax)
jmp 0x249b
movl $0x0, 0x4(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
testq %rsi, %rsi
je 0x24b6
pushq %rbp
movq %rsp, %rbp
movl $0x1, 0x4(%rdi)
movq 0x8(%rdi), %rax
movq %rsi, (%rax)
popq %rbp
retq
movl $0x0, 0x4(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2563
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%rsi), %r12d
movl %r12d, %r15d
negl %r15d
cmovsl %r12d, %r15d
cmpl (%rdi), %r15d
jle 0x252f
cmpq $0x2, %r15
movl $0x1, %r13d
cmovgeq %r15, %r13
movq 0x8(%rbx), %rdi
leaq (,%r13,8), %rdx
xorl %esi, %esi
callq *0xdb98(%rip)           # 0x100a8
movq %rax, 0x8(%rbx)
movl %r13d, (%rbx)
movl 0x4(%rbx), %ecx
movl %ecx, %edx
negl %edx
cmovsl %ecx, %edx
cmpq %rdx, %r13
jae 0x2533
movl $0x0, 0x4(%rbx)
jmp 0x2533
movq 0x8(%rbx), %rax
testl %r12d, %r12d
je 0x254e
movq 0x8(%r14), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movq %rsi, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r15
jne 0x253e
movl 0x4(%r14), %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_O1/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 0x264f
testl %eax, %eax
je 0x264b
cmpl $0x1, %eax
jne 0x2665
movq 0x8(%rdi), %rax
cmpq $0x0, (%rax)
setns %al
jmp 0x2667
movb $0x1, %al
jmp 0x2667
movq 0x8(%rdi), %rax
movabsq $-0x7fffffffffffffff, %rcx # imm = 0x8000000000000001
cmpq %rcx, (%rax)
setb %al
jmp 0x2667
xorl %eax, %eax
movzbl %al, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x26a4
movq 0x8(%rdi), %rcx
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
andq (%rcx), %rax
jmp 0x26c3
js 0x26aa
xorl %eax, %eax
jmp 0x26c3
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_O1/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
movq %rdi, %rax
movl $0x0, (%rdi)
movq %rsi, 0x8(%rdi)
movq %rdx, %rcx
negq %rcx
cmovsq %rdx, %rcx
jae 0x2864
cmpq $0x0, -0x8(%rsi,%rcx,8)
jne 0x2864
leaq -0x1(%rcx), %rdi
cmpq $0x1, %rcx
movq %rdi, %rcx
jg 0x284d
xorl %ecx, %ecx
movl %ecx, %esi
negl %esi
testq %rdx, %rdx
cmovnsl %ecx, %esi
movl %esi, 0x4(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2b47
pushq %rbp
movq %rsp, %rbp
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
movq 0x8(%rdi), %rdx
movsd -0x8(%rdx,%rcx,8), %xmm1
unpcklps 0x7562(%rip), %xmm1     # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x756a(%rip), %xmm1     # 0xa050
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
cmpl $0x2, %ecx
jb 0x2b39
movsd 0x7541(%rip), %xmm1     # 0xa040
movapd 0x7549(%rip), %xmm2     # 0xa050
movsd 0x7509(%rip), %xmm3     # 0xa018
movsd -0x10(%rdx,%rcx,8), %xmm4
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
decq %rcx
cmpq $0x1, %rcx
jg 0x2b0f
testl %eax, %eax
jns 0x2b45
xorpd 0x74eb(%rip), %xmm0     # 0xa030
popq %rbp
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x74d6(%rip), %xmm2     # 0xa030
xorpd %xmm0, %xmm2
movapd %xmm2, %xmm1
cmplesd %xmm0, %xmm1
andpd %xmm1, %xmm0
andnpd %xmm2, %xmm1
orpd %xmm0, %xmm1
testl %eax, %eax
je 0x2c41
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cmpl $0x2, %ecx
jb 0x2b9c
leaq -0x1(%rcx), %rax
movsd 0x748d(%rip), %xmm0     # 0xa020
mulsd %xmm0, %xmm1
decq %rax
jne 0x2b93
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
ucomisd 0x746f(%rip), %xmm1     # 0xa018
jae 0x2c50
movq 0x8(%rdi), %rdx
movsd 0x746d(%rip), %xmm0     # 0xa028
movq 0x747d(%rip), %xmm2     # 0xa040
movapd 0x7485(%rip), %xmm3     # 0xa050
movsd 0x7445(%rip), %xmm4     # 0xa018
testq %rcx, %rcx
jle 0x2c41
cvttsd2si %xmm1, %rdi
movq %rdi, %r8
sarq $0x3f, %r8
movapd %xmm1, %xmm5
subsd %xmm0, %xmm5
cvttsd2si %xmm5, %rsi
andq %r8, %rsi
orq %rdi, %rsi
movq -0x8(%rdx,%rcx,8), %rdi
cmpq %rsi, %rdi
jbe 0x2c08
movl $0x1, %eax
jmp 0x2c0f
jae 0x2c13
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %esi, %esi
jmp 0x2c37
movq %rsi, %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
movb $0x1, %sil
decq %rcx
testb %sil, %sil
jne 0x2bd3
jmp 0x2c50
xorpd %xmm0, %xmm0
xorl %eax, %eax
ucomisd %xmm0, %xmm1
seta %al
negl %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c6c
movl $0x1, %eax
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x2b4b
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jae 0x2c6b
pushq %rbp
movq %rsp, %rbp
callq 0x2b4b
negl %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $-0x1, %ecx
jl 0x2d00
movl $0x1, %eax
testq %rsi, %rsi
js 0x2cd6
cmpl $0x1, %ecx
jg 0x2d00
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
js 0x2d00
cmpl $0x1, %ecx
jne 0x2cf3
movq 0x8(%rdi), %rax
movq (%rax), %rcx
jmp 0x2cf5
testl %ecx, %ecx
jns 0x2d00
movq 0x8(%rdi), %rax
negq %rsi
xorl %ecx, %ecx
cmpq %rsi, (%rax)
setb %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovbel %ecx, %eax
jmp 0x2d00
xorl %ecx, %ecx
xorl %eax, %eax
cmpq %rsi, %rcx
seta %al
sbbl $0x0, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %ecx
movl $0x1, %eax
cmpl $0x1, %ecx
jg 0x2d2a
testl %ecx, %ecx
js 0x2d25
pushq %rbp
movq %rsp, %rbp
cmpl $0x1, %ecx
jne 0x2d2b
movq 0x8(%rdi), %rax
movq (%rax), %rcx
jmp 0x2d2d
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_O1/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:
movslq 0x4(%rdi), %rax
movl 0x4(%rsi), %ecx
cmpl %ecx, %eax
jne 0x2d6e
pushq %rbp
movq %rsp, %rbp
testl %eax, %eax
js 0x2d7d
movq 0x8(%rdi), %rcx
movq 0x8(%rsi), %rdx
testq %rax, %rax
jle 0x2dac
movq -0x8(%rcx,%rax,8), %rsi
movq -0x8(%rdx,%rax,8), %rdi
decq %rax
cmpq %rdi, %rsi
je 0x2d55
jmp 0x2d9f
xorl %edx, %edx
cmpl %ecx, %eax
setge %dl
leal -0x1(,%rdx,2), %eax
retq
movq 0x8(%rsi), %rcx
movq 0x8(%rdi), %rdx
negq %rax
testq %rax, %rax
jle 0x2dac
movq -0x8(%rcx,%rax,8), %rsi
movq -0x8(%rdx,%rax,8), %rdi
decq %rax
cmpq %rdi, %rsi
je 0x2d88
xorl %eax, %eax
cmpq %rsi, %rdi
adcl $-0x1, %eax
orl $0x1, %eax
jmp 0x2dae
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x1, %eax
cmpl $0x1, %ecx
ja 0x2de1
pushq %rbp
movq %rsp, %rbp
jne 0x2dd3
movq 0x8(%rdi), %rax
movq (%rax), %rcx
jmp 0x2dd5
xorl %ecx, %ecx
xorl %eax, %eax
cmpq %rsi, %rcx
seta %al
sbbl $0x0, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r12
movl 0x4(%rsi), %eax
movl %eax, %r14d
negl %r14d
cmovsl %eax, %r14d
jae 0x2efe
movq %rsi, %r15
cmpl (%r12), %r14d
jge 0x2f10
movq 0x8(%r12), %r13
jmp 0x2f57
movq 0x8(%r12), %rax
movq %rbx, (%rax)
xorl %eax, %eax
testq %rbx, %rbx
setne %al
jmp 0x2f71
leaq 0x1(%r14), %rax
movq %rax, -0x30(%rbp)
movq 0x8(%r12), %rdi
leaq 0x8(,%r14,8), %rdx
xorl %esi, %esi
callq *0xd17b(%rip)           # 0x100a8
movq %rax, %r13
movq %rax, 0x8(%r12)
movq -0x30(%rbp), %rdx
movl %edx, (%r12)
movl 0x4(%r12), %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cmpq %rcx, %rdx
jae 0x2f57
movl $0x0, 0x4(%r12)
movq 0x8(%r15), %rsi
movq %r13, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x155d
movq %rax, (%r13,%r14,8)
addq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r8
movq %rdi, %r13
movl 0x4(%rsi), %r14d
movl %r14d, %ebx
negl %ebx
cmovsl %r14d, %ebx
cmpl (%rdi), %ebx
jle 0x2fff
movq %rsi, -0x30(%rbp)
movq %r8, -0x38(%rbp)
cmpq $0x2, %rbx
movl $0x1, %r12d
cmovgeq %rbx, %r12
movq 0x8(%r13), %rdi
leaq (,%r12,8), %rdx
xorl %esi, %esi
callq *0xd0d6(%rip)           # 0x100a8
movq %rax, %r15
movq %rax, 0x8(%r13)
movl %r12d, (%r13)
movl 0x4(%r13), %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cmpq %rcx, %r12
jae 0x2ff5
movl $0x0, 0x4(%r13)
movq -0x38(%rbp), %r8
movq -0x30(%rbp), %rsi
jmp 0x3003
movq 0x8(%r13), %r15
cmpq $0x1, %rbx
je 0x301a
testl %ebx, %ebx
jne 0x3032
movq %r8, (%r15)
xorl %ebx, %ebx
negq %r8
sbbq %rbx, %rbx
jmp 0x3065
movq 0x8(%rsi), %rcx
movq %r8, %rax
subq (%rcx), %rax
jbe 0x3032
movq %rax, (%r15)
movq $-0x1, %rbx
jmp 0x3065
movq 0x8(%rsi), %rsi
movq %r15, %rdi
movq %rbx, %rdx
movq %r8, %rcx
callq 0x1662
testq %rax, %rax
jne 0x3077
testl %r14d, %r14d
je 0x3065
cmpq $0x0, -0x8(%r15,%rbx,8)
jne 0x3065
leaq -0x1(%rbx), %rax
cmpq $0x1, %rbx
movq %rax, %rbx
jg 0x304e
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x73b7(%rip), %rdi      # 0xa435
leaq 0x6fdf(%rip), %rsi      # 0xa064
leaq 0x8077(%rip), %rcx      # 0xb103
movl $0x746, %edx            # imm = 0x746
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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 0x311e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x313d
jmp 0x3129
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3202
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_O1/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
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %r15
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 0x3174
movq %rax, %r8
movq %rsi, %rcx
jmp 0x3180
movq %rbx, %r8
movq %rax, %rbx
movq %r14, %rcx
movq %rsi, %r14
movslq (%r15), %rax
cmpq %rax, %rbx
jge 0x318e
movq 0x8(%r15), %r13
jmp 0x31d8
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
leaq 0x1(%rbx), %r12
movq 0x8(%r15), %rdi
leaq 0x8(,%rbx,8), %rdx
xorl %esi, %esi
callq *0xcefa(%rip)           # 0x100a8
movq %rax, %r13
movq %rax, 0x8(%r15)
movl %r12d, (%r15)
movl 0x4(%r15), %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cmpq %rcx, %r12
jae 0x31d0
movl $0x0, 0x4(%r15)
movq -0x38(%rbp), %r8
movq -0x30(%rbp), %rcx
movq 0x8(%r14), %rsi
movq 0x8(%rcx), %rcx
movq %r13, %rdi
movq %rbx, %rdx
callq 0x15e0
movq %rax, (%r13,%rbx,8)
addq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x346f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3484
negq %rdx
movq %rbx, %rdi
callq 0x3484
negl 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movq %rdx, %r8
movq %rdi, %rbx
movl 0x4(%rsi), %r14d
testl %r14d, %r14d
sete %cl
testq %rdx, %rdx
sete %dl
xorl %eax, %eax
orb %cl, %dl
jne 0x3543
movq %rsi, %r12
movl %r14d, %r15d
negl %r15d
cmovsl %r14d, %r15d
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0x34d0
movq 0x8(%rbx), %r13
jmp 0x3517
movq %r8, -0x30(%rbp)
leaq 0x1(%r15), %rax
movq %rax, -0x38(%rbp)
movq 0x8(%rbx), %rdi
leaq 0x8(,%r15,8), %rdx
xorl %esi, %esi
callq *0xcbb8(%rip)           # 0x100a8
movq %rax, %r13
movq %rax, 0x8(%rbx)
movq -0x38(%rbp), %rdx
movl %edx, (%rbx)
movl 0x4(%rbx), %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cmpq %rcx, %rdx
jae 0x3513
movl $0x0, 0x4(%rbx)
movq -0x30(%rbp), %r8
movq 0x8(%r12), %rsi
movq %r13, %rdi
movq %r15, %rdx
movq %r8, %rcx
callq 0x1754
movq %rax, (%r13,%r15,8)
cmpq $0x1, %rax
sbbl $-0x1, %r15d
movl %r15d, %eax
negl %eax
testl %r14d, %r14d
cmovnsl %r15d, %eax
movl %eax, 0x4(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x18, %rsp
movq %rsi, %r15
movslq 0x4(%rsi), %rax
testq %rax, %rax
sete %r8b
movl 0x4(%rdx), %ecx
testl %ecx, %ecx
sete %sil
orb %r8b, %sil
cmpb $0x1, %sil
jne 0x359c
movl $0x0, 0x4(%rdi)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, -0x30(%rbp)
movq %rdi, -0x40(%rbp)
movslq %ecx, %rcx
movq %rcx, %rdx
xorq %rax, %rdx
movq %rdx, -0x38(%rbp)
movq %rax, %r12
negq %r12
cmovsq %rax, %r12
movq %rcx, %rbx
negq %rbx
cmovsq %rcx, %rbx
movq %rbx, %r13
addq %r12, %r13
movabsq $0x3ffffffffffffff, %rax # imm = 0x3FFFFFFFFFFFFFF
movq %rax, %r14
cmoveq %r13, %r14
addq %r13, %r14
andq %rax, %r14
leaq 0x8(,%r14,8), %rdi
incq %r14
callq *0xcaad(%rip)           # 0x100a0
movq %rax, %rdi
cmpq %rbx, %r12
jae 0x3612
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rsi
movq 0x8(%r15), %rcx
movq %rdi, %r15
movq %rbx, %rdx
movq %r12, %r8
jmp 0x3627
movq 0x8(%r15), %rsi
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rdi, %r15
movq %r12, %rdx
movq %rbx, %r8
callq 0x1981
cmpq $0x1, -0x8(%r15,%r13,8)
sbbl $0x0, %r13d
movl %r13d, %eax
negl %eax
cmpq $0x0, -0x38(%rbp)
cmovnsl %r13d, %eax
movq -0x40(%rbp), %rcx
movl %eax, 0x4(%rcx)
movl %r14d, (%rcx)
movq 0x8(%rcx), %rdi
movq %r15, 0x8(%rcx)
movq 0xca53(%rip), %rax      # 0x100b0
xorl %esi, %esi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movq %rdi, -0x38(%rbp)
movl 0x4(%rsi), %r8d
movl %r8d, %ebx
negl %ebx
movl %r8d, %r15d
cmovnsl %ebx, %r15d
jae 0x3733
movq %rsi, %r12
movq %rdx, %r9
shrq $0x6, %r9
xorl %r13d, %r13d
movq %rdx, -0x50(%rbp)
movl %edx, %ecx
andl $0x3f, %ecx
setne %r13b
addq %r9, %r13
addq %r15, %r13
movq -0x38(%rbp), %rax
movslq (%rax), %rax
cmpq %rax, %r13
jle 0x3737
movl %ecx, -0x2c(%rbp)
movl %r8d, -0x30(%rbp)
movq %r9, -0x40(%rbp)
movq %r12, -0x48(%rbp)
cmpq $0x2, %r13
movq -0x38(%rbp), %r12
movl $0x1, %r14d
cmovgeq %r13, %r14
movq 0x8(%r12), %rdi
leaq (,%r14,8), %rdx
xorl %esi, %esi
callq *0xc9ac(%rip)           # 0x100a8
movq %rax, %rdx
movq %rax, 0x8(%r12)
movl %r14d, (%r12)
movl 0x4(%r12), %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cmpq %rcx, %r14
jae 0x3722
movl $0x0, 0x4(%r12)
movq -0x48(%rbp), %r12
movq -0x40(%rbp), %r9
movl -0x30(%rbp), %r8d
movl -0x2c(%rbp), %ecx
jmp 0x373f
xorl %eax, %eax
jmp 0x37b6
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdx
leaq (%rdx,%r9,8), %rdi
movq 0x8(%r12), %rsi
testl %ecx, %ecx
je 0x376f
movq %rdx, %r14
movq %r15, %rdx
movq %r9, %rbx
callq 0x1a6f
movq %r14, %rdx
movq %rbx, %r9
movq %rax, -0x8(%r14,%r13,8)
cmpq $0x1, %rax
sbbq $0x0, %r13
jmp 0x378c
cmpl %ebx, %r8d
cmovgl %r8d, %ebx
incq %rbx
movq -0x10(%rsi,%rbx,8), %rax
movq %rax, -0x10(%rdi,%rbx,8)
decq %rbx
cmpq $0x1, %rbx
jg 0x3779
movq -0x50(%rbp), %rax
cmpq $0x40, %rax
jb 0x37a7
shlq $0x3, %r9
movq %rdx, %rdi
xorl %esi, %esi
movq %r9, %rdx
callq 0x10a0
movl %r13d, %eax
negl %eax
cmpl $0x0, 0x4(%r12)
cmovnsl %r13d, %eax
movq -0x38(%rbp), %rcx
movl %eax, 0x4(%rcx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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)
movl $0x8, %edi
callq *0xc8a5(%rip)           # 0x100a0
movq %rax, 0x8(%r12)
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3484
movq %r15, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x30fc
movq 0xc88d(%rip), %rax      # 0x100b0
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_O1/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)
movl $0x8, %edi
callq *0xc839(%rip)           # 0x100a0
movq %rax, 0x8(%r12)
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3484
movq %r15, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3412
movq 0xc821(%rip), %rax      # 0x100b0
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_O1/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)
movl $0x8, %edi
callq *0xc7cd(%rip)           # 0x100a0
movq %rax, 0x8(%r12)
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3555
movq %r15, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x30fc
movq 0xc7b5(%rip), %rax      # 0x100b0
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_O1/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)
movl $0x8, %edi
callq *0xc761(%rip)           # 0x100a0
movq %rax, 0x8(%r12)
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3555
movq %r15, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3412
movq 0xc749(%rip), %rax      # 0x100b0
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_O1/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_congruent_p
int
mpz_congruent_p (const mpz_t a, const mpz_t b, const mpz_t m)
{
  mpz_t t;
  int res;

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

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

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x4(%rdx), %eax
movl %eax, %ecx
sarl $0x1f, %ecx
xorl %edx, %edx
testl %eax, %eax
setne %dl
orl %ecx, %edx
je 0x43eb
leaq -0x30(%rbp), %r12
movq $0x1, (%r12)
movl $0x8, %edi
callq *0xbcf1(%rip)           # 0x100a0
movq %rax, 0x8(%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3412
xorl %edi, %edi
xorl %esi, %esi
movq %r12, %rdx
movq %rbx, %rcx
movl $0x2, %r8d
callq 0x3989
movl %eax, %ebx
xorl $0x1, %ebx
movq 0x8(%r12), %rdi
xorl %esi, %esi
callq *0xbcc7(%rip)           # 0x100b0
jmp 0x43fd
movq %r15, %rdi
movq %r14, %rsi
callq 0x2d3a
xorl %ebx, %ebx
testl %eax, %eax
sete %bl
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_gcd_ui
unsigned long
mpz_gcd_ui (mpz_t g, const mpz_t u, unsigned long v)
{
  mp_size_t un;

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

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

  return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x47da
movq %rdx, %rbx
movl 0x4(%rsi), %eax
testl %eax, %eax
je 0x47bf
movl %eax, %edx
negl %edx
cmovsl %eax, %edx
movq 0x8(%rsi), %rsi
xorl %edi, %edi
movq %rbx, %rcx
callq 0x48f5
movq %rax, %rdi
movq %rbx, %rsi
callq 0x480a
movq %rax, %rbx
testq %r14, %r14
je 0x4802
testq %rbx, %rbx
je 0x47fa
movl $0x1, 0x4(%r14)
movq 0x8(%r14), %rax
movq %rbx, (%rax)
jmp 0x4802
testq %r14, %r14
je 0x47f6
movq %r14, %rdi
callq 0x24be
movl 0x4(%r14), %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
movl %ecx, 0x4(%r14)
xorl %ebx, %ebx
jmp 0x4802
movl $0x0, 0x4(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_gcd_11
static mp_limb_t
mpn_gcd_11 (mp_limb_t u, mp_limb_t v)
{
  unsigned shift;

  assert ( (u | v) > 0);

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

  gmp_ctz (shift, u | v);

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

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

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

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

// Assembly:
movq %rsi, %rax
orq %rdi, %rax
je 0x48d2
testq %rdi, %rdi
je 0x48ce
testq %rsi, %rsi
je 0x484f
movq %rax, %rdx
negq %rdx
andq %rax, %rdx
xorl %eax, %eax
movq %rdx, %rcx
shrq $0x38, %rcx
jne 0x4854
xorl %eax, %eax
movq %rdx, %rcx
shlq $0x8, %rcx
addl $0x8, %eax
shrq $0x30, %rdx
movq %rcx, %rdx
je 0x483d
jmp 0x485e
movq %rdi, %rsi
jmp 0x48ce
movq %rdx, %rcx
jmp 0x485e
addq %rcx, %rcx
incl %eax
testq %rcx, %rcx
jns 0x4859
movl $0x3f, %ecx
subl %eax, %ecx
movq %rdi, %rdx
shrq %cl, %rdx
shrq %cl, %rsi
btq %rcx, %rdi
movq %rsi, %rdi
cmovaeq %rdx, %rdi
movq %rdi, %rax
shrq %rdi
testb $0x1, %al
je 0x487e
testb $0x1, %dl
cmovneq %rdx, %rsi
cmpq %rax, %rsi
jne 0x4899
movq %rsi, %rdx
jmp 0x48c8
movq %rsi, %rdx
subq %rax, %rdx
jbe 0x48b2
movq %rdx, %rsi
shrq %rdx
testb $0x2, %sil
je 0x48a1
movq %rdx, %rsi
jmp 0x48c3
subq %rsi, %rax
movq %rax, %rdx
shrq %rax
testb $0x2, %dl
je 0x48b5
movq %rsi, %rdx
cmpq %rax, %rdx
jne 0x4899
shlq %cl, %rdx
movq %rdx, %rsi
movq %rsi, %rax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x6a33(%rip), %rdi      # 0xb310
leaq 0x5780(%rip), %rsi      # 0xa064
leaq 0x6a31(%rip), %rcx      # 0xb31c
movl $0xa5e, %edx            # imm = 0xA5E
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_div_qr_1
static mp_limb_t
mpn_div_qr_1 (mp_ptr qp, mp_srcptr np, mp_size_t nn, mp_limb_t d)
{
  assert (d > 0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
testq %rcx, %rcx
je 0x49d2
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq -0x1(%rcx), %rbx
testq %rbx, %rcx
jne 0x494e
andq (%r15), %rbx
testq %r12, %r12
je 0x49c2
cmpq $0x1, %rcx
jne 0x4973
testq %r14, %r14
jle 0x49c2
xorl %eax, %eax
movq (%r15,%rax,8), %rcx
movq %rcx, (%r12,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0x493c
jmp 0x49c2
leaq -0x40(%rbp), %rbx
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x7a94
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x7b11
movq %rax, %rbx
jmp 0x49c2
movq %rcx, %rdx
negq %rdx
andq %rcx, %rdx
xorl %eax, %eax
movq %rdx, %rcx
shrq $0x38, %rcx
jne 0x499e
xorl %eax, %eax
movq %rdx, %rcx
shlq $0x8, %rcx
addl $0x8, %eax
shrq $0x30, %rdx
movq %rcx, %rdx
je 0x498c
jmp 0x49a8
movq %rdx, %rcx
jmp 0x49a8
addq %rcx, %rcx
incl %eax
testq %rcx, %rcx
jns 0x49a3
movl $0x3f, %ecx
subl %eax, %ecx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1b49
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x696e(%rip), %rdi      # 0xb347
leaq 0x5684(%rip), %rsi      # 0xa064
leaq 0x6966(%rip), %rcx      # 0xb34d
movl $0x37f, %edx            # imm = 0x37F
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_make_odd
static mp_bitcnt_t
mpz_make_odd (mpz_t r)
{
  mp_bitcnt_t shift;

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

  return shift;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl $0x0, 0x4(%rdi)
jle 0x4c7f
movq %rdi, %rbx
movq 0x8(%rdi), %rdx
movq (%rdx), %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x1c4a
movq %rax, %r14
movq %rbx, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movl $0x2, %ecx
callq 0x3ea2
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6707(%rip), %rdi      # 0xb38d
leaq 0x53d7(%rip), %rsi      # 0xa064
leaq 0x6709(%rip), %rcx      # 0xb39d
movl $0xaa0, %edx            # imm = 0xAA0
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_setbit
void
mpz_setbit (mpz_t d, mp_bitcnt_t bit_index)
{
  if (!mpz_tstbit (d, bit_index))
    {
      if (d->_mp_size >= 0)
	mpz_abs_add_bit (d, bit_index);
      else
	mpz_abs_sub_bit (d, bit_index);
    }
}

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

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

  mpz_init (g);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x4(%rsi)
je 0x5433
movq %rdx, %r14
cmpl $0x0, 0x4(%rdx)
je 0x5433
movq %rsi, %r15
leaq -0x30(%rbp), %r12
movq $0x1, (%r12)
movl $0x8, %edi
callq *0xacb8(%rip)           # 0x100a0
movq %rax, 0x8(%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x49f1
movq %r12, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4313
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x3555
movq 0x8(%r12), %rdi
xorl %esi, %esi
callq *0xac8c(%rip)           # 0x100b0
movl 0x4(%rbx), %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
movl %ecx, 0x4(%rbx)
jmp 0x543a
movl $0x0, 0x4(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_lcm_ui
void
mpz_lcm_ui (mpz_t r, const mpz_t u, unsigned long v)
{
  if (v == 0 || u->_mp_size == 0)
    {
      r->_mp_size = 0;
      return;
    }

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

  mpz_abs (r, r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdx, %rdx
je 0x5497
movq %rsi, %r14
cmpl $0x0, 0x4(%rsi)
je 0x5497
movq %rdx, %r15
xorl %edi, %edi
movq %r14, %rsi
callq 0x4783
movq %rax, %rcx
movq %r15, %rax
xorl %edx, %edx
divq %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x3484
movl 0x4(%rbx), %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
movl %ecx, 0x4(%rbx)
jmp 0x549e
movl $0x0, 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_invert
int
mpz_invert (mpz_t r, const mpz_t u, const mpz_t m)
{
  mpz_t g, tr;
  int invertible;

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

  mpz_init (g);
  mpz_init (tr);

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorl %r12d, %r12d
cmpl $0x0, 0x4(%rsi)
je 0x55cc
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x4(%rdx), %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cmpl $0x1, %ecx
jbe 0x5569
movl $0x1, %eax
leaq -0x50(%rbp), %r12
movq %rax, (%r12)
movl $0x8, %edi
callq *0xaba5(%rip)           # 0x100a0
movq %rax, 0x8(%r12)
leaq -0x40(%rbp), %r13
movl $0x1, %eax
movq %rax, (%r13)
movl $0x8, %edi
callq *0xab88(%rip)           # 0x100a0
movq %rax, 0x8(%r13)
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
movq %r15, %rcx
xorl %r15d, %r15d
movq %r14, %r8
callq 0x4c9e
cmpl $0x1, 0x4(%r12)
jne 0x5546
movq -0x48(%rbp), %rax
cmpq $0x1, (%rax)
sete %r15b
testb %r15b, %r15b
je 0x55b0
cmpl $0x0, -0x3c(%rbp)
jns 0x558a
cmpl $0x0, 0x4(%r14)
js 0x557b
leaq -0x40(%rbp), %rdi
movq %rdi, %rsi
movq %r14, %rdx
callq 0x30fc
jmp 0x558a
jne 0x55cc
movq 0x8(%r14), %rax
cmpq $0x2, (%rax)
jae 0x54e3
jmp 0x55cc
leaq -0x40(%rbp), %rdi
movq %rdi, %rsi
movq %r14, %rdx
callq 0x3412
movl 0x4(%rbx), %eax
movl -0x3c(%rbp), %ecx
movl %ecx, 0x4(%rbx)
movl %eax, -0x3c(%rbp)
movl (%rbx), %eax
movl -0x40(%rbp), %ecx
movl %ecx, (%rbx)
movl %eax, -0x40(%rbp)
movq 0x8(%rbx), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, -0x38(%rbp)
movzbl %r15b, %r12d
movq -0x48(%rbp), %rdi
xorl %esi, %esi
callq *0xaaf0(%rip)           # 0x100b0
movq -0x38(%rbp), %rdi
xorl %esi, %esi
callq *0xaae4(%rip)           # 0x100b0
movl %r12d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq