LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ejunjsh[P]mycc/gen.c
// Function: update_line
static void update_line(struct ASTnode *n) {
  // 如果我们在语法树节点上改变了行号, 输出行号到汇编
  if (n->linenum != 0 && Line != n->linenum) {
    Line = n->linenum;
    cglinenum(Line);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x40(%rax)
je 0x6fc6
leaq 0xb55b(%rip), %rax      # 0x124f8
movl (%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x40(%rcx), %eax
je 0x6fc6
movq -0x8(%rbp), %rax
movl 0x40(%rax), %ecx
leaq 0xb542(%rip), %rax      # 0x124f8
movl %ecx, (%rax)
leaq 0xb539(%rip), %rax      # 0x124f8
movl (%rax), %edi
callq 0x42c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ejunjsh[P]mycc/gen.c
// Function: genIF
static int genIF(struct ASTnode *n, int looptoplabel, int loopendlabel) {
  int Lfalse, Lend;

  // 生成两个标签: 一个是给false时的组合语句,一个是整个IF的结束标签
  // 当没有ELSE语句的情况,Lfalse相当于结束标签了
  Lfalse = genlabel();
  if (n->right)
    Lend = genlabel();

  // 生成条件的汇编代码,传Lfalse作为参数是方便跳到Lfalse
  genAST(n->left, Lfalse, NOLABEL, NOLABEL, n->op);
  genfreeregs(NOREG);

  // 生成true时的组合语句的汇编
  genAST(n->mid, NOLABEL, looptoplabel, loopendlabel, n->op);
  genfreeregs(NOREG);

  // 如果有ELSE, 生成跳转指令,跳到最后
  if (n->right)
    cgjump(Lend);

  // 生成false时的标签
  cglabel(Lfalse);

  // 如果有ELSE,生成false时的组合语句的汇编和结束标签
  if (n->right) {
    genAST(n->right, NOLABEL, NOLABEL, loopendlabel, n->op);
    genfreeregs(NOREG);
    cglabel(Lend);
  }

  return (NOREG);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
callq 0x6830
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x6ffd
callq 0x6830
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0x14(%rbp), %esi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %r8d
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x6850
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x7520
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl 0x4(%rax), %r8d
xorl %esi, %esi
callq 0x6850
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x7520
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x705d
movl -0x18(%rbp), %edi
callq 0x3bc0
movl -0x14(%rbp), %edi
callq 0x2960
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x709e
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl 0x4(%rax), %r8d
xorl %edx, %edx
movl %edx, %esi
callq 0x6850
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x7520
movl -0x18(%rbp), %edi
callq 0x2960
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ejunjsh[P]mycc/gen.c
// Function: genWHILE
static int genWHILE(struct ASTnode *n) {
  int Lstart, Lend;

  // 生成开始和结束标签
  // 输出开始标签
  Lstart = genlabel();
  Lend = genlabel();
  cglabel(Lstart);

  // 生成条件的汇编代码,传Lend作为参数是方便跳出循环
  genAST(n->left, Lend, Lstart, Lend, n->op);
  genfreeregs(NOREG);

  // 生成循环体的汇编
  genAST(n->right, NOLABEL, Lstart, Lend, n->op);
  genfreeregs(NOREG);

  // 最后输出跳回开始的指令和结束标签
  cgjump(Lstart);
  cglabel(Lend);
  return (NOREG);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x6830
movl %eax, -0xc(%rbp)
callq 0x6830
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edi
callq 0x2960
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl 0x4(%rax), %r8d
callq 0x6850
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x7520
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl 0x4(%rax), %r8d
xorl %esi, %esi
callq 0x6850
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x7520
movl -0xc(%rbp), %edi
callq 0x3bc0
movl -0x10(%rbp), %edi
callq 0x2960
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ejunjsh[P]mycc/gen.c
// Function: gen_funccall
static int gen_funccall(struct ASTnode *n) {
  struct ASTnode *gluetree = n->left;
  int reg;
  int numargs = 0;

  // 拷贝实参之前,先保存寄存器
  cgspillregs();

  // 如果有一列表实参,从最后一个开始遍历到第一个
  while (gluetree) {
    // 生成表达式,并返回表达式值的寄存器
    reg = genAST(gluetree->right, NOLABEL, NOLABEL, NOLABEL, gluetree->op);
    // 拷贝实参到形参
    cgcopyarg(reg, gluetree->atu.a_size);
    // 保留函数参数数量
    if (numargs == 0)
      numargs = gluetree->atu.a_size;
    gluetree = gluetree->left;
  }

  // 调用函数,清理栈(根据参数数量),并返回函数返回值
  return (cgcall(n->sym, numargs));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
callq 0x2580
cmpq $0x0, -0x10(%rbp)
je 0x7334
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %r8d
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0x6850
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x35d0
cmpl $0x0, -0x18(%rbp)
jne 0x7326
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x72e4
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movl -0x18(%rbp), %esi
callq 0x3500
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ejunjsh[P]mycc/gen.c
// Function: gen_ternary
static int gen_ternary(struct ASTnode *n) {
  int Lfalse, Lend;
  int reg, expreg;

  // 生成两个标签：一个是给false表达式，一个是给整个表达式
  Lfalse = genlabel();
  Lend = genlabel();

  // 生成条件的汇编代码，并传递Lfalse作为参数
  genAST(n->left, Lfalse, NOLABEL, NOLABEL, n->op);
  // genfreeregs(NOREG);

  // 分配一个寄存器用来存储后面两个表达式的结果
  reg = cgallocreg();

  // 生成true表达式和false标签
  // 把表达式的结果拷贝到上面那个已知的寄存器
  expreg = genAST(n->mid, NOLABEL, NOLABEL, NOLABEL, n->op);
  cgmove(expreg, reg);
  cgfreereg(expreg);
  cgjump(Lend);
  cglabel(Lfalse);

  // 生成false表达式和结束标签
  // 把表达式的结果拷贝到上面那个已知的寄存器
  expreg = genAST(n->right, NOLABEL, NOLABEL, NOLABEL, n->op);
  cgmove(expreg, reg);
  cgfreereg(expreg);
  cglabel(Lend);
  return (reg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x6830
movl %eax, -0xc(%rbp)
callq 0x6830
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %r8d
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x6850
callq 0x23f0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %r8d
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0x6850
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %edi
movl -0x14(%rbp), %esi
callq 0x4270
movl -0x18(%rbp), %edi
callq 0x24c0
movl -0x10(%rbp), %edi
callq 0x3bc0
movl -0xc(%rbp), %edi
callq 0x2960
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %r8d
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0x6850
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %edi
movl -0x14(%rbp), %esi
callq 0x4270
movl -0x18(%rbp), %edi
callq 0x24c0
movl -0x10(%rbp), %edi
callq 0x2960
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x6830
movl %eax, -0xc(%rbp)
callq 0x6830
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
xorl %r8d, %r8d
movl %r8d, %esi
movl %r8d, %edx
movl %r8d, %ecx
callq 0x6850
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
movl -0xc(%rbp), %edx
callq 0x3400
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x7520
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
xorl %r8d, %r8d
movl %r8d, %esi
movl %r8d, %edx
movl %r8d, %ecx
callq 0x6850
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
movl -0xc(%rbp), %edx
callq 0x3400
movl -0x14(%rbp), %edi
callq 0x7520
movq -0x8(%rbp), %rax
cmpl $0x9, 0x4(%rax)
jne 0x74dd
movl -0x14(%rbp), %edi
movl $0x1, %esi
callq 0x33c0
movl -0x10(%rbp), %edi
callq 0x3bc0
movl -0xc(%rbp), %edi
callq 0x2960
movl -0x14(%rbp), %edi
xorl %esi, %esi
callq 0x33c0
jmp 0x7504
movl -0x14(%rbp), %edi
xorl %esi, %esi
callq 0x33c0
movl -0x10(%rbp), %edi
callq 0x3bc0
movl -0xc(%rbp), %edi
callq 0x2960
movl -0x14(%rbp), %edi
movl $0x1, %esi
callq 0x33c0
movl -0x10(%rbp), %edi
callq 0x2960
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2150
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x764f
movq $0x0, -0x8(%rbp)
jmp 0x76b7
movq -0x28(%rbp), %rdi
movl $0x2e, %esi
callq 0x2090
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x7671
movq $0x0, -0x8(%rbp)
jmp 0x76b7
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x7693
movq $0x0, -0x8(%rbp)
jmp 0x76b7
movb -0x11(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x6f, %esi
callq 0x7620
movq %rax, -0x220(%rbp)
cmpq $0x0, -0x220(%rbp)
jne 0x7724
movq 0xa8f3(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x5d69(%rip), %rsi      # 0xd47c
movb $0x0, %al
callq 0x20e0
movl $0x1, %edi
callq 0x2140
leaq -0x210(%rbp), %rdi
movq -0x220(%rbp), %r8
movq -0x8(%rbp), %r9
movl $0x200, %esi            # imm = 0x200
leaq 0x5d66(%rip), %rdx      # 0xd4a8
leaq 0x5d68(%rip), %rcx      # 0xd4b1
movb $0x0, %al
callq 0x2080
cmpl $0x0, 0xad89(%rip)      # 0x124e0
je 0x776e
leaq -0x210(%rbp), %rsi
leaq 0x4d3e(%rip), %rdi      # 0xc4a5
movb $0x0, %al
callq 0x2070
leaq -0x210(%rbp), %rdi
callq 0x2060
movl %eax, -0x214(%rbp)
cmpl $0x0, -0x214(%rbp)
je 0x77af
movq 0xa868(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x5d1d(%rip), %rsi      # 0xd4bb
movb $0x0, %al
callq 0x20e0
movl $0x1, %edi
callq 0x2140
movq -0x220(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x200, -0x18(%rbp)     # imm = 0x200
leaq -0x220(%rbp), %rax
movq %rax, -0x228(%rbp)
movq -0x228(%rbp), %rdi
movslq -0x18(%rbp), %rsi
movq -0x8(%rbp), %r8
leaq 0x5cd4(%rip), %rdx      # 0xd4d2
leaq 0x5cd4(%rip), %rcx      # 0xd4d9
movb $0x0, %al
callq 0x2080
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x228(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x228(%rbp)
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x788e
movq -0x228(%rbp), %rdi
movslq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rcx
leaq 0x674d(%rip), %rdx      # 0xdfa1
movb $0x0, %al
callq 0x2080
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x228(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x228(%rbp)
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x7831
cmpl $0x0, 0xac4b(%rip)      # 0x124e0
je 0x78ac
leaq -0x220(%rbp), %rsi
leaq 0x4c00(%rip), %rdi      # 0xc4a5
movb $0x0, %al
callq 0x2070
leaq -0x220(%rbp), %rdi
callq 0x2060
movl %eax, -0x22c(%rbp)
cmpl $0x0, -0x22c(%rbp)
je 0x78e9
movq 0xa72a(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x5c0b(%rip), %rsi      # 0xd4e3
movb $0x0, %al
callq 0x20e0
movl $0x1, %edi
callq 0x2140
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xa385(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x58aa(%rip), %rsi      # 0xd52b
movb $0x0, %al
callq 0x20e0
movq 0xa369(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x58c3(%rip), %rsi      # 0xd55c
movb $0x0, %al
callq 0x20e0
movq 0xa351(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x58e4(%rip), %rsi      # 0xd595
movb $0x0, %al
callq 0x20e0
movq 0xa339(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x5901(%rip), %rsi      # 0xd5ca
movb $0x0, %al
callq 0x20e0
movq 0xa321(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x5920(%rip), %rsi      # 0xd601
movb $0x0, %al
callq 0x20e0
movq 0xa309(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x593a(%rip), %rsi      # 0xd633
movb $0x0, %al
callq 0x20e0
movq 0xa2f1(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x5957(%rip), %rsi      # 0xd668
movb $0x0, %al
callq 0x20e0
movl $0x1, %edi
callq 0x2140
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ejunjsh[P]mycc/misc.c
// Function: match
void match(int t, char *what){
    if(Token.token == t){
        scan(&Token);
    } else{
        fatals("Expected", what);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xa5aa(%rip), %rax      # 0x12530
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x7f9b
leaq 0xa59c(%rip), %rdi      # 0x12530
callq 0x84c0
jmp 0x7fab
movq -0x10(%rbp), %rsi
leaq 0x579b(%rip), %rdi      # 0xd741
callq 0x7fc0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0xa021(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0xa50f(%rip), %rax      # 0x124f8
movl (%rax), %r8d
leaq 0xa52d(%rip), %rax      # 0x12520
movq (%rax), %r9
leaq 0x5759(%rip), %rsi      # 0xd756
movb $0x0, %al
callq 0x20e0
leaq 0xa50d(%rip), %rax      # 0x12518
movq (%rax), %rdi
callq 0x2050
leaq 0xa50e(%rip), %rax      # 0x12528
movq (%rax), %rdi
callq 0x2040
movl $0x1, %edi
callq 0x2140
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x9ed5(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0xa3c7(%rip), %rax      # 0x124f8
movl (%rax), %ecx
leaq 0xa3e6(%rip), %rax      # 0x12520
movq (%rax), %r8
leaq 0x5615(%rip), %rsi      # 0xd759
movb $0x0, %al
callq 0x20e0
leaq 0xa3c6(%rip), %rax      # 0x12518
movq (%rax), %rdi
callq 0x2050
leaq 0xa3c7(%rip), %rax      # 0x12528
movq (%rax), %rdi
callq 0x2040
movl $0x1, %edi
callq 0x2140
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ejunjsh[P]mycc/misc.c
// Function: fatald
void fatald(char *s, int d) {
  fprintf(stderr, "%s:%d on line %d of %s\n", s, d, Line, Infilename);
  fclose(Outfile);
  unlink(Outfilename);
  exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x9e62(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %ecx
leaq 0xa351(%rip), %rax      # 0x124f8
movl (%rax), %r8d
leaq 0xa36f(%rip), %rax      # 0x12520
movq (%rax), %r9
leaq 0x55b3(%rip), %rsi      # 0xd76e
movb $0x0, %al
callq 0x20e0
leaq 0xa34f(%rip), %rax      # 0x12518
movq (%rax), %rdi
callq 0x2050
leaq 0xa350(%rip), %rax      # 0x12528
movq (%rax), %rdi
callq 0x2040
movl $0x1, %edi
callq 0x2140
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ejunjsh[P]mycc/misc.c
// Function: fatalc
void fatalc(char *s, int c) {
  fprintf(stderr, "%s:%c on line %d of %s\n", s, c, Line, Infilename);
  fclose(Outfile);
  unlink(Outfilename);
  exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x9df2(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %ecx
leaq 0xa2e1(%rip), %rax      # 0x124f8
movl (%rax), %r8d
leaq 0xa2ff(%rip), %rax      # 0x12520
movq (%rax), %r9
leaq 0x555b(%rip), %rsi      # 0xd786
movb $0x0, %al
callq 0x20e0
leaq 0xa2df(%rip), %rax      # 0x12518
movq (%rax), %rdi
callq 0x2050
leaq 0xa2e0(%rip), %rax      # 0x12528
movq (%rax), %rdi
callq 0x2040
movl $0x1, %edi
callq 0x2140
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ejunjsh[P]mycc/opt.c
// Function: fold
static struct ASTnode *fold(struct ASTnode *n) {

  if (n == NULL)
    return (NULL);

  // 折叠左子树和右子树
  n->left = fold(n->left);
  n->right = fold(n->right);

  // 如果两个子树都是A_INTLITs，使用fold2()折叠
  if (n->left && n->left->op == A_INTLIT) {
    if (n->right && n->right->op == A_INTLIT)
      n = fold2(n);
    else
      // 如果只是左子树是A_INTLIT,使用fold1()折叠
      n = fold1(n);
  }

  // 返回可能折叠过的树
  return (n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x82b0
movq $0x0, -0x8(%rbp)
jmp 0x8338
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x8290
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x8290
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x8330
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x1a, 0x4(%rax)
jne 0x8330
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x8321
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x1a, 0x4(%rax)
jne 0x8321
movq -0x10(%rbp), %rdi
callq 0x8350
movq %rax, -0x10(%rbp)
jmp 0x832e
movq -0x10(%rbp), %rdi
callq 0x8420
movq %rax, -0x10(%rbp)
jmp 0x8330
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ejunjsh[P]mycc/opt.c
// Function: fold2
static struct ASTnode *fold2(struct ASTnode *n) {
  int val, leftval, rightval;

  // 从每个子节点那里获得值
  leftval = n->left->atu.a_intvalue;
  rightval = n->right->atu.a_intvalue;

  // 执行二元操作
  // 对于其他不支持的操作
  // 返回原来的树
  switch (n->op) {
    case A_ADD:
      val = leftval + rightval;
      break;
    case A_SUBTRACT:
      val = leftval - rightval;
      break;
    case A_MULTIPLY:
      val = leftval * rightval;
      break;
    case A_DIVIDE:
      // 不会去除0
      if (rightval == 0)
	return (n);
      val = leftval / rightval;
      break;
    default:
      return (n);
  }

    // 返回一个含新值的叶子节点
  return (mkastleaf(A_INTLIT, n->type, NULL, NULL, val));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
addl $-0x15, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x3, %eax
ja 0x83dd
movq -0x28(%rbp), %rax
leaq 0x540a(%rip), %rcx      # 0xd7a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0x18(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x83e7
movl -0x18(%rbp), %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x83e7
movl -0x18(%rbp), %eax
imull -0x1c(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x83e7
cmpl $0x0, -0x1c(%rbp)
jne 0x83d1
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8407
movl -0x18(%rbp), %eax
cltd
idivl -0x1c(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x83e7
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8407
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
movl -0x14(%rbp), %r8d
movl $0x1a, %edi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0xad50
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ejunjsh[P]mycc/opt.c
// Function: fold1
static struct ASTnode *fold1(struct ASTnode *n) {
  int val;

  // 对孩子对值进行操作，前提是支持的操作
  // 返回一个新的叶子，对于不支持的操作，返回原树
  val = n->left->atu.a_intvalue;
  switch (n->op) {
    case A_WIDEN:
      break;
    case A_INVERT:
      val = ~val;
      break;
    case A_LOGNOT:
      val = !val;
      break;
    default:
      return (n);
  }

  // 返回一个含新值的叶子节点
  return (mkastleaf(A_INTLIT, n->type, NULL, NULL, val));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x18(%rbp)
subl $0x21, %eax
je 0x845e
jmp 0x844a
movl -0x18(%rbp), %eax
subl $0x2c, %eax
je 0x8460
jmp 0x8454
movl -0x18(%rbp), %eax
subl $0x2d, %eax
je 0x846b
jmp 0x847e
jmp 0x8488
movl -0x14(%rbp), %eax
xorl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8488
cmpl $0x0, -0x14(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
jmp 0x8488
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x84a8
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
movl -0x14(%rbp), %r8d
movl $0x1a, %edi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0xad50
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ejunjsh[P]mycc/scan.c
// Function: skip
static int skip(void) {
  int c;

  c = next();
  while (' ' == c || '\t' == c || '\n' == c || '\r' == c || '\f' == c) {
    c = next();
  }
  return (c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x8a80
movl %eax, -0x4(%rbp)
movb $0x1, %al
movl $0x20, %ecx
cmpl -0x4(%rbp), %ecx
movb %al, -0x5(%rbp)
je 0x8a5a
movb $0x1, %al
movl $0x9, %ecx
cmpl -0x4(%rbp), %ecx
movb %al, -0x5(%rbp)
je 0x8a5a
movb $0x1, %al
movl $0xa, %ecx
cmpl -0x4(%rbp), %ecx
movb %al, -0x5(%rbp)
je 0x8a5a
movb $0x1, %al
movl $0xd, %ecx
cmpl -0x4(%rbp), %ecx
movb %al, -0x5(%rbp)
je 0x8a5a
movl $0xc, %eax
cmpl -0x4(%rbp), %eax
sete %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
testb $0x1, %al
jne 0x8a63
jmp 0x8a6d
callq 0x8a80
movl %eax, -0x4(%rbp)
jmp 0x8a10
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ejunjsh[P]mycc/scan.c
// Function: scanint
static int scanint(int c) {
  int k, val = 0, radix = 10;

  // 一般都是10进制，除非是0开头
  if (c == '0') {
    // 如果接下来是'x', 16进制
    if ((c = next()) == 'x') {
      radix = 16;
      c = next();
    } else
      // 否则8进制
      radix = 8;

  }

  // 转换字符到整型
  while ((k = chrpos("0123456789abcdef", tolower(c))) >= 0) {
    if (k >= radix)
      fatalc("invalid digit in integer literal", c);
    val = val * radix + k;
    c = next();
  }

  // 遇到非整型字符，放回
  putback(c);
  return (val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0xc(%rbp)
movl $0xa, -0x10(%rbp)
cmpl $0x30, -0x4(%rbp)
jne 0x8ca6
callq 0x8a80
movl %eax, -0x4(%rbp)
cmpl $0x78, %eax
jne 0x8c9d
movl $0x10, -0x10(%rbp)
callq 0x8a80
movl %eax, -0x4(%rbp)
jmp 0x8ca4
movl $0x8, -0x10(%rbp)
jmp 0x8ca6
jmp 0x8ca8
movl -0x4(%rbp), %edi
callq 0x20f0
movl %eax, %esi
leaq 0x4fc6(%rip), %rdi      # 0xdc7f
callq 0x9310
movl %eax, -0x8(%rbp)
cmpl $0x0, %eax
jl 0x8cf4
movl -0x8(%rbp), %eax
cmpl -0x10(%rbp), %eax
jl 0x8cdd
movl -0x4(%rbp), %esi
leaq 0x4fb8(%rip), %rdi      # 0xdc90
callq 0x81f0
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
addl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
callq 0x8a80
movl %eax, -0x4(%rbp)
jmp 0x8ca8
movl -0x4(%rbp), %edi
callq 0x8c40
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ejunjsh[P]mycc/scan.c
// Function: scanch
static int scanch(void) {
  int i, c, c2;

  // 获取下个字符，并解释那些有反斜杠开头的字符
  c = next();
  if (c == '\\') {
    switch (c = next()) {
      case 'a':
	    return ('\a');
      case 'b':
	    return ('\b');
      case 'f':
	    return ('\f');
      case 'n':
	    return ('\n');
      case 'r':
	    return ('\r');
      case 't':
	    return ('\t');
      case 'v':
	    return ('\v');
      case '\\':
	    return ('\\');
      case '"':
	    return ('"');
      case '\'':
	    return ('\'');

    // 处理8进制，直到碰到不是8进制数字为止
    // 值放在c2，位数放在i，只允许3位8进制数字
      case '0':
      case '1':
      case '2':
      case '3':
      case '4':
      case '5':
      case '6':
      case '7':
        for (i = c2 = 0; isdigit(c) && c < '8'; c = next()) {
            if (++i > 3)
                break;
            c2 = c2 * 8 + (c - '0');
        }

	    putback(c);		// 返回非8进制字符
	    return (c2);
      case 'x':
	    return (hexchar());
      default:
	    fatalc("unknown escape sequence", c);
    }
  }
  return (c);			// 返回普通的字符（没有反斜杠转义的）
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x8a80
movl %eax, -0xc(%rbp)
cmpl $0x5c, -0xc(%rbp)
jne 0x8e67
callq 0x8a80
movl %eax, -0xc(%rbp)
addl $-0x22, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x56, %eax
ja 0x8e56
movq -0x18(%rbp), %rax
leaq 0x4c61(%rip), %rcx      # 0xd9b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x7, -0x4(%rbp)
jmp 0x8e6d
movl $0x8, -0x4(%rbp)
jmp 0x8e6d
movl $0xc, -0x4(%rbp)
jmp 0x8e6d
movl $0xa, -0x4(%rbp)
jmp 0x8e6d
movl $0xd, -0x4(%rbp)
jmp 0x8e6d
movl $0x9, -0x4(%rbp)
jmp 0x8e6d
movl $0xb, -0x4(%rbp)
jmp 0x8e6d
movl $0x5c, -0x4(%rbp)
jmp 0x8e6d
movl $0x22, -0x4(%rbp)
jmp 0x8e6d
movl $0x27, -0x4(%rbp)
jmp 0x8e6d
movl $0x0, -0x10(%rbp)
movl $0x0, -0x8(%rbp)
callq 0x2170
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x800, %ecx            # imm = 0x800
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x8e08
cmpl $0x38, -0xc(%rbp)
setl %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x8e11
jmp 0x8e3c
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
cmpl $0x3, %eax
jle 0x8e21
jmp 0x8e3c
movl -0x10(%rbp), %eax
shll $0x3, %eax
movl -0xc(%rbp), %ecx
subl $0x30, %ecx
addl %ecx, %eax
movl %eax, -0x10(%rbp)
callq 0x8a80
movl %eax, -0xc(%rbp)
jmp 0x8dde
movl -0xc(%rbp), %edi
callq 0x8c40
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8e6d
callq 0x9370
movl %eax, -0x4(%rbp)
jmp 0x8e6d
movl -0xc(%rbp), %esi
leaq 0x4e51(%rip), %rdi      # 0xdcb1
callq 0x81f0
jmp 0x8e67
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ejunjsh[P]mycc/scan.c
// Function: scanstr
static int scanstr(char *buf) {
  int i, c;

  // 循环直到没有缓存
  for (i = 0; i < TEXTLEN - 1; i++) {
    // 获取下一个字符，并放入到buf， 直到遇到双引号
    if ((c = scanch()) == '"') {
      buf[i] = 0;
      return (i);
    }
    buf[i] = (char)c;
  }

  // 用完buf[]空间
  fatal("String literal too long");
  return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x1ff, -0x14(%rbp)     # imm = 0x1FF
jge 0x8ed8
callq 0x8d10
movl %eax, -0x18(%rbp)
cmpl $0x22, %eax
jne 0x8ebd
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8eeb
movl -0x18(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8e93
leaq 0x4e22(%rip), %rdi      # 0xdd01
callq 0x8110
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ejunjsh[P]mycc/scan.c
// Function: scanident
static int scanident(int c, char *buf, int lim) {
  int i = 0;

  // 允许数字，字母，下划线
  while (isalpha(c) || isdigit(c) || '_' == c) {
    // 如果超过标识符长度限制，就报错，
    // 否则放入到buf[],并获取下个字符
    if (lim - 1 == i) {
      fatal("Identifier too long");
    } else if (i < lim - 1) {
      buf[i++] = (char)c;
    }
    c = next();
  }

  // 遇到无效字符，放回
  // 0作为终结符放到buf[]中，并返回长度
  putback(c);
  buf[i] = '\0';
  return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
callq 0x2170
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x400, %ecx            # imm = 0x400
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
jne 0x8f67
callq 0x2170
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x800, %ecx            # imm = 0x800
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
jne 0x8f67
movl $0x5f, %eax
cmpl -0x4(%rbp), %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x8f70
jmp 0x8fbf
movl -0x14(%rbp), %eax
subl $0x1, %eax
cmpl -0x18(%rbp), %eax
jne 0x8f89
leaq 0x4d97(%rip), %rdi      # 0xdd19
callq 0x8110
jmp 0x8fb2
movl -0x18(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x8fb0
movl -0x4(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x18(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x8fb2
callq 0x8a80
movl %eax, -0x4(%rbp)
jmp 0x8f19
movl -0x4(%rbp), %edi
callq 0x8c40
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ejunjsh[P]mycc/scan.c
// Function: chrpos
static int chrpos(char *s, int c) {
  int i;
  for (i = 0; s[i] != '\0'; i++)
    if (s[i] == (char) c)
      return (i);
  return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x935e
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl -0x14(%rbp), %ecx
movsbl %cl, %ecx
cmpl %ecx, %eax
jne 0x9351
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9365
jmp 0x9353
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x9322
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ejunjsh[P]mycc/scan.c
// Function: hexchar
static int hexchar(void) {
  int c, h, n = 0, f = 0;

  // 循环获取字符
  while (isxdigit(c = next())) {
    // 转换字符为整型
    h = chrpos("0123456789abcdef", tolower(c));

    // Add to running hex value
    // 加到已有的16进制值
    n = n * 16 + h;
    f = 1;
  }

  // 碰到一个非16进制字符，放回
  putback(c);

  // 标志告诉我们，没有看到任何16进制字符
  if (!f)
    fatal("missing digits after '\\x'");
  if (n > 255)
    fatal("value out of range after '\\x'");

  return (n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
callq 0x2170
movq (%rax), %rax
movq %rax, -0x18(%rbp)
callq 0x8a80
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0x4(%rbp)
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
je 0x93df
movl -0x4(%rbp), %edi
callq 0x20f0
movl %eax, %esi
leaq 0x48bd(%rip), %rdi      # 0xdc7f
callq 0x9310
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
shll $0x4, %eax
addl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
jmp 0x9386
movl -0x4(%rbp), %edi
callq 0x8c40
cmpl $0x0, -0x10(%rbp)
jne 0x93f9
leaq 0x48d5(%rip), %rdi      # 0xdcc9
callq 0x8110
cmpl $0xff, -0xc(%rbp)
jle 0x940e
leaq 0x48da(%rip), %rdi      # 0xdce3
callq 0x8110
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ejunjsh[P]mycc/stmt.c
// Function: compound_statement
struct ASTnode *compound_statement(int inswitch) {
  struct ASTnode *left = NULL;
  struct ASTnode *tree;

  while (1) {
    // 遇到结束token,
    // 先判断结束token,来允许空的组合语句
    if (Token.token == T_RBRACE)
      return (left);
    if (inswitch && (Token.token == T_CASE || Token.token == T_DEFAULT))
      return (left);

    // 解析单一语句
    tree = single_statement();

    // 对于每个新tree,如果left为空,就保存到left上
    // 否则跟left粘在一起
    if (tree != NULL) {
      if (left == NULL)
	      left = tree;
      else
	      left = mkastnode(A_GLUE, P_NONE, NULL, left, NULL, tree, NULL, 0);
    }
  }
  return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
leaq 0x90f6(%rip), %rax      # 0x12530
cmpl $0x38, (%rax)
jne 0x944c
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x94cc
cmpl $0x0, -0xc(%rbp)
je 0x9474
leaq 0x90d7(%rip), %rax      # 0x12530
cmpl $0x2f, (%rax)
je 0x946a
leaq 0x90cb(%rip), %rax      # 0x12530
cmpl $0x30, (%rax)
jne 0x9474
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x94cc
callq 0x94e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x94c7
cmpq $0x0, -0x18(%rbp)
jne 0x9495
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x94c5
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r9
movl $0x1d, %edi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
movq $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0xac90
movq %rax, -0x18(%rbp)
jmp 0x94c7
jmp 0x9433
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ejunjsh[P]mycc/stmt.c
// Function: if_statement
static struct ASTnode *if_statement(void) {
  struct ASTnode *condAST, *trueAST, *falseAST = NULL;

  // 确认有'if' '('
  match(T_IF, "if");
  lparen();

  // 解析接下来的表达式和')'
  // 强制把一个不可比较的操作转成可比较（A_TOBOOL）
  condAST = binexpr(0);
  if (condAST->op < A_EQ || condAST->op > A_GE)
    condAST =
      mkastunary(A_TOBOOL, condAST->type, condAST->ctype, condAST, NULL, 0);
  rparen();

  // 获得true时候的语句
  trueAST = single_statement();

  // 如果有'else'，跳过它，
  // 继续获得false的语句
  if (Token.token == T_ELSE) {
    scan(&Token);
    falseAST = single_statement();
  }

  // 创建一个A_IF的语法树，并返回
  return (mkastnode(A_IF, P_NONE, NULL, condAST, trueAST, falseAST, NULL, 0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq $0x0, -0x18(%rbp)
movl $0x22, %edi
leaq 0x44c5(%rip), %rsi      # 0xdbb1
callq 0x7f70
callq 0x8090
xorl %edi, %edi
callq 0x58c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0xd, 0x4(%rax)
jl 0x9715
movq -0x8(%rbp), %rax
cmpl $0x12, 0x4(%rax)
jle 0x973e
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x8(%rbp), %rcx
movl $0x2e, %edi
xorl %eax, %eax
movl %eax, %r8d
xorl %r9d, %r9d
callq 0xada0
movq %rax, -0x8(%rbp)
callq 0x80b0
callq 0x94e0
movq %rax, -0x10(%rbp)
leaq 0x8ddd(%rip), %rax      # 0x12530
cmpl $0x23, (%rax)
jne 0x976d
leaq 0x8dd1(%rip), %rdi      # 0x12530
callq 0x84c0
callq 0x94e0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %r8
movq -0x18(%rbp), %r9
movl $0x1e, %edi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
movq $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0xac90
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ejunjsh[P]mycc/stmt.c
// Function: while_statement
static struct ASTnode *while_statement(void) {
  struct ASTnode *condAST, *bodyAST;

  // 保证有'while' '('
  match(T_WHILE, "while");
  lparen();

  // 解析接下来的表达式和')'
  // 强制把一个不可比较的操作转成可比较（A_TOBOOL）
  condAST = binexpr(0);
  if (condAST->op < A_EQ || condAST->op > A_GE)
    condAST =
      mkastunary(A_TOBOOL, condAST->type, condAST->ctype, condAST, NULL, 0);
  rparen();

  // 获得循环体语法树
  // 同时更新在这个过程中的循环深度
  Looplevel++;
  bodyAST = single_statement();
  Looplevel--;

  // 创建A_WHILE语法树并返回
  return (mkastnode(A_WHILE, P_NONE, NULL, condAST, NULL, bodyAST, NULL, 0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x24, %edi
leaq 0x4405(%rip), %rsi      # 0xdbb9
callq 0x7f70
callq 0x8090
xorl %edi, %edi
callq 0x58c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0xd, 0x4(%rax)
jl 0x97dd
movq -0x8(%rbp), %rax
cmpl $0x12, 0x4(%rax)
jle 0x9806
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x8(%rbp), %rcx
movl $0x2e, %edi
xorl %eax, %eax
movl %eax, %r8d
xorl %r9d, %r9d
callq 0xada0
movq %rax, -0x8(%rbp)
callq 0x80b0
leaq 0x8f52(%rip), %rax      # 0x12764
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x8f46(%rip), %rax      # 0x12764
movl %ecx, (%rax)
callq 0x94e0
movq %rax, -0x10(%rbp)
leaq 0x8f34(%rip), %rax      # 0x12764
movl (%rax), %ecx
addl $-0x1, %ecx
leaq 0x8f28(%rip), %rax      # 0x12764
movl %ecx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %r9
movl $0x1f, %edi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
movq $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0xac90
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ejunjsh[P]mycc/stmt.c
// Function: for_statement
static struct ASTnode *for_statement(void) {
  struct ASTnode *condAST, *bodyAST;
  struct ASTnode *preopAST, *postopAST;
  struct ASTnode *tree;

  // 保证有'for' '('
  match(T_FOR, "for");
  lparen();

  // 获取for循环第一个表达式，和后面的';'
  preopAST = expression_list(T_SEMI);
  semi();

  // 获得条件表达式和';'
  // 强制把一个不可比较的操作转成可比较（A_TOBOOL）
  condAST = binexpr(0);
  if (condAST->op < A_EQ || condAST->op > A_GE)
    condAST =
      mkastunary(A_TOBOOL, condAST->type, condAST->ctype, condAST, NULL, 0);
  semi();

  // 获得最后的表达式和')'
  postopAST = expression_list(T_RPAREN);
  rparen();

  // 获得循环体语法树
  // 同时更新在这个过程中的循环深度
  Looplevel++;
  bodyAST = single_statement();
  Looplevel--;

  // 把循环体语句和最后的表达式黏在一起
  tree = mkastnode(A_GLUE, P_NONE, NULL, bodyAST, NULL, postopAST, NULL, 0);

  // 然后跟条件表达式合成一个WHILE循环语句（这里就是强制把一个for循环变成一个while循环）
  tree = mkastnode(A_WHILE, P_NONE, NULL, condAST, NULL, tree, NULL, 0);

  // 把第一个表达式跟WHILE循环黏在一起
  return (mkastnode(A_GLUE, P_NONE, NULL, preopAST, NULL, tree, NULL, 0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x25, %edi
leaq 0x433b(%rip), %rsi      # 0xdbbf
callq 0x7f70
callq 0x8090
movl $0x35, %edi
callq 0x5820
movq %rax, -0x18(%rbp)
callq 0x8030
xorl %edi, %edi
callq 0x58c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0xd, 0x4(%rax)
jl 0x98c0
movq -0x8(%rbp), %rax
cmpl $0x12, 0x4(%rax)
jle 0x98e9
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x8(%rbp), %rcx
movl $0x2e, %edi
xorl %eax, %eax
movl %eax, %r8d
xorl %r9d, %r9d
callq 0xada0
movq %rax, -0x8(%rbp)
callq 0x8030
movl $0x3a, %edi
callq 0x5820
movq %rax, -0x20(%rbp)
callq 0x80b0
leaq 0x8e5c(%rip), %rax      # 0x12764
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x8e50(%rip), %rax      # 0x12764
movl %ecx, (%rax)
callq 0x94e0
movq %rax, -0x10(%rbp)
leaq 0x8e3e(%rip), %rax      # 0x12764
movl (%rax), %ecx
addl $-0x1, %ecx
leaq 0x8e32(%rip), %rax      # 0x12764
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %r9
movl $0x1d, %edi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
movq $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0xac90
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %r9
movl $0x1f, %edi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
movq $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0xac90
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %r9
movl $0x1d, %edi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
movq $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0xac90
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ejunjsh[P]mycc/stmt.c
// Function: return_statement
static struct ASTnode *return_statement(void) {
  struct ASTnode *tree= NULL;

  // 保证有个 'return'
  match(T_RETURN, "return");

  // 检查是否有返回值
  if (Token.token == T_LPAREN) {
    // 如果函数返回类型为P_VOID,报错
    if (Functionid->type == P_VOID)
      fatal("Can't return from a void function");

    // 跳过左括号
    lparen();

    // 解析接下来的表达式
    tree = binexpr(0);

    // 保证返回值跟函数返回类型是兼容的
    tree = modify_type(tree, Functionid->type, Functionid->ctype, 0);
    if (tree == NULL)
      fatal("Incompatible type to return");

    // 保证有个')'
    rparen();
  }

  // 包装为A_RETURN节点
  tree = mkastunary(A_RETURN, P_NONE, NULL, tree, NULL, 0);

  // 保证有';'
  semi();
  return (tree);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, -0x8(%rbp)
movl $0x26, %edi
leaq 0x43df(%rip), %rsi      # 0xddcb
callq 0x7f70
leaq 0x8b38(%rip), %rax      # 0x12530
cmpl $0x39, (%rax)
jne 0x9a6b
leaq 0x8b04(%rip), %rax      # 0x12508
movq (%rax), %rax
cmpl $0x10, 0x10(%rax)
jne 0x9a19
leaq 0x4380(%rip), %rdi      # 0xdd94
callq 0x8110
callq 0x8090
xorl %edi, %edi
callq 0x58c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x8ad4(%rip), %rax      # 0x12508
movq (%rax), %rax
movl 0x10(%rax), %esi
leaq 0x8ac7(%rip), %rax      # 0x12508
movq (%rax), %rax
movq 0x18(%rax), %rdx
xorl %ecx, %ecx
callq 0xb800
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x9a66
leaq 0x4355(%rip), %rdi      # 0xddb6
callq 0x8110
callq 0x80b0
movq -0x8(%rbp), %rcx
movl $0x22, %edi
xorl %r9d, %r9d
xorl %eax, %eax
movl %eax, %r8d
movl %r9d, %esi
movq %r8, %rdx
callq 0xada0
movq %rax, -0x8(%rbp)
callq 0x8030
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ejunjsh[P]mycc/stmt.c
// Function: break_statement
static struct ASTnode *break_statement(void) {

  if (Looplevel == 0 && Switchlevel == 0)
    fatal("no loop or switch to break out from");
  scan(&Token);
  semi();
  return (mkastleaf(A_BREAK, P_NONE, NULL, NULL, 0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x8cb9(%rip), %rax      # 0x12764
cmpl $0x0, (%rax)
jne 0x9ac8
leaq 0x8cb1(%rip), %rax      # 0x12768
cmpl $0x0, (%rax)
jne 0x9ac8
leaq 0x430f(%rip), %rdi      # 0xddd2
callq 0x8110
leaq 0x8a61(%rip), %rdi      # 0x12530
callq 0x84c0
callq 0x8030
movl $0x2f, %edi
xorl %r8d, %r8d
xorl %eax, %eax
movl %eax, %ecx
movl %r8d, %esi
movq %rcx, %rdx
callq 0xad50
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ejunjsh[P]mycc/stmt.c
// Function: continue_statement
static struct ASTnode *continue_statement(void) {

  if (Looplevel == 0)
    fatal("no loop to continue to");
  scan(&Token);
  semi();
  return (mkastleaf(A_CONTINUE, P_NONE, NULL, NULL, 0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x8c59(%rip), %rax      # 0x12764
cmpl $0x0, (%rax)
jne 0x9b1c
leaq 0x42df(%rip), %rdi      # 0xddf6
callq 0x8110
leaq 0x8a0d(%rip), %rdi      # 0x12530
callq 0x84c0
callq 0x8030
movl $0x30, %edi
xorl %r8d, %r8d
xorl %eax, %eax
movl %eax, %ecx
movl %r8d, %esi
movq %rcx, %rdx
callq 0xad50
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ejunjsh[P]mycc/sym.c
// Function: appendsym
void appendsym(struct symtable **head, struct symtable **tail,
	       struct symtable *node) {

  // 检查指针的有效性
  if (head == NULL || tail == NULL || node == NULL)
    fatal("Either head, tail or node is NULL in appendsym");

  // 加到列表
  if (*tail) {
    (*tail)->next = node;
    *tail = node;
  } else
    *head = *tail = node;
  node->next = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x9e09
cmpq $0x0, -0x10(%rbp)
je 0x9e09
cmpq $0x0, -0x18(%rbp)
jne 0x9e15
leaq 0x40e8(%rip), %rdi      # 0xdef8
callq 0x8110
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x9e3b
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x9e4d
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x38(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop