// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_trace_scan_avx2_256_16.c
// Function: parasail_nw_trace_scan_profile_avx2_256_16
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;
    int16_t* restrict boundary = NULL;
    __m256i* restrict pvHt = NULL;
    __m256i* restrict pvH = NULL;
    __m256i* restrict pvGapper = NULL;
    __m256i vGapO;
    __m256i vGapE;
    int16_t NEG_LIMIT = 0;
    int16_t POS_LIMIT = 0;
    __m256i vZero;
    int16_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->profile16.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 = 16; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    offset = (s1Len - 1) % segLen;
    position = (segWidth - 1) - (s1Len - 1) / segLen;
    pvP = (__m256i*)profile->profile16.score;
    vGapO = _mm256_set1_epi16(open);
    vGapE = _mm256_set1_epi16(gap);
    NEG_LIMIT = (-open < matrix->min ? INT16_MIN + open : INT16_MIN - matrix->min) + 1;
    POS_LIMIT = INT16_MAX - matrix->max - 1;
    vZero = _mm256_setzero_si256();
    score = NEG_LIMIT;
    vNegLimit = _mm256_set1_epi16(NEG_LIMIT);
    vPosLimit = _mm256_set1_epi16(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    vNegInfFront = vZero;
    vTIns  = _mm256_set1_epi16(PARASAIL_INS);
    vTDel  = _mm256_set1_epi16(PARASAIL_DEL);
    vTDiag = _mm256_set1_epi16(PARASAIL_DIAG);
    vTDiagE = _mm256_set1_epi16(PARASAIL_DIAG_E);
    vTInsE = _mm256_set1_epi16(PARASAIL_INS_E);
    vTDiagF = _mm256_set1_epi16(PARASAIL_DIAG_F);
    vTDelF = _mm256_set1_epi16(PARASAIL_DEL_F);
    vNegInfFront = _mm256_insert_epi16_rpl(vNegInfFront, NEG_LIMIT, 0);
    vSegLenXgap = _mm256_adds_epi16(vNegInfFront,
            _mm256_slli_si256_rpl(_mm256_set1_epi16(-segLen*gap), 2));

    /* 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_16 | PARASAIL_FLAG_LANES_16;

    /* initialize heap variables */
    pvE = parasail_memalign___m256i(32, segLen);
    boundary = parasail_memalign_int16_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_16_t h;
            __m256i_16_t e;
            for (segNum=0; segNum<segWidth; ++segNum) {
                int64_t tmp = -open-gap*(segNum*segLen+i);
                h.v[segNum] = tmp < INT16_MIN ? INT16_MIN : tmp;
                tmp = tmp - open;
                e.v[segNum] = tmp < INT16_MIN ? INT16_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 < INT16_MIN ? INT16_MIN : tmp;
        }
    }

    {
        __m256i vGapper = _mm256_subs_epi16(vZero,vGapO);
        for (i=segLen-1; i>=0; --i) {
            _mm256_store_si256(pvGapper+i, vGapper);
            vGapper = _mm256_subs_epi16(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, 2);
        vHp = _mm256_insert_epi16_rpl(vHp, boundary[j], 0);
        pvW = pvP + matrix->mapper[(unsigned char)s2[j]]*segLen;
        vHt = _mm256_subs_epi16(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_epi16(vH, vGapO);
            vE_ext = _mm256_subs_epi16(vE, vGapE);
            case1 = _mm256_cmpgt_epi16(vE_opn, vE_ext);
            vET = _mm256_blendv_epi8(vTInsE, vTDiagE, case1);
            arr_store(result->trace->trace_table, vET, i, segLen, j);
            vE = _mm256_max_epi16(vE_opn, vE_ext);
            vSaturationCheckMin = _mm256_min_epi16(vSaturationCheckMin, vE);
            vGapper = _mm256_adds_epi16(vHt, vGapper);
            vF = _mm256_max_epi16(vF, vGapper);
            vHp = _mm256_adds_epi16(vHp, vW);
            vHt = _mm256_max_epi16(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, 2);
        vHt = _mm256_insert_epi16_rpl(vHt, boundary[j+1], 0);
        vGapper = _mm256_load_si256(pvGapper);
        vGapper = _mm256_adds_epi16(vHt, vGapper);
        vF = _mm256_max_epi16(vF, vGapper);
        for (i=0; i<segWidth-2; ++i) {
            __m256i vFt = _mm256_slli_si256_rpl(vF, 2);
            vFt = _mm256_adds_epi16(vFt, vSegLenXgap);
            vF = _mm256_max_epi16(vF, vFt);
        }

        /* calculate final H */
        vF = _mm256_slli_si256_rpl(vF, 2);
        vF = _mm256_adds_epi16(vF, vNegInfFront);
        vH = _mm256_max_epi16(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_epi16(vH, vGapO);
            vF_ext = _mm256_subs_epi16(vF, vGapE);
            vF = _mm256_max_epi16(vF_opn, vF_ext);
            case1 = _mm256_cmpgt_epi16(vF_opn, vF_ext);
            vFT = _mm256_blendv_epi8(vTDelF, vTDiagF, case1);
            vH = _mm256_max_epi16(vHt, vF);
            case1 = _mm256_cmpeq_epi16(vH, vHp);
            case2 = _mm256_cmpeq_epi16(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_epi16(vSaturationCheckMin, vH);
            vSaturationCheckMin = _mm256_min_epi16(vSaturationCheckMin, vF);
            vSaturationCheckMax = _mm256_max_epi16(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, 2);
        }
        score = (int16_t) _mm256_extract_epi16_rpl (vH, 15);
    }

    if (_mm256_movemask_epi8(_mm256_or_si256(
            _mm256_cmplt_epi16_rpl(vSaturationCheckMin, vNegLimit),
            _mm256_cmpgt_epi16(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
testq %rdi, %rdi
je 0x579858
movq 0x30(%rdi), %rax
movq %rax, 0x58(%rsp)
testq %rax, %rax
je 0x57985f
movq 0x10(%rdi), %rax
movq %rax, 0x40(%rsp)
testq %rax, %rax
je 0x579866
movl 0x8(%rdi), %r13d
testl %r13d, %r13d
jle 0x57986d
testq %rsi, %rsi
je 0x579874
movl %edx, %r9d
testl %edx, %edx
jle 0x57987b
testl %ecx, %ecx
js 0x579882
testl %r8d, %r8d
js 0x579889
movl %r8d, 0xc0(%rsp)
movq %rsi, 0x50(%rsp)
leal -0x1(%r13), %r14d
addq $0xf, %r13
shrq $0x4, %r13
movl %r14d, %eax
cltd
idivl %r13d
movl %eax, %r15d
movl %edx, %r12d
movl %ecx, %edx
negl %edx
movq 0x40(%rsp), %rsi
movl 0x20(%rsi), %eax
movl %eax, %edi
negl %edi
movl %edx, 0xa0(%rsp)
cmpl %edx, %eax
movl %ecx, 0x10(%rsp)
cmovgl %ecx, %edi
movl %edi, 0x80(%rsp)
movw $0x7ffe, %ax            # imm = 0x7FFE
subw 0x1c(%rsi), %ax
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 0x57988e
movq %rax, %rbx
movl %r12d, 0x3c(%rsp)
movl %r15d, 0x1c(%rsp)
movl %r14d, 0x38(%rsp)
orl $0x10280401, 0xc(%rax)  # imm = 0x10280401
movl $0x20, %edi
movq %r13, %rsi
callq 0x4c5e3c
movq %rax, %r12
movq 0x60(%rsp), %rax
leal 0x1(%rax), %esi
movl $0x20, %edi
movq %rsi, 0x48(%rsp)
callq 0x2094cd
movq %rax, 0x8(%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, 0x8(%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 0x57988e
movq %rax, 0x28(%rsp)
movq 0x60(%rsp), %rax
decl %eax
movl %eax, 0x18(%rsp)
movl $0xf, %eax
subl 0x1c(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x10(%rsp), %edx
vmovd %edx, %xmm0
vpbroadcastw %xmm0, %ymm2
movl 0xc0(%rsp), %eax
vmovd %eax, %xmm0
vpbroadcastw %xmm0, %ymm3
movl 0x80(%rsp), %ecx
addl $0xffff8001, %ecx       # imm = 0xFFFF8001
vmovd %ecx, %xmm0
vpbroadcastw %xmm0, %ymm0
vmovdqa %ymm0, 0x80(%rsp)
vmovd 0xe0(%rsp), %xmm1
vpbroadcastw %xmm1, %ymm7
movzwl %cx, %ecx
vmovd %ecx, %xmm0
movl %r13d, %ecx
imull %eax, %ecx
negl %ecx
vmovd %ecx, %xmm1
vpbroadcastw %xmm1, %ymm1
vpand 0x803f0(%rip), %ymm1, %ymm1 # 0x5f9820
vmovdqa %ymm0, 0xe0(%rsp)
vpaddsw %ymm1, %ymm0, %ymm8
movl %edx, %edi
movl %eax, %ecx
movslq 0xa0(%rsp), %rax
movl %r13d, %r9d
negq %rdi
movq %r9, 0x10(%rsp)
movq %rcx, 0x20(%rsp)
imulq %rcx, %r9
xorl %edx, %edx
movq $-0x7fff, %r10          # imm = 0x8001
movq $-0x8000, %r11          # imm = 0x8000
movq %rax, %r8
xorl %ecx, %ecx
cmpq %r10, %r8
movq $-0x8000, %rsi          # imm = 0x8000
cmovgeq %r8, %rsi
movw %si, 0x140(%rsp,%rcx,2)
leaq (%rdi,%r8), %rsi
cmpq %r10, %rsi
cmovlq %r11, %rsi
movw %si, 0x120(%rsp,%rcx,2)
incq %rcx
subq %r9, %r8
cmpq $0x10, %rcx
jne 0x579472
movq %rdx, %rcx
shlq $0x5, %rcx
vmovaps 0x140(%rsp), %ymm1
vmovaps %ymm1, (%r14,%rcx)
vmovdqa 0x120(%rsp), %ymm1
vmovdqa %ymm1, (%r12,%rcx)
incq %rdx
subq 0x20(%rsp), %rax
cmpq 0x10(%rsp), %rdx
jne 0x57946d
movq 0x8(%rsp), %rdx
movw $0x0, (%rdx)
movl $0x1, %ecx
movl 0xc0(%rsp), %esi
movl 0xa0(%rsp), %edi
movq 0x48(%rsp), %r8
cmpl $0xffff8001, %edi       # imm = 0xFFFF8001
movl $0xffff8000, %eax       # imm = 0xFFFF8000
cmovgel %edi, %eax
movw %ax, (%rdx,%rcx,2)
incq %rcx
subl %esi, %edi
cmpq %rcx, %r8
jne 0x5794fd
vpxor %xmm1, %xmm1, %xmm1
vpsubsw %ymm2, %ymm1, %ymm1
leal -0x1(%r13), %ecx
movq %rcx, %rax
shlq $0x5, %rax
movq 0x28(%rsp), %rdx
addq %rax, %rdx
movl %r13d, %esi
movq 0x60(%rsp), %rdi
vmovdqa %ymm1, (%rdx)
vpsubsw %ymm3, %ymm1, %ymm1
addq $-0x20, %rdx
decl %esi
jg 0x57953c
movl %ecx, %eax
shlq $0x5, %rax
movq %r14, %rcx
addq %rax, %rcx
movq %rcx, 0x20(%rsp)
cmpl $0x1, %r13d
adcl $0x0, %r13d
cmpl $0x2, %edi
movl $0x1, %r8d
cmovgel %edi, %r8d
vpbroadcastw 0x81ef7(%rip), %ymm15 # 0x5fb472
movq 0x10(%rsp), %r9
vpbroadcastw 0x81eeb(%rip), %ymm0 # 0x5fb474
vmovdqa %ymm0, 0x60(%rsp)
shlq $0x5, %r9
vpbroadcastw 0x81eda(%rip), %ymm9 # 0x5fb476
shlq $0x5, %r13
vpbroadcastw 0x81ecf(%rip), %ymm11 # 0x5fb478
xorl %r10d, %r10d
vpbroadcastw 0x81ec5(%rip), %ymm12 # 0x5fb47a
vpbroadcastw 0x81ebe(%rip), %ymm13 # 0x5fb47c
xorl %r11d, %r11d
vmovdqa 0x80(%rsp), %ymm6
vmovdqa %ymm7, 0xa0(%rsp)
movq 0x50(%rsp), %rsi
movq 0x8(%rsp), %rdx
vmovdqa %ymm8, 0x100(%rsp)
vmovdqa %ymm9, 0xc0(%rsp)
movq 0x28(%rsp), %rdi
vmovdqa 0x60(%rsp), %ymm10
movq 0x20(%rsp), %rax
vmovdqa (%rax), %ymm1
vinserti128 $0x1, %xmm1, %ymm0, %ymm14
vpalignr $0xe, %ymm14, %ymm1, %ymm1 # ymm1 = ymm14[14,15],ymm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm14[30,31],ymm1[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
vpinsrw $0x0, (%rdx,%r11,2), %xmm1, %xmm14
vpblendd $0xf, %ymm14, %ymm1, %ymm4 # ymm4 = ymm14[0,1,2,3],ymm1[4,5,6,7]
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rsi,%r11), %ecx
movslq (%rax,%rcx,4), %rcx
imulq 0x10(%rsp), %rcx
shlq $0x5, %rcx
addq 0x58(%rsp), %rcx
vmovdqa 0x80(%rsp), %ymm14
vmovdqa %ymm15, %ymm9
vpsubsw (%rdi), %ymm14, %ymm15
xorl %edx, %edx
vpaddsw (%rcx,%rdx), %ymm4, %ymm1
vmovdqa (%r14,%rdx), %ymm4
vmovdqa (%r12,%rdx), %ymm0
vpsubsw %ymm2, %ymm4, %ymm5
vpsubsw %ymm3, %ymm0, %ymm0
vpcmpgtw %ymm0, %ymm5, %ymm8
vpblendvb %ymm8, %ymm9, %ymm10, %ymm8
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %r10, %rax
vpaddsw (%rdi,%rdx), %ymm15, %ymm15
vmovdqa %ymm8, (%rdx,%rax)
vpmaxsw %ymm15, %ymm14, %ymm14
vpmaxsw %ymm0, %ymm5, %ymm0
vpminsw %ymm0, %ymm7, %ymm7
vpmaxsw %ymm1, %ymm0, %ymm15
vmovdqa %ymm0, (%r12,%rdx)
vmovdqa %ymm15, (%r15,%rdx)
vmovdqa %ymm1, (%r14,%rdx)
addq $0x20, %rdx
cmpq %rdx, %r13
jne 0x579651
vinserti128 $0x1, %xmm15, %ymm0, %ymm0
vpalignr $0xe, %ymm0, %ymm15, %ymm0 # ymm0 = ymm0[14,15],ymm15[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm0[30,31],ymm15[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
movq 0x8(%rsp), %rdx
vpinsrw $0x0, 0x2(%rdx,%r11,2), %xmm0, %xmm1
incq %r11
vpblendd $0xf, %ymm1, %ymm0, %ymm1 # ymm1 = ymm1[0,1,2,3],ymm0[4,5,6,7]
vpaddsw (%rdi), %ymm1, %ymm0
vpmaxsw %ymm0, %ymm14, %ymm14
movl $0xe, %ecx
vmovdqa 0x100(%rsp), %ymm8
vperm2i128 $0x28, %ymm14, %ymm14, %ymm0 # ymm0 = zero,zero,ymm14[0,1]
vpalignr $0xe, %ymm0, %ymm14, %ymm0 # ymm0 = ymm0[14,15],ymm14[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm0[30,31],ymm14[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
vpaddsw %ymm0, %ymm8, %ymm0
vpmaxsw %ymm0, %ymm14, %ymm14
decl %ecx
jne 0x5796ec
vperm2i128 $0x28, %ymm14, %ymm14, %ymm0 # ymm0 = zero,zero,ymm14[0,1]
vpalignr $0xe, %ymm0, %ymm14, %ymm0 # ymm0 = ymm0[14,15],ymm14[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm0[30,31],ymm14[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
vpaddsw 0xe0(%rsp), %ymm0, %ymm14
vpmaxsw %ymm1, %ymm14, %ymm1
xorl %ecx, %ecx
vmovdqa %ymm9, %ymm15
vmovdqa 0xc0(%rsp), %ymm9
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %r10, %rax
vmovdqa (%r15,%rcx), %ymm0
vpsubsw %ymm2, %ymm1, %ymm1
vpsubsw %ymm3, %ymm14, %ymm4
vpmaxsw %ymm4, %ymm1, %ymm14
vpcmpgtw %ymm4, %ymm1, %ymm1
vpblendvb %ymm1, %ymm9, %ymm11, %ymm4
vpmaxsw %ymm0, %ymm14, %ymm1
vpcmpeqw (%r14,%rcx), %ymm1, %ymm5
vpcmpgtw %ymm14, %ymm0, %ymm0
vpaddw %ymm0, %ymm12, %ymm0
vpblendvb %ymm5, %ymm13, %ymm0, %ymm0
vpor (%rcx,%rax), %ymm4, %ymm4
vpor %ymm0, %ymm4, %ymm0
vmovdqa %ymm0, (%rcx,%rax)
vmovdqa %ymm1, (%r14,%rcx)
vpminsw %ymm7, %ymm14, %ymm0
vpminsw %ymm1, %ymm0, %ymm7
vpmaxsw %ymm1, %ymm6, %ymm6
addq $0x20, %rcx
cmpq %rcx, %r13
jne 0x57972d
addq %r9, %r10
cmpq %r8, %r11
jne 0x5795fa
movl 0x3c(%rsp), %eax
shlq $0x5, %rax
vmovdqa (%r14,%rax), %ymm1
cmpl $0xe, 0x1c(%rsp)
jg 0x5797db
movl 0x34(%rsp), %eax
cmpl $0x2, %eax
movl $0x1, %ecx
cmovgel %eax, %ecx
movl 0x18(%rsp), %esi
vperm2i128 $0x28, %ymm1, %ymm1, %ymm0 # ymm0 = zero,zero,ymm1[0,1]
vpalignr $0xe, %ymm0, %ymm1, %ymm1 # ymm1 = ymm0[14,15],ymm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm0[30,31],ymm1[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
decl %ecx
jne 0x5797c9
jmp 0x5797df
movl 0x18(%rsp), %esi
vmovdqa 0x80(%rsp), %ymm0
vpcmpgtw %ymm7, %ymm0, %ymm0
vpcmpgtw 0xa0(%rsp), %ymm6, %ymm2
vpor %ymm0, %ymm2, %ymm0
vpmovmskb %ymm0, %eax
testl %eax, %eax
je 0x57980d
orb $0x40, 0xc(%rbx)
xorl %ecx, %ecx
xorl %esi, %esi
xorl %edx, %edx
jmp 0x57981c
vextracti128 $0x1, %ymm1, %xmm0
vpextrw $0x7, %xmm0, %ecx
movl 0x38(%rsp), %edx
movswl %cx, %eax
movl %eax, (%rbx)
movl %edx, 0x4(%rbx)
movl %esi, 0x8(%rbx)
movq 0x28(%rsp), %rdi
vzeroupper
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
movq 0x8(%rsp), %rdi
callq 0x2094b5
movq %r12, %rdi
callq 0x2094b5
jmp 0x579890
callq 0x1f8601
jmp 0x57988e
callq 0x1f85db
jmp 0x57988e
callq 0x1f85b5
jmp 0x57988e
callq 0x1f858f
jmp 0x57988e
callq 0x1f8569
jmp 0x57988e
callq 0x1f8543
jmp 0x57988e
callq 0x1f851d
jmp 0x57988e
callq 0x1f84f7
xorl %ebx, %ebx
movq %rbx, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop