LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x2, %edi
callq 0x3a70
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x10(%rbp), %rdi
callq 0xe630
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xb1d9
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xb1f1
leaq 0x6276(%rip), %rdi      # 0x11456
leaq 0x6266(%rip), %rsi      # 0x1144d
movl $0x2c, %edx
callq 0x4b20
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xbd90
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4f60
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
je 0xb261
leaq 0x6219(%rip), %rdi      # 0x11469
leaq 0x61f6(%rip), %rsi      # 0x1144d
movl $0x34, %edx
callq 0x4b20
movq -0x8(%rbp), %rdi
callq 0xddf0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xb27e
movq -0x8(%rbp), %rax
cmpl $0x19, (%rax)
je 0xb296
leaq 0x6202(%rip), %rdi      # 0x11487
leaq 0x61c1(%rip), %rsi      # 0x1144d
movl $0x36, %edx
callq 0x4b20
movq -0x8(%rbp), %rax
cmpq $0x0, 0xf0(%rax)
jne 0xb2bc
leaq 0x620c(%rip), %rdi      # 0x114b7
leaq 0x619b(%rip), %rsi      # 0x1144d
movl $0x37, %edx
callq 0x4b20
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rax
cmpq $0x0, 0x68(%rax)
jne 0xb2e6
leaq 0x6200(%rip), %rdi      # 0x114d5
leaq 0x6171(%rip), %rsi      # 0x1144d
movl $0x38, %edx
callq 0x4b20
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rax
movq 0x68(%rax), %rax
cmpl $0x6, (%rax)
je 0xb312
leaq 0x6206(%rip), %rdi      # 0x11507
leaq 0x6145(%rip), %rsi      # 0x1144d
movl $0x39, %edx
callq 0x4b20
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rax
movq 0x68(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x50b0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xb34c
jmp 0xb46b
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x18(%rbp)
movq 0x9c99(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
leaq 0x61e2(%rip), %rsi      # 0x1154b
movb $0x0, %al
callq 0x2100
movb $0x0, %al
callq 0x4e30
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4fe0
movl %eax, %ecx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
jge 0xb45f
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x5030
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0xa0(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x78(%rax), %rsi
callq 0xe9d0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0xb3e4
movq -0x40(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xb3fc
leaq 0x606b(%rip), %rdi      # 0x11456
leaq 0x605b(%rip), %rsi      # 0x1144d
movl $0x4b, %edx
callq 0x4b20
movq -0x40(%rbp), %rdi
callq 0xddf0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x20(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0xb480
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x80(%rax)
movq -0x38(%rbp), %rdi
callq 0x4190
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x98(%rax), %rsi
movq -0x30(%rbp), %rax
movq 0xa0(%rax), %rdx
callq 0x4f60
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xb382
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x68(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb54f
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0xb4fe
jmp 0xb541
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xb516
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0x12, (%rax)
je 0xb52e
leaq 0x608f(%rip), %rdi      # 0x115ac
leaq 0x60b3(%rip), %rsi      # 0x115d7
movl $0x15, %edx
callq 0x4b20
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl 0xa8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xb556
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xb4ec
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xb593
leaq 0x605e(%rip), %rdi      # 0x115e0
leaq 0x604e(%rip), %rsi      # 0x115d7
movl $0x1d, %edx
callq 0x4b20
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xb4e0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe040
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe040
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
subl $0x1, %eax
cltd
idivl -0x20(%rbp)
imull -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x3dd0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
xorl %edi, %edi
callq 0xb610
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xb670
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x20e0
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x993d(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x5f1b(%rip), %rsi      # 0x115e4
movb $0x0, %al
callq 0x2100
movq -0x18(%rbp), %rdi
callq 0x4190
movq 0x9918(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
leaq 0x4b99(%rip), %rsi      # 0x10283
movb $0x0, %al
callq 0x2100
cmpq $0x0, -0x8(%rbp)
jne 0xb710
leaq 0x5ee1(%rip), %rdi      # 0x115e0
leaq 0x5ed1(%rip), %rsi      # 0x115d7
movl $0x2d, %edx
callq 0x4b20
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x1, %edi
callq 0xb610
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xb670
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x989d(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x5e86(%rip), %rsi      # 0x115ef
movb $0x0, %al
callq 0x2100
movq -0x18(%rbp), %rdi
callq 0x4190
movq 0x9878(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
leaq 0x4af9(%rip), %rsi      # 0x10283
movb $0x0, %al
callq 0x2100
cmpq $0x0, -0x8(%rbp)
jne 0xb7b0
leaq 0x5e41(%rip), %rdi      # 0x115e0
leaq 0x5e31(%rip), %rsi      # 0x115d7
movl $0x36, %edx
callq 0x4b20
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x2, %edi
callq 0xb610
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xb670
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb836
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
je 0xb802
jmp 0xb828
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0xbdf0
cmpl $0x0, %eax
jne 0xb81a
jmp 0xb828
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xb83e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xb7f0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb8a6
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
je 0xb872
jmp 0xb898
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0xbdf0
cmpl $0x0, %eax
jne 0xb88a
jmp 0xb898
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xb8ae
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xb860
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb916
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0xb8e2
jmp 0xb908
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0xbdf0
cmpl $0x0, %eax
jne 0xb8fa
jmp 0xb908
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xb91e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xb8d0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb9e6
movq -0x10(%rbp), %rax
cmpl $0x3, (%rax)
je 0xb9b2
jmp 0xb9d8
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0xbdf0
cmpl $0x0, %eax
jne 0xb9ca
jmp 0xb9d8
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xb9ee
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xb9a0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xbab6
movq -0x10(%rbp), %rax
cmpl $0x4, (%rax)
je 0xba82
jmp 0xbaa8
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0xbdf0
cmpl $0x0, %eax
jne 0xba9a
jmp 0xbaa8
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xbabe
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xba70
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xbb03
leaq 0x5aee(%rip), %rdi      # 0x115e0
leaq 0x5ade(%rip), %rsi      # 0x115d7
movl $0x7a, %edx
callq 0x4b20
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x5, %edi
callq 0xb610
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xb670
movq -0x18(%rbp), %rdi
callq 0x4190
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xbb96
movq -0x10(%rbp), %rax
cmpl $0x5, (%rax)
je 0xbb62
jmp 0xbb88
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0xbdf0
cmpl $0x0, %eax
jne 0xbb7a
jmp 0xbb88
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xbb9e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xbb50
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl $0x1, %edi
callq 0x3a70
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x118(%rax)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x120(%rax)
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x108(%rax)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x128(%rax)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x130(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbbb0
testb $0x1, %al
jne 0xbce1
leaq 0x592a(%rip), %rdi      # 0x115fa
leaq 0x5937(%rip), %rsi      # 0x1160e
movl $0x15, %edx
callq 0x4b20
movl $0x1, %edi
callq 0x3a70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x138, %edx            # imm = 0x138
callq 0x2120
movq -0x10(%rbp), %rax
movq $0x0, 0x110(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xbd78
movq -0x8(%rbp), %rdi
callq 0xbcb0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq $0x110, %rax            # imm = 0x110
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xbd3c
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xbe85
jmp 0xbefe
movq -0x8(%rbp), %rdi
callq 0xbbb0
testb $0x1, %al
jne 0xbeaa
leaq 0x447f(%rip), %rdi      # 0x10318
leaq 0x576e(%rip), %rsi      # 0x1160e
movl $0x33, %edx
callq 0x4b20
cmpq $0x0, -0x8(%rbp)
je 0xbefe
movq -0x8(%rbp), %rax
cmpl $0x2, 0x108(%rax)
jne 0xbec0
jmp 0xbeed
movq 0x9131(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x120(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x118(%rax), %rcx
leaq 0x5730(%rip), %rsi      # 0x11616
movb $0x0, %al
callq 0x2100
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xbeaa
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xbf25
jmp 0xbf9e
movq -0x8(%rbp), %rdi
callq 0xbbb0
testb $0x1, %al
jne 0xbf4a
leaq 0x43df(%rip), %rdi      # 0x10318
leaq 0x56ce(%rip), %rsi      # 0x1160e
movl $0x3e, %edx
callq 0x4b20
cmpq $0x0, -0x8(%rbp)
je 0xbf9e
movq -0x8(%rbp), %rax
cmpl $0x2, 0x108(%rax)
jne 0xbf60
jmp 0xbf8d
movq 0x9069(%rip), %rax      # 0x14fd0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x120(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x118(%rax), %rcx
leaq 0x5690(%rip), %rsi      # 0x11616
movb $0x0, %al
callq 0x2100
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xbf4a
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/token.c
// Function: PrintTokenBrief
void PrintTokenBrief(struct Node *t) {
  assert(t);
  if (t->token_type == kTokenStringLiteral ||
      t->token_type == kTokenCharLiteral) {
    fprintf(stderr, "%.*s", t->length, t->begin);
    return;
  }
  fprintf(stderr, "<%.*s>", t->length, t->begin);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xc02b
leaq 0x54eb(%rip), %rdi      # 0x11505
leaq 0x55ed(%rip), %rsi      # 0x1160e
movl $0x4c, %edx
callq 0x4b20
movq -0x8(%rbp), %rax
cmpl $0x18, 0x108(%rax)
je 0xc045
movq -0x8(%rbp), %rax
cmpl $0x17, 0x108(%rax)
jne 0xc074
movq 0x8fac(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x120(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x118(%rax), %rcx
leaq 0x55ab(%rip), %rsi      # 0x11616
movb $0x0, %al
callq 0x2100
jmp 0xc0a1
movq 0x8f7d(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x120(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x118(%rax), %rcx
leaq 0x5596(%rip), %rsi      # 0x11630
movb $0x0, %al
callq 0x2100
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq 0x91a6(%rip), %rax      # 0x15378
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xc1f0
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xbbe0
testb $0x1, %al
jne 0xc1fa
movq $0x0, -0x8(%rbp)
jmp 0xc207
callq 0xc220
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x9115(%rip), %rax      # 0x15378
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xc283
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xbdf0
cmpl $0x0, %eax
jne 0xc28d
movq $0x0, -0x8(%rbp)
jmp 0xc29a
callq 0xc220
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x90b5(%rip), %rax      # 0x15378
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc2e3
movq -0x8(%rbp), %rsi
leaq 0x537f(%rip), %rdi      # 0x1165b
movb $0x0, %al
callq 0x4a40
movq -0x8(%rbp), %rdi
callq 0xc250
cmpq $0x0, %rax
jne 0xc308
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x5376(%rip), %rsi      # 0x11677
movb $0x0, %al
callq 0x4d50
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x9045(%rip), %rax      # 0x15378
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xc367
movq -0x18(%rbp), %rdi
movl $0x19, %esi
callq 0xbbe0
testb $0x1, %al
jne 0xc355
jmp 0xc367
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xbdf0
cmpl $0x0, %eax
jne 0xc371
movq $0x0, -0x8(%rbp)
jmp 0xc37e
callq 0xc220
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x8fd5(%rip), %rax      # 0x15378
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc3c3
movq -0x8(%rbp), %rsi
leaq 0x529f(%rip), %rdi      # 0x1165b
movb $0x0, %al
callq 0x4a40
movq -0x8(%rbp), %rdi
callq 0xc320
cmpq $0x0, %rax
jne 0xc3e8
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x5296(%rip), %rsi      # 0x11677
movb $0x0, %al
callq 0x4d50
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbbb0
testb $0x1, %al
jne 0xc4cb
jmp 0xc513
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x110(%rax)
je 0xc4f2
movq -0x10(%rbp), %rax
movq 0x110(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xc4d3
callq 0xc130
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x110(%rax)
movq -0x8(%rbp), %rcx
movq 0x8e68(%rip), %rax      # 0x15378
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/token.c
// Function: CreateStringLiteralOfTokens
static struct Node *CreateStringLiteralOfTokens(struct Node *head) {
  assert(IsToken(head));
  int len = 0;
  for (struct Node *t = head; t; t = t->next_token) {
    len += t->length;
  }
  char *s = malloc(len + 1 + 2);
  assert(s);
  char *p = s;
  *p = '"';
  p++;
  for (struct Node *t = head; t; t = t->next_token) {
    for (int i = 0; i < t->length; i++) {
      *p = t->begin[i];
      p++;
    }
  }
  *p = '"';
  p++;
  *p = 0;
  return AllocToken(s, 0, s, len + 2, kTokenStringLiteral);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbbb0
testb $0x1, %al
jne 0xc711
leaq 0x4f8e(%rip), %rdi      # 0x1168e
leaq 0x4f07(%rip), %rsi      # 0x1160e
movl $0xb7, %edx
callq 0x4b20
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xc748
movq -0x18(%rbp), %rax
movl 0x120(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq 0x110(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xc720
movl -0xc(%rbp), %eax
addl $0x1, %eax
addl $0x2, %eax
movslq %eax, %rdi
callq 0x2130
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xc77c
leaq 0x4be9(%rip), %rdi      # 0x11354
leaq 0x4e9c(%rip), %rsi      # 0x1160e
movl $0xbd, %edx
callq 0x4b20
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb $0x22, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xc7fe
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl 0x120(%rcx), %eax
jge 0xc7eb
movq -0x30(%rbp), %rax
movq 0x118(%rax), %rax
movslq -0x34(%rbp), %rcx
movb (%rax,%rcx), %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xc7ad
jmp 0xc7ed
movq -0x30(%rbp), %rax
movq 0x110(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xc79f
movq -0x28(%rbp), %rax
movb $0x22, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl -0xc(%rbp), %ecx
addl $0x2, %ecx
xorl %esi, %esi
movl $0x18, %r8d
callq 0xbc30
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc0f0
callq 0xc130
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc867
jmp 0xc884
movq -0x10(%rbp), %rdi
callq 0xc890
testb $0x1, %al
jne 0xc876
jmp 0xc87d
callq 0xc430
jmp 0xc855
callq 0xc220
jmp 0xc855
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
callq 0xc900
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xdbee
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x110, %rax            # imm = 0x110
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq 0x118(%rax), %rax
movq -0x28(%rbp), %rcx
movslq 0x120(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0xdb9b
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xdf9b
leaq 0x34fb(%rip), %rdi      # 0x11485
leaq 0x37bd(%rip), %rsi      # 0x1174e
movl $0x33, %edx
callq 0x4b20
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x3, %esi
callq 0xbbe0
testb $0x1, %al
jne 0xdfb3
jmp 0xdfd2
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x118(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2110
movl %eax, -0x4(%rbp)
jmp 0xe035
movq -0x10(%rbp), %rax
cmpl $0x4, (%rax)
jne 0xe01d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x218e(%rip), %rsi      # 0x10178
callq 0xbdf0
cmpl $0x0, %eax
je 0xe01d
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xdf70
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xdf70
movl %eax, %ecx
movl -0x14(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xe035
leaq 0x2033(%rip), %rdi      # 0x10057
leaq 0x3723(%rip), %rsi      # 0x1174e
movl $0x3a, %edx
callq 0x4b20
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xddf0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xe078
leaq 0x349e(%rip), %rdi      # 0x11505
leaq 0x36e0(%rip), %rsi      # 0x1174e
movl $0x3f, %edx
callq 0x4b20
movq -0x10(%rbp), %rax
cmpl $0x14, (%rax)
jne 0xe126
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xbbb0
testb $0x1, %al
jne 0xe0ae
leaq 0x3701(%rip), %rdi      # 0x1179e
leaq 0x36aa(%rip), %rsi      # 0x1174e
movl $0x41, %edx
callq 0x4b20
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x108(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x6, %eax
je 0xe0e9
jmp 0xe0c6
movl -0x14(%rbp), %eax
addl $-0xd, %eax
subl $0x2, %eax
jb 0xe0dd
jmp 0xe0d3
movl -0x14(%rbp), %eax
subl $0x15, %eax
je 0xe0f5
jmp 0xe101
movl $0x4, -0x4(%rbp)
jmp 0xe1e0
movl $0x1, -0x4(%rbp)
jmp 0xe1e0
movl $0x0, -0x4(%rbp)
jmp 0xe1e0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4190
leaq 0x1f42(%rip), %rdi      # 0x10057
leaq 0x3632(%rip), %rsi      # 0x1174e
movl $0x4c, %edx
callq 0x4b20
movq -0x10(%rbp), %rax
cmpl $0x16, (%rax)
jne 0xe13b
movl $0x8, -0x4(%rbp)
jmp 0xe1e0
movq -0x10(%rbp), %rax
cmpl $0x19, (%rax)
jne 0xe180
movq -0x10(%rbp), %rax
cmpq $0x0, 0xf0(%rax)
jne 0xe16b
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rdi
leaq 0x3649(%rip), %rsi      # 0x117ad
movb $0x0, %al
callq 0x4d50
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rdi
callq 0xaf80
movl %eax, -0x4(%rbp)
jmp 0xe1e0
movq -0x10(%rbp), %rax
cmpl $0x1a, (%rax)
jne 0xe1b9
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rdi
callq 0xe040
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rdi
callq 0xdf70
movl %eax, %ecx
movl -0x18(%rbp), %eax
imull %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xe1e0
jmp 0xe1bb
jmp 0xe1bd
jmp 0xe1bf
movq -0x10(%rbp), %rdi
callq 0x4190
leaq 0x1e88(%rip), %rdi      # 0x10057
leaq 0x3578(%rip), %rsi      # 0x1174e
movl $0x5a, %edx
callq 0x4b20
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xddf0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xe228
leaq 0x32ee(%rip), %rdi      # 0x11505
leaq 0x3530(%rip), %rsi      # 0x1174e
movl $0x5f, %edx
callq 0x4b20
movq -0x10(%rbp), %rax
cmpl $0x14, (%rax)
jne 0xe2a6
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xbbb0
testb $0x1, %al
jne 0xe25a
leaq 0x3555(%rip), %rdi      # 0x1179e
leaq 0x34fe(%rip), %rsi      # 0x1174e
movl $0x61, %edx
callq 0x4b20
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x108(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x6, %eax
je 0xe285
jmp 0xe272
movl -0x14(%rbp), %eax
subl $0xd, %eax
jne 0xe28e
jmp 0xe27c
movl $0x4, -0x4(%rbp)
jmp 0xe2fb
movl $0x1, -0x4(%rbp)
jmp 0xe2fb
leaq 0x1dc2(%rip), %rdi      # 0x10057
leaq 0x34b2(%rip), %rsi      # 0x1174e
movl $0x68, %edx
callq 0x4b20
movq -0x10(%rbp), %rax
cmpl $0x16, (%rax)
jne 0xe2b8
movl $0x8, -0x4(%rbp)
jmp 0xe2fb
movq -0x10(%rbp), %rax
cmpl $0x19, (%rax)
jne 0xe2d6
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rdi
callq 0xb060
movl %eax, -0x4(%rbp)
jmp 0xe2fb
jmp 0xe2d8
jmp 0xe2da
movq -0x10(%rbp), %rdi
callq 0x4190
leaq 0x1d6d(%rip), %rdi      # 0x10057
leaq 0x345d(%rip), %rsi      # 0x1174e
movl $0x70, %edx
callq 0x4b20
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x5f15(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x2c35(%rip), %rsi      # 0x11d26
movb $0x0, %al
callq 0x2100
movq -0x8(%rbp), %rdi
callq 0xdb70
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x9f60
callq 0x9e30
movq %rax, %rdi
callq 0xe630
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
andb $0x1, %al
movb %al, 0x13(%rsp)
movq 0x18(%rsp), %rdi
callq 0x6d70
movl %eax, 0xc(%rsp)
testb $0x1, 0x13(%rsp)
jne 0x1309
movl 0xc(%rsp), %eax
cmpl 0x14(%rsp), %eax
je 0x1307
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
movl 0x14(%rsp), %ecx
movl 0xc(%rsp), %r8d
leaq 0x8d1f(%rip), %rsi      # 0xa018
movb $0x0, %al
callq 0x73a0
movb $0x0, 0x37(%rsp)
jmp 0x1342
jmp 0x133d
movl 0xc(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x133b
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
movl 0x14(%rsp), %ecx
movl 0xc(%rsp), %r8d
leaq 0x8d17(%rip), %rsi      # 0xa044
movb $0x0, %al
callq 0x73a0
movb $0x0, 0x37(%rsp)
jmp 0x1342
jmp 0x133d
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
cmpq %rax, 0x28(%rsp)
jne 0x2528
movabsq $0x7ffc000000000002, %rax # imm = 0x7FFC000000000002
movq %rax, 0x40(%rsp)
jmp 0x2615
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x8120
movq %rax, 0x20(%rsp)
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
movq %rax, 0x18(%rsp)
movabsq $0x3ffffffffffff, %rdi  # imm = 0x3FFFFFFFFFFFF
andq 0x20(%rsp), %rdi
callq 0x4d10
movq %rax, 0x8(%rsp)
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
cmpq %rax, 0x8(%rsp)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2586
jmp 0x2606
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movb $0x1, %al
testb $0x1, %al
jne 0x25a6
jmp 0x25e7
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
cmpq %rax, 0x18(%rsp)
je 0x25dd
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4d30
testb $0x1, %al
jne 0x25db
movabsq $0x7ffc000000000003, %rax # imm = 0x7FFC000000000003
movq %rax, 0x40(%rsp)
jmp 0x2615
jmp 0x25dd
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x25e9
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x2569
movabsq $0x7ffc000000000002, %rax # imm = 0x7FFC000000000002
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
cmpq %rax, 0x28(%rsp)
jne 0x2658
movabsq $0x7ffc000000000002, %rax # imm = 0x7FFC000000000002
movq %rax, 0x40(%rsp)
jmp 0x2745
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x8120
movq %rax, 0x20(%rsp)
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
movq %rax, 0x18(%rsp)
movabsq $0x3ffffffffffff, %rdi  # imm = 0x3FFFFFFFFFFFF
andq 0x20(%rsp), %rdi
callq 0x4d10
movq %rax, 0x8(%rsp)
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
cmpq %rax, 0x8(%rsp)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x26b6
jmp 0x2736
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movb $0x1, %al
testb $0x1, %al
jne 0x26d6
jmp 0x2717
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
cmpq %rax, 0x18(%rsp)
je 0x270d
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x7060
testb $0x1, %al
jne 0x270b
movabsq $0x7ffc000000000003, %rax # imm = 0x7FFC000000000003
movq %rax, 0x40(%rsp)
jmp 0x2745
jmp 0x270d
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x2719
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x2699
movabsq $0x7ffc000000000002, %rax # imm = 0x7FFC000000000002
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x6f64(%rip), %rsi      # 0xa138
movl $0x2, %ecx
movl $0x1, %r8d
callq 0x12a0
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x18(%rsp), %rax
movq 0x10(%rax), %rdx
callq 0x85b0
movq %rax, 0x10(%rsp)
movabsq $0x7ffc000000000003, %rax # imm = 0x7FFC000000000003
cmpq %rax, 0x10(%rsp)
je 0x326e
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
cmpq %rax, 0x10(%rsp)
je 0x326e
movabsq $0x3ffffffffffff, %rcx  # imm = 0x3FFFFFFFFFFFF
andq 0x18(%rsp), %rcx
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x18(%rcx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x85b0
movq %rax, 0x30(%rsp)
jmp 0x32e9
movabsq $0x3ffffffffffff, %rcx  # imm = 0x3FFFFFFFFFFFF
andq 0x18(%rsp), %rcx
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x18(%rcx), %rax
movabsq $0x7ffc000000000001, %rcx # imm = 0x7FFC000000000001
cmpq %rcx, 0x18(%rax)
jne 0x32ac
movabsq $0x7ffc000000000003, %rax # imm = 0x7FFC000000000003
movq %rax, 0x30(%rsp)
jmp 0x32e9
movabsq $0x3ffffffffffff, %rcx  # imm = 0x3FFFFFFFFFFFF
andq 0x18(%rsp), %rcx
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x18(%rcx), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq (%rsp), %rdx
callq 0x8960
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)