// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_striped_avx2_256_8.c
// Function: parasail_sw_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;
    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 vProfile = NULL;
    __m256i* restrict pvHStore = NULL;
    __m256i* restrict pvHLoad = NULL;
    __m256i* restrict pvHMax = NULL;
    __m256i* restrict pvE = NULL;
    __m256i vGapO;
    __m256i vGapE;
    __m256i vZero;
    int8_t bias = 0;
    int8_t score = 0;
    __m256i vBias;
    __m256i vMaxH;
    __m256i vMaxHUnit;
    int8_t maxp = 0;
    __m256i insert_mask;
    /*int8_t stop = 0;*/
    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;
    end_query = 0;
    end_ref = 0;
    s1Len = profile->s1Len;
    matrix = profile->matrix;
    segWidth = 32; /* 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
    vProfile = (__m256i*)profile->profile8.score;
    vGapO = _mm256_set1_epi8(open);
    vGapE = _mm256_set1_epi8(gap);
    vZero = _mm256_set1_epi8(0);
    bias = INT8_MIN;
    score = bias;
    vBias = _mm256_set1_epi8(bias);
    vMaxH = vBias;
    vMaxHUnit = vBias;
    maxp = INT8_MAX - (int8_t)(matrix->max+1);
    insert_mask = _mm256_cmpgt_epi8(
            _mm256_set_epi8(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1),
            vZero);
    /*stop = profile->stop == INT32_MAX ?  INT8_MAX : (int8_t)profile->stop-bias;*/

    /* 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_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);
    pvHMax = parasail_memalign___m256i(32, segLen);
    pvE = parasail_memalign___m256i(32, segLen);

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

    /* initialize H and E */
    parasail_memset___m256i(pvHStore, vBias, segLen);
    parasail_memset___m256i(pvE, vBias, segLen);

    /* outer loop over database sequence */
    for (j=0; j<s2Len; ++j) {
        __m256i vE;
        __m256i vF;
        __m256i vH;
        const __m256i* vP = NULL;
        __m256i* pv = NULL;

        /* Initialize F value to 0.  Any errors to vH values will be
         * corrected in the Lazy_F loop.  */
        vF = vBias;

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

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

        if (end_ref == j-2) {
            /* Swap in the max buffer. */
            pv = pvHMax;
            pvHMax = pvHLoad;
            pvHLoad = pvHStore;
            pvHStore = pv;
        }
        else {
            /* Swap the 2 H buffers. */
            pv = pvHLoad;
            pvHLoad = pvHStore;
            pvHStore = pv;
        }

        /* 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);
#ifdef PARASAIL_TABLE
            arr_store_si256(result->tables->score_table, vH, i, segLen, j, s2Len, bias);
#endif
            vMaxH = _mm256_max_epi8(vH, vMaxH);

            /* 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) {
            vF = _mm256_slli_si256_rpl(vF, 1);
            vF = _mm256_blendv_epi8(vF, vBias, insert_mask);
            for (i=0; i<segLen; ++i) {
                vH = _mm256_load_si256(pvHStore + i);
                vH = _mm256_max_epi8(vH,vF);
                _mm256_store_si256(pvHStore + i, vH);
#ifdef PARASAIL_TABLE
                arr_store_si256(result->tables->score_table, vH, i, segLen, j, s2Len, bias);
#endif
                vMaxH = _mm256_max_epi8(vH, vMaxH);
                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) - bias;
        }
#endif

        {
            __m256i vCompare = _mm256_cmpgt_epi8(vMaxH, vMaxHUnit);
            if (_mm256_movemask_epi8(vCompare)) {
                score = _mm256_hmax_epi8_rpl(vMaxH);
                /* if score has potential to overflow, abort early */
                if (score > maxp) {
                    result->flag |= PARASAIL_FLAG_SATURATED;
                    break;
                }
                vMaxHUnit = _mm256_set1_epi8(score);
                end_ref = j;
            }
        }

        /*if (score == stop) break;*/
    }

#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, bias);
    }
#endif

    if (score == INT8_MAX) {
        result->flag |= PARASAIL_FLAG_SATURATED;
    }

    if (parasail_result_is_saturated(result)) {
        score = INT8_MAX;
        end_query = 0;
        end_ref = 0;
    }
    else {
        if (end_ref == j-1) {
            /* end_ref was the last store column */
            __m256i *pv = pvHMax;
            pvHMax = pvHStore;
            pvHStore = pv;
        }
        else if (end_ref == j-2) {
            /* end_ref was the last load column */
            __m256i *pv = pvHMax;
            pvHMax = pvHLoad;
            pvHLoad = pv;
        }
        /* Trace the alignment ending position on read. */
        {
            int8_t *t = (int8_t*)pvHMax;
            int32_t column_len = segLen * segWidth;
            end_query = s1Len - 1;
            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;
                    }
                }
            }
        }
    }

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

    parasail_free(pvE);
    parasail_free(pvHMax);
    parasail_free(pvHLoad);
    parasail_free(pvHStore);

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
movq %rsi, 0x30(%rsp)
testq %rdi, %rdi
je 0x53eb51
movq 0x18(%rdi), %rax
movq %rax, 0x48(%rsp)
testq %rax, %rax
je 0x53eb58
movq 0x10(%rdi), %rax
movq %rax, 0x28(%rsp)
testq %rax, %rax
je 0x53eb5f
movl 0x8(%rdi), %eax
testl %eax, %eax
jle 0x53eb66
cmpq $0x0, 0x30(%rsp)
je 0x53eb6d
movl %edx, %r15d
testl %edx, %edx
jle 0x53eb74
movl %ecx, %r13d
testl %ecx, %ecx
js 0x53eb7b
movl %r8d, %r12d
testl %r8d, %r8d
js 0x53eb82
movq %rax, %r14
addq $0x1f, %r14
movq %r14, %rbx
shrq $0x5, %rbx
leal -0x1(%rax), %ebp
movl %ebp, %eax
cltd
idivl %ebx
movl %eax, 0x20(%rsp)
movl %edx, 0x8(%rsp)
movq 0x28(%rsp), %rax
movl 0x1c(%rax), %eax
movl %eax, 0x10(%rsp)
andl $0x7fffffe0, %r14d      # imm = 0x7FFFFFE0
movl %r14d, %edi
movl %r15d, %esi
callq 0x209630
testq %rax, %rax
je 0x53eb87
movl %r13d, 0x120(%rsp)
movl %r12d, 0x70(%rsp)
movq %r14, 0x90(%rsp)
movq %r15, 0x40(%rsp)
movq %rax, 0x38(%rsp)
orl $0x20140804, 0xc(%rax)  # imm = 0x20140804
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4c5e3c
movq %rax, %r13
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4c5e3c
movq %rax, %r15
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4c5e3c
movq %rax, %r14
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4c5e3c
movq %rax, %r12
testq %r13, %r13
sete %al
testq %r15, %r15
sete %cl
orb %al, %cl
movq %r14, 0x50(%rsp)
testq %r14, %r14
sete %al
testq %r12, %r12
sete %dl
orb %al, %dl
orb %cl, %dl
jne 0x53eb87
movl %ebp, 0x5c(%rsp)
movl $0x1f, %ebp
subl 0x20(%rsp), %ebp
vmovd 0x120(%rsp), %xmm0
vpbroadcastb %xmm0, %ymm0
vmovdqu %ymm0, 0x120(%rsp)
vmovd 0x70(%rsp), %xmm0
vpbroadcastb %xmm0, %ymm0
vmovdqu %ymm0, 0x140(%rsp)
vbroadcastsd 0xbb9d1(%rip), %ymm0 # 0x5f9d58
vmovups %ymm0, 0x70(%rsp)
movq %r13, %rdi
movq %rbx, %rsi
callq 0x4c5e45
movq %r12, %rdi
vmovups 0x70(%rsp), %ymm0
movq %rbx, %rsi
callq 0x4c5e45
vmovdqu 0x140(%rsp), %ymm8
vmovdqu 0x120(%rsp), %ymm7
leal -0x1(%rbx), %ecx
movl 0x8(%rsp), %edx
movb $0x7e, %al
subb 0x10(%rsp), %al
cmpl $0x2, %ebp
movl $0x1, %esi
cmovgel %ebp, %esi
movl %esi, 0x70(%rsp)
movsbl %al, %eax
movl %eax, 0x8(%rsp)
movl 0x40(%rsp), %eax
movq %rax, 0x10(%rsp)
movq %rbx, 0x68(%rsp)
movl %ebx, %r8d
movq %r8, %rsi
shlq $0x5, %r8
movb $-0x80, %al
movl %eax, 0x1c(%rsp)
vpbroadcastb 0xbcb33(%rip), %ymm0 # 0x5faf38
shlq $0x5, %rcx
movl $0x80, %r9d
shlq $0x5, %rdx
xorl %r10d, %r10d
vmovdqa %ymm0, %ymm2
vmovdqa %ymm0, %ymm1
xorl %ebp, %ebp
movq %r13, %r14
movq 0x28(%rsp), %rax
movq 0x10(%rax), %r11
movq 0x30(%rsp), %rax
movzbl (%rax,%r10), %ebx
movslq (%r11,%rbx,4), %rbx
movq %rsi, %r11
imulq %rbx, %r11
shlq $0x5, %r11
addq 0x48(%rsp), %r11
leal -0x2(%r10), %ebx
movq %rbp, %rax
cmpl %ebx, %ebp
movq %r15, %r13
movq 0x50(%rsp), %rdi
cmoveq %rdi, %r13
cmoveq %r15, %rdi
movq %rdi, 0x50(%rsp)
vmovdqa (%r14,%rcx), %ymm3
vinserti128 $0x1, %xmm3, %ymm0, %ymm4
vpalignr $0xf, %ymm4, %ymm3, %ymm3 # ymm3 = ymm4[15],ymm3[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm4[31],ymm3[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpinsrb $0x0, %r9d, %xmm3, %xmm4
vpblendd $0xf, %ymm4, %ymm3, %ymm4 # ymm4 = ymm4[0,1,2,3],ymm3[4,5,6,7]
xorl %ebx, %ebx
vmovdqa %ymm0, %ymm3
vpaddsb (%r11,%rbx), %ymm4, %ymm4
vmovdqa (%r12,%rbx), %ymm5
vpmaxsb %ymm3, %ymm5, %ymm6
vpmaxsb %ymm6, %ymm4, %ymm4
vmovdqa %ymm4, (%r13,%rbx)
vpmaxsb %ymm1, %ymm4, %ymm1
vpsubsb %ymm7, %ymm4, %ymm4
vpsubsb %ymm8, %ymm5, %ymm5
vpmaxsb %ymm4, %ymm5, %ymm5
vmovdqa %ymm5, (%r12,%rbx)
vpsubsb %ymm8, %ymm3, %ymm3
vpmaxsb %ymm4, %ymm3, %ymm3
vmovdqa (%r14,%rbx), %ymm4
addq $0x20, %rbx
cmpq %rbx, %r8
jne 0x53e48c
xorl %r11d, %r11d
movq 0x38(%rsp), %rdi
vinserti128 $0x1, %xmm3, %ymm0, %ymm4
vpalignr $0xf, %ymm4, %ymm3, %ymm3 # ymm3 = ymm4[15],ymm3[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm4[31],ymm3[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpinsrb $0x0, %r9d, %xmm3, %xmm4
vpblendd $0xf, %ymm4, %ymm3, %ymm3 # ymm3 = ymm4[0,1,2,3],ymm3[4,5,6,7]
xorl %ebx, %ebx
vpmaxsb (%r13,%rbx), %ymm3, %ymm4
vmovdqa %ymm4, (%r13,%rbx)
vpmaxsb %ymm1, %ymm4, %ymm1
vpsubsb %ymm7, %ymm4, %ymm4
vpsubsb %ymm8, %ymm3, %ymm3
vpcmpgtb %ymm4, %ymm3, %ymm4
vpmovmskb %ymm4, %ebp
testl %ebp, %ebp
je 0x53e537
addq $0x20, %rbx
cmpq %rbx, %r8
jne 0x53e4fd
incl %r11d
cmpl $0x20, %r11d
jne 0x53e4e3
movq %rax, %rbp
vmovdqa (%r13,%rdx), %ymm3
cmpl $0x1e, 0x20(%rsp)
jg 0x53e55e
movl 0x70(%rsp), %r11d
vperm2i128 $0x28, %ymm3, %ymm3, %ymm4 # ymm4 = zero,zero,ymm3[0,1]
vpalignr $0xf, %ymm4, %ymm3, %ymm3 # ymm3 = ymm4[15],ymm3[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm4[31],ymm3[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
decl %r11d
jne 0x53e54d
vextracti128 $0x1, %ymm3, %xmm3
vpextrb $0xf, %xmm3, %r11d
movsbl %r11b, %r11d
subl $-0x80, %r11d
movq 0x10(%rdi), %rbx
movq (%rbx), %rbx
movl %r11d, (%rbx,%r10,4)
vpcmpgtb %ymm2, %ymm1, %ymm3
vpmovmskb %ymm3, %ebx
movb $0x1, %r11b
testl %ebx, %ebx
je 0x53e5f8
vpermq $0x44, %ymm1, %ymm3     # ymm3 = ymm1[0,1,0,1]
vpmaxsb %ymm3, %ymm1, %ymm3
vpslldq $0x8, %ymm3, %ymm4      # ymm4 = zero,zero,zero,zero,zero,zero,zero,zero,ymm3[0,1,2,3,4,5,6,7],zero,zero,zero,zero,zero,zero,zero,zero,ymm3[16,17,18,19,20,21,22,23]
vpmaxsb %ymm4, %ymm3, %ymm3
vpslldq $0x4, %ymm3, %ymm4      # ymm4 = zero,zero,zero,zero,ymm3[0,1,2,3,4,5,6,7,8,9,10,11],zero,zero,zero,zero,ymm3[16,17,18,19,20,21,22,23,24,25,26,27]
vpmaxsb %ymm4, %ymm3, %ymm3
vpslldq $0x2, %ymm3, %ymm4      # ymm4 = zero,zero,ymm3[0,1,2,3,4,5,6,7,8,9,10,11,12,13],zero,zero,ymm3[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
vpmaxsb %ymm4, %ymm3, %ymm3
vpslldq $0x1, %ymm3, %ymm4      # ymm4 = zero,ymm3[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],zero,ymm3[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpmaxsb %ymm4, %ymm3, %ymm3
vextracti128 $0x1, %ymm3, %xmm4
vpextrb $0xf, %xmm4, %eax
movl %eax, 0x1c(%rsp)
movsbl %al, %ebx
cmpl %ebx, 0x8(%rsp)
jge 0x53e5e1
orb $0x40, 0xc(%rdi)
xorl %r11d, %r11d
jmp 0x53e5f8
vpbroadcastb 0xbc94f(%rip), %ymm2 # 0x5faf39
vpshufb %ymm2, %ymm3, %ymm2
vpermq $0xaa, %ymm2, %ymm2     # ymm2 = ymm2[2,2,2,2]
movl %r10d, %ebp
testb %r11b, %r11b
je 0x53e61a
incq %r10
movq %r14, %r15
cmpq 0x10(%rsp), %r10
jne 0x53e420
movq %rbp, 0x60(%rsp)
movq 0x38(%rsp), %rdi
jmp 0x53e624
movq %rbp, 0x60(%rsp)
movq %r10, 0x40(%rsp)
movq 0x68(%rsp), %rcx
movl %ecx, %r10d
shll $0x4, %r10d
leaq (%rsi,%rsi,8), %rax
leaq (%rax,%rax,2), %rax
addq %rsi, %rax
movq %rax, 0x30(%rsp)
cmpl $0x1, %ecx
movl %ecx, %eax
adcl $0x0, %eax
imulq $0x7c, %rsi, %rdx
movq %rdx, 0x48(%rsp)
imulq $0x78, %rsi, %rdx
movq %rdx, 0x20(%rsp)
imulq $0x74, %rsi, %rdx
movq %rdx, 0x10(%rsp)
imulq $0x70, %rsi, %rdx
movq %rdx, 0x8(%rsp)
imulq $0x6c, %rsi, %rdx
movq %rdx, 0x70(%rsp)
imulq $0x68, %rsi, %rdx
movq %rdx, 0x120(%rsp)
imulq $0x64, %rsi, %rdx
movq %rdx, 0x140(%rsp)
movq %rsi, %r9
shlq $0x5, %r9
imulq $0x5c, %rsi, %rdx
movq %rdx, 0x110(%rsp)
imulq $0x58, %rsi, %rdx
movq %rdx, 0x108(%rsp)
movq %rsi, %r8
shlq $0x6, %r8
imulq $0x54, %rsi, %rdx
movq %rdx, 0x100(%rsp)
imulq $0x4c, %rsi, %rdx
movq %rdx, 0xf8(%rsp)
imulq $0x3c, %rsi, %rdx
movq %rdx, 0xf0(%rsp)
imulq $0x38, %rsi, %rdx
movq %rdx, 0xe8(%rsp)
imulq $0x34, %rsi, %rdx
movq %rdx, 0xe0(%rsp)
imulq $0x2c, %rsi, %rdx
movq %rdx, 0xd8(%rsp)
shll $0x2, %eax
movq %rax, 0x28(%rsp)
leal (,%rcx,4), %ebx
leal (,%rcx,8), %edx
leaq (%rbx,%rbx,2), %rax
movq %rax, 0xd0(%rsp)
leaq (%rbx,%rbx,4), %rax
movq %rax, 0xc8(%rsp)
leaq (%rdx,%rdx,2), %rax
movq %rax, 0xc0(%rsp)
movq %r9, 0x118(%rsp)
leaq (%r9,%r9,2), %rax
movq %rax, 0xb8(%rsp)
leaq (%r10,%r10,4), %rax
movq %rax, 0xb0(%rsp)
leaq (%rdx,%rdx,8), %rax
movq %rax, 0xa8(%rsp)
leaq (%r8,%rbx), %rax
movq %rax, 0xa0(%rsp)
movq %r10, %r9
leaq (%r10,%r10,2), %rax
movq %rax, 0x98(%rsp)
leaq (%rdx,%rdx,4), %rsi
leaq (%rbx,%rbx,8), %rax
xorl %r10d, %r10d
movl $0x80, %r11d
movq 0x10(%rdi), %rcx
movq 0x8(%rcx), %rcx
vmovdqa (%r13,%r10,8), %xmm1
vmovdqa 0x10(%r13,%r10,8), %xmm0
vmovd %xmm1, %r15d
movsbl %r15b, %r15d
addl %r11d, %r15d
movl %r15d, (%rcx,%r10)
addq %r10, %rcx
vpextrb $0x1, %xmm1, %r15d
movsbl %r15b, %r15d
addl %r11d, %r15d
movl %r15d, (%rbx,%rcx)
vpextrb $0x2, %xmm1, %r15d
movsbl %r15b, %r15d
addl %r11d, %r15d
movl %r15d, (%rdx,%rcx)
vpextrb $0x3, %xmm1, %r15d
movsbl %r15b, %r15d
addl %r11d, %r15d
vpextrb $0x4, %xmm1, %ebp
movq 0xd0(%rsp), %rdi
movl %r15d, (%rdi,%rcx)
movsbl %bpl, %ebp
addl %r11d, %ebp
movl %ebp, (%r9,%rcx)
vpextrb $0x5, %xmm1, %ebp
movsbl %bpl, %ebp
addl %r11d, %ebp
movq 0xc8(%rsp), %rdi
movl %ebp, (%rdi,%rcx)
vpextrb $0x6, %xmm1, %ebp
movsbl %bpl, %ebp
addl %r11d, %ebp
movq 0xc0(%rsp), %rdi
movl %ebp, (%rdi,%rcx)
vpextrb $0x7, %xmm1, %ebp
movsbl %bpl, %ebp
addl %r11d, %ebp
vpextrb $0x8, %xmm1, %r15d
movq 0x30(%rsp), %rdi
movl %ebp, (%rdi,%rcx)
movsbl %r15b, %ebp
addl %r11d, %ebp
movq 0x118(%rsp), %rdi
movl %ebp, (%rdi,%rcx)
vpextrb $0x9, %xmm1, %ebp
movsbl %bpl, %ebp
addl %r11d, %ebp
movl %ebp, (%rax,%rcx)
vpextrb $0xa, %xmm1, %ebp
movsbl %bpl, %ebp
addl %r11d, %ebp
movl %ebp, (%rsi,%rcx)
vpextrb $0xb, %xmm1, %ebp
movsbl %bpl, %ebp
addl %r11d, %ebp
vpextrb $0xc, %xmm1, %r15d
movq 0xd8(%rsp), %rdi
movl %ebp, (%rdi,%rcx)
movsbl %r15b, %ebp
addl %r11d, %ebp
movq 0x98(%rsp), %rdi
movl %ebp, (%rdi,%rcx)
vpextrb $0xd, %xmm1, %ebp
movsbl %bpl, %ebp
addl %r11d, %ebp
movq 0xe0(%rsp), %rdi
movl %ebp, (%rdi,%rcx)
vpextrb $0xe, %xmm1, %ebp
movsbl %bpl, %ebp
addl %r11d, %ebp
movq 0xe8(%rsp), %rdi
movl %ebp, (%rdi,%rcx)
vpextrb $0xf, %xmm1, %ebp
movsbl %bpl, %ebp
addl %r11d, %ebp
movq 0xf0(%rsp), %rdi
movl %ebp, (%rdi,%rcx)
vmovd %xmm0, %ebp
movsbl %bpl, %ebp
addl %r11d, %ebp
vpextrb $0x1, %xmm0, %r15d
movl %ebp, (%r8,%rcx)
movsbl %r15b, %ebp
addl %r11d, %ebp
movq 0xa0(%rsp), %rdi
movl %ebp, (%rdi,%rcx)
vpextrb $0x2, %xmm0, %ebp
movsbl %bpl, %ebp
addl %r11d, %ebp
movq 0xa8(%rsp), %rdi
movl %ebp, (%rdi,%rcx)
vpextrb $0x3, %xmm0, %ebp
movsbl %bpl, %ebp
addl %r11d, %ebp
movq 0xf8(%rsp), %rdi
movl %ebp, (%rdi,%rcx)
vpextrb $0x4, %xmm0, %ebp
movsbl %bpl, %ebp
addl %r11d, %ebp
vpextrb $0x5, %xmm0, %r15d
movq 0xb0(%rsp), %rdi
movl %ebp, (%rdi,%rcx)
movsbl %r15b, %ebp
addl %r11d, %ebp
movq 0x100(%rsp), %rdi
movl %ebp, (%rdi,%rcx)
vpextrb $0x6, %xmm0, %ebp
movsbl %bpl, %ebp
addl %r11d, %ebp
movq 0x108(%rsp), %rdi
movl %ebp, (%rdi,%rcx)
vpextrb $0x7, %xmm0, %ebp
movsbl %bpl, %ebp
addl %r11d, %ebp
movq 0x110(%rsp), %rdi
movl %ebp, (%rdi,%rcx)
vpextrb $0x8, %xmm0, %ebp
movsbl %bpl, %ebp
addl %r11d, %ebp
vpextrb $0x9, %xmm0, %r15d
movq 0xb8(%rsp), %rdi
movl %ebp, (%rdi,%rcx)
movsbl %r15b, %ebp
addl %r11d, %ebp
movq 0x140(%rsp), %rdi
movl %ebp, (%rdi,%rcx)
vpextrb $0xa, %xmm0, %ebp
movsbl %bpl, %ebp
addl %r11d, %ebp
movq 0x120(%rsp), %rdi
movl %ebp, (%rdi,%rcx)
vpextrb $0xb, %xmm0, %ebp
movsbl %bpl, %ebp
addl %r11d, %ebp
movq 0x70(%rsp), %rdi
movl %ebp, (%rdi,%rcx)
vpextrb $0xc, %xmm0, %ebp
movsbl %bpl, %ebp
addl %r11d, %ebp
vpextrb $0xd, %xmm0, %r15d
movq 0x8(%rsp), %rdi
movl %ebp, (%rdi,%rcx)
movsbl %r15b, %ebp
movq 0x38(%rsp), %rdi
addl %r11d, %ebp
movq 0x10(%rsp), %r15
movl %ebp, (%r15,%rcx)
vpextrb $0xe, %xmm0, %ebp
movsbl %bpl, %ebp
addl %r11d, %ebp
movq 0x20(%rsp), %r15
movl %ebp, (%r15,%rcx)
vpextrb $0xf, %xmm0, %ebp
movsbl %bpl, %ebp
addl %r11d, %ebp
movq 0x48(%rsp), %r15
movl %ebp, (%r15,%rcx)
addq $0x4, %r10
cmpq %r10, 0x28(%rsp)
jne 0x53e78d
movl 0x1c(%rsp), %ebx
cmpb $0x7f, %bl
jne 0x53ea83
orb $0x40, 0xc(%rdi)
vzeroupper
callq 0x20a805
testl %eax, %eax
movl 0x5c(%rsp), %edi
movq 0x50(%rsp), %r9
movq 0x60(%rsp), %r10
je 0x53eaaf
xorl %r10d, %r10d
movl $0xff, %eax
movq %r14, %rbp
movq %r9, %r15
xorl %edi, %edi
jmp 0x53eb21
movq 0x40(%rsp), %rcx
leal -0x1(%rcx), %eax
addl $-0x2, %ecx
cmpl %ecx, %r10d
movq %r14, %rbp
cmoveq %r9, %rbp
movq %r9, %r15
cmoveq %r14, %r15
cmpl %eax, %r10d
cmovneq %r13, %r9
cmoveq %r14, %rbp
cmoveq %r13, %r15
cmpl $0x0, 0x90(%rsp)
je 0x53eb18
movq 0x68(%rsp), %r8
movl %r8d, %eax
andl $0x3ffffff, %eax        # imm = 0x3FFFFFF
shll $0x5, %eax
xorl %ecx, %ecx
cmpb %bl, (%r15,%rcx)
jne 0x53eb11
movl %ecx, %edx
shrl $0x5, %edx
movl %ecx, %esi
andl $0x1f, %esi
imull %r8d, %esi
addl %edx, %esi
cmpl %edi, %esi
cmovll %esi, %edi
incq %rcx
cmpl %ecx, %eax
jne 0x53eaf6
movsbl %bl, %eax
subl $-0x80, %eax
movq %r9, %r13
movq 0x38(%rsp), %rbx
movl %eax, (%rbx)
movl %edi, 0x4(%rbx)
movl %r10d, 0x8(%rbx)
movq %r12, %rdi
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
movq %rbp, %rdi
callq 0x2094b5
movq %r13, %rdi
callq 0x2094b5
jmp 0x53eb89
callq 0x1f3027
jmp 0x53eb87
callq 0x1f3001
jmp 0x53eb87
callq 0x1f2fdb
jmp 0x53eb87
callq 0x1f2fb5
jmp 0x53eb87
callq 0x1f2f8f
jmp 0x53eb87
callq 0x1f2f69
jmp 0x53eb87
callq 0x1f2f43
jmp 0x53eb87
callq 0x1f2f1d
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop