LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/t_tree.c
// Function: start
NODE_T *start(NODE_T *root_node, int direct)
{
    NODE_T *curr_node = root_node->ptr[RIGHT];
    int con_direct = 1 - direct;

    while (!curr_node->thread[1 - direct]) {
        curr_node = curr_node->ptr[con_direct];
    }

    return curr_node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x1, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl $0x1, %ecx
subl -0xc(%rbp), %ecx
movslq %ecx, %rcx
cmpl $0x0, 0x18(%rax,%rcx,4)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x16d51
jmp 0x16d64
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0x16d32
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/t_tree.c
// Function: traverse
NODE_T *traverse(NODE_T *curr_node, int direct)
{
    if (curr_node->thread[direct]) {
        return curr_node->ptr[direct];
    }
    else {
        curr_node = curr_node->ptr[direct];
        int con_direct = 1 - direct;

        while (!curr_node->thread[1 - direct]) {
            curr_node = curr_node->ptr[con_direct];
        }

        return curr_node;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpl $0x0, 0x18(%rax,%rcx,4)
je 0x16d9d
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x16df3
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movl $0x1, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, %ecx
subl -0x14(%rbp), %ecx
movslq %ecx, %rcx
cmpl $0x0, 0x18(%rax,%rcx,4)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x16dd8
jmp 0x16deb
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0x16db9
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Nico01[P]obj2asm/utils.c
// Function: o_malloc
void *o_malloc(size_t size)
{
    char *result = calloc(1, size);

    if (result == NULL) {
        fprintf(stderr, "Out of memory!    [Crrraassshhhhh....]\n");
        exit(4);
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movl $0x1, %edi
callq 0x90f0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x16e87
movq 0x518c(%rip), %rax      # 0x1bff8
movq (%rax), %rdi
leaq 0x1dde(%rip), %rsi      # 0x18c54
movb $0x0, %al
callq 0x9120
movl $0x4, %edi
callq 0x91a0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/main.c
// Function: main
int main(int argc, char **argv) {
	eweb_getopt_t opt = { .init = 0, .error = 1 };
	int ch = -1;
	unsigned port = 8080;
	eweb_threading_mode_e mode = EWEB_TM_MULTI_THREADS_E;
	while ((ch = eweb_getopt(&opt, argc, argv, "hp:m:")) != -1) {
		switch (ch) {
		case 'h': return help(argv[0]); break;
		case 'p': port = atoi(opt.arg); break;
		case 'm': mode = resolve_mode(opt.arg); break;
		default:
			  help(argv[0]);
			  return EXIT_FAILURE;
		}
	}
	if (opt.index != argc) {
		fprintf(stderr, "Unexpected extra arguments\n");
		help(argv[0]);
		return EXIT_FAILURE;
	}
	eweb_os_t *w = eweb_os_new(NULL, mode);
	if (!w) {
		fprintf(stderr, "os allocation failed\n");
		return EXIT_FAILURE;
	}

	w->log(w, EWEB_OK, "hit CTRL-C to terminate");
	const int r = eweb_server(w, port, send_response) == EWEB_OK ? EXIT_SUCCESS : EXIT_FAILURE;
	eweb_os_delete(w);
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x2130
movl $0x1, -0x30(%rbp)
movl $0xffffffff, -0x3c(%rbp) # imm = 0xFFFFFFFF
movl $0x1f90, -0x40(%rbp)    # imm = 0x1F90
movl $0x3, -0x44(%rbp)
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq -0x38(%rbp), %rdi
leaq 0x4b60(%rip), %rcx      # 0x7004
callq 0x25f0
movl %eax, -0x3c(%rbp)
cmpl $-0x1, %eax
je 0x251f
movl -0x3c(%rbp), %eax
movl %eax, -0x58(%rbp)
subl $0x68, %eax
je 0x24d2
jmp 0x24be
movl -0x58(%rbp), %eax
subl $0x6d, %eax
je 0x24f4
jmp 0x24c8
movl -0x58(%rbp), %eax
subl $0x70, %eax
je 0x24e6
jmp 0x2502
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2940
movl %eax, -0x4(%rbp)
jmp 0x25dc
movq -0x38(%rbp), %rdi
callq 0x22d0
movl %eax, -0x40(%rbp)
jmp 0x251a
movq -0x38(%rbp), %rdi
callq 0x29e0
movl %eax, -0x44(%rbp)
jmp 0x251a
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2940
movl $0x1, -0x4(%rbp)
jmp 0x25dc
jmp 0x2492
movl -0x2c(%rbp), %eax
cmpl -0x8(%rbp), %eax
je 0x2557
movq 0x8ac2(%rip), %rax      # 0xaff0
movq (%rax), %rdi
leaq 0x4ad2(%rip), %rsi      # 0x700a
movb $0x0, %al
callq 0x21b0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2940
movl $0x1, -0x4(%rbp)
jmp 0x25dc
movl -0x44(%rbp), %esi
xorl %eax, %eax
movl %eax, %edi
callq 0x6270
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x258f
movq 0x8a7b(%rip), %rax      # 0xaff0
movq (%rax), %rdi
leaq 0x4aa7(%rip), %rsi      # 0x7026
movb $0x0, %al
callq 0x21b0
movl $0x1, -0x4(%rbp)
jmp 0x25dc
movq -0x50(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x50(%rbp), %rdi
xorl %esi, %esi
leaq 0x4a98(%rip), %rdx      # 0x703c
movb $0x0, %al
callq *%rcx
movq -0x50(%rbp), %rdi
movl -0x40(%rbp), %esi
leaq 0x4ea(%rip), %rdx       # 0x2aa0
callq 0x4bc0
movl %eax, %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x54(%rbp)
movq -0x50(%rbp), %rdi
callq 0x63c0
movl -0x54(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/main.c
// Function: help
static int help(const char *arg0) {
	assert(arg0);
	FILE *output = stdout;
	fprintf(output, "Usage: %s [-h] [-p port-number] [-m mode]\n", arg0);
	static const char *m = "\n\
eweb - an embeddable web-server\n\n\
git:       https://github.com/hower/eweb\n\
license:   MIT\n\
copyright: 2015-2016 http://www.codehosting.net\n\
           2018      Richard James Howe\n\
           (see project repo for more details)\n\
\n\
Options:\n\n\
\t-h,        Print this help message and exit successfully.\n\
\t-p number, Set server port number for server to listen to.\n\
\t-m mode,   Set server thread management mode.\n\
\n\
This is a demonstration program for a tiny, embeddable web-server. It\n\
is not a fully featured web-server but is designed to be tiny and\n\
most importantly portable with platform dependent functionality hidden\n\
within the library.\n\
\n\
Different methods for coping with simultaneous connections can be\n\
selected from with the '-m' flag. Valid modes are 'thread', 'fork'\n\
and 'single'. Your platform may not support all modes.\n\
\n";
	fputs(m, output);
	fprintf(output, "The default port the server listens on is %d.\n\n", DEFAULT_PORT);
	fprintf(output, "This program returns %d on success, and %d on failure.\n\n", EXIT_SUCCESS, EXIT_FAILURE);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2955
jmp 0x2974
leaq 0x478e(%rip), %rdi      # 0x70ea
leaq 0x46f5(%rip), %rsi      # 0x7058
movl $0xf4, %edx
leaq 0x4780(%rip), %rcx      # 0x70ef
callq 0x2100
movq 0x8655(%rip), %rax      # 0xafd0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x4775(%rip), %rsi      # 0x7106
movb $0x0, %al
callq 0x21b0
movq 0x8821(%rip), %rdi      # 0xb1c0
movq -0x10(%rbp), %rsi
callq 0x2110
movq -0x10(%rbp), %rdi
leaq 0x4ab3(%rip), %rsi      # 0x7466
movl $0x1f90, %edx           # imm = 0x1F90
movb $0x0, %al
callq 0x21b0
movq -0x10(%rbp), %rdi
leaq 0x4acc(%rip), %rsi      # 0x7496
xorl %edx, %edx
movl $0x1, %ecx
movb $0x0, %al
callq 0x21b0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/main.c
// Function: resolve_mode
static eweb_threading_mode_e resolve_mode(const char *ms) {
	assert(ms);
	if (!strcmp(ms, "thread"))
		return EWEB_TM_MULTI_THREADS_E;
	if (!strcmp(ms, "fork"))
		return EWEB_TM_MULTI_PROCESS_E;
	if (!strcmp(ms, "single"))
		return EWEB_TM_SINGLE_THREAD_E;
	fprintf(stdout, "unknown mode: %s (selecting default)\n", ms);
	return 0; // auto
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x29f5
jmp 0x2a14
leaq 0x4ad3(%rip), %rdi      # 0x74cf
leaq 0x4655(%rip), %rsi      # 0x7058
movl $0x114, %edx            # imm = 0x114
leaq 0x4ac3(%rip), %rcx      # 0x74d2
callq 0x2100
movq -0x10(%rbp), %rdi
leaq 0x5c33(%rip), %rsi      # 0x8652
callq 0x2190
cmpl $0x0, %eax
jne 0x2a32
movl $0x3, -0x4(%rbp)
jmp 0x2a91
movq -0x10(%rbp), %rdi
leaq 0x4ac6(%rip), %rsi      # 0x7503
callq 0x2190
cmpl $0x0, %eax
jne 0x2a50
movl $0x2, -0x4(%rbp)
jmp 0x2a91
movq -0x10(%rbp), %rdi
leaq 0x4aad(%rip), %rsi      # 0x7508
callq 0x2190
cmpl $0x0, %eax
jne 0x2a6e
movl $0x1, -0x4(%rbp)
jmp 0x2a91
movq 0x855b(%rip), %rax      # 0xafd0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x4a8c(%rip), %rsi      # 0x750f
movb $0x0, %al
callq 0x21b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/main.c
// Function: send_response
static int send_response(eweb_os_t *w, eweb_os_hit_args_t *args, const char *path, const char *request_body, http_verb type) {
	assert(w);
	assert(path);
	UNUSED(type);
	const size_t path_length = strlen(path);
	if (path_length > 3 && !strncmp(&path[path_length - 3], "api", 3))
		return send_api_response(w, args, path, request_body);
	if (path_length == 0)
		return send_file_response(w, args, "index.html", request_body, 10);
	return send_file_response(w, args, path, request_body, path_length);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2ac5
jmp 0x2ae4
leaq 0x4a69(%rip), %rdi      # 0x7535
leaq 0x4585(%rip), %rsi      # 0x7058
movl $0xe8, %edx
leaq 0x4a58(%rip), %rcx      # 0x7537
callq 0x2100
cmpq $0x0, -0x20(%rbp)
je 0x2aed
jmp 0x2b0c
leaq 0x4a9f(%rip), %rdi      # 0x7593
leaq 0x455d(%rip), %rsi      # 0x7058
movl $0xe9, %edx
leaq 0x4a30(%rip), %rcx      # 0x7537
callq 0x2100
movq -0x20(%rbp), %rdi
callq 0x20b0
movq %rax, -0x38(%rbp)
cmpq $0x3, -0x38(%rbp)
jbe 0x2b5f
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rax
subq $0x3, %rax
addq %rax, %rdi
leaq 0x4a62(%rip), %rsi      # 0x7598
movl $0x3, %edx
callq 0x2070
cmpl $0x0, %eax
jne 0x2b5f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x2bb0
movl %eax, -0x4(%rbp)
jmp 0x2ba5
cmpq $0x0, -0x38(%rbp)
jne 0x2b89
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rcx
leaq 0x4a23(%rip), %rdx      # 0x759c
movl $0xa, %r8d
callq 0x2ce0
movl %eax, -0x4(%rbp)
jmp 0x2ba5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %r8
callq 0x2ce0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/main.c
// Function: send_api_response
static int send_api_response(eweb_os_t *w, eweb_os_hit_args_t *args, const char *path, const char *request_body) {
	assert(w);
	UNUSED(request_body);
	if (args->form_value_counter == 1 && !strncmp(eweb_form_name(args, 0), "counter", strlen(eweb_form_name(args, 0)))) {
		char response[4] = { 0 };
		int c = atoi(eweb_form_value(args, 0));
		if (c > 99 || c < 0)
			c = 0;
		snprintf(response, sizeof response, "%d", ++c);
		return eweb_ok_200(w, args, "\nContent-Type: text/plain", response, path);
	}
	return eweb_forbidden_403(w, args, "Bad request");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2bd1
jmp 0x2bf0
leaq 0x495d(%rip), %rdi      # 0x7535
leaq 0x4479(%rip), %rsi      # 0x7058
movl $0x83, %edx
leaq 0x49bc(%rip), %rcx      # 0x75a7
callq 0x2100
movq -0x18(%rbp), %rax
cmpq $0x1, 0x30(%rax)
jne 0x2cb9
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5210
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5210
movq %rax, %rdi
callq 0x20b0
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x49c9(%rip), %rsi      # 0x75fc
callq 0x2070
cmpl $0x0, %eax
jne 0x2cb9
leaq -0x2c(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x2130
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5190
movq %rax, %rdi
callq 0x22d0
movl %eax, -0x30(%rbp)
cmpl $0x63, -0x30(%rbp)
jg 0x2c71
cmpl $0x0, -0x30(%rbp)
jge 0x2c78
movl $0x0, -0x30(%rbp)
leaq -0x2c(%rbp), %rdi
movl -0x30(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x30(%rbp)
movl $0x4, %esi
leaq 0x59ad(%rip), %rdx      # 0x863e
movb $0x0, %al
callq 0x20f0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x2c(%rbp), %rcx
movq -0x20(%rbp), %r8
leaq 0x4955(%rip), %rdx      # 0x7604
callq 0x3960
movl %eax, -0x4(%rbp)
jmp 0x2cd0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x4956(%rip), %rdx      # 0x761e
callq 0x37e0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/main.c
// Function: find_file_type_by_file_extension
static const char *find_file_type_by_file_extension(const char *path, size_t path_length) {
	assert(path);
	static const struct {
		char *ext;
		char *filetype;
	} extensions[] = {
		{ "gif",   "image/gif" },
		{ "jpg",   "image/jpeg" },
		{ "jpeg",  "image/jpeg" },
		{ "png",   "image/png" },
		{ "ico",   "image/x-icon" },
		{ "zip",   "application/zip" },
		{ "gz",    "application/gzip" },
		{ "tar",   "application/x-tar" },
		{ "htm",   "text/html" },
		{ "html",  "text/html" },
		{ "js",    "text/javascript" },
		{ "txt",   "text/plain" },
		{ "css",   "text/css" },
		{ "map",   "application/json" },
		{ "woff",  "application/font-woff" },
		{ "woff2", "application/font-woff2" },
		{ "ttf",   "application/font-sfnt" },
		{ "svg",   "image/svg+xml" },
		{ "eot",   "application/vnd.ms-fontobject" },
		{ "mp4",   "video/mp4" },
		{ NULL,    NULL }
	};
	const char *content_type = NULL;
	for (size_t i = 0; extensions[i].ext != 0; i++) {
		const size_t len = strlen(extensions[i].ext);
		if (len > path_length)
			continue;
		if (!strncmp(&path[path_length - len], extensions[i].ext, len)) {
			content_type = extensions[i].filetype;
			break;
		}
	}
	return content_type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x31e9
jmp 0x3208
leaq 0x43a3(%rip), %rdi      # 0x7593
leaq 0x3e61(%rip), %rsi      # 0x7058
movl $0x59, %edx
leaq 0x45da(%rip), %rcx      # 0x77dd
callq 0x2100
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rcx
leaq 0x79ad(%rip), %rax      # 0xabd0
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x32bf
movq -0x20(%rbp), %rcx
leaq 0x7991(%rip), %rax      # 0xabd0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x20b0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jbe 0x325e
jmp 0x32ae
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
subq -0x28(%rbp), %rax
addq %rax, %rdi
movq -0x20(%rbp), %rcx
leaq 0x7958(%rip), %rax      # 0xabd0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq -0x28(%rbp), %rdx
callq 0x2070
cmpl $0x0, %eax
jne 0x32ac
movq -0x20(%rbp), %rcx
leaq 0x7935(%rip), %rax      # 0xabd0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x32bf
jmp 0x32ae
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3218
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/eweb.c
// Function: eweb_write_header
int eweb_write_header(eweb_os_t *w, const int socket_fd, const char *head, long content_len) {
	assert(w);
	assert(head);
	int r = EWEB_OK;
	char cl[64+1] = { 0 };
	string_t *header = string_new(w, 255);
	if (!header)
		goto fail;
	if (!string_add(w, header, head))
		goto fail;
	if (!string_add(w, header, "\nContent-Length: "))
		goto fail;
	snprintf(cl, sizeof(cl), "%ld", content_len);
	if (!string_add(w, header, cl))
		goto fail;
	if (!string_add(w, header, "\r\n\r\n"))
		goto fail;
	const long wlen = header->used_bytes - 1;
	if (w->write(w, socket_fd, string_chars(w, header), wlen) != wlen)
		r = EWEB_ERROR;
	string_free(w, header);
	return r;
fail:
	string_free(w, header);
	return EWEB_ERROR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x32f3
jmp 0x3312
leaq 0x423b(%rip), %rdi      # 0x7535
leaq 0x4647(%rip), %rsi      # 0x7948
movl $0x80, %edx
leaq 0x4642(%rip), %rcx      # 0x794f
callq 0x2100
cmpq $0x0, -0x20(%rbp)
je 0x331b
jmp 0x333a
leaq 0x466f(%rip), %rdi      # 0x7991
leaq 0x461f(%rip), %rsi      # 0x7948
movl $0x81, %edx
leaq 0x461a(%rip), %rcx      # 0x794f
callq 0x2100
movl $0x0, -0x2c(%rbp)
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x41, %edx
callq 0x2130
movq -0x10(%rbp), %rdi
movl $0xff, %esi
callq 0x34a0
movq %rax, -0x78(%rbp)
cmpq $0x0, -0x78(%rbp)
jne 0x336f
jmp 0x347c
movq -0x10(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3540
cmpq $0x0, %rax
jne 0x338b
jmp 0x347c
movq -0x10(%rbp), %rdi
movq -0x78(%rbp), %rsi
leaq 0x45fc(%rip), %rdx      # 0x7996
callq 0x3540
cmpq $0x0, %rax
jne 0x33aa
jmp 0x347c
leaq -0x70(%rbp), %rdi
movq -0x28(%rbp), %rcx
movl $0x41, %esi
leaq 0x45ea(%rip), %rdx      # 0x79a8
movb $0x0, %al
callq 0x20f0
movq -0x10(%rbp), %rdi
movq -0x78(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x3540
cmpq $0x0, %rax
jne 0x33e1
jmp 0x347c
movq -0x10(%rbp), %rdi
movq -0x78(%rbp), %rsi
leaq 0x45bc(%rip), %rdx      # 0x79ac
callq 0x3540
cmpq $0x0, %rax
jne 0x33fd
jmp 0x347c
movq -0x78(%rbp), %rax
movq 0x10(%rax), %rax
subq $0x1, %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x3610
movq -0x98(%rbp), %rdi
movl -0x8c(%rbp), %esi
movq %rax, %rdx
movq -0x88(%rbp), %rax
movq -0x80(%rbp), %rcx
callq *%rax
cmpq -0x80(%rbp), %rax
je 0x3467
movl $0x1, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x3660
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3490
movq -0x10(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x3660
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/eweb.c
// Function: string_new
string_t *string_new(eweb_os_t *w, const long increments) {
	string_t *s = eweb_malloc_or_die(w, sizeof(*s));
	if (!s)
		goto fail;
	if (bcreate(w, s, 1, increments) != EWEB_OK)
		goto fail;
	if (badd(w, s, "\0", 1) != EWEB_OK)
		goto fail;
	return s;
fail:
	string_free(w, s);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x28, %esi
callq 0x45b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x34cb
jmp 0x3512
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rcx
movl $0x1, %edx
callq 0x53f0
cmpl $0x0, %eax
je 0x34e8
jmp 0x3512
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x4ec9(%rip), %rdx      # 0x83c0
movl $0x1, %ecx
callq 0x54e0
cmpl $0x0, %eax
je 0x3508
jmp 0x3512
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3527
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3660
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/eweb.c
// Function: string_add
string_t *string_add(eweb_os_t *w, string_t * s, const char *char_array) {
	assert(s);
	assert(char_array);
	s->used_bytes--;
	if (badd(w, s, char_array, strlen(char_array) + 1) != EWEB_OK)
		return NULL;
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x355d
jmp 0x357c
leaq 0x4f62(%rip), %rdi      # 0x84c6
leaq 0x43dd(%rip), %rsi      # 0x7948
movl $0x241, %edx            # imm = 0x241
leaq 0x4bf9(%rip), %rcx      # 0x8170
callq 0x2100
cmpq $0x0, -0x20(%rbp)
je 0x3585
jmp 0x35a4
leaq 0x4c20(%rip), %rdi      # 0x81ac
leaq 0x43b5(%rip), %rsi      # 0x7948
movl $0x242, %edx            # imm = 0x242
leaq 0x4bd1(%rip), %rcx      # 0x8170
callq 0x2100
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x20b0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
addq $0x1, %rcx
callq 0x54e0
cmpl $0x0, %eax
je 0x35fc
movq $0x0, -0x8(%rbp)
jmp 0x3604
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/eweb.c
// Function: eweb_write_html
int eweb_write_html(eweb_os_t *w, const int socket_fd, const char *head, const char *html) {
	assert(w);
	assert(head);
	assert(html);
	const long r = eweb_write_header(w, socket_fd, head, strlen(html));
	if (r != EWEB_OK)
		return r;
	const long wlen = strlen(html);
	return w->write(w, socket_fd, html, wlen) == wlen ? EWEB_OK : EWEB_ERROR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x36e0
jmp 0x36ff
leaq 0x3e4e(%rip), %rdi      # 0x7535
leaq 0x425a(%rip), %rsi      # 0x7948
movl $0x9b, %edx
leaq 0x42b7(%rip), %rcx      # 0x79b1
callq 0x2100
cmpq $0x0, -0x20(%rbp)
je 0x3708
jmp 0x3727
leaq 0x4282(%rip), %rdi      # 0x7991
leaq 0x4232(%rip), %rsi      # 0x7948
movl $0x9c, %edx
leaq 0x428f(%rip), %rcx      # 0x79b1
callq 0x2100
cmpq $0x0, -0x28(%rbp)
je 0x3730
jmp 0x374f
leaq 0x3e6b(%rip), %rdi      # 0x75a2
leaq 0x420a(%rip), %rsi      # 0x7948
movl $0x9d, %edx
leaq 0x4267(%rip), %rcx      # 0x79b1
callq 0x2100
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0x20b0
movq -0x50(%rbp), %rdi
movl -0x44(%rbp), %esi
movq -0x40(%rbp), %rdx
movq %rax, %rcx
callq 0x32d0
cltq
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x3797
movq -0x30(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x37d4
movq -0x28(%rbp), %rdi
callq 0x20b0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x28(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq *%rax
movq %rax, %rdx
movq -0x38(%rbp), %rsi
movl $0x1, %eax
xorl %ecx, %ecx
cmpq %rsi, %rdx
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/eweb.c
// Function: eweb_forbidden_403
int eweb_forbidden_403(eweb_os_t *w, eweb_os_hit_args_t *args, const char *info) {
	assert(args);
	assert(info);
	const int r = eweb_write_html(w, args->socketfd,
		"HTTP/1.1 403 Forbidden\nServer: eweb\nConnection: close\nContent-Type: text/html",
		"<!DOCTYPE html>\n"
		"<html><head>\n<title>403 Forbidden</title>\n"
		"</head><body>\n<h1>Forbidden</h1>\nThe requested URL, file type or operation is not allowed.\n</body>"
		"</html>");
	w->log(w, EWEB_OK, "403 FORBIDDEN: %s/%d", info, args->socketfd);
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x37fd
jmp 0x381c
leaq 0x41f5(%rip), %rdi      # 0x79f9
leaq 0x413d(%rip), %rsi      # 0x7948
movl $0xa6, %edx
leaq 0x41e7(%rip), %rcx      # 0x79fe
callq 0x2100
cmpq $0x0, -0x18(%rbp)
je 0x3825
jmp 0x3844
leaq 0x421a(%rip), %rdi      # 0x7a46
leaq 0x4115(%rip), %rsi      # 0x7948
movl $0xa7, %edx
leaq 0x41bf(%rip), %rcx      # 0x79fe
callq 0x2100
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x40(%rax), %esi
leaq 0x41f5(%rip), %rdx      # 0x7a4b
leaq 0x423c(%rip), %rcx      # 0x7a99
callq 0x36c0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %r9
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movl 0x40(%rax), %r8d
xorl %esi, %esi
leaq 0x42b7(%rip), %rdx      # 0x7b3d
movb $0x0, %al
callq *%r9
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/eweb.c
// Function: eweb_not_found_404
int eweb_not_found_404(eweb_os_t *w, eweb_os_hit_args_t *args, const char *info) {
	assert(args);
	assert(info);
	const int r = eweb_write_html(w, args->socketfd,
		"HTTP/1.1 404 Not Found\nServer: eweb\nConnection: close\nContent-Type: text/html",
		"<!DOCTYPE html>\n"
		"<html><head>\n<title>404 Not Found</title>\n"
		"</head><body>\n<h1>Not Found</h1>\nThe requested URL was not found on this server.\n</body></html>");
	w->log(w, EWEB_OK, "404 NOT FOUND: %s/%d", info, args->socketfd);
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x38bd
jmp 0x38dc
leaq 0x4135(%rip), %rdi      # 0x79f9
leaq 0x407d(%rip), %rsi      # 0x7948
movl $0xb3, %edx
leaq 0x427b(%rip), %rcx      # 0x7b52
callq 0x2100
cmpq $0x0, -0x18(%rbp)
je 0x38e5
jmp 0x3904
leaq 0x415a(%rip), %rdi      # 0x7a46
leaq 0x4055(%rip), %rsi      # 0x7948
movl $0xb4, %edx
leaq 0x4253(%rip), %rcx      # 0x7b52
callq 0x2100
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x40(%rax), %esi
leaq 0x4284(%rip), %rdx      # 0x7b9a
leaq 0x42cb(%rip), %rcx      # 0x7be8
callq 0x36c0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %r9
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movl 0x40(%rax), %r8d
xorl %esi, %esi
leaq 0x433c(%rip), %rdx      # 0x7c82
movb $0x0, %al
callq *%r9
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/eweb.c
// Function: eweb_ok_200
int eweb_ok_200(eweb_os_t *w, eweb_os_hit_args_t *args, const char *custom_headers, const char *html, const char *path) {
	assert(w);
	string_t *headers = string_new(w, 255);
	if (!headers)
		goto fail;
	if (!string_add(w, headers, "HTTP/1.1 200 OK\nServer: eweb\nCache-Control: no-cache\nPragma: no-cache"))
		goto fail;
	if (!custom_headers)
		if (!string_add(w, headers, custom_headers))
			goto fail;
	eweb_write_html(w, args->socketfd, string_chars(w, headers), html);
	string_free(w, headers);
	w->log(w, EWEB_OK, "200 OK: %s/%d", path, args->socketfd);
	return EWEB_OK;
fail:
	string_free(w, headers);
	w->log(w, EWEB_ERROR, "Failed to serve (200)");
	return EWEB_ERROR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3985
jmp 0x39a4
leaq 0x3ba9(%rip), %rdi      # 0x7535
leaq 0x3fb5(%rip), %rsi      # 0x7948
movl $0xbf, %edx
leaq 0x42f8(%rip), %rcx      # 0x7c97
callq 0x2100
movq -0x10(%rbp), %rdi
movl $0xff, %esi
callq 0x34a0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x39c2
jmp 0x3a71
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq 0x4323(%rip), %rdx      # 0x7cf4
callq 0x3540
cmpq $0x0, %rax
jne 0x39e1
jmp 0x3a71
cmpq $0x0, -0x20(%rbp)
jne 0x3a03
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3540
cmpq $0x0, %rax
jne 0x3a01
jmp 0x3a71
jmp 0x3a03
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x3610
movq -0x48(%rbp), %rdi
movl -0x3c(%rbp), %esi
movq %rax, %rdx
movq -0x28(%rbp), %rcx
callq 0x36c0
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x3660
movq -0x10(%rbp), %rax
movq 0x50(%rax), %r9
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movl 0x40(%rax), %r8d
xorl %esi, %esi
leaq 0x42d7(%rip), %rdx      # 0x7d3a
movb $0x0, %al
callq *%r9
movl $0x0, -0x4(%rbp)
jmp 0x3aa1
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x3660
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x42b2(%rip), %rdx      # 0x7d48
movb $0x0, %al
callq *%rcx
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/eweb.c
// Function: eweb_get_body_start
static long eweb_get_body_start(const char *request) { /* return the starting index of the request body, or end of the HTTP headers */
	assert(request);
	const char *ptr = strstr(request, "\r\n\r\n"); // !!
	return !ptr ? -1 : (ptr + 4) - request;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4485
jmp 0x44a4
leaq 0x3196(%rip), %rdi      # 0x7622
leaq 0x34b5(%rip), %rsi      # 0x7948
movl $0xea, %edx
leaq 0x3d44(%rip), %rcx      # 0x81e3
callq 0x2100
movq -0x8(%rbp), %rdi
leaq 0x34fd(%rip), %rsi      # 0x79ac
callq 0x2320
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x44cc
movq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x44df
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/eweb.c
// Function: eweb_finish_hit
static int eweb_finish_hit(eweb_os_t *w, eweb_os_hit_args_t *args, int exit_code) {
	assert(args);
	UNUSED(exit_code);
	w->close(w, args->socketfd);
	string_free(w, args->buffer);
	eweb_free(w, args->headers);
	eweb_clear_form_values(w, args);
	eweb_free(w, args->content_type);
	eweb_free(w, args);
	w->thread_exit(w, exit_code);
	return EWEB_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x450c
jmp 0x452b
leaq 0x34e6(%rip), %rdi      # 0x79f9
leaq 0x342e(%rip), %rsi      # 0x7948
movl $0x72, %edx
leaq 0x3ce4(%rip), %rcx      # 0x820a
callq 0x2100
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl 0x40(%rcx), %esi
callq *%rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3660
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x5130
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5640
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x5130
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5130
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq *%rax
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/eweb.c
// Function: eweb_malloc_or_die
void *eweb_malloc_or_die(eweb_os_t *w, size_t num_bytes) {
	assert(w);
	assert(!(w->allocation_error));
	void *mem = w->allocator.malloc(w->allocator.arena, num_bytes);
	if (!mem) {
		w->allocation_error = 1;
		w->log(w, EWEB_ERROR, "malloc of %zu bytes failed", num_bytes);
		w->exit(w, 1);
	}
	return mem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x45c9
jmp 0x45e8
leaq 0x2f65(%rip), %rdi      # 0x7535
leaq 0x3371(%rip), %rsi      # 0x7948
movl $0x1db, %edx            # imm = 0x1DB
leaq 0x3a2a(%rip), %rcx      # 0x800d
callq 0x2100
movq -0x8(%rbp), %rax
movb 0x98(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x45fe
jmp 0x461d
leaq 0x3a36(%rip), %rdi      # 0x803b
leaq 0x333c(%rip), %rsi      # 0x7948
movl $0x1dc, %edx            # imm = 0x1DC
leaq 0x39f5(%rip), %rcx      # 0x800d
callq 0x2100
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4687
movq -0x8(%rbp), %rax
movb 0x98(%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, 0x98(%rax)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %r8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x1, %esi
leaq 0x39e3(%rip), %rdx      # 0x8052
movb $0x0, %al
callq *%r8
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq *%rax
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/eweb.c
// Function: eweb_request_type
static http_verb eweb_request_type(const char *request) {
	assert(request);
	if (strncmp(request, "GET ", 4) == 0 || strncmp(request, "get ", 4) == 0)
		return EWEB_RT_HTTP_GET_E;
	if (strncmp(request, "POST ", 5) == 0 || strncmp(request, "post ", 5) == 0)
		return EWEB_RT_HTTP_POST_E;
	return EWEB_RT_HTTP_NOT_SUPPORTED_E;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x46b5
jmp 0x46d4
leaq 0x2f66(%rip), %rdi      # 0x7622
leaq 0x3285(%rip), %rsi      # 0x7948
movl $0xf0, %edx
leaq 0x3bb5(%rip), %rcx      # 0x8284
callq 0x2100
movq -0x10(%rbp), %rdi
leaq 0x3bcf(%rip), %rsi      # 0x82ae
movl $0x4, %edx
callq 0x2070
cmpl $0x0, %eax
je 0x4708
movq -0x10(%rbp), %rdi
leaq 0x3bba(%rip), %rsi      # 0x82b3
movl $0x4, %edx
callq 0x2070
cmpl $0x0, %eax
jne 0x4711
movl $0x65, -0x4(%rbp)
jmp 0x4755
movq -0x10(%rbp), %rdi
leaq 0x3b9c(%rip), %rsi      # 0x82b8
movl $0x5, %edx
callq 0x2070
cmpl $0x0, %eax
je 0x4745
movq -0x10(%rbp), %rdi
leaq 0x3b88(%rip), %rsi      # 0x82be
movl $0x5, %edx
callq 0x2070
cmpl $0x0, %eax
jne 0x474e
movl $0x66, -0x4(%rbp)
jmp 0x4755
movl $0x64, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/eweb.c
// Function: eweb_calloc_or_die
void *eweb_calloc_or_die(eweb_os_t *w, const size_t num, const size_t size) {
	assert(w);
	assert(!(w->allocation_error));
	void *mem = w->allocator.malloc(w->allocator.arena, num * size); /**@todo check for overflow! */
	if (!mem) {
		w->allocation_error = 1;
		w->log(w, EWEB_ERROR, "calloc failed [%zu x %zu] bytes", num, size);
		w->exit(w, 1);
	}
	memset(mem, 0, num * size);
	return mem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4e0d
jmp 0x4e2c
leaq 0x2721(%rip), %rdi      # 0x7535
leaq 0x2b2d(%rip), %rsi      # 0x7948
movl $0x1f3, %edx            # imm = 0x1F3
leaq 0x3299(%rip), %rcx      # 0x80c0
callq 0x2100
movq -0x8(%rbp), %rax
movb 0x98(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x4e42
jmp 0x4e61
leaq 0x31f2(%rip), %rdi      # 0x803b
leaq 0x2af8(%rip), %rsi      # 0x7948
movl $0x1f4, %edx            # imm = 0x1F4
leaq 0x3264(%rip), %rcx      # 0x80c0
callq 0x2100
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq -0x10(%rbp), %rsi
imulq -0x18(%rbp), %rsi
callq *%rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4ed4
movq -0x8(%rbp), %rax
movb 0x98(%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, 0x98(%rax)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %r9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
movl $0x1, %esi
leaq 0x3246(%rip), %rdx      # 0x8102
movb $0x0, %al
callq *%r9
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq *%rax
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rdx
imulq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x2130
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/eweb.c
// Function: eweb_url_decode
int eweb_url_decode(eweb_os_t *w, char *s) {
	assert(s);
	const size_t len = strlen(s);
	char *s_copy = eweb_calloc_or_die(w, 1, len + 1);
	if (!s_copy)
		return EWEB_ERROR;
	char *ptr = s_copy;

	for (size_t i = 0; i < len; i++) {
		if (s[i] == '+') {
			*ptr++ = ' ';
		} else if ((s[i] != '%') || (!isxdigit(s[i + 1]) || !isxdigit(s[i + 2]))) {
			*ptr++ = s[i];
		} else {
			*ptr++ = ((eweb_decode_char(s[i + 1]) << 4) | eweb_decode_char(s[i + 2]));
			i += 2;
		}
	}
	*ptr = 0;
	memcpy(s, s_copy, len + 1);
	eweb_free(w, s_copy);
	return EWEB_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4f19
jmp 0x4f38
leaq 0x35a6(%rip), %rdi      # 0x84c6
leaq 0x2a21(%rip), %rsi      # 0x7948
movl $0x1a2, %edx            # imm = 0x1A2
leaq 0x3042(%rip), %rcx      # 0x7f75
callq 0x2100
movq -0x18(%rbp), %rdi
callq 0x20b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
addq $0x1, %rdx
movl $0x1, %esi
callq 0x4df0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4f72
movl $0x1, -0x4(%rbp)
jmp 0x50ce
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x509e
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2b, %eax
jne 0x4fb8
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movb $0x20, (%rax)
jmp 0x508b
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x25, %eax
jne 0x5015
callq 0x2330
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rdx
movsbl 0x1(%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
je 0x5015
callq 0x2330
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rdx
movsbl 0x2(%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
jne 0x5033
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movb (%rax,%rcx), %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
jmp 0x5089
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movsbl 0x1(%rax,%rcx), %edi
callq 0x50e0
movsbl %al, %eax
shll $0x4, %eax
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movsbl 0x2(%rax,%rcx), %edi
callq 0x50e0
movb %al, %cl
movl -0x3c(%rbp), %eax
movsbl %cl, %ecx
orl %ecx, %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
movq -0x38(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x38(%rbp)
jmp 0x508b
jmp 0x508d
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x4f82
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x1, %rdx
callq 0x21d0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x5130
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/eweb.c
// Function: eweb_free
void eweb_free(eweb_os_t *w, void *ptr) {
	assert(w);
	if (!ptr)
		return;
	w->allocator.free(w->allocator.arena, ptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5149
jmp 0x5168
leaq 0x23e5(%rip), %rdi      # 0x7535
leaq 0x27f1(%rip), %rsi      # 0x7948
movl $0x200, %edx            # imm = 0x200
leaq 0x2fbf(%rip), %rcx      # 0x8122
callq 0x2100
cmpq $0x0, -0x10(%rbp)
jne 0x5171
jmp 0x5187
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/eweb.c
// Function: eweb_form_value
char *eweb_form_value(eweb_os_hit_args_t *args, const long i) {
	assert(args);
	if (i >= args->form_value_counter || i < 0)
		return NULL;
	return args->form_values[i].value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x51a9
jmp 0x51c8
leaq 0x2849(%rip), %rdi      # 0x79f9
leaq 0x2791(%rip), %rsi      # 0x7948
movl $0x1bf, %edx            # imm = 0x1BF
leaq 0x2ddb(%rip), %rcx      # 0x7f9e
callq 0x2100
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jge 0x51dd
cmpq $0x0, -0x18(%rbp)
jge 0x51e7
movq $0x0, -0x8(%rbp)
jmp 0x51ff
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/eweb.c
// Function: eweb_form_name
char *eweb_form_name(eweb_os_hit_args_t *args, const long i) {
	assert(args);
	if (i >= args->form_value_counter || i < 0)
		return NULL;
	return args->form_values[i].name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5229
jmp 0x5248
leaq 0x27c9(%rip), %rdi      # 0x79f9
leaq 0x2711(%rip), %rsi      # 0x7948
movl $0x1c6, %edx            # imm = 0x1C6
leaq 0x2d93(%rip), %rcx      # 0x7fd6
callq 0x2100
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jge 0x525d
cmpq $0x0, -0x18(%rbp)
jge 0x5267
movq $0x0, -0x8(%rbp)
jmp 0x527e
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/eweb.c
// Function: eweb_realloc_or_die
void *eweb_realloc_or_die(eweb_os_t *w, void *ptr, size_t num_bytes) {
	assert(w);
	assert(!(w->allocation_error));
	void *mem = w->allocator.realloc(w->allocator.arena, ptr, num_bytes);
	if (!mem) {
		w->allocation_error = 1;
		w->log(w, EWEB_ERROR, "realloc of %zu bytes failed", num_bytes);
		w->exit(w, 1);
	}
	return mem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x52ad
jmp 0x52cc
leaq 0x2281(%rip), %rdi      # 0x7535
leaq 0x268d(%rip), %rsi      # 0x7948
movl $0x1e7, %edx            # imm = 0x1E7
leaq 0x2da6(%rip), %rcx      # 0x806d
callq 0x2100
movq -0x8(%rbp), %rax
movb 0x98(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x52e2
jmp 0x5301
leaq 0x2d52(%rip), %rdi      # 0x803b
leaq 0x2658(%rip), %rsi      # 0x7948
movl $0x1e8, %edx            # imm = 0x1E8
leaq 0x2d71(%rip), %rcx      # 0x806d
callq 0x2100
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5370
movq -0x8(%rbp), %rax
movb 0x98(%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, 0x98(%rax)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %r8
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0x1, %esi
leaq 0x2d4c(%rip), %rdx      # 0x80a4
movb $0x0, %al
callq *%r8
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq *%rax
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/eweb.c
// Function: bfree
static void bfree(eweb_os_t *w, block_t *b) {
	assert(w);
	if (!b)
		return;
	eweb_free(w, b->ptr);
	b->used_bytes = 0;
	b->alloc_bytes = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5399
jmp 0x53b8
leaq 0x2195(%rip), %rdi      # 0x7535
leaq 0x25a1(%rip), %rsi      # 0x7948
movl $0x224, %edx            # imm = 0x224
leaq 0x2f6e(%rip), %rcx      # 0x8321
callq 0x2100
cmpq $0x0, -0x10(%rbp)
jne 0x53c1
jmp 0x53e9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x5130
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/eweb.c
// Function: bcreate
static inline int bcreate(eweb_os_t *w, block_t *b, const long elem_size, const long inc) {
	assert(w);
	assert(b);
	b->elem_bytes = elem_size;
	b->chunk_size = inc;
	if (!(b->ptr = eweb_calloc_or_die(w, b->chunk_size, b->elem_bytes)))
		return EWEB_ERROR;
	b->alloc_bytes = b->chunk_size * b->elem_bytes;
	b->used_bytes = 0;
	return EWEB_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5411
jmp 0x5430
leaq 0x211d(%rip), %rdi      # 0x7535
leaq 0x2529(%rip), %rsi      # 0x7948
movl $0x207, %edx            # imm = 0x207
leaq 0x2f19(%rip), %rcx      # 0x8344
callq 0x2100
cmpq $0x0, -0x18(%rbp)
je 0x5439
jmp 0x5458
leaq 0x2313(%rip), %rdi      # 0x7753
leaq 0x2501(%rip), %rsi      # 0x7948
movl $0x208, %edx            # imm = 0x208
leaq 0x2ef1(%rip), %rcx      # 0x8344
callq 0x2100
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x4df0
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x549f
movl $0x1, -0x4(%rbp)
jmp 0x54cb
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
imulq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/eweb.c
// Function: badd
static int badd(eweb_os_t *w, block_t *b, const void *data, const long len) {
	assert(b);
	assert(data);
	if ((b->alloc_bytes - b->used_bytes) < len) {
		while ((b->alloc_bytes - b->used_bytes) < len) // !?
			b->alloc_bytes += (b->chunk_size * b->elem_bytes);
		void *p = b->ptr;
		if (!(p = eweb_realloc_or_die(w, b->ptr, b->alloc_bytes)))
			return EWEB_ERROR;
		b->ptr = p;
	}
	memcpy((char*)b->ptr + b->used_bytes, data, len);
	b->used_bytes += len;
	memset((char*)b->ptr + b->used_bytes, 0, b->alloc_bytes - b->used_bytes);
	return EWEB_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5501
jmp 0x5520
leaq 0x224b(%rip), %rdi      # 0x7753
leaq 0x2439(%rip), %rsi      # 0x7948
movl $0x213, %edx            # imm = 0x213
leaq 0x2e65(%rip), %rcx      # 0x8380
callq 0x2100
cmpq $0x0, -0x20(%rbp)
je 0x5529
jmp 0x5548
leaq 0x2e8b(%rip), %rdi      # 0x83bb
leaq 0x2411(%rip), %rsi      # 0x7948
movl $0x214, %edx            # imm = 0x214
leaq 0x2e3d(%rip), %rcx      # 0x8380
callq 0x2100
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
subq 0x10(%rcx), %rax
cmpq -0x28(%rbp), %rax
jge 0x55d6
jmp 0x5560
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
subq 0x10(%rcx), %rax
cmpq -0x28(%rbp), %rax
jge 0x5595
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
imulq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
jmp 0x5560
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x5290
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x55cb
movl $0x1, -0x4(%rbp)
jmp 0x562f
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
addq 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x21d0
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
addq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rax
subq 0x10(%rax), %rdx
xorl %esi, %esi
callq 0x2130
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)