LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_pow_ui
void
mpz_pow_ui (mpz_t r, const mpz_t b, unsigned long e)
{
  unsigned long bit;
  mpz_t tr;
  mpz_init_set_ui (tr, 1);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x1, %r13d
leaq -0x40(%rbp), %r12
movq %r13, (%r12)
movl $0x8, %edi
callq *0xaa8f(%rip)           # 0x100a0
movq %rax, 0x8(%r12)
movl $0x1, 0x4(%r12)
movq %r13, (%rax)
movabsq $-0x8000000000000000, %r13 # imm = 0x8000000000000000
movq %r12, %rdi
movq %r12, %rsi
movq %r12, %rdx
callq 0x3555
testq %r14, %r13
je 0x564d
movq %r12, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3555
movq %r13, %rax
shrq %rax
cmpq $0x1, %r13
movq %rax, %r13
ja 0x562c
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), %rdi
movq -0x38(%rbp), %rax
movq %rax, 0x8(%rbx)
movq %rdi, -0x38(%rbp)
movq 0xaa27(%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: mpn_div_qr_invert
static void
mpn_div_qr_invert (struct gmp_div_inverse *inv,
		   mp_srcptr dp, mp_size_t dn)
{
  assert (dn > 0);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdx, %rdx
jle 0x5b98
movq %rdi, %rbx
cmpq $0x2, %rdx
je 0x5aba
cmpq $0x1, %rdx
jne 0x5b1c
movq (%rsi), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7a94
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0x5bb7
xorl %ecx, %ecx
movq %rdi, %rax
shrq $0x38, %rax
movq %rdi, %rax
jne 0x5afd
xorl %ecx, %ecx
movabsq $0x1000000000000, %rdx  # imm = 0x1000000000000
movq %rdi, %r8
movq %rdi, %rax
shlq $0x8, %rax
addl $0x8, %ecx
cmpq %rdx, %r8
movq %rax, %r8
jb 0x5ae7
jmp 0x5afd
addq %rax, %rax
incl %ecx
testq %rax, %rax
jns 0x5af8
movq (%rsi), %rsi
movl %ecx, (%rbx)
testl %ecx, %ecx
je 0x5b12
shldq %cl, %rsi, %rdi
shlq %cl, %rsi
movq %rdi, 0x8(%rbx)
movq %rsi, 0x10(%rbx)
jmp 0x5b88
movq -0x8(%rsi,%rdx,8), %rdi
testq %rdi, %rdi
je 0x5bd6
xorl %ecx, %ecx
movq %rdi, %rax
shrq $0x38, %rax
movq %rdi, %rax
jne 0x5b60
xorl %ecx, %ecx
movabsq $0x1000000000000, %r8   # imm = 0x1000000000000
movq %rdi, %r9
movq %rdi, %rax
shlq $0x8, %rax
addl $0x8, %ecx
cmpq %r8, %r9
movq %rax, %r9
jb 0x5b4a
jmp 0x5b60
addq %rax, %rax
incl %ecx
testq %rax, %rax
jns 0x5b5b
movq -0x10(%rsi,%rdx,8), %rax
movl %ecx, (%rbx)
testl %ecx, %ecx
je 0x5b7d
shldq %cl, %rax, %rdi
movq -0x18(%rsi,%rdx,8), %rdx
shldq %cl, %rdx, %rax
movq %rdi, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rax, %rsi
callq 0x1d48
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5620(%rip), %rdi      # 0xb1bf
leaq 0x44be(%rip), %rsi      # 0xa064
leaq 0x581d(%rip), %rcx      # 0xb3ca
movl $0x33e, %edx            # imm = 0x33E
callq 0x1090
leaq 0x5853(%rip), %rdi      # 0xb411
leaq 0x449f(%rip), %rsi      # 0xa064
leaq 0x584c(%rip), %rcx      # 0xb418
movl $0x32d, %edx            # imm = 0x32D
callq 0x1090
leaq 0x5834(%rip), %rdi      # 0xb411
leaq 0x4480(%rip), %rsi      # 0xa064
leaq 0x57df(%rip), %rcx      # 0xb3ca
movl $0x34b, %edx            # imm = 0x34B
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_sizeinbase
size_t
mpz_sizeinbase (const mpz_t u, int base)
{
  mp_size_t un;
  mp_srcptr up;
  mp_ptr tp;
  mp_bitcnt_t bits;
  struct gmp_div_inverse bi;
  size_t ndigits;

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

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

  up = u->_mp_d;

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

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

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

  gmp_free (tp);
  return ndigits;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x1, %esi
jle 0x6535
cmpl $0x25, %esi
jge 0x6554
movl 0x4(%rdi), %eax
movl %eax, %r13d
negl %r13d
movl %eax, %r14d
cmovnsl %r13d, %r14d
jae 0x6474
movl %eax, -0x30(%rbp)
movq 0x8(%rdi), %r15
leaq -0x1(%r14), %r12
shlq $0x6, %r12
movq -0x8(%r15,%r14,8), %rdi
movl %esi, -0x2c(%rbp)
callq 0x7a30
movl -0x2c(%rbp), %ecx
movq %rax, %rbx
addq %r12, %rbx
cmpl $0x7, %ecx
jle 0x647e
cmpl $0x8, %ecx
je 0x6491
cmpl $0x10, %ecx
je 0x64ad
cmpl $0x20, %ecx
jne 0x64b7
addq $0x4, %rbx
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
movq %rbx, %rax
mulq %rcx
movq %rdx, %rbx
jmp 0x64b1
movl $0x1, %ebx
jmp 0x6523
cmpl $0x2, %ecx
je 0x6523
cmpl $0x4, %ecx
jne 0x64b7
incq %rbx
jmp 0x64a8
addq $0x2, %rbx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
movq %rbx, %rax
mulq %rcx
movq %rdx, %rbx
shrq %rbx
jmp 0x6523
addq $0x3, %rbx
shrq $0x2, %rbx
jmp 0x6523
leaq (,%r14,8), %rdi
callq *0x9bdb(%rip)           # 0x100a0
movq %rax, %r12
movl -0x30(%rbp), %eax
cmpl %r13d, %eax
cmovgl %eax, %r13d
xorl %eax, %eax
movq (%r15,%rax,8), %rcx
movq %rcx, (%r12,%rax,8)
incq %rax
cmpq %rax, %r13
jne 0x64d4
movl -0x2c(%rbp), %esi
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x7a94
xorl %ebx, %ebx
incq %rbx
movq %r12, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x7b11
cmpq $0x1, -0x8(%r12,%r14,8)
sbbq $0x0, %r14
testq %r14, %r14
jg 0x64f5
movq %r12, %rdi
xorl %esi, %esi
callq *0x9b8d(%rip)           # 0x100b0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4288(%rip), %rdi      # 0xa7c4
leaq 0x3b21(%rip), %rsi      # 0xa064
leaq 0x4284(%rip), %rcx      # 0xa7ce
movl $0xf95, %edx            # imm = 0xF95
callq 0x1090
leaq 0x42a4(%rip), %rdi      # 0xa7ff
leaq 0x3b02(%rip), %rsi      # 0xa064
leaq 0x4265(%rip), %rcx      # 0xa7ce
movl $0xf96, %edx            # imm = 0xF96
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_root
int
mpz_root (mpz_t x, const mpz_t y, unsigned long z)
{
  int res;
  mpz_t r;

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

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x30(%rbp), %r12
movq $0x1, (%r12)
movl $0x8, %edi
callq *0x9afe(%rip)           # 0x100a0
movq %rax, 0x8(%r12)
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x604f
xorl %ebx, %ebx
cmpl $0x0, 0x4(%r12)
sete %bl
movq 0x8(%r12), %rdi
xorl %esi, %esi
callq *0x9ae0(%rip)           # 0x100b0
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: mpn_perfect_square_p
int
mpn_perfect_square_p (mp_srcptr p, mp_size_t n)
{
  mpz_t t;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
testq %rsi, %rsi
jle 0x6677
cmpq $0x0, -0x8(%rdi,%rsi,8)
je 0x6696
movl $0x0, -0x10(%rbp)
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rdi,%rsi,8)
jne 0x665b
leaq -0x1(%rsi), %rax
cmpq $0x1, %rsi
movq %rax, %rsi
jg 0x6644
xorl %esi, %esi
leaq -0x10(%rbp), %rax
movl %esi, 0x4(%rax)
movl $0x2, %edx
xorl %edi, %edi
movq %rax, %rsi
callq 0x6573
addq $0x10, %rsp
popq %rbp
retq
leaq 0x4b42(%rip), %rdi      # 0xb1c0
leaq 0x39df(%rip), %rsi      # 0xa064
leaq 0x3f41(%rip), %rcx      # 0xa5cd
movl $0xcda, %edx            # imm = 0xCDA
callq 0x1090
leaq 0x3f5f(%rip), %rdi      # 0xa5fc
leaq 0x39c0(%rip), %rsi      # 0xa064
leaq 0x3f22(%rip), %rcx      # 0xa5cd
movl $0xcdb, %edx            # imm = 0xCDB
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_sqrtrem
mp_size_t
mpn_sqrtrem (mp_ptr sp, mp_ptr rp, mp_srcptr p, mp_size_t n)
{
  mpz_t s, r, u;
  mp_size_t res;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
testq %rcx, %rcx
jle 0x67d5
movq %rcx, %r15
movq %rdx, %r12
cmpq $0x0, -0x8(%rdx,%rcx,8)
je 0x67f4
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %r13d
movq %r13, -0x40(%rbp)
movl $0x8, %edi
callq *0x99a4(%rip)           # 0x100a0
movq %rax, -0x38(%rbp)
movq %r13, -0x50(%rbp)
movl $0x8, %edi
callq *0x9991(%rip)           # 0x100a0
movq %rax, -0x48(%rbp)
movl $0x0, -0x60(%rbp)
movq %r12, -0x58(%rbp)
movq %r15, %rax
cmpq $0x0, -0x8(%r12,%rax,8)
jne 0x6738
leaq -0x1(%rax), %rcx
cmpq $0x1, %rax
movq %rcx, %rax
jg 0x6721
xorl %eax, %eax
leaq -0x60(%rbp), %rdx
movl %eax, 0x4(%rdx)
leaq -0x50(%rbp), %r12
leaq -0x40(%rbp), %rsi
movl $0x2, %ecx
movq %r12, %rdi
callq 0x604f
movslq 0x4(%r12), %rax
incq %r15
shrq %r15
cmpq %rax, %r15
jne 0x6813
movq -0x48(%rbp), %rdi
testl %eax, %eax
jle 0x6786
incq %rax
movq -0x10(%rdi,%rax,8), %rcx
movq %rcx, -0x10(%r14,%rax,8)
decq %rax
cmpq $0x1, %rax
jg 0x6773
xorl %esi, %esi
callq *0x9922(%rip)           # 0x100b0
movslq -0x3c(%rbp), %r14
testq %rbx, %rbx
je 0x67b7
testl %r14d, %r14d
jle 0x67b7
movq -0x38(%rbp), %rax
leaq 0x1(%r14), %rcx
movq -0x10(%rax,%rcx,8), %rdx
movq %rdx, -0x10(%rbx,%rcx,8)
decq %rcx
cmpq $0x1, %rcx
jg 0x67a4
movq -0x38(%rbp), %rdi
xorl %esi, %esi
callq *0x98ed(%rip)           # 0x100b0
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x49e4(%rip), %rdi      # 0xb1c0
leaq 0x3881(%rip), %rsi      # 0xa064
leaq 0x3e1f(%rip), %rcx      # 0xa609
movl $0xce5, %edx            # imm = 0xCE5
callq 0x1090
leaq 0x3e01(%rip), %rdi      # 0xa5fc
leaq 0x3862(%rip), %rsi      # 0xa064
leaq 0x3e00(%rip), %rcx      # 0xa609
movl $0xce6, %edx            # imm = 0xCE6
callq 0x1090
leaq 0x3e2b(%rip), %rdi      # 0xa645
leaq 0x3843(%rip), %rsi      # 0xa064
leaq 0x3de1(%rip), %rcx      # 0xa609
movl $0xcec, %edx            # imm = 0xCEC
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_bin_uiui
void
mpz_bin_uiui (mpz_t r, unsigned long n, unsigned long k)
{
  mpz_t t;

  mpz_set_ui (r, k <= n);

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq %rsi, %rdx
ja 0x68aa
setbe %al
movzbl %al, %eax
movl $0x1, 0x4(%rbx)
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
jmp 0x68b1
movl $0x0, 0x4(%rbx)
movq %r14, %rax
shrq %rax
xorl %r15d, %r15d
movq %r14, %rcx
subq %rdx, %rcx
cmovaeq %rcx, %r15
cmpq %rdx, %rax
cmovaeq %rdx, %r15
leaq -0x30(%rbp), %r12
movq $0x1, (%r12)
movl $0x8, %edi
callq *0x97be(%rip)           # 0x100a0
movq %rax, 0x8(%r12)
movq %r12, %rdi
movq %r15, %rsi
callq 0x6832
testq %r15, %r15
je 0x6911
leaq -0x1(%r14), %r12
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3484
movq %r12, %r14
decq %r15
jne 0x68f7
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4313
movq 0x9786(%rip), %rax      # 0x100b0
movq 0x8(%r14), %rdi
xorl %esi, %esi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_scan1
mp_bitcnt_t
mpz_scan1 (const mpz_t u, mp_bitcnt_t starting_bit)
{
  mp_ptr up;
  mp_size_t us, un, i;
  mp_limb_t limb, ux;

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

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x4(%rdi), %r8d
movl %r8d, %eax
negl %eax
cmovsl %r8d, %eax
movq %rsi, %rcx
shrq $0x6, %rsi
cmpq %rax, %rsi
jae 0x6d2e
movq 0x8(%rdi), %rdx
movq (%rdx,%rsi,8), %rdi
testq %rcx, %rcx
je 0x6d41
testl %r8d, %r8d
js 0x6d46
xorl %r8d, %r8d
jmp 0x6d84
testl %r8d, %r8d
movq $-0x1, %rax
cmovnsq %rax, %rcx
movq %rcx, %rax
popq %rbp
retq
xorl %r8d, %r8d
jmp 0x6d8a
movq %rsi, %r8
cmpq $0x40, %rcx
jb 0x6d6a
movq %rsi, %r8
cmpq $0x0, -0x8(%rdx,%r8,8)
jne 0x6d6a
leaq -0x1(%r8), %r9
cmpq $0x1, %r8
movq %r9, %r8
jg 0x6d52
xorl %r8d, %r8d
xorl %r9d, %r9d
testq %r8, %r8
sete %r9b
notq %rdi
addq %r9, %rdi
xorl %r8d, %r8d
cmpq %r9, %rdi
adcq $-0x1, %r8
shrq %cl, %rdi
shlq %cl, %rdi
movq %rax, %rcx
popq %rbp
jmp 0x1c4a
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_tstbit
int
mpz_tstbit (const mpz_t d, mp_bitcnt_t bit_index)
{
  mp_size_t limb_index;
  unsigned shift;
  mp_size_t ds;
  mp_size_t dn;
  mp_limb_t w;
  int bit;

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

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

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

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

  dn = GMP_ABS (d->_mp_size);

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

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

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

      dp = d->_mp_d;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %rbx
movl 0x4(%rdi), %eax
movl %eax, %r12d
negl %r12d
cmovsl %eax, %r12d
movq %rsi, %r14
shrq $0x6, %r14
movl $0x1, %r15d
shlq %cl, %r15
cmpq %r12, %r14
jae 0x6e99
leaq (,%r14,8), %rdi
addq 0x8(%rbx), %rdi
movq %r12, %rdx
subq %r14, %rdx
movq %rdi, %rsi
movq %r15, %rcx
callq 0x155d
testq %rax, %rax
je 0x6ef6
leaq 0x1(%r12), %r13
movq 0x8(%rbx), %rax
cmpl (%rbx), %r12d
jl 0x6e8f
leaq (,%r13,8), %rdx
movq %rax, %rdi
xorl %esi, %esi
callq *0x9236(%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 0x6e8f
movl $0x0, 0x4(%rbx)
movq $0x1, (%rax,%r12,8)
jmp 0x6ef9
leaq 0x1(%r14), %r13
movslq (%rbx), %rcx
movq 0x8(%rbx), %rax
cmpq %rcx, %r14
jl 0x6ed9
leaq (,%r13,8), %rdx
movq %rax, %rdi
xorl %esi, %esi
callq *0x91ec(%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 0x6ed9
movl $0x0, 0x4(%rbx)
movq %r15, (%rax,%r14,8)
subq %r12, %r14
jbe 0x6ef9
leaq (%rax,%r12,8), %rdi
shlq $0x3, %r14
xorl %esi, %esi
movq %r14, %rdx
callq 0x10a0
jmp 0x6ef9
movq %r12, %r13
movl %r13d, %eax
negl %eax
cmpl $0x0, 0x4(%rbx)
cmovnsl %r13d, %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_abs_sub_bit
static void
mpz_abs_sub_bit (mpz_t d, mp_bitcnt_t bit_index)
{
  mp_size_t dn, limb_index;
  mp_ptr dp;
  mp_limb_t bit;

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

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

  assert (limb_index < dn);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x4(%rdi), %eax
movl %eax, %r14d
negl %r14d
cmovsl %eax, %r14d
movq %rsi, %rdi
shrq $0x6, %rdi
movq %r14, %rdx
subq %rdi, %rdx
jbe 0x6f96
movq 0x8(%rbx), %r15
movl $0x1, %eax
movl %esi, %ecx
shlq %cl, %rax
leaq (%r15,%rdi,8), %rdi
movq %rdi, %rsi
movq %rax, %rcx
callq 0x1662
testq %rax, %rax
jne 0x6fb5
cmpq $0x0, -0x8(%r15,%r14,8)
jne 0x6f7b
leaq -0x1(%r14), %rax
cmpq $0x1, %r14
movq %rax, %r14
jg 0x6f63
xorl %r14d, %r14d
movl %r14d, %eax
negl %eax
cmpl $0x0, 0x4(%rbx)
cmovnsl %r14d, %eax
movl %eax, 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x46f3(%rip), %rdi      # 0xb690
leaq 0x30c0(%rip), %rsi      # 0xa064
leaq 0x46f5(%rip), %rcx      # 0xb6a0
movl $0xde4, %edx            # imm = 0xDE4
callq 0x1090
leaq 0x3479(%rip), %rdi      # 0xa435
leaq 0x30a1(%rip), %rsi      # 0xa064
leaq 0x46d6(%rip), %rcx      # 0xb6a0
movl $0xde7, %edx            # imm = 0xDE7
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_clrbit
void
mpz_clrbit (mpz_t d, mp_bitcnt_t bit_index)
{
  if (mpz_tstbit (d, bit_index))
    {
      if (d->_mp_size >= 0)
	mpz_abs_sub_bit (d, bit_index);
      else
	mpz_abs_add_bit (d, bit_index);
    }
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6d93
movl 0x4(%r14), %ecx
shrl $0x1f, %ecx
movq %r14, %rdi
movq %rbx, %rsi
cmpl %ecx, %eax
jne 0x7040
popq %rbx
popq %r14
popq %rbp
jmp 0x6df5
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: mpn_popcount
mp_bitcnt_t
mpn_popcount (mp_srcptr p, mp_size_t n)
{
  mp_size_t i;
  mp_bitcnt_t c;

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

  return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
jle 0x7764
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
callq 0x7772
movl %eax, %eax
addq %rax, %rbx
incq %r12
cmpq %r12, %r14
jne 0x774c
jmp 0x7766
xorl %ebx, %ebx
movq %rbx, %rax
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: gmp_popcount_limb
static unsigned
gmp_popcount_limb (mp_limb_t x)
{
  unsigned c;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x77de
xorl %r9d, %r9d
movl $0x5555, %ecx           # imm = 0x5555
movl $0x3333, %edx           # imm = 0x3333
movl $0x707, %esi            # imm = 0x707
movq %rdi, %r8
movl %edi, %eax
shrl %eax
andl %ecx, %eax
movl %edi, %r10d
andl %ecx, %r10d
addl %eax, %r10d
movl %r10d, %eax
shrl $0x2, %eax
andl %edx, %eax
andl %edx, %r10d
addl %eax, %r10d
movl %r10d, %eax
shrl $0x4, %eax
andl %esi, %eax
andl %esi, %r10d
addl %eax, %r10d
movzbl %r10b, %eax
shrl $0x8, %r10d
addl %r9d, %eax
addl %r10d, %eax
shrq $0x10, %r8
movl %eax, %r9d
cmpq $0xffff, %rdi           # imm = 0xFFFF
movq %r8, %rdi
ja 0x7790
jmp 0x77e0
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_popcount
mp_bitcnt_t
mpz_popcount (const mpz_t u)
{
  mp_size_t un;

  un = u->_mp_size;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movslq 0x4(%rdi), %r14
testq %r14, %r14
js 0x781c
testl %r14d, %r14d
je 0x7825
movq 0x8(%rdi), %r15
xorl %ebx, %ebx
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
callq 0x7772
movl %eax, %eax
addq %rax, %rbx
incq %r12
cmpq %r12, %r14
jne 0x7804
jmp 0x7827
movq $-0x1, %rbx
jmp 0x7827
xorl %ebx, %ebx
movq %rbx, %rax
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_hamdist
mp_bitcnt_t
mpz_hamdist (const mpz_t u, const mpz_t v)
{
  mp_size_t un, vn, i;
  mp_limb_t uc, vc, ul, vl, comp;
  mp_srcptr up, vp;
  mp_bitcnt_t c;

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

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

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

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

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

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

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

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

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

      c += gmp_popcount_limb (ul ^ comp);
    }

  return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movslq 0x4(%rdi), %r13
movslq 0x4(%rsi), %rdx
movq %rdx, %rax
xorq %r13, %rax
js 0x785e
testl %r13d, %r13d
js 0x786a
movq %r13, %rax
jmp 0x787b
movq $-0x1, %rbx
jmp 0x7959
testl %edx, %edx
jns 0x798a
movq %r13, %rax
negq %rax
negq %rdx
shrl $0x1f, %r13d
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rcx
cmpq %rdx, %rax
jge 0x7894
movq %rax, %r8
movq %rcx, %rsi
jmp 0x78a0
movq %rdx, %r8
movq %rdi, %rsi
movq %rcx, %rdi
movq %rax, %rdx
movq %rdx, -0x30(%rbp)
movq %r13, %r12
negq %r12
testq %r8, %r8
movq %rsi, -0x38(%rbp)
jle 0x7918
xorl %ebx, %ebx
xorl %r14d, %r14d
movq %r13, %rax
movq %r13, %rcx
movq %r12, -0x40(%rbp)
movq %rdi, -0x48(%rbp)
movq (%rsi,%r14,8), %rdx
xorq %r12, %rdx
xorl %r13d, %r13d
addq %rcx, %rdx
setb %r13b
movq -0x48(%rbp), %rcx
movq (%rcx,%r14,8), %rdi
xorq -0x40(%rbp), %rdi
xorl %r15d, %r15d
addq %rax, %rdi
setb %r15b
xorq %rdx, %rdi
movq %r8, %r12
callq 0x7772
movq %r12, %r8
movq -0x40(%rbp), %r12
movq -0x38(%rbp), %rsi
movl %eax, %eax
addq %rax, %rbx
incq %r14
movq %r15, %rax
movq %r13, %rcx
cmpq %r14, %r8
jne 0x78c6
jmp 0x7920
xorl %r14d, %r14d
movq %r13, %r15
xorl %ebx, %ebx
testq %r15, %r15
jne 0x796b
cmpq -0x30(%rbp), %r14
jge 0x7959
movq (%rsi,%r14,8), %rdi
xorq %r12, %rdi
xorl %r15d, %r15d
addq %r13, %rdi
setb %r15b
xorq %r12, %rdi
callq 0x7772
movq -0x38(%rbp), %rsi
movl %eax, %eax
addq %rax, %rbx
incq %r14
movq %r15, %r13
cmpq %r14, -0x30(%rbp)
jne 0x792b
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2d24(%rip), %rdi      # 0xa696
leaq 0x26eb(%rip), %rsi      # 0xa064
leaq 0x2e00(%rip), %rcx      # 0xa780
movl $0xf3a, %edx            # imm = 0xF3A
callq 0x1090
leaq 0x2de8(%rip), %rdi      # 0xa779
leaq 0x26cc(%rip), %rsi      # 0xa064
leaq 0x2de1(%rip), %rcx      # 0xa780
movl $0xf25, %edx            # imm = 0xF25
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpz_scan0
mp_bitcnt_t
mpz_scan0 (const mpz_t u, mp_bitcnt_t starting_bit)
{
  mp_ptr up;
  mp_size_t us, un, i;
  mp_limb_t limb, ux;

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

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x4(%rdi), %r9d
xorl %r8d, %r8d
testl %r9d, %r9d
setns %dl
movl %r9d, %eax
negl %eax
cmovsl %r9d, %eax
movq %rsi, %rcx
shrq $0x6, %rsi
cmpq %rax, %rsi
jae 0x7a20
movb %dl, %r8b
negq %r8
movq 0x8(%rdi), %rdx
movq (%rdx,%rsi,8), %rdi
xorq %r8, %rdi
testl %r9d, %r9d
jns 0x7a11
movq %rsi, %r9
cmpq $0x40, %rcx
jb 0x7a09
movq %rsi, %r9
cmpq $0x0, -0x8(%rdx,%r9,8)
jne 0x7a09
leaq -0x1(%r9), %r10
cmpq $0x1, %r9
movq %r10, %r9
jg 0x79f1
xorl %r9d, %r9d
cmpq $0x1, %r9
sbbq $0x0, %rdi
shrq %cl, %rdi
shlq %cl, %rdi
movq %rax, %rcx
popq %rbp
jmp 0x1c4a
testl %r9d, %r9d
movq $-0x1, %rax
cmovnsq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_limb_size_in_base_2
static mp_bitcnt_t
mpn_limb_size_in_base_2 (mp_limb_t u)
{
  unsigned shift;

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

// Assembly:
testq %rdi, %rdi
je 0x7a71
xorl %eax, %eax
movq %rdi, %rcx
shrq $0x38, %rcx
jne 0x7a57
xorl %eax, %eax
movq %rdi, %rcx
shlq $0x8, %rcx
addl $0x8, %eax
shrq $0x30, %rdi
movq %rcx, %rdi
je 0x7a45
jmp 0x7a61
movq %rdi, %rcx
jmp 0x7a61
addq %rcx, %rcx
incl %eax
testq %rcx, %rcx
jns 0x7a5c
movl %eax, %ecx
movl $0x40, %eax
subq %rcx, %rax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x3c56(%rip), %rdi      # 0xb6d2
leaq 0x25e1(%rip), %rsi      # 0xa064
leaq 0x3c4e(%rip), %rcx      # 0xb6d8
movl $0x47f, %edx            # imm = 0x47F
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_div_qr_1_invert
static void
mpn_div_qr_1_invert (struct gmp_div_inverse *inv, mp_limb_t d)
{
  unsigned shift;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x7af2
movq %rdi, %rbx
xorl %ecx, %ecx
movq %rsi, %rax
shrq $0x38, %rax
movq %rsi, %rax
jne 0x7acf
xorl %ecx, %ecx
movq %rsi, %rdx
movq %rsi, %rax
shlq $0x8, %rax
addl $0x8, %ecx
shrq $0x30, %rdx
movq %rax, %rdx
je 0x7ab8
jmp 0x7acf
addq %rax, %rax
incl %ecx
testq %rax, %rax
jns 0x7aca
movl %ecx, (%rbx)
shlq %cl, %rsi
movq %rsi, 0x8(%rbx)
movq %rsi, %rdi
xorl %esi, %esi
callq 0x1d48
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x384e(%rip), %rdi      # 0xb347
leaq 0x2564(%rip), %rsi      # 0xa064
leaq 0x3c00(%rip), %rcx      # 0xb707
movl $0x320, %edx            # imm = 0x320
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_div_qr_1_preinv
static mp_limb_t
mpn_div_qr_1_preinv (mp_ptr qp, mp_srcptr np, mp_size_t nn,
		     const struct gmp_div_inverse *inv)
{
  mp_limb_t d, di;
  mp_limb_t r;
  mp_ptr tp = NULL;

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

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

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

  return r >> inv->shift;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
cmpl $0x0, (%rcx)
movq %rcx, -0x38(%rbp)
je 0x7b65
movq %rcx, %r14
leaq (,%r15,8), %rdi
callq *0x855b(%rip)           # 0x100a0
movq %rax, %rbx
movl (%r14), %ecx
movq %rax, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x1a6f
movq %rax, %r14
movq %rbx, -0x30(%rbp)
movq %rbx, %r13
jmp 0x7b70
movq $0x0, -0x30(%rbp)
xorl %r14d, %r14d
testq %r15, %r15
jle 0x7c3f
movq -0x38(%rbp), %rbx
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rdx
movl %edx, %ecx
shrq $0x20, %rdx
incq %r15
movabsq $0x100000000, %rsi      # imm = 0x100000000
movq %r14, %r9
shrq $0x20, %r9
movl %r14d, %edi
movq %rdi, %r10
imulq %rcx, %r10
imulq %rdx, %rdi
movq %r9, %r11
imulq %rcx, %r11
imulq %rdx, %r9
movl %r10d, %r8d
shrq $0x20, %r10
addq %r11, %rdi
addq %r10, %rdi
leaq (%r9,%rsi), %r10
cmpq %r11, %rdi
cmovaeq %r9, %r10
movq %rdi, %r11
shrq $0x20, %r11
shlq $0x20, %rdi
orq %rdi, %r8
movq -0x10(%r13,%r15,8), %r9
addq %r9, %r8
leaq 0x1(%r14,%r11), %rdi
adcq %r10, %rdi
movq %rdi, %r10
imulq %rax, %r10
subq %r10, %r9
cmpq %r8, %r9
movl $0x0, %r14d
cmovaq %rax, %r14
addq %r9, %r14
cmpq %rax, %r14
movl $0x0, %r10d
cmovaeq %rax, %r10
testq %r12, %r12
je 0x7c2d
cmpq %r9, %r8
sbbq $0x0, %rdi
cmpq %rax, %r14
sbbq $-0x1, %rdi
movq %rdi, -0x10(%r12,%r15,8)
subq %r10, %r14
decq %r15
cmpq $0x1, %r15
jg 0x7b98
jmp 0x7c43
movq -0x38(%rbp), %rbx
cmpl $0x0, (%rbx)
je 0x7c54
movq -0x30(%rbp), %rdi
xorl %esi, %esi
callq *0x845c(%rip)           # 0x100b0
movb (%rbx), %cl
shrq %cl, %r14
movq %r14, %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_out_str
size_t
mpz_out_str (FILE *stream, int base, const mpz_t x)
{
  char *str;
  size_t len;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %edi, %edi
callq 0x7c6b
movq %rax, %r14
movq %rax, %rdi
callq 0x1070
movl $0x1, %esi
movq %r14, %rdi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x1100
movq %rax, %rbx
movq %r14, %rdi
xorl %esi, %esi
callq *0x7f0d(%rip)           # 0x100b0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./bootstrap.c
// Function: isprime
int
isprime (unsigned long int t)
{
  unsigned long int q, r, d;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x1f, %rdi
ja 0x863b
movl $0xa08a28ac, %eax       # imm = 0xA08A28AC
xorl %ecx, %ecx
btq %rdi, %rax
setb %cl
jmp 0x8705
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
movq %rdi, %rax
mulq %rcx
movq %rdx, %rsi
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
movq %rdi, %rax
mulq %rcx
movabsq $0x6db6db6db6db6db7, %rax # imm = 0x6DB6DB6DB6DB6DB7
imulq %rdi, %rax
xorl %ecx, %ecx
movabsq $0x2492492492492493, %r8 # imm = 0x2492492492492493
cmpq %r8, %rax
jb 0x8705
shrq $0x2, %rdx
leaq (%rdx,%rdx,4), %rax
movq %rdi, %rdx
subq %rax, %rdx
je 0x8705
movl %edi, %eax
andl $0x1, %eax
je 0x8705
shrq %rsi
leaq (%rsi,%rsi,2), %rax
movq %rdi, %rdx
subq %rax, %rdx
je 0x8705
movl $0x1, %ecx
cmpq $0x79, %rdi
jb 0x8705
movabsq $0x2e8ba2e8ba2e8ba3, %rdx # imm = 0x2E8BA2E8BA2E8BA3
movq %rdi, %rax
mulq %rdx
movq %rdx, %rax
shrq %rax
movl $0xb, %esi
imulq %rsi, %rax
cmpq %rdi, %rax
je 0x8703
leaq 0x2(%rsi), %r8
movq %rdi, %rax
xorl %edx, %edx
divq %r8
cmpq %r8, %rax
jb 0x8705
imulq %r8, %rax
cmpq %rdi, %rax
je 0x8703
addq $0x6, %rsi
movq %rdi, %rax
xorl %edx, %edx
divq %rsi
cmpq %rsi, %rax
jae 0x86cd
jmp 0x8705
xorl %ecx, %ecx
movl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./bootstrap.c
// Function: log2_ceil
int
log2_ceil (int n)
{
  int  e;
  assert (n >= 1);
  for (e = 0; ; e++)
    if ((1 << e) >= n)
      break;
  return e;
}

// Assembly:
testl %edi, %edi
jle 0x8722
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
incl %ecx
movl $0x1, %eax
shll %cl, %eax
cmpl %edi, %eax
jl 0x8712
movl %ecx, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1b69(%rip), %rdi      # 0xa296
leaq 0x22d0(%rip), %rsi      # 0xaa04
leaq 0x22d7(%rip), %rcx      # 0xaa12
movl $0x51, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./bootstrap.c
// Function: mpz_preinv_invert
void
mpz_preinv_invert (mpz_t inv, mpz_t d, int numb_bits)
{
  mpz_t  t;
  int    norm;
  assert (SIZ(d) > 0);

  norm = numb_bits - mpz_sizeinbase (d, 2);
  assert (norm >= 0);
  mpz_init_set_ui (t, 1L);
  mpz_mul_2exp (t, t, 2*numb_bits - norm);
  mpz_tdiv_q (inv, t, d);
  mpz_set_ui (t, 1L);
  mpz_mul_2exp (t, t, numb_bits);
  mpz_sub (inv, inv, t);

  mpz_clear (t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movslq 0x4(%rsi), %rax
testq %rax, %rax
jle 0x883b
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rcx
leaq -0x1(%rax), %r15
shll $0x6, %r15d
movq -0x8(%rcx,%rax,8), %rdi
callq 0x7a30
addl %r15d, %eax
movl %r12d, %r13d
subl %eax, %r13d
js 0x885a
movslq %r12d, %rax
movq %rax, -0x30(%rbp)
movl $0x1, %eax
leaq -0x40(%rbp), %r15
movq %rax, (%r15)
movl $0x8, %edi
callq *0x78f1(%rip)           # 0x100a0
movq %rax, 0x8(%r15)
movl $0x1, %ecx
movl %ecx, 0x4(%r15)
movl $0x1, %ecx
movq %rcx, (%rax)
addl %r12d, %r12d
subl %r13d, %r12d
movslq %r12d, %rdx
movq %r15, %rdi
movq %r15, %rsi
callq 0x366f
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movl $0x2, %r8d
callq 0x3989
movl $0x1, %eax
movl %eax, 0x4(%r15)
movq 0x8(%r15), %rax
movl $0x1, %ecx
movq %rcx, (%rax)
movq %r15, %rdi
movq %r15, %rsi
movq -0x30(%rbp), %rdx
callq 0x366f
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3412
movq 0x8(%r15), %rdi
xorl %esi, %esi
callq *0x7884(%rip)           # 0x100b0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x21e3(%rip), %rdi      # 0xaa25
leaq 0x21bb(%rip), %rsi      # 0xaa04
leaq 0x21e0(%rip), %rcx      # 0xaa30
movl $0x5f, %edx
callq 0x1090
leaq 0x220b(%rip), %rdi      # 0xaa6c
leaq 0x219c(%rip), %rsi      # 0xaa04
leaq 0x21c1(%rip), %rcx      # 0xaa30
movl $0x62, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./bootstrap.c
// Function: mpz_invert_2exp
void
mpz_invert_2exp (mpz_t r, mpz_t a, unsigned long n)
{
  unsigned long  i;
  mpz_t  inv, prod;

  assert (mpz_odd_p (a));

  mpz_init_set_ui (inv, 1L);
  mpz_init (prod);

  for (i = 1; i < n; i++)
    {
      mpz_mul (prod, inv, a);
      if (mpz_tstbit (prod, i) != 0)
	mpz_setbit (inv, i);
    }

  mpz_mul (prod, inv, a);
  mpz_tdiv_r_2exp (prod, prod, n);
  assert (mpz_cmp_ui (prod, 1L) == 0);

  mpz_set (r, inv);

  mpz_clear (inv);
  mpz_clear (prod);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, -0x58(%rbp)
cmpl $0x0, 0x4(%rsi)
je 0x89ae
movq %rsi, %r15
movq 0x8(%rsi), %rax
movq (%rax), %rax
andl $0x1, %eax
je 0x89ae
movq %rdx, %r14
movl $0x1, %r12d
movq %r12, -0x50(%rbp)
movl $0x8, %edi
callq *0x77dd(%rip)           # 0x100a0
movq %rax, -0x48(%rbp)
movl $0x1, -0x4c(%rbp)
movq %r12, (%rax)
movq %r12, -0x40(%rbp)
movl $0x8, %edi
callq *0x77c0(%rip)           # 0x100a0
movq %rax, -0x38(%rbp)
cmpq $0x2, %r14
jb 0x8922
leaq -0x40(%rbp), %r13
leaq -0x50(%rbp), %rbx
movq %r13, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3555
movq %r13, %rdi
movq %r12, %rsi
callq 0x6d93
testl %eax, %eax
je 0x891a
movq %rbx, %rdi
movq %r12, %rsi
callq 0x536d
incq %r12
cmpq %r12, %r14
jne 0x88f2
leaq -0x40(%rbp), %rbx
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3555
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl $0x2, %ecx
callq 0x4055
cmpl $0x1, 0x4(%rbx)
jne 0x898f
movq -0x38(%rbp), %rax
cmpq $0x1, (%rax)
jne 0x898f
leaq -0x50(%rbp), %rbx
movq -0x58(%rbp), %rdi
movq %rbx, %rsi
callq 0x24be
movq 0x8(%rbx), %rdi
xorl %esi, %esi
callq *0x773c(%rip)           # 0x100b0
movq -0x38(%rbp), %rdi
xorl %esi, %esi
callq *0x7730(%rip)           # 0x100b0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2132(%rip), %rdi      # 0xaac8
leaq 0x2067(%rip), %rsi      # 0xaa04
leaq 0x20e0(%rip), %rcx      # 0xaa84
movl $0x82, %edx
callq 0x1090
leaq 0x20c1(%rip), %rdi      # 0xaa76
leaq 0x2048(%rip), %rsi      # 0xaa04
leaq 0x20c1(%rip), %rcx      # 0xaa84
movl $0x74, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./bootstrap.c
// Function: mpz_invert_ui_2exp
void
mpz_invert_ui_2exp (mpz_t r, unsigned long a, unsigned long n)
{
  mpz_t  az;
  mpz_init_set_ui (az, a);
  mpz_invert_2exp (r, az, n);
  mpz_clear (az);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movq $0x1, -0x30(%rbp)
movl $0x8, %edi
callq *0x76a8(%rip)           # 0x100a0
movq %rax, %r14
movq %rax, -0x28(%rbp)
testq %r12, %r12
je 0x8a10
movl $0x1, -0x2c(%rbp)
movq %r12, (%r14)
jmp 0x8a17
movl $0x0, -0x2c(%rbp)
leaq -0x30(%rbp), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x8879
movq 0x7683(%rip), %rax      # 0x100b0
movq %r14, %rdi
xorl %esi, %esi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/gen-fac.c
// Function: main
int
main (int argc, char *argv[])
{
  int nail_bits, limb_bits, numb_bits;

  if (argc != 3)
    {
      fprintf (stderr, "Usage: gen-fac limbbits nailbits\n");
      exit (1);
    }
  limb_bits = atoi (argv[1]);
  nail_bits = atoi (argv[2]);
  numb_bits = limb_bits - nail_bits;
  if (limb_bits < 2 || nail_bits < 0 || numb_bits < 1)
    {
      fprintf (stderr, "Invalid limb/nail bits %d,%d\n", limb_bits,
	       nail_bits);
      exit (1);
    }
  gen_consts (numb_bits, nail_bits, limb_bits);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl $0x3, %edi
jne 0x9549
movq %rsi, %r14
movq 0x8(%rsi), %rdi
callq 0x10e0
movl %eax, %ebx
movq 0x10(%r14), %rdi
callq 0x10e0
cmpl $0x2, %ebx
jl 0x954e
testl %eax, %eax
js 0x954e
movl %ebx, %edi
subl %eax, %edi
testl %edi, %edi
jle 0x954e
callq 0x8a6f
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x1298
movl %ebx, %edi
movl %eax, %esi
callq 0x12c0
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_limb_get_str
static size_t
mpn_limb_get_str (unsigned char *sp, mp_limb_t w,
		  const struct gmp_div_inverse *binv)
{
  mp_size_t i;
  for (i = 0; w > 0; i++)
    {
      mp_limb_t h, l, r;

      h = w >> (GMP_LIMB_BITS - binv->shift);
      l = w << binv->shift;

      gmp_udiv_qrnnd_preinv (w, r, h, l, binv->d1, binv->di);
      assert ( (r << (GMP_LIMB_BITS - binv->shift)) == 0);
      r >>= binv->shift;

      sp[i] = r;
    }
  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x9657
xorl %r10d, %r10d
movabsq $0x100000000, %r9       # imm = 0x100000000
movl (%rdx), %eax
movl %eax, %r8d
negb %r8b
movq %rsi, %r11
movl %r8d, %ecx
shrq %cl, %r11
movl %eax, %ecx
shlq %cl, %rsi
movq 0x18(%rdx), %r15
movq %r11, %rbx
shrq $0x20, %rbx
movl %r15d, %r14d
shrq $0x20, %r15
movl %r11d, %ecx
movq %rcx, %r12
imulq %r14, %r12
imulq %r15, %rcx
imulq %rbx, %r14
imulq %rbx, %r15
movl %r12d, %ebx
shrq $0x20, %r12
addq %r14, %rcx
addq %r12, %rcx
leaq (%r15,%r9), %r12
cmpq %r14, %rcx
cmovaeq %r15, %r12
movq %rcx, %r14
shrq $0x20, %r14
shlq $0x20, %rcx
orq %rcx, %rbx
addq %rsi, %rbx
leaq 0x1(%r11,%r14), %r11
adcq %r12, %r11
movq 0x8(%rdx), %r15
movq %r11, %rcx
imulq %r15, %rcx
subq %rcx, %rsi
cmpq %rbx, %rsi
movl $0x0, %r12d
cmovaq %r15, %r12
addq %rsi, %r12
cmpq %r15, %r12
movl $0x0, %ecx
cmovaeq %r15, %rcx
movq %r12, %r14
subq %rcx, %r14
movq %r14, %r13
movl %r8d, %ecx
shlq %cl, %r13
testq %r13, %r13
jne 0x9668
xorl %r8d, %r8d
cmpq %r15, %r12
setae %r8b
cmpq %rsi, %rbx
sbbq $0x0, %r11
movl %eax, %ecx
shrq %cl, %r14
leaq 0x1(%r10), %rax
movb %r14b, (%rdi,%r10)
movq %rax, %r10
addq %r11, %r8
movq %r8, %rsi
jne 0x957b
jmp 0x9659
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x19a2(%rip), %rdi      # 0xb011
leaq 0x9ee(%rip), %rsi       # 0xa064
leaq 0x19be(%rip), %rcx      # 0xb03b
movl $0x4b0, %edx            # imm = 0x4B0
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/test1.cpp
// Function: main
int main()
{
    CoroOptions opt;
    opt.share_stack_count = 1;
    SchedulerManager::CreateSingleton(opt);
    for (int i = 0; i < 1000; i++)
    {
        StartCoro(testFunc, NULL);
    }

    sleep(100);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
leaq 0x28(%rsp), %rdi
movb $0x1, (%rdi)
movaps 0x4a2d(%rip), %xmm0     # 0x7010
movups %xmm0, 0x4(%rdi)
movq $0x0, 0x20(%rdi)
movabsq $-0xffffffff, %rax      # imm = 0xFFFFFFFF00000001
movq %rax, 0x14(%rdi)
callq 0x4402
movl $0x3e8, %ebp            # imm = 0x3E8
leaq 0x95(%rip), %r14        # 0x26a3
leaq 0x24f(%rip), %r15       # 0x2864
leaq 0x250(%rip), %r12       # 0x286c
movq %rsp, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movq %r14, (%rsp)
movq %r15, 0x18(%rsp)
movq %r12, 0x10(%rsp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x45ea
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x265a
movq %rbx, %rdi
movq %rbx, %rsi
movl $0x3, %edx
callq *%rax
decl %ebp
jne 0x261f
movl $0x64, %edi
callq 0x2170
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x269b
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2693
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x2330
movq %rax, %rdi
callq 0x2858
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/test1.cpp
// Function: testFunc(void*)
static void testFunc(void *data)
{
    CoroPtr self = CoroSelf();
    printf("###testFunc:%d\n", self->id);
    CoroSleep(2000);
    printf("###testFunc:%d after 2000\n", self->id);
    auto f = [](void* data)
    {
        CoroPtr self = CoroSelf();
        printf("###subrun:%d\n", self->id);
        int32_t sleep_ms = 2000 + 1000 - self->id;
        int64_t start = mstime();
        CoroSleep(sleep_ms);
        printf("###subTestFunc:%d after %lldms actual %lldms\n", self->id, sleep_ms, mstime() - start);
    };
    auto cid = StartCoro(f, NULL);
    printf("###Join coro:%d\n", cid);
    JoinCoro(cid);
    printf("###Join coro done:%d\n", cid);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
callq 0x43b6
movq %rax, %rbx
movq 0x10(%rax), %rsi
leaq 0x4965(%rip), %rdi      # 0x7020
xorl %eax, %eax
callq 0x2050
movl $0x7d0, %edi            # imm = 0x7D0
callq 0x46d3
movq 0x10(%rbx), %rsi
leaq 0x4959(%rip), %rdi      # 0x7030
xorl %eax, %eax
callq 0x2050
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
leaq 0x8c(%rip), %rax        # 0x277a
movq %rax, 0x18(%rdi)
leaq 0x147(%rip), %rax       # 0x2840
movq %rax, 0x10(%rdi)
xorl %esi, %esi
callq 0x45ea
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x271e
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x4926(%rip), %rdi      # 0x704b
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2050
movq %rbx, %rdi
callq 0x4645
leaq 0x491e(%rip), %rdi      # 0x705c
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2050
addq $0x20, %rsp
popq %rbx
retq
jmp 0x2772
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x276a
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x2330
movq %rax, %rdi
callq 0x2858
// File: /workspace/github_cpp_makefile_star2_O1/yinqiwen[P]coroxx/libcoro.cpp
// Function: coroxx::LibCoroCoroutine::LibCoroCoroutine(coroxx::CoroOptions const&, bool)
LibCoroCoroutine::LibCoroCoroutine(const CoroOptions& opt, bool main)
            : stack(NULL), id(0), ctx_inited(false), waiting(false), save_buffer(NULL), save_buffer_size(0), stack_sp(
            NULL)
    {
        id = g_coro_id_seed++;
        data_ctx.coro = this;

        g_create_mutex.Lock();
        if (main)
        {
            coro_create(&ctx, NULL, NULL, NULL, 0);
            ctx_inited = true;
        }
        g_create_mutex.Unlock();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
movw $0x0, 0x48(%rdi)
movups %xmm0, 0x50(%rdi)
movq $0x0, 0x60(%rdi)
movq 0x8948(%rip), %rax      # 0xb210
leaq 0x1(%rax), %rcx
movq %rcx, 0x893d(%rip)      # 0xb210
movq %rax, 0x10(%rdi)
movq %rdi, 0x40(%rdi)
leaq 0x8906(%rip), %rdi      # 0xb1e8
callq 0x2270
testl %ebp, %ebp
je 0x2904
leaq 0x18(%rbx), %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5e79
movb $0x1, 0x48(%rbx)
leaq 0x88dd(%rip), %rdi      # 0xb1e8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2180
movq %rax, %r15
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x2933
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
movq %r15, %rdi
callq 0x2330
movq %rax, %rdi
callq 0x2858
nop