LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/utils.c
// Function: m38_get_cookie_value
char *m38_get_cookie_value(const char *cookie_string, const size_t cookie_string_siz, const char *needle) {
	/* TODO: Make sure this function handles bad input. */
	if (!cookie_string)
			return NULL;

	const char *cookie_loc = strnstr(cookie_string, needle, cookie_string_siz);
	if (!cookie_loc)
			return NULL;

	const char *cookie_string_start = cookie_loc;
	const char *cookie_string_end = strnstr(cookie_loc, ";", cookie_string_siz - (cookie_loc - cookie_string));
	if (!cookie_string_end) {
			/* This is okay, it might be at the end of the cookie. */
			cookie_string_end = strnstr(cookie_loc, " ", cookie_string_siz - (cookie_loc - cookie_string));
			if (!cookie_string_end)
					cookie_string_end = cookie_loc + cookie_string_siz;
	}

	const size_t cookie_string_size = cookie_string_end - cookie_string_start;
	const char *cookie_string_value = strnstr(cookie_loc, "=", cookie_string_size);
	if (!cookie_string_value)
			return NULL;

	/* -1 here is for the '=': */
	const size_t cookie_string_value_size = cookie_string_end - cookie_string_value;
	char *data = calloc(sizeof(char), cookie_string_value_size + 2); /* Plus two here: One for =, one for NULL */
	data[cookie_string_value_size] = '\0';
	strncpy(data, cookie_string_value + 1, cookie_string_value_size);

	return data;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x421a
movq %rsi, %rbx
movq %rdi, %r15
movq %rdx, %rsi
movq %rbx, %rdx
callq 0x32a0
testq %rax, %rax
je 0x421a
movq %rax, %r14
subq %rax, %r15
addq %rbx, %r15
leaq 0x4e97(%rip), %rsi      # 0x9036
movq %rax, %rdi
movq %r15, %rdx
callq 0x32a0
movq %rax, %r12
testq %rax, %rax
jne 0x41d1
leaq 0x69c4(%rip), %rsi      # 0xab7d
movq %r14, %rdi
movq %r15, %rdx
callq 0x32a0
addq %r14, %rbx
testq %rax, %rax
cmovneq %rax, %rbx
movq %rbx, %r12
movq %r12, %rdx
subq %r14, %rdx
leaq 0x69f8(%rip), %rsi      # 0xabd6
movq %r14, %rdi
callq 0x32a0
testq %rax, %rax
je 0x421a
movq %rax, %rbx
subq %rax, %r12
leaq 0x2(%r12), %rsi
pushq $0x1
popq %rdi
callq 0x32e0
incq %rbx
movq %rax, %rdi
movq %rbx, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x30a0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/grengine.c
// Function: m38_insert_custom_header
int m38_insert_custom_header(m38_http_response *response, const char *header, const size_t header_len,
		const char *value, const size_t value_len) {
	if (!header || !value || !response)
		return 0;

	m38_header_pair *new_pair = calloc(1, sizeof(m38_header_pair));
	if (!new_pair) {
		m38_log_msg(LOG_ERR, "Could not create header_pair for http_response extra headers!");
		return 0;
	}

	const char *copied_header = strndup(header, header_len);
	const char *copied_value = strndup(value, value_len);
	if (!copied_header || !copied_value) {
		m38_log_msg(LOG_ERR, "Could not create copied values for http_response extra headers!");
		free(new_pair);
		return 0;
	}

	m38_header_pair _stack_pair = {
		.header = copied_header,
		.header_len = header_len,
		.value = copied_value,
		.value_len = value_len,
	};
	memcpy(new_pair, &_stack_pair, sizeof(m38_header_pair));
	vector_append_ptr(response->extra_headers, new_pair);

	return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x4a90
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbp
testq %rsi, %rsi
je 0x4a82
movq %rcx, %r13
testq %rcx, %rcx
je 0x4a82
movq %r8, %rbx
movq %rdx, %r15
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0x32e0
testq %rax, %rax
je 0x4a56
movq %rax, %r12
movq %rbp, %rdi
movq %r15, %rsi
callq 0x32d0
movq %rax, %rbp
movq %r13, %rdi
movq %rbx, %rsi
callq 0x32d0
testq %rbp, %rbp
setne %cl
testq %rax, %rax
setne %dl
testb %dl, %cl
je 0x4a69
movq %rbp, (%r12)
movq %r15, 0x8(%r12)
movq %rax, 0x10(%r12)
movq %rbx, 0x18(%r12)
movq 0x38(%r14), %rdi
movq %r12, %rsi
callq 0x34d0
jmp 0x4a82
leaq 0x475b(%rip), %rsi      # 0x91b8
pushq $0x3
popq %rdi
xorl %eax, %eax
callq 0x3540
jmp 0x4a82
leaq 0x4786(%rip), %rsi      # 0x91f6
pushq $0x3
popq %rdi
xorl %eax, %eax
callq 0x3540
movq %r12, %rdi
callq 0x3050
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/grengine.c
// Function: read_max_bytes_from_socket
static int read_max_bytes_from_socket(const int accept_fd, unsigned char **to_read, size_t *num_read) {
	size_t read_this_time = 0;
	while ((read_this_time = recv(accept_fd, *to_read + *num_read, MAX_READ_LEN, 0))) {
		*num_read += read_this_time;
		if (read_this_time == 0 || read_this_time < MAX_READ_LEN)
			break;
		read_this_time = 0;

		*to_read = realloc(*to_read, *num_read + MAX_READ_LEN);
		if (!(*to_read)) {
			m38_log_msg(LOG_ERR, "Ran out of memory reading request.");
			goto error;
		}
		memset(*to_read + *num_read, '\0', MAX_READ_LEN);
		if (*num_read >= MAX_REQUEST_SIZE)
			break;
	}

	return 0;

error:
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movq (%rsi), %r12
movq (%rdx), %r13
addq %r12, %r13
xorl %r15d, %r15d
movl $0x400, %edx            # imm = 0x400
movl %ebp, %edi
movq %r13, %rsi
xorl %ecx, %ecx
callq 0x3060
testq %rax, %rax
je 0x5633
movq (%rbx), %rsi
addq %rax, %rsi
movq %rsi, (%rbx)
cmpq $0x400, %rax            # imm = 0x400
jb 0x5633
movq (%r14), %rdi
addq $0x400, %rsi            # imm = 0x400
callq 0x3440
movq %rax, (%r14)
testq %rax, %rax
je 0x561e
movq %rax, %r12
movq (%rbx), %r13
movq %rax, %rdi
addq %r13, %rdi
xorl %r15d, %r15d
movl $0x400, %edx            # imm = 0x400
xorl %esi, %esi
callq 0x3220
cmpq $0x200000, %r13         # imm = 0x200000
jb 0x55b4
jmp 0x5633
leaq 0x3f6b(%rip), %rsi      # 0x9590
pushq $0x3
popq %rdi
xorl %eax, %eax
callq 0x3540
pushq $-0x1
popq %r15
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/grengine.c
// Function: m38_send_response
m38_handled_request *m38_send_response(m38_handled_request *hreq) {
	/* Send that shit over the wire: */
	const m38_route *matching_route = hreq->matching_route;

	const size_t bytes_left = hreq->response_len - hreq->sent;
	const size_t to_send = bytes_left < 4096 ? bytes_left : 4096;
	int rc = send(hreq->accept_fd, hreq->response_bytes + hreq->sent, to_send, MSG_NOSIGNAL);
	if (rc <= 0) {
		m38_log_msg(LOG_ERR, "Could not send response.");
		goto error;
	}

	hreq->sent += to_send;

	if (hreq->response_len - hreq->sent <= 0) {
		if (matching_route->cleanup != NULL) {
			m38_log_msg(LOG_INFO, "Calling cleanup for %s.", matching_route->name);
			matching_route->cleanup(hreq->response_code, &hreq->response);
		}
		_clean_up_extra_headers(&hreq->response);
		close(hreq->accept_fd);
		free(hreq->response_bytes);
		free(hreq);

		return NULL;
	}

	return hreq;

error:
	if (matching_route != NULL && matching_route->cleanup != NULL)
		matching_route->cleanup(500, &hreq->response);
	_clean_up_extra_headers(&hreq->response);
	close(hreq->accept_fd);
	free(hreq->response_bytes);
	free(hreq);

	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq 0x18(%rdi), %rsi
subq %rsi, %r14
movl $0x1000, %eax           # imm = 0x1000
cmpq %rax, %r14
cmovaeq %rax, %r14
movq 0x20(%rdi), %r15
movl 0x10(%rdi), %edi
addq (%rbx), %rsi
movq %r14, %rdx
movl $0x4000, %ecx           # imm = 0x4000
callq 0x31a0
testl %eax, %eax
jle 0x56bb
addq 0x18(%rbx), %r14
movq %r14, 0x18(%rbx)
cmpq %r14, 0x8(%rbx)
jne 0x570b
cmpq $0x0, 0x160(%r15)
je 0x56e8
leaq 0x10(%r15), %rdx
leaq 0x3e1e(%rip), %rsi      # 0x94c0
xorl %edi, %edi
xorl %eax, %eax
callq 0x3540
movl 0x14(%rbx), %edi
leaq 0x28(%rbx), %rsi
callq *0x160(%r15)
jmp 0x56e8
leaq 0x3de5(%rip), %rsi      # 0x94a7
pushq $0x3
popq %rdi
xorl %eax, %eax
callq 0x3540
testq %r15, %r15
je 0x56e8
movq 0x160(%r15), %rax
testq %rax, %rax
je 0x56e8
leaq 0x28(%rbx), %rsi
movl $0x1f4, %edi            # imm = 0x1F4
callq *%rax
leaq 0x28(%rbx), %rdi
callq 0x5714
movl 0x10(%rbx), %edi
callq 0x3280
movq (%rbx), %rdi
callq 0x3050
movq %rbx, %rdi
callq 0x3050
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/grengine.c
// Function: clean_up_extra_headers
static void _clean_up_extra_headers(m38_http_response *response) {
	size_t i = 0;
	for (i = 0; i < response->extra_headers->count; i++) {
		m38_header_pair **pair = (m38_header_pair **)vector_get(response->extra_headers, i);
		free((char *)(*pair)->header);
		free((char *)(*pair)->value);
		free(*pair);
	}
	vector_free(response->extra_headers);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x38(%rbx), %rdi
cmpq 0x10(%rdi), %r14
jae 0x5758
movl %r14d, %esi
callq 0x3170
movq %rax, %r15
movq (%rax), %rax
movq (%rax), %rdi
callq 0x3050
movq (%r15), %rax
movq 0x10(%rax), %rdi
callq 0x3050
movq (%r15), %rdi
callq 0x3050
incq %r14
jmp 0x571f
popq %rbx
popq %r14
popq %r15
jmp 0x3130
nop
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/server.c
// Function: open_queue
static inline mqd_t _open_queue(const char *queue_name, int flags, const size_t size) {
	(void) flags;
	struct mq_attr asq_attr = {
		.mq_flags = 0,
		.mq_maxmsg = 10,
		.mq_msgsize = size, /* We're passing around file descriptors */
		.mq_curmsgs = 0
	};

	mqd_t to_return = mq_open(queue_name, O_WRONLY | O_CREAT, 0644, &asq_attr);
	if (to_return == -1)
		perror("Could not open queue");

	return to_return;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movaps %xmm0, 0x10(%rcx)
movaps %xmm0, 0x30(%rcx)
movaps %xmm0, 0x20(%rcx)
movq $0xa, 0x8(%rcx)
movq %rsi, 0x10(%rcx)
pushq $0x41
popq %rsi
movl $0x1a4, %edx            # imm = 0x1A4
xorl %eax, %eax
callq 0x3370
movl %eax, %ebx
cmpl $-0x1, %eax
je 0x7fb3
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
retq
leaq 0x28bc(%rip), %rdi      # 0xa876
callq 0x34f0
jmp 0x7fab
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/server.c
// Function: acceptor
static void *acceptor(void *arg) {
	mqd_t accepted_socket_queue = 0;
	const acceptor_arg *args = arg;
	const int main_sock_fd = args->main_sock_fd;

	accepted_socket_queue = _open_queue(ACCEPTED_SOCKET_QUEUE_NAME, O_WRONLY, sizeof(int));
	if (accepted_socket_queue == -1) {
		m38_log_msg(LOG_ERR, "Acceptor: Could not open accepted_socket_queue.");
		perror("Acceptor: ");
		return NULL;
	}

	while(1) {
		struct sockaddr_storage their_addr = {0};
		socklen_t sin_size = sizeof(their_addr);

		int new_fd = accept(main_sock_fd, (struct sockaddr *)&their_addr, &sin_size);

		if (new_fd == -1) {
			m38_log_msg(LOG_ERR, "Acceptor: Could not accept new connection.");
			return NULL;
		}

		ssize_t msg_size = mq_send(accepted_socket_queue, (char *)&new_fd, sizeof(int), 0);
		if (msg_size == -1) {
			/* We want to continue from this error. Maybe the queue is full or something. */
			m38_log_msg(LOG_ERR, "Acceptor: Could not queue new accepted connection.");
			close(new_fd);
		}
	}

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl (%rdi), %ebx
leaq 0x266e(%rip), %rdi      # 0xa649
pushq $0x4
popq %rsi
callq 0x7f6f
cmpl $-0x1, %eax
je 0x80a2
movl %eax, %ebp
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %r15
leaq 0x8(%rsp), %r12
pushq $0x4
popq %r13
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movl $0x80, 0xc(%rsp)
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3510
movl %eax, 0x8(%rsp)
cmpl $-0x1, %eax
je 0x807d
movl %ebp, %edi
movq %r12, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x3290
cmpl $-0x1, %eax
jne 0x8001
pushq $0x3
popq %rdi
leaq 0x2886(%rip), %rsi      # 0xa8f1
xorl %eax, %eax
callq 0x3540
movl 0x8(%rsp), %edi
callq 0x3280
jmp 0x8001
leaq 0x2842(%rip), %rsi      # 0xa8c6
pushq $0x3
popq %rdi
xorl %eax, %eax
callq 0x3540
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x27e2(%rip), %rsi      # 0xa88b
pushq $0x3
popq %rdi
xorl %eax, %eax
callq 0x3540
leaq 0x2801(%rip), %rdi      # 0xa8bb
callq 0x34f0
jmp 0x808e
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/server.c
// Function: responder
static void *responder(void *arg) {
	UNUSED(arg);

	mqd_t handled_queue = -1;
	handled_queue = mq_open(HANDLED_CONNECTION_QUEUE_NAME, O_RDWR);
	if (handled_queue == -1) {
		m38_log_msg(LOG_ERR, "Responder: Could not open handled queue.");
		perror("Responder: ");
		return NULL;
	}

	while(1) {
		m38_handled_request *req = NULL;
		ssize_t msg_size = mq_receive(handled_queue, (char *)&req, sizeof(m38_handled_request *), NULL);

		if (msg_size == -1) {
			m38_log_msg(LOG_ERR, "Responder: Could not read from handled_queue.");
			perror("Responder: ");
			break;
		} else if (req == NULL) {
			m38_log_msg(LOG_ERR, "Responder: Got bogus request from queue.");
		} else {
			m38_handled_request *new_req = m38_send_response(req);
			if (new_req != NULL) {
				ssize_t msg_size = mq_send(handled_queue, (char *)&new_req, sizeof(m38_handled_request *), 0);
				if (msg_size == -1)
					m38_log_msg(LOG_ERR, "Responder: Could not enqueue handled response.");
			} else {
				m38_log_msg(LOG_FUN, "Responder: Response sent.");
			}
		}
	}

	mq_close(handled_queue);

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x2599(%rip), %rdi      # 0xa66f
pushq $0x2
popq %rsi
xorl %eax, %eax
callq 0x3370
cmpl $-0x1, %eax
jne 0x8107
leaq 0x2838(%rip), %rsi      # 0xa924
pushq $0x3
popq %rdi
xorl %eax, %eax
callq 0x3540
leaq 0x2850(%rip), %rdi      # 0xa94d
callq 0x34f0
jmp 0x81b2
movl %eax, %ebx
leaq 0x8(%rsp), %r14
pushq $0x8
popq %r15
leaq 0x286e(%rip), %r12      # 0xa987
pushq $0x3
popq %rbp
leaq 0x10(%rsp), %r13
andq $0x0, 0x8(%rsp)
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x34b0
cmpq $-0x1, %rax
je 0x818e
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x8174
callq 0x35e0
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x817b
movl %ebx, %edi
movq %r13, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x3290
cmpl $-0x1, %eax
jne 0x8121
movl %ebp, %edi
leaq 0x283e(%rip), %rsi      # 0xa9b0
jmp 0x8185
movl %ebp, %edi
movq %r12, %rsi
jmp 0x8185
pushq $0x4
popq %rdi
leaq 0x285a(%rip), %rsi      # 0xa9df
xorl %eax, %eax
callq 0x3540
jmp 0x8121
leaq 0x27c4(%rip), %rsi      # 0xa959
pushq $0x3
popq %rdi
xorl %eax, %eax
callq 0x3540
leaq 0x27a7(%rip), %rdi      # 0xa94d
callq 0x34f0
movl %ebx, %edi
callq 0x3260
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/server.c
// Function: m38_set_404_handler
int m38_set_404_handler(m38_app *app,
	int (*handler)(const m38_http_request *request, m38_http_response *response)) {
	if (app->r_404_route) {
		app->r_404_route->handler = handler;
	} else {
		m38_route *new_route = calloc(1, sizeof(m38_route));
		new_route->handler = handler;
		new_route->cleanup = NULL;
		strncpy(new_route->name, "Custom 404 Handler", sizeof(new_route->name));
		strncpy(new_route->verb, "GET", sizeof(new_route->verb));
		strncpy(new_route->route_match, "^.*$", sizeof(new_route->route_match));

		app->r_404_route = new_route;
	}

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x8367
movq %r14, 0x158(%rax)
jmp 0x83d0
movq %rdi, %rbx
pushq $0x1
popq %rdi
movl $0x168, %esi            # imm = 0x168
callq 0x32e0
movq %rax, %r15
movq %r14, 0x158(%rax)
movups 0x27f7(%rip), %xmm0     # 0xab7f
movups %xmm0, 0x10(%rax)
movups 0x27fc(%rip), %xmm0     # 0xab8f
movups %xmm0, 0x20(%rax)
movups 0x2801(%rip), %xmm0     # 0xab9f
movups %xmm0, 0x30(%rax)
movups 0x2806(%rip), %xmm0     # 0xabaf
movups %xmm0, 0x40(%rax)
movups 0x280c(%rip), %xmm0     # 0xabc0
movups %xmm0, (%rax)
leaq 0x50(%rax), %rdi
leaq 0x2432(%rip), %rsi      # 0xa7f4
movl $0x100, %edx            # imm = 0x100
callq 0x30a0
movq %r15, 0x20(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/server.c
// Function: m38_set_404_cleanup
int m38_set_404_cleanup(m38_app *app,
	void (*cleanup)(const int status_code, m38_http_response *response)) {
	if (app->r_404_route) {
		app->r_404_route->cleanup = cleanup;
	} else {
		m38_route *new_route = calloc(1, sizeof(m38_route));
		new_route->handler = NULL;
		new_route->cleanup = cleanup;
		strncpy(new_route->name, "Custom 404 Handler", sizeof(new_route->name));
		strncpy(new_route->verb, "GET", sizeof(new_route->verb));
		strncpy(new_route->route_match, "^.*$", sizeof(new_route->route_match));

		app->r_404_route = new_route;
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x83f2
movq %r14, 0x160(%rax)
jmp 0x845b
movq %rdi, %rbx
pushq $0x1
popq %rdi
movl $0x168, %esi            # imm = 0x168
callq 0x32e0
movq %rax, %r15
movq %r14, 0x160(%rax)
movups 0x276c(%rip), %xmm0     # 0xab7f
movups %xmm0, 0x10(%rax)
movups 0x2771(%rip), %xmm0     # 0xab8f
movups %xmm0, 0x20(%rax)
movups 0x2776(%rip), %xmm0     # 0xab9f
movups %xmm0, 0x30(%rax)
movups 0x277b(%rip), %xmm0     # 0xabaf
movups %xmm0, 0x40(%rax)
movups 0x2781(%rip), %xmm0     # 0xabc0
movups %xmm0, (%rax)
leaq 0x50(%rax), %rdi
leaq 0x23a7(%rip), %rsi      # 0xa7f4
movl $0x100, %edx            # imm = 0x100
callq 0x30a0
movq %r15, 0x20(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/parse.c
// Function: m38_get_header_value_raw
char *m38_get_header_value_raw(const char *request, const size_t request_siz, const char header[static 1]) {
	/* TODO: Make sure this function handles bad input. */
	char *data = NULL;
	const char *header_loc = strnstr(request, header, request_siz);
	if (!header_loc)
		return NULL;

	const char *header_value_start = header_loc + strnlen(header, request_siz) + strlen(": ");
	const char *header_value_end = strnstr(header_loc, "\r\n", request_siz);
	if (!header_value_end)
		return NULL;

	const size_t header_value_size = header_value_end - header_value_start;
	data = calloc(sizeof(char), header_value_size + 1);
	data[header_value_size] = '\0';
	strncpy(data, header_value_start, header_value_size);

	return data;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdx, %rsi
movq %r14, %rdx
callq 0x32a0
testq %rax, %rax
je 0x85b8
movq %rax, %rbx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3240
movq %rax, %r15
leaq 0xecb(%rip), %rsi       # 0x9447
movq %rbx, %rdi
movq %r14, %rdx
callq 0x32a0
testq %rax, %rax
je 0x85b8
movq %rax, %r14
addq %r15, %rbx
addq $0x2, %rbx
subq %rbx, %r14
leaq 0x1(%r14), %rsi
pushq $0x1
popq %rdi
callq 0x32e0
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x30a0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/parse.c
// Function: m38_parse_request
int m38_parse_request(const unsigned char *to_read, const size_t num_read, m38_http_request *out) {
	/* Find the verb */
	const char *verb_end = strnstr((char *)to_read, " ", MAX_READ_LEN);
	if (verb_end == NULL)
		goto error;

	const size_t c_verb_size = verb_end - (char *)to_read;
	const size_t verb_size = c_verb_size >= sizeof(out->verb) ? sizeof(out->verb) - 1: c_verb_size;
	strncpy(out->verb, (char *)to_read, verb_size);

	const char *res_offset = verb_end + strlen(" ");
	const char *resource_end = strnstr(res_offset, " ", sizeof(out->resource));
	if (resource_end == NULL)
		goto error;

	const size_t c_resource_size = resource_end - res_offset;
	const size_t resource_size = c_resource_size >= sizeof(out->resource) ? sizeof(out->resource) : c_resource_size;
	strncpy(out->resource, res_offset, resource_size);

	/* Parse full header here. */
	size_t header_length = 0;
	int found_end = 0;
	while (header_length + 3 <= num_read) {
		if (to_read[header_length] == '\r' &&
		    to_read[header_length + 1] == '\n' &&
		    to_read[header_length + 2] == '\r' &&
		    to_read[header_length + 3] == '\n') {
			header_length += 4;
			found_end = 1;
			break;
		}
		header_length++;
	}

	if (!found_end) {
		m38_log_msg(LOG_DEBUG, "Could not find end of HTTP header.");
		goto error;
	}

	out->full_header = strndup((char *)to_read, header_length);
	out->header_len = header_length;

	return 0;

error:
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x2589(%rip), %rsi      # 0xab7d
movl $0x400, %edx            # imm = 0x400
callq 0x32a0
pushq $-0x1
popq %rbp
testq %rax, %rax
je 0x869f
movq %rax, %r12
subq %r14, %rax
cmpq $0xf, %rax
pushq $0xf
popq %rdx
cmovbq %rax, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x30a0
incq %r12
leaq 0x254d(%rip), %rsi      # 0xab7d
movl $0x200, %r13d           # imm = 0x200
movl $0x200, %edx            # imm = 0x200
movq %r12, %rdi
callq 0x32a0
testq %rax, %rax
je 0x869f
subq %r12, %rax
cmpq %r13, %rax
cmovaeq %r13, %rax
leaq 0x10(%rbx), %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x30a0
pushq $0x3
popq %r12
cmpq %r15, %r12
ja 0x868e
cmpb $0xd, -0x3(%r14,%r12)
jne 0x8689
cmpb $0xa, -0x2(%r14,%r12)
jne 0x8689
cmpb $0xd, -0x1(%r14,%r12)
jne 0x8689
cmpb $0xa, (%r14,%r12)
je 0x86b0
incq %r12
jmp 0x8665
leaq 0x2592(%rip), %rsi      # 0xac27
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x3540
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
incq %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x32d0
movq %rax, 0x230(%rbx)
movq %r12, 0x238(%rbx)
xorl %ebp, %ebp
jmp 0x869f
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/parse.c
// Function: m38_parse_body
int m38_parse_body(const size_t received_body_len,
			   const size_t content_length_num,
			   const unsigned char *raw_request,
			   m38_http_request *request) {

	const char *body_start = (char *)raw_request + request->header_len;
	/* We want to read the least amount. Read whatever is smallest. DO IT BECAUSE I SAY SO. */
	if (content_length_num == received_body_len) {
		request->body_len = content_length_num;
		request->full_body = (unsigned char *)strndup(body_start, content_length_num);
	} else if (received_body_len < content_length_num) {
		m38_log_msg(LOG_DEBUG, "FULL BODY: Received body length is less than clength for full_body.");
		request->body_len = received_body_len;
		request->full_body = (unsigned char *)strndup(body_start, request->body_len);
	} else if (content_length_num > 0 && content_length_num < received_body_len) {
		m38_log_msg(LOG_DEBUG, "FULL BODY: Content length is less than total received body length.");
		request->body_len = content_length_num;
		request->full_body = (unsigned char *)strndup(body_start, request->body_len);
	} else {
		m38_log_msg(LOG_DEBUG, "FULL BODY: Discrepancy between content-length and body length.");
		request->full_body = NULL;
	}

	if (!request->full_body) {
		m38_log_msg(LOG_WARN, "No body on request, even though we expect one.");
		return -1;
	}

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
addq 0x238(%rcx), %r14
cmpq %rdi, %rsi
je 0x8719
jbe 0x86f8
leaq 0x2557(%rip), %rsi      # 0xac4a
movq %rdi, %r15
jmp 0x870f
testq %r15, %r15
setne %al
cmpq %rdi, %r15
setb %cl
testb %cl, %al
je 0x873e
leaq 0x257f(%rip), %rsi      # 0xac8e
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x3540
movq %r15, 0x248(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x32d0
movq %rax, %rcx
movq %rax, 0x240(%rbx)
xorl %eax, %eax
testq %rcx, %rcx
jne 0x876b
jmp 0x8757
leaq 0x258c(%rip), %rsi      # 0xacd1
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x3540
andq $0x0, 0x240(%rbx)
leaq 0x25b2(%rip), %rsi      # 0xad10
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x3540
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/parse.c
// Function: m38_parse_form_encoded_body
int m38_parse_form_encoded_body(m38_http_request *request) {
	struct sparse_dict *new_dict = NULL;
	char *potential_kv_pair = NULL;
	char *duplicated_body = strndup((char *)request->full_body, request->body_len);
	if (!duplicated_body) {
		goto err;
	}

	new_dict = sparse_dict_init();

	while ((potential_kv_pair = strsep((char **)&request->full_body, "&")) != NULL) {
		char *key = NULL;
		char *value = NULL;
		key = strsep(&potential_kv_pair, "=");
		value = strsep(&potential_kv_pair, "=");

		if (!key || !value) {
			continue;
		}

		char *decoded_buffer = calloc(1, strlen(value));
		if (m38_url_decode(value, decoded_buffer) > 0) {
			sparse_dict_set(new_dict, key, strlen(key), decoded_buffer, strlen(decoded_buffer));
		} else {
			m38_log_msg(LOG_WARN, "Could not place item into form elements dict.");
		}
		free(decoded_buffer);
	}

	request->form_elements = new_dict;
	free(duplicated_body);
	return 0;

err:
	free(duplicated_body);
	free(new_dict);
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x10(%rsp), %r14
andq $0x0, (%r14)
movq %rdi, 0x8(%rsp)
leaq 0x240(%rdi), %r15
xorl %eax, %eax
callq 0x31d0
movq %rax, (%rsp)
leaq 0x2599(%rip), %r12      # 0xad3f
leaq 0x2429(%rip), %rbp      # 0xabd6
movq %r15, %rdi
movq %r12, %rsi
callq 0x33d0
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x8874
movq %r14, %rdi
movq %rbp, %rsi
callq 0x33d0
movq %rax, %rbx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x33d0
movq %rax, %r13
testq %rbx, %rbx
setne %al
testq %r13, %r13
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x87ad
movq %r15, %rbp
movq %r14, %r15
movq %r12, %r14
movq %r13, %rdi
callq 0x3150
pushq $0x1
popq %rdi
movq %rax, %rsi
callq 0x32e0
movq %rax, %r12
movq %r13, %rdi
movq %rax, %rsi
callq 0x30e0
testl %eax, %eax
jle 0x884d
movq %rbx, %rdi
callq 0x3150
movq %rax, %r13
movq %r12, %rdi
callq 0x3150
movq (%rsp), %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %rax, %r8
callq 0x3300
jmp 0x885e
pushq $0x2
popq %rdi
leaq 0x24ea(%rip), %rsi      # 0xad41
xorl %eax, %eax
callq 0x3540
movq %r12, %rdi
callq 0x3050
movq %r14, %r12
movq %r15, %r14
movq %rbp, %r15
jmp 0x87a6
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0x250(%rax)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/perftests/kvldsclean/main.c
// Function: batch_set
static int
batch_set(struct wire_requestqueue * Q, size_t start, size_t N)
{
	struct many_state C;
	char buf[9];
	size_t x;
	struct kvldskey * key;

	/* Not failed or done yet.  No requests in progress yet. */
	C.failed = C.done = 0;
	C.Nip = 0;

	/* Set values. */
	for (x = start; x < start + N; x++) {
		/* Set "$x" = "$x". */
		sprintf(buf, "%08zu", x);
		if ((key = kvldskey_create((uint8_t *)buf, 8)) == NULL)
			goto err0;
		if (proto_kvlds_request_set(Q, key, key, callback_done, &C)) {
			warnp("Failed to send SET request");
			goto err1;
		}
		C.Nip += 1;
		kvldskey_free(key);
	}

	/* Spin until the requests are done. */
	if (events_spin(&C.done) || C.failed) {
		warnp("SET request failed");
		return (-1);
	}

	/* Success! */
	return (0);

err1:
	kvldskey_free(key);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0xc(%rsp), %rax
addq %rsi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0xc(%rax)
leaq 0x1f(%rsp), %r14
movq %rsp, %r13
cmpq %rbx, %r15
jae 0x28a1
movq %r14, %rdi
leaq 0x6913(%rip), %rsi      # 0x9166
movq %r15, %rdx
xorl %eax, %eax
callq 0x22b0
movq %r14, %rdi
pushq $0x8
popq %rsi
callq 0x4fe0
testq %rax, %rax
je 0x290b
movq %rax, %rbp
movq %r12, %rdi
movq %rax, %rsi
movq %rax, %rdx
leaq 0x1bd(%rip), %rcx       # 0x2a41
movq %r13, %r8
callq 0x51e2
testl %eax, %eax
jne 0x28d5
incq (%rsp)
movq %rbp, %rdi
callq 0x2040
incq %r15
jmp 0x2844
leaq 0xc(%rsp), %rdi
callq 0x2cff
movl %eax, %ecx
xorl %eax, %eax
orl 0x8(%rsp), %ecx
je 0x290e
callq 0x2090
cmpl $0x0, (%rax)
je 0x291d
movq %rax, %rbx
leaq 0x68be(%rip), %rdi      # 0x9187
xorl %eax, %eax
callq 0x4ccd
andl $0x0, (%rbx)
jmp 0x290b
callq 0x2090
cmpl $0x0, (%rax)
je 0x28f5
movq %rax, %rbx
leaq 0x6883(%rip), %rdi      # 0x916c
xorl %eax, %eax
callq 0x4ccd
andl $0x0, (%rbx)
jmp 0x2903
leaq 0x6870(%rip), %rdi      # 0x916c
xorl %eax, %eax
callq 0x4e5c
movq %rbp, %rdi
callq 0x2040
pushq $-0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6863(%rip), %rdi      # 0x9187
xorl %eax, %eax
callq 0x4e5c
jmp 0x290b
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/perftests/kvldsclean/main.c
// Function: batch_delete
static int
batch_delete(struct wire_requestqueue * Q, size_t start, size_t N)
{
	struct many_state C;
	char buf[9];
	size_t x;
	struct kvldskey * key;

	/* Not failed or done yet.  No requests in progress yet. */
	C.failed = C.done = 0;
	C.Nip = 0;

	/* Set values. */
	for (x = start; x < start + N; x++) {
		/* Delete "$x". */
		sprintf(buf, "%08zu", x);
		if ((key = kvldskey_create((uint8_t *)buf, 8)) == NULL)
			goto err0;
		if (proto_kvlds_request_delete(Q, key, callback_done, &C)) {
			warnp("Failed to send DELETE request");
			goto err1;
		}
		C.Nip += 1;
		kvldskey_free(key);
	}

	/* Spin until the requests are done. */
	if (events_spin(&C.done) || C.failed) {
		warnp("DELETE request failed");
		return (-1);
	}

	/* Success! */
	return (0);

err1:
	kvldskey_free(key);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0xc(%rsp), %rax
addq %rsi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0xc(%rax)
leaq 0x1f(%rsp), %r14
movq %rsp, %r13
cmpq %rbx, %r15
jae 0x29b5
movq %r14, %rdi
leaq 0x67fc(%rip), %rsi      # 0x9166
movq %r15, %rdx
xorl %eax, %eax
callq 0x22b0
movq %r14, %rdi
pushq $0x8
popq %rsi
callq 0x4fe0
testq %rax, %rax
je 0x2a1f
movq %rax, %rbp
movq %r12, %rdi
movq %rax, %rsi
leaq 0xa9(%rip), %rdx        # 0x2a41
movq %r13, %rcx
callq 0x5741
testl %eax, %eax
jne 0x29e9
incq (%rsp)
movq %rbp, %rdi
callq 0x2040
incq %r15
jmp 0x295b
leaq 0xc(%rsp), %rdi
callq 0x2cff
movl %eax, %ecx
xorl %eax, %eax
orl 0x8(%rsp), %ecx
je 0x2a22
callq 0x2090
cmpl $0x0, (%rax)
je 0x2a31
movq %rax, %rbx
leaq 0x67db(%rip), %rdi      # 0x91b8
xorl %eax, %eax
callq 0x4ccd
andl $0x0, (%rbx)
jmp 0x2a1f
callq 0x2090
cmpl $0x0, (%rax)
je 0x2a09
movq %rax, %rbx
leaq 0x679d(%rip), %rdi      # 0x919a
xorl %eax, %eax
callq 0x4ccd
andl $0x0, (%rbx)
jmp 0x2a17
leaq 0x678a(%rip), %rdi      # 0x919a
xorl %eax, %eax
callq 0x4e5c
movq %rbp, %rdi
callq 0x2040
pushq $-0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6780(%rip), %rdi      # 0x91b8
xorl %eax, %eax
callq 0x4e5c
jmp 0x2a1f
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_11/word_count_test.c
// Function: main
int main(void)
{
  char nl;
  char nw;
  char nc;

  int state;

  nl = nw = nc = 0;
  state = OUT;

  char c;
  while ((c = getchar()) != EOF)
  {
    ++nc;

    if (c == '\n')
    {
      ++nl;
    }

    if (c == ' ' || c == '\n' || c == '\t')
    {
      state = OUT;
    }
    else if (state == OUT)
    {
      state = IN;
      ++nw;
    }
  }

  printf("lines: %d\nwords: %d\ncharacters: %d\n", nl, nw, nc);

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movb $0x1, %r15b
xorl %ebx, %ebx
xorl %ebp, %ebp
xorl %r14d, %r14d
callq 0x1040
shll $0x18, %eax
cmpl $0xff000000, %eax       # imm = 0xFF000000
je 0x119f
cmpl $0xa000000, %eax        # imm = 0xA000000
sete %cl
addb %cl, %r14b
cmpl $0x9000000, %eax        # imm = 0x9000000
je 0x118c
cmpl $0x20000000, %eax       # imm = 0x20000000
je 0x118c
cmpl $0xa000000, %eax        # imm = 0xA000000
jne 0x1194
incb %bpl
movb $0x1, %r15b
jmp 0x115d
addb %r15b, %bl
incb %bpl
xorl %r15d, %r15d
jmp 0x115d
movsbl %r14b, %esi
movsbl %bl, %edx
movsbl %bpl, %ecx
leaq 0xe53(%rip), %rdi       # 0x2004
xorl %eax, %eax
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: nrParameters
int nrParameters(Node argList) {
	int level = 0;
	int nrParameters = argList == NULL? 0: 1;

	for (Node nPtr = argList; nPtr != NULL; nPtr = nPtr->next) {
        const char *str = (const char *) nPtr->element.name;
        if (strcmp(str, ",") == 0 && level == 0) {
			nrParameters++;
        } else {
            if (strcmp(str, "{") == 0 || strcmp(str, "(") == 0 || strcmp(str, "[") == 0) {
                level++;
            } else if (strcmp(str, "}") == 0 || strcmp(str, ")") == 0 || strcmp(str, "]") == 0) {
                level--;
            }
        }
	}
	return nrParameters;
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
setne %al
xorl %ecx, %ecx
testq %rdi, %rdi
je 0x341c
movq 0x18(%rdi), %rdx
movzbl (%rdx), %esi
cmpl $0x28, %esi
je 0x3404
cmpl $0x29, %esi
je 0x340e
cmpl $0x7d, %esi
je 0x340e
cmpl $0x5b, %esi
je 0x3404
cmpl $0x5d, %esi
je 0x340e
cmpl $0x7b, %esi
je 0x3404
cmpl $0x2c, %esi
jne 0x3416
cmpb $0x0, 0x1(%rdx)
sete %dl
testl %ecx, %ecx
sete %sil
andb %dl, %sil
movzbl %sil, %edx
addl %edx, %eax
jmp 0x3416
cmpb $0x0, 0x1(%rdx)
jne 0x3416
incl %ecx
jmp 0x3416
cmpb $0x0, 0x1(%rdx)
jne 0x3416
decl %ecx
movq 0x28(%rdi), %rdi
jmp 0x33bd
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: MakeRuleResult
RuleResult MakeRuleResult(Name returnVariable, Name returnType, Name initialValue) {
	RuleResult ruleResult = (RuleResult) mmalloc(sizeof(struct RuleResult));

	ruleResult->returnVariable = returnVariable;
	ruleResult->returnType = returnType;
	ruleResult->initialValue = initialValue;
	return ruleResult;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x18
popq %rdi
callq 0xb85c
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: MakeName
Name MakeName(char *str, int index, NameType nameType, short int lineNr) {
	Name name = (Name) mmalloc(sizeof(struct Name));

	name->name = MakeString(str);
	name->index = index;
	name->lineNr = lineNr;
	name->empty = false;
	name->first = NULL;
	name->nameType = nameType;
	name->rules = NULL;
	name->follow = NULL;
	name->arglist = NULL;
	name->ruleResult = NULL;
	name->keywords = NULL;
	name->usesLA = false;
	name->functions = NULL;
	name->nrParameters = 0;
	name->isTerminal = false;
	return (name);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
pushq $0x68
popq %rdi
callq 0xb85c
movq %rax, %r12
movq %r15, %rdi
callq 0x333c
movq %rax, (%r12)
movslq %r14d, %rax
movq %rax, 0x28(%r12)
movl %ebx, 0x20(%r12)
andw $0x0, 0x30(%r12)
andq $0x0, 0x8(%r12)
movl %ebp, 0x38(%r12)
andq $0x0, 0x40(%r12)
andl $0x0, 0x32(%r12)
andl $0x0, 0x48(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r12)
movups %xmm0, 0x50(%r12)
andq $0x0, 0x60(%r12)
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: InsertSymbol
Name InsertSymbol(char *str, NodeList rules, Boolean lhs, NameType nameType) {
	Name name = GetInfo(FindNode(idTree, str, (TreeCmp) NameCmpStr));

	if (name == NULL) {
		name = MakeName(str, -1, nameType, lineNumber);
		InsertNodeSingle(&idTree, name, name, (TreeCmp) NameCmp);
	}
	if (lhs) {
		if (name->rules == NULL && name->nameType != token) {
			name->rules = rules;
		} else {
			yyerror("lhs %s already used", str);
		}
	}
	return (name);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r12d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x15627(%rip), %rdi     # 0x18b00
leaq 0x82(%rip), %rdx        # 0x3562
movq %rbx, %rsi
callq 0xb305
movq %rax, %rdi
callq 0xb265
movq %rax, %r15
testq %rax, %rax
jne 0x352c
leaq 0x14ca5(%rip), %rax     # 0x181a4
movswl (%rax), %ecx
pushq $-0x1
popq %rsi
movq %rbx, %rdi
movl %r12d, %edx
callq 0x3444
movq %rax, %r15
leaq 0x155e6(%rip), %rdi     # 0x18b00
leaq 0x49(%rip), %rcx        # 0x356a
movq %rax, %rsi
movq %rax, %rdx
callq 0xaecc
testw %bp, %bp
je 0x3550
cmpq $0x0, 0x18(%r15)
jne 0x353f
cmpl $0x4, 0x38(%r15)
jne 0x355c
leaq 0xcbaa(%rip), %rdi      # 0x100f0
movq %rbx, %rsi
xorl %eax, %eax
callq 0x358b
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, 0x18(%r15)
jmp 0x3550
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: yyerror
void yyerror(char *format, ...) { /* Called by yyparse on error */
	va_list args;

	errorOccurred = true;
	(void) fprintf(stderr, "%s:%d: ", inputFileName, lineNumber);
	va_start(args, format);
	vfprintf(stderr, format, args);
	fprintf(stderr, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x35ee
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movb $0x1, 0x15519(%rip)     # 0x18b0e
movq 0x149fc(%rip), %r15     # 0x17ff8
movq (%r15), %rdi
movq 0x14b82(%rip), %rdx     # 0x18188
leaq 0x14b97(%rip), %rax     # 0x181a4
movl (%rax), %ecx
leaq 0xcc56(%rip), %rsi      # 0x1026c
xorl %eax, %eax
callq 0x3150
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movq %r14, 0x10(%rdx)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x31d0
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x3120
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: InsertString
Name InsertString(char *str) {
	Name name = GetInfo(FindNode(idTree, str, (TreeCmp) NameCmpStr));

	if (name == NULL) {
		name = MakeName(str, ++nodeNumber, string, lineNumber);
		InsertNodeSingle(&idTree, name, name, (TreeCmp) NameCmp);
	}
	return (name);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x15492(%rip), %rdi     # 0x18b00
leaq -0x113(%rip), %rdx      # 0x3562
movq %rbx, %rsi
callq 0xb305
movq %rax, %rdi
callq 0xb265
movq %rax, %r14
testq %rax, %rax
jne 0x36cc
movl 0x15475(%rip), %esi     # 0x18b08
incl %esi
movl %esi, 0x1546d(%rip)     # 0x18b08
leaq 0x14b02(%rip), %rax     # 0x181a4
movswl (%rax), %ecx
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x3444
movq %rax, %r14
leaq 0x15446(%rip), %rdi     # 0x18b00
leaq -0x157(%rip), %rcx      # 0x356a
movq %rax, %rsi
movq %rax, %rdx
callq 0xaecc
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: AssignString
void AssignString(Name name, Name str) {
	if (name->rules == NULL && name->nameType == identifier) {
		name->nameType = token;
		name->index = str->index;
	} else {
		yyerror("token already defined as lhs %s", name->name);
	}
}

// Assembly:
cmpq $0x0, 0x18(%rdi)
jne 0x36e4
cmpl $0x0, 0x38(%rdi)
je 0x36f5
movq (%rdi), %rsi
leaq 0xca16(%rip), %rdi      # 0x10104
xorl %eax, %eax
jmp 0x358b
movl $0x4, 0x38(%rdi)
movq 0x28(%rsi), %rax
movq %rax, 0x28(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: KeywordString
void KeywordString(Name name, Name str, Name ident) {
    if (name->keywords != NULL || name->functions != NULL) {
		yyerror("no keyword hierarchie allowed: %s", name->name);
	} else if (name->rules == NULL && name->nameType == identifier && (ident->nameType == identifier || ident->nameType == token)) {
		name->nameType = token;
		if (str == NULL) {
			name->index = ++nodeNumber;
		} else {
			name->index = str->index;
			str->index = 0;
		}
		ident->nameType = token;
		InsertNodeSingle(&ident->keywords, str, name, (TreeCmp) NameCmp);
		AddProperty("keywords");
	} else if (ident->nameType != identifier && ident->nameType != token) {
		yyerror("identifier already defined as lhs %s", ident->name);
	} else {
		yyerror("token already defined as lhs %s", name->name);
	}
}

// Assembly:
movq %rdi, %rax
cmpq $0x0, 0x58(%rdi)
jne 0x3716
cmpq $0x0, 0x60(%rax)
je 0x3727
movq (%rax), %rsi
leaq 0xca04(%rip), %rdi      # 0x10124
xorl %eax, %eax
jmp 0x358b
cmpq $0x0, 0x18(%rax)
jne 0x3734
cmpl $0x0, 0x38(%rax)
je 0x3755
testl $0xfffffffb, 0x38(%rdx) # imm = 0xFFFFFFFB
jne 0x3749
movq (%rax), %rsi
leaq 0xc9bd(%rip), %rdi      # 0x10104
jmp 0x3720
movq (%rdx), %rsi
leaq 0xc9fc(%rip), %rdi      # 0x1014f
jmp 0x3720
testl $0xfffffffb, 0x38(%rdx) # imm = 0xFFFFFFFB
jne 0x3734
movl $0x4, 0x38(%rax)
testq %rsi, %rsi
je 0x3779
movq 0x28(%rsi), %rcx
movq %rcx, 0x28(%rax)
andq $0x0, 0x28(%rsi)
jmp 0x378d
movslq 0x15388(%rip), %rcx     # 0x18b08
incq %rcx
movl %ecx, 0x1537f(%rip)     # 0x18b08
movq %rcx, 0x28(%rax)
pushq %rax
movl $0x4, 0x38(%rdx)
addq $0x58, %rdx
leaq -0x236(%rip), %rcx      # 0x356a
movq %rdx, %rdi
movq %rax, %rdx
callq 0xaecc
leaq 0xc994(%rip), %rdi      # 0x10146
popq %rax
jmp 0x3359
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: Function
void Function(Name name, Name fun, Name ident) {
	if (name->keywords != NULL || name->functions != NULL) {
		yyerror("no function hierarchie allowed: %s", name->name);
	} else if (name->rules == NULL && name->nameType == identifier && (ident->nameType == identifier || ident->nameType == token)) {
		name->nameType = token;
		name->index = ++nodeNumber;
		fun->index = 0;
		fun->nameType = function;
		ident->nameType = token;
		InsertNodeSingle(&ident->functions, fun, name, (TreeCmp) NameCmp);
		AddProperty("functions");
	} else if (ident->nameType != identifier && ident->nameType != token) {
		yyerror("identifier already defined as lhs %s", ident->name);
	} else {
		yyerror("token already defined as lhs %s", name->name);
	}
}

// Assembly:
movq %rdi, %rax
cmpq $0x0, 0x58(%rdi)
jne 0x37c9
cmpq $0x0, 0x60(%rax)
je 0x37da
movq (%rax), %rsi
leaq 0xc9a1(%rip), %rdi      # 0x10174
xorl %eax, %eax
jmp 0x358b
cmpq $0x0, 0x18(%rax)
jne 0x37e7
cmpl $0x0, 0x38(%rax)
je 0x3808
testl $0xfffffffb, 0x38(%rdx) # imm = 0xFFFFFFFB
jne 0x37fc
movq (%rax), %rsi
leaq 0xc90a(%rip), %rdi      # 0x10104
jmp 0x37d3
movq (%rdx), %rsi
leaq 0xc949(%rip), %rdi      # 0x1014f
jmp 0x37d3
testl $0xfffffffb, 0x38(%rdx) # imm = 0xFFFFFFFB
jne 0x37e7
pushq %rax
pushq $0x4
popq %rcx
movl %ecx, 0x38(%rax)
movslq 0x152e9(%rip), %rdi     # 0x18b08
incq %rdi
movl %edi, 0x152e0(%rip)     # 0x18b08
movq %rdi, 0x28(%rax)
andq $0x0, 0x28(%rsi)
movl $0x5, 0x38(%rsi)
movl %ecx, 0x38(%rdx)
addq $0x60, %rdx
leaq -0x2dc(%rip), %rcx      # 0x356a
movq %rdx, %rdi
movq %rax, %rdx
callq 0xaecc
leaq 0xcc24(%rip), %rdi      # 0x1047c
popq %rax
jmp 0x3359
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: MakeNode
Node MakeNode(short int lineNr, NodeType nodeType, void *element, Node next) {
	Node node;

	if (oldNodes == NULL) {
		node = (Node) mmalloc(sizeof(struct Node));
	} else {
		node = oldNodes;
		oldNodes = oldNodes->next;
	}
	node->nodeType = nodeType;
	node->arglist = NULL;
	switch (nodeType) {
		case single: node->element.name = element; break;
		case option: node->element.sub = element; break;
		case sequence: node->element.sub = element; break;
		case chain: node->element.sub = element; break;
		case alternative: node->element.alternatives = element; break;
		case breakToken: node->element.name = element; break;
		case errorMessage: node->element.sub = element; break;
		// default: fprintf(stderr, "MakeNode: unknown nodetype %d\n", nodeType);
	}
	node->lineNr = lineNr;
	node->next = next;
	node->preferShift = false;
	node->empty = false;
	node->assignTo = NULL;
	return (node);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r15d
movl %edi, %ebp
pushq $0x30
popq %rdi
callq 0xb85c
movl %r15d, 0x4(%rax)
andq $0x0, 0x8(%rax)
cmpl $0x6, %r15d
ja 0x388b
movq %r14, 0x18(%rax)
movw %bp, (%rax)
movq %rbx, 0x28(%rax)
andl $0x0, 0x20(%rax)
andq $0x0, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: MakeNodeList
NodeList MakeNodeList(Node first, NodeList rest) {
	NodeList nodeList = (NodeList) mmalloc(sizeof(struct NodeList));

	nodeList->first = first;
	nodeList->rest = rest;
	nodeList->empty = false;
	return (nodeList);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x18
popq %rdi
callq 0xb85c
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
andw $0x0, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: containsGrammarSymbol
Boolean containsGrammarSymbol(NodeList list) {
	NodeList ptr = list;

	while (ptr != NULL) {
		if (nodeContainsGrammarSymbol(ptr->first)) {
			return true;
		}
		ptr = ptr->rest;
	}
	return false;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rbx, %rbx
je 0x3908
movq (%rbx), %rdi
callq 0x3912
testw %ax, %ax
jne 0x390c
movq 0x8(%rbx), %rbx
jmp 0x38f0
xorl %eax, %eax
jmp 0x3910
movw $0xffff, %ax            # imm = 0xFFFF
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: nodeContainsGrammarSymbol
static Boolean nodeContainsGrammarSymbol(Node node) {
	while (node != NULL) {
		switch (node->nodeType) {
			case single:
				if (node->element.name->nameType != code && node->element.name->nameType != output) {
					return true;
				}
				break;
			case option:
				if (nodeContainsGrammarSymbol(node->element.sub)) {
					return true;
				}
				break;
			case sequence:
				if (nodeContainsGrammarSymbol(node->element.sub)) {
					return true;
				}
				break;
			case chain:
				if (nodeContainsGrammarSymbol(node->element.sub->element.sub) ||
					  nodeContainsGrammarSymbol(node->element.sub->next->element.sub)) {
					return true;
				}
			case alternative:
				if (containsGrammarSymbol(node->element.alternatives)) {
					return true;
				}
				break;
			case breakToken:
			case errorMessage:
				return true;
		}
		node = node->next;
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xc6e1(%rip), %r15      # 0x10004
testq %rbx, %rbx
je 0x3997
movl 0x4(%rbx), %eax
cmpq $0x6, %rax
ja 0x3991
movw $0xffff, %bp            # imm = 0xFFFF
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movq 0x18(%rbx), %rdi
callq 0x3912
jmp 0x397b
movq 0x18(%rbx), %r14
movq 0x18(%r14), %rdi
callq 0x3912
testw %ax, %ax
jne 0x3999
movq 0x28(%r14), %rax
movq 0x18(%rax), %rdi
callq 0x3912
testw %ax, %ax
je 0x3973
jmp 0x3999
movq 0x18(%rbx), %r14
movq %r14, %rdi
callq 0x38ec
testw %ax, %ax
je 0x3991
jmp 0x3999
movq 0x18(%rbx), %rax
movl 0x38(%rax), %eax
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0x3999
movq 0x28(%rbx), %rbx
jmp 0x3923
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: doIndent
void doIndent(int level) {
    fputc('\n', outputFile);
	while (level != 0) {
		fputs("	", outputFile);
		level--;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0x15115(%rip), %rsi     # 0x18ae8
pushq $0xa
popq %rdi
callq 0x3120
leaq 0xc7b5(%rip), %r14      # 0x10197
subl $0x1, %ebx
jb 0x39f8
movq 0x150fa(%rip), %rsi     # 0x18ae8
movq %r14, %rdi
callq 0x3110
jmp 0x39e2
addq $0x8, %rsp
popq %rbx
popq %r14
retq