// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_scan_avx2_256_16.c
// Function: parasail_nw_table_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;

    /* 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;
    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 */
#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_16 | PARASAIL_FLAG_LANES_16;
#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_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 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, 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);
            vE = _mm256_max_epi16(
                    _mm256_subs_epi16(vE, vGapE),
                    _mm256_subs_epi16(vH, vGapO));
            vHp = _mm256_adds_epi16(vHp, vW);
            vF = _mm256_max_epi16(vF, _mm256_adds_epi16(vHt, pvGapper[i]));
            vHt = _mm256_max_epi16(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, 2);
        vHt = _mm256_insert_epi16_rpl(vHt, boundary[j+1], 0);
        vF = _mm256_max_epi16(vF, _mm256_adds_epi16(vHt, pvGapper[0]));
        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(vHt, vF);
        for (i=0; i<segLen; ++i) {
            vHt = _mm256_load_si256(pvHt+i);
            vF = _mm256_max_epi16(
                    _mm256_subs_epi16(vF, vGapE),
                    _mm256_subs_epi16(vH, vGapO));
            vH = _mm256_max_epi16(vHt, vF);
            _mm256_store_si256(pvH+i, vH);
            vSaturationCheckMin = _mm256_min_epi16(vSaturationCheckMin, vH);
            vSaturationCheckMax = _mm256_max_epi16(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, 2);
            }
            result->rowcols->score_row[j] = (int16_t) _mm256_extract_epi16_rpl (vH, 15);
        }
#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, 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
movq %rsi, 0x88(%rsp)
testq %rdi, %rdi
je 0x4cbbf1
movq 0x30(%rdi), %rax
movq %rax, 0xe8(%rsp)
testq %rax, %rax
je 0x4cbbf8
movq 0x10(%rdi), %rax
movq %rax, 0x80(%rsp)
testq %rax, %rax
je 0x4cbbff
movl 0x8(%rdi), %edi
testl %edi, %edi
jle 0x4cbc06
cmpq $0x0, 0x88(%rsp)
je 0x4cbc0d
movl %edx, %r9d
testl %edx, %edx
jle 0x4cbc14
testl %ecx, %ecx
js 0x4cbc1b
testl %r8d, %r8d
js 0x4cbc22
movl %r8d, 0x40(%rsp)
leal -0x1(%rdi), %eax
addq $0xf, %rdi
movq %rdi, %r13
shrq $0x4, %r13
movl %eax, 0x3c(%rsp)
cltd
idivl %r13d
movl %eax, %r12d
movl %edx, 0x74(%rsp)
movl %ecx, %ebx
negl %ebx
movq 0x80(%rsp), %rdx
movl 0x20(%rdx), %eax
movl %eax, %r14d
negl %r14d
cmpl %ebx, %eax
movl %ecx, 0x60(%rsp)
cmovgl %ecx, %r14d
movw $0x7ffe, %ax            # imm = 0x7FFE
subw 0x1c(%rdx), %ax
movl %eax, 0x58(%rsp)
andl $0x7ffffff0, %edi       # imm = 0x7FFFFFF0
movl %r9d, %esi
movq %r9, 0x28(%rsp)
callq 0x20959f
testq %rax, %rax
je 0x4cbc27
movq %rax, %r15
movl %r12d, 0x38(%rsp)
orl $0x10220401, 0xc(%rax)  # imm = 0x10220401
movl $0x20, %edi
movq %r13, %rsi
callq 0x4c5e3c
movq %r13, %r12
movq %rax, %r13
movq 0x28(%rsp), %rax
leal 0x1(%rax), %esi
movl $0x20, %edi
callq 0x2094cd
movq %rax, 0x20(%rsp)
movl $0x20, %edi
movq %r12, %rsi
callq 0x4c5e3c
movq %rax, 0x48(%rsp)
movl $0x20, %edi
movq %r12, %rsi
callq 0x4c5e3c
movq %rax, 0x30(%rsp)
movl $0x20, %edi
movq %r12, 0x18(%rsp)
movq %r12, %rsi
callq 0x4c5e3c
movq 0x48(%rsp), %rsi
movq 0x20(%rsp), %rcx
testq %r13, %r13
sete %dl
testq %rcx, %rcx
sete %cl
orb %dl, %cl
testq %rsi, %rsi
sete %r8b
cmpq $0x0, 0x30(%rsp)
sete %dl
orb %r8b, %dl
orb %cl, %dl
testq %rax, %rax
sete %cl
orb %dl, %cl
jne 0x4cbc27
movq %rax, 0x78(%rsp)
movq 0x28(%rsp), %rax
decl %eax
movl %eax, 0x70(%rsp)
movl $0xf, %eax
subl 0x38(%rsp), %eax
movl %eax, 0x6c(%rsp)
movl 0x60(%rsp), %edx
vmovd %edx, %xmm0
vpbroadcastw %xmm0, %ymm2
movl 0x40(%rsp), %ecx
vmovd %ecx, %xmm0
vpbroadcastw %xmm0, %ymm3
addl $0xffff8001, %r14d      # imm = 0xFFFF8001
vmovd %r14d, %xmm0
vpbroadcastw %xmm0, %ymm0
vmovd 0x58(%rsp), %xmm1
vpbroadcastw %xmm1, %ymm1
movzwl %r14w, %eax
vmovd %eax, %xmm4
movq 0x18(%rsp), %rsi
movl %esi, %eax
imull %ecx, %eax
negl %eax
vmovd %eax, %xmm5
vpbroadcastw %xmm5, %ymm5
vpand 0x12e21a(%rip), %ymm5, %ymm5 # 0x5f9820
vpaddsw %ymm5, %ymm4, %ymm5
movl %edx, %eax
movl %ecx, %ecx
movslq %ebx, %rdx
movl %esi, %esi
negq %rax
movq %rsi, 0x50(%rsp)
imulq %rcx, %rsi
xorl %edi, %edi
movq $-0x7fff, %r8           # imm = 0x8001
movq $-0x8000, %r9           # imm = 0x8000
movq 0x30(%rsp), %r12
movq %rdx, %r10
xorl %r11d, %r11d
cmpq %r8, %r10
movq $-0x8000, %r14          # imm = 0x8000
cmovgeq %r10, %r14
movw %r14w, 0x140(%rsp,%r11,2)
leaq (%rax,%r10), %r14
cmpq %r8, %r14
cmovlq %r9, %r14
movw %r14w, 0x120(%rsp,%r11,2)
incq %r11
subq %rsi, %r10
cmpq $0x10, %r11
jne 0x4cb63a
movq %rdi, %r10
shlq $0x5, %r10
vmovaps 0x140(%rsp), %ymm6
vmovaps %ymm6, (%r12,%r10)
vmovdqa 0x120(%rsp), %ymm6
vmovdqa %ymm6, (%r13,%r10)
incq %rdi
subq %rcx, %rdx
cmpq 0x50(%rsp), %rdi
jne 0x4cb634
movq 0x20(%rsp), %rsi
movw $0x0, (%rsi)
movq 0x28(%rsp), %r8
cmpl $0x2, %r8d
movl $0x1, %eax
cmovgel %r8d, %eax
xorl %ecx, %ecx
movl 0x40(%rsp), %edi
cmpl $0xffff8001, %ebx       # imm = 0xFFFF8001
movl $0xffff8000, %edx       # imm = 0xFFFF8000
cmovgel %ebx, %edx
movw %dx, 0x2(%rsi,%rcx,2)
subl %edi, %ebx
incq %rcx
cmpq %rcx, %rax
jne 0x4cb6c6
movq 0x18(%rsp), %rsi
leal -0x1(%rsi), %eax
vpxor %xmm6, %xmm6, %xmm6
vpsubsw %ymm2, %ymm6, %ymm6
movq %rax, %rdx
shlq $0x5, %rdx
movq 0x78(%rsp), %rdi
movq %rdi, %rcx
addq %rdx, %rcx
movl %esi, %edx
movq 0x48(%rsp), %r9
vmovdqa %ymm6, (%rcx)
vpsubsw %ymm3, %ymm6, %ymm6
addq $-0x20, %rcx
decl %edx
jg 0x4cb70c
movl %eax, %eax
shlq $0x5, %rax
addq %rax, %r12
movq %r12, 0xd8(%rsp)
movl %r8d, %esi
movq 0x18(%rsp), %rax
cmpl $0x1, %eax
adcl $0x0, %eax
cmpl $0x2, %r8d
movl $0x1, %ecx
cmovgel %r8d, %ecx
movq %rcx, 0xd0(%rsp)
shlq $0x5, %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rax
imulq %rsi, %rax
leaq (,%rax,4), %rdx
shlq $0x2, %rsi
leaq (,%rax,8), %r12
leaq (%rdx,%rdx,2), %rcx
movq %rcx, 0x40(%rsp)
leaq (%rax,%rax,8), %rcx
leaq (%rcx,%rcx,2), %rcx
addq %rax, %rcx
movq %rax, %r14
imulq $0x2c, %rax, %r10
imulq $0x34, %rax, %r11
imulq $0x38, %rax, %r8
movq %r8, 0x58(%rsp)
imulq $0x3c, %rax, %r8
movq %r8, 0xc8(%rsp)
movq %rax, %r8
shlq $0x4, %r8
shlq $0x5, %r14
vmovdqa %ymm0, %ymm6
vmovdqa %ymm1, %ymm7
leaq (%rdx,%rdx,4), %rbx
movq %rbx, 0xb8(%rsp)
leaq (%r12,%r12,2), %rbx
movq %rbx, 0xb0(%rsp)
movq %rdx, 0x28(%rsp)
leaq (%rdx,%rdx,8), %rdx
movq %rdx, 0xa8(%rsp)
leaq (%r12,%r12,4), %rdx
movq %rdx, 0xa0(%rsp)
movq %r8, 0xc0(%rsp)
leaq (%r8,%r8,2), %rdx
movq %rdx, 0x98(%rsp)
movq $0x0, 0x90(%rsp)
xorl %r8d, %r8d
movq %r13, 0xe0(%rsp)
movq %rsi, 0x60(%rsp)
movq %r11, 0x118(%rsp)
movq %r12, 0x110(%rsp)
movq %r14, 0x108(%rsp)
movq %rcx, 0x100(%rsp)
movq %r10, 0xf8(%rsp)
movq 0xc0(%rsp), %r14
movq 0xb0(%rsp), %r10
movq 0xa0(%rsp), %rax
movq 0x98(%rsp), %r11
movq 0x80(%rsp), %rdx
movq 0x10(%rdx), %rdx
movq 0x88(%rsp), %rsi
movzbl (%rsi,%r8), %esi
movslq (%rdx,%rsi,4), %rsi
movq 0x50(%rsp), %rdx
imulq %rsi, %rdx
shlq $0x5, %rdx
vpsubsw (%rdi), %ymm0, %ymm8
addq 0xe8(%rsp), %rdx
movq 0xd8(%rsp), %rsi
vmovdqa (%rsi), %ymm9
vinserti128 $0x1, %xmm9, %ymm0, %ymm10
vpalignr $0xe, %ymm10, %ymm9, %ymm9 # ymm9 = ymm10[14,15],ymm9[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm10[30,31],ymm9[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
movq %r8, %r12
movq 0x20(%rsp), %rsi
vpinsrw $0x0, (%rsi,%r8,2), %xmm9, %xmm10
vpblendd $0xf, %ymm10, %ymm9, %ymm10 # ymm10 = ymm10[0,1,2,3],ymm9[4,5,6,7]
xorl %esi, %esi
vmovdqa %ymm0, %ymm9
movq 0x30(%rsp), %rbx
movq 0x18(%rsp), %r8
vpaddsw (%rdx,%rsi), %ymm10, %ymm10
vmovdqa (%rbx,%rsi), %ymm11
vmovdqa (%r13,%rsi), %ymm12
vpsubsw %ymm3, %ymm12, %ymm12
vpsubsw %ymm2, %ymm11, %ymm13
vpmaxsw %ymm13, %ymm12, %ymm12
vpaddsw (%rdi,%rsi), %ymm8, %ymm8
vpmaxsw %ymm8, %ymm9, %ymm9
vpmaxsw %ymm10, %ymm12, %ymm8
vmovdqa %ymm12, (%r13,%rsi)
vmovdqa %ymm8, (%r9,%rsi)
addq $0x20, %rsi
vmovdqa %ymm11, %ymm10
cmpq %rsi, %r8
jne 0x4cb8dd
vinserti128 $0x1, %xmm8, %ymm0, %ymm10
vpalignr $0xe, %ymm10, %ymm8, %ymm8 # ymm8 = ymm10[14,15],ymm8[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm10[30,31],ymm8[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
movq 0x20(%rsp), %rcx
vpinsrw $0x0, 0x2(%rcx,%r12,2), %xmm8, %xmm10
incq %r12
movq %r12, 0xf0(%rsp)
vpblendd $0xf, %ymm10, %ymm8, %ymm10 # ymm10 = ymm10[0,1,2,3],ymm8[4,5,6,7]
vpaddsw (%rdi), %ymm10, %ymm8
vpmaxsw %ymm8, %ymm9, %ymm8
movl $0xe, %edx
vperm2i128 $0x28, %ymm8, %ymm8, %ymm9 # ymm9 = zero,zero,ymm8[0,1]
vpalignr $0xe, %ymm9, %ymm8, %ymm9 # ymm9 = ymm9[14,15],ymm8[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm9[30,31],ymm8[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
vpaddsw %ymm5, %ymm9, %ymm9
vpmaxsw %ymm9, %ymm8, %ymm8
decl %edx
jne 0x4cb95d
vperm2i128 $0x28, %ymm8, %ymm8, %ymm9 # ymm9 = zero,zero,ymm8[0,1]
vpalignr $0xe, %ymm9, %ymm8, %ymm8 # ymm8 = ymm9[14,15],ymm8[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm9[30,31],ymm8[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
vpaddsw %ymm4, %ymm8, %ymm8
vpmaxsw %ymm8, %ymm10, %ymm9
movq 0x90(%rsp), %rdx
xorl %edi, %edi
movq 0xc8(%rsp), %rbx
movq 0xb8(%rsp), %rcx
movq 0xa8(%rsp), %r8
vpsubsw %ymm3, %ymm8, %ymm8
vpsubsw %ymm2, %ymm9, %ymm9
vpmaxsw %ymm9, %ymm8, %ymm8
vpmaxsw (%r9,%rdi), %ymm8, %ymm9
movq 0x30(%rsp), %rsi
vmovdqa %ymm9, (%rsi,%rdi)
movq 0x10(%r15), %r9
movq (%r9), %r9
movq %r15, %rsi
vmovd %xmm9, %r15d
movswl %r15w, %r15d
movl %r15d, (%r9,%rdx)
vpextrw $0x1, %xmm9, %r15d
addq %rdx, %r9
movswl %r15w, %r15d
vpextrw $0x2, %xmm9, %r13d
movq 0x28(%rsp), %r12
movl %r15d, (%r12,%r9)
movswl %r13w, %r15d
vpextrw $0x3, %xmm9, %r13d
movq 0x110(%rsp), %r12
movl %r15d, (%r12,%r9)
movswl %r13w, %r15d
vpextrw $0x4, %xmm9, %r13d
movq 0x40(%rsp), %r12
movl %r15d, (%r12,%r9)
movswl %r13w, %r15d
vpextrw $0x5, %xmm9, %r13d
movl %r15d, (%r14,%r9)
movswl %r13w, %r15d
vpextrw $0x6, %xmm9, %r13d
movl %r15d, (%rcx,%r9)
movswl %r13w, %r15d
vpextrw $0x7, %xmm9, %r13d
movl %r15d, (%r10,%r9)
movswl %r13w, %r15d
movq 0x100(%rsp), %r12
movl %r15d, (%r12,%r9)
vextracti128 $0x1, %ymm9, %xmm10
vmovd %xmm10, %r15d
movswl %r15w, %r15d
vpextrw $0x1, %xmm10, %r13d
movq 0x108(%rsp), %r12
movl %r15d, (%r12,%r9)
movswl %r13w, %r15d
vpextrw $0x2, %xmm10, %r13d
movl %r15d, (%r8,%r9)
movswl %r13w, %r15d
vpextrw $0x3, %xmm10, %r13d
movl %r15d, (%rax,%r9)
movswl %r13w, %r15d
vpextrw $0x4, %xmm10, %r13d
movq 0xf8(%rsp), %r12
movl %r15d, (%r12,%r9)
movswl %r13w, %r15d
vpextrw $0x5, %xmm10, %r13d
movl %r15d, (%r11,%r9)
movswl %r13w, %r15d
vpextrw $0x6, %xmm10, %r13d
movq 0x118(%rsp), %r12
movl %r15d, (%r12,%r9)
movswl %r13w, %r15d
vpextrw $0x7, %xmm10, %r13d
movq 0x58(%rsp), %r12
movl %r15d, (%r12,%r9)
movswl %r13w, %r15d
movl %r15d, (%rbx,%r9)
movq 0x48(%rsp), %r9
movq %rsi, %r15
movq 0x60(%rsp), %rsi
vpminsw %ymm7, %ymm9, %ymm7
vpmaxsw %ymm6, %ymm9, %ymm6
addq $0x20, %rdi
addq %rsi, %rdx
cmpq %rdi, 0x18(%rsp)
jne 0x4cb9ad
addq $0x4, 0x90(%rsp)
movq 0xf0(%rsp), %r8
cmpq 0xd0(%rsp), %r8
movq 0xe0(%rsp), %r13
movq 0x78(%rsp), %rdi
jne 0x4cb86a
movl 0x74(%rsp), %eax
shlq $0x5, %rax
movq 0x30(%rsp), %rbx
vmovdqa (%rbx,%rax), %ymm2
cmpl $0xe, 0x38(%rsp)
movl 0x70(%rsp), %edx
jg 0x4cbb87
movl 0x6c(%rsp), %ecx
cmpl $0x2, %ecx
movl $0x1, %eax
cmovgel %ecx, %eax
movl 0x3c(%rsp), %ecx
vperm2i128 $0x28, %ymm2, %ymm2, %ymm3 # ymm3 = zero,zero,ymm2[0,1]
vpalignr $0xe, %ymm3, %ymm2, %ymm2 # ymm2 = ymm3[14,15],ymm2[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm3[30,31],ymm2[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
decl %eax
jne 0x4cbb75
jmp 0x4cbb8b
movl 0x3c(%rsp), %ecx
vpcmpgtw %ymm7, %ymm0, %ymm0
vpcmpgtw %ymm1, %ymm6, %ymm1
vpor %ymm0, %ymm1, %ymm0
vpmovmskb %ymm0, %eax
testl %eax, %eax
je 0x4cbbac
orb $0x40, 0xc(%r15)
xorl %eax, %eax
xorl %edx, %edx
xorl %ecx, %ecx
jmp 0x4cbbb7
vextracti128 $0x1, %ymm2, %xmm0
vpextrw $0x7, %xmm0, %eax
cwtl
movl %eax, (%r15)
movl %ecx, 0x4(%r15)
movl %edx, 0x8(%r15)
vzeroupper
callq 0x2094b5
movq %rbx, %rdi
callq 0x2094b5
movq 0x48(%rsp), %rdi
callq 0x2094b5
movq 0x20(%rsp), %rdi
callq 0x2094b5
movq %r13, %rdi
callq 0x2094b5
jmp 0x4cbc2a
callq 0x1e75a9
jmp 0x4cbc27
callq 0x1e7583
jmp 0x4cbc27
callq 0x1e755d
jmp 0x4cbc27
callq 0x1e7537
jmp 0x4cbc27
callq 0x1e7511
jmp 0x4cbc27
callq 0x1e74eb
jmp 0x4cbc27
callq 0x1e74c5
jmp 0x4cbc27
callq 0x1e749f
xorl %r15d, %r15d
movq %r15, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq