LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_striped_sse2_128_16.c
// Function: arr_store_si128
static inline void arr_store_si128(
        int *array,
        __m128i vH,
        int32_t t,
        int32_t seglen,
        int32_t d,
        int32_t dlen)
{
    array[1LL*(0*seglen+t)*dlen + d] = (int16_t)_mm_extract_epi16(vH, 0);
    array[1LL*(1*seglen+t)*dlen + d] = (int16_t)_mm_extract_epi16(vH, 1);
    array[1LL*(2*seglen+t)*dlen + d] = (int16_t)_mm_extract_epi16(vH, 2);
    array[1LL*(3*seglen+t)*dlen + d] = (int16_t)_mm_extract_epi16(vH, 3);
    array[1LL*(4*seglen+t)*dlen + d] = (int16_t)_mm_extract_epi16(vH, 4);
    array[1LL*(5*seglen+t)*dlen + d] = (int16_t)_mm_extract_epi16(vH, 5);
    array[1LL*(6*seglen+t)*dlen + d] = (int16_t)_mm_extract_epi16(vH, 6);
    array[1LL*(7*seglen+t)*dlen + d] = (int16_t)_mm_extract_epi16(vH, 7);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movslq %esi, %rax
movl %r8d, %esi
leal (%rdx,%rax), %r8d
movslq %r8d, %r8
imulq %rsi, %r8
leal (%rax,%rdx,2), %r9d
movslq %r9d, %r9
imulq %rsi, %r9
leal (%rdx,%rdx,2), %r10d
addl %eax, %r10d
movslq %r10d, %r10
imulq %rsi, %r10
leal (%rax,%rdx,4), %r11d
movslq %r11d, %r11
imulq %rsi, %r11
leal (%rdx,%rdx,4), %ebx
addl %eax, %ebx
movslq %ebx, %rbx
imulq %rsi, %rbx
imull $0x6, %edx, %ebp
addl %eax, %ebp
movslq %ebp, %r14
imulq %rsi, %r14
imull $0x7, %edx, %edx
addl %eax, %edx
movslq %edx, %rdx
imulq %rsi, %rdx
imulq %rax, %rsi
movd %xmm0, %eax
cwtl
movslq %ecx, %rcx
leaq (%rdi,%rsi,4), %rsi
movl %eax, (%rsi,%rcx,4)
pextrw $0x1, %xmm0, %eax
cwtl
leaq (%rdi,%r8,4), %rsi
movl %eax, (%rsi,%rcx,4)
pextrw $0x2, %xmm0, %eax
cwtl
leaq (%rdi,%r9,4), %rsi
pextrw $0x3, %xmm0, %r8d
movl %eax, (%rsi,%rcx,4)
movswl %r8w, %eax
leaq (%rdi,%r10,4), %rsi
movl %eax, (%rsi,%rcx,4)
pextrw $0x4, %xmm0, %eax
cwtl
leaq (%rdi,%r11,4), %rsi
movl %eax, (%rsi,%rcx,4)
pextrw $0x5, %xmm0, %eax
cwtl
leaq (%rdi,%rbx,4), %rsi
movl %eax, (%rsi,%rcx,4)
pextrw $0x6, %xmm0, %eax
cwtl
leaq (%rdi,%r14,4), %rsi
pextrw $0x7, %xmm0, %r8d
movl %eax, (%rsi,%rcx,4)
movswl %r8w, %eax
leaq (%rdi,%rdx,4), %rdx
movl %eax, (%rdx,%rcx,4)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_striped_sse2_128_16.c
// Function: arr_store_si128
static inline void arr_store_si128(
        int *array,
        __m128i vH,
        int32_t t,
        int32_t seglen,
        int32_t d,
        int32_t dlen,
        int32_t bias)
{
    array[1LL*(0*seglen+t)*dlen + d] = (int16_t)_mm_extract_epi16(vH, 0) - bias;
    array[1LL*(1*seglen+t)*dlen + d] = (int16_t)_mm_extract_epi16(vH, 1) - bias;
    array[1LL*(2*seglen+t)*dlen + d] = (int16_t)_mm_extract_epi16(vH, 2) - bias;
    array[1LL*(3*seglen+t)*dlen + d] = (int16_t)_mm_extract_epi16(vH, 3) - bias;
    array[1LL*(4*seglen+t)*dlen + d] = (int16_t)_mm_extract_epi16(vH, 4) - bias;
    array[1LL*(5*seglen+t)*dlen + d] = (int16_t)_mm_extract_epi16(vH, 5) - bias;
    array[1LL*(6*seglen+t)*dlen + d] = (int16_t)_mm_extract_epi16(vH, 6) - bias;
    array[1LL*(7*seglen+t)*dlen + d] = (int16_t)_mm_extract_epi16(vH, 7) - bias;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movd %xmm0, %eax
cwtl
movslq %esi, %rsi
movl %r8d, %r8d
leal (%rdx,%rsi), %r9d
movslq %r9d, %r9
imulq %r8, %r9
leal (%rsi,%rdx,2), %r10d
movslq %r10d, %r10
imulq %r8, %r10
leal (%rdx,%rdx,2), %r11d
addl %esi, %r11d
movslq %r11d, %r11
imulq %r8, %r11
leal (%rsi,%rdx,4), %ebx
movslq %ebx, %rbx
imulq %r8, %rbx
leal (%rdx,%rdx,4), %ebp
addl %esi, %ebp
movslq %ebp, %r14
imulq %r8, %r14
imull $0x6, %edx, %ebp
addl %esi, %ebp
movslq %ebp, %r15
imulq %r8, %r15
imull $0x7, %edx, %edx
addl %esi, %edx
movslq %edx, %rdx
imulq %r8, %rdx
imulq %rsi, %r8
movl $0x8000, %esi           # imm = 0x8000
addl %esi, %eax
movslq %ecx, %rcx
leaq (%rdi,%r8,4), %r8
movl %eax, (%r8,%rcx,4)
pextrw $0x1, %xmm0, %eax
cwtl
addl %esi, %eax
leaq (%rdi,%r9,4), %r8
movl %eax, (%r8,%rcx,4)
pextrw $0x2, %xmm0, %eax
cwtl
addl %esi, %eax
leaq (%rdi,%r10,4), %r8
movl %eax, (%r8,%rcx,4)
pextrw $0x3, %xmm0, %eax
cwtl
addl %esi, %eax
leaq (%rdi,%r11,4), %r8
movl %eax, (%r8,%rcx,4)
pextrw $0x4, %xmm0, %eax
cwtl
addl %esi, %eax
leaq (%rdi,%rbx,4), %r8
movl %eax, (%r8,%rcx,4)
pextrw $0x5, %xmm0, %eax
cwtl
addl %esi, %eax
leaq (%rdi,%r14,4), %r8
movl %eax, (%r8,%rcx,4)
pextrw $0x6, %xmm0, %eax
cwtl
addl %esi, %eax
leaq (%rdi,%r15,4), %r8
movl %eax, (%r8,%rcx,4)
pextrw $0x7, %xmm0, %eax
cwtl
addl %esi, %eax
leaq (%rdi,%rdx,4), %rdx
movl %eax, (%rdx,%rcx,4)
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_stats_diag_sse2_128_64.c
// Function: arr_store_si128
static inline void arr_store_si128(
        int *array,
        __m128i vWH,
        int32_t i,
        int32_t s1Len,
        int32_t j,
        int32_t s2Len)
{
    if (0 <= i+0 && i+0 < s1Len && 0 <= j-0 && j-0 < s2Len) {
        array[1LL*(i+0)*s2Len + (j-0)] = (int64_t)_mm_extract_epi64_rpl(vWH, 1);
    }
    if (0 <= i+1 && i+1 < s1Len && 0 <= j-1 && j-1 < s2Len) {
        array[1LL*(i+1)*s2Len + (j-1)] = (int64_t)_mm_extract_epi64_rpl(vWH, 0);
    }
}

// Assembly:
movl %r8d, %r9d
movl %ecx, %eax
cmpl %r8d, %ecx
jge 0x2c993e
cmpl %edx, %esi
jge 0x2c993e
movl %ecx, %r10d
orl %esi, %r10d
js 0x2c993e
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
movl %esi, %r10d
imulq %r9, %r10
leaq (%rdi,%r10,4), %r10
movd %xmm1, (%r10,%rax,4)
leal 0x1(%rsi), %r10d
cmpl $-0x1, %esi
setl %sil
cmpl %edx, %r10d
setge %dl
testl %ecx, %ecx
setle %r11b
orb %sil, %r11b
orb %dl, %r11b
cmpl %r8d, %ecx
setg %cl
orb %r11b, %cl
jne 0x2c9977
movl %r10d, %ecx
imulq %rcx, %r9
leaq (%rdi,%r9,4), %rcx
movd %xmm0, -0x4(%rcx,%rax,4)
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_stats_diag_sse2_128_32.c
// Function: arr_store_si128
static inline void arr_store_si128(
        int *array,
        __m128i vWH,
        int32_t i,
        int32_t s1Len,
        int32_t j,
        int32_t s2Len)
{
    if (0 <= i+0 && i+0 < s1Len && 0 <= j-0 && j-0 < s2Len) {
        array[1LL*(i+0)*s2Len + (j-0)] = (int32_t)_mm_extract_epi32_rpl(vWH, 3);
    }
    if (0 <= i+1 && i+1 < s1Len && 0 <= j-1 && j-1 < s2Len) {
        array[1LL*(i+1)*s2Len + (j-1)] = (int32_t)_mm_extract_epi32_rpl(vWH, 2);
    }
    if (0 <= i+2 && i+2 < s1Len && 0 <= j-2 && j-2 < s2Len) {
        array[1LL*(i+2)*s2Len + (j-2)] = (int32_t)_mm_extract_epi32_rpl(vWH, 1);
    }
    if (0 <= i+3 && i+3 < s1Len && 0 <= j-3 && j-3 < s2Len) {
        array[1LL*(i+3)*s2Len + (j-3)] = (int32_t)_mm_extract_epi32_rpl(vWH, 0);
    }
}

// Assembly:
movl %r8d, %eax
movl %ecx, %r9d
cmpl %r8d, %ecx
jge 0x2cdf80
cmpl %edx, %esi
jge 0x2cdf80
movl %ecx, %r10d
orl %esi, %r10d
js 0x2cdf80
pshufd $0xff, %xmm0, %xmm1     # xmm1 = xmm0[3,3,3,3]
movl %esi, %r10d
imulq %rax, %r10
leaq (%rdi,%r10,4), %r10
movd %xmm1, (%r10,%r9,4)
pushq %rbp
pushq %rbx
leal 0x1(%rsi), %r10d
cmpl $-0x1, %esi
setl %r11b
cmpl %edx, %r10d
setge %bl
testl %ecx, %ecx
setle %bpl
orb %r11b, %bpl
orb %bl, %bpl
cmpl %r8d, %ecx
setg %r11b
orb %bpl, %r11b
jne 0x2cdfc2
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
movl %r10d, %r10d
imulq %rax, %r10
leaq (%rdi,%r10,4), %r10
movd %xmm1, -0x4(%r10,%r9,4)
leal 0x2(%rsi), %r9d
cmpl $-0x2, %esi
setge %r10b
cmpl %edx, %r9d
setl %r11b
andb %r10b, %r11b
cmpb $0x1, %r11b
jne 0x2ce00f
leal -0x2(%rcx), %r10d
cmpl $0x2, %ecx
setge %r11b
cmpl %r8d, %r10d
setl %bl
andb %r11b, %bl
cmpb $0x1, %bl
jne 0x2ce00f
pshufd $0x55, %xmm0, %xmm1     # xmm1 = xmm0[1,1,1,1]
movl %r9d, %r9d
imulq %rax, %r9
movl %r10d, %r10d
leaq (%rdi,%r9,4), %r9
movd %xmm1, (%r9,%r10,4)
leal 0x3(%rsi), %r9d
cmpl $-0x3, %esi
setge %sil
cmpl %edx, %r9d
setl %dl
andb %sil, %dl
cmpb $0x1, %dl
popq %rbx
popq %rbp
jne 0x2ce055
leal -0x3(%rcx), %edx
cmpl $0x3, %ecx
setge %cl
cmpl %r8d, %edx
setl %sil
andb %cl, %sil
cmpb $0x1, %sil
jne 0x2ce055
movl %r9d, %ecx
imulq %rcx, %rax
movl %edx, %ecx
leaq (%rdi,%rax,4), %rax
movd %xmm0, (%rax,%rcx,4)
retq
nop
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_stats_scan_sse2_128_32.c
// Function: arr_store_col
static inline void arr_store_col(
        int *col,
        __m128i vH,
        int32_t t,
        int32_t seglen)
{
    col[0*seglen+t] = (int32_t)_mm_extract_epi32_rpl(vH, 0);
    col[1*seglen+t] = (int32_t)_mm_extract_epi32_rpl(vH, 1);
    col[2*seglen+t] = (int32_t)_mm_extract_epi32_rpl(vH, 2);
    col[3*seglen+t] = (int32_t)_mm_extract_epi32_rpl(vH, 3);
}

// Assembly:
movslq %esi, %rax
movd %xmm0, (%rdi,%rax,4)
pshufd $0x55, %xmm0, %xmm1     # xmm1 = xmm0[1,1,1,1]
leal (%rdx,%rax), %ecx
movslq %ecx, %rcx
movd %xmm1, (%rdi,%rcx,4)
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
leal (%rax,%rdx,2), %ecx
movslq %ecx, %rcx
movd %xmm1, (%rdi,%rcx,4)
pshufd $0xff, %xmm0, %xmm0     # xmm0 = xmm0[3,3,3,3]
leal (%rdx,%rdx,2), %ecx
addl %eax, %ecx
movslq %ecx, %rax
movd %xmm0, (%rdi,%rax,4)
retq
nop
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_stats_scan_sse2_128_16.c
// Function: arr_store_col
static inline void arr_store_col(
        int *col,
        __m128i vH,
        int32_t t,
        int32_t seglen)
{
    col[0*seglen+t] = (int16_t)_mm_extract_epi16(vH, 0);
    col[1*seglen+t] = (int16_t)_mm_extract_epi16(vH, 1);
    col[2*seglen+t] = (int16_t)_mm_extract_epi16(vH, 2);
    col[3*seglen+t] = (int16_t)_mm_extract_epi16(vH, 3);
    col[4*seglen+t] = (int16_t)_mm_extract_epi16(vH, 4);
    col[5*seglen+t] = (int16_t)_mm_extract_epi16(vH, 5);
    col[6*seglen+t] = (int16_t)_mm_extract_epi16(vH, 6);
    col[7*seglen+t] = (int16_t)_mm_extract_epi16(vH, 7);
}

// Assembly:
movd %xmm0, %eax
movswl %ax, %ecx
movslq %esi, %rax
movl %ecx, (%rdi,%rax,4)
pextrw $0x1, %xmm0, %ecx
movswl %cx, %ecx
leal (%rdx,%rax), %esi
movslq %esi, %rsi
movl %ecx, (%rdi,%rsi,4)
pextrw $0x2, %xmm0, %ecx
movswl %cx, %ecx
leal (%rax,%rdx,2), %esi
movslq %esi, %rsi
movl %ecx, (%rdi,%rsi,4)
pextrw $0x3, %xmm0, %ecx
movswl %cx, %ecx
leal (%rdx,%rdx,2), %esi
addl %eax, %esi
movslq %esi, %rsi
movl %ecx, (%rdi,%rsi,4)
pextrw $0x4, %xmm0, %ecx
movswl %cx, %ecx
leal (%rax,%rdx,4), %esi
movslq %esi, %rsi
pextrw $0x5, %xmm0, %r8d
movl %ecx, (%rdi,%rsi,4)
movswl %r8w, %ecx
leal (%rdx,%rdx,4), %esi
addl %eax, %esi
movslq %esi, %rsi
movl %ecx, (%rdi,%rsi,4)
pextrw $0x6, %xmm0, %ecx
movswl %cx, %ecx
imull $0x6, %edx, %esi
addl %eax, %esi
movslq %esi, %rsi
movl %ecx, (%rdi,%rsi,4)
pextrw $0x7, %xmm0, %ecx
movswl %cx, %ecx
imull $0x7, %edx, %edx
addl %eax, %edx
movslq %edx, %rax
movl %ecx, (%rdi,%rax,4)
retq
nop
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_stats_scan_sse2_128_8.c
// Function: arr_store_col
static inline void arr_store_col(
        int *col,
        __m128i vH,
        int32_t t,
        int32_t seglen)
{
    col[ 0*seglen+t] = (int8_t)_mm_extract_epi8_rpl(vH,  0);
    col[ 1*seglen+t] = (int8_t)_mm_extract_epi8_rpl(vH,  1);
    col[ 2*seglen+t] = (int8_t)_mm_extract_epi8_rpl(vH,  2);
    col[ 3*seglen+t] = (int8_t)_mm_extract_epi8_rpl(vH,  3);
    col[ 4*seglen+t] = (int8_t)_mm_extract_epi8_rpl(vH,  4);
    col[ 5*seglen+t] = (int8_t)_mm_extract_epi8_rpl(vH,  5);
    col[ 6*seglen+t] = (int8_t)_mm_extract_epi8_rpl(vH,  6);
    col[ 7*seglen+t] = (int8_t)_mm_extract_epi8_rpl(vH,  7);
    col[ 8*seglen+t] = (int8_t)_mm_extract_epi8_rpl(vH,  8);
    col[ 9*seglen+t] = (int8_t)_mm_extract_epi8_rpl(vH,  9);
    col[10*seglen+t] = (int8_t)_mm_extract_epi8_rpl(vH, 10);
    col[11*seglen+t] = (int8_t)_mm_extract_epi8_rpl(vH, 11);
    col[12*seglen+t] = (int8_t)_mm_extract_epi8_rpl(vH, 12);
    col[13*seglen+t] = (int8_t)_mm_extract_epi8_rpl(vH, 13);
    col[14*seglen+t] = (int8_t)_mm_extract_epi8_rpl(vH, 14);
    col[15*seglen+t] = (int8_t)_mm_extract_epi8_rpl(vH, 15);
}

// Assembly:
movaps %xmm0, -0x18(%rsp)
movsbl -0x18(%rsp), %ecx
movslq %esi, %rax
movl %ecx, (%rdi,%rax,4)
movsbl -0x17(%rsp), %ecx
leal (%rdx,%rax), %esi
movslq %esi, %rsi
movl %ecx, (%rdi,%rsi,4)
movsbl -0x16(%rsp), %ecx
leal (%rax,%rdx,2), %esi
movslq %esi, %rsi
movl %ecx, (%rdi,%rsi,4)
movsbl -0x15(%rsp), %ecx
leal (%rdx,%rdx,2), %esi
addl %eax, %esi
movslq %esi, %rsi
movl %ecx, (%rdi,%rsi,4)
movsbl -0x14(%rsp), %ecx
leal (%rax,%rdx,4), %esi
movslq %esi, %rsi
movl %ecx, (%rdi,%rsi,4)
movsbl -0x13(%rsp), %ecx
leal (%rdx,%rdx,4), %esi
addl %eax, %esi
movslq %esi, %rsi
movl %ecx, (%rdi,%rsi,4)
movsbl -0x12(%rsp), %ecx
imull $0x6, %edx, %esi
addl %eax, %esi
movslq %esi, %rsi
movl %ecx, (%rdi,%rsi,4)
movsbl -0x11(%rsp), %ecx
imull $0x7, %edx, %esi
addl %eax, %esi
movslq %esi, %rsi
movl %ecx, (%rdi,%rsi,4)
movsbl -0x10(%rsp), %ecx
leal (%rax,%rdx,8), %esi
movslq %esi, %rsi
movl %ecx, (%rdi,%rsi,4)
movsbl -0xf(%rsp), %ecx
leal (%rdx,%rdx,8), %esi
addl %eax, %esi
movslq %esi, %rsi
movl %ecx, (%rdi,%rsi,4)
movsbl -0xe(%rsp), %ecx
imull $0xa, %edx, %esi
addl %eax, %esi
movslq %esi, %rsi
movl %ecx, (%rdi,%rsi,4)
movsbl -0xd(%rsp), %ecx
imull $0xb, %edx, %esi
addl %eax, %esi
movslq %esi, %rsi
movl %ecx, (%rdi,%rsi,4)
movsbl -0xc(%rsp), %ecx
imull $0xc, %edx, %esi
addl %eax, %esi
movslq %esi, %rsi
movl %ecx, (%rdi,%rsi,4)
movsbl -0xb(%rsp), %ecx
imull $0xd, %edx, %esi
addl %eax, %esi
movslq %esi, %rsi
movl %ecx, (%rdi,%rsi,4)
movsbl -0xa(%rsp), %ecx
imull $0xe, %edx, %esi
addl %eax, %esi
movslq %esi, %rsi
movl %ecx, (%rdi,%rsi,4)
movsbl -0x9(%rsp), %ecx
imull $0xf, %edx, %edx
addl %eax, %edx
movslq %edx, %rax
movl %ecx, (%rdi,%rax,4)
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_stats_diag_sse2_128_64.c
// Function: arr_store_rowcol
static inline void arr_store_rowcol(
        int *row,
        int *col,
        __m128i vWH,
        int32_t i,
        int32_t s1Len,
        int32_t j,
        int32_t s2Len)
{
    if (i+0 == s1Len-1 && 0 <= j-0 && j-0 < s2Len) {
        row[j-0] = (int64_t)_mm_extract_epi64_rpl(vWH, 1);
    }
    if (j-0 == s2Len-1 && 0 <= i+0 && i+0 < s1Len) {
        col[(i+0)] = (int64_t)_mm_extract_epi64_rpl(vWH, 1);
    }
    if (i+1 == s1Len-1 && 0 <= j-1 && j-1 < s2Len) {
        row[j-1] = (int64_t)_mm_extract_epi64_rpl(vWH, 0);
    }
    if (j-1 == s2Len-1 && 0 <= i+1 && i+1 < s1Len) {
        col[(i+1)] = (int64_t)_mm_extract_epi64_rpl(vWH, 0);
    }
}

// Assembly:
pushq %rbp
pushq %rbx
leal -0x1(%rcx), %r10d
cmpl %edx, %r10d
setne %al
testl %r8d, %r8d
sets %r11b
cmpl %r9d, %r8d
setge %bl
orb %r11b, %bl
orb %al, %bl
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
movl %r8d, %eax
jne 0x31d663
movd %xmm1, (%rdi,%rax,4)
cmpl %ecx, %edx
jge 0x31d67d
testl %edx, %edx
js 0x31d67d
leal -0x1(%r9), %r11d
cmpl %r8d, %r11d
jne 0x31d67d
movl %edx, %r11d
movd %xmm1, (%rsi,%r11,4)
leal 0x1(%rdx), %r11d
cmpl %r10d, %r11d
setne %r10b
testl %r8d, %r8d
setle %bl
cmpl %r9d, %r8d
setg %bpl
orb %bl, %bpl
orb %r10b, %bpl
jne 0x31d6a3
movd %xmm0, -0x4(%rdi,%rax,4)
cmpl %ecx, %r11d
jge 0x31d6ba
cmpl $-0x1, %edx
jl 0x31d6ba
cmpl %r9d, %r8d
jne 0x31d6ba
movl %r11d, %eax
movd %xmm0, (%rsi,%rax,4)
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_stats_diag_sse2_128_32.c
// Function: arr_store_rowcol
static inline void arr_store_rowcol(
        int *row,
        int *col,
        __m128i vWH,
        int32_t i,
        int32_t s1Len,
        int32_t j,
        int32_t s2Len)
{
    if (i+0 == s1Len-1 && 0 <= j-0 && j-0 < s2Len) {
        row[j-0] = (int32_t)_mm_extract_epi32_rpl(vWH, 3);
    }
    if (j-0 == s2Len-1 && 0 <= i+0 && i+0 < s1Len) {
        col[(i+0)] = (int32_t)_mm_extract_epi32_rpl(vWH, 3);
    }
    if (i+1 == s1Len-1 && 0 <= j-1 && j-1 < s2Len) {
        row[j-1] = (int32_t)_mm_extract_epi32_rpl(vWH, 2);
    }
    if (j-1 == s2Len-1 && 0 <= i+1 && i+1 < s1Len) {
        col[(i+1)] = (int32_t)_mm_extract_epi32_rpl(vWH, 2);
    }
    if (i+2 == s1Len-1 && 0 <= j-2 && j-2 < s2Len) {
        row[j-2] = (int32_t)_mm_extract_epi32_rpl(vWH, 1);
    }
    if (j-2 == s2Len-1 && 0 <= i+2 && i+2 < s1Len) {
        col[(i+2)] = (int32_t)_mm_extract_epi32_rpl(vWH, 1);
    }
    if (i+3 == s1Len-1 && 0 <= j-3 && j-3 < s2Len) {
        row[j-3] = (int32_t)_mm_extract_epi32_rpl(vWH, 0);
    }
    if (j-3 == s2Len-1 && 0 <= i+3 && i+3 < s1Len) {
        col[(i+3)] = (int32_t)_mm_extract_epi32_rpl(vWH, 0);
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
leal -0x1(%rcx), %eax
cmpl %edx, %eax
setne %r10b
testl %r8d, %r8d
sets %r11b
cmpl %r9d, %r8d
setge %bl
orb %r11b, %bl
orb %r10b, %bl
pshufd $0xff, %xmm0, %xmm1     # xmm1 = xmm0[3,3,3,3]
movl %r8d, %r10d
jne 0x321d3f
movd %xmm1, (%rdi,%r10,4)
cmpl %ecx, %edx
jge 0x321d59
testl %edx, %edx
js 0x321d59
leal -0x1(%r9), %r11d
cmpl %r8d, %r11d
jne 0x321d59
movl %edx, %r11d
movd %xmm1, (%rsi,%r11,4)
leal 0x1(%rdx), %r11d
cmpl %eax, %r11d
setne %bl
testl %r8d, %r8d
setle %bpl
cmpl %r9d, %r8d
setg %r14b
orb %bpl, %r14b
orb %bl, %r14b
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
jne 0x321d85
movd %xmm1, -0x4(%rdi,%r10,4)
cmpl %ecx, %r11d
jge 0x321d9d
cmpl $-0x1, %edx
jl 0x321d9d
cmpl %r9d, %r8d
jne 0x321d9d
movl %r11d, %r10d
movd %xmm1, (%rsi,%r10,4)
leal 0x2(%rdx), %r10d
pshufd $0x55, %xmm0, %xmm1     # xmm1 = xmm0[1,1,1,1]
cmpl %eax, %r10d
jne 0x321dcf
leal -0x2(%r8), %r11d
cmpl $0x2, %r8d
setge %bl
cmpl %r9d, %r11d
setl %bpl
andb %bl, %bpl
cmpb $0x1, %bpl
jne 0x321dcf
movl %r11d, %r11d
movd %xmm1, (%rdi,%r11,4)
cmpl %ecx, %r10d
jge 0x321deb
cmpl $-0x2, %edx
jl 0x321deb
leal -0x1(%r8), %r11d
cmpl %r9d, %r11d
jne 0x321deb
movl %r10d, %r10d
movd %xmm1, (%rsi,%r10,4)
leal 0x3(%rdx), %r10d
cmpl %eax, %r10d
jne 0x321e15
leal -0x3(%r8), %eax
cmpl $0x3, %r8d
setge %r11b
cmpl %r9d, %eax
setl %bl
andb %r11b, %bl
cmpb $0x1, %bl
jne 0x321e15
movl %eax, %eax
movd %xmm0, (%rdi,%rax,4)
cmpl %ecx, %r10d
jge 0x321e30
cmpl $-0x3, %edx
jl 0x321e30
addl $-0x2, %r8d
cmpl %r9d, %r8d
jne 0x321e30
movl %r10d, %eax
movd %xmm0, (%rsi,%rax,4)
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/sw_stats_striped_sse2_128_16.c
// Function: arr_store_col
static inline void arr_store_col(
        int *col,
        __m128i vH,
        int32_t t,
        int32_t seglen,
        int32_t bias)
{
    col[0*seglen+t] = (int16_t)_mm_extract_epi16(vH, 0) - bias;
    col[1*seglen+t] = (int16_t)_mm_extract_epi16(vH, 1) - bias;
    col[2*seglen+t] = (int16_t)_mm_extract_epi16(vH, 2) - bias;
    col[3*seglen+t] = (int16_t)_mm_extract_epi16(vH, 3) - bias;
    col[4*seglen+t] = (int16_t)_mm_extract_epi16(vH, 4) - bias;
    col[5*seglen+t] = (int16_t)_mm_extract_epi16(vH, 5) - bias;
    col[6*seglen+t] = (int16_t)_mm_extract_epi16(vH, 6) - bias;
    col[7*seglen+t] = (int16_t)_mm_extract_epi16(vH, 7) - bias;
}

// Assembly:
movd %xmm0, %eax
movswl %ax, %r8d
movl $0x8000, %eax           # imm = 0x8000
addl %eax, %r8d
movslq %esi, %rcx
pextrw $0x1, %xmm0, %esi
movl %r8d, (%rdi,%rcx,4)
movswl %si, %esi
addl %eax, %esi
leal (%rdx,%rcx), %r8d
movslq %r8d, %r8
movl %esi, (%rdi,%r8,4)
pextrw $0x2, %xmm0, %esi
movswl %si, %esi
addl %eax, %esi
leal (%rcx,%rdx,2), %r8d
movslq %r8d, %r8
movl %esi, (%rdi,%r8,4)
pextrw $0x3, %xmm0, %esi
movswl %si, %esi
addl %eax, %esi
leal (%rdx,%rdx,2), %r8d
addl %ecx, %r8d
movslq %r8d, %r8
movl %esi, (%rdi,%r8,4)
pextrw $0x4, %xmm0, %esi
movswl %si, %esi
addl %eax, %esi
leal (%rcx,%rdx,4), %r8d
movslq %r8d, %r8
movl %esi, (%rdi,%r8,4)
pextrw $0x5, %xmm0, %esi
movswl %si, %esi
addl %eax, %esi
leal (%rdx,%rdx,4), %r8d
addl %ecx, %r8d
movslq %r8d, %r8
movl %esi, (%rdi,%r8,4)
pextrw $0x6, %xmm0, %esi
movswl %si, %esi
addl %eax, %esi
imull $0x6, %edx, %r8d
addl %ecx, %r8d
movslq %r8d, %r8
movl %esi, (%rdi,%r8,4)
pextrw $0x7, %xmm0, %esi
movswl %si, %esi
addl %eax, %esi
imull $0x7, %edx, %eax
addl %ecx, %eax
cltq
movl %esi, (%rdi,%rax,4)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_striped_sse41_128_32.c
// Function: arr_store_si128
static inline void arr_store_si128(
        int *array,
        __m128i vH,
        int32_t t,
        int32_t seglen,
        int32_t d,
        int32_t dlen)
{
    array[1LL*(0*seglen+t)*dlen + d] = (int32_t)_mm_extract_epi32(vH, 0);
    array[1LL*(1*seglen+t)*dlen + d] = (int32_t)_mm_extract_epi32(vH, 1);
    array[1LL*(2*seglen+t)*dlen + d] = (int32_t)_mm_extract_epi32(vH, 2);
    array[1LL*(3*seglen+t)*dlen + d] = (int32_t)_mm_extract_epi32(vH, 3);
}

// Assembly:
movslq %esi, %rsi
movl %r8d, %eax
leal (%rdx,%rsi), %r8d
movslq %r8d, %r8
imulq %rax, %r8
movq %rax, %r9
imulq %rsi, %r9
movslq %ecx, %rcx
leaq (%rdi,%r9,4), %r9
movss %xmm0, (%r9,%rcx,4)
leaq (%rdi,%r8,4), %r8
extractps $0x1, %xmm0, (%r8,%rcx,4)
leal (%rsi,%rdx,2), %r8d
movslq %r8d, %r8
imulq %rax, %r8
leaq (%rdi,%r8,4), %r8
extractps $0x2, %xmm0, (%r8,%rcx,4)
leal (%rdx,%rdx,2), %edx
addl %esi, %edx
movslq %edx, %rdx
imulq %rax, %rdx
leaq (%rdi,%rdx,4), %rax
extractps $0x3, %xmm0, (%rax,%rcx,4)
retq
nop
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_stats_diag_sse41_128_32.c
// Function: arr_store_si128
static inline void arr_store_si128(
        int *array,
        __m128i vWH,
        int32_t i,
        int32_t s1Len,
        int32_t j,
        int32_t s2Len)
{
    if (0 <= i+0 && i+0 < s1Len && 0 <= j-0 && j-0 < s2Len) {
        array[1LL*(i+0)*s2Len + (j-0)] = (int32_t)_mm_extract_epi32(vWH, 3);
    }
    if (0 <= i+1 && i+1 < s1Len && 0 <= j-1 && j-1 < s2Len) {
        array[1LL*(i+1)*s2Len + (j-1)] = (int32_t)_mm_extract_epi32(vWH, 2);
    }
    if (0 <= i+2 && i+2 < s1Len && 0 <= j-2 && j-2 < s2Len) {
        array[1LL*(i+2)*s2Len + (j-2)] = (int32_t)_mm_extract_epi32(vWH, 1);
    }
    if (0 <= i+3 && i+3 < s1Len && 0 <= j-3 && j-3 < s2Len) {
        array[1LL*(i+3)*s2Len + (j-3)] = (int32_t)_mm_extract_epi32(vWH, 0);
    }
}

// Assembly:
movl %r8d, %eax
movl %ecx, %r9d
cmpl %r8d, %ecx
jge 0x3cfced
cmpl %edx, %esi
jge 0x3cfced
movl %ecx, %r10d
orl %esi, %r10d
js 0x3cfced
movl %esi, %r10d
imulq %rax, %r10
leaq (%rdi,%r10,4), %r10
extractps $0x3, %xmm0, (%r10,%r9,4)
pushq %rbp
pushq %rbx
leal 0x1(%rsi), %r10d
cmpl $-0x1, %esi
setl %r11b
cmpl %edx, %r10d
setge %bl
testl %ecx, %ecx
setle %bpl
orb %r11b, %bpl
orb %bl, %bpl
cmpl %r8d, %ecx
setg %r11b
orb %bpl, %r11b
jne 0x3cfd2c
movl %r10d, %r10d
imulq %rax, %r10
leaq (%rdi,%r10,4), %r10
extractps $0x2, %xmm0, -0x4(%r10,%r9,4)
leal 0x2(%rsi), %r9d
cmpl $-0x2, %esi
setge %r10b
cmpl %edx, %r9d
setl %r11b
andb %r10b, %r11b
cmpb $0x1, %r11b
jne 0x3cfd76
leal -0x2(%rcx), %r10d
cmpl $0x2, %ecx
setge %r11b
cmpl %r8d, %r10d
setl %bl
andb %r11b, %bl
cmpb $0x1, %bl
jne 0x3cfd76
movl %r9d, %r9d
imulq %rax, %r9
movl %r10d, %r10d
leaq (%rdi,%r9,4), %r9
extractps $0x1, %xmm0, (%r9,%r10,4)
leal 0x3(%rsi), %r9d
cmpl $-0x3, %esi
setge %sil
cmpl %edx, %r9d
setl %dl
andb %sil, %dl
cmpb $0x1, %dl
popq %rbx
popq %rbp
jne 0x3cfdbc
leal -0x3(%rcx), %edx
cmpl $0x3, %ecx
setge %cl
cmpl %r8d, %edx
setl %sil
andb %cl, %sil
cmpb $0x1, %sil
jne 0x3cfdbc
movl %r9d, %ecx
imulq %rcx, %rax
movl %edx, %ecx
leaq (%rdi,%rax,4), %rax
movss %xmm0, (%rax,%rcx,4)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_stats_scan_sse41_128_32.c
// Function: arr_store_col
static inline void arr_store_col(
        int *col,
        __m128i vH,
        int32_t t,
        int32_t seglen)
{
    col[0*seglen+t] = (int32_t)_mm_extract_epi32(vH, 0);
    col[1*seglen+t] = (int32_t)_mm_extract_epi32(vH, 1);
    col[2*seglen+t] = (int32_t)_mm_extract_epi32(vH, 2);
    col[3*seglen+t] = (int32_t)_mm_extract_epi32(vH, 3);
}

// Assembly:
movslq %esi, %rax
movss %xmm0, (%rdi,%rax,4)
leal (%rdx,%rax), %ecx
movslq %ecx, %rcx
extractps $0x1, %xmm0, (%rdi,%rcx,4)
leal (%rax,%rdx,2), %ecx
movslq %ecx, %rcx
extractps $0x2, %xmm0, (%rdi,%rcx,4)
leal (%rdx,%rdx,2), %ecx
addl %eax, %ecx
movslq %ecx, %rax
extractps $0x3, %xmm0, (%rdi,%rax,4)
retq
nop
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_stats_scan_sse41_128_8.c
// Function: arr_store_col
static inline void arr_store_col(
        int *col,
        __m128i vH,
        int32_t t,
        int32_t seglen)
{
    col[ 0*seglen+t] = (int8_t)_mm_extract_epi8(vH,  0);
    col[ 1*seglen+t] = (int8_t)_mm_extract_epi8(vH,  1);
    col[ 2*seglen+t] = (int8_t)_mm_extract_epi8(vH,  2);
    col[ 3*seglen+t] = (int8_t)_mm_extract_epi8(vH,  3);
    col[ 4*seglen+t] = (int8_t)_mm_extract_epi8(vH,  4);
    col[ 5*seglen+t] = (int8_t)_mm_extract_epi8(vH,  5);
    col[ 6*seglen+t] = (int8_t)_mm_extract_epi8(vH,  6);
    col[ 7*seglen+t] = (int8_t)_mm_extract_epi8(vH,  7);
    col[ 8*seglen+t] = (int8_t)_mm_extract_epi8(vH,  8);
    col[ 9*seglen+t] = (int8_t)_mm_extract_epi8(vH,  9);
    col[10*seglen+t] = (int8_t)_mm_extract_epi8(vH, 10);
    col[11*seglen+t] = (int8_t)_mm_extract_epi8(vH, 11);
    col[12*seglen+t] = (int8_t)_mm_extract_epi8(vH, 12);
    col[13*seglen+t] = (int8_t)_mm_extract_epi8(vH, 13);
    col[14*seglen+t] = (int8_t)_mm_extract_epi8(vH, 14);
    col[15*seglen+t] = (int8_t)_mm_extract_epi8(vH, 15);
}

// Assembly:
movd %xmm0, %eax
movsbl %al, %ecx
movslq %esi, %rax
pextrb $0x1, %xmm0, %esi
movl %ecx, (%rdi,%rax,4)
movsbl %sil, %ecx
leal (%rdx,%rax), %esi
movslq %esi, %rsi
movl %ecx, (%rdi,%rsi,4)
pextrb $0x2, %xmm0, %ecx
movsbl %cl, %ecx
leal (%rax,%rdx,2), %esi
movslq %esi, %rsi
pextrb $0x3, %xmm0, %r8d
movl %ecx, (%rdi,%rsi,4)
movsbl %r8b, %ecx
leal (%rdx,%rdx,2), %esi
addl %eax, %esi
movslq %esi, %rsi
movl %ecx, (%rdi,%rsi,4)
pextrb $0x4, %xmm0, %ecx
movsbl %cl, %ecx
leal (%rax,%rdx,4), %esi
movslq %esi, %rsi
movl %ecx, (%rdi,%rsi,4)
pextrb $0x5, %xmm0, %ecx
movsbl %cl, %ecx
leal (%rdx,%rdx,4), %esi
addl %eax, %esi
movslq %esi, %rsi
pextrb $0x6, %xmm0, %r8d
movl %ecx, (%rdi,%rsi,4)
movsbl %r8b, %ecx
imull $0x6, %edx, %esi
addl %eax, %esi
movslq %esi, %rsi
movl %ecx, (%rdi,%rsi,4)
pextrb $0x7, %xmm0, %ecx
movsbl %cl, %ecx
imull $0x7, %edx, %esi
addl %eax, %esi
movslq %esi, %rsi
movl %ecx, (%rdi,%rsi,4)
pextrb $0x8, %xmm0, %ecx
movsbl %cl, %ecx
leal (%rax,%rdx,8), %esi
movslq %esi, %rsi
pextrb $0x9, %xmm0, %r8d
movl %ecx, (%rdi,%rsi,4)
movsbl %r8b, %ecx
leal (%rdx,%rdx,8), %esi
addl %eax, %esi
movslq %esi, %rsi
movl %ecx, (%rdi,%rsi,4)
pextrb $0xa, %xmm0, %ecx
movsbl %cl, %ecx
imull $0xa, %edx, %esi
addl %eax, %esi
movslq %esi, %rsi
movl %ecx, (%rdi,%rsi,4)
pextrb $0xb, %xmm0, %ecx
movsbl %cl, %ecx
imull $0xb, %edx, %esi
addl %eax, %esi
movslq %esi, %rsi
movl %ecx, (%rdi,%rsi,4)
pextrb $0xc, %xmm0, %ecx
movsbl %cl, %ecx
imull $0xc, %edx, %esi
addl %eax, %esi
movslq %esi, %rsi
pextrb $0xd, %xmm0, %r8d
movl %ecx, (%rdi,%rsi,4)
movsbl %r8b, %ecx
imull $0xd, %edx, %esi
addl %eax, %esi
movslq %esi, %rsi
movl %ecx, (%rdi,%rsi,4)
pextrb $0xe, %xmm0, %ecx
movsbl %cl, %ecx
imull $0xe, %edx, %esi
addl %eax, %esi
movslq %esi, %rsi
movl %ecx, (%rdi,%rsi,4)
pextrb $0xf, %xmm0, %ecx
movsbl %cl, %ecx
imull $0xf, %edx, %edx
addl %eax, %edx
movslq %edx, %rax
movl %ecx, (%rdi,%rax,4)
retq
nop
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_stats_diag_sse41_128_32.c
// Function: arr_store_rowcol
static inline void arr_store_rowcol(
        int *row,
        int *col,
        __m128i vWH,
        int32_t i,
        int32_t s1Len,
        int32_t j,
        int32_t s2Len)
{
    if (i+0 == s1Len-1 && 0 <= j-0 && j-0 < s2Len) {
        row[j-0] = (int32_t)_mm_extract_epi32(vWH, 3);
    }
    if (j-0 == s2Len-1 && 0 <= i+0 && i+0 < s1Len) {
        col[(i+0)] = (int32_t)_mm_extract_epi32(vWH, 3);
    }
    if (i+1 == s1Len-1 && 0 <= j-1 && j-1 < s2Len) {
        row[j-1] = (int32_t)_mm_extract_epi32(vWH, 2);
    }
    if (j-1 == s2Len-1 && 0 <= i+1 && i+1 < s1Len) {
        col[(i+1)] = (int32_t)_mm_extract_epi32(vWH, 2);
    }
    if (i+2 == s1Len-1 && 0 <= j-2 && j-2 < s2Len) {
        row[j-2] = (int32_t)_mm_extract_epi32(vWH, 1);
    }
    if (j-2 == s2Len-1 && 0 <= i+2 && i+2 < s1Len) {
        col[(i+2)] = (int32_t)_mm_extract_epi32(vWH, 1);
    }
    if (i+3 == s1Len-1 && 0 <= j-3 && j-3 < s2Len) {
        row[j-3] = (int32_t)_mm_extract_epi32(vWH, 0);
    }
    if (j-3 == s2Len-1 && 0 <= i+3 && i+3 < s1Len) {
        col[(i+3)] = (int32_t)_mm_extract_epi32(vWH, 0);
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
leal -0x1(%rcx), %eax
cmpl %edx, %eax
setne %r10b
testl %r8d, %r8d
sets %r11b
cmpl %r9d, %r8d
setge %bl
orb %r11b, %bl
orb %r10b, %bl
movl %r8d, %r10d
jne 0x41b0a0
extractps $0x3, %xmm0, (%rdi,%r10,4)
cmpl %ecx, %edx
jge 0x41b0bc
testl %edx, %edx
js 0x41b0bc
leal -0x1(%r9), %r11d
cmpl %r8d, %r11d
jne 0x41b0bc
movl %edx, %r11d
extractps $0x3, %xmm0, (%rsi,%r11,4)
leal 0x1(%rdx), %r11d
cmpl %eax, %r11d
setne %bl
testl %r8d, %r8d
setle %bpl
cmpl %r9d, %r8d
setg %r14b
orb %bpl, %r14b
orb %bl, %r14b
jne 0x41b0e5
extractps $0x2, %xmm0, -0x4(%rdi,%r10,4)
cmpl %ecx, %r11d
jge 0x41b0ff
cmpl $-0x1, %edx
jl 0x41b0ff
cmpl %r9d, %r8d
jne 0x41b0ff
movl %r11d, %r10d
extractps $0x2, %xmm0, (%rsi,%r10,4)
leal 0x2(%rdx), %r10d
cmpl %eax, %r10d
jne 0x41b12e
leal -0x2(%r8), %r11d
cmpl $0x2, %r8d
setge %bl
cmpl %r9d, %r11d
setl %bpl
andb %bl, %bpl
cmpb $0x1, %bpl
jne 0x41b12e
movl %r11d, %r11d
extractps $0x1, %xmm0, (%rdi,%r11,4)
cmpl %ecx, %r10d
jge 0x41b14c
cmpl $-0x2, %edx
jl 0x41b14c
leal -0x1(%r8), %r11d
cmpl %r9d, %r11d
jne 0x41b14c
movl %r10d, %r10d
extractps $0x1, %xmm0, (%rsi,%r10,4)
leal 0x3(%rdx), %r10d
cmpl %eax, %r10d
jne 0x41b176
leal -0x3(%r8), %eax
cmpl $0x3, %r8d
setge %r11b
cmpl %r9d, %eax
setl %bl
andb %r11b, %bl
cmpb $0x1, %bl
jne 0x41b176
movl %eax, %eax
movss %xmm0, (%rdi,%rax,4)
cmpl %ecx, %r10d
jge 0x41b191
cmpl $-0x3, %edx
jl 0x41b191
addl $-0x2, %r8d
cmpl %r9d, %r8d
jne 0x41b191
movl %r10d, %eax
movss %xmm0, (%rsi,%rax,4)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/memory_avx2.c
// Function: parasail_profile_create_avx_256_sat
parasail_profile_t* parasail_profile_create_avx_256_sat(
        const char * const restrict s1, const int s1Len,
        const parasail_matrix_t *matrix)
{
    parasail_profile_t *profile8 = parasail_profile_create_avx_256_8(s1, s1Len, matrix);
    parasail_profile_t *profile16 = parasail_profile_create_avx_256_16(s1, s1Len, matrix);
    parasail_profile_t *profile32 = parasail_profile_create_avx_256_32(s1, s1Len, matrix);
    profile8->profile16 = profile16->profile16;
    profile8->profile32 = profile32->profile32;
    free(profile16);
    free(profile32);

    return profile8;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
callq 0x496ac1
movq %rax, %rbx
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x496cfd
movq %rax, %r12
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x496f36
vmovups 0x30(%r12), %xmm0
vmovups %xmm0, 0x30(%rbx)
movq %rax, %r14
movq 0x40(%r12), %rax
movq %rax, 0x40(%rbx)
vmovups 0x48(%r14), %xmm0
vmovups %xmm0, 0x48(%rbx)
movq 0x58(%r14), %rax
movq %rax, 0x58(%rbx)
movq %r12, %rdi
callq 0x19e120
movq %r14, %rdi
callq 0x19e120
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/memory_avx2.c
// Function: parasail_profile_create_stats_avx_256_sat
parasail_profile_t* parasail_profile_create_stats_avx_256_sat(
        const char * const restrict s1, const int s1Len,
        const parasail_matrix_t *matrix)
{
    parasail_profile_t *profile8 = parasail_profile_create_stats_avx_256_8(s1, s1Len, matrix);
    parasail_profile_t *profile16 = parasail_profile_create_stats_avx_256_16(s1, s1Len, matrix);
    parasail_profile_t *profile32 = parasail_profile_create_stats_avx_256_32(s1, s1Len, matrix);
    profile8->profile16 = profile16->profile16;
    profile8->profile32 = profile32->profile32;
    free(profile16);
    free(profile32);

    return profile8;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
callq 0x497420
movq %rax, %rbx
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x4976fd
movq %rax, %r12
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x4979e7
vmovups 0x30(%r12), %xmm0
vmovups %xmm0, 0x30(%rbx)
movq %rax, %r14
movq 0x40(%r12), %rax
movq %rax, 0x40(%rbx)
vmovups 0x48(%r14), %xmm0
vmovups %xmm0, 0x48(%rbx)
movq 0x58(%r14), %rax
movq %rax, 0x58(%rbx)
movq %r12, %rdi
callq 0x19e120
movq %r14, %rdi
callq 0x19e120
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_striped_avx2_256_64.c
// Function: arr_store_si256
static inline void arr_store_si256(
        int *array,
        __m256i vH,
        int32_t t,
        int32_t seglen,
        int32_t d,
        int32_t dlen)
{
    array[1LL*(0*seglen+t)*dlen + d] = (int64_t)_mm256_extract_epi64_rpl(vH, 0);
    array[1LL*(1*seglen+t)*dlen + d] = (int64_t)_mm256_extract_epi64_rpl(vH, 1);
    array[1LL*(2*seglen+t)*dlen + d] = (int64_t)_mm256_extract_epi64_rpl(vH, 2);
    array[1LL*(3*seglen+t)*dlen + d] = (int64_t)_mm256_extract_epi64_rpl(vH, 3);
}

// Assembly:
movslq %esi, %rax
movl %r8d, %esi
leal (%rdx,%rax), %r8d
movslq %r8d, %r8
imulq %rsi, %r8
leal (%rax,%rdx,2), %r9d
movslq %r9d, %r9
imulq %rsi, %r9
leal (%rdx,%rdx,2), %edx
addl %eax, %edx
movslq %edx, %rdx
imulq %rsi, %rdx
imulq %rax, %rsi
movslq %ecx, %rax
leaq (%rdi,%rsi,4), %rcx
vmovss %xmm0, (%rcx,%rax,4)
leaq (%rdi,%r8,4), %rcx
vextractps $0x2, %xmm0, (%rcx,%rax,4)
vextractf128 $0x1, %ymm0, %xmm0
leaq (%rdi,%r9,4), %rcx
vmovss %xmm0, (%rcx,%rax,4)
leaq (%rdi,%rdx,4), %rcx
vextractps $0x2, %xmm0, (%rcx,%rax,4)
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_striped_avx2_256_32.c
// Function: arr_store_si256
static inline void arr_store_si256(
        int *array,
        __m256i vH,
        int32_t t,
        int32_t seglen,
        int32_t d,
        int32_t dlen)
{
    array[1LL*(0*seglen+t)*dlen + d] = (int32_t)_mm256_extract_epi32_rpl(vH, 0);
    array[1LL*(1*seglen+t)*dlen + d] = (int32_t)_mm256_extract_epi32_rpl(vH, 1);
    array[1LL*(2*seglen+t)*dlen + d] = (int32_t)_mm256_extract_epi32_rpl(vH, 2);
    array[1LL*(3*seglen+t)*dlen + d] = (int32_t)_mm256_extract_epi32_rpl(vH, 3);
    array[1LL*(4*seglen+t)*dlen + d] = (int32_t)_mm256_extract_epi32_rpl(vH, 4);
    array[1LL*(5*seglen+t)*dlen + d] = (int32_t)_mm256_extract_epi32_rpl(vH, 5);
    array[1LL*(6*seglen+t)*dlen + d] = (int32_t)_mm256_extract_epi32_rpl(vH, 6);
    array[1LL*(7*seglen+t)*dlen + d] = (int32_t)_mm256_extract_epi32_rpl(vH, 7);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movslq %esi, %rax
movl %r8d, %esi
leal (%rdx,%rax), %r8d
movslq %r8d, %r8
imulq %rsi, %r8
leal (%rax,%rdx,2), %r9d
movslq %r9d, %r9
imulq %rsi, %r9
leal (%rdx,%rdx,2), %r10d
addl %eax, %r10d
movslq %r10d, %r10
imulq %rsi, %r10
leal (%rax,%rdx,4), %r11d
movslq %r11d, %r11
imulq %rsi, %r11
leal (%rdx,%rdx,4), %ebx
addl %eax, %ebx
movslq %ebx, %rbx
imulq %rsi, %rbx
imull $0x6, %edx, %ebp
addl %eax, %ebp
movslq %ebp, %r14
imulq %rsi, %r14
imull $0x7, %edx, %edx
addl %eax, %edx
movslq %edx, %rdx
imulq %rsi, %rdx
imulq %rax, %rsi
movslq %ecx, %rax
leaq (%rdi,%rsi,4), %rcx
vmovss %xmm0, (%rcx,%rax,4)
leaq (%rdi,%r8,4), %rcx
vextractps $0x1, %xmm0, (%rcx,%rax,4)
leaq (%rdi,%r9,4), %rcx
vextractps $0x2, %xmm0, (%rcx,%rax,4)
leaq (%rdi,%r10,4), %rcx
vextractps $0x3, %xmm0, (%rcx,%rax,4)
vextractf128 $0x1, %ymm0, %xmm0
leaq (%rdi,%r11,4), %rcx
vmovss %xmm0, (%rcx,%rax,4)
leaq (%rdi,%rbx,4), %rcx
vextractps $0x1, %xmm0, (%rcx,%rax,4)
leaq (%rdi,%r14,4), %rcx
vextractps $0x2, %xmm0, (%rcx,%rax,4)
leaq (%rdi,%rdx,4), %rcx
vextractps $0x3, %xmm0, (%rcx,%rax,4)
popq %rbx
popq %r14
popq %rbp
vzeroupper
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_stats_diag_avx2_256_64.c
// Function: arr_store_si256
static inline void arr_store_si256(
        int *array,
        __m256i vWH,
        int32_t i,
        int32_t s1Len,
        int32_t j,
        int32_t s2Len)
{
    if (0 <= i+0 && i+0 < s1Len && 0 <= j-0 && j-0 < s2Len) {
        array[1LL*(i+0)*s2Len + (j-0)] = (int64_t)_mm256_extract_epi64_rpl(vWH, 3);
    }
    if (0 <= i+1 && i+1 < s1Len && 0 <= j-1 && j-1 < s2Len) {
        array[1LL*(i+1)*s2Len + (j-1)] = (int64_t)_mm256_extract_epi64_rpl(vWH, 2);
    }
    if (0 <= i+2 && i+2 < s1Len && 0 <= j-2 && j-2 < s2Len) {
        array[1LL*(i+2)*s2Len + (j-2)] = (int64_t)_mm256_extract_epi64_rpl(vWH, 1);
    }
    if (0 <= i+3 && i+3 < s1Len && 0 <= j-3 && j-3 < s2Len) {
        array[1LL*(i+3)*s2Len + (j-3)] = (int64_t)_mm256_extract_epi64_rpl(vWH, 0);
    }
}

// Assembly:
vextractf128 $0x1, %ymm0, %xmm1
movl %r8d, %eax
movl %ecx, %r9d
cmpl %r8d, %ecx
jge 0x4cae19
cmpl %edx, %esi
jge 0x4cae19
movl %ecx, %r10d
orl %esi, %r10d
js 0x4cae19
movl %esi, %r10d
imulq %rax, %r10
leaq (%rdi,%r10,4), %r10
vextractps $0x2, %xmm1, (%r10,%r9,4)
pushq %rbp
pushq %rbx
leal 0x1(%rsi), %r10d
cmpl $-0x1, %esi
setl %r11b
cmpl %edx, %r10d
setge %bl
testl %ecx, %ecx
setle %bpl
orb %r11b, %bpl
orb %bl, %bpl
cmpl %r8d, %ecx
setg %r11b
orb %bpl, %r11b
jne 0x4cae56
movl %r10d, %r10d
imulq %rax, %r10
leaq (%rdi,%r10,4), %r10
vmovss %xmm1, -0x4(%r10,%r9,4)
leal 0x2(%rsi), %r9d
cmpl $-0x2, %esi
setge %r10b
cmpl %edx, %r9d
setl %r11b
andb %r10b, %r11b
cmpb $0x1, %r11b
jne 0x4cae9f
leal -0x2(%rcx), %r10d
cmpl $0x2, %ecx
setge %r11b
cmpl %r8d, %r10d
setl %bl
andb %r11b, %bl
cmpb $0x1, %bl
jne 0x4cae9f
movl %r9d, %r9d
imulq %rax, %r9
movl %r10d, %r10d
leaq (%rdi,%r9,4), %r9
vextractps $0x2, %xmm0, (%r9,%r10,4)
leal 0x3(%rsi), %r9d
cmpl $-0x3, %esi
setge %sil
cmpl %edx, %r9d
setl %dl
andb %sil, %dl
cmpb $0x1, %dl
popq %rbx
popq %rbp
jne 0x4caee5
leal -0x3(%rcx), %edx
cmpl $0x3, %ecx
setge %cl
cmpl %r8d, %edx
setl %sil
andb %cl, %sil
cmpb $0x1, %sil
jne 0x4caee5
movl %r9d, %ecx
imulq %rcx, %rax
movl %edx, %ecx
leaq (%rdi,%rax,4), %rax
vmovss %xmm0, (%rax,%rcx,4)
vzeroupper
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_stats_scan_avx2_256_64.c
// Function: arr_store_col
static inline void arr_store_col(
        int *col,
        __m256i vH,
        int32_t t,
        int32_t seglen)
{
    col[0*seglen+t] = (int64_t)_mm256_extract_epi64_rpl(vH, 0);
    col[1*seglen+t] = (int64_t)_mm256_extract_epi64_rpl(vH, 1);
    col[2*seglen+t] = (int64_t)_mm256_extract_epi64_rpl(vH, 2);
    col[3*seglen+t] = (int64_t)_mm256_extract_epi64_rpl(vH, 3);
}

// Assembly:
movslq %esi, %rax
vmovss %xmm0, (%rdi,%rax,4)
leal (%rdx,%rax), %ecx
movslq %ecx, %rcx
vextractps $0x2, %xmm0, (%rdi,%rcx,4)
vextractf128 $0x1, %ymm0, %xmm0
leal (%rax,%rdx,2), %ecx
movslq %ecx, %rcx
vmovss %xmm0, (%rdi,%rcx,4)
leal (%rdx,%rdx,2), %ecx
addl %eax, %ecx
movslq %ecx, %rax
vextractps $0x2, %xmm0, (%rdi,%rax,4)
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_stats_scan_avx2_256_32.c
// Function: arr_store_col
static inline void arr_store_col(
        int *col,
        __m256i vH,
        int32_t t,
        int32_t seglen)
{
    col[0*seglen+t] = (int32_t)_mm256_extract_epi32_rpl(vH, 0);
    col[1*seglen+t] = (int32_t)_mm256_extract_epi32_rpl(vH, 1);
    col[2*seglen+t] = (int32_t)_mm256_extract_epi32_rpl(vH, 2);
    col[3*seglen+t] = (int32_t)_mm256_extract_epi32_rpl(vH, 3);
    col[4*seglen+t] = (int32_t)_mm256_extract_epi32_rpl(vH, 4);
    col[5*seglen+t] = (int32_t)_mm256_extract_epi32_rpl(vH, 5);
    col[6*seglen+t] = (int32_t)_mm256_extract_epi32_rpl(vH, 6);
    col[7*seglen+t] = (int32_t)_mm256_extract_epi32_rpl(vH, 7);
}

// Assembly:
movslq %esi, %rax
vmovss %xmm0, (%rdi,%rax,4)
leal (%rdx,%rax), %ecx
movslq %ecx, %rcx
vextractps $0x1, %xmm0, (%rdi,%rcx,4)
leal (%rax,%rdx,2), %ecx
movslq %ecx, %rcx
vextractps $0x2, %xmm0, (%rdi,%rcx,4)
leal (%rdx,%rdx,2), %ecx
addl %eax, %ecx
movslq %ecx, %rcx
vextractps $0x3, %xmm0, (%rdi,%rcx,4)
vextractf128 $0x1, %ymm0, %xmm0
leal (%rax,%rdx,4), %ecx
movslq %ecx, %rcx
vmovss %xmm0, (%rdi,%rcx,4)
leal (%rdx,%rdx,4), %ecx
addl %eax, %ecx
movslq %ecx, %rcx
vextractps $0x1, %xmm0, (%rdi,%rcx,4)
imull $0x6, %edx, %ecx
addl %eax, %ecx
movslq %ecx, %rcx
vextractps $0x2, %xmm0, (%rdi,%rcx,4)
imull $0x7, %edx, %ecx
addl %eax, %ecx
movslq %ecx, %rax
vextractps $0x3, %xmm0, (%rdi,%rax,4)
vzeroupper
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/nw_stats_diag_avx2_256_64.c
// Function: arr_store_rowcol
static inline void arr_store_rowcol(
        int *row,
        int *col,
        __m256i vWH,
        int32_t i,
        int32_t s1Len,
        int32_t j,
        int32_t s2Len)
{
    if (i+0 == s1Len-1 && 0 <= j-0 && j-0 < s2Len) {
        row[j-0] = (int64_t)_mm256_extract_epi64_rpl(vWH, 3);
    }
    if (j-0 == s2Len-1 && 0 <= i+0 && i+0 < s1Len) {
        col[(i+0)] = (int64_t)_mm256_extract_epi64_rpl(vWH, 3);
    }
    if (i+1 == s1Len-1 && 0 <= j-1 && j-1 < s2Len) {
        row[j-1] = (int64_t)_mm256_extract_epi64_rpl(vWH, 2);
    }
    if (j-1 == s2Len-1 && 0 <= i+1 && i+1 < s1Len) {
        col[(i+1)] = (int64_t)_mm256_extract_epi64_rpl(vWH, 2);
    }
    if (i+2 == s1Len-1 && 0 <= j-2 && j-2 < s2Len) {
        row[j-2] = (int64_t)_mm256_extract_epi64_rpl(vWH, 1);
    }
    if (j-2 == s2Len-1 && 0 <= i+2 && i+2 < s1Len) {
        col[(i+2)] = (int64_t)_mm256_extract_epi64_rpl(vWH, 1);
    }
    if (i+3 == s1Len-1 && 0 <= j-3 && j-3 < s2Len) {
        row[j-3] = (int64_t)_mm256_extract_epi64_rpl(vWH, 0);
    }
    if (j-3 == s2Len-1 && 0 <= i+3 && i+3 < s1Len) {
        col[(i+3)] = (int64_t)_mm256_extract_epi64_rpl(vWH, 0);
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
leal -0x1(%rcx), %eax
cmpl %edx, %eax
setne %r10b
testl %r8d, %r8d
sets %r11b
cmpl %r9d, %r8d
setge %bl
orb %r11b, %bl
orb %r10b, %bl
vextractf128 $0x1, %ymm0, %xmm1
movl %r8d, %r10d
jne 0x521eb4
vextractps $0x2, %xmm1, (%rdi,%r10,4)
cmpl %ecx, %edx
jge 0x521ecf
testl %edx, %edx
js 0x521ecf
leal -0x1(%r9), %r11d
cmpl %r8d, %r11d
jne 0x521ecf
movl %edx, %r11d
vextractps $0x2, %xmm1, (%rsi,%r11,4)
leal 0x1(%rdx), %r11d
cmpl %eax, %r11d
setne %bl
testl %r8d, %r8d
setle %bpl
cmpl %r9d, %r8d
setg %r14b
orb %bpl, %r14b
orb %bl, %r14b
jne 0x521ef6
vmovss %xmm1, -0x4(%rdi,%r10,4)
cmpl %ecx, %r11d
jge 0x521f0e
cmpl $-0x1, %edx
jl 0x521f0e
cmpl %r9d, %r8d
jne 0x521f0e
movl %r11d, %r10d
vmovss %xmm1, (%rsi,%r10,4)
leal 0x2(%rdx), %r10d
cmpl %eax, %r10d
jne 0x521f3c
leal -0x2(%r8), %r11d
cmpl $0x2, %r8d
setge %bl
cmpl %r9d, %r11d
setl %bpl
andb %bl, %bpl
cmpb $0x1, %bpl
jne 0x521f3c
movl %r11d, %r11d
vextractps $0x2, %xmm0, (%rdi,%r11,4)
cmpl %ecx, %r10d
jge 0x521f59
cmpl $-0x2, %edx
jl 0x521f59
leal -0x1(%r8), %r11d
cmpl %r9d, %r11d
jne 0x521f59
movl %r10d, %r10d
vextractps $0x2, %xmm0, (%rsi,%r10,4)
leal 0x3(%rdx), %r10d
cmpl %eax, %r10d
jne 0x521f83
leal -0x3(%r8), %eax
cmpl $0x3, %r8d
setge %r11b
cmpl %r9d, %eax
setl %bl
andb %r11b, %bl
cmpb $0x1, %bl
jne 0x521f83
movl %eax, %eax
vmovss %xmm0, (%rdi,%rax,4)
cmpl %ecx, %r10d
jge 0x521f9e
cmpl $-0x3, %edx
jl 0x521f9e
addl $-0x2, %r8d
cmpl %r9d, %r8d
jne 0x521f9e
movl %r10d, %eax
vmovss %xmm0, (%rsi,%rax,4)
popq %rbx
popq %r14
popq %rbp
vzeroupper
retq
nop
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/cpuid.c
// Function: parasail_can_use_avx512vbmi
int parasail_can_use_avx512vbmi()
{
    static int avx512vbmi_features_available = -1;
    /* test is performed once */
    if (avx512vbmi_features_available < 0 )
        avx512vbmi_features_available = has_intel_avx512vbmi_features();
    return avx512vbmi_features_available;
}

// Assembly:
movl 0x1d795e(%rip), %esi    # 0x73eb50
testl %esi, %esi
jns 0x567230
pushq %rbx
movl $0x1, %eax
xorl %ebx, %ebx
xorl %ecx, %ecx
cpuid
xorl %esi, %esi
btl $0x1b, %ecx
jae 0x567229
xorl %esi, %esi
xorl %ecx, %ecx
xgetbv
notl %eax
testb $-0x1a, %al
jne 0x567229
movl $0x7, %eax
xorl %ebx, %ebx
xorl %ecx, %ecx
cpuid
movl %ecx, %esi
shrl %esi
andl $0x1, %esi
movl %esi, 0x1d7921(%rip)    # 0x73eb50
popq %rbx
movl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/cpuid.c
// Function: parasail_can_use_avx512bw
int parasail_can_use_avx512bw()
{
    static int avx512bw_features_available = -1;
    /* test is performed once */
    if (avx512bw_features_available < 0 )
        avx512bw_features_available = has_intel_avx512bw_features();
    return avx512bw_features_available;
}

// Assembly:
movl 0x1d791b(%rip), %esi    # 0x73eb54
testl %esi, %esi
jns 0x56727e
pushq %rbx
movl $0x1, %eax
xorl %ebx, %ebx
xorl %ecx, %ecx
cpuid
xorl %esi, %esi
btl $0x1b, %ecx
jae 0x567277
xorl %esi, %esi
xorl %ecx, %ecx
xgetbv
notl %eax
testb $-0x1a, %al
jne 0x567277
movl $0x7, %eax
xorl %ebx, %ebx
xorl %ecx, %ecx
cpuid
notl %ebx
xorl %esi, %esi
testl $0xc0020000, %ebx       # imm = 0xC0020000
sete %sil
movl %esi, 0x1d78d7(%rip)    # 0x73eb54
popq %rbx
movl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/cpuid.c
// Function: parasail_can_use_avx512f
int parasail_can_use_avx512f()
{
    static int avx512f_features_available = -1;
    /* test is performed once */
    if (avx512f_features_available < 0 )
        avx512f_features_available = has_intel_avx512f_features();
    return avx512f_features_available;
}

// Assembly:
movl 0x1d78d1(%rip), %esi    # 0x73eb58
testl %esi, %esi
jns 0x5672cc
pushq %rbx
movl $0x1, %eax
xorl %ebx, %ebx
xorl %ecx, %ecx
cpuid
xorl %esi, %esi
btl $0x1b, %ecx
jae 0x5672c5
xorl %esi, %esi
xorl %ecx, %ecx
xgetbv
notl %eax
testb $-0x1a, %al
jne 0x5672c5
movl $0x7, %eax
xorl %ebx, %ebx
xorl %ecx, %ecx
cpuid
notl %ebx
xorl %esi, %esi
testl $0x1c010000, %ebx       # imm = 0x1C010000
sete %sil
movl %esi, 0x1d788d(%rip)    # 0x73eb58
popq %rbx
movl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/cpuid.c
// Function: parasail_can_use_avx2
int parasail_can_use_avx2()
{
    static int the_4th_gen_features_available = -1;
    /* test is performed once */
    if (the_4th_gen_features_available < 0 )
        the_4th_gen_features_available = check_4th_gen_intel_core_features();

    return the_4th_gen_features_available;
}

// Assembly:
movl 0x1d7887(%rip), %eax    # 0x73eb5c
testl %eax, %eax
js 0x5672da
retq
pushq %rbx
movl $0x7, %eax
xorl %ebx, %ebx
xorl %ecx, %ecx
cpuid
movl %ebx, %eax
shrl $0x5, %eax
andl $0x1, %eax
movl %eax, 0x1d7868(%rip)    # 0x73eb5c
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/cpuid.c
// Function: parasail_can_use_sse41
int parasail_can_use_sse41()
{
    static int can_use_sse41 = -1;
    /* test is performed once */
    if (can_use_sse41 < 0)
        can_use_sse41 = check_sse41();

    return can_use_sse41;
}

// Assembly:
movl 0x1d7864(%rip), %esi    # 0x73eb60
testl %esi, %esi
jns 0x567329
pushq %rbx
xorl %esi, %esi
xorl %ebx, %ebx
xorl %eax, %eax
xorl %ecx, %ecx
cpuid
testl %eax, %eax
je 0x567322
movl $0x1, %eax
xorl %ebx, %ebx
xorl %ecx, %ecx
cpuid
movl %ecx, %esi
shrl $0x13, %esi
andl $0x1, %esi
movl %esi, 0x1d7838(%rip)    # 0x73eb60
popq %rbx
movl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/cpuid.c
// Function: parasail_can_use_sse2
int parasail_can_use_sse2()
{
    static int can_use_sse2 = -1;
    /* test is performed once */
    if (can_use_sse2 < 0)
        can_use_sse2 = check_sse2();

    return can_use_sse2;
}

// Assembly:
movl 0x1d7832(%rip), %esi    # 0x73eb64
testl %esi, %esi
jns 0x56735f
pushq %rbx
xorl %esi, %esi
xorl %ebx, %ebx
xorl %eax, %eax
xorl %ecx, %ecx
cpuid
testl %eax, %eax
je 0x567358
movl $0x1, %eax
xorl %ebx, %ebx
xorl %ecx, %ecx
cpuid
movl %edx, %esi
shrl $0x1a, %esi
andl $0x1, %esi
movl %esi, 0x1d7806(%rip)    # 0x73eb64
popq %rbx
movl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.2/thread-create2.c
// Function: char_print
void* char_print (void* parameters)
{
/* Cast the cookie pointer to the right type. */
	struct char_print_parms* p = (struct char_print_parms*) parameters;
	int i;
	for (i = 0; i < p->count; ++i)
    fputc (p->character, stderr);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x2e95(%rip), %r15      # 0x3ff8
cmpl 0x4(%rbx), %r14d
jge 0x1179
movsbl (%rbx), %edi
movq (%r15), %rsi
callq 0x1030
incl %r14d
jmp 0x1163
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq