LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0x28, %edi
callq 0x9570
movq %rax, %rbx
testq %rax, %rax
je 0xdf61
movq %r15, 0x20(%rbx)
leaq 0x31(%rip), %rax        # 0xdf6d
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x97f0
leaq 0x10(%rbx), %rsi
leaq 0x31(%rip), %rax        # 0xdf86
movq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0x96f0
testq %rbx, %rbx
setne %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x9bb9(%rip), %rax      # 0x17b90
cmpq %rax, (%rdi)
jne 0xe10f
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rsp), %rdx
movq %rsi, %rdi
movl $0x3000000, %esi        # imm = 0x3000000
callq 0x9890
movl %eax, %ebx
testb %al, %al
je 0xe0fe
movq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x91e0
testq %rax, %rax
jne 0xe023
leaq 0x8(%r14), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x92b0
movq 0x18(%r14), %r13
movq %r13, %rdi
callq 0x9170
xorl %r10d, %r10d
movq %r13, %rdi
movl $0x1, %esi
xorl %edx, %edx
movl %eax, %ecx
xorl %r8d, %r8d
movq %r12, %r9
xorl %eax, %eax
pushq %r10
pushq %r10
callq 0x9400
addq $0x10, %rsp
addq $0x18, %r15
movq %r15, %rdi
callq 0x91f0
testl %eax, %eax
je 0xe0dc
movb %bl, 0x3(%rsp)
leaq 0x4(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x93b0
subl $0x1, (%r12)
jb 0xe0d8
movq %rax, %r15
movq %r14, 0x8(%rsp)
movq 0x18(%r14), %r12
movl (%r15), %ebp
movl 0x4(%r15), %r13d
movl 0x8(%r15), %ebx
subl %ebp, %ebx
movl 0xc(%r15), %r14d
subl %r13d, %r14d
movq %r12, %rdi
callq 0x9170
subq $0x8, %rsp
movq %r12, %rdi
movl $0x2, %esi
xorl %edx, %edx
movl %eax, %ecx
xorl %r8d, %r8d
movl %ebp, %r9d
xorl %eax, %eax
pushq %r14
movq 0x18(%rsp), %r14
pushq %rbx
pushq %r13
callq 0x9400
addq $0x20, %rsp
subl $0x1, 0x4(%rsp)
jae 0xe086
movb 0x3(%rsp), %bl
movq 0x18(%r14), %r14
movq %r14, %rdi
callq 0x9170
movq %r14, %rdi
movl $0x6, %esi
xorl %edx, %edx
movl %eax, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x9400
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3501(%rip), %rdi      # 0x11617
leaq 0x351e(%rip), %rsi      # 0x1163b
leaq 0x3521(%rip), %rcx      # 0x11645
movl $0x39, %edx
callq 0x9380
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0x48, %edi
callq 0x9570
testq %rax, %rax
je 0xe257
movq %rax, %rbx
leaq 0x9a1d(%rip), %rsi      # 0x17bb8
movq %rax, %rdi
callq 0xa1b4
movq $0x0, 0x28(%rbx)
leaq 0x30(%rbx), %r12
movq %r12, %rdi
callq 0x91c0
movq %r15, %rdi
callq 0x9170
movq 0x9e02(%rip), %rdx      # 0x17fc8
movq %r15, %rdi
movl $0x1, %esi
movl %eax, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x9400
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0xe234
leaq 0x99f3(%rip), %rsi      # 0x17be0
movq %rax, %rdi
movq %rbx, %rdx
callq 0x92b0
movq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x97c0
movq %r15, %rdi
movq %r14, %rsi
callq 0x97b0
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0xe23b
leaq 0x99d1(%rip), %rsi      # 0x17bf0
movq %rbx, %rdx
callq 0x92b0
movq %r15, %rdi
movq %r14, %rsi
callq 0x97b0
jmp 0xe259
callq 0x9a4f
jmp 0xe247
movq %rbx, %rdi
addq $0x20, %rdi
callq 0x9a23
movq %r12, %rdi
callq 0x95a0
movq %rbx, %rdi
callq 0x9060
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
leaq 0x9948(%rip), %rax      # 0x17bb8
cmpq %rax, (%rdi)
jne 0xe2b0
xorl %ecx, %ecx
cmpl $0x34325258, %esi       # imm = 0x34325258
sete %al
movq 0x30(%rdi), %rdx
testq %rdx, %rdx
jle 0xe2ac
movb %al, %cl
movq 0x40(%rdi), %rsi
addq %rsi, %rdx
addq $0x4, %rsi
cmpl %ecx, -0x4(%rsi)
sete %al
je 0xe2ae
leaq 0x4(%rsi), %rdi
cmpq %rdx, %rsi
movq %rdi, %rsi
jb 0xe296
jmp 0xe2ae
xorl %eax, %eax
popq %rcx
retq
leaq 0x2a0c(%rip), %rdi      # 0x10cc3
leaq 0x3408(%rip), %rsi      # 0x116c6
leaq 0x340f(%rip), %rcx      # 0x116d4
movl $0x36, %edx
callq 0x9380
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
leaq 0x96ab(%rip), %rax      # 0x17bb8
cmpq %rax, (%rdi)
jne 0xe542
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x9830
movq 0x20(%rbx), %rdi
callq 0x9830
leaq 0x30(%rbx), %rdi
callq 0x95a0
movq 0x18(%rbx), %rdi
callq 0x9190
movq %rbx, %rdi
popq %rbx
jmp 0x9060
leaq 0x277a(%rip), %rdi      # 0x10cc3
leaq 0x3176(%rip), %rsi      # 0x116c6
leaq 0x317d(%rip), %rcx      # 0x116d4
movl $0x36, %edx
callq 0x9380
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
leaq 0x968f(%rip), %rax      # 0x17bf8
cmpq %rax, (%rdi)
jne 0xe5a3
movq %rdi, %rbx
movl 0xc(%rdi), %esi
movl 0x50(%rdi), %r8d
imull 0x10(%rdi), %esi
xorl %edi, %edi
movl $0x3, %edx
movl $0x1, %ecx
xorl %r9d, %r9d
callq 0x9290
cmpq $-0x1, %rax
je 0xe59a
movq %rax, 0x30(%rbx)
cmpq $-0x1, %rax
setne %al
popq %rbx
retq
leaq 0x277a(%rip), %rdi      # 0x10d24
leaq 0x3115(%rip), %rsi      # 0x116c6
leaq 0x3152(%rip), %rcx      # 0x1170a
movl $0x37, %edx
callq 0x9380
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]wld/wayland-drm.c
// Function: wayland_create_context
struct wayland_context *
wayland_create_context(struct wl_display *display,
                       struct wl_event_queue *queue)
{
	struct drm_context *context;

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

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

	if (!(context->registry = wl_display_get_registry(display)))
		goto error1;

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

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

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

	wl_drm_add_listener(context->wl, &drm_listener, context);

	/* Wait for DRM capabilities and device. */
	wl_display_roundtrip_queue(display, queue);

	if (!(context->capabilities & WL_DRM_CAPABILITY_PRIME)) {
		DEBUG("No PRIME support\n");
		goto error3;
	}

	if (context->fd == -1) {
		DEBUG("No DRM device\n");
		goto error3;
	}

	if (!(context->driver_context = wld_drm_create_context(context->fd))) {
		DEBUG("Couldn't initialize context for DRM device\n");
		goto error4;
	}

	return &context->base;

error4:
	close(context->fd);
error3:
	wl_drm_destroy(context->wl);
error2:
	wl_registry_destroy(context->registry);
error1:
	wl_array_release(&context->formats);
	free(context);
error0:
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r12
movl $0x58, %edi
callq 0x9570
testq %rax, %rax
je 0xe7d2
movq %rax, %rbx
leaq 0x9559(%rip), %rsi      # 0x17c20
movq %rax, %rdi
callq 0xa1b4
movq $0x0, 0x28(%rbx)
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, 0x50(%rbx)
leaq 0x38(%rbx), %r14
movq %r14, %rdi
callq 0x91c0
movq %r12, %rdi
callq 0x9170
movq 0x98c8(%rip), %rdx      # 0x17fc8
movq %r12, %rdi
movl $0x1, %esi
movl %eax, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x9400
movq %rax, 0x30(%rbx)
testq %rax, %rax
je 0xe7c2
leaq 0x951d(%rip), %rsi      # 0x17c48
movq %rax, %rdi
movq %rbx, %rdx
callq 0x92b0
movq 0x30(%rbx), %rdi
movq %r15, %rsi
callq 0x97c0
movq %r12, %rdi
movq %r15, %rsi
callq 0x97b0
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0xe79d
leaq 0x94fb(%rip), %rsi      # 0x17c58
movq %rbx, %rdx
callq 0x92b0
movq %r12, %rdi
movq %r15, %rsi
callq 0x97b0
testb $0x1, 0x50(%rbx)
je 0xe7a4
movq %rbx, %r15
addq $0x54, %r15
movl (%r15), %edi
cmpl $-0x1, %edi
je 0xe7ab
callq 0x9160
movq %rax, 0x20(%rbx)
testq %rax, %rax
jne 0xe7d4
movq %r15, %rdi
callq 0x9a6e
jmp 0xe7b0
callq 0x9ad7
jmp 0xe7b9
callq 0x9ab8
jmp 0xe7b0
callq 0x9a99
movq 0x28(%rbx), %rdi
callq 0x9830
movq 0x30(%rbx), %rdi
callq 0x9830
movq %r14, %rdi
callq 0x95a0
movq %rbx, %rdi
callq 0x9060
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
leaq 0x9435(%rip), %rax      # 0x17c20
cmpq %rax, (%rdi)
jne 0xe81e
movq 0x38(%rdi), %rcx
testq %rcx, %rcx
jle 0xe81a
movq 0x48(%rdi), %rdx
addq %rdx, %rcx
addq $0x4, %rdx
cmpl %esi, -0x4(%rdx)
sete %al
je 0xe81c
leaq 0x4(%rdx), %rdi
cmpq %rcx, %rdx
movq %rdi, %rdx
jb 0xe804
jmp 0xe81c
xorl %eax, %eax
popq %rcx
retq
leaq 0x249e(%rip), %rdi      # 0x10cc3
leaq 0x2fe2(%rip), %rsi      # 0x1180e
leaq 0x2fe9(%rip), %rcx      # 0x1181c
movl $0x32, %edx
callq 0x9380
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x9369(%rip), %rax      # 0x17c20
cmpq %rax, (%rdi)
jne 0xe9c6
movl %r8d, %ebx
movl %ecx, %r12d
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, %r13
movl %ecx, %esi
callq 0xe7e3
testb %al, %al
je 0xe9b2
movq 0x20(%r13), %rdi
movq (%rdi), %rax
movl %r14d, %esi
movl %r15d, %edx
movl %r12d, %ecx
movl %ebx, %r8d
callq *0x8(%rax)
testq %rax, %rax
je 0xe9b2
movq %rax, %rbx
leaq 0x8(%rsp), %rdx
movq %rax, %rdi
movl $0x2000001, %esi        # imm = 0x2000001
callq 0x9890
testb %al, %al
je 0xe9aa
movq 0x28(%r13), %r13
movl 0x8(%rsp), %eax
movq %rax, 0x10(%rsp)
movl 0x10(%rbx), %ebp
movq %r13, %rdi
callq 0x9170
xorl %r10d, %r10d
movq 0x9694(%rip), %rdx      # 0x17fd0
movq %r13, %rdi
movl $0x3, %esi
movl %eax, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
pushq %r10
pushq %r10
pushq %r10
pushq %r10
pushq %rbp
pushq %r10
pushq %r12
pushq %r15
pushq %r14
pushq 0x58(%rsp)
callq 0x9400
addq $0x50, %rsp
movq %rax, %r14
movl 0x8(%rsp), %edi
callq 0x93c0
testq %r14, %r14
je 0xe9aa
movq %rbx, %rdi
movq %r14, %rsi
callq 0xdf14
testb %al, %al
jne 0xe9b4
movq %r14, %rdi
callq 0x9170
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl %eax, %ecx
movl $0x1, %r8d
xorl %eax, %eax
callq 0x9400
movq %rbx, %rdi
callq 0x9260
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x22f6(%rip), %rdi      # 0x10cc3
leaq 0x2e3a(%rip), %rsi      # 0x1180e
leaq 0x2e41(%rip), %rcx      # 0x1181c
movl $0x32, %edx
callq 0x9380
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
leaq 0x9230(%rip), %rax      # 0x17c20
cmpq %rax, (%rdi)
jne 0xea36
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x9490
movl 0x54(%rbx), %edi
callq 0x93c0
movq 0x28(%rbx), %rdi
callq 0x9830
movq 0x30(%rbx), %rdi
callq 0x9830
leaq 0x38(%rbx), %rdi
callq 0x95a0
movq 0x18(%rbx), %rdi
callq 0x9190
movq %rbx, %rdi
popq %rbx
jmp 0x9060
leaq 0x2286(%rip), %rdi      # 0x10cc3
leaq 0x2dca(%rip), %rsi      # 0x1180e
leaq 0x2dd1(%rip), %rcx      # 0x1181c
movl $0x32, %edx
callq 0x9380
// File: /workspace/github_c_makefile_star2_O3/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 %rax
leaq 0xef168(%rip), %rdi     # 0x4f1328
callq 0x4242f0
decq 0xeb14c(%rip)           # 0x4ed318
je 0x4021e3
leaq 0xef17b(%rip), %rdi     # 0x4f1350
leaq 0xef14c(%rip), %rsi     # 0x4f1328
callq 0x420950
jmp 0x4021ef
leaq 0xef166(%rip), %rdi     # 0x4f1350
callq 0x420300
leaq 0xef132(%rip), %rdi     # 0x4f1328
popq %rax
jmp 0x4251d0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq 0x1c7b2(%rip), %rax     # 0x201b0
movslq %edi, %rcx
movq (%rax,%rcx,8), %r9
movq 0x8(%rax,%rcx,8), %r11
movl $0x1, %eax
cmpl %r11d, %r9d
jge 0x3a88
movabsq $0x300000000, %r8       # imm = 0x300000000
movq 0x1c793(%rip), %rcx     # 0x201b8
movq %r9, %rdi
shlq $0x20, %rdi
movslq %r9d, %r9
movslq %r11d, %r10
cmpl %esi, 0x4(%rcx,%r9,4)
jge 0x3a47
addq $0x3, %r9
addq %r8, %rdi
cmpq %r10, %r9
jl 0x3a32
jmp 0x3a88
movq %rdi, %rbx
sarq $0x1e, %rbx
cmpl %esi, (%rcx,%rbx)
jg 0x3a88
cmpl %r11d, %r9d
jge 0x3a88
addq $0x3, %r9
cmpl %edx, -0x8(%rcx,%r9,4)
jge 0x3a7c
cmpl $0x2, -0x4(%rcx,%r9,4)
je 0x3a88
addq %r8, %rdi
leaq 0x3(%r9), %rsi
cmpq %r10, %r9
movq %rsi, %r9
jl 0x3a5c
jmp 0x3a88
sarq $0x1e, %rdi
xorl %eax, %eax
cmpl %edx, (%rcx,%rdi)
setg %al
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 %rax
leaq 0x169ec(%rip), %rsi     # 0x1a480
movl $0x50, %edi
callq 0x124b1
testq %rax, %rax
je 0x3ac9
xorl %ecx, %ecx
movl %ecx, (%rax)
movq %rcx, 0x8(%rax)
movl %ecx, 0x20(%rax)
movq %rcx, 0x28(%rax)
movl %ecx, 0x30(%rax)
movq %rcx, 0x38(%rax)
movl %ecx, 0x40(%rax)
movq %rcx, 0x48(%rax)
movl %ecx, 0x10(%rax)
movq %rcx, 0x18(%rax)
popq %rcx
retq
movl $0x1, %edi
callq 0x1280
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x3ae5
callq 0x1030
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x3af3
callq 0x1030
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x3b01
callq 0x1030
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x3b0f
callq 0x1030
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x3b1d
callq 0x1030
movq %rbx, %rdi
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movl %ecx, %r15d
movl %edx, %ebp
movl %esi, %r14d
cmpl $0xe, %edi
jg 0x3d24
movl %edi, %r12d
incl %r12d
cmpl %r15d, %ebp
cmovgl %ebp, %r15d
leal (%r14,%r14), %esi
movl %ebp, %edx
subl 0x4(%rbx), %edx
movl %r12d, %edi
movl %r15d, %ecx
movq %rbx, %r8
callq 0x3cd5
leal 0x1(,%r14,2), %r14d
addl (%rbx), %ebp
incl %r12d
cmpl $0x10, %r12d
jne 0x3cf3
movl %ebp, %eax
subl %r15d, %eax
movq 0x8(%rbx), %rcx
movslq %r14d, %rdx
movw %ax, (%rcx,%rdx,2)
movq 0x10(%rbx), %rax
movw %bp, (%rax,%rdx,2)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
cvtsi2sd %esi, %xmm0
mulsd 0x15de1(%rip), %xmm0    # 0x1a010
cvttsd2si %xmm0, %ebp
movq %rdi, %rbx
addl $0x2710, %ebp           # imm = 0x2710
movq 0x8(%rdi), %rdi
movslq %ebp, %rsi
leaq 0x1644a(%rip), %rdx     # 0x1a694
callq 0x12509
testq %rax, %rax
je 0x4261
movl %ebp, (%rbx)
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x1, %edi
callq 0x1280
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
cvtsi2sd %esi, %xmm0
mulsd 0x15d96(%rip), %xmm0    # 0x1a010
cvttsd2si %xmm0, %ebp
movq %rdi, %rbx
addl $0x2710, %ebp           # imm = 0x2710
movq 0x28(%rdi), %rdi
movslq %ebp, %rsi
leaq 0x16413(%rip), %rdx     # 0x1a6a8
callq 0x12509
testq %rax, %rax
je 0x42ad
movl %ebp, 0x20(%rbx)
movq %rax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x1, %edi
callq 0x1280
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r15
leaq 0x8(%rsi), %r14
movl $0x28, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rcx
callq 0x1290
movl $0x1, %ebx
cmpq $0x1, %rax
jne 0x9934
movq (%r12), %rdi
testq %rdi, %rdi
je 0x9932
movslq %ebp, %rsi
movslq (%r14), %rdx
movq %r15, %rcx
callq 0x1290
movslq (%r14), %rcx
cmpq %rcx, %rax
jne 0x9934
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
movq (%rdi), %rax
movl 0x8(%rdi), %ecx
testl %esi, %esi
je 0x996d
testl %ecx, %ecx
jle 0x9985
xorl %ecx, %ecx
movzwl (%rax,%rcx,2), %edx
cmpl $0x100, %edx            # imm = 0x100
jae 0x9989
movb %dl, (%rax,%rcx)
incq %rcx
movslq 0x8(%rdi), %rdx
cmpq %rdx, %rcx
jl 0x9950
jmp 0x9985
testl %ecx, %ecx
jle 0x9985
xorl %ecx, %ecx
movb (%rax,%rcx,2), %dl
movb %dl, (%rax,%rcx)
incq %rcx
movslq 0x8(%rdi), %rdx
cmpq %rdx, %rcx
jl 0x9973
xorl %eax, %eax
popq %rcx
retq
callq 0x12ff
// File: /workspace/github_c_makefile_star2_O3/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:
movslq 0x8(%rdi), %rax
testq %rax, %rax
jle 0x99b0
movq (%rdi), %rcx
incq %rax
movzbl -0x2(%rcx,%rax), %edx
movw %dx, -0x4(%rcx,%rax,2)
decq %rax
cmpq $0x1, %rax
ja 0x999d
retq
// File: /workspace/github_c_makefile_star2_O3/thegenemyers[P]DASCRUBBER/align.c
// Function: Check_Trace_Points
int Check_Trace_Points(Overlap *ovl, int tspace, int verbose, char *fname)
{ int i, p, q; 

  if (tspace != 0)
    { if (((ovl->path.aepos-1)/tspace - ovl->path.abpos/tspace)*2 != ovl->path.tlen-2)
        { if (verbose) 
            EPRINTF(EPLACE,"  %s: Wrong number of trace points\n",fname);
          return (1);
        }         
      p = ovl->path.bbpos;
      if (tspace <= TRACE_XOVR)
        { uint8 *trace8 = (uint8 *) ovl->path.trace;
          for (i = 1; i < ovl->path.tlen; i += 2)
            p += trace8[i];
        }
      else      
        { uint16 *trace16 = (uint16 *) ovl->path.trace;
          for (i = 1; i < ovl->path.tlen; i += 2)
            p += trace16[i];
        }
      if (p != ovl->path.bepos)
        { if (verbose)
            EPRINTF(EPLACE,"  %s: Trace point sum != aligned interval\n",fname);
          return (1); 
        }         
    }
  else
    { uint16 *trace16 = (uint16 *) ovl->path.trace;

      p = ovl->path.bbpos;
      q = ovl->path.abpos;
      for (i = 1; i < ovl->path.tlen; i += 2)
        { p += trace16[i];
          q += trace16[i-1];
        }
      if (p != ovl->path.bepos || q != ovl->path.aepos)
        { if (verbose)
            EPRINTF(EPLACE,"  %s: Trace point sum != aligned interval\n",fname);
          return (1); 
        }         
    }
  return (0);
}

// Assembly:
pushq %rax
movl %edx, %r8d
testl %esi, %esi
je 0x9c7a
movl 0x18(%rdi), %eax
decl %eax
cltd
idivl %esi
movl %eax, %r9d
movl 0x8(%rdi), %r10d
movl 0x10(%rdi), %eax
cltd
idivl %esi
subl %eax, %r9d
addl %r9d, %r9d
leal -0x2(%r10), %eax
cmpl %eax, %r9d
jne 0x9cca
movl 0x14(%rdi), %eax
movq (%rdi), %rdx
cmpl $0x7d, %esi
jg 0x9cf6
cmpl $0x2, %r10d
jl 0x9d12
movl $0x1, %esi
movzbl (%rdx,%rsi), %r9d
addl %r9d, %eax
addq $0x2, %rsi
cmpq %r10, %rsi
jb 0x9c64
jmp 0x9d12
movl 0x14(%rdi), %edx
movl 0x10(%rdi), %eax
movslq 0x8(%rdi), %rsi
cmpq $0x2, %rsi
jl 0x9cad
movq (%rdi), %r9
movl $0x1, %r10d
movzwl (%r9,%r10,2), %r11d
addl %r11d, %edx
movzwl -0x2(%r9,%r10,2), %r11d
addl %r11d, %eax
addq $0x2, %r10
cmpq %rsi, %r10
jb 0x9c93
cmpl 0x1c(%rdi), %edx
jne 0x9cb7
cmpl 0x18(%rdi), %eax
je 0x9d17
movl $0x1, %eax
testl %r8d, %r8d
je 0x9d19
leaq 0x10916(%rip), %rsi     # 0x1a5de
jmp 0x9cdb
movl $0x1, %eax
testl %r8d, %r8d
je 0x9d19
leaq 0x108df(%rip), %rsi     # 0x1a5ba
movq 0x16316(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
movq %rcx, %rdx
xorl %eax, %eax
callq 0x11a0
movl $0x1, %eax
jmp 0x9d19
cmpl $0x2, %r10d
jl 0x9d12
movl $0x1, %esi
movzwl (%rdx,%rsi,2), %r9d
addl %r9d, %eax
addq $0x2, %rsi
cmpq %r10, %rsi
jb 0x9d01
cmpl 0x1c(%rdi), %eax
jne 0x9cb7
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/thegenemyers[P]DASCRUBBER/align.c
// Function: Flip_Alignment
void Flip_Alignment(Alignment *align, int full)
{ char *aseq  = align->aseq;
  char *bseq  = align->bseq;
  int   alen  = align->alen;
  int   blen  = align->blen;
  Path *path  = align->path;
  int   comp  = COMP(align->flags);

  int  *trace = (int *) path->trace;
  int   tlen  = path->tlen;

  int   i, j, p;

  if (comp)
    { p = path->abpos;
      path->abpos = blen - path->bepos;
      path->bepos = alen - p;
      p = path->aepos;
      path->aepos = blen - path->bbpos;
      path->bbpos = alen - p;

      if (full)
        { alen += 2;
          blen += 2;

          for (i = 0; i < tlen; i++)
            if ((p = trace[i]) < 0)
              trace[i] = alen + p;
            else
              trace[i] = p - blen;

          i = tlen-1;
          j = 0;
          while (j < i)
            { p = trace[i];
              trace[i] = trace[j];
              trace[j] = p;
              i -= 1;
              j += 1;
            }

          alen -= 2;
          blen -= 2;
        }
    }
  else
    { p = path->abpos;
      path->abpos = path->bbpos;
      path->bbpos = p;
      p = path->aepos;
      path->aepos = path->bepos;
      path->bepos = p;

      if (full)
        for (i = 0; i < tlen; i++)
          trace[i] = - (trace[i]);
    }

  align->aseq  = bseq;
  align->bseq  = aseq;
  align->alen  = blen;
  align->blen  = alen;
}

// Assembly:
pushq %rbx
movdqu 0x10(%rdi), %xmm0
movl 0x20(%rdi), %eax
movl 0x24(%rdi), %ecx
movq (%rdi), %r9
movq (%r9), %rdx
movl 0x8(%r9), %r8d
testb $0x1, 0x8(%rdi)
movl 0x10(%r9), %r10d
jne 0x9d7b
movl 0x14(%r9), %r11d
movl %r11d, 0x10(%r9)
movl %r10d, 0x14(%r9)
movq 0x18(%r9), %xmm1
pshufd $0xe1, %xmm1, %xmm1     # xmm1 = xmm1[1,0,2,3]
movq %xmm1, 0x18(%r9)
testl %esi, %esi
je 0x9e07
testl %r8d, %r8d
jle 0x9e07
xorl %esi, %esi
negl (%rdx,%rsi,4)
incq %rsi
cmpq %rsi, %r8
jne 0x9d6b
jmp 0x9e07
movl %ecx, %r11d
subl 0x1c(%r9), %r11d
movl %r11d, 0x10(%r9)
movl %eax, %r11d
subl %r10d, %r11d
movl %r11d, 0x1c(%r9)
movl %ecx, %r10d
subl 0x14(%r9), %r10d
movl %eax, %r11d
subl 0x18(%r9), %r11d
movl %r10d, 0x18(%r9)
movl %r11d, 0x14(%r9)
testl %esi, %esi
je 0x9e07
testl %r8d, %r8d
jle 0x9e07
leal 0x2(%rax), %esi
movl $0xfffffffe, %r9d       # imm = 0xFFFFFFFE
subl %ecx, %r9d
xorl %r10d, %r10d
movl (%rdx,%r10,4), %r11d
testl %r11d, %r11d
movl %r9d, %ebx
cmovsl %esi, %ebx
addl %r11d, %ebx
movl %ebx, (%rdx,%r10,4)
incq %r10
cmpq %r10, %r8
jne 0x9dbe
cmpl $0x1, %r8d
je 0x9e07
addq $-0x2, %r8
xorl %esi, %esi
movl 0x4(%rdx,%r8,4), %r9d
movl (%rdx,%rsi,4), %r10d
movl %r10d, 0x4(%rdx,%r8,4)
movl %r9d, (%rdx,%rsi,4)
incq %rsi
leaq -0x1(%r8), %r9
cmpq %r8, %rsi
movq %r9, %r8
jl 0x9de6
pshufd $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movdqu %xmm0, 0x10(%rdi)
movl %ecx, 0x20(%rdi)
movl %eax, 0x24(%rdi)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movslq %esi, %rax
addq %rdi, %rax
decq %rax
cmpq %rdi, %rax
jbe 0x9e3e
movb $0x3, %cl
subb (%rdi), %cl
movb $0x3, %dl
subb (%rax), %dl
movb %dl, (%rdi)
incq %rdi
movb %cl, (%rax)
decq %rax
cmpq %rax, %rdi
jb 0x9e27
cmpq %rax, %rdi
je 0x9e44
retq
movb $0x3, %al
subb (%rdi), %al
movb %al, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/thegenemyers[P]DASCRUBBER/align.c
// Function: enlarge_trace
static int enlarge_trace(_Work_Data *work, int newmax)
{ void *vec;
  int   max;

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cvtsi2sd %esi, %xmm0
mulsd 0x9cce(%rip), %xmm0     # 0x1a010
cvttsd2si %xmm0, %ebp
movq %rdi, %rbx
addl $0x2710, %ebp           # imm = 0x2710
movq 0x38(%rdi), %rdi
movslq %ebp, %rsi
leaq 0xa37b(%rip), %rdx      # 0x1a6d8
callq 0x12509
testq %rax, %rax
je 0x10375
movl %ebp, 0x30(%rbx)
movq %rax, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x1, %edi
callq 0x1280
// File: /workspace/github_c_makefile_star2_O3/ikbenlike[P]nngutils/src/cat.c
// Function: cat
int cat(struct cat_args *args, char *name){
    int fd;
    int c;
    for(int i = 0; i < args->fcount; i++){
        if(!strcmp(args->files[i], "-")){
            fd = STDIN_FILENO;
        }
        else {
            fd = open(args->files[i], O_RDONLY);
            if(fd == -1){
                fprintf(stderr, "%s: %s\n", name, strerror(errno));
                exit(1);
            }
        }
        print_file(fd, args, name);
        close(fd);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x0, 0x10(%rdi)
jle 0x183a
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rdi
cmpb $0x2d, (%rdi)
jne 0x1800
cmpb $0x0, 0x1(%rdi)
je 0x1835
xorl %esi, %esi
xorl %eax, %eax
callq 0x10e0
movl %eax, %r15d
cmpl $-0x1, %eax
je 0x1845
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1552
movl %r15d, %edi
callq 0x1080
incq %r12
movslq 0x10(%r14), %rax
cmpq %rax, %r12
jl 0x17ed
jmp 0x183a
xorl %r15d, %r15d
jmp 0x1811
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x118c
// File: /workspace/github_c_makefile_star2_O3/ikbenlike[P]nngutils/src/cat.c
// Function: main
int main(int argc, char **argv){
    struct cat_args *args = calloc(1, sizeof(struct cat_args));
    if(args == NULL){
        fprintf(stderr, "%s: %s\n", argv[0], strerror(errno));
        return 1;
    }
    args = parse_arg(args, argc, argv);
    if(argc == 1 || args->fcount == 0){
        args->files[0] = calloc(1, 2 * sizeof(char));
        strcpy(args->files[0], "-");
        args->fcount = 1;
    }
    cat(args, argv[0]);
    free(args->files);
    free(args);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %r15d
movl $0x1, %edi
movl $0x18, %esi
callq 0x10b0
testq %rax, %rax
je 0x18e0
movq %rax, %rbx
movq %rax, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x12fc
cmpl $0x1, %r15d
je 0x188e
cmpl $0x0, 0x10(%rbx)
jne 0x18b7
movl $0x1, %edi
movl $0x2, %esi
callq 0x10b0
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movq 0x8(%rbx), %rax
movq (%rax), %rax
movw $0x2d, (%rax)
movl $0x1, 0x10(%rbx)
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x17d3
movq 0x8(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x11cb
movl $0x1, %eax
jmp 0x18d5
// File: /workspace/github_c_makefile_star2_O3/macournoyer[P]peg/leg.c
// Function: yyparsefrom
YY_PARSE(int) YYPARSEFROM(yyrule yystart)
{
  int yyok;
  if (!yybuflen)
    {
      yybuflen= 1024;
      yybuf= malloc(yybuflen);
      yytextlen= 1024;
      yytext= malloc(yytextlen);
      yythunkslen= 32;
      yythunks= malloc(sizeof(yythunk) * yythunkslen);
      yyvalslen= 32;
      yyvals= malloc(sizeof(YYSTYPE) * yyvalslen);
      yybegin= yyend= yypos= yylimit= yythunkpos= 0;
    }
  yybegin= yyend= yypos;
  yythunkpos= 0;
  yyval= yyvals;
  yyok= yystart();
  if (yyok) yyDone();
  yyCommit();
  return yyok;
  (void)yyrefill;
  (void)yymatchDot;
  (void)yymatchChar;
  (void)yymatchString;
  (void)yymatchClass;
  (void)yyDo;
  (void)yyText;
  (void)yyDone;
  (void)yyCommit;
  (void)yyAccept;
  (void)yyPush;
  (void)yyPop;
  (void)yySet;
  (void)yytextmax;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x8c26(%rip)      # 0xa114
je 0x14ff
movl 0x8c5a(%rip), %ecx      # 0xa150
movq 0x8c43(%rip), %rax      # 0xa140
jmp 0x156c
movl $0x400, %ebp            # imm = 0x400
movl %ebp, 0x8c0a(%rip)      # 0xa114
movl $0x400, %edi            # imm = 0x400
callq 0x1100
movq %rax, 0x8bfd(%rip)      # 0xa118
movl %ebp, 0x8bff(%rip)      # 0xa120
movl $0x400, %edi            # imm = 0x400
callq 0x1100
movq %rax, 0x8bf6(%rip)      # 0xa128
movl $0x20, 0x8bf4(%rip)     # 0xa130
movl $0x300, %edi            # imm = 0x300
callq 0x1100
movq %rax, 0x8beb(%rip)      # 0xa138
movl $0x80, %edi
callq 0x1100
movq %rax, 0x8be2(%rip)      # 0xa140
xorl %ecx, %ecx
movl %ecx, 0x8be6(%rip)      # 0xa14c
movl %ecx, 0x8be4(%rip)      # 0xa150
movl %ecx, 0x8be2(%rip)      # 0xa154
movl %ecx, 0x8be0(%rip)      # 0xa158
movl $0x0, 0x8bc6(%rip)      # 0xa148
movq %rax, 0x8bd7(%rip)      # 0xa160
xorl %eax, %eax
callq *%rbx
movl %eax, %ebx
testl %eax, %eax
je 0x15e3
cmpl $0x0, 0x8bae(%rip)      # 0xa148
jle 0x15e3
movl $0x8, %r14d
xorl %r15d, %r15d
movq 0x8b8c(%rip), %r12      # 0xa138
movl -0x8(%r12,%r14), %esi
movl -0x4(%r12,%r14), %eax
testl %eax, %eax
je 0x15c5
movl %esi, %edi
movl %eax, %esi
callq 0x1a26
movl %eax, %esi
movq 0x8b5c(%rip), %rdi      # 0xa128
callq *(%r12,%r14)
incq %r15
movslq 0x8b6e(%rip), %rax      # 0xa148
addq $0x18, %r14
cmpq %rax, %r15
jl 0x15a5
movslq 0x8b66(%rip), %r14      # 0xa150
movl 0x8b5c(%rip), %eax      # 0xa14c
subl %r14d, %eax
movl %eax, 0x8b53(%rip)      # 0xa14c
je 0x160e
movq 0x8b16(%rip), %rdi      # 0xa118
leaq (%rdi,%r14), %rsi
movslq %eax, %rdx
callq 0x1120
subl %r14d, 0x8b43(%rip)     # 0xa158
subl %r14d, 0x8b38(%rip)     # 0xa154
xorl %eax, %eax
movl %eax, 0x8b24(%rip)      # 0xa148
movl %eax, 0x8b26(%rip)      # 0xa150
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/macournoyer[P]peg/leg.c
// Function: yyerror
void yyerror(char *message)
{
  fprintf(stderr, "%s:%d: %s", fileName, lineNumber, message);
  if (yytext[0]) fprintf(stderr, " near token '%s'", yytext);
  if (yypos < yylimit || !feof(input))
    {
      yybuf[yylimit]= '\0';
      fprintf(stderr, " before text \"");
      while (yypos < yylimit)
	{
	  if ('\n' == yybuf[yypos] || '\r' == yybuf[yypos]) break;
	  fputc(yybuf[yypos++], stderr);
	}
      if (yypos == yylimit)
	{
	  int c;
	  while (EOF != (c= fgetc(input)) && '\n' != c && '\r' != c)
	    fputc(c, stderr);
	}
      fputc('\"', stderr);
    }
  fprintf(stderr, "\n");
  exit(1);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %r8
movq 0x89aa(%rip), %rbx      # 0x9ff8
movq (%rbx), %rdi
movq 0x8b10(%rip), %rdx      # 0xa168
movl 0x8b12(%rip), %ecx      # 0xa170
leaq 0x399f(%rip), %rsi      # 0x5004
xorl %eax, %eax
callq 0x10c0
movq 0x8ab5(%rip), %rdx      # 0xa128
cmpb $0x0, (%rdx)
je 0x1689
movq (%rbx), %rdi
leaq 0x398c(%rip), %rsi      # 0x500e
xorl %eax, %eax
callq 0x10c0
movl 0x8abd(%rip), %eax      # 0xa14c
cmpl %eax, 0x8abb(%rip)      # 0xa150
jl 0x16b1
movq 0x8a6a(%rip), %rdi      # 0xa108
callq 0x10d0
testl %eax, %eax
jne 0x174f
movl 0x8a9b(%rip), %eax      # 0xa14c
movq 0x8a60(%rip), %rcx      # 0xa118
cltq
movb $0x0, (%rcx,%rax)
movq (%rbx), %rcx
leaq 0x3957(%rip), %rdi      # 0x501f
movl $0xe, %esi
movl $0x1, %edx
callq 0x1180
movl 0x8a73(%rip), %eax      # 0xa150
movl 0x8a69(%rip), %ecx      # 0xa14c
cmpl %ecx, %eax
jge 0x1714
movq 0x8a2a(%rip), %rdx      # 0xa118
movslq %eax, %rsi
movzbl (%rdx,%rsi), %edx
cmpl $0xa, %edx
je 0x1714
cmpl $0xd, %edx
je 0x1714
movsbl %dl, %edi
incl %eax
movl %eax, 0x8a46(%rip)      # 0xa150
movq (%rbx), %rsi
callq 0x1090
jmp 0x16d7
cmpl %ecx, %eax
jne 0x1742
movl $0x4801, %ebp           # imm = 0x4801
movq 0x89e4(%rip), %rdi      # 0xa108
callq 0x1080
leal 0x1(%rax), %ecx
cmpl $0xe, %ecx
ja 0x1736
btl %ecx, %ebp
jb 0x1742
movq (%rbx), %rsi
movl %eax, %edi
callq 0x1090
jmp 0x171d
movq (%rbx), %rsi
movl $0x22, %edi
callq 0x1090
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x1090
movl $0x1, %edi
callq 0x1170
// File: /workspace/github_c_makefile_star2_O3/macournoyer[P]peg/leg.c
// Function: makeHeader
void makeHeader(char *text)
{
  Header *header= (Header *)malloc(sizeof(Header));
  header->text= strdup(text);
  header->next= headers;
  headers= header;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10, %edi
callq 0x1100
movq %rax, %r14
movq %rbx, %rdi
callq 0x1190
movq %rax, (%r14)
movq 0x89ec(%rip), %rax      # 0xa178
movq %rax, 0x8(%r14)
movq %r14, 0x89e1(%rip)      # 0xa178
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/macournoyer[P]peg/leg.c
// Function: yyText
YY_LOCAL(int) yyText(int begin, int end)
{
  int yyleng= end - begin;
  if (yyleng <= 0)
    yyleng= 0;
  else
    {
      while (yytextlen < (yyleng - 1))
	{
	  yytextlen *= 2;
	  yytext= realloc(yytext, yytextlen);
	}
      memcpy(yytext, yybuf + begin, yyleng);
    }
  yytext[yyleng]= '\0';
  return yyleng;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
subl %edi, %ebx
jle 0x1a8d
movl %edi, %ebp
leal -0x1(%rbx), %r13d
movl 0x86dc(%rip), %r12d     # 0xa120
movq 0x86dd(%rip), %r14      # 0xa128
cmpl %r13d, %r12d
jge 0x1a77
addl %r12d, %r12d
movslq %r12d, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1110
movq %rax, %r14
cmpl %r13d, %r15d
jl 0x1a50
movl %r12d, 0x86b0(%rip)     # 0xa120
movq %r14, 0x86b1(%rip)      # 0xa128
movslq %ebp, %rsi
addq 0x8697(%rip), %rsi      # 0xa118
movl %ebx, %edx
movq %r14, %rdi
callq 0x10e0
jmp 0x1a96
xorl %ebx, %ebx
movq 0x8692(%rip), %r14      # 0xa128
movl %ebx, %eax
movb $0x0, (%r14,%rax)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/macournoyer[P]peg/leg.c
// Function: yy__
YY_RULE(int) yy__()
{
  yyprintf((stderr, "%s\n", "_"));
  l107:;	
  {  int yypos108= yypos, yythunkpos108= yythunkpos;
  {  int yypos109= yypos, yythunkpos109= yythunkpos;  if (!yy_space()) goto l110;  goto l109;
  l110:;	  yypos= yypos109; yythunkpos= yythunkpos109;  if (!yy_comment()) goto l108;
  }
  l109:;	  goto l107;
  l108:;	  yypos= yypos108; yythunkpos= yythunkpos108;
  }
  yyprintf((stderr, "  ok   %s @ %s\n", "_", yybuf+yypos));
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x8515(%rip), %ebx      # 0xa150
movl 0x8507(%rip), %ebp      # 0xa148
movl $0x20, %edi
callq 0x1d1b
testl %eax, %eax
jne 0x1c35
movl %ebx, 0x84fb(%rip)      # 0xa150
movl %ebp, 0x84ed(%rip)      # 0xa148
movl $0x9, %edi
callq 0x1d1b
testl %eax, %eax
jne 0x1c35
movl %ebx, 0x84e1(%rip)      # 0xa150
movl %ebp, 0x84d3(%rip)      # 0xa148
callq 0x1df2
testl %eax, %eax
jne 0x1c35
movl %ebx, 0x84cc(%rip)      # 0xa150
movl %ebp, 0x84be(%rip)      # 0xa148
movl $0x23, %edi
callq 0x1d1b
testl %eax, %eax
je 0x1d04
movl 0x84b1(%rip), %r14d     # 0xa150
movl 0x84a2(%rip), %r15d     # 0xa148
callq 0x1df2
testl %eax, %eax
jne 0x1ce9
movl %r14d, 0x849a(%rip)     # 0xa150
movl %r15d, 0x848b(%rip)     # 0xa148
cmpl 0x8488(%rip), %r14d     # 0xa14c
jl 0x1cdd
callq 0x1d60
testl %eax, %eax
je 0x1ce9
movl 0x847a(%rip), %r14d     # 0xa150
movl 0x846b(%rip), %r15d     # 0xa148
incl %r14d
movl %r14d, 0x8469(%rip)     # 0xa150
jmp 0x1ca6
movl %r14d, 0x8460(%rip)     # 0xa150
movl %r15d, 0x8451(%rip)     # 0xa148
callq 0x1df2
testl %eax, %eax
jne 0x1c35
movl %ebx, 0x8446(%rip)      # 0xa150
movl %ebp, 0x8438(%rip)      # 0xa148
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/macournoyer[P]peg/leg.c
// Function: yyrefill
YY_LOCAL(int) yyrefill(void)
{
  int yyn;
  while (yybuflen - yypos < 512)
    {
      yybuflen *= 2;
      yybuf= realloc(yybuf, yybuflen);
    }
  YY_INPUT((yybuf + yypos), yyn, (yybuflen - yypos));
  if (!yyn) return 0;
  yylimit += yyn;
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl 0x83e5(%rip), %r14d     # 0xa150
movl 0x83a3(%rip), %ebp      # 0xa114
movl %ebp, %eax
subl %r14d, %eax
cmpl $0x1ff, %eax            # imm = 0x1FF
jg 0x1dac
movq 0x8394(%rip), %rax      # 0xa118
addl %ebp, %ebp
movslq %ebp, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1110
subl %r14d, %ebx
cmpl $0x200, %ebx            # imm = 0x200
jl 0x1d84
movl %ebp, 0x836f(%rip)      # 0xa114
movq %rax, 0x836c(%rip)      # 0xa118
movq 0x8355(%rip), %rdi      # 0xa108
callq 0x11a0
cmpl $-0x1, %eax
je 0x1deb
cmpl $0xd, %eax
je 0x1dc7
cmpl $0xa, %eax
jne 0x1dcd
incl 0x83a3(%rip)            # 0xa170
movq 0x8344(%rip), %rcx      # 0xa118
movslq 0x8375(%rip), %rdx      # 0xa150
movb %al, (%rcx,%rdx)
incl 0x8368(%rip)            # 0xa14c
movl $0x1, %eax
jmp 0x1ded
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/macournoyer[P]peg/leg.c
// Function: yy_end_of_line
YY_RULE(int) yy_end_of_line()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "end_of_line"));
  {  int yypos2= yypos, yythunkpos2= yythunkpos;  if (!yymatchString("\r\n")) goto l3;  goto l2;
  l3:;	  yypos= yypos2; yythunkpos= yythunkpos2;  if (!yymatchChar('\n')) goto l4;  goto l2;
  l4:;	  yypos= yypos2; yythunkpos= yythunkpos2;  if (!yymatchChar('\r')) goto l1;
  }
  l2:;	
  yyprintf((stderr, "  ok   %s @ %s\n", "end_of_line", yybuf+yypos));
  return 1;
  l1:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "end_of_line", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl 0x8354(%rip), %ebp      # 0xa150
movl 0x8345(%rip), %r14d     # 0xa148
leaq 0x3257(%rip), %rdi      # 0x5061
callq 0x1e64
movl $0x1, %ebx
testl %eax, %eax
jne 0x1e5d
movl %ebp, 0x8332(%rip)      # 0xa150
movl %r14d, 0x8323(%rip)     # 0xa148
movl $0xa, %edi
callq 0x1d1b
testl %eax, %eax
jne 0x1e5d
movl %ebp, 0x8317(%rip)      # 0xa150
movl %r14d, 0x8308(%rip)     # 0xa148
movl $0xd, %edi
callq 0x1d1b
testl %eax, %eax
jne 0x1e5d
movl %ebp, 0x82fc(%rip)      # 0xa150
movl %r14d, 0x82ed(%rip)     # 0xa148
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/macournoyer[P]peg/leg.c
// Function: yymatchString
YY_LOCAL(int) yymatchString(char *s)
{
  int yysav= yypos;
  while (*s)
    {
      if (yypos >= yylimit && !yyrefill()) return 0;
      if (yybuf[yypos] != *s)
        {
          yypos= yysav;
          return 0;
        }
      ++s;
      ++yypos;
    }
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movb (%rdi), %cl
movl $0x1, %ebx
testb %cl, %cl
je 0x1ecf
movq %rdi, %r14
movl 0x82d4(%rip), %ebp      # 0xa150
movl 0x82ca(%rip), %eax      # 0xa14c
incq %r14
movl %ebp, %edx
cmpl %eax, %edx
jl 0x1ea4
callq 0x1d60
testl %eax, %eax
je 0x1ecd
movl 0x82b2(%rip), %eax      # 0xa14c
movl 0x82b0(%rip), %edx      # 0xa150
movb -0x1(%r14), %cl
movq 0x826d(%rip), %rsi      # 0xa118
movslq %edx, %rdi
cmpb %cl, (%rsi,%rdi)
jne 0x1ec7
incl %edx
movl %edx, 0x8295(%rip)      # 0xa150
movb (%r14), %cl
incq %r14
testb %cl, %cl
jne 0x1e87
jmp 0x1ecf
movl %ebp, 0x8283(%rip)      # 0xa150
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq