LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::readtcpcli(bamboo::tcpcli_t*, unsigned char*, int, char*)
static int readtcpcli(tcpcli_t *tcpcli, unsigned char *buff, int n, char *msg)
	{
		int nr, err;

		tracet(4, "readtcpcli: sock=%d\n", tcpcli->svr.sock);

		if (!waittcpcli(tcpcli, msg)) return 0;

		if ((nr = recv_nb(tcpcli->svr.sock, buff, n)) == -1) {
			if ((err = errsock())) {
				tracet(1, "readtcpcli: recv error sock=%d err=%d\n", tcpcli->svr.sock, err);
				sprintf(msg, "recv error (%d)", err);
			}
			else {
				sprintf(msg, "disconnected");
			}
			discontcp(&tcpcli->svr, tcpcli->tirecon);
			return 0;
		}
		if (nr > 0) tcpcli->svr.tact = tickget();
		tracet(5, "readtcpcli: exit sock=%d nr=%d\n", tcpcli->svr.sock, nr);
		return nr;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %rbx
movl 0x118(%rdi), %edx
leaq 0x1beaf(%rip), %rsi     # 0x767ab
xorl %r14d, %r14d
movl $0x4, %edi
xorl %eax, %eax
callq 0x53ec4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5d8a9
testl %eax, %eax
je 0x5a9cf
movl 0x118(%rbx), %edi
movq %r13, %rsi
movl %r12d, %edx
callq 0x5d6b4
cmpl $-0x1, %eax
je 0x5a967
movl %eax, %r12d
testl %eax, %eax
jle 0x5a946
callq 0x5088f
movl %eax, 0x120(%rbx)
movl 0x118(%rbx), %edx
leaq 0x1beb1(%rip), %rsi     # 0x76804
movl $0x5, %edi
movl %r12d, %ecx
xorl %eax, %eax
callq 0x53ec4
movl %r12d, %r14d
jmp 0x5a9cf
callq 0x8070
movl (%rax), %r12d
testl %r12d, %r12d
je 0x5a9a6
movl 0x118(%rbx), %edx
leaq 0x1be3f(%rip), %rsi     # 0x767c0
movl $0x1, %edi
movl %r12d, %ecx
xorl %eax, %eax
callq 0x53ec4
leaq 0x1be50(%rip), %rsi     # 0x767e7
movq %r15, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x8120
jmp 0x5a9c1
movabsq $0x64657463656e6e, %rax # imm = 0x64657463656E6E
movq %rax, 0x5(%r15)
movabsq $0x656e6e6f63736964, %rax # imm = 0x656E6E6F63736964
movq %rax, (%r15)
movl 0x12c(%rbx), %esi
movq %rbx, %rdi
callq 0x5d761
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::writetcpsvr(bamboo::tcpsvr_tag*, unsigned char*, int, char*)
static int writetcpsvr(tcpsvr_t *tcpsvr, unsigned char *buff, int n, char *msg)
	{
		int i, ns = 0, err;

		tracet(4, "writetcpsvr: state=%d n=%d\n", tcpsvr->svr.state, n);

		if (!waittcpsvr(tcpsvr, msg)) return 0;

		for (i = 0; i < MAXCLI; i++) {
			if (tcpsvr->cli[i].state != 2) continue;

			if ((ns = send_nb(tcpsvr->cli[i].sock, buff, n)) == -1) {
				if ((err = errsock())) {
					tracet(1, "writetcpsvr: send error i=%d sock=%d err=%d\n", i,
						tcpsvr->cli[i].sock, err);
				}
				discontcp(&tcpsvr->cli[i], ticonnect);
				updatetcpsvr(tcpsvr, msg);
				return 0;
			}
			if (ns > 0) tcpsvr->cli[i].tact = tickget();
		}
		return ns;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %r15
movl (%rdi), %edx
leaq 0x1bd29(%rip), %rsi     # 0x7728b
xorl %r14d, %r14d
movl $0x4, %edi
movl %r12d, %ecx
xorl %eax, %eax
callq 0x53ec4
movq %r15, -0x30(%rbp)
movq %r15, %rdi
movq %rbx, -0x38(%rbp)
movq %rbx, %rsi
callq 0x5d463
testl %eax, %eax
je 0x5b62b
movq -0x30(%rbp), %rax
leaq 0x128(%rax), %r15
xorl %ebx, %ebx
xorl %r14d, %r14d
cmpl $0x2, (%r15)
jne 0x5b5cf
movl 0x118(%r15), %edi
movq %r13, %rsi
movl %r12d, %edx
callq 0x5edf0
cmpl $-0x1, %eax
je 0x5b5e4
movl %eax, %r14d
testl %eax, %eax
jle 0x5b5cf
callq 0x5088f
movl %eax, 0x120(%r15)
incq %rbx
addq $0x128, %r15            # imm = 0x128
cmpq $0x100, %rbx            # imm = 0x100
jne 0x5b59f
jmp 0x5b62b
callq 0x8070
movl (%rax), %r8d
testl %r8d, %r8d
je 0x5b60d
movl 0x118(%r15), %ecx
leaq 0x1bca8(%rip), %rsi     # 0x772a7
movl $0x1, %edi
movl %ebx, %edx
xorl %eax, %eax
callq 0x53ec4
movl 0x3488d(%rip), %esi     # 0x8fea0
movq %r15, %rdi
callq 0x5d761
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x5d7b3
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::writetcpcli(bamboo::tcpcli_t*, unsigned char*, int, char*)
static int writetcpcli(tcpcli_t *tcpcli, unsigned char *buff, int n, char *msg)
	{
		int ns, err;

		tracet(3, "writetcpcli: sock=%d state=%d n=%d\n", tcpcli->svr.sock, tcpcli->svr.state, n);

		if (!waittcpcli(tcpcli, msg)) return 0;

		if ((ns = send_nb(tcpcli->svr.sock, buff, n)) == -1) {
			if ((err = errsock())) {
				tracet(1, "writetcp: send error sock=%d err=%d\n", tcpcli->svr.sock, err);
				sprintf(msg, "send error (%d)", err);
			}
			else {
				sprintf(msg, "disconnected");
			}
			discontcp(&tcpcli->svr, tcpcli->tirecon);
			return 0;
		}
		if (ns > 0) tcpcli->svr.tact = tickget();
		tracet(5, "writetcpcli: exit sock=%d ns=%d\n", tcpcli->svr.sock, ns);
		return ns;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %rbx
movl (%rdi), %ecx
movl 0x118(%rdi), %edx
leaq 0x1bc6e(%rip), %rsi     # 0x772d4
xorl %r14d, %r14d
movl $0x3, %edi
movl %r12d, %r8d
xorl %eax, %eax
callq 0x53ec4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5d8a9
testl %eax, %eax
je 0x5b73c
movl 0x118(%rbx), %edi
movq %r13, %rsi
movl %r12d, %edx
callq 0x5edf0
cmpl $-0x1, %eax
je 0x5b6d4
movl %eax, %r12d
testl %eax, %eax
jle 0x5b6b3
callq 0x5088f
movl %eax, 0x120(%rbx)
movl 0x118(%rbx), %edx
leaq 0x1bc6d(%rip), %rsi     # 0x7732d
movl $0x5, %edi
movl %r12d, %ecx
xorl %eax, %eax
callq 0x53ec4
movl %r12d, %r14d
jmp 0x5b73c
callq 0x8070
movl (%rax), %r12d
testl %r12d, %r12d
je 0x5b713
movl 0x118(%rbx), %edx
leaq 0x1bc0a(%rip), %rsi     # 0x772f8
movl $0x1, %edi
movl %r12d, %ecx
xorl %eax, %eax
callq 0x53ec4
leaq 0x1bc19(%rip), %rsi     # 0x7731d
movq %r15, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x8120
jmp 0x5b72e
movabsq $0x64657463656e6e, %rax # imm = 0x64657463656E6E
movq %rax, 0x5(%r15)
movabsq $0x656e6e6f63736964, %rax # imm = 0x656E6E6F63736964
movq %rax, (%r15)
movl 0x12c(%rbx), %esi
movq %rbx, %rdi
callq 0x5d761
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::strsetsel(bamboo::stream_t*, char const*)
extern int strsetsel(stream_t *stream, const char *sel)
	{
		if (!stream->port ||
			(stream->type != STR_NTRIPC_S && stream->type != STR_NTRIPC_C)) {
			return 0;
		}
		strlock(stream);

		strcpy(((ntripc_t *)stream->port)->mntpnt, sel);

		strunlock(stream);
		return 1;
	}

// Assembly:
xorl %eax, %eax
cmpq $0x0, 0x58(%rdi)
je 0x5b7a4
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl (%rdi), %ecx
andl $-0x2, %ecx
cmpl $0xa, %ecx
jne 0x5b79a
movq %rsi, %rbx
leaq 0x30(%r14), %r15
movq %r15, %rdi
callq 0x8910
movq 0x58(%r14), %rdi
addq $0x8, %rdi
movq %rbx, %rsi
callq 0x85c0
movq %r15, %rdi
callq 0x84b0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::strgetsel(bamboo::stream_t*, char*)
extern int strgetsel(stream_t *stream, char *sel)
	{
		*sel = '\0';

		if (!stream->port ||
			(stream->type != STR_NTRIPC_S && stream->type != STR_NTRIPC_C)) {
			return 0;
		}
		strlock(stream);

		strcpy(sel, ((ntripc_t *)stream->port)->mntpnt);

		strunlock(stream);
		return 1;
	}

// Assembly:
movb $0x0, (%rsi)
xorl %eax, %eax
cmpq $0x0, 0x58(%rdi)
je 0x5b7fe
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl (%rdi), %ecx
andl $-0x2, %ecx
cmpl $0xa, %ecx
jne 0x5b7f4
movq %rsi, %rbx
leaq 0x30(%r14), %r15
movq %r15, %rdi
callq 0x8910
movq 0x58(%r14), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x85c0
movq %r15, %rdi
callq 0x84b0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::strgetmsgid(bamboo::stream_t*, int*)
extern int strgetmsgid(stream_t *stream, int *msgid) {
		if (!stream->port ||
			(stream->type != STR_NTRIPC_S && stream->type != STR_NTRIPC_C)) {
			return 0;
		}
		strlock(stream);
		*msgid = ((ntripc_t*)stream->port)->msgid;
		strunlock(stream);
		return 1;
	}

// Assembly:
xorl %eax, %eax
cmpq $0x0, 0x58(%rdi)
je 0x5b851
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl (%rdi), %ecx
andl $-0x2, %ecx
cmpl $0xa, %ecx
jne 0x5b847
movq %rsi, %rbx
leaq 0x30(%r14), %r15
movq %r15, %rdi
callq 0x8910
movq 0x58(%r14), %rax
movl 0x820f40(%rax), %eax
movl %eax, (%rbx)
movq %r15, %rdi
callq 0x84b0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::strsetmsgid(bamboo::stream_t*, int)
extern int strsetmsgid(stream_t *stream, int msgid) {
		if (!stream->port ||
			(stream->type != STR_NTRIPC_S && stream->type != STR_NTRIPC_C)) {
			return 0;
		}
		strlock(stream);

		((ntripc_t*)stream->port)->msgid = msgid;
		strunlock(stream);
		return 1;
	}

// Assembly:
xorl %eax, %eax
cmpq $0x0, 0x58(%rdi)
je 0x5b8a1
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl (%rdi), %ecx
andl $-0x2, %ecx
cmpl $0xa, %ecx
jne 0x5b897
movl %esi, %ebx
leaq 0x30(%r14), %r15
movq %r15, %rdi
callq 0x8910
movq 0x58(%r14), %rax
movl %ebx, 0x820f40(%rax)
movq %r15, %rdi
callq 0x84b0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::strstat(bamboo::stream_t*, char*)
extern int strstat(stream_t *stream, char *msg)
	{
		int state;

		tracet(4, "strstat:\n");

		strlock(stream);
		if (msg) {
			strncpy(msg, stream->msg, MAXSTRMSG - 1); msg[MAXSTRMSG - 1] = '\0';
		}
		if (!stream->port) {
			strunlock(stream);
			return stream->state;
		}
		switch (stream->type) {
		case STR_SERIAL: state = stateserial((serial_t *)stream->port); break;
		case STR_FILE: state = statefile((file_t   *)stream->port); break;
		case STR_TCPSVR: state = statetcpsvr((tcpsvr_t *)stream->port); break;
		case STR_TCPCLI: state = statetcpcli((tcpcli_t *)stream->port); break;
		case STR_NTRIPSVR:
		case STR_NTRIPCLI: state = statentrip((ntrip_t  *)stream->port); break;
		case STR_NTRIPC_C:
		case STR_NTRIPC_S: state = statentripc((ntripc_t *)stream->port); break;
		case STR_UDPSVR: state = stateudpsvr((udp_t    *)stream->port); break;
		case STR_UDPCLI: state = stateudpcli((udp_t    *)stream->port); break;
		case STR_MEMBUF: state = statemembuf((membuf_t *)stream->port); break;
		case STR_FTP: state = stateftp((ftp_t    *)stream->port); break;
		case STR_HTTP: state = stateftp((ftp_t    *)stream->port); break;
		default:
			strunlock(stream);
			return 0;
		}
		if (state == 2 && (int)(tickget() - stream->tact) <= TINTACT) state = 3;
		strunlock(stream);
		return state;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq 0x1a5cd(%rip), %rsi     # 0x75e86
movl $0x4, %edi
xorl %eax, %eax
callq 0x53ec4
leaq 0x30(%r14), %rbx
movq %rbx, %rdi
callq 0x8910
testq %r15, %r15
je 0x5b8f2
leaq 0x460(%r14), %rsi
movl $0x3ff, %edx            # imm = 0x3FF
movq %r15, %rdi
callq 0x8350
movb $0x0, 0x3ff(%r15)
movq 0x58(%r14), %rax
testq %rax, %rax
je 0x5b91c
movl (%r14), %r15d
leal -0x1(%r15), %ecx
cmpl $0xd, %ecx
ja 0x5b95a
leaq 0x1a3e2(%rip), %rdx     # 0x75cf0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl (%rax), %r15d
jmp 0x5b975
movq %rbx, %rdi
callq 0x84b0
movl 0x8(%r14), %r15d
jmp 0x5b99c
movl (%rax), %eax
xorl %ecx, %ecx
cmpl $0x3, %eax
setl %cl
testl %eax, %eax
leal -0x1(,%rcx,4), %eax
movl $0x2, %r15d
cmovnel %eax, %r15d
jmp 0x5b975
movl (%rax), %r15d
testl %r15d, %r15d
jne 0x5b975
movq 0x8510(%rax), %rax
jmp 0x5b917
movq %rbx, %rdi
callq 0x84b0
xorl %r15d, %r15d
jmp 0x5b99c
xorl %r15d, %r15d
cmpl 0x4(%rax), %r15d
sbbl %r15d, %r15d
orl $0x2, %r15d
cmpl $0x2, %r15d
jne 0x5b994
callq 0x5088f
subl 0x24(%r14), %eax
xorl %r15d, %r15d
cmpl $0xc9, %eax
setl %r15b
orl $0x2, %r15d
movq %rbx, %rdi
callq 0x84b0
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::strsum(bamboo::stream_t*, int*, int*, int*, int*)
extern void strsum(stream_t *stream, int *inb, int *inr, int *outb, int *outr)
	{
		tracet(4, "strsum:\n");

		strlock(stream);
		if (inb)  *inb = stream->inb;
		if (inr)  *inr = stream->inr;
		if (outb) *outb = stream->outb;
		if (outr) *outr = stream->outr;
		strunlock(stream);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, -0x30(%rbp)
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x19bb4(%rip), %rsi     # 0x75e9b
movl $0x4, %edi
xorl %eax, %eax
callq 0x53ec4
leaq 0x30(%r14), %r12
movq %r12, %rdi
callq 0x8910
testq %rbx, %rbx
je 0x5c30a
movl 0xc(%r14), %eax
movl %eax, (%rbx)
testq %r13, %r13
je 0x5c317
movl 0x10(%r14), %eax
movl %eax, (%r13)
testq %r15, %r15
movq -0x30(%rbp), %rcx
je 0x5c327
movl 0x14(%r14), %eax
movl %eax, (%r15)
testq %rcx, %rcx
je 0x5c332
movl 0x18(%r14), %eax
movl %eax, (%rcx)
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x84b0
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::strsetsrctbl(bamboo::stream_t*, char const*)
extern int strsetsrctbl(stream_t *stream, const char *file)
	{
		FILE *fp;
		ntripc_t *ntripc;
		char *srctbl = NULL, *srctbl_n;
		int n = 0, nmax;

		tracet(3, "strsetsrctbl: file=%s\n", file);

		strlock(stream);

		if (stream->type != STR_NTRIPC_C && stream->type != STR_NTRIPC_S) {
			strunlock(stream);
			return 1;
		}
		if (!(ntripc = (ntripc_t *)stream->port)) {
			strunlock(stream);
			return 0;
		}
		if (!(fp = fopen(file, "rb"))) {
			tracet(2, "strsetsrctbl: file open error %s\n", file);
			strunlock(stream);
			return 0;
		}
		for (nmax = 4096;; nmax += 4096) {
			if (!(srctbl_n = (char *)realloc(srctbl, nmax))) {
				free(srctbl); fclose(fp);
				strunlock(stream);
				return 0;
			}
			srctbl = srctbl_n;
			n += fread(srctbl + n, 1, nmax - 1 - n, fp);
			if (n < nmax - 1) break;
		}
		srctbl[n++] = '\0';
		fclose(fp);
		tracet(3, "strsetsrctbl: n=%d\n", n);

		lock(&ntripc->lock_srctbl);

		free(ntripc->srctbl);
		ntripc->srctbl = srctbl;

		unlock(&ntripc->lock_srctbl);
		strunlock(stream);
		return 1;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r12
leaq 0x19b3e(%rip), %rsi     # 0x75ea4
xorl %r14d, %r14d
movl $0x3, %edi
movq %r15, %rdx
xorl %eax, %eax
callq 0x53ec4
leaq 0x30(%r12), %rbx
movq %rbx, %rdi
callq 0x8910
movl (%r12), %eax
andl $-0x2, %eax
cmpl $0xa, %eax
jne 0x5c431
movq 0x58(%r12), %r12
testq %r12, %r12
je 0x5c4ca
leaq 0x19b11(%rip), %rsi     # 0x75ebb
movq %r15, %rdi
callq 0x8780
testq %rax, %rax
je 0x5c43c
movq %rax, %r14
movq %rbx, -0x30(%rbp)
movl $0x1000, %edi           # imm = 0x1000
callq 0x8850
xorl %ebx, %ebx
testq %rax, %rax
je 0x5c457
movq %rax, %r15
movq %r12, -0x38(%rbp)
movl $0xfff, %r13d           # imm = 0xFFF
movl $0x2000, %r12d          # imm = 0x2000
movslq %ebx, %rbx
leaq (%r15,%rbx), %rdi
movq %r13, %rdx
subq %rbx, %rdx
movl $0x1, %esi
movq %r14, %rcx
callq 0x8930
addl %eax, %ebx
movslq %ebx, %rax
cmpq %rax, %r13
jg 0x5c46b
movq %r15, %rdi
movq %r12, %rsi
callq 0x8a80
movq %r15, %rdi
movl $0x1000, %ecx           # imm = 0x1000
addq %rcx, %r13
addq %rcx, %r12
movq %rax, %r15
testq %rax, %rax
jne 0x5c3ea
jmp 0x5c459
movl $0x1, %r14d
jmp 0x5c4ca
leaq 0x19a7b(%rip), %rsi     # 0x75ebe
xorl %r14d, %r14d
movl $0x2, %edi
movq %r15, %rdx
xorl %eax, %eax
callq 0x53ec4
jmp 0x5c4ca
xorl %edi, %edi
callq 0x87b0
movq %r14, %rdi
callq 0x8630
xorl %r14d, %r14d
jmp 0x5c4c6
leal 0x1(%rax), %r12d
movb $0x0, (%r15,%rax)
movq %r14, %rdi
callq 0x8630
leaq 0x19a5d(%rip), %rsi     # 0x75ee0
movl $0x3, %edi
movl %r12d, %edx
xorl %eax, %eax
callq 0x53ec4
movq -0x38(%rbp), %rbx
leaq 0x310(%rbx), %r14
movq %r14, %rdi
callq 0x8910
movq 0x308(%rbx), %rdi
callq 0x87b0
movq %r15, 0x308(%rbx)
movq %r14, %rdi
callq 0x84b0
movl $0x1, %r14d
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x84b0
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::strsetopt(int const*)
extern void strsetopt(const int *opt)
	{
		tracet(3, "strsetopt: opt=%d %d %d %d %d %d %d %d\n", opt[0], opt[1], opt[2],
			opt[3], opt[4], opt[5], opt[6], opt[7]);

		toinact = 0 < opt[0] && opt[0] < 1000 ? 1000 : opt[0]; /* >=1s */
		ticonnect = opt[1] < 1000 ? 1000 : opt[1]; /* >=1s */
		tirate = opt[2] < 100 ? 100 : opt[2]; /* >=0.1s */
		buffsize = opt[3] < 4096 ? 4096 : opt[3]; /* >=4096byte */
		fswapmargin = opt[4] < 0 ? 0 : opt[4];
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %edx
movl 0x4(%rdi), %ecx
movl 0x8(%rdi), %r8d
movl 0xc(%rdi), %r9d
movl 0x10(%rdi), %r10d
movl 0x14(%rdi), %r11d
movl 0x18(%rdi), %r15d
movl 0x1c(%rdi), %r12d
leaq 0x199de(%rip), %rsi     # 0x75ef4
xorl %r14d, %r14d
movl $0x3, %edi
xorl %eax, %eax
pushq %r12
pushq %r15
pushq %r11
pushq %r10
callq 0x53ec4
addq $0x20, %rsp
movl (%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0x3e7, %ecx            # imm = 0x3E7
movl $0x3e8, %ecx            # imm = 0x3E8
cmovbl %ecx, %eax
movl %eax, 0x33952(%rip)     # 0x8fe9c
movl 0x4(%rbx), %eax
cmpl $0x3e9, %eax            # imm = 0x3E9
cmovgel %eax, %ecx
movl %ecx, 0x33945(%rip)     # 0x8fea0
movl 0x8(%rbx), %eax
cmpl $0x65, %eax
movl $0x64, %ecx
cmovgel %eax, %ecx
movl %ecx, 0x33929(%rip)     # 0x8fe98
movl 0xc(%rbx), %eax
cmpl $0x1001, %eax           # imm = 0x1001
movl $0x1000, %ecx           # imm = 0x1000
cmovgel %eax, %ecx
movl %ecx, 0x3391f(%rip)     # 0x8fea4
movl 0x10(%rbx), %eax
testl %eax, %eax
cmovgl %eax, %r14d
movl %r14d, 0x33913(%rip)    # 0x8fea8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::strsettimeout(bamboo::stream_t*, int, int)
extern void strsettimeout(stream_t *stream, int toinact, int tirecon)
	{
		tcpcli_t *tcpcli;

		tracet(3, "strsettimeout: toinact=%d tirecon=%d\n", toinact, tirecon);

		if (stream->type == STR_TCPCLI) {
			tcpcli = (tcpcli_t *)stream->port;
		}
		else if (stream->type == STR_NTRIPCLI || stream->type == STR_NTRIPSVR) {
			tcpcli = ((ntrip_t *)stream->port)->tcp;
		}
		else return;

		tcpcli->toinact = toinact;
		tcpcli->tirecon = tirecon;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
leaq 0x19965(%rip), %rsi     # 0x75f1c
movl $0x3, %edi
movl %r14d, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x53ec4
movl (%r15), %eax
leal -0x6(%rax), %ecx
cmpl $0x2, %ecx
jae 0x5c5e1
movl $0x8510, %eax           # imm = 0x8510
addq 0x58(%r15), %rax
movq %rax, %r15
jmp 0x5c5ea
cmpl $0x4, %eax
jne 0x5c5fa
addq $0x58, %r15
movq (%r15), %rax
movl %r14d, 0x128(%rax)
movl %ebx, 0x12c(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::strgettime(bamboo::stream_t*)
extern gtime_t strgettime(stream_t *stream)
	{
		file_t *file;
		if (stream->type == STR_FILE && (stream->mode&STR_MODE_R) &&
			(file = (file_t *)stream->port)) {
			return timeadd(file->time, file->start); /* replay start time */
		}
		return utc2gpst(timeget());
	}

// Assembly:
cmpl $0x2, (%rdi)
jne 0x5c69d
testb $0x1, 0x4(%rdi)
je 0x5c69d
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0x5c69d
movq 0x838(%rax), %rdi
movsd 0x840(%rax), %xmm0
movsd 0x870(%rax), %xmm1
jmp 0x4fe63
pushq %rbp
movq %rsp, %rbp
callq 0x4febe
movq %rax, %rdi
popq %rbp
jmp 0x5040e
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::waittcpsvr(bamboo::tcpsvr_tag*, char*)
static int waittcpsvr(tcpsvr_t *tcpsvr, char *msg)
	{
		tracet(4, "waittcpsvr: sock=%d state=%d\n", tcpsvr->svr.sock, tcpsvr->svr.state);

		if (tcpsvr->svr.state <= 0) return 0;

		while (accsock(tcpsvr, msg));

		updatetcpsvr(tcpsvr, msg);
		return tcpsvr->svr.state == 2;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rbx
movl (%rdi), %ecx
movl 0x118(%rdi), %edx
leaq 0x19243(%rip), %rsi     # 0x766d0
xorl %r15d, %r15d
movl $0x4, %edi
xorl %eax, %eax
callq 0x53ec4
cmpl $0x0, (%rbx)
jle 0x5d69f
leaq 0x128(%rbx), %r14
movl $0x10, -0x34(%rbp)
movl 0x118(%rbx), %edx
movl $0x4, %edi
leaq 0x19229(%rip), %rsi     # 0x766ee
xorl %eax, %eax
callq 0x53ec4
movq %r14, %rax
xorl %r15d, %r15d
cmpl $0x0, (%rax)
je 0x5d4ef
incq %r15
addq $0x128, %rax            # imm = 0x128
cmpq $0x100, %r15            # imm = 0x100
jne 0x5d4d2
movl $0x100, %r15d           # imm = 0x100
cmpl $0xff, %r15d
ja 0x5d689
movl 0x118(%rbx), %r12d
xorps %xmm0, %xmm0
movaps %xmm0, -0x60(%rbp)
movaps %xmm0, -0x70(%rbp)
movaps %xmm0, -0x80(%rbp)
movaps %xmm0, -0x90(%rbp)
movaps %xmm0, -0xa0(%rbp)
movaps %xmm0, -0xb0(%rbp)
movaps %xmm0, -0xc0(%rbp)
leal 0x3f(%r12), %eax
testl %r12d, %r12d
cmovnsl %r12d, %eax
movl %eax, %edx
andl $-0x40, %edx
movl %r12d, %ecx
subl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movaps %xmm0, -0xd0(%rbp)
movaps %xmm0, -0xe0(%rbp)
sarl $0x6, %eax
cltq
orq %rdx, -0xe0(%rbp,%rax,8)
leal 0x1(%r12), %edi
leaq -0xe0(%rbp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
leaq -0x60(%rbp), %r8
callq 0x85e0
testl %eax, %eax
jle 0x5d594
movl %r12d, %edi
leaq -0x44(%rbp), %rsi
leaq -0x34(%rbp), %rdx
callq 0x8200
movl %eax, %r13d
testl %eax, %eax
je 0x5d689
cmpl $-0x1, %r13d
je 0x5d63f
movl %r13d, %edi
movq -0x30(%rbp), %rsi
callq 0x5d008
testl %eax, %eax
je 0x5d689
movl %r15d, %eax
imulq $0x128, %rax, %rax      # imm = 0x128
leaq (%r14,%rax), %r12
addq $0x4, %r12
movl %r13d, 0x114(%r12)
movups -0x44(%rbp), %xmm0
movups %xmm0, 0x104(%r12)
movl -0x40(%rbp), %edi
callq 0x82a0
movq %r12, %rdi
movq %rax, %rsi
callq 0x85c0
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x85c0
movl 0x114(%r12), %edx
movl $0x3, %edi
leaq 0x19121(%rip), %rsi     # 0x76738
movq %r12, %rcx
movl %r15d, %r8d
xorl %eax, %eax
callq 0x53ec4
movl $0x2, -0x4(%r12)
callq 0x5088f
movl %eax, 0x11c(%r12)
jmp 0x5d4ac
callq 0x8070
movl (%rax), %r15d
leaq 0x190b2(%rip), %rsi     # 0x76700
movq -0x30(%rbp), %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x8120
movl 0x118(%rbx), %edx
leaq 0x190a9(%rip), %rsi     # 0x76712
movl $0x1, %edi
movl %r15d, %ecx
xorl %eax, %eax
callq 0x53ec4
movl 0x118(%rbx), %edi
callq 0x8c50
movl $0x0, (%rbx)
movq %rbx, %rdi
movq -0x30(%rbp), %rsi
callq 0x5d7b3
xorl %r15d, %r15d
cmpl $0x2, (%rbx)
sete %r15b
movl %r15d, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::recv_nb(int, unsigned char*, int)
static int recv_nb(socket_t sock, unsigned char *buff, int n)
	{
		struct timeval tv = { 0 };
		fd_set rs;
		int ret, nr;

		FD_ZERO(&rs); FD_SET(sock, &rs);
		ret = select(sock + 1, &rs, NULL, NULL, &tv);
		if (ret <= 0) return ret;
		nr = recv(sock, (char *)buff, n, 0);
		return nr <= 0 ? -1 : nr;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movl %edx, %r14d
movq %rsi, %rbx
movl %edi, %r15d
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %r8
movaps %xmm0, (%r8)
leaq -0xb0(%rbp), %rsi
movaps %xmm0, 0x70(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x20(%rsi)
leal 0x3f(%r15), %eax
testl %edi, %edi
cmovnsl %edi, %eax
movl %eax, %edx
andl $-0x40, %edx
movl %edi, %ecx
subl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
sarl $0x6, %eax
cltq
orq %rdx, -0xb0(%rbp,%rax,8)
leal 0x1(%r15), %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x85e0
testl %eax, %eax
jle 0x5d753
movslq %r14d, %rdx
movl %r15d, %edi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x8210
movq %rax, %rcx
testl %ecx, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovgl %ecx, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::discontcp(bamboo::tcp_t*, int)
static void discontcp(tcp_t *tcp, int tcon)
	{
		tracet(3, "discontcp: sock=%d tcon=%d\n", tcp->sock, tcon);

		closesocket(tcp->sock);
		tcp->state = 0;
		tcp->tcon = tcon;
		tcp->tdis = tickget();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl 0x118(%rdi), %edx
leaq 0x18fe7(%rip), %rsi     # 0x76761
movl $0x3, %edi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x53ec4
movl 0x118(%r14), %edi
callq 0x8c50
movl $0x0, (%r14)
movl %ebx, 0x11c(%r14)
callq 0x5088f
movl %eax, 0x124(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::updatetcpsvr(bamboo::tcpsvr_tag*, char*)
static void updatetcpsvr(tcpsvr_t *tcpsvr, char *msg)
	{
		char saddr[256] = "";
		int i, n = 0;

		tracet(4, "updatetcpsvr: state=%d\n", tcpsvr->svr.state);

		if (tcpsvr->svr.state == 0) return;

		for (i = 0; i < MAXCLI; i++) {
			if (!tcpsvr->cli[i].state) continue;
			strcpy(saddr, tcpsvr->cli[i].saddr);
			n++;
		}
		if (n == 0) {
			tcpsvr->svr.state = 1;
			sprintf(msg, "waiting...");
			return;
		}
		tcpsvr->svr.state = 2;
		if (n == 1) sprintf(msg, "%s", saddr); else sprintf(msg, "%d clients", n);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x130(%rbp), %rdi
xorl %r14d, %r14d
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x8390
movl (%r15), %edx
leaq 0x18f90(%rip), %rsi     # 0x7677d
movl $0x4, %edi
xorl %eax, %eax
callq 0x53ec4
cmpl $0x0, (%r15)
je 0x5d897
movq %rbx, -0x30(%rbp)
leaq 0x12c(%r15), %r13
leaq -0x130(%rbp), %r12
xorl %ebx, %ebx
cmpl $0x0, 0x128(%r15,%rbx)
je 0x5d831
leaq (%rbx,%r13), %rsi
movq %r12, %rdi
callq 0x85c0
incl %r14d
addq $0x128, %rbx            # imm = 0x128
cmpq $0x12800, %rbx          # imm = 0x12800
jne 0x5d817
testl %r14d, %r14d
je 0x5d865
movl $0x2, (%r15)
cmpl $0x1, %r14d
movq -0x30(%rbp), %rdi
jne 0x5d886
leaq -0x130(%rbp), %rsi
callq 0x85c0
jmp 0x5d897
movl $0x1, (%r15)
movabsq $0x2e676e6974696177, %rax # imm = 0x2E676E6974696177
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
movl $0x2e2e2e, 0x7(%rcx)    # imm = 0x2E2E2E
jmp 0x5d897
leaq 0x18f13(%rip), %rsi     # 0x767a0
movl %r14d, %edx
xorl %eax, %eax
callq 0x8120
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::encbase64(char*, unsigned char const*, int)
static int encbase64(char *str, const unsigned char *byte, int n)
	{
		const char table[] =
			"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
		int i, j, k, b;

		tracet(4, "encbase64: n=%d\n", n);

		for (i = j = 0; i / 8 < n;) {
			for (k = b = 0; k < 6; k++, i++) {
				b <<= 1; if (i / 8 < n) b |= (byte[i / 8] >> (7 - i % 8)) & 0x1;
			}
			str[j++] = table[b];
		}
		while (j & 0x3) str[j++] = '=';
		str[j] = '\0';
		tracet(5, "encbase64: str=%s\n", str);
		return j;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x18799(%rip), %rsi     # 0x76a7d
xorl %r14d, %r14d
movl $0x4, %edi
xorl %eax, %eax
callq 0x53ec4
testl %r15d, %r15d
jle 0x5e377
xorl %r14d, %r14d
leaq 0x1936e(%rip), %rax     # 0x77670
xorl %ecx, %ecx
xorl %esi, %esi
xorl %edx, %edx
leal (%rcx,%rsi), %edi
addl %edx, %edx
leal (%rcx,%rsi), %r8d
addl $0x7, %r8d
testl %edi, %edi
cmovnsl %edi, %r8d
movl %r8d, %r9d
sarl $0x3, %r9d
cmpl %r15d, %r9d
jge 0x5e34e
andl $-0x8, %r8d
subl %r8d, %edi
movslq %r9d, %r8
movzbl (%r12,%r8), %r8d
movb $0x7, %r9b
subb %dil, %r9b
movzbl %r9b, %edi
xorl %r9d, %r9d
btl %edi, %r8d
setb %r9b
orl %r9d, %edx
incl %esi
cmpl $0x6, %esi
jne 0x5e308
leal 0x6(%rcx), %esi
movslq %edx, %rdx
movb (%rdx,%rax), %dl
movb %dl, (%rbx,%r14)
incq %r14
addl $0xd, %ecx
testl %esi, %esi
cmovnsl %esi, %ecx
sarl $0x3, %ecx
cmpl %r15d, %ecx
movl %esi, %ecx
jl 0x5e304
testb $0x3, %r14b
je 0x5e3b4
movl %r14d, %r15d
leaq (%rbx,%r15), %rdi
movl %r14d, %eax
andl $0x3, %eax
movl $0x4, %edx
subl %eax, %edx
movl $0x3d, %esi
callq 0x8390
incq %r15
orl $0x3, %r14d
incl %r14d
movq %r15, %rax
incq %rax
testb $0x3, %r15b
movq %rax, %r15
jne 0x5e3a8
movl %r14d, %eax
movb $0x0, (%rbx,%rax)
leaq 0x186cc(%rip), %rsi     # 0x76a8e
movl $0x5, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x53ec4
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::discon_ntripc(bamboo::ntripc_t*, int)
static void discon_ntripc(ntripc_t *ntripc, int i)
	{
		tracet(3, "discon_ntripc: i=%d\n", i);

		discontcp(&ntripc->tcp->cli[i], ticonnect);
		ntripc->con[i].nb = 0;
		ntripc->con[i].buff[0] = '\0';
		ntripc->con[i].state = 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x182e6(%rip), %rsi     # 0x76fa6
xorl %r15d, %r15d
movl $0x3, %edi
movl %ebx, %edx
xorl %eax, %eax
callq 0x53ec4
movslq %ebx, %rbx
imulq $0x128, %rbx, %rdi      # imm = 0x128
addq 0x338(%r14), %rdi
addq $0x128, %rdi            # imm = 0x128
movl 0x311b1(%rip), %esi     # 0x8fea0
callq 0x5d761
imulq $0x820c, %rbx, %rax     # imm = 0x820C
movl %r15d, 0x544(%r14,%rax)
movb $0x0, 0x548(%r14,%rax)
movl %r15d, 0x340(%r14,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::test_mntpnt(bamboo::ntripc_t*, char const*)
static int test_mntpnt(ntripc_t *ntripc, const char *mntpnt)
	{
		char *p, str[256];

		lock(&ntripc->lock_srctbl);

		if (!ntripc->srctbl) {
			unlock(&ntripc->lock_srctbl);
			return 1;
		}
		for (p = ntripc->srctbl; (p = strstr(p, "STR;")); p++) {
			if (sscanf(p, "STR;%255[^;]", str) && !strcmp(str, mntpnt)) break;
		}
		unlock(&ntripc->lock_srctbl);

		return p != NULL;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x310(%rdi), %r15
movq %r15, %rdi
callq 0x8910
movq 0x308(%rbx), %rdi
testq %rdi, %rdi
je 0x5edd1
movq %r15, -0x30(%rbp)
leaq 0x180c5(%rip), %rsi     # 0x76e24
callq 0x8160
testq %rax, %rax
setne %r12b
je 0x5edbf
movq %rax, %r15
leaq -0x130(%rbp), %r13
leaq 0x180a6(%rip), %rbx     # 0x76e24
movq %r15, %rdi
leaq 0x180a1(%rip), %rsi     # 0x76e29
movq %r13, %rdx
xorl %eax, %eax
callq 0x8610
testl %eax, %eax
je 0x5eda5
movq %r13, %rdi
movq %r14, %rsi
callq 0x8890
testl %eax, %eax
je 0x5edbf
incq %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8160
movq %rax, %r15
testq %rax, %rax
setne %r12b
jne 0x5ed7e
movq -0x30(%rbp), %rdi
callq 0x84b0
movzbl %r12b, %eax
andl $0x1, %eax
jmp 0x5edde
movq %r15, %rdi
callq 0x84b0
movl $0x1, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::send_nb(int, unsigned char*, int)
static int send_nb(socket_t sock, unsigned char *buff, int n)
	{
		struct timeval tv = { 0 };
		fd_set ws;
		int ret, ns;

		FD_ZERO(&ws); FD_SET(sock, &ws);
		ret = select(sock + 1, NULL, &ws, NULL, &tv);
		if (ret <= 0) return ret;
		ns = send(sock, (char *)buff, n, 0);
		return ns < n ? -1 : ns;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movl %edx, %r14d
movq %rsi, %rbx
movl %edi, %r15d
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %r8
movaps %xmm0, (%r8)
leaq -0xb0(%rbp), %rdx
movaps %xmm0, 0x70(%rdx)
movaps %xmm0, 0x60(%rdx)
movaps %xmm0, 0x50(%rdx)
movaps %xmm0, 0x40(%rdx)
movaps %xmm0, 0x30(%rdx)
movaps %xmm0, 0x20(%rdx)
leal 0x3f(%r15), %eax
testl %edi, %edi
cmovnsl %edi, %eax
movl %eax, %esi
andl $-0x40, %esi
movl %edi, %ecx
subl %esi, %ecx
movl $0x1, %esi
shlq %cl, %rsi
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
sarl $0x6, %eax
cltq
orq %rsi, -0xb0(%rbp,%rax,8)
leal 0x1(%r15), %edi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x85e0
testl %eax, %eax
jle 0x5ee93
movslq %r14d, %r14
movl %r15d, %edi
movq %rbx, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x8320
movq %rax, %rcx
cmpl %r14d, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovgel %ecx, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::nextdltime(int const*, int)
static gtime_t nextdltime(const int *topts, int stat)
	{
		gtime_t time;
		double tow;
		int week, tint;

		tracet(3, "nextdltime: topts=%d %d %d %d stat=%d\n", topts[0], topts[1],
			topts[2], topts[3], stat);

		/* current time (gpst) */
		time = utc2gpst(timeget());
		tow = time2gpst(time, &week);

		/* next retry time */
		if (stat == 0 && topts[3] > 0) {
			tow = (floor((tow - topts[2]) / topts[3]) + 1.0)*topts[3] + topts[2];
			return gpst2time(week, tow);
		}
		/* next interval time */
		tint = topts[1] <= 0 ? 3600 : topts[1];
		tow = (floor((tow - topts[2]) / tint) + 1.0)*tint + topts[2];
		time = gpst2time(week, tow);

		return time;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movl (%rdi), %edx
movl 0x4(%rdi), %ecx
movl 0x8(%rdi), %r8d
movl 0xc(%rdi), %r9d
movl %esi, (%rsp)
leaq 0x17e71(%rip), %rsi     # 0x7719d
movl $0x3, %edi
xorl %eax, %eax
callq 0x53ec4
callq 0x4febe
movq %rax, %rdi
callq 0x5040e
leaq -0x14(%rbp), %rsi
movq %rax, %rdi
callq 0x4fc2d
testl %r14d, %r14d
je 0x5f380
movl 0x4(%rbx), %eax
testl %eax, %eax
jle 0x5f363
cvtsi2sd %eax, %xmm1
jmp 0x5f36b
movsd 0xb555(%rip), %xmm1     # 0x6a8c0
movsd %xmm1, -0x20(%rbp)
cvtsi2sdl 0x8(%rbx), %xmm2
movsd %xmm2, -0x28(%rbp)
subsd %xmm2, %xmm0
jmp 0x5f3a1
movl 0xc(%rbx), %eax
testl %eax, %eax
jle 0x5f356
cvtsi2sdl 0x8(%rbx), %xmm1
movsd %xmm1, -0x28(%rbp)
subsd %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
movsd %xmm1, -0x20(%rbp)
divsd %xmm1, %xmm0
callq 0x8ad0
addsd 0xa56e(%rip), %xmm0     # 0x69920
mulsd -0x20(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
movl -0x14(%rbp), %edi
callq 0x4fbc6
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::waitvrsconcli(bamboo::vrscon_cli_t*, char*)
static int waitvrsconcli(vrscon_cli_t* vrscon_cli, char* msg) {
		int n;
		char *p;
		if (vrscon_cli->state < 0) return 0;
		if (vrscon_cli->tcp->svr.state < 2) vrscon_cli->state = 0; /* tcp disconnected */
		if (vrscon_cli->state == 0) { /* send request */
			if (!reqvrscon_c(vrscon_cli, msg)) return 0;
		}
		if (vrscon_cli->state == 1) { /* read response */
			p = (char*)vrscon_cli->buff + vrscon_cli->nb;
			if ((n = readtcpcli(vrscon_cli->tcp, (unsigned char *)p, sizeof(vrscon_cli->buff) - vrscon_cli->nb - 1, msg)) == 0) {
				tracet(5, "waitntrip: readtcp n=%d\n", n);
				return 0;
			}
			vrscon_cli->nb += n; vrscon_cli->buff[vrscon_cli->nb] = '\0';
			return rspvrscon_c(vrscon_cli,msg);
		}
		return 1;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
xorl %r14d, %r14d
cmpl $0x0, (%rdi)
js 0x5f44f
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x608(%rdi), %rdi
cmpl $0x1, (%rdi)
jg 0x5f3f4
movl $0x0, (%rbx)
movl $0x1, %r14d
cmpl $0x1, (%rbx)
jne 0x5f44f
movslq 0x4(%rbx), %rax
leaq (%rbx,%rax), %rsi
addq $0x208, %rsi            # imm = 0x208
movl $0x3ff, %edx            # imm = 0x3FF
subl %eax, %edx
callq 0x5a8d5
testl %eax, %eax
je 0x5f437
movslq 0x4(%rbx), %rcx
cltq
addq %rcx, %rax
movl %eax, 0x4(%rbx)
movb $0x0, 0x208(%rbx,%rax)
xorl %r14d, %r14d
jmp 0x5f44f
leaq 0x174cf(%rip), %rsi     # 0x7690d
xorl %r14d, %r14d
movl $0x5, %edi
xorl %edx, %edx
xorl %eax, %eax
callq 0x53ec4
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::waitvrsconsvr(bamboo::vrscon_svr_t*, char*)
static void waitvrsconsvr(vrscon_svr_t* vrscon_svr, char* msg) {
		/* wait for authentication */
		unsigned char *buff;
		int i, n, nmax, err;
		tracet(4, "wait_ntripc\n");
		vrscon_svr->state = vrscon_svr->tcp->svr.state;
		if (!waittcpsvr(vrscon_svr->tcp, msg)) return;
		for (i = 0; i < MAXCLI; i++) {
			if (vrscon_svr->tcp->cli[i].state != 2 || vrscon_svr->con[i].state) continue;
			/* receive ntrip-caster request */
			buff = vrscon_svr->con[i].buff + vrscon_svr->con[i].nb;
			nmax = sizeof(vrscon_svr->con[i].buff) - vrscon_svr->con[i].nb - 1;

			if ((n = recv_nb(vrscon_svr->tcp->cli[i].sock, buff, nmax)) == -1) {
				if ((err = errsock())) {
					tracet(1, "accept_ntripc: recv error sock=%d err=%d\n",
						vrscon_svr->tcp->cli[i].sock, err);
				}
				discon_vrsconsvr(vrscon_svr, i);
				continue;
			}
			if (n <= 0) continue;

			/* test ntrip-caster request */
			vrscon_svr->con[i].nb += n;
			rsp_vrscon_s(vrscon_svr,i);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1784c(%rip), %rsi     # 0x76cbb
movl $0x4, %edi
xorl %eax, %eax
callq 0x53ec4
movq 0x608(%rbx), %rdi
movl (%rdi), %eax
movl %eax, (%rbx)
movq %r14, %rsi
callq 0x5d463
testl %eax, %eax
je 0x5f555
leaq 0x618(%rbx), %r15
movl $0x240, %r12d           # imm = 0x240
leaq 0x1781e(%rip), %r14     # 0x76cc8
movq 0x608(%rbx), %rax
cmpl $0x2, -0x118(%rax,%r12)
jne 0x5f4c3
cmpl $0x0, -0x8(%r15)
je 0x5f4dc
addq $0x408, %r15            # imm = 0x408
addq $0x128, %r12            # imm = 0x128
cmpq $0x12a40, %r12          # imm = 0x12A40
jne 0x5f4aa
jmp 0x5f555
movslq -0x4(%r15), %rsi
movl $0x3ff, %edx            # imm = 0x3FF
subl %esi, %edx
addq %r15, %rsi
movl (%rax,%r12), %edi
callq 0x5d6b4
cmpl $-0x1, %eax
je 0x5f502
testl %eax, %eax
jle 0x5f4c3
addl %eax, -0x4(%r15)
jmp 0x5f4c3
callq 0x8070
movl (%rax), %ecx
testl %ecx, %ecx
je 0x5f527
movq 0x608(%rbx), %rax
movl (%rax,%r12), %edx
movl $0x1, %edi
movq %r14, %rsi
xorl %eax, %eax
callq 0x53ec4
movq 0x608(%rbx), %rax
leaq (%rax,%r12), %rdi
addq $-0x118, %rdi           # imm = 0xFEE8
movl 0x30961(%rip), %esi     # 0x8fea0
callq 0x5d761
movb $0x0, (%r15)
movq $0x0, -0x8(%r15)
jmp 0x5f4c3
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::statextcp(bamboo::tcp_t*, char*)
static int statextcp(tcp_t *tcp, char *msg)
	{
		char *p = msg;

		p += sprintf(p, "    state = %d\n", tcp->state);
		p += sprintf(p, "    saddr = %s\n", tcp->saddr);
		p += sprintf(p, "    port  = %d\n", tcp->port);
		p += sprintf(p, "    sock  = %d\n", (int)tcp->sock);
#if 0
		p += sprintf(p, "    tcon  = %d\n", tcp->tcon);
		p += sprintf(p, "    tact  = %u\n", tcp->tact);
		p += sprintf(p, "    tdis  = %u\n", tcp->tdis);
#endif
		return (int)(p - msg);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %edx
leaq 0x17f8b(%rip), %rsi     # 0x77503
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8120
movslq %eax, %r15
addq %rbx, %r15
leaq 0x4(%r14), %rdx
leaq 0x17f80(%rip), %rsi     # 0x77513
movq %r15, %rdi
xorl %eax, %eax
callq 0x8120
movslq %eax, %r12
addq %r15, %r12
movl 0x104(%r14), %edx
leaq 0x17f72(%rip), %rsi     # 0x77523
movq %r12, %rdi
xorl %eax, %eax
callq 0x8120
movslq %eax, %r15
addq %r12, %r15
movl 0x118(%r14), %edx
leaq 0x17f64(%rip), %rsi     # 0x77533
movq %r15, %rdi
xorl %eax, %eax
callq 0x8120
addl %r15d, %eax
subl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/ublox.cpp
// Function: bamboo::input_ubx(bamboo::raw_t*, unsigned char)
extern int input_ubx(raw_t *raw, unsigned char data)
{
    trace(5,"input_ubx: data=%02x\n",data);
    
    /* synchronize frame */
    if (raw->nbyte==0) {
        if (!sync_ubx(raw->buff,data)) return 0;
        raw->nbyte=2;
        return 0;
    }
    raw->buff[raw->nbyte++]=data;
    
    if (raw->nbyte==6) {
        if ((raw->len=U2(raw->buff+4)+8)>MAXRAWLEN) {
            trace(2,"ubx length error: len=%d\n",raw->len);
            raw->nbyte=0;
            return -1;
        }
    }
    if (raw->nbyte<6||raw->nbyte<raw->len) return 0;
    raw->nbyte=0;
    
    /* decode ublox raw message */
    return decode_ubx(raw);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x19431(%rip), %rsi     # 0x78a30
xorl %r14d, %r14d
movl $0x5, %edi
movl %r15d, %edx
xorl %eax, %eax
callq 0x4ded0
movslq 0x81a74(%rbx), %rax
testq %rax, %rax
je 0x5f6a3
leal 0x1(%rax), %ecx
movl %ecx, 0x81a74(%rbx)
movb %r15b, 0x81a90(%rbx,%rax)
movl 0x81a74(%rbx), %eax
cmpl $0x6, %eax
jne 0x5f67a
movzwl 0x81a94(%rbx), %ecx
leal 0x8(%rcx), %edx
movl %edx, 0x81a78(%rbx)
cmpl $0xff9, %ecx            # imm = 0xFF9
jb 0x5f67a
leaq 0x193ea(%rip), %rsi     # 0x78a46
movl $0x2, %edi
xorl %eax, %eax
callq 0x4ded0
movl $0x0, 0x81a74(%rbx)
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0x5f6cb
xorl %r14d, %r14d
cmpl $0x6, %eax
jl 0x5f6cb
cmpl 0x81a78(%rbx), %eax
jl 0x5f6cb
movl $0x0, 0x81a74(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5f6d9
movb 0x81a91(%rbx), %al
movb %al, 0x81a90(%rbx)
movb %r15b, 0x81a91(%rbx)
xorb $-0x4b, %al
xorb $0x62, %r15b
orb %al, %r15b
jne 0x5f6cb
movl $0x2, 0x81a74(%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/ublox.cpp
// Function: bamboo::input_ubxf(bamboo::raw_t*, _IO_FILE*)
extern int input_ubxf(raw_t *raw, FILE *fp)
{
    int i,data;
    
    trace(4,"input_ubxf:\n");
    
    /* synchronize frame */
    if (raw->nbyte==0) {
        for (i=0;;i++) {
            if ((data=fgetc(fp))==EOF) return -2;
            if (sync_ubx(raw->buff,(unsigned char)data)) break;
            if (i>=4096) return 0;
        }
    }
    if (fread(raw->buff+2,1,4,fp)<4) return -2;
    raw->nbyte=6;
    
    if ((raw->len=U2(raw->buff+4)+8)>MAXRAWLEN) {
        trace(2,"ubx length error: len=%d\n",raw->len);
        raw->nbyte=0;
        return -1;
    }
    if (fread(raw->buff+6,1,raw->len-6,fp)<(size_t)(raw->len-6)) return -2;
    raw->nbyte=0;
    
    /* decode ubx raw message */
    return decode_ubx(raw);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1726d(%rip), %rsi     # 0x78a60
movl $0x4, %edi
xorl %eax, %eax
callq 0x4ded0
cmpl $0x0, 0x81a74(%rbx)
je 0x6187d
leaq 0x81a92(%rbx), %rdi
movl $0x1, %esi
movl $0x4, %edx
movq %r14, %rcx
callq 0x8930
movl $0xfffffffe, %r15d      # imm = 0xFFFFFFFE
cmpq $0x4, %rax
jb 0x6190e
movl $0x6, 0x81a74(%rbx)
movzwl 0x81a94(%rbx), %edx
leal 0x8(%rdx), %eax
movl %eax, 0x81a78(%rbx)
cmpl $0xff9, %edx            # imm = 0xFF9
jb 0x618c9
leaq 0x171ec(%rip), %rsi     # 0x78a46
movl $0x2, %edi
movl %eax, %edx
xorl %eax, %eax
callq 0x4ded0
movl $0x0, 0x81a74(%rbx)
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jmp 0x6190e
movq %r14, %rdi
callq 0x89d0
movl $0xfffffffe, %r15d      # imm = 0xFFFFFFFE
cmpl $-0x1, %eax
je 0x6190e
movl $0x1001, %r12d          # imm = 0x1001
movb 0x81a91(%rbx), %cl
movb %cl, 0x81a90(%rbx)
movb %al, 0x81a91(%rbx)
xorb $-0x4b, %cl
xorb $0x62, %al
orb %cl, %al
je 0x61808
decl %r12d
je 0x6190b
movq %r14, %rdi
callq 0x89d0
cmpl $-0x1, %eax
jne 0x61896
jmp 0x6190e
leaq 0x81a96(%rbx), %rdi
addq $0x2, %rdx
movl $0x1, %esi
movq %r14, %rcx
callq 0x8930
movslq 0x81a78(%rbx), %rcx
addq $-0x6, %rcx
cmpq %rcx, %rax
jb 0x6190e
movl $0x0, 0x81a74(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5f6d9
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/ublox.cpp
// Function: bamboo::sbsdecodemsg(bamboo::gtime_t, int, unsigned int const*, bamboo::sbsmsg_t*)
extern int sbsdecodemsg(gtime_t time, int prn, const unsigned int *words,
                        sbsmsg_t *sbsmsg)
{
    int i,j;
    unsigned char f[29];
    double tow;

    trace(5,"sbsdecodemsg: prn=%d\n",prn);

    if (time.time==0) return 0;
    tow=time2gpst(time,&sbsmsg->week);
    sbsmsg->tow=(int)(tow+DTTOL);
    sbsmsg->prn=prn;
    for (i=0;i<7;i++) for (j=0;j<4;j++) {
        sbsmsg->msg[i*4+j]=(unsigned char)(words[i]>>((3-j)*8));
    }
    sbsmsg->msg[28]=(unsigned char)(words[7]>>18)&0xC0;
    for (i=28;i>0;i--) f[i]=(sbsmsg->msg[i]>>6)+(sbsmsg->msg[i-1]<<2);
    f[0]=sbsmsg->msg[0]>>6;

    return rtk_crc24q(f,29)==(words[7]&0xFFFFFF); /* check crc */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %r15d
movsd %xmm0, -0x30(%rbp)
movq %rdi, %r13
leaq 0x16f05(%rip), %rsi     # 0x78b35
xorl %r12d, %r12d
movl $0x5, %edi
movl %r15d, %edx
xorl %eax, %eax
callq 0x4ded0
testq %r13, %r13
je 0x61cfd
movq %r13, %rdi
movsd -0x30(%rbp), %xmm0
movq %r14, %rsi
callq 0x4fc2d
addsd 0x1305d(%rip), %xmm0    # 0x74cc0
cvttsd2si %xmm0, %eax
movl %eax, 0x4(%r14)
movl %r15d, 0x8(%r14)
leaq 0xc(%r14), %rax
xorl %edx, %edx
movl $0x18, %ecx
xorl %esi, %esi
movl (%rbx,%rdx,4), %edi
shrl %cl, %edi
movb %dil, (%rax,%rsi)
incq %rsi
addl $-0x8, %ecx
cmpq $0x4, %rsi
jne 0x61c7c
incq %rdx
addq $0x4, %rax
cmpq $0x7, %rdx
jne 0x61c75
movl 0x1c(%rbx), %eax
shrl $0x12, %eax
andb $-0x40, %al
movb %al, 0x28(%r14)
movl $0x28, %eax
movb -0x1(%r14,%rax), %cl
movb (%r14,%rax), %dl
shrb $0x6, %dl
shlb $0x2, %cl
orb %dl, %cl
movb %cl, -0x5c(%rbp,%rax)
leaq -0x1(%rax), %rcx
addq $-0xc, %rax
cmpq $0x1, %rax
movq %rcx, %rax
ja 0x61caf
movb 0xc(%r14), %al
shrb $0x6, %al
leaq -0x50(%rbp), %rdi
movb %al, (%rdi)
movl $0x1d, %esi
callq 0x4e4e2
movl $0xffffff, %ecx         # imm = 0xFFFFFF
andl 0x1c(%rbx), %ecx
xorl %r12d, %r12d
cmpl %ecx, %eax
sete %r12b
movl %r12d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq