LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/parser.c
// Function: decode_operator_type
const char* decode_operator_type(int operator_type) {
    switch (operator_type) {
    case OP_NONE:   { return "OP_NONE";   }
    case OP_ASSIGN: { return "OP_ASSIGN"; }
    case OP_MUL_EQ: { return "OP_MUL_EQ"; } 
    case OP_DIV_EQ: { return "OP_DIV_EQ"; }
    case OP_MOD_EQ: { return "OP_MOD_EQ"; }
    case OP_ADD_EQ: { return "OP_ADD_EQ"; }
    case OP_SUB_EQ: { return "OP_SUB_EQ"; }
    case OP_AND_EQ: { return "OP_AND_EQ"; }
    case OP_XOR_EQ: { return "OP_XOR_EQ"; }
    case OP_OR_EQ:  { return "OP_OR_EQ";  }
    case OP_AND:    { return "OP_AND";    }
    case OP_ADD:    { return "OP_ADD";    }
    case OP_SUB:    { return "OP_SUB";    }
    case OP_MUL:    { return "OP_MUL";    }
    case OP_DIV:    { return "OP_DIV";    }
    case OP_MOD:    { return "OP_MOD";    }
    case OP_TILDE:  { return "OP_TILDE";  }
    case OP_EXCLA:  { return "OP_EXCLA";  }
    default:        { return "INVALID";   }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x11, %rax
ja 0x7311
movq -0x18(%rbp), %rax
leaq 0x88a1(%rip), %rcx      # 0xfaa4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8b3c(%rip), %rax      # 0xfd4f
movq %rax, -0x8(%rbp)
jmp 0x731c
leaq 0x8b34(%rip), %rax      # 0xfd57
movq %rax, -0x8(%rbp)
jmp 0x731c
leaq 0x8b2e(%rip), %rax      # 0xfd61
movq %rax, -0x8(%rbp)
jmp 0x731c
leaq 0x8b28(%rip), %rax      # 0xfd6b
movq %rax, -0x8(%rbp)
jmp 0x731c
leaq 0x8b22(%rip), %rax      # 0xfd75
movq %rax, -0x8(%rbp)
jmp 0x731c
leaq 0x8b1c(%rip), %rax      # 0xfd7f
movq %rax, -0x8(%rbp)
jmp 0x731c
leaq 0x8b16(%rip), %rax      # 0xfd89
movq %rax, -0x8(%rbp)
jmp 0x731c
leaq 0x8b10(%rip), %rax      # 0xfd93
movq %rax, -0x8(%rbp)
jmp 0x731c
leaq 0x8b0a(%rip), %rax      # 0xfd9d
movq %rax, -0x8(%rbp)
jmp 0x731c
leaq 0x8b04(%rip), %rax      # 0xfda7
movq %rax, -0x8(%rbp)
jmp 0x731c
leaq 0x8b00(%rip), %rax      # 0xfdb0
movq %rax, -0x8(%rbp)
jmp 0x731c
leaq 0x8afa(%rip), %rax      # 0xfdb7
movq %rax, -0x8(%rbp)
jmp 0x731c
leaq 0x8af4(%rip), %rax      # 0xfdbe
movq %rax, -0x8(%rbp)
jmp 0x731c
leaq 0x8aee(%rip), %rax      # 0xfdc5
movq %rax, -0x8(%rbp)
jmp 0x731c
leaq 0x8ae8(%rip), %rax      # 0xfdcc
movq %rax, -0x8(%rbp)
jmp 0x731c
leaq 0x8ae2(%rip), %rax      # 0xfdd3
movq %rax, -0x8(%rbp)
jmp 0x731c
leaq 0x8adc(%rip), %rax      # 0xfdda
movq %rax, -0x8(%rbp)
jmp 0x731c
leaq 0x8ad8(%rip), %rax      # 0xfde3
movq %rax, -0x8(%rbp)
jmp 0x731c
leaq 0x8a2f(%rip), %rax      # 0xfd47
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/parser.c
// Function: decode_comparison_operator_type
const char* decode_comparison_operator_type(int type) {
    switch (type) {
    case CMP_NONE: { return "CMP_NONE"; }
    case CMP_LT:   { return "CMP_LT";   }
    case CMP_GT:   { return "CMP_GT";   }
    case CMP_EQ:   { return "CMP_EQ";   }
    case CMP_NE:   { return "CMP_NE";   }
    case CMP_LE:   { return "CMP_LE";   }
    case CMP_GE:   { return "CMP_GE";   }
    default:       { return "INVALID";  }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x6, %rax
ja 0x73b3
movq -0x18(%rbp), %rax
leaq 0x879d(%rip), %rcx      # 0xfaec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8a8d(%rip), %rax      # 0xfdec
movq %rax, -0x8(%rbp)
jmp 0x73be
leaq 0x8a89(%rip), %rax      # 0xfdf5
movq %rax, -0x8(%rbp)
jmp 0x73be
leaq 0x8a83(%rip), %rax      # 0xfdfc
movq %rax, -0x8(%rbp)
jmp 0x73be
leaq 0x8a7d(%rip), %rax      # 0xfe03
movq %rax, -0x8(%rbp)
jmp 0x73be
leaq 0x8a77(%rip), %rax      # 0xfe0a
movq %rax, -0x8(%rbp)
jmp 0x73be
leaq 0x8a71(%rip), %rax      # 0xfe11
movq %rax, -0x8(%rbp)
jmp 0x73be
leaq 0x8a6b(%rip), %rax      # 0xfe18
movq %rax, -0x8(%rbp)
jmp 0x73be
leaq 0x898d(%rip), %rax      # 0xfd47
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/parser.c
// Function: decode_const_type
const char* decode_const_type(int type) {
    switch (type) {
    case CONST_INT:   { return "CONST_INT";   }
    case CONST_STR:   { return "CONST_STR";   }
    case CONST_FLOAT: { return "CONST_FLOAT"; }
    default:          { return "INVALID";     }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x73f7
jmp 0x73e3
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x7404
jmp 0x73ed
movl -0x10(%rbp), %eax
subl $0x3, %eax
je 0x7411
jmp 0x741e
leaq 0x8a21(%rip), %rax      # 0xfe1f
movq %rax, -0x8(%rbp)
jmp 0x7429
leaq 0x8a1e(%rip), %rax      # 0xfe29
movq %rax, -0x8(%rbp)
jmp 0x7429
leaq 0x8a1b(%rip), %rax      # 0xfe33
movq %rax, -0x8(%rbp)
jmp 0x7429
leaq 0x8922(%rip), %rax      # 0xfd47
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/parser.c
// Function: decode_jump_type
const char* decode_jump_type(int type) {
    switch (type) {
    case JMP_CONTINUE: { return "JMP_CONTINUE"; }
    case JMP_BREAK:    { return "JMP_BREAK";    }
    case JMP_RETURN:   { return "JMP_RETURN";   }
    default:           { return "INVALID";      }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x7457
jmp 0x7443
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0x7464
jmp 0x744d
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x7471
jmp 0x747e
leaq 0x89e1(%rip), %rax      # 0xfe3f
movq %rax, -0x8(%rbp)
jmp 0x7489
leaq 0x89e1(%rip), %rax      # 0xfe4c
movq %rax, -0x8(%rbp)
jmp 0x7489
leaq 0x89de(%rip), %rax      # 0xfe56
movq %rax, -0x8(%rbp)
jmp 0x7489
leaq 0x88c2(%rip), %rax      # 0xfd47
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/parser.c
// Function: decode_unary_type
const char* decode_unary_type(int type) {
    switch (type) {
    case UN_NONE:         { return "UN_NONE";         }
    case UN_INC:          { return "UN_INC";          }
    case UN_DEC:          { return "UN_DEC";          }
    case UN_OP:           { return "UN_OP";           }
    case UN_SIZEOF_IDENT: { return "UN_SIZEOF_IDENT"; }
    case UN_SIZEOF_TYPE:  { return "UN_SIZEOF_TYPE";  }
    default:              { return "INVALID";         }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x5, %rax
ja 0x7506
movq -0x18(%rbp), %rax
leaq 0x8659(%rip), %rcx      # 0xfb08
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x89a2(%rip), %rax      # 0xfe61
movq %rax, -0x8(%rbp)
jmp 0x7511
leaq 0x899d(%rip), %rax      # 0xfe69
movq %rax, -0x8(%rbp)
jmp 0x7511
leaq 0x8997(%rip), %rax      # 0xfe70
movq %rax, -0x8(%rbp)
jmp 0x7511
leaq 0x8991(%rip), %rax      # 0xfe77
movq %rax, -0x8(%rbp)
jmp 0x7511
leaq 0x898a(%rip), %rax      # 0xfe7d
movq %rax, -0x8(%rbp)
jmp 0x7511
leaq 0x898d(%rip), %rax      # 0xfe8d
movq %rax, -0x8(%rbp)
jmp 0x7511
leaq 0x883a(%rip), %rax      # 0xfd47
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/parser.c
// Function: decode_postfix_type
const char* decode_postfix_type(int type) {
    switch (type) {
    case PS_PRIMARY: { return "PS_PRIMARY"; }
    case PS_LSQUARE: { return "PS_LSQUARE"; }
    case PS_LPAREN:  { return "PS_LPAREN";  }
    case PS_DOT:     { return "PS_DOT";     }
    case PS_ARROW:   { return "PS_ARROW";   }
    case PS_INC:     { return "PS_INC";     }
    case PS_DEC:     { return "PS_DEC";     }
    default:         { return "INVALID";    }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x6, %rax
ja 0x75a3
movq -0x18(%rbp), %rax
leaq 0x85e1(%rip), %rcx      # 0xfb20
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x894d(%rip), %rax      # 0xfe9c
movq %rax, -0x8(%rbp)
jmp 0x75ae
leaq 0x894b(%rip), %rax      # 0xfea7
movq %rax, -0x8(%rbp)
jmp 0x75ae
leaq 0x8949(%rip), %rax      # 0xfeb2
movq %rax, -0x8(%rbp)
jmp 0x75ae
leaq 0x8946(%rip), %rax      # 0xfebc
movq %rax, -0x8(%rbp)
jmp 0x75ae
leaq 0x8940(%rip), %rax      # 0xfec3
movq %rax, -0x8(%rbp)
jmp 0x75ae
leaq 0x893c(%rip), %rax      # 0xfecc
movq %rax, -0x8(%rbp)
jmp 0x75ae
leaq 0x8936(%rip), %rax      # 0xfed3
movq %rax, -0x8(%rbp)
jmp 0x75ae
leaq 0x879d(%rip), %rax      # 0xfd47
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/parser.c
// Function: decode_selection_stmt_type
const char* decode_selection_stmt_type(int type) {
    switch (type) {
    case SELECT_IF:      { return "SELECT_IF";      }
    case SELECT_IF_ELSE: { return "SELECT_IF_ELSE"; }
    case SELECT_SWITCH:  { return "SELECT_SWITCH";  }
    default:             { return "INVALID";        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x75e7
jmp 0x75d3
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0x75f4
jmp 0x75dd
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x7601
jmp 0x760e
leaq 0x88ec(%rip), %rax      # 0xfeda
movq %rax, -0x8(%rbp)
jmp 0x7619
leaq 0x88e9(%rip), %rax      # 0xfee4
movq %rax, -0x8(%rbp)
jmp 0x7619
leaq 0x88eb(%rip), %rax      # 0xfef3
movq %rax, -0x8(%rbp)
jmp 0x7619
leaq 0x8732(%rip), %rax      # 0xfd47
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/parser.c
// Function: decode_itr_type
const char* decode_itr_type(int type) {
    switch (type) {
    case ITR_WHILE: { return "ITR_WHILE"; }
    case ITR_FOR:   { return "ITR_FOR";   }
    default:        { return "INVALID";   }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x763d
jmp 0x7633
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0x764a
jmp 0x7657
leaq 0x88bd(%rip), %rax      # 0xff01
movq %rax, -0x8(%rbp)
jmp 0x7662
leaq 0x88ba(%rip), %rax      # 0xff0b
movq %rax, -0x8(%rbp)
jmp 0x7662
leaq 0x86e9(%rip), %rax      # 0xfd47
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/parser.c
// Function: decode_labeled_stmt_type
const char* decode_labeled_stmt_type(int type) {
    switch (type) {
    case LABELED_CASE:    { return "LABELED_CASE";    }
    case LABELED_DEFAULT: { return "LABELED_DEFAULT"; }
    default:              { return "INVALID";         }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x768d
jmp 0x7683
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0x769a
jmp 0x76a7
leaq 0x887f(%rip), %rax      # 0xff13
movq %rax, -0x8(%rbp)
jmp 0x76b2
leaq 0x887f(%rip), %rax      # 0xff20
movq %rax, -0x8(%rbp)
jmp 0x76b2
leaq 0x8699(%rip), %rax      # 0xfd47
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/parser.c
// Function: is_func_def
static bool is_func_def(const Vector* vec, int index) {
    const Token* token = vec->elements[index];
    while (!(token->type == TK_IDENT && !strptrmap_contains(typedef_map, token->str))) {
        ++index;
        token = vec->elements[index];
    }
    ++index;
    token = vec->elements[index];

    if (token->type != TK_LPAREN) {
        return false;
    }

    while (token->type != TK_RPAREN) {
        ++index;
        token = vec->elements[index];
    }
    ++index;
    token = vec->elements[index];

    return (token->type == TK_LBRCKT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl $0x3, (%rcx)
movb %al, -0x21(%rbp)
jne 0x7919
movq 0xd881(%rip), %rdi      # 0x15188
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xeae0
xorb $-0x1, %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x7924
jmp 0x7942
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
jmp 0x78f2
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x21, (%rax)
je 0x796d
movb $0x0, -0x1(%rbp)
jmp 0x79c1
jmp 0x796f
movq -0x20(%rbp), %rax
cmpl $0x22, (%rax)
je 0x7996
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
jmp 0x796f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x23, (%rax)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/parser.c
// Function: create_func_def_node
static FuncDefNode* create_func_def_node(const Vector* vec, int* index) {
    FuncDefNode* func_def_node = calloc(1, sizeof(FuncDefNode));

    func_def_node->decl_specifier_nodes = create_vector();

    // {declaration-specifier}*
    while (is_declaration_specifier(vec, *index)) {
        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(func_def_node->decl_specifier_nodes, decl_specifier_node);
    }

    // declarator
    func_def_node->declarator_node = create_declarator_node(vec, index);
    if (func_def_node->declarator_node == NULL) {
        error("Failed to create declarator node.\n");
        return NULL;
    }

    // compound-statement
    func_def_node->compound_stmt_node = create_compound_stmt_node(vec, index);
    if (func_def_node->compound_stmt_node == NULL) {
        error("Failed to create compound-statement node\n");
        return NULL;
    }

    return func_def_node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x10b0
movq %rax, -0x20(%rbp)
movb $0x0, %al
callq 0xe5c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x7eb0
testb $0x1, %al
jne 0x7a19
jmp 0x7a5e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7f20
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x7a4c
leaq 0x85bb(%rip), %rdi      # 0xfff3
movb $0x0, %al
callq 0xe4e0
movq $0x0, -0x8(%rbp)
jmp 0x7adc
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0xe610
jmp 0x7a04
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8000
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x7a99
leaq 0x8599(%rip), %rdi      # 0x10021
movb $0x0, %al
callq 0xe4e0
movq $0x0, -0x8(%rbp)
jmp 0x7adc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x80b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x7ad4
leaq 0x8581(%rip), %rdi      # 0x10044
movb $0x0, %al
callq 0xe4e0
movq $0x0, -0x8(%rbp)
jmp 0x7adc
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/parser.c
// Function: is_func_decl
static bool is_func_decl(const Vector* vec, int index) {
    const Token* token = vec->elements[index];
    while (!(token->type == TK_IDENT && !strptrmap_contains(typedef_map, token->str))) {
        ++index;
        token = vec->elements[index];
    }
    ++index;
    token = vec->elements[index];

    if (token->type != TK_LPAREN) {
        return false;
    }

    while (token->type != TK_RPAREN) {
        ++index;
        token = vec->elements[index];
    }
    ++index;
    token = vec->elements[index];

    return (token->type == TK_SEMICOL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl $0x3, (%rcx)
movb %al, -0x21(%rbp)
jne 0x7b39
movq 0xd661(%rip), %rdi      # 0x15188
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xeae0
xorb $-0x1, %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x7b44
jmp 0x7b62
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
jmp 0x7b12
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x21, (%rax)
je 0x7b8d
movb $0x0, -0x1(%rbp)
jmp 0x7be1
jmp 0x7b8f
movq -0x20(%rbp), %rax
cmpl $0x22, (%rax)
je 0x7bb6
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
jmp 0x7b8f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x1f, (%rax)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/parser.c
// Function: create_enumerator_list_node
static EnumeratorListNode* create_enumerator_list_node(const Vector* vec, int* index) {
    EnumeratorListNode* enumerator_list_node = malloc(sizeof(EnumeratorListNode));
    enumerator_list_node->identifiers = create_vector();

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

        char* identifier = strdup(token->str);
        vector_push_back(enumerator_list_node->identifiers, identifier);

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

        if (token->type == TK_RBRCKT) {
            break;
        }
    }

    return enumerator_list_node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x8, %edi
callq 0x10f0
movq %rax, -0x20(%rbp)
movb $0x0, %al
callq 0xe5c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x3, (%rax)
je 0x7e13
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %edi
callq 0xe050
movl -0x34(%rbp), %esi
movq %rax, %rdx
leaq 0x8131(%rip), %rdi      # 0xff30
movb $0x0, %al
callq 0xe4e0
movq $0x0, -0x8(%rbp)
jmp 0x7e97
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1170
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0xe610
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x30, (%rax)
jne 0x7e7f
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x24, (%rax)
jne 0x7e8a
jmp 0x7e8f
jmp 0x7dd5
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x81c0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1d(%rbp)
jne 0x7f08
movb $0x1, %al
cmpl $0xc, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
je 0x7f08
cmpl $0x4, -0x1c(%rbp)
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x10b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x7f77
movq -0x20(%rbp), %rax
movb $0x1, 0x9(%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x7fe9
movq -0x28(%rbp), %rax
cmpl $0xc, (%rax)
jne 0x7f95
movq -0x20(%rbp), %rax
movb $0x1, 0x8(%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x7fe7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x81c0
testb $0x1, %al
jne 0x7faa
jmp 0x7fe5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8260
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x7fe3
leaq 0x809c(%rip), %rdi      # 0x1006e
movb $0x0, %al
callq 0xe4e0
movq $0x0, -0x8(%rbp)
jmp 0x7ff1
jmp 0x7fe5
jmp 0x7fe7
jmp 0x7fe9
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/parser.c
// Function: create_declarator_node
static DeclaratorNode* create_declarator_node(const Vector* vec, int* index) {
    DeclaratorNode* declarator_node = calloc(1, sizeof(DeclaratorNode));

    const Token* token = vec->elements[*index];
    if (token->type == TK_ASTER) {
        declarator_node->pointer_node = create_pointer_node(vec, index); 
    }

    declarator_node->direct_declarator_node = create_direct_declarator_node(vec, index);
    if (declarator_node->direct_declarator_node == NULL) {
        error("Failed to create direct-declarator node.\n");
        return NULL;
    }

    return declarator_node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x10b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x1a, (%rax)
jne 0x8059
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8950
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8a40
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x8094
leaq 0x80bb(%rip), %rdi      # 0x1013e
movb $0x0, %al
callq 0xe4e0
movq $0x0, -0x8(%rbp)
jmp 0x809c
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x8, %edi
callq 0x10f0
movq %rax, -0x20(%rbp)
movb $0x0, %al
callq 0xe5c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x23, (%rax)
je 0x8133
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %edi
callq 0xe050
movl -0x34(%rbp), %esi
movq %rax, %rdx
leaq 0x7e11(%rip), %rdi      # 0xff30
movb $0x0, %al
callq 0xe4e0
movq $0x0, -0x8(%rbp)
jmp 0x81b4
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x24, (%rax)
jne 0x816a
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x81ac
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xae60
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x819a
leaq 0x8459(%rip), %rdi      # 0x105e2
movb $0x0, %al
callq 0xe4e0
movq $0x0, -0x8(%rbp)
jmp 0x81b4
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0xe610
jmp 0x813e
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movb $0x1, %al
cmpl $0x6, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
je 0x824f
movb $0x1, %al
cmpl $0x7, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
je 0x824f
movb $0x1, %al
cmpl $0x8, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
je 0x824f
movb $0x1, %al
cmpl $0x9, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
je 0x824f
movb $0x1, %al
cmpl $0xa, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
je 0x824f
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x8(%rcx)
movb %al, -0x1e(%rbp)
je 0x8249
movq 0xcf4f(%rip), %rdi      # 0x15188
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xeae0
movb %al, -0x1e(%rbp)
movb -0x1e(%rbp), %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x10b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x81c0
testb $0x1, %al
jne 0x88ae
jmp 0x88e9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8260
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x88e7
leaq 0x7798(%rip), %rdi      # 0x1006e
movb $0x0, %al
callq 0xe4e0
movq $0x0, -0x8(%rbp)
jmp 0x8943
jmp 0x893b
movq -0x28(%rbp), %rax
cmpl $0xc, (%rax)
jne 0x8907
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movb $0x1, 0x8(%rax)
jmp 0x8939
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %edi
callq 0xe050
movl -0x2c(%rbp), %esi
movq %rax, %rdx
leaq 0x7608(%rip), %rdi      # 0xff30
movb $0x0, %al
callq 0xe4e0
movq $0x0, -0x8(%rbp)
jmp 0x8943
jmp 0x893b
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x4, %edi
callq 0x10f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x1a, (%rax)
je 0x89c9
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %edi
callq 0xe050
movl -0x2c(%rbp), %esi
movq %rax, %rdx
leaq 0x7578(%rip), %rdi      # 0xff30
movb $0x0, %al
callq 0xe4e0
movq $0x0, -0x8(%rbp)
jmp 0x8a29
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x1a, (%rax)
jne 0x8a21
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0x89ea
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/parser.c
// Function: create_param_type_list_node
static ParamTypeListNode* create_param_type_list_node(const Vector* vec, int* index) {
    ParamTypeListNode* param_type_list_node = calloc(1, sizeof(ParamTypeListNode));
    
    param_type_list_node->param_list_node = create_param_list_node(vec, index);
    if (param_type_list_node->param_list_node == NULL) {
        error("Failed to create parameter-type-list node.\n");
        return NULL;
    }

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

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

        ++(*index);
    }

    return param_type_list_node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x10b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xac00
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x8fd1
leaq 0x71d7(%rip), %rdi      # 0x10194
movb $0x0, %al
callq 0xe4e0
movq $0x0, -0x8(%rbp)
jmp 0x905f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x30, (%rax)
jne 0x9057
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x45, (%rax)
je 0x904c
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %edi
callq 0xe050
movl -0x2c(%rbp), %esi
movq %rax, %rdx
leaq 0x6ef5(%rip), %rdi      # 0xff30
movb $0x0, %al
callq 0xe4e0
movq $0x0, -0x8(%rbp)
jmp 0x905f
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/parser.c
// Function: create_logical_or_expr_node
static LogicalOrExprNode* create_logical_or_expr_node(const Vector* vec, int* index) {
    LogicalOrExprNode* logical_or_expr_node = calloc(1, sizeof(LogicalOrExprNode));

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

    const Token* token = vec->elements[*index];
    LogicalOrExprNode* current = logical_or_expr_node;
    while (token->type == TK_LOGOR) {
        ++(*index);

        LogicalOrExprNode* p_logical_or_expr_node = calloc(1, sizeof(LogicalOrExprNode));

        p_logical_or_expr_node->logical_or_expr_node  = current;
        p_logical_or_expr_node->logical_and_expr_node = create_logical_and_expr_node(vec, index);
        if (p_logical_or_expr_node->logical_and_expr_node == NULL) {
            error("Failed to create logical-and-expression node.\n");
            return NULL;
        }
        
        token = vec->elements[*index];
        current = p_logical_or_expr_node;
    }

    return current;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x10b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x92d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x90cf
leaq 0x7185(%rip), %rdi      # 0x10240
movb $0x0, %al
callq 0xe4e0
movq $0x0, -0x8(%rbp)
jmp 0x9188
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x37, (%rax)
jne 0x9180
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl $0x1, %edi
movl $0x10, %esi
callq 0x10b0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x92d0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x915d
leaq 0x70f4(%rip), %rdi      # 0x10240
movb $0x0, %al
callq 0xe4e0
movq $0x0, -0x8(%rbp)
jmp 0x9188
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x90ed
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x10b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa880
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x91ff
leaq 0x7303(%rip), %rdi      # 0x104ee
movb $0x0, %al
callq 0xe4e0
movq $0x0, -0x8(%rbp)
jmp 0x92b8
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x30, (%rax)
jne 0x92b0
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl $0x1, %edi
movl $0x10, %esi
callq 0x10b0
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa880
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x928d
leaq 0x730e(%rip), %rdi      # 0x1058a
movb $0x0, %al
callq 0xe4e0
movq $0x0, -0x8(%rbp)
jmp 0x92b8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x921d
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x10b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9400
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x932f
leaq 0x6f54(%rip), %rdi      # 0x1026f
movb $0x0, %al
callq 0xe4e0
movq $0x0, -0x8(%rbp)
jmp 0x93e8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x38, (%rax)
jne 0x93e0
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl $0x1, %edi
movl $0x10, %esi
callq 0x10b0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9400
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x93bd
leaq 0x6ec3(%rip), %rdi      # 0x1026f
movb $0x0, %al
callq 0xe4e0
movq $0x0, -0x8(%rbp)
jmp 0x93e8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x934d
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x10, %edi
callq 0x10f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9480
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x9463
leaq 0x6e4d(%rip), %rdi      # 0x1029f
movb $0x0, %al
callq 0xe4e0
movq $0x0, -0x8(%rbp)
jmp 0x946b
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/parser.c
// Function: create_exclusive_or_expr_node
static ExclusiveOrExprNode* create_exclusive_or_expr_node(const Vector* vec, int* index) {
    ExclusiveOrExprNode* exclusive_or_expr_node = calloc(1, sizeof(ExclusiveOrExprNode));

    exclusive_or_expr_node->and_expr_node = create_and_expr_node(vec, index);
    if (exclusive_or_expr_node->and_expr_node == NULL) {
        error("Failed to create and-expression node.\n");
        return NULL;
    }

    return exclusive_or_expr_node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x10b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x94f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x94dc
leaq 0x6e04(%rip), %rdi      # 0x102cf
movb $0x0, %al
callq 0xe4e0
movq $0x0, -0x8(%rbp)
jmp 0x94e4
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/parser.c
// Function: create_and_expr_node
static AndExprNode* create_and_expr_node(const Vector* vec, int* index) {
    AndExprNode* and_expr_node = calloc(1, sizeof(AndExprNode));

    and_expr_node->equality_expr_node = create_equality_expr_node(vec, index);
    if (and_expr_node->equality_expr_node == NULL) {
        error("Failed to create equality-expression node.\n");
        return NULL;
    }

    return and_expr_node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x10b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9560
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x954c
leaq 0x6dbb(%rip), %rdi      # 0x102f6
movb $0x0, %al
callq 0xe4e0
movq $0x0, -0x8(%rbp)
jmp 0x9554
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x10b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9920
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x990c
leaq 0x6aa7(%rip), %rdi      # 0x103a2
movb $0x0, %al
callq 0xe4e0
movq $0x0, -0x8(%rbp)
jmp 0x9914
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop