LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/tomka[P]cliaspora/http.c
// Function: get_http_status
int
get_http_status(ssl_conn_t *cp)
{
	char *p, *q;

	while ((p = ssl_readln(cp)) != NULL) {
		if (strncmp(p, "HTTP/", 5) == 0) {
			for (q = p; (q = strtok(q, " ")) != NULL; q = NULL) {
				if (isdigit(*q))
					return (strtol(q, NULL, 10));
			}
			warnx("Unexpected server reply: %s", p);
			return (-1);
		}
	}
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa790
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xb086
movq -0x18(%rbp), %rdi
leaq 0x48a5(%rip), %rsi      # 0xf893
movl $0x5, %edx
callq 0x2180
cmpl $0x0, %eax
jne 0xb081
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x399e(%rip), %rsi      # 0xe9b2
callq 0x2510
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xb066
callq 0x2300
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0xb05a
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x2470
movl %eax, -0x4(%rbp)
jmp 0xb08d
jmp 0xb05c
movq $0x0, -0x20(%rbp)
jmp 0xb009
movq -0x18(%rbp), %rsi
leaq 0x4828(%rip), %rdi      # 0xf899
movb $0x0, %al
callq 0x22f0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb08d
jmp 0xafcc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
leaq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x48, %edx
callq 0x21d0
movq -0x30(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movl $0x1, -0x7c(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xaa60
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0xb126
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb187
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2160
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq %rax, %rdx
callq 0xa550
cmpl $-0x1, %eax
jne 0xb172
movq -0x38(%rbp), %rdi
callq 0x23d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb187
movq -0x38(%rbp), %rdi
callq 0x23d0
movq -0x10(%rbp), %rdi
callq 0xafc0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xa0, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
leaq -0x88(%rbp), %rdi
xorl %esi, %esi
movl $0x48, %edx
callq 0x21d0
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x58(%rbp)
movl $0x2, -0x84(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpl $0x1, -0x34(%rbp)
jne 0xb22b
leaq 0x4690(%rip), %rax      # 0xf8b5
movq %rax, -0x68(%rbp)
jmp 0xb24b
cmpl $0x2, -0x34(%rbp)
jne 0xb23e
leaq 0x469d(%rip), %rax      # 0xf8d5
movq %rax, -0x68(%rbp)
jmp 0xb249
leaq 0x46a9(%rip), %rax      # 0xf8ee
movq %rax, -0x68(%rbp)
jmp 0xb24b
cmpq $0x0, 0x10(%rbp)
je 0xb261
movq 0x10(%rbp), %rdi
callq 0x2160
movl %eax, -0x88(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xaa60
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0xb283
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb30f
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x40(%rbp), %rdi
callq 0x2160
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq %rax, %rdx
callq 0xa550
cmpl $-0x1, %eax
jne 0xb2cf
movq -0x40(%rbp), %rdi
callq 0x23d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb30f
movq -0x40(%rbp), %rdi
callq 0x23d0
cmpq $0x0, 0x10(%rbp)
je 0xb303
movq -0x10(%rbp), %rdi
movq 0x10(%rbp), %rsi
movslq -0x88(%rbp), %rdx
callq 0xa550
cmpl $-0x1, %eax
jne 0xb301
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb30f
jmp 0xb303
movq -0x10(%rbp), %rdi
callq 0xafc0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
movl $0x48, %edx
callq 0x21d0
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x3, -0x74(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xaa60
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xb39a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb3f5
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2160
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq %rax, %rdx
callq 0xa550
cmpl $-0x1, %eax
jne 0xb3e0
movq -0x30(%rbp), %rdi
callq 0x23d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb3f5
movq -0x30(%rbp), %rdi
callq 0x23d0
movq -0x10(%rbp), %rdi
callq 0xafc0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
je 0xb801
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
sarl $0x4, %eax
cmpl $0xf, %eax
jne 0xb723
movq -0x10(%rbp), %rdi
callq 0x2160
cmpq $0x4, %rax
jae 0xb6d6
movl $0x0, -0x4(%rbp)
jmp 0xb808
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
sarl $0x6, %eax
cmpl $0x2, %eax
jne 0xb706
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
sarl $0x6, %eax
cmpl $0x2, %eax
jne 0xb706
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
sarl $0x6, %eax
cmpl $0x2, %eax
je 0xb712
movl $0x0, -0x4(%rbp)
jmp 0xb808
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0xb7fc
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
sarl $0x5, %eax
cmpl $0x7, %eax
jne 0xb787
movq -0x10(%rbp), %rdi
callq 0x2160
cmpq $0x3, %rax
jae 0xb74d
movl $0x0, -0x4(%rbp)
jmp 0xb808
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
sarl $0x6, %eax
cmpl $0x2, %eax
jne 0xb76d
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
sarl $0x6, %eax
cmpl $0x2, %eax
je 0xb779
movl $0x0, -0x4(%rbp)
jmp 0xb808
movq -0x10(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x10(%rbp)
jmp 0xb7fa
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
sarl $0x6, %eax
cmpl $0x3, %eax
jne 0xb7d5
movq -0x10(%rbp), %rdi
callq 0x2160
cmpq $0x2, %rax
jae 0xb7ae
movl $0x0, -0x4(%rbp)
jmp 0xb808
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
sarl $0x6, %eax
cmpl $0x2, %eax
je 0xb7c7
movl $0x0, -0x4(%rbp)
jmp 0xb808
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
jmp 0xb7f8
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x7f, %eax
jle 0xb7ea
movl $0x0, -0x4(%rbp)
jmp 0xb808
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xb7f8
jmp 0xb7fa
jmp 0xb7fc
jmp 0xb69c
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomka[P]cliaspora/json.c
// Function: new_json_node
json_node_t *
new_json_node()
{
	json_node_t *node;

	if ((node = malloc(sizeof(json_node_t))) == NULL)
		return (NULL);
	node->var  = NULL;
	node->val  = NULL;
	node->next = NULL;
	node->type = JSON_TYPE_UNDEF;

	return (node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x20, %edi
callq 0x2430
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0xb846
movq $0x0, -0x8(%rbp)
jmp 0xb879
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xb903
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4, %eax
je 0xb8bb
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3, %eax
jne 0xb8ca
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xb890
jmp 0xb903
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x23d0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x23d0
movq -0x8(%rbp), %rdi
callq 0x23d0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb89c
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xc4c4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xc472
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2460
cmpl $0x0, %eax
jne 0xc472
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc4cc
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4, %eax
je 0xc48a
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3, %eax
jne 0xc4b1
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xc430
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xc4af
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc4cc
jmp 0xc4b1
jmp 0xc4b3
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xc440
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/tomka[P]cliaspora/json.c
// Function: json_add_node
json_node_t *
json_add_node(json_node_t *node)
{
	for (; node != NULL && node->next != NULL; node = node->next)
		;
	if (node == NULL)
		return (NULL);
	return ((node->next = new_json_node()));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
je 0xc507
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xc510
jmp 0xc520
jmp 0xc512
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xc4ec
cmpq $0x0, -0x10(%rbp)
jne 0xc531
movq $0x0, -0x8(%rbp)
jmp 0xc542
callq 0xb820
movq -0x10(%rbp), %rcx
movq %rax, 0x18(%rcx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0xffff, -0x4(%rbp)     # imm = 0xFFFF
jbe 0xc818
movl $0x4, -0x14(%rbp)
movl -0x4(%rbp), %eax
shrl $0x12, %eax
andl $0x7, %eax
addl $0xf0, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl -0x4(%rbp), %eax
shrl $0xc, %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x4(%rbp), %eax
shrl $0x6, %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0x4(%rbp), %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
jmp 0xc8ba
cmpl $0xff, -0x4(%rbp)
jbe 0xc86b
movl $0x3, -0x14(%rbp)
movl -0x4(%rbp), %eax
shrl $0xc, %eax
andl $0xf, %eax
addl $0xe0, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl -0x4(%rbp), %eax
shrl $0x6, %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x4(%rbp), %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
jmp 0xc8b8
cmpl $0x7f, -0x4(%rbp)
jbe 0xc8a4
movl $0x2, -0x14(%rbp)
movl -0x4(%rbp), %eax
shrl $0x6, %eax
andl $0x1f, %eax
addl $0xc0, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl -0x4(%rbp), %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
jmp 0xc8b6
movl $0x1, -0x14(%rbp)
movl -0x4(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0xc8b8
jmp 0xc8ba
movl -0x14(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xc960
cmpl $0x0, %eax
je 0xc955
callq 0xc9d0
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0xc953
movq -0x8(%rbp), %rdi
callq 0x2570
cmpl $-0x1, %eax
jne 0xc951
movq -0x8(%rbp), %rsi
leaq 0x3247(%rip), %rdi      # 0xfb91
movb $0x0, %al
callq 0x2120
jmp 0xc953
jmp 0xc955
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
callq 0xc9d0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0xc983
movl $0x0, -0x4(%rbp)
jmp 0xc9c4
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x2280
cmpl $-0x1, %eax
jne 0xc9bd
callq 0x2060
cmpl $0x2, (%rax)
je 0xc9b4
movq -0x10(%rbp), %rsi
leaq 0x3272(%rip), %rdi      # 0xfc1f
movb $0x0, %al
callq 0x2120
movl $0x0, -0x4(%rbp)
jmp 0xc9c4
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpq $0x0, 0x62b0(%rip)      # 0x12c90
je 0xc9f2
movq 0x62a7(%rip), %rax      # 0x12c90
movq %rax, -0x8(%rbp)
jmp 0xca9e
callq 0x2190
movl %eax, %edi
callq 0x2390
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xca20
leaq 0x2af6(%rip), %rdi      # 0xf505
movb $0x0, %al
callq 0x22f0
movq $0x0, -0x8(%rbp)
jmp 0xca9e
callq 0x2380
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2160
addq $0x14, %rax
addq $0x2, %rax
movl %eax, -0xc(%rbp)
movslq -0xc(%rbp), %rdi
callq 0x2430
movq %rax, 0x6243(%rip)      # 0x12c90
cmpq $0x0, %rax
jne 0xca6b
leaq 0x2184(%rip), %rdi      # 0xebde
movb $0x0, %al
callq 0x2120
movq $0x0, -0x8(%rbp)
jmp 0xca9e
movq 0x621e(%rip), %rdi      # 0x12c90
movslq -0xc(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
leaq 0x2aa7(%rip), %rdx      # 0xf52c
leaq 0x317e(%rip), %r8       # 0xfc0a
movb $0x0, %al
callq 0x2540
movq 0x61f6(%rip), %rax      # 0x12c90
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomka[P]cliaspora/file.c
// Function: get_input
char *
get_input(bool fromstdin)
{
	int  c;
	FILE *fp;
	char *path, *buf;

	if (fromstdin) {
		if ((buf = read_file(stdin)) == NULL)
			errx(EXIT_FAILURE, "Failed to read file");
		return (buf);
	}
	if (have_postponed()) {
		do {
			(void)fputs("\nEdit postponed file? (y/n) ", stderr);
			c = tolower(fgetc(stdin));
		} while (c != 'y' && c != 'n');
		if (c == 'y')
			path = get_postponed_path();
		else
			path = NULL;
	} else
		path = NULL;
	do {
		path = edit_file(path);
		if (path == NULL)
			errx(EXIT_FAILURE, "Failed to edit file");
		else
			write_postponed(path);
		do {
			(void)fputs("\nReady to send? (y/n) ", stderr);
			c = tolower(fgetc(stdin));
		} while (c != 'y' && c != 'n');
	} while (c != 'y');
	if ((fp = fopen(path, "r")) == NULL)
		err(EXIT_FAILURE, "fopen(%s)", path);
	if ((buf = read_file(fp)) == NULL)
		errx(EXIT_FAILURE, "Failed to read file");
	delete_tmpfile();
	return (buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xcb2a
movq 0x54d8(%rip), %rax      # 0x11fd0
movq (%rax), %rdi
callq 0xcca0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xcb1d
movl $0x1, %edi
leaq 0x3098(%rip), %rsi      # 0xfbae
movb $0x0, %al
callq 0x25a0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcc93
callq 0xc960
cmpl $0x0, %eax
je 0xcb9c
jmp 0xcb36
movq 0x549b(%rip), %rax      # 0x11fd8
movq (%rax), %rsi
leaq 0x307b(%rip), %rdi      # 0xfbc2
callq 0x2360
movq 0x547d(%rip), %rax      # 0x11fd0
movq (%rax), %rdi
callq 0x2520
movl %eax, %edi
callq 0x24c0
movl %eax, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x79, -0x10(%rbp)
movb %al, -0x29(%rbp)
je 0xcb7a
cmpl $0x6e, -0x10(%rbp)
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xcb36
cmpl $0x79, -0x10(%rbp)
jne 0xcb92
callq 0xc9d0
movq %rax, -0x20(%rbp)
jmp 0xcb9a
movq $0x0, -0x20(%rbp)
jmp 0xcba4
movq $0x0, -0x20(%rbp)
jmp 0xcba6
movq -0x20(%rbp), %rdi
callq 0xce00
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xcbcd
movl $0x1, %edi
leaq 0x3019(%rip), %rsi      # 0xfbdf
movb $0x0, %al
callq 0x25a0
movq -0x20(%rbp), %rdi
callq 0xcfb0
jmp 0xcbd8
movq 0x53f9(%rip), %rax      # 0x11fd8
movq (%rax), %rsi
leaq 0x300a(%rip), %rdi      # 0xfbf3
callq 0x2360
movq 0x53db(%rip), %rax      # 0x11fd0
movq (%rax), %rdi
callq 0x2520
movl %eax, %edi
callq 0x24c0
movl %eax, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x79, -0x10(%rbp)
movb %al, -0x2a(%rbp)
je 0xcc1c
cmpl $0x6e, -0x10(%rbp)
setne %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0xcbd8
jmp 0xcc25
cmpl $0x79, -0x10(%rbp)
jne 0xcba6
movq -0x20(%rbp), %rdi
leaq 0x1ddc(%rip), %rsi      # 0xea16
callq 0x23b0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xcc60
movq -0x20(%rbp), %rdx
movl $0x1, %edi
leaq 0x28e6(%rip), %rsi      # 0xf53f
movb $0x0, %al
callq 0x2270
movq -0x18(%rbp), %rdi
callq 0xcca0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xcc86
movl $0x1, %edi
leaq 0x2f2f(%rip), %rsi      # 0xfbae
movb $0x0, %al
callq 0x25a0
callq 0xcab0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x2000, %edi           # imm = 0x2000
callq 0x2430
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xcceb
leaq 0x1f07(%rip), %rdi      # 0xebde
movb $0x0, %al
callq 0x2120
movq $0x0, -0x8(%rbp)
jmp 0xcdf5
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x2000, %rax           # imm = 0x2000
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x1, %esi
movl $0x2000, %edx           # imm = 0x2000
callq 0x24e0
movq %rax, -0x38(%rbp)
cmpq $0x2000, %rax           # imm = 0x2000
jne 0xcda6
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x2000, %rax           # imm = 0x2000
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2550
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xcd82
leaq 0x1593(%rip), %rdi      # 0xe2fb
movb $0x0, %al
callq 0x2120
movq -0x18(%rbp), %rdi
callq 0x23d0
movq $0x0, -0x8(%rbp)
jmp 0xcdf5
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
subq $0x1, %rcx
shlq $0xd, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0xcd0d
movq -0x10(%rbp), %rdi
callq 0x2500
cmpl $0x0, %eax
jne 0xcdd5
leaq 0x2ee2(%rip), %rdi      # 0xfc9d
movb $0x0, %al
callq 0x2120
movq -0x18(%rbp), %rdi
callq 0x23d0
movq $0x0, -0x8(%rbp)
jmp 0xcdf5
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
subq $0x1, %rcx
shlq $0xd, %rcx
addq -0x38(%rbp), %rcx
movb $0x0, (%rax,%rcx)
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/tomka[P]cliaspora/file.c
// Function: edit_file
static char *
edit_file(char *path)
{
	int  fd;
	char *editor, *cmd;

	if (path == NULL) {
		if ((fd = mkstemp(tmp_path)) == -1) {
			warn("mkstemp()"); return (NULL);
		}
		(void)close(fd); path = tmp_path;
	}
	if (cfg.editor == NULL || cfg.editor[0] == '\0') {
		if ((editor = getenv("EDITOR")) == NULL) {
			warnx("Environment variable EDITOR not defined. " \
			    "Using %s", DEFAULT_EDITOR);
			editor = DEFAULT_EDITOR;
		}
	} else
		editor = cfg.editor;
	if ((cmd = malloc(strlen(editor) + strlen(path) + 4)) == NULL) {
		warn("malloc()"); return (NULL);
	}
	(void)sprintf(cmd, "%s %s", editor, path);
	switch (system(cmd)) {
	case  -1:
		warn("system(%s)", cmd); free(cmd);
		return (NULL);
	case 127:
		warnx("Failed to execute command '%s'", cmd);
		free(cmd);
		return (NULL);
	}
	free(cmd);

	return (path);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xce55
leaq 0x5576(%rip), %rdi      # 0x12390
callq 0x2110
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
jne 0xce42
leaq 0x276e(%rip), %rdi      # 0xf59c
movb $0x0, %al
callq 0x2120
movq $0x0, -0x8(%rbp)
jmp 0xcf9c
movl -0x14(%rbp), %edi
callq 0x25d0
leaq 0x553f(%rip), %rax      # 0x12390
movq %rax, -0x10(%rbp)
leaq 0x55b4(%rip), %rax      # 0x12410
cmpq $0x0, 0x20(%rax)
je 0xce76
leaq 0x55a6(%rip), %rax      # 0x12410
movq 0x20(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xceae
leaq 0x2dab(%rip), %rdi      # 0xfc28
callq 0x2400
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xceac
leaq 0x2d9c(%rip), %rdi      # 0xfc2f
leaq 0x2dc7(%rip), %rsi      # 0xfc61
movb $0x0, %al
callq 0x22f0
leaq 0x2db9(%rip), %rax      # 0xfc61
movq %rax, -0x20(%rbp)
jmp 0xcebd
leaq 0x555b(%rip), %rax      # 0x12410
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2160
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2160
movq -0x30(%rbp), %rdi
addq %rax, %rdi
addq $0x4, %rdi
callq 0x2430
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xcf08
leaq 0x1cea(%rip), %rdi      # 0xebde
movb $0x0, %al
callq 0x2120
movq $0x0, -0x8(%rbp)
jmp 0xcf9c
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x2d52(%rip), %rsi      # 0xfc6d
xorl %eax, %eax
callq 0x20d0
movq -0x28(%rbp), %rdi
callq 0x2240
movl %eax, %ecx
movl %ecx, -0x34(%rbp)
subl $-0x1, %eax
je 0xcf41
jmp 0xcf37
movl -0x34(%rbp), %eax
subl $0x7f, %eax
je 0xcf66
jmp 0xcf8b
movq -0x28(%rbp), %rsi
leaq 0x2d27(%rip), %rdi      # 0xfc73
movb $0x0, %al
callq 0x2120
movq -0x28(%rbp), %rdi
callq 0x23d0
movq $0x0, -0x8(%rbp)
jmp 0xcf9c
movq -0x28(%rbp), %rsi
leaq 0x2d0d(%rip), %rdi      # 0xfc7e
movb $0x0, %al
callq 0x22f0
movq -0x28(%rbp), %rdi
callq 0x23d0
movq $0x0, -0x8(%rbp)
jmp 0xcf9c
movq -0x28(%rbp), %rdi
callq 0x23d0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x4e21(%rip), %rax      # 0x11fd0
movq (%rax), %rdi
callq 0x22d0
movl %eax, %edi
leaq -0x40(%rbp), %rsi
callq 0x2340
cmpl $-0x1, %eax
jne 0xd1de
leaq 0x2af5(%rip), %rdi      # 0xfcc3
movb $0x0, %al
callq 0x2120
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd234
leaq 0x5abb(%rip), %rdi      # 0x12ca0
leaq -0x40(%rbp), %rsi
movl $0x3c, %edx
callq 0x2220
movl -0x34(%rbp), %eax
andl $-0xb, %eax
movl %eax, -0x34(%rbp)
movb $0x0, -0x2a(%rbp)
movb $0x1, -0x29(%rbp)
xorl %esi, %esi
leaq -0x40(%rbp), %rdx
movl %esi, %edi
callq 0x2420
cmpl $-0x1, %eax
jne 0xd22d
leaq 0x2ab7(%rip), %rdi      # 0xfcd4
movb $0x0, %al
callq 0x2120
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd234
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0xc(%rbp)
movq 0x4d2a(%rip), %rax      # 0x11fd0
movq (%rax), %rdi
callq 0x22d0
movl %eax, %edi
callq 0x2560
cmpl $0x0, %eax
jne 0xd2f8
movq 0x4d0f(%rip), %rax      # 0x11fd0
movq (%rax), %rdx
leaq 0x5a15(%rip), %rdi      # 0x12ce0
movl $0x80, %esi
callq 0x2530
leaq 0x5a04(%rip), %rdi      # 0x12ce0
leaq 0x2a0e(%rip), %rsi      # 0xfcf1
callq 0x2510
leaq 0x59f1(%rip), %rax      # 0x12ce0
movq %rax, -0x8(%rbp)
jmp 0xd456
callq 0xd1a0
cmpl $-0x1, %eax
jne 0xd30f
movq $0x0, -0x8(%rbp)
jmp 0xd456
movq 0x4cc2(%rip), %rax      # 0x11fd8
movq (%rax), %rsi
leaq 0x29d4(%rip), %rdi      # 0xfcf4
callq 0x2360
callq 0x2060
movl $0x0, (%rax)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rcx
xorl %eax, %eax
cmpq $0x80, %rcx
movb %al, -0xd(%rbp)
jae 0xd375
movq 0x4c80(%rip), %rax      # 0x11fd0
movq (%rax), %rdi
callq 0x22d0
movl %eax, %edi
leaq 0x597b(%rip), %rsi      # 0x12cdc
movl $0x1, %edx
callq 0x24b0
cmpq $0x0, %rax
setg %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0xd381
jmp 0xd419
movsbl 0x5954(%rip), %eax      # 0x12cdc
cmpl $0x8, %eax
je 0xd39f
movsbl 0x5948(%rip), %eax      # 0x12cdc
movzbl 0x5918(%rip), %ecx      # 0x12cb3
cmpl %ecx, %eax
jne 0xd3c6
cmpl $0x0, -0xc(%rbp)
jle 0xd3c4
movq 0x4c2c(%rip), %rax      # 0x11fd8
movq (%rax), %rsi
leaq 0x2949(%rip), %rdi      # 0xfcff
callq 0x2360
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xd414
movsbl 0x590f(%rip), %eax      # 0x12cdc
cmpl $0xa, %eax
je 0xd3de
movsbl 0x5903(%rip), %eax      # 0x12cdc
cmpl $0xd, %eax
jne 0xd3e0
jmp 0xd419
movq 0x4bf1(%rip), %rax      # 0x11fd8
movq (%rax), %rsi
movl $0x2a, %edi
callq 0x2410
movb 0x58e2(%rip), %dl       # 0x12cdc
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
movslq %eax, %rcx
leaq 0x58d1(%rip), %rax      # 0x12ce0
movb %dl, (%rax,%rcx)
jmp 0xd414
jmp 0xd337
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
movslq %eax, %rcx
leaq 0x58b2(%rip), %rax      # 0x12ce0
movb $0x0, (%rax,%rcx)
callq 0xd240
movq 0x4b9a(%rip), %rax      # 0x11fd8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x2410
leaq 0x588e(%rip), %rax      # 0x12ce0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jb 0xd532
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xd4c6
movq -0x28(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2160
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
movq -0x18(%rbp), %rcx
addq (%rcx), %rax
movq %rax, -0x38(%rbp)
jmp 0xd4d2
movq -0x28(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x2550
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xd504
leaq 0xe08(%rip), %rdi       # 0xe2fb
movb $0x0, %al
callq 0x2120
movq $0x0, -0x8(%rbp)
jmp 0xd566
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xd515
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
addq $0x20, %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rdx
addq $0x1, %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
subq %rdx, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x2200
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x27cdd(%rip), %rdi     # 0x2a004
movb $0x0, %al
callq 0x2040
leaq 0x27cf3(%rip), %rdi     # 0x2a028
movb $0x0, %al
callq 0x2040
leaq 0x27ced(%rip), %rdi     # 0x2a030
movb $0x0, %al
callq 0x2040
leaq 0x27d0c(%rip), %rdi     # 0x2a05d
movb $0x0, %al
callq 0x2040
leaq 0x27d29(%rip), %rdi     # 0x2a088
movb $0x0, %al
callq 0x2040
leaq 0x27d3b(%rip), %rdi     # 0x2a0a8
movb $0x0, %al
callq 0x2040
leaq 0x27d5f(%rip), %rdi     # 0x2a0da
movb $0x0, %al
callq 0x2040
leaq 0x27d74(%rip), %rdi     # 0x2a0fd
movb $0x0, %al
callq 0x2040
leaq 0x27d94(%rip), %rdi     # 0x2a12b
movb $0x0, %al
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %r8
leaq -0x30(%rbp), %r9
leaq -0x38(%rbp), %r11
leaq -0x40(%rbp), %r10
leaq -0x44(%rbp), %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x23b0
movl %eax, -0x48(%rbp)
cmpl $0x0, -0x48(%rbp)
je 0x2a24
movl -0x48(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2a65
cmpl $0x0, -0x44(%rbp)
je 0x2a3f
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2310
movl $0x0, -0x4(%rbp)
jmp 0x2a65
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x40(%rbp), %r9
callq 0x2620
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x300, %rsp            # imm = 0x300
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x238a
movq 0x17c92(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x10c8d(%rip), %rsi     # 0x13004
movb $0x0, %al
callq 0x2150
movl $0x1, -0x4(%rbp)
jmp 0x249f
leaq -0x2e8(%rbp), %rdi
callq 0x2550
xorl %edi, %edi
movl $0x1, %esi
callq 0x3f00
movl $0x1, %esi
movl %esi, %edi
callq 0x3f00
leaq -0x2e8(%rbp), %rdi
leaq 0x10c5f(%rip), %rsi     # 0x1301b
leaq 0x10c61(%rip), %rdx     # 0x13024
callq 0x3920
leaq -0x2e8(%rbp), %rdi
callq 0x3f20
movl $0x2, -0x2ec(%rbp)
movl -0x2ec(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x2432
movq -0x10(%rbp), %rax
movslq -0x2ec(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x10c2a(%rip), %rsi     # 0x13029
callq 0x2130
cmpl $0x0, %eax
jne 0x241f
movq 0x17bc0(%rip), %rax     # 0x19fd0
movq (%rax), %rsi
leaq -0x2e8(%rbp), %rdi
callq 0x42e0
jmp 0x2421
movl -0x2ec(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2ec(%rbp)
jmp 0x23de
movl $0x0, -0x2f0(%rbp)
movslq -0x2f0(%rbp), %rax
movq %rax, -0x2f8(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x2170
movq %rax, %rcx
movq -0x2f8(%rbp), %rax
cmpq %rcx, %rax
jge 0x248c
leaq -0x2e8(%rbp), %rdi
callq 0x4b00
movl -0x2f0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2f0(%rbp)
jmp 0x243c
leaq -0x2e8(%rbp), %rdi
callq 0x6840
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x300, %rsp            # imm = 0x300
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goodpaul6[P]generic/script.c
// Function: estrdup
static char* estrdup(const char* str)
{
	size_t length = strlen(str);
	char* cpy = emalloc(length + 1);
	strcpy(cpy, str);
	
	return cpy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0x3580
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2050
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1110, %edi           # imm = 0x1110
callq 0x3580
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x150(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl $0x40, 0x8(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x2825
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
subl -0x14(%rbp), %edx
subl $0x1, %edx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, 0xc(%rax,%rcx,4)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
addq $0x110, %rax            # imm = 0x110
movslq -0x14(%rbp), %rdx
shlq $0x6, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
addq $0x110, %rax            # imm = 0x110
movslq -0x14(%rbp), %rdx
shlq $0x6, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x27be
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x150(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x2b8, %rdi            # imm = 0x2B8
leaq 0x112(%rip), %rsi       # 0x2ec0
callq 0x11d40
movq -0x8(%rbp), %rdi
addq $0x2b8, %rdi            # imm = 0x2B8
callq 0x11da0
movq -0x8(%rbp), %rdi
callq 0x2fc0
movq -0x8(%rbp), %rax
movq $0x0, 0x150(%rax)
movq -0x8(%rbp), %rdi
callq 0x2780
movq -0x8(%rbp), %rax
movb $0x0, 0x119(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x168(%rax)
movq -0x8(%rbp), %rax
movl $0x40, 0x16c(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x11c(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0x0, 0x120(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x158(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x160(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x190(%rax)
movq -0x8(%rbp), %rdi
addq $0x170, %rdi            # imm = 0x170
callq 0x11da0
movq -0x8(%rbp), %rdi
addq $0x198, %rdi            # imm = 0x198
callq 0x11da0
movq -0x8(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
callq 0x11da0
movq -0x8(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
callq 0x11da0
movq -0x8(%rbp), %rdi
addq $0x278, %rdi            # imm = 0x278
callq 0x11da0
movq -0x8(%rbp), %rdi
addq $0x298, %rdi            # imm = 0x298
callq 0x11da0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11dc0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2030
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2030
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2030
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x60(%rcx), %rax
jae 0x2f3d
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
movslq -0x14(%rbp), %rsi
callq 0x11890
movq (%rax), %rdi
callq 0xbdb0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2f0b
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0x11dc0
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
callq 0x11dc0
movq -0x10(%rbp), %rdi
addq $0x20f0, %rdi           # imm = 0x20F0
callq 0x11dc0
movq -0x10(%rbp), %rdi
addq $0x20d0, %rdi           # imm = 0x20D0
callq 0x11dc0
movq -0x10(%rbp), %rdi
addq $0x90, %rdi
leaq 0x91a7(%rip), %rsi      # 0xc130
callq 0x11d40
movq -0x10(%rbp), %rdi
addq $0x90, %rdi
callq 0x11dc0
movq -0x10(%rbp), %rdi
addq $0xb0, %rdi
callq 0x12340
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x150(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3000
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2030
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x2fdb
movq -0x8(%rbp), %rax
movq $0x0, 0x158(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl $0x1, 0x172e0(%rip)     # 0x1a3dc
movb $0x1, 0x172ed(%rip)     # 0x1a3f0
movl $0x1, 0x1730f(%rip)     # 0x1a41c
movb $0x0, 0x1731c(%rip)     # 0x1a430
movq -0x8(%rbp), %rdi
movsbl -0x9(%rbp), %ecx
leaq 0x172ed(%rip), %rsi     # 0x1a410
leaq 0x172a6(%rip), %rax     # 0x1a3d0
cmpl $0x0, %ecx
cmovneq %rax, %rsi
callq 0x3140
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3090
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0xc(%rax)
je 0x31e9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, %ecx
leaq 0x16f69(%rip), %rax     # 0x1a140
movq (%rax,%rcx,8), %rdx
leaq 0x10573(%rip), %rsi     # 0x13755
movb $0x0, %al
callq 0x3200
movq -0x10(%rbp), %rax
movb 0x20(%rax), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)