// File: /workspace/github_c_makefile_star2_O0/MartinNovotny25[P]VUT-FIT-IFJ2020/parser.c
// Function: rule_stat
void rule_stat() {
    //switch podla typu tokenu
    switch (token.type) {
        // <stat> -> id ID_N/CALL_FUNC -- ak pride id
        // ak príde ID, môže sa jednat buď o volanie funkcie bez návratových hodnôt (napr. PRINT), alebo môže ísť o priradenie/definíciu
        // voláme rule_id_n_or_call_func na rozhonutie
        case t_IDENTIFIER:
            token = get_next_token(stdin);
            TDLLInsertLast(&tokens, token);
            rule_id_n_or_call_func();

            break;

            // ak príde IF
        case t_IF:
            token = get_next_token(stdin);
            TDLLInsertLast(&tokens, token);

            // If bez vyrazu
            if (token.type == t_BRACES_L) {error_call(ERR_SYN, &tokens);}

            //Nacitavanie tokenov vyrazu do listu -- PSA
            TDLLInitList(&psa_list);

             while (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);}


            }
            // TU SA ZAVOLA PRECEDENCNA S NAPLNENYM LISTOM
            evaluation(&psa_list, &tokens);
             TDLLDisposeList(&psa_list);

            // Otváracia množinová zátvorka pre telo IFu
            if (token.type != t_BRACES_L) {
                error_call(ERR_SYN, &tokens);
            }
            else {
                global_brace_count++;
                token = get_next_token(stdin);
                TDLLInsertLast(&tokens, token);
            }

            //Vynútenie eolu 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); }

            // Dalsie optional EOLy
            if (token.type == t_EOL) {
                rule_eol();
            }

            //rekurzivne volanie stat v tele stat if -- dalsi token sa nacita v rule_eol

            rule_stat();

            // Dalsie optional EOLy
            if (token.type == t_EOL) {
                rule_eol();
            }

            // Ukoncovacia množinová zátvorka tela IFu
            if (token.type != t_BRACES_R) {
                error_call(ERR_SYN, &tokens);
            }
            else {
                global_brace_count--;
                token = get_next_token(stdin);
                TDLLInsertLast(&tokens, token);
            }

            //ELSE statement

            // token ELSE
            if (token.type != t_ELSE) { error_call(ERR_SYN, &tokens); }
            else { token = get_next_token(stdin); TDLLInsertLast(&tokens, token); }


            //Otváracia množinová zátvorka tela bloku ELSE
            if (token.type != t_BRACES_L) {
                error_call(ERR_SYN, &tokens);
            }
            else {
                global_brace_count++;
                token = get_next_token(stdin);
                TDLLInsertLast(&tokens, token);
            }

            //Vynútenie EOlu po otváracej zátvorke
            if (token.type != t_EOL) { error_call(ERR_SYN, &tokens); }
            else { token = get_next_token(stdin); TDLLInsertLast(&tokens, token); }

            // Dalsie optional EOLy
            if (token.type == t_EOL) {
                rule_eol();
            }

            //rekurzivne volanie stat v else vetve
            rule_stat();

            // Dalsie optional EOLy
            if (token.type == t_EOL) {
                rule_eol();
            }

            // ukoncovacia mnozinová zátvorka na konci tela bloku ELSE
            if (token.type != t_BRACES_R) { error_call(ERR_SYN, &tokens); }
            else {
                global_brace_count--;
                token = get_next_token(stdin);
                TDLLInsertLast(&tokens, token);
            }

            // Vynútenie EOLu za zatvorkou
            if (token.type != t_EOL) {
                error_call(ERR_SYN, &tokens);
            }
            else { token = get_next_token(stdin); TDLLInsertLast(&tokens, token); }

            // Dalsie optional EOLy
            if (token.type == t_EOL) {
                rule_eol();
            }

            //volanie stat po skonceni if  pre dalsie možné príkazy v tele funkie
            rule_stat();
            break;

         // token FOR
        case t_FOR:
            token = get_next_token(stdin);
            TDLLInsertLast(&tokens, token);


            //rule for_def, ktoré skontroluje definíciu LOKALNEJ ITERACNEJ PREMENNEJ
            //Bodkociarka sa kontroluje v pravidle
            rule_for_def();

            TDLLInitList(&psa_list);

            //for bez výrazu
            if (token.type == T_SEMICOLON) {error_call(ERR_SYN, &tokens);}

            while (token.type != T_SEMICOLON)
            {
                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);
            token = get_next_token(stdin); TDLLInsertLast(&tokens, token);



            // Pravidlo for_assign pre priradenie hodnoty premennej po vykonaní FOR cyklu
            //bodkociarka sa kontroluje v pravidle
            rule_for_assign();

            // token otváracej množinovej zátvorky tela for cyklu
            if (token.type != t_BRACES_L) { error_call(ERR_SYN, &tokens); }
            else { token = get_next_token(stdin); TDLLInsertLast(&tokens, token); }

            // Vynútenie eolu po zatvorke
            if (token.type != t_EOL) { error_call(ERR_SYN, &tokens); }
            else { token = get_next_token(stdin); TDLLInsertLast(&tokens, token); }

            // Dalsie optional EOLy
            if (token.type == t_EOL) {
                rule_eol();
            }

            //rekurzivne volanie stat v tele for cyklu

            rule_stat();

            // Dalsie optional EOLy
            if (token.type == t_EOL) {
                rule_eol();
            }

            // token ukončovacej zátvorky tela for cyklu
            if (token.type != t_BRACES_R) { error_call(ERR_SYN, &tokens); }
            else { token = get_next_token(stdin); TDLLInsertLast(&tokens, token); }

            // Vynútenie EOLu po ukončovacej zátvorke
            if (token.type != t_EOL) { error_call(ERR_SYN, &tokens); }
            else { token = get_next_token(stdin); TDLLInsertLast(&tokens, token); }

            // Dalsie optional EOLy
            if (token.type == t_EOL) {
                rule_eol();
            }

            // Volanie pravidla stat po vykonaní príkazu FOR
            rule_stat();
            break;

        // Prípad, kedy stat príde EOL -- nepovinný eol medzi príkazmy (STATEMENTAMI)
        case t_EOL:
            token = get_next_token(stdin);
            TDLLInsertLast(&tokens, token);
            rule_stat();
            break;

            //ak po stat nebude nič a skonči sa blok
        case t_BRACES_R:
            break;

        // Ak príde return -- pokracujeme do rule_return a za tym rule_stat
        // TU POZOR -- Syntakticky môže byt return hocikde v kóde, nie je to chyba, avšak parser bude dalej parsovat kód.
        // Generator by ASI mal vediet jak s tym naložiť
        case t_RETURN:
            rule_return();
            rule_stat();
            break;
         // Pride hocico ine - ERROR
        default:
            error_call(ERR_SYN, &tokens);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movl 0xe13f(%rip), %eax      # 0x103d0
addl $-0x13, %eax
movl %eax, %ecx
movq %rcx, -0x138(%rbp)
subl $0x20, %eax
ja 0x2cef
movq -0x138(%rbp), %rax
leaq 0xae20(%rip), %rcx      # 0xd0d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0xdd14(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x10(%rbp)
movl %edx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0xe0ea(%rip)      # 0x103c8
movq -0x8(%rbp), %rax
movq %rax, 0xe0e7(%rip)      # 0x103d0
movq 0xe0d8(%rip), %rsi      # 0x103c8
movl 0xe0da(%rip), %edx      # 0x103d0
leaq 0xe0b3(%rip), %rdi      # 0x103b0
callq 0x1450
callq 0x2d10
jmp 0x2d00
movq 0xdcc5(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x20(%rbp)
movl %edx, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, 0xe09b(%rip)      # 0x103c8
movq -0x18(%rbp), %rax
movq %rax, 0xe098(%rip)      # 0x103d0
movq 0xe089(%rip), %rsi      # 0x103c8
movl 0xe08b(%rip), %edx      # 0x103d0
leaq 0xe064(%rip), %rdi      # 0x103b0
callq 0x1450
cmpl $0x34, 0xe078(%rip)     # 0x103d0
jne 0x236b
movl $0x2, %edi
leaq 0xe04a(%rip), %rsi      # 0x103b0
callq 0x64e0
leaq 0xe066(%rip), %rdi      # 0x103d8
callq 0x1310
cmpl $0x34, 0xe052(%rip)     # 0x103d0
je 0x249b
cmpl $0xa, 0xe045(%rip)      # 0x103d0
je 0x2425
cmpl $0xb, 0xe038(%rip)      # 0x103d0
je 0x2425
cmpl $0x8, 0xe02b(%rip)      # 0x103d0
je 0x2425
cmpl $0x9, 0xe022(%rip)      # 0x103d0
je 0x2425
cmpl $0x7, 0xe019(%rip)      # 0x103d0
je 0x2425
cmpl $0x6, 0xe010(%rip)      # 0x103d0
je 0x2425
cmpl $0x1, 0xe007(%rip)      # 0x103d0
je 0x2425
cmpl $0x1e, 0xdffe(%rip)     # 0x103d0
je 0x2425
cmpl $0x2, 0xdff5(%rip)      # 0x103d0
je 0x2425
cmpl $0x1f, 0xdfec(%rip)     # 0x103d0
je 0x2425
cmpl $0x20, 0xdfe3(%rip)     # 0x103d0
je 0x2425
cmpl $0x21, 0xdfda(%rip)     # 0x103d0
je 0x2425
cmpl $0x13, 0xdfd1(%rip)     # 0x103d0
je 0x2425
cmpl $0x29, 0xdfc8(%rip)     # 0x103d0
je 0x2425
cmpl $0x11, 0xdfbf(%rip)     # 0x103d0
je 0x2425
cmpl $0x10, 0xdfb6(%rip)     # 0x103d0
je 0x2425
cmpl $0x2b, 0xdfad(%rip)     # 0x103d0
jne 0x2485
movq 0xdf9c(%rip), %rsi      # 0x103c8
movl 0xdf9e(%rip), %edx      # 0x103d0
leaq 0xdf9f(%rip), %rdi      # 0x103d8
callq 0x1450
movq 0xdb93(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x30(%rbp)
movl %edx, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq %rax, 0xdf69(%rip)      # 0x103c8
movq -0x28(%rbp), %rax
movq %rax, 0xdf66(%rip)      # 0x103d0
movq 0xdf57(%rip), %rsi      # 0x103c8
movl 0xdf59(%rip), %edx      # 0x103d0
leaq 0xdf32(%rip), %rdi      # 0x103b0
callq 0x1450
jmp 0x2496
movl $0x2, %edi
leaq 0xdf1f(%rip), %rsi      # 0x103b0
callq 0x64e0
jmp 0x2377
leaq 0xdf36(%rip), %rdi      # 0x103d8
leaq 0xdf07(%rip), %rsi      # 0x103b0
callq 0xc860
leaq 0xdf23(%rip), %rdi      # 0x103d8
callq 0x1340
cmpl $0x34, 0xdf0f(%rip)     # 0x103d0
je 0x24d6
movl $0x2, %edi
leaq 0xdee1(%rip), %rsi      # 0x103b0
callq 0x64e0
jmp 0x252a
movl 0xded0(%rip), %eax      # 0x103ac
addl $0x1, %eax
movl %eax, 0xdec7(%rip)      # 0x103ac
movq 0xdaec(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x40(%rbp)
movl %edx, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, 0xdec2(%rip)      # 0x103c8
movq -0x38(%rbp), %rax
movq %rax, 0xdebf(%rip)      # 0x103d0
movq 0xdeb0(%rip), %rsi      # 0x103c8
movl 0xdeb2(%rip), %edx      # 0x103d0
leaq 0xde8b(%rip), %rdi      # 0x103b0
callq 0x1450
cmpl $0x2f, 0xde9f(%rip)     # 0x103d0
je 0x2546
movl $0x2, %edi
leaq 0xde71(%rip), %rsi      # 0x103b0
callq 0x64e0
jmp 0x258b
movq 0xda8b(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x50(%rbp)
movl %edx, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, 0xde61(%rip)      # 0x103c8
movq -0x48(%rbp), %rax
movq %rax, 0xde5e(%rip)      # 0x103d0
movq 0xde4f(%rip), %rsi      # 0x103c8
movl 0xde51(%rip), %edx      # 0x103d0
leaq 0xde2a(%rip), %rdi      # 0x103b0
callq 0x1450
cmpl $0x2f, 0xde3e(%rip)     # 0x103d0
jne 0x2599
callq 0x43d0
callq 0x2280
cmpl $0x2f, 0xde2b(%rip)     # 0x103d0
jne 0x25ac
callq 0x43d0
cmpl $0x33, 0xde1d(%rip)     # 0x103d0
je 0x25c8
movl $0x2, %edi
leaq 0xddef(%rip), %rsi      # 0x103b0
callq 0x64e0
jmp 0x261c
movl 0xddde(%rip), %eax      # 0x103ac
addl $-0x1, %eax
movl %eax, 0xddd5(%rip)      # 0x103ac
movq 0xd9fa(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x60(%rbp)
movl %edx, -0x58(%rbp)
movq -0x60(%rbp), %rax
movq %rax, 0xddd0(%rip)      # 0x103c8
movq -0x58(%rbp), %rax
movq %rax, 0xddcd(%rip)      # 0x103d0
movq 0xddbe(%rip), %rsi      # 0x103c8
movl 0xddc0(%rip), %edx      # 0x103d0
leaq 0xdd99(%rip), %rdi      # 0x103b0
callq 0x1450
cmpl $0x15, 0xddad(%rip)     # 0x103d0
je 0x2638
movl $0x2, %edi
leaq 0xdd7f(%rip), %rsi      # 0x103b0
callq 0x64e0
jmp 0x267d
movq 0xd999(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x70(%rbp)
movl %edx, -0x68(%rbp)
movq -0x70(%rbp), %rax
movq %rax, 0xdd6f(%rip)      # 0x103c8
movq -0x68(%rbp), %rax
movq %rax, 0xdd6c(%rip)      # 0x103d0
movq 0xdd5d(%rip), %rsi      # 0x103c8
movl 0xdd5f(%rip), %edx      # 0x103d0
leaq 0xdd38(%rip), %rdi      # 0x103b0
callq 0x1450
cmpl $0x34, 0xdd4c(%rip)     # 0x103d0
je 0x2699
movl $0x2, %edi
leaq 0xdd1e(%rip), %rsi      # 0x103b0
callq 0x64e0
jmp 0x26ed
movl 0xdd0d(%rip), %eax      # 0x103ac
addl $0x1, %eax
movl %eax, 0xdd04(%rip)      # 0x103ac
movq 0xd929(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x80(%rbp)
movl %edx, -0x78(%rbp)
movq -0x80(%rbp), %rax
movq %rax, 0xdcff(%rip)      # 0x103c8
movq -0x78(%rbp), %rax
movq %rax, 0xdcfc(%rip)      # 0x103d0
movq 0xdced(%rip), %rsi      # 0x103c8
movl 0xdcef(%rip), %edx      # 0x103d0
leaq 0xdcc8(%rip), %rdi      # 0x103b0
callq 0x1450
cmpl $0x2f, 0xdcdc(%rip)     # 0x103d0
je 0x2709
movl $0x2, %edi
leaq 0xdcae(%rip), %rsi      # 0x103b0
callq 0x64e0
jmp 0x275a
movq 0xd8c8(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x90(%rbp)
movl %edx, -0x88(%rbp)
movq -0x90(%rbp), %rax
movq %rax, 0xdc95(%rip)      # 0x103c8
movq -0x88(%rbp), %rax
movq %rax, 0xdc8f(%rip)      # 0x103d0
movq 0xdc80(%rip), %rsi      # 0x103c8
movl 0xdc82(%rip), %edx      # 0x103d0
leaq 0xdc5b(%rip), %rdi      # 0x103b0
callq 0x1450
cmpl $0x2f, 0xdc6f(%rip)     # 0x103d0
jne 0x2768
callq 0x43d0
callq 0x2280
cmpl $0x2f, 0xdc5c(%rip)     # 0x103d0
jne 0x277b
callq 0x43d0
cmpl $0x33, 0xdc4e(%rip)     # 0x103d0
je 0x2797
movl $0x2, %edi
leaq 0xdc20(%rip), %rsi      # 0x103b0
callq 0x64e0
jmp 0x27f7
movl 0xdc0f(%rip), %eax      # 0x103ac
addl $-0x1, %eax
movl %eax, 0xdc06(%rip)      # 0x103ac
movq 0xd82b(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0xa0(%rbp)
movl %edx, -0x98(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, 0xdbf8(%rip)      # 0x103c8
movq -0x98(%rbp), %rax
movq %rax, 0xdbf2(%rip)      # 0x103d0
movq 0xdbe3(%rip), %rsi      # 0x103c8
movl 0xdbe5(%rip), %edx      # 0x103d0
leaq 0xdbbe(%rip), %rdi      # 0x103b0
callq 0x1450
cmpl $0x2f, 0xdbd2(%rip)     # 0x103d0
je 0x2813
movl $0x2, %edi
leaq 0xdba4(%rip), %rsi      # 0x103b0
callq 0x64e0
jmp 0x2864
movq 0xd7be(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0xb0(%rbp)
movl %edx, -0xa8(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, 0xdb8b(%rip)      # 0x103c8
movq -0xa8(%rbp), %rax
movq %rax, 0xdb85(%rip)      # 0x103d0
movq 0xdb76(%rip), %rsi      # 0x103c8
movl 0xdb78(%rip), %edx      # 0x103d0
leaq 0xdb51(%rip), %rdi      # 0x103b0
callq 0x1450
cmpl $0x2f, 0xdb65(%rip)     # 0x103d0
jne 0x2872
callq 0x43d0
callq 0x2280
jmp 0x2d00
movq 0xd755(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0xc0(%rbp)
movl %edx, -0xb8(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, 0xdb22(%rip)      # 0x103c8
movq -0xb8(%rbp), %rax
movq %rax, 0xdb1c(%rip)      # 0x103d0
movq 0xdb0d(%rip), %rsi      # 0x103c8
movl 0xdb0f(%rip), %edx      # 0x103d0
leaq 0xdae8(%rip), %rdi      # 0x103b0
callq 0x1450
callq 0x3840
leaq 0xdaff(%rip), %rdi      # 0x103d8
callq 0x1310
cmpl $0x38, 0xdaeb(%rip)     # 0x103d0
jne 0x28f8
movl $0x2, %edi
leaq 0xdabd(%rip), %rsi      # 0x103b0
callq 0x64e0
jmp 0x28fa
cmpl $0x38, 0xdacf(%rip)     # 0x103d0
je 0x2a2a
cmpl $0xa, 0xdac2(%rip)      # 0x103d0
je 0x29a8
cmpl $0xb, 0xdab5(%rip)      # 0x103d0
je 0x29a8
cmpl $0x8, 0xdaa8(%rip)      # 0x103d0
je 0x29a8
cmpl $0x9, 0xda9f(%rip)      # 0x103d0
je 0x29a8
cmpl $0x7, 0xda96(%rip)      # 0x103d0
je 0x29a8
cmpl $0x6, 0xda8d(%rip)      # 0x103d0
je 0x29a8
cmpl $0x1, 0xda84(%rip)      # 0x103d0
je 0x29a8
cmpl $0x1e, 0xda7b(%rip)     # 0x103d0
je 0x29a8
cmpl $0x2, 0xda72(%rip)      # 0x103d0
je 0x29a8
cmpl $0x1f, 0xda69(%rip)     # 0x103d0
je 0x29a8
cmpl $0x20, 0xda60(%rip)     # 0x103d0
je 0x29a8
cmpl $0x21, 0xda57(%rip)     # 0x103d0
je 0x29a8
cmpl $0x13, 0xda4e(%rip)     # 0x103d0
je 0x29a8
cmpl $0x29, 0xda45(%rip)     # 0x103d0
je 0x29a8
cmpl $0x11, 0xda3c(%rip)     # 0x103d0
je 0x29a8
cmpl $0x10, 0xda33(%rip)     # 0x103d0
je 0x29a8
cmpl $0x2b, 0xda2a(%rip)     # 0x103d0
jne 0x2a14
movq 0xda19(%rip), %rsi      # 0x103c8
movl 0xda1b(%rip), %edx      # 0x103d0
leaq 0xda1c(%rip), %rdi      # 0x103d8
callq 0x1450
movq 0xd610(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0xd0(%rbp)
movl %edx, -0xc8(%rbp)
movq -0xd0(%rbp), %rax
movq %rax, 0xd9dd(%rip)      # 0x103c8
movq -0xc8(%rbp), %rax
movq %rax, 0xd9d7(%rip)      # 0x103d0
movq 0xd9c8(%rip), %rsi      # 0x103c8
movl 0xd9ca(%rip), %edx      # 0x103d0
leaq 0xd9a3(%rip), %rdi      # 0x103b0
callq 0x1450
jmp 0x2a25
movl $0x2, %edi
leaq 0xd990(%rip), %rsi      # 0x103b0
callq 0x64e0
jmp 0x28fa
leaq 0xd9a7(%rip), %rdi      # 0x103d8
leaq 0xd978(%rip), %rsi      # 0x103b0
callq 0xc860
leaq 0xd994(%rip), %rdi      # 0x103d8
callq 0x1340
movq 0xd588(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0xe0(%rbp)
movl %edx, -0xd8(%rbp)
movq -0xe0(%rbp), %rax
movq %rax, 0xd955(%rip)      # 0x103c8
movq -0xd8(%rbp), %rax
movq %rax, 0xd94f(%rip)      # 0x103d0
movq 0xd940(%rip), %rsi      # 0x103c8
movl 0xd942(%rip), %edx      # 0x103d0
leaq 0xd91b(%rip), %rdi      # 0x103b0
callq 0x1450
callq 0x3b10
cmpl $0x34, 0xd92a(%rip)     # 0x103d0
je 0x2abb
movl $0x2, %edi
leaq 0xd8fc(%rip), %rsi      # 0x103b0
callq 0x64e0
jmp 0x2b0c
movq 0xd516(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0xf0(%rbp)
movl %edx, -0xe8(%rbp)
movq -0xf0(%rbp), %rax
movq %rax, 0xd8e3(%rip)      # 0x103c8
movq -0xe8(%rbp), %rax
movq %rax, 0xd8dd(%rip)      # 0x103d0
movq 0xd8ce(%rip), %rsi      # 0x103c8
movl 0xd8d0(%rip), %edx      # 0x103d0
leaq 0xd8a9(%rip), %rdi      # 0x103b0
callq 0x1450
cmpl $0x2f, 0xd8bd(%rip)     # 0x103d0
je 0x2b28
movl $0x2, %edi
leaq 0xd88f(%rip), %rsi      # 0x103b0
callq 0x64e0
jmp 0x2b79
movq 0xd4a9(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x100(%rbp)
movl %edx, -0xf8(%rbp)
movq -0x100(%rbp), %rax
movq %rax, 0xd876(%rip)      # 0x103c8
movq -0xf8(%rbp), %rax
movq %rax, 0xd870(%rip)      # 0x103d0
movq 0xd861(%rip), %rsi      # 0x103c8
movl 0xd863(%rip), %edx      # 0x103d0
leaq 0xd83c(%rip), %rdi      # 0x103b0
callq 0x1450
cmpl $0x2f, 0xd850(%rip)     # 0x103d0
jne 0x2b87
callq 0x43d0
callq 0x2280
cmpl $0x2f, 0xd83d(%rip)     # 0x103d0
jne 0x2b9a
callq 0x43d0
cmpl $0x33, 0xd82f(%rip)     # 0x103d0
je 0x2bb6
movl $0x2, %edi
leaq 0xd801(%rip), %rsi      # 0x103b0
callq 0x64e0
jmp 0x2c07
movq 0xd41b(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x110(%rbp)
movl %edx, -0x108(%rbp)
movq -0x110(%rbp), %rax
movq %rax, 0xd7e8(%rip)      # 0x103c8
movq -0x108(%rbp), %rax
movq %rax, 0xd7e2(%rip)      # 0x103d0
movq 0xd7d3(%rip), %rsi      # 0x103c8
movl 0xd7d5(%rip), %edx      # 0x103d0
leaq 0xd7ae(%rip), %rdi      # 0x103b0
callq 0x1450
cmpl $0x2f, 0xd7c2(%rip)     # 0x103d0
je 0x2c23
movl $0x2, %edi
leaq 0xd794(%rip), %rsi      # 0x103b0
callq 0x64e0
jmp 0x2c74
movq 0xd3ae(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x120(%rbp)
movl %edx, -0x118(%rbp)
movq -0x120(%rbp), %rax
movq %rax, 0xd77b(%rip)      # 0x103c8
movq -0x118(%rbp), %rax
movq %rax, 0xd775(%rip)      # 0x103d0
movq 0xd766(%rip), %rsi      # 0x103c8
movl 0xd768(%rip), %edx      # 0x103d0
leaq 0xd741(%rip), %rdi      # 0x103b0
callq 0x1450
cmpl $0x2f, 0xd755(%rip)     # 0x103d0
jne 0x2c82
callq 0x43d0
callq 0x2280
jmp 0x2d00
movq 0xd348(%rip), %rax      # 0xffd8
movq (%rax), %rdi
callq 0x4840
movq %rax, -0x130(%rbp)
movl %edx, -0x128(%rbp)
movq -0x130(%rbp), %rax
movq %rax, 0xd715(%rip)      # 0x103c8
movq -0x128(%rbp), %rax
movq %rax, 0xd70f(%rip)      # 0x103d0
movq 0xd700(%rip), %rsi      # 0x103c8
movl 0xd702(%rip), %edx      # 0x103d0
leaq 0xd6db(%rip), %rdi      # 0x103b0
callq 0x1450
callq 0x2280
jmp 0x2d00
jmp 0x2d00
callq 0x4040
callq 0x2280
jmp 0x2d00
movl $0x2, %edi
leaq 0xd6b5(%rip), %rsi      # 0x103b0
callq 0x64e0
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopl (%rax)