// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_scan_avx2_256_8.c
// Function: parasail_nw_table_scan_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 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 pvP = NULL;
    __m256i* restrict pvE = NULL;
    int8_t* restrict boundary = NULL;
    __m256i* restrict pvHt = NULL;
    __m256i* restrict pvH = NULL;
    __m256i* restrict pvGapper = NULL;
    __m256i vGapO;
    __m256i vGapE;
    int8_t NEG_LIMIT = 0;
    int8_t POS_LIMIT = 0;
    __m256i vZero;
    int8_t score = 0;
    __m256i vNegLimit;
    __m256i vPosLimit;
    __m256i vSaturationCheckMin;
    __m256i vSaturationCheckMax;
    __m256i vNegInfFront;
    __m256i vSegLenXgap;
    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;
    pvP = (__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;
    vZero = _mm256_setzero_si256();
    score = NEG_LIMIT;
    vNegLimit = _mm256_set1_epi8(NEG_LIMIT);
    vPosLimit = _mm256_set1_epi8(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    vNegInfFront = vZero;
    vNegInfFront = _mm256_insert_epi8_rpl(vNegInfFront, NEG_LIMIT, 0);
    vSegLenXgap = _mm256_adds_epi8(vNegInfFront,
            _mm256_slli_si256_rpl(_mm256_set1_epi8(-segLen*gap), 1));

    /* 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_SCAN
        | 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 */
    pvE = parasail_memalign___m256i(32, segLen);
    boundary = parasail_memalign_int8_t(32, s2Len+1);
    pvHt= parasail_memalign___m256i(32, segLen);
    pvH = parasail_memalign___m256i(32, segLen);
    pvGapper = parasail_memalign___m256i(32, segLen);

    /* validate heap variables */
    if (!pvE) return NULL;
    if (!boundary) return NULL;
    if (!pvHt) return NULL;
    if (!pvH) return NULL;
    if (!pvGapper) 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(&pvH[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;
        }
    }

    {
        __m256i vGapper = _mm256_subs_epi8(vZero,vGapO);
        for (i=segLen-1; i>=0; --i) {
            _mm256_store_si256(pvGapper+i, vGapper);
            vGapper = _mm256_subs_epi8(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, 1);
        vHp = _mm256_insert_epi8_rpl(vHp, boundary[j], 0);
        pvW = pvP + matrix->mapper[(unsigned char)s2[j]]*segLen;
        vHt = _mm256_subs_epi8(vNegLimit, pvGapper[0]);
        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_epi8(
                    _mm256_subs_epi8(vE, vGapE),
                    _mm256_subs_epi8(vH, vGapO));
            vHp = _mm256_adds_epi8(vHp, vW);
            vF = _mm256_max_epi8(vF, _mm256_adds_epi8(vHt, pvGapper[i]));
            vHt = _mm256_max_epi8(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, 1);
        vHt = _mm256_insert_epi8_rpl(vHt, boundary[j+1], 0);
        vF = _mm256_max_epi8(vF, _mm256_adds_epi8(vHt, pvGapper[0]));
        for (i=0; i<segWidth-2; ++i) {
            __m256i vFt = _mm256_slli_si256_rpl(vF, 1);
            vFt = _mm256_adds_epi8(vFt, vSegLenXgap);
            vF = _mm256_max_epi8(vF, vFt);
        }

        /* calculate final H */
        vF = _mm256_slli_si256_rpl(vF, 1);
        vF = _mm256_adds_epi8(vF, vNegInfFront);
        vH = _mm256_max_epi8(vHt, vF);
        for (i=0; i<segLen; ++i) {
            vHt = _mm256_load_si256(pvHt+i);
            vF = _mm256_max_epi8(
                    _mm256_subs_epi8(vF, vGapE),
                    _mm256_subs_epi8(vH, vGapO));
            vH = _mm256_max_epi8(vHt, vF);
            _mm256_store_si256(pvH+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
        } 


#ifdef PARASAIL_ROWCOL
        /* extract last value from the column */
        {
            vH = _mm256_load_si256(pvH + 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(pvH+i);
        arr_store_col(result->rowcols->score_col, vH, i, segLen);
    }
#endif

    /* extract last value from the last column */
    {
        __m256i vH = _mm256_load_si256(pvH + 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(pvGapper);
    parasail_free(pvH);
    parasail_free(pvHt);
    parasail_free(boundary);
    parasail_free(pvE);

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0x200, %rsp            # imm = 0x200
movq %rsi, 0x90(%rsp)
testq %rdi, %rdi
je 0x4cddb4
movq 0x18(%rdi), %rax
movq %rax, 0xf0(%rsp)
testq %rax, %rax
je 0x4cddbb
movq 0x10(%rdi), %rax
movq %rax, 0x88(%rsp)
testq %rax, %rax
je 0x4cddc2
movl 0x8(%rdi), %edi
testl %edi, %edi
jle 0x4cddc9
cmpq $0x0, 0x90(%rsp)
je 0x4cddd0
movl %edx, %r9d
testl %edx, %edx
jle 0x4cddd7
testl %ecx, %ecx
js 0x4cddde
testl %r8d, %r8d
js 0x4cdde5
movl %r8d, 0x60(%rsp)
leal -0x1(%rdi), %r14d
addq $0x1f, %rdi
movq %rdi, %r15
shrq $0x5, %r15
movl %r14d, %eax
cltd
idivl %r15d
movl %eax, %r12d
movl %edx, %r13d
movq 0x88(%rsp), %rdx
movl 0x20(%rdx), %eax
movl %eax, %esi
negb %sil
movzbl %sil, %esi
movl %ecx, %ebx
negl %ebx
cmpl %ebx, %eax
movl %ecx, 0x58(%rsp)
cmovgl %ecx, %esi
movl %esi, 0x50(%rsp)
movb $0x7e, %al
subb 0x1c(%rdx), %al
movl %eax, 0x48(%rsp)
andl $0x7fffffe0, %edi       # imm = 0x7FFFFFE0
movl %r9d, %esi
movq %r9, 0x18(%rsp)
callq 0x20959f
testq %rax, %rax
je 0x4cddea
movl %r13d, 0x7c(%rsp)
movl %r12d, 0x24(%rsp)
movl %r14d, 0x78(%rsp)
movq %rax, 0x30(%rsp)
orl $0x20120401, 0xc(%rax)  # imm = 0x20120401
movl $0x20, %edi
movq %r15, %rsi
callq 0x4c5e3c
movq %rax, %r12
movq 0x18(%rsp), %rax
leal 0x1(%rax), %esi
movl $0x20, %edi
callq 0x2094c8
movq %rax, 0x28(%rsp)
movl $0x20, %edi
movq %r15, %rsi
callq 0x4c5e3c
movq %rax, %r14
movl $0x20, %edi
movq %r15, %rsi
callq 0x4c5e3c
movq %rax, %r13
movl $0x20, %edi
movq %r15, %rsi
callq 0x4c5e3c
movq 0x28(%rsp), %rcx
movq %r12, 0x40(%rsp)
testq %r12, %r12
sete %dl
testq %rcx, %rcx
sete %cl
orb %dl, %cl
movq %r14, 0x68(%rsp)
testq %r14, %r14
sete %dil
testq %r13, %r13
sete %dl
orb %dil, %dl
orb %cl, %dl
testq %rax, %rax
sete %cl
orb %dl, %cl
jne 0x4cddea
movq %rax, 0x80(%rsp)
movq 0x18(%rsp), %rax
movq %rax, %r14
decl %eax
movl %eax, 0x20(%rsp)
movl $0x1f, %eax
subl 0x24(%rsp), %eax
movl %eax, 0x74(%rsp)
movl 0x58(%rsp), %ecx
vmovd %ecx, %xmm0
vpbroadcastb %xmm0, %ymm2
movl 0x60(%rsp), %r12d
vmovd %r12d, %xmm0
vpbroadcastb %xmm0, %ymm3
movl 0x50(%rsp), %eax
addb $-0x7f, %al
vmovd %eax, %xmm0
vpbroadcastb %xmm0, %ymm0
vmovd 0x48(%rsp), %xmm1
vpbroadcastb %xmm1, %ymm1
movzbl %al, %eax
vmovd %eax, %xmm4
movl %r15d, %eax
imull %r12d, %eax
negb %al
vmovd %eax, %xmm5
vpbroadcastb %xmm5, %ymm5
vpand 0x12c308(%rip), %ymm5, %ymm5 # 0x5f98c0
vpaddsb %ymm5, %ymm4, %ymm5
movl %ecx, %eax
movl %r12d, %ecx
movslq %ebx, %rdx
movl %r15d, %esi
negq %rax
movq %rsi, 0x38(%rsp)
imulq %rcx, %rsi
xorl %edi, %edi
movq $-0x80, %r8
movq %rdx, %r9
xorl %r10d, %r10d
cmpq $-0x7f, %r9
movq $-0x80, %r11
cmovgeq %r9, %r11
movb %r11b, 0x1c0(%rsp,%r10)
leaq (%rax,%r9), %r11
cmpq $-0x7f, %r11
cmovlq %r8, %r11
movb %r11b, 0x1a0(%rsp,%r10)
incq %r10
subq %rsi, %r9
cmpq $0x20, %r10
jne 0x4cd5e2
movq %rdi, %r9
shlq $0x5, %r9
vmovaps 0x1c0(%rsp), %ymm6
vmovaps %ymm6, (%r13,%r9)
vmovdqa 0x1a0(%rsp), %ymm6
movq 0x40(%rsp), %r10
vmovdqa %ymm6, (%r10,%r9)
incq %rdi
subq %rcx, %rdx
cmpq 0x38(%rsp), %rdi
jne 0x4cd5dc
movq 0x28(%rsp), %r8
movb $0x0, (%r8)
cmpl $0x2, %r14d
movl $0x1, %eax
cmovgel %r14d, %eax
xorl %ecx, %ecx
cmpl $-0x7f, %ebx
movl $0xffffff80, %edx       # imm = 0xFFFFFF80
cmovgel %ebx, %edx
movb %dl, 0x1(%r8,%rcx)
subl %r12d, %ebx
incq %rcx
cmpq %rcx, %rax
jne 0x4cd669
leal -0x1(%r15), %eax
vpxor %xmm6, %xmm6, %xmm6
vpsubsb %ymm2, %ymm6, %ymm6
movq %rax, %rdx
shlq $0x5, %rdx
movq 0x80(%rsp), %rdi
movq %rdi, %rcx
addq %rdx, %rcx
movl %r15d, %edx
vmovdqa %ymm6, (%rcx)
vpsubsb %ymm3, %ymm6, %ymm6
addq $-0x20, %rcx
decl %edx
jg 0x4cd6a8
movl %eax, %eax
shlq $0x5, %rax
movq %r13, %rcx
addq %rax, %rcx
movq %rcx, 0xe8(%rsp)
movl %r14d, %r9d
cmpl $0x1, %r15d
adcl $0x0, %r15d
cmpl $0x2, %r14d
movl $0x1, %eax
cmovgel %r14d, %eax
movq %rax, 0xe0(%rsp)
shlq $0x5, %r15
movq 0x38(%rsp), %rax
imulq %r9, %rax
leaq (,%rax,4), %rdx
shlq $0x2, %r9
leaq (,%rax,8), %r12
leaq (%rax,%rax,8), %rcx
leaq (%rcx,%rcx,2), %rcx
addq %rax, %rcx
movq %rcx, 0x60(%rsp)
movq %rax, %rsi
imulq $0x2c, %rax, %r10
imulq $0x34, %rax, %r14
imulq $0x38, %rax, %rcx
movq %rcx, 0x58(%rsp)
imulq $0x3c, %rax, %rcx
movq %rcx, 0x50(%rsp)
movq %rax, %rcx
shlq $0x6, %rcx
movq %rcx, 0x48(%rsp)
leaq (%rcx,%rax,4), %rcx
movq %rcx, 0x198(%rsp)
imulq $0x4c, %rax, %rcx
movq %rcx, 0x190(%rsp)
imulq $0x54, %rax, %rcx
movq %rcx, 0x188(%rsp)
imulq $0x58, %rax, %rcx
movq %rcx, 0x180(%rsp)
imulq $0x5c, %rax, %rcx
movq %rcx, 0x178(%rsp)
imulq $0x64, %rax, %rcx
movq %rcx, 0x170(%rsp)
imulq $0x68, %rax, %rcx
movq %rcx, 0x168(%rsp)
imulq $0x6c, %rax, %rcx
movq %rcx, 0x160(%rsp)
imulq $0x70, %rax, %rcx
movq %rcx, 0x158(%rsp)
imulq $0x74, %rax, %rcx
movq %rcx, 0x150(%rsp)
imulq $0x78, %rax, %rcx
movq %rcx, 0x148(%rsp)
imulq $0x7c, %rax, %rcx
movq %rcx, 0x140(%rsp)
shlq $0x4, %rax
shlq $0x5, %rsi
vmovdqa %ymm0, %ymm6
vmovdqa %ymm1, %ymm7
leaq (%rdx,%rdx,2), %rcx
movq %rcx, 0x130(%rsp)
leaq (%rdx,%rdx,4), %rcx
movq %rcx, 0x128(%rsp)
leaq (%r12,%r12,2), %rcx
movq %rcx, 0xd8(%rsp)
leaq (%rdx,%rdx,8), %rcx
movq %rcx, 0xd0(%rsp)
leaq (%r12,%r12,4), %rcx
movq %rcx, 0xc8(%rsp)
leaq (%rax,%rax,2), %rcx
movq %rcx, 0xc0(%rsp)
leaq (%r12,%r12,8), %rcx
movq %rcx, 0xb8(%rsp)
movq %rax, 0x138(%rsp)
leaq (%rax,%rax,4), %rax
movq %rax, 0xb0(%rsp)
leaq (%rsi,%rsi,2), %rax
movq %rax, 0xa8(%rsp)
movq $0x0, 0x98(%rsp)
xorl %eax, %eax
movq 0x40(%rsp), %rbx
movq %r13, 0xa0(%rsp)
movq %r12, 0x120(%rsp)
movq %rdx, 0x118(%rsp)
movq %r10, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movq %r15, 0x18(%rsp)
movq %r14, 0x100(%rsp)
movq 0xd0(%rsp), %r12
movq 0xc8(%rsp), %rsi
movq 0xb8(%rsp), %r10
movq 0x88(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x90(%rsp), %rdx
movzbl (%rdx,%rax), %edx
movslq (%rcx,%rdx,4), %rdx
movq 0x38(%rsp), %rcx
imulq %rdx, %rcx
shlq $0x5, %rcx
vpsubsb (%rdi), %ymm0, %ymm8
addq 0xf0(%rsp), %rcx
movq 0xe8(%rsp), %rdx
vmovdqa (%rdx), %ymm9
vinserti128 $0x1, %xmm9, %ymm0, %ymm10
vpalignr $0xf, %ymm10, %ymm9, %ymm9 # ymm9 = ymm10[15],ymm9[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm10[31],ymm9[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
movq %r8, %rdx
movq %rax, %r8
movq %rdx, %r11
vpinsrb $0x0, (%rdx,%rax), %xmm9, %xmm10
vpblendd $0xf, %ymm10, %ymm9, %ymm10 # ymm10 = ymm10[0,1,2,3],ymm9[4,5,6,7]
xorl %edx, %edx
vmovdqa %ymm0, %ymm9
movq 0x68(%rsp), %rax
vpaddsb (%rcx,%rdx), %ymm10, %ymm10
vmovdqa (%r13,%rdx), %ymm11
vmovdqa (%rbx,%rdx), %ymm12
vpsubsb %ymm3, %ymm12, %ymm12
vpsubsb %ymm2, %ymm11, %ymm13
vpmaxsb %ymm13, %ymm12, %ymm12
vpaddsb (%rdi,%rdx), %ymm8, %ymm8
vpmaxsb %ymm8, %ymm9, %ymm9
vpmaxsb %ymm10, %ymm12, %ymm8
vmovdqa %ymm12, (%rbx,%rdx)
vmovdqa %ymm8, (%rax,%rdx)
addq $0x20, %rdx
vmovdqa %ymm11, %ymm10
cmpq %rdx, %r15
jne 0x4cd928
vinserti128 $0x1, %xmm8, %ymm0, %ymm10
vpalignr $0xf, %ymm10, %ymm8, %ymm8 # ymm8 = ymm10[15],ymm8[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm10[31],ymm8[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpinsrb $0x0, 0x1(%r11,%r8), %xmm8, %xmm10
incq %r8
movq %r8, 0xf8(%rsp)
vpblendd $0xf, %ymm10, %ymm8, %ymm10 # ymm10 = ymm10[0,1,2,3],ymm8[4,5,6,7]
vpaddsb (%rdi), %ymm10, %ymm8
vpmaxsb %ymm8, %ymm9, %ymm8
movl $0x1e, %ecx
vperm2i128 $0x28, %ymm8, %ymm8, %ymm9 # ymm9 = zero,zero,ymm8[0,1]
vpalignr $0xf, %ymm9, %ymm8, %ymm9 # ymm9 = ymm9[15],ymm8[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm9[31],ymm8[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpaddsb %ymm5, %ymm9, %ymm9
vpmaxsb %ymm9, %ymm8, %ymm8
decl %ecx
jne 0x4cd9a0
vperm2i128 $0x28, %ymm8, %ymm8, %ymm9 # ymm9 = zero,zero,ymm8[0,1]
vpalignr $0xf, %ymm9, %ymm8, %ymm8 # ymm8 = ymm9[15],ymm8[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm9[31],ymm8[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpaddsb %ymm4, %ymm8, %ymm8
vpmaxsb %ymm8, %ymm10, %ymm9
movq 0x98(%rsp), %r11
xorl %ecx, %ecx
movq 0xd8(%rsp), %r8
movq 0xc0(%rsp), %r13
movq 0xb0(%rsp), %r15
movq 0xa8(%rsp), %rax
vpsubsb %ymm3, %ymm8, %ymm8
vpsubsb %ymm2, %ymm9, %ymm9
vpmaxsb %ymm9, %ymm8, %ymm8
movq 0x68(%rsp), %rdx
vpmaxsb (%rdx,%rcx), %ymm8, %ymm9
movq 0xa0(%rsp), %rdx
vmovdqa %ymm9, (%rdx,%rcx)
movq 0x30(%rsp), %rdx
movq 0x10(%rdx), %rdi
movq (%rdi), %rdi
vmovd %xmm9, %edx
movsbl %dl, %edx
movl %edx, (%rdi,%r11)
vpextrb $0x1, %xmm9, %edx
addq %r11, %rdi
movsbl %dl, %edx
movq %r9, %rbx
vpextrb $0x2, %xmm9, %r9d
movq 0x118(%rsp), %r14
movl %edx, (%r14,%rdi)
movsbl %r9b, %edx
vpextrb $0x3, %xmm9, %r9d
movq 0x120(%rsp), %r14
movl %edx, (%r14,%rdi)
movsbl %r9b, %edx
vpextrb $0x4, %xmm9, %r9d
movq 0x130(%rsp), %r14
movl %edx, (%r14,%rdi)
movsbl %r9b, %edx
vpextrb $0x5, %xmm9, %r9d
movq 0x138(%rsp), %r14
movl %edx, (%r14,%rdi)
movsbl %r9b, %edx
vpextrb $0x6, %xmm9, %r9d
movq 0x128(%rsp), %r14
movl %edx, (%r14,%rdi)
movsbl %r9b, %edx
vpextrb $0x7, %xmm9, %r9d
movl %edx, (%r8,%rdi)
movsbl %r9b, %edx
vpextrb $0x8, %xmm9, %r9d
movq 0x60(%rsp), %r14
movl %edx, (%r14,%rdi)
movsbl %r9b, %edx
vpextrb $0x9, %xmm9, %r9d
movq 0x108(%rsp), %r14
movl %edx, (%r14,%rdi)
movsbl %r9b, %edx
vpextrb $0xa, %xmm9, %r9d
movl %edx, (%r12,%rdi)
movsbl %r9b, %edx
vpextrb $0xb, %xmm9, %r9d
movl %edx, (%rsi,%rdi)
movsbl %r9b, %edx
vpextrb $0xc, %xmm9, %r9d
movq 0x110(%rsp), %r14
movl %edx, (%r14,%rdi)
movsbl %r9b, %edx
vpextrb $0xd, %xmm9, %r9d
movl %edx, (%r13,%rdi)
movsbl %r9b, %edx
vpextrb $0xe, %xmm9, %r9d
movq 0x100(%rsp), %r14
movl %edx, (%r14,%rdi)
movsbl %r9b, %edx
vpextrb $0xf, %xmm9, %r9d
movq 0x58(%rsp), %r14
movl %edx, (%r14,%rdi)
movsbl %r9b, %edx
movq 0x50(%rsp), %r9
movl %edx, (%r9,%rdi)
vextracti128 $0x1, %ymm9, %xmm10
vmovd %xmm10, %edx
movsbl %dl, %edx
vpextrb $0x1, %xmm10, %r9d
movq 0x48(%rsp), %r14
movl %edx, (%r14,%rdi)
movsbl %r9b, %edx
vpextrb $0x2, %xmm10, %r9d
movq 0x198(%rsp), %r14
movl %edx, (%r14,%rdi)
movsbl %r9b, %edx
vpextrb $0x3, %xmm10, %r9d
movl %edx, (%r10,%rdi)
movsbl %r9b, %edx
vpextrb $0x4, %xmm10, %r9d
movq 0x190(%rsp), %r14
movl %edx, (%r14,%rdi)
movsbl %r9b, %edx
vpextrb $0x5, %xmm10, %r9d
movl %edx, (%r15,%rdi)
movsbl %r9b, %edx
vpextrb $0x6, %xmm10, %r9d
movq 0x188(%rsp), %r14
movl %edx, (%r14,%rdi)
movsbl %r9b, %edx
vpextrb $0x7, %xmm10, %r9d
movq 0x180(%rsp), %r14
movl %edx, (%r14,%rdi)
movsbl %r9b, %edx
vpextrb $0x8, %xmm10, %r9d
movq 0x178(%rsp), %r14
movl %edx, (%r14,%rdi)
movsbl %r9b, %edx
vpextrb $0x9, %xmm10, %r9d
movl %edx, (%rax,%rdi)
movsbl %r9b, %edx
vpextrb $0xa, %xmm10, %r9d
movq 0x170(%rsp), %r14
movl %edx, (%r14,%rdi)
movsbl %r9b, %edx
vpextrb $0xb, %xmm10, %r9d
movq 0x168(%rsp), %r14
movl %edx, (%r14,%rdi)
movsbl %r9b, %edx
vpextrb $0xc, %xmm10, %r9d
movq 0x160(%rsp), %r14
movl %edx, (%r14,%rdi)
movsbl %r9b, %edx
vpextrb $0xd, %xmm10, %r9d
movq 0x158(%rsp), %r14
movl %edx, (%r14,%rdi)
movsbl %r9b, %edx
vpextrb $0xe, %xmm10, %r9d
movq 0x150(%rsp), %r14
movl %edx, (%r14,%rdi)
movsbl %r9b, %edx
vpextrb $0xf, %xmm10, %r9d
movq 0x148(%rsp), %r14
movl %edx, (%r14,%rdi)
movsbl %r9b, %edx
movq %rbx, %r9
movq 0x140(%rsp), %rbx
movl %edx, (%rbx,%rdi)
vpminsb %ymm9, %ymm7, %ymm7
vpmaxsb %ymm9, %ymm6, %ymm6
addq $0x20, %rcx
addq %r9, %r11
cmpq %rcx, 0x18(%rsp)
jne 0x4cd9f8
addq $0x4, 0x98(%rsp)
movq 0xf8(%rsp), %rax
cmpq 0xe0(%rsp), %rax
movq 0x28(%rsp), %r8
movq 0x80(%rsp), %rdi
movq 0x40(%rsp), %rbx
movq 0x18(%rsp), %r15
movq 0xa0(%rsp), %r13
jne 0x4cd8ba
movl 0x7c(%rsp), %eax
shlq $0x5, %rax
vmovdqa (%r13,%rax), %ymm2
cmpl $0x1e, 0x24(%rsp)
jg 0x4cdd3d
movl 0x74(%rsp), %ecx
cmpl $0x2, %ecx
movl $0x1, %eax
cmovgel %ecx, %eax
movq 0x30(%rsp), %rcx
movl 0x20(%rsp), %esi
vperm2i128 $0x28, %ymm2, %ymm2, %ymm3 # ymm3 = zero,zero,ymm2[0,1]
vpalignr $0xf, %ymm3, %ymm2, %ymm2 # ymm2 = ymm3[15],ymm2[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm3[31],ymm2[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
decl %eax
jne 0x4cdd2b
jmp 0x4cdd46
movq 0x30(%rsp), %rcx
movl 0x20(%rsp), %esi
vpcmpgtb %ymm7, %ymm0, %ymm0
vpcmpgtb %ymm1, %ymm6, %ymm1
vpor %ymm0, %ymm1, %ymm0
vpmovmskb %ymm0, %eax
testl %eax, %eax
je 0x4cdd66
orb $0x40, 0xc(%rcx)
xorl %eax, %eax
xorl %esi, %esi
xorl %edx, %edx
jmp 0x4cdd76
vextracti128 $0x1, %ymm2, %xmm0
vpextrb $0xf, %xmm0, %eax
movl 0x78(%rsp), %edx
movsbl %al, %eax
movl %eax, (%rcx)
movl %edx, 0x4(%rcx)
movl %esi, 0x8(%rcx)
vzeroupper
callq 0x2094b5
movq %r13, %rdi
callq 0x2094b5
movq 0x68(%rsp), %rdi
callq 0x2094b5
movq 0x28(%rsp), %rdi
callq 0x2094b5
movq %rbx, %rdi
callq 0x2094b5
movq 0x30(%rsp), %rax
jmp 0x4cddec
callq 0x1e7c57
jmp 0x4cddea
callq 0x1e7c31
jmp 0x4cddea
callq 0x1e7c0b
jmp 0x4cddea
callq 0x1e7be5
jmp 0x4cddea
callq 0x1e7bbf
jmp 0x4cddea
callq 0x1e7b99
jmp 0x4cddea
callq 0x1e7b73
jmp 0x4cddea
callq 0x1e7b4d
xorl %eax, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop