LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x669f
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 0x667b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6708
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 0x8881(%rip), %rbp      # 0xefb0
leaq 0x4219(%rip), %r15      # 0xa94f
leaq 0x4215(%rip), %r12      # 0xa952
leaq 0x4201(%rip), %r13      # 0xa945
movzbl (%rbx), %eax
cmpl $0x25, %eax
je 0x6761
testl %eax, %eax
je 0x6886
movsbl %al, %edi
incq %rbx
callq 0x2440
jmp 0x6744
movzbl 0x1(%rbx), %eax
testl %eax, %eax
je 0x6886
addq $0x2, %rbx
cmpl $0x63, %eax
jg 0x6799
cmpl $0x25, %eax
je 0x67bc
cmpl $0x63, %eax
jne 0x6744
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x67eb
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x67f9
cmpl $0x64, %eax
je 0x67cb
cmpl $0x73, %eax
jne 0x6744
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x6805
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x6813
movl $0x25, %edi
callq 0x2440
jmp 0x6744
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x6863
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x6871
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl (%rax), %edi
callq 0x2440
jmp 0x6744
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %r14
movzbl (%r14), %eax
cmpl $0x2d, %eax
jle 0x6832
cmpl $0x5c, %eax
je 0x6840
cmpl $0x2e, %eax
jne 0x6856
movq (%rbp), %rsi
movq %r13, %rdi
jmp 0x6847
cmpl $0x27, %eax
jne 0x684e
movq (%rbp), %rsi
movq %r15, %rdi
jmp 0x6847
movq (%rbp), %rsi
movq %r12, %rdi
callq 0x2350
jmp 0x685e
testl %eax, %eax
je 0x6744
movsbl %al, %edi
callq 0x2440
incq %r14
jmp 0x6816
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl (%rax), %esi
leaq 0x4ee9(%rip), %rdi      # 0xb763
xorl %eax, %eax
callq 0x2070
jmp 0x6744
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x68f8
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 0x690a
movq %rax, %rbx
leaq 0x4ba9(%rip), %rdx      # 0xb488
leaq 0x4ba8(%rip), %r8       # 0xb48e
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2530
jmp 0x691a
leaq 0x4b62(%rip), %rdi      # 0xb461
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x22d0
jmp 0x691a
leaq 0x3d75(%rip), %rdi      # 0xa686
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2110
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6bc1
movq (%rax), %r14
movzwl (%r14,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
jne 0x6bc1
movq %rbx, %rdi
movl $0x3a, %esi
callq 0x2120
testq %rax, %rax
je 0x6bc1
incq %rax
movsbq (%rax), %rcx
incq %rax
testb $0x20, 0x1(%r14,%rcx,2)
jne 0x6bae
testb %cl, %cl
je 0x6bcb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x1, %eax
jmp 0x6bc3
// File: /workspace/github_c_makefile_star2_O3/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), %dl
movl $0x1, %ebp
cmpb $0x3a, %dl
je 0x6f42
movl %edx, %eax
movb (%rbx), %cl
cmpb %cl, %dl
jne 0x6f3a
incq %rbx
movb 0x1(%r14), %dl
incq %r14
cmpb $0x3a, %dl
jne 0x6f23
xorl %ebp, %ebp
cmpb %cl, %al
sete %bpl
xorl %r13d, %r13d
cmpb $0x3a, (%rbx)
sete %r12b
movsbq (%r14,%rbp), %r15
testq %r15, %r15
je 0x6f66
callq 0x22e0
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r15,2)
je 0x6f83
movb %r12b, %r13b
movsbq (%rbx,%r13), %r12
testq %r12, %r12
je 0x6f87
callq 0x22e0
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r12,2)
jne 0x6f87
xorl %eax, %eax
jmp 0x6fe9
testb %r15b, %r15b
je 0x6fb1
callq 0x22e0
movq (%rax), %rax
leaq (%r14,%rbp), %rcx
incq %rcx
movsbq %r15b, %rdx
testb $0x20, 0x1(%rax,%rdx,2)
je 0x6fb4
movb (%rcx), %r15b
incq %rcx
testb %r15b, %r15b
jne 0x6f9b
xorl %r15d, %r15d
testb %r12b, %r12b
je 0x6fde
callq 0x22e0
movq (%rax), %rax
leaq (%rbx,%r13), %rcx
incq %rcx
movsbq %r12b, %rdx
testb $0x20, 0x1(%rax,%rdx,2)
je 0x6fe1
movb (%rcx), %r12b
incq %rcx
testb %r12b, %r12b
jne 0x6fc8
xorl %r12d, %r12d
xorl %eax, %eax
cmpb %r12b, %r15b
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x751f
movq %rdi, %r14
movl 0xc(%rdi), %eax
cmpq $0x3, %rax
ja 0x751f
movq %rsi, %rbx
leaq 0x405e(%rip), %rcx      # 0xb440
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%r14), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x751f
callq 0x76c5
testq %rax, %rax
je 0x751f
movq %rax, %r15
movq (%r14), %rdx
leaq 0x41c7(%rip), %rsi      # 0xb5dd
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 0x41af(%rip), %rsi      # 0xb5f3
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 0x40f6(%rip), %rax      # 0xb55e
leaq 0x4196(%rip), %rcx      # 0xb605
cmoveq %rax, %rcx
leaq 0x4182(%rip), %rsi      # 0xb5fc
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2490
movq (%r14), %rdx
leaq 0x4151(%rip), %rsi      # 0xb5e8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2490
movq 0x10(%r14), %rax
movq (%rax), %r13
testq %r13, %r13
je 0x7509
movq (%r13), %rdi
testq %rdi, %rdi
je 0x7509
leaq 0x4131(%rip), %r15      # 0xb5ee
movq 0x10(%r14), %rax
cmpq (%rax), %r13
je 0x74d7
movl $0x20, %edi
movq %rbx, %rsi
callq 0x2400
movq (%r13), %rdi
callq 0x76c5
testq %rax, %rax
je 0x751f
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2490
movq %r12, %rdi
callq 0x23c0
movq 0x8(%r13), %rdi
addq $0x8, %r13
testq %rdi, %rdi
jne 0x74bd
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_O3/tomka[P]cliaspora/config.c
// Function: cutok
static char *
cutok(char *str, bool *error)
{
	static int   quote;
	static char *p, *start = NULL;

	if (str != NULL)
		start = str;
	while (*start != '\0' && isspace(*start))
		start++;
	if (*start == '"') {
		start++; quote = 1;
	} else
		quote = 0;
	if (*start == '\0') {
		if (quote == 1) {
			warnx("Syntax error: Unterminated quoted string:");
			*error = true;
		} else
			*error = false;
		return (NULL);
	}
	*error = true;
	for (p = str = start; *str != '\0'; str++) {
		if (*str == '\\') {
			if (*(str + 1) == '\0') {
				warnx("Syntax error: " \
				    "Incomplete escape sequence:");
				return (NULL);
			}
			*p++ = *++str;
		} else if (*str == '"' || isspace(*str)) {
			if (*str == '"')
				quote ^= 1;
			if (quote == 0) {
				*p++ = '\0'; p = start; start = str + 1;
				*error = false;
				return (p);
			} else
				*p++ = *str;
		} else
			*p++ = *str;
	}
	*p = '\0'; p = start; start = str;
	if (quote == 1) {
		warnx("Syntax error: Unterminated quoted string:");
		return (NULL);
	}
	*error = false;
	return (p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
testq %rdi, %rdi
je 0x7548
movq %rdi, %rbx
movq %rdi, 0x86fa(%rip)      # 0xfc40
jmp 0x754f
movq 0x86f1(%rip), %rbx      # 0xfc40
movb (%rbx), %bpl
testb %bpl, %bpl
je 0x757f
callq 0x22e0
movq (%rax), %rax
incq %rbx
movsbq %bpl, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x75a2
movq %rbx, 0x86cc(%rip)      # 0xfc40
movb (%rbx), %bpl
incq %rbx
testb %bpl, %bpl
jne 0x7562
movl $0x0, 0x86a7(%rip)      # 0xfc30
xorl %eax, %eax
movl %eax, (%r14)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x22, %bpl
jne 0x75d8
movq %rbx, 0x8691(%rip)      # 0xfc40
movl $0x1, 0x8677(%rip)      # 0xfc30
movl $0x1, %ebp
cmpb $0x0, (%rbx)
jne 0x75e7
leaq 0x3fbf(%rip), %rdi      # 0xb589
xorl %eax, %eax
callq 0x22d0
movl $0x1, %eax
jmp 0x758b
decq %rbx
movl $0x0, 0x864b(%rip)      # 0xfc30
xorl %ebp, %ebp
movq %r14, (%rsp)
movl $0x1, (%r14)
movq %rbx, 0x863f(%rip)      # 0xfc38
leaq 0x1(%rbx), %r12
movq %rbx, %r15
movzbl (%r15), %r13d
cmpl $0x22, %r13d
je 0x7639
cmpl $0x5c, %r13d
je 0x762b
testl %r13d, %r13d
je 0x7677
movsbq %r13b, %r14
callq 0x22e0
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r14,2)
jne 0x7642
jmp 0x7646
movb 0x1(%r15), %r13b
testb %r13b, %r13b
je 0x76b0
incq %r15
jmp 0x7646
xorl $0x1, %ebp
movl %ebp, 0x85ee(%rip)      # 0xfc30
testl %ebp, %ebp
je 0x765a
movq %r12, 0x85eb(%rip)      # 0xfc38
movb %r13b, -0x1(%r12)
incq %r15
incq %r12
jmp 0x7600
movq 0x85d7(%rip), %rax      # 0xfc38
movb $0x0, (%rax)
movq %rbx, 0x85cd(%rip)      # 0xfc38
incq %r15
movq %r15, 0x85cb(%rip)      # 0xfc40
jmp 0x76a1
movq 0x85ba(%rip), %rax      # 0xfc38
movb $0x0, (%rax)
movq %rbx, 0x85b0(%rip)      # 0xfc38
movq %r15, 0x85b1(%rip)      # 0xfc40
cmpl $0x1, 0x859a(%rip)      # 0xfc30
jne 0x76a1
leaq 0x3eea(%rip), %rdi      # 0xb589
jmp 0x76b7
movq (%rsp), %rax
movl $0x0, (%rax)
jmp 0x7590
leaq 0x3efc(%rip), %rdi      # 0xb5b3
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x22d0
jmp 0x7590
// File: /workspace/github_c_makefile_star2_O3/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 0x770b
movq %rax, %rcx
movzbl (%rbx), %edx
cmpl $0x22, %edx
je 0x76f6
cmpl $0x5c, %edx
je 0x76f6
testl %edx, %edx
jne 0x76fe
jmp 0x7708
movb $0x5c, (%rcx)
incq %rcx
movb (%rbx), %dl
movb %dl, (%rcx)
incq %rcx
incq %rbx
jmp 0x76e3
movb $0x0, (%rcx)
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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, 0x8(%rsp)
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 0x7c07
callq 0x2060
cmpl $0x4, (%rax)
je 0x7be2
jmp 0x7c76
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 0x7c9d
movq 0x28(%rbx), %rdi
movq %r15, %rsi
movq 0x8(%rsp), %rdx
callq 0x25a0
movl %eax, %ebp
testl %eax, %eax
jns 0x7caf
movq 0x28(%rbx), %rdi
movl %ebp, %esi
callq 0x2040
movl %eax, %r14d
andl $-0x2, %eax
cmpl $0x2, %eax
xorps %xmm0, %xmm0
je 0x7b7e
callq 0x2060
cmpl $0x0, (%rax)
je 0x7cbc
leaq 0x3a34(%rip), %rdi      # 0xb69c
movl %ebp, %esi
movl %r14d, %edx
xorl %eax, %eax
callq 0x2110
jmp 0x7ccf
leaq 0x39f4(%rip), %rdi      # 0xb671
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 0x39e3(%rip), %rdi      # 0xb687
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x22d0
jmp 0x7c89
jne 0x7c89
movl $0x0, 0x10(%rbx)
xorl %ebp, %ebp
jmp 0x7c89
leaq 0x39d9(%rip), %rdi      # 0xb69c
movl %ebp, %esi
movl %r14d, %edx
xorl %eax, %eax
callq 0x22d0
movq 0x7302(%rip), %rax      # 0xefd8
movq (%rax), %rdi
callq 0x21b0
jmp 0x7c84
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
jne 0x7d0b
movl $0x800, %edi            # imm = 0x800
callq 0x2420
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x7de8
movl $0x800, (%rbx)          # imm = 0x800
xorl %r14d, %r14d
movl $0x800, %ebp            # imm = 0x800
xorl %eax, %eax
addl 0x4(%rbx), %eax
movl %eax, 0x4(%rbx)
movl 0x8(%rbx), %ecx
testl %ecx, %ecx
jle 0x7d4c
cmpl %ecx, %eax
jle 0x7d4c
xorl %edx, %edx
movq 0x20(%rbx), %rax
addl %edx, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movb %cl, (%rax,%rdx)
incq %rdx
movl 0x4(%rbx), %eax
movl 0x8(%rbx), %ecx
movl %eax, %esi
subl %ecx, %esi
movslq %esi, %rsi
cmpq %rsi, %rdx
jl 0x7d28
subl %ecx, %eax
movl %eax, 0x4(%rbx)
movl $0x0, 0x8(%rbx)
movq 0x20(%rbx), %rdx
jle 0x7d78
movl %eax, %esi
xorl %ecx, %ecx
cmpb $0xa, (%rdx,%rcx)
je 0x7d72
incq %rcx
cmpq %rcx, %rsi
jne 0x7d62
jmp 0x7d78
cmpb $0xa, (%rdx,%rcx)
je 0x7ded
movl (%rbx), %ecx
cmpl %ecx, %eax
jl 0x7da9
movslq %ecx, %rsi
addq $0x800, %rsi            # imm = 0x800
movq %rdx, %rdi
callq 0x2540
testq %rax, %rax
je 0x7e1c
movq %rax, %rdx
movq %rax, 0x20(%rbx)
movl (%rbx), %ecx
addl %ebp, %ecx
movl %ecx, (%rbx)
movl 0x4(%rbx), %eax
cltq
addq %rax, %rdx
subl %eax, %ecx
movq %rbx, %rdi
movl $0x14, %esi
callq 0x7977
testl %eax, %eax
jg 0x7d15
movslq 0x4(%rbx), %rax
testq %rax, %rax
jle 0x7de0
movq 0x20(%rbx), %rcx
movb $0x0, (%rcx,%rax)
movq $0x0, 0x4(%rbx)
jmp 0x7e18
movq $0x0, 0x4(%rbx)
xorl %r14d, %r14d
jmp 0x7e1c
testq %rcx, %rcx
je 0x7dfe
cmpb $0xd, -0x1(%rdx,%rcx)
jne 0x7dfe
movb $0x0, -0x1(%rdx,%rcx)
leal 0x1(%rcx), %eax
movl %eax, 0x8(%rbx)
cmpl (%rbx), %eax
jl 0x7e10
movq $0x0, 0x4(%rbx)
movq 0x20(%rbx), %rax
movb $0x0, (%rax,%rcx)
movq 0x20(%rbx), %r14
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x381b(%rip), %rsi      # 0xb8b0
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 0x8138
movq %rbx, %rdi
callq 0x2150
leal (%rax,%rax,2), %ebp
incl %ebp
movslq %ebp, %rdi
callq 0x2420
testq %rax, %rax
je 0x8138
movq %rax, %r14
movb (%rbx), %r12b
xorl %eax, %eax
testb %r12b, %r12b
je 0x8131
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 0x8102
movb %r12b, (%rdi)
jmp 0x8120
movl %ebp, %eax
subl %r13d, %eax
movslq %eax, %rsi
movzbl %r12b, %ecx
leaq 0x36d3(%rip), %rdx      # 0xb7e8
xorl %eax, %eax
callq 0x2530
addl $0x2, %r13d
incl %r13d
movb (%rbx), %r12b
incq %rbx
testb %r12b, %r12b
jne 0x80e6
movslq %r13d, %rax
movb $0x0, (%r14,%rax)
jmp 0x813b
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_O3/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 0x3690(%rip), %r12      # 0xb7ef
movq %r15, %rdi
callq 0x7ce0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x81e0
movq %rax, %r14
movl $0x5, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2170
testl %eax, %eax
jne 0x815f
leaq 0x22e7(%rip), %r15      # 0xa476
movq %r14, %rdi
movq %r15, %rsi
callq 0x2500
testq %rax, %rax
je 0x81cf
movq %rax, %r12
callq 0x22e0
movq (%rax), %rax
movsbq (%r12), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
movl $0x0, %edi
je 0x8192
movq %r12, %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x2460
movq %rax, %rbx
jmp 0x81e0
leaq 0x361f(%rip), %rdi      # 0xb7f5
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_O3/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)
movq $0x0, 0x20(%rdi)
movq %r8, 0x10(%rdi)
movq %rsi, 0x8(%rdi)
movl $0x1, 0x4(%rdi)
movq 0x18(%rbx), %rax
movq %rax, 0x30(%rdi)
movq %rdx, 0x40(%rdi)
movq %rcx, 0x28(%rdi)
movq %rsi, 0x38(%rdi)
callq 0x7e24
testq %rax, %rax
je 0x8273
movq %rax, %r14
movq %rax, %rdi
callq 0x2150
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x7b55
movl %eax, %ebp
movq %r14, %rdi
callq 0x23c0
cmpl $-0x1, %ebp
je 0x8273
movq %rbx, %rdi
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x814d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tomka[P]cliaspora/http.c
// Function: http_post
int
http_post(ssl_conn_t *cp, const char *url, const char *cookie,
	 const char *accept, const char *agent, int type, const char *content)
{
	char	   *rq;
	http_req_t hdr;

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq 0x80(%rsp), %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%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 0x354f(%rip), %rax      # 0xb831
leaq 0x3561(%rip), %rcx      # 0xb84a
cmoveq %rax, %rcx
cmpl $0x1, %r9d
leaq 0x3519(%rip), %rax      # 0xb811
cmovneq %rcx, %rax
movq %rax, 0x20(%rsp)
testq %r14, %r14
je 0x8316
movq %r14, %rdi
callq 0x2150
movl %eax, (%rsp)
movslq %eax, %r15
jmp 0x8319
xorl %r15d, %r15d
movq %rsp, %rdi
callq 0x7e24
testq %rax, %rax
je 0x837a
movq %rax, %r12
movq %rax, %rdi
callq 0x2150
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x7b55
movl %eax, %ebp
movq %r12, %rdi
callq 0x23c0
cmpl $-0x1, %ebp
je 0x837a
testq %r14, %r14
je 0x8366
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x7b55
cmpl $-0x1, %eax
je 0x837a
movq %rbx, %rdi
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x814d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tomka[P]cliaspora/http.c
// Function: http_delete
int
http_delete(ssl_conn_t *cp, const char *url, const char *cookie,
	    const char *agent)
{
	char	   *rq;
	http_req_t hdr;

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

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, 0x20(%rdi)
movq %rsi, 0x8(%rdi)
movq %rdx, 0x40(%rdi)
movq %rcx, 0x10(%rdi)
movl $0x3, 0x4(%rdi)
movq 0x18(%rbx), %rax
movq %rax, 0x30(%rdi)
movq %rsi, 0x38(%rdi)
callq 0x7e24
testq %rax, %rax
je 0x8409
movq %rax, %r14
movq %rax, %rdi
callq 0x2150
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x7b55
movl %eax, %ebp
movq %r14, %rdi
callq 0x23c0
cmpl $-0x1, %ebp
je 0x8409
movq %rbx, %rdi
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x814d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x867f
pushq %rbx
movq %rdi, %rbx
movzbl %al, %ecx
notl %ecx
testb $-0x10, %cl
jne 0x860c
movq %rbx, %rdi
callq 0x2150
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x4, %rcx
jb 0x868a
movb 0x1(%rbx), %cl
andb $-0x40, %cl
negb %cl
jno 0x868a
movb 0x2(%rbx), %cl
andb $-0x40, %cl
negb %cl
jno 0x868a
movb 0x3(%rbx), %dl
andb $-0x40, %dl
movl $0x4, %ecx
jmp 0x865e
testb $-0x20, %cl
jne 0x863b
movq %rbx, %rdi
callq 0x2150
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x3, %rcx
jb 0x868a
movb 0x1(%rbx), %cl
andb $-0x40, %cl
negb %cl
jno 0x868a
movb 0x2(%rbx), %dl
andb $-0x40, %dl
movl $0x3, %ecx
jmp 0x865e
testb $-0x40, %cl
jne 0x8672
movq %rbx, %rdi
callq 0x2150
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x2, %rcx
jb 0x868a
movb 0x1(%rbx), %dl
andb $-0x40, %dl
movl $0x2, %ecx
negb %dl
jno 0x868a
movb (%rbx,%rcx), %al
addq %rcx, %rbx
testb %al, %al
jne 0x85c2
jmp 0x8685
movl $0x1, %ecx
testb %al, %al
jns 0x8662
xorl %eax, %eax
jmp 0x868a
movl $0x1, %eax
retq
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x86fc
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rbx), %al
addb $-0x3, %al
cmpb $0x1, %al
ja 0x86cf
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x86bc
jmp 0x86f5
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 0x86bc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8e66
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x8e44
movq %r14, %rsi
callq 0x2450
testl %eax, %eax
je 0x8e68
movb (%rbx), %al
addb $-0x3, %al
cmpb $0x1, %al
ja 0x8e5d
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x8e20
testq %rax, %rax
jne 0x8e73
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x8e2f
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x8e68
// File: /workspace/github_c_makefile_star2_O3/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 0x8eb1
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
jne 0x8e7b
movl $0x20, %edi
callq 0x2420
testq %rax, %rax
je 0x8ead
movb $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
movq %rax, 0x18(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8f64
movq %rax, %rcx
testq %rbx, %rbx
je 0x8f61
leaq 0x2a5f(%rip), %rdx      # 0xb944
movq %rax, %rcx
movb (%rbx), %sil
movzbl %sil, %edi
cmpl $0x21, %edi
jg 0x8f0b
cmpl $0xd, %edi
ja 0x8f59
movl %edi, %edi
movslq (%rdx,%rdi,4), %rdi
addq %rdx, %rdi
jmpq *%rdi
movw $0x625c, (%rcx)         # imm = 0x625C
jmp 0x8f50
cmpl $0x22, %edi
je 0x8f44
cmpl $0x2f, %edi
je 0x8f4b
cmpl $0x5c, %edi
jne 0x8f59
movw $0x5c5c, (%rcx)         # imm = 0x5C5C
jmp 0x8f50
movw $0x765c, (%rcx)         # imm = 0x765C
jmp 0x8f50
movw $0x745c, (%rcx)         # imm = 0x745C
jmp 0x8f50
movw $0x725c, (%rcx)         # imm = 0x725C
jmp 0x8f50
movw $0x6e5c, (%rcx)         # imm = 0x6E5C
jmp 0x8f50
movw $0x665c, (%rcx)         # imm = 0x665C
jmp 0x8f50
movw $0x225c, (%rcx)         # imm = 0x225C
jmp 0x8f50
movw $0x2f5c, (%rcx)         # imm = 0x2F5C
addq $0x2, %rcx
incq %rbx
jmp 0x8ee8
movb %sil, (%rcx)
incq %rcx
jmp 0x8f54
movb $0x0, (%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8fb3
movl %edi, %eax
shrl $0x12, %eax
movl %edi, %ecx
shrl $0x4, %ecx
andl $0xff00, %ecx           # imm = 0xFF00
movzbl %al, %eax
orl %ecx, %eax
movl %edi, %ecx
shll $0xa, %ecx
andl $0xff0000, %ecx         # imm = 0xFF0000
orl %eax, %ecx
shll $0x18, %edi
orl %ecx, %edi
movd %edi, %xmm0
pand 0x295f(%rip), %xmm0     # 0xb900
por 0x2967(%rip), %xmm0     # 0xb910
movd %xmm0, (%rsi)
movl $0x4, %eax
retq
cmpl $0x100, %edi            # imm = 0x100
jb 0x8fe2
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 0x9005
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
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x9048
testl %eax, %eax
je 0x9034
callq 0x90a5
testq %rax, %rax
je 0x9034
movq %rax, %rbx
movq %rax, %rdi
callq 0x2560
cmpl $-0x1, %eax
je 0x9036
popq %rbx
retq
leaq 0x2993(%rip), %rdi      # 0xb9d0
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
jmp 0x2110
// File: /workspace/github_c_makefile_star2_O3/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 0x90a5
xorl %ebp, %ebp
testq %rax, %rax
je 0x9099
movq %rax, %rbx
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2260
movl $0x1, %ebp
cmpl $-0x1, %eax
jne 0x9099
callq 0x2060
cmpl $0x2, (%rax)
movl $0x0, %ebp
je 0x9099
leaq 0x29d1(%rip), %rdi      # 0xba5e
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_O3/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 0x6bd0(%rip), %rbx      # 0xfc80
testq %rbx, %rbx
je 0x90c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x2180
movl %eax, %edi
callq 0x2380
testq %rax, %rax
je 0x9126
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, 0x6b86(%rip)      # 0xfc80
testq %rax, %rax
je 0x913b
leaq 0x2382(%rip), %rdx      # 0xb488
leaq 0x293c(%rip), %r8       # 0xba49
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2530
movq 0x6b5c(%rip), %rbx      # 0xfc80
jmp 0x90b5
leaq 0x2334(%rip), %rdi      # 0xb461
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x22d0
jmp 0x90b5
leaq 0x1544(%rip), %rdi      # 0xa686
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2110
jmp 0x90b5
// File: /workspace/github_c_makefile_star2_O3/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 0x952f
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 0x9541
xorl %r13d, %r13d
leaq 0x4000(%r13), %rsi
movq %rbx, %rdi
callq 0x2540
testq %rax, %rax
je 0x9566
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 0x94e8
movq %rax, %r15
movq %r12, %rbx
jmp 0x9547
leaq 0x1150(%rip), %rdi      # 0xa686
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2110
jmp 0x957e
movq %rax, %r15
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x24f0
testl %eax, %eax
je 0x955d
addq %r15, %r13
movb $0x0, (%rbx,%r13)
jmp 0x957e
leaq 0x2578(%rip), %rdi      # 0xbadc
jmp 0x956d
leaq 0xcee(%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
// File: /workspace/github_c_makefile_star2_O3/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 0x5a34(%rip), %rax      # 0xefd0
movq (%rax), %rdi
callq 0x22b0
leaq 0x4(%rsp), %rsi
movl %eax, %edi
callq 0x2330
cmpl $-0x1, %eax
je 0x9608
leaq 0x4(%rsp), %rdx
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups 0x20(%rdx), %xmm2
movups 0x2c(%rdx), %xmm3
movups %xmm3, 0x66ec(%rip)     # 0xfcbc
movups %xmm2, 0x66d9(%rip)     # 0xfcb0
movups %xmm1, 0x66c2(%rip)     # 0xfca0
movups %xmm0, 0x66ab(%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 0x961b
leaq 0x250d(%rip), %rdi      # 0xbb13
jmp 0x960f
leaq 0x24f3(%rip), %rdi      # 0xbb02
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_O3/tomka[P]cliaspora/str.c
// Function: strdupstrcat
char *
strdupstrcat(char **buf, size_t *remain, const char *str, size_t len)
{
	char   *p;
	size_t sz;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x1(%rcx), %rax
movq (%rsi), %r15
movq (%rdi), %r13
cmpq %r15, %rax
jb 0x9736
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0x20(%r14), %rbp
testq %r13, %r13
je 0x96ff
movq %r13, %rdi
callq 0x2150
addq %r15, %rbp
addq %rax, %rbp
movq %r13, %rdi
movq %rbp, %rsi
callq 0x2540
testq %rax, %rax
je 0x9760
movq %rax, %r13
cmpq $0x0, (%rbx)
jne 0x971d
movb $0x0, (%r13)
movq %r13, (%rbx)
movq (%r12), %rax
leaq (%r14,%rax), %r15
addq $0x20, %r15
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rax
subq %rax, %r15
movq %r15, (%r12)
movq %r13, %rdi
movq %rdx, %rsi
movq %r14, %rdx
callq 0x21e0
movq (%rbx), %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xaf4(%rip), %rdi       # 0xa25b
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2110
jmp 0x974e
// File: /workspace/github_c_makefile_star2_O3/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 0x1db7d(%rip), %rdi     # 0x20004
xorl %eax, %eax
callq 0x2040
leaq 0x1dceb(%rip), %rdi     # 0x20180
callq 0x2210
leaq 0x1dce6(%rip), %rdi     # 0x20187
callq 0x2210
leaq 0x1dd06(%rip), %rdi     # 0x201b3
callq 0x2210
leaq 0x1dd24(%rip), %rdi     # 0x201dd
callq 0x2210
leaq 0x1dd37(%rip), %rdi     # 0x201fc
callq 0x2210
leaq 0x1dd5c(%rip), %rdi     # 0x2022d
callq 0x2210
leaq 0x1dd72(%rip), %rdi     # 0x2024f
callq 0x2210
leaq 0x1dd93(%rip), %rdi     # 0x2027c
popq %rax
jmp 0x2210
// File: /workspace/github_c_makefile_star2_O3/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 0x286e
cmpl $0x0, 0xc(%rsp)
je 0x2874
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 0x25d5
// File: /workspace/github_c_makefile_star2_O3/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 0x22f3
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 0x13cdf(%rip), %r15     # 0x15ff0
movq (%r15), %rax
movq 0x10(%rdi), %rdx
movl 0x8(%rdi), %ecx
leaq 0xdf74(%rip), %rsi      # 0x10296
movq %rax, %rdi
xorl %eax, %eax
callq 0x2180
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 0x2210
movb $0x1, 0x13ef1(%rip)     # 0x1624c
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq