LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/xconfig.c
// Function: unset_option
static void unset_option(struct xconfig_option *option) {
	switch (option->type) {
	case XCONFIG_STRING:
		if (*(char **)option->dest.s) {
			free(*(char **)option->dest.s);
			*(char **)option->dest.s = NULL;
		}
		break;
	case XCONFIG_STR_LIST:
		if (*(char ***)option->dest.sl) {
			if ((*(char ***)option->dest.sl)[0]) {
				free((*(char ***)option->dest.sl)[0]);
			}
			free(*(char ***)option->dest.sl);
			*(char ***)option->dest.sl = NULL;
		}
		break;
	default:
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x3, %eax
je 0xd5d9
jmp 0xd5cc
movl -0xc(%rbp), %eax
subl $0x4, %eax
je 0xd608
jmp 0xd65b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, (%rax)
je 0xd606
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
callq 0x42e0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq $0x0, (%rax)
jmp 0xd65d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, (%rax)
je 0xd659
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
cmpq $0x0, (%rax)
je 0xd63a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x42e0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
callq 0x42e0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq $0x0, (%rax)
jmp 0xd65d
jmp 0xd65d
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/xmalloc.c
// Function: xmalloc
void *xmalloc(size_t s) {
	void *mem = malloc(s);
	if (!mem) {
		perror(NULL);
		exit(EXIT_FAILURE);
	}
	return mem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x41f0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xd8c3
xorl %eax, %eax
movl %eax, %edi
callq 0x46e0
movl $0x1, %edi
callq 0x4170
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/xmalloc.c
// Function: xrealloc
void *xrealloc(void *p, size_t s) {
	void *mem = realloc(p, s);
	if (!mem && s != 0) {
		perror(NULL);
		exit(EXIT_FAILURE);
	}
	return mem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x46c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xd952
cmpq $0x0, -0x10(%rbp)
je 0xd952
xorl %eax, %eax
movl %eax, %edi
callq 0x46e0
movl $0x1, %edi
callq 0x4170
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mati75[P]evilwm/xmalloc.c
// Function: xmemdup
void *xmemdup(const void *p, size_t s) {
	if (!p)
		return NULL;
	void *mem = xmalloc(s);
	memcpy(mem, p, s);
	return mem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xd981
movq $0x0, -0x8(%rbp)
jmp 0xd9a7
movq -0x18(%rbp), %rdi
callq 0xd890
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4750
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/jacereda[P]fsatrace/src/fsatrace.c
// Function: fatal
static void
fatal(const char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	errv(fmt, "fatal error: ", ap);
	va_end(ap);
	exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x1725
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rdx
leaq 0x1abd(%rip), %rsi      # 0x323c
callq 0x1ac0
leaq -0x20(%rbp), %rax
movl $0x1, %edi
callq 0x11d0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/fsatrace.c
// Function: uniq
static void
uniq(char *d, size_t *tot, const char *s, const char *last, size_t lastsz)
{
	const char *end = strchr(s, '\n');
	size_t	    sz = end - s;
	if (!end) {
		strcpy(d, s);
		*tot += strlen(s);
	} else if (sz != lastsz || strncmp(s, last, lastsz)) {
		memcpy(d, s, sz + 1);
		*tot += sz + 1;
		uniq(d + sz + 1, tot, end + 1, s, sz);
	} else
		uniq(d, tot, end + 1, last, lastsz);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movl $0xa, %esi
callq 0x10d0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x18cc
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1060
movq -0x18(%rbp), %rdi
callq 0x10b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x1959
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x18ec
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x1040
cmpl $0x0, %eax
je 0x193a
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
addq $0x1, %rdx
callq 0x1150
movq -0x38(%rbp), %rcx
addq $0x1, %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
addq -0x38(%rbp), %rdi
addq $0x1, %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
addq $0x1, %rdx
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %r8
callq 0x1860
jmp 0x1957
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
addq $0x1, %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x1860
jmp 0x1959
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/fsatrace.c
// Function: dump
static void
dump(const char *path, char *p, size_t sz)
{
	int	fd;
	ssize_t r = 0;
	if (strcmp(path, "-"))
		fd = open(path, O_CREAT | O_WRONLY | O_TRUNC, 0777);
	else
		fd = 1;
	if (fd >= 0)
		r = write(fd, p, sz);
	else
		error("Unable to open output file '%s'", path);
	if (r != sz)
		error("Short write (%d/%d)", r, sz);
	if (fd != 1)
		close(fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1697(%rip), %rsi      # 0x301e
callq 0x1130
cmpl $0x0, %eax
je 0x19ab
movq -0x8(%rbp), %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x1ff, %edx            # imm = 0x1FF
movb $0x0, %al
callq 0x11a0
movl %eax, -0x1c(%rbp)
jmp 0x19b2
movl $0x1, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x19ce
movl -0x1c(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1090
movq %rax, -0x28(%rbp)
jmp 0x19e0
movq -0x8(%rbp), %rsi
leaq 0x1882(%rip), %rdi      # 0x325b
movb $0x0, %al
callq 0x1a20
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x1a00
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x1882(%rip), %rdi      # 0x327b
movb $0x0, %al
callq 0x1a20
cmpl $0x1, -0x1c(%rbp)
je 0x1a0e
movl -0x1c(%rbp), %edi
callq 0x1110
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/fsatrace.c
// Function: errv
static void
errv(const char *fmt, const char *pref, va_list ap)
{
	char fullpath[PATH_MAX];
	char *es = strerror(errno);
	procPath(fullpath);
	fprintf(stderr, "%s(%d): %s", basename(fullpath), getpid(), pref);
	vfprintf(stderr, fmt, ap);
	fprintf(stderr, ": %s\n", es);
	fflush(stderr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1040, %rsp           # imm = 0x1040
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x1030
movl (%rax), %edi
callq 0x11f0
movq %rax, -0x1028(%rbp)
leaq -0x1020(%rbp), %rdi
callq 0x1b90
movq 0x34fb(%rip), %rax      # 0x4ff8
movq (%rax), %rax
movq %rax, -0x1038(%rbp)
leaq -0x1020(%rbp), %rdi
callq 0x1160
movq %rax, -0x1030(%rbp)
callq 0x10a0
movq -0x1038(%rbp), %rdi
movq -0x1030(%rbp), %rdx
movl %eax, %ecx
movq -0x10(%rbp), %r8
leaq 0x1710(%rip), %rsi      # 0x324a
movb $0x0, %al
callq 0x1140
movq 0x34b0(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x11b0
movq 0x3499(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x1028(%rbp), %rdx
leaq 0x16e5(%rip), %rsi      # 0x3255
movb $0x0, %al
callq 0x1140
movq 0x347a(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
callq 0x1170
addq $0x1040, %rsp           # imm = 0x1040
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/proc.c
// Function: procPath
void
procPath(char *fullpath)
{
#if defined __linux__
	char	exepath[64];
	ssize_t ret;
	snprintf(exepath, sizeof(exepath), "/proc/%d/exe", getpid());
	ret = readlink(exepath, fullpath, PATH_MAX);
	assert(ret != -1);
	fullpath[ret] = 0;
#else
	proc_pidpath(getpid(), fullpath, PATH_MAX);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x10a0
movq -0x60(%rbp), %rdi
movl %eax, %ecx
movl $0x40, %esi
leaq 0x16d4(%rip), %rdx      # 0x328f
movb $0x0, %al
callq 0x10e0
leaq -0x50(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x1070
movq %rax, -0x58(%rbp)
cmpq $-0x1, -0x58(%rbp)
je 0x1be1
jmp 0x1c00
leaq 0x16b4(%rip), %rdi      # 0x329c
leaq 0x16b7(%rip), %rsi      # 0x32a6
movl $0x16, %edx
leaq 0x16bb(%rip), %rcx      # 0x32b6
callq 0x1100
movq -0x8(%rbp), %rax
movq -0x58(%rbp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/proc.c
// Function: procRun
enum procerr
procRun(unsigned nargs, char *const args[], int *rc)
{
	extern char **environ;
	int	      ret;
	int	      child;
	char	      so[PATH_MAX + 3];
	char	      fullpath[PATH_MAX];
	procPath(fullpath);
	snprintf(so, sizeof(so), "%s.so", fullpath);
#if defined __linux__
	setenv("LD_PRELOAD", so, 1);
#else
	setenv("DYLD_INSERT_LIBRARIES", so, 1);
	setenv("DYLD_FORCE_FLAT_NAMESPACE", "1", 1);
#endif

#if 0
	if (posix_spawnp(&child, args[0], 0, 0, args, environ))
		ret = ERR_PROC_FORK;
	else
		ret = waitchild(child, rc);
#else
	child = fork();
	switch (child) {
	case -1:
		ret = ERR_PROC_FORK;
		break;
	case 0:
		execvp(args[0], args);
		_exit(EXIT_FAILURE);
		break;
	default:
		ret = waitchild(child, rc);
	}
#endif
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2050, %rsp           # imm = 0x2050
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x2030(%rbp), %rdi
movq %rdi, -0x2048(%rbp)
callq 0x1b90
movq -0x2048(%rbp), %rcx
leaq 0x1622(%rip), %rdx      # 0x32d9
xorl %eax, %eax
leaq -0x1030(%rbp), %rdi
movq %rdi, -0x2040(%rbp)
movl $0x1003, %esi           # imm = 0x1003
callq 0x10e0
movq -0x2040(%rbp), %rsi
leaq 0x1600(%rip), %rdi      # 0x32df
movl $0x1, %edx
callq 0x1080
callq 0x1210
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x2034(%rbp)
subl $-0x1, %eax
je 0x1d0d
jmp 0x1d01
movl -0x2034(%rbp), %eax
testl %eax, %eax
je 0x1d16
jmp 0x1d30
movl $0x1, -0x1c(%rbp)
jmp 0x1d3f
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x11c0
movl $0x1, %edi
callq 0x1050
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x1d50
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x2050, %rsp           # imm = 0x2050
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/proc.c
// Function: waitchild
static enum procerr
waitchild(int child, int *rc)
{
	enum procerr ret;
	if (-1 != waitpid(child, rc, 0)) {
		int st = *rc;
		if (WIFEXITED(st)) {
			ret = ERR_PROC_OK;
			*rc = WEXITSTATUS(st);
		} else if (WIFSIGNALED(st)) {
			ret = ERR_PROC_SIGNALED;
			*rc = WTERMSIG(st);
		} else if (WIFSTOPPED(st)) {
			ret = ERR_PROC_STOPPED;
			*rc = WSTOPSIG(st);
		} else {
			ret = ERR_PROC_UNKNOWN;
		}
	} else
		ret = ERR_PROC_WAIT;
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x1190
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
je 0x1e08
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x1dab
movl $0x0, -0x14(%rbp)
movl -0x18(%rbp), %ecx
andl $0xff00, %ecx           # imm = 0xFF00
sarl $0x8, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x1e06
movl -0x18(%rbp), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
jle 0x1dd3
movl $0x3, -0x14(%rbp)
movl -0x18(%rbp), %ecx
andl $0x7f, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x1e04
movl -0x18(%rbp), %eax
andl $0xff, %eax
cmpl $0x7f, %eax
jne 0x1dfb
movl $0x4, -0x14(%rbp)
movl -0x18(%rbp), %ecx
andl $0xff00, %ecx           # imm = 0xFF00
sarl $0x8, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x1e02
movl $0x6, -0x14(%rbp)
jmp 0x1e04
jmp 0x1e06
jmp 0x1e0f
movl $0x5, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/shm.c
// Function: hash
static unsigned long
hash(unsigned char *str)
{
	unsigned long h = 5381;
	int	      c;
	while ((c = *str++))
		h = ((h << 5) + h) + c;
	return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x1505, -0x10(%rbp)    # imm = 0x1505
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x2023
movq -0x10(%rbp), %rax
shlq $0x5, %rax
addq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x1ff0
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/unix/shm.c
// Function: shmTerm
int
shmTerm(struct shm *shm, int root)
{
	struct priv *p = (struct priv *)shm->storage;
	int	     err = 0;
	err += (-1 == munmap(shm->buf, p->sz)) << 0;
	err += (-1 == close(p->fd)) << 1;
	err += (root && (-1 == shm_unlink(shm->name))) << 2;
	return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $0x1008, %rax           # imm = 0x1008
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x1180
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
shll $0x0, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0x1110
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
shll %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x1d(%rbp)
je 0x20cd
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x1200
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
shll $0x2, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ryo[P]shmqueue/shmdump.c
// Function: main
int
main(int argc, char *argv[])
{
	int ch, id;
	int opt_t = 0;
	int opt_s = 0;

	while ((ch = getopt(argc, argv, "st")) != -1) {
		switch (ch) {
		case 's':
			opt_s = 1;
			break;
		case 't':
			opt_t = 1;
			break;
		default:
			usage();
			return 1;
		}
	}
	argc -= optind;
	argv += optind;

	id = shmget(MEMID, MEMSIZE, 0);
	if (id == -1)
		err(1, "shmget");

	shmqueue = shmqueue_new(MEMID, 0, 1, 0);

	if (opt_s) {
		shmqueue_dump_statistics(shmqueue);
		return 0;
	}


	if (opt_t) {
		shmqueue_dump_tsv(shmqueue);
	} else {
		shmqueue_dumpall(shmqueue);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0x2de5(%rip), %rdx      # 0x4017
callq 0x10b0
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
je 0x127b
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x73, %eax
je 0x1256
jmp 0x124c
movl -0x24(%rbp), %eax
subl $0x74, %eax
je 0x125f
jmp 0x1268
movl $0x1, -0x20(%rbp)
jmp 0x1279
movl $0x1, -0x1c(%rbp)
jmp 0x1279
callq 0x11e0
movl $0x1, -0x4(%rbp)
jmp 0x1332
jmp 0x1224
movq 0x4d5e(%rip), %rax      # 0x5fe0
movl (%rax), %ecx
movl -0x8(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x8(%rbp)
movq 0x4d4d(%rip), %rax      # 0x5fe0
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl $0x186a0, %edi          # imm = 0x186A0
movl $0x10000000, %esi       # imm = 0x10000000
xorl %edx, %edx
callq 0x10d0
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
jne 0x12d4
movl $0x1, %edi
leaq 0x2d4d(%rip), %rsi      # 0x401a
movb $0x0, %al
callq 0x1080
movl $0x186a0, %edi          # imm = 0x186A0
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x1ca0
movq %rax, 0x4d98(%rip)      # 0x6088
cmpl $0x0, -0x20(%rbp)
je 0x130b
movq 0x4d8b(%rip), %rdi      # 0x6088
callq 0x1b80
movl $0x0, -0x4(%rbp)
jmp 0x1332
cmpl $0x0, -0x1c(%rbp)
je 0x131f
movq 0x4d70(%rip), %rdi      # 0x6088
callq 0x19d0
jmp 0x132b
movq 0x4d62(%rip), %rdi      # 0x6088
callq 0x14b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryo[P]shmqueue/shmqueue.c
// Function: shmqueue_hash_string
uint32_t
shmqueue_hash_string(uint8_t *key)
{
	uint32_t hash = 0;
	uint8_t *p, c;

	p = key;

	while ((c = *p++) != 0)
		hash = (hash << 5) - hash + c;

	return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb (%rax), %al
movb %al, -0x19(%rbp)
movzbl %al, %eax
cmpl $0x0, %eax
je 0x1387
movl -0xc(%rbp), %eax
shll $0x5, %eax
subl -0xc(%rbp), %eax
movzbl -0x19(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
jmp 0x1357
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ryo[P]shmqueue/shmqueue.c
// Function: shmqueue_dumpitem
void
shmqueue_dumpitem(struct shmqueue_item *item)
{
	printf("      shi_hashidx=%d\n", item->shi_hashidx);
	printf("      shi_keyvalue.keysize=<%d>\n", item->shi_keyvalue.kv_keysize);
	printf("      shi_keyvalue.storagesize=%u\n", item->shi_keyvalue.kv_storagesize);
	printf("      shi_keyvalue.key(%p)=<%s>\n", KEYVALUE_KEY(&item->shi_keyvalue), KEYVALUE_KEY(&item->shi_keyvalue));
	printf("      shi_keyvalue.storage(%p)=<%s>\n", KEYVALUE_STORAGE(&item->shi_keyvalue), KEYVALUE_STORAGE(&item->shi_keyvalue));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %esi
leaq 0x2ca6(%rip), %rdi      # 0x4050
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rax
movl 0x24(%rax), %esi
leaq 0x2ca7(%rip), %rdi      # 0x4066
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rax
movl 0x28(%rax), %esi
leaq 0x2cb3(%rip), %rdi      # 0x4087
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rsi
addq $0x24, %rsi
addq $0x8, %rsi
movq -0x8(%rbp), %rdx
addq $0x24, %rdx
addq $0x8, %rdx
leaq 0x2cb0(%rip), %rdi      # 0x40aa
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rsi
addq $0x24, %rsi
addq $0x8, %rsi
movq -0x8(%rbp), %rax
movl 0x24(%rax), %eax
addq %rax, %rsi
movq -0x8(%rbp), %rdx
addq $0x24, %rdx
addq $0x8, %rdx
movq -0x8(%rbp), %rax
movl 0x24(%rax), %eax
addq %rax, %rdx
leaq 0x2c97(%rip), %rdi      # 0x40cb
movb $0x0, %al
callq 0x1050
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryo[P]shmqueue/shmqueue.c
// Function: shmqueue_dump
void
shmqueue_dump(struct shmqueue *shmq_header)
{
	struct shmqueue_header *header;

	header = shmq_header->header;

	printf("queue usage: %u/%u %2.3g%%\n",
	    header->sha_item_inuse,
	    header->sha_itemnum,
	    (double)header->sha_item_inuse * 100.0 / header->sha_itemnum);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movl 0x30(%rcx), %eax
movl 0x34(%rcx), %ecx
movl %ecx, %esi
movl %eax, %edx
cvtsi2sd %rcx, %xmm0
movsd 0x2ba6(%rip), %xmm1     # 0x4028
mulsd %xmm1, %xmm0
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
leaq 0x2c5a(%rip), %rdi      # 0x40f0
movb $0x1, %al
callq 0x1050
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryo[P]shmqueue/shmqueue.c
// Function: shmqueue_dump_tsv
void
shmqueue_dump_tsv(struct shmqueue *shmq_header)
{
	struct shmqueue_header *header;
	struct shmqueue_item *item;

	header = shmq_header->header;

	for (item = RTAILQ_FIRST(&header->sha_lrulist, shmqueue_item);
	    item != NULL;
	    item = RTAILQ_NEXT(item, &header->sha_lrulist, shmqueue_item, shi_list)) {

		printf("%s\t", KEYVALUE_KEY(&item->shi_keyvalue));
		dumpdata(KEYVALUE_STORAGE(&item->shi_keyvalue), item->shi_keyvalue.kv_storagesize);
		printf("\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x19fa
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x1a11
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1a9f
movq -0x18(%rbp), %rsi
addq $0x24, %rsi
addq $0x8, %rsi
leaq 0x2808(%rip), %rdi      # 0x423b
movb $0x0, %al
callq 0x1050
movq -0x18(%rbp), %rdi
addq $0x24, %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rax
movl 0x24(%rax), %eax
addq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x28(%rax), %esi
callq 0x1ab0
leaq 0x26a7(%rip), %rdi      # 0x410a
movb $0x0, %al
callq 0x1050
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1a7c
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x1a92
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x1a19
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryo[P]shmqueue/shmqueue.c
// Function: dumpdata
static void
dumpdata(uint8_t *p, uint32_t len)
{
	uint8_t c;
	printf("%u\t\"", len);

	for (; len > 0; len--) {
		c = *p++;
		if ((c < 0x20) || (c >= 0x7f) || (c == '"') || (c == '\'') ||
		    (c == '$') || (c == '%') || (c == '\\')) {

			printf("\\x%02x", c);
		} else {
			printf("%c", c);
		}
	}

	printf("\"");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %esi
leaq 0x29d7(%rip), %rdi      # 0x44a0
movb $0x0, %al
callq 0x1050
cmpl $0x0, -0xc(%rbp)
jbe 0x1b63
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %al
movb %al, -0xd(%rbp)
movzbl -0xd(%rbp), %eax
cmpl $0x20, %eax
jl 0x1b2d
movzbl -0xd(%rbp), %eax
cmpl $0x7f, %eax
jge 0x1b2d
movzbl -0xd(%rbp), %eax
cmpl $0x22, %eax
je 0x1b2d
movzbl -0xd(%rbp), %eax
cmpl $0x27, %eax
je 0x1b2d
movzbl -0xd(%rbp), %eax
cmpl $0x24, %eax
je 0x1b2d
movzbl -0xd(%rbp), %eax
cmpl $0x25, %eax
je 0x1b2d
movzbl -0xd(%rbp), %eax
cmpl $0x5c, %eax
jne 0x1b41
movzbl -0xd(%rbp), %esi
leaq 0x296d(%rip), %rdi      # 0x44a5
movb $0x0, %al
callq 0x1050
jmp 0x1b53
movzbl -0xd(%rbp), %esi
leaq 0x2960(%rip), %rdi      # 0x44ac
movb $0x0, %al
callq 0x1050
jmp 0x1b55
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1ad0
leaq 0x2939(%rip), %rdi      # 0x44a3
movb $0x0, %al
callq 0x1050
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryo[P]shmqueue/shmqueue.c
// Function: shmqueue_dump_statistics
void
shmqueue_dump_statistics(struct shmqueue *shmq_header)
{
	int i;

	for (i = 0; i < SHMQUEUE_NBUCKET; i++)
		printf("store (new)   success (bucket=%d): %llu\n", i, shmq_header->header->sha_stat.ss_store_new_success[i]);

	for (i = 0; i < SHMQUEUE_NBUCKET; i++)
		printf("store (reuse) success (bucket=%d): %llu\n", i, shmq_header->header->sha_stat.ss_store_reuse_success[i]);

	for (i = 0; i < SHMQUEUE_NBUCKET; i++)
		printf("store failure         (bucket=%d): %llu\n", i, shmq_header->header->sha_stat.ss_store_failure[i]);

	for (i = 0; i < SHMQUEUE_NBUCKET; i++)
		printf("fetch (peek) success  (bucket=%d): %llu\n", i, shmq_header->header->sha_stat.ss_fetch_success[i]);

	printf("fetch (peek) failure  (bucket=%d): %llu\n", i, shmq_header->header->sha_stat.ss_fetch_failure);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x8, -0xc(%rbp)
jge 0x1bc5
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq 0x40(%rax,%rcx,8), %rdx
leaq 0x268c(%rip), %rdi      # 0x423f
movb $0x0, %al
callq 0x1050
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1b93
movl $0x0, -0xc(%rbp)
cmpl $0x8, -0xc(%rbp)
jge 0x1c01
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq 0x80(%rax,%rcx,8), %rdx
leaq 0x2679(%rip), %rdi      # 0x4268
movb $0x0, %al
callq 0x1050
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1bcc
movl $0x0, -0xc(%rbp)
cmpl $0x8, -0xc(%rbp)
jge 0x1c3d
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq 0xc0(%rax,%rcx,8), %rdx
leaq 0x2666(%rip), %rdi      # 0x4291
movb $0x0, %al
callq 0x1050
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1c08
movl $0x0, -0xc(%rbp)
cmpl $0x8, -0xc(%rbp)
jge 0x1c79
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq 0x100(%rax,%rcx,8), %rdx
leaq 0x2653(%rip), %rdi      # 0x42ba
movb $0x0, %al
callq 0x1050
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1c44
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x140(%rax), %rdx
leaq 0x2652(%rip), %rdi      # 0x42e3
movb $0x0, %al
callq 0x1050
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ryo[P]shmqueue/shmqueue.c
// Function: shmqueue_new
struct shmqueue *
shmqueue_new(int shmid, size_t size, int reuse, int verbose)
{
	struct shmqueue *shmqueue;
	void *mem;
	int id, rc;

	if (size == 0) {
		id = shmget(shmid, size, 0);
	} else {
		id = shmget(shmid, size,
#ifdef SHM_HUGETLB
//		    SHM_HUGETLB |
#endif
		    IPC_EXCL | IPC_CREAT | 0666);
		reuse = 0;
	}
	if (id == -1)
		return NULL;

	mem = shmat(id, NULL, 0);
	if (mem == NULL)
		return NULL;

	if (verbose) {
		printf("shmid = %d\n", id);
	}

	shmqueue = malloc(sizeof(struct shmqueue));
	if (shmqueue == NULL)
		return NULL;

	if (!reuse) {
		if (verbose) {
			printf("create memory: %p[%llu]\n", mem, (unsigned long long)size);
		}
		if (shmqueue_create(shmqueue, mem, size) < 0) {
			rc = shmctl(id, IPC_RMID, NULL);
			return NULL;
		}
	} else {
		if (shmqueue_attach(shmqueue, mem) < 0) {
			rc = shmctl(id, IPC_RMID, NULL);
			return NULL;
		}
		if (verbose) {
			printf("attach memory: %p[%llu]\n", mem, (unsigned long long)shmqueue->header->sha_memsize);
		}
	}
	return shmqueue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1ccf
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x10d0
movl %eax, -0x34(%rbp)
jmp 0x1cea
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movl $0x7b6, %edx            # imm = 0x7B6
callq 0x10d0
movl %eax, -0x34(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $-0x1, -0x34(%rbp)
jne 0x1cfd
movq $0x0, -0x8(%rbp)
jmp 0x1e0b
movl -0x34(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x10c0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x1d23
movq $0x0, -0x8(%rbp)
jmp 0x1e0b
cmpl $0x0, -0x20(%rbp)
je 0x1d3a
movl -0x34(%rbp), %esi
leaq 0x25d9(%rip), %rdi      # 0x430c
movb $0x0, %al
callq 0x1050
movl $0x10, %edi
callq 0x1090
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1d5c
movq $0x0, -0x8(%rbp)
jmp 0x1e0b
cmpl $0x0, -0x1c(%rbp)
jne 0x1db1
cmpl $0x0, -0x20(%rbp)
je 0x1d7e
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x25a1(%rip), %rdi      # 0x4318
movb $0x0, %al
callq 0x1050
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1e20
cmpl $0x0, %eax
jge 0x1daf
movl -0x34(%rbp), %edi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x10a0
movl %eax, -0x38(%rbp)
movq $0x0, -0x8(%rbp)
jmp 0x1e0b
jmp 0x1e03
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2070
cmpl $0x0, %eax
jge 0x1dde
movl -0x34(%rbp), %edi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x10a0
movl %eax, -0x38(%rbp)
movq $0x0, -0x8(%rbp)
jmp 0x1e0b
cmpl $0x0, -0x20(%rbp)
je 0x1e01
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rdx
leaq 0x2537(%rip), %rdi      # 0x4331
movb $0x0, %al
callq 0x1050
jmp 0x1e03
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryo[P]shmqueue/shmqueue.c
// Function: shmqueue_init
void
shmqueue_init(struct shmqueue_header *header)
{
	int i;

	/* init queue headers */
	RTAILQ_INIT(&header->sha_freelist);
	RTAILQ_INIT(&header->sha_lrulist);

	for (i = 0; i < header->sha_hashnum; i++)
		RTAILQ_INIT(&header->sha_hashlist[i]);

	/* insert all itempool to freelist */
	header->sha_item_inuse = 0;
	for (i = 0; i < header->sha_itemnum; i++) {
		RTAILQ_INSERT_TAIL(&header->sha_freelist,
		    &header->sha_pool[i], shmqueue_item, shi_list);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x20f1
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jae 0x2164
jmp 0x211e
movq -0x8(%rbp), %rax
addq $0x150, %rax            # imm = 0x150
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
addq $0x150, %rax            # imm = 0x150
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
jmp 0x2159
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2110
movq -0x8(%rbp), %rax
movl $0x0, 0x34(%rax)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jae 0x221f
jmp 0x2188
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0xb, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rdx
shlq $0xb, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
movslq -0xc(%rbp), %rax
shlq $0xb, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
subq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
movslq -0xc(%rbp), %rax
shlq $0xb, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
subq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x2211
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2176
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryo[P]shmqueue/shmqueue.c
// Function: shmqueue_remove_from_freelist
struct shmqueue_item *
shmqueue_remove_from_freelist(struct shmqueue *shmq_header)
{
	struct shmqueue_header *header;
	struct shmqueue_item *item;

	header = shmq_header->header;

	shmqueue_lock(shmq_header);

	item = RTAILQ_FIRST(&header->sha_freelist, shmqueue_item);
	if (item == NULL) {
		shmqueue_unlock(shmq_header);
		return NULL;
	}

	/* remove from FREE list */
	RTAILQ_REMOVE(&header->sha_freelist,
	    item, shmqueue_item, shi_list);

	shmqueue_unlock(shmq_header);

	item->shi_hashidx = 0;
	item->shi_keyvalue.kv_keysize = 1;
	item->shi_keyvalue.kv_storagesize = 0;
	item->shi_keyvalue.kv_data[0] = '\0';

	return item;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2350
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2282
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x2294
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x22b9
movq -0x10(%rbp), %rdi
callq 0x2380
movq $0x0, -0x8(%rbp)
jmp 0x2344
jmp 0x22bb
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x22e1
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
jmp 0x22f1
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x2380
movq -0x20(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x24(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x2c(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ryo[P]shmqueue/shmqueue.c
// Function: shmqueue_remove_from_lru
struct shmqueue_item *
shmqueue_remove_from_lru(struct shmqueue *shmq_header)
{
	struct shmqueue_header *header;
	struct shmqueue_item *item;

	header = shmq_header->header;

	shmqueue_lock(shmq_header);

	/* get tail of LRU list */
	item = RTAILQ_LAST(&header->sha_lrulist, shmqueue_item);
	if (item == NULL) {
		shmqueue_unlock(shmq_header);
		return NULL;
	}

	/* remove from LRU list */
	RTAILQ_REMOVE(&header->sha_lrulist,
	    item, shmqueue_item, shi_list);

	/* remove from HASH list */
	RTAILQ_REMOVE(&header->sha_hashlist[item->shi_hashidx],
	    item, shmqueue_item, shi_hashlist);

	header->sha_item_inuse--;

	shmqueue_unlock(shmq_header);

	return item;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2350
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
addq $0x10, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
addq $0x10, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0x2620
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x2654
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
addq $0x10, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
addq $0x10, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
addq $0x10, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2679
movq -0x10(%rbp), %rdi
callq 0x2380
movq $0x0, -0x8(%rbp)
jmp 0x2782
jmp 0x267b
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x26a5
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rdx
addq $0x10, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
jmp 0x26b5
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rdx
addq $0x10, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
jmp 0x26d4
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2711
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rdx
addq $0x150, %rdx            # imm = 0x150
movq -0x20(%rbp), %rsi
movl 0x20(%rsi), %esi
shlq $0x4, %rsi
addq %rsi, %rdx
addq %rdx, %rax
movq %rcx, 0x18(%rax)
jmp 0x2735
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
addq $0x150, %rax            # imm = 0x150
movq -0x20(%rbp), %rdx
movl 0x20(%rdx), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rdx
addq $0x150, %rdx            # imm = 0x150
movq -0x20(%rbp), %rsi
movl 0x20(%rsi), %esi
shlq $0x4, %rsi
addq %rsi, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl 0x34(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x34(%rax)
movq -0x10(%rbp), %rdi
callq 0x2380
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ryo[P]shmqueue/shmqueue.c
// Function: shmqueue_add_to_freelist
void
shmqueue_add_to_freelist(struct shmqueue *shmq_header, struct shmqueue_item *item)
{
	struct shmqueue_header *header;

	header = shmq_header->header;

	shmqueue_lock(shmq_header);

	/* insert to FREE list */
	RTAILQ_INSERT_HEAD(&header->sha_freelist,
	    item, shmqueue_item, shi_list);

	shmqueue_unlock(shmq_header);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2350
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0x27e7
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rax, %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
jmp 0x27fa
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x2380
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ryo[P]shmqueue/shmqueue.c
// Function: shmqueue_inuse
int
shmqueue_inuse(struct shmqueue *shmq_header)
{
	int inuse;

	shmqueue_lock(shmq_header);
	inuse = shmq_header->header->sha_item_inuse;
	shmqueue_unlock(shmq_header);

	return inuse;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2350
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x34(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2380
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryo[P]shmqueue/shmqueue.c
// Function: shmqueue_watermark
int
shmqueue_watermark(struct shmqueue *shmq_header)
{
	/*
	 * usage rate reaches 87.5%? (7/8)
	 */
	int mark = 0;

	shmqueue_lock(shmq_header);
	if (shmq_header->header->sha_itemnum -
	    (shmq_header->header->sha_itemnum / 8) <
	    shmq_header->header->sha_item_inuse)
		mark = 1;
	shmqueue_unlock(shmq_header);
	return mark;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2350
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x30(%rax), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl 0x30(%rcx), %ecx
shrl $0x3, %ecx
subl %ecx, %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x34(%rcx), %eax
jae 0x3868
movl $0x1, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2380
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryo[P]shmqueue/shmqueue.c
// Function: shmqueue_getoldest
int
shmqueue_getoldest(struct shmqueue *shmq_header, struct keyvalue *keyvalue)
{
	struct shmqueue_item *item;

	item = shmqueue_remove_from_lru(shmq_header);
	if (item == NULL)
		return -1;

	keyvalue->kv_keysize = item->shi_keyvalue.kv_keysize;
	keyvalue->kv_storagesize = item->shi_keyvalue.kv_storagesize;

	memcpy(keyvalue->kv_data, item->shi_keyvalue.kv_data, keyvalue->kv_keysize + keyvalue->kv_storagesize);
	KEYVALUE_STORAGE(keyvalue)[keyvalue->kv_storagesize] = '\0';

	shmqueue_add_to_freelist(shmq_header, item);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x25d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x38ad
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3922
movq -0x20(%rbp), %rax
movl 0x24(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
addq $0x24, %rsi
addq $0x8, %rsi
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
addl 0x4(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x1070
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
addq %rcx, %rax
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2790
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/armlabs[P]ssd1306_linux/main.c
// Function: print_help
void print_help()
{
    printf("help message\n\n");
    printf("-I\t\tinit oled (128x32 or 128x64 or 64x48)\n");
    printf("-c\t\tclear (line number or all)\n");
    printf("-d\t\t0/display off 1/display on\n");
    printf("-f\t\t0/small font 5x7 1/normal font 8x8 (default normal font)\n");
    printf("-h\t\thelp message\n");
    printf("-i\t\t0/normal oled 1/invert oled\n");
    printf("-l\t\tput your line to display\n");
    printf("-m\t\tput your strings to oled\n");
    printf("-n\t\tI2C device node address (0,1,2..., default 0)\n");
    printf("-r\t\t0/normal 180/rotate\n");
    printf("-x\t\tx position\n");
    printf("-y\t\ty position\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xbc7f5(%rip), %rdi     # 0x4be1f0
movb $0x0, %al
callq 0x40d7f0
leaq 0xbc7f6(%rip), %rdi     # 0x4be1ff
movb $0x0, %al
callq 0x40d7f0
leaq 0xbc813(%rip), %rdi     # 0x4be22a
movb $0x0, %al
callq 0x40d7f0
leaq 0xbc825(%rip), %rdi     # 0x4be24a
movb $0x0, %al
callq 0x40d7f0
leaq 0xbc837(%rip), %rdi     # 0x4be26a
movb $0x0, %al
callq 0x40d7f0
leaq 0xbc867(%rip), %rdi     # 0x4be2a8
movb $0x0, %al
callq 0x40d7f0
leaq 0xbc86b(%rip), %rdi     # 0x4be2ba
movb $0x0, %al
callq 0x40d7f0
leaq 0xbc87e(%rip), %rdi     # 0x4be2db
movb $0x0, %al
callq 0x40d7f0
leaq 0xbc88e(%rip), %rdi     # 0x4be2f9
movb $0x0, %al
callq 0x40d7f0
leaq 0xbc89e(%rip), %rdi     # 0x4be317
movb $0x0, %al
callq 0x40d7f0
leaq 0xbc8c3(%rip), %rdi     # 0x4be34a
movb $0x0, %al
callq 0x40d7f0
leaq 0xbc8ce(%rip), %rdi     # 0x4be363
movb $0x0, %al
callq 0x40d7f0
leaq 0xbc8d0(%rip), %rdi     # 0x4be373
movb $0x0, %al
callq 0x40d7f0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/armlabs[P]ssd1306_linux/ssd1306.c
// Function: ssd1306_init
uint8_t ssd1306_init(uint8_t i2c_dev)
{
    uint8_t rc;
    rc = _i2c_init(i2c_dev, SSD1306_I2C_ADDR);
    if (rc > 0)
        return rc;
        
    // test i2c connection
    uint8_t cmd = SSD1306_COMM_CONTROL_BYTE;
    uint8_t result = 0;
    _i2c_write(&cmd, 1);
    _i2c_read(&result, 1);
    if (result == 0)
        return 1;
    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %edi
movl $0x3c, %esi
callq 0x403190
movb %al, -0x3(%rbp)
movzbl -0x3(%rbp), %eax
cmpl $0x0, %eax
jle 0x4021d0
movb -0x3(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x402207
movb $0x0, -0x4(%rbp)
movb $0x0, -0x5(%rbp)
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x403280
leaq -0x5(%rbp), %rdi
movl $0x1, %esi
callq 0x4032e0
movzbl -0x5(%rbp), %eax
cmpl $0x0, %eax
jne 0x402203
movb $0x1, -0x1(%rbp)
jmp 0x402207
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/armlabs[P]ssd1306_linux/ssd1306.c
// Function: ssd1306_oled_onoff
uint8_t ssd1306_oled_onoff(uint8_t onoff)
{
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    if (onoff == 0)
        data_buf[1] = SSD1306_COMM_DISPLAY_OFF;
    else
        data_buf[1] = SSD1306_COMM_DISPLAY_ON;
    
    return _i2c_write(data_buf, 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movb $0x0, 0xf019b(%rip)     # 0x4f23d0
movzbl -0x1(%rbp), %eax
cmpl $0x0, %eax
jne 0x402247
movb $-0x52, 0xf018c(%rip)   # 0x4f23d1
jmp 0x40224e
movb $-0x51, 0xf0183(%rip)   # 0x4f23d1
leaq 0xf017b(%rip), %rdi     # 0x4f23d0
movl $0x2, %esi
callq 0x403280
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/armlabs[P]ssd1306_linux/ssd1306.c
// Function: ssd1306_oled_horizontal_flip
uint8_t ssd1306_oled_horizontal_flip(uint8_t flip)
{
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    if (flip == 0)
        data_buf[1] = SSD1306_COMM_HORIZ_NORM;
    else
        data_buf[1] = SSD1306_COMM_HORIZ_FLIP;
    
    return _i2c_write(data_buf, 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movb $0x0, 0xf014b(%rip)     # 0x4f23d0
movzbl -0x1(%rbp), %eax
cmpl $0x0, %eax
jne 0x402297
movb $-0x60, 0xf013c(%rip)   # 0x4f23d1
jmp 0x40229e
movb $-0x5f, 0xf0133(%rip)   # 0x4f23d1
leaq 0xf012b(%rip), %rdi     # 0x4f23d0
movl $0x2, %esi
callq 0x403280
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/armlabs[P]ssd1306_linux/ssd1306.c
// Function: ssd1306_oled_display_flip
uint8_t ssd1306_oled_display_flip(uint8_t flip)
{
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    if (flip == 0)
        data_buf[1] = SSD1306_COMM_DISP_NORM;
    else
        data_buf[1] = SSD1306_COMM_DISP_INVERSE;
    
    return _i2c_write(data_buf, 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movb $0x0, 0xf00fb(%rip)     # 0x4f23d0
movzbl -0x1(%rbp), %eax
cmpl $0x0, %eax
jne 0x4022e7
movb $-0x5a, 0xf00ec(%rip)   # 0x4f23d1
jmp 0x4022ee
movb $-0x59, 0xf00e3(%rip)   # 0x4f23d1
leaq 0xf00db(%rip), %rdi     # 0x4f23d0
movl $0x2, %esi
callq 0x403280
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/armlabs[P]ssd1306_linux/ssd1306.c
// Function: ssd1306_oled_multiplex
uint8_t ssd1306_oled_multiplex(uint8_t row)
{
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    data_buf[1] = SSD1306_COMM_MULTIPLEX;
    data_buf[2] = row - 1;
    
    return _i2c_write(data_buf, 3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movb $0x0, 0xf00ab(%rip)     # 0x4f23d0
movb $-0x58, 0xf00a5(%rip)   # 0x4f23d1
movzbl -0x1(%rbp), %eax
subl $0x1, %eax
movb %al, 0xf0099(%rip)      # 0x4f23d2
leaq 0xf0090(%rip), %rdi     # 0x4f23d0
movl $0x3, %esi
callq 0x403280
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/armlabs[P]ssd1306_linux/ssd1306.c
// Function: ssd1306_oled_vert_shift
uint8_t ssd1306_oled_vert_shift(uint8_t offset)
{
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    data_buf[1] = SSD1306_COMM_VERT_OFFSET;
    data_buf[2] = offset;
    
    return _i2c_write(data_buf, 3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movb $0x0, 0xf006b(%rip)     # 0x4f23d0
movb $-0x2d, 0xf0065(%rip)   # 0x4f23d1
movb -0x1(%rbp), %al
movb %al, 0xf005d(%rip)      # 0x4f23d2
leaq 0xf0054(%rip), %rdi     # 0x4f23d0
movl $0x3, %esi
callq 0x403280
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/armlabs[P]ssd1306_linux/ssd1306.c
// Function: ssd1306_oled_set_clock
uint8_t ssd1306_oled_set_clock(uint8_t clk)
{
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    data_buf[1] = SSD1306_COMM_CLK_SET;
    data_buf[2] = clk;
    
    return _i2c_write(data_buf, 3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movb $0x0, 0xf002b(%rip)     # 0x4f23d0
movb $-0x2b, 0xf0025(%rip)   # 0x4f23d1
movb -0x1(%rbp), %al
movb %al, 0xf001d(%rip)      # 0x4f23d2
leaq 0xf0014(%rip), %rdi     # 0x4f23d0
movl $0x3, %esi
callq 0x403280
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)