LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/jalalium[P]graph_algorithms_task/src_scc_para/create_graph.c
// Function: init_adj
int	init_adj(t_graph *g)
{
	if(!(g->adj = (t_vect*)malloc(sizeof(t_vect)*g->vertx)))
		return 0;
	if(!(g->rev_adj = (t_vect*)malloc(sizeof(t_vect)*g->vertx)))
		return 0;
	for (int i = 0; i < g->vertx; i++)
		if (!(init_vector(&g->adj[i])))
			return 0;
	for (int i = 0; i < g->vertx; i++)
		if (!(init_vector(&g->rev_adj[i])))
			return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movslq 0x34(%rdi), %r12
leaq (,%r12,8), %rax
leaq (%rax,%rax,2), %r15
movq %r15, %rdi
callq 0x10b0
movq %rax, (%rbx)
xorl %r14d, %r14d
testq %rax, %rax
je 0x19fc
movq %r15, %rdi
callq 0x10b0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x19fc
movl $0x1, %r14d
testl %r12d, %r12d
jle 0x19fc
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%rbx), %rdi
addq %r15, %rdi
callq 0x1ccc
testl %eax, %eax
je 0x19f9
incq %r12
movslq 0x34(%rbx), %rax
addq $0x18, %r15
cmpq %rax, %r12
jl 0x19a5
testl %eax, %eax
jle 0x19fc
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %rdi
addq %r14, %rdi
callq 0x1ccc
testl %eax, %eax
je 0x19ee
incq %r15
movslq 0x34(%rbx), %rcx
addq $0x18, %r14
cmpq %rcx, %r15
jl 0x19ce
xorl %r14d, %r14d
testl %eax, %eax
setne %r14b
jmp 0x19fc
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jalalium[P]graph_algorithms_task/src_scc_para/create_graph.c
// Function: get_dimensions
int		get_dimensions(t_graph *new)
{
	int n,m;

	scanf("%d %d", &n, &m);
	if (!valid_dimensions(n,m,new))
	{
		free(new);
		return 0;
	}
	if (!init_adj(new))
		return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x603(%rip), %rdi       # 0x2024
xorl %ebx, %ebx
leaq -0x28(%rbp), %r15
leaq -0x24(%rbp), %r12
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x10d0
movl (%r15), %edi
movl (%r12), %esi
movq %r14, %rdx
callq 0x1db8
movq %r14, %rdi
testl %eax, %eax
je 0x1a57
callq 0x1952
movl %eax, %ebx
jmp 0x1a5c
callq 0x1030
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jalalium[P]graph_algorithms_task/src_scc_para/stack.c
// Function: pop
void	pop(t_stack *stk)
{
	t_layer		*tmp;

	if (stk->size <= 0)
		return ;
	if (stk->size == 1)
	{
		free(stk->top);
		stk->size--;
		return ;
	}
	tmp = stk->top->prev;
	free(stk->top);
	stk->top = tmp;
	stk->top->next = NULL;
	stk->size--;
}

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x1c85
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x1, %rax
jne 0x1c67
movq (%rbx), %rdi
callq 0x1030
jmp 0x1c7d
movq (%rbx), %rdi
movq (%rdi), %r14
callq 0x1030
movq %r14, (%rbx)
movq $0x0, 0x8(%r14)
decq 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jalalium[P]graph_algorithms_task/src_scc_para/stack.c
// Function: push
void	push(t_stack *stk, int val)
{
	t_layer *new = (t_layer*)malloc(sizeof(t_layer));
	
	new->val = val;
	if (stk->size == 0)
		stk->top = new;
	else
	{
		new->next = NULL;
		new->prev = stk->top;
		stk->top->next = new;
		stk->top = new;
	}
	stk->size++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movl $0x18, %edi
callq 0x10b0
movl %r14d, 0x10(%rax)
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x1cbc
movq $0x0, 0x8(%rax)
movq (%rbx), %rdx
movq %rdx, (%rax)
movq %rax, 0x8(%rdx)
movq %rax, (%rbx)
incq %rcx
movq %rcx, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/jalalium[P]graph_algorithms_task/src_scc_para/validation.c
// Function: valid_edge
int		valid_edge(t_pair *got, int i, t_graph *g)
{
	got[i].x--;
	got[i].y--;
	if (got[i].x < 0 || got[i].x >= g->vertx)
	   return 0;
	if (got[i].y < 0 || got[i].y >= g->vertx)
		return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %esi, %rax
movl (%rdi,%rax,8), %esi
movl 0x4(%rdi,%rax,8), %ecx
leal -0x1(%rsi), %r8d
movl %r8d, (%rdi,%rax,8)
leal -0x1(%rcx), %r8d
movl %r8d, 0x4(%rdi,%rax,8)
xorl %eax, %eax
testl %esi, %esi
jle 0x1e15
movl 0x34(%rdx), %edx
cmpl %edx, %esi
jg 0x1e15
testl %ecx, %ecx
setg %al
cmpl %edx, %ecx
setle %cl
andb %al, %cl
movzbl %cl, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rouming[P]io/http-server.c
// Function: on_sock_connection
static int on_sock_connection(void *poller, struct poller_item *item)
{
	struct sockaddr addr;
	socklen_t len = sizeof(addr);
	struct loop_ctx *ctx = item->data;
	struct connection *conn;
	struct io_req *req;

	int rc, peer;

	peer = accept4(item->fd, &addr, &len, SOCK_CLOEXEC | SOCK_NONBLOCK);
	if (peer < 0) {
		switch (errno) {
		case EWOULDBLOCK:
			break;
		case EMFILE:
		case ENFILE:
		case ENOBUFS:
		case ENOMEM:
		default:
			err(EXIT_FAILURE, "accept4 failed: errno=%d\n", errno);

			return rc;
		}

		return 0;
	}

	conn = calloc(1, sizeof(*conn));
	assert(conn);

	conn->ctx = ctx;
	conn->sock = peer;
	io_queue_init(&conn->cli_q);

	rc = io_queue_bind(&conn->cli_q, poller, peer);
	assert(rc == 0);

	req = io_req_create(&conn->cli_q, REQ_RD, conn,
			    on_read__from_client);
	assert(req);

	req->buf = (struct io_buf){
		.iov_num  = 1,
		.is_vari_len = true
	};
	rc = io_queue_submit(req);
	assert(rc == 0);

	/* Do not propagate an error up to avoid IO loop exit */
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x4(%rsp), %rdx
movl $0x10, (%rdx)
movq 0x10(%rsi), %r15
movl (%rsi), %edi
leaq 0x8(%rsp), %rsi
movl $0x80800, %ecx          # imm = 0x80800
callq 0x10b0
testl %eax, %eax
js 0x18dc
movl %eax, %ebp
movl $0x1, %edi
movl $0x198, %esi            # imm = 0x198
callq 0x1140
testq %rax, %rax
je 0x18f5
movq %rax, %r14
movq %r15, (%rax)
movl %ebp, 0x190(%rax)
movq %rax, %r15
addq $0x8, %r15
movq %r15, %rdi
callq 0x2e2f
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2f21
testl %eax, %eax
jne 0x1914
leaq 0x162(%rip), %rcx       # 0x19c4
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x3ac7
testq %rax, %rax
je 0x1933
movq %rax, %rbx
movq %rax, %rdi
addq $0x28, %rdi
movl $0x120, %edx            # imm = 0x120
xorl %esi, %esi
callq 0x10e0
movq $0x1, 0x148(%rbx)
movb $0x1, 0x150(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x151(%rbx)
movups %xmm0, 0x160(%rbx)
movq %rbx, %rdi
callq 0x37e2
testl %eax, %eax
je 0x18e8
leaq 0x389a(%rip), %rdi      # 0x515e
leaq 0x37a5(%rip), %rsi      # 0x5070
leaq 0x3857(%rip), %rcx      # 0x5129
movl $0xf5, %edx
callq 0x10d0
callq 0x1050
movl (%rax), %edx
cmpl $0xb, %edx
jne 0x1952
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3828(%rip), %rdi      # 0x5124
leaq 0x376d(%rip), %rsi      # 0x5070
leaq 0x381f(%rip), %rcx      # 0x5129
movl $0xe3, %edx
callq 0x10d0
leaq 0x3843(%rip), %rdi      # 0x515e
leaq 0x374e(%rip), %rsi      # 0x5070
leaq 0x3800(%rip), %rcx      # 0x5129
movl $0xea, %edx
callq 0x10d0
leaq 0x3909(%rip), %rdi      # 0x5243
leaq 0x372f(%rip), %rsi      # 0x5070
leaq 0x37e1(%rip), %rcx      # 0x5129
movl $0xee, %edx
callq 0x10d0
leaq 0x37b1(%rip), %rsi      # 0x510a
movl $0x1, %edi
xorl %eax, %eax
callq 0x1190
// File: /workspace/github_c_makefile_star2_O3/rouming[P]io/http-server.c
// Function: on_signal
static int on_signal(struct io_req *req, int err)
{
	struct signalfd_siginfo *siginfo;
	struct loop_ctx *ctx = req->data;

	if (err < 0)
		return err;

	assert(err == sizeof(struct signalfd_siginfo));
	siginfo = req->buf.iov[0].iov_base;
	assert(siginfo->ssi_signo == SIGINT);

	/* Graceful exit */
	ctx->shutdown = true;

	return err;
}

// Assembly:
pushq %rax
testl %esi, %esi
js 0x1982
cmpl $0x80, %esi
jne 0x1986
movq 0x28(%rdi), %rax
cmpl $0x2, (%rax)
jne 0x19a5
movq 0x18(%rdi), %rax
movb $0x1, (%rax)
movl %esi, %eax
popq %rcx
retq
leaq 0x383d(%rip), %rdi      # 0x51ca
leaq 0x36dc(%rip), %rsi      # 0x5070
leaq 0x3856(%rip), %rcx      # 0x51f1
movl $0x49, %edx
callq 0x10d0
leaq 0x3869(%rip), %rdi      # 0x5215
leaq 0x36bd(%rip), %rsi      # 0x5070
leaq 0x3837(%rip), %rcx      # 0x51f1
movl $0x4b, %edx
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O3/rouming[P]io/http-server.c
// Function: on_read__from_client
static int on_read__from_client(struct io_req *req, int len)
{
	struct connection *conn = req->data;
	struct io_req *wr_req;
	int rc;

	if (len < 0) {
		io_req_put(req);
		list_add_tail(&conn->dead_entry, &conn->ctx->dead_conns);
		/* Propagate error up */
		return len;
	}
	if (!strnstr(req->buf.iov[0].iov_base, "\r\n\r\n", len)) {
		/* Not enough, continue */
		return 0;
	}
	io_req_put(req);

	wr_req = io_req_create(&conn->cli_q, REQ_WR, conn,
			       on_write__to_client);
	assert(wr_req);

	wr_req->buf = (struct io_buf){
		.iov[0] = {
			.iov_base = (void *)http_response,
			.iov_len  = strlen(http_response)
		},
		.iov_num  = 1,
	};
	rc = io_queue_submit(wr_req);
	assert(rc == 0);

	/* Request will be put by the queue */
	return len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq 0x18(%rdi), %r14
testl %esi, %esi
js 0x19fd
xorl %eax, %eax
cmpl $0x4, %ebx
jb 0x1ab2
movl %ebx, %ecx
movq 0x28(%rdi), %rdx
cmpl $0xa0d0a0d, (%rdx)      # imm = 0xA0D0A0D
je 0x1a30
decq %rcx
incq %rdx
cmpq $0x3, %rcx
ja 0x19e4
jmp 0x1ab2
callq 0x3b5a
leaq 0x180(%r14), %rax
movq (%r14), %rcx
leaq 0x8(%rcx), %rdx
movq 0x10(%rcx), %rsi
movq %rax, 0x10(%rcx)
movq %rdx, 0x180(%r14)
movq %rsi, 0x188(%r14)
movq %rax, (%rsi)
movl %ebx, %eax
jmp 0x1ab2
testq %rdx, %rdx
je 0x1ab2
callq 0x3b5a
leaq 0x8(%r14), %rdi
leaq 0xb1(%rip), %rcx        # 0x1af6
movl $0x1, %esi
movq %r14, %rdx
callq 0x3ac7
testq %rax, %rax
je 0x1ab8
movq %rax, %r14
movq 0x66cf(%rip), %r15      # 0x8130
movq %r15, %rdi
callq 0x10a0
movq %r15, 0x28(%r14)
movq %rax, 0x30(%r14)
movq %r14, %rdi
addq $0x38, %rdi
movl $0x110, %edx            # imm = 0x110
xorl %esi, %esi
callq 0x10e0
movq $0x1, 0x148(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x150(%r14)
movups %xmm0, 0x160(%r14)
movq %r14, %rdi
callq 0x37e2
movl %eax, %ecx
movl %ebx, %eax
testl %ecx, %ecx
jne 0x1ad7
popq %rbx
popq %r14
popq %r15
retq
leaq 0x36a7(%rip), %rdi      # 0x5166
leaq 0x35aa(%rip), %rsi      # 0x5070
leaq 0x36a0(%rip), %rcx      # 0x516d
movl $0xb6, %edx
callq 0x10d0
leaq 0x3680(%rip), %rdi      # 0x515e
leaq 0x358b(%rip), %rsi      # 0x5070
leaq 0x3681(%rip), %rcx      # 0x516d
movl $0xc0, %edx
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O3/rouming[P]io/http-server.c
// Function: on_write__to_client
static int on_write__to_client(struct io_req *req, int len)
{
	struct connection *conn = req->data;
	int rc;

	io_req_put(req);
	if (len < 0) {
		list_add_tail(&conn->dead_entry, &conn->ctx->dead_conns);
	} else {
		req = io_req_create(&conn->cli_q, REQ_RD, conn,
				    on_read__from_client);
		assert(req);

		req->buf = (struct io_buf){
			.iov_num  = 1,
			.is_vari_len = true
		};
		rc = io_queue_submit(req);
		assert(rc == 0);
	}

	return len;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0x18(%rdi), %r14
callq 0x3b5a
testl %ebx, %ebx
js 0x1b92
leaq 0x8(%r14), %rdi
leaq -0x154(%rip), %rcx      # 0x19c4
xorl %esi, %esi
movq %r14, %rdx
callq 0x3ac7
testq %rax, %rax
je 0x1bc3
movq %rax, %r14
movq %rax, %rdi
addq $0x28, %rdi
movl $0x120, %edx            # imm = 0x120
xorl %esi, %esi
callq 0x10e0
movq $0x1, 0x148(%r14)
movb $0x1, 0x150(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x151(%r14)
movups %xmm0, 0x160(%r14)
movq %r14, %rdi
callq 0x37e2
testl %eax, %eax
je 0x1bb9
leaq 0x35e4(%rip), %rdi      # 0x515e
leaq 0x34ef(%rip), %rsi      # 0x5070
leaq 0x3614(%rip), %rcx      # 0x519c
movl $0x96, %edx
callq 0x10d0
leaq 0x180(%r14), %rax
movq (%r14), %rcx
leaq 0x8(%rcx), %rdx
movq 0x10(%rcx), %rsi
movq %rax, 0x10(%rcx)
movq %rdx, 0x180(%r14)
movq %rsi, 0x188(%r14)
movq %rax, (%rsi)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3679(%rip), %rdi      # 0x5243
leaq 0x349f(%rip), %rsi      # 0x5070
leaq 0x35c4(%rip), %rcx      # 0x519c
movl $0x8f, %edx
callq 0x10d0
nop
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/psfrag.c
// Function: print_usage
void print_usage()
{
	fprintf(stderr, PROGRAM_NAME " version " VERSION_STRING
			", Copyright (C) 2019 jrra.\n"
			"A utility for code fragments in the Pokemon Stadium games.\n\n"
			"usage: " PROGRAM_NAME " <cmd>\n\n"
			"Commands:\n"
		);
	int cmds_index = 0;
	while (cmds[cmds_index].command) {
		fprintf(stderr, "\t%s\n", cmds[cmds_index].help);
		cmds_index++;
	}
	fprintf(stderr, "\nReport bugs to " URL_STRING "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0xa0c44(%rip), %r14     # 0xa8ff0
movq (%r14), %rcx
leaq 0x7ddfb(%rip), %rdi     # 0x861b1
pushq $0x1
popq %rdx
movl $0x88, %esi
callq 0x82e0
cmpq $0x0, 0xa0e15(%rip)     # 0xa91e0
je 0x83f6
leaq 0xa0e24(%rip), %r15     # 0xa91f8
leaq 0x7de5f(%rip), %rbx     # 0x8623a
movq (%r14), %rdi
movq -0x10(%r15), %rdx
movq %rbx, %rsi
xorl %eax, %eax
callq 0x81b0
cmpq $0x0, (%r15)
leaq 0x18(%r15), %r15
jne 0x83db
movq (%r14), %rcx
leaq 0x7de3f(%rip), %rdi     # 0x8623f
pushq $0x33
popq %rsi
pushq $0x1
popq %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x82e0
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/psfrag.c
// Function: cmd_scan
char *cmd_scan(int argc, char **argv)
{
	__label__ out_return;
	struct MappedFile_s m;
	char *msg = NULL;
	int rc;

	if (argc < 3) {
		msg = "must specify a pokemon stadium rom";
		goto out_return;
	}

	rc = DB_Init(&db, ":memory:");
	if (rc != SQLITE_OK) {
		msg = "DB_Init oopsed";
		goto out_return;
	}

	m = MappedFile_Open(argv[2], false);
	if (m.data == NULL) {
		msg = "couldn't open rom";
		goto out_dbclose;
	}

	if (m.size < (1048576 + 4096)) {
		msg = "rom too small";
		goto out_unmap;
	}

	rc = DB_FragSearch(db, m.data, m.size);
	if (rc != SQLITE_OK) {
		msg = "DB_FragSearch oopsed";
		goto out_unmap;
	}

	dump_frags();

out_unmap:
	MappedFile_Close(m);
out_dbclose:
	DB_Close(db);
out_return:
	if (msg) {
		return msg;
	} else {
		return NULL;
	}
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
cmpl $0x3, %edi
jge 0x85a2
leaq 0x7dddf(%rip), %rbx     # 0x8637c
jmp 0x8644
movq %rsi, %rbx
leaq 0xa2c5c(%rip), %rdi     # 0xab208
leaq 0x7ddec(%rip), %rsi     # 0x8639f
callq 0x93e4
testl %eax, %eax
je 0x85c5
leaq 0x7dde5(%rip), %rbx     # 0x863a8
jmp 0x8644
movq 0x10(%rbx), %rsi
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x9919
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x85f7
movq 0x20(%rsp), %rdx
cmpq $0x101000, %rdx         # imm = 0x101000
jae 0x8600
leaq 0x7ddd4(%rip), %rbx     # 0x863c9
jmp 0x8620
leaq 0x7ddb9(%rip), %rbx     # 0x863b7
jmp 0x8638
movq 0xa2c01(%rip), %rdi     # 0xab208
callq 0x96c6
testl %eax, %eax
je 0x8619
leaq 0x7ddc0(%rip), %rbx     # 0x863d7
jmp 0x8620
callq 0x8ec7
xorl %ebx, %ebx
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x99aa
movq 0xa2bc9(%rip), %rdi     # 0xab208
callq 0x9410
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/psfrag.c
// Function: get_cmd_from_name
struct cmd_s *get_cmd_from_name(char *needle)
{
	int cmds_index = 0;
	while (cmds[cmds_index].command) {
		if (!strcmp(cmds[cmds_index].command, needle))
			return &cmds[cmds_index];
		cmds_index++;
	}
	return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xa0356(%rip), %rdi     # 0xa91e0
testq %rdi, %rdi
je 0x8eb9
movq %rbx, %rsi
callq 0x8190
leaq 0xa0342(%rip), %r14     # 0xa91e0
testl %eax, %eax
je 0x8ebc
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x8eb9
movq %rbx, %rsi
callq 0x8190
addq $0x18, %r14
jmp 0x8e9e
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/psfrag.c
// Function: main
int main(int argc, char **argv)
{
	__label__ out_return;
	char *msg = NULL;
	char *cmd_string = NULL;

	if (argc < 2) {
		print_usage();
		goto out_return;
	}

	cmd_string = argv[1];

	struct cmd_s *cmd = get_cmd_from_name(cmd_string);
	if (cmd != NULL) {
		if (cmd->handler)
			msg = cmd->handler(argc, argv);
		else
			msg = "command has no handler";
	} else {
		msg = "invalid command";
	}

out_return:
	if (msg) {
		fprintf(stderr, "%s: error: %s\n", argv[0], msg);
		return EXIT_FAILURE;
	} else {
		return EXIT_SUCCESS;
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpl $0x1, %edi
jle 0x93a3
movq %rsi, %rbx
movl %edi, %ebp
movq 0x8(%rsi), %rdi
callq 0x8e7c
testq %rax, %rax
je 0x93ac
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x93b5
movl %ebp, %edi
movq %rbx, %rsi
callq *%rax
xorl %ecx, %ecx
testq %rax, %rax
jne 0x93bc
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x83a0
xorl %ecx, %ecx
jmp 0x939a
leaq 0x7d47a(%rip), %rax     # 0x8682d
jmp 0x93bc
leaq 0x7d45a(%rip), %rax     # 0x86816
movq 0x9fc2d(%rip), %rcx     # 0xa8ff0
movq (%rcx), %rdi
movq (%rbx), %rdx
leaq 0x7d46d(%rip), %rsi     # 0x8683d
movq %rax, %rcx
xorl %eax, %eax
callq 0x81b0
movl $0x1, %ecx
jmp 0x939a
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/db.c
// Function: DB_Init
int DB_Init(sqlite3 **db, char *filename) {
	int rc = SQLITE_OK;
	rc = sqlite3_open(filename, db);
	if (rc != SQLITE_OK) return rc;

	rc = sqlite3_exec(*db,
		"CREATE TABLE IF NOT EXISTS frags(pcode text, addr int, num int, entrypoint int, offset_code int, offset_relocs int, romsize int, ramsize int, vma int);",
		NULL, NULL, NULL
	);
	if (rc != SQLITE_OK) return rc;
	return SQLITE_OK;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x19638
testl %eax, %eax
je 0x93f9
popq %rbx
retq
movq (%rbx), %rdi
leaq 0x7d4a2(%rip), %rsi     # 0x868a5
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
popq %rbx
jmp 0x1497e
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/db.c
// Function: DB_FragSearch
int DB_FragSearch(sqlite3 *db, uint8_t *data, ssize_t size)
{
	int rc = SQLITE_OK;
	char pcode[6] = {0};
	get_pcode(pcode, data);
	DB_Begin(db);
	for (ssize_t i = 0; i < (size - 15); i += 16) {
		struct fragment_s *frag = (struct fragment_s *)(data + i);
		if (!isfrag(frag)) continue;
		rc = DB_AddFrag(
			db,
			pcode,
			i,
			get_frag_num(frag),
			get_entrypoint(frag),
			ntohl(frag->offset_code),
			ntohl(frag->offset_relocs),
			ntohl(frag->romsize),
			ntohl(frag->ramsize),
			get_vma(frag)
		);
		if (rc != SQLITE_OK) {
			break;
		}
	}
	DB_End(db);
	return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rsp), %rdi
movw $0x0, 0x4(%rdi)
movl $0x0, (%rdi)
callq 0x99c4
leaq 0x7d243(%rip), %rsi     # 0x8693d
xorl %r13d, %r13d
movq %rbx, 0x8(%rsp)
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x1497e
cmpq $0x10, %r14
jl 0x97d8
addq $-0xf, %r14
xorl %r12d, %r12d
movq %r14, 0x20(%rsp)
movq %r15, 0x10(%rsp)
leaq (%r15,%r12), %rbp
movq %rbp, %rdi
callq 0x9857
testb %al, %al
je 0x97c3
movq %rbp, %rdi
callq 0x9804
cltq
movq %rax, 0x30(%rsp)
movq %rbp, %rdi
callq 0x9835
movl %eax, %eax
movq %rax, 0x28(%rsp)
movl 0x10(%r15,%r12), %r14d
movl 0x14(%r15,%r12), %r13d
bswapl %r14d
bswapl %r13d
movl 0x18(%r15,%r12), %ebx
bswapl %ebx
movq 0x10(%rsp), %rax
movl 0x1c(%rax,%r12), %r15d
bswapl %r15d
movq %rbp, %rdi
callq 0x9846
movl %eax, %eax
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
movq %r12, %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
movq %r14, %r9
movq 0x20(%rsp), %r14
pushq %rax
pushq %r15
movq 0x20(%rsp), %r15
pushq %rbx
pushq %r13
callq 0x943b
addq $0x20, %rsp
testl %eax, %eax
jne 0x97d5
addq $0x10, %r12
cmpq %r14, %r12
jl 0x972c
xorl %r13d, %r13d
jmp 0x97d8
movl %eax, %r13d
leaq 0x7d165(%rip), %rsi     # 0x86944
movq 0x8(%rsp), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x1497e
movl %r13d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/mapfile.c
// Function: MappedFile_Create
struct MappedFile_s MappedFile_Create(char *filename, size_t size)
{
	__label__ out_error, out_ok, out_close;
	struct MappedFile_s m;

	m._fd = open(filename, O_RDWR | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR);
	if (!m._fd) goto out_error;
	close(m._fd);
	if (truncate(filename, size) < 0) goto out_error;
	m._fd = open(filename, O_RDWR);
	if (!m._fd) goto out_error;

	m.data = mmap(
		NULL,
		size,
		PROT_READ|PROT_WRITE,
		MAP_SHARED,
		m._fd,
		0
	);
	if (m.data == NULL) {
		goto out_close;
	}

	memset(m.data, 0, size);
	m.size = size;

	goto out_ok;

out_close:
	close(m._fd);
out_error:
	m.size = 0;
	m.data = NULL;
out_ok:
	return m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x242, %esi            # imm = 0x242
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x82a0
movl %eax, 0x10(%rbx)
testl %eax, %eax
je 0x9905
movl %eax, %edi
callq 0x8140
movq %r15, %rdi
movq %r14, %rsi
callq 0x81e0
testl %eax, %eax
js 0x9905
movq %r15, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x82a0
movl %eax, 0x10(%rbx)
testl %eax, %eax
je 0x9905
movl %eax, %ebp
xorl %edi, %edi
movq %r14, %rsi
movl $0x3, %edx
movl $0x1, %ecx
movl %eax, %r8d
xorl %r9d, %r9d
callq 0x80c0
movq %rax, (%rbx)
testq %rax, %rax
je 0x98fe
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x8130
movq %r14, 0x8(%rbx)
jmp 0x990b
movl %ebp, %edi
callq 0x8140
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/pcode.c
// Function: get_pcode
char *get_pcode(char pcode[6], uint8_t *rom)
{
	__label__ out;
	if (!rom or !pcode) goto out;
	pcode[0] = rom[0x3b];
	pcode[1] = rom[0x3c];
	pcode[2] = rom[0x3d];
	pcode[3] = rom[0x3e];
	pcode[4] = rom[0x3f] + '0';
	pcode[5] = '\0';
	for (int i=0; i < 4; i++) {
		if (!isalnum(pcode[i]))
			pcode[i] = '_';
		else
			pcode[i] = tolower(pcode[i]);
	}

	if (!isdigit(pcode[4]))
		pcode[4] = '_';

out:
	return pcode;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x9a4a
movb 0x3b(%rsi), %al
movb %al, (%rbx)
movb 0x3c(%rsi), %al
movb %al, 0x1(%rbx)
movb 0x3d(%rsi), %al
movb %al, 0x2(%rbx)
movb 0x3e(%rsi), %al
movb %al, 0x3(%rbx)
movb 0x3f(%rsi), %al
addb $0x30, %al
movb %al, 0x4(%rbx)
movb $0x0, 0x5(%rbx)
xorl %r15d, %r15d
callq 0x8380
movq %rax, %r14
movq (%r14), %rcx
movsbq (%rbx,%r15), %r12
movb $0x5f, %al
testb $0x8, (%rcx,%r12,2)
je 0x9a2a
callq 0x8370
movq (%rax), %rax
movb (%rax,%r12,4), %al
movb %al, (%rbx,%r15)
incq %r15
cmpq $0x4, %r15
jne 0x9a0d
movq (%r14), %rax
movsbq 0x4(%rbx), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x9a4a
movb $0x5f, 0x4(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/sqlite3.c
// Function: invokeProfileCallback
static SQLITE_NOINLINE void invokeProfileCallback(sqlite3 *db, Vdbe *p){
  sqlite3_int64 iNow;
  sqlite3_int64 iElapse;
  assert( p->startTime>0 );
  assert( (db->mTrace & (SQLITE_TRACE_PROFILE|SQLITE_TRACE_XPROFILE))!=0 );
  assert( db->init.busy==0 );
  assert( p->zSql!=0 );
  sqlite3OsCurrentTimeInt64(db->pVfs, &iNow);
  iElapse = (iNow - p->startTime)*1000000;
#ifndef SQLITE_OMIT_DEPRECATED
  if( db->xProfile ){
    db->xProfile(db->pProfileArg, p->zSql, iElapse);
  }
#endif
  if( db->mTrace & SQLITE_TRACE_PROFILE ){
    db->xTrace(SQLITE_TRACE_PROFILE, db->pTraceArg, p, (void*)&iElapse);
  }
  p->startTime = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x28b6d
movq (%r15), %rax
subq 0xb8(%rbx), %rax
imulq $0xf4240, %rax, %rdx    # imm = 0xF4240
movq %rdx, (%rsp)
movq 0xf0(%r14), %rax
testq %rax, %rax
je 0x101ab
movq 0xf8(%r14), %rdi
movq 0xf0(%rbx), %rsi
callq *%rax
testb $0x2, 0x68(%r14)
je 0x101cb
movq 0xe8(%r14), %rsi
movq %rsp, %rcx
movl $0x2, %edi
movq %rbx, %rdx
callq *0xe0(%r14)
movq $0x0, 0xb8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3OomFault
SQLITE_PRIVATE void sqlite3OomFault(sqlite3 *db){
  if( db->mallocFailed==0 && db->bBenignMalloc==0 ){
    db->mallocFailed = 1;
    if( db->nVdbeExec>0 ){
      db->u1.isInterrupted = 1;
    }
    db->lookaside.bDisable++;
    if( db->pParse ){
      db->pParse->rc = SQLITE_NOMEM_BKPT;
    }
  }
}

// Assembly:
cmpb $0x0, 0x61(%rdi)
je 0x10d93
retq
cmpb $0x0, 0x62(%rdi)
jne 0x10d92
movb $0x1, 0x61(%rdi)
cmpl $0x0, 0xcc(%rdi)
jle 0x10db0
movl $0x1, 0x168(%rdi)
incl 0x170(%rdi)
movq 0x130(%rdi), %rax
testq %rax, %rax
je 0x10d92
movl $0x7, 0x18(%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/sqlite3.c
// Function: columnName
static const void *columnName(
  sqlite3_stmt *pStmt,     /* The statement */
  int N,                   /* Which column to get the name for */
  int useUtf16,            /* True to return the name as UTF16 */
  int useType              /* What type of name */
){
  const void *ret;
  Vdbe *p;
  int n;
  sqlite3 *db;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pStmt==0 ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  ret = 0;
  p = (Vdbe *)pStmt;
  db = p->db;
  assert( db!=0 );
  n = sqlite3_column_count(pStmt);
  if( N<n && N>=0 ){
    N += useType*n;
    sqlite3_mutex_enter(db->mutex);
    assert( db->mallocFailed==0 );
#ifndef SQLITE_OMIT_UTF16
    if( useUtf16 ){
      ret = sqlite3_value_text16((sqlite3_value*)&p->aColName[N]);
    }else
#endif
    {
      ret = sqlite3_value_text((sqlite3_value*)&p->aColName[N]);
    }
    /* A malloc may have failed inside of the _text() call. If this
    ** is the case, clear the mallocFailed flag and return NULL.
    */
    if( db->mallocFailed ){
      sqlite3OomClear(db);
      ret = 0;
    }
    sqlite3_mutex_leave(db->mutex);
  }
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movzwl 0xc0(%rdi), %ebp
cmpl %esi, %ebp
jbe 0x12080
movl %edx, %ebx
movq %rdi, %r14
movq (%rdi), %r15
imull %ecx, %ebp
addl %esi, %ebp
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0x12037
callq *0x972d9(%rip)          # 0xa9310
movl %ebp, %eax
imulq $0x38, %rax, %rdi
addq 0x98(%r14), %rdi
cmpl $0x1, %ebx
movl $0x2, %esi
sbbl $0x0, %esi
callq 0x1058a
cmpb $0x0, 0x61(%r15)
je 0x12084
cmpl $0x0, 0xcc(%r15)
jne 0x1207c
movb $0x0, 0x61(%r15)
movl $0x0, 0x168(%r15)
decl 0x170(%r15)
xorl %ebx, %ebx
jmp 0x12087
xorl %ebx, %ebx
jmp 0x12096
movq %rax, %rbx
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0x12096
callq *0x9728a(%rip)          # 0xa9320
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3_blob_close
SQLITE_API int sqlite3_blob_close(sqlite3_blob *pBlob){
  Incrblob *p = (Incrblob *)pBlob;
  int rc;
  sqlite3 *db;

  if( p ){
    sqlite3_stmt *pStmt = p->pStmt;
    db = p->db;
    sqlite3_mutex_enter(db->mutex);
    sqlite3DbFree(db, p);
    sqlite3_mutex_leave(db->mutex);
    rc = sqlite3_finalize(pStmt);
  }else{
    rc = SQLITE_OK;
  }
  return rc;
}

// Assembly:
testq %rdi, %rdi
je 0x141dd
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rbx
movq 0x20(%rdi), %r15
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0x141b6
callq *0x9515a(%rip)          # 0xa9310
movq %r15, %rdi
movq %r14, %rsi
callq 0x1b5f7
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0x141d0
callq *0x95150(%rip)          # 0xa9320
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x100a7
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3_enable_load_extension
SQLITE_API int sqlite3_enable_load_extension(sqlite3 *db, int onoff){
  sqlite3_mutex_enter(db->mutex);
  if( onoff ){
    db->flags |= SQLITE_LoadExtension|SQLITE_LoadExtFunc;
  }else{
    db->flags &= ~(u64)(SQLITE_LoadExtension|SQLITE_LoadExtFunc);
  }
  sqlite3_mutex_leave(db->mutex);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x15446
callq *0x93eca(%rip)          # 0xa9310
movq $-0x30001, %rax         # imm = 0xFFFCFFFF
andq 0x30(%rbx), %rax
xorl %ecx, %ecx
testl %ebp, %ebp
movl $0x30000, %edx          # imm = 0x30000
cmoveq %rcx, %rdx
orq %rax, %rdx
movq %rdx, 0x30(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x15474
callq *0x93eac(%rip)          # 0xa9320
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3_profile
SQLITE_API void *sqlite3_profile(
  sqlite3 *db,
  void (*xProfile)(void*,const char*,sqlite_uint64),
  void *pArg
){
  void *pOld;

#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  pOld = db->pProfileArg;
  db->xProfile = xProfile;
  db->pProfileArg = pArg;
  db->mTrace &= SQLITE_TRACE_NONLEGACY_MASK;
  if( db->xProfile ) db->mTrace |= SQLITE_TRACE_XPROFILE;
  sqlite3_mutex_leave(db->mutex);
  return pOld;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x18cf5
callq *0x90621(%rip)          # 0xa9310
movq 0x18(%rbx), %rdi
jmp 0x18cf7
xorl %edi, %edi
movq 0xf8(%rbx), %r15
movq %r14, 0xf0(%rbx)
movq %r12, 0xf8(%rbx)
movb 0x68(%rbx), %al
andb $0xf, %al
leal -0x80(%rax), %ecx
testq %r14, %r14
movzbl %al, %eax
movzbl %cl, %ecx
cmovel %eax, %ecx
movb %cl, 0x68(%rbx)
testq %rdi, %rdi
je 0x18d2e
callq *0x905f2(%rip)          # 0xa9320
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3KeyInfoUnref
SQLITE_PRIVATE void sqlite3KeyInfoUnref(KeyInfo *p){
  if( p ){
    assert( p->nRef>0 );
    p->nRef--;
    if( p->nRef==0 ) sqlite3DbFreeNN(p->db, p);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x28abb
movq %rdi, %rsi
decl (%rdi)
je 0x28abc
retq
movq 0x10(%rsi), %rdi
jmp 0x1b5f7
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/sqlite3.c
// Function: clearSelect
static void clearSelect(sqlite3 *db, Select *p, int bFree){
  while( p ){
    Select *pPrior = p->pPrior;
    sqlite3ExprListDelete(db, p->pEList);
    sqlite3SrcListDelete(db, p->pSrc);
    sqlite3ExprDelete(db, p->pWhere);
    sqlite3ExprListDelete(db, p->pGroupBy);
    sqlite3ExprDelete(db, p->pHaving);
    sqlite3ExprListDelete(db, p->pOrderBy);
    sqlite3ExprDelete(db, p->pLimit);
#ifndef SQLITE_OMIT_WINDOWFUNC
    if( OK_IF_ALWAYS_TRUE(p->pWinDefn) ){
      sqlite3WindowListDelete(db, p->pWinDefn);
    }
    assert( p->pWin==0 );
#endif
    if( OK_IF_ALWAYS_TRUE(p->pWith) ) sqlite3WithDelete(db, p->pWith);
    if( bFree ) sqlite3DbFreeNN(db, p);
    p = pPrior;
    bFree = 1;
  }
}

// Assembly:
testq %rsi, %rsi
je 0x3ea1d
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
sete %bpl
movq (%r14), %rsi
movq 0x50(%r14), %r15
testq %rsi, %rsi
je 0x3e967
movq %rbx, %rdi
callq 0x3ebf2
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x3ea1e
movq 0x30(%r14), %rsi
testq %rsi, %rsi
je 0x3e984
movq %rbx, %rdi
callq 0x3e7b4
movq 0x38(%r14), %rsi
testq %rsi, %rsi
je 0x3e995
movq %rbx, %rdi
callq 0x3ebf2
movq 0x40(%r14), %rsi
testq %rsi, %rsi
je 0x3e9a6
movq %rbx, %rdi
callq 0x3e7b4
movq 0x48(%r14), %rsi
testq %rsi, %rsi
je 0x3e9b7
movq %rbx, %rdi
callq 0x3ebf2
movq 0x60(%r14), %rsi
testq %rsi, %rsi
je 0x3e9c8
movq %rbx, %rdi
callq 0x3e7b4
movq 0x78(%r14), %rsi
testq %rsi, %rsi
je 0x3e9e5
movq 0x40(%rsi), %r12
movq %rbx, %rdi
callq 0x3e875
movq %r12, %rsi
testq %r12, %r12
jne 0x3e9d1
movq 0x68(%r14), %rsi
testq %rsi, %rsi
je 0x3e9f6
movq %rbx, %rdi
callq 0x3eb09
testb $0x1, %bpl
jne 0x3ea07
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b5f7
xorl %ebp, %ebp
movq %r15, %r14
testq %r15, %r15
jne 0x3e953
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3ExprIdToTrueFalse
SQLITE_PRIVATE int sqlite3ExprIdToTrueFalse(Expr *pExpr){
  assert( pExpr->op==TK_ID || pExpr->op==TK_STRING );
  if( !ExprHasProperty(pExpr, EP_Quoted)
   && (sqlite3StrICmp(pExpr->u.zToken, "true")==0
       || sqlite3StrICmp(pExpr->u.zToken, "false")==0)
  ){
    pExpr->op = TK_TRUEFALSE;
    ExprSetProperty(pExpr, pExpr->u.zToken[4]==0 ? EP_IsTrue : EP_IsFalse);
    return 1;
  }
  return 0;
}

// Assembly:
movl 0x4(%rdi), %eax
btl $0x1a, %eax
jb 0x462c8
movq 0x8(%rdi), %rcx
xorl %esi, %esi
leaq 0x48776(%rip), %r8      # 0x8e9e4
leaq 0x41bdb(%rip), %rdx     # 0x87e50
movzbl (%rcx,%rsi), %r9d
movzbl (%rsi,%r8), %r10d
cmpb %r10b, %r9b
jne 0x4628b
testq %r9, %r9
jne 0x46295
jmp 0x462cb
movb (%r9,%rdx), %r9b
cmpb (%r10,%rdx), %r9b
jne 0x4629a
incq %rsi
jmp 0x46275
xorl %esi, %esi
leaq 0x48746(%rip), %r8      # 0x8e9e9
movzbl (%rcx,%rsi), %r9d
movzbl (%rsi,%r8), %r10d
cmpb %r10b, %r9b
jne 0x462b9
testq %r9, %r9
jne 0x462c3
jmp 0x462cb
movb (%r9,%rdx), %r9b
cmpb (%r10,%rdx), %r9b
jne 0x462c8
incq %rsi
jmp 0x462a3
xorl %eax, %eax
retq
movb $-0x5b, (%rdi)
xorl %edx, %edx
cmpb $0x0, 0x4(%rcx)
setne %dl
shll $0x1c, %edx
addl $0x10000000, %edx       # imm = 0x10000000
orl %eax, %edx
movl %edx, 0x4(%rdi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3ExprAnd
SQLITE_PRIVATE Expr *sqlite3ExprAnd(Parse *pParse, Expr *pLeft, Expr *pRight){
  sqlite3 *db = pParse->db;
  if( pLeft==0  ){
    return pRight;
  }else if( pRight==0 ){
    return pLeft;
  }else if( ExprAlwaysFalse(pLeft) || ExprAlwaysFalse(pRight) ){
    sqlite3ExprUnmapAndDelete(pParse, pLeft);
    sqlite3ExprUnmapAndDelete(pParse, pRight);
    return sqlite3Expr(db, TK_INTEGER, "0");
  }else{
    return sqlite3PExpr(pParse, TK_AND, pLeft, pRight);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
testq %rsi, %rsi
je 0x4f121
movq %rsi, %rdx
testq %rbx, %rbx
je 0x4f11e
movq %rdi, %r15
movq (%rdi), %r14
movl $0x20000001, %eax       # imm = 0x20000001
movl 0x4(%rdx), %ecx
andl %eax, %ecx
cmpl $0x20000000, %ecx       # imm = 0x20000000
je 0x4f0e0
andl 0x4(%rbx), %eax
cmpl $0x20000000, %eax       # imm = 0x20000000
jne 0x4f12e
movq %r15, %rdi
movq %rdx, %rsi
callq 0x4f186
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4f186
leaq 0x3f126(%rip), %rax     # 0x8e223
movq %rsp, %rdx
movq %rax, (%rdx)
movl $0x1, 0x8(%rdx)
movq %r14, %rdi
movl $0x96, %esi
xorl %ecx, %ecx
callq 0x4a8df
movq %rax, %rbx
jmp 0x4f121
movq %rdx, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movl $0x2c, %esi
movq %rbx, %rcx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x460a2
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/sqlite3.c
// Function: exprToRegister
SQLITE_PRIVATE Expr *sqlite3ExprSkipCollateAndLikely(Expr *pExpr){
  while( pExpr && ExprHasProperty(pExpr, EP_Skip|EP_Unlikely) ){
    if( ExprHasProperty(pExpr, EP_Unlikely) ){
      assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
      assert( pExpr->x.pList->nExpr>0 );
      assert( pExpr->op==TK_FUNCTION );
      pExpr = pExpr->x.pList->a[0].pExpr;
    }else{
      assert( pExpr->op==TK_COLLATE );
      pExpr = pExpr->pLeft;
    }
  }   
  return pExpr;
}

// Assembly:
movl 0x4(%rdi), %eax
testl $0x41000, %eax          # imm = 0x41000
je 0x57897
btl $0x12, %eax
jb 0x5788a
addq $0x10, %rdi
jmp 0x57892
movq 0x20(%rdi), %rdi
addq $0x8, %rdi
movq (%rdi), %rdi
jmp 0x57874
movb (%rdi), %cl
movb %cl, 0x36(%rdi)
movb $-0x55, (%rdi)
movl %esi, 0x2c(%rdi)
andl $0xffffefff, %eax       # imm = 0xFFFFEFFF
movl %eax, 0x4(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3ExprAffinity
SQLITE_PRIVATE char sqlite3ExprAffinity(Expr *pExpr){
  int op;
  while( ExprHasProperty(pExpr, EP_Skip) ){
    assert( pExpr->op==TK_COLLATE );
    pExpr = pExpr->pLeft;
    assert( pExpr!=0 );
  }
  op = pExpr->op;
  if( op==TK_SELECT ){
    assert( pExpr->flags&EP_xIsSelect );
    return sqlite3ExprAffinity(pExpr->x.pSelect->pEList->a[0].pExpr);
  }
  if( op==TK_REGISTER ) op = pExpr->op2;
#ifndef SQLITE_OMIT_CAST
  if( op==TK_CAST ){
    assert( !ExprHasProperty(pExpr, EP_IntValue) );
    return sqlite3AffinityType(pExpr->u.zToken, 0);
  }
#endif
  if( (op==TK_AGG_COLUMN || op==TK_COLUMN) && pExpr->y.pTab ){
    return sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);
  }
  if( op==TK_SELECT_COLUMN ){
    assert( pExpr->pLeft->flags&EP_xIsSelect );
    return sqlite3ExprAffinity(
        pExpr->pLeft->x.pSelect->pEList->a[pExpr->iColumn].pExpr
    );
  }
  return pExpr->affExpr;
}

// Assembly:
testb $0x10, 0x5(%rdi)
je 0x5841a
movq 0x10(%rdi), %rdi
jmp 0x5840e
movzbl (%rdi), %eax
cmpl $0xab, %eax
je 0x58438
cmpl $0x86, %eax
jne 0x5843b
movq 0x20(%rdi), %rax
movq (%rax), %rax
addq $0x8, %rax
jmp 0x5845a
movb 0x36(%rdi), %al
cmpb $-0x53, %al
jne 0x5845f
movq 0x10(%rdi), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movswq 0x30(%rdi), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
addq $0x8, %rax
movq (%rax), %rdi
jmp 0x5840e
movzbl %al, %eax
cmpl $0xa4, %eax
je 0x58480
cmpl $0xa2, %eax
je 0x58480
cmpl $0x24, %eax
jne 0x584a0
movq 0x8(%rdi), %rdi
xorl %esi, %esi
jmp 0x56451
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x584a0
movswq 0x30(%rdi), %rcx
testq %rcx, %rcx
js 0x584a4
movq 0x8(%rax), %rax
shlq $0x5, %rcx
movb 0x19(%rax,%rcx), %al
retq
movb 0x1(%rdi), %al
retq
movb $0x44, %al
retq
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3WindowCompare
SQLITE_PRIVATE int sqlite3WindowCompare(Parse *pParse, Window *p1, Window *p2, int bFilter){
  if( p1->eFrmType!=p2->eFrmType ) return 1;
  if( p1->eStart!=p2->eStart ) return 1;
  if( p1->eEnd!=p2->eEnd ) return 1;
  if( p1->eExclude!=p2->eExclude ) return 1;
  if( sqlite3ExprCompare(pParse, p1->pStart, p2->pStart, -1) ) return 1;
  if( sqlite3ExprCompare(pParse, p1->pEnd, p2->pEnd, -1) ) return 1;
  if( sqlite3ExprListCompare(p1->pPartition, p2->pPartition, -1) ) return 1;
  if( sqlite3ExprListCompare(p1->pOrderBy, p2->pOrderBy, -1) ) return 1;
  if( bFilter ){
    if( sqlite3ExprCompare(pParse, p1->pFilter, p2->pFilter, -1) ) return 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movb 0x20(%rsi), %al
movl $0x1, %ebx
cmpb 0x20(%rdx), %al
jne 0x58d7c
movq %rdx, %r15
movq %rsi, %r12
movb 0x21(%rsi), %al
cmpb 0x21(%rdx), %al
jne 0x58d7c
movb 0x22(%r12), %al
cmpb 0x22(%r15), %al
jne 0x58d7c
movb 0x24(%r12), %al
cmpb 0x24(%r15), %al
jne 0x58d7c
movl %ecx, %ebp
movq %rdi, %r14
movq 0x28(%r12), %rsi
movq 0x28(%r15), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x588b0
testl %eax, %eax
jne 0x58d7c
movq 0x30(%r12), %rsi
movq 0x30(%r15), %rdx
movq %r14, %rdi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x588b0
testl %eax, %eax
jne 0x58d7c
movq 0x10(%r12), %rdi
movq 0x10(%r15), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x58d87
testl %eax, %eax
jne 0x58d7c
movq 0x18(%r12), %rdi
movq 0x18(%r15), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x58d87
testl %eax, %eax
jne 0x58d7c
testl %ebp, %ebp
je 0x58d7a
movq 0x48(%r12), %rsi
movq 0x48(%r15), %rdx
movq %r14, %rdi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x588b0
testl %eax, %eax
jne 0x58d7c
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3ExprListCompare
SQLITE_PRIVATE int sqlite3ExprListCompare(ExprList *pA, ExprList *pB, int iTab){
  int i;
  if( pA==0 && pB==0 ) return 0;
  if( pA==0 || pB==0 ) return 1;
  if( pA->nExpr!=pB->nExpr ) return 1;
  for(i=0; i<pA->nExpr; i++){
    Expr *pExprA = pA->a[i].pExpr;
    Expr *pExprB = pB->a[i].pExpr;
    if( pA->a[i].sortFlags!=pB->a[i].sortFlags ) return 1;
    if( sqlite3ExprCompare(0, pExprA, pExprB, iTab) ) return 1;
  }
  return 0;
}

// Assembly:
xorl %eax, %eax
movq %rdi, %rcx
orq %rsi, %rcx
je 0x58e09
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
testq %rsi, %rsi
sete %cl
testq %rdi, %rdi
sete %dl
orb %cl, %dl
jne 0x58dfb
movl (%r15), %ecx
cmpl (%r14), %ecx
jne 0x58dfb
testl %ecx, %ecx
jle 0x58e00
movl $0x20, %r12d
xorl %r13d, %r13d
movb (%r15,%r12), %al
cmpb (%r14,%r12), %al
jne 0x58dfb
movq -0x18(%r14,%r12), %rdx
movq -0x18(%r15,%r12), %rsi
xorl %edi, %edi
movl %ebx, %ecx
callq 0x588b0
testl %eax, %eax
jne 0x58dfb
incq %r13
movslq (%r15), %rcx
addq $0x20, %r12
xorl %eax, %eax
cmpq %rcx, %r13
jl 0x58dc7
jmp 0x58e00
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3WindowDup
SQLITE_PRIVATE Window *sqlite3WindowDup(sqlite3 *db, Expr *pOwner, Window *p){
  Window *pNew = 0;
  if( ALWAYS(p) ){
    pNew = sqlite3DbMallocZero(db, sizeof(Window));
    if( pNew ){
      pNew->zName = sqlite3DbStrDup(db, p->zName);
      pNew->zBase = sqlite3DbStrDup(db, p->zBase);
      pNew->pFilter = sqlite3ExprDup(db, p->pFilter, 0);
      pNew->pFunc = p->pFunc;
      pNew->pPartition = sqlite3ExprListDup(db, p->pPartition, 0);
      pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, 0);
      pNew->eFrmType = p->eFrmType;
      pNew->eEnd = p->eEnd;
      pNew->eStart = p->eStart;
      pNew->eExclude = p->eExclude;
      pNew->regResult = p->regResult;
      pNew->pStart = sqlite3ExprDup(db, p->pStart, 0);
      pNew->pEnd = sqlite3ExprDup(db, p->pEnd, 0);
      pNew->pOwner = pOwner;
      pNew->bImplicitFrame = p->bImplicitFrame;
    }
  }
  return pNew;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0x5a733
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x90, %esi
callq 0x11d1f
testq %rax, %rax
je 0x5a733
movq %rax, %rbx
movq (%r14), %rsi
movq %r12, %rdi
callq 0x11b20
movq %rax, (%rbx)
movq 0x8(%r14), %rsi
movq %r12, %rdi
callq 0x11b20
movq %rax, 0x8(%rbx)
movq 0x48(%r14), %rsi
testq %rsi, %rsi
je 0x5a73a
movq %r12, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x59f79
jmp 0x5a73c
xorl %ebx, %ebx
jmp 0x5a7d6
xorl %eax, %eax
movq %rax, 0x48(%rbx)
movq 0x50(%r14), %rax
movq %rax, 0x50(%rbx)
movq 0x10(%r14), %rsi
xorl %r13d, %r13d
movq %r12, %rdi
xorl %edx, %edx
callq 0x5a500
movq %rax, 0x10(%rbx)
movq 0x18(%r14), %rsi
movq %r12, %rdi
xorl %edx, %edx
callq 0x5a500
movq %rax, 0x18(%rbx)
movb 0x20(%r14), %al
movb %al, 0x20(%rbx)
movb 0x22(%r14), %al
movb %al, 0x22(%rbx)
movb 0x21(%r14), %al
movb %al, 0x21(%rbx)
movb 0x24(%r14), %al
movb %al, 0x24(%rbx)
movl 0x60(%r14), %eax
movl %eax, 0x60(%rbx)
movq 0x28(%r14), %rsi
testq %rsi, %rsi
je 0x5a7aa
movq %r12, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x59f79
movq %rax, %r13
movq %r13, 0x28(%rbx)
movq 0x30(%r14), %rsi
testq %rsi, %rsi
je 0x5a7c5
movq %r12, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x59f79
jmp 0x5a7c7
xorl %eax, %eax
movq %rax, 0x30(%rbx)
movq %r15, 0x70(%rbx)
movb 0x23(%r14), %al
movb %al, 0x23(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3CheckObjectName
SQLITE_PRIVATE int sqlite3CheckObjectName(
  Parse *pParse,            /* Parsing context */
  const char *zName,        /* Name of the object to check */
  const char *zType,        /* Type of this object */
  const char *zTblName      /* Parent table name for triggers and indexes */
){
  sqlite3 *db = pParse->db;
  if( sqlite3WritableSchema(db) || db->init.imposterTable ){
    /* Skip these error checks for writable_schema=ON */
    return SQLITE_OK;
  }
  if( db->init.busy ){
    if( sqlite3_stricmp(zType, db->init.azInit[0])
     || sqlite3_stricmp(zName, db->init.azInit[1])
     || sqlite3_stricmp(zTblName, db->init.azInit[2])
    ){
      if( sqlite3Config.bExtraSchemaChecks ){
        sqlite3ErrorMsg(pParse, ""); /* corruptSchema() will supply the error */
        return SQLITE_ERROR;
      }
    }
  }else{
    if( pParse->nested==0 
     && 0==sqlite3StrNICmp(zName, "sqlite_", 7)
    ){
      sqlite3ErrorMsg(pParse, "object name reserved for internal use: %s",
                      zName);
      return SQLITE_ERROR;
    }
  }
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movq (%rdi), %rsi
movl $0x10000001, %edi       # imm = 0x10000001
andl 0x30(%rsi), %edi
xorl %ebp, %ebp
cmpl $0x1, %edi
je 0x5b0f0
testb $0x2, 0xb6(%rsi)
jne 0x5b0f0
cmpb $0x0, 0xb5(%rsi)
je 0x5affd
movq 0xb8(%rsi), %rsi
movq (%rsi), %rdi
testq %rdx, %rdx
je 0x5b051
testq %rdi, %rdi
je 0x5b0a7
xorl %r8d, %r8d
leaq 0x2ce7c(%rip), %r9      # 0x87e50
movzbl (%rdx,%r8), %r10d
movzbl (%rdi,%r8), %r11d
cmpb %r11b, %r10b
jne 0x5afea
testq %r10, %r10
jne 0x5aff8
jmp 0x5b056
movb (%r10,%r9), %r10b
cmpb (%r11,%r9), %r10b
jne 0x5b0a7
incq %r8
jmp 0x5afd4
testq %rax, %rax
je 0x5b0f0
cmpb $0x0, 0x1e(%rbx)
jne 0x5b0f0
xorl %edx, %edx
leaq 0x2ce37(%rip), %rcx     # 0x87e50
leaq 0x3306c(%rip), %rsi     # 0x8e08c
movzbl (%rax,%rdx), %edi
testq %rdi, %rdi
je 0x5b0c3
movzbl (%rdi,%rcx), %edi
movzbl (%rdx,%rsi), %r8d
movb (%r8,%rcx), %r8b
cmpb %r8b, %dil
jne 0x5b0cd
incq %rdx
cmpq $0x7, %rdx
jne 0x5b020
jmp 0x5b0d7
testq %rdi, %rdi
jne 0x5b0a7
movq 0x8(%rsi), %rdx
testq %rax, %rax
je 0x5b092
testq %rdx, %rdx
je 0x5b0a7
xorl %edi, %edi
leaq 0x2cde3(%rip), %r8      # 0x87e50
movzbl (%rax,%rdi), %r9d
movzbl (%rdx,%rdi), %r10d
cmpb %r10b, %r9b
jne 0x5b083
testq %r9, %r9
jne 0x5b08d
jmp 0x5b097
movb (%r9,%r8), %r9b
cmpb (%r10,%r8), %r9b
jne 0x5b0a7
incq %rdi
jmp 0x5b06d
testq %rdx, %rdx
jne 0x5b0a7
movq 0x10(%rsi), %rsi
movq %rcx, %rdi
callq 0xcfc4
testl %eax, %eax
je 0x5b0f0
cmpb $0x0, 0x4e1eb(%rip)     # 0xa9299
je 0x5b0f0
leaq 0x2b9b5(%rip), %rsi     # 0x86a6c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x13932
jmp 0x5b0eb
movzbl (%rdx,%rsi), %edx
movb (%rdx,%rcx), %r8b
xorl %edi, %edi
movzbl %r8b, %ecx
xorl %ebp, %ebp
cmpl %ecx, %edi
jne 0x5b0f0
leaq 0x32fb6(%rip), %rsi     # 0x8e094
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x13932
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3ResolveSelfReference
SQLITE_PRIVATE int sqlite3ResolveSelfReference(
  Parse *pParse,      /* Parsing context */
  Table *pTab,        /* The table being referenced, or NULL */
  int type,           /* NC_IsCheck or NC_PartIdx or NC_IdxExpr, or 0 */
  Expr *pExpr,        /* Expression to resolve.  May be NULL. */
  ExprList *pList     /* Expression list to resolve.  May be NULL. */
){
  SrcList sSrc;                   /* Fake SrcList for pParse->pNewTable */
  NameContext sNC;                /* Name context for pParse->pNewTable */
  int rc;

  assert( type==0 || pTab!=0 );
  assert( type==NC_IsCheck || type==NC_PartIdx || type==NC_IdxExpr || pTab==0 );
  memset(&sNC, 0, sizeof(sNC));
  memset(&sSrc, 0, sizeof(sSrc));
  if( pTab ){
    sSrc.nSrc = 1;
    sSrc.a[0].zName = pTab->zName;
    sSrc.a[0].pTab = pTab;
    sSrc.a[0].iCursor = -1;
  }
  sNC.pParse = pParse;
  sNC.pSrcList = &sSrc;
  sNC.ncFlags = type | NC_IsDDL;
  if( (rc = sqlite3ResolveExprNames(&sNC, pExpr))!=SQLITE_OK ) return rc;
  if( pList ) rc = sqlite3ResolveExprListNames(&sNC, pList);
  return rc;
}

// Assembly:
pushq %rbx
subq $0xb0, %rsp
movq %r8, %rbx
xorl %eax, %eax
movq %rax, 0xa8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x98(%rsp)
movups %xmm0, 0x88(%rsp)
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x60(%rsp)
movq %rax, 0x70(%rsp)
testq %rsi, %rsi
je 0x5b247
movl $0x1, (%rsp)
movq (%rsi), %rax
movq %rax, 0x18(%rsp)
movq %rsi, 0x28(%rsp)
movl $0xffffffff, 0x48(%rsp) # imm = 0xFFFFFFFF
leaq 0x78(%rsp), %rax
movq %rdi, (%rax)
movq %rsp, %rsi
movq %rsi, 0x8(%rax)
orl $0x10000, %edx          # imm = 0x10000
movl %edx, 0x28(%rax)
movq %rax, %rdi
movq %rcx, %rsi
callq 0x5b9a5
testl %eax, %eax
setne %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x5b286
leaq 0x78(%rsp), %rdi
movq %rbx, %rsi
callq 0x5ba7c
addq $0xb0, %rsp
popq %rbx
retq