LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/MartinNovotny25[P]VUT-FIT-IFJ2020/semantics.c
// Function: printFunction
void printFunction(char *id, functionData data) {
    printf("Spustam printFunction\n");
    printf("Function id: %s\n", id);
    printf("Number of params: %d\n", data.numOfParams);
    printf("Number of return vals: %d\n", data.numOfReturns);
    printf("Params: \n");
    for (int i = 0; i < data.numOfParams; i++) {
        switch (data.paramsType[i]) {
            case t_INT_ID:
                printf("int ");
                break;
            case t_STRING_ID:
                printf("string ");
                break;
            case t_FLOAT64:
                printf("float64 ");
                break;
                
            default:
                break;
        }
        printf("%s\n", data.params[i]);
    }
    printf("Return types:\n");
    for (int i = 0; i < data.numOfReturns; i++) {
        switch (data.returns[i]) {
            case t_INT_ID:
                printf("int ");
                break;
            case t_STRING_ID:
                printf("string ");
                break;
            case t_FLOAT64:
                printf("float64 ");
                break;
                
            default:
                break;
        }
    }
    printf("\nprintFunction Ended\n\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x40(%rsp), %r15
leaq 0x3db9(%rip), %rdi      # 0x857b
callq 0x1050
leaq 0x3cf2(%rip), %rdi      # 0x84c0
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1070
movslq (%r15), %r14
leaq 0x3cef(%rip), %rdi      # 0x84d1
movl %r14d, %esi
xorl %eax, %eax
callq 0x1070
movl 0x4(%r15), %ebx
leaq 0x3cf0(%rip), %rdi      # 0x84e7
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x3d8a(%rip), %rdi      # 0x8591
callq 0x1050
testq %r14, %r14
jle 0x4861
leaq 0x3cea(%rip), %r12      # 0x8502
leaq 0x3ce8(%rip), %rbp      # 0x8507
xorl %r13d, %r13d
movl 0x808(%r15,%r13,4), %eax
movq %r12, %rdi
cmpl $0x18, %eax
je 0x4848
cmpl $0x17, %eax
je 0x4841
cmpl $0x14, %eax
jne 0x484f
movq %rbp, %rdi
jmp 0x4848
leaq 0x3cc7(%rip), %rdi      # 0x850f
xorl %eax, %eax
callq 0x1070
movq 0x8(%r15,%r13,8), %rdi
callq 0x1050
incq %r13
cmpq %r13, %r14
jne 0x4822
leaq 0x3d32(%rip), %rdi      # 0x859a
callq 0x1050
testl %ebx, %ebx
jle 0x48b9
leaq 0x3c8a(%rip), %r14      # 0x8502
leaq 0x3c90(%rip), %r12      # 0x850f
leaq 0x3c81(%rip), %r13      # 0x8507
xorl %ebp, %ebp
movl 0xc08(%r15,%rbp,4), %eax
movq %r14, %rdi
cmpl $0x18, %eax
je 0x48aa
cmpl $0x17, %eax
je 0x48a7
cmpl $0x14, %eax
jne 0x48b1
movq %r13, %rdi
jmp 0x48aa
movq %r12, %rdi
xorl %eax, %eax
callq 0x1070
incq %rbp
cmpq %rbp, %rbx
jne 0x4888
leaq 0x3ce8(%rip), %rdi      # 0x85a8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O1/MartinNovotny25[P]VUT-FIT-IFJ2020/semantics.c
// Function: for_control
void for_control(TDLList *L, tBSTNodePtrLocal *node, functionData params){   
    TDLLSucc(L);
	// ak je prvy lexem bodkociarka
	if(L->Act->tdata.type == T_SEMICOLON){
		TDLLSucc(L); // chod za bodkociarku (ma byt identifikator alebo vyraz)
		// Skontroluj podmienku
		if_control(L, node, params);

		if(L->Act->tdata.type != T_SEMICOLON){
            error_call(ERR_SEM_OTHER, L);
            BSTDisposeLocal(node);
        } 
        TDLLSucc(L);
        if(!(L->Act->tdata.type == t_BRACES_L)) {assign_vals_control(L, node, params);}
        TDLLPred(L);
	// Ak prvy lexem nie je bodkociarka
	}else if(L->Act->tdata.type == t_IDENTIFIER){
	
		dec_var_control(L, node, params);
	
        TDLLSucc(L);

		if_control(L, node, params);
		
		if(L->Act->tdata.type != T_SEMICOLON){
            error_call(ERR_SEM_OTHER, L);
                BSTDisposeLocal(node);
        } 
		TDLLSucc(L);
		// ak nechyba vyraz skontroluj ho
		if(!(L->Act->tdata.type == t_BRACES_L)) assign_vals_control(L, node, params);
        TDLLPred(L);
	// ak chyba bodkociarka aj deklaracia
	}else
	{
        error_call(ERR_SEM_OTHER, L);
        BSTDisposeLocal(node);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1010, %rsp           # imm = 0x1010
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1030(%rsp), %r15
callq 0x1695
movq 0x8(%rbx), %rax
movl 0x8(%rax), %eax
cmpl $0x13, %eax
je 0x6ba0
cmpl $0x38, %eax
je 0x6bb9
movl $0x7, %edi
movq %rbx, %rsi
callq 0x42c8
movq %r14, %rdi
addq $0x1010, %rsp           # imm = 0x1010
popq %rbx
popq %r14
popq %r15
jmp 0x46ab
movl $0x201, %ecx            # imm = 0x201
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x611b
movq %rbx, %rdi
callq 0x1695
movl $0x201, %ecx            # imm = 0x201
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5131
movq 0x8(%rbx), %rax
cmpl $0x38, 0x8(%rax)
je 0x6bf9
movl $0x7, %edi
movq %rbx, %rsi
callq 0x42c8
movq %r14, %rdi
callq 0x46ab
movq %rbx, %rdi
callq 0x1695
movq 0x8(%rbx), %rax
cmpl $0x34, 0x8(%rax)
je 0x6c24
movl $0x201, %ecx            # imm = 0x201
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5689
movq %rbx, %rdi
addq $0x1010, %rsp           # imm = 0x1010
popq %rbx
popq %r14
popq %r15
jmp 0x19a1
// File: /workspace/github_c_makefile_star2_O1/MartinNovotny25[P]VUT-FIT-IFJ2020/semantics.c
// Function: secondRun
void secondRun(TDLList *L) {
    //aktivita musi ist na zaciatok
    TDLLFirst(L);
    //prehladavaj kym nenajdes funkciu
    while (L->Act->tdata.type != t_EOF) {
        if (!strcmp(L->Act->tdata.lex, "func")) {
            // Stack pre pracu s ramcami vo funkcii
            // (Re)Inicializacia stacku
            InitMainStack(&mainstack);
            enterFuncBody(L, L->Act->rptr->tdata.lex);
        }
        TDLLSucc(L);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x168d
movq 0x8(%rbx), %rax
cmpl $0x1d, 0x8(%rax)
je 0x73e7
leaq 0xef3(%rip), %r14       # 0x8297
leaq 0x50dd(%rip), %r15      # 0xc488
movq (%rax), %rdi
movq %r14, %rsi
callq 0x1080
testl %eax, %eax
jne 0x73d5
movq %r15, %rdi
callq 0x46dd
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x70c7
movq %rbx, %rdi
callq 0x1695
movq 0x8(%rbx), %rax
cmpl $0x1d, 0x8(%rax)
jne 0x73ab
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/MartinNovotny25[P]VUT-FIT-IFJ2020/semantics.c
// Function: paramsRedefinitionCheck
void paramsRedefinitionCheck(functionData data, TDLList *L) {
    if (data.numOfParams == 0) {
        return;
    }
    for (int i = 0; i < data.numOfParams; i++) {
        for (int j = 0; j < data.numOfParams; j++) {
            //porovname parameter sameho so sebou, tento krok treba preskocit
            if (i == j) {
                continue;
            }
            //id parametrov sa rovnaju, volaj error
            if (!strcmp(data.params[i], data.params[j])) {
                BSTDisposeGlobal(&functions);
                error_call(ERR_SEM_UNDEF, L);
                return;
            }
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq 0x30(%rsp), %r14
testq %r14, %r14
jle 0x7713
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x7703
movq 0x8(%r15,%r12,8), %rdi
movq 0x8(%r15,%r13,8), %rsi
callq 0x1080
testl %eax, %eax
je 0x771d
incq %r13
cmpq %r13, %r14
jne 0x76eb
incq %r12
cmpq %r14, %r12
jne 0x76e8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x6cac(%rip), %rdi      # 0xe3d0
callq 0x44f1
movl $0x3, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x42c8
// File: /workspace/github_c_makefile_star2_O1/MartinNovotny25[P]VUT-FIT-IFJ2020/semantics.c
// Function: goThroughList
void goThroughList(TDLList *L) {
    
    //inicializacia tabulky funkcii
    BSTInitGlobal(&functions);
    insertBuiltInFunction();
    TDLLFirst(L);
    int i = 0, j = 0;      //pre potreby vypiskov
    while (L->Act->tdata.type != t_EOF) {
        if (!strcmp(L->Act->tdata.lex, "func")) {
            j++;
            checkFunction(L);
            
        }
        if (L->Act->rptr == NULL) {
            error_call(ERR_INTERN, L);
            return;
        }
        i++;
        TDLLSucc(L);
    }
    //main nebol najdeny, volaj error
    if (!mainFound) {
        error_call(ERR_SEM_UNDEF, L);
        return;
        
    }
    
    TDLLFirst(L);
    
    secondRun(L);
    //TDLLPrintAllTokens(L);
    //uvolnime pouzivane struktury
    TDLLDisposeList(L);
    BSTDisposeGlobal(&functions);
    //printf("USPESNY KONIEC SEMANTIKY\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x69ae(%rip), %rdi      # 0xe3d0
callq 0x43a0
callq 0x73ed
movq %rbx, %rdi
callq 0x168d
movq 0x8(%rbx), %rax
cmpl $0x1d, 0x8(%rax)
je 0x7a79
leaq 0x852(%rip), %r14       # 0x8297
movq (%rax), %rdi
movq %r14, %rsi
callq 0x1080
testl %eax, %eax
jne 0x7a5c
movq %rbx, %rdi
callq 0x78c6
movq 0x8(%rbx), %rax
cmpq $0x0, 0x18(%rax)
je 0x7ab4
movq %rbx, %rdi
callq 0x1695
movq 0x8(%rbx), %rax
cmpl $0x1d, 0x8(%rax)
jne 0x7a45
cmpb $0x0, 0x4a00(%rip)      # 0xc480
je 0x7aad
movq %rbx, %rdi
callq 0x168d
movq %rbx, %rdi
callq 0x7386
movq %rbx, %rdi
callq 0x16b6
leaq 0x692f(%rip), %rdi      # 0xe3d0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x44f1
movl $0x3, %edi
jmp 0x7ab9
movl $0x63, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x42c8
// File: /workspace/github_c_makefile_star2_O1/MartinNovotny25[P]VUT-FIT-IFJ2020/precanalysis_stack.c
// Function: symstack_push
void symstack_push(tsym_stack* sym_stack, psa_symbols symbol){
    tsym_stack_symbol* pushed_sym = (tsym_stack_symbol*)malloc(sizeof(tsym_stack_symbol));

    if (pushed_sym == NULL) {
        return;
    }
    pushed_sym->next = sym_stack->top;
    pushed_sym->symbol = symbol;

    sym_stack->top = pushed_sym;

    return;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl $0x10, %edi
callq 0x10a0
testq %rax, %rax
je 0x7af3
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
movl %ebp, (%rax)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MartinNovotny25[P]VUT-FIT-IFJ2020/precanalysis_stack.c
// Function: symstack_pop
bool symstack_pop(tsym_stack* sym_stack) {
    if (sym_stack->top != NULL)
    {

        tsym_stack_symbol* stack_sym = sym_stack->top;
        sym_stack->top = stack_sym->next;
        free(stack_sym);
        return true;
    }
    return false;
}

// Assembly:
pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x7b12
movq 0x8(%rbx), %rax
movq %rax, (%rdi)
movq %rbx, %rdi
callq 0x1030
testq %rbx, %rbx
setne %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/MartinNovotny25[P]VUT-FIT-IFJ2020/precanalysis_stack.c
// Function: symstack_push_red
void symstack_push_red(tsym_stack* sym_stack, psa_symbols symbol)
{
    tsym_stack_symbol* left = NULL;
    tsym_stack_symbol* stack_sym = sym_stack->top;

    while (stack_sym != NULL)
    {
        if (stack_sym->symbol != T_RED && stack_sym->symbol != T_NON_TERM){

            tsym_stack_symbol* pushed_sym = (tsym_stack_symbol*)malloc(sizeof(tsym_stack_symbol));
            pushed_sym->symbol = symbol;

            if (left == NULL){
                pushed_sym->next = sym_stack->top;
                sym_stack->top = pushed_sym;
            }
            else {
                pushed_sym->next = left->next;
                left->next = pushed_sym;
            }
            return;

        }

        left = stack_sym;
        stack_sym = stack_sym->next;
    }


}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x7b92
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl (%rax), %ecx
andl $-0x2, %ecx
cmpl $0xe, %ecx
jne 0x7b69
movq %rax, %r15
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x7b8d
movl (%rax), %ecx
andl $-0x2, %ecx
cmpl $0xe, %ecx
je 0x7b51
jmp 0x7b6c
xorl %r15d, %r15d
movl $0x10, %edi
callq 0x10a0
testq %r15, %r15
leaq 0x8(%r15), %rcx
cmoveq %r14, %rcx
movl %ebx, (%rax)
movq (%rcx), %rdx
movq %rdx, 0x8(%rax)
movq %rax, (%rcx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/MartinNovotny25[P]VUT-FIT-IFJ2020/precanalysis.c
// Function: pop1_push
void pop1_push(){
    //1 symbol potrebny pre redukciu
    tsym_stack_symbol* red1;
    red1 = syms_Stack.top;

    //Aplikacia pravidla
    reduction_succ  = psa_rule_application(count, red1, NULL, NULL);

    // popnutie vrchneho symbolu
    symstack_pop(&syms_Stack);
    symstack_pop(&syms_Stack); //popuje sa RED symbol


    //Pushnutie nontermu -> E
    symstack_push(&syms_Stack, T_NON_TERM);

}

// Assembly:
pushq %rbx
leaq 0x677d(%rip), %rbx      # 0xe3d8
movq 0x6776(%rip), %rsi      # 0xe3d8
movl 0x6778(%rip), %edi      # 0xe3e0
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x7c0a
movb %al, 0x676d(%rip)       # 0xe3e4
movq %rbx, %rdi
callq 0x7afa
movq %rbx, %rdi
callq 0x7afa
movq %rbx, %rdi
movl $0xf, %esi
popq %rbx
jmp 0x7ad0
// File: /workspace/github_c_makefile_star2_O1/eric-lo[P]3150/9-File/fork.c
// Function: main
int main(void) {
	printf("Hello");
	fork();
	printf("\n");
	return 0;
}

// Assembly:
pushq %rax
leaq 0xea0(%rip), %rdi       # 0x2004
xorl %eax, %eax
callq 0x1040
callq 0x1050
movl $0xa, %edi
callq 0x1030
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_node_array_new
struct hg_ast_node* hg_ast_node_array_new(struct hg_parser* p, enum hg_ast_node_type type) {
    assert(type > _HG_AST_NODE_ARRAY_START && type < _HG_AST_NODE_ARRAY_END);

    struct hg_ast_node_array* arr =
        hg_alloc(sizeof(struct hg_ast_node_array) + sizeof(struct hg_ast_node*) * _start_array_cap);

    arr->node.type = type;
    arr->node.line = p->lineno;
    arr->cap       = _start_array_cap;
    arr->len       = 0;

    return &arr->node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
leal -0x1(%r14), %eax
cmpl $0x5, %eax
jae 0x264e
movq %rdi, %rbx
movl $0x38, %edi
callq 0x2160
movl %r14d, (%rax)
movl 0xc(%rbx), %ecx
movl %ecx, 0x4(%rax)
movq $0x4, 0x10(%rax)
movq $0x0, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4bdf(%rip), %rdi      # 0x7234
leaq 0x4c19(%rip), %rsi      # 0x7275
leaq 0x4c18(%rip), %rcx      # 0x727b
movl $0x18, %edx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O1/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_node_array_append
struct hg_ast_node* hg_ast_node_array_append(struct hg_parser* p, struct hg_ast_node* _arr, struct hg_ast_node* node) {
    assert(_arr->type > _HG_AST_NODE_ARRAY_START && _arr->type < _HG_AST_NODE_ARRAY_END);

    __hg_ast_raw_to(_arr, struct hg_ast_node_array, arr);

    if (arr->len >= arr->cap) {
        arr->cap *= 2;
        arr = hg_realloc(arr, sizeof(struct hg_ast_node_array) + sizeof(struct hg_ast_node*) * arr->cap);
    }

    arr->arr[arr->len++] = node;

    unused_(p);
    return &arr->node;
}

// Assembly:
pushq %rbx
movl (%rsi), %ecx
decl %ecx
cmpl $0x5, %ecx
jae 0x26b2
movq %rdx, %rbx
movq %rsi, %rax
movq 0x10(%rsi), %rsi
cmpq %rsi, 0x8(%rax)
jb 0x269f
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x10(%rax)
shlq $0x4, %rsi
addq $0x18, %rsi
movq %rax, %rdi
callq 0x2180
movq 0x8(%rax), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq %rbx, 0x18(%rax,%rcx,8)
popq %rbx
retq
leaq 0x4c17(%rip), %rdi      # 0x72d0
leaq 0x4bb5(%rip), %rsi      # 0x7275
leaq 0x4c56(%rip), %rcx      # 0x731d
movl $0x26, %edx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O1/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_for_stat_new
struct hg_ast_node* hg_ast_for_stat_new(struct hg_parser* p, struct hg_ast_node* params, struct hg_ast_node* iterator,
                                        struct hg_ast_node* block) {
    assert(block->type == HG_AST_NODE_ARRAY_STATS);
    assert(params->type == HG_AST_NODE_ARRAY_PARAMS);

    __hg_new_ast(for_stat, struct hg_ast_for_stat);

    for_stat->node.type = HG_AST_NODE_FOR;
    for_stat->node.line = params->line;
    for_stat->params    = params;
    for_stat->block     = block;
    for_stat->iterator  = iterator;

    unused_(p);
    return &for_stat->node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x1, (%rcx)
jne 0x2712
movq %rsi, %r15
cmpl $0x4, (%rsi)
jne 0x2731
movq %rcx, %r14
movq %rdx, %rbx
movl $0x20, %edi
callq 0x2160
movl $0x9, (%rax)
movl 0x4(%r15), %ecx
movl %ecx, 0x4(%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4e14(%rip), %rdi      # 0x752d
leaq 0x4b55(%rip), %rsi      # 0x7275
leaq 0x4c63(%rip), %rcx      # 0x738a
movl $0x37, %edx
callq 0x20f0
leaq 0x4ec2(%rip), %rdi      # 0x75fa
leaq 0x4b36(%rip), %rsi      # 0x7275
leaq 0x4c44(%rip), %rcx      # 0x738a
movl $0x38, %edx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O1/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_break_stat_new
struct hg_ast_node* hg_ast_break_stat_new(struct hg_parser* p) {
    __hg_new_ast(stat, struct hg_ast_break_stat);

    stat->node.type = HG_AST_NODE_BREAK;
    stat->node.line = p->lineno;

    return &stat->node;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x8, %edi
callq 0x2160
movl $0xc, (%rax)
movl 0xc(%rbx), %ecx
movl %ecx, 0x4(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_continue_stat_new
struct hg_ast_node* hg_ast_continue_stat_new(struct hg_parser* p) {
    __hg_new_ast(stat, struct hg_ast_continue_stat);

    stat->node.type = HG_AST_NODE_CONTINUE;
    stat->node.line = p->lineno;

    return &stat->node;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x8, %edi
callq 0x2160
movl $0xd, (%rax)
movl 0xc(%rbx), %ecx
movl %ecx, 0x4(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_return_stat_new
struct hg_ast_node* hg_ast_return_stat_new(struct hg_parser* p, struct hg_ast_node* exprs) {
    assert(exprs == NULL || exprs->type == HG_AST_NODE_ARRAY_EXPRS);

    __hg_new_ast(stat, struct hg_ast_return_stat);

    stat->node.type = HG_AST_NODE_RETURN;
    stat->node.line = exprs != NULL ? exprs->line : p->lineno;
    stat->exprs     = exprs;

    unused_(p);
    return &stat->node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x279c
cmpl $0x2, (%rbx)
jne 0x27cd
movl $0x10, %edi
callq 0x2160
leaq 0x4(%rbx), %rcx
addq $0xc, %r14
testq %rbx, %rbx
movl $0xe, (%rax)
cmovneq %rcx, %r14
movl (%r14), %ecx
movl %ecx, 0x4(%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4c34(%rip), %rdi      # 0x7408
leaq 0x4a9a(%rip), %rsi      # 0x7275
leaq 0x4c5e(%rip), %rcx      # 0x7440
movl $0x59, %edx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O1/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_if_stat_new
struct hg_ast_node* hg_ast_if_stat_new(struct hg_parser* p, struct hg_ast_node* cond, struct hg_ast_node* block,
                                       struct hg_ast_node* else_block) {
    assert(block->type == HG_AST_NODE_ARRAY_STATS);
    assert(else_block == NULL || else_block->type == HG_AST_NODE_ARRAY_STATS);

    __hg_new_ast(stat, struct hg_ast_if_stat);

    stat->node.type  = HG_AST_NODE_IF;
    stat->node.line  = cond->line;
    stat->condition  = cond;
    stat->block      = block;
    stat->else_block = else_block == NULL ? NULL : else_block;

    unused_(p);
    return &stat->node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x1, (%rdx)
jne 0x2832
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
testq %rcx, %rcx
je 0x2809
cmpl $0x1, (%rbx)
jne 0x2851
movl $0x20, %edi
callq 0x2160
movl $0xa, (%rax)
movl 0x4(%r15), %ecx
movl %ecx, 0x4(%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4cf4(%rip), %rdi      # 0x752d
leaq 0x4a35(%rip), %rsi      # 0x7275
leaq 0x4c4e(%rip), %rcx      # 0x7495
movl $0x67, %edx
callq 0x20f0
leaq 0x4cba(%rip), %rdi      # 0x7512
leaq 0x4a16(%rip), %rsi      # 0x7275
leaq 0x4c2f(%rip), %rcx      # 0x7495
movl $0x68, %edx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O1/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_assignment_stat_new
struct hg_ast_node* hg_ast_assignment_stat_new(struct hg_parser* p, struct hg_ast_node* vars,
                                               struct hg_ast_node* exprs) {
    assert(vars->type == HG_AST_NODE_ARRAY_VARS);
    assert(exprs->type == HG_AST_NODE_ARRAY_EXPRS);

    __hg_new_ast(stat, struct hg_ast_assignment_stat);

    stat->node.type = HG_AST_NODE_ASSIGNMENT;
    stat->node.line = vars->line;
    stat->vars      = vars;
    stat->exprs     = exprs;

    unused_(p);
    return &stat->node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x3, (%rsi)
jne 0x28ab
movq %rdx, %rbx
cmpl $0x2, (%rdx)
jne 0x28ca
movq %rsi, %r14
movl $0x18, %edi
callq 0x2160
movl $0x8, (%rax)
movl 0x4(%r14), %ecx
movl %ecx, 0x4(%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4ca2(%rip), %rdi      # 0x7554
leaq 0x49bc(%rip), %rsi      # 0x7275
leaq 0x4cb9(%rip), %rcx      # 0x7579
movl $0x78, %edx
callq 0x20f0
leaq 0x4b48(%rip), %rdi      # 0x7419
leaq 0x499d(%rip), %rsi      # 0x7275
leaq 0x4c9a(%rip), %rcx      # 0x7579
movl $0x79, %edx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O1/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_func_stat_new
struct hg_ast_node* hg_ast_func_stat_new(struct hg_parser* p, struct hg_ast_node* id, struct hg_ast_node* params,
                                         struct hg_ast_node* block) {
    assert(params == NULL || params->type == HG_AST_NODE_ARRAY_PARAMS);
    assert(block->type == HG_AST_NODE_ARRAY_STATS);
    assert(id->type == HG_AST_NODE_LITERAL_ID);

    __hg_new_ast(stat, struct hg_ast_func_stat);

    stat->node.type = HG_AST_NODE_FUNC;
    stat->node.line = id->line;
    stat->id        = id;
    stat->params    = params;
    stat->block     = block;

    unused_(p);
    return &stat->node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
testq %rdx, %rdx
je 0x2902
cmpl $0x4, (%r14)
jne 0x2974
cmpl $0x1, (%rbx)
jne 0x2936
cmpl $0x1e, (%r15)
jne 0x2955
movl $0x20, %edi
callq 0x2160
movl $0xb, (%rax)
movl 0x4(%r15), %ecx
movl %ecx, 0x4(%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4bf0(%rip), %rdi      # 0x752d
leaq 0x4931(%rip), %rsi      # 0x7275
leaq 0x4cd8(%rip), %rcx      # 0x7623
movl $0x89, %edx
callq 0x20f0
leaq 0x4d46(%rip), %rdi      # 0x76a2
leaq 0x4912(%rip), %rsi      # 0x7275
leaq 0x4cb9(%rip), %rcx      # 0x7623
movl $0x8a, %edx
callq 0x20f0
leaq 0x4c6d(%rip), %rdi      # 0x75e8
leaq 0x48f3(%rip), %rsi      # 0x7275
leaq 0x4c9a(%rip), %rcx      # 0x7623
movl $0x88, %edx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O1/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_expr_stat_new
struct hg_ast_node* hg_ast_expr_stat_new(struct hg_parser* p, struct hg_ast_node* expr) {
    __hg_new_ast(stat, struct hg_ast_expr_stat);

    stat->node.type = HG_AST_NODE_EXPR_STAT;
    stat->node.line = expr->line;
    stat->expr      = expr;

    unused_(p);
    return &stat->node;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movl $0x10, %edi
callq 0x2160
movl $0xf, (%rax)
movl 0x4(%rbx), %ecx
movl %ecx, 0x4(%rax)
movq %rbx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_func_def_new
struct hg_ast_node* hg_ast_func_def_new(struct hg_parser* p, struct hg_ast_node* params, struct hg_ast_node* block) {
    assert(params == NULL || params->type == HG_AST_NODE_ARRAY_PARAMS);
    assert(block->type == HG_AST_NODE_ARRAY_STATS);

    __hg_new_ast(expr, struct hg_ast_func_def_expr);

    expr->node.type = HG_AST_NODE_FUNC_DEF;
    expr->node.line = params != NULL ? params->line : block->line;
    expr->params    = params;
    expr->block     = block;

    unused_(p);
    return &expr->node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
testq %rsi, %rsi
je 0x29c8
cmpl $0x4, (%r14)
jne 0x2a1c
cmpl $0x1, (%rbx)
jne 0x29fd
movl $0x18, %edi
callq 0x2160
testq %r14, %r14
movl $0x15, (%rax)
movq %r14, %rcx
cmoveq %rbx, %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x4(%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4b29(%rip), %rdi      # 0x752d
leaq 0x486a(%rip), %rsi      # 0x7275
leaq 0x4cb3(%rip), %rcx      # 0x76c5
movl $0xa5, %edx
callq 0x20f0
leaq 0x4bc5(%rip), %rdi      # 0x75e8
leaq 0x484b(%rip), %rsi      # 0x7275
leaq 0x4c94(%rip), %rcx      # 0x76c5
movl $0xa4, %edx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O1/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_unary_expr_new
struct hg_ast_node* hg_ast_unary_expr_new(struct hg_parser* p, enum hg_ast_node_op op, struct hg_ast_node* expr) {
    __hg_new_ast(unary, struct hg_ast_unary_expr);

    unary->node.type = HG_AST_NODE_UNARY_EXPR;
    unary->node.line = expr->line;
    unary->expr      = expr;
    unary->op        = op;

    unused_(p);
    return &unary->node;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movl $0x18, %edi
callq 0x2160
movl $0x17, (%rax)
movl 0x4(%rbx), %ecx
movl %ecx, 0x4(%rax)
movq %rbx, 0x10(%rax)
movl %ebp, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_binary_expr_new
struct hg_ast_node* hg_ast_binary_expr_new(struct hg_parser* p, enum hg_ast_node_op op, struct hg_ast_node* left,
                                           struct hg_ast_node* right) {
    __hg_new_ast(expr, struct hg_ast_binary_expr);

    expr->node.type = HG_AST_NODE_BINARY_EXPR;
    expr->node.line = left->line;
    expr->left      = left;
    expr->right     = right;
    expr->op        = op;

    unused_(p);
    return &expr->node;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movl $0x20, %edi
callq 0x2160
movl $0x16, (%rax)
movl 0x4(%r14), %ecx
movl %ecx, 0x4(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
movl %ebp, 0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_call_expr_new
struct hg_ast_node* hg_ast_call_expr_new(struct hg_parser* p, struct hg_ast_node* callable, struct hg_ast_node* exprs) {
    assert(exprs == NULL || exprs->type == HG_AST_NODE_ARRAY_EXPRS);

    __hg_new_ast(expr, struct hg_ast_call_expr);

    expr->node.type = HG_AST_NODE_CALL;
    expr->node.line = callable->line;
    expr->callable  = callable;
    expr->exprs     = exprs;

    unused_(p);
    return &expr->node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
testq %rdx, %rdx
je 0x2aae
cmpl $0x2, (%rbx)
jne 0x2ad5
movl $0x18, %edi
callq 0x2160
movl $0x12, (%rax)
movl 0x4(%r14), %ecx
movl %ecx, 0x4(%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x492c(%rip), %rdi      # 0x7408
leaq 0x4792(%rip), %rsi      # 0x7275
leaq 0x4c43(%rip), %rcx      # 0x772d
movl $0xcd, %edx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O1/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_field_expr_new
struct hg_ast_node* hg_ast_field_expr_new(struct hg_parser* p, struct hg_ast_node* prefix, struct hg_ast_node* field) {
    assert(field->type == HG_AST_NODE_LITERAL_ID);

    __hg_new_ast(expr, struct hg_ast_field_expr);

    expr->node.type = HG_AST_NODE_FIELD;
    expr->node.line = prefix->line;
    expr->prefix    = prefix;
    expr->field     = field;

    unused_(p);
    return &expr->node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1e, (%rdx)
jne 0x2b2a
movq %rdx, %rbx
movq %rsi, %r14
movl $0x18, %edi
callq 0x2160
movl $0x13, (%rax)
movl 0x4(%r14), %ecx
movl %ecx, 0x4(%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4c65(%rip), %rdi      # 0x7796
leaq 0x473d(%rip), %rsi      # 0x7275
leaq 0x4c7d(%rip), %rcx      # 0x77bc
movl $0xdb, %edx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O1/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_index_expr_new
struct hg_ast_node* hg_ast_index_expr_new(struct hg_parser* p, struct hg_ast_node* prefix, struct hg_ast_node* index) {
    __hg_new_ast(expr, struct hg_ast_index_expr);

    expr->node.type = HG_AST_NODE_INDEX;
    expr->node.line = prefix->line;
    expr->prefix    = prefix;
    expr->index     = index;

    unused_(p);
    return &expr->node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl $0x18, %edi
callq 0x2160
movl $0x14, (%rax)
movl 0x4(%r14), %ecx
movl %ecx, 0x4(%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_table_expr_new
struct hg_ast_node* hg_ast_table_expr_new(struct hg_parser* p, struct hg_ast_node* arr) {
    assert(arr == NULL || arr->type == HG_AST_NODE_ARRAY_TABLE_ENTRIES /* for maps */ ||
           arr->type == HG_AST_NODE_ARRAY_EXPRS /* for lists*/);

    __hg_new_ast(expr, struct hg_ast_table_expr);

    expr->node.type = HG_AST_NODE_TABLE;
    expr->node.line = arr != NULL ? arr->line : p->lineno;
    expr->entries   = arr;

    unused_(p);
    return &expr->node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x2b95
movl (%rbx), %eax
cmpl $0x2, %eax
je 0x2b95
cmpl $0x5, %eax
jne 0x2bc6
movl $0x10, %edi
callq 0x2160
leaq 0x4(%rbx), %rcx
addq $0xc, %r14
testq %rbx, %rbx
movl $0x18, (%rax)
cmovneq %rcx, %r14
movl (%r14), %ecx
movl %ecx, 0x4(%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4c59(%rip), %rdi      # 0x7826
leaq 0x46a1(%rip), %rsi      # 0x7275
leaq 0x4caf(%rip), %rcx      # 0x788a
movl $0xf6, %edx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O1/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_table_entry_new
struct hg_ast_node* hg_ast_table_entry_new(struct hg_parser* p, struct hg_ast_node* key, struct hg_ast_node* value) {
    __hg_new_ast(entry, struct hg_ast_table_entry);

    entry->node.type = HG_AST_NODE_TABLE_ENTRY;
    entry->node.line = key != NULL ? key->line : value->line;
    entry->key       = key;
    entry->value     = value;

    unused_(p);
    return &entry->node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl $0x18, %edi
callq 0x2160
movl $0x19, (%rax)
testq %r14, %r14
movq %r14, %rcx
cmoveq %rbx, %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x4(%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_brack_expr_new
struct hg_ast_node* hg_ast_brack_expr_new(struct hg_parser* p, struct hg_ast_node* expr) {
    assert(expr->type > _HG_AST_NODE_EXPR_START && expr->type < _HG_AST_NODE_EXPR_END);

    __hg_new_ast(node, struct hg_ast_brack_expr);

    node->node.type = HG_AST_NODE_BRACK_EXPR;
    node->node.line = expr->line;
    node->expr      = expr;

    unused_(p);
    return &node->node;
}

// Assembly:
pushq %rbx
movl (%rsi), %eax
addl $-0x12, %eax
cmpl $0x9, %eax
jae 0x2c49
movq %rsi, %rbx
movl $0x10, %edi
callq 0x2160
movl $0x1a, (%rax)
movl 0x4(%rbx), %ecx
movl %ecx, 0x4(%rax)
movq %rbx, 0x8(%rax)
popq %rbx
retq
leaq 0x4c8e(%rip), %rdi      # 0x78de
leaq 0x461e(%rip), %rsi      # 0x7275
leaq 0x4ccb(%rip), %rcx      # 0x7929
movl $0x10f, %edx            # imm = 0x10F
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O1/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_literal_id_new
struct hg_ast_node* hg_ast_literal_id_new(struct hg_parser* p, hg_str str) {
    __hg_new_ast(lit, struct hg_ast_literal);

    lit->node.type = HG_AST_NODE_LITERAL_ID;
    lit->node.line = p->lineno;
    lit->as_id     = str;

    return &lit->node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x10, %edi
callq 0x2160
movl $0x1e, (%rax)
movl 0xc(%r14), %ecx
movl %ecx, 0x4(%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_literal_str_new
struct hg_ast_node* hg_ast_literal_str_new(struct hg_parser* p, hg_str str) {
    __hg_new_ast(lit, struct hg_ast_literal);

    lit->node.type = HG_AST_NODE_LITERAL_STR;
    lit->node.line = p->lineno;
    lit->as_str    = str;

    return &lit->node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x10, %edi
callq 0x2160
movl $0x1d, (%rax)
movl 0xc(%r14), %ecx
movl %ecx, 0x4(%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_literal_sym_new
struct hg_ast_node* hg_ast_literal_sym_new(struct hg_parser* p, hg_str str) {
    __hg_new_ast(lit, struct hg_ast_literal);

    lit->node.type = HG_AST_NODE_LITERAL_SYMBOL;
    lit->node.line = p->lineno;
    lit->as_str    = str;

    return &lit->node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x10, %edi
callq 0x2160
movl $0x1f, (%rax)
movl 0xc(%r14), %ecx
movl %ecx, 0x4(%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_literal_float_new
struct hg_ast_node* hg_ast_literal_float_new(struct hg_parser* p, hg_float d) {
    __hg_new_ast(lit, struct hg_ast_literal);

    lit->node.type = HG_AST_NODE_LITERAL_FLOAT;
    lit->node.line = p->lineno;
    lit->as_float  = d;

    return &lit->node;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
movl $0x10, %edi
callq 0x2160
movl $0x22, (%rax)
movl 0xc(%rbx), %ecx
movl %ecx, 0x4(%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_literal_int_new
struct hg_ast_node* hg_ast_literal_int_new(struct hg_parser* p, hg_int i) {
    __hg_new_ast(lit, struct hg_ast_literal);

    lit->node.type = HG_AST_NODE_LITERAL_INT;
    lit->node.line = p->lineno;
    lit->as_int    = i;

    return &lit->node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x10, %edi
callq 0x2160
movl $0x21, (%rax)
movl 0xc(%r14), %ecx
movl %ecx, 0x4(%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_literal_bool_new
struct hg_ast_node* hg_ast_literal_bool_new(struct hg_parser* p, hg_bool b) {
    __hg_new_ast(lit, struct hg_ast_literal);

    lit->node.type = HG_AST_NODE_LITERAL_BOOL;
    lit->node.line = p->lineno;
    lit->as_bool   = b;

    return &lit->node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl $0x10, %edi
callq 0x2160
movl $0x20, (%rax)
movl 0xc(%r14), %ecx
movl %ecx, 0x4(%rax)
movb %bl, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_node_to_str
hg_str hg_ast_node_to_str(const struct hg_ast_node* node, uint32_t indent) {
    struct hg_strbuf buf;

    hg_strbuf_init(&buf);

    _node_to_str(node, indent, 0, &buf);

    hg_str ret = hg_strbuf_to_str(&buf);
    hg_strbuf_free(&buf);
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x3abc
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x2ed0
movq %r15, %rdi
callq 0x3cc2
movq %rax, %rbx
movq %r15, %rdi
callq 0x3ae3
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/yangtau[P]hedgehog/src/ast.c
// Function: get_indent_str
static hg_str _get_indent_str(uint32_t indent, uint32_t depth) {
    switch (indent * depth) {
    case 0:
        return "";
    case 2:
        return "  ";
    case 4:
        return "    ";
    case 6:
        return "      ";
    case 8:
        return "        ";
    case 10:
        return "          ";
    case 12:
        return "            ";
    case 16:
        return "                ";
    }

    hg_str indent_str;

    struct hg_strbuf indent_buf;
    hg_strbuf_init(&indent_buf);

    for (size_t i = 0; i < indent * depth; i++)
        assert(hg_strbuf_append(&indent_buf, " "));
    indent_str = hg_strbuf_to_str(&indent_buf);
    hg_strbuf_free(&indent_buf);
    return indent_str;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebp
imull %esi, %ebp
cmpl $0x11, %ebp
jae 0x35e6
movl $0x11555, %eax          # imm = 0x11555
btl %ebp, %eax
jae 0x35e6
movl %ebp, %eax
leaq 0x3c13(%rip), %rcx      # 0x71f0
movslq (%rcx,%rax,4), %rbx
addq %rcx, %rbx
jmp 0x362b
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x3abc
movl %ebp, %r15d
leaq 0x444e(%rip), %r14      # 0x7a4b
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3b18
testb %al, %al
je 0x3639
decq %r15
jne 0x35fd
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3cc2
movq %rax, %rbx
movq %r14, %rdi
callq 0x3ae3
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x440d(%rip), %rdi      # 0x7a4d
leaq 0x3c2e(%rip), %rsi      # 0x7275
leaq 0x4422(%rip), %rcx      # 0x7a70
movl $0x218, %edx            # imm = 0x218
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O1/yangtau[P]hedgehog/src/lex.hedgehog.c
// Function: hg_yy_init_buffer
static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)

{
	int oerrno = errno;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

	yy_flush_buffer( b , yyscanner);

	b->yy_input_file = file;
	b->yy_fill_buffer = 1;

    /* If b is the current buffer, then yy_init_buffer was _probably_
     * called from yyrestart() or through yy_get_next_buffer.
     * In that case, we don't want to reset the lineno or column.
     */
    if (b != YY_CURRENT_BUFFER){
        b->yy_bs_lineno = 1;
        b->yy_bs_column = 0;
    }

        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
    
	errno = oerrno;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
callq 0x2050
movq %rax, %r14
movl (%rax), %ebp
movq %rbx, %rdi
movq %r12, %rsi
callq 0x64ef
movq %r15, (%rbx)
movl $0x1, 0x34(%rbx)
movq 0x28(%r12), %rax
testq %rax, %rax
je 0x63b5
movq 0x18(%r12), %rcx
movq (%rax,%rcx,8), %rax
jmp 0x63b7
xorl %eax, %eax
cmpq %rbx, %rax
je 0x63c4
movq $0x1, 0x2c(%rbx)
testq %r15, %r15
je 0x63e1
movq %r15, %rdi
callq 0x2150
movl %eax, %edi
callq 0x2080
xorl %ecx, %ecx
testl %eax, %eax
setg %cl
jmp 0x63e3
xorl %ecx, %ecx
movl %ecx, 0x24(%rbx)
movl %ebp, (%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/channel.C
// Function: Channel::AddSpike(int)
void Channel::AddSpike(int spikeT){
    int size = _spikeT.size();
    if(size > 0){
        if(spikeT <= _spikeT[size-1])
            cout<<spikeT<<"\t"<<_spikeT[size-1]<<endl;
        assert(spikeT > _spikeT[size-1]);
    }else{
        assert(spikeT > 0);
    }
    _spikeT.push_back(spikeT);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, 0x4(%rsp)
leaq 0x18(%rdi), %r14
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %r12
subq %rax, %r12
sarq $0x2, %r12
testl %r12d, %r12d
jle 0x3e98
decl %r12d
cmpl %esi, (%rax,%r12,4)
jl 0x3e6c
movq 0x1d1b9(%rip), %rdi     # 0x20fd0
callq 0x3560
movq %rax, %r15
leaq 0x1320a(%rip), %rsi     # 0x17030
movl $0x1, %edx
movq %rax, %rdi
callq 0x3340
movq (%r14), %rax
movl (%rax,%r12,4), %esi
movq %r15, %rdi
callq 0x3560
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
movl 0x4(%rsp), %eax
movq (%r14), %rcx
cmpl (%rcx,%r12,4), %eax
jg 0x3e9c
leaq 0x131b2(%rip), %rdi     # 0x17032
leaq 0x131c4(%rip), %rsi     # 0x1704b
leaq 0x131c7(%rip), %rcx     # 0x17055
movl $0x25, %edx
callq 0x31b0
testl %esi, %esi
jle 0x3ecf
movq 0x20(%rbx), %rsi
cmpq 0x28(%rbx), %rsi
je 0x3eb6
movl 0x4(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x20(%rbx)
jmp 0x3ec3
leaq 0x4(%rsp), %rdx
movq %r14, %rdi
callq 0x4476
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1319b(%rip), %rdi     # 0x17071
leaq 0x1316e(%rip), %rsi     # 0x1704b
leaq 0x13171(%rip), %rcx     # 0x17055
movl $0x27, %edx
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/channel.C
// Function: Channel::Print(std::basic_ofstream<char, std::char_traits<char>>&)
void Channel::Print(ofstream& f_out){
    assert(f_out.is_open());
    if(_spikeT.empty() == true) return;
    for(_iter_spikeT = _spikeT.begin(); _iter_spikeT != _spikeT.end(); _iter_spikeT++) 
        f_out<<_index<<"\t"<<*_iter_spikeT<<endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x70(%rsi), %rdi
callq 0x30b0
testb %al, %al
je 0x423b
movq 0x18(%r14), %rax
cmpq 0x20(%r14), %rax
je 0x422f
movq %rax, 0x30(%r14)
cmpq 0x20(%r14), %rax
je 0x422f
leaq 0x12e6a(%rip), %r15     # 0x17030
movl 0x40(%r14), %esi
movq %rbx, %rdi
callq 0x3560
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x3340
movq 0x30(%r14), %rax
movl (%rax), %esi
movq %r12, %rdi
callq 0x3560
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %r12, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
movq 0x30(%r14), %rax
addq $0x4, %rax
movq %rax, 0x30(%r14)
cmpq 0x20(%r14), %rax
jne 0x41c6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x12e3a(%rip), %rdi     # 0x1707c
leaq 0x12e02(%rip), %rsi     # 0x1704b
leaq 0x12e3c(%rip), %rcx     # 0x1708c
movl $0x69, %edx
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/channel.C
// Function: Channel::Read(_IO_FILE*)
void Channel::Read(FILE * fp){
	char linestring[8192];
	char * token;
	int spike_t;
	int index;
	while(1){
		if(fgets(linestring,8191,fp)==NULL||linestring[0]=='\n'){
			assert(0);
		}
		token=strtok(linestring," \t\n,");
		index=atoi(token);
		if(index==-1){
			break;
		}
		if(index!=_index)
			assert(0);
		token=strtok(NULL," \t\n,");
		spike_t=atoi(token);
		AddSpike(atoi(token));
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2008, %rsp           # imm = 0x2008
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %rdi
movl $0x1fff, %esi           # imm = 0x1FFF
movq %rbx, %rdx
callq 0x34c0
testq %rax, %rax
je 0x42e8
cmpb $0xa, (%rsp)
je 0x42e8
leaq 0x12e37(%rip), %r15     # 0x170c7
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x34a0
movq %rax, %rdi
callq 0x3490
cmpl $-0x1, %eax
je 0x4307
cmpl 0x40(%r14), %eax
jne 0x4316
xorl %edi, %edi
movq %r15, %rsi
callq 0x34a0
movq %rax, %rdi
callq 0x3490
movq %r14, %rdi
movl %eax, %esi
callq 0x3ddc
movq %r12, %rdi
movl $0x1fff, %esi           # imm = 0x1FFF
movq %rbx, %rdx
callq 0x34c0
testq %rax, %rax
je 0x42e8
cmpb $0xa, (%rsp)
jne 0x4293
leaq 0x14041(%rip), %rdi     # 0x18330
leaq 0x12d55(%rip), %rsi     # 0x1704b
leaq 0x12daf(%rip), %rcx     # 0x170ac
movl $0x76, %edx
callq 0x31b0
addq $0x2008, %rsp           # imm = 0x2008
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x14013(%rip), %rdi     # 0x18330
leaq 0x12d27(%rip), %rsi     # 0x1704b
leaq 0x12d81(%rip), %rcx     # 0x170ac
movl $0x7e, %edx
callq 0x31b0
nop
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/speech.C
// Function: Speech::SetNumChannel(int, channelmode_t)
void Speech::SetNumChannel(int size, channelmode_t mode){
    assert(size >= 0);
    while(_channel_map[mode]->size() < size){
        Channel * channel = new Channel(_channel_map[mode]->size());
        channel->SetMode(mode);
        _channel_map[mode]->push_back(channel);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testl %esi, %esi
js 0x4a6e
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
addq $0x48, %r14
leaq 0x10(%rsp), %rsi
movl %edx, (%rsi)
movq %r14, %rdi
callq 0x651c
movq (%rax), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x3, %rcx
movl %ebp, %ebp
cmpq %rbp, %rcx
jae 0x4a5f
leaq 0xc(%rsp), %r15
leaq 0x10(%rsp), %r12
movl $0x48, %edi
callq 0x32e0
movq %rax, %r13
movl %ebx, 0xc(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x651c
movq (%rax), %rax
movq 0x8(%rax), %rsi
subq (%rax), %rsi
shrq $0x3, %rsi
movq %r13, %rdi
callq 0x3d84
movq %r13, 0x10(%rsp)
movl %ebx, 0x44(%r13)
movl %ebx, 0xc(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x651c
movq (%rax), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x4a31
movq 0x10(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x4a39
movq %r12, %rdx
callq 0x67fc
movl %ebx, 0x10(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x651c
movq (%rax), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x3, %rcx
cmpq %rbp, %rcx
jb 0x49cb
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x12671(%rip), %rdi     # 0x170e6
leaq 0x12674(%rip), %rsi     # 0x170f0
leaq 0x12676(%rip), %rcx     # 0x170f9
movl $0x25, %edx
callq 0x31b0
movq %rax, %rbx
movl $0x48, %esi
movq %r13, %rdi
callq 0x32f0
movq %rbx, %rdi
callq 0x3570
nop
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/speech.C
// Function: Speech::ClearChannel(channelmode_t)
void Speech::ClearChannel(channelmode_t channelmode){
    if(_channel_map.find(channelmode) == _channel_map.end()){
        cout<<"Invalid channel type: "<<channelmode<<endl;
        exit(EXIT_FAILURE);
    }

    for(size_t i = 0; i < _channel_map[channelmode]->size(); ++i){
        Channel * channel = (*_channel_map[channelmode])[i]; 
        assert(channel);
        channel->Clear();
    }

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movslq %esi, %rax
movq 0x48(%rdi), %rsi
movq 0x50(%rdi), %rdi
xorl %r9d, %r9d
xorl %edx, %edx
divq %rdi
movq (%rsi,%rdx,8), %rax
testq %rax, %rax
je 0x4c09
movq (%rax), %r8
movq %rax, %r9
cmpl %ebx, 0x8(%r8)
je 0x4c09
movq %rdx, %rcx
movq %r8, %r10
movq (%r8), %r8
testq %r8, %r8
je 0x4c06
movslq 0x8(%r8), %rsi
movq %rsi, %rax
xorl %edx, %edx
divq %rdi
movl $0x0, %r9d
cmpq %rcx, %rdx
jne 0x4c09
movq %r10, %r9
cmpl %ebx, %esi
jne 0x4bdb
jmp 0x4c09
xorl %r9d, %r9d
testq %r9, %r9
je 0x4cbd
cmpq $0x0, (%r9)
je 0x4cbd
addq $0x48, %r14
leaq 0x8(%rsp), %rsi
movl %ebx, (%rsi)
movq %r14, %rdi
callq 0x651c
movq (%rax), %rax
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0x4c90
xorl %r13d, %r13d
leaq 0xc(%rsp), %r15
leaq 0x8(%rsp), %r12
movl %ebx, 0xc(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x651c
movq (%rax), %rax
movq (%rax), %rax
movq (%rax,%r13,8), %rdi
testq %rdi, %rdi
je 0x4c9e
callq 0x417c
incq %r13
movl %ebx, 0x8(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x651c
movq (%rax), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jb 0x4c48
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x12abf(%rip), %rdi     # 0x17764
leaq 0x12444(%rip), %rsi     # 0x170f0
leaq 0x124de(%rip), %rcx     # 0x17191
movl $0x42, %edx
callq 0x31b0
movq 0x1c30c(%rip), %rdi     # 0x20fd0
leaq 0x124af(%rip), %rsi     # 0x1717a
callq 0x32c0
movq %rax, %rdi
movl %ebx, %esi
callq 0x3560
movq %rax, %rdi
callq 0x3160
movl $0x1, %edi
callq 0x3370