LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/tomka[P]cliaspora/cliaspora.c
// Function: reply
static int
reply(session_t *sp, const char *msg, int msg_id)
{
	int	   ret, status;
	char	   *rq, *url, *p;
	ssl_conn_t *cp;

	errno = 0;

	if ((p = urlencode(msg)) == NULL)
		return (-1);
	if ((url = strduprintf("/conversations/%d/messages",
	    msg_id)) == NULL) {
		free(p); return (-1);
	}
	if ((rq = strduprintf("message%%5btext%%5d=%s\n", p)) == NULL) {
		free(p); free(url); return (-1);
	}
	free(p);
	if ((cp = ssl_connect(sp->host, sp->port)) == NULL)
		return (-1);
	status = http_post(cp, url, sp->cookie, NULL, USER_AGENT,
	    HTTP_POST_TYPE_FORM, rq);
	free(url); free(rq);
	if (status == HTTP_UNAUTHORIZED) {
		warnx("You're not logged in. Please create a new session");
		ret = -1;
	} else if (status == HTTP_FOUND)
		ret = 0;
	else if (status == -1)
		ret = -1;
	else {
		warnx("Server replied with code %d", status);
		ret = -1;
	}
	ssl_disconnect(cp);
	return (ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
callq 0x2060
movl $0x0, (%rax)
movq %rbx, %rdi
callq 0x81cd
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x627b
movq %rax, %r14
leaq 0x445c(%rip), %rdi      # 0xa601
movl %ebp, %esi
xorl %eax, %eax
callq 0x99a1
testq %rax, %rax
je 0x624f
movq %rax, %r12
leaq 0x445b(%rip), %rdi      # 0xa61c
movq %r14, %rsi
xorl %eax, %eax
callq 0x99a1
movq %rax, %r13
movq %r14, %rdi
callq 0x23c0
testq %r13, %r13
je 0x6254
movq (%r15), %rdi
movzwl 0x10(%r15), %esi
callq 0x7828
testq %rax, %rax
je 0x627b
movq %rax, %r14
movq 0x8(%r15), %rdx
movq %r13, (%rsp)
leaq 0x41fd(%rip), %r8       # 0xa400
xorl %ebx, %ebx
movq %rax, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
movl $0x3, %r9d
callq 0x83d9
movl %eax, %ebp
movq %r12, %rdi
callq 0x23c0
movq %r13, %rdi
callq 0x23c0
cmpl $-0x1, %ebp
je 0x626e
cmpl $0x12e, %ebp            # imm = 0x12E
je 0x6273
cmpl $0x191, %ebp            # imm = 0x191
jne 0x625e
leaq 0x41c4(%rip), %rdi      # 0xa40a
xorl %eax, %eax
callq 0x22d0
jmp 0x626e
movq %r14, %rdi
jmp 0x6257
movq %r12, %rdi
callq 0x23c0
jmp 0x627b
leaq 0x4472(%rip), %rdi      # 0xa6d7
movl %ebp, %esi
xorl %eax, %eax
callq 0x22d0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq %r14, %rdi
callq 0x7a3f
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tomka[P]cliaspora/cliaspora.c
// Function: free_contacts
static void
free_contacts(contact_t *ctp)
{

	contact_t *next;

	for (; ctp != NULL; ctp = next) {
		free(ctp->name); free(ctp->handle); 
		free(ctp->url);  free(ctp->avatar);
		next = ctp->next; free(ctp);
	}
}

// Assembly:
testq %rdi, %rdi
je 0x62d7
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rbx), %rdi
callq 0x23c0
movq 0x10(%rbx), %rdi
callq 0x23c0
movq 0x18(%rbx), %rdi
callq 0x23c0
movq 0x20(%rbx), %rdi
callq 0x23c0
movq 0x28(%rbx), %r14
movq %rbx, %rdi
callq 0x23c0
movq %r14, %rbx
testq %r14, %r14
jne 0x6298
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tomka[P]cliaspora/cliaspora.c
// Function: free_aspects
static void
free_aspects(aspect_t *aspect)
{
	aspect_t *next;

	while (aspect != NULL) {
		next = aspect->next;
		free(aspect->name); free(aspect);
		aspect = next;
	}
}

// Assembly:
testq %rdi, %rdi
je 0x6756
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %r14
callq 0x23c0
movq %rbx, %rdi
callq 0x23c0
movq %r14, %rbx
testq %r14, %r14
jne 0x6732
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tomka[P]cliaspora/cliaspora.c
// Function: groff_printf
static void
groff_printf(const char *fmt, ...)
{
	char	*str;
	va_list ap;

	va_start(ap, fmt);
	while (*fmt != '\0') {
		if (*fmt == '%') {
			if (*++fmt == '\0') {
				va_end(ap); return;
			}
		} else {
			putchar(*fmt++);
			continue;
		}
		switch(*fmt++) {
		case '%':
			putchar('%');
			break;	
		case 'c':
			(void)printf("%c", va_arg(ap, int));
			break;
		case 'd':
			(void)printf("%d", va_arg(ap, int));
			break;
		case 's':
			for (str = va_arg(ap, char *); *str != '\0'; str++) {
				if (*str == '.')
					(void)fputs("\\\[char46]", stdout);
				else if (*str == '\'')
					(void)fputs("\\\'", stdout);
				else if (*str == '\\')
					(void)fputs("\\\\", stdout);
				else 
					(void)putchar(*str);
			}
			break;
		}
	}
	va_end(ap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x67bf
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rdi, 0x10(%rsp)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsp)
movq 0x87ca(%rip), %rbp      # 0xefb0
leaq 0x417e(%rip), %r15      # 0xa96b
leaq 0x417a(%rip), %r12      # 0xa96e
leaq 0x4166(%rip), %r13      # 0xa961
movzbl (%rbx), %eax
cmpl $0x25, %eax
je 0x6818
testl %eax, %eax
je 0x693d
movsbl %al, %edi
incq %rbx
callq 0x2440
jmp 0x67fb
movzbl 0x1(%rbx), %eax
testl %eax, %eax
je 0x693d
addq $0x2, %rbx
cmpl $0x63, %eax
jg 0x6850
cmpl $0x25, %eax
je 0x6873
cmpl $0x63, %eax
jne 0x67fb
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x68a2
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x68b0
cmpl $0x64, %eax
je 0x6882
cmpl $0x73, %eax
jne 0x67fb
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x68bc
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x68ca
movl $0x25, %edi
callq 0x2440
jmp 0x67fb
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x691a
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x6928
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl (%rax), %edi
callq 0x2440
jmp 0x67fb
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %r14
movzbl (%r14), %eax
cmpl $0x2d, %eax
jle 0x68e9
cmpl $0x5c, %eax
je 0x68f7
cmpl $0x2e, %eax
jne 0x690d
movq (%rbp), %rsi
movq %r13, %rdi
jmp 0x68fe
cmpl $0x27, %eax
jne 0x6905
movq (%rbp), %rsi
movq %r15, %rdi
jmp 0x68fe
movq (%rbp), %rsi
movq %r12, %rdi
callq 0x2350
jmp 0x6915
testl %eax, %eax
je 0x67fb
movsbl %al, %edi
callq 0x2440
incq %r14
jmp 0x68cd
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl (%rax), %esi
leaq 0x4e52(%rip), %rdi      # 0xb783
xorl %eax, %eax
callq 0x2070
jmp 0x67fb
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/tomka[P]cliaspora/config.c
// Function: cfgpath
char *
cfgpath()
{
	int	      len;
	char	      *path;
	struct passwd *pw;
	
	if ((pw = getpwuid(getuid())) == NULL) {
		warnx("Couldn't find you in the password file");
		return (NULL);
	}
	endpwent();
	len = strlen(pw->pw_dir) + sizeof(PATH_CONFIG) + 1;
	if ((path = malloc(len)) == NULL) {
		warn("malloc()"); return (NULL);
	}
	(void)snprintf(path, len, "%s/%s", pw->pw_dir, PATH_CONFIG);

	return (path);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0x2180
movl %eax, %edi
callq 0x2380
testq %rax, %rax
je 0x69b0
movq %rax, %rbx
callq 0x2370
movq 0x20(%rbx), %r14
movq %r14, %rdi
callq 0x2150
addl $0xe, %eax
movslq %eax, %r15
movq %r15, %rdi
callq 0x2420
testq %rax, %rax
je 0x69c2
movq %rax, %rbx
leaq 0x4b11(%rip), %rdx      # 0xb4a8
leaq 0x4b10(%rip), %r8       # 0xb4ae
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2530
jmp 0x69d2
leaq 0x4aca(%rip), %rdi      # 0xb481
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x22d0
jmp 0x69d2
leaq 0x3cd9(%rip), %rdi      # 0xa6a2
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2110
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tomka[P]cliaspora/config.c
// Function: is_label
static bool
is_label(const char *str)
{
	const char *p;

	if (!isspace(str[0]) && str[0] != ':') {
		if ((p = strchr(str, ':')) != NULL) {
			while (isspace(*(++p)))
				;
			if (*p == '\0')
				/* Match. */
				return (true);
		}
	}
	/* No match. */
        return (false);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x22e0
movsbq (%rbx), %rcx
cmpq $0x3a, %rcx
je 0x6c90
movq (%rax), %r14
movzwl (%r14,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
jne 0x6c90
movq %rbx, %rdi
movl $0x3a, %esi
callq 0x2120
testq %rax, %rax
je 0x6c90
incq %rax
movsbq (%rax), %rcx
incq %rax
testb $0x20, 0x1(%r14,%rcx,2)
jne 0x6c7d
testb %cl, %cl
je 0x6c9a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x1, %eax
jmp 0x6c92
// File: /workspace/github_c_makefile_star2_O1/tomka[P]cliaspora/config.c
// Function: cmp_label
static bool
cmp_label(const char *l0, const char *l1)
{
	while (*l0 != ':' && *l1 != ':' && *l0 == *l1)
		l0++, l1++;
	if (*l0 == ':')
		l0++;
	if (*l1 == ':')
		l1++;
	if ((*l0 != '\0' && !isspace(*l0)) || (*l1 != '\0' && !isspace(*l1)))
		/* No match */
		return (false);
	/* Ignore trailing whitespaces */
	while (*l0 != '\0' && isspace(*l0))
		l0++;
	while (*l1 != '\0' && isspace(*l1))
		l1++;
	if (*l0 == *l1)
		/* == */
		return (true);
	/* != */
	return (false);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb (%rdi), %cl
cmpb $0x3a, %cl
sete %al
je 0x7040
cmpb (%rbx), %cl
jne 0x7040
incq %r14
incq %rbx
movq %rbx, %rcx
movq %r14, %rdx
movq %rdx, %r14
movq %rcx, %rbx
movb (%rdx), %sil
cmpb $0x3a, %sil
sete %al
je 0x7040
leaq 0x1(%r14), %rdx
leaq 0x1(%rbx), %rcx
cmpb (%rbx), %sil
je 0x7021
xorl %r15d, %r15d
cmpb $0x3a, (%rbx)
movzbl %al, %r12d
sete %bpl
movsbq (%r14,%r12), %r13
testq %r13, %r13
je 0x7068
callq 0x22e0
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r13,2)
je 0x7085
movb %bpl, %r15b
movsbq (%rbx,%r15), %r13
testq %r13, %r13
je 0x7089
callq 0x22e0
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r13,2)
jne 0x7089
xorl %eax, %eax
jmp 0x70ed
movb (%r14,%r12), %bpl
testb %bpl, %bpl
je 0x70b7
callq 0x22e0
movq (%rax), %rax
leaq (%r12,%r14), %rcx
incq %rcx
movsbq %bpl, %rdx
testb $0x20, 0x1(%rax,%rdx,2)
je 0x70b7
movb (%rcx), %bpl
incq %rcx
testb %bpl, %bpl
jne 0x70a1
movb (%rbx,%r15), %r14b
testb %r14b, %r14b
je 0x70e5
callq 0x22e0
movq (%rax), %rax
leaq (%r15,%rbx), %rcx
incq %rcx
movsbq %r14b, %rdx
testb $0x20, 0x1(%rax,%rdx,2)
je 0x70e5
movb (%rcx), %r14b
incq %rcx
testb %r14b, %r14b
jne 0x70cf
xorl %eax, %eax
cmpb %r14b, %bpl
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tomka[P]cliaspora/config.c
// Function: write_var
static int
write_var(var_t *var, FILE *fp)
{
	char *p, **s;

	if (var == NULL)
		return (0);

	switch (var->type) {
	case VAR_STRING:
		if (*var->val.string == NULL)
			return (0);
		p = escape_str(*var->val.string);
		if (p == NULL)
			return (-1);
		(void)fprintf(fp, "%s = \"%s\"\n",
		    var->name, p);
		free(p);
		break;
	case VAR_STRINGS:
		(void)fprintf(fp, "%s = ", var->name);
		for (s = *var->val.strings;
		    s != NULL && *s != NULL; s++) {
			if (s != *var->val.strings)
				(void)fputc(' ', fp);
			p = escape_str(*s);
			if (p == NULL)
				return (-1);
			(void)fprintf(fp, "\"%s\"", p);
			free(p);
		}
		(void)fputc('\n', fp);
		break;
	case VAR_INTEGER:
		(void)fprintf(fp, "%s = %d\n", var->name, *var->val.integer);
		break;
	case VAR_BOOLEAN:
		(void)fprintf(fp, "%s = %s\n", var->name,
		    *var->val.boolean ? "true" : "false");
		break;
	}
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x7615
movq %rdi, %r14
movl 0xc(%rdi), %eax
cmpq $0x3, %rax
ja 0x7615
movq %rsi, %rbx
leaq 0x3f84(%rip), %rcx      # 0xb460
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%r14), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x7615
callq 0x77da
testq %rax, %rax
je 0x7615
movq %rax, %r15
movq (%r14), %rdx
leaq 0x40ed(%rip), %rsi      # 0xb5fd
movq %rbx, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0x2490
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x23c0
movq (%r14), %rdx
movq 0x10(%r14), %rax
movl (%rax), %ecx
leaq 0x40d5(%rip), %rsi      # 0xb613
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2490
movq (%r14), %rdx
movq 0x10(%r14), %rax
cmpl $0x0, (%rax)
leaq 0x401c(%rip), %rax      # 0xb57e
leaq 0x40bc(%rip), %rcx      # 0xb625
cmoveq %rax, %rcx
leaq 0x40a8(%rip), %rsi      # 0xb61c
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2490
movq (%r14), %rdx
leaq 0x4077(%rip), %rsi      # 0xb608
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2490
movq 0x10(%r14), %rax
movq (%rax), %r13
testq %r13, %r13
je 0x75ff
cmpq $0x0, (%r13)
je 0x75ff
leaq 0x4059(%rip), %r15      # 0xb60e
movq 0x10(%r14), %rax
cmpq (%rax), %r13
je 0x75cb
movl $0x20, %edi
movq %rbx, %rsi
callq 0x2400
movq (%r13), %rdi
callq 0x77da
testq %rax, %rax
je 0x7615
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2490
movq %r12, %rdi
callq 0x23c0
cmpq $0x0, 0x8(%r13)
leaq 0x8(%r13), %r13
jne 0x75b5
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2400
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tomka[P]cliaspora/config.c
// Function: escape_str
static char *
escape_str(const char *str)
{
	char *p, *esc;

	if ((esc = malloc(2 * strlen(str) + 1)) == NULL)
		return (NULL);
	for (p = esc; *str != '\0'; str++) {
		if (*str == '"' || *str == '\\')
			*p++ = '\\';
		*p++ = *str;
	}
	*p = '\0';

	return (esc);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2150
leaq 0x1(,%rax,2), %rdi
callq 0x2420
testq %rax, %rax
je 0x7822
movq %rax, %rcx
movzbl (%rbx), %edx
cmpl $0x22, %edx
je 0x780b
cmpl $0x5c, %edx
je 0x780b
testl %edx, %edx
jne 0x7811
jmp 0x781d
movb $0x5c, (%rcx)
incq %rcx
movb (%rbx), %dl
movb %dl, (%rcx)
incq %rcx
incq %rbx
jmp 0x77f8
movb $0x0, (%rcx)
jmp 0x7824
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/tomka[P]cliaspora/ssl.c
// Function: ssl_disconnect
void
ssl_disconnect(ssl_conn_t *cp)
{
	int saved_errno;

	saved_errno = errno;
	(void)close(cp->sock);
	SSL_shutdown(cp->handle);
	SSL_free(cp->handle);
	SSL_CTX_free(cp->ctx);
	free(cp->host);
	free(cp->lnbuf);
	free(cp);
	errno = saved_errno;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2060
movq %rax, %r14
movl (%rax), %ebp
movl 0xc(%rbx), %edi
callq 0x25c0
movq 0x28(%rbx), %rdi
callq 0x2340
movq 0x28(%rbx), %rdi
callq 0x21c0
movq 0x30(%rbx), %rdi
callq 0x2090
movq 0x18(%rbx), %rdi
callq 0x23c0
movq 0x20(%rbx), %rdi
callq 0x23c0
movq %rbx, %rdi
callq 0x23c0
movl %ebp, (%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tomka[P]cliaspora/ssl.c
// Function: ssl_write
int
ssl_write(ssl_conn_t *cp, const void *buf, size_t size)
{
	int	       n, ec;
	fd_set	       wset;
	struct timeval tv;

	for (n = -1; n < 0;) {
		tv.tv_sec = 20; tv.tv_usec = 0;
		FD_ZERO(&wset); FD_SET(cp->sock, &wset);
		while (select(cp->sock + 1, NULL, &wset, NULL, &tv) == -1) {
			if (errno != EINTR) {
				warn("ssl_write(): select()");
				return (-1);
			}
		}
		if (!FD_ISSET(cp->sock, &wset)) {
			warnx("ssl_write(): Timeout");
			return (TIMEOUT);
		}
		if ((n = SSL_write(cp->handle, buf, size)) < 0) {
			switch ((ec = SSL_get_error(cp->handle, n))) {
			case SSL_ERROR_WANT_READ:
			case SSL_ERROR_WANT_WRITE:
				/* FALLTHROUGH */
				break;
			default:
				if (errno != 0) {
					warn("SSL_write() returned with %d," \
					     "SSL-error code %d", n, ec);
				} else {
					warnx("SSL_write() returned with %d," \
					      "SSL-error code %d", n, ec);
				}
				ERR_print_errors_fp(stderr);
				return (-1);
			}
		}
	}
	if (n == 0)
		cp->state = SSL_STATE_DISCONNECTED;
	return (n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r12
leaq 0x10(%rsp), %r13
movq $0x14, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x90(%rsp)
movl 0xc(%rbx), %ecx
leal 0x3f(%rcx), %eax
testl %ecx, %ecx
cmovnsl %ecx, %eax
movl %eax, %edx
andl $-0x40, %edx
subl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
sarl $0x6, %eax
cltq
orq %rdx, 0x20(%rsp,%rax,8)
movl 0xc(%rbx), %edi
incl %edi
xorl %esi, %esi
movq %r12, %rdx
xorl %ecx, %ecx
movq %r13, %r8
callq 0x2270
cmpl $-0x1, %eax
jne 0x7d1d
callq 0x2060
cmpl $0x4, (%rax)
je 0x7cf8
jmp 0x7d8a
movl 0xc(%rbx), %eax
leal 0x3f(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
sarl $0x6, %ecx
movslq %ecx, %rcx
movq 0x20(%rsp,%rcx,8), %rcx
btq %rax, %rcx
jae 0x7db1
movq 0x28(%rbx), %rdi
movq %r15, 0x8(%rsp)
movq %r15, %rsi
movq %r14, %r15
movl %r14d, %edx
callq 0x25a0
movl %eax, %ebp
testl %eax, %eax
jns 0x7d6c
movq 0x28(%rbx), %rdi
movl %ebp, %esi
callq 0x2040
movl %eax, %r14d
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0x7dc3
testl %ebp, %ebp
movq %r15, %r14
movq 0x8(%rsp), %r15
xorps %xmm0, %xmm0
js 0x7c94
jne 0x7d9d
movl $0x0, 0x10(%rbx)
jmp 0x7d9d
leaq 0x3900(%rip), %rdi      # 0xb691
xorl %eax, %eax
callq 0x2110
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x38ef(%rip), %rdi      # 0xb6a7
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x22d0
jmp 0x7d9d
callq 0x2060
cmpl $0x0, (%rax)
je 0x7de2
leaq 0x38e8(%rip), %rdi      # 0xb6bc
movl %ebp, %esi
movl %r14d, %edx
xorl %eax, %eax
callq 0x2110
jmp 0x7df5
leaq 0x38d3(%rip), %rdi      # 0xb6bc
movl %ebp, %esi
movl %r14d, %edx
xorl %eax, %eax
callq 0x22d0
movq 0x71dc(%rip), %rax      # 0xefd8
movq (%rax), %rdi
callq 0x21b0
jmp 0x7d98
// File: /workspace/github_c_makefile_star2_O1/tomka[P]cliaspora/ssl.c
// Function: ssl_readln
char *
ssl_readln(ssl_conn_t *cp)
{
	int  i, n;
	char *p;
	
	if (cp->lnbuf == NULL) {
		if ((cp->lnbuf = malloc(_POSIX2_LINE_MAX)) == NULL)
			return (NULL);
		cp->bufsz = _POSIX2_LINE_MAX;
	}
	n = 0;
	do {
		cp->rd += n;
		if (cp->slen > 0) {
			for (i = 0; i < cp->rd - cp->slen; i++)
				cp->lnbuf[i] = cp->lnbuf[i + cp->slen];
		}
		cp->rd	-= cp->slen;
		cp->slen = 0;
		for (i = 0; i < cp->rd && cp->lnbuf[i] != '\n'; i++)
			;
		if (i < cp->rd && cp->lnbuf[i] == '\n') {
			if (i > 0 && cp->lnbuf[i - 1] == '\r')
				cp->lnbuf[i - 1] = '\0';
			cp->slen = i + 1;
			if (cp->slen >= cp->bufsz)
				cp->slen = cp->rd = 0;
			cp->lnbuf[i] = '\0';
			return (cp->lnbuf);
		}
		if (cp->rd >= cp->bufsz) {
			p = realloc(cp->lnbuf, cp->bufsz + _POSIX2_LINE_MAX);
			if (p == NULL)
				return (NULL);
			cp->lnbuf  = p;
			cp->bufsz += _POSIX2_LINE_MAX;
		}
	} while ((n = ssl_read(cp, 20, cp->lnbuf + cp->rd,
	    cp->bufsz - cp->rd)) > 0);
	if (cp->rd > 0) {
		cp->lnbuf[cp->rd] = '\0';
		cp->slen = cp->rd = 0;
		return (cp->lnbuf);
	}
	cp->slen = cp->rd = 0;

	return (NULL);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
jne 0x7e31
movl $0x800, %edi            # imm = 0x800
callq 0x2420
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x7f35
movl $0x800, (%rbx)          # imm = 0x800
xorl %r14d, %r14d
xorl %eax, %eax
addl %eax, 0x4(%rbx)
cmpl $0x0, 0x8(%rbx)
jle 0x7e6a
movl 0x8(%rbx), %eax
cmpl %eax, 0x4(%rbx)
jle 0x7e6a
xorl %ecx, %ecx
movq 0x20(%rbx), %rdx
addl %ecx, %eax
cltq
movb (%rdx,%rax), %al
movb %al, (%rdx,%rcx)
incq %rcx
movslq 0x4(%rbx), %rdx
movslq 0x8(%rbx), %rax
subq %rax, %rdx
cmpq %rdx, %rcx
jl 0x7e49
movl 0x4(%rbx), %eax
movl 0x8(%rbx), %ecx
movl %eax, %edx
subl %ecx, %edx
testl %edx, %edx
setg %dl
subl %ecx, %eax
movl %eax, 0x4(%rbx)
movl $0x0, 0x8(%rbx)
jle 0x7ec7
movq 0x20(%rbx), %rsi
cmpb $0xa, (%rsi)
jne 0x7e94
xorl %ecx, %ecx
jmp 0x7eb7
movl %eax, %edx
leaq -0x1(%rdx), %rdi
xorl %r8d, %r8d
cmpq %r8, %rdi
je 0x7ec7
leaq 0x1(%r8), %rcx
cmpb $0xa, 0x1(%rsi,%r8)
movq %rcx, %r8
jne 0x7e9d
cmpq %rdx, %rcx
setb %dl
testb %dl, %dl
je 0x7ec7
movq 0x20(%rbx), %rsi
movl %ecx, %edx
cmpb $0xa, (%rsi,%rdx)
je 0x7f3a
movslq (%rbx), %rsi
cmpl %esi, %eax
jl 0x7ef1
movq 0x20(%rbx), %rdi
addq $0x800, %rsi            # imm = 0x800
callq 0x2540
testq %rax, %rax
je 0x7f69
movq %rax, 0x20(%rbx)
addl $0x800, (%rbx)          # imm = 0x800
movslq 0x4(%rbx), %rdx
movl (%rbx), %ecx
subl %edx, %ecx
addq 0x20(%rbx), %rdx
movq %rbx, %rdi
movl $0x14, %esi
callq 0x7a95
testl %eax, %eax
jg 0x7e36
movslq 0x4(%rbx), %rax
testq %rax, %rax
jle 0x7f2d
movq 0x20(%rbx), %rcx
movb $0x0, (%rcx,%rax)
movq $0x0, 0x4(%rbx)
jmp 0x7f65
movq $0x0, 0x4(%rbx)
xorl %r14d, %r14d
jmp 0x7f69
testq %rcx, %rcx
je 0x7f4b
cmpb $0xd, -0x1(%rsi,%rdx)
jne 0x7f4b
movb $0x0, -0x1(%rsi,%rdx)
leal 0x1(%rcx), %eax
movl %eax, 0x8(%rbx)
cmpl (%rbx), %eax
jl 0x7f5d
movq $0x0, 0x4(%rbx)
movq 0x20(%rbx), %rax
movb $0x0, (%rax,%rdx)
movq 0x20(%rbx), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tomka[P]cliaspora/http.c
// Function: urlencode
char *
urlencode(const char *url)
{
	int	   n, buflen = 0;
	char	   *buf = NULL;
	const char nores[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" \
			     "abcdefghijklmnopqrstuvwxyz" \
			     "0123456789-_.~";

	if (url == NULL)
		return (NULL);
	buflen = strlen(url) * 3 + 1;
	if ((buf = malloc(buflen)) == NULL)
		return (NULL);
	for (n = 0; *url != '\0'; n++, url++) {
		if (strchr(nores, (int)*url) == NULL) {
			(void)snprintf(&buf[n], buflen - n, "%%%02x",
			    (u_char)*url);
			n += 2;
		} else
			buf[n] = *url;
	}
	buf[n] = '\0';
	return (buf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x36eb(%rip), %rsi      # 0xb8d0
movq %rsp, %rax
movl $0x8, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movb $0x0, 0x42(%rax)
movw $0x7e2e, 0x40(%rax)     # imm = 0x7E2E
testq %rbx, %rbx
je 0x8288
movq %rbx, %rdi
callq 0x2150
leal (%rax,%rax,2), %ebp
incl %ebp
movslq %ebp, %rdi
callq 0x2420
testq %rax, %rax
je 0x8288
movq %rax, %r14
movb (%rbx), %r12b
xorl %eax, %eax
testb %r12b, %r12b
je 0x8281
incq %rbx
movq %rsp, %r15
xorl %r13d, %r13d
movsbl %r12b, %esi
movq %r15, %rdi
callq 0x2120
movslq %r13d, %rdi
addq %r14, %rdi
testq %rax, %rax
je 0x8252
movb %r12b, (%rdi)
jmp 0x8270
movl %ebp, %eax
subl %r13d, %eax
movslq %eax, %rsi
movzbl %r12b, %ecx
leaq 0x35a3(%rip), %rdx      # 0xb808
xorl %eax, %eax
callq 0x2530
addl $0x2, %r13d
incl %r13d
movb (%rbx), %r12b
incq %rbx
testb %r12b, %r12b
jne 0x8236
movslq %r13d, %rax
movb $0x0, (%r14,%rax)
jmp 0x828b
xorl %r14d, %r14d
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
leaq 0x3560(%rip), %r12      # 0xb80f
movq %r15, %rdi
callq 0x7e06
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x8330
movq %rax, %r14
movl $0x5, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2170
testl %eax, %eax
jne 0x82af
leaq 0x2197(%rip), %r15      # 0xa476
movq %r14, %rdi
movq %r15, %rsi
callq 0x2500
testq %rax, %rax
je 0x831f
movq %rax, %r12
callq 0x22e0
movq (%rax), %rax
movsbq (%r12), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
movl $0x0, %edi
je 0x82e2
movq %r12, %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x2460
movq %rax, %rbx
jmp 0x8330
leaq 0x34ef(%rip), %rdi      # 0xb815
movq %r14, %rsi
xorl %eax, %eax
callq 0x22d0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movq $0x0, 0x40(%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 0x7f74
testq %rax, %rax
je 0x83cb
movq %rax, %r14
movq %rax, %rdi
callq 0x2150
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x7c6d
movl %eax, %ebp
movq %r14, %rdi
callq 0x23c0
cmpl $-0x1, %ebp
je 0x83cb
movq %rbx, %rdi
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x829d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x70(%rsp), %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x40(%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 0x3412(%rip), %rax      # 0xb851
leaq 0x3424(%rip), %rcx      # 0xb86a
cmoveq %rax, %rcx
cmpl $0x1, %r9d
leaq 0x33dc(%rip), %rax      # 0xb831
cmovneq %rcx, %rax
movq %rax, 0x20(%rsp)
testq %r14, %r14
je 0x846e
movq %r14, %rdi
callq 0x2150
movl %eax, (%rsp)
movq %rsp, %rdi
callq 0x7f74
testq %rax, %rax
je 0x84ce
movq %rax, %r15
movq %rax, %rdi
callq 0x2150
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7c6d
movl %eax, %ebp
movq %r15, %rdi
callq 0x23c0
cmpl $-0x1, %ebp
je 0x84ce
testq %r14, %r14
je 0x84bc
movslq (%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7c6d
cmpl $-0x1, %eax
je 0x84ce
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x829d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x30(%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 0x7f74
testq %rax, %rax
je 0x855f
movq %rax, %r14
movq %rax, %rdi
callq 0x2150
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x7c6d
movl %eax, %ebp
movq %r14, %rdi
callq 0x23c0
cmpl $-0x1, %ebp
je 0x855f
movq %rbx, %rdi
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x829d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movb (%rdi), %al
testb %al, %al
je 0x87df
pushq %rbx
movq %rdi, %rbx
movzbl %al, %ecx
notl %ecx
testb $-0x10, %cl
jne 0x876c
movq %rbx, %rdi
callq 0x2150
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x4, %rcx
jb 0x87ea
movb 0x1(%rbx), %cl
andb $-0x40, %cl
negb %cl
jno 0x87ea
movb 0x2(%rbx), %cl
andb $-0x40, %cl
negb %cl
jno 0x87ea
movb 0x3(%rbx), %dl
andb $-0x40, %dl
movl $0x4, %ecx
jmp 0x87be
testb $-0x20, %cl
jne 0x879b
movq %rbx, %rdi
callq 0x2150
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x3, %rcx
jb 0x87ea
movb 0x1(%rbx), %cl
andb $-0x40, %cl
negb %cl
jno 0x87ea
movb 0x2(%rbx), %dl
andb $-0x40, %dl
movl $0x3, %ecx
jmp 0x87be
testb $-0x40, %cl
jne 0x87d2
movq %rbx, %rdi
callq 0x2150
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x2, %rcx
jb 0x87ea
movb 0x1(%rbx), %dl
andb $-0x40, %dl
movl $0x2, %ecx
negb %dl
jno 0x87ea
movb (%rbx,%rcx), %al
addq %rcx, %rbx
testb %al, %al
jne 0x8722
jmp 0x87e5
movl $0x1, %ecx
testb %al, %al
jns 0x87c2
xorl %eax, %eax
jmp 0x87ea
movl $0x1, %eax
retq
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8856
movb (%rbx), %al
addb $-0x3, %al
cmpb $0x1, %al
jbe 0x8850
movq 0x8(%rbx), %rdi
movq 0x18(%rbx), %r14
callq 0x23c0
movq 0x10(%rbx), %rdi
callq 0x23c0
movq %rbx, %rdi
callq 0x23c0
movq %r14, %rbx
testq %r14, %r14
jne 0x8820
jmp 0x8856
movq 0x10(%rbx), %rbx
jmp 0x881b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
testq %rdi, %rdi
je 0x9000
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x8fde
movq %r14, %rsi
callq 0x2450
testl %eax, %eax
je 0x9002
movb (%rbx), %al
addb $-0x3, %al
cmpb $0x1, %al
ja 0x8ff7
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x8fba
testq %rax, %rax
jne 0x900d
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x8fc9
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x9002
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
xorl %eax, %eax
testq %rdi, %rdi
je 0x904f
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
jne 0x9015
movl $0x20, %edi
callq 0x2420
testq %rax, %rax
je 0x9049
movb $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
jmp 0x904b
xorl %eax, %eax
movq %rax, 0x18(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2420
testq %rax, %rax
je 0x9104
movq %rax, %rcx
testq %rbx, %rbx
je 0x90ff
leaq 0x28b5(%rip), %rdx      # 0xb938
movq %rax, %rcx
movb (%rbx), %sil
movzbl %sil, %edi
cmpl $0x21, %edi
jg 0x90a9
cmpl $0xd, %edi
ja 0x90f7
movl %edi, %edi
movslq (%rdx,%rdi,4), %rdi
addq %rdx, %rdi
jmpq *%rdi
movw $0x625c, (%rcx)         # imm = 0x625C
jmp 0x90ee
cmpl $0x22, %edi
je 0x90e2
cmpl $0x2f, %edi
je 0x90e9
cmpl $0x5c, %edi
jne 0x90f7
movw $0x5c5c, (%rcx)         # imm = 0x5C5C
jmp 0x90ee
movw $0x765c, (%rcx)         # imm = 0x765C
jmp 0x90ee
movw $0x745c, (%rcx)         # imm = 0x745C
jmp 0x90ee
movw $0x725c, (%rcx)         # imm = 0x725C
jmp 0x90ee
movw $0x6e5c, (%rcx)         # imm = 0x6E5C
jmp 0x90ee
movw $0x665c, (%rcx)         # imm = 0x665C
jmp 0x90ee
movw $0x225c, (%rcx)         # imm = 0x225C
jmp 0x90ee
movw $0x2f5c, (%rcx)         # imm = 0x2F5C
addq $0x2, %rcx
incq %rbx
jmp 0x9086
movb %sil, (%rcx)
incq %rcx
jmp 0x90f2
movb $0x0, (%rcx)
jmp 0x9106
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9145
movl %edi, %eax
shrl $0x12, %eax
andb $0x7, %al
orb $-0x10, %al
movb %al, (%rsi)
movl %edi, %eax
shrl $0xc, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rsi)
movl %edi, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x2(%rsi)
andb $0x3f, %dil
orb $-0x80, %dil
movb %dil, 0x3(%rsi)
movl $0x4, %eax
retq
cmpl $0x100, %edi            # imm = 0x100
jb 0x9174
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)
movl $0x3, %eax
retq
cmpl $0x80, %edi
jb 0x9197
movl %edi, %eax
shrl $0x6, %eax
orb $-0x40, %al
movb %al, (%rsi)
andb $0x3f, %dil
orb $-0x80, %dil
movb %dil, 0x1(%rsi)
movl $0x2, %eax
retq
movb %dil, (%rsi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x91d8
testl %eax, %eax
je 0x91c4
callq 0x9235
testq %rax, %rax
je 0x91c4
movq %rax, %rbx
movq %rax, %rdi
callq 0x2560
cmpl $-0x1, %eax
je 0x91c6
popq %rbx
retq
leaq 0x27f3(%rip), %rdi      # 0xb9c0
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
jmp 0x2110
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
subq $0x98, %rsp
callq 0x9235
xorl %ebp, %ebp
testq %rax, %rax
je 0x9229
movq %rax, %rbx
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2260
movl $0x1, %ebp
cmpl $-0x1, %eax
jne 0x9229
callq 0x2060
cmpl $0x2, (%rax)
movl $0x0, %ebp
je 0x9229
leaq 0x2831(%rip), %rdi      # 0xba4e
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2110
movl %ebp, %eax
addq $0x98, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6a40(%rip), %rbx      # 0xfc80
testq %rbx, %rbx
je 0x9250
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x2180
movl %eax, %edi
callq 0x2380
testq %rax, %rax
je 0x92b6
movq %rax, %rbx
callq 0x2370
movq 0x20(%rbx), %rbx
movq %rbx, %rdi
callq 0x2150
addl $0x16, %eax
movslq %eax, %r14
movq %r14, %rdi
callq 0x2420
movq %rax, 0x69f6(%rip)      # 0xfc80
testq %rax, %rax
je 0x92cb
leaq 0x2212(%rip), %rdx      # 0xb4a8
leaq 0x279c(%rip), %r8       # 0xba39
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2530
movq 0x69cc(%rip), %rbx      # 0xfc80
jmp 0x9245
leaq 0x21c4(%rip), %rdi      # 0xb481
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x22d0
jmp 0x9245
leaq 0x13d0(%rip), %rdi      # 0xa6a2
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2110
jmp 0x9245
// File: /workspace/github_c_makefile_star2_O1/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 0x2420
testq %rax, %rax
je 0x9760
movq %rax, %rbx
movl $0x2000, %ebp           # imm = 0x2000
movl $0x1, %esi
movl $0x2000, %edx           # imm = 0x2000
movq %rax, %rdi
movq %r14, %rcx
callq 0x24d0
cmpq $0x2000, %rax           # imm = 0x2000
jne 0x9772
xorl %r13d, %r13d
leaq 0x4000(%r13), %rsi
movq %rbx, %rdi
callq 0x2540
testq %rax, %rax
je 0x9797
movq %rax, %r12
leaq (%rax,%r13), %rdi
addq $0x2000, %rdi           # imm = 0x2000
movl $0x1, %esi
movl $0x2000, %edx           # imm = 0x2000
movq %r14, %rcx
callq 0x24d0
addq %rbp, %r13
movq %r12, %rbx
cmpq %rbp, %rax
je 0x9719
movq %rax, %r15
movq %r12, %rbx
jmp 0x9778
leaq 0xf3b(%rip), %rdi       # 0xa6a2
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2110
jmp 0x97af
movq %rax, %r15
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x24f0
testl %eax, %eax
je 0x978e
addq %r15, %r13
movb $0x0, (%rbx,%r13)
jmp 0x97af
leaq 0x2337(%rip), %rdi      # 0xbacc
jmp 0x979e
leaq 0xabd(%rip), %rdi       # 0xa25b
xorl %eax, %eax
callq 0x2110
movq %rbx, %rdi
callq 0x23c0
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_O1/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 0x5800(%rip), %rax      # 0xefd0
movq (%rax), %rdi
callq 0x22b0
leaq 0x4(%rsp), %rsi
movl %eax, %edi
callq 0x2330
cmpl $-0x1, %eax
je 0x983c
leaq 0x4(%rsp), %rdx
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups 0x20(%rdx), %xmm2
movups 0x2c(%rdx), %xmm3
movups %xmm3, 0x64b8(%rip)     # 0xfcbc
movups %xmm2, 0x64a5(%rip)     # 0xfcb0
movups %xmm1, 0x648e(%rip)     # 0xfca0
movups %xmm0, 0x6477(%rip)     # 0xfc90
andb $-0xb, 0xc(%rdx)
movw $0x100, 0x16(%rdx)      # imm = 0x100
xorl %ebx, %ebx
xorl %edi, %edi
xorl %esi, %esi
callq 0x2410
cmpl $-0x1, %eax
jne 0x984f
leaq 0x22c9(%rip), %rdi      # 0xbb03
jmp 0x9843
leaq 0x22af(%rip), %rdi      # 0xbaf2
xorl %eax, %eax
callq 0x2110
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
cmpq %r15, %rax
jb 0x9968
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq (%rbx), %r13
leaq 0x20(%r14), %rbp
testq %r13, %r13
je 0x9933
movq %r13, %rdi
callq 0x2150
addq %r15, %rbp
addq %rax, %rbp
movq %r13, %rdi
movq %rbp, %rsi
callq 0x2540
testq %rax, %rax
je 0x998f
cmpq $0x0, (%rbx)
jne 0x994c
movb $0x0, (%rax)
movq %rax, (%rbx)
movq (%r12), %rax
addq %r14, %rax
addq $0x20, %rax
movq %rax, (%r12)
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rax
subq %rax, (%r12)
movq (%rbx), %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 0x8c5(%rip), %rdi       # 0xa25b
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2110
jmp 0x997d
// File: /workspace/github_c_makefile_star2_O1/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 0x1eb7d(%rip), %rdi     # 0x21004
xorl %eax, %eax
callq 0x2040
leaq 0x1ed00(%rip), %rdi     # 0x21195
callq 0x2210
leaq 0x1ecfb(%rip), %rdi     # 0x2119c
callq 0x2210
leaq 0x1ed1b(%rip), %rdi     # 0x211c8
callq 0x2210
leaq 0x1ed39(%rip), %rdi     # 0x211f2
callq 0x2210
leaq 0x1ed4c(%rip), %rdi     # 0x21211
callq 0x2210
leaq 0x1ed71(%rip), %rdi     # 0x21242
callq 0x2210
leaq 0x1ed87(%rip), %rdi     # 0x21264
callq 0x2210
leaq 0x1eda8(%rip), %rdi     # 0x21291
popq %rax
jmp 0x2210
// File: /workspace/github_c_makefile_star2_O1/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
xorl %eax, %eax
leaq 0x38(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x30(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x28(%rsp), %r8
movq %rax, (%r8)
leaq 0x20(%rsp), %r9
movq %rax, (%r9)
leaq 0x18(%rsp), %r10
movq %rax, (%r10)
leaq 0x10(%rsp), %r11
movq %rax, (%r11)
leaq 0xc(%rsp), %rax
movl $0x0, (%rax)
subq $0x8, %rsp
pushq %rax
pushq %r11
pushq %r10
callq 0x24ef
addq $0x20, %rsp
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x2947
cmpl $0x0, 0xc(%rsp)
je 0x294d
movq (%rbx), %rdi
callq 0x247c
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 0x26ae
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/goodpaul6[P]generic/script.c
// Function: error_defer_e
static void error_defer_e(expr_t* exp, const char* fmt, ...)
{
	fprintf(stderr, "\nError (%s:%i):\n", exp->ctx.file, exp->ctx.line);
	
	va_list args;
	va_start(args, fmt);
	vfprintf(stderr, fmt, args);
	va_end(args);
	
	g_has_error = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %rbx
testb %al, %al
je 0x22e3
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 %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
movq 0x13cef(%rip), %r15     # 0x15ff0
movq (%r15), %rax
movq 0x10(%rdi), %rdx
movl 0x8(%rdi), %ecx
leaq 0xdf84(%rip), %rsi      # 0x10296
movq %rax, %rdi
xorl %eax, %eax
callq 0x2170
leaq -0x30(%rbp), %rdx
movq %r14, 0x10(%rdx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x2200
movb $0x1, 0x13ef1(%rip)     # 0x1623c
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq