// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_trace_scan_sse2_128_16.c
// Function: parasail_nw_trace_scan_profile_sse2_128_16
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;
    int16_t* restrict boundary = NULL;
    __m128i* restrict pvHt = NULL;
    __m128i* restrict pvH = NULL;
    __m128i* restrict pvGapper = NULL;
    __m128i vGapO;
    __m128i vGapE;
    int16_t NEG_LIMIT = 0;
    int16_t POS_LIMIT = 0;
    __m128i vZero;
    int16_t score = 0;
    __m128i vNegLimit;
    __m128i vPosLimit;
    __m128i vSaturationCheckMin;
    __m128i vSaturationCheckMax;
    __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->profile16.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 = 8; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    offset = (s1Len - 1) % segLen;
    position = (segWidth - 1) - (s1Len - 1) / segLen;
    pvP = (__m128i*)profile->profile16.score;
    vGapO = _mm_set1_epi16(open);
    vGapE = _mm_set1_epi16(gap);
    NEG_LIMIT = (-open < matrix->min ? INT16_MIN + open : INT16_MIN - matrix->min) + 1;
    POS_LIMIT = INT16_MAX - matrix->max - 1;
    vZero = _mm_setzero_si128();
    score = NEG_LIMIT;
    vNegLimit = _mm_set1_epi16(NEG_LIMIT);
    vPosLimit = _mm_set1_epi16(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    vNegInfFront = vZero;
    vTIns  = _mm_set1_epi16(PARASAIL_INS);
    vTDel  = _mm_set1_epi16(PARASAIL_DEL);
    vTDiag = _mm_set1_epi16(PARASAIL_DIAG);
    vTDiagE = _mm_set1_epi16(PARASAIL_DIAG_E);
    vTInsE = _mm_set1_epi16(PARASAIL_INS_E);
    vTDiagF = _mm_set1_epi16(PARASAIL_DIAG_F);
    vTDelF = _mm_set1_epi16(PARASAIL_DEL_F);
    vNegInfFront = _mm_insert_epi16(vNegInfFront, NEG_LIMIT, 0);
    vSegLenXgap = _mm_adds_epi16(vNegInfFront,
            _mm_slli_si128(_mm_set1_epi16(-segLen*gap), 2));

    /* initialize result */
    result = parasail_result_new_trace(segLen, s2Len, 16, sizeof(__m128i));
    if (!result) return NULL;

    /* set known flags */
    result->flag |= PARASAIL_FLAG_NW | PARASAIL_FLAG_SCAN
        | PARASAIL_FLAG_TRACE
        | PARASAIL_FLAG_BITS_16 | PARASAIL_FLAG_LANES_8;

    /* initialize heap variables */
    pvE = parasail_memalign___m128i(16, segLen);
    boundary = parasail_memalign_int16_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_16_t h;
            __m128i_16_t e;
            for (segNum=0; segNum<segWidth; ++segNum) {
                int64_t tmp = -open-gap*(segNum*segLen+i);
                h.v[segNum] = tmp < INT16_MIN ? INT16_MIN : tmp;
                tmp = tmp - open;
                e.v[segNum] = tmp < INT16_MIN ? INT16_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 < INT16_MIN ? INT16_MIN : tmp;
        }
    }

    {
        __m128i vGapper = _mm_subs_epi16(vZero,vGapO);
        for (i=segLen-1; i>=0; --i) {
            _mm_store_si128(pvGapper+i, vGapper);
            vGapper = _mm_subs_epi16(vGapper, vGapE);
        }
    }

    /* 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, 2);
        vHp = _mm_insert_epi16(vHp, boundary[j], 0);
        pvW = pvP + matrix->mapper[(unsigned char)s2[j]]*segLen;
        vHt = _mm_subs_epi16(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_epi16(vH, vGapO);
            vE_ext = _mm_subs_epi16(vE, vGapE);
            case1 = _mm_cmpgt_epi16(vE_opn, vE_ext);
            vET = _mm_blendv_epi8_rpl(vTInsE, vTDiagE, case1);
            arr_store(result->trace->trace_table, vET, i, segLen, j);
            vE = _mm_max_epi16(vE_opn, vE_ext);
            vSaturationCheckMin = _mm_min_epi16(vSaturationCheckMin, vE);
            vGapper = _mm_adds_epi16(vHt, vGapper);
            vF = _mm_max_epi16(vF, vGapper);
            vHp = _mm_adds_epi16(vHp, vW);
            vHt = _mm_max_epi16(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, 2);
        vHt = _mm_insert_epi16(vHt, boundary[j+1], 0);
        vGapper = _mm_load_si128(pvGapper);
        vGapper = _mm_adds_epi16(vHt, vGapper);
        vF = _mm_max_epi16(vF, vGapper);
        for (i=0; i<segWidth-2; ++i) {
            __m128i vFt = _mm_slli_si128(vF, 2);
            vFt = _mm_adds_epi16(vFt, vSegLenXgap);
            vF = _mm_max_epi16(vF, vFt);
        }

        /* calculate final H */
        vF = _mm_slli_si128(vF, 2);
        vF = _mm_adds_epi16(vF, vNegInfFront);
        vH = _mm_max_epi16(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_epi16(vH, vGapO);
            vF_ext = _mm_subs_epi16(vF, vGapE);
            vF = _mm_max_epi16(vF_opn, vF_ext);
            case1 = _mm_cmpgt_epi16(vF_opn, vF_ext);
            vFT = _mm_blendv_epi8_rpl(vTDelF, vTDiagF, case1);
            vH = _mm_max_epi16(vHt, vF);
            case1 = _mm_cmpeq_epi16(vH, vHp);
            case2 = _mm_cmpeq_epi16(vH, vF);
            vT = _mm_blendv_epi8_rpl(
                    _mm_blendv_epi8_rpl(vTIns, vTDel, case2),
                    vTDiag, case1);
            vT = _mm_or_si128(vT, vET);
            vT = _mm_or_si128(vT, vFT);
            arr_store(result->trace->trace_table, vT, i, segLen, j);
            _mm_store_si128(pvH+i, vH);
            vSaturationCheckMin = _mm_min_epi16(vSaturationCheckMin, vH);
            vSaturationCheckMin = _mm_min_epi16(vSaturationCheckMin, vF);
            vSaturationCheckMax = _mm_max_epi16(vSaturationCheckMax, vH);
        }
    }

    /* 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, 2);
        }
        score = (int16_t) _mm_extract_epi16 (vH, 7);
    }

    if (_mm_movemask_epi8(_mm_or_si128(
            _mm_cmplt_epi16(vSaturationCheckMin, vNegLimit),
            _mm_cmpgt_epi16(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 $0xc8, %rsp
testq %rdi, %rdi
je 0x389b35
movq 0x30(%rdi), %rax
movq %rax, 0x88(%rsp)
testq %rax, %rax
je 0x389b3c
movq 0x10(%rdi), %rax
movq %rax, 0x48(%rsp)
testq %rax, %rax
je 0x389b43
movl 0x8(%rdi), %r12d
testl %r12d, %r12d
jle 0x389b4a
testq %rsi, %rsi
je 0x389b51
movl %edx, %r13d
testl %edx, %edx
jle 0x389b58
movl %ecx, %r15d
testl %ecx, %ecx
js 0x389b5f
testl %r8d, %r8d
js 0x389b66
movl %r8d, 0x1c(%rsp)
movq %rsi, 0x80(%rsp)
leal -0x1(%r12), %eax
addq $0x7, %r12
shrq $0x3, %r12
movl %eax, 0x14(%rsp)
cltd
idivl %r12d
movl %eax, %ebp
movl %edx, %r14d
movl %r15d, %edx
negl %edx
movq 0x48(%rsp), %rcx
movl 0x20(%rcx), %eax
movl %eax, %esi
negl %esi
movl %edx, 0x18(%rsp)
cmpl %edx, %eax
cmovgl %r15d, %esi
movl %esi, (%rsp)
movw $0x7ffe, %ax            # imm = 0x7FFE
subw 0x1c(%rcx), %ax
movl %eax, 0x50(%rsp)
movl $0x10, %edx
movl $0x10, %ecx
movl %r12d, %edi
movl %r13d, %esi
callq 0x2097d1
testq %rax, %rax
je 0x389b6b
movq %rax, %rbx
movl %r15d, 0x30(%rsp)
movl %r14d, 0x2c(%rsp)
movl %ebp, 0x10(%rsp)
orl $0x8280401, 0xc(%rax)   # imm = 0x8280401
movl $0x10, %edi
movq %r12, %rsi
callq 0x2ea474
movq %rax, %r15
leal 0x1(%r13), %esi
movl $0x10, %edi
movq %rsi, 0x78(%rsp)
callq 0x2094cd
movq %r13, 0x40(%rsp)
movq %rax, %r13
movl $0x10, %edi
movq %r12, %rsi
callq 0x2ea474
movq %rax, %rbp
movl $0x10, %edi
movq %r12, %rsi
callq 0x2ea474
movq %rax, %r14
movl $0x10, %edi
movq %r12, %rsi
callq 0x2ea474
testq %r15, %r15
sete %cl
movq %r13, 0x20(%rsp)
testq %r13, %r13
sete %dl
orb %cl, %dl
testq %rbp, %rbp
sete %cl
testq %r14, %r14
sete %sil
orb %cl, %sil
orb %dl, %sil
testq %rax, %rax
sete %cl
orb %sil, %cl
jne 0x389b6b
movq 0x40(%rsp), %rcx
decl %ecx
movl %ecx, 0xc(%rsp)
movl $0x7, %ecx
subl 0x10(%rsp), %ecx
movl %ecx, 0x28(%rsp)
movl 0x30(%rsp), %esi
movd %esi, %xmm0
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 0x1c(%rsp), %edx
movd %edx, %xmm0
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 (%rsp), %ecx
addl $0xffff8001, %ecx       # imm = 0xFFFF8001
movd %ecx, %xmm0
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)
movd 0x50(%rsp), %xmm1
pshuflw $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm1, %xmm7      # xmm7 = xmm1[0,0,0,0]
movzwl %cx, %ecx
movd %ecx, %xmm0
movl %r12d, %ecx
imull %edx, %ecx
negl %ecx
movd %ecx, %xmm1
pshuflw $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
pslldq $0x2, %xmm1             # xmm1 = zero,zero,xmm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
movdqa %xmm0, 0x50(%rsp)
paddsw %xmm0, %xmm1
movdqa %xmm1, 0x90(%rsp)
movl %esi, %edi
movl %edx, %edx
movslq 0x18(%rsp), %rsi
movl %r12d, %ecx
negq %rdi
movq %rcx, (%rsp)
movq %rdx, 0x30(%rsp)
imulq %rdx, %rcx
xorl %r10d, %r10d
movq $-0x7fff, %r11          # imm = 0x8001
movq $-0x8000, %rdx          # imm = 0x8000
movq %rsi, %r9
xorl %r8d, %r8d
cmpq %r11, %r9
movq $-0x8000, %r13          # imm = 0x8000
cmovgeq %r9, %r13
movw %r13w, 0xb0(%rsp,%r8,2)
leaq (%rdi,%r9), %r13
cmpq %r11, %r13
cmovlq %rdx, %r13
movw %r13w, 0xa0(%rsp,%r8,2)
incq %r8
subq %rcx, %r9
cmpq $0x8, %r8
jne 0x389735
movq %r10, %r8
shlq $0x4, %r8
movaps 0xb0(%rsp), %xmm1
movaps %xmm1, (%r14,%r8)
movdqa 0xa0(%rsp), %xmm1
movdqa %xmm1, (%r15,%r8)
incq %r10
subq 0x30(%rsp), %rsi
cmpq (%rsp), %r10
jne 0x38972f
movq 0x20(%rsp), %r13
movw $0x0, (%r13)
movl $0x1, %ecx
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edi
movq 0x78(%rsp), %r8
cmpl $0xffff8001, %edi       # imm = 0xFFFF8001
movl $0xffff8000, %edx       # imm = 0xFFFF8000
cmovgel %edi, %edx
movw %dx, (%r13,%rcx,2)
incq %rcx
subl %esi, %edi
cmpq %rcx, %r8
jne 0x3897bb
pxor %xmm1, %xmm1
psubsw %xmm2, %xmm1
leal -0x1(%r12), %ecx
movq %rcx, %rsi
shlq $0x4, %rsi
movq %rax, %rdx
addq %rsi, %rdx
movl %r12d, %esi
movdqa %xmm1, (%rdx)
psubsw %xmm3, %xmm1
addq $-0x10, %rdx
decl %esi
jg 0x3897f6
movl %ecx, %ecx
shlq $0x4, %rcx
movq %r14, %rdi
addq %rcx, %rdi
cmpl $0x1, %r12d
adcl $0x0, %r12d
movq 0x40(%rsp), %rcx
cmpl $0x2, %ecx
movl $0x1, %r8d
cmovgel %ecx, %r8d
movq (%rsp), %r9
shlq $0x4, %r9
shlq $0x4, %r12
xorl %r10d, %r10d
movdqa 0x26c48c(%rip), %xmm10  # 0x5f5cd0
movdqa 0x26dd94(%rip), %xmm4   # 0x5f75e0
movdqa 0x26dd9b(%rip), %xmm9   # 0x5f75f0
movdqa 0x26dda3(%rip), %xmm0   # 0x5f7600
xorl %r11d, %r11d
movdqa 0x60(%rsp), %xmm6
movdqa %xmm7, 0x30(%rsp)
movq 0x80(%rsp), %rsi
movdqa %xmm0, %xmm5
movdqa %xmm9, %xmm13
movdqa %xmm4, %xmm12
movdqa (%rdi), %xmm1
pslldq $0x2, %xmm1             # xmm1 = zero,zero,xmm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
pinsrw $0x0, (%r13,%r11,2), %xmm1
movq 0x48(%rsp), %rcx
movq 0x10(%rcx), %rcx
movzbl (%rsi,%r11), %edx
movslq (%rcx,%rdx,4), %r13
imulq (%rsp), %r13
shlq $0x4, %r13
addq 0x88(%rsp), %r13
movdqa 0x60(%rsp), %xmm15
movdqa %xmm15, %xmm14
psubsw (%rax), %xmm14
xorl %ecx, %ecx
movdqa %xmm10, %xmm11
movdqa 0x26dce9(%rip), %xmm10  # 0x5f75c0
movdqa (%r14,%rcx), %xmm9
movdqa (%r15,%rcx), %xmm0
movdqa %xmm9, %xmm8
psubsw %xmm2, %xmm8
psubsw %xmm3, %xmm0
movdqa %xmm8, %xmm4
pcmpgtw %xmm0, %xmm4
pand %xmm10, %xmm4
pxor %xmm11, %xmm4
movq 0x10(%rbx), %rdx
movq (%rdx), %rdx
addq %r10, %rdx
paddsw (%rax,%rcx), %xmm14
paddsw (%r13,%rcx), %xmm1
pmaxsw %xmm14, %xmm15
movdqa %xmm4, (%rcx,%rdx)
pmaxsw %xmm8, %xmm0
pminsw %xmm0, %xmm7
movdqa %xmm0, (%r15,%rcx)
movdqa %xmm0, %xmm14
pmaxsw %xmm1, %xmm14
movdqa %xmm14, (%rbp,%rcx)
movdqa %xmm1, (%r14,%rcx)
addq $0x10, %rcx
movdqa %xmm9, %xmm1
cmpq %rcx, %r12
jne 0x3898d7
pslldq $0x2, %xmm14            # xmm14 = zero,zero,xmm14[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
movq 0x20(%rsp), %rcx
pinsrw $0x0, 0x2(%rcx,%r11,2), %xmm14
incq %r11
movdqa (%rax), %xmm0
paddsw %xmm14, %xmm0
pmaxsw %xmm0, %xmm15
movl $0x6, %ecx
movdqa 0x90(%rsp), %xmm1
movdqa %xmm15, %xmm0
pslldq $0x2, %xmm15            # xmm15 = zero,zero,xmm15[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
paddsw %xmm1, %xmm15
pmaxsw %xmm0, %xmm15
decl %ecx
jne 0x38998f
pslldq $0x2, %xmm15            # xmm15 = zero,zero,xmm15[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
paddsw 0x50(%rsp), %xmm15
pmaxsw %xmm15, %xmm14
xorl %r13d, %r13d
movdqa %xmm11, %xmm10
movdqa 0x26dc05(%rip), %xmm11  # 0x5f75d0
movdqa %xmm12, %xmm4
movdqa %xmm13, %xmm9
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq %r10, %rcx
movdqa (%rbp,%r13), %xmm0
psubsw %xmm2, %xmm14
psubsw %xmm3, %xmm15
movdqa %xmm14, %xmm1
pmaxsw %xmm15, %xmm1
pcmpgtw %xmm15, %xmm14
pand %xmm11, %xmm14
pxor %xmm4, %xmm14
movdqa %xmm0, %xmm4
pmaxsw %xmm1, %xmm4
movdqa (%r14,%r13), %xmm8
pcmpeqw %xmm4, %xmm8
pcmpgtw %xmm1, %xmm0
paddw %xmm9, %xmm0
movdqa %xmm8, %xmm9
pandn %xmm0, %xmm9
pand %xmm5, %xmm8
por %xmm9, %xmm8
movdqa %xmm13, %xmm9
por (%r13,%rcx), %xmm14
por %xmm8, %xmm14
movdqa %xmm14, (%r13,%rcx)
movdqa %xmm4, (%r14,%r13)
pminsw %xmm1, %xmm7
pminsw %xmm4, %xmm7
pmaxsw %xmm4, %xmm6
addq $0x10, %r13
movdqa %xmm4, %xmm14
movdqa %xmm12, %xmm4
movdqa %xmm1, %xmm15
cmpq %r13, %r12
jne 0x3899d5
movdqa %xmm5, %xmm0
addq %r9, %r10
cmpq %r8, %r11
movq 0x20(%rsp), %r13
jne 0x389874
movl 0x2c(%rsp), %ecx
shlq $0x4, %rcx
movdqa (%r14,%rcx), %xmm1
cmpl $0x6, 0x10(%rsp)
jg 0x389acb
movl 0x28(%rsp), %edx
cmpl $0x2, %edx
movl $0x1, %ecx
cmovgel %edx, %ecx
movl 0x14(%rsp), %edx
movl 0xc(%rsp), %esi
pslldq $0x2, %xmm1             # xmm1 = zero,zero,xmm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
decl %ecx
jne 0x389ac0
jmp 0x389ad3
movl 0x14(%rsp), %edx
movl 0xc(%rsp), %esi
movdqa 0x60(%rsp), %xmm0
pcmpgtw %xmm7, %xmm0
pcmpgtw 0x30(%rsp), %xmm6
por %xmm0, %xmm6
pmovmskb %xmm6, %ecx
testl %ecx, %ecx
je 0x389afb
orb $0x40, 0xc(%rbx)
xorl %ecx, %ecx
xorl %esi, %esi
xorl %edx, %edx
jmp 0x389b00
pextrw $0x7, %xmm1, %ecx
movswl %cx, %ecx
movl %ecx, (%rbx)
movl %edx, 0x4(%rbx)
movl %esi, 0x8(%rbx)
movq %rax, %rdi
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
movq %rbp, %rdi
callq 0x2094b5
movq %r13, %rdi
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
jmp 0x389b6d
callq 0x1bcec9
jmp 0x389b6b
callq 0x1bcea3
jmp 0x389b6b
callq 0x1bce7d
jmp 0x389b6b
callq 0x1bce57
jmp 0x389b6b
callq 0x1bce31
jmp 0x389b6b
callq 0x1bce0b
jmp 0x389b6b
callq 0x1bcde5
jmp 0x389b6b
callq 0x1bcdbf
xorl %ebx, %ebx
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop