LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x4, %edi
leaq 0x22c64(%rip), %rsi     # 0xcb7b0
movb $0x0, %al
callq 0x8b980
movq -0x10(%rbp), %rax
cmpl $0x0, 0x81a74(%rax)
jne 0xa8bc5
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9b80
movl %eax, -0x20(%rbp)
cmpl $-0x1, %eax
jne 0xa8b84
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0xa8ccb
movq -0x10(%rbp), %rdi
addq $0x81a90, %rdi          # imm = 0x81A90
movl -0x20(%rbp), %eax
movzbl %al, %esi
callq 0xa88c0
cmpl $0x0, %eax
je 0xa8ba1
jmp 0xa8bc3
cmpl $0x1000, -0x1c(%rbp)    # imm = 0x1000
jl 0xa8bb6
movl $0x0, -0x4(%rbp)
jmp 0xa8ccb
jmp 0xa8bb8
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa8b67
jmp 0xa8bc5
movq -0x10(%rbp), %rdi
addq $0x81a90, %rdi          # imm = 0x81A90
addq $0x2, %rdi
movq -0x18(%rbp), %rcx
movl $0x1, %esi
movl $0x4, %edx
callq 0x9af0
cmpq $0x4, %rax
jae 0xa8bf9
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0xa8ccb
movq -0x10(%rbp), %rax
movl $0x6, 0x81a74(%rax)
movq -0x10(%rbp), %rdi
addq $0x81a90, %rdi          # imm = 0x81A90
addq $0x4, %rdi
callq 0xa8920
movzwl %ax, %eax
addl $0x8, %eax
movq -0x10(%rbp), %rcx
movl %eax, 0x81a78(%rcx)
cmpl $0x1000, %eax           # imm = 0x1000
jle 0xa8c66
movq -0x10(%rbp), %rax
movl 0x81a78(%rax), %edx
movl $0x2, %edi
leaq 0x22b4e(%rip), %rsi     # 0xcb796
movb $0x0, %al
callq 0x8b980
movq -0x10(%rbp), %rax
movl $0x0, 0x81a74(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa8ccb
movq -0x10(%rbp), %rdi
addq $0x81a90, %rdi          # imm = 0x81A90
addq $0x6, %rdi
movq -0x10(%rbp), %rax
movl 0x81a78(%rax), %eax
subl $0x6, %eax
movslq %eax, %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x9af0
movq -0x10(%rbp), %rcx
movl 0x81a78(%rcx), %ecx
subl $0x6, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jae 0xa8cb1
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0xa8ccb
movq -0x10(%rbp), %rax
movl $0x0, 0x81a74(%rax)
movq -0x10(%rbp), %rdi
callq 0xa8940
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/ublox.cpp
// Function: bamboo::setcs(unsigned char*, int)
static void setcs(unsigned char *buff, int len)
{
    unsigned char cka=0,ckb=0;
    int i;
    
    for (i=2;i<len-2;i++) {
        cka+=buff[i]; ckb+=cka;
    }
    buff[len-2]=cka;
    buff[len-1]=ckb;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
movb $0x0, -0xe(%rbp)
movl $0x2, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x2, %ecx
cmpl %ecx, %eax
jge 0xa9614
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
movzbl -0xd(%rbp), %eax
addl %ecx, %eax
movb %al, -0xd(%rbp)
movzbl -0xd(%rbp), %ecx
movzbl -0xe(%rbp), %eax
addl %ecx, %eax
movb %al, -0xe(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa95da
movb -0xd(%rbp), %dl
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movb -0xe(%rbp), %dl
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %esi, -0x1c(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movl -0x1c(%rbp), %edx
movl $0x5, %edi
leaq 0x22217(%rip), %rsi     # 0xcb885
movb $0x0, %al
callq 0x8b980
cmpq $0x0, -0x18(%rbp)
jne 0xa9688
movl $0x0, -0x4(%rbp)
jmp 0xa97cb
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x30(%rbp), %rsi
movq -0x78(%rbp), %rdi
movsd -0x70(%rbp), %xmm0
callq 0x8e540
movsd %xmm0, -0x68(%rbp)
movsd 0x1de61(%rip), %xmm0    # 0xc7518
addsd -0x68(%rbp), %xmm0
cvttsd2si %xmm0, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x1c(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x8(%rax)
movl $0x0, -0x34(%rbp)
cmpl $0x7, -0x34(%rbp)
jge 0xa9731
movl $0x0, -0x38(%rbp)
cmpl $0x4, -0x38(%rbp)
jge 0xa9724
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl $0x3, %ecx
subl -0x38(%rbp), %ecx
shll $0x3, %ecx
shrl %cl, %eax
movb %al, %dl
movq -0x30(%rbp), %rax
movl -0x34(%rbp), %ecx
shll $0x2, %ecx
addl -0x38(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, 0xc(%rax,%rcx)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0xa96e5
jmp 0xa9726
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xa96d8
movq -0x28(%rbp), %rax
movl 0x1c(%rax), %eax
shrl $0x12, %eax
movzbl %al, %eax
andl $0xc0, %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movb %cl, 0x28(%rax)
movl $0x1c, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jle 0xa9795
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movzbl 0xc(%rax,%rcx), %eax
sarl $0x6, %eax
movq -0x30(%rbp), %rcx
movl -0x34(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movzbl 0xc(%rcx,%rdx), %ecx
shll $0x2, %ecx
addl %ecx, %eax
movb %al, %cl
movslq -0x34(%rbp), %rax
movb %cl, -0x60(%rbp,%rax)
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xa9753
movq -0x30(%rbp), %rax
movzbl 0xc(%rax), %eax
sarl $0x6, %eax
movb %al, -0x60(%rbp)
leaq -0x60(%rbp), %rdi
movl $0x1d, %esi
callq 0x8c2d0
movq -0x28(%rbp), %rcx
movl 0x1c(%rcx), %ecx
andl $0xffffff, %ecx         # imm = 0xFFFFFF
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/ublox.cpp
// Function: bamboo::checksum(unsigned char*, int)
static int checksum(unsigned char *buff, int len)
{
    unsigned char cka=0,ckb=0;
    int i;
    
    for (i=2;i<len-2;i++) {
        cka+=buff[i]; ckb+=cka;
    }
    return cka==buff[len-2]&&ckb==buff[len-1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
movb $0x0, -0xe(%rbp)
movl $0x2, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x2, %ecx
cmpl %ecx, %eax
jge 0xa9834
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
movzbl -0xd(%rbp), %eax
addl %ecx, %eax
movb %al, -0xd(%rbp)
movzbl -0xd(%rbp), %ecx
movzbl -0xe(%rbp), %eax
addl %ecx, %eax
movb %al, -0xe(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa97fa
movzbl -0xd(%rbp), %ecx
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %edx
subl $0x2, %edx
movslq %edx, %rdx
movzbl (%rax,%rdx), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x15(%rbp)
jne 0xa986f
movzbl -0xe(%rbp), %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/ublox.cpp
// Function: bamboo::decode_navsol(bamboo::raw_t*)
static int decode_navsol(raw_t *raw)
{
    int itow,ftow,week;
    unsigned char *p=raw->buff+6;
    
    trace(4,"decode_navsol: len=%d\n",raw->len);
    
    if (raw->outtype) {
        sprintf(raw->msgtype,"UBX NAV-SOL   (%4d):",raw->len);
    }
    itow=U4(p);
    ftow=I4(p+4);
    week=U2(p+8);
    if ((U1(p+11)&0x0C)==0x0C) {
        raw->time=gpst2time(week,itow*1E-3+ftow*1E-9);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x81a90, %rax          # imm = 0x81A90
addq $0x6, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x81a78(%rax), %edx
movl $0x4, %edi
leaq 0x20e0a(%rip), %rsi     # 0xcbe3e
movb $0x0, %al
callq 0x8b980
movq -0x8(%rbp), %rax
cmpl $0x0, 0x81a8c(%rax)
je 0xab06b
movq -0x8(%rbp), %rdi
addq $0x70e70, %rdi          # imm = 0x70E70
movq -0x8(%rbp), %rax
movl 0x81a78(%rax), %edx
leaq 0x20df1(%rip), %rsi     # 0xcbe55
movb $0x0, %al
callq 0x9150
movq -0x20(%rbp), %rdi
callq 0xac7b0
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rdi
addq $0x4, %rdi
callq 0xae690
movl %eax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0xa8920
movzwl %ax, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movzbl 0xb(%rax), %eax
andl $0xc, %eax
cmpl $0xc, %eax
jne 0xab0f4
movl -0x14(%rbp), %edi
cvtsi2sdl -0xc(%rbp), %xmm0
cvtsi2sdl -0x10(%rbp), %xmm1
movsd 0x12ce1(%rip), %xmm2    # 0xbdda0
mulsd %xmm2, %xmm1
movsd 0x12c7d(%rip), %xmm2    # 0xbdd48
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x8e4a0
movq %rax, -0x30(%rbp)
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/ublox.cpp
// Function: bamboo::decode_navtime(bamboo::raw_t*)
static int decode_navtime(raw_t *raw)
{
    int itow,ftow,week;
    unsigned char *p=raw->buff+6;
    
    trace(4,"decode_navtime: len=%d\n",raw->len);
    
    if (raw->outtype) {
        sprintf(raw->msgtype,"UBX NAV-TIME  (%4d):",raw->len);
    }
    itow=U4(p);
    ftow=I4(p+4);
    week=U2(p+8);
    if ((U1(p+11)&0x03)==0x03) {
        raw->time=gpst2time(week,itow*1E-3+ftow*1E-9);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x81a90, %rax          # imm = 0x81A90
addq $0x6, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x81a78(%rax), %edx
movl $0x4, %edi
leaq 0x20d36(%rip), %rsi     # 0xcbe6a
movb $0x0, %al
callq 0x8b980
movq -0x8(%rbp), %rax
cmpl $0x0, 0x81a8c(%rax)
je 0xab16b
movq -0x8(%rbp), %rdi
addq $0x70e70, %rdi          # imm = 0x70E70
movq -0x8(%rbp), %rax
movl 0x81a78(%rax), %edx
leaq 0x20d1e(%rip), %rsi     # 0xcbe82
movb $0x0, %al
callq 0x9150
movq -0x20(%rbp), %rdi
callq 0xac7b0
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rdi
addq $0x4, %rdi
callq 0xae690
movl %eax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0xa8920
movzwl %ax, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movzbl 0xb(%rax), %eax
andl $0x3, %eax
cmpl $0x3, %eax
jne 0xab1f4
movl -0x14(%rbp), %edi
cvtsi2sdl -0xc(%rbp), %xmm0
cvtsi2sdl -0x10(%rbp), %xmm1
movsd 0x12be1(%rip), %xmm2    # 0xbdda0
mulsd %xmm2, %xmm1
movsd 0x12b7d(%rip), %xmm2    # 0xbdd48
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x8e4a0
movq %rax, -0x30(%rbp)
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/ublox.cpp
// Function: bamboo::ubx_sys(int)
static int ubx_sys(int gnssid)
{
    switch (gnssid) {
        case 0: return SYS_GPS;
        case 1: return SYS_SBS;
        case 2: return SYS_GAL;
        case 3: return SYS_CMP;
        case 5: return SYS_QZS;
        case 6: return SYS_GLO;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0x6, %rax
ja 0xac86e
movq -0x10(%rbp), %rax
leaq 0x1dd25(%rip), %rcx     # 0xca554
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0xac875
movl $0x2, -0x4(%rbp)
jmp 0xac875
movl $0x8, -0x4(%rbp)
jmp 0xac875
movl $0x20, -0x4(%rbp)
jmp 0xac875
movl $0x10, -0x4(%rbp)
jmp 0xac875
movl $0x4, -0x4(%rbp)
jmp 0xac875
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/ublox.cpp
// Function: bamboo::ubx_sig(int, int)
static int ubx_sig(int sys, int sigid)
{
    if (sys == SYS_GPS) {
        if (sigid == 0) return CODE_L1C; /* L1C/A */
        if (sigid == 3) return CODE_L2L; /* L2CL */
        if (sigid == 4) return CODE_L2M; /* L2CM */
    }
    else if (sys == SYS_GLO) {
        if (sigid == 0) return CODE_L1C; /* G1C/A (GLO L1 OF) */
        if (sigid == 2) return CODE_L2C; /* G2C/A (GLO L2 OF) */
    }
    else if (sys == SYS_GAL) {
        if (sigid == 0) return CODE_L1C; /* E1C */
        if (sigid == 1) return CODE_L1B; /* E1B */
        if (sigid == 5) return CODE_L7I; /* E5bI */
        if (sigid == 6) return CODE_L7Q; /* E5bQ */
    }
    else if (sys == SYS_QZS) {
        if (sigid == 0) return CODE_L1C; /* L1C/A */
        if (sigid == 5) return CODE_L2L; /* L2CL (not specified in [5]) */
    }
    else if (sys == SYS_CMP) {
        if (sigid == 0) return CODE_L1I; /* B1I D1 (rinex 3.02) */
        if (sigid == 1) return CODE_L1I; /* B1I D2 (rinex 3.02) */
        if (sigid == 2) return CODE_L7I; /* B2I D1 */
        if (sigid == 3) return CODE_L7I; /* B2I D2 */
    }
    else if (sys == SYS_SBS) {
        return CODE_L1C; /* L1C/A (not in [5]) */
    }
    return CODE_NONE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0xac8cb
cmpl $0x0, -0xc(%rbp)
jne 0xac8a2
movl $0x1, -0x4(%rbp)
jmp 0xac9d4
cmpl $0x3, -0xc(%rbp)
jne 0xac8b4
movl $0x11, -0x4(%rbp)
jmp 0xac9d4
cmpl $0x4, -0xc(%rbp)
jne 0xac8c6
movl $0x16, -0x4(%rbp)
jmp 0xac9d4
jmp 0xac9cd
cmpl $0x4, -0x8(%rbp)
jne 0xac8fa
cmpl $0x0, -0xc(%rbp)
jne 0xac8e3
movl $0x1, -0x4(%rbp)
jmp 0xac9d4
cmpl $0x2, -0xc(%rbp)
jne 0xac8f5
movl $0xe, -0x4(%rbp)
jmp 0xac9d4
jmp 0xac9cb
cmpl $0x8, -0x8(%rbp)
jne 0xac94a
cmpl $0x0, -0xc(%rbp)
jne 0xac912
movl $0x1, -0x4(%rbp)
jmp 0xac9d4
cmpl $0x1, -0xc(%rbp)
jne 0xac924
movl $0xb, -0x4(%rbp)
jmp 0xac9d4
cmpl $0x5, -0xc(%rbp)
jne 0xac936
movl $0x1b, -0x4(%rbp)
jmp 0xac9d4
cmpl $0x6, -0xc(%rbp)
jne 0xac948
movl $0x1c, -0x4(%rbp)
jmp 0xac9d4
jmp 0xac9c9
cmpl $0x10, -0x8(%rbp)
jne 0xac970
cmpl $0x0, -0xc(%rbp)
jne 0xac95f
movl $0x1, -0x4(%rbp)
jmp 0xac9d4
cmpl $0x5, -0xc(%rbp)
jne 0xac96e
movl $0x11, -0x4(%rbp)
jmp 0xac9d4
jmp 0xac9c7
cmpl $0x20, -0x8(%rbp)
jne 0xac9b4
cmpl $0x0, -0xc(%rbp)
jne 0xac985
movl $0x2f, -0x4(%rbp)
jmp 0xac9d4
cmpl $0x1, -0xc(%rbp)
jne 0xac994
movl $0x2f, -0x4(%rbp)
jmp 0xac9d4
cmpl $0x2, -0xc(%rbp)
jne 0xac9a3
movl $0x1b, -0x4(%rbp)
jmp 0xac9d4
cmpl $0x3, -0xc(%rbp)
jne 0xac9b2
movl $0x1b, -0x4(%rbp)
jmp 0xac9d4
jmp 0xac9c5
cmpl $0x2, -0x8(%rbp)
jne 0xac9c3
movl $0x1, -0x4(%rbp)
jmp 0xac9d4
jmp 0xac9c5
jmp 0xac9c7
jmp 0xac9c9
jmp 0xac9cb
jmp 0xac9cd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/ublox.cpp
// Function: bamboo::sig_idx(int, int)
static int sig_idx(int sys, int code)
{
    if (sys == SYS_GPS) {
        if (code==CODE_L1C) return 1;
        if (code==CODE_L2L) return 2;
        if (code==CODE_L2M) return NFREQ+1;
    }
    else if (sys == SYS_GLO) {
        if (code==CODE_L1C) return 1;
        if (code==CODE_L2C) return 2;
    }
    else if (sys == SYS_GAL) {
        if (code==CODE_L1C) return 1;
        if (code==CODE_L1B) return NFREQ+1;
        if (code==CODE_L7I) return 2; /* E5bI */
        if (code==CODE_L7Q) return 2; /* E5bQ */
    }
    else if (sys == SYS_QZS) {
        if (code==CODE_L1C) return 1;
        if (code==CODE_L2L) return 2;
    }
    else if (sys == SYS_CMP) {
        if (code==CODE_L1I) return 1;
        if (code==CODE_L7I) return 2;
    }
    else if (sys == SYS_SBS) {
        if (code==CODE_L1C) return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0xaca2b
cmpl $0x1, -0xc(%rbp)
jne 0xaca02
movl $0x1, -0x4(%rbp)
jmp 0xacb1b
cmpl $0x11, -0xc(%rbp)
jne 0xaca14
movl $0x2, -0x4(%rbp)
jmp 0xacb1b
cmpl $0x16, -0xc(%rbp)
jne 0xaca26
movl $0x4, -0x4(%rbp)
jmp 0xacb1b
jmp 0xacb14
cmpl $0x4, -0x8(%rbp)
jne 0xaca5a
cmpl $0x1, -0xc(%rbp)
jne 0xaca43
movl $0x1, -0x4(%rbp)
jmp 0xacb1b
cmpl $0xe, -0xc(%rbp)
jne 0xaca55
movl $0x2, -0x4(%rbp)
jmp 0xacb1b
jmp 0xacb12
cmpl $0x8, -0x8(%rbp)
jne 0xacaa7
cmpl $0x1, -0xc(%rbp)
jne 0xaca72
movl $0x1, -0x4(%rbp)
jmp 0xacb1b
cmpl $0xb, -0xc(%rbp)
jne 0xaca84
movl $0x4, -0x4(%rbp)
jmp 0xacb1b
cmpl $0x1b, -0xc(%rbp)
jne 0xaca96
movl $0x2, -0x4(%rbp)
jmp 0xacb1b
cmpl $0x1c, -0xc(%rbp)
jne 0xacaa5
movl $0x2, -0x4(%rbp)
jmp 0xacb1b
jmp 0xacb10
cmpl $0x10, -0x8(%rbp)
jne 0xacacd
cmpl $0x1, -0xc(%rbp)
jne 0xacabc
movl $0x1, -0x4(%rbp)
jmp 0xacb1b
cmpl $0x11, -0xc(%rbp)
jne 0xacacb
movl $0x2, -0x4(%rbp)
jmp 0xacb1b
jmp 0xacb0e
cmpl $0x20, -0x8(%rbp)
jne 0xacaf3
cmpl $0x2f, -0xc(%rbp)
jne 0xacae2
movl $0x1, -0x4(%rbp)
jmp 0xacb1b
cmpl $0x1b, -0xc(%rbp)
jne 0xacaf1
movl $0x2, -0x4(%rbp)
jmp 0xacb1b
jmp 0xacb0c
cmpl $0x2, -0x8(%rbp)
jne 0xacb0a
cmpl $0x1, -0xc(%rbp)
jne 0xacb08
movl $0x1, -0x4(%rbp)
jmp 0xacb1b
jmp 0xacb0a
jmp 0xacb0c
jmp 0xacb0e
jmp 0xacb10
jmp 0xacb12
jmp 0xacb14
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: DoubleString[P]RtConverter/src/Rtklib/ublox.cpp
// Function: bamboo::sig_freq(int, int, int)
static double sig_freq(int sys, int f, int fcn)
{
    static const double freq_glo[8]={FREQ1_GLO,FREQ2_GLO,FREQ3_GLO};
    static const double dfrq_glo[8]={DFRQ1_GLO,DFRQ2_GLO};
    static const double freq_bds[8]={FREQ1_CMP,0,0,FREQ3_CMP,FREQ2_CMP};
    
    if (sys == SYS_GLO) {
        return freq_glo[f-1]+dfrq_glo[f-1]*fcn;
    }
    else if (sys == SYS_CMP) {
        return freq_bds[f-1];
    }
    return CLIGHT/lam_carr[f-1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x4, -0xc(%rbp)
jne 0xacb71
movl -0x10(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x1eb5d(%rip), %rax     # 0xcb6a0
movsd (%rax,%rcx,8), %xmm1
movl -0x10(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x1eb88(%rip), %rax     # 0xcb6e0
movsd (%rax,%rcx,8), %xmm0
cvtsi2sdl -0x14(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xacbb7
cmpl $0x20, -0xc(%rbp)
jne 0xacb93
movl -0x10(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x1eb99(%rip), %rax     # 0xcb720
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xacbb7
jmp 0xacb95
movl -0x10(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
movsd 0x11202(%rip), %xmm0    # 0xbdda8
leaq 0x163e3(%rip), %rax     # 0xc2f90
divsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nop
// File: DoubleString[P]RtConverter/src/Rtklib/ublox.cpp
// Function: bamboo::save_subfrm(int, bamboo::raw_t*)
static int save_subfrm(int sat, raw_t *raw)
{
    unsigned char *p=raw->buff+6,*q;
    int i,j,n,id=(U4(p+6)>>2)&0x7;
    
    trace(4,"save_subfrm: sat=%2d id=%d\n",sat,id);
    
    if (id<1||5<id) return 0;
    
    q=raw->subfrm[sat-1]+(id-1)*30;
    
    for (i=n=0,p+=2;i<10;i++,p+=4) {
        for (j=23;j>=0;j--) {
            *q=(*q<<1)+((U4(p)>>j)&1); if (++n%8==0) q++;
        }
    }
    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x81a90, %rax          # imm = 0x81A90
addq $0x6, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x6, %rdi
callq 0xac7b0
shrl $0x2, %eax
andl $0x7, %eax
movl %eax, -0x30(%rbp)
movl -0x8(%rbp), %edx
movl -0x30(%rbp), %ecx
movl $0x4, %edi
leaq 0x1ef80(%rip), %rsi     # 0xcbb89
movb $0x0, %al
callq 0x8b980
cmpl $0x1, -0x30(%rbp)
jl 0xacc20
movl $0x5, %eax
cmpl -0x30(%rbp), %eax
jge 0xacc2c
movl $0x0, -0x4(%rbp)
jmp 0xacd0c
movq -0x10(%rbp), %rax
addq $0x70f70, %rax          # imm = 0x70F70
movl -0x8(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x17c, %rcx, %rcx      # imm = 0x17C
addq %rcx, %rax
movl -0x30(%rbp), %ecx
subl $0x1, %ecx
imull $0x1e, %ecx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
cmpl $0xa, -0x24(%rbp)
jge 0xacd06
movl $0x17, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jl 0xaccea
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
shll %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
callq 0xac7b0
movl %eax, %edx
movl -0x34(%rbp), %eax
movl -0x28(%rbp), %ecx
shrl %cl, %edx
movl %edx, %ecx
andl $0x1, %ecx
addl %ecx, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl $0x8, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0xaccdd
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xaccdf
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xacc87
jmp 0xaccec
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0xacc76
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x81a90, %rax          # imm = 0x81A90
addq $0x6, %rax
movslq -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0x81a78(%rax), %eax
movl -0x18(%rbp), %ecx
addl $0x28, %ecx
cmpl %ecx, %eax
jge 0xae52b
movq -0x10(%rbp), %rax
movl 0x81a78(%rax), %edx
movl $0x2, %edi
leaq 0x1d8fe(%rip), %rsi     # 0xcbe16
movb $0x0, %al
callq 0x8b980
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xae67e
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0xa0(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x98(%rbp)
movq -0xa0(%rbp), %rdi
movsd -0x98(%rbp), %xmm0
movsd 0x1087d(%rip), %xmm1    # 0xbedd8
callq 0x8e860
movq %rax, -0x90(%rbp)
movsd %xmm0, -0x88(%rbp)
movq -0x90(%rbp), %rdi
movsd -0x88(%rbp), %xmm0
leaq -0x30(%rbp), %rsi
callq 0x8e540
cvttsd2si %xmm0, %eax
movl %eax, -0x2c(%rbp)
movl -0x14(%rbp), %edi
leaq -0x28(%rbp), %rsi
callq 0x8b3b0
movl -0x28(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x70e4c(%rax)
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x70e48(%rax)
movl -0x30(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x70e44(%rax)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jge 0xae629
movl $0x0, -0x20(%rbp)
cmpl $0x4, -0x20(%rbp)
jge 0xae610
movq -0x38(%rbp), %rax
movl $0x3, %ecx
subl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movl -0x24(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
cltq
movb %cl, -0x80(%rbp,%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xae5dc
jmp 0xae612
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x38(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x38(%rbp)
jmp 0xae5cf
movq -0x10(%rbp), %rax
movq -0x80(%rbp), %rcx
movq %rcx, 0x70e50(%rax)
movq -0x78(%rbp), %rcx
movq %rcx, 0x70e58(%rax)
movq -0x70(%rbp), %rcx
movq %rcx, 0x70e60(%rax)
movl -0x68(%rbp), %ecx
movl %ecx, 0x70e68(%rax)
movb -0x64(%rbp), %cl
movb %cl, 0x70e6c(%rax)
movq -0x10(%rbp), %rax
movzbl 0x70e6c(%rax), %ecx
andl $0xc0, %ecx
movb %cl, 0x70e6c(%rax)
movl $0x3, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x2070, %rsp           # imm = 0x2070
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x2070(%rbp)
movb $0x1, (%rax)
leaq -0x2048(%rbp), %rdi
movq %rdi, -0x2068(%rbp)
callq 0x4f7c0
movq -0x2070(%rbp), %rdi
movq -0x2068(%rbp), %rsi
addq $0x10, %rdi
callq 0x44f90
jmp 0xae7b9
leaq -0x2048(%rbp), %rdi
callq 0x4f750
movq -0x2070(%rbp), %rdi
addq $0x8, %rdi
callq 0x96e0
movq -0x2070(%rbp), %rcx
leaq -0x2060(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x72(%rip), %rdx        # 0xae860
callq 0x9dc0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0xae847
movq 0x487be(%rip), %rdi     # 0xf6fc0
leaq 0xf212(%rip), %rsi      # 0xbda1b
callq 0x9760
movq %rax, %rdi
movq 0x48788(%rip), %rsi     # 0xf6fa0
callq 0x97c0
movl $0x1, %edi
callq 0x9910
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2050(%rbp)
movl %eax, -0x2054(%rbp)
leaq -0x2048(%rbp), %rdi
callq 0x4f750
jmp 0xae850
addq $0x2070, %rsp           # imm = 0x2070
popq %rbp
retq
movq -0x2050(%rbp), %rdi
callq 0x9d20
nopl (%rax)
// File: 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
subq $0x2080, %rsp           # imm = 0x2080
movq %rsi, -0x2080(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x2078(%rbp)
movb $0x1, (%rax)
leaq -0x2050(%rbp), %rdi
movq %rdi, -0x2070(%rbp)
callq 0x4f7c0
movq -0x2078(%rbp), %rdi
movq -0x2070(%rbp), %rsi
addq $0x10, %rdi
callq 0x44f90
jmp 0xae8e4
leaq -0x2050(%rbp), %rdi
callq 0x4f750
movq -0x2078(%rbp), %rdi
addq $0x8, %rdi
callq 0x96e0
movq -0x2078(%rbp), %rcx
leaq -0x2068(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0xb9(%rip), %rdx       # 0xae860
callq 0x9dc0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0xae972
movq 0x48693(%rip), %rdi     # 0xf6fc0
leaq 0xf0e7(%rip), %rsi      # 0xbda1b
callq 0x9760
movq %rax, %rdi
movq 0x4865d(%rip), %rsi     # 0xf6fa0
callq 0x97c0
movl $0x1, %edi
callq 0x9910
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2058(%rbp)
movl %eax, -0x205c(%rbp)
leaq -0x2050(%rbp), %rdi
callq 0x4f750
jmp 0xae995
movq -0x2080(%rbp), %rsi
movq -0x2078(%rbp), %rdi
addq $0x2050, %rdi           # imm = 0x2050
callq 0x45080
addq $0x2080, %rsp           # imm = 0x2080
popq %rbp
retq
movq -0x2058(%rbp), %rdi
callq 0x9d20
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x1, %edi
movl $0x860, %esi            # imm = 0x860
callq 0x94f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9d310
movl $0x1, %edi
movl $0x9fe48, %esi          # imm = 0x9FE48
callq 0x94f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6a920
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x92b0
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl $0x7, %esi
movl $0x3, %edx
callq 0x9d3f0
movq -0x18(%rbp), %rdi
movl $0xea60, %esi           # imm = 0xEA60
movl $0x2710, %edx           # imm = 0x2710
callq 0xa3430
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x2068, %rdi           # imm = 0x2068
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0xb0ab0
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rdi
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x2098, %rdi           # imm = 0x2098
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0xb05d0
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rdi
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x20c8, %rdi           # imm = 0x20C8
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0xb04d0
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x512b0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: DoubleString[P]RtConverter/src/VrsObs/VrsNtripClient.cpp
// Function: bamboo::VrsNtripClient::m_deleteConnection(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void VrsNtripClient::m_deleteConnection(string staname) {
	map<string, stream_t*>::iterator streamItr;
	map<string, rtcm_t*>::iterator rtcmItr;
	map<string, VrsStaItem>::iterator vrsItr;

	streamItr = m_streams.find(staname);
	rtcmItr = m_rtcms.find(staname);
	vrsItr = m_stas.find(staname);

	if (streamItr != m_streams.end()) {
		strclose((*streamItr).second);
		free((*streamItr).second);
		m_streams.erase(streamItr);
	}
	if (rtcmItr != m_rtcms.end()) {
		free_rtcm((*rtcmItr).second);
		free((*rtcmItr).second);
		m_rtcms.erase(rtcmItr);
	}
	if (vrsItr != m_stas.end())
		m_stas.erase(vrsItr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb03e0
leaq -0x20(%rbp), %rdi
callq 0xb0400
leaq -0x28(%rbp), %rdi
callq 0xb0420
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdi
addq $0x2068, %rdi           # imm = 0x2068
callq 0xb0900
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
addq $0x2098, %rdi           # imm = 0x2098
callq 0xb0930
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x20c8, %rdi           # imm = 0x20C8
callq 0xb0960
movq -0x90(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x2068, %rdi           # imm = 0x2068
callq 0xb04a0
movq %rax, -0x48(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xb0470
testb $0x1, %al
jne 0xb026c
jmp 0xb02b3
leaq -0x18(%rbp), %rdi
callq 0xb05b0
movq 0x20(%rax), %rdi
callq 0x9ed20
leaq -0x18(%rbp), %rdi
callq 0xb05b0
movq 0x20(%rax), %rdi
callq 0x9900
movq -0x90(%rbp), %rdi
addq $0x2068, %rdi           # imm = 0x2068
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rsi
callq 0xb0990
movq %rax, -0x58(%rbp)
movq -0x90(%rbp), %rdi
addq $0x2098, %rdi           # imm = 0x2098
callq 0xb0740
movq %rax, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xb0710
testb $0x1, %al
jne 0xb02dd
jmp 0xb0324
leaq -0x20(%rbp), %rdi
callq 0xb0770
movq 0x20(%rax), %rdi
callq 0x6af80
leaq -0x20(%rbp), %rdi
callq 0xb0770
movq 0x20(%rax), %rdi
callq 0x9900
movq -0x90(%rbp), %rdi
addq $0x2098, %rdi           # imm = 0x2098
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rsi
callq 0xb09d0
movq %rax, -0x70(%rbp)
movq -0x90(%rbp), %rdi
addq $0x20c8, %rdi           # imm = 0x20C8
callq 0xb0a40
movq %rax, -0x78(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xb0a10
testb $0x1, %al
jne 0xb034e
jmp 0xb0374
movq -0x90(%rbp), %rdi
addq $0x20c8, %rdi           # imm = 0x20C8
movq -0x28(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rsi
callq 0xb0a70
movq %rax, -0x88(%rbp)
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Rnxbrd/BroadcastEphUtils.cpp
// Function: bamboo::BroadcastEphUtils::glsinit(double*, bamboo::GLSEPH&)
void BroadcastEphUtils::glsinit(double* x,GLSEPH& eph){
	int i;
	for (i = 0; i < 3; i++)
		x[i] = eph.pos[i];
	for (i = 3; i < 6; i++)
		x[i] = eph.vel[i - 3];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0xb6c23
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd 0x30(%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb6bf7
movl $0x3, -0x1c(%rbp)
cmpl $0x6, -0x1c(%rbp)
jge 0xb6c5b
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x3, %ecx
movslq %ecx, %rcx
movsd 0x48(%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb6c2a
popq %rbp
retq
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Rnxbrd/RnxEphFileAdapter.cpp
// Function: bamboo::RnxEphFileAdapter::RnxEphFileAdapter()
RnxEphFileAdapter::RnxEphFileAdapter() {
	memset(neph, 0, sizeof(int) * MAXSYS);
	mjd0 = mjd1 = leap = 0;
	sod0 = sod1 = ver = 0.0;
	memset(ionc, 0, sizeof(char) * MAXSYS * 2 * LEN_EPHION);
	memset(ion, 0, sizeof(double) * MAXSYS * 2 * 4);
	memset(timc, 0, sizeof(char) * MAXSYS * 2 * LEN_EPHION);
	memset(tim, 0, sizeof(double) * MAXSYS * 2 * 4);
	isOpen = 0;
	orbType = ORB_BRD;
	clkType = CLK_BRD;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xba710
movq -0x10(%rbp), %rdi
addq $0x6d0, %rdi            # imm = 0x6D0
callq 0xba7a0
movq -0x10(%rbp), %rdi
leaq 0x3f264(%rip), %rax     # 0xf6ac8
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x3f256(%rip), %rax     # 0xf6ac8
addq $0xa8, %rax
movq %rax, 0x2b8(%rdi)
leaq 0x3f242(%rip), %rax     # 0xf6ac8
addq $0xd8, %rax
movq %rax, 0x6d0(%rdi)
addq $0x6d0, %rdi            # imm = 0x6D0
addq $0x8, %rdi
xorl %esi, %esi
movl $0x1c, %edx
callq 0x93d0
movq -0x10(%rbp), %rdi
movl $0x0, 0xfd0(%rdi)
movl $0x0, 0xdb4(%rdi)
movl $0x0, 0xdb0(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0xdd0(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0xdc0(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0xdb8(%rdi)
addq $0x7b8, %rdi            # imm = 0x7B8
xorl %esi, %esi
movl $0x38, %edx
callq 0x93d0
movq -0x10(%rbp), %rdi
addq $0x7f0, %rdi            # imm = 0x7F0
xorl %esi, %esi
movl $0x1c0, %edx            # imm = 0x1C0
callq 0x93d0
movq -0x10(%rbp), %rdi
addq $0xdd8, %rdi            # imm = 0xDD8
xorl %esi, %esi
movl $0x38, %edx
callq 0x93d0
movq -0x10(%rbp), %rdi
addq $0xe10, %rdi            # imm = 0xE10
xorl %esi, %esi
movl $0x1c0, %edx            # imm = 0x1C0
callq 0x93d0
movq -0x10(%rbp), %rax
movl $0x0, 0xdc8(%rax)
movl $0x3, 0x2c0(%rax)
movl $0x6, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rnxbrd/RnxEphFileAdapter.cpp
// Function: bamboo::RnxEphFileAdapter::v_closeRnxEph()
void RnxEphFileAdapter::v_closeRnxEph() {
	int isys;
	for (isys = 0; isys < MAXSYS; isys++) {
		this->gnssEph[isys].clear();
	}
	this->glsEph.clear();
	memset(neph, 0, sizeof(int) * MAXSYS);
	this->isOpen = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x7, -0xc(%rbp)
jge 0xb9c2b
movq -0x18(%rbp), %rdi
addq $0x6d0, %rdi            # imm = 0x6D0
addq $0x28, %rdi
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x45680
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb9bfb
movq -0x18(%rbp), %rdi
addq $0x6d0, %rdi            # imm = 0x6D0
addq $0xd0, %rdi
callq 0x45650
movq -0x18(%rbp), %rdi
addq $0x6d0, %rdi            # imm = 0x6D0
addq $0x8, %rdi
xorl %esi, %esi
movl $0x1c, %edx
callq 0x93d0
movq -0x18(%rbp), %rax
movl $0x0, 0xdc8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rnxbrd/RnxEphFileAdapter.cpp
// Function: bamboo::RnxEphFileAdapter::v_readClk(char const*, int, double, double*)
int RnxEphFileAdapter::v_readClk(const char* cprn, int mjd, double sod,
		double* sclk) {
	// using rinex navigation file to acquire satellite clock
	int wk, iode = -1;
	double sow, tgd, dtmin;
	mjd2wksow(mjd, sod, &wk, &sow);
	*sclk = 0.0;
	if (cprn[0] != 'R')
		if (cprn[0] == 'C')
			return this->m_brd2xyz("ynn", cprn, wk, sow - 14.0, NULL, sclk,
					&dtmin, &tgd, &iode);
		else
			return this->m_brd2xyz("ynn", cprn, wk, sow, NULL, sclk, &dtmin,
					&tgd, &iode);
	else
		return this->m_gls2xyz("ynn", cprn, wk, sow, NULL, sclk, &dtmin, &iode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x78, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movsd %xmm0, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0xffffffff, -0x40(%rbp) # imm = 0xFFFFFFFF
movl -0x24(%rbp), %edi
movsd -0x30(%rbp), %xmm0
leaq -0x3c(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x33810
movq -0x38(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x52, %eax
je 0xb9d99
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x43, %eax
jne 0xb9d48
movq -0x60(%rbp), %rax
movq %rax, %rdi
addq $0x6d0, %rdi            # imm = 0x6D0
movq -0x20(%rbp), %rdx
movl -0x3c(%rbp), %ecx
movsd -0x48(%rbp), %xmm0
movsd 0x31de(%rip), %xmm1     # 0xbcee8
subsd %xmm1, %xmm0
movq -0x38(%rbp), %r9
movq 0x6d0(%rax), %rax
leaq 0x12505(%rip), %rsi     # 0xcc225
xorl %r8d, %r8d
leaq -0x58(%rbp), %rbx
leaq -0x50(%rbp), %r11
leaq -0x40(%rbp), %r10
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
callq *0x10(%rax)
movl %eax, -0xc(%rbp)
jmp 0xb9ddf
movq -0x60(%rbp), %rax
movq %rax, %rdi
addq $0x6d0, %rdi            # imm = 0x6D0
movq -0x20(%rbp), %rdx
movl -0x3c(%rbp), %ecx
movsd -0x48(%rbp), %xmm0
movq -0x38(%rbp), %r9
movq 0x6d0(%rax), %rax
leaq 0x124b1(%rip), %rsi     # 0xcc225
xorl %r8d, %r8d
leaq -0x58(%rbp), %rbx
leaq -0x50(%rbp), %r11
leaq -0x40(%rbp), %r10
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
callq *0x10(%rax)
movl %eax, -0xc(%rbp)
jmp 0xb9ddf
movq -0x60(%rbp), %rax
movq %rax, %rdi
addq $0x6d0, %rdi            # imm = 0x6D0
movq -0x20(%rbp), %rdx
movl -0x3c(%rbp), %ecx
movsd -0x48(%rbp), %xmm0
movq -0x38(%rbp), %r9
movq 0x6d0(%rax), %rax
leaq 0x12460(%rip), %rsi     # 0xcc225
xorl %r8d, %r8d
leaq -0x58(%rbp), %r11
leaq -0x40(%rbp), %r10
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
callq *0x18(%rax)
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Rnxbrd/RnxEphFileAdapter.cpp
// Function: bamboo::RnxEphFileAdapter::v_readClk(char const*, int, double, double*, int*)
int RnxEphFileAdapter::v_readClk(const char* cprn, int mjd, double sod,
		double* sclk, int* iode) {
	int wk;
	double sow, tgd, dtmin;
	mjd2wksow(mjd, sod, &wk, &sow);
	*sclk = 0.0;
	if (cprn[0] != 'R')
		if (cprn[0] == 'C')
			return this->m_brd2xyz("ynn", cprn, wk, sow - 14.0, NULL, sclk,
					&dtmin, &tgd, iode);
		else
			return this->m_brd2xyz("ynn", cprn, wk, sow, NULL, sclk, &dtmin,
					&tgd, iode);
	else
		return this->m_gls2xyz("ynn", cprn, wk, sow, NULL, sclk, &dtmin, iode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x78, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movsd %xmm0, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0x24(%rbp), %edi
movsd -0x30(%rbp), %xmm0
leaq -0x44(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x33810
movq -0x38(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x52, %eax
je 0xb9f06
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x43, %eax
jne 0xb9eb5
movq -0x68(%rbp), %rax
movq %rax, %rdi
addq $0x6d0, %rdi            # imm = 0x6D0
movq -0x20(%rbp), %rdx
movl -0x44(%rbp), %ecx
movsd -0x50(%rbp), %xmm0
movsd 0x3071(%rip), %xmm1     # 0xbcee8
subsd %xmm1, %xmm0
movq -0x38(%rbp), %r9
movq -0x40(%rbp), %r10
movq 0x6d0(%rax), %rax
leaq 0x12394(%rip), %rsi     # 0xcc225
xorl %r8d, %r8d
leaq -0x60(%rbp), %rbx
leaq -0x58(%rbp), %r11
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
callq *0x10(%rax)
movl %eax, -0xc(%rbp)
jmp 0xb9f4c
movq -0x68(%rbp), %rax
movq %rax, %rdi
addq $0x6d0, %rdi            # imm = 0x6D0
movq -0x20(%rbp), %rdx
movl -0x44(%rbp), %ecx
movsd -0x50(%rbp), %xmm0
movq -0x38(%rbp), %r9
movq -0x40(%rbp), %r10
movq 0x6d0(%rax), %rax
leaq 0x12340(%rip), %rsi     # 0xcc225
xorl %r8d, %r8d
leaq -0x60(%rbp), %rbx
leaq -0x58(%rbp), %r11
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
callq *0x10(%rax)
movl %eax, -0xc(%rbp)
jmp 0xb9f4c
movq -0x68(%rbp), %rax
movq %rax, %rdi
addq $0x6d0, %rdi            # imm = 0x6D0
movq -0x20(%rbp), %rdx
movl -0x44(%rbp), %ecx
movsd -0x50(%rbp), %xmm0
movq -0x38(%rbp), %r9
movq -0x40(%rbp), %r10
movq 0x6d0(%rax), %rax
leaq 0x122ef(%rip), %rsi     # 0xcc225
xorl %r8d, %r8d
leaq -0x60(%rbp), %r11
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
callq *0x18(%rax)
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rnxbrd/RnxEphFileAdapter.cpp
// Function: bamboo::RnxEphFileAdapter::v_readOrbit(char const*, int, double, double*)
int RnxEphFileAdapter::v_readOrbit(const char* cprn, int mjd, double sod,
		double* xsat) {
	// using rinex navigation file to acquire orbit
	int wk, iode = -1;
	double sow, tgd, dtmin, sclk;
	mjd2wksow(mjd, sod, &wk, &sow);
	if (cprn[0] != 'R')
		if (cprn[0] == 'C')
			return this->m_brd2xyz("yyy", cprn, wk, sow - 14.0, xsat, &sclk,
					&dtmin, &tgd, &iode);
		else
			return this->m_brd2xyz("yyy", cprn, wk, sow, xsat, &sclk, &dtmin,
					&tgd, &iode);
	else
		return this->m_gls2xyz("yyy", cprn, wk, sow, xsat, &sclk, &dtmin, &iode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x78, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movsd %xmm0, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0xffffffff, -0x40(%rbp) # imm = 0xFFFFFFFF
movl -0x24(%rbp), %edi
movsd -0x30(%rbp), %xmm0
leaq -0x3c(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x33810
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x52, %eax
je 0xba070
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x43, %eax
jne 0xba01e
movq -0x68(%rbp), %rax
movq %rax, %rdi
addq $0x6d0, %rdi            # imm = 0x6D0
movq -0x20(%rbp), %rdx
movl -0x3c(%rbp), %ecx
movsd -0x48(%rbp), %xmm0
movsd 0x2f09(%rip), %xmm1     # 0xbcee8
subsd %xmm1, %xmm0
movq -0x38(%rbp), %r8
movq 0x6d0(%rax), %rax
leaq 0x122ab(%rip), %rsi     # 0xcc2a0
leaq -0x60(%rbp), %r9
leaq -0x58(%rbp), %rbx
leaq -0x50(%rbp), %r11
leaq -0x40(%rbp), %r10
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
callq *0x10(%rax)
movl %eax, -0xc(%rbp)
jmp 0xba0b7
movq -0x68(%rbp), %rax
movq %rax, %rdi
addq $0x6d0, %rdi            # imm = 0x6D0
movq -0x20(%rbp), %rdx
movl -0x3c(%rbp), %ecx
movsd -0x48(%rbp), %xmm0
movq -0x38(%rbp), %r8
movq 0x6d0(%rax), %rax
leaq 0x12256(%rip), %rsi     # 0xcc2a0
leaq -0x60(%rbp), %r9
leaq -0x58(%rbp), %rbx
leaq -0x50(%rbp), %r11
leaq -0x40(%rbp), %r10
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
callq *0x10(%rax)
movl %eax, -0xc(%rbp)
jmp 0xba0b7
movq -0x68(%rbp), %rax
movq %rax, %rdi
addq $0x6d0, %rdi            # imm = 0x6D0
movq -0x20(%rbp), %rdx
movl -0x3c(%rbp), %ecx
movsd -0x48(%rbp), %xmm0
movq -0x38(%rbp), %r8
movq 0x6d0(%rax), %rax
leaq 0x12204(%rip), %rsi     # 0xcc2a0
leaq -0x60(%rbp), %r9
leaq -0x58(%rbp), %r11
leaq -0x40(%rbp), %r10
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
callq *0x18(%rax)
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rnxbrd/RnxEphFileAdapter.cpp
// Function: bamboo::RnxEphFileAdapter::v_readOrbit(char const*, int, double, double*, int*)
int RnxEphFileAdapter::v_readOrbit(const char* cprn, int mjd, double sod,
		double* xsat, int* iode) {
	// using rinex navigation file to acquire orbit
	// using rinex navigation file to acquire orbit
	int wk;
	double sow, tgd, dtmin, sclk;
	mjd2wksow(mjd, sod, &wk, &sow);
	if (cprn[0] != 'R')
		if (cprn[0] == 'C')
			return this->m_brd2xyz("yyy", cprn, wk, sow - 14.0, xsat, &sclk,
					&dtmin, &tgd, iode);
		else
			return this->m_brd2xyz("yyy", cprn, wk, sow, xsat, &sclk, &dtmin,
					&tgd, iode);
	else
		return this->m_gls2xyz("yyy", cprn, wk, sow, xsat, &sclk, &dtmin, iode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x88, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movsd %xmm0, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movl -0x24(%rbp), %edi
movsd -0x30(%rbp), %xmm0
leaq -0x44(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x33810
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x52, %eax
je 0xba220
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x43, %eax
jne 0xba1ce
movq -0x70(%rbp), %rax
movq %rax, %rdi
addq $0x6d0, %rdi            # imm = 0x6D0
movq -0x20(%rbp), %rdx
movl -0x44(%rbp), %ecx
movsd -0x50(%rbp), %xmm0
movsd 0x2d59(%rip), %xmm1     # 0xbcee8
subsd %xmm1, %xmm0
movq -0x38(%rbp), %r8
movq -0x40(%rbp), %r10
movq 0x6d0(%rax), %rax
leaq 0x120f7(%rip), %rsi     # 0xcc2a0
leaq -0x68(%rbp), %r9
leaq -0x60(%rbp), %rbx
leaq -0x58(%rbp), %r11
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
callq *0x10(%rax)
movl %eax, -0xc(%rbp)
jmp 0xba267
movq -0x70(%rbp), %rax
movq %rax, %rdi
addq $0x6d0, %rdi            # imm = 0x6D0
movq -0x20(%rbp), %rdx
movl -0x44(%rbp), %ecx
movsd -0x50(%rbp), %xmm0
movq -0x38(%rbp), %r8
movq -0x40(%rbp), %r10
movq 0x6d0(%rax), %rax
leaq 0x120a2(%rip), %rsi     # 0xcc2a0
leaq -0x68(%rbp), %r9
leaq -0x60(%rbp), %rbx
leaq -0x58(%rbp), %r11
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
callq *0x10(%rax)
movl %eax, -0xc(%rbp)
jmp 0xba267
movq -0x70(%rbp), %rax
movq %rax, %rdi
addq $0x6d0, %rdi            # imm = 0x6D0
movq -0x20(%rbp), %rdx
movl -0x44(%rbp), %ecx
movsd -0x50(%rbp), %xmm0
movq -0x38(%rbp), %r8
movq -0x40(%rbp), %r10
movq 0x6d0(%rax), %rax
leaq 0x12050(%rip), %rsi     # 0xcc2a0
leaq -0x68(%rbp), %r9
leaq -0x60(%rbp), %r11
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
callq *0x18(%rax)
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
nopw %cs:(%rax,%rax)