LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/unix.c
// Function: ttyinput
int
ttyinput(Tty *tty, char *c)
{
	if(hasinput(tty->fd)){
		read(tty->fd, c, 1);
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x9ab0
cmpl $0x0, %eax
je 0x9a0d
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x2100
movl $0x1, -0x4(%rbp)
jmp 0x9a14
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/unix.c
// Function: timestamp
int
timestamp(char *buffer, size_t n)
{
	struct tm *tm;
	time_t t;

	t = time(NULL);
	if (t == (time_t)-1)
		return -1;
	tm = localtime(&t);
	if (tm == NULL)
		return -1;
	if(strftime(buffer, n, "%Y%m%d%H%M%S", tm) == 0)
		return -1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x2140
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0x9a4d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9a98
leaq -0x28(%rbp), %rdi
callq 0x2030
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x9a6a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9a98
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq 0x1dfd(%rip), %rdx      # 0xb87a
callq 0x2190
cmpq $0x0, %rax
jne 0x9a91
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9a98
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/util.c
// Function: hasinput
int
hasinput(int fd)
{
	fd_set fds;
	struct timeval timeout;

	if(fd < 0) return 0;

	timeout.tv_sec = 0;
	timeout.tv_usec = 0;
	FD_ZERO(&fds);
	FD_SET(fd, &fds);
	return select(fd+1, &fds, NULL, NULL, &timeout) > 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x9ad0
movl $0x0, -0x4(%rbp)
jmp 0x9b97
movq $0x0, -0x98(%rbp)
movq $0x0, -0x90(%rbp)
leaq -0x88(%rbp), %rax
movq %rax, -0xa8(%rbp)
movl $0x0, -0x9c(%rbp)
movl -0x9c(%rbp), %eax
cmpq $0x10, %rax
jae 0x9b30
movq -0xa8(%rbp), %rax
movl -0x9c(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0x9c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x9c(%rbp)
jmp 0x9afe
jmp 0x9b32
movl -0x8(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movl -0x8(%rbp), %eax
movl $0x40, %esi
cltd
idivl %esi
cltq
orq -0x88(%rbp,%rax,8), %rcx
movq %rcx, -0x88(%rbp,%rax,8)
movl -0x8(%rbp), %edi
addl $0x1, %edi
leaq -0x88(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x98(%rbp), %r8
movq %rcx, %rdx
callq 0x2150
cmpl $0x0, %eax
setg %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/util.c
// Function: readn
int
readn(int fd, void *data, int n)
{
	int m;

	while(n > 0){
		m = read(fd, data, n);
		if(m <= 0)
			return -1;
		data += m;
		n -= m;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x9c08
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x2100
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jg 0x9bea
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9c0f
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x18(%rbp), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x9bc2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/util.c
// Function: writen
int
writen(int fd, void *data, int n)
{
	int m;

	while(n > 0){
		m = write(fd, data, n);
		if(m <= 0)
			return -1;
		data += m;
		n -= m;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x9c78
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x2070
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jg 0x9c5a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9c7f
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x18(%rbp), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x9c32
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/util.c
// Function: dial
int
dial(char *host, int port)
{
	char portstr[32];
	int sockfd;
	struct addrinfo *result, *rp, hints;

	memset(&hints, 0, sizeof(hints));
	hints.ai_family = AF_UNSPEC;
	hints.ai_socktype = SOCK_STREAM;

	snprintf(portstr, 32, "%d", port);
	if(getaddrinfo(host, portstr, &hints, &result)){
		perror("error: getaddrinfo");
		return -1;
	}

	for(rp = result; rp; rp = rp->ai_next){
		sockfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
		if(sockfd < 0)
			continue;
		if(connect(sockfd, rp->ai_addr, rp->ai_addrlen) >= 0)
			goto win;
		close(sockfd);
	}
	freeaddrinfo(result);
	perror("error");
	return -1;

win:
	freeaddrinfo(result);
	return sockfd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq -0x88(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x20e0
movl $0x0, -0x84(%rbp)
movl $0x1, -0x80(%rbp)
leaq -0x40(%rbp), %rdi
movl -0x14(%rbp), %ecx
movl $0x20, %esi
leaq 0x1bae(%rip), %rdx      # 0xb887
movb $0x0, %al
callq 0x20b0
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x88(%rbp), %rdx
leaq -0x50(%rbp), %rcx
callq 0x2210
cmpl $0x0, %eax
je 0x9d15
leaq 0x1b86(%rip), %rdi      # 0xb88a
callq 0x21c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9daa
movq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0x9d7d
movq -0x58(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x58(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x58(%rbp), %rax
movl 0xc(%rax), %edx
callq 0x2240
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jge 0x9d49
jmp 0x9d6f
movl -0x44(%rbp), %edi
movq -0x58(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x58(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x21f0
cmpl $0x0, %eax
jl 0x9d67
jmp 0x9d9b
movl -0x44(%rbp), %edi
callq 0x20f0
movq -0x58(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x58(%rbp)
jmp 0x9d1d
movq -0x50(%rbp), %rdi
callq 0x2230
leaq 0x1b10(%rip), %rdi      # 0xb89d
callq 0x21c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9daa
movq -0x50(%rbp), %rdi
callq 0x2230
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/util.c
// Function: serve
void
serve(int port, void (*handlecon)(int, void*), void *arg)
{
	int sockfd, confd;
	socklen_t len;
	struct sockaddr_in server, client;
	int x;

	sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if(sockfd < 0){
		perror("error: socket");
		return;
	}

	x = 1;
	setsockopt (sockfd, SOL_SOCKET, SO_REUSEADDR, (void *)&x, sizeof x);

	memset(&server, 0, sizeof(server));
	server.sin_family = AF_INET;
	server.sin_addr.s_addr = INADDR_ANY;
	server.sin_port = htons(port);
	if(bind(sockfd, (struct sockaddr*)&server, sizeof(server)) < 0){
		perror("error: bind");
		return;
	}
	listen(sockfd, 5);
	len = sizeof(client);
	while(confd = accept(sockfd, (struct sockaddr*)&client, &len),
	      confd >= 0)
		handlecon(confd, arg);
	perror("error: accept");
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2240
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x9dfe
leaq 0x1aaf(%rip), %rdi      # 0xb8a3
callq 0x21c0
jmp 0x9eb9
movl $0x1, -0x48(%rbp)
movl -0x1c(%rbp), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0x48(%rbp), %rcx
movl $0x4, %r8d
callq 0x2050
leaq -0x34(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x20e0
movw $0x2, -0x34(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x4(%rbp), %eax
movzwl %ax, %edi
callq 0x2090
movw %ax, -0x32(%rbp)
movl -0x1c(%rbp), %edi
leaq -0x34(%rbp), %rsi
movl $0x10, %edx
callq 0x2180
cmpl $0x0, %eax
jge 0x9e71
leaq 0x1a47(%rip), %rdi      # 0xb8b1
callq 0x21c0
jmp 0x9eb9
movl -0x1c(%rbp), %edi
movl $0x5, %esi
callq 0x2160
movl $0x10, -0x24(%rbp)
movl -0x1c(%rbp), %edi
leaq -0x44(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x21d0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0x9ead
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq *%rax
jmp 0x9e85
leaq 0x1a09(%rip), %rdi      # 0xb8bd
callq 0x21c0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/util.c
// Function: sleep_ms
void
sleep_ms (uint32 ms)
{
	struct timespec ts;

	if (ms == 0)
		return;

	ts.tv_sec = ms / 1000;
	ts.tv_nsec = (ms % 1000) * 1000000;
	(void)nanosleep (&ts, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x9f13
jmp 0x9f4a
movl -0x4(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divl %ecx
movl %eax, %eax
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divl %ecx
imull $0xf4240, %edx, %eax    # imm = 0xF4240
movl %eax, %eax
movq %rax, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20c0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/dc11_fake.c
// Function: dati_dc11
int
dati_dc11(Bus *bus, void *dev)
{
	if(bus->addr >= 0774000 && bus->addr < 0774400){
		int unit = (bus->addr>>3)&037;
		switch(bus->addr&6){
		/* Receive */
		case 0:
			bus->data = 0;
			break;
		case 2:
			bus->data = 0;
			break;
		/* Transmit */
		case 4:
			bus->data = 0;
			break;
		case 6:
			/* write only */
			bus->data = 0;
			break;
		default: assert(0);	/* can't happen */
		}
		return 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x3f800, 0x8(%rax)     # imm = 0x3F800
jb 0xa013
movq -0x10(%rbp), %rax
cmpl $0x3f900, 0x8(%rax)     # imm = 0x3F900
jae 0xa013
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
shrl $0x3, %eax
andl $0x1f, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x6, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x6, %eax
ja 0x9feb
movq -0x28(%rbp), %rax
leaq 0x191a(%rip), %rcx      # 0xb8cc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movw $0x0, 0xc(%rax)
jmp 0xa00a
movq -0x10(%rbp), %rax
movw $0x0, 0xc(%rax)
jmp 0xa00a
movq -0x10(%rbp), %rax
movw $0x0, 0xc(%rax)
jmp 0xa00a
movq -0x10(%rbp), %rax
movw $0x0, 0xc(%rax)
jmp 0xa00a
leaq 0x1419(%rip), %rdi      # 0xb40b
leaq 0x190f(%rip), %rsi      # 0xb908
movl $0x1b, %edx
leaq 0x190f(%rip), %rcx      # 0xb914
callq 0x20d0
movl $0x0, -0x4(%rbp)
jmp 0xa01a
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/dc11_fake.c
// Function: dato_dc11
int
dato_dc11(Bus *bus, void *dev)
{
	if(bus->addr >= 0774000 && bus->addr < 0774400){
		switch(bus->addr&7){
		/* Receive */
		case 0:
		case 1:
			break;
		case 2:
		case 3:
			/* read only */
			break;
		/* Transmit */
		case 4:
		case 5:
			break;
		case 6:
		case 7:
			break;
		default: assert(0);	/* can't happen */
		}
		return 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x3f800, 0x8(%rax)     # imm = 0x3F800
jb 0xa0b3
movq -0x10(%rbp), %rax
cmpl $0x3f900, 0x8(%rax)     # imm = 0x3F900
jae 0xa0b3
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x7, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x7, %eax
ja 0xa08b
movq -0x20(%rbp), %rax
leaq 0x186e(%rip), %rcx      # 0xb8e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xa0aa
jmp 0xa0aa
jmp 0xa0aa
jmp 0xa0aa
leaq 0x1379(%rip), %rdi      # 0xb40b
leaq 0x186f(%rip), %rsi      # 0xb908
movl $0x36, %edx
leaq 0x188c(%rip), %rcx      # 0xb931
callq 0x20d0
movl $0x0, -0x4(%rbp)
jmp 0xa0ba
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/w4kfu[P]HommI/Bmp/main.c
// Function: main
int main(int argc, char *argv[])
{
	struct bmp *bmp = NULL;

	if (argc != 4)
	{
		fprintf(stderr, "%s <*.BMP|*.bmp|*.bkg> <*.pal> outfile\n", argv[0]);
		return EXIT_FAILURE;
	}

	if ((bmp = convertbmp(argv[1], argv[2])))
	{
		writeImage(argv[3], bmp->width, bmp->height, bmp->data, argv[3]);
		closebmp(bmp);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpl $0x4, -0x8(%rbp)
je 0x161c
movq 0x29fd(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xa6c(%rip), %rsi       # 0x2078
movb $0x0, %al
callq 0x10c0
movl $0x1, -0x4(%rbp)
jmp 0x1678
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x18d0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x1671
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movzwl 0x2(%rax), %esi
movq -0x18(%rbp), %rax
movzwl 0x4(%rax), %edx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %r8
callq 0x12c0
movq -0x18(%rbp), %rdi
callq 0x1870
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/w4kfu[P]HommI/Bmp/bmp.c
// Function: openbmp
struct bmp *openbmp(char *filename)
{
	struct bmp *newbmp = NULL;
	FILE *fin = NULL;
	unsigned int filesize = 0;

	if (!(fin = fopen(filename, "rb")))
	{
		perror("fopen()");
		return NULL;
	}
	if (!(newbmp = malloc(sizeof (struct bmp))))
	{
		perror("malloc()");
		return NULL;
	}

        fseek(fin, 0, SEEK_END);
        filesize = ftell(fin);
        fseek(fin, 0, SEEK_SET);
	if (!(newbmp->buf = malloc(sizeof (char) * filesize)))
	{
		perror("malloc()");
		free(newbmp);
		fclose(fin);
		return NULL;
	}
	if (fread(newbmp->buf, 1, filesize, fin) != filesize)
	{
		perror("fread()");
		free(newbmp);
		fclose(fin);
		return NULL;
	}
	memcpy(newbmp, newbmp->buf, 3 * sizeof (unsigned short));
	if (newbmp->sig != 0x0021)
	{
		fprintf(stderr, "[-] Wrong signature\n");
		free(newbmp->buf);
		free(newbmp);
		fclose(fin);
		return NULL;
	}
	newbmp->data = NULL;
	fclose(fin);
	return newbmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x9e2(%rip), %rsi       # 0x20a0
callq 0x1140
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x16e6
leaq 0x933(%rip), %rdi       # 0x2007
callq 0x1150
movq $0x0, -0x8(%rbp)
jmp 0x1857
movl $0x18, %edi
callq 0x1110
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x1713
leaq 0x9a2(%rip), %rdi       # 0x20a3
callq 0x1150
movq $0x0, -0x8(%rbp)
jmp 0x1857
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x1120
movq -0x20(%rbp), %rdi
callq 0x10d0
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1120
movl -0x24(%rbp), %eax
movl %eax, %edi
shlq $0x0, %rdi
callq 0x1110
movq -0x18(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x1787
leaq 0x940(%rip), %rdi       # 0x20a3
callq 0x1150
movq -0x18(%rbp), %rdi
callq 0x1040
movq -0x20(%rbp), %rdi
callq 0x1070
movq $0x0, -0x8(%rbp)
jmp 0x1857
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x24(%rbp), %eax
movl %eax, %edx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
callq 0x1050
movl -0x24(%rbp), %ecx
cmpq %rcx, %rax
je 0x17d5
leaq 0x8fb(%rip), %rdi       # 0x20ac
callq 0x1150
movq -0x18(%rbp), %rdi
callq 0x1040
movq -0x20(%rbp), %rdi
callq 0x1070
movq $0x0, -0x8(%rbp)
jmp 0x1857
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movl (%rcx), %edx
movl %edx, (%rax)
movw 0x4(%rcx), %cx
movw %cx, 0x4(%rax)
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x21, %eax
je 0x183a
movq 0x27f8(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x8aa(%rip), %rsi       # 0x20b4
movb $0x0, %al
callq 0x10c0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1040
movq -0x18(%rbp), %rdi
callq 0x1040
movq -0x20(%rbp), %rdi
callq 0x1070
movq $0x0, -0x8(%rbp)
jmp 0x1857
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rdi
callq 0x1070
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/w4kfu[P]HommI/Bmp/bmp.c
// Function: closebmp
void closebmp(struct bmp *nbmp)
{
	if (nbmp)
	{
		if (nbmp->buf)
			free(nbmp->buf);
		if (nbmp->data)
			free(nbmp->data);
		free(nbmp);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x18bc
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x189b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x18b3
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/w4kfu[P]HommI/Bmp/bmp.c
// Function: convertbmp
struct bmp* convertbmp(char *filename, char *palettefile)
{
	struct bmp *newbmp = NULL;
	unsigned char *pal = NULL;
	unsigned char *newdata = NULL;
	struct color *rgb = NULL;
	unsigned int y, x;

	if (!(pal = open_palette(palettefile)))
		return NULL;
	if (!(newbmp = openbmp(filename)))
	{
		free(pal);
		return NULL;
	}
	if (!(newdata = malloc(sizeof (char) * newbmp->width * newbmp->height * 3)))
	{
		perror("malloc()");
		free(pal);
		free(newbmp);
		return NULL;
	}
	newbmp->data = newdata;
	rgb = (struct color *)pal;
	for (y = 0; y < newbmp->height; y++)
	{
		for (x = 0; x < newbmp->width; x++)
		{
			memcpy(newdata, &rgb[*(newbmp->buf + (3 * 2) + (x + (y * newbmp->width)))], 3);
			newdata += 3;
		}
	}
	free(pal);
	return newbmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1a60
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x1920
movq $0x0, -0x8(%rbp)
jmp 0x1a56
movq -0x10(%rbp), %rdi
callq 0x1690
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x1949
movq -0x28(%rbp), %rdi
callq 0x1040
movq $0x0, -0x8(%rbp)
jmp 0x1a56
movq -0x20(%rbp), %rax
movzwl 0x2(%rax), %eax
shlq $0x0, %rax
movq -0x20(%rbp), %rcx
movzwl 0x4(%rcx), %ecx
imulq %rcx, %rax
imulq $0x3, %rax, %rdi
callq 0x1110
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x199f
leaq 0x728(%rip), %rdi       # 0x20a3
callq 0x1150
movq -0x28(%rbp), %rdi
callq 0x1040
movq -0x20(%rbp), %rdi
callq 0x1040
movq $0x0, -0x8(%rbp)
jmp 0x1a56
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x20(%rbp), %rcx
movzwl 0x4(%rcx), %ecx
cmpl %ecx, %eax
jae 0x1a45
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
movq -0x20(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jae 0x1a35
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rdx
movq 0x8(%rdx), %rdx
movl -0x40(%rbp), %esi
movl -0x3c(%rbp), %edi
movq -0x20(%rbp), %r8
movzwl 0x2(%r8), %r8d
imull %r8d, %edi
addl %edi, %esi
movl %esi, %esi
movzbl 0x6(%rdx,%rsi), %edx
imulq $0x3, %rdx, %rdx
addq %rdx, %rcx
movw (%rcx), %dx
movw %dx, (%rax)
movb 0x2(%rcx), %cl
movb %cl, 0x2(%rax)
movq -0x30(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x30(%rbp)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x19d0
jmp 0x1a37
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x19ba
movq -0x28(%rbp), %rdi
callq 0x1040
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/JulStrat[P]bams/bams_app.c
// Function: cmp_int
int
cmp_int(const void *first, const void *second)
{
    int a = *(int *) first;
    int b = *(int *) second;

    /*
     * printf("%d %d\n", a, b); 
     */
    if (a < b)
        return -1;
    if (a > b)
        return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x11ef
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1207
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jle 0x1200
movl $0x1, -0x4(%rbp)
jmp 0x1207
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JulStrat[P]bams/./sh_bisect.h
// Function: bisect_left
void *
bisect_left(const void *key, const void *arr,
            size_t el_num, size_t el_size,
            int (*compare) (const void *, const void *))
{
    size_t low = 0;
    size_t high = el_num;
    size_t mid;
    char *off;

    ASSERT_BISECT_ARGS();

    while (low < high) {
        mid = low + ((high - low) >> 1);
        off = (char *) arr + mid * el_size;
        if ((*compare) (key, off) > 0) {
            low = mid + 1;
        } else {
            high = mid;
        }
    }

    return (char *) arr + low * el_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1d15
jmp 0x1d34
leaq 0x2613(%rip), %rdi      # 0x432f
leaq 0x2618(%rip), %rsi      # 0x433b
movl $0x5c, %edx
leaq 0x261a(%rip), %rcx      # 0x4349
callq 0x1050
cmpq $0x0, -0x10(%rbp)
je 0x1d3d
jmp 0x1d5c
leaq 0x2668(%rip), %rdi      # 0x43ac
leaq 0x25f0(%rip), %rsi      # 0x433b
movl $0x5c, %edx
leaq 0x25f2(%rip), %rcx      # 0x4349
callq 0x1050
cmpq $0x0, -0x20(%rbp)
je 0x1d65
jmp 0x1d84
leaq 0x24d0(%rip), %rdi      # 0x423c
leaq 0x25c8(%rip), %rsi      # 0x433b
movl $0x5c, %edx
leaq 0x25ca(%rip), %rcx      # 0x4349
callq 0x1050
cmpq $0x0, -0x28(%rbp)
je 0x1d8d
jmp 0x1dac
leaq 0x2527(%rip), %rdi      # 0x42bb
leaq 0x25a0(%rip), %rsi      # 0x433b
movl $0x5c, %edx
leaq 0x25a2(%rip), %rcx      # 0x4349
callq 0x1050
jmp 0x1dae
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x1e0d
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
subq -0x30(%rbp), %rcx
shrq %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
imulq -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
jle 0x1e03
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1e0b
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x1dae
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
imulq -0x20(%rbp), %rcx
addq %rcx, %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JulStrat[P]bams/bams.c
// Function: bams_create
BAMS *
bams_create(size_t key_size, int (*compare) (const void *, const void *))
{
    BAMS *set;

    assert(NULL != compare);

    set = (BAMS *) malloc(sizeof (BAMS));
    if (!set) {
        return NULL;
    }

    if (key_size) {
        set->key_size = key_size;
        set->type = COPY_DATA;
    } else {
        set->key_size = sizeof (void *);
        set->type = COPY_POINTER;
    }
    set->compare = compare;
    set->head = NULL;
    set->size = 0;

    return set;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x1f9a
jmp 0x1fb9
leaq 0x247b(%rip), %rdi      # 0x441c
leaq 0x2484(%rip), %rsi      # 0x442c
movl $0x52, %edx
leaq 0x247f(%rip), %rcx      # 0x4433
callq 0x1050
movl $0x28, %edi
callq 0x1090
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1fd8
movq $0x0, -0x8(%rbp)
jmp 0x2039
cmpq $0x0, -0x10(%rbp)
je 0x1ff7
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x20(%rax)
jmp 0x200d
movq -0x20(%rbp), %rax
movq $0x8, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JulStrat[P]bams/bams.c
// Function: make_node
static SET_NODE *
make_node(const BAMS * set, const void *key)
{
    SET_NODE *node = (SET_NODE *) malloc(sizeof (SET_NODE));
    void *keys;
    const void *tkey;	

    if (!node) {
        return NULL;
    }

    keys = malloc(set->key_size);
    if (!keys) {
        free(node);
        return NULL;
    }

    if (set->type == COPY_POINTER) {
        POINTER_ADDR(key, tkey);
    }

/*
    switch (set->type) {
      case COPY_DATA:
        memcpy(keys, key, set->key_size);
        break;
      default:
        *(void **) keys = key;
        break;
    }
*/	
	memcpy(keys, key, set->key_size);
	
    node->keys = keys;
    node->length = 1;

    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x18, %edi
callq 0x1090
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x221f
movq $0x0, -0x8(%rbp)
jmp 0x2297
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1090
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x2249
movq -0x20(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
jmp 0x2297
movq -0x10(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x2263
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
callq 0x1070
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x1, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JulStrat[P]bams/bams.c
// Function: bams_min
const void *
bams_min(const BAMS * set)
{
    SET_NODE *curr;
    void *min_key = NULL;

    assert(NULL != set);

    curr = set->head;
    if (set->size > 0) {
        assert(curr != NULL);
        assert(curr->keys != NULL);

        min_key = curr->keys;
        while (NULL != curr->next) {
            curr = curr->next;
            if ((*(set->compare)) (min_key, curr->keys) > 0) {
                min_key = curr->keys;
            }
        }
    }

    if (set->type == COPY_POINTER) {
        return *(void **) min_key;
    } else {
        return min_key;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x22ce
jmp 0x22ed
leaq 0x219d(%rip), %rdi      # 0x4472
leaq 0x2150(%rip), %rsi      # 0x442c
movl $0xa4, %edx
leaq 0x21c8(%rip), %rcx      # 0x44b0
callq 0x1050
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jbe 0x23a9
cmpq $0x0, -0x18(%rbp)
je 0x2311
jmp 0x2330
leaq 0x21bb(%rip), %rdi      # 0x44d3
leaq 0x210d(%rip), %rsi      # 0x442c
movl $0xa8, %edx
leaq 0x2185(%rip), %rcx      # 0x44b0
callq 0x1050
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x233d
jmp 0x235c
leaq 0x219c(%rip), %rdi      # 0x44e0
leaq 0x20e1(%rip), %rsi      # 0x442c
movl $0xa9, %edx
leaq 0x2159(%rip), %rcx      # 0x44b0
callq 0x1050
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x23a7
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
jle 0x23a5
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2368
jmp 0x23a9
movq -0x10(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x23c0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x23c8
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JulStrat[P]bams/bams.c
// Function: bams_max
const void *
bams_max(const BAMS * set)
{
    SET_NODE *curr;
    size_t key_size;
    char *last = NULL;
    char *max_key = NULL;

    assert(NULL != set);

    curr = set->head;
    key_size = set->key_size;

    if (set->size > 0) {
        assert(curr != NULL);
        assert(curr->keys != NULL);

        max_key = (char *) curr->keys + (curr->length - 1) * key_size;
        while (NULL != curr->next) {
            curr = curr->next;
            last = (char *) curr->keys + (curr->length - 1) * key_size;
            if ((*(set->compare)) (last, max_key) > 0) {
                max_key = last;
            }
        }
    }

    if (set->type == COPY_POINTER) {
        return *(void **) max_key;
    } else {
        return max_key;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x2406
jmp 0x2425
leaq 0x2065(%rip), %rdi      # 0x4472
leaq 0x2018(%rip), %rsi      # 0x442c
movl $0xc3, %edx
leaq 0x20d3(%rip), %rcx      # 0x44f3
callq 0x1050
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jbe 0x2518
cmpq $0x0, -0x18(%rbp)
je 0x2454
jmp 0x2473
leaq 0x2078(%rip), %rdi      # 0x44d3
leaq 0x1fca(%rip), %rsi      # 0x442c
movl $0xc9, %edx
leaq 0x2085(%rip), %rcx      # 0x44f3
callq 0x1050
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2480
jmp 0x249f
leaq 0x2059(%rip), %rdi      # 0x44e0
leaq 0x1f9e(%rip), %rsi      # 0x442c
movl $0xca, %edx
leaq 0x2059(%rip), %rcx      # 0x44f3
callq 0x1050
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
imulq -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x2516
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
imulq -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
jle 0x2514
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x24bf
jmp 0x2518
movq -0x10(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x252f
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2537
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JulStrat[P]bams/bams.c
// Function: bams_count_less
size_t
bams_count_less(const BAMS * set, const void *key)
{
    SET_NODE *curr;
    size_t key_size;
    char *off;
    size_t less = 0;
    const void *tkey;

    assert(NULL != set);
    assert(NULL != key);

    curr = set->head;
    key_size = set->key_size;

    if (set->type == COPY_POINTER) {
        POINTER_ADDR(key, tkey);
    }

    while (NULL != curr) {
        off = (char *) bisect_left(key, curr->keys, curr->length,
                                   key_size, set->compare);
        assert(off >= (char *) curr->keys);
        less += off - (char *) curr->keys;
        curr = curr->next;
    }

    return (size_t) (less / key_size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x30(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
je 0x2572
jmp 0x2591
leaq 0x1ef9(%rip), %rdi      # 0x4472
leaq 0x1eac(%rip), %rsi      # 0x442c
movl $0xe6, %edx
leaq 0x1f8a(%rip), %rcx      # 0x4516
callq 0x1050
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x259b
jmp 0x25ba
leaq 0x1f02(%rip), %rdi      # 0x44a4
leaq 0x1e83(%rip), %rsi      # 0x442c
movl $0xe7, %edx
leaq 0x1f61(%rip), %rcx      # 0x4516
callq 0x1050
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x25eb
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x25ed
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x2674
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %r8
callq 0x1ce0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x262e
jmp 0x264d
leaq 0x1f14(%rip), %rdi      # 0x4549
leaq 0x1df0(%rip), %rsi      # 0x442c
movl $0xf3, %edx
leaq 0x1ece(%rip), %rcx      # 0x4516
callq 0x1050
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x25ed
movq -0x30(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x20(%rbp)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JulStrat[P]bams/bams.c
// Function: bams_count_equal
size_t
bams_count_equal(const BAMS * set, const void *key)
{
    SET_NODE *curr;
    size_t key_size;
    char *low, *high;
    size_t equal = 0;
    const void *tkey;

    assert(NULL != set);
    assert(NULL != key);

    curr = set->head;
    key_size = set->key_size;

    if (set->type == COPY_POINTER) {
        POINTER_ADDR(key, tkey);
    }

    while (NULL != curr) {
        low = (char *) bisect_left(key, curr->keys, curr->length,
                                   key_size, set->compare);
        high = (char *) bisect_right(key, curr->keys, curr->length,
                                     key_size, set->compare);
        assert(high >= low);
        equal += high - low;
        curr = curr->next;
    }

    return (size_t) (equal / key_size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x38(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
je 0x26b2
jmp 0x26d1
leaq 0x1db9(%rip), %rdi      # 0x4472
leaq 0x1d6c(%rip), %rsi      # 0x442c
movl $0x104, %edx            # imm = 0x104
leaq 0x1e98(%rip), %rcx      # 0x4564
callq 0x1050
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x26db
jmp 0x26fa
leaq 0x1dc2(%rip), %rdi      # 0x44a4
leaq 0x1d43(%rip), %rsi      # 0x442c
movl $0x105, %edx            # imm = 0x105
leaq 0x1e6f(%rip), %rcx      # 0x4564
callq 0x1050
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x272b
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x272d
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x27d9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %r8
callq 0x1ce0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %r8
callq 0x1e30
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x2797
jmp 0x27b6
leaq 0x1dfa(%rip), %rdi      # 0x4598
leaq 0x1c87(%rip), %rsi      # 0x442c
movl $0x113, %edx            # imm = 0x113
leaq 0x1db3(%rip), %rcx      # 0x4564
callq 0x1050
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x272d
movq -0x38(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x20(%rbp)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JulStrat[P]bams/bams.c
// Function: bams_count_great
size_t
bams_count_great(const BAMS * set, const void *key)
{
    SET_NODE *curr;
    size_t key_size;
    char *low, *high;
    size_t great = 0;
    const void *tkey;

    assert(NULL != set);
    assert(NULL != key);

    curr = set->head;
    key_size = set->key_size;

    if (set->type == COPY_POINTER) {
        POINTER_ADDR(key, tkey);
    }

    while (NULL != curr) {
        low = (char *) bisect_right(key, curr->keys, curr->length,
                                    key_size, set->compare);
        high = (char *) curr->keys + curr->length * key_size;
        assert(high >= low);
        great += high - low;
        curr = curr->next;
    }

    return (size_t) (great / key_size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x38(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
je 0x2812
jmp 0x2831
leaq 0x1c59(%rip), %rdi      # 0x4472
leaq 0x1c0c(%rip), %rsi      # 0x442c
movl $0x124, %edx            # imm = 0x124
leaq 0x1d78(%rip), %rcx      # 0x45a4
callq 0x1050
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x283b
jmp 0x285a
leaq 0x1c62(%rip), %rdi      # 0x44a4
leaq 0x1be3(%rip), %rsi      # 0x442c
movl $0x125, %edx            # imm = 0x125
leaq 0x1d4f(%rip), %rcx      # 0x45a4
callq 0x1050
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x288b
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x288d
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x292c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %r8
callq 0x1e30
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
imulq -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x28ea
jmp 0x2909
leaq 0x1ca7(%rip), %rdi      # 0x4598
leaq 0x1b34(%rip), %rsi      # 0x442c
movl $0x132, %edx            # imm = 0x132
leaq 0x1ca0(%rip), %rcx      # 0x45a4
callq 0x1050
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x288d
movq -0x38(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x20(%rbp)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/JulStrat[P]bams/bams.c
// Function: bams_array
void *
bams_array(const BAMS * set, size_t *key_num)
{
    SET_NODE *curr;
    char *r = NULL;
    char *t;

    assert(NULL != set);
    assert(NULL != key_num);

    curr = set->head;
    *key_num = 0;
    while (NULL != curr) {
        t = merge_into(r, *key_num, curr->keys, curr->length,
                       set->key_size, set->compare);
        /*
         * free(r); 
         */
        r = t;
        *key_num += curr->length;
        curr = curr->next;
    }

    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
je 0x2f12
jmp 0x2f31
leaq 0x1559(%rip), %rdi      # 0x4472
leaq 0x150c(%rip), %rsi      # 0x442c
movl $0x1c2, %edx            # imm = 0x1C2
leaq 0x176a(%rip), %rcx      # 0x4696
callq 0x1050
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x2f3b
jmp 0x2f5a
leaq 0x16cc(%rip), %rdi      # 0x460e
leaq 0x14e3(%rip), %rsi      # 0x442c
movl $0x1c3, %edx            # imm = 0x1C3
leaq 0x1741(%rip), %rcx      # 0x4696
callq 0x1050
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x2fd3
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %r8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %r9
callq 0x1ac0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2f71
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JulStrat[P]bams/bams.c
// Function: bams_clear
void
bams_clear(BAMS * set)
{
    SET_NODE *curr;
    SET_NODE *next;

    assert(NULL != set);

    curr = set->head;
    while (NULL != curr) {
        next = curr->next;
        free(curr->keys);
        free(curr);
        curr = next;
    }
    set->head = NULL;
    set->size = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
je 0x3046
jmp 0x3065
leaq 0x1425(%rip), %rdi      # 0x4472
leaq 0x13d8(%rip), %rsi      # 0x442c
movl $0x1e3, %edx            # imm = 0x1E3
leaq 0x167e(%rip), %rcx      # 0x46de
callq 0x1050
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x30a4
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x3071
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JulStrat[P]bams/bams.c
// Function: bams_free
void
bams_free(BAMS * set)
{
    SET_NODE *curr;
    SET_NODE *next;

    assert(NULL != set);

    curr = set->head;
    while (NULL != curr) {
        next = curr->next;
        free(curr->keys);
        free(curr);
        curr = next;
    }
    free(set);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
je 0x30e6
jmp 0x3105
leaq 0x1385(%rip), %rdi      # 0x4472
leaq 0x1338(%rip), %rsi      # 0x442c
movl $0x1f6, %edx            # imm = 0x1F6
leaq 0x15f6(%rip), %rcx      # 0x46f6
callq 0x1050
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x3144
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x3111
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JulStrat[P]bams/bams.c
// Function: bams_check_structure
int
bams_check_structure(const BAMS * set)
{
    SET_NODE *curr;
    char *off;

    size_t set_size = 0;
    size_t node_len = 0;
    size_t key_size;

    assert(NULL != set);

    curr = set->head;
    key_size = set->key_size;

    while (NULL != curr) {
        if ((node_len >= curr->length) || (0 == curr->length)) {
            return 1;
        }
        /*
         * check if node length is power of two 
         */
        node_len = curr->length;
        /*
         * printf("node len: %d\n", node_len); 
         */
        while (0 == (node_len & 1)) {
            node_len >>= 1;
        }
        if (node_len > 1) {
            return 2;
        }
        node_len = curr->length;
        set_size += node_len;

        /*
         * check current node keys 
         */
        off = (char *) (curr->keys);
        while (node_len-- > 1) {
            if ((set->compare) (off, off + key_size) > 0) {
                return 3;
            }
            off += key_size;
        }

        curr = curr->next;
    }
    if (set_size != set->size) {
        return 4;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x3186
jmp 0x31a5
leaq 0x12e5(%rip), %rdi      # 0x4472
leaq 0x1298(%rip), %rsi      # 0x442c
movl $0x20c, %edx            # imm = 0x20C
leaq 0x156d(%rip), %rcx      # 0x470d
callq 0x1050
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x32a4
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x31e2
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq 0x8(%rcx), %rax
jne 0x31ee
movl $0x1, -0x4(%rbp)
jmp 0x32c2
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
andq $0x1, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x3216
movq -0x30(%rbp), %rax
shrq %rax
movq %rax, -0x30(%rbp)
jmp 0x31fa
cmpq $0x1, -0x30(%rbp)
jbe 0x3229
movl $0x2, -0x4(%rbp)
jmp 0x32c2
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x30(%rbp)
cmpq $0x1, %rax
jbe 0x3294
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq -0x38(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
jle 0x3286
movl $0x3, -0x4(%rbp)
jmp 0x32c2
movq -0x38(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x324d
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x31bc
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
je 0x32bb
movl $0x4, -0x4(%rbp)
jmp 0x32c2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/src/key.c
// Function: SH_Key__destroy
void
SH_Key__destroy(SH_Key* obj, int* err) {
	__cascade(err,);
	if ((sh_char_t*)0 != obj->value) {
		free(obj->value);
	}
	free(obj);
	__clear(err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x1364
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x1364
jmp 0x1396
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x137b
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x1396
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/src/key.c
// Function: SH_Key__hash
uint8_t
SH_Key__hash(SH_Key* obj, int* err) {
	size_t buflen;
	uint8_t* ptr;
	uint8_t hsh = UINT8_C(1);

	__cascade(err, UINT8_C(0));

	buflen = obj->length; /* assumes sizeof(uint8_t) and sizeof(sh_char_t) are both 1 */
	ptr = (uint8_t*)(obj->value);

	for (; buflen > 0; buflen--) {
		hsh = (hsh << 3) | (hsh >> 5);
		hsh ^= (uint8_t)*ptr;
		ptr++;
	}

	__clear(err);
	return hsh;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x1, -0x29(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x13c8
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x13c8
movb $0x0, -0x1(%rbp)
jmp 0x143b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x1423
movzbl -0x29(%rbp), %eax
shll $0x3, %eax
movzbl -0x29(%rbp), %ecx
sarl $0x5, %ecx
orl %ecx, %eax
movb %al, -0x29(%rbp)
movq -0x28(%rbp), %rax
movzbl (%rax), %ecx
movzbl -0x29(%rbp), %eax
xorl %ecx, %eax
movb %al, -0x29(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x13df
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x1435
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movb -0x29(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq