// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_striped_sse2_128_8.c
// Function: parasail_sg_flags_table_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,
        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 vProfile = NULL;
    __m128i* restrict pvHStore = NULL;
    __m128i* restrict pvHLoad = NULL;
    __m128i* restrict pvE = 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;
    __m128i vMaxH;
    __m128i vPosMask;
    parasail_result_t *result = NULL;

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

    /* initialize result */
#ifdef PARASAIL_TABLE
    result = parasail_result_new_table1(segLen*segWidth, s2Len);
#else
#ifdef PARASAIL_ROWCOL
    result = parasail_result_new_rowcol1(segLen*segWidth, s2Len);
#else
    result = parasail_result_new();
#endif
#endif
    if (!result) return NULL;

    /* set known flags */
    result->flag |= PARASAIL_FLAG_SG | PARASAIL_FLAG_STRIPED
        | 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;
#ifdef PARASAIL_TABLE
    result->flag |= PARASAIL_FLAG_TABLE;
#endif
#ifdef PARASAIL_ROWCOL
    result->flag |= PARASAIL_FLAG_ROWCOL;
#endif

    /* initialize heap variables */
    pvHStore = parasail_memalign___m128i(16, segLen);
    pvHLoad =  parasail_memalign___m128i(16, segLen);
    pvE      = 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 (!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 = 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(&pvHStore[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;
        }
    }

    /* outer loop over database sequence */
    for (j=0; j<s2Len; ++j) {
        __m128i vE;
        /* Initialize F value to -inf.  Any errors to vH values will be
         * corrected in the Lazy_F loop.  */
        __m128i vF = vNegLimit;

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

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

        /* Swap the 2 H buffers. */
        __m128i* pv = pvHLoad;
        pvHLoad = pvHStore;
        pvHStore = pv;

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

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

            /* Get max from vH, vE and vF. */
            vH = _mm_max_epi8_rpl(vH, 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);
#ifdef PARASAIL_TABLE
            arr_store_si128(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif

            /* Update vE value. */
            vH = _mm_subs_epi8(vH, vGapO);
            vE = _mm_subs_epi8(vE, vGapE);
            vE = _mm_max_epi8_rpl(vE, vH);
            _mm_store_si128(pvE + i, vE);

            /* Update vF value. */
            vF = _mm_subs_epi8(vF, vGapE);
            vF = _mm_max_epi8_rpl(vF, vH);

            /* 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 */
        for (k=0; k<segWidth; ++k) {
            int64_t tmp = s2_beg ? -open : (boundary[j+1]-open);
            int8_t tmp2 = tmp < INT8_MIN ? INT8_MIN : tmp;
            vF = _mm_slli_si128(vF, 1);
            vF = _mm_insert_epi8_rpl(vF, 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);
#ifdef PARASAIL_TABLE
                arr_store_si128(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif
                vH = _mm_subs_epi8(vH, vGapO);
                vF = _mm_subs_epi8(vF, vGapE);
                if (! _mm_movemask_epi8(_mm_cmpgt_epi8(vF, vH))) goto end;
                /*vF = _mm_max_epi8_rpl(vF, vH);*/
            }
        }
end:
        {
            /* extract vector containing last value from the column */
            __m128i vCompare;
            vH = _mm_load_si128(pvHStore + 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;
            }
#ifdef PARASAIL_ROWCOL
            for (k=0; k<position; ++k) {
                vH = _mm_slli_si128(vH, 1);
            }
            result->rowcols->score_row[j] = (int8_t) _mm_extract_epi8_rpl (vH, 15);
#endif
        }
    }

#ifdef PARASAIL_ROWCOL
    for (i=0; i<segLen; ++i) {
        __m128i vH = _mm_load_si128(pvHStore + i);
        arr_store_col(result->rowcols->score_col, vH, i, segLen);
    }
#endif

    /* 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*)pvHStore;
        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(pvHStore + 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(boundary);
    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 $0x208, %rsp            # imm = 0x208
movq %r8, 0x20(%rsp)
movl %ecx, 0xc(%rsp)
movq %rsi, 0xe0(%rsp)
testq %rdi, %rdi
je 0x314270
movq 0x18(%rdi), %rax
movq %rax, 0x1b8(%rsp)
testq %rax, %rax
je 0x31427a
movq 0x10(%rdi), %rax
movq %rax, 0xd8(%rsp)
testq %rax, %rax
je 0x314284
movl 0x8(%rdi), %ecx
testl %ecx, %ecx
jle 0x31428e
cmpq $0x0, 0xe0(%rsp)
je 0x314298
movl %edx, %ebx
testl %edx, %edx
jle 0x3142a2
cmpl $0x0, 0xc(%rsp)
js 0x3142ac
cmpl $0x0, 0x20(%rsp)
js 0x3142b6
movl %r9d, %r14d
leal -0x1(%rcx), %eax
movq %rcx, 0x1a0(%rsp)
leaq 0xf(%rcx), %r12
movq %r12, %rbp
shrq $0x4, %rbp
movl %eax, 0x9c(%rsp)
xorl %edx, %edx
divl %ebp
movl %eax, 0x38(%rsp)
movl %edx, 0x68(%rsp)
movl 0xc(%rsp), %edx
movl %edx, %edi
negl %edi
movq 0xd8(%rsp), %rsi
movl 0x20(%rsi), %eax
movl %eax, %ecx
negb %cl
movl %edi, 0x14(%rsp)
cmpl %edi, %eax
movzbl %cl, %eax
cmovgl %edx, %eax
movl %eax, 0x10(%rsp)
movb $0x7e, %al
subb 0x1c(%rsi), %al
movb %al, 0x40(%rsp)
andl $0x7ffffff0, %r12d      # imm = 0x7FFFFFF0
movl %r12d, %edi
movl %ebx, %esi
callq 0x20abc2
testq %rax, %rax
je 0x3130b3
movq %rax, %r15
movq %r12, 0x198(%rsp)
xorl %eax, %eax
testl %r14d, %r14d
setne %al
xorl %ecx, %ecx
cmpl $0x0, 0x240(%rsp)
setne %cl
shll $0x4, %ecx
xorl %edx, %edx
cmpl $0x0, 0x248(%rsp)
setne %dl
shll $0xe, %edx
xorl %esi, %esi
cmpl $0x0, 0x250(%rsp)
setne %sil
shll $0xf, %esi
leal (%rcx,%rax,8), %eax
orl %edx, %eax
orl %esi, %eax
orl 0xc(%r15), %eax
orl $0x10120802, %eax       # imm = 0x10120802
movl %eax, 0xc(%r15)
movl $0x10, %edi
movq %rbp, %rsi
callq 0x2f600c
movq %rax, %r13
movl $0x10, %edi
movq %rbp, %rsi
callq 0x2f600c
movq %rbp, %rsi
movq %rax, %rbp
movl $0x10, %edi
movq %rsi, 0x18(%rsp)
callq 0x2f600c
movq %rax, %r12
leal 0x1(%rbx), %esi
movl $0x10, %edi
callq 0x20a620
movq %r13, %xmm0
movq %rbp, %xmm1
punpcklqdq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0]
movq %r12, %xmm1
movq %rax, %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
testl %ecx, %ecx
je 0x3130cb
xorl %r15d, %r15d
movq %r15, %rax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, 0x28(%rsp)
movl 0x250(%rsp), %ecx
movl %ecx, 0x98(%rsp)
movq %rax, 0x58(%rsp)
movq %rbp, 0x60(%rsp)
movq %rbx, %rbp
leal -0x1(%rbx), %eax
movl %eax, 0x34(%rsp)
movl $0xf, %edx
subl 0x38(%rsp), %edx
movl 0xc(%rsp), %ecx
movd %ecx, %xmm0
movdqa %xmm0, 0xc0(%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 0x20(%rsp), %rsi
movd %esi, %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 0x10(%rsp), %r13d
addb $-0x7f, %r13b
movl %r13d, 0x10(%rsp)
movzbl %r13b, %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, %xmm4      # xmm4 = xmm1[0,0,0,0]
movzbl 0x40(%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, %xmm5      # xmm5 = xmm1[0,0,0,0]
movl %edx, 0x94(%rsp)
movd %edx, %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, 0x180(%rsp)
movl %ecx, %eax
movl %esi, %ecx
movslq 0x14(%rsp), %rdx
movq 0x18(%rsp), %rsi
imulq %rcx, %rsi
xorl %edi, %edi
movq $-0x80, %r8
movq %r12, %r13
movq %rdx, %r9
xorl %r10d, %r10d
testl %r14d, %r14d
je 0x3131c0
xorl %r11d, %r11d
jmp 0x3131c3
movq %r9, %r11
cmpq $-0x7f, %r11
movq $-0x80, %rbx
cmovgeq %r11, %rbx
movb %bl, 0x1f0(%rsp,%r10)
subq %rax, %r11
cmpq $-0x7f, %r11
cmovlq %r8, %r11
movb %r11b, 0x1e0(%rsp,%r10)
incq %r10
subq %rsi, %r9
cmpq $0x10, %r10
jne 0x3131b6
movq %rdi, %r9
shlq $0x4, %r9
movaps 0x1f0(%rsp), %xmm1
movq 0x28(%rsp), %r10
movaps %xmm1, (%r10,%r9)
movdqa 0x1e0(%rsp), %xmm1
movdqa %xmm1, (%r13,%r9)
incq %rdi
subq %rcx, %rdx
cmpq 0x18(%rsp), %rdi
jne 0x3131b0
movdqa %xmm5, 0x1c0(%rsp)
movdqa %xmm4, 0x1d0(%rsp)
movq 0x58(%rsp), %rdx
movb $0x0, (%rdx)
movl %ebp, %eax
addl $0xf, %ebp
andl $-0x10, %ebp
movq %rax, 0xd0(%rsp)
decq %rax
movq %rax, %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
movdqa %xmm1, 0xb0(%rsp)
movd 0x14(%rsp), %xmm1
movdqa %xmm1, 0xa0(%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, 0x70(%rsp)
movq 0x20(%rsp), %rsi
movl %esi, %edi
negl %edi
movl %esi, %r8d
shll $0x4, %r8d
leal (%rsi,%rsi,2), %r9d
addl %esi, %esi
xorl %r10d, %r10d
movdqa 0x315bea(%rip), %xmm11  # 0x628ea0
pcmpeqd %xmm12, %xmm12
xorl %r11d, %r11d
xorl %r14d, %r14d
movdqa 0x316947(%rip), %xmm1   # 0x629c10
movq %r14, %xmm0
pshufd $0x44, %xmm0, %xmm10    # xmm10 = xmm0[0,1,0,1]
movdqa %xmm10, %xmm0
por 0x315baf(%rip), %xmm0   # 0x628e90
movdqa 0xb0(%rsp), %xmm6
pxor %xmm11, %xmm6
pxor %xmm11, %xmm0
movdqa %xmm0, %xmm4
pcmpgtd %xmm6, %xmm4
pshufd $0xa0, %xmm4, %xmm15    # xmm15 = xmm4[0,0,2,2]
pshuflw $0xe8, %xmm15, %xmm5    # xmm5 = xmm15[0,2,2,3,4,5,6,7]
pcmpeqd %xmm6, %xmm0
pshufd $0xf5, %xmm0, %xmm14    # xmm14 = xmm0[1,1,3,3]
pshuflw $0xe8, %xmm14, %xmm0    # xmm0 = xmm14[0,2,2,3,4,5,6,7]
pand %xmm5, %xmm0
pshufd $0xf5, %xmm4, %xmm4     # xmm4 = xmm4[1,1,3,3]
pshuflw $0xe8, %xmm4, %xmm5     # xmm5 = xmm4[0,2,2,3,4,5,6,7]
por %xmm0, %xmm5
pxor %xmm12, %xmm5
packssdw %xmm5, %xmm5
leal (%rsi,%r11), %eax
leal (%r9,%r11), %ecx
movd %edi, %xmm0
punpcklqdq 0xa0(%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 %r11d, %xmm0
punpckldq 0xc0(%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
movl 0x248(%rsp), %ecx
je 0x3133a6
testl %ecx, %ecx
movd %xmm0, %eax
cmovnel %r10d, %eax
movb %al, 0x1(%rdx,%r14)
pand %xmm15, %xmm14
por %xmm4, %xmm14
packssdw %xmm14, %xmm14
pxor %xmm12, %xmm14
packssdw %xmm14, %xmm14
packsswb %xmm14, %xmm14
movd %xmm14, %eax
shrl $0x8, %eax
testb $0x1, %al
je 0x3133e0
pextrw $0x2, %xmm0, %eax
testl %ecx, %ecx
cmovnel %r10d, %eax
movb %al, 0x2(%rdx,%r14)
movdqa %xmm10, %xmm5
por 0x315a93(%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 0x31344a
pextrw $0x4, %xmm0, %eax
testl %ecx, %ecx
cmovnel %r10d, %eax
movb %al, 0x3(%rdx,%r14)
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 0x31348a
pextrw $0x6, %xmm0, %eax
testl %ecx, %ecx
cmovnel %r10d, %eax
movb %al, 0x4(%rdx,%r14)
movdqa %xmm10, %xmm4
por 0x315a39(%rip), %xmm4   # 0x628ed0
movd %r14d, %xmm0
pshufd $0x0, %xmm0, %xmm14     # xmm14 = xmm0[0,0,0,0]
movdqa %xmm14, %xmm0
por 0x316651(%rip), %xmm0   # 0x629b00
pshufd $0xf5, %xmm0, %xmm5     # xmm5 = xmm0[1,1,3,3]
movdqa 0x70(%rsp), %xmm7
pmuludq %xmm7, %xmm0
pshufd $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3]
pshufd $0xf5, %xmm7, %xmm15    # xmm15 = xmm7[1,1,3,3]
pmuludq %xmm15, %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, %xmm13    # xmm13 = 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, %xmm8     # xmm8 = xmm4[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 0x313557
testl %ecx, %ecx
movd %xmm0, %eax
cmovnel %r10d, %eax
movb %al, 0x5(%rdx,%r14)
pand %xmm5, %xmm4
por %xmm13, %xmm4
packssdw %xmm4, %xmm4
pxor %xmm12, %xmm4
packssdw %xmm4, %xmm4
packsswb %xmm4, %xmm4
pextrw $0x2, %xmm4, %eax
shrl $0x8, %eax
testb $0x1, %al
je 0x31358d
pextrw $0x2, %xmm0, %eax
testl %ecx, %ecx
cmovnel %r10d, %eax
movb %al, 0x6(%rdx,%r14)
movdqa %xmm10, %xmm5
por 0x315926(%rip), %xmm5   # 0x628ec0
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, %xmm8
pand %xmm4, %xmm8
pshufd $0xf5, %xmm7, %xmm13    # xmm13 = xmm7[1,1,3,3]
por %xmm13, %xmm8
packssdw %xmm8, %xmm7
pxor %xmm12, %xmm7
packssdw %xmm7, %xmm7
packsswb %xmm7, %xmm7
pextrw $0x3, %xmm7, %eax
testb $0x1, %al
je 0x3135f5
pextrw $0x4, %xmm0, %eax
testl %ecx, %ecx
cmovnel %r10d, %eax
movb %al, 0x7(%rdx,%r14)
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, %xmm13, %xmm4    # xmm4 = xmm13[0,1,2,3,4,5,4,6]
por %xmm5, %xmm4
pxor %xmm12, %xmm4
packssdw %xmm4, %xmm4
packsswb %xmm4, %xmm4
pextrw $0x3, %xmm4, %eax
shrl $0x8, %eax
testb $0x1, %al
je 0x313636
pextrw $0x6, %xmm0, %eax
testl %ecx, %ecx
cmovnel %r10d, %eax
movb %al, 0x8(%rdx,%r14)
movdqa %xmm10, %xmm4
por 0x31659d(%rip), %xmm4   # 0x629be0
movdqa %xmm14, %xmm0
por 0x3165a0(%rip), %xmm0   # 0x629bf0
pshufd $0xf5, %xmm0, %xmm5     # xmm5 = xmm0[1,1,3,3]
pmuludq 0x70(%rsp), %xmm0
pshufd $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3]
pmuludq %xmm15, %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 $0x4, %xmm7, %eax
testb $0x1, %al
je 0x3136ee
testl %ecx, %ecx
movd %xmm0, %eax
cmovnel %r10d, %eax
movb %al, 0x9(%rdx,%r14)
pand %xmm5, %xmm4
por %xmm13, %xmm4
packssdw %xmm4, %xmm4
pxor %xmm12, %xmm4
packssdw %xmm4, %xmm4
packsswb %xmm4, %xmm4
pextrw $0x4, %xmm4, %eax
shrl $0x8, %eax
testb $0x1, %al
je 0x313724
pextrw $0x2, %xmm0, %eax
testl %ecx, %ecx
cmovnel %r10d, %eax
movb %al, 0xa(%rdx,%r14)
movdqa %xmm10, %xmm5
por 0x31649f(%rip), %xmm5   # 0x629bd0
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, %xmm8
pand %xmm4, %xmm8
pshufd $0xf5, %xmm7, %xmm13    # xmm13 = xmm7[1,1,3,3]
por %xmm13, %xmm8
packssdw %xmm8, %xmm7
pxor %xmm12, %xmm7
packssdw %xmm7, %xmm7
packsswb %xmm7, %xmm7
pextrw $0x5, %xmm7, %eax
testb $0x1, %al
je 0x31378c
pextrw $0x4, %xmm0, %eax
testl %ecx, %ecx
cmovnel %r10d, %eax
movb %al, 0xb(%rdx,%r14)
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, %xmm13, %xmm4    # xmm4 = xmm13[0,1,2,3,4,5,4,6]
por %xmm5, %xmm4
pxor %xmm12, %xmm4
packssdw %xmm4, %xmm4
packsswb %xmm4, %xmm4
pextrw $0x5, %xmm4, %eax
shrl $0x8, %eax
testb $0x1, %al
je 0x3137cd
pextrw $0x6, %xmm0, %eax
testl %ecx, %ecx
cmovnel %r10d, %eax
movb %al, 0xc(%rdx,%r14)
movdqa %xmm10, %xmm4
por 0x3163e6(%rip), %xmm4   # 0x629bc0
por 0x31641d(%rip), %xmm14  # 0x629c00
pshufd $0xf5, %xmm14, %xmm0    # xmm0 = xmm14[1,1,3,3]
pmuludq 0x70(%rsp), %xmm14
pshufd $0xe8, %xmm14, %xmm5    # xmm5 = xmm14[0,2,2,3]
pmuludq %xmm15, %xmm0
pshufd $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3]
punpckldq %xmm0, %xmm5    # xmm5 = xmm5[0],xmm0[0],xmm5[1],xmm0[1]
movdqa 0x40(%rsp), %xmm7
psubd %xmm5, %xmm7
movdqa %xmm7, %xmm0
pcmpgtd %xmm1, %xmm0
pand %xmm0, %xmm7
pandn %xmm1, %xmm0
por %xmm7, %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 0x313884
testl %ecx, %ecx
movd %xmm0, %eax
cmovnel %r10d, %eax
movb %al, 0xd(%rdx,%r14)
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 0x3138ba
pextrw $0x2, %xmm0, %eax
testl %ecx, %ecx
cmovnel %r10d, %eax
movb %al, 0xe(%rdx,%r14)
por 0x3162ed(%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 0x313920
pextrw $0x4, %xmm0, %eax
testl %ecx, %ecx
cmovnel %r10d, %eax
movb %al, 0xf(%rdx,%r14)
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 0x313960
pextrw $0x6, %xmm0, %eax
testl %ecx, %ecx
cmovnel %r10d, %eax
movb %al, 0x10(%rdx,%r14)
addq $0x10, %r14
subl %r8d, %edi
addl %r8d, %r11d
cmpq %r14, %rbp
jne 0x3132c9
movq 0x18(%rsp), %r10
leal -0x1(%r10), %esi
movl 0x68(%rsp), %edx
movq %r10, %rax
movq 0xd0(%rsp), %rcx
imulq %rcx, %rax
leaq (,%rax,4), %rdi
leaq (,%rcx,4), %r8
leaq (,%rax,8), %r9
leaq (%rdi,%rdi,2), %rcx
movq %rcx, 0x108(%rsp)
leaq (%rax,%rax,8), %rcx
leaq (%rcx,%rcx,2), %rcx
addq %rax, %rcx
movq %rcx, 0x170(%rsp)
movq %rax, %rbx
imulq $0x2c, %rax, %rbp
imulq $0x34, %rax, %rcx
imulq $0x38, %rax, %r14
movq %r14, 0x150(%rsp)
imulq $0x3c, %rax, %r14
movq %r14, 0x148(%rsp)
shlq $0x4, %rax
shlq $0x5, %rbx
movq %r10, %r14
shlq $0x4, %r14
shlq $0x4, %rsi
movq %rsi, 0x1b0(%rsp)
movdqa 0x316214(%rip), %xmm7   # 0x629c20
movdqa 0x180(%rsp), %xmm0
pcmpeqb 0x316233(%rip), %xmm0   # 0x629c50
movdqa %xmm0, 0x180(%rsp)
movq %rdx, 0x190(%rsp)
shlq $0x4, %rdx
movq %rdx, 0x1a8(%rsp)
movdqa 0x1d0(%rsp), %xmm11
movdqa %xmm11, %xmm6
movdqa %xmm11, %xmm1
movdqa 0x1c0(%rsp), %xmm12
movdqa %xmm12, %xmm5
leaq (%rdi,%rdi,4), %rdx
movq %rdx, 0x130(%rsp)
leaq (%r9,%r9,2), %r11
leaq (%rdi,%rdi,8), %rdx
movq %rdx, 0x120(%rsp)
movq %r9, %r10
leaq (%r9,%r9,4), %rdx
movq %rdx, 0x118(%rsp)
movq %rax, 0x140(%rsp)
leaq (%rax,%rax,2), %rax
movq %rax, 0x110(%rsp)
xorl %r9d, %r9d
xorl %edx, %edx
movl 0x34(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x28(%rsp), %r12
movq %r15, 0x178(%rsp)
movq %r13, 0xf8(%rsp)
movq %r8, 0x20(%rsp)
movq %r10, 0x68(%rsp)
movq %rbx, 0x168(%rsp)
movq %rbp, 0x160(%rsp)
movq %rcx, 0x158(%rsp)
movq %r14, 0x138(%rsp)
movq %r11, 0x128(%rsp)
movq %rdi, 0x100(%rsp)
movq 0x60(%rsp), %r14
movq 0x1b0(%rsp), %rcx
movdqa (%r12,%rcx), %xmm4
pslldq $0x1, %xmm4             # xmm4 = zero,xmm4[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movq 0xd8(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq %rdx, %rax
movq 0xe0(%rsp), %rdx
movzbl (%rdx,%rax), %edx
movslq (%rcx,%rdx,4), %rdx
movl 0x18(%rsp), %ecx
imulq %rdx, %rcx
shlq $0x4, %rcx
addq 0x1b8(%rsp), %rcx
movq %rcx, 0x88(%rsp)
movq 0x58(%rsp), %rcx
movq %rax, 0xe8(%rsp)
movzbl (%rcx,%rax), %edx
movd %edx, %xmm8
movdqa %xmm7, %xmm0
pandn %xmm8, %xmm0
por %xmm4, %xmm0
movq %r9, 0xf0(%rsp)
movq %r9, 0x40(%rsp)
xorl %r9d, %r9d
movdqa %xmm11, %xmm8
movq %r12, 0x60(%rsp)
movq 0x88(%rsp), %rax
paddsb (%rax,%r9), %xmm0
movdqa (%r13,%r9), %xmm9
movdqa %xmm0, %xmm4
pcmpgtb %xmm9, %xmm4
pand %xmm4, %xmm0
pandn %xmm9, %xmm4
por %xmm0, %xmm4
movdqa %xmm4, %xmm0
pcmpgtb %xmm8, %xmm0
pand %xmm0, %xmm4
pandn %xmm8, %xmm0
por %xmm4, %xmm0
movdqa %xmm0, (%r14,%r9)
movq 0x10(%r15), %rsi
movq (%rsi), %rsi
movsbl (%r14,%r9), %r12d
movsbl 0x1(%r14,%r9), %ebp
movsbl 0x2(%r14,%r9), %r8d
movsbl 0x3(%r14,%r9), %r15d
movsbl 0x4(%r14,%r9), %ebx
movsbl 0x5(%r14,%r9), %eax
movl %eax, 0x70(%rsp)
movsbl 0x6(%r14,%r9), %r13d
movsbl 0x7(%r14,%r9), %r11d
movsbl 0x8(%r14,%r9), %r10d
movsbl 0x9(%r14,%r9), %edi
movsbl 0xa(%r14,%r9), %ecx
movsbl 0xb(%r14,%r9), %edx
movsbl 0xc(%r14,%r9), %eax
movl %eax, 0x28(%rsp)
movsbl 0xd(%r14,%r9), %eax
movl %eax, 0xc0(%rsp)
movsbl 0xe(%r14,%r9), %eax
movl %eax, 0xb0(%rsp)
movsbl 0xf(%r14,%r9), %eax
movl %eax, 0xa0(%rsp)
movq 0x40(%rsp), %rax
movl %r12d, (%rsi,%rax)
leaq (%rsi,%rax), %rsi
movq 0x100(%rsp), %r12
movl %ebp, (%r12,%rsi)
movq 0x160(%rsp), %rbp
movq 0x68(%rsp), %r12
movl %r8d, (%r12,%rsi)
movq 0x20(%rsp), %r8
movq 0x108(%rsp), %r12
movl %r15d, (%r12,%rsi)
movq 0x178(%rsp), %r15
movq 0x140(%rsp), %r12
movl %ebx, (%r12,%rsi)
movq 0x130(%rsp), %rbx
movl 0x70(%rsp), %r12d
movl %r12d, (%rbx,%rsi)
movq 0x60(%rsp), %r12
movq 0x128(%rsp), %rbx
movl %r13d, (%rbx,%rsi)
movq 0xf8(%rsp), %r13
movq 0x170(%rsp), %rbx
movl %r11d, (%rbx,%rsi)
movq 0x168(%rsp), %rbx
movl %r10d, (%rbx,%rsi)
movq 0x120(%rsp), %r10
movl %edi, (%r10,%rsi)
movq 0x118(%rsp), %rdi
movl %ecx, (%rdi,%rsi)
movl %edx, (%rbp,%rsi)
movq 0x110(%rsp), %rcx
movl 0x28(%rsp), %edx
movl %edx, (%rcx,%rsi)
movq 0x158(%rsp), %rcx
movl 0xc0(%rsp), %edx
movl %edx, (%rcx,%rsi)
movq 0x150(%rsp), %rcx
movl 0xb0(%rsp), %edx
movl %edx, (%rcx,%rsi)
movq 0x148(%rsp), %rcx
movl 0xa0(%rsp), %edx
movl %edx, (%rcx,%rsi)
movq 0x138(%rsp), %rsi
movdqa %xmm1, %xmm4
pcmpgtb %xmm0, %xmm1
pand %xmm1, %xmm4
pandn %xmm0, %xmm1
por %xmm4, %xmm1
movdqa %xmm5, %xmm4
pcmpgtb %xmm0, %xmm4
movdqa %xmm0, %xmm10
pand %xmm4, %xmm10
pandn %xmm5, %xmm4
por %xmm10, %xmm4
movdqa %xmm4, %xmm10
pcmpgtb %xmm9, %xmm10
movdqa %xmm9, %xmm5
pand %xmm10, %xmm5
pandn %xmm4, %xmm10
por %xmm5, %xmm10
movdqa %xmm10, %xmm5
pcmpgtb %xmm8, %xmm5
movdqa %xmm8, %xmm4
pand %xmm5, %xmm4
pandn %xmm10, %xmm5
por %xmm4, %xmm5
psubsb %xmm2, %xmm0
psubsb %xmm3, %xmm9
movdqa %xmm9, %xmm4
pcmpgtb %xmm0, %xmm4
pand %xmm4, %xmm9
pandn %xmm0, %xmm4
por %xmm9, %xmm4
movdqa %xmm4, (%r13,%r9)
psubsb %xmm3, %xmm8
movdqa %xmm8, %xmm4
pcmpgtb %xmm0, %xmm8
pand %xmm8, %xmm4
pandn %xmm0, %xmm8
por %xmm4, %xmm8
movdqa (%r12,%r9), %xmm0
addq $0x10, %r9
addq %r8, %rax
movq %rax, 0x40(%rsp)
cmpq %r9, %rsi
jne 0x313b88
movl $0x0, 0x3c(%rsp)
movq 0x100(%rsp), %rdi
movl 0x14(%rsp), %edx
cmpl $0x0, 0x248(%rsp)
jne 0x313e48
movq 0x58(%rsp), %rax
movq 0xe8(%rsp), %rdx
movsbl 0x1(%rax,%rdx), %edx
subl 0xc(%rsp), %edx
cmpl $-0x7f, %edx
movl $0xffffff80, %eax       # imm = 0xFFFFFF80
cmovll %eax, %edx
pslldq $0x1, %xmm8             # xmm8 = zero,xmm8[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movd %edx, %xmm0
movdqa %xmm7, %xmm4
pandn %xmm0, %xmm4
por %xmm4, %xmm8
movq 0xf0(%rsp), %rdx
xorl %r9d, %r9d
movdqa (%r14,%r9), %xmm4
movdqa %xmm4, %xmm0
pcmpgtb %xmm8, %xmm0
pand %xmm0, %xmm4
pandn %xmm8, %xmm0
por %xmm4, %xmm0
movdqa %xmm0, (%r14,%r9)
movq 0x10(%r15), %rax
movq (%rax), %rax
movsbl (%r14,%r9), %esi
movsbl 0x1(%r14,%r9), %ecx
movsbl 0x2(%r14,%r9), %r8d
movsbl 0x3(%r14,%r9), %r10d
movl %r10d, 0x40(%rsp)
movsbl 0x4(%r14,%r9), %r11d
movsbl 0x5(%r14,%r9), %ebx
movsbl 0x6(%r14,%r9), %ebp
movsbl 0x7(%r14,%r9), %r15d
movsbl 0x8(%r14,%r9), %r12d
movsbl 0x9(%r14,%r9), %r13d
movsbl 0xa(%r14,%r9), %r10d
movl %r10d, 0x70(%rsp)
movsbl 0xb(%r14,%r9), %r10d
movl %r10d, 0x28(%rsp)
movsbl 0xc(%r14,%r9), %r10d
movl %r10d, 0xc0(%rsp)
movsbl 0xd(%r14,%r9), %r10d
movl %r10d, 0xb0(%rsp)
movsbl 0xe(%r14,%r9), %r10d
movl %r10d, 0xa0(%rsp)
movsbl 0xf(%r14,%r9), %r10d
movl %r10d, 0x88(%rsp)
movl %esi, (%rax,%rdx)
movq 0x68(%rsp), %rsi
leaq (%rax,%rdx), %rax
movl %ecx, (%rdi,%rax)
movq %rdi, %rcx
movl %r8d, (%rsi,%rax)
movq 0x20(%rsp), %r8
movq 0x108(%rsp), %rsi
movl 0x40(%rsp), %edi
movl %edi, (%rsi,%rax)
movq 0x140(%rsp), %rsi
movl %r11d, (%rsi,%rax)
movq 0x138(%rsp), %rsi
movq 0x130(%rsp), %r11
movl %ebx, (%r11,%rax)
movq 0x128(%rsp), %r11
movq 0x168(%rsp), %rbx
movl %ebp, (%r11,%rax)
movq 0x160(%rsp), %rbp
movq 0x170(%rsp), %rdi
movl %r15d, (%rdi,%rax)
movq %rcx, %rdi
movq 0x178(%rsp), %r15
movl %r12d, (%rbx,%rax)
movq 0x120(%rsp), %r12
movl %r13d, (%r12,%rax)
movq 0x118(%rsp), %r12
movl 0x70(%rsp), %ecx
movl %ecx, (%r12,%rax)
movq 0x158(%rsp), %rcx
movl 0x28(%rsp), %r12d
movl %r12d, (%rbp,%rax)
movq 0x110(%rsp), %r12
movl 0xc0(%rsp), %r13d
movl %r13d, (%r12,%rax)
movl 0xb0(%rsp), %r12d
movl %r12d, (%rcx,%rax)
movq 0x150(%rsp), %r12
movl 0xa0(%rsp), %r13d
movl %r13d, (%r12,%rax)
movq 0x148(%rsp), %r12
movl 0x88(%rsp), %r13d
movl %r13d, (%r12,%rax)
movdqa %xmm5, %xmm4
pcmpgtb %xmm0, %xmm4
movdqa %xmm0, %xmm9
pand %xmm4, %xmm9
pandn %xmm5, %xmm4
movdqa %xmm4, %xmm5
por %xmm9, %xmm5
movdqa %xmm1, %xmm4
pcmpgtb %xmm0, %xmm1
pand %xmm1, %xmm4
pandn %xmm0, %xmm1
por %xmm4, %xmm1
psubsb %xmm2, %xmm0
psubsb %xmm3, %xmm8
movdqa %xmm8, %xmm4
pcmpgtb %xmm0, %xmm4
pmovmskb %xmm4, %eax
testl %eax, %eax
je 0x314093
addq $0x10, %r9
addq %r8, %rdx
cmpq %r9, %rsi
jne 0x313e75
movl 0x3c(%rsp), %eax
incl %eax
movl %eax, 0x3c(%rsp)
cmpl $0x10, %eax
jne 0x313e24
movq 0x1a8(%rsp), %rax
movdqa (%r14,%rax), %xmm0
movdqa %xmm0, %xmm4
pcmpgtb %xmm6, %xmm4
movdqa %xmm4, %xmm8
pand 0x180(%rsp), %xmm8
pand %xmm4, %xmm0
pandn %xmm6, %xmm4
movdqa %xmm4, %xmm6
por %xmm0, %xmm6
pmovmskb %xmm8, %eax
testl %eax, %eax
movl 0x8(%rsp), %eax
movq 0xe8(%rsp), %rdx
cmovnel %edx, %eax
movl %eax, 0x8(%rsp)
incq %rdx
movq 0xf0(%rsp), %r9
addq $0x4, %r9
movq %r14, %r12
cmpq 0xd0(%rsp), %rdx
movq 0xf8(%rsp), %r13
jne 0x313af8
cmpl $0x0, 0x250(%rsp)
movl 0x9c(%rsp), %r8d
movq 0x1a0(%rsp), %r9
movl 0x38(%rsp), %r10d
movl 0x10(%rsp), %r11d
movl 0x34(%rsp), %ebx
movl 0x94(%rsp), %ebp
je 0x314156
cmpl $0xe, %r10d
jg 0x31414c
xorl %eax, %eax
pslldq $0x1, %xmm6             # xmm6 = zero,xmm6[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
incl %eax
cmpl %ebp, %eax
jl 0x314141
pextrw $0x7, %xmm6, %r11d
shrl $0x8, %r11d
cmpl $0x0, 0x240(%rsp)
je 0x3141c2
cmpl $0x0, 0x198(%rsp)
je 0x3141c2
movq 0x18(%rsp), %rcx
andl $0x7ffffff, %ecx        # imm = 0x7FFFFFF
shll $0x4, %ecx
xorl %edx, %edx
movl %r8d, %eax
movl %edx, %edi
shrl $0x4, %edi
movl %edx, %esi
andl $0xf, %esi
imull 0x18(%rsp), %esi
addl %edi, %esi
cmpl %r9d, %esi
jge 0x3141b9
movb (%r14,%rdx), %dil
cmpb %r11b, %dil
jle 0x3141a7
movl %edi, %r11d
movl %ebx, 0x8(%rsp)
movl %esi, %eax
jmp 0x3141b9
cmpl %eax, %esi
cmovgel %eax, %esi
cmpl %ebx, 0x8(%rsp)
cmovnel %eax, %esi
cmpb %r11b, %dil
cmovel %esi, %eax
incq %rdx
cmpl %edx, %ecx
jne 0x31417d
jmp 0x3141c5
movl %r8d, %eax
movl 0x240(%rsp), %ecx
orl %ecx, 0x98(%rsp)
movq 0x58(%rsp), %rdi
jne 0x314210
movq 0x190(%rsp), %rax
shlq $0x4, %rax
movdqa (%r14,%rax), %xmm0
cmpl $0xe, %r10d
jg 0x3141ff
xorl %eax, %eax
pslldq $0x1, %xmm0             # xmm0 = zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
incl %eax
cmpl %ebp, %eax
jl 0x3141f4
pextrw $0x7, %xmm0, %r11d
shrl $0x8, %r11d
movl %ebx, 0x8(%rsp)
movl %r8d, %eax
pcmpgtb %xmm5, %xmm11
pcmpgtb %xmm12, %xmm1
por %xmm11, %xmm1
pmovmskb %xmm1, %ecx
testl %ecx, %ecx
je 0x314239
orb $0x40, 0xc(%r15)
xorl %r11d, %r11d
movl $0x0, 0x8(%rsp)
xorl %eax, %eax
movsbl %r11b, %ecx
movl %ecx, (%r15)
movl %eax, 0x4(%r15)
movl 0x8(%rsp), %eax
movl %eax, 0x8(%r15)
callq 0x20a60d
movq %r13, %rdi
callq 0x20a60d
movq 0x60(%rsp), %rdi
callq 0x20a60d
movq %r14, %rdi
callq 0x20a60d
jmp 0x3130b6
callq 0x1aee7d
jmp 0x3130b3
callq 0x1aee57
jmp 0x3130b3
callq 0x1aee31
jmp 0x3130b3
callq 0x1aee0b
jmp 0x3130b3
callq 0x1aede5
jmp 0x3130b3
callq 0x1aedbf
jmp 0x3130b3
callq 0x1aed99
jmp 0x3130b3
callq 0x1aed73
jmp 0x3130b3