// File: /workspace/github_c_makefile_star2_O1/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, 0xc(%rsp)
movq %rdi, %rbx
movb $0x0, 0x3(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x6fc0
leaq 0x2a92(%rip), %rsi      # 0x859c
movq %rbx, 0x98(%rsp)
movq %rbx, %rdi
callq 0x11f0
testq %rax, %rax
je 0x6d19
movq %rax, %r15
leaq 0xd0(%rsp), %r14
movabsq $0x3a4e494745422d45, %rbp # imm = 0x3A4E494745422D45
leaq 0x3c67(%rip), %r13      # 0x97a6
movq $0x0, 0xa0(%rsp)
movl %eax, 0x8(%rsp)
movl %eax, 0x4(%rsp)
movq %r14, %rdi
movl $0x200, %esi            # imm = 0x200
movq %r15, %rdx
callq 0x1130
testq %rax, %rax
je 0x6ce2
movq %r14, %rdi
callq 0x10c0
cmpq $0x1, %rax
jne 0x5bb2
cmpb $0xa, 0xd0(%rsp)
jne 0x5bb2
movl $0xa, %edi
callq 0x1040
movw $0xa, 0x10(%rsp)
movq 0xd854(%rip), %rsi      # 0x133f0
movl $0xa, %edi
callq 0x1120
movq 0xd843(%rip), %rdi      # 0x133f0
callq 0x11b0
cmpb $0x3a, 0xd0(%rsp)
jne 0x5b53
movq %r14, %rdi
leaq 0x3c41(%rip), %rsi      # 0x9807
callq 0x1200
movq 0xd83e(%rip), %rdx      # 0x13410
leaq 0x10(%rsp), %r12
movq %r12, %rdi
leaq 0x3bc1(%rip), %rbx      # 0x97a2
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1240
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x4e50
movq 0xd818(%rip), %rdx      # 0x13418
movq %r12, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1240
movq %r14, %rdi
leaq 0x3b9b(%rip), %rsi      # 0x97b2
movq %r12, %rdx
callq 0x4e50
movq 0xd7fa(%rip), %rdx      # 0x13420
movq %r12, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1240
movq %r14, %rdi
leaq 0x3b81(%rip), %rsi      # 0x97be
movq %r12, %rdx
callq 0x4e50
movdqa 0xd0(%rsp), %xmm0
pcmpeqb 0x3a5a(%rip), %xmm0     # 0x96b0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x5f16
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 0x5ffd
movl 0xd0(%rsp), %eax
movl $0x5345443a, %ecx       # imm = 0x5345443A
xorl %ecx, %eax
movzwl 0xd4(%rsp), %ecx
xorl $0x3a43, %ecx           # imm = 0x3A43
orl %eax, %ecx
leaq 0x3869(%rip), %r12      # 0x9526
je 0x631f
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 0x6c22
movl 0xd0(%rsp), %eax
movl $0x444d433a, %ecx       # imm = 0x444D433A
xorl %ecx, %eax
movzbl 0xd4(%rsp), %ecx
xorl $0x3a, %ecx
orl %eax, %ecx
je 0x638e
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
je 0x656d
movdqu 0xd3(%rsp), %xmm0
pcmpeqb 0x3974(%rip), %xmm0     # 0x96c0
movdqa 0xd0(%rsp), %xmm1
pcmpeqb 0x3973(%rip), %xmm1     # 0x96d0
pand %xmm0, %xmm1
pmovmskb %xmm1, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x66a4
movq %rbp, %rbx
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 0x682e
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 0x6caa
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 0x6921
movl 0xd0(%rsp), %eax
movl $0x4552473a, %ecx       # imm = 0x4552473A
xorl %ecx, %eax
movzwl 0xd4(%rsp), %ecx
xorl $0x3a50, %ecx           # imm = 0x3A50
orl %eax, %ecx
movq %rbx, %rbp
je 0x69db
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 0x6abb
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 0x6b0b
movq 0xd0(%rsp), %rax
xorq %rdx, %rax
movl 0xd8(%rsp), %ecx
xorq $0x3a324552, %rcx       # imm = 0x3A324552
orq %rax, %rcx
je 0x6b7d
movq 0xd0(%rsp), %rax
xorq %rdx, %rax
movl 0xd8(%rsp), %ecx
xorq $0x3a334552, %rcx       # imm = 0x3A334552
orq %rax, %rcx
jne 0x5b53
movq %r14, %rbx
movq %r14, %rdi
leaq 0x367f(%rip), %r14      # 0x9526
movq %r14, %rsi
callq 0x1200
xorl %edi, %edi
movq %r14, %rsi
callq 0x1200
movq %rax, %rdi
callq 0x1210
testl %eax, %eax
je 0x6d76
movl %eax, %r14d
movl 0xdd5e(%rip), %esi      # 0x13c30
leaq 0xd557(%rip), %rdi      # 0x13430
movl %eax, %edx
callq 0x5081
movq %rax, 0xd539(%rip)      # 0x13420
leaq 0x3b9a(%rip), %rdi      # 0x9a88
movq %rax, %rsi
movl %r14d, %edx
xorl %eax, %eax
callq 0x10e0
movq 0xd51e(%rip), %rdx      # 0x13420
leaq 0x10(%rsp), %r12
movq %r12, %rdi
leaq 0x3b77(%rip), %rsi      # 0x9a88
jmp 0x6bed
movq %rbp, %r12
movl 0xc(%rsp), %r13d
testw %r13w, %r13w
setne %bpl
movq %r14, %rdi
leaq 0x35f6(%rip), %rbx      # 0x9526
movq %rbx, %rsi
callq 0x1200
xorl %edi, %edi
movq %rbx, %rsi
callq 0x1200
movq %rax, %rdi
callq 0x1210
movl %eax, 0x8(%rsp)
cmpw %r13w, %ax
setne %bl
andb %bpl, %bl
cmpb $0x1, %bl
jne 0x6294
movq %r12, %rbp
leaq 0x383b(%rip), %r13      # 0x97a6
movq %r14, %rdi
movl $0x200, %esi            # imm = 0x200
movq %r15, %rdx
callq 0x1130
testq %rax, %rax
je 0x62a0
movq 0xd0(%rsp), %rax
movabsq $0x534143545345543a, %rcx # imm = 0x534143545345543A
xorq %rcx, %rax
movq 0xd8(%rsp), %rcx
xorq %rbp, %rcx
orq %rax, %rcx
jne 0x5f6b
movl 0xc(%rsp), %r13d
testw %r13w, %r13w
setne %bpl
movq %r14, %rdi
leaq 0x3566(%rip), %rbx      # 0x9526
movq %rbx, %rsi
callq 0x1200
xorl %edi, %edi
movq %rbx, %rsi
callq 0x1200
movq %rax, %rdi
callq 0x1210
movl %eax, 0x8(%rsp)
cmpw %r13w, %ax
leaq 0x37bd(%rip), %r13      # 0x97a6
setne %bl
andb %bpl, %bl
movq %r12, %rbp
jne 0x5f6b
jmp 0x62a9
movq %r15, 0xb8(%rsp)
movq %r14, %rdi
leaq 0x3517(%rip), %r14      # 0x9526
movq %r14, %rsi
callq 0x1200
xorl %r13d, %r13d
xorl %edi, %edi
movq %r14, %rsi
callq 0x1200
movzwl 0x8(%rsp), %ecx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
leaq 0x37e0(%rip), %rsi      # 0x9818
movq 0x98(%rsp), %rdx
xorl %eax, %eax
callq 0x1240
movl %eax, %r14d
leaq 0x30bf(%rip), %rbx      # 0x9110
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x10e0
movslq %r14d, %rdx
movq 0xd388(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movq %r15, %rdi
callq 0x1260
movdqu 0x3a98(%rip), %xmm0     # 0x9b15
movdqa %xmm0, 0x2d0(%rsp)
movabsq $0xa2a2a2a2a2a2a, %rax  # imm = 0xA2A2A2A2A2A2A
movq %rax, 0x2de(%rsp)
movq %rbx, %rdi
leaq 0x2d0(%rsp), %rbp
movq %rbp, %rsi
xorl %eax, %eax
callq 0x10e0
movq 0xd33c(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movl $0x15, %edx
movq %rbp, %rdi
callq 0x1260
movq 0xb0(%rsp), %r15
movl $0x0, %r14d
movl $0x0, %r12d
testq %r15, %r15
leaq 0x3a5a(%rip), %rcx      # 0x9b3e
leaq 0x3a61(%rip), %rdx      # 0x9b4c
leaq 0x3abc(%rip), %rsi      # 0x9bae
leaq 0x3ab0(%rip), %rbx      # 0x9ba9
leaq 0x3a2b(%rip), %rax      # 0x9b2b
je 0x61c9
xorl %r12d, %r12d
xorl %r14d, %r14d
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 %rbp, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x1240
movl %eax, %ebp
leaq 0x2fba(%rip), %rdi      # 0x9110
leaq 0x2d0(%rsp), %rsi
xorl %eax, %eax
callq 0x10e0
movslq %ebp, %rdx
leaq 0x2d0(%rsp), %rbp
movq 0xd279(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movq %rbp, %rdi
callq 0x1260
leaq 0x3a23(%rip), %rsi      # 0x9bae
movq %r13, %rdx
movq 0xc8(%rsp), %r13
leaq 0x39a1(%rip), %rcx      # 0x9b3e
movzbl -0x6(%r15), %eax
addl %eax, %r13d
xorl $0x1, %eax
addl %eax, %r14d
leaq 0x3979(%rip), %rax      # 0x9b2b
incl %r12d
movq 0xc0(%rsp), %r8
movq %r8, %r15
testq %r8, %r8
jne 0x610f
leaq 0x3990(%rip), %rbx      # 0x9b60
movq %rbx, %rdi
movl %r12d, %esi
movl %r13d, %edx
movl %r14d, %ecx
xorl %eax, %eax
callq 0x10e0
movq %rbp, %rdi
movq %rbx, %rsi
movl %r12d, %edx
movl %r13d, %ecx
movl %r14d, %r8d
xorl %eax, %eax
callq 0x1240
movslq %eax, %rdx
movq 0xd1ed(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movq %rbp, %rdi
callq 0x1260
movq 0xd1d9(%rip), %rdi      # 0x133f0
callq 0x11b0
movq 0xb0(%rsp), %r14
testq %r14, %r14
je 0x6249
movq 0x8(%r14), %rbx
movq %r14, %rdi
callq 0x6ffa
addq $-0x8, %r14
movq %r14, %rdi
callq 0x1030
movq %rbx, %r14
testq %rbx, %rbx
jne 0x6229
movq 0xd1a0(%rip), %rdi      # 0x133f0
callq 0x11b0
cmpw $0x0, 0xc(%rsp)
movq 0xb8(%rsp), %r15
leaq 0xd0(%rsp), %r14
movabsq $0x3a4e494745422d45, %rbp # imm = 0x3A4E494745422D45
leaq 0x352a(%rip), %r13      # 0x97a6
je 0x5b53
cmpb $0x0, 0xd19f(%rip)      # 0x13428
je 0x5b53
jmp 0x6ce2
movq %r12, %rbp
leaq 0x3508(%rip), %r13      # 0x97a6
jmp 0x62a9
testb $0x1, %bl
jne 0x6ce2
movzwl 0x8(%rsp), %ecx
leaq 0x10(%rsp), %r12
movq %r12, %rdi
leaq 0x351e(%rip), %rsi      # 0x97db
movq 0x98(%rsp), %rdx
xorl %eax, %eax
callq 0x1240
movq %r14, %rbx
movl %eax, %r14d
leaq 0x2e37(%rip), %rdi      # 0x9110
movq %r12, %rsi
xorl %eax, %eax
callq 0x10e0
movslq %r14d, %rdx
movq %rbx, %r14
movq 0xd100(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movq %r12, %rdi
callq 0x1260
movq 0xd0ec(%rip), %rdi      # 0x133f0
callq 0x11b0
movb $0x1, 0xd118(%rip)      # 0x13428
movb $0x1, %al
movq %rax, 0xa0(%rsp)
jmp 0x5b53
movq %r14, %rdi
movq %r12, %rsi
callq 0x1200
xorl %edi, %edi
movq %r12, %rsi
callq 0x1200
leaq 0x10(%rsp), %r12
movq %r12, %rdi
leaq 0x3509(%rip), %rsi      # 0x984c
movq %rax, %rdx
xorl %eax, %eax
callq 0x1240
movq %rbp, %rbx
movl %eax, %ebp
leaq 0x2db7(%rip), %rdi      # 0x9110
movq %r12, %rsi
xorl %eax, %eax
callq 0x10e0
movslq %ebp, %rdx
movq %rbx, %rbp
movq 0xd080(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movq %r12, %rdi
callq 0x1260
movq 0xd06c(%rip), %rdi      # 0x133f0
callq 0x11b0
jmp 0x5b53
movq %r12, %r13
movq %rbp, %r12
movq %r14, %rbx
movq %r14, %rdi
movq %r13, %rsi
callq 0x1200
xorl %edi, %edi
movq %r13, %rsi
callq 0x1200
movq %rax, %r14
leaq 0x10(%rsp), %r13
movq %r13, %rdi
leaq 0x34b8(%rip), %rsi      # 0x9876
movq %rax, %rdx
xorl %eax, %eax
callq 0x1240
movl %eax, %ebp
leaq 0x2d3f(%rip), %rdi      # 0x9110
movq %r13, %rsi
xorl %eax, %eax
callq 0x10e0
movslq %ebp, %rdx
movq 0xd00b(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movq %r13, %rdi
callq 0x1260
movq 0xcff7(%rip), %rdi      # 0x133f0
callq 0x11b0
movq %r14, %rdi
callq 0x10c0
movq %r14, %rdi
movl %eax, %esi
leaq 0x3(%rsp), %rdx
callq 0x3673
testl %eax, %eax
jne 0x6d38
movq %r14, %rdi
callq 0x10c0
movq %r14, %rdi
movl %eax, %esi
leaq 0x201c(%rip), %rdx      # 0x844d
callq 0x4f8b
testb %al, %al
movq %rbx, %r14
movq %r12, %rbp
leaq 0x3361(%rip), %r13      # 0x97a6
je 0x637d
cmpb $0x1, 0xcfd6(%rip)      # 0x13428
jne 0x637d
cmpb $0x1, 0xcfca(%rip)      # 0x13429
jne 0x64aa
movups 0x3435(%rip), %xmm0     # 0x989d
movups %xmm0, 0x1a(%rsp)
movdqu 0x341e(%rip), %xmm0     # 0x9893
movdqa %xmm0, 0x10(%rsp)
leaq 0x2c8e(%rip), %rdi      # 0x9110
leaq 0x10(%rsp), %rbx
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10e0
movq 0xcf58(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movl $0x19, %edx
movq %rbx, %rdi
callq 0x1260
movl 0xcf48(%rip), %edi      # 0x133f8
movl $0x800, %edx            # imm = 0x800
leaq 0xcf74(%rip), %rbx      # 0x13430
movq %rbx, %rsi
xorl %ecx, %ecx
leaq 0xcf38(%rip), %r8       # 0x13400
callq 0x10b0
movl %eax, 0xd75d(%rip)      # 0x13c30
cmpl $-0x1, %eax
je 0x6970
cmpb $0x1, 0xcf46(%rip)      # 0x13429
jne 0x637d
leaq 0x36c3(%rip), %rdi      # 0x9bb3
callq 0x1080
leaq 0xcf34(%rip), %rbx      # 0x13430
movq %rbx, %rdi
callq 0x1080
movups 0x33d0(%rip), %xmm0     # 0x98db
movaps %xmm0, 0x10(%rsp)
movdqu 0x33d2(%rip), %xmm0     # 0x98ea
movdqu %xmm0, 0x1f(%rsp)
movq 0xcecb(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movl $0x1e, %edx
leaq 0x10(%rsp), %rdi
callq 0x1260
movslq 0xd6f0(%rip), %rdx      # 0x13c30
decq %rdx
movq 0xcea6(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1260
movq 0xce92(%rip), %rsi      # 0x133f0
movl $0xa, %edi
callq 0x1120
jmp 0x69bd
movq %r14, %rdi
movq %r12, %rsi
callq 0x1200
xorl %edi, %edi
movq %r12, %rsi
callq 0x1200
leaq 0x2d0(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10a0
movq %rax, %r14
subl %ebx, %r14d
xorl %edi, %edi
movq %r12, %rsi
callq 0x1200
testq %rax, %rax
je 0x65de
leaq 0x3359(%rip), %rbx      # 0x990a
movslq %r14d, %r14
leaq (%rsp,%r14), %rdi
addq $0x2d0, %rdi            # imm = 0x2D0
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1240
addl %eax, %r14d
xorl %edi, %edi
movq %r12, %rsi
callq 0x1200
testq %rax, %rax
jne 0x65b1
leaq 0x3329(%rip), %rdi      # 0x990e
leaq 0x2d0(%rsp), %rbx
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10e0
movups 0x332e(%rip), %xmm0     # 0x992c
movaps %xmm0, 0x10(%rsp)
movdqu 0x332b(%rip), %xmm0     # 0x9936
movdqu %xmm0, 0x1a(%rsp)
movq 0xcdd8(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movl $0x19, %edx
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x1260
movslq %r14d, %rdx
movq 0xcdb7(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1260
movw $0xa7c, 0x10(%rsp)      # imm = 0xA7C
movb $0x0, 0x12(%rsp)
movq 0xcd97(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movl $0x2, %edx
movq %r12, %rdi
callq 0x1260
movl 0xd5bf(%rip), %esi      # 0x13c30
leaq 0xcdb8(%rip), %rdi      # 0x13430
movq %rbx, %rdx
callq 0x4f8b
movl %eax, %r14d
testb %al, %al
je 0x67db
leaq 0x351c(%rip), %rdi      # 0x9bae
callq 0x1080
movl $0x53534150, 0x10(%rsp) # imm = 0x53534150
jmp 0x67ef
movq %r14, %rdi
movq %r12, %rsi
callq 0x1200
xorl %edi, %edi
movq %r12, %rsi
callq 0x1200
leaq 0x2d0(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10a0
movq %rax, %r14
subl %ebx, %r14d
xorl %edi, %edi
movq %r12, %rsi
callq 0x1200
testq %rax, %rax
je 0x6715
leaq 0x3222(%rip), %rbx      # 0x990a
movslq %r14d, %r14
leaq (%rsp,%r14), %rdi
addq $0x2d0, %rdi            # imm = 0x2D0
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1240
addl %eax, %r14d
xorl %edi, %edi
movq %r12, %rsi
callq 0x1200
testq %rax, %rax
jne 0x66e8
leaq 0x324a(%rip), %rdi      # 0x9966
leaq 0x2d0(%rsp), %rbx
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10e0
movups 0x3253(%rip), %xmm0     # 0x9988
movaps %xmm0, 0x10(%rsp)
movdqu 0x3254(%rip), %xmm0     # 0x9996
movdqu %xmm0, 0x1e(%rsp)
movq 0xcca1(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movl $0x1d, %edx
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x1260
movslq %r14d, %rdx
movq 0xcc80(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1260
movw $0xa7c, 0x10(%rsp)      # imm = 0xA7C
movb $0x0, 0x12(%rsp)
movq 0xcc60(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movl $0x2, %edx
movq %r12, %rdi
callq 0x1260
movl 0xd488(%rip), %esi      # 0x13c30
leaq 0xcc81(%rip), %rdi      # 0x13430
movq %rbx, %rdx
callq 0x4f8b
movl %eax, %r14d
testb %al, %al
je 0x68b4
leaq 0x33e0(%rip), %rdi      # 0x9ba9
callq 0x1080
movl $0x4c494146, 0x10(%rsp) # imm = 0x4C494146
jmp 0x68c8
leaq 0x33c7(%rip), %rdi      # 0x9ba9
callq 0x1080
movl $0x4c494146, 0x10(%rsp) # imm = 0x4C494146
movw $0xa, 0x14(%rsp)
movl 0x4(%rsp), %ebx
movq 0xcbef(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movl $0x5, %edx
leaq 0x10(%rsp), %rdi
callq 0x1260
movzwl %bx, %esi
movzbl %r14b, %edx
leaq 0xa8(%rsp), %rdi
movl $0x1, %ecx
jmp 0x6903
movq %r14, %rdi
movq %r12, %rsi
callq 0x1200
xorl %edi, %edi
movq %r12, %rsi
callq 0x1200
movq %rax, %r14
leaq 0x10(%rsp), %r12
movq %r12, %rdi
leaq 0x3159(%rip), %rsi      # 0x99ae
movq %rax, %rdx
xorl %eax, %eax
callq 0x1240
movl %eax, %ebp
leaq 0x28a8(%rip), %rdi      # 0x9110
movq %r12, %rsi
xorl %eax, %eax
callq 0x10e0
movslq %ebp, %rdx
movq 0xcb74(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movq %r12, %rdi
callq 0x1260
movq 0xcb60(%rip), %rdi      # 0x133f0
callq 0x11b0
movq %r14, %rdi
leaq 0xd0(%rsp), %r14
callq 0x1210
movl %eax, %edi
callq 0x1270
movq %rbx, %rbp
jmp 0x5b53
leaq 0x32f3(%rip), %rdi      # 0x9bae
callq 0x1080
movl $0x53534150, 0x10(%rsp) # imm = 0x53534150
movw $0xa, 0x14(%rsp)
movl 0x4(%rsp), %ebx
xorb $0x1, %r14b
movq 0xcb12(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movl $0x5, %edx
leaq 0x10(%rsp), %rdi
callq 0x1260
movzwl %bx, %esi
movzbl %r14b, %edx
leaq 0xa8(%rsp), %rdi
xorl %ecx, %ecx
callq 0x6db4
movq 0xcae1(%rip), %rdi      # 0x133f0
callq 0x11b0
leaq 0xd0(%rsp), %r14
jmp 0x5b53
leaq 0x3272(%rip), %rdi      # 0x9b9a
callq 0x1080
movabsq $0xa646573756150, %rax  # imm = 0xA646573756150
movq %rax, 0x10(%rsp)
movq 0xcaad(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movl $0x7, %edx
leaq 0x10(%rsp), %rdi
callq 0x1260
movq 0xca92(%rip), %rdi      # 0x133f0
callq 0x11b0
callq 0x1150
movq %rbx, %rbp
jmp 0x5b53
leaq 0x325a(%rip), %rdi      # 0x9bd1
callq 0x1080
movups 0x2f2a(%rip), %xmm0     # 0x98ad
movaps %xmm0, 0x10(%rsp)
movups 0x2f2e(%rip), %xmm0     # 0x98bd
movaps %xmm0, 0x20(%rsp)
movdqu 0x2f2f(%rip), %xmm0     # 0x98cb
movdqu %xmm0, 0x2e(%rsp)
movq 0xca47(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movl $0x2d, %edx
leaq 0x10(%rsp), %rdi
callq 0x1260
movl $0x0, 0xd269(%rip)      # 0x13c30
movl $0x800, %edx            # imm = 0x800
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1100
jmp 0x637d
movq %r14, %rdi
movq %r12, %rsi
callq 0x1200
xorl %edi, %edi
movq %r12, %rsi
callq 0x1200
movq %rax, %r14
leaq 0x2fe9(%rip), %rbx      # 0x99e3
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x10e0
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1240
movslq %eax, %rdx
movq 0xc9ca(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movq %r12, %rdi
movq %r12, %rbx
callq 0x1260
movl 0xd1f4(%rip), %esi      # 0x13c30
leaq 0xc9ed(%rip), %r12      # 0x13430
movq %r12, %rdi
movq %r14, %rdx
leaq 0xd0(%rsp), %r14
callq 0x4fa6
movl %eax, 0xd1d4(%rip)      # 0x13c30
leaq 0x3122(%rip), %rdi      # 0x9b85
callq 0x1080
leaq 0x26a1(%rip), %rdi      # 0x9110
movq %r12, %rsi
xorl %eax, %eax
callq 0x10e0
movabsq $0xa203a20706572, %rax  # imm = 0xA203A20706572
movq %rax, 0x1e(%rsp)
movdqu 0x2f66(%rip), %xmm0     # 0x99f6
movdqa %xmm0, 0x10(%rsp)
movq 0xc953(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movl $0x15, %edx
movq %rbx, %rdi
callq 0x1260
movslq 0xd17a(%rip), %rdx      # 0x13c30
jmp 0x6369
movq %r14, %rdi
movq %r12, %rsi
callq 0x1200
xorl %edi, %edi
movq %r12, %rsi
callq 0x1200
movq %r14, %rbx
movq %rax, %r14
leaq 0x2f37(%rip), %rdi      # 0x9a14
movq %rax, %rsi
xorl %eax, %eax
callq 0x10e0
leaq 0x10(%rsp), %r12
movq %r12, %rdi
leaq 0x2f1e(%rip), %rsi      # 0x9a14
movq %r14, %rdx
movq %rbx, %r14
xorl %eax, %eax
callq 0x1240
movslq %eax, %rdx
jmp 0x6369
movq %r14, %rbx
movq %r14, %rdi
movq %r12, %rsi
callq 0x1200
xorl %edi, %edi
movq %r12, %rsi
callq 0x1200
movq %rax, %rdi
callq 0x1210
testl %eax, %eax
je 0x6d57
movl %eax, %r14d
movl 0xd0f4(%rip), %esi      # 0x13c30
leaq 0xc8ed(%rip), %rdi      # 0x13430
movl %eax, %edx
callq 0x5081
movq %rax, 0xc8bf(%rip)      # 0x13410
leaq 0x2eda(%rip), %rdi      # 0x9a32
movq %rax, %rsi
movl %r14d, %edx
xorl %eax, %eax
callq 0x10e0
movq 0xc8a4(%rip), %rdx      # 0x13410
leaq 0x10(%rsp), %r12
movq %r12, %rdi
leaq 0x2eb7(%rip), %rsi      # 0x9a32
jmp 0x6bed
movq %r14, %rbx
movq %r14, %rdi
movq %r12, %rsi
callq 0x1200
xorl %edi, %edi
movq %r12, %rsi
callq 0x1200
movq %rax, %rdi
callq 0x1210
testl %eax, %eax
je 0x6d95
movl %eax, %r14d
movl 0xd082(%rip), %esi      # 0x13c30
leaq 0xc87b(%rip), %rdi      # 0x13430
movl %eax, %edx
callq 0x5081
movq %rax, 0xc855(%rip)      # 0x13418
leaq 0x2e93(%rip), %rdi      # 0x9a5d
movq %rax, %rsi
movl %r14d, %edx
xorl %eax, %eax
callq 0x10e0
movq 0xc83a(%rip), %rdx      # 0x13418
leaq 0x10(%rsp), %r12
movq %r12, %rdi
leaq 0x2e70(%rip), %rsi      # 0x9a5d
movl %r14d, %ecx
xorl %eax, %eax
callq 0x1240
movslq %eax, %rdx
movq 0xc7ef(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movq %r12, %rdi
callq 0x1260
movq 0xc7db(%rip), %rdi      # 0x133f0
callq 0x11b0
movq %rbx, %r14
jmp 0x5b53
movq %r14, %rdi
movq %r12, %rsi
callq 0x1200
xorl %edi, %edi
movq %r12, %rsi
callq 0x1200
movq %rax, %r14
movq %r13, %rbx
leaq 0x10(%rsp), %r13
movq %r13, %rdi
leaq 0x2c19(%rip), %rsi      # 0x9865
movq %rax, %rdx
xorl %eax, %eax
callq 0x1240
movq %rbp, %r12
movl %eax, %ebp
leaq 0x24ae(%rip), %rdi      # 0x9110
movq %r13, %rsi
xorl %eax, %eax
callq 0x10e0
movslq %ebp, %rdx
movq %r12, %rbp
movq 0xc777(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movq %r13, %rdi
movq %rbx, %r13
callq 0x1260
movq 0xc760(%rip), %rdi      # 0x133f0
callq 0x11b0
movq %r14, %rdi
leaq 0xd0(%rsp), %r14
callq 0x1210
jmp 0x5b4f
leaq 0x2ef0(%rip), %rdi      # 0x9ba1
callq 0x1080
movabsq $0xa646574726f6241, %rax # imm = 0xA646574726F6241
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movb $0x0, 0x8(%rdi)
movq 0xc71d(%rip), %rcx      # 0x133f0
movl $0x1, %esi
movl $0x8, %edx
callq 0x1260
movq %r15, %rdi
callq 0x1090
movb $0x0, 0xc737(%rip)      # 0x13428
movq 0xc6f8(%rip), %rdi      # 0x133f0
callq 0x11b0
movq 0xa0(%rsp), %rax
andb $0x1, %al
addq $0x3d8, %rsp            # imm = 0x3D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a59(%rip), %rdi      # 0x9779
leaq 0x29ee(%rip), %rsi      # 0x9715
leaq 0x2a4e(%rip), %rcx      # 0x977c
movl $0x99, %edx
callq 0x10f0
leaq 0x2b41(%rip), %rdi      # 0x9880
leaq 0x29cf(%rip), %rsi      # 0x9715
leaq 0x2a2f(%rip), %rcx      # 0x977c
movl $0x10b, %edx            # imm = 0x10B
callq 0x10f0
leaq 0x2cce(%rip), %rdi      # 0x9a2c
leaq 0x29b0(%rip), %rsi      # 0x9715
leaq 0x2a10(%rip), %rcx      # 0x977c
movl $0x1c3, %edx            # imm = 0x1C3
callq 0x10f0
leaq 0x2caf(%rip), %rdi      # 0x9a2c
leaq 0x2991(%rip), %rsi      # 0x9715
leaq 0x29f1(%rip), %rcx      # 0x977c
movl $0x1e1, %edx            # imm = 0x1E1
callq 0x10f0
leaq 0x2c90(%rip), %rdi      # 0x9a2c
leaq 0x2972(%rip), %rsi      # 0x9715
leaq 0x29d2(%rip), %rcx      # 0x977c
movl $0x1d2, %edx            # imm = 0x1D2
callq 0x10f0