// File: /workspace/github_cpp_makefile_star2_O3/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, %r12
movl %edi, %r13d
movq (%rsi), %rax
movq %rax, 0x8243(%rip)      # 0xb478
movl $0x1, %edi
callq 0x20b0
movl %eax, 0x823b(%rip)      # 0xb480
movb $0x1, 0x8238(%rip)      # 0xb484
movl $0x6, %edi
movl $0x10, %esi
callq 0x2210
movq %rax, 0x8226(%rip)      # 0xb488
testq %rax, %rax
je 0x3cdd
movb $0x0, 0x60(%rsp)
cmpl $0x2, %r13d
movq %r12, 0x8(%rsp)
jl 0x357e
movl $0x1, %ebp
xorl %ebx, %ebx
movl %r13d, 0x4(%rsp)
movslq %ebp, %rax
movq (%r12,%rax,8), %rsi
testl %ebx, %ebx
jne 0x3365
cmpb $0x2d, (%rsi)
jne 0x3363
movb 0x1(%rsi), %r13b
testb %r13b, %r13b
je 0x3365
cmpb $0x2d, %r13b
jne 0x32c0
cmpb $0x0, 0x2(%rsi)
je 0x349b
movq %rax, 0x38(%rsp)
movq %rsi, 0x10(%rsp)
leaq 0x2(%rsi), %rax
movq %rax, 0x18(%rsp)
movl $0x58, %r12d
leaq 0x78d0(%rip), %r15      # 0xabb0
cmpb $0x2d, %r13b
setne %al
movq 0x8(%r15), %r14
testq %r14, %r14
sete %cl
orb %al, %cl
je 0x32ff
cmpb (%r15), %r13b
jne 0x3338
jmp 0x3389
movq %r14, %rdi
callq 0x2150
movq %rax, %rbx
movq 0x18(%rsp), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2090
testl %eax, %eax
jne 0x3338
movq 0x18(%rsp), %rax
movzbl (%rax,%rbx), %eax
cmpl $0x3d, %eax
je 0x34fc
testl %eax, %eax
je 0x34e7
movl 0x28(%r15), %r12d
addq $0x18, %r15
testl %r12d, %r12d
jne 0x32e0
cmpb $0x2d, %r13b
je 0x3438
movq 0x8(%rsp), %r12
movl 0x4(%rsp), %r13d
movq 0x10(%rsp), %r15
jmp 0x3487
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x3ce2
movl 0x4(%rsp), %r13d
testl %eax, %eax
jne 0x357e
incl %ebp
cmpl %r13d, %ebp
jl 0x328b
jmp 0x357e
testb $0x2, 0x14(%r15)
jne 0x34aa
movl %r12d, %edi
xorl %esi, %esi
callq 0x3ce2
testl %eax, %eax
movq 0x8(%rsp), %r12
movl 0x4(%rsp), %r13d
jne 0x357e
movq 0x38(%rsp), %rax
movq (%r12,%rax,8), %r14
movb 0x2(%r14), %cl
xorl %ebx, %ebx
testb %cl, %cl
je 0x3379
xorl %r15d, %r15d
movl $0x58, %edi
leaq 0x77de(%rip), %rdx      # 0xabb0
cmpb $0x58, %cl
je 0x33f1
leaq 0x77d2(%rip), %rax      # 0xabb0
movl 0x28(%rax), %edi
testl %edi, %edi
je 0x3400
leaq 0x18(%rax), %rdx
cmpb 0x18(%rax), %cl
movq %rdx, %rax
jne 0x33de
movl $0x80000002, %eax       # imm = 0x80000002
testb $0x2, 0x14(%rdx)
jne 0x3405
xorl %esi, %esi
jmp 0x341a
movl $0x80000001, %eax       # imm = 0x80000001
movb $0x2d, 0x28(%rsp)
movb %cl, 0x29(%rsp)
movb $0x0, 0x2a(%rsp)
movl %eax, %edi
leaq 0x28(%rsp), %rsi
callq 0x3ce2
testl %eax, %eax
jne 0x357e
movb 0x3(%r14,%r15), %cl
incq %r15
testb %cl, %cl
jne 0x33c6
jmp 0x3379
movq 0x10(%rsp), %r15
movq %r15, %rdi
movl $0x3d, %esi
callq 0x2170
testq %rax, %rax
movq 0x8(%rsp), %r12
movl 0x4(%rsp), %r13d
je 0x3487
movq %rax, %rbx
subq %r15, %rbx
cmpq $0x20, %rbx
movl $0x20, %eax
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 0x3ce2
xorl %ebx, %ebx
jmp 0x3371
movl $0x1, %ebx
movl 0x4(%rsp), %r13d
jmp 0x3379
movq 0x18(%rsp), %rsi
cmpb $0x0, (%rsi)
movl 0x4(%rsp), %r13d
jne 0x3514
leal 0x1(%rbp), %r14d
cmpl %r13d, %r14d
jge 0x3572
movslq %r14d, %rax
movq 0x8(%rsp), %rcx
movq (%rcx,%rax,8), %rsi
movl %r12d, %edi
movq %rcx, %r12
callq 0x3ce2
xorl %ebx, %ebx
movl %r14d, %ebp
jmp 0x3371
testb $0x2, 0x14(%r15)
jne 0x3528
xorl %ebx, %ebx
movl %r12d, %edi
xorl %esi, %esi
callq 0x3ce2
jmp 0x3539
testb $0x3, 0x14(%r15)
movl 0x4(%rsp), %r13d
je 0x3543
movq 0x18(%rsp), %rax
leaq (%rax,%rbx), %rsi
incq %rsi
movl %r12d, %edi
callq 0x3ce2
xorl %ebx, %ebx
movq 0x8(%rsp), %r12
jmp 0x3371
movl $0x80000002, %edi       # imm = 0x80000002
movq 0x10(%rsp), %rsi
callq 0x3ce2
xorl %ebx, %ebx
movq 0x8(%rsp), %r12
jmp 0x336c
xorl %ebx, %ebx
movl $0x21, %esi
leaq 0x40(%rsp), %r15
movq %r15, %rdi
leaq 0x4404(%rip), %rdx      # 0x795d
movq %r14, %rcx
xorl %eax, %eax
callq 0x2190
movl $0x80000003, %edi       # imm = 0x80000003
movq %r15, %rsi
callq 0x3ce2
jmp 0x351e
movl $0x80000002, %edi       # imm = 0x80000002
movq 0x10(%rsp), %rsi
jmp 0x3517
movl 0x7f30(%rip), %eax      # 0xb4b4
leal -0x1(%rax), %ecx
cmpl $0x1, %ecx
ja 0x3592
movl %eax, 0x7f46(%rip)      # 0xb4d8
xorl %eax, %eax
movq 0x7eed(%rip), %rcx      # 0xb488
xorl %edx, %edx
xorl %esi, %esi
cmpl $-0x3, (%rcx,%rax)
sete %sil
addl %esi, %edx
addq $0x10, %rax
cmpq $0x60, %rax
jne 0x359d
testl %edx, %edx
je 0x35e9
movb 0x7ed3(%rip), %cl       # 0xb490
movq 0x7ec4(%rip), %rax      # 0xb488
xorl %edx, %edx
cmpl $-0x3, (%rax,%rdx)
sete %sil
xorb %cl, %sil
movzbl %sil, %esi
notl %esi
orl $-0x2, %esi
movl %esi, (%rax,%rdx)
addq $0x10, %rdx
cmpq $0x60, %rdx
jne 0x35c6
jmp 0x3667
movdqa 0x3a1f(%rip), %xmm0     # 0x7010
movl $0x10, %ecx
movq 0x7e8b(%rip), %rax      # 0xb488
movdqa 0x3a1b(%rip), %xmm1     # 0x7020
movdqa 0x3a23(%rip), %xmm2     # 0x7030
pshufd $0xf5, %xmm2, %xmm3     # xmm3 = xmm2[1,1,3,3]
movdqa 0x3a26(%rip), %xmm4     # 0x7040
movdqa %xmm0, %xmm5
pxor %xmm1, %xmm5
movdqa %xmm2, %xmm6
pcmpgtd %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm5     # xmm5 = xmm5[1,1,3,3]
pcmpeqd %xmm3, %xmm5
pand %xmm6, %xmm5
movd %xmm5, %edx
testb $0x1, %dl
je 0x3648
movl $0xfffffffe, -0x10(%rax,%rcx) # imm = 0xFFFFFFFE
pextrw $0x4, %xmm5, %edx
testb $0x1, %dl
je 0x3659
movl $0xfffffffe, (%rax,%rcx) # imm = 0xFFFFFFFE
paddq %xmm4, %xmm0
addq $0x20, %rcx
cmpq $0x70, %rcx
jne 0x361a
cmpl $0x0, 0x7bb6(%rip)      # 0xb224
jns 0x377b
xorl %ecx, %ecx
xorl %edx, %edx
xorl %esi, %esi
cmpl $-0x2, (%rax,%rcx)
sete %sil
addl %esi, %edx
addq $0x10, %rcx
cmpq $0x60, %rcx
jne 0x3678
movl $0x1, %r12d
cmpl $0x2, %edx
jb 0x3774
movb $0xa, 0x40(%rsp)
leaq 0x44fe(%rip), %rdi      # 0x7ba7
xorl %r12d, %r12d
xorl %esi, %esi
xorl %eax, %eax
callq 0x2320
cmpl $-0x1, %eax
je 0x3774
movl %eax, %ebp
leaq 0x220(%rsp), %rbx
movl $0x1, %ecx
leaq 0x3a07(%rip), %r14      # 0x70db
leaq 0x40(%rsp), %r15
movq %rcx, %r13
cmpq $0x1fe, %rcx            # imm = 0x1FE
ja 0x3705
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 0x36d9
movb $0x0, 0x40(%rsp,%r13)
movq %r15, %rdi
movq %r14, %rsi
callq 0x23d0
testq %rax, %rax
setne %cl
cmpq %rbx, %rax
setb %dl
testb %dl, %cl
jne 0x3755
cmpq $0x1ff, %r13            # imm = 0x1FF
jne 0x374c
movdqu -0x1(%rbx), %xmm0
movdqu 0xf(%rbx), %xmm1
movdqa %xmm1, 0x50(%rsp)
movdqa %xmm0, 0x40(%rsp)
movl $0x20, %ecx
jmp 0x36d9
movl %ebp, %edi
callq 0x21d0
jmp 0x3774
addq $0xb, %rax
movq %rax, %rdi
callq 0x2360
movl %eax, %ebx
movl %ebp, %edi
callq 0x21d0
testl %ebx, %ebx
je 0x3774
movl $0x1, %r12d
movl %r12d, 0x7aa9(%rip)     # 0xb224
cmpb $0x1, 0x7d12(%rip)      # 0xb494
jne 0x37d5
cmpl $0x3, 0x7a95(%rip)      # 0xb220
jl 0x3797
movl $0x2, 0x7a89(%rip)      # 0xb220
movb $0x1, 0x7cfa(%rip)      # 0xb498
cmpb $0x0, 0x7cf7(%rip)      # 0xb49c
jne 0x37d5
xorl %eax, %eax
movq 0x7cd8(%rip), %rcx      # 0xb488
xorl %esi, %esi
xorl %edx, %edx
cmpl $-0x2, (%rcx,%rax)
sete %dl
addl %edx, %esi
addq $0x10, %rax
cmpq $0x60, %rax
jne 0x37b2
leaq 0x3a22(%rip), %rdi      # 0x71f0
xorl %eax, %eax
callq 0x2180
movl 0x7cc5(%rip), %ebp      # 0xb4a0
movq 0x7ca6(%rip), %rax      # 0xb488
leaq 0x28(%rsp), %r14
leaq 0x40(%rsp), %r13
xorl %r12d, %r12d
cmpl $-0x2, (%rax,%r12)
jne 0x3983
leaq 0x754f(%rip), %rax      # 0xad50
leaq (%rax,%r12), %r15
movq %r15, 0x7b3c(%rip)      # 0xb348
movl $0x0, 0x7b2e(%rip)      # 0xb344
movl 0x7cbc(%rip), %edi      # 0xb4d8
movq %r14, %rsi
callq 0x2100
cmpl $0x0, 0x79f9(%rip)      # 0xb224
je 0x383e
movq %r15, %rdi
movl %ebp, %esi
callq 0x549c
movl %eax, %ebx
jmp 0x3926
movq 0x778b(%rip), %rax      # 0xafd0
movq (%rax), %rdi
callq 0x22a0
movq 0x779c(%rip), %rax      # 0xaff0
movq (%rax), %rdi
callq 0x22a0
callq 0x23c0
cmpl $-0x1, %eax
je 0x38bf
testl %eax, %eax
je 0x3cc5
movl %eax, %edi
leaq 0x24(%rsp), %rsi
xorl %edx, %edx
callq 0x22f0
movl 0x24(%rsp), %eax
movl %eax, %ecx
andl $0x7f, %ecx
je 0x38e3
movl %ecx, %edx
shll $0x18, %edx
addl $0x1000000, %edx        # imm = 0x1000000
cmpl $0x2000000, %edx        # imm = 0x2000000
jl 0x38e8
cmpl $0x10, %ecx
jae 0x38fa
movq %rcx, %rax
decq %rax
movl $0x452f, %edx           # imm = 0x452F
btl %eax, %edx
jae 0x38fa
leaq 0x3866(%rip), %rcx      # 0x711c
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
jmp 0x3913
callq 0x2060
movq %rax, %rbx
movl (%rax), %edi
callq 0x23b0
movl (%rbx), %edx
leaq 0x42e2(%rip), %rdi      # 0x7bb9
movq %rax, %rsi
xorl %eax, %eax
callq 0x53bb
jmp 0x3921
movzbl %ah, %ebx
jmp 0x3926
leaq 0x433e(%rip), %rdi      # 0x7c2d
movl %eax, %esi
xorl %eax, %eax
callq 0x53bb
jmp 0x3921
movl $0x20, %esi
movq %r13, %rdi
leaq 0x4302(%rip), %rdx      # 0x7c0b
xorl %eax, %eax
callq 0x2190
movq %r13, %rsi
leaq 0x42fb(%rip), %rdi      # 0x7c15
xorl %eax, %eax
callq 0x53bb
movl $0x1, %ebx
incl %ebp
movl 0x7baa(%rip), %edi      # 0xb4d8
movq %r13, %rsi
callq 0x2100
movq $0x0, 0x7a07(%rip) # 0xb348
movq 0x7b40(%rip), %rax      # 0xb488
movl %ebx, (%rax,%r12)
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %rdx
subq 0x28(%rsp), %rcx
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
subq 0x30(%rsp), %rdx
xorps %xmm1, %xmm1
cvtsi2sd %rdx, %xmm1
divsd 0x3690(%rip), %xmm1     # 0x7008
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rax,%r12)
addq $0x10, %r12
cmpq $0x60, %r12
jne 0x37ef
movl 0x7889(%rip), %ecx      # 0xb220
testl %ecx, %ecx
setle %dl
orb 0x7af6(%rip), %dl       # 0xb498
testb $0x1, %dl
movq 0x8(%rsp), %rbx
jne 0x3ac1
xorl %esi, %esi
xorl %edx, %edx
xorl %edi, %edi
cmpl $-0x1, (%rax,%rsi)
sete %dil
addl %edi, %edx
addq $0x10, %rsi
cmpq $0x60, %rsi
jne 0x39b4
xorl %esi, %esi
xorl %r14d, %r14d
cmpl $0x1, (%rax,%rsi)
adcl $0x0, %r14d
addq $0x10, %rsi
cmpq $0x60, %rsi
jne 0x39cf
xorl %esi, %esi
xorl %ebp, %ebp
xorl %edi, %edi
cmpl $0x1, (%rax,%rsi)
sete %dil
addl %edi, %ebp
addq $0x10, %rsi
cmpq $0x60, %rsi
jne 0x39e5
movl $0x6, %r15d
subl %edx, %r15d
cmpl $0x3, %ecx
jl 0x3a4e
leaq 0x37e7(%rip), %rsi      # 0x71f7
movl $0xa, %edi
xorl %eax, %eax
callq 0x2c74
leaq 0x37de(%rip), %rdi      # 0x7201
movl %r15d, %esi
xorl %eax, %eax
callq 0x2180
leaq 0x37f4(%rip), %rdi      # 0x7228
movl %r14d, %esi
xorl %eax, %eax
callq 0x2180
leaq 0x380a(%rip), %rdi      # 0x724f
movl %ebp, %esi
xorl %eax, %eax
callq 0x2180
testl %ebp, %ebp
je 0x3a8f
leaq 0x3826(%rip), %rsi      # 0x727f
movl $0xb, %edi
xorl %eax, %eax
callq 0x2c74
cmpl $0x1, %ebp
leaq 0x3839(%rip), %rax      # 0x72a8
leaq 0x3836(%rip), %rcx      # 0x72ac
cmoveq %rax, %rcx
leaq 0x3806(%rip), %rdi      # 0x7287
movl %ebp, %esi
movl %r15d, %edx
xorl %eax, %eax
callq 0x2180
jmp 0x3aae
leaq 0x37e0(%rip), %rsi      # 0x7276
movl $0xc, %edi
xorl %eax, %eax
callq 0x2c74
leaq 0x4264(%rip), %rdi      # 0x7d0d
callq 0x20a0
cmpl $0x3, 0x776b(%rip)      # 0xb220
jl 0x3ac1
movl $0xa, %edi
callq 0x2050
movq 0x79e0(%rip), %r14      # 0xb4a8
testq %r14, %r14
je 0x3c43
movq (%rbx), %r15
movq %r15, %rdi
movl $0x2f, %esi
callq 0x21a0
leaq 0x1(%rax), %rbx
testq %rax, %rax
cmoveq %r15, %rbx
leaq 0x37be(%rip), %rdi      # 0x72b1
movl $0x27, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x2390
movq 0x799c(%rip), %rdi      # 0xb4a8
xorl %ecx, %ecx
movq 0x7973(%rip), %rax      # 0xb488
xorl %r8d, %r8d
xorl %edx, %edx
cmpl $0x1, (%rax,%rcx)
sete %dl
addl %edx, %r8d
addq $0x10, %rcx
cmpq $0x60, %rcx
jne 0x3b18
xorl %edx, %edx
xorl %ecx, %ecx
xorl %esi, %esi
cmpl $0x2, (%rax,%rdx)
sete %sil
addl %esi, %ecx
addq $0x10, %rdx
cmpq $0x60, %rdx
jne 0x3b32
xorl %edx, %edx
xorl %r9d, %r9d
xorl %esi, %esi
cmpl $-0x1, (%rax,%rdx)
sete %sil
addl %esi, %r9d
addq $0x10, %rdx
cmpq $0x60, %rdx
jne 0x3b4d
addl %ecx, %r9d
leaq 0x376b(%rip), %rsi      # 0x72d9
movq %rbx, %rdx
movl $0x6, %ecx
xorl %eax, %eax
callq 0x2250
leaq 0x379a(%rip), %rbx      # 0x731e
leaq 0x37b7(%rip), %r12      # 0x7342
leaq 0x37c8(%rip), %r14      # 0x735a
leaq 0x37c9(%rip), %r15      # 0x7362
xorl %ebp, %ebp
movq 0x78e6(%rip), %r13      # 0xb488
movq 0x78ff(%rip), %rdi      # 0xb4a8
leaq 0x71a0(%rip), %rax      # 0xad50
movq (%rbp,%rax), %rdx
movq 0x8(%r13,%rbp), %xmm0
movq %rbx, %rsi
movb $0x1, %al
callq 0x2250
movl (%r13,%rbp), %eax
movq %r12, %rdx
cmpl $-0x1, %eax
je 0x3be6
testl %eax, %eax
je 0x3bf7
movq %r12, %rdx
cmpl $0x2, %eax
je 0x3be6
leaq 0x3768(%rip), %rdx      # 0x734e
movq 0x78bb(%rip), %rdi      # 0xb4a8
movq %r14, %rsi
xorl %eax, %eax
callq 0x2250
movq 0x78aa(%rip), %rcx      # 0xb4a8
movl $0xe, %esi
movl $0x1, %edx
movq %r15, %rdi
callq 0x2390
addq $0x10, %rbp
cmpq $0x60, %rbp
jne 0x3b9b
movq 0x7887(%rip), %rcx      # 0xb4a8
leaq 0x3749(%rip), %rdi      # 0x7371
movl $0xd, %esi
movl $0x1, %edx
callq 0x2390
movq 0x786a(%rip), %rdi      # 0xb4a8
callq 0x2130
movq 0x783e(%rip), %rdi      # 0xb488
cmpb $0x1, 0x784b(%rip)      # 0xb49c
jne 0x3c8c
xorl %eax, %eax
xorl %ecx, %ecx
xorl %edx, %edx
cmpl $-0x1, (%rdi,%rax)
sete %dl
addl %edx, %ecx
addq $0x10, %rax
cmpq $0x60, %rax
jne 0x3c57
cmpl $0x5, %ecx
jne 0x3c8c
xorl %eax, %eax
movl (%rdi,%rax), %ebx
cmpl $-0x1, %ebx
jne 0x3cac
addq $0x10, %rax
cmpq $0x60, %rax
jne 0x3c73
movl $0x1, %ebx
jmp 0x3cac
xorl %eax, %eax
xorl %ecx, %ecx
xorl %edx, %edx
cmpl $0x1, (%rdi,%rax)
sete %dl
addl %edx, %ecx
addq $0x10, %rax
cmpq $0x60, %rax
jne 0x3c90
xorl %ebx, %ebx
testl %ecx, %ecx
setne %bl
callq 0x2040
movl %ebx, %eax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, 0x77d0(%rip)      # 0xb49c
movq %r15, %rdi
movl %ebp, %esi
callq 0x549c
movl %eax, %edi
callq 0x3205
callq 0x2430