// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3d8, %rsp            # imm = 0x3D8
movl %esi, 0x4(%rsp)
movq %rdi, %rbx
movb $0x0, 0x3(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x6e88
leaq 0x2be5(%rip), %rsi      # 0x859c
movq %rbx, 0x10(%rsp)
movq %rbx, %rdi
callq 0x11f0
testq %rax, %rax
je 0x6be2
movq %rax, %r15
leaq 0xd0(%rsp), %r12
leaq 0x3d83(%rip), %rbp      # 0x9762
leaq 0x30(%rsp), %r13
leaq 0x3d7b(%rip), %r14      # 0x9766
leaq 0x3d80(%rip), %rbx      # 0x9772
movq $0x0, 0x18(%rsp)
movl %eax, 0xc(%rsp)
movl %eax, 0x8(%rsp)
movq %r12, %rdi
movl $0x200, %esi            # imm = 0x200
movq %r15, %rdx
callq 0x1130
testq %rax, %rax
je 0x6bae
movq %r12, %rdi
callq 0x10c0
cmpq $0x1, %rax
sete %cl
movb 0xd0(%rsp), %al
cmpb $0xa, %al
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x5a73
movl $0xa, %edi
callq 0x1040
movw $0xa, 0x30(%rsp)
movq 0xd99a(%rip), %rsi      # 0x133f0
movl $0xa, %edi
callq 0x1120
movq 0xd989(%rip), %rdi      # 0x133f0
callq 0x11b0
movb 0xd0(%rsp), %al
cmpb $0x3a, %al
jne 0x5a03
movq %r12, %rdi
leaq 0x3d46(%rip), %rsi      # 0x97c7
callq 0x1200
movq 0xd983(%rip), %rdx      # 0x13410
movq %r13, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x1240
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x4d09
movq 0xd969(%rip), %rdx      # 0x13418
movq %r13, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x1240
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x4d09
movq 0xd94f(%rip), %rdx      # 0x13420
movq %r13, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x1240
movq %r12, %rdi
leaq 0x3c96(%rip), %rsi      # 0x977e
movq %r13, %rdx
callq 0x4d09
movdqa 0xd0(%rsp), %xmm0
pcmpeqb 0x3b6f(%rip), %xmm0     # 0x9670
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x5dbf
movq 0xd0(%rsp), %rax
movabsq $0x534143545345543a, %rcx # imm = 0x534143545345543A
xorq %rcx, %rax
movq 0xd6(%rsp), %rcx
movabsq $0x3a444e452d455341, %rdx # imm = 0x3A444E452D455341
xorq %rdx, %rcx
orq %rax, %rcx
je 0x5e94
movl 0xd0(%rsp), %eax
movl $0x5345443a, %ecx       # imm = 0x5345443A
xorl %ecx, %eax
movzwl 0xd4(%rsp), %ecx
xorl $0x3a43, %ecx           # imm = 0x3A43
orl %eax, %ecx
je 0x61a5
movl 0xd0(%rsp), %eax
movl $0x4554533a, %ecx       # imm = 0x4554533A
xorl %ecx, %eax
movzwl 0xd4(%rsp), %ecx
xorl $0x3a50, %ecx           # imm = 0x3A50
orl %eax, %ecx
je 0x6ae4
movl 0xd0(%rsp), %eax
movl $0x444d433a, %ecx       # imm = 0x444D433A
xorl %ecx, %eax
movzbl 0xd4(%rsp), %ecx
xorl $0x3a, %ecx
orl %eax, %ecx
je 0x6223
movq 0xd0(%rsp), %rax
movabsq $0x4e5245545441503a, %rcx # imm = 0x4E5245545441503A
xorq %rcx, %rax
movq 0xd7(%rsp), %rcx
movabsq $0x3a484354414d2d4e, %rdx # imm = 0x3A484354414D2D4E
xorq %rdx, %rcx
orq %rax, %rcx
leaq 0x3909(%rip), %rbp      # 0x94e9
je 0x6400
movdqu 0xd3(%rsp), %xmm0
pcmpeqb 0x3a89(%rip), %xmm0     # 0x9680
movdqa 0xd0(%rsp), %xmm1
pcmpeqb 0x3a88(%rip), %xmm1     # 0x9690
pand %xmm0, %xmm1
pmovmskb %xmm1, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x6531
movl 0xd0(%rsp), %eax
movl $0x454c533a, %ecx       # imm = 0x454C533A
xorl %ecx, %eax
movl 0xd3(%rsp), %ecx
movl $0x3a504545, %edx       # imm = 0x3A504545
xorl %edx, %ecx
orl %eax, %ecx
je 0x66b6
movl 0xd0(%rsp), %eax
movl $0x4f42413a, %ecx       # imm = 0x4F42413A
xorl %ecx, %eax
movl 0xd3(%rsp), %ecx
movl $0x3a54524f, %edx       # imm = 0x3A54524F
xorl %edx, %ecx
orl %eax, %ecx
je 0x6b76
movl 0xd0(%rsp), %eax
movl $0x5541503a, %ecx       # imm = 0x5541503A
xorl %ecx, %eax
movl 0xd3(%rsp), %ecx
movl $0x3a455355, %edx       # imm = 0x3A455355
xorl %edx, %ecx
orl %eax, %ecx
je 0x67ad
movl 0xd0(%rsp), %eax
movl $0x4552473a, %ecx       # imm = 0x4552473A
xorl %ecx, %eax
movzwl 0xd4(%rsp), %ecx
xorl $0x3a50, %ecx           # imm = 0x3A50
orl %eax, %ecx
leaq 0x3ab6(%rip), %rbp      # 0x9762
je 0x6861
movl 0xd0(%rsp), %eax
movl $0x4952503a, %ecx       # imm = 0x4952503A
xorl %ecx, %eax
movl 0xd3(%rsp), %ecx
movl $0x3a544e49, %edx       # imm = 0x3A544E49
xorl %edx, %ecx
orl %eax, %ecx
je 0x6951
movq 0xd0(%rsp), %rax
movabsq $0x4f54535f544e493a, %rdx # imm = 0x4F54535F544E493A
xorq %rdx, %rax
movl 0xd8(%rsp), %ecx
xorq $0x3a314552, %rcx       # imm = 0x3A314552
orq %rax, %rcx
je 0x69d0
movq 0xd0(%rsp), %rax
xorq %rdx, %rax
movl 0xd8(%rsp), %ecx
xorq $0x3a324552, %rcx       # imm = 0x3A324552
orq %rax, %rcx
leaq 0x3a4d(%rip), %rbx      # 0x9772
je 0x6a46
movq 0xd0(%rsp), %rax
xorq %rdx, %rax
movl 0xd8(%rsp), %ecx
xorq $0x3a334552, %rcx       # imm = 0x3A334552
orq %rax, %rcx
jne 0x5a03
movq %r12, %rdi
leaq 0x3792(%rip), %rbp      # 0x94e9
movq %rbp, %rsi
callq 0x1200
xorl %edi, %edi
movq %rbp, %rsi
callq 0x1200
movq %rax, %rdi
callq 0x1210
testl %eax, %eax
je 0x6c3f
movl %eax, %ebp
movl 0xdeaf(%rip), %esi      # 0x13c30
leaq 0xd6a8(%rip), %rdi      # 0x13430
movl %eax, %edx
callq 0x4f39
movq %rax, 0xd68a(%rip)      # 0x13420
leaq 0x3cab(%rip), %rdi      # 0x9a48
movq %rax, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x10e0
movq 0xd670(%rip), %rdx      # 0x13420
movq %r13, %rdi
leaq 0x3c8e(%rip), %rsi      # 0x9a48
jmp 0x6ab3
movl 0x4(%rsp), %r13d
testw %r13w, %r13w
setne %bl
movq %r12, %rdi
leaq 0x3714(%rip), %rbp      # 0x94e9
movq %rbp, %rsi
callq 0x1200
xorl %edi, %edi
movq %rbp, %rsi
callq 0x1200
movq %rax, %rdi
callq 0x1210
cmpw %r13w, %ax
setne %cl
andb %bl, %cl
cmpb $0x1, %cl
jne 0x6125
leaq 0x30(%rsp), %r13
leaq 0x3959(%rip), %r14      # 0x9766
leaq 0x395e(%rip), %rbx      # 0x9772
movq %r12, %rdi
movl $0x200, %esi            # imm = 0x200
movq %r15, %rdx
callq 0x1130
testq %rax, %rax
je 0x6bae
movq 0xd0(%rsp), %rax
movabsq $0x534143545345543a, %rcx # imm = 0x534143545345543A
xorq %rcx, %rax
movq 0xd8(%rsp), %rcx
movabsq $0x3a4e494745422d45, %rdx # imm = 0x3A4E494745422D45
xorq %rdx, %rcx
orq %rax, %rcx
jne 0x5e14
movq %r12, %rdi
leaq 0x3683(%rip), %rbp      # 0x94e9
movq %rbp, %rsi
callq 0x1200
xorl %edi, %edi
movq %rbp, %rsi
callq 0x1200
movq %rax, %rdi
callq 0x1210
cmpw 0x4(%rsp), %ax
jne 0x5e14
movl 0x4(%rsp), %ecx
movl %ecx, 0xc(%rsp)
jmp 0x613c
movq %r15, 0xb8(%rsp)
movq %r12, %rdi
leaq 0x3643(%rip), %r14      # 0x94e9
movq %r14, %rsi
callq 0x1200
movq %r13, %rbx
xorl %r13d, %r13d
xorl %edi, %edi
movq %r14, %rsi
callq 0x1200
movzwl 0xc(%rsp), %ecx
movq %rbx, %rdi
leaq 0x390b(%rip), %rsi      # 0x97d8
movq 0x10(%rsp), %rdx
xorl %eax, %eax
callq 0x1240
movl %eax, %ebp
leaq 0x31ee(%rip), %r14      # 0x90d0
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10e0
movslq %ebp, %rdx
movq 0xd4f7(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1260
movdqu 0x3bc7(%rip), %xmm0     # 0x9ad5
movdqa %xmm0, 0x2d0(%rsp)
movabsq $0xa2a2a2a2a2a2a, %rax  # imm = 0xA2A2A2A2A2A2A
movq %rax, 0x2de(%rsp)
movq %r14, %rdi
leaq 0x2d0(%rsp), %r14
movq %r14, %rsi
xorl %eax, %eax
callq 0x10e0
movq 0xd4ab(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movl $0x15, %edx
movq %r14, %rdi
callq 0x1260
movq 0x28(%rsp), %r15
movl $0x0, %r12d
movl $0x0, %ebp
testq %r15, %r15
leaq 0x3b8d(%rip), %rcx      # 0x9afe
leaq 0x3b94(%rip), %rdx      # 0x9b0c
leaq 0x3bef(%rip), %rsi      # 0x9b6e
leaq 0x3be3(%rip), %rbx      # 0x9b69
leaq 0x3b5e(%rip), %rax      # 0x9aeb
je 0x6055
xorl %ebp, %ebp
xorl %r12d, %r12d
xorl %r13d, %r13d
movq %r13, 0xc8(%rsp)
movq 0x8(%r15), %r8
movq %r8, 0xc0(%rsp)
cmpb $0x0, -0x5(%r15)
movq %rdx, %r13
cmovneq %rcx, %rdx
cmpb $0x0, -0x6(%r15)
movzwl -0x8(%r15), %ecx
movq %rbx, %r8
cmovneq %rsi, %r8
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x1240
movl %eax, %r14d
leaq 0x30ed(%rip), %rdi      # 0x90d0
leaq 0x2d0(%rsp), %rsi
xorl %eax, %eax
callq 0x10e0
movslq %r14d, %rdx
leaq 0x2d0(%rsp), %r14
movq 0xd3ec(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movq %r14, %rdi
callq 0x1260
leaq 0x3b56(%rip), %rsi      # 0x9b6e
movq %r13, %rdx
movq 0xc8(%rsp), %r13
leaq 0x3ad4(%rip), %rcx      # 0x9afe
movzbl -0x6(%r15), %eax
addl %eax, %r13d
xorl $0x1, %eax
addl %eax, %r12d
leaq 0x3aac(%rip), %rax      # 0x9aeb
incl %ebp
movq 0xc0(%rsp), %r8
movq %r8, %r15
testq %r8, %r8
jne 0x5f9b
leaq 0x3ac4(%rip), %rbx      # 0x9b20
movq %rbx, %rdi
movl %ebp, %esi
movl %r13d, %edx
movl %r12d, %ecx
xorl %eax, %eax
callq 0x10e0
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl %r13d, %ecx
movl %r12d, %r8d
xorl %eax, %eax
callq 0x1240
movslq %eax, %rdx
movq 0xd363(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movq %r14, %rdi
callq 0x1260
movq 0xd34f(%rip), %rdi      # 0x133f0
callq 0x11b0
movq 0x28(%rsp), %r12
testq %r12, %r12
je 0x60d1
movq 0x8(%r12), %rbx
movq %r12, %rdi
callq 0x6ebe
addq $-0x8, %r12
movq %r12, %rdi
callq 0x1030
movq %rbx, %r12
testq %rbx, %rbx
jne 0x60b0
movq 0xd318(%rip), %rdi      # 0x133f0
callq 0x11b0
cmpw $0x0, 0x4(%rsp)
movq 0xb8(%rsp), %r15
leaq 0xd0(%rsp), %r12
leaq 0x3668(%rip), %rbp      # 0x9762
leaq 0x30(%rsp), %r13
leaq 0x3660(%rip), %r14      # 0x9766
leaq 0x3665(%rip), %rbx      # 0x9772
je 0x5a03
cmpb $0x0, 0xd30e(%rip)      # 0x13428
je 0x5a03
jmp 0x6bae
movl %eax, 0xc(%rsp)
leaq 0x30(%rsp), %r13
leaq 0x3631(%rip), %r14      # 0x9766
leaq 0x3636(%rip), %rbx      # 0x9772
movzwl %ax, %ecx
movq %r13, %rdi
leaq 0x3652(%rip), %rsi      # 0x979b
movq 0x10(%rsp), %rdx
xorl %eax, %eax
callq 0x1240
movl %eax, %ebp
leaq 0x2f72(%rip), %rdi      # 0x90d0
movq %r13, %rsi
xorl %eax, %eax
callq 0x10e0
movslq %ebp, %rdx
movq 0xd27e(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movq %r13, %rdi
callq 0x1260
movq 0xd26a(%rip), %rdi      # 0x133f0
callq 0x11b0
movb $0x1, 0xd296(%rip)      # 0x13428
movb $0x1, %al
movq %rax, 0x18(%rsp)
leaq 0x35c2(%rip), %rbp      # 0x9762
jmp 0x5a03
movq %r12, %rdi
leaq 0x333a(%rip), %rbx      # 0x94e9
movq %rbx, %rsi
callq 0x1200
xorl %edi, %edi
movq %rbx, %rsi
callq 0x1200
movq %r13, %rdi
leaq 0x3641(%rip), %rsi      # 0x980c
movq %rax, %rdx
xorl %eax, %eax
callq 0x1240
movq %r14, %rbx
movq %rbp, %r14
movl %eax, %ebp
leaq 0x2eec(%rip), %rdi      # 0x90d0
movq %r13, %rsi
xorl %eax, %eax
callq 0x10e0
movslq %ebp, %rdx
movq %r14, %rbp
movq %rbx, %r14
leaq 0x3574(%rip), %rbx      # 0x9772
movq 0xd1eb(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movq %r13, %rdi
callq 0x1260
movq 0xd1d7(%rip), %rdi      # 0x133f0
callq 0x11b0
jmp 0x5a03
movq %r12, %rbx
movq %r12, %rdi
leaq 0x32b9(%rip), %r12      # 0x94e9
movq %r12, %rsi
callq 0x1200
xorl %edi, %edi
movq %r12, %rsi
callq 0x1200
movq %rax, %r12
movq %r13, %rdi
leaq 0x35e7(%rip), %rsi      # 0x9836
movq %rax, %rdx
xorl %eax, %eax
callq 0x1240
movl %eax, %ebp
leaq 0x2e6e(%rip), %rdi      # 0x90d0
movq %r13, %rsi
xorl %eax, %eax
callq 0x10e0
movslq %ebp, %rdx
movq 0xd17a(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movq %r13, %rdi
callq 0x1260
movq 0xd166(%rip), %rdi      # 0x133f0
callq 0x11b0
movq %r12, %rdi
callq 0x10c0
movq %r12, %rdi
movl %eax, %esi
leaq 0x3(%rsp), %rdx
callq 0x360d
testl %eax, %eax
jne 0x6c01
movq %r12, %rdi
callq 0x10c0
movq %r12, %rdi
movl %eax, %esi
leaq 0x218b(%rip), %rdx      # 0x844d
callq 0x4e43
testb %al, %al
movq %rbx, %r12
leaq 0x348f(%rip), %rbp      # 0x9762
leaq 0x348c(%rip), %r14      # 0x9766
leaq 0x3491(%rip), %rbx      # 0x9772
je 0x6212
cmpb $0x1, 0xd13a(%rip)      # 0x13428
jne 0x6212
cmpb $0x1, 0xd12e(%rip)      # 0x13429
jne 0x6341
movups 0x3559(%rip), %xmm0     # 0x985d
movups %xmm0, 0x3a(%rsp)
movdqu 0x3542(%rip), %xmm0     # 0x9853
movdqa %xmm0, 0x30(%rsp)
leaq 0x2db2(%rip), %rdi      # 0x90d0
movq %r13, %rsi
xorl %eax, %eax
callq 0x10e0
movq 0xd0c1(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movl $0x19, %edx
movq %r13, %rdi
callq 0x1260
movl 0xd0b1(%rip), %edi      # 0x133f8
movl $0x800, %edx            # imm = 0x800
leaq 0xd0dd(%rip), %rsi      # 0x13430
xorl %ecx, %ecx
leaq 0xd0a4(%rip), %r8       # 0x13400
callq 0x10b0
movl %eax, 0xd8c9(%rip)      # 0x13c30
cmpl $-0x1, %eax
je 0x67f4
cmpb $0x1, 0xd0b2(%rip)      # 0x13429
jne 0x6212
leaq 0x37ef(%rip), %rdi      # 0x9b73
callq 0x1080
leaq 0xd0a0(%rip), %rdi      # 0x13430
callq 0x1080
movups 0x34ff(%rip), %xmm0     # 0x989b
movaps %xmm0, 0x30(%rsp)
movdqu 0x3501(%rip), %xmm0     # 0x98aa
movdqu %xmm0, 0x3f(%rsp)
movq 0xd03a(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movl $0x1e, %edx
movq %r13, %rdi
callq 0x1260
movslq 0xd861(%rip), %rdx      # 0x13c30
decq %rdx
movq 0xd017(%rip), %rcx      # 0x133f0
movl $0x1, %esi
leaq 0xd04b(%rip), %rdi      # 0x13430
callq 0x1260
movq 0xcfff(%rip), %rsi      # 0x133f0
movl $0xa, %edi
callq 0x1120
jmp 0x683f
movq %r12, %rdi
movq %rbp, %rsi
callq 0x1200
xorl %edi, %edi
movq %rbp, %rsi
callq 0x1200
leaq 0x2d0(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10a0
movq %rax, %r12
subl %ebx, %r12d
xorl %edi, %edi
movq %rbp, %rsi
callq 0x1200
testq %rax, %rax
je 0x6471
leaq 0x3486(%rip), %rbx      # 0x98ca
movslq %r12d, %r12
leaq (%rsp,%r12), %rdi
addq $0x2d0, %rdi            # imm = 0x2D0
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1240
addl %eax, %r12d
xorl %edi, %edi
movq %rbp, %rsi
callq 0x1200
testq %rax, %rax
jne 0x6444
leaq 0x3456(%rip), %rdi      # 0x98ce
leaq 0x2d0(%rsp), %rbp
movq %rbp, %rsi
xorl %eax, %eax
callq 0x10e0
movups 0x345b(%rip), %xmm0     # 0x98ec
movaps %xmm0, 0x30(%rsp)
movdqu 0x3458(%rip), %xmm0     # 0x98f6
movdqu %xmm0, 0x3a(%rsp)
movq 0xcf45(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movl $0x19, %edx
movq %r13, %rdi
callq 0x1260
movslq %r12d, %rdx
movq 0xcf29(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movq %rbp, %rdi
callq 0x1260
movw $0xa7c, 0x30(%rsp)      # imm = 0xA7C
movb $0x0, 0x32(%rsp)
movq 0xcf09(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movl $0x2, %edx
movq %r13, %rdi
callq 0x1260
movl 0xd731(%rip), %esi      # 0x13c30
leaq 0xcf2a(%rip), %rdi      # 0x13430
movq %rbp, %rdx
callq 0x4e43
movl %eax, %ebp
testb %al, %al
je 0x6662
leaq 0x364f(%rip), %rdi      # 0x9b6e
callq 0x1080
movl $0x53534150, 0x30(%rsp) # imm = 0x53534150
jmp 0x6676
movq %r12, %rdi
movq %rbp, %rsi
callq 0x1200
xorl %edi, %edi
movq %rbp, %rsi
callq 0x1200
leaq 0x2d0(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10a0
movq %rax, %r12
subl %ebx, %r12d
xorl %edi, %edi
movq %rbp, %rsi
callq 0x1200
testq %rax, %rax
je 0x65a2
leaq 0x3355(%rip), %rbx      # 0x98ca
movslq %r12d, %r12
leaq (%rsp,%r12), %rdi
addq $0x2d0, %rdi            # imm = 0x2D0
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1240
addl %eax, %r12d
xorl %edi, %edi
movq %rbp, %rsi
callq 0x1200
testq %rax, %rax
jne 0x6575
leaq 0x337d(%rip), %rdi      # 0x9926
leaq 0x2d0(%rsp), %rbp
movq %rbp, %rsi
xorl %eax, %eax
callq 0x10e0
movups 0x3386(%rip), %xmm0     # 0x9948
movaps %xmm0, 0x30(%rsp)
movdqu 0x3387(%rip), %xmm0     # 0x9956
movdqu %xmm0, 0x3e(%rsp)
movq 0xce14(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movl $0x1d, %edx
movq %r13, %rdi
callq 0x1260
movslq %r12d, %rdx
movq 0xcdf8(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movq %rbp, %rdi
callq 0x1260
movw $0xa7c, 0x30(%rsp)      # imm = 0xA7C
movb $0x0, 0x32(%rsp)
movq 0xcdd8(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movl $0x2, %edx
movq %r13, %rdi
callq 0x1260
movl 0xd600(%rip), %esi      # 0x13c30
leaq 0xcdf9(%rip), %rdi      # 0x13430
movq %rbp, %rdx
callq 0x4e43
movl %eax, %ebp
testb %al, %al
je 0x6739
leaq 0x3519(%rip), %rdi      # 0x9b69
callq 0x1080
movl $0x4c494146, 0x30(%rsp) # imm = 0x4C494146
jmp 0x674d
leaq 0x3500(%rip), %rdi      # 0x9b69
callq 0x1080
movl $0x4c494146, 0x30(%rsp) # imm = 0x4C494146
movw $0xa, 0x34(%rsp)
leaq 0xd0(%rsp), %r12
movq 0xcd64(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movl $0x5, %edx
movq %r13, %rdi
callq 0x1260
movzwl 0x8(%rsp), %esi
movzbl %bpl, %edx
leaq 0x20(%rsp), %rdi
movl $0x1, %ecx
jmp 0x6789
movq %r12, %rdi
movq %rbp, %rsi
callq 0x1200
xorl %edi, %edi
movq %rbp, %rsi
callq 0x1200
movq %r12, %rbx
movq %rax, %r12
movq %r13, %rdi
leaq 0x3293(%rip), %rsi      # 0x996e
movq %rax, %rdx
xorl %eax, %eax
callq 0x1240
movl %eax, %ebp
leaq 0x29e2(%rip), %rdi      # 0x90d0
movq %r13, %rsi
xorl %eax, %eax
callq 0x10e0
movslq %ebp, %rdx
movq 0xccee(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movq %r13, %rdi
callq 0x1260
movq 0xccda(%rip), %rdi      # 0x133f0
callq 0x11b0
movq %r12, %rdi
movq %rbx, %r12
callq 0x1210
movl %eax, %edi
callq 0x1270
leaq 0x303e(%rip), %rbx      # 0x9772
jmp 0x6199
leaq 0x342e(%rip), %rdi      # 0x9b6e
callq 0x1080
movl $0x53534150, 0x30(%rsp) # imm = 0x53534150
movw $0xa, 0x34(%rsp)
leaq 0xd0(%rsp), %r12
xorb $0x1, %bpl
movq 0xcc89(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movl $0x5, %edx
movq %r13, %rdi
callq 0x1260
movzwl 0x8(%rsp), %esi
movzbl %bpl, %edx
leaq 0x20(%rsp), %rdi
xorl %ecx, %ecx
callq 0x6c7d
movq 0xcc5b(%rip), %rdi      # 0x133f0
callq 0x11b0
leaq 0x2fc1(%rip), %rbp      # 0x9762
leaq 0x2fca(%rip), %rbx      # 0x9772
jmp 0x5a03
leaq 0x33a6(%rip), %rdi      # 0x9b5a
callq 0x1080
movabsq $0xa646573756150, %rax  # imm = 0xA646573756150
movq %rax, 0x30(%rsp)
movq 0xcc21(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movl $0x7, %edx
movq %r13, %rdi
callq 0x1260
movq 0xcc08(%rip), %rdi      # 0x133f0
callq 0x11b0
callq 0x1150
jmp 0x679a
leaq 0x3396(%rip), %rdi      # 0x9b91
callq 0x1080
movups 0x3066(%rip), %xmm0     # 0x986d
movaps %xmm0, 0x30(%rsp)
movups 0x306a(%rip), %xmm0     # 0x987d
movaps %xmm0, 0x40(%rsp)
movdqu 0x306b(%rip), %xmm0     # 0x988b
movdqu %xmm0, 0x4e(%rsp)
movq 0xcbc3(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movl $0x2d, %edx
movq %r13, %rdi
callq 0x1260
leaq 0xcbea(%rip), %rdi      # 0x13430
movl $0x0, 0xd3e0(%rip)      # 0x13c30
movl $0x800, %edx            # imm = 0x800
xorl %esi, %esi
callq 0x1100
jmp 0x6212
movq %r12, %rdi
leaq 0x2c7e(%rip), %rbx      # 0x94e9
movq %rbx, %rsi
callq 0x1200
xorl %edi, %edi
movq %rbx, %rsi
callq 0x1200
movq %r14, %rbp
movq %rax, %r14
leaq 0x3119(%rip), %rbx      # 0x99a3
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x10e0
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1240
movslq %eax, %rdx
movq 0xcb3f(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movq %r13, %rdi
callq 0x1260
movl 0xd36c(%rip), %esi      # 0x13c30
leaq 0xcb65(%rip), %rbx      # 0x13430
movq %rbx, %rdi
movq %r14, %rdx
movq %rbp, %r14
leaq 0x2e87(%rip), %rbp      # 0x9762
callq 0x4e5e
movl %eax, 0xd34a(%rip)      # 0x13c30
leaq 0x3258(%rip), %rdi      # 0x9b45
callq 0x1080
leaq 0x27d7(%rip), %rdi      # 0x90d0
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10e0
movabsq $0xa203a20706572, %rax  # imm = 0xA203A20706572
movq %rax, 0x3e(%rsp)
movdqu 0x309c(%rip), %xmm0     # 0x99b6
movdqa %xmm0, 0x30(%rsp)
movq 0xcac9(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movl $0x15, %edx
movq %r13, %rdi
callq 0x1260
movslq 0xd2f0(%rip), %rdx      # 0x13c30
movq 0xcaa9(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movq %rbx, %rdi
jmp 0x69b3
movq %r12, %rdi
leaq 0x2b8e(%rip), %rbx      # 0x94e9
movq %rbx, %rsi
callq 0x1200
xorl %edi, %edi
movq %rbx, %rsi
callq 0x1200
movq %r14, %rbp
movq %rax, %r14
leaq 0x305a(%rip), %rbx      # 0x99d4
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x10e0
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %rbp, %r14
leaq 0x2dc8(%rip), %rbp      # 0x9762
xorl %eax, %eax
callq 0x1240
movslq %eax, %rdx
movq 0xca45(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movq %r13, %rdi
callq 0x1260
movq 0xca31(%rip), %rdi      # 0x133f0
callq 0x11b0
leaq 0x2da7(%rip), %rbx      # 0x9772
jmp 0x5a03
movq %r12, %rdi
leaq 0x2b0f(%rip), %rbx      # 0x94e9
movq %rbx, %rsi
callq 0x1200
xorl %edi, %edi
movq %rbx, %rsi
callq 0x1200
movq %rax, %rdi
callq 0x1210
testl %eax, %eax
leaq 0x2d75(%rip), %rbx      # 0x9772
je 0x6c20
movl %eax, %ebp
movl 0xd225(%rip), %esi      # 0x13c30
leaq 0xca1e(%rip), %rdi      # 0x13430
movl %eax, %edx
callq 0x4f39
movq %rax, 0xc9f0(%rip)      # 0x13410
leaq 0x2fcb(%rip), %rdi      # 0x99f2
movq %rax, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x10e0
movq 0xc9d6(%rip), %rdx      # 0x13410
movq %r13, %rdi
leaq 0x2fae(%rip), %rsi      # 0x99f2
jmp 0x6ab3
movq %r12, %rdi
leaq 0x2a99(%rip), %rbp      # 0x94e9
movq %rbp, %rsi
callq 0x1200
xorl %edi, %edi
movq %rbp, %rsi
callq 0x1200
movq %rax, %rdi
callq 0x1210
testl %eax, %eax
je 0x6c5e
movl %eax, %ebp
movl 0xd1b6(%rip), %esi      # 0x13c30
leaq 0xc9af(%rip), %rdi      # 0x13430
movl %eax, %edx
callq 0x4f39
movq %rax, 0xc989(%rip)      # 0x13418
leaq 0x2f87(%rip), %rdi      # 0x9a1d
movq %rax, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x10e0
movq 0xc96f(%rip), %rdx      # 0x13418
movq %r13, %rdi
leaq 0x2f6a(%rip), %rsi      # 0x9a1d
movl %ebp, %ecx
xorl %eax, %eax
callq 0x1240
movslq %eax, %rdx
movq 0xc92a(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movq %r13, %rdi
callq 0x1260
movq 0xc916(%rip), %rdi      # 0x133f0
callq 0x11b0
jmp 0x6199
movq %r12, %rdi
leaq 0x29fb(%rip), %r14      # 0x94e9
movq %r14, %rsi
callq 0x1200
xorl %edi, %edi
movq %r14, %rsi
callq 0x1200
movq %r12, %r14
movq %rax, %r12
movq %r13, %rdi
leaq 0x2d15(%rip), %rsi      # 0x9825
movq %rax, %rdx
xorl %eax, %eax
callq 0x1240
movq %rbp, %r13
movl %eax, %ebp
leaq 0x25aa(%rip), %rdi      # 0x90d0
leaq 0x30(%rsp), %rsi
xorl %eax, %eax
callq 0x10e0
movslq %ebp, %rdx
movq %r13, %rbp
movq 0xc8b1(%rip), %rcx      # 0x133f0
movl $0x1, %esi
leaq 0x30(%rsp), %rdi
callq 0x1260
movq 0xc89b(%rip), %rdi      # 0x133f0
callq 0x11b0
movq %r12, %rdi
movq %r14, %r12
leaq 0x2bff(%rip), %r14      # 0x9766
leaq 0x30(%rsp), %r13
callq 0x1210
jmp 0x59ff
leaq 0x2fe4(%rip), %rdi      # 0x9b61
callq 0x1080
movabsq $0xa646574726f6241, %rax # imm = 0xA646574726F6241
leaq 0x30(%rsp), %rdi
movq %rax, (%rdi)
movb $0x0, 0x8(%rdi)
movq 0xc851(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movl $0x8, %edx
callq 0x1260
movq %r15, %rdi
callq 0x1090
movb $0x0, 0xc86b(%rip)      # 0x13428
movq 0xc82c(%rip), %rdi      # 0x133f0
callq 0x11b0
movq 0x18(%rsp), %rax
andb $0x1, %al
addq $0x3d8, %rsp            # imm = 0x3D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2b50(%rip), %rdi      # 0x9739
leaq 0x2ae5(%rip), %rsi      # 0x96d5
leaq 0x2b45(%rip), %rcx      # 0x973c
movl $0x99, %edx
callq 0x10f0
leaq 0x2c38(%rip), %rdi      # 0x9840
leaq 0x2ac6(%rip), %rsi      # 0x96d5
leaq 0x2b26(%rip), %rcx      # 0x973c
movl $0x10b, %edx            # imm = 0x10B
callq 0x10f0
leaq 0x2dc5(%rip), %rdi      # 0x99ec
leaq 0x2aa7(%rip), %rsi      # 0x96d5
leaq 0x2b07(%rip), %rcx      # 0x973c
movl $0x1c3, %edx            # imm = 0x1C3
callq 0x10f0
leaq 0x2da6(%rip), %rdi      # 0x99ec
leaq 0x2a88(%rip), %rsi      # 0x96d5
leaq 0x2ae8(%rip), %rcx      # 0x973c
movl $0x1e1, %edx            # imm = 0x1E1
callq 0x10f0
leaq 0x2d87(%rip), %rdi      # 0x99ec
leaq 0x2a69(%rip), %rsi      # 0x96d5
leaq 0x2ac9(%rip), %rcx      # 0x973c
movl $0x1d2, %edx            # imm = 0x1D2
callq 0x10f0