// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_scan_avx2_256_32.c
// Function: parasail_sw_rowcol_scan_profile_avx2_256_32
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;
    int32_t NEG_LIMIT = 0;
    int32_t POS_LIMIT = 0;
    __m256i vZero;
    int32_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->profile32.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 = 8; /* 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->profile32.score;
    vGapO = _mm256_set1_epi32(open);
    vGapE = _mm256_set1_epi32(gap);
    NEG_LIMIT = (-open < matrix->min ? INT32_MIN + open : INT32_MIN - matrix->min) + 1;
    POS_LIMIT = INT32_MAX - matrix->max - 1;
    vZero = _mm256_setzero_si256();
    score = NEG_LIMIT;
    vNegLimit = _mm256_set1_epi32(NEG_LIMIT);
    vPosLimit = _mm256_set1_epi32(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    vMaxH = vNegLimit;
    vMaxHUnit = vNegLimit;
    vNegInfFront = vZero;
    vNegInfFront = _mm256_insert_epi32_rpl(vNegInfFront, NEG_LIMIT, 0);
    vSegLenXgap = _mm256_add_epi32(vNegInfFront,
            _mm256_slli_si256_rpl(_mm256_set1_epi32(-segLen*gap), 4));

    /* 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_32 | PARASAIL_FLAG_LANES_8;
#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_epi32(vZero,vGapO);
        for (i=segLen-1; i>=0; --i) {
            _mm256_store_si256(pvGapper+i, vGapper);
            vGapper = _mm256_sub_epi32(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, 4);
        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_epi32(
                    _mm256_sub_epi32(vE, vGapE),
                    _mm256_sub_epi32(vH, vGapO));
            vHp = _mm256_add_epi32(vHp, vW);
            vF = _mm256_max_epi32(vF, _mm256_add_epi32(vHt, pvGapper[i]));
            vHt = _mm256_max_epi32(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, 4);
        vF = _mm256_max_epi32(vF, _mm256_add_epi32(vHt, pvGapper[0]));
        for (i=0; i<segWidth-2; ++i) {
            __m256i vFt = _mm256_slli_si256_rpl(vF, 4);
            vFt = _mm256_add_epi32(vFt, vSegLenXgap);
            vF = _mm256_max_epi32(vF, vFt);
        }

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

        {
            __m256i vCompare = _mm256_cmpgt_epi32(vMaxH, vMaxHUnit);
            if (_mm256_movemask_epi8(vCompare)) {
                score = _mm256_hmax_epi32_rpl(vMaxH);
                vMaxHUnit = _mm256_set1_epi32(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, 4);
            }
            result->rowcols->score_row[j] = (int32_t) _mm256_extract_epi32_rpl (vH, 7);
        }
#endif
    }

    /* Trace the alignment ending position on read. */
    {
        int32_t *t = (int32_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_epi32_rpl(vSaturationCheckMin, vNegLimit),
            _mm256_cmpgt_epi32(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 $0x1c8, %rsp            # imm = 0x1C8
movq %rsi, 0x8(%rsp)
testq %rdi, %rdi
je 0x522d7d
movq 0x48(%rdi), %rax
movq %rax, 0x78(%rsp)
testq %rax, %rax
je 0x522d84
movq 0x10(%rdi), %rax
movq %rax, 0x48(%rsp)
testq %rax, %rax
je 0x522d8b
movl 0x8(%rdi), %eax
testl %eax, %eax
jle 0x522d92
cmpq $0x0, 0x8(%rsp)
je 0x522d99
movl %edx, %r15d
testl %edx, %edx
jle 0x522da0
testl %ecx, %ecx
js 0x522da7
movl %r8d, %r13d
testl %r8d, %r8d
js 0x522dae
leaq 0x7(%rax), %r14
movq %r14, %rbp
shrq $0x3, %rbp
movq %rax, 0x18(%rsp)
decl %eax
cltd
idivl %ebp
movl %eax, 0x14(%rsp)
movl %edx, %r12d
movl %ecx, %eax
negl %eax
movq 0x48(%rsp), %rdi
movl 0x20(%rdi), %r8d
movl $0x80000000, %esi       # imm = 0x80000000
movl %ecx, 0x100(%rsp)
movl %ecx, %edx
orl %esi, %edx
subl %r8d, %esi
cmpl %eax, %r8d
cmovgl %edx, %esi
movl %esi, 0x4(%rsp)
movl $0x7ffffffe, %eax       # imm = 0x7FFFFFFE
subl 0x1c(%rdi), %eax
movl %eax, 0xe0(%rsp)
andl $0x7ffffff8, %r14d      # imm = 0x7FFFFFF8
movl %r14d, %edi
movl %r15d, %esi
callq 0x209630
testq %rax, %rax
je 0x522db3
movq %rax, %rbx
movl %r13d, 0xa0(%rsp)
movl %r12d, 0xc0(%rsp)
movl %r15d, 0x30(%rsp)
movq %r14, 0x50(%rsp)
orl $0x8440404, 0xc(%rax)   # imm = 0x8440404
movl $0x20, %edi
movq %rbp, %rsi
callq 0x4c5e3c
movq %rax, %r15
movl $0x20, %edi
movq %rbp, %rsi
callq 0x4c5e3c
movq %rax, %r12
movl $0x20, %edi
movq %rbp, %rsi
callq 0x4c5e3c
movq %rax, %r13
movl $0x20, %edi
movq %rbp, %rsi
callq 0x4c5e3c
movq %rax, %r14
movl $0x20, %edi
movq %rbp, %rsi
callq 0x4c5e3c
movq %rbp, %rsi
movq %rax, %rbp
testq %r15, %r15
sete %al
testq %r12, %r12
sete %cl
orb %al, %cl
testq %r13, %r13
sete %al
movq %r14, 0x38(%rsp)
testq %r14, %r14
sete %dl
orb %al, %dl
orb %cl, %dl
testq %rbp, %rbp
sete %al
orb %dl, %al
jne 0x522db3
movq %rbx, 0x28(%rsp)
movl $0x7, %ebx
subl 0x14(%rsp), %ebx
vmovss 0x100(%rsp), %xmm0
vbroadcastss %xmm0, %ymm0
vmovups %ymm0, 0x180(%rsp)
movl 0xa0(%rsp), %ecx
vmovd %ecx, %xmm0
vpbroadcastd %xmm0, %ymm0
vmovdqu %ymm0, 0x160(%rsp)
movl 0x4(%rsp), %eax
incl %eax
movl %eax, 0x4(%rsp)
vmovd %eax, %xmm0
vpbroadcastd %xmm0, %ymm1
vmovdqu %ymm1, 0x80(%rsp)
vmovss 0xe0(%rsp), %xmm0
vbroadcastss %xmm0, %ymm0
vmovups %ymm0, 0x120(%rsp)
vxorps %xmm0, %xmm0, %xmm0
vmovss %xmm1, %xmm0, %xmm2     # xmm2 = xmm1[0],xmm0[1,2,3]
imull %esi, %ecx
negl %ecx
vmovd %ecx, %xmm0
vpbroadcastd %xmm0, %ymm0
vpxor %xmm1, %xmm1, %xmm1
vpblendd $0x1, %ymm1, %ymm0, %ymm0 # ymm0 = ymm1[0],ymm0[1,2,3,4,5,6,7]
vmovups %ymm2, 0x1a0(%rsp)
vpaddd %ymm0, %ymm2, %ymm0
vmovdqu %ymm0, 0x140(%rsp)
vpxor %xmm0, %xmm0, %xmm0
movq %r13, %rdi
movq %rsi, %r14
callq 0x4c5e45
movq %r15, %rdi
vmovdqu 0x80(%rsp), %ymm0
movq %r14, %rsi
callq 0x4c5e45
vmovdqu 0x160(%rsp), %ymm9
vmovdqu 0x180(%rsp), %ymm7
vpxor %xmm0, %xmm0, %xmm0
vpsubd %ymm7, %ymm0, %ymm0
leal -0x1(%r14), %eax
movq %rax, %rcx
shlq $0x5, %rcx
addq %rbp, %rcx
movq %r14, 0x20(%rsp)
movl %r14d, %edx
vmovdqa %ymm0, (%rcx)
vpsubd %ymm9, %ymm0, %ymm0
addq $-0x20, %rcx
decl %edx
jg 0x522929
movl %eax, %eax
shlq $0x5, %rax
addq %r13, %rax
movq %rax, 0x70(%rsp)
movq 0x20(%rsp), %rax
movq %rax, %rcx
shlq $0x5, %rcx
movq %rcx, 0x58(%rsp)
movl 0xc0(%rsp), %ecx
shlq $0x5, %rcx
addq %r13, %rcx
movq %rcx, 0x68(%rsp)
cmpl $0x2, %ebx
movl $0x1, %ecx
cmovgel %ebx, %ecx
movl %ecx, 0x44(%rsp)
movl 0x30(%rsp), %ecx
movq %rcx, 0x60(%rsp)
movl %eax, %r14d
movq %r14, %rbx
shlq $0x5, %rbx
xorl %edi, %edi
vpxor %xmm11, %xmm11, %xmm11
xorl %esi, %esi
vmovdqu 0x80(%rsp), %ymm0
vmovdqa %ymm0, %ymm13
vmovdqa %ymm0, %ymm12
vmovdqa %ymm0, %ymm6
vmovdqu 0x120(%rsp), %ymm8
vmovdqu 0x140(%rsp), %ymm10
movq 0x70(%rsp), %rax
vmovdqa (%rax), %ymm0
vperm2i128 $0x28, %ymm0, %ymm0, %ymm1 # ymm1 = zero,zero,ymm0[0,1]
vpalignr $0xc, %ymm1, %ymm0, %ymm1 # ymm1 = ymm1[12,13,14,15],ymm0[0,1,2,3,4,5,6,7,8,9,10,11],ymm1[28,29,30,31],ymm0[16,17,18,19,20,21,22,23,24,25,26,27]
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rsp), %rax
movzbl (%rax,%rdi), %edx
movslq (%rcx,%rdx,4), %rdx
movq %r14, %rcx
imulq %rdx, %rcx
shlq $0x5, %rcx
addq 0x78(%rsp), %rcx
xorl %edx, %edx
vmovdqu 0x80(%rsp), %ymm0
vpxor %xmm2, %xmm2, %xmm2
vpaddd (%rcx,%rdx), %ymm1, %ymm1
vmovdqa (%r13,%rdx), %ymm3
vmovdqa (%r15,%rdx), %ymm4
vpsubd %ymm9, %ymm4, %ymm4
vpsubd %ymm7, %ymm3, %ymm5
vpmaxsd %ymm5, %ymm4, %ymm4
vpaddd (%rbp,%rdx), %ymm2, %ymm2
vpmaxsd %ymm2, %ymm0, %ymm0
vpmaxsd %ymm1, %ymm4, %ymm2
vmovdqa %ymm4, (%r15,%rdx)
vmovdqa %ymm2, (%r12,%rdx)
addq $0x20, %rdx
vmovdqa %ymm3, %ymm1
cmpq %rdx, %rbx
jne 0x522a08
vperm2i128 $0x8, %ymm2, %ymm2, %ymm1 # ymm1 = zero,zero,ymm2[0,1]
vpalignr $0xc, %ymm1, %ymm2, %ymm1 # ymm1 = ymm1[12,13,14,15],ymm2[0,1,2,3,4,5,6,7,8,9,10,11],ymm1[28,29,30,31],ymm2[16,17,18,19,20,21,22,23,24,25,26,27]
vpaddd (%rbp), %ymm1, %ymm2
vpmaxsd %ymm2, %ymm0, %ymm0
movl $0x6, %ecx
vperm2i128 $0x28, %ymm0, %ymm0, %ymm2 # ymm2 = zero,zero,ymm0[0,1]
vpalignr $0xc, %ymm2, %ymm0, %ymm2 # ymm2 = ymm2[12,13,14,15],ymm0[0,1,2,3,4,5,6,7,8,9,10,11],ymm2[28,29,30,31],ymm0[16,17,18,19,20,21,22,23,24,25,26,27]
vpaddd %ymm2, %ymm10, %ymm2
vpmaxsd %ymm2, %ymm0, %ymm0
decl %ecx
jne 0x522a6c
vperm2i128 $0x28, %ymm0, %ymm0, %ymm2 # ymm2 = zero,zero,ymm0[0,1]
vpalignr $0xc, %ymm2, %ymm0, %ymm0 # ymm0 = ymm2[12,13,14,15],ymm0[0,1,2,3,4,5,6,7,8,9,10,11],ymm2[28,29,30,31],ymm0[16,17,18,19,20,21,22,23,24,25,26,27]
vpaddd 0x1a0(%rsp), %ymm0, %ymm0
vpmaxsd %ymm11, %ymm1, %ymm1
vpmaxsd %ymm0, %ymm1, %ymm1
xorl %ecx, %ecx
vpsubd %ymm9, %ymm0, %ymm0
vpsubd %ymm7, %ymm1, %ymm1
vpmaxsd %ymm1, %ymm0, %ymm0
vpmaxsd (%r12,%rcx), %ymm0, %ymm1
vpmaxsd %ymm11, %ymm1, %ymm1
vmovdqa %ymm1, (%r13,%rcx)
vpminsd %ymm1, %ymm8, %ymm8
vpmaxsd %ymm1, %ymm6, %ymm6
vpmaxsd %ymm12, %ymm1, %ymm12
addq $0x20, %rcx
cmpq %rcx, %rbx
jne 0x522aa6
vpcmpgtd %ymm13, %ymm12, %ymm0
vtestps %ymm0, %ymm0
je 0x522bb2
vpermq $0x44, %ymm12, %ymm0    # ymm0 = ymm12[0,1,0,1]
vpmaxsd %ymm0, %ymm12, %ymm0
vpslldq $0x8, %ymm0, %ymm1      # ymm1 = zero,zero,zero,zero,zero,zero,zero,zero,ymm0[0,1,2,3,4,5,6,7],zero,zero,zero,zero,zero,zero,zero,zero,ymm0[16,17,18,19,20,21,22,23]
vpmaxsd %ymm1, %ymm0, %ymm0
vpslldq $0x4, %ymm0, %ymm1      # ymm1 = zero,zero,zero,zero,ymm0[0,1,2,3,4,5,6,7,8,9,10,11],zero,zero,zero,zero,ymm0[16,17,18,19,20,21,22,23,24,25,26,27]
vpmaxsd %ymm1, %ymm0, %ymm0
vextracti128 $0x1, %ymm0, %xmm1
vpextrd $0x3, %xmm1, 0x4(%rsp)
vpbroadcastd 0xd6cec(%rip), %ymm1 # 0x5f9810
vpermd %ymm0, %ymm1, %ymm0
vmovdqu %ymm0, 0xa0(%rsp)
movq %rdi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq %r13, %rsi
movq 0x58(%rsp), %rdx
vmovdqu %ymm6, 0x100(%rsp)
vmovdqu %ymm8, 0xe0(%rsp)
vmovdqu %ymm12, 0xc0(%rsp)
vzeroupper
callq 0x19e0c0
vmovdqu 0xa0(%rsp), %ymm13
vmovdqu 0xc0(%rsp), %ymm12
vpxor %xmm11, %xmm11, %xmm11
movq 0x30(%rsp), %rdi
vmovdqu 0x140(%rsp), %ymm10
vmovdqu 0x160(%rsp), %ymm9
vmovdqu 0xe0(%rsp), %ymm8
vmovdqu 0x180(%rsp), %ymm7
vmovdqu 0x100(%rsp), %ymm6
movl %edi, %esi
movq 0x68(%rsp), %rax
vmovdqa (%rax), %ymm0
cmpl $0x6, 0x14(%rsp)
jg 0x522bd6
movl 0x44(%rsp), %ecx
vperm2i128 $0x28, %ymm0, %ymm0, %ymm1 # ymm1 = zero,zero,ymm0[0,1]
vpalignr $0xc, %ymm1, %ymm0, %ymm0 # ymm0 = ymm1[12,13,14,15],ymm0[0,1,2,3,4,5,6,7,8,9,10,11],ymm1[28,29,30,31],ymm0[16,17,18,19,20,21,22,23,24,25,26,27]
decl %ecx
jne 0x522bc6
vextracti128 $0x1, %ymm0, %xmm0
movq 0x28(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq (%rcx), %rcx
vpextrd $0x3, %xmm0, (%rcx,%rdi,4)
incq %rdi
cmpq 0x60(%rsp), %rdi
jne 0x5229be
cmpl $0x0, 0x50(%rsp)
je 0x522c51
movl %esi, 0x8(%rsp)
movq 0x20(%rsp), %rcx
andl $0xfffffff, %ecx        # imm = 0xFFFFFFF
shll $0x3, %ecx
xorl %edx, %edx
movq 0x28(%rsp), %r11
movq 0x18(%rsp), %r8
movl 0x4(%rsp), %eax
movq 0x38(%rsp), %rsi
cmpl %eax, (%rsi,%rdx,4)
jne 0x522c48
movl %edx, %esi
shrl $0x3, %esi
movl %edx, %edi
andl $0x7, %edi
imull 0x20(%rsp), %edi
addl %esi, %edi
cmpl %r8d, %edi
cmovll %edi, %r8d
incq %rdx
cmpl %edx, %ecx
jne 0x522c26
jmp 0x522c5f
movl %esi, 0x8(%rsp)
movq 0x28(%rsp), %r11
movq 0x18(%rsp), %r8
movq %r8, 0x18(%rsp)
movq 0x20(%rsp), %rax
leal (,%rax,4), %ecx
cmpl $0x1, %eax
adcl $0x0, %eax
leaq (%r14,%r14,8), %rdx
leaq (%rdx,%rdx,2), %rdx
addq %r14, %rdx
leaq (,%r14,8), %rsi
leaq (%rsi,%rsi,2), %rdi
leaq (%rcx,%rcx,4), %r8
shlq $0x4, %r14
movq %r14, %r9
leaq (%rcx,%rcx,2), %rbx
shll $0x2, %eax
xorl %r10d, %r10d
movq %r11, %r14
movq 0x10(%r11), %r11
movq 0x8(%r11), %r11
vmovdqa (%r13,%r10,8), %xmm0
vmovdqa 0x10(%r13,%r10,8), %xmm1
vmovd %xmm0, (%r11,%r10)
addq %r10, %r11
vpextrd $0x1, %xmm0, (%rcx,%r11)
vpextrd $0x2, %xmm0, (%rsi,%r11)
vpextrd $0x3, %xmm0, (%rbx,%r11)
vmovd %xmm1, (%r9,%r11)
vpextrd $0x1, %xmm1, (%r8,%r11)
vpextrd $0x2, %xmm1, (%rdi,%r11)
vpextrd $0x3, %xmm1, (%rdx,%r11)
movq %r14, %r11
addq $0x4, %r10
cmpq %r10, %rax
jne 0x522ca2
vmovdqu 0x80(%rsp), %ymm0
vpcmpgtd %ymm8, %ymm0, %ymm0
vpcmpgtd 0x120(%rsp), %ymm6, %ymm1
vpor %ymm0, %ymm1, %ymm0
vtestps %ymm0, %ymm0
movl 0x8(%rsp), %ecx
movq 0x18(%rsp), %rdx
je 0x522d3c
orb $0x40, 0xc(%r11)
movl $0x0, 0x4(%rsp)
xorl %ecx, %ecx
xorl %edx, %edx
movl 0x4(%rsp), %eax
movl %eax, (%r11)
movl %edx, 0x4(%r11)
movl %ecx, 0x8(%r11)
movq %rbp, %rdi
vzeroupper
callq 0x2094b5
movq 0x38(%rsp), %rdi
callq 0x2094b5
movq %r13, %rdi
callq 0x2094b5
movq %r12, %rdi
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
movq %r14, %rax
jmp 0x522db5
callq 0x1efb9b
jmp 0x522db3
callq 0x1efb75
jmp 0x522db3
callq 0x1efb4f
jmp 0x522db3
callq 0x1efb29
jmp 0x522db3
callq 0x1efb03
jmp 0x522db3
callq 0x1efadd
jmp 0x522db3
callq 0x1efab7
jmp 0x522db3
callq 0x1efa91
xorl %eax, %eax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop