LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/tokenList.c
// Function: TDLLPreDelete
void TDLLPreDelete (TDLList *L) {

    if (L->Act && L->Act != L->First) {             //zoznam musi byt aktivny inde ako na prvom prvku
        TDLLElemPtr tmp = L->Act->lptr;              //tmp bude ukazovat na odstranovany prvok
        if (tmp == L->First) {                      //odstranovan prvok je prvy
            L->Act->lptr = NULL;                    //lavy ukazatel aktivneho prvku bude NULL
            L->First = L->Act;                      //aktivny prvok sa stava prvym
        }
        else {                                      //odstranovany prvok nie je prvy
            L->Act->lptr = tmp->lptr;               //lavy ukazatel aktivneho musi ukazovat vlavo od mazaneho
            tmp->lptr->rptr = L->Act;               //pravy ukazatel vpravo od mazaneho musi ukazovat na aktivny
        }
        free(tmp);                                  //uvolnenie pamati mazaneho prvku
    }
}

// Assembly:
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x187d
movq (%rdi), %rdx
cmpq %rdx, %rcx
je 0x187d
movq 0x10(%rcx), %rax
cmpq %rdx, %rax
je 0x187e
movq 0x10(%rax), %rdi
movq %rdi, 0x10(%rcx)
addq $0x18, %rdi
jmp 0x1886
retq
movq $0x0, 0x10(%rcx)
movq %rcx, (%rdi)
movq %rax, %rdi
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/tokenList.c
// Function: TDLLPostInsert
void TDLLPostInsert (TDLList *L, TOKEN token) {

    if (L->Act) {                                   //zoznam je aktivny
        TDLLElemPtr tmp = (TDLLElemPtr) malloc(sizeof(struct TDLLElem));   //alokacia pamati
        tmp->tdata = token;                            //kopirovanie dat
        if (L->Act == L->Last) {                    //aktivny prvok je posledny
            L->Act->rptr = tmp;
            tmp->lptr = L->Act;
            tmp->rptr = NULL;
            L->Last = tmp;
        }
        else {                                      //aktivny prvok nie je posledny
            tmp->rptr = L->Act->rptr;               //pravy ukazatel tmp ukazuje vpravo od Act
            tmp->rptr->lptr = tmp;                  //lavy ukazatel prvku vpravo od tmp ukazuje na tmp
            tmp->lptr = L->Act;                     //lavy ukazatel tmp ukazuje na Act
            L->Act->rptr = tmp;                     //pravy ukazatel act ukazuje na tmp
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0x18f7
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x20, %edi
callq 0x10a0
movq %r14, (%rax)
movl %ebp, 0x8(%rax)
leaq 0x18(%r15), %rcx
cmpq 0x10(%rbx), %r15
je 0x18d4
movq (%rcx), %rsi
movq %rsi, 0x18(%rax)
movl $0x10, %edx
movq %rax, %rdi
jmp 0x18ec
addq $0x10, %rbx
movq %rax, (%rcx)
movl $0x18, %edx
movq %rax, %rsi
movq %r15, %rdi
xorl %r15d, %r15d
movq %rbx, %rcx
movq %rdi, 0x10(%rsi)
movq %r15, (%rax,%rdx)
movq %rax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/tokenList.c
// Function: TDLLPreInsert
void TDLLPreInsert (TDLList *L, TOKEN token) {

    if (L->Act) {                                   //zoznam je aktivny
        TDLLElemPtr tmp = (TDLLElemPtr) malloc(sizeof(struct TDLLElem));   //alokacia pamati
        tmp->tdata = token;                            //kopirovanie dat
        if (L->Act == L->First) {                    //aktivny prvok je prvy
            tmp->rptr = L->Act;                      //pravy ukazatel tmp ukazuje na act
            tmp->lptr = NULL;                        //lavy ukazatel tmp je NULL
            L->Act->lptr = tmp;                      //lavy ukazatel act ukazuje na tmp
            L->First = tmp;                          //tmp je prvy prvok v zozname
        }
        else {                                      //aktivny prvok nie je prvy
            tmp->rptr = L->Act;                      //pravy ukazatel tmp ukazuje na act
            tmp->lptr = L->Act->lptr;                //lavy ukazatel tmp ukazuje na prvok pred act
            tmp->lptr->rptr = tmp;                   //pravy ukazatel prvku pred act ukazuje na tmp
            L->Act->lptr = tmp;                      //lavy ukazatel act ukazuje na tmp
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0x195a
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x20, %edi
callq 0x10a0
movq %r14, (%rax)
movl %ebp, 0x8(%rax)
cmpq (%rbx), %r15
movq %r15, 0x18(%rax)
je 0x1948
movq %r15, %rbx
movq 0x10(%r15), %r15
addq $0x10, %rbx
movq %r15, 0x10(%rax)
addq $0x18, %r15
jmp 0x1954
movq $0x0, 0x10(%rax)
addq $0x10, %r15
movq %rax, (%r15)
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/parser.c
// Function: main
int main() {

    //inicilizacia zoznamu tokenov
    TDLLInitList(&tokens);

    //načitanie prvého tokenu
    token = get_next_token(stdin);
    //nacitanie tokenu do zoznamu tokenov, bude sa volast s kazdym get_next_token
    TDLLInsertLast(&tokens, token);
    // eol(y) na zaciatku -- nepovinne
    if (token.type == t_EOL) {
        rule_eol();
    }

    // Test package main
    if (token.type != t_PACKAGE_MAIN) { error_call(ERR_SYN, &tokens); }
    else { token = get_next_token(stdin); TDLLInsertLast(&tokens, token); }

    // Neterminal <eol> -- nepovinny eol
    if (token.type == t_EOL) {
        rule_eol();
    }

    // Neterminal <def_func> -- Zacne definicia funkcie
    if (token.type != t_FUNC) { error_call(ERR_SYN, &tokens); }
    else {
        token = get_next_token(stdin);
        TDLLInsertLast(&tokens, token);
        def_func();
    }
    goThroughList(&tokens);

    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xaa01(%rip), %rbx      # 0xc3b0
movq %rbx, %rdi
callq 0x16a3
movq 0xa61a(%rip), %r14      # 0xbfd8
movq (%r14), %rdi
callq 0x31f4
movq %rax, 0xa9fb(%rip)      # 0xc3c8
movl %edx, 0xa9fd(%rip)      # 0xc3d0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1722
movl 0xa9ec(%rip), %eax      # 0xc3d0
cmpl $0x2f, %eax
jne 0x19f4
callq 0x2f48
movl 0xa9dc(%rip), %eax      # 0xc3d0
cmpl $0x1b, %eax
jne 0x1a1f
movq (%r14), %rdi
callq 0x31f4
movq %rax, 0xa9c0(%rip)      # 0xc3c8
movl %edx, 0xa9c2(%rip)      # 0xc3d0
leaq 0xa99b(%rip), %rdi      # 0xc3b0
movq %rax, %rsi
callq 0x1722
jmp 0x1a30
leaq 0xa98a(%rip), %rsi      # 0xc3b0
movl $0x2, %edi
callq 0x42d0
movl 0xa99a(%rip), %eax      # 0xc3d0
cmpl $0x2f, %eax
jne 0x1a46
callq 0x2f48
movl 0xa98a(%rip), %eax      # 0xc3d0
cmpl $0x1c, %eax
jne 0x1a76
movq (%r14), %rdi
callq 0x31f4
movq %rax, 0xa96e(%rip)      # 0xc3c8
movl %edx, 0xa970(%rip)      # 0xc3d0
leaq 0xa949(%rip), %rdi      # 0xc3b0
movq %rax, %rsi
callq 0x1722
callq 0x1a9d
jmp 0x1a87
leaq 0xa933(%rip), %rsi      # 0xc3b0
movl $0x2, %edi
callq 0x42d0
leaq 0xa922(%rip), %rdi      # 0xc3b0
callq 0x78f1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/parser.c
// Function: rule_func_retlist_body
void rule_func_retlist_body() {
    switch (token.type) {
        //REQUIRED_RETURN
        case t_LEFT_BRACKET:
            token = get_next_token(stdin);
            TDLLInsertLast(&tokens, token);

            rule_func_body();

            break;

            //OPTIONAL_RETURN
        case t_BRACES_L:
            global_brace_count++;
            token = get_next_token(stdin);
            TDLLInsertLast(&tokens, token);
            if (token.type != t_EOL) { error_call(ERR_SYN, &tokens); }
            else { token = get_next_token(stdin); TDLLInsertLast(&tokens, token); }

            // Neterminál stat (STATEMENT) -- Vyjadruje možné príkazy v tele funkcie
            rule_stat();

    }
}

// Assembly:
pushq %rbx
movl 0xa790(%rip), %eax      # 0xc3d0
cmpl $0x34, %eax
je 0x1c7f
cmpl $0x6, %eax
jne 0x1cdf
movq 0xa383(%rip), %rax      # 0xbfd8
movq (%rax), %rdi
callq 0x31f4
movq %rax, 0xa764(%rip)      # 0xc3c8
movl %edx, 0xa766(%rip)      # 0xc3d0
leaq 0xa73f(%rip), %rdi      # 0xc3b0
movq %rax, %rsi
callq 0x1722
popq %rbx
jmp 0x1d47
incl 0xa727(%rip)            # 0xc3ac
movq 0xa34c(%rip), %rbx      # 0xbfd8
movq (%rbx), %rdi
callq 0x31f4
movq %rax, 0xa72d(%rip)      # 0xc3c8
movl %edx, 0xa72f(%rip)      # 0xc3d0
leaq 0xa708(%rip), %rdi      # 0xc3b0
movq %rax, %rsi
callq 0x1722
cmpl $0x2f, 0xa719(%rip)     # 0xc3d0
jne 0x1ce1
movq (%rbx), %rdi
callq 0x31f4
movq %rax, 0xa700(%rip)      # 0xc3c8
movl %edx, 0xa702(%rip)      # 0xc3d0
leaq 0xa6db(%rip), %rdi      # 0xc3b0
movq %rax, %rsi
callq 0x1722
jmp 0x1cf2
popq %rbx
retq
leaq 0xa6c8(%rip), %rsi      # 0xc3b0
movl $0x2, %edi
callq 0x42d0
popq %rbx
jmp 0x1e2e
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/parser.c
// Function: rule_func_body
void rule_func_body() {
    //pravidlo return_type
    rule_return_type();

    //V prípade, že nám nepríde ukončovacia zátvorka zoznamu návratových typov, ERROR.

    if (token.type != t_RIGHT_BRACKET) { error_call(ERR_SYN, &tokens); }
    else { token = get_next_token(stdin); TDLLInsertLast(&tokens, token); }

    // Token otváracej množinovej zátvorky pre začiatok tela funckie

    if (token.type != t_BRACES_L) { error_call(ERR_SYN, &tokens); }
    else {
        global_brace_count++;
        token = get_next_token(stdin);
        TDLLInsertLast(&tokens, token);
    }

    // Nutný EOL po otváracej množinovej zátvorke
    if (token.type != t_EOL) { error_call(ERR_SYN, &tokens); }
    else { token = get_next_token(stdin); TDLLInsertLast(&tokens, token); }


    // Neterminál EOL pre možné príkazy v tele funckie
    rule_stat();

}

// Assembly:
pushq %rax
callq 0x1cf8
cmpl $0x7, 0xa67c(%rip)      # 0xc3d0
jne 0x1d83
movq 0xa27b(%rip), %rax      # 0xbfd8
movq (%rax), %rdi
callq 0x31f4
movq %rax, 0xa65c(%rip)      # 0xc3c8
movl %edx, 0xa65e(%rip)      # 0xc3d0
leaq 0xa637(%rip), %rdi      # 0xc3b0
movq %rax, %rsi
callq 0x1722
jmp 0x1d94
leaq 0xa626(%rip), %rsi      # 0xc3b0
movl $0x2, %edi
callq 0x42d0
cmpl $0x34, 0xa635(%rip)     # 0xc3d0
jne 0x1dd0
incl 0xa609(%rip)            # 0xc3ac
movq 0xa22e(%rip), %rax      # 0xbfd8
movq (%rax), %rdi
callq 0x31f4
movq %rax, 0xa60f(%rip)      # 0xc3c8
movl %edx, 0xa611(%rip)      # 0xc3d0
leaq 0xa5ea(%rip), %rdi      # 0xc3b0
movq %rax, %rsi
callq 0x1722
jmp 0x1de1
leaq 0xa5d9(%rip), %rsi      # 0xc3b0
movl $0x2, %edi
callq 0x42d0
cmpl $0x2f, 0xa5e8(%rip)     # 0xc3d0
jne 0x1e17
movq 0xa1e7(%rip), %rax      # 0xbfd8
movq (%rax), %rdi
callq 0x31f4
movq %rax, 0xa5c8(%rip)      # 0xc3c8
movl %edx, 0xa5ca(%rip)      # 0xc3d0
leaq 0xa5a3(%rip), %rdi      # 0xc3b0
movq %rax, %rsi
callq 0x1722
jmp 0x1e28
leaq 0xa592(%rip), %rsi      # 0xc3b0
movl $0x2, %edi
callq 0x42d0
popq %rax
jmp 0x1e2e
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/parser.c
// Function: rule_params
void rule_params() {
    // nastavenie flagu na true
    no_id_in_params_flag = true;
    switch (token.type) {
        case t_IDENTIFIER:
            token = get_next_token(stdin);
            TDLLInsertLast(&tokens, token);
            //kontrola, ci je správny typ
            rule_type();
            //Ak nasleduju dalsie parametre
            rule_params_n();
            break;

        // koniec zoznamu ukoncovacou zatvorkou
        case t_RIGHT_BRACKET:
            token = get_next_token(stdin);
            TDLLInsertLast(&tokens, token);
            break;
    }
    no_id_in_params_flag = false;
}

// Assembly:
pushq %rax
movb $0x1, 0x9d1b(%rip)      # 0xc3a8
movl 0x9d3d(%rip), %eax      # 0xc3d0
cmpl $0x7, %eax
je 0x26d4
cmpl $0x13, %eax
jne 0x26ff
movq 0x9934(%rip), %rax      # 0xbfd8
movq (%rax), %rdi
callq 0x31f4
movq %rax, 0x9d15(%rip)      # 0xc3c8
movl %edx, 0x9d17(%rip)      # 0xc3d0
leaq 0x9cf0(%rip), %rdi      # 0xc3b0
movq %rax, %rsi
callq 0x1722
callq 0x2ce8
callq 0x2708
jmp 0x26ff
movq 0x98fd(%rip), %rax      # 0xbfd8
movq (%rax), %rdi
callq 0x31f4
movq %rax, 0x9cde(%rip)      # 0xc3c8
movl %edx, 0x9ce0(%rip)      # 0xc3d0
leaq 0x9cb9(%rip), %rdi      # 0xc3b0
movq %rax, %rsi
callq 0x1722
movb $0x0, 0x9ca2(%rip)      # 0xc3a8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/parser.c
// Function: rule_params_n
void rule_params_n() {
    //ak pride zatvorka -- koniec
    if (token.type == t_RIGHT_BRACKET) {
        token = get_next_token(stdin);
        TDLLInsertLast(&tokens, token);
        return;
    }

    // prva musi prist ciarka ako oddelovac dalsieho parametra
    if (token.type != t_COMMA) { error_call(ERR_SYN, &tokens); }
    else { token = get_next_token(stdin); TDLLInsertLast(&tokens, token); }

    // kontrola, ci po ciarke pride id
    if (token.type != t_IDENTIFIER) { error_call(ERR_SYN, &tokens); }
        // ak pride id, pokracujeme typom a nasledne volame params_n znova
    else {
        token = get_next_token(stdin);
        TDLLInsertLast(&tokens, token);
        //kontrola, ci je typ premennej správny
        rule_type();
        // rekurzivne volanie params_n
        rule_params_n();
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x98c5(%rip), %r14      # 0xbfd8
leaq 0x9c96(%rip), %rbx      # 0xc3b0
movl 0x9cb0(%rip), %eax      # 0xc3d0
cmpl $0x5, %eax
je 0x2739
cmpl $0x7, %eax
je 0x27a1
movl $0x2, %edi
movq %rbx, %rsi
callq 0x42d0
jmp 0x2759
movq (%r14), %rdi
callq 0x31f4
movq %rax, 0x9c80(%rip)      # 0xc3c8
movl %edx, 0x9c82(%rip)      # 0xc3d0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1722
cmpl $0x13, 0x9c70(%rip)     # 0xc3d0
jne 0x2789
movq (%r14), %rdi
callq 0x31f4
movq %rax, 0x9c57(%rip)      # 0xc3c8
movl %edx, 0x9c59(%rip)      # 0xc3d0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1722
callq 0x2ce8
jmp 0x271a
leaq 0x9c20(%rip), %rsi      # 0xc3b0
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x42d0
movq (%r14), %rdi
callq 0x31f4
movq %rax, 0x9c18(%rip)      # 0xc3c8
movl %edx, 0x9c1a(%rip)      # 0xc3d0
leaq 0x9bf3(%rip), %rdi      # 0xc3b0
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1722
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/parser.c
// Function: rule_func_params
void rule_func_params() {
   //Token pravá zátvorka, koniec
    if (token.type == t_RIGHT_BRACKET) {
        token = get_next_token(stdin);
        TDLLInsertLast(&tokens, token);
        return;
    }
    else {
        // Možné typy vo vstupnych parametroch funckie
        if (token.type != t_IDENTIFIER && token.type != t_FLOAT && token.type != t_STRING &&
            token.type != t_INT_NON_ZERO && token.type != t_INT_ZERO) { error_call(ERR_SYN, &tokens); }
        token = get_next_token(stdin);
        TDLLInsertLast(&tokens, token);
        //rekurzivne func_params_NEXT, bud budu dalsie typy alebo koniec
        rule_func_params_n();
    }
}

// Assembly:
pushq %rax
movl 0x9bfd(%rip), %eax      # 0xc3d0
cmpq $0x2b, %rax
ja 0x284c
movabsq $0xa00000b0000, %rcx    # imm = 0xA00000B0000
btq %rax, %rcx
jae 0x281a
movq 0x97e8(%rip), %rax      # 0xbfd8
movq (%rax), %rdi
callq 0x31f4
movq %rax, 0x9bc9(%rip)      # 0xc3c8
movl %edx, 0x9bcb(%rip)      # 0xc3d0
leaq 0x9ba4(%rip), %rdi      # 0xc3b0
movq %rax, %rsi
callq 0x1722
popq %rax
jmp 0x285f
cmpq $0x7, %rax
jne 0x284c
movq 0x97b1(%rip), %rax      # 0xbfd8
movq (%rax), %rdi
callq 0x31f4
movq %rax, 0x9b92(%rip)      # 0xc3c8
movl %edx, 0x9b94(%rip)      # 0xc3d0
leaq 0x9b6d(%rip), %rdi      # 0xc3b0
movq %rax, %rsi
popq %rax
jmp 0x1722
leaq 0x9b5d(%rip), %rsi      # 0xc3b0
movl $0x2, %edi
callq 0x42d0
jmp 0x27e9
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/parser.c
// Function: rule_func_params_n
void rule_func_params_n() {
    if (token.type == t_RIGHT_BRACKET) { return; }

    else {
        // Za prechádzajúcim typom musí prísť čiarka napr. (10 , ...)
        if (token.type != t_COMMA) { error_call(ERR_SYN, &tokens); }
        token = get_next_token(stdin);
        TDLLInsertLast(&tokens, token);

        if (token.type != t_IDENTIFIER && token.type != t_FLOAT && token.type != t_STRING &&
            token.type != t_INT_NON_ZERO && token.type != t_INT_ZERO) { error_call(ERR_SYN, &tokens); }
        token = get_next_token(stdin);
        TDLLInsertLast(&tokens, token);
        //rekurzivne volanie, bud dalsie typy alebo koniec
        rule_func_params_n();

    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x976d(%rip), %r14      # 0xbfd8
leaq 0x9b3e(%rip), %rbx      # 0xc3b0
movabsq $0xa00000b0000, %r15    # imm = 0xA00000B0000
movl 0x9b4e(%rip), %eax      # 0xc3d0
cmpl $0x5, %eax
je 0x2899
cmpl $0x7, %eax
je 0x28fc
movl $0x2, %edi
movq %rbx, %rsi
callq 0x42d0
movq (%r14), %rdi
callq 0x31f4
movq %rax, 0x9b20(%rip)      # 0xc3c8
movl %edx, 0x9b22(%rip)      # 0xc3d0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1722
movl 0x9b11(%rip), %eax      # 0xc3d0
cmpq $0x2b, %rax
ja 0x28ed
btq %rax, %r15
jae 0x28ed
movq (%r14), %rdi
callq 0x31f4
movq %rax, 0x9aee(%rip)      # 0xc3c8
movl %edx, 0x9af0(%rip)      # 0xc3d0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1722
jmp 0x287c
movl $0x2, %edi
movq %rbx, %rsi
callq 0x42d0
jmp 0x28cb
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/parser.c
// Function: rule_id_n
void rule_id_n() {
    switch (token.type) {
        // za predchádzajúcim identifikátorom musí prísť čiarka
        case t_COMMA:
            token = get_next_token(stdin);
            TDLLInsertLast(&tokens, token);
            //token ID
            if (token.type != t_IDENTIFIER) { error_call(ERR_SYN, &tokens); }
            else { token = get_next_token(stdin); TDLLInsertLast(&tokens, token); }


            //rekurzivne volanie pre dalsie mozne IDs, ak nepridu, koniec
            rule_id_n();
            break;
            //ak pride =, koniec
        case t_ASSIGN:
            break;
            //ak pride :=, koniec, NEPODPORUJEME, ROZSIRENIE MULTI_VAL
        case t_DEFINITION_2:
            break;
            // hocico ine, ERROR
        default:
            error_call(ERR_SYN, &tokens);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x96cb(%rip), %r14      # 0xbfd8
leaq 0x9a9c(%rip), %rbx      # 0xc3b0
movl 0x9ab6(%rip), %eax      # 0xc3d0
cmpl $0x5, %eax
jne 0x2979
movq (%r14), %rdi
callq 0x31f4
movq %rax, 0x9a9a(%rip)      # 0xc3c8
movl %edx, 0x9a9c(%rip)      # 0xc3d0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1722
cmpl $0x13, 0x9a8a(%rip)     # 0xc3d0
jne 0x296a
movq (%r14), %rdi
callq 0x31f4
movq %rax, 0x9a71(%rip)      # 0xc3c8
movl %edx, 0x9a73(%rip)      # 0xc3d0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1722
jmp 0x2914
movl $0x2, %edi
movq %rbx, %rsi
callq 0x42d0
jmp 0x2914
cmpl $0x3, %eax
je 0x2983
cmpl $0x32, %eax
jne 0x298b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x9a1e(%rip), %rsi      # 0xc3b0
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x42d0
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/parser.c
// Function: rule_type
void rule_type() {
    // Priradenie datoveho typu -
    switch (token.type) {
        case t_FLOAT64:
            token = get_next_token(stdin);
            TDLLInsertLast(&tokens, token);
            break;
        case t_INT_ID:
            token = get_next_token(stdin);
            TDLLInsertLast(&tokens, token);
            break;
        case t_INT_ZERO:
            token = get_next_token(stdin);
            TDLLInsertLast(&tokens, token);
            break;
        case t_STRING_ID:
            token = get_next_token(stdin);
            TDLLInsertLast(&tokens, token);
            break;
        case t_IDENTIFIER:
            if (no_id_in_params_flag == true) { error_call(ERR_SYN, &tokens); }
            token = get_next_token(stdin);
            TDLLInsertLast(&tokens, token);
            break;
        default:
            error_call(ERR_SYN, &tokens);
    }
}

// Assembly:
pushq %rax
movl 0x96e1(%rip), %eax      # 0xc3d0
addl $-0x10, %eax
cmpl $0x8, %eax
ja 0x2d33
leaq 0x53aa(%rip), %rcx      # 0x80a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x92ca(%rip), %rax      # 0xbfd8
movq (%rax), %rdi
callq 0x31f4
movq %rax, 0x96ab(%rip)      # 0xc3c8
movl %edx, 0x96ad(%rip)      # 0xc3d0
leaq 0x9686(%rip), %rdi      # 0xc3b0
movq %rax, %rsi
popq %rax
jmp 0x1722
leaq 0x9676(%rip), %rsi      # 0xc3b0
movl $0x2, %edi
popq %rax
jmp 0x42d0
cmpb $0x1, 0x965c(%rip)      # 0xc3a8
jne 0x2d07
leaq 0x965b(%rip), %rsi      # 0xc3b0
movl $0x2, %edi
callq 0x42d0
jmp 0x2d07
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/parser.c
// Function: rule_return_type_n
void rule_return_type_n() {
    no_id_in_params_flag = true;
    switch (token.type) {
        case t_COMMA:
            // Musí prís čiarka za predchadzajúcim návratovým typom
            token = get_next_token(stdin);
            TDLLInsertLast(&tokens, token);
            rule_type();
            rule_return_type_n();
            break;

            //prava zatvorka, koniec
        case t_RIGHT_BRACKET:
            break;

        default:
            error_call(ERR_SYN, &tokens);
    }
    no_id_in_params_flag = false;
}

// Assembly:
movb $0x1, 0x95dc(%rip)      # 0xc3a8
movl 0x95fe(%rip), %eax      # 0xc3d0
cmpl $0x7, %eax
je 0x2e29
pushq %rax
cmpl $0x5, %eax
jne 0x2e14
movq 0x91f4(%rip), %rax      # 0xbfd8
movq (%rax), %rdi
callq 0x31f4
movq %rax, 0x95d5(%rip)      # 0xc3c8
movl %edx, 0x95d7(%rip)      # 0xc3d0
leaq 0x95b0(%rip), %rdi      # 0xc3b0
movq %rax, %rsi
callq 0x1722
callq 0x2ce8
callq 0x2dc5
jmp 0x2e25
leaq 0x9595(%rip), %rsi      # 0xc3b0
movl $0x2, %edi
callq 0x42d0
addq $0x8, %rsp
movb $0x0, 0x9578(%rip)      # 0xc3a8
retq
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/parser.c
// Function: rule_exp_n
void rule_exp_n() {

    if (token.type == t_EOL)
    {
        return;

    } else if (token.type == t_BRACES_L) {
        return;
    } else if (token.type != t_COMMA) {error_call(ERR_SYN, &tokens);}
    else {
        token = get_next_token(stdin);
        TDLLInsertLast(&tokens, token);

        TDLLInitList(&psa_list);

        if (token.type == t_EOL) {error_call(ERR_SYN, &tokens);}
        else {

            while (token.type != t_COMMA && token.type != t_EOL && token.type != t_BRACES_L) {
                if ((token.type == t_PLUS)
                    || (token.type == t_MINUS)
                    || (token.type == t_DIVIDE)
                    || (token.type == t_MULTIPLY)
                    || (token.type == t_RIGHT_BRACKET)
                    || (token.type == t_LEFT_BRACKET)
                    || (token.type == t_LESS)
                    || (token.type == t_LESSOREQUAL)
                    || (token.type == t_GREATER)
                    || (token.type == t_GREATEROREQUAL)
                    || (token.type == t_EQUAL)
                    || (token.type == t_NOT_EQUAL)
                    || (token.type == t_IDENTIFIER)
                    || (token.type == t_FLOAT)
                    || (token.type == t_INT_NON_ZERO)
                    || (token.type == t_INT_ZERO)
                    || (token.type == t_STRING)) {

                    TDLLInsertLast(&psa_list, token);
                    token = get_next_token(stdin); TDLLInsertLast(&tokens, token);

                } else { error_call(ERR_SYN, &tokens); }
            }

            evaluation(&psa_list, &tokens);
            TDLLDisposeList(&psa_list);


            rule_exp_n();
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x9197(%rip), %r15      # 0xbfd8
leaq 0x9568(%rip), %rbx      # 0xc3b0
leaq 0x9589(%rip), %r14      # 0xc3d8
movabsq $0xa03c00b0fc6, %r12    # imm = 0xA03C00B0FC6
movabsq $0x10800000000020, %r13 # imm = 0x10800000000020
movl 0x9567(%rip), %eax      # 0xc3d0
cmpl $0x5, %eax
jne 0x2f1a
movq (%r15), %rdi
callq 0x31f4
movq %rax, 0x9547(%rip)      # 0xc3c8
movl %edx, 0x9549(%rip)      # 0xc3d0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1722
movq %r14, %rdi
callq 0x16a3
movl 0x9530(%rip), %edx      # 0xc3d0
cmpl $0x2f, %edx
je 0x2f2e
cmpl $0x34, %edx
ja 0x2ef3
movl %edx, %eax
btq %rax, %r12
jae 0x2eed
movq 0x950b(%rip), %rsi      # 0xc3c8
movq %r14, %rdi
callq 0x1722
movq (%r15), %rdi
callq 0x31f4
movq %rax, 0x94f4(%rip)      # 0xc3c8
movl %edx, 0x94f6(%rip)      # 0xc3d0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1722
movl 0x94e5(%rip), %edx      # 0xc3d0
jmp 0x2ea9
btq %rax, %r13
jb 0x2f02
movl $0x2, %edi
movq %rbx, %rsi
callq 0x42d0
jmp 0x2ee5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7bf8
movq %r14, %rdi
callq 0x16b2
jmp 0x2e63
cmpl $0x2f, %eax
je 0x2f24
cmpl $0x34, %eax
jne 0x2f2e
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x947b(%rip), %rsi      # 0xc3b0
movl $0x2, %edi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x42d0
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/parser.c
// Function: rule_eol
void rule_eol() {

    //Zaplata pre PRAVE ZATVORKY
    if (token.type == t_BRACES_R) { return; }

    token = get_next_token(stdin);
    TDLLInsertLast(&tokens, token);

    switch (token.type) {
        case t_EOL:
            rule_eol();
            break;

        default:
            if (between_def == true) {
                if (token.type != t_FUNC && token.type != t_EOF) {
                    error_call(ERR_SYN, &tokens);
                }
            }
            break;
    }
}

// Assembly:
cmpl $0x33, 0x9481(%rip)     # 0xc3d0
jne 0x2f52
retq
pushq %r14
pushq %rbx
pushq %rax
movq 0x907b(%rip), %r14      # 0xbfd8
leaq 0x944c(%rip), %rbx      # 0xc3b0
movq (%r14), %rdi
callq 0x31f4
movq %rax, 0x9455(%rip)      # 0xc3c8
movl %edx, 0x9457(%rip)      # 0xc3d0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1722
movl 0x9446(%rip), %eax      # 0xc3d0
cmpl $0x2f, %eax
je 0x2f64
addl $-0x1e, %eax
cmpl $-0x3, %eax
leaq 0x8(%rsp), %rsp
popq %rbx
popq %r14
ja 0x2f51
cmpb $0x0, 0x9405(%rip)      # 0xc3ab
je 0x2f51
leaq 0x9401(%rip), %rsi      # 0xc3b0
movl $0x2, %edi
jmp 0x42d0
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/parser.c
// Function: optional_return
void optional_return(){

    // Nic nevraciame, cize za RETURNOM musí ísť eol
    if (token.type != t_EOL) { error_call(ERR_SEM_RETURN, &tokens); }
    else { token = get_next_token(stdin); TDLLInsertLast(&tokens, token); }

    // Možné eoly na konci
    if (token.type == t_EOL) {
        rule_eol();
    }
}

// Assembly:
pushq %rax
cmpl $0x2f, 0x940f(%rip)     # 0xc3d0
jne 0x2ff0
movq 0x900e(%rip), %rax      # 0xbfd8
movq (%rax), %rdi
callq 0x31f4
movq %rax, 0x93ef(%rip)      # 0xc3c8
movl %edx, 0x93f1(%rip)      # 0xc3d0
leaq 0x93ca(%rip), %rdi      # 0xc3b0
movq %rax, %rsi
callq 0x1722
jmp 0x3001
leaq 0x93b9(%rip), %rsi      # 0xc3b0
movl $0x6, %edi
callq 0x42d0
cmpl $0x2f, 0x93c8(%rip)     # 0xc3d0
jne 0x3010
popq %rax
jmp 0x2f48
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/parser.c
// Function: required_return
void required_return() {
    TDLLInitList(&psa_list);

    if (token.type == t_EOL) {error_call(ERR_SEM_RETURN, &tokens);}
    else {

        while (token.type != t_COMMA && token.type != t_EOL) {
            if ((token.type == t_PLUS)
                || (token.type == t_MINUS)
                || (token.type == t_DIVIDE)
                || (token.type == t_MULTIPLY)
                || (token.type == t_RIGHT_BRACKET)
                || (token.type == t_LEFT_BRACKET)
                || (token.type == t_LESS)
                || (token.type == t_LESSOREQUAL)
                || (token.type == t_GREATER)
                || (token.type == t_GREATEROREQUAL)
                || (token.type == t_EQUAL)
                || (token.type == t_NOT_EQUAL)
                || (token.type == t_IDENTIFIER)
                || (token.type == t_FLOAT)
                || (token.type == t_INT_NON_ZERO)
                || (token.type == t_INT_ZERO)
                || (token.type == t_STRING)){

                TDLLInsertLast(&psa_list, token);
                token = get_next_token(stdin);
                TDLLInsertLast(&tokens, token);

            } else { error_call(ERR_SYN, &tokens); }
        }

        evaluation(&psa_list, &tokens);
        TDLLDisposeList(&psa_list);

    }


    // Ak za returnom nasledujú dalsie return výrazy
    rule_exp_n();



    //mozné EOLy sa returnom
    if (token.type == t_EOL) {
        rule_eol();
    }

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x93b6(%rip), %rdi      # 0xc3d8
callq 0x16a3
movl 0x93a3(%rip), %edx      # 0xc3d0
cmpl $0x2f, %edx
jne 0x3048
leaq 0x9377(%rip), %rsi      # 0xc3b0
movl $0x6, %edi
callq 0x42d0
jmp 0x30e9
leaq 0x9361(%rip), %rbx      # 0xc3b0
movabsq $0xa03c00b0fc6, %r15    # imm = 0xA03C00B0FC6
leaq 0x9378(%rip), %r14      # 0xc3d8
movq 0x8f71(%rip), %r12      # 0xbfd8
movabsq $0x800000000020, %r13   # imm = 0x800000000020
cmpl $0x2f, %edx
ja 0x30bc
movl %edx, %eax
btq %rax, %r15
jae 0x30b6
movq 0x9343(%rip), %rsi      # 0xc3c8
movq %r14, %rdi
callq 0x1722
movq (%r12), %rdi
callq 0x31f4
movq %rax, 0x932b(%rip)      # 0xc3c8
movl %edx, 0x932d(%rip)      # 0xc3d0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1722
movl 0x931c(%rip), %edx      # 0xc3d0
jmp 0x3071
btq %rax, %r13
jb 0x30cb
movl $0x2, %edi
movq %rbx, %rsi
callq 0x42d0
jmp 0x30ae
leaq 0x9306(%rip), %rbx      # 0xc3d8
leaq 0x92d7(%rip), %rsi      # 0xc3b0
movq %rbx, %rdi
callq 0x7bf8
movq %rbx, %rdi
callq 0x16b2
callq 0x2e31
cmpl $0x2f, 0x92db(%rip)     # 0xc3d0
jne 0x3105
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2f48
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/scanner.c
// Function: load_c
void load_c(FILE* text)
{
    current_char = getc(text);
    current_token[current_token_position] = current_char;
    current_token_position++;
    current_token[current_token_position] = 0x00;
}

// Assembly:
pushq %rax
callq 0x10e0
movb %al, 0x9326(%rip)       # 0xc474
movslq 0x92af(%rip), %rcx      # 0xc404
leaq 0x92b4(%rip), %rdx      # 0xc410
movb %al, (%rcx,%rdx)
leaq 0x1(%rcx), %rax
movl %eax, 0x929b(%rip)      # 0xc404
movb $0x0, 0x1(%rcx,%rdx)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/scanner.c
// Function: end_token
void end_token(int type, TOKEN* token)
{
    alloc(current_token_position+1, token);
    strcpy(token->lex, current_token);
    token->type = type;
    delete_string();
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movslq 0x9245(%rip), %rdi      # 0xc404
incq %rdi
callq 0x10a0
movq %rax, (%rbx)
leaq 0x923f(%rip), %rsi      # 0xc410
movq %rax, %rdi
callq 0x1040
movl %ebp, 0x8(%rbx)
movb $0x0, 0x922d(%rip)      # 0xc410
movl $0x0, 0x9217(%rip)      # 0xc404
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/symtable.c
// Function: BSTSearchGlobal
bool BSTSearchGlobal (tBSTNodePtrGlobal RootPtr, char* name,functionData *Content)	{

	if (RootPtr != NULL)
	{
		if ((strcmp(name, RootPtr->Name) < 0))
		{
			return BSTSearchGlobal(RootPtr->LPtr,name,Content);
				
		}
		else if (strcmp(name, RootPtr->Name) > 0)
		{
			return BSTSearchGlobal(RootPtr->RPtr,name,Content);
		}
		else
		{
			*(Content) = RootPtr->content;
			return true;								
		}
	}
	else 
	{

		return false;
	}
}

// Assembly:
testq %rdi, %rdi
je 0x43eb
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%r14), %rsi
movq %r15, %rdi
callq 0x1080
movl $0x1010, %ecx           # imm = 0x1010
testl %eax, %eax
js 0x43de
movl $0x1018, %ecx           # imm = 0x1018
je 0x43ee
movq (%r14,%rcx), %r14
testq %r14, %r14
jne 0x43c3
xorl %eax, %eax
jmp 0x4404
xorl %eax, %eax
retq
addq $0x8, %r14
movl $0x1008, %edx           # imm = 0x1008
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1090
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/symtable.c
// Function: BSTInsertGlobal
void BSTInsertGlobal (tBSTNodePtrGlobal* RootPtr, char* name, functionData Content)	{

    
	if (*RootPtr == NULL)
	{
		*RootPtr = malloc(sizeof (struct tBSTNodeGlobal));	
		(*RootPtr)->Name = name;
		(*RootPtr)->content = Content;
		(*RootPtr)->LPtr = NULL;
		(*RootPtr)->RPtr = NULL;	
	}

	else if (strcmp(name, (*RootPtr)->Name) == 0)
	{														
		(*RootPtr)->content = Content;

	}
	else if (strcmp(name, (*RootPtr)->Name) < 0)     	
	{
		BSTInsertGlobal(&(*RootPtr)->LPtr,name,Content);
	}
	else if (strcmp(name, (*RootPtr)->Name) > 0)
	{
		BSTInsertGlobal(&(*RootPtr)->RPtr,name,Content);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq 0x30(%rsp), %rbx
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x4454
movq %rcx, %r14
movq (%rcx), %rsi
movq %r15, %rdi
callq 0x1080
testl %eax, %eax
je 0x4486
notl %eax
shrl $0x1f, %eax
movq 0x1010(%r14,%rax,8), %rcx
testq %rcx, %rcx
jne 0x4425
leaq 0x1010(,%rax,8), %rax
addq %rax, %r14
movl $0x1020, %edi           # imm = 0x1020
callq 0x10a0
movq %rax, %r12
movq %rax, (%r14)
movq %r15, (%rax)
leaq 0x8(%rax), %rdi
movl $0x1008, %edx           # imm = 0x1008
movq %rbx, %rsi
callq 0x1090
xorps %xmm0, %xmm0
movups %xmm0, 0x1010(%r12)
jmp 0x449a
addq $0x8, %r14
movl $0x1008, %edx           # imm = 0x1008
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1090
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/symtable.c
// Function: BSTDisposeGlobal
void BSTDisposeGlobal (tBSTNodePtrGlobal *RootPtr) {

	if (*RootPtr != NULL)					
	{
		BSTDisposeGlobal(&(*RootPtr)->LPtr);
		BSTDisposeGlobal(&(*RootPtr)->RPtr);
		free(*RootPtr);
		*RootPtr = NULL;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x44da
addq $0x1010, %rdi           # imm = 0x1010
callq 0x44a6
movl $0x1018, %edi           # imm = 0x1018
addq (%rbx), %rdi
callq 0x44a6
movq (%rbx), %rdi
callq 0x1030
movq $0x0, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/symtable.c
// Function: BSTSearchLocal
bool BSTSearchLocal (tBSTNodePtrLocal RootPtr, char* name, int *Type, char *Data)    {


    if (RootPtr != NULL && RootPtr->Name != NULL)
    {
        if ((strcmp(name, RootPtr->Name) < 0))
        {
            return BSTSearchLocal(RootPtr->LPtr,name, Type, Data);
                
        }
        else if (strcmp(name, RootPtr->Name) > 0)
        {
            return BSTSearchLocal(RootPtr->RPtr,name, Type, Data);
        }
        else
        {
            *Type = RootPtr->Type;
            //*Data = *RootPtr->Data;
            return true;
        }
    }
    else
    {
        return false;
    }
}

// Assembly:
testq %rdi, %rdi
je 0x4528
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%r14), %rsi
testq %rsi, %rsi
je 0x4520
movq %r15, %rdi
callq 0x1080
movl $0x18, %ecx
testl %eax, %eax
js 0x4517
movl $0x20, %ecx
je 0x452b
movq (%r14,%rcx), %r14
testq %r14, %r14
jne 0x44f7
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
movl 0x8(%r14), %eax
movl %eax, (%rbx)
movb $0x1, %al
jmp 0x4522
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/symtable.c
// Function: BSTInsertLocal
void BSTInsertLocal (tBSTNodePtrLocal* RootPtr, char * Name, int *Type, char *Data)	{


	if (*RootPtr == NULL){
		*RootPtr = malloc(sizeof (struct tBSTNodeLocal));	
		(*RootPtr)->Name = Name;
		(*RootPtr)->LPtr = NULL;
		(*RootPtr)->RPtr = NULL;	
		(*RootPtr)->Type = *Type;
		(*RootPtr)->Data = Data;
	
	}else if (strcmp(Name, (*RootPtr)->Name) == 0)
	{
	}else if (strcmp(Name, (*RootPtr)->Name) < 0)     	
	{
	//	printf("Vlkadam dolava\n");
		BSTInsertLocal(&(*RootPtr)->LPtr,Name, Type, Data);
	}else if (strcmp(Name, (*RootPtr)->Name) > 0)
	{
	//	printf("Vkladam doprava\n");
		BSTInsertLocal(&(*RootPtr)->RPtr,Name, Type, Data);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x457d
movq %rcx, %r12
movq (%rcx), %rsi
movq %r15, %rdi
callq 0x1080
testl %eax, %eax
je 0x459f
notl %eax
shrl $0x1f, %eax
movq 0x18(%r12,%rax,8), %rcx
testq %rcx, %rcx
jne 0x4551
leaq 0x18(,%rax,8), %rax
addq %rax, %r12
movl $0x28, %edi
callq 0x10a0
movq %rax, (%r12)
movq %r15, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movl (%r14), %ecx
movl %ecx, 0x8(%rax)
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/symtable.c
// Function: ReplaceByRightmost
void ReplaceByRightmost (tBSTNodePtrLocal PtrReplaced, tBSTNodePtrLocal *RootPtr) {

	if(*RootPtr != NULL && PtrReplaced != NULL){
		if((*RootPtr)->RPtr != NULL){ 
			// najde najpravejsi uzol
			ReplaceByRightmost(PtrReplaced, &(*RootPtr)->RPtr);
		}else{
			PtrReplaced->Name = (*RootPtr)->Name;
			PtrReplaced->Type = (*RootPtr)->Type;
			PtrReplaced->Data = (*RootPtr)->Data;
			BSTDelete(RootPtr, (*RootPtr)->Name);
		}
	}else return;
}

// Assembly:
testq %rdi, %rdi
je 0x45f0
movq (%rsi), %rdx
testq %rdx, %rdx
je 0x45f0
movq %rsi, %rax
movq %rdx, %rcx
leaq 0x20(%rdx), %rsi
movq 0x20(%rdx), %rdx
testq %rdx, %rdx
jne 0x45b3
movq (%rcx), %rcx
movq %rcx, (%rdi)
movq (%rax), %rcx
movl 0x8(%rcx), %edx
movl %edx, 0x8(%rdi)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rdi)
movq (%rax), %rcx
movq (%rcx), %rsi
movq %rax, %rdi
jmp 0x45f1
retq
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/symtable.c
// Function: BSTDelete
void BSTDelete (tBSTNodePtrLocal *RootPtr, char *K) {

	if(*RootPtr != NULL){ // nemame prazdny uzol
		if((*RootPtr)->Name > K){ // kluc je vlavo 
			BSTDelete(&(*RootPtr)->LPtr, K);
		}else if((*RootPtr)->Name < K){ // kluc je vpravo
			BSTDelete(&(*RootPtr)->RPtr, K); 
		}else if((*RootPtr)->Name == K){ // ak sme nasli uzol

			if((*RootPtr)->LPtr != NULL && (*RootPtr)->RPtr != NULL){ // 2 podstromy
					ReplaceByRightmost(*RootPtr, &(*RootPtr)->LPtr);
			}else if((*RootPtr)->LPtr != NULL && (*RootPtr)->RPtr == NULL){ // lavy 
				tBSTNodePtrLocal temp_node;//funguje
				temp_node = (*RootPtr)->LPtr; // ulozime odstranovany uzol
				free(*RootPtr);
				*RootPtr = temp_node;

			}else if((*RootPtr)->RPtr != NULL && (*RootPtr)->LPtr == NULL){ // pravy
				tBSTNodePtrLocal temp_node; // funguje
				temp_node = (*RootPtr)->RPtr;
				free(*RootPtr);
				*RootPtr = temp_node;

			}else{ // ziadny podstrom funguje
				free(*RootPtr);
				*RootPtr = NULL;
			}
		}
	}else{
		return;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x465c
movl $0x18, %eax
cmpq %rsi, (%rdi)
ja 0x4612
movl $0x20, %eax
jae 0x461c
leaq (%rdi,%rax), %rbx
movq (%rdi,%rax), %rdi
jmp 0x45fc
movq 0x18(%rdi), %r15
movq 0x20(%rdi), %r14
testq %r15, %r15
je 0x463c
testq %r14, %r14
je 0x464b
leaq 0x18(%rdi), %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x45ab
callq 0x1030
testq %r14, %r14
je 0x4655
movq %r14, (%rbx)
jmp 0x465c
callq 0x1030
movq %r15, (%rbx)
jmp 0x465c
movq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/symtable.c
// Function: BSTDisposeLocal
void BSTDisposeLocal (tBSTNodePtrLocal *RootPtr) {	


	if (*RootPtr != NULL)					
	{
		BSTDisposeLocal(&(*RootPtr)->LPtr);
		BSTDisposeLocal(&(*RootPtr)->RPtr);
		free(*RootPtr);
		*RootPtr = NULL;
	}
	


}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x4692
addq $0x18, %rdi
callq 0x4662
movq (%rbx), %rdi
addq $0x20, %rdi
callq 0x4662
movq (%rbx), %rdi
callq 0x1030
movq $0x0, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/symtable.c
// Function: MainStackSearch
bool MainStackSearch(MainStack stack, char* id, int *type) {
    
    //pocet stromov v zasobniku
    int i = stack.top;
    //na ulozenie typu
    int typ = 0;
    char* unneeded = NULL;
    
    while (i != 0) {
        if (BSTSearchLocal((*stack.a[i]), id, &typ, unneeded)) {
            *type = typ;
            return true;
        }
        i--;
    }
    return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movslq 0x40(%rsp), %r12
movl $0x0, 0xc(%rsp)
testq %r12, %r12
je 0x4720
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x40(%rsp), %r13
leaq 0xc(%rsp), %r15
movq 0x8(%r13,%r12,8), %rax
movq (%rax), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x44e4
testb %al, %al
jne 0x4724
decq %r12
jne 0x4704
xorl %eax, %eax
jmp 0x472c
movl 0xc(%rsp), %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/semantics.c
// Function: printFunction
void printFunction(char *id, functionData data) {
    printf("Spustam printFunction\n");
    printf("Function id: %s\n", id);
    printf("Number of params: %d\n", data.numOfParams);
    printf("Number of return vals: %d\n", data.numOfReturns);
    printf("Params: \n");
    for (int i = 0; i < data.numOfParams; i++) {
        switch (data.paramsType[i]) {
            case t_INT_ID:
                printf("int ");
                break;
            case t_STRING_ID:
                printf("string ");
                break;
            case t_FLOAT64:
                printf("float64 ");
                break;
                
            default:
                break;
        }
        printf("%s\n", data.params[i]);
    }
    printf("Return types:\n");
    for (int i = 0; i < data.numOfReturns; i++) {
        switch (data.returns[i]) {
            case t_INT_ID:
                printf("int ");
                break;
            case t_STRING_ID:
                printf("string ");
                break;
            case t_FLOAT64:
                printf("float64 ");
                break;
                
            default:
                break;
        }
    }
    printf("\nprintFunction Ended\n\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x40(%rsp), %r15
leaq 0x3e19(%rip), %rdi      # 0x856f
callq 0x1050
leaq 0x3d5e(%rip), %rdi      # 0x84c0
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1070
movslq (%r15), %r14
leaq 0x3d5b(%rip), %rdi      # 0x84d1
movl %r14d, %esi
xorl %eax, %eax
callq 0x1070
movl 0x4(%r15), %ebx
leaq 0x3d5c(%rip), %rdi      # 0x84e7
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x3dea(%rip), %rdi      # 0x8585
callq 0x1050
testq %r14, %r14
jle 0x47f5
leaq 0x3d56(%rip), %r12      # 0x8502
leaq 0x3d54(%rip), %rbp      # 0x8507
xorl %r13d, %r13d
movl 0x808(%r15,%r13,4), %eax
movq %r12, %rdi
cmpl $0x18, %eax
je 0x47dc
cmpl $0x17, %eax
je 0x47d5
cmpl $0x14, %eax
jne 0x47e3
movq %rbp, %rdi
jmp 0x47dc
leaq 0x3d33(%rip), %rdi      # 0x850f
xorl %eax, %eax
callq 0x1070
movq 0x8(%r15,%r13,8), %rdi
callq 0x1050
incq %r13
cmpq %r13, %r14
jne 0x47b6
leaq 0x3d92(%rip), %rdi      # 0x858e
callq 0x1050
testl %ebx, %ebx
jle 0x484d
leaq 0x3cf6(%rip), %r14      # 0x8502
leaq 0x3cfc(%rip), %r12      # 0x850f
leaq 0x3ced(%rip), %r13      # 0x8507
xorl %ebp, %ebp
movl 0xc08(%r15,%rbp,4), %eax
movq %r14, %rdi
cmpl $0x18, %eax
je 0x483e
cmpl $0x17, %eax
je 0x483b
cmpl $0x14, %eax
jne 0x4845
movq %r13, %rdi
jmp 0x483e
movq %r12, %rdi
xorl %eax, %eax
callq 0x1070
incq %rbp
cmpq %rbp, %rbx
jne 0x481c
leaq 0x3d48(%rip), %rdi      # 0x859c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O3/MartinNovotny25[P]VUT-FIT-IFJ2020/semantics.c
// Function: for_control
void for_control(TDLList *L, tBSTNodePtrLocal *node, functionData params){   
    TDLLSucc(L);
	// ak je prvy lexem bodkociarka
	if(L->Act->tdata.type == T_SEMICOLON){
		TDLLSucc(L); // chod za bodkociarku (ma byt identifikator alebo vyraz)
		// Skontroluj podmienku
		if_control(L, node, params);

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x1689
movq 0x8(%rbx), %rax
cmpl $0x1d, 0x8(%rax)
je 0x7367
leaq 0xf73(%rip), %r14       # 0x8297
leaq 0x515d(%rip), %r15      # 0xc488
movq (%rax), %rdi
movq %r14, %rsi
callq 0x1080
testl %eax, %eax
jne 0x7355
movq %r15, %rdi
callq 0x4694
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x706e
movq %rbx, %rdi
callq 0x1691
movq 0x8(%rbx), %rax
cmpl $0x1d, 0x8(%rax)
jne 0x732b
popq %rbx
popq %r14
popq %r15
retq