LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x12c2
movq 0x8(%rbx), %rax
movl 0x8(%rax), %eax
cmpl $0x13, %eax
je 0x6280
cmpl $0x38, %eax
je 0x6299
pushq $0x7
popq %rdi
movq %rbx, %rsi
callq 0x3ac4
movq %r14, %rdi
addq $0x1010, %rsp           # imm = 0x1010
popq %rbx
popq %r14
popq %r15
jmp 0x3e46
movl $0x201, %ecx            # imm = 0x201
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5770
movq %rbx, %rdi
callq 0x12c2
movl $0x201, %ecx            # imm = 0x201
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4855
movq 0x8(%rbx), %rax
cmpl $0x38, 0x8(%rax)
je 0x62d7
pushq $0x7
popq %rdi
movq %rbx, %rsi
callq 0x3ac4
movq %r14, %rdi
callq 0x3e46
movq %rbx, %rdi
callq 0x12c2
movq 0x8(%rbx), %rax
cmpl $0x34, 0x8(%rax)
je 0x6302
movl $0x201, %ecx            # imm = 0x201
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4d97
movq %rbx, %rdi
addq $0x1010, %rsp           # imm = 0x1010
popq %rbx
popq %r14
popq %r15
jmp 0x1586
// File: /workspace/github_c_makefile_star2_O2/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 0x12ba
leaq 0x1898(%rip), %r14      # 0x8297
leaq 0x5a92(%rip), %r15      # 0xc498
movq 0x8(%rbx), %rax
cmpl $0x1d, 0x8(%rax)
je 0x6a44
movq (%rax), %rdi
movq %r14, %rsi
callq 0x1080
testl %eax, %eax
jne 0x6a3a
movq %r15, %rdi
callq 0x3e75
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x6753
movq %rbx, %rdi
callq 0x12c2
jmp 0x6a06
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x40(%rsp), %r14d
testq %r14, %r14
je 0x6da3
movq %rdi, %rbx
leaq 0x40(%rsp), %r15
xorl %r12d, %r12d
testl %r14d, %r14d
movl $0x0, %r13d
cmovgl %r14d, %r13d
cmpq %r13, %r12
je 0x6da3
xorl %ebp, %ebp
cmpq %rbp, %r14
je 0x6d79
cmpq %rbp, %r12
je 0x6d74
movq 0x8(%r15,%r12,8), %rdi
movq 0x8(%r15,%rbp,8), %rsi
callq 0x1080
testl %eax, %eax
je 0x6d7e
incq %rbp
jmp 0x6d57
incq %r12
jmp 0x6d50
leaq 0x765b(%rip), %rdi      # 0xe3e0
callq 0x3c99
pushq $0x3
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3ac4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MartinNovotny25[P]VUT-FIT-IFJ2020/semantics.c
// Function: checkFunction
void checkFunction(TDLList *L) {
    //pomocna premenna, BSTSearchGlobal() sem vravcia data
    functionData data;
    //pomocny string, ulozime sem identifikator fcie
    char *id = L->Act->rptr->tdata.lex;
    //identifikator funkcie je "main"
    if (!strcmp(id, "main")) {
        //ak uz main bol raz najdeny, volaj error
        if (mainFound) {
            error_call(ERR_SEM_UNDEF, L);
            return;
        }
        //pomocny pointer, mal by ukazovat vpravo od lexemu main, teda (
        struct TDLLElem *tmp = L->Act->rptr->rptr;
        //overime lexemi vpravo od identifikatoru main, ak su (){, tak sme nasli main
        if ((!strcmp(tmp->tdata.lex, "(")) && (!strcmp(tmp->rptr->tdata.lex, ")")) && (!strcmp(tmp->rptr->rptr->tdata.lex, "{"))) {
            mainFound = true;
        }
        else {
            if ((!strcmp(tmp->tdata.lex, "(")) &&
                (!strcmp(tmp->rptr->tdata.lex, ")")) &&
                (!strcmp(tmp->rptr->rptr->tdata.lex, "(")) &&
                (!strcmp(tmp->rptr->rptr->rptr->tdata.lex, ")")) &&
                (!strcmp(tmp->rptr->rptr->rptr->rptr->tdata.lex, "{"))) {
                mainFound = true;
            } else {
                //main nema spravne parametre, volaj error
                error_call(ERR_SEM_RETURN, L);
                return;
            }
        }
    } else {
        //skontroluj ci identifikator uz neni v symtable
        if (BSTSearchGlobal(functions, id, &data)) {
            error_call(ERR_SEM_UNDEF, L);
        }
        checkFunctionParams(L, id);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1010, %rsp           # imm = 0x1010
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %r15
movq (%r15), %r14
leaq 0x1629(%rip), %rsi      # 0x851a
movq %r14, %rdi
callq 0x1080
testl %eax, %eax
je 0x6f38
movq 0x74dc(%rip), %rdi      # 0xe3e0
leaq 0x8(%rsp), %rdx
movq %r14, %rsi
callq 0x3b85
testb %al, %al
je 0x6f20
pushq $0x3
popq %rdi
movq %rbx, %rsi
callq 0x3ac4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6db2
addq $0x1010, %rsp           # imm = 0x1010
popq %rbx
popq %r14
popq %r15
retq
cmpb $0x1, 0x5551(%rip)      # 0xc490
jne 0x6f45
pushq $0x3
jmp 0x6fb9
movq 0x18(%r15), %rax
movq (%rax), %rcx
cmpb $0x28, (%rcx)
jne 0x6fb7
cmpb $0x0, 0x1(%rcx)
jne 0x6fb7
movq 0x18(%rax), %rax
movq (%rax), %rcx
cmpb $0x29, (%rcx)
jne 0x6fb7
cmpb $0x0, 0x1(%rcx)
jne 0x6f7b
movq 0x18(%rax), %rdx
movq (%rdx), %rdx
cmpb $0x7b, (%rdx)
jne 0x6f7b
cmpb $0x0, 0x1(%rdx)
je 0x6fce
cmpb $0x0, 0x1(%rcx)
jne 0x6fb7
movq 0x18(%rax), %rax
movq (%rax), %rcx
cmpb $0x28, (%rcx)
jne 0x6fb7
cmpb $0x0, 0x1(%rcx)
jne 0x6fb7
movq 0x18(%rax), %rax
movq (%rax), %rcx
cmpb $0x29, (%rcx)
jne 0x6fb7
cmpb $0x0, 0x1(%rcx)
jne 0x6fb7
movq 0x18(%rax), %rax
movq (%rax), %rax
cmpb $0x7b, (%rax)
jne 0x6fb7
cmpb $0x0, 0x1(%rax)
je 0x6fce
pushq $0x6
popq %rdi
movq %rbx, %rsi
addq $0x1010, %rsp           # imm = 0x1010
popq %rbx
popq %r14
popq %r15
jmp 0x3ac4
movb $0x1, 0x54bb(%rip)      # 0xc490
jmp 0x6f2b
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x73f7(%rip), %rdi      # 0xe3e0
callq 0x3b80
callq 0x6a4a
movq %rbx, %rdi
callq 0x12ba
leaq 0x1295(%rip), %r14      # 0x8297
movq 0x8(%rbx), %r15
cmpl $0x1d, 0x8(%r15)
je 0x7039
movq (%r15), %rdi
movq %r14, %rsi
callq 0x1080
testl %eax, %eax
jne 0x7028
movq %rbx, %rdi
callq 0x6ed0
movq 0x8(%rbx), %r15
cmpq $0x0, 0x18(%r15)
je 0x706b
movq %rbx, %rdi
callq 0x12c2
jmp 0x7002
cmpb $0x0, 0x5450(%rip)      # 0xc490
je 0x706f
movq %rbx, %rdi
callq 0x12ba
movq %rbx, %rdi
callq 0x69eb
movq %rbx, %rdi
callq 0x12e0
leaq 0x737f(%rip), %rdi      # 0xe3e0
popq %rbx
popq %r14
popq %r15
jmp 0x3c99
pushq $0x63
jmp 0x7071
pushq $0x3
popq %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3ac4
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x10
popq %rdi
callq 0x10a0
testq %rax, %rax
je 0x70a6
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_O2/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 0x70c5
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_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %eax, %eax
movq %rdi, %rcx
movq %rax, %r15
movq (%rcx), %rax
testq %rax, %rax
je 0x7130
movl (%rax), %edx
andl $-0x2, %edx
leaq 0x8(%rax), %rcx
cmpl $0xe, %edx
je 0x70f8
pushq $0x10
popq %rdi
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_O2/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 0x71fe(%rip), %rbx      # 0xe3e8
movq 0x71f7(%rip), %rsi      # 0xe3e8
movl 0x71f9(%rip), %edi      # 0xe3f0
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x719c
movb %al, 0x71ee(%rip)       # 0xe3f4
movq %rbx, %rdi
callq 0x70ad
movq %rbx, %rdi
callq 0x70ad
pushq $0xf
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x7085
// File: /workspace/github_c_makefile_star2_O2/giometti[P]mastering_UNIX_programming/chapter_07/fgets.c
// Function: main
int main(int argc, char *argv[])
{
	size_t size = BUFSIZ;
	char buf[MAX_SIZE];
	char *ptr;
	int ret;

        if (argc > 1)
		size = atoi(argv[1]);
	if ((size <= 1) || (size > MAX_SIZE)) {
                fprintf(stderr, "invalid size, must be in [2,%d]\n",
			MAX_SIZE);
                return -1;
	}
	fprintf(stderr, "set buffer size to %ld\n", size);

	ret = setvbuf(stdin, NULL, _IOFBF, size);
	if (ret) {
		fprintf(stderr, "setvbuf error for stdin\n");
		return -1;
	}
	ret = setvbuf(stdout, NULL, _IOFBF, size);
	if (ret) {
		fprintf(stderr, "setvbuf error for stdout\n");
		return -1;
	}

	while (!feof(stdin)) {
		/* Read data from input file */
		ptr = fgets(buf, size, stdin);
		if (ptr == NULL) {
			if (ferror(stdin)) {
				fprintf(stderr, "error in reading\n");
				return -1;
			}
			break;
		}

		/* Write data to output file */
		ret = fputs(buf, stdout);
		if (ret == EOF) {
			if (ferror(stdout)) {
				fprintf(stderr, "error in writing\n");
				return -1;
			}
			break;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40008, %rsp          # imm = 0x40008
movl $0x2000, %ebx           # imm = 0x2000
cmpl $0x2, %edi
jl 0x1204
movq 0x8(%rsi), %rdi
callq 0x1090
movslq %eax, %rbx
leaq -0x40001(%rbx), %rax
cmpq $-0x40000, %rax         # imm = 0xFFFC0000
ja 0x1204
movq 0x2e0f(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xe11(%rip), %rsi       # 0x2004
movl $0x40000, %edx          # imm = 0x40000
xorl %eax, %eax
callq 0x1060
jmp 0x12e6
movq 0x2ded(%rip), %r15      # 0x3ff8
movq (%r15), %rdi
leaq 0xe10(%rip), %rsi       # 0x2025
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1060
movq 0x2db2(%rip), %r12      # 0x3fd8
movq (%r12), %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x1080
testl %eax, %eax
jne 0x12c3
movq 0x2d8b(%rip), %r13      # 0x3fd0
movq (%r13), %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x1080
testl %eax, %eax
jne 0x12d1
movq %rsp, %r14
xorl %ebp, %ebp
movq (%r12), %rdi
callq 0x1070
testl %eax, %eax
jne 0x12e9
movq (%r12), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x1050
testq %rax, %rax
je 0x12a8
movq (%r13), %rsi
movq %r14, %rdi
callq 0x1040
cmpl $-0x1, %eax
jne 0x125e
movq (%r13), %rdi
callq 0x1030
testl %eax, %eax
je 0x12e9
movq (%r15), %rcx
leaq 0xddc(%rip), %rdi       # 0x2082
jmp 0x12bf
movq (%r12), %rdi
callq 0x1030
testl %eax, %eax
je 0x12e9
movq (%r15), %rcx
leaq 0xdb1(%rip), %rdi       # 0x2070
pushq $0x11
jmp 0x12dd
movq (%r15), %rcx
leaq 0xd70(%rip), %rdi       # 0x203d
pushq $0x18
jmp 0x12dd
movq (%r15), %rcx
leaq 0xd7b(%rip), %rdi       # 0x2056
pushq $0x19
popq %rsi
pushq $0x1
popq %rdx
callq 0x10a0
pushq $-0x1
popq %rbp
movl %ebp, %eax
addq $0x40008, %rsp          # imm = 0x40008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0xa
popq %rdi
callq 0x1030
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x24c5
movq %rdi, %rbx
pushq $0x38
popq %rdi
callq 0x2150
movl %r14d, (%rax)
movl 0xc(%rbx), %ecx
movl %ecx, 0x4(%rax)
movq $0x4, 0x10(%rax)
andq $0x0, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3d68(%rip), %rdi      # 0x6234
leaq 0x3da2(%rip), %rsi      # 0x6275
leaq 0x3da1(%rip), %rcx      # 0x627b
pushq $0x18
popq %rdx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O2/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 0x252a
movq %rdx, %rbx
movq %rsi, %rax
movq 0x8(%rsi), %rcx
movq 0x10(%rsi), %rsi
cmpq %rsi, %rcx
jb 0x251b
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x10(%rax)
shlq $0x4, %rsi
addq $0x18, %rsi
movq %rax, %rdi
callq 0x2170
movq 0x8(%rax), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq %rbx, 0x18(%rax,%rcx,8)
popq %rbx
retq
leaq 0x3d9f(%rip), %rdi      # 0x62d0
leaq 0x3d3d(%rip), %rsi      # 0x6275
leaq 0x3dde(%rip), %rcx      # 0x631d
pushq $0x26
popq %rdx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O2/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 0x2586
movq %rsi, %r15
cmpl $0x4, (%rsi)
jne 0x259f
movq %rcx, %r14
movq %rdx, %rbx
pushq $0x20
popq %rdi
callq 0x2150
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 0x3fa0(%rip), %rdi      # 0x652d
leaq 0x3ce1(%rip), %rsi      # 0x6275
leaq 0x3def(%rip), %rcx      # 0x638a
pushq $0x37
jmp 0x25b6
leaq 0x4054(%rip), %rdi      # 0x65fa
leaq 0x3cc8(%rip), %rsi      # 0x6275
leaq 0x3dd6(%rip), %rcx      # 0x638a
pushq $0x38
popq %rdx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x8
popq %rdi
callq 0x2150
movl $0xc, (%rax)
movl 0xc(%rbx), %ecx
movl %ecx, 0x4(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x8
popq %rdi
callq 0x2150
movl $0xd, (%rax)
movl 0xc(%rbx), %ecx
movl %ecx, 0x4(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2604
cmpl $0x2, (%rbx)
jne 0x2633
pushq $0x10
popq %rdi
callq 0x2150
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 0x3dce(%rip), %rdi      # 0x6408
leaq 0x3c34(%rip), %rsi      # 0x6275
leaq 0x3df8(%rip), %rcx      # 0x6440
pushq $0x59
popq %rdx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O2/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 0x2694
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
testq %rcx, %rcx
je 0x266d
cmpl $0x1, (%rbx)
jne 0x26ad
pushq $0x20
popq %rdi
callq 0x2150
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 0x3e92(%rip), %rdi      # 0x652d
leaq 0x3bd3(%rip), %rsi      # 0x6275
leaq 0x3dec(%rip), %rcx      # 0x6495
pushq $0x67
jmp 0x26c4
leaq 0x3e5e(%rip), %rdi      # 0x6512
leaq 0x3bba(%rip), %rsi      # 0x6275
leaq 0x3dd3(%rip), %rcx      # 0x6495
pushq $0x68
popq %rdx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O2/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 0x2703
movq %rdx, %rbx
cmpl $0x2, (%rdx)
jne 0x271c
movq %rsi, %r14
pushq $0x18
popq %rdi
callq 0x2150
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 0x3e4a(%rip), %rdi      # 0x6554
leaq 0x3b64(%rip), %rsi      # 0x6275
leaq 0x3e61(%rip), %rcx      # 0x6579
pushq $0x78
jmp 0x2733
leaq 0x3cf6(%rip), %rdi      # 0x6419
leaq 0x3b4b(%rip), %rsi      # 0x6275
leaq 0x3e48(%rip), %rcx      # 0x6579
pushq $0x79
popq %rdx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O2/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 0x2752
cmpl $0x4, (%r14)
jne 0x27c2
cmpl $0x1, (%rbx)
jne 0x2784
cmpl $0x1e, (%r15)
jne 0x27a3
pushq $0x20
popq %rdi
callq 0x2150
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 0x3da2(%rip), %rdi      # 0x652d
leaq 0x3ae3(%rip), %rsi      # 0x6275
leaq 0x3e8a(%rip), %rcx      # 0x6623
movl $0x89, %edx
callq 0x20f0
leaq 0x3ef8(%rip), %rdi      # 0x66a2
leaq 0x3ac4(%rip), %rsi      # 0x6275
leaq 0x3e6b(%rip), %rcx      # 0x6623
movl $0x8a, %edx
callq 0x20f0
leaq 0x3e1f(%rip), %rdi      # 0x65e8
leaq 0x3aa5(%rip), %rsi      # 0x6275
leaq 0x3e4c(%rip), %rcx      # 0x6623
movl $0x88, %edx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x10
popq %rdi
callq 0x2150
movl $0xf, (%rax)
movl 0x4(%rbx), %ecx
movl %ecx, 0x4(%rax)
movq %rbx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2814
cmpl $0x4, (%r14)
jne 0x2866
cmpl $0x1, (%rbx)
jne 0x2847
pushq $0x18
popq %rdi
callq 0x2150
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 0x3cdf(%rip), %rdi      # 0x652d
leaq 0x3a20(%rip), %rsi      # 0x6275
leaq 0x3e69(%rip), %rcx      # 0x66c5
movl $0xa5, %edx
callq 0x20f0
leaq 0x3d7b(%rip), %rdi      # 0x65e8
leaq 0x3a01(%rip), %rsi      # 0x6275
leaq 0x3e4a(%rip), %rcx      # 0x66c5
movl $0xa4, %edx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0x2150
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_O2/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
pushq $0x20
popq %rdi
callq 0x2150
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_O2/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 0x28f4
cmpl $0x2, (%rbx)
jne 0x2919
pushq $0x18
popq %rdi
callq 0x2150
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 0x3ae8(%rip), %rdi      # 0x6408
leaq 0x394e(%rip), %rsi      # 0x6275
leaq 0x3dff(%rip), %rcx      # 0x672d
movl $0xcd, %edx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O2/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 0x296c
movq %rdx, %rbx
movq %rsi, %r14
pushq $0x18
popq %rdi
callq 0x2150
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 0x3e23(%rip), %rdi      # 0x6796
leaq 0x38fb(%rip), %rsi      # 0x6275
leaq 0x3e3b(%rip), %rcx      # 0x67bc
movl $0xdb, %edx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0x2150
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_O2/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 0x29d5
movl (%rbx), %eax
cmpl $0x2, %eax
je 0x29d5
cmpl $0x5, %eax
jne 0x2a04
pushq $0x10
popq %rdi
callq 0x2150
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 0x3e1b(%rip), %rdi      # 0x6826
leaq 0x3863(%rip), %rsi      # 0x6275
leaq 0x3e71(%rip), %rcx      # 0x688a
movl $0xf6, %edx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0x2150
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_O2/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 0x2a83
movq %rsi, %rbx
pushq $0x10
popq %rdi
callq 0x2150
movl $0x1a, (%rax)
movl 0x4(%rbx), %ecx
movl %ecx, 0x4(%rax)
movq %rbx, 0x8(%rax)
popq %rbx
retq
leaq 0x3e54(%rip), %rdi      # 0x68de
leaq 0x37e4(%rip), %rsi      # 0x6275
leaq 0x3e91(%rip), %rcx      # 0x6929
movl $0x10f, %edx            # imm = 0x10F
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x10
popq %rdi
callq 0x2150
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_O2/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
pushq $0x10
popq %rdi
callq 0x2150
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_O2/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
pushq $0x10
popq %rdi
callq 0x2150
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_O2/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
pushq $0x10
popq %rdi
callq 0x2150
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_O2/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
pushq $0x10
popq %rdi
callq 0x2150
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_O2/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 0x38d4
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x2d1f
movq %r15, %rdi
callq 0x3a98
movq %rax, %rbx
movq %r15, %rdi
callq 0x38f6
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x343b
movl $0x11555, %eax          # imm = 0x11555
btl %ebp, %eax
jae 0x343b
movl %ebp, %eax
leaq 0x2dbe(%rip), %rcx      # 0x61f0
movslq (%rcx,%rax,4), %rbx
addq %rcx, %rbx
jmp 0x34a2
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x38d4
movl %ebp, %r15d
incq %r15
leaq 0x35d6(%rip), %r14      # 0x6a2b
decq %r15
je 0x348a
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3929
testb %al, %al
jne 0x3455
leaq 0x35bb(%rip), %rdi      # 0x6a2d
leaq 0x2dfc(%rip), %rsi      # 0x6275
leaq 0x35d0(%rip), %rcx      # 0x6a50
movl $0x218, %edx            # imm = 0x218
callq 0x20f0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3a98
movq %rax, %rbx
movq %r14, %rdi
callq 0x38f6
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5af9
movq %r15, (%rbx)
movl $0x1, 0x34(%rbx)
movq 0x28(%r12), %rax
testq %rax, %rax
je 0x59fe
movq 0x18(%r12), %rcx
movq (%rax,%rcx,8), %rax
jmp 0x5a00
xorl %eax, %eax
cmpq %rbx, %rax
je 0x5a0d
movq $0x1, 0x2c(%rbx)
testq %r15, %r15
je 0x5a2a
movq %r15, %rdi
callq 0x2140
movl %eax, %edi
callq 0x2080
xorl %ecx, %ecx
testl %eax, %eax
setg %cl
jmp 0x5a2c
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_O2/yangtau[P]hedgehog/src/lex.hedgehog.c
// Function: hg_yylex_init
int yylex_init(yyscan_t* ptr_yy_globals)
{
    if (ptr_yy_globals == NULL){
        errno = EINVAL;
        return 1;
    }

    *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );

    if (*ptr_yy_globals == NULL){
        errno = ENOMEM;
        return 1;
    }

    /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));

    return yy_init_globals ( *ptr_yy_globals );
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x5e3c
movq %rdi, %rbx
pushq $0x1
popq %rdi
movl $0x98, %esi
callq 0x2100
movq %rax, %rcx
movq %rax, (%rbx)
xorl %eax, %eax
testq %rcx, %rcx
jne 0x5e49
pushq $0xc
jmp 0x5e3e
pushq $0x16
popq %rbx
callq 0x2050
movl %ebx, (%rax)
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movl %esi, 0xc(%rsp)
leaq 0x18(%rdi), %rbx
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %r14
subq %rax, %r14
sarq $0x2, %r14
testl %r14d, %r14d
jle 0x3973
decl %r14d
movl (%rax,%r14,4), %eax
cmpl %ebp, %eax
jl 0x3956
movq 0x1c6a6(%rip), %rdi     # 0x1ffc8
movl %ebp, %esi
callq 0x3530
leaq 0x10700(%rip), %rsi     # 0x14030
movq %rax, %rdi
callq 0x32a0
movq (%rbx), %rcx
movl (%rcx,%r14,4), %esi
movq %rax, %rdi
callq 0x3530
movq %rax, %rdi
callq 0x3160
movq (%rbx), %rax
movl (%rax,%r14,4), %eax
cmpl %ebp, %eax
jl 0x3977
leaq 0x106d1(%rip), %rdi     # 0x14032
leaq 0x106e3(%rip), %rsi     # 0x1404b
leaq 0x106e6(%rip), %rcx     # 0x14055
pushq $0x25
jmp 0x39a4
testl %ebp, %ebp
jle 0x398d
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x3d58
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x106dd(%rip), %rdi     # 0x14071
leaq 0x106b0(%rip), %rsi     # 0x1404b
leaq 0x106b3(%rip), %rcx     # 0x14055
pushq $0x27
popq %rdx
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x70(%rsi), %rdi
callq 0x30a0
testb %al, %al
je 0x3c5e
movq 0x18(%r14), %rcx
movq 0x20(%r14), %rax
cmpq %rax, %rcx
je 0x3c58
leaq 0x1041c(%rip), %r15     # 0x14030
movq %rcx, 0x30(%r14)
cmpq %rax, %rcx
je 0x3c58
movl 0x40(%r14), %esi
movq %rbx, %rdi
callq 0x3530
movq %rax, %rdi
movq %r15, %rsi
callq 0x32a0
movq 0x30(%r14), %rcx
movl (%rcx), %esi
movq %rax, %rdi
callq 0x3530
movq %rax, %rdi
callq 0x3160
movq 0x20(%r14), %rax
movq 0x30(%r14), %rcx
addq $0x4, %rcx
jmp 0x3c14
popq %rbx
popq %r14
popq %r15
retq
leaq 0x10417(%rip), %rdi     # 0x1407c
leaq 0x103df(%rip), %rsi     # 0x1404b
leaq 0x10419(%rip), %rcx     # 0x1408c
pushq $0x69
popq %rdx
callq 0x31b0
nop
// File: /workspace/github_c_makefile_star2_O2/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, %r15
leaq 0x1042d(%rip), %r12     # 0x140c7
movq %r15, %rdi
movl $0x1fff, %esi           # imm = 0x1FFF
movq %rbx, %rdx
callq 0x3490
testq %rax, %rax
je 0x3d00
cmpb $0xa, (%rsp)
je 0x3d00
movq %r15, %rdi
movq %r12, %rsi
callq 0x3470
movq %rax, %rdi
callq 0x3460
cmpl $-0x1, %eax
je 0x3cf1
cmpl 0x40(%r14), %eax
jne 0x3d19
xorl %edi, %edi
movq %r12, %rsi
callq 0x3470
movq %rax, %rdi
callq 0x3460
movq %r14, %rdi
movl %eax, %esi
callq 0x38ea
jmp 0x3c9a
addq $0x2008, %rsp           # imm = 0x2008
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x116a9(%rip), %rdi     # 0x153b0
leaq 0x1033d(%rip), %rsi     # 0x1404b
leaq 0x10397(%rip), %rcx     # 0x140ac
pushq $0x76
jmp 0x3d30
leaq 0x11690(%rip), %rdi     # 0x153b0
leaq 0x10324(%rip), %rsi     # 0x1404b
leaq 0x1037e(%rip), %rcx     # 0x140ac
pushq $0x7e
popq %rdx
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O2/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 0x43fd
movl %edx, %ebx
movq %rdi, %r14
addq $0x48, %r14
movl %esi, %r12d
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %r13
movl %ebx, 0x10(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x5316
movq (%rax), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
jae 0x43ee
pushq $0x48
popq %rdi
callq 0x32c0
movq %rax, %rbp
movl %ebx, 0xc(%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0x5316
movq (%rax), %rax
movq 0x8(%rax), %rsi
subq (%rax), %rsi
shrq $0x3, %rsi
movq %rbp, %rdi
callq 0x38ae
movq %rbp, 0x10(%rsp)
movl %ebx, 0x44(%rbp)
movl %ebx, 0xc(%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0x5316
movq (%rax), %rdi
movq %r15, %rsi
callq 0x502a
jmp 0x4378
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xfce2(%rip), %rdi      # 0x140e6
leaq 0xfce5(%rip), %rsi      # 0x140f0
leaq 0xfce7(%rip), %rcx      # 0x140f9
pushq $0x25
popq %rdx
callq 0x31b0
movq %rax, %rbx
pushq $0x48
popq %rsi
movq %rbp, %rdi
callq 0x32d0
movq %rbx, %rdi
callq 0x3540