LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
cmpl $0x1, %edi
jg 0x495b
leaq 0x5071(%rip), %rdi      # 0x99c2
callq 0x1070
jmp 0x4a06
movq %rsi, %rbx
movq 0x8(%rsi), %rsi
movzbl (%rsi), %eax
subl $0x2d, %eax
jne 0x4975
movzbl 0x1(%rsi), %ecx
pushq $0x64
popq %rax
subl %ecx, %eax
jmp 0x4977
negl %eax
testl %eax, %eax
je 0x4992
leaq 0x4fe4(%rip), %rdi      # 0x9966
pushq $0x7
popq %rdx
callq 0x1060
testl %eax, %eax
je 0x4992
pushq $0x1
jmp 0x499b
movb $0x1, 0x97bf(%rip)      # 0xe158
pushq $0x2
popq %rax
movq (%rbx,%rax,8), %rdi
callq 0x80b9
testq %rax, %rax
je 0x49dd
movq %rax, %rdi
callq 0x74d8
testq %rax, %rax
je 0x49e6
movq %rax, %rdi
callq 0x714c
testq %rax, %rax
je 0x49ef
movq %rax, %rdi
callq 0x4a0c
testq %rax, %rax
je 0x49f8
movq %rax, %rdi
callq 0x21d0
xorl %eax, %eax
jmp 0x4a09
leaq 0x4f8a(%rip), %rdi      # 0x996e
jmp 0x49ff
leaq 0x4f97(%rip), %rdi      # 0x9984
jmp 0x49ff
leaq 0x4fa3(%rip), %rdi      # 0x9999
jmp 0x49ff
leaq 0x4fb1(%rip), %rdi      # 0x99b0
xorl %eax, %eax
callq 0x80a8
pushq $-0x1
popq %rax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/chgzm[P]minic/parser.c
// Function: create_declaration_node
static DeclarationNode* create_declaration_node(const Vector* vec, int* index) {
    DeclarationNode* declaration_node = malloc(sizeof(DeclarationNode));

    declaration_node->decl_specifier_nodes  = create_vector();
    declaration_node->init_declarator_nodes = create_vector();

    const Token* token = vec->elements[*index];
    while (is_declaration_specifier(vec, *index) && token->type != TK_SEMICOL) {
        DeclSpecifierNode* decl_specifier_node = create_decl_specifier_node(vec, index);
        if (decl_specifier_node == NULL) {
            error("Failed to create declaration-specifier node.\n");
            return NULL;
        }

        vector_push_back(declaration_node->decl_specifier_nodes, decl_specifier_node);
    }

    token = vec->elements[*index];
    while (token->type != TK_SEMICOL) {
        InitDeclaratorNode* init_declarator_node = create_init_declarator_node(vec, index);
        if (init_declarator_node == NULL) {
            error("Failed to create init-declarator node.\n");
            return NULL;
        }

        vector_push_back(declaration_node->init_declarator_nodes, init_declarator_node);

        token = vec->elements[*index];
        if (token->type == TK_COMMA) {
            ++(*index);
            token = vec->elements[*index];
        } 
    }
    ++(*index);

    return declaration_node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
pushq $0x10
popq %rdi
callq 0x1100
movq %rax, %rbp
xorl %eax, %eax
callq 0x812e
movq %rax, %r13
movq %rax, (%rbp)
xorl %eax, %eax
callq 0x812e
movq %rax, %r12
movq %rax, 0x8(%rbp)
movq (%r15), %rax
movslq (%r14), %rsi
movq (%rax,%rsi,8), %rbx
movq %r15, %rdi
callq 0x518f
testb %al, %al
je 0x50b9
cmpl $0x1f, (%rbx)
je 0x50b9
movq %r15, %rdi
movq %r14, %rsi
callq 0x51ae
testq %rax, %rax
je 0x5140
movq %r13, %rdi
movq %rax, %rsi
callq 0x8167
movl (%r14), %esi
jmp 0x5084
movq %rbp, (%rsp)
movq (%r15), %rcx
movl (%r14), %eax
pushq $0x1
popq %rbp
pushq $0x10
popq %r13
movslq %eax, %rdx
movq (%rcx,%rdx,8), %rdx
cmpl $0x1f, (%rdx)
je 0x514b
movq %rbp, %rdi
movq %r13, %rsi
callq 0x10c0
movq %rax, %rbx
movq %r15, %rdi
movq %r14, %rsi
callq 0x5227
movq %rax, (%rbx)
testq %rax, %rax
je 0x5156
movq (%r15), %rcx
movslq (%r14), %rax
movq (%rcx,%rax,8), %rcx
cmpl $0x1e, (%rcx)
jne 0x511f
incl %eax
movl %eax, (%r14)
movq %r15, %rdi
movq %r14, %rsi
callq 0x7041
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x515f
movq %r12, %rdi
movq %rbx, %rsi
callq 0x8167
movq (%r15), %rcx
movslq (%r14), %rax
movq (%rcx,%rax,8), %rdx
cmpl $0x30, (%rdx)
jne 0x50d1
incl %eax
movl %eax, (%r14)
jmp 0x50ca
leaq 0x4d6c(%rip), %rdi      # 0x9eb3
xorl %ebx, %ebx
jmp 0x5176
incl %eax
movl %eax, (%r14)
movq (%rsp), %rbx
jmp 0x517d
leaq 0x5543(%rip), %rdi      # 0xa6a0
jmp 0x5166
leaq 0x555d(%rip), %rdi      # 0xa6c3
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x80a8
leaq 0x5502(%rip), %rdi      # 0xa678
xorl %eax, %eax
callq 0x80a8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/chgzm[P]minic/parser.c
// Function: is_declaration_specifier
static bool is_declaration_specifier(const Vector* vec, int index) {
    const Token* token = vec->elements[index];
    const int type = token->type;
    return (is_type_specifier(vec, index)
         || type == TK_CONST
         || type == TK_STATIC
    );
}

// Assembly:
pushq %rbx
movq (%rdi), %rax
movslq %esi, %rsi
movq (%rax,%rsi,8), %rax
movl (%rax), %ebx
callq 0x5639
andl $-0x9, %ebx
cmpl $0x4, %ebx
sete %cl
orb %cl, %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x10c0
movq %rax, %rbx
movq (%r15), %rax
movslq (%r14), %rsi
movq (%rax,%rsi,8), %rax
movl (%rax), %eax
cmpl $0xc, %eax
je 0x51e3
cmpl $0x4, %eax
jne 0x51f6
movb $0x1, 0x9(%rbx)
jmp 0x51e7
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 0x5639
testb %al, %al
je 0x51ed
movq %r15, %rdi
movq %r14, %rsi
callq 0x5667
movq %rax, (%rbx)
testq %rax, %rax
jne 0x51ed
leaq 0x4d12(%rip), %rdi      # 0x9f2e
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x80a8
jmp 0x51ed
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x8
popq %rdi
callq 0x1100
movq %rax, %r13
xorl %eax, %eax
callq 0x812e
movq %rax, %r12
movq %rax, (%r13)
movq (%r15), %rax
movslq (%r14), %rbx
movq (%rax,%rbx,8), %rcx
movl (%rcx), %edi
cmpl $0x23, %edi
jne 0x55d7
movq %r13, (%rsp)
leal 0x1(%rbx), %ebp
movl %ebp, (%r14)
pushq $0x10
popq %r13
movslq %ebp, %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x24, (%rax)
je 0x55f4
pushq $0x1
popq %rdi
movq %r13, %rsi
callq 0x10c0
movq %rax, %rbx
movq %r15, %rdi
movl %ebp, %esi
callq 0x518f
movq %r15, %rdi
movq %r14, %rsi
testb %al, %al
je 0x55b6
callq 0x5042
movq %rax, (%rbx)
testq %rax, %rax
jne 0x55c4
jmp 0x55ff
callq 0x6889
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x5608
movq %r12, %rdi
movq %rbx, %rsi
callq 0x8167
movq (%r15), %rax
movl (%r14), %ebp
jmp 0x5579
callq 0x807a
leaq 0x480d(%rip), %rdi      # 0x9df0
xorl %r14d, %r14d
movl %ebx, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x80a8
jmp 0x5627
incl %ebp
movl %ebp, (%r14)
movq (%rsp), %r14
jmp 0x5627
leaq 0x4e9e(%rip), %rdi      # 0xa4a4
jmp 0x560f
leaq 0x4eba(%rip), %rdi      # 0xa4c9
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x80a8
leaq 0x4e61(%rip), %rdi      # 0xa481
xorl %eax, %eax
callq 0x80a8
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_O2/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 0x5666
movq 0x8(%rcx), %rsi
testq %rsi, %rsi
je 0x5664
movq 0x8b01(%rip), %rdi      # 0xe160
jmp 0x83c5
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x10c0
movq %rax, %rbx
movq (%r15), %rax
movslq (%r14), %rsi
movq (%rax,%rsi,8), %r12
movq %r15, %rdi
callq 0x5639
testb %al, %al
je 0x59d1
movq %r15, %rdi
movq %r14, %rsi
callq 0x5667
movq %rax, (%rbx)
testq %rax, %rax
jne 0x5a02
leaq 0x4568(%rip), %rdi      # 0x9f2e
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x80a8
jmp 0x5a02
movl (%r12), %edi
movl (%r14), %ebp
cmpl $0xc, %edi
jne 0x59e8
incl %ebp
movl %ebp, (%r14)
movb $0x1, 0x8(%rbx)
jmp 0x5a02
callq 0x807a
leaq 0x43fc(%rip), %rdi      # 0x9df0
xorl %ebx, %ebx
movl %ebp, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x80a8
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq %rdi, %r15
pushq $0x4
popq %rdi
callq 0x1100
movq %rax, %rbx
movl $0x1, (%rax)
movq (%r15), %rax
movslq (%r14), %r15
movq (%rax,%r15,8), %rcx
movl (%rcx), %edi
cmpl $0x1a, %edi
jne 0x5a62
leaq (%rax,%r15,8), %rax
addq $0x8, %rax
leal 0x1(%r15), %ecx
xorl %edx, %edx
leal (%rcx,%rdx), %esi
movl %esi, (%r14)
movq (%rax,%rdx,8), %rsi
cmpl $0x1a, (%rsi)
jne 0x5a7d
leal 0x2(%rdx), %esi
movl %esi, (%rbx)
incq %rdx
jmp 0x5a49
callq 0x807a
leaq 0x4382(%rip), %rdi      # 0x9df0
xorl %ebx, %ebx
movl %r15d, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x80a8
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/chgzm[P]minic/parser.c
// Function: create_conditional_expr_node
static ConditionalExprNode* create_conditional_expr_node(const Vector* vec, int* index) {
    ConditionalExprNode* conditional_expr_node = calloc(1, sizeof(ConditionalExprNode));

    conditional_expr_node->logical_or_expr_node  = create_logical_or_expr_node(vec, index);
    if (conditional_expr_node->logical_or_expr_node == NULL) {
        error("Failed to create logical-or-expression node.\n");
        return NULL;
    }

    const Token* token = vec->elements[*index];
    if (token->type == TK_QUESTION) {
        ++(*index);

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

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

        conditional_expr_node->conditional_expr_node = create_conditional_expr_node(vec, index);
        if (conditional_expr_node->conditional_expr_node == NULL) {
            error("Failed to create conditional-expression node.\n");
            return NULL;
        }
    }

    return conditional_expr_node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %r12
pushq $0x18
popq %rsi
movq %r12, %rdi
callq 0x10c0
movq %rax, (%rsp)
pushq $0x10
popq %rsi
movq %r12, %rdi
callq 0x10c0
movq %rax, %rbx
movq %r15, %rdi
movq %r14, %rsi
callq 0x5c70
movq %rax, (%rbx)
testq %rax, %rax
je 0x5b0f
pushq $0x1
popq %r13
pushq $0x10
popq %rbp
movq (%r15), %rcx
movslq (%r14), %rax
movq (%rcx,%rax,8), %rdx
cmpl $0x37, (%rdx)
jne 0x5b3f
incl %eax
movl %eax, (%r14)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x10c0
movq %rax, %r12
movq %rbx, 0x8(%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0x5c70
movq %rax, (%r12)
movq %r12, %rbx
testq %rax, %rax
jne 0x5ad2
leaq 0x45ea(%rip), %rdi      # 0xa100
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x80a8
leaq 0x455a(%rip), %rdi      # 0xa080
xorl %eax, %eax
callq 0x80a8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %rdx
movq %rbx, (%rdx)
movq %rdx, %rbx
movq (%rcx,%rax,8), %rcx
cmpl $0x2a, (%rcx)
jne 0x5b2d
incl %eax
movl %eax, (%r14)
movq %r15, %rdi
movq %r14, %rsi
callq 0x5bcf
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x5ba1
movq (%r15), %rax
movslq (%r14), %r12
movq (%rax,%r12,8), %rax
movl (%rax), %edi
cmpl $0x20, %edi
jne 0x5baf
leal 0x1(%r12), %eax
movl %eax, (%r14)
movq %r15, %rdi
movq %r14, %rsi
callq 0x5a86
movq %rax, 0x10(%rbx)
testq %rax, %rax
jne 0x5b2d
leaq 0x4532(%rip), %rdi      # 0xa0d1
jmp 0x5ba8
leaq 0x4506(%rip), %rdi      # 0xa0ae
xorl %ebx, %ebx
jmp 0x5b26
callq 0x807a
leaq 0x4235(%rip), %rdi      # 0x9df0
xorl %ebx, %ebx
movl %r12d, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x80a8
jmp 0x5b2d
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x10c0
movq %rax, %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6709
movq %rax, (%r12)
testq %rax, %rax
je 0x5c4d
pushq $0x1
popq %r13
pushq $0x10
popq %rbp
movq (%r14), %rcx
movslq (%rbx), %rax
movq (%rcx,%rax,8), %rcx
cmpl $0x30, (%rcx)
jne 0x5c5e
incl %eax
movl %eax, (%rbx)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x10c0
movq %rax, %r15
movq %r12, 0x8(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6709
movq %rax, (%r15)
movq %r15, %r12
testq %rax, %rax
jne 0x5c09
leaq 0x47de(%rip), %rdi      # 0xa429
jmp 0x5c54
leaq 0x475a(%rip), %rdi      # 0xa3ae
xorl %r12d, %r12d
xorl %eax, %eax
callq 0x80a8
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/chgzm[P]minic/parser.c
// Function: create_logical_and_expr_node
static LogicalAndExprNode* create_logical_and_expr_node(const Vector* vec, int* index) {
    LogicalAndExprNode* logical_and_expr_node = calloc(1, sizeof(LogicalAndExprNode));

    logical_and_expr_node->inclusive_or_expr_node = create_inclusive_or_expr_node(vec, index);
    if (logical_and_expr_node->inclusive_or_expr_node == NULL) {
        error("Failed to create inclusive-or-expression node.\n");
        return NULL;
    }

    const Token* token = vec->elements[*index];
    LogicalAndExprNode* current = logical_and_expr_node;
    while (token->type == TK_LOGAND) {
        ++(*index);

        LogicalAndExprNode* p_logical_and_expr_node = calloc(1, sizeof(LogicalAndExprNode));

        p_logical_and_expr_node->logical_and_expr_node  = current;
        p_logical_and_expr_node->inclusive_or_expr_node = create_inclusive_or_expr_node(vec, index);
        if (p_logical_and_expr_node->inclusive_or_expr_node == NULL) {
            error("Failed to create inclusive-or-expression node.\n");
            return NULL;
        }

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

    return current;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x10c0
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5d09
movq %rax, (%r15)
testq %rax, %rax
je 0x5ce6
pushq $0x1
popq %r12
pushq $0x10
popq %r13
movq (%r14), %rcx
movslq (%rbx), %rax
movq (%rcx,%rax,8), %rcx
cmpl $0x38, (%rcx)
jne 0x5cf7
incl %eax
movl %eax, (%rbx)
movq %r12, %rdi
movq %r13, %rsi
callq 0x10c0
movq %rax, %rbp
movq %r15, 0x8(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5d09
movq %rax, (%rbp)
movq %rbp, %r15
testq %rax, %rax
jne 0x5caa
leaq 0x4442(%rip), %rdi      # 0xa12f
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x80a8
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/chgzm[P]minic/parser.c
// Function: create_inclusive_or_expr_node
static InclusiveOrExprNode* create_inclusive_or_expr_node(const Vector* vec, int* index) {
    InclusiveOrExprNode* inclusive_or_expr_node = malloc(sizeof(InclusiveOrExprNode));

    inclusive_or_expr_node->inclusive_or_expr_node = NULL;
    inclusive_or_expr_node->exclusive_or_expr_node = create_exclusive_or_expr_node(vec, index);
    if (inclusive_or_expr_node->exclusive_or_expr_node  == NULL) {
        error("Failed to create exclusive-or-expression node.\n");
        return NULL;
    }

    return inclusive_or_expr_node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
pushq $0x10
popq %rbx
movq %rbx, %rdi
callq 0x1100
movq %rax, (%rsp)
andq $0x0, 0x8(%rax)
pushq $0x1
popq %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x10c0
movq %rax, 0x10(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x10c0
movq %rax, 0x8(%rsp)
pushq $0x18
popq %rsi
movq %r12, %rdi
callq 0x10c0
movq %rax, %r13
movq %r15, %rdi
movq %r14, %rsi
callq 0x5e49
movq %rax, 0x8(%r13)
testq %rax, %rax
je 0x5ddf
movq %r13, %rbp
movq (%r15), %rcx
movslq (%r14), %rax
movq (%rcx,%rax,8), %r12
movl (%r12), %ecx
addl $-0x33, %ecx
cmpl $0x1, %ecx
ja 0x5e23
incl %eax
movl %eax, (%r14)
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x10c0
movq %rax, %rbx
movq %rbp, 0x10(%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0x5e49
movq %rax, 0x8(%rbx)
cmpq $0x0, 0x8(%r13)
je 0x5ddf
movl (%r12), %eax
pushq $0x3
popq %rcx
cmpl $0x33, %eax
je 0x5dd8
movq %rbx, %rbp
cmpl $0x34, %eax
jne 0x5d7a
pushq $0x4
popq %rcx
movl %ecx, (%rbx)
movq %rbx, %rbp
jmp 0x5d7a
leaq 0x43fc(%rip), %rdi      # 0xa1e2
xorl %eax, %eax
callq 0x80a8
leaq 0x43c2(%rip), %rdi      # 0xa1b6
xorl %eax, %eax
callq 0x80a8
leaq 0x438d(%rip), %rdi      # 0xa18f
xorl %eax, %eax
callq 0x80a8
movq (%rsp), %rax
andq $0x0, (%rax)
leaq 0x4347(%rip), %rdi      # 0xa15f
xorl %eax, %eax
callq 0x80a8
xorl %eax, %eax
jmp 0x5e3a
movq 0x8(%rsp), %rax
movq %rbp, (%rax)
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq (%rsp), %rax
movq %rcx, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/chgzm[P]minic/parser.c
// Function: create_relational_expr_node
static RelationalExprNode* create_relational_expr_node(const Vector* vec, int* index) {
    RelationalExprNode* relational_expr_node = calloc(1, sizeof(RelationalExprNode));

    relational_expr_node->cmp_type             = CMP_NONE;
    relational_expr_node->shift_expr_node      = create_shift_expr(vec, index);
    if (relational_expr_node->shift_expr_node == NULL) {
        error("Failed to create shift-expression node.\n");
        return NULL;
    }
    
    RelationalExprNode* current = relational_expr_node;
    const Token* token = vec->elements[*index];
    while (token->type == TK_LANGLE || token->type == TK_RANGLE || token->type == TK_LE || token->type == TK_GE) {
        ++(*index);
    
        RelationalExprNode* parent = calloc(1, sizeof(EqualityExprNode));

        parent->relational_expr_node = current;
        parent->shift_expr_node      = create_shift_expr(vec, index);
        if (parent->shift_expr_node == NULL) {
            error("Failed to create shif-texpression node.\n");
            return NULL;
        }

        if      (token->type == TK_LANGLE) { parent->cmp_type = CMP_LT; }
        else if (token->type == TK_RANGLE) { parent->cmp_type = CMP_GT; }
        else if (token->type == TK_LE)     { parent->cmp_type = CMP_LE; }
        else if (token->type == TK_GE)     { parent->cmp_type = CMP_GE; }
     
        token = vec->elements[*index];
        current = parent;
    }

    return current;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x10c0
movq %rax, %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5f34
movq %rax, 0x8(%r12)
testq %rax, %rax
je 0x5f11
pushq $0x18
popq %rbp
movq (%r14), %rcx
movslq (%rbx), %rax
movq (%rcx,%rax,8), %r13
movl (%r13), %ecx
cmpq $0x36, %rcx
ja 0x5f22
movabsq $0x60018000000000, %rdx # imm = 0x60018000000000
btq %rcx, %rdx
jae 0x5f22
incl %eax
movl %eax, (%rbx)
pushq $0x1
popq %rdi
movq %rbp, %rsi
callq 0x10c0
movq %rax, %r15
movq %r12, 0x10(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5f34
movq %rax, 0x8(%r15)
testq %rax, %rax
je 0x5f08
movq %r15, %r12
movl (%r13), %eax
pushq $0x1
popq %rcx
cmpl $0x27, %eax
je 0x5eff
cmpl $0x36, %eax
je 0x5ef8
cmpl $0x35, %eax
je 0x5efc
cmpl $0x28, %eax
jne 0x5e84
pushq $0x2
jmp 0x5efe
pushq $0x6
jmp 0x5efe
pushq $0x5
popq %rcx
movl %ecx, (%r12)
jmp 0x5e84
leaq 0x432a(%rip), %rdi      # 0xa239
jmp 0x5f18
leaq 0x42f8(%rip), %rdi      # 0xa210
xorl %r12d, %r12d
xorl %eax, %eax
callq 0x80a8
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/chgzm[P]minic/parser.c
// Function: create_shift_expr
static ShiftExprNode* create_shift_expr(const Vector* vec, int* index) {
    ShiftExprNode* shift_expr_node = calloc(1, sizeof(ShiftExprNode));

    shift_expr_node->additive_expr_node = create_additive_expr_node(vec, index);
    if (shift_expr_node->additive_expr_node == NULL) {
        error("Failed to additive-expression node.\n");
        return NULL;
    }

    return shift_expr_node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %r12
pushq $0x10
popq %rsi
movq %r12, %rdi
callq 0x10c0
movq %rax, (%rsp)
pushq $0x18
popq %rsi
movq %r12, %rdi
callq 0x10c0
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x6005
movq %rax, 0x8(%r12)
testq %rax, %rax
je 0x5fcc
pushq $0x18
popq %r13
movq (%r15), %rcx
movslq (%r14), %rax
movq (%rcx,%rax,8), %rbx
movl (%rbx), %ecx
andl $-0x2, %ecx
cmpl $0x18, %ecx
jne 0x5fec
incl %eax
movl %eax, (%r14)
movq %r13, %rdi
callq 0x1100
movq %rax, %rbp
xorl %eax, %eax
cmpl $0x18, (%rbx)
setne %al
addl $0xb, %eax
movl %eax, (%rbp)
movq %r12, 0x10(%rbp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x6005
movq %rax, 0x8(%rbp)
movq %rbp, %r12
testq %rax, %rax
jne 0x5f7f
leaq 0x42b4(%rip), %rdi      # 0xa287
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x80a8
leaq 0x427f(%rip), %rdi      # 0xa262
xorl %eax, %eax
callq 0x80a8
jmp 0x5ff3
movq (%rsp), %rbx
movq %r12, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/chgzm[P]minic/parser.c
// Function: create_multiplicative_expr_node
static MultiPlicativeExprNode* create_multiplicative_expr_node(const Vector* vec, int* index) {
    MultiPlicativeExprNode* multiplicative_expr_node = calloc(1, sizeof(MultiPlicativeExprNode));

    multiplicative_expr_node->operator_type  = OP_NONE;
    multiplicative_expr_node->cast_expr_node = create_cast_expr_node(vec, index);
    if (multiplicative_expr_node->cast_expr_node == NULL) {
        error("Failed to create cast-expression node.\n");
        return NULL;
    }

    MultiPlicativeExprNode* current = multiplicative_expr_node;
    const Token* token = vec->elements[*index];
    while (token->type == TK_ASTER || token->type == TK_SLASH || token->type == TK_PER) {
        ++(*index);

        MultiPlicativeExprNode* p_multiplicative_expr_node = malloc(sizeof(MultiPlicativeExprNode));
        p_multiplicative_expr_node->multiplicative_expr_node = current;
        p_multiplicative_expr_node->cast_expr_node           = create_cast_expr_node(vec, index);
        if (p_multiplicative_expr_node->cast_expr_node == NULL) {
            error("Failed to create cast-expression node.\n");
            return NULL;
        }

        if      (token->type == TK_ASTER) { p_multiplicative_expr_node->operator_type = OP_MUL; }
        else if (token->type == TK_SLASH) { p_multiplicative_expr_node->operator_type = OP_DIV; }
        else if (token->type == TK_PER)   { p_multiplicative_expr_node->operator_type = OP_MOD; }

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

    return current;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x10c0
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x60c6
movq %rax, 0x8(%r15)
testq %rax, %rax
je 0x60a3
pushq $0x18
popq %r12
movq (%r14), %rcx
movslq (%rbx), %rax
movq (%rcx,%rax,8), %rbp
movl (%rbp), %ecx
cmpl $0x1d, %ecx
ja 0x60b4
movl $0x2c000000, %edx       # imm = 0x2C000000
btl %ecx, %edx
jae 0x60b4
incl %eax
movl %eax, (%rbx)
movq %r12, %rdi
callq 0x1100
movq %rax, %r13
movq %r15, 0x10(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x60c6
movq %rax, 0x8(%r13)
testq %rax, %rax
je 0x60a3
movq %r13, %r15
movl (%rbp), %eax
pushq $0xd
popq %rcx
cmpl $0x1a, %eax
je 0x609e
cmpl $0x1d, %eax
je 0x609b
cmpl $0x1b, %eax
jne 0x603c
pushq $0xe
jmp 0x609d
pushq $0xf
popq %rcx
movl %ecx, (%r15)
jmp 0x603c
leaq 0x420f(%rip), %rdi      # 0xa2b9
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x80a8
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/chgzm[P]minic/parser.c
// Function: create_cast_expr_node
static CastExprNode* create_cast_expr_node(const Vector* vec, int* index) {
    CastExprNode* cast_expr_node = calloc(1, sizeof(CastExprNode));

    cast_expr_node->unary_expr_node = create_unary_expr_node(vec, index);
    if (cast_expr_node->unary_expr_node == NULL) {
        error("Failed to create unary-expression node.\n");
        return NULL;
    }

    return cast_expr_node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x10c0
movq %rax, %rbx
movq %r15, %rdi
movq %r14, %rsi
callq 0x610b
movq %rax, (%rbx)
testq %rax, %rax
jne 0x6102
leaq 0x41e8(%rip), %rdi      # 0xa2e1
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x80a8
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/chgzm[P]minic/parser.c
// Function: create_param_declaration_node
static ParamDeclarationNode* create_param_declaration_node(const Vector* vec, int* index) {
    ParamDeclarationNode* param_declaration_node = calloc(1, sizeof(ParamDeclarationNode));

    param_declaration_node->decl_spec_nodes          = create_vector();

    while (is_declaration_specifier(vec, *index)) {
        DeclSpecifierNode* decl_spec_node = create_decl_specifier_node(vec, index);
        if (decl_spec_node == NULL) {
            error("Failed to create declaration-specifier node.\n");
            return NULL;
        }

        vector_push_back(param_declaration_node->decl_spec_nodes, decl_spec_node);
    }

    if (is_declarator(vec, *index)) {
        param_declaration_node->declarator_node = create_declarator_node(vec, index); 
    } 

    return param_declaration_node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x10c0
movq %rax, %rbx
xorl %eax, %eax
callq 0x812e
movq %rax, %r12
movq %rax, (%rbx)
movl (%r14), %esi
movq %r15, %rdi
callq 0x518f
testb %al, %al
je 0x6843
movq %r15, %rdi
movq %r14, %rsi
callq 0x51ae
testq %rax, %rax
je 0x686a
movq %r12, %rdi
movq %rax, %rsi
callq 0x8167
jmp 0x6817
movslq (%r14), %rax
movq (%r15), %rcx
movq (%rcx,%rax,8), %rax
movl (%rax), %eax
cmpl $0x1a, %eax
je 0x6859
cmpl $0x3, %eax
jne 0x687a
movq %r15, %rdi
movq %r14, %rsi
callq 0x5227
movq %rax, 0x8(%rbx)
jmp 0x687a
leaq 0x3642(%rip), %rdi      # 0x9eb3
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x80a8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/chgzm[P]minic/parser.c
// Function: create_initializer_node
static InitializerNode* create_initializer_node(const Vector* vec, int* index) {
    InitializerNode* initializer_node = calloc(1, sizeof(InitializerNode));

    const Token* token = vec->elements[*index];
    if (token->type == TK_LBRCKT) {
        ++(*index); 

        initializer_node->initializer_list_node = create_initializer_list_node(vec, index);
        if (initializer_node->initializer_list_node == NULL) {
            error("Failed to create initializer-list node.\n");
            return NULL;
        }

        token = vec->elements[*index];
        if (token->type != TK_RBRCKT) {
            error("Invalid token[%d]=\"%s\".\n", *index, decode_token_type(token->type));
            return NULL;
        }
        ++(*index); 
    }
    else {
        initializer_node->assign_expr_node = create_assign_expr_node(vec, index);
        if (initializer_node->assign_expr_node == NULL) {
            error("Failed to create assignment-expression node.\n");
            return NULL;
        }
    }

    return initializer_node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x10c0
movq %rax, %rbx
movq (%r15), %rcx
movslq (%r14), %rax
movq (%rcx,%rax,8), %rcx
cmpl $0x23, (%rcx)
jne 0x70fa
incl %eax
movl %eax, (%r14)
pushq $0x8
popq %rdi
callq 0x1100
movq %rax, %r12
xorl %eax, %eax
callq 0x812e
movq %rax, %r13
movq %rax, (%r12)
movq %r15, %rdi
movq %r14, %rsi
callq 0x7041
testq %rax, %rax
jne 0x70ca
leaq 0x361b(%rip), %rdi      # 0xa6c3
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x80a8
leaq 0x362f(%rip), %rdi      # 0xa6e7
jmp 0x7116
incl %ebp
movl %ebp, (%r14)
movq %r15, %rdi
movq %r14, %rsi
callq 0x7041
movq %r13, %rdi
movq %rax, %rsi
callq 0x8167
movq (%r15), %rax
movslq (%r14), %rbp
movq (%rax,%rbp,8), %rcx
cmpl $0x30, (%rcx)
je 0x70ba
movq %r12, 0x8(%rbx)
movq (%rax,%rbp,8), %rax
movl (%rax), %edi
cmpl $0x24, %edi
jne 0x711f
incl %ebp
movl %ebp, (%r14)
jmp 0x7139
movq %r15, %rdi
movq %r14, %rsi
callq 0x6709
movq %rax, (%rbx)
testq %rax, %rax
jne 0x7139
leaq 0x329a(%rip), %rdi      # 0xa3ae
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x80a8
jmp 0x7139
callq 0x807a
leaq 0x2cc5(%rip), %rdi      # 0x9df0
xorl %ebx, %ebx
movl %ebp, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x80a8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/chgzm[P]minic/util.c
// Function: read_file
char* read_file(const char* file_path) {
    FILE* fp = fopen(file_path, "r");
    if (fp == NULL) {
        return NULL;
    }

    fseek(fp, 0, SEEK_END);
    int fsize = ftell(fp);
    fseek(fp, 0, SEEK_SET);

    char* addr = calloc(fsize, sizeof(char) + 1);
    fread(addr, sizeof(char), fsize, fp);
    fclose(fp);

    return addr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x2bbf(%rip), %rsi      # 0xac84
callq 0x1140
testq %rax, %rax
je 0x8122
movq %rax, %rbx
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x1120
movq %rbx, %rdi
callq 0x10f0
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1120
movslq %r14d, %r15
pushq $0x2
popq %rsi
movq %r15, %rdi
callq 0x10c0
movq %rax, %r14
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x1080
movq %rbx, %rdi
callq 0x1090
jmp 0x8125
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/chgzm[P]minic/util.c
// Function: create_vector
Vector* create_vector() {
    Vector* vec   = malloc(sizeof(Vector));
    vec->elements = calloc(16, sizeof(void*));
    vec->capacity = 16;
    vec->size     = 0;

    return vec;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
pushq $0x10
popq %rbx
movq %rbx, %rdi
callq 0x1100
movq %rax, %r14
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x10c0
movq %rax, (%r14)
movabsq $0x1000000000, %rax     # imm = 0x1000000000
movq %rax, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/chgzm[P]minic/util.c
// Function: vector_push_back
void vector_push_back(Vector* vec, void* e) {
    if (vec->size == vec->capacity) {
        vec->capacity *= 2;
        vec->elements = realloc(vec->elements, sizeof(void*) * vec->capacity);
    }

    vec->elements[vec->size] = e;
    ++(vec->size);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movq (%rdi), %rax
cmpl 0xc(%rdi), %ecx
jne 0x8196
movslq %ecx, %rsi
addl %ecx, %ecx
movl %ecx, 0xc(%rbx)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x1130
movq %rax, (%rbx)
movl 0x8(%rbx), %ecx
movslq %ecx, %rcx
movq %r14, (%rax,%rcx,8)
incl %ecx
movl %ecx, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/chgzm[P]minic/util.c
// Function: create_stack
Stack* create_stack() {
    Stack* stack    = malloc(sizeof(Stack));
    stack->elements = calloc(16, sizeof(void*));
    stack->capacity = 16;
    stack->top      = -1;

    return stack;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
pushq $0x10
popq %rbx
movq %rbx, %rdi
callq 0x1100
movq %rax, %r14
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x10c0
movq %rax, (%r14)
movabsq $0x10ffffffff, %rax     # imm = 0x10FFFFFFFF
movq %rax, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/chgzm[P]minic/util.c
// Function: stack_push
void stack_push(Stack* stack, void* e) {
    ++(stack->top);
    if (stack->top == stack->capacity) {
        stack->capacity *= 2;
        stack->elements = realloc(stack->elements, sizeof(void*) * stack->capacity);
    }

    stack->elements[stack->top] = e;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq 0x8(%rdi), %rsi
incq %rsi
movl %esi, 0x8(%rdi)
movq (%rdi), %rax
cmpl 0xc(%rdi), %esi
jne 0x8218
movq %rdi, %r14
leal (%rsi,%rsi), %ecx
movl %ecx, 0xc(%rdi)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x1130
movq %rax, (%r14)
movl 0x8(%r14), %esi
movslq %esi, %rcx
movq %rbx, (%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/chgzm[P]minic/util.c
// Function: create_intstack
IntStack* create_intstack() {
    IntStack* stack = malloc(sizeof(Stack));
    stack->elements = malloc(sizeof(int) * 16);
    stack->capacity = 16;
    stack->top      = -1;

    return stack;
}

// Assembly:
pushq %rbx
pushq $0x10
popq %rdi
callq 0x1100
movq %rax, %rbx
pushq $0x40
popq %rdi
callq 0x1100
movq %rax, (%rbx)
movabsq $0x10ffffffff, %rax     # imm = 0x10FFFFFFFF
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/chgzm[P]minic/util.c
// Function: intstack_push
void intstack_push(IntStack* stack, int e) {
    ++(stack->top);
    if (stack->top == stack->capacity) {
        stack->capacity *= 2;
        stack->elements = realloc(stack->elements, sizeof(int) * stack->capacity);
    }

    stack->elements[stack->top] = e;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movslq 0x8(%rdi), %rsi
incq %rsi
movl %esi, 0x8(%rdi)
movq (%rdi), %rax
cmpl 0xc(%rdi), %esi
jne 0x829d
movq %rdi, %r14
leal (%rsi,%rsi), %ecx
movl %ecx, 0xc(%rdi)
shlq $0x3, %rsi
movq %rax, %rdi
callq 0x1130
movq %rax, (%r14)
movl 0x8(%r14), %esi
movslq %esi, %rcx
movl %ebx, (%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/chgzm[P]minic/util.c
// Function: intstack_top
int intstack_top(IntStack* stack) {
    if (stack->top < 0) {
        fprintf(stderr, "stack is empty.\n");
        exit(-1);
    }

    return stack->elements[stack->top];
}

// Assembly:
movslq 0x8(%rdi), %rax
testq %rax, %rax
js 0x82bb
movq (%rdi), %rcx
movl (%rcx,%rax,4), %eax
retq
pushq %rax
movq 0x5d2d(%rip), %rax      # 0xdff0
movq (%rax), %rcx
leaq 0x2a1a(%rip), %rdi      # 0xace7
pushq $0x10
popq %rsi
pushq $0x1
popq %rdx
callq 0x1180
pushq $-0x1
popq %rdi
callq 0x1170
// File: /workspace/github_c_makefile_star2_O2/chgzm[P]minic/util.c
// Function: create_strptrmap
StrPtrMap* create_strptrmap(int capacity) {
    StrPtrMap* map = malloc(sizeof(StrPtrMap));
    map->size      = 0;
    map->capacity  = capacity;
    map->entries   = calloc(capacity, sizeof(StrPtrMapEntry*));

    return map;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
pushq $0x10
popq %rdi
callq 0x1100
movq %rax, %r14
andl $0x0, 0x8(%rax)
movl %ebx, 0xc(%rax)
movslq %ebx, %rdi
pushq $0x8
popq %rsi
callq 0x10c0
movq %rax, (%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/chgzm[P]minic/util.c
// Function: strptrmap_put
void strptrmap_put(StrPtrMap* map, const char* key, void* val) {
    const int hash  = calc_hash(key);
    const int index = hash % map->capacity;
    if (map->entries[index] == NULL) {
        map->entries[index]       = calloc(1, sizeof(StrPtrMapEntry));
        map->entries[index]->key  = strdup(key);
        map->entries[index]->val  = val;
        map->entries[index]->next = NULL;
    }
    else {
        StrPtrMapEntry* current = map->entries[index];
        while (current->next != NULL) {
            current = current->next;
        }
        current->next       = calloc(1, sizeof(StrPtrMapEntry));
        current->next->key  = strdup(key);
        current->next->val  = val;
        current->next->next = NULL;
    }

    ++(map->size);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x83b4
cltd
idivl 0xc(%rbx)
movq (%rbx), %r13
movslq %edx, %r12
movq (%r13,%r12,8), %rax
testq %rax, %rax
je 0x8374
movq %rax, %r13
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x8343
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x10c0
movq %rax, %r12
movq %rax, 0x10(%r13)
movq %r15, %rdi
callq 0x1190
movq %rax, (%r12)
movq %r14, 0x8(%r12)
jmp 0x83a7
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x10c0
movq %rax, (%r13,%r12,8)
movq %r15, %rdi
callq 0x1190
movq (%rbx), %rcx
movq (%rcx,%r12,8), %rdx
movq %rax, (%rdx)
movq (%rcx,%r12,8), %rax
movq %r14, 0x8(%rax)
movq (%rcx,%r12,8), %rax
andq $0x0, 0x10(%rax)
incl 0x8(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/chgzm[P]minic/util.c
// Function: calc_hash
static int calc_hash(const char* str) {
    int h = 0, pos = 0;
    while (str[pos] != '\0') {
        h += str[pos];
        ++pos;
    }

    return h;
}

// Assembly:
xorl %eax, %eax
movsbl (%rdi), %ecx
testl %ecx, %ecx
je 0x83c4
addl %ecx, %eax
incq %rdi
jmp 0x83b6
retq
// File: /workspace/github_c_makefile_star2_O2/chgzm[P]minic/util.c
// Function: strptrmap_contains
bool strptrmap_contains(StrPtrMap* map, const char* key) {
    const int hash  = calc_hash(key);
    const int index = hash % map->capacity;

    if (map->entries[index] == NULL) {
        return false;
    }
    else {
        StrPtrMapEntry* current = map->entries[index];
        while (current != NULL) {
            if (strcmp(current->key, key) == 0) {
                return true;
            }
            current = current->next;
        }

        return false;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x83b4
cltd
idivl 0xc(%r14)
movq (%r14), %rax
movslq %edx, %rcx
movq (%rax,%rcx,8), %r14
testq %r14, %r14
je 0x8409
testq %r14, %r14
setne %bpl
je 0x840b
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x10d0
testl %eax, %eax
je 0x840b
movq 0x10(%r14), %r14
jmp 0x83eb
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/chgzm[P]minic/util.c
// Function: strptrmap_get
void* strptrmap_get(StrPtrMap* map, const char* key) {
    const int hash  = calc_hash(key);
    const int index = hash % map->capacity;
    if (map->entries[index] == NULL) {
        return NULL;
    }
    else {
        StrPtrMapEntry* current = map->entries[index];
        while (current != NULL) {
            if (strcmp(current->key, key) == 0) {
                return current->val;
            }

            current = current->next;
        }

        return NULL;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x83b4
cltd
idivl 0xc(%r14)
movq (%r14), %rax
movslq %edx, %rcx
movq (%rax,%rcx,8), %r15
xorl %r14d, %r14d
testq %r15, %r15
je 0x845a
testq %r15, %r15
je 0x845a
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x10d0
testl %eax, %eax
je 0x8456
movq 0x10(%r15), %r15
jmp 0x843c
movq 0x8(%r15), %r14
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/chgzm[P]minic/util.c
// Function: strintmap_put
void strintmap_put(StrIntMap* map, const char* key, int val) {
    const int hash  = calc_hash(key);
    const int index = hash % map->capacity;
    if (map->entries[index] == NULL) {
        map->entries[index]       = calloc(1, sizeof(StrIntMapEntry));
        map->entries[index]->key  = strdup(key);
        map->entries[index]->val  = val;
        map->entries[index]->next = NULL;
    }
    else {
        StrIntMapEntry* current = map->entries[index];
        while (current->next != NULL) {
            current = current->next;
        }
        current->next       = calloc(1, sizeof(StrIntMapEntry));
        current->next->key  = strdup(key);
        current->next->val  = val;
        current->next->next = NULL;
    }

    ++(map->size);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x83b4
cltd
idivl 0xc(%rbx)
movq (%rbx), %r12
movslq %edx, %r15
movq (%r12,%r15,8), %rax
testq %rax, %rax
je 0x84ef
movq %rax, %r12
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x84bf
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x10c0
movq %rax, %r15
movq %rax, 0x10(%r12)
movq %r14, %rdi
callq 0x1190
movq %rax, (%r15)
movl %ebp, 0x8(%r15)
jmp 0x851c
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x10c0
movq %rax, (%r12,%r15,8)
movq %r14, %rdi
callq 0x1190
movq (%rbx), %rcx
movq (%rcx,%r15,8), %rdx
movq %rax, (%rdx)
movq (%rcx,%r15,8), %rax
movl %ebp, 0x8(%rax)
andq $0x0, 0x10(%rax)
incl 0x8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/chgzm[P]minic/util.c
// Function: strintmap_contains
bool strintmap_contains(StrIntMap* map, const char* key) {
    const int hash  = calc_hash(key);
    const int index = hash % map->capacity;

    if (map->entries[index] == NULL) {
        return false;
    }
    else {
        StrIntMapEntry* current = map->entries[index];
        while (current != NULL) {
            if (strcmp(current->key, key) == 0) {
                return true;
            }
            current = current->next;
        }
        return false;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x83b4
cltd
idivl 0xc(%r14)
movq (%r14), %rax
movslq %edx, %rcx
movq (%rax,%rcx,8), %r14
testq %r14, %r14
je 0x856c
testq %r14, %r14
setne %bpl
je 0x856e
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x10d0
testl %eax, %eax
je 0x856e
movq 0x10(%r14), %r14
jmp 0x854e
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq