LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/cigar.c
// Function: parasail_cigar_decode
char* parasail_cigar_decode(parasail_cigar_t *cigar)
{
#define SIZE 40
    char *ret = NULL;
    size_t retlen = 0;
    size_t size = 0;
    int i = 0;

    /* initial allocation for 1 op and 3 number characters per cigar int */
    size = sizeof(char)*cigar->len*4;
    ret = malloc(size+1);
    ret[0] = '\0';

    for (i=0; i<cigar->len; ++i) {
        char tmp[SIZE];
        char op = parasail_cigar_decode_op(cigar->seq[i]);
        uint32_t len = parasail_cigar_decode_len(cigar->seq[i]);
        int snprintf_retcode = snprintf(tmp, SIZE, "%u%c", len, op);
        if (snprintf_retcode >= SIZE) {
            fprintf(stderr, "invalid CIGAR\n");
            free(ret);
            return NULL;
        }
        retlen += snprintf_retcode;
        if (retlen >= size) {
            size *= 2;
            ret = realloc(ret, size+1);
        }
        strcat(ret, tmp);
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movslq 0x8(%rax), %rax
shlq $0x0, %rax
shlq $0x2, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
callq 0x19e150
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x1b9fce
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x1b9e40
movb %al, -0x61(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x1b9e80
movl %eax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
movl -0x68(%rbp), %ecx
movsbl -0x61(%rbp), %r8d
movl $0x28, %esi
leaq 0xad3e66(%rip), %rdx    # 0xc8dda8
movb $0x0, %al
callq 0x19e1e0
movl %eax, -0x6c(%rbp)
cmpl $0x28, -0x6c(%rbp)
jl 0x1b9f7d
movq 0xc6d07f(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
leaq 0xad3e4a(%rip), %rsi    # 0xc8ddad
movb $0x0, %al
callq 0x19e180
movq -0x18(%rbp), %rdi
callq 0x19e120
movq $0x0, -0x8(%rbp)
jmp 0x1b9fd6
movslq -0x6c(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x1b9fb3
movq -0x28(%rbp), %rax
shlq %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x1, %rsi
callq 0x19e1f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x19e200
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1b9eee
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/function_lookup.c
// Function: parasail_lookup_function
parasail_function_t * parasail_lookup_function(const char *funcname)
{
    const parasail_function_info_t * info = NULL;

    info = parasail_lookup_function_info(funcname);

    if (info && info->pointer) {
        return info->pointer;
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c3120
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1c30ff
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1c30ff
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1c3107
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/function_lookup.c
// Function: parasail_lookup_function_info
const parasail_function_info_t * parasail_lookup_function_info(const char *funcname)
{
    const parasail_function_info_t * f = NULL;

    if (funcname) {
        int index = 0;
        f = &functions[index++];
        while (f->pointer) {
            if (0 == strcmp(funcname, f->name)) {
                break;
            }
            f = &functions[index++];
        }
        if (!f->pointer) {
            /* perhaps caller forgot "parasail_" prefix? */
            const char *prefix = "parasail_";
            char *newname = (char*)malloc(strlen(prefix)+strlen(funcname)+1);
            strcpy(newname, prefix);
            strcat(newname, funcname);
            index = 0;
            f = &functions[index++];
            while (f->pointer) {
                if (0 == strcmp(newname, f->name)) {
                    break;
                }
                f = &functions[index++];
            }
            free(newname);
        }
    }

    if (!f->pointer) {
        f = NULL;
    }

    return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1c3283
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %eax, %rcx
leaq 0xbb95b5(%rip), %rax    # 0xd7c710
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1c31ad
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x19e170
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1c318b
jmp 0x1c31ad
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %eax, %rcx
leaq 0xbb9570(%rip), %rax    # 0xd7c710
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x1c3166
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1c3281
leaq 0xacacf6(%rip), %rax    # 0xc8deb8
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x19e050
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x19e050
movq -0x30(%rbp), %rdi
addq %rax, %rdi
addq $0x1, %rdi
callq 0x19e150
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x19e0b0
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x19e200
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %eax, %rcx
leaq 0xbb94ea(%rip), %rax    # 0xd7c710
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1c3278
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x19e170
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1c3256
jmp 0x1c3278
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %eax, %rcx
leaq 0xbb94a5(%rip), %rax    # 0xd7c710
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x1c3231
movq -0x28(%rbp), %rdi
callq 0x19e120
jmp 0x1c3283
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1c3295
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/function_lookup.c
// Function: parasail_lookup_pfunction
parasail_pfunction_t * parasail_lookup_pfunction(const char *funcname)
{
    const parasail_pfunction_info_t * info = NULL;

    info = parasail_lookup_pfunction_info(funcname);

    if (info && info->pointer) {
        return info->pointer;
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c3300
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1c32df
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1c32df
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1c32e7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/function_lookup.c
// Function: parasail_lookup_pfunction_info
const parasail_pfunction_info_t * parasail_lookup_pfunction_info(const char *funcname)
{
    const parasail_pfunction_info_t * f = NULL;

    if (funcname) {
        int index = 0;
        f = &pfunctions[index++];
        while (f->pointer) {
            if (0 == strcmp(funcname, f->name)) {
                break;
            }
            f = &pfunctions[index++];
        }
        if (!f->pointer) {
            /* perhaps caller forgot "parasail_" prefix? */
            const char *prefix = "parasail_";
            char *newname = (char*)malloc(strlen(prefix)+strlen(funcname)+1);
            strcpy(newname, prefix);
            strcat(newname, funcname);
            index = 0;
            f = &pfunctions[index++];
            while (f->pointer) {
                if (0 == strcmp(newname, f->name)) {
                    break;
                }
                f = &pfunctions[index++];
            }
            free(newname);
        }
    }

    if (!f->pointer) {
        f = NULL;
    }

    return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1c3463
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %eax, %rcx
leaq 0xc1c8a5(%rip), %rax    # 0xddfbe0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1c338d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x19e170
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1c336b
jmp 0x1c338d
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %eax, %rcx
leaq 0xc1c860(%rip), %rax    # 0xddfbe0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x1c3346
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1c3461
leaq 0xacab16(%rip), %rax    # 0xc8deb8
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x19e050
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x19e050
movq -0x30(%rbp), %rdi
addq %rax, %rdi
addq $0x1, %rdi
callq 0x19e150
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x19e0b0
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x19e200
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %eax, %rcx
leaq 0xc1c7da(%rip), %rax    # 0xddfbe0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1c3458
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x19e170
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1c3436
jmp 0x1c3458
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %eax, %rcx
leaq 0xc1c795(%rip), %rax    # 0xddfbe0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x1c3411
movq -0x28(%rbp), %rdi
callq 0x19e120
jmp 0x1c3463
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1c3475
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/function_lookup.c
// Function: parasail_lookup_pcreator
parasail_pcreator_t * parasail_lookup_pcreator(const char *funcname)
{
    const parasail_pfunction_info_t * info = NULL;

    info = parasail_lookup_pfunction_info(funcname);

    if (info && info->creator) {
        return info->creator;
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c3300
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1c34c1
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1c34c1
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1c34c9
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/memory.c
// Function: parasail_memalign
void* parasail_memalign(size_t alignment, size_t size)
{
    void *ptr = NULL;
#if defined(HAVE__ALIGNED_MALLOC)
    ptr = _aligned_malloc(size, alignment);
#elif defined(HAVE_POSIX_MEMALIGN)
    int retcode = posix_memalign(&ptr, alignment, size);
    if (0 != retcode) {
        fprintf(stderr, "%s: posix_memalign failed: %s\n",
                __func__, strerror(retcode));
        return NULL;
    }
#elif defined(HAVE_ALIGNED_ALLOC)
    ptr = aligned_alloc(alignment, size);
#elif defined(HAVE_MEMALIGN)
    ptr = memalign(alignment, size);
#else
#error "No suitable memory alignment routine found."
#endif
    if (NULL == ptr) {
        fprintf(stderr, "%s: failed\n", __func__);
    }
    return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0x19e060
movl %eax, -0x24(%rbp)
xorl %eax, %eax
cmpl -0x24(%rbp), %eax
je 0x1c354f
movq 0xc63abe(%rip), %rax    # 0xe26fd8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %edi
callq 0x19e040
movq -0x30(%rbp), %rdi
movq %rax, %rcx
leaq 0xb28949(%rip), %rsi    # 0xcebe80
leaq 0xb28961(%rip), %rdx    # 0xcebe9f
movb $0x0, %al
callq 0x19e180
movq $0x0, -0x8(%rbp)
jmp 0x1c357e
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x1c3576
movq 0xc63a7a(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
leaq 0xb28949(%rip), %rsi    # 0xcebeb1
leaq 0xb28930(%rip), %rdx    # 0xcebe9f
movb $0x0, %al
callq 0x19e180
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/memory.c
// Function: parasail_result_new
parasail_result_t* parasail_result_new()
{
    /* declare all variables */
    parasail_result_t *result = NULL;

    PARASAIL_NEW(result, parasail_result_t);

    result->score = 0;
    result->end_query = 0;
    result->end_ref = 0;
    result->flag = 0;
    result->extra = NULL;

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x10(%rbp)
movq $0x18, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x19e150
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1c38b9
movq 0xc63745(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
movq -0x18(%rbp), %rcx
leaq 0xb2861c(%rip), %rsi    # 0xcebebd
leaq 0xb28635(%rip), %rdx    # 0xcebedd
movb $0x0, %al
callq 0x19e180
movq $0x0, -0x8(%rbp)
jmp 0x1c38fa
jmp 0x1c38bb
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/memory.c
// Function: parasail_result_new_stats
parasail_result_t* parasail_result_new_stats()
{
    /* declare all variables */
    parasail_result_t *result = NULL;

    /* allocate struct to hold memory */
    result = parasail_result_new();
    if (!result) return NULL;

    /* allocate only tables */
    PARASAIL_NEW(result->stats, parasail_result_extra_stats_t);

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x10(%rbp)
callq 0x1c3860
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1c393a
movq $0x0, -0x8(%rbp)
jmp 0x1c399a
jmp 0x1c393c
movq $0x18, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x19e150
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1c3990
movq 0xc6366e(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
movq -0x18(%rbp), %rcx
leaq 0xb28545(%rip), %rsi    # 0xcebebd
leaq 0xb28572(%rip), %rdx    # 0xcebef1
movb $0x0, %al
callq 0x19e180
movq $0x0, -0x8(%rbp)
jmp 0x1c399a
jmp 0x1c3992
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/memory.c
// Function: parasail_result_new_table1
parasail_result_t* parasail_result_new_table1(const int a, const int b)
{
    /* declare all variables */
    parasail_result_t *result = NULL;

    /* validate inputs */
    VALIDATE_A_B
    
    /* allocate struct to hold memory */
    result = parasail_result_new();
    if (!result) return NULL;

    /* allocate only score table */
    PARASAIL_NEW(result->tables, parasail_result_extra_tables_t);
    PARASAIL_CALLOC(result->tables->score_table, int, a*b);

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x1c39d2
cmpl $0x0, -0x10(%rbp)
jg 0x1c39fe
movq 0xc635ff(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
leaq 0xb28528(%rip), %rsi    # 0xcebf0b
leaq 0xb28539(%rip), %rdx    # 0xcebf23
movb $0x0, %al
callq 0x19e180
movq $0x0, -0x8(%rbp)
jmp 0x1c3ae2
callq 0x1c3860
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1c3a1b
movq $0x0, -0x8(%rbp)
jmp 0x1c3ae2
jmp 0x1c3a1d
movq $0x8, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x19e150
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1c3a71
movq 0xc6358d(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
movq -0x20(%rbp), %rcx
leaq 0xb28464(%rip), %rsi    # 0xcebebd
leaq 0xb284c3(%rip), %rdx    # 0xcebf23
movb $0x0, %al
callq 0x19e180
movq $0x0, -0x8(%rbp)
jmp 0x1c3ae2
jmp 0x1c3a73
jmp 0x1c3a75
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
cltq
shlq $0x2, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x19e150
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, (%rax)
jne 0x1c3ad8
movq 0xc63526(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
movq -0x28(%rbp), %rcx
leaq 0xb283fd(%rip), %rsi    # 0xcebebd
leaq 0xb2845c(%rip), %rdx    # 0xcebf23
movb $0x0, %al
callq 0x19e180
movq $0x0, -0x8(%rbp)
jmp 0x1c3ae2
jmp 0x1c3ada
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/memory.c
// Function: parasail_result_new_rowcol1
parasail_result_t* parasail_result_new_rowcol1(const int a, const int b)
{
    /* declare all variables */
    parasail_result_t *result = NULL;

    VALIDATE_A_B
    
    /* allocate struct to hold memory */
    result = parasail_result_new();
    if (!result) return NULL;

    /* allocate only score col and row */
    PARASAIL_NEW(result->rowcols, parasail_result_extra_rowcols_t);
    PARASAIL_CALLOC(result->rowcols->score_row, int, b);
    PARASAIL_CALLOC(result->rowcols->score_col, int, a);

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x1c3b12
cmpl $0x0, -0x10(%rbp)
jg 0x1c3b3e
movq 0xc634bf(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
leaq 0xb283e8(%rip), %rsi    # 0xcebf0b
leaq 0xb28414(%rip), %rdx    # 0xcebf3e
movb $0x0, %al
callq 0x19e180
movq $0x0, -0x8(%rbp)
jmp 0x1c3c84
callq 0x1c3860
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1c3b5b
movq $0x0, -0x8(%rbp)
jmp 0x1c3c84
jmp 0x1c3b5d
movq $0x10, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x19e150
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1c3bb4
movq 0xc6344d(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
movq -0x20(%rbp), %rcx
leaq 0xb28324(%rip), %rsi    # 0xcebebd
leaq 0xb2839e(%rip), %rdx    # 0xcebf3e
movb $0x0, %al
callq 0x19e180
movq $0x0, -0x8(%rbp)
jmp 0x1c3c84
jmp 0x1c3bb6
jmp 0x1c3bb8
movslq -0x10(%rbp), %rax
shlq $0x2, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x19e150
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, (%rax)
jne 0x1c3c16
movq 0xc633e8(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
movq -0x28(%rbp), %rcx
leaq 0xb282bf(%rip), %rsi    # 0xcebebd
leaq 0xb28339(%rip), %rdx    # 0xcebf3e
movb $0x0, %al
callq 0x19e180
movq $0x0, -0x8(%rbp)
jmp 0x1c3c84
jmp 0x1c3c18
jmp 0x1c3c1a
movslq -0xc(%rbp), %rax
shlq $0x2, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x19e150
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1c3c7a
movq 0xc63384(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
movq -0x30(%rbp), %rcx
leaq 0xb2825b(%rip), %rsi    # 0xcebebd
leaq 0xb282d5(%rip), %rdx    # 0xcebf3e
movb $0x0, %al
callq 0x19e180
movq $0x0, -0x8(%rbp)
jmp 0x1c3c84
jmp 0x1c3c7c
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/memory.c
// Function: parasail_result_new_trace
parasail_result_t* parasail_result_new_trace(const int a, const int b, const size_t alignment, const size_t size)
{
    /* declare all variables */
    parasail_result_t *result = NULL;

    VALIDATE_A_B

    /* allocate struct to hold memory */
    result = parasail_result_new();
    if (!result) return NULL;

    PARASAIL_NEW(result->trace, parasail_result_extra_trace_t);
    result->trace->trace_table = parasail_memalign(alignment, size*a*b);
    if (!result->trace->trace_table) return NULL;
    result->trace->trace_ins_table = NULL;
    result->trace->trace_del_table = NULL;

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x1c3fca
cmpl $0x0, -0x10(%rbp)
jg 0x1c3ff6
movq 0xc63007(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
leaq 0xb27f30(%rip), %rsi    # 0xcebf0b
leaq 0xb27f93(%rip), %rdx    # 0xcebf75
movb $0x0, %al
callq 0x19e180
movq $0x0, -0x8(%rbp)
jmp 0x1c40d6
callq 0x1c3860
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1c4013
movq $0x0, -0x8(%rbp)
jmp 0x1c40d6
jmp 0x1c4015
movq $0x18, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x19e150
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1c4069
movq 0xc62f95(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
movq -0x30(%rbp), %rcx
leaq 0xb27e6c(%rip), %rsi    # 0xcebebd
leaq 0xb27f1d(%rip), %rdx    # 0xcebf75
movb $0x0, %al
callq 0x19e180
movq $0x0, -0x8(%rbp)
jmp 0x1c40d6
jmp 0x1c406b
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movslq -0xc(%rbp), %rax
imulq %rax, %rsi
movslq -0x10(%rbp), %rax
imulq %rax, %rsi
callq 0x1c34e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, (%rax)
jne 0x1c40ae
movq $0x0, -0x8(%rbp)
jmp 0x1c40d6
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq $0x0, 0x10(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/memory.c
// Function: parasail_matrix_set_value
void parasail_matrix_set_value(parasail_matrix_t *matrix, int row, int col, int value)
{
    PARASAIL_CHECK_NULL_NORETVAL(matrix);

    if (NULL == matrix->user_matrix) {
        fprintf(stderr, "%s: attempted to set value of built-in matrix '%s'\n",
                __func__, matrix->name);
        return;
    }

    matrix->user_matrix[row*matrix->size + col] = value;
    if (value > matrix->max) {
        matrix->max = value;
    }
    if (value < matrix->min) {
        matrix->min = value;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1c5bb7
movq 0xc61445(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
leaq 0xb2644e(%rip), %rsi    # 0xcebfeb
leaq 0xb264c7(%rip), %rdx    # 0xcec06b
leaq 0xb26d7a(%rip), %rcx    # 0xcec925
movb $0x0, %al
callq 0x19e180
jmp 0x1c5c38
jmp 0x1c5bb9
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq 0x28(%rcx), %rax
jne 0x1c5bed
movq 0xc6140c(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rcx
leaq 0xb264a8(%rip), %rsi    # 0xcec085
leaq 0xb26487(%rip), %rdx    # 0xcec06b
movb $0x0, %al
callq 0x19e180
jmp 0x1c5c38
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rsi
imull 0x18(%rsi), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jle 0x1c5c22
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x1c5c38
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/memory.c
// Function: parasail_matrix_free
void parasail_matrix_free(parasail_matrix_t *matrix)
{
    /* validate inputs */
    PARASAIL_CHECK_NULL_NORETVAL(matrix);

    if (NULL != matrix->user_matrix) {
        free((void*)matrix->matrix);
        free((void*)matrix->mapper);
        free((void*)matrix->alphabet);
        if (matrix->query) free((void*)matrix->query);
        free(matrix);
    }
    else {
        fprintf(stderr, "%s: attempted to free built-in matrix '%s'\n",
                __func__, matrix->name);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1c5c7b
movq 0xc6137e(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
leaq 0xb26387(%rip), %rsi    # 0xcebfeb
leaq 0xb2644e(%rip), %rdx    # 0xcec0b9
leaq 0xb26cb3(%rip), %rcx    # 0xcec925
movb $0x0, %al
callq 0x19e180
jmp 0x1c5cf9
jmp 0x1c5c7d
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq 0x28(%rcx), %rax
je 0x1c5cd3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x19e120
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x19e120
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x19e120
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x1c5cc8
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x19e120
movq -0x8(%rbp), %rdi
callq 0x19e120
jmp 0x1c5cf9
movq 0xc612fe(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rcx
leaq 0xb263e3(%rip), %rsi    # 0xcec0ce
leaq 0xb263c7(%rip), %rdx    # 0xcec0b9
movb $0x0, %al
callq 0x19e180
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/memory.c
// Function: parasail_reverse
char* parasail_reverse(const char *s, size_t length)
{
    char *r = NULL;
    size_t i = 0;
    size_t j = 0;

    PARASAIL_CALLOC(r, char, length+1);
    r[length] = '\0';
    for (i=0,j=length-1; i<length; ++i,--j) {
        r[i] = s[j];
    }

    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
shlq $0x0, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x19e150
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1c6119
movq 0xc60ee5(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
movq -0x38(%rbp), %rcx
leaq 0xb25dbc(%rip), %rsi    # 0xcebebd
leaq 0xb26049(%rip), %rdx    # 0xcec151
movb $0x0, %al
callq 0x19e180
movq $0x0, -0x8(%rbp)
jmp 0x1c617d
jmp 0x1c611b
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1c6175
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1c613b
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/memory.c
// Function: parasail_reverse_uint32_t
uint32_t* parasail_reverse_uint32_t(const uint32_t *s, size_t length)
{
    uint32_t *r = NULL;
    size_t i = 0;
    size_t j = 0;

    PARASAIL_CALLOC(r, uint32_t, length);
    for (i=0,j=length-1; i<length; ++i,--j) {
        r[i] = s[j];
    }

    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
shlq $0x2, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x19e150
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1c6205
movq 0xc60df9(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
movq -0x38(%rbp), %rcx
leaq 0xb25cd0(%rip), %rsi    # 0xcebebd
leaq 0xb25f6e(%rip), %rdx    # 0xcec162
movb $0x0, %al
callq 0x19e180
movq $0x0, -0x8(%rbp)
jmp 0x1c625d
jmp 0x1c6207
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1c6255
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1c621b
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/memory.c
// Function: parasail_result_get_score_table
int* parasail_result_get_score_table(const parasail_result_t * const restrict result)
{
    PARASAIL_CHECK_NULL(result);
    PARASAIL_ASSERT(parasail_result_is_table(result) || parasail_result_is_stats_table(result));
    if (parasail_result_is_stats_table(result)) {
        return result->stats->tables->score_table;
    }
    if (parasail_result_is_table(result)) {
        return result->tables->score_table;
    }
    return NULL; /* should not reach */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1c6bb6
movq 0xc6044e(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
leaq 0xb25457(%rip), %rsi    # 0xcebfeb
leaq 0xb25833(%rip), %rdx    # 0xcec3ce
leaq 0xb255f0(%rip), %rcx    # 0xcec192
movb $0x0, %al
callq 0x19e180
movq $0x0, -0x8(%rbp)
jmp 0x1c6c52
jmp 0x1c6bb8
jmp 0x1c6bba
movq -0x10(%rbp), %rdi
callq 0x1c6750
cmpl $0x0, %eax
jne 0x1c6c06
movq -0x10(%rbp), %rdi
callq 0x1c6630
cmpl $0x0, %eax
jne 0x1c6c06
movq 0xc603fb(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
leaq 0xac71d5(%rip), %rsi    # 0xc8ddbc
leaq 0xb257e0(%rip), %rdx    # 0xcec3ce
leaq 0xb257f9(%rip), %rcx    # 0xcec3ee
movb $0x0, %al
callq 0x19e180
movq $0x0, -0x8(%rbp)
jmp 0x1c6c52
jmp 0x1c6c08
movq -0x10(%rbp), %rdi
callq 0x1c6630
cmpl $0x0, %eax
je 0x1c6c2b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1c6c52
movq -0x10(%rbp), %rdi
callq 0x1c6750
cmpl $0x0, %eax
je 0x1c6c4a
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1c6c52
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/memory.c
// Function: parasail_result_get_score_row
int* parasail_result_get_score_row(const parasail_result_t * const restrict result)
{
    PARASAIL_CHECK_NULL(result);
    PARASAIL_ASSERT(parasail_result_is_stats_rowcol(result) || parasail_result_is_rowcol(result));
    if (parasail_result_is_stats_rowcol(result)) {
        return result->stats->rowcols->score_row;
    }
    if (parasail_result_is_rowcol(result)) {
        return result->rowcols->score_row;
    }
    return NULL; /* should not reach */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1c6eb6
movq 0xc6014e(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
leaq 0xb25157(%rip), %rsi    # 0xcebfeb
leaq 0xb25603(%rip), %rdx    # 0xcec49e
leaq 0xb252f0(%rip), %rcx    # 0xcec192
movb $0x0, %al
callq 0x19e180
movq $0x0, -0x8(%rbp)
jmp 0x1c6f52
jmp 0x1c6eb8
jmp 0x1c6eba
movq -0x10(%rbp), %rdi
callq 0x1c66c0
cmpl $0x0, %eax
jne 0x1c6f06
movq -0x10(%rbp), %rdi
callq 0x1c67b0
cmpl $0x0, %eax
jne 0x1c6f06
movq 0xc600fb(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
leaq 0xac6ed5(%rip), %rsi    # 0xc8ddbc
leaq 0xb255b0(%rip), %rdx    # 0xcec49e
leaq 0xb255c7(%rip), %rcx    # 0xcec4bc
movb $0x0, %al
callq 0x19e180
movq $0x0, -0x8(%rbp)
jmp 0x1c6f52
jmp 0x1c6f08
movq -0x10(%rbp), %rdi
callq 0x1c66c0
cmpl $0x0, %eax
je 0x1c6f2b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1c6f52
movq -0x10(%rbp), %rdi
callq 0x1c67b0
cmpl $0x0, %eax
je 0x1c6f4a
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1c6f52
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/memory.c
// Function: parasail_result_get_score_col
int* parasail_result_get_score_col(const parasail_result_t * const restrict result)
{
    PARASAIL_CHECK_NULL(result);
    PARASAIL_ASSERT(parasail_result_is_stats_rowcol(result) || parasail_result_is_rowcol(result));
    if (parasail_result_is_stats_rowcol(result)) {
        return result->stats->rowcols->score_col;
    }
    if (parasail_result_is_rowcol(result)) {
        return result->rowcols->score_col;
    }
    return NULL; /* should not reach */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1c71b6
movq 0xc5fe4e(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
leaq 0xb24e57(%rip), %rsi    # 0xcebfeb
leaq 0xb253f5(%rip), %rdx    # 0xcec590
leaq 0xb24ff0(%rip), %rcx    # 0xcec192
movb $0x0, %al
callq 0x19e180
movq $0x0, -0x8(%rbp)
jmp 0x1c7254
jmp 0x1c71b8
jmp 0x1c71ba
movq -0x10(%rbp), %rdi
callq 0x1c66c0
cmpl $0x0, %eax
jne 0x1c7206
movq -0x10(%rbp), %rdi
callq 0x1c67b0
cmpl $0x0, %eax
jne 0x1c7206
movq 0xc5fdfb(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
leaq 0xac6bd5(%rip), %rsi    # 0xc8ddbc
leaq 0xb253a2(%rip), %rdx    # 0xcec590
leaq 0xb252c7(%rip), %rcx    # 0xcec4bc
movb $0x0, %al
callq 0x19e180
movq $0x0, -0x8(%rbp)
jmp 0x1c7254
jmp 0x1c7208
movq -0x10(%rbp), %rdi
callq 0x1c66c0
cmpl $0x0, %eax
je 0x1c722c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1c7254
movq -0x10(%rbp), %rdi
callq 0x1c67b0
cmpl $0x0, %eax
je 0x1c724c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1c7254
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_scan_64_dispatcher
parasail_result_t* parasail_nw_scan_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_scan_64_pointer = parasail_nw_scan_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_scan_64_pointer = parasail_nw_scan_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_scan_64_pointer = parasail_nw_scan_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_scan_64_pointer = parasail_nw_scan_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_scan_64_pointer = parasail_nw_scan_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_scan_64_pointer = parasail_nw_scan;
    }
    return parasail_nw_scan_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1c76ae
leaq 0x6b7c5b(%rip), %rax    # 0x87f300
movq %rax, 0xc5fb74(%rip)    # 0xe27220
jmp 0x1c76f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1c76ca
leaq 0x3cf75f(%rip), %rax    # 0x596e20
movq %rax, 0xc5fb58(%rip)    # 0xe27220
jmp 0x1c76f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1c76e6
leaq 0xf56a3(%rip), %rax     # 0x2bcd80
movq %rax, 0xc5fb3c(%rip)    # 0xe27220
jmp 0x1c76f4
leaq 0xd07f3(%rip), %rax     # 0x297ee0
movq %rax, 0xc5fb2c(%rip)    # 0xe27220
jmp 0x1c76f6
jmp 0x1c76f8
movq 0xc5fb21(%rip), %rax    # 0xe27220
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_scan_32_dispatcher
parasail_result_t* parasail_nw_scan_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_scan_32_pointer = parasail_nw_scan_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_scan_32_pointer = parasail_nw_scan_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_scan_32_pointer = parasail_nw_scan_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_scan_32_pointer = parasail_nw_scan_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_scan_32_pointer = parasail_nw_scan_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_scan_32_pointer = parasail_nw_scan;
    }
    return parasail_nw_scan_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1c776e
leaq 0x6bdc6b(%rip), %rax    # 0x8853d0
movq %rax, 0xc5fabc(%rip)    # 0xe27228
jmp 0x1c77b8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1c778a
leaq 0x3d484f(%rip), %rax    # 0x59bfd0
movq %rax, 0xc5faa0(%rip)    # 0xe27228
jmp 0x1c77b6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1c77a6
leaq 0xfa973(%rip), %rax     # 0x2c2110
movq %rax, 0xc5fa84(%rip)    # 0xe27228
jmp 0x1c77b4
leaq 0xd0733(%rip), %rax     # 0x297ee0
movq %rax, 0xc5fa74(%rip)    # 0xe27228
jmp 0x1c77b6
jmp 0x1c77b8
movq 0xc5fa69(%rip), %rax    # 0xe27228
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_scan_16_dispatcher
parasail_result_t* parasail_nw_scan_16_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_scan_16_pointer = parasail_nw_scan_avx2_256_16;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_scan_16_pointer = parasail_nw_scan_sse41_128_16;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_scan_16_pointer = parasail_nw_scan_sse2_128_16;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_scan_16_pointer = parasail_nw_scan_altivec_128_16;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_scan_16_pointer = parasail_nw_scan_neon_128_16;
    }
    else
#endif
    {
        parasail_nw_scan_16_pointer = parasail_nw_scan;
    }
    return parasail_nw_scan_16_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1c782e
leaq 0x6c434b(%rip), %rax    # 0x88bb70
movq %rax, 0xc5fa04(%rip)    # 0xe27230
jmp 0x1c7878
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1c784a
leaq 0x3d9aef(%rip), %rax    # 0x5a1330
movq %rax, 0xc5f9e8(%rip)    # 0xe27230
jmp 0x1c7876
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1c7866
leaq 0xffdb3(%rip), %rax     # 0x2c7610
movq %rax, 0xc5f9cc(%rip)    # 0xe27230
jmp 0x1c7874
leaq 0xd0673(%rip), %rax     # 0x297ee0
movq %rax, 0xc5f9bc(%rip)    # 0xe27230
jmp 0x1c7876
jmp 0x1c7878
movq 0xc5f9b1(%rip), %rax    # 0xe27230
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_scan_8_dispatcher
parasail_result_t* parasail_nw_scan_8_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_scan_8_pointer = parasail_nw_scan_avx2_256_8;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_scan_8_pointer = parasail_nw_scan_sse41_128_8;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_scan_8_pointer = parasail_nw_scan_sse2_128_8;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_scan_8_pointer = parasail_nw_scan_altivec_128_8;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_scan_8_pointer = parasail_nw_scan_neon_128_8;
    }
    else
#endif
    {
        parasail_nw_scan_8_pointer = parasail_nw_scan;
    }
    return parasail_nw_scan_8_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1c78ee
leaq 0x6cbbdb(%rip), %rax    # 0x8934c0
movq %rax, 0xc5f94c(%rip)    # 0xe27238
jmp 0x1c7938
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1c790a
leaq 0x3df39f(%rip), %rax    # 0x5a6ca0
movq %rax, 0xc5f930(%rip)    # 0xe27238
jmp 0x1c7936
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1c7926
leaq 0x1057e3(%rip), %rax    # 0x2cd100
movq %rax, 0xc5f914(%rip)    # 0xe27238
jmp 0x1c7934
leaq 0xd05b3(%rip), %rax     # 0x297ee0
movq %rax, 0xc5f904(%rip)    # 0xe27238
jmp 0x1c7936
jmp 0x1c7938
movq 0xc5f8f9(%rip), %rax    # 0xe27238
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_striped_64_dispatcher
parasail_result_t* parasail_nw_striped_64_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_striped_64_pointer = parasail_nw_striped_avx2_256_64;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_striped_64_pointer = parasail_nw_striped_sse41_128_64;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_striped_64_pointer = parasail_nw_striped_sse2_128_64;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_striped_64_pointer = parasail_nw_striped_altivec_128_64;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_striped_64_pointer = parasail_nw_striped_neon_128_64;
    }
    else
#endif
    {
        parasail_nw_striped_64_pointer = parasail_nw;
    }
    return parasail_nw_striped_64_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1c79ae
leaq 0x70385b(%rip), %rax    # 0x8cb200
movq %rax, 0xc5f894(%rip)    # 0xe27240
jmp 0x1c79f8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1c79ca
leaq 0x40329f(%rip), %rax    # 0x5cac60
movq %rax, 0xc5f878(%rip)    # 0xe27240
jmp 0x1c79f6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1c79e6
leaq 0x12a653(%rip), %rax    # 0x2f2030
movq %rax, 0xc5f85c(%rip)    # 0xe27240
jmp 0x1c79f4
leaq 0xce763(%rip), %rax     # 0x296150
movq %rax, 0xc5f84c(%rip)    # 0xe27240
jmp 0x1c79f6
jmp 0x1c79f8
movq 0xc5f841(%rip), %rax    # 0xe27240
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/nw_dispatch.c
// Function: parasail_nw_striped_32_dispatcher
parasail_result_t* parasail_nw_striped_32_dispatcher(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap,
        const parasail_matrix_t *matrix)
{
#if HAVE_AVX2
    if (parasail_can_use_avx2()) {
        parasail_nw_striped_32_pointer = parasail_nw_striped_avx2_256_32;
    }
    else
#endif
#if HAVE_SSE41
    if (parasail_can_use_sse41()) {
        parasail_nw_striped_32_pointer = parasail_nw_striped_sse41_128_32;
    }
    else
#endif
#if HAVE_SSE2
    if (parasail_can_use_sse2()) {
        parasail_nw_striped_32_pointer = parasail_nw_striped_sse2_128_32;
    }
    else
#endif
#if HAVE_ALTIVEC
    if (parasail_can_use_altivec()) {
        parasail_nw_striped_32_pointer = parasail_nw_striped_altivec_128_32;
    }
    else
#endif
#if HAVE_NEON
    if (parasail_can_use_neon()) {
        parasail_nw_striped_32_pointer = parasail_nw_striped_neon_128_32;
    }
    else
#endif
    {
        parasail_nw_striped_32_pointer = parasail_nw;
    }
    return parasail_nw_striped_32_pointer(s1, s1Len, s2, s2Len, open, gap, matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, %al
callq 0xc8c2e0
cmpl $0x0, %eax
je 0x1c7a6e
leaq 0x708c1b(%rip), %rax    # 0x8d0680
movq %rax, 0xc5f7dc(%rip)    # 0xe27248
jmp 0x1c7ab8
movb $0x0, %al
callq 0xc8c300
cmpl $0x0, %eax
je 0x1c7a8a
leaq 0x407c1f(%rip), %rax    # 0x5cf6a0
movq %rax, 0xc5f7c0(%rip)    # 0xe27248
jmp 0x1c7ab6
movb $0x0, %al
callq 0xc8c320
cmpl $0x0, %eax
je 0x1c7aa6
leaq 0x12f153(%rip), %rax    # 0x2f6bf0
movq %rax, 0xc5f7a4(%rip)    # 0xe27248
jmp 0x1c7ab4
leaq 0xce6a3(%rip), %rax     # 0x296150
movq %rax, 0xc5f794(%rip)    # 0xe27248
jmp 0x1c7ab6
jmp 0x1c7ab8
movq 0xc5f789(%rip), %rax    # 0xe27248
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)