// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_scan_sse41_128_64.c
// Function: parasail_sw_rowcol_scan_profile_sse41_128_64
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 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;
#ifdef PARASAIL_ROWCOL
    int32_t offset = 0;
    int32_t position = 0;
#endif
    __m128i* restrict pvP = NULL;
    __m128i* restrict pvE = NULL;
    __m128i* restrict pvHt = NULL;
    __m128i* restrict pvH = NULL;
    __m128i* restrict pvHMax = NULL;
    __m128i* restrict pvGapper = NULL;
    __m128i vGapO;
    __m128i vGapE;
    int64_t NEG_LIMIT = 0;
    int64_t POS_LIMIT = 0;
    __m128i vZero;
    int64_t score = 0;
    __m128i vNegLimit;
    __m128i vPosLimit;
    __m128i vSaturationCheckMin;
    __m128i vSaturationCheckMax;
    __m128i vMaxH;
    __m128i vMaxHUnit;
    __m128i vNegInfFront;
    __m128i vSegLenXgap;
    parasail_result_t *result = NULL;

    /* validate inputs */
    PARASAIL_CHECK_NULL(profile);
    PARASAIL_CHECK_NULL(profile->profile64.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;
    end_query = 0;
    end_ref = 0;
    s1Len = profile->s1Len;
    matrix = profile->matrix;
    segWidth = 2; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
#ifdef PARASAIL_ROWCOL
    offset = (s1Len - 1) % segLen;
    position = (segWidth - 1) - (s1Len - 1) / segLen;
#endif
    pvP = (__m128i*)profile->profile64.score;
    vGapO = _mm_set1_epi64x_rpl(open);
    vGapE = _mm_set1_epi64x_rpl(gap);
    NEG_LIMIT = (-open < matrix->min ? INT64_MIN + open : INT64_MIN - matrix->min) + 1;
    POS_LIMIT = INT64_MAX - matrix->max - 1;
    vZero = _mm_setzero_si128();
    score = NEG_LIMIT;
    vNegLimit = _mm_set1_epi64x_rpl(NEG_LIMIT);
    vPosLimit = _mm_set1_epi64x_rpl(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    vMaxH = vNegLimit;
    vMaxHUnit = vNegLimit;
    vNegInfFront = vZero;
    vNegInfFront = _mm_insert_epi64_rpl(vNegInfFront, NEG_LIMIT, 0);
    vSegLenXgap = _mm_add_epi64(vNegInfFront,
            _mm_slli_si128(_mm_set1_epi64x_rpl(-segLen*gap), 8));

    /* 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_SW | PARASAIL_FLAG_SCAN
        | PARASAIL_FLAG_BITS_64 | PARASAIL_FLAG_LANES_2;
#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);
    pvHt= parasail_memalign___m128i(16, segLen);
    pvH = parasail_memalign___m128i(16, segLen);
    pvHMax = parasail_memalign___m128i(16, segLen);
    pvGapper = parasail_memalign___m128i(16, segLen);

    /* validate heap variables */
    if (!pvE) return NULL;
    if (!pvHt) return NULL;
    if (!pvH) return NULL;
    if (!pvHMax) return NULL;
    if (!pvGapper) return NULL;

    parasail_memset___m128i(pvH, vZero, segLen);
    parasail_memset___m128i(pvE, vNegLimit, segLen);
    {
        __m128i vGapper = _mm_sub_epi64(vZero,vGapO);
        for (i=segLen-1; i>=0; --i) {
            _mm_store_si128(pvGapper+i, vGapper);
            vGapper = _mm_sub_epi64(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, 8);
        pvW = pvP + matrix->mapper[(unsigned char)s2[j]]*segLen;
        vHt = vZero;
        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_epi64_rpl(
                    _mm_sub_epi64(vE, vGapE),
                    _mm_sub_epi64(vH, vGapO));
            vHp = _mm_add_epi64(vHp, vW);
            vF = _mm_max_epi64_rpl(vF, _mm_add_epi64(vHt, pvGapper[i]));
            vHt = _mm_max_epi64_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, 8);
        vF = _mm_max_epi64_rpl(vF, _mm_add_epi64(vHt, pvGapper[0]));
        for (i=0; i<segWidth-2; ++i) {
            __m128i vFt = _mm_slli_si128(vF, 8);
            vFt = _mm_add_epi64(vFt, vSegLenXgap);
            vF = _mm_max_epi64_rpl(vF, vFt);
        }

        /* calculate final H */
        vF = _mm_slli_si128(vF, 8);
        vF = _mm_add_epi64(vF, vNegInfFront);
        vH = _mm_max_epi64_rpl(vHt, vF);
        vH = _mm_max_epi64_rpl(vH, vZero);
        for (i=0; i<segLen; ++i) {
            vHt = _mm_load_si128(pvHt+i);
            vF = _mm_max_epi64_rpl(
                    _mm_sub_epi64(vF, vGapE),
                    _mm_sub_epi64(vH, vGapO));
            vH = _mm_max_epi64_rpl(vHt, vF);
            vH = _mm_max_epi64_rpl(vH, vZero);
            _mm_store_si128(pvH+i, vH);
            vSaturationCheckMin = _mm_min_epi64_rpl(vSaturationCheckMin, vH);
            vSaturationCheckMax = _mm_max_epi64_rpl(vSaturationCheckMax, vH);
#ifdef PARASAIL_TABLE
            arr_store_si128(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif
            vMaxH = _mm_max_epi64_rpl(vH, vMaxH);
        } 

        {
            __m128i vCompare = _mm_cmpgt_epi64_rpl(vMaxH, vMaxHUnit);
            if (_mm_movemask_epi8(vCompare)) {
                score = _mm_hmax_epi64_rpl(vMaxH);
                vMaxHUnit = _mm_set1_epi64x_rpl(score);
                end_ref = j;
                (void)memcpy(pvHMax, pvH, sizeof(__m128i)*segLen);
            }
        }

#ifdef PARASAIL_ROWCOL
        /* extract last value from the column */
        {
            int32_t k = 0;
            __m128i vH = _mm_load_si128(pvH + offset);
            for (k=0; k<position; ++k) {
                vH = _mm_slli_si128(vH, 8);
            }
            result->rowcols->score_row[j] = (int64_t) _mm_extract_epi64_rpl (vH, 1);
        }
#endif
    }

    /* Trace the alignment ending position on read. */
    {
        int64_t *t = (int64_t*)pvHMax;
        int32_t column_len = segLen * segWidth;
        end_query = s1Len;
        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;
                }
            }
        }
    }

#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

    if (_mm_movemask_epi8(_mm_or_si128(
            _mm_cmplt_epi64_rpl(vSaturationCheckMin, vNegLimit),
            _mm_cmpgt_epi64_rpl(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(pvHMax);
    parasail_free(pvH);
    parasail_free(pvHt);
    parasail_free(pvE);

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %rsi, 0x88(%rsp)
testq %rdi, %rdi
je 0x4257d9
movq 0x60(%rdi), %rax
movq %rax, 0x108(%rsp)
testq %rax, %rax
je 0x4257e0
movq 0x10(%rdi), %rax
movq %rax, 0x80(%rsp)
testq %rax, %rax
je 0x4257e7
movl 0x8(%rdi), %r12d
testl %r12d, %r12d
jle 0x4257ee
cmpq $0x0, 0x88(%rsp)
je 0x4257f5
movl %edx, %ebp
testl %edx, %edx
jle 0x4257fc
testl %ecx, %ecx
js 0x425803
testl %r8d, %r8d
js 0x42580a
movl %r8d, 0x8(%rsp)
leaq 0x1(%r12), %r13
movq %r13, %rbx
shrq %rbx
leal -0x1(%r12), %eax
cltd
idivl %ebx
movl %eax, 0x3c(%rsp)
movl %edx, 0x10(%rsp)
movl %ecx, %edx
negl %ecx
movq 0x80(%rsp), %rdi
movslq 0x20(%rdi), %rax
movq %rdx, 0x40(%rsp)
btsq $0x3f, %rdx
movabsq $-0x8000000000000000, %r14 # imm = 0x8000000000000000
subq %rax, %r14
cmpl %ecx, %eax
cmovgq %rdx, %r14
movslq 0x1c(%rdi), %rax
movq %rax, 0xb0(%rsp)
andl $0x7ffffffe, %r13d      # imm = 0x7FFFFFFE
movl %r13d, %edi
movl %ebp, %esi
callq 0x209630
testq %rax, %rax
je 0x42580f
movq %rax, %r15
movl %ebp, 0xa0(%rsp)
movq %r13, 0xd8(%rsp)
movq %r14, 0x68(%rsp)
orl $0x2840404, 0xc(%rax)   # imm = 0x2840404
movl $0x10, %edi
movq %rbx, %rsi
callq 0x2ea474
movq %rax, %r14
movl $0x10, %edi
movq %rbx, %rsi
callq 0x2ea474
movq %rax, 0x30(%rsp)
movl $0x10, %edi
movq %rbx, %rsi
callq 0x2ea474
movq %rax, %rbp
movl $0x10, %edi
movq %rbx, %rsi
callq 0x2ea474
movq %rax, %r13
movl $0x10, %edi
movq %rbx, %rsi
callq 0x2ea474
movq 0x30(%rsp), %rcx
movq %r14, 0x20(%rsp)
testq %r14, %r14
sete %dl
testq %rcx, %rcx
sete %cl
orb %dl, %cl
testq %rbp, %rbp
sete %sil
movq %r13, 0x28(%rsp)
testq %r13, %r13
movq %rax, %r14
sete %dl
orb %sil, %dl
orb %cl, %dl
testq %rax, %rax
sete %al
orb %dl, %al
jne 0x42580f
movq %r12, 0xd0(%rsp)
movq 0x40(%rsp), %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa %xmm0, 0x120(%rsp)
movd 0x8(%rsp), %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa %xmm0, 0x110(%rsp)
movq 0x68(%rsp), %rax
leaq 0x1(%rax), %rcx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
subq 0xb0(%rsp), %rax
addq $-0x2, %rax
movq %rcx, 0x18(%rsp)
movq %rcx, %xmm0
movdqa %xmm0, 0x130(%rsp)
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa %xmm0, 0x90(%rsp)
movq %rax, 0xc8(%rsp)
movq %rax, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa %xmm0, 0x40(%rsp)
pxor %xmm0, %xmm0
movq %rbp, 0x8(%rsp)
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x2ea47d
movq 0x20(%rsp), %rdi
movdqa 0x90(%rsp), %xmm0
movq %rbx, %rsi
callq 0x2ea47d
pxor %xmm0, %xmm0
movdqa 0x110(%rsp), %xmm7
movdqa 0x120(%rsp), %xmm6
psubq %xmm6, %xmm0
leal -0x1(%rbx), %eax
movq %rax, %rcx
shlq $0x4, %rcx
movq %r14, 0x78(%rsp)
addq %r14, %rcx
movl %ebx, %edx
movdqa %xmm0, (%rcx)
psubq %xmm7, %xmm0
addq $-0x10, %rcx
decl %edx
jg 0x425241
movl %eax, %eax
shlq $0x4, %rax
movq 0x8(%rsp), %rsi
addq %rsi, %rax
movq %rax, 0x100(%rsp)
movq %rbx, %rax
shlq $0x4, %rax
movq %rax, 0xe0(%rsp)
movl 0x10(%rsp), %eax
shlq $0x4, %rax
addq %rsi, %rax
movq %rax, 0xf8(%rsp)
movl 0xa0(%rsp), %eax
movq %rax, 0xf0(%rsp)
movl %ebx, %ebp
movq %rbp, 0x58(%rsp)
shlq $0x4, %rbp
movq %rbx, 0x60(%rsp)
movslq %ebx, %rax
movq %rax, 0xe8(%rsp)
xorl %edi, %edi
xorl %eax, %eax
movdqa 0x90(%rsp), %xmm0
movdqa %xmm0, %xmm9
movdqa %xmm0, %xmm10
movdqa %xmm0, %xmm11
movdqa 0x40(%rsp), %xmm8
movq %r15, 0x70(%rsp)
movq 0x100(%rsp), %rcx
movdqa (%rcx), %xmm0
pslldq $0x8, %xmm0             # xmm0 = zero,zero,zero,zero,zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7]
movq 0x80(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x88(%rsp), %rdx
movq %rdi, 0x10(%rsp)
movzbl (%rdx,%rdi), %edx
movslq (%rcx,%rdx,4), %rcx
imulq 0xe8(%rsp), %rcx
shlq $0x4, %rcx
addq 0x108(%rsp), %rcx
pxor %xmm3, %xmm3
xorl %r14d, %r14d
movdqa 0x90(%rsp), %xmm2
movq 0x20(%rsp), %rbx
movq 0x78(%rsp), %r15
movdqa (%rsi,%r14), %xmm1
movdqa (%rbx,%r14), %xmm4
psubq %xmm7, %xmm4
movdqa %xmm1, %xmm5
psubq %xmm6, %xmm5
movq %xmm4, %rdi
movq %xmm5, %rdx
cmpq %rdx, %rdi
cmovgq %rdi, %rdx
pextrq $0x1, %xmm4, %rdi
pextrq $0x1, %xmm5, %r8
cmpq %r8, %rdi
cmovgq %rdi, %r8
paddq (%rcx,%r14), %xmm0
paddq (%r15,%r14), %xmm3
movq %xmm2, %r9
movq %xmm3, %rdi
cmpq %rdi, %r9
cmovgq %r9, %rdi
pextrq $0x1, %xmm2, %r9
pextrq $0x1, %xmm3, %r10
cmpq %r10, %r9
cmovgq %r9, %r10
movq %xmm0, %r9
pextrq $0x1, %xmm0, %r11
movdqa %xmm1, %xmm0
movq %r10, %xmm1
movq 0x8(%rsp), %rsi
movq %r8, %xmm2
movq %rdx, %xmm4
punpcklqdq %xmm2, %xmm4    # xmm4 = xmm4[0],xmm2[0]
cmpq %r9, %rdx
cmovleq %r9, %rdx
movq 0x30(%rsp), %r9
movq %rdi, %xmm2
cmpq %r11, %r8
cmovleq %r11, %r8
punpcklqdq %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0]
movq %r8, %xmm1
movq %rdx, %xmm3
punpcklqdq %xmm1, %xmm3    # xmm3 = xmm3[0],xmm1[0]
movdqa %xmm4, (%rbx,%r14)
movdqa %xmm3, (%r9,%r14)
addq $0x10, %r14
cmpq %r14, %rbp
jne 0x42533c
movq (%r15), %rcx
cmpq %rcx, %rdi
cmovgq %rdi, %rcx
movq %rcx, %xmm0
pslldq $0x8, %xmm0             # xmm0 = zero,zero,zero,zero,zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7]
paddq 0x130(%rsp), %xmm0
movq %xmm0, %rcx
testq %rcx, %rcx
movl $0x0, %r8d
cmovleq %r8, %rcx
pextrq $0x1, %xmm0, %rdi
cmpq %rdi, %rdx
cmovgq %rdx, %rdi
testq %rdi, %rdi
cmovleq %r8, %rdi
movq %rdi, %xmm2
movq %rcx, %xmm1
punpcklqdq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0]
xorl %ecx, %ecx
psubq %xmm7, %xmm0
psubq %xmm6, %xmm1
movq %xmm0, %rdx
movq %xmm1, %rdi
cmpq %rdi, %rdx
cmovgq %rdx, %rdi
pextrq $0x1, %xmm0, %rdx
pextrq $0x1, %xmm1, %r8
cmpq %r8, %rdx
cmovgq %rdx, %r8
movq (%r9,%rcx), %r10
movq 0x8(%r9,%rcx), %rdx
cmpq %rdi, %r10
jg 0x4254aa
movq %rdi, %r10
cmpq %r8, %rdx
jg 0x4254b2
movq %r8, %rdx
testq %r10, %r10
jg 0x4254ba
xorl %r10d, %r10d
testq %rdx, %rdx
jg 0x4254c1
xorl %edx, %edx
movq %r8, %xmm1
movq %rdi, %xmm0
punpcklqdq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0]
movq %rdx, %xmm2
movq %r10, %xmm1
punpcklqdq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0]
movdqa %xmm1, (%rsi,%rcx)
movq %xmm8, %r12
cmpq %r10, %r12
cmovgeq %r10, %r12
pextrq $0x1, %xmm8, %r14
cmpq %rdx, %r14
cmovgeq %rdx, %r14
movq %r14, %xmm2
movq %r12, %xmm8
punpcklqdq %xmm2, %xmm8    # xmm8 = xmm8[0],xmm2[0]
movq %xmm11, %r13
cmpq %r10, %r13
cmovleq %r10, %r13
pextrq $0x1, %xmm11, %rbx
cmpq %rdx, %rbx
cmovleq %rdx, %rbx
movq %rbx, %xmm2
movq %r13, %xmm11
punpcklqdq %xmm2, %xmm11   # xmm11 = xmm11[0],xmm2[0]
movq %xmm10, %rdi
cmpq %rdi, %r10
cmovgq %r10, %rdi
pextrq $0x1, %xmm10, %r15
cmpq %r15, %rdx
cmovgq %rdx, %r15
movq %r15, %xmm2
movq %rdi, %xmm10
punpcklqdq %xmm2, %xmm10   # xmm10 = xmm10[0],xmm2[0]
addq $0x10, %rcx
cmpq %rcx, %rbp
jne 0x42546b
movq %xmm9, %rcx
xorl %edx, %edx
cmpq %rcx, %rdi
setg %dl
negq %rdx
pextrq $0x1, %xmm9, %rcx
xorl %r8d, %r8d
cmpq %rcx, %r15
setg %r8b
negq %r8
movq %r8, %xmm0
movq %rdx, %xmm1
punpcklqdq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0]
pmovmskb %xmm1, %ecx
testl %ecx, %ecx
je 0x425635
cmpq %r15, %rdi
cmovgq %rdi, %r15
movq %r15, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa %xmm0, 0x140(%rsp)
movq 0x28(%rsp), %rdi
movq 0xe0(%rsp), %rdx
movdqa %xmm8, 0x40(%rsp)
movdqa %xmm10, 0xb0(%rsp)
movdqa %xmm11, 0xa0(%rsp)
callq 0x19e0c0
movdqa 0xa0(%rsp), %xmm11
movdqa 0xb0(%rsp), %xmm10
movdqa 0x140(%rsp), %xmm9
movdqa 0x40(%rsp), %xmm8
movdqa 0x110(%rsp), %xmm7
movdqa 0x120(%rsp), %xmm6
movq 0x8(%rsp), %rsi
movq %r15, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq 0xf8(%rsp), %rcx
movdqa (%rcx), %xmm0
movl 0x3c(%rsp), %ecx
testl %ecx, %ecx
jle 0x425655
movq 0x70(%rsp), %r15
movq 0x10(%rsp), %rdi
jmp 0x425668
movq 0x70(%rsp), %r15
movq 0x10(%rsp), %rdi
pslldq $0x8, %xmm0             # xmm0 = zero,zero,zero,zero,zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7]
testl %ecx, %ecx
js 0x42565f
movq 0x10(%r15), %rcx
movq (%rcx), %rcx
pextrd $0x2, %xmm0, (%rcx,%rdi,4)
incq %rdi
cmpq 0xf0(%rsp), %rdi
jne 0x4252db
cmpl $0x0, 0xd8(%rsp)
movq 0xd0(%rsp), %r8
je 0x4256e5
movq 0x60(%rsp), %r10
movl %r10d, %ecx
andl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
addl %ecx, %ecx
xorl %edx, %edx
movq 0x18(%rsp), %r11
movq 0x58(%rsp), %rbp
movq 0x28(%rsp), %rdi
cmpq %r11, (%rdi,%rdx,8)
jne 0x4256dc
movl %edx, %r9d
shrl %r9d
testb $0x1, %dl
movl $0x0, %edi
cmovnel %r10d, %edi
addl %r9d, %edi
cmpl %r8d, %edi
cmovll %edi, %r8d
incq %rdx
cmpl %edx, %ecx
jne 0x4256b5
jmp 0x4256f4
movq 0x60(%rsp), %r10
movq 0x18(%rsp), %r11
movq 0x58(%rsp), %rbp
cmpl $0x1, %r10d
adcl $0x0, %r10d
shlq $0x2, %rbp
shlq $0x2, %r10
xorl %ecx, %ecx
movdqa (%rsi,%rcx,4), %xmm0
movq 0x10(%r15), %rdx
movq 0x8(%rdx), %rdx
movd %xmm0, (%rdx,%rcx)
addq %rcx, %rdx
pextrd $0x2, %xmm0, (%rbp,%rdx)
addq $0x4, %rcx
cmpq %rcx, %r10
jne 0x425706
xorl %ecx, %ecx
movq 0x68(%rsp), %rsi
cmpq %rsi, %r12
setle %cl
negq %rcx
xorl %edx, %edx
cmpq %rsi, %r14
setle %dl
negq %rdx
movq %rdx, %xmm0
movq %rcx, %xmm1
punpcklqdq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0]
xorl %ecx, %ecx
movq 0xc8(%rsp), %rsi
cmpq %rsi, %r13
setg %cl
negq %rcx
xorl %edx, %edx
cmpq %rsi, %rbx
setg %dl
negq %rdx
movq %rdx, %xmm0
movq %rcx, %xmm2
punpcklqdq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0]
por %xmm1, %xmm2
pmovmskb %xmm2, %ecx
testl %ecx, %ecx
je 0x42579a
orb $0x40, 0xc(%r15)
xorl %r11d, %r11d
xorl %eax, %eax
xorl %r8d, %r8d
movl %r11d, (%r15)
movl %r8d, 0x4(%r15)
movl %eax, 0x8(%r15)
movq 0x78(%rsp), %rdi
callq 0x2094b5
movq 0x28(%rsp), %rdi
callq 0x2094b5
movq 0x8(%rsp), %rdi
callq 0x2094b5
movq 0x30(%rsp), %rdi
callq 0x2094b5
movq 0x20(%rsp), %rdi
callq 0x2094b5
jmp 0x425812
callq 0x1d1821
jmp 0x42580f
callq 0x1d17fb
jmp 0x42580f
callq 0x1d17d5
jmp 0x42580f
callq 0x1d17af
jmp 0x42580f
callq 0x1d1789
jmp 0x42580f
callq 0x1d1763
jmp 0x42580f
callq 0x1d173d
jmp 0x42580f
callq 0x1d1717
xorl %r15d, %r15d
movq %r15, %rax
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop