// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_trace_striped_sse2_128_8.c
// Function: parasail_sw_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 end_query = 0;
    int32_t end_ref = 0;
    int32_t s1Len = 0;
    const parasail_matrix_t *matrix = NULL;
    int32_t segWidth = 0;
    int32_t segLen = 0;
    __m128i* restrict 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;
    __m128i* restrict pvHMax = NULL;
    __m128i vGapO;
    __m128i vGapE;
    __m128i vZero;
    int8_t score = 0;
    __m128i vMaxH;
    __m128i vMaxHUnit;
    int8_t maxp = 0;
    parasail_result_t *result = NULL;
    __m128i vTZero;
    __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;
    end_query = 0;
    end_ref = 0;
    s1Len = profile->s1Len;
    matrix = profile->matrix;
    segWidth = 16; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    vProfile = (__m128i*)profile->profile8.score;
    vGapO = _mm_set1_epi8(open);
    vGapE = _mm_set1_epi8(gap);
    vZero = _mm_setzero_si128();
    score = NEG_INF;
    vMaxH = vZero;
    vMaxHUnit = vZero;
    maxp = INT8_MAX - (int8_t)(matrix->max+1);
    vTZero = _mm_set1_epi8(PARASAIL_ZERO);
    vTIns  = _mm_set1_epi8(PARASAIL_INS);
    vTDel  = _mm_set1_epi8(PARASAIL_DEL);
    vTDiag = _mm_set1_epi8(PARASAIL_DIAG);
    vTDiagE= _mm_set1_epi8(PARASAIL_DIAG_E);
    vTInsE = _mm_set1_epi8(PARASAIL_INS_E);
    vTDiagF= _mm_set1_epi8(PARASAIL_DIAG_F);
    vTDelF = _mm_set1_epi8(PARASAIL_DEL_F);
    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_SW | 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);
    pvHMax = parasail_memalign___m128i(16, segLen);

    /* 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 (!pvHMax) return NULL;

    /* initialize H and E */
    parasail_memset___m128i(pvHStore, vZero, segLen);
    parasail_memset___m128i(pvE, _mm_set1_epi8(-open), segLen);
    parasail_memset___m128i(pvEaStore, _mm_set1_epi8(-open), segLen);

    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 0.  Any errors to vH values will be
         * corrected in the Lazy_F loop. */
        vF = _mm_subs_epi8(vZero,vGapO);

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

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

        if (end_ref == j-2) {
            /* Swap in the max buffer. */
            SWAP3(pvHMax,  pvHLoad,  pvHStore)
            SWAP(pvEaLoad,  pvEaStore)
        }
        else {
            /* 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_dag = _mm_max_epi8_rpl(vH_dag, vZero);
            vH = _mm_max_epi8_rpl(vH_dag, vE);
            vH = _mm_max_epi8_rpl(vH, vF);
            /* Save vH values. */
            _mm_store_si128(pvHStore + i, vH);

            {
                __m128i vTAll = arr_load(result->trace->trace_table, i, segLen, j);
                __m128i cond_zero = _mm_cmpeq_epi8(vH, vZero);
                __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),
                        _mm_blendv_epi8_rpl(vTDiag, vTZero, cond_zero),
                        case1);
                _mm_store_si128(pvHT + i, vT);
                vT = _mm_or_si128(vT, vTAll);
                arr_store(result->trace->trace_table, vT, i, segLen, j);
            }
            vMaxH = _mm_max_epi8_rpl(vH, vMaxH);
            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) {
            __m128i vHp = _mm_load_si128(&pvHLoad[segLen - 1]);
            vHp = _mm_slli_si128(vHp, 1);
            vEF_opn = _mm_slli_si128(vEF_opn, 1);
            vEF_opn = _mm_insert_epi8_rpl(vEF_opn, -open, 0);
            vF_ext = _mm_slli_si128(vF_ext, 1);
            vF_ext = _mm_insert_epi8_rpl(vF_ext, NEG_INF, 0);
            vF = _mm_slli_si128(vF, 1);
            vF = _mm_insert_epi8_rpl(vF, -open, 0);
            vFa_ext = _mm_slli_si128(vFa_ext, 1);
            vFa_ext = _mm_insert_epi8_rpl(vFa_ext, NEG_INF, 0);
            vFa = _mm_slli_si128(vFa, 1);
            vFa = _mm_insert_epi8_rpl(vFa, -open, 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);
                {
                    __m128i vTAll;
                    __m128i vT;
                    __m128i case1;
                    __m128i case2;
                    __m128i cond;
                    vHp = _mm_adds_epi8(vHp, _mm_load_si128(vP + i));
                    vHp = _mm_max_epi8_rpl(vHp, vZero);
                    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);
                }
                vMaxH = _mm_max_epi8_rpl(vH, vMaxH);
                /* 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:
        {
        }

        {
            __m128i vCompare = _mm_cmpgt_epi8(vMaxH, vMaxHUnit);
            if (_mm_movemask_epi8(vCompare)) {
                score = _mm_hmax_epi8_rpl(vMaxH);
                /* if score has potential to overflow, abort early */
                if (score > maxp) {
                    result->flag |= PARASAIL_FLAG_SATURATED;
                    break;
                }
                vMaxHUnit = _mm_set1_epi8(score);
                end_ref = j;
            }
        }

        /*if (score == stop) break;*/
    }

    if (score == INT8_MAX) {
        result->flag |= PARASAIL_FLAG_SATURATED;
    }

    if (parasail_result_is_saturated(result)) {
        score = 0;
        end_query = 0;
        end_ref = 0;
    }
    else {
        if (end_ref == j-1) {
            /* end_ref was the last store column */
            SWAP(pvHMax,  pvHStore)
        }
        else if (end_ref == j-2) {
            /* end_ref was the last load column */
            SWAP(pvHMax,  pvHLoad)
        }
        /* Trace the alignment ending position on read. */
        {
            int8_t *t = (int8_t*)pvHMax;
            int32_t column_len = segLen * segWidth;
            end_query = s1Len - 1;
            for (i = 0; i<column_len; ++i, ++t) {
                if (*t == score) {
                    int32_t temp = i / segWidth + i % segWidth * segLen;
                    if (temp < end_query) {
                        end_query = temp;
                    }
                }
            }
        }
    }

    result->score = score;
    result->end_query = end_query;
    result->end_ref = end_ref;

    parasail_free(pvHMax);
    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 $0x108, %rsp            # imm = 0x108
movq %rsi, 0x78(%rsp)
testq %rdi, %rdi
je 0x3a1bc5
movq 0x18(%rdi), %rax
movq %rax, 0xb0(%rsp)
testq %rax, %rax
je 0x3a1bcc
movq 0x10(%rdi), %rax
movq %rax, 0x70(%rsp)
testq %rax, %rax
je 0x3a1bd3
movl 0x8(%rdi), %r14d
testl %r14d, %r14d
jle 0x3a1bda
cmpq $0x0, 0x78(%rsp)
je 0x3a1be1
movl %edx, %ebp
testl %edx, %edx
jle 0x3a1be8
testl %ecx, %ecx
js 0x3a1bef
testl %r8d, %r8d
js 0x3a1bf6
movl %r8d, 0x60(%rsp)
movl %ecx, 0x30(%rsp)
leaq 0xf(%r14), %r15
movq %r15, %r12
shrq $0x4, %r12
movq 0x70(%rsp), %rax
movl 0x1c(%rax), %r13d
movl $0x10, %edx
movl $0x10, %ecx
movl %r12d, %edi
movl %ebp, %esi
callq 0x2097d1
testq %rax, %rax
je 0x3a1bfb
movq %rax, %rbx
movl %r13d, 0x8(%rsp)
movl %ebp, 0x50(%rsp)
movq %r15, 0x90(%rsp)
movq %r14, 0x98(%rsp)
orl $0x10180804, 0xc(%rax)  # imm = 0x10180804
movl $0x10, %edi
movq %r12, %rsi
callq 0x2ea474
movq %rax, %r15
movl $0x10, %edi
movq %r12, %rsi
callq 0x2ea474
movq %r12, %r13
movq %rax, %r12
movl $0x10, %edi
movq %r13, %rsi
callq 0x2ea474
movq %rax, 0x28(%rsp)
movl $0x10, %edi
movq %r13, %rsi
callq 0x2ea474
movq %rax, 0x10(%rsp)
movl $0x10, %edi
movq %r13, %rsi
callq 0x2ea474
movq %rax, %r14
movl $0x10, %edi
movq %r13, %rsi
callq 0x2ea474
movq %rax, %rbp
movl $0x10, %edi
movq %r13, 0x40(%rsp)
movq %r13, %rsi
callq 0x2ea474
movq %rax, %rcx
xorl %eax, %eax
testq %r15, %r15
je 0x3a1c4c
testq %r12, %r12
je 0x3a1c4c
cmpq $0x0, 0x28(%rsp)
je 0x3a1c4c
movq 0x10(%rsp), %rdx
testq %rdx, %rdx
je 0x3a1c4c
testq %r14, %r14
je 0x3a1c4c
testq %rbp, %rbp
je 0x3a1c4c
testq %rcx, %rcx
je 0x3a1c4c
movq %rcx, 0x20(%rsp)
movd 0x30(%rsp), %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x80(%rsp)
movd 0x60(%rsp), %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x60(%rsp)
pxor %xmm0, %xmm0
movq %r15, %rdi
movq 0x40(%rsp), %r13
movq %r13, %rsi
callq 0x2ea47d
movl 0x30(%rsp), %eax
negb %al
movzbl %al, %eax
movd %eax, %xmm0
movdqa %xmm0, 0xe0(%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, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x30(%rsp)
movq 0x28(%rsp), %rdi
movq %r13, %rsi
callq 0x2ea47d
movq 0x10(%rsp), %rdi
movaps 0x30(%rsp), %xmm0
movq %r13, %rsi
callq 0x2ea47d
movl %r13d, %eax
movq %rax, 0x30(%rsp)
movq %rax, %rdx
shlq $0x4, %rdx
xorl %eax, %eax
movdqa 0x1f4cec(%rip), %xmm0   # 0x596180
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
movdqa %xmm0, (%rcx,%rax)
addq $0x10, %rax
cmpq %rax, %rdx
jne 0x3a1494
pxor %xmm0, %xmm0
pxor %xmm1, %xmm1
psubsb 0x80(%rsp), %xmm1
movdqa %xmm1, 0xd0(%rsp)
movq 0x40(%rsp), %rdi
leal -0x1(%rdi), %ecx
movb $0x7e, %al
subb 0x8(%rsp), %al
movsbl %al, %eax
movl %eax, 0x5c(%rsp)
cmpl $0x1, %edi
adcl $0x0, %edi
movl 0x50(%rsp), %esi
cmpl $0x2, %esi
movl $0x1, %eax
cmovgel %esi, %eax
movq %rax, 0x48(%rsp)
movl %esi, %r8d
shlq $0x4, %rdi
movb $-0x80, %al
movl %eax, 0xc(%rsp)
xorl %r9d, %r9d
shlq $0x4, %rcx
movq %rcx, 0xa8(%rsp)
movdqa 0x1f4c3a(%rip), %xmm2   # 0x596150
movdqa 0x256162(%rip), %xmm6   # 0x5f7680
movdqa 0x1f4c8a(%rip), %xmm7   # 0x5961b0
movdqa 0x256481(%rip), %xmm10  # 0x5f79b0
movdqa 0x256488(%rip), %xmm11  # 0x5f79c0
movq %rdx, 0xa0(%rsp)
movq %rdx, %r10
xorl %eax, %eax
xorl %r11d, %r11d
pxor %xmm12, %xmm12
pxor %xmm1, %xmm1
movdqa %xmm1, 0xc0(%rsp)
movq 0x10(%rsp), %rcx
movq %r10, 0x10(%rsp)
movq 0x20(%rsp), %r10
movq %r10, 0x18(%rsp)
movq %r14, %r13
movq %rcx, %r14
movq %r12, 0xb8(%rsp)
movq %r15, %r12
movq 0xa8(%rsp), %rdx
leaq (%r15,%rdx), %rcx
movq %rcx, 0x50(%rsp)
movq %rax, %rcx
movq 0x70(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x78(%rsp), %rsi
movzbl (%rsi,%rcx), %esi
movslq (%rax,%rsi,4), %rsi
movq 0x30(%rsp), %rax
imulq %rsi, %rax
shlq $0x4, %rax
addq 0xb0(%rsp), %rax
leal -0x2(%rcx), %esi
movl %r11d, 0x8(%rsp)
cmpl %esi, %r11d
movq 0xb8(%rsp), %r15
cmoveq %r15, %r10
movq %r10, 0x20(%rsp)
cmoveq 0x18(%rsp), %r15
movdqa (%r12,%rdx), %xmm15
pslldq $0x1, %xmm15            # xmm15 = zero,xmm15[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movq %rcx, 0x18(%rsp)
leaq 0x1(%rcx), %r11
movl $0x1, %esi
xorl %edx, %edx
movdqa 0xd0(%rsp), %xmm5
paddsb (%rax,%rdx), %xmm15
movq 0x28(%rsp), %r10
movdqa (%r10,%rdx), %xmm1
movdqa %xmm15, %xmm8
pcmpgtb %xmm0, %xmm8
pand %xmm15, %xmm8
movdqa %xmm8, %xmm13
pcmpgtb %xmm1, %xmm13
movdqa %xmm8, %xmm14
pand %xmm13, %xmm14
pandn %xmm1, %xmm13
por %xmm14, %xmm13
movdqa %xmm13, %xmm14
pcmpgtb %xmm5, %xmm14
pand %xmm14, %xmm13
movdqa %xmm14, %xmm15
pandn %xmm5, %xmm15
por %xmm13, %xmm15
movdqa %xmm15, (%r15,%rdx)
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq %r9, %rcx
pcmpeqb %xmm15, %xmm8
movdqa %xmm15, %xmm13
pcmpeqb %xmm0, %xmm13
pandn %xmm8, %xmm13
pand 0x1f4ae2(%rip), %xmm13  # 0x596170
paddb %xmm2, %xmm14
pandn %xmm14, %xmm8
por %xmm13, %xmm8
movdqa (%rdx,%rcx), %xmm13
por %xmm8, %xmm13
movdqa %xmm8, (%rbp,%rdx)
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq %r9, %rcx
movdqa %xmm13, (%rdx,%rcx)
movdqa %xmm15, %xmm9
psubsb 0x80(%rsp), %xmm9
movdqa 0x60(%rsp), %xmm13
psubsb %xmm13, %xmm1
movdqa %xmm9, %xmm8
pcmpgtb %xmm1, %xmm8
movdqa %xmm9, %xmm3
pand %xmm8, %xmm3
pandn %xmm1, %xmm8
por %xmm3, %xmm8
movdqa %xmm8, (%r10,%rdx)
movdqa (%r14,%rdx), %xmm8
psubsb %xmm13, %xmm8
movdqa %xmm9, %xmm3
pcmpgtb %xmm8, %xmm3
movdqa %xmm9, %xmm4
pand %xmm3, %xmm4
movdqa %xmm3, %xmm1
pandn %xmm8, %xmm1
por %xmm4, %xmm1
movdqa %xmm1, (%r13,%rdx)
cmpq %r8, %r11
jae 0x3a1756
pand 0x255f33(%rip), %xmm3   # 0x5f7670
pxor 0x1f4a4b(%rip), %xmm3   # 0x596190
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq 0x10(%rsp), %rcx
movdqa %xmm3, (%rdx,%rcx)
movdqa %xmm5, %xmm4
psubsb %xmm13, %xmm4
movdqa %xmm9, %xmm5
pcmpgtb %xmm4, %xmm5
cmpq 0x30(%rsp), %rsi
jae 0x3a1791
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq %r9, %rcx
movdqa %xmm5, %xmm1
pand %xmm6, %xmm1
pxor %xmm7, %xmm1
por 0x10(%rdx,%rcx), %xmm1
movdqa %xmm1, 0x10(%rdx,%rcx)
movdqa %xmm15, %xmm1
pcmpgtb %xmm12, %xmm1
pand %xmm1, %xmm15
pandn %xmm12, %xmm1
movdqa %xmm1, %xmm12
por %xmm15, %xmm12
movdqa %xmm9, %xmm1
pand %xmm5, %xmm1
pandn %xmm4, %xmm5
por %xmm1, %xmm5
movdqa (%r12,%rdx), %xmm15
addq $0x10, %rdx
incq %rsi
cmpq %rdx, %rdi
jne 0x3a1605
xorl %esi, %esi
movdqa %xmm5, %xmm15
movdqa 0x60(%rsp), %xmm14
movq 0x10(%rsp), %r10
pslldq $0x1, %xmm15            # xmm15 = zero,xmm15[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movdqa 0x254289(%rip), %xmm1   # 0x5f5a80
pandn 0xe0(%rsp), %xmm1
por %xmm1, %xmm15
pslldq $0x1, %xmm4             # xmm4 = zero,xmm4[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
por 0x25469e(%rip), %xmm4   # 0x5f5eb0
pslldq $0x1, %xmm5             # xmm5 = zero,xmm5[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
por %xmm1, %xmm5
pslldq $0x1, %xmm9             # xmm9 = zero,xmm9[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
por %xmm1, %xmm9
movq 0x50(%rsp), %rcx
movdqa (%rcx), %xmm8
pslldq $0x1, %xmm8             # xmm8 = zero,xmm8[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
xorl %edx, %edx
movdqa (%r15,%rdx), %xmm3
movdqa %xmm3, %xmm1
pcmpgtb %xmm5, %xmm1
pand %xmm1, %xmm3
movdqa %xmm1, %xmm13
pandn %xmm5, %xmm13
por %xmm3, %xmm13
movdqa %xmm13, (%r15,%rdx)
paddsb (%rax,%rdx), %xmm8
movdqa %xmm8, %xmm3
pcmpgtb %xmm0, %xmm3
pand %xmm8, %xmm3
pcmpeqb %xmm13, %xmm3
por %xmm1, %xmm3
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq %r9, %rcx
movdqa (%rdx,%rcx), %xmm1
pand %xmm10, %xmm1
movdqa (%rbp,%rdx), %xmm8
pand %xmm3, %xmm8
pandn %xmm2, %xmm3
por %xmm8, %xmm3
movdqa %xmm3, (%rbp,%rdx)
por %xmm1, %xmm3
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq %r9, %rcx
movdqa %xmm3, (%rdx,%rcx)
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq %r9, %rcx
pcmpgtb %xmm4, %xmm9
pand %xmm6, %xmm9
movdqa (%rdx,%rcx), %xmm1
pand %xmm11, %xmm1
por %xmm9, %xmm1
pxor %xmm7, %xmm1
movdqa %xmm1, (%rdx,%rcx)
movdqa %xmm13, %xmm9
psubsb 0x80(%rsp), %xmm9
movdqa (%r14,%rdx), %xmm1
psubsb %xmm14, %xmm1
movdqa %xmm9, %xmm14
pcmpgtb %xmm1, %xmm14
movdqa %xmm9, %xmm3
pand %xmm14, %xmm3
movdqa %xmm14, %xmm8
pandn %xmm1, %xmm8
por %xmm3, %xmm8
movdqa %xmm8, (%r13,%rdx)
cmpq %r8, %r11
jae 0x3a1955
pand 0x255d34(%rip), %xmm14  # 0x5f7670
pxor 0x1f484b(%rip), %xmm14  # 0x596190
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq %r10, %rcx
movdqa %xmm14, (%rdx,%rcx)
movdqa %xmm13, %xmm1
pcmpgtb %xmm12, %xmm1
pand %xmm1, %xmm13
pandn %xmm12, %xmm1
movdqa %xmm1, %xmm12
por %xmm13, %xmm12
movdqa %xmm5, %xmm1
movdqa 0x60(%rsp), %xmm14
psubsb %xmm14, %xmm1
movdqa %xmm9, %xmm3
pcmpgtb %xmm1, %xmm3
pmovmskb %xmm3, %ecx
xorl $0xffff, %ecx           # imm = 0xFFFF
setne %cl
je 0x3a19e2
movdqa %xmm15, %xmm4
psubsb %xmm14, %xmm4
movdqa %xmm9, %xmm15
pcmpgtb %xmm4, %xmm15
movdqa %xmm9, %xmm3
pand %xmm15, %xmm3
pandn %xmm4, %xmm15
por %xmm3, %xmm15
movdqa (%r12,%rdx), %xmm8
addq $0x10, %rdx
movdqa %xmm1, %xmm5
cmpq %rdx, %rdi
jne 0x3a1838
xorl %edx, %edx
movdqa %xmm1, %xmm5
jmp 0x3a19e7
movl $0x21, %edx
testl %edx, %edx
jne 0x3a19f8
incl %esi
cmpl $0x10, %esi
jne 0x3a17e9
jmp 0x3a1a01
cmpl $0x21, %edx
jne 0x3a1adb
movdqa %xmm12, %xmm1
pcmpgtb 0xc0(%rsp), %xmm1
pmovmskb %xmm1, %eax
movb $0x1, %cl
testl %eax, %eax
je 0x3a1adb
movdqa %xmm12, %xmm1
psrldq $0x8, %xmm1             # xmm1 = xmm1[8,9,10,11,12,13,14,15],zero,zero,zero,zero,zero,zero,zero,zero
movdqa %xmm12, %xmm3
pcmpgtb %xmm1, %xmm3
movdqa %xmm12, %xmm4
pand %xmm3, %xmm4
pandn %xmm1, %xmm3
por %xmm4, %xmm3
movdqa %xmm3, %xmm1
psrldq $0x4, %xmm1             # xmm1 = xmm1[4,5,6,7,8,9,10,11,12,13,14,15],zero,zero,zero,zero
movdqa %xmm3, %xmm4
pcmpgtb %xmm1, %xmm4
pand %xmm4, %xmm3
pandn %xmm1, %xmm4
por %xmm3, %xmm4
movdqa %xmm4, %xmm1
psrldq $0x2, %xmm1             # xmm1 = xmm1[2,3,4,5,6,7,8,9,10,11,12,13,14,15],zero,zero
movdqa %xmm4, %xmm3
pcmpgtb %xmm1, %xmm3
pand %xmm3, %xmm4
pandn %xmm1, %xmm3
por %xmm4, %xmm3
movdqa %xmm3, %xmm4
psrldq $0x1, %xmm4             # xmm4 = xmm4[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],zero
movdqa %xmm3, %xmm1
pcmpgtb %xmm4, %xmm1
pand %xmm1, %xmm3
pandn %xmm4, %xmm1
por %xmm3, %xmm1
movdqa %xmm1, 0xf0(%rsp)
movsbl 0xf0(%rsp), %eax
movl %eax, 0xc(%rsp)
cmpl %eax, 0x5c(%rsp)
jge 0x3a1abb
orb $0x40, 0xc(%rbx)
xorl %ecx, %ecx
jmp 0x3a1adb
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, 0xc0(%rsp)
movq 0x18(%rsp), %rax
movl %eax, 0x8(%rsp)
testb %cl, %cl
je 0x3a1b05
movq 0xa0(%rsp), %rax
addq %rax, %r10
addq %rax, %r9
movq %r11, %rax
movq %r13, %rcx
cmpq 0x48(%rsp), %r11
movl 0x8(%rsp), %r11d
jne 0x3a155f
jmp 0x3a1b0f
movq 0x18(%rsp), %rax
movq %rax, 0x48(%rsp)
cmpb $0x7f, 0xc(%rsp)
jne 0x3a1b1a
orb $0x40, 0xc(%rbx)
movq %rbx, %rdi
callq 0x20a805
xorl %ecx, %ecx
testl %eax, %eax
je 0x3a1b38
movq 0x20(%rsp), %rdi
xorl %r10d, %r10d
xorl %r8d, %r8d
jmp 0x3a1c08
movq 0x48(%rsp), %rcx
leal -0x1(%rcx), %eax
addl $-0x2, %ecx
movl 0x8(%rsp), %r10d
cmpl %ecx, %r10d
movq 0x20(%rsp), %rcx
movq %rcx, %rdi
cmoveq %r12, %rdi
movq %r12, %rdx
cmoveq %rcx, %rdx
cmpl %eax, %r10d
cmoveq %r15, %rdi
cmoveq %r12, %rdx
movq %rdx, %r12
cmoveq %rcx, %r15
movq 0x98(%rsp), %r8
decl %r8d
testl $0x7ffffff0, 0x90(%rsp) # imm = 0x7FFFFFF0
je 0x3a1bff
movq 0x40(%rsp), %r9
movl %r9d, %eax
andl $0x7ffffff, %eax        # imm = 0x7FFFFFF
shll $0x4, %eax
xorl %ecx, %ecx
movl 0xc(%rsp), %r11d
cmpb %r11b, (%rdi,%rcx)
jne 0x3a1bbc
movl %ecx, %edx
shrl $0x4, %edx
movl %ecx, %esi
andl $0xf, %esi
imull %r9d, %esi
addl %edx, %esi
cmpl %r8d, %esi
cmovll %esi, %r8d
incq %rcx
cmpl %ecx, %eax
jne 0x3a1b9f
jmp 0x3a1c04
callq 0x1c011b
jmp 0x3a1bfb
callq 0x1c00f5
jmp 0x3a1bfb
callq 0x1c00cf
jmp 0x3a1bfb
callq 0x1c00a9
jmp 0x3a1bfb
callq 0x1c0083
jmp 0x3a1bfb
callq 0x1c005d
jmp 0x3a1bfb
callq 0x1c0037
jmp 0x3a1bfb
callq 0x1c0011
xorl %eax, %eax
jmp 0x3a1c4c
movl 0xc(%rsp), %r11d
movsbl %r11b, %ecx
movl %ecx, (%rbx)
movl %r8d, 0x4(%rbx)
movl %r10d, 0x8(%rbx)
callq 0x2094b5
movq %rbp, %rdi
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
movq %r13, %rdi
callq 0x2094b5
movq 0x28(%rsp), %rdi
callq 0x2094b5
movq %r12, %rdi
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
movq %rbx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop