LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/src/aib.c
// Function: main
int main()
{
    vl_uint32 nrows = 10;
    vl_uint32 ncols = 3;
    double Pic[3*10] = {
    0.6813,    0.3028,    0.8216,
    0.3795,    0.5417,    0.6449,
    0.8318,    0.1509,    0.8180,
    0.5028,    0.6979,    0.6602,
    0.7095,    0.3784,    0.3420,
    0.4289,    0.8600,    0.2897,
    0.3046,    0.8537,    0.3412,
    0.1897,    0.5936,    0.5341,
    0.1934,    0.4966,    0.7271,
    0.6822,    0.8998,    0.3093,
    };

    vl_uint32 r,c;
    VlAIB * aib;
    vl_uint * parents;

    printf("Pic = [");
    for(r=0; r<nrows; r++)
    {
        for(c=0; c<ncols; c++)
            printf("%f ", Pic[r*ncols+c]);
        printf("; ...\n");
    }
    printf("];\n");

    printf("AIB starting\n");
    {
      aib = vl_aib_new(Pic, nrows, ncols);
      vl_aib_process(aib);

      /*  parents always has size 2*nrows-1 */
      parents = vl_aib_get_parents(aib);
      for(r=0; r<2*nrows-1; r++)
        printf("%d => %d\n", r, parents[r]);

      vl_aib_delete(aib);
    }
    /* free(Pic); */

    printf("IB done\n");
    return 0;
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movl $0x0, 0x124(%rsp)
movl $0xa, 0x120(%rsp)
movl $0x3, 0x11c(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0xe5c(%rip), %rsi       # 0x2010
movl $0xf0, %edx
callq 0x1070
leaq 0xf3b(%rip), %rdi       # 0x2100
movb $0x0, %al
callq 0x1040
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x120(%rsp), %eax
jae 0x1244
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x11c(%rsp), %eax
jae 0x1229
movl 0x1c(%rsp), %eax
imull 0x11c(%rsp), %eax
addl 0x18(%rsp), %eax
movl %eax, %eax
movsd 0x20(%rsp,%rax,8), %xmm0
leaq 0xef3(%rip), %rdi       # 0x2108
movb $0x1, %al
callq 0x1040
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x11e9
leaq 0xedc(%rip), %rdi       # 0x210c
movb $0x0, %al
callq 0x1040
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x11d4
leaq 0xec8(%rip), %rdi       # 0x2113
movb $0x0, %al
callq 0x1040
leaq 0xebe(%rip), %rdi       # 0x2117
movb $0x0, %al
callq 0x1040
leaq 0x20(%rsp), %rdi
movl 0x120(%rsp), %esi
movl 0x11c(%rsp), %edx
callq 0x1050
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1030
movq 0x10(%rsp), %rdi
callq 0x1300
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl 0x120(%rsp), %ecx
shll %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x12dd
movl 0x1c(%rsp), %esi
movq 0x8(%rsp), %rax
movl 0x1c(%rsp), %ecx
movl (%rax,%rcx,4), %edx
leaq 0xe5c(%rip), %rdi       # 0x2125
movb $0x0, %al
callq 0x1040
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x129e
movq 0x10(%rsp), %rdi
callq 0x1060
leaq 0xe41(%rip), %rdi       # 0x212f
movb $0x0, %al
callq 0x1040
xorl %eax, %eax
addq $0x128, %rsp            # imm = 0x128
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/analyzer.c
// Function: Analyze
struct SymbolEntry *Analyze(struct Node *ast) {
  // Returns root context of symbols (including global vars)
  struct SymbolEntry *root_ctx = NULL;
  in_function = NULL;
  AnalyzeNode(ast, &root_ctx);
  return root_ctx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, 0x12fe1(%rip) # 0x152b0
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x22f0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/analyzer.c
// Function: AllocReg
static void AllocReg(struct Node *n) {
  assert(n);
  for (int i = 1; i <= NUM_OF_SCRATCH_REGS; i++) {
    if (!reg_used_table[i]) {
      reg_used_table[i] = 1;
      reg_node_table[i] = n;
      n->reg = i;
      return;
    }
  }
  fprintf(stderr, "\n**** Allocated regs ****\n");
  for (int i = 1; i <= NUM_OF_SCRATCH_REGS; i++) {
    fprintf(stderr, "reg[%d]:\n", i);
    if (reg_node_table[i]->op) {
      PrintTokenLine(reg_node_table[i]->op);
    } else {
      fprintf(stderr, "Op info not found\n");
    }
  }
  fprintf(stderr, "\n**** Tried to allocate reg for ****\n");
  PrintASTNode(n);
  ErrorWithToken(n->op, "No free registers found");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x380b
leaq 0xdc8b(%rip), %rdi      # 0x11485
leaq 0xc808(%rip), %rsi      # 0x10009
movl $0x8, %edx
callq 0x4b20
movl $0x1, -0xc(%rbp)
cmpl $0xa, -0xc(%rbp)
jg 0x386b
movslq -0xc(%rbp), %rcx
leaq 0x11a9d(%rip), %rax     # 0x152c0
cmpl $0x0, (%rax,%rcx,4)
jne 0x385e
movslq -0xc(%rbp), %rcx
leaq 0x11a8c(%rip), %rax     # 0x152c0
movl $0x1, (%rax,%rcx,4)
movq -0x8(%rbp), %rdx
movslq -0xc(%rbp), %rcx
leaq 0x11aa6(%rip), %rax     # 0x152f0
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
addq $0x10, %rsp
popq %rbp
retq
jmp 0x3860
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3812
movq 0x11786(%rip), %rax     # 0x14ff8
movq (%rax), %rdi
leaq 0xc9ab(%rip), %rsi      # 0x10227
movb $0x0, %al
callq 0x2100
movl $0x1, -0x10(%rbp)
cmpl $0xa, -0x10(%rbp)
jg 0x3900
movq 0x11761(%rip), %rax     # 0x14ff8
movq (%rax), %rdi
movl -0x10(%rbp), %edx
leaq 0xc99e(%rip), %rsi      # 0x10242
movb $0x0, %al
callq 0x2100
movslq -0x10(%rbp), %rcx
leaq 0x11a3a(%rip), %rax     # 0x152f0
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x10(%rax)
je 0x38db
movslq -0x10(%rbp), %rcx
leaq 0x11a24(%rip), %rax     # 0x152f0
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rdi
callq 0x4b50
jmp 0x38f3
movq 0x11716(%rip), %rax     # 0x14ff8
movq (%rax), %rdi
leaq 0xc960(%rip), %rsi      # 0x1024c
movb $0x0, %al
callq 0x2100
jmp 0x38f5
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x388a
movq 0x116f1(%rip), %rax     # 0x14ff8
movq (%rax), %rdi
leaq 0xc94e(%rip), %rsi      # 0x1025f
movb $0x0, %al
callq 0x2100
movq -0x8(%rbp), %rdi
callq 0x4190
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0xc955(%rip), %rsi      # 0x10285
movb $0x0, %al
callq 0x4d50
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/ast.c
// Function: CreateASTBinOp
struct Node *CreateASTBinOp(struct Node *t, struct Node *left,
                            struct Node *right) {
  if (!right) ErrorWithToken(t, "Expected expression after binary operator");
  struct Node *op = AllocNode(kASTExpr);
  op->op = t;
  op->left = left;
  op->right = right;
  return op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3add
movq -0x8(%rbp), %rdi
leaq 0xc7ee(%rip), %rsi      # 0x102c4
movb $0x0, %al
callq 0x4d50
movl $0x4, %edi
callq 0x3a70
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/ast.c
// Function: CreateASTUnaryPrefixOp
struct Node *CreateASTUnaryPrefixOp(struct Node *t, struct Node *right) {
  if (!right) ErrorWithToken(t, "Expected expression after prefix operator");
  struct Node *op = AllocNode(kASTExpr);
  op->op = t;
  op->right = right;
  return op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3b49
movq -0x8(%rbp), %rdi
leaq 0xc7ac(%rip), %rsi      # 0x102ee
movb $0x0, %al
callq 0x4d50
movl $0x4, %edi
callq 0x3a70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/ast.c
// Function: CreateASTUnaryPostfixOp
struct Node *CreateASTUnaryPostfixOp(struct Node *left, struct Node *t) {
  assert(IsToken(t));
  if (!left) ErrorWithToken(t, "Expected expression before prefix operator");
  struct Node *op = AllocNode(kASTExpr);
  op->op = t;
  op->left = left;
  return op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbbb0
testb $0x1, %al
jne 0x3bb5
leaq 0xc774(%rip), %rdi      # 0x10318
leaq 0xc778(%rip), %rsi      # 0x10323
movl $0x27, %edx
callq 0x4b20
cmpq $0x0, -0x8(%rbp)
jne 0x3bce
movq -0x10(%rbp), %rdi
leaq 0xc762(%rip), %rsi      # 0x10329
movb $0x0, %al
callq 0x4d50
movl $0x4, %edi
callq 0x3a70
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/ast.c
// Function: CreateASTFuncDef
struct Node *CreateASTFuncDef(struct Node *func_decl, struct Node *func_body) {
  assert(func_decl && func_decl->type == kASTDecl);
  assert(IsASTList(func_body));
  struct Node *n = AllocNode(kASTFuncDef);
  n->func_body = func_body;
  struct Node *type = CreateTypeFromDecl(func_decl);
  assert(type);
  n->func_name_token = type->left;
  assert(IsToken(n->func_name_token));
  n->func_type = GetTypeWithoutAttr(type);
  assert(n->func_type && n->func_type->type == kTypeFunction);
  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3c60
movq -0x8(%rbp), %rax
cmpl $0xd, (%rax)
je 0x3c78
leaq 0xc6ed(%rip), %rdi      # 0x10354
leaq 0xc6b5(%rip), %rsi      # 0x10323
movl $0x37, %edx
callq 0x4b20
movq -0x10(%rbp), %rdi
callq 0x39a0
testb $0x1, %al
jne 0x3c9d
leaq 0xc6f1(%rip), %rdi      # 0x1037d
leaq 0xc690(%rip), %rsi      # 0x10323
movl $0x38, %edx
callq 0x4b20
movl $0x10, %edi
callq 0x3a70
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xd0(%rax)
movq -0x8(%rbp), %rdi
callq 0xe630
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3ce6
leaq 0xc351(%rip), %rdi      # 0x10026
leaq 0xc647(%rip), %rsi      # 0x10323
movl $0x3c, %edx
callq 0x4b20
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xe0(%rax)
movq -0x18(%rbp), %rax
movq 0xe0(%rax), %rdi
callq 0xbbb0
testb $0x1, %al
jne 0x3d25
leaq 0xc67e(%rip), %rdi      # 0x10392
leaq 0xc608(%rip), %rsi      # 0x10323
movl $0x3e, %edx
callq 0x4b20
movq -0x20(%rbp), %rdi
callq 0xddf0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xd8(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0xd8(%rax)
je 0x3d5a
movq -0x18(%rbp), %rax
movq 0xd8(%rax), %rax
cmpl $0x17, (%rax)
je 0x3d72
leaq 0xc64d(%rip), %rdi      # 0x103ae
leaq 0xc5bb(%rip), %rsi      # 0x10323
movl $0x40, %edx
callq 0x4b20
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/ast.c
// Function: CreateASTKeyValue
struct Node *CreateASTKeyValue(const char *key, struct Node *value) {
  struct Node *n = AllocNode(kASTKeyValue);
  n->key = key;
  n->value = value;
  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x11, %edi
callq 0x3a70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xa0(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/ast.c
// Function: CreateASTLocalVar
struct Node *CreateASTLocalVar(int byte_offset, struct Node *var_type) {
  struct Node *n = AllocNode(kASTLocalVar);
  n->byte_offset = byte_offset;
  n->expr_type = var_type;
  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x12, %edi
callq 0x3a70
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xa8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/ast.c
// Function: CreateTypeFunction
struct Node *CreateTypeFunction(struct Node *return_type,
                                struct Node *arg_type_list) {
  assert(IsASTList(arg_type_list));
  struct Node *n = AllocNode(kTypeFunction);
  n->left = return_type;
  n->right = arg_type_list;
  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x39a0
testb $0x1, %al
jne 0x3ed5
leaq 0xc51e(%rip), %rdi      # 0x103e2
leaq 0xc458(%rip), %rsi      # 0x10323
movl $0x66, %edx
callq 0x4b20
movl $0x17, %edi
callq 0x3a70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/ast.c
// Function: CreateTypeStruct
struct Node *CreateTypeStruct(struct Node *tag_token,
                              struct Node *struct_spec) {
  assert(IsToken(tag_token));
  struct Node *n = AllocNode(kTypeStruct);
  n->tag = tag_token;
  n->type_struct_spec = struct_spec;
  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbbb0
testb $0x1, %al
jne 0x3fe5
leaq 0xc455(%rip), %rdi      # 0x10429
leaq 0xc348(%rip), %rsi      # 0x10323
movl $0x79, %edx
callq 0x4b20
movl $0x19, %edi
callq 0x3a70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xe8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xf0(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/ast.c
// Function: CreateTypeAttrIdent
struct Node *CreateTypeAttrIdent(struct Node *ident_token, struct Node *type) {
  assert(ident_token && IsToken(ident_token));
  struct Node *n = AllocNode(kTypeAttrIdent);
  n->left = ident_token;
  n->right = type;
  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4044
movq -0x8(%rbp), %rdi
callq 0xbbb0
testb $0x1, %al
jne 0x405c
leaq 0xc3f1(%rip), %rdi      # 0x1043c
leaq 0xc2d1(%rip), %rsi      # 0x10323
movl $0x81, %edx
callq 0x4b20
movl $0x18, %edi
callq 0x3a70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/ast.c
// Function: CreateASTIdent
struct Node *CreateASTIdent(struct Node *ident) {
  assert(IsToken(ident));
  struct Node *n = AllocNode(kASTIdent);
  n->op = ident;
  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbbb0
testb $0x1, %al
jne 0x40c1
leaq 0xc3b0(%rip), %rdi      # 0x10460
leaq 0xc26c(%rip), %rsi      # 0x10323
movl $0x89, %edx
callq 0x4b20
movl $0xa, %edi
callq 0x3a70
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/ast.c
// Function: CreateTypeArray
struct Node *CreateTypeArray(struct Node *type_of, struct Node *index_decl) {
  struct Node *n = AllocNode(kTypeArray);
  n->type_array_type_of = type_of;
  n->type_array_index_decl = index_decl;
  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1a, %edi
callq 0x3a70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xf8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x100(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/ast.c
// Function: CreateMacroReplacement
struct Node *CreateMacroReplacement(struct Node *args_tokens,
                                    struct Node *to_tokens) {
  struct Node *n = AllocNode(kNodeMacroReplacement);
  n->arg_expr_list = args_tokens;
  n->value = to_tokens;
  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x3, %edi
callq 0x3a70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xb8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xa0(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/compilium.c
// Function: Error
_Noreturn void Error(const char *fmt, ...) {
  fflush(stdout);
  fprintf(stderr, "Error: ");
  va_list ap;
  va_start(ap, fmt);
  vfprintf(stderr, fmt, ap);
  va_end(ap);
  fputc('\n', stderr);
  exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x4a75
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq 0x1052d(%rip), %rax     # 0x14fd0
movq (%rax), %rdi
callq 0x2140
movq 0x10546(%rip), %rax     # 0x14ff8
movq (%rax), %rdi
leaq 0xba99(%rip), %rsi      # 0x10555
movb $0x0, %al
callq 0x2100
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x1050a(%rip), %rax     # 0x14ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x2170
leaq -0x20(%rbp), %rax
movq 0x104ef(%rip), %rax     # 0x14ff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x20c0
movl $0x1, %edi
callq 0x2190
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/compilium.c
// Function: ErrorWithToken
_Noreturn void ErrorWithToken(struct Node *t, const char *fmt, ...) {
  PrintTokenLine(t);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x4d88
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4b50
movq 0x1023c(%rip), %rax     # 0x14ff8
movq (%rax), %rdi
leaq 0xb78f(%rip), %rsi      # 0x10555
movb $0x0, %al
callq 0x2100
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0x10200(%rip), %rax     # 0x14ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x2170
leaq -0x30(%rbp), %rax
movq 0x101e5(%rip), %rax     # 0x14ff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x20c0
movl $0x1, %edi
callq 0x2190
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/compilium.c
// Function: ExpandListSizeIfNeeded
void ExpandListSizeIfNeeded(struct Node *list) {
  if (list->size < list->capacity) return;
  list->capacity = (list->capacity + 1) * 2;
  list->nodes = realloc(list->nodes, sizeof(struct Node *) * list->capacity);
  assert(list->nodes);
  assert(list->size < list->capacity);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x88(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x84(%rcx), %eax
jge 0x4e67
jmp 0x4f01
movq -0x8(%rbp), %rax
movl 0x84(%rax), %ecx
addl $0x1, %ecx
shll %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x84(%rax)
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x84(%rax), %rsi
shlq $0x3, %rsi
callq 0x2150
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x90(%rax)
jne 0x4ed3
leaq 0xb6d0(%rip), %rdi      # 0x10592
leaq 0xb6b3(%rip), %rsi      # 0x1057c
movl $0x6e, %edx
callq 0x4b20
movq -0x8(%rbp), %rax
movl 0x88(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x84(%rcx), %eax
jl 0x4f01
leaq 0xb6ae(%rip), %rdi      # 0x1059e
leaq 0xb685(%rip), %rsi      # 0x1057c
movl $0x6f, %edx
callq 0x4b20
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/compilium.c
// Function: GetNodeByTokenKey
struct Node *GetNodeByTokenKey(struct Node *list, struct Node *key) {
  assert(list && list->type == kASTList);
  for (int i = 0; i < list->size; i++) {
    struct Node *n = list->nodes[i];
    if (n->type != kASTKeyValue) continue;
    if (IsEqualTokenWithCStr(key, n->key)) return n->value;
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x50d0
movq -0x10(%rbp), %rax
cmpl $0x6, (%rax)
je 0x50e8
leaq 0xb4f0(%rip), %rdi      # 0x105c7
leaq 0xb49e(%rip), %rsi      # 0x1057c
movl $0x8a, %edx
callq 0x4b20
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x88(%rcx), %eax
jge 0x5157
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x11, (%rax)
je 0x5120
jmp 0x514c
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x98(%rax), %rsi
callq 0xbdf0
cmpl $0x0, %eax
je 0x514a
movq -0x28(%rbp), %rax
movq 0xa0(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x515f
jmp 0x514c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x50ef
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/compilium.c
// Function: GetNodeByKey
struct Node *GetNodeByKey(struct Node *list, const char *key) {
  assert(list && list->type == kASTList);
  for (int i = 0; i < list->size; i++) {
    struct Node *n = list->nodes[i];
    if (n->type != kASTKeyValue) continue;
    if (strcmp(n->key, key) == 0) return n->value;
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5190
movq -0x10(%rbp), %rax
cmpl $0x6, (%rax)
je 0x51a8
leaq 0xb430(%rip), %rdi      # 0x105c7
leaq 0xb3de(%rip), %rsi      # 0x1057c
movl $0x94, %edx
callq 0x4b20
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x88(%rcx), %eax
jge 0x5217
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x11, (%rax)
je 0x51e0
jmp 0x520c
movq -0x28(%rbp), %rax
movq 0x98(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0x520a
movq -0x28(%rbp), %rax
movq 0xa0(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x521f
jmp 0x520c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x51af
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/compilium.c
// Function: ReadFile
const char *ReadFile(FILE *fp) {
  int buf_size = INITIAL_INPUT_SIZE;
  char *input = malloc(buf_size);
  int input_size = 0;
  int c;
  while ((c = fgetc(fp)) != EOF) {
    input[input_size++] = c;
    if (input_size == buf_size) {
      buf_size <<= 1;
      assert((input = realloc(input, buf_size)));
    }
  }
  assert(input_size < buf_size);
  input[input_size] = 0;
  return input;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x2000, -0xc(%rbp)     # imm = 0x2000
movslq -0xc(%rbp), %rdi
callq 0x2130
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20b0
movl %eax, -0x20(%rbp)
cmpl $-0x1, %eax
je 0x5593
movl -0x20(%rbp), %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x5591
movl -0xc(%rbp), %eax
shll %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x2150
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x5591
leaq 0xb268(%rip), %rdi      # 0x107e8
leaq 0xaff5(%rip), %rsi      # 0x1057c
movl $0x106, %edx            # imm = 0x106
callq 0x4b20
jmp 0x5527
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jl 0x55b3
leaq 0xb269(%rip), %rdi      # 0x1080b
leaq 0xafd3(%rip), %rsi      # 0x1057c
movl $0x109, %edx            # imm = 0x109
callq 0x4b20
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/compilium.c
// Function: main
int main(int argc, char *argv[]) {
  struct Node *replacement_list = ParseCompilerArgs(argc, argv);
  const char *input = ReadFile(stdin);

  struct Node *tokens = Tokenize(input);

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

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

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

  Generate(ast, ctx);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x5700
movq %rax, -0x18(%rbp)
movq 0xf9db(%rip), %rax      # 0x14fd8
movq (%rax), %rdi
callq 0x5500
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xdb70
movq %rax, -0x28(%rbp)
movq 0xf9db(%rip), %rax      # 0x14ff8
movq (%rax), %rsi
leaq 0xb1fa(%rip), %rdi      # 0x10821
callq 0x20a0
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0xa0f0
testb $0x1, 0xfd00(%rip)      # 0x15340
je 0x5657
movq -0x28(%rbp), %rdi
callq 0xbf10
movl $0x0, -0x4(%rbp)
jmp 0x56eb
movq 0xf99a(%rip), %rax      # 0x14ff8
movq (%rax), %rsi
leaq 0xb1cb(%rip), %rdi      # 0x10833
callq 0x20a0
leaq -0x28(%rbp), %rdi
callq 0x9fa0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x4190
movq 0xf96e(%rip), %rax      # 0x14ff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x20c0
movq 0xf95a(%rip), %rax      # 0x14ff8
movq (%rax), %rsi
leaq 0xb198(%rip), %rdi      # 0x10840
callq 0x20a0
movq -0x30(%rbp), %rdi
callq 0x22b0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x4190
movq 0xf92e(%rip), %rax      # 0x14ff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x20c0
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x5a30
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/generator.c
// Function: GetParamRegName
const char *GetParamRegName(struct Node *type, int idx) {
  assert(0 <= idx && idx < NUM_OF_PARAM_REGISTERS);
  int size = GetSizeOfType(type);
  if (size == 8) return param_reg_names_64[idx];
  if (size == 4) return param_reg_names_32[idx];
  if (size == 1) return param_reg_names_8[idx];
  ErrorWithToken(GetIdentifierTokenFromTypeAttr(type),
                 "Assigning %d bytes is not implemented.", size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
xorl %eax, %eax
cmpl -0x14(%rbp), %eax
jg 0x598c
cmpl $0x6, -0x14(%rbp)
jl 0x59a4
leaq 0xaf86(%rip), %rdi      # 0x10919
leaq 0xafa8(%rip), %rsi      # 0x10942
movl $0xb4, %edx
callq 0x4b20
movq -0x10(%rbp), %rdi
callq 0xe040
movl %eax, -0x18(%rbp)
cmpl $0x8, -0x18(%rbp)
jne 0x59cb
movslq -0x14(%rbp), %rcx
leaq 0xf84f(%rip), %rax      # 0x15210
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x5a1e
cmpl $0x4, -0x18(%rbp)
jne 0x59e6
movslq -0x14(%rbp), %rcx
leaq 0xf864(%rip), %rax      # 0x15240
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x5a1e
cmpl $0x1, -0x18(%rbp)
jne 0x5a01
movslq -0x14(%rbp), %rcx
leaq 0xf879(%rip), %rax      # 0x15270
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x5a1e
movq -0x10(%rbp), %rdi
callq 0xde50
movq %rax, %rdi
movl -0x18(%rbp), %edx
leaq 0xaf37(%rip), %rsi      # 0x1094e
movb $0x0, %al
callq 0x4d50
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/generator.c
// Function: Generate
void Generate(struct Node *ast, struct SymbolEntry *toplevel_names) {
  label_to_break = 0;
  label_to_continue = 0;
  str_list = AllocList();
  printf(".intel_syntax noprefix\n");
  printf(".text\n");
  GenerateForNode(ast);
  GenerateDataSection(toplevel_names);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, 0xf90e(%rip)      # 0x15358
movl $0x0, 0xf908(%rip)      # 0x1535c
movb $0x0, %al
callq 0x4e30
movq %rax, 0xf8fe(%rip)      # 0x15360
leaq 0xaf0c(%rip), %rdi      # 0x10975
movb $0x0, %al
callq 0x2080
leaq 0xaf16(%rip), %rdi      # 0x1098d
movb $0x0, %al
callq 0x2080
movq -0x8(%rbp), %rdi
callq 0x5aa0
movq -0x10(%rbp), %rdi
callq 0x7aa0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/generator.c
// Function: GenerateDataSection
static void GenerateDataSection(struct SymbolEntry *toplevel_names) {
  printf(".data\n");
  for (int i = 0; i < GetSizeOfList(str_list); i++) {
    struct Node *n = GetNodeAt(str_list, i);
    printf("L%d: ", n->label_number);
    printf(".asciz ");
    PrintTokenStrToFile(n->op, stdout);
    putchar('\n');
  }
  struct SymbolEntry *e = toplevel_names;
  for (; e; e = e->prev) {
    if (e->type != kSymbolGlobalVar) continue;
    int size = GetSizeOfType(e->value);
    fprintf(stderr, "Global Var: %s = %d bytes\n", e->key, size);
    printf(".global %s%s\n", symbol_prefix, e->key);
    printf("%s%s:\n", symbol_prefix, e->key);
    printf(".byte ");
    for (int i = 0; i < size; i++) {
      printf("0%s", i == (size - 1) ? "\n" : ", ");
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x964c(%rip), %rdi      # 0x110ff
movb $0x0, %al
callq 0x2080
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq 0xd892(%rip), %rdi      # 0x15360
callq 0x4fe0
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x7b41
movq 0xd87d(%rip), %rdi      # 0x15360
movl -0xc(%rbp), %esi
callq 0x5030
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0xac(%rax), %esi
leaq 0x9606(%rip), %rdi      # 0x11106
movb $0x0, %al
callq 0x2080
leaq 0x95fe(%rip), %rdi      # 0x1110c
movb $0x0, %al
callq 0x2080
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq 0xd4ac(%rip), %rax      # 0x14fd0
movq (%rax), %rsi
callq 0xc0b0
movl $0xa, %edi
callq 0x2030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7ac1
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x7c3b
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
je 0x7b62
jmp 0x7c2a
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xe040
movl %eax, -0x24(%rbp)
movq 0xd47f(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
movl -0x24(%rbp), %ecx
leaq 0x9586(%rip), %rsi      # 0x11114
movb $0x0, %al
callq 0x2100
leaq 0xd7ac(%rip), %rax      # 0x15348
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x8ee4(%rip), %rdi      # 0x10a92
movb $0x0, %al
callq 0x2080
leaq 0xd78c(%rip), %rax      # 0x15348
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x8ed2(%rip), %rdi      # 0x10aa0
movb $0x0, %al
callq 0x2080
leaq 0x9553(%rip), %rdi      # 0x1112f
movb $0x0, %al
callq 0x2080
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x7c28
movl -0x28(%rbp), %ecx
movl -0x24(%rbp), %edx
subl $0x1, %edx
leaq 0x9538(%rip), %rsi      # 0x1113a
leaq 0x867a(%rip), %rax      # 0x10283
cmpl %edx, %ecx
cmoveq %rax, %rsi
leaq 0x9520(%rip), %rdi      # 0x11136
movb $0x0, %al
callq 0x2080
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x7bea
jmp 0x7c2a
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x7b49
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/generator.c
// Function: GenerateForNodeRValue
static void GenerateForNodeRValue(struct Node *node) {
  GenerateForNode(node);
  if (!node->expr_type) return;
  if (node->expr_type->type != kTypeLValue) return;
  if (node->expr_type->type == kTypeLValue &&
      node->expr_type->right->type == kTypeArray)
    return;
  int size = GetSizeOfType(GetRValueType(node->expr_type));
  if (size == 8) {
    printf("mov %s, [%s]\n", reg_names_64[node->reg], reg_names_64[node->reg]);
    return;
  } else if (size == 4) {
    printf("movsxd %s, dword ptr[%s]\n", reg_names_64[node->reg],
           reg_names_64[node->reg]);
    return;
  } else if (size == 1) {
    printf("movsx %s, byte ptr[%s]\n", reg_names_64[node->reg],
           reg_names_64[node->reg]);
    return;
  }
  ErrorWithToken(node->op, "Dereferencing %d bytes is not implemented.", size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5aa0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x7c75
jmp 0x7d96
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x15, (%rax)
je 0x7c87
jmp 0x7d96
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x15, (%rax)
jne 0x7caa
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
cmpl $0x1a, (%rax)
jne 0x7caa
jmp 0x7d96
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xde90
movq %rax, %rdi
callq 0xe040
movl %eax, -0xc(%rbp)
cmpl $0x8, -0xc(%rbp)
jne 0x7d01
movq -0x8(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0xd419(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
movq -0x8(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0xd406(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rdx
leaq 0x9188(%rip), %rdi      # 0x10e7d
movb $0x0, %al
callq 0x2080
jmp 0x7d96
cmpl $0x4, -0xc(%rbp)
jne 0x7d3d
movq -0x8(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0xd3da(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
movq -0x8(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0xd3c7(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rdx
leaq 0x9157(%rip), %rdi      # 0x10e8b
movb $0x0, %al
callq 0x2080
jmp 0x7d96
cmpl $0x1, -0xc(%rbp)
jne 0x7d79
movq -0x8(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0xd39e(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
movq -0x8(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0xd38b(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rdx
leaq 0x9135(%rip), %rdi      # 0x10ea5
movb $0x0, %al
callq 0x2080
jmp 0x7d96
jmp 0x7d7b
jmp 0x7d7d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %edx
leaq 0x912e(%rip), %rsi      # 0x10ebd
movb $0x0, %al
callq 0x4d50
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/generator.c
// Function: EmitConvertToBool
static void EmitConvertToBool(int dst, int src) {
  // This code also sets zero flag as boolean value
  printf("cmp %s, 0\n", reg_names_64[src]);
  printf("setnz %s\n", reg_names_8[src]);
  printf("movzx %s, %s\n", reg_names_64[dst], reg_names_8[src]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0xd337(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
leaq 0x9124(%rip), %rdi      # 0x10ee8
movb $0x0, %al
callq 0x2080
movslq -0x8(%rbp), %rcx
leaq 0xd3da(%rip), %rax      # 0x151b0
movq (%rax,%rcx,8), %rsi
leaq 0x9112(%rip), %rdi      # 0x10ef3
movb $0x0, %al
callq 0x2080
movslq -0x4(%rbp), %rcx
leaq 0xd2fd(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
movslq -0x8(%rbp), %rcx
leaq 0xd3ae(%rip), %rax      # 0x151b0
movq (%rax,%rcx,8), %rdx
leaq 0x90f0(%rip), %rdi      # 0x10efd
movb $0x0, %al
callq 0x2080
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/generator.c
// Function: EmitDecMemory
static void EmitDecMemory(struct Node *op, int dst, int size) {
  if (size == 8) {
    printf("dec qword ptr [%s]\n", reg_names_64[dst]);
    return;
  }
  if (size == 4) {
    printf("dec dword ptr [%s]\n", reg_names_64[dst]);
    return;
  }
  if (size == 1) {
    printf("dec byte ptr [%s]\n", reg_names_64[dst]);
    return;
  }
  ErrorWithToken(op, "Assigning %d bytes is not implemented.", size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x8, -0x10(%rbp)
jne 0x7e57
movslq -0xc(%rbp), %rcx
leaq 0xd2ad(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
leaq 0x90bd(%rip), %rdi      # 0x10f0b
movb $0x0, %al
callq 0x2080
jmp 0x7eb6
cmpl $0x4, -0x10(%rbp)
jne 0x7e7c
movslq -0xc(%rbp), %rcx
leaq 0xd288(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
leaq 0x90ac(%rip), %rdi      # 0x10f1f
movb $0x0, %al
callq 0x2080
jmp 0x7eb6
cmpl $0x1, -0x10(%rbp)
jne 0x7ea1
movslq -0xc(%rbp), %rcx
leaq 0xd263(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
leaq 0x909b(%rip), %rdi      # 0x10f33
movb $0x0, %al
callq 0x2080
jmp 0x7eb6
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %edx
leaq 0x8a9f(%rip), %rsi      # 0x1094e
movb $0x0, %al
callq 0x4d50
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/generator.c
// Function: EmitMoveFromMemory
static void EmitMoveFromMemory(struct Node *op, int dst, int src, int size) {
  if (size == 8) {
    printf("mov %s, [%s]\n", reg_names_64[dst], reg_names_64[src]);
    return;
  }
  if (size == 4) {
    printf("movsxd %s, dword ptr [%s]\n", reg_names_64[dst], reg_names_64[src]);
    return;
  }
  if (size == 1) {
    printf("movsxb %s, byte ptr [%s]\n", reg_names_64[dst], reg_names_64[src]);
    return;
  }
  ErrorWithToken(op, "Assigning %d bytes is not implemented.", size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jne 0x7f09
movslq -0xc(%rbp), %rcx
leaq 0xd20a(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
movslq -0x10(%rbp), %rcx
leaq 0xd1fb(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rdx
leaq 0x8f7d(%rip), %rdi      # 0x10e7d
movb $0x0, %al
callq 0x2080
jmp 0x7f86
cmpl $0x4, -0x14(%rbp)
jne 0x7f3d
movslq -0xc(%rbp), %rcx
leaq 0xd1d6(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
movslq -0x10(%rbp), %rcx
leaq 0xd1c7(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rdx
leaq 0x9012(%rip), %rdi      # 0x10f46
movb $0x0, %al
callq 0x2080
jmp 0x7f86
cmpl $0x1, -0x14(%rbp)
jne 0x7f71
movslq -0xc(%rbp), %rcx
leaq 0xd1a2(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
movslq -0x10(%rbp), %rcx
leaq 0xd193(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rdx
leaq 0x8ff9(%rip), %rdi      # 0x10f61
movb $0x0, %al
callq 0x2080
jmp 0x7f86
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x89cf(%rip), %rsi      # 0x1094e
movb $0x0, %al
callq 0x4d50
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/generator.c
// Function: EmitIncMemory
static void EmitIncMemory(struct Node *op, int dst, int size) {
  if (size == 8) {
    printf("inc qword ptr [%s]\n", reg_names_64[dst]);
    return;
  }
  if (size == 4) {
    printf("inc dword ptr [%s]\n", reg_names_64[dst]);
    return;
  }
  if (size == 1) {
    printf("inc byte ptr [%s]\n", reg_names_64[dst]);
    return;
  }
  ErrorWithToken(op, "Assigning %d bytes is not implemented.", size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x8, -0x10(%rbp)
jne 0x7fc7
movslq -0xc(%rbp), %rcx
leaq 0xd13d(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
leaq 0x8fbd(%rip), %rdi      # 0x10f7b
movb $0x0, %al
callq 0x2080
jmp 0x8026
cmpl $0x4, -0x10(%rbp)
jne 0x7fec
movslq -0xc(%rbp), %rcx
leaq 0xd118(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
leaq 0x8fac(%rip), %rdi      # 0x10f8f
movb $0x0, %al
callq 0x2080
jmp 0x8026
cmpl $0x1, -0x10(%rbp)
jne 0x8011
movslq -0xc(%rbp), %rcx
leaq 0xd0f3(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
leaq 0x8f9b(%rip), %rdi      # 0x10fa3
movb $0x0, %al
callq 0x2080
jmp 0x8026
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %edx
leaq 0x892f(%rip), %rsi      # 0x1094e
movb $0x0, %al
callq 0x4d50
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/generator.c
// Function: EmitMoveToMemory
static void EmitMoveToMemory(struct Node *op, int dst, int src, int size) {
  if (size == 8) {
    printf("mov [%s], %s\n", reg_names_64[dst], reg_names_64[src]);
    return;
  }
  if (size == 4) {
    printf("mov [%s], %s # 4 byte store\n", reg_names_64[dst],
           reg_names_32[src]);
    return;
  }
  if (size == 1) {
    printf("mov [%s], %s\n", reg_names_64[dst], reg_names_8[src]);
    return;
  }
  ErrorWithToken(op, "Assigning %d bytes is not implemented.", size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jne 0x8079
movslq -0xc(%rbp), %rcx
leaq 0xd09a(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
movslq -0x10(%rbp), %rcx
leaq 0xd08b(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rdx
leaq 0x8f46(%rip), %rdi      # 0x10fb6
movb $0x0, %al
callq 0x2080
jmp 0x80f6
cmpl $0x4, -0x14(%rbp)
jne 0x80ad
movslq -0xc(%rbp), %rcx
leaq 0xd066(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
movslq -0x10(%rbp), %rcx
leaq 0xd0b7(%rip), %rax      # 0x15150
movq (%rax,%rcx,8), %rdx
leaq 0x8f20(%rip), %rdi      # 0x10fc4
movb $0x0, %al
callq 0x2080
jmp 0x80f6
cmpl $0x1, -0x14(%rbp)
jne 0x80e1
movslq -0xc(%rbp), %rcx
leaq 0xd032(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
movslq -0x10(%rbp), %rcx
leaq 0xd0e3(%rip), %rax      # 0x151b0
movq (%rax,%rcx,8), %rdx
leaq 0x8ede(%rip), %rdi      # 0x10fb6
movb $0x0, %al
callq 0x2080
jmp 0x80f6
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x885f(%rip), %rsi      # 0x1094e
movb $0x0, %al
callq 0x4d50
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/generator.c
// Function: EmitAddToMemory
static void EmitAddToMemory(struct Node *op, int dst, int src, int size) {
  if (size == 8) {
    printf("add qword ptr [%s], %s\n", reg_names_64[dst], reg_names_64[src]);
    return;
  }
  if (size == 4) {
    printf("add dword ptr [%s], %s\n", reg_names_64[dst], reg_names_32[src]);
    return;
  }
  if (size == 1) {
    printf("add byte ptr [%s], %s\n", reg_names_64[dst], reg_names_8[src]);
    return;
  }
  ErrorWithToken(op, "Assigning %d bytes is not implemented.", size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jne 0x8149
movslq -0xc(%rbp), %rcx
leaq 0xcfca(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
movslq -0x10(%rbp), %rcx
leaq 0xcfbb(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rdx
leaq 0x8ea1(%rip), %rdi      # 0x10fe1
movb $0x0, %al
callq 0x2080
jmp 0x81c6
cmpl $0x4, -0x14(%rbp)
jne 0x817d
movslq -0xc(%rbp), %rcx
leaq 0xcf96(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
movslq -0x10(%rbp), %rcx
leaq 0xcfe7(%rip), %rax      # 0x15150
movq (%rax,%rcx,8), %rdx
leaq 0x8e85(%rip), %rdi      # 0x10ff9
movb $0x0, %al
callq 0x2080
jmp 0x81c6
cmpl $0x1, -0x14(%rbp)
jne 0x81b1
movslq -0xc(%rbp), %rcx
leaq 0xcf62(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
movslq -0x10(%rbp), %rcx
leaq 0xd013(%rip), %rax      # 0x151b0
movq (%rax,%rcx,8), %rdx
leaq 0x8e69(%rip), %rdi      # 0x11011
movb $0x0, %al
callq 0x2080
jmp 0x81c6
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x878f(%rip), %rsi      # 0x1094e
movb $0x0, %al
callq 0x4d50
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/generator.c
// Function: EmitSubFromMemory
static void EmitSubFromMemory(struct Node *op, int dst, int src, int size) {
  if (size == 8) {
    printf("sub qword ptr [%s], %s\n", reg_names_64[dst], reg_names_64[src]);
    return;
  }
  if (size == 4) {
    printf("sub dword ptr [%s], %s\n", reg_names_64[dst], reg_names_32[src]);
    return;
  }
  if (size == 1) {
    printf("sub byte ptr [%s], %s\n", reg_names_64[dst], reg_names_8[src]);
    return;
  }
  ErrorWithToken(op, "Assigning %d bytes is not implemented.", size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jne 0x8219
movslq -0xc(%rbp), %rcx
leaq 0xcefa(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
movslq -0x10(%rbp), %rcx
leaq 0xceeb(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rdx
leaq 0x8e18(%rip), %rdi      # 0x11028
movb $0x0, %al
callq 0x2080
jmp 0x8296
cmpl $0x4, -0x14(%rbp)
jne 0x824d
movslq -0xc(%rbp), %rcx
leaq 0xcec6(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
movslq -0x10(%rbp), %rcx
leaq 0xcf17(%rip), %rax      # 0x15150
movq (%rax,%rcx,8), %rdx
leaq 0x8dfc(%rip), %rdi      # 0x11040
movb $0x0, %al
callq 0x2080
jmp 0x8296
cmpl $0x1, -0x14(%rbp)
jne 0x8281
movslq -0xc(%rbp), %rcx
leaq 0xce92(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
movslq -0x10(%rbp), %rcx
leaq 0xcf43(%rip), %rax      # 0x151b0
movq (%rax,%rcx,8), %rdx
leaq 0x8de0(%rip), %rdi      # 0x11058
movb $0x0, %al
callq 0x2080
jmp 0x8296
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x86bf(%rip), %rsi      # 0x1094e
movb $0x0, %al
callq 0x4d50
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hikalium[P]compilium/generator.c
// Function: EmitMulToMemory
static void EmitMulToMemory(struct Node *op, int dst, int src, int size) {
  if (size == 4) {
    // rdx:rax <- rax * r/m
    printf("xor rdx, rdx\n");
    printf("mov rax, %s\n", reg_names_64[dst]);
    printf("mov eax, [rax]\n");
    printf("imul %s\n", reg_names_64[src]);
    printf("mov [%s], eax\n", reg_names_64[dst]);
    return;
  }
  ErrorWithToken(op, "Assigning %d bytes is not implemented.", size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jne 0x8334
leaq 0x8a7e(%rip), %rdi      # 0x10d40
movb $0x0, %al
callq 0x2080
movslq -0xc(%rbp), %rcx
leaq 0xce1c(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
leaq 0x8a6f(%rip), %rdi      # 0x10d4e
movb $0x0, %al
callq 0x2080
leaq 0x8d82(%rip), %rdi      # 0x1106f
movb $0x0, %al
callq 0x2080
movslq -0x10(%rbp), %rcx
leaq 0xcdf1(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
leaq 0x8a51(%rip), %rdi      # 0x10d5b
movb $0x0, %al
callq 0x2080
movslq -0xc(%rbp), %rcx
leaq 0xcdd4(%rip), %rax      # 0x150f0
movq (%rax,%rcx,8), %rsi
leaq 0x8d58(%rip), %rdi      # 0x1107f
movb $0x0, %al
callq 0x2080
addq $0x20, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x860c(%rip), %rsi      # 0x1094e
movb $0x0, %al
callq 0x4d50
nopl (%rax)