// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_striped_avx2_256_8.c
// Function: parasail_nw_rowcol_striped_profile_avx2_256_8
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 k = 0;
    int s1Len = 0;
    int32_t end_query = 0;
    int32_t end_ref = 0;
    const parasail_matrix_t *matrix = NULL;
    int32_t segWidth = 0;
    int32_t segLen = 0;
    int32_t offset = 0;
    int32_t position = 0;
    __m256i* restrict vProfile = NULL;
    __m256i* restrict pvHStore = NULL;
    __m256i* restrict pvHLoad = NULL;
    __m256i* restrict pvE = NULL;
    int8_t* restrict boundary = NULL;
    __m256i vGapO;
    __m256i vGapE;
    int8_t NEG_LIMIT = 0;
    int8_t POS_LIMIT = 0;
    int8_t score = 0;
    __m256i vNegLimit;
    __m256i vPosLimit;
    __m256i vSaturationCheckMin;
    __m256i vSaturationCheckMax;
    parasail_result_t *result = NULL;

    /* validate inputs */
    PARASAIL_CHECK_NULL(profile);
    PARASAIL_CHECK_NULL(profile->profile8.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;
    k = 0;
    s1Len = profile->s1Len;
    end_query = s1Len-1;
    end_ref = s2Len-1;
    matrix = profile->matrix;
    segWidth = 32; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    offset = (s1Len - 1) % segLen;
    position = (segWidth - 1) - (s1Len - 1) / segLen;
    vProfile = (__m256i*)profile->profile8.score;
    vGapO = _mm256_set1_epi8(open);
    vGapE = _mm256_set1_epi8(gap);
    NEG_LIMIT = (-open < matrix->min ? INT8_MIN + open : INT8_MIN - matrix->min) + 1;
    POS_LIMIT = INT8_MAX - matrix->max - 1;
    score = NEG_LIMIT;
    vNegLimit = _mm256_set1_epi8(NEG_LIMIT);
    vPosLimit = _mm256_set1_epi8(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;

    /* 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_NW | PARASAIL_FLAG_STRIPED
        | PARASAIL_FLAG_BITS_8 | PARASAIL_FLAG_LANES_32;
#ifdef PARASAIL_TABLE
    result->flag |= PARASAIL_FLAG_TABLE;
#endif
#ifdef PARASAIL_ROWCOL
    result->flag |= PARASAIL_FLAG_ROWCOL;
#endif

    /* initialize heap variables */
    pvHStore = parasail_memalign___m256i(32, segLen);
    pvHLoad  = parasail_memalign___m256i(32, segLen);
    pvE      = parasail_memalign___m256i(32, segLen);
    boundary = parasail_memalign_int8_t(32, s2Len+1);

    /* validate heap variables */
    if (!pvHStore) return NULL;
    if (!pvHLoad) return NULL;
    if (!pvE) return NULL;
    if (!boundary) return NULL;

    /* initialize H and E */
    {
        int32_t index = 0;
        for (i=0; i<segLen; ++i) {
            int32_t segNum = 0;
            __m256i_8_t h;
            __m256i_8_t e;
            for (segNum=0; segNum<segWidth; ++segNum) {
                int64_t tmp = -open-gap*(segNum*segLen+i);
                h.v[segNum] = tmp < INT8_MIN ? INT8_MIN : tmp;
                tmp = tmp - open;
                e.v[segNum] = tmp < INT8_MIN ? INT8_MIN : tmp;
            }
            _mm256_store_si256(&pvHStore[index], h.m);
            _mm256_store_si256(&pvE[index], e.m);
            ++index;
        }
    }

    /* initialize uppder boundary */
    {
        boundary[0] = 0;
        for (i=1; i<=s2Len; ++i) {
            int64_t tmp = -open-gap*(i-1);
            boundary[i] = tmp < INT8_MIN ? INT8_MIN : tmp;
        }
    }

    /* outer loop over database sequence */
    for (j=0; j<s2Len; ++j) {
        __m256i vE;
        /* Initialize F value to -inf.  Any errors to vH values will be
         * corrected in the Lazy_F loop.  */
        __m256i vF = vNegLimit;

        /* load final segment of pvHStore and shift left by 2 bytes */
        __m256i vH = _mm256_slli_si256_rpl(pvHStore[segLen - 1], 1);

        /* Correct part of the vProfile */
        const __m256i* vP = vProfile + matrix->mapper[(unsigned char)s2[j]] * segLen;

        /* Swap the 2 H buffers. */
        __m256i* pv = pvHLoad;
        pvHLoad = pvHStore;
        pvHStore = pv;

        /* insert upper boundary condition */
        vH = _mm256_insert_epi8_rpl(vH, boundary[j], 0);

        /* inner loop to process the query sequence */
        for (i=0; i<segLen; ++i) {
            vH = _mm256_adds_epi8(vH, _mm256_load_si256(vP + i));
            vE = _mm256_load_si256(pvE + i);

            /* Get max from vH, vE and vF. */
            vH = _mm256_max_epi8(vH, vE);
            vH = _mm256_max_epi8(vH, vF);
            /* Save vH values. */
            _mm256_store_si256(pvHStore + i, vH);
            vSaturationCheckMax = _mm256_max_epi8(vSaturationCheckMax, vH);
            vSaturationCheckMin = _mm256_min_epi8(vSaturationCheckMin, vH);
            vSaturationCheckMin = _mm256_min_epi8(vSaturationCheckMin, vE);
            vSaturationCheckMin = _mm256_min_epi8(vSaturationCheckMin, vF);
#ifdef PARASAIL_TABLE
            arr_store_si256(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif

            /* Update vE value. */
            vH = _mm256_subs_epi8(vH, vGapO);
            vE = _mm256_subs_epi8(vE, vGapE);
            vE = _mm256_max_epi8(vE, vH);
            _mm256_store_si256(pvE + i, vE);

            /* Update vF value. */
            vF = _mm256_subs_epi8(vF, vGapE);
            vF = _mm256_max_epi8(vF, vH);

            /* Load the next vH. */
            vH = _mm256_load_si256(pvHLoad + i);
        }

        /* Lazy_F loop: has been revised to disallow adjecent insertion and
         * then deletion, so don't update E(i, i), learn from SWPS3 */
        for (k=0; k<segWidth; ++k) {
            int64_t tmp = boundary[j+1]-open;
            int8_t tmp2 = tmp < INT8_MIN ? INT8_MIN : tmp;
            vF = _mm256_slli_si256_rpl(vF, 1);
            vF = _mm256_insert_epi8_rpl(vF, tmp2, 0);
            for (i=0; i<segLen; ++i) {
                vH = _mm256_load_si256(pvHStore + i);
                vH = _mm256_max_epi8(vH,vF);
                _mm256_store_si256(pvHStore + i, vH);
                vSaturationCheckMin = _mm256_min_epi8(vSaturationCheckMin, vH);
                vSaturationCheckMax = _mm256_max_epi8(vSaturationCheckMax, vH);
#ifdef PARASAIL_TABLE
                arr_store_si256(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif
                vH = _mm256_subs_epi8(vH, vGapO);
                vF = _mm256_subs_epi8(vF, vGapE);
                if (! _mm256_movemask_epi8(_mm256_cmpgt_epi8(vF, vH))) goto end;
                /*vF = _mm256_max_epi8(vF, vH);*/
            }
        }
end:
        {
        }

#ifdef PARASAIL_ROWCOL
        /* extract last value from the column */
        {
            vH = _mm256_load_si256(pvHStore + offset);
            for (k=0; k<position; ++k) {
                vH = _mm256_slli_si256_rpl(vH, 1);
            }
            result->rowcols->score_row[j] = (int8_t) _mm256_extract_epi8_rpl (vH, 31);
        }
#endif
    }

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

    /* extract last value from the last column */
    {
        __m256i vH = _mm256_load_si256(pvHStore + offset);
        for (k=0; k<position; ++k) {
            vH = _mm256_slli_si256_rpl (vH, 1);
        }
        score = (int8_t) _mm256_extract_epi8_rpl (vH, 31);
    }

    if (_mm256_movemask_epi8(_mm256_or_si256(
            _mm256_cmplt_epi8_rpl(vSaturationCheckMin, vNegLimit),
            _mm256_cmpgt_epi8(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(boundary);
    parasail_free(pvE);
    parasail_free(pvHLoad);
    parasail_free(pvHStore);

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0x180, %rsp            # imm = 0x180
movq %rsi, 0x60(%rsp)
testq %rdi, %rdi
je 0x53d24a
movq 0x18(%rdi), %rax
movq %rax, 0x78(%rsp)
testq %rax, %rax
je 0x53d251
movq 0x10(%rdi), %rax
movq %rax, 0x58(%rsp)
testq %rax, %rax
je 0x53d258
movl 0x8(%rdi), %edi
testl %edi, %edi
jle 0x53d25f
cmpq $0x0, 0x60(%rsp)
je 0x53d266
movl %edx, %r9d
testl %edx, %edx
jle 0x53d26d
movl %ecx, %r13d
testl %ecx, %ecx
js 0x53d274
testl %r8d, %r8d
js 0x53d27b
movl %r8d, 0x30(%rsp)
leal -0x1(%rdi), %r15d
addq $0x1f, %rdi
movq %rdi, %r12
shrq $0x5, %r12
movl %r15d, %eax
cltd
idivl %r12d
movl %eax, 0x2c(%rsp)
movl %edx, 0x38(%rsp)
movq 0x58(%rsp), %rdx
movl 0x20(%rdx), %eax
movl %eax, %ecx
negb %cl
movzbl %cl, %ebx
movl %r13d, %r14d
negl %r14d
cmpl %r14d, %eax
cmovgl %r13d, %ebx
movb $0x7e, %al
subb 0x1c(%rdx), %al
movl %eax, 0x20(%rsp)
andl $0x7fffffe0, %edi       # imm = 0x7FFFFFE0
movl %r9d, %esi
movq %r9, 0x18(%rsp)
callq 0x209630
testq %rax, %rax
je 0x53d280
movl %ebx, 0x68(%rsp)
movl %r15d, 0x84(%rsp)
movq %rax, 0x40(%rsp)
orl $0x20140801, 0xc(%rax)  # imm = 0x20140801
movl $0x20, %edi
movq %r12, %rsi
callq 0x4c5e3c
movq %rax, %r15
movl $0x20, %edi
movq %r12, %rsi
callq 0x4c5e3c
movq %rax, %rbx
movl $0x20, %edi
movq %r12, %rsi
callq 0x4c5e3c
movq %r12, 0x48(%rsp)
movq %rax, %r12
movq 0x18(%rsp), %rax
leal 0x1(%rax), %esi
movl $0x20, %edi
callq 0x2094c8
testq %r15, %r15
sete %cl
movq %rbx, 0x70(%rsp)
testq %rbx, %rbx
sete %dl
orb %cl, %dl
testq %r12, %r12
sete %cl
testq %rax, %rax
sete %sil
orb %cl, %sil
orb %dl, %sil
jne 0x53d280
movq 0x18(%rsp), %rcx
decl %ecx
movl %ecx, 0x50(%rsp)
movl $0x1f, %ecx
subl 0x2c(%rsp), %ecx
movl %ecx, 0x54(%rsp)
vmovd %r13d, %xmm0
vpbroadcastb %xmm0, %ymm4
movl 0x30(%rsp), %edx
vmovd %edx, %xmm0
vpbroadcastb %xmm0, %ymm5
movl 0x68(%rsp), %ecx
addb $-0x7f, %cl
vmovd %ecx, %xmm0
vpbroadcastb %xmm0, %ymm0
vmovd 0x20(%rsp), %xmm1
vpbroadcastb %xmm1, %ymm1
movl %r13d, %ecx
movl %edx, %edx
movslq %r14d, %rsi
movl 0x48(%rsp), %edi
negq %rcx
movq %rdi, %r8
movq %rdx, 0x20(%rsp)
imulq %rdx, %r8
xorl %r9d, %r9d
movq $-0x80, %r10
movq %rsi, %r11
xorl %edx, %edx
cmpq $-0x7f, %r11
movq $-0x80, %rbx
cmovgeq %r11, %rbx
movb %bl, 0x140(%rsp,%rdx)
leaq (%rcx,%r11), %rbx
cmpq $-0x7f, %rbx
cmovlq %r10, %rbx
movb %bl, 0x120(%rsp,%rdx)
incq %rdx
subq %r8, %r11
cmpq $0x20, %rdx
jne 0x53cacd
movq %r9, %rdx
shlq $0x5, %rdx
vmovaps 0x140(%rsp), %ymm2
vmovaps %ymm2, (%r15,%rdx)
vmovaps 0x120(%rsp), %ymm2
vmovaps %ymm2, (%r12,%rdx)
incq %r9
subq 0x20(%rsp), %rsi
cmpq %rdi, %r9
jne 0x53cac8
movb $0x0, (%rax)
movq 0x18(%rsp), %r9
cmpl $0x2, %r9d
movl $0x1, %ecx
cmovgel %r9d, %ecx
xorl %edx, %edx
movl 0x30(%rsp), %r8d
cmpl $-0x7f, %r14d
movl $0xffffff80, %esi       # imm = 0xFFFFFF80
cmovgel %r14d, %esi
movb %sil, 0x1(%rax,%rdx)
subl %r8d, %r14d
incq %rdx
cmpq %rdx, %rcx
jne 0x53cb50
movq 0x48(%rsp), %r10
leal -0x1(%r10), %esi
movl 0x38(%rsp), %r8d
movl $0x1, %edx
cmpl %edx, %r10d
adcl $0x0, %r10d
movl 0x54(%rsp), %ecx
cmpl $0x2, %ecx
movl $0x1, %r11d
cmovgel %ecx, %r11d
movl %r11d, 0x38(%rsp)
cmpl $0x2, %r9d
cmovgel %r9d, %edx
movq %rdx, 0x18(%rsp)
shlq $0x5, %r10
xorl %edx, %edx
shlq $0x5, %rsi
movq %rsi, 0x20(%rsp)
movl $0xffffff80, %esi       # imm = 0xFFFFFF80
movq %r8, 0x88(%rsp)
shlq $0x5, %r8
movq %r8, 0x30(%rsp)
vmovdqa %ymm0, %ymm2
vmovdqa %ymm1, %ymm3
movq 0x70(%rsp), %rcx
movq %r15, %r14
movq %rcx, %r15
movq 0x58(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x60(%rsp), %r8
movzbl (%r8,%rdx), %r8d
movslq (%rcx,%r8,4), %rcx
movq %rdi, %rbx
imulq %rcx, %rbx
shlq $0x5, %rbx
addq 0x78(%rsp), %rbx
movq 0x20(%rsp), %rcx
vmovdqa (%r14,%rcx), %ymm6
vinserti128 $0x1, %xmm6, %ymm0, %ymm7
vpalignr $0xf, %ymm7, %ymm6, %ymm6 # ymm6 = ymm7[15],ymm6[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm7[31],ymm6[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpinsrb $0x0, (%rax,%rdx), %xmm6, %xmm7
vpblendd $0xf, %ymm7, %ymm6, %ymm7 # ymm7 = ymm7[0,1,2,3],ymm6[4,5,6,7]
xorl %ecx, %ecx
vmovdqa %ymm0, %ymm6
vpaddsb (%rbx,%rcx), %ymm7, %ymm7
vmovdqa (%r12,%rcx), %ymm8
vpmaxsb %ymm6, %ymm8, %ymm9
vpmaxsb %ymm9, %ymm7, %ymm7
vmovdqa %ymm7, (%r15,%rcx)
vpmaxsb %ymm7, %ymm2, %ymm2
vpminsb %ymm8, %ymm3, %ymm3
vpminsb %ymm6, %ymm3, %ymm3
vpminsb %ymm7, %ymm3, %ymm3
vpsubsb %ymm4, %ymm7, %ymm7
vpsubsb %ymm5, %ymm8, %ymm8
vpmaxsb %ymm7, %ymm8, %ymm8
vmovdqa %ymm8, (%r12,%rcx)
vpsubsb %ymm5, %ymm6, %ymm6
vpmaxsb %ymm7, %ymm6, %ymm6
vmovdqa (%r14,%rcx), %ymm7
addq $0x20, %rcx
cmpq %rcx, %r10
jne 0x53cc33
xorl %ebx, %ebx
vinserti128 $0x1, %xmm6, %ymm0, %ymm7
vpalignr $0xf, %ymm7, %ymm6, %ymm6 # ymm6 = ymm7[15],ymm6[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm7[31],ymm6[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
movsbl 0x1(%rax,%rdx), %ecx
subl %r13d, %ecx
cmpl $-0x7f, %ecx
cmovll %esi, %ecx
vpinsrb $0x0, %ecx, %xmm6, %xmm7
vpblendd $0xf, %ymm7, %ymm6, %ymm6 # ymm6 = ymm7[0,1,2,3],ymm6[4,5,6,7]
movb $0x1, %cl
movl $0x1, %r8d
xorl %r9d, %r9d
vpmaxsb (%r15,%r9), %ymm6, %ymm7
vmovdqa %ymm7, (%r15,%r9)
vpminsb %ymm7, %ymm3, %ymm3
vpmaxsb %ymm7, %ymm2, %ymm2
vpsubsb %ymm4, %ymm7, %ymm7
vpsubsb %ymm5, %ymm6, %ymm6
vpcmpgtb %ymm7, %ymm6, %ymm7
vpmovmskb %ymm7, %r11d
testl %r11d, %r11d
je 0x53ccfd
cmpq %rdi, %r8
setb %cl
addq $0x20, %r9
incq %r8
cmpq %r9, %r10
jne 0x53ccc0
testb $0x1, %cl
jne 0x53cd0c
leal 0x1(%rbx), %ecx
cmpl $0x1f, %ebx
movl %ecx, %ebx
jb 0x53cc8f
movq 0x30(%rsp), %rcx
vmovdqa (%r15,%rcx), %ymm6
cmpl $0x1e, 0x2c(%rsp)
jg 0x53cd39
movl 0x38(%rsp), %ecx
movq 0x40(%rsp), %r8
vperm2i128 $0x28, %ymm6, %ymm6, %ymm7 # ymm7 = zero,zero,ymm6[0,1]
vpalignr $0xf, %ymm7, %ymm6, %ymm6 # ymm6 = ymm7[15],ymm6[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm7[31],ymm6[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
decl %ecx
jne 0x53cd27
jmp 0x53cd3e
movq 0x40(%rsp), %r8
vextracti128 $0x1, %ymm6, %xmm6
vpextrb $0xf, %xmm6, %ecx
movsbl %cl, %ecx
movq 0x10(%r8), %r8
movq (%r8), %r8
movl %ecx, (%r8,%rdx,4)
incq %rdx
movq %r14, %rcx
cmpq 0x18(%rsp), %rdx
jne 0x53cbdc
movq 0x48(%rsp), %rsi
leal (,%rsi,4), %r8d
leal (,%rsi,8), %r10d
movl %esi, %ecx
shll $0x4, %ecx
movq %rcx, 0x60(%rsp)
leaq (%rdi,%rdi,8), %rcx
leaq (%rcx,%rcx,2), %rcx
addq %rdi, %rcx
movq %rcx, 0x58(%rsp)
cmpl $0x1, %esi
adcl $0x0, %esi
imulq $0x7c, %rdi, %rcx
movq %rcx, 0x78(%rsp)
imulq $0x78, %rdi, %rcx
movq %rcx, 0x20(%rsp)
imulq $0x74, %rdi, %rcx
movq %rcx, 0x18(%rsp)
imulq $0x70, %rdi, %rcx
movq %rcx, 0x30(%rsp)
movq %rdi, %r11
shlq $0x5, %r11
movl %edi, %ecx
shll $0x4, %ecx
leaq (%rcx,%rcx,4), %rdx
movq %rdx, 0x38(%rsp)
movq %rdi, %r9
shlq $0x6, %r9
leaq (%rcx,%rcx,2), %rcx
movq %rcx, 0x68(%rsp)
imulq $0x6c, %rdi, %rcx
movq %rcx, 0x118(%rsp)
imulq $0x68, %rdi, %rcx
movq %rcx, 0x110(%rsp)
imulq $0x64, %rdi, %rcx
movq %rcx, 0x108(%rsp)
imulq $0x5c, %rdi, %rcx
movq %rcx, 0x100(%rsp)
imulq $0x58, %rdi, %rcx
movq %rcx, 0xf8(%rsp)
imulq $0x54, %rdi, %rcx
movq %rcx, 0xf0(%rsp)
imulq $0x4c, %rdi, %rcx
movq %rcx, 0xe8(%rsp)
leal (,%rdi,8), %ecx
leal (,%rdi,4), %edx
imulq $0x3c, %rdi, %rbx
movq %rbx, 0xe0(%rsp)
imulq $0x38, %rdi, %rbx
movq %rbx, 0xd8(%rsp)
imulq $0x34, %rdi, %rbx
movq %rbx, 0xd0(%rsp)
imulq $0x2c, %rdi, %rdi
movq %rdi, 0xc8(%rsp)
leaq (%rcx,%rcx,8), %rdi
movq %rdi, 0xc0(%rsp)
leaq (%rcx,%rcx,4), %rcx
movq %rcx, 0xb8(%rsp)
movq %r9, 0x70(%rsp)
leaq (%r9,%rdx), %rcx
movq %rcx, 0xb0(%rsp)
leaq (%rdx,%rdx,8), %rcx
movq %rcx, 0xa8(%rsp)
shll $0x2, %esi
movq %rsi, 0x48(%rsp)
leaq (%r8,%r8,2), %rcx
movq %rcx, 0xa0(%rsp)
movq %r8, %rsi
leaq (%r8,%r8,4), %rcx
movq %rcx, 0x98(%rsp)
movq %r10, %rbx
leaq (%r10,%r10,2), %rcx
movq %rcx, 0x90(%rsp)
movq %r11, %r9
leaq (%r11,%r11,2), %rcx
xorl %edi, %edi
movq 0x40(%rsp), %r11
movq 0x10(%r11), %rdx
movq 0x8(%rdx), %rdx
vmovdqa (%r15,%rdi,8), %xmm5
vmovdqa 0x10(%r15,%rdi,8), %xmm4
vmovd %xmm5, %r8d
movsbl %r8b, %r8d
movl %r8d, (%rdx,%rdi)
vpextrb $0x1, %xmm5, %r8d
addq %rdi, %rdx
movsbl %r8b, %r8d
vpextrb $0x2, %xmm5, %r10d
movl %r8d, (%rsi,%rdx)
movsbl %r10b, %r8d
vpextrb $0x3, %xmm5, %r10d
movl %r8d, (%rbx,%rdx)
movsbl %r10b, %r8d
vpextrb $0x4, %xmm5, %r10d
movq 0xa0(%rsp), %r13
movl %r8d, (%r13,%rdx)
movsbl %r10b, %r8d
vpextrb $0x5, %xmm5, %r10d
movq 0x60(%rsp), %r13
movl %r8d, (%r13,%rdx)
movsbl %r10b, %r8d
vpextrb $0x6, %xmm5, %r10d
movq 0x98(%rsp), %r13
movl %r8d, (%r13,%rdx)
movsbl %r10b, %r8d
vpextrb $0x7, %xmm5, %r10d
movq 0x90(%rsp), %r13
movl %r8d, (%r13,%rdx)
movsbl %r10b, %r8d
vpextrb $0x8, %xmm5, %r10d
movq 0x58(%rsp), %r13
movl %r8d, (%r13,%rdx)
movsbl %r10b, %r8d
vpextrb $0x9, %xmm5, %r10d
movl %r8d, (%r9,%rdx)
movsbl %r10b, %r8d
vpextrb $0xa, %xmm5, %r10d
movq 0xa8(%rsp), %r13
movl %r8d, (%r13,%rdx)
movsbl %r10b, %r8d
vpextrb $0xb, %xmm5, %r10d
movq 0xb8(%rsp), %r13
movl %r8d, (%r13,%rdx)
movsbl %r10b, %r8d
vpextrb $0xc, %xmm5, %r10d
movq 0xc8(%rsp), %r13
movl %r8d, (%r13,%rdx)
movsbl %r10b, %r8d
vpextrb $0xd, %xmm5, %r10d
movq 0x68(%rsp), %r13
movl %r8d, (%r13,%rdx)
movsbl %r10b, %r8d
vpextrb $0xe, %xmm5, %r10d
movq 0xd0(%rsp), %r13
movl %r8d, (%r13,%rdx)
movsbl %r10b, %r8d
vpextrb $0xf, %xmm5, %r10d
movq 0xd8(%rsp), %r13
movl %r8d, (%r13,%rdx)
movsbl %r10b, %r8d
movq 0xe0(%rsp), %r10
movl %r8d, (%r10,%rdx)
vmovd %xmm4, %r8d
movsbl %r8b, %r8d
movq 0x70(%rsp), %r10
movl %r8d, (%r10,%rdx)
vpextrb $0x1, %xmm4, %r8d
movsbl %r8b, %r8d
movq 0xb0(%rsp), %r10
movl %r8d, (%r10,%rdx)
vpextrb $0x2, %xmm4, %r8d
movsbl %r8b, %r8d
movq 0xc0(%rsp), %r10
movl %r8d, (%r10,%rdx)
vpextrb $0x3, %xmm4, %r8d
movsbl %r8b, %r8d
movq 0xe8(%rsp), %r10
movl %r8d, (%r10,%rdx)
vpextrb $0x4, %xmm4, %r8d
movsbl %r8b, %r8d
movq 0x38(%rsp), %r10
movl %r8d, (%r10,%rdx)
vpextrb $0x5, %xmm4, %r8d
movsbl %r8b, %r8d
movq 0xf0(%rsp), %r10
movl %r8d, (%r10,%rdx)
vpextrb $0x6, %xmm4, %r8d
movsbl %r8b, %r8d
movq 0xf8(%rsp), %r10
movl %r8d, (%r10,%rdx)
vpextrb $0x7, %xmm4, %r8d
movsbl %r8b, %r8d
movq 0x100(%rsp), %r10
movl %r8d, (%r10,%rdx)
vpextrb $0x8, %xmm4, %r8d
movsbl %r8b, %r8d
movl %r8d, (%rcx,%rdx)
vpextrb $0x9, %xmm4, %r8d
movsbl %r8b, %r8d
movq 0x108(%rsp), %r10
movl %r8d, (%r10,%rdx)
vpextrb $0xa, %xmm4, %r8d
movsbl %r8b, %r8d
movq 0x110(%rsp), %r10
movl %r8d, (%r10,%rdx)
vpextrb $0xb, %xmm4, %r8d
movsbl %r8b, %r8d
movq 0x118(%rsp), %r10
movl %r8d, (%r10,%rdx)
vpextrb $0xc, %xmm4, %r8d
movsbl %r8b, %r8d
movq 0x30(%rsp), %r10
movl %r8d, (%r10,%rdx)
vpextrb $0xd, %xmm4, %r8d
movsbl %r8b, %r8d
movq 0x18(%rsp), %r10
movl %r8d, (%r10,%rdx)
vpextrb $0xe, %xmm4, %r8d
movsbl %r8b, %r8d
movq 0x20(%rsp), %r10
movl %r8d, (%r10,%rdx)
vpextrb $0xf, %xmm4, %r8d
movsbl %r8b, %r8d
movq 0x78(%rsp), %r10
movl %r8d, (%r10,%rdx)
addq $0x4, %rdi
cmpq %rdi, 0x48(%rsp)
jne 0x53ceee
movq 0x88(%rsp), %rcx
shlq $0x5, %rcx
vmovdqa (%r15,%rcx), %ymm4
cmpl $0x1e, 0x2c(%rsp)
jg 0x53d1de
movl 0x54(%rsp), %edx
cmpl $0x2, %edx
movl $0x1, %ecx
cmovgel %edx, %ecx
movq 0x40(%rsp), %rbx
movl 0x50(%rsp), %esi
vperm2i128 $0x28, %ymm4, %ymm4, %ymm5 # ymm5 = zero,zero,ymm4[0,1]
vpalignr $0xf, %ymm5, %ymm4, %ymm4 # ymm4 = ymm5[15],ymm4[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm5[31],ymm4[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
decl %ecx
jne 0x53d1cc
jmp 0x53d1e7
movq 0x40(%rsp), %rbx
movl 0x50(%rsp), %esi
vpcmpgtb %ymm3, %ymm0, %ymm0
vpcmpgtb %ymm1, %ymm2, %ymm1
vpor %ymm0, %ymm1, %ymm0
vpmovmskb %ymm0, %ecx
testl %ecx, %ecx
je 0x53d207
orb $0x40, 0xc(%rbx)
xorl %ecx, %ecx
xorl %esi, %esi
xorl %edx, %edx
jmp 0x53d21a
vextracti128 $0x1, %ymm4, %xmm0
vpextrb $0xf, %xmm0, %ecx
movl 0x84(%rsp), %edx
movsbl %cl, %ecx
movl %ecx, (%rbx)
movl %edx, 0x4(%rbx)
movl %esi, 0x8(%rbx)
movq %rax, %rdi
vzeroupper
callq 0x2094b5
movq %r12, %rdi
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
jmp 0x53d282
callq 0x1f2bb3
jmp 0x53d280
callq 0x1f2b8d
jmp 0x53d280
callq 0x1f2b67
jmp 0x53d280
callq 0x1f2b41
jmp 0x53d280
callq 0x1f2b1b
jmp 0x53d280
callq 0x1f2af5
jmp 0x53d280
callq 0x1f2acf
jmp 0x53d280
callq 0x1f2aa9
xorl %ebx, %ebx
movq %rbx, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq