// File: /workspace/github_cpp_makefile_star2_O2/AndreRenaud[P]simple_uart/./acutest.h
// Function: main
int
main(int argc, char** argv)
{
    int i, index;
    int exit_code = 1;

    acutest_argv0_ = argv[0];

#if defined ACUTEST_UNIX_
    acutest_colorize_ = isatty(STDOUT_FILENO);
#elif defined ACUTEST_WIN_
 #if defined _BORLANDC_
    acutest_colorize_ = isatty(_fileno(stdout));
 #else
    acutest_colorize_ = _isatty(_fileno(stdout));
 #endif
#else
    acutest_colorize_ = 0;
#endif

    /* Count all test units */
    acutest_list_size_ = 0;
    for(i = 0; acutest_list_[i].func != NULL; i++)
        acutest_list_size_++;

    acutest_test_data_ = (struct acutest_test_data_*)calloc(acutest_list_size_, sizeof(struct acutest_test_data_));
    if(acutest_test_data_ == NULL) {
        fprintf(stderr, "Out of memory.\n");
        acutest_exit_(2);
    }

    /* Parse options */
    acutest_cmdline_read_(acutest_cmdline_options_, argc, argv, acutest_cmdline_callback_);

    /* Initialize the proper timer. */
    acutest_timer_init_();

#if defined(ACUTEST_WIN_)
    SetUnhandledExceptionFilter(acutest_seh_exception_filter_);
#ifdef _MSC_VER
    _set_abort_behavior(0, _WRITE_ABORT_MSG);
#endif
#endif

    /* Determine what to run. */
    if(acutest_count_(ACUTEST_STATE_SELECTED) > 0) {
        enum acutest_state_ if_selected;
        enum acutest_state_ if_unselected;

        if(!acutest_exclude_mode_) {
            if_selected = ACUTEST_STATE_NEEDTORUN;
            if_unselected = ACUTEST_STATE_EXCLUDED;
        } else {
            if_selected = ACUTEST_STATE_EXCLUDED;
            if_unselected = ACUTEST_STATE_NEEDTORUN;
        }

        for(i = 0; acutest_list_[i].func != NULL; i++) {
            if(acutest_test_data_[i].state == ACUTEST_STATE_SELECTED)
                acutest_test_data_[i].state = if_selected;
            else
                acutest_test_data_[i].state = if_unselected;
        }
    } else {
        /* By default, we want to run all tests. */
        for(i = 0; acutest_list_[i].func != NULL; i++)
            acutest_test_data_[i].state = ACUTEST_STATE_NEEDTORUN;
    }

    /* By default, we want to suppress running tests as child processes if we
     * run just one test, or if we're under debugger: Debugging tests is then
     * so much easier. */
    if(acutest_no_exec_ < 0) {
        if(acutest_count_(ACUTEST_STATE_NEEDTORUN) <= 1  ||  acutest_under_debugger_())
            acutest_no_exec_ = 1;
        else
            acutest_no_exec_ = 0;
    }

    if(acutest_tap_) {
        /* TAP requires we know test result ("ok", "not ok") before we output
         * anything about the test, and this gets problematic for larger verbose
         * levels. */
        if(acutest_verbose_level_ > 2)
            acutest_verbose_level_ = 2;

        /* TAP harness should provide some summary. */
        acutest_no_summary_ = 1;

        if(!acutest_worker_)
            printf("1..%d\n", acutest_count_(ACUTEST_STATE_NEEDTORUN));
    }

    index = acutest_worker_index_;
    for(i = 0; acutest_list_[i].func != NULL; i++) {
        if(acutest_test_data_[i].state == ACUTEST_STATE_NEEDTORUN)
            acutest_run_(&acutest_list_[i], index++, i);
    }

    /* Write a summary */
    if(!acutest_no_summary_ && acutest_verbose_level_ >= 1) {
        int n_run, n_success, n_failed ;

        n_run = acutest_list_size_ - acutest_count_(ACUTEST_STATE_EXCLUDED);
        n_success = acutest_count_(ACUTEST_STATE_SUCCESS);
        n_failed = acutest_count_(ACUTEST_STATE_FAILED);

        if(acutest_verbose_level_ >= 3) {
            acutest_colored_printf_(ACUTEST_COLOR_DEFAULT_INTENSIVE_, "Summary:\n");

            printf("  Count of run unit tests:        %4d\n", n_run);
            printf("  Count of successful unit tests: %4d\n", n_success);
            printf("  Count of failed unit tests:     %4d\n", n_failed);
        }

        if(n_failed == 0) {
            acutest_colored_printf_(ACUTEST_COLOR_GREEN_INTENSIVE_, "SUCCESS:");
            printf(" No unit tests have failed.\n");
        } else {
            acutest_colored_printf_(ACUTEST_COLOR_RED_INTENSIVE_, "FAILED:");
            printf(" %d of %d unit tests %s failed.\n",
                    n_failed, n_run, (n_failed == 1) ? "has" : "have");
        }

        if(acutest_verbose_level_ >= 3)
            printf("\n");
    }

    if (acutest_xml_output_) {
        const char* suite_name = acutest_basename_(argv[0]);
        fprintf(acutest_xml_output_, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
        fprintf(acutest_xml_output_, "<testsuite name=\"%s\" tests=\"%d\" errors=\"0\" failures=\"%d\" skip=\"%d\">\n",
            suite_name,
            (int)acutest_list_size_,
            acutest_count_(ACUTEST_STATE_FAILED),
            acutest_count_(ACUTEST_STATE_SKIPPED) + acutest_count_(ACUTEST_STATE_EXCLUDED));
        for(i = 0; acutest_list_[i].func != NULL; i++) {
            struct acutest_test_data_ *details = &acutest_test_data_[i];
            const char* str_state;
            fprintf(acutest_xml_output_, "  <testcase name=\"%s\" time=\"%.2f\">\n", acutest_list_[i].name, details->duration);

            switch(details->state) {
                case ACUTEST_STATE_SUCCESS:     str_state = NULL; break;
                case ACUTEST_STATE_EXCLUDED:    /* Fall through. */
                case ACUTEST_STATE_SKIPPED:     str_state = "<skipped />"; break;
                case ACUTEST_STATE_FAILED:      /* Fall through. */
                default:                        str_state = "<failure />"; break;
            }

            if(str_state != NULL)
                fprintf(acutest_xml_output_, "    %s\n", str_state);
            fprintf(acutest_xml_output_, "  </testcase>\n");
        }
        fprintf(acutest_xml_output_, "</testsuite>\n");
        fclose(acutest_xml_output_);
    }

    if(acutest_worker_  &&  acutest_count_(ACUTEST_STATE_EXCLUDED)+1 == acutest_list_size_) {
        /* If we are the child process, we need to propagate the test state
         * without any moderation. */
        for(i = 0; acutest_list_[i].func != NULL; i++) {
            if(acutest_test_data_[i].state != ACUTEST_STATE_EXCLUDED) {
                exit_code = (int) acutest_test_data_[i].state;
                break;
            }
        }
    } else {
        if(acutest_count_(ACUTEST_STATE_FAILED) > 0)
            exit_code = 1;
        else
            exit_code = 0;
    }

    acutest_cleanup_();
    return exit_code;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rsi, %r13
movl %edi, 0x14(%rsp)
movq (%rsi), %rax
movq %rax, 0x8507(%rip)      # 0xb478
pushq $0x1
popq %rbp
movl %ebp, %edi
callq 0x20b0
movl %eax, 0x84ff(%rip)      # 0xb480
movl $0x6, 0x84f9(%rip)      # 0xb484
pushq $0x6
popq %rdi
pushq $0x10
popq %rsi
callq 0x2210
movq %rax, 0x84eb(%rip)      # 0xb488
testq %rax, %rax
je 0x388b
leaq 0x40(%rsp), %rax
movb $0x0, 0x20(%rax)
xorl %ebx, %ebx
movl %ebp, %r12d
movq %r13, (%rsp)
cmpl 0x14(%rsp), %r12d
jge 0x3280
movq %r12, 0x8(%rsp)
movslq %r12d, %rbp
movq (%r13,%rbp,8), %rsi
testl %ebx, %ebx
jne 0x307d
cmpb $0x2d, (%rsi)
jne 0x307b
movb 0x1(%rsi), %r12b
testb %r12b, %r12b
je 0x307d
cmpb $0x2d, %r12b
jne 0x2ffe
cmpb $0x0, 0x2(%rsi)
je 0x31a8
movq %rsi, 0x18(%rsp)
leaq 0x2(%rsi), %rax
movq %rax, 0x20(%rsp)
leaq 0x7bb1(%rip), %r15      # 0xabc4
movl -0x4(%r15), %r13d
testl %r13d, %r13d
je 0x3099
cmpb $0x2d, %r12b
setne %al
movq -0xc(%r15), %r14
testq %r14, %r14
sete %cl
orb %al, %cl
je 0x303c
cmpb -0x14(%r15), %r12b
jne 0x3075
jmp 0x310d
movq %r14, %rdi
callq 0x2150
movq %rax, %rbx
movq 0x20(%rsp), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2090
testl %eax, %eax
jne 0x3075
movq 0x20(%rsp), %rax
movzbl (%rax,%rbx), %eax
cmpl $0x3d, %eax
je 0x31dd
testl %eax, %eax
je 0x31ce
addq $0x18, %r15
jmp 0x3013
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x38af
movq 0x8(%rsp), %r12
testl %eax, %eax
jne 0x3280
incl %r12d
jmp 0x2fb8
cmpb $0x2d, %r12b
je 0x30af
movq (%rsp), %r13
movq 0x8(%rsp), %r12
movq 0x18(%rsp), %r15
jmp 0x30f9
movq 0x18(%rsp), %r15
movq %r15, %rdi
pushq $0x3d
popq %rsi
callq 0x2170
testq %rax, %rax
movq (%rsp), %r13
movq 0x8(%rsp), %r12
je 0x30f9
movq %rax, %rbx
subq %r15, %rbx
cmpq $0x20, %rbx
pushq $0x20
popq %rax
cmovaeq %rax, %rbx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2080
movb $0x0, 0x40(%rsp,%rbx)
movq %r14, %r15
movl $0x80000001, %edi       # imm = 0x80000001
movq %r15, %rsi
callq 0x38af
xorl %ebx, %ebx
jmp 0x3089
testb $0x2, (%r15)
jne 0x31b7
movl %r13d, %edi
xorl %esi, %esi
callq 0x38af
testl %eax, %eax
movq (%rsp), %r13
movq 0x8(%rsp), %r12
jne 0x3280
movq (%r13,%rbp,8), %r14
xorl %ebx, %ebx
cmpb $0x0, 0x2(%r14)
je 0x3091
xorl %r15d, %r15d
movb 0x2(%r14,%r15), %cl
testb %cl, %cl
je 0x3091
leaq 0x7a69(%rip), %rdx      # 0xabc4
movl -0x4(%rdx), %edi
testl %edi, %edi
je 0x316d
cmpb -0x14(%rdx), %cl
je 0x3174
addq $0x18, %rdx
jmp 0x315b
movl $0x80000001, %eax       # imm = 0x80000001
jmp 0x3182
movl $0x80000002, %eax       # imm = 0x80000002
testb $0x2, (%rdx)
jne 0x3182
xorl %esi, %esi
jmp 0x3197
movb $0x2d, 0x30(%rsp)
movb %cl, 0x31(%rsp)
movb $0x0, 0x32(%rsp)
movl %eax, %edi
leaq 0x30(%rsp), %rsi
callq 0x38af
incq %r15
testl %eax, %eax
je 0x3147
jmp 0x3280
pushq $0x1
popq %rax
movl %eax, %ebx
movq 0x8(%rsp), %r12
jmp 0x3091
movq 0x20(%rsp), %rsi
cmpb $0x0, (%rsi)
movq 0x8(%rsp), %r12
je 0x31f4
movl %r13d, %edi
jmp 0x3270
testb $0x2, (%r15)
jne 0x321f
xorl %ebx, %ebx
movl %r13d, %edi
xorl %esi, %esi
jmp 0x3258
testb $0x3, (%r15)
je 0x3232
movq 0x20(%rsp), %rax
leaq (%rax,%rbx), %rsi
incq %rsi
movl %r13d, %edi
jmp 0x3229
leal 0x1(%r12), %ebp
cmpl 0x14(%rsp), %ebp
jge 0x3266
movslq %ebp, %rax
movq (%rsp), %rcx
movq (%rcx,%rax,8), %rsi
movl %r13d, %edi
movq %rcx, %r13
callq 0x38af
xorl %ebx, %ebx
movl %ebp, %r12d
jmp 0x3089
movl $0x80000002, %edi       # imm = 0x80000002
movq 0x18(%rsp), %rsi
callq 0x38af
xorl %ebx, %ebx
jmp 0x325d
xorl %ebx, %ebx
leaq 0x40(%rsp), %r15
movq %r15, %rdi
pushq $0x21
popq %rsi
leaq 0x46df(%rip), %rdx      # 0x7925
movq %r14, %rcx
xorl %eax, %eax
callq 0x2190
movl $0x80000003, %edi       # imm = 0x80000003
movq %r15, %rsi
callq 0x38af
movq (%rsp), %r13
jmp 0x3084
movl $0x80000002, %edi       # imm = 0x80000002
movq 0x18(%rsp), %rsi
callq 0x38af
xorl %ebx, %ebx
movq (%rsp), %r13
jmp 0x3089
movl 0x822e(%rip), %eax      # 0xb4b4
leal -0x1(%rax), %ecx
cmpl $0x1, %ecx
ja 0x3294
movl %eax, 0x8244(%rip)      # 0xb4d8
pushq $-0x3
popq %rdi
callq 0x3d9a
testl %eax, %eax
jle 0x32d2
movb 0x81ea(%rip), %al       # 0xb490
movq 0x81db(%rip), %rcx      # 0xb488
xorl %edx, %edx
cmpq $0x60, %rdx
je 0x32ee
cmpl $-0x3, (%rcx,%rdx)
sete %sil
xorb %al, %sil
movzbl %sil, %esi
notl %esi
orl $-0x2, %esi
movl %esi, (%rcx,%rdx)
addq $0x10, %rdx
jmp 0x32af
movq 0x81af(%rip), %rax      # 0xb488
xorl %ecx, %ecx
cmpq $0x60, %rcx
je 0x32ee
movl $0xfffffffe, (%rax,%rcx) # imm = 0xFFFFFFFE
addq $0x10, %rcx
jmp 0x32db
cmpl $0x0, 0x7f2f(%rip)      # 0xb224
jns 0x33ed
pushq $-0x2
popq %rdi
callq 0x3d9a
pushq $0x1
popq %r12
cmpl $0x2, %eax
jl 0x33e6
movb $0xa, 0x40(%rsp)
leaq 0x4853(%rip), %rdi      # 0x7b6f
xorl %r12d, %r12d
xorl %esi, %esi
xorl %eax, %eax
callq 0x2320
cmpl $-0x1, %eax
je 0x33e6
movl %eax, %ebp
pushq $0x1
popq %rcx
leaq 0x220(%rsp), %rbx
leaq 0x3d46(%rip), %r14      # 0x708b
leaq 0x40(%rsp), %r15
movq %rcx, %r13
cmpq $0x1fe, %rcx            # imm = 0x1FE
ja 0x3376
leaq (%rsp,%r13), %rsi
addq $0x40, %rsi
movl $0x1ff, %edx            # imm = 0x1FF
subq %r13, %rdx
movl %ebp, %edi
callq 0x21f0
leaq (%rax,%r13), %rcx
testq %rax, %rax
jg 0x334a
movb $0x0, 0x40(%rsp,%r13)
movq %r15, %rdi
movq %r14, %rsi
callq 0x23d0
testq %rax, %rax
setne %cl
cmpq %rbx, %rax
setb %dl
andb %cl, %dl
cmpb $0x1, %dl
je 0x33c7
cmpq $0x1ff, %r13            # imm = 0x1FF
jne 0x33be
movupd -0x1(%rbx), %xmm0
movupd 0xf(%rbx), %xmm1
movapd %xmm1, 0x50(%rsp)
movapd %xmm0, 0x40(%rsp)
pushq $0x20
popq %rcx
jmp 0x334a
movl %ebp, %edi
callq 0x21d0
jmp 0x33e6
addq $0xb, %rax
movq %rax, %rdi
callq 0x2360
movl %eax, %ebx
movl %ebp, %edi
callq 0x21d0
testl %ebx, %ebx
pushq $0x1
popq %rax
je 0x33e6
movl %eax, %r12d
movl %r12d, 0x7e37(%rip)     # 0xb224
cmpb $0x1, 0x80a0(%rip)      # 0xb494
jne 0x3431
cmpl $0x3, 0x7e23(%rip)      # 0xb220
jl 0x3409
movl $0x2, 0x7e17(%rip)      # 0xb220
movb $0x1, 0x8088(%rip)      # 0xb498
cmpb $0x0, 0x8085(%rip)      # 0xb49c
jne 0x3431
pushq $-0x2
popq %rdi
callq 0x3d9a
leaq 0x3d90(%rip), %rdi      # 0x71b8
movl %eax, %esi
xorl %eax, %eax
callq 0x2180
movl 0x8069(%rip), %ebp      # 0xb4a0
leaq 0x30(%rsp), %r14
leaq 0x40(%rsp), %r13
xorl %r12d, %r12d
cmpq $0x60, %r12
je 0x35d6
movq 0x8033(%rip), %rax      # 0xb488
cmpl $-0x2, (%rax,%r12)
jne 0x35cd
leaq 0x78e9(%rip), %rax      # 0xad50
leaq (%rax,%r12), %r15
movq %r15, 0x7ed6(%rip)      # 0xb348
andl $0x0, 0x7ecb(%rip)      # 0xb344
movq %r14, %rdi
callq 0x4f6b
cmpl $0x0, 0x7d9c(%rip)      # 0xb224
je 0x349b
movq %r15, %rdi
movl %ebp, %esi
callq 0x5052
movl %eax, %ebx
jmp 0x357f
movq 0x7b2e(%rip), %rax      # 0xafd0
movq (%rax), %rdi
callq 0x22a0
movq 0x7b3f(%rip), %rax      # 0xaff0
movq (%rax), %rdi
callq 0x22a0
callq 0x23c0
cmpl $-0x1, %eax
je 0x351c
testl %eax, %eax
je 0x3873
movl %eax, %edi
leaq 0x2c(%rsp), %rsi
xorl %edx, %edx
callq 0x22f0
movl 0x2c(%rsp), %eax
movl %eax, %ecx
andl $0x7f, %ecx
je 0x3540
movl %ecx, %edx
shll $0x18, %edx
addl $0x1000000, %edx        # imm = 0x1000000
cmpl $0x2000000, %edx        # imm = 0x2000000
jl 0x3545
cmpl $0x10, %ecx
jae 0x3557
movq %rcx, %rax
decq %rax
movl $0x452f, %edx           # imm = 0x452F
btl %eax, %edx
jae 0x3557
leaq 0x3bb9(%rip), %rcx      # 0x70cc
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
jmp 0x356e
callq 0x2060
movq %rax, %rbx
movl (%rax), %edi
callq 0x23b0
movl (%rbx), %edx
leaq 0x464d(%rip), %rdi      # 0x7b81
movq %rax, %rsi
xorl %eax, %eax
callq 0x4f79
jmp 0x357c
movzbl %ah, %ebx
jmp 0x357f
leaq 0x46a9(%rip), %rdi      # 0x7bf5
movl %eax, %esi
xorl %eax, %eax
callq 0x4f79
jmp 0x357c
movq %r13, %rdi
pushq $0x20
popq %rsi
leaq 0x466f(%rip), %rdx      # 0x7bd3
xorl %eax, %eax
callq 0x2190
movq %r13, %rsi
leaq 0x4668(%rip), %rdi      # 0x7bdd
xorl %eax, %eax
callq 0x4f79
pushq $0x1
popq %rbx
incl %ebp
movq %r13, %rdi
callq 0x4f6b
andq $0x0, 0x7db7(%rip)      # 0xb348
movq 0x7ef0(%rip), %rax      # 0xb488
movl %ebx, (%rax,%r12)
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %rdx
subq 0x30(%rsp), %rcx
cvtsi2sd %rcx, %xmm0
subq 0x38(%rsp), %rdx
cvtsi2sd %rdx, %xmm1
divsd 0x3a46(%rip), %xmm1     # 0x7008
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rax,%r12)
addq $0x10, %r12
jmp 0x3444
movl 0x7c44(%rip), %ebx      # 0xb220
testl %ebx, %ebx
setle %al
orb 0x7eb1(%rip), %al       # 0xb498
testb $0x1, %al
movq (%rsp), %r12
jne 0x36cf
movl 0x7e8b(%rip), %ebp      # 0xb484
pushq $-0x1
popq %rdi
callq 0x3d9a
subl %eax, %ebp
xorl %edi, %edi
callq 0x3d9a
movl %eax, %r15d
pushq $0x1
popq %rdi
callq 0x3d9a
movl %eax, %r14d
cmpl $0x3, %ebx
jb 0x3660
leaq 0x3b9b(%rip), %rsi      # 0x71bf
pushq $0xa
popq %rdi
xorl %eax, %eax
callq 0x29de
leaq 0x3b94(%rip), %rdi      # 0x71c9
movl %ebp, %esi
xorl %eax, %eax
callq 0x2180
leaq 0x3bab(%rip), %rdi      # 0x71f0
movl %r15d, %esi
xorl %eax, %eax
callq 0x2180
leaq 0x3bc1(%rip), %rdi      # 0x7217
movl %r14d, %esi
xorl %eax, %eax
callq 0x2180
testl %r14d, %r14d
je 0x36a1
leaq 0x3bdb(%rip), %rsi      # 0x7247
pushq $0xb
popq %rdi
xorl %eax, %eax
callq 0x29de
cmpl $0x1, %r14d
leaq 0x3bef(%rip), %rax      # 0x7270
leaq 0x3bec(%rip), %rcx      # 0x7274
cmoveq %rax, %rcx
leaq 0x3bbc(%rip), %rdi      # 0x724f
movl %r14d, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x2180
jmp 0x36be
leaq 0x3b96(%rip), %rsi      # 0x723e
pushq $0xc
popq %rdi
xorl %eax, %eax
callq 0x29de
leaq 0x461c(%rip), %rdi      # 0x7cd5
callq 0x20a0
cmpl $0x3, 0x7b5b(%rip)      # 0xb220
jl 0x36cf
pushq $0xa
popq %rdi
callq 0x2050
movq 0x7dd2(%rip), %r15      # 0xb4a8
testq %r15, %r15
je 0x3809
movq (%r12), %rdi
callq 0x29c2
movq %rax, %r14
leaq 0x3b87(%rip), %rdi      # 0x7279
pushq $0x27
popq %rsi
pushq $0x1
popq %rdx
movq %r15, %rcx
callq 0x2390
movq 0x7da1(%rip), %r15      # 0xb4a8
movl 0x7d77(%rip), %ebp      # 0xb484
pushq $0x1
popq %rdi
callq 0x3d9a
movl %eax, %r12d
pushq $0x2
popq %rdi
callq 0x3d9a
movl %eax, %r13d
pushq $-0x1
popq %rdi
callq 0x3d9a
addl %eax, %r13d
leaq 0x3b6c(%rip), %rsi      # 0x72a1
movq %r15, %rdi
movq %r14, %rdx
movl %ebp, %ecx
movl %r12d, %r8d
movl %r13d, %r9d
xorl %eax, %eax
callq 0x2250
leaq 0x3b95(%rip), %r14      # 0x72e6
leaq 0x3bb2(%rip), %rbp      # 0x730a
leaq 0x3bcb(%rip), %r12      # 0x732a
pushq $0xe
popq %r13
xorl %ebx, %ebx
cmpq $0x60, %rbx
je 0x37e4
movq 0x7d16(%rip), %r15      # 0xb488
movq 0x7d2f(%rip), %rdi      # 0xb4a8
leaq 0x75d0(%rip), %rax      # 0xad50
movq (%rbx,%rax), %rdx
movsd 0x8(%r15,%rbx), %xmm0
movq %r14, %rsi
movb $0x1, %al
callq 0x2250
movl (%r15,%rbx), %eax
movq %rbp, %rdx
cmpl $-0x1, %eax
je 0x37b4
testl %eax, %eax
je 0x37c9
movq %rbp, %rdx
cmpl $0x2, %eax
je 0x37b4
leaq 0x3b62(%rip), %rdx      # 0x7316
movq 0x7ced(%rip), %rdi      # 0xb4a8
leaq 0x3b60(%rip), %rsi      # 0x7322
xorl %eax, %eax
callq 0x2250
movq 0x7cd8(%rip), %rcx      # 0xb4a8
movq %r12, %rdi
movq %r13, %rsi
pushq $0x1
popq %rdx
callq 0x2390
addq $0x10, %rbx
jmp 0x3765
movq 0x7cbd(%rip), %rcx      # 0xb4a8
leaq 0x3b47(%rip), %rdi      # 0x7339
pushq $0xd
popq %rsi
pushq $0x1
popq %rdx
callq 0x2390
movq 0x7ca4(%rip), %rdi      # 0xb4a8
callq 0x2130
cmpb $0x1, 0x7c8c(%rip)      # 0xb49c
jne 0x3847
pushq $-0x1
popq %rdi
callq 0x3d9a
incl %eax
cmpl 0x7c62(%rip), %eax      # 0xb484
jne 0x3847
movq 0x7c5d(%rip), %rax      # 0xb488
xorl %edx, %edx
pushq $0x1
popq %rcx
leaq 0x10(%rdx), %rsi
cmpq $0x70, %rsi
je 0x386f
movl (%rax,%rdx), %ebx
movq %rsi, %rdx
cmpl $-0x1, %ebx
je 0x3830
jmp 0x3856
pushq $0x1
popq %rdi
callq 0x3d9a
xorl %ebx, %ebx
testl %eax, %eax
setg %bl
callq 0x3dcd
movl %ebx, %eax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ecx, %ebx
jmp 0x3856
movb $0x1, 0x7c22(%rip)      # 0xb49c
movq %r15, %rdi
movl %ebp, %esi
callq 0x5052
movl %eax, %edi
callq 0x2f40
movq 0x775e(%rip), %rax      # 0xaff0
movq (%rax), %rcx
leaq 0x390c(%rip), %rdi      # 0x71a8
pushq $0xf
popq %rsi
pushq $0x1
popq %rdx
callq 0x2390
pushq $0x2
popq %rdi
callq 0x2f40