LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/debug.c
// Function: dump_inclusive_or_expr_node
static void dump_inclusive_or_expr_node(const InclusiveOrExprNode* node, int indent) {
    printf_indent(indent, "InclusiveOrExprNode\n");

    if (node->exclusive_or_expr_node != NULL) {
        dump_exclusive_or_expr_node(node->exclusive_or_expr_node, indent + 2);
    }

    if (node->inclusive_or_expr_node != NULL) {
        dump_inclusive_or_expr_node(node->inclusive_or_expr_node, indent + 2);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq 0xd44b(%rip), %rsi      # 0xf164
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1d3c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1d60
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1d5a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1d00
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/debug.c
// Function: dump_exclusive_or_expr_node
static void dump_exclusive_or_expr_node(const ExclusiveOrExprNode* node, int indent) {
    printf_indent(indent, "ExclusiveOrExprNode\n");

    if (node->and_expr_node != NULL) {
        dump_and_expr_node(node->and_expr_node, indent + 2);
    }

    if (node->exclusive_or_expr_node != NULL) {
        dump_exclusive_or_expr_node(node->exclusive_or_expr_node, indent + 2);
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq 0xd400(%rip), %rsi      # 0xf179
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1d9c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1dc0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1dba
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1d60
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/debug.c
// Function: dump_and_expr_node
static void dump_and_expr_node(const AndExprNode* node, int indent) {
    printf_indent(indent, "AndExprNode\n");

    if (node->equality_expr_node != NULL) {
        dump_equality_expr_node(node->equality_expr_node, indent + 2);
    }

    if (node->and_expr_node != NULL) {
        dump_and_expr_node(node->and_expr_node, indent + 2);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq 0xd37e(%rip), %rsi      # 0xf157
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1dfc
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1e20
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1e1a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1dc0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/debug.c
// Function: dump_equality_expr_node
static void dump_equality_expr_node(const EqualityExprNode* node, int indent) {
    printf_indent(
        indent, 
        "EqualityExprNode,CmpType=\"%s\"\n",
        decode_comparison_operator_type(node->cmp_type)
    );

    if (node->relational_expr_node != NULL) {
        dump_relational_expr_node(node->relational_expr_node, indent + 2);
    }

    if (node->equality_expr_node != NULL) {
        dump_equality_expr_node(node->equality_expr_node, indent + 2);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x7330
movl -0x10(%rbp), %edi
movq %rax, %rdx
leaq 0xd341(%rip), %rsi      # 0xf18e
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1e72
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1ea0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1e90
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1e20
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/debug.c
// Function: dump_relational_expr_node
static void dump_relational_expr_node(const RelationalExprNode* node, int indent) {
    printf_indent(
        indent,
        "RelationalExprNode,CmpType=\"%s\"\n",
        decode_comparison_operator_type(node->cmp_type)
    );

    if (node->shift_expr_node != NULL) {
        dump_shift_expr_node(node->shift_expr_node, indent + 2);
    }

    if (node->relational_expr_node != NULL) {
        dump_relational_expr_node(node->relational_expr_node, indent + 2);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x7330
movl -0x10(%rbp), %edi
movq %rax, %rdx
leaq 0xd2e0(%rip), %rsi      # 0xf1ad
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1ef2
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1f20
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1f10
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1ea0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/debug.c
// Function: dump_shift_expr_node
static void dump_shift_expr_node(const ShiftExprNode* node, int indent) {
    printf_indent(indent, "ShiftExprNode\n");

    if (node->additive_expr_node != NULL) {
        dump_additive_expr_node(node->additive_expr_node, indent + 2);
    }

    if (node->shift_expr_node != NULL) {
        dump_shift_expr_node(node->shift_expr_node, indent + 2);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq 0xd295(%rip), %rsi      # 0xf1ce
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1f5c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1f80
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1f7a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1f20
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/debug.c
// Function: dump_additive_expr_node
static void dump_additive_expr_node(const AdditiveExprNode* node, int indent) {
    printf_indent(
        indent, 
        "AdditiveExprNode,OperatorType=\"%s\"\n", 
        decode_operator_type(node->operator_type)
    );

    if (node->multiplicative_expr_node != NULL) {
        dump_multiplicative_expr_node(node->multiplicative_expr_node, indent + 2);
    }

    if (node->additive_expr_node != NULL) {
        dump_additive_expr_node(node->additive_expr_node, indent + 2);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x71e0
movl -0x10(%rbp), %edi
movq %rax, %rdx
leaq 0xd230(%rip), %rsi      # 0xf1dd
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1fd2
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x2000
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1ff0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1f80
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/debug.c
// Function: dump_multiplicative_expr_node
static void dump_multiplicative_expr_node(const MultiPlicativeExprNode* node, int indent) {
    printf_indent(
        indent,
        "MultiPlicativeExprNode,OperatorType=\"%s\"\n",
        decode_operator_type(node->operator_type)
    );

    if (node->cast_expr_node != NULL) {
        dump_cast_expr_node(node->cast_expr_node, indent + 2);
    }

    if (node->multiplicative_expr_node != NULL) {
        dump_multiplicative_expr_node(node->multiplicative_expr_node, indent + 2);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x71e0
movl -0x10(%rbp), %edi
movq %rax, %rdx
leaq 0xd1d4(%rip), %rsi      # 0xf201
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2052
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x2080
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2070
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x2000
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/debug.c
// Function: dump_cast_expr_node
static void dump_cast_expr_node(const CastExprNode* node, int indent) {
    printf_indent(indent, "CastExprNode\n");

    if (node->unary_expr_node != NULL) {
        dump_unary_expr_node(node->unary_expr_node, indent + 2);
    }

    if (node->cast_expr_node != NULL) {
        dump_cast_expr_node(node->cast_expr_node, indent + 2);
    }

    if (node->type_name_node != NULL) {
        dump_type_name_node(node->type_name_node, indent + 2);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq 0xd192(%rip), %rsi      # 0xf22b
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x20bc
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x2100
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x20da
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x2080
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x20f8
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x21b0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/debug.c
// Function: dump_unary_expr_node
static void dump_unary_expr_node(const UnaryExprNode* node, int indent) {
    printf_indent(
        indent, 
        "UnaryExprNode,UnaryType=\"%s\",OperatorType=\"%s\"\n", 
        decode_unary_type(node->type),
        decode_operator_type(node->op_type)
    );

    if (node->postfix_expr_node != NULL) {
        dump_postfix_expr_node(node->postfix_expr_node, indent + 2);
    }

    if (node->unary_expr_node != NULL) {
        dump_unary_expr_node(node->unary_expr_node, indent + 2);
    }

    if (node->cast_expr_node != NULL) {
        dump_cast_expr_node(node->cast_expr_node, indent + 2);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %edi
callq 0x7490
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x24(%rax), %edi
callq 0x71e0
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rdx
movq %rax, %rcx
leaq 0xd0f7(%rip), %rsi      # 0xf239
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2165
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x21e0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2183
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x2100
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x21a1
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x2080
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/debug.c
// Function: dump_postfix_expr_node
static void dump_postfix_expr_node(const PostfixExprNode* node, int indent) {
    printf_indent(
        indent, 
        "PostfixExprNode,PostfixExprType=\"%s\",Identifier=\"%s\"\n",
        decode_postfix_type(node->postfix_expr_type),
        node->identifier
    );

    if (node->primary_expr_node != NULL) {
        dump_primary_expr_node(node->primary_expr_node, indent + 2);
    }

    if (node->postfix_expr_node != NULL) {
        dump_postfix_expr_node(node->postfix_expr_node, indent + 2);
    }

    if (node->expr_node != NULL) {
        dump_expr_node(node->expr_node, indent + 2);
    }

    for (int i = 0; i < node->assign_expr_nodes->size; ++i) {
        dump_assign_expr_node(node->assign_expr_nodes->elements[i], indent + 2);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edi
callq 0x7520
movl -0x14(%rbp), %edi
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
leaq 0xd053(%rip), %rsi      # 0xf269
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2239
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x22c0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2257
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x21e0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2275
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1c40
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpl 0x8(%rcx), %eax
jge 0x22b5
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x2330
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x227c
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/debug.c
// Function: dump_primary_expr_node
static void dump_primary_expr_node(const PrimaryExprNode* node, int indent) {
    printf_indent(
        indent, 
        "PrimaryExprNode,Identifier=\"%s\"\n",
        node->identifier
    );

    if (node->constant_node != NULL) {
        dump_constant_node(node->constant_node, indent + 2);
    }

    if (node->expr_node != NULL) {
        dump_expr_node(node->expr_node, indent + 2);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
leaq 0xcfbe(%rip), %rsi      # 0xf29f
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2304
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x23c0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2322
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1c40
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/debug.c
// Function: dump_assign_expr_node
static void dump_assign_expr_node(const AssignExprNode* node, int indent) {
    printf_indent(
        indent, 
        "AssignExprNode,Operator=\"%s\"\n",
        decode_operator_type(node->assign_operator)
    );

    if (node->conditional_expr_node != NULL) {
        dump_conditional_expr_node(node->conditional_expr_node, indent + 2);
    }

    if (node->unary_expr_node != NULL) {
        dump_unary_expr_node(node->unary_expr_node, indent + 2);
        dump_assign_expr_node(node->assign_expr_node, indent + 2);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edi
callq 0x71e0
movl -0x10(%rbp), %edi
movq %rax, %rdx
leaq 0xcfaa(%rip), %rsi      # 0xf308
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2381
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1b10
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x23b2
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x2100
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x2330
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/debug.c
// Function: dump_constant_node
static void dump_constant_node(const ConstantNode* node, int indent) {
    printf_indent(
        indent, 
        "ConstantNode,ConstType=\"%s\"",
        decode_const_type(node->const_type)
    );

    switch (node->const_type) {
    case CONST_INT: {
        printf("IntegerConstant=%d\n", node->integer_constant);
        break;
    }
    case CONST_STR: {
        printf("CharacterConstant=\"%s\"\n", node->character_constant);
        break;
    }
    default: {
        printf("\n");
        break;
    }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x73d0
movl -0x14(%rbp), %edi
movq %rax, %rdx
leaq 0xced3(%rip), %rsi      # 0xf2c0
xorl %eax, %eax
callq 0x14d0
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x240d
jmp 0x2403
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x2424
jmp 0x243c
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
leaq 0xcec1(%rip), %rdi      # 0xf2dc
movb $0x0, %al
callq 0x1090
jmp 0x244a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0xcebd(%rip), %rdi      # 0xf2f0
movb $0x0, %al
callq 0x1090
jmp 0x244a
leaq 0xd1d0(%rip), %rdi      # 0xf613
movb $0x0, %al
callq 0x1090
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/debug.c
// Function: dump_param_list_node
static void dump_param_list_node(const ParamListNode* node, int indent) {
    printf_indent(indent, "ParamListNode\n");

    if (node->param_declaration_node != NULL) {
        dump_param_declaration_node(node->param_declaration_node, indent + 2);
    }

    if (node->param_list_node != NULL) {
        dump_param_list_node(node->param_list_node, indent + 2);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq 0xcedd(%rip), %rsi      # 0xf346
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x248c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x24b0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x24aa
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x2450
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/debug.c
// Function: dump_param_declaration_node
static void dump_param_declaration_node(const ParamDeclarationNode* node, int indent) {
    printf_indent(indent, "ParamDeclarationNode\n");

    for (int i = 0; i < node->decl_spec_nodes->size; ++i) {
        dump_decl_specifier_node(node->decl_spec_nodes->elements[i], indent + 2);
    }

    if (node->declarator_node != NULL) {
        dump_declarator_node(node->declarator_node, indent + 2);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq 0xce8c(%rip), %rsi      # 0xf355
movb $0x0, %al
callq 0x14d0
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x8(%rcx), %eax
jge 0x250e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1740
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x24d7
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x252c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1790
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/debug.c
// Function: dump_block_item_node
static void dump_block_item_node(const BlockItemNode* node, int indent) {
    printf_indent(indent, "BlockItemNode\n");

    if (node->declaration_node != NULL) {
        dump_declaration_node(node->declaration_node, indent + 2);
    } else {
        dump_stmt_node(node->stmt_node, indent + 2);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq 0xce24(%rip), %rsi      # 0xf37d
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x257e
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1640
jmp 0x2591
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x25a0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/debug.c
// Function: dump_stmt_node
static void dump_stmt_node(const StmtNode* node, int indent) {
    printf_indent(indent, "StmtNode\n");

    if (node->labeled_stmt_node != NULL) {
        dump_labeled_stmt_node(node->labeled_stmt_node, indent + 2);
    }

    if (node->expr_stmt_node != NULL) {
        dump_expr_stmt_node(node->expr_stmt_node, indent + 2);
    }

    if (node->compound_stmt_node != NULL) {
        dump_compound_stmt_node(node->compound_stmt_node, indent + 2);
    }

    if (node->selection_stmt_node != NULL) {
        dump_selection_stmt_node(node->selection_stmt_node, indent + 2);
    }

    if (node->itr_stmt_node != NULL) {
        dump_itr_stmt_node(node->itr_stmt_node, indent + 2);
    }

    if (node->jump_stmt_node != NULL) {
        dump_jump_stmt_node(node->jump_stmt_node, indent + 2);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq 0xcdba(%rip), %rsi      # 0xf373
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x25dc
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x2680
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x25fa
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x2700
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2618
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x17f0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x2636
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x2750
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x2654
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x27f0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x2672
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x28f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/debug.c
// Function: dump_labeled_stmt_node
static void dump_labeled_stmt_node(const LabeledStmtNode* node, int indent) {
    printf_indent(
        indent,
        "LabeledStmtNode,LabeledStmtType=\"%s\"\n",
        decode_labeled_stmt_type(node->labeled_stmt_type)
    );

    if (node->conditional_expr_node != NULL) {
        dump_conditional_expr_node(node->conditional_expr_node, indent + 2 );
    }

    if (node->stmt_node != NULL) {
        dump_stmt_node(node->stmt_node, indent + 2);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x7670
movl -0x10(%rbp), %edi
movq %rax, %rdx
leaq 0xccdf(%rip), %rsi      # 0xf38c
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x26d2
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1b10
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x26f0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x25a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/debug.c
// Function: dump_selection_stmt_node
static void dump_selection_stmt_node(const SelectionStmtNode* node, int indent) {
    printf_indent(
        indent, 
        "SelectionStmtNode,SelectionType=\"%s\"\n",
        decode_selection_stmt_type(node->selection_type)
    );

    if (node->expr_node != NULL) {
        dump_expr_node(node->expr_node, indent + 2);
    }

    if (node->stmt_node_0 != NULL) {
        dump_stmt_node(node->stmt_node_0, indent + 2);
    }

    if (node->stmt_node_1 != NULL) {
        dump_stmt_node(node->stmt_node_1, indent + 2);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x75c0
movl -0x10(%rbp), %edi
movq %rax, %rdx
leaq 0xcc43(%rip), %rsi      # 0xf3c0
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x27a2
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1c40
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x27c0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x25a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x27de
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x25a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/debug.c
// Function: dump_itr_stmt_node
static void dump_itr_stmt_node(const ItrStmtNode* node, int indent) {
    printf_indent(
        indent, 
        "ItrStmtNode,ItrType=\"%s\"", 
        decode_itr_type(node->itr_type)
    );

    for (int i = 0; i < node->declaration_nodes->size; ++i) {
        dump_declaration_node(node->declaration_nodes->elements[i], indent + 2);
    }

    if (node->expr_node_0 != NULL) {
        dump_expr_node(node->expr_node_0, indent + 2);
    }

    if (node->expr_node_1 != NULL) {
        dump_expr_node(node->expr_node_1, indent + 2);
    }

    if (node->expr_node_2 != NULL) {
        dump_expr_node(node->expr_node_2, indent + 2);
    }

    if (node->stmt_node != NULL) {
        dump_stmt_node(node->stmt_node, indent + 2);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x7620
movl -0x14(%rbp), %edi
movq %rax, %rdx
leaq 0xcbc9(%rip), %rsi      # 0xf3e6
movb $0x0, %al
callq 0x14d0
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
cmpl 0x8(%rcx), %eax
jge 0x2864
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1640
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x282b
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2882
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1c40
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x28a0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1c40
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x28be
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1c40
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x28dc
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x25a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/debug.c
// Function: dump_jump_stmt_node
static void dump_jump_stmt_node(const JumpStmtNode* node, int indent) {
    printf_indent(
        indent, 
        "JumpStmtNode,JumpType=\"%s\",Identifier=\"%s\"\n",
        decode_jump_type(node->jump_type),
        node->identifier
    );

    if (node->expr_node != NULL) {
        dump_expr_node(node->expr_node, indent + 2);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x7430
movl -0x10(%rbp), %edi
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0xcada(%rip), %rsi      # 0xf3ff
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x294a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1c40
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/debug.c
// Function: dump_init_declarator_node
static void dump_init_declarator_node(const InitDeclaratorNode* node, int indent) {
    printf_indent(indent, "InitDeclaratorNode\n");

    if (node->declarator_node != NULL) {
        dump_declarator_node(node->declarator_node, indent + 2);
    }

    if (node->initializer_node != NULL) {
        dump_initializer_node(node->initializer_node, indent + 2);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq 0xcac2(%rip), %rsi      # 0xf42b
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x298c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1790
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x29aa
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x29b0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/debug.c
// Function: dump_initializer_node
static void dump_initializer_node(const InitializerNode* node, int indent) {
    printf_indent(indent, "InitializerNode\n");

    if (node->assign_expr_node != NULL) {
        dump_assign_expr_node(node->assign_expr_node, indent + 2);
    }

    if (node->initializer_list_node != NULL) {
        dump_initializer_list_node(node->initializer_list_node, indent + 2);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq 0xca76(%rip), %rsi      # 0xf43f
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x29ec
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x2330
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2a0a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x2a10
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/generator.c
// Function: gen
void gen(const TransUnitNode* node) {
    printf(".intel_syntax noprefix\n");

    // init
    label_index              = 2;
    break_label_stack        = create_stack();
    continue_label_stack     = create_stack();
    type_stack               = create_stack();
    current_stmt_label_stack = create_stack();
    size_stack               = create_intstack();
    globalvar_list           = create_vector();
    struct_map               = create_strptrmap(1024);
    enum_map                 = create_strintmap(1024);

    // gen
    for (int i = 0; i < node->external_decl_nodes->size; ++i) {
        process_external_decl(node->external_decl_nodes->elements[i]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xcb31(%rip), %rdi      # 0xf5b4
movb $0x0, %al
callq 0x1090
movl $0x2, 0x12684(%rip)     # 0x15118
movb $0x0, %al
callq 0xe690
movq %rax, 0x1267e(%rip)     # 0x15120
movb $0x0, %al
callq 0xe690
movq %rax, 0x12678(%rip)     # 0x15128
movb $0x0, %al
callq 0xe690
movq %rax, 0x12672(%rip)     # 0x15130
movb $0x0, %al
callq 0xe690
movq %rax, 0x1266c(%rip)     # 0x15138
movb $0x0, %al
callq 0xe7c0
movq %rax, 0x12666(%rip)     # 0x15140
movb $0x0, %al
callq 0xe5c0
movq %rax, 0x12660(%rip)     # 0x15148
movl $0x400, %edi            # imm = 0x400
callq 0xe900
movq %rax, 0x12657(%rip)     # 0x15150
movl $0x400, %edi            # imm = 0x400
callq 0xec30
movq %rax, 0x1264e(%rip)     # 0x15158
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x8(%rcx), %eax
jge 0x2b42
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2b50
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2b11
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/generator.c
// Function: process_external_decl
static void process_external_decl(const ExternalDeclNode* node) {
    if (node->enum_specifier_node != NULL) {
        process_enum_specifier(node->enum_specifier_node);
    }

    if (node->declaration_node != NULL) {
        process_global_declaration(node->declaration_node);
    }

    if (node->func_def_node != NULL) {
        process_func_def(node->func_def_node);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2b74
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2bb0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2b8c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2c20
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2ba2
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3150
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/generator.c
// Function: process_enum_specifier
static void process_enum_specifier(const EnumSpecifierNode* node) {
    const EnumeratorListNode* enumerator_list_node = node->enumerator_list_node;
    const Vector* identifiers = enumerator_list_node->identifiers;

    for (int i = 0; i < identifiers->size; ++i) {
        strintmap_put(enum_map, identifiers->elements[i], i);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x2c0f
movq 0x1256b(%rip), %rdi     # 0x15158
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl -0x1c(%rbp), %edx
callq 0xec80
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2bda
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/generator.c
// Function: process_func_def
static void process_func_def(const FuncDefNode* node) {
    localvar_list = create_vector();
    current_offset = 0;

    const DeclaratorNode* declarator_node = node->declarator_node;
    const DirectDeclaratorNode* direct_declarator_node = declarator_node->direct_declarator_node;
    printf(".global %s\n", get_ident_from_direct_declarator(direct_declarator_node));
    printf("%s:\n",        get_ident_from_direct_declarator(direct_declarator_node));

    const int localvar_size = calc_localvar_size_in_compound_stmt(node->compound_stmt_node);
    const int arg_size      = calc_arg_size(node);

    // prologue
    printf("  push rbp\n");
    printf("  mov rbp, rsp\n");
    printf("  sub rsp, %d\n", (localvar_size + arg_size));

    process_func_declarator(declarator_node);
    process_compound_stmt(node->compound_stmt_node);

    // epilogue
    if (ret_label != NULL) {
        printf("%s:\n", ret_label);
    }
    printf("  mov rsp, rbp\n");
    printf("  pop rbp\n");
    printf("  ret\n");

    free(localvar_list);
    free(ret_label);
    ret_label = NULL;
    current_offset = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, %al
callq 0xe5c0
movq %rax, 0x11ffe(%rip)     # 0x15168
movl $0x0, 0x11ffc(%rip)     # 0x15170
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3810
movq %rax, %rsi
leaq 0xc42d(%rip), %rdi      # 0xf5cc
movb $0x0, %al
callq 0x1090
movq -0x18(%rbp), %rdi
callq 0x3810
movq %rax, %rsi
leaq 0xc434(%rip), %rdi      # 0xf5ed
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3850
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x38f0
movl %eax, -0x20(%rbp)
leaq 0xc444(%rip), %rdi      # 0xf627
movb $0x0, %al
callq 0x1090
leaq 0xc442(%rip), %rdi      # 0xf633
movb $0x0, %al
callq 0x1090
movl -0x1c(%rbp), %esi
addl -0x20(%rbp), %esi
leaq 0xc43e(%rip), %rdi      # 0xf643
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rdi
callq 0x3980
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x39d0
cmpq $0x0, 0x11f4e(%rip)     # 0x15178
je 0x3241
movq 0x11f45(%rip), %rsi     # 0x15178
leaq 0xc3b3(%rip), %rdi      # 0xf5ed
movb $0x0, %al
callq 0x1090
leaq 0xc40a(%rip), %rdi      # 0xf652
movb $0x0, %al
callq 0x1090
leaq 0xc40c(%rip), %rdi      # 0xf662
movb $0x0, %al
callq 0x1090
leaq 0xc409(%rip), %rdi      # 0xf66d
movb $0x0, %al
callq 0x1090
movq 0x11ef6(%rip), %rdi     # 0x15168
callq 0x1030
movq 0x11efa(%rip), %rdi     # 0x15178
callq 0x1030
movq $0x0, 0x11eea(%rip) # 0x15178
movl $0x0, 0x11ed8(%rip)     # 0x15170
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/generator.c
// Function: get_array_size_from_constant_expr
static int get_array_size_from_constant_expr(const ConditionalExprNode* node) {
    return node->logical_or_expr_node
               ->logical_and_expr_node
               ->inclusive_or_expr_node
               ->exclusive_or_expr_node
               ->and_expr_node
               ->equality_expr_node
               ->relational_expr_node
               ->shift_expr_node
               ->additive_expr_node
               ->multiplicative_expr_node
               ->cast_expr_node
               ->unary_expr_node
               ->postfix_expr_node
               ->primary_expr_node
               ->constant_node
               ->integer_constant;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movl 0x4(%rax), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/generator.c
// Function: get_identifier_direct_declarator
static const DirectDeclaratorNode* get_identifier_direct_declarator(const DirectDeclaratorNode* node) {
    const DirectDeclaratorNode* current = node;
    while (current->direct_declarator_node != NULL) {
        current = current->direct_declarator_node;
    }

    return current;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x36d9
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x36c0
movq -0x10(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/generator.c
// Function: is_int_constant
static bool is_int_constant(const AssignExprNode* node) {
     return (CONST_INT == node->conditional_expr_node
                              ->logical_or_expr_node
                              ->logical_and_expr_node
                              ->inclusive_or_expr_node
                              ->exclusive_or_expr_node
                              ->and_expr_node
                              ->equality_expr_node
                              ->relational_expr_node
                              ->shift_expr_node
                              ->additive_expr_node
                              ->multiplicative_expr_node
                              ->cast_expr_node
                              ->unary_expr_node
                              ->postfix_expr_node
                              ->primary_expr_node
                              ->constant_node
                              ->const_type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
sete %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/generator.c
// Function: get_character_constant
static const char* get_character_constant(const AssignExprNode* node) {
    return node->conditional_expr_node
               ->logical_or_expr_node
               ->logical_and_expr_node
               ->inclusive_or_expr_node
               ->exclusive_or_expr_node
               ->and_expr_node
               ->equality_expr_node
               ->relational_expr_node
               ->shift_expr_node
               ->additive_expr_node
               ->multiplicative_expr_node
               ->cast_expr_node
               ->unary_expr_node
               ->postfix_expr_node
               ->primary_expr_node
               ->constant_node
               ->character_constant;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/generator.c
// Function: get_ident_from_direct_declarator
static const char* get_ident_from_direct_declarator(const DirectDeclaratorNode* node) {
    const DirectDeclaratorNode* current = node;
    while (current->direct_declarator_node != NULL) {
        current = current->direct_declarator_node;
    }

    return current->identifier;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3839
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x3820
movq -0x10(%rbp), %rax
movq (%rax), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/generator.c
// Function: calc_localvar_size_in_compound_stmt
static int calc_localvar_size_in_compound_stmt(const CompoundStmtNode* node) {
    if (node == NULL) {
        return 0;
    }

    int size = 0;
    for (int i = 0; i < node->block_item_nodes->size; ++i) {
        const BlockItemNode* block_item_node = node->block_item_nodes->elements[i];
        if (block_item_node->declaration_node != NULL) {
            size += calc_localvar_size_in_declaration(block_item_node->declaration_node);
        } else {
            size += calc_localvar_size_in_stmt(block_item_node->stmt_node);
        }
    }

    return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x386c
movl $0x0, -0x4(%rbp)
jmp 0x38e3
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x8(%rcx), %eax
jge 0x38dd
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x38bd
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x3a20
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x38d0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3b00
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x38d2
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x387a
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/generator.c
// Function: calc_arg_size
static int calc_arg_size(const FuncDefNode* node) {
    const DeclaratorNode* declarator_node = node->declarator_node;
    if (declarator_node == NULL) {
        return 0;
    }

    const DirectDeclaratorNode* direct_declarator_node = declarator_node->direct_declarator_node;
    const ParamTypeListNode*    param_type_list_node   = direct_declarator_node->param_type_list_node;
    if (param_type_list_node == NULL) {
        return 0;
    }

    int cnt = 0;
    const ParamListNode* current = param_type_list_node->param_list_node;
    while (current != NULL) {
        ++cnt;
        current = current->param_list_node;
    }

    return cnt * 8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3914
movl $0x0, -0x4(%rbp)
jmp 0x3976
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x393c
movl $0x0, -0x4(%rbp)
jmp 0x3976
movl $0x0, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x396d
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x394f
movl -0x2c(%rbp), %eax
shll $0x3, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/generator.c
// Function: process_func_declarator
static void process_func_declarator(const DeclaratorNode* node) {
    const DirectDeclaratorNode* direct_declarator_node = node->direct_declarator_node;
    const ParamTypeListNode* param_type_list_node = direct_declarator_node->param_type_list_node;
    if (param_type_list_node == NULL) {
        return;
    }

    const ParamListNode* param_list_node = param_type_list_node->param_list_node;
    process_args(param_list_node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x39ad
jmp 0x39c2
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3e00
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/generator.c
// Function: calc_localvar_size_in_declaration
static int calc_localvar_size_in_declaration(const DeclarationNode* node) {
    const int var_size = get_varsize_from_decl_specifier_nodes(node->decl_specifier_nodes);

    int size = 0;
    const Vector* init_declarator_nodes = node->init_declarator_nodes;
    for (int i = 0; i < init_declarator_nodes->size; ++i) {
        const InitDeclaratorNode* init_declarator_node = init_declarator_nodes->elements[i];
        const DeclaratorNode* declarator_node = init_declarator_node->declarator_node;
        const DirectDeclaratorNode* direct_declarator_node = declarator_node->direct_declarator_node;

        if (declarator_node->pointer_node != NULL) {
            size += 8;
        }
        else if (direct_declarator_node->conditional_expr_node == NULL) {
            size += var_size;
        } 
        else {
            const int array_size = get_array_size_from_constant_expr(direct_declarator_node->conditional_expr_node);
            size += (array_size * var_size);
        }
    }

    return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3ba0
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x3ae9
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3aa4
movl -0x10(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x10(%rbp)
jmp 0x3ad9
movq -0x38(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x3aba
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x3ad7
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3660
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
imull -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x3ad9
jmp 0x3adb
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3a55
movl -0x10(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)