LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/generator.c
// Function: EmitDivToMemory
static void EmitDivToMemory(struct Node *op, int dst, int src, int size) {
  if (size == 4) {
    // rax <- rdx:rax / r/m
    printf("xor rdx, rdx\n");
    printf("mov eax, [%s]\n", reg_names_64[dst]);
    printf("idiv %s\n", reg_names_64[src]);
    printf("mov [%s], eax\n", reg_names_64[dst]);
    return;
  }
  ErrorWithToken(op, "Assigning %d bytes is not implemented.", size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jne 0x83d6
leaq 0x89ce(%rip), %rdi      # 0x10d40
movb $0x0, %al
callq 0x2080
movslq -0xc(%rbp), %rcx
leaq 0xcd6c(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
leaq 0x8cff(%rip), %rdi      # 0x1108e
movb $0x0, %al
callq 0x2080
movslq -0x10(%rbp), %rcx
leaq 0xcd4f(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
leaq 0x89b8(%rip), %rdi      # 0x10d64
movb $0x0, %al
callq 0x2080
movslq -0xc(%rbp), %rcx
leaq 0xcd32(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
leaq 0x8cb6(%rip), %rdi      # 0x1107f
movb $0x0, %al
callq 0x2080
addq $0x20, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x856a(%rip), %rsi      # 0x1094e
movb $0x0, %al
callq 0x4d50
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/generator.c
// Function: EmitModToMemory
static void EmitModToMemory(struct Node *op, int dst, int src, int size) {
  if (size == 4) {
    // rdx <- rdx:rax % r/m
    printf("xor rdx, rdx\n");
    printf("mov eax, [%s]\n", reg_names_64[dst]);
    printf("idiv %s\n", reg_names_64[src]);
    printf("mov [%s], edx\n", reg_names_64[dst]);
    return;
  }
  ErrorWithToken(op, "Assigning %d bytes is not implemented.", size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jne 0x8476
leaq 0x892e(%rip), %rdi      # 0x10d40
movb $0x0, %al
callq 0x2080
movslq -0xc(%rbp), %rcx
leaq 0xcccc(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
leaq 0x8c5f(%rip), %rdi      # 0x1108e
movb $0x0, %al
callq 0x2080
movslq -0x10(%rbp), %rcx
leaq 0xccaf(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
leaq 0x8918(%rip), %rdi      # 0x10d64
movb $0x0, %al
callq 0x2080
movslq -0xc(%rbp), %rcx
leaq 0xcc92(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
leaq 0x8c34(%rip), %rdi      # 0x1109d
movb $0x0, %al
callq 0x2080
addq $0x20, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x84ca(%rip), %rsi      # 0x1094e
movb $0x0, %al
callq 0x4d50
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/generator.c
// Function: EmitLShiftMemory
static void EmitLShiftMemory(struct Node *op, int dst, int src, int size) {
  if (size == 4) {
    printf("mov ecx, %s\n", reg_names_32[src]);
    printf("shl dword ptr [%s], cl\n", reg_names_64[dst]);
    return;
  }
  ErrorWithToken(op, "Assigning %d bytes is not implemented.", size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jne 0x84eb
movslq -0x10(%rbp), %rcx
leaq 0xcc9a(%rip), %rax      # 0x15150
movq (%rax,%rcx,8), %rsi
leaq 0x8beb(%rip), %rdi      # 0x110ac
movb $0x0, %al
callq 0x2080
movslq -0xc(%rbp), %rcx
leaq 0xcc1d(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
leaq 0x8bdb(%rip), %rdi      # 0x110b9
movb $0x0, %al
callq 0x2080
addq $0x20, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x8455(%rip), %rsi      # 0x1094e
movb $0x0, %al
callq 0x4d50
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/generator.c
// Function: EmitRShiftMemory
static void EmitRShiftMemory(struct Node *op, int dst, int src, int size) {
  if (size == 4) {
    printf("mov ecx, %s\n", reg_names_32[src]);
    printf("shr dword ptr [%s], cl\n", reg_names_64[dst]);
    return;
  }
  ErrorWithToken(op, "Assigning %d bytes is not implemented.", size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jne 0x855b
movslq -0x10(%rbp), %rcx
leaq 0xcc2a(%rip), %rax      # 0x15150
movq (%rax,%rcx,8), %rsi
leaq 0x8b7b(%rip), %rdi      # 0x110ac
movb $0x0, %al
callq 0x2080
movslq -0xc(%rbp), %rcx
leaq 0xcbad(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
leaq 0x8b83(%rip), %rdi      # 0x110d1
movb $0x0, %al
callq 0x2080
addq $0x20, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x83e5(%rip), %rsi      # 0x1094e
movb $0x0, %al
callq 0x4d50
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/parser.c
// Function: ParsePrimaryExpr
struct Node *ParsePrimaryExpr() {
  struct Node *t;
  if ((t = ConsumeToken(kTokenIntegerConstant)) ||
      (t = ConsumeToken(kTokenIdent)) ||
      (t = ConsumeToken(kTokenCharLiteral)) ||
      (t = ConsumeToken(kTokenStringLiteral))) {
    struct Node *op = AllocNode(kASTExpr);
    op->op = t;
    return op;
  }
  if ((t = ConsumePunctuator("("))) {
    struct Node *op = AllocNode(kASTExpr);
    op->op = t;
    op->right = ParseExpr();
    if (!op->right) ErrorWithToken(t, "Expected expr after this token");
    ExpectPunctuator(")");
    return op;
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x3, %edi
callq 0xc1c0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x8688
movl $0x4, %edi
callq 0xc1c0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x8688
movl $0x17, %edi
callq 0xc1c0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x8688
movl $0x18, %edi
callq 0xc1c0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x86ac
movl $0x4, %edi
callq 0x3a70
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8727
leaq 0x7e81(%rip), %rdi      # 0x10534
callq 0xc320
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x871f
movl $0x4, %edi
callq 0x3a70
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
callq 0x8740
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x8709
movq -0x10(%rbp), %rdi
leaq 0x8a3b(%rip), %rsi      # 0x1113d
movb $0x0, %al
callq 0x4d50
leaq 0x9035(%rip), %rdi      # 0x11745
callq 0xc390
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8727
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/parser.c
// Function: ParseExpr
struct Node *ParseExpr() {
  struct Node *op = ParseAssignExpr();
  if (!op) return NULL;
  struct Node *t;
  while ((t = ConsumePunctuator(","))) {
    op = CreateASTBinOp(t, op, ParseAssignExpr());
  }
  return op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0x9240
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8762
movq $0x0, -0x8(%rbp)
jmp 0x87ad
jmp 0x8764
leaq 0x7a7f(%rip), %rdi      # 0x101ea
callq 0xc320
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x87a5
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x9240
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
callq 0x3ab0
movq %rax, -0x10(%rbp)
jmp 0x8764
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/parser.c
// Function: ParseUnaryExpr
struct Node *ParseUnaryExpr() {
  struct Node *t;
  if ((t = ConsumePunctuator("+")) || (t = ConsumePunctuator("-")) ||
      (t = ConsumePunctuator("~")) || (t = ConsumePunctuator("!")) ||
      (t = ConsumePunctuator("&")) || (t = ConsumePunctuator("*"))) {
    return CreateASTUnaryPrefixOp(t, ParseCastExpr());
  } else if ((t = ConsumePunctuator("--")) || (t = ConsumePunctuator("++")) ||
             (t = ConsumeToken(kTokenKwSizeof))) {
    return CreateASTUnaryPrefixOp(t, ParseUnaryExpr());
  }
  return ParsePostfixExpr();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x7799(%rip), %rdi      # 0x10178
callq 0xc320
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x8a5c
leaq 0x7780(%rip), %rdi      # 0x10175
callq 0xc320
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x8a5c
leaq 0x8275(%rip), %rdi      # 0x10c80
callq 0xc320
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x8a5c
leaq 0x8269(%rip), %rdi      # 0x10c8a
callq 0xc320
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x8a5c
leaq 0x82d8(%rip), %rdi      # 0x10d0f
callq 0xc320
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x8a5c
leaq 0x7752(%rip), %rdi      # 0x1019f
callq 0xc320
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x8a7b
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x8af0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x3b20
movq %rax, -0x8(%rbp)
jmp 0x8ae5
leaq 0x76f2(%rip), %rdi      # 0x10174
callq 0xc320
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x8abb
leaq 0x76df(%rip), %rdi      # 0x10177
callq 0xc320
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x8abb
movl $0x10, %edi
callq 0xc1c0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x8ada
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x89d0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x3b20
movq %rax, -0x8(%rbp)
jmp 0x8ae5
jmp 0x8adc
callq 0x87c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/parser.c
// Function: ParseMulExpr
struct Node *ParseMulExpr() {
  struct Node *op = ParseCastExpr();
  if (!op) return NULL;
  struct Node *t;
  while ((t = ConsumePunctuator("*")) || (t = ConsumePunctuator("/")) ||
         (t = ConsumePunctuator("%"))) {
    op = CreateASTBinOp(t, op, ParseCastExpr());
  }
  return op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0x8af0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8b25
movq $0x0, -0x8(%rbp)
jmp 0x8bbc
jmp 0x8b27
leaq 0x7671(%rip), %rdi      # 0x1019f
callq 0xc320
movq %rax, %rcx
movq %rcx, -0x18(%rbp)
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x19(%rbp)
jne 0x8b7d
leaq 0x876b(%rip), %rdi      # 0x112b7
callq 0xc320
movq %rax, %rcx
movq %rcx, -0x18(%rbp)
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x19(%rbp)
jne 0x8b7d
leaq 0x8203(%rip), %rdi      # 0x10d6d
callq 0xc320
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x8b86
jmp 0x8bb4
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x8af0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x3ab0
movq %rax, -0x10(%rbp)
jmp 0x8b27
movq -0x10(%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/hikalium[P]compilium/parser.c
// Function: ParseAddExpr
struct Node *ParseAddExpr() {
  struct Node *op = ParseMulExpr();
  if (!op) return NULL;
  struct Node *t;
  while ((t = ConsumePunctuator("+")) || (t = ConsumePunctuator("-"))) {
    op = CreateASTBinOp(t, op, ParseMulExpr());
  }
  return op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0x8b00
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8bf2
movq $0x0, -0x8(%rbp)
jmp 0x8c68
jmp 0x8bf4
leaq 0x757d(%rip), %rdi      # 0x10178
callq 0xc320
movq %rax, %rcx
movq %rcx, -0x18(%rbp)
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x19(%rbp)
jne 0x8c2c
leaq 0x755c(%rip), %rdi      # 0x10175
callq 0xc320
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x8c35
jmp 0x8c60
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x8b00
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x3ab0
movq %rax, -0x10(%rbp)
jmp 0x8bf4
movq -0x10(%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/hikalium[P]compilium/parser.c
// Function: ParseShiftExpr
struct Node *ParseShiftExpr() {
  struct Node *op = ParseAddExpr();
  if (!op) return NULL;
  struct Node *t;
  while ((t = ConsumePunctuator("<<")) || (t = ConsumePunctuator(">>"))) {
    op = CreateASTBinOp(t, op, ParseAddExpr());
  }
  return op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0x8bd0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8ca2
movq $0x0, -0x8(%rbp)
jmp 0x8d18
jmp 0x8ca4
leaq 0x80d1(%rip), %rdi      # 0x10d7c
callq 0xc320
movq %rax, %rcx
movq %rcx, -0x18(%rbp)
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x19(%rbp)
jne 0x8cdc
leaq 0x80cf(%rip), %rdi      # 0x10d98
callq 0xc320
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x8ce5
jmp 0x8d10
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x8bd0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x3ab0
movq %rax, -0x10(%rbp)
jmp 0x8ca4
movq -0x10(%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/hikalium[P]compilium/parser.c
// Function: ParseRelExpr
struct Node *ParseRelExpr() {
  struct Node *op = ParseShiftExpr();
  if (!op) return NULL;
  struct Node *t;
  while ((t = ConsumePunctuator("<")) || (t = ConsumePunctuator(">")) ||
         (t = ConsumePunctuator("<=")) || (t = ConsumePunctuator(">="))) {
    op = CreateASTBinOp(t, op, ParseShiftExpr());
  }
  return op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0x8c80
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8d55
movq $0x0, -0x8(%rbp)
jmp 0x8e0a
jmp 0x8d57
leaq 0x801f(%rip), %rdi      # 0x10d7d
callq 0xc320
movq %rax, %rcx
movq %rcx, -0x18(%rbp)
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x19(%rbp)
jne 0x8dcb
leaq 0x72e2(%rip), %rdi      # 0x1005e
callq 0xc320
movq %rax, %rcx
movq %rcx, -0x18(%rbp)
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x19(%rbp)
jne 0x8dcb
leaq 0x7f93(%rip), %rdi      # 0x10d2d
callq 0xc320
movq %rax, %rcx
movq %rcx, -0x18(%rbp)
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x19(%rbp)
jne 0x8dcb
leaq 0x7f79(%rip), %rdi      # 0x10d31
callq 0xc320
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x8dd4
jmp 0x8e02
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x8c80
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x3ab0
movq %rax, -0x10(%rbp)
jmp 0x8d57
movq -0x10(%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/hikalium[P]compilium/parser.c
// Function: ParseEqExpr
struct Node *ParseEqExpr() {
  struct Node *op = ParseRelExpr();
  if (!op) return NULL;
  struct Node *t;
  while ((t = ConsumePunctuator("==")) || (t = ConsumePunctuator("!="))) {
    op = CreateASTBinOp(t, op, ParseRelExpr());
  }
  return op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0x8d30
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8e42
movq $0x0, -0x8(%rbp)
jmp 0x8eb8
jmp 0x8e44
leaq 0x7f5f(%rip), %rdi      # 0x10daa
callq 0xc320
movq %rax, %rcx
movq %rcx, -0x18(%rbp)
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x19(%rbp)
jne 0x8e7c
leaq 0x7f44(%rip), %rdi      # 0x10dad
callq 0xc320
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x8e85
jmp 0x8eb0
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x8d30
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x3ab0
movq %rax, -0x10(%rbp)
jmp 0x8e44
movq -0x10(%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/hikalium[P]compilium/parser.c
// Function: ParseAndExpr
struct Node *ParseAndExpr() {
  struct Node *op = ParseEqExpr();
  if (!op) return NULL;
  struct Node *t;
  while ((t = ConsumePunctuator("&"))) {
    op = CreateASTBinOp(t, op, ParseEqExpr());
  }
  return op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0x8e20
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8ef2
movq $0x0, -0x8(%rbp)
jmp 0x8f3d
jmp 0x8ef4
leaq 0x7e14(%rip), %rdi      # 0x10d0f
callq 0xc320
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x8f35
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x8e20
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
callq 0x3ab0
movq %rax, -0x10(%rbp)
jmp 0x8ef4
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/parser.c
// Function: ParseXorExpr
struct Node *ParseXorExpr() {
  struct Node *op = ParseAndExpr();
  if (!op) return NULL;
  struct Node *t;
  while ((t = ConsumePunctuator("^"))) {
    op = CreateASTBinOp(t, op, ParseAndExpr());
  }
  return op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0x8ed0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8f72
movq $0x0, -0x8(%rbp)
jmp 0x8fbd
jmp 0x8f74
leaq 0x7e41(%rip), %rdi      # 0x10dbc
callq 0xc320
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x8fb5
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x8ed0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
callq 0x3ab0
movq %rax, -0x10(%rbp)
jmp 0x8f74
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/parser.c
// Function: ParseOrExpr
struct Node *ParseOrExpr() {
  struct Node *op = ParseXorExpr();
  if (!op) return NULL;
  struct Node *t;
  while ((t = ConsumePunctuator("|"))) {
    op = CreateASTBinOp(t, op, ParseXorExpr());
  }
  return op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0x8f50
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8ff2
movq $0x0, -0x8(%rbp)
jmp 0x903d
jmp 0x8ff4
leaq 0x7d17(%rip), %rdi      # 0x10d12
callq 0xc320
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x9035
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x8f50
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
callq 0x3ab0
movq %rax, -0x10(%rbp)
jmp 0x8ff4
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/parser.c
// Function: ParseBoolAndExpr
struct Node *ParseBoolAndExpr() {
  struct Node *op = ParseOrExpr();
  if (!op) return NULL;
  struct Node *t;
  while ((t = ConsumePunctuator("&&"))) {
    op = CreateASTBinOp(t, op, ParseOrExpr());
  }
  return op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0x8fd0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x9072
movq $0x0, -0x8(%rbp)
jmp 0x90bd
jmp 0x9074
leaq 0x7c93(%rip), %rdi      # 0x10d0e
callq 0xc320
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x90b5
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x8fd0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
callq 0x3ab0
movq %rax, -0x10(%rbp)
jmp 0x9074
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/parser.c
// Function: ParseBoolOrExpr
struct Node *ParseBoolOrExpr() {
  struct Node *op = ParseBoolAndExpr();
  if (!op) return NULL;
  struct Node *t;
  while ((t = ConsumePunctuator("||"))) {
    op = CreateASTBinOp(t, op, ParseBoolAndExpr());
  }
  return op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0x9050
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x90f2
movq $0x0, -0x8(%rbp)
jmp 0x913d
jmp 0x90f4
leaq 0x7c16(%rip), %rdi      # 0x10d11
callq 0xc320
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x9135
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x9050
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
callq 0x3ab0
movq %rax, -0x10(%rbp)
jmp 0x90f4
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/parser.c
// Function: ParseConditionalExpr
struct Node *ParseConditionalExpr() {
  struct Node *expr = ParseBoolOrExpr();
  if (!expr) return NULL;
  struct Node *t;
  if ((t = ConsumePunctuator("?"))) {
    struct Node *op = AllocNode(kASTExpr);
    op->op = t;
    op->cond = expr;
    op->left = ParseConditionalExpr();
    if (!op->left)
      ErrorWithToken(t, "Expected true-expr for this conditional expr");
    ExpectPunctuator(":");
    op->right = ParseConditionalExpr();
    if (!op->right)
      ErrorWithToken(t, "Expected false-expr for this conditional expr");
    return op;
  }
  return expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x90d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x9175
movq $0x0, -0x8(%rbp)
jmp 0x922d
leaq 0x8008(%rip), %rdi      # 0x11184
callq 0xc320
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x9225
movl $0x4, %edi
callq 0x3a70
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
callq 0x9150
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x91e2
movq -0x18(%rbp), %rdi
leaq 0x7fab(%rip), %rsi      # 0x11186
movb $0x0, %al
callq 0x4d50
leaq 0x7352(%rip), %rdi      # 0x1053b
callq 0xc390
callq 0x9150
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x921b
movq -0x18(%rbp), %rdi
leaq 0x7f9f(%rip), %rsi      # 0x111b3
movb $0x0, %al
callq 0x4d50
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x922d
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/parser.c
// Function: ParseAssignExpr
struct Node *ParseAssignExpr() {
  struct Node *left = ParseConditionalExpr();
  if (!left) return NULL;
  struct Node *t;
  if ((t = ConsumePunctuator("=")) || (t = ConsumePunctuator("+=")) ||
      (t = ConsumePunctuator("-=")) || (t = ConsumePunctuator("*=")) ||
      (t = ConsumePunctuator("/=")) || (t = ConsumePunctuator("%=")) ||
      (t = ConsumePunctuator("<<=")) || (t = ConsumePunctuator(">>="))) {
    struct Node *right = ParseAssignExpr();
    if (!right) ErrorWithToken(t, "Expected expr after this token");
    return CreateASTBinOp(t, left, right);
  }
  return left;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x9150
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x9265
movq $0x0, -0x8(%rbp)
jmp 0x935e
leaq 0x7b42(%rip), %rdi      # 0x10dae
callq 0xc320
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x931d
leaq 0x7a97(%rip), %rdi      # 0x10d1d
callq 0xc320
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x931d
leaq 0x7a80(%rip), %rdi      # 0x10d20
callq 0xc320
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x931d
leaq 0x7a6d(%rip), %rdi      # 0x10d23
callq 0xc320
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x931d
leaq 0x7a5a(%rip), %rdi      # 0x10d26
callq 0xc320
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x931d
leaq 0x7a47(%rip), %rdi      # 0x10d29
callq 0xc320
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x931d
leaq 0x7a34(%rip), %rdi      # 0x10d2c
callq 0xc320
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x931d
leaq 0x7a22(%rip), %rdi      # 0x10d30
callq 0xc320
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x9356
callq 0x9240
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x933f
movq -0x18(%rbp), %rdi
leaq 0x7e05(%rip), %rsi      # 0x1113d
movb $0x0, %al
callq 0x4d50
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3ab0
movq %rax, -0x8(%rbp)
jmp 0x935e
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/parser.c
// Function: ParseExprStmt
struct Node *ParseExprStmt() {
  struct Node *expr = ParseExpr();
  struct Node *t;
  if ((t = ConsumePunctuator(";"))) {
    return CreateASTExprStmt(t, expr);
  } else if (expr) {
    ExpectPunctuator(";");
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x8740
movq %rax, -0x10(%rbp)
leaq 0x87da(%rip), %rdi      # 0x11b62
callq 0xc320
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x93aa
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3c00
movq %rax, -0x8(%rbp)
jmp 0x93c7
cmpq $0x0, -0x10(%rbp)
je 0x93bd
leaq 0x87aa(%rip), %rdi      # 0x11b62
callq 0xc390
jmp 0x93bf
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/parser.c
// Function: ParseSelectionStmt
struct Node *ParseSelectionStmt() {
  struct Node *t;
  if ((t = ConsumeToken(kTokenKwIf))) {
    ExpectPunctuator("(");
    struct Node *expr = ParseExpr();
    assert(expr);
    ExpectPunctuator(")");
    struct Node *stmt_true = ParseStmt();
    assert(stmt_true);
    struct Node *stmt = AllocNode(kASTSelectionStmt);
    stmt->op = t;
    stmt->cond = expr;
    stmt->if_true_stmt = stmt_true;
    if (ConsumeToken(kTokenKwElse)) {
      stmt->if_else_stmt = ParseStmt();
    }
    return stmt;
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0xc, %edi
callq 0xc1c0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x94c4
leaq 0x712d(%rip), %rdi      # 0x10534
callq 0xc390
callq 0x8740
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x9434
leaq 0x7db9(%rip), %rdi      # 0x111dc
leaq 0x7d51(%rip), %rsi      # 0x1117b
movl $0x103, %edx            # imm = 0x103
callq 0x4b20
leaq 0x830a(%rip), %rdi      # 0x11745
callq 0xc390
callq 0x9780
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x9468
leaq 0x7d8a(%rip), %rdi      # 0x111e1
leaq 0x7d1d(%rip), %rsi      # 0x1117b
movl $0x106, %edx            # imm = 0x106
callq 0x4b20
movl $0x9, %edi
callq 0x3a70
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x48(%rax)
movl $0x9, %edi
callq 0xc1c0
cmpq $0x0, %rax
je 0x94ba
callq 0x9780
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x94cc
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/parser.c
// Function: ParseJumpStmt
struct Node *ParseJumpStmt() {
  // jump-statement
  struct Node *t;
  if ((t = ConsumeToken(kTokenKwBreak)) ||
      (t = ConsumeToken(kTokenKwContinue))) {
    ExpectPunctuator(";");
    struct Node *stmt = AllocNode(kASTJumpStmt);
    stmt->op = t;
    return stmt;
  }
  if ((t = ConsumeToken(kTokenKwReturn))) {
    struct Node *expr = ParseExpr();
    ExpectPunctuator(";");
    struct Node *stmt = AllocNode(kASTJumpStmt);
    stmt->op = t;
    stmt->right = expr;
    return stmt;
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x5, %edi
callq 0xc1c0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x9510
movl $0x8, %edi
callq 0xc1c0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x9540
leaq 0x864b(%rip), %rdi      # 0x11b62
callq 0xc390
movl $0x8, %edi
callq 0x3a70
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x95a1
movl $0xf, %edi
callq 0xc1c0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x9599
callq 0x8740
movq %rax, -0x20(%rbp)
leaq 0x85fe(%rip), %rdi      # 0x11b62
callq 0xc390
movl $0x8, %edi
callq 0x3a70
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x95a1
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/parser.c
// Function: ParseStmt
struct Node *ParseStmt() {
  struct Node *stmt;
  if ((stmt = ParseExprStmt()) || (stmt = ParseJumpStmt()) ||
      (stmt = ParseSelectionStmt()) || (stmt = ParseCompStmt()) ||
      (stmt = ParseIterationStmt()))
    return stmt;
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x9370
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x97d3
callq 0x94e0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x97d3
callq 0x93e0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x97d3
callq 0x9e70
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x97d3
callq 0x95b0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x97dd
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x97e5
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/parser.c
// Function: ParseDecltor
struct Node *ParseDecltor() {
  struct Node *n = AllocNode(kASTDecltor);
  struct Node *pointer = NULL;
  struct Node *t;
  while ((t = ConsumePunctuator("*"))) {
    pointer = CreateTypePointer(pointer);
  }
  n->left = pointer;
  n->right = ParseDirectDecltor();
  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0xc, %edi
callq 0x3a70
movq %rax, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
leaq 0x651a(%rip), %rdi      # 0x1019f
callq 0xc320
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x9ca3
movq -0x10(%rbp), %rdi
callq 0x3e70
movq %rax, -0x10(%rbp)
jmp 0x9c7e
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0x9a40
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/parser.c
// Function: ParseInitDecltor
struct Node *ParseInitDecltor() {
  struct Node *decltor = ParseDecltor();
  if (!decltor) return NULL;
  struct Node *t;
  if (!(t = ConsumePunctuator("="))) return decltor;
  struct Node *init_expr = ParseAssignExpr();
  assert(init_expr);
  decltor->decltor_init_expr = CreateASTBinOp(t, NULL, init_expr);
  return decltor;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x9c60
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x9cf2
movq $0x0, -0x8(%rbp)
jmp 0x9d5e
leaq 0x70b5(%rip), %rdi      # 0x10dae
callq 0xc320
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x9d12
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9d5e
callq 0x9240
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x9d3a
leaq 0x7512(%rip), %rdi      # 0x1123b
leaq 0x744b(%rip), %rsi      # 0x1117b
movl $0x1e1, %edx            # imm = 0x1E1
callq 0x4b20
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x3ab0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/parser.c
// Function: ParseParamDecl
struct Node *ParseParamDecl() {
  struct Node *decl_specs = ParseDeclSpecs();
  if (!decl_specs) return NULL;
  struct Node *n = AllocNode(kASTDecl);
  n->op = decl_specs;
  n->right = ParseDecltor();
  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x97f0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x9d92
movq $0x0, -0x8(%rbp)
jmp 0x9dc4
movl $0xd, %edi
callq 0x3a70
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
callq 0x9c60
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/parser.c
// Function: ParseDeclBody
struct Node *ParseDeclBody() {
  struct Node *decl_specs = ParseDeclSpecs();
  if (!decl_specs) return NULL;
  struct Node *n = AllocNode(kASTDecl);
  n->op = decl_specs;
  n->right = ParseInitDecltor();
  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x97f0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x9df2
movq $0x0, -0x8(%rbp)
jmp 0x9e24
movl $0xd, %edi
callq 0x3a70
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
callq 0x9cd0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/parser.c
// Function: ParseDecl
struct Node *ParseDecl() {
  struct Node *decl_body = ParseDeclBody();
  if (!decl_body) return NULL;
  ExpectPunctuator(";");
  return decl_body;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x9dd0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x9e52
movq $0x0, -0x8(%rbp)
jmp 0x9e66
leaq 0x7d09(%rip), %rdi      # 0x11b62
callq 0xc390
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/parser.c
// Function: ParseCompStmt
struct Node *ParseCompStmt() {
  struct Node *t;
  if (!(t = ConsumePunctuator("{"))) return NULL;
  struct Node *list = AllocList();
  list->op = t;
  struct Node *stmt;
  while ((stmt = ParseDecl()) || (stmt = ParseStmt())) {
    PushToList(list, stmt);
  }
  ExpectPunctuator("}");
  return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x7399(%rip), %rdi      # 0x11218
callq 0xc320
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x9e98
movq $0x0, -0x8(%rbp)
jmp 0x9f05
movb $0x0, %al
callq 0x4e30
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
callq 0x9e30
movq %rax, %rcx
movq %rcx, -0x20(%rbp)
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x21(%rbp)
jne 0x9ed9
callq 0x9780
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x9ee2
jmp 0x9ef1
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4f10
jmp 0x9eaf
leaq 0x662f(%rip), %rdi      # 0x10527
callq 0xc390
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/parser.c
// Function: Parse
struct Node *Parse(struct Node **head_token) {
  InitParser(head_token);
  struct Node *list = AllocList();
  struct Node *decl_body;
  while ((decl_body = ParseDeclBody())) {
    if (ConsumePunctuator(";")) {
      PushToList(list, decl_body);
      assert(IsASTList(decl_body->op));
      if (IsASTDeclOfTypedef(decl_body)) {
        // typedef case
        struct Node *typedef_type = CreateTypeFromDecl(decl_body);
        struct Node *typedef_name =
            GetIdentifierTokenFromTypeAttr(typedef_type);
        PrintASTNode(typedef_name);
        PushKeyValueToList(ord_idents, CreateTokenStr(typedef_name),
                           GetTypeWithoutAttr(typedef_type));
      }
      continue;
    }
    struct Node *func_def = ParseFuncDef(decl_body);
    if (!func_def) {
      ErrorWithToken(NextToken(), "Unexpected token");
    }
    PushToList(list, func_def);
  }
  struct Node *t;
  if (!(t = NextToken())) return list;
  ErrorWithToken(t, "Unexpected token");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9f60
movb $0x0, %al
callq 0x4e30
movq %rax, -0x10(%rbp)
callq 0x9dd0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xa0c3
leaq 0x7b88(%rip), %rdi      # 0x11b62
callq 0xc320
cmpq $0x0, %rax
je 0xa087
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4f10
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x39a0
testb $0x1, %al
jne 0xa01f
leaq 0x7237(%rip), %rdi      # 0x11245
leaq 0x7166(%rip), %rsi      # 0x1117b
movl $0x21e, %edx            # imm = 0x21E
callq 0x4b20
movq -0x18(%rbp), %rdi
callq 0x39d0
testb $0x1, %al
jne 0xa02e
jmp 0xa082
movq -0x18(%rbp), %rdi
callq 0xe630
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xde50
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4190
movq 0xb318(%rip), %rax      # 0x15370
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
callq 0xbd90
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0xddf0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0x4f60
jmp 0x9fc0
movq -0x18(%rbp), %rdi
callq 0x9f10
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xa0b1
callq 0xc400
movq %rax, %rdi
leaq 0x71b4(%rip), %rsi      # 0x1125e
movb $0x0, %al
callq 0x4d50
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x4f10
jmp 0x9fc0
callq 0xc400
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0xa0dc
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
leaq 0x7177(%rip), %rsi      # 0x1125e
movb $0x0, %al
callq 0x4d50
nop
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/preprocessor.c
// Function: SkipDelimiterTokensInLogicalLine
static struct Node *SkipDelimiterTokensInLogicalLine(struct Node *t) {
  while (t && t->token_type == kTokenDelimiter &&
         !IsEqualTokenWithCStr(t, "\n"))
    t = t->next_token;
  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x9(%rbp)
je 0xac15
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl $0x1, 0x108(%rcx)
movb %al, -0x9(%rbp)
jne 0xac15
movq -0x8(%rbp), %rdi
leaq 0x567e(%rip), %rsi      # 0x10283
callq 0xbdf0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0xac1e
jmp 0xac2f
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xabdc
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/preprocessor.c
// Function: TryReadIdentListWrappedByParens
static struct Node *TryReadIdentListWrappedByParens(struct Node **tp) {
  // If ( ident_list ) is read, this function returns cloned tokens of
  // ident_list without commas and tp is advanced to next token.
  // If not, this function returns NULL and tp is unchanged.
  struct Node *t = *tp;
  if (!IsEqualTokenWithCStr(t, "(")) {
    return NULL;
  }
  struct Node *ident_list_head = NULL;
  struct Node **ident_list_last_holder = &ident_list_head;
  for (t = SkipDelimiterTokensInLogicalLine(t->next_token); t;
       t = SkipDelimiterTokensInLogicalLine(t->next_token)) {
    if (IsEqualTokenWithCStr(t, ")")) break;
    *ident_list_last_holder = DuplicateToken(t);
    ident_list_last_holder = &(*ident_list_last_holder)->next_token;
    t = SkipDelimiterTokensInLogicalLine(t->next_token);
    if (!IsEqualTokenWithCStr(t, ",")) break;
  }
  if (!IsEqualTokenWithCStr(t, ")")) {
    return NULL;
  }
  // To distinguish function-like macro with zero args and
  // token level replacement macro, add ) at the end of args
  // to ensure args is not NULL
  *ident_list_last_holder = DuplicateToken(t);
  *tp = SkipDelimiterTokensInLogicalLine(t->next_token);
  return ident_list_head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x58d2(%rip), %rsi      # 0x10534
callq 0xbdf0
cmpl $0x0, %eax
jne 0xac79
movq $0x0, -0x8(%rbp)
jmp 0xad7d
movq $0x0, -0x20(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x110(%rax), %rdi
callq 0xabd0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xad29
movq -0x18(%rbp), %rdi
leaq 0x6a92(%rip), %rsi      # 0x11745
callq 0xbdf0
cmpl $0x0, %eax
je 0xacbf
jmp 0xad29
movq -0x18(%rbp), %rdi
callq 0xbcb0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
addq $0x110, %rax            # imm = 0x110
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x110(%rax), %rdi
callq 0xabd0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x54e8(%rip), %rsi      # 0x101ea
callq 0xbdf0
cmpl $0x0, %eax
jne 0xad0e
jmp 0xad29
jmp 0xad10
movq -0x18(%rbp), %rax
movq 0x110(%rax), %rdi
callq 0xabd0
movq %rax, -0x18(%rbp)
jmp 0xac9d
movq -0x18(%rbp), %rdi
leaq 0x6a11(%rip), %rsi      # 0x11745
callq 0xbdf0
cmpl $0x0, %eax
jne 0xad48
movq $0x0, -0x8(%rbp)
jmp 0xad7d
movq -0x18(%rbp), %rdi
callq 0xbcb0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x110(%rax), %rdi
callq 0xabd0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/preprocessor.c
// Function: CreateJoinedString
static char *CreateJoinedString(const char *s1, const char *s2) {
  assert(s1 && s2);
  char *s = malloc(strlen(s1) + strlen(s2) + 1);
  assert(s);
  strcpy(s, s1);
  strcat(s, s2);
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xadae
cmpq $0x0, -0x10(%rbp)
jne 0xadc6
leaq 0x6664(%rip), %rdi      # 0x11419
leaq 0x64be(%rip), %rsi      # 0x1127a
movl $0x40, %edx
callq 0x4b20
movq -0x8(%rbp), %rdi
callq 0x2070
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2070
movq -0x20(%rbp), %rdi
addq %rax, %rdi
addq $0x1, %rdi
callq 0x2130
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xae0f
leaq 0x6556(%rip), %rdi      # 0x11354
leaq 0x6475(%rip), %rsi      # 0x1127a
movl $0x42, %edx
callq 0x4b20
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2050
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2180
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/preprocessor.c
// Function: CreateStrFromTokenRange
static const char *CreateStrFromTokenRange(struct Node *begin,
                                           struct Node *end) {
  assert(begin);
  int len = 0;
  for (struct Node *t = begin; t && t != end; t = t->next_token) {
    len += t->length;
  }
  return strndup(begin->begin, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xae6f
leaq 0x65c4(%rip), %rdi      # 0x11422
leaq 0x6415(%rip), %rsi      # 0x1127a
movl $0xc, %edx
callq 0x4b20
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x21(%rbp)
je 0xae98
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xaea1
jmp 0xaec2
movq -0x20(%rbp), %rax
movl 0x120(%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movq 0x110(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xae7e
movq -0x8(%rbp), %rax
movq 0x118(%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0x20d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/preprocessor.c
// Function: PreprocessRemoveBlock
static void PreprocessRemoveBlock(void) {
  for (struct Node *t = PeekToken(); t; t = t->next_token) {
    if (!IsEqualTokenWithCStr(t, "#")) {
      continue;
    }
    t = SkipDelimiterTokensInLogicalLine(t->next_token);
    if (!IsEqualTokenWithCStr(t, "endif") && !IsEqualTokenWithCStr(t, "else")) {
      continue;
    }
    RemoveTokensTo(t);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xc130
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xaf6b
movq -0x8(%rbp), %rdi
leaq 0x6375(%rip), %rsi      # 0x11278
callq 0xbdf0
cmpl $0x0, %eax
jne 0xaf0f
jmp 0xaf5a
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rdi
callq 0xabd0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x6433(%rip), %rsi      # 0x11361
callq 0xbdf0
cmpl $0x0, %eax
jne 0xaf4f
movq -0x8(%rbp), %rdi
leaq 0x6419(%rip), %rsi      # 0x1135c
callq 0xbdf0
cmpl $0x0, %eax
jne 0xaf4f
jmp 0xaf5a
movq -0x8(%rbp), %rdi
callq 0xc460
jmp 0xaf6b
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xaef1
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/struct.c
// Function: CalcStructSizeFromDict
static int CalcStructSizeFromDict(struct Node *dict) {
  if (!GetSizeOfList(dict)) return 0;
  struct Node *last_kv = GetNodeAt(dict, GetSizeOfList(dict) - 1);
  struct Node *last_member = last_kv->value;
  return last_member->struct_member_ent_ofs +
         GetSizeOfType(last_member->struct_member_ent_type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4fe0
cmpl $0x0, %eax
jne 0xaff3
movl $0x0, -0x4(%rbp)
jmp 0xb049
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4fe0
movq -0x30(%rbp), %rdi
movl %eax, %esi
subl $0x1, %esi
callq 0x5030
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0xa0(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x80(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0xe040
movl %eax, %ecx
movl -0x24(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/struct.c
// Function: CalcStructAlignFromDict
static int CalcStructAlignFromDict(struct Node *dict) {
  assert(dict && dict->type == kASTList);
  int align = 1;
  for (int i = 0; i < GetSizeOfList(dict); i++) {
    struct Node *kv = GetNodeAt(dict, i);
    struct Node *member_info = kv->value;
    assert(member_info->struct_member_ent_type);
    int member_align = GetAlignOfType(member_info->struct_member_ent_type);
    if (align < member_align) align = member_align;
  }
  return align;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xb0cc
movq -0x8(%rbp), %rax
cmpl $0x6, (%rax)
je 0xb0e4
leaq 0x6496(%rip), %rdi      # 0x11569
leaq 0x6373(%rip), %rsi      # 0x1144d
movl $0x17, %edx
callq 0x4b20
movl $0x1, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4fe0
movl %eax, %ecx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
jge 0xb17a
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x5030
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0xa0(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x70(%rax)
jne 0xb14c
leaq 0x644d(%rip), %rdi      # 0x11588
leaq 0x630b(%rip), %rsi      # 0x1144d
movl $0x1c, %edx
callq 0x4b20
movq -0x20(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0xe1f0
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0xb16a
movl -0x24(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xb16c
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xb0f2
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)