LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]wld/pixman.c
// Function: renderer_copy_region
void
renderer_copy_region(struct wld_renderer *base, struct buffer *buffer,
                     int32_t dst_x, int32_t dst_y,
                     pixman_region32_t *region)
{
	struct pixman_renderer *renderer = pixman_renderer(base);
	pixman_image_t *src = pixman_image(buffer), *dst = renderer->target;
	pixman_region32_t clip;

	if (!src)
		return;

	pixman_region32_init(&clip);
	pixman_region32_copy(&clip, region);
	pixman_region32_translate(&clip, dst_x, dst_y);

	pixman_image_set_clip_region32(dst, &clip);
	pixman_image_composite32(PIXMAN_OP_SRC, src, NULL, dst,
	                         region->extents.x1, region->extents.y1, 0, 0,
	                         region->extents.x1 + dst_x,
	                         region->extents.y1 + dst_y,
	                         region->extents.x2 - region->extents.x1,
	                         region->extents.y2 - region->extents.y1);
	pixman_image_set_clip_region32(dst, NULL);

	pixman_region32_fini(&clip);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movl %ecx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10990
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x109e0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x10452
jmp 0x10513
leaq -0x60(%rbp), %rdi
callq 0x9240
movq -0x30(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x92d0
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
leaq -0x60(%rbp), %rdi
callq 0x9600
movq -0x48(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x9430
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rcx
movq -0x30(%rbp), %rax
movl (%rax), %r8d
movq -0x30(%rbp), %rax
movl 0x4(%rax), %r9d
movq -0x30(%rbp), %rax
movl (%rax), %ebx
addl -0x24(%rbp), %ebx
movq -0x30(%rbp), %rax
movl 0x4(%rax), %r11d
addl -0x28(%rbp), %r11d
movq -0x30(%rbp), %rax
movl 0x8(%rax), %r10d
movq -0x30(%rbp), %rax
subl (%rax), %r10d
movq -0x30(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x30(%rbp), %rdx
subl 0x4(%rdx), %eax
movl $0x1, %edi
xorl %edx, %edx
xorl %r14d, %r14d
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movl %ebx, 0x10(%rsp)
movl %r11d, 0x18(%rsp)
movl %r10d, 0x20(%rsp)
movl %eax, 0x28(%rsp)
callq 0x9130
movq -0x48(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9430
leaq -0x60(%rbp), %rdi
callq 0x9140
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]wld/pixman.c
// Function: pixman_image
static pixman_image_t *
pixman_image(struct buffer *buffer)
{
	if (buffer->base.impl == &wld_buffer_impl)
		return pixman_image_ref(pixman_buffer(&buffer->base)->image);

	union wld_object object;

	if (wld_export(&buffer->base, WLD_PIXMAN_OBJECT_IMAGE, &object))
		return object.ptr;

	struct pixman_map *map;
	pixman_image_t *image;

	if (!wld_map(&buffer->base))
		goto error0;

	image = pixman_image_create_bits(format_wld_to_pixman(buffer->base.format),
	                                 buffer->base.width, buffer->base.height,
	                                 buffer->base.map, buffer->base.pitch);

	if (!image)
		goto error1;

	if (!(map = malloc(sizeof *map)))
		goto error2;

	map->image = image;
	map->exporter.export = &map_export;
	wld_buffer_add_exporter(&buffer->base, &map->exporter);
	map->destructor.destroy = &map_destroy;
	wld_buffer_add_destructor(&buffer->base, &map->destructor);
	pixman_image_set_destroy_function(image, &destroy_image, buffer);

	return pixman_image_ref(image);

error2:
	pixman_image_unref(image);
error1:
	wld_unmap(&buffer->base);
error0:
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xb181(%rip), %rcx      # 0x1bb78
cmpq %rcx, (%rax)
jne 0x10a17
movq -0x10(%rbp), %rdi
callq 0x10b40
movq 0x50(%rax), %rdi
callq 0x9510
movq %rax, -0x8(%rbp)
jmp 0x10b29
movq -0x10(%rbp), %rdi
movl $0x1000000, %esi        # imm = 0x1000000
leaq -0x18(%rbp), %rdx
callq 0x98b0
testb $0x1, %al
jne 0x10a2f
jmp 0x10a3c
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10b29
movq -0x10(%rbp), %rdi
callq 0x91b0
testb $0x1, %al
jne 0x10a4e
jmp 0x10b21
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edi
callq 0x10b90
movl %eax, %edi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movl 0x10(%rax), %r8d
callq 0x9690
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x10a8f
jmp 0x10b18
movl $0x28, %edi
callq 0x9590
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x10aa5
jmp 0x10b0f
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
leaq -0xbcc(%rip), %rcx      # 0xfef0
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9810
movq -0x20(%rbp), %rax
leaq -0xb87(%rip), %rcx      # 0xff50
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x10, %rsi
callq 0x9710
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0xd5(%rip), %rsi        # 0x10bd0
callq 0x9890
movq -0x28(%rbp), %rdi
callq 0x9510
movq %rax, -0x8(%rbp)
jmp 0x10b29
movq -0x28(%rbp), %rdi
callq 0x9400
movq -0x10(%rbp), %rdi
callq 0x9150
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]wld/./wld-private.h
// Function: format_wld_to_pixman
static inline pixman_format_code_t
format_wld_to_pixman(uint32_t format)
{
	switch (format) {
	case WLD_FORMAT_ARGB8888:
		return PIXMAN_a8r8g8b8;
	case WLD_FORMAT_XRGB8888:
		return PIXMAN_x8r8g8b8;
	default:
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x34325241, %eax       # imm = 0x34325241
je 0x10bb2
jmp 0x10ba6
movl -0xc(%rbp), %eax
subl $0x34325258, %eax       # imm = 0x34325258
je 0x10bbb
jmp 0x10bc4
movl $0x20028888, -0x4(%rbp) # imm = 0x20028888
jmp 0x10bcb
movl $0x20020888, -0x4(%rbp) # imm = 0x20020888
jmp 0x10bcb
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]wld/pixman.c
// Function: reverse
static inline uint8_t
reverse(uint8_t byte)
{
	byte = ((byte << 1) & 0xaa) | ((byte >> 1) & 0x55);
	byte = ((byte << 2) & 0xcc) | ((byte >> 2) & 0x33);
	byte = ((byte << 4) & 0xf0) | ((byte >> 4) & 0x0f);

	return byte;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
shll %eax
andl $0xaa, %eax
movzbl -0x1(%rbp), %ecx
sarl %ecx
andl $0x55, %ecx
orl %ecx, %eax
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
shll $0x2, %eax
andl $0xcc, %eax
movzbl -0x1(%rbp), %ecx
sarl $0x2, %ecx
andl $0x33, %ecx
orl %ecx, %eax
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
shll $0x4, %eax
andl $0xf0, %eax
movzbl -0x1(%rbp), %ecx
sarl $0x4, %ecx
andl $0xf, %ecx
orl %ecx, %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]wld/pixman.c
// Function: new_buffer
static struct buffer *
new_buffer(pixman_image_t *image)
{
	struct pixman_buffer *buffer;

	if (!(buffer = malloc(sizeof *buffer)))
		return NULL;

	buffer_initialize(&buffer->base, &wld_buffer_impl,
	                  pixman_image_get_width(image),
	                  pixman_image_get_height(image),
	                  format_pixman_to_wld(pixman_image_get_format(image)),
	                  pixman_image_get_stride(image));
	buffer->base.base.map = pixman_image_get_data(image);
	buffer->image = image;

	return &buffer->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x58, %edi
callq 0x9590
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x10ced
movq $0x0, -0x8(%rbp)
jmp 0x10d6e
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9450
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9490
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9190
movl %eax, %edi
callq 0x10d80
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9530
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x1c(%rbp), %r8d
movl %eax, %r9d
leaq 0xae37(%rip), %rsi      # 0x1bb78
callq 0x99b0
movq -0x10(%rbp), %rdi
callq 0x97c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]wld/./wld-private.h
// Function: format_pixman_to_wld
static inline uint32_t
format_pixman_to_wld(pixman_format_code_t format)
{
	switch (format) {
	case PIXMAN_a8r8g8b8:
		return WLD_FORMAT_ARGB8888;
	case PIXMAN_x8r8g8b8:
		return WLD_FORMAT_XRGB8888;
	default:
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x20020888, %eax       # imm = 0x20020888
je 0x10dab
jmp 0x10d96
movl -0xc(%rbp), %eax
subl $0x20028888, %eax       # imm = 0x20028888
jne 0x10db4
jmp 0x10da2
movl $0x34325241, -0x4(%rbp) # imm = 0x34325241
jmp 0x10dbb
movl $0x34325258, -0x4(%rbp) # imm = 0x34325258
jmp 0x10dbb
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]wld/wayland.c
// Function: interface_id
enum wld_wayland_interface_id
interface_id(const char *string)
{
	if (strcmp(string, "drm") == 0)
		return WLD_DRM;
	if (strcmp(string, "shm") == 0)
		return WLD_SHM;

	fprintf(stderr, "Unknown Wayland interface specified: '%s'\n", string);

	return WLD_NONE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x4523(%rip), %rsi      # 0x152fa
callq 0x9470
cmpl $0x0, %eax
jne 0x10dea
movl $0x0, -0x4(%rbp)
jmp 0x10e2b
movq -0x10(%rbp), %rdi
leaq 0x4473(%rip), %rsi      # 0x15268
callq 0x9470
cmpl $0x0, %eax
jne 0x10e08
movl $0x1, -0x4(%rbp)
jmp 0x10e2b
movq 0xb1e1(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x4250(%rip), %rsi      # 0x1506d
movb $0x0, %al
callq 0x94a0
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]wld/wayland.c
// Function: wld_wayland_create_surface
wld_surface *
wld_wayland_create_surface(struct wld_context *context,
                           uint32_t width, uint32_t height,
                           uint32_t format, uint32_t flags,
                           struct wl_surface *wl)
{
	struct wayland_buffer_socket *socket;

	if (!(socket = malloc(sizeof *socket)))
		goto error0;

	socket->base.impl = &buffer_socket_impl;
	socket->listener.release = &buffer_release;
	socket->wl = wl;
	socket->queue = ((struct wayland_context *)context)->queue;
	socket->display = ((struct wayland_context *)context)->display;
	socket->surface = buffered_surface_create(context, width, height, format,
	                                          flags, &socket->base);

	if (!socket->surface)
		goto error1;

	return socket->surface;

error1:
	free(socket);
error0:
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movl $0x30, %edi
callq 0x9590
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x11166
jmp 0x111f8
movq -0x30(%rbp), %rax
leaq 0xaa1f(%rip), %rcx      # 0x1bb90
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
leaq 0x91(%rip), %rcx        # 0x11210
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x30(%rbp), %r9
callq 0x9ce0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x111e1
jmp 0x111ef
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x11200
movq -0x30(%rbp), %rdi
callq 0x9060
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]wld/wayland.c
// Function: buffer_release
void
buffer_release(void *data, struct wl_buffer *wl)
{
	struct wld_buffer *buffer = data;
	const struct wl_buffer_listener *listener = wl_proxy_get_listener((struct wl_proxy *)wl);
	struct wayland_buffer_socket *socket = CONTAINER_OF(listener, struct wayland_buffer_socket, listener);

	wld_surface_release(socket->surface, buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x91f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
subq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x9750
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]wld/wayland.c
// Function: wayland_buffer_add_exporter
bool
wayland_buffer_add_exporter(struct buffer *buffer, struct wl_buffer *wl)
{
	struct wayland_buffer *wayland_buffer;

	if (!(wayland_buffer = malloc(sizeof *wayland_buffer)))
		return false;

	wayland_buffer->wl = wl;
	wayland_buffer->exporter.export = &buffer_export;
	wld_buffer_add_exporter(&buffer->base, &wayland_buffer->exporter);
	wayland_buffer->destructor.destroy = &buffer_destroy;
	wld_buffer_add_destructor(&buffer->base, &wayland_buffer->destructor);

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x28, %edi
callq 0x9590
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x112ca
movb $0x0, -0x1(%rbp)
jmp 0x11315
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
leaq 0x3f(%rip), %rcx        # 0x11320
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9810
movq -0x20(%rbp), %rax
leaq 0x74(%rip), %rcx        # 0x11370
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x10, %rsi
callq 0x9710
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]wld/wayland.c
// Function: buffer_export
static bool
buffer_export(struct wld_exporter *exporter,
              struct wld_buffer *buffer,
              uint32_t type, union wld_object *object)
{
	struct wayland_buffer *wayland_buffer = CONTAINER_OF(exporter, struct wayland_buffer, exporter);

	switch (type) {
	case WLD_WAYLAND_OBJECT_BUFFER:
		object->ptr = wayland_buffer->wl;
		return true;
	default:
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
subl $0x3000000, %eax        # imm = 0x3000000
jne 0x1135c
jmp 0x11347
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x11360
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]wld/wayland.c
// Function: buffer_socket_attach
bool
buffer_socket_attach(struct buffer_socket *base, struct buffer *buffer)
{
	struct wayland_buffer_socket *socket = wayland_buffer_socket(base);
	struct wl_buffer *wl;
	union wld_object object;

	if (!wld_export(&buffer->base, WLD_WAYLAND_OBJECT_BUFFER, &object))
		return false;

	wl = object.ptr;

	if (!wl_proxy_get_listener((struct wl_proxy *)wl))
		wl_buffer_add_listener(wl, &socket->listener, buffer);

	wl_surface_attach(socket->wl, wl, 0, 0);

	if (pixman_region32_not_empty(&buffer->base.damage)) {
		pixman_box32_t *box;
		int num_boxes;

		box = pixman_region32_rectangles(&buffer->base.damage, &num_boxes);

		while (num_boxes--) {
			wl_surface_damage(socket->wl, box->x1, box->y1,
			                  box->x2 - box->x1, box->y2 - box->y1);
		}
	}

	wl_surface_commit(socket->wl);

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11520
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x3000000, %esi        # imm = 0x3000000
leaq -0x30(%rbp), %rdx
callq 0x98b0
testb $0x1, %al
jne 0x113ec
movb $0x0, -0x1(%rbp)
jmp 0x114b0
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x91f0
cmpq $0x0, %rax
jne 0x11418
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
movq -0x18(%rbp), %rdx
callq 0x11570
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x115a0
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x9200
cmpl $0x0, %eax
je 0x1149f
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
leaq -0x3c(%rbp), %rsi
callq 0x93d0
movq %rax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x3c(%rbp)
cmpl $0x0, %eax
je 0x1149d
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x38(%rbp), %rax
movl (%rax), %esi
movq -0x38(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x38(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x38(%rbp), %rax
subl (%rax), %ecx
movq -0x38(%rbp), %rax
movl 0xc(%rax), %r8d
movq -0x38(%rbp), %rax
subl 0x4(%rax), %r8d
callq 0x11600
jmp 0x11454
jmp 0x1149f
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x11670
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]wld/wayland-shm.c
// Function: wayland_create_context
struct wayland_context *
wayland_create_context(struct wl_display *display,
                       struct wl_event_queue *queue)
{
	struct shm_context *context;

	if (!(context = malloc(sizeof *context)))
		goto error0;

	context_initialize(&context->base.base, &wld_context_impl);
	context->wl = NULL;
	wl_array_init(&context->formats);

	if (!(context->registry = wl_display_get_registry(display))) {
		DEBUG("Couldn't get registry\n");
		goto error1;
	}

	wl_registry_add_listener(context->registry, &registry_listener, context);
	wl_proxy_set_queue((struct wl_proxy *)context->registry, queue);

	/* Wait for wl_shm global. */
	wl_display_roundtrip_queue(display, queue);

	if (!context->wl) {
		DEBUG("No wl_shm global\n");
		goto error2;
	}

	wl_shm_add_listener(context->wl, &shm_listener, context);

	/* Wait for SHM formats. */
	wl_display_roundtrip_queue(display, queue);

	return &context->base;

error2:
	wl_registry_destroy(context->registry);
error1:
	wl_array_release(&context->formats);
	free(context);
error0:
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x48, %edi
callq 0x9590
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x11719
jmp 0x11831
movq -0x20(%rbp), %rdi
leaq 0xa494(%rip), %rsi      # 0x1bbb8
callq 0xa3f0
movq -0x20(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
callq 0x91d0
movq -0x10(%rbp), %rdi
callq 0x118d0
movq -0x20(%rbp), %rcx
movq %rax, 0x20(%rcx)
cmpq $0x0, %rax
jne 0x1177d
movq 0xa890(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
leaq 0x3a4f(%rip), %rsi      # 0x151b9
leaq 0x39b7(%rip), %rdx      # 0x15128
movb $0x0, %al
callq 0x94a0
jmp 0x1181b
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0xa450(%rip), %rsi      # 0x1bbe0
callq 0x11920
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x97e0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x97d0
movq -0x20(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x117df
movq 0xa82b(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
leaq 0x3a07(%rip), %rsi      # 0x151d6
leaq 0x3952(%rip), %rdx      # 0x15128
movb $0x0, %al
callq 0x94a0
jmp 0x1180e
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0xa3fe(%rip), %rsi      # 0x1bbf0
callq 0x11950
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x97d0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x11839
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x11980
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
callq 0x95c0
movq -0x20(%rbp), %rdi
callq 0x9060
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]wld/wayland-shm.c
// Function: wayland_has_format
bool
wayland_has_format(struct wld_context *base, uint32_t format)
{
	struct shm_context *context = shm_context(base);
	uint32_t *supported_format;
	uint32_t shm_format = format_wld_to_shm(format);

	wl_array_for_each (supported_format, &context->formats) {
		if (*supported_format == shm_format)
			return true;
	}

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11c30
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %edi
callq 0x11db0
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x40(%rcx), %rcx
movq -0x20(%rbp), %rdx
addq 0x30(%rdx), %rcx
cmpq %rcx, %rax
jae 0x118bd
movq -0x28(%rbp), %rax
movl (%rax), %eax
cmpl -0x2c(%rbp), %eax
jne 0x118ad
movb $0x1, -0x1(%rbp)
jmp 0x118c1
jmp 0x118af
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
jmp 0x11883
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]wld/wayland-shm.c
// Function: context_destroy
void
context_destroy(struct wld_context *base)
{
	struct shm_context *context = shm_context(base);

	wl_shm_destroy(context->wl);
	wl_registry_destroy(context->registry);
	wl_array_release(&context->formats);
	wl_event_queue_destroy(context->base.queue);
	free(context);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11c30
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x11fe0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x11980
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x95c0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x91a0
movq -0x10(%rbp), %rdi
callq 0x9060
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]wld/wayland-shm.c
// Function: format_wld_to_shm
static inline uint32_t
format_wld_to_shm(uint32_t format)
{
	switch (format) {
	case WLD_FORMAT_ARGB8888:
		return WL_SHM_FORMAT_ARGB8888;
	case WLD_FORMAT_XRGB8888:
		return WL_SHM_FORMAT_XRGB8888;
	default:
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x34325241, %eax       # imm = 0x34325241
je 0x11dd2
jmp 0x11dc6
movl -0xc(%rbp), %eax
subl $0x34325258, %eax       # imm = 0x34325258
je 0x11ddb
jmp 0x11de4
movl $0x0, -0x4(%rbp)
jmp 0x11deb
movl $0x1, -0x4(%rbp)
jmp 0x11deb
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]wld/wayland-shm.c
// Function: buffer_map
bool
buffer_map(struct buffer *base)
{
	struct shm_buffer *buffer = shm_buffer(&base->base);
	void *data;

	data = mmap(NULL, buffer->base.base.pitch * buffer->base.base.height,
	            PROT_READ | PROT_WRITE, MAP_SHARED, buffer->fd, 0);

	if (data == MAP_FAILED)
		return false;

	buffer->base.base.map = data;

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11f90
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
imull 0xc(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
movq -0x18(%rbp), %rax
movl 0x50(%rax), %r8d
xorl %eax, %eax
movl %eax, %r9d
movl $0x3, %edx
movl $0x1, %ecx
movq %r9, %rdi
callq 0x92a0
movq %rax, -0x20(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x20(%rbp)
jne 0x11ed2
movb $0x0, -0x1(%rbp)
jmp 0x11ee2
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]wld/wayland-shm.c
// Function: shm_format
void
shm_format(void *data, struct wl_shm *wl, uint32_t format)
{
	struct shm_context *context = data;
	uint32_t *added_format;

	if (!(added_format = wl_array_add(&context->formats, sizeof format)))
		return;
	*added_format = format;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
movl $0x4, %esi
callq 0x95b0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x12129
jmp 0x12132
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]wld/wayland-drm.c
// Function: wayland_has_format
bool
wayland_has_format(struct wld_context *base, uint32_t format)
{
	struct drm_context *context = drm_context(base);
	uint32_t *supported_format;

	wl_array_for_each (supported_format, &context->formats) {
		if (*supported_format == format)
			return true;
	}

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x123f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x48(%rcx), %rcx
movq -0x20(%rbp), %rdx
addq 0x38(%rdx), %rcx
cmpq %rcx, %rax
jae 0x123a2
movq -0x28(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x12392
movb $0x1, -0x1(%rbp)
jmp 0x123a6
jmp 0x12394
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
jmp 0x12368
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]wld/wayland-drm.c
// Function: context_create_buffer
struct buffer *
context_create_buffer(struct wld_context *base,
                      uint32_t width, uint32_t height,
                      uint32_t format, uint32_t flags)
{
	struct drm_context *context = drm_context(base);
	struct buffer *buffer;
	union wld_object object;
	struct wl_buffer *wl;

	if (!wayland_has_format(base, format))
		goto error0;

	buffer = context->driver_context->impl->create_buffer(context->driver_context, width, height, format, flags);

	if (!buffer)
		goto error0;

	if (!wld_export(&buffer->base, WLD_DRM_OBJECT_PRIME_FD, &object))
		goto error1;

	wl = wl_drm_create_prime_buffer(context->wl, object.i, width, height,
	                                format, 0, buffer->base.pitch, 0, 0, 0, 0);
	close(object.i);

	if (!wl)
		goto error1;

	if (!wayland_buffer_add_exporter(buffer, wl))
		goto error2;

	return buffer;

error2:
	wl_buffer_destroy(wl);
error1:
	wld_buffer_unreference(&buffer->base);
error0:
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x123f0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x12340
testb $0x1, %al
jne 0x1259b
jmp 0x12677
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x20(%rcx), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
callq *%rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x125d1
jmp 0x12677
movq -0x30(%rbp), %rdi
movl $0x2000001, %esi        # imm = 0x2000001
leaq -0x38(%rbp), %rdx
callq 0x98b0
testb $0x1, %al
jne 0x125ec
jmp 0x1266e
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rdi
movl -0x38(%rbp), %esi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
movq -0x30(%rbp), %rax
movl 0x10(%rax), %eax
xorl %r9d, %r9d
movl %eax, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movl $0x0, 0x20(%rsp)
callq 0x12740
movq %rax, -0x40(%rbp)
movl -0x38(%rbp), %edi
callq 0x93e0
cmpq $0x0, -0x40(%rbp)
jne 0x12648
jmp 0x1266e
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x112a0
testb $0x1, %al
jne 0x1265b
jmp 0x12665
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1267f
movq -0x40(%rbp), %rdi
callq 0x12820
movq -0x30(%rbp), %rdi
callq 0x9270
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]wld/wayland-drm.c
// Function: context_destroy
void
context_destroy(struct wld_context *base)
{
	struct drm_context *context = drm_context(base);

	wld_destroy_context(context->driver_context);
	close(context->fd);
	wl_drm_destroy(context->wl);
	wl_registry_destroy(context->registry);
	wl_array_release(&context->formats);
	wl_event_queue_destroy(context->base.queue);
	free(context);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x123f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x94b0
movq -0x10(%rbp), %rax
movl 0x54(%rax), %edi
callq 0x93e0
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x124f0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x12510
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x95c0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x91a0
movq -0x10(%rbp), %rdi
callq 0x9060
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]wld/./protocol/wayland-drm-client-protocol.h
// Function: wl_drm_create_prime_buffer
static inline struct wl_buffer *
wl_drm_create_prime_buffer(struct wl_drm *wl_drm, int32_t name, int32_t width, int32_t height, uint32_t format, int32_t offset0, int32_t stride0, int32_t offset1, int32_t stride1, int32_t offset2, int32_t stride2)
{
	struct wl_proxy *id;

	id = wl_proxy_marshal_flags((struct wl_proxy *) wl_drm,
			 WL_DRM_CREATE_PRIME_BUFFER, &wl_buffer_interface, wl_proxy_get_version((struct wl_proxy *) wl_drm), 0, NULL, name, width, height, format, offset0, stride0, offset1, stride1, offset2, stride2);

	return (struct wl_buffer *) id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl 0x30(%rbp), %eax
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x30(%rbp)
movl %esi, -0x34(%rbp)
movl %edx, -0x38(%rbp)
movl %ecx, -0x3c(%rbp)
movl %r8d, -0x40(%rbp)
movl %r9d, -0x44(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x30(%rbp), %rdi
callq 0x9180
movq -0x60(%rbp), %rdi
movl %eax, %ecx
movl -0x34(%rbp), %eax
movl -0x38(%rbp), %edx
movl %edx, -0x58(%rbp)
movl -0x3c(%rbp), %r13d
movl -0x40(%rbp), %r12d
movl -0x44(%rbp), %r15d
movl 0x10(%rbp), %r14d
movl 0x18(%rbp), %ebx
movl 0x20(%rbp), %r11d
movl 0x28(%rbp), %r10d
movl 0x30(%rbp), %edx
movl %edx, -0x54(%rbp)
movl $0x3, %esi
movq 0x980b(%rip), %rdx      # 0x1bfd0
xorl %r8d, %r8d
xorl %r9d, %r9d
movl %eax, (%rsp)
movl -0x58(%rbp), %eax
movl %eax, 0x8(%rsp)
movl -0x54(%rbp), %eax
movl %r13d, 0x10(%rsp)
movl %r12d, 0x18(%rsp)
movl %r15d, 0x20(%rsp)
movl %r14d, 0x28(%rsp)
movl %ebx, 0x30(%rsp)
movl %r11d, 0x38(%rsp)
movl %r10d, 0x40(%rsp)
movl %eax, 0x48(%rsp)
movb $0x0, %al
callq 0x9420
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]wld/wayland-drm.c
// Function: drm_device
void
drm_device(void *data, struct wl_drm *wl, const char *name)
{
	struct drm_context *context = data;

	context->fd = open(name, O_RDWR);
	if (context->fd == -1) {
		DEBUG("Couldn't open DRM device '%s'\n", name);
		return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x2, %esi
movb $0x0, %al
callq 0x96c0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x54(%rax)
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x54(%rax)
jne 0x129b2
movq 0x965a(%rip), %rax      # 0x1bff0
movq (%rax), %rdi
movq -0x18(%rbp), %rcx
leaq 0x295a(%rip), %rsi      # 0x152fe
leaq 0x2978(%rip), %rdx      # 0x15323
movb $0x0, %al
callq 0x94a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/google[P]multichase/fairness.c
// Function: wait_for_startup
static void wait_for_startup(void) {
  // wait for everyone to spawn
  pthread_mutex_lock(&wait_mutex);
  --nr_to_startup;
  if (nr_to_startup) {
    pthread_cond_wait(&wait_cond, &wait_mutex);
  } else {
    pthread_cond_broadcast(&wait_cond);
  }
  pthread_mutex_unlock(&wait_mutex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xefb7d(%rip), %rdi     # 0x4f2328
callq 0x424790
movq 0xebb61(%rip), %rax     # 0x4ee318
addq $-0x1, %rax
movq %rax, 0xebb56(%rip)     # 0x4ee318
cmpq $0x0, 0xebb4e(%rip)     # 0x4ee318
je 0x4027e1
leaq 0xefb7d(%rip), %rdi     # 0x4f2350
leaq 0xefb4e(%rip), %rsi     # 0x4f2328
callq 0x420df0
jmp 0x4027ed
leaq 0xefb68(%rip), %rdi     # 0x4f2350
callq 0x4207a0
leaq 0xefb34(%rip), %rdi     # 0x4f2328
callq 0x425670
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/DASpatch.c
// Function: unsuitable
static int unsuitable(int bread, int lft, int rgt)
{ int tb, te;

  tb = TRIM_IDX[bread];
  te = TRIM_IDX[bread+1];
  for ( ; tb < te; tb += 3)
    if (TRIM[tb+1] >= lft)
      break;
  if (tb >= te || TRIM[tb] > lft)
    return (1);
  for ( ; tb < te ; tb += 3)
    { if (TRIM[tb+1] >= rgt)
        break;
      if (TRIM[tb+2] == SPLIT)
        return (1);
    }
  if (tb >= te || TRIM[tb] > rgt)
    return (1);
  return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq 0x2712c(%rip), %rax     # 0x2b410
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, -0x14(%rbp)
movq 0x2711a(%rip), %rax     # 0x2b410
movl -0x8(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x4335
movq 0x27103(%rip), %rax     # 0x2b418
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
cmpl -0xc(%rbp), %eax
jl 0x4328
jmp 0x4335
jmp 0x432a
movl -0x14(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x14(%rbp)
jmp 0x4306
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x4350
movq 0x270d4(%rip), %rax     # 0x2b418
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0xc(%rbp), %eax
jle 0x4359
movl $0x1, -0x4(%rbp)
jmp 0x43d4
jmp 0x435b
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x43a9
movq 0x270ae(%rip), %rax     # 0x2b418
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x10(%rbp), %eax
jl 0x437d
jmp 0x43a9
movq 0x27094(%rip), %rax     # 0x2b418
movl -0x14(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
cmpl $0x2, (%rax,%rcx,4)
jne 0x439c
movl $0x1, -0x4(%rbp)
jmp 0x43d4
jmp 0x439e
movl -0x14(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x14(%rbp)
jmp 0x435b
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x43c4
movq 0x27060(%rip), %rax     # 0x2b418
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x10(%rbp), %eax
jle 0x43cd
movl $0x1, -0x4(%rbp)
jmp 0x43d4
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/align.c
// Function: New_Work_Data
Work_Data *New_Work_Data()
{ _Work_Data *work;
  
  work = (_Work_Data *) Malloc(sizeof(_Work_Data),"Allocating work data block");
  if (work == NULL)
    EXIT(NULL);
  work->vecmax = 0;
  work->vector = NULL;
  work->pntmax = 0;
  work->points = NULL;
  work->tramax = 0;
  work->trace  = NULL;
  work->alnmax = 0;
  work->alnpts = NULL;
  work->celmax = 0;
  work->cells  = NULL;
  return ((Work_Data *) work);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x50, %edi
leaq 0x22044(%rip), %rsi     # 0x26438
callq 0x1aa00
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x440e
movl $0x1, %edi
callq 0x2290
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/align.c
// Function: Free_Work_Data
void Free_Work_Data(Work_Data *ework)
{ _Work_Data *work = (_Work_Data *) ework;
  if (work->vector != NULL)
    free(work->vector);
  if (work->cells != NULL)
    free(work->cells);
  if (work->trace != NULL)
    free(work->trace);
  if (work->points != NULL)
    free(work->points);
  if (work->alnpts != NULL)
    free(work->alnpts);
  free(work);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x44bc
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2030
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x44d4
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2030
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x44ec
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2030
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x4504
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2030
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x451c
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x2030
movq -0x10(%rbp), %rdi
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/align.c
// Function: set_table
static void set_table(int bit, int prefix, int score, int max, Table_Bits *parms)
{ if (bit >= TRIM_LEN)
    { parms->table[prefix] = (int16) (score-max);
      parms->score[prefix] = (int16) score;
    }
  else
    { if (score > max)
        max = score;
      set_table(bit+1,(prefix<<1),score - parms->dscore,max,parms);
      set_table(bit+1,(prefix<<1) | 1,score + parms->mscore,max,parms);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movq %r8, -0x18(%rbp)
cmpl $0xf, -0x4(%rbp)
jl 0x481f
movl -0xc(%rbp), %eax
subl -0x10(%rbp), %eax
movw %ax, %dx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x8(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movl -0xc(%rbp), %eax
movw %ax, %dx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x8(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
jmp 0x4871
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jle 0x482d
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x4(%rbp), %edi
addl $0x1, %edi
movl -0x8(%rbp), %esi
shll %esi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rax
subl 0x4(%rax), %edx
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %r8
callq 0x47d0
movl -0x4(%rbp), %edi
addl $0x1, %edi
movl -0x8(%rbp), %esi
shll %esi
orl $0x1, %esi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rax
addl (%rax), %edx
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %r8
callq 0x47d0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/align.c
// Function: enlarge_vector
static int enlarge_vector(_Work_Data *work, int newmax)
{ void *vec;
  int   max;

  max = ((int) (newmax*1.2)) + 10000;
  vec = Realloc(work->vector,max,"Enlarging DP vector");
  if (vec == NULL)
    EXIT(1);
  work->vecmax = max;
  work->vector = vec;
  return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cvtsi2sdl -0xc(%rbp), %xmm0
movsd 0x20dd4(%rip), %xmm1    # 0x26010
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
addl $0x2710, %eax           # imm = 0x2710
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x1c(%rbp), %rsi
leaq 0x213ef(%rip), %rdx     # 0x2664e
callq 0x1aa80
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5279
movl $0x1, %edi
callq 0x2290
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/align.c
// Function: enlarge_points
static int enlarge_points(_Work_Data *work, int newmax)
{ void *vec;
  int   max;

  max = ((int) (newmax*1.2)) + 10000;
  vec = Realloc(work->points,max,"Enlarging point vector");
  if (vec == NULL)
    EXIT(1);
  work->pntmax = max;
  work->points = vec;
  return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cvtsi2sdl -0xc(%rbp), %xmm0
movsd 0x20d54(%rip), %xmm1    # 0x26010
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
addl $0x2710, %eax           # imm = 0x2710
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movslq -0x1c(%rbp), %rsi
leaq 0x21383(%rip), %rdx     # 0x26662
callq 0x1aa80
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x52f9
movl $0x1, %edi
callq 0x2290
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/align.c
// Function: Read_Trace
int Read_Trace(FILE *input, Overlap *ovl, int tbytes)
{ if (tbytes > 0 && ovl->path.tlen > 0)
    { if (fread(ovl->path.trace, tbytes*ovl->path.tlen, 1, input) != 1)
        return (1);
    }
  return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0xd937
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jle 0xd937
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
imull 0x8(%rcx), %eax
movslq %eax, %rsi
movq -0x10(%rbp), %rcx
movl $0x1, %edx
callq 0x20a0
cmpq $0x1, %rax
je 0xd935
movl $0x1, -0x4(%rbp)
jmp 0xd93e
jmp 0xd937
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/align.c
// Function: Write_Overlap
int Write_Overlap(FILE *output, Overlap *ovl, int tbytes)
{ if (fwrite( ((char *) ovl) + PtrSize, OvlIOSize, 1, output) != 1)
    return (1);
  if (ovl->path.trace != NULL)
    if (fwrite(ovl->path.trace,tbytes,ovl->path.tlen,output) != (size_t) ovl->path.tlen)
      return (1);
  return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
addq 0x1d88a(%rip), %rdi     # 0x2b1f8
movq 0x1d88b(%rip), %rsi     # 0x2b200
movq -0x10(%rbp), %rcx
movl $0x1, %edx
callq 0x22a0
cmpq $0x1, %rax
je 0xd992
movl $0x1, -0x4(%rbp)
jmp 0xd9d7
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0xd9d0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movslq -0x1c(%rbp), %rsi
movq -0x18(%rbp), %rax
movslq 0x8(%rax), %rdx
movq -0x10(%rbp), %rcx
callq 0x22a0
movq -0x18(%rbp), %rcx
movslq 0x8(%rcx), %rcx
cmpq %rcx, %rax
je 0xd9ce
movl $0x1, -0x4(%rbp)
jmp 0xd9d7
jmp 0xd9d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/align.c
// Function: Compress_TraceTo8
int Compress_TraceTo8(Overlap *ovl, int check)
{ uint16 *t16 = (uint16 *) ovl->path.trace;
  uint8  *t8  = (uint8  *) ovl->path.trace;
  int     j, x;

  if (check)
    for (j = 0; j < ovl->path.tlen; j++)
      { x = t16[j];
        if (x > 255)
          { fprintf(stderr,"%s: Compression of trace to bytes fails, value too big\n",Prog_Name);
            EXIT(1);
          }
        t8[j] = (uint8) x;
      }
  else
    for (j = 0; j < ovl->path.tlen; j++)
      t8[j] = (uint8) (t16[j]);
  return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xda7f
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xda7d
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x28(%rbp)
cmpl $0xff, -0x28(%rbp)
jle 0xda62
movq 0x1d5bb(%rip), %rax     # 0x2aff8
movq (%rax), %rdi
leaq 0x1db09(%rip), %rax     # 0x2b550
movq (%rax), %rdx
leaq 0x18a9b(%rip), %rsi     # 0x264ec
movb $0x0, %al
callq 0x2190
movl $0x1, %edi
callq 0x2290
movl -0x28(%rbp), %eax
movb %al, %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xda12
jmp 0xdab8
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xdab6
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movw (%rax,%rcx,2), %ax
movb %al, %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xda86
jmp 0xdab8
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/align.c
// Function: Decompress_TraceTo16
void Decompress_TraceTo16(Overlap *ovl)
{ uint16 *t16 = (uint16 *) ovl->path.trace;
  uint8  *t8  = (uint8  *) ovl->path.trace;
  int     j;

  for (j = ovl->path.tlen-1; j >= 0; j--)
    t16[j] = t8[j];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0xdb17
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movw %ax, %dx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xdaeb
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/align.c
// Function: Complement_Seq
void Complement_Seq(char *aseq, int len)
{ char *s, *t;
  int   c;

  s = aseq;
  t = aseq + (len-1);
  while (s < t)
    { c    = 3 - *s;
      *s++ = (char) (3 - *t);
      *t-- = (char) c;
    }
  if (s == t)
    *s = (char) (3 - *s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xe2bb
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movl $0x3, %eax
subl %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
movl $0x3, %eax
subl %ecx, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movl -0x24(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
jmp 0xe267
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0xe2db
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movl $0x3, %eax
subl %ecx, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
popq %rbp
retq
nopl (%rax)