LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/MartinNovotny25[P]VUT-FIT-IFJ2020/precanalysis.c
// Function: pop3_push
void pop3_push(){

    //3 symboly potrebne pre redukciu
    tsym_stack_symbol* red1;
    tsym_stack_symbol* red2;
    tsym_stack_symbol* red3;

    red3 = syms_Stack.top;
    red2 = red3->next;
    red1 = red3->next->next;

    // Apliakcia pravidla
    reduction_succ  = psa_rule_application(count, red1, red2, red3);

    //Popnutie 3 symbolob, ktore sa redukovali
    symstack_pop(&syms_Stack);
    symstack_pop(&syms_Stack);
    symstack_pop(&syms_Stack);
    symstack_pop(&syms_Stack); //popuje sa RED symbol

    // push nonterm
    symstack_push(&syms_Stack, T_NON_TERM);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x5f69(%rip), %rax      # 0x123d8
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movl 0x5f4b(%rip), %edi      # 0x123e0
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0xc500
andb $0x1, %al
movb %al, 0x5f36(%rip)       # 0x123e4
leaq 0x5f23(%rip), %rdi      # 0x123d8
callq 0xc2c0
leaq 0x5f17(%rip), %rdi      # 0x123d8
callq 0xc2c0
leaq 0x5f0b(%rip), %rdi      # 0x123d8
callq 0xc2c0
leaq 0x5eff(%rip), %rdi      # 0x123d8
callq 0xc2c0
leaq 0x5ef3(%rip), %rdi      # 0x123d8
movl $0xf, %esi
callq 0xc270
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x5d79(%rip), %rax      # 0x123d8
movq %rax, -0x8(%rbp)
movl 0x5d77(%rip), %edi      # 0x123e0
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0xc500
andb $0x1, %al
movb %al, 0x5d63(%rip)       # 0x123e4
leaq 0x5d50(%rip), %rdi      # 0x123d8
callq 0xc2c0
leaq 0x5d44(%rip), %rdi      # 0x123d8
callq 0xc2c0
leaq 0x5d38(%rip), %rdi      # 0x123d8
movl $0xf, %esi
callq 0xc270
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv2aes128/ref/poet.c
// Function: to_array
static inline void to_array(unsigned char* dst, 
                            const uint64_t* src, 
                            const size_t n)
{
    size_t i;
    size_t j;
    for (i = 0; i < n; i++) {
        for (j = 0; j < 8; ++j) {
            dst[i*8+j] = (unsigned char)((src[i] >> (8*j)) & 0xFF);
        }
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x18(%rsp), %rax
jae 0x702f
movq $0x0, -0x28(%rsp)
cmpq $0x8, -0x28(%rsp)
jae 0x701d
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x28(%rsp), %rcx
shlq $0x3, %rcx
shrq %cl, %rax
andq $0xff, %rax
movb %al, %dl
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
shlq $0x3, %rcx
addq -0x28(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x6fcd
jmp 0x701f
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x6fb8
retq
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/9-File/fork.c
// Function: main
int main(void) {
	printf("Hello");
	fork();
	printf("\n");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xe9e(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
callq 0x1040
leaq 0xe91(%rip), %rdi       # 0x200a
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jbe 0x251d
cmpl $0x6, -0x14(%rbp)
jae 0x251d
jmp 0x253c
leaq 0x9d10(%rip), %rdi      # 0xc234
leaq 0x9d4a(%rip), %rsi      # 0xc275
movl $0x18, %edx
leaq 0x9d44(%rip), %rcx      # 0xc27b
callq 0x20f0
movq $0x38, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2160
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movq $0x4, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jbe 0x25b8
movq -0x20(%rbp), %rax
cmpl $0x6, (%rax)
jae 0x25b8
jmp 0x25d7
leaq 0x9d11(%rip), %rdi      # 0xc2d0
leaq 0x9caf(%rip), %rsi      # 0xc275
movl $0x26, %edx
leaq 0x9d4b(%rip), %rcx      # 0xc31d
callq 0x20f0
movq -0x20(%rbp), %rax
subq $0x0, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x2639
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
shlq %rcx
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
shlq $0x3, %rax
addq $0x18, %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2180
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rax
movq -0x30(%rbp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movq %rdx, 0x18(%rax,%rcx,8)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x2693
jmp 0x26b2
leaq 0x9e93(%rip), %rdi      # 0xc52d
leaq 0x9bd4(%rip), %rsi      # 0xc275
movl $0x37, %edx
leaq 0x9cdd(%rip), %rcx      # 0xc38a
callq 0x20f0
movq -0x18(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x26bd
jmp 0x26dc
leaq 0x9f36(%rip), %rdi      # 0xc5fa
leaq 0x9baa(%rip), %rsi      # 0xc275
movl $0x38, %edx
leaq 0x9cb3(%rip), %rcx      # 0xc38a
callq 0x20f0
movq $0x20, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2160
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x9, (%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x8, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2160
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0xc, (%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x8, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2160
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0xd, (%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2800
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x2802
jmp 0x2821
leaq 0x9bff(%rip), %rdi      # 0xc408
leaq 0x9a65(%rip), %rsi      # 0xc275
movl $0x59, %edx
leaq 0x9c24(%rip), %rcx      # 0xc440
callq 0x20f0
movq $0x10, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2160
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0xe, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x2853
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x285d
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x28a3
jmp 0x28c2
leaq 0x9c83(%rip), %rdi      # 0xc52d
leaq 0x99c4(%rip), %rsi      # 0xc275
movl $0x67, %edx
leaq 0x9bd8(%rip), %rcx      # 0xc495
callq 0x20f0
cmpq $0x0, -0x28(%rbp)
je 0x28d2
movq -0x28(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x28d4
jmp 0x28f3
leaq 0x9c37(%rip), %rdi      # 0xc512
leaq 0x9993(%rip), %rsi      # 0xc275
movl $0x68, %edx
leaq 0x9ba7(%rip), %rcx      # 0xc495
callq 0x20f0
movq $0x20, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2160
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0xa, (%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, -0x28(%rbp)
jne 0x2947
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x294f
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x298f
jmp 0x29ae
leaq 0x9bbe(%rip), %rdi      # 0xc554
leaq 0x98d8(%rip), %rsi      # 0xc275
movl $0x78, %edx
leaq 0x9bd0(%rip), %rcx      # 0xc579
callq 0x20f0
movq -0x20(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x29b9
jmp 0x29d8
leaq 0x9a59(%rip), %rdi      # 0xc419
leaq 0x98ae(%rip), %rsi      # 0xc275
movl $0x79, %edx
leaq 0x9ba6(%rip), %rcx      # 0xc579
callq 0x20f0
movq $0x18, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2160
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x8, (%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2a58
movq -0x20(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x2a5a
jmp 0x2a79
leaq 0x9b87(%rip), %rdi      # 0xc5e8
leaq 0x980d(%rip), %rsi      # 0xc275
movl $0x88, %edx
leaq 0x9baf(%rip), %rcx      # 0xc623
callq 0x20f0
movq -0x28(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x2a84
jmp 0x2aa3
leaq 0x9aa2(%rip), %rdi      # 0xc52d
leaq 0x97e3(%rip), %rsi      # 0xc275
movl $0x89, %edx
leaq 0x9b85(%rip), %rcx      # 0xc623
callq 0x20f0
movq -0x18(%rbp), %rax
cmpl $0x1e, (%rax)
jne 0x2aae
jmp 0x2acd
leaq 0x9bed(%rip), %rdi      # 0xc6a2
leaq 0x97b9(%rip), %rsi      # 0xc275
movl $0x8a, %edx
leaq 0x9b5b(%rip), %rcx      # 0xc623
callq 0x20f0
movq $0x20, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2160
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0xb, (%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x10, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2160
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0xf, (%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2bb4
movq -0x18(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x2bb6
jmp 0x2bd5
leaq 0x9a2b(%rip), %rdi      # 0xc5e8
leaq 0x96b1(%rip), %rsi      # 0xc275
movl $0xa4, %edx
leaq 0x9af5(%rip), %rcx      # 0xc6c5
callq 0x20f0
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x2be0
jmp 0x2bff
leaq 0x9946(%rip), %rdi      # 0xc52d
leaq 0x9687(%rip), %rsi      # 0xc275
movl $0xa5, %edx
leaq 0x9acb(%rip), %rcx      # 0xc6c5
callq 0x20f0
movq $0x18, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2160
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x15, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x2c31
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x2c3b
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x18, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2160
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x17, (%rax)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x20, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2160
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x16, (%rax)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0x14(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2d64
movq -0x20(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x2d66
jmp 0x2d85
leaq 0x969b(%rip), %rdi      # 0xc408
leaq 0x9501(%rip), %rsi      # 0xc275
movl $0xcd, %edx
leaq 0x99ad(%rip), %rcx      # 0xc72d
callq 0x20f0
movq $0x18, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2160
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x12, (%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x1e, (%rax)
jne 0x2dff
jmp 0x2e1e
leaq 0x9990(%rip), %rdi      # 0xc796
leaq 0x9468(%rip), %rsi      # 0xc275
movl $0xdb, %edx
leaq 0x99a3(%rip), %rcx      # 0xc7bc
callq 0x20f0
movq $0x18, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2160
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x13, (%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x18, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2160
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x14, (%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2f09
movq -0x18(%rbp), %rax
cmpl $0x5, (%rax)
je 0x2f09
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x2f0b
jmp 0x2f2a
leaq 0x9914(%rip), %rdi      # 0xc826
leaq 0x935c(%rip), %rsi      # 0xc275
movl $0xf6, %edx
leaq 0x9965(%rip), %rcx      # 0xc88a
callq 0x20f0
movq $0x10, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2160
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x18, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x2f5c
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x2f66
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x18, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2160
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x19, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x2fd6
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x2fe0
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x11, (%rax)
jbe 0x3034
movq -0x18(%rbp), %rax
cmpl $0x1b, (%rax)
jae 0x3034
jmp 0x3053
leaq 0x98a3(%rip), %rdi      # 0xc8de
leaq 0x9233(%rip), %rsi      # 0xc275
movl $0x10f, %edx            # imm = 0x10F
leaq 0x98db(%rip), %rcx      # 0xc929
callq 0x20f0
movq $0x10, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2160
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x1a, (%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq $0x10, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2160
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x22, (%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movsd -0x18(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq $0x10, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2160
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x20, (%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movb -0x11(%rbp), %cl
movq -0x20(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5c80
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
xorl %edx, %edx
leaq -0x30(%rbp), %rcx
callq 0x4000
leaq -0x30(%rbp), %rdi
callq 0x5f80
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5ce0
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl -0x10(%rbp), %ecx
imull %ecx, %eax
movl %eax, %ecx
movq %rcx, -0x48(%rbp)
subl $0x10, %eax
ja 0x52da
movq -0x48(%rbp), %rax
leaq 0x6f9f(%rip), %rcx      # 0xc1f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x6e3e(%rip), %rax      # 0xc09f
movq %rax, -0x8(%rbp)
jmp 0x5364
leaq 0x77d9(%rip), %rax      # 0xca4a
movq %rax, -0x8(%rbp)
jmp 0x5364
leaq 0x77c7(%rip), %rax      # 0xca48
movq %rax, -0x8(%rbp)
jmp 0x5364
leaq 0x77b5(%rip), %rax      # 0xca46
movq %rax, -0x8(%rbp)
jmp 0x5364
leaq 0x77a3(%rip), %rax      # 0xca44
movq %rax, -0x8(%rbp)
jmp 0x5364
leaq 0x7791(%rip), %rax      # 0xca42
movq %rax, -0x8(%rbp)
jmp 0x5364
leaq 0x777f(%rip), %rax      # 0xca40
movq %rax, -0x8(%rbp)
jmp 0x5364
leaq 0x776b(%rip), %rax      # 0xca3c
movq %rax, -0x8(%rbp)
jmp 0x5364
leaq -0x38(%rbp), %rdi
callq 0x5c80
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl -0xc(%rbp), %ecx
imull -0x10(%rbp), %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jae 0x5346
leaq -0x38(%rbp), %rdi
leaq 0x7743(%rip), %rsi      # 0xca4b
movb $0x0, %al
callq 0x5d40
testb $0x1, %al
jne 0x5315
jmp 0x5317
jmp 0x5336
leaq 0x772f(%rip), %rdi      # 0xca4d
leaq 0x6f50(%rip), %rsi      # 0xc275
movl $0x218, %edx            # imm = 0x218
leaq 0x773f(%rip), %rcx      # 0xca70
callq 0x20f0
jmp 0x5338
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x52eb
leaq -0x38(%rbp), %rdi
callq 0x5f80
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5ce0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/yangtau[P]hedgehog/src/ast.c
// Function: op_to_str
static const char* _op_to_str(enum hg_ast_node_op op) {
    assert(op < _HG_AST_NODE_OP_END && op > _HG_AST_NODE_OP_START);
    const char* const chars[] = {
        [HG_AST_NODE_OP_AND] = "and", // and
        [HG_AST_NODE_OP_OR]  = "or",  // or
        [HG_AST_NODE_OP_NOT] = "not", // not
        [HG_AST_NODE_OP_NEQ] = "!=",  // !=
        [HG_AST_NODE_OP_EQ]  = "==",  // ==
        [HG_AST_NODE_OP_GE]  = ">=",  // >=
        [HG_AST_NODE_OP_LE]  = "<=",  // <=
        [HG_AST_NODE_OP_GT]  = ">",   // >
        [HG_AST_NODE_OP_LS]  = "<",   // <
        [HG_AST_NODE_OP_ADD] = "+",   // +
        [HG_AST_NODE_OP_SUB] = "-",   // -
        [HG_AST_NODE_OP_MUL] = "*",   // *
        [HG_AST_NODE_OP_DIV] = "/",   // /
        [HG_AST_NODE_OP_MOD] = "%",   // %
    };

    return chars[op];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x4(%rbp)
cmpl $0xf, -0x4(%rbp)
jae 0x538c
cmpl $0x0, -0x4(%rbp)
jbe 0x538c
jmp 0x53ab
leaq 0x7708(%rip), %rdi      # 0xca9b
leaq 0x6edb(%rip), %rsi      # 0xc275
movl $0x21f, %edx            # imm = 0x21F
leaq 0x772c(%rip), %rcx      # 0xcad2
callq 0x20f0
leaq -0x80(%rbp), %rdi
leaq 0xc75a(%rip), %rsi      # 0x11b10
movl $0x78, %edx
callq 0x2140
movl -0x4(%rbp), %eax
movq -0x80(%rbp,%rax,8), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yangtau[P]hedgehog/src/lex.hedgehog.c
// Function: yy_try_NUL_trans
static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
{
	int yy_is_jam;
    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
	char *yy_cp = yyg->yy_c_buf_p;

	YY_CHAR yy_c = 1;
	if ( yy_accept[yy_current_state] )
		{
		yyg->yy_last_accepting_state = yy_current_state;
		yyg->yy_last_accepting_cpos = yy_cp;
		}
	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		{
		yy_current_state = (int) yy_def[yy_current_state];
		if ( yy_current_state >= 196 )
			yy_c = yy_meta[yy_c];
		}
	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	yy_is_jam = (yy_current_state == 195);

	(void)yyg;
	return yy_is_jam ? 0 : yy_current_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
movb $0x1, -0x29(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x4432(%rip), %rax      # 0xdae0
cmpw $0x0, (%rax,%rcx,2)
je 0x96cb
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x68(%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x70(%rax)
jmp 0x96cd
movslq -0x4(%rbp), %rcx
leaq 0x4968(%rip), %rax      # 0xe040
movswl (%rax,%rcx,2), %eax
movzbl -0x29(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x4584(%rip), %rax      # 0xdc70
movswl (%rax,%rcx,2), %eax
cmpl -0x4(%rbp), %eax
je 0x9725
movslq -0x4(%rbp), %rcx
leaq 0x4b10(%rip), %rax      # 0xe210
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0xc4, -0x4(%rbp)
jl 0x9723
movzbl -0x29(%rbp), %eax
movl %eax, %ecx
leaq 0x4cc3(%rip), %rax      # 0xe3e0
movb (%rax,%rcx), %al
movb %al, -0x29(%rbp)
jmp 0x96cd
movslq -0x4(%rbp), %rcx
leaq 0x4910(%rip), %rax      # 0xe040
movswl (%rax,%rcx,2), %eax
movzbl -0x29(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x4ccc(%rip), %rax      # 0xe410
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0xc3, -0x4(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x976a
xorl %eax, %eax
movl %eax, -0x30(%rbp)
jmp 0x9770
movl -0x4(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yangtau[P]hedgehog/src/yy.hedgehog.c
// Function: yy_syntax_error_arguments
static int
yy_syntax_error_arguments (const yypcontext_t *yyctx,
                           yysymbol_kind_t yyarg[], int yyargn)
{
  /* Actual size of YYARG. */
  int yycount = 0;
  /* There are many possibilities here to consider:
     - If this state is a consistent state with a default action, then
       the only way this function was invoked is if the default action
       is an error action.  In that case, don't check for expected
       tokens because there are none.
     - The only way there can be no lookahead present (in yychar) is if
       this state is a consistent state with a default action.  Thus,
       detecting the absence of a lookahead is sufficient to determine
       that there is no unexpected or expected token to report.  In that
       case, just report a simple "syntax error".
     - Don't assume there isn't a lookahead just because this state is a
       consistent state with a default action.  There might have been a
       previous inconsistent state, consistent state with a non-default
       action, or user semantic action that manipulated yychar.
       In the first two cases, it might appear that the current syntax
       error should have been detected in the previous state when yy_lac
       was invoked.  However, at that time, there might have been a
       different syntax error that discarded a different initial context
       during error recovery, leaving behind the current lookahead.
  */
  if (yyctx->yytoken != YYSYMBOL_YYEMPTY)
    {
      int yyn;
      YYDPRINTF ((stderr, "Constructing syntax error message\n"));
      if (yyarg)
        yyarg[yycount] = yyctx->yytoken;
      ++yycount;
      yyn = yypcontext_expected_tokens (yyctx,
                                        yyarg ? yyarg + 1 : yyarg, yyargn - 1);
      if (yyn == YYENOMEM)
        return YYENOMEM;
      else if (yyn == 0)
        YYDPRINTF ((stderr, "No expected tokens.\n"));
      else
        yycount += yyn;
    }
  return yycount;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x2, 0x20(%rax)
je 0xafa9
cmpq $0x0, -0x18(%rbp)
je 0xaf41
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edx
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xaf67
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x38(%rbp)
jmp 0xaf6f
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x1c(%rbp), %edx
subl $0x1, %edx
callq 0xb110
movl %eax, -0x24(%rbp)
cmpl $-0x2, -0x24(%rbp)
jne 0xaf94
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0xafaf
cmpl $0x0, -0x24(%rbp)
jne 0xaf9c
jmp 0xafa5
movl -0x24(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0xafa7
jmp 0xafa9
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yangtau[P]hedgehog/src/yy.hedgehog.c
// Function: yypcontext_expected_tokens
static int
yypcontext_expected_tokens (const yypcontext_t *yyctx,
                            yysymbol_kind_t yyarg[], int yyargn)
{
  /* Actual size of YYARG. */
  int yycount = 0;

  int yyx;
  for (yyx = 0; yyx < YYNTOKENS; ++yyx)
    {
      yysymbol_kind_t yysym = YY_CAST (yysymbol_kind_t, yyx);
      if (yysym != YYSYMBOL_YYerror && yysym != YYSYMBOL_YYUNDEF)
        switch (yy_lac (yyctx->yyesa, yyctx->yyes, yyctx->yyes_capacity, yyctx->yyssp, yysym))
          {
          case YYENOMEM:
            return YYENOMEM;
          case 1:
            continue;
          default:
            if (!yyarg)
              ++yycount;
            else if (yycount == yyargn)
              return 0;
            else
              yyarg[yycount++] = yysym;
          }
    }
  if (yyarg && yycount == 0 && 0 < yyargn)
    yyarg[0] = YYSYMBOL_YYEMPTY;
  return yycount;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x2b, -0x24(%rbp)
jge 0xb1df
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpl $0x1, -0x28(%rbp)
je 0xb1cf
cmpl $0x2, -0x28(%rbp)
je 0xb1cf
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
movl -0x28(%rbp), %r8d
callq 0x8cb0
movl %eax, %ecx
movl %ecx, -0x2c(%rbp)
subl $-0x2, %eax
je 0xb183
jmp 0xb179
movl -0x2c(%rbp), %eax
subl $0x1, %eax
je 0xb18c
jmp 0xb18e
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0xb203
jmp 0xb1d1
cmpq $0x0, -0x18(%rbp)
jne 0xb1a0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xb1cb
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0xb1b1
movl $0x0, -0x4(%rbp)
jmp 0xb203
movl -0x28(%rbp), %edx
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x20(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xb1cb
jmp 0xb1cd
jmp 0xb1cf
jmp 0xb1d1
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xb131
cmpq $0x0, -0x18(%rbp)
je 0xb1fd
cmpl $0x0, -0x20(%rbp)
jne 0xb1fd
xorl %eax, %eax
cmpl -0x1c(%rbp), %eax
jge 0xb1fd
movq -0x18(%rbp), %rax
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x18, %rdi
callq 0x5600
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jle 0x4d4e
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
addq $0x18, %rdi
movl -0x10(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x5620
movq %rax, %rcx
movl -0x1c(%rbp), %eax
cmpl (%rcx), %eax
jg 0x4d05
movl -0xc(%rbp), %esi
movq 0x4830b(%rip), %rdi     # 0x4cfc8
callq 0x46c0
movq %rax, %rdi
leaq 0x2f35c(%rip), %rsi     # 0x34028
callq 0x4360
movq -0x18(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x18, %rdi
movl -0x10(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x5620
movq -0x28(%rbp), %rdi
movl (%rax), %esi
callq 0x46c0
movq %rax, %rdi
movq 0x482b8(%rip), %rsi     # 0x4cfb8
callq 0x43b0
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
addq $0x18, %rdi
movl -0x10(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x5620
movq %rax, %rcx
movl -0x2c(%rbp), %eax
cmpl (%rcx), %eax
jle 0x4d2d
jmp 0x4d4c
leaq 0x2f2f6(%rip), %rdi     # 0x3402a
leaq 0x2f308(%rip), %rsi     # 0x34043
movl $0x25, %edx
leaq 0x2f306(%rip), %rcx     # 0x3404d
callq 0x4210
jmp 0x4d77
cmpl $0x0, -0xc(%rbp)
jle 0x4d56
jmp 0x4d75
leaq 0x2f30c(%rip), %rdi     # 0x34069
leaq 0x2f2df(%rip), %rsi     # 0x34043
movl $0x27, %edx
leaq 0x2f2dd(%rip), %rcx     # 0x3404d
callq 0x4210
jmp 0x4d77
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
leaq -0xc(%rbp), %rsi
callq 0x5640
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4270
testb $0x1, %al
jne 0x52f7
jmp 0x52f9
jmp 0x5318
leaq 0x2ed74(%rip), %rdi     # 0x34074
leaq 0x2ed3c(%rip), %rsi     # 0x34043
movl $0x69, %edx
leaq 0x2ed71(%rip), %rcx     # 0x34084
callq 0x4210
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x56b0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x5334
jmp 0x53e5
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x56f0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x30(%rbp), %rdi
movq %rdi, %rax
addq $0x30, %rax
movq %rax, -0x38(%rbp)
addq $0x18, %rdi
callq 0x57c0
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x5880
testb $0x1, %al
jne 0x5383
jmp 0x53e5
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x40(%rax), %esi
callq 0x46c0
movq %rax, %rdi
leaq 0x2ec8b(%rip), %rsi     # 0x34028
callq 0x4360
movq -0x30(%rbp), %rdi
movq %rax, -0x40(%rbp)
addq $0x30, %rdi
callq 0x5720
movq -0x40(%rbp), %rdi
movl (%rax), %esi
callq 0x46c0
movq %rax, %rdi
movq 0x47bf0(%rip), %rsi     # 0x4cfb8
callq 0x43b0
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
xorl %esi, %esi
callq 0x5740
movq %rax, -0x28(%rbp)
jmp 0x5354
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)