// File: /workspace/github_cpp_makefile_star2_O1/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
movl %edi, %r15d
movq %rsi, 0x18(%rsp)
movq (%rsi), %rax
movq %rax, 0x8261(%rip)      # 0xb478
movl $0x1, %edi
callq 0x20b0
movl %eax, 0x8259(%rip)      # 0xb480
movb $0x1, 0x8256(%rip)      # 0xb484
movl $0x6, %edi
movl $0x10, %esi
callq 0x2210
movq %rax, 0x8244(%rip)      # 0xb488
testq %rax, %rax
je 0x3d72
movb $0x0, 0x60(%rsp)
cmpl $0x2, %r15d
jl 0x3613
movl $0x1, %r13d
leaq 0x46bd(%rip), %r12      # 0x7926
xorl %ebp, %ebp
movl %r15d, 0x4(%rsp)
movslq %r13d, %r14
testl %ebp, %ebp
je 0x329c
movq 0x18(%rsp), %rax
movq (%rax,%r14,8), %rsi
xorl %edi, %edi
callq 0x3d77
testl %eax, %eax
jne 0x3613
incl %r13d
cmpl %r15d, %r13d
jl 0x3270
jmp 0x3613
movq 0x18(%rsp), %rax
movq (%rax,%r14,8), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2220
testl %eax, %eax
je 0x3277
movq %r14, 0x20(%rsp)
movq %rbx, %rdi
leaq 0x4662(%rip), %rsi      # 0x7925
callq 0x2220
testl %eax, %eax
je 0x341a
cmpb $0x2d, (%rbx)
jne 0x3426
movq %r13, 0x8(%rsp)
xorl %ebx, %ebx
movl $0x58, %r13d
leaq 0x78c3(%rip), %r12      # 0xabb0
movl $0x0, (%rsp)
movq 0x20(%rsp), %rbp
movq 0x8(%r12), %r14
testq %r14, %r14
je 0x3324
movq 0x18(%rsp), %rax
movq (%rax,%rbp,8), %r15
movl $0x2, %edx
movq %r15, %rdi
leaq 0x460a(%rip), %rsi      # 0x7925
callq 0x2090
testl %eax, %eax
je 0x3344
movb (%r12), %al
testb %al, %al
je 0x337c
movq 0x18(%rsp), %rcx
movq (%rcx,%rbp,8), %rsi
cmpb $0x2d, (%rsi)
jne 0x337c
cmpb %al, 0x1(%rsi)
jne 0x337c
jmp 0x3432
movl %ebx, 0x14(%rsp)
movq %r14, %rdi
callq 0x2150
movq %rax, %rbx
leaq 0x2(%r15), %rbp
movq %rbp, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2090
testl %eax, %eax
je 0x3396
xorl %eax, %eax
movl 0x14(%rsp), %ebx
movq 0x20(%rsp), %rbp
testb %al, %al
jne 0x3510
movl 0x28(%r12), %r13d
addq $0x18, %r12
testl %r13d, %r13d
sete %bl
jne 0x32f9
jmp 0x3510
movzbl 0x2(%r15,%rbx), %eax
cmpl $0x3d, %eax
je 0x33bd
testl %eax, %eax
jne 0x3369
testb $0x2, 0x14(%r12)
movl 0x14(%rsp), %ebx
movq 0x20(%rsp), %rbp
jne 0x33d1
movl %r13d, %edi
xorl %esi, %esi
jmp 0x33d9
testb $0x3, 0x14(%r12)
je 0x33e5
leaq (%rbx,%rbp), %rsi
incq %rsi
movl %r13d, %edi
jmp 0x340b
movl $0x80000002, %edi       # imm = 0x80000002
movq %r15, %rsi
callq 0x3d77
movl %eax, (%rsp)
movb $0x1, %al
jmp 0x3374
movl $0x21, %esi
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
leaq 0x452f(%rip), %rdx      # 0x7928
movq %r14, %rcx
xorl %eax, %eax
callq 0x2190
movl $0x80000003, %edi       # imm = 0x80000003
movq %rbx, %rsi
callq 0x3d77
movl %eax, (%rsp)
movb $0x1, %al
jmp 0x336b
movl $0x1, %ebp
xorl %eax, %eax
jmp 0x3287
xorl %ebp, %ebp
xorl %edi, %edi
movq %rbx, %rsi
jmp 0x3282
testb $0x2, 0x14(%r12)
jne 0x34f7
movl %r13d, %edi
xorl %esi, %esi
callq 0x3d77
movl %eax, (%rsp)
testl %eax, %eax
jne 0x3510
movq %rbp, %rcx
movl %ebx, %ebp
movq 0x18(%rsp), %rax
movq (%rax,%rcx,8), %rbx
movb 0x2(%rbx), %cl
movl $0x0, (%rsp)
testb %cl, %cl
movl 0x4(%rsp), %r15d
leaq 0x44ad(%rip), %r12      # 0x7926
je 0x3607
xorl %r14d, %r14d
leaq 0x30(%rsp), %r13
movl $0x58, %edi
leaq 0x771d(%rip), %rdx      # 0xabb0
cmpb $0x58, %cl
je 0x34b2
leaq 0x7711(%rip), %rax      # 0xabb0
movl 0x28(%rax), %edi
testl %edi, %edi
je 0x34c1
leaq 0x18(%rax), %rdx
cmpb 0x18(%rax), %cl
movq %rdx, %rax
jne 0x349f
movl $0x80000002, %eax       # imm = 0x80000002
testb $0x2, 0x14(%rdx)
jne 0x34c6
xorl %esi, %esi
jmp 0x34d9
movl $0x80000001, %eax       # imm = 0x80000001
movb $0x2d, 0x30(%rsp)
movb %cl, 0x31(%rsp)
movb $0x0, 0x32(%rsp)
movl %eax, %edi
movq %r13, %rsi
callq 0x3d77
testl %eax, %eax
jne 0x3604
movb 0x3(%rbx,%r14), %cl
incq %r14
testb %cl, %cl
jne 0x3487
jmp 0x3607
cmpb $0x0, 0x2(%rsi)
je 0x35b7
addq $0x2, %rsi
movl %r13d, %edi
callq 0x3d77
movl %eax, (%rsp)
movl 0x4(%rsp), %r15d
leaq 0x440a(%rip), %r12      # 0x7926
movq 0x8(%rsp), %r13
xorl %ebp, %ebp
testb $0x1, %bl
je 0x35a3
movslq %r13d, %rax
movq 0x18(%rsp), %rcx
movq (%rcx,%rax,8), %r14
cmpb $0x2d, (%r14)
jne 0x35ab
movl $0x2, %edx
movq %r14, %rdi
leaq 0x43dc(%rip), %rsi      # 0x7925
callq 0x2090
testl %eax, %eax
jne 0x359c
movq %r14, %rdi
movl $0x3d, %esi
callq 0x2170
testq %rax, %rax
je 0x359c
movq %rax, %rbx
subq %r14, %rbx
cmpq $0x20, %rbx
movl $0x20, %eax
cmovaeq %rax, %rbx
movq %r13, 0x8(%rsp)
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2080
movb $0x0, 0x40(%rsp,%rbx)
movq %r13, %r14
movq 0x8(%rsp), %r13
movl $0x80000001, %edi       # imm = 0x80000001
jmp 0x35af
movl (%rsp), %eax
jmp 0x3287
xorl %ebp, %ebp
xorl %edi, %edi
movq %r14, %rsi
jmp 0x3282
movl %ebx, %ebp
movq 0x8(%rsp), %rax
leal 0x1(%rax), %ebx
movl 0x4(%rsp), %r15d
cmpl %r15d, %ebx
jge 0x35ee
movslq %ebx, %rax
movq 0x18(%rsp), %rcx
movq (%rcx,%rax,8), %rsi
movl %r13d, %edi
callq 0x3d77
movl %eax, (%rsp)
movl %ebx, %r13d
leaq 0x433a(%rip), %r12      # 0x7926
jmp 0x360c
movl $0x80000002, %edi       # imm = 0x80000002
callq 0x3d77
movl %eax, (%rsp)
leaq 0x4324(%rip), %r12      # 0x7926
jmp 0x3607
movl %eax, (%rsp)
movq 0x8(%rsp), %r13
movl %ebp, %ebx
jmp 0x3521
movl 0x7e9b(%rip), %eax      # 0xb4b4
leal -0x1(%rax), %ecx
cmpl $0x1, %ecx
ja 0x3627
movl %eax, 0x7eb1(%rip)      # 0xb4d8
xorl %eax, %eax
movq 0x7e58(%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 0x3632
testl %edx, %edx
je 0x367e
movb 0x7e3e(%rip), %al       # 0xb490
movq 0x7e2f(%rip), %rcx      # 0xb488
xorl %edx, %edx
cmpl $-0x3, (%rcx,%rdx)
sete %sil
xorb %al, %sil
movzbl %sil, %esi
notl %esi
orl $-0x2, %esi
movl %esi, (%rcx,%rdx)
addq $0x10, %rdx
cmpq $0x60, %rdx
jne 0x365b
jmp 0x3698
movq 0x7e03(%rip), %rax      # 0xb488
xorl %ecx, %ecx
movl $0xfffffffe, (%rax,%rcx) # imm = 0xFFFFFFFE
addq $0x10, %rcx
cmpq $0x60, %rcx
jne 0x3687
cmpl $0x0, 0x7b85(%rip)      # 0xb224
jns 0x37c3
xorl %eax, %eax
movq 0x7dda(%rip), %rcx      # 0xb488
xorl %edx, %edx
xorl %esi, %esi
cmpl $-0x2, (%rcx,%rax)
sete %sil
addl %esi, %edx
addq $0x10, %rax
cmpq $0x60, %rax
jne 0x36b0
movl $0x1, %eax
cmpl $0x2, %edx
jb 0x37bd
movb $0xa, 0x40(%rsp)
leaq 0x4492(%rip), %rdi      # 0x7b72
xorl %r14d, %r14d
xorl %esi, %esi
xorl %eax, %eax
callq 0x2320
cmpl $-0x1, %eax
je 0x37bb
movl %eax, %ebp
leaq 0x220(%rsp), %r13
movl $0x1, %ebx
leaq 0x3980(%rip), %r15      # 0x708b
leaq 0x40(%rsp), %r12
cmpq $0x1fe, %rbx            # imm = 0x1FE
ja 0x3744
leaq (%rsp,%rbx), %rsi
addq $0x40, %rsi
movl $0x1ff, %edx            # imm = 0x1FF
subq %rbx, %rdx
movl %ebp, %edi
callq 0x21f0
testq %rax, %rax
movl $0x0, %ecx
cmovgq %rax, %rcx
addq %rcx, %rbx
testq %rax, %rax
jg 0x3710
movb $0x0, 0x40(%rsp,%rbx)
movq %r12, %rdi
movq %r15, %rsi
callq 0x23d0
testq %rax, %rax
setne %cl
cmpq %r13, %rax
setb %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x3778
addq $0xb, %rax
movq %rax, %rdi
callq 0x2360
movl %eax, %r14d
jmp 0x3781
cmpq $0x1ff, %rbx            # imm = 0x1FF
je 0x3789
xorl %eax, %eax
testb %al, %al
jne 0x3710
jmp 0x37aa
movupd -0x1(%r13), %xmm0
movupd 0xf(%r13), %xmm1
movapd %xmm1, 0x50(%rsp)
movapd %xmm0, 0x40(%rsp)
movb $0x1, %al
movl $0x20, %ebx
jmp 0x3783
movl %ebp, %edi
callq 0x21d0
testl %r14d, %r14d
movl $0x1, %eax
jne 0x37bd
xorl %eax, %eax
movl %eax, 0x7a61(%rip)      # 0xb224
cmpb $0x1, 0x7cca(%rip)      # 0xb494
jne 0x381d
cmpl $0x3, 0x7a4d(%rip)      # 0xb220
jl 0x37df
movl $0x2, 0x7a41(%rip)      # 0xb220
movb $0x1, 0x7cb2(%rip)      # 0xb498
cmpb $0x0, 0x7caf(%rip)      # 0xb49c
jne 0x381d
xorl %eax, %eax
movq 0x7c90(%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 0x37fa
leaq 0x39a2(%rip), %rdi      # 0x71b8
xorl %eax, %eax
callq 0x2180
movl 0x7c7d(%rip), %ebp      # 0xb4a0
leaq 0x30(%rsp), %r14
leaq 0x40(%rsp), %r13
xorl %r12d, %r12d
movq 0x7c51(%rip), %rax      # 0xb488
cmpl $-0x2, (%rax,%r12)
jne 0x39cb
leaq 0x7507(%rip), %rax      # 0xad50
leaq (%rax,%r12), %r15
movq %r15, 0x7af4(%rip)      # 0xb348
movl $0x0, 0x7ae6(%rip)      # 0xb344
movl 0x7c74(%rip), %edi      # 0xb4d8
movq %r14, %rsi
callq 0x2100
cmpl $0x0, 0x79b1(%rip)      # 0xb224
je 0x3886
movq %r15, %rdi
movl %ebp, %esi
callq 0x558a
movl %eax, %ebx
jmp 0x396e
movq 0x7743(%rip), %rax      # 0xafd0
movq (%rax), %rdi
callq 0x22a0
movq 0x7754(%rip), %rax      # 0xaff0
movq (%rax), %rdi
callq 0x22a0
callq 0x23c0
cmpl $-0x1, %eax
je 0x3907
testl %eax, %eax
je 0x3d5a
movl %eax, %edi
leaq 0x2c(%rsp), %rsi
xorl %edx, %edx
callq 0x22f0
movl 0x2c(%rsp), %eax
movl %eax, %ecx
andl $0x7f, %ecx
je 0x392b
movl %ecx, %edx
shll $0x18, %edx
addl $0x1000000, %edx        # imm = 0x1000000
cmpl $0x2000000, %edx        # imm = 0x2000000
jl 0x3930
cmpl $0x10, %ecx
jae 0x3942
movq %rcx, %rax
decq %rax
movl $0x452f, %edx           # imm = 0x452F
btl %eax, %edx
jae 0x3942
leaq 0x37ce(%rip), %rcx      # 0x70cc
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
jmp 0x395b
callq 0x2060
movq %rax, %rbx
movl (%rax), %edi
callq 0x23b0
movl (%rbx), %edx
leaq 0x4265(%rip), %rdi      # 0x7b84
movq %rax, %rsi
xorl %eax, %eax
callq 0x54a3
jmp 0x3969
movzbl %ah, %ebx
jmp 0x396e
leaq 0x42c1(%rip), %rdi      # 0x7bf8
movl %eax, %esi
xorl %eax, %eax
callq 0x54a3
jmp 0x3969
movl $0x20, %esi
movq %r13, %rdi
leaq 0x4285(%rip), %rdx      # 0x7bd6
xorl %eax, %eax
callq 0x2190
movq %r13, %rsi
leaq 0x427e(%rip), %rdi      # 0x7be0
xorl %eax, %eax
callq 0x54a3
movl $0x1, %ebx
incl %ebp
movl 0x7b62(%rip), %edi      # 0xb4d8
movq %r13, %rsi
callq 0x2100
movq $0x0, 0x79bf(%rip) # 0xb348
movq 0x7af8(%rip), %rax      # 0xb488
movl %ebx, (%rax,%r12)
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %rdx
subq 0x30(%rsp), %rcx
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
subq 0x38(%rsp), %rdx
xorps %xmm1, %xmm1
cvtsi2sd %rdx, %xmm1
divsd 0x3648(%rip), %xmm1     # 0x7008
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rax,%r12)
addq $0x10, %r12
cmpq $0x60, %r12
jne 0x3830
movl 0x7841(%rip), %eax      # 0xb220
testl %eax, %eax
setle %cl
orb 0x7aae(%rip), %cl       # 0xb498
testb $0x1, %cl
jne 0x3b1b
xorl %ecx, %ecx
movq 0x7a8c(%rip), %rsi      # 0xb488
xorl %edx, %edx
xorl %edi, %edi
cmpl $-0x1, (%rsi,%rcx)
sete %dil
addl %edi, %edx
addq $0x10, %rcx
cmpq $0x60, %rcx
jne 0x39fe
movl $0x6, %ebp
subl %edx, %ebp
xorl %ecx, %ecx
movq 0x7a64(%rip), %rdx      # 0xb488
xorl %r15d, %r15d
cmpl $0x1, (%rdx,%rcx)
adcl $0x0, %r15d
addq $0x10, %rcx
cmpq $0x60, %rcx
jne 0x3a27
xorl %ecx, %ecx
movq 0x7a46(%rip), %rdx      # 0xb488
xorl %r14d, %r14d
xorl %esi, %esi
cmpl $0x1, (%rdx,%rcx)
sete %sil
addl %esi, %r14d
addq $0x10, %rcx
cmpq $0x60, %rcx
jne 0x3a45
cmpl $0x3, %eax
jl 0x3aa6
leaq 0x3757(%rip), %rsi      # 0x71bf
movl $0xa, %edi
xorl %eax, %eax
callq 0x2c57
leaq 0x374e(%rip), %rdi      # 0x71c9
movl %ebp, %esi
xorl %eax, %eax
callq 0x2180
leaq 0x3765(%rip), %rdi      # 0x71f0
movl %r15d, %esi
xorl %eax, %eax
callq 0x2180
leaq 0x377b(%rip), %rdi      # 0x7217
movl %r14d, %esi
xorl %eax, %eax
callq 0x2180
testl %r14d, %r14d
je 0x3ae9
leaq 0x3795(%rip), %rsi      # 0x7247
movl $0xb, %edi
xorl %eax, %eax
callq 0x2c57
cmpl $0x1, %r14d
leaq 0x37a7(%rip), %rax      # 0x7270
leaq 0x37a4(%rip), %rcx      # 0x7274
cmoveq %rax, %rcx
leaq 0x3774(%rip), %rdi      # 0x724f
movl %r14d, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x2180
jmp 0x3b08
leaq 0x374e(%rip), %rsi      # 0x723e
movl $0xc, %edi
xorl %eax, %eax
callq 0x2c57
leaq 0x41d5(%rip), %rdi      # 0x7cd8
callq 0x20a0
cmpl $0x3, 0x7711(%rip)      # 0xb220
jl 0x3b1b
movl $0xa, %edi
callq 0x2050
movq 0x7986(%rip), %r14      # 0xb4a8
testq %r14, %r14
je 0x3cc1
movq 0x18(%rsp), %rax
movq (%rax), %r15
movq %r15, %rdi
movl $0x2f, %esi
callq 0x21a0
leaq 0x1(%rax), %rbx
testq %rax, %rax
cmoveq %r15, %rbx
leaq 0x3727(%rip), %rdi      # 0x7279
movl $0x27, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x2390
movq 0x793d(%rip), %rdi      # 0xb4a8
xorl %eax, %eax
movq 0x7914(%rip), %rcx      # 0xb488
xorl %r8d, %r8d
xorl %edx, %edx
cmpl $0x1, (%rcx,%rax)
sete %dl
addl %edx, %r8d
addq $0x10, %rax
cmpq $0x60, %rax
jne 0x3b77
xorl %ecx, %ecx
movq 0x78f2(%rip), %rdx      # 0xb488
xorl %eax, %eax
xorl %esi, %esi
cmpl $0x2, (%rdx,%rcx)
sete %sil
addl %esi, %eax
addq $0x10, %rcx
cmpq $0x60, %rcx
jne 0x3b98
xorl %ecx, %ecx
movq 0x78d1(%rip), %rdx      # 0xb488
xorl %r9d, %r9d
xorl %esi, %esi
cmpl $-0x1, (%rdx,%rcx)
sete %sil
addl %esi, %r9d
addq $0x10, %rcx
cmpq $0x60, %rcx
jne 0x3bba
addl %eax, %r9d
leaq 0x36c6(%rip), %rsi      # 0x72a1
movq %rbx, %rdx
movl $0x6, %ecx
xorl %eax, %eax
callq 0x2250
leaq 0x36f5(%rip), %rbx      # 0x72e6
leaq 0x3732(%rip), %r14      # 0x732a
leaq 0x3723(%rip), %r15      # 0x7322
xorl %ebp, %ebp
movq 0x7880(%rip), %r12      # 0xb488
movq 0x7899(%rip), %rdi      # 0xb4a8
leaq 0x713a(%rip), %rax      # 0xad50
movq (%rbp,%rax), %rdx
movsd 0x8(%r12,%rbp), %xmm0
movb $0x1, %r13b
movq %rbx, %rsi
movb $0x1, %al
callq 0x2250
movl (%r12,%rbp), %eax
cmpl $0x2, %eax
je 0x3c41
testl %eax, %eax
je 0x3c4d
cmpl $-0x1, %eax
jne 0x3c51
xorl %r13d, %r13d
leaq 0x36bf(%rip), %rdx      # 0x730a
jmp 0x3c5b
xorl %edx, %edx
jmp 0x3c5b
xorl %r13d, %r13d
leaq 0x36bb(%rip), %rdx      # 0x7316
testb %r13b, %r13b
jne 0x3c71
movq 0x7841(%rip), %rdi      # 0xb4a8
movq %r15, %rsi
xorl %eax, %eax
callq 0x2250
movq 0x7830(%rip), %rcx      # 0xb4a8
movl $0xe, %esi
movl $0x1, %edx
movq %r14, %rdi
callq 0x2390
addq $0x10, %rbp
cmpq $0x60, %rbp
jne 0x3c01
movq 0x7809(%rip), %rcx      # 0xb4a8
leaq 0x3693(%rip), %rdi      # 0x7339
movl $0xd, %esi
movl $0x1, %edx
callq 0x2390
movq 0x77ec(%rip), %rdi      # 0xb4a8
callq 0x2130
cmpb $0x1, 0x77d4(%rip)      # 0xb49c
jne 0x3d12
xorl %eax, %eax
movq 0x77b5(%rip), %rcx      # 0xb488
xorl %edx, %edx
xorl %esi, %esi
cmpl $-0x1, (%rcx,%rax)
sete %sil
addl %esi, %edx
addq $0x10, %rax
cmpq $0x60, %rax
jne 0x3cd5
cmpl $0x5, %edx
jne 0x3d12
movq 0x7791(%rip), %rax      # 0xb488
xorl %ecx, %ecx
movl (%rax,%rcx), %ebx
cmpl $-0x1, %ebx
jne 0x3d3a
addq $0x10, %rcx
cmpq $0x60, %rcx
jne 0x3cf9
movl $0x1, %ebx
jmp 0x3d3a
xorl %eax, %eax
movq 0x776d(%rip), %rcx      # 0xb488
xorl %edx, %edx
xorl %esi, %esi
cmpl $0x1, (%rcx,%rax)
sete %sil
addl %esi, %edx
addq $0x10, %rax
cmpq $0x60, %rax
jne 0x3d1d
xorl %ebx, %ebx
testl %edx, %edx
setne %bl
movq 0x7747(%rip), %rdi      # 0xb488
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, 0x773b(%rip)      # 0xb49c
movq %r15, %rdi
movl %ebp, %esi
callq 0x558a
movl %eax, %edi
callq 0x31e5
callq 0x2430