LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_scan_sse41_128_8.c
// Function: mm_hmax_epi8_rpl
static inline int8_t _mm_hmax_epi8_rpl(__m128i a) {
    a = _mm_max_epi8(a, _mm_srli_si128(a, 8));
    a = _mm_max_epi8(a, _mm_srli_si128(a, 4));
    a = _mm_max_epi8(a, _mm_srli_si128(a, 2));
    a = _mm_max_epi8(a, _mm_srli_si128(a, 1));
    return _mm_extract_epi8(a, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movaps %xmm0, -0x90(%rbp)
movaps -0x90(%rbp), %xmm1
movaps %xmm1, %xmm0
psrldq $0x8, %xmm0             # xmm0 = xmm0[8,9,10,11,12,13,14,15],zero,zero,zero,zero,zero,zero,zero,zero
movaps %xmm1, -0x10(%rbp)
movaps %xmm0, -0x20(%rbp)
movaps -0x10(%rbp), %xmm0
movaps -0x20(%rbp), %xmm1
pmaxsb %xmm1, %xmm0
movaps %xmm0, -0x90(%rbp)
movaps -0x90(%rbp), %xmm1
movaps %xmm1, %xmm0
psrldq $0x4, %xmm0             # xmm0 = xmm0[4,5,6,7,8,9,10,11,12,13,14,15],zero,zero,zero,zero
movaps %xmm1, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
movaps -0x30(%rbp), %xmm0
movaps -0x40(%rbp), %xmm1
pmaxsb %xmm1, %xmm0
movaps %xmm0, -0x90(%rbp)
movaps -0x90(%rbp), %xmm1
movaps %xmm1, %xmm0
psrldq $0x2, %xmm0             # xmm0 = xmm0[2,3,4,5,6,7,8,9,10,11,12,13,14,15],zero,zero
movaps %xmm1, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
movaps -0x50(%rbp), %xmm0
movaps -0x60(%rbp), %xmm1
pmaxsb %xmm1, %xmm0
movaps %xmm0, -0x90(%rbp)
movaps -0x90(%rbp), %xmm1
movaps %xmm1, %xmm0
psrldq $0x1, %xmm0             # xmm0 = xmm0[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],zero
movaps %xmm1, -0x70(%rbp)
movaps %xmm0, -0x80(%rbp)
movaps -0x70(%rbp), %xmm0
movaps -0x80(%rbp), %xmm1
pmaxsb %xmm1, %xmm0
movaps %xmm0, -0x90(%rbp)
movb -0x90(%rbp), %al
movzbl %al, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_scan_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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movaps %xmm0, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movl %edx, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
movl %r8d, -0x30(%rbp)
movl -0x20(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movslq -0x30(%rbp), %rsi
imulq %rsi, %rcx
movslq -0x2c(%rbp), %rsi
addq %rsi, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
movl -0x24(%rbp), %esi
addl %esi, %ecx
movslq %ecx, %rcx
movslq -0x30(%rbp), %rsi
imulq %rsi, %rcx
movslq -0x2c(%rbp), %rsi
addq %rsi, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
movl -0x24(%rbp), %edi
movl %ecx, %esi
movl %edi, %ecx
leal (%rcx,%rsi,2), %ecx
movslq %ecx, %rcx
movslq -0x30(%rbp), %rsi
imulq %rsi, %rcx
movslq -0x2c(%rbp), %rsi
addq %rsi, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
imull $0x3, -0x28(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
shlq $0x0, %rcx
movslq -0x30(%rbp), %rsi
imulq %rsi, %rcx
movslq -0x2c(%rbp), %rsi
addq %rsi, %rcx
movl %edx, (%rax,%rcx,4)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_blocked_sse41_128_32.c
// Function: arr_store_si128
static inline void arr_store_si128(
        int *array,
        __m128i vH,
        int32_t i,
        int32_t segWidth,
        int32_t j,
        int32_t s2Len)
{
    array[(i*segWidth+0)*s2Len + j] = (int32_t)_mm_extract_epi32(vH, 0);
    array[(i*segWidth+1)*s2Len + j] = (int32_t)_mm_extract_epi32(vH, 1);
    array[(i*segWidth+2)*s2Len + j] = (int32_t)_mm_extract_epi32(vH, 2);
    array[(i*segWidth+3)*s2Len + j] = (int32_t)_mm_extract_epi32(vH, 3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movaps %xmm0, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movl %edx, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
movl %r8d, -0x30(%rbp)
movl -0x20(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %esi
imull %esi, %ecx
movl -0x30(%rbp), %esi
imull %esi, %ecx
movl -0x2c(%rbp), %esi
addl %esi, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %esi
imull %esi, %ecx
incl %ecx
movl -0x30(%rbp), %esi
imull %esi, %ecx
movl -0x2c(%rbp), %esi
addl %esi, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %esi
imull %esi, %ecx
addl $0x2, %ecx
movl -0x30(%rbp), %esi
imull %esi, %ecx
movl -0x2c(%rbp), %esi
addl %esi, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
imull -0x28(%rbp), %ecx
addl $0x3, %ecx
imull -0x30(%rbp), %ecx
addl -0x2c(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movaps %xmm0, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movl %edx, -0x28(%rbp)
movl -0x20(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
movl -0x24(%rbp), %esi
addl %esi, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
movl -0x24(%rbp), %edi
movl %ecx, %esi
movl %edi, %ecx
leal (%rcx,%rsi,2), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
imull $0x3, -0x28(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_blocked_sse41_128_32.c
// Function: arr_store_col
static inline void arr_store_col(
        int *col,
        __m128i vH,
        int32_t i,
        int32_t segWidth)
{
    col[i*segWidth+0] = (int16_t)_mm_extract_epi16(vH, 0);
    col[i*segWidth+1] = (int16_t)_mm_extract_epi16(vH, 1);
    col[i*segWidth+2] = (int16_t)_mm_extract_epi16(vH, 2);
    col[i*segWidth+3] = (int16_t)_mm_extract_epi16(vH, 3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movaps %xmm0, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movl %edx, -0x28(%rbp)
movswl -0x20(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %esi
imull %esi, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movaps -0x20(%rbp), %xmm0
pextrw $0x1, %xmm0, %eax
movswl %ax, %edx
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %esi
imull %esi, %ecx
movslq %ecx, %rcx
movl %edx, 0x4(%rax,%rcx,4)
movaps -0x20(%rbp), %xmm0
pextrw $0x2, %xmm0, %eax
movswl %ax, %edx
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %esi
imull %esi, %ecx
movslq %ecx, %rcx
movl %edx, 0x8(%rax,%rcx,4)
movaps -0x20(%rbp), %xmm0
pextrw $0x3, %xmm0, %eax
movzwl %ax, %eax
movswl %ax, %edx
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
imull -0x28(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_blocked_sse41_128_16.c
// Function: arr_store_col
static inline void arr_store_col(
        int *col,
        __m128i vH,
        int32_t i,
        int32_t segWidth)
{
    col[i*segWidth+0] = (int16_t)_mm_extract_epi16(vH, 0);
    col[i*segWidth+1] = (int16_t)_mm_extract_epi16(vH, 1);
    col[i*segWidth+2] = (int16_t)_mm_extract_epi16(vH, 2);
    col[i*segWidth+3] = (int16_t)_mm_extract_epi16(vH, 3);
    col[i*segWidth+4] = (int16_t)_mm_extract_epi16(vH, 4);
    col[i*segWidth+5] = (int16_t)_mm_extract_epi16(vH, 5);
    col[i*segWidth+6] = (int16_t)_mm_extract_epi16(vH, 6);
    col[i*segWidth+7] = (int16_t)_mm_extract_epi16(vH, 7);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movaps %xmm0, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movl %edx, -0x28(%rbp)
movswl -0x20(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %esi
imull %esi, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movaps -0x20(%rbp), %xmm0
pextrw $0x1, %xmm0, %eax
movswl %ax, %edx
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %esi
imull %esi, %ecx
movslq %ecx, %rcx
movl %edx, 0x4(%rax,%rcx,4)
movaps -0x20(%rbp), %xmm0
pextrw $0x2, %xmm0, %eax
movswl %ax, %edx
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %esi
imull %esi, %ecx
movslq %ecx, %rcx
movl %edx, 0x8(%rax,%rcx,4)
movaps -0x20(%rbp), %xmm0
pextrw $0x3, %xmm0, %eax
movswl %ax, %edx
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %esi
imull %esi, %ecx
movslq %ecx, %rcx
movl %edx, 0xc(%rax,%rcx,4)
movaps -0x20(%rbp), %xmm0
pextrw $0x4, %xmm0, %eax
movswl %ax, %edx
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %esi
imull %esi, %ecx
movslq %ecx, %rcx
movl %edx, 0x10(%rax,%rcx,4)
movaps -0x20(%rbp), %xmm0
pextrw $0x5, %xmm0, %eax
movswl %ax, %edx
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %esi
imull %esi, %ecx
movslq %ecx, %rcx
movl %edx, 0x14(%rax,%rcx,4)
movaps -0x20(%rbp), %xmm0
pextrw $0x6, %xmm0, %eax
movswl %ax, %edx
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %esi
imull %esi, %ecx
movslq %ecx, %rcx
movl %edx, 0x18(%rax,%rcx,4)
movaps -0x20(%rbp), %xmm0
pextrw $0x7, %xmm0, %eax
movzwl %ax, %eax
movswl %ax, %edx
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
imull -0x28(%rbp), %ecx
addl $0x7, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_scan_avx2_256_64.c
// Function: mm256_max_epi64_rpl
static inline __m256i _mm256_max_epi64_rpl(__m256i a, __m256i b) {
    __m256i_64_t A;
    __m256i_64_t B;
    A.m = a;
    B.m = b;
    A.v[0] = (A.v[0]>B.v[0]) ? A.v[0] : B.v[0];
    A.v[1] = (A.v[1]>B.v[1]) ? A.v[1] : B.v[1];
    A.v[2] = (A.v[2]>B.v[2]) ? A.v[2] : B.v[2];
    A.v[3] = (A.v[3]>B.v[3]) ? A.v[3] : B.v[3];
    return A.m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0xc0, %rsp
vmovdqa %ymm0, 0x80(%rsp)
vmovdqa %ymm1, 0x60(%rsp)
vmovdqa 0x80(%rsp), %ymm0
vmovdqa %ymm0, 0x40(%rsp)
vmovdqa 0x60(%rsp), %ymm0
vmovdqa %ymm0, 0x20(%rsp)
movq 0x40(%rsp), %rax
cmpq 0x20(%rsp), %rax
jle 0x880d41
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x880d4b
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rax
cmpq 0x28(%rsp), %rax
jle 0x880d6d
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x880d77
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rax
cmpq 0x30(%rsp), %rax
jle 0x880d99
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x880da3
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rax
cmpq 0x38(%rsp), %rax
jle 0x880dc4
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
jmp 0x880dcd
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x58(%rsp)
vmovdqa 0x40(%rsp), %ymm0
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_scan_avx2_256_64.c
// Function: mm256_min_epi64_rpl
static inline __m256i _mm256_min_epi64_rpl(__m256i a, __m256i b) {
    __m256i_64_t A;
    __m256i_64_t B;
    A.m = a;
    B.m = b;
    A.v[0] = (A.v[0]<B.v[0]) ? A.v[0] : B.v[0];
    A.v[1] = (A.v[1]<B.v[1]) ? A.v[1] : B.v[1];
    A.v[2] = (A.v[2]<B.v[2]) ? A.v[2] : B.v[2];
    A.v[3] = (A.v[3]<B.v[3]) ? A.v[3] : B.v[3];
    return A.m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0xc0, %rsp
vmovdqa %ymm0, 0x80(%rsp)
vmovdqa %ymm1, 0x60(%rsp)
vmovdqa 0x80(%rsp), %ymm0
vmovdqa %ymm0, 0x40(%rsp)
vmovdqa 0x60(%rsp), %ymm0
vmovdqa %ymm0, 0x20(%rsp)
movq 0x40(%rsp), %rax
cmpq 0x20(%rsp), %rax
jge 0x880e41
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x880e4b
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rax
cmpq 0x28(%rsp), %rax
jge 0x880e6d
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x880e77
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rax
cmpq 0x30(%rsp), %rax
jge 0x880e99
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x880ea3
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rax
cmpq 0x38(%rsp), %rax
jge 0x880ec4
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
jmp 0x880ecd
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x58(%rsp)
vmovdqa 0x40(%rsp), %ymm0
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_scan_avx2_256_32.c
// Function: mm256_hmax_epi32_rpl
static inline int32_t _mm256_hmax_epi32_rpl(__m256i a) {
    a = _mm256_max_epi32(a, _mm256_permute2x128_si256(a, a, _MM_SHUFFLE(0,0,0,0)));
    a = _mm256_max_epi32(a, _mm256_slli_si256(a, 8));
    a = _mm256_max_epi32(a, _mm256_slli_si256(a, 4));
    return _mm256_extract_epi32_rpl(a, 7);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x100, %rsp            # imm = 0x100
vmovaps %ymm0, (%rsp)
vmovaps (%rsp), %ymm1
vpermq $0x44, %ymm1, %ymm0     # ymm0 = ymm1[0,1,0,1]
vmovaps %ymm1, 0xc0(%rsp)
vmovaps %ymm0, 0xa0(%rsp)
vmovaps 0xc0(%rsp), %ymm0
vmovaps 0xa0(%rsp), %ymm1
vpmaxsd %ymm1, %ymm0, %ymm0
vmovaps %ymm0, (%rsp)
vmovaps (%rsp), %ymm1
vpslldq $0x8, %ymm1, %ymm0      # ymm0 = zero,zero,zero,zero,zero,zero,zero,zero,ymm1[0,1,2,3,4,5,6,7],zero,zero,zero,zero,zero,zero,zero,zero,ymm1[16,17,18,19,20,21,22,23]
vmovaps %ymm1, 0x80(%rsp)
vmovaps %ymm0, 0x60(%rsp)
vmovaps 0x80(%rsp), %ymm0
vmovaps 0x60(%rsp), %ymm1
vpmaxsd %ymm1, %ymm0, %ymm0
vmovaps %ymm0, (%rsp)
vmovaps (%rsp), %ymm1
vpslldq $0x4, %ymm1, %ymm0      # ymm0 = zero,zero,zero,zero,ymm1[0,1,2,3,4,5,6,7,8,9,10,11],zero,zero,zero,zero,ymm1[16,17,18,19,20,21,22,23,24,25,26,27]
vmovaps %ymm1, 0x40(%rsp)
vmovaps %ymm0, 0x20(%rsp)
vmovaps 0x40(%rsp), %ymm0
vmovaps 0x20(%rsp), %ymm1
vpmaxsd %ymm1, %ymm0, %ymm0
vmovaps %ymm0, (%rsp)
movl 0x1c(%rsp), %eax
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_scan_avx2_256_16.c
// Function: mm256_hmax_epi16_rpl
static inline int16_t _mm256_hmax_epi16_rpl(__m256i a) {
    a = _mm256_max_epi16(a, _mm256_permute2x128_si256(a, a, _MM_SHUFFLE(0,0,0,0)));
    a = _mm256_max_epi16(a, _mm256_slli_si256(a, 8));
    a = _mm256_max_epi16(a, _mm256_slli_si256(a, 4));
    a = _mm256_max_epi16(a, _mm256_slli_si256(a, 2));
    return _mm256_extract_epi16_rpl(a, 15);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x140, %rsp            # imm = 0x140
vmovaps %ymm0, (%rsp)
vmovaps (%rsp), %ymm1
vpermq $0x44, %ymm1, %ymm0     # ymm0 = ymm1[0,1,0,1]
vmovaps %ymm1, 0x100(%rsp)
vmovaps %ymm0, 0xe0(%rsp)
vmovaps 0x100(%rsp), %ymm0
vmovaps 0xe0(%rsp), %ymm1
vpmaxsw %ymm1, %ymm0, %ymm0
vmovaps %ymm0, (%rsp)
vmovaps (%rsp), %ymm1
vpslldq $0x8, %ymm1, %ymm0      # ymm0 = zero,zero,zero,zero,zero,zero,zero,zero,ymm1[0,1,2,3,4,5,6,7],zero,zero,zero,zero,zero,zero,zero,zero,ymm1[16,17,18,19,20,21,22,23]
vmovaps %ymm1, 0xc0(%rsp)
vmovaps %ymm0, 0xa0(%rsp)
vmovaps 0xc0(%rsp), %ymm0
vmovaps 0xa0(%rsp), %ymm1
vpmaxsw %ymm1, %ymm0, %ymm0
vmovaps %ymm0, (%rsp)
vmovaps (%rsp), %ymm1
vpslldq $0x4, %ymm1, %ymm0      # ymm0 = zero,zero,zero,zero,ymm1[0,1,2,3,4,5,6,7,8,9,10,11],zero,zero,zero,zero,ymm1[16,17,18,19,20,21,22,23,24,25,26,27]
vmovaps %ymm1, 0x80(%rsp)
vmovaps %ymm0, 0x60(%rsp)
vmovaps 0x80(%rsp), %ymm0
vmovaps 0x60(%rsp), %ymm1
vpmaxsw %ymm1, %ymm0, %ymm0
vmovaps %ymm0, (%rsp)
vmovaps (%rsp), %ymm1
vpslldq $0x2, %ymm1, %ymm0      # ymm0 = zero,zero,ymm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13],zero,zero,ymm1[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
vmovaps %ymm1, 0x40(%rsp)
vmovaps %ymm0, 0x20(%rsp)
vmovaps 0x40(%rsp), %ymm0
vmovaps 0x20(%rsp), %ymm1
vpmaxsw %ymm1, %ymm0, %ymm0
vmovaps %ymm0, (%rsp)
vmovdqa 0x10(%rsp), %xmm0
vpextrw $0x7, %xmm0, %eax
movzwl %ax, %eax
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/sw_scan_avx2_256_8.c
// Function: mm256_hmax_epi8_rpl
static inline int8_t _mm256_hmax_epi8_rpl(__m256i a) {
    a = _mm256_max_epi8(a, _mm256_permute2x128_si256(a, a, _MM_SHUFFLE(0,0,0,0)));
    a = _mm256_max_epi8(a, _mm256_slli_si256(a, 8));
    a = _mm256_max_epi8(a, _mm256_slli_si256(a, 4));
    a = _mm256_max_epi8(a, _mm256_slli_si256(a, 2));
    a = _mm256_max_epi8(a, _mm256_slli_si256(a, 1));
    return _mm256_extract_epi8_rpl(a, 31);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x180, %rsp            # imm = 0x180
vmovaps %ymm0, (%rsp)
vmovaps (%rsp), %ymm1
vpermq $0x44, %ymm1, %ymm0     # ymm0 = ymm1[0,1,0,1]
vmovaps %ymm1, 0x140(%rsp)
vmovaps %ymm0, 0x120(%rsp)
vmovaps 0x140(%rsp), %ymm0
vmovaps 0x120(%rsp), %ymm1
vpmaxsb %ymm1, %ymm0, %ymm0
vmovaps %ymm0, (%rsp)
vmovaps (%rsp), %ymm1
vpslldq $0x8, %ymm1, %ymm0      # ymm0 = zero,zero,zero,zero,zero,zero,zero,zero,ymm1[0,1,2,3,4,5,6,7],zero,zero,zero,zero,zero,zero,zero,zero,ymm1[16,17,18,19,20,21,22,23]
vmovaps %ymm1, 0x100(%rsp)
vmovaps %ymm0, 0xe0(%rsp)
vmovaps 0x100(%rsp), %ymm0
vmovaps 0xe0(%rsp), %ymm1
vpmaxsb %ymm1, %ymm0, %ymm0
vmovaps %ymm0, (%rsp)
vmovaps (%rsp), %ymm1
vpslldq $0x4, %ymm1, %ymm0      # ymm0 = zero,zero,zero,zero,ymm1[0,1,2,3,4,5,6,7,8,9,10,11],zero,zero,zero,zero,ymm1[16,17,18,19,20,21,22,23,24,25,26,27]
vmovaps %ymm1, 0xc0(%rsp)
vmovaps %ymm0, 0xa0(%rsp)
vmovaps 0xc0(%rsp), %ymm0
vmovaps 0xa0(%rsp), %ymm1
vpmaxsb %ymm1, %ymm0, %ymm0
vmovaps %ymm0, (%rsp)
vmovaps (%rsp), %ymm1
vpslldq $0x2, %ymm1, %ymm0      # ymm0 = zero,zero,ymm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13],zero,zero,ymm1[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
vmovaps %ymm1, 0x80(%rsp)
vmovaps %ymm0, 0x60(%rsp)
vmovaps 0x80(%rsp), %ymm0
vmovaps 0x60(%rsp), %ymm1
vpmaxsb %ymm1, %ymm0, %ymm0
vmovaps %ymm0, (%rsp)
vmovaps (%rsp), %ymm1
vpslldq $0x1, %ymm1, %ymm0      # ymm0 = zero,ymm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],zero,ymm1[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vmovaps %ymm1, 0x40(%rsp)
vmovaps %ymm0, 0x20(%rsp)
vmovaps 0x40(%rsp), %ymm0
vmovaps 0x20(%rsp), %ymm1
vpmaxsb %ymm1, %ymm0, %ymm0
vmovaps %ymm0, (%rsp)
vmovdqa 0x10(%rsp), %xmm0
vpextrb $0xf, %xmm0, %eax
movzbl %al, %eax
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x993ff0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x994620
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x994c60
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x30(%rcx), %rdx
movq %rdx, 0x30(%rax)
movq 0x38(%rcx), %rdx
movq %rdx, 0x38(%rax)
movq 0x40(%rcx), %rcx
movq %rcx, 0x40(%rax)
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movq 0x48(%rcx), %rdx
movq %rdx, 0x48(%rax)
movq 0x50(%rcx), %rdx
movq %rdx, 0x50(%rax)
movq 0x58(%rcx), %rcx
movq %rcx, 0x58(%rax)
movq -0x28(%rbp), %rdi
callq 0x19e120
movq -0x30(%rbp), %rdi
callq 0x19e120
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_scan_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:
pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x60, %rsp
movq %rdi, 0x48(%rsp)
vmovaps %ymm0, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
movl 0x20(%rsp), %edx
movq 0x48(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movslq 0x10(%rsp), %rsi
imulq %rsi, %rcx
movslq 0x14(%rsp), %rsi
addq %rsi, %rcx
movl %edx, (%rax,%rcx,4)
movl 0x28(%rsp), %edx
movq 0x48(%rsp), %rax
movl 0x18(%rsp), %ecx
movl 0x1c(%rsp), %esi
addl %esi, %ecx
movslq %ecx, %rcx
movslq 0x10(%rsp), %rsi
imulq %rsi, %rcx
movslq 0x14(%rsp), %rsi
addq %rsi, %rcx
movl %edx, (%rax,%rcx,4)
movl 0x30(%rsp), %edx
movq 0x48(%rsp), %rax
movl 0x18(%rsp), %ecx
movl 0x1c(%rsp), %edi
movl %ecx, %esi
movl %edi, %ecx
leal (%rcx,%rsi,2), %ecx
movslq %ecx, %rcx
movslq 0x10(%rsp), %rsi
imulq %rsi, %rcx
movslq 0x14(%rsp), %rsi
addq %rsi, %rcx
movl %edx, (%rax,%rcx,4)
movq 0x38(%rsp), %rax
movl %eax, %edx
movq 0x48(%rsp), %rax
imull $0x3, 0x18(%rsp), %ecx
addl 0x1c(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x0, %rcx
movslq 0x10(%rsp), %rsi
imulq %rsi, %rcx
movslq 0x14(%rsp), %rsi
addq %rsi, %rcx
movl %edx, (%rax,%rcx,4)
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_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:
pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x60, %rsp
movq %rdi, 0x48(%rsp)
vmovaps %ymm0, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl 0x20(%rsp), %edx
movq 0x48(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x28(%rsp), %edx
movq 0x48(%rsp), %rax
movl 0x18(%rsp), %ecx
movl 0x1c(%rsp), %esi
addl %esi, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl 0x30(%rsp), %edx
movq 0x48(%rsp), %rax
movl 0x18(%rsp), %ecx
movl 0x1c(%rsp), %edi
movl %ecx, %esi
movl %edi, %ecx
leal (%rcx,%rsi,2), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq 0x38(%rsp), %rax
movl %eax, %edx
movq 0x48(%rsp), %rax
imull $0x3, 0x18(%rsp), %ecx
addl 0x1c(%rsp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_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:
pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x60, %rsp
movq %rdi, 0x48(%rsp)
vmovaps %ymm0, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl 0x20(%rsp), %edx
movq 0x48(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x24(%rsp), %edx
movq 0x48(%rsp), %rax
movl 0x18(%rsp), %ecx
movl 0x1c(%rsp), %esi
addl %esi, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl 0x28(%rsp), %edx
movq 0x48(%rsp), %rax
movl 0x18(%rsp), %ecx
movl 0x1c(%rsp), %edi
movl %ecx, %esi
movl %edi, %ecx
leal (%rcx,%rsi,2), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl 0x2c(%rsp), %edx
movq 0x48(%rsp), %rax
movl 0x18(%rsp), %esi
movl %esi, %ecx
leal (%rcx,%rcx,2), %ecx
movl 0x1c(%rsp), %esi
addl %esi, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl 0x30(%rsp), %edx
movq 0x48(%rsp), %rax
movl 0x18(%rsp), %ecx
movl 0x1c(%rsp), %edi
movl %ecx, %esi
movl %edi, %ecx
leal (%rcx,%rsi,4), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl 0x34(%rsp), %edx
movq 0x48(%rsp), %rax
movl 0x18(%rsp), %esi
movl %esi, %ecx
leal (%rcx,%rcx,4), %ecx
movl 0x1c(%rsp), %esi
addl %esi, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl 0x38(%rsp), %edx
movq 0x48(%rsp), %rax
movl 0x18(%rsp), %esi
movl %esi, %ecx
leal (%rcx,%rcx,2), %edi
movl 0x1c(%rsp), %esi
movl %esi, %ecx
movl %edi, %esi
leal (%rcx,%rsi,2), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl 0x3c(%rsp), %edx
movq 0x48(%rsp), %rax
imull $0x7, 0x18(%rsp), %ecx
addl 0x1c(%rsp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/cpuid.c
// Function: has_intel_avx512vbmi_features
static int has_intel_avx512vbmi_features()
{
    uint32_t abcd[4];
    uint32_t osxsave_mask = (1U << 27); /* OSX. */
    uint32_t avx512vbmi_mask = (1U << 1); /* AVX-512VBMI */

    /* CPUID.(EAX=01H, ECX=0H):ECX.OSXSAVE[bit 27]==1 */
    run_cpuid( 1, 0, abcd );
    if ( (abcd[2] & osxsave_mask) != osxsave_mask )
        return 0;

    if ( ! check_xcr0_zmm() )
        return 0;

    /*  CPUID.(EAX=07H, ECX=0H):ECX.AVX-512VBMI[bit 1]==1 */
    run_cpuid( 7, 0, abcd );
    if ( (abcd[2] & avx512vbmi_mask) != avx512vbmi_mask )
        return 0;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x8000000, -0x24(%rbp) # imm = 0x8000000
movl $0x2, -0x28(%rbp)
leaq -0x20(%rbp), %rdx
movl $0x1, %edi
xorl %esi, %esi
callq 0xc8c3f0
movl -0x18(%rbp), %eax
andl -0x24(%rbp), %eax
cmpl -0x24(%rbp), %eax
je 0xc8c39a
movl $0x0, -0x4(%rbp)
jmp 0xc8c3d8
callq 0xc8c450
cmpl $0x0, %eax
jne 0xc8c3ad
movl $0x0, -0x4(%rbp)
jmp 0xc8c3d8
leaq -0x20(%rbp), %rdx
movl $0x7, %edi
xorl %esi, %esi
callq 0xc8c3f0
movl -0x18(%rbp), %eax
andl -0x28(%rbp), %eax
cmpl -0x28(%rbp), %eax
je 0xc8c3d1
movl $0x0, -0x4(%rbp)
jmp 0xc8c3d8
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/cpuid.c
// Function: has_intel_avx512bw_features
static int has_intel_avx512bw_features() {
    uint32_t abcd[4];
    uint32_t osxsave_mask = (1U << 27); /* OSX. */
    uint32_t avx512bw_mask = (1U << 30) | /* AVX-512BW */
        (1U << 17) | /* AVX-512DQ */
        (1U << 31);  /* AVX-512VL */

    /* CPUID.(EAX=01H, ECX=0H):ECX.OSXSAVE[bit 27]==1 */
    run_cpuid( 1, 0, abcd );
    if ( (abcd[2] & osxsave_mask) != osxsave_mask )
        return 0;

    if ( ! check_xcr0_zmm() )
        return 0;

    /*  CPUID.(EAX=07H, ECX=0H):EBX.AVX-512BW[bit 30]==1  &&
        CPUID.(EAX=07H, ECX=0H):EBX.AVX-512DQ[bit 17]==1  &&
        CPUID.(EAX=07H, ECX=0H):EBX.AVX-512VL[bit 31]==1  */
    run_cpuid( 7, 0, abcd );
    if ( (abcd[1] & avx512bw_mask) != avx512bw_mask )
        return 0;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x8000000, -0x24(%rbp) # imm = 0x8000000
movl $0xc0020000, -0x28(%rbp) # imm = 0xC0020000
leaq -0x20(%rbp), %rdx
movl $0x1, %edi
xorl %esi, %esi
callq 0xc8c3f0
movl -0x18(%rbp), %eax
andl -0x24(%rbp), %eax
cmpl -0x24(%rbp), %eax
je 0xc8c4ba
movl $0x0, -0x4(%rbp)
jmp 0xc8c4f8
callq 0xc8c450
cmpl $0x0, %eax
jne 0xc8c4cd
movl $0x0, -0x4(%rbp)
jmp 0xc8c4f8
leaq -0x20(%rbp), %rdx
movl $0x7, %edi
xorl %esi, %esi
callq 0xc8c3f0
movl -0x1c(%rbp), %eax
andl -0x28(%rbp), %eax
cmpl -0x28(%rbp), %eax
je 0xc8c4f1
movl $0x0, -0x4(%rbp)
jmp 0xc8c4f8
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/cpuid.c
// Function: has_intel_avx512f_features
static int has_intel_avx512f_features() {
    uint32_t abcd[4];
    uint32_t osxsave_mask = (1U << 27); /* OSX. */
    uint32_t avx512f_mask = (1U << 16) | /* AVX-512F */
        (1U << 26) | /* AVX-512PF */
        (1U << 27) | /* AVX-512ER */
        (1U << 28);  /* AVX-512CD */

    /* CPUID.(EAX=01H, ECX=0H):ECX.OSXSAVE[bit 27]==1 */
    run_cpuid( 1, 0, abcd );
    if ( (abcd[2] & osxsave_mask) != osxsave_mask )
        return 0;

    if ( ! check_xcr0_zmm() )
        return 0;

    /*  CPUID.(EAX=07H, ECX=0H):EBX.AVX-512F [bit 16]==1  &&
        CPUID.(EAX=07H, ECX=0H):EBX.AVX-512PF[bit 26]==1  &&
        CPUID.(EAX=07H, ECX=0H):EBX.AVX-512ER[bit 27]==1  &&
        CPUID.(EAX=07H, ECX=0H):EBX.AVX-512CD[bit 28]==1  */
    run_cpuid( 7, 0, abcd );
    if ( (abcd[1] & avx512f_mask) != avx512f_mask )
        return 0;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x8000000, -0x24(%rbp) # imm = 0x8000000
movl $0x1c010000, -0x28(%rbp) # imm = 0x1C010000
leaq -0x20(%rbp), %rdx
movl $0x1, %edi
xorl %esi, %esi
callq 0xc8c3f0
movl -0x18(%rbp), %eax
andl -0x24(%rbp), %eax
cmpl -0x24(%rbp), %eax
je 0xc8c54a
movl $0x0, -0x4(%rbp)
jmp 0xc8c588
callq 0xc8c450
cmpl $0x0, %eax
jne 0xc8c55d
movl $0x0, -0x4(%rbp)
jmp 0xc8c588
leaq -0x20(%rbp), %rdx
movl $0x7, %edi
xorl %esi, %esi
callq 0xc8c3f0
movl -0x1c(%rbp), %eax
andl -0x28(%rbp), %eax
cmpl -0x28(%rbp), %eax
je 0xc8c581
movl $0x0, -0x4(%rbp)
jmp 0xc8c588
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/cpuid.c
// Function: check_sse41
static int check_sse41()
{
    uint32_t info[4];
    uint32_t nIds;

    run_cpuid(0, 0, info);
    nIds = info[0];

    /*  Detect Instruction Set */
    if (nIds >= 1){
        run_cpuid(0x00000001, 0, info);
        return (info[2] & (1U << 19)) != 0;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq -0x20(%rbp), %rdx
xorl %esi, %esi
movl %esi, %edi
callq 0xc8c3f0
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x1, -0x24(%rbp)
jb 0xc8c639
leaq -0x20(%rbp), %rdx
movl $0x1, %edi
xorl %esi, %esi
callq 0xc8c3f0
movl -0x18(%rbp), %eax
andl $0x80000, %eax          # imm = 0x80000
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0xc8c640
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/cpuid.c
// Function: check_sse2
static int check_sse2()
{
    uint32_t info[4];
    uint32_t nIds;

    run_cpuid(0, 0, info);
    nIds = info[0];

    /*  Detect Instruction Set */
    if (nIds >= 1){
        run_cpuid(0x00000001, 0, info);
        return (info[3] & (1U << 26)) != 0;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq -0x20(%rbp), %rdx
xorl %esi, %esi
movl %esi, %edi
callq 0xc8c3f0
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x1, -0x24(%rbp)
jb 0xc8c699
leaq -0x20(%rbp), %rdx
movl $0x1, %edi
xorl %esi, %esi
callq 0xc8c3f0
movl -0x14(%rbp), %eax
andl $0x4000000, %eax        # imm = 0x4000000
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0xc8c6a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x1198
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
movq 0x2e73(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
callq 0x1030
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x116b
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.2/thread-create2.c
// Function: main
int main ()
{
	pthread_t thread1_id;
	pthread_t thread2_id;
	struct char_print_parms thread1_args;
	struct char_print_parms thread2_args;

  /* Create a new thread to print 30,000 ’x’s. */
	thread1_args.character = 'x';
	thread1_args.count = 30000;
	pthread_create (&thread1_id, NULL, &char_print, &thread1_args);

  /* Create a new thread to print 20,000 o’s. */
	thread2_args.character = 'o';
	thread2_args.count = 20000;
	pthread_create (&thread2_id, NULL, &char_print, &thread2_args);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movb $0x78, -0x20(%rbp)
movl $0x7530, -0x1c(%rbp)    # imm = 0x7530
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0x79(%rip), %rdx       # 0x1150
leaq -0x20(%rbp), %rcx
callq 0x1040
movb $0x6f, -0x28(%rbp)
movl $0x4e20, -0x24(%rbp)    # imm = 0x4E20
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0x9c(%rip), %rdx       # 0x1150
leaq -0x28(%rbp), %rcx
callq 0x1040
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/saulvargas[P]re-C-sys/test_usersim.c
// Function: main
int main(int argc, char** argv) {
    FILE* user_data;
    FILE* item_data;
    int N_users;
    int N_items;
    int N_prefs;
    int binary;
    recdata_t* recdata;
    int uid;
    int i;
    similarity_t* similarity;
    idpairs_t* pairs;

    if (!read_args(argc, argv, &user_data, &item_data, &N_users, &N_items, &N_prefs, &binary)) {
        return EXIT_FAILURE;
    }

    recdata = recdata_simple_create(user_data, item_data, N_users, N_items, N_prefs, binary);
    
    fclose(user_data);
    fclose(item_data);

    if (!binary) {
        similarity = similarity_veccosine_create(recdata);
    } else {
        similarity = similarity_setcosine_create(recdata);
    }

    for (uid = 0; uid < recdata->N_users; uid++) {
        pairs = similarity_calculate(similarity, uid, 100);

        for (i = 0; i < idpairs_size(pairs); i++) {
            printf("%d\t%d\t%.4f\n", uid, idpairs_keys(pairs)[i], idpairs_values(pairs)[i]);
        }
        
        idpairs_close_deep(pairs);
    }
 
    similarity_close(similarity);
    
    recdata_close(recdata);
    
    return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x24(%rbp), %r8
leaq -0x28(%rbp), %r9
leaq -0x2c(%rbp), %r10
leaq -0x30(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x3280
cmpl $0x0, %eax
jne 0x1274
movl $0x1, -0x4(%rbp)
jmp 0x138b
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
movl -0x28(%rbp), %ecx
movl -0x2c(%rbp), %r8d
movl -0x30(%rbp), %r9d
callq 0x1930
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1060
movq -0x20(%rbp), %rdi
callq 0x1060
cmpl $0x0, -0x30(%rbp)
jne 0x12ba
movq -0x38(%rbp), %rdi
callq 0x20f0
movq %rax, -0x48(%rbp)
jmp 0x12c7
movq -0x38(%rbp), %rdi
callq 0x1d60
movq %rax, -0x48(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x38(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x1372
movq -0x48(%rbp), %rdi
movl -0x3c(%rbp), %esi
movl $0x64, %edx
callq 0x1b10
movq %rax, -0x50(%rbp)
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x50(%rbp), %rdi
callq 0x30e0
movl %eax, %ecx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jge 0x135b
movl -0x3c(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x50(%rbp), %rdi
callq 0x30f0
movslq -0x40(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x3110
movl -0x5c(%rbp), %esi
movl -0x58(%rbp), %edx
movslq -0x40(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x2cbb(%rip), %rdi      # 0x4004
movb $0x1, %al
callq 0x1080
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x12f9
movq -0x50(%rbp), %rdi
callq 0x3080
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x12ce
movq -0x48(%rbp), %rdi
callq 0x1b40
movq -0x38(%rbp), %rdi
callq 0x1460
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/agraf[P]kvmbench/l3cache.c
// Function: main
int main(int argc, char **argv)
{
    int i;
    sigset_t fSigSet;

    sigemptyset(&fSigSet);
    sigaddset(&fSigSet, SIGUSR1);
    pthread_sigmask(SIG_BLOCK, &fSigSet, NULL);

    pthread_create(&threads[0], NULL, notifier_thread, NULL);
    pthread_create(&threads[1], NULL, waiter_thread, NULL);

    for (i=0; i<(sizeof(threads) / sizeof(threads[0])); i++) {
        pthread_join(threads[i], NULL);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x1080
leaq -0x98(%rbp), %rdi
movl $0xa, %esi
callq 0x10e0
xorl %edi, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x10a0
leaq 0x2e71(%rip), %rdi      # 0x40b0
xorl %eax, %eax
movl %eax, %ecx
leaq 0x66(%rip), %rdx        # 0x12b0
movq %rcx, %rsi
callq 0x10b0
leaq 0x2e57(%rip), %rdi      # 0x40b0
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq 0x98(%rip), %rdx        # 0x1300
movq %rcx, %rsi
callq 0x10b0
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $0x2, %rax
jae 0x12a4
movslq -0x14(%rbp), %rcx
leaq 0x2e24(%rip), %rax      # 0x40b0
movq (%rax,%rcx,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10d0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1277
xorl %eax, %eax
addq $0xa0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/agraf[P]kvmbench/l3cache.c
// Function: notifier_thread
static void *notifier_thread(void *opaque)
{
    while (sig_state != SIG_STATE_IDLE) ;
    while (1) {
//printf("[%d] trigger\n", gettid());
        sig_state = SIG_STATE_SENDING;
        pthread_kill(threads[1], SIGUSR1);
        while (sig_state != SIG_STATE_IDLE) ;
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0x2dde(%rip), %eax      # 0x40a0
cmpl $0x1, %eax
je 0x12c9
jmp 0x12bc
jmp 0x12cb
movl $0x2, 0x2dcb(%rip)      # 0x40a0
movq 0x2ddc(%rip), %rdi      # 0x40b8
movl $0xa, %esi
callq 0x1070
movl 0x2db4(%rip), %eax      # 0x40a0
cmpl $0x1, %eax
je 0x12f3
jmp 0x12e6
jmp 0x12cb
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/agraf[P]kvmbench/l3cache.c
// Function: waiter_thread
static void *waiter_thread(void *opaque)
{
    struct timeval tv_start;
    struct timeval tv_end;
    struct timeval tv;
    uint64_t loops = 0;
    struct sigaction sa = {
        .sa_handler = sig_handler,
    };

    sigset_t fSigSet;

    sigemptyset(&fSigSet);
    sigaddset(&fSigSet, SIGUSR1);
    pthread_sigmask(SIG_UNBLOCK, &fSigSet, NULL);

    sigaction(SIGUSR1, &sa, NULL);

    assert(!gettimeofday(&tv_start, NULL));
    tv_end = tv_start;
    tv_end.tv_sec += 1;

    sig_state = SIG_STATE_IDLE;

    while(1) {
        assert(!gettimeofday(&tv, NULL));
        if ((tv.tv_sec >= tv_end.tv_sec) && (tv.tv_usec >= tv_end.tv_usec))
            break;

        loops++;
//printf("[%d] pre-received \n", gettid());
        while (sig_state != SIG_STATE_RECEIVED) ;
//printf("[%d] recevied\n", gettid());
        sig_state = SIG_STATE_IDLE;
    }

    printf("Number of sleeps: %ld\n", loops);
    exit(0);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x8(%rbp)
movq $0x0, -0x40(%rbp)
leaq -0xd8(%rbp), %rdi
leaq 0x2a3b(%rip), %rsi      # 0x3d60
movl $0x98, %edx
callq 0x1090
leaq -0x158(%rbp), %rdi
callq 0x1080
leaq -0x158(%rbp), %rdi
movl $0xa, %esi
callq 0x10e0
movl $0x1, %edi
leaq -0x158(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x10a0
movl $0xa, %edi
leaq -0xd8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1030
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1050
cmpl $0x0, %eax
jne 0x138a
jmp 0x13a9
leaq 0xc73(%rip), %rdi       # 0x2004
leaq 0xc8b(%rip), %rsi       # 0x2023
movl $0x40, %edx
leaq 0xc89(%rip), %rcx       # 0x202d
callq 0x1060
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movl $0x1, 0x2cd1(%rip)      # 0x40a0
leaq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1050
cmpl $0x0, %eax
jne 0x13e3
jmp 0x1402
leaq 0xc5f(%rip), %rdi       # 0x2049
leaq 0xc32(%rip), %rsi       # 0x2023
movl $0x47, %edx
leaq 0xc30(%rip), %rcx       # 0x202d
callq 0x1060
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jl 0x1418
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jl 0x1418
jmp 0x143d
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movl 0x2c76(%rip), %eax      # 0x40a0
cmpl $0x3, %eax
je 0x1431
jmp 0x1424
movl $0x1, 0x2c65(%rip)      # 0x40a0
jmp 0x13cf
movq -0x40(%rbp), %rsi
leaq 0xc1a(%rip), %rdi       # 0x2062
movb $0x0, %al
callq 0x1040
xorl %edi, %edi
callq 0x10c0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/accre[P]Cprogramming/loops.c
// Function: main
int main()
{
   
   int n = 10;

   int i; // we'll use i as an index within a for loop
   int x[n];
   for ( i=0; i<n ; i++ ) {
      x[i] = i * 10;
      printf("i: %d x[i]: %d\n",i,x[i]);
   }

   // while loops are useful in certain situations as well
   int y = 0;
   while ( y < 100 ) {
      y += 12;
      printf("y: %d\n",y);
   }

   // and do-while loops, use these instead of while loops
   // if you want the code block executed before evaluation
   // of a condition (rather than vice versa, as is done with
   // a normal while loop)
   y = 0;
   do {
      y += 12;
      printf("y: %d\n",y);
   }
   while ( y < 100 );

   return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl $0xa, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x18(%rbp)
leaq 0xf(,%rax,4), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x30(%rbp)
movq %rcx, %rsp
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x11be
movq -0x30(%rbp), %rax
imull $0xa, -0xc(%rbp), %edx
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %esi
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0xe58(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1184
movl $0x0, -0x24(%rbp)
cmpl $0x64, -0x24(%rbp)
jge 0x11e7
movl -0x24(%rbp), %eax
addl $0xc, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %esi
leaq 0xe36(%rip), %rdi       # 0x2014
movb $0x0, %al
callq 0x1030
jmp 0x11c5
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $0xc, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %esi
leaq 0xe13(%rip), %rdi       # 0x2014
movb $0x0, %al
callq 0x1030
cmpl $0x64, -0x24(%rbp)
jl 0x11ee
movl $0x0, -0x4(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jafrado[P]magdec/test.c
// Function: main
int main(int argc, char* argv[])
{
	int i, year;
	double variance[100];

	printf("Showing Magnetic declination changes for "
	       "%ld locations over %ld years\n\n", n_locations, n_years);
	
	for (int i = 0; i < n_locations; i++) {
		for (int j = 0; j < n_years; j++) { 		
			year = years[j];
			printf("%s,%s, %s (%2.3f,%2.3f) in "
			       "%d: %2.2f degrees\n", 
			       locations[i].city, locations[i].state,
			       locations[i].country,
			       locations[i].lat,
			       locations[i].lon, year,
			       lookup_magdev(locations[i].lat,
					     locations[i].lon, year));

		}
		printf("---\n");
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x380, %rsp            # imm = 0x380
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xf99(%rip), %rdi       # 0x20f9
movl $0xd, %esi
movl $0x6, %edx
movb $0x0, %al
callq 0x1030
movl $0x0, -0x344(%rbp)
movslq -0x344(%rbp), %rax
cmpq $0xd, %rax
jae 0x1322
movl $0x0, -0x348(%rbp)
movslq -0x348(%rbp), %rax
cmpq $0x6, %rax
jae 0x1300
movslq -0x348(%rbp), %rcx
leaq 0x301b(%rip), %rax      # 0x41d0
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
movslq -0x344(%rbp), %rcx
leaq 0x2e67(%rip), %rax      # 0x4030
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x378(%rbp)
movslq -0x344(%rbp), %rcx
leaq 0x2e48(%rip), %rax      # 0x4030
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x370(%rbp)
movslq -0x344(%rbp), %rcx
leaq 0x2e28(%rip), %rax      # 0x4030
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, -0x368(%rbp)
movslq -0x344(%rbp), %rcx
leaq 0x2e08(%rip), %rax      # 0x4030
shlq $0x5, %rcx
addq %rcx, %rax
movss 0x18(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x350(%rbp)
movslq -0x344(%rbp), %rcx
leaq 0x2de2(%rip), %rax      # 0x4030
shlq $0x5, %rcx
addq %rcx, %rax
movss 0x1c(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x360(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x354(%rbp)
movslq -0x344(%rbp), %rcx
leaq 0x2db3(%rip), %rax      # 0x4030
shlq $0x5, %rcx
addq %rcx, %rax
movss 0x18(%rax), %xmm0
movslq -0x344(%rbp), %rcx
leaq 0x2d99(%rip), %rax      # 0x4030
shlq $0x5, %rcx
addq %rcx, %rax
movss 0x1c(%rax), %xmm1
movl -0x18(%rbp), %edi
callq 0x1330
movq -0x378(%rbp), %rsi
movq -0x370(%rbp), %rdx
movq -0x368(%rbp), %rcx
movsd -0x360(%rbp), %xmm1
movl -0x354(%rbp), %r8d
movaps %xmm0, %xmm2
movsd -0x350(%rbp), %xmm0
cvtss2sd %xmm2, %xmm2
leaq 0xe5c(%rip), %rdi       # 0x2141
movb $0x3, %al
callq 0x1030
movl -0x348(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x348(%rbp)
jmp 0x1196
leaq 0xe68(%rip), %rdi       # 0x216f
movb $0x0, %al
callq 0x1030
movl -0x344(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x344(%rbp)
jmp 0x117b
movl -0x4(%rbp), %eax
addq $0x380, %rsp            # imm = 0x380
popq %rbp
retq
nop