LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/main.c
// Function: fill_matrix
void fill_matrix(int8_t *matrix, char *fn) {
	FILE *fp = fopen(fn, "r");
	char buffer[256];
	char *pch;
	int i = 0;

	while (0 < fgets(buffer, 256, fp)) {
		pch = strtok(buffer, ",\t");
		while (pch != NULL) {
			if (25 <= i) {
				fprintf(stderr, "Too many values in %s\n", fn);
				exit(1);
			}
			matrix[i] = atoi(pch);
			i++;
		}
	}
	if (i != 16 || i != 25) {
		fprintf(stderr, "Incorrect # of values (found %d, want 16 or 25) in %s\n", i, fn);
		exit(1);
	}

	fclose(fp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3c6615(%rip), %rsi    # 0x5cacdf
movq %rbx, %rdi
callq 0x19e110
movq %rax, %r15
movq %rsp, %rdi
movl $0x100, %esi            # imm = 0x100
movq %rax, %rdx
callq 0x19e1c0
testq %rax, %rax
je 0x204719
leaq 0x3c5dbf(%rip), %r13    # 0x5ca4b0
movq %rsp, %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x19e1b0
testq %rax, %rax
jne 0x204738
movq %rbp, %rdi
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdx
callq 0x19e1c0
testq %rax, %rax
jne 0x2046f4
movq 0x5d38b8(%rip), %rax    # 0x7d7fd8
movq (%rax), %rdi
leaq 0x3c5da0(%rip), %rsi    # 0x5ca4ca
xorl %edx, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x19e180
jmp 0x20476e
movq %rax, %r12
xorl %r15d, %r15d
movq %r12, %rdi
callq 0x19e1a0
movb %al, (%r14,%r15)
incq %r15
cmpq $0x19, %r15
jne 0x20473e
movq 0x5d387e(%rip), %rax    # 0x7d7fd8
movq (%rax), %rdi
leaq 0x3c5d4f(%rip), %rsi    # 0x5ca4b3
movq %rbx, %rdx
xorl %eax, %eax
callq 0x19e180
movl $0x1, %edi
callq 0x19e130
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/main.c
// Function: ksw2_data_init
ksw2_data_t *ksw2_data_init(main_opt_t *opt, const int8_t *matrix)
{
	ksw2_data_t *data = calloc(1, sizeof(ksw2_data_t));

	data->ksw2_flags = (opt->right_align_gaps == 1) ? KSW_EZ_RIGHT : 0;
	if (opt->add_cigar != 1) data->ksw2_flags |= KSW_EZ_SCORE_ONLY;
	memset(&data->ez, 0, sizeof(ksw_extz_t));
	
	//data->km = km_init(); FIXME

	data->matrix = calloc(1, sizeof(int8_t)*25);
	memcpy(data->matrix, matrix, sizeof(int8_t)*25);
	
	return data;

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movl $0x1, %edi
movl $0x48, %esi
callq 0x19e0b0
movq %rax, %r14
xorl %eax, %eax
cmpl $0x1, 0x30(%r15)
sete %al
addl %eax, %eax
movl %eax, 0x8(%r14)
cmpl $0x1, 0x24(%r15)
je 0x2047e9
orl $0x1, %eax
movl %eax, 0x8(%r14)
movl $0x1, %edi
movl $0x19, %esi
callq 0x19e0b0
movq %rax, (%r14)
movups (%rbx), %xmm0
movups 0x9(%rbx), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x9(%rax)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/main.c
// Function: parasail_to_func_name
void parasail_to_func_name(char *parasail_func_name, int alignment_mode, int add_cigar, int vec_strategy)
{
	parasail_func_name[0] = '\0';
	strcat(parasail_func_name, "parasail");


	// Vectorized
	switch (alignment_mode) {
		case Local: strcat(parasail_func_name, "_sw"); break; // local
		case Glocal: strcat(parasail_func_name, "_sg_dx"); break; // glocal
		case Extension: fprintf(stderr, "Parasail does not support extension\n"); exit(1);
		case Global: strcat(parasail_func_name, "_nw"); break; // global
		default: fprintf(stderr, "Unknown alignment mode: %d\n", alignment_mode); exit(1);
	}
	if (add_cigar == 1) strcat(parasail_func_name, "_trace");
	switch (vec_strategy) {
		case 0: strcat(parasail_func_name, "_striped"); break;
		case 1: strcat(parasail_func_name, "_scan"); break;
		case 2: strcat(parasail_func_name, "_diag"); break;
		default: fprintf(stderr, "Unknown parasail vectorization strategy: %d\n", vec_strategy); exit(1);
	}
	strcat(parasail_func_name, "_32"); // TODO: add this as a command line option?
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
xorl %r12d, %r12d
movb %r12b, (%rdi)
callq 0x19e070
movabsq $0x6c69617361726170, %rcx # imm = 0x6C69617361726170
movq %rcx, (%rbx,%rax)
movb %r12b, 0x8(%rbx,%rax)
cmpl $0x3, %r15d
ja 0x204951
movl %r15d, %eax
leaq 0x3c5b9b(%rip), %rcx    # 0x5ca410
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x19e070
movl $0x77735f, (%rbx,%rax)  # imm = 0x77735F
jmp 0x2048b7
movq %rbx, %rdi
callq 0x19e070
movl $0x5f67735f, (%rbx,%rax) # imm = 0x5F67735F
movl $0x78645f, 0x3(%rbx,%rax) # imm = 0x78645F
jmp 0x2048b7
movq %rbx, %rdi
callq 0x19e070
movl $0x776e5f, (%rbx,%rax)  # imm = 0x776E5F
cmpl $0x1, %r14d
jne 0x2048d4
movq %rbx, %rdi
callq 0x19e070
movl $0x6172745f, (%rbx,%rax) # imm = 0x6172745F
movl $0x656361, 0x3(%rbx,%rax) # imm = 0x656361
cmpl $0x2, %ebp
je 0x204917
cmpl $0x1, %ebp
je 0x2048ff
testl %ebp, %ebp
jne 0x204945
movq %rbx, %rdi
callq 0x19e070
movabsq $0x646570697274735f, %rcx # imm = 0x646570697274735F
movq %rcx, (%rbx,%rax)
movb $0x0, 0x8(%rbx,%rax)
jmp 0x20492d
movq %rbx, %rdi
callq 0x19e070
movl $0x6163735f, (%rbx,%rax) # imm = 0x6163735F
movw $0x6e, 0x4(%rbx,%rax)
jmp 0x20492d
movq %rbx, %rdi
callq 0x19e070
movl $0x6169645f, (%rbx,%rax) # imm = 0x6169645F
movw $0x67, 0x4(%rbx,%rax)
movq %rbx, %rdi
callq 0x19e070
movl $0x32335f, (%rbx,%rax)  # imm = 0x32335F
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %edi
callq 0x19e681
callq 0x19e65c
movl %r15d, %edi
callq 0x19e6a4
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/main.c
// Function: parasail_data_init
parasail_data_t *parasail_data_init(main_opt_t *opt, const int8_t *matrix)
{
	int i, j, l;
	parasail_data_t *data = calloc(1, sizeof(parasail_data_t));
	char parasail_func_name[128];
	
	// create a matrix, don't care about the valukes
	data->matrix = parasail_matrix_create("ACGTN", matrix[0], matrix[1]); 
	// update the matrix with the correct values
	for (i = l = 0; i < 5; ++i) {
		for (j = 0; j < 5; ++j, ++l) {
			parasail_matrix_set_value(data->matrix, i, j, matrix[l]);
		}
	}

	parasail_to_func_name(parasail_func_name, opt->alignment_mode, opt->add_cigar, opt->parasail_vec_strat);
	data->func = parasail_lookup_function(parasail_func_name);

	// the global alignment function is needed for glocal when we don't align the full query
	if (opt->alignment_mode == Glocal) {
		data->func_global = data->func;
	}
	else {
		parasail_to_func_name(parasail_func_name, Global, opt->add_cigar, opt->parasail_vec_strat);
		data->func_global = parasail_lookup_function(parasail_func_name);
	}

	return data;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r15
movq %rdi, (%rsp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x19e0b0
movq %rax, %rbx
movsbl (%r15), %esi
movsbl 0x1(%r15), %edx
leaq 0x3c5c07(%rip), %rdi    # 0x5ca59a
callq 0x20b196
movq %rax, %r12
movq %rbx, 0x8(%rsp)
movq %rax, (%rbx)
xorl %r13d, %r13d
xorl %ebx, %ebx
movslq %ebx, %rbx
leaq (%r15,%rbx), %r14
xorl %ebp, %ebp
movsbl (%r14,%rbp), %ecx
movq %r12, %rdi
movl %r13d, %esi
movl %ebp, %edx
callq 0x20bb27
incq %rbp
cmpl $0x5, %ebp
jne 0x2049b1
incl %r13d
addq %rbp, %rbx
cmpl $0x5, %r13d
jne 0x2049a8
movq (%rsp), %r14
movl 0x20(%r14), %esi
movl 0x24(%r14), %edx
movl 0x3c(%r14), %ecx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x204830
movq %r15, %rdi
callq 0x20a42c
movq 0x8(%rsp), %rbx
movq %rax, 0x8(%rbx)
cmpl $0x1, 0x20(%r14)
je 0x204a2e
movl 0x24(%r14), %edx
movl 0x3c(%r14), %ecx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl $0x3, %esi
callq 0x204830
movq %r14, %rdi
callq 0x20a42c
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/main.c
// Function: main_opt_init_library
void main_opt_init_library(main_opt_t *opt)
{
	int i, j, k;
	int8_t matrix[25];

	// initialize scoring matrix
	for (i = k = 0; i < 4; ++i) {
		for (j = 0; j < 4; ++j) {
			matrix[k++] = i == j? opt->match_score: -opt->mismatch_score;
		}
		matrix[k++] = 0; // ambiguous base
	}
	for (j = 0; j < 5; ++j) matrix[k++] = 0;
	// overwrite if a matrix file was given
	if (opt->matrix_fn != NULL) fill_matrix(matrix, opt->matrix_fn);

	// adjust the library mode if it is set on auto
	if (opt->library == AutoLibrary) {
		switch (opt->alignment_mode) {
			case Local: 
			case Glocal: 
			case Global: opt->library = Parasail; break;
			case Extension: opt->library = Ksw2; break;
			default:
				fprintf(stderr, "Unknown alignment mode in %s: %d\n", __func__, opt->alignment_mode); 
				exit(1);
		}
	}

	switch (opt->library) {
		case Ksw2: 
			opt->_library_func = align_with_ksw2;
			opt->_library_data = (void*)ksw2_data_init(opt, matrix); 
			break;
		case Parasail: 
			opt->_library_func = align_with_parasail;
			opt->_library_data = (void*)parasail_data_init(opt, matrix); 
			break;
		default:
			fprintf(stderr, "Unknown library in %s: %d", __func__, opt->library);
			exit(1);
	}
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorl %ecx, %ecx
movabsq $0x100000000, %rax      # imm = 0x100000000
xorl %edx, %edx
movslq %ecx, %rsi
leaq (%rsp,%rsi), %rdi
shlq $0x20, %rsi
xorl %r8d, %r8d
movl %edx, %r9d
addl %r8d, %r9d
je 0x204ab4
xorl %r9d, %r9d
subl 0x4(%rbx), %r9d
jmp 0x204ab7
movl (%rbx), %r9d
movb %r9b, (%rdi)
decl %r8d
incq %rdi
addq %rax, %rsi
cmpl $-0x4, %r8d
jne 0x204aa3
movl %ecx, %edi
subl %r8d, %edi
leal 0x1(%rdi), %ecx
sarq $0x20, %rsi
movb $0x0, (%rsp,%rsi)
incl %edx
cmpl $0x4, %edx
jne 0x204a95
incl %edi
movslq %edi, %rax
movb $0x0, 0x4(%rsp,%rax)
movl $0x0, (%rsp,%rax)
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
jne 0x204b60
movl 0x38(%rbx), %edi
cmpl $0x2, %edi
je 0x204b21
cmpl $0x1, %edi
je 0x204b40
testl %edi, %edi
jne 0x204b68
movl 0x20(%rbx), %edi
cmpl $0x2, %edi
jb 0x204b1a
je 0x204b39
cmpl $0x3, %edi
jne 0x204b6d
movl $0x2, 0x38(%rbx)
leaq 0x29c(%rip), %rax       # 0x204dc4
movq %rax, 0x40(%rbx)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x204959
jmp 0x204b56
movl $0x1, 0x38(%rbx)
leaq 0x2b(%rip), %rax        # 0x204b72
movq %rax, 0x40(%rbx)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2047ae
movq %rax, 0x48(%rbx)
addq $0x20, %rsp
popq %rbx
retq
movq %rsp, %rdi
callq 0x2046ac
callq 0x19e6f1
callq 0x19e6c7
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/main.c
// Function: main_opt_destroy
void main_opt_destroy(main_opt_t *opt)
{
	switch (opt->library) {
		case Ksw2: ksw2_data_destroy((ksw2_data_t*)opt->_library_data); break;
		case Parasail: parasail_data_destroy((parasail_data_t*)opt->_library_data); break;
		default:
			fprintf(stderr, "Unknown library in %s: %d", __func__, opt->library);
			exit(1);
	}
	free(opt);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x38(%rdi), %edi
cmpl $0x2, %edi
je 0x204fc1
cmpl $0x1, %edi
jne 0x204fe4
movq 0x48(%rbx), %rdi
callq 0x204812
jmp 0x204fd5
movq 0x48(%rbx), %r14
movq (%r14), %rdi
callq 0x20bb62
movq %r14, %rdi
callq 0x19e120
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19e120
callq 0x19e7b4
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/main.c
// Function: assert_or_exit
void assert_or_exit(int condition, const char *fmt, ...)
{
	if (condition == 0) {
		fprintf(stderr, "Error: ");
		va_list args;
		va_start(args, fmt);
		vfprintf(stderr, fmt, args);
		va_end(args);
		fprintf(stderr, "\n");
		exit(1);
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x205042
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testl %edi, %edi
je 0x205051
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
movq %rsi, %rbx
movq 0x5d2f7d(%rip), %r14    # 0x7d7fd8
movq (%r14), %rcx
leaq 0x3c559e(%rip), %rdi    # 0x5ca603
movl $0x7, %esi
movl $0x1, %edx
callq 0x19e200
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x19e160
movq (%r14), %rsi
movl $0xa, %edi
callq 0x19e140
movl $0x1, %edi
callq 0x19e130
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/main.c
// Function: alignment_print
void alignment_print(FILE *fp, const char *query, const char *target, const main_opt_t *opt, const alignment_t *a) 
{
	int i;
	// output the score and start/end or start/length
	if (opt->offset_and_length == 1) {
		int qll = a->qle - a->qlb + 1;
		int tll = a->tle - a->tlb + 1;
		fprintf(fp, "%d\t%d\t%d\t%d\t%d", a->score, a->qlb, qll, a->tlb, tll);
	}
	else {
		fprintf(fp, "%d\t%d\t%d\t%d\t%d", a->score, a->qlb, a->qle, a->tlb, a->tle);
	}
	// output the cigar
	if (opt->add_cigar == 1) {
		fputc('\t', fp);
		if (a->n_cigar == 0) fputc('*', fp);
		for (i = 0; i < a->n_cigar; ++i) {
			fprintf(fp, "%d%c", a->cigar[i]>>4, "MID"[a->cigar[i]&0xf]);
		}
	}
	// output the query and target
	if (opt->add_seq) fprintf(fp, "\t%s\t%s", query, target);
	// flush the output so no one is waiting on buffering.
	fputc('\n', fp);
	fflush(fp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r13
movq %rcx, %r12
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
cmpl $0x1, 0x34(%rcx)
jne 0x20527a
movl 0xc(%r13), %r8d
movl (%r13), %edx
movl 0x4(%r13), %ecx
subl %ecx, %r8d
incl %r8d
movl 0x10(%r13), %eax
movl 0x8(%r13), %r9d
subl %r9d, %eax
incl %eax
jmp 0x20528e
movl (%r13), %edx
movl 0x4(%r13), %ecx
movl 0xc(%r13), %r8d
movl 0x8(%r13), %r9d
movl 0x10(%r13), %eax
movl %eax, (%rsp)
leaq 0x3c557d(%rip), %rsi    # 0x5ca815
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19e180
cmpl $0x1, 0x24(%r12)
jne 0x205313
movl $0x9, %edi
movq %rbx, %rsi
callq 0x19e140
movl 0x20(%r13), %eax
testl %eax, %eax
jne 0x2052d0
movl $0x2a, %edi
movq %rbx, %rsi
callq 0x19e140
movl 0x20(%r13), %eax
testl %eax, %eax
jle 0x205313
leaq 0x3c554e(%rip), %r14    # 0x5ca829
leaq 0x3c5542(%rip), %rbp    # 0x5ca824
xorl %r15d, %r15d
movq 0x18(%r13), %rax
movl (%rax,%r15,4), %eax
movl %eax, %edx
shrl $0x4, %edx
andl $0xf, %eax
movsbl (%rax,%r14), %ecx
movq %rbx, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x19e180
incq %r15
movslq 0x20(%r13), %rax
cmpq %rax, %r15
jl 0x2052e5
cmpl $0x0, 0x28(%r12)
je 0x205336
leaq 0x3c550b(%rip), %rsi    # 0x5ca82d
movq %rbx, %rdi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
xorl %eax, %eax
callq 0x19e180
movl $0xa, %edi
movq %rbx, %rsi
callq 0x19e140
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x19e100
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/main.c
// Function: align
void align(char *query, char *target, main_opt_t *opt, alignment_t *alignment) 
{
	int ql = strlen(query); // query length
	int tl = strlen(target); // target length

	// remove ending newlines
	if (query[ql-1] == '\n') { query[ql-1] = '\0'; ql--; }
	if (target[tl-1] == '\n') { target[tl-1] = '\0'; tl--; }

	// reset the alignment
	alignment_reset(alignment);

	// do the alignment
	opt->_library_func(query, ql, target, tl, opt, opt->_library_data, alignment);

	// print it
	alignment_print(stdout, query, target, opt, alignment);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movabsq $-0x100000000, %rbp     # imm = 0xFFFFFFFF00000000
callq 0x19e070
movq %rax, %r13
movq %r15, %rdi
callq 0x19e070
leal -0x1(%r13), %ecx
movslq %ecx, %rdx
cmpb $0xa, (%r12,%rdx)
jne 0x2053b6
movb $0x0, (%r12,%rdx)
movl %ecx, %r13d
movq %rax, %rcx
shlq $0x20, %rcx
addq %rbp, %rcx
sarq $0x20, %rcx
cmpb $0xa, (%r15,%rcx)
jne 0x2053d2
movb $0x0, (%r15,%rcx)
decl %eax
movl $0x0, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rbx)
movq 0x48(%r14), %r9
movq %rbx, (%rsp)
movq %r12, %rdi
movl %r13d, %esi
movq %r15, %rdx
movl %eax, %ecx
movq %r14, %r8
callq *0x40(%r14)
movq 0x5d2baf(%rip), %rax    # 0x7d7fb0
movq (%rax), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x205232
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/cigar.c
// Function: parasail_cigar_encode_string
parasail_cigar_t* parasail_cigar_encode_string(const char *cigar)
{
    int sscanf_retcode = 0;
    size_t offset = 0;
    int chars_read = 0;
    unsigned int len = 0;
    char op = 'M';
    int done = 0;
    size_t string_length = 0;
    size_t size = 0;
    parasail_cigar_t *ret = NULL;

    string_length = strlen(cigar);
    size = sizeof(uint32_t)*string_length;
    ret = malloc(sizeof(parasail_cigar_t));
    ret->seq = malloc(size);
    ret->len = 0;

    while (!done) {
        sscanf_retcode = sscanf(
                &cigar[offset], "%u%c%n", &len, &op, &chars_read);
        if (2 != sscanf_retcode) {
            fprintf(stderr, "invalid CIGAR string\n");
            parasail_cigar_free(ret);
            return NULL;
        }
        offset += chars_read;
        ret->len += 1;
        if ((size_t)ret->len >= size) {
            size *= 2;
            ret->seq = realloc(ret->seq, size);
        }
        ret->seq[ret->len-1] = parasail_cigar_encode(len, op);
        if (offset >= string_length) {
            done = 1;
        }
    }

    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorl %ebx, %ebx
leaq 0x14(%rsp), %rax
movl %ebx, (%rax)
leaq 0x10(%rsp), %rax
movl %ebx, (%rax)
leaq 0xf(%rsp), %rax
movb $0x4d, (%rax)
movq %rdi, 0x20(%rsp)
callq 0x19e070
movq %rax, 0x18(%rsp)
leaq (,%rax,4), %r14
movl $0x18, %edi
callq 0x19e150
movq %rax, %r13
movq %r14, %rdi
callq 0x19e150
movq %rax, %r15
movq %rax, (%r13)
movl %ebx, 0x8(%r13)
movl $0x1, %r12d
xorl %ebx, %ebx
movq 0x20(%rsp), %rax
leaq (%rax,%rbx), %rdi
leaq 0x3c53bf(%rip), %rsi    # 0x5cad80
leaq 0x10(%rsp), %rdx
leaq 0xf(%rsp), %rcx
leaq 0x14(%rsp), %r8
xorl %eax, %eax
callq 0x19e0d0
cmpl $0x2, %eax
jne 0x205a3d
movslq 0x14(%rsp), %rbp
movl %r12d, 0x8(%r13)
cmpq %r12, %r14
ja 0x2059ff
addq %r14, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x19e1e0
movq %rax, %r15
movq %rax, (%r13)
addq %rbp, %rbx
movl 0x10(%rsp), %eax
movsbq 0xf(%rsp), %rcx
shll $0x4, %eax
leaq 0x3c52ea(%rip), %rdx    # 0x5cad00
movzbl (%rcx,%rdx), %ecx
orl %eax, %ecx
movl %ecx, -0x4(%r15,%r12,4)
incq %r12
cmpq 0x18(%rsp), %rbx
jb 0x2059b1
movq %r13, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %r13, %rsi
callq 0x19e7de
xorl %r13d, %r13d
jmp 0x205a2b
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movslq 0x8(%rdi), %r13
leaq 0x1(,%r13,4), %rdi
callq 0x19e150
movq %rax, %rbx
movb $0x0, (%rax)
testq %r13, %r13
jle 0x205b31
shlq $0x2, %r13
movq %rsp, %r12
xorl %ebp, %ebp
xorl %r15d, %r15d
movq (%r14), %rax
movl (%rax,%rbp,4), %ecx
movl %ecx, %eax
andl $0xf, %eax
movl $0x4d, %r8d
cmpl $0x9, %eax
ja 0x205adc
leaq 0x3c52c6(%rip), %rdx    # 0x5cad9d
movsbl (%rax,%rdx), %r8d
shrl $0x4, %ecx
movl $0x28, %esi
movq %r12, %rdi
leaq 0x3c52ba(%rip), %rdx    # 0x5cada8
xorl %eax, %eax
callq 0x19e1d0
cmpl $0x27, %eax
jg 0x205b43
cltq
addq %rax, %r15
cmpq %r13, %r15
jb 0x205b1a
leaq 0x1(,%r13,2), %rsi
addq %r13, %r13
movq %rbx, %rdi
callq 0x19e1e0
movq %rax, %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x19e1f0
incq %rbp
movslq 0x8(%r14), %rax
cmpq %rax, %rbp
jl 0x205aba
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x19e81c
xorl %ebx, %ebx
jmp 0x205b31
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x5232be(%rip), %rbx    # 0x72d710
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x19e170
testl %eax, %eax
je 0x20a4d2
cmpq $0x0, 0x48(%rbx)
leaq 0x48(%rbx), %rbx
jne 0x20a452
movq %r14, %rdi
callq 0x19e070
leaq 0xa(%rax), %rdi
callq 0x19e150
movq %rax, %r15
movabsq $0x6c69617361726170, %rax # imm = 0x6C69617361726170
movq %rax, (%r15)
movw $0x5f, 0x8(%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0x19e1f0
leaq 0x523269(%rip), %r14    # 0x72d710
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x19e170
testl %eax, %eax
je 0x20a4c7
leaq 0x48(%r14), %rbx
cmpq $0x0, 0x48(%r14)
movq %rbx, %r14
jne 0x20a4a7
jmp 0x20a4ca
movq %r14, %rbx
movq %r15, %rdi
callq 0x19e120
movq (%rbx), %rax
testq %rax, %rax
cmoveq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x5866d5(%rip), %rbx    # 0x790be0
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x19e170
testl %eax, %eax
je 0x20a58b
cmpq $0x0, 0x50(%rbx)
leaq 0x50(%rbx), %rbx
jne 0x20a50b
movq %r14, %rdi
callq 0x19e070
leaq 0xa(%rax), %rdi
callq 0x19e150
movq %rax, %r15
movabsq $0x6c69617361726170, %rax # imm = 0x6C69617361726170
movq %rax, (%r15)
movw $0x5f, 0x8(%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0x19e1f0
leaq 0x586680(%rip), %r14    # 0x790be0
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x19e170
testl %eax, %eax
je 0x20a580
leaq 0x50(%r14), %rbx
cmpq $0x0, 0x50(%r14)
movq %rbx, %r14
jne 0x20a560
jmp 0x20a583
movq %r14, %rbx
movq %r15, %rdi
callq 0x19e120
movq (%rbx), %rax
testq %rax, %rax
cmoveq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
movq %rsi, %rdx
movq %rdi, %rsi
movq %rsp, %rdi
movq $0x0, (%rdi)
callq 0x19e080
testl %eax, %eax
jne 0x20a5dd
movq (%rsp), %rax
testq %rax, %rax
je 0x20a5e8
popq %rcx
retq
movl %eax, %edi
callq 0x19e929
xorl %eax, %eax
jmp 0x20a5db
movq 0x5cd9e9(%rip), %rax    # 0x7d7fd8
movq (%rax), %rdi
leaq 0x41e938(%rip), %rsi    # 0x628f31
leaq 0x41e91f(%rip), %rdx    # 0x628f1f
xorl %eax, %eax
callq 0x19e180
movq (%rsp), %rax
jmp 0x20a5db
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %edi, %edi
jle 0x20ac37
movl %esi, %r14d
testl %esi, %esi
jle 0x20ac37
movl %edi, %ebp
callq 0x20ab71
testq %rax, %rax
je 0x20ac43
movq %rax, %rbx
movl $0x8, %edi
callq 0x19e150
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x20ac3e
movq %rax, %r15
imull %ebp, %r14d
shlq $0x2, %r14
movq %r14, %rdi
callq 0x19e150
movq %rax, (%r15)
testq %rax, %rax
jne 0x20ac45
movq 0x5cd3c0(%rip), %rax    # 0x7d7fd8
movq (%rax), %rdi
leaq 0x41e31b(%rip), %rsi    # 0x628f3d
leaq 0x41e37a(%rip), %rdx    # 0x628fa3
xorl %ebx, %ebx
movq %r14, %rcx
xorl %eax, %eax
callq 0x19e180
jmp 0x20ac45
callq 0x19e9bc
jmp 0x20ac43
callq 0x19e99a
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %edi, %edi
jle 0x20ace3
movl %esi, %r15d
testl %esi, %esi
jle 0x20ace3
movl %edi, %ebp
callq 0x20ab71
testq %rax, %rax
je 0x20acef
movq %rax, %rbx
movl $0x10, %edi
callq 0x19e150
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x20acea
movq %rax, %r14
movl %r15d, %r15d
shlq $0x2, %r15
movq %r15, %rdi
callq 0x19e150
movq %rax, (%r14)
testq %rax, %rax
je 0x20acbd
movl %ebp, %r15d
shlq $0x2, %r15
movq %r15, %rdi
callq 0x19e150
movq %rax, 0x8(%r14)
testq %rax, %rax
jne 0x20acf1
movq 0x5cd314(%rip), %rax    # 0x7d7fd8
movq (%rax), %rdi
leaq 0x41e26f(%rip), %rsi    # 0x628f3d
leaq 0x41e2e9(%rip), %rdx    # 0x628fbe
xorl %ebx, %ebx
movq %r15, %rcx
xorl %eax, %eax
callq 0x19e180
jmp 0x20acf1
callq 0x19e9fd
jmp 0x20acef
callq 0x19e9db
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/memory.c
// Function: parasail_result_new_table3
parasail_result_t* parasail_result_new_table3(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 tables */
    PARASAIL_NEW(result->stats, parasail_result_extra_stats_t);
    PARASAIL_NEW(result->stats->tables, parasail_result_extra_stats_tables_t);
    PARASAIL_CALLOC(result->stats->tables->score_table, int, a*b);
    PARASAIL_CALLOC(result->stats->tables->matches_table, int, a*b);
    PARASAIL_CALLOC(result->stats->tables->similar_table, int, a*b);
    PARASAIL_CALLOC(result->stats->tables->length_table, int, a*b);

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testl %edi, %edi
jle 0x20add3
movl %esi, %r14d
testl %esi, %esi
jle 0x20add3
movl %edi, %ebp
callq 0x20ab71
testq %rax, %rax
je 0x20ade6
movq %rax, %rbx
movl $0x18, %edi
callq 0x19e150
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x20adda
movq %rax, %r12
movl $0x20, %edi
callq 0x19e150
movq %rax, 0x10(%r12)
testq %rax, %rax
je 0x20ade1
movq %rax, %r15
imull %ebp, %r14d
shlq $0x2, %r14
movq %r14, %rdi
callq 0x19e150
movq %rax, (%r15)
testq %rax, %rax
je 0x20adad
movq %r14, %rdi
callq 0x19e150
movq %rax, 0x8(%r15)
testq %rax, %rax
je 0x20adad
movq %r14, %rdi
callq 0x19e150
movq %rax, 0x10(%r15)
testq %rax, %rax
je 0x20adad
movq %r14, %rdi
callq 0x19e150
movq %rax, 0x18(%r15)
testq %rax, %rax
jne 0x20ade8
movq 0x5cd224(%rip), %rax    # 0x7d7fd8
movq (%rax), %rdi
leaq 0x41e17f(%rip), %rsi    # 0x628f3d
leaq 0x41e215(%rip), %rdx    # 0x628fda
xorl %ebx, %ebx
movq %r14, %rcx
xorl %eax, %eax
callq 0x19e180
jmp 0x20ade8
callq 0x19ea60
jmp 0x20ade6
callq 0x19ea3e
jmp 0x20ade6
callq 0x19ea1c
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edi, %edi
jle 0x20ae5d
movl %esi, %ebp
testl %esi, %esi
jle 0x20ae5d
movq %rcx, %r15
movq %rdx, %r14
movl %edi, %r12d
callq 0x20ab71
testq %rax, %rax
je 0x20ae69
movq %rax, %rbx
movl $0x18, %edi
callq 0x19e150
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x20ae64
movq %rax, %r13
movl %r12d, %eax
movl %ebp, %esi
imulq %rax, %rsi
imulq %r15, %rsi
movq %r14, %rdi
callq 0x20a5b8
movq %rax, (%r13)
testq %rax, %rax
je 0x20ae69
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r13)
jmp 0x20ae6b
callq 0x19eaa1
jmp 0x20ae69
callq 0x19ea7f
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/memory.c
// Function: parasail_result_new_rowcol3
parasail_result_t* parasail_result_new_rowcol3(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;
    
    PARASAIL_NEW(result->stats, parasail_result_extra_stats_t);
    PARASAIL_NEW(result->stats->rowcols, parasail_result_extra_stats_rowcols_t);
    PARASAIL_CALLOC(result->stats->rowcols->score_row, int, b);
    PARASAIL_CALLOC(result->stats->rowcols->matches_row, int, b);
    PARASAIL_CALLOC(result->stats->rowcols->similar_row, int, b);
    PARASAIL_CALLOC(result->stats->rowcols->length_row, int, b);

    PARASAIL_CALLOC(result->stats->rowcols->score_col, int, a);
    PARASAIL_CALLOC(result->stats->rowcols->matches_col, int, a);
    PARASAIL_CALLOC(result->stats->rowcols->similar_col, int, a);
    PARASAIL_CALLOC(result->stats->rowcols->length_col, int, a);

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testl %edi, %edi
jle 0x20af9b
movl %esi, %r15d
testl %esi, %esi
jle 0x20af9b
movl %edi, %ebp
callq 0x20ab71
testq %rax, %rax
je 0x20afae
movq %rax, %rbx
movl $0x18, %edi
callq 0x19e150
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x20afa2
movq %rax, %r12
movl $0x40, %edi
callq 0x19e150
movq %rax, 0x10(%r12)
testq %rax, %rax
je 0x20afa9
movq %rax, %r14
movl %r15d, %r15d
shlq $0x2, %r15
movq %r15, %rdi
callq 0x19e150
movq %rax, (%r14)
testq %rax, %rax
je 0x20af75
movq %r15, %rdi
callq 0x19e150
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x20af75
movq %r15, %rdi
callq 0x19e150
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x20af75
movq %r15, %rdi
callq 0x19e150
movq %rax, 0x18(%r14)
testq %rax, %rax
je 0x20af75
movl %ebp, %r15d
shlq $0x2, %r15
movq %r15, %rdi
callq 0x19e150
movq %rax, 0x20(%r14)
testq %rax, %rax
je 0x20af75
movq %r15, %rdi
callq 0x19e150
movq %rax, 0x28(%r14)
testq %rax, %rax
je 0x20af75
movq %r15, %rdi
callq 0x19e150
movq %rax, 0x30(%r14)
testq %rax, %rax
je 0x20af75
movq %r15, %rdi
callq 0x19e150
movq %rax, 0x38(%r14)
testq %rax, %rax
jne 0x20afb0
movq 0x5cd05c(%rip), %rax    # 0x7d7fd8
movq (%rax), %rdi
leaq 0x41dfb7(%rip), %rsi    # 0x628f3d
leaq 0x41e082(%rip), %rdx    # 0x62900f
xorl %ebx, %ebx
movq %r15, %rcx
xorl %eax, %eax
callq 0x19e180
jmp 0x20afb0
callq 0x19eb04
jmp 0x20afae
callq 0x19eae2
jmp 0x20afae
callq 0x19eac0
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
testq %rdi, %rdi
je 0x20bb54
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x20bb5b
imull 0x18(%rdi), %esi
addl %edx, %esi
movslq %esi, %rdx
movl %ecx, (%rax,%rdx,4)
cmpl %ecx, 0x1c(%rdi)
jge 0x20bb4a
movl %ecx, 0x1c(%rdi)
cmpl %ecx, 0x20(%rdi)
jle 0x20bb52
movl %ecx, 0x20(%rdi)
popq %rax
retq
callq 0x19ed93
jmp 0x20bb52
callq 0x19ed6e
jmp 0x20bb52
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
testq %rdi, %rdi
je 0x20bba4
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
je 0x20bbab
movq 0x8(%rbx), %rdi
callq 0x19e120
movq 0x10(%rbx), %rdi
callq 0x19e120
movq 0x38(%rbx), %rdi
callq 0x19e120
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x20bb9b
callq 0x19e120
movq %rbx, %rdi
popq %rbx
jmp 0x19e120
callq 0x19edde
jmp 0x20bbb3
movq %rbx, %rdi
callq 0x19edb9
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/memory.c
// Function: parasail_profile_new
parasail_profile_t* parasail_profile_new(
        const char * s1, const int s1Len, const parasail_matrix_t *matrix)
{
    /* declare all variables */
    parasail_profile_t *profile = NULL;

    PARASAIL_CHECK_NULL(matrix);
    if (matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) {
        PARASAIL_CHECK_NULL(s1);
    }

    PARASAIL_NEW(profile, parasail_profile_t);

    profile->s1 = s1;
    profile->s1Len = s1Len;
    profile->matrix = matrix;
    profile->profile8.score = NULL;
    profile->profile8.matches = NULL;
    profile->profile8.similar = NULL;
    profile->profile16.score = NULL;
    profile->profile16.matches = NULL;
    profile->profile16.similar = NULL;
    profile->profile32.score = NULL;
    profile->profile32.matches = NULL;
    profile->profile32.similar = NULL;
    profile->profile64.score = NULL;
    profile->profile64.matches = NULL;
    profile->profile64.similar = NULL;
    profile->free = NULL;
    profile->stop = INT32_MAX;

    if (matrix->type == PARASAIL_MATRIX_TYPE_PSSM) {
        profile->s1Len = matrix->length;
    }

    return profile;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x20bc31
movq %rdx, %rbx
movq %rdi, %r14
movl 0x30(%rdx), %r15d
testl %r15d, %r15d
setne %al
testq %rdi, %rdi
setne %cl
orb %al, %cl
je 0x20bc38
movl %esi, %ebp
movl $0x88, %edi
callq 0x19e150
testq %rax, %rax
je 0x20bc3f
movq %r14, (%rax)
movl %ebp, 0x8(%rax)
movq %rbx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movups %xmm0, 0x48(%rax)
movups %xmm0, 0x58(%rax)
movups %xmm0, 0x68(%rax)
movq $0x0, 0x78(%rax)
movl $0x7fffffff, 0x80(%rax) # imm = 0x7FFFFFFF
cmpl $0x1, %r15d
jne 0x20bc46
movl 0x34(%rbx), %ecx
movl %ecx, 0x8(%rax)
jmp 0x20bc46
callq 0x19ee4e
jmp 0x20bc44
callq 0x19ee04
jmp 0x20bc44
callq 0x19ee2a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/memory.c
// Function: parasail_profile_free
void parasail_profile_free(parasail_profile_t *profile)
{
    if (!profile) {
        fprintf(stderr, "%s: attempted free of NULL profile pointer\n", __func__);
        return;
    }

    if (NULL != profile->profile8.score) {
        profile->free(profile->profile8.score);
    }
    if (NULL != profile->profile8.matches) {
        profile->free(profile->profile8.matches);
    }
    if (NULL != profile->profile8.similar) {
        profile->free(profile->profile8.similar);
    }

    if (NULL != profile->profile16.score) {
        profile->free(profile->profile16.score);
    }
    if (NULL != profile->profile16.matches) {
        profile->free(profile->profile16.matches);
    }
    if (NULL != profile->profile16.similar) {
        profile->free(profile->profile16.similar);
    }

    if (NULL != profile->profile32.score) {
        profile->free(profile->profile32.score);
    }
    if (NULL != profile->profile32.matches) {
        profile->free(profile->profile32.matches);
    }
    if (NULL != profile->profile32.similar) {
        profile->free(profile->profile32.similar);
    }

    if (NULL != profile->profile64.score) {
        profile->free(profile->profile64.score);
    }
    if (NULL != profile->profile64.matches) {
        profile->free(profile->profile64.matches);
    }
    if (NULL != profile->profile64.similar) {
        profile->free(profile->profile64.similar);
    }

    free(profile);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x20bcf7
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x20bc6a
callq *0x78(%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x20bc76
callq *0x78(%rbx)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x20bc82
callq *0x78(%rbx)
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x20bc8e
callq *0x78(%rbx)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x20bc9a
callq *0x78(%rbx)
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x20bca6
callq *0x78(%rbx)
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x20bcb2
callq *0x78(%rbx)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x20bcbe
callq *0x78(%rbx)
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x20bcca
callq *0x78(%rbx)
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x20bcd6
callq *0x78(%rbx)
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x20bce2
callq *0x78(%rbx)
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x20bcee
callq *0x78(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x19e120
callq 0x19ee74
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1(%rsi), %r12
movq %r12, %rdi
callq 0x19e150
movq %rax, %rbx
testq %rax, %rax
je 0x20bd4b
movb $0x0, (%rbx,%r14)
testq %r14, %r14
je 0x20bd3c
movq %rbx, %rax
movb -0x1(%r15,%r14), %cl
movb %cl, (%rax)
incq %rax
decq %r14
jne 0x20bd2d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x5cc286(%rip), %rax    # 0x7d7fd8
movq (%rax), %rdi
leaq 0x41d1e1(%rip), %rsi    # 0x628f3d
leaq 0x41d46e(%rip), %rdx    # 0x6291d1
movq %r12, %rcx
xorl %eax, %eax
callq 0x19e180
jmp 0x20bd3c
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq (,%rsi,4), %r12
movq %r12, %rdi
callq 0x19e150
movq %rax, %rbx
testq %rax, %rax
je 0x20bdbf
testq %r14, %r14
je 0x20bdb0
movq %rbx, %rax
movl -0x4(%r15,%r14,4), %ecx
decq %r14
movl %ecx, (%rax)
addq $0x4, %rax
testq %r14, %r14
jne 0x20bd9d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x5cc212(%rip), %rax    # 0x7d7fd8
movq (%rax), %rdi
leaq 0x41d16d(%rip), %rsi    # 0x628f3d
leaq 0x41d40b(%rip), %rdx    # 0x6291e2
movq %r12, %rcx
xorl %eax, %eax
callq 0x19e180
jmp 0x20bdb0
// File: /workspace/github_c_makefile_star2_O3/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 %rax
testq %rdi, %rdi
je 0x20c059
movl 0xc(%rdi), %eax
btl $0x11, %eax
jae 0x20c060
notl %eax
movq 0x10(%rdi), %rcx
testl $0x30000, %eax          # imm = 0x30000
jne 0x20c054
movq 0x10(%rcx), %rax
movq (%rax), %rax
jmp 0x20c067
movq (%rcx), %rax
jmp 0x20c067
callq 0x19f249
jmp 0x20c065
callq 0x19f223
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
testq %rdi, %rdi
je 0x20c127
movl 0xc(%rdi), %eax
movl %eax, %ecx
notl %ecx
testl $0x50000, %ecx          # imm = 0x50000
jne 0x20c118
movq 0x10(%rdi), %rax
movq 0x10(%rax), %rax
jmp 0x20c122
btl $0x12, %eax
jae 0x20c12e
movq 0x10(%rdi), %rax
movq (%rax), %rax
popq %rcx
retq
callq 0x19f379
jmp 0x20c133
callq 0x19f353
xorl %eax, %eax
jmp 0x20c125
// File: /workspace/github_c_makefile_star2_O3/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 %rax
testq %rdi, %rdi
je 0x20c1fa
movl 0xc(%rdi), %eax
movl %eax, %ecx
notl %ecx
testl $0x50000, %ecx          # imm = 0x50000
jne 0x20c1ea
movq 0x10(%rdi), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
jmp 0x20c1f8
btl $0x12, %eax
jae 0x20c201
movq 0x10(%rdi), %rax
movq 0x8(%rax), %rax
popq %rcx
retq
callq 0x19f4a9
jmp 0x20c206
callq 0x19f483
xorl %eax, %eax
jmp 0x20c1f8
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
callq 0x5c8fdb
testl %eax, %eax
je 0x20c33d
leaq 0x2a050d(%rip), %rax    # 0x4ac848
jmp 0x20c36c
xorl %eax, %eax
callq 0x5c9002
testl %eax, %eax
je 0x20c351
leaq 0x1b4f71(%rip), %rax    # 0x3c12c0
jmp 0x20c36c
xorl %eax, %eax
callq 0x5c9038
testl %eax, %eax
jne 0x20c365
leaq 0x8f201(%rip), %rax     # 0x29b564
jmp 0x20c36c
leaq 0xa1cd8(%rip), %rax     # 0x2ae044
movq %rax, 0x5cbead(%rip)    # 0x7d8220
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax