// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/tests/test_openmp.c
// Function: main
int main(int argc, char **argv)
{
    double timer_clock = 0.0;
    unsigned long i = 0;
    size_t limit = 0;
    char *filename_database = NULL;
    parasail_sequences_t *sequences_database = NULL;
    size_t seq_count_database = 0;
    char *filename_queries = NULL;
    parasail_sequences_t *sequences_queries = NULL;
    size_t seq_count_queries = 0;
    char *endptr = NULL;
    char *funcname1 = NULL;
    char *funcname2 = NULL;
    parasail_function_t *function1 = NULL;
    parasail_function_t *function2 = NULL;
    int banded = 0;
    int kbandsize = 3;
    int c = 0;
    char *matrixname = "blosum62";
    const parasail_matrix_t *matrix = NULL;
    int gap_open = 10;
    int gap_extend = 1;
    int N = 1;
    int saturated = 0;
    int smallest_first = 0;
    int biggest_first = 0;
    int truncate = 0;
    int iterations = 1;
    int func_cutoff = 0;
    int iter = 0;
    stats_t stats_time;

    stats_clear(&stats_time);

    while ((c = getopt(argc, argv, "a:A:c:b:f:k:q:o:e:slt:i:")) != -1) {
        switch (c) {
            case 'a':
                funcname1 = optarg;
                break;
            case 'A':
                funcname2 = optarg;
                break;
            case 'b':
                matrixname = optarg;
                break;
            case 'c':
                errno = 0;
                func_cutoff = strtol(optarg, &endptr, 10);
                if (errno) {
                    perror("strtol");
                    exit(1);
                }
                break;
            case 'f':
                filename_database = optarg;
                break;
            case 'q':
                filename_queries = optarg;
                break;
            case 'k':
                errno = 0;
                kbandsize = strtol(optarg, &endptr, 10);
                if (errno) {
                    perror("strtol");
                    exit(1);
                }
                break;
            case 'i':
                errno = 0;
                iterations = strtol(optarg, &endptr, 10);
                if (errno) {
                    perror("strtol");
                    exit(1);
                }
                break;
            case 'o':
                errno = 0;
                gap_open = strtol(optarg, &endptr, 10);
                if (errno) {
                    perror("strtol");
                    exit(1);
                }
                break;
            case 'e':
                errno = 0;
                gap_extend = strtol(optarg, &endptr, 10);
                if (errno) {
                    perror("strtol");
                    exit(1);
                }
                break;
            case 's':
                smallest_first = 1;
                break;
            case 'l':
                biggest_first = 1;
                break;
            case 't':
                errno = 0;
                truncate = strtol(optarg, &endptr, 10);
                if (errno) {
                    perror("strtol");
                    exit(1);
                }
                break;
            case '?':
                if (optopt == 'a'
                        || optopt == 'b'
                        || optopt == 'e'
                        || optopt == 'f'
                        || optopt == 'i'
                        || optopt == 'n'
                        || optopt == 'o'
                        || optopt == 't')
                {
                    fprintf(stderr,
                            "Option -%c requires an argument.\n",
                            optopt);
                }
                else if (isprint(optopt)) {
                    fprintf(stderr, "Unknown option `-%c'.\n",
                            optopt);
                }
                else {
                    fprintf(stderr,
                            "Unknown option character `\\x%x'.\n",
                            optopt);
                }
                exit(1);
            default:
                fprintf(stderr, "default case in getopt\n");
                exit(1);
        }
    }

    if (smallest_first && biggest_first) {
        fprintf(stderr, "cannot choose both smallest and biggest first\n");
        exit(1);
    }

    /* select the function */
    if (funcname1) {
        function1 = parasail_lookup_function(funcname1);
#if HAVE_SSE2
        if (NULL == function1) {
            if (0 == strcmp(funcname1, "ssw_16")) {
                function1 = ssw_16;
            }
            else if (0 == strcmp(funcname1, "ssw_8")) {
                function1 = ssw;
            }
        }
#endif
        if (NULL == function1 && NULL != strstr(funcname1, "nw_banded")) {
            banded = 1;
        }
        if (NULL == function1 && 0 == banded) {
            fprintf(stderr, "Specified function1 not found.\n");
            exit(1);
        }
    }
    else {
        fprintf(stderr, "No alignment function1 specified.\n");
        exit(1);
    }

    if (funcname2) {
        function2 = parasail_lookup_function(funcname2);
        if (NULL == function2) {
            fprintf(stderr, "Specified function2 not found.\n");
            exit(1);
        }
    }

    /* select the substitution matrix */
    if (matrixname) {
        matrix = parasail_matrix_lookup(matrixname);
        if (NULL == matrix) {
            fprintf(stderr, "Specified substitution matrix not found.\n");
            exit(1);
        }
    }

    if (filename_database) {
        sequences_database = parasail_sequences_from_file(filename_database);
        seq_count_database = sequences_database->l;
    }
    else {
        fprintf(stderr, "missing database filename\n");
        exit(1);
    }

    limit = binomial_coefficient(seq_count_database, 2);
    /*printf("%lu choose 2 is %lu\n", seq_count_database, limit);*/

#if defined(_OPENMP)
#pragma omp parallel
    {
#pragma omp single
        {
            N = omp_get_max_threads();
            /*printf("omp_get_max_threads()=%d\n", N);*/
        }
    }
#endif

    if (filename_queries) {
        double total_timer = 0.0;
        sequences_queries = parasail_sequences_from_file(filename_queries);
        seq_count_queries = sequences_queries->l;
        for (i=0; i<seq_count_queries; ++i) {
            int saturated_query = 0;
            double local_timer = 0.0;
            parasail_function_t *function = function1;

            if (func_cutoff > 0) {
                if (sequences_queries->seqs[i].seq.l > (unsigned long)func_cutoff) {
                    function = function2;
                }
            }

            local_timer = timer_real();
#pragma omp parallel
            {
				long long int seq_count_database_signed = seq_count_database;
				long long int j_signed = 0;
#pragma omp for schedule(guided)
                for (j_signed=0; j_signed<seq_count_database_signed; ++j_signed) {
                    parasail_result_t *result = function(
                            sequences_queries->seqs[i].seq.s,
                            sequences_queries->seqs[i].seq.l,
                            sequences_database->seqs[j_signed].seq.s,
                            sequences_database->seqs[j_signed].seq.l,
                            gap_open, gap_extend, matrix);
#pragma omp atomic
                    saturated_query += parasail_result_is_saturated(result);
                    parasail_result_free(result);
                }
            }
            local_timer = timer_real() - local_timer;
            total_timer += local_timer;
            printf("%lu\t %lu\t %d\t %f\n",
                    i, (unsigned long)sequences_queries->seqs[i].seq.l,
                    saturated_query, local_timer);
            fflush(stdout);
        }
        printf("total_time=%f\n", total_timer);
        fflush(stdout);
    }
    else {
        for (iter=0; iter<iterations; ++iter) {
            timer_clock = timer_real();
#pragma omp parallel
            {
                unsigned long a=0;
                unsigned long b=1;
                unsigned long swap=0;
				long long i_signed = 0;
				long long limit_signed = limit;
#pragma omp for schedule(guided)
                for (i_signed=0; i_signed<limit_signed; ++i_signed) {
                    parasail_function_t *function = function1;
                    parasail_result_t *result = NULL;
                    unsigned long query_size;
                    k_combination2(i_signed, &a, &b);
                    if (smallest_first) {
                        if (sequences_database->seqs[a].seq.l > sequences_database->seqs[b].seq.l) {
                            swap = a;
                            a = b;
                            b = swap;
                        }
                    }
                    else if (biggest_first) {
                        if (sequences_database->seqs[a].seq.l < sequences_database->seqs[b].seq.l) {
                            swap = a;
                            a = b;
                            b = swap;
                        }
                    }
                    query_size = sequences_database->seqs[a].seq.l;
                    if (truncate > 0) {
                        if (query_size > (unsigned long)truncate) {
                            query_size = truncate;
                        }
                    }
                    if (func_cutoff > 0) {
                        if (query_size > (unsigned long)func_cutoff) {
                            function = function2;
                        }
                    }
                    if (NULL != function1) {
                        result = function(
                                sequences_database->seqs[a].seq.s, query_size,
                                sequences_database->seqs[b].seq.s, sequences_database->seqs[b].seq.l,
                                gap_open, gap_extend, matrix);
                    }
                    else if (0 != banded) {
                        result = parasail_nw_banded(
                                sequences_database->seqs[a].seq.s, query_size,
                                sequences_database->seqs[b].seq.s, sequences_database->seqs[b].seq.l,
                                gap_open, gap_extend, kbandsize, matrix);
                    }
#pragma omp atomic
                    saturated += parasail_result_is_saturated(result);
                    if (parasail_result_is_saturated(result)) {
#pragma omp critical(printer)
                        {
                            printf("saturated -- (%lu,%lu)\n", a, b);
                        }
                    }
                    parasail_result_free(result);
                }
            }
            timer_clock = timer_real() - timer_clock;
            stats_sample_value(&stats_time, timer_clock);
        }
        printf("%s\t %s\t %d\t %d\t %d\t %d\t %f\t %f\t %f\t %f\n",
                funcname1, matrixname, gap_open, gap_extend, N,
                saturated,
                stats_time._mean, stats_stddev(&stats_time),
                stats_time._min, stats_time._max);
        fflush(stdout);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq $0x0, -0x60(%rbp)
movq $0x0, -0x68(%rbp)
movq $0x0, -0x70(%rbp)
movq $0x0, -0x78(%rbp)
movq $0x0, -0x80(%rbp)
movl $0x0, -0x84(%rbp)
movl $0x3, -0x88(%rbp)
movl $0x0, -0x8c(%rbp)
leaq 0xad0de2(%rip), %rax    # 0xd6c1b0
movq %rax, -0x98(%rbp)
movq $0x0, -0xa0(%rbp)
movl $0xa, -0xa4(%rbp)
movl $0x1, -0xa8(%rbp)
movl $0x1, -0xac(%rbp)
movl $0x0, -0xb0(%rbp)
movl $0x0, -0xb4(%rbp)
movl $0x0, -0xb8(%rbp)
movl $0x0, -0xbc(%rbp)
movl $0x1, -0xc0(%rbp)
movl $0x0, -0xc4(%rbp)
movl $0x0, -0xc8(%rbp)
leaq -0xf8(%rbp), %rdi
callq 0x29c100
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0xad0d5b(%rip), %rdx    # 0xd6c1b9
callq 0x29b060
movl %eax, -0x8c(%rbp)
cmpl $-0x1, %eax
je 0x29b812
movl -0x8c(%rbp), %eax
addl $-0x3f, %eax
movl %eax, %ecx
movq %rcx, -0x178(%rbp)
subl $0x35, %eax
ja 0x29b7eb
movq -0x178(%rbp), %rax
leaq 0xad0b75(%rip), %rcx    # 0xd6c010
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0xc91b15(%rip), %rax    # 0xf2cfc0
movq (%rax), %rax
movq %rax, -0x68(%rbp)
jmp 0x29b80d
movq 0xc91b02(%rip), %rax    # 0xf2cfc0
movq (%rax), %rax
movq %rax, -0x70(%rbp)
jmp 0x29b80d
movq 0xc91aef(%rip), %rax    # 0xf2cfc0
movq (%rax), %rax
movq %rax, -0x98(%rbp)
jmp 0x29b80d
callq 0x29b030
movl $0x0, (%rax)
movq 0xc91ace(%rip), %rax    # 0xf2cfc0
movq (%rax), %rdi
leaq -0x60(%rbp), %rsi
movl $0xa, %edx
callq 0x29b1a0
movl %eax, -0xc4(%rbp)
callq 0x29b030
cmpl $0x0, (%rax)
je 0x29b529
leaq 0xad0cb8(%rip), %rdi    # 0xd6c1d2
callq 0x29b0f0
movl $0x1, %edi
callq 0x29b170
jmp 0x29b80d
movq 0xc91a8b(%rip), %rax    # 0xf2cfc0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x29b80d
movq 0xc91a78(%rip), %rax    # 0xf2cfc0
movq (%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x29b80d
callq 0x29b030
movl $0x0, (%rax)
movq 0xc91a5a(%rip), %rax    # 0xf2cfc0
movq (%rax), %rdi
leaq -0x60(%rbp), %rsi
movl $0xa, %edx
callq 0x29b1a0
movl %eax, -0x88(%rbp)
callq 0x29b030
cmpl $0x0, (%rax)
je 0x29b59d
leaq 0xad0c44(%rip), %rdi    # 0xd6c1d2
callq 0x29b0f0
movl $0x1, %edi
callq 0x29b170
jmp 0x29b80d
callq 0x29b030
movl $0x0, (%rax)
movq 0xc91a0c(%rip), %rax    # 0xf2cfc0
movq (%rax), %rdi
leaq -0x60(%rbp), %rsi
movl $0xa, %edx
callq 0x29b1a0
movl %eax, -0xc0(%rbp)
callq 0x29b030
cmpl $0x0, (%rax)
je 0x29b5eb
leaq 0xad0bf6(%rip), %rdi    # 0xd6c1d2
callq 0x29b0f0
movl $0x1, %edi
callq 0x29b170
jmp 0x29b80d
callq 0x29b030
movl $0x0, (%rax)
movq 0xc919be(%rip), %rax    # 0xf2cfc0
movq (%rax), %rdi
leaq -0x60(%rbp), %rsi
movl $0xa, %edx
callq 0x29b1a0
movl %eax, -0xa4(%rbp)
callq 0x29b030
cmpl $0x0, (%rax)
je 0x29b639
leaq 0xad0ba8(%rip), %rdi    # 0xd6c1d2
callq 0x29b0f0
movl $0x1, %edi
callq 0x29b170
jmp 0x29b80d
callq 0x29b030
movl $0x0, (%rax)
movq 0xc91970(%rip), %rax    # 0xf2cfc0
movq (%rax), %rdi
leaq -0x60(%rbp), %rsi
movl $0xa, %edx
callq 0x29b1a0
movl %eax, -0xa8(%rbp)
callq 0x29b030
cmpl $0x0, (%rax)
je 0x29b687
leaq 0xad0b5a(%rip), %rdi    # 0xd6c1d2
callq 0x29b0f0
movl $0x1, %edi
callq 0x29b170
jmp 0x29b80d
movl $0x1, -0xb4(%rbp)
jmp 0x29b80d
movl $0x1, -0xb8(%rbp)
jmp 0x29b80d
callq 0x29b030
movl $0x0, (%rax)
movq 0xc91904(%rip), %rax    # 0xf2cfc0
movq (%rax), %rdi
leaq -0x60(%rbp), %rsi
movl $0xa, %edx
callq 0x29b1a0
movl %eax, -0xbc(%rbp)
callq 0x29b030
cmpl $0x0, (%rax)
je 0x29b6f3
leaq 0xad0aee(%rip), %rdi    # 0xd6c1d2
callq 0x29b0f0
movl $0x1, %edi
callq 0x29b170
jmp 0x29b80d
movq 0xc918d9(%rip), %rax    # 0xf2cfd8
cmpl $0x61, (%rax)
je 0x29b758
movq 0xc918cd(%rip), %rax    # 0xf2cfd8
cmpl $0x62, (%rax)
je 0x29b758
movq 0xc918c1(%rip), %rax    # 0xf2cfd8
cmpl $0x65, (%rax)
je 0x29b758
movq 0xc918b5(%rip), %rax    # 0xf2cfd8
cmpl $0x66, (%rax)
je 0x29b758
movq 0xc918a9(%rip), %rax    # 0xf2cfd8
cmpl $0x69, (%rax)
je 0x29b758
movq 0xc9189d(%rip), %rax    # 0xf2cfd8
cmpl $0x6e, (%rax)
je 0x29b758
movq 0xc91891(%rip), %rax    # 0xf2cfd8
cmpl $0x6f, (%rax)
je 0x29b758
movq 0xc91885(%rip), %rax    # 0xf2cfd8
cmpl $0x74, (%rax)
jne 0x29b77b
movq 0xc91881(%rip), %rax    # 0xf2cfe0
movq (%rax), %rdi
movq 0xc9186f(%rip), %rax    # 0xf2cfd8
movl (%rax), %edx
leaq 0xad0a67(%rip), %rsi    # 0xd6c1d9
movb $0x0, %al
callq 0x29b1b0
jmp 0x29b7e1
callq 0x29b130
movq (%rax), %rax
movq 0xc9184e(%rip), %rcx    # 0xf2cfd8
movslq (%rcx), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0x29b7be
movq 0xc9183e(%rip), %rax    # 0xf2cfe0
movq (%rax), %rdi
movq 0xc9182c(%rip), %rax    # 0xf2cfd8
movl (%rax), %edx
leaq 0xad0a46(%rip), %rsi    # 0xd6c1fb
movb $0x0, %al
callq 0x29b1b0
jmp 0x29b7df
movq 0xc9181b(%rip), %rax    # 0xf2cfe0
movq (%rax), %rdi
movq 0xc91809(%rip), %rax    # 0xf2cfd8
movl (%rax), %edx
leaq 0xad0a3a(%rip), %rsi    # 0xd6c212
movb $0x0, %al
callq 0x29b1b0
jmp 0x29b7e1
movl $0x1, %edi
callq 0x29b170
movq 0xc917ee(%rip), %rax    # 0xf2cfe0
movq (%rax), %rdi
leaq 0xad0a38(%rip), %rsi    # 0xd6c234
movb $0x0, %al
callq 0x29b1b0
movl $0x1, %edi
callq 0x29b170
jmp 0x29b450
cmpl $0x0, -0xb4(%rbp)
je 0x29b846
cmpl $0x0, -0xb8(%rbp)
je 0x29b846
movq 0xc917b5(%rip), %rax    # 0xf2cfe0
movq (%rax), %rdi
leaq 0xad0a17(%rip), %rsi    # 0xd6c24c
movb $0x0, %al
callq 0x29b1b0
movl $0x1, %edi
callq 0x29b170
cmpq $0x0, -0x68(%rbp)
je 0x29b914
movq -0x68(%rbp), %rdi
callq 0x2a0a90
movq %rax, -0x78(%rbp)
xorl %eax, %eax
cmpq -0x78(%rbp), %rax
jne 0x29b8b2
movq -0x68(%rbp), %rdi
leaq 0xad0a0a(%rip), %rsi    # 0xd6c27b
callq 0x29b190
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x29b88b
leaq 0x8db(%rip), %rax       # 0x29c160
movq %rax, -0x78(%rbp)
jmp 0x29b8b0
movq -0x68(%rbp), %rdi
leaq 0xad09ec(%rip), %rsi    # 0xd6c282
callq 0x29b190
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x29b8ae
leaq 0x916(%rip), %rax       # 0x29c1c0
movq %rax, -0x78(%rbp)
jmp 0x29b8b0
jmp 0x29b8b2
xorl %eax, %eax
cmpq -0x78(%rbp), %rax
jne 0x29b8de
movq -0x68(%rbp), %rdi
leaq 0xb56271(%rip), %rsi    # 0xdf1b36
callq 0x29b050
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x29b8de
movl $0x1, -0x84(%rbp)
xorl %eax, %eax
cmpq -0x78(%rbp), %rax
jne 0x29b912
xorl %eax, %eax
cmpl -0x84(%rbp), %eax
jne 0x29b912
movq 0xc916e9(%rip), %rax    # 0xf2cfe0
movq (%rax), %rdi
leaq 0xad0987(%rip), %rsi    # 0xd6c288
movb $0x0, %al
callq 0x29b1b0
movl $0x1, %edi
callq 0x29b170
jmp 0x29b936
movq 0xc916c5(%rip), %rax    # 0xf2cfe0
movq (%rax), %rdi
leaq 0xad0983(%rip), %rsi    # 0xd6c2a8
movb $0x0, %al
callq 0x29b1b0
movl $0x1, %edi
callq 0x29b170
cmpq $0x0, -0x70(%rbp)
je 0x29b976
movq -0x70(%rbp), %rdi
callq 0x2a0a90
movq %rax, -0x80(%rbp)
xorl %eax, %eax
cmpq -0x80(%rbp), %rax
jne 0x29b974
movq 0xc91687(%rip), %rax    # 0xf2cfe0
movq (%rax), %rdi
leaq 0xad0968(%rip), %rsi    # 0xd6c2cb
movb $0x0, %al
callq 0x29b1b0
movl $0x1, %edi
callq 0x29b170
jmp 0x29b976
cmpq $0x0, -0x98(%rbp)
je 0x29b9c2
movq -0x98(%rbp), %rdi
callq 0x2a0eb0
movq %rax, -0xa0(%rbp)
xorl %eax, %eax
cmpq -0xa0(%rbp), %rax
jne 0x29b9c0
movq 0xc9163b(%rip), %rax    # 0xf2cfe0
movq (%rax), %rdi
leaq 0xad093c(%rip), %rsi    # 0xd6c2eb
movb $0x0, %al
callq 0x29b1b0
movl $0x1, %edi
callq 0x29b170
jmp 0x29b9c2
cmpq $0x0, -0x30(%rbp)
je 0x29b9e4
movq -0x30(%rbp), %rdi
callq 0x2a50e0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x29ba06
movq 0xc915f5(%rip), %rax    # 0xf2cfe0
movq (%rax), %rdi
leaq 0xad0920(%rip), %rsi    # 0xd6c315
movb $0x0, %al
callq 0x29b1b0
movl $0x1, %edi
callq 0x29b170
movq -0x40(%rbp), %rdi
movl $0x2, %esi
callq 0x29c220
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x29bc68
xorps %xmm0, %xmm0
movsd %xmm0, -0x100(%rbp)
movq -0x48(%rbp), %rdi
callq 0x2a50e0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x58(%rbp), %rax
jae 0x29bc3e
movl $0x0, -0x104(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x110(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x118(%rbp)
cmpl $0x0, -0xc4(%rbp)
jle 0x29bab5
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rax
movslq -0xc4(%rbp), %rcx
cmpq %rcx, %rax
jbe 0x29bab3
movq -0x80(%rbp), %rax
movq %rax, -0x118(%rbp)
jmp 0x29bab5
callq 0x2a6730
movsd %xmm0, -0x110(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x120(%rbp)
movq $0x0, -0x128(%rbp)
movq $0x0, -0x128(%rbp)
movq -0x128(%rbp), %rax
cmpq -0x120(%rbp), %rax
jge 0x29bbbb
movq -0x118(%rbp), %rax
movq -0x50(%rbp), %rcx
movq (%rcx), %rcx
movq -0x20(%rbp), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
movq 0x28(%rcx), %rdi
movq -0x50(%rbp), %rcx
movq (%rcx), %rcx
movq -0x20(%rbp), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
movq 0x20(%rcx), %rcx
movl %ecx, %esi
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
movq -0x128(%rbp), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
movq 0x28(%rcx), %rdx
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
movq -0x128(%rbp), %r8
shlq $0x6, %r8
addq %r8, %rcx
movq 0x20(%rcx), %rcx
movl -0xa4(%rbp), %r8d
movl -0xa8(%rbp), %r9d
movq -0xa0(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
movq %rax, -0x130(%rbp)
movq -0x130(%rbp), %rdi
callq 0x2a3e00
addl -0x104(%rbp), %eax
movl %eax, -0x104(%rbp)
movq -0x130(%rbp), %rdi
callq 0x2a2000
movq -0x128(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x128(%rbp)
jmp 0x29bae3
callq 0x2a6730
subsd -0x110(%rbp), %xmm0
movsd %xmm0, -0x110(%rbp)
movsd -0x110(%rbp), %xmm0
addsd -0x100(%rbp), %xmm0
movsd %xmm0, -0x100(%rbp)
movq -0x20(%rbp), %rsi
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rdx
movl -0x104(%rbp), %ecx
movsd -0x110(%rbp), %xmm0
leaq 0xad0719(%rip), %rdi    # 0xd6c330
movb $0x1, %al
callq 0x29b040
movq 0xc9138b(%rip), %rax    # 0xf2cfb0
movq (%rax), %rdi
callq 0x29b140
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x29ba4f
movsd -0x100(%rbp), %xmm0
leaq 0xad06f5(%rip), %rdi    # 0xd6c342
movb $0x1, %al
callq 0x29b040
movq 0xc91355(%rip), %rax    # 0xf2cfb0
movq (%rax), %rdi
callq 0x29b140
jmp 0x29c0e6
movl $0x0, -0xc8(%rbp)
movl -0xc8(%rbp), %eax
cmpl -0xc0(%rbp), %eax
jge 0x29c01e
callq 0x2a6730
movsd %xmm0, -0x18(%rbp)
movq $0x0, -0x138(%rbp)
movq $0x1, -0x140(%rbp)
movq $0x0, -0x148(%rbp)
movq $0x0, -0x150(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x158(%rbp)
movq $0x0, -0x150(%rbp)
movq -0x150(%rbp), %rax
cmpq -0x158(%rbp), %rax
jge 0x29bfea
movq -0x78(%rbp), %rax
movq %rax, -0x160(%rbp)
movq $0x0, -0x168(%rbp)
movq -0x150(%rbp), %rdi
leaq -0x138(%rbp), %rsi
leaq -0x140(%rbp), %rdx
callq 0x29c2a0
cmpl $0x0, -0xb4(%rbp)
je 0x29bd7d
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq -0x138(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
movq -0x140(%rbp), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
cmpq 0x20(%rcx), %rax
jbe 0x29bd7b
movq -0x138(%rbp), %rax
movq %rax, -0x148(%rbp)
movq -0x140(%rbp), %rax
movq %rax, -0x138(%rbp)
movq -0x148(%rbp), %rax
movq %rax, -0x140(%rbp)
jmp 0x29bde8
cmpl $0x0, -0xb8(%rbp)
je 0x29bde6
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq -0x138(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
movq -0x140(%rbp), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
cmpq 0x20(%rcx), %rax
jae 0x29bde4
movq -0x138(%rbp), %rax
movq %rax, -0x148(%rbp)
movq -0x140(%rbp), %rax
movq %rax, -0x138(%rbp)
movq -0x148(%rbp), %rax
movq %rax, -0x140(%rbp)
jmp 0x29bde6
jmp 0x29bde8
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq -0x138(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rax
movq %rax, -0x170(%rbp)
cmpl $0x0, -0xbc(%rbp)
jle 0x29be34
movq -0x170(%rbp), %rax
movslq -0xbc(%rbp), %rcx
cmpq %rcx, %rax
jbe 0x29be32
movslq -0xbc(%rbp), %rax
movq %rax, -0x170(%rbp)
jmp 0x29be34
cmpl $0x0, -0xc4(%rbp)
jle 0x29be5d
movq -0x170(%rbp), %rax
movslq -0xc4(%rbp), %rcx
cmpq %rcx, %rax
jbe 0x29be5b
movq -0x80(%rbp), %rax
movq %rax, -0x160(%rbp)
jmp 0x29be5d
xorl %eax, %eax
cmpq -0x78(%rbp), %rax
je 0x29beeb
movq -0x160(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
movq -0x138(%rbp), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
movq 0x28(%rcx), %rdi
movq -0x170(%rbp), %rcx
movl %ecx, %esi
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
movq -0x140(%rbp), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
movq 0x28(%rcx), %rdx
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
movq -0x140(%rbp), %r8
shlq $0x6, %r8
addq %r8, %rcx
movq 0x20(%rcx), %rcx
movl -0xa4(%rbp), %r8d
movl -0xa8(%rbp), %r9d
movq -0xa0(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
movq %rax, -0x168(%rbp)
jmp 0x29bf82
xorl %eax, %eax
cmpl -0x84(%rbp), %eax
je 0x29bf80
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq -0x138(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rdi
movq -0x170(%rbp), %rax
movl %eax, %esi
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq -0x140(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rdx
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq -0x140(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rax
movl %eax, %ecx
movl -0xa4(%rbp), %r8d
movl -0xa8(%rbp), %r9d
movl -0x88(%rbp), %r10d
movq -0xa0(%rbp), %rax
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x376fb0
movq %rax, -0x168(%rbp)
jmp 0x29bf82
movq -0x168(%rbp), %rdi
callq 0x2a3e00
addl -0xb0(%rbp), %eax
movl %eax, -0xb0(%rbp)
movq -0x168(%rbp), %rdi
callq 0x2a3e00
cmpl $0x0, %eax
je 0x29bfc7
movq -0x138(%rbp), %rsi
movq -0x140(%rbp), %rdx
leaq 0xad0391(%rip), %rdi    # 0xd6c351
movb $0x0, %al
callq 0x29b040
movq -0x168(%rbp), %rdi
callq 0x2a2000
movq -0x150(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x150(%rbp)
jmp 0x29bcd0
callq 0x2a6730
subsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
leaq -0xf8(%rbp), %rdi
callq 0x29c430
movl -0xc8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc8(%rbp)
jmp 0x29bc72
movq -0x68(%rbp), %rax
movq %rax, -0x1a0(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x198(%rbp)
movl -0xa4(%rbp), %eax
movl %eax, -0x190(%rbp)
movl -0xa8(%rbp), %eax
movl %eax, -0x18c(%rbp)
movl -0xac(%rbp), %eax
movl %eax, -0x188(%rbp)
movl -0xb0(%rbp), %eax
movl %eax, -0x184(%rbp)
movsd -0xf0(%rbp), %xmm0
movsd %xmm0, -0x180(%rbp)
leaq -0xf8(%rbp), %rdi
callq 0x29c5a0
movq -0x1a0(%rbp), %rsi
movq -0x198(%rbp), %rdx
movl -0x190(%rbp), %ecx
movl -0x18c(%rbp), %r8d
movl -0x188(%rbp), %r9d
movl -0x184(%rbp), %eax
movaps %xmm0, %xmm1
movsd -0x180(%rbp), %xmm0
movsd -0xd8(%rbp), %xmm2
movsd -0xd0(%rbp), %xmm3
leaq 0xad029c(%rip), %rdi    # 0xd6c369
movl %eax, (%rsp)
movb $0x4, %al
callq 0x29b040
movq 0xc90ed2(%rip), %rax    # 0xf2cfb0
movq (%rax), %rdi
callq 0x29b140
xorl %eax, %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
nopw %cs:(%rax,%rax)