LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jle 0xb58f
jmp 0xb5ae
leaq 0x3510(%rip), %rdi      # 0xeaa6
leaq 0x34e8(%rip), %rsi      # 0xea85
movl $0x5f, %edx
leaq 0x3508(%rip), %rcx      # 0xeab1
callq 0x1070
movslq -0x14(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x8230
movq %rax, %rcx
movq -0x40(%rbp), %rax
subq %rcx, %rax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0xb5d9
jmp 0xb5f8
leaq 0x350d(%rip), %rdi      # 0xeaed
leaq 0x349e(%rip), %rsi      # 0xea85
movl $0x62, %edx
leaq 0x34be(%rip), %rcx      # 0xeab1
callq 0x1070
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x3520
leaq -0x30(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl -0x14(%rbp), %eax
shll %eax
subl -0x34(%rbp), %eax
movslq %eax, %rdx
callq 0x5000
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x57c0
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x3350
leaq -0x30(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x5000
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x4c50
leaq -0x30(%rbp), %rdi
callq 0x32c0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rcx
andl %ecx, %eax
cmpl $0x0, %eax
je 0xb6a8
jmp 0xb6c7
leaq 0x3448(%rip), %rdi      # 0xeaf7
leaq 0x33cf(%rip), %rsi      # 0xea85
movl $0x74, %edx
leaq 0x3443(%rip), %rcx      # 0xeb05
callq 0x1070
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x3520
leaq -0x40(%rbp), %rdi
callq 0x31e0
movq $0x1, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xb730
leaq -0x40(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x4e70
leaq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x8ce0
cmpl $0x0, %eax
je 0xb720
leaq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7420
jmp 0xb722
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xb6e6
leaq -0x40(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x4e70
leaq -0x40(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x5fc0
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x4120
cmpl $0x0, %eax
jne 0xb767
jmp 0xb786
leaq 0x33db(%rip), %rdi      # 0xeb49
leaq 0x3310(%rip), %rsi      # 0xea85
movl $0x82, %edx
leaq 0x3384(%rip), %rcx      # 0xeb05
callq 0x1070
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3390
leaq -0x30(%rbp), %rdi
callq 0x32c0
leaq -0x40(%rbp), %rdi
callq 0x32c0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0xc1be
movq 0x6e55(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
leaq 0x316d(%rip), %rsi      # 0xf31a
movb $0x0, %al
callq 0x1080
movl $0x1, %edi
callq 0x10c0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10b0
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x10b0
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x2, -0x18(%rbp)
jl 0xc1f9
cmpl $0x0, -0x14(%rbp)
jl 0xc1f9
cmpl $0x1, -0x1c(%rbp)
jge 0xc221
movq 0x6df8(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
movl -0x18(%rbp), %edx
movl -0x14(%rbp), %ecx
leaq 0x312c(%rip), %rsi      # 0xf33c
movb $0x0, %al
callq 0x1080
movl $0x1, %edi
callq 0x10c0
movl -0x1c(%rbp), %edi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0xb840
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_div_qr
static void
mpn_div_qr (mp_ptr qp, mp_ptr np, mp_size_t nn, mp_srcptr dp, mp_size_t dn)
{
  struct gmp_div_inverse inv;
  mp_ptr tp = NULL;

  assert (dn > 0);
  assert (nn >= dn);

  mpn_div_qr_invert (&inv, dp, dn);
  if (dn > 2 && inv.shift > 0)
    {
      tp = gmp_xalloc_limbs (dn);
      gmp_assert_nocarry (mpn_lshift (tp, dp, dn, inv.shift));
      dp = tp;
    }
  mpn_div_qr_preinv (qp, np, nn, dp, dn, &inv);
  if (tp)
    gmp_free (tp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x50(%rbp)
cmpq $0x0, -0x28(%rbp)
jle 0xc59d
jmp 0xc5bc
leaq 0x3090(%rip), %rdi      # 0xf634
leaq 0x1b29(%rip), %rsi      # 0xe0d4
movl $0x441, %edx            # imm = 0x441
leaq 0x3084(%rip), %rcx      # 0xf63b
callq 0x1070
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jl 0xc5c8
jmp 0xc5e7
leaq 0x30ad(%rip), %rdi      # 0xf67c
leaq 0x1afe(%rip), %rsi      # 0xe0d4
movl $0x442, %edx            # imm = 0x442
leaq 0x3059(%rip), %rcx      # 0xf63b
callq 0x1070
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x7b80
cmpq $0x2, -0x28(%rbp)
jle 0xc65c
cmpl $0x0, -0x48(%rbp)
jbe 0xc65c
movq -0x28(%rbp), %rdi
callq 0x3220
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x48(%rbp), %ecx
callq 0x20b0
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0xc633
jmp 0xc652
leaq 0x1e6b(%rip), %rdi      # 0xe4a5
leaq 0x1a93(%rip), %rsi      # 0xe0d4
movl $0x448, %edx            # imm = 0x448
leaq 0x2fee(%rip), %rcx      # 0xf63b
callq 0x1070
jmp 0xc654
movq -0x50(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq -0x48(%rbp), %r9
callq 0x7d60
cmpq $0x0, -0x50(%rbp)
je 0xc691
movq 0x6a11(%rip), %rax      # 0x13098
movq -0x50(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
callq *%rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_div_qr_2_invert
static void
mpn_div_qr_2_invert (struct gmp_div_inverse *inv,
		     mp_limb_t d1, mp_limb_t d0)
{
  unsigned shift;

  assert (d1 > 0);
  gmp_clz (shift, d1);
  inv->shift = shift;
  if (shift > 0)
    {
      d1 = (d1 << shift) | (d0 >> (GMP_LIMB_BITS - shift));
      d0 <<= shift;
    }
  inv->d1 = d1;
  inv->d0 = d0;
  inv->di = mpn_invert_3by2 (d1, d0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jbe 0xc6bd
jmp 0xc6dc
leaq 0x31c2(%rip), %rdi      # 0xf886
leaq 0x1a09(%rip), %rsi      # 0xe0d4
movl $0x32d, %edx            # imm = 0x32D
leaq 0x31b6(%rip), %rcx      # 0xf88d
callq 0x1070
jmp 0xc6de
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movabsq $-0x100000000000000, %rax # imm = 0xFF00000000000000
andq -0x28(%rbp), %rax
cmpq $0x0, %rax
jne 0xc718
movq -0x28(%rbp), %rax
shlq $0x8, %rax
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x2c(%rbp)
jmp 0xc6ed
jmp 0xc71a
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq -0x28(%rbp), %rax
cmpq $0x0, %rax
jne 0xc744
movq -0x28(%rbp), %rax
shlq %rax
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xc71a
movl -0x2c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x0, -0x1c(%rbp)
jbe 0xc791
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
shlq %cl, %rax
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
movl $0x40, %ecx
subq %rsi, %rcx
shrq %cl, %rdx
movq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x25e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: NKUSec[P]Rethinking-Honeywords/gen.cpp
// Function: printSegTrieNode(SegTable*, SegTrieNode*, char*, int)
void printSegTrieNode(SegTable* tb, SegTrieNode* node, char* path, int level)
{
	path[level] = node->c;
	if (node->count > 0)
	{
		int count = tb[level].cnt;
		for (int i = 1; i <= level; i++) tb[level].t[tb[level].cnt].w[i-1] = path[i];
		tb[level].t[count].cnt = node->count;
		tb[level].t[count].l = level;
		tb[level].cnt++;
		tb[level].sum += node->count;
	}
	SegTrieNode* tmpNode = node->firstSon;
	while (tmpNode != NULL)
	{
		printSegTrieNode(tb, tmpNode, path, level+1);
		tmpNode = tmpNode->rightBrother;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jle 0x1629
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl %eax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jg 0x15aa
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movslq -0x1c(%rbp), %rsi
imulq $0x18, %rsi, %rsi
addq %rsi, %rcx
movslq 0x4(%rcx), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, 0x8(%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1552
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq 0x10(%rax), %rax
movslq -0x20(%rbp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq 0x10(%rax), %rax
movslq -0x20(%rbp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x1661
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
callq 0x1500
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x1635
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: NKUSec[P]Rethinking-Honeywords/gen.cpp
// Function: printIntoSegTable(SegTable*, SegTrie*)
void printIntoSegTable(SegTable *tb, SegTrie* tree)
{
	char path[WORD_LEN];
	printSegTrieNode(tb, tree->root, path, 0);
	for (int i = 0; i < WORD_LEN; i++)
		sort(tb[i].t, tb[i].t+tb[i].cnt, stringCompare);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq -0x30(%rbp), %rdx
xorl %ecx, %ecx
callq 0x1500
movl $0x0, -0x34(%rbp)
cmpl $0x1e, -0x34(%rbp)
jge 0x16fa
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rsi
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq 0x4(%rax), %rax
imulq $0x28, %rax, %rax
addq %rax, %rsi
leaq -0x20a(%rip), %rdx      # 0x14e0
callq 0x27b0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x169d
addq $0x40, %rsp
popq %rbp
retq
// File: NKUSec[P]Rethinking-Honeywords/gen.cpp
// Function: gen_model_syntax(char*, int, char**)
void gen_model_syntax(char* pwd, int k, char** pwdset)
{
	char newpwd[WORD_LEN];
	strcpy(pwdset[0], pwd);
	for (int i = 1; i < k; i++)
	{
		gen(pwd, newpwd);
		strcpy(pwdset[i], newpwd);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x10a0
movl $0x1, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x222f
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1e20
movq -0x18(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq -0x40(%rbp), %rsi
callq 0x10a0
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x21fa
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: NKUSec[P]Rethinking-Honeywords/gen.cpp
// Function: shuffle(int*)
int shuffle(int* idx)
{
	int pos = 0;
	for (int i = 0; i < THRESHOLD_K; i++)
	{
		int r = get_random_int(i, THRESHOLD_K);
		int t = idx[r];
		idx[r] = idx[i];
		idx[i] = t;
	}
	for (int i = 0; i < THRESHOLD_K; i++)
		if (idx[i] == 0) {pos = i; break;}
	return pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x14, -0x10(%rbp)
jge 0x22ad
movl -0x10(%rbp), %edi
movl $0x14, %esi
callq 0x13d0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x225a
movl $0x0, -0x1c(%rbp)
cmpl $0x14, -0x1c(%rbp)
jge 0x22dd
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x22d0
movl -0x1c(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x22dd
jmp 0x22d2
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x22b4
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: NKUSec[P]Rethinking-Honeywords/gen.cpp
// Function: main
int main(int argc, char* argv[])
{
	if (argc != 2)
	{
		printf("gen parameters wrong!\n");
		return 0;
	}

	srand(time(NULL));

	char prefix[LINE_LEN], honeywords_file[LINE_LEN], checker_file[LINE_LEN];
	strcpy(prefix, argv[1]);
	int dotpos = strlen(prefix)-1;
	while (prefix[dotpos] != '.' && dotpos > 0) dotpos--;
	prefix[dotpos] = '\0';
	strcpy(honeywords_file, prefix);
	strcat(honeywords_file, "_honeywords.txt");
	strcpy(checker_file, prefix);
	strcat(checker_file, "_checker.txt");

	honeywords_gen_model_syntax(argv[1], honeywords_file, checker_file);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x49400, %rsp          # imm = 0x49400
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x25f9
leaq 0x1a51(%rip), %rdi      # 0x4037
movb $0x0, %al
callq 0x1040
movl $0x0, -0x4(%rbp)
jmp 0x26f9
xorl %eax, %eax
movl %eax, %edi
callq 0x1090
movl %eax, %edi
callq 0x10b0
leaq -0x186b0(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x10a0
leaq -0x186b0(%rbp), %rdi
callq 0x1060
subq $0x1, %rax
movl %eax, -0x493f4(%rbp)
movslq -0x493f4(%rbp), %rax
movsbl -0x186b0(%rbp,%rax), %ecx
xorl %eax, %eax
cmpl $0x2e, %ecx
movb %al, -0x493f5(%rbp)
je 0x265f
cmpl $0x0, -0x493f4(%rbp)
setg %al
movb %al, -0x493f5(%rbp)
movb -0x493f5(%rbp), %al
testb $0x1, %al
jne 0x266b
jmp 0x267c
movl -0x493f4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x493f4(%rbp)
jmp 0x2633
movslq -0x493f4(%rbp), %rax
movb $0x0, -0x186b0(%rbp,%rax)
leaq -0x30d50(%rbp), %rdi
leaq -0x186b0(%rbp), %rsi
callq 0x10a0
leaq -0x30d50(%rbp), %rdi
leaq 0x19a2(%rip), %rsi      # 0x404e
callq 0x1140
leaq -0x493f0(%rbp), %rdi
leaq -0x186b0(%rbp), %rsi
callq 0x10a0
leaq -0x493f0(%rbp), %rdi
leaq 0x198c(%rip), %rsi      # 0x405e
callq 0x1140
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x30d50(%rbp), %rsi
leaq -0x493f0(%rbp), %rdx
callq 0x22f0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x49400, %rsp          # imm = 0x49400
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: NKUSec[P]Rethinking-Honeywords/gen.cpp
// Function: SegTrie::insert(char*)
bool insert(char* str)
	{
		int l = strlen(str);
		SegTrieNode* curNode = root;
		SegTrieNode* tmpNode = NULL;
		for (int i = 0; i < l; i++)
		{
			tmpNode = curNode->firstSon;
			while (tmpNode != NULL)
			{
				if (tmpNode->c == str[i]) break;
				tmpNode = tmpNode->rightBrother;
			}
			if (tmpNode == NULL)
			{
				tmpNode = new SegTrieNode();
				tmpNode->c = str[i];
				tmpNode->rightBrother = curNode->firstSon;
				curNode->firstSon = tmpNode;
			}
			curNode = tmpNode;
		}
		bool f = true;
		if (curNode->count == 0) f = false;
		else f = true;
		curNode->count++;
		return f;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1060
movq %rax, %rcx
movq -0x48(%rbp), %rax
movl %ecx, -0x14(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2962
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x28d7
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
movq -0x10(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x28c9
jmp 0x28d7
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x28a9
cmpq $0x0, -0x28(%rbp)
jne 0x294c
movl $0x18, %edi
callq 0x10d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x2a00
jmp 0x28f9
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb (%rax,%rcx), %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x294c
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x18, %esi
callq 0x10e0
jmp 0x2992
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2891
movb $0x1, -0x3d(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x2976
movb $0x0, -0x3d(%rbp)
jmp 0x297a
movb $0x1, -0x3d(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movb -0x3d(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x1130
nopl (%rax,%rax)
// File: yinqiwen[P]coroxx/test1.cpp
// Function: ustime()
static long long ustime(void)
{
    struct timeval tv;
    long long ust;

    gettimeofday(&tv, NULL);
    ust = ((long long) tv.tv_sec) * 1000000;
    ust += tv.tv_usec;
    return ust;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2300
imulq $0xf4240, -0x10(%rbp), %rax # imm = 0xF4240
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2bc0
movl $0x1, -0x1c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x71b0
movl $0x0, -0x34(%rbp)
cmpl $0x3e8, -0x34(%rbp)     # imm = 0x3E8
jge 0x2686
leaq 0x71(%rip), %rsi        # 0x26b0
leaq -0x58(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x2c10
movq -0x70(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x74d0
jmp 0x265b
leaq -0x58(%rbp), %rdi
callq 0x2ca0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x262f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2ca0
jmp 0x2698
movl $0x64, %edi
callq 0x2170
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x2330
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
callq 0x7160
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0xc970(%rip), %rdi      # 0xf044
xorl %eax, %eax
movl %eax, -0x64(%rbp)
movb %al, -0x65(%rbp)
callq 0x2050
movl $0x7d0, %edi            # imm = 0x7D0
callq 0x75e0
movb -0x65(%rbp), %al
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rsi
leaq 0xc957(%rip), %rdi      # 0xf054
callq 0x2050
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
leaq -0x11(%rbp), %rsi
callq 0x2790
movl -0x64(%rbp), %eax
movq -0x60(%rbp), %rdi
movl %eax, %esi
callq 0x74d0
movq %rax, -0x58(%rbp)
jmp 0x2727
leaq -0x40(%rbp), %rdi
callq 0x2ca0
movq -0x58(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq 0xc92c(%rip), %rdi      # 0xf06f
movb $0x0, %al
callq 0x2050
movq -0x20(%rbp), %rdi
callq 0x7540
movq -0x20(%rbp), %rsi
leaq 0xc922(%rip), %rdi      # 0xf080
movb $0x0, %al
callq 0x2050
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2ca0
movq -0x48(%rbp), %rdi
callq 0x2330
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
addq $0x18, %rdi
movq %rdi, -0x38(%rbp)
callq 0x38d0
movq -0x30(%rbp), %rax
movb $0x0, 0x48(%rax)
movb $0x0, 0x49(%rax)
movq $0x0, 0x50(%rax)
movq $0x0, 0x58(%rax)
movq $0x0, 0x60(%rax)
movq 0x150f9(%rip), %rcx     # 0x18210
movq %rcx, %rdx
incq %rdx
movq %rdx, 0x150ec(%rip)     # 0x18210
movq %rcx, 0x10(%rax)
movq %rax, 0x40(%rax)
leaq 0x150ad(%rip), %rdi     # 0x181e0
callq 0x3910
jmp 0x313a
testb $0x1, -0x11(%rbp)
je 0x317a
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rsi
movq %r8, %rdx
movq %r8, %rcx
callq 0xe3d0
jmp 0x3159
movq -0x30(%rbp), %rax
movb $0x1, 0x48(%rax)
jmp 0x317a
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3970
jmp 0x318e
leaq 0x1505f(%rip), %rdi     # 0x181e0
callq 0x3940
jmp 0x3188
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2330
nopw (%rax,%rax)
// File: yinqiwen[P]coroxx/libcoro.cpp
// Function: coroxx::LibCoroCoroutine::SaveStackBuffer()
void LibCoroCoroutine::SaveStackBuffer()
    {
        if (NULL != stack && stack->shared && NULL != stack_sp)
        {
            if (NULL != save_buffer)
            {
                free(save_buffer);
            }
            save_buffer = malloc(save_buffer_size);
            memcpy(save_buffer, stack_sp, save_buffer_size);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
xorl %eax, %eax
cmpq 0x8(%rcx), %rax
je 0x3218
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x18(%rax)
je 0x3218
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq 0x60(%rcx), %rax
je 0x3218
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq 0x50(%rcx), %rax
je 0x31ef
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x2210
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x2250
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movq 0x50(%rax), %rdi
movq 0x60(%rax), %rsi
movq 0x58(%rax), %rdx
callq 0x21a0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: yinqiwen[P]coroxx/libcoro.cpp
// Function: coroxx::LibCoroCoroutine::ResumeStackBuffer()
void LibCoroCoroutine::ResumeStackBuffer()
    {
        if (NULL != save_buffer && NULL != stack && stack->shared)
        {
            memcpy(stack_sp, save_buffer, save_buffer_size);
            free(save_buffer);
            save_buffer = NULL;
            stack_sp = NULL;
            save_buffer_size = 0;

        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
xorl %eax, %eax
cmpq 0x50(%rcx), %rax
je 0x3294
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq 0x8(%rcx), %rax
je 0x3294
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x18(%rax)
je 0x3294
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
movq 0x50(%rax), %rsi
movq 0x58(%rax), %rdx
callq 0x21a0
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x2210
movq -0x10(%rbp), %rax
movq $0x0, 0x50(%rax)
movq $0x0, 0x60(%rax)
movq $0x0, 0x58(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: yinqiwen[P]coroxx/libcoro.cpp
// Function: coroxx::LibCoroCoroutine::MarkStackResumePoint()
void LibCoroCoroutine::MarkStackResumePoint()
    {
        if (NULL != stack && stack->shared)
        {
            char c;
            stack_sp = &c;
            save_buffer_size = ((char*) stack->stack.sptr + stack->stack.ssze) - stack_sp;
            //printf("###[%d, %lld]Save buffer size:%lld\n", id, stack->stack.ssze, save_buffer_size);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
xorl %eax, %eax
cmpq 0x8(%rcx), %rax
je 0x32ec
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x18(%rax)
je 0x32ec
movq -0x18(%rbp), %rax
leaq -0x9(%rbp), %rcx
movq %rcx, 0x60(%rax)
movq 0x8(%rax), %rcx
movq (%rcx), %rcx
movq 0x8(%rax), %rdx
addq 0x8(%rdx), %rcx
movq 0x60(%rax), %rdx
subq %rdx, %rcx
movq %rcx, 0x58(%rax)
popq %rbp
retq
nop
// File: yinqiwen[P]coroxx/libcoro.cpp
// Function: coroxx::LibCoroCoroutine::~LibCoroCoroutine()
LibCoroCoroutine::~LibCoroCoroutine()
    {
        if (NULL != stack)
        {
            if (stack->shared)
            {
                if (stack->coro == this)
                {
                    stack->coro = NULL;
                }
            }
            else
            {
                delete stack;
            }
        }
        if (NULL != save_buffer)
        {
            free(save_buffer);
        }
        coro_destroy(&ctx);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
xorl %eax, %eax
cmpq 0x8(%rcx), %rax
je 0x3367
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x18(%rax)
je 0x333a
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
cmpq %rcx, 0x10(%rax)
jne 0x3338
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x10(%rax)
jmp 0x3365
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x3363
movq -0x18(%rbp), %rdi
callq 0x3990
movq -0x18(%rbp), %rdi
movl $0x20, %esi
callq 0x21e0
jmp 0x3365
jmp 0x3367
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq 0x50(%rcx), %rax
je 0x3380
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x2210
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x3970
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yinqiwen[P]coroxx/libcoro.cpp
// Function: coroxx::LibCoroCoroutine::Yield(bool)
void LibCoroCoroutine::Yield(bool release_current)
    {
        CoroutineStack& coro_stack = getCoroEnv().coro_stack;
        LibCoroCoroutine* next = getCoroEnv().main;
        if (!coro_stack.empty())
        {
            next = coro_stack.top();
            coro_stack.pop();
        }
        next->Resume(release_current);

    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
callq 0x3440
addq $0x10, %rax
movq %rax, -0x18(%rbp)
callq 0x3440
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x39c0
testb $0x1, %al
jne 0x3424
movq -0x18(%rbp), %rdi
callq 0x39e0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3a00
movq -0x20(%rbp), %rdi
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x3460
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: yinqiwen[P]coroxx/libcoro.cpp
// Function: coroxx::swapCoroFunc(void*)
static void swapCoroFunc(void* data)
    {
        while (1)
        {
            CoroEnv& coro_env = getCoroEnv();
            SwapContext& swap = coro_env.swap_ctx;
            swap.from->SaveStackBuffer();
            swap.to->ResumeStackBuffer();

            //printf("####%d resumex %d\n", swap.to->id,coro_env.current->id);
            coro_env.current = swap.to;
            coro_transfer(&(swap.swap_coro), &(swap.to->ctx));
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x3440
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x31a0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3220
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xe3b0
jmp 0x379c
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yinqiwen[P]coroxx/./thread_mutex.h
// Function: coroxx::ThreadMutex::ThreadMutex(int)
ThreadMutex(int type = PTHREAD_MUTEX_DEFAULT)
			{
				pthread_mutexattr_t attr;
				pthread_mutexattr_init(&attr);
				pthread_mutexattr_settype(&attr, type);
				pthread_mutex_init(&m_mutex, &attr);
				pthread_mutexattr_destroy(&attr);
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x1447a(%rip), %rcx     # 0x17cd8
addq $0x10, %rcx
movq %rcx, (%rax)
leaq -0x10(%rbp), %rdi
callq 0x2060
movl -0xc(%rbp), %esi
leaq -0x10(%rbp), %rdi
callq 0x2280
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq -0x10(%rbp), %rsi
callq 0x22a0
leaq -0x10(%rbp), %rdi
callq 0x2290
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: yinqiwen[P]coroxx/libcoro.cpp
// Function: coroxx::CoroEnv::GetCoroStack()
CoroStack* GetCoroStack()
            {
                if (share_stack_pool.size() < share_stack_count)
                {
                    CoroStack* s = new CoroStack(stack_size, true);
                    share_stack_pool.pool.push_back(s);
                    return s;
                }
                if (share_stack_pool.pool.empty())
                {
                    return new CoroStack(stack_size, false);
                }
                size_t idx = share_stack_pool.cursor;
                if (idx >= share_stack_pool.size())
                {
                    idx = 0;
                    share_stack_pool.cursor = 0;
                }
                share_stack_pool.cursor++;
                return share_stack_pool.pool[idx];
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x60, %rdi
callq 0x4c80
movq -0x38(%rbp), %rcx
movl 0xb4(%rcx), %ecx
cmpq %rcx, %rax
jae 0x3aeb
movl $0x20, %edi
callq 0x21d0
movq %rax, %rdi
movq -0x38(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x40(%rbp)
movl 0xb0(%rax), %esi
movl $0x1, %edx
callq 0x4ca0
jmp 0x3aa6
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
addq $0x60, %rdi
leaq -0x18(%rbp), %rsi
callq 0x4ce0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3bac
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x20, %esi
callq 0x21e0
jmp 0x3bb6
movq -0x38(%rbp), %rdi
addq $0x60, %rdi
callq 0x4d50
testb $0x1, %al
jne 0x3afe
jmp 0x3b4b
movl $0x20, %edi
callq 0x21d0
movq %rax, %rdi
movq -0x38(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x48(%rbp)
movl 0xb0(%rax), %esi
xorl %edx, %edx
callq 0x4ca0
jmp 0x3b25
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3bac
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x20, %esi
callq 0x21e0
jmp 0x3bb6
movq -0x38(%rbp), %rdi
movq 0x78(%rdi), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0x60, %rdi
callq 0x4c80
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jb 0x3b88
movq -0x38(%rbp), %rax
movq $0x0, -0x30(%rbp)
movq $0x0, 0x78(%rax)
movq -0x38(%rbp), %rdi
movq 0x78(%rdi), %rax
addq $0x1, %rax
movq %rax, 0x78(%rdi)
addq $0x60, %rdi
movq -0x30(%rbp), %rsi
callq 0x4d90
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2330
nop
// File: yinqiwen[P]coroxx/libcoro.cpp
// Function: coroxx::SwapContext::Init()
void Init()
            {
                if (inited)
                {
                    return;
                }
                coro_stack_alloc(&swap_stack, 0);
                coro_create(&swap_coro, swapCoroFunc, NULL, swap_stack.sptr, swap_stack.ssze);
                inited = true;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x28(%rax)
je 0x3bdc
jmp 0x3c16
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
xorl %esi, %esi
callq 0xe4f0
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x10, %rdi
movq 0x18(%rax), %rcx
movq 0x20(%rax), %r8
leaq -0x475(%rip), %rsi      # 0x3790
xorl %eax, %eax
movl %eax, %edx
callq 0xe3d0
movq -0x10(%rbp), %rax
movb $0x1, 0x28(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: yinqiwen[P]coroxx/./thread_local.h
// Function: coroxx::ThreadLocal<coroxx::CoroEnv>::GetValue()
T& GetValue()
			{
				T* local_thread_value = static_cast<T*>(pthread_getspecific(
				        m_key));
				if (NULL == local_thread_value)
				{
					T* newObj = InitialValue();
					pthread_setspecific(m_key, newObj);
					local_thread_value = newObj;
				}
				return *local_thread_value;
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl (%rax), %edi
callq 0x22c0
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x3cde
movq -0x20(%rbp), %rdi
callq 0x3cf0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movl (%rax), %edi
movq -0x18(%rbp), %rsi
callq 0x2080
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::Scheduler::RunFunc(void*)
void* Scheduler::RunFunc(void* data)
    {
        Scheduler* s = (Scheduler*) data;
        s->Run();
        delete s;
        return NULL;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60b0
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x60a2
movq -0x18(%rbp), %rdi
callq 0x76f0
movq -0x18(%rbp), %rdi
movl $0x208, %esi            # imm = 0x208
callq 0x21e0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::Scheduler::Run()
void Scheduler::Run()
    {
        g_current_scheduler.SetValue(this);
        InitCoroPool();
        sched_coro = new CoroType(options);
        sched_coro->ResetContext(Scheduler::RoutineFunc, this);
        sched_coro->Resume();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x48(%rbp)
leaq 0x1214d(%rip), %rdi     # 0x18218
callq 0x7770
movq -0x48(%rbp), %rdi
callq 0x6240
movl $0x68, %edi
callq 0x21d0
movq -0x48(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
addq $0x1e0, %rsi            # imm = 0x1E0
xorl %edx, %edx
callq 0x30b0
jmp 0x6101
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x1c8(%rax)
movq 0x1c8(%rax), %rax
movq %rax, -0x58(%rbp)
leaq 0x5de(%rip), %rsi       # 0x6700
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x2c10
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x7be0
jmp 0x6142
leaq -0x38(%rbp), %rdi
callq 0x2ca0
movq -0x48(%rbp), %rax
movq 0x1c8(%rax), %rdi
xorl %esi, %esi
callq 0x3460
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x68, %esi
callq 0x21e0
jmp 0x6194
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2ca0
movq -0x10(%rbp), %rdi
callq 0x2330
nopl (%rax)
// File: yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::Scheduler::Start()
int Scheduler::Start()
    {
        options.share_stack = CoroType::NewShareStack(options.share_stack_count, options.max_stack_size);
        if (options.create_thread)
        {
            pthread_attr_t attr;
            pthread_attr_init(&attr);
            if (0 != pthread_create(&tid, &attr, RunFunc, this))
            {
                return errno;
            }
        }
        else
        {
            g_current_scheduler.SetValue(this);
            InitCoroPool();
        }
        return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl 0x1f4(%rax), %edi
movl 0x1e4(%rax), %esi
callq 0x3750
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x200(%rax)
testb $0x1, 0x1e0(%rax)
je 0x6216
leaq -0x48(%rbp), %rdi
callq 0x2230
movq -0x50(%rbp), %rcx
movq %rcx, %rdi
addq $0x70, %rdi
leaq -0x48(%rbp), %rsi
leaq -0x19b(%rip), %rdx      # 0x6060
callq 0x2350
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x6214
callq 0x2040
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x6236
jmp 0x622f
movq -0x50(%rbp), %rsi
leaq 0x11ff7(%rip), %rdi     # 0x18218
callq 0x7770
movq -0x50(%rbp), %rdi
callq 0x6240
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::Scheduler::GetCoroutineById(unsigned long)
CoroPtr Scheduler::GetCoroutineById(coro_id id)
    {
        CoroutineTable::iterator found = exec_table.find(id);
        if (found == exec_table.end())
        {
            return NULL;
        }
        return found->second;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x38, %rdi
leaq -0x18(%rbp), %rsi
callq 0x77a0
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x38, %rdi
callq 0x7800
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x77d0
testb $0x1, %al
jne 0x634d
jmp 0x6357
movq $0x0, -0x8(%rbp)
jmp 0x6368
leaq -0x20(%rbp), %rdi
callq 0x7830
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::Scheduler::CheckTimeQueue()
int64_t Scheduler::CheckTimeQueue()
    {
        while (!coro_time_queue.empty())
        {
            TimeCoroDiaptchDataQueue::iterator it = coro_time_queue.begin();
            CoroDiaptchDataQueue& queue = it->second;
            int64_t ts = it->first;
            int64_t now = currentMills();
            if (now < ts)
            {
                return ts - now;
            }
            //printf("###time queue size:%d\n", queue.size());
            for (size_t i = 0; i < queue.size(); i++)
            {
                CoroDiaptchData* data = queue[i];
                data->Invoke();
            }
            coro_time_queue.erase(it);
        }
        return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
addq $0xc8, %rdi
callq 0x7860
xorb $-0x1, %al
testb $0x1, %al
jne 0x63af
jmp 0x647a
movq -0x58(%rbp), %rdi
addq $0xc8, %rdi
callq 0x7880
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x78b0
addq $0x8, %rax
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x78b0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x6490
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x6405
movq -0x28(%rbp), %rax
subq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6482
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rdi
callq 0x78d0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x6455
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x7900
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x7930
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x640d
movq -0x58(%rbp), %rdi
addq $0xc8, %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
callq 0x79b0
movq %rax, -0x50(%rbp)
jmp 0x6394
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::currentMills()
static int64_t currentMills()
    {
        struct timeval timeValue;
        gettimeofday(&timeValue, NULL);
        int64_t ts = ((int64_t) timeValue.tv_sec) * 1000;
        ts += ((timeValue.tv_usec) / 1000);
        return ts;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2300
imulq $0x3e8, -0x10(%rbp), %rax # imm = 0x3E8
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::Scheduler::InvokeQueueSize()
uint32_t Scheduler::InvokeQueueSize()
    {
        uint32_t n = 0;
        coro_queue_mutex.Lock();
        n = coro_queue.size();
        coro_queue_mutex.Unlock();
        return n;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
addq $0xf8, %rdi
callq 0x79f0
movq -0x18(%rbp), %rdi
addq $0x78, %rdi
callq 0x78d0
movq -0x18(%rbp), %rdi
movl %eax, -0xc(%rbp)
addq $0xf8, %rdi
callq 0x7a20
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::Scheduler::Routine(bool)
void Scheduler::Routine(bool wait)
    {
        CoroGC();
        while (1)
        {
            CoroDiaptchData* data = NULL;
            {
                coro_queue_mutex.Lock();
                if ((coro_queue.empty()) && wait)
                {
                    if (routine_wait_ms <= 0 || routine_wait_ms > 100)
                    {
                        routine_wait_ms = 10;
                    }
                    //printf("###before wait %d %lld\n", routine_wait_ms, nowMs());
                    coro_queue_mutex.Wait(routine_wait_ms);
                    //printf("###after wait %d %lld %d\n", routine_wait_ms, nowMs(), v);
                }
                if (!coro_queue.empty())
                {
                    data = coro_queue.front();
                    coro_queue.pop_front();
                }
                coro_queue_mutex.Unlock();
            }

            if (NULL == data)
            {
                routine_wait_ms = CheckTimeQueue();
                return;
            }
            else
            {
                data->Invoke();
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x6640
movq -0x20(%rbp), %rdi
movq $0x0, -0x18(%rbp)
addq $0xf8, %rdi
callq 0x79f0
movq -0x20(%rbp), %rdi
addq $0x78, %rdi
callq 0x7a50
testb $0x1, %al
jne 0x657c
jmp 0x65c7
testb $0x1, -0x9(%rbp)
je 0x65c7
movq -0x20(%rbp), %rax
cmpq $0x0, 0x1d0(%rax)
jle 0x659e
movq -0x20(%rbp), %rax
cmpq $0x64, 0x1d0(%rax)
jle 0x65ad
movq -0x20(%rbp), %rax
movq $0xa, 0x1d0(%rax)
movq -0x20(%rbp), %rax
movq %rax, %rdi
addq $0xf8, %rdi
movq 0x1d0(%rax), %rsi
callq 0x7a80
movq -0x20(%rbp), %rdi
addq $0x78, %rdi
callq 0x7a50
testb $0x1, %al
jne 0x65f9
movq -0x20(%rbp), %rdi
addq $0x78, %rdi
callq 0x7b40
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x18(%rbp)
addq $0x78, %rdi
callq 0x7b70
movq -0x20(%rbp), %rdi
addq $0xf8, %rdi
callq 0x7a20
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x662e
movq -0x20(%rbp), %rdi
callq 0x6380
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x1d0(%rax)
addq $0x20, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x7930
jmp 0x6551
nopl (%rax)
// File: yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::Scheduler::CoroGC()
void Scheduler::CoroGC()
    {
        if(!deleting_coros.empty())
        {
            for (size_t i = 0; i < deleting_coros.size(); i++)
            {
                delete deleting_coros[i];
            }
            deleting_coros.clear();
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x160, %rdi            # imm = 0x160
callq 0x7ea0
testb $0x1, %al
jne 0x66ec
movq $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x160, %rdi            # imm = 0x160
callq 0x7ee0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x66dc
movq -0x18(%rbp), %rdi
addq $0x160, %rdi            # imm = 0x160
movq -0x10(%rbp), %rsi
callq 0x7f00
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x66cc
movq -0x28(%rbp), %rdi
callq 0x32f0
movq -0x28(%rbp), %rdi
movl $0x68, %esi
callq 0x21e0
jmp 0x66ce
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x6670
movq -0x18(%rbp), %rdi
addq $0x160, %rdi            # imm = 0x160
callq 0x7f20
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)