LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: releasetmp
static void releasetmp(Node p) {
    if (!p) return;
    assert(p->count!=0);
    p->count--;
    switch(generic(p->op)) {
        case ADDRG: case ADDRL: case ADDRF: case CNST:
            if (optimizelevel>0) return;
            break;
        case INDIR:
            if (p->x.optimized) return;
    }
    if (p->count==0) {
        int i;
        for (i=0;i<32;i++) {
            if (p->x.result == temp[i])   busy &= ~(1<<i);
            if (p->x.result==flt_temp[i]) busy_flt &= ~(1<<i);
        }
    }
}

// Assembly:
testq %rdi, %rdi
je 0x1b4cb
movzwl 0x4(%rdi), %eax
testw %ax, %ax
je 0x1b4cc
decl %eax
movw %ax, 0x4(%rdi)
movl (%rdi), %ecx
andl $-0x10, %ecx
leal -0x100(%rcx), %edx
cmpl $0x20, %edx
ja 0x1b44f
movabsq $0x100010001, %rsi      # imm = 0x100010001
btq %rdx, %rsi
jb 0x1b459
cmpl $0x40, %ecx
je 0x1b4b9
cmpl $0x10, %ecx
jne 0x1b4c6
testw %ax, %ax
jne 0x1b4cb
cmpl $0x0, 0xe363(%rip)      # 0x297c8
jg 0x1b4cb
movq 0x48(%rdi), %rax
movl 0x1722b(%rip), %ecx     # 0x3269c
movl 0x1722d(%rip), %edx     # 0x326a4
xorl %esi, %esi
leaq 0x17010(%rip), %rdi     # 0x32490
leaq 0x17109(%rip), %r8      # 0x32590
xorl %r9d, %r9d
cmpq $0x20, %r9
je 0x1b4cb
cmpq (%rsi,%rdi), %rax
jne 0x1b4a0
btrl %r9d, %ecx
movl %ecx, 0x171fc(%rip)     # 0x3269c
cmpq (%rsi,%r8), %rax
jne 0x1b4b0
btrl %r9d, %edx
movl %edx, 0x171f4(%rip)     # 0x326a4
incq %r9
addq $0x8, %rsi
jmp 0x1b48a
testw %ax, %ax
jne 0x1b4cb
cmpb $0x0, 0x60(%rdi)
je 0x1b467
jmp 0x1b4cb
testw %ax, %ax
je 0x1b467
retq
pushq %rax
leaq 0x4cf5(%rip), %rdi      # 0x201c9
leaq 0x4ae2(%rip), %rsi      # 0x1ffbd
leaq 0x4cf3(%rip), %rcx      # 0x201d5
movl $0x199, %edx            # imm = 0x199
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: binary
static void binary(char *inst) {
    if (optimizelevel==0)
        print("\t%s(%s,%s,%s)\n"
            ,inst
            ,output_arg(a)
            ,output_arg(b)
            ,output_arg(r));
    else
        print("\t%s_%c%c%c(%s,%s,%s)\n"
            ,inst
            ,simple_adrmode(a->x.adrmode)
            ,simple_adrmode(b->x.adrmode)
            ,simple_adrmode(r->x.adrmode)
            ,output_arg(a)
            ,output_arg(b)
            ,output_arg(r));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xe287(%rip)      # 0x297c8
movq 0x17168(%rip), %rdi     # 0x326b0
je 0x1b567
movzbl 0x40(%rdi), %eax
pushq $0x44
popq %rbp
cmpl $0x49, %eax
je 0x1b5b2
movl %ebp, %r14d
cmpl $0x5a, %eax
je 0x1b5bc
cmpl $0x52, %eax
jne 0x1b5b8
pushq $0x43
jmp 0x1b5b4
callq 0x1b739
movq %rax, %r14
movq 0x17142(%rip), %rdi     # 0x326b8
callq 0x1b739
movq %rax, %r15
movq 0x1713b(%rip), %rdi     # 0x326c0
callq 0x1b739
leaq 0x5013(%rip), %rdi      # 0x205a4
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x106a9
pushq $0x59
popq %r14
jmp 0x1b5bc
movsbl %al, %r14d
movq 0x170f5(%rip), %rax     # 0x326b8
movzbl 0x40(%rax), %eax
cmpl $0x49, %eax
je 0x1b5dd
movl %ebp, %r15d
cmpl $0x5a, %eax
je 0x1b5e7
cmpl $0x52, %eax
jne 0x1b5e3
pushq $0x43
jmp 0x1b5df
pushq $0x59
popq %r15
jmp 0x1b5e7
movsbl %al, %r15d
movq 0x170d2(%rip), %rax     # 0x326c0
movzbl 0x40(%rax), %eax
cmpl $0x49, %eax
je 0x1b605
cmpl $0x5a, %eax
je 0x1b60d
cmpl $0x52, %eax
jne 0x1b60a
pushq $0x43
jmp 0x1b607
pushq $0x59
popq %rbp
jmp 0x1b60d
movsbl %al, %ebp
callq 0x1b739
movq %rax, %r12
movq 0x1709c(%rip), %rdi     # 0x326b8
callq 0x1b739
movq %rax, %r13
movq 0x17095(%rip), %rdi     # 0x326c0
callq 0x1b739
movq %rax, %r10
leaq 0x4f79(%rip), %rdi      # 0x205b3
movq %rbx, %rsi
movl %r14d, %edx
movl %r15d, %ecx
movl %ebp, %r8d
movq %r12, %r9
xorl %eax, %eax
pushq %r10
pushq %r13
callq 0x106a9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: unary
static void unary(char *inst) {
    if (optimizelevel==0)
        print("\t%s(%s,%s)\n"
            ,inst
            ,output_arg(a)
            ,output_arg(r));
    else
        print("\t%s_%c%c(%s,%s)\n"
            ,inst
            ,simple_adrmode(a->x.adrmode)
            ,simple_adrmode(r->x.adrmode)
            ,output_arg(a)
            ,output_arg(r));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xe154(%rip)      # 0x297c8
movq 0x17035(%rip), %rdi     # 0x326b0
je 0x1b69a
movzbl 0x40(%rdi), %eax
pushq $0x44
popq %rbp
cmpl $0x49, %eax
je 0x1b6cf
movl %ebp, %r14d
cmpl $0x5a, %eax
je 0x1b6d9
cmpl $0x52, %eax
jne 0x1b6d5
pushq $0x43
jmp 0x1b6d1
callq 0x1b739
movq %rax, %r14
movq 0x17017(%rip), %rdi     # 0x326c0
callq 0x1b739
leaq 0x4f14(%rip), %rdi      # 0x205c9
movq %rbx, %rsi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x106a9
pushq $0x59
popq %r14
jmp 0x1b6d9
movsbl %al, %r14d
movq 0x16fe0(%rip), %rax     # 0x326c0
movzbl 0x40(%rax), %eax
cmpl $0x49, %eax
je 0x1b6f7
cmpl $0x5a, %eax
je 0x1b6ff
cmpl $0x52, %eax
jne 0x1b6fc
pushq $0x43
jmp 0x1b6f9
pushq $0x59
popq %rbp
jmp 0x1b6ff
movsbl %al, %ebp
callq 0x1b739
movq %rax, %r15
movq 0x16fb2(%rip), %rdi     # 0x326c0
callq 0x1b739
leaq 0x4ebb(%rip), %rdi      # 0x205d5
movq %rbx, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movq %r15, %r8
movq %rax, %r9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x106a9
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: save_busy
static void save_busy(Node p) {
    int i, offset=p->x.argoffset;
    for (i=0; i<8; i++) {
        if (p->x.busy & (1<<i)) {
            // save on stack and increase the argsize
            print("\tSAVE(tmp%d,(sp),%d)\n", i, offset);
            offset += 2;
        }
    }
    // update the CALL's argoffset so that it is passed to the callee
    p->x.argoffset = offset;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x50(%rdi), %ebp
leaq 0x4e5c(%rip), %r14      # 0x205ed
xorl %r15d, %r15d
cmpl $0x8, %r15d
je 0x1b7ba
movl 0x54(%rbx), %eax
btl %r15d, %eax
jae 0x1b7b5
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x106a9
addl $0x2, %ebp
incl %r15d
jmp 0x1b794
movl %ebp, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: restore_busy
static void restore_busy(Node p) {
    int i, offset=p->x.argoffset;
    for (i=7; i>=0; i--) { // reverse order
        if (p->x.busy & (1<<i)) {
            offset -= 2;
            print("\tRESTORE((sp),%d,tmp%d)\n", offset, i);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x50(%rdi), %ebp
pushq $0x7
popq %r14
leaq 0x4e23(%rip), %r15      # 0x20603
testl %r14d, %r14d
js 0x1b805
movl 0x54(%rbx), %eax
btl %r14d, %eax
jae 0x1b800
addl $-0x2, %ebp
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
xorl %eax, %eax
callq 0x106a9
decl %r14d
jmp 0x1b7e0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: compare
static void compare(char *inst) {
     if (optimizelevel==0)
        print("\t%s(%s,%s,%s)\n"
            ,inst
            ,output_arg(a)
            ,output_arg(b)
            ,r->syms[0]->x.name);
    else
        print("\t%s_%c%c(%s,%s,%s)\n"
            ,inst
            ,simple_adrmode(a->x.adrmode)
            ,simple_adrmode(b->x.adrmode)
            ,output_arg(a)
            ,output_arg(b)
            ,r->syms[0]->x.name);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xdfa7(%rip)      # 0x297c8
movq 0x16e88(%rip), %rdi     # 0x326b0
je 0x1b847
movzbl 0x40(%rdi), %eax
pushq $0x44
popq %rbp
cmpl $0x49, %eax
je 0x1b88a
movl %ebp, %r14d
cmpl $0x5a, %eax
je 0x1b894
cmpl $0x52, %eax
jne 0x1b890
pushq $0x43
jmp 0x1b88c
callq 0x1b739
movq %rax, %r14
movq 0x16e62(%rip), %rdi     # 0x326b8
callq 0x1b739
movq 0x16e5e(%rip), %rcx     # 0x326c0
movq 0x8(%rcx), %rcx
movq (%rcx), %r8
leaq 0x4d34(%rip), %rdi      # 0x205a4
movq %rbx, %rsi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x106a9
pushq $0x59
popq %r14
jmp 0x1b894
movsbl %al, %r14d
movq 0x16e1d(%rip), %rax     # 0x326b8
movzbl 0x40(%rax), %eax
cmpl $0x49, %eax
je 0x1b8b2
cmpl $0x5a, %eax
je 0x1b8ba
cmpl $0x52, %eax
jne 0x1b8b7
pushq $0x43
jmp 0x1b8b4
pushq $0x59
popq %rbp
jmp 0x1b8ba
movsbl %al, %ebp
callq 0x1b739
movq %rax, %r15
movq 0x16def(%rip), %rdi     # 0x326b8
callq 0x1b739
movq 0x16deb(%rip), %rcx     # 0x326c0
movq 0x8(%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, (%rsp)
leaq 0x4d35(%rip), %rdi      # 0x2061c
movq %rbx, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movq %r15, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x106a9
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: compare0
static void compare0(char *inst) {
    print("\t%s_%c(%s,%s)\n"
            ,inst
            ,simple_adrmode(a->x.adrmode)
            ,output_arg(a)
            ,r->syms[0]->x.name);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x16d9c(%rip), %rdi     # 0x326b0
movzbl 0x40(%rdi), %eax
cmpl $0x49, %eax
je 0x1b92f
cmpl $0x5a, %eax
je 0x1b92b
cmpl $0x52, %eax
jne 0x1b934
pushq $0x43
jmp 0x1b931
pushq $0x44
jmp 0x1b931
pushq $0x59
popq %rbp
jmp 0x1b937
movsbl %al, %ebp
callq 0x1b739
movq 0x16d7d(%rip), %rcx     # 0x326c0
movq 0x8(%rcx), %rcx
movq (%rcx), %r8
leaq 0x4ec3(%rip), %rdi      # 0x20814
movq %rbx, %rsi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x106a9
// File: /workspace/github_c_makefile_star2_O2/phluid61[P]hsf/src/token.c
// Function: SH_Token__init
SH_Token*
SH_Token__init(sh_char_t* value, size_t n, int* err) {
	SH_Token* obj;
	sh_char_t* ptr;
	sh_char_t  c;
	size_t m;

	__cascade(err, (SH_Token*)0);

	if (n < 1 || n > SH_TOKEN_LENGTH_MAX) {
		__raise(err, SH_E_TOKEN_TOO_LONG);
		return (SH_Token*)0;
	}

	c = *value;
	if (!LEGIT_START(c)) {
		__raise(err, SH_E_TOKEN_BAD_CHAR);
		return (SH_Token*)0;
	}

	ptr = value;
	m = 0;
	while (m < n) {
		c = *ptr;
		if (LEGIT(c)) {
			ptr++;
			m++;
		} else {
			__raise(err, SH_E_TOKEN_BAD_CHAR);
			return (SH_Token*)0;
		}
	}

	obj = (SH_Token*)malloc(sizeof(SH_Token));
	if ((SH_Token*)0 == obj) {
		__raise(err, SH_E_MALLOC_ERROR);
		return (SH_Token*)0;
	}

	obj->value = (sh_char_t*)malloc(sizeof(sh_char_t) * (m + 1));
	if ((sh_char_t*)0 == obj->value) {
		free(obj);
		__raise(err, SH_E_MALLOC_ERROR);
		return (SH_Token*)0;
	}

	memcpy((void*)obj->value, (const void*)value, m);
	obj->value[m] = SH_CHAR_C(0);
	obj->length = m;

	__clear(err);
	return obj;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x1164
cmpl $0x0, (%rbx)
jne 0x1173
leaq -0x201(%r14), %rax
cmpq $-0x200, %rax           # imm = 0xFE00
jae 0x1178
movl $0x140001, %eax         # imm = 0x140001
xorl %r12d, %r12d
jmp 0x11e8
leaq -0x201(%r14), %rax
cmpq $-0x200, %rax           # imm = 0xFE00
jae 0x1178
xorl %r12d, %r12d
jmp 0x11ea
movl $0xffffffc0, %eax       # imm = 0xFFFFFFC0
movzbl (%r15), %ecx
cmpq $0x40, %rcx
jb 0x119b
addl %eax, %ecx
movabsq $0x7fffffe07fffffe, %rdx # imm = 0x7FFFFFE07FFFFFE
btq %rcx, %rdx
jb 0x11a0
jmp 0x11db
cmpl $0x2a, %ecx
jne 0x11db
xorl %ecx, %ecx
movabsq $0x57ffffffc7fffffe, %rdx # imm = 0x57FFFFFFC7FFFFFE
movabsq $0x7ffecfa00000000, %rsi # imm = 0x7FFECFA00000000
cmpq %rcx, %r14
je 0x11f7
movzbl (%r15,%rcx), %edi
cmpq $0x40, %rdi
jb 0x11d0
addl %eax, %edi
btq %rdi, %rdx
jb 0x11d6
jmp 0x11db
btq %rdi, %rsi
jae 0x11db
incq %rcx
jmp 0x11b6
movl $0x140002, %eax         # imm = 0x140002
xorl %r12d, %r12d
testq %rbx, %rbx
je 0x11ea
movl %eax, (%rbx)
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x1050
testq %rax, %rax
je 0x1239
movq %rax, %r12
leaq 0x1(%r14), %rdi
callq 0x1050
movq %rax, (%r12)
testq %rax, %rax
je 0x1240
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1040
xorl %eax, %eax
movb $0x0, (%r13,%r14)
movq %r14, 0x8(%r12)
jmp 0x11e3
movl $0x80000001, %eax       # imm = 0x80000001
jmp 0x11e0
movq %r12, %rdi
callq 0x1030
xorl %r12d, %r12d
movl $0x80000001, %eax       # imm = 0x80000001
jmp 0x11e3
// File: /workspace/github_c_makefile_star2_O2/marcespie[P]unix-samples/chapter1/fork2.c
// Function: decode_status
void 
decode_status(int status)
{
	if (WIFEXITED(status)) {
		int rc = WEXITSTATUS(status);
		if (rc == 0)
			return;
		else {
			fprintf(stderr, "Child exited with exit(%d)\n", rc);
			exit(1);
		}
	} else if (WIFSIGNALED(status)) {
		int sig = WTERMSIG(status);
		fprintf(stderr, "Child exited with signal %d (%s)\n", 
		    sig, strsignal(sig));
	} else {
		// under normal circumstances, you either get a signal
		// or an exit status
		fprintf(stderr, "This should never happen: %d\n", status);
	}
	exit(1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %edx
movl %edi, %ebx
andl $0x7f, %ebx
jne 0x11d4
shrl $0x8, %edx
andl $0xff, %edx
jne 0x120e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %ebx, %eax
shll $0x18, %eax
addl $0x1000000, %eax        # imm = 0x1000000
movq 0x2e13(%rip), %rcx      # 0x3ff8
movq (%rcx), %r14
cmpl $0x2000000, %eax        # imm = 0x2000000
jl 0x1221
movl %ebx, %edi
callq 0x1060
leaq 0xe37(%rip), %rsi       # 0x2034
movq %r14, %rdi
movl %ebx, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1040
jmp 0x1232
movq 0x2de3(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xdf9(%rip), %rsi       # 0x2018
jmp 0x122b
leaq 0xe2e(%rip), %rsi       # 0x2056
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
pushq $0x1
popq %rdi
callq 0x1080
// File: /workspace/github_c_makefile_star2_O2/marcespie[P]unix-samples/chapter1/fork2.c
// Function: main
int
main()
{
	int i = 15;
	int pid = fork();
	switch(pid) {
	case -1: 
		err(1, "fork");
	case 0:
		perform_computation(i);
		exit(0);
	}
	// parent
	int status;
	int r = waitpid(pid, &status, 0);
	if (r == -1)
		err(1, "waitpid");
	decode_status(status);
	exit(0);
}

// Assembly:
pushq %rax
callq 0x1090
testl %eax, %eax
je 0x1252
cmpl $-0x1, %eax
jne 0x125c
leaq 0xe24(%rip), %rsi       # 0x2074
jmp 0x1276
pushq $0xf
popq %rdi
callq 0x119c
jmp 0x1289
leaq 0x4(%rsp), %rsi
movl %eax, %edi
xorl %edx, %edx
callq 0x1070
cmpl $-0x1, %eax
jne 0x1280
leaq 0xe03(%rip), %rsi       # 0x2079
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x1050
movl 0x4(%rsp), %edi
callq 0x11b4
xorl %edi, %edi
callq 0x1080
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/parasail/stats.h
// Function: stats_sample_value
static inline void stats_sample_value(stats_t *stats, const double x) {
    double delta = 0;

    /* extra stats */
    stats->_sum = stats->_sum + x;
    if (0UL == stats->_n) {
        stats->_min = x;
        stats->_max = x;
    }
    else {
        stats->_min = stats->_min < x ? stats->_min : x;
        stats->_max = stats->_max > x ? stats->_max : x;
    }

    stats->_n = stats->_n + 1UL;
    delta = x - stats->_mean;
    stats->_mean = stats->_mean + delta/stats->_n;
    stats->_M2 = stats->_M2 + delta * (x - stats->_mean);
}

// Assembly:
movsd 0x18(%rdi), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rdi)
movq (%rdi), %rax
testq %rax, %rax
je 0x1f26ab
movupd 0x20(%rdi), %xmm1
movapd %xmm1, %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
movapd %xmm1, %xmm3
movsd %xmm0, %xmm3            # xmm3 = xmm0[0],xmm3[1]
cmpltpd %xmm3, %xmm2
movapd %xmm0, %xmm3
unpcklpd %xmm0, %xmm3            # xmm3 = xmm3[0],xmm0[0]
andpd %xmm2, %xmm1
andnpd %xmm3, %xmm2
orpd %xmm1, %xmm2
movupd %xmm2, 0x20(%rdi)
jmp 0x1f26b5
movsd %xmm0, 0x20(%rdi)
movsd %xmm0, 0x28(%rdi)
incq %rax
movq %rax, (%rdi)
movsd 0x8(%rdi), %xmm1
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
movq %rax, %xmm3
punpckldq 0x3c393b(%rip), %xmm3 # xmm3 = xmm3[0],mem[0],xmm3[1],mem[1]
subpd 0x3c3943(%rip), %xmm3   # 0x5b6020
movapd %xmm3, %xmm4
unpckhpd %xmm3, %xmm4            # xmm4 = xmm4[1],xmm3[1]
addsd %xmm3, %xmm4
movapd %xmm2, %xmm3
divsd %xmm4, %xmm3
addsd %xmm1, %xmm3
movsd %xmm3, 0x8(%rdi)
subsd %xmm3, %xmm0
mulsd %xmm2, %xmm0
addsd 0x10(%rdi), %xmm0
movsd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/tests/test_align.c
// Function: print_array_int
static void print_array_int(
        const char * filename,
        int * array,
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        parasail_result_t *result)
{
    int i;
    int j;
    FILE *f = NULL;

    f = fopen(filename, "w");
    if (NULL == f) {
        printf("fopen(\"%s\") error: %s\n", filename, strerror(errno));
        exit(-1);
    }
    fprintf(f, "saturated=%d\n", parasail_result_is_saturated(result) ? 1 : 0);
    fprintf(f, " ");
    for (j=0; j<s2Len; ++j) {
        fprintf(f, "%4c", s2[j]);
    }
    fprintf(f, "\n");
    for (i=0; i<s1Len; ++i) {
        fprintf(f, "%c", s1[i]);
        for (j=0; j<s2Len; ++j) {
            fprintf(f, "%4d", array[i*s2Len + j]);
        }
        fprintf(f, "\n");
    }
    fclose(f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebx
movq %r8, %r13
movq %rcx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %r15
movq %rdi, %r14
movq 0x50(%rsp), %rbp
leaq 0x41fb10(%rip), %rsi    # 0x6125cd
callq 0x1f01b0
testq %rax, %rax
je 0x1f2bbf
movq %rax, %r12
movq %rbp, %rdi
callq 0x1f5e3e
xorl %edx, %edx
testl %eax, %eax
setne %dl
leaq 0x3f7f7c(%rip), %rsi    # 0x5eaa60
movq %r12, %rdi
xorl %eax, %eax
callq 0x1f0220
pushq $0x20
popq %rdi
movq %r12, %rsi
callq 0x1f01e0
testl %ebx, %ebx
movl $0x0, %r14d
movl %ebx, (%rsp)
cmovgl %ebx, %r14d
leaq 0x3f7f5f(%rip), %rbp    # 0x5eaa6e
xorl %ebx, %ebx
cmpq %rbx, %r14
je 0x1f2b2e
movsbl (%r13,%rbx), %edx
movq %r12, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x1f0220
incq %rbx
jmp 0x1f2b11
pushq $0xa
popq %rdi
movq %r12, %rsi
callq 0x1f01e0
xorl %eax, %eax
movq 0x8(%rsp), %rcx
testl %ecx, %ecx
cmovlel %eax, %ecx
movq %rcx, 0x8(%rsp)
movslq (%rsp), %rax
shlq $0x2, %rax
movq %rax, (%rsp)
leaq 0x3f7f15(%rip), %rbp    # 0x5eaa72
xorl %ebx, %ebx
cmpq 0x8(%rsp), %rbx
je 0x1f2ba9
movq 0x10(%rsp), %rax
movsbl (%rax,%rbx), %edi
movq %r12, %rsi
callq 0x1f01e0
xorl %r13d, %r13d
cmpq %r13, %r14
je 0x1f2b95
movl (%r15,%r13,4), %edx
movq %r12, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x1f0220
incq %r13
jmp 0x1f2b7a
pushq $0xa
popq %rdi
movq %r12, %rsi
callq 0x1f01e0
incq %rbx
addq (%rsp), %r15
jmp 0x1f2b5f
movq %r12, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1f0170
callq 0x1f0030
movl (%rax), %edi
callq 0x1f0090
leaq 0x3f7e77(%rip), %rdi    # 0x5eaa49
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1f0040
pushq $-0x1
popq %rdi
callq 0x1f01d0
nop
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/io.c
// Function: parasail_close
void parasail_close(parasail_file_t *pf)
{
    if (NULL == pf) {
        fprintf(stderr, "parasail_close: NULL file\n");
        return;
    }
#if defined(HAVE_SYS_MMAN_H)
    if (-1 == munmap((void*)pf->buf, pf->size)) {
        perror("munmap");
        fprintf(stderr, "parasail_close: cannot munmap file buffer\n");
    }
    if (-1 == close(pf->fd)) {
        perror("close");
        fprintf(stderr, "parasail_close: cannot close file descriptor\n");
    }
#else
    free((void*)pf->buf);
    /* file was already closed */
#endif
    free(pf);
}

// Assembly:
testq %rdi, %rdi
je 0x1f2ef4
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdi
callq 0x1f00e0
cmpl $-0x1, %eax
je 0x1f2f10
movl (%rbx), %edi
callq 0x1f02c0
cmpl $-0x1, %eax
je 0x1f2f3a
movq %rbx, %rdi
popq %rbx
jmp 0x1f01c0
movq 0x5510dd(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f7c72(%rip), %rdi    # 0x5eab77
pushq $0x1a
popq %rsi
pushq $0x1
popq %rdx
jmp 0x1f02b0
leaq 0x3f7c7b(%rip), %rdi    # 0x5eab92
callq 0x1f0140
movq 0x5510b5(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f7c6c(%rip), %rdi    # 0x5eab99
pushq $0x2a
popq %rsi
pushq $0x1
popq %rdx
callq 0x1f02b0
jmp 0x1f2edf
leaq 0x3f7c83(%rip), %rdi    # 0x5eabc4
callq 0x1f0140
movq 0x55108b(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f7c73(%rip), %rdi    # 0x5eabca
pushq $0x2d
popq %rsi
pushq $0x1
popq %rdx
callq 0x1f02b0
jmp 0x1f2eeb
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/io.c
// Function: parasail_is_fasta
int parasail_is_fasta(const parasail_file_t *pf)
{
    if (NULL == pf) {
        fprintf(stderr, "parasail_is_fasta: NULL pointer\n");
        return -1;
    }

    return parasail_is_fasta_buffer(pf->buf, pf->size);
}

// Assembly:
testq %rdi, %rdi
je 0x1f2f72
movq 0x10(%rdi), %rdi
jmp 0x1f2f94
pushq %rax
movq 0x55105e(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f7c74(%rip), %rdi    # 0x5eabf8
pushq $0x20
popq %rsi
pushq $0x1
popq %rdx
callq 0x1f02b0
pushq $-0x1
popq %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/io.c
// Function: parasail_is_fasta_buffer
int parasail_is_fasta_buffer(const char *buf, off_t UNUSED(size))
{
    if (NULL == buf) {
        fprintf(stderr, "parasail_is_fasta_buffer: NULL pointer\n");
        return -1;
    }

    return '>' == buf[0];
}

// Assembly:
testq %rdi, %rdi
je 0x1f2fa2
xorl %eax, %eax
cmpb $0x3e, (%rdi)
sete %al
retq
pushq %rax
movq 0x55102e(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f7c65(%rip), %rdi    # 0x5eac19
pushq $0x27
popq %rsi
pushq $0x1
popq %rdx
callq 0x1f02b0
pushq $-0x1
popq %rax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/io.c
// Function: parasail_is_fastq
int parasail_is_fastq(const parasail_file_t *pf)
{
    if (NULL == pf) {
        fprintf(stderr, "parasail_is_fastq: NULL pointer\n");
        return -1;
    }

    return parasail_is_fastq_buffer(pf->buf, pf->size);
}

// Assembly:
testq %rdi, %rdi
je 0x1f2fd5
movq 0x10(%rdi), %rdi
jmp 0x1f2ff7
pushq %rax
movq 0x550ffb(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f7c5a(%rip), %rdi    # 0x5eac41
pushq $0x20
popq %rsi
pushq $0x1
popq %rdx
callq 0x1f02b0
pushq $-0x1
popq %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/io.c
// Function: parasail_is_fastq_buffer
int parasail_is_fastq_buffer(const char *buf, off_t UNUSED(size))
{
    if (NULL == buf) {
        fprintf(stderr, "parasail_is_fastq_buffer: NULL pointer\n");
        return -1;
    }

    return '@' == buf[0];
}

// Assembly:
testq %rdi, %rdi
je 0x1f3005
xorl %eax, %eax
cmpb $0x40, (%rdi)
sete %al
retq
pushq %rax
movq 0x550fcb(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f7c4b(%rip), %rdi    # 0x5eac62
pushq $0x27
popq %rsi
pushq $0x1
popq %rdx
callq 0x1f02b0
pushq $-0x1
popq %rax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/io.c
// Function: parasail_stat
parasail_file_stat_t* parasail_stat(const parasail_file_t *pf)
{
    parasail_file_stat_t *stat = NULL;

    if (NULL == pf) {
        fprintf(stderr, "parasail_stat: NULL pointer\n");
        return NULL;
    }

    if (1 == parasail_is_fasta(pf)) {
        stat = parasail_stat_fasta(pf);
    }
    else if (1 == parasail_is_fastq(pf)) {
        stat = parasail_stat_fastq(pf);
    }
    else {
        fprintf(stderr, "parasail_stat: cannot determine file format\n");
        return NULL;
    }

    if (NULL == stat) {
        fprintf(stderr, "parasail_stat: failed\n");
        return NULL;
    }

    return stat;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x1f3063
movq %rdi, %rbx
callq 0x1f2f64
cmpl $0x1, %eax
jne 0x1f3047
movq %rbx, %rdi
callq 0x1f30ad
jmp 0x1f305c
movq %rbx, %rdi
callq 0x1f2fc7
cmpl $0x1, %eax
jne 0x1f308d
movq %rbx, %rdi
callq 0x1f30e0
testq %rax, %rax
je 0x1f3078
popq %rbx
retq
movq 0x550f6e(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f7c16(%rip), %rdi    # 0x5eac8a
pushq $0x1c
jmp 0x1f30a0
movq 0x550f59(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f7c4b(%rip), %rdi    # 0x5eacd4
pushq $0x16
jmp 0x1f30a0
movq 0x550f44(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f7c09(%rip), %rdi    # 0x5eaca7
pushq $0x2c
popq %rsi
pushq $0x1
popq %rdx
callq 0x1f02b0
xorl %eax, %eax
jmp 0x1f3061
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/io.c
// Function: parasail_stat_fasta
parasail_file_stat_t* parasail_stat_fasta(const parasail_file_t *pf)
{
    if (NULL == pf) {
        fprintf(stderr, "parasail_stat_fasta: NULL pointer\n");
        return NULL;
    }

    return parasail_stat_fasta_buffer(pf->buf, pf->size);
}

// Assembly:
testq %rdi, %rdi
je 0x1f30bf
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdi
jmp 0x1f3183
pushq %rax
movq 0x550f11(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f7c5c(%rip), %rdi    # 0x5ead2d
pushq $0x22
popq %rsi
pushq $0x1
popq %rdx
callq 0x1f02b0
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/io.c
// Function: parasail_stat_fastq
parasail_file_stat_t* parasail_stat_fastq(const parasail_file_t *pf)
{
    if (NULL == pf) {
        fprintf(stderr, "parasail_stat_fastq: NULL pointer\n");
        return NULL;
    }

    return parasail_stat_fastq_buffer(pf->buf, pf->size);
}

// Assembly:
testq %rdi, %rdi
je 0x1f30f2
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdi
jmp 0x1f344f
pushq %rax
movq 0x550ede(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f7da0(%rip), %rdi    # 0x5eaea4
pushq $0x22
popq %rsi
pushq $0x1
popq %rdx
callq 0x1f02b0
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/io.c
// Function: parasail_stat_buffer
parasail_file_stat_t* parasail_stat_buffer(const char *buf, off_t size)
{
    parasail_file_stat_t *stat = NULL;

    if (NULL == buf) {
        fprintf(stderr, "parasail_stat_buffer: NULL pointer\n");
        return NULL;
    }

    if (1 == parasail_is_fasta_buffer(buf, size)) {
        stat = parasail_stat_fasta_buffer(buf, size);
    }
    else if (parasail_is_fastq_buffer(buf, size)) {
        stat = parasail_stat_fastq_buffer(buf, size);
    }
    else {
        fprintf(stderr, "parasail_stat: cannot determine file format\n");
        return NULL;
    }

    if (NULL == stat) {
        fprintf(stderr, "parasail_stat_buffer: failed\n");
        return NULL;
    }

    return stat;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1f3139
movzbl (%rdi), %eax
cmpl $0x40, %eax
je 0x1f312d
cmpl $0x3e, %eax
jne 0x1f3163
callq 0x1f3183
jmp 0x1f3132
callq 0x1f344f
testq %rax, %rax
je 0x1f314e
popq %rcx
retq
movq 0x550e98(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f7ba1(%rip), %rdi    # 0x5eaceb
pushq $0x23
jmp 0x1f3176
movq 0x550e83(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f7bb0(%rip), %rdi    # 0x5ead0f
pushq $0x1d
jmp 0x1f3176
movq 0x550e6e(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f7b33(%rip), %rdi    # 0x5eaca7
pushq $0x2c
popq %rsi
pushq $0x1
popq %rdx
callq 0x1f02b0
xorl %eax, %eax
jmp 0x1f3137
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/io.c
// Function: skip_line
inline static off_t skip_line(const char *T, off_t i)
{
    while (T[i] != '\n' && T[i] != '\r') {
        ++i;
    }

    /* for the case of "\r\n" or "\n\r" */
    if (T[i+1] == '\n' || T[i+1] == '\r') {
        ++i;
    }

    return i;
}

// Assembly:
movzbl (%rdi,%rsi), %eax
cmpl $0xa, %eax
je 0x1f36d9
cmpl $0xd, %eax
je 0x1f36d9
incq %rsi
jmp 0x1f36c6
leaq 0x1(%rsi), %rax
movzbl 0x1(%rdi,%rsi), %ecx
cmpl $0xa, %ecx
je 0x1f36ef
cmpl $0xd, %ecx
je 0x1f36ef
movq %rsi, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/io.c
// Function: parasail_read
char * parasail_read(const parasail_file_t *pf, long * size)
{
    char * buffer = NULL;

    if (NULL == pf) {
        fprintf(stderr, "parasail_read: NULL pointer\n");
        return NULL;
    }

    if (NULL == size) {
        fprintf(stderr, "parasail_read: NULL size pointer\n");
        return NULL;
    }

    buffer = (char*)malloc(sizeof(char) * (pf->size+1));
    if (NULL == buffer) {
        perror("malloc");
        fprintf(stderr, "parasail_read: "
                "cannont malloc buffer for input file");
        return NULL;
    }

    (void)memcpy(buffer, pf->buf, pf->size);
    buffer[pf->size] = '\0';
    *size = pf->size;
    return buffer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1f37f1
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1f3806
movq %rdi, %r15
movq 0x8(%rdi), %r12
leaq 0x1(%r12), %rdi
callq 0x1f01f0
testq %rax, %rax
je 0x1f381b
movq %rax, %r14
movq 0x10(%r15), %rsi
movq %rax, %rdi
movq %r12, %rdx
callq 0x1f0130
movb $0x0, (%r14,%r12)
movq %r12, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x5507e0(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f7774(%rip), %rdi    # 0x5eaf76
pushq $0x1c
jmp 0x1f383a
movq 0x5507cb(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f777c(%rip), %rdi    # 0x5eaf93
pushq $0x21
jmp 0x1f383a
leaq 0x3f731d(%rip), %rdi    # 0x5eab3f
callq 0x1f0140
movq 0x5507aa(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f777d(%rip), %rdi    # 0x5eafb5
pushq $0x33
popq %rsi
pushq $0x1
popq %rdx
callq 0x1f02b0
xorl %r14d, %r14d
jmp 0x1f37e2
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/io.c
// Function: parasail_pack
char * parasail_pack(const parasail_file_t *pf, long * size)
{
    char *packed = NULL;

    if (NULL == pf) {
        fprintf(stderr, "parasail_pack: NULL pointer\n");
        return NULL;
    }

    if (NULL == size) {
        fprintf(stderr, "parasail_pack: NULL size pointer\n");
        return NULL;
    }

    if (1 == parasail_is_fasta(pf)) {
        packed = parasail_pack_fasta(pf, size);
    }
    else if (1 == parasail_is_fastq(pf)) {
        packed = parasail_pack_fastq(pf, size);
    }
    else {
        fprintf(stderr, "parasail_pack: cannot determine file format\n");
        return NULL;
    }

    if (NULL == packed) {
        fprintf(stderr, "parasail_pack: failed\n");
        return NULL;
    }

    return packed;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1f3898
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1f38ad
movq %rdi, %r14
callq 0x1f2f64
cmpl $0x1, %eax
jne 0x1f3873
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1f38f7
jmp 0x1f388b
movq %r14, %rdi
callq 0x1f2fc7
cmpl $0x1, %eax
jne 0x1f38d7
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1f3948
testq %rax, %rax
je 0x1f38c2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x550739(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f7740(%rip), %rdi    # 0x5eafe9
pushq $0x1c
jmp 0x1f38ea
movq 0x550724(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f7748(%rip), %rdi    # 0x5eb006
pushq $0x21
jmp 0x1f38ea
movq 0x55070f(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f7782(%rip), %rdi    # 0x5eb055
pushq $0x16
jmp 0x1f38ea
movq 0x5506fa(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f7740(%rip), %rdi    # 0x5eb028
pushq $0x2c
popq %rsi
pushq $0x1
popq %rdx
callq 0x1f02b0
xorl %eax, %eax
jmp 0x1f3890
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/io.c
// Function: parasail_pack_fasta
char * parasail_pack_fasta(const parasail_file_t *pf, long * packed_size)
{
    if (NULL == pf) {
        fprintf(stderr, "parasail_pack_fasta: NULL pointer\n");
        return NULL;
    }

    if (NULL == packed_size) {
        fprintf(stderr, "parasail_pack_fasta: NULL size pointer\n");
        return NULL;
    }

    return parasail_pack_fasta_buffer(pf->buf, pf->size, packed_size);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1f3913
movq %rsi, %rdx
testq %rsi, %rsi
je 0x1f3928
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdi
popq %rax
jmp 0x1f3a23
movq 0x5506be(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f77b3(%rip), %rdi    # 0x5eb0d7
pushq $0x22
jmp 0x1f393b
movq 0x5506a9(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f77c1(%rip), %rdi    # 0x5eb0fa
pushq $0x27
popq %rsi
pushq $0x1
popq %rdx
callq 0x1f02b0
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/io.c
// Function: parasail_pack_fastq
char * parasail_pack_fastq(const parasail_file_t *pf, long * size)
{
    if (NULL == pf) {
        fprintf(stderr, "parasail_pack_fastq: NULL pointer\n");
        return NULL;
    }

    if (NULL == size) {
        fprintf(stderr, "parasail_pack_fastq: NULL size pointer\n");
        return NULL;
    }

    return parasail_pack_fastq_buffer(pf->buf, pf->size, size);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1f3964
movq %rsi, %rdx
testq %rsi, %rsi
je 0x1f3979
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdi
popq %rax
jmp 0x1f3c2f
movq 0x55066d(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f790c(%rip), %rdi    # 0x5eb281
pushq $0x22
jmp 0x1f398c
movq 0x550658(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f791a(%rip), %rdi    # 0x5eb2a4
pushq $0x27
popq %rsi
pushq $0x1
popq %rdx
callq 0x1f02b0
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/io.c
// Function: parasail_pack_buffer
char * parasail_pack_buffer(const char *buf, off_t size, long * packed_size)
{
    char *packed = NULL;

    if (NULL == buf) {
        fprintf(stderr, "parasail_pack_buffer: NULL pointer\n");
        return NULL;
    }

    if (NULL == packed_size) {
        fprintf(stderr, "parasail_pack_buffer: NULL size pointer\n");
        return NULL;
    }

    if (1 == parasail_is_fasta_buffer(buf, size)) {
        packed = parasail_pack_fasta_buffer(buf, size, packed_size);
    }
    else if (1 == parasail_is_fastq_buffer(buf, size)) {
        packed = parasail_pack_fastq_buffer(buf, size, packed_size);
    }
    else {
        fprintf(stderr, "parasail_pack: cannot determine file format\n");
        return NULL;
    }

    if (NULL == packed) {
        fprintf(stderr, "parasail_pack_buffer: failed\n");
        return NULL;
    }

    return packed;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1f39c4
testq %rdx, %rdx
je 0x1f39d9
movzbl (%rdi), %eax
cmpl $0x40, %eax
je 0x1f39b8
cmpl $0x3e, %eax
jne 0x1f3a03
callq 0x1f3a23
jmp 0x1f39bd
callq 0x1f3c2f
testq %rax, %rax
je 0x1f39ee
popq %rcx
retq
movq 0x55060d(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f7697(%rip), %rdi    # 0x5eb06c
pushq $0x23
jmp 0x1f3a16
movq 0x5505f8(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f76a6(%rip), %rdi    # 0x5eb090
pushq $0x28
jmp 0x1f3a16
movq 0x5505e3(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f76ba(%rip), %rdi    # 0x5eb0b9
pushq $0x1d
jmp 0x1f3a16
movq 0x5505ce(%rip), %rax    # 0x743fd8
movq (%rax), %rcx
leaq 0x3f7614(%rip), %rdi    # 0x5eb028
pushq $0x2c
popq %rsi
pushq $0x1
popq %rdx
callq 0x1f02b0
xorl %eax, %eax
jmp 0x1f39c2
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/pssw.c
// Function: parasail_ssw_init
parasail_profile_t* parasail_ssw_init(
        const char * const restrict s1, const int s1Len,
        const parasail_matrix_t* matrix, const int8_t score_size)
{
    parasail_profile_t *profile8 = NULL;
    parasail_profile_t *profile16 = NULL;

    if (score_size == 0 || score_size == 2) {
        profile8 = parasail_profile_create_8(s1, s1Len, matrix);
    }
    if (score_size == 1 || score_size == 2) {
        profile16 = parasail_profile_create_16(s1, s1Len, matrix);
    }

    if (profile8 && profile16) {
        profile8->profile16 = profile16->profile16;
        free(profile16);
        return profile8;
    }
    else if (profile8) {
        return profile8;
    }
    else if (profile16) {
        return profile16;
    }

    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r12d
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
testb $-0x3, %r12b
je 0x1f7561
xorl %ebx, %ebx
jmp 0x1f7571
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x236153
movq %rax, %rbx
decb %r12b
cmpb $0x2, %r12b
jae 0x1f75b4
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x23614a
testq %rbx, %rbx
setne %cl
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x1f75bc
movq 0x40(%rax), %rcx
movq %rcx, 0x40(%rbx)
movups 0x30(%rax), %xmm0
movups %xmm0, 0x30(%rbx)
movq %rax, %rdi
callq 0x1f01c0
jmp 0x1f75c2
testq %rbx, %rbx
setne %cl
xorl %eax, %eax
testb %cl, %cl
cmoveq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/pssw.c
// Function: parasail_ssw
parasail_result_ssw_t* parasail_ssw(
        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)
{
    parasail_profile_t *profile = parasail_ssw_init(s1, s1Len, matrix, 2);
    parasail_result_ssw_t *result = parasail_ssw_profile(profile, s2, s2Len, open, gap);
    parasail_profile_free(profile);
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movq 0x30(%rsp), %rdx
pushq $0x2
popq %rcx
callq 0x1f7544
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x1f761c
movq %rax, %rbx
movq %r12, %rdi
callq 0x1f5bec
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/striped_unwind.c
// Function: parasail_striped_unwind_8
static inline int* CONCAT(parasail_striped_unwind_, T) (
        int lena,
        int lenb,
        int segWidth,
        void *array_)
{
    int i;
    int j;
    int *ret = (int*)malloc(sizeof(int)*lena*lenb);
    D *array = (D*)array_;
    const int32_t segLen = (lena + segWidth - 1) / segWidth;
    int32_t column_len = segLen * segWidth;
    for (j=0; j<lenb; ++j) {
        for (i=0; i<column_len; ++i) {
            int32_t i_unwound = i / segWidth + i % segWidth * segLen;
            if (i_unwound < lena) {
                ret[i_unwound*lenb + j] = (int)array[j*column_len + i];
            }
        }
    }
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r14d
movl %esi, %ebp
movl %edi, %r15d
movslq %edi, %r13
movslq %esi, %r12
movq %r13, %rdi
imulq %r12, %rdi
shlq $0x2, %rdi
callq 0x1f01f0
movq %rax, %rcx
leal (%r14,%r13), %eax
decl %eax
cltd
idivl %r14d
movl %eax, %esi
imull %r14d, %eax
xorl %r8d, %r8d
testl %eax, %eax
movl $0x0, %r9d
cmovgl %eax, %r9d
movslq %eax, %r10
testl %r12d, %r12d
cmovlel %r8d, %r12d
cmpq %r12, %r8
je 0x2860e0
leaq (%rcx,%r8,4), %r11
xorl %edi, %edi
cmpq %rdi, %r9
je 0x2860d8
movl %edi, %eax
cltd
idivl %r14d
imull %esi, %edx
addl %eax, %edx
cmpl %r15d, %edx
jge 0x2860d3
movsbl (%rbx,%rdi), %eax
imull %ebp, %edx
movslq %edx, %rdx
movl %eax, (%r11,%rdx,4)
incq %rdi
jmp 0x2860b0
incq %r8
addq %r10, %rbx
jmp 0x2860a5
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sharpyfox[P]citrusleaf-client/tests/loop_c/src/main.c
// Function: atomic_int_create
atomic_int	*
atomic_int_create(uint64_t val)
{
	atomic_int *ai = malloc(sizeof(atomic_int));
	ai->val = val;
	pthread_mutex_init(&ai->lock,0);
	return(ai);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x30
popq %rdi
callq 0x22e0
leaq 0x8(%rax), %rdi
xorl %esi, %esi
movq %rax, %r14
movq %rbx, (%rax)
callq 0x2400
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/sharpyfox[P]citrusleaf-client/tests/loop_c/src/main.c
// Function: atomic_int_add
uint64_t
atomic_int_add(atomic_int *ai, int val)
{
	uint32_t	rv;
	pthread_mutex_lock(&ai->lock);
	ai->val += val;
	rv = ai->val;
	pthread_mutex_unlock(&ai->lock);
	return(rv);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x8(%rdi), %r15
movq %rdi, %r14
movl %esi, %ebx
movq %r15, %rdi
callq 0x23b0
movslq %ebx, %rbx
movq %r15, %rdi
addq (%r14), %rbx
movq %rbx, (%r14)
callq 0x2190
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sharpyfox[P]citrusleaf-client/tests/loop_c/src/main.c
// Function: atomic_int_get
uint64_t		
atomic_int_get(atomic_int *ai)
{
	uint64_t	val;
	pthread_mutex_lock(&ai->lock);
	val = ai->val;
	pthread_mutex_unlock(&ai->lock);
	return(val);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x8(%rdi), %r14
movq %rdi, %rbx
movq %r14, %rdi
callq 0x23b0
movq (%rbx), %rbx
movq %r14, %rdi
callq 0x2190
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/sharpyfox[P]citrusleaf-client/tests/loop_c/src/main.c
// Function: counter_fn
void *
counter_fn(void *arg)
{
	counter_thread_control *ctc = (counter_thread_control *) arg;
	
	while (ctc->death == 0) {
		sleep(1);
		fprintf(stderr, "loopTest: reads %"PRIu64" writes %"PRIu64" deletes %"PRIu64" (total keys: %"PRIu64")\n",
			atomic_int_get(ctc->reads), atomic_int_get(ctc->writes), atomic_int_get(ctc->deletes),
			atomic_int_get(ctc->keys) );
        	citrusleaf_print_stats();
	}
	return(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb96a(%rip), %r14      # 0xe074
cmpl $0x0, 0x20(%rbx)
jne 0x276e
pushq $0x1
popq %rdi
callq 0x2180
movq 0x128c1(%rip), %rax     # 0x14fe0
movq (%rbx), %rdi
movq (%rax), %r15
callq 0x26cc
movq 0x8(%rbx), %rdi
movq %rax, %r12
callq 0x26cc
movq 0x10(%rbx), %rdi
movq %rax, %r13
callq 0x26cc
movq 0x18(%rbx), %rdi
movq %rax, %rbp
callq 0x26cc
movq %rax, %r9
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %rbp, %r8
xorl %eax, %eax
callq 0x2380
callq 0x6608
jmp 0x270a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sharpyfox[P]citrusleaf-client/tests/loop_c/src/main.c
// Function: start_counter_thread
void *
start_counter_thread(atomic_int *reads, atomic_int *writes, atomic_int *deletes, atomic_int *keys)
{
	counter_thread_control *ctc = (counter_thread_control *) malloc(sizeof(counter_thread_control));
	ctc->reads = reads;
	ctc->writes = writes;
	ctc->deletes = deletes;
	ctc->keys = keys;
	ctc->death = 0;
	pthread_create(&ctc->th, 0, counter_fn, ctc);
	return(ctc);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x30
popq %rdi
callq 0x22e0
movq %r12, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
andl $0x0, 0x20(%rax)
leaq 0x28(%rax), %rdi
leaq -0xc5(%rip), %rdx       # 0x26f5
xorl %esi, %esi
movq %rax, %rcx
movq %rax, %r13
callq 0x24e0
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sharpyfox[P]citrusleaf-client/tests/loop_c/src/main.c
// Function: rand_64
uint64_t
rand_64()
{
	uint64_t r;
	if (g_config.pseudo_seed) {

		r = random();
		
	}
	else {
		pthread_mutex_lock(&rand_buf_lock);
		if (rand_buf_off < sizeof(uint64_t) ) {
			if (seeded == 0) {
				int rfd = open("/dev/urandom",	O_RDONLY);
				int rsz = read(rfd, rand_buf, SEED_SZ);
				if (rsz < SEED_SZ) {
					fprintf(stderr, "warning! can't seed random number generator");
					return(0);
				}
				close(rfd);
				RAND_seed(rand_buf, rsz);
				seeded = 1;
			}
			if (1 != RAND_bytes(rand_buf, sizeof(rand_buf))) {
				fprintf(stderr, "RAND_bytes not so happy.\n");
				pthread_mutex_unlock(&rand_buf_lock);
				return(0);
			}
			rand_buf_off = sizeof(rand_buf);
		}
		
		rand_buf_off -= sizeof(uint64_t);
		r = *(uint64_t *) (&rand_buf[rand_buf_off]);
		pthread_mutex_unlock(&rand_buf_lock);
	}
	return(r);
}

// Assembly:
cmpl $0x0, 0x12b66(%rip)     # 0x15360
jne 0x2120
pushq %r14
pushq %rbx
pushq %rax
leaq 0x12b65(%rip), %rdi     # 0x15370
callq 0x23b0
movl 0x12b82(%rip), %ebx     # 0x15398
cmpl $0x7, %ebx
ja 0x288c
cmpb $0x0, 0x12b7a(%rip)     # 0x1539c
jne 0x2871
leaq 0xb887(%rip), %rdi      # 0xe0b2
xorl %esi, %esi
xorl %eax, %eax
callq 0x24b0
movl %eax, %ebx
leaq 0x12b63(%rip), %rsi     # 0x153a0
pushq $0x40
popq %rdx
movl %eax, %edi
callq 0x2390
movq %rax, %r14
cmpl $0x40, %r14d
jl 0x28e1
movl %ebx, %edi
callq 0x2550
leaq 0x12b3e(%rip), %rdi     # 0x153a0
movl %r14d, %esi
callq 0x24a0
movb $0x1, 0x12b2b(%rip)     # 0x1539c
leaq 0x12b28(%rip), %rdi     # 0x153a0
movl $0x2000, %esi           # imm = 0x2000
movl $0x2000, %ebx           # imm = 0x2000
callq 0x23d0
cmpl $0x1, %eax
jne 0x28b7
addl $-0x8, %ebx
leaq 0x12b0a(%rip), %rax     # 0x153a0
leaq 0x12ad3(%rip), %rdi     # 0x15370
movl %ebx, 0x12af5(%rip)     # 0x15398
movq (%rbx,%rax), %rbx
callq 0x2190
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x12722(%rip), %rax     # 0x14fe0
leaq 0xb826(%rip), %rdi      # 0xe0eb
movq (%rax), %rcx
pushq $0x19
popq %rsi
pushq $0x1
popq %rdx
callq 0x2540
leaq 0x12a96(%rip), %rdi     # 0x15370
callq 0x2190
jmp 0x28fd
movq 0x126f8(%rip), %rax     # 0x14fe0
leaq 0xb7d0(%rip), %rdi      # 0xe0bf
movq (%rax), %rcx
pushq $0x2b
popq %rsi
pushq $0x1
popq %rdx
callq 0x2540
xorl %ebx, %ebx
jmp 0x28ac
// File: /workspace/github_c_makefile_star2_O2/sharpyfox[P]citrusleaf-client/tests/loop_c/src/main.c
// Function: usage
void usage(void) {
	fprintf(stderr, "Usage key_c:\n");
	fprintf(stderr, "-h host [default 127.0.0.1] \n");
	fprintf(stderr, "-p port [default 3000]\n");
	fprintf(stderr, "-H host:port [default 127.0.0.1:3000]\n");
	fprintf(stderr, "-n namespace [default test]\n");
	fprintf(stderr, "-s set [default 'set']\n");
	fprintf(stderr, "-S Strict - verify all keys and halt on error\n");
	fprintf(stderr, "-b bin [default value]\n");
	fprintf(stderr, "-t threads [default 32]\n");
	fprintf(stderr, "-k keys [default 100000]\n");
	fprintf(stderr, "-K key size [default 10]\n");
	fprintf(stderr, "-V value size [default 20]\n");
	fprintf(stderr, "-r random seed [default random]\n");
	fprintf(stderr, "-m milliseconds timeout [default 200]\n");
	fprintf(stderr, "-f do not follow cluster [default do follow]\n");
	fprintf(stderr, "-v is verbose\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x126a6(%rip), %r12     # 0x14fe0
leaq 0xb7c4(%rip), %rdi      # 0xe105
movq (%r12), %rcx
pushq $0xd
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x2540
movq (%r12), %rcx
leaq 0xb7b5(%rip), %rdi      # 0xe113
pushq $0x1d
popq %rsi
movq %rbx, %rdx
callq 0x2540
movq (%r12), %rcx
leaq 0xb7bd(%rip), %rdi      # 0xe131
pushq $0x17
popq %r15
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2540
movq (%r12), %rcx
leaq 0xb7bb(%rip), %rdi      # 0xe149
pushq $0x26
popq %r14
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2540
movq (%r12), %rcx
leaq 0xb7c8(%rip), %rdi      # 0xe170
pushq $0x1c
popq %rsi
movq %rbx, %rdx
callq 0x2540
movq (%r12), %rcx
leaq 0xb7cf(%rip), %rdi      # 0xe18d
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2540
movq (%r12), %rcx
leaq 0xb7d1(%rip), %rdi      # 0xe1a5
pushq $0x2e
popq %rsi
movq %rbx, %rdx
callq 0x2540
movq (%r12), %rcx
leaq 0xb7ea(%rip), %rdi      # 0xe1d4
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2540
movq (%r12), %rcx
leaq 0xb7ec(%rip), %rdi      # 0xe1ec
pushq $0x18
popq %rsi
movq %rbx, %rdx
callq 0x2540
movq (%r12), %rcx
leaq 0xb7ef(%rip), %rdi      # 0xe205
pushq $0x19
popq %r15
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2540
movq (%r12), %rcx
leaq 0xb7ef(%rip), %rdi      # 0xe21f
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2540
movq (%r12), %rcx
leaq 0xb7f3(%rip), %rdi      # 0xe239
pushq $0x1b
popq %rsi
movq %rbx, %rdx
callq 0x2540
movq (%r12), %rcx
leaq 0xb7f9(%rip), %rdi      # 0xe255
pushq $0x20
popq %rsi
movq %rbx, %rdx
callq 0x2540
movq (%r12), %rcx
leaq 0xb804(%rip), %rdi      # 0xe276
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2540
movq (%r12), %rcx
leaq 0xb815(%rip), %rdi      # 0xe29d
pushq $0x2d
popq %rsi
movq %rbx, %rdx
callq 0x2540
movq (%r12), %rcx
leaq 0xb82d(%rip), %rdi      # 0xe2cb
pushq $0xe
popq %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2540