// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_trace_striped_sse2_128_8.c
// Function: parasail_nw_trace_striped_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 vProfile = NULL;
    __m128i* restrict pvHStore = NULL;
    __m128i* restrict pvHLoad = NULL;
    __m128i* restrict pvE = NULL;
    __m128i* restrict pvEaStore = NULL;
    __m128i* restrict pvEaLoad = NULL;
    __m128i* restrict pvHT = NULL;
    int8_t* restrict boundary = NULL;
    __m128i vGapO;
    __m128i vGapE;
    int8_t NEG_LIMIT = 0;
    int8_t POS_LIMIT = 0;
    int8_t score = 0;
    __m128i vNegLimit;
    __m128i vPosLimit;
    __m128i vSaturationCheckMin;
    __m128i vSaturationCheckMax;
    parasail_result_t *result = NULL;
    __m128i vTIns;
    __m128i vTDel;
    __m128i vTDiag;
    __m128i vTDiagE;
    __m128i vTInsE;
    __m128i vTDiagF;
    __m128i vTDelF;
    __m128i vTMask;
    __m128i vFTMask;

    /* 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;
    vProfile = (__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;
    score = NEG_LIMIT;
    vNegLimit = _mm_set1_epi8(NEG_LIMIT);
    vPosLimit = _mm_set1_epi8(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    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);
    vTMask = _mm_set1_epi8(PARASAIL_ZERO_MASK);
    vFTMask = _mm_set1_epi8(PARASAIL_F_MASK);

    /* 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_STRIPED
        | PARASAIL_FLAG_TRACE
        | PARASAIL_FLAG_BITS_8 | PARASAIL_FLAG_LANES_16;

    /* initialize heap variables */
    pvHStore = parasail_memalign___m128i(16, segLen);
    pvHLoad = parasail_memalign___m128i(16, segLen);
    pvE = parasail_memalign___m128i(16, segLen);
    pvEaStore = parasail_memalign___m128i(16, segLen);
    pvEaLoad = parasail_memalign___m128i(16, segLen);
    pvHT = parasail_memalign___m128i(16, segLen);
    boundary = parasail_memalign_int8_t(16, s2Len+1);

    /* validate heap variables */
    if (!pvHStore) return NULL;
    if (!pvHLoad) return NULL;
    if (!pvE) return NULL;
    if (!pvEaStore) return NULL;
    if (!pvEaLoad) return NULL;
    if (!pvHT) return NULL;
    if (!boundary) 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(&pvHStore[index], h.m);
            _mm_store_si128(&pvE[index], e.m);
            _mm_store_si128(&pvEaStore[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;
        }
    }

    for (i=0; i<segLen; ++i) {
        arr_store(result->trace->trace_table, vTDiagE, i, segLen, 0);
    }

    /* outer loop over database sequence */
    for (j=0; j<s2Len; ++j) {
        __m128i vEF_opn;
        __m128i vE;
        __m128i vE_ext;
        __m128i vF;
        __m128i vF_ext;
        __m128i vFa;
        __m128i vFa_ext;
        __m128i vH;
        __m128i vH_dag;
        const __m128i* vP = NULL;

        /* Initialize F value to -inf.  Any errors to vH values will be
         * corrected in the Lazy_F loop.  */
        vF = vNegLimit;

        /* load final segment of pvHStore and shift left by 1 bytes */
        vH = _mm_load_si128(&pvHStore[segLen - 1]);
        vH = _mm_slli_si128(vH, 1);

        /* insert upper boundary condition */
        vH = _mm_insert_epi8_rpl(vH, boundary[j], 0);

        /* Correct part of the vProfile */
        vP = vProfile + matrix->mapper[(unsigned char)s2[j]] * segLen;

        /* Swap the 2 H buffers. */
        SWAP(pvHLoad, pvHStore)
        SWAP(pvEaLoad, pvEaStore)

        /* inner loop to process the query sequence */
        for (i=0; i<segLen; ++i) {
            vE = _mm_load_si128(pvE + i);

            /* Get max from vH, vE and vF. */
            vH_dag = _mm_adds_epi8(vH, _mm_load_si128(vP + i));
            vH = _mm_max_epi8_rpl(vH_dag, vE);
            vH = _mm_max_epi8_rpl(vH, vF);
            /* Save vH values. */
            _mm_store_si128(pvHStore + i, vH);
            vSaturationCheckMax = _mm_max_epi8_rpl(vSaturationCheckMax, vH);
            vSaturationCheckMin = _mm_min_epi8_rpl(vSaturationCheckMin, vH);
            vSaturationCheckMin = _mm_min_epi8_rpl(vSaturationCheckMin, vE);
            vSaturationCheckMin = _mm_min_epi8_rpl(vSaturationCheckMin, vF);

            {
                __m128i vTAll = arr_load(result->trace->trace_table, i, segLen, j);
                __m128i case1 = _mm_cmpeq_epi8(vH, vH_dag);
                __m128i case2 = _mm_cmpeq_epi8(vH, vF);
                __m128i vT = _mm_blendv_epi8_rpl(
                        _mm_blendv_epi8_rpl(vTIns, vTDel, case2),
                        vTDiag, case1);
                _mm_store_si128(pvHT + i, vT);
                vT = _mm_or_si128(vT, vTAll);
                arr_store(result->trace->trace_table, vT, i, segLen, j);
            }

            vEF_opn = _mm_subs_epi8(vH, vGapO);

            /* Update vE value. */
            vE_ext = _mm_subs_epi8(vE, vGapE);
            vE = _mm_max_epi8_rpl(vEF_opn, vE_ext);
            _mm_store_si128(pvE + i, vE);
            {
                __m128i vEa = _mm_load_si128(pvEaLoad + i);
                __m128i vEa_ext = _mm_subs_epi8(vEa, vGapE);
                vEa = _mm_max_epi8_rpl(vEF_opn, vEa_ext);
                _mm_store_si128(pvEaStore + i, vEa);
                if (j+1<s2Len) {
                    __m128i cond = _mm_cmpgt_epi8(vEF_opn, vEa_ext);
                    __m128i vT = _mm_blendv_epi8_rpl(vTInsE, vTDiagE, cond);
                    arr_store(result->trace->trace_table, vT, i, segLen, j+1);
                }
            }

            /* Update vF value. */
            vF_ext = _mm_subs_epi8(vF, vGapE);
            vF = _mm_max_epi8_rpl(vEF_opn, vF_ext);
            if (i+1<segLen) {
                __m128i vTAll = arr_load(result->trace->trace_table, i+1, segLen, j);
                __m128i cond = _mm_cmpgt_epi8(vEF_opn, vF_ext);
                __m128i vT = _mm_blendv_epi8_rpl(vTDelF, vTDiagF, cond);
                vT = _mm_or_si128(vT, vTAll);
                arr_store(result->trace->trace_table, vT, i+1, segLen, j);
            }

            /* Load the next vH. */
            vH = _mm_load_si128(pvHLoad + i);
        }


        /* Lazy_F loop: has been revised to disallow adjecent insertion and
         * then deletion, so don't update E(i, i), learn from SWPS3 */
        vFa_ext = vF_ext;
        vFa = vF;
        for (k=0; k<segWidth; ++k) {
            int64_t tmp = boundary[j+1]-open;
            int8_t tmp2 = tmp < INT8_MIN ? INT8_MIN : tmp;
            __m128i vHp = _mm_load_si128(&pvHLoad[segLen - 1]);
            vHp = _mm_slli_si128(vHp, 1);
            vHp = _mm_insert_epi8_rpl(vHp, boundary[j], 0);
            vEF_opn = _mm_slli_si128(vEF_opn, 1);
            vEF_opn = _mm_insert_epi8_rpl(vEF_opn, tmp2, 0);
            vF_ext = _mm_slli_si128(vF_ext, 1);
            vF_ext = _mm_insert_epi8_rpl(vF_ext, NEG_LIMIT, 0);
            vF = _mm_slli_si128(vF, 1);
            vF = _mm_insert_epi8_rpl(vF, tmp2, 0);
            vFa_ext = _mm_slli_si128(vFa_ext, 1);
            vFa_ext = _mm_insert_epi8_rpl(vFa_ext, NEG_LIMIT, 0);
            vFa = _mm_slli_si128(vFa, 1);
            vFa = _mm_insert_epi8_rpl(vFa, tmp2, 0);
            for (i=0; i<segLen; ++i) {
                vH = _mm_load_si128(pvHStore + i);
                vH = _mm_max_epi8_rpl(vH,vF);
                _mm_store_si128(pvHStore + i, vH);
                vSaturationCheckMin = _mm_min_epi8_rpl(vSaturationCheckMin, vH);
                vSaturationCheckMax = _mm_max_epi8_rpl(vSaturationCheckMax, vH);
                {
                    __m128i vTAll;
                    __m128i vT;
                    __m128i case1;
                    __m128i case2;
                    __m128i cond;
                    vHp = _mm_adds_epi8(vHp, _mm_load_si128(vP + i));
                    case1 = _mm_cmpeq_epi8(vH, vHp);
                    case2 = _mm_cmpeq_epi8(vH, vF);
                    cond = _mm_andnot_si128(case1,case2);
                    vTAll = arr_load(result->trace->trace_table, i, segLen, j);
                    vT = _mm_load_si128(pvHT + i);
                    vT = _mm_blendv_epi8_rpl(vT, vTDel, cond);
                    _mm_store_si128(pvHT + i, vT);
                    vTAll = _mm_and_si128(vTAll, vTMask);
                    vTAll = _mm_or_si128(vTAll, vT);
                    arr_store(result->trace->trace_table, vTAll, i, segLen, j);
                }
                /* Update vF value. */
                {
                    __m128i vTAll = arr_load(result->trace->trace_table, i, segLen, j);
                    __m128i cond = _mm_cmpgt_epi8(vEF_opn, vFa_ext);
                    __m128i vT = _mm_blendv_epi8_rpl(vTDelF, vTDiagF, cond);
                    vTAll = _mm_and_si128(vTAll, vFTMask);
                    vTAll = _mm_or_si128(vTAll, vT);
                    arr_store(result->trace->trace_table, vTAll, i, segLen, j);
                }
                vEF_opn = _mm_subs_epi8(vH, vGapO);
                vF_ext = _mm_subs_epi8(vF, vGapE);
                {
                    __m128i vEa = _mm_load_si128(pvEaLoad + i);
                    __m128i vEa_ext = _mm_subs_epi8(vEa, vGapE);
                    vEa = _mm_max_epi8_rpl(vEF_opn, vEa_ext);
                    _mm_store_si128(pvEaStore + i, vEa);
                    if (j+1<s2Len) {
                        __m128i cond = _mm_cmpgt_epi8(vEF_opn, vEa_ext);
                        __m128i vT = _mm_blendv_epi8_rpl(vTInsE, vTDiagE, cond);
                        arr_store(result->trace->trace_table, vT, i, segLen, j+1);
                    }
                }
                if (! _mm_movemask_epi8(
                            _mm_or_si128(
                                _mm_cmpgt_epi8(vF_ext, vEF_opn),
                                _mm_cmpeq_epi8(vF_ext, vEF_opn))))
                    goto end;
                /*vF = _mm_max_epi8_rpl(vEF_opn, vF_ext);*/
                vF = vF_ext;
                vFa_ext = _mm_subs_epi8(vFa, vGapE);
                vFa = _mm_max_epi8_rpl(vEF_opn, vFa_ext);
                vHp = _mm_load_si128(pvHLoad + i);
            }
        }
end:
        {
        }
    }

    /* extract last value from the last column */
    {
        __m128i vH = _mm_load_si128(pvHStore + 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(boundary);
    parasail_free(pvHT);
    parasail_free(pvEaLoad);
    parasail_free(pvEaStore);
    parasail_free(pvE);
    parasail_free(pvHLoad);
    parasail_free(pvHStore);

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movl %ecx, 0xc(%rsp)
movq %rsi, 0x88(%rsp)
testq %rdi, %rdi
je 0x3bf048
movq 0x18(%rdi), %rax
movq %rax, 0xc8(%rsp)
testq %rax, %rax
je 0x3bf04f
movq 0x10(%rdi), %rax
movq %rax, 0x80(%rsp)
testq %rax, %rax
je 0x3bf056
movl 0x8(%rdi), %r15d
testl %r15d, %r15d
jle 0x3bf05d
cmpq $0x0, 0x88(%rsp)
je 0x3bf064
movl %r8d, %r13d
movl %edx, %r8d
testl %edx, %edx
jle 0x3bf06b
cmpl $0x0, 0xc(%rsp)
js 0x3bf072
testl %r13d, %r13d
js 0x3bf079
leal -0x1(%r15), %ebp
addq $0xf, %r15
shrq $0x4, %r15
movl %ebp, %eax
xorl %edx, %edx
divl %r15d
movl %eax, %r14d
movl %edx, %r12d
movl 0xc(%rsp), %edx
movl %edx, %edi
negl %edi
movq 0x80(%rsp), %rsi
movl 0x20(%rsi), %eax
movl %eax, %ecx
negb %cl
movl %edi, 0x30(%rsp)
cmpl %edi, %eax
movzbl %cl, %eax
cmovgl %edx, %eax
movl %eax, 0xb0(%rsp)
movb $0x7e, %al
subb 0x1c(%rsi), %al
movb %al, 0x70(%rsp)
movl $0x10, %edx
movl $0x10, %ecx
movl %r15d, %edi
movq %r8, 0x40(%rsp)
movl %r8d, %esi
callq 0x20adf4
testq %rax, %rax
je 0x3bf07e
movq %rax, %rbx
movq %r13, 0xc0(%rsp)
movl %r12d, 0x6c(%rsp)
movl %r14d, 0x2c(%rsp)
movl %ebp, 0x68(%rsp)
orl $0x10180801, 0xc(%rax)  # imm = 0x10180801
movl $0x10, %edi
movq %r15, %rsi
callq 0x2f600c
movq %rax, 0x18(%rsp)
movl $0x10, %edi
movq %r15, %rsi
callq 0x2f600c
movq %rax, %r12
movl $0x10, %edi
movq %r15, %rsi
callq 0x2f600c
movq %rax, %r13
movl $0x10, %edi
movq %r15, %rsi
callq 0x2f600c
movq %rax, 0x10(%rsp)
movl $0x10, %edi
movq %r15, %rsi
callq 0x2f600c
movq %rax, %rbp
movl $0x10, %edi
movq %r15, %rsi
callq 0x2f600c
movq %rax, %r14
movq 0x40(%rsp), %rax
leal 0x1(%rax), %esi
movl $0x10, %edi
callq 0x20a620
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %xmm0
movq %r12, 0x20(%rsp)
movq %r12, %xmm1
punpcklqdq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0]
movq %r13, 0x58(%rsp)
movq %r13, %xmm1
movq %rcx, %xmm2
punpcklqdq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0]
pxor %xmm2, %xmm2
testq %rbp, %rbp
sete %dil
testq %r14, %r14
sete %cl
movq %rax, 0x50(%rsp)
testq %rax, %rax
sete %dl
pcmpeqd %xmm2, %xmm0
pcmpeqd %xmm2, %xmm1
movdqa %xmm0, %xmm2
shufps $0xdd, %xmm1, %xmm2     # xmm2 = xmm2[1,3],xmm1[1,3]
shufps $0x88, %xmm1, %xmm0     # xmm0 = xmm0[0,2],xmm1[0,2]
andps %xmm2, %xmm0
movmskps %xmm0, %esi
testl %esi, %esi
setne %sil
orb %dil, %cl
orb %dl, %cl
orb %sil, %cl
jne 0x3bf07e
movq 0x40(%rsp), %r13
leal -0x1(%r13), %eax
movl %eax, 0x28(%rsp)
movl $0xf, %eax
subl 0x2c(%rsp), %eax
movl %eax, 0x64(%rsp)
movl 0xc(%rsp), %ecx
movd %ecx, %xmm0
movdqa %xmm0, 0x90(%rsp)
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]
movq 0xc0(%rsp), %r12
movd %r12d, %xmm0
movdqa %xmm0, %xmm1
punpcklbw %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1],xmm1[2],xmm0[2],xmm1[3],xmm0[3],xmm1[4],xmm0[4],xmm1[5],xmm0[5],xmm1[6],xmm0[6],xmm1[7],xmm0[7]
pshuflw $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm1, %xmm3      # xmm3 = xmm1[0,0,0,0]
movl 0xb0(%rsp), %eax
addb $-0x7f, %al
movzbl %al, %eax
movd %eax, %xmm1
movdqa %xmm1, 0xb0(%rsp)
punpcklbw %xmm1, %xmm1    # xmm1 = xmm1[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
movdqa %xmm1, 0xa0(%rsp)
movzbl 0x70(%rsp), %eax
movd %eax, %xmm1
punpcklbw %xmm1, %xmm1    # xmm1 = xmm1[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
movdqa %xmm1, 0xd0(%rsp)
movl %ecx, %eax
movl %r12d, %ecx
movslq 0x30(%rsp), %rdx
negq %rax
movq %r15, %rsi
imulq %rcx, %rsi
xorl %edi, %edi
movq $-0x80, %r8
movq %rdx, %r9
xorl %r10d, %r10d
cmpq $-0x7f, %r9
movq $-0x80, %r11
cmovgeq %r9, %r11
movb %r11b, 0x100(%rsp,%r10)
leaq (%rax,%r9), %r11
cmpq $-0x7f, %r11
cmovlq %r8, %r11
movb %r11b, 0xf0(%rsp,%r10)
incq %r10
subq %rsi, %r9
cmpq $0x10, %r10
jne 0x3be2c2
movq %rdi, %r9
shlq $0x4, %r9
movaps 0x100(%rsp), %xmm1
movq 0x18(%rsp), %r10
movaps %xmm1, (%r10,%r9)
movdqa 0xf0(%rsp), %xmm1
movq 0x58(%rsp), %r10
movdqa %xmm1, (%r10,%r9)
movq 0x10(%rsp), %r10
movdqa %xmm1, (%r10,%r9)
incq %rdi
subq %rcx, %rdx
cmpq %r15, %rdi
jne 0x3be2bc
movq 0x50(%rsp), %rdi
movb $0x0, (%rdi)
movl %r13d, %esi
addl $0xf, %r13d
andl $-0x10, %r13d
leaq -0x1(%rsi), %rax
movq %rax, %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
movdqa %xmm1, 0x70(%rsp)
movd 0x30(%rsp), %xmm1
movdqa %xmm1, 0xe0(%rsp)
pshufd $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
movdqa %xmm1, 0x40(%rsp)
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x30(%rsp)
movl %r12d, %edx
negl %edx
movl %r12d, %r8d
shll $0x4, %r8d
leal (%r12,%r12,2), %r9d
addl %r12d, %r12d
xorl %r10d, %r10d
movdqa 0x26aaf9(%rip), %xmm11  # 0x628ea0
pcmpeqd %xmm12, %xmm12
xorl %r11d, %r11d
movdqa 0x26b859(%rip), %xmm1   # 0x629c10
movq %r11, %xmm0
pshufd $0x44, %xmm0, %xmm10    # xmm10 = xmm0[0,1,0,1]
movdqa %xmm10, %xmm0
por 0x26aac1(%rip), %xmm0   # 0x628e90
movdqa 0x70(%rsp), %xmm6
pxor %xmm11, %xmm6
pxor %xmm11, %xmm0
movdqa %xmm0, %xmm5
pcmpgtd %xmm6, %xmm5
pshufd $0xa0, %xmm5, %xmm14    # xmm14 = xmm5[0,0,2,2]
pshuflw $0xe8, %xmm14, %xmm13   # xmm13 = xmm14[0,2,2,3,4,5,6,7]
pcmpeqd %xmm6, %xmm0
pshufd $0xf5, %xmm0, %xmm4     # xmm4 = xmm0[1,1,3,3]
pshuflw $0xe8, %xmm4, %xmm0     # xmm0 = xmm4[0,2,2,3,4,5,6,7]
pand %xmm13, %xmm0
pshufd $0xf5, %xmm5, %xmm15    # xmm15 = xmm5[1,1,3,3]
pshuflw $0xe8, %xmm15, %xmm5    # xmm5 = xmm15[0,2,2,3,4,5,6,7]
por %xmm0, %xmm5
pxor %xmm12, %xmm5
packssdw %xmm5, %xmm5
leal (%r12,%r10), %eax
leal (%r9,%r10), %ecx
movd %edx, %xmm0
punpcklqdq 0xe0(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
pshufd $0xa2, %xmm0, %xmm13    # xmm13 = xmm0[2,0,2,2]
movd %ecx, %xmm0
movd %eax, %xmm7
punpckldq %xmm0, %xmm7    # xmm7 = xmm7[0],xmm0[0],xmm7[1],xmm0[1]
movd %r10d, %xmm0
punpckldq 0x90(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
punpcklqdq %xmm7, %xmm0    # xmm0 = xmm0[0],xmm7[0]
psubd %xmm0, %xmm13
movdqa %xmm13, %xmm0
pcmpgtd %xmm1, %xmm0
pand %xmm0, %xmm13
pandn %xmm1, %xmm0
por %xmm13, %xmm0
movd %xmm5, %eax
testb $0x1, %al
je 0x3be485
movd %xmm0, %eax
movb %al, 0x1(%rdi,%r11)
pand %xmm14, %xmm4
por %xmm15, %xmm4
packssdw %xmm4, %xmm4
pxor %xmm12, %xmm4
packssdw %xmm4, %xmm4
packsswb %xmm4, %xmm4
movd %xmm4, %eax
shrl $0x8, %eax
testb $0x1, %al
je 0x3be4b5
pextrw $0x2, %xmm0, %eax
movb %al, 0x2(%rdi,%r11)
movdqa %xmm10, %xmm5
por 0x26a9be(%rip), %xmm5   # 0x628e80
pxor %xmm11, %xmm5
movdqa %xmm5, %xmm7
pcmpgtd %xmm6, %xmm7
pshufd $0xa0, %xmm7, %xmm4     # xmm4 = xmm7[0,0,2,2]
pcmpeqd %xmm6, %xmm5
pshufd $0xf5, %xmm5, %xmm5     # xmm5 = xmm5[1,1,3,3]
movdqa %xmm5, %xmm13
pand %xmm4, %xmm13
pshufd $0xf5, %xmm7, %xmm14    # xmm14 = xmm7[1,1,3,3]
por %xmm14, %xmm13
packssdw %xmm13, %xmm7
pxor %xmm12, %xmm7
packssdw %xmm7, %xmm7
packsswb %xmm7, %xmm7
movd %xmm7, %eax
shrl $0x10, %eax
testb $0x1, %al
je 0x3be519
pextrw $0x4, %xmm0, %eax
movb %al, 0x3(%rdi,%r11)
pshufhw $0x84, %xmm4, %xmm4     # xmm4 = xmm4[0,1,2,3,4,5,4,6]
pshufhw $0x84, %xmm5, %xmm5     # xmm5 = xmm5[0,1,2,3,4,5,4,6]
pand %xmm4, %xmm5
pshufhw $0x84, %xmm14, %xmm4    # xmm4 = xmm14[0,1,2,3,4,5,4,6]
por %xmm5, %xmm4
pxor %xmm12, %xmm4
packssdw %xmm4, %xmm4
packsswb %xmm4, %xmm4
movd %xmm4, %eax
shrl $0x18, %eax
testb $0x1, %al
je 0x3be553
pextrw $0x6, %xmm0, %eax
movb %al, 0x4(%rdi,%r11)
movdqa %xmm10, %xmm5
por 0x26a970(%rip), %xmm5   # 0x628ed0
movd %r11d, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, %xmm4
por 0x26b58a(%rip), %xmm4   # 0x629b00
pshufd $0xf5, %xmm4, %xmm7     # xmm7 = xmm4[1,1,3,3]
movdqa 0x30(%rsp), %xmm8
pmuludq %xmm8, %xmm4
pshufd $0xe8, %xmm4, %xmm4     # xmm4 = xmm4[0,2,2,3]
pshufd $0xf5, %xmm8, %xmm14    # xmm14 = xmm8[1,1,3,3]
pmuludq %xmm14, %xmm7
pshufd $0xe8, %xmm7, %xmm7     # xmm7 = xmm7[0,2,2,3]
punpckldq %xmm7, %xmm4    # xmm4 = xmm4[0],xmm7[0],xmm4[1],xmm7[1]
movdqa 0x40(%rsp), %xmm7
psubd %xmm4, %xmm7
movdqa %xmm7, %xmm4
pcmpgtd %xmm1, %xmm4
pand %xmm4, %xmm7
pandn %xmm1, %xmm4
por %xmm7, %xmm4
pxor %xmm11, %xmm5
movdqa %xmm5, %xmm7
pcmpgtd %xmm6, %xmm7
pshufd $0xa0, %xmm7, %xmm15    # xmm15 = xmm7[0,0,2,2]
pshuflw $0xe8, %xmm15, %xmm13   # xmm13 = xmm15[0,2,2,3,4,5,6,7]
pcmpeqd %xmm6, %xmm5
pshufd $0xf5, %xmm5, %xmm5     # xmm5 = xmm5[1,1,3,3]
pshuflw $0xe8, %xmm5, %xmm8     # xmm8 = xmm5[0,2,2,3,4,5,6,7]
pand %xmm13, %xmm8
pshufd $0xf5, %xmm7, %xmm13    # xmm13 = xmm7[1,1,3,3]
pshuflw $0xe8, %xmm13, %xmm7    # xmm7 = xmm13[0,2,2,3,4,5,6,7]
por %xmm8, %xmm7
pxor %xmm12, %xmm7
packssdw %xmm7, %xmm7
packsswb %xmm7, %xmm7
pextrw $0x2, %xmm7, %eax
testb $0x1, %al
je 0x3be61b
movd %xmm4, %eax
movb %al, 0x5(%rdi,%r11)
pand %xmm15, %xmm5
por %xmm13, %xmm5
packssdw %xmm5, %xmm5
pxor %xmm12, %xmm5
packssdw %xmm5, %xmm5
packsswb %xmm5, %xmm5
pextrw $0x2, %xmm5, %eax
shrl $0x8, %eax
testb $0x1, %al
je 0x3be64c
pextrw $0x2, %xmm4, %eax
movb %al, 0x6(%rdi,%r11)
movdqa %xmm10, %xmm7
por 0x26a867(%rip), %xmm7   # 0x628ec0
pxor %xmm11, %xmm7
movdqa %xmm7, %xmm8
pcmpgtd %xmm6, %xmm8
pshufd $0xa0, %xmm8, %xmm5     # xmm5 = xmm8[0,0,2,2]
pcmpeqd %xmm6, %xmm7
pshufd $0xf5, %xmm7, %xmm15    # xmm15 = xmm7[1,1,3,3]
movdqa %xmm15, %xmm7
pand %xmm5, %xmm7
pshufd $0xf5, %xmm8, %xmm13    # xmm13 = xmm8[1,1,3,3]
por %xmm13, %xmm7
packssdw %xmm7, %xmm7
pxor %xmm12, %xmm7
packssdw %xmm7, %xmm7
packsswb %xmm7, %xmm7
pextrw $0x3, %xmm7, %eax
testb $0x1, %al
je 0x3be6b0
pextrw $0x4, %xmm4, %eax
movb %al, 0x7(%rdi,%r11)
pshufhw $0x84, %xmm5, %xmm5     # xmm5 = xmm5[0,1,2,3,4,5,4,6]
pshufhw $0x84, %xmm15, %xmm7    # xmm7 = xmm15[0,1,2,3,4,5,4,6]
pand %xmm5, %xmm7
pshufhw $0x84, %xmm13, %xmm5    # xmm5 = xmm13[0,1,2,3,4,5,4,6]
por %xmm7, %xmm5
pxor %xmm12, %xmm5
packssdw %xmm5, %xmm5
packsswb %xmm5, %xmm5
pextrw $0x3, %xmm5, %eax
shrl $0x8, %eax
testb $0x1, %al
je 0x3be6ec
pextrw $0x6, %xmm4, %eax
movb %al, 0x8(%rdi,%r11)
movdqa %xmm10, %xmm5
por 0x26b4e7(%rip), %xmm5   # 0x629be0
movdqa %xmm0, %xmm4
por 0x26b4eb(%rip), %xmm4   # 0x629bf0
pshufd $0xf5, %xmm4, %xmm7     # xmm7 = xmm4[1,1,3,3]
pmuludq 0x30(%rsp), %xmm4
pshufd $0xe8, %xmm4, %xmm4     # xmm4 = xmm4[0,2,2,3]
pmuludq %xmm14, %xmm7
pshufd $0xe8, %xmm7, %xmm7     # xmm7 = xmm7[0,2,2,3]
punpckldq %xmm7, %xmm4    # xmm4 = xmm4[0],xmm7[0],xmm4[1],xmm7[1]
movdqa 0x40(%rsp), %xmm7
psubd %xmm4, %xmm7
movdqa %xmm7, %xmm4
pcmpgtd %xmm1, %xmm4
pand %xmm4, %xmm7
pandn %xmm1, %xmm4
por %xmm7, %xmm4
pxor %xmm11, %xmm5
movdqa %xmm5, %xmm7
pcmpgtd %xmm6, %xmm7
pshufd $0xa0, %xmm7, %xmm15    # xmm15 = xmm7[0,0,2,2]
pshuflw $0xe8, %xmm15, %xmm8    # xmm8 = xmm15[0,2,2,3,4,5,6,7]
pcmpeqd %xmm6, %xmm5
pshufd $0xf5, %xmm5, %xmm5     # xmm5 = xmm5[1,1,3,3]
pshuflw $0xe8, %xmm5, %xmm9     # xmm9 = xmm5[0,2,2,3,4,5,6,7]
pand %xmm8, %xmm9
pshufd $0xf5, %xmm7, %xmm13    # xmm13 = xmm7[1,1,3,3]
pshuflw $0xe8, %xmm13, %xmm7    # xmm7 = xmm13[0,2,2,3,4,5,6,7]
por %xmm9, %xmm7
pxor %xmm12, %xmm7
packssdw %xmm7, %xmm7
packsswb %xmm7, %xmm7
pextrw $0x4, %xmm7, %eax
testb $0x1, %al
je 0x3be79e
movd %xmm4, %eax
movb %al, 0x9(%rdi,%r11)
pand %xmm15, %xmm5
por %xmm13, %xmm5
packssdw %xmm5, %xmm5
pxor %xmm12, %xmm5
packssdw %xmm5, %xmm5
packsswb %xmm5, %xmm5
pextrw $0x4, %xmm5, %eax
shrl $0x8, %eax
testb $0x1, %al
je 0x3be7cf
pextrw $0x2, %xmm4, %eax
movb %al, 0xa(%rdi,%r11)
movdqa %xmm10, %xmm7
por 0x26b3f4(%rip), %xmm7   # 0x629bd0
pxor %xmm11, %xmm7
movdqa %xmm7, %xmm8
pcmpgtd %xmm6, %xmm8
pshufd $0xa0, %xmm8, %xmm5     # xmm5 = xmm8[0,0,2,2]
pcmpeqd %xmm6, %xmm7
pshufd $0xf5, %xmm7, %xmm13    # xmm13 = xmm7[1,1,3,3]
movdqa %xmm13, %xmm7
pand %xmm5, %xmm7
pshufd $0xf5, %xmm8, %xmm15    # xmm15 = xmm8[1,1,3,3]
por %xmm15, %xmm7
packssdw %xmm7, %xmm7
pxor %xmm12, %xmm7
packssdw %xmm7, %xmm7
packsswb %xmm7, %xmm7
pextrw $0x5, %xmm7, %eax
testb $0x1, %al
je 0x3be833
pextrw $0x4, %xmm4, %eax
movb %al, 0xb(%rdi,%r11)
pshufhw $0x84, %xmm5, %xmm5     # xmm5 = xmm5[0,1,2,3,4,5,4,6]
pshufhw $0x84, %xmm13, %xmm7    # xmm7 = xmm13[0,1,2,3,4,5,4,6]
pand %xmm5, %xmm7
pshufhw $0x84, %xmm15, %xmm5    # xmm5 = xmm15[0,1,2,3,4,5,4,6]
por %xmm7, %xmm5
pxor %xmm12, %xmm5
packssdw %xmm5, %xmm5
packsswb %xmm5, %xmm5
pextrw $0x5, %xmm5, %eax
shrl $0x8, %eax
testb $0x1, %al
je 0x3be86f
pextrw $0x6, %xmm4, %eax
movb %al, 0xc(%rdi,%r11)
movdqa %xmm10, %xmm4
por 0x26b344(%rip), %xmm4   # 0x629bc0
por 0x26b37c(%rip), %xmm0   # 0x629c00
pshufd $0xf5, %xmm0, %xmm5     # xmm5 = xmm0[1,1,3,3]
pmuludq 0x30(%rsp), %xmm0
pshufd $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3]
pmuludq %xmm14, %xmm5
pshufd $0xe8, %xmm5, %xmm5     # xmm5 = xmm5[0,2,2,3]
punpckldq %xmm5, %xmm0    # xmm0 = xmm0[0],xmm5[0],xmm0[1],xmm5[1]
movdqa 0x40(%rsp), %xmm5
psubd %xmm0, %xmm5
movdqa %xmm5, %xmm0
pcmpgtd %xmm1, %xmm0
pand %xmm0, %xmm5
pandn %xmm1, %xmm0
por %xmm5, %xmm0
pxor %xmm11, %xmm4
movdqa %xmm4, %xmm7
pcmpgtd %xmm6, %xmm7
pshufd $0xa0, %xmm7, %xmm5     # xmm5 = xmm7[0,0,2,2]
pshuflw $0xe8, %xmm5, %xmm8     # xmm8 = xmm5[0,2,2,3,4,5,6,7]
pcmpeqd %xmm6, %xmm4
pshufd $0xf5, %xmm4, %xmm4     # xmm4 = xmm4[1,1,3,3]
pshuflw $0xe8, %xmm4, %xmm9     # xmm9 = xmm4[0,2,2,3,4,5,6,7]
pand %xmm8, %xmm9
pshufd $0xf5, %xmm7, %xmm13    # xmm13 = xmm7[1,1,3,3]
pshuflw $0xe8, %xmm13, %xmm7    # xmm7 = xmm13[0,2,2,3,4,5,6,7]
por %xmm9, %xmm7
pxor %xmm12, %xmm7
packssdw %xmm7, %xmm7
packsswb %xmm7, %xmm7
pextrw $0x6, %xmm7, %eax
testb $0x1, %al
je 0x3be91c
movd %xmm0, %eax
movb %al, 0xd(%rdi,%r11)
pand %xmm5, %xmm4
por %xmm13, %xmm4
packssdw %xmm4, %xmm4
pxor %xmm12, %xmm4
packssdw %xmm4, %xmm4
packsswb %xmm4, %xmm4
pextrw $0x6, %xmm4, %eax
shrl $0x8, %eax
testb $0x1, %al
je 0x3be94c
pextrw $0x2, %xmm0, %eax
movb %al, 0xe(%rdi,%r11)
por 0x26b25b(%rip), %xmm10  # 0x629bb0
pxor %xmm11, %xmm10
movdqa %xmm10, %xmm7
pcmpgtd %xmm6, %xmm7
pshufd $0xa0, %xmm7, %xmm4     # xmm4 = xmm7[0,0,2,2]
pcmpeqd %xmm6, %xmm10
pshufd $0xf5, %xmm10, %xmm5    # xmm5 = xmm10[1,1,3,3]
movdqa %xmm5, %xmm8
pand %xmm4, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm6, %xmm8
packssdw %xmm8, %xmm7
pxor %xmm12, %xmm7
packssdw %xmm7, %xmm7
packsswb %xmm7, %xmm7
pextrw $0x7, %xmm7, %eax
testb $0x1, %al
je 0x3be9ac
pextrw $0x4, %xmm0, %eax
movb %al, 0xf(%rdi,%r11)
pshufhw $0x84, %xmm4, %xmm4     # xmm4 = xmm4[0,1,2,3,4,5,4,6]
pshufhw $0x84, %xmm5, %xmm5     # xmm5 = xmm5[0,1,2,3,4,5,4,6]
pand %xmm4, %xmm5
pshufhw $0x84, %xmm6, %xmm4     # xmm4 = xmm6[0,1,2,3,4,5,4,6]
por %xmm5, %xmm4
pxor %xmm12, %xmm4
packssdw %xmm4, %xmm4
packsswb %xmm4, %xmm4
pextrw $0x7, %xmm4, %eax
shrl $0x8, %eax
testb $0x1, %al
je 0x3be9e6
pextrw $0x6, %xmm0, %eax
movb %al, 0x10(%rdi,%r11)
addq $0x10, %r11
subl %r8d, %edx
addl %r8d, %r10d
cmpq %r11, %r13
jne 0x3be3b7
movq %r15, %r13
shlq $0x4, %r13
xorl %eax, %eax
movdqa 0x20b7a6(%rip), %xmm0   # 0x5ca1b0
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
movdqa %xmm0, (%rcx,%rax)
addq $0x10, %rax
cmpq %rax, %r13
jne 0x3bea0a
leal -0x1(%r15), %eax
xorl %r9d, %r9d
shlq $0x4, %rax
movq %rax, 0x90(%rsp)
movq %r15, 0x40(%rsp)
movl %r15d, %eax
movq %rax, 0x70(%rsp)
movdqa 0x20b739(%rip), %xmm7   # 0x5ca180
movdqa 0x20b750(%rip), %xmm8   # 0x5ca1a0
movdqa 0x26ce67(%rip), %xmm11  # 0x62b8c0
movdqa 0x20b77e(%rip), %xmm12  # 0x5ca1e0
movq %r13, %rcx
xorl %edx, %edx
movdqa 0xd0(%rsp), %xmm5
movdqa 0xa0(%rsp), %xmm1
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %r8
movq %rbp, %r15
movq %r8, %rbp
movq 0x20(%rsp), %r12
movq %rdx, %r10
movq 0x90(%rsp), %rdx
leaq (%rax,%rdx), %r8
movq %r8, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movdqa (%rax,%rdx), %xmm0
pslldq $0x1, %xmm0             # xmm0 = zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movzbl (%rdi,%r10), %edx
movd %edx, %xmm4
movdqa 0x26b15d(%rip), %xmm13  # 0x629c20
pandn %xmm4, %xmm13
por %xmm0, %xmm13
movq 0x80(%rsp), %rax
movq 0x10(%rax), %rdx
movq 0x88(%rsp), %rax
movzbl (%rax,%r10), %r8d
movslq (%rdx,%r8,4), %r8
imulq 0x70(%rsp), %r8
shlq $0x4, %r8
addq 0xc8(%rsp), %r8
movq %r10, 0x30(%rsp)
leaq 0x1(%r10), %rdx
movl $0x1, %r10d
xorl %r11d, %r11d
movdqa 0xa0(%rsp), %xmm15
paddsb (%r8,%r11), %xmm13
movq %rsi, %rdi
movq %rbp, %rsi
movq 0x58(%rsp), %rbp
movdqa (%rbp,%r11), %xmm4
movdqa %xmm13, %xmm6
pcmpgtb %xmm4, %xmm6
movdqa %xmm13, %xmm0
pand %xmm6, %xmm0
pandn %xmm4, %xmm6
por %xmm0, %xmm6
movdqa %xmm6, %xmm14
pcmpgtb %xmm15, %xmm14
pand %xmm14, %xmm6
movdqa %xmm14, %xmm0
pandn %xmm15, %xmm0
por %xmm6, %xmm0
movdqa %xmm0, (%r12,%r11)
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %r9, %rax
pcmpeqb %xmm0, %xmm13
paddb %xmm7, %xmm14
movdqa %xmm13, %xmm6
pandn %xmm14, %xmm6
pand %xmm8, %xmm13
por %xmm6, %xmm13
movdqa (%r11,%rax), %xmm6
por %xmm13, %xmm6
movdqa %xmm13, (%r14,%r11)
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %r9, %rax
movdqa %xmm6, (%r11,%rax)
movdqa %xmm0, %xmm10
psubsb %xmm2, %xmm10
movdqa %xmm4, %xmm6
psubsb %xmm3, %xmm6
movdqa %xmm10, %xmm13
pcmpgtb %xmm6, %xmm13
movdqa %xmm10, %xmm14
pand %xmm13, %xmm14
pandn %xmm6, %xmm13
por %xmm14, %xmm13
movdqa %xmm13, (%rbp,%r11)
movq %rsi, %rbp
movq %rdi, %rsi
movdqa (%rbp,%r11), %xmm13
psubsb %xmm3, %xmm13
movdqa %xmm10, %xmm9
pcmpgtb %xmm13, %xmm9
movdqa %xmm10, %xmm14
pand %xmm9, %xmm14
movdqa %xmm9, %xmm6
pandn %xmm13, %xmm6
por %xmm14, %xmm6
movdqa %xmm6, (%r15,%r11)
cmpq %rdi, %rdx
jae 0x3bec4f
pand 0x26cc7a(%rip), %xmm9   # 0x62b8b0
pxor 0x20b581(%rip), %xmm9   # 0x5ca1c0
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %rcx, %rax
movdqa %xmm9, (%r11,%rax)
movdqa %xmm15, %xmm6
psubsb %xmm3, %xmm6
movdqa %xmm10, %xmm13
pcmpgtb %xmm6, %xmm13
cmpq 0x40(%rsp), %r10
jae 0x3bec90
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %r9, %rax
movdqa %xmm13, %xmm9
pand %xmm11, %xmm9
pxor %xmm12, %xmm9
por 0x10(%r11,%rax), %xmm9
movdqa %xmm9, 0x10(%r11,%rax)
movdqa %xmm1, %xmm9
pcmpgtb %xmm0, %xmm1
pand %xmm1, %xmm9
pandn %xmm0, %xmm1
por %xmm9, %xmm1
movdqa %xmm5, %xmm9
pcmpgtb %xmm0, %xmm9
pand %xmm9, %xmm0
pandn %xmm5, %xmm9
por %xmm0, %xmm9
movdqa %xmm9, %xmm0
pcmpgtb %xmm4, %xmm0
pand %xmm0, %xmm4
pandn %xmm9, %xmm0
por %xmm4, %xmm0
movdqa %xmm0, %xmm5
pcmpgtb %xmm15, %xmm5
pand %xmm5, %xmm15
pandn %xmm0, %xmm5
por %xmm15, %xmm5
movdqa %xmm10, %xmm0
pand %xmm13, %xmm0
pandn %xmm6, %xmm13
movdqa %xmm13, %xmm15
por %xmm0, %xmm15
movq 0x20(%rsp), %rax
movdqa (%rax,%r11), %xmm13
addq $0x10, %r11
incq %r10
cmpq %r11, %r13
jne 0x3beb18
movl $0x0, 0x10(%rsp)
movdqa %xmm15, %xmm4
movq 0x30(%rsp), %r10
movq 0x50(%rsp), %rdi
movsbl 0x1(%rdi,%r10), %eax
subl 0xc(%rsp), %eax
cmpl $-0x7f, %eax
movl $0xffffff80, %r11d      # imm = 0xFFFFFF80
cmovll %r11d, %eax
movq 0x18(%rsp), %r11
movdqa (%r11), %xmm9
pslldq $0x1, %xmm9             # xmm9 = zero,xmm9[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movzbl (%rdi,%r10), %r11d
movd %r11d, %xmm13
movdqa 0x26aeae(%rip), %xmm14  # 0x629c20
movdqa %xmm14, %xmm0
pandn %xmm13, %xmm0
por %xmm9, %xmm0
pslldq $0x1, %xmm10            # xmm10 = zero,xmm10[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movd %eax, %xmm9
movdqa %xmm14, %xmm13
pandn %xmm9, %xmm13
por %xmm13, %xmm10
pslldq $0x1, %xmm4             # xmm4 = zero,xmm4[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
por %xmm13, %xmm4
pslldq $0x1, %xmm6             # xmm6 = zero,xmm6[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movdqa %xmm14, %xmm9
pandn 0xb0(%rsp), %xmm9
por %xmm9, %xmm6
pslldq $0x1, %xmm15            # xmm15 = zero,xmm15[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
por %xmm13, %xmm15
xorl %r11d, %r11d
movdqa (%r12,%r11), %xmm9
movdqa %xmm9, %xmm14
pcmpgtb %xmm4, %xmm14
pand %xmm14, %xmm9
movdqa %xmm14, %xmm13
pandn %xmm4, %xmm13
por %xmm9, %xmm13
movdqa %xmm13, (%r12,%r11)
paddsb (%r8,%r11), %xmm0
pcmpgtb %xmm6, %xmm10
pcmpeqb %xmm13, %xmm0
por %xmm14, %xmm0
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %r9, %rax
movdqa (%r11,%rax), %xmm6
pand 0x26cded(%rip), %xmm6   # 0x62bc10
movdqa (%r14,%r11), %xmm9
pand %xmm0, %xmm9
pandn %xmm7, %xmm0
por %xmm9, %xmm0
movdqa %xmm0, (%r14,%r11)
por %xmm6, %xmm0
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %r9, %rax
movdqa %xmm0, (%r11,%rax)
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %r9, %rax
pand %xmm11, %xmm10
movdqa (%r11,%rax), %xmm0
pand 0x26cdb2(%rip), %xmm0   # 0x62bc20
por %xmm10, %xmm0
pxor %xmm12, %xmm0
movdqa %xmm0, (%r11,%rax)
movdqa %xmm13, %xmm10
psubsb %xmm2, %xmm10
movdqa (%rbp,%r11), %xmm6
psubsb %xmm3, %xmm6
movdqa %xmm10, %xmm0
pcmpgtb %xmm6, %xmm0
movdqa %xmm10, %xmm9
pand %xmm0, %xmm9
movdqa %xmm0, %xmm14
pandn %xmm6, %xmm14
por %xmm9, %xmm14
movdqa %xmm14, (%r15,%r11)
cmpq %rsi, %rdx
jae 0x3beee0
pand 0x26c9e8(%rip), %xmm0   # 0x62b8b0
pxor 0x20b2f0(%rip), %xmm0   # 0x5ca1c0
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %rcx, %rax
movdqa %xmm0, (%r11,%rax)
movdqa %xmm5, %xmm0
pcmpgtb %xmm13, %xmm0
movdqa %xmm13, %xmm6
pand %xmm0, %xmm6
pandn %xmm5, %xmm0
movdqa %xmm0, %xmm5
por %xmm6, %xmm5
movdqa %xmm1, %xmm0
pcmpgtb %xmm13, %xmm1
pand %xmm1, %xmm0
pandn %xmm13, %xmm1
por %xmm0, %xmm1
psubsb %xmm3, %xmm4
movdqa %xmm10, %xmm0
pcmpgtb %xmm4, %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x3bef7e
movdqa %xmm15, %xmm6
psubsb %xmm3, %xmm6
movdqa %xmm10, %xmm15
pcmpgtb %xmm6, %xmm15
movdqa %xmm10, %xmm0
pand %xmm15, %xmm0
pandn %xmm6, %xmm15
por %xmm0, %xmm15
movq 0x20(%rsp), %rax
movdqa (%rax,%r11), %xmm0
addq $0x10, %r11
cmpq %r11, %r13
jne 0x3bedcc
movl 0x10(%rsp), %eax
incl %eax
movl %eax, 0x10(%rsp)
cmpl $0x10, %eax
jne 0x3bed2e
addq %r13, %rcx
addq %r13, %r9
movq %r12, %rax
movq %r15, %r8
cmpq %rsi, %rdx
movq 0x50(%rsp), %rdi
jne 0x3bea83
movl 0x6c(%rsp), %eax
shlq $0x4, %rax
movdqa (%r12,%rax), %xmm0
cmpl $0xe, 0x2c(%rsp)
jg 0x3befc4
xorl %eax, %eax
movl 0x28(%rsp), %edx
movl 0x64(%rsp), %ecx
pslldq $0x1, %xmm0             # xmm0 = zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
incl %eax
cmpl %ecx, %eax
jl 0x3befb7
jmp 0x3befc8
movl 0x28(%rsp), %edx
movdqa 0xa0(%rsp), %xmm2
pcmpgtb %xmm5, %xmm2
pcmpgtb 0xd0(%rsp), %xmm1
por %xmm2, %xmm1
pmovmskb %xmm1, %eax
testl %eax, %eax
je 0x3beff6
orb $0x40, 0xc(%rbx)
xorl %eax, %eax
xorl %edx, %edx
xorl %ecx, %ecx
jmp 0x3bf002
pextrw $0x7, %xmm0, %eax
shrl $0x8, %eax
movl 0x68(%rsp), %ecx
movsbl %al, %eax
movl %eax, (%rbx)
movl %ecx, 0x4(%rbx)
movl %edx, 0x8(%rbx)
callq 0x20a60d
movq %r14, %rdi
callq 0x20a60d
movq %rbp, %rdi
callq 0x20a60d
movq %r15, %rdi
callq 0x20a60d
movq 0x58(%rsp), %rdi
callq 0x20a60d
movq 0x20(%rsp), %rdi
callq 0x20a60d
movq %r12, %rdi
callq 0x20a60d
jmp 0x3bf080
callq 0x1bfc9b
jmp 0x3bf07e
callq 0x1bfc75
jmp 0x3bf07e
callq 0x1bfc4f
jmp 0x3bf07e
callq 0x1bfc29
jmp 0x3bf07e
callq 0x1bfc03
jmp 0x3bf07e
callq 0x1bfbdd
jmp 0x3bf07e
callq 0x1bfbb7
jmp 0x3bf07e
callq 0x1bfb91
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)