LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/hikalium[P]compilium/ast.c
// Function: CreateASTIdent
struct Node *CreateASTIdent(struct Node *ident) {
  assert(IsToken(ident));
  struct Node *n = AllocNode(kASTIdent);
  n->op = ident;
  return n;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x9130
testb %al, %al
je 0x438c
movl $0x1, %edi
movl $0x138, %esi            # imm = 0x138
callq 0x20f0
movl $0xa, (%rax)
movq %rbx, 0x10(%rax)
popq %rbx
retq
leaq 0x7161(%rip), %rdi      # 0xb4f4
leaq 0x701d(%rip), %rsi      # 0xb3b7
movl $0x89, %edx
callq 0x4704
// File: /workspace/github_c_makefile_star2_O1/hikalium[P]compilium/ast.c
// Function: CreateTypeArray
struct Node *CreateTypeArray(struct Node *type_of, struct Node *index_decl) {
  struct Node *n = AllocNode(kTypeArray);
  n->type_array_type_of = type_of;
  n->type_array_index_decl = index_decl;
  return n;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x138, %esi            # imm = 0x138
callq 0x20f0
movl $0x1a, (%rax)
movq %r14, 0xf8(%rax)
movq %rbx, 0x100(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %edi
movl $0x138, %esi            # imm = 0x138
callq 0x20f0
movl $0x3, (%rax)
movq %r14, 0xb8(%rax)
movq %rbx, 0xa0(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x467a
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 0xc936(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
callq 0x2150
movq 0xc94f(%rip), %r15      # 0x10ff8
movq (%r15), %rcx
leaq 0x6f30(%rip), %rdi      # 0xb5e3
movl $0x7, %esi
movl $0x1, %edx
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
movl $0xa, %edi
callq 0x20d0
movl $0x1, %edi
callq 0x21a0
// File: /workspace/github_c_makefile_star2_O1/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 0x479f
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 0x471b
movq 0xc84d(%rip), %r15      # 0x10ff8
movq (%r15), %rcx
leaq 0x6e2e(%rip), %rdi      # 0xb5e3
movl $0x7, %esi
movl $0x1, %edx
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
movl $0xa, %edi
callq 0x20d0
movl $0x1, %edi
callq 0x21a0
// File: /workspace/github_c_makefile_star2_O1/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 0x485c
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 0x485e
movl 0x88(%rbx), %eax
cmpl 0x84(%rbx), %eax
jge 0x4876
popq %rbx
retq
leaq 0x6dbb(%rip), %rdi      # 0xb620
leaq 0x6d9e(%rip), %rsi      # 0xb60a
movl $0x6e, %edx
callq 0x4704
leaq 0x6daf(%rip), %rdi      # 0xb62c
leaq 0x6d86(%rip), %rsi      # 0xb60a
movl $0x6f, %edx
callq 0x4704
// File: /workspace/github_c_makefile_star2_O1/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 0x4a25
movq %rdi, %r14
cmpl $0x6, (%rdi)
jne 0x4a25
cmpl $0x0, 0x88(%r14)
jle 0x4a15
movq %rsi, %rbx
xorl %r12d, %r12d
movq 0x90(%r14), %rax
movq (%rax,%r12,8), %r13
movl $0x4, %eax
cmpl $0x11, (%r13)
jne 0x4a02
movq 0x98(%r13), %rsi
movq %rbx, %rdi
callq 0x9278
testl %eax, %eax
je 0x4a00
movq 0xa0(%r13), %r15
movl $0x1, %eax
jmp 0x4a02
xorl %eax, %eax
testb $0x3, %al
jne 0x4a18
incq %r12
movslq 0x88(%r14), %rax
cmpq %rax, %r12
jl 0x49c8
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x6c29(%rip), %rdi      # 0xb655
leaq 0x6bd7(%rip), %rsi      # 0xb60a
movl $0x8a, %edx
callq 0x4704
// File: /workspace/github_c_makefile_star2_O1/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 0x4abd
cmpl $0x6, (%rdi)
jne 0x4abd
movslq 0x88(%rdi), %r15
testq %r15, %r15
jle 0x4aa8
movq %rsi, %rbx
movq 0x90(%rdi), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rbp
movl $0x4, %ecx
cmpl $0x11, (%rbp)
jne 0x4a9b
movq 0x98(%rbp), %rdi
movq %rbx, %rsi
callq 0x2100
xorl %ecx, %ecx
testl %eax, %eax
jne 0x4a9b
movq 0xa0(%rbp), %r14
movl $0x1, %ecx
testb $0x3, %cl
jne 0x4aab
incq %r13
cmpq %r13, %r15
jne 0x4a6b
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6b91(%rip), %rdi      # 0xb655
leaq 0x6b3f(%rip), %rsi      # 0xb60a
movl $0x94, %edx
callq 0x4704
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x2000, %edi           # imm = 0x2000
callq 0x2140
movq %rax, %rbx
movq %r14, %rdi
callq 0x20c0
movl $0x2000, %ebp           # imm = 0x2000
xorl %r15d, %r15d
cmpl $-0x1, %eax
je 0x4e68
movb %al, (%rbx,%r15)
incq %r15
movl %ebp, %eax
cmpq %rax, %r15
jne 0x4e5e
addl %ebp, %ebp
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0x2160
movq %rax, %rbx
testq %rax, %rax
je 0x4e82
movq %r14, %rdi
callq 0x20c0
jmp 0x4e36
cmpl %ebp, %r15d
jge 0x4e9a
movl %r15d, %eax
movb $0x0, (%rbx,%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x69d9(%rip), %rdi      # 0xb862
leaq 0x677a(%rip), %rsi      # 0xb60a
movl $0x106, %edx            # imm = 0x106
callq 0x4704
leaq 0x69e4(%rip), %rdi      # 0xb885
leaq 0x6762(%rip), %rsi      # 0xb60a
movl $0x109, %edx            # imm = 0x109
callq 0x4704
// File: /workspace/github_c_makefile_star2_O1/hikalium[P]compilium/compilium.c
// Function: main
int main(int argc, char *argv[]) {
  struct Node *replacement_list = ParseCompilerArgs(argc, argv);
  const char *input = ReadFile(stdin);

  struct Node *tokens = Tokenize(input);

  fputs("Preprocess begin\n", stderr);
  Preprocess(&tokens, replacement_list);
  if (is_preprocess_only) {
    OutputTokenSequenceAsCSource(tokens);
    return 0;
  }

  fputs("Parse begin\n", stderr);
  struct Node *ast = Parse(&tokens);
  PrintASTNode(ast);
  fputc('\n', stderr);

  fputs("Analyze begin\n", stderr);
  struct SymbolEntry *ctx = Analyze(ast);
  PrintASTNode(ast);
  fputc('\n', stderr);

  Generate(ast, ctx);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl $0x6, %edi
callq 0x3f05
movq %rax, (%rsp)
leaq 0x6a0d(%rip), %rax      # 0xb8e4
movq %rax, 0xc47a(%rip)      # 0x11358
cmpl $0x2, %ebp
jl 0x502e
movl $0x1, %r12d
leaq 0x69d5(%rip), %r15      # 0xb8c9
movslq %r12d, %r13
movq (%rbx,%r13,8), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x2100
testl %eax, %eax
je 0x4f6e
movq %r14, %rdi
leaq 0x69eb(%rip), %rsi      # 0xb8ff
callq 0x2100
testl %eax, %eax
je 0x4fe3
movq %r14, %rdi
leaq 0x6a28(%rip), %rsi      # 0xb953
callq 0x2100
testl %eax, %eax
je 0x5048
movq %r14, %rdi
leaq 0x6a25(%rip), %rsi      # 0xb967
callq 0x2100
testl %eax, %eax
je 0x4fb0
movq %r14, %rdi
leaq 0x6a26(%rip), %rsi      # 0xb97b
callq 0x2100
testl %eax, %eax
jne 0x5073
movb $0x1, 0xc3e7(%rip)      # 0x11350
jmp 0x5022
incl %r12d
movq 0x8(%rbx,%r13,8), %r14
movq %r14, %rdi
leaq 0x6955(%rip), %rsi      # 0xb8d5
callq 0x2100
testl %eax, %eax
je 0x4fb7
movq %r14, %rdi
leaq 0x6953(%rip), %rsi      # 0xb8e6
callq 0x2100
testl %eax, %eax
jne 0x507c
leaq 0x630d(%rip), %rax      # 0xb2b4
movq %rax, 0xc3aa(%rip)      # 0x11358
jmp 0x5022
callq 0xa957
jmp 0x5022
leaq 0x6926(%rip), %rax      # 0xb8e4
movq %rax, 0xc393(%rip)      # 0x11358
xorl %edi, %edi
xorl %esi, %esi
callq 0x43d9
movq (%rsp), %rdi
leaq 0x6903(%rip), %rsi      # 0xb8dc
movq %rax, %rdx
callq 0x48c1
jmp 0x5022
movq 0x8(%rbx,%r13,8), %r14
movq %r14, 0xc371(%rip)      # 0x11360
testq %r14, %r14
je 0x504d
movq %r14, %rdi
callq 0x2080
cmpb $0x2f, -0x1(%r14,%rax)
jne 0x5065
incl %r12d
movq 0xbfea(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x6929(%rip), %rsi      # 0xb941
movq %r14, %rdx
xorl %eax, %eax
callq 0x2110
incl %r12d
cmpl %ebp, %r12d
jl 0x4ef4
movq (%rsp), %rdi
callq 0x2941
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4ad5
leaq 0x68ae(%rip), %rdi      # 0xb902
leaq 0x65af(%rip), %rsi      # 0xb60a
movl $0x2c, %edx
callq 0x4704
leaq 0x68a3(%rip), %rdi      # 0xb90f
xorl %eax, %eax
callq 0x4630
leaq 0x6904(%rip), %rdi      # 0xb97e
jmp 0x5083
leaq 0x6869(%rip), %rdi      # 0xb8ec
movq %r14, %rsi
xorl %eax, %eax
callq 0x4630
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x50d8
movl %esi, %ebx
movq %rdi, %r14
callq 0xa222
cmpl $0x1, %eax
je 0x50c6
movl %eax, %ebp
cmpl $0x8, %eax
je 0x50bd
cmpl $0x4, %ebp
jne 0x50f0
leaq 0xc195(%rip), %rax      # 0x11250
jmp 0x50cd
leaq 0xc15c(%rip), %rax      # 0x11220
jmp 0x50cd
leaq 0xc1b3(%rip), %rax      # 0x11280
movl %ebx, %ecx
movq (%rax,%rcx,8), %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x68dd(%rip), %rdi      # 0xb9bc
leaq 0x68ff(%rip), %rsi      # 0xb9e5
movl $0xb4, %edx
callq 0x4704
movq %r14, %rdi
callq 0xa121
leaq 0x68f2(%rip), %rsi      # 0xb9f1
movq %rax, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x4740
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdi, %r14
xorl %eax, %eax
movl %eax, 0xc244(%rip)      # 0x11368
movl %eax, 0xc242(%rip)      # 0x1136c
xorl %eax, %eax
callq 0x4806
movq %rax, 0xc238(%rip)      # 0x11370
leaq 0x6fca(%rip), %rdi      # 0xc109
callq 0x2060
leaq 0x6fd5(%rip), %rdi      # 0xc120
callq 0x2060
movq %r14, %rdi
callq 0x520f
leaq 0x704b(%rip), %rdi      # 0xc1aa
callq 0x2060
movq 0xc205(%rip), %rdi      # 0x11370
callq 0x4922
testl %eax, %eax
jle 0x51fb
leaq 0x6f53(%rip), %r14      # 0xc0d2
leaq 0x6f52(%rip), %r15      # 0xc0d8
movq 0xbe43(%rip), %r13      # 0x10fd0
xorl %ebp, %ebp
movq 0xc1da(%rip), %rdi      # 0x11370
movl %ebp, %esi
callq 0x494c
movq %rax, %r12
movl 0xac(%rax), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2090
movq %r15, %rdi
xorl %eax, %eax
callq 0x2090
movq 0x10(%r12), %rdi
movq (%r13), %rsi
callq 0x939d
movl $0xa, %edi
callq 0x2030
incl %ebp
movq 0xc195(%rip), %rdi      # 0x11370
callq 0x4922
cmpl %eax, %ebp
jl 0x518f
jmp 0x51fb
cmpl $0x1, (%rbx)
je 0x51f1
movq 0x8(%rbx), %rbx
jmp 0x51fb
movq %rbx, %rdi
callq 0x2a0e
jmp 0x51eb
testq %rbx, %rbx
jne 0x51e6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x520f
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x6912
cmpl $0x15, (%rdi)
jne 0x6912
movq 0x20(%rdi), %rax
cmpl $0x1a, (%rax)
jne 0x6914
popq %rbx
retq
callq 0xa133
movq %rax, %rdi
callq 0xa222
cmpl $0x1, %eax
je 0x6942
cmpl $0x8, %eax
je 0x6939
cmpl $0x4, %eax
jne 0x6963
leaq 0x5537(%rip), %rdi      # 0xbe6e
jmp 0x6949
leaq 0x5520(%rip), %rdi      # 0xbe60
jmp 0x6949
leaq 0x553f(%rip), %rdi      # 0xbe88
movslq 0x4(%rbx), %rax
leaq 0xa7ac(%rip), %rcx      # 0x11100
movq (%rcx,%rax,8), %rdx
movq %rdx, %rsi
xorl %eax, %eax
popq %rbx
jmp 0x2090
movq 0x10(%rbx), %rdi
leaq 0x5532(%rip), %rsi      # 0xbea0
movl %eax, %edx
xorl %eax, %eax
callq 0x4740
// File: /workspace/github_c_makefile_star2_O1/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 0xa775(%rip), %r15      # 0x11100
movq (%r15,%r14,8), %rsi
leaq 0x5535(%rip), %rdi      # 0xbecb
xorl %eax, %eax
callq 0x2090
leaq 0xa81c(%rip), %r12      # 0x111c0
movq (%r12,%r14,8), %rsi
leaq 0x5527(%rip), %rdi      # 0xbed6
xorl %eax, %eax
callq 0x2090
movslq %ebx, %rax
movq (%r15,%rax,8), %rsi
movq (%r12,%r14,8), %rdx
leaq 0x5518(%rip), %rdi      # 0xbee0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2090
// File: /workspace/github_c_makefile_star2_O1/hikalium[P]compilium/generator.c
// Function: EmitMoveToMemory
static void EmitMoveToMemory(struct Node *op, int dst, int src, int size) {
  if (size == 8) {
    printf("mov [%s], %s\n", reg_names_64[dst], reg_names_64[src]);
    return;
  }
  if (size == 4) {
    printf("mov [%s], %s # 4 byte store\n", reg_names_64[dst],
           reg_names_32[src]);
    return;
  }
  if (size == 1) {
    printf("mov [%s], %s\n", reg_names_64[dst], reg_names_8[src]);
    return;
  }
  ErrorWithToken(op, "Assigning %d bytes is not implemented.", size);
}

// Assembly:
movq %rdi, %rax
leaq 0x54c8(%rip), %rdi      # 0xbf99
leaq 0xa628(%rip), %r8       # 0x11100
cmpl $0x1, %ecx
je 0x6afa
movq %r8, %r9
cmpl $0x8, %ecx
je 0x6b01
cmpl $0x4, %ecx
jne 0x6b16
leaq 0x54b6(%rip), %rdi      # 0xbfa7
leaq 0xa668(%rip), %r9       # 0x11160
jmp 0x6b01
leaq 0xa6bf(%rip), %r9       # 0x111c0
movslq %esi, %rax
movq (%r8,%rax,8), %rsi
movslq %edx, %rax
movq (%r9,%rax,8), %rdx
xorl %eax, %eax
jmp 0x2090
pushq %rax
leaq 0x4ed3(%rip), %rsi      # 0xb9f1
movq %rax, %rdi
movl %ecx, %edx
xorl %eax, %eax
callq 0x4740
// File: /workspace/github_c_makefile_star2_O1/hikalium[P]compilium/generator.c
// Function: EmitAddToMemory
static void EmitAddToMemory(struct Node *op, int dst, int src, int size) {
  if (size == 8) {
    printf("add qword ptr [%s], %s\n", reg_names_64[dst], reg_names_64[src]);
    return;
  }
  if (size == 4) {
    printf("add dword ptr [%s], %s\n", reg_names_64[dst], reg_names_32[src]);
    return;
  }
  if (size == 1) {
    printf("add byte ptr [%s], %s\n", reg_names_64[dst], reg_names_8[src]);
    return;
  }
  ErrorWithToken(op, "Assigning %d bytes is not implemented.", size);
}

// Assembly:
leaq 0xa5cf(%rip), %rax      # 0x11100
cmpl $0x1, %ecx
je 0x6b5c
cmpl $0x8, %ecx
je 0x6b50
cmpl $0x4, %ecx
jne 0x6b7f
leaq 0x5495(%rip), %rdi      # 0xbfdc
leaq 0xa612(%rip), %rcx      # 0x11160
jmp 0x6b6a
leaq 0x546d(%rip), %rdi      # 0xbfc4
movq %rax, %rcx
jmp 0x6b6a
leaq 0x5491(%rip), %rdi      # 0xbff4
leaq 0xa656(%rip), %rcx      # 0x111c0
movslq %esi, %rsi
movq (%rax,%rsi,8), %rsi
movslq %edx, %rax
movq (%rcx,%rax,8), %rdx
xorl %eax, %eax
jmp 0x2090
pushq %rax
leaq 0x4e6a(%rip), %rsi      # 0xb9f1
movl %ecx, %edx
xorl %eax, %eax
callq 0x4740
// File: /workspace/github_c_makefile_star2_O1/hikalium[P]compilium/generator.c
// Function: EmitSubFromMemory
static void EmitSubFromMemory(struct Node *op, int dst, int src, int size) {
  if (size == 8) {
    printf("sub qword ptr [%s], %s\n", reg_names_64[dst], reg_names_64[src]);
    return;
  }
  if (size == 4) {
    printf("sub dword ptr [%s], %s\n", reg_names_64[dst], reg_names_32[src]);
    return;
  }
  if (size == 1) {
    printf("sub byte ptr [%s], %s\n", reg_names_64[dst], reg_names_8[src]);
    return;
  }
  ErrorWithToken(op, "Assigning %d bytes is not implemented.", size);
}

// Assembly:
leaq 0xa569(%rip), %rax      # 0x11100
cmpl $0x1, %ecx
je 0x6bc2
cmpl $0x8, %ecx
je 0x6bb6
cmpl $0x4, %ecx
jne 0x6be5
leaq 0x5476(%rip), %rdi      # 0xc023
leaq 0xa5ac(%rip), %rcx      # 0x11160
jmp 0x6bd0
leaq 0x544e(%rip), %rdi      # 0xc00b
movq %rax, %rcx
jmp 0x6bd0
leaq 0x5472(%rip), %rdi      # 0xc03b
leaq 0xa5f0(%rip), %rcx      # 0x111c0
movslq %esi, %rsi
movq (%rax,%rsi,8), %rsi
movslq %edx, %rax
movq (%rcx,%rax,8), %rdx
xorl %eax, %eax
jmp 0x2090
pushq %rax
leaq 0x4e04(%rip), %rsi      # 0xb9f1
movl %ecx, %edx
xorl %eax, %eax
callq 0x4740
// File: /workspace/github_c_makefile_star2_O1/hikalium[P]compilium/generator.c
// Function: EmitMulToMemory
static void EmitMulToMemory(struct Node *op, int dst, int src, int size) {
  if (size == 4) {
    // rdx:rax <- rax * r/m
    printf("xor rdx, rdx\n");
    printf("mov rax, %s\n", reg_names_64[dst]);
    printf("mov eax, [rax]\n");
    printf("imul %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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x4, %ecx
jne 0x6c6b
movl %edx, %ebx
movl %esi, %ebp
leaq 0x55b2(%rip), %rdi      # 0xc1bf
callq 0x2060
movslq %ebp, %r14
leaq 0xa4e4(%rip), %r15      # 0x11100
movq (%r15,%r14,8), %rsi
leaq 0x510a(%rip), %rdi      # 0xbd31
xorl %eax, %eax
callq 0x2090
leaq 0x557b(%rip), %rdi      # 0xc1b0
callq 0x2060
movslq %ebx, %rax
movq (%r15,%rax,8), %rsi
leaq 0x50f6(%rip), %rdi      # 0xbd3e
xorl %eax, %eax
callq 0x2090
movq (%r15,%r14,8), %rsi
leaq 0x53f8(%rip), %rdi      # 0xc052
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2090
leaq 0x4d7f(%rip), %rsi      # 0xb9f1
movl %ecx, %edx
xorl %eax, %eax
callq 0x4740
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x4, %ecx
jne 0x6ce4
movl %edx, %ebx
movl %esi, %ebp
leaq 0x552d(%rip), %rdi      # 0xc1bf
callq 0x2060
movslq %ebp, %r14
leaq 0xa45f(%rip), %r15      # 0x11100
movq (%r15,%r14,8), %rsi
leaq 0x53b5(%rip), %rdi      # 0xc061
xorl %eax, %eax
callq 0x2090
movslq %ebx, %rax
movq (%r15,%rax,8), %rsi
leaq 0x5086(%rip), %rdi      # 0xbd47
xorl %eax, %eax
callq 0x2090
movq (%r15,%r14,8), %rsi
leaq 0x537f(%rip), %rdi      # 0xc052
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2090
leaq 0x4d06(%rip), %rsi      # 0xb9f1
movl %ecx, %edx
xorl %eax, %eax
callq 0x4740
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x4, %ecx
jne 0x6d5d
movl %edx, %ebx
movl %esi, %ebp
leaq 0x54b4(%rip), %rdi      # 0xc1bf
callq 0x2060
movslq %ebp, %r14
leaq 0xa3e6(%rip), %r15      # 0x11100
movq (%r15,%r14,8), %rsi
leaq 0x533c(%rip), %rdi      # 0xc061
xorl %eax, %eax
callq 0x2090
movslq %ebx, %rax
movq (%r15,%rax,8), %rsi
leaq 0x500d(%rip), %rdi      # 0xbd47
xorl %eax, %eax
callq 0x2090
movq (%r15,%r14,8), %rsi
leaq 0x5324(%rip), %rdi      # 0xc070
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2090
leaq 0x4c8d(%rip), %rsi      # 0xb9f1
movl %ecx, %edx
xorl %eax, %eax
callq 0x4740
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
cmpl $0x4, %ecx
jne 0x6dae
movl %esi, %ebx
movslq %edx, %rax
leaq 0xa3e1(%rip), %rcx      # 0x11160
movq (%rcx,%rax,8), %rsi
leaq 0x52f5(%rip), %rdi      # 0xc07f
xorl %eax, %eax
callq 0x2090
movslq %ebx, %rax
leaq 0xa365(%rip), %rcx      # 0x11100
movq (%rcx,%rax,8), %rsi
leaq 0x52e6(%rip), %rdi      # 0xc08c
xorl %eax, %eax
popq %rbx
jmp 0x2090
leaq 0x4c3c(%rip), %rsi      # 0xb9f1
movl %ecx, %edx
xorl %eax, %eax
callq 0x4740
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
cmpl $0x4, %ecx
jne 0x6dff
movl %esi, %ebx
movslq %edx, %rax
leaq 0xa390(%rip), %rcx      # 0x11160
movq (%rcx,%rax,8), %rsi
leaq 0x52a4(%rip), %rdi      # 0xc07f
xorl %eax, %eax
callq 0x2090
movslq %ebx, %rax
leaq 0xa314(%rip), %rcx      # 0x11100
movq (%rcx,%rax,8), %rsi
leaq 0x52ad(%rip), %rdi      # 0xc0a4
xorl %eax, %eax
popq %rbx
jmp 0x2090
leaq 0x4beb(%rip), %rsi      # 0xb9f1
movl %ecx, %edx
xorl %eax, %eax
callq 0x4740
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x3, %edi
callq 0x9431
testq %rax, %rax
jne 0x6ebc
movl $0x4, %edi
callq 0x9431
testq %rax, %rax
jne 0x6ebc
movl $0x17, %edi
callq 0x9431
testq %rax, %rax
jne 0x6ebc
movl $0x18, %edi
callq 0x9431
testq %rax, %rax
je 0x6edb
movq %rax, %rbx
movl $0x4, %edi
callq 0x3f05
movq %rax, %r14
movq %rbx, 0x10(%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x46e2(%rip), %rdi      # 0xb5c4
callq 0x94f8
testq %rax, %rax
je 0x6f1c
movq %rax, %rbx
movl $0x4, %edi
callq 0x3f05
movq %rax, %r14
movq %rbx, 0x10(%rax)
callq 0x6f32
movq %rax, 0x20(%r14)
testq %rax, %rax
je 0x6f21
leaq 0x5964(%rip), %rdi      # 0xc879
callq 0x953c
jmp 0x6ed0
xorl %r14d, %r14d
jmp 0x6ed0
leaq 0x52a4(%rip), %rsi      # 0xc1cc
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4740
// File: /workspace/github_c_makefile_star2_O1/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 0x76ab
testq %rax, %rax
je 0x6f87
movq %rax, %rbx
leaq 0x42cf(%rip), %rdi      # 0xb21a
callq 0x94f8
testq %rax, %rax
je 0x6f89
movq %rax, %r15
leaq 0x42bb(%rip), %r14      # 0xb21a
callq 0x76ab
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3f1b
movq %rax, %rbx
movq %r14, %rdi
callq 0x94f8
movq %rax, %r15
testq %rax, %rax
jne 0x6f5f
jmp 0x6f89
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x406a(%rip), %rdi      # 0xb1a8
callq 0x94f8
testq %rax, %rax
jne 0x71d2
leaq 0x4052(%rip), %rdi      # 0xb1a5
callq 0x94f8
testq %rax, %rax
jne 0x71d2
leaq 0x4b0d(%rip), %rdi      # 0xbc71
callq 0x94f8
testq %rax, %rax
jne 0x71d2
leaq 0x4b06(%rip), %rdi      # 0xbc7b
callq 0x94f8
testq %rax, %rax
jne 0x71d2
leaq 0x4b7a(%rip), %rdi      # 0xbd00
callq 0x94f8
testq %rax, %rax
jne 0x71d2
leaq 0x4038(%rip), %rdi      # 0xb1cf
callq 0x94f8
testq %rax, %rax
jne 0x71d2
leaq 0x3ffc(%rip), %rdi      # 0xb1a4
callq 0x94f8
testq %rax, %rax
jne 0x71d2
leaq 0x3fee(%rip), %rdi      # 0xb1a7
callq 0x94f8
testq %rax, %rax
jne 0x71d2
movl $0x10, %edi
callq 0x9431
testq %rax, %rax
je 0x71e6
movq %rax, %rbx
callq 0x7136
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x3f66
popq %rbx
jmp 0x6f92
// File: /workspace/github_c_makefile_star2_O1/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 0x7136
testq %rax, %rax
je 0x725e
movq %rax, %rbx
leaq 0x3fc1(%rip), %r14      # 0xb1cf
leaq 0x5135(%rip), %r15      # 0xc34a
leaq 0x4b34(%rip), %r12      # 0xbd50
movq %r14, %rdi
callq 0x94f8
testq %rax, %rax
jne 0x7243
movq %r15, %rdi
callq 0x94f8
testq %rax, %rax
jne 0x7243
movq %r12, %rdi
callq 0x94f8
testq %rax, %rax
je 0x7260
movq %rax, %r13
callq 0x7136
movq %r13, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3f1b
movq %rax, %rbx
jmp 0x721c
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x71f1
testq %rax, %rax
je 0x72c5
movq %rax, %rbx
leaq 0x3f1f(%rip), %r14      # 0xb1a8
leaq 0x3f15(%rip), %r15      # 0xb1a5
movq %r14, %rdi
callq 0x94f8
testq %rax, %rax
jne 0x72aa
movq %r15, %rdi
callq 0x94f8
testq %rax, %rax
je 0x72c7
movq %rax, %r12
callq 0x71f1
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3f1b
movq %rax, %rbx
jmp 0x7290
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x726d
testq %rax, %rax
je 0x732e
movq %rax, %rbx
leaq 0x4a6d(%rip), %r14      # 0xbd5f
leaq 0x4a82(%rip), %r15      # 0xbd7b
movq %r14, %rdi
callq 0x94f8
testq %rax, %rax
jne 0x7313
movq %r15, %rdi
callq 0x94f8
testq %rax, %rax
je 0x7330
movq %rax, %r12
callq 0x726d
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3f1b
movq %rax, %rbx
jmp 0x72f9
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x72d6
testq %rax, %rax
je 0x73c2
movq %rax, %rbx
leaq 0x4a02(%rip), %r14      # 0xbd60
leaq 0x3d29(%rip), %r15      # 0xb08e
leaq 0x49b2(%rip), %r12      # 0xbd1e
leaq 0x49af(%rip), %r13      # 0xbd22
movq %r14, %rdi
callq 0x94f8
testq %rax, %rax
jne 0x73a7
movq %r15, %rdi
callq 0x94f8
testq %rax, %rax
jne 0x73a7
movq %r12, %rdi
callq 0x94f8
testq %rax, %rax
jne 0x73a7
movq %r13, %rdi
callq 0x94f8
testq %rax, %rax
je 0x73c4
movq %rax, %rbp
callq 0x72d6
movq %rbp, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3f1b
movq %rax, %rbx
jmp 0x7373
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_O1/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 0x733f
testq %rax, %rax
je 0x742e
movq %rax, %rbx
leaq 0x499b(%rip), %r14      # 0xbd8d
leaq 0x4997(%rip), %r15      # 0xbd90
movq %r14, %rdi
callq 0x94f8
testq %rax, %rax
jne 0x7413
movq %r15, %rdi
callq 0x94f8
testq %rax, %rax
je 0x7430
movq %rax, %r12
callq 0x733f
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3f1b
movq %rax, %rbx
jmp 0x73f9
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x73d6
testq %rax, %rax
je 0x7494
movq %rax, %rbx
leaq 0x48a8(%rip), %rdi      # 0xbd00
callq 0x94f8
testq %rax, %rax
je 0x7496
movq %rax, %r15
leaq 0x4894(%rip), %r14      # 0xbd00
callq 0x73d6
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3f1b
movq %rax, %rbx
movq %r14, %rdi
callq 0x94f8
movq %rax, %r15
testq %rax, %rax
jne 0x746c
jmp 0x7496
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x743f
testq %rax, %rax
je 0x74f4
movq %rax, %rbx
leaq 0x48e7(%rip), %rdi      # 0xbd9f
callq 0x94f8
testq %rax, %rax
je 0x74f6
movq %rax, %r15
leaq 0x48d3(%rip), %r14      # 0xbd9f
callq 0x743f
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3f1b
movq %rax, %rbx
movq %r14, %rdi
callq 0x94f8
movq %rax, %r15
testq %rax, %rax
jne 0x74cc
jmp 0x74f6
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x749f
testq %rax, %rax
je 0x7554
movq %rax, %rbx
leaq 0x47eb(%rip), %rdi      # 0xbd03
callq 0x94f8
testq %rax, %rax
je 0x7556
movq %rax, %r15
leaq 0x47d7(%rip), %r14      # 0xbd03
callq 0x749f
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3f1b
movq %rax, %rbx
movq %r14, %rdi
callq 0x94f8
movq %rax, %r15
testq %rax, %rax
jne 0x752c
jmp 0x7556
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x74ff
testq %rax, %rax
je 0x75b4
movq %rax, %rbx
leaq 0x4787(%rip), %rdi      # 0xbcff
callq 0x94f8
testq %rax, %rax
je 0x75b6
movq %rax, %r15
leaq 0x4773(%rip), %r14      # 0xbcff
callq 0x74ff
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3f1b
movq %rax, %rbx
movq %r14, %rdi
callq 0x94f8
movq %rax, %r15
testq %rax, %rax
jne 0x758c
jmp 0x75b6
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x755f
testq %rax, %rax
je 0x7614
movq %rax, %rbx
leaq 0x472a(%rip), %rdi      # 0xbd02
callq 0x94f8
testq %rax, %rax
je 0x7616
movq %rax, %r15
leaq 0x4716(%rip), %r14      # 0xbd02
callq 0x755f
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3f1b
movq %rax, %rbx
movq %r14, %rdi
callq 0x94f8
movq %rax, %r15
testq %rax, %rax
jne 0x75ec
jmp 0x7616
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x75bf
testq %rax, %rax
je 0x768e
movq %rax, %r14
leaq 0x4bdb(%rip), %rdi      # 0xc213
callq 0x94f8
testq %rax, %rax
je 0x7691
movq %rax, %rbx
movl $0x4, %edi
callq 0x3f05
movq %rax, %r15
movq %rbx, 0x10(%rax)
movq %r14, 0x30(%rax)
callq 0x761f
movq %rax, 0x18(%r15)
testq %rax, %rax
je 0x769a
leaq 0x4bd3(%rip), %rdi      # 0xc242
callq 0x953c
callq 0x761f
movq %rax, 0x20(%r15)
movq %r15, %r14
testq %rax, %rax
jne 0x7691
leaq 0x4bb8(%rip), %rsi      # 0xc244
jmp 0x76a1
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4b74(%rip), %rsi      # 0xc215
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4740
// File: /workspace/github_c_makefile_star2_O1/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 0x761f
testq %rax, %rax
je 0x776a
movq %rax, %rbx
leaq 0x46ca(%rip), %rdi      # 0xbd91
callq 0x94f8
testq %rax, %rax
jne 0x7748
leaq 0x4636(%rip), %rdi      # 0xbd0e
callq 0x94f8
testq %rax, %rax
jne 0x7748
leaq 0x4628(%rip), %rdi      # 0xbd11
callq 0x94f8
testq %rax, %rax
jne 0x7748
leaq 0x461a(%rip), %rdi      # 0xbd14
callq 0x94f8
testq %rax, %rax
jne 0x7748
leaq 0x460c(%rip), %rdi      # 0xbd17
callq 0x94f8
testq %rax, %rax
jne 0x7748
leaq 0x45fe(%rip), %rdi      # 0xbd1a
callq 0x94f8
testq %rax, %rax
jne 0x7748
leaq 0x45f0(%rip), %rdi      # 0xbd1d
callq 0x94f8
testq %rax, %rax
jne 0x7748
leaq 0x45e3(%rip), %rdi      # 0xbd21
callq 0x94f8
testq %rax, %rax
je 0x776c
movq %rax, %r14
callq 0x76ab
testq %rax, %rax
je 0x7777
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3f1b
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4a4e(%rip), %rsi      # 0xc1cc
movq %r14, %rdi
xorl %eax, %eax
callq 0x4740
// File: /workspace/github_c_makefile_star2_O1/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 0x6f32
movq %rax, %rbx
leaq 0x5511(%rip), %rdi      # 0xcca9
callq 0x94f8
testq %rax, %rax
je 0x77ae
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x4014
testq %rbx, %rbx
je 0x77bf
leaq 0x54ef(%rip), %rdi      # 0xcca9
callq 0x953c
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0xc, %edi
callq 0x9431
testq %rax, %rax
je 0x7842
movq %rax, %rbx
leaq 0x3de0(%rip), %rdi      # 0xb5c4
callq 0x953c
callq 0x6f32
testq %rax, %rax
je 0x7854
movq %rax, %r14
leaq 0x507c(%rip), %rdi      # 0xc879
callq 0x953c
callq 0x7a59
testq %rax, %rax
je 0x786c
movq %rax, %r12
movl $0x9, %edi
callq 0x3f05
movq %rax, %r15
movq %rbx, 0x10(%rax)
movq %r14, 0x30(%rax)
movq %r12, 0x48(%rax)
movl $0x9, %edi
callq 0x9431
testq %rax, %rax
je 0x7845
callq 0x7a59
movq %rax, 0x50(%r15)
jmp 0x7845
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4a12(%rip), %rdi      # 0xc26d
leaq 0x49a8(%rip), %rsi      # 0xc20a
movl $0x103, %edx            # imm = 0x103
callq 0x4704
leaq 0x49ff(%rip), %rdi      # 0xc272
leaq 0x4990(%rip), %rsi      # 0xc20a
movl $0x106, %edx            # imm = 0x106
callq 0x4704
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x5, %edi
callq 0x9431
testq %rax, %rax
jne 0x78a6
movl $0x8, %edi
callq 0x9431
testq %rax, %rax
je 0x78cb
movq %rax, %rbx
leaq 0x53f9(%rip), %rdi      # 0xcca9
callq 0x953c
movl $0x8, %edi
callq 0x3f05
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0xf, %edi
callq 0x9431
testq %rax, %rax
je 0x7905
movq %rax, %rbx
callq 0x6f32
movq %rax, %r14
leaq 0x53bd(%rip), %rdi      # 0xcca9
callq 0x953c
movl $0x8, %edi
callq 0x3f05
movq %rbx, 0x10(%rax)
movq %r14, 0x20(%rax)
jmp 0x78c3
xorl %eax, %eax
jmp 0x78c3
// File: /workspace/github_c_makefile_star2_O1/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
movl $0xb, %edi
callq 0x9431
testq %rax, %rax
je 0x79a9
movq %rax, %rbx
leaq 0x3c95(%rip), %rdi      # 0xb5c4
callq 0x953c
callq 0x7ecc
movq %rax, %r14
testq %rax, %rax
jne 0x7949
callq 0x6f32
movq %rax, %r14
leaq 0x5359(%rip), %r15      # 0xcca9
movq %r15, %rdi
callq 0x953c
callq 0x6f32
movq %rax, %r12
movq %r15, %rdi
callq 0x953c
callq 0x6f32
movq %rax, %r13
leaq 0x4f02(%rip), %rdi      # 0xc879
callq 0x953c
callq 0x7a59
testq %rax, %rax
je 0x7a11
movq %rax, %r15
movl $0xe, %edi
callq 0x3f05
movq %rbx, 0x10(%rax)
movq %r14, 0x28(%rax)
movq %r12, 0x30(%rax)
movq %r13, 0x38(%rax)
jmp 0x79ff
movl $0x16, %edi
callq 0x9431
testq %rax, %rax
je 0x7a0d
movq %rax, %rbx
leaq 0x3c02(%rip), %rdi      # 0xb5c4
callq 0x953c
callq 0x6f32
testq %rax, %rax
je 0x7a29
movq %rax, %r14
leaq 0x4e9e(%rip), %rdi      # 0xc879
callq 0x953c
callq 0x7a59
testq %rax, %rax
je 0x7a41
movq %rax, %r15
movl $0xf, %edi
callq 0x3f05
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 0x7a03
leaq 0x4864(%rip), %rdi      # 0xc27c
leaq 0x47eb(%rip), %rsi      # 0xc20a
movl $0x134, %edx            # imm = 0x134
callq 0x4704
leaq 0x4851(%rip), %rdi      # 0xc281
leaq 0x47d3(%rip), %rsi      # 0xc20a
movl $0x141, %edx            # imm = 0x141
callq 0x4704
leaq 0x4834(%rip), %rdi      # 0xc27c
leaq 0x47bb(%rip), %rsi      # 0xc20a
movl $0x144, %edx            # imm = 0x144
callq 0x4704
// File: /workspace/github_c_makefile_star2_O1/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 0x7788
testq %rax, %rax
jne 0x7a82
callq 0x7884
testq %rax, %rax
jne 0x7a82
callq 0x77c3
testq %rax, %rax
jne 0x7a82
callq 0x7f29
testq %rax, %rax
je 0x7a84
popq %rcx
retq
popq %rax
jmp 0x7909
// File: /workspace/github_c_makefile_star2_O1/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
movl $0xc, %edi
callq 0x3f05
movq %rax, %rbx
leaq 0x33e6(%rip), %rdi      # 0xb1cf
callq 0x94f8
xorl %r14d, %r14d
testq %rax, %rax
je 0x7e15
leaq 0x33d2(%rip), %r15      # 0xb1cf
movq %r14, %rdi
callq 0x41f9
movq %rax, %r14
movq %r15, %rdi
callq 0x94f8
testq %rax, %rax
jne 0x7dfd
movq %r14, 0x18(%rbx)
callq 0x7c36
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq