LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/tomka[P]cliaspora/http.c
// Function: http_get
int
http_get(ssl_conn_t *cp, const char *url, const char *cookie,
	 const char *accept, const char *agent)
{
	char	   *rq;
	http_req_t hdr;

	(void)memset(&hdr, 0, sizeof(hdr));
	hdr.ua       = agent;
	hdr.url	     = url;
	hdr.type     = HTTP_RQ_TYPE_GET;
	hdr.host     = cp->host;
	hdr.cookie   = cookie;
	hdr.accept   = accept;
	hdr.location = url; 

	if ((rq = http_gen_req(&hdr)) == NULL)
		return (-1);
	if (ssl_write(cp, rq, strlen(rq)) == -1) {
		free(rq); return (-1);
	}
	free(rq);
	return (get_http_status(cp));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
andq $0x0, 0x20(%rdi)
movq %r8, 0x10(%rdi)
movq %rsi, 0x8(%rdi)
movl $0x1, 0x4(%rdi)
movq 0x18(%rbx), %rax
movq %rax, 0x30(%rdi)
movq %rdx, 0x40(%rdi)
movq %rcx, 0x28(%rdi)
movq %rsi, 0x38(%rdi)
callq 0x7790
testq %rax, %rax
je 0x7bbe
movq %rax, %r14
movq %rax, %rdi
callq 0x2150
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x74e2
movl %eax, %ebp
movq %r14, %rdi
callq 0x23d0
cmpl $-0x1, %ebp
je 0x7bbe
movq %rbx, %rdi
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x7a9e
pushq $-0x1
popq %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tomka[P]cliaspora/http.c
// Function: http_post
int
http_post(ssl_conn_t *cp, const char *url, const char *cookie,
	 const char *accept, const char *agent, int type, const char *content)
{
	char	   *rq;
	http_req_t hdr;

	(void)memset(&hdr, 0, sizeof(hdr));
	hdr.url      = url;
	hdr.ua       = agent;
	hdr.host     = cp->host;
	hdr.type     = HTTP_RQ_TYPE_POST;
	hdr.cookie   = cookie;
	hdr.accept   = accept;
	hdr.location = url;

	if (type == HTTP_POST_TYPE_JSON)
		hdr.ct = "application/json; charset=UTF-8";
	else if (type == HTTP_POST_TYPE_OCTET)
		hdr.ct = "application/octet-stream";
	else {
		hdr.ct = "application/x-www-form-" \
			 "urlencoded;charset=utf-8";
	}
	if (content != NULL)
		hdr.cl = strlen(content);
	if ((rq = http_gen_req(&hdr)) == NULL)
		return (-1);
	if (ssl_write(cp, rq, strlen(rq)) == -1) {
		free(rq); return (-1);
	}
	free(rq);
	if (content != NULL) {
		if (ssl_write(cp, content, hdr.cl) == -1)
			return (-1);
	}
	return (get_http_status(cp));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq 0x80(%rsp), %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %r8, 0x10(%rsp)
movq 0x18(%rdi), %rax
movq %rax, 0x30(%rsp)
movl $0x2, 0x4(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x28(%rsp)
movq %rsi, 0x38(%rsp)
cmpl $0x2, %r9d
leaq 0x3c09(%rip), %rax      # 0xb831
leaq 0x3c1b(%rip), %rcx      # 0xb84a
cmoveq %rax, %rcx
cmpl $0x1, %r9d
leaq 0x3bd3(%rip), %rax      # 0xb811
cmovneq %rcx, %rax
movq %rax, 0x20(%rsp)
testq %r14, %r14
je 0x7c5c
movq %r14, %rdi
callq 0x2150
movl %eax, (%rsp)
movslq %eax, %r15
jmp 0x7c5f
xorl %r15d, %r15d
movq %rsp, %rdi
callq 0x7790
testq %rax, %rax
je 0x7cc0
movq %rax, %r12
movq %rax, %rdi
callq 0x2150
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x74e2
movl %eax, %ebp
movq %r12, %rdi
callq 0x23d0
cmpl $-0x1, %ebp
je 0x7cc0
testq %r14, %r14
je 0x7cac
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x74e2
cmpl $-0x1, %eax
je 0x7cc0
movq %rbx, %rdi
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7a9e
pushq $-0x1
popq %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tomka[P]cliaspora/http.c
// Function: http_delete
int
http_delete(ssl_conn_t *cp, const char *url, const char *cookie,
	    const char *agent)
{
	char	   *rq;
	http_req_t hdr;

	(void)memset(&hdr, 0, sizeof(hdr));
	hdr.url	     = url;
	hdr.cookie   = cookie;
	hdr.ua	     = agent;
	hdr.type     = HTTP_RQ_TYPE_DELETE;
	hdr.host     = cp->host;
	hdr.location = url;

	if ((rq = http_gen_req(&hdr)) == NULL)
		return (-1);
	if (ssl_write(cp, rq, strlen(rq)) == -1) {
		free(rq); return (-1);
	}
	free(rq);
	return (get_http_status(cp));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, 0x20(%rdi)
movq %rsi, 0x8(%rdi)
movq %rdx, 0x40(%rdi)
movq %rcx, 0x10(%rdi)
movl $0x3, 0x4(%rdi)
movq 0x18(%rbx), %rax
movq %rax, 0x30(%rdi)
movq %rsi, 0x38(%rdi)
callq 0x7790
testq %rax, %rax
je 0x7d4d
movq %rax, %r14
movq %rax, %rdi
callq 0x2150
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x74e2
movl %eax, %ebp
movq %r14, %rdi
callq 0x23d0
cmpl $-0x1, %ebp
je 0x7d4d
movq %rbx, %rdi
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x7a9e
pushq $-0x1
popq %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tomka[P]cliaspora/json.c
// Function: isutf8
bool
isutf8(const u_char *str)
{
	while (*str != '\0') {
		if ((*str >> 4) == 0x0f) {
			if (strlen((char *)str) < 4)
				return (false);
			if ((str[1] >> 6) != 0x02 || (str[2] >> 6) != 0x02 ||
			    (str[3] >> 6) != 0x02)
				return (false);
			str += 4;
		} else if ((*str >> 5) == 0x07) {
			if (strlen((char *)str) < 3)
				return (false);
			if ((str[1] >> 6) != 0x02 || (str[2] >> 6) != 0x02)
				return (false);
			str += 3;
		} else if ((*str >> 6) == 0x03) {
			if (strlen((char *)str) < 2)
				return (false);
			if ((str[1] >> 6) != 0x02)
				return (false);
			str += 2;
		} else if (*str > 0x7f)
			return (false);
		else
			str++;
	}
	return (true);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
pushq $0x4
popq %r14
pushq $0x3
popq %r15
pushq $0x2
popq %r12
pushq $0x1
popq %r13
movzbl (%rbx), %eax
testl %eax, %eax
je 0x7fce
movl %eax, %ecx
notl %ecx
testb $-0x10, %cl
jne 0x7f67
movq %rbx, %rdi
callq 0x2150
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x4, %rcx
jb 0x7fd0
movb 0x1(%rbx), %cl
andb $-0x40, %cl
negb %cl
jno 0x7fd0
movb 0x2(%rbx), %cl
andb $-0x40, %cl
negb %cl
jno 0x7fd0
movb 0x3(%rbx), %cl
andb $-0x40, %cl
negb %cl
movq %r14, %rcx
jo 0x7fc6
jmp 0x7fd0
testb $-0x20, %cl
jne 0x7f98
movq %rbx, %rdi
callq 0x2150
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x3, %rcx
jb 0x7fd0
movb 0x1(%rbx), %cl
andb $-0x40, %cl
negb %cl
jno 0x7fd0
movb 0x2(%rbx), %cl
andb $-0x40, %cl
negb %cl
movq %r15, %rcx
jo 0x7fc6
jmp 0x7fd0
testb $-0x40, %cl
jne 0x7fbf
movq %rbx, %rdi
callq 0x2150
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x2, %rcx
jb 0x7fd0
movb 0x1(%rbx), %cl
andb $-0x40, %cl
negb %cl
movq %r12, %rcx
jo 0x7fc6
jmp 0x7fd0
movq %r13, %rcx
testb %al, %al
js 0x7fdf
addq %rcx, %rbx
jmp 0x7f15
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x7fd0
// File: /workspace/github_c_makefile_star2_O2/tomka[P]cliaspora/json.c
// Function: free_json_node
void
free_json_node(json_node_t *node)
{
	json_node_t *next;

	while (node != NULL) {
		if (node->type == JSON_TYPE_OBJECT ||
		    node->type == JSON_TYPE_ARRAY) {
			free_json_node(node->val);
			return;
		}
		next = node->next;
		free(node->var); free(node->val);
		free(node);
		node = next;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rbx, %rbx
je 0x803f
movb (%rbx), %al
addb $-0x3, %al
cmpb $0x1, %al
ja 0x801c
movq 0x10(%rbx), %rbx
jmp 0x8009
movq 0x8(%rbx), %rdi
movq 0x18(%rbx), %r14
callq 0x23d0
movq 0x10(%rbx), %rdi
callq 0x23d0
movq %rbx, %rdi
callq 0x23d0
movq %r14, %rbx
jmp 0x8009
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/tomka[P]cliaspora/json.c
// Function: find_json_node
json_node_t *
find_json_node(json_node_t *node, const char *name)
{
	json_node_t *np;

	while (node != NULL) {
		if (node->var != NULL && strcmp(node->var, name) == 0)
			return (node);
		else if (node->type == JSON_TYPE_OBJECT ||
		    node->type == JSON_TYPE_ARRAY) {
			if ((np = find_json_node(node->val, name)) != NULL)
				return (np);
		}
		node = node->next;
	}	
	return (NULL);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rbx, %rbx
je 0x8760
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x8741
movq %r14, %rsi
callq 0x2460
testl %eax, %eax
je 0x8767
movb (%rbx), %al
addb $-0x3, %al
cmpb $0x1, %al
ja 0x875a
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x871d
testq %rax, %rax
jne 0x8764
movq 0x18(%rbx), %rbx
jmp 0x8727
xorl %ebx, %ebx
jmp 0x8767
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/tomka[P]cliaspora/json.c
// Function: json_escape_str
char *
json_escape_str(const char *str)
{
	char *p, *buf;

	if ((buf = malloc(strlen(str) * 2 + 1)) == NULL)
		return (NULL);
	for (p = buf; str != NULL && *str != '\0'; str++) {
		switch (*str) {
		case '\r':
			*p++ = '\\'; *p++ = 'r';
			break;
		case '\b':
			*p++ = '\\'; *p++ = 'b';
			break;
		case '\f':
			*p++ = '\\'; *p++ = 'f';
			break;
		case '\n':
			*p++ = '\\'; *p++ = 'n';
			break;
		case '\t':
			*p++ = '\\'; *p++ = 't';
			break;
		case '\v':
			*p++ = '\\'; *p++ = 'v';
			break;
		case '\\':
			*p++ = '\\'; *p++ = '\\';
			break;
		case '/':
			*p++ = '\\'; *p++ = '/';
			break;
		case '"':
			*p++ = '\\'; *p++ = '"';
			break;
		default:
			*p++ = *str;
		}
	}
	*p = '\0';
	return (buf);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2150
leaq 0x1(,%rax,2), %rdi
callq 0x2430
testq %rax, %rax
je 0x8831
leaq 0x3161(%rip), %rcx      # 0xb918
movq %rax, %rdx
testq %rbx, %rbx
je 0x882e
movzbl (%rbx), %esi
cmpq $0xd, %rsi
ja 0x87d8
movslq (%rcx,%rsi,4), %rdi
addq %rcx, %rdi
jmpq *%rdi
movw $0x625c, (%rdx)         # imm = 0x625C
jmp 0x8825
cmpl $0x22, %esi
je 0x8819
cmpl $0x2f, %esi
je 0x8820
cmpl $0x5c, %esi
jne 0x87ee
movw $0x5c5c, (%rdx)         # imm = 0x5C5C
jmp 0x8825
movb %sil, (%rdx)
incq %rdx
jmp 0x8829
movw $0x765c, (%rdx)         # imm = 0x765C
jmp 0x8825
movw $0x665c, (%rdx)         # imm = 0x665C
jmp 0x8825
movw $0x6e5c, (%rdx)         # imm = 0x6E5C
jmp 0x8825
movw $0x745c, (%rdx)         # imm = 0x745C
jmp 0x8825
movw $0x725c, (%rdx)         # imm = 0x725C
jmp 0x8825
movw $0x225c, (%rdx)         # imm = 0x225C
jmp 0x8825
movw $0x2f5c, (%rdx)         # imm = 0x2F5C
addq $0x2, %rdx
incq %rbx
jmp 0x87ba
movb $0x0, (%rdx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/tomka[P]cliaspora/json.c
// Function: uctoutf8
static int
uctoutf8(u_int u, u_char *buf)
{
	int n;

	if (u > 0xffff) {
		n = 4;
		buf[0] = 0xf0 + ((u >> 18) & 0x07);
		buf[1] = 0x80 + ((u >> 12) & 0x3f);
		buf[2] = 0x80 + ((u >>  6) & 0x3f);
		buf[3] = 0x80 + (u & 0x3f);
	} else if (u > 0xff) {
		n = 3;
		buf[0] = 0xe0 + ((u >> 12) & 0x0f);
		buf[1] = 0x80 + ((u >>  6) & 0x3f);
		buf[2] = 0x80 + (u & 0x3f);
	} else if (u > 0x7f) {
		n = 2;
		buf[0] = 0xc0 + ((u >>  6) & 0x1f);
		buf[1] = 0x80 + (u & 0x3f);
	} else {
		n = 1;
		buf[0] = u;
	}
	return (n);
}

// Assembly:
cmpl $0x10000, %edi          # imm = 0x10000
jb 0x887e
movl %edi, %eax
shrl $0x12, %eax
movl %edi, %ecx
shrl $0x4, %ecx
andl $0xff00, %ecx           # imm = 0xFF00
movzbl %al, %eax
orl %ecx, %eax
movl %edi, %ecx
shll $0xa, %ecx
andl $0xff0000, %ecx         # imm = 0xFF0000
orl %eax, %ecx
shll $0x18, %edi
orl %ecx, %edi
movd %edi, %xmm0
pand 0x30e2(%rip), %xmm0     # 0xb950
por 0x30ea(%rip), %xmm0     # 0xb960
movd %xmm0, (%rsi)
pushq $0x4
jmp 0x88d1
cmpl $0x100, %edi            # imm = 0x100
jb 0x88ab
movl %edi, %eax
shrl $0xc, %eax
orb $-0x20, %al
movb %al, (%rsi)
movl %edi, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rsi)
andb $0x3f, %dil
orb $-0x80, %dil
movb %dil, 0x2(%rsi)
pushq $0x3
jmp 0x88d1
cmpl $0x80, %edi
jb 0x88cc
movl %edi, %eax
shrl $0x6, %eax
orb $-0x40, %al
movb %al, (%rsi)
andb $0x3f, %dil
orb $-0x80, %dil
movb %dil, 0x1(%rsi)
pushq $0x2
jmp 0x88d1
movb %dil, (%rsi)
pushq $0x1
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/tomka[P]cliaspora/file.c
// Function: delete_postponed
void
delete_postponed()
{
	char *pp_path;

	if (have_postponed()) {
		if ((pp_path = get_postponed_path()) != NULL) {
			if (remove(pp_path) == -1)
				warn("remove(%s)", pp_path);
		}
	}
}

// Assembly:
pushq %rbx
callq 0x890c
testl %eax, %eax
je 0x88f8
callq 0x8966
testq %rax, %rax
je 0x88f8
movq %rax, %rbx
movq %rax, %rdi
callq 0x2570
cmpl $-0x1, %eax
je 0x88fa
popq %rbx
retq
leaq 0x309c(%rip), %rdi      # 0xb99d
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
jmp 0x2110
// File: /workspace/github_c_makefile_star2_O2/tomka[P]cliaspora/file.c
// Function: have_postponed
static bool
have_postponed()
{
	char	    *pp_path;
	struct stat sb;

	if ((pp_path = get_postponed_path()) == NULL)
		return (false);
	if (stat(pp_path, &sb) == -1) {
		if (errno != ENOENT)
			warn("stat(%s)", pp_path);
		return (false);
	}
	return (true);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
callq 0x8966
xorl %ebx, %ebx
testq %rax, %rax
je 0x8959
movq %rax, %r14
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2260
cmpl $-0x1, %eax
je 0x893c
pushq $0x1
popq %rbx
jmp 0x8959
callq 0x2060
cmpl $0x2, (%rax)
je 0x8959
leaq 0x30de(%rip), %rdi      # 0xba2b
xorl %ebx, %ebx
movq %r14, %rsi
xorl %eax, %eax
callq 0x2110
movl %ebx, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/tomka[P]cliaspora/file.c
// Function: get_postponed_path
static char *
get_postponed_path()
{
	int	      len;
	static char   *pp_path = NULL;
	struct passwd *pw;

	if (pp_path != NULL)
		return (pp_path);
	if ((pw = getpwuid(getuid())) == NULL) {
		warnx("Couldn't find you in the password file");
		return (NULL);
	}
	endpwent();
	len = strlen(pw->pw_dir) + strlen(PATH_POSTPONED) + 2;

	if ((pp_path = malloc(len)) == NULL) {
		warn("malloc()"); return (NULL);
	}
	(void)snprintf(pp_path, len, "%s/%s", pw->pw_dir, PATH_POSTPONED);

	return (pp_path);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x731f(%rip), %rbx      # 0xfc90
testq %rbx, %rbx
je 0x8981
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x2180
movl %eax, %edi
callq 0x2390
testq %rax, %rax
je 0x89e7
movq %rax, %rbx
callq 0x2380
movq 0x20(%rbx), %rbx
movq %rbx, %rdi
callq 0x2150
addl $0x16, %eax
movslq %eax, %r14
movq %r14, %rdi
callq 0x2430
movq %rax, 0x72d5(%rip)      # 0xfc90
testq %rax, %rax
je 0x89fc
leaq 0x2ac1(%rip), %rdx      # 0xb488
leaq 0x3048(%rip), %r8       # 0xba16
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2540
movq 0x72ab(%rip), %rbx      # 0xfc90
jmp 0x8976
leaq 0x2a73(%rip), %rdi      # 0xb461
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x22e0
jmp 0x8976
leaq 0x1c83(%rip), %rdi      # 0xa686
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2110
jmp 0x8976
// File: /workspace/github_c_makefile_star2_O2/tomka[P]cliaspora/file.c
// Function: read_file
static char *
read_file(FILE *fp)
{
	char   *buf, *p;
	size_t bufsz, blocks, rd;

	bufsz = blocks = 0;
	if ((buf = malloc(BUFSIZ)) == NULL) {
		warn("malloc()"); return (NULL);
	}
	blocks++; bufsz += BUFSIZ; p = buf;
	while ((rd = fread(p, 1, BUFSIZ, fp)) == BUFSIZ) {
		blocks++; bufsz += BUFSIZ;
		if ((p = realloc(buf, bufsz)) == NULL) {
			warn("realloc()"); free(buf); return (NULL);
		}
		buf = p; p = buf + (blocks - 1) * BUFSIZ;
	} 
	if (!feof(fp)) {
		warn("fread()"); free(buf); return (NULL);
	}
	buf[(blocks - 1) * BUFSIZ + rd] = '\0';
	return (buf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x2000, %edi           # imm = 0x2000
callq 0x2430
testq %rax, %rax
je 0x8e4f
movq %rax, %rbx
pushq $0x1
popq %r12
movl $0x4000, %r15d          # imm = 0x4000
movq %rax, %rdi
movq %r12, %rbp
movl $0x2000, %edx           # imm = 0x2000
movq %r12, %rsi
movq %r14, %rcx
callq 0x24e0
cmpq $0x2000, %rax           # imm = 0x2000
jne 0x8e61
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2550
testq %rax, %rax
je 0x8e7e
leaq 0x1(%rbp), %rcx
shlq $0xd, %rbp
addq %rax, %rbp
addq $0x2000, %r15           # imm = 0x2000
movq %rax, %rbx
movq %rbp, %rdi
movq %rcx, %rbp
jmp 0x8e0a
leaq 0x1830(%rip), %rdi      # 0xa686
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2110
jmp 0x8e9f
movq %rax, %r13
movq %r14, %rdi
callq 0x2500
testl %eax, %eax
je 0x8e87
addq %rbx, %r13
movb $0x0, -0x4000(%r15,%r13)
jmp 0x8e9f
leaq 0x13d6(%rip), %rdi      # 0xa25b
jmp 0x8e8e
leaq 0x2c1b(%rip), %rdi      # 0xbaa9
xorl %eax, %eax
callq 0x2110
movq %rbx, %rdi
callq 0x23d0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/tomka[P]cliaspora/readpass.c
// Function: rawtty
int
rawtty()
{
	struct termios tt;

	if (tcgetattr(fileno(stdin), &tt) == -1) {
		warn("tcgetattr(stdin)"); return (-1);
	}
	tt_old = tt;
	tt.c_lflag &= ~(ICANON | ECHO);
	tt.c_cc[VTIME] = 0;
	tt.c_cc[VMIN] = 1;

	if (tcsetattr(STDIN_FILENO, TCSANOW, &tt) == -1) {
		warn("tcsetattr(stdin)"); return (-1);
	}
	return (0);
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq 0x6110(%rip), %rax      # 0xefd0
movq (%rax), %rdi
callq 0x22c0
leaq 0x4(%rsp), %rsi
movl %eax, %edi
callq 0x2340
cmpl $-0x1, %eax
je 0x8f2c
leaq 0x4(%rsp), %rdx
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups 0x20(%rdx), %xmm2
movups 0x2c(%rdx), %xmm3
movups %xmm3, 0x6dd8(%rip)     # 0xfccc
movups %xmm2, 0x6dc5(%rip)     # 0xfcc0
movups %xmm1, 0x6dae(%rip)     # 0xfcb0
movups %xmm0, 0x6d97(%rip)     # 0xfca0
andb $-0xb, 0xc(%rdx)
movw $0x100, 0x16(%rdx)      # imm = 0x100
xorl %ebx, %ebx
xorl %edi, %edi
xorl %esi, %esi
callq 0x2420
cmpl $-0x1, %eax
jne 0x8f3d
leaq 0x2bb6(%rip), %rdi      # 0xbae0
jmp 0x8f33
leaq 0x2b9c(%rip), %rdi      # 0xbacf
xorl %eax, %eax
callq 0x2110
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/tomka[P]cliaspora/readpass.c
// Function: readpass
char *
readpass()
{
	int	    n = 0;
	static char c, buf[128];

	if (!isatty(fileno(stdin))) {
		(void)fgets(buf, sizeof(buf), stdin);
		(void)strtok(buf, "\n\r");
		return (buf);
	}
	if (rawtty() == -1)
		return (NULL);
	(void)fputs("Password: ", stderr);
	errno = 0;
	for (n = 0; n < sizeof(buf) && read(fileno(stdin), &c, 1) > 0;) {
		if (c == '\b' || c == tt_old.c_cc[VERASE]) {
			if (n > 0)
				(void)fputs("\b \b", stderr), n--;
		} else if (c == '\n' || c == '\r')
			break;
		else
			(void)fputc('*', stderr), buf[n++] = c;
	}
	buf[n++] = '\0';
	(void)unrawtty();
	(void)fputc('\n', stderr);

	return (buf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x604b(%rip), %r13      # 0xefd0
movq (%r13), %rdi
callq 0x22c0
movl %eax, %edi
callq 0x2560
testl %eax, %eax
je 0x8faa
callq 0x8eb4
xorl %r14d, %r14d
cmpl $-0x1, %eax
jne 0x8fe3
xorl %ebx, %ebx
jmp 0x8fd1
movq (%r13), %rdx
leaq 0x6d2b(%rip), %rbx      # 0xfce0
movq %rbx, %rdi
movl $0x80, %esi
callq 0x2530
leaq 0x2b34(%rip), %rsi      # 0xbafd
movq %rbx, %rdi
callq 0x2510
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x5fee(%rip), %rax      # 0xefd8
movq (%rax), %rsi
leaq 0x2b0c(%rip), %rdi      # 0xbb00
callq 0x2360
callq 0x2060
andl $0x0, (%rax)
pushq $0x1
popq %r15
leaq 0x6cd4(%rip), %rbx      # 0xfce0
movslq %r14d, %rbp
cmpl $0x7f, %ebp
ja 0x90ac
movl %r14d, %r12d
movq (%r13), %rdi
callq 0x22c0
movl %eax, %edi
leaq 0x6caf(%rip), %rsi      # 0xfcdc
movq %r15, %rdx
callq 0x24b0
testq %rax, %rax
jle 0x90ac
movsbl 0x6c9b(%rip), %eax      # 0xfcdc
cmpl $0x8, %eax
je 0x9080
movzbl 0x6c66(%rip), %ecx      # 0xfcb3
cmpl %ecx, %eax
je 0x9080
movzbl %al, %eax
cmpl $0xa, %eax
je 0x90ac
cmpl $0xd, %eax
je 0x90ac
movq 0x5f73(%rip), %rax      # 0xefd8
movq (%rax), %rsi
pushq $0x2a
popq %rdi
callq 0x2410
movb 0x6c66(%rip), %al       # 0xfcdc
leal 0x1(%rbp), %r14d
movb %al, (%rbp,%rbx)
jmp 0x900c
movl $0x0, %r14d
testl %r12d, %r12d
je 0x900c
movq 0x5f46(%rip), %rax      # 0xefd8
movq (%rax), %rsi
leaq 0x2a6f(%rip), %rdi      # 0xbb0b
callq 0x2360
decl %r12d
movl %r12d, %r14d
jmp 0x900c
movb $0x0, (%rbp,%rbx)
callq 0x8f45
movq 0x5f1b(%rip), %rax      # 0xefd8
movq (%rax), %rsi
pushq $0xa
popq %rdi
callq 0x2410
jmp 0x8fd1
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/tomka[P]cliaspora/str.c
// Function: strdupstrcat
char *
strdupstrcat(char **buf, size_t *remain, const char *str, size_t len)
{
	char   *p;
	size_t sz;

	if (len + 1 >= *remain) {
		if (*buf != NULL)
			sz = len + 32 + strlen(*buf) + *remain;
		else
			sz = len + 32;
		if ((p = realloc(*buf, sz)) == NULL) {
			warn("realloc()"); return (NULL);
		}
		if (*buf == NULL)
			*p = '\0';
		*buf = p; *remain += len + 32;
	}
	*remain -= (len + 1);
	(void)strncat(*buf, str, len);
	return (*buf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x1(%rcx), %rax
movq (%rsi), %r15
movq (%rdi), %r13
cmpq %r15, %rax
jb 0x914e
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0x20(%r14), %rbp
testq %r13, %r13
je 0x9117
movq %r13, %rdi
callq 0x2150
addq %r15, %rbp
addq %rax, %rbp
movq %r13, %rdi
movq %rbp, %rsi
callq 0x2550
testq %rax, %rax
je 0x9178
movq %rax, %r13
cmpq $0x0, (%rbx)
jne 0x9135
movb $0x0, (%r13)
movq %r13, (%rbx)
movq (%r12), %rax
leaq (%r14,%rax), %r15
addq $0x20, %r15
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rax
subq %rax, %r15
movq %r15, (%r12)
movq %r13, %rdi
movq %rdx, %rsi
movq %r14, %rdx
callq 0x21e0
movq (%rbx), %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10dc(%rip), %rdi      # 0xa25b
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2110
jmp 0x9166
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/demos/demo_destroy.c
// Function: print_help
void
print_help(const char *app)
{
    printf("Usage: %s [flag value | flag] ...\n\n", app);
    printf("Flags:\n");
    printf("-a addr : the IP address of the KMIP server\n");
    printf("-c path : path to client certificate file\n");
    printf("-h      : print this help info\n");
    printf("-i id   : the ID of the symmetric key to destroy\n");
    printf("-k path : path to client key file\n");
    printf("-p port : the port number of the KMIP server\n");
    printf("-r path : path to CA certificate file\n");
}

// Assembly:
pushq %rax
movq %rdi, %rsi
leaq 0x16cad(%rip), %rdi     # 0x19004
xorl %eax, %eax
callq 0x2040
leaq 0x16e1b(%rip), %rdi     # 0x19180
callq 0x2210
leaq 0x16e16(%rip), %rdi     # 0x19187
callq 0x2210
leaq 0x16e36(%rip), %rdi     # 0x191b3
callq 0x2210
leaq 0x16e54(%rip), %rdi     # 0x191dd
callq 0x2210
leaq 0x16e67(%rip), %rdi     # 0x191fc
callq 0x2210
leaq 0x16e8c(%rip), %rdi     # 0x1922d
callq 0x2210
leaq 0x16ea2(%rip), %rdi     # 0x1924f
callq 0x2210
leaq 0x16ec3(%rip), %rdi     # 0x1927c
popq %rax
jmp 0x2210
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/demos/demo_destroy.c
// Function: main
int
main(int argc, char **argv)
{
    char *server_address = NULL;
    char *server_port = NULL;
    char *client_certificate = NULL;
    char *client_key = NULL;
    char *ca_certificate = NULL;
    char *id = NULL;
    int help = 0;
    
    int error = parse_arguments(argc, argv, &server_address, &server_port, &client_certificate, &client_key, &ca_certificate, &id, &help);
    if(error)
    {
        return(error);
    }
    if(help)
    {
        print_help(argv[0]);
        return(0);
    }
    
    int result = use_high_level_api(server_address, server_port, client_certificate, client_key, ca_certificate, id);
    return(result);
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
leaq 0x38(%rsp), %rdx
andq $0x0, (%rdx)
leaq 0x30(%rsp), %rcx
andq $0x0, (%rcx)
leaq 0x28(%rsp), %r8
andq $0x0, (%r8)
leaq 0x20(%rsp), %r9
andq $0x0, (%r9)
leaq 0x18(%rsp), %rax
andq $0x0, (%rax)
leaq 0x10(%rsp), %r10
andq $0x0, (%r10)
leaq 0xc(%rsp), %r11
andl $0x0, (%r11)
subq $0x8, %rsp
pushq %r11
pushq %r10
pushq %rax
callq 0x23bf
addq $0x20, %rsp
testl %eax, %eax
je 0x2776
pushq $-0x1
popq %rax
jmp 0x2787
cmpl $0x0, 0xc(%rsp)
je 0x278d
movq (%rbx), %rdi
callq 0x234c
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
retq
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x10(%rsp), %r9
addq $0x40, %rsp
popq %rbx
jmp 0x24a6
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/test.c
// Function: main
int main(int argc, char* argv[])
{
	if(argc < 2)
	{
		fprintf(stderr, "%s [execution amount]\n", argv[0]);
		return 1;
	}
	
	script_t script;
	
	script_init(&script);
	
	script_disable_warning(WARN_DYNAMIC_ARRAY_LITERAL, 1);
	script_disable_warning(WARN_ARRAY_DYNAMIC_TO_SPECIFIC, 1);
	
	script_load_parse_file(&script, "test.txt", "test");
	script_compile(&script);
	
	for(int i = 2; i < argc; ++i)
	{
		if(strcmp(argv[i], "-dis") == 0)
			script_dissassemble(&script, stdout);
	}
	for(int i = 0; i < strtol(argv[1], NULL, 10); ++i)
		script_run(&script);
	script_destroy(&script);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2d8, %rsp            # imm = 0x2D8
movq %rsi, %rbx
cmpl $0x1, %edi
jle 0x2471
movl %edi, %r15d
leaq -0x300(%rbp), %r14
movq %r14, %rdi
callq 0x2507
pushq $0x1
popq %r12
xorl %edi, %edi
movl %r12d, %esi
callq 0x38e0
movl %r12d, %edi
movl %r12d, %esi
callq 0x38e0
leaq 0xac4d(%rip), %rsi      # 0xd01b
leaq 0xac4f(%rip), %rdx      # 0xd024
movq %r14, %rdi
callq 0x348b
movq %r14, %rdi
callq 0x38f4
movl %r15d, %r12d
pushq $0x2
popq %r13
leaq 0xac36(%rip), %r15      # 0xd029
movq 0x11bce(%rip), %r14     # 0x13fc8
cmpq %r13, %r12
je 0x2423
movq (%rbx,%r13,8), %rdi
movq %r15, %rsi
callq 0x2150
testl %eax, %eax
jne 0x241e
movq (%r14), %rsi
leaq -0x300(%rbp), %rdi
callq 0x3c49
incq %r13
jmp 0x23fa
xorl %r12d, %r12d
pushq $0xa
popq %r14
leaq -0x300(%rbp), %r15
movq 0x8(%rbx), %rdi
xorl %esi, %esi
movl %r14d, %edx
callq 0x2190
cmpq %r12, %rax
jle 0x2451
movq %r15, %rdi
callq 0x40fb
incq %r12
jmp 0x2431
leaq -0x300(%rbp), %rdi
callq 0x5339
xorl %eax, %eax
addq $0x2d8, %rsp            # imm = 0x2D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x11b78(%rip), %rax     # 0x13ff0
movq (%rax), %rdi
movq (%rbx), %rdx
leaq 0xab7f(%rip), %rsi      # 0xd004
xorl %eax, %eax
callq 0x2170
pushq $0x1
popq %rax
jmp 0x245f
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: add_heap_block
static void add_heap_block(script_t* script)
{
	script_heap_block_t* block = emalloc(sizeof(script_heap_block_t));
	
	block->next = script->heap_head;
	block->num_free = SCRIPT_HEAP_BLOCK_SIZE;
	for (int i = 0; i < block->num_free; ++i)
	{
		block->free_indices[i] = block->num_free - i - 1;

		block->values[i].block = block;
		block->values[i].block_index = i;
	}

	script->heap_head = block;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1110, %edi           # imm = 0x1110
callq 0x325f
movq 0x150(%rbx), %rcx
movq %rcx, (%rax)
movl $0x40, 0x8(%rax)
movq %rax, %rcx
addq $0x118, %rcx            # imm = 0x118
pushq $0x3f
popq %rdx
xorl %esi, %esi
cmpq $0x40, %rsi
je 0x2bb5
movl %edx, 0xc(%rax,%rsi,4)
movq %rax, -0x8(%rcx)
movl %esi, (%rcx)
incq %rsi
decl %edx
addq $0x40, %rcx
jmp 0x2b9a
movq %rax, 0x150(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: script_reset
void script_reset(script_t* script)
{	
	vec_traverse(&script->modules, destroy_module);
	vec_clear(&script->modules);
	
	destroy_all_values(script);
	
	script->heap_head = NULL;
	add_heap_block(script);

	script->in_extern = 0;
	
	script->num_objects = 0;
	script->max_objects_until_gc = INIT_GC_THRESH;
	
	script->pc = -1;
	script->fp = 0;

	script->gc_head = NULL;
	script->ret_val = NULL;

	script->indir_depth = 0;

	vec_clear(&script->globals);
	
	vec_clear(&script->stack);
	vec_clear(&script->indir);
	
	vec_clear(&script->code);
	
	vec_clear(&script->function_names);
	vec_clear(&script->function_pcs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2b8(%rdi), %r14
leaq 0xac(%rip), %rsi        # 0x2c87
movq %r14, %rdi
callq 0xc3b4
movq %r14, %rdi
callq 0xc3ea
movq %rbx, %rdi
callq 0x2d39
andq $0x0, 0x150(%rbx)
movq %rbx, %rdi
callq 0x2b67
movb $0x0, 0x119(%rbx)
movabsq $0x4000000000, %rax     # imm = 0x4000000000
movq %rax, 0x168(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x11c(%rbx)
andl $0x0, 0x190(%rbx)
leaq 0x170(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x158(%rbx)
callq 0xc3ea
leaq 0x198(%rbx), %rdi
callq 0xc3ea
leaq 0x1b8(%rbx), %rdi
callq 0xc3ea
leaq 0x1d8(%rbx), %rdi
callq 0xc3ea
leaq 0x278(%rbx), %rdi
callq 0xc3ea
addq $0x298, %rbx            # imm = 0x298
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc3ea
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: destroy_module
static void destroy_module(void* p_module)
{
	script_module_t* module = p_module;

	vec_destroy(&module->referenced_modules);

	free(module->local_path);
	free(module->name);
	free(module->source_code);

	for(int i = 0; i < module->expr_list.length; ++i)
		delete_expr(vec_get_value(&module->expr_list, i, expr_t*));
	vec_destroy(&module->expr_list);

	vec_destroy(&module->compile_time_blocks);

	vec_destroy(&module->globals);
	vec_destroy(&module->functions);

	vec_traverse(&module->all_type_tags, destroy_type_tag);

	vec_destroy(&module->all_type_tags);
	map_destroy(&module->user_type_tags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xc3f5
movq 0x40(%rbx), %rdi
callq 0x2030
movq 0x38(%rbx), %rdi
callq 0x2030
movq 0x30(%rbx), %rdi
callq 0x2030
leaq 0x50(%rbx), %r14
xorl %r15d, %r15d
cmpq %r15, 0x60(%rbx)
jbe 0x2cd9
movq %r14, %rdi
movq %r15, %rsi
callq 0xc15c
movq (%rax), %rdi
callq 0x8a3f
incq %r15
jmp 0x2cbb
movq %r14, %rdi
callq 0xc3f5
leaq 0x70(%rbx), %rdi
callq 0xc3f5
leaq 0x20f0(%rbx), %rdi
callq 0xc3f5
leaq 0x20d0(%rbx), %rdi
callq 0xc3f5
leaq 0x90(%rbx), %r14
leaq 0x5ecf(%rip), %rsi      # 0x8bdf
movq %r14, %rdi
callq 0xc3b4
movq %r14, %rdi
callq 0xc3f5
addq $0xb0, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xc747
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: destroy_all_values
static void destroy_all_values(script_t* script)
{
	script_heap_block_t* block = script->heap_head;
	while (block)
	{
		script_heap_block_t* next = block->next;
		free(block);
		block = next;
	}

	script->gc_head = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x150(%rdi), %rdi
testq %rdi, %rdi
je 0x2d5c
movq (%rdi), %r14
callq 0x2030
movq %r14, %rdi
jmp 0x2d4a
andq $0x0, 0x158(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: pop_value
static script_value_t* pop_value(script_t* script)
{
	if(script->stack.length == 0) error_exit_script(script, "Stack underflow\n");
	
	script_value_t* val;
	vec_pop_back(&script->stack, &val);
	
	return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpq $0x0, 0x1a8(%rdi)
je 0x2df4
addq $0x198, %rdi            # imm = 0x198
leaq -0x10(%rbp), %rbx
movq %rbx, %rsi
callq 0xc219
movq (%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xbf5f(%rip), %rsi      # 0xed5a
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: script_push_bool
void script_push_bool(script_t* script, char bv)
{
	// NOTE: Singleton values
	// which never get gc'd
	static script_value_t true_val = { 0 };
	static script_value_t false_val = { 0 };

	true_val.type = VAL_BOOL;
	true_val.boolean = 1;
	
	false_val.type = VAL_BOOL;
	false_val.boolean = 0;

	push_value(script, bv ? &true_val : &false_val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, %eax
movl %eax, 0x1137b(%rip)     # 0x1418c
leaq 0x11368(%rip), %rcx     # 0x14180
movb $0x1, 0x11381(%rip)     # 0x141a0
movl %eax, 0x113a7(%rip)     # 0x141cc
leaq 0x11394(%rip), %rax     # 0x141c0
movb $0x0, 0x113ad(%rip)     # 0x141e0
testb %sil, %sil
cmovneq %rcx, %rax
movq %rax, %rsi
popq %rbp
jmp 0x2e40
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: script_pop_bool
char script_pop_bool(script_t* script)
{	
	script_value_t* val = pop_value(script);
	if(val->type != VAL_BOOL)
		error_exit_script(script, "Expected bool but received %s\n", g_value_types[val->type]);

	return val->boolean;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2dc7
movl 0xc(%rax), %ecx
cmpq $0x1, %rcx
jne 0x2ea4
movb 0x20(%rax), %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x10d45(%rip), %rax     # 0x13bf0
movq (%rax,%rcx,8), %rdx
leaq 0xa80f(%rip), %rsi      # 0xd6c5
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: error_exit_script
static void error_exit_script(script_t* script, const char* fmt, ...)
{
	fprintf(stderr, "\nError (%s:%i):\n", script->cur_file, script->cur_line);
	
	va_list args;
	va_start(args, fmt);
	vfprintf(stderr, fmt, args);
	va_end(args);
	
	fprintf(stderr, "\n");
	print_stack_trace(script);
	
	debug_script(script);

	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testb %al, %al
je 0x2f08
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
leaq -0xf0(%rbp), %r15
movq %rdx, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %r8, 0x20(%r15)
movq %r9, 0x28(%r15)
movq 0x110ca(%rip), %r12     # 0x13ff0
movq (%r12), %rdi
movq 0x128(%rbx), %rdx
movl 0x124(%rbx), %ecx
leaq 0xb360(%rip), %rsi      # 0xe29e
xorl %eax, %eax
callq 0x2170
leaq -0x40(%rbp), %rdx
movq %r15, 0x10(%rdx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq (%r12), %rdi
movq %r14, %rsi
callq 0x2210
movq (%r12), %rsi
pushq $0xa
popq %rdi
callq 0x2120
movq %rbx, %rdi
callq 0x8c68
movq %rbx, %rdi
callq 0x4ae5
pushq $0x1
popq %rdi
callq 0x2240
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: new_value
static script_value_t* new_value(script_t* script, script_value_type_t type)
{
	if(!script->in_extern && script->num_objects >= script->max_objects_until_gc) collect_garbage(script); 
	
	script_value_t* val = get_heap_value(script);
	
	val->marked = 0;
	val->type = type;
	
	val->next = script->gc_head;
	script->gc_head = val;
	
	++script->num_objects;
	
	return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
cmpb $0x0, 0x119(%rdi)
jne 0x30f4
movl 0x168(%rbx), %eax
cmpl 0x16c(%rbx), %eax
jl 0x30f4
movq 0x160(%rbx), %rdi
testq %rdi, %rdi
je 0x2ffc
callq 0x8fdc
leaq 0x198(%rbx), %r15
xorl %r12d, %r12d
cmpq %r12, 0x1a8(%rbx)
jbe 0x3027
movq %r15, %rdi
movq %r12, %rsi
callq 0xc15c
movq (%rax), %rdi
callq 0x8fdc
incq %r12
jmp 0x3006
leaq 0x170(%rbx), %r15
xorl %r12d, %r12d
cmpq %r12, 0x180(%rbx)
jbe 0x3052
movq %r15, %rdi
movq %r12, %rsi
callq 0xc15c
movq (%rax), %rdi
callq 0x8fdc
incq %r12
jmp 0x3031
leaq 0x158(%rbx), %r12
leaq 0x9fd0(%rip), %r15      # 0xd030
movq (%r12), %r13
testq %r13, %r13
je 0x30e6
cmpb $0x0, 0x18(%r13)
jne 0x30d5
movq 0x10(%r13), %rax
movq %rax, (%r12)
decl 0x168(%rbx)
movl 0xc(%r13), %eax
addl $-0x4, %eax
cmpl $0x4, %eax
ja 0x30bd
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
leaq 0x20(%r13), %rdi
callq 0xc3f5
jmp 0x30bd
movq 0x28(%r13), %rdi
callq 0x2030
andq $0x0, 0x28(%r13)
jmp 0x30bd
movq 0x30(%r13), %rax
testq %rax, %rax
je 0x30bd
movq 0x20(%r13), %rdi
callq *%rax
movl 0x8(%r13), %eax
movq (%r13), %rcx
movslq 0x8(%rcx), %rdx
leal 0x1(%rdx), %esi
movl %esi, 0x8(%rcx)
movl %eax, 0xc(%rcx,%rdx,4)
jmp 0x3060
movb $0x0, 0x18(%r13)
addq $0x10, %r13
movq %r13, %r12
jmp 0x3060
movl 0x168(%rbx), %eax
addl %eax, %eax
movl %eax, 0x16c(%rbx)
leaq 0x150(%rbx), %r15
movq %r15, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x310f
movl 0x8(%rax), %ecx
testl %ecx, %ecx
jle 0x30fe
jmp 0x3119
movq %rbx, %rdi
callq 0x2b67
jmp 0x30fb
decl %ecx
movl %ecx, 0x8(%rax)
movslq 0xc(%rax,%rcx,4), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
addq $0x110, %rax            # imm = 0x110
movb $0x0, 0x18(%rax)
movl %r14d, 0xc(%rax)
movq 0x158(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq %rax, 0x158(%rbx)
incl 0x168(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: script_pop_char
char script_pop_char(script_t* script)
{
	script_value_t* val = pop_value(script);
	if(val->type != VAL_CHAR)
		error_exit_script(script, "Expected char but received %s\n", g_value_types[val->type]);

	return val->code;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2dc7
movl 0xc(%rax), %ecx
cmpq $0x2, %rcx
jne 0x3180
movb 0x20(%rax), %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x10a69(%rip), %rax     # 0x13bf0
movq (%rax,%rcx,8), %rdx
leaq 0xa552(%rip), %rsi      # 0xd6e4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: script_pop_number
double script_pop_number(script_t* script)
{
	script_value_t* val = pop_value(script);
	if(val->type != VAL_NUMBER)
		error_exit_script(script, "Expected number but received %s\n", g_value_types[val->type]);
	
	return val->number;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2dc7
movl 0xc(%rax), %ecx
cmpq $0x3, %rcx
jne 0x31f0
movsd 0x20(%rax), %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x109f9(%rip), %rax     # 0x13bf0
movq (%rax,%rcx,8), %rdx
leaq 0xa501(%rip), %rsi      # 0xd703
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: script_push_cstr
void script_push_cstr(script_t* script, const char* string)
{
	script_value_t* val = new_value(script, VAL_STRING);
	val->string.length = strlen(string);
	val->string.data = emalloc(val->string.length + 1);
	strcpy(val->string.data, string);
	
	push_value(script, val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x4
popq %rsi
callq 0x2fb8
movq %rax, %r15
movq %r14, %rdi
callq 0x20b0
movl %eax, 0x20(%r15)
leal 0x1(%rax), %edi
callq 0x325f
movq %rax, 0x28(%r15)
movq %rax, %rdi
movq %r14, %rsi
callq 0x2050
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2e40
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: script_push_string
void script_push_string(script_t* script, script_string_t string)
{
	script_value_t* val = new_value(script, VAL_STRING);
	val->string.length = string.length;
	val->string.data = emalloc(string.length + 1);
	strcpy(val->string.data, string.data);
	
	push_value(script, val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
pushq $0x4
popq %rsi
callq 0x2fb8
movq %rax, %r12
movl %r14d, 0x20(%rax)
incl %r14d
movq %r14, %rdi
callq 0x325f
movq %rax, 0x28(%r12)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2050
movq %r15, %rdi
movq %r12, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2e40
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: script_pop_string
script_string_t script_pop_string(script_t* script)
{
	script_value_t* val = pop_value(script);
	if (val->type != VAL_STRING)
		error_exit_script(script, "Expected string but received %s\n", g_value_types[val->type]);
	return val->string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2dc7
movl 0xc(%rax), %ecx
cmpq $0x4, %rcx
jne 0x32f5
movl 0x20(%rax), %ecx
movq 0x28(%rax), %rdx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x108f4(%rip), %rax     # 0x13bf0
movq (%rax,%rcx,8), %rdx
leaq 0xa41d(%rip), %rsi      # 0xd724
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2ec0
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: script_push_array
void script_push_array(script_t* script, size_t length)
{
	script_value_t* val = new_value(script, VAL_ARRAY);
	vec_init(&val->array, sizeof(script_value_t*));
	vec_reserve(&val->array, length);
	push_value(script, val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x6
popq %rsi
callq 0x2fb8
movq %rax, %r15
leaq 0x20(%rax), %r12
pushq $0x8
popq %rsi
movq %r12, %rdi
callq 0xbf0c
movq %r12, %rdi
movq %rbx, %rsi
callq 0xc0f4
movq %r14, %rdi
movq %r15, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2e40
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: script_push_native
void script_push_native(script_t* script, void* value, script_native_callback_t on_mark, script_native_callback_t on_delete)
{
	script_value_t* val = new_value(script, VAL_NATIVE);
	val->nat.value = value;
	val->nat.on_mark = on_mark;
	val->nat.on_delete = on_delete;
	push_value(script, val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x8
popq %rsi
callq 0x2fb8
movq %r15, 0x20(%rax)
movq %r14, 0x28(%rax)
movq %rbx, 0x30(%rax)
movq %r12, %rdi
movq %rax, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2e40
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: script_load_parse_file
void script_load_parse_file(script_t* script, const char* filename, const char* module_name)
{
	FILE* in = fopen(filename, "rb");
	
	if (!in)
		error_exit("Failed to open file '%s'\n", filename);
	
	script_parse_file(script, in, filename, module_name);

	fclose(in);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0xa2e0(%rip), %rsi      # 0xd786
movq %rbx, %rdi
callq 0x2200
testq %rax, %rax
je 0x34d7
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x358f
movq %r12, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20a0
leaq 0xa2ab(%rip), %rdi      # 0xd789
movq %rbx, %rsi
xorl %eax, %eax
callq 0x34e8
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: error_exit
static void error_exit(const char* fmt, ...)
{
	fprintf(stderr, "\nError:\n");
	
	va_list args;
	va_start(args, fmt);
	vfprintf(stderr, fmt, args);
	va_end(args);
	
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
testb %al, %al
je 0x3528
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
leaq -0xe0(%rbp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
movq 0x10aa6(%rip), %r15     # 0x13ff0
movq (%r15), %rcx
leaq 0xb897(%rip), %rdi      # 0xedeb
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
callq 0x2250
leaq -0x30(%rbp), %rdx
movq %r14, 0x10(%rdx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x2210
pushq $0x1
popq %rdi
callq 0x2240
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: script_parse_file
void script_parse_file(script_t* script, FILE* in, const char* local_path, const char* module_name)
{
	fseek(in, 0, SEEK_END);
	size_t length = ftell(in);
	fseek(in, 0, SEEK_SET);
	
	char* str = emalloc(length + 1);
	fread(str, sizeof(char), length, in);
	str[length] = '\0';
	
	rewind(in);
	
	script_parse_code(script, str, local_path, module_name);
	
	free(str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, -0x30(%rbp)
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
pushq $0x2
popq %rdx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x21d0
movq %r12, %rdi
callq 0x2180
movq %rax, %r13
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21d0
leaq 0x1(%r13), %rdi
callq 0x325f
movq %rax, %rbx
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r13, %rdx
movq %r12, %rcx
callq 0x2080
movb $0x0, (%rbx,%r13)
movq %r12, %rdi
callq 0x20e0
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq -0x30(%rbp), %rcx
callq 0x3620
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O2/goodpaul6[P]generic/script.c
// Function: script_parse_code
void script_parse_code(script_t* script, const char* code, const char* local_path, const char* module_name)
{
	g_file = local_path;
	g_code = code;
	g_line = 1;
	
	// NOTE: adding the current module in and parsing it
	int current_module_index = add_module(script, local_path, module_name, code);

	script_module_t* module = vec_get(&script->modules, current_module_index);
	
	if (!module->parsed)
	{
		g_cur_module_index = current_module_index;
			
		parse_program(script, &module->expr_list);
		module->parsed = 1;
	}

	// NOTE: parse any unparsed modules
	for(int i = 0; i < script->modules.length; ++i)
	{
		script_module_t* module = vec_get(&script->modules, i);
		
		if(!module->parsed)
		{
			g_file = module->local_path;
			g_line = 1;
			g_code = module->source_code;
			g_cur_module_index = i;
			
			// NOTE: new modules *might* result
			// in a relocation of the module values (i.e a vec_realloc call could result in the 
			// vec.data being moved somewhere else leaving this "module" pointer invalid)
			
			// NOTE: this should not be 'destroyed' because
			// it is being copied into module->expr_list 
			vector_t expr_list;
			vec_init(&expr_list, sizeof(expr_t*));
			
			parse_program(script, &expr_list);
			
			// NOTE: the module pointer must be reset for above reason
			module = vec_get(&script->modules, i);
			module->expr_list = expr_list;
			module->parsed = 1;
		}
	}
	
	if(g_has_error) error_exit("Found errors in script code. Stopping compilation\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq %rdx, 0x10b1a(%rip)     # 0x14158
movq %rsi, 0x10bfb(%rip)     # 0x14240
movl $0x1, 0x10b01(%rip)     # 0x14150
movq %rdx, %rsi
movq %rcx, %rdx
movq %rax, %rcx
callq 0x3743
movl %eax, %r15d
leaq 0x2b8(%rbx), %r14
movslq %eax, %rsi
movq %r14, %rdi
callq 0xc15c
cmpb $0x0, 0x48(%rax)
jne 0x3697
movq %rax, %r12
movl %r15d, 0x10bc6(%rip)    # 0x14248
movq %rax, %rsi
addq $0x50, %rsi
movq %rbx, %rdi
callq 0x3886
movb $0x1, 0x48(%r12)
xorl %r15d, %r15d
leaq -0x48(%rbp), %r12
pushq $0x8
popq %r13
cmpq %r15, 0x2c8(%rbx)
jbe 0x371d
movq %r14, %rdi
movq %r15, %rsi
callq 0xc15c
cmpb $0x0, 0x48(%rax)
jne 0x3718
movq 0x40(%rax), %rcx
movq %rcx, 0x10a91(%rip)     # 0x14158
movl $0x1, 0x10a7f(%rip)     # 0x14150
movq 0x30(%rax), %rax
movq %rax, 0x10b64(%rip)     # 0x14240
movl %r15d, 0x10b65(%rip)    # 0x14248
movq %r12, %rdi
movq %r13, %rsi
callq 0xbf0c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3886
movq %r14, %rdi
movq %r15, %rsi
callq 0xc15c
movups -0x48(%rbp), %xmm0
movups -0x38(%rbp), %xmm1
movups %xmm0, 0x50(%rax)
movups %xmm1, 0x60(%rax)
movb $0x1, 0x48(%rax)
incq %r15
jmp 0x36a2
cmpb $0x0, 0x10b28(%rip)     # 0x1424c
jne 0x3735
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa067(%rip), %rdi      # 0xd7a3
xorl %eax, %eax
callq 0x34e8