LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x83b6(%rip), %r15      # 0xa2f9
movl 0x18(%r14), %edi
callq 0x529d
movl %ebx, %edi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1566
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1f6b
leal 0x2(%rbx), %esi
callq 0x19f0
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x1f84
addl $0x2, %ebx
movl %ebx, %esi
callq 0x1da0
movq 0x10(%r14), %r14
jmp 0x1f43
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8396(%rip), %r15      # 0xa337
movl %ebx, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1566
movq (%r14), %r13
testq %r13, %r13
je 0x2005
leal 0x2(%rbx), %edi
leaq 0x8387(%rip), %rsi      # 0xa346
xorl %eax, %eax
callq 0x1566
movq (%r13), %rax
cmpl $0x0, 0x8(%rax)
jle 0x1ff4
leal 0x4(%rbx), %ebp
xorl %r12d, %r12d
movq (%rax), %rax
movq (%rax,%r12,8), %rdi
movl %ebp, %esi
callq 0x1707
incq %r12
movq (%r13), %rax
movslq 0x8(%rax), %rcx
cmpq %rcx, %r12
jl 0x1fd6
movq 0x8(%r13), %rdi
testq %rdi, %rdi
je 0x2005
leal 0x4(%rbx), %esi
callq 0x1741
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x2013
addl $0x2, %ebx
jmp 0x1fa1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x2e42
movq %rdi, %rbx
movq (%rdi), %rax
cmpl $0x0, 0x8(%rax)
jle 0x2e42
xorl %r15d, %r15d
xorl %ebp, %ebp
movq %rbx, 0x10(%rsp)
movq (%rax), %rax
movq (%rax,%r15,8), %rax
movq (%rax), %r12
testq %r12, %r12
je 0x2e20
movq (%r12), %r13
xorl %r14d, %r14d
cmpl $0x0, 0x8(%r13)
movl $0x0, %eax
jle 0x2da1
movl %ebp, 0xc(%rsp)
xorl %ebx, %ebx
movq (%r13), %rcx
movq (%rcx,%rbx,8), %rcx
movq (%rcx), %rbp
testq %rbp, %rbp
je 0x2d85
movl (%rbp), %ecx
cmpl $0x7, %ecx
je 0x2d6c
movl $0x8, %eax
cmpl $0x5, %ecx
jne 0x2d85
movq 0x8(%rbp), %rax
movq (%rax), %rsi
movq 0xc3be(%rip), %rdi      # 0xf128
jmp 0x2d77
movq 0xc3b5(%rip), %rdi      # 0xf128
movq 0x10(%rbp), %rsi
callq 0x8def
movq (%rax), %rax
movl 0x8(%rax), %eax
shll $0x3, %eax
testq %rbp, %rbp
jne 0x2d98
incq %rbx
movslq 0x8(%r13), %rcx
cmpq %rcx, %rbx
jl 0x2d3a
xorl %eax, %eax
movq 0x10(%rsp), %rbx
movl 0xc(%rsp), %ebp
movq 0x8(%r12), %rdx
movslq 0x8(%rdx), %rcx
testq %rcx, %rcx
jle 0x2e2c
movq (%rdx), %rdx
xorl %esi, %esi
xorl %r14d, %r14d
movq (%rdx,%rsi,8), %rdi
movq (%rdi), %rdi
cmpq $0x0, (%rdi)
je 0x2dca
addl $0x8, %r14d
jmp 0x2e16
movq 0x8(%rdi), %rdi
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x2e13
movq (%rdi), %rdi
movq (%rdi), %rdi
movq (%rdi), %rdi
movq (%rdi), %rdi
movq (%rdi), %rdi
movq (%rdi), %rdi
movq 0x8(%rdi), %rdi
movq 0x8(%rdi), %rdi
movq (%rdi), %rdi
movq 0x8(%rdi), %rdi
movq 0x8(%rdi), %rdi
movq (%rdi), %rdi
movq (%rdi), %rdi
movq (%rdi), %rdi
movq (%rdi), %rdi
movl 0x4(%rdi), %edi
imull %eax, %edi
addl %edi, %r14d
jmp 0x2e16
addl %eax, %r14d
incq %rsi
cmpq %rsi, %rcx
jne 0x2db7
jmp 0x2e2c
movq 0x8(%rax), %rdi
callq 0x2e9c
movl %eax, %r14d
addl %r14d, %ebp
incq %r15
movq (%rbx), %rax
movslq 0x8(%rax), %rcx
cmpq %rcx, %r15
jl 0x2d0e
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/generator.c
// Function: calc_localvar_size_in_stmt
static int calc_localvar_size_in_stmt(const StmtNode* node) {
    if (node->labeled_stmt_node != NULL) {
        return calc_localvar_size_in_labeled_stmt(node->labeled_stmt_node);
    }
    else if (node->compound_stmt_node != NULL) {
        return calc_localvar_size_in_compound_stmt(node->compound_stmt_node);
    }
    else if (node->selection_stmt_node != NULL) {
        return calc_localvar_size_in_selection_stmt(node->selection_stmt_node);
    }
    else if (node->itr_stmt_node != NULL) {
        return calc_localvar_size_in_itr_stmt(node->itr_stmt_node);
    }

    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
movq (%rdi), %rax
testq %rax, %rax
je 0x2eb0
movq 0x10(%rax), %rdi
jmp 0x2ea2
movq 0x10(%rdi), %rax
testq %rax, %rax
jne 0x2edc
movq 0x18(%rdi), %r14
testq %r14, %r14
je 0x2ee9
movq 0x10(%r14), %rdi
callq 0x2e9c
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x2f9e
addl %eax, %ebx
jmp 0x2ea2
movq %rax, %rdi
callq 0x2cdb
jmp 0x2f9e
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x2f8b
movq 0x28(%rax), %rdx
movslq 0x8(%rdx), %rcx
testq %rcx, %rcx
jle 0x2f8f
movq (%rdx), %rdx
xorl %esi, %esi
xorl %r14d, %r14d
movq (%rdx,%rsi,8), %rdi
movq 0x8(%rdi), %r8
movslq 0x8(%r8), %rdi
testq %rdi, %rdi
jle 0x2f81
movq (%r8), %r8
xorl %r9d, %r9d
movq (%r8,%r9,8), %r10
movq (%r10), %r10
movq 0x8(%r10), %r10
movq 0x18(%r10), %r10
testq %r10, %r10
je 0x2f75
movq (%r10), %r10
movq (%r10), %r10
movq (%r10), %r10
movq (%r10), %r10
movq (%r10), %r10
movq (%r10), %r10
movq 0x8(%r10), %r10
movq 0x8(%r10), %r10
movq (%r10), %r10
movq 0x8(%r10), %r10
movq 0x8(%r10), %r10
movq (%r10), %r10
movq (%r10), %r10
movq (%r10), %r10
movq (%r10), %r10
movl 0x4(%r10), %r10d
leal (%r14,%r10,8), %r14d
jmp 0x2f79
addl $0x8, %r14d
incq %r9
cmpq %r9, %rdi
jne 0x2f26
incq %rsi
cmpq %rcx, %rsi
jne 0x2f0f
jmp 0x2f92
xorl %eax, %eax
jmp 0x2f9e
xorl %r14d, %r14d
movq 0x8(%rax), %rdi
callq 0x2e9c
addl %r14d, %ebx
addl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/generator.c
// Function: process_type_specifier_in_local
static Type* process_type_specifier_in_local(const TypeSpecifierNode* node) {
    Type* type = calloc(1, sizeof(Type));

    switch (node->type_specifier) {
    case TYPE_VOID: { 
        type->base_type = VAR_VOID;
        type->type_size = 8;
        return type;
    }
    case TYPE_CHAR: { 
        type->base_type = VAR_CHAR;
        type->type_size = 1;
        return type;
    }
    case TYPE_INT: {
        type->base_type = VAR_INT;
        type->type_size = 8;
        return type;
    }
    case TYPE_DOUBLE: { 
        type->base_type = VAR_DOUBLE;
        type->type_size = 8;
        return type;
    }
    case TYPE_STRUCT: { 
        type->base_type = VAR_STRUCT;   

        type->struct_info = strptrmap_get(struct_map, node->struct_specifier_node->identifier); 
        if (type->struct_info == NULL) {
            error("Invalid sturct name=\"%s\"\n", node->struct_specifier_node->identifier);
            return NULL;
        }

        type->type_size = type->struct_info->size;
        return type;
    } 
    case TYPE_TYPEDEFNAME: { 
        type->base_type = VAR_STRUCT;   

        type->struct_info = strptrmap_get(struct_map, node->struct_name);
        if (type->struct_info == NULL) {
            error("Invalid sturct name=\"%s\"\n", node->struct_name);
            return NULL;
        }

        type->type_size = type->struct_info->size;
        return type;
    } 
    default: { 
        return NULL;
    }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x20, %esi
callq 0x10c0
movq %rax, %rbx
movl (%r14), %eax
xorl %r15d, %r15d
decl %eax
cmpl $0x6, %eax
ja 0x3068
leaq 0x74cc(%rip), %rcx      # 0xa4a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movabsq $0x800000000, %rax      # imm = 0x800000000
jmp 0x3038
movabsq $0x800000002, %rax      # imm = 0x800000002
jmp 0x3038
movl $0x5, (%rbx)
movq 0xc11e(%rip), %rdi      # 0xf128
movq 0x10(%r14), %rsi
callq 0x8def
movq %rax, 0x18(%rbx)
testq %rax, %rax
jne 0x305f
movq 0x10(%r14), %rsi
jmp 0x3078
movabsq $0x100000001, %rax      # imm = 0x100000001
jmp 0x3038
movabsq $0x800000003, %rax      # imm = 0x800000003
movq %rax, (%rbx)
jmp 0x3065
movl $0x5, (%rbx)
movq 0xc0de(%rip), %rdi      # 0xf128
movq 0x8(%r14), %rax
movq (%rax), %rsi
callq 0x8def
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x3071
movl 0x8(%rax), %eax
movl %eax, 0x4(%rbx)
movq %rbx, %r15
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%r14), %rax
movq (%rax), %rsi
leaq 0x7581(%rip), %rdi      # 0xa600
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x8a7c
jmp 0x3068
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/generator.c
// Function: process_conditional_expr
static void process_conditional_expr(const ConditionalExprNode* node) {
    // <logical-or-expression>
    if (node->conditional_expr_node == NULL) {
        process_logical_or_expr(node->logical_or_expr_node);
    }
    // <logical-or-expression> ? <expression> : <conditional-expression>
    else {
        const char* label1 = get_label();
        const char* label2 = get_label();
 
        process_logical_or_expr(node->logical_or_expr_node);
        printf("  pop rax\n");
        printf("  cmp rax, 0\n");
        printf("  je %s\n", label1);
        process_expr(node->expr_node);
        printf("  jmp %s\n", label2);
        printf("%s:\n", label1);
        process_conditional_expr(node->conditional_expr_node);
        printf("%s:\n", label2);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x378d
callq 0x489a
movq %rax, %r15
callq 0x489a
movq %rax, %r14
movq (%rbx), %rdi
callq 0x37c8
leaq 0x7233(%rip), %rdi      # 0xa94f
callq 0x1070
leaq 0x7231(%rip), %rdi      # 0xa959
callq 0x1070
leaq 0x6f16(%rip), %rdi      # 0xa64a
movq %r15, %rsi
xorl %eax, %eax
callq 0x10a0
movq 0x8(%rbx), %rdi
callq 0x3819
leaq 0x6f05(%rip), %rdi      # 0xa653
movq %r14, %rsi
xorl %eax, %eax
callq 0x10a0
leaq 0x6e4b(%rip), %r12      # 0xa5aa
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x10a0
movq 0x10(%rbx), %rdi
callq 0x36e7
movq %r12, %rdi
movq %r14, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10a0
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x37c8
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/generator.c
// Function: process_logical_or_expr
static void process_logical_or_expr(const LogicalOrExprNode* node) {
    // <logical-and-expression>
    if (node->logical_or_expr_node == NULL) {
        process_logical_and_expr(node->logical_and_expr_node);
    }
    // <logical-or-expression> || <logical-and-expression>
    else {
        process_logical_or_expr(node->logical_or_expr_node);
        process_logical_and_expr(node->logical_and_expr_node);

        printf("  pop rdi\n");
        printf("  pop rax\n");
        printf("  or rax, rdi\n");
        printf("  push rax\n");
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x3813
callq 0x37c8
movq (%rbx), %rdi
callq 0x3844
leaq 0x7142(%rip), %rdi      # 0xa92b
callq 0x1070
leaq 0x715a(%rip), %rdi      # 0xa94f
callq 0x1070
leaq 0x6fa7(%rip), %rdi      # 0xa7a8
callq 0x1070
leaq 0x7128(%rip), %rdi      # 0xa935
popq %rbx
jmp 0x1070
movq (%rbx), %rdi
popq %rbx
jmp 0x3844
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/generator.c
// Function: process_expr
static void process_expr(const ExprNode* node) {
    // <assignment-expression>
    if (node->expr_node == NULL) {
        process_assign_expr(node->assign_expr_node);
    }
    // <expression> , <assignment-expression>
    else {
        const ExprNode* current = node;
        while (current->expr_node != NULL) {
            process_assign_expr(current->assign_expr_node);
            current = current->expr_node;
        }
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x383b
cmpq $0x0, 0x8(%rbx)
je 0x3839
movq (%rbx), %rdi
callq 0x3501
movq 0x8(%rbx), %rbx
jmp 0x3824
popq %rbx
retq
movq (%rbx), %rdi
popq %rbx
jmp 0x3501
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/generator.c
// Function: process_logical_and_expr
static void process_logical_and_expr(const LogicalAndExprNode* node) {
    // <inclusive-or-expression>
    if (node->logical_and_expr_node == NULL) {
        process_inclusive_or_expr(node->inclusive_or_expr_node);
    }
    // <logical-and-expression> && <inclusive-or-expression>
    else {
        char* label1 = get_label();
        char* label2 = get_label();
        process_logical_and_expr(node->logical_and_expr_node);
        printf("  pop rax\n");
        printf("  cmp rax, 0\n");
        printf("  je %s\n", label1);
        process_inclusive_or_expr(node->inclusive_or_expr_node);
        printf("  pop rax\n");
        printf("  cmp rax, 0\n");
        printf("  je %s\n", label1);
        printf("  push 1\n");
        printf("  jmp %s\n", label2);
        printf("%s:\n", label1);
        printf("  push 0\n");
        printf("%s:\n", label2);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
cmpq $0x0, 0x8(%rdi)
je 0x3937
callq 0x489a
movq %rax, %r14
callq 0x489a
movq %rax, %rbx
movq 0x8(%r15), %rdi
callq 0x3844
leaq 0x70d8(%rip), %rdi      # 0xa94f
callq 0x1070
leaq 0x70d6(%rip), %rdi      # 0xa959
callq 0x1070
leaq 0x6dbb(%rip), %rdi      # 0xa64a
movq %r14, %rsi
xorl %eax, %eax
callq 0x10a0
movq (%r15), %rax
cmpq $0x0, 0x8(%rax)
jne 0x38bf
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0x38bf
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0x38bf
movq (%rax), %rdi
callq 0x3965
leaq 0x7089(%rip), %rdi      # 0xa94f
callq 0x1070
leaq 0x7087(%rip), %rdi      # 0xa959
callq 0x1070
leaq 0x6d6c(%rip), %rdi      # 0xa64a
movq %r14, %rsi
xorl %eax, %eax
callq 0x10a0
leaq 0x6fcc(%rip), %rdi      # 0xa8bb
callq 0x1070
leaq 0x6d58(%rip), %rdi      # 0xa653
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10a0
leaq 0x6c9e(%rip), %r15      # 0xa5aa
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x10a0
leaq 0x6e96(%rip), %rdi      # 0xa7b6
callq 0x1070
movq %r15, %rdi
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x10a0
movq (%r15), %rax
cmpq $0x0, 0x8(%rax)
jne 0x3955
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0x3955
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x395b
popq %rbx
popq %r14
popq %r15
retq
movq (%rax), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3965
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/generator.c
// Function: process_equality_expr
static void process_equality_expr(const EqualityExprNode* node) {
    switch (node->cmp_type) {
    // <relational-expression>
    case CMP_NONE: {
        process_relational_expr(node->relational_expr_node);
        break;
    }
    // <equality-expression> == <relational-expression>
    case CMP_EQ: {
        process_equality_expr(node->equality_expr_node);
        process_relational_expr(node->relational_expr_node);

        printf("  pop rdi\n");
        printf("  pop rax\n");
        printf("  cmp rax, rdi\n");
        printf("  sete al\n");
        printf("  movzb rax, al\n");
        printf("  push rax\n");

        break;
    }
    // <equality-expression> != <relational-expression>
    case CMP_NE: {
        process_equality_expr(node->equality_expr_node);
        process_relational_expr(node->relational_expr_node);

        printf("  pop rdi\n");
        printf("  pop rax\n");
        printf("  cmp rax, rdi\n");
        printf("  setne al\n");
        printf("  movzb rax, al\n");
        printf("  push rax\n");

        break;
    }
    default:{
        break;
    }
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x4, %eax
je 0x39c6
cmpl $0x3, %eax
je 0x3987
testl %eax, %eax
jne 0x3a21
movq 0x8(%rbx), %rdi
popq %rbx
jmp 0x3a23
movq 0x10(%rbx), %rdi
callq 0x3965
movq 0x8(%rbx), %rdi
callq 0x3a23
leaq 0x6f8b(%rip), %rdi      # 0xa92b
callq 0x1070
leaq 0x6fa3(%rip), %rdi      # 0xa94f
callq 0x1070
leaq 0x6f88(%rip), %rdi      # 0xa940
callq 0x1070
leaq 0x6e6b(%rip), %rdi      # 0xa82f
jmp 0x3a03
movq 0x10(%rbx), %rdi
callq 0x3965
movq 0x8(%rbx), %rdi
callq 0x3a23
leaq 0x6f4c(%rip), %rdi      # 0xa92b
callq 0x1070
leaq 0x6f64(%rip), %rdi      # 0xa94f
callq 0x1070
leaq 0x6f49(%rip), %rdi      # 0xa940
callq 0x1070
leaq 0x6dbc(%rip), %rdi      # 0xa7bf
callq 0x1070
leaq 0x6e2a(%rip), %rdi      # 0xa839
callq 0x1070
leaq 0x6f1a(%rip), %rdi      # 0xa935
popq %rbx
jmp 0x1070
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/generator.c
// Function: process_additive_expr
static void process_additive_expr(const AdditiveExprNode* node) {
    // <multiplicative-expression>
    if (node->additive_expr_node == NULL) {
        process_multiplicative_expr(node->multiplicative_expr_node);
    }
    //  <additive-expression> + <multiplicative-expression>
    else if (node->operator_type == OP_ADD) {
        process_additive_expr(node->additive_expr_node);
        process_multiplicative_expr(node->multiplicative_expr_node);

        printf("  pop rdi\n");
        printf("  pop rax\n");
        printf("  add rax, rdi\n");
        printf("  push rax\n");
    }
    // <additive-expression> - <multiplicative-expression>
    else if (node->operator_type == OP_SUB) {
        process_additive_expr(node->additive_expr_node);
        process_multiplicative_expr(node->multiplicative_expr_node);

        printf("  pop rdi\n");
        printf("  pop rax\n");
        printf("  sub rax, rdi\n");
        printf("  push rax\n");
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x3be4
movl (%rbx), %eax
cmpl $0xb, %eax
je 0x3beb
cmpl $0xc, %eax
jne 0x3c2a
callq 0x3b9c
movq 0x8(%rbx), %rdi
callq 0x3c2c
leaq 0x6d61(%rip), %rdi      # 0xa92b
callq 0x1070
leaq 0x6d79(%rip), %rdi      # 0xa94f
callq 0x1070
leaq 0x6c3e(%rip), %rdi      # 0xa820
jmp 0x3c18
movq 0x8(%rbx), %rdi
popq %rbx
jmp 0x3c2c
callq 0x3b9c
movq 0x8(%rbx), %rdi
callq 0x3c2c
leaq 0x6d2b(%rip), %rdi      # 0xa92b
callq 0x1070
leaq 0x6d43(%rip), %rdi      # 0xa94f
callq 0x1070
leaq 0x6ccb(%rip), %rdi      # 0xa8e3
callq 0x1070
leaq 0x6d11(%rip), %rdi      # 0xa935
popq %rbx
jmp 0x1070
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/generator.c
// Function: process_multiplicative_expr
static void process_multiplicative_expr(const MultiPlicativeExprNode* node) {
    // <cast-expression>
    if (node->multiplicative_expr_node == NULL) {
        process_cast_expr(node->cast_expr_node);
    }
    //   <multiplicative-expression> * <cast-expression>
    // | <multiplicative-expression> / <cast-expression>
    // | <multiplicative-expression> % <cast-expression>
    else if (node->operator_type == OP_MUL) {
        process_multiplicative_expr(node->multiplicative_expr_node);
        process_cast_expr(node->cast_expr_node);

        printf("  pop rdi\n");
        printf("  pop rax\n");
        printf("  imul rax, rdi\n");
        printf("  push rax\n");
    }
    else if (node->operator_type == OP_DIV) {
        process_multiplicative_expr(node->multiplicative_expr_node);
        process_cast_expr(node->cast_expr_node);

        printf("  pop rdi\n");
        printf("  pop rax\n");
        printf("  cqo\n");
        printf("  idiv rdi\n");
        printf("  push rax\n");
    }
    else if (node->operator_type == OP_MOD) {
        process_multiplicative_expr(node->multiplicative_expr_node);
        process_cast_expr(node->cast_expr_node);

        printf("  pop rdi\n");
        printf("  pop rax\n");
        printf("  cqo\n");
        printf("  idiv rdi\n");
        printf("  push rdx\n");
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x3c85
movl (%rbx), %eax
cmpl $0xf, %eax
je 0x3ce8
cmpl $0xe, %eax
je 0x3c99
cmpl $0xd, %eax
jne 0x3c97
callq 0x3c2c
movq 0x8(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3c64
callq 0x3d3b
leaq 0x6cc0(%rip), %rdi      # 0xa92b
callq 0x1070
leaq 0x6cd8(%rip), %rdi      # 0xa94f
callq 0x1070
leaq 0x6b8d(%rip), %rdi      # 0xa810
jmp 0x3cda
movq 0x8(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3c97
popq %rbx
jmp 0x3d3b
popq %rbx
retq
callq 0x3c2c
movq 0x8(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3caf
callq 0x3d3b
leaq 0x6c75(%rip), %rdi      # 0xa92b
callq 0x1070
leaq 0x6c8d(%rip), %rdi      # 0xa94f
callq 0x1070
leaq 0x6b31(%rip), %rdi      # 0xa7ff
callq 0x1070
leaq 0x6b2b(%rip), %rdi      # 0xa805
callq 0x1070
leaq 0x6c4f(%rip), %rdi      # 0xa935
jmp 0x3d35
callq 0x3c2c
movq 0x8(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3cfe
callq 0x3d3b
leaq 0x6c26(%rip), %rdi      # 0xa92b
callq 0x1070
leaq 0x6c3e(%rip), %rdi      # 0xa94f
callq 0x1070
leaq 0x6ae2(%rip), %rdi      # 0xa7ff
callq 0x1070
leaq 0x6adc(%rip), %rdi      # 0xa805
callq 0x1070
leaq 0x6abf(%rip), %rdi      # 0xa7f4
popq %rbx
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/generator.c
// Function: get_localvar
static LocalVar* get_localvar(const char* str) {
    for (int i = 0; i < localvar_list->size; ++i) {
        LocalVar* localvar = localvar_list->elements[i];
        if (strcmp(localvar->name, str) == 0) {
            return localvar;
        }
    }

    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xae62(%rip), %rax      # 0xf140
movslq 0x8(%rax), %r15
testq %r15, %r15
jle 0x4310
movq %rdi, %rbx
movq (%rax), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rbp
movq 0x8(%rbp), %rdi
movq %rbx, %rsi
callq 0x10d0
testl %eax, %eax
cmoveq %rbp, %r14
je 0x4313
incq %r13
cmpq %r13, %r15
jne 0x42f0
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/generator.c
// Function: get_globalvar
static GlobalVar* get_globalvar(const char* str) {
    for (int i = 0; i < globalvar_list->size; ++i) {
        GlobalVar* gv = globalvar_list->elements[i];
        if (strcmp(gv->name, str) == 0) {
            return gv;
        }
    }

    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xade9(%rip), %rax      # 0xf120
movslq 0x8(%rax), %r15
testq %r15, %r15
jle 0x4369
movq %rdi, %rbx
movq (%rax), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rbp
movq 0x8(%rbp), %rdi
movq %rbx, %rsi
callq 0x10d0
testl %eax, %eax
cmoveq %rbp, %r14
je 0x436c
incq %r13
cmpq %r13, %r15
jne 0x4349
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/generator.c
// Function: process_constant_node
static void process_constant_node(const ConstantNode* node) {
    switch (node->const_type) {
    case CONST_BYTE: {
        printf("  push %d\n", node->integer_constant);
        intstack_push(size_stack, 1);
        break;
    }
    case CONST_INT: {
        printf("  push %d\n", node->integer_constant);
        intstack_push(size_stack, 8);
        break;
    }
    case CONST_STR: {
        const char* label = get_string_label();
        printf(".data\n");
        printf("%s:\n", label);
        printf("  .string \"%s\"\n", node->character_constant);
        printf(".text\n");
        printf("  lea rax, %s[rip]\n", label);
        printf("  push rax\n");
        break;
    }
    case CONST_FLOAT: {
        break;
    }
    default: {
        error("Invalid ConstType.\n");
        break;
    }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl (%rdi), %eax
cmpq $0x3, %rax
ja 0x4730
movq %rdi, %rbx
leaq 0x5f13(%rip), %rcx      # 0xa580
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x4(%rbx), %esi
leaq 0x5fdd(%rip), %rdi      # 0xa65d
xorl %eax, %eax
callq 0x10a0
movq 0xaa8a(%rip), %rdi      # 0xf118
movl $0x8, %esi
jmp 0x4724
callq 0x2c9e
movq %rax, %r14
leaq 0x624b(%rip), %rdi      # 0xa8f2
callq 0x1070
leaq 0x5ef7(%rip), %rdi      # 0xa5aa
movq %r14, %rsi
xorl %eax, %eax
callq 0x10a0
movq 0x10(%rbx), %rsi
leaq 0x5ef3(%rip), %rdi      # 0xa5bb
xorl %eax, %eax
callq 0x10a0
leaq 0x6222(%rip), %rdi      # 0xa8f8
callq 0x1070
leaq 0x5fbf(%rip), %rdi      # 0xa6a1
movq %r14, %rsi
xorl %eax, %eax
callq 0x10a0
leaq 0x6242(%rip), %rdi      # 0xa935
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1070
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x4(%rbx), %esi
leaq 0x5f4c(%rip), %rdi      # 0xa65d
xorl %eax, %eax
callq 0x10a0
movq 0xa9f9(%rip), %rdi      # 0xf118
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8c38
leaq 0x5f7e(%rip), %rdi      # 0xa6b5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8a7c
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/generator.c
// Function: process_identifier_right
static void process_identifier_right(const char* identifier) {
    // enum 
    if (strintmap_contains(enum_map, identifier)) {
        printf("  push %d\n", strintmap_get(enum_map, identifier));
        return;
    } 

    // local variable
    const LocalVar* lv = get_localvar(identifier);
    if (lv != NULL) {
        printf("  lea rax, [rbp-%d]\n", lv->offset);
        if (lv->type->array_size == 0) { 
            if (lv->type->type_size == 1 && lv->type->ptr_count == 0) {
                printf("  movzx eax, BYTE PTR [rax]\n");
            } else { 
                printf("  mov rax, [rax]\n");
            }
        } 
        printf("  push rax\n");
        intstack_push(size_stack, lv->type->size);
        stack_push(type_stack, lv->type);

        return;
    } 

    // global variable
    const GlobalVar* gv = get_globalvar(identifier);
    printf("  lea rax, %s[rip]\n", gv->name);
    if (gv->type->array_size == 0) {
        if (gv->type->type_size == 1 && gv->type->ptr_count == 0) {
            printf("  movzx eax, BYTE PTR [rax]\n");
        } else { 
            printf("  mov rax, [rax]\n");
        }
    }
    printf("  push rax\n");
    intstack_push(size_stack, gv->type->size);
    stack_push(type_stack, gv->type);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0xa9dd(%rip), %rdi      # 0xf130
movq %r14, %rsi
callq 0x8f37
testb %al, %al
je 0x4785
movq 0xa9ca(%rip), %rdi      # 0xf130
movq %r14, %rsi
callq 0x8f9a
leaq 0x5ee8(%rip), %rdi      # 0xa65d
movl %eax, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10a0
movq %r14, %rdi
callq 0x42cc
testq %rax, %rax
je 0x47a8
movq %rax, %rbx
movl 0x14(%rax), %esi
leaq 0x5e85(%rip), %rdi      # 0xa624
xorl %eax, %eax
callq 0x10a0
jmp 0x47c5
movq %r14, %rdi
callq 0x4325
movq %rax, %rbx
movq 0x8(%rax), %rsi
leaq 0x5ee3(%rip), %rdi      # 0xa6a1
xorl %eax, %eax
callq 0x10a0
movq (%rbx), %rax
cmpl $0x0, 0xc(%rax)
jne 0x47e6
cmpl $0x1, 0x4(%rax)
jne 0x47da
cmpl $0x0, 0x10(%rax)
je 0x481a
leaq 0x611d(%rip), %rdi      # 0xa8fe
callq 0x1070
leaq 0x6148(%rip), %rdi      # 0xa935
callq 0x1070
movq 0xa91f(%rip), %rdi      # 0xf118
movq (%rbx), %rax
movl 0x8(%rax), %esi
callq 0x8c38
movq 0xa8fd(%rip), %rdi      # 0xf108
movq (%rbx), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8baf
leaq 0x60ee(%rip), %rdi      # 0xa90f
jmp 0x47e1
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/generator.c
// Function: process_identifier_left
static void process_identifier_left(const char* identifier) {
    const LocalVar* lv = get_localvar(identifier);
    if (lv != NULL) {
        printf("  lea rax, [rbp-%d]\n", lv->offset);
        printf("  push rax\n");
        stack_push(type_stack, lv->type);
    } 
    else {
        const GlobalVar* gv = get_globalvar(identifier);    
        printf("  lea rax, %s[rip]\n", gv->name);
        printf("  push rax\n");
        stack_push(type_stack, gv->type);
    }
    intstack_push(size_stack, 8);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x42cc
testq %rax, %rax
je 0x484a
movq %rax, %rbx
movl 0x14(%rax), %esi
leaq 0x5de3(%rip), %rdi      # 0xa624
xorl %eax, %eax
callq 0x10a0
jmp 0x4867
movq %r14, %rdi
callq 0x4325
movq %rax, %rbx
movq 0x8(%rax), %rsi
leaq 0x5e41(%rip), %rdi      # 0xa6a1
xorl %eax, %eax
callq 0x10a0
leaq 0x60c7(%rip), %rdi      # 0xa935
callq 0x1070
movq 0xa88e(%rip), %rdi      # 0xf108
movq (%rbx), %rsi
callq 0x8baf
movq 0xa88f(%rip), %rdi      # 0xf118
movl $0x8, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8c38
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/generator.c
// Function: process_labeled_stmt
static void process_labeled_stmt(const LabeledStmtNode* node) {
    switch (node->labeled_stmt_type) {
    case LABELED_CASE: {
        process_conditional_expr(node->conditional_expr_node);

        printf("  pop rdi\n");
        printf("  pop rax\n");
        printf("  push rax\n");
        printf("  cmp rax, rdi\n");
        char* current_stmt_label = stack_top(current_stmt_label_stack);
        if (node->stmt_node->labeled_stmt_node == NULL) {
            const char* label = get_label();
            printf("  jne %s\n", label);
            printf("%s:\n", current_stmt_label);
            process_stmt(node->stmt_node);
            printf("%s:\n", label); 
           
            stack_pop(current_stmt_label_stack);
            stack_push(current_stmt_label_stack, get_label()); 
        } else {
            printf("  je %s\n", current_stmt_label);
            process_labeled_stmt(node->stmt_node->labeled_stmt_node);
        }

        break;
    }
    case LABELED_DEFAULT: {
        process_stmt(node->stmt_node);
        break;
    }
    default: {
        break;
    }
    } 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6063(%rip), %r15      # 0xa94f
leaq 0x6042(%rip), %r12      # 0xa935
leaq 0x6046(%rip), %r13      # 0xa940
leaq 0x5d49(%rip), %rbp      # 0xa64a
movl (%rbx), %eax
testl %eax, %eax
jne 0x4963
movq 0x8(%rbx), %rdi
callq 0x36e7
leaq 0x6014(%rip), %rdi      # 0xa92b
callq 0x1070
movq %r15, %rdi
callq 0x1070
movq %r12, %rdi
callq 0x1070
movq %r13, %rdi
callq 0x1070
movq 0xa7d5(%rip), %rdi      # 0xf110
callq 0x8bf2
movq %rax, %r14
movq 0x10(%rbx), %rax
cmpq $0x0, (%rax)
je 0x498e
movq %rbp, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x10a0
movq 0x10(%rbx), %rax
movq (%rax), %rbx
jmp 0x4901
cmpl $0x1, %eax
jne 0x497f
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3264
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x489a
movq %rax, %r15
leaq 0x5d42(%rip), %rdi      # 0xa6df
movq %rax, %rsi
xorl %eax, %eax
callq 0x10a0
leaq 0x5bfc(%rip), %r12      # 0xa5aa
movq %r12, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x10a0
movq 0x10(%rbx), %rdi
callq 0x3264
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x10a0
movq 0xa738(%rip), %rdi      # 0xf110
callq 0x8c06
movq 0xa72c(%rip), %rbx      # 0xf110
callq 0x489a
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8baf
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/generator.c
// Function: process_jump_stmt
static void process_jump_stmt(const JumpStmtNode* node) {
    switch (node->jump_type) {
    case JMP_CONTINUE: {
        const char* label1 = stack_top(continue_label_stack);
        printf("  jmp %s\n", label1);
        break;
    }
    case JMP_BREAK: {
        const char* label2 = stack_top(break_label_stack);
        printf("  jmp %s\n", label2);
        break;
    }
    case JMP_RETURN: {
        if (node->expr_node != NULL) {
            process_expr(node->expr_node);
        }
        printf("  pop rax\n");
        if (ret_label == NULL) {
            ret_label = get_label();
        }
        printf("  jmp %s\n", ret_label);
        break;
    }
    default: {
        break;
    }
    }
}

// Assembly:
pushq %rax
movl (%rdi), %eax
cmpl $0x2, %eax
je 0x4a2d
cmpl $0x1, %eax
je 0x4a1c
testl %eax, %eax
jne 0x4a73
movq 0xa6e6(%rip), %rdi      # 0xf100
jmp 0x4a23
movq 0xa6d5(%rip), %rdi      # 0xf0f8
callq 0x8bf2
movq %rax, %rsi
jmp 0x4a64
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x4a3b
callq 0x3819
leaq 0x5f0d(%rip), %rdi      # 0xa94f
callq 0x1070
cmpq $0x0, 0xa701(%rip)      # 0xf150
jne 0x4a5d
callq 0x489a
movq %rax, 0xa6f3(%rip)      # 0xf150
movq 0xa6ec(%rip), %rsi      # 0xf150
leaq 0x5be8(%rip), %rdi      # 0xa653
xorl %eax, %eax
popq %rcx
jmp 0x10a0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/generator.c
// Function: process_selection_stmt
static void process_selection_stmt(const SelectionStmtNode* node) {
    switch (node->selection_type) {
    case SELECT_IF: {
        const char* label1 = get_label();

        process_expr(node->expr_node);
        printf("  pop rax\n");
        printf("  cmp rax, 0\n");
        printf("  je %s\n", label1);
        process_stmt(node->stmt_node_0);
        printf("%s:\n", label1);

        break;
    }
    case SELECT_IF_ELSE: {
        const char* label2 = get_label();
        const char* label3 = get_label();

        process_expr(node->expr_node);
        printf("  pop rax\n");
        printf("  cmp rax, 0\n");
        printf("  je %s\n", label2);
        process_stmt(node->stmt_node_0);
        printf("  jmp %s\n", label3);
        printf("%s:\n", label2);
        process_stmt(node->stmt_node_1);
        printf("%s:\n", label3);

        break;
    }
    case SELECT_SWITCH: {
        char* label4 = get_label();
        stack_push(break_label_stack, label4);
        stack_push(current_stmt_label_stack, get_label()); 

        process_expr(node->expr_node);
        process_stmt(node->stmt_node_0);

        printf("%s:\n", label4);
        stack_pop(break_label_stack);
        stack_pop(current_stmt_label_stack); 
        break;
    }
    default: {
        break;
    }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x2, %eax
je 0x4b75
cmpl $0x1, %eax
je 0x4ae4
testl %eax, %eax
jne 0x4be9
callq 0x489a
movq %rax, %r14
movq 0x8(%rbx), %rdi
callq 0x3819
leaq 0x5e9f(%rip), %rdi      # 0xa94f
callq 0x1070
leaq 0x5e9d(%rip), %rdi      # 0xa959
callq 0x1070
leaq 0x5b82(%rip), %rdi      # 0xa64a
movq %r14, %rsi
xorl %eax, %eax
callq 0x10a0
movq 0x10(%rbx), %rdi
callq 0x3264
leaq 0x5ac8(%rip), %rdi      # 0xa5aa
jmp 0x4b60
callq 0x489a
movq %rax, %r15
callq 0x489a
movq %rax, %r14
movq 0x8(%rbx), %rdi
callq 0x3819
leaq 0x5e4b(%rip), %rdi      # 0xa94f
callq 0x1070
leaq 0x5e49(%rip), %rdi      # 0xa959
callq 0x1070
leaq 0x5b2e(%rip), %rdi      # 0xa64a
movq %r15, %rsi
xorl %eax, %eax
callq 0x10a0
movq 0x10(%rbx), %rdi
callq 0x3264
leaq 0x5b1d(%rip), %rdi      # 0xa653
movq %r14, %rsi
xorl %eax, %eax
callq 0x10a0
leaq 0x5a63(%rip), %r12      # 0xa5aa
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x10a0
movq 0x18(%rbx), %rdi
callq 0x3264
movq %r12, %rdi
movq %r14, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10a0
callq 0x489a
movq %rax, %r14
movq 0xa574(%rip), %rdi      # 0xf0f8
movq %rax, %rsi
callq 0x8baf
movq 0xa57d(%rip), %r15      # 0xf110
callq 0x489a
movq %r15, %rdi
movq %rax, %rsi
callq 0x8baf
movq 0x8(%rbx), %rdi
callq 0x3819
movq 0x10(%rbx), %rdi
callq 0x3264
leaq 0x59ee(%rip), %rdi      # 0xa5aa
movq %r14, %rsi
xorl %eax, %eax
callq 0x10a0
movq 0xa52b(%rip), %rdi      # 0xf0f8
callq 0x8c06
movq 0xa537(%rip), %rdi      # 0xf110
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8c06
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/minic.c
// Function: main
int main(int argc, char** argv) {
    if (argc < 2) {
        usage();
        return -1;
    }

    int arg_index = 1;
    if (strncmp("-d", argv[1], 2) == 0 || strncmp("--debug", argv[1], 7) == 0) {
        debug_flag = true;
        arg_index = 2;
    } 

    char* addr = read_file(argv[arg_index]);
    if (addr == NULL) {
        error("Failed to load file.\n"); 
        return -1;
    }

    const Vector* vec = tokenize(addr);
    if (vec == NULL) {
        error("Failed to tokenize.\n");
        return -1;
    }

#ifdef MINIC_DEV
    if (debug_flag) {
        dump_tokens(vec);
    }
#endif

    const Vector* processed_vec = preprocess(vec); 
    if (processed_vec == NULL) {
        error("Failed to preprocess.\n");
        return -1;
    }

#ifdef MINIC_DEV
    if (debug_flag) {
        dump_tokens(processed_vec);
    }
#endif

    const TransUnitNode* node = parse(processed_vec);
    if (node == NULL) {
        error("Failed to parse.\n");
        return -1;
    }

#ifdef MINIC_DEV
    if (debug_flag) {
        dump_nodes(node);
    }
#endif

    gen(node);

    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, %edi
jg 0x4c12
leaq 0x5dbd(%rip), %rdi      # 0xa9c5
callq 0x1070
jmp 0x4cc4
movq %rsi, %rbx
movq 0x8(%rsi), %r14
leaq 0x5d46(%rip), %rdi      # 0xa966
movl $0x2, %edx
movq %r14, %rsi
callq 0x1060
testl %eax, %eax
je 0x4c4e
leaq 0x5d31(%rip), %rdi      # 0xa969
movl $0x7, %edx
movq %r14, %rsi
callq 0x1060
movl $0x1, %ecx
testl %eax, %eax
jne 0x4c5a
movb $0x1, 0xa503(%rip)      # 0xf158
movl $0x2, %ecx
movq (%rbx,%rcx,8), %rdi
callq 0x8a8d
testq %rax, %rax
je 0x4c9b
movq %rax, %rdi
callq 0x7e18
testq %rax, %rax
je 0x4ca4
movq %rax, %rdi
callq 0x7a0c
testq %rax, %rax
je 0x4cad
movq %rax, %rdi
callq 0x4cd4
testq %rax, %rax
je 0x4cb6
movq %rax, %rdi
callq 0x2208
xorl %eax, %eax
jmp 0x4cc9
leaq 0x5ccf(%rip), %rdi      # 0xa971
jmp 0x4cbd
leaq 0x5cdc(%rip), %rdi      # 0xa987
jmp 0x4cbd
leaq 0x5ce8(%rip), %rdi      # 0xa99c
jmp 0x4cbd
leaq 0x5cf6(%rip), %rdi      # 0xa9b3
xorl %eax, %eax
callq 0x8a7c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/parser.c
// Function: create_decl_specifier_node
static DeclSpecifierNode* create_decl_specifier_node(const Vector* vec, int* index) {
    DeclSpecifierNode* decl_specifier_node = calloc(1, sizeof(DeclSpecifierNode));

    const Token* token = vec->elements[*index];
    if (token->type == TK_STATIC) {
        decl_specifier_node->is_static = true;
        ++(*index);
    }
    else if (token->type == TK_CONST) {
        decl_specifier_node->is_const = true;
        ++(*index);
    }
    else if (is_type_specifier(vec, *index)) {
        decl_specifier_node->type_specifier_node = create_type_specifier_node(vec, index);
        if (decl_specifier_node->type_specifier_node == NULL) {
            error("Failed to create type-specifier node.\n");
            return NULL;
        }
    }

    return decl_specifier_node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x10, %esi
callq 0x10c0
movq %rax, %rbx
movq (%r15), %rax
movslq (%r14), %rsi
movq (%rax,%rsi,8), %rax
movl (%rax), %eax
cmpl $0xc, %eax
je 0x5570
cmpl $0x4, %eax
jne 0x5583
movb $0x1, 0x9(%rbx)
jmp 0x5574
movb $0x1, 0x8(%rbx)
leal 0x1(%rsi), %eax
movl %eax, (%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0x5ac1
testb %al, %al
je 0x557a
movq %r15, %rdi
movq %r14, %rsi
callq 0x5aef
movq %rax, (%rbx)
testq %rax, %rax
jne 0x557a
leaq 0x5985(%rip), %rdi      # 0xaf2e
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x8a7c
jmp 0x557a
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/parser.c
// Function: create_compound_stmt_node
static CompoundStmtNode* create_compound_stmt_node(const Vector* vec, int* index) {
    CompoundStmtNode* compound_stmt_node = malloc(sizeof(CompoundStmtNode));

    compound_stmt_node->block_item_nodes = create_vector();

    const Token* token = vec->elements[*index];
    if (token->type != TK_LBRCKT) {
        error("Invalid token[%d]=\"%s\".\n", *index, decode_token_type(token->type));
        return NULL;
    }
    ++(*index);

    while (true) {
        token = vec->elements[*index];
        if (token->type == TK_RBRCKT) {
            ++(*index);
            break;
        }

        BlockItemNode* block_item_node = create_block_item_node(vec, index);
        if (block_item_node == NULL) {
            error("Failed to create block-item node.\n");
            return NULL; 
        }

        vector_push_back(compound_stmt_node->block_item_nodes, block_item_node);
    }

    return compound_stmt_node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0x8, %edi
callq 0x1100
movq %rax, %rbx
xorl %eax, %eax
callq 0x8b08
movq %rax, %r12
movq %rbx, (%rsp)
movq %rax, (%rbx)
movq (%r15), %rax
movslq (%r14), %r13
movq (%rax,%r13,8), %rax
movl (%rax), %edi
cmpl $0x23, %edi
jne 0x5a87
leal 0x1(%r13), %eax
movl %eax, (%r14)
movq (%r15), %rax
movslq (%r14), %r13
movq (%rax,%r13,8), %rax
movl (%rax), %ebx
cmpl $0x24, %ebx
je 0x5aa4
movl $0x1, %edi
movl $0x10, %esi
callq 0x10c0
movq %rax, %rbp
movq %r15, %rdi
movl %r13d, %esi
callq 0x5ac1
andl $-0x9, %ebx
cmpl $0x4, %ebx
je 0x5a36
testb %al, %al
jne 0x5a36
movq %r15, %rdi
movq %r14, %rsi
callq 0x706c
movq %rax, 0x8(%rbp)
leaq 0x5ab6(%rip), %rdi      # 0xb4ea
jmp 0x5a4c
movq %r15, %rdi
movq %r14, %rsi
callq 0x53b5
movq %rax, (%rbp)
leaq 0x5a79(%rip), %rdi      # 0xb4c5
testq %rax, %rax
jne 0x5a5a
xorl %eax, %eax
callq 0x8a7c
xorl %ebp, %ebp
testq %rbp, %rbp
je 0x5a6c
movq %r12, %rdi
movq %rbp, %rsi
callq 0x8b3b
jmp 0x5a7a
leaq 0x5a2f(%rip), %rdi      # 0xb4a2
xorl %eax, %eax
callq 0x8a7c
testq %rbp, %rbp
jne 0x59e0
xorl %ebx, %ebx
jmp 0x5aaf
callq 0x8a51
leaq 0x535d(%rip), %rdi      # 0xadf0
xorl %ebx, %ebx
movl %r13d, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x8a7c
jmp 0x5aaf
leal 0x1(%r13), %eax
movl %eax, (%r14)
movq (%rsp), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/parser.c
// Function: is_type_specifier
static bool is_type_specifier(const Vector* vec, int index) {
    const Token* token = vec->elements[index];
    const int type = token->type;
    return (type == TK_VOID   || type == TK_CHAR || type == TK_INT
         || type == TK_DOUBLE || type == TK_STRUCT
         || (token->str != NULL && strptrmap_contains(typedef_map, token->str))
    );
}

// Assembly:
movq (%rdi), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %rcx
movl (%rcx), %edx
addl $-0x6, %edx
movb $0x1, %al
cmpl $0x5, %edx
jb 0x5aee
movq 0x8(%rcx), %rsi
testq %rsi, %rsi
je 0x5aec
movq 0x9679(%rip), %rdi      # 0xf160
jmp 0x8d8c
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/parser.c
// Function: create_specifier_qualifier_node
static SpecifierQualifierNode* create_specifier_qualifier_node(const Vector* vec, int* index) {
    SpecifierQualifierNode* specifier_qualifier_node = calloc(1, sizeof(SpecifierQualifierNode));

    const Token* token = vec->elements[*index];
    if (is_type_specifier(vec, *index)) {
        specifier_qualifier_node->type_specifier_node = create_type_specifier_node(vec, index);
        if (specifier_qualifier_node->type_specifier_node == NULL) {
            error("Failed to create type-specifier node.\n");
            return NULL;
        }
    } 
    else if (token->type == TK_CONST) {
        ++(*index);
        specifier_qualifier_node->is_const = true;
    }
    else {
        error("Invalid token[%d]=\"%s\".\n", *index, decode_token_type(token->type));
        return NULL;
    }

    return specifier_qualifier_node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x10, %esi
callq 0x10c0
movq %rax, %rbx
movq (%r15), %rax
movslq (%r14), %rsi
movq (%rax,%rsi,8), %r12
movq %r15, %rdi
callq 0x5ac1
testb %al, %al
je 0x5e8e
movq %r15, %rdi
movq %r14, %rsi
callq 0x5aef
movq %rax, (%rbx)
testq %rax, %rax
jne 0x5ebf
leaq 0x50ab(%rip), %rdi      # 0xaf2e
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x8a7c
jmp 0x5ebf
movl (%r12), %edi
movl (%r14), %ebp
cmpl $0xc, %edi
jne 0x5ea5
incl %ebp
movl %ebp, (%r14)
movb $0x1, 0x8(%rbx)
jmp 0x5ebf
callq 0x8a51
leaq 0x4f3f(%rip), %rdi      # 0xadf0
xorl %ebx, %ebx
movl %ebp, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x8a7c
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/parser.c
// Function: create_pointer_node
static PointerNode* create_pointer_node(const Vector* vec, int* index) {
    PointerNode* pointer_node = malloc(sizeof(PointerNode));

    pointer_node->count = 1;
    const Token* token = vec->elements[*index];
    if (token->type != TK_ASTER) {
        error("Invalid token[%d]=\"%s\".\n", *index, decode_token_type(token->type));
        return NULL;
    }
    ++(*index);

    token = vec->elements[*index];
    while (token->type == TK_ASTER) {
        ++(pointer_node->count);
        ++(*index);
        token = vec->elements[*index];
    } 
    
    return pointer_node;  
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0x4, %edi
callq 0x1100
movq %rax, %rbx
movl $0x1, (%rax)
movq (%r14), %rcx
movslq (%r15), %r14
movq (%rcx,%r14,8), %rax
movl (%rax), %edi
cmpl $0x1a, %edi
jne 0x5f34
leaq 0x1(%r14), %rdx
movl %edx, (%r15)
movq 0x8(%rcx,%r14,8), %rax
cmpl $0x1a, (%rax)
jne 0x5f4f
movl (%rbx), %eax
movslq %edx, %rdx
leaq (%rcx,%rdx,8), %rcx
addq $0x8, %rcx
addl $0x2, %r14d
incl %eax
movl %r14d, (%r15)
movq (%rcx), %rdx
addq $0x8, %rcx
incl %r14d
cmpl $0x1a, (%rdx)
je 0x5f1c
movl %eax, (%rbx)
jmp 0x5f4f
callq 0x8a51
leaq 0x4eb0(%rip), %rdi      # 0xadf0
xorl %ebx, %ebx
movl %r14d, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x8a7c
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/parser.c
// Function: create_expr_node
static ExprNode* create_expr_node(const Vector* vec, int* index) {
    ExprNode* expr_node = calloc(1, sizeof(ExprNode));

    expr_node->assign_expr_node = create_assign_expr_node(vec, index);
    if (expr_node->assign_expr_node == NULL) {
        error("Failed to create assignment-expression node.\n");
        return NULL;
    }

    ExprNode* current = expr_node;
    const Token* token = vec->elements[*index];
    while (token->type == TK_COMMA) {
        ++(*index);

        ExprNode* p_expr_node = calloc(1, sizeof(ExprNode));

        p_expr_node->expr_node        = current;
        p_expr_node->assign_expr_node = create_assign_expr_node(vec, index);
        if (p_expr_node->assign_expr_node == NULL) {
            error("Failed to create assing-expression node.\n");
            return NULL;
        }

        token = vec->elements[*index];
        current = p_expr_node;
    }

    return current;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x10, %esi
callq 0x10c0
movq %rax, %rbx
movq %r15, %rdi
movq %r14, %rsi
callq 0x6e9d
movq %rax, (%rbx)
testq %rax, %rax
je 0x616d
movq (%r15), %rax
movslq (%r14), %rcx
movq (%rax,%rcx,8), %r12
cmpl $0x30, (%r12)
jne 0x617d
incl (%r14)
movl $0x1, %edi
movl $0x10, %esi
callq 0x10c0
movq %rax, %rbp
movq %rbx, 0x8(%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0x6e9d
movq %rax, %r13
movq %rax, (%rbp)
testq %rax, %rax
je 0x6156
movq (%r15), %rax
movslq (%r14), %rcx
movq (%rax,%rcx,8), %r12
movq %rbp, %rbx
jmp 0x6164
leaq 0x52ed(%rip), %rdi      # 0xb44a
xorl %eax, %eax
callq 0x8a7c
testq %r13, %r13
jne 0x6110
xorl %ebx, %ebx
jmp 0x617d
leaq 0x523a(%rip), %rdi      # 0xb3ae
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x8a7c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq