LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/preprocessor.c
// Function: PreprocessRemoveBlock
static void PreprocessRemoveBlock(void) {
  for (struct Node *t = PeekToken(); t; t = t->next_token) {
    if (!IsEqualTokenWithCStr(t, "#")) {
      continue;
    }
    t = SkipDelimiterTokensInLogicalLine(t->next_token);
    if (!IsEqualTokenWithCStr(t, "endif") && !IsEqualTokenWithCStr(t, "else")) {
      continue;
    }
    RemoveTokensTo(t);
    break;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x89d5
movq %rax, %r15
leaq 0x4413(%rip), %rbx      # 0xc307
leaq 0x44f5(%rip), %r14      # 0xc3f0
leaq 0x44e9(%rip), %r12      # 0xc3eb
testq %r15, %r15
je 0x7f5f
movq %r15, %rdi
movq %rbx, %rsi
callq 0x87de
testl %eax, %eax
je 0x7f43
movq 0x110(%r15), %rdi
callq 0x7e22
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x87de
testl %eax, %eax
jne 0x7f4c
movq %r15, %rdi
movq %r12, %rsi
callq 0x87de
testl %eax, %eax
jne 0x7f4c
movq 0x110(%r15), %r15
jmp 0x7f02
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8ba6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/struct.c
// Function: CalcStructSizeFromDict
static int CalcStructSizeFromDict(struct Node *dict) {
  if (!GetSizeOfList(dict)) return 0;
  struct Node *last_kv = GetNodeAt(dict, GetSizeOfList(dict) - 1);
  struct Node *last_member = last_kv->value;
  return last_member->struct_member_ent_ofs +
         GetSizeOfType(last_member->struct_member_ent_type);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x3fb7
testl %eax, %eax
je 0x7fcd
movq %rbx, %rdi
callq 0x3fb7
leal -0x1(%rax), %esi
movq %rbx, %rdi
callq 0x3fdf
movq 0xa0(%rax), %rax
movl 0x80(%rax), %ebx
movq 0x70(%rax), %rdi
callq 0x9672
addl %ebx, %eax
jmp 0x7fcf
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/struct.c
// Function: AddMemberOfStructFromDecl
void AddMemberOfStructFromDecl(struct Node *struct_spec, struct Node *decl) {
  struct Node *struct_member = AllocNode(kNodeStructMember);
  struct_member->struct_member_decl = decl;
  struct Node *type = CreateTypeFromDecl(decl);
  assert(type && type->left);
  const char *name = CreateTokenStr(type->left);
  struct Node *dict = struct_spec->struct_member_dict;
  PushKeyValueToList(dict, name, struct_member);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x2
popq %rdi
callq 0x319d
movq %rax, %r14
movq %r15, 0x78(%rax)
movq %r15, %rdi
callq 0x9aa3
testq %rax, %rax
je 0x80b4
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x80b4
callq 0x87a7
movq 0x68(%rbx), %rdi
movq %rax, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x3f58
leaq 0x442a(%rip), %rdi      # 0xc4e5
leaq 0x441a(%rip), %rsi      # 0xc4dc
pushq $0x2c
popq %rdx
callq 0x3cc4
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/struct.c
// Function: FindStructMember
struct Node *FindStructMember(struct Node *struct_type,
                              struct Node *key_token) {
  assert(key_token->type == kNodeToken);
  struct_type = GetTypeWithoutAttr(struct_type);
  assert(struct_type && struct_type->type == kTypeStruct);
  assert(struct_type->type_struct_spec);
  assert(struct_type->type_struct_spec->struct_member_dict);
  assert(struct_type->type_struct_spec->struct_member_dict->type == kASTList);
  return GetNodeByTokenKey(struct_type->type_struct_spec->struct_member_dict,
                           key_token);
}

// Assembly:
pushq %rbx
cmpl $0x1, (%rsi)
jne 0x8117
movq %rsi, %rbx
callq 0x9554
testq %rax, %rax
je 0x8105
cmpl $0x19, (%rax)
jne 0x8105
movq 0xf0(%rax), %rax
testq %rax, %rax
je 0x8129
movq 0x68(%rax), %rdi
testq %rdi, %rdi
je 0x813b
cmpl $0x6, (%rdi)
jne 0x814d
movq %rbx, %rsi
popq %rbx
jmp 0x4035
leaq 0x440a(%rip), %rdi      # 0xc516
leaq 0x43c9(%rip), %rsi      # 0xc4dc
pushq $0x36
jmp 0x815d
leaq 0x43da(%rip), %rdi      # 0xc4f8
leaq 0x43b7(%rip), %rsi      # 0xc4dc
pushq $0x34
jmp 0x815d
leaq 0x4416(%rip), %rdi      # 0xc546
leaq 0x43a5(%rip), %rsi      # 0xc4dc
pushq $0x37
jmp 0x815d
leaq 0x4422(%rip), %rdi      # 0xc564
leaq 0x4393(%rip), %rsi      # 0xc4dc
pushq $0x38
jmp 0x815d
leaq 0x4442(%rip), %rdi      # 0xc596
leaq 0x4381(%rip), %rsi      # 0xc4dc
pushq $0x39
popq %rdx
callq 0x3cc4
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/struct.c
// Function: ResolveTypesOfMembersOfStruct
void ResolveTypesOfMembersOfStruct(struct SymbolEntry *ctx, struct Node *spec) {
  if (!spec) {
    // Skip resolving members since it is incomplete.
    return;
  }
  struct Node *dict = spec->struct_member_dict;
  fprintf(stderr, "Resolving types of struct...\n");
  struct Node *resolved_dict = AllocList();
  for (int i = 0; i < GetSizeOfList(dict); i++) {
    struct Node *kv = GetNodeAt(dict, i);
    struct Node *member_info = kv->value;
    struct Node *type =
        CreateTypeFromDeclInContext(ctx, member_info->struct_member_decl);
    assert(type && type->left);
    member_info->struct_member_ent_type = GetTypeWithoutAttr(type);
    member_info->struct_member_ent_ofs =
        CalcNextMemberOffset(resolved_dict, type);
    PrintASTNode(member_info);
    PushKeyValueToList(resolved_dict, kv->key, kv->value);
  }
  spec->struct_member_dict = resolved_dict;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
jne 0x8185
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
movq 0x68(%rsi), %rbx
movq 0x8e60(%rip), %rax      # 0x10ff8
movq (%rax), %rcx
leaq 0x4438(%rip), %rdi      # 0xc5da
pushq $0x1d
popq %rsi
pushq $0x1
popq %rdx
callq 0x21b0
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x3ea7
movq %rax, %rbp
movq %rbx, 0x10(%rsp)
movq %rbx, %rdi
callq 0x3fb7
cmpl %eax, %r15d
jge 0x8282
movq %rbx, %rdi
movl %r15d, %r12d
movl %r15d, %esi
callq 0x3fdf
movq %rax, %r13
movq 0xa0(%rax), %rbx
movq 0x78(%rbx), %rsi
movq %r14, %r15
movq %r14, %rdi
callq 0x9d3b
testq %rax, %rax
je 0x8290
movq %rax, %r14
cmpq $0x0, 0x18(%rax)
je 0x8290
movq %r14, %rdi
callq 0x9554
movq %rax, 0x70(%rbx)
movq %rbp, %rdi
callq 0x3fb7
testl %eax, %eax
je 0x8249
movq %r14, %rdi
callq 0x978f
movl %eax, %r14d
movq %rbp, %rdi
callq 0x7f93
leal (%rax,%r14), %ecx
decl %ecx
movl %ecx, %eax
cltd
idivl %r14d
subl %edx, %ecx
jmp 0x824b
xorl %ecx, %ecx
movq %r15, %r14
movl %ecx, 0x80(%rbx)
movq %rbx, %rdi
callq 0x3598
movq 0x98(%r13), %rsi
movq 0xa0(%r13), %rdx
movq %rbp, %rdi
callq 0x3f58
movl %r12d, %r15d
incl %r15d
movq 0x10(%rsp), %rbx
jmp 0x81bf
movq 0x8(%rsp), %rax
movq %rbp, 0x68(%rax)
jmp 0x8176
leaq 0x424e(%rip), %rdi      # 0xc4e5
leaq 0x423e(%rip), %rsi      # 0xc4dc
pushq $0x4b
popq %rdx
callq 0x3cc4
nop
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/symbol.c
// Function: GetLastLocalVarOffset
int GetLastLocalVarOffset(struct SymbolEntry *e) {
  for (; e; e = e->prev) {
    if (e->type != kSymbolLocalVar) continue;
    assert(e->value && e->value->type == kASTLocalVar);
    return e->value->byte_offset;
  }
  return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x82b9
cmpl $0x0, (%rdi)
je 0x82bd
movq 0x8(%rdi), %rdi
jmp 0x82a9
xorl %eax, %eax
jmp 0x82d1
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x82d3
cmpl $0x12, (%rax)
jne 0x82d3
movl 0xa8(%rax), %eax
popq %rcx
retq
leaq 0x4361(%rip), %rdi      # 0xc63b
leaq 0x4385(%rip), %rsi      # 0xc666
pushq $0x15
popq %rdx
callq 0x3cc4
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/symbol.c
// Function: AddLocalVar
struct Node *AddLocalVar(struct SymbolEntry **ctx, const char *key,
                         struct Node *var_type) {
  assert(ctx);
  int ofs = GetLastLocalVarOffset(*ctx);
  ofs += GetSizeOfType(var_type);
  int align = GetSizeOfType(var_type);
  ofs = (ofs + align - 1) / align * align;
  struct Node *local_var = CreateASTLocalVar(ofs, var_type);
  struct SymbolEntry *e = AllocSymbolEntry(kSymbolLocalVar, key, local_var);
  PushSymbol(ctx, e);
  return local_var;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x835c
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x82a8
movl %eax, %ebp
movq %r15, %rdi
callq 0x9672
movl %eax, %r12d
addl %ebp, %r12d
movq %r15, %rdi
callq 0x9672
movl %eax, %ecx
leal (%rcx,%r12), %edi
decl %edi
movl %edi, %eax
cltd
idivl %ecx
subl %edx, %edi
movq %r15, %rsi
callq 0x33a1
movq %rax, %r15
xorl %edi, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8372
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rbx)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x430c(%rip), %rdi      # 0xc66f
leaq 0x42fc(%rip), %rsi      # 0xc666
pushq $0x1d
popq %rdx
callq 0x3cc4
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/symbol.c
// Function: AllocSymbolEntry
static struct SymbolEntry *AllocSymbolEntry(enum SymbolType type,
                                            const char *key,
                                            struct Node *value) {
  struct SymbolEntry *e = calloc(1, sizeof(struct SymbolEntry));
  e->type = type;
  e->key = key;
  e->value = value;
  return e;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0x20f0
movl %ebp, (%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/symbol.c
// Function: AddGlobalVar
void AddGlobalVar(struct SymbolEntry **ctx, const char *key,
                  struct Node *var_type) {
  fprintf(stderr, "Gvar: %s: ", key);
  PrintASTNode(var_type);
  fprintf(stderr, "\n");
  assert(ctx);
  struct SymbolEntry *e = AllocSymbolEntry(kSymbolGlobalVar, key, var_type);
  PushSymbol(ctx, e);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8c48(%rip), %r12      # 0x10ff8
movq (%r12), %rdi
leaq 0x42b8(%rip), %rsi      # 0xc673
movq %r15, %rdx
xorl %eax, %eax
callq 0x2110
movq %r14, %rdi
callq 0x3598
movq (%r12), %rsi
pushq $0xa
popq %rdi
callq 0x20d0
testq %rbx, %rbx
je 0x8402
pushq $0x1
popq %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x8372
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4266(%rip), %rdi      # 0xc66f
leaq 0x4256(%rip), %rsi      # 0xc666
pushq $0x2d
popq %rdx
callq 0x3cc4
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/symbol.c
// Function: AddExternVar
void AddExternVar(struct SymbolEntry **ctx, const char *key,
                  struct Node *var_type) {
  fprintf(stderr, "Evar: %s: ", key);
  PrintASTNode(var_type);
  fprintf(stderr, "\n");
  assert(ctx);
  struct SymbolEntry *e = AllocSymbolEntry(kSymbolExternVar, key, var_type);
  PushSymbol(ctx, e);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8bc8(%rip), %r12      # 0x10ff8
movq (%r12), %rdi
leaq 0x4243(%rip), %rsi      # 0xc67e
movq %r15, %rdx
xorl %eax, %eax
callq 0x2110
movq %r14, %rdi
callq 0x3598
movq (%r12), %rsi
pushq $0xa
popq %rdi
callq 0x20d0
testq %rbx, %rbx
je 0x8482
pushq $0x2
popq %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x8372
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x41e6(%rip), %rdi      # 0xc66f
leaq 0x41d6(%rip), %rsi      # 0xc666
pushq $0x36
popq %rdx
callq 0x3cc4
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/symbol.c
// Function: FindExternVar
struct Node *FindExternVar(struct SymbolEntry *e, struct Node *key_token) {
  // returns ASTNode which represents Type
  for (; e; e = e->prev) {
    if (e->type != kSymbolExternVar) continue;
    if (!IsEqualTokenWithCStr(key_token, e->key)) continue;
    return e->value;
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %ebx, %ebx
testq %r14, %r14
je 0x84ca
cmpl $0x2, (%r14)
jne 0x84c0
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x87de
testl %eax, %eax
jne 0x84c6
movq 0x8(%r14), %r14
jmp 0x84a5
movq 0x18(%r14), %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/symbol.c
// Function: FindGlobalVar
struct Node *FindGlobalVar(struct SymbolEntry *e, struct Node *key_token) {
  // returns ASTNode which represents Type
  for (; e; e = e->prev) {
    if (e->type != kSymbolGlobalVar) continue;
    if (!IsEqualTokenWithCStr(key_token, e->key)) continue;
    return e->value;
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %ebx, %ebx
testq %r14, %r14
je 0x8505
cmpl $0x1, (%r14)
jne 0x84fb
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x87de
testl %eax, %eax
jne 0x8501
movq 0x8(%r14), %r14
jmp 0x84e0
movq 0x18(%r14), %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/symbol.c
// Function: FindLocalVar
struct Node *FindLocalVar(struct SymbolEntry *e, struct Node *key_token) {
  for (; e; e = e->prev) {
    if (e->type != kSymbolLocalVar) continue;
    if (!IsEqualTokenWithCStr(key_token, e->key)) continue;
    return e->value;
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %ebx, %ebx
testq %r14, %r14
je 0x8540
cmpl $0x0, (%r14)
jne 0x8536
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x87de
testl %eax, %eax
jne 0x853c
movq 0x8(%r14), %r14
jmp 0x851b
movq 0x18(%r14), %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/symbol.c
// Function: FindFuncDef
struct Node *FindFuncDef(struct SymbolEntry *e, struct Node *key_token) {
  for (; e; e = e->prev) {
    if (e->type != kSymbolFuncDef) continue;
    if (!IsEqualTokenWithCStr(key_token, e->key)) continue;
    return e->value;
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %ebx, %ebx
testq %r14, %r14
je 0x85ae
cmpl $0x3, (%r14)
jne 0x85a4
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x87de
testl %eax, %eax
jne 0x85aa
movq 0x8(%r14), %r14
jmp 0x8589
movq 0x18(%r14), %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/symbol.c
// Function: FindFuncDeclType
struct Node *FindFuncDeclType(struct SymbolEntry *e, struct Node *key_token) {
  for (; e; e = e->prev) {
    if (e->type != kSymbolFuncDeclType) continue;
    if (!IsEqualTokenWithCStr(key_token, e->key)) continue;
    return e->value;
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %ebx, %ebx
testq %r14, %r14
je 0x861c
cmpl $0x4, (%r14)
jne 0x8612
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x87de
testl %eax, %eax
jne 0x8618
movq 0x8(%r14), %r14
jmp 0x85f7
movq 0x18(%r14), %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/symbol.c
// Function: AddStructType
void AddStructType(struct SymbolEntry **ctx, const char *key,
                   struct Node *type) {
  assert(ctx);
  struct SymbolEntry *e = AllocSymbolEntry(kSymbolStructType, key, type);
  PushSymbol(ctx, e);
  PrintASTNode(type);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8655
movq %rdx, %rbx
movq %rdi, %r14
pushq $0x5
popq %rdi
callq 0x8372
movq (%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3598
leaq 0x4013(%rip), %rdi      # 0xc66f
leaq 0x4003(%rip), %rsi      # 0xc666
pushq $0x7a
popq %rdx
callq 0x3cc4
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/symbol.c
// Function: FindStructType
struct Node *FindStructType(struct SymbolEntry *e, struct Node *key_token) {
  for (; e; e = e->prev) {
    if (e->type != kSymbolStructType) continue;
    if (!IsEqualTokenWithCStr(key_token, e->key)) continue;
    return e->value;
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %ebx, %ebx
testq %r14, %r14
je 0x869d
cmpl $0x5, (%r14)
jne 0x8693
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x87de
testl %eax, %eax
jne 0x8699
movq 0x8(%r14), %r14
jmp 0x8678
movq 0x18(%r14), %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/token.c
// Function: AllocToken
struct Node *AllocToken(const char *src_str, int line, const char *begin,
                        int length, enum TokenType type) {
  struct Node *t = AllocNode(kNodeToken);
  t->begin = begin;
  t->length = length;
  t->token_type = type;
  t->src_str = src_str;
  t->line = line;
  return t;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
pushq $0x1
popq %rdi
callq 0x319d
movq %r14, 0x118(%rax)
movl %ebp, 0x120(%rax)
movl %ebx, 0x108(%rax)
movq %r12, 0x128(%rax)
movl %r15d, 0x130(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/token.c
// Function: DuplicateToken
struct Node *DuplicateToken(struct Node *base_token) {
  assert(IsToken(base_token));
  struct Node *t = AllocNode(kNodeToken);
  memcpy(t, base_token, sizeof(*t));
  t->next_token = NULL;
  return t;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8755
movq %rdi, %rbx
cmpl $0x1, (%rdi)
jne 0x8755
pushq $0x1
popq %rdi
callq 0x319d
movq %rax, %r14
movl $0x138, %edx            # imm = 0x138
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2130
andq $0x0, 0x110(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3f2d(%rip), %rdi      # 0xc689
leaq 0x3f3a(%rip), %rsi      # 0xc69d
pushq $0x15
popq %rdx
callq 0x3cc4
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/token.c
// Function: DuplicateTokenSequence
struct Node *DuplicateTokenSequence(struct Node *base_head) {
  struct Node *dup_head = NULL;
  struct Node **dup_head_holder = &dup_head;
  while (base_head) {
    *dup_head_holder = DuplicateToken(base_head);
    dup_head_holder = &(*dup_head_holder)->next_token;
    base_head = base_head->next_token;
  }
  return dup_head;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
andq $0x0, (%r14)
testq %rbx, %rbx
je 0x879b
movq %rbx, %rdi
callq 0x8716
movq %rax, (%r14)
addq $0x110, %rax            # imm = 0x110
movq 0x110(%rbx), %rbx
movq %rax, %r14
jmp 0x8779
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/token.c
// Function: PrintTokenSequence
void PrintTokenSequence(struct Node *t) {
  if (!t) return;
  assert(IsToken(t));
  for (; t; t = t->next_token) {
    if (t->token_type == kTokenZeroWidthNoBreakSpace) {
      continue;
    }
    fprintf(stderr, "%.*s", t->length, t->begin);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x887d
movq %rdi, %rbx
cmpl $0x1, (%rdi)
jne 0x8883
movq 0x87b5(%rip), %r15      # 0x10ff8
leaq 0x3e5b(%rip), %r14      # 0xc6a5
testq %rbx, %rbx
je 0x887d
cmpl $0x2, 0x108(%rbx)
jne 0x8861
movq 0x110(%rbx), %rbx
jmp 0x884a
movq (%r15), %rdi
movl 0x120(%rbx), %edx
movq 0x118(%rbx), %rcx
movq %r14, %rsi
xorl %eax, %eax
callq 0x2110
jmp 0x8858
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2b22(%rip), %rdi      # 0xb3ac
leaq 0x3e0c(%rip), %rsi      # 0xc69d
pushq $0x33
popq %rdx
callq 0x3cc4
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/token.c
// Function: OutputTokenSequenceAsCSource
void OutputTokenSequenceAsCSource(struct Node *t) {
  if (!t) return;
  assert(IsToken(t));
  for (; t; t = t->next_token) {
    if (t->token_type == kTokenZeroWidthNoBreakSpace) {
      continue;
    }
    fprintf(stdout, "%.*s", t->length, t->begin);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x88ea
movq %rdi, %rbx
cmpl $0x1, (%rdi)
jne 0x88f0
movq 0x871e(%rip), %r15      # 0x10fd0
leaq 0x3dec(%rip), %r14      # 0xc6a5
testq %rbx, %rbx
je 0x88ea
cmpl $0x2, 0x108(%rbx)
je 0x88e1
movq (%r15), %rdi
movl 0x120(%rbx), %edx
movq 0x118(%rbx), %rcx
movq %r14, %rsi
xorl %eax, %eax
callq 0x2110
movq 0x110(%rbx), %rbx
jmp 0x88b9
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2ab5(%rip), %rdi      # 0xb3ac
leaq 0x3d9f(%rip), %rsi      # 0xc69d
pushq $0x3e
popq %rdx
callq 0x3cc4
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/token.c
// Function: ConsumeToken
struct Node *ConsumeToken(enum TokenType type) {
  struct Node *t = *next_token_holder;
  if (!t || !IsTokenWithType(t, type)) return NULL;
  AdvanceTokenStream();
  return t;
}

// Assembly:
movq 0x8961(%rip), %rax      # 0x11388
movq (%rax), %rax
testq %rax, %rax
je 0x8a4b
cmpl $0x1, (%rax)
jne 0x8a4b
cmpl %edi, 0x108(%rax)
jne 0x8a4b
leaq 0x110(%rax), %rcx
movq %rcx, 0x893e(%rip)      # 0x11388
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/token.c
// Function: ConsumeTokenStr
struct Node *ConsumeTokenStr(const char *s) {
  struct Node *t = *next_token_holder;
  if (!t || !IsEqualTokenWithCStr(t, s)) return NULL;
  AdvanceTokenStream();
  return t;
}

// Assembly:
pushq %rbx
movq 0x8932(%rip), %rax      # 0x11388
movq (%rax), %rbx
testq %rbx, %rbx
je 0x8a7d
movq %rdi, %rsi
movq %rbx, %rdi
callq 0x87de
testl %eax, %eax
je 0x8a7d
leaq 0x110(%rbx), %rax
movq %rax, 0x890d(%rip)      # 0x11388
jmp 0x8a7f
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/token.c
// Function: ExpectTokenStr
struct Node *ExpectTokenStr(const char *s) {
  struct Node *t = *next_token_holder;
  if (!t) Error("Expect token %s but got EOF", s);
  if (!ConsumeTokenStr(s)) ErrorWithToken(t, "Expected token %s here", s);
  return t;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x88f6(%rip), %rax      # 0x11388
movq (%rax), %r14
testq %r14, %r14
je 0x8ab2
movq %rbx, %rdi
callq 0x8a4e
testq %rax, %rax
je 0x8ac3
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3c31(%rip), %rdi      # 0xc6ea
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3bf8
leaq 0x3c3c(%rip), %rsi      # 0xc706
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3de9
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/token.c
// Function: ConsumePunctuator
struct Node *ConsumePunctuator(const char *s) {
  struct Node *t = *next_token_holder;
  if (!t || !IsTokenWithType(t, kTokenPunctuator) ||
      !IsEqualTokenWithCStr(t, s))
    return NULL;
  AdvanceTokenStream();
  return t;
}

// Assembly:
pushq %rbx
movq 0x88a9(%rip), %rax      # 0x11388
movq (%rax), %rbx
testq %rbx, %rbx
je 0x8b14
cmpl $0x1, (%rbx)
jne 0x8b14
cmpl $0x19, 0x108(%rbx)
jne 0x8b14
movq %rdi, %rsi
movq %rbx, %rdi
callq 0x87de
testl %eax, %eax
je 0x8b14
leaq 0x110(%rbx), %rax
movq %rax, 0x8876(%rip)      # 0x11388
jmp 0x8b16
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/token.c
// Function: ExpectPunctuator
struct Node *ExpectPunctuator(const char *s) {
  struct Node *t = *next_token_holder;
  if (!t) Error("Expect token %s but got EOF", s);
  if (!ConsumePunctuator(s)) ErrorWithToken(t, "Expected token %s here", s);
  return t;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x885f(%rip), %rax      # 0x11388
movq (%rax), %r14
testq %r14, %r14
je 0x8b49
movq %rbx, %rdi
callq 0x8ad7
testq %rax, %rax
je 0x8b5a
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3b9a(%rip), %rdi      # 0xc6ea
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3bf8
leaq 0x3ba5(%rip), %rsi      # 0xc706
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3de9
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/token.c
// Function: InsertTokens
void InsertTokens(struct Node *seq_first) {
  // Insert token sequece (seq) at current cursor pos.
  if (!IsToken(seq_first)) return;
  struct Node *seq_last = seq_first;
  while (seq_last->next_token) seq_last = seq_last->next_token;
  seq_last->next_token = PeekToken();
  *next_token_holder = seq_first;
}

// Assembly:
testq %rdi, %rdi
je 0x8c07
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x1, (%rdi)
jne 0x8c00
movq %rbx, %rax
movq %rax, %r14
movq 0x110(%rax), %rax
testq %rax, %rax
jne 0x8bdb
callq 0x89d5
movq %rax, 0x110(%r14)
movq 0x878b(%rip), %rax      # 0x11388
movq %rbx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/token.c
// Function: RemoveDelimiterTokens
struct Node **RemoveDelimiterTokens(struct Node **head_holder) {
  InitTokenStream(head_holder);
  for (;;) {
    struct Node *t = PeekToken();
    if (!t) break;
    if (ShouldRemoveToken(t)) {
      RemoveCurrentToken();
      continue;
    }
    AdvanceTokenStream();
  }
  return head_holder;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x89b1
callq 0x89d5
testq %rax, %rax
je 0x8e3f
movl 0x108(%rax), %edx
decl %edx
movq 0x8576(%rip), %rcx      # 0x11388
movq (%rcx), %rax
cmpl $0x1, %edx
ja 0x8e2b
testq %rax, %rax
je 0x8df9
movq 0x110(%rax), %rax
movq %rax, (%rcx)
jmp 0x8df9
testq %rax, %rax
je 0x8df9
addq $0x110, %rax            # imm = 0x110
movq %rax, 0x854b(%rip)      # 0x11388
jmp 0x8df9
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/tokenizer.c
// Function: Tokenize
struct Node *Tokenize(const char *input) {
  // returns head of tokens.
  struct Node *token_head = NULL;
  struct Node **last_next_token = &token_head;
  const char *p = input;
  struct Node *t;
  int line = 1;
  while ((t = CreateNextToken(p, input, &line))) {
    *last_next_token = t;
    last_next_token = &t->next_token;
    p = t->begin + t->length;
  }
  return token_head;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsp, %r15
andq $0x0, (%r15)
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
movl $0x1, (%r14)
movq %rbx, %rsi
movq %r14, %rdx
callq 0x8e5a
testq %rax, %rax
je 0x941c
movq %rax, (%r15)
movq %rax, %r15
addq $0x110, %r15            # imm = 0x110
movslq 0x120(%rax), %rdi
addq 0x118(%rax), %rdi
jmp 0x93ef
movq (%rsp), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/type.c
// Function: IsSameTypeExceptAttr
int IsSameTypeExceptAttr(struct Node *a, struct Node *b) {
  assert(a && b);
  a = GetTypeWithoutAttr(a);
  b = GetTypeWithoutAttr(b);
  if (a->type != b->type) return 0;
  if (a->type == kTypeBase) {
    assert(a->op && b->op);
    return a->op->type == b->op->type;
  } else if (a->type == kTypePointer) {
    return IsSameTypeExceptAttr(a->right, b->right);
  } else if (a->type == kTypeFunction) {
    if (!IsSameTypeExceptAttr(a->left, b->left)) return 0;
    if (GetSizeOfList(a->right) != GetSizeOfList(b->right)) return 0;
    for (int i = 0; i < GetSizeOfList(a->right); i++) {
      if (!IsSameTypeExceptAttr(GetNodeAt(a->right, i), GetNodeAt(b->right, i)))
        return 0;
    }
    return 1;
  }
  Error("IsSameTypeExceptAttr: Comparing non-type nodes");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
je 0x951e
testq %rbx, %rbx
je 0x951e
callq 0x9554
movq %rax, %r15
movq %rbx, %rdi
callq 0x9554
movq %rax, %r14
movl (%r15), %eax
xorl %ebx, %ebx
cmpl (%r14), %eax
jne 0x9513
cmpl $0x16, %eax
jne 0x9479
movq 0x20(%r15), %rdi
movq 0x20(%r14), %rbx
jmp 0x9437
cmpl $0x17, %eax
je 0x94ac
cmpl $0x14, %eax
jne 0x9534
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x9542
movq 0x10(%r14), %rcx
testq %rcx, %rcx
je 0x9542
movl (%rax), %eax
xorl %ebx, %ebx
cmpl (%rcx), %eax
sete %bl
jmp 0x9513
movq 0x18(%r15), %rdi
movq 0x18(%r14), %rsi
callq 0x942c
testl %eax, %eax
je 0x9513
movq 0x20(%r15), %rdi
callq 0x3fb7
movl %eax, %ebp
movq 0x20(%r14), %rdi
callq 0x3fb7
cmpl %eax, %ebp
jne 0x9513
xorl %ebp, %ebp
pushq $0x1
popq %rbx
movq 0x20(%r15), %rdi
callq 0x3fb7
cmpl %eax, %ebp
jge 0x9513
movq 0x20(%r15), %rdi
movl %ebp, %esi
callq 0x3fdf
movq %rax, %r12
movq 0x20(%r14), %rdi
movl %ebp, %esi
callq 0x3fdf
movq %r12, %rdi
movq %rax, %rsi
callq 0x942c
incl %ebp
testl %eax, %eax
jne 0x94da
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x336f(%rip), %rdi      # 0xc894
leaq 0x336f(%rip), %rsi      # 0xc89b
pushq $0x4
popq %rdx
callq 0x3cc4
leaq 0x3376(%rip), %rdi      # 0xc8b1
xorl %eax, %eax
callq 0x3bf8
leaq 0x3359(%rip), %rdi      # 0xc8a2
leaq 0x334b(%rip), %rsi      # 0xc89b
pushq $0x9
jmp 0x952e
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/type.c
// Function: EvalExprAsInt
int EvalExprAsInt(struct Node *n) {
  assert(n);
  if (IsTokenWithType(n->op, kTokenIntegerConstant)) {
    return strtol(n->op->begin, NULL, 0);
  }
  if (n->type == kASTExpr && IsEqualTokenWithCStr(n->op, "+")) {
    return EvalExprAsInt(n->left) + EvalExprAsInt(n->right);
  }
  assert(false);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
pushq $0x3
popq %rbp
leaq 0x1bbb(%rip), %r14      # 0xb1a8
testq %rbx, %rbx
je 0x965c
movq 0x10(%rbx), %rdi
movl %ebp, %esi
callq 0x86b7
testb %al, %al
jne 0x9628
cmpl $0x4, (%rbx)
jne 0x964a
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x87de
testl %eax, %eax
je 0x964a
movq 0x18(%rbx), %rdi
callq 0x95d6
movq 0x20(%rbx), %rbx
addl %eax, %r15d
jmp 0x95ed
movq 0x10(%rbx), %rax
movq 0x118(%rax), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2120
addl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a36(%rip), %rdi      # 0xb087
leaq 0x3243(%rip), %rsi      # 0xc89b
pushq $0x3a
jmp 0x966c
leaq 0x2eb1(%rip), %rdi      # 0xc514
leaq 0x3231(%rip), %rsi      # 0xc89b
pushq $0x33
popq %rdx
callq 0x3cc4
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/type.c
// Function: GetSizeOfType
int GetSizeOfType(struct Node *t) {
  t = GetTypeWithoutAttr(t);
  assert(t);
  if (t->type == kTypeBase) {
    assert(IsToken(t->op));
    switch (t->op->token_type) {
      case kTokenKwInt:
      case kTokenKwLong:
        return 4;
      case kTokenKwChar:
        return 1;
      case kTokenKwVoid:
        return 0;
      default:
        PrintASTNode(t->op);
        assert(false);
    }
  } else if (t->type == kTypePointer) {
    return 8;
  } else if (t->type == kTypeStruct) {
    if (!t->type_struct_spec) {
      ErrorWithToken(t->tag, "Cannot take sizeof incomplete struct");
    }
    return CalcStructSize(t->type_struct_spec);
  } else if (t->type == kTypeArray) {
    return GetSizeOfType(t->type_array_type_of) *
           EvalExprAsInt(t->type_array_index_decl);
  }
  PrintASTNode(t);
  assert(false);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
callq 0x9554
testq %rax, %rax
je 0x9721
movq %rax, %rbx
movl (%rax), %eax
addl $-0x14, %eax
cmpl $0x6, %eax
ja 0x9737
leaq 0x31dd(%rip), %rcx      # 0xc878
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rbx), %rdi
callq 0x86a8
testb %al, %al
je 0x9766
movq 0x10(%rbx), %rdi
movl 0x108(%rdi), %eax
leal -0xd(%rax), %ecx
cmpl $0x2, %ecx
jb 0x9713
cmpl $0x15, %eax
je 0x971d
cmpl $0x6, %eax
jne 0x9778
pushq $0x1
jmp 0x9715
movq 0xf0(%rbx), %rdi
testq %rdi, %rdi
je 0x9751
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7f6c
movq 0xf8(%rbx), %rdi
callq 0x9672
movl %eax, %ebp
movq 0x100(%rbx), %rdi
callq 0x95d6
imull %ebp, %eax
jmp 0x9716
pushq $0x8
jmp 0x9715
pushq $0x4
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %eax, %eax
jmp 0x9716
leaq 0x2e6c(%rip), %rdi      # 0xc594
leaq 0x316c(%rip), %rsi      # 0xc89b
pushq $0x3f
popq %rdx
callq 0x3cc4
movq %rbx, %rdi
callq 0x3598
leaq 0x1941(%rip), %rdi      # 0xb087
leaq 0x314e(%rip), %rsi      # 0xc89b
pushq $0x5a
jmp 0x9731
movq 0xe8(%rbx), %rdi
leaq 0x319b(%rip), %rsi      # 0xc8fa
xorl %eax, %eax
callq 0x3de9
leaq 0x317e(%rip), %rdi      # 0xc8eb
leaq 0x3127(%rip), %rsi      # 0xc89b
pushq $0x41
jmp 0x9731
callq 0x3598
leaq 0x1903(%rip), %rdi      # 0xb087
leaq 0x3110(%rip), %rsi      # 0xc89b
pushq $0x4c
jmp 0x9731
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/type.c
// Function: GetAlignOfType
int GetAlignOfType(struct Node *t) {
  t = GetTypeWithoutAttr(t);
  assert(t);
  if (t->type == kTypeBase) {
    assert(IsToken(t->op));
    switch (t->op->token_type) {
      case kTokenKwInt:
        return 4;
      case kTokenKwChar:
        return 1;
      default:
        assert(false);
    }
  } else if (t->type == kTypePointer) {
    return 8;
  } else if (t->type == kTypeStruct) {
    return CalcStructAlign(t->type_struct_spec);
  }
  PrintASTNode(t);
  assert(false);
}

// Assembly:
pushq %rbx
callq 0x9554
testq %rax, %rax
je 0x97e9
movq %rax, %rbx
movl (%rax), %eax
cmpl $0x19, %eax
je 0x97d7
cmpl $0x16, %eax
je 0x97d3
cmpl $0x14, %eax
jne 0x97fb
movq 0x10(%rbx), %rdi
callq 0x86a8
testb %al, %al
je 0x9815
movq 0x10(%rbx), %rax
movl 0x108(%rax), %eax
cmpl $0xd, %eax
je 0x97e4
cmpl $0x6, %eax
jne 0x9827
pushq $0x1
jmp 0x97e6
pushq $0x8
jmp 0x97e6
movq 0xf0(%rbx), %rdi
popq %rbx
jmp 0x7fd1
pushq $0x4
popq %rax
popq %rbx
retq
leaq 0x2da4(%rip), %rdi      # 0xc594
leaq 0x30a4(%rip), %rsi      # 0xc89b
pushq $0x5f
jmp 0x9837
movq %rbx, %rdi
callq 0x3598
leaq 0x187d(%rip), %rdi      # 0xb087
leaq 0x308a(%rip), %rsi      # 0xc89b
pushq $0x70
jmp 0x9837
leaq 0x30cf(%rip), %rdi      # 0xc8eb
leaq 0x3078(%rip), %rsi      # 0xc89b
pushq $0x61
jmp 0x9837
leaq 0x1859(%rip), %rdi      # 0xb087
leaq 0x3066(%rip), %rsi      # 0xc89b
pushq $0x68
popq %rdx
callq 0x3cc4
// File: /workspace/github_c_makefile_star2_O2/hikalium[P]compilium/type.c
// Function: CreateTypeFromInput
static struct Node *CreateTypeFromInput(const char *s) {
  fprintf(stderr, "CreateTypeFromInput: %s\n", s);
  struct Node *tokens = Tokenize(s);
  InitParser(&tokens);
  return CreateTypeFromDecl(ParseDecl());
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x6c31(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x2a98(%rip), %rsi      # 0xce69
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2110
movq %rbx, %rdi
callq 0x93d0
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x7413
callq 0x7374
movq %rax, %rdi
callq 0x9aa3
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/core.c
// Function: arity_check
bool arity_check(vm_t *vm, const char *fn_name, value_t args, int n,
                 bool at_least) {
    int argc = cons_len(args);
    if (!at_least) {  // exactly
        if (argc != n) {
            error_runtime(vm, "%s: not enough args: %d expected, %d given!",
                          fn_name, n, argc);
            return false;
        }
    } else {  // at least
        if (argc < n) {
            error_runtime(vm, "%s: not enough args: >= %d expected, %d given!",
                          fn_name, n, argc);
            return false;
        }
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x4378
testl %ebp, %ebp
je 0x12fa
movb $0x1, %bpl
cmpl %ebx, %eax
jge 0x131c
leaq 0x4d44(%rip), %rsi      # 0x603c
jmp 0x1308
movb $0x1, %bpl
cmpl %ebx, %eax
je 0x131c
leaq 0x4d08(%rip), %rsi      # 0x6010
xorl %ebp, %ebp
movq %r15, %rdi
movq %r14, %rdx
movl %ebx, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x45ec
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/core.c
// Function: eq
static value_t eq(vm_t *vm, env_t *env, value_t args) {
    if (IS_NIL(args)) {
        return TRUE_VAL;
    }
    value_t eargs = eval_list(vm, env, args);
    value_t prev = NIL_VAL;
    value_t arg, iter;
    SCM_FOREACH (arg, AS_CONS(eargs), iter) {
        if (!IS_NIL(prev)) {
            // if we find a pair where the 'eq?' relation doesn't hold,
            // return false
            if (!val_eq(prev, arg)) {
                return FALSE_VAL;
            }
        }
        prev = arg;
    }
    return TRUE_VAL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movabsq $0x7ffc000000000001, %r14 # imm = 0x7FFC000000000001
leaq 0x1(%r14), %rbx
cmpq %r14, %rdx
je 0x1ebc
callq 0x4cbf
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
orq %rax, %rcx
movabsq $0x3ffffffffffff, %rdx  # imm = 0x3FFFFFFFFFFFF
leaq 0x2(%r14), %rax
movq %r14, %rsi
cmpq %r14, %rcx
je 0x1ebc
andq %rdx, %rcx
movq 0x10(%rcx), %rdi
cmpq %r14, %rsi
sete %r8b
cmpq %rdi, %rsi
sete %sil
orb %r8b, %sil
cmpb $0x1, %sil
jne 0x1eb9
movq 0x18(%rcx), %rcx
movq %rdi, %rsi
jmp 0x1e8d
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/core.c
// Function: equal
static value_t equal(vm_t *vm, env_t *env, value_t args) {
    if (IS_NIL(args)) {
        return TRUE_VAL;
    }
    value_t eargs = eval_list(vm, env, args);
    value_t prev = NIL_VAL;
    value_t arg, iter;
    SCM_FOREACH (arg, AS_CONS(eargs), iter) {
        if (!IS_NIL(prev)) {
            // if we find a pair where the 'equal?' relation doesn't hold,
            // return false
            if (!val_equal(prev, arg)) {
                return FALSE_VAL;
            }
        }
        prev = arg;
    }
    return TRUE_VAL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movabsq $0x7ffc000000000001, %r15 # imm = 0x7FFC000000000001
leaq 0x1(%r15), %rbx
cmpq %r15, %rdx
je 0x1f33
callq 0x4cbf
movabsq $-0x4000000000000, %r12 # imm = 0xFFFC000000000000
orq %rax, %r12
movabsq $0x3ffffffffffff, %rbp  # imm = 0x3FFFFFFFFFFFF
leaq 0x2(%r15), %r13
movq %r15, %rdi
cmpq %r15, %r12
je 0x1f33
andq %rbp, %r12
movq 0x10(%r12), %r14
cmpq %r15, %rdi
je 0x1f26
movq %r14, %rsi
callq 0x447f
testb %al, %al
je 0x1f30
movq 0x18(%r12), %r12
movq %r14, %rdi
jmp 0x1f08
movq %r13, %rbx
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/jiribenes[P]scheme/src/core.c
// Function: builtin_define
static value_t builtin_define(vm_t *vm, env_t *env, value_t args) {
    cons_t *rest = AS_CONS(args);

    if (IS_SYMBOL(rest->car)) {  // (define <name> <body>)
        symbol_t *sym = AS_SYMBOL(rest->car);
        value_t body = AS_CONS(rest->cdr)->car;
        value_t val = eval(vm, env, body);

        if (IS_FUNCTION(val)) {
            // If <body> is a nameless function, set its name to <name>
            // (we won't do any renaming...)
            function_t *func = AS_FUNCTION(val);
            if (func->name == NULL) {
                func->name = sym;
            }
        }
        variable_add(vm, env, sym, val);

        return VOID_VAL;
    } else if (IS_CONS(rest->car)) {  // (define (<name> <params...>) <body...>)
        symbol_t *sym = AS_SYMBOL(AS_CONS(rest->car)->car);
        value_t params = AS_CONS(rest->car)->cdr;
        cons_t *body = AS_CONS(rest->cdr);

        function_t *func = function_new(vm, env, params, PTR_VAL(body));
        func->name = sym;

        variable_add(vm, env, sym, PTR_VAL(func));

        return VOID_VAL;
    } else {
        error_runtime(vm, "define: is wrong - first argument has to be"
                          "either a list or a symbol!");
        return NIL_VAL;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movabsq $0x7ffc000000000005, %rbx # imm = 0x7FFC000000000005
movabsq $0x3ffffffffffff, %r12  # imm = 0x3FFFFFFFFFFFF
andq %r12, %rdx
movq 0x10(%rdx), %r13
movq %r13, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x238d
movq %rsi, %r15
movabsq $-0x4000000000001, %rbp # imm = 0xFFFBFFFFFFFFFFFF
andq %r12, %r13
movl (%r13), %eax
testl %eax, %eax
je 0x23a4
cmpl $0x2, %eax
jne 0x238d
movq 0x18(%rdx), %rax
andq %r12, %rax
movq 0x10(%rax), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4ebe
cmpq %rbp, %rax
jbe 0x237f
movq %rax, %rcx
andq %r12, %rcx
cmpl $0x4, (%rcx)
jne 0x237f
cmpq $0x0, 0x10(%rcx)
jne 0x237f
movq %r13, 0x10(%rcx)
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %rax, %rcx
jmp 0x23d7
leaq 0x3f8f(%rip), %rsi      # 0x6323
movq %r14, %rdi
xorl %eax, %eax
callq 0x45ec
addq $-0x4, %rbx
jmp 0x23dc
andq 0x10(%r13), %r12
movq 0x18(%r13), %rax
incq %rbp
movq 0x18(%rdx), %rcx
orq %rbp, %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x41a0
movq %r12, 0x10(%rax)
orq %rax, %rbp
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbp, %rcx
callq 0x4a76
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/jiribenes[P]scheme/src/core.c
// Function: lambda
static value_t lambda(vm_t *vm, env_t *env, value_t args) {
    // (lambda (<params...>) <body...>)

    if (IS_NIL(AS_CONS(args)->car)) {
        // no parameters -> (lambda () <body...>)
        value_t body = AS_CONS(args)->cdr;
        function_t *func = function_new(vm, env, NIL_VAL, body);
        return PTR_VAL(func);
    }

    if (IS_SYMBOL(AS_CONS(args)->car)) {
        // variadic -> (lambda param <body...>)
        value_t param = AS_CONS(args)->car;
        value_t body = AS_CONS(args)->cdr;
        function_t *func = function_new(vm, env, param, body);
        return PTR_VAL(func);
    }

    // TODO: Rewrite using SCM_FOREACH macro
    for (cons_t *cons = AS_CONS(AS_CONS(args)->car);;
         cons = AS_CONS(cons->cdr)) {
        if (!IS_CONS(cons->cdr) && !IS_NIL(cons->cdr) && IS_SYMBOL(cons->cdr)) {
            // variadic (lambda (a b . rest) <body...>)
            break;
        }

        if (!IS_SYMBOL(cons->car)) {
            error_runtime(vm, "lambda: all parameters must be symbols!");
            return NIL_VAL;
        }


        if (IS_NIL(cons->cdr)) {
            break;
        }
    }

    value_t params = AS_CONS(args)->car;
    value_t body = AS_CONS(args)->cdr;
    function_t *func = function_new(vm, env, params, body);
    return PTR_VAL(func);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movabsq $-0x4000000000001, %r14 # imm = 0xFFFBFFFFFFFFFFFF
movabsq $0x7ffc000000000001, %rbx # imm = 0x7FFC000000000001
movabsq $0x3ffffffffffff, %rcx  # imm = 0x3FFFFFFFFFFFF
andq %rcx, %rdx
movq 0x10(%rdx), %rax
cmpq %rbx, %rax
jne 0x2425
movq 0x18(%rdx), %rcx
movq %rbx, %rdx
jmp 0x2475
movq %rax, %r8
cmpq %r14, %rax
jbe 0x243c
movq %rax, %r8
andq %rcx, %r8
cmpl $0x2, (%r8)
movq %rax, %r8
je 0x246e
movq %r8, %r9
andq %rcx, %r9
movq 0x18(%r9), %r8
cmpq %r14, %r8
jbe 0x2457
movq %r8, %r10
andq %rcx, %r10
cmpl $0x2, (%r10)
je 0x246e
movq 0x10(%r9), %r9
cmpq %r14, %r9
jbe 0x2485
andq %rcx, %r9
cmpl $0x2, (%r9)
jne 0x2485
cmpq %rbx, %r8
jne 0x243c
movq 0x18(%rdx), %rcx
movq %rax, %rdx
callq 0x41a0
incq %r14
orq %rax, %r14
movq %r14, %rbx
jmp 0x2493
leaq 0x3edd(%rip), %rsi      # 0x6369
xorl %eax, %eax
callq 0x45ec
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/core.c
// Function: builtin_if
static value_t builtin_if(vm_t *vm, env_t *env, value_t args) {
    arity_check(vm, "if", args, 2, true);

    // First evaluate <condition>
    value_t condition = eval(vm, env, AS_CONS(args)->car);

    // if it's true, return <then>
    if (AS_BOOL(condition)) {
        value_t then = AS_CONS(AS_CONS(args)->cdr)->car;
        return eval(vm, env, then);
    }

    // If missing <otherwise> and <condition> is false, return false
    if (IS_NIL(AS_CONS(AS_CONS(args)->cdr)->cdr)) {
        return FALSE_VAL;
    }

    // Else do <otherwise>
    value_t otherwise = AS_CONS(AS_CONS(args)->cdr)->cdr;
    return begin(vm, env, otherwise);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0x7ffc000000000001, %r15 # imm = 0x7FFC000000000001
leaq 0x3c6f(%rip), %rsi      # 0x6130
pushq $0x2
popq %rcx
pushq $0x1
popq %r8
callq 0x12cc
movabsq $0x3ffffffffffff, %r13  # imm = 0x3FFFFFFFFFFFF
andq %r13, %r12
movq 0x10(%r12), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4ebe
andq $-0x3, %rax
andq 0x18(%r12), %r13
cmpq %r15, %rax
jne 0x2512
movq 0x18(%r13), %rdx
cmpq %r15, %rdx
jne 0x252a
addq $0x2, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x10(%r13), %rdx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4ebe
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x5086
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/core.c
// Function: builtin_set
static value_t builtin_set(vm_t *vm, env_t *env, value_t args) {
    // (set! <sym> <expr>)
    arity_check(vm, "set!", args, 2, false);
    value_t arg = AS_CONS(args)->car;
    if (!IS_SYMBOL(arg)) {
        error_runtime(vm, "set!: first argument must be a symbol!");
        return NIL_VAL;
    }

    symbol_t *sym = AS_SYMBOL(arg);

    arg = AS_CONS(AS_CONS(args)->cdr)->car;
    value_t val = eval(vm, env, arg);
    value_t result = find_replace(env, sym, val);

    if (IS_UNDEFINED(result)) {
        error_runtime(vm, "set!: assignment not allowed - %s is undefined!",
                      sym->name);
    }

    return VOID_VAL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r14
movabsq $0x7ffc000000000005, %rbx # imm = 0x7FFC000000000005
movabsq $0x3ffffffffffff, %rbp  # imm = 0x3FFFFFFFFFFFF
leaq 0x3c52(%rip), %rsi      # 0x61bf
pushq $0x2
popq %rcx
xorl %r8d, %r8d
callq 0x12cc
andq %rbp, %r13
movq 0x10(%r13), %r15
movq %r15, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x25da
andq %rbp, %r15
cmpl $0x2, (%r15)
jne 0x25da
andq 0x18(%r13), %rbp
movq 0x10(%rbp), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x4ebe
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x4e36
leaq -0x1(%rbx), %rcx
cmpq %rcx, %rax
jne 0x25ef
addq $0x20, %r15
leaq 0x3ded(%rip), %rsi      # 0x63b8
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x45ec
jmp 0x25ef
leaq 0x3db0(%rip), %rsi      # 0x6391
movq %r14, %rdi
xorl %eax, %eax
callq 0x45ec
addq $-0x4, %rbx
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/jiribenes[P]scheme/src/core.c
// Function: builtin_write
static value_t builtin_write(vm_t *vm, env_t *env, value_t args) {
    value_t eargs = eval_list(vm, env, args);
    arity_check(vm, "write", eargs, 1, false);
    write(stdout, AS_CONS(eargs)->car);
    return VOID_VAL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4cbf
movq %rax, %r14
leaq 0x391d(%rip), %rsi      # 0x6137
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %rax, %rdx
xorl %r8d, %r8d
callq 0x12cc
movq 0x779e(%rip), %rax      # 0x9fd0
movq (%rax), %rdi
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %r14, %rax
movq 0x10(%rax), %rsi
callq 0x524c
movabsq $0x7ffc000000000005, %rax # imm = 0x7FFC000000000005
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/core.c
// Function: builtin_display
static value_t builtin_display(vm_t *vm, env_t *env, value_t args) {
    value_t eargs = eval_list(vm, env, args);
    arity_check(vm, "display", eargs, 1, false);
    display(stdout, AS_CONS(eargs)->car);
    return VOID_VAL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4cbf
movq %rax, %r14
leaq 0x38ca(%rip), %rsi      # 0x613d
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %rax, %rdx
xorl %r8d, %r8d
callq 0x12cc
movq 0x7745(%rip), %rax      # 0x9fd0
movq (%rax), %rdi
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %r14, %rax
movq 0x10(%rax), %rsi
callq 0x5642
movabsq $0x7ffc000000000005, %rax # imm = 0x7FFC000000000005
addq $0x8, %rsp
popq %rbx
popq %r14
retq