// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_scan_avx2_256_8.c
// Function: parasail_sw_rowcol_scan_profile_avx2_256_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 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
    __m256i* restrict pvP = NULL;
    __m256i* restrict pvE = NULL;
    __m256i* restrict pvHt = NULL;
    __m256i* restrict pvH = NULL;
    __m256i* restrict pvHMax = NULL;
    __m256i* restrict pvGapper = NULL;
    __m256i vGapO;
    __m256i vGapE;
    int8_t NEG_LIMIT = 0;
    int8_t POS_LIMIT = 0;
    __m256i vZero;
    int8_t score = 0;
    __m256i vNegLimit;
    __m256i vPosLimit;
    __m256i vSaturationCheckMin;
    __m256i vSaturationCheckMax;
    __m256i vMaxH;
    __m256i vMaxHUnit;
    __m256i vNegInfFront;
    __m256i 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;
    end_query = 0;
    end_ref = 0;
    s1Len = profile->s1Len;
    matrix = profile->matrix;
    segWidth = 32; /* 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 = (__m256i*)profile->profile8.score;
    vGapO = _mm256_set1_epi8(open);
    vGapE = _mm256_set1_epi8(gap);
    NEG_LIMIT = (-open < matrix->min ? INT8_MIN + open : INT8_MIN - matrix->min) + 1;
    POS_LIMIT = INT8_MAX - matrix->max - 1;
    vZero = _mm256_setzero_si256();
    score = NEG_LIMIT;
    vNegLimit = _mm256_set1_epi8(NEG_LIMIT);
    vPosLimit = _mm256_set1_epi8(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    vMaxH = vNegLimit;
    vMaxHUnit = vNegLimit;
    vNegInfFront = vZero;
    vNegInfFront = _mm256_insert_epi8_rpl(vNegInfFront, NEG_LIMIT, 0);
    vSegLenXgap = _mm256_adds_epi8(vNegInfFront,
            _mm256_slli_si256_rpl(_mm256_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_SW | PARASAIL_FLAG_SCAN
        | PARASAIL_FLAG_BITS_8 | PARASAIL_FLAG_LANES_32;
#ifdef PARASAIL_TABLE
    result->flag |= PARASAIL_FLAG_TABLE;
#endif
#ifdef PARASAIL_ROWCOL
    result->flag |= PARASAIL_FLAG_ROWCOL;
#endif

    /* initialize heap variables */
    pvE = parasail_memalign___m256i(32, segLen);
    pvHt= parasail_memalign___m256i(32, segLen);
    pvH = parasail_memalign___m256i(32, segLen);
    pvHMax = parasail_memalign___m256i(32, segLen);
    pvGapper = parasail_memalign___m256i(32, 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___m256i(pvH, vZero, segLen);
    parasail_memset___m256i(pvE, vNegLimit, segLen);
    {
        __m256i vGapper = _mm256_subs_epi8(vZero,vGapO);
        for (i=segLen-1; i>=0; --i) {
            _mm256_store_si256(pvGapper+i, vGapper);
            vGapper = _mm256_subs_epi8(vGapper, vGapE);
        }
    }

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

        /* calculate E */
        /* calculate Ht */
        /* calculate F and H first pass */
        vHp = _mm256_load_si256(pvH+(segLen-1));
        vHp = _mm256_slli_si256_rpl(vHp, 1);
        pvW = pvP + matrix->mapper[(unsigned char)s2[j]]*segLen;
        vHt = vZero;
        vF = vNegLimit;
        for (i=0; i<segLen; ++i) {
            vH = _mm256_load_si256(pvH+i);
            vE = _mm256_load_si256(pvE+i);
            vW = _mm256_load_si256(pvW+i);
            vE = _mm256_max_epi8(
                    _mm256_subs_epi8(vE, vGapE),
                    _mm256_subs_epi8(vH, vGapO));
            vHp = _mm256_adds_epi8(vHp, vW);
            vF = _mm256_max_epi8(vF, _mm256_adds_epi8(vHt, pvGapper[i]));
            vHt = _mm256_max_epi8(vE, vHp);
            _mm256_store_si256(pvE+i, vE);
            _mm256_store_si256(pvHt+i, vHt);
            vHp = vH;
        }

        /* pseudo prefix scan on F and H */
        vHt = _mm256_slli_si256_rpl(vHt, 1);
        vF = _mm256_max_epi8(vF, _mm256_adds_epi8(vHt, pvGapper[0]));
        for (i=0; i<segWidth-2; ++i) {
            __m256i vFt = _mm256_slli_si256_rpl(vF, 1);
            vFt = _mm256_adds_epi8(vFt, vSegLenXgap);
            vF = _mm256_max_epi8(vF, vFt);
        }

        /* calculate final H */
        vF = _mm256_slli_si256_rpl(vF, 1);
        vF = _mm256_adds_epi8(vF, vNegInfFront);
        vH = _mm256_max_epi8(vHt, vF);
        vH = _mm256_max_epi8(vH, vZero);
        for (i=0; i<segLen; ++i) {
            vHt = _mm256_load_si256(pvHt+i);
            vF = _mm256_max_epi8(
                    _mm256_subs_epi8(vF, vGapE),
                    _mm256_subs_epi8(vH, vGapO));
            vH = _mm256_max_epi8(vHt, vF);
            vH = _mm256_max_epi8(vH, vZero);
            _mm256_store_si256(pvH+i, vH);
            vSaturationCheckMin = _mm256_min_epi8(vSaturationCheckMin, vH);
            vSaturationCheckMax = _mm256_max_epi8(vSaturationCheckMax, vH);
#ifdef PARASAIL_TABLE
            arr_store_si256(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif
            vMaxH = _mm256_max_epi8(vH, vMaxH);
        } 

        {
            __m256i vCompare = _mm256_cmpgt_epi8(vMaxH, vMaxHUnit);
            if (_mm256_movemask_epi8(vCompare)) {
                score = _mm256_hmax_epi8_rpl(vMaxH);
                vMaxHUnit = _mm256_set1_epi8(score);
                end_ref = j;
                (void)memcpy(pvHMax, pvH, sizeof(__m256i)*segLen);
            }
        }

#ifdef PARASAIL_ROWCOL
        /* extract last value from the column */
        {
            int32_t k = 0;
            __m256i vH = _mm256_load_si256(pvH + offset);
            for (k=0; k<position; ++k) {
                vH = _mm256_slli_si256_rpl(vH, 1);
            }
            result->rowcols->score_row[j] = (int8_t) _mm256_extract_epi8_rpl (vH, 31);
        }
#endif
    }

    /* Trace the alignment ending position on read. */
    {
        int8_t *t = (int8_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) {
        __m256i vH = _mm256_load_si256(pvH+i);
        arr_store_col(result->rowcols->score_col, vH, i, segLen);
    }
#endif

    if (_mm256_movemask_epi8(_mm256_or_si256(
            _mm256_cmplt_epi8_rpl(vSaturationCheckMin, vNegLimit),
            _mm256_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(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 $0x208, %rsp            # imm = 0x208
movq %rsi, 0x40(%rsp)
testq %rdi, %rdi
je 0x527070
movq 0x18(%rdi), %rax
movq %rax, 0x80(%rsp)
testq %rax, %rax
je 0x527077
movq 0x10(%rdi), %rax
movq %rax, 0x38(%rsp)
testq %rax, %rax
je 0x52707e
movl 0x8(%rdi), %eax
testl %eax, %eax
jle 0x527085
cmpq $0x0, 0x40(%rsp)
je 0x52708c
movl %edx, %ebp
testl %edx, %edx
jle 0x527093
movl %ecx, %r13d
testl %ecx, %ecx
js 0x52709a
movl %r8d, %r12d
testl %r8d, %r8d
js 0x5270a1
leaq 0x1f(%rax), %r14
movq %r14, %rbx
shrq $0x5, %rbx
movq %rax, 0x50(%rsp)
decl %eax
cltd
idivl %ebx
movl %eax, 0x30(%rsp)
movl %edx, %r15d
movq 0x38(%rsp), %rsi
movl 0x20(%rsi), %eax
movl %eax, %ecx
negb %cl
movzbl %cl, %edx
movl %r13d, %ecx
negl %ecx
cmpl %ecx, %eax
cmovgl %r13d, %edx
movl %edx, 0xc(%rsp)
movb $0x7e, %al
subb 0x1c(%rsi), %al
movl %eax, 0x140(%rsp)
andl $0x7fffffe0, %r14d      # imm = 0x7FFFFFE0
movl %r14d, %edi
movl %ebp, %esi
callq 0x209630
testq %rax, %rax
je 0x5270a6
movl %r13d, 0xc0(%rsp)
movl %r12d, 0xe0(%rsp)
movl %r15d, 0x100(%rsp)
movl %ebp, 0x120(%rsp)
movq %r14, 0x58(%rsp)
movq %rax, 0x48(%rsp)
orl $0x20140404, 0xc(%rax)  # imm = 0x20140404
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4c5e3c
movq %rax, %r15
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4c5e3c
movq %rax, %r12
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4c5e3c
movq %rax, %r13
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4c5e3c
movq %rax, %r14
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4c5e3c
movq %rax, %rbp
testq %r15, %r15
sete %al
testq %r12, %r12
sete %cl
orb %al, %cl
testq %r13, %r13
sete %al
movq %r14, 0x88(%rsp)
testq %r14, %r14
sete %dl
orb %al, %dl
orb %cl, %dl
testq %rbp, %rbp
sete %al
orb %dl, %al
jne 0x5270a6
movl $0x1f, %eax
subl 0x30(%rsp), %eax
movl %eax, 0x10(%rsp)
vmovd 0xc0(%rsp), %xmm0
vpbroadcastb %xmm0, %ymm0
vmovdqu %ymm0, 0x1a0(%rsp)
movl 0xe0(%rsp), %ecx
vmovd %ecx, %xmm0
vpbroadcastb %xmm0, %ymm0
vmovdqu %ymm0, 0x180(%rsp)
movl 0xc(%rsp), %eax
addb $-0x7f, %al
vmovd %eax, %xmm0
vpbroadcastb %xmm0, %ymm0
vmovdqu %ymm0, 0xc0(%rsp)
vmovd 0x140(%rsp), %xmm0
vpbroadcastb %xmm0, %ymm0
vmovdqu %ymm0, 0x1e0(%rsp)
movl %eax, 0xc(%rsp)
movzbl %al, %eax
vmovd %eax, %xmm1
imull %ebx, %ecx
negb %cl
vmovd %ecx, %xmm0
vpbroadcastb %xmm0, %ymm0
vpand 0xd306f(%rip), %ymm0, %ymm0 # 0x5f98c0
vmovdqu %ymm1, 0x1c0(%rsp)
vpaddsb %ymm0, %ymm1, %ymm0
vmovdqu %ymm0, 0x160(%rsp)
vpxor %xmm0, %xmm0, %xmm0
movq %r13, %rdi
movq %rbx, %rsi
callq 0x4c5e45
movq %r15, %rdi
vmovdqu 0xc0(%rsp), %ymm0
movq %rbx, %rsi
callq 0x4c5e45
vmovdqu 0x180(%rsp), %ymm9
vmovdqu 0x1a0(%rsp), %ymm8
leal -0x1(%rbx), %eax
vpxor %xmm0, %xmm0, %xmm0
vpsubsb %ymm8, %ymm0, %ymm0
movq %rax, %rcx
shlq $0x5, %rcx
addq %rbp, %rcx
movl %ebx, %edx
vmovdqa %ymm0, (%rcx)
vpsubsb %ymm9, %ymm0, %ymm0
addq $-0x20, %rcx
decl %edx
jg 0x5268b4
movl %eax, %eax
shlq $0x5, %rax
addq %r13, %rax
movq %rax, 0x78(%rsp)
movq %rbx, %rax
shlq $0x5, %rax
movq %rax, 0x60(%rsp)
movl 0x100(%rsp), %eax
shlq $0x5, %rax
addq %r13, %rax
movq %rax, 0x70(%rsp)
movl $0x1, %edx
cmpl %edx, %ebx
movq %rbx, %rax
movl %eax, %r14d
adcl $0x0, %r14d
movl 0x10(%rsp), %ecx
cmpl $0x2, %ecx
cmovll %edx, %ecx
movl %ecx, 0x10(%rsp)
movl 0x120(%rsp), %ecx
cmpl $0x2, %ecx
cmovgel %ecx, %edx
movq %rdx, 0x68(%rsp)
shlq $0x5, %r14
xorl %ebx, %ebx
movq %rax, 0x28(%rsp)
movl %eax, %eax
movq %rax, 0x20(%rsp)
vpxor %xmm11, %xmm11, %xmm11
xorl %edx, %edx
vmovdqu 0xc0(%rsp), %ymm0
vmovdqa %ymm0, %ymm13
vmovdqa %ymm0, %ymm12
vmovdqa %ymm0, %ymm6
vmovdqu 0x1e0(%rsp), %ymm7
movq 0x48(%rsp), %r11
vmovdqu 0x160(%rsp), %ymm10
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x40(%rsp), %rcx
movzbl (%rcx,%rbx), %ecx
movslq (%rax,%rcx,4), %rax
imulq 0x20(%rsp), %rax
shlq $0x5, %rax
addq 0x80(%rsp), %rax
movq 0x78(%rsp), %rcx
vmovdqa (%rcx), %ymm0
vperm2i128 $0x28, %ymm0, %ymm0, %ymm1 # ymm1 = zero,zero,ymm0[0,1]
vpalignr $0xf, %ymm1, %ymm0, %ymm2 # ymm2 = ymm1[15],ymm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm1[31],ymm0[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
xorl %ecx, %ecx
vmovdqu 0xc0(%rsp), %ymm0
vpxor %xmm1, %xmm1, %xmm1
vpaddsb (%rax,%rcx), %ymm2, %ymm2
vmovdqa (%r13,%rcx), %ymm3
vmovdqa (%r15,%rcx), %ymm4
vpsubsb %ymm9, %ymm4, %ymm4
vpsubsb %ymm8, %ymm3, %ymm5
vpmaxsb %ymm5, %ymm4, %ymm4
vpaddsb (%rbp,%rcx), %ymm1, %ymm1
vpmaxsb %ymm1, %ymm0, %ymm0
vpmaxsb %ymm2, %ymm4, %ymm1
vmovdqa %ymm4, (%r15,%rcx)
vmovdqa %ymm1, (%r12,%rcx)
addq $0x20, %rcx
vmovdqa %ymm3, %ymm2
cmpq %rcx, %r14
jne 0x5269b4
vperm2i128 $0x8, %ymm1, %ymm1, %ymm2 # ymm2 = zero,zero,ymm1[0,1]
vpalignr $0xf, %ymm2, %ymm1, %ymm1 # ymm1 = ymm2[15],ymm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm2[31],ymm1[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpaddsb (%rbp), %ymm1, %ymm2
vpmaxsb %ymm2, %ymm0, %ymm0
movl $0x1e, %eax
vperm2i128 $0x28, %ymm0, %ymm0, %ymm2 # ymm2 = zero,zero,ymm0[0,1]
vpalignr $0xf, %ymm2, %ymm0, %ymm2 # ymm2 = ymm2[15],ymm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm2[31],ymm0[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpaddsb %ymm2, %ymm10, %ymm2
vpmaxsb %ymm2, %ymm0, %ymm0
decl %eax
jne 0x526a19
vperm2i128 $0x28, %ymm0, %ymm0, %ymm2 # ymm2 = zero,zero,ymm0[0,1]
vpalignr $0xf, %ymm2, %ymm0, %ymm0 # ymm0 = ymm2[15],ymm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm2[31],ymm0[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpaddsb 0x1c0(%rsp), %ymm0, %ymm0
vpmaxsb %ymm11, %ymm1, %ymm1
vpmaxsb %ymm0, %ymm1, %ymm1
xorl %eax, %eax
vpsubsb %ymm9, %ymm0, %ymm0
vpsubsb %ymm8, %ymm1, %ymm1
vpmaxsb %ymm1, %ymm0, %ymm0
vpmaxsb (%r12,%rax), %ymm0, %ymm1
vpmaxsb %ymm11, %ymm1, %ymm1
vmovdqa %ymm1, (%r13,%rax)
vpminsb %ymm1, %ymm7, %ymm7
vpmaxsb %ymm1, %ymm6, %ymm6
vpmaxsb %ymm12, %ymm1, %ymm12
addq $0x20, %rax
cmpq %rax, %r14
jne 0x526a53
vpcmpgtb %ymm13, %ymm12, %ymm0
vpmovmskb %ymm0, %eax
testl %eax, %eax
je 0x526b7b
vpermq $0x44, %ymm12, %ymm0    # ymm0 = ymm12[0,1,0,1]
vpmaxsb %ymm0, %ymm12, %ymm0
vpslldq $0x8, %ymm0, %ymm1      # ymm1 = zero,zero,zero,zero,zero,zero,zero,zero,ymm0[0,1,2,3,4,5,6,7],zero,zero,zero,zero,zero,zero,zero,zero,ymm0[16,17,18,19,20,21,22,23]
vpmaxsb %ymm1, %ymm0, %ymm0
vpslldq $0x4, %ymm0, %ymm1      # ymm1 = zero,zero,zero,zero,ymm0[0,1,2,3,4,5,6,7,8,9,10,11],zero,zero,zero,zero,ymm0[16,17,18,19,20,21,22,23,24,25,26,27]
vpmaxsb %ymm1, %ymm0, %ymm0
vpslldq $0x2, %ymm0, %ymm1      # ymm1 = zero,zero,ymm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13],zero,zero,ymm0[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
vpmaxsb %ymm1, %ymm0, %ymm0
vpslldq $0x1, %ymm0, %ymm1      # ymm1 = zero,ymm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],zero,ymm0[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpmaxsb %ymm1, %ymm0, %ymm0
vextracti128 $0x1, %ymm0, %xmm1
vpbroadcastb 0xd4214(%rip), %ymm2 # 0x5facf3
vpextrb $0xf, %xmm1, %eax
movl %eax, 0xc(%rsp)
vpshufb %ymm2, %ymm0, %ymm0
vpermq $0xaa, %ymm0, %ymm0     # ymm0 = ymm0[2,2,2,2]
vmovdqu %ymm0, 0xe0(%rsp)
movq 0x88(%rsp), %rdi
movq %r13, %rsi
movq 0x60(%rsp), %rdx
vmovdqu %ymm6, 0x140(%rsp)
vmovdqu %ymm7, 0x120(%rsp)
vmovdqu %ymm12, 0x100(%rsp)
vzeroupper
callq 0x19e0c0
vmovdqu 0xe0(%rsp), %ymm13
vmovdqu 0x100(%rsp), %ymm12
vpxor %xmm11, %xmm11, %xmm11
vmovdqu 0x160(%rsp), %ymm10
vmovdqu 0x180(%rsp), %ymm9
vmovdqu 0x1a0(%rsp), %ymm8
vmovdqu 0x120(%rsp), %ymm7
vmovdqu 0x140(%rsp), %ymm6
movq 0x48(%rsp), %r11
movl %ebx, %edx
movq 0x70(%rsp), %rax
vmovdqa (%rax), %ymm0
cmpl $0x1e, 0x30(%rsp)
jg 0x526b9f
movl 0x10(%rsp), %eax
vperm2i128 $0x28, %ymm0, %ymm0, %ymm1 # ymm1 = zero,zero,ymm0[0,1]
vpalignr $0xf, %ymm1, %ymm0, %ymm0 # ymm0 = ymm1[15],ymm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm1[31],ymm0[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
decl %eax
jne 0x526b8f
vextracti128 $0x1, %ymm0, %xmm0
vpextrb $0xf, %xmm0, %eax
movsbl %al, %eax
movq 0x10(%r11), %rcx
movq (%rcx), %rcx
movl %eax, (%rcx,%rbx,4)
incq %rbx
cmpq 0x68(%rsp), %rbx
jne 0x526968
cmpl $0x0, 0x58(%rsp)
movq 0x50(%rsp), %rdi
je 0x526c19
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %r10
movl %r10d, %eax
andl $0x3ffffff, %eax        # imm = 0x3FFFFFF
shll $0x5, %eax
xorl %ecx, %ecx
movl 0xc(%rsp), %r8d
movq 0x88(%rsp), %rdx
cmpb %r8b, (%rdx,%rcx)
jne 0x526c10
movl %ecx, %edx
shrl $0x5, %edx
movl %ecx, %esi
andl $0x1f, %esi
imull %r10d, %esi
addl %edx, %esi
cmpl %edi, %esi
cmovll %esi, %edi
incq %rcx
cmpl %ecx, %eax
jne 0x526bed
jmp 0x526c22
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %r10
movq %rdi, 0x50(%rsp)
leal (,%r10,4), %edx
leal (,%r10,8), %esi
movl %r10d, %r8d
shll $0x4, %r8d
movq 0x20(%rsp), %rcx
leaq (%rcx,%rcx,8), %rax
leaq (%rax,%rax,2), %rax
addq %rcx, %rax
movq %rax, 0x40(%rsp)
cmpl $0x1, %r10d
adcl $0x0, %r10d
imulq $0x7c, %rcx, %rax
movq %rax, 0x140(%rsp)
imulq $0x78, %rcx, %rax
movq %rax, 0x120(%rsp)
imulq $0x74, %rcx, %rax
movq %rax, 0x100(%rsp)
imulq $0x70, %rcx, %rax
movq %rax, 0xe0(%rsp)
imulq $0x6c, %rcx, %rax
movq %rax, 0x38(%rsp)
imulq $0x68, %rcx, %rax
movq %rax, 0x80(%rsp)
imulq $0x64, %rcx, %rax
movq %rax, 0x30(%rsp)
movq %rcx, %rax
shlq $0x5, %rax
imulq $0x5c, %rcx, %rdi
movq %rdi, 0x1c0(%rsp)
movq %rcx, %rdi
shlq $0x6, %rdi
imulq $0x58, %rcx, %r9
movq %r9, 0x78(%rsp)
imulq $0x54, %rcx, %r9
movq %r9, 0x70(%rsp)
imulq $0x4c, %rcx, %r9
movq %r9, 0x68(%rsp)
imulq $0x3c, %rcx, %r9
movq %r9, 0x1a0(%rsp)
imulq $0x38, %rcx, %r9
movq %r9, 0x180(%rsp)
imulq $0x34, %rcx, %r9
movq %r9, 0x160(%rsp)
imulq $0x2c, %rcx, %rcx
movq %rcx, 0x60(%rsp)
shll $0x2, %r10d
movq %r10, 0x28(%rsp)
leaq (%rdx,%rdx,2), %rcx
movq %rcx, 0x10(%rsp)
leaq (%rdx,%rdx,4), %rcx
movq %rcx, 0x58(%rsp)
leaq (%rsi,%rsi,2), %rcx
movq %rcx, 0xb8(%rsp)
movq %rax, 0x20(%rsp)
leaq (%rax,%rax,2), %rax
movq %rax, 0xb0(%rsp)
leaq (%r8,%r8,4), %rax
movq %rax, 0xa8(%rsp)
leaq (%rsi,%rsi,8), %rax
movq %rax, 0xa0(%rsp)
movq %rdi, %rbx
leaq (%rdi,%rdx), %rax
movq %rax, 0x98(%rsp)
movq %r8, %rdi
leaq (%r8,%r8,2), %rax
movq %rax, 0x90(%rsp)
movq %rsi, %r14
leaq (%rsi,%rsi,4), %rcx
movq %rdx, %r10
leaq (%rdx,%rdx,8), %r8
xorl %r9d, %r9d
movq 0x10(%r11), %rsi
movq 0x8(%rsi), %rsi
vmovdqa (%r13,%r9,8), %xmm1
vmovdqa 0x10(%r13,%r9,8), %xmm0
vmovd %xmm1, %r11d
movsbl %r11b, %r11d
movl %r11d, (%rsi,%r9)
vpextrb $0x1, %xmm1, %r11d
addq %r9, %rsi
movsbl %r11b, %r11d
vpextrb $0x2, %xmm1, %edx
movl %r11d, (%r10,%rsi)
movsbl %dl, %edx
vpextrb $0x3, %xmm1, %r11d
movl %edx, (%r14,%rsi)
movsbl %r11b, %edx
vpextrb $0x4, %xmm1, %r11d
movq 0x10(%rsp), %rax
movl %edx, (%rax,%rsi)
movsbl %r11b, %edx
vpextrb $0x5, %xmm1, %r11d
movl %edx, (%rdi,%rsi)
movsbl %r11b, %edx
vpextrb $0x6, %xmm1, %r11d
movq 0x58(%rsp), %rax
movl %edx, (%rax,%rsi)
movsbl %r11b, %edx
vpextrb $0x7, %xmm1, %r11d
movq 0xb8(%rsp), %rax
movl %edx, (%rax,%rsi)
movsbl %r11b, %edx
vpextrb $0x8, %xmm1, %r11d
movq 0x40(%rsp), %rax
movl %edx, (%rax,%rsi)
movsbl %r11b, %edx
vpextrb $0x9, %xmm1, %r11d
movq 0x20(%rsp), %rax
movl %edx, (%rax,%rsi)
movsbl %r11b, %edx
vpextrb $0xa, %xmm1, %r11d
movl %edx, (%r8,%rsi)
movsbl %r11b, %edx
vpextrb $0xb, %xmm1, %r11d
movl %edx, (%rcx,%rsi)
movsbl %r11b, %edx
vpextrb $0xc, %xmm1, %r11d
movq 0x60(%rsp), %rax
movl %edx, (%rax,%rsi)
movsbl %r11b, %edx
vpextrb $0xd, %xmm1, %r11d
movq 0x90(%rsp), %rax
movl %edx, (%rax,%rsi)
movsbl %r11b, %edx
vpextrb $0xe, %xmm1, %r11d
movq 0x160(%rsp), %rax
movl %edx, (%rax,%rsi)
movsbl %r11b, %edx
vpextrb $0xf, %xmm1, %r11d
movq 0x180(%rsp), %rax
movl %edx, (%rax,%rsi)
movsbl %r11b, %edx
movq 0x48(%rsp), %r11
movq 0x1a0(%rsp), %rax
movl %edx, (%rax,%rsi)
vmovd %xmm0, %edx
movsbl %dl, %edx
movl %edx, (%rbx,%rsi)
vpextrb $0x1, %xmm0, %edx
movsbl %dl, %edx
movq 0x98(%rsp), %rax
movl %edx, (%rax,%rsi)
vpextrb $0x2, %xmm0, %edx
movsbl %dl, %edx
movq 0xa0(%rsp), %rax
movl %edx, (%rax,%rsi)
vpextrb $0x3, %xmm0, %edx
movsbl %dl, %edx
movq 0x68(%rsp), %rax
movl %edx, (%rax,%rsi)
vpextrb $0x4, %xmm0, %edx
movsbl %dl, %edx
movq 0xa8(%rsp), %rax
movl %edx, (%rax,%rsi)
vpextrb $0x5, %xmm0, %edx
movsbl %dl, %edx
movq 0x70(%rsp), %rax
movl %edx, (%rax,%rsi)
vpextrb $0x6, %xmm0, %edx
movsbl %dl, %edx
movq 0x78(%rsp), %rax
movl %edx, (%rax,%rsi)
vpextrb $0x7, %xmm0, %edx
movsbl %dl, %edx
movq 0x1c0(%rsp), %rax
movl %edx, (%rax,%rsi)
vpextrb $0x8, %xmm0, %edx
movsbl %dl, %edx
movq 0xb0(%rsp), %rax
movl %edx, (%rax,%rsi)
vpextrb $0x9, %xmm0, %edx
movsbl %dl, %edx
movq 0x30(%rsp), %rax
movl %edx, (%rax,%rsi)
vpextrb $0xa, %xmm0, %edx
movsbl %dl, %edx
movq 0x80(%rsp), %rax
movl %edx, (%rax,%rsi)
vpextrb $0xb, %xmm0, %edx
movsbl %dl, %edx
movq 0x38(%rsp), %rax
movl %edx, (%rax,%rsi)
vpextrb $0xc, %xmm0, %edx
movsbl %dl, %edx
movq 0xe0(%rsp), %rax
movl %edx, (%rax,%rsi)
vpextrb $0xd, %xmm0, %edx
movsbl %dl, %edx
movq 0x100(%rsp), %rax
movl %edx, (%rax,%rsi)
vpextrb $0xe, %xmm0, %edx
movsbl %dl, %edx
movq 0x120(%rsp), %rax
movl %edx, (%rax,%rsi)
vpextrb $0xf, %xmm0, %edx
movsbl %dl, %edx
movq 0x140(%rsp), %rax
movl %edx, (%rax,%rsi)
addq $0x4, %r9
cmpq %r9, 0x28(%rsp)
jne 0x526d8a
vmovdqu 0xc0(%rsp), %ymm0
vpcmpgtb %ymm7, %ymm0, %ymm0
vpcmpgtb 0x1e0(%rsp), %ymm6, %ymm1
vpor %ymm0, %ymm1, %ymm0
vpmovmskb %ymm0, %eax
testl %eax, %eax
movq 0x50(%rsp), %rcx
movl 0xc(%rsp), %eax
movl 0x1c(%rsp), %edx
je 0x52702b
orb $0x40, 0xc(%r11)
xorl %eax, %eax
xorl %edx, %edx
xorl %ecx, %ecx
movsbl %al, %eax
movl %eax, (%r11)
movl %ecx, 0x4(%r11)
movl %edx, 0x8(%r11)
movq %rbp, %rdi
vzeroupper
callq 0x2094b5
movq 0x88(%rsp), %rdi
callq 0x2094b5
movq %r13, %rdi
callq 0x2094b5
movq %r12, %rdi
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
movq 0x48(%rsp), %rax
jmp 0x5270a8
callq 0x1f08f7
jmp 0x5270a6
callq 0x1f08d1
jmp 0x5270a6
callq 0x1f08ab
jmp 0x5270a6
callq 0x1f0885
jmp 0x5270a6
callq 0x1f085f
jmp 0x5270a6
callq 0x1f0839
jmp 0x5270a6
callq 0x1f0813
jmp 0x5270a6
callq 0x1f07ed
xorl %eax, %eax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop