// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_trace_scan_sse2_128_8.c
// Function: parasail_sg_flags_trace_scan_profile_sse2_128_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,
        int s1_beg, int s1_end, int s2_beg, int s2_end)
{
    /* 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;
    __m128i* restrict pvP = NULL;
    __m128i* restrict pvE = NULL;
    int8_t* restrict boundary = NULL;
    __m128i* restrict pvHt = NULL;
    __m128i* restrict pvH = NULL;
    __m128i* restrict pvGapper = NULL;
    __m128i vGapO;
    __m128i vGapE;
    int8_t NEG_LIMIT = 0;
    int8_t POS_LIMIT = 0;
    __m128i vZero;
    int8_t score = 0;
    __m128i vNegLimit;
    __m128i vPosLimit;
    __m128i vSaturationCheckMin;
    __m128i vSaturationCheckMax;
    __m128i vMaxH;
    __m128i vPosMask;
    __m128i vNegInfFront;
    __m128i vSegLenXgap;
    parasail_result_t *result = NULL;
    __m128i vTIns;
    __m128i vTDel;
    __m128i vTDiag;
    __m128i vTDiagE;
    __m128i vTInsE;
    __m128i vTDiagF;
    __m128i 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 = 16; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    offset = (s1Len - 1) % segLen;
    position = (segWidth - 1) - (s1Len - 1) / segLen;
    pvP = (__m128i*)profile->profile8.score;
    vGapO = _mm_set1_epi8(open);
    vGapE = _mm_set1_epi8(gap);
    NEG_LIMIT = (-open < matrix->min ? INT8_MIN + open : INT8_MIN - matrix->min) + 1;
    POS_LIMIT = INT8_MAX - matrix->max - 1;
    vZero = _mm_setzero_si128();
    score = NEG_LIMIT;
    vNegLimit = _mm_set1_epi8(NEG_LIMIT);
    vPosLimit = _mm_set1_epi8(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    vMaxH = vNegLimit;
    vPosMask = _mm_cmpeq_epi8(_mm_set1_epi8(position),
            _mm_set_epi8(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15));
    vNegInfFront = vZero;
    vNegInfFront = _mm_insert_epi8_rpl(vNegInfFront, NEG_LIMIT, 0);
    vSegLenXgap = _mm_adds_epi8(vNegInfFront,
            _mm_slli_si128(_mm_set1_epi8(-segLen*gap), 1));
    vTIns  = _mm_set1_epi8(PARASAIL_INS);
    vTDel  = _mm_set1_epi8(PARASAIL_DEL);
    vTDiag = _mm_set1_epi8(PARASAIL_DIAG);
    vTDiagE= _mm_set1_epi8(PARASAIL_DIAG_E);
    vTInsE = _mm_set1_epi8(PARASAIL_INS_E);
    vTDiagF= _mm_set1_epi8(PARASAIL_DIAG_F);
    vTDelF = _mm_set1_epi8(PARASAIL_DEL_F);

    /* initialize result */
    result = parasail_result_new_trace(segLen, s2Len, 16, sizeof(__m128i));
    if (!result) return NULL;

    /* set known flags */
    result->flag |= PARASAIL_FLAG_SG | PARASAIL_FLAG_SCAN
        | PARASAIL_FLAG_TRACE
        | PARASAIL_FLAG_BITS_8 | PARASAIL_FLAG_LANES_16;
    result->flag |= s1_beg ? PARASAIL_FLAG_SG_S1_BEG : 0;
    result->flag |= s1_end ? PARASAIL_FLAG_SG_S1_END : 0;
    result->flag |= s2_beg ? PARASAIL_FLAG_SG_S2_BEG : 0;
    result->flag |= s2_end ? PARASAIL_FLAG_SG_S2_END : 0;

    /* initialize heap variables */
    pvE = parasail_memalign___m128i(16, segLen);
    boundary = parasail_memalign_int8_t(16, s2Len+1);
    pvHt= parasail_memalign___m128i(16, segLen);
    pvH = parasail_memalign___m128i(16, segLen);
    pvGapper = parasail_memalign___m128i(16, 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;
            __m128i_8_t h;
            __m128i_8_t e;
            for (segNum=0; segNum<segWidth; ++segNum) {
                int64_t tmp = s1_beg ? 0 : (-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;
            }
            _mm_store_si128(&pvH[index], h.m);
            _mm_store_si128(&pvE[index], e.m);
            ++index;
        }
    }

    /* initialize uppder boundary */
    {
        boundary[0] = 0;
        for (i=1; i<=s2Len; ++i) {
            int64_t tmp = s2_beg ? 0 : (-open-gap*(i-1));
            boundary[i] = tmp < INT8_MIN ? INT8_MIN : tmp;
        }
    }

    {
        __m128i vGapper = _mm_subs_epi8(vZero,vGapO);
        for (i=segLen-1; i>=0; --i) {
            _mm_store_si128(pvGapper+i, vGapper);
            vGapper = _mm_subs_epi8(vGapper, vGapE);
            /* long queries and/or large penalties will break the pseudo prefix scan */
            vSaturationCheckMin = _mm_min_epi8_rpl(vSaturationCheckMin, vGapper);
        }
    }

    /* outer loop over database sequence */
    for (j=0; j<s2Len; ++j) {
        __m128i vE;
        __m128i vE_ext;
        __m128i vE_opn;
        __m128i vHt;
        __m128i vF;
        __m128i vF_ext;
        __m128i vF_opn;
        __m128i vH;
        __m128i vHp;
        __m128i *pvW;
        __m128i vW;
        __m128i case1;
        __m128i case2;
        __m128i vGapper;
        __m128i vT;
        __m128i vET;
        __m128i vFT;

        /* calculate E */
        /* calculate Ht */
        /* calculate F and H first pass */
        vHp = _mm_load_si128(pvH+(segLen-1));
        vHp = _mm_slli_si128(vHp, 1);
        vHp = _mm_insert_epi8_rpl(vHp, boundary[j], 0);
        pvW = pvP + matrix->mapper[(unsigned char)s2[j]]*segLen;
        vHt = _mm_subs_epi8(vNegLimit, pvGapper[0]);
        vF = vNegLimit;
        for (i=0; i<segLen; ++i) {
            vH = _mm_load_si128(pvH+i);
            vE = _mm_load_si128(pvE+i);
            vW = _mm_load_si128(pvW+i);
            vGapper = _mm_load_si128(pvGapper+i);
            vE_opn = _mm_subs_epi8(vH, vGapO);
            vE_ext = _mm_subs_epi8(vE, vGapE);
            case1 = _mm_cmpgt_epi8(vE_opn, vE_ext);
            vET = _mm_blendv_epi8_rpl(vTInsE, vTDiagE, case1);
            arr_store(result->trace->trace_table, vET, i, segLen, j);
            vE = _mm_max_epi8_rpl(vE_opn, vE_ext);
            vSaturationCheckMin = _mm_min_epi8_rpl(vSaturationCheckMin, vE);
            vGapper = _mm_adds_epi8(vHt, vGapper);
            vF = _mm_max_epi8_rpl(vF, vGapper);
            vHp = _mm_adds_epi8(vHp, vW);
            vHt = _mm_max_epi8_rpl(vE, vHp);
            _mm_store_si128(pvE+i, vE);
            _mm_store_si128(pvHt+i, vHt);
            _mm_store_si128(pvH+i, vHp);
            vHp = vH;
        }

        /* pseudo prefix scan on F and H */
        vHt = _mm_slli_si128(vHt, 1);
        vHt = _mm_insert_epi8_rpl(vHt, boundary[j+1], 0);
        vGapper = _mm_load_si128(pvGapper);
        vGapper = _mm_adds_epi8(vHt, vGapper);
        vF = _mm_max_epi8_rpl(vF, vGapper);
        for (i=0; i<segWidth-2; ++i) {
            __m128i vFt = _mm_slli_si128(vF, 1);
            vFt = _mm_adds_epi8(vFt, vSegLenXgap);
            vF = _mm_max_epi8_rpl(vF, vFt);
        }

        /* calculate final H */
        vF = _mm_slli_si128(vF, 1);
        vF = _mm_adds_epi8(vF, vNegInfFront);
        vH = _mm_max_epi8_rpl(vF, vHt);
        for (i=0; i<segLen; ++i) {
            vET = arr_load(result->trace->trace_table, i, segLen, j);
            vHp = _mm_load_si128(pvH+i);
            vHt = _mm_load_si128(pvHt+i);
            vF_opn = _mm_subs_epi8(vH, vGapO);
            vF_ext = _mm_subs_epi8(vF, vGapE);
            vF = _mm_max_epi8_rpl(vF_opn, vF_ext);
            case1 = _mm_cmpgt_epi8(vF_opn, vF_ext);
            vFT = _mm_blendv_epi8_rpl(vTDelF, vTDiagF, case1);
            vH = _mm_max_epi8_rpl(vHt, vF);
            case1 = _mm_cmpeq_epi8(vH, vHp);
            case2 = _mm_cmpeq_epi8(vH, vF);
            vT = _mm_blendv_epi8_rpl(
                    _mm_blendv_epi8_rpl(vTIns, vTDel, case2),
                    vTDiag, case1);
            vT = _mm_or_si128(vT, vET);
            vT = _mm_or_si128(vT, vFT);
            arr_store(result->trace->trace_table, vT, i, segLen, j);
            _mm_store_si128(pvH+i, vH);
            vSaturationCheckMin = _mm_min_epi8_rpl(vSaturationCheckMin, vH);
            vSaturationCheckMin = _mm_min_epi8_rpl(vSaturationCheckMin, vF);
            vSaturationCheckMax = _mm_max_epi8_rpl(vSaturationCheckMax, vH);
        }

        /* extract vector containing last value from column */
        {
            __m128i vCompare;
            vH = _mm_load_si128(pvH + offset);
            vCompare = _mm_and_si128(vPosMask, _mm_cmpgt_epi8(vH, vMaxH));
            vMaxH = _mm_max_epi8_rpl(vH, vMaxH);
            if (_mm_movemask_epi8(vCompare)) {
                end_ref = j;
            }
        }
    } 

    /* max last value from all columns */
    if (s2_end)
    {
        for (k=0; k<position; ++k) {
            vMaxH = _mm_slli_si128(vMaxH, 1);
        }
        score = (int8_t) _mm_extract_epi8_rpl(vMaxH, 15);
        end_query = s1Len-1;
    }

    /* max of last column */
    if (s1_end)
    {
        /* Trace the alignment ending position on read. */
        int8_t *t = (int8_t*)pvH;
        int32_t column_len = segLen * segWidth;
        for (i = 0; i<column_len; ++i, ++t) {
            int32_t temp = i / segWidth + i % segWidth * segLen;
            if (temp >= s1Len) continue;
            if (*t > score) {
                score = *t;
                end_query = temp;
                end_ref = s2Len-1;
            }
            else if (*t == score && end_ref == s2Len-1 && temp < end_query) {
                end_query = temp;
            }
        }
    }

    if (!s1_end && !s2_end) {
        /* extract last value from the last column */
        {
            __m128i vH = _mm_load_si128(pvH + offset);
            for (k=0; k<position; ++k) {
                vH = _mm_slli_si128(vH, 1);
            }
            score = (int8_t) _mm_extract_epi8_rpl (vH, 15);
            end_ref = s2Len - 1;
            end_query = s1Len - 1;
        }
    }

    if (_mm_movemask_epi8(_mm_or_si128(
            _mm_cmplt_epi8(vSaturationCheckMin, vNegLimit),
            _mm_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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, 0x78(%rsp)
testq %rdi, %rdi
je 0x38c1cb
movq 0x18(%rdi), %rax
movq %rax, 0xc8(%rsp)
testq %rax, %rax
je 0x38c1d2
movq 0x10(%rdi), %rax
movq %rax, 0x70(%rsp)
testq %rax, %rax
je 0x38c1d9
movl %edx, %ebp
movl 0x8(%rdi), %edx
testl %edx, %edx
jle 0x38c1e0
cmpq $0x0, 0x78(%rsp)
je 0x38c1e7
testl %ebp, %ebp
jle 0x38c1ee
testl %ecx, %ecx
js 0x38c1f5
testl %r8d, %r8d
js 0x38c1fc
movl %r9d, %r12d
movl %r8d, 0x30(%rsp)
leal -0x1(%rdx), %eax
movq %rdx, 0xc0(%rsp)
leaq 0xf(%rdx), %r15
movq %r15, %r14
shrq $0x4, %r14
movl %eax, 0x4c(%rsp)
cltd
idivl %r14d
movl %eax, 0x8(%rsp)
movl %edx, %r13d
movl %ecx, %esi
negl %esi
movq 0x70(%rsp), %rdx
movl 0x20(%rdx), %eax
movl %eax, %edi
negb %dil
movl %esi, 0x28(%rsp)
cmpl %esi, %eax
movzbl %dil, %eax
movl %ecx, 0x18(%rsp)
cmovgl %ecx, %eax
movl %eax, 0xc(%rsp)
movb $0x7e, %al
subb 0x1c(%rdx), %al
movb %al, 0x50(%rsp)
movl $0x10, %edx
movl $0x10, %ecx
movl %r14d, %edi
movl %ebp, %esi
callq 0x2097d1
testq %rax, %rax
je 0x38c201
movq %rax, %rbx
movl %r13d, 0x40(%rsp)
movq %r15, 0xb8(%rsp)
xorl %eax, %eax
testl %r12d, %r12d
setne %al
xorl %ecx, %ecx
cmpl $0x0, 0x140(%rsp)
setne %cl
shll $0x4, %ecx
xorl %edx, %edx
cmpl $0x0, 0x148(%rsp)
setne %dl
shll $0xe, %edx
xorl %esi, %esi
cmpl $0x0, 0x150(%rsp)
setne %sil
shll $0xf, %esi
leal (%rcx,%rax,8), %eax
orl %edx, %eax
orl %esi, %eax
orl 0xc(%rbx), %eax
orl $0x10180402, %eax       # imm = 0x10180402
movl %eax, 0xc(%rbx)
movl $0x10, %edi
movq %r14, %rsi
callq 0x2ea474
movq %r14, %r13
movq %rax, %r14
leal 0x1(%rbp), %esi
movl $0x10, %edi
movq %rsi, 0x80(%rsp)
callq 0x2094c8
movq %rbp, 0x68(%rsp)
movq %rax, 0x38(%rsp)
movl $0x10, %edi
movq %r13, %rsi
callq 0x2ea474
movq %rax, %r15
movl $0x10, %edi
movq %r13, %rsi
callq 0x2ea474
movq %rax, %rbp
movl $0x10, %edi
movq %r13, 0x10(%rsp)
movq %r13, %rsi
callq 0x2ea474
movq 0x38(%rsp), %rdx
testq %r14, %r14
sete %cl
testq %rdx, %rdx
sete %dl
orb %cl, %dl
testq %r15, %r15
sete %cl
testq %rbp, %rbp
sete %sil
orb %cl, %sil
orb %dl, %sil
testq %rax, %rax
sete %cl
orb %sil, %cl
jne 0x38c201
movq 0x68(%rsp), %rcx
decl %ecx
movl %ecx, 0x4(%rsp)
movl $0xf, %edx
subl 0x8(%rsp), %edx
movl 0x18(%rsp), %edi
movd %edi, %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm3      # xmm3 = xmm0[0,0,0,0]
movl 0x30(%rsp), %esi
movd %esi, %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm4      # xmm4 = xmm0[0,0,0,0]
movl 0xc(%rsp), %r13d
addb $-0x7f, %r13b
movl %r13d, 0xc(%rsp)
movzbl %r13b, %ecx
movd %ecx, %xmm1
movdqa %xmm1, %xmm0
punpcklbw %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3],xmm0[4],xmm1[4],xmm0[5],xmm1[5],xmm0[6],xmm1[6],xmm0[7],xmm1[7]
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x90(%rsp)
movzbl 0x50(%rsp), %ecx
movd %ecx, %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm2      # xmm2 = xmm0[0,0,0,0]
movl %edx, 0x24(%rsp)
movd %edx, %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0xa0(%rsp)
movq 0x10(%rsp), %r8
movl %r8d, %ecx
imull %esi, %ecx
negb %cl
movzbl %cl, %ecx
movd %ecx, %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm7      # xmm7 = xmm0[0,0,0,0]
pslldq $0x1, %xmm7             # xmm7 = zero,xmm7[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movdqa %xmm1, 0xd0(%rsp)
paddsb %xmm1, %xmm7
movl %edi, %ecx
movl %esi, %esi
movslq 0x28(%rsp), %rdx
movl %r8d, %r8d
movq %r8, 0x18(%rsp)
movq %rsi, 0x50(%rsp)
imulq %rsi, %r8
xorl %r9d, %r9d
movq $-0x80, %r10
movq %rdx, %rsi
xorl %edi, %edi
testl %r12d, %r12d
je 0x38bb45
xorl %r11d, %r11d
jmp 0x38bb48
movq %rsi, %r11
cmpq $-0x7f, %r11
movq $-0x80, %r13
cmovgeq %r11, %r13
movb %r13b, 0xf0(%rsp,%rdi)
subq %rcx, %r11
cmpq $-0x7f, %r11
cmovlq %r10, %r11
movb %r11b, 0xe0(%rsp,%rdi)
incq %rdi
subq %r8, %rsi
cmpq $0x10, %rdi
jne 0x38bb3b
movq %r9, %rsi
shlq $0x4, %rsi
movaps 0xf0(%rsp), %xmm0
movaps %xmm0, (%rbp,%rsi)
movdqa 0xe0(%rsp), %xmm0
movdqa %xmm0, (%r14,%rsi)
incq %r9
subq 0x50(%rsp), %rdx
cmpq 0x18(%rsp), %r9
jne 0x38bb36
movq 0x38(%rsp), %r9
movb $0x0, (%r9)
movl $0x1, %ecx
xorl %edx, %edx
movl 0x30(%rsp), %edi
movl 0x28(%rsp), %r8d
movl 0x148(%rsp), %r10d
movq 0x80(%rsp), %r11
cmpl $-0x7f, %r8d
movl $0xffffff80, %esi       # imm = 0xFFFFFF80
cmovgel %r8d, %esi
testl %r10d, %r10d
cmovnel %edx, %esi
movb %sil, (%r9,%rcx)
incq %rcx
subl %edi, %r8d
cmpq %rcx, %r11
jne 0x38bbd9
pxor %xmm0, %xmm0
psubsb %xmm3, %xmm0
movq 0x10(%rsp), %rdi
leal -0x1(%rdi), %ecx
movq %rcx, %rsi
shlq $0x4, %rsi
movq %rax, %rdx
addq %rsi, %rdx
movl %edi, %esi
movdqa %xmm2, 0x80(%rsp)
movq 0x68(%rsp), %rdi
movdqa %xmm0, (%rdx)
psubsb %xmm4, %xmm0
movdqa %xmm2, %xmm1
pcmpgtb %xmm0, %xmm1
movdqa %xmm0, %xmm5
pand %xmm1, %xmm5
pandn %xmm2, %xmm1
movdqa %xmm1, %xmm2
por %xmm5, %xmm2
addq $-0x10, %rdx
decl %esi
jg 0x38bc28
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rbp, %rcx
movq %rcx, 0x30(%rsp)
movl 0x40(%rsp), %r10d
movq %r10, 0x40(%rsp)
shlq $0x4, %r10
addq %rbp, %r10
movq 0x10(%rsp), %r11
cmpl $0x1, %r11d
adcl $0x0, %r11d
cmpl $0x2, %edi
movl $0x1, %ecx
cmovgel %edi, %ecx
movq %rcx, 0x28(%rsp)
movq 0x18(%rsp), %r13
shlq $0x4, %r13
shlq $0x4, %r11
xorl %esi, %esi
movdqa 0x269dd8(%rip), %xmm12  # 0x5f5a80
movdqa 0x26b9bf(%rip), %xmm14  # 0x5f7670
movdqa 0x20a4d6(%rip), %xmm15  # 0x596190
movdqa 0x20a4ed(%rip), %xmm11  # 0x5961b0
movdqa 0xa0(%rsp), %xmm0
pcmpeqb 0x269ddc(%rip), %xmm0   # 0x5f5ab0
movdqa %xmm0, 0xa0(%rsp)
xorl %edx, %edx
movl 0x4(%rsp), %r8d
movdqa 0x90(%rsp), %xmm0
movdqa %xmm0, %xmm8
movdqa %xmm0, %xmm5
movdqa %xmm11, %xmm1
movdqa %xmm5, 0x50(%rsp)
movq 0x30(%rsp), %rcx
movdqa (%rcx), %xmm0
pslldq $0x1, %xmm0             # xmm0 = zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movzbl (%r9,%rdx), %ecx
movd %ecx, %xmm6
movdqa %xmm12, %xmm5
pandn %xmm6, %xmm5
por %xmm0, %xmm5
movq 0x70(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x78(%rsp), %rdi
movzbl (%rdi,%rdx), %edi
movslq (%rcx,%rdi,4), %rcx
imulq 0x18(%rsp), %rcx
shlq $0x4, %rcx
addq 0xc8(%rsp), %rcx
movdqa 0x90(%rsp), %xmm6
movdqa %xmm6, %xmm0
psubsb (%rax), %xmm0
xorl %r12d, %r12d
movdqa (%rbp,%r12), %xmm12
movdqa (%r14,%r12), %xmm11
movdqa %xmm12, %xmm10
psubsb %xmm3, %xmm10
psubsb %xmm4, %xmm11
movdqa %xmm10, %xmm9
pcmpgtb %xmm11, %xmm9
movdqa %xmm9, %xmm13
pand %xmm14, %xmm13
pxor %xmm15, %xmm13
movq 0x10(%rbx), %rdi
movq (%rdi), %rdi
addq %rsi, %rdi
paddsb (%rax,%r12), %xmm0
paddsb (%rcx,%r12), %xmm5
movdqa %xmm13, (%r12,%rdi)
pand %xmm9, %xmm10
pandn %xmm11, %xmm9
por %xmm10, %xmm9
movdqa %xmm2, %xmm10
pcmpgtb %xmm9, %xmm10
movdqa %xmm6, %xmm11
pcmpgtb %xmm0, %xmm6
pand %xmm6, %xmm11
pandn %xmm0, %xmm6
movdqa %xmm9, %xmm0
movdqa %xmm9, %xmm13
movdqa %xmm9, (%r14,%r12)
pand %xmm10, %xmm9
pandn %xmm2, %xmm10
movdqa %xmm10, %xmm2
por %xmm9, %xmm2
por %xmm11, %xmm6
pcmpgtb %xmm5, %xmm0
pand %xmm0, %xmm13
pandn %xmm5, %xmm0
por %xmm13, %xmm0
movdqa %xmm0, (%r15,%r12)
movdqa %xmm5, (%rbp,%r12)
addq $0x10, %r12
movdqa %xmm12, %xmm5
cmpq %r12, %r11
jne 0x38bd61
pslldq $0x1, %xmm0             # xmm0 = zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
leaq 0x1(%rdx), %rcx
movzbl 0x1(%r9,%rdx), %edi
movd %edi, %xmm5
movdqa 0x269c2d(%rip), %xmm12  # 0x5f5a80
movdqa %xmm12, %xmm10
pandn %xmm5, %xmm10
por %xmm0, %xmm10
movdqa (%rax), %xmm0
paddsb %xmm10, %xmm0
movdqa %xmm6, %xmm5
pcmpgtb %xmm0, %xmm5
pand %xmm5, %xmm6
pandn %xmm0, %xmm5
por %xmm6, %xmm5
movl $0xe, %edi
movdqa %xmm5, %xmm0
movdqa %xmm5, %xmm6
pslldq $0x1, %xmm5             # xmm5 = zero,xmm5[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
paddsb %xmm7, %xmm5
pcmpgtb %xmm5, %xmm0
pand %xmm0, %xmm6
pandn %xmm5, %xmm0
movdqa %xmm0, %xmm5
por %xmm6, %xmm5
decl %edi
jne 0x38be84
pslldq $0x1, %xmm5             # xmm5 = zero,xmm5[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
paddsb 0xd0(%rsp), %xmm5
movdqa %xmm5, %xmm6
pcmpgtb %xmm10, %xmm6
movdqa %xmm5, %xmm0
pand %xmm6, %xmm0
pandn %xmm10, %xmm6
por %xmm0, %xmm6
xorl %r12d, %r12d
movdqa 0x26b79f(%rip), %xmm15  # 0x5f7680
movdqa %xmm1, %xmm11
movdqa 0x20a261(%rip), %xmm14  # 0x596150
movdqa 0x20a278(%rip), %xmm13  # 0x596170
movq 0x10(%rbx), %rdi
movq (%rdi), %r9
addq %rsi, %r9
movdqa (%r15,%r12), %xmm0
psubsb %xmm3, %xmm6
psubsb %xmm4, %xmm5
movdqa %xmm6, %xmm9
pcmpgtb %xmm5, %xmm9
movdqa %xmm9, %xmm10
pandn %xmm5, %xmm10
pand %xmm9, %xmm6
movdqa %xmm6, %xmm5
por %xmm10, %xmm5
pand %xmm15, %xmm9
pxor %xmm11, %xmm9
movdqa %xmm0, %xmm6
pcmpgtb %xmm5, %xmm6
movdqa %xmm6, %xmm10
pandn %xmm5, %xmm10
pand %xmm6, %xmm0
por %xmm10, %xmm0
movdqa (%rbp,%r12), %xmm10
pcmpeqb %xmm0, %xmm10
paddb %xmm14, %xmm6
movdqa %xmm10, %xmm11
pandn %xmm6, %xmm11
pand %xmm13, %xmm10
por %xmm11, %xmm10
movdqa %xmm1, %xmm11
por (%r12,%r9), %xmm9
por %xmm10, %xmm9
movdqa %xmm9, (%r12,%r9)
movdqa %xmm0, (%rbp,%r12)
movdqa %xmm2, %xmm9
pcmpgtb %xmm0, %xmm9
movdqa %xmm8, %xmm10
pcmpgtb %xmm0, %xmm8
pand %xmm8, %xmm10
pandn %xmm0, %xmm8
movdqa %xmm0, %xmm6
pand %xmm9, %xmm0
pandn %xmm2, %xmm9
por %xmm0, %xmm9
movdqa %xmm9, %xmm2
pcmpgtb %xmm5, %xmm2
movdqa %xmm5, %xmm0
pand %xmm2, %xmm0
pandn %xmm9, %xmm2
por %xmm0, %xmm2
por %xmm10, %xmm8
addq $0x10, %r12
cmpq %r12, %r11
jne 0x38bef8
movdqa (%r10), %xmm0
movdqa %xmm0, %xmm5
movdqa 0x50(%rsp), %xmm9
pcmpgtb %xmm9, %xmm5
movdqa %xmm5, %xmm6
pand 0xa0(%rsp), %xmm6
pand %xmm5, %xmm0
pandn %xmm9, %xmm5
pmovmskb %xmm6, %edi
testl %edi, %edi
cmovnel %edx, %r8d
por %xmm0, %xmm5
addq %r13, %rsi
movq %rcx, %rdx
cmpq 0x28(%rsp), %rcx
movq 0x38(%rsp), %r9
movdqa 0x26b628(%rip), %xmm14  # 0x5f7670
movdqa 0x20a13f(%rip), %xmm15  # 0x596190
jne 0x38bcf6
movl 0x150(%rsp), %r13d
testl %r13d, %r13d
movl 0x4c(%rsp), %r10d
movq 0xc0(%rsp), %r11
movl 0xc(%rsp), %r12d
je 0x38c09f
cmpl $0xe, 0x8(%rsp)
jg 0x38c095
movl 0x24(%rsp), %edx
cmpl $0x2, %edx
movl $0x1, %ecx
cmovgel %edx, %ecx
pslldq $0x1, %xmm5             # xmm5 = zero,xmm5[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
decl %ecx
jne 0x38c08c
pextrw $0x7, %xmm5, %r12d
shrl $0x8, %r12d
cmpl $0x0, 0x140(%rsp)
je 0x38c114
testl $0x7ffffff0, 0xb8(%rsp) # imm = 0x7FFFFFF0
je 0x38c114
movq 0x10(%rsp), %rdx
andl $0x7ffffff, %edx        # imm = 0x7FFFFFF
shll $0x4, %edx
xorl %esi, %esi
movl %r10d, %ecx
movl %esi, %r9d
shrl $0x4, %r9d
movl %esi, %edi
andl $0xf, %edi
imull 0x10(%rsp), %edi
addl %r9d, %edi
cmpl %r11d, %edi
jge 0x38c10b
movb (%rbp,%rsi), %r9b
cmpb %r12b, %r9b
jle 0x38c0f8
movl %r9d, %r12d
movl 0x4(%rsp), %r8d
movl %edi, %ecx
jmp 0x38c10b
cmpl %ecx, %edi
cmovgel %ecx, %edi
cmpl 0x4(%rsp), %r8d
cmovnel %ecx, %edi
cmpb %r12b, %r9b
cmovel %edi, %ecx
incq %rsi
cmpl %esi, %edx
jne 0x38c0c9
jmp 0x38c117
movl %r10d, %ecx
orl 0x140(%rsp), %r13d
jne 0x38c161
movq 0x40(%rsp), %rcx
shlq $0x4, %rcx
movdqa (%rbp,%rcx), %xmm0
cmpl $0xe, 0x8(%rsp)
jg 0x38c14f
movl 0x24(%rsp), %edx
cmpl $0x2, %edx
movl $0x1, %ecx
cmovgel %edx, %ecx
pslldq $0x1, %xmm0             # xmm0 = zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
decl %ecx
jne 0x38c146
pextrw $0x7, %xmm0, %r12d
shrl $0x8, %r12d
movl 0x4(%rsp), %r8d
movl %r10d, %ecx
movdqa 0x90(%rsp), %xmm0
pcmpgtb %xmm2, %xmm0
pcmpgtb 0x80(%rsp), %xmm8
por %xmm0, %xmm8
pmovmskb %xmm8, %edx
testl %edx, %edx
je 0x38c192
orb $0x40, 0xc(%rbx)
xorl %r12d, %r12d
xorl %r8d, %r8d
xorl %ecx, %ecx
movsbl %r12b, %edx
movl %edx, (%rbx)
movl %ecx, 0x4(%rbx)
movl %r8d, 0x8(%rbx)
movq %rax, %rdi
callq 0x2094b5
movq %rbp, %rdi
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
movq 0x38(%rsp), %rdi
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
jmp 0x38c203
callq 0x1bd7b1
jmp 0x38c201
callq 0x1bd78b
jmp 0x38c201
callq 0x1bd765
jmp 0x38c201
callq 0x1bd73f
jmp 0x38c201
callq 0x1bd719
jmp 0x38c201
callq 0x1bd6f3
jmp 0x38c201
callq 0x1bd6cd
jmp 0x38c201
callq 0x1bd6a7
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq