// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_trace_scan_sse2_128_8.c
// Function: parasail_nw_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)
{
    /* 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 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;
    vNegInfFront = vZero;
    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);
    vNegInfFront = _mm_insert_epi8_rpl(vNegInfFront, NEG_LIMIT, 0);
    vSegLenXgap = _mm_adds_epi8(vNegInfFront,
            _mm_slli_si128(_mm_set1_epi8(-segLen*gap), 1));

    /* initialize result */
    result = parasail_result_new_trace(segLen, s2Len, 16, sizeof(__m128i));
    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_16;

    /* 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 = -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 = -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);
        }
    }

    /* 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 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);
    }

    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 $0xc8, %rsp
testq %rdi, %rdi
je 0x38b729
movq 0x18(%rdi), %rax
movq %rax, 0x98(%rsp)
testq %rax, %rax
je 0x38b730
movq 0x10(%rdi), %rax
movq %rax, 0x58(%rsp)
testq %rax, %rax
je 0x38b737
movl 0x8(%rdi), %r12d
testl %r12d, %r12d
jle 0x38b73e
testq %rsi, %rsi
je 0x38b745
movl %edx, %r9d
testl %edx, %edx
jle 0x38b74c
testl %ecx, %ecx
js 0x38b753
testl %r8d, %r8d
js 0x38b75a
movl %r8d, 0x24(%rsp)
movq %rsi, 0x90(%rsp)
leal -0x1(%r12), %ebp
addq $0xf, %r12
shrq $0x4, %r12
movl %ebp, %eax
cltd
idivl %r12d
movl %eax, %r14d
movl %edx, %r15d
movl %ecx, %r13d
negl %r13d
movq 0x58(%rsp), %rdx
movl 0x20(%rdx), %eax
movl %eax, %esi
negb %sil
cmpl %r13d, %eax
movzbl %sil, %eax
movl %ecx, 0x8(%rsp)
cmovgl %ecx, %eax
movl %eax, 0x40(%rsp)
movb $0x7e, %al
subb 0x1c(%rdx), %al
movb %al, 0x70(%rsp)
movl $0x10, %edx
movl $0x10, %ecx
movl %r12d, %edi
movl %r9d, %esi
movq %r9, 0x28(%rsp)
callq 0x2097d1
testq %rax, %rax
je 0x38b75f
movq %rax, %rbx
movl %r15d, 0x3c(%rsp)
movl %r14d, 0x20(%rsp)
movl %ebp, 0x38(%rsp)
orl $0x10180401, 0xc(%rax)  # imm = 0x10180401
movl $0x10, %edi
movq %r12, %rsi
callq 0x2ea474
movq %rax, %r15
movq 0x28(%rsp), %rax
leal 0x1(%rax), %esi
movl $0x10, %edi
movq %rsi, 0x88(%rsp)
callq 0x2094c8
movq %rax, 0x10(%rsp)
movl $0x10, %edi
movq %r12, %rsi
callq 0x2ea474
movq %rax, %rbp
movl $0x10, %edi
movq %r12, %rsi
callq 0x2ea474
movq %rax, %r14
movl $0x10, %edi
movq %r12, %rsi
callq 0x2ea474
testq %r15, %r15
sete %cl
cmpq $0x0, 0x10(%rsp)
sete %dl
orb %cl, %dl
testq %rbp, %rbp
sete %cl
testq %r14, %r14
sete %sil
orb %cl, %sil
orb %dl, %sil
testq %rax, %rax
sete %cl
orb %sil, %cl
jne 0x38b75f
movq 0x28(%rsp), %rcx
decl %ecx
movl %ecx, 0x1c(%rsp)
movl $0xf, %ecx
subl 0x20(%rsp), %ecx
movl %ecx, 0x34(%rsp)
movl 0x8(%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, %xmm2      # xmm2 = xmm0[0,0,0,0]
movl 0x24(%rsp), %edx
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, %xmm3      # xmm3 = xmm0[0,0,0,0]
movl 0x40(%rsp), %ecx
addb $-0x7f, %cl
movzbl %cl, %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, 0x40(%rsp)
movzbl 0x70(%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, %xmm6      # xmm6 = xmm0[0,0,0,0]
movl %r12d, %ecx
imull %edx, %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, %xmm5      # xmm5 = xmm0[0,0,0,0]
pslldq $0x1, %xmm5             # xmm5 = zero,xmm5[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movdqa %xmm1, 0x70(%rsp)
paddsb %xmm1, %xmm5
movl %esi, %ecx
movl %edx, %esi
movslq %r13d, %rdx
movl %r12d, %r9d
negq %rcx
movq %r9, 0x8(%rsp)
movq %rsi, 0x60(%rsp)
imulq %rsi, %r9
xorl %r10d, %r10d
movq $-0x80, %r11
movq %rdx, %r8
xorl %esi, %esi
cmpq $-0x7f, %r8
movq $-0x80, %rdi
cmovgeq %r8, %rdi
movb %dil, 0xb0(%rsp,%rsi)
leaq (%rcx,%r8), %rdi
cmpq $-0x7f, %rdi
cmovlq %r11, %rdi
movb %dil, 0xa0(%rsp,%rsi)
incq %rsi
subq %r9, %r8
cmpq $0x10, %rsi
jne 0x38b22e
movq %r10, %rsi
shlq $0x4, %rsi
movaps 0xb0(%rsp), %xmm0
movaps %xmm0, (%r14,%rsi)
movdqa 0xa0(%rsp), %xmm0
movdqa %xmm0, (%r15,%rsi)
incq %r10
subq 0x60(%rsp), %rdx
cmpq 0x8(%rsp), %r10
jne 0x38b229
movq 0x10(%rsp), %rsi
movb $0x0, (%rsi)
movl $0x1, %ecx
movl 0x24(%rsp), %edi
movq 0x88(%rsp), %r8
cmpl $-0x7f, %r13d
movl $0xffffff80, %edx       # imm = 0xFFFFFF80
cmovgel %r13d, %edx
movb %dl, (%rsi,%rcx)
incq %rcx
subl %edi, %r13d
cmpq %rcx, %r8
jne 0x38b2b0
pxor %xmm0, %xmm0
psubsb %xmm2, %xmm0
leal -0x1(%r12), %ecx
movq %rcx, %rsi
shlq $0x4, %rsi
movq %rax, %rdx
addq %rsi, %rdx
movl %r12d, %esi
movq 0x28(%rsp), %r9
movdqa %xmm0, (%rdx)
psubsb %xmm3, %xmm0
addq $-0x10, %rdx
decl %esi
jg 0x38b2ed
movl %ecx, %ecx
shlq $0x4, %rcx
movq %r14, %rdi
addq %rcx, %rdi
cmpl $0x1, %r12d
adcl $0x0, %r12d
cmpl $0x2, %r9d
movl $0x1, %r8d
cmovgel %r9d, %r8d
movq 0x8(%rsp), %r9
shlq $0x4, %r9
shlq $0x4, %r12
xorl %r10d, %r10d
movdqa 0x26a748(%rip), %xmm10  # 0x5f5a80
movdqa 0x26c32f(%rip), %xmm12  # 0x5f7670
movdqa 0x20ae46(%rip), %xmm13  # 0x596190
movdqa 0x20ae5d(%rip), %xmm9   # 0x5961b0
xorl %r11d, %r11d
movdqa 0x40(%rsp), %xmm7
movdqa %xmm6, 0x60(%rsp)
movq 0x90(%rsp), %rsi
movdqa %xmm9, %xmm14
movdqa (%rdi), %xmm0
pslldq $0x1, %xmm0             # xmm0 = zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movq 0x10(%rsp), %rcx
movzbl (%rcx,%r11), %ecx
movd %ecx, %xmm1
movdqa %xmm10, %xmm15
pandn %xmm1, %xmm15
por %xmm0, %xmm15
movq 0x58(%rsp), %rcx
movq 0x10(%rcx), %rcx
movzbl (%rsi,%r11), %edx
movslq (%rcx,%rdx,4), %r13
imulq 0x8(%rsp), %r13
shlq $0x4, %r13
addq 0x98(%rsp), %r13
movdqa 0x40(%rsp), %xmm1
movdqa %xmm1, %xmm0
psubsb (%rax), %xmm0
xorl %ecx, %ecx
movdqa (%r14,%rcx), %xmm10
movdqa (%r15,%rcx), %xmm9
movdqa %xmm10, %xmm8
psubsb %xmm2, %xmm8
psubsb %xmm3, %xmm9
movdqa %xmm8, %xmm4
pcmpgtb %xmm9, %xmm4
movdqa %xmm4, %xmm11
pand %xmm12, %xmm11
pxor %xmm13, %xmm11
movq 0x10(%rbx), %rdx
movq (%rdx), %rdx
addq %r10, %rdx
paddsb (%rax,%rcx), %xmm0
paddsb (%r13,%rcx), %xmm15
movdqa %xmm11, (%rcx,%rdx)
pand %xmm4, %xmm8
pandn %xmm9, %xmm4
por %xmm8, %xmm4
movdqa %xmm6, %xmm8
pcmpgtb %xmm4, %xmm8
movdqa %xmm1, %xmm9
pcmpgtb %xmm0, %xmm1
pand %xmm1, %xmm9
pandn %xmm0, %xmm1
movdqa %xmm4, %xmm0
movdqa %xmm4, %xmm11
movdqa %xmm4, (%r15,%rcx)
pand %xmm8, %xmm4
pandn %xmm6, %xmm8
movdqa %xmm8, %xmm6
por %xmm4, %xmm6
por %xmm9, %xmm1
pcmpgtb %xmm15, %xmm0
pand %xmm0, %xmm11
pandn %xmm15, %xmm0
por %xmm11, %xmm0
movdqa %xmm0, (%rbp,%rcx)
movdqa %xmm15, (%r14,%rcx)
addq $0x10, %rcx
movdqa %xmm10, %xmm15
cmpq %rcx, %r12
jne 0x38b3c9
pslldq $0x1, %xmm0             # xmm0 = zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movq 0x10(%rsp), %rcx
movzbl 0x1(%rcx,%r11), %ecx
incq %r11
movd %ecx, %xmm4
movdqa 0x26a5c3(%rip), %xmm10  # 0x5f5a80
movdqa %xmm10, %xmm8
pandn %xmm4, %xmm8
por %xmm0, %xmm8
movdqa (%rax), %xmm0
paddsb %xmm8, %xmm0
movdqa %xmm1, %xmm15
pcmpgtb %xmm0, %xmm15
pand %xmm15, %xmm1
pandn %xmm0, %xmm15
por %xmm1, %xmm15
movl $0xe, %ecx
movdqa %xmm15, %xmm0
movdqa %xmm15, %xmm1
pslldq $0x1, %xmm15            # xmm15 = zero,xmm15[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
paddsb %xmm5, %xmm15
pcmpgtb %xmm15, %xmm0
pand %xmm0, %xmm1
pandn %xmm15, %xmm0
movdqa %xmm0, %xmm15
por %xmm1, %xmm15
decl %ecx
jne 0x38b4f3
pslldq $0x1, %xmm15            # xmm15 = zero,xmm15[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
paddsb 0x70(%rsp), %xmm15
movdqa %xmm15, %xmm1
pcmpgtb %xmm8, %xmm1
movdqa %xmm15, %xmm0
pand %xmm1, %xmm0
pandn %xmm8, %xmm1
por %xmm0, %xmm1
xorl %r13d, %r13d
movdqa 0x26c127(%rip), %xmm13  # 0x5f7680
movdqa %xmm14, %xmm9
movdqa 0x20abe9(%rip), %xmm12  # 0x596150
movdqa 0x20ac00(%rip), %xmm11  # 0x596170
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq %r10, %rcx
movdqa (%rbp,%r13), %xmm0
psubsb %xmm2, %xmm1
psubsb %xmm3, %xmm15
movdqa %xmm1, %xmm4
pcmpgtb %xmm15, %xmm4
movdqa %xmm4, %xmm8
pandn %xmm15, %xmm8
pand %xmm4, %xmm1
movdqa %xmm1, %xmm15
por %xmm8, %xmm15
pand %xmm13, %xmm4
pxor %xmm9, %xmm4
movdqa %xmm0, %xmm1
pcmpgtb %xmm15, %xmm1
movdqa %xmm1, %xmm8
pandn %xmm15, %xmm8
pand %xmm1, %xmm0
por %xmm8, %xmm0
movdqa (%r14,%r13), %xmm8
pcmpeqb %xmm0, %xmm8
paddb %xmm12, %xmm1
movdqa %xmm8, %xmm9
pandn %xmm1, %xmm9
pand %xmm11, %xmm8
por %xmm9, %xmm8
movdqa %xmm14, %xmm9
por (%r13,%rcx), %xmm4
por %xmm8, %xmm4
movdqa %xmm4, (%r13,%rcx)
movdqa %xmm0, (%r14,%r13)
movdqa %xmm6, %xmm4
pcmpgtb %xmm0, %xmm4
movdqa %xmm7, %xmm8
pcmpgtb %xmm0, %xmm7
pand %xmm7, %xmm8
pandn %xmm0, %xmm7
movdqa %xmm0, %xmm1
pand %xmm4, %xmm0
pandn %xmm6, %xmm4
por %xmm0, %xmm4
movdqa %xmm4, %xmm6
pcmpgtb %xmm15, %xmm6
movdqa %xmm15, %xmm0
pand %xmm6, %xmm0
pandn %xmm4, %xmm6
por %xmm0, %xmm6
por %xmm8, %xmm7
addq $0x10, %r13
cmpq %r13, %r12
jne 0x38b570
addq %r9, %r10
cmpq %r8, %r11
movdqa 0x26bff8(%rip), %xmm12  # 0x5f7670
movdqa 0x20ab0f(%rip), %xmm13  # 0x596190
jne 0x38b36a
movl 0x3c(%rsp), %ecx
shlq $0x4, %rcx
movdqa (%r14,%rcx), %xmm0
cmpl $0xe, 0x20(%rsp)
jg 0x38b6ba
movl 0x34(%rsp), %edx
cmpl $0x2, %edx
movl $0x1, %ecx
cmovgel %edx, %ecx
movl 0x1c(%rsp), %esi
pslldq $0x1, %xmm0             # xmm0 = zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
decl %ecx
jne 0x38b6af
jmp 0x38b6be
movl 0x1c(%rsp), %esi
movdqa 0x40(%rsp), %xmm1
pcmpgtb %xmm6, %xmm1
pcmpgtb 0x60(%rsp), %xmm7
por %xmm1, %xmm7
pmovmskb %xmm7, %ecx
testl %ecx, %ecx
je 0x38b6e6
orb $0x40, 0xc(%rbx)
xorl %ecx, %ecx
xorl %esi, %esi
xorl %edx, %edx
jmp 0x38b6f2
pextrw $0x7, %xmm0, %ecx
shrl $0x8, %ecx
movl 0x38(%rsp), %edx
movsbl %cl, %ecx
movl %ecx, (%rbx)
movl %edx, 0x4(%rbx)
movl %esi, 0x8(%rbx)
movq %rax, %rdi
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
movq %rbp, %rdi
callq 0x2094b5
movq 0x10(%rsp), %rdi
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
jmp 0x38b761
callq 0x1bd577
jmp 0x38b75f
callq 0x1bd551
jmp 0x38b75f
callq 0x1bd52b
jmp 0x38b75f
callq 0x1bd505
jmp 0x38b75f
callq 0x1bd4df
jmp 0x38b75f
callq 0x1bd4b9
jmp 0x38b75f
callq 0x1bd493
jmp 0x38b75f
callq 0x1bd46d
xorl %ebx, %ebx
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop