LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/ejunjsh[P]mycc/sym.c
// Function: dumptable
void dumptable(struct symtable *head, char *name, int indent) {
  struct symtable *sym;

  if (head != NULL && name != NULL)
    printf("%s\n--------\n", name);
  for (sym = head; sym != NULL; sym = sym->next)
    dumpsym(sym, indent);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x855d
leaq 0x3634(%rip), %rdi      # 0xbb8a
xorl %eax, %eax
callq 0x2090
testq %r14, %r14
je 0x873e
leaq 0x36f0(%rip), %r15      # 0xbc5d
leaq 0x3574(%rip), %r12      # 0xbae8
testl %ebx, %ebx
jle 0x858a
movl %ebx, %r13d
movl $0x20, %edi
callq 0x2030
decl %r13d
jne 0x857b
movl 0x10(%r14), %eax
addl $-0x10, %eax
shrl $0x4, %eax
cmpl $0x5, %eax
ja 0x85e4
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
leaq 0x3604(%rip), %rdi      # 0xbbad
jmp 0x85eb
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x85f4
movq 0x8(%rax), %rsi
jmp 0x85f8
leaq 0x35f8(%rip), %rdi      # 0xbbb9
jmp 0x85eb
leaq 0x35f4(%rip), %rdi      # 0xbbbe
jmp 0x85eb
leaq 0x35e0(%rip), %rdi      # 0xbbb3
jmp 0x85eb
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x8601
movq 0x8(%rax), %rsi
jmp 0x8605
leaq 0x35ee(%rip), %rdi      # 0xbbd9
xorl %eax, %eax
callq 0x2090
jmp 0x8613
movq 0x8(%r14), %rsi
leaq 0x35c5(%rip), %rdi      # 0xbbc4
jmp 0x860c
movq 0x8(%r14), %rsi
leaq 0x35c3(%rip), %rdi      # 0xbbcf
xorl %eax, %eax
callq 0x2090
testb $0xf, 0x10(%r14)
je 0x8636
xorl %r13d, %r13d
movl $0x2a, %edi
callq 0x2030
incl %r13d
movl 0x10(%r14), %eax
andl $0xf, %eax
cmpl %eax, %r13d
jb 0x861d
movq 0x8(%r14), %rsi
leaq 0x2ccd(%rip), %rdi      # 0xb30e
xorl %eax, %eax
callq 0x2090
movl 0x20(%r14), %eax
testl %eax, %eax
je 0x8678
leaq 0x3732(%rip), %rdi      # 0xbd89
cmpl $0x1, %eax
je 0x8671
cmpl $0x2, %eax
jne 0x866a
leaq 0x357f(%rip), %rdi      # 0xbbe7
jmp 0x8671
leaq 0x3579(%rip), %rdi      # 0xbbea
xorl %eax, %eax
callq 0x2090
movl 0x24(%r14), %eax
decl %eax
movq %r15, %rdi
cmpl $0xa, %eax
ja 0x8696
movl %eax, %eax
leaq 0x3471(%rip), %rcx      # 0xbb00
movslq (%rcx,%rax,4), %rdi
addq %rcx, %rdi
xorl %eax, %eax
callq 0x2090
movl 0x20(%r14), %eax
cmpl $0x2, %eax
je 0x86cf
cmpl $0x1, %eax
je 0x86c2
testl %eax, %eax
jne 0x86f9
cmpl $0xa, 0x24(%r14)
jne 0x86e7
movl (%r14), %esi
leaq 0x35ad(%rip), %rdi      # 0xbc6d
jmp 0x86f2
movl 0x2c(%r14), %esi
leaq 0x35ac(%rip), %rdi      # 0xbc79
jmp 0x86f2
movl 0x28(%r14), %edx
movl 0x2c(%r14), %esi
leaq 0x35a8(%rip), %rdi      # 0xbc86
xorl %eax, %eax
callq 0x2090
jmp 0x86f9
movl 0x28(%r14), %esi
leaq 0x359e(%rip), %rdi      # 0xbc90
xorl %eax, %eax
callq 0x2090
movl 0x10(%r14), %eax
andl $-0x10, %eax
cmpl $0x60, %eax
je 0x870a
cmpl $0x50, %eax
jne 0x871a
movq 0x40(%r14), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x852c
cmpl $0x1, 0x20(%r14)
jne 0x8731
movq 0x40(%r14), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x852c
movq 0x38(%r14), %r14
testq %r14, %r14
jne 0x8574
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ejunjsh[P]mycc/sym.c
// Function: dumpsymtables
void dumpsymtables(void) {
  dumptable(Globhead, "Global", 0);
  printf("\n");
  dumptable(Enumhead, "Enums", 0);
  printf("\n");
  dumptable(Typehead, "Typedefs", 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x6e88(%rip), %rax      # 0xf5e0
movq (%rax), %rdi
leaq 0x3435(%rip), %rsi      # 0xbb97
xorl %edx, %edx
callq 0x852c
movl $0xa, %edi
callq 0x2030
leaq 0x6ec6(%rip), %rax      # 0xf640
movq (%rax), %rdi
leaq 0x341a(%rip), %rsi      # 0xbb9e
xorl %edx, %edx
callq 0x852c
movl $0xa, %edi
callq 0x2030
leaq 0x6eb4(%rip), %rax      # 0xf650
movq (%rax), %rdi
leaq 0x33fe(%rip), %rsi      # 0xbba4
xorl %edx, %edx
popq %rbp
jmp 0x852c
nop
// File: /workspace/github_c_makefile_star2_O1/ejunjsh[P]mycc/tree.c
// Function: mkastnode
struct ASTnode *mkastnode(int op, int type,
			  struct symtable *ctype,
			  struct ASTnode *left,
			  struct ASTnode *mid,
			  struct ASTnode *right,
			  struct symtable *sym, int intvalue) {
  struct ASTnode *n;

  // 给新节点分配内存
  n = (struct ASTnode *) malloc(sizeof(struct ASTnode));
  if (n == NULL)
    fatal("Unable to malloc in mkastnode()");

  // 复制数据到这个新节点并返回
  n->op = op;
  n->type = type;
  n->ctype = ctype;
  n->left = left;
  n->mid = mid;
  n->right = right;
  n->sym = sym;
  n->atu.a_intvalue = intvalue;
  n->linenum= 0;
  return (n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, -0x38(%rbp)
movq %r8, -0x30(%rbp)
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebx
movl %edi, %r14d
movl $0x48, %edi
callq 0x2120
movq %rax, %r13
testq %rax, %rax
jne 0x87f2
leaq 0x357f(%rip), %rdi      # 0xbd6c
callq 0x688f
movl %r14d, 0x4(%r13)
movl %ebx, 0x8(%r13)
movq %r12, 0x10(%r13)
movq %r15, 0x20(%r13)
movq -0x30(%rbp), %rax
movq %rax, 0x28(%r13)
movq -0x38(%rbp), %rax
movq %rax, 0x30(%r13)
movq 0x10(%rbp), %rax
movq %rax, 0x38(%r13)
movl 0x18(%rbp), %eax
movl %eax, (%r13)
movl $0x0, 0x40(%r13)
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/tests/events/events_counter.c
// Function: events_counter_ping
void
events_counter_ping(void)
{

	/* Print the current count. */
	printf("event %d\n", events_counter);

	/* Increment. */
	events_counter++;

	/* Check to see if we should interrupt the events. */
	if (events_counter == INTERRUPT_AT) {
		if (raise(SIGUSR1)) {
			warnp("raise(SIGUSR1) failed");
			exit(1);
		}
	}

	/* Emergency exit for runaway loops. */
	if (events_counter > INTERRUPT_BAIL) {
		warn0("events_interrupt() is broken.");
		exit(1);
	}
}

// Assembly:
pushq %rbx
movl 0x5ba3(%rip), %esi      # 0x83c0
leaq 0x2839(%rip), %rdi      # 0x505d
xorl %eax, %eax
callq 0x20e0
movl 0x5b8f(%rip), %eax      # 0x83c0
incl %eax
movl %eax, 0x5b87(%rip)      # 0x83c0
cmpl $0x4, %eax
jne 0x284c
movl $0xa, %edi
callq 0x2030
testl %eax, %eax
jne 0x2872
cmpl $0xb, 0x5b6d(%rip)      # 0x83c0
jge 0x2857
popq %rbx
retq
leaq 0x281f(%rip), %rdi      # 0x507d
xorl %eax, %eax
callq 0x418b
callq 0x2070
movl $0x0, (%rax)
jmp 0x28a3
callq 0x2070
cmpl $0x0, (%rax)
jne 0x288c
leaq 0x27e4(%rip), %rdi      # 0x5067
xorl %eax, %eax
callq 0x418b
jmp 0x28a3
movq %rax, %rbx
leaq 0x27d1(%rip), %rdi      # 0x5067
xorl %eax, %eax
callq 0x406c
movl $0x0, (%rbx)
movl $0x1, %edi
callq 0x21e0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/tests/events/events_interrupter.c
// Function: events_interrupter_init
int
events_interrupter_init(void)
{
	struct sigaction sa;

	/* Clear the flag. */
	events_interrupter_reset();

	/* Set up the SIGUSR1 handler. */
	sa.sa_handler = interrupt;
	if (sigemptyset(&sa.sa_mask)) {
		warnp("siginfo");
		goto err0;
	}
	sa.sa_flags = 0;
	if (sigaction(SIGUSR1, &sa, NULL)) {
		warnp("sigaction");
		goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbx
subq $0xa0, %rsp
movl $0x0, 0x5b02(%rip)      # 0x83c4
leaq 0x9e(%rip), %rax        # 0x2967
leaq 0x10(%rsp), %rdi
movq %rax, -0x8(%rdi)
callq 0x2140
testl %eax, %eax
je 0x28f1
callq 0x2070
cmpl $0x0, (%rax)
je 0x2935
movq %rax, %rbx
leaq 0x27c8(%rip), %rdi      # 0x50b7
jmp 0x2926
leaq 0x8(%rsp), %rsi
movl $0x0, 0x88(%rsi)
xorl %ebx, %ebx
movl $0xa, %edi
xorl %edx, %edx
callq 0x2090
testl %eax, %eax
je 0x2951
callq 0x2070
cmpl $0x0, (%rax)
je 0x293e
movq %rax, %rbx
leaq 0x2799(%rip), %rdi      # 0x50bf
xorl %eax, %eax
callq 0x406c
movl $0x0, (%rbx)
jmp 0x294c
leaq 0x277b(%rip), %rdi      # 0x50b7
jmp 0x2945
leaq 0x277a(%rip), %rdi      # 0x50bf
xorl %eax, %eax
callq 0x418b
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0xa0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/daemonize.c
// Function: daemonize
void
daemonize(void)
{
	switch (fork()) {
	case FORK_FAILED:
		fatal(errno, "daemonize: cannot fork");
		break;
	case VALUE_CHILD_PROCESS:
		if (setsid() == -1)
			fatal(errno, "daemonize: trouble in becoming "
			    "the session leader");
		break;
	default:
		_exit(0);
	}

	/* Calls to the log functions before this log to stderr/stdout. */
	log_init();

	switch (redirect_standard_streams()) {
	case REDIR_STDERR_FAIL:
		log_warn(0, "daemonize: error redirecting stderr");
		break;
	case REDIR_STDIN_FAIL:
		log_warn(0, "daemonize: error redirecting stdin");
		break;
	case REDIR_STDOUT_FAIL:
		log_warn(0, "daemonize: error redirecting stdout");
		break;
	default:
	case REDIR_OK:
		log_debug("daemonize: all standard io-streams successfully "
		    "redirected");
		break;
	}

	if (is_already_running()) {
		fatal(0, "daemonize: fatal: a copy of the daemon is already "
		    "running!");
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
callq 0x4100
testl %eax, %eax
jne 0x4efa
callq 0x4490
cmpl $-0x1, %eax
je 0x4f16
callq 0x5854
callq 0x55ac
cmpl $0x3, %eax
je 0x4e36
cmpl $0x2, %eax
je 0x4e2d
cmpl $0x1, %eax
jne 0x4e48
leaq 0x4298(%rip), %rsi      # 0x90c3
jmp 0x4e3d
leaq 0x42b3(%rip), %rsi      # 0x90e7
jmp 0x4e3d
leaq 0x42cd(%rip), %rsi      # 0x910a
xorl %edi, %edi
xorl %eax, %eax
callq 0x591f
jmp 0x4e56
leaq 0x42df(%rip), %rdi      # 0x912e
xorl %eax, %eax
callq 0x57b1
movups 0x43a3(%rip), %xmm0     # 0x9200
movaps %xmm0, 0x10(%rsp)
movups 0x4387(%rip), %xmm0     # 0x91f0
movaps %xmm0, (%rsp)
leaq 0x41ec(%rip), %rdi      # 0x9060
movl $0x42, %esi
movl $0x1a4, %edx            # imm = 0x1A4
xorl %eax, %eax
callq 0x4310
cmpl $-0x1, %eax
je 0x4f26
movl %eax, %ebx
movq %rsp, %rdx
movl %eax, %edi
movl $0x6, %esi
xorl %eax, %eax
callq 0x4270
movl %eax, %ebp
cmpl $-0x1, %eax
je 0x4ed1
movl %ebx, %edi
xorl %esi, %esi
callq 0x4610
callq 0x4690
movslq %eax, %rdx
leaq 0x4328(%rip), %rsi      # 0x91e8
movl %ebx, %edi
xorl %eax, %eax
callq 0x4240
movl %ebx, 0x9551(%rip)      # 0xe420
jmp 0x4eec
callq 0x4050
movl (%rax), %r14d
movl %ebx, %edi
callq 0x4800
cmpl $0xb, %r14d
je 0x4eec
cmpl $0xd, %r14d
jne 0x4f52
cmpl $-0x1, %ebp
je 0x4f42
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cmpl $-0x1, %eax
jne 0x4f0f
callq 0x4050
movl (%rax), %edi
leaq 0x416d(%rip), %rsi      # 0x907a
jmp 0x4f4b
xorl %edi, %edi
callq 0x4720
callq 0x4050
movl (%rax), %edi
leaq 0x416d(%rip), %rsi      # 0x9091
jmp 0x4f4b
callq 0x4050
movl (%rax), %edi
leaq 0x4270(%rip), %rsi      # 0x91a4
leaq 0x4125(%rip), %rdx      # 0x9060
xorl %eax, %eax
callq 0x563c
leaq 0x4220(%rip), %rsi      # 0x9169
xorl %edi, %edi
xorl %eax, %eax
callq 0x563c
leaq 0x426d(%rip), %rsi      # 0x91c6
leaq 0x4100(%rip), %rdx      # 0x9060
movl %r14d, %edi
jmp 0x4f3b
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/interpreter.cpp
// Function: Interpreter_processAllLines
void
Interpreter_processAllLines(FILE *fp, const char *path, Interpreter_vFunc func1,
    Interpreter_instFunc func2)
{
	char		buf[MAXLINE] = { '\0' };
	long int	line_num = 0;

	while (fgets(buf, sizeof buf, fp) != nullptr) {
		char			*line;
		const char		*cp;
		struct Interpreter_in	 in;

		cp = &buf[0];
		eatwhite(&cp);
		if (strings_match(cp, "") || *cp == CommentChar) {
			line_num++;
			continue;
		}

		line = trim(xstrdup(cp));

		in.path			= const_cast<char *>(path);
		in.line			= line;
		in.line_num		= ++line_num;
		in.validator_func	= func1;
		in.install_func		= func2;
		Interpreter(&in);

		free(line);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xcb8, %rsp            # imm = 0xCB8
movq %rcx, (%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x30(%rsp), %rbp
movl $0xc80, %edx            # imm = 0xC80
movq %rbp, %rdi
xorl %esi, %esi
callq 0x4220
movq %rbp, %rdi
movl $0xc80, %esi            # imm = 0xC80
movq %r12, %rdx
callq 0x4700
testq %rax, %rax
je 0x558e
xorl %ebx, %ebx
movsbl 0x30(%rsp), %edi
callq 0x4080
movq %rbp, %r13
testl %eax, %eax
je 0x551d
movq %rbp, %r13
movsbl 0x1(%r13), %edi
incq %r13
callq 0x4080
testl %eax, %eax
jne 0x550c
cmpb $0x0, (%r13)
je 0x552b
cmpb $0x23, (%r13)
jne 0x5530
incq %rbx
jmp 0x5575
movq %r13, %rdi
callq 0x880a
movq %rax, %rdi
callq 0x8619
movq %rax, %r13
movq %r15, 0x8(%rsp)
movq %rax, 0x10(%rsp)
incq %rbx
movq %rbx, 0x18(%rsp)
movq %r14, 0x20(%rsp)
movq (%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x4f68
movq %r13, %rdi
callq 0x4540
movq %rbp, %rdi
movl $0xc80, %esi            # imm = 0xC80
movq %r12, %rdx
callq 0x4700
testq %rax, %rax
jne 0x54f8
addq $0xcb8, %rsp            # imm = 0xCB8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/log.c
// Function: redirect_standard_streams
redir_res_t
redirect_standard_streams(void)
{
	const char dev_null[] = "/dev/null";

	if (freopen(dev_null, "r+", stderr) == NULL)
		return REDIR_STDERR_FAIL;
	else if (freopen(dev_null, "r+", stdin) == NULL)
		return REDIR_STDIN_FAIL;
	else if (freopen(dev_null, "r+", stdout) == NULL)
		return REDIR_STDOUT_FAIL;
	return REDIR_OK;
}

// Assembly:
subq $0x18, %rsp
movabsq $0x6c756e2f7665642f, %rax # imm = 0x6C756E2F7665642F
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movw $0x6c, 0x8(%rdi)
movq 0x89f1(%rip), %rax      # 0xdfc0
movq (%rax), %rdx
leaq 0x3e43(%rip), %rsi      # 0x941c
callq 0x4450
testq %rax, %rax
je 0x562b
movq 0x89b6(%rip), %rax      # 0xdfa0
movq (%rax), %rdx
leaq 0x3e28(%rip), %rsi      # 0x941c
leaq 0x8(%rsp), %rdi
callq 0x4450
testq %rax, %rax
je 0x5632
movq 0x8976(%rip), %rax      # 0xdf80
movq (%rax), %rdx
leaq 0x3e08(%rip), %rsi      # 0x941c
leaq 0x8(%rsp), %rdi
callq 0x4450
xorl %ecx, %ecx
testq %rax, %rax
sete %cl
leal (%rcx,%rcx,2), %eax
jmp 0x5637
movl $0x1, %eax
jmp 0x5637
movl $0x2, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/log.c
// Function: log_doit
static void
log_doit(int errCode, int priority, const char *fmt, va_list ap)
{
	char buf[2000] = { '\0' };

	(void) vsnprintf(buf, sizeof buf, fmt, ap);

	if (errCode) {
		(void) snprintf(&buf[strlen(buf)], sizeof buf - strlen(buf),
		    ": %s", strerror(errCode));
	}

	if (g_log_to_syslog)
		syslog(priority, "%s", buf);
	else {
		FILE *stream = stderr;

		switch (priority) {
		case LOG_INFO:
		case LOG_DEBUG:
			stream = stdout;
			break;
		}

		(void) fputs(buf, stream);
		(void) fputc('\n', stream);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7d8, %rsp            # imm = 0x7D8
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebx
movl %edi, %ebp
movq %rsp, %r13
movl $0x7d0, %r14d           # imm = 0x7D0
movl $0x7d0, %edx            # imm = 0x7D0
movq %r13, %rdi
xorl %esi, %esi
callq 0x4220
movl $0x7d0, %esi            # imm = 0x7D0
movq %r13, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0x42a0
testl %ebp, %ebp
je 0x573f
movq %rsp, %rdi
callq 0x41c0
leaq (%rsp,%rax), %r15
subq %rax, %r14
movl %ebp, %edi
callq 0x4160
leaq 0x5a39(%rip), %rdx      # 0xb168
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rcx
xorl %eax, %eax
callq 0x4710
cmpb $0x1, 0x8fcb(%rip)      # 0xe711
jne 0x576d
leaq 0x46de(%rip), %rsi      # 0x9e2d
movq %rsp, %rdx
movl %ebx, %edi
xorl %eax, %eax
callq 0x40b0
addq $0x7d8, %rsp            # imm = 0x7D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
andl $-0x2, %ebx
cmpl $0x6, %ebx
jne 0x577e
movq 0x8804(%rip), %rax      # 0xdf80
jmp 0x5785
movq 0x883b(%rip), %rax      # 0xdfc0
movq (%rax), %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x44f0
movl $0xa, %edi
movq %rbx, %rsi
addq $0x7d8, %rsp            # imm = 0x7D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4560
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/main.c
// Function: usage
static __dead void
usage(void)
{
	extern char *__progname;
	char *msgVersion = strdup_printf("%s%s%s %s by %s\n",
	    MAGENTA, g_programName, NORMAL,
	    g_programVersion,
	    g_programAuthor);
	char *msgUsage = strdup_printf("Usage: %s [OPTION] ...\n", __progname);

	(void) fputs(msgVersion, stderr);

	(void) fputc('\n', stderr);
	(void) fputs(msgUsage, stderr);

	free(msgVersion);
	free(msgUsage);

	for (const char **ppcc = &help_text[0];
	     ppcc < &help_text[nitems(help_text)]; ppcc++)
		(void) fputs(*ppcc, stderr);
	exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x3378(%rip), %rdi      # 0x9792
leaq 0x3382(%rip), %rsi      # 0x97a3
leaq 0x3018(%rip), %rdx      # 0x9440
leaq 0x337a(%rip), %rcx      # 0x97a9
leaq 0x3017(%rip), %r8       # 0x944d
leaq 0x3015(%rip), %r9       # 0x9452
xorl %eax, %eax
callq 0x8754
movq %rax, %rbx
movq 0x7b5a(%rip), %rax      # 0xdfa8
movq (%rax), %rsi
leaq 0x3356(%rip), %rdi      # 0x97ae
xorl %eax, %eax
callq 0x8754
movq %rax, %r14
movq 0x7b57(%rip), %r15      # 0xdfc0
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x44f0
movq (%r15), %rsi
movl $0xa, %edi
callq 0x4560
movq (%r15), %rsi
movq %r14, %rdi
callq 0x44f0
movq %rbx, %rdi
callq 0x4540
movq %r14, %rdi
callq 0x4540
movq $-0x8, %rbx
leaq 0x75e6(%rip), %r14      # 0xda90
movq 0x8(%rbx,%r14), %rdi
movq (%r15), %rsi
callq 0x44f0
addq $0x8, %rbx
cmpq $0x58, %rbx
jb 0x64aa
movl $0x1, %edi
callq 0x4550
nop
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/my_vasprintf.c
// Function: my_vasprintf
int
my_vasprintf(char **ret, const char *format, va_list ap)
{
	va_list ap_copy;
	int sz;

	if (ret == NULL || format == NULL) {
		errno = EINVAL;
		return -1;
	}

	va_copy(ap_copy, ap);
	sz = vsnprintf(NULL, 0, format, ap_copy);
	va_end(ap_copy);

	if (sz < 0) {
		*ret = NULL;
		errno = ENOSYS;
		return -1;
	} else {
		sz += 1; /* +1 for `\0'. */
	}

	if ((*ret = malloc(sz)) == NULL) {
		errno = ENOMEM;
		return -1;
	}

	return vsnprintf(*ret, sz, format, ap);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
testb %cl, %al
jne 0x64f4
callq 0x4050
movl $0x16, (%rax)
jmp 0x6566
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdx), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
movups (%rdx), %xmm0
movaps %xmm0, (%rcx)
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x42a0
testl %eax, %eax
js 0x6547
movl %eax, %r12d
incl %r12d
movq %r12, %rdi
callq 0x45e0
movq %rax, (%r15)
testq %rax, %rax
je 0x655b
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x42a0
jmp 0x656b
movq $0x0, (%r15)
callq 0x4050
movl $0x26, (%rax)
jmp 0x6566
callq 0x4050
movl $0xc, (%rax)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/network-openssl.c
// Function: net_ssl_begin
int
net_ssl_begin(void)
{
	const char		*err_reason = "";
	static const int	 VALUE_HANDSHAKE_OK = 1;

	if (ssl != NULL) {
		err_reason = "the ssl object appears to be non-null";
		goto err;
	} else if ((ssl = SSL_new(ssl_ctx)) == NULL) {
		fatal(ENOMEM, "%s: unable to create a new ssl object",
		    __func__);
	} else if (!SSL_set_fd(ssl, g_socket)) {
		err_reason = "unable to associate the global socket fd with "
		    "the ssl object";
		goto err;
	}

	SSL_set_connect_state(ssl);

	if (SSL_connect(ssl) != VALUE_HANDSHAKE_OK) {
		err_reason = "handshake not ok!";
		goto err;
	}

	return 0;

  err:
	log_warn(0, "%s: %s", __func__, err_reason);
	return -1;
}

// Assembly:
pushq %rax
cmpq $0x0, 0x7db4(%rip)      # 0xe7e0
je 0x6a53
leaq 0x3620(%rip), %rcx      # 0xa055
leaq 0x36c2(%rip), %rsi      # 0xa0fe
leaq 0x365e(%rip), %rdx      # 0xa0a1
xorl %edi, %edi
xorl %eax, %eax
callq 0x591f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rcx
retq
movq 0x7d8e(%rip), %rdi      # 0xe7e8
callq 0x4430
movq %rax, 0x7d7a(%rip)      # 0xe7e0
testq %rax, %rax
je 0x6ab3
leaq 0x79de(%rip), %rcx      # 0xe450
movl (%rcx), %esi
movq %rax, %rdi
callq 0x4290
testl %eax, %eax
je 0x6aaa
movq 0x7d59(%rip), %rdi      # 0xe7e0
callq 0x4170
movq 0x7d4d(%rip), %rdi      # 0xe7e0
callq 0x4660
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
je 0x6a51
leaq 0x3644(%rip), %rcx      # 0xa0ec
jmp 0x6a35
leaq 0x35fe(%rip), %rcx      # 0xa0af
jmp 0x6a35
leaq 0x35c1(%rip), %rsi      # 0xa07b
leaq 0x35e0(%rip), %rdx      # 0xa0a1
movl $0xc, %edi
xorl %eax, %eax
callq 0x563c
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/network-openssl.c
// Function: net_ssl_end
void
net_ssl_end(void)
{
	if (ssl) {
		switch (SSL_shutdown(ssl)) {
		case 0:
			log_debug("%s: SSL_shutdown: not yet finished",
			    __func__);
			(void) SSL_shutdown(ssl);
			break;
		case 1:
			/* success! */
			break;
		default:
			log_warn(0, "%s: SSL_shutdown: error", __func__);
			break;
		}

		SSL_free(ssl);
		ssl = NULL;
	}
}

// Assembly:
movq 0x7d0c(%rip), %rdi      # 0xe7e0
testq %rdi, %rdi
je 0x6b3d
pushq %rax
callq 0x44e0
cmpl $0x1, %eax
je 0x6b22
testl %eax, %eax
jne 0x6b0b
leaq 0x3616(%rip), %rdi      # 0xa105
leaq 0x3632(%rip), %rsi      # 0xa128
xorl %eax, %eax
callq 0x57b1
movq 0x7cdc(%rip), %rdi      # 0xe7e0
callq 0x44e0
jmp 0x6b22
leaq 0x3622(%rip), %rsi      # 0xa134
leaq 0x360f(%rip), %rdx      # 0xa128
xorl %edi, %edi
xorl %eax, %eax
callq 0x591f
movq 0x7cb7(%rip), %rdi      # 0xe7e0
callq 0x4250
movq $0x0, 0x7ca7(%rip) # 0xe7e0
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/network-openssl.c
// Function: verify_callback
static int
verify_callback(int ok, X509_STORE_CTX *ctx)
{
	X509		*cert = X509_STORE_CTX_get_current_cert(ctx);
	char		 issuer[256] = { '\0' };
	char		 subject[256] = { '\0' };
	const int	 depth = X509_STORE_CTX_get_error_depth(ctx);
	const int	 err = X509_STORE_CTX_get_error(ctx);

	(void) X509_NAME_oneline(X509_get_issuer_name(cert), issuer,
	    sizeof issuer);
	(void) X509_NAME_oneline(X509_get_subject_name(cert), subject,
	    sizeof subject);

	if (!ok) {
		log_warn(0, "Error with certificate at depth: %d", depth);
		log_warn(0, "  issuer  = %s", issuer);
		log_warn(0, "  subject = %s", subject);
		log_warn(0, "Reason: %s", X509_verify_cert_error_string(err));
	} else {
		log_debug("Cert verification OK!");
		log_debug("  issuer  = %s", issuer);
		log_debug("  subject = %s", subject);
	}
	return (ok);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %rbp
movl %edi, %ebx
movq %rsi, %rdi
callq 0x4750
movq %rax, %r14
leaq 0x100(%rsp), %r12
movl $0x100, %edx            # imm = 0x100
movq %r12, %rdi
xorl %esi, %esi
callq 0x4220
movq %rsp, %r13
movl $0x100, %edx            # imm = 0x100
movq %r13, %rdi
xorl %esi, %esi
callq 0x4220
movq %rbp, %rdi
callq 0x42c0
movl %eax, %r15d
movq %rbp, %rdi
callq 0x4320
movl %eax, %ebp
movq %r14, %rdi
callq 0x4420
movq %rax, %rdi
movq %r12, %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x4300
movq %r14, %rdi
callq 0x4460
movq %rax, %rdi
movq %r13, %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x4300
testl %ebx, %ebx
je 0x6de8
leaq 0x351a(%rip), %rdi      # 0xa2d2
xorl %eax, %eax
callq 0x57b1
leaq 0x34e3(%rip), %rdi      # 0xa2a9
leaq 0x100(%rsp), %rsi
xorl %eax, %eax
callq 0x57b1
leaq 0x34dc(%rip), %rdi      # 0xa2b8
movq %rsp, %rsi
xorl %eax, %eax
callq 0x57b1
jmp 0x6e41
leaq 0x3496(%rip), %rsi      # 0xa285
xorl %edi, %edi
movl %r15d, %edx
xorl %eax, %eax
callq 0x591f
leaq 0x34a7(%rip), %rsi      # 0xa2a9
leaq 0x100(%rsp), %rdx
xorl %edi, %edi
xorl %eax, %eax
callq 0x591f
leaq 0x349e(%rip), %rsi      # 0xa2b8
movq %rsp, %rdx
xorl %edi, %edi
xorl %eax, %eax
callq 0x591f
movslq %ebp, %rdi
callq 0x42e0
leaq 0x3492(%rip), %rsi      # 0xa2c7
xorl %edi, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x591f
movl %ebx, %eax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/network-openssl.c
// Function: net_ssl_deinit
void
net_ssl_deinit(void)
{
	net_ssl_end();

	if (ssl_ctx) {
		SSL_CTX_free(ssl_ctx);
		ssl_ctx = NULL;
	}
}

// Assembly:
pushq %rax
callq 0x6acd
movq 0x7986(%rip), %rdi      # 0xe7e8
testq %rdi, %rdi
je 0x6e77
callq 0x4090
movq $0x0, 0x7971(%rip) # 0xe7e8
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/network.c
// Function: net_send_plain
int
net_send_plain(const char *fmt, ...)
{
	bool		 ok = true;
	char		*buf = NULL;
	size_t		 newSize = 0;
	static const char
			 message_terminate[] = "\r\n\r\n";
	va_list		 ap;

	log_assert_arg_nonnull("net_send_plain", "fmt", fmt);

	va_start(ap, fmt);
	if (errno = 0, my_vasprintf(&buf, fmt, ap) < 0)
		fatal(errno, "net_send_plain: my_vasprintf");
	va_end(ap);

	newSize = strlen(buf) + nitems(message_terminate);
	buf = xrealloc(buf, newSize);

	if (strlcat(buf, message_terminate, newSize) >= newSize)
		fatal(EOVERFLOW, "net_send_plain: strlcat");
	if (errno = 0, send(g_socket, buf, strlen(buf), 0) == -1)
		ok = false;
	if (!ok)
		log_warn(errno, "net_send_plain: send");
	free(buf);
	return (ok ? 0 : -1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xe8, %rsp
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
testb %al, %al
je 0x6ee0
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movq $0x0, 0x8(%rsp)
testq %rdi, %rdi
je 0x6fe7
movq %rdi, %r14
leaq 0x30(%rsp), %rax
leaq 0x10(%rsp), %r15
movq %rax, 0x10(%r15)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%r15)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r15)
callq 0x4050
movq %rax, %rbx
movl $0x0, (%rax)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x64cc
testl %eax, %eax
js 0x7008
movq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x41c0
movq %rax, %r15
addq $0x5, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x894d
movq %rax, 0x8(%rsp)
leaq 0x36db(%rip), %rsi      # 0xa648
movq %rax, %rdi
movq %r15, %rdx
callq 0x8344
cmpq %r15, %rax
jae 0x7013
movl $0x0, (%rbx)
movl 0x74c3(%rip), %ebp      # 0xe450
movq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x41c0
movl %ebp, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x4200
movq %rax, %r14
cmpq $-0x1, %rax
jne 0x6fc2
movl (%rbx), %edi
leaq 0x34a6(%rip), %rsi      # 0xa461
xorl %eax, %eax
callq 0x591f
xorl %ebx, %ebx
cmpq $-0x1, %r14
sete %bl
movq 0x8(%rsp), %rdi
callq 0x4540
negl %ebx
movl %ebx, %eax
addq $0xe8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x31ed(%rip), %rsi      # 0xa1db
leaq 0x3428(%rip), %rdx      # 0xa41d
leaq 0x2f73(%rip), %rcx      # 0x9f6f
movl $0x16, %edi
xorl %eax, %eax
callq 0x563c
movl (%rbx), %edi
leaq 0x341b(%rip), %rsi      # 0xa42c
jmp 0x701f
leaq 0x342f(%rip), %rsi      # 0xa449
movl $0x4b, %edi
xorl %eax, %eax
callq 0x563c
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/network.c
// Function: net_recv_plain
int
net_recv_plain(char *recvbuf, size_t recvbuf_size)
{
#if IO_MULTIPLEXING
	const int	 maxfdp1 = g_socket + 1;
	fd_set		 readset;
	struct timeval	 tv;

	tv.tv_sec	= 10;
	tv.tv_usec	= 333;

	FD_ZERO(&readset);
	FD_SET(g_socket, &readset);

	if (select(maxfdp1, &readset, NULL, NULL, &tv) == -1) {
		log_warn(errno, "net_recv_plain: select");
		return -1;
	} else if (!FD_ISSET(g_socket, &readset)) {
		log_warn(0, "net_recv_plain: no data to receive  --  "
		    "timed out!");
		return -1;
	}
#endif /* IO_MULTIPLEXING */

	log_assert_arg_nonnull("net_recv_plain", "recvbuf", recvbuf);

	switch (recv(g_socket, recvbuf, recvbuf_size, 0)) {
	case -1:
		log_warn(errno, "net_recv_plain: recv");
		return -1;
	case 0:
		log_warn(0, "net_recv_plain: fatal: connection lost");
		return -1;
	default:
		break;
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x7413(%rip), %ecx      # 0xe450
movq %rsp, %r8
movq $0xa, (%r8)
movq $0x14d, 0x8(%r8)        # imm = 0x14D
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x70(%rsi)
leal 0x1(%rcx), %edi
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, 0x10(%rsp,%rax,8)
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x43d0
cmpl $-0x1, %eax
je 0x70f5
movl 0x73a2(%rip), %edi      # 0xe450
leal 0x3f(%rdi), %eax
testl %edi, %edi
cmovnsl %edi, %eax
sarl $0x6, %eax
cltq
movq 0x10(%rsp,%rax,8), %rax
btq %rdi, %rax
jae 0x7105
testq %r14, %r14
je 0x7131
xorl %ebp, %ebp
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x4150
testq %rax, %rax
je 0x710e
cmpq $-0x1, %rax
jne 0x7123
callq 0x4050
movl (%rax), %edi
leaq 0x33dc(%rip), %rsi      # 0xa4cf
jmp 0x7117
callq 0x4050
movl (%rax), %edi
leaq 0x3373(%rip), %rsi      # 0xa476
jmp 0x7117
leaq 0x3381(%rip), %rsi      # 0xa48d
jmp 0x7115
leaq 0x33cf(%rip), %rsi      # 0xa4e4
xorl %edi, %edi
xorl %eax, %eax
callq 0x591f
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x30a3(%rip), %rsi      # 0xa1db
leaq 0x3381(%rip), %rdx      # 0xa4c0
leaq 0x2eb9(%rip), %rcx      # 0x9fff
movl $0x16, %edi
xorl %eax, %eax
callq 0x563c
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/network.c
// Function: net_connect
int
net_connect(void)
{
	bool			 connected = false;
	const char		*host = setting("sp_hostname");
	const char		*port = setting("port");
	struct addrinfo		*res, *rp;

	log_debug("connecting to %s (%s)...", host, port);

	if ((res = net_addr_resolve(host, port)) == NULL) {
		log_warn(0, "unable to get a list of ip addresses. "
		    "bogus hostname?");
		return -1;
	} else {
		log_debug("get a list of ip addresses complete");
	}

	for (rp = res; rp; rp = rp->ai_next) {
		g_socket =
		    socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);

		if (g_socket == SOCKET_CREATION_FAILED) {
			continue;
		} else if (connect(g_socket, rp->ai_addr, rp->ai_addrlen) == 0) {
			log_debug("connected!");
			connected = true;
			break;
		} else {
			(void) close(g_socket);
		}
	}

	freeaddrinfo(res);

	if (!connected || (ssl_is_enabled() && net_ssl_begin() == -1)) {
		log_warn(0, "failed to establish a connection");
		return -1;
	}
	if (ssl_is_enabled() &&
	    net_ssl_check_hostname(host, 0) == HOSTNAME_MISMATCH) {
		log_warn(0, "net_ssl_check_hostname: warning: "
		    "hostname checking failed: "
		    "hostname specified by 'sp_hostname' mismatch: "
		    "failed to establish a connection");
		return -1;
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x2c55(%rip), %rdi      # 0x9db5
callq 0x798d
movq %rax, %rbx
leaq 0x31a1(%rip), %rdi      # 0xa310
callq 0x798d
movq %rax, %r14
leaq 0x3197(%rip), %rdi      # 0xa315
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x57b1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x72a2
testq %rax, %rax
je 0x7203
movq %rax, %r14
leaq 0x31bf(%rip), %rdi      # 0xa364
xorl %eax, %eax
callq 0x57b1
movq %r14, %r15
movl 0x4(%r15), %edi
movl 0x8(%r15), %esi
movl 0xc(%r15), %edx
callq 0x40f0
movl %eax, 0x728a(%rip)      # 0xe450
cmpl $-0x1, %eax
je 0x71e9
movq 0x18(%r15), %rsi
movl 0x10(%r15), %edx
movl %eax, %edi
callq 0x4360
testl %eax, %eax
je 0x7225
movl 0x726c(%rip), %edi      # 0xe450
callq 0x4800
movq 0x28(%r15), %r15
testq %r15, %r15
jne 0x71af
movq %r14, %rdi
callq 0x45c0
leaq 0x31fb(%rip), %rsi      # 0xa3fc
jmp 0x720a
leaq 0x3124(%rip), %rsi      # 0xa32e
xorl %edi, %edi
xorl %eax, %eax
callq 0x591f
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x315c(%rip), %rdi      # 0xa388
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x57b1
movq %r14, %rdi
callq 0x45c0
leaq 0x30cc(%rip), %rdi      # 0xa310
callq 0x798d
leaq 0x33f4(%rip), %rsi      # 0xa644
movq %rax, %rdi
callq 0x4640
testl %eax, %eax
jne 0x7266
callq 0x6a23
cmpl $-0x1, %eax
je 0x71fa
leaq 0x30a3(%rip), %rdi      # 0xa310
callq 0x798d
leaq 0x33cb(%rip), %rsi      # 0xa644
movq %rax, %rdi
callq 0x4640
testl %eax, %eax
jne 0x7218
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6578
cmpl $0x1, %eax
jne 0x7218
leaq 0x30f6(%rip), %rsi      # 0xa393
jmp 0x720a
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/network.c
// Function: net_addr_resolve
static struct addrinfo *
net_addr_resolve(const char *host, const char *port)
{
	struct addrinfo		*res;
	struct addrinfo		 hints = { 0 };

	if (host == NULL || port == NULL)
		return NULL;

	hints.ai_flags     = AI_CANONNAME;
	hints.ai_family    = AF_UNSPEC;
	hints.ai_socktype  = SOCK_STREAM;
	hints.ai_protocol  = 0;
	hints.ai_addrlen   = 0;
	hints.ai_addr      = NULL;
	hints.ai_canonname = NULL;
	hints.ai_next      = NULL;

	if (getaddrinfo(host, port, &hints, &res) != 0)
		return NULL;
	return res;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x72cd
xorl %ebx, %ebx
jmp 0x7300
movaps 0x302c(%rip), %xmm1     # 0xa300
leaq 0x10(%rsp), %rdx
movaps %xmm1, (%rdx)
movl $0x0, 0x10(%rdx)
movups %xmm0, 0x18(%rdx)
xorl %ebx, %ebx
movq %rbx, 0x28(%rdx)
leaq 0x8(%rsp), %rcx
callq 0x4590
testl %eax, %eax
jne 0x7300
movq 0x8(%rsp), %rbx
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/network.c
// Function: net_disconnect
void
net_disconnect(void)
{
	if (ssl_is_enabled())
		net_ssl_end();
	if (g_socket != -1) {
		(void) close(g_socket);
		g_socket = -1;
	}
}

// Assembly:
pushq %rax
leaq 0x2fff(%rip), %rdi      # 0xa310
callq 0x798d
leaq 0x3327(%rip), %rsi      # 0xa644
movq %rax, %rdi
callq 0x4640
testl %eax, %eax
jne 0x732e
callq 0x6acd
movl 0x711c(%rip), %edi      # 0xe450
cmpl $-0x1, %edi
je 0x7348
callq 0x4800
movl $0xffffffff, 0x7108(%rip) # imm = 0xFFFFFFFF
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/network.c
// Function: net_deinit
void
net_deinit(void)
{
	if (ssl_is_enabled())
		net_ssl_deinit();
	if (g_socket != -1) {
		(void) close(g_socket);
		g_socket = -1;
	}
}

// Assembly:
pushq %rax
leaq 0x2d52(%rip), %rdi      # 0xa310
callq 0x798d
leaq 0x307a(%rip), %rsi      # 0xa644
movq %rax, %rdi
callq 0x4640
testl %eax, %eax
jne 0x75db
callq 0x6e55
movl 0x6e6f(%rip), %edi      # 0xe450
cmpl $-0x1, %edi
je 0x75f5
callq 0x4800
movl $0xffffffff, 0x6e5b(%rip) # imm = 0xFFFFFFFF
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/settings.c
// Function: setting_bool
bool
setting_bool(const char *setting_name, const bool fallback_val)
{
	if (setting_name == NULL)
		return fallback_val;
	FOREACH_CDV() {
		if (strings_match(setting_name, cdv->setting_name)) {
			const char *value =
			    (cdv->custom_val ? cdv->custom_val : cdv->value);

			if (cdv->type != TYPE_BOOLEAN) {
				log_warn(0, "setting_bool: %s: "
				    "setting not a boolean!", setting_name);
				break;
			} else if (strings_match(value, "yes") ||
				   strings_match(value, "YES")) {
				return true;
			} else if (strings_match(value, "no") ||
				   strings_match(value, "NO")) {
				return false;
			} else {
				log_warn(0, "setting_bool: %s: "
				    "setting has an invalid value!",
				    setting_name);
				break;
			}
		}
	}
	return fallback_val;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
testq %rdi, %rdi
je 0x7665
movq %rdi, %r14
movq $-0x28, %r12
leaq 0x6e45(%rip), %r13      # 0xe460
movq 0x28(%r12,%r13), %rsi
movq %r14, %rdi
callq 0x4640
testl %eax, %eax
je 0x763b
addq $0x28, %r12
cmpq $0x167, %r12            # imm = 0x167
jbe 0x761b
jmp 0x7665
movq 0x40(%r12,%r13), %r15
testq %r15, %r15
jne 0x764a
movq 0x38(%r12,%r13), %r15
cmpl $0x0, 0x30(%r12,%r13)
je 0x7678
leaq 0x2ff4(%rip), %rsi      # 0xa64d
xorl %edi, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x591f
movl %ebx, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ff7(%rip), %rsi      # 0xa676
movq %r15, %rdi
callq 0x4640
movb $0x1, %bpl
testl %eax, %eax
je 0x7667
leaq 0x2fe5(%rip), %rsi      # 0xa67a
movq %r15, %rdi
callq 0x4640
testl %eax, %eax
je 0x7667
leaq 0x2fd6(%rip), %rsi      # 0xa67e
movq %r15, %rdi
callq 0x4640
testl %eax, %eax
je 0x76d0
leaq 0x339e(%rip), %rsi      # 0xaa59
movq %r15, %rdi
callq 0x4640
testl %eax, %eax
je 0x76d0
leaq 0x2fb3(%rip), %rsi      # 0xa681
jmp 0x7659
xorl %ebp, %ebp
jmp 0x7667
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/settings.c
// Function: is_setting_ok
static bool
is_setting_ok(const char *value, enum setting_type type)
{
	if (value == NULL)
		return false;

	switch (type) {
	case TYPE_BOOLEAN: {
		if (!strings_match(value, "yes") &&
		    !strings_match(value, "YES") &&
		    !strings_match(value, "no") &&
		    !strings_match(value, "NO")) {
			log_warn(0, "%s is_setting_ok: "
			    "booleans must be either: yes, YES, no or NO",
			    GfxFailure);
			return false;
		}
		break;
	}
	case TYPE_INTEGER: {
		if (!is_numeric(value)) {
			log_warn(0, "%s is_setting_ok: integer not all numeric",
			    GfxFailure);
			return false;
		}
		break;
	}
	case TYPE_STRING: {
		if (strpbrk(value, " \f\n\r\t\v\"") != NULL) {
			log_warn(0, "%s is_setting_ok: "
			    "illegal characters in string", GfxFailure);
			return false;
		}
		break;
	}
	default:
		fatal(0, "is_setting_ok: statement reached unexpectedly");
		break;
	}

	return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7927
movq %rdi, %r14
cmpl $0x2, %esi
je 0x7942
cmpl $0x1, %esi
je 0x792b
testl %esi, %esi
jne 0x797d
leaq 0x2da3(%rip), %rsi      # 0xa676
movq %r14, %rdi
callq 0x4640
movb $0x1, %bl
testl %eax, %eax
je 0x7973
leaq 0x2d8e(%rip), %rsi      # 0xa67a
movq %r14, %rdi
callq 0x4640
testl %eax, %eax
je 0x7973
leaq 0x2d7f(%rip), %rsi      # 0xa67e
movq %r14, %rdi
callq 0x4640
testl %eax, %eax
je 0x7973
leaq 0x3147(%rip), %rsi      # 0xaa59
movq %r14, %rdi
callq 0x4640
testl %eax, %eax
je 0x7973
leaq 0x30f9(%rip), %rsi      # 0xaa1e
jmp 0x795d
xorl %ebx, %ebx
jmp 0x7973
movq %r14, %rdi
callq 0x84ea
movb $0x1, %bl
testb %al, %al
jne 0x7973
leaq 0x311c(%rip), %rsi      # 0xaa5c
jmp 0x795d
leaq 0x313d(%rip), %rsi      # 0xaa86
movq %r14, %rdi
callq 0x4780
testq %rax, %rax
je 0x7971
leaq 0x3131(%rip), %rsi      # 0xaa8e
leaq 0x31cc(%rip), %rdx      # 0xab30
xorl %ebx, %ebx
xorl %edi, %edi
xorl %eax, %eax
callq 0x591f
jmp 0x7973
movb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3139(%rip), %rsi      # 0xaabd
xorl %edi, %edi
xorl %eax, %eax
callq 0x563c
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/settings.c
// Function: setting
const char *
setting(const char *setting_name)
{
	if (setting_name == NULL) {
		return ("");
	}

	FOREACH_CDV() {
		if (strings_match(setting_name, cdv->setting_name))
			return (cdv->custom_val ? cdv->custom_val : cdv->value);
	}

	return ("");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x250f(%rip), %rbx      # 0x9eab
testq %rdi, %rdi
je 0x79e1
movq %rdi, %r14
movq $-0x28, %r15
leaq 0x6aae(%rip), %r12      # 0xe460
movq 0x28(%r15,%r12), %rsi
movq %r14, %rdi
callq 0x4640
testl %eax, %eax
je 0x79d2
addq $0x28, %r15
cmpq $0x167, %r15            # imm = 0x167
jbe 0x79b2
jmp 0x79e1
movq 0x40(%r15,%r12), %rbx
testq %rbx, %rbx
jne 0x79e1
movq 0x38(%r15,%r12), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/settings.c
// Function: setting_integer
long int
setting_integer(const struct integer_context *ctx)
{
	long int val = 0;

	log_assert_arg_nonnull("setting_integer", "ctx", ctx);

	FOREACH_CDV() {
		if (strings_match(ctx->setting_name, cdv->setting_name)) {
			const char *str =
			    (cdv->custom_val ? cdv->custom_val : cdv->value);
			errno = 0;
			val = strtol(str, NULL, 10);

			if (errno != 0 ||
			    (val < ctx->lo_limit || val > ctx->hi_limit)) {
				log_warn(ERANGE, "warning: setting %s "
				    "out of range %ld-%ld: "
				    "fallback value is %ld", ctx->setting_name,
				    ctx->lo_limit, ctx->hi_limit,
				    ctx->fallback_val);
				break;
			} else {
				return val;
			}
		}
	}

	return (ctx->fallback_val);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7ab7
movq %rdi, %rbx
movq (%rdi), %r14
movq $-0x28, %r15
leaq 0x6a4b(%rip), %r12      # 0xe460
movq 0x28(%r15,%r12), %rsi
movq %r14, %rdi
callq 0x4640
testl %eax, %eax
je 0x7a37
addq $0x28, %r15
cmpq $0x167, %r15            # imm = 0x167
jbe 0x7a15
movb $0x1, %al
jmp 0x7a9c
movq 0x40(%r15,%r12), %r14
testq %r14, %r14
jne 0x7a46
movq 0x38(%r15,%r12), %r14
callq 0x4050
movq %rax, %r15
movl $0x0, (%rax)
movq %r14, %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x4650
movq %rax, %r14
cmpl $0x0, (%r15)
jne 0x7a78
cmpq 0x8(%rbx), %r14
jl 0x7a78
cmpq 0x10(%rbx), %r14
jle 0x7ab3
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %r8
movq 0x18(%rbx), %r9
leaq 0x2cac(%rip), %rsi      # 0xa73a
movl $0x22, %edi
xorl %eax, %eax
callq 0x591f
movb $0x1, %al
testb %al, %al
je 0x7aa4
movq 0x18(%rbx), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0x7a9c
leaq 0x271d(%rip), %rsi      # 0xa1db
leaq 0x2c61(%rip), %rdx      # 0xa726
leaq 0x2c6a(%rip), %rcx      # 0xa736
movl $0x16, %edi
xorl %eax, %eax
callq 0x563c
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/settings.c
// Function: is_hostname_ok
static bool
is_hostname_ok(const char *host, const char **reason)
{
	const char host_chars[] =
	    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
	    "abcdefghijklmnopqrstuvwxyz"
	    "0123456789-.:";
	const size_t host_maxlen = 255;

	if (strings_match(host, "")) {
		*reason = "empty setting";
		return false;
	} else if (strlen(host) > host_maxlen) {
		*reason = "name too long";
		return false;
	} else {
		for (const char *cp = host; *cp; cp++) {
			if (strchr(host_chars, *cp) == NULL) {
				*reason = "invalid chars found!";
				return false;
			}
		}
	}

	*reason = "";
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x321c(%rip), %rsi      # 0xaef0
movq %rsp, %rax
movl $0x8, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movw $0x3a, 0x40(%rax)
cmpb $0x0, (%r14)
je 0x7d07
movq %r14, %rdi
callq 0x41c0
cmpq $0xff, %rax
jbe 0x7d21
leaq 0x2df4(%rip), %r12      # 0xaaf9
jmp 0x7d0e
leaq 0x2ddd(%rip), %r12      # 0xaaeb
xorl %eax, %eax
movq %r12, (%rbx)
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movb (%r14), %cl
leaq 0x2180(%rip), %r12      # 0x9eab
testb %cl, %cl
je 0x7d5b
incq %r14
movq %rsp, %r15
leaq 0x2dcb(%rip), %r13      # 0xab07
movsbl %cl, %esi
movq %r15, %rdi
callq 0x4180
testq %rax, %rax
setne %al
je 0x7d5f
movb (%r14), %cl
incq %r14
testb %cl, %cl
jne 0x7d3c
jmp 0x7d10
movb $0x1, %al
jmp 0x7d10
movq %r13, %r12
jmp 0x7d10
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/settings.c
// Function: create_config_file
void
create_config_file(const char *path)
{
	const mode_t	 mode = (S_IRUSR | S_IWUSR);
	int		 fd;

	log_assert_arg_nonnull("create_config_file", "path", path);

	if (file_exists(path)) {
		fatal(EEXIST, "%s %s: can't create config file  --  "
		    "it's already existent", GfxFailure, __func__);
	} else if ((fd = creat(path, mode)) < 0) {
		fatal(errno, "%s %s: creat", GfxFailure, __func__);
	}

	FOREACH_CDV() {
		char	*ans = NULL;
		int	 ret = -1;

		while ((ans = get_answer(cdv->description, cdv->type,
		    cdv->value)) == NULL)
			/* continue */;
		ret = dprintf(fd, "%s = \"%s\";\n", cdv->setting_name, ans);
		if (ret < 0) {
			fatal(0, "%s %s: failed to write to the file stream",
			    GfxFailure, __func__);
		}
		free(ans);
	}

	if (!(fd < 0) && close(fd) != 0)
		fatal(errno, "%s %s: close", GfxFailure, __func__);
	printf("%s %s successfully written!\n", GfxSuccess, path);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7e4f
movq %rdi, %rbx
callq 0x843c
testb %al, %al
jne 0x7e6b
movq %rbx, %rdi
movl $0x180, %esi            # imm = 0x180
callq 0x42d0
testl %eax, %eax
js 0x7e87
movl %eax, %ebp
leaq 0x66ba(%rip), %r12      # 0xe460
leaq 0x2b39(%rip), %r14      # 0xa8e6
xorl %r13d, %r13d
movq 0x20(%r13,%r12), %rdi
movl 0x8(%r13,%r12), %esi
movq 0x10(%r13,%r12), %rdx
callq 0x76d4
testq %rax, %rax
je 0x7db0
movq %rax, %r15
movq (%r13,%r12), %rdx
movl %ebp, %edi
movq %r14, %rsi
movq %rax, %rcx
xorl %eax, %eax
callq 0x4240
testl %eax, %eax
js 0x7e31
movq %r15, %rdi
callq 0x4540
leaq 0x28(%r13), %rax
cmpq $0x168, %r13            # imm = 0x168
movq %rax, %r13
jb 0x7db0
movl %ebp, %edi
callq 0x4800
testl %eax, %eax
jne 0x7e97
leaq 0x2b17(%rip), %rdi      # 0xa929
leaq 0x2d26(%rip), %rsi      # 0xab3f
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4060
leaq 0x2aba(%rip), %rsi      # 0xa8f2
leaq 0x2cf1(%rip), %rdx      # 0xab30
leaq 0x2a40(%rip), %rcx      # 0xa886
xorl %edi, %edi
xorl %eax, %eax
callq 0x563c
leaq 0x2385(%rip), %rsi      # 0xa1db
leaq 0x2a29(%rip), %rdx      # 0xa886
leaq 0x2a35(%rip), %rcx      # 0xa899
movl $0x16, %edi
jmp 0x7e48
leaq 0x2a2c(%rip), %rsi      # 0xa89e
leaq 0x2cb7(%rip), %rdx      # 0xab30
leaq 0x2a06(%rip), %rcx      # 0xa886
movl $0x11, %edi
jmp 0x7e48
callq 0x4050
movl (%rax), %edi
leaq 0x2a44(%rip), %rsi      # 0xa8d9
jmp 0x7ea5
callq 0x4050
movl (%rax), %edi
leaq 0x2a77(%rip), %rsi      # 0xa91c
leaq 0x2c84(%rip), %rdx      # 0xab30
leaq 0x29d3(%rip), %rcx      # 0xa886
jmp 0x7e48
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/settings.c
// Function: destroy_config_custom_values
void
destroy_config_custom_values(void)
{
	FOREACH_CDV() {
		if (cdv->custom_val) {
			free(cdv->custom_val);
			cdv->custom_val = NULL;
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq $-0x28, %rbx
leaq 0x6599(%rip), %r14      # 0xe460
movq 0x40(%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x7edf
callq 0x4540
movq $0x0, 0x40(%rbx,%r14)
addq $0x28, %rbx
cmpq $0x168, %rbx            # imm = 0x168
jb 0x7ec7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/settings.c
// Function: read_config_file
void
read_config_file(const char *path)
{
	FILE *fp = NULL;

	log_assert_arg_nonnull("read_config_file", "path", path);

	if (g_conf_read) {
		return;
	} else if (!is_regularFile(path)) {
		fatal(0, "%s: either the config file is nonexistent"
		    "  --  or it isn't a regular file", __func__);
	} else if ((fp = fopen(path, "r")) == NULL) {
		fatal(errno, "%s: fopen", __func__);
	}

	Interpreter_processAllLines(fp, path, is_recognized_setting,
	    install_setting);

	if (feof(fp))
		fclose(fp);
	else if (ferror(fp))
		fatal(0, "%s: %s", __func__, g_fgets_nullret_err1);
	else
		fatal(0, "%s: %s", __func__, g_fgets_nullret_err2);

	g_conf_read = true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7f65
cmpb $0x0, 0x68ec(%rip)      # 0xe7f0
jne 0x7f5d
movq %rdi, %rbx
callq 0x853d
testb %al, %al
je 0x7f81
leaq 0x1b3e(%rip), %rsi      # 0x9a57
movq %rbx, %rdi
callq 0x4530
testq %rax, %rax
je 0x7f93
movq %rax, %r14
leaq 0xaf(%rip), %rdx        # 0x7fdf
leaq 0x109(%rip), %rcx       # 0x8040
movq %rax, %rdi
movq %rbx, %rsi
callq 0x54ab
movq %r14, %rdi
callq 0x46e0
movq %r14, %rdi
testl %eax, %eax
je 0x7faf
callq 0x4410
movb $0x1, 0x6893(%rip)      # 0xe7f0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x226f(%rip), %rsi      # 0xa1db
leaq 0x29d3(%rip), %rdx      # 0xa946
leaq 0x291f(%rip), %rcx      # 0xa899
movl $0x16, %edi
jmp 0x7fd8
leaq 0x29cf(%rip), %rsi      # 0xa957
leaq 0x29b7(%rip), %rdx      # 0xa946
xorl %edi, %edi
jmp 0x7fa8
callq 0x4050
movl (%rax), %edi
leaq 0x2a00(%rip), %rsi      # 0xa9a1
leaq 0x299e(%rip), %rdx      # 0xa946
xorl %eax, %eax
callq 0x563c
callq 0x47b0
leaq 0x2143(%rip), %rsi      # 0xa0fe
leaq 0x2984(%rip), %rdx      # 0xa946
testl %eax, %eax
jne 0x7fcf
leaq 0x1293(%rip), %rcx      # 0x9260
jmp 0x7fd6
leaq 0x123a(%rip), %rcx      # 0x9210
xorl %edi, %edi
xorl %eax, %eax
callq 0x563c