LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/ast.c
// Function: CreateMacroReplacement
struct Node *CreateMacroReplacement(struct Node *args_tokens,
                                    struct Node *to_tokens) {
  struct Node *n = AllocNode(kNodeMacroReplacement);
  n->arg_expr_list = args_tokens;
  n->value = to_tokens;
  return n;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x3
popq %rdi
callq 0x319d
movq %r14, 0xb8(%rax)
movq %rbx, 0xa0(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/compilium.c
// Function: Error
_Noreturn void Error(const char *fmt, ...) {
  fflush(stdout);
  fprintf(stderr, "Error: ");
  va_list ap;
  va_start(ap, fmt);
  vfprintf(stderr, fmt, ap);
  va_end(ap);
  fputc('\n', stderr);
  exit(EXIT_FAILURE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
testb %al, %al
je 0x3c42
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
movq 0xd36e(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
callq 0x2150
movq 0xd387(%rip), %r15      # 0x10ff8
movq (%r15), %rcx
leaq 0x7968(%rip), %rdi      # 0xb5e3
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x21b0
movq %rsp, %rdx
movq %r14, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x2180
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x20d0
pushq $0x1
popq %rdi
callq 0x21a0
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/compilium.c
// Function: PrintTokenLine
void PrintTokenLine(struct Node *t) {
  assert(t);
  const char *line_begin = t->begin;
  while (t->src_str < line_begin) {
    if (line_begin[-1] == '\n') break;
    line_begin--;
  }

  fprintf(stderr, "Line %d:\n", t->line);

  for (const char *p = line_begin; *p && *p != '\n'; p++) {
    fputc(*p <= ' ' ? ' ' : *p, stderr);
  }
  fputc('\n', stderr);
  const char *p;
  for (p = line_begin; p < t->begin; p++) {
    fputc(' ', stderr);
  }
  for (int i = 0; i < t->length; i++) {
    fputc('^', stderr);
    p++;
  }
  for (; *p && *p != '\n'; p++) {
    fputc(' ', stderr);
  }
  fputc('\n', stderr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x3dd3
movq %rdi, %rbx
movq 0x118(%rdi), %rcx
movq 0x128(%rdi), %rax
movq %rcx, %r14
cmpq %rcx, %rax
jae 0x3d10
leaq -0x1(%r14), %rcx
cmpb $0xa, -0x1(%r14)
jne 0x3cfd
movq 0xd2e1(%rip), %r15      # 0x10ff8
movq (%r15), %rdi
movl 0x130(%rbx), %edx
leaq 0x78ef(%rip), %rsi      # 0xb616
xorl %eax, %eax
callq 0x2110
pushq $0x20
popq %rbp
movq %r14, %r12
movzbl (%r12), %eax
cmpl $0xa, %eax
je 0x3d5a
testl %eax, %eax
je 0x3d5a
movzbl %al, %eax
cmpb $0x21, %al
cmovll %ebp, %eax
movzbl %al, %edi
movq (%r15), %rsi
callq 0x20d0
incq %r12
jmp 0x3d34
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x20d0
pushq $0x20
popq %rbp
cmpq 0x118(%rbx), %r14
jae 0x3d80
movq (%r15), %rsi
movl %ebp, %edi
callq 0x20d0
incq %r14
jmp 0x3d68
xorl %r12d, %r12d
pushq $0x5e
popq %rbp
cmpl 0x120(%rbx), %r12d
jge 0x3d9e
movq (%r15), %rsi
movl %ebp, %edi
callq 0x20d0
incq %r12
jmp 0x3d86
addq %r12, %r14
pushq $0x20
popq %rbx
movzbl (%r14), %eax
testl %eax, %eax
je 0x3dc0
cmpl $0xa, %eax
je 0x3dc0
movq (%r15), %rsi
movl %ebx, %edi
callq 0x20d0
incq %r14
jmp 0x3da4
movq (%r15), %rsi
pushq $0xa
popq %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20d0
leaq 0x87ba(%rip), %rdi      # 0xc594
leaq 0x7829(%rip), %rsi      # 0xb60a
pushq $0x3f
popq %rdx
callq 0x3cc4
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/compilium.c
// Function: ErrorWithToken
_Noreturn void ErrorWithToken(struct Node *t, const char *fmt, ...) {
  PrintTokenLine(t);

  fprintf(stderr, "Error: ");
  va_list ap;
  va_start(ap, fmt);
  vfprintf(stderr, fmt, ap);
  va_end(ap);
  fputc('\n', stderr);
  exit(EXIT_FAILURE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %rbx
leaq 0x20(%rsp), %r14
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x3e48
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
callq 0x3cdb
movq 0xd1a4(%rip), %r15      # 0x10ff8
movq (%r15), %rcx
leaq 0x7785(%rip), %rdi      # 0xb5e3
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x21b0
movq %rsp, %rdx
movq %r14, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x2180
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x20d0
pushq $0x1
popq %rdi
callq 0x21a0
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/compilium.c
// Function: ExpandListSizeIfNeeded
void ExpandListSizeIfNeeded(struct Node *list) {
  if (list->size < list->capacity) return;
  list->capacity = (list->capacity + 1) * 2;
  list->nodes = realloc(list->nodes, sizeof(struct Node *) * list->capacity);
  assert(list->nodes);
  assert(list->size < list->capacity);
}

// Assembly:
pushq %rbx
movl 0x84(%rdi), %eax
cmpl %eax, 0x88(%rdi)
jl 0x3efb
movq %rdi, %rbx
leal 0x2(,%rax,2), %eax
movl %eax, 0x84(%rdi)
movq 0x90(%rdi), %rdi
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x2160
movq %rax, 0x90(%rbx)
testq %rax, %rax
je 0x3efd
movl 0x88(%rbx), %eax
cmpl 0x84(%rbx), %eax
jge 0x3f0f
popq %rbx
retq
leaq 0x771c(%rip), %rdi      # 0xb620
leaq 0x76ff(%rip), %rsi      # 0xb60a
pushq $0x6e
jmp 0x3f1f
leaq 0x7716(%rip), %rdi      # 0xb62c
leaq 0x76ed(%rip), %rsi      # 0xb60a
pushq $0x6f
popq %rdx
callq 0x3cc4
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/compilium.c
// Function: GetNodeByTokenKey
struct Node *GetNodeByTokenKey(struct Node *list, struct Node *key) {
  assert(list && list->type == kASTList);
  for (int i = 0; i < list->size; i++) {
    struct Node *n = list->nodes[i];
    if (n->type != kASTKeyValue) continue;
    if (IsEqualTokenWithCStr(key, n->key)) return n->value;
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x409e
movq %rdi, %r14
cmpl $0x6, (%rdi)
jne 0x409e
movq %rsi, %rbx
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq 0x88(%r14), %rax
cmpq %rax, %r12
jge 0x4091
movq 0x90(%r14), %rax
movq (%rax,%r12,8), %r13
cmpl $0x11, (%r13)
jne 0x4085
movq 0x98(%r13), %rsi
movq %rbx, %rdi
callq 0x87de
testl %eax, %eax
jne 0x408a
incq %r12
jmp 0x4054
movq 0xa0(%r13), %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x75b0(%rip), %rdi      # 0xb655
leaq 0x755e(%rip), %rsi      # 0xb60a
movl $0x8a, %edx
callq 0x3cc4
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/compilium.c
// Function: GetNodeByKey
struct Node *GetNodeByKey(struct Node *list, const char *key) {
  assert(list && list->type == kASTList);
  for (int i = 0; i < list->size; i++) {
    struct Node *n = list->nodes[i];
    if (n->type != kASTKeyValue) continue;
    if (strcmp(n->key, key) == 0) return n->value;
  }
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x412c
movq %rdi, %r14
cmpl $0x6, (%rdi)
jne 0x412c
movq %rsi, %rbx
movl 0x88(%r14), %r12d
xorl %r15d, %r15d
testl %r12d, %r12d
cmovlel %r15d, %r12d
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x411a
movq 0x90(%r14), %rax
movq (%rax,%r13,8), %rbp
cmpl $0x11, (%rbp)
jne 0x410e
movq 0x98(%rbp), %rdi
movq %rbx, %rsi
callq 0x2100
testl %eax, %eax
je 0x4113
incq %r13
jmp 0x40e5
movq 0xa0(%rbp), %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7522(%rip), %rdi      # 0xb655
leaq 0x74d0(%rip), %rsi      # 0xb60a
movl $0x94, %edx
callq 0x3cc4
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/compilium.c
// Function: ReadFile
const char *ReadFile(FILE *fp) {
  int buf_size = INITIAL_INPUT_SIZE;
  char *input = malloc(buf_size);
  int input_size = 0;
  int c;
  while ((c = fgetc(fp)) != EOF) {
    input[input_size++] = c;
    if (input_size == buf_size) {
      buf_size <<= 1;
      assert((input = realloc(input, buf_size)));
    }
  }
  assert(input_size < buf_size);
  input[input_size] = 0;
  return input;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x2000, %edi           # imm = 0x2000
callq 0x2140
movq %rax, %rbx
movl $0x2000, %r12d          # imm = 0x2000
xorl %r15d, %r15d
movl %r12d, %r12d
movq %r14, %rdi
callq 0x20c0
cmpl $-0x1, %eax
je 0x445d
movb %al, (%rbx,%r15)
incq %r15
cmpq %r15, %r12
jne 0x4416
addl %r12d, %r12d
movslq %r12d, %rsi
movq %rbx, %rdi
callq 0x2160
movq %rax, %rbx
testq %rax, %rax
jne 0x4413
leaq 0x7416(%rip), %rdi      # 0xb862
leaq 0x71b7(%rip), %rsi      # 0xb60a
movl $0x106, %edx            # imm = 0x106
callq 0x3cc4
cmpl %r15d, %r12d
jle 0x4478
movl %r15d, %eax
movb $0x0, (%rbx,%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x7406(%rip), %rdi      # 0xb885
leaq 0x7184(%rip), %rsi      # 0xb60a
movl $0x109, %edx            # imm = 0x109
callq 0x3cc4
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/generator.c
// Function: GetParamRegName
const char *GetParamRegName(struct Node *type, int idx) {
  assert(0 <= idx && idx < NUM_OF_PARAM_REGISTERS);
  int size = GetSizeOfType(type);
  if (size == 8) return param_reg_names_64[idx];
  if (size == 4) return param_reg_names_32[idx];
  if (size == 1) return param_reg_names_8[idx];
  ErrorWithToken(GetIdentifierTokenFromTypeAttr(type),
                 "Assigning %d bytes is not implemented.", size);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x6, %esi
jae 0x4774
movl %esi, %ebx
movq %rdi, %r14
callq 0x9672
cmpl $0x1, %eax
je 0x4762
movl %eax, %ebp
cmpl $0x8, %eax
je 0x4759
cmpl $0x4, %ebp
jne 0x478c
leaq 0xcaf9(%rip), %rax      # 0x11250
jmp 0x4769
leaq 0xcac0(%rip), %rax      # 0x11220
jmp 0x4769
leaq 0xcb17(%rip), %rax      # 0x11280
movl %ebx, %ecx
movq (%rax,%rcx,8), %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x723d(%rip), %rdi      # 0xb9b8
leaq 0x725f(%rip), %rsi      # 0xb9e1
movl $0xb4, %edx
callq 0x3cc4
movq %r14, %rdi
callq 0x956f
leaq 0x7252(%rip), %rsi      # 0xb9ed
movq %rax, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x3de9
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/generator.c
// Function: Generate
void Generate(struct Node *ast, struct SymbolEntry *toplevel_names) {
  label_to_break = 0;
  label_to_continue = 0;
  str_list = AllocList();
  printf(".intel_syntax noprefix\n");
  printf(".text\n");
  GenerateForNode(ast);
  GenerateDataSection(toplevel_names);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
andl $0x0, 0xcbac(%rip)      # 0x11368
movq %rdi, %r14
andl $0x0, 0xcba6(%rip)      # 0x1136c
xorl %eax, %eax
callq 0x3ea7
movq %rax, 0xcb9c(%rip)      # 0x11370
leaq 0x792a(%rip), %rdi      # 0xc105
callq 0x2060
leaq 0x7935(%rip), %rdi      # 0xc11c
callq 0x2060
movq %r14, %rdi
callq 0x4941
leaq 0x79ab(%rip), %rdi      # 0xc1a6
callq 0x2060
leaq 0x78cd(%rip), %r15      # 0xc0d4
movq 0xc7c2(%rip), %r14      # 0x10fd0
pushq $0xa
popq %rbp
xorl %r12d, %r12d
movq 0xcb55(%rip), %rdi      # 0x11370
callq 0x3fb7
cmpl %eax, %r12d
jge 0x486d
movq 0xcb44(%rip), %rdi      # 0x11370
movl %r12d, %esi
callq 0x3fdf
movq %rax, %r13
movl 0xac(%rax), %esi
leaq 0x788a(%rip), %rdi      # 0xc0ce
xorl %eax, %eax
callq 0x2090
movq %r15, %rdi
xorl %eax, %eax
callq 0x2090
movq 0x10(%r13), %rdi
movq (%r14), %rsi
callq 0x8990
movl %ebp, %edi
callq 0x2030
incl %r12d
jmp 0x4814
leaq 0x788e(%rip), %r13      # 0xc102
leaq 0x7883(%rip), %rbp      # 0xc0fe
testq %rbx, %rbx
je 0x4932
cmpl $0x1, (%rbx)
je 0x488f
movq 0x8(%rbx), %rbx
jmp 0x487b
movq 0x18(%rbx), %rdi
callq 0x9672
movl %eax, %r14d
movq 0xc756(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
movq 0x10(%rbx), %rdx
xorl %r15d, %r15d
leaq 0x7829(%rip), %rsi      # 0xc0dc
movl %r14d, %ecx
xorl %eax, %eax
callq 0x2110
leaq 0xca94(%rip), %r12      # 0x11358
movq (%r12), %rsi
movq 0x10(%rbx), %rdx
leaq 0x722c(%rip), %rdi      # 0xbaff
xorl %eax, %eax
callq 0x2090
movq (%r12), %rsi
movq 0x10(%rbx), %rdx
leaq 0x7224(%rip), %rdi      # 0xbb0d
xorl %eax, %eax
callq 0x2090
leaq 0x7800(%rip), %rdi      # 0xc0f7
xorl %eax, %eax
callq 0x2090
leal -0x1(%r14), %r12d
testl %r14d, %r14d
cmovlel %r15d, %r14d
cmpl %r15d, %r14d
je 0x4889
cmpl %r15d, %r12d
movq %r13, %rsi
leaq 0x6994(%rip), %rax      # 0xb2b3
cmoveq %rax, %rsi
movq %rbp, %rdi
xorl %eax, %eax
callq 0x2090
incl %r15d
jmp 0x4909
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/generator.c
// Function: GenerateForNodeRValue
static void GenerateForNodeRValue(struct Node *node) {
  GenerateForNode(node);
  if (!node->expr_type) return;
  if (node->expr_type->type != kTypeLValue) return;
  if (node->expr_type->type == kTypeLValue &&
      node->expr_type->right->type == kTypeArray)
    return;
  int size = GetSizeOfType(GetRValueType(node->expr_type));
  if (size == 8) {
    printf("mov %s, [%s]\n", reg_names_64[node->reg], reg_names_64[node->reg]);
    return;
  } else if (size == 4) {
    printf("movsxd %s, dword ptr[%s]\n", reg_names_64[node->reg],
           reg_names_64[node->reg]);
    return;
  } else if (size == 1) {
    printf("movsx %s, byte ptr[%s]\n", reg_names_64[node->reg],
           reg_names_64[node->reg]);
    return;
  }
  ErrorWithToken(node->op, "Dereferencing %d bytes is not implemented.", size);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x4941
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x6197
cmpl $0x15, (%rdi)
jne 0x6197
movq 0x20(%rdi), %rax
cmpl $0x1a, (%rax)
jne 0x6199
popq %rbx
retq
callq 0x9581
movq %rax, %rdi
callq 0x9672
cmpl $0x1, %eax
je 0x61c7
cmpl $0x8, %eax
je 0x61be
cmpl $0x4, %eax
jne 0x61e8
leaq 0x5cae(%rip), %rdi      # 0xbe6a
jmp 0x61ce
leaq 0x5c97(%rip), %rdi      # 0xbe5c
jmp 0x61ce
leaq 0x5cb6(%rip), %rdi      # 0xbe84
movslq 0x4(%rbx), %rax
leaq 0xaf27(%rip), %rcx      # 0x11100
movq (%rcx,%rax,8), %rdx
movq %rdx, %rsi
xorl %eax, %eax
popq %rbx
jmp 0x2090
movq 0x10(%rbx), %rdi
leaq 0x5ca9(%rip), %rsi      # 0xbe9c
movl %eax, %edx
xorl %eax, %eax
callq 0x3de9
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/generator.c
// Function: EmitConvertToBool
static void EmitConvertToBool(int dst, int src) {
  // This code also sets zero flag as boolean value
  printf("cmp %s, 0\n", reg_names_64[src]);
  printf("setnz %s\n", reg_names_8[src]);
  printf("movzx %s, %s\n", reg_names_64[dst], reg_names_8[src]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movslq %esi, %r14
leaq 0xaef0(%rip), %r15      # 0x11100
movq (%r15,%r14,8), %rsi
leaq 0x5cac(%rip), %rdi      # 0xbec7
xorl %eax, %eax
callq 0x2090
leaq 0xaf97(%rip), %r12      # 0x111c0
movq (%r12,%r14,8), %rsi
leaq 0x5c9e(%rip), %rdi      # 0xbed2
xorl %eax, %eax
callq 0x2090
movslq %ebx, %rax
movq (%r15,%rax,8), %rsi
movq (%r12,%r14,8), %rdx
leaq 0x5c8f(%rip), %rdi      # 0xbedc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2090
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
pushq $0x3
popq %rdi
callq 0x8a20
testq %rax, %rax
jne 0x63f4
pushq $0x4
popq %rdi
callq 0x8a20
testq %rax, %rax
jne 0x63f4
pushq $0x17
popq %rdi
callq 0x8a20
testq %rax, %rax
jne 0x63f4
pushq $0x18
popq %rdi
callq 0x8a20
testq %rax, %rax
je 0x6411
movq %rax, %rbx
pushq $0x4
popq %rdi
callq 0x319d
movq %rax, %r14
movq %rbx, 0x10(%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x51ac(%rip), %rdi      # 0xb5c4
callq 0x8ad7
testq %rax, %rax
je 0x6450
movq %rax, %rbx
pushq $0x4
popq %rdi
callq 0x319d
movq %rax, %r14
movq %rbx, 0x10(%rax)
callq 0x6466
movq %rax, 0x20(%r14)
testq %rax, %rax
je 0x6455
leaq 0x642c(%rip), %rdi      # 0xc875
callq 0x8b1b
jmp 0x6406
xorl %r14d, %r14d
jmp 0x6406
leaq 0x5d6c(%rip), %rsi      # 0xc1c8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3de9
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
callq 0x6b57
testq %rax, %rax
je 0x64a7
movq %rax, %rbx
leaq 0x4d9b(%rip), %r14      # 0xb21a
movq %r14, %rdi
callq 0x8ad7
testq %rax, %rax
je 0x64a9
movq %rax, %r15
callq 0x6b57
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x31b1
movq %rax, %rbx
jmp 0x647f
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/parser.c
// Function: ParsePostfixExpr
struct Node *ParsePostfixExpr() {
  struct Node *n = ParsePrimaryExpr();
  while (n) {
    struct Node *t;
    if (ConsumePunctuator("(")) {
      struct Node *args = AllocList();
      if (!ConsumePunctuator(")")) {
        do {
          struct Node *arg_expr = ParseAssignExpr();
          if (!arg_expr)
            ErrorWithToken(NextToken(), "Expected expression here");
          PushToList(args, arg_expr);
        } while (ConsumePunctuator(","));
        ExpectPunctuator(")");
      }
      struct Node *nn = AllocNode(kASTExprFuncCall);
      nn->func_expr = n;
      nn->arg_expr_list = args;
      n = nn;
      continue;
    }
    if ((t = ConsumePunctuator("["))) {
      n = CreateASTBinOp(t, n, ParseExpr());
      ExpectPunctuator("]");
      continue;
    }
    if ((t = ConsumePunctuator(".")) || (t = ConsumePunctuator("->"))) {
      struct Node *right = ConsumeToken(kTokenIdent);
      assert(right);
      n = CreateASTBinOp(t, n, right);
      continue;
    }
    if ((t = ConsumePunctuator("++"))) {
      n = CreateASTUnaryPostfixOp(n, t);
      continue;
    }
    if ((t = ConsumePunctuator("--"))) {
      n = CreateASTUnaryPostfixOp(n, t);
      continue;
    }
    break;
  }
  return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x63bc
movq %rax, %r13
leaq 0x50f8(%rip), %rbx      # 0xb5c4
leaq 0x63a2(%rip), %r12      # 0xc875
leaq 0x4d40(%rip), %rbp      # 0xb21a
pushq $0x5
popq %r15
testq %r13, %r13
je 0x660c
movq %rbx, %rdi
callq 0x8ad7
testq %rax, %rax
je 0x6554
xorl %eax, %eax
callq 0x3ea7
movq %rax, %r14
movq %r12, %rdi
callq 0x8ad7
testq %rax, %rax
jne 0x6539
callq 0x6b57
testq %rax, %rax
je 0x661e
movq %r14, %rdi
movq %rax, %rsi
callq 0x3f25
movq %rbp, %rdi
callq 0x8ad7
testq %rax, %rax
jne 0x650b
movq %r12, %rdi
callq 0x8b1b
movl %r15d, %edi
callq 0x319d
movq %r13, 0xb0(%rax)
movq %r14, 0xb8(%rax)
movq %rax, %r13
jmp 0x64de
leaq 0x503e(%rip), %rdi      # 0xb599
callq 0x8ad7
testq %rax, %rax
je 0x658f
movq %rax, %r14
callq 0x6466
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x31b1
movq %rax, %r13
leaq 0x5c34(%rip), %rdi      # 0xc1b9
callq 0x8b1b
jmp 0x64de
leaq 0x510d(%rip), %rdi      # 0xb6a3
callq 0x8ad7
testq %rax, %rax
jne 0x65b1
leaq 0x4ae6(%rip), %rdi      # 0xb08d
callq 0x8ad7
testq %rax, %rax
je 0x65d7
movq %rax, %r14
pushq $0x4
popq %rdi
callq 0x8a20
testq %rax, %rax
je 0x6634
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x31b1
movq %rax, %r13
jmp 0x64de
leaq 0x4bc9(%rip), %rdi      # 0xb1a7
callq 0x8ad7
testq %rax, %rax
jne 0x65f9
leaq 0x4bb5(%rip), %rdi      # 0xb1a4
callq 0x8ad7
testq %rax, %rax
je 0x660c
movq %r13, %rdi
movq %rax, %rsi
callq 0x3227
movq %rax, %r13
jmp 0x64de
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x8b6e
leaq 0x5bbd(%rip), %rsi      # 0xc1e7
movq %rax, %rdi
xorl %eax, %eax
callq 0x3de9
leaq 0x5bc5(%rip), %rdi      # 0xc200
leaq 0x5bc4(%rip), %rsi      # 0xc206
pushq $0x3e
popq %rdx
callq 0x3cc4
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
leaq 0x4b56(%rip), %rdi      # 0xb1a8
callq 0x8ad7
testq %rax, %rax
jne 0x66e4
leaq 0x4b3e(%rip), %rdi      # 0xb1a5
callq 0x8ad7
testq %rax, %rax
jne 0x66e4
leaq 0x55f5(%rip), %rdi      # 0xbc6d
callq 0x8ad7
testq %rax, %rax
jne 0x66e4
leaq 0x55ee(%rip), %rdi      # 0xbc77
callq 0x8ad7
testq %rax, %rax
jne 0x66e4
leaq 0x5662(%rip), %rdi      # 0xbcfc
callq 0x8ad7
testq %rax, %rax
jne 0x66e4
leaq 0x4b24(%rip), %rdi      # 0xb1cf
callq 0x8ad7
testq %rax, %rax
jne 0x66e4
leaq 0x4ae8(%rip), %rdi      # 0xb1a4
callq 0x8ad7
testq %rax, %rax
jne 0x66e4
leaq 0x4ada(%rip), %rdi      # 0xb1a7
callq 0x8ad7
testq %rax, %rax
jne 0x66e4
pushq $0x10
popq %rdi
callq 0x8a20
testq %rax, %rax
je 0x66f8
movq %rax, %rbx
callq 0x664a
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x31ef
popq %rbx
jmp 0x64b2
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
callq 0x664a
testq %rax, %rax
je 0x6770
movq %rax, %rbx
leaq 0x4aaf(%rip), %r14      # 0xb1cf
leaq 0x5c1f(%rip), %r15      # 0xc346
leaq 0x561e(%rip), %r12      # 0xbd4c
movq %r14, %rdi
callq 0x8ad7
testq %rax, %rax
jne 0x6755
movq %r15, %rdi
callq 0x8ad7
testq %rax, %rax
jne 0x6755
movq %r12, %rdi
callq 0x8ad7
testq %rax, %rax
je 0x6772
movq %rax, %r13
callq 0x664a
movq %r13, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x31b1
movq %rax, %rbx
jmp 0x672e
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x6703
testq %rax, %rax
je 0x67d7
movq %rax, %rbx
leaq 0x4a0d(%rip), %r14      # 0xb1a8
leaq 0x4a03(%rip), %r15      # 0xb1a5
movq %r14, %rdi
callq 0x8ad7
testq %rax, %rax
jne 0x67bc
movq %r15, %rdi
callq 0x8ad7
testq %rax, %rax
je 0x67d9
movq %rax, %r12
callq 0x6703
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x31b1
movq %rax, %rbx
jmp 0x67a2
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x677f
testq %rax, %rax
je 0x6840
movq %rax, %rbx
leaq 0x5557(%rip), %r14      # 0xbd5b
leaq 0x556c(%rip), %r15      # 0xbd77
movq %r14, %rdi
callq 0x8ad7
testq %rax, %rax
jne 0x6825
movq %r15, %rdi
callq 0x8ad7
testq %rax, %rax
je 0x6842
movq %rax, %r12
callq 0x677f
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x31b1
movq %rax, %rbx
jmp 0x680b
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x67e8
testq %rax, %rax
je 0x68d4
movq %rax, %rbx
leaq 0x54ec(%rip), %r14      # 0xbd5c
leaq 0x4817(%rip), %r15      # 0xb08e
leaq 0x549c(%rip), %r12      # 0xbd1a
leaq 0x5499(%rip), %r13      # 0xbd1e
movq %r14, %rdi
callq 0x8ad7
testq %rax, %rax
jne 0x68b9
movq %r15, %rdi
callq 0x8ad7
testq %rax, %rax
jne 0x68b9
movq %r12, %rdi
callq 0x8ad7
testq %rax, %rax
jne 0x68b9
movq %r13, %rdi
callq 0x8ad7
testq %rax, %rax
je 0x68d6
movq %rax, %rbp
callq 0x67e8
movq %rbp, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x31b1
movq %rax, %rbx
jmp 0x6885
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x6851
testq %rax, %rax
je 0x6940
movq %rax, %rbx
leaq 0x5485(%rip), %r14      # 0xbd89
leaq 0x5481(%rip), %r15      # 0xbd8c
movq %r14, %rdi
callq 0x8ad7
testq %rax, %rax
jne 0x6925
movq %r15, %rdi
callq 0x8ad7
testq %rax, %rax
je 0x6942
movq %rax, %r12
callq 0x6851
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x31b1
movq %rax, %rbx
jmp 0x690b
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
callq 0x68e8
testq %rax, %rax
je 0x6992
movq %rax, %rbx
leaq 0x5392(%rip), %r14      # 0xbcfc
movq %r14, %rdi
callq 0x8ad7
testq %rax, %rax
je 0x6994
movq %rax, %r15
callq 0x68e8
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x31b1
movq %rax, %rbx
jmp 0x696a
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
callq 0x6951
testq %rax, %rax
je 0x69de
movq %rax, %rbx
leaq 0x53e5(%rip), %r14      # 0xbd9b
movq %r14, %rdi
callq 0x8ad7
testq %rax, %rax
je 0x69e0
movq %rax, %r15
callq 0x6951
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x31b1
movq %rax, %rbx
jmp 0x69b6
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
callq 0x699d
testq %rax, %rax
je 0x6a2a
movq %rax, %rbx
leaq 0x52fd(%rip), %r14      # 0xbcff
movq %r14, %rdi
callq 0x8ad7
testq %rax, %rax
je 0x6a2c
movq %rax, %r15
callq 0x699d
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x31b1
movq %rax, %rbx
jmp 0x6a02
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
callq 0x69e9
testq %rax, %rax
je 0x6a76
movq %rax, %rbx
leaq 0x52ad(%rip), %r14      # 0xbcfb
movq %r14, %rdi
callq 0x8ad7
testq %rax, %rax
je 0x6a78
movq %rax, %r15
callq 0x69e9
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x31b1
movq %rax, %rbx
jmp 0x6a4e
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
callq 0x6a35
testq %rax, %rax
je 0x6ac2
movq %rax, %rbx
leaq 0x5264(%rip), %r14      # 0xbcfe
movq %r14, %rdi
callq 0x8ad7
testq %rax, %rax
je 0x6ac4
movq %rax, %r15
callq 0x6a35
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x31b1
movq %rax, %rbx
jmp 0x6a9a
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
callq 0x6a81
testq %rax, %rax
je 0x6b3a
movq %rax, %r14
leaq 0x5729(%rip), %rdi      # 0xc20f
callq 0x8ad7
testq %rax, %rax
je 0x6b3d
movq %rax, %rbx
pushq $0x4
popq %rdi
callq 0x319d
movq %rax, %r15
movq %rbx, 0x10(%rax)
movq %r14, 0x30(%rax)
callq 0x6acd
movq %rax, 0x18(%r15)
testq %rax, %rax
je 0x6b46
leaq 0x5723(%rip), %rdi      # 0xc23e
callq 0x8b1b
callq 0x6acd
movq %rax, 0x20(%r15)
movq %r15, %r14
testq %rax, %rax
jne 0x6b3d
leaq 0x5708(%rip), %rsi      # 0xc240
jmp 0x6b4d
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x56c4(%rip), %rsi      # 0xc211
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3de9
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
callq 0x6acd
testq %rax, %rax
je 0x6c16
movq %rax, %rbx
leaq 0x521a(%rip), %rdi      # 0xbd8d
callq 0x8ad7
testq %rax, %rax
jne 0x6bf4
leaq 0x5186(%rip), %rdi      # 0xbd0a
callq 0x8ad7
testq %rax, %rax
jne 0x6bf4
leaq 0x5178(%rip), %rdi      # 0xbd0d
callq 0x8ad7
testq %rax, %rax
jne 0x6bf4
leaq 0x516a(%rip), %rdi      # 0xbd10
callq 0x8ad7
testq %rax, %rax
jne 0x6bf4
leaq 0x515c(%rip), %rdi      # 0xbd13
callq 0x8ad7
testq %rax, %rax
jne 0x6bf4
leaq 0x514e(%rip), %rdi      # 0xbd16
callq 0x8ad7
testq %rax, %rax
jne 0x6bf4
leaq 0x5140(%rip), %rdi      # 0xbd19
callq 0x8ad7
testq %rax, %rax
jne 0x6bf4
leaq 0x5133(%rip), %rdi      # 0xbd1d
callq 0x8ad7
testq %rax, %rax
je 0x6c18
movq %rax, %r14
callq 0x6b57
testq %rax, %rax
je 0x6c23
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x31b1
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x559e(%rip), %rsi      # 0xc1c8
movq %r14, %rdi
xorl %eax, %eax
callq 0x3de9
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
callq 0x6466
movq %rax, %rbx
leaq 0x6061(%rip), %rdi      # 0xcca5
callq 0x8ad7
testq %rax, %rax
je 0x6c5a
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x3281
testq %rbx, %rbx
je 0x6c6b
leaq 0x603f(%rip), %rdi      # 0xcca5
callq 0x8b1b
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq $0xc
popq %rdi
callq 0x8a20
testq %rax, %rax
je 0x6ce9
movq %rax, %rbx
leaq 0x4936(%rip), %rdi      # 0xb5c4
callq 0x8b1b
callq 0x6466
testq %rax, %rax
je 0x6cf8
movq %rax, %r14
leaq 0x5bce(%rip), %rdi      # 0xc875
callq 0x8b1b
callq 0x6eeb
testq %rax, %rax
je 0x6d10
movq %rax, %r12
pushq $0x9
popq %rbp
movl %ebp, %edi
callq 0x319d
movq %rax, %r15
movq %rbx, 0x10(%rax)
movq %r14, 0x30(%rax)
movq %r12, 0x48(%rax)
movl %ebp, %edi
callq 0x8a20
testq %rax, %rax
je 0x6cec
callq 0x6eeb
movq %rax, 0x50(%r15)
jmp 0x6cec
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x556a(%rip), %rdi      # 0xc269
leaq 0x5500(%rip), %rsi      # 0xc206
movl $0x103, %edx            # imm = 0x103
callq 0x3cc4
leaq 0x5557(%rip), %rdi      # 0xc26e
leaq 0x54e8(%rip), %rsi      # 0xc206
movl $0x106, %edx            # imm = 0x106
callq 0x3cc4
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
pushq $0x5
popq %rdi
callq 0x8a20
testq %rax, %rax
jne 0x6d46
pushq $0x8
popq %rdi
callq 0x8a20
testq %rax, %rax
je 0x6d69
movq %rax, %rbx
leaq 0x5f55(%rip), %rdi      # 0xcca5
callq 0x8b1b
pushq $0x8
popq %rdi
callq 0x319d
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0xf
popq %rdi
callq 0x8a20
testq %rax, %rax
je 0x6d9f
movq %rax, %rbx
callq 0x6466
movq %rax, %r14
leaq 0x5f1d(%rip), %rdi      # 0xcca5
callq 0x8b1b
pushq $0x8
popq %rdi
callq 0x319d
movq %rbx, 0x10(%rax)
movq %r14, 0x20(%rax)
jmp 0x6d61
xorl %eax, %eax
jmp 0x6d61
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/parser.c
// Function: ParseIterationStmt
struct Node *ParseIterationStmt() {
  struct Node *t;
  if ((t = ConsumeToken(kTokenKwFor))) {
    ExpectPunctuator("(");
    struct Node *init = ParseDeclBody();
    if (!init) init = ParseExpr();
    ExpectPunctuator(";");
    struct Node *cond = ParseExpr();
    ExpectPunctuator(";");
    struct Node *updt = ParseExpr();
    ExpectPunctuator(")");
    struct Node *body = ParseStmt();
    assert(body);

    struct Node *stmt = AllocNode(kASTForStmt);
    stmt->op = t;
    stmt->init = init;
    stmt->cond = cond;
    stmt->updt = updt;
    stmt->body = body;
    return stmt;
  }
  if ((t = ConsumeToken(kTokenKwWhile))) {
    ExpectPunctuator("(");
    struct Node *cond = ParseExpr();
    assert(cond);
    ExpectPunctuator(")");
    struct Node *body = ParseStmt();
    assert(body);

    struct Node *stmt = AllocNode(kASTWhileStmt);
    stmt->op = t;
    stmt->cond = cond;
    stmt->body = body;
    return stmt;
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq $0xb
popq %rdi
callq 0x8a20
testq %rax, %rax
je 0x6e3f
movq %rax, %rbx
leaq 0x47fd(%rip), %rdi      # 0xb5c4
callq 0x8b1b
callq 0x733c
movq %rax, %r14
testq %rax, %rax
jne 0x6de1
callq 0x6466
movq %rax, %r14
leaq 0x5ebd(%rip), %r15      # 0xcca5
movq %r15, %rdi
callq 0x8b1b
callq 0x6466
movq %rax, %r12
movq %r15, %rdi
callq 0x8b1b
callq 0x6466
movq %rax, %r13
leaq 0x5a66(%rip), %rdi      # 0xc875
callq 0x8b1b
callq 0x6eeb
testq %rax, %rax
je 0x6ea3
movq %rax, %r15
pushq $0xe
popq %rdi
callq 0x319d
movq %rbx, 0x10(%rax)
movq %r14, 0x28(%rax)
movq %r12, 0x30(%rax)
movq %r13, 0x38(%rax)
jmp 0x6e91
pushq $0x16
popq %rdi
callq 0x8a20
testq %rax, %rax
je 0x6e9f
movq %rax, %rbx
leaq 0x476e(%rip), %rdi      # 0xb5c4
callq 0x8b1b
callq 0x6466
testq %rax, %rax
je 0x6ebb
movq %rax, %r14
leaq 0x5a06(%rip), %rdi      # 0xc875
callq 0x8b1b
callq 0x6eeb
testq %rax, %rax
je 0x6ed3
movq %rax, %r15
pushq $0xf
popq %rdi
callq 0x319d
movq %rbx, 0x10(%rax)
movq %r14, 0x30(%rax)
movq %r15, 0x40(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0x6e95
leaq 0x53ce(%rip), %rdi      # 0xc278
leaq 0x5355(%rip), %rsi      # 0xc206
movl $0x134, %edx            # imm = 0x134
callq 0x3cc4
leaq 0x53bb(%rip), %rdi      # 0xc27d
leaq 0x533d(%rip), %rsi      # 0xc206
movl $0x141, %edx            # imm = 0x141
callq 0x3cc4
leaq 0x539e(%rip), %rdi      # 0xc278
leaq 0x5325(%rip), %rsi      # 0xc206
movl $0x144, %edx            # imm = 0x144
callq 0x3cc4
// File: /workspace/github_c_makefile_star2_O2/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 %rax
callq 0x6c34
testq %rax, %rax
jne 0x6f14
callq 0x6d28
testq %rax, %rax
jne 0x6f14
callq 0x6c6f
testq %rax, %rax
jne 0x6f14
callq 0x7393
testq %rax, %rax
je 0x6f16
popq %rcx
retq
popq %rax
jmp 0x6da3
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq $0xc
popq %rdi
callq 0x319d
movq %rax, %rbx
xorl %r14d, %r14d
leaq 0x3f5e(%rip), %r15      # 0xb1cf
movq %r15, %rdi
callq 0x8ad7
testq %rax, %rax
je 0x728b
movq %r14, %rdi
callq 0x33e6
movq %rax, %r14
jmp 0x7271
movq %r14, 0x18(%rbx)
callq 0x70cb
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
callq 0x7257
movq %rax, %rbx
testq %rax, %rax
je 0x72e1
leaq 0x4ad4(%rip), %rdi      # 0xbd8d
callq 0x8ad7
testq %rax, %rax
je 0x72e1
movq %rax, %r14
callq 0x6b57
testq %rax, %rax
je 0x72ec
movq %r14, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x31b1
movq %rax, 0x58(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4fd7(%rip), %rdi      # 0xc2ca
leaq 0x4f0c(%rip), %rsi      # 0xc206
movl $0x1e1, %edx            # imm = 0x1E1
callq 0x3cc4
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
callq 0x6f1c
testq %rax, %rax
je 0x732f
movq %rax, %r14
pushq $0xd
popq %rdi
callq 0x319d
movq %rax, %rbx
movq %r14, 0x10(%rax)
callq 0x7257
movq %rax, 0x20(%rbx)
jmp 0x7331
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
callq 0x6f1c
testq %rax, %rax
je 0x7367
movq %rax, %r14
pushq $0xd
popq %rdi
callq 0x319d
movq %rax, %rbx
movq %r14, 0x10(%rax)
callq 0x72a1
movq %rax, 0x20(%rbx)
jmp 0x7369
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
callq 0x733c
movq %rax, %rbx
testq %rax, %rax
je 0x738e
leaq 0x591c(%rip), %rdi      # 0xcca5
callq 0x8b1b
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
leaq 0x4f07(%rip), %rdi      # 0xc2a5
callq 0x8ad7
testq %rax, %rax
je 0x73e8
movq %rax, %r14
xorl %eax, %eax
callq 0x3ea7
movq %rax, %rbx
movq %r14, 0x10(%rax)
callq 0x7374
testq %rax, %rax
jne 0x73cd
callq 0x6eeb
testq %rax, %rax
je 0x73da
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3f25
jmp 0x73b9
leaq 0x4ec6(%rip), %rdi      # 0xc2a7
callq 0x8b1b
jmp 0x73ea
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
callq 0x7413
xorl %eax, %eax
callq 0x3ea7
movq %rax, %rbx
leaq 0x5855(%rip), %r14      # 0xcca5
callq 0x733c
testq %rax, %rax
je 0x74fe
movq %rax, %r15
movq %r14, %rdi
callq 0x8ad7
testq %rax, %rax
je 0x74e1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3f25
movq 0x10(%r15), %rdi
callq 0x3144
testb %al, %al
je 0x7515
movq %r15, %rdi
callq 0x3153
testb %al, %al
je 0x7450
movq %r15, %rdi
callq 0x9aa3
movq %rax, %r15
movq %rax, %rdi
callq 0x956f
movq %rax, %r12
movq %rax, %rdi
callq 0x3598
movq 0x9ec5(%rip), %r13      # 0x11380
movq %r12, %rdi
callq 0x87a7
movq %rax, %r12
movq %r15, %rdi
callq 0x9554
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x3f58
jmp 0x7450
movq %r15, %rdi
callq 0x73f5
testq %rax, %rax
je 0x752d
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3f25
jmp 0x7450
callq 0x8b6e
testq %rax, %rax
jne 0x7532
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x4db8(%rip), %rdi      # 0xc2d4
leaq 0x4ce3(%rip), %rsi      # 0xc206
movl $0x21e, %edx            # imm = 0x21E
callq 0x3cc4
callq 0x8b6e
leaq 0x4db4(%rip), %rsi      # 0xc2ed
movq %rax, %rdi
xorl %eax, %eax
callq 0x3de9
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3483(%rip), %r14      # 0xb2b3
testq %rbx, %rbx
je 0x7e56
cmpl $0x1, 0x108(%rbx)
jne 0x7e56
movq %rbx, %rdi
movq %r14, %rsi
callq 0x87de
testl %eax, %eax
jne 0x7e56
movq 0x110(%rbx), %rbx
jmp 0x7e30
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x7eb5
movq %rsi, %rbx
testq %rsi, %rsi
je 0x7eb5
movq %rdi, %r14
callq 0x2080
movq %rax, %r15
movq %rbx, %rdi
callq 0x2080
leaq (%r15,%rax), %rdi
incq %rdi
callq 0x2140
testq %rax, %rax
je 0x7ec7
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x2050
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2190
leaq 0x45ec(%rip), %rdi      # 0xc4a8
leaq 0x4446(%rip), %rsi      # 0xc309
pushq $0x40
jmp 0x7ed7
leaq 0x4515(%rip), %rdi      # 0xc3e3
leaq 0x4434(%rip), %rsi      # 0xc309
pushq $0x42
popq %rdx
callq 0x3cc4