LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1a642(%rip), %rsi     # 0x75e54
xorl %r14d, %r14d
movl $0x3, %edi
movq %r15, %rdx
xorl %eax, %eax
callq 0x5342c
leaq 0x30(%r12), %rbx
movq %rbx, %rdi
callq 0x8900
movl (%r12), %eax
andl $-0x2, %eax
cmpl $0xa, %eax
jne 0x5b8dd
movq 0x58(%r12), %r12
testq %r12, %r12
je 0x5b976
leaq 0x1a615(%rip), %rsi     # 0x75e6b
movq %r15, %rdi
callq 0x8770
testq %rax, %rax
je 0x5b8e8
movq %rax, %r14
movq %rbx, -0x30(%rbp)
movl $0x1000, %edi           # imm = 0x1000
callq 0x8840
xorl %ebx, %ebx
testq %rax, %rax
je 0x5b903
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 0x8920
addl %eax, %ebx
movslq %ebx, %rax
cmpq %rax, %r13
jg 0x5b917
movq %r15, %rdi
movq %r12, %rsi
callq 0x8a70
movq %r15, %rdi
movl $0x1000, %ecx           # imm = 0x1000
addq %rcx, %r13
addq %rcx, %r12
movq %rax, %r15
testq %rax, %rax
jne 0x5b896
jmp 0x5b905
movl $0x1, %r14d
jmp 0x5b976
leaq 0x1a57f(%rip), %rsi     # 0x75e6e
xorl %r14d, %r14d
movl $0x2, %edi
movq %r15, %rdx
xorl %eax, %eax
callq 0x5342c
jmp 0x5b976
xorl %edi, %edi
callq 0x87a0
movq %r14, %rdi
callq 0x8630
xorl %r14d, %r14d
jmp 0x5b972
leal 0x1(%rax), %r12d
movb $0x0, (%r15,%rax)
movq %r14, %rdi
callq 0x8630
leaq 0x1a561(%rip), %rsi     # 0x75e90
movl $0x3, %edi
movl %r12d, %edx
xorl %eax, %eax
callq 0x5342c
movq -0x38(%rbp), %rbx
leaq 0x310(%rbx), %r14
movq %r14, %rdi
callq 0x8900
movq 0x308(%rbx), %rdi
callq 0x87a0
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_O3/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 0x1a4e2(%rip), %rsi     # 0x75ea4
xorl %r14d, %r14d
movl $0x3, %edi
xorl %eax, %eax
pushq %r12
pushq %r15
pushq %r11
pushq %r10
callq 0x5342c
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, 0x344a6(%rip)     # 0x8fe9c
movl 0x4(%rbx), %eax
cmpl $0x3e9, %eax            # imm = 0x3E9
cmovgel %eax, %ecx
movl %ecx, 0x34499(%rip)     # 0x8fea0
movl 0x8(%rbx), %eax
cmpl $0x65, %eax
movl $0x64, %ecx
cmovgel %eax, %ecx
movl %ecx, 0x3447d(%rip)     # 0x8fe98
movl 0xc(%rbx), %eax
cmpl $0x1001, %eax           # imm = 0x1001
movl $0x1000, %ecx           # imm = 0x1000
cmovgel %eax, %ecx
movl %ecx, 0x34473(%rip)     # 0x8fea4
movl 0x10(%rbx), %eax
testl %eax, %eax
cmovgl %eax, %r14d
movl %r14d, 0x34467(%rip)    # 0x8fea8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1a469(%rip), %rsi     # 0x75ecc
movl $0x3, %edi
movl %r14d, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x5342c
movl (%r15), %eax
leal -0x6(%rax), %ecx
cmpl $0x2, %ecx
jae 0x5ba8d
movl $0x8510, %eax           # imm = 0x8510
addq 0x58(%r15), %rax
movq %rax, %r15
jmp 0x5ba96
cmpl $0x4, %eax
jne 0x5baa6
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_O3/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 0x5bb49
testb $0x1, 0x4(%rdi)
je 0x5bb49
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0x5bb49
movq 0x838(%rax), %rdi
movsd 0x840(%rax), %xmm0
movsd 0x870(%rax), %xmm1
jmp 0x4f4e7
pushq %rbp
movq %rsp, %rbp
callq 0x4f542
movq %rax, %rdi
popq %rbp
jmp 0x4fa70
// File: /workspace/github_cpp_makefile_star2_O3/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, %r13
movq %rdi, %rbx
movl (%rdi), %ecx
movl 0x118(%rdi), %edx
leaq 0x19cf8(%rip), %rsi     # 0x76655
xorl %r15d, %r15d
movl $0x4, %edi
xorl %eax, %eax
callq 0x5342c
cmpl $0x0, (%rbx)
jle 0x5cb5b
leaq 0x248(%rbx), %r14
leaq 0x19cf0(%rip), %rsi     # 0x76673
movq %r14, -0x40(%rbp)
movl $0x10, -0x2c(%rbp)
movl 0x118(%rbx), %edx
movl $0x4, %edi
xorl %eax, %eax
callq 0x5342c
xorl %r12d, %r12d
cmpl $0x0, -0x120(%r14)
je 0x5c9c5
incq %r12
addq $0x128, %r14            # imm = 0x128
cmpq $0x100, %r12            # imm = 0x100
jne 0x5c9a3
jmp 0x5cb46
movq %r13, -0x38(%rbp)
movl 0x118(%rbx), %r13d
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(%r13), %eax
testl %r13d, %r13d
cmovnsl %r13d, %eax
movl %eax, %edx
andl $-0x40, %edx
movl %r13d, %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(%r13), %edi
leaq -0xe0(%rbp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
leaq -0x60(%rbp), %r8
callq 0x85e0
testl %eax, %eax
jle 0x5ca5f
movl %r13d, %edi
leaq -0x50(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
callq 0x8200
movl %eax, %r15d
movq -0x38(%rbp), %r13
testl %eax, %eax
je 0x5cb46
cmpl $-0x1, %r15d
je 0x5cafd
movl %r15d, %edi
movq %r13, %rsi
callq 0x5c4d8
testl %eax, %eax
je 0x5cb46
movl %r15d, -0x8(%r14)
movups -0x50(%rbp), %xmm0
movups %xmm0, -0x18(%r14)
leaq -0x11c(%r14), %r15
movl -0x4c(%rbp), %edi
callq 0x82a0
movq %r15, %rdi
movq %rax, %rsi
callq 0x85c0
movq %r13, %rdi
movq %r15, %rsi
callq 0x85c0
movl -0x8(%r14), %edx
movl $0x3, %edi
leaq 0x19bf0(%rip), %rsi     # 0x766bd
movq %r15, %rcx
movl %r12d, %r8d
xorl %eax, %eax
callq 0x5342c
movl $0x2, -0x120(%r14)
callq 0x4fece
movl %eax, (%r14)
movq -0x40(%rbp), %r14
leaq 0x19b7b(%rip), %rsi     # 0x76673
jmp 0x5c987
callq 0x8070
movl (%rax), %r15d
leaq 0x19b79(%rip), %rsi     # 0x76685
movq %r13, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x8120
movl 0x118(%rbx), %edx
leaq 0x19b71(%rip), %rsi     # 0x76697
movl $0x1, %edi
movl %r15d, %ecx
xorl %eax, %eax
callq 0x5342c
movl 0x118(%rbx), %edi
callq 0x8c40
movl $0x0, (%rbx)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x5cc6f
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_O3/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 0x19ab0(%rip), %rsi     # 0x766e6
movl $0x3, %edi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x5342c
movl 0x118(%r14), %edi
callq 0x8c40
movl $0x0, (%r14)
movl %ebx, 0x11c(%r14)
callq 0x4fece
movl %eax, 0x124(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x19a59(%rip), %rsi     # 0x76702
movl $0x4, %edi
xorl %eax, %eax
callq 0x5342c
cmpl $0x0, (%r15)
je 0x5cd53
movq %rbx, -0x30(%rbp)
leaq 0x12c(%r15), %r13
leaq -0x130(%rbp), %r12
xorl %ebx, %ebx
cmpl $0x0, 0x128(%r15,%rbx)
je 0x5cced
leaq (%rbx,%r13), %rsi
movq %r12, %rdi
callq 0x85c0
incl %r14d
addq $0x128, %rbx            # imm = 0x128
cmpq $0x12800, %rbx          # imm = 0x12800
jne 0x5ccd3
testl %r14d, %r14d
je 0x5cd21
movl $0x2, (%r15)
cmpl $0x1, %r14d
movq -0x30(%rbp), %rdi
jne 0x5cd42
leaq -0x130(%rbp), %rsi
callq 0x85c0
jmp 0x5cd53
movl $0x1, (%r15)
movabsq $0x2e676e6974696177, %rax # imm = 0x2E676E6974696177
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
movl $0x2e2e2e, 0x7(%rcx)    # imm = 0x2E2E2E
jmp 0x5cd53
leaq 0x199dc(%rip), %rsi     # 0x76725
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_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x19282(%rip), %rsi     # 0x76a02
xorl %r12d, %r12d
movl $0x4, %edi
xorl %eax, %eax
callq 0x5342c
movq %rbx, %rdx
testl %r14d, %r14d
jle 0x5d874
xorl %r12d, %r12d
movl $0x1, %edi
leaq 0x19e56(%rip), %rax     # 0x77600
xorl %ecx, %ecx
movq %r12, %rbx
movl %edi, %r13d
xorl %esi, %esi
xorl %r10d, %r10d
leal (%rcx,%rsi), %edi
addl %r10d, %r10d
leal (%rcx,%rsi), %r8d
addl $0x7, %r8d
testl %edi, %edi
cmovnsl %edi, %r8d
movl %r8d, %r9d
sarl $0x3, %r9d
cmpl %r14d, %r9d
jge 0x5d7fe
andl $-0x8, %r8d
subl %r8d, %edi
movslq %r9d, %r8
movzbl (%r15,%r8), %r8d
movb $0x7, %r9b
subb %dil, %r9b
movzbl %r9b, %edi
xorl %r9d, %r9d
btl %edi, %r8d
setb %r9b
orl %r9d, %r10d
incl %esi
cmpl $0x6, %esi
jne 0x5d7b7
leal 0x6(%rcx), %esi
movslq %r10d, %rdi
movb (%rdi,%rax), %dil
leaq 0x1(%rbx), %r12
movb %dil, (%rdx,%rbx)
addl $0xd, %ecx
testl %esi, %esi
cmovnsl %esi, %ecx
sarl $0x3, %ecx
leal 0x1(%r13), %edi
cmpl %r14d, %ecx
movl %esi, %ecx
jl 0x5d7ac
testb $0x3, %r12b
je 0x5d874
movl %r12d, %edi
movq %rdx, %r14
addq %rdx, %rdi
andl $0x3, %r12d
movl $0x4, %edx
subq %r12, %rdx
movl $0x3d, %esi
callq 0x8390
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
subl %ebx, %eax
andl $0x3, %eax
leal (%rbx,%rax), %r12d
addl $0x2, %r12d
incl %r13d
testb $0x3, %r13b
jne 0x5d868
movq %r14, %rdx
movl %r12d, %eax
movb $0x0, (%rdx,%rax)
leaq 0x19191(%rip), %rsi     # 0x76a13
movl $0x5, %edi
xorl %eax, %eax
callq 0x5342c
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x18dbd(%rip), %rsi     # 0x76f2b
xorl %r15d, %r15d
movl $0x3, %edi
movl %ebx, %edx
xorl %eax, %eax
callq 0x5342c
movslq %ebx, %rbx
imulq $0x128, %rbx, %rdi      # imm = 0x128
addq 0x338(%r14), %rdi
addq $0x128, %rdi            # imm = 0x128
movl 0x31d03(%rip), %esi     # 0x8fea0
callq 0x5cc1d
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_O3/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), %r12
movq %r12, %rdi
callq 0x8900
movq 0x308(%rbx), %rdi
testq %rdi, %rdi
je 0x5e26c
leaq 0x18ba0(%rip), %rsi     # 0x76da9
callq 0x8160
testq %rax, %rax
je 0x5e27b
movq %rax, %r15
movq %r12, -0x30(%rbp)
leaq 0x18b8d(%rip), %r12     # 0x76dae
leaq -0x130(%rbp), %r13
leaq 0x18b7a(%rip), %rbx     # 0x76da9
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x8610
testl %eax, %eax
je 0x5e252
movq %r13, %rdi
movq %r14, %rsi
callq 0x8880
testl %eax, %eax
je 0x5e27f
incq %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8160
movq %rax, %r15
testq %rax, %rax
jne 0x5e22f
xorl %ebx, %ebx
jmp 0x5e284
movq %r12, %rdi
callq 0x84b0
movl $0x1, %ebx
jmp 0x5e290
xorl %ebx, %ebx
jmp 0x5e288
movl $0x1, %ebx
movq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0x84b0
movl %ebx, %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_O3/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 0x18931(%rip), %rsi     # 0x77122
movl $0x3, %edi
xorl %eax, %eax
callq 0x5342c
callq 0x4f542
movq %rax, %rdi
callq 0x4fa70
leaq -0x14(%rbp), %rsi
movq %rax, %rdi
callq 0x4f2b1
testl %r14d, %r14d
je 0x5e845
movl 0x4(%rbx), %eax
testl %eax, %eax
jle 0x5e828
cvtsi2sd %eax, %xmm1
jmp 0x5e830
movsd 0xc090(%rip), %xmm1     # 0x6a8c0
movsd %xmm1, -0x20(%rbp)
cvtsi2sdl 0x8(%rbx), %xmm2
movsd %xmm2, -0x28(%rbp)
subsd %xmm2, %xmm0
jmp 0x5e866
movl 0xc(%rbx), %eax
testl %eax, %eax
jle 0x5e81b
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 0x8ac0
addsd 0xb0a9(%rip), %xmm0     # 0x69920
mulsd -0x20(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
movl -0x14(%rbp), %edi
callq 0x4f24a
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl (%rdi), %eax
xorl %r14d, %r14d
testl %eax, %eax
js 0x5e91d
movq %rdi, %rbx
movq 0x608(%rdi), %rdi
cmpl $0x1, (%rdi)
jg 0x5e8bf
movl $0x0, (%rbx)
movl $0x1, %r14d
jmp 0x5e91d
movl $0x1, %r14d
cmpl $0x1, %eax
jne 0x5e91d
movq %rsi, %rcx
movslq 0x4(%rbx), %rax
leaq (%rbx,%rax), %rsi
addq $0x208, %rsi            # imm = 0x208
movl $0x3ff, %edx            # imm = 0x3FF
subl %eax, %edx
callq 0x59cb7
testl %eax, %eax
je 0x5e905
movslq 0x4(%rbx), %rcx
cltq
addq %rcx, %rax
movl %eax, 0x4(%rbx)
movb $0x0, 0x208(%rbx,%rax)
xorl %r14d, %r14d
jmp 0x5e91d
leaq 0x17f86(%rip), %rsi     # 0x76892
xorl %r14d, %r14d
movl $0x5, %edi
xorl %edx, %edx
xorl %eax, %eax
callq 0x5342c
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18300(%rip), %rsi     # 0x76c40
movl $0x4, %edi
xorl %eax, %eax
callq 0x5342c
movq 0x608(%rbx), %rdi
movl (%rdi), %eax
movl %eax, (%rbx)
movq %r14, %rsi
callq 0x5c934
testl %eax, %eax
je 0x5ea2b
leaq 0x618(%rbx), %r15
movl $0x240, %r12d           # imm = 0x240
leaq 0x182d2(%rip), %r14     # 0x76c4d
movq 0x608(%rbx), %rax
cmpl $0x2, -0x118(%rax,%r12)
jne 0x5e994
cmpl $0x0, -0x8(%r15)
je 0x5e9ad
addq $0x408, %r15            # imm = 0x408
addq $0x128, %r12            # imm = 0x128
cmpq $0x12a40, %r12          # imm = 0x12A40
jne 0x5e97b
jmp 0x5ea2b
movslq -0x4(%r15), %rsi
movl $0x3ff, %edx            # imm = 0x3FF
subl %esi, %edx
addq %r15, %rsi
movl (%rax,%r12), %edi
callq 0x5cb70
cmpl $-0x1, %eax
je 0x5e9d3
testl %eax, %eax
jle 0x5e994
addl %eax, -0x4(%r15)
jmp 0x5e994
callq 0x8070
movl (%rax), %ecx
testl %ecx, %ecx
je 0x5e9f8
movq 0x608(%rbx), %rax
movl (%rax,%r12), %edx
movl $0x1, %edi
movq %r14, %rsi
xorl %eax, %eax
callq 0x5342c
leaq -0x8(%r15), %r13
movq 0x608(%rbx), %rax
leaq (%rax,%r12), %rdi
addq $-0x118, %rdi           # imm = 0xFEE8
movl 0x3148c(%rip), %esi     # 0x8fea0
callq 0x5cc1d
movb $0x0, 0x8(%r13)
movq $0x0, (%r13)
jmp 0x5e994
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x18a34(%rip), %rsi     # 0x77488
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8120
movslq %eax, %r15
addq %rbx, %r15
leaq 0x4(%r14), %rdx
leaq 0x18a29(%rip), %rsi     # 0x77498
movq %r15, %rdi
xorl %eax, %eax
callq 0x8120
movslq %eax, %r12
addq %r15, %r12
movl 0x104(%r14), %edx
leaq 0x18a1b(%rip), %rsi     # 0x774a8
movq %r12, %rdi
xorl %eax, %eax
callq 0x8120
movslq %eax, %r15
addq %r12, %r15
movl 0x118(%r14), %edx
leaq 0x18a0d(%rip), %rsi     # 0x774b8
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_O3/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 0x19f2d(%rip), %rsi     # 0x78a08
xorl %r14d, %r14d
movl $0x5, %edi
movl %r15d, %edx
xorl %eax, %eax
callq 0x4d55d
movslq 0x81a74(%rbx), %rax
testq %rax, %rax
je 0x5eb52
leal 0x1(%rax), %ecx
movl %ecx, 0x81a74(%rbx)
movb %r15b, 0x81a90(%rbx,%rax)
movl 0x81a74(%rbx), %eax
cmpl $0x6, %eax
jne 0x5eb7c
movzwl 0x81a94(%rbx), %ecx
leal 0x8(%rcx), %edx
movl %edx, 0x81a78(%rbx)
cmpl $0xff9, %ecx            # imm = 0xFF9
jb 0x5eb84
leaq 0x19eea(%rip), %rsi     # 0x78a1e
movl $0x2, %edi
xorl %eax, %eax
callq 0x4d55d
movl $0x0, 0x81a74(%rbx)
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0x5eb8b
movb 0x81a91(%rbx), %al
movb %al, 0x81a90(%rbx)
movb %r15b, 0x81a91(%rbx)
xorb $-0x4b, %al
xorb $0x62, %r15b
orb %al, %r15b
jne 0x5eb8b
movl $0x2, 0x81a74(%rbx)
jmp 0x5eb8b
jl 0x5eb88
movl 0x81a78(%rbx), %edx
cmpl %edx, %eax
jge 0x5eb99
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x0, 0x81a74(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5ebb2
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17e51(%rip), %rsi     # 0x78a38
movl $0x4, %edi
xorl %eax, %eax
callq 0x4d55d
cmpl $0x0, 0x81a74(%rbx)
je 0x60c71
leaq 0x81a92(%rbx), %rdi
movl $0x1, %esi
movl $0x4, %edx
movq %r14, %rcx
callq 0x8920
movl $0xfffffffe, %r15d      # imm = 0xFFFFFFFE
cmpq $0x4, %rax
jb 0x60d02
movl $0x6, 0x81a74(%rbx)
movzwl 0x81a94(%rbx), %edx
leal 0x8(%rdx), %eax
movl %eax, 0x81a78(%rbx)
cmpl $0xff9, %edx            # imm = 0xFF9
jb 0x60cbd
leaq 0x17dd0(%rip), %rsi     # 0x78a1e
movl $0x2, %edi
movl %eax, %edx
xorl %eax, %eax
callq 0x4d55d
movl $0x0, 0x81a74(%rbx)
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jmp 0x60d02
movq %r14, %rdi
callq 0x89c0
movl $0xfffffffe, %r15d      # imm = 0xFFFFFFFE
cmpl $-0x1, %eax
je 0x60d02
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 0x60bfc
decl %r12d
je 0x60cff
movq %r14, %rdi
callq 0x89c0
cmpl $-0x1, %eax
jne 0x60c8a
jmp 0x60d02
leaq 0x81a96(%rbx), %rdi
addq $0x2, %rdx
movl $0x1, %esi
movq %r14, %rcx
callq 0x8920
movslq 0x81a78(%rbx), %rcx
addq $-0x6, %rcx
cmpq %rcx, %rax
jb 0x60d02
movl $0x0, 0x81a74(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5ebb2
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17b1c(%rip), %rsi     # 0x78b0d
xorl %r12d, %r12d
movl $0x5, %edi
movl %r15d, %edx
xorl %eax, %eax
callq 0x4d55d
testq %r13, %r13
je 0x610c4
movq %r13, %rdi
movsd -0x30(%rbp), %xmm0
movq %r14, %rsi
callq 0x4f2b1
addsd 0x13c7c(%rip), %xmm0    # 0x74ca0
cvttsd2si %xmm0, %eax
movl %eax, 0x4(%r14)
movl %r15d, 0x8(%r14)
leaq 0xc(%r14), %rax
xorl %edx, %edx
movq %rax, %rsi
movl $0x18, %ecx
xorl %edi, %edi
movl (%rbx,%rdx,4), %r8d
shrl %cl, %r8d
movb %r8b, (%rsi,%rdi)
incq %rdi
addl $-0x8, %ecx
cmpq $0x4, %rdi
jne 0x61040
incq %rdx
addq $0x4, %rsi
cmpq $0x7, %rdx
jne 0x61039
movl 0x1c(%rbx), %ecx
shrl $0x12, %ecx
andb $-0x40, %cl
movb %cl, 0x28(%r14)
movl $0x27, %edx
movb (%r14,%rdx), %sil
leal (,%rsi,4), %edi
shrb $0x6, %cl
orb %dil, %cl
movb %cl, -0x5b(%rbp,%rdx)
leaq -0x1(%rdx), %rdi
addq $-0xb, %rdx
movl %esi, %ecx
cmpq $0x1, %rdx
movq %rdi, %rdx
ja 0x61076
movb (%rax), %al
shrb $0x6, %al
leaq -0x50(%rbp), %rdi
movb %al, (%rdi)
movl $0x1d, %esi
callq 0x4db73
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
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/ublox.cpp
// Function: bamboo::decode_ephem(int, bamboo::raw_t*)
static int decode_ephem(int sat, raw_t *raw)
{
    eph_t eph={0};
    
    trace(4,"decode_ephem: sat=%2d\n",sat);
    
    if (decode_frame(raw->subfrm[sat-1]   ,&eph,NULL,NULL,NULL,NULL)!=1||
        decode_frame(raw->subfrm[sat-1]+30,&eph,NULL,NULL,NULL,NULL)!=2||
        decode_frame(raw->subfrm[sat-1]+60,&eph,NULL,NULL,NULL,NULL)!=3) return 0;
    
    if (!strstr(raw->opt,"-EPHALL")) {
        if (eph.iode==raw->nav.eph[sat-1].iode&&
            eph.iodc==raw->nav.eph[sat-1].iodc) return 0; /* unchanged */
    }
    eph.sat=sat;
    raw->nav.eph[sat-1]=eph;
    raw->ephsat=sat;
    return 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rsi, %r12
movl %edi, %r14d
leaq -0x150(%rbp), %r13
xorl %r15d, %r15d
movl $0x120, %edx            # imm = 0x120
movq %r13, %rdi
xorl %esi, %esi
callq 0x8390
leaq 0x147dc(%rip), %rsi     # 0x758ec
movl $0x4, %edi
movl %r14d, %edx
xorl %eax, %eax
callq 0x4d55d
leal -0x1(%r14), %eax
movslq %eax, %rbx
imulq $0x17c, %rbx, %rax      # imm = 0x17C
movq %r12, -0x30(%rbp)
addq %rax, %r12
addq $0x70f70, %r12          # imm = 0x70F70
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x35822
cmpl $0x1, %eax
jne 0x61229
leaq 0x1e(%r12), %rdi
xorl %r15d, %r15d
leaq -0x150(%rbp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x35822
cmpl $0x2, %eax
jne 0x61229
addq $0x3c, %r12
xorl %r15d, %r15d
leaq -0x150(%rbp), %rsi
movq %r12, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x35822
cmpl $0x3, %eax
jne 0x61229
movq -0x30(%rbp), %r12
leaq 0x82a90(%r12), %rdi
leaq 0xb50b(%rip), %rsi      # 0x6c6c7
callq 0x8160
leaq (%rbx,%rbx,8), %rdi
testq %rax, %rax
je 0x611d4
movq 0x1d80(%r12), %rax
jmp 0x611fd
movl -0x14c(%rbp), %edx
movq 0x1d80(%r12), %rax
movq %rdi, %rcx
shlq $0x5, %rcx
cmpl 0x4(%rax,%rcx), %edx
jne 0x611fd
addq %rax, %rcx
movl -0x148(%rbp), %edx
cmpl 0x8(%rcx), %edx
je 0x61229
leaq -0x150(%rbp), %rsi
movl %r14d, (%rsi)
shlq $0x5, %rdi
addq %rax, %rdi
movl $0x120, %edx            # imm = 0x120
callq 0x84f0
movq -0x30(%rbp), %rax
movl %r14d, 0x70e40(%rax)
movl $0x2, %r15d
movl %r15d, %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/ublox.cpp
// Function: bamboo::decode_alm1(int, bamboo::raw_t*)
static int decode_alm1(int sat, raw_t *raw)
{
    int sys=satsys(sat,NULL);
    
    trace(4,"decode_alm1 : sat=%2d\n",sat);
    
    if (sys==SYS_GPS) {
        decode_frame(raw->subfrm[sat-1]+90,NULL,raw->nav.alm,raw->nav.ion_gps,
                     raw->nav.utc_gps,&raw->nav.leaps);
        adj_utcweek(raw->time,raw->nav.utc_gps);
    }
    else if (sys==SYS_QZS) {
        decode_frame(raw->subfrm[sat-1]+90,NULL,raw->nav.alm,raw->nav.ion_qzs,
                     raw->nav.utc_qzs,&raw->nav.leaps);
        adj_utcweek(raw->time,raw->nav.utc_qzs);
    }
    return 9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
xorl %esi, %esi
callq 0x4d2f2
movl %eax, %r15d
leaq 0x146a4(%rip), %rsi     # 0x75903
movl $0x4, %edi
movl %r14d, %edx
xorl %eax, %eax
callq 0x4d55d
cmpl $0x1, %r15d
je 0x61287
cmpl $0x10, %r15d
jne 0x612e2
movl $0x1e30, %r15d          # imm = 0x1E30
movl $0x1f10, %ecx           # imm = 0x1F10
jmp 0x61292
movl $0x1dd0, %r15d          # imm = 0x1DD0
movl $0x1eb0, %ecx           # imm = 0x1EB0
decl %r14d
movslq %r14d, %rax
imulq $0x17c, %rax, %rax      # imm = 0x17C
leaq (%rbx,%rax), %rdi
addq $0x70fca, %rdi          # imm = 0x70FCA
movq 0x1da8(%rbx), %rdx
addq %rbx, %rcx
addq %rbx, %r15
leaq 0x1fd0(%rbx), %r9
xorl %esi, %esi
movq %r15, %r8
callq 0x35822
movq (%rbx), %rdi
movsd 0x8(%rbx), %xmm0
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x613c5
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/ublox.cpp
// Function: bamboo::decode_alm2(int, bamboo::raw_t*)
static int decode_alm2(int sat, raw_t *raw)
{
    int sys=satsys(sat,NULL);
    
    trace(4,"decode_alm2 : sat=%2d\n",sat);
    
    if (sys==SYS_GPS) {
        decode_frame(raw->subfrm[sat-1]+120,NULL,raw->nav.alm,NULL,NULL,NULL);
    }
    else if (sys==SYS_QZS) {
        decode_frame(raw->subfrm[sat-1]+120,NULL,raw->nav.alm,raw->nav.ion_qzs,
                     raw->nav.utc_qzs,&raw->nav.leaps);
        adj_utcweek(raw->time,raw->nav.utc_qzs);
    }
    return  0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
xorl %esi, %esi
callq 0x4d2f2
movl %eax, %r15d
leaq 0x1460c(%rip), %rsi     # 0x7591a
movl $0x4, %edi
movl %r14d, %edx
xorl %eax, %eax
callq 0x4d55d
cmpl $0x10, %r15d
je 0x61365
cmpl $0x1, %r15d
jne 0x613ba
decl %r14d
movslq %r14d, %rax
imulq $0x17c, %rax, %rax      # imm = 0x17C
leaq (%rbx,%rax), %rdi
addq $0x70fe8, %rdi          # imm = 0x70FE8
movq 0x1da8(%rbx), %rdx
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x35822
decl %r14d
movslq %r14d, %rax
imulq $0x17c, %rax, %rax      # imm = 0x17C
leaq (%rbx,%rax), %rdi
addq $0x70fe8, %rdi          # imm = 0x70FE8
movq 0x1da8(%rbx), %rdx
leaq 0x1f10(%rbx), %rcx
leaq 0x1e30(%rbx), %r14
leaq 0x1fd0(%rbx), %r9
xorl %esi, %esi
movq %r14, %r8
callq 0x35822
movq (%rbx), %rdi
movsd 0x8(%rbx), %xmm0
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x613c5
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/ublox.cpp
// Function: bamboo::decode_nav(bamboo::raw_t*, int, int)
static int decode_nav(raw_t *raw, int sat, int off)
{
    unsigned int words[10];
    int i,id;
    unsigned char *p=raw->buff+6+off;
    
    if (raw->len<48+off) {
        trace(2,"ubx rawsfrbx length error: sat=%d len=%d\n",sat,raw->len);
        return -1;
    }
    if ((U4(p)>>24)==PREAMB_CNAV) {
        trace(3,"ubx rawsfrbx cnav not supported sat=%d prn=%d\n",sat,
              (U4(p)>>18)&0x3F);
        return 0;
    }
    for (i=0;i<10;i++,p+=4) words[i]=U4(p)>>6; /* 24 bits without parity */
    
    id=(words[1]>>2)&7;
    if (id<1||5<id) {
        trace(2,"ubx rawsfrbx subfrm id error: sat=%2d id=%d len=%d\n",sat,id,
              raw->len);
        return -1;
    }
    for (i=0;i<10;i++) {
        setbitu(raw->subfrm[sat-1]+(id-1)*30,i*24,24,words[i]);
    }
    if (id==3) return decode_ephem(sat,raw);
    if (id==4) return decode_alm1 (sat,raw);
    if (id==5) return decode_alm2 (sat,raw);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %r9d
movl 0x81a78(%rdi), %r8d
leal 0x30(%rdx), %eax
cmpl %eax, %r8d
jge 0x6149b
leaq 0x17a3a(%rip), %rsi     # 0x78ebb
movl $0x2, %edi
movl %r9d, %edx
movl %r8d, %ecx
xorl %eax, %eax
callq 0x4d55d
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
jmp 0x614d6
movq %rdi, %r14
movl %edx, %eax
movl 0x81a96(%rdi,%rax), %ecx
movl %ecx, %edx
andl $0xff000000, %edx       # imm = 0xFF000000
cmpl $0x8b000000, %edx       # imm = 0x8B000000
jne 0x614e8
shrl $0x12, %ecx
andl $0x3f, %ecx
leaq 0x17a21(%rip), %rsi     # 0x78ee5
xorl %r12d, %r12d
movl $0x3, %edi
movl %r9d, %edx
xorl %eax, %eax
callq 0x4d55d
movl %r12d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq %r14, %rax
addq $0x81a96, %rax          # imm = 0x81A96
xorl %ecx, %ecx
movl (%rax,%rcx,4), %edx
shrl $0x6, %edx
movl %edx, -0x60(%rbp,%rcx,4)
incq %rcx
cmpq $0xa, %rcx
jne 0x614f3
movl -0x5c(%rbp), %r15d
shrl $0x2, %r15d
andl $0x7, %r15d
leal -0x6(%r15), %eax
cmpl $-0x5, %eax
jae 0x61539
leaq 0x179f2(%rip), %rsi     # 0x78f14
movl $0x2, %edi
movl %r9d, %edx
movl %r15d, %ecx
xorl %eax, %eax
callq 0x4d55d
jmp 0x61493
movq %r9, -0x30(%rbp)
leal -0x1(%r9), %eax
cltq
imulq $0x17c, %rax, %rax      # imm = 0x17C
addq %r14, %rax
movl %r15d, %edx
shll $0x5, %edx
subq %r15, %rdx
subq %r15, %rdx
leaq (%rdx,%rax), %r12
addq $0x70f52, %r12          # imm = 0x70F52
leaq -0x60(%rbp), %rbx
xorl %r13d, %r13d
movl (%rbx), %ecx
movq %r12, %rdi
movl %r13d, %esi
movl $0x18, %edx
callq 0x4da98
addq $0x18, %r13
addq $0x4, %rbx
cmpq $0xf0, %r13
jne 0x6156b
xorl %r12d, %r12d
cmpl $0x5, %r15d
je 0x615d4
cmpl $0x4, %r15d
movq -0x30(%rbp), %rdi
je 0x615c1
cmpl $0x3, %r15d
jne 0x614d6
movq %r14, %rsi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x610d6
movq %r14, %rsi
callq 0x6123e
movl $0x9, %r12d
jmp 0x614d6
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x612ed
jmp 0x614d6
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/ublox.cpp
// Function: bamboo::decode_snav(bamboo::raw_t*, int, int)
static int decode_snav(raw_t *raw, int sat, int off)
{
    int i,j,k,prn,tow,week;
    unsigned char *p=raw->buff+6+off,buff[64];
    
    if (raw->len<40+off) {
        trace(2,"ubx rawsfrbx snav length error: len=%d\n",raw->len);
        return -1;
    }
    tow=(int)time2gpst(timeadd(raw->time,-1.0),&week);
    satsys(sat,&prn);
    raw->sbsmsg.prn=prn;
    raw->sbsmsg.tow=tow;
    raw->sbsmsg.week=week;
    for (i=k=0;i<8;i++,p+=4) for (j=0;j<4;j++) {
        buff[k++]=p[3-j];
    }
    memcpy(raw->sbsmsg.msg,buff,29);
    raw->sbsmsg.msg[28]&=0xC0;
    return 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, %eax
movl 0x81a78(%rdi), %edx
leal 0x28(%rax), %ecx
cmpl %ecx, %edx
jge 0x61f4e
leaq 0x17166(%rip), %rsi     # 0x7909e
movl $0x2, %edi
xorl %eax, %eax
callq 0x4d55d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x62004
movl %esi, %r14d
movq %rdi, %rbx
movl %eax, %eax
movq %rax, -0x30(%rbp)
movq (%rdi), %rdi
movsd 0x8(%rbx), %xmm0
movsd 0x8a46(%rip), %xmm1     # 0x6a9b0
callq 0x4f4e7
leaq -0x34(%rbp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4f2b1
cvttsd2si %xmm0, %r13d
leaq -0x38(%rbp), %r12
movl %r14d, %edi
movq %r12, %rsi
callq 0x4d2f2
movl (%r12), %eax
movl %eax, 0x70e4c(%rbx)
movl %r13d, 0x70e48(%rbx)
movl (%r15), %eax
movl %eax, 0x70e44(%rbx)
movq -0x30(%rbp), %rax
addq %rbx, %rax
addq $0x81a99, %rax          # imm = 0x81A99
xorl %ecx, %ecx
xorl %edx, %edx
movslq %edx, %rdx
xorl %esi, %esi
movb (%rax,%rsi), %dil
movb %dil, -0x80(%rbp,%rdx)
incq %rdx
decq %rsi
cmpq $-0x4, %rsi
jne 0x61fc2
incl %ecx
addq $0x4, %rax
cmpl $0x8, %ecx
jne 0x61fbd
movups -0x73(%rbp), %xmm0
movups %xmm0, 0x70e5d(%rbx)
movaps -0x80(%rbp), %xmm0
movups %xmm0, 0x70e50(%rbx)
andb $-0x40, 0x70e6c(%rbx)
movl $0x3, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/VrsObs/VrsNtripClient.cpp
// Function: bamboo::VrsNtripClient::openStream()
void VrsNtripClient::openStream() {
	lcont = true;
	configs_sav = Deploy::s_getConfigures();
	time(&lastCheck);
	def_thread_t pid_handle;
#ifdef _WIN32
	CreateThread(NULL, 0, s_pthVrsStream_win, this, 0, NULL);
#else
	if (0 != pthread_create(&pid_handle, NULL, &s_pthVrsStream, this)) {
		cout
			<< "***ERROR(s_VRSMain):cant create thread to handle request!"
			<< endl;
		exit(1);
	}
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2048, %rsp           # imm = 0x2048
movq %rdi, %rbx
movb $0x1, (%rdi)
leaq -0x2068(%rbp), %r14
movq %r14, %rdi
callq 0x2aa68
leaq 0x10(%rbx), %r15
movl $0x6b0, %edx            # imm = 0x6B0
movq %r15, %rdi
movq %r14, %rsi
callq 0x84f0
leaq 0x6c0(%rbx), %r12
movl $0xaa, %r14d
leaq -0x19b8(%rbp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x8380
addq $0x20, %r13
addq $0x20, %r12
decq %r14
jne 0x620d3
movq -0x478(%rbp), %rax
movq %rax, 0x1c00(%rbx)
leaq -0x2068(%rbp), %rax
cmpq %rax, %r15
je 0x6211b
leaq -0x470(%rbp), %rdx
leaq 0x1c08(%rbx), %rdi
movq (%rdx), %rsi
callq 0x27caa
leaq 0x1c20(%rbx), %rdi
leaq -0x458(%rbp), %rsi
callq 0x27ef2
leaq 0x1c50(%rbx), %rdi
leaq -0x428(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x84f0
leaq -0x2068(%rbp), %rdi
callq 0x2aa1a
leaq 0x8(%rbx), %rdi
callq 0x85b0
leaq 0x66(%rip), %rdx        # 0x621c8
leaq -0x2068(%rbp), %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x8bb0
testl %eax, %eax
jne 0x62189
addq $0x2048, %rsp           # imm = 0x2048
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2be40(%rip), %rdi     # 0x8dfd0
leaq 0x98aa(%rip), %rsi      # 0x6ba41
callq 0x8620
movq %rax, %rdi
callq 0x8300
movl $0x1, %edi
callq 0x87b0
jmp 0x621b0
movq %rax, %rbx
leaq -0x2068(%rbp), %rdi
callq 0x2aa1a
movq %rbx, %rdi
callq 0x8b30
nop
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/VrsObs/VrsNtripClient.cpp
// Function: bamboo::VrsNtripClient::openStream(std::__cxx11::list<bamboo::RtConverter*, std::allocator<bamboo::RtConverter*>>)
void VrsNtripClient::openStream(list<RtConverter*> svrs_in) {
	lcont = true;
	configs_sav = Deploy::s_getConfigures();
	time(&lastCheck);
	def_thread_t pid_handle;
#ifdef _WIN32
	CreateThread(NULL, 0, s_pthVrsStream_win, this, 0, NULL);
#else
	if (0 != pthread_create(&pid_handle, NULL, &s_pthVrsStream, this)) {
		cout
			<< "***ERROR(s_VRSMain):cant create thread to handle request!"
			<< endl;
		exit(1);
	}
#endif
	this->m_svrs = svrs_in;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2048, %rsp           # imm = 0x2048
movq %rsi, -0x30(%rbp)
movq %rdi, %r14
movb $0x1, (%rdi)
leaq -0x2070(%rbp), %rbx
movq %rbx, %rdi
callq 0x2aa68
leaq 0x10(%r14), %r12
movl $0x6b0, %edx            # imm = 0x6B0
movq %r12, %rdi
movq %rbx, %rsi
callq 0x84f0
leaq 0x6c0(%r14), %r13
movl $0xaa, %r15d
leaq -0x19c0(%rbp), %rbx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x8380
addq $0x20, %rbx
addq $0x20, %r13
decq %r15
jne 0x6222b
movq -0x480(%rbp), %rax
movq %rax, 0x1c00(%r14)
leaq -0x2070(%rbp), %rax
cmpq %rax, %r12
je 0x62273
leaq -0x478(%rbp), %rdx
leaq 0x1c08(%r14), %rdi
movq (%rdx), %rsi
callq 0x27caa
leaq 0x1c20(%r14), %rdi
leaq -0x460(%rbp), %rsi
callq 0x27ef2
leaq 0x1c50(%r14), %rdi
leaq -0x430(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x84f0
leaq -0x2070(%rbp), %rdi
callq 0x2aa1a
leaq 0x8(%r14), %rdi
callq 0x85b0
leaq -0xf2(%rip), %rdx       # 0x621c8
leaq -0x2070(%rbp), %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0x8bb0
testl %eax, %eax
jne 0x622fc
addq $0x2050, %r14           # imm = 0x2050
movq -0x30(%rbp), %rdx
cmpq %rdx, %r14
je 0x622ea
movq (%rdx), %rsi
movq %r14, %rdi
callq 0x289e4
addq $0x2048, %rsp           # imm = 0x2048
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2bccd(%rip), %rdi     # 0x8dfd0
leaq 0x9737(%rip), %rsi      # 0x6ba41
callq 0x8620
movq %rax, %rdi
callq 0x8300
movl $0x1, %edi
callq 0x87b0
jmp 0x62323
movq %rax, %rbx
leaq -0x2070(%rbp), %rdi
callq 0x2aa1a
movq %rbx, %rdi
callq 0x8b30
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/VrsObs/VrsNtripClient.cpp
// Function: bamboo::VrsNtripClient::m_newConnection(bamboo::VrsStaItem&)
void VrsNtripClient::m_newConnection(VrsStaItem& item) {
	stream_t* str_m;
	rtcm_t* rtcm_m;
	str_m = (stream_t*)calloc(1, sizeof(stream_t));
	strinit(str_m);
	rtcm_m = (rtcm_t*)calloc(1, sizeof(rtcm_t));
	init_rtcm(rtcm_m);
	stropen(str_m, STR_NTRIPCLI, STR_MODE_RW, item.strpath.c_str());
	strsettimeout(str_m, 60000, 10000); /// 60s for timeout 10s for reconnect
	m_streams[item.staname] = str_m;
	m_rtcms[item.staname] = rtcm_m;
	m_stas[item.staname] = item;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x860, %esi            # imm = 0x860
callq 0x8440
movq %rax, %r12
movq %rax, %rdi
callq 0x57d6e
movl $0x1, %edi
movl $0x9fe48, %esi          # imm = 0x9FE48
callq 0x8440
movq %rax, %r13
movq %rax, %rdi
callq 0x3899c
leaq 0x40(%rbx), %rax
movq %rax, -0x30(%rbp)
movq 0x40(%rbx), %rcx
movq %r12, %rdi
movl $0x7, %esi
movl $0x3, %edx
callq 0x57dbf
movq %r12, %rdi
movl $0xea60, %esi           # imm = 0xEA60
movl $0x2710, %edx           # imm = 0x2710
callq 0x5ba4a
leaq 0x2068(%r14), %rdi
leaq 0x20(%rbx), %r15
movq %r15, %rsi
callq 0x6353e
movq %r12, (%rax)
leaq 0x2098(%r14), %rdi
movq %r15, %rsi
callq 0x6343e
movq %r13, (%rax)
addq $0x20c8, %r14           # imm = 0x20C8
movq %r14, %rdi
movq %r15, %rsi
callq 0x633be
movq %rax, %r14
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
leaq 0x20(%rax), %rdi
movq %r15, %rsi
callq 0x8380
leaq 0x40(%r14), %rdi
movq -0x30(%rbp), %rsi
callq 0x8380
movl 0x60(%rbx), %eax
movl %eax, 0x60(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq