LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/cg.c
// Function: cgfuncpreamble
void cgfuncpreamble(struct symtable *sym) {
  char *name = sym->name;
  struct symtable *parm, *locvar;
  int cnt;
  int paramOffset = 16;		// 超过6个的那部分参数所在栈的开始位置
  int paramReg = FIRSTPARAMREG;	// 上面参数寄存器列表的索引

  // 输出text段，重设本地变量位移
  cgtextseg();
  localOffset = 0;

  // 输出函数开始标签，保存%rbp 和 %rsp
  if (sym->class == C_GLOBAL)
    fprintf(Outfile, "\t.globl\t%s\n" "\t.type\t%s, @function\n", name, name);
  fprintf(Outfile, "%s:\n" "\tpushq\t%%rbp\n" "\tmovq\t%%rsp, %%rbp\n", name);

  // 拷贝在寄存器里面的参数到栈
  // 如果大于6个参数都已经在栈了
  for (parm = sym->member, cnt = 1; parm != NULL; parm = parm->next, cnt++) {
    if (cnt > 6) {
      parm->stu.st_posn = paramOffset;
      paramOffset += 8;
    } else {
      parm->stu.st_posn = newlocaloffset(parm->size);
      cgstorlocal(paramReg--, parm);
    }
  }

  // 计算本地变量的栈位置
  for (locvar = Loclhead; locvar != NULL; locvar = locvar->next) {
    locvar->stu.st_posn = newlocaloffset(locvar->size);
  }

  // 对齐栈指针到16的倍数
  stackOffset = (localOffset + 15) & ~15;
  fprintf(Outfile, "\taddq\t$%d,%%rsp\n", -stackOffset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
callq 0x22bc
andl $0x0, 0xbde4(%rip)      # 0xe344
cmpl $0x1, 0x24(%rbx)
jne 0x2584
leaq 0xbe1b(%rip), %rax      # 0xe388
movq (%rax), %rdi
leaq 0x6cd4(%rip), %rsi      # 0x924b
movq %r14, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x2100
leaq 0xbdfd(%rip), %rax      # 0xe388
movq (%rax), %rdi
leaq 0x6cd7(%rip), %rsi      # 0x926c
movq %r14, %rdx
xorl %eax, %eax
callq 0x2100
addq $0x40, %rbx
pushq $0x9
popq %rdi
pushq $0x10
popq %r12
pushq $0x1
popq %r13
pushq $0x4
popq %r14
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x25fb
cmpl $0x7, %r13d
jb 0x25c9
movl %r12d, (%rbx)
addl $0x8, %r12d
jmp 0x25f2
movl 0x28(%rbx), %eax
cmpl $0x5, %eax
cmovll %r14d, %eax
addl 0xbd6b(%rip), %eax      # 0xe344
movl %eax, 0xbd65(%rip)      # 0xe344
negl %eax
movl %eax, (%rbx)
leal -0x1(%rdi), %r15d
movq %rbx, %rsi
callq 0x2662
movl %r15d, %edi
addq $0x38, %rbx
incl %r13d
jmp 0x25b2
leaq 0xbfee(%rip), %rax      # 0xe5f0
movl 0xbd3c(%rip), %edx      # 0xe344
movq (%rax), %rax
testq %rax, %rax
je 0x262e
movl 0x28(%rax), %ecx
cmpl $0x5, %ecx
cmovll %r14d, %ecx
addl %ecx, %edx
movl %edx, 0xbd22(%rip)      # 0xe344
movl %edx, %ecx
negl %ecx
movl %ecx, (%rax)
addq $0x38, %rax
jmp 0x2608
addl $0xf, %edx
andl $-0x10, %edx
movl %edx, 0xbd0e(%rip)      # 0xe348
leaq 0xbd47(%rip), %rax      # 0xe388
movq (%rax), %rdi
negl %edx
leaq 0x6c44(%rip), %rsi      # 0x9291
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/cg.c
// Function: cgstorlocal
int cgstorlocal(int r, struct symtable *sym) {

  if (cgprimsize(sym->type) == 8) {
    fprintf(Outfile, "\tmovq\t%s, %d(%%rbp)\n", reglist[r], sym->stu.st_posn);
  } else
    switch (sym->type) {
    case P_CHAR:
      fprintf(Outfile, "\tmovb\t%s, %d(%%rbp)\n", breglist[r], sym->stu.st_posn);
      break;
    case P_INT:
      fprintf(Outfile, "\tmovl\t%s, %d(%%rbp)\n", dreglist[r], sym->stu.st_posn);
      break;
    default:
      fatald("Bad type in cgstorlocal:", sym->type);
    }
  return (r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebx
movl 0x10(%rsi), %edi
callq 0x231a
cmpl $0x8, %eax
jne 0x269f
leaq 0xbd06(%rip), %rax      # 0xe388
movq (%rax), %rdi
movslq %ebx, %rax
leaq 0xb661(%rip), %rcx      # 0xdcf0
movq (%rcx,%rax,8), %rdx
movl (%r14), %ecx
leaq 0x6eea(%rip), %rsi      # 0x9587
jmp 0x26f3
movl 0x10(%r14), %esi
cmpl $0x30, %esi
je 0x26d1
cmpl $0x20, %esi
jne 0x2701
leaq 0xbcd4(%rip), %rax      # 0xe388
movq (%rax), %rdi
movslq %ebx, %rax
leaq 0xb67f(%rip), %rcx      # 0xdd40
movq (%rcx,%rax,8), %rdx
movl (%r14), %ecx
leaq 0x6ecd(%rip), %rsi      # 0x959c
jmp 0x26f3
leaq 0xbcb0(%rip), %rax      # 0xe388
movq (%rax), %rdi
movslq %ebx, %rax
leaq 0xb6ab(%rip), %rcx      # 0xdd90
movq (%rcx,%rax,8), %rdx
movl (%r14), %ecx
leaq 0x6ebe(%rip), %rsi      # 0x95b1
xorl %eax, %eax
callq 0x2100
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6ebe(%rip), %rdi      # 0x95c6
callq 0x656d
jmp 0x26fa
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/cg.c
// Function: cgfuncpostamble
void cgfuncpostamble(struct symtable *sym) {
  cglabel(sym->stu.st_endlabel);
  fprintf(Outfile, "\taddq\t$%d,%%rsp\n", stackOffset);
  fputs("\tpopq	%rbp\n" "\tret\n", Outfile);
  cgfreeallregs(NOREG);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl (%rdi), %edi
callq 0x2757
leaq 0xbc65(%rip), %rbx      # 0xe388
movq (%rbx), %rdi
movl 0xbc1c(%rip), %edx      # 0xe348
leaq 0x6b5e(%rip), %rsi      # 0x9291
xorl %eax, %eax
callq 0x2100
movq (%rbx), %rsi
leaq 0x6b5e(%rip), %rdi      # 0x92a2
callq 0x20c0
pushq $-0x1
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2373
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/cg.c
// Function: cgloadint
int cgloadint(int value, int type) {
  // 分配一个新的寄存器
  int r = cgallocreg();

  fprintf(Outfile, "\tmovq\t$%d, %s\n", value, reglist[r]);
  return (r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
callq 0x23a0
leaq 0xbbfd(%rip), %rcx      # 0xe388
movq (%rcx), %rdi
movslq %eax, %r14
leaq 0xb558(%rip), %rax      # 0xdcf0
movq (%rax,%r14,8), %rcx
leaq 0x6b10(%rip), %rsi      # 0x92b3
movl %ebx, %edx
xorl %eax, %eax
callq 0x2100
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/cg.c
// Function: cgloadglobstr
int cgloadglobstr(int label) {
  // 分配一个新的寄存器
  int r = cgallocreg();
  fprintf(Outfile, "\tleaq\tL%d(%%rip), %s\n", label, reglist[r]);
  return (r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
callq 0x23a0
leaq 0xb8db(%rip), %rcx      # 0xe388
movq (%rcx), %rdi
movslq %eax, %r14
leaq 0xb236(%rip), %rax      # 0xdcf0
movq (%rax,%r14,8), %rcx
leaq 0x68dd(%rip), %rsi      # 0x93a2
movl %ebx, %edx
xorl %eax, %eax
callq 0x2100
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/cg.c
// Function: cgdivmod
int cgdivmod(int r1, int r2, int op) {
  fprintf(Outfile, "\tmovq\t%s,%%rax\n", reglist[r1]);
  fprintf(Outfile, "\tcqo\n");
  fprintf(Outfile, "\tidivq\t%s\n", reglist[r2]);
  if (op == A_DIVIDE)
    fprintf(Outfile, "\tmovq\t%%rax,%s\n", reglist[r1]);
  else
    fprintf(Outfile, "\tmovq\t%%rdx,%s\n", reglist[r1]);
  cgfreereg(r2);
  return (r1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %r12d
leaq 0xb7c5(%rip), %r13      # 0xe388
movq (%r13), %rax
movslq %edi, %rbx
leaq 0xb11f(%rip), %rcx      # 0xdcf0
movq (%rcx,%rbx,8), %r14
leaq 0x6807(%rip), %rsi      # 0x93e3
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2100
movq (%r13), %rcx
leaq 0x67ff(%rip), %rdi      # 0x93f3
pushq $0x5
popq %rsi
pushq $0x1
popq %rdx
callq 0x2180
movq (%r13), %rdi
movslq %r12d, %r12
leaq 0xb0e3(%rip), %rax      # 0xdcf0
movq (%rax,%r12,8), %rdx
leaq 0x67e1(%rip), %rsi      # 0x93f9
xorl %eax, %eax
callq 0x2100
cmpl $0x18, %r15d
movq (%r13), %rdi
leaq 0x67d6(%rip), %rax      # 0x9404
leaq 0x67df(%rip), %rsi      # 0x9414
cmoveq %rax, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2100
movl %r12d, %edi
callq 0x241e
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/cg.c
// Function: cgshl
int cgshl(int r1, int r2) {
  fprintf(Outfile, "\tmovb\t%s, %%cl\n", breglist[r2]);
  fprintf(Outfile, "\tshlq\t%%cl, %s\n", reglist[r1]);
  cgfreereg(r2);
  return (r1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0xb647(%rip), %r15      # 0xe388
movq (%r15), %rdi
movslq %esi, %r14
leaq 0xaff2(%rip), %rax      # 0xdd40
movq (%rax,%r14,8), %rdx
leaq 0x66f4(%rip), %rsi      # 0x944d
xorl %eax, %eax
callq 0x2100
movq (%r15), %rdi
movslq %ebx, %rbx
leaq 0xaf83(%rip), %rax      # 0xdcf0
movq (%rax,%rbx,8), %rdx
leaq 0x66e5(%rip), %rsi      # 0x945d
xorl %eax, %eax
callq 0x2100
movl %r14d, %edi
callq 0x241e
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/cg.c
// Function: cgshr
int cgshr(int r1, int r2) {
  fprintf(Outfile, "\tmovb\t%s, %%cl\n", breglist[r2]);
  fprintf(Outfile, "\tshrq\t%%cl, %s\n", reglist[r1]);
  cgfreereg(r2);
  return (r1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0xb5e1(%rip), %r15      # 0xe388
movq (%r15), %rdi
movslq %esi, %r14
leaq 0xaf8c(%rip), %rax      # 0xdd40
movq (%rax,%r14,8), %rdx
leaq 0x668e(%rip), %rsi      # 0x944d
xorl %eax, %eax
callq 0x2100
movq (%r15), %rdi
movslq %ebx, %rbx
leaq 0xaf1d(%rip), %rax      # 0xdcf0
movq (%rax,%rbx,8), %rdx
leaq 0x668f(%rip), %rsi      # 0x946d
xorl %eax, %eax
callq 0x2100
movl %r14d, %edi
callq 0x241e
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/cg.c
// Function: cglognot
int cglognot(int r) {
  fprintf(Outfile, "\ttest\t%s, %s\n", reglist[r], reglist[r]);
  fprintf(Outfile, "\tsete\t%s\n", breglist[r]);
  fprintf(Outfile, "\tmovzbq\t%s, %s\n", breglist[r], reglist[r]);
  return (r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0xb50c(%rip), %r12      # 0xe388
movq (%r12), %rax
movslq %edi, %rbx
leaq 0xae66(%rip), %rcx      # 0xdcf0
movq (%rcx,%rbx,8), %r14
leaq 0x65fc(%rip), %rsi      # 0x9491
movq %rax, %rdi
movq %r14, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x2100
movq (%r12), %rdi
leaq 0xae90(%rip), %rax      # 0xdd40
movq (%rax,%rbx,8), %r15
leaq 0x65e4(%rip), %rsi      # 0x949f
movq %r15, %rdx
xorl %eax, %eax
callq 0x2100
movq (%r12), %rdi
leaq 0x65d9(%rip), %rsi      # 0x94a9
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x2100
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/cg.c
// Function: cgboolean
int cgboolean(int r, int op, int label) {
  fprintf(Outfile, "\ttest\t%s, %s\n", reglist[r], reglist[r]);
  switch (op) {
  case A_IF:
  case A_WHILE:
  case A_LOGAND:
    fprintf(Outfile, "\tje\tL%d\n", label);
    break;
  case A_LOGOR:
    fprintf(Outfile, "\tjne\tL%d\n", label);
    break;
  default:
    fprintf(Outfile, "\tsetnz\t%s\n", breglist[r]);
    fprintf(Outfile, "\tmovzbq\t%s, %s\n", breglist[r], reglist[r]);
  }
  return (r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %r12d
movl %edi, %ebx
leaq 0xb453(%rip), %rax      # 0xe388
movq (%rax), %rdi
movslq %ebx, %r13
leaq 0xadae(%rip), %rax      # 0xdcf0
movq (%rax,%r13,8), %r15
leaq 0x6544(%rip), %rsi      # 0x9491
movq %r15, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x2100
leal -0x1e(%r12), %eax
cmpl $0x2, %eax
jb 0x2f70
cmpl $0x8, %r12d
je 0x2f83
cmpl $0x9, %r12d
jne 0x2faf
leaq 0xb411(%rip), %rax      # 0xe388
movq (%rax), %rdi
leaq 0x6538(%rip), %rsi      # 0x94b9
jmp 0x2f94
leaq 0xb3fe(%rip), %rax      # 0xe388
movq (%rax), %rdi
leaq 0x652e(%rip), %rsi      # 0x94c2
movl %r14d, %edx
xorl %eax, %eax
callq 0x2100
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb3d2(%rip), %r12      # 0xe388
movq (%r12), %rdi
leaq 0xad7f(%rip), %rax      # 0xdd40
movq (%rax,%r13,8), %r14
leaq 0x6500(%rip), %rsi      # 0x94cc
movq %r14, %rdx
xorl %eax, %eax
callq 0x2100
movq (%r12), %rdi
leaq 0x64c8(%rip), %rsi      # 0x94a9
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x2100
jmp 0x2f9e
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/cg.c
// Function: cgcall
int cgcall(struct symtable *sym, int numargs) {
  int outr;

  // 调用函数
  fprintf(Outfile, "\tcall\t%s@PLT\n", sym->name);

  // 删除之前入栈的实参
  if (numargs > 6)
    fprintf(Outfile, "\taddq\t$%d, %%rsp\n", 8 * (numargs - 6));

  // 恢复之前入栈的寄存器
  cgunspillregs();

  // 获取一个新的寄存器,拷贝返回值给他
  outr = cgallocreg();
  fprintf(Outfile, "\tmovq\t%%rax, %s\n", reglist[outr]);
  return (outr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
leaq 0xb388(%rip), %r14      # 0xe388
movq (%r14), %rax
movq 0x8(%rdi), %rdx
leaq 0x64c9(%rip), %rsi      # 0x94d7
movq %rax, %rdi
xorl %eax, %eax
callq 0x2100
cmpl $0x7, %ebx
jl 0x3035
movq (%r14), %rdi
leal -0x30(,%rbx,8), %edx
leaq 0x64b7(%rip), %rsi      # 0x94e5
xorl %eax, %eax
callq 0x2100
pushq $0x3
popq %rbx
testl %ebx, %ebx
js 0x3047
movl %ebx, %edi
callq 0x246c
decl %ebx
jmp 0x3038
callq 0x23a0
movq (%r14), %rdi
movslq %eax, %rbx
leaq 0xac97(%rip), %rax      # 0xdcf0
movq (%rax,%rbx,8), %rdx
leaq 0x6493(%rip), %rsi      # 0x94f7
xorl %eax, %eax
callq 0x2100
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/cg.c
// Function: cgcopyarg
void cgcopyarg(int r, int argposn) {

  // 如果实参数量大于6个,那就把大于的都压入栈中
  if (argposn > 6) {
    fprintf(Outfile, "\tpushq\t%s\n", reglist[r]);
  } else {
    // 否则把实参值拷贝到指定的寄存器
    fprintf(Outfile, "\tmovq\t%s, %s\n", reglist[r],
	    reglist[FIRSTPARAMREG - argposn + 1]);
  }
  cgfreereg(r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0xb307(%rip), %rax      # 0xe388
movq (%rax), %rdi
movslq %ebx, %rcx
leaq 0xac62(%rip), %rax      # 0xdcf0
movq (%rax,%rcx,8), %rdx
cmpl $0x7, %esi
jl 0x30a7
leaq 0x646a(%rip), %rsi      # 0x9508
xorl %eax, %eax
callq 0x2100
jmp 0x30be
pushq $0xa
popq %rcx
subl %esi, %ecx
movq (%rax,%rcx,8), %rcx
leaq 0x645c(%rip), %rsi      # 0x9513
xorl %eax, %eax
callq 0x2100
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x241e
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/cg.c
// Function: cgstorglob
int cgstorglob(int r, struct symtable *sym) {

  if (cgprimsize(sym->type) == 8) {
    fprintf(Outfile, "\tmovq\t%s, %s(%%rip)\n", reglist[r], sym->name);
  } else
    switch (sym->type) {
    case P_CHAR:
      fprintf(Outfile, "\tmovb\t%s, %s(%%rip)\n", breglist[r], sym->name);
      break;
    case P_INT:
      fprintf(Outfile, "\tmovl\t%s, %s(%%rip)\n", dreglist[r], sym->name);
      break;
    default:
      fatald("Bad type in cgstorglob:", sym->type);
    }
  return (r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebx
movl 0x10(%rsi), %edi
callq 0x231a
cmpl $0x8, %eax
jne 0x3143
leaq 0xb263(%rip), %rax      # 0xe388
movq (%rax), %rdi
movslq %ebx, %rax
leaq 0xabbe(%rip), %rcx      # 0xdcf0
movq (%rcx,%rax,8), %rdx
movq 0x8(%r14), %rcx
leaq 0x63ef(%rip), %rsi      # 0x9530
jmp 0x3199
movl 0x10(%r14), %esi
cmpl $0x30, %esi
je 0x3176
cmpl $0x20, %esi
jne 0x31a7
leaq 0xb230(%rip), %rax      # 0xe388
movq (%rax), %rdi
movslq %ebx, %rax
leaq 0xabdb(%rip), %rcx      # 0xdd40
movq (%rcx,%rax,8), %rdx
movq 0x8(%r14), %rcx
leaq 0x63d1(%rip), %rsi      # 0x9545
jmp 0x3199
leaq 0xb20b(%rip), %rax      # 0xe388
movq (%rax), %rdi
movslq %ebx, %rax
leaq 0xac06(%rip), %rcx      # 0xdd90
movq (%rcx,%rax,8), %rdx
movq 0x8(%r14), %rcx
leaq 0x63c1(%rip), %rsi      # 0x955a
xorl %eax, %eax
callq 0x2100
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x63c1(%rip), %rdi      # 0x956f
callq 0x656d
jmp 0x31a0
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/cg.c
// Function: cgglobstr
void cgglobstr(int l, char *strvalue, int append) {
  char *cptr;
  if (!append)
    cglabel(l);
  for (cptr = strvalue; *cptr; cptr++) {
    fprintf(Outfile, "\t.byte\t%d\n", *cptr);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testl %edx, %edx
jne 0x3352
callq 0x2757
leaq 0xb02f(%rip), %r15      # 0xe388
leaq 0x6290(%rip), %r14      # 0x95f0
movsbl (%rbx), %edx
testl %edx, %edx
je 0x3379
movq (%r15), %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x2100
incq %rbx
jmp 0x3360
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/cg.c
// Function: cgcompare_and_set
int cgcompare_and_set(int ASTop, int r1, int r2, int type) {
  int size = cgprimsize(type);


  // 检查语法树操作的范围
  if (ASTop < A_EQ || ASTop > A_GE)
    fatal("Bad ASTop in cgcompare_and_set()");

  switch (size) {
  case 1:
    fprintf(Outfile, "\tcmpb\t%s, %s\n", breglist[r2], breglist[r1]);
    break;
  case 4:
    fprintf(Outfile, "\tcmpl\t%s, %s\n", dreglist[r2], dreglist[r1]);
    break;
  default:
    fprintf(Outfile, "\tcmpq\t%s, %s\n", reglist[r2], reglist[r1]);
  }

  fprintf(Outfile, "\t%s\t%s\n", cmplist[ASTop - A_EQ], breglist[r2]);
  fprintf(Outfile, "\tmovzbq\t%s, %s\n", breglist[r2], reglist[r2]);
  cgfreereg(r1);
  return (r2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %r14d
movl %edi, %ebx
movl %ecx, %edi
callq 0x231a
movl %eax, %r12d
leal -0x13(%rbx), %eax
cmpl $-0x7, %eax
ja 0x33e7
leaq 0x6245(%rip), %rdi      # 0x9627
callq 0x6515
leaq 0xaf9a(%rip), %r13      # 0xe388
movq (%r13), %rdi
leaq 0xa947(%rip), %rax      # 0xdd40
cmpl $0x1, %r12d
je 0x3418
cmpl $0x4, %r12d
jne 0x3424
movq %rax, %r12
leaq 0x6247(%rip), %rsi      # 0x9656
leaq 0xa97a(%rip), %rax      # 0xdd90
jmp 0x3435
leaq 0x6229(%rip), %rsi      # 0x9648
movq %rax, %r12
jmp 0x3435
movq %rax, %r12
leaq 0x6236(%rip), %rsi      # 0x9664
leaq 0xa8bb(%rip), %rax      # 0xdcf0
movslq %r15d, %r15
movslq %r14d, %r14
movq (%rax,%r15,8), %rdx
movq (%rax,%r14,8), %rcx
xorl %eax, %eax
callq 0x2100
movq (%r13), %rdi
movslq %ebx, %rax
leaq 0x6438(%rip), %rcx      # 0x9890
movslq -0x34(%rcx,%rax,4), %rdx
addq %rcx, %rdx
movq (%r12,%r15,8), %rbx
leaq 0x6207(%rip), %rsi      # 0x9672
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2100
movq (%r13), %rdi
leaq 0xa870(%rip), %rax      # 0xdcf0
movq (%rax,%r15,8), %rcx
leaq 0x601e(%rip), %rsi      # 0x94a9
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2100
movl %r14d, %edi
callq 0x241e
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/cg.c
// Function: cgcompare_and_jump
int cgcompare_and_jump(int ASTop, int r1, int r2, int label, int type) {
  int size = cgprimsize(type);

  // 检查语法树操作范围
  if (ASTop < A_EQ || ASTop > A_GE)
    fatal("Bad ASTop in cgcompare_and_set()");

  switch (size) {
  case 1:
    fprintf(Outfile, "\tcmpb\t%s, %s\n", breglist[r2], breglist[r1]);
    break;
  case 4:
    fprintf(Outfile, "\tcmpl\t%s, %s\n", dreglist[r2], dreglist[r1]);
    break;
  default:
    fprintf(Outfile, "\tcmpq\t%s, %s\n", reglist[r2], reglist[r1]);
  }

  fprintf(Outfile, "\t%s\tL%d\n", invcmplist[ASTop - A_EQ], label);
  cgfreereg(r1);
  cgfreereg(r2);
  return (NOREG);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %r15d
movl %esi, %r12d
movl %edi, %r14d
movl %r8d, %edi
callq 0x231a
movl %eax, %r13d
leal -0x13(%r14), %eax
cmpl $-0x7, %eax
ja 0x3507
leaq 0x6125(%rip), %rdi      # 0x9627
callq 0x6515
leaq 0xae7a(%rip), %rax      # 0xe388
movq (%rax), %rdi
cmpl $0x1, %r13d
je 0x3530
cmpl $0x4, %r13d
jne 0x3543
movq %rax, %r13
leaq 0x612f(%rip), %rsi      # 0x9656
leaq 0xa862(%rip), %rax      # 0xdd90
jmp 0x3554
movq %rax, %r13
leaq 0x610e(%rip), %rsi      # 0x9648
leaq 0xa7ff(%rip), %rax      # 0xdd40
jmp 0x3554
movq %rax, %r13
leaq 0x6117(%rip), %rsi      # 0x9664
leaq 0xa79c(%rip), %rax      # 0xdcf0
movslq %r12d, %r12
movslq %r15d, %r15
movq (%rax,%r15,8), %rdx
movq (%rax,%r12,8), %rcx
xorl %eax, %eax
callq 0x2100
movq (%r13), %rdi
movslq %r14d, %rax
leaq 0x6331(%rip), %rcx      # 0x98a8
movslq -0x34(%rcx,%rax,4), %rdx
addq %rcx, %rdx
leaq 0x6104(%rip), %rsi      # 0x968a
movl %ebx, %ecx
xorl %eax, %eax
callq 0x2100
movl %r12d, %edi
callq 0x241e
movl %r15d, %edi
callq 0x241e
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/cg.c
// Function: cgreturn
void cgreturn(int reg, struct symtable *sym) {

  // 处理有返回值的
  if (reg != NOREG) {
    // 处理指针，不能把它放在下面的switch语句里面一起处理
    if (ptrtype(sym->type))
      fprintf(Outfile, "\tmovq\t%s, %%rax\n", reglist[reg]);
    else {
      // 根据函数类型生成相应汇编代码
      switch (sym->type) {
      case P_CHAR:
        fprintf(Outfile, "\tmovzbl\t%s, %%eax\n", breglist[reg]);
        break;
      case P_INT:
        fprintf(Outfile, "\tmovl\t%s, %%eax\n", dreglist[reg]);
        break;
      case P_LONG:
        fprintf(Outfile, "\tmovq\t%s, %%rax\n", reglist[reg]);
        break;
      default:
	      fatald("Bad function type in cgreturn:", sym->type);
      }
    }
  }

  cgjump(sym->stu.st_endlabel);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpl $-0x1, %edi
je 0x35fd
movl %edi, %r14d
movl 0x10(%rbx), %edi
callq 0x8743
testl %eax, %eax
je 0x3608
leaq 0xadaa(%rip), %rax      # 0xe388
movq (%rax), %rdi
movslq %r14d, %rax
leaq 0xa705(%rip), %rcx      # 0xdcf0
movq (%rcx,%rax,8), %rdx
leaq 0x609d(%rip), %rsi      # 0x9693
xorl %eax, %eax
callq 0x2100
movl (%rbx), %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x34af
movl 0x10(%rbx), %esi
cmpl $0x40, %esi
je 0x35d7
cmpl $0x30, %esi
je 0x363b
cmpl $0x20, %esi
jne 0x365c
leaq 0xad67(%rip), %rax      # 0xe388
movq (%rax), %rdi
movslq %r14d, %rax
leaq 0xa712(%rip), %rcx      # 0xdd40
movq (%rcx,%rax,8), %rdx
leaq 0x606b(%rip), %rsi      # 0x96a4
jmp 0x35f6
leaq 0xad46(%rip), %rax      # 0xe388
movq (%rax), %rdi
movslq %r14d, %rax
leaq 0xa741(%rip), %rcx      # 0xdd90
movq (%rcx,%rax,8), %rdx
leaq 0x605d(%rip), %rsi      # 0x96b7
jmp 0x35f6
leaq 0x6065(%rip), %rdi      # 0x96c8
callq 0x656d
jmp 0x35fd
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/cg.c
// Function: cgaddress
int cgaddress(struct symtable *sym) {
  int r = cgallocreg();

  if (sym->class == C_GLOBAL ||
      sym->class == C_EXTERN || sym->class == C_STATIC)
    fprintf(Outfile, "\tleaq\t%s(%%rip), %s\n", sym->name, reglist[r]);
  else
    fprintf(Outfile, "\tleaq\t%d(%%rbp), %s\n", sym->stu.st_posn, reglist[r]);
  return (r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x23a0
movl %eax, %ebx
movl 0x24(%r14), %eax
cmpl $0x5, %eax
ja 0x36b8
pushq $0x32
popq %rcx
btl %eax, %ecx
jae 0x36b8
leaq 0xacf5(%rip), %rax      # 0xe388
movq (%rax), %rdi
movq 0x8(%r14), %rdx
movslq %ebx, %rax
leaq 0xa64c(%rip), %rcx      # 0xdcf0
movq (%rcx,%rax,8), %rcx
leaq 0x5c28(%rip), %rsi      # 0x92d7
xorl %eax, %eax
callq 0x2100
jmp 0x36e1
leaq 0xacc9(%rip), %rax      # 0xe388
movq (%rax), %rdi
movl (%r14), %edx
movslq %ebx, %rax
leaq 0xa621(%rip), %rcx      # 0xdcf0
movq (%rcx,%rax,8), %rcx
leaq 0x5be8(%rip), %rsi      # 0x92c2
xorl %eax, %eax
callq 0x2100
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/cg.c
// Function: cgderef
int cgderef(int r, int type) {
  // 获得指针指向的类型
  int newtype = value_at(type);
  // 获得类型大小
  int size = cgprimsize(newtype);

  switch (size) {
  case 1:
    fprintf(Outfile, "\tmovzbq\t(%s), %s\n", reglist[r], reglist[r]);
    break;
  case 4:
    fprintf(Outfile, "\tmovslq\t(%s), %s\n", reglist[r], reglist[r]);
    break;
  case 8:
    fprintf(Outfile, "\tmovq\t(%s), %s\n", reglist[r], reglist[r]);
    break;
  default:
    fatald("Can't cgderef on type:", type);
  }
  return (r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movl %edi, %ebx
movl %esi, %edi
callq 0x877b
movl %eax, %edi
callq 0x231a
cmpl $0x8, %eax
je 0x3753
cmpl $0x4, %eax
je 0x3732
cmpl $0x1, %eax
jne 0x377e
leaq 0xac70(%rip), %rax      # 0xe388
movq (%rax), %rdi
movslq %ebx, %rax
leaq 0xa5cb(%rip), %rcx      # 0xdcf0
movq (%rcx,%rax,8), %rcx
leaq 0x5fb7(%rip), %rsi      # 0x96e7
jmp 0x3772
leaq 0xac4f(%rip), %rax      # 0xe388
movq (%rax), %rdi
movslq %ebx, %rax
leaq 0xa5aa(%rip), %rcx      # 0xdcf0
movq (%rcx,%rax,8), %rcx
leaq 0x5fa8(%rip), %rsi      # 0x96f9
jmp 0x3772
leaq 0xac2e(%rip), %rax      # 0xe388
movq (%rax), %rdi
movslq %ebx, %rax
leaq 0xa589(%rip), %rcx      # 0xdcf0
movq (%rcx,%rax,8), %rcx
leaq 0x5f99(%rip), %rsi      # 0x970b
movq %rcx, %rdx
xorl %eax, %eax
callq 0x2100
jmp 0x378d
leaq 0x5f96(%rip), %rdi      # 0x971b
movl %r14d, %esi
callq 0x656d
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/cg.c
// Function: cgstorderef
int cgstorderef(int r1, int r2, int type) {
  // 获得类型大小
  int size = cgprimsize(type);

  switch (size) {
  case 1:
    fprintf(Outfile, "\tmovb\t%s, (%s)\n", breglist[r1], reglist[r2]);
    break;
  case 4:
    fprintf(Outfile, "\tmovl\t%s, (%s)\n", dreglist[r1], reglist[r2]);
    break;
  case 8:
    fprintf(Outfile, "\tmovq\t%s, (%s)\n", reglist[r1], reglist[r2]);
    break;
  default:
    fatald("Can't cgstoderef on type:", type);
  }
  return (r1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %r14d
movl %edi, %ebx
movl %edx, %edi
callq 0x231a
cmpl $0x8, %eax
je 0x381e
cmpl $0x4, %eax
je 0x37ef
cmpl $0x1, %eax
jne 0x384d
leaq 0xabc1(%rip), %rax      # 0xe388
movq (%rax), %rdi
movslq %ebx, %rax
leaq 0xa56c(%rip), %rcx      # 0xdd40
movq (%rcx,%rax,8), %rdx
movslq %r14d, %rax
leaq 0xa50e(%rip), %rcx      # 0xdcf0
movq (%rcx,%rax,8), %rcx
leaq 0x5f45(%rip), %rsi      # 0x9732
jmp 0x3844
leaq 0xab92(%rip), %rax      # 0xe388
movq (%rax), %rdi
movslq %ebx, %rax
leaq 0xa58d(%rip), %rcx      # 0xdd90
movq (%rcx,%rax,8), %rdx
movslq %r14d, %rax
leaq 0xa4df(%rip), %rcx      # 0xdcf0
movq (%rcx,%rax,8), %rcx
leaq 0x5f26(%rip), %rsi      # 0x9742
jmp 0x3844
leaq 0xab63(%rip), %rax      # 0xe388
movq (%rax), %rdi
movslq %ebx, %rax
leaq 0xa4be(%rip), %rcx      # 0xdcf0
movq (%rcx,%rax,8), %rdx
movslq %r14d, %rax
movq (%rcx,%rax,8), %rcx
leaq 0x5f0e(%rip), %rsi      # 0x9752
xorl %eax, %eax
callq 0x2100
jmp 0x385c
leaq 0x5f0e(%rip), %rdi      # 0x9762
movl %r15d, %esi
callq 0x656d
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/cg.c
// Function: cgswitch
void cgswitch(int reg, int casecount, int toplabel,
	      int *caselabel, int *caseval, int defaultlabel) {
  int i, label;

  // 为switch表，获得和生成一个标签
  label = genlabel();
  cglabel(label);

  // 如果没有case，就创建一个case指向默认case
  if (casecount == 0) {
    caseval[0] = 0;
    caselabel[0] = defaultlabel;
    casecount = 1;
  }
  // 生成switch跳表
  fprintf(Outfile, "\t.quad\t%d\n", casecount);
  for (i = 0; i < casecount; i++)
    fprintf(Outfile, "\t.quad\t%d, L%d\n", caseval[i], caselabel[i]);
  fprintf(Outfile, "\t.quad\tL%d\n", defaultlabel);

  // 加载指定寄存器
  cglabel(toplabel);
  fprintf(Outfile, "\tmovq\t%s, %%rax\n", reglist[reg]);
  fprintf(Outfile, "\tleaq\tL%d(%%rip), %%rdx\n", label);
  fprintf(Outfile, "\tjmp\t__switch\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebx
movq %r8, %r13
movq %rcx, %r14
movl %edx, -0x30(%rbp)
movl %esi, %r15d
movl %edi, -0x34(%rbp)
callq 0x53c0
movl %eax, -0x38(%rbp)
movl %eax, %edi
callq 0x2757
testl %r15d, %r15d
jne 0x38ac
andl $0x0, (%r13)
movl %ebx, (%r14)
pushq $0x1
popq %r15
movl %ebx, -0x2c(%rbp)
leaq 0xaad2(%rip), %rax      # 0xe388
movq (%rax), %rdi
leaq 0x5d52(%rip), %rsi      # 0x9612
xorl %ebx, %ebx
movl %r15d, %edx
xorl %eax, %eax
callq 0x2100
testl %r15d, %r15d
cmovlel %ebx, %r15d
leaq 0x5ea2(%rip), %r12      # 0x977c
xorl %ebx, %ebx
leaq 0xaaa5(%rip), %rax      # 0xe388
movq (%rax), %rdi
cmpq %rbx, %r15
je 0x3903
movl (%r13,%rbx,4), %edx
movl (%r14,%rbx,4), %ecx
movq %r12, %rsi
xorl %eax, %eax
callq 0x2100
incq %rbx
jmp 0x38dc
leaq 0x5cfc(%rip), %rsi      # 0x9606
movl -0x2c(%rbp), %edx
xorl %eax, %eax
callq 0x2100
movl -0x30(%rbp), %edi
callq 0x2757
leaq 0xaa65(%rip), %rbx      # 0xe388
movq (%rbx), %rdi
movslq -0x34(%rbp), %rax
leaq 0xa3bf(%rip), %rcx      # 0xdcf0
movq (%rcx,%rax,8), %rdx
leaq 0x5d57(%rip), %rsi      # 0x9693
xorl %eax, %eax
callq 0x2100
movq (%rbx), %rdi
leaq 0x5e3f(%rip), %rsi      # 0x978c
movl -0x38(%rbp), %edx
xorl %eax, %eax
callq 0x2100
movq (%rbx), %rcx
leaq 0x5e44(%rip), %rdi      # 0x97a5
pushq $0xe
popq %rsi
pushq $0x1
popq %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2180
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/decl.c
// Function: parse_stars
int parse_stars(int type) {

  while (1) {
    if (Token.token != T_STAR)
      break;
    type = pointer_to(type);
    scan(&Token);
  }
  return (type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %r14d
leaq 0xa463(%rip), %rbx      # 0xe3a0
cmpl $0x17, (%rbx)
jne 0x3f57
movl %r14d, %edi
callq 0x8752
movl %eax, %r14d
movq %rbx, %rdi
callq 0x66f4
jmp 0x3f3d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/decl.c
// Function: parse_cast
int parse_cast(struct symtable **ctype) {
  int type, class = 0;

  // 从括号里面获取类型
  type = parse_stars(parse_type(ctype, &class));

  // 错误检查，目前不支持，强转到复合类型
  if (type == P_STRUCT || type == P_UNION || type == P_VOID)
    fatal("Cannot cast to a struct, union or void type");
  return (type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq -0xc(%rbp), %rsi
andl $0x0, (%rsi)
callq 0x39b8
movl %eax, %edi
callq 0x3f2c
movl %eax, %ebx
cmpl $0x10, %eax
je 0x3f89
cmpl $0x60, %ebx
je 0x3f89
cmpl $0x50, %ebx
jne 0x3f95
leaq 0x59fe(%rip), %rdi      # 0x998e
callq 0x6515
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/decl.c
// Function: parse_literal
int parse_literal(int type) {
  struct ASTnode *tree;

  // 解析表达式，并优化解析出来的语法树tree
  tree = optimise(binexpr(0));

  // 如果这里有个cast，获取子树应用到tree上
  if (tree->op == A_CAST) {
    tree->left->type = tree->type;
    tree = tree->left;
  }

  // 这颗tree现在必须是个整型或者字符串字面量
  if (tree->op != A_INTLIT && tree->op != A_STRLIT)
    fatal("Cannot initialise globals with a general expression");

  // 如果type是char*
  if (type == pointer_to(P_CHAR)) {
    // tree是字符字面量，返回标签号
    if (tree->op == A_STRLIT)
      return (tree->atu.a_intvalue);
    // tree是整型零值，所以是个NULL，所以返回0
    if (tree->op == A_INTLIT && tree->atu.a_intvalue == 0)
      return (0);
  }

  // 代码走到这里就是处理整型字面量量
  // 输入的type必须是个整型，同时足够宽来容纳这个字面值
  if (inttype(type) && typesize(type, NULL) >= typesize(tree->type, NULL))
    return (tree->atu.a_intvalue);

  fatal("Type mismatch: literal vs. variable");
  return (0);		
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %r14d
xorl %edi, %edi
callq 0x49b5
movq %rax, %rdi
callq 0x6624
movq %rax, %rbx
movl 0x4(%rax), %eax
cmpl $0x34, %eax
jne 0x3fcf
movl 0x8(%rbx), %eax
movq 0x20(%rbx), %rbx
movl %eax, 0x8(%rbx)
movl 0x4(%rbx), %eax
andl $-0x2, %eax
cmpl $0x1a, %eax
je 0x3fe3
leaq 0x59dc(%rip), %rdi      # 0x99ba
callq 0x6515
pushq $0x20
popq %rdi
callq 0x8752
cmpl %r14d, %eax
jne 0x4004
movl 0x4(%rbx), %eax
cmpl $0x1a, %eax
je 0x3fff
cmpl $0x1b, %eax
je 0x403c
jmp 0x4004
cmpl $0x0, (%rbx)
je 0x4038
movl %r14d, %edi
callq 0x8728
testl %eax, %eax
je 0x402c
movl %r14d, %edi
xorl %esi, %esi
callq 0x87a1
movl %eax, %r14d
movl 0x8(%rbx), %edi
xorl %esi, %esi
callq 0x87a1
cmpl %eax, %r14d
jge 0x403c
leaq 0x59bb(%rip), %rdi      # 0x99ee
callq 0x6515
xorl %eax, %eax
jmp 0x403e
movl (%rbx), %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/decl.c
// Function: global_declarations
void global_declarations(void) {
  struct symtable *ctype= NULL;
  struct ASTnode *unused;

  // 循环解析直到文件结束
  while (Token.token != T_EOF) {
    declaration_list(&ctype, C_GLOBAL, T_SEMI, T_EOF, &unused);

    // 跳过分号
    if (Token.token == T_SEMI)
      scan(&Token);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq -0x38(%rbp), %rbx
andq $0x0, (%rbx)
leaq 0x9b41(%rip), %r14      # 0xe3a0
movl (%r14), %eax
pushq $0x1
popq %r15
pushq $0x35
popq %r12
leaq -0x30(%rbp), %r13
testl %eax, %eax
je 0x489a
movq %rbx, %rdi
movl %r15d, %esi
movl %r12d, %edx
xorl %ecx, %ecx
movq %r13, %r8
callq 0x4043
movl (%r14), %eax
cmpl $0x35, %eax
jne 0x486e
movq %r14, %rdi
callq 0x66f4
movl (%r14), %eax
jmp 0x486e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/decl.c
// Function: is_new_symbol
static int is_new_symbol(struct symtable *sym, int class, 
		  int type, struct symtable *ctype) {

  // 不存在，代表是新的
  if (sym==NULL) return(1);

  // 如果类型匹配，就转换为global（全局）
  if ((sym->class== C_GLOBAL && class== C_EXTERN)
      || (sym->class== C_EXTERN && class== C_GLOBAL)) {

      // 类型不匹配
      if (type != sym->type)
        fatals("Type mismatch between global/extern", sym->name);

      // Struct/unions, 比较ctype
      if (type >= P_STRUCT && ctype != sym->ctype)
        fatals("Type mismatch between global/extern", sym->name);

      // 到这里，代表类型匹配来，转换为global（全局）
      sym->class= C_GLOBAL;
      // 返回0，表示符号不是新的
      return(0);
  }

  // 如果到了这里，代表重复定义
  fatals("Duplicate global variable declaration", sym->name);
  return(-1);	
}

// Assembly:
testq %rdi, %rdi
je 0x4919
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %r15d
movq %rdi, %rbx
movl 0x24(%rdi), %eax
movl %eax, %ecx
xorl $0x1, %ecx
movl %esi, %edx
xorl $0x4, %edx
orl %ecx, %edx
je 0x48dc
xorl $0x4, %eax
xorl $0x1, %esi
orl %eax, %esi
jne 0x491d
cmpl %r15d, 0x10(%rbx)
je 0x48f2
movq 0x8(%rbx), %rsi
leaq 0x5433(%rip), %rdi      # 0x9d20
callq 0x641f
cmpl $0x50, %r15d
jl 0x490e
cmpq %r14, 0x18(%rbx)
je 0x490e
movq 0x8(%rbx), %rsi
leaq 0x5417(%rip), %rdi      # 0x9d20
callq 0x641f
movl $0x1, 0x24(%rbx)
xorl %eax, %eax
jmp 0x4930
pushq $0x1
popq %rax
retq
movq 0x8(%rbx), %rsi
leaq 0x541c(%rip), %rdi      # 0x9d44
callq 0x641f
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/expr.c
// Function: expression_list
struct ASTnode *expression_list(int endtoken) {
  struct ASTnode *tree = NULL;
  struct ASTnode *child = NULL;
  int exprcount = 0;

  // 循环直到遇到结束的token
  while (Token.token != endtoken) {

    // 解析下个表达式，同时增加表达式数量
    child = binexpr(0);
    exprcount++;

    // 创建一个A_GLUE节点，左树是之前的tree，右树是新的表达式child，同时保存表达式数量
    tree =
      mkastnode(A_GLUE, P_NONE, NULL, tree, NULL, child, NULL, exprcount);

    // 遇到结束token
    if (Token.token == endtoken)
      break;

    // 必须有逗号
    match(T_COMMA, ",");
  }

  // 返回所有表达式的树
  return (tree);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
pushq $0x1
popq %r12
xorl %r14d, %r14d
leaq 0x9a46(%rip), %r13      # 0xe3a0
pushq $0x1d
popq %r15
cmpl %ebx, (%r13)
je 0x49a3
xorl %edi, %edi
callq 0x49b5
movl %r15d, %edi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
xorl %r8d, %r8d
movq %rax, %r9
pushq %r12
pushq $0x0
callq 0x8108
popq %rcx
popq %rdx
movq %rax, %r14
cmpl %ebx, (%r13)
je 0x49a3
pushq $0x3d
popq %rdi
leaq 0x54bf(%rip), %rsi      # 0x9e58
callq 0x63f8
incl %r12d
jmp 0x495e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/expr.c
// Function: op_precedence
static int op_precedence(int tokentype) {
  int prec;
  if (tokentype > T_MOD)
    fatals("Token with no precedence in op_precedence:", Tstring[tokentype]);
  prec = OpPrec[tokentype];
  if (prec == 0)
    fatals("Syntax error, token", Tstring[tokentype]);
  return (prec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
cmpl $0x1a, %edi
jl 0x524e
movl %ebx, %eax
leaq 0x8ec2(%rip), %rcx      # 0xe100
movq (%rcx,%rax,8), %rsi
leaq 0x4f31(%rip), %rdi      # 0xa17a
callq 0x641f
movslq %ebx, %rax
leaq 0x4b98(%rip), %rcx      # 0x9df0
movl (%rcx,%rax,4), %r14d
testl %ebx, %ebx
jne 0x5277
leaq 0x8e99(%rip), %rcx      # 0xe100
movq (%rcx,%rax,8), %rsi
leaq 0x4f33(%rip), %rdi      # 0xa1a5
callq 0x641f
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/expr.c
// Function: member_access
static struct ASTnode *member_access(struct ASTnode *left, int withpointer) {
  struct ASTnode *right;
  struct symtable *typeptr;
  struct symtable *m;

  // 检查左树是不是个struct/union指针
  if (withpointer && left->type != pointer_to(P_STRUCT)
      && left->type != pointer_to(P_UNION))
    fatal("Expression is not a pointer to a struct/union");

  // 否则，检查左树是不是个struct/union
  // 如果是就改变节点类型，从A_IDENT到A_ADDR
  // 这样我们获得的是基地址，而不是地址里面的值
  if (!withpointer) {
    if (left->type == P_STRUCT || left->type == P_UNION)
      left->op = A_ADDR;
    else
      fatal("Expression is not a struct/union");
  }

  // 获取组合类型
  typeptr = left->ctype;

  // 跳过'.' 或者 '->'
  // 获取成员名字
  scan(&Token);
  ident();

  // 查找是否存在这个成员
  for (m = typeptr->member; m != NULL; m = m->next)
    if (!strcmp(m->name, Text))
      break;
  if (m == NULL)
    fatals("No member found in struct/union: ", Text);

  // 令左树为右值
  left->rvalue = 1;

  // 创建一个A_INTLIT节点，表示位移
  right = mkastleaf(A_INTLIT, P_INT, NULL, NULL, m->stu.st_posn);

  // 返回一个语法树节点，该节点是给这个struct/union的基地址加上位移
  // 然后再在这个节点基础上，再加个节点来解引用。现在这些节点还是左值
  left =
    mkastnode(A_ADD, pointer_to(m->type), m->ctype, left, NULL, right, NULL,
	      0);
  left = mkastunary(A_DEREF, m->type, m->ctype, left, NULL, 0);
  return (left);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %r14d
testl %esi, %esi
je 0x52e6
pushq $0x50
popq %rdi
callq 0x8752
cmpl %eax, %r14d
je 0x5307
movl 0x8(%rbx), %r14d
pushq $0x60
popq %rdi
callq 0x8752
cmpl %eax, %r14d
je 0x5307
leaq 0x4e25(%rip), %rdi      # 0xa109
jmp 0x5302
cmpl $0x60, %r14d
je 0x52f2
cmpl $0x50, %r14d
jne 0x52fb
movl $0x25, 0x4(%rbx)
jmp 0x5307
leaq 0x4e35(%rip), %rdi      # 0xa137
callq 0x6515
movq 0x10(%rbx), %r15
leaq 0x908e(%rip), %rdi      # 0xe3a0
callq 0x66f4
callq 0x64e9
addq $0x40, %r15
leaq 0x90a9(%rip), %r14      # 0xe3d0
movq (%r15), %r15
testq %r15, %r15
je 0x5345
movq 0x8(%r15), %rdi
movq %r14, %rsi
callq 0x20f0
testl %eax, %eax
je 0x5358
addq $0x38, %r15
jmp 0x5327
leaq 0x4e0c(%rip), %rdi      # 0xa158
leaq 0x907d(%rip), %rsi      # 0xe3d0
callq 0x641f
movl $0x1, 0x18(%rbx)
movl (%r15), %r8d
pushq $0x1a
popq %rdi
pushq $0x30
popq %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x818c
movq %rax, %r14
movl 0x10(%r15), %edi
callq 0x8752
movq 0x18(%r15), %rdx
pushq $0x15
popq %rdi
movl %eax, %esi
movq %rbx, %rcx
xorl %r8d, %r8d
movq %r14, %r9
pushq $0x0
pushq $0x0
callq 0x8108
addq $0x10, %rsp
movl 0x10(%r15), %esi
movq 0x18(%r15), %rdx
pushq $0x24
popq %rdi
movq %rax, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x81aa
nop
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/gen.c
// Function: gen_logandor
static int gen_logandor(struct ASTnode *n) {
  // 生成两个标签
  int Lfalse = genlabel();
  int Lend = genlabel();
  int reg;

  // 为左表达式生成代码, 如果表达式满足条件,则跳到false标签
  // 例如 1&&1+1 这个表达式,由于左边为true,那就不用执行右边,直接跳转到Lfalse
  reg = genAST(n->left, NOLABEL, NOLABEL, NOLABEL, 0);
  cgboolean(reg, n->op, Lfalse);
  genfreeregs(NOREG);

  // 为右表达式生成代码, 如果表达式满足条件,则跳到false标签
  reg = genAST(n->right, NOLABEL, NOLABEL, NOLABEL, 0);
  cgboolean(reg, n->op, Lfalse);
  genfreeregs(reg);

  // 设置寄存器的值
  // 这里很精彩,好好品品:)
  if (n->op == A_LOGAND) {
    cgloadboolean(reg, 1);
    cgjump(Lend);
    cglabel(Lfalse);
    cgloadboolean(reg, 0);
  } else {
    cgloadboolean(reg, 0);
    cgjump(Lend);
    cglabel(Lfalse);
    cgloadboolean(reg, 1);
  }
  cglabel(Lend);
  return (reg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movl 0x8453(%rip), %r14d     # 0xe0f0
leal 0x1(%r14), %ebx
leal 0x2(%r14), %eax
movl %eax, 0x8445(%rip)      # 0xe0f0
movq 0x20(%rdi), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x53d5
movl 0x4(%r15), %esi
movl %eax, %edi
movl %r14d, %edx
callq 0x2f18
pushq $-0x1
popq %rdi
callq 0x2373
movq 0x30(%r15), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x53d5
movl %eax, %r12d
movl 0x4(%r15), %esi
movl %eax, %edi
movl %r14d, %edx
callq 0x2f18
movl %r12d, %edi
callq 0x2373
xorl %r13d, %r13d
xorl %esi, %esi
cmpl $0x9, 0x4(%r15)
setne %r13b
sete %sil
movl %r12d, %edi
callq 0x2ee8
movl %ebx, %edi
callq 0x34af
movl %r14d, %edi
callq 0x2757
movl %r12d, %edi
movl %r13d, %esi
callq 0x2ee8
movl %ebx, %edi
callq 0x2757
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/main.c
// Function: alter_suffix
char *alter_suffix(char *str, char suffix) {
  char *posn;
  char *newstr;

  // 拷贝字符串
  if ((newstr = strdup(str)) == NULL)
    return (NULL);

  // 找到'.'的位置
  if ((posn = strrchr(newstr, '.')) == NULL)
    return (NULL);

  // 保证这里有个后缀
  posn++;
  if (*posn == '\0')
    return (NULL);

  // 改变后缀，并用NULL终结
  *posn = suffix;
  posn++;
  *posn = '\0';
  return (newstr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
callq 0x2190
testq %rax, %rax
je 0x5df7
movq %rax, %rbx
pushq $0x2e
popq %rsi
movq %rax, %rdi
callq 0x20b0
testq %rax, %rax
je 0x5df7
cmpb $0x0, 0x1(%rax)
je 0x5df7
movb %r14b, 0x1(%rax)
movb $0x0, 0x2(%rax)
jmp 0x5df9
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/main.c
// Function: do_assemble
char *do_assemble(char *filename) {
  char cmd[TEXTLEN];
  int err;

  char *outfilename = alter_suffix(filename, 'o');
  if (outfilename == NULL) {
    fprintf(stderr, "Error: %s has no suffix, try .s on the end\n", filename);
    exit(1);
  }

  // 创建汇编命令,然后运行它
  snprintf(cmd, TEXTLEN, "%s %s %s", ASCMD, outfilename, filename);
  if (O_verbose)
    printf("%s\n", cmd);
  err = system(cmd);
  if (err != 0) {
    fprintf(stderr, "Assembly of %s failed\n", filename);
    exit(1);
  }
  return (outfilename);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdi, %rbx
pushq $0x6f
popq %rsi
callq 0x5dc0
testq %rax, %rax
je 0x5e7d
movq %rax, %r14
leaq 0x44df(%rip), %rdx      # 0xa308
leaq 0x44e1(%rip), %rcx      # 0xa311
leaq -0x210(%rbp), %rdi
movl $0x200, %esi            # imm = 0x200
movq %rax, %r8
movq %rbx, %r9
xorl %eax, %eax
callq 0x20a0
cmpl $0x0, 0x8500(%rip)      # 0xe350
je 0x5e5e
leaq -0x210(%rbp), %rdi
callq 0x2060
leaq -0x210(%rbp), %rdi
callq 0x2080
testl %eax, %eax
jne 0x5e90
movq %r14, %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %rbp
retq
movq 0x816c(%rip), %rax      # 0xdff0
movq (%rax), %rdi
leaq 0x444e(%rip), %rsi      # 0xa2dc
jmp 0x5ea1
movq 0x8159(%rip), %rax      # 0xdff0
movq (%rax), %rdi
leaq 0x447a(%rip), %rsi      # 0xa31b
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2100
pushq $0x1
popq %rdi
callq 0x2170
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/main.c
// Function: do_link
void do_link(char *outfilename, char **objlist) {
  int cnt, size = TEXTLEN;
  char cmd[TEXTLEN], *cptr;
  int err;

  // 先设置链接器命令和输出文件
  cptr = cmd;
  cnt = snprintf(cptr, size, "%s %s ", LDCMD, outfilename);
  cptr += cnt;
  size -= cnt;

  // 然后添加每个目标文件
  while (*objlist != NULL) {
    cnt = snprintf(cptr, size, "%s ", *objlist);
    cptr += cnt;
    size -= cnt;
    objlist++;
  }

  if (O_verbose)
    printf("%s\n", cmd);
  err = system(cmd);
  if (err != 0) {
    fprintf(stderr, "Linking failed\n");
    exit(1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rsi, %rbx
movq %rdi, %r8
leaq 0x4460(%rip), %rdx      # 0xa332
leaq 0x4460(%rip), %rcx      # 0xa339
leaq -0x220(%rbp), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %eax, %eax
callq 0x20a0
cltq
leaq (%rax,%rbp), %r14
addq $-0x220, %r14           # imm = 0xFDE0
movl $0x200, %r15d           # imm = 0x200
subl %eax, %r15d
leaq 0x4ccc(%rip), %r12      # 0xabd5
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x5f32
movslq %r15d, %r15
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x20a0
cltq
addq %rax, %r14
subl %eax, %r15d
addq $0x8, %rbx
jmp 0x5f09
cmpl $0x0, 0x8417(%rip)      # 0xe350
je 0x5f47
leaq -0x220(%rbp), %rdi
callq 0x2060
leaq -0x220(%rbp), %rdi
callq 0x2080
testl %eax, %eax
jne 0x5f67
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x8082(%rip), %rax      # 0xdff0
movq (%rax), %rcx
leaq 0x43cb(%rip), %rdi      # 0xa343
pushq $0xf
popq %rsi
pushq $0x1
popq %rdx
callq 0x2180
pushq $0x1
popq %rdi
callq 0x2170
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/main.c
// Function: usage
static void usage(char *prog) {
  fprintf(stderr, "Usage: %s [-vcSTM] [-o outfile] file [file ...]\n", prog);
  fprintf(stderr,
	  "       -v give verbose output of the compilation stages\n");
  fprintf(stderr, "       -c generate object files but don't link them\n");
  fprintf(stderr, "       -S generate assembly files but don't link them\n");
  fprintf(stderr, "       -T dump the AST trees for each input file\n");
  fprintf(stderr, "       -M dump the symbol table for each input file\n");
  fprintf(stderr, "       -o outfile, produce the outfile executable file\n");
  exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rdx
movq 0x7c96(%rip), %r15      # 0xdff0
movq (%r15), %rdi
leaq 0x4027(%rip), %rsi      # 0xa38b
xorl %eax, %eax
callq 0x2100
movq (%r15), %rcx
leaq 0x4047(%rip), %rdi      # 0xa3bc
pushq $0x38
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x2180
movq (%r15), %rcx
leaq 0x4068(%rip), %rdi      # 0xa3f5
pushq $0x34
popq %r14
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2180
movq (%r15), %rcx
leaq 0x4084(%rip), %rdi      # 0xa42a
pushq $0x36
popq %rsi
movq %rbx, %rdx
callq 0x2180
movq (%r15), %rcx
leaq 0x40a6(%rip), %rdi      # 0xa461
pushq $0x31
popq %rsi
movq %rbx, %rdx
callq 0x2180
movq (%r15), %rcx
leaq 0x40c3(%rip), %rdi      # 0xa493
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2180
movq (%r15), %rcx
leaq 0x40e3(%rip), %rdi      # 0xa4c8
pushq $0x37
popq %rsi
movq %rbx, %rdx
callq 0x2180
pushq $0x1
popq %rdi
callq 0x2170
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/misc.c
// Function: fatals
void fatals(char *s1, char *s2) {
  fprintf(stderr, "%s:%s on line %d of %s\n", s1, s2, Line, Infilename);
  fclose(Outfile);
  unlink(Outfilename);
  exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rcx
movq %rdi, %rdx
movq 0x7bc0(%rip), %rax      # 0xdff0
movq (%rax), %rdi
leaq 0x7f2e(%rip), %rax      # 0xe368
movl (%rax), %r8d
leaq 0x7f4c(%rip), %rax      # 0xe390
movq (%rax), %r9
leaq 0x4168(%rip), %rsi      # 0xa5b6
xorl %eax, %eax
callq 0x2100
leaq 0x7f2c(%rip), %rax      # 0xe388
movq (%rax), %rdi
callq 0x2070
leaq 0x7f2d(%rip), %rax      # 0xe398
movq (%rax), %rdi
callq 0x2050
pushq $0x1
popq %rdi
callq 0x2170
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/misc.c
// Function: fatal
void fatal(char *s) {
  fprintf(stderr, "%s on line %d of %s\n", s, Line, Infilename);
  fclose(Outfile);
  unlink(Outfilename);
  exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rdx
movq 0x7acd(%rip), %rax      # 0xdff0
movq (%rax), %rdi
leaq 0x7e3b(%rip), %rax      # 0xe368
movl (%rax), %ecx
leaq 0x7e5a(%rip), %rax      # 0xe390
movq (%rax), %r8
leaq 0x4079(%rip), %rsi      # 0xa5b9
xorl %eax, %eax
callq 0x2100
leaq 0x7e3a(%rip), %rax      # 0xe388
movq (%rax), %rdi
callq 0x2070
leaq 0x7e3b(%rip), %rax      # 0xe398
movq (%rax), %rdi
callq 0x2050
pushq $0x1
popq %rdi
callq 0x2170