// File: /workspace/github_c_makefile_star2_O0/sachinites[P]CommandParser/ut/utinfra/ut_parser.c
// Function: run_test_case
bool
run_test_case(char *file_name, uint16_t tc_no) {

    int rc = 0;
    char *token;
    char buff[128];
    char *fget_ptr;
    bool tc_found = false;
    glthread_t result_head;
    uint16_t current_tc_no;
    char line[512];
    uint16_t current_step_no;
    bool is_repeat_cmd = false;
    CMD_PARSE_STATUS status = UNKNOWN;

     fget_ptr = NULL;
    init_glthread(&result_head);

    FILE *fp = fopen (file_name, "r");
    assert(fp);

    while (( fget_ptr = (fgets (line, sizeof(line), fp)))) {

            if (strlen(line) == 1 && line[0] == '\n') {
                printf("\n");
                rc = sprintf (buff, "\n");
                fwrite(buff, 1, rc, ut_log_file);
                fflush(ut_log_file);
            }

            if (line[0] != ':') continue;
            strtok(line, "\n");

            rc = sprintf(buff, "%lu", int_store1);
            replaceSubstring(line, "$INT_STORE1", buff);
            rc = sprintf(buff, "%lu", int_store2);
            replaceSubstring(line, "$INT_STORE2", buff);
            rc = sprintf(buff, "%lu", int_store3);
            replaceSubstring(line, "$INT_STORE3", buff);

            if (strncmp (line, ":TESTCASE-BEGIN:", strlen(":TESTCASE-BEGIN:")) == 0) {

                token = strtok(line, ":") ;
                token = strtok(NULL, ":") ;
                current_tc_no = atoi(token);

                while (tc_no &&  current_tc_no != tc_no) {

                    /* skip to next test case */
                    while (( fget_ptr = fgets (line, sizeof(line), fp))) {

                             if (strncmp (line, ":TESTCASE-BEGIN:", strlen(":TESTCASE-BEGIN:"))) {
                                 continue;
                             }
                             break;
                    }

                    if (!fget_ptr) break;
                    token = strtok(line, ":") ;
                    token = strtok(NULL, ":") ;
                    current_tc_no = atoi(token);
                }
                
               if (!fget_ptr) break;

               /* Test case found */
                rc = sprintf(buff, "\n ***** Executing Test case : %s - %d ***** \n",
                                    file_name,  current_tc_no);
                printf("%s", buff);
                fwrite(buff, 1, rc, ut_log_file);
                fflush(ut_log_file);
                TC_RUNNING = true;
                tc_found = true;
            }



            else if (strncmp (line, ":TESTCASE-END:", strlen(":TESTCASE-END:")) == 0) {

                token = strtok(line, ":") ;
                token = strtok(NULL, ":") ;

               /* Test case found */
                rc = sprintf(buff, "\n ***** Test case : %s - %d Finished ***** \n",
                                    file_name,  current_tc_no);
                printf("%s", buff);
                fwrite(buff, 1, rc, ut_log_file);

                tc_print_result(&result_head);
                tc_cleanup_result_list(&result_head);
                fflush(ut_log_file);

                if (  tc_no && TC_RUNNING ) {
                    break;
                }
            }



            else if (strncmp (line, ":DESC:", strlen(":DESC:")) == 0) {
                
                token = strtok(line, ":") ;
                token = strtok(NULL, ":") ;
                rc = sprintf(buff, "Description : %s\n", token);
                 printf("%s", buff);
                 fwrite(buff, 1, rc, ut_log_file);
                 fflush(ut_log_file);
            }



            else if (strncmp (line, ":STEP:", strlen(":STEP:")) == 0) {

                token = strtok(line, ":") ;
                token = strtok(NULL, ":") ;
                rc = sprintf(buff, "STEP : %s\n", token);
                printf("%s", buff);
                fwrite(buff, 1, rc, ut_log_file);
                fflush(ut_log_file);
                current_step_no = atoi(token);
            }



            else if (strncmp (line, ":CMD:", strlen(":CMD:")) == 0) {

                token = strtok(line, ":") ;
                token = strtok(NULL, ":") ;
                rc = sprintf(buff, "CMD : %s\n", token);
                printf("%s", buff);
                fwrite(buff, 1, rc, ut_log_file);
                fflush(ut_log_file);
                status = parse_input_cmd(token, strlen(token), &is_repeat_cmd);
                assert(status == COMPLETE);

                /* block if it is show command */
                if (pattern_match(token, strlen(token), "show") && 
                        TC_RUNNING) {   /* You can load the cmds without testcase script */

                    if (ut_parser_debug) {
                        rc = sprintf(buff, "Waiting for backend data\n");
                        printf("%s", buff);
                        fwrite(buff, 1, rc, ut_log_file);
                    }

                    if ((ut_parser_recv_buff_data_size =
                             mq_timedreceive(UT_PARSER_MSG_Q_FD,
                                        ut_parser_recv_buff, MAX_MSG_SIZE, NULL,
                                        &mq_wait_time)) == -1) {

                            printf ("Msg Q  Time out : No Data Recvd from Backend\n");
                            rc = sprintf(buff, "Msg Q  Time out : No Data Recvd from Backend\n");
                            fwrite(buff, 1, rc, ut_log_file);
                            ut_parser_recv_buff_data_size = 0;
                            memset(ut_parser_recv_buff, 0, sizeof(ut_parser_recv_buff));
                    }

                    else if (ut_parser_debug) {

                        printf("Mq Data Recvd by UT Parser : \n");
                        printf("%s\n", ut_parser_recv_buff);
                        rc = sprintf(buff, "Mq Data Recvd by UT Parser : \n");
                        fwrite(buff, 1, rc, ut_log_file);
                        fwrite(ut_parser_recv_buff, 1, ut_parser_recv_buff_data_size -1, ut_log_file);
			fwrite("\n", 1, 1, ut_log_file);
			ut_parser_recv_buff_data_size = 0;
                        memset(ut_parser_recv_buff, 0, sizeof(ut_parser_recv_buff));
                    }
                }
                fflush(ut_log_file);
            }



            else if (strncmp (line, ":PATTERN-MATCH:", strlen(":PATTERN-MATCH:")) == 0) {

                int rc1 = 0;
                char pattern [256];
                token = strtok(line, ":") ;
                token = strtok(NULL, ":") ;  // this is the pattern to be matched
                rc1 = sprintf(pattern + rc1, "%s", token);

                while(1) {
                    token = strtok(NULL, ":") ;
                    if (!token) break;
                    rc1 += sprintf(pattern + rc1, ":%s", token);
                }
              
                printf("pattern to be matched : |%s|\n", pattern);
                rc = sprintf(buff, "pattern to be matched : |");
                fwrite(buff, 1, rc, ut_log_file);
                fwrite(pattern, 1, rc1, ut_log_file);
                rc = sprintf(buff, "|\n");
                fwrite(buff, 1, rc, ut_log_file);

                if (pattern_match(ut_parser_recv_buff,  ut_parser_recv_buff_data_size, pattern)) {
                    printf("PASS\n");
                    rc = sprintf(buff, "PASS\n");
                    fwrite(buff, 1, rc, ut_log_file);
                    tc_append_result(&result_head, current_step_no, true, true);
                }
                else {
                   printf("FAIL\n");
                   rc = sprintf(buff,  "FAIL\n");
                   fwrite(buff, 1, rc, ut_log_file);
                   tc_append_result(&result_head, current_step_no, false, true);
                }
                fflush(ut_log_file);
            }



            else if (strncmp (line, ":PATTERN-NOT-MATCH:", strlen(":PATTERN-NOT-MATCH:")) == 0) {

                int rc1 = 0;
                char pattern [256];
                token = strtok(line, ":") ;
                token = strtok(NULL, ":") ;  // this is the pattern to be not matched
                rc1 += sprintf(pattern + rc1, "%s", token);

                while(1) {
                    token = strtok(NULL, ":") ;
                    if (!token) break;
                    rc1 += sprintf(pattern + rc1,  ":%s", token);
                }

                printf("pattern to be not matched : |%s|\n", pattern);
                rc = sprintf(buff, "pattern to be not matched : |");
                fwrite(buff, 1, rc, ut_log_file);
                fwrite(pattern, 1, rc1, ut_log_file);
                rc = sprintf(buff, "|\n");
                fwrite(buff, 1, rc, ut_log_file);

                if (!pattern_match(ut_parser_recv_buff, ut_parser_recv_buff_data_size, pattern)) {
                    printf("PASS\n");
                    rc = sprintf(buff, "PASS\n");
                    fwrite(buff, 1, rc, ut_log_file);
                    tc_append_result(&result_head, current_step_no, true, false);
                }
                else {
                    printf("FAIL\n");
                    rc = sprintf(buff, "FAIL\n");
                    fwrite(buff, 1, rc, ut_log_file);
                    tc_append_result(&result_head, current_step_no, false, false);
                }
                fflush(ut_log_file);
            }



            else if (strncmp (line, ":SLEEP:", strlen(":SLEEP:")) == 0) {

                    token = strtok(line, ":") ;
                    token = strtok(NULL, ":") ;
                    rc = sprintf(buff, "Sleeping for %s sec\n", token);
                    printf("%s", buff);
                    fwrite(buff, 1, rc, ut_log_file);
                    fflush(ut_log_file);
                    sleep(atoi(token));
            }



            else if (strncmp (line, ":ABORT:", strlen(":ABORT:")) == 0) {
                    printf("Aborted\n");
                    rc = sprintf(buff, "Aborted\n");
                    fwrite(buff, 1, rc, ut_log_file);
                    break;
            }



            else if (strncmp (line, ":PAUSE:", strlen(":PAUSE:")) == 0) {
                    printf("Paused\n");
                    rc = sprintf(buff, "Paused\n");
                    fwrite(buff, 1, rc, ut_log_file);
                     fflush(ut_log_file);
                    getchar();
            }



             else if (strncmp (line, ":GREP:", strlen(":GREP:")) == 0) {
                    token = strtok(line, ":") ;
                    token = strtok(NULL, ":") ;
                    printf ("Grep Pattern : %s\n", token);
                    rc = sprintf (buff, "Grep Pattern : %s\n", token);
                    fwrite(buff, 1, rc, ut_log_file);
                    ut_parser_recv_buff_data_size = 
                        grep (ut_parser_recv_buff, ut_parser_recv_buff_data_size, token);
                    printf ("Output After Grep : \n");
                    printf("%s", ut_parser_recv_buff);
                    rc = sprintf (buff, "Output After Grep : \n");
                    fwrite(buff, 1, rc, ut_log_file);
                    fwrite(ut_parser_recv_buff, 1, ut_parser_recv_buff_data_size, ut_log_file);
                    fflush(ut_log_file);
             }



             else if (strncmp (line, ":PRINT:", strlen(":PRINT:")) == 0) {
                    token = strtok(line, ":") ;
                    token = strtok(NULL, ":") ;
                    printf ("INFO : %s\n", token);
                    rc = sprintf (buff, "INFO : %s\n", token);
                    fwrite(buff, 1, rc, ut_log_file);
                    fflush(ut_log_file);
             }



            else if (strncmp (line, ":INT_STORE1:", strlen(":INT_STORE1:")) == 0) {

                    int index = 0;
                    token = strtok(line, ":") ;
                    token = strtok(NULL, ":") ;
                    index = atoi(token);
                    assert(index);
                    int_store1 = string_fetch_integer(ut_parser_recv_buff, 
                                        ut_parser_recv_buff_data_size, index);
                    printf("int_store1 = %lu at index %d\n", int_store1, index);
                    rc = sprintf (buff, "int_store1 = %lu at index %d\n", int_store1, index);
                    fwrite(buff, 1, rc, ut_log_file);
                     fflush(ut_log_file);
            }
            
            else if (strncmp (line, ":INT_STORE2:", strlen(":INT_STORE2:")) == 0) {

                    int index = 0;
                    token = strtok(line, ":") ;
                    token = strtok(NULL, ":") ;
                    index = atoi(token);
                    assert(index);
                    int_store2 = string_fetch_integer(ut_parser_recv_buff, 
                                        ut_parser_recv_buff_data_size, index);
                    printf("int_store2 = %lu at index %d\n", int_store2, index);
                    rc = sprintf (buff, "int_store2 = %lu at index %d\n", int_store2, index);
                    fwrite(buff, 1, rc, ut_log_file);
                    fflush(ut_log_file);
            }
            
            else if (strncmp (line, ":INT_STORE3:", strlen(":INT_STORE3:")) == 0) {

                    int index = 0;
                    token = strtok(line, ":") ;
                    token = strtok(NULL, ":") ;
                    index = atoi(token);
                    assert(index);
                    int_store3 = string_fetch_integer(ut_parser_recv_buff, 
                                        ut_parser_recv_buff_data_size, index);
                    printf("int_store3 = %lu at index %d\n", int_store3, index);
                    rc = sprintf (buff, "int_store3 = %lu at index %d\n", int_store3, index);
                    fwrite(buff, 1, rc, ut_log_file);
                     fflush(ut_log_file);
            }




    }

    fclose(fp);
    TC_RUNNING = false;
    fflush(ut_log_file);
    return tc_found;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x520, %rsp            # imm = 0x520
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movl $0x0, -0x10(%rbp)
movb $0x0, -0xa9(%rbp)
movb $0x0, -0x2d3(%rbp)
movl $0x7, -0x2d8(%rbp)
movq $0x0, -0xa8(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x9430
movq -0x8(%rbp), %rdi
leaq 0x2bcf(%rip), %rsi      # 0xa606
callq 0x11b0
movq %rax, -0x2e0(%rbp)
cmpq $0x0, -0x2e0(%rbp)
je 0x7a4f
jmp 0x7a6e
leaq 0x3d39(%rip), %rdi      # 0xb78f
leaq 0x3cce(%rip), %rsi      # 0xb72b
movl $0x99, %edx
leaq 0x3d29(%rip), %rcx      # 0xb792
callq 0x10c0
jmp 0x7a70
leaq -0x2d0(%rbp), %rdi
movq -0x2e0(%rbp), %rdx
movl $0x200, %esi            # imm = 0x200
callq 0x10f0
movq %rax, -0xa8(%rbp)
cmpq $0x0, %rax
je 0x8e3c
leaq -0x2d0(%rbp), %rdi
callq 0x1090
cmpq $0x1, %rax
jne 0x7b05
movsbl -0x2d0(%rbp), %eax
cmpl $0xa, %eax
jne 0x7b05
leaq 0x3d5f(%rip), %rdi      # 0xb81d
movb $0x0, %al
callq 0x10b0
leaq -0xa0(%rbp), %rdi
leaq 0x3d4a(%rip), %rsi      # 0xb81d
movb $0x0, %al
callq 0x1200
movl %eax, -0x10(%rbp)
leaq -0xa0(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq 0xd8e1(%rip), %rcx      # 0x153d0
movl $0x1, %esi
callq 0x1220
movq 0xd8d0(%rip), %rdi      # 0x153d0
callq 0x1170
movsbl -0x2d0(%rbp), %eax
cmpl $0x3a, %eax
je 0x7b16
jmp 0x7a70
leaq -0x2d0(%rbp), %rdi
leaq 0x3cf9(%rip), %rsi      # 0xb81d
callq 0x11c0
leaq -0xa0(%rbp), %rdi
movq 0xd8b9(%rip), %rdx      # 0x153f0
leaq 0x3c7a(%rip), %rsi      # 0xb7b8
movb $0x0, %al
callq 0x1200
movl %eax, -0x10(%rbp)
leaq -0x2d0(%rbp), %rdi
leaq -0xa0(%rbp), %rdx
leaq 0x3c5f(%rip), %rsi      # 0xb7bc
callq 0x6620
leaq -0xa0(%rbp), %rdi
movq 0xd888(%rip), %rdx      # 0x153f8
leaq 0x3c41(%rip), %rsi      # 0xb7b8
movb $0x0, %al
callq 0x1200
movl %eax, -0x10(%rbp)
leaq -0x2d0(%rbp), %rdi
leaq -0xa0(%rbp), %rdx
leaq 0x3c32(%rip), %rsi      # 0xb7c8
callq 0x6620
leaq -0xa0(%rbp), %rdi
movq 0xd857(%rip), %rdx      # 0x15400
leaq 0x3c08(%rip), %rsi      # 0xb7b8
movb $0x0, %al
callq 0x1200
movl %eax, -0x10(%rbp)
leaq -0x2d0(%rbp), %rdi
leaq -0xa0(%rbp), %rdx
leaq 0x3c05(%rip), %rsi      # 0xb7d4
callq 0x6620
leaq -0x2d0(%rbp), %rdi
leaq 0x3bfe(%rip), %rsi      # 0xb7e0
movl $0x10, %edx
callq 0x1060
cmpl $0x0, %eax
jne 0x7d7c
leaq -0x2d0(%rbp), %rdi
leaq 0x3e45(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x3e31(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11d0
movw %ax, -0xc2(%rbp)
movzwl -0xa(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x50d(%rbp)
je 0x7c57
movzwl -0xc2(%rbp), %eax
movzwl -0xa(%rbp), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x50d(%rbp)
movb -0x50d(%rbp), %al
testb $0x1, %al
jne 0x7c66
jmp 0x7cfa
jmp 0x7c68
leaq -0x2d0(%rbp), %rdi
movq -0x2e0(%rbp), %rdx
movl $0x200, %esi            # imm = 0x200
callq 0x10f0
movq %rax, -0xa8(%rbp)
cmpq $0x0, %rax
je 0x7cae
leaq -0x2d0(%rbp), %rdi
leaq 0x3b45(%rip), %rsi      # 0xb7e0
movl $0x10, %edx
callq 0x1060
cmpl $0x0, %eax
je 0x7cac
jmp 0x7c68
jmp 0x7cae
cmpq $0x0, -0xa8(%rbp)
jne 0x7cba
jmp 0x7cfa
leaq -0x2d0(%rbp), %rdi
leaq 0x3d80(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x3d6c(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11d0
movw %ax, -0xc2(%rbp)
jmp 0x7c30
cmpq $0x0, -0xa8(%rbp)
jne 0x7d09
jmp 0x8e3c
leaq -0xa0(%rbp), %rdi
movq -0x8(%rbp), %rdx
movzwl -0xc2(%rbp), %ecx
leaq 0x3acf(%rip), %rsi      # 0xb7f1
movb $0x0, %al
callq 0x1200
movl %eax, -0x10(%rbp)
leaq -0xa0(%rbp), %rsi
leaq 0x349b(%rip), %rdi      # 0xb1d5
movb $0x0, %al
callq 0x10b0
leaq -0xa0(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq 0xd67d(%rip), %rcx      # 0x153d0
movl $0x1, %esi
callq 0x1220
movq 0xd66c(%rip), %rdi      # 0x153d0
callq 0x1170
movb $0x1, 0xd698(%rip)      # 0x15408
movb $0x1, -0xa9(%rbp)
jmp 0x8e37
leaq -0x2d0(%rbp), %rdi
leaq 0x3a95(%rip), %rsi      # 0xb81f
movl $0xe, %edx
callq 0x1060
cmpl $0x0, %eax
jne 0x7e5c
leaq -0x2d0(%rbp), %rdi
leaq 0x3c9d(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x3c89(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
leaq -0xa0(%rbp), %rdi
movq -0x8(%rbp), %rdx
movzwl -0xc2(%rbp), %ecx
leaq 0x3a4d(%rip), %rsi      # 0xb82e
movb $0x0, %al
callq 0x1200
movl %eax, -0x10(%rbp)
leaq -0xa0(%rbp), %rsi
leaq 0x33dc(%rip), %rdi      # 0xb1d5
movb $0x0, %al
callq 0x10b0
leaq -0xa0(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq 0xd5be(%rip), %rcx      # 0x153d0
movl $0x1, %esi
callq 0x1220
leaq -0xc0(%rbp), %rdi
callq 0x8e70
leaq -0xc0(%rbp), %rdi
callq 0x9080
movq 0xd595(%rip), %rdi      # 0x153d0
callq 0x1170
movzwl -0xa(%rbp), %eax
cmpl $0x0, %eax
je 0x7e57
testb $0x1, 0xd5b8(%rip)      # 0x15408
je 0x7e57
jmp 0x8e3c
jmp 0x8e35
leaq -0x2d0(%rbp), %rdi
leaq 0x39f1(%rip), %rsi      # 0xb85b
movl $0x6, %edx
callq 0x1060
cmpl $0x0, %eax
jne 0x7f06
leaq -0x2d0(%rbp), %rdi
leaq 0x3bbd(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x3ba9(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
leaq -0xa0(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x39a8(%rip), %rsi      # 0xb862
movb $0x0, %al
callq 0x1200
movl %eax, -0x10(%rbp)
leaq -0xa0(%rbp), %rsi
leaq 0x3303(%rip), %rdi      # 0xb1d5
movb $0x0, %al
callq 0x10b0
leaq -0xa0(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq 0xd4e5(%rip), %rcx      # 0x153d0
movl $0x1, %esi
callq 0x1220
movq 0xd4d4(%rip), %rdi      # 0x153d0
callq 0x1170
jmp 0x8e33
leaq -0x2d0(%rbp), %rdi
leaq 0x3960(%rip), %rsi      # 0xb874
movl $0x6, %edx
callq 0x1060
cmpl $0x0, %eax
jne 0x7fc0
leaq -0x2d0(%rbp), %rdi
leaq 0x3b13(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x3aff(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
leaq -0xa0(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3917(%rip), %rsi      # 0xb87b
movb $0x0, %al
callq 0x1200
movl %eax, -0x10(%rbp)
leaq -0xa0(%rbp), %rsi
leaq 0x3259(%rip), %rdi      # 0xb1d5
movb $0x0, %al
callq 0x10b0
leaq -0xa0(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq 0xd43b(%rip), %rcx      # 0x153d0
movl $0x1, %esi
callq 0x1220
movq 0xd42a(%rip), %rdi      # 0x153d0
callq 0x1170
movq -0x18(%rbp), %rdi
callq 0x11d0
movw %ax, -0x2d2(%rbp)
jmp 0x8e31
leaq -0x2d0(%rbp), %rdi
leaq 0x38b8(%rip), %rsi      # 0xb886
movl $0x5, %edx
callq 0x1060
cmpl $0x0, %eax
jne 0x82b5
leaq -0x2d0(%rbp), %rdi
leaq 0x3a59(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x3a45(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
leaq -0xa0(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x386e(%rip), %rsi      # 0xb88c
movb $0x0, %al
callq 0x1200
movl %eax, -0x10(%rbp)
leaq -0xa0(%rbp), %rsi
leaq 0x319f(%rip), %rdi      # 0xb1d5
movb $0x0, %al
callq 0x10b0
leaq -0xa0(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq 0xd381(%rip), %rcx      # 0x153d0
movl $0x1, %esi
callq 0x1220
movq 0xd370(%rip), %rdi      # 0x153d0
callq 0x1170
movq -0x18(%rbp), %rax
movq %rax, -0x518(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1090
movq -0x518(%rbp), %rdi
movl %eax, %esi
leaq -0x2d3(%rbp), %rdx
callq 0x41f0
movl %eax, -0x2d8(%rbp)
cmpl $0x0, -0x2d8(%rbp)
jne 0x809f
jmp 0x80be
leaq 0x37f0(%rip), %rdi      # 0xb896
leaq 0x367e(%rip), %rsi      # 0xb72b
movl $0x10b, %edx            # imm = 0x10B
leaq 0x36d9(%rip), %rcx      # 0xb792
callq 0x10c0
movq -0x18(%rbp), %rax
movq %rax, -0x520(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1090
movq -0x520(%rbp), %rdi
movl %eax, %esi
leaq 0x23d5(%rip), %rdx      # 0xa4b7
callq 0x67f0
testb $0x1, %al
jne 0x80f0
jmp 0x82a4
testb $0x1, 0xd311(%rip)      # 0x15408
je 0x82a4
testb $0x1, 0xd305(%rip)      # 0x15409
je 0x814f
leaq -0xa0(%rbp), %rdi
leaq 0x3795(%rip), %rsi      # 0xb8a9
movb $0x0, %al
callq 0x1200
movl %eax, -0x10(%rbp)
leaq -0xa0(%rbp), %rsi
leaq 0x30a9(%rip), %rdi      # 0xb1d5
movb $0x0, %al
callq 0x10b0
leaq -0xa0(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq 0xd28b(%rip), %rcx      # 0x153d0
movl $0x1, %esi
callq 0x1220
movl 0xd283(%rip), %edi      # 0x153d8
leaq 0xd2b4(%rip), %rsi      # 0x15410
movl $0x800, %edx            # imm = 0x800
xorl %eax, %eax
movl %eax, %ecx
leaq 0xd274(%rip), %r8       # 0x153e0
callq 0x1080
movl %eax, 0xda99(%rip)      # 0x15c10
cmpl $-0x1, %eax
jne 0x81e0
leaq 0x3740(%rip), %rdi      # 0xb8c3
movb $0x0, %al
callq 0x10b0
leaq -0xa0(%rbp), %rdi
leaq 0x372b(%rip), %rsi      # 0xb8c3
movb $0x0, %al
callq 0x1200
movl %eax, -0x10(%rbp)
leaq -0xa0(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq 0xd21c(%rip), %rcx      # 0x153d0
movl $0x1, %esi
callq 0x1220
movl $0x0, 0xda48(%rip)      # 0x15c10
leaq 0xd241(%rip), %rdi      # 0x15410
xorl %esi, %esi
movl $0x800, %edx            # imm = 0x800
callq 0x10d0
jmp 0x82a2
testb $0x1, 0xd222(%rip)      # 0x15409
je 0x82a0
leaq 0x36fd(%rip), %rdi      # 0xb8f1
movb $0x0, %al
callq 0x10b0
leaq 0x28b4(%rip), %rdi      # 0xaab6
leaq 0xd207(%rip), %rsi      # 0x15410
movb $0x0, %al
callq 0x10b0
leaq -0xa0(%rbp), %rdi
leaq 0x36d3(%rip), %rsi      # 0xb8f1
movb $0x0, %al
callq 0x1200
movl %eax, -0x10(%rbp)
leaq -0xa0(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq 0xd196(%rip), %rcx      # 0x153d0
movl $0x1, %esi
callq 0x1220
movl 0xd9c6(%rip), %eax      # 0x15c10
subl $0x1, %eax
movslq %eax, %rdx
movq 0xd179(%rip), %rcx      # 0x153d0
leaq 0xd1b2(%rip), %rdi      # 0x15410
movl $0x1, %esi
callq 0x1220
movq 0xd161(%rip), %rcx      # 0x153d0
leaq 0x35a7(%rip), %rdi      # 0xb81d
movl $0x1, %edx
movq %rdx, %rsi
callq 0x1220
movl $0x0, 0xd983(%rip)      # 0x15c10
leaq 0xd17c(%rip), %rdi      # 0x15410
xorl %esi, %esi
movl $0x800, %edx            # imm = 0x800
callq 0x10d0
jmp 0x82a2
jmp 0x82a4
movq 0xd125(%rip), %rdi      # 0x153d0
callq 0x1170
jmp 0x8e2f
leaq -0x2d0(%rbp), %rdi
leaq 0x364d(%rip), %rsi      # 0xb910
movl $0xf, %edx
callq 0x1060
cmpl $0x0, %eax
jne 0x8508
movl $0x0, -0x2e4(%rbp)
leaq -0x2d0(%rbp), %rdi
leaq 0x375a(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x3746(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
leaq -0x3f0(%rbp), %rdi
movslq -0x2e4(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rdx
leaq 0x2eae(%rip), %rsi      # 0xb1d5
movb $0x0, %al
callq 0x1200
movl %eax, -0x2e4(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x3709(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8351
jmp 0x8382
leaq -0x3f0(%rbp), %rdi
movslq -0x2e4(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rdx
leaq 0x35b3(%rip), %rsi      # 0xb920
movb $0x0, %al
callq 0x1200
addl -0x2e4(%rbp), %eax
movl %eax, -0x2e4(%rbp)
jmp 0x8334
leaq -0x3f0(%rbp), %rsi
leaq 0x3594(%rip), %rdi      # 0xb924
movb $0x0, %al
callq 0x10b0
leaq -0xa0(%rbp), %rdi
leaq 0x359d(%rip), %rsi      # 0xb942
movb $0x0, %al
callq 0x1200
movl %eax, -0x10(%rbp)
leaq -0xa0(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq 0xd00f(%rip), %rcx      # 0x153d0
movl $0x1, %esi
callq 0x1220
leaq -0x3f0(%rbp), %rdi
movslq -0x2e4(%rbp), %rdx
movq 0xcff0(%rip), %rcx      # 0x153d0
movl $0x1, %esi
callq 0x1220
leaq -0xa0(%rbp), %rdi
leaq 0x3547(%rip), %rsi      # 0xb93f
movb $0x0, %al
callq 0x1200
movl %eax, -0x10(%rbp)
leaq -0xa0(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq 0xcfbc(%rip), %rcx      # 0x153d0
movl $0x1, %esi
callq 0x1220
movl 0xd7ec(%rip), %esi      # 0x15c10
leaq -0x3f0(%rbp), %rdx
leaq 0xcfde(%rip), %rdi      # 0x15410
callq 0x67f0
testb $0x1, %al
jne 0x843d
jmp 0x849b
leaq 0x3518(%rip), %rdi      # 0xb95c
movb $0x0, %al
callq 0x10b0
leaq -0xa0(%rbp), %rdi
leaq 0x3503(%rip), %rsi      # 0xb95c
movb $0x0, %al
callq 0x1200
movl %eax, -0x10(%rbp)
leaq -0xa0(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq 0xcf5b(%rip), %rcx      # 0x153d0
movl $0x1, %esi
callq 0x1220
leaq -0xc0(%rbp), %rdi
movl $0x1, %ecx
movzwl -0x2d2(%rbp), %esi
movl %ecx, %edx
callq 0x90f0
jmp 0x84f7
leaq 0x34c0(%rip), %rdi      # 0xb962
movb $0x0, %al
callq 0x10b0
leaq -0xa0(%rbp), %rdi
leaq 0x34ab(%rip), %rsi      # 0xb962
movb $0x0, %al
callq 0x1200
movl %eax, -0x10(%rbp)
leaq -0xa0(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq 0xcefd(%rip), %rcx      # 0x153d0
movl $0x1, %esi
callq 0x1220
leaq -0xc0(%rbp), %rdi
xorl %edx, %edx
movl $0x1, %ecx
movzwl -0x2d2(%rbp), %esi
callq 0x90f0
movq 0xced2(%rip), %rdi      # 0x153d0
callq 0x1170
jmp 0x8e2d
leaq -0x2d0(%rbp), %rdi
leaq 0x3452(%rip), %rsi      # 0xb968
movl $0x13, %edx
callq 0x1060
cmpl $0x0, %eax
jne 0x875c
movl $0x0, -0x3f4(%rbp)
leaq -0x2d0(%rbp), %rdi
leaq 0x3507(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x34f3(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
leaq -0x500(%rbp), %rdi
movslq -0x3f4(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rdx
leaq 0x2c5b(%rip), %rsi      # 0xb1d5
movb $0x0, %al
callq 0x1200
addl -0x3f4(%rbp), %eax
movl %eax, -0x3f4(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x34b0(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x85aa
jmp 0x85db
leaq -0x500(%rbp), %rdi
movslq -0x3f4(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rdx
leaq 0x335a(%rip), %rsi      # 0xb920
movb $0x0, %al
callq 0x1200
addl -0x3f4(%rbp), %eax
movl %eax, -0x3f4(%rbp)
jmp 0x858d
leaq -0x500(%rbp), %rsi
leaq 0x3393(%rip), %rdi      # 0xb97c
movb $0x0, %al
callq 0x10b0
leaq -0xa0(%rbp), %rdi
leaq 0x33a0(%rip), %rsi      # 0xb99e
movb $0x0, %al
callq 0x1200
movl %eax, -0x10(%rbp)
leaq -0xa0(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq 0xcdb6(%rip), %rcx      # 0x153d0
movl $0x1, %esi
callq 0x1220
leaq -0x500(%rbp), %rdi
movslq -0x3f4(%rbp), %rdx
movq 0xcd97(%rip), %rcx      # 0x153d0
movl $0x1, %esi
callq 0x1220
leaq -0xa0(%rbp), %rdi
leaq 0x32ee(%rip), %rsi      # 0xb93f
movb $0x0, %al
callq 0x1200
movl %eax, -0x10(%rbp)
leaq -0xa0(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq 0xcd63(%rip), %rcx      # 0x153d0
movl $0x1, %esi
callq 0x1220
movl 0xd593(%rip), %esi      # 0x15c10
leaq -0x500(%rbp), %rdx
leaq 0xcd85(%rip), %rdi      # 0x15410
callq 0x67f0
testb $0x1, %al
jne 0x86f2
leaq 0x32c1(%rip), %rdi      # 0xb95c
movb $0x0, %al
callq 0x10b0
leaq -0xa0(%rbp), %rdi
leaq 0x32ac(%rip), %rsi      # 0xb95c
movb $0x0, %al
callq 0x1200
movl %eax, -0x10(%rbp)
leaq -0xa0(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq 0xcd04(%rip), %rcx      # 0x153d0
movl $0x1, %esi
callq 0x1220
leaq -0xc0(%rbp), %rdi
movl $0x1, %edx
xorl %ecx, %ecx
movzwl -0x2d2(%rbp), %esi
callq 0x90f0
jmp 0x874b
leaq 0x3269(%rip), %rdi      # 0xb962
movb $0x0, %al
callq 0x10b0
leaq -0xa0(%rbp), %rdi
leaq 0x3254(%rip), %rsi      # 0xb962
movb $0x0, %al
callq 0x1200
movl %eax, -0x10(%rbp)
leaq -0xa0(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq 0xcca6(%rip), %rcx      # 0x153d0
movl $0x1, %esi
callq 0x1220
leaq -0xc0(%rbp), %rdi
xorl %ecx, %ecx
movzwl -0x2d2(%rbp), %esi
movl %ecx, %edx
callq 0x90f0
movq 0xcc7e(%rip), %rdi      # 0x153d0
callq 0x1170
jmp 0x8e2b
leaq -0x2d0(%rbp), %rdi
leaq 0x3252(%rip), %rsi      # 0xb9bc
movl $0x7, %edx
callq 0x1060
cmpl $0x0, %eax
jne 0x8816
leaq -0x2d0(%rbp), %rdi
leaq 0x32bd(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x32a9(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
leaq -0xa0(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x320a(%rip), %rsi      # 0xb9c4
movb $0x0, %al
callq 0x1200
movl %eax, -0x10(%rbp)
leaq -0xa0(%rbp), %rsi
leaq 0x2a03(%rip), %rdi      # 0xb1d5
movb $0x0, %al
callq 0x10b0
leaq -0xa0(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq 0xcbe5(%rip), %rcx      # 0x153d0
movl $0x1, %esi
callq 0x1220
movq 0xcbd4(%rip), %rdi      # 0x153d0
callq 0x1170
movq -0x18(%rbp), %rdi
callq 0x11d0
movl %eax, %edi
callq 0x1230
jmp 0x8e29
leaq -0x2d0(%rbp), %rdi
leaq 0x31b5(%rip), %rsi      # 0xb9d9
movl $0x7, %edx
callq 0x1060
cmpl $0x0, %eax
jne 0x887a
leaq 0x31a7(%rip), %rdi      # 0xb9e1
movb $0x0, %al
callq 0x10b0
leaq -0xa0(%rbp), %rdi
leaq 0x3192(%rip), %rsi      # 0xb9e1
movb $0x0, %al
callq 0x1200
movl %eax, -0x10(%rbp)
leaq -0xa0(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq 0xcb65(%rip), %rcx      # 0x153d0
movl $0x1, %esi
callq 0x1220
jmp 0x8e3c
leaq -0x2d0(%rbp), %rdi
leaq 0x3162(%rip), %rsi      # 0xb9ea
movl $0x7, %edx
callq 0x1060
cmpl $0x0, %eax
jne 0x88ef
leaq 0x3154(%rip), %rdi      # 0xb9f2
movb $0x0, %al
callq 0x10b0
leaq -0xa0(%rbp), %rdi
leaq 0x313f(%rip), %rsi      # 0xb9f2
movb $0x0, %al
callq 0x1200
movl %eax, -0x10(%rbp)
leaq -0xa0(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq 0xcb01(%rip), %rcx      # 0x153d0
movl $0x1, %esi
callq 0x1220
movq 0xcaf0(%rip), %rdi      # 0x153d0
callq 0x1170
callq 0x1110
jmp 0x8e25
leaq -0x2d0(%rbp), %rdi
leaq 0x30fd(%rip), %rsi      # 0xb9fa
movl $0x6, %edx
callq 0x1060
cmpl $0x0, %eax
jne 0x8a28
leaq -0x2d0(%rbp), %rdi
leaq 0x312a(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x3116(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x30bb(%rip), %rdi      # 0xba01
movb $0x0, %al
callq 0x10b0
leaq -0xa0(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x30a2(%rip), %rsi      # 0xba01
movb $0x0, %al
callq 0x1200
movl %eax, -0x10(%rbp)
leaq -0xa0(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq 0xca55(%rip), %rcx      # 0x153d0
movl $0x1, %esi
callq 0x1220
movl 0xd285(%rip), %esi      # 0x15c10
movq -0x18(%rbp), %rdx
leaq 0xca7a(%rip), %rdi      # 0x15410
callq 0x6840
movl %eax, 0xd26f(%rip)      # 0x15c10
leaq 0x306c(%rip), %rdi      # 0xba14
movb $0x0, %al
callq 0x10b0
leaq 0x281f(%rip), %rdi      # 0xb1d5
leaq 0xca53(%rip), %rsi      # 0x15410
movb $0x0, %al
callq 0x10b0
leaq -0xa0(%rbp), %rdi
leaq 0x3042(%rip), %rsi      # 0xba14
movb $0x0, %al
callq 0x1200
movl %eax, -0x10(%rbp)
leaq -0xa0(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq 0xc9e2(%rip), %rcx      # 0x153d0
movl $0x1, %esi
callq 0x1220
movslq 0xd211(%rip), %rdx      # 0x15c10
movq 0xc9ca(%rip), %rcx      # 0x153d0
leaq 0xca03(%rip), %rdi      # 0x15410
movl $0x1, %esi
callq 0x1220
movq 0xc9b2(%rip), %rdi      # 0x153d0
callq 0x1170
jmp 0x8e23
leaq -0x2d0(%rbp), %rdi
leaq 0x2ff4(%rip), %rsi      # 0xba2a
movl $0x7, %edx
callq 0x1060
cmpl $0x0, %eax
jne 0x8acf
leaq -0x2d0(%rbp), %rdi
leaq 0x2ff1(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x2fdd(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x2fb3(%rip), %rdi      # 0xba32
movb $0x0, %al
callq 0x10b0
leaq -0xa0(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x2f9a(%rip), %rsi      # 0xba32
movb $0x0, %al
callq 0x1200
movl %eax, -0x10(%rbp)
leaq -0xa0(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq 0xc91c(%rip), %rcx      # 0x153d0
movl $0x1, %esi
callq 0x1220
movq 0xc90b(%rip), %rdi      # 0x153d0
callq 0x1170
jmp 0x8e21
leaq -0x2d0(%rbp), %rdi
leaq 0x2f60(%rip), %rsi      # 0xba3d
movl $0xc, %edx
callq 0x1060
cmpl $0x0, %eax
jne 0x8bea
movl $0x0, -0x504(%rbp)
leaq -0x2d0(%rbp), %rdi
leaq 0x2f40(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x2f2c(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11d0
movl %eax, -0x504(%rbp)
cmpl $0x0, -0x504(%rbp)
je 0x8b3f
jmp 0x8b5e
leaq 0x2f04(%rip), %rdi      # 0xba4a
leaq 0x2bde(%rip), %rsi      # 0xb72b
movl $0x1c3, %edx            # imm = 0x1C3
leaq 0x2c39(%rip), %rcx      # 0xb792
callq 0x10c0
movl 0xd0ac(%rip), %esi      # 0x15c10
movl -0x504(%rbp), %edx
leaq 0xc89f(%rip), %rdi      # 0x15410
callq 0x6930
movq %rax, 0xc873(%rip)      # 0x153f0
movq 0xc86c(%rip), %rsi      # 0x153f0
movl -0x504(%rbp), %edx
leaq 0x2ebf(%rip), %rdi      # 0xba50
movb $0x0, %al
callq 0x10b0
leaq -0xa0(%rbp), %rdi
movq 0xc84a(%rip), %rdx      # 0x153f0
movl -0x504(%rbp), %ecx
leaq 0x2e9d(%rip), %rsi      # 0xba50
movb $0x0, %al
callq 0x1200
movl %eax, -0x10(%rbp)
leaq -0xa0(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq 0xc801(%rip), %rcx      # 0x153d0
movl $0x1, %esi
callq 0x1220
movq 0xc7f0(%rip), %rdi      # 0x153d0
callq 0x1170
jmp 0x8e1f
leaq -0x2d0(%rbp), %rdi
leaq 0x2e76(%rip), %rsi      # 0xba6e
movl $0xc, %edx
callq 0x1060
cmpl $0x0, %eax
jne 0x8d05
movl $0x0, -0x508(%rbp)
leaq -0x2d0(%rbp), %rdi
leaq 0x2e25(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x2e11(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11d0
movl %eax, -0x508(%rbp)
cmpl $0x0, -0x508(%rbp)
je 0x8c5a
jmp 0x8c79
leaq 0x2de9(%rip), %rdi      # 0xba4a
leaq 0x2ac3(%rip), %rsi      # 0xb72b
movl $0x1d2, %edx            # imm = 0x1D2
leaq 0x2b1e(%rip), %rcx      # 0xb792
callq 0x10c0
movl 0xcf91(%rip), %esi      # 0x15c10
movl -0x508(%rbp), %edx
leaq 0xc784(%rip), %rdi      # 0x15410
callq 0x6930
movq %rax, 0xc760(%rip)      # 0x153f8
movq 0xc759(%rip), %rsi      # 0x153f8
movl -0x508(%rbp), %edx
leaq 0x2dcf(%rip), %rdi      # 0xba7b
movb $0x0, %al
callq 0x10b0
leaq -0xa0(%rbp), %rdi
movq 0xc737(%rip), %rdx      # 0x153f8
movl -0x508(%rbp), %ecx
leaq 0x2dad(%rip), %rsi      # 0xba7b
movb $0x0, %al
callq 0x1200
movl %eax, -0x10(%rbp)
leaq -0xa0(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq 0xc6e6(%rip), %rcx      # 0x153d0
movl $0x1, %esi
callq 0x1220
movq 0xc6d5(%rip), %rdi      # 0x153d0
callq 0x1170
jmp 0x8e1d
leaq -0x2d0(%rbp), %rdi
leaq 0x2d86(%rip), %rsi      # 0xba99
movl $0xc, %edx
callq 0x1060
cmpl $0x0, %eax
jne 0x8e1b
movl $0x0, -0x50c(%rbp)
leaq -0x2d0(%rbp), %rdi
leaq 0x2d0a(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x2cf6(%rip), %rsi      # 0xba48
callq 0x11c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11d0
movl %eax, -0x50c(%rbp)
cmpl $0x0, -0x50c(%rbp)
je 0x8d75
jmp 0x8d94
leaq 0x2cce(%rip), %rdi      # 0xba4a
leaq 0x29a8(%rip), %rsi      # 0xb72b
movl $0x1e1, %edx            # imm = 0x1E1
leaq 0x2a03(%rip), %rcx      # 0xb792
callq 0x10c0
movl 0xce76(%rip), %esi      # 0x15c10
movl -0x50c(%rbp), %edx
leaq 0xc669(%rip), %rdi      # 0x15410
callq 0x6930
movq %rax, 0xc64d(%rip)      # 0x15400
movq 0xc646(%rip), %rsi      # 0x15400
movl -0x50c(%rbp), %edx
leaq 0x2cdf(%rip), %rdi      # 0xbaa6
movb $0x0, %al
callq 0x10b0
leaq -0xa0(%rbp), %rdi
movq 0xc624(%rip), %rdx      # 0x15400
movl -0x50c(%rbp), %ecx
leaq 0x2cbd(%rip), %rsi      # 0xbaa6
movb $0x0, %al
callq 0x1200
movl %eax, -0x10(%rbp)
leaq -0xa0(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq 0xc5cb(%rip), %rcx      # 0x153d0
movl $0x1, %esi
callq 0x1220
movq 0xc5ba(%rip), %rdi      # 0x153d0
callq 0x1170
jmp 0x8e1d
jmp 0x8e1f
jmp 0x8e21
jmp 0x8e23
jmp 0x8e25
jmp 0x8e27
jmp 0x8e29
jmp 0x8e2b
jmp 0x8e2d
jmp 0x8e2f
jmp 0x8e31
jmp 0x8e33
jmp 0x8e35
jmp 0x8e37
jmp 0x7a70
movq -0x2e0(%rbp), %rdi
callq 0x1070
movb $0x0, 0xc5b9(%rip)      # 0x15408
movq 0xc57a(%rip), %rdi      # 0x153d0
callq 0x1170
movb -0xa9(%rbp), %al
andb $0x1, %al
addq $0x520, %rsp            # imm = 0x520
popq %rbp
retq
nopl (%rax)