LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb $0x1, 0xd059(%rip)      # 0x103a8
movl 0xd07b(%rip), %eax      # 0x103d0
movl %eax, -0x24(%rbp)
subl $0x7, %eax
je 0x33be
jmp 0x335f
movl -0x24(%rbp), %eax
subl $0x13, %eax
jne 0x3403
jmp 0x336d
movq 0xcc64(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x10(%rbp)
movl %edx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0xd03a(%rip)      # 0x103c8
movq -0x8(%rbp), %rax
movq %rax, 0xd037(%rip)      # 0x103d0
movq 0xd028(%rip), %rsi      # 0x103c8
movl 0xd02a(%rip), %edx      # 0x103d0
leaq 0xd003(%rip), %rdi      # 0x103b0
callq 0x1450
callq 0x3e60
callq 0x3410
jmp 0x3403
movq 0xcc13(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x20(%rbp)
movl %edx, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, 0xcfe9(%rip)      # 0x103c8
movq -0x18(%rbp), %rax
movq %rax, 0xcfe6(%rip)      # 0x103d0
movq 0xcfd7(%rip), %rsi      # 0x103c8
movl 0xcfd9(%rip), %edx      # 0x103d0
leaq 0xcfb2(%rip), %rdi      # 0x103b0
callq 0x1450
movb $0x0, 0xcf9e(%rip)      # 0x103a8
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
cmpl $0x7, 0xcfb1(%rip)      # 0x103d0
jne 0x346b
movq 0xcbb0(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x10(%rbp)
movl %edx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0xcf86(%rip)      # 0x103c8
movq -0x8(%rbp), %rax
movq %rax, 0xcf83(%rip)      # 0x103d0
movq 0xcf74(%rip), %rsi      # 0x103c8
movl 0xcf76(%rip), %edx      # 0x103d0
leaq 0xcf4f(%rip), %rdi      # 0x103b0
callq 0x1450
jmp 0x3537
cmpl $0x5, 0xcf5e(%rip)      # 0x103d0
je 0x3487
movl $0x2, %edi
leaq 0xcf30(%rip), %rsi      # 0x103b0
callq 0x64e0
jmp 0x34cc
movq 0xcb4a(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x20(%rbp)
movl %edx, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, 0xcf20(%rip)      # 0x103c8
movq -0x18(%rbp), %rax
movq %rax, 0xcf1d(%rip)      # 0x103d0
movq 0xcf0e(%rip), %rsi      # 0x103c8
movl 0xcf10(%rip), %edx      # 0x103d0
leaq 0xcee9(%rip), %rdi      # 0x103b0
callq 0x1450
cmpl $0x13, 0xcefd(%rip)     # 0x103d0
je 0x34e8
movl $0x2, %edi
leaq 0xcecf(%rip), %rsi      # 0x103b0
callq 0x64e0
jmp 0x3537
movq 0xcae9(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x30(%rbp)
movl %edx, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq %rax, 0xcebf(%rip)      # 0x103c8
movq -0x28(%rbp), %rax
movq %rax, 0xcebc(%rip)      # 0x103d0
movq 0xcead(%rip), %rsi      # 0x103c8
movl 0xceaf(%rip), %edx      # 0x103d0
leaq 0xce88(%rip), %rdi      # 0x103b0
callq 0x1450
callq 0x3e60
callq 0x3410
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpl $0x7, 0xce81(%rip)      # 0x103d0
jne 0x359b
movq 0xca80(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x10(%rbp)
movl %edx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0xce56(%rip)      # 0x103c8
movq -0x8(%rbp), %rax
movq %rax, 0xce53(%rip)      # 0x103d0
movq 0xce44(%rip), %rsi      # 0x103c8
movl 0xce46(%rip), %edx      # 0x103d0
leaq 0xce1f(%rip), %rdi      # 0x103b0
callq 0x1450
jmp 0x3623
cmpl $0x13, 0xce2e(%rip)     # 0x103d0
je 0x35d9
cmpl $0x29, 0xce25(%rip)     # 0x103d0
je 0x35d9
cmpl $0x2b, 0xce1c(%rip)     # 0x103d0
je 0x35d9
cmpl $0x11, 0xce13(%rip)     # 0x103d0
je 0x35d9
cmpl $0x10, 0xce0a(%rip)     # 0x103d0
je 0x35d9
movl $0x2, %edi
leaq 0xcddc(%rip), %rsi      # 0x103b0
callq 0x64e0
movq 0xc9f8(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x20(%rbp)
movl %edx, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, 0xcdce(%rip)      # 0x103c8
movq -0x18(%rbp), %rax
movq %rax, 0xcdcb(%rip)      # 0x103d0
movq 0xcdbc(%rip), %rsi      # 0x103c8
movl 0xcdbe(%rip), %edx      # 0x103d0
leaq 0xcd97(%rip), %rdi      # 0x103b0
callq 0x1450
callq 0x3630
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpl $0x7, 0xcd91(%rip)      # 0x103d0
jne 0x3646
jmp 0x372d
cmpl $0x5, 0xcd83(%rip)      # 0x103d0
je 0x3660
movl $0x2, %edi
leaq 0xcd55(%rip), %rsi      # 0x103b0
callq 0x64e0
movq 0xc971(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x10(%rbp)
movl %edx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0xcd47(%rip)      # 0x103c8
movq -0x8(%rbp), %rax
movq %rax, 0xcd44(%rip)      # 0x103d0
movq 0xcd35(%rip), %rsi      # 0x103c8
movl 0xcd37(%rip), %edx      # 0x103d0
leaq 0xcd10(%rip), %rdi      # 0x103b0
callq 0x1450
cmpl $0x13, 0xcd24(%rip)     # 0x103d0
je 0x36e3
cmpl $0x29, 0xcd1b(%rip)     # 0x103d0
je 0x36e3
cmpl $0x2b, 0xcd12(%rip)     # 0x103d0
je 0x36e3
cmpl $0x11, 0xcd09(%rip)     # 0x103d0
je 0x36e3
cmpl $0x10, 0xcd00(%rip)     # 0x103d0
je 0x36e3
movl $0x2, %edi
leaq 0xccd2(%rip), %rsi      # 0x103b0
callq 0x64e0
movq 0xc8ee(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x20(%rbp)
movl %edx, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, 0xccc4(%rip)      # 0x103c8
movq -0x18(%rbp), %rax
movq %rax, 0xccc1(%rip)      # 0x103d0
movq 0xccb2(%rip), %rsi      # 0x103c8
movl 0xccb4(%rip), %edx      # 0x103d0
leaq 0xcc8d(%rip), %rdi      # 0x103b0
callq 0x1450
callq 0x3630
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0xcc82(%rip), %eax      # 0x103d0
movl %eax, -0x24(%rbp)
subl $0x3, %eax
je 0x3824
jmp 0x375c
movl -0x24(%rbp), %eax
subl $0x5, %eax
je 0x3777
jmp 0x3766
movl -0x24(%rbp), %eax
subl $0x32, %eax
je 0x3826
jmp 0x3828
movq 0xc85a(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x10(%rbp)
movl %edx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0xcc30(%rip)      # 0x103c8
movq -0x8(%rbp), %rax
movq %rax, 0xcc2d(%rip)      # 0x103d0
movq 0xcc1e(%rip), %rsi      # 0x103c8
movl 0xcc20(%rip), %edx      # 0x103d0
leaq 0xcbf9(%rip), %rdi      # 0x103b0
callq 0x1450
cmpl $0x13, 0xcc0d(%rip)     # 0x103d0
je 0x37d8
movl $0x2, %edi
leaq 0xcbdf(%rip), %rsi      # 0x103b0
callq 0x64e0
jmp 0x381d
movq 0xc7f9(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x20(%rbp)
movl %edx, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, 0xcbcf(%rip)      # 0x103c8
movq -0x18(%rbp), %rax
movq %rax, 0xcbcc(%rip)      # 0x103d0
movq 0xcbbd(%rip), %rsi      # 0x103c8
movl 0xcbbf(%rip), %edx      # 0x103d0
leaq 0xcb98(%rip), %rdi      # 0x103b0
callq 0x1450
callq 0x3740
jmp 0x3839
jmp 0x3839
jmp 0x3839
movl $0x2, %edi
leaq 0xcb7c(%rip), %rsi      # 0x103b0
callq 0x64e0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MartinNovotny25[P]VUT-FIT-IFJ2020/parser.c
// Function: rule_init_def
void rule_init_def() {
    switch (token.type) {
        case t_ASSIGN:
            token = get_next_token(stdin);
            TDLLInsertLast(&tokens, token);
            break;
        case t_DEFINITION_2:
            token = get_next_token(stdin);
            TDLLInsertLast(&tokens, token);
            break;
        default:
            error_call(ERR_SYN, &tokens);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0xc632(%rip), %eax      # 0x103d0
movl %eax, -0x24(%rbp)
subl $0x3, %eax
je 0x3db5
jmp 0x3da8
movl -0x24(%rbp), %eax
subl $0x32, %eax
je 0x3dfc
jmp 0x3e43
movq 0xc21c(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x10(%rbp)
movl %edx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0xc5f2(%rip)      # 0x103c8
movq -0x8(%rbp), %rax
movq %rax, 0xc5ef(%rip)      # 0x103d0
movq 0xc5e0(%rip), %rsi      # 0x103c8
movl 0xc5e2(%rip), %edx      # 0x103d0
leaq 0xc5bb(%rip), %rdi      # 0x103b0
callq 0x1450
jmp 0x3e54
movq 0xc1d5(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x20(%rbp)
movl %edx, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, 0xc5ab(%rip)      # 0x103c8
movq -0x18(%rbp), %rax
movq %rax, 0xc5a8(%rip)      # 0x103d0
movq 0xc599(%rip), %rsi      # 0x103c8
movl 0xc59b(%rip), %edx      # 0x103d0
leaq 0xc574(%rip), %rdi      # 0x103b0
callq 0x1450
jmp 0x3e54
movl $0x2, %edi
leaq 0xc561(%rip), %rsi      # 0x103b0
callq 0x64e0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MartinNovotny25[P]VUT-FIT-IFJ2020/parser.c
// Function: rule_return
void rule_return() {
    switch (token.type) {
        //ak príde token RETURN
        case t_RETURN:
            was_return = true; // nastavíme premennú výskytu RETURN na true
            token = get_next_token(stdin);
            TDLLInsertLast(&tokens, token);

            // Ak je prítomnost RETURN nutná -- definicia obsahuje návratové typy // PRAVIDLO REQUIRED RETURN
            if (is_return == true) {
                required_return();
                // Ak je prítomnosť RETURN nepovinná // PRAVIDLO OPTIONAL RETURN
            } else if (is_return == false) {
                optional_return();
            }
            break;

        default:
            error_call(ERR_SYN, &tokens);

    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0xc382(%rip), %eax      # 0x103d0
subl $0x19, %eax
jne 0x40d1
jmp 0x4055
movb $0x1, 0xc34e(%rip)      # 0x103aa
movq 0xbf75(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x10(%rbp)
movl %edx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0xc34b(%rip)      # 0x103c8
movq -0x8(%rbp), %rax
movq %rax, 0xc348(%rip)      # 0x103d0
movq 0xc339(%rip), %rsi      # 0x103c8
movl 0xc33b(%rip), %edx      # 0x103d0
leaq 0xc314(%rip), %rdi      # 0x103b0
callq 0x1450
movb 0xc302(%rip), %al       # 0x103a9
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x40b8
callq 0x4500
jmp 0x40cf
movb 0xc2eb(%rip), %al       # 0x103a9
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x40cd
callq 0x4480
jmp 0x40cf
jmp 0x40e2
movl $0x2, %edi
leaq 0xc2d3(%rip), %rsi      # 0x103b0
callq 0x64e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb $0x1, 0xc2a9(%rip)      # 0x103a8
movl 0xc2cb(%rip), %eax      # 0x103d0
movl %eax, -0x14(%rbp)
subl $0x5, %eax
je 0x4119
jmp 0x410f
movl -0x14(%rbp), %eax
subl $0x7, %eax
je 0x416a
jmp 0x416c
movq 0xbeb8(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x10(%rbp)
movl %edx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0xc28e(%rip)      # 0x103c8
movq -0x8(%rbp), %rax
movq %rax, 0xc28b(%rip)      # 0x103d0
movq 0xc27c(%rip), %rsi      # 0x103c8
movl 0xc27e(%rip), %edx      # 0x103d0
leaq 0xc257(%rip), %rdi      # 0x103b0
callq 0x1450
callq 0x3e60
callq 0x40f0
jmp 0x417d
jmp 0x417d
movl $0x2, %edi
leaq 0xc238(%rip), %rsi      # 0x103b0
callq 0x64e0
movb $0x0, 0xc224(%rip)      # 0x103a8
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x33, 0xbff1(%rip)     # 0x103d0
jne 0x43e6
jmp 0x446b
movq 0xbbeb(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x10(%rbp)
movl %edx, -0x8(%rbp)
movups -0x10(%rbp), %xmm0
movups %xmm0, 0xbfc1(%rip)     # 0x103c8
movq 0xbfba(%rip), %rsi      # 0x103c8
movl 0xbfbc(%rip), %edx      # 0x103d0
leaq 0xbf95(%rip), %rdi      # 0x103b0
callq 0x1450
movl 0xbfaa(%rip), %eax      # 0x103d0
subl $0x2f, %eax
jne 0x4434
jmp 0x442d
callq 0x43d0
jmp 0x446b
movb 0xbf71(%rip), %al       # 0x103ab
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4469
cmpl $0x1c, 0xbf85(%rip)     # 0x103d0
je 0x4467
cmpl $0x1d, 0xbf7c(%rip)     # 0x103d0
je 0x4467
movl $0x2, %edi
leaq 0xbf4e(%rip), %rsi      # 0x103b0
callq 0x64e0
jmp 0x4469
jmp 0x446b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x2f, 0xbf41(%rip)     # 0x103d0
je 0x44a4
movl $0x6, %edi
leaq 0xbf13(%rip), %rsi      # 0x103b0
callq 0x64e0
jmp 0x44e9
movq 0xbb2d(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x10(%rbp)
movl %edx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0xbf03(%rip)      # 0x103c8
movq -0x8(%rbp), %rax
movq %rax, 0xbf00(%rip)      # 0x103d0
movq 0xbef1(%rip), %rsi      # 0x103c8
movl 0xbef3(%rip), %edx      # 0x103d0
leaq 0xbecc(%rip), %rdi      # 0x103b0
callq 0x1450
cmpl $0x2f, 0xbee0(%rip)     # 0x103d0
jne 0x44f7
callq 0x43d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10d0
movb %al, 0xbd49(%rip)       # 0x10474
movb 0xbd43(%rip), %dl       # 0x10474
movslq 0xbccc(%rip), %rcx      # 0x10404
leaq 0xbcd1(%rip), %rax      # 0x10410
movb %dl, (%rax,%rcx)
movl 0xbcbc(%rip), %eax      # 0x10404
addl $0x1, %eax
movl %eax, 0xbcb3(%rip)      # 0x10404
movslq 0xbcac(%rip), %rcx      # 0x10404
leaq 0xbcb1(%rip), %rax      # 0x10410
movb $0x0, (%rax,%rcx)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl 0xbbff(%rip), %edi      # 0x10404
addl $0x1, %edi
movq -0x10(%rbp), %rsi
callq 0x47c0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0xbbf1(%rip), %rsi      # 0x10410
callq 0x1040
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
callq 0x46f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6793
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x1070
cmpl $0x0, %eax
jge 0x6743
movq -0x10(%rbp), %rax
movq 0x1010(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x66f0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x6797
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x1070
cmpl $0x0, %eax
jle 0x6777
movq -0x10(%rbp), %rax
movq 0x1018(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x66f0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x6797
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movl $0x1008, %edx           # imm = 0x1008
callq 0x1090
movb $0x1, -0x1(%rbp)
jmp 0x6797
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x1040, %rsp           # imm = 0x1040
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x6839
movl $0x1020, %edi           # imm = 0x1020
callq 0x10a0
movq -0x18(%rbp), %rsi
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
movl $0x1008, %edx           # imm = 0x1008
callq 0x1090
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x1010(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x1018(%rax)
jmp 0x6911
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
callq 0x1070
cmpl $0x0, %eax
jne 0x686f
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
movl $0x1008, %edx           # imm = 0x1008
callq 0x1090
jmp 0x690f
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
callq 0x1070
cmpl $0x0, %eax
jge 0x68be
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0x1010, %rax           # imm = 0x1010
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rsp, %rdi
movl $0x201, %ecx            # imm = 0x201
rep  movsq (%rsi), %es:(%rdi)
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0x67b0
jmp 0x690d
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
callq 0x1070
cmpl $0x0, %eax
jle 0x690b
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0x1018, %rax           # imm = 0x1018
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rsp, %rdi
movl $0x201, %ecx            # imm = 0x201
rep  movsq (%rsi), %es:(%rdi)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x67b0
jmp 0x690d
jmp 0x690f
jmp 0x6911
addq $0x1040, %rsp           # imm = 0x1040
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6973
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x1010, %rdi           # imm = 0x1010
callq 0x6920
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x1018, %rdi           # imm = 0x1018
callq 0x6920
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6a4a
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6a4a
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x1070
cmpl $0x0, %eax
jge 0x6a02
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x69a0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x6a4e
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x1070
cmpl $0x0, %eax
jle 0x6a37
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x69a0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x6a4e
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x6a4e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x6ae6
movl $0x28, %edi
callq 0x10a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0x6b70
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
callq 0x1070
cmpl $0x0, %eax
jne 0x6b00
jmp 0x6b6e
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
callq 0x1070
cmpl $0x0, %eax
jge 0x6b36
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x6a60
jmp 0x6b6c
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
callq 0x1070
cmpl $0x0, %eax
jle 0x6b6a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x6a60
jmp 0x6b6c
jmp 0x6b6e
jmp 0x6b70
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6c0f
cmpq $0x0, -0x8(%rbp)
je 0x6c0f
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0x6bc5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x20, %rsi
callq 0x6b80
jmp 0x6c0d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
callq 0x6c20
jmp 0x6c11
jmp 0x6c11
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6d87
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jbe 0x6c67
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
callq 0x6c20
jmp 0x6d85
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jae 0x6c90
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
callq 0x6c20
jmp 0x6d83
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x6d81
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x6cdc
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0x6cdc
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
addq $0x18, %rsi
callq 0x6b80
jmp 0x6d7f
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x6d20
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x20(%rax)
jne 0x6d20
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x6d7d
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0x6d64
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
jne 0x6d64
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x6d7b
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
jmp 0x6d7d
jmp 0x6d7f
jmp 0x6d81
jmp 0x6d83
jmp 0x6d85
jmp 0x6d89
jmp 0x6d89
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6ddd
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
callq 0x6d90
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x20, %rdi
callq 0x6d90
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MartinNovotny25[P]VUT-FIT-IFJ2020/symtable.c
// Function: PushTreeMain
void PushTreeMain (MainStack *S, tBSTNodePtrLocal *ptrLocal)
{

    
  if (S->top==MAXSTACK)
   printf("Chyba: Došlo k přetečení zásobníku s ukazateli!\n");
  else {
		S->top++;
		S->a[S->top]=ptrLocal;
		//printf("top %d\n", S->top);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x3e8, (%rax)          # imm = 0x3E8
jne 0x6e3c
leaq 0x6648(%rip), %rdi      # 0xd47b
movb $0x0, %al
callq 0x1060
jmp 0x6e5b
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
movq %rdx, 0x8(%rax,%rcx,8)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x6f33
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rcx
leaq -0x20(%rbp), %rdx
callq 0x69a0
testb $0x1, %al
jne 0x6f19
jmp 0x6f28
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x6f37
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6eec
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MartinNovotny25[P]VUT-FIT-IFJ2020/semantics.c
// Function: isLiteral
bool isLiteral(TDLList *L, int *type) {
    if ((L->Act->tdata.type == t_INT_ZERO) || (L->Act->tdata.type == t_INT_NON_ZERO) ||
        (L->Act->tdata.type == t_STRING) || (L->Act->tdata.type == t_FLOAT)) {
        switch (L->Act->tdata.type) {
            case t_INT_ZERO:
                *type = t_INT_ID;
                TDLLSucc(L);
                return true;
                break;
                
            case t_INT_NON_ZERO:
                *type = t_INT_ID;
                TDLLSucc(L);
                return true;
                break;
            
            case t_STRING:
                *type = t_STRING_ID;
                TDLLSucc(L);
                return true;
                break;
                
            case t_FLOAT:
                *type = t_FLOAT64;
                TDLLSucc(L);
                return true;
                break;

            default:
                break;
        }
    } else {
        return false;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x10, 0x8(%rax)
je 0x714c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x11, 0x8(%rax)
je 0x714c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x2b, 0x8(%rax)
je 0x714c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x29, 0x8(%rax)
jne 0x71e1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %eax
addl $-0x10, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x1b, %eax
ja 0x71dd
movq -0x20(%rbp), %rax
leaq 0x6344(%rip), %rcx      # 0xd4b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movl $0x18, (%rax)
movq -0x10(%rbp), %rdi
callq 0x12e0
movb $0x1, -0x1(%rbp)
jmp 0x71eb
movq -0x18(%rbp), %rax
movl $0x18, (%rax)
movq -0x10(%rbp), %rdi
callq 0x12e0
movb $0x1, -0x1(%rbp)
jmp 0x71eb
movq -0x18(%rbp), %rax
movl $0x14, (%rax)
movq -0x10(%rbp), %rdi
callq 0x12e0
movb $0x1, -0x1(%rbp)
jmp 0x71eb
movq -0x18(%rbp), %rax
movl $0x17, (%rax)
movq -0x10(%rbp), %rdi
callq 0x12e0
movb $0x1, -0x1(%rbp)
jmp 0x71eb
jmp 0x71df
jmp 0x71e7
movb $0x0, -0x1(%rbp)
jmp 0x71eb
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12c0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x1d, 0x8(%rax)
je 0xb8ee
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
leaq 0x1a2a(%rip), %rsi      # 0xd2df
callq 0x1070
cmpl $0x0, %eax
jne 0xb8e3
leaq 0x4bc2(%rip), %rdi      # 0x10488
callq 0x6df0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq (%rax), %rsi
callq 0xb4e0
movq -0x8(%rbp), %rdi
callq 0x12e0
jmp 0xb895
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MartinNovotny25[P]VUT-FIT-IFJ2020/semantics.c
// Function: paramsRedefinitionCheck
void paramsRedefinitionCheck(functionData data, TDLList *L) {
    if (data.numOfParams == 0) {
        return;
    }
    for (int i = 0; i < data.numOfParams; i++) {
        for (int j = 0; j < data.numOfParams; j++) {
            //porovname parameter sameho so sebou, tento krok treba preskocit
            if (i == j) {
                continue;
            }
            //id parametrov sa rovnaju, volaj error
            if (!strcmp(data.params[i], data.params[j])) {
                BSTDisposeGlobal(&functions);
                error_call(ERR_SEM_UNDEF, L);
                return;
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
cmpl $0x0, (%rax)
jne 0xbcde
jmp 0xbd62
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jge 0xbd62
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl (%rcx), %eax
jge 0xbd55
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jne 0xbd0c
jmp 0xbd4a
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rdi
movslq -0x10(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rsi
callq 0x1070
cmpl $0x0, %eax
jne 0xbd48
leaq 0x669d(%rip), %rdi      # 0x123d0
callq 0x6920
movq -0x8(%rbp), %rsi
movl $0x3, %edi
callq 0x64e0
jmp 0xbd62
jmp 0xbd4a
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xbcf7
jmp 0xbd57
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xbce5
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x625d(%rip), %rdi      # 0x123d0
callq 0x66d0
callq 0xb900
movq -0x8(%rbp), %rdi
callq 0x12c0
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x1d, 0x8(%rax)
je 0xc203
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
leaq 0x112b(%rip), %rsi      # 0xd2df
callq 0x1070
cmpl $0x0, %eax
jne 0xc1d0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbf60
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x18(%rax)
jne 0xc1ef
movq -0x8(%rbp), %rsi
movl $0x63, %edi
callq 0x64e0
jmp 0xc243
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12e0
jmp 0xc194
testb $0x1, 0x4276(%rip)      # 0x10480
jne 0xc21c
movq -0x8(%rbp), %rsi
movl $0x3, %edi
callq 0x64e0
jmp 0xc243
movq -0x8(%rbp), %rdi
callq 0x12c0
movq -0x8(%rbp), %rdi
callq 0xb880
movq -0x8(%rbp), %rdi
callq 0x1340
leaq 0x6192(%rip), %rdi      # 0x123d0
callq 0x6920
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x10, %edi
callq 0x10a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xc296
jmp 0xc2b9
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xc2ff
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x1030
movb $0x1, -0x1(%rbp)
jmp 0xc303
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MartinNovotny25[P]VUT-FIT-IFJ2020/precanalysis_stack.c
// Function: symstack_top_t
tsym_stack_symbol* symstack_top_t(tsym_stack* sym_stack)
{

    tsym_stack_symbol* stack_sym = sym_stack->top;
    while (stack_sym != NULL) {

        if (stack_sym->symbol != T_RED && stack_sym->symbol != T_NON_TERM) {
            return stack_sym;
        }

        stack_sym = stack_sym->next;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xc354
movq -0x18(%rbp), %rax
cmpl $0xe, (%rax)
je 0xc346
movq -0x18(%rbp), %rax
cmpl $0xf, (%rax)
je 0xc346
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc35c
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xc323
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xc420
movq -0x20(%rbp), %rax
cmpl $0xe, (%rax)
je 0xc407
movq -0x20(%rbp), %rax
cmpl $0xf, (%rax)
je 0xc407
movl $0x10, %edi
callq 0x10a0
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x18(%rbp)
jne 0xc3e9
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0xc405
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xc420
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xc392
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)