// File: /workspace/github_c_makefile_star2_O3/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 $0x128, %rsp            # imm = 0x128
movq %r8, 0x28(%rsp)
movq %rsi, 0x78(%rsp)
testq %rdi, %rdi
je 0x3aa086
movq 0x18(%rdi), %rax
movq %rax, 0xc8(%rsp)
testq %rax, %rax
je 0x3aa08d
movq 0x10(%rdi), %rax
movq %rax, 0x70(%rsp)
testq %rax, %rax
je 0x3aa094
movl %edx, %ebp
movl 0x8(%rdi), %edx
testl %edx, %edx
jle 0x3aa09b
cmpq $0x0, 0x78(%rsp)
je 0x3aa0a2
testl %ebp, %ebp
jle 0x3aa0a9
testl %ecx, %ecx
js 0x3aa0b0
cmpl $0x0, 0x28(%rsp)
js 0x3aa0b7
movl %r9d, %r13d
leal -0x1(%rdx), %eax
movq %rdx, 0xb8(%rsp)
leaq 0xf(%rdx), %r14
movq %r14, %r12
shrq $0x4, %r12
movl %eax, 0x3c(%rsp)
xorl %edx, %edx
divl %r12d
movl %eax, 0x8(%rsp)
movl %edx, %r15d
movl %ecx, %esi
negl %esi
movq 0x70(%rsp), %rdx
movl 0x20(%rdx), %eax
movl %eax, %edi
negb %dil
movl %esi, 0x80(%rsp)
cmpl %esi, %eax
movzbl %dil, %eax
movl %ecx, 0x50(%rsp)
cmovgl %ecx, %eax
movl %eax, 0xc(%rsp)
movb $0x7e, %al
subb 0x1c(%rdx), %al
movb %al, 0x60(%rsp)
movl $0x10, %edx
movl $0x10, %ecx
movl %r12d, %edi
movl %ebp, %esi
callq 0x20adf4
testq %rax, %rax
je 0x3aa0bc
movq %rax, %rbx
movl %r15d, 0x34(%rsp)
movq %r14, 0xb0(%rsp)
movl 0x170(%rsp), %edi
xorl %eax, %eax
testl %r13d, %r13d
setne %al
xorl %ecx, %ecx
cmpl $0x0, 0x160(%rsp)
setne %cl
shll $0x4, %ecx
xorl %edx, %edx
cmpl $0x0, 0x168(%rsp)
setne %dl
shll $0xe, %edx
xorl %esi, %esi
movl %edi, 0x38(%rsp)
testl %edi, %edi
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 %r12, %rsi
callq 0x2f600c
movq %rax, %r15
movq %rbp, 0x40(%rsp)
leal 0x1(%rbp), %esi
movl $0x10, %edi
callq 0x20a620
movq %rax, 0x10(%rsp)
movl $0x10, %edi
movq %r12, %rsi
callq 0x2f600c
movq %rax, %r14
movl $0x10, %edi
movq %r12, %rsi
callq 0x2f600c
movq %rax, %rbp
movl $0x10, %edi
movq %r12, 0x20(%rsp)
movq %r12, %rsi
callq 0x2f600c
movq 0x10(%rsp), %rcx
movq %r15, %xmm0
movq %rcx, %xmm1
punpcklqdq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0]
movq %r14, %xmm1
movq %rbp, %xmm2
punpcklqdq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0]
pxor %xmm2, %xmm2
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, %ecx
xorl %edx, %edx
testl %ecx, %ecx
jne 0x3aa0be
testq %rax, %rax
je 0x3aa0be
movq 0x40(%rsp), %rcx
decl %ecx
movl %ecx, 0x4(%rsp)
movl $0xf, %edx
subl 0x8(%rsp), %edx
movl 0x50(%rsp), %r8d
movd %r8d, %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 0x28(%rsp), %rsi
movd %esi, %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, %xmm3      # xmm3 = xmm0[0,0,0,0]
movl 0xc(%rsp), %ecx
addb $-0x7f, %cl
movl %ecx, 0xc(%rsp)
movzbl %cl, %ecx
movd %ecx, %xmm4
movdqa %xmm4, %xmm0
punpcklbw %xmm4, %xmm0    # xmm0 = xmm0[0],xmm4[0],xmm0[1],xmm4[1],xmm0[2],xmm4[2],xmm0[3],xmm4[3],xmm0[4],xmm4[4],xmm0[5],xmm4[5],xmm0[6],xmm4[6],xmm0[7],xmm4[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)
movzbl 0x60(%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, 0xd0(%rsp)
movl %edx, 0x1c(%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, 0x60(%rsp)
movq 0x20(%rsp), %rdi
movl %edi, %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, %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 %xmm4, 0xf0(%rsp)
paddsb %xmm4, %xmm5
movl %r8d, %ecx
movl %esi, %edx
movslq 0x80(%rsp), %r12
movq %rdx, 0x50(%rsp)
imulq %rdx, %rdi
xorl %r8d, %r8d
movq $-0x80, %r9
movq %r12, %rsi
xorl %r11d, %r11d
testl %r13d, %r13d
je 0x3a932c
xorl %r10d, %r10d
jmp 0x3a932f
movq %rsi, %r10
cmpq $-0x7f, %r10
movq $-0x80, %rdx
cmovgeq %r10, %rdx
movb %dl, 0x110(%rsp,%r11)
subq %rcx, %r10
cmpq $-0x7f, %r10
cmovlq %r9, %r10
movb %r10b, 0x100(%rsp,%r11)
incq %r11
subq %rdi, %rsi
cmpq $0x10, %r11
jne 0x3a9322
movq %r8, %rdx
shlq $0x4, %rdx
movaps 0x110(%rsp), %xmm0
movaps %xmm0, (%rbp,%rdx)
movdqa 0x100(%rsp), %xmm0
movdqa %xmm0, (%r15,%rdx)
incq %r8
subq 0x50(%rsp), %r12
cmpq 0x20(%rsp), %r8
jne 0x3a931c
movdqa %xmm5, 0x50(%rsp)
movq 0x10(%rsp), %rsi
movb $0x0, (%rsi)
movq 0x40(%rsp), %rdx
movl %edx, %ecx
addl $0xf, %edx
andl $-0x10, %edx
movq %rdx, 0x40(%rsp)
movq %rcx, 0xc0(%rsp)
decq %rcx
movq %rcx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa %xmm0, 0xe0(%rsp)
movd 0x80(%rsp), %xmm0
movdqa %xmm0, 0x80(%rsp)
pshufd $0x0, %xmm0, %xmm11     # xmm11 = xmm0[0,0,0,0]
pshufd $0x0, %xmm1, %xmm12     # xmm12 = xmm1[0,0,0,0]
movq 0x28(%rsp), %r12
movl %r12d, %edi
negl %edi
movl %r12d, %r8d
shll $0x4, %r8d
leal (%r12,%r12,2), %r9d
addl %r12d, %r12d
xorl %r10d, %r10d
movdqa 0x27fa89(%rip), %xmm15  # 0x628ea0
pcmpeqd %xmm10, %xmm10
xorl %r11d, %r11d
xorl %r13d, %r13d
movdqa 0x2807e6(%rip), %xmm1   # 0x629c10
movq %r13, %xmm0
pshufd $0x44, %xmm0, %xmm13    # xmm13 = xmm0[0,1,0,1]
movdqa %xmm13, %xmm0
por 0x27fa4e(%rip), %xmm0   # 0x628e90
movdqa 0xe0(%rsp), %xmm8
pxor %xmm15, %xmm8
pxor %xmm15, %xmm0
movdqa %xmm0, %xmm4
pcmpgtd %xmm8, %xmm4
pshufd $0xa0, %xmm4, %xmm5     # xmm5 = xmm4[0,0,2,2]
pshuflw $0xe8, %xmm5, %xmm6     # xmm6 = xmm5[0,2,2,3,4,5,6,7]
pcmpeqd %xmm8, %xmm0
pshufd $0xf5, %xmm0, %xmm0     # xmm0 = xmm0[1,1,3,3]
pshuflw $0xe8, %xmm0, %xmm14    # xmm14 = xmm0[0,2,2,3,4,5,6,7]
pand %xmm6, %xmm14
pshufd $0xf5, %xmm4, %xmm7     # xmm7 = xmm4[1,1,3,3]
pshuflw $0xe8, %xmm7, %xmm6     # xmm6 = xmm7[0,2,2,3,4,5,6,7]
por %xmm14, %xmm6
pxor %xmm10, %xmm6
packssdw %xmm6, %xmm6
leal (%r12,%r11), %ecx
leal (%r9,%r11), %edx
movd %edi, %xmm4
punpcklqdq 0x80(%rsp), %xmm4 # xmm4 = xmm4[0],mem[0]
pshufd $0xa2, %xmm4, %xmm14    # xmm14 = xmm4[2,0,2,2]
movd %edx, %xmm4
movd %ecx, %xmm9
punpckldq %xmm4, %xmm9    # xmm9 = xmm9[0],xmm4[0],xmm9[1],xmm4[1]
movd %r11d, %xmm4
punpckldq 0x90(%rsp), %xmm4 # xmm4 = xmm4[0],mem[0],xmm4[1],mem[1]
punpcklqdq %xmm9, %xmm4    # xmm4 = xmm4[0],xmm9[0]
psubd %xmm4, %xmm14
movdqa %xmm14, %xmm4
pcmpgtd %xmm1, %xmm4
pand %xmm4, %xmm14
pandn %xmm1, %xmm4
por %xmm14, %xmm4
movd %xmm6, %ecx
testb $0x1, %cl
movl 0x168(%rsp), %edx
je 0x3a950d
testl %edx, %edx
movd %xmm4, %ecx
cmovnel %r10d, %ecx
movb %cl, 0x1(%rsi,%r13)
pand %xmm5, %xmm0
por %xmm7, %xmm0
packssdw %xmm0, %xmm0
pxor %xmm10, %xmm0
packssdw %xmm0, %xmm0
packsswb %xmm0, %xmm0
movd %xmm0, %ecx
shrl $0x8, %ecx
testb $0x1, %cl
je 0x3a9542
pextrw $0x2, %xmm4, %ecx
testl %edx, %edx
cmovnel %r10d, %ecx
movb %cl, 0x2(%rsi,%r13)
movdqa %xmm13, %xmm5
por 0x27f931(%rip), %xmm5   # 0x628e80
pxor %xmm15, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm8, %xmm6
pshufd $0xa0, %xmm6, %xmm0     # xmm0 = xmm6[0,0,2,2]
pcmpeqd %xmm8, %xmm5
pshufd $0xf5, %xmm5, %xmm5     # xmm5 = xmm5[1,1,3,3]
movdqa %xmm5, %xmm7
pand %xmm0, %xmm7
pshufd $0xf5, %xmm6, %xmm6     # xmm6 = xmm6[1,1,3,3]
por %xmm6, %xmm7
packssdw %xmm7, %xmm7
pxor %xmm10, %xmm7
packssdw %xmm7, %xmm7
packsswb %xmm7, %xmm7
movd %xmm7, %ecx
shrl $0x10, %ecx
testb $0x1, %cl
je 0x3a95aa
pextrw $0x4, %xmm4, %ecx
testl %edx, %edx
cmovnel %r10d, %ecx
movb %cl, 0x3(%rsi,%r13)
pshufhw $0x84, %xmm0, %xmm0     # xmm0 = xmm0[0,1,2,3,4,5,4,6]
pshufhw $0x84, %xmm5, %xmm5     # xmm5 = xmm5[0,1,2,3,4,5,4,6]
pand %xmm0, %xmm5
pshufhw $0x84, %xmm6, %xmm0     # xmm0 = xmm6[0,1,2,3,4,5,4,6]
por %xmm5, %xmm0
pxor %xmm10, %xmm0
packssdw %xmm0, %xmm0
packsswb %xmm0, %xmm0
movd %xmm0, %ecx
shrl $0x18, %ecx
testb $0x1, %cl
je 0x3a95ea
pextrw $0x6, %xmm4, %ecx
testl %edx, %edx
cmovnel %r10d, %ecx
movb %cl, 0x4(%rsi,%r13)
movdqa %xmm13, %xmm0
por 0x27f8d9(%rip), %xmm0   # 0x628ed0
movd %r13d, %xmm4
pshufd $0x0, %xmm4, %xmm4      # xmm4 = xmm4[0,0,0,0]
movdqa %xmm4, %xmm5
por 0x2804f3(%rip), %xmm5   # 0x629b00
pshufd $0xf5, %xmm5, %xmm6     # xmm6 = xmm5[1,1,3,3]
pmuludq %xmm12, %xmm5
pshufd $0xe8, %xmm5, %xmm7     # xmm7 = xmm5[0,2,2,3]
pshufd $0xf5, %xmm12, %xmm5    # xmm5 = xmm12[1,1,3,3]
pmuludq %xmm5, %xmm6
pshufd $0xe8, %xmm6, %xmm6     # xmm6 = xmm6[0,2,2,3]
punpckldq %xmm6, %xmm7    # xmm7 = xmm7[0],xmm6[0],xmm7[1],xmm6[1]
movdqa %xmm11, %xmm6
psubd %xmm7, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm1, %xmm7
pand %xmm7, %xmm6
pandn %xmm1, %xmm7
por %xmm6, %xmm7
pxor %xmm15, %xmm0
movdqa %xmm0, %xmm9
pcmpgtd %xmm8, %xmm9
pshufd $0xa0, %xmm9, %xmm6     # xmm6 = xmm9[0,0,2,2]
pshuflw $0xe8, %xmm6, %xmm14    # xmm14 = xmm6[0,2,2,3,4,5,6,7]
pcmpeqd %xmm8, %xmm0
pshufd $0xf5, %xmm0, %xmm0     # xmm0 = xmm0[1,1,3,3]
pshuflw $0xe8, %xmm0, %xmm10    # xmm10 = xmm0[0,2,2,3,4,5,6,7]
pand %xmm14, %xmm10
pshufd $0xf5, %xmm9, %xmm14    # xmm14 = xmm9[1,1,3,3]
pshuflw $0xe8, %xmm14, %xmm9    # xmm9 = xmm14[0,2,2,3,4,5,6,7]
por %xmm10, %xmm9
pcmpeqd %xmm1, %xmm1
pxor %xmm1, %xmm9
packssdw %xmm9, %xmm9
packsswb %xmm9, %xmm9
pextrw $0x2, %xmm9, %ecx
testb $0x1, %cl
je 0x3a96ba
testl %edx, %edx
movd %xmm7, %ecx
cmovnel %r10d, %ecx
movb %cl, 0x5(%rsi,%r13)
pand %xmm6, %xmm0
por %xmm14, %xmm0
packssdw %xmm0, %xmm0
pxor %xmm1, %xmm0
packssdw %xmm0, %xmm0
packsswb %xmm0, %xmm0
pextrw $0x2, %xmm0, %ecx
shrl $0x8, %ecx
testb $0x1, %cl
je 0x3a96f0
pextrw $0x2, %xmm7, %ecx
testl %edx, %edx
cmovnel %r10d, %ecx
movb %cl, 0x6(%rsi,%r13)
movdqa %xmm13, %xmm6
por 0x27f7c3(%rip), %xmm6   # 0x628ec0
pxor %xmm15, %xmm6
movdqa %xmm6, %xmm9
pcmpgtd %xmm8, %xmm9
pshufd $0xa0, %xmm9, %xmm0     # xmm0 = xmm9[0,0,2,2]
pcmpeqd %xmm8, %xmm6
pshufd $0xf5, %xmm6, %xmm6     # xmm6 = xmm6[1,1,3,3]
movdqa %xmm6, %xmm10
pand %xmm0, %xmm10
pshufd $0xf5, %xmm9, %xmm14    # xmm14 = xmm9[1,1,3,3]
por %xmm14, %xmm10
packssdw %xmm10, %xmm9
pxor %xmm1, %xmm9
packssdw %xmm9, %xmm9
packsswb %xmm9, %xmm9
pextrw $0x3, %xmm9, %ecx
testb $0x1, %cl
je 0x3a9760
pextrw $0x4, %xmm7, %ecx
testl %edx, %edx
cmovnel %r10d, %ecx
movb %cl, 0x7(%rsi,%r13)
pshufhw $0x84, %xmm0, %xmm0     # xmm0 = xmm0[0,1,2,3,4,5,4,6]
pshufhw $0x84, %xmm6, %xmm6     # xmm6 = xmm6[0,1,2,3,4,5,4,6]
pand %xmm0, %xmm6
pshufhw $0x84, %xmm14, %xmm0    # xmm0 = xmm14[0,1,2,3,4,5,4,6]
por %xmm6, %xmm0
pxor %xmm1, %xmm0
packssdw %xmm0, %xmm0
packsswb %xmm0, %xmm0
pextrw $0x3, %xmm0, %ecx
shrl $0x8, %ecx
testb $0x1, %cl
je 0x3a97a1
pextrw $0x6, %xmm7, %ecx
testl %edx, %edx
cmovnel %r10d, %ecx
movb %cl, 0x8(%rsi,%r13)
movdqa %xmm13, %xmm0
por 0x280432(%rip), %xmm0   # 0x629be0
movdqa %xmm4, %xmm6
por 0x280436(%rip), %xmm6   # 0x629bf0
pshufd $0xf5, %xmm6, %xmm7     # xmm7 = xmm6[1,1,3,3]
movdqa %xmm12, %xmm1
pmuludq %xmm12, %xmm6
pshufd $0xe8, %xmm6, %xmm6     # xmm6 = xmm6[0,2,2,3]
pmuludq %xmm5, %xmm7
pshufd $0xe8, %xmm7, %xmm7     # xmm7 = xmm7[0,2,2,3]
punpckldq %xmm7, %xmm6    # xmm6 = xmm6[0],xmm7[0],xmm6[1],xmm7[1]
movdqa %xmm11, %xmm12
movdqa %xmm11, %xmm9
psubd %xmm6, %xmm9
movdqa %xmm9, %xmm7
movdqa 0x280419(%rip), %xmm6   # 0x629c10
pcmpgtd %xmm6, %xmm7
pand %xmm7, %xmm9
pandn %xmm6, %xmm7
por %xmm9, %xmm7
pxor %xmm15, %xmm0
movdqa %xmm0, %xmm9
pcmpgtd %xmm8, %xmm9
pshufd $0xa0, %xmm9, %xmm6     # xmm6 = xmm9[0,0,2,2]
pshuflw $0xe8, %xmm6, %xmm10    # xmm10 = xmm6[0,2,2,3,4,5,6,7]
pcmpeqd %xmm8, %xmm0
pshufd $0xf5, %xmm0, %xmm0     # xmm0 = xmm0[1,1,3,3]
pshuflw $0xe8, %xmm0, %xmm11    # xmm11 = xmm0[0,2,2,3,4,5,6,7]
pand %xmm10, %xmm11
pshufd $0xf5, %xmm9, %xmm14    # xmm14 = xmm9[1,1,3,3]
pshuflw $0xe8, %xmm14, %xmm9    # xmm9 = xmm14[0,2,2,3,4,5,6,7]
por %xmm11, %xmm9
pcmpeqd %xmm10, %xmm10
pxor %xmm10, %xmm9
packssdw %xmm9, %xmm9
packsswb %xmm9, %xmm9
pextrw $0x4, %xmm9, %ecx
testb $0x1, %cl
je 0x3a9878
testl %edx, %edx
movd %xmm7, %ecx
cmovnel %r10d, %ecx
movb %cl, 0x9(%rsi,%r13)
pand %xmm6, %xmm0
por %xmm14, %xmm0
packssdw %xmm0, %xmm0
pxor %xmm10, %xmm0
packssdw %xmm0, %xmm0
packsswb %xmm0, %xmm0
pextrw $0x4, %xmm0, %ecx
shrl $0x8, %ecx
testb $0x1, %cl
je 0x3a98af
pextrw $0x2, %xmm7, %ecx
testl %edx, %edx
cmovnel %r10d, %ecx
movb %cl, 0xa(%rsi,%r13)
movdqa %xmm13, %xmm6
por 0x280314(%rip), %xmm6   # 0x629bd0
pxor %xmm15, %xmm6
movdqa %xmm6, %xmm9
pcmpgtd %xmm8, %xmm9
pshufd $0xa0, %xmm9, %xmm0     # xmm0 = xmm9[0,0,2,2]
pcmpeqd %xmm8, %xmm6
pshufd $0xf5, %xmm6, %xmm6     # xmm6 = xmm6[1,1,3,3]
movdqa %xmm6, %xmm10
pand %xmm0, %xmm10
pshufd $0xf5, %xmm9, %xmm14    # xmm14 = xmm9[1,1,3,3]
por %xmm14, %xmm10
packssdw %xmm10, %xmm9
pcmpeqd %xmm10, %xmm10
pxor %xmm10, %xmm9
packssdw %xmm9, %xmm9
packsswb %xmm9, %xmm9
pextrw $0x5, %xmm9, %ecx
testb $0x1, %cl
movdqa %xmm12, %xmm11
je 0x3a9929
pextrw $0x4, %xmm7, %ecx
testl %edx, %edx
cmovnel %r10d, %ecx
movb %cl, 0xb(%rsi,%r13)
pshufhw $0x84, %xmm0, %xmm0     # xmm0 = xmm0[0,1,2,3,4,5,4,6]
pshufhw $0x84, %xmm6, %xmm6     # xmm6 = xmm6[0,1,2,3,4,5,4,6]
pand %xmm0, %xmm6
pshufhw $0x84, %xmm14, %xmm0    # xmm0 = xmm14[0,1,2,3,4,5,4,6]
por %xmm6, %xmm0
pxor %xmm10, %xmm0
packssdw %xmm0, %xmm0
packsswb %xmm0, %xmm0
pextrw $0x5, %xmm0, %ecx
shrl $0x8, %ecx
testb $0x1, %cl
movdqa %xmm1, %xmm12
je 0x3a9970
pextrw $0x6, %xmm7, %ecx
testl %edx, %edx
cmovnel %r10d, %ecx
movb %cl, 0xc(%rsi,%r13)
movdqa %xmm13, %xmm0
por 0x280243(%rip), %xmm0   # 0x629bc0
por 0x28027b(%rip), %xmm4   # 0x629c00
pshufd $0xf5, %xmm4, %xmm6     # xmm6 = xmm4[1,1,3,3]
pmuludq %xmm12, %xmm4
pshufd $0xe8, %xmm4, %xmm4     # xmm4 = xmm4[0,2,2,3]
pmuludq %xmm5, %xmm6
pshufd $0xe8, %xmm6, %xmm5     # xmm5 = xmm6[0,2,2,3]
punpckldq %xmm5, %xmm4    # xmm4 = xmm4[0],xmm5[0],xmm4[1],xmm5[1]
movdqa %xmm11, %xmm5
psubd %xmm4, %xmm5
movdqa %xmm5, %xmm4
movdqa 0x28025a(%rip), %xmm1   # 0x629c10
pcmpgtd %xmm1, %xmm4
pand %xmm4, %xmm5
pandn %xmm1, %xmm4
por %xmm5, %xmm4
pxor %xmm15, %xmm0
movdqa %xmm0, %xmm6
pcmpgtd %xmm8, %xmm6
pshufd $0xa0, %xmm6, %xmm5     # xmm5 = xmm6[0,0,2,2]
pshuflw $0xe8, %xmm5, %xmm7     # xmm7 = xmm5[0,2,2,3,4,5,6,7]
pcmpeqd %xmm8, %xmm0
pshufd $0xf5, %xmm0, %xmm0     # xmm0 = xmm0[1,1,3,3]
pshuflw $0xe8, %xmm0, %xmm9     # xmm9 = xmm0[0,2,2,3,4,5,6,7]
pand %xmm7, %xmm9
pshufd $0xf5, %xmm6, %xmm6     # xmm6 = xmm6[1,1,3,3]
pshuflw $0xe8, %xmm6, %xmm7     # xmm7 = xmm6[0,2,2,3,4,5,6,7]
por %xmm9, %xmm7
pxor %xmm10, %xmm7
packssdw %xmm7, %xmm7
packsswb %xmm7, %xmm7
pextrw $0x6, %xmm7, %ecx
testb $0x1, %cl
je 0x3a9a28
testl %edx, %edx
movd %xmm4, %ecx
cmovnel %r10d, %ecx
movb %cl, 0xd(%rsi,%r13)
pand %xmm5, %xmm0
por %xmm6, %xmm0
packssdw %xmm0, %xmm0
pxor %xmm10, %xmm0
packssdw %xmm0, %xmm0
packsswb %xmm0, %xmm0
pextrw $0x6, %xmm0, %ecx
shrl $0x8, %ecx
testb $0x1, %cl
je 0x3a9a5e
pextrw $0x2, %xmm4, %ecx
testl %edx, %edx
cmovnel %r10d, %ecx
movb %cl, 0xe(%rsi,%r13)
por 0x280149(%rip), %xmm13  # 0x629bb0
pxor %xmm15, %xmm13
movdqa %xmm13, %xmm6
pcmpgtd %xmm8, %xmm6
pshufd $0xa0, %xmm6, %xmm0     # xmm0 = xmm6[0,0,2,2]
pcmpeqd %xmm8, %xmm13
pshufd $0xf5, %xmm13, %xmm5    # xmm5 = xmm13[1,1,3,3]
movdqa %xmm5, %xmm7
pand %xmm0, %xmm7
pshufd $0xf5, %xmm6, %xmm6     # xmm6 = xmm6[1,1,3,3]
por %xmm6, %xmm7
packssdw %xmm7, %xmm7
pxor %xmm10, %xmm7
packssdw %xmm7, %xmm7
packsswb %xmm7, %xmm7
pextrw $0x7, %xmm7, %ecx
testb $0x1, %cl
je 0x3a9ac2
pextrw $0x4, %xmm4, %ecx
testl %edx, %edx
cmovnel %r10d, %ecx
movb %cl, 0xf(%rsi,%r13)
pshufhw $0x84, %xmm0, %xmm0     # xmm0 = xmm0[0,1,2,3,4,5,4,6]
pshufhw $0x84, %xmm5, %xmm5     # xmm5 = xmm5[0,1,2,3,4,5,4,6]
pand %xmm0, %xmm5
pshufhw $0x84, %xmm6, %xmm0     # xmm0 = xmm6[0,1,2,3,4,5,4,6]
por %xmm5, %xmm0
pxor %xmm10, %xmm0
packssdw %xmm0, %xmm0
packsswb %xmm0, %xmm0
pextrw $0x7, %xmm0, %ecx
shrl $0x8, %ecx
testb $0x1, %cl
je 0x3a9b03
pextrw $0x6, %xmm4, %ecx
testl %edx, %edx
cmovnel %r10d, %ecx
movb %cl, 0x10(%rsi,%r13)
addq $0x10, %r13
subl %r8d, %edi
addl %r8d, %r11d
cmpq %r13, 0x40(%rsp)
jne 0x3a942a
pxor %xmm0, %xmm0
psubsb %xmm2, %xmm0
movq 0x20(%rsp), %rdi
leal -0x1(%rdi), %r9d
shlq $0x4, %r9
movq %rax, %rcx
addq %r9, %rcx
movl %edi, %edx
movdqa 0xd0(%rsp), %xmm1
movdqa %xmm0, (%rcx)
psubsb %xmm3, %xmm0
movdqa %xmm1, %xmm4
pcmpgtb %xmm0, %xmm4
movdqa %xmm0, %xmm5
pand %xmm4, %xmm5
pandn %xmm1, %xmm4
movdqa %xmm4, %xmm1
por %xmm5, %xmm1
addq $-0x10, %rcx
decl %edx
jg 0x3a9b3e
addq %rbp, %r9
movl 0x34(%rsp), %r10d
movq %r10, 0x90(%rsp)
shlq $0x4, %r10
addq %rbp, %r10
movq %rdi, %r11
shlq $0x4, %r11
xorl %r13d, %r13d
movdqa 0x28008c(%rip), %xmm10  # 0x629c20
movl %edi, %r12d
movdqa 0x281d10(%rip), %xmm11  # 0x62b8b0
movdqa 0x220617(%rip), %xmm13  # 0x5ca1c0
movdqa 0x2205ce(%rip), %xmm14  # 0x5ca180
movdqa 0x2205e5(%rip), %xmm15  # 0x5ca1a0
movdqa 0x60(%rsp), %xmm0
pcmpeqb 0x280087(%rip), %xmm0   # 0x629c50
movdqa %xmm0, 0x60(%rsp)
xorl %ecx, %ecx
movl 0x4(%rsp), %r8d
movdqa 0xa0(%rsp), %xmm0
movdqa %xmm0, %xmm7
movdqa %xmm0, %xmm4
movdqa %xmm4, 0x40(%rsp)
movdqa (%r9), %xmm0
pslldq $0x1, %xmm0             # xmm0 = zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movzbl (%rsi,%rcx), %edx
movd %edx, %xmm5
movdqa %xmm10, %xmm4
pandn %xmm5, %xmm4
por %xmm0, %xmm4
movq 0x70(%rsp), %rdx
movq 0x10(%rdx), %rdx
movq 0x78(%rsp), %rsi
movzbl (%rsi,%rcx), %esi
movslq (%rdx,%rsi,4), %rdx
imulq %r12, %rdx
shlq $0x4, %rdx
addq 0xc8(%rsp), %rdx
movdqa 0xa0(%rsp), %xmm0
movdqa %xmm0, %xmm5
psubsb (%rax), %xmm5
xorl %esi, %esi
movdqa %xmm11, %xmm12
movdqa (%rbp,%rsi), %xmm10
movdqa (%r15,%rsi), %xmm8
movdqa %xmm10, %xmm9
psubsb %xmm2, %xmm9
psubsb %xmm3, %xmm8
movdqa %xmm9, %xmm6
pcmpgtb %xmm8, %xmm6
movdqa %xmm6, %xmm11
pand %xmm12, %xmm11
pxor %xmm13, %xmm11
movq 0x10(%rbx), %rdi
movq (%rdi), %rdi
addq %r13, %rdi
paddsb (%rax,%rsi), %xmm5
paddsb (%rdx,%rsi), %xmm4
movdqa %xmm11, (%rsi,%rdi)
pand %xmm6, %xmm9
pandn %xmm8, %xmm6
por %xmm9, %xmm6
movdqa %xmm1, %xmm8
pcmpgtb %xmm6, %xmm8
movdqa %xmm0, %xmm9
pcmpgtb %xmm5, %xmm0
pand %xmm0, %xmm9
pandn %xmm5, %xmm0
movdqa %xmm6, %xmm5
movdqa %xmm6, %xmm11
movdqa %xmm6, (%r15,%rsi)
pand %xmm8, %xmm6
pandn %xmm1, %xmm8
movdqa %xmm8, %xmm1
por %xmm6, %xmm1
por %xmm9, %xmm0
pcmpgtb %xmm4, %xmm5
pand %xmm5, %xmm11
pandn %xmm4, %xmm5
por %xmm11, %xmm5
movdqa %xmm5, (%r14,%rsi)
movdqa %xmm4, (%rbp,%rsi)
addq $0x10, %rsi
movdqa %xmm10, %xmm4
cmpq %rsi, %r11
jne 0x3a9c4a
movdqa %xmm12, %xmm11
pslldq $0x1, %xmm5             # xmm5 = zero,xmm5[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
leaq 0x1(%rcx), %rdx
movq 0x10(%rsp), %rsi
movzbl 0x1(%rsi,%rcx), %esi
movd %esi, %xmm4
movdqa 0x27fee0(%rip), %xmm10  # 0x629c20
movdqa %xmm10, %xmm9
pandn %xmm4, %xmm9
por %xmm5, %xmm9
movdqa (%rax), %xmm5
paddsb %xmm9, %xmm5
movdqa %xmm0, %xmm4
pcmpgtb %xmm5, %xmm4
pand %xmm4, %xmm0
pandn %xmm5, %xmm4
por %xmm0, %xmm4
movl $0xe, %esi
movdqa 0x50(%rsp), %xmm6
movdqa %xmm4, %xmm0
movdqa %xmm4, %xmm5
pslldq $0x1, %xmm4             # xmm4 = zero,xmm4[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
paddsb %xmm6, %xmm4
pcmpgtb %xmm4, %xmm0
pand %xmm0, %xmm5
pandn %xmm4, %xmm0
movdqa %xmm0, %xmm4
por %xmm5, %xmm4
decl %esi
jne 0x3a9d77
pslldq $0x1, %xmm4             # xmm4 = zero,xmm4[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
paddsb 0xf0(%rsp), %xmm4
movdqa %xmm4, %xmm5
pcmpgtb %xmm9, %xmm5
movdqa %xmm4, %xmm0
pand %xmm5, %xmm0
pandn %xmm9, %xmm5
por %xmm0, %xmm5
xorl %esi, %esi
movdqa 0x281aed(%rip), %xmm13  # 0x62b8c0
movdqa 0x220404(%rip), %xmm12  # 0x5ca1e0
movq 0x10(%rbx), %rdi
movq (%rdi), %rdi
addq %r13, %rdi
movdqa (%r14,%rsi), %xmm0
psubsb %xmm2, %xmm5
psubsb %xmm3, %xmm4
movdqa %xmm5, %xmm6
pcmpgtb %xmm4, %xmm6
movdqa %xmm6, %xmm8
pandn %xmm4, %xmm8
pand %xmm6, %xmm5
movdqa %xmm5, %xmm4
por %xmm8, %xmm4
pand %xmm13, %xmm6
pxor %xmm12, %xmm6
movdqa %xmm0, %xmm5
pcmpgtb %xmm4, %xmm5
movdqa %xmm5, %xmm8
pandn %xmm4, %xmm8
pand %xmm5, %xmm0
por %xmm8, %xmm0
movdqa (%rbp,%rsi), %xmm8
pcmpeqb %xmm0, %xmm8
paddb %xmm14, %xmm5
movdqa %xmm8, %xmm9
pandn %xmm5, %xmm9
pand %xmm15, %xmm8
por %xmm9, %xmm8
por (%rsi,%rdi), %xmm6
por %xmm8, %xmm6
movdqa %xmm6, (%rsi,%rdi)
movdqa %xmm0, (%rbp,%rsi)
movdqa %xmm1, %xmm6
pcmpgtb %xmm0, %xmm6
movdqa %xmm7, %xmm8
pcmpgtb %xmm0, %xmm7
pand %xmm7, %xmm8
pandn %xmm0, %xmm7
movdqa %xmm0, %xmm5
pand %xmm6, %xmm0
pandn %xmm1, %xmm6
por %xmm0, %xmm6
movdqa %xmm6, %xmm1
pcmpgtb %xmm4, %xmm1
movdqa %xmm4, %xmm0
pand %xmm1, %xmm0
pandn %xmm6, %xmm1
por %xmm0, %xmm1
por %xmm8, %xmm7
addq $0x10, %rsi
cmpq %rsi, %r11
jne 0x3a9ddc
movdqa (%r10), %xmm0
movdqa %xmm0, %xmm4
movdqa 0x40(%rsp), %xmm6
pcmpgtb %xmm6, %xmm4
movdqa %xmm4, %xmm5
pand 0x60(%rsp), %xmm5
pand %xmm4, %xmm0
pandn %xmm6, %xmm4
pmovmskb %xmm5, %esi
testl %esi, %esi
cmovnel %ecx, %r8d
por %xmm0, %xmm4
addq %r11, %r13
movq %rdx, %rcx
cmpq 0xc0(%rsp), %rdx
movq 0x10(%rsp), %rsi
movdqa 0x2202ab(%rip), %xmm13  # 0x5ca1c0
jne 0x3a9be7
cmpl $0x0, 0x170(%rsp)
movq 0xb8(%rsp), %r10
movl 0xc(%rsp), %r11d
movq 0x20(%rsp), %r13
movl 0x3c(%rsp), %r12d
je 0x3a9f5e
cmpl $0xe, 0x8(%rsp)
jg 0x3a9f54
xorl %ecx, %ecx
movl 0x1c(%rsp), %edx
pslldq $0x1, %xmm4             # xmm4 = zero,xmm4[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
incl %ecx
cmpl %edx, %ecx
jl 0x3a9f49
pextrw $0x7, %xmm4, %r11d
shrl $0x8, %r11d
cmpl $0x0, 0x160(%rsp)
je 0x3a9fd0
testl $0x7ffffff0, 0xb0(%rsp) # imm = 0x7FFFFFF0
je 0x3a9fd0
movl %r13d, %edx
andl $0x7ffffff, %edx        # imm = 0x7FFFFFF
shll $0x4, %edx
xorl %esi, %esi
movl %r12d, %ecx
movl %esi, %r9d
shrl $0x4, %r9d
movl %esi, %edi
andl $0xf, %edi
imull %r13d, %edi
addl %r9d, %edi
cmpl %r10d, %edi
jge 0x3a9fc7
movb (%rbp,%rsi), %r9b
cmpb %r11b, %r9b
jle 0x3a9fb4
movl %r9d, %r11d
movl 0x4(%rsp), %r8d
movl %edi, %ecx
jmp 0x3a9fc7
cmpl %ecx, %edi
cmovgel %ecx, %edi
cmpl 0x4(%rsp), %r8d
cmovnel %ecx, %edi
cmpb %r11b, %r9b
cmovel %edi, %ecx
incq %rsi
cmpl %esi, %edx
jne 0x3a9f86
jmp 0x3a9fd3
movl %r12d, %ecx
movl 0x160(%rsp), %edx
orl %edx, 0x38(%rsp)
jne 0x3aa01c
movq 0x90(%rsp), %rcx
shlq $0x4, %rcx
movdqa (%rbp,%rcx), %xmm0
cmpl $0xe, 0x8(%rsp)
jg 0x3aa00a
xorl %ecx, %ecx
movl 0x1c(%rsp), %edx
pslldq $0x1, %xmm0             # xmm0 = zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
incl %ecx
cmpl %edx, %ecx
jl 0x3a9fff
pextrw $0x7, %xmm0, %r11d
shrl $0x8, %r11d
movl 0x4(%rsp), %r8d
movl %r12d, %ecx
movdqa 0xa0(%rsp), %xmm0
pcmpgtb %xmm1, %xmm0
pcmpgtb 0xd0(%rsp), %xmm7
por %xmm0, %xmm7
pmovmskb %xmm7, %edx
testl %edx, %edx
je 0x3aa04a
orb $0x40, 0xc(%rbx)
xorl %r11d, %r11d
xorl %r8d, %r8d
xorl %ecx, %ecx
movsbl %r11b, %edx
movl %edx, (%rbx)
movl %ecx, 0x4(%rbx)
movl %r8d, 0x8(%rbx)
movq %rax, %rdi
callq 0x20a60d
movq %rbp, %rdi
callq 0x20a60d
movq %r14, %rdi
callq 0x20a60d
movq 0x10(%rsp), %rdi
callq 0x20a60d
movq %r15, %rdi
callq 0x20a60d
movq %rbx, %rdx
jmp 0x3aa0be
callq 0x1bd7a5
jmp 0x3aa0bc
callq 0x1bd77f
jmp 0x3aa0bc
callq 0x1bd759
jmp 0x3aa0bc
callq 0x1bd733
jmp 0x3aa0bc
callq 0x1bd70d
jmp 0x3aa0bc
callq 0x1bd6e7
jmp 0x3aa0bc
callq 0x1bd6c1
jmp 0x3aa0bc
callq 0x1bd69b
xorl %edx, %edx
movq %rdx, %rax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq