// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_scan_avx2_256_64.c
// Function: parasail_sw_rowcol_scan_profile_avx2_256_64
parasail_result_t* PNAME(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
    /* declare local variables */
    int32_t i = 0;
    int32_t j = 0;
    int32_t end_query = 0;
    int32_t end_ref = 0;
    int32_t s1Len = 0;
    const parasail_matrix_t *matrix = NULL;
    int32_t segWidth = 0;
    int32_t segLen = 0;
#ifdef PARASAIL_ROWCOL
    int32_t offset = 0;
    int32_t position = 0;
#endif
    __m256i* restrict pvP = NULL;
    __m256i* restrict pvE = NULL;
    __m256i* restrict pvHt = NULL;
    __m256i* restrict pvH = NULL;
    __m256i* restrict pvHMax = NULL;
    __m256i* restrict pvGapper = NULL;
    __m256i vGapO;
    __m256i vGapE;
    int64_t NEG_LIMIT = 0;
    int64_t POS_LIMIT = 0;
    __m256i vZero;
    int64_t score = 0;
    __m256i vNegLimit;
    __m256i vPosLimit;
    __m256i vSaturationCheckMin;
    __m256i vSaturationCheckMax;
    __m256i vMaxH;
    __m256i vMaxHUnit;
    __m256i vNegInfFront;
    __m256i vSegLenXgap;
    parasail_result_t *result = NULL;

    /* validate inputs */
    PARASAIL_CHECK_NULL(profile);
    PARASAIL_CHECK_NULL(profile->profile64.score);
    PARASAIL_CHECK_NULL(profile->matrix);
    PARASAIL_CHECK_GT0(profile->s1Len);
    PARASAIL_CHECK_NULL(s2);
    PARASAIL_CHECK_GT0(s2Len);
    PARASAIL_CHECK_GE0(open);
    PARASAIL_CHECK_GE0(gap);

    /* initialize stack variables */
    i = 0;
    j = 0;
    end_query = 0;
    end_ref = 0;
    s1Len = profile->s1Len;
    matrix = profile->matrix;
    segWidth = 4; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
#ifdef PARASAIL_ROWCOL
    offset = (s1Len - 1) % segLen;
    position = (segWidth - 1) - (s1Len - 1) / segLen;
#endif
    pvP = (__m256i*)profile->profile64.score;
    vGapO = _mm256_set1_epi64x_rpl(open);
    vGapE = _mm256_set1_epi64x_rpl(gap);
    NEG_LIMIT = (-open < matrix->min ? INT64_MIN + open : INT64_MIN - matrix->min) + 1;
    POS_LIMIT = INT64_MAX - matrix->max - 1;
    vZero = _mm256_setzero_si256();
    score = NEG_LIMIT;
    vNegLimit = _mm256_set1_epi64x_rpl(NEG_LIMIT);
    vPosLimit = _mm256_set1_epi64x_rpl(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    vMaxH = vNegLimit;
    vMaxHUnit = vNegLimit;
    vNegInfFront = vZero;
    vNegInfFront = _mm256_insert_epi64_rpl(vNegInfFront, NEG_LIMIT, 0);
    vSegLenXgap = _mm256_add_epi64(vNegInfFront,
            _mm256_slli_si256_rpl(_mm256_set1_epi64x_rpl(-segLen*gap), 8));

    /* initialize result */
#ifdef PARASAIL_TABLE
    result = parasail_result_new_table1(segLen*segWidth, s2Len);
#else
#ifdef PARASAIL_ROWCOL
    result = parasail_result_new_rowcol1(segLen*segWidth, s2Len);
#else
    result = parasail_result_new();
#endif
#endif
    if (!result) return NULL;

    /* set known flags */
    result->flag |= PARASAIL_FLAG_SW | PARASAIL_FLAG_SCAN
        | PARASAIL_FLAG_BITS_64 | PARASAIL_FLAG_LANES_4;
#ifdef PARASAIL_TABLE
    result->flag |= PARASAIL_FLAG_TABLE;
#endif
#ifdef PARASAIL_ROWCOL
    result->flag |= PARASAIL_FLAG_ROWCOL;
#endif

    /* initialize heap variables */
    pvE = parasail_memalign___m256i(32, segLen);
    pvHt= parasail_memalign___m256i(32, segLen);
    pvH = parasail_memalign___m256i(32, segLen);
    pvHMax = parasail_memalign___m256i(32, segLen);
    pvGapper = parasail_memalign___m256i(32, segLen);

    /* validate heap variables */
    if (!pvE) return NULL;
    if (!pvHt) return NULL;
    if (!pvH) return NULL;
    if (!pvHMax) return NULL;
    if (!pvGapper) return NULL;

    parasail_memset___m256i(pvH, vZero, segLen);
    parasail_memset___m256i(pvE, vNegLimit, segLen);
    {
        __m256i vGapper = _mm256_sub_epi64(vZero,vGapO);
        for (i=segLen-1; i>=0; --i) {
            _mm256_store_si256(pvGapper+i, vGapper);
            vGapper = _mm256_sub_epi64(vGapper, vGapE);
        }
    }

    /* outer loop over database sequence */
    for (j=0; j<s2Len; ++j) {
        __m256i vE;
        __m256i vHt;
        __m256i vF;
        __m256i vH;
        __m256i vHp;
        __m256i *pvW;
        __m256i vW;

        /* calculate E */
        /* calculate Ht */
        /* calculate F and H first pass */
        vHp = _mm256_load_si256(pvH+(segLen-1));
        vHp = _mm256_slli_si256_rpl(vHp, 8);
        pvW = pvP + matrix->mapper[(unsigned char)s2[j]]*segLen;
        vHt = vZero;
        vF = vNegLimit;
        for (i=0; i<segLen; ++i) {
            vH = _mm256_load_si256(pvH+i);
            vE = _mm256_load_si256(pvE+i);
            vW = _mm256_load_si256(pvW+i);
            vE = _mm256_max_epi64_rpl(
                    _mm256_sub_epi64(vE, vGapE),
                    _mm256_sub_epi64(vH, vGapO));
            vHp = _mm256_add_epi64(vHp, vW);
            vF = _mm256_max_epi64_rpl(vF, _mm256_add_epi64(vHt, pvGapper[i]));
            vHt = _mm256_max_epi64_rpl(vE, vHp);
            _mm256_store_si256(pvE+i, vE);
            _mm256_store_si256(pvHt+i, vHt);
            vHp = vH;
        }

        /* pseudo prefix scan on F and H */
        vHt = _mm256_slli_si256_rpl(vHt, 8);
        vF = _mm256_max_epi64_rpl(vF, _mm256_add_epi64(vHt, pvGapper[0]));
        for (i=0; i<segWidth-2; ++i) {
            __m256i vFt = _mm256_slli_si256_rpl(vF, 8);
            vFt = _mm256_add_epi64(vFt, vSegLenXgap);
            vF = _mm256_max_epi64_rpl(vF, vFt);
        }

        /* calculate final H */
        vF = _mm256_slli_si256_rpl(vF, 8);
        vF = _mm256_add_epi64(vF, vNegInfFront);
        vH = _mm256_max_epi64_rpl(vHt, vF);
        vH = _mm256_max_epi64_rpl(vH, vZero);
        for (i=0; i<segLen; ++i) {
            vHt = _mm256_load_si256(pvHt+i);
            vF = _mm256_max_epi64_rpl(
                    _mm256_sub_epi64(vF, vGapE),
                    _mm256_sub_epi64(vH, vGapO));
            vH = _mm256_max_epi64_rpl(vHt, vF);
            vH = _mm256_max_epi64_rpl(vH, vZero);
            _mm256_store_si256(pvH+i, vH);
            vSaturationCheckMin = _mm256_min_epi64_rpl(vSaturationCheckMin, vH);
            vSaturationCheckMax = _mm256_max_epi64_rpl(vSaturationCheckMax, vH);
#ifdef PARASAIL_TABLE
            arr_store_si256(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif
            vMaxH = _mm256_max_epi64_rpl(vH, vMaxH);
        } 

        {
            __m256i vCompare = _mm256_cmpgt_epi64(vMaxH, vMaxHUnit);
            if (_mm256_movemask_epi8(vCompare)) {
                score = _mm256_hmax_epi64_rpl(vMaxH);
                vMaxHUnit = _mm256_set1_epi64x_rpl(score);
                end_ref = j;
                (void)memcpy(pvHMax, pvH, sizeof(__m256i)*segLen);
            }
        }

#ifdef PARASAIL_ROWCOL
        /* extract last value from the column */
        {
            int32_t k = 0;
            __m256i vH = _mm256_load_si256(pvH + offset);
            for (k=0; k<position; ++k) {
                vH = _mm256_slli_si256_rpl(vH, 8);
            }
            result->rowcols->score_row[j] = (int64_t) _mm256_extract_epi64_rpl (vH, 3);
        }
#endif
    }

    /* Trace the alignment ending position on read. */
    {
        int64_t *t = (int64_t*)pvHMax;
        int32_t column_len = segLen * segWidth;
        end_query = s1Len;
        for (i = 0; i<column_len; ++i, ++t) {
            if (*t == score) {
                int32_t temp = i / segWidth + i % segWidth * segLen;
                if (temp < end_query) {
                    end_query = temp;
                }
            }
        }
    }

#ifdef PARASAIL_ROWCOL
    for (i=0; i<segLen; ++i) {
        __m256i vH = _mm256_load_si256(pvH+i);
        arr_store_col(result->rowcols->score_col, vH, i, segLen);
    }
#endif

    if (_mm256_movemask_epi8(_mm256_or_si256(
            _mm256_cmplt_epi64_rpl(vSaturationCheckMin, vNegLimit),
            _mm256_cmpgt_epi64(vSaturationCheckMax, vPosLimit)))) {
        result->flag |= PARASAIL_FLAG_SATURATED;
        score = 0;
        end_query = 0;
        end_ref = 0;
    }

    result->score = score;
    result->end_query = end_query;
    result->end_ref = end_ref;

    parasail_free(pvGapper);
    parasail_free(pvHMax);
    parasail_free(pvH);
    parasail_free(pvHt);
    parasail_free(pvE);

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rsi, 0x60(%rsp)
testq %rdi, %rdi
je 0x521374
movq 0x60(%rdi), %rax
movq %rax, 0x98(%rsp)
testq %rax, %rax
je 0x52137b
movq 0x10(%rdi), %rax
movq %rax, 0x58(%rsp)
testq %rax, %rax
je 0x521382
movl 0x8(%rdi), %eax
testl %eax, %eax
jle 0x521389
cmpq $0x0, 0x60(%rsp)
je 0x521390
movl %edx, %r15d
testl %edx, %edx
jle 0x521397
testl %ecx, %ecx
js 0x52139e
movl %r8d, %r13d
testl %r8d, %r8d
js 0x5213a5
leaq 0x3(%rax), %r14
movq %r14, %rbx
shrq $0x2, %rbx
movq %rax, 0x48(%rsp)
decl %eax
cltd
idivl %ebx
movl %eax, 0x1c(%rsp)
movl %edx, %r12d
movl %ecx, %edx
negl %ecx
movq 0x58(%rsp), %rdi
movslq 0x20(%rdi), %rax
movq %rdx, 0x8(%rsp)
btsq $0x3f, %rdx
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
subq %rax, %rsi
cmpl %ecx, %eax
cmovgq %rdx, %rsi
movq %rsi, 0x10(%rsp)
movslq 0x1c(%rdi), %rax
movq %rax, 0x30(%rsp)
andl $0x7ffffffc, %r14d      # imm = 0x7FFFFFFC
movl %r14d, %edi
movl %r15d, %esi
callq 0x209630
testq %rax, %rax
je 0x5213aa
movq %rax, %rbp
movl %r13d, 0xe0(%rsp)
movl %r12d, 0x100(%rsp)
movl %r15d, 0x120(%rsp)
movq %r14, 0x68(%rsp)
orl $0x4840404, 0xc(%rax)   # imm = 0x4840404
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4c5e3c
movq %rax, %r15
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4c5e3c
movq %rax, %r12
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4c5e3c
movq %rax, %r13
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4c5e3c
movq %rax, %r14
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4c5e3c
testq %r15, %r15
sete %dl
testq %r12, %r12
sete %cl
orb %dl, %cl
testq %r13, %r13
sete %sil
movq %r14, 0x28(%rsp)
testq %r14, %r14
movq %rax, %r14
sete %dl
orb %sil, %dl
orb %cl, %dl
testq %rax, %rax
sete %al
orb %dl, %al
jne 0x5213aa
movl $0x3, %eax
subl 0x1c(%rsp), %eax
movl %eax, 0xc0(%rsp)
vmovsd 0x8(%rsp), %xmm0
vbroadcastsd %xmm0, %ymm0
vmovups %ymm0, 0x1a0(%rsp)
movl 0xe0(%rsp), %ecx
movl %ecx, %eax
vmovq %rax, %xmm0
vpbroadcastq %xmm0, %ymm0
vmovdqu %ymm0, 0x180(%rsp)
movq 0x10(%rsp), %rax
incq %rax
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
subq 0x30(%rsp), %rdx
addq $-0x2, %rdx
movq %rax, 0x10(%rsp)
vmovq %rax, %xmm0
vpbroadcastq %xmm0, %ymm1
vmovdqu %ymm1, 0xa0(%rsp)
vmovq %rdx, %xmm0
vpbroadcastq %xmm0, %ymm0
vmovdqu %ymm0, 0x140(%rsp)
vmovq %xmm1, %xmm2            # xmm2 = xmm1[0],zero
imull %ebx, %ecx
negl %ecx
movslq %ecx, %rax
vmovq %rax, %xmm0
vpbroadcastq %xmm0, %ymm0
vpxor %xmm1, %xmm1, %xmm1
vpblendd $0x3, %ymm1, %ymm0, %ymm0 # ymm0 = ymm1[0,1],ymm0[2,3,4,5,6,7]
vmovdqu %ymm2, 0x1c0(%rsp)
vpaddq %ymm0, %ymm2, %ymm0
vmovdqu %ymm0, 0x160(%rsp)
vpxor %xmm0, %xmm0, %xmm0
movq %r13, %rdi
movq %rbx, %rsi
callq 0x4c5e45
movq %r15, 0x20(%rsp)
movq %r15, %rdi
vmovdqu 0xa0(%rsp), %ymm0
movq %rbx, %rsi
callq 0x4c5e45
vmovdqu 0x180(%rsp), %ymm9
vmovdqu 0x1a0(%rsp), %ymm8
vpxor %xmm0, %xmm0, %xmm0
vpsubq %ymm8, %ymm0, %ymm0
leal -0x1(%rbx), %eax
movq %rax, %rcx
shlq $0x5, %rcx
movq %r14, 0x8(%rsp)
addq %r14, %rcx
movl %ebx, %edx
vmovdqa %ymm0, (%rcx)
vpsubq %ymm9, %ymm0, %ymm0
addq $-0x20, %rcx
decl %edx
jg 0x520aae
movl %eax, %eax
shlq $0x5, %rax
addq %r13, %rax
movq %rax, 0x88(%rsp)
movq %rbx, %rax
shlq $0x5, %rax
movq %rax, 0x70(%rsp)
movl 0x100(%rsp), %eax
shlq $0x5, %rax
addq %r13, %rax
movq %rax, 0x80(%rsp)
movl 0xc0(%rsp), %ecx
cmpl $0x2, %ecx
movl $0x1, %eax
cmovgel %ecx, %eax
movl %eax, 0x3c(%rsp)
movl 0x120(%rsp), %eax
movq %rax, 0x78(%rsp)
movq %rbx, 0x40(%rsp)
movl %ebx, %r11d
movq %r11, %r14
shlq $0x5, %r14
xorl %r15d, %r15d
vpxor %xmm13, %xmm13, %xmm13
movl $0x0, 0x18(%rsp)
vmovdqu 0xa0(%rsp), %ymm0
vmovdqa %ymm0, %ymm14
vmovdqa %ymm0, %ymm15
vmovdqa %ymm0, %ymm11
vmovdqu 0x140(%rsp), %ymm12
vmovdqu 0x160(%rsp), %ymm10
movq %rbp, 0x90(%rsp)
movq %r11, 0x50(%rsp)
movq 0x88(%rsp), %rax
vmovdqa (%rax), %ymm0
vperm2i128 $0x8, %ymm0, %ymm0, %ymm1 # ymm1 = zero,zero,ymm0[0,1]
vpalignr $0x8, %ymm1, %ymm0, %ymm0 # ymm0 = ymm1[8,9,10,11,12,13,14,15],ymm0[0,1,2,3,4,5,6,7],ymm1[24,25,26,27,28,29,30,31],ymm0[16,17,18,19,20,21,22,23]
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x60(%rsp), %rcx
movq %r15, 0x30(%rsp)
movzbl (%rcx,%r15), %ecx
movslq (%rax,%rcx,4), %rax
movq %r11, %rdi
imulq %rax, %rdi
shlq $0x5, %rdi
addq 0x98(%rsp), %rdi
xorl %r8d, %r8d
vmovdqu 0xa0(%rsp), %ymm1
vpxor %xmm2, %xmm2, %xmm2
movq %r12, %r15
movq 0x20(%rsp), %r12
vpaddq (%rdi,%r8), %ymm0, %ymm3
vmovdqa (%r13,%r8), %ymm0
vmovdqa (%r12,%r8), %ymm4
vpsubq %ymm9, %ymm4, %ymm4
vpsubq %ymm8, %ymm0, %ymm5
vmovq %xmm4, %rax
vmovq %xmm5, %rdx
cmpq %rdx, %rax
cmovgq %rax, %rdx
vpextrq $0x1, %xmm4, %rax
vpextrq $0x1, %xmm5, %rcx
cmpq %rcx, %rax
cmovgq %rax, %rcx
vextracti128 $0x1, %ymm4, %xmm4
vmovq %xmm4, %rax
vextracti128 $0x1, %ymm5, %xmm5
vmovq %xmm5, %rsi
cmpq %rsi, %rax
cmovgq %rax, %rsi
vpextrq $0x1, %xmm4, %rax
vpextrq $0x1, %xmm5, %rbx
cmpq %rbx, %rax
cmovgq %rax, %rbx
vmovq %rcx, %xmm4
movq 0x8(%rsp), %rax
vpaddq (%rax,%r8), %ymm2, %ymm2
vmovq %xmm1, %rax
vmovq %xmm2, %r9
cmpq %r9, %rax
cmovgq %rax, %r9
vpextrq $0x1, %xmm1, %rax
vpextrq $0x1, %xmm2, %r10
cmpq %r10, %rax
cmovgq %rax, %r10
vextracti128 $0x1, %ymm1, %xmm1
vmovq %xmm1, %rax
vextracti128 $0x1, %ymm2, %xmm2
vmovq %xmm2, %r11
cmpq %r11, %rax
cmovgq %rax, %r11
vpextrq $0x1, %xmm1, %rbp
vmovq %rdx, %xmm1
vpextrq $0x1, %xmm2, %rax
cmpq %rax, %rbp
cmovgq %rbp, %rax
vmovq %xmm3, %rbp
cmpq %rbp, %rdx
cmovleq %rbp, %rdx
vpextrq $0x1, %xmm3, %rbp
vmovq %rbx, %xmm2
cmpq %rbp, %rcx
cmovleq %rbp, %rcx
vmovq %rsi, %xmm5
vextracti128 $0x1, %ymm3, %xmm3
vmovq %xmm3, %rbp
cmpq %rbp, %rsi
cmovleq %rbp, %rsi
vpextrq $0x1, %xmm3, %rbp
cmpq %rbp, %rbx
cmovleq %rbp, %rbx
vmovq %rbx, %xmm6
vpunpcklqdq %xmm4, %xmm1, %xmm7 # xmm7 = xmm1[0],xmm4[0]
vpunpcklqdq %xmm2, %xmm5, %xmm5 # xmm5 = xmm5[0],xmm2[0]
vmovq %rax, %xmm1
vmovq %r11, %xmm2
vpunpcklqdq %xmm1, %xmm2, %xmm1 # xmm1 = xmm2[0],xmm1[0]
vmovq %r10, %xmm2
vmovq %r9, %xmm3
vpunpcklqdq %xmm2, %xmm3, %xmm2 # xmm2 = xmm3[0],xmm2[0]
vinserti128 $0x1, %xmm1, %ymm2, %ymm1
vmovq %rcx, %xmm3
vmovq %rdx, %xmm2
vpunpcklqdq %xmm3, %xmm2, %xmm2 # xmm2 = xmm2[0],xmm3[0]
vmovq %rsi, %xmm4
vinserti128 $0x1, %xmm4, %ymm2, %ymm4
vpbroadcastq %xmm6, %ymm2
vpblendd $0xc0, %ymm2, %ymm4, %ymm2 # ymm2 = ymm4[0,1,2,3,4,5],ymm2[6,7]
vmovdqa %xmm5, 0x10(%r12,%r8)
vmovdqa %xmm7, (%r12,%r8)
vmovdqa %ymm2, (%r15,%r8)
addq $0x20, %r8
cmpq %r8, %r14
jne 0x520bc6
vpbroadcastq %xmm3, %xmm0
vinserti128 $0x1, %xmm0, %ymm13, %ymm0
vpalignr $0x8, %ymm0, %ymm4, %ymm0 # ymm0 = ymm0[8,9,10,11,12,13,14,15],ymm4[0,1,2,3,4,5,6,7],ymm0[24,25,26,27,28,29,30,31],ymm4[16,17,18,19,20,21,22,23]
movq 0x8(%rsp), %rdi
vpaddq (%rdi), %ymm0, %ymm0
vmovq %xmm0, %rdi
cmpq %rdi, %r9
cmovgq %r9, %rdi
vpextrq $0x1, %xmm0, %r8
cmpq %r8, %r10
cmovgq %r10, %r8
vextracti128 $0x1, %ymm0, %xmm0
vmovq %xmm0, %r9
cmpq %r9, %r11
cmovgq %r11, %r9
vpextrq $0x1, %xmm0, %r10
cmpq %r10, %rax
cmovgq %rax, %r10
vmovq %r10, %xmm0
vmovq %r9, %xmm1
vpunpcklqdq %xmm0, %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[0]
vmovq %r8, %xmm1
vmovq %rdi, %xmm2
vpunpcklqdq %xmm1, %xmm2, %xmm1 # xmm1 = xmm2[0],xmm1[0]
vinserti128 $0x1, %xmm0, %ymm1, %ymm0
movl $0x1, %eax
vperm2i128 $0x8, %ymm0, %ymm0, %ymm1 # ymm1 = zero,zero,ymm0[0,1]
vpalignr $0x8, %ymm1, %ymm0, %ymm1 # ymm1 = ymm1[8,9,10,11,12,13,14,15],ymm0[0,1,2,3,4,5,6,7],ymm1[24,25,26,27,28,29,30,31],ymm0[16,17,18,19,20,21,22,23]
vpaddq %ymm1, %ymm10, %ymm1
vmovq %xmm0, %rdi
vmovq %xmm1, %r8
cmpq %r8, %rdi
cmovgq %rdi, %r8
vpextrq $0x1, %xmm0, %rdi
vpextrq $0x1, %xmm1, %r9
cmpq %r9, %rdi
cmovgq %rdi, %r9
vextracti128 $0x1, %ymm0, %xmm0
vmovq %xmm0, %rdi
vextracti128 $0x1, %ymm1, %xmm2
vmovq %xmm2, %r10
cmpq %r10, %rdi
cmovgq %rdi, %r10
vmovq %r9, %xmm1
vmovq %r8, %xmm3
vpunpcklqdq %xmm1, %xmm3, %xmm3 # xmm3 = xmm3[0],xmm1[0]
vmovq %r10, %xmm4
vpextrq $0x1, %xmm0, %rdi
vpextrq $0x1, %xmm2, %r8
vinserti128 $0x1, %xmm4, %ymm3, %ymm2
cmpq %r8, %rdi
cmovgq %rdi, %r8
vmovq %r8, %xmm0
vpbroadcastq %xmm0, %ymm0
vpblendd $0xc0, %ymm0, %ymm2, %ymm0 # ymm0 = ymm2[0,1,2,3,4,5],ymm0[6,7]
decl %eax
je 0x520dce
vpbroadcastq %xmm1, %xmm0
vinserti128 $0x1, %xmm0, %ymm13, %ymm0
vpalignr $0x8, %ymm0, %ymm2, %ymm0 # ymm0 = ymm0[8,9,10,11,12,13,14,15],ymm2[0,1,2,3,4,5,6,7],ymm0[24,25,26,27,28,29,30,31],ymm2[16,17,18,19,20,21,22,23]
vpaddq 0x1c0(%rsp), %ymm0, %ymm0
vmovq %xmm0, %rax
movq %rax, %rdi
sarq $0x3f, %rdi
andnq %rax, %rdi, %rax
vpextrq $0x1, %xmm0, %rdi
cmpq %rdi, %rdx
cmovgq %rdx, %rdi
vextracti128 $0x1, %ymm0, %xmm1
vmovq %xmm1, %rdx
cmpq %rdx, %rcx
cmovgq %rcx, %rdx
vpextrq $0x1, %xmm1, %rcx
cmpq %rcx, %rsi
cmovgq %rsi, %rcx
movq %rdi, %rsi
sarq $0x3f, %rsi
andnq %rdi, %rsi, %rsi
movq %rdx, %rdi
sarq $0x3f, %rdi
andnq %rdx, %rdi, %rdx
movq %rcx, %rdi
sarq $0x3f, %rdi
andnq %rcx, %rdi, %rcx
vmovq %rcx, %xmm1
vmovq %rdx, %xmm2
vpunpcklqdq %xmm1, %xmm2, %xmm1 # xmm1 = xmm2[0],xmm1[0]
vmovq %rsi, %xmm2
vmovq %rax, %xmm3
vpunpcklqdq %xmm2, %xmm3, %xmm2 # xmm2 = xmm3[0],xmm2[0]
vinserti128 $0x1, %xmm1, %ymm2, %ymm1
xorl %ecx, %ecx
movq %r15, %r12
movq 0x30(%rsp), %r15
vpsubq %ymm9, %ymm0, %ymm0
vpsubq %ymm8, %ymm1, %ymm1
vmovq %xmm0, %rdx
vmovq %xmm1, %rax
cmpq %rax, %rdx
cmovgq %rdx, %rax
vpextrq $0x1, %xmm0, %rsi
vpextrq $0x1, %xmm1, %rdx
cmpq %rdx, %rsi
cmovgq %rsi, %rdx
vextracti128 $0x1, %ymm0, %xmm0
vmovq %xmm0, %rsi
vextracti128 $0x1, %ymm1, %xmm1
vmovq %xmm1, %r8
cmpq %r8, %rsi
cmovgq %rsi, %r8
vpextrq $0x1, %xmm0, %rsi
vpextrq $0x1, %xmm1, %r9
cmpq %r9, %rsi
cmovgq %rsi, %r9
vmovq %r9, %xmm1
vmovq %r8, %xmm3
vmovq %rdx, %xmm0
vmovq %rax, %xmm2
movq (%r12,%rcx), %rsi
cmpq %rax, %rsi
cmovgq %rsi, %rax
movq 0x8(%r12,%rcx), %rsi
cmpq %rdx, %rsi
cmovgq %rsi, %rdx
movq 0x10(%r12,%rcx), %rsi
cmpq %r8, %rsi
cmovgq %rsi, %r8
movq 0x18(%r12,%rcx), %rsi
cmpq %r9, %rsi
cmovgq %rsi, %r9
vpunpcklqdq %xmm1, %xmm3, %xmm3 # xmm3 = xmm3[0],xmm1[0]
movq %rax, %rsi
sarq $0x3f, %rsi
andnq %rax, %rsi, %rdi
movq %rdx, %rax
sarq $0x3f, %rax
andnq %rdx, %rax, %rsi
movq %r8, %rax
sarq $0x3f, %rax
andnq %r8, %rax, %rdx
movq %r9, %rax
sarq $0x3f, %rax
andnq %r9, %rax, %rax
vmovq %rax, %xmm1
vmovq %rdx, %xmm4
vpunpcklqdq %xmm1, %xmm4, %xmm1 # xmm1 = xmm4[0],xmm1[0]
vmovq %rsi, %xmm4
vmovq %rdi, %xmm5
vpunpcklqdq %xmm4, %xmm5, %xmm4 # xmm4 = xmm5[0],xmm4[0]
vinserti128 $0x1, %xmm1, %ymm4, %ymm1
vmovdqa %ymm1, (%r13,%rcx)
vmovq %xmm12, %r8
cmpq %rdi, %r8
cmovgeq %rdi, %r8
vpextrq $0x1, %xmm12, %r9
vpunpcklqdq %xmm0, %xmm2, %xmm0 # xmm0 = xmm2[0],xmm0[0]
cmpq %rsi, %r9
cmovgeq %rsi, %r9
vinserti128 $0x1, %xmm3, %ymm0, %ymm0
vextracti128 $0x1, %ymm12, %xmm2
vmovq %xmm2, %r10
cmpq %rdx, %r10
cmovgeq %rdx, %r10
vpextrq $0x1, %xmm2, %r11
cmpq %rax, %r11
cmovgeq %rax, %r11
vmovq %r11, %xmm2
vmovq %r10, %xmm3
vpunpcklqdq %xmm2, %xmm3, %xmm2 # xmm2 = xmm3[0],xmm2[0]
vmovq %xmm11, %r10
cmpq %rdi, %r10
cmovleq %rdi, %r10
vpextrq $0x1, %xmm11, %r11
vmovq %r9, %xmm3
cmpq %rsi, %r11
cmovleq %rsi, %r11
vmovq %r8, %xmm4
vextracti128 $0x1, %ymm11, %xmm5
vmovq %xmm5, %r8
cmpq %rdx, %r8
cmovleq %rdx, %r8
vpextrq $0x1, %xmm5, %r9
vpunpcklqdq %xmm3, %xmm4, %xmm3 # xmm3 = xmm4[0],xmm3[0]
cmpq %rax, %r9
cmovleq %rax, %r9
vinserti128 $0x1, %xmm2, %ymm3, %ymm12
vmovq %r9, %xmm2
vmovq %r8, %xmm3
vpunpcklqdq %xmm2, %xmm3, %xmm2 # xmm2 = xmm3[0],xmm2[0]
vmovq %r11, %xmm3
vmovq %r10, %xmm4
vmovq %xmm15, %r8
cmpq %r8, %rdi
cmovgq %rdi, %r8
vpextrq $0x1, %xmm15, %rbx
vpunpcklqdq %xmm3, %xmm4, %xmm3 # xmm3 = xmm4[0],xmm3[0]
cmpq %rbx, %rsi
cmovgq %rsi, %rbx
vinserti128 $0x1, %xmm2, %ymm3, %ymm11
vextracti128 $0x1, %ymm15, %xmm2
vmovq %xmm2, %rsi
cmpq %rsi, %rdx
cmovgq %rdx, %rsi
vpextrq $0x1, %xmm2, %rdx
cmpq %rdx, %rax
cmovgq %rax, %rdx
vmovq %rdx, %xmm2
vmovq %rsi, %xmm3
vpunpcklqdq %xmm2, %xmm3, %xmm2 # xmm2 = xmm3[0],xmm2[0]
vmovq %rbx, %xmm3
vmovq %r8, %xmm4
vpunpcklqdq %xmm3, %xmm4, %xmm3 # xmm3 = xmm4[0],xmm3[0]
vinserti128 $0x1, %xmm2, %ymm3, %ymm15
addq $0x20, %rcx
cmpq %rcx, %r14
jne 0x520f0a
vpcmpgtq %ymm14, %ymm15, %ymm0
vtestpd %ymm0, %ymm0
movq 0x90(%rsp), %rbp
je 0x5211eb
cmpq %r8, %rsi
cmovgq %rsi, %r8
cmpq %rbx, %rdx
cmovgq %rdx, %rbx
cmpq %r8, %rbx
cmovleq %r8, %rbx
vmovq %rbx, %xmm0
vpbroadcastq %xmm0, %ymm0
vmovdqu %ymm0, 0xc0(%rsp)
movq 0x28(%rsp), %rdi
movq %r13, %rsi
movq 0x70(%rsp), %rdx
vmovdqu %ymm11, 0x120(%rsp)
vmovdqu %ymm12, 0x100(%rsp)
vmovdqu %ymm15, 0xe0(%rsp)
vzeroupper
callq 0x19e0c0
vmovdqu 0xe0(%rsp), %ymm15
vmovdqu 0xc0(%rsp), %ymm14
vpxor %xmm13, %xmm13, %xmm13
vmovdqu 0x100(%rsp), %ymm12
vmovdqu 0x120(%rsp), %ymm11
vmovdqu 0x160(%rsp), %ymm10
vmovdqu 0x180(%rsp), %ymm9
vmovdqu 0x1a0(%rsp), %ymm8
movq %rbx, 0x10(%rsp)
movl %r15d, 0x18(%rsp)
movq 0x80(%rsp), %rax
vmovdqa (%rax), %ymm0
cmpl $0x2, 0x1c(%rsp)
jg 0x521219
movl 0x3c(%rsp), %eax
movq 0x50(%rsp), %r11
vperm2i128 $0x8, %ymm0, %ymm0, %ymm1 # ymm1 = zero,zero,ymm0[0,1]
vpalignr $0x8, %ymm1, %ymm0, %ymm0 # ymm0 = ymm1[8,9,10,11,12,13,14,15],ymm0[0,1,2,3,4,5,6,7],ymm1[24,25,26,27,28,29,30,31],ymm0[16,17,18,19,20,21,22,23]
decl %eax
jne 0x521207
jmp 0x52121e
movq 0x50(%rsp), %r11
vextracti128 $0x1, %ymm0, %xmm0
movq 0x10(%rbp), %rax
movq (%rax), %rax
vpextrd $0x2, %xmm0, (%rax,%r15,4)
incq %r15
cmpq 0x78(%rsp), %r15
jne 0x520b67
cmpl $0x0, 0x68(%rsp)
je 0x521298
movq 0x40(%rsp), %r8
movl %r8d, %eax
andl $0x1fffffff, %eax       # imm = 0x1FFFFFFF
shll $0x2, %eax
xorl %ecx, %ecx
movq 0x48(%rsp), %r10
movq 0x10(%rsp), %r9
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rbx
movq 0x28(%rsp), %rdx
cmpq %r9, (%rdx,%rcx,8)
jne 0x52128f
movl %ecx, %edx
shrl $0x2, %edx
movl %ecx, %esi
andl $0x3, %esi
imull %r8d, %esi
addl %edx, %esi
cmpl %r10d, %esi
cmovll %esi, %r10d
incq %rcx
cmpl %ecx, %eax
jne 0x52126d
jmp 0x5212b1
movq 0x48(%rsp), %r10
movq 0x40(%rsp), %r8
movq 0x10(%rsp), %r9
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rbx
cmpl $0x1, %r8d
adcl $0x0, %r8d
leaq (,%r11,4), %rax
leaq (%rax,%rax,2), %rcx
shlq $0x3, %r11
shlq $0x2, %r8
xorl %edx, %edx
movq 0x10(%rbp), %rsi
movq 0x8(%rsi), %rsi
vmovdqa (%r13,%rdx,8), %xmm0
vmovdqa 0x10(%r13,%rdx,8), %xmm1
vmovd %xmm0, (%rsi,%rdx)
addq %rdx, %rsi
vpextrd $0x2, %xmm0, (%rax,%rsi)
vmovd %xmm1, (%r11,%rsi)
vpextrd $0x2, %xmm1, (%rcx,%rsi)
addq $0x4, %rdx
cmpq %rdx, %r8
jne 0x5212cf
vmovdqu 0xa0(%rsp), %ymm0
vpcmpgtq %ymm12, %ymm0, %ymm0
vpcmpgtq 0x140(%rsp), %ymm11, %ymm1
vpor %ymm0, %ymm1, %ymm0
vtestpd %ymm0, %ymm0
movl 0x18(%rsp), %eax
je 0x52133d
orb $0x40, 0xc(%rbp)
xorl %r9d, %r9d
xorl %eax, %eax
xorl %r10d, %r10d
movl %r9d, (%rbp)
movl %r10d, 0x4(%rbp)
movl %eax, 0x8(%rbp)
vzeroupper
callq 0x2094b5
movq 0x28(%rsp), %rdi
callq 0x2094b5
movq %r13, %rdi
callq 0x2094b5
movq %r12, %rdi
callq 0x2094b5
movq %rbx, %rdi
callq 0x2094b5
jmp 0x5213ac
callq 0x1ef4ed
jmp 0x5213aa
callq 0x1ef4c7
jmp 0x5213aa
callq 0x1ef4a1
jmp 0x5213aa
callq 0x1ef47b
jmp 0x5213aa
callq 0x1ef455
jmp 0x5213aa
callq 0x1ef42f
jmp 0x5213aa
callq 0x1ef409
jmp 0x5213aa
callq 0x1ef3e3
xorl %ebp, %ebp
movq %rbp, %rax
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)