// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_trace_scan_avx2_256_8.c
// Function: parasail_nw_trace_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;
    __m256i vTIns;
    __m256i vTDel;
    __m256i vTDiag;
    __m256i vTDiagE;
    __m256i vTInsE;
    __m256i vTDiagF;
    __m256i vTDelF;

    /* 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;
    vTIns  = _mm256_set1_epi8(PARASAIL_INS);
    vTDel  = _mm256_set1_epi8(PARASAIL_DEL);
    vTDiag = _mm256_set1_epi8(PARASAIL_DIAG);
    vTDiagE = _mm256_set1_epi8(PARASAIL_DIAG_E);
    vTInsE = _mm256_set1_epi8(PARASAIL_INS_E);
    vTDiagF = _mm256_set1_epi8(PARASAIL_DIAG_F);
    vTDelF = _mm256_set1_epi8(PARASAIL_DEL_F);
    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 */
    result = parasail_result_new_trace(segLen, s2Len, 32, sizeof(__m256i));
    if (!result) return NULL;

    /* set known flags */
    result->flag |= PARASAIL_FLAG_NW | PARASAIL_FLAG_SCAN
        | PARASAIL_FLAG_TRACE
        | PARASAIL_FLAG_BITS_8 | PARASAIL_FLAG_LANES_32;

    /* 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 vE_ext;
        __m256i vE_opn;
        __m256i vHt;
        __m256i vF;
        __m256i vF_ext;
        __m256i vF_opn;
        __m256i vH;
        __m256i vHp;
        __m256i *pvW;
        __m256i vW;
        __m256i case1;
        __m256i case2;
        __m256i vGapper;
        __m256i vT;
        __m256i vET;
        __m256i vFT;

        /* 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);
            vGapper = _mm256_load_si256(pvGapper+i);
            vE_opn = _mm256_subs_epi8(vH, vGapO);
            vE_ext = _mm256_subs_epi8(vE, vGapE);
            case1 = _mm256_cmpgt_epi8(vE_opn, vE_ext);
            vET = _mm256_blendv_epi8(vTInsE, vTDiagE, case1);
            arr_store(result->trace->trace_table, vET, i, segLen, j);
            vE = _mm256_max_epi8(vE_opn, vE_ext);
            vSaturationCheckMin = _mm256_min_epi8(vSaturationCheckMin, vE);
            vGapper = _mm256_adds_epi8(vHt, vGapper);
            vF = _mm256_max_epi8(vF, vGapper);
            vHp = _mm256_adds_epi8(vHp, vW);
            vHt = _mm256_max_epi8(vE, vHp);
            _mm256_store_si256(pvE+i, vE);
            _mm256_store_si256(pvHt+i, vHt);
            _mm256_store_si256(pvH+i, vHp);
            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);
        vGapper = _mm256_load_si256(pvGapper);
        vGapper = _mm256_adds_epi8(vHt, vGapper);
        vF = _mm256_max_epi8(vF, vGapper);
        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(vF, vHt);
        for (i=0; i<segLen; ++i) {
            vET = arr_load(result->trace->trace_table, i, segLen, j);
            vHp = _mm256_load_si256(pvH+i);
            vHt = _mm256_load_si256(pvHt+i);
            vF_opn = _mm256_subs_epi8(vH, vGapO);
            vF_ext = _mm256_subs_epi8(vF, vGapE);
            vF = _mm256_max_epi8(vF_opn, vF_ext);
            case1 = _mm256_cmpgt_epi8(vF_opn, vF_ext);
            vFT = _mm256_blendv_epi8(vTDelF, vTDiagF, case1);
            vH = _mm256_max_epi8(vHt, vF);
            case1 = _mm256_cmpeq_epi8(vH, vHp);
            case2 = _mm256_cmpeq_epi8(vH, vF);
            vT = _mm256_blendv_epi8(
                    _mm256_blendv_epi8(vTIns, vTDel, case2),
                    vTDiag, case1);
            vT = _mm256_or_si256(vT, vET);
            vT = _mm256_or_si256(vT, vFT);
            arr_store(result->trace->trace_table, vT, i, segLen, j);
            _mm256_store_si256(pvH+i, vH);
            vSaturationCheckMin = _mm256_min_epi8(vSaturationCheckMin, vH);
            vSaturationCheckMin = _mm256_min_epi8(vSaturationCheckMin, vF);
            vSaturationCheckMax = _mm256_max_epi8(vSaturationCheckMax, vH);
        }
    }

    /* 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 $0x180, %rsp            # imm = 0x180
movq %rsi, 0x48(%rsp)
testq %rdi, %rdi
je 0x57b30e
movq 0x18(%rdi), %rax
movq %rax, 0x58(%rsp)
testq %rax, %rax
je 0x57b315
movq 0x10(%rdi), %rax
movq %rax, 0x40(%rsp)
testq %rax, %rax
je 0x57b31c
movl 0x8(%rdi), %r13d
testl %r13d, %r13d
jle 0x57b323
cmpq $0x0, 0x48(%rsp)
je 0x57b32a
movl %edx, %r9d
testl %edx, %edx
jle 0x57b331
testl %ecx, %ecx
js 0x57b338
testl %r8d, %r8d
js 0x57b33f
movl %r8d, 0xa0(%rsp)
leal -0x1(%r13), %r14d
addq $0x1f, %r13
shrq $0x5, %r13
movl %r14d, %eax
cltd
idivl %r13d
movl %eax, %r15d
movl %edx, %r12d
movq 0x40(%rsp), %rdx
movl 0x20(%rdx), %eax
movl %eax, %esi
negb %sil
movzbl %sil, %edi
movl %ecx, %esi
negl %esi
movl %esi, 0x30(%rsp)
cmpl %esi, %eax
movl %ecx, 0x20(%rsp)
cmovgl %ecx, %edi
movl %edi, 0x80(%rsp)
movb $0x7e, %al
subb 0x1c(%rdx), %al
movl %eax, 0xe0(%rsp)
movl $0x20, %edx
movl $0x20, %ecx
movl %r13d, %edi
movl %r9d, %esi
movq %r9, 0x60(%rsp)
callq 0x2097d1
testq %rax, %rax
je 0x57b344
movq %rax, %rbx
movl %r12d, 0x3c(%rsp)
movl %r15d, 0x2c(%rsp)
movl %r14d, 0x38(%rsp)
orl $0x20180401, 0xc(%rax)  # imm = 0x20180401
movl $0x20, %edi
movq %r13, %rsi
callq 0x4c5e3c
movq %rax, %r12
movq 0x60(%rsp), %rax
leal 0x1(%rax), %esi
movl $0x20, %edi
movq %rsi, 0x50(%rsp)
callq 0x2094c8
movq %rax, 0x18(%rsp)
movl $0x20, %edi
movq %r13, %rsi
callq 0x4c5e3c
movq %rax, %r15
movl $0x20, %edi
movq %r13, %rsi
callq 0x4c5e3c
movq %rax, %r14
movl $0x20, %edi
movq %r13, %rsi
callq 0x4c5e3c
testq %r12, %r12
sete %cl
cmpq $0x0, 0x18(%rsp)
sete %dl
orb %cl, %dl
testq %r15, %r15
sete %cl
testq %r14, %r14
sete %sil
orb %cl, %sil
orb %dl, %sil
testq %rax, %rax
sete %cl
orb %sil, %cl
jne 0x57b344
movq 0x60(%rsp), %rcx
decl %ecx
movl %ecx, 0x28(%rsp)
movl $0x1f, %ecx
subl 0x2c(%rsp), %ecx
movl %ecx, 0x34(%rsp)
movl 0x20(%rsp), %esi
vmovd %esi, %xmm0
vpbroadcastb %xmm0, %ymm2
movl 0xa0(%rsp), %edx
vmovd %edx, %xmm0
vpbroadcastb %xmm0, %ymm3
movl 0x80(%rsp), %ecx
addb $-0x7f, %cl
vmovd %ecx, %xmm0
vpbroadcastb %xmm0, %ymm0
vmovdqa %ymm0, 0x80(%rsp)
vmovd 0xe0(%rsp), %xmm1
vpbroadcastb %xmm1, %ymm7
movzbl %cl, %ecx
vmovd %ecx, %xmm0
movl %r13d, %ecx
imull %edx, %ecx
negb %cl
vmovd %ecx, %xmm1
vpbroadcastb %xmm1, %ymm1
vpand 0x7e9ce(%rip), %ymm1, %ymm1 # 0x5f98c0
vmovdqa %ymm0, 0xe0(%rsp)
vpaddsb %ymm1, %ymm0, %ymm8
movl %esi, %ecx
movl %edx, %esi
movslq 0x30(%rsp), %r8
movl %r13d, %edx
negq %rcx
movq %rdx, 0x20(%rsp)
movq %rsi, 0xc0(%rsp)
imulq %rsi, %rdx
xorl %r9d, %r9d
movq $-0x80, %r10
movq %r8, %r11
xorl %esi, %esi
cmpq $-0x7f, %r11
movq $-0x80, %rdi
cmovgeq %r11, %rdi
movb %dil, 0x140(%rsp,%rsi)
leaq (%rcx,%r11), %rdi
cmpq $-0x7f, %rdi
cmovlq %r10, %rdi
movb %dil, 0x120(%rsp,%rsi)
incq %rsi
subq %rdx, %r11
cmpq $0x20, %rsi
jne 0x57af2e
movq %r9, %rsi
shlq $0x5, %rsi
vmovaps 0x140(%rsp), %ymm1
vmovaps %ymm1, (%r14,%rsi)
vmovdqa 0x120(%rsp), %ymm1
vmovdqa %ymm1, (%r12,%rsi)
incq %r9
subq 0xc0(%rsp), %r8
cmpq 0x20(%rsp), %r9
jne 0x57af29
movq 0x18(%rsp), %rsi
movb $0x0, (%rsi)
movl $0x1, %ecx
movl 0xa0(%rsp), %edi
movl 0x30(%rsp), %r8d
movq 0x50(%rsp), %r9
cmpl $-0x7f, %r8d
movl $0xffffff80, %edx       # imm = 0xFFFFFF80
cmovgel %r8d, %edx
movb %dl, (%rsi,%rcx)
incq %rcx
subl %edi, %r8d
cmpq %rcx, %r9
jne 0x57afba
vpxor %xmm1, %xmm1, %xmm1
vpsubsb %ymm2, %ymm1, %ymm1
leal -0x1(%r13), %ecx
movq %rcx, %rsi
shlq $0x5, %rsi
movq %rax, %rdx
addq %rsi, %rdx
movl %r13d, %esi
movq 0x60(%rsp), %r9
vmovdqa %ymm1, (%rdx)
vpsubsb %ymm3, %ymm1, %ymm1
addq $-0x20, %rdx
decl %esi
jg 0x57aff6
movl %ecx, %ecx
shlq $0x5, %rcx
movq %r14, %rdi
addq %rcx, %rdi
cmpl $0x1, %r13d
adcl $0x0, %r13d
cmpl $0x2, %r9d
movl $0x1, %r8d
cmovgel %r9d, %r8d
vpbroadcastb 0x804bf(%rip), %ymm15 # 0x5fb4f0
movq 0x20(%rsp), %r9
vpbroadcastb 0x804b2(%rip), %ymm0 # 0x5fb4f1
vmovdqa %ymm0, 0xc0(%rsp)
shlq $0x5, %r9
vpbroadcastb 0x8049d(%rip), %ymm9 # 0x5fb4f2
shlq $0x5, %r13
vpbroadcastb 0x80491(%rip), %ymm11 # 0x5fb4f3
xorl %r10d, %r10d
vpbroadcastb 0x80486(%rip), %ymm12 # 0x5fb4f4
vpbroadcastb 0x8047e(%rip), %ymm13 # 0x5fb4f5
xorl %r11d, %r11d
vmovdqa 0x80(%rsp), %ymm6
vmovdqa %ymm7, 0xa0(%rsp)
movq 0x18(%rsp), %rsi
vmovdqa %ymm8, 0x100(%rsp)
vmovdqa %ymm9, 0x60(%rsp)
vmovdqa 0xc0(%rsp), %ymm10
vmovdqa (%rdi), %ymm1
vinserti128 $0x1, %xmm1, %ymm0, %ymm14
vpalignr $0xf, %ymm14, %ymm1, %ymm1 # ymm1 = ymm14[15],ymm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm14[31],ymm1[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpinsrb $0x0, (%rsi,%r11), %xmm1, %xmm14
vpblendd $0xf, %ymm14, %ymm1, %ymm4 # ymm4 = ymm14[0,1,2,3],ymm1[4,5,6,7]
movq 0x40(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x48(%rsp), %rdx
movzbl (%rdx,%r11), %edx
movslq (%rcx,%rdx,4), %rcx
imulq 0x20(%rsp), %rcx
shlq $0x5, %rcx
addq 0x58(%rsp), %rcx
vmovdqa 0x80(%rsp), %ymm14
vmovdqa %ymm15, %ymm9
vpsubsb (%rax), %ymm14, %ymm15
xorl %edx, %edx
vpaddsb (%rcx,%rdx), %ymm4, %ymm1
vmovdqa (%r14,%rdx), %ymm4
vmovdqa (%r12,%rdx), %ymm0
vpsubsb %ymm2, %ymm4, %ymm5
vpsubsb %ymm3, %ymm0, %ymm0
vpcmpgtb %ymm0, %ymm5, %ymm8
vpblendvb %ymm8, %ymm9, %ymm10, %ymm8
movq 0x10(%rbx), %rsi
movq (%rsi), %rsi
addq %r10, %rsi
vpaddsb (%rax,%rdx), %ymm15, %ymm15
vmovdqa %ymm8, (%rdx,%rsi)
vpmaxsb %ymm15, %ymm14, %ymm14
vpmaxsb %ymm0, %ymm5, %ymm0
vpminsb %ymm0, %ymm7, %ymm7
vpmaxsb %ymm1, %ymm0, %ymm15
vmovdqa %ymm0, (%r12,%rdx)
vmovdqa %ymm15, (%r15,%rdx)
vmovdqa %ymm1, (%r14,%rdx)
addq $0x20, %rdx
cmpq %rdx, %r13
jne 0x57b100
vinserti128 $0x1, %xmm15, %ymm0, %ymm0
vpalignr $0xf, %ymm0, %ymm15, %ymm0 # ymm0 = ymm0[15],ymm15[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm0[31],ymm15[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
movq 0x18(%rsp), %rsi
vpinsrb $0x0, 0x1(%rsi,%r11), %xmm0, %xmm1
incq %r11
vpblendd $0xf, %ymm1, %ymm0, %ymm1 # ymm1 = ymm1[0,1,2,3],ymm0[4,5,6,7]
vpaddsb (%rax), %ymm1, %ymm0
vpmaxsb %ymm0, %ymm14, %ymm14
movl $0x1e, %ecx
vmovdqa 0x100(%rsp), %ymm8
vperm2i128 $0x28, %ymm14, %ymm14, %ymm0 # ymm0 = zero,zero,ymm14[0,1]
vpalignr $0xf, %ymm0, %ymm14, %ymm0 # ymm0 = ymm0[15],ymm14[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm0[31],ymm14[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpaddsb %ymm0, %ymm8, %ymm0
vpmaxsb %ymm0, %ymm14, %ymm14
decl %ecx
jne 0x57b19f
vperm2i128 $0x28, %ymm14, %ymm14, %ymm0 # ymm0 = zero,zero,ymm14[0,1]
vpalignr $0xf, %ymm0, %ymm14, %ymm0 # ymm0 = ymm0[15],ymm14[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm0[31],ymm14[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpaddsb 0xe0(%rsp), %ymm0, %ymm14
vpmaxsb %ymm1, %ymm14, %ymm1
xorl %ecx, %ecx
vmovdqa %ymm9, %ymm15
vmovdqa 0x60(%rsp), %ymm9
movq 0x10(%rbx), %rdx
movq (%rdx), %rdx
addq %r10, %rdx
vmovdqa (%r15,%rcx), %ymm0
vpsubsb %ymm2, %ymm1, %ymm1
vpsubsb %ymm3, %ymm14, %ymm4
vpmaxsb %ymm4, %ymm1, %ymm14
vpcmpgtb %ymm4, %ymm1, %ymm1
vpblendvb %ymm1, %ymm9, %ymm11, %ymm4
vpmaxsb %ymm14, %ymm0, %ymm1
vpcmpeqb (%r14,%rcx), %ymm1, %ymm5
vpcmpgtb %ymm14, %ymm0, %ymm0
vpaddb %ymm0, %ymm12, %ymm0
vpblendvb %ymm5, %ymm13, %ymm0, %ymm0
vpor (%rcx,%rdx), %ymm4, %ymm4
vpor %ymm0, %ymm4, %ymm0
vmovdqa %ymm0, (%rcx,%rdx)
vmovdqa %ymm1, (%r14,%rcx)
vpminsb %ymm14, %ymm7, %ymm0
vpminsb %ymm1, %ymm0, %ymm7
vpmaxsb %ymm1, %ymm6, %ymm6
addq $0x20, %rcx
cmpq %rcx, %r13
jne 0x57b1df
addq %r9, %r10
cmpq %r8, %r11
jne 0x57b0a9
movl 0x3c(%rsp), %ecx
shlq $0x5, %rcx
vmovdqa (%r14,%rcx), %ymm1
cmpl $0x1e, 0x2c(%rsp)
jg 0x57b292
movl 0x34(%rsp), %edx
cmpl $0x2, %edx
movl $0x1, %ecx
cmovgel %edx, %ecx
movl 0x28(%rsp), %esi
vperm2i128 $0x28, %ymm1, %ymm1, %ymm0 # ymm0 = zero,zero,ymm1[0,1]
vpalignr $0xf, %ymm0, %ymm1, %ymm1 # ymm1 = ymm0[15],ymm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm0[31],ymm1[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
decl %ecx
jne 0x57b280
jmp 0x57b296
movl 0x28(%rsp), %esi
vmovdqa 0x80(%rsp), %ymm0
vpcmpgtb %ymm7, %ymm0, %ymm0
vpcmpgtb 0xa0(%rsp), %ymm6, %ymm2
vpor %ymm0, %ymm2, %ymm0
vpmovmskb %ymm0, %ecx
testl %ecx, %ecx
je 0x57b2c4
orb $0x40, 0xc(%rbx)
xorl %ecx, %ecx
xorl %esi, %esi
xorl %edx, %edx
jmp 0x57b2d4
vextracti128 $0x1, %ymm1, %xmm0
vpextrb $0xf, %xmm0, %ecx
movl 0x38(%rsp), %edx
movsbl %cl, %ecx
movl %ecx, (%rbx)
movl %edx, 0x4(%rbx)
movl %esi, 0x8(%rbx)
movq %rax, %rdi
vzeroupper
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
movq 0x18(%rsp), %rdi
callq 0x2094b5
movq %r12, %rdi
callq 0x2094b5
jmp 0x57b346
callq 0x1f8caf
jmp 0x57b344
callq 0x1f8c89
jmp 0x57b344
callq 0x1f8c63
jmp 0x57b344
callq 0x1f8c3d
jmp 0x57b344
callq 0x1f8c17
jmp 0x57b344
callq 0x1f8bf1
jmp 0x57b344
callq 0x1f8bcb
jmp 0x57b344
callq 0x1f8ba5
xorl %ebx, %ebx
movq %rbx, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq