// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_scan_sse2_128_8.c
// Function: parasail_nw_rowcol_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)
{
    /* 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 vNegInfFront;
    __m128i vSegLenXgap;
    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;
    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;
    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));

    /* 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_NW | PARASAIL_FLAG_SCAN
        | PARASAIL_FLAG_BITS_8 | PARASAIL_FLAG_LANES_16;
#ifdef PARASAIL_TABLE
    result->flag |= PARASAIL_FLAG_TABLE;
#endif
#ifdef PARASAIL_ROWCOL
    result->flag |= PARASAIL_FLAG_ROWCOL;
#endif

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

    /* outer loop over database sequence */
    for (j=0; j<s2Len; ++j) {
        __m128i vE;
        __m128i vHt;
        __m128i vF;
        __m128i vH;
        __m128i vHp;
        __m128i *pvW;
        __m128i vW;

        /* 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);
            vE = _mm_max_epi8_rpl(
                    _mm_subs_epi8(vE, vGapE),
                    _mm_subs_epi8(vH, vGapO));
            vHp = _mm_adds_epi8(vHp, vW);
            vF = _mm_max_epi8_rpl(vF, _mm_adds_epi8(vHt, pvGapper[i]));
            vHt = _mm_max_epi8_rpl(vE, vHp);
            _mm_store_si128(pvE+i, vE);
            _mm_store_si128(pvHt+i, vHt);
            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);
        vF = _mm_max_epi8_rpl(vF, _mm_adds_epi8(vHt, pvGapper[0]));
        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(vHt, vF);
        for (i=0; i<segLen; ++i) {
            vHt = _mm_load_si128(pvHt+i);
            vF = _mm_max_epi8_rpl(
                    _mm_subs_epi8(vF, vGapE),
                    _mm_subs_epi8(vH, vGapO));
            vH = _mm_max_epi8_rpl(vHt, vF);
            _mm_store_si128(pvH+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
        } 


#ifdef PARASAIL_ROWCOL
        /* extract last value from the column */
        {
            vH = _mm_load_si128(pvH + offset);
            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(pvH+i);
        arr_store_col(result->rowcols->score_col, vH, i, segLen);
    }
#endif

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

    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 $0xb8, %rsp
movq %rsi, 0x50(%rsp)
testq %rdi, %rdi
je 0x33eccb
movq 0x18(%rdi), %rax
movq %rax, 0x80(%rsp)
testq %rax, %rax
je 0x33ecd2
movq 0x10(%rdi), %rax
movq %rax, 0x48(%rsp)
testq %rax, %rax
je 0x33ecd9
movl 0x8(%rdi), %edi
testl %edi, %edi
jle 0x33ece0
cmpq $0x0, 0x50(%rsp)
je 0x33ece7
movl %edx, %ebp
testl %edx, %edx
jle 0x33ecee
testl %ecx, %ecx
js 0x33ecf5
testl %r8d, %r8d
js 0x33ecfc
movl %r8d, 0x28(%rsp)
leal -0x1(%rdi), %r14d
addq $0xf, %rdi
movq %rdi, %r12
shrq $0x4, %r12
movl %r14d, %eax
cltd
idivl %r12d
movl %eax, 0x1c(%rsp)
movl %edx, %r13d
movl %ecx, %ebx
negl %ebx
movq 0x48(%rsp), %rdx
movl 0x20(%rdx), %eax
movl %eax, %esi
negb %sil
cmpl %ebx, %eax
movzbl %sil, %eax
movl %ecx, 0x78(%rsp)
cmovgl %ecx, %eax
movl %eax, 0x68(%rsp)
movb $0x7e, %al
subb 0x1c(%rdx), %al
movb %al, 0x70(%rsp)
andl $0x7ffffff0, %edi       # imm = 0x7FFFFFF0
movl %ebp, %esi
callq 0x209630
testq %rax, %rax
je 0x33ed01
movq %rax, %r15
movl %r13d, 0x58(%rsp)
movl %r14d, 0x8c(%rsp)
orl $0x10140401, 0xc(%rax)  # imm = 0x10140401
movl $0x10, %edi
movq %r12, %rsi
callq 0x2ea474
movq %rax, %r14
leal 0x1(%rbp), %esi
movl $0x10, %edi
callq 0x2094c8
movq %rax, 0x60(%rsp)
movl $0x10, %edi
movq %r12, %rsi
callq 0x2ea474
movq %rbp, 0x30(%rsp)
movq %r12, %rbp
movq %rax, %r12
movl $0x10, %edi
movq %rbp, %rsi
callq 0x2ea474
movq %rax, %r13
movl $0x10, %edi
movq %rbp, 0x20(%rsp)
movq %rbp, %rsi
callq 0x2ea474
movq 0x60(%rsp), %rdx
testq %r14, %r14
sete %cl
testq %rdx, %rdx
sete %dl
orb %cl, %dl
testq %r12, %r12
sete %cl
testq %r13, %r13
sete %sil
orb %cl, %sil
orb %dl, %sil
testq %rax, %rax
sete %cl
orb %sil, %cl
jne 0x33ed01
movq %r15, 0x40(%rsp)
movq 0x30(%rsp), %rcx
decl %ecx
movl %ecx, 0x38(%rsp)
movl $0xf, %ecx
subl 0x1c(%rsp), %ecx
movl %ecx, 0x3c(%rsp)
movl 0x78(%rsp), %esi
movd %esi, %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, %xmm2      # xmm2 = xmm0[0,0,0,0]
movl 0x28(%rsp), %edx
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, %xmm3      # xmm3 = xmm0[0,0,0,0]
movl 0x68(%rsp), %ecx
addb $-0x7f, %cl
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]
movzbl 0x70(%rsp), %ecx
movd %ecx, %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]
movq 0x20(%rsp), %rdi
movl %edi, %ecx
imull %edx, %ecx
negb %cl
movzbl %cl, %ecx
movd %ecx, %xmm5
punpcklbw %xmm5, %xmm5    # xmm5 = xmm5[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm5, %xmm5      # xmm5 = xmm5[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm5, %xmm5      # xmm5 = xmm5[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]
paddsb %xmm4, %xmm5
movl %esi, %ecx
movl %edx, %edx
movslq %ebx, %rsi
movl %edi, %edi
negq %rcx
movq %rdi, %rbp
imulq %rdx, %rdi
xorl %r8d, %r8d
movq $-0x80, %r9
movq %rsi, %r10
xorl %r11d, %r11d
cmpq $-0x7f, %r10
movq $-0x80, %r15
cmovgeq %r10, %r15
movb %r15b, 0xa0(%rsp,%r11)
leaq (%rcx,%r10), %r15
cmpq $-0x7f, %r15
cmovlq %r9, %r15
movb %r15b, 0x90(%rsp,%r11)
incq %r11
subq %rdi, %r10
cmpq $0x10, %r11
jne 0x33e706
movq %r8, %r10
shlq $0x4, %r10
movaps 0xa0(%rsp), %xmm6
movaps %xmm6, (%r13,%r10)
movdqa 0x90(%rsp), %xmm6
movdqa %xmm6, (%r14,%r10)
incq %r8
subq %rdx, %rsi
cmpq %rbp, %r8
jne 0x33e700
movq 0x60(%rsp), %rdi
movb $0x0, (%rdi)
movq 0x30(%rsp), %rdx
cmpl $0x2, %edx
movl $0x1, %ecx
cmovgel %edx, %ecx
xorl %edx, %edx
movl 0x28(%rsp), %r8d
cmpl $-0x7f, %ebx
movl $0xffffff80, %esi       # imm = 0xFFFFFF80
cmovgel %ebx, %esi
movb %sil, 0x1(%rdi,%rdx)
subl %r8d, %ebx
incq %rdx
cmpq %rdx, %rcx
jne 0x33e78b
movq 0x20(%rsp), %r8
leal -0x1(%r8), %ecx
pxor %xmm6, %xmm6
psubsb %xmm2, %xmm6
movq %rcx, %rsi
shlq $0x4, %rsi
movq %rax, %rdx
addq %rsi, %rdx
movl %r8d, %esi
movq 0x40(%rsp), %r15
movdqa %xmm6, (%rdx)
psubsb %xmm3, %xmm6
addq $-0x10, %rdx
decl %esi
jg 0x33e7cc
movl %ecx, %r8d
shlq $0x4, %r8
addq %r13, %r8
movl 0x58(%rsp), %r9d
movq %r9, 0x58(%rsp)
shlq $0x4, %r9
addq %r13, %r9
movl $0x1, %r10d
movq 0x20(%rsp), %r11
cmpl %r10d, %r11d
adcl $0x0, %r11d
movl 0x3c(%rsp), %ecx
cmpl $0x2, %ecx
movl $0x1, %edx
cmovgel %ecx, %edx
movl %edx, 0x28(%rsp)
movq 0x30(%rsp), %rcx
cmpl $0x2, %ecx
cmovgel %ecx, %r10d
shlq $0x4, %r11
xorl %ebx, %ebx
movdqa 0x2b7249(%rip), %xmm8   # 0x5f5a80
movdqa %xmm0, %xmm6
movdqa %xmm1, %xmm7
movq %rbx, %rcx
movq 0x48(%rsp), %rdx
movq 0x10(%rdx), %rdx
movq 0x50(%rsp), %rsi
movzbl (%rsi,%rbx), %esi
movslq (%rdx,%rsi,4), %rbx
imulq %rbp, %rbx
shlq $0x4, %rbx
addq 0x80(%rsp), %rbx
movdqa %xmm0, %xmm9
psubsb (%rax), %xmm9
movdqa (%r8), %xmm10
pslldq $0x1, %xmm10            # xmm10 = zero,xmm10[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movzbl (%rdi,%rcx), %edx
movd %edx, %xmm12
movdqa %xmm8, %xmm11
pandn %xmm12, %xmm11
por %xmm10, %xmm11
xorl %edx, %edx
movdqa %xmm0, %xmm10
movdqa (%r13,%rdx), %xmm12
movdqa (%r14,%rdx), %xmm13
psubsb %xmm3, %xmm13
movdqa %xmm12, %xmm14
psubsb %xmm2, %xmm14
movdqa %xmm13, %xmm15
pcmpgtb %xmm14, %xmm15
pand %xmm15, %xmm13
pandn %xmm14, %xmm15
por %xmm13, %xmm15
paddsb (%rbx,%rdx), %xmm11
paddsb (%rax,%rdx), %xmm9
movdqa %xmm10, %xmm13
pcmpgtb %xmm9, %xmm10
pand %xmm10, %xmm13
pandn %xmm9, %xmm10
por %xmm13, %xmm10
movdqa %xmm15, %xmm9
pcmpgtb %xmm11, %xmm9
movdqa %xmm15, (%r14,%rdx)
pand %xmm9, %xmm15
pandn %xmm11, %xmm9
por %xmm15, %xmm9
movdqa %xmm9, (%r12,%rdx)
addq $0x10, %rdx
movdqa %xmm12, %xmm11
cmpq %rdx, %r11
jne 0x33e89c
pslldq $0x1, %xmm9             # xmm9 = zero,xmm9[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
leaq 0x1(%rcx), %rbx
movzbl 0x1(%rdi,%rcx), %edx
movd %edx, %xmm12
movdqa %xmm8, %xmm11
pandn %xmm12, %xmm11
por %xmm9, %xmm11
movdqa (%rax), %xmm12
paddsb %xmm11, %xmm12
movdqa %xmm10, %xmm9
pcmpgtb %xmm12, %xmm9
pand %xmm9, %xmm10
pandn %xmm12, %xmm9
por %xmm10, %xmm9
movl $0xe, %edx
movdqa %xmm9, %xmm10
movdqa %xmm9, %xmm12
pslldq $0x1, %xmm9             # xmm9 = zero,xmm9[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
paddsb %xmm5, %xmm9
pcmpgtb %xmm9, %xmm10
pand %xmm10, %xmm12
pandn %xmm9, %xmm10
movdqa %xmm10, %xmm9
por %xmm12, %xmm9
decl %edx
jne 0x33e978
pslldq $0x1, %xmm9             # xmm9 = zero,xmm9[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
paddsb %xmm4, %xmm9
movdqa %xmm11, %xmm10
pcmpgtb %xmm9, %xmm10
pand %xmm10, %xmm11
pandn %xmm9, %xmm10
por %xmm11, %xmm10
xorl %edx, %edx
movdqa (%r12,%rdx), %xmm11
psubsb %xmm3, %xmm9
psubsb %xmm2, %xmm10
movdqa %xmm9, %xmm12
pcmpgtb %xmm10, %xmm12
pand %xmm12, %xmm9
pandn %xmm10, %xmm12
por %xmm12, %xmm9
movdqa %xmm11, %xmm10
pcmpgtb %xmm9, %xmm10
pand %xmm10, %xmm11
pandn %xmm9, %xmm10
por %xmm11, %xmm10
movdqa %xmm10, (%r13,%rdx)
movdqa %xmm7, %xmm11
pcmpgtb %xmm10, %xmm11
movdqa %xmm10, %xmm12
pand %xmm11, %xmm12
pandn %xmm7, %xmm11
movdqa %xmm11, %xmm7
por %xmm12, %xmm7
movdqa %xmm6, %xmm11
pcmpgtb %xmm10, %xmm6
pand %xmm6, %xmm11
pandn %xmm10, %xmm6
por %xmm11, %xmm6
addq $0x10, %rdx
cmpq %rdx, %r11
jne 0x33e9d0
movdqa (%r9), %xmm9
cmpl $0xe, 0x1c(%rsp)
jg 0x33ea7c
movl 0x28(%rsp), %edx
pslldq $0x1, %xmm9             # xmm9 = zero,xmm9[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
decl %edx
jne 0x33ea72
pextrw $0x7, %xmm9, %edx
shrl $0x8, %edx
movsbl %dl, %edx
movq 0x10(%r15), %rsi
movq (%rsi), %rsi
movl %edx, (%rsi,%rcx,4)
cmpq %r10, %rbx
jne 0x33e83f
movq 0x20(%rsp), %rdi
leal (,%rdi,4), %ecx
leal (,%rdi,8), %edx
movq %rdx, 0x48(%rsp)
movq %rcx, 0x50(%rsp)
leaq (%rcx,%rcx,2), %rcx
movq %rcx, 0x80(%rsp)
cmpl $0x1, %edi
adcl $0x0, %edi
imulq $0x3c, %rbp, %rcx
movq %rcx, 0x28(%rsp)
imulq $0x38, %rbp, %rcx
movq %rcx, 0x20(%rsp)
imulq $0x34, %rbp, %rcx
movq %rcx, 0x30(%rsp)
movq %rbp, %r15
shlq $0x4, %r15
leaq (%r15,%r15,2), %rsi
movq %rsi, 0x78(%rsp)
imulq $0x2c, %rbp, %rsi
movq %rsi, 0x70(%rsp)
leal (,%rbp,8), %r9d
leaq (%r9,%r9,4), %rcx
movq %rcx, 0x68(%rsp)
leal (,%rbp,4), %r10d
leaq (%r10,%r10,8), %rsi
leaq (,%rbp,8), %rcx
addq %rbp, %rcx
leaq (%rcx,%rcx,2), %r8
addq %rbp, %r8
movq %rbp, %rcx
shlq $0x5, %rcx
leaq (%r9,%r9,2), %r9
leaq (%r10,%r10,4), %r10
shll $0x2, %edi
movq %rdi, %rbp
xorl %r11d, %r11d
movdqa (%r13,%r11,4), %xmm2
movq 0x40(%rsp), %rdx
movq 0x10(%rdx), %rbx
movq 0x8(%rbx), %rbx
movdqa %xmm2, (%rsp)
movsbl (%rsp), %edx
movl %edx, (%rbx,%r11)
addq %r11, %rbx
movsbl 0x1(%rsp), %edx
movq 0x50(%rsp), %rdi
movl %edx, (%rdi,%rbx)
movsbl 0x2(%rsp), %edx
movq 0x48(%rsp), %rdi
movl %edx, (%rdi,%rbx)
movsbl 0x3(%rsp), %edx
movq 0x80(%rsp), %rdi
movl %edx, (%rdi,%rbx)
movsbl 0x4(%rsp), %edx
movl %edx, (%r15,%rbx)
movsbl 0x5(%rsp), %edx
movl %edx, (%r10,%rbx)
movsbl 0x6(%rsp), %edx
movl %edx, (%r9,%rbx)
movsbl 0x7(%rsp), %edx
movl %edx, (%r8,%rbx)
movsbl 0x8(%rsp), %edx
movl %edx, (%rcx,%rbx)
movsbl 0x9(%rsp), %edx
movl %edx, (%rsi,%rbx)
movsbl 0xa(%rsp), %edx
movq 0x68(%rsp), %rdi
movl %edx, (%rdi,%rbx)
movsbl 0xb(%rsp), %edx
movq 0x70(%rsp), %rdi
movl %edx, (%rdi,%rbx)
movsbl 0xc(%rsp), %edx
movq 0x78(%rsp), %rdi
movl %edx, (%rdi,%rbx)
movsbl 0xd(%rsp), %edx
movq 0x30(%rsp), %rdi
movl %edx, (%rdi,%rbx)
movsbl 0xe(%rsp), %edx
movq 0x20(%rsp), %rdi
movl %edx, (%rdi,%rbx)
movsbl 0xf(%rsp), %edx
movq 0x28(%rsp), %rdi
movl %edx, (%rdi,%rbx)
addq $0x4, %r11
cmpq %r11, %rbp
jne 0x33eb45
movq 0x58(%rsp), %rcx
shlq $0x4, %rcx
movdqa (%r13,%rcx), %xmm2
cmpl $0xe, 0x1c(%rsp)
jg 0x33ec5c
movl 0x3c(%rsp), %edx
cmpl $0x2, %edx
movl $0x1, %ecx
cmovgel %edx, %ecx
movq 0x40(%rsp), %rbx
movl 0x38(%rsp), %esi
pslldq $0x1, %xmm2             # xmm2 = zero,xmm2[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
decl %ecx
jne 0x33ec51
jmp 0x33ec65
movq 0x40(%rsp), %rbx
movl 0x38(%rsp), %esi
pcmpgtb %xmm7, %xmm0
pcmpgtb %xmm1, %xmm6
por %xmm0, %xmm6
pmovmskb %xmm6, %ecx
testl %ecx, %ecx
je 0x33ec85
orb $0x40, 0xc(%rbx)
xorl %ecx, %ecx
xorl %esi, %esi
xorl %edx, %edx
jmp 0x33ec94
pextrw $0x7, %xmm2, %ecx
shrl $0x8, %ecx
movl 0x8c(%rsp), %edx
movsbl %cl, %ecx
movl %ecx, (%rbx)
movl %edx, 0x4(%rbx)
movl %esi, 0x8(%rbx)
movq %rax, %rdi
callq 0x2094b5
movq %r13, %rdi
callq 0x2094b5
movq %r12, %rdi
callq 0x2094b5
movq 0x60(%rsp), %rdi
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
jmp 0x33ed03
callq 0x1b4d4b
jmp 0x33ed01
callq 0x1b4d25
jmp 0x33ed01
callq 0x1b4cff
jmp 0x33ed01
callq 0x1b4cd9
jmp 0x33ed01
callq 0x1b4cb3
jmp 0x33ed01
callq 0x1b4c8d
jmp 0x33ed01
callq 0x1b4c67
jmp 0x33ed01
callq 0x1b4c41
xorl %ebx, %ebx
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq