// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_trace_scan_sse2_128_8.c
// Function: parasail_sw_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 end_query = 0;
    int32_t end_ref = 0;
    int32_t s1Len = 0;
    const parasail_matrix_t *matrix = NULL;
    int32_t segWidth = 0;
    int32_t segLen = 0;
    __m128i* restrict pvP = NULL;
    __m128i* restrict pvE = NULL;
    __m128i* restrict pvHt = NULL;
    __m128i* restrict pvH = NULL;
    __m128i* restrict pvHMax = 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 vMaxHUnit;
    __m128i vNegInfFront;
    __m128i vSegLenXgap;
    parasail_result_t *result = NULL;
    __m128i vTZero;
    __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;
    end_query = 0;
    end_ref = 0;
    s1Len = profile->s1Len;
    matrix = profile->matrix;
    segWidth = 16; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    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;
    vMaxHUnit = vNegLimit;
    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));
    vTZero = _mm_set1_epi8(PARASAIL_ZERO);
    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_SW | PARASAIL_FLAG_SCAN
        | PARASAIL_FLAG_TRACE
        | PARASAIL_FLAG_BITS_8 | PARASAIL_FLAG_LANES_16;

    /* initialize heap variables */
    pvE    = parasail_memalign___m128i(16, segLen);
    pvHt   = parasail_memalign___m128i(16, segLen);
    pvH    = parasail_memalign___m128i(16, segLen);
    pvHMax = parasail_memalign___m128i(16, segLen);
    pvGapper = parasail_memalign___m128i(16, segLen);

    /* validate heap variables */
    if (!pvE) return NULL;
    if (!pvHt) return NULL;
    if (!pvH) return NULL;
    if (!pvHMax) return NULL;
    if (!pvGapper) return NULL;

    parasail_memset___m128i(pvH, vZero, segLen);
    parasail_memset___m128i(pvE, vNegLimit, segLen);
    {
        __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 case0;
        __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);
        pvW = pvP + matrix->mapper[(unsigned char)s2[j]]*segLen;
        vHt = vZero;
        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);
            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);
        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);
        vH = _mm_max_epi8_rpl(vH, vZero);
        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);
            vH = _mm_max_epi8_rpl(vH, vZero);
            case0 = _mm_cmpeq_epi8(vH, vZero);
            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_blendv_epi8_rpl(vT, vTZero, case0);
            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);
            vSaturationCheckMax = _mm_max_epi8_rpl(vSaturationCheckMax, vH);
            {
                vMaxH = _mm_max_epi8_rpl(vH, vMaxH);
            }
        } 

        {
            __m128i vCompare = _mm_cmpgt_epi8(vMaxH, vMaxHUnit);
            if (_mm_movemask_epi8(vCompare)) {
                score = _mm_hmax_epi8_rpl(vMaxH);
                vMaxHUnit = _mm_set1_epi8(score);
                end_ref = j;
                (void)memcpy(pvHMax, pvH, sizeof(__m128i)*segLen);
            }
        }
    }

    /* Trace the alignment ending position on read. */
    {
        int8_t *t = (int8_t*)pvHMax;
        int32_t column_len = segLen * segWidth;
        end_query = s1Len;
        for (i = 0; i<column_len; ++i, ++t) {
            if (*t == score) {
                int32_t temp = i / segWidth + i % segWidth * segLen;
                if (temp < end_query) {
                    end_query = temp;
                }
            }
        }
    }

    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(pvHMax);
    parasail_free(pvH);
    parasail_free(pvHt);
    parasail_free(pvE);

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rsi, 0x38(%rsp)
testq %rdi, %rdi
je 0x38cd30
movq 0x18(%rdi), %rax
movq %rax, 0xb0(%rsp)
testq %rax, %rax
je 0x38cd37
movq 0x10(%rdi), %rax
movq %rax, 0x30(%rsp)
testq %rax, %rax
je 0x38cd3e
movl 0x8(%rdi), %eax
testl %eax, %eax
jle 0x38cd45
cmpq $0x0, 0x38(%rsp)
je 0x38cd4c
movl %edx, %r15d
testl %edx, %edx
jle 0x38cd53
testl %ecx, %ecx
js 0x38cd5a
movl %r8d, %r13d
testl %r8d, %r8d
js 0x38cd61
movq %rax, 0x20(%rsp)
leaq 0xf(%rax), %r14
movq %r14, %r12
shrq $0x4, %r12
movl %ecx, %eax
negl %eax
movq 0x30(%rsp), %rsi
movl 0x20(%rsi), %edi
movl %edi, %edx
negb %dl
cmpl %eax, %edi
movzbl %dl, %ebp
movl %ecx, 0x60(%rsp)
cmovgl %ecx, %ebp
movb $0x7e, %al
subb 0x1c(%rsi), %al
movb %al, 0x10(%rsp)
movl $0x10, %edx
movl $0x10, %ecx
movl %r12d, %edi
movl %r15d, %esi
callq 0x2097d1
testq %rax, %rax
je 0x38cd66
movq %rax, %rbx
movl %r13d, 0x70(%rsp)
movl %r15d, 0x50(%rsp)
movq %r14, 0x88(%rsp)
movl %ebp, 0x4(%rsp)
orl $0x10180404, 0xc(%rax)  # imm = 0x10180404
movl $0x10, %edi
movq %r12, %rsi
callq 0x2ea474
movq %rax, %r14
movl $0x10, %edi
movq %r12, %rsi
callq 0x2ea474
movq %rax, %r15
movl $0x10, %edi
movq %r12, %rsi
callq 0x2ea474
movq %rax, %r13
movl $0x10, %edi
movq %r12, %rsi
callq 0x2ea474
movq %rax, %rbp
movl $0x10, %edi
movq %r12, %rsi
callq 0x2ea474
testq %r14, %r14
sete %dl
testq %r15, %r15
sete %cl
orb %dl, %cl
testq %r13, %r13
sete %sil
movq %rbp, 0x8(%rsp)
testq %rbp, %rbp
sete %dl
orb %sil, %dl
orb %cl, %dl
testq %rax, %rax
sete %cl
orb %dl, %cl
jne 0x38cd66
movd 0x60(%rsp), %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, 0xe0(%rsp)
movl 0x70(%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, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0xd0(%rsp)
movl 0x4(%rsp), %ecx
addb $-0x7f, %cl
movl %ecx, 0x4(%rsp)
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 0x10(%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, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0xc0(%rsp)
imull %r12d, %edx
negb %dl
movzbl %dl, %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, %xmm0      # xmm0 = xmm0[0,0,0,0]
pslldq $0x1, %xmm0             # xmm0 = zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movdqa %xmm1, 0xf0(%rsp)
paddsb %xmm1, %xmm0
movdqa %xmm0, 0x10(%rsp)
pxor %xmm0, %xmm0
movq %r13, %rdi
movq %r12, %rsi
movq %rax, 0x28(%rsp)
callq 0x2ea47d
movq %r14, %rdi
movdqa 0x40(%rsp), %xmm0
movq %r12, %rsi
callq 0x2ea47d
pxor %xmm0, %xmm0
movdqa 0xd0(%rsp), %xmm9
movdqa 0xe0(%rsp), %xmm8
movq 0x28(%rsp), %rdi
leal -0x1(%r12), %eax
psubsb %xmm8, %xmm0
movq %rax, %rcx
shlq $0x4, %rcx
addq %rdi, %rcx
movl %r12d, %edx
movdqa %xmm0, (%rcx)
psubsb %xmm9, %xmm0
addq $-0x10, %rcx
decl %edx
jg 0x38c7c7
movl %eax, %eax
shlq $0x4, %rax
movq %r13, %rcx
addq %rax, %rcx
movq %rcx, 0xa8(%rsp)
movq %r12, %r8
shlq $0x4, %r8
cmpl $0x1, %r12d
movq %r12, %rax
movl %eax, %ebp
adcl $0x0, %ebp
movl 0x50(%rsp), %edx
cmpl $0x2, %edx
movl $0x1, %ecx
cmovgel %edx, %ecx
movq %rcx, 0xa0(%rsp)
shlq $0x4, %rbp
xorl %r12d, %r12d
movq %rax, 0x80(%rsp)
movl %eax, %eax
movq %rax, 0x98(%rsp)
xorl %r9d, %r9d
xorl %eax, %eax
movdqa 0xc0(%rsp), %xmm11
movdqa 0x40(%rsp), %xmm0
movdqa %xmm0, %xmm12
movdqa %xmm0, %xmm10
movdqa %xmm0, 0x50(%rsp)
movdqa 0x10(%rsp), %xmm13
movq %r8, 0x90(%rsp)
movq 0x30(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x38(%rsp), %rdx
movzbl (%rdx,%r9), %edx
movslq (%rcx,%rdx,4), %rcx
imulq 0x98(%rsp), %rcx
shlq $0x4, %rcx
addq 0xb0(%rsp), %rcx
movq 0xa8(%rsp), %rdx
movdqa (%rdx), %xmm0
pslldq $0x1, %xmm0             # xmm0 = zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
xorl %edx, %edx
movdqa 0x40(%rsp), %xmm2
pxor %xmm1, %xmm1
movdqa (%r13,%rdx), %xmm3
movdqa (%r14,%rdx), %xmm5
movdqa %xmm3, %xmm6
psubsb %xmm8, %xmm6
psubsb %xmm9, %xmm5
movdqa %xmm6, %xmm4
pcmpgtb %xmm5, %xmm4
movdqa %xmm4, %xmm7
pand 0x26ad95(%rip), %xmm7   # 0x5f7670
pxor 0x2098ad(%rip), %xmm7   # 0x596190
movq 0x10(%rbx), %rsi
movq (%rsi), %rsi
paddsb (%rdi,%rdx), %xmm1
paddsb (%rcx,%rdx), %xmm0
addq %r12, %rsi
movdqa %xmm7, (%rdx,%rsi)
pand %xmm4, %xmm6
pandn %xmm5, %xmm4
por %xmm6, %xmm4
movdqa %xmm2, %xmm5
pcmpgtb %xmm1, %xmm2
pand %xmm2, %xmm5
pandn %xmm1, %xmm2
por %xmm5, %xmm2
movdqa %xmm4, %xmm1
pcmpgtb %xmm0, %xmm1
movdqa %xmm4, (%r14,%rdx)
pand %xmm1, %xmm4
pandn %xmm0, %xmm1
por %xmm4, %xmm1
movdqa %xmm1, (%r15,%rdx)
movdqa %xmm0, (%r13,%rdx)
addq $0x10, %rdx
movdqa %xmm3, %xmm0
cmpq %rdx, %rbp
jne 0x38c8ac
pslldq $0x1, %xmm1             # xmm1 = zero,xmm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movdqa (%rdi), %xmm3
paddsb %xmm1, %xmm3
movdqa %xmm2, %xmm0
pcmpgtb %xmm3, %xmm0
pand %xmm0, %xmm2
pandn %xmm3, %xmm0
por %xmm2, %xmm0
movl $0xe, %ecx
movdqa %xmm0, %xmm2
movdqa %xmm0, %xmm3
pslldq $0x1, %xmm0             # xmm0 = zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
paddsb %xmm13, %xmm0
pcmpgtb %xmm0, %xmm2
pand %xmm2, %xmm3
pandn %xmm0, %xmm2
movdqa %xmm2, %xmm0
por %xmm3, %xmm0
decl %ecx
jne 0x38c97a
pslldq $0x1, %xmm0             # xmm0 = zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
paddsb 0xf0(%rsp), %xmm0
movdqa %xmm0, %xmm2
pcmpgtb %xmm1, %xmm2
movdqa %xmm0, %xmm3
pand %xmm2, %xmm3
pandn %xmm1, %xmm2
por %xmm3, %xmm2
movdqa %xmm2, %xmm1
pcmpgtb 0x2098ba(%rip), %xmm1   # 0x596290
pand %xmm2, %xmm1
xorl %ecx, %ecx
movdqa 0x26ac9c(%rip), %xmm7   # 0x5f7680
movdqa 0x2097c3(%rip), %xmm13  # 0x5961b0
movdqa 0x20995a(%rip), %xmm14  # 0x596350
movdqa 0x209771(%rip), %xmm15  # 0x596170
movdqa (%r15,%rcx), %xmm3
psubsb %xmm8, %xmm1
psubsb %xmm9, %xmm0
movdqa %xmm1, %xmm2
pcmpgtb %xmm0, %xmm2
movdqa %xmm2, %xmm4
pandn %xmm0, %xmm4
pand %xmm2, %xmm1
movdqa %xmm1, %xmm0
por %xmm4, %xmm0
movdqa %xmm3, %xmm1
pcmpgtb %xmm0, %xmm1
pand %xmm1, %xmm3
pandn %xmm0, %xmm1
por %xmm3, %xmm1
movdqa %xmm1, %xmm3
pcmpgtb 0x209845(%rip), %xmm3   # 0x596290
pand %xmm3, %xmm1
movdqa (%r13,%rcx), %xmm4
pcmpeqb %xmm1, %xmm4
movdqa %xmm1, %xmm5
pcmpeqb %xmm0, %xmm5
movdqa %xmm14, %xmm6
psubb %xmm5, %xmm6
movdqa %xmm4, %xmm5
pandn %xmm6, %xmm5
pand %xmm15, %xmm4
por %xmm5, %xmm4
pand %xmm3, %xmm4
movq 0x10(%rbx), %rdx
movq (%rdx), %rdx
addq %r12, %rdx
pand %xmm7, %xmm2
pxor %xmm13, %xmm2
por (%rcx,%rdx), %xmm2
por %xmm4, %xmm2
movdqa %xmm2, (%rcx,%rdx)
movdqa %xmm11, %xmm2
pcmpgtb %xmm1, %xmm2
movdqa %xmm1, %xmm3
pand %xmm2, %xmm3
pandn %xmm11, %xmm2
movdqa %xmm2, %xmm11
por %xmm3, %xmm11
movdqa %xmm12, %xmm2
movdqa %xmm12, %xmm3
pcmpgtb %xmm1, %xmm3
pand %xmm3, %xmm2
pandn %xmm1, %xmm3
movdqa %xmm3, %xmm12
por %xmm2, %xmm12
movdqa %xmm1, %xmm2
pcmpgtb %xmm10, %xmm2
movdqa %xmm1, %xmm3
pand %xmm2, %xmm3
pandn %xmm10, %xmm2
movdqa %xmm2, %xmm10
por %xmm3, %xmm10
movdqa %xmm1, (%r13,%rcx)
addq $0x10, %rcx
cmpq %rcx, %rbp
jne 0x38c9ff
movdqa %xmm10, %xmm0
pcmpgtb 0x50(%rsp), %xmm0
pmovmskb %xmm0, %ecx
testl %ecx, %ecx
movdqa 0x10(%rsp), %xmm13
je 0x38cc52
movdqa %xmm10, %xmm0
psrldq $0x8, %xmm0             # xmm0 = xmm0[8,9,10,11,12,13,14,15],zero,zero,zero,zero,zero,zero,zero,zero
movdqa %xmm10, %xmm1
pcmpgtb %xmm0, %xmm1
movdqa %xmm10, 0x60(%rsp)
movdqa 0x60(%rsp), %xmm2
pand %xmm1, %xmm2
pandn %xmm0, %xmm1
por %xmm2, %xmm1
movdqa %xmm1, %xmm0
psrldq $0x4, %xmm0             # xmm0 = xmm0[4,5,6,7,8,9,10,11,12,13,14,15],zero,zero,zero,zero
movdqa %xmm1, %xmm2
pcmpgtb %xmm0, %xmm2
pand %xmm2, %xmm1
pandn %xmm0, %xmm2
por %xmm1, %xmm2
movdqa %xmm2, %xmm0
psrldq $0x2, %xmm0             # xmm0 = xmm0[2,3,4,5,6,7,8,9,10,11,12,13,14,15],zero,zero
movdqa %xmm2, %xmm1
pcmpgtb %xmm0, %xmm1
pand %xmm1, %xmm2
pandn %xmm0, %xmm1
por %xmm2, %xmm1
movdqa %xmm1, %xmm0
psrldq $0x1, %xmm0             # xmm0 = xmm0[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],zero
movdqa %xmm1, %xmm2
pcmpgtb %xmm0, %xmm2
pand %xmm2, %xmm1
pandn %xmm0, %xmm2
por %xmm1, %xmm2
movdqa %xmm2, 0x110(%rsp)
movb 0x110(%rsp), %al
movl %eax, 0x4(%rsp)
punpcklbw %xmm2, %xmm2    # xmm2 = xmm2[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm2, %xmm0      # xmm0 = xmm2[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x50(%rsp)
movq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r8, %rdx
movdqa %xmm11, 0x70(%rsp)
movdqa %xmm12, 0x100(%rsp)
movq %r9, 0xb8(%rsp)
callq 0x19e0c0
movdqa 0x60(%rsp), %xmm10
movq 0xb8(%rsp), %r9
movq 0x90(%rsp), %r8
movdqa 0x100(%rsp), %xmm12
movdqa 0x70(%rsp), %xmm11
movdqa 0x10(%rsp), %xmm13
movdqa 0xd0(%rsp), %xmm9
movdqa 0xe0(%rsp), %xmm8
movq 0x28(%rsp), %rdi
movl %r9d, %eax
incq %r9
addq %r8, %r12
cmpq 0xa0(%rsp), %r9
jne 0x38c863
testl $0x7ffffff0, 0x88(%rsp) # imm = 0x7FFFFFF0
je 0x38ccc1
movq 0x80(%rsp), %r9
movl %r9d, %ecx
andl $0x7ffffff, %ecx        # imm = 0x7FFFFFF
shll $0x4, %ecx
xorl %edx, %edx
movq 0x20(%rsp), %r8
movl 0x4(%rsp), %r10d
movq 0x8(%rsp), %rsi
cmpb %r10b, (%rsi,%rdx)
jne 0x38ccb8
movl %edx, %esi
shrl $0x4, %esi
movl %edx, %r11d
andl $0xf, %r11d
imull %r9d, %r11d
addl %esi, %r11d
cmpl %r8d, %r11d
cmovll %r11d, %r8d
incq %rdx
cmpl %edx, %ecx
jne 0x38cc93
jmp 0x38cccb
movq 0x20(%rsp), %r8
movl 0x4(%rsp), %r10d
movdqa 0x40(%rsp), %xmm0
pcmpgtb %xmm11, %xmm0
pcmpgtb 0xc0(%rsp), %xmm12
por %xmm0, %xmm12
pmovmskb %xmm12, %ecx
testl %ecx, %ecx
je 0x38ccfa
orb $0x40, 0xc(%rbx)
xorl %r10d, %r10d
xorl %eax, %eax
xorl %r8d, %r8d
movsbl %r10b, %ecx
movl %ecx, (%rbx)
movl %r8d, 0x4(%rbx)
movl %eax, 0x8(%rbx)
callq 0x2094b5
movq 0x8(%rsp), %rdi
callq 0x2094b5
movq %r13, %rdi
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
jmp 0x38cd68
callq 0x1bd9eb
jmp 0x38cd66
callq 0x1bd9c5
jmp 0x38cd66
callq 0x1bd99f
jmp 0x38cd66
callq 0x1bd979
jmp 0x38cd66
callq 0x1bd953
jmp 0x38cd66
callq 0x1bd92d
jmp 0x38cd66
callq 0x1bd907
jmp 0x38cd66
callq 0x1bd8e1
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)