LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/semantics.c
// Function: paramsRedefinitionCheck
void paramsRedefinitionCheck(functionData data, TDLList *L) {
    if (data.numOfParams == 0) {
        return;
    }
    for (int i = 0; i < data.numOfParams; i++) {
        for (int j = 0; j < data.numOfParams; j++) {
            //porovname parameter sameho so sebou, tento krok treba preskocit
            if (i == j) {
                continue;
            }
            //id parametrov sa rovnaju, volaj error
            if (!strcmp(data.params[i], data.params[j])) {
                BSTDisposeGlobal(&functions);
                error_call(ERR_SEM_UNDEF, L);
                return;
            }
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq 0x30(%rsp), %r14
testq %r14, %r14
jle 0x7693
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x7683
movq 0x8(%r15,%r12,8), %rdi
movq 0x8(%r15,%r13,8), %rsi
callq 0x1080
testl %eax, %eax
je 0x769d
incq %r13
cmpq %r13, %r14
jne 0x766b
incq %r12
cmpq %r14, %r12
jne 0x7668
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x6d2c(%rip), %rdi      # 0xe3d0
callq 0x44a6
movl $0x3, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x42d0
// File: /workspace/github_c_makefile_star2_O3/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 0xd19(%rip), %rsi       # 0x851a
movq %r14, %rdi
callq 0x1080
testl %eax, %eax
je 0x784a
movq 0x6bbc(%rip), %rdi      # 0xe3d0
leaq 0x8(%rsp), %rdx
movq %r14, %rsi
callq 0x43b0
testb %al, %al
je 0x7832
movl $0x3, %edi
movq %rbx, %rsi
callq 0x42d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x76bf
addq $0x1010, %rsp           # imm = 0x1010
popq %rbx
popq %r14
popq %r15
retq
cmpb $0x1, 0x4c2f(%rip)      # 0xc480
jne 0x785a
movl $0x3, %edi
jmp 0x78d1
movq 0x18(%r15), %rax
movq (%rax), %rcx
cmpb $0x28, (%rcx)
jne 0x78cc
cmpb $0x0, 0x1(%rcx)
jne 0x78cc
movq 0x18(%rax), %rax
movq (%rax), %rcx
cmpb $0x29, (%rcx)
jne 0x78cc
cmpb $0x0, 0x1(%rcx)
jne 0x7890
movq 0x18(%rax), %rdx
movq (%rdx), %rdx
cmpb $0x7b, (%rdx)
jne 0x7890
cmpb $0x0, 0x1(%rdx)
je 0x78e5
cmpb $0x0, 0x1(%rcx)
jne 0x78cc
movq 0x18(%rax), %rax
movq (%rax), %rcx
cmpb $0x28, (%rcx)
jne 0x78cc
cmpb $0x0, 0x1(%rcx)
jne 0x78cc
movq 0x18(%rax), %rax
movq (%rax), %rcx
cmpb $0x29, (%rcx)
jne 0x78cc
cmpb $0x0, 0x1(%rcx)
jne 0x78cc
movq 0x18(%rax), %rax
movq (%rax), %rax
cmpb $0x7b, (%rax)
jne 0x78cc
cmpb $0x0, 0x1(%rax)
je 0x78e5
movl $0x6, %edi
movq %rbx, %rsi
addq $0x1010, %rsp           # imm = 0x1010
popq %rbx
popq %r14
popq %r15
jmp 0x42d0
movb $0x1, 0x4b94(%rip)      # 0xc480
jmp 0x783d
// File: /workspace/github_c_makefile_star2_O3/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 0x6ad0(%rip), %rdi      # 0xe3d0
callq 0x43a8
callq 0x736d
movq %rbx, %rdi
callq 0x1689
movq 0x8(%rbx), %r15
cmpl $0x1d, 0x8(%r15)
je 0x7959
leaq 0x973(%rip), %r14       # 0x8297
movq (%r15), %rdi
movq %r14, %rsi
callq 0x1080
testl %eax, %eax
jne 0x793f
movq %rbx, %rdi
callq 0x77e0
movq 0x8(%rbx), %r15
cmpq $0x0, 0x18(%r15)
je 0x7992
movq %rbx, %rdi
callq 0x1691
movq 0x8(%rbx), %r15
cmpl $0x1d, 0x8(%r15)
jne 0x7924
cmpb $0x0, 0x4b20(%rip)      # 0xc480
je 0x798b
movq %rbx, %rdi
callq 0x1689
movq %rbx, %rdi
callq 0x7306
movq %rbx, %rdi
callq 0x16b2
leaq 0x6a4f(%rip), %rdi      # 0xe3d0
popq %rbx
popq %r14
popq %r15
jmp 0x44a6
movl $0x3, %edi
jmp 0x7997
movl $0x63, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x42d0
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/precanalysis_stack.c
// Function: symstack_push
void symstack_push(tsym_stack* sym_stack, psa_symbols symbol){
    tsym_stack_symbol* pushed_sym = (tsym_stack_symbol*)malloc(sizeof(tsym_stack_symbol));

    if (pushed_sym == NULL) {
        return;
    }
    pushed_sym->next = sym_stack->top;
    pushed_sym->symbol = symbol;

    sym_stack->top = pushed_sym;

    return;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl $0x10, %edi
callq 0x10a0
testq %rax, %rax
je 0x79cf
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_O3/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 0x79ee
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_O3/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x7a71
movl %esi, %ebp
movq %rdi, %rbx
movl (%r14), %eax
andl $-0x2, %eax
cmpl $0xe, %eax
jne 0x7a4b
movq %r14, %rax
movq %rax, %r15
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x7a71
movl (%rax), %ecx
andl $-0x2, %ecx
cmpl $0xe, %ecx
je 0x7a33
jmp 0x7a4e
xorl %r15d, %r15d
movl $0x10, %edi
callq 0x10a0
movl %ebp, (%rax)
testq %r15, %r15
je 0x7a6a
movq 0x8(%r15), %r14
addq $0x8, %r15
movq %r15, %rbx
movq %r14, 0x8(%rax)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6898(%rip), %rbx      # 0xe3d8
movq 0x6891(%rip), %rsi      # 0xe3d8
movl 0x6893(%rip), %edi      # 0xe3e0
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x7af2
movb %al, 0x6888(%rip)       # 0xe3e4
movq %rbx, %rdi
callq 0x79d6
movq %rbx, %rdi
callq 0x79d6
movq %rbx, %rdi
movl $0xf, %esi
popq %rbx
jmp 0x79ac
// File: /workspace/github_c_makefile_star2_O3/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 0x2636
movq %rdi, %rbx
movl $0x38, %edi
callq 0x2150
movl %r14d, (%rax)
movl 0xc(%rbx), %ecx
movl %ecx, 0x4(%rax)
movq $0x4, 0x10(%rax)
movq $0x0, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4bf7(%rip), %rdi      # 0x7234
leaq 0x4c31(%rip), %rsi      # 0x7275
leaq 0x4c30(%rip), %rcx      # 0x727b
movl $0x18, %edx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O3/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 0x269d
movq %rdx, %rbx
movq %rsi, %rax
movq 0x8(%rsi), %rcx
movq 0x10(%rsi), %rsi
cmpq %rsi, %rcx
jb 0x268e
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 0x4c2c(%rip), %rdi      # 0x72d0
leaq 0x4bca(%rip), %rsi      # 0x7275
leaq 0x4c6b(%rip), %rcx      # 0x731d
movl $0x26, %edx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O3/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 0x26fd
movq %rsi, %r15
cmpl $0x4, (%rsi)
jne 0x271c
movq %rcx, %r14
movq %rdx, %rbx
movl $0x20, %edi
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 0x4e29(%rip), %rdi      # 0x752d
leaq 0x4b6a(%rip), %rsi      # 0x7275
leaq 0x4c78(%rip), %rcx      # 0x738a
movl $0x37, %edx
callq 0x20f0
leaq 0x4ed7(%rip), %rdi      # 0x75fa
leaq 0x4b4b(%rip), %rsi      # 0x7275
leaq 0x4c59(%rip), %rcx      # 0x738a
movl $0x38, %edx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O3/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_break_stat_new
struct hg_ast_node* hg_ast_break_stat_new(struct hg_parser* p) {
    __hg_new_ast(stat, struct hg_ast_break_stat);

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

    return &stat->node;
}

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

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

    return &stat->node;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x8, %edi
callq 0x2150
movl $0xd, (%rax)
movl 0xc(%rbx), %ecx
movl %ecx, 0x4(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2787
cmpl $0x2, (%rbx)
jne 0x27b8
movl $0x10, %edi
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 0x4c49(%rip), %rdi      # 0x7408
leaq 0x4aaf(%rip), %rsi      # 0x7275
leaq 0x4c73(%rip), %rcx      # 0x7440
movl $0x59, %edx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O3/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 0x281d
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
testq %rcx, %rcx
je 0x27f4
cmpl $0x1, (%rbx)
jne 0x283c
movl $0x20, %edi
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 0x4d09(%rip), %rdi      # 0x752d
leaq 0x4a4a(%rip), %rsi      # 0x7275
leaq 0x4c63(%rip), %rcx      # 0x7495
movl $0x67, %edx
callq 0x20f0
leaq 0x4ccf(%rip), %rdi      # 0x7512
leaq 0x4a2b(%rip), %rsi      # 0x7275
leaq 0x4c44(%rip), %rcx      # 0x7495
movl $0x68, %edx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O3/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 0x2896
movq %rdx, %rbx
cmpl $0x2, (%rdx)
jne 0x28b5
movq %rsi, %r14
movl $0x18, %edi
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 0x4cb7(%rip), %rdi      # 0x7554
leaq 0x49d1(%rip), %rsi      # 0x7275
leaq 0x4cce(%rip), %rcx      # 0x7579
movl $0x78, %edx
callq 0x20f0
leaq 0x4b5d(%rip), %rdi      # 0x7419
leaq 0x49b2(%rip), %rsi      # 0x7275
leaq 0x4caf(%rip), %rcx      # 0x7579
movl $0x79, %edx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O3/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 0x28ed
cmpl $0x4, (%r14)
jne 0x295f
cmpl $0x1, (%rbx)
jne 0x2921
cmpl $0x1e, (%r15)
jne 0x2940
movl $0x20, %edi
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 0x4c05(%rip), %rdi      # 0x752d
leaq 0x4946(%rip), %rsi      # 0x7275
leaq 0x4ced(%rip), %rcx      # 0x7623
movl $0x89, %edx
callq 0x20f0
leaq 0x4d5b(%rip), %rdi      # 0x76a2
leaq 0x4927(%rip), %rsi      # 0x7275
leaq 0x4cce(%rip), %rcx      # 0x7623
movl $0x8a, %edx
callq 0x20f0
leaq 0x4c82(%rip), %rdi      # 0x75e8
leaq 0x4908(%rip), %rsi      # 0x7275
leaq 0x4caf(%rip), %rcx      # 0x7623
movl $0x88, %edx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O3/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 0x29b3
cmpl $0x4, (%r14)
jne 0x2a07
cmpl $0x1, (%rbx)
jne 0x29e8
movl $0x18, %edi
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 0x4b3e(%rip), %rdi      # 0x752d
leaq 0x487f(%rip), %rsi      # 0x7275
leaq 0x4cc8(%rip), %rcx      # 0x76c5
movl $0xa5, %edx
callq 0x20f0
leaq 0x4bda(%rip), %rdi      # 0x75e8
leaq 0x4860(%rip), %rsi      # 0x7275
leaq 0x4ca9(%rip), %rcx      # 0x76c5
movl $0xa4, %edx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O3/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_binary_expr_new
struct hg_ast_node* hg_ast_binary_expr_new(struct hg_parser* p, enum hg_ast_node_op op, struct hg_ast_node* left,
                                           struct hg_ast_node* right) {
    __hg_new_ast(expr, struct hg_ast_binary_expr);

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

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movl $0x20, %edi
callq 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_O3/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 0x2a99
cmpl $0x2, (%rbx)
jne 0x2ac0
movl $0x18, %edi
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 0x4941(%rip), %rdi      # 0x7408
leaq 0x47a7(%rip), %rsi      # 0x7275
leaq 0x4c58(%rip), %rcx      # 0x772d
movl $0xcd, %edx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O3/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 0x2b15
movq %rdx, %rbx
movq %rsi, %r14
movl $0x18, %edi
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 0x4c7a(%rip), %rdi      # 0x7796
leaq 0x4752(%rip), %rsi      # 0x7275
leaq 0x4c92(%rip), %rcx      # 0x77bc
movl $0xdb, %edx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O3/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_index_expr_new
struct hg_ast_node* hg_ast_index_expr_new(struct hg_parser* p, struct hg_ast_node* prefix, struct hg_ast_node* index) {
    __hg_new_ast(expr, struct hg_ast_index_expr);

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl $0x18, %edi
callq 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_O3/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 0x2b80
movl (%rbx), %eax
cmpl $0x2, %eax
je 0x2b80
cmpl $0x5, %eax
jne 0x2bb1
movl $0x10, %edi
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 0x4c6e(%rip), %rdi      # 0x7826
leaq 0x46b6(%rip), %rsi      # 0x7275
leaq 0x4cc4(%rip), %rcx      # 0x788a
movl $0xf6, %edx
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O3/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_table_entry_new
struct hg_ast_node* hg_ast_table_entry_new(struct hg_parser* p, struct hg_ast_node* key, struct hg_ast_node* value) {
    __hg_new_ast(entry, struct hg_ast_table_entry);

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl $0x18, %edi
callq 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_O3/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 0x2c34
movq %rsi, %rbx
movl $0x10, %edi
callq 0x2150
movl $0x1a, (%rax)
movl 0x4(%rbx), %ecx
movl %ecx, 0x4(%rax)
movq %rbx, 0x8(%rax)
popq %rbx
retq
leaq 0x4ca3(%rip), %rdi      # 0x78de
leaq 0x4633(%rip), %rsi      # 0x7275
leaq 0x4ce0(%rip), %rcx      # 0x7929
movl $0x10f, %edx            # imm = 0x10F
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O3/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_literal_id_new
struct hg_ast_node* hg_ast_literal_id_new(struct hg_parser* p, hg_str str) {
    __hg_new_ast(lit, struct hg_ast_literal);

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

    return &lit->node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x10, %edi
callq 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_O3/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_literal_str_new
struct hg_ast_node* hg_ast_literal_str_new(struct hg_parser* p, hg_str str) {
    __hg_new_ast(lit, struct hg_ast_literal);

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

    return &lit->node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x10, %edi
callq 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_O3/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_literal_float_new
struct hg_ast_node* hg_ast_literal_float_new(struct hg_parser* p, hg_float d) {
    __hg_new_ast(lit, struct hg_ast_literal);

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

    return &lit->node;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
movl $0x10, %edi
callq 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_O3/yangtau[P]hedgehog/src/ast.c
// Function: hg_ast_literal_int_new
struct hg_ast_node* hg_ast_literal_int_new(struct hg_parser* p, hg_int i) {
    __hg_new_ast(lit, struct hg_ast_literal);

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

    return &lit->node;
}

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

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

    return &lit->node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl $0x10, %edi
callq 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_O3/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 0x3b32
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x2e9b
movq %r15, %rdi
callq 0x3d16
movq %rax, %rbx
movq %r15, %rdi
callq 0x3b59
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x35b4
movl $0x11555, %eax          # imm = 0x11555
btl %ebp, %eax
jae 0x35b4
movl %ebp, %eax
leaq 0x3c45(%rip), %rcx      # 0x71f0
movslq (%rcx,%rax,4), %rbx
addq %rcx, %rbx
jmp 0x35f9
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x3b32
movl %ebp, %r15d
leaq 0x4460(%rip), %r14      # 0x7a2b
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3b8e
testb %al, %al
je 0x3607
decq %r15
jne 0x35cb
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3d16
movq %rax, %rbx
movq %r14, %rdi
callq 0x3b59
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x441f(%rip), %rdi      # 0x7a2d
leaq 0x3c60(%rip), %rsi      # 0x7275
leaq 0x4434(%rip), %rcx      # 0x7a50
movl $0x218, %edx            # imm = 0x218
callq 0x20f0
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x640d
movq %r15, (%rbx)
movl $0x1, 0x34(%rbx)
movq 0x28(%r12), %rax
testq %rax, %rax
je 0x62ea
movq 0x18(%r12), %rcx
movq (%rax,%rcx,8), %rax
jmp 0x62ec
xorl %eax, %eax
cmpq %rbx, %rax
je 0x62f9
movq $0x1, 0x2c(%rbx)
testq %r15, %r15
je 0x6316
movq %r15, %rdi
callq 0x2140
movl %eax, %edi
callq 0x2080
xorl %ecx, %ecx
testl %eax, %eax
setg %cl
jmp 0x6318
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_O3/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 0x67c0
movq %rdi, %rbx
movl $0x1, %edi
movl $0x98, %esi
callq 0x2100
movq %rax, %rcx
movq %rax, (%rbx)
xorl %eax, %eax
testq %rcx, %rcx
jne 0x67d1
movl $0xc, %ebx
jmp 0x67c5
movl $0x16, %ebx
callq 0x2050
movl %ebx, (%rax)
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
leaq 0x18(%rdi), %r14
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rsi
movq %rsi, %r12
subq %rax, %r12
sarq $0x2, %r12
testl %r12d, %r12d
jle 0x3de6
decl %r12d
movl (%rax,%r12,4), %eax
cmpl %ebp, %eax
jl 0x3ddc
movq 0x1d252(%rip), %rdi     # 0x20fd0
movl %ebp, %esi
callq 0x3560
movq %rax, %r15
leaq 0x132c1(%rip), %rsi     # 0x17050
movl $0x1, %edx
movq %rax, %rdi
callq 0x3340
movq (%r14), %rax
movl (%rax,%r12,4), %esi
movq %r15, %rdi
callq 0x3560
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
movq (%r14), %rax
movl (%rax,%r12,4), %eax
cmpl %ebp, %eax
jge 0x3e16
movq 0x20(%rbx), %rsi
jmp 0x3dea
testl %ebp, %ebp
jle 0x3e35
cmpq 0x28(%rbx), %rsi
je 0x3dfc
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x20(%rbx)
jmp 0x3e09
leaq 0xc(%rsp), %rdx
movq %r14, %rdi
callq 0x4500
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13235(%rip), %rdi     # 0x17052
leaq 0x13247(%rip), %rsi     # 0x1706b
leaq 0x1324a(%rip), %rcx     # 0x17075
movl $0x25, %edx
callq 0x31b0
leaq 0x13255(%rip), %rdi     # 0x17091
leaq 0x13228(%rip), %rsi     # 0x1706b
leaq 0x1322b(%rip), %rcx     # 0x17075
movl $0x27, %edx
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O3/stonezwr[P]SpiKL-IP/channel.C
// Function: Channel::Print(std::basic_ofstream<char, std::char_traits<char>>&)
void Channel::Print(ofstream& f_out){
    assert(f_out.is_open());
    if(_spikeT.empty() == true) return;
    for(_iter_spikeT = _spikeT.begin(); _iter_spikeT != _spikeT.end(); _iter_spikeT++) 
        f_out<<_index<<"\t"<<*_iter_spikeT<<endl;
}

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2008, %rsp           # imm = 0x2008
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %rdi
movl $0x1fff, %esi           # imm = 0x1FFF
movq %rbx, %rdx
callq 0x34c0
testq %rax, %rax
je 0x4372
cmpb $0xa, (%rsp)
je 0x4372
leaq 0x12dcd(%rip), %r15     # 0x170e7
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x34a0
movq %rax, %rdi
callq 0x3490
cmpl $-0x1, %eax
je 0x4391
cmpl 0x40(%r14), %eax
jne 0x43a0
xorl %edi, %edi
movq %r15, %rsi
callq 0x34a0
movq %rax, %rdi
callq 0x3490
movq %r14, %rdi
movl %eax, %esi
callq 0x3d3c
movq %r12, %rdi
movl $0x1fff, %esi           # imm = 0x1FFF
movq %rbx, %rdx
callq 0x34c0
testq %rax, %rax
je 0x4372
cmpb $0xa, (%rsp)
jne 0x431d
leaq 0x14057(%rip), %rdi     # 0x183d0
leaq 0x12ceb(%rip), %rsi     # 0x1706b
leaq 0x12d45(%rip), %rcx     # 0x170cc
movl $0x76, %edx
callq 0x31b0
addq $0x2008, %rsp           # imm = 0x2008
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x14029(%rip), %rdi     # 0x183d0
leaq 0x12cbd(%rip), %rsi     # 0x1706b
leaq 0x12d17(%rip), %rcx     # 0x170cc
movl $0x7e, %edx
callq 0x31b0
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x4afa
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
addq $0x48, %r14
leaq 0x10(%rsp), %rsi
movl %edx, (%rsi)
movq %r14, %rdi
callq 0x6530
movq (%rax), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x3, %rcx
movl %ebp, %ebp
cmpq %rbp, %rcx
jae 0x4aeb
leaq 0xc(%rsp), %r15
leaq 0x10(%rsp), %r12
movl $0x48, %edi
callq 0x32e0
movq %rax, %r13
movl %ebx, 0xc(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x6530
movq (%rax), %rax
movq 0x8(%rax), %rsi
subq (%rax), %rsi
shrq $0x3, %rsi
movq %r13, %rdi
callq 0x3ce4
movq %r13, 0x10(%rsp)
movl %ebx, 0x44(%r13)
movl %ebx, 0xc(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x6530
movq (%rax), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x4abd
movq 0x10(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x4ac5
movq %r12, %rdx
callq 0x67dc
movl %ebx, 0x10(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x6530
movq (%rax), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x3, %rcx
cmpq %rbp, %rcx
jb 0x4a57
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x12605(%rip), %rdi     # 0x17106
leaq 0x12608(%rip), %rsi     # 0x17110
leaq 0x1260a(%rip), %rcx     # 0x17119
movl $0x25, %edx
callq 0x31b0
movq %rax, %rbx
movl $0x48, %esi
movq %r13, %rdi
callq 0x32f0
movq %rbx, %rdi
callq 0x3570
nop
// File: /workspace/github_c_makefile_star2_O3/stonezwr[P]SpiKL-IP/speech.C
// Function: Speech::ClearChannel(channelmode_t)
void Speech::ClearChannel(channelmode_t channelmode){
    if(_channel_map.find(channelmode) == _channel_map.end()){
        cout<<"Invalid channel type: "<<channelmode<<endl;
        exit(EXIT_FAILURE);
    }

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

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
addq $0x48, %r14
leaq 0xc(%rsp), %rsi
movl %ebx, (%rsi)
movq %r14, %rdi
callq 0x6918
testq %rax, %rax
je 0x4cfb
leaq 0x4(%rsp), %rsi
movl %ebx, (%rsi)
movq %r14, %rdi
callq 0x6530
movq (%rax), %rax
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0x4cce
xorl %r13d, %r13d
leaq 0x8(%rsp), %r15
leaq 0x4(%rsp), %r12
movl %ebx, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x6530
movq (%rax), %rax
movq (%rax), %rax
movq (%rax,%r13,8), %rdi
testq %rdi, %rdi
je 0x4cdc
callq 0x420c
incq %r13
movl %ebx, 0x4(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x6530
movq (%rax), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jb 0x4c86
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x12b21(%rip), %rdi     # 0x17804
leaq 0x12426(%rip), %rsi     # 0x17110
leaq 0x124c0(%rip), %rcx     # 0x171b1
movl $0x42, %edx
callq 0x31b0
movq 0x1c2ce(%rip), %rdi     # 0x20fd0
leaq 0x12491(%rip), %rsi     # 0x1719a
callq 0x32c0
movq %rax, %rdi
movl %ebx, %esi
callq 0x3560
movq %rax, %rdi
callq 0x3160
movl $0x1, %edi
callq 0x3370
// File: /workspace/github_c_makefile_star2_O3/stonezwr[P]SpiKL-IP/speech.C
// Function: Speech::Info()
void Speech::Info(){
    cout<<"# of input channels = "<<_channels.size()<<endl;
    for(int i = 0; i < _channels.size(); i++) cout<<_channels[i]->SizeSpikeT()<<"\t";
    cout<<endl;
    cout<<"# of reservoir channels = "<<_rChannels.size()<<endl;
    for(int i = 0; i < _rChannels.size(); i++) cout<<_rChannels[i]->SizeSpikeT()<<"\t";
    cout<<endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0x1c1e9(%rip), %rbx     # 0x20fd0
leaq 0x12442(%rip), %rsi     # 0x17230
movl $0x16, %edx
movq %rbx, %rdi
callq 0x3340
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x3, %rsi
movq %rbx, %rdi
callq 0x31d0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x4e90
xorl %r13d, %r13d
movq 0x1c185(%rip), %r15     # 0x20fd0
leaq 0x121fe(%rip), %r12     # 0x17050
movq (%rax,%r13,8), %rax
movq 0x20(%rax), %rsi
subq 0x18(%rax), %rsi
shrq $0x2, %rsi
movq %r15, %rdi
callq 0x3560
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x3340
incq %r13
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
ja 0x4e52
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
leaq 0x12389(%rip), %rsi     # 0x17247
movl $0x1a, %edx
movq %rbx, %rdi
callq 0x3340
movq 0x20(%r14), %rsi
subq 0x18(%r14), %rsi
sarq $0x3, %rsi
movq %rbx, %rdi
callq 0x31d0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
movq 0x18(%r14), %rax
cmpq %rax, 0x20(%r14)
je 0x4f63
xorl %r13d, %r13d
movq 0x1c0b3(%rip), %r15     # 0x20fd0
leaq 0x1212c(%rip), %r12     # 0x17050
movq (%rax,%r13,8), %rax
movq 0x20(%rax), %rsi
subq 0x18(%rax), %rsi
shrq $0x2, %rsi
movq %r15, %rdi
callq 0x3560
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x3340
incq %r13
movq 0x18(%r14), %rax
movq 0x20(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
ja 0x4f24
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x31e0
nop
// File: /workspace/github_c_makefile_star2_O3/stonezwr[P]SpiKL-IP/speech.C
// Function: Speech::PrintSpikesPerChannels(std::vector<Channel*, std::allocator<Channel*>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Speech::PrintSpikesPerChannels(const vector<Channel*>& channels, const string & filename){
    ofstream f_out(filename.c_str());
    if(!f_out.is_open()){
        cout<<"Cannot open file : "<<filename<<" for dumping the spikes!"<<endl;
        assert(f_out.is_open());
    }
    f_out<<"-1\t-1"<<endl;
    for(int i = 0; i < channels.size(); i++){ 
        channels[i]->Print(f_out);
    }
    f_out<<"-1\t-1"<<endl;
    f_out.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdx, %r15
movq %rsi, %rbx
movq (%rdx), %rsi
movq %rsp, %rdi
movl $0x10, %edx
callq 0x3320
leaq 0x70(%rsp), %r14
movq %r14, %rdi
callq 0x30b0
testb %al, %al
jne 0x5040
movq 0x1c002(%rip), %rdi     # 0x20fd0
leaq 0x1228d(%rip), %rsi     # 0x17262
movl $0x13, %edx
callq 0x3340
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x1bfe3(%rip), %rdi     # 0x20fd0
callq 0x3340
movq %rax, %r15
leaq 0x1227a(%rip), %rsi     # 0x17276
movl $0x18, %edx
movq %rax, %rdi
callq 0x3340
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
movq %r14, %rdi
callq 0x30b0
testb %al, %al
je 0x5135
leaq 0x12297(%rip), %rsi     # 0x172de
movq %rsp, %r14
movl $0x5, %edx
movq %r14, %rdi
callq 0x3340
movq (%rsp), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %rsp, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x50b0
xorl %r15d, %r15d
movq %rsp, %r14
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
callq 0x421c
incq %r15
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
ja 0x508e
leaq 0x12227(%rip), %rsi     # 0x172de
movq %rsp, %rbx
movl $0x5, %edx
movq %rbx, %rdi
callq 0x3340
movq (%rsp), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %rsp, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
movq %rsp, %rdi
callq 0x3410
movq 0x1beca(%rip), %rax     # 0x20fc8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x8(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, (%rsp,%rcx)
callq 0x3240
leaq 0xf8(%rsp), %rdi
callq 0x3120
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
leaq 0x11f60(%rip), %rdi     # 0x1709c
leaq 0x11fcd(%rip), %rsi     # 0x17110
leaq 0x12145(%rip), %rcx     # 0x1728f
movl $0x63, %edx
callq 0x31b0
jmp 0x5156
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3450
movq %rbx, %rdi
callq 0x3570
nop