// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_trace_scan_sse41_128_8.c
// Function: parasail_sg_flags_trace_scan_profile_sse41_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(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(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(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(vTInsE, vTDiagE, case1);
            arr_store(result->trace->trace_table, vET, i, segLen, j);
            vE = _mm_max_epi8(vE_opn, vE_ext);
            vSaturationCheckMin = _mm_min_epi8(vSaturationCheckMin, vE);
            vGapper = _mm_adds_epi8(vHt, vGapper);
            vF = _mm_max_epi8(vF, vGapper);
            vHp = _mm_adds_epi8(vHp, vW);
            vHt = _mm_max_epi8(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(vHt, boundary[j+1], 0);
        vGapper = _mm_load_si128(pvGapper);
        vGapper = _mm_adds_epi8(vHt, vGapper);
        vF = _mm_max_epi8(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(vF, vFt);
        }

        /* calculate final H */
        vF = _mm_slli_si128(vF, 1);
        vF = _mm_adds_epi8(vF, vNegInfFront);
        vH = _mm_max_epi8(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(vF_opn, vF_ext);
            case1 = _mm_cmpgt_epi8(vF_opn, vF_ext);
            vFT = _mm_blendv_epi8(vTDelF, vTDiagF, case1);
            vH = _mm_max_epi8(vHt, vF);
            case1 = _mm_cmpeq_epi8(vH, vHp);
            case2 = _mm_cmpeq_epi8(vH, vF);
            vT = _mm_blendv_epi8(
                    _mm_blendv_epi8(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(vSaturationCheckMin, vH);
            vSaturationCheckMin = _mm_min_epi8(vSaturationCheckMin, vF);
            vSaturationCheckMax = _mm_max_epi8(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(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(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 (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 $0x108, %rsp            # imm = 0x108
movq %rsi, 0x78(%rsp)
testq %rdi, %rdi
je 0x471044
movq 0x18(%rdi), %rax
movq %rax, 0xc8(%rsp)
testq %rax, %rax
je 0x47104b
movq 0x10(%rdi), %rax
movq %rax, 0x70(%rsp)
testq %rax, %rax
je 0x471052
movl %ecx, %r12d
movl 0x8(%rdi), %ecx
testl %ecx, %ecx
jle 0x471059
cmpq $0x0, 0x78(%rsp)
je 0x471060
movl %edx, %ebp
testl %edx, %edx
jle 0x471067
testl %r12d, %r12d
js 0x47106e
testl %r8d, %r8d
js 0x471075
movl %r9d, %r13d
movl %r8d, 0x38(%rsp)
leal -0x1(%rcx), %eax
movq %rcx, 0xc0(%rsp)
leaq 0xf(%rcx), %r15
movq %r15, %r14
shrq $0x4, %r14
movl %eax, 0x4c(%rsp)
cltd
idivl %r14d
movl %eax, 0x10(%rsp)
movl %edx, 0x40(%rsp)
movl %r12d, %esi
negl %esi
movq 0x70(%rsp), %rdx
movl 0x20(%rdx), %eax
movl %eax, %ecx
negb %cl
movl %esi, 0x80(%rsp)
cmpl %esi, %eax
movzbl %cl, %eax
cmovgl %r12d, %eax
movl %eax, 0x14(%rsp)
movb $0x7e, %al
subb 0x1c(%rdx), %al
movb %al, 0x20(%rsp)
movl $0x10, %edx
movl $0x10, %ecx
movl %r14d, %edi
movl %ebp, %esi
callq 0x2097d1
testq %rax, %rax
je 0x47107a
movq %rax, %rbx
movl %r12d, 0x50(%rsp)
movq %r15, 0xb0(%rsp)
movl 0x150(%rsp), %edi
xorl %eax, %eax
testl %r13d, %r13d
setne %al
xorl %ecx, %ecx
cmpl $0x0, 0x140(%rsp)
setne %cl
shll $0x4, %ecx
xorl %edx, %edx
cmpl $0x0, 0x148(%rsp)
setne %dl
shll $0xe, %edx
xorl %esi, %esi
movl %edi, 0x48(%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 %r14, %rsi
callq 0x2ea474
movq %rax, %r15
leal 0x1(%rbp), %esi
movl $0x10, %edi
movq %rsi, 0xb8(%rsp)
callq 0x2094c8
movq %rax, 0x28(%rsp)
movl $0x10, %edi
movq %r14, %rsi
callq 0x2ea474
movq %r14, %r12
movq %rax, %r14
movl $0x10, %edi
movq %r12, %rsi
callq 0x2ea474
movq %rbp, 0x68(%rsp)
movq %rax, %rbp
movl $0x10, %edi
movq %r12, 0x18(%rsp)
movq %r12, %rsi
callq 0x2ea474
testq %r15, %r15
sete %cl
cmpq $0x0, 0x28(%rsp)
sete %dl
orb %cl, %dl
testq %r14, %r14
sete %cl
testq %rbp, %rbp
sete %sil
orb %cl, %sil
orb %dl, %sil
testq %rax, %rax
sete %cl
orb %sil, %cl
jne 0x47107a
movq 0x68(%rsp), %rcx
decl %ecx
movl %ecx, 0xc(%rsp)
movl $0xf, %edx
subl 0x10(%rsp), %edx
movl 0x50(%rsp), %edi
movd %edi, %xmm5
pxor %xmm0, %xmm0
pshufb %xmm0, %xmm5
movl 0x38(%rsp), %esi
movd %esi, %xmm6
pshufb %xmm0, %xmm6
movl 0x14(%rsp), %r12d
addb $-0x7f, %r12b
movl %r12d, 0x14(%rsp)
movzbl %r12b, %ecx
movd %ecx, %xmm2
movdqa %xmm2, %xmm1
pshufb %xmm0, %xmm1
movdqa %xmm1, 0x90(%rsp)
movzbl 0x20(%rsp), %ecx
movd %ecx, %xmm4
pshufb %xmm0, %xmm4
movl %edx, 0x34(%rsp)
movd %edx, %xmm1
pshufb %xmm0, %xmm1
movdqa %xmm1, 0xa0(%rsp)
movq 0x18(%rsp), %r8
movl %r8d, %ecx
imull %esi, %ecx
negb %cl
movzbl %cl, %ecx
movd %ecx, %xmm9
pshufb 0x1853ed(%rip), %xmm9   # 0x5f5eb0
movdqa %xmm2, 0xd0(%rsp)
paddsb %xmm2, %xmm9
movl %edi, %ecx
movl %esi, %esi
movslq 0x80(%rsp), %rdx
movl %r8d, %r8d
movq %r8, 0x20(%rsp)
movq %rsi, 0x50(%rsp)
imulq %rsi, %r8
xorl %r9d, %r9d
movq $-0x80, %r10
movq %rdx, %rsi
xorl %edi, %edi
testl %r13d, %r13d
je 0x470b07
xorl %r11d, %r11d
jmp 0x470b0a
movq %rsi, %r11
cmpq $-0x7f, %r11
movq $-0x80, %r12
cmovgeq %r11, %r12
movb %r12b, 0xf0(%rsp,%rdi)
subq %rcx, %r11
cmpq $-0x7f, %r11
cmovlq %r10, %r11
movb %r11b, 0xe0(%rsp,%rdi)
incq %rdi
subq %r8, %rsi
cmpq $0x10, %rdi
jne 0x470afd
movq %r9, %rsi
shlq $0x4, %rsi
movaps 0xf0(%rsp), %xmm0
movaps %xmm0, (%rbp,%rsi)
movdqa 0xe0(%rsp), %xmm0
movdqa %xmm0, (%r15,%rsi)
incq %r9
subq 0x50(%rsp), %rdx
cmpq 0x20(%rsp), %r9
jne 0x470af8
movq 0x28(%rsp), %rdi
movb $0x0, (%rdi)
movl $0x1, %ecx
xorl %edx, %edx
movl 0x38(%rsp), %r8d
movl 0x80(%rsp), %r9d
movl 0x148(%rsp), %r10d
movq 0xb8(%rsp), %r11
cmpl $-0x7f, %r9d
movl $0xffffff80, %esi       # imm = 0xFFFFFF80
cmovgel %r9d, %esi
testl %r10d, %r10d
cmovnel %edx, %esi
movb %sil, (%rdi,%rcx)
incq %rcx
subl %r8d, %r9d
cmpq %rcx, %r11
jne 0x470b9e
pxor %xmm0, %xmm0
psubsb %xmm5, %xmm0
movq 0x18(%rsp), %rdi
leal -0x1(%rdi), %ecx
movq %rcx, %rsi
shlq $0x4, %rsi
movq %rax, %rdx
addq %rsi, %rdx
movl %edi, %esi
movdqa %xmm4, 0x80(%rsp)
movdqa %xmm0, (%rdx)
psubsb %xmm6, %xmm0
pminsb %xmm0, %xmm4
addq $-0x10, %rdx
decl %esi
jg 0x470be8
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rbp, %rcx
movq %rcx, 0x38(%rsp)
movl 0x40(%rsp), %r10d
movq %r10, 0x40(%rsp)
shlq $0x4, %r10
addq %rbp, %r10
movq 0x18(%rsp), %r11
cmpl $0x1, %r11d
adcl $0x0, %r11d
movq 0x68(%rsp), %rcx
cmpl $0x2, %ecx
movl $0x1, %r12d
cmovgel %ecx, %r12d
movq 0x20(%rsp), %r13
shlq $0x4, %r13
shlq $0x4, %r11
xorl %esi, %esi
movdqa 0x12553d(%rip), %xmm15  # 0x596190
movdqa 0x125525(%rip), %xmm3   # 0x596180
movdqa 0x12550d(%rip), %xmm7   # 0x596170
movdqa 0xa0(%rsp), %xmm0
pcmpeqb 0x184e3c(%rip), %xmm0   # 0x5f5ab0
movdqa %xmm0, 0xa0(%rsp)
xorl %edx, %edx
movl 0xc(%rsp), %r8d
movdqa 0x90(%rsp), %xmm0
movdqa %xmm0, %xmm10
movdqa %xmm0, %xmm2
movdqa %xmm2, 0x50(%rsp)
movq 0x38(%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]
movq 0x28(%rsp), %rcx
pinsrb $0x0, (%rcx,%rdx), %xmm8
movq 0x70(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x78(%rsp), %rdi
movzbl (%rdi,%rdx), %edi
movslq (%rcx,%rdi,4), %rcx
imulq 0x20(%rsp), %rcx
shlq $0x4, %rcx
addq 0xc8(%rsp), %rcx
movdqa 0x90(%rsp), %xmm2
movdqa %xmm2, %xmm1
psubsb (%rax), %xmm1
xorl %r9d, %r9d
movdqa %xmm3, %xmm14
movdqa (%rbp,%r9), %xmm12
movdqa (%r15,%r9), %xmm13
movdqa %xmm12, %xmm11
psubsb %xmm5, %xmm11
psubsb %xmm6, %xmm13
movdqa %xmm11, %xmm0
pcmpgtb %xmm13, %xmm0
movdqa %xmm15, %xmm3
pblendvb %xmm0, %xmm14, %xmm15
movq 0x10(%rbx), %rdi
movq (%rdi), %rdi
addq %rsi, %rdi
paddsb (%rax,%r9), %xmm1
paddsb (%rcx,%r9), %xmm8
pmaxsb %xmm1, %xmm2
movdqa %xmm15, (%r9,%rdi)
movdqa %xmm3, %xmm15
pmaxsb %xmm11, %xmm13
pminsb %xmm13, %xmm4
movdqa %xmm13, (%r15,%r9)
movdqa %xmm13, %xmm1
pmaxsb %xmm8, %xmm1
movdqa %xmm1, (%r14,%r9)
movdqa %xmm8, (%rbp,%r9)
addq $0x10, %r9
movdqa %xmm12, %xmm8
cmpq %r9, %r11
jne 0x470cfa
pslldq $0x1, %xmm1             # xmm1 = zero,xmm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
leaq 0x1(%rdx), %rcx
movq 0x28(%rsp), %rdi
pinsrb $0x0, 0x1(%rdi,%rdx), %xmm1
movdqa (%rax), %xmm0
paddsb %xmm1, %xmm0
pmaxsb %xmm0, %xmm2
movl $0xe, %edi
movdqa %xmm2, %xmm0
pslldq $0x1, %xmm2             # xmm2 = zero,xmm2[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
paddsb %xmm9, %xmm2
pmaxsb %xmm0, %xmm2
decl %edi
jne 0x470db5
pslldq $0x1, %xmm2             # xmm2 = zero,xmm2[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
paddsb 0xd0(%rsp), %xmm2
pmaxsb %xmm2, %xmm1
xorl %r9d, %r9d
movdqa %xmm14, %xmm3
movdqa 0x1253c0(%rip), %xmm12  # 0x5961b0
movdqa 0x1253a7(%rip), %xmm13  # 0x5961a0
movdqa 0x12534e(%rip), %xmm14  # 0x596150
movq 0x10(%rbx), %rdi
movq (%rdi), %rdi
movdqa (%r14,%r9), %xmm11
psubsb %xmm5, %xmm1
psubsb %xmm6, %xmm2
movdqa %xmm1, %xmm8
pmaxsb %xmm2, %xmm8
pcmpgtb %xmm2, %xmm1
movdqa %xmm12, %xmm2
movdqa %xmm1, %xmm0
pblendvb %xmm0, %xmm13, %xmm2
movdqa %xmm11, %xmm1
pmaxsb %xmm8, %xmm1
movdqa (%rbp,%r9), %xmm0
pcmpeqb %xmm1, %xmm0
pcmpgtb %xmm8, %xmm11
paddb %xmm14, %xmm11
pblendvb %xmm0, %xmm7, %xmm11
addq %rsi, %rdi
por (%r9,%rdi), %xmm2
por %xmm11, %xmm2
movdqa %xmm2, (%r9,%rdi)
movdqa %xmm1, (%rbp,%r9)
pminsb %xmm8, %xmm4
pminsb %xmm1, %xmm4
pmaxsb %xmm1, %xmm10
addq $0x10, %r9
movdqa %xmm8, %xmm2
cmpq %r9, %r11
jne 0x470e02
movdqa (%r10), %xmm0
movdqa %xmm0, %xmm1
movdqa 0x50(%rsp), %xmm2
pcmpgtb %xmm2, %xmm1
pand 0xa0(%rsp), %xmm1
pmovmskb %xmm1, %edi
testl %edi, %edi
cmovnel %edx, %r8d
pmaxsb %xmm0, %xmm2
addq %r13, %rsi
movq %rcx, %rdx
cmpq %r12, %rcx
jne 0x470c96
cmpl $0x0, 0x150(%rsp)
movl 0x4c(%rsp), %r10d
movq 0xc0(%rsp), %r11
movl 0x14(%rsp), %r12d
movq 0x28(%rsp), %r13
je 0x470f1a
cmpl $0xe, 0x10(%rsp)
jg 0x470f13
movl 0x34(%rsp), %edx
cmpl $0x2, %edx
movl $0x1, %ecx
cmovgel %edx, %ecx
pslldq $0x1, %xmm2             # xmm2 = zero,xmm2[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
decl %ecx
jne 0x470f0a
pextrb $0xf, %xmm2, %r12d
cmpl $0x0, 0x140(%rsp)
je 0x470f8f
testl $0x7ffffff0, 0xb0(%rsp) # imm = 0x7FFFFFF0
je 0x470f8f
movq 0x18(%rsp), %rdx
andl $0x7ffffff, %edx        # imm = 0x7FFFFFF
shll $0x4, %edx
xorl %esi, %esi
movl %r10d, %ecx
movl %esi, %r9d
shrl $0x4, %r9d
movl %esi, %edi
andl $0xf, %edi
imull 0x18(%rsp), %edi
addl %r9d, %edi
cmpl %r11d, %edi
jge 0x470f86
movb (%rbp,%rsi), %r9b
cmpb %r12b, %r9b
jle 0x470f73
movl %r9d, %r12d
movl 0xc(%rsp), %r8d
movl %edi, %ecx
jmp 0x470f86
cmpl %ecx, %edi
cmovgel %ecx, %edi
cmpl 0xc(%rsp), %r8d
cmovnel %ecx, %edi
cmpb %r12b, %r9b
cmovel %edi, %ecx
incq %rsi
cmpl %esi, %edx
jne 0x470f44
jmp 0x470f92
movl %r10d, %ecx
movl 0x140(%rsp), %edx
orl %edx, 0x48(%rsp)
jne 0x470fdc
movq 0x40(%rsp), %rcx
shlq $0x4, %rcx
movdqa (%rbp,%rcx), %xmm0
cmpl $0xe, 0x10(%rsp)
jg 0x470fcd
movl 0x34(%rsp), %edx
cmpl $0x2, %edx
movl $0x1, %ecx
cmovgel %edx, %ecx
pslldq $0x1, %xmm0             # xmm0 = zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
decl %ecx
jne 0x470fc4
pextrb $0xf, %xmm0, %r12d
movl 0xc(%rsp), %r8d
movl %r10d, %ecx
movdqa 0x90(%rsp), %xmm0
pcmpgtb %xmm4, %xmm0
pcmpgtb 0x80(%rsp), %xmm10
por %xmm0, %xmm10
pmovmskb %xmm10, %edx
testl %edx, %edx
je 0x47100d
orb $0x40, 0xc(%rbx)
xorl %r12d, %r12d
xorl %r8d, %r8d
xorl %ecx, %ecx
movsbl %r12b, %edx
movl %edx, (%rbx)
movl %ecx, 0x4(%rbx)
movl %r8d, 0x8(%rbx)
movq %rax, %rdi
callq 0x2094b5
movq %rbp, %rdi
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
movq %r13, %rdi
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
jmp 0x47107c
callq 0x1db21d
jmp 0x47107a
callq 0x1db1f7
jmp 0x47107a
callq 0x1db1d1
jmp 0x47107a
callq 0x1db1ab
jmp 0x47107a
callq 0x1db185
jmp 0x47107a
callq 0x1db15f
jmp 0x47107a
callq 0x1db139
jmp 0x47107a
callq 0x1db113
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq