LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::time2sec(bamboo::gtime_t, bamboo::gtime_t*)
static double time2sec(gtime_t time, gtime_t *day)
{
    double ep[6],sec;
    time2epoch(time,ep);
    sec=ep[3]*3600.0+ep[4]*60.0+ep[5];
    ep[3]=ep[4]=ep[5]=0.0;
    *day=epoch2time(ep);
    return sec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x50(%rbp), %rsi
movq -0x68(%rbp), %rdi
movsd -0x60(%rbp), %xmm0
callq 0x8e2f0
movsd -0x38(%rbp), %xmm0
movsd 0x2d941(%rip), %xmm1    # 0xbce18
mulsd -0x30(%rbp), %xmm1
movsd 0x2d92c(%rip), %xmm2    # 0xbce10
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x8e180
movq %rax, -0x78(%rbp)
movsd %xmm0, -0x70(%rbp)
movq -0x18(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %rcx, (%rax)
movq -0x70(%rbp), %rcx
movq %rcx, 0x8(%rax)
movsd -0x58(%rbp), %xmm0
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::time2str(bamboo::gtime_t, char*, int)
extern void time2str(gtime_t t, char *s, int n)
{
    double ep[6];
    
    if (n<0) n=0; else if (n>12) n=12;
    if (1.0-t.sec<0.5/pow(10.0,n)) {t.time++; t.sec=0.0;};
    time2epoch(t,ep);
    sprintf(s,"%04.0f/%02.0f/%02.0f %02.0f:%02.0f:%0*.*f",ep[0],ep[1],ep[2],
            ep[3],ep[4],n<=0?2:n+3,n<=0?0:n,ep[5]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x8f57a
movl $0x0, -0x1c(%rbp)
jmp 0x8f589
cmpl $0xc, -0x1c(%rbp)
jle 0x8f587
movl $0xc, -0x1c(%rbp)
jmp 0x8f589
movsd 0x2c8cf(%rip), %xmm0    # 0xbbe60
subsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
movl -0x1c(%rbp), %edi
movsd 0x2da5a(%rip), %xmm0    # 0xbd000
callq 0x38f40
movsd -0x68(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd 0x2d8c5(%rip), %xmm0    # 0xbce80
divsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x8f5d9
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rsi
movq -0x60(%rbp), %rdi
movsd -0x58(%rbp), %xmm0
callq 0x8e2f0
movq -0x18(%rbp), %rax
movq %rax, -0x98(%rbp)
movsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x90(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x88(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x80(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0x8f651
movl $0x2, %eax
movl %eax, -0x9c(%rbp)
jmp 0x8f65d
movl -0x1c(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x9c(%rbp)
movl -0x9c(%rbp), %eax
movl %eax, -0xa0(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0x8f679
xorl %eax, %eax
movl %eax, -0xa4(%rbp)
jmp 0x8f682
movl -0x1c(%rbp), %eax
movl %eax, -0xa4(%rbp)
movl -0xa0(%rbp), %edx
movsd -0x70(%rbp), %xmm4
movsd -0x78(%rbp), %xmm3
movsd -0x80(%rbp), %xmm2
movsd -0x88(%rbp), %xmm1
movsd -0x90(%rbp), %xmm0
movq -0x98(%rbp), %rdi
movl -0xa4(%rbp), %ecx
movsd -0x28(%rbp), %xmm5
leaq 0x382d6(%rip), %rsi     # 0xc7996
movb $0x6, %al
callq 0x9150
addq $0xb0, %rsp
popq %rbp
retq
// File: DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::tickget()
extern unsigned int tickget(void)
{
#ifdef WIN32
    return (unsigned int)timeGetTime();
#else
    struct timespec tp={0};
    struct timeval  tv={0};
    
#ifdef CLOCK_MONOTONIC_RAW
    /* linux kernel > 2.6.28 */
    if (!clock_gettime(CLOCK_MONOTONIC_RAW,&tp)) {
        return tp.tv_sec*1000u+tp.tv_nsec/1000000u;
    }
    else {
        gettimeofday(&tv,NULL);
        return tv.tv_sec*1000u+tv.tv_usec/1000u;
    }
#else
    gettimeofday(&tv,NULL);
    return tv.tv_sec*1000u+tv.tv_usec/1000u;
#endif
#endif /* WIN32 */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x93d0
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x93d0
movl $0x4, %edi
leaq -0x18(%rbp), %rsi
callq 0x96d0
cmpl $0x0, %eax
jne 0x8f8c4
imulq $0x3e8, -0x18(%rbp), %rax # imm = 0x3E8
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
movq %rax, %rcx
movq -0x30(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x4(%rbp)
jmp 0x8f8f8
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9bf0
imulq $0x3e8, -0x28(%rbp), %rax # imm = 0x3E8
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
movq %rax, %rcx
movq -0x38(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::sleepms(int)
extern void sleepms(int ms)
{
#ifdef WIN32
    if (ms<5) Sleep(1); else Sleep(ms);
#else
    struct timespec ts;
    if (ms<=0) return;
    ts.tv_sec=(time_t)(ms/1000);
    ts.tv_nsec=(long)(ms%1000*1000000);
    nanosleep(&ts,NULL);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jg 0x8f923
jmp 0x8f958
movl -0x4(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
cltq
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
imull $0xf4240, %edx, %eax    # imm = 0xF4240
cltq
movq %rax, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9230
addq $0x20, %rsp
popq %rbp
retq
nop
// File: DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::deg2dms(double, double*, int)
extern void deg2dms(double deg, double *dms, int ndec)
{
    double sign=deg<0.0?-1.0:1.0,a=fabs(deg);
    double unit=pow(0.1,ndec);
    dms[0]=floor(a); a=(a-dms[0])*60.0;
    dms[1]=floor(a); a=(a-dms[1])*60.0;
    dms[2]=floor(a/unit+0.5)*unit;
    if (dms[2]>=60.0) {
        dms[2]=0.0;
        dms[1]+=1.0;
        if (dms[1]>=60.0) {
            dms[1]=0.0;
            dms[0]+=1.0;
        }
    }
    dms[0]*=sign;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x2f457(%rip), %xmm3    # 0xbedd8
movsd 0x2c4d7(%rip), %xmm2    # 0xbbe60
xorps %xmm1, %xmm1
cmpltsd %xmm1, %xmm0
movaps %xmm0, %xmm1
andpd %xmm3, %xmm1
andnpd %xmm2, %xmm0
orpd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x8(%rbp), %xmm0
movaps 0x2d86f(%rip), %xmm1    # 0xbd220
pand %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x14(%rbp), %edi
movsd 0x2e38b(%rip), %xmm0    # 0xbdd50
callq 0x38f40
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x9c90
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x28(%rbp), %xmm0
movq -0x10(%rbp), %rax
subsd (%rax), %xmm0
movsd 0x2d422(%rip), %xmm1    # 0xbce18
mulsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x9c90
movq -0x10(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movsd -0x28(%rbp), %xmm0
movq -0x10(%rbp), %rax
subsd 0x8(%rax), %xmm0
movsd 0x2d3f0(%rip), %xmm1    # 0xbce18
mulsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
divsd -0x30(%rbp), %xmm0
movsd 0x2d43d(%rip), %xmm1    # 0xbce80
addsd %xmm1, %xmm0
callq 0x9c90
mulsd -0x30(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd 0x2d3ad(%rip), %xmm1    # 0xbce18
ucomisd %xmm1, %xmm0
jb 0x8facc
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x10(%rbp), %rax
movsd 0x2c3d7(%rip), %xmm0    # 0xbbe60
addsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd 0x2d374(%rip), %xmm1    # 0xbce18
ucomisd %xmm1, %xmm0
jb 0x8faca
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
movsd 0x2c39e(%rip), %xmm0    # 0xbbe60
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
jmp 0x8facc
movsd -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::pos2ecef(double const*, double*)
extern void pos2ecef(const double *pos, double *r)
{
    double sinp=sin(pos[0]),cosp=cos(pos[0]),sinl=sin(pos[1]),cosl=cos(pos[1]);
    double e2=FE_WGS84*(2.0-FE_WGS84),v=RE_WGS84/sqrt(1.0-e2*sinp*sinp);
    
    r[0]=(v+pos[2])*cosp*cosl;
    r[1]=(v+pos[2])*cosp*sinl;
    r[2]=(v*(1.0-e2)+pos[2])*sinp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
callq 0x91a0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
callq 0x9e00
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0x91a0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0x9e00
movsd %xmm0, -0x30(%rbp)
movsd 0x37606(%rip), %xmm0    # 0xc7428
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm1, %xmm0
movsd 0x2c007(%rip), %xmm1    # 0xbbe60
addsd %xmm1, %xmm0
callq 0x95e0
movaps %xmm0, %xmm1
movsd 0x2cfdb(%rip), %xmm0    # 0xbce48
divsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movq -0x8(%rbp), %rax
addsd 0x10(%rax), %xmm0
mulsd -0x20(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x40(%rbp), %xmm0
movq -0x8(%rbp), %rax
addsd 0x10(%rax), %xmm0
mulsd -0x20(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movsd -0x40(%rbp), %xmm0
movsd 0x2bf9c(%rip), %xmm2    # 0xbbe60
subsd -0x38(%rbp), %xmm2
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
mulsd -0x18(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::xyz2enu(double const*, double*)
extern void xyz2enu(const double *pos, double *E)
{
    double sinp=sin(pos[0]),cosp=cos(pos[0]),sinl=sin(pos[1]),cosl=cos(pos[1]);
    
    E[0]=-sinl;      E[3]=cosl;       E[6]=0.0;
    E[1]=-sinp*cosl; E[4]=-sinp*sinl; E[7]=cosp;
    E[2]=cosp*cosl;  E[5]=cosp*sinl;  E[8]=sinp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
callq 0x91a0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
callq 0x9e00
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0x91a0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0x9e00
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x30(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rax)
movsd -0x18(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd -0x30(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movsd -0x18(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd -0x28(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movsd -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x38(%rax)
movsd -0x20(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x20(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x28(%rax)
movsd -0x18(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x40(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::ast_args(double, double*)
static void ast_args(double t, double *f)
{
    static const double fc[][5]={ /* coefficients for iau 1980 nutation */
        { 134.96340251, 1717915923.2178,  31.8792,  0.051635, -0.00024470},
        { 357.52910918,  129596581.0481,  -0.5532,  0.000136, -0.00001149},
        {  93.27209062, 1739527262.8478, -12.7512, -0.001037,  0.00000417},
        { 297.85019547, 1602961601.2090,  -6.3706,  0.006593, -0.00003169},
        { 125.04455501,   -6962890.2665,   7.4722,  0.007702, -0.00005939}
    };
    double tt[4];
    int i,j;
    
    for (tt[0]=t,i=1;i<4;i++) tt[i]=tt[i-1]*t;
    for (i=0;i<5;i++) {
        f[i]=fc[i][0]*3600.0;
        for (j=0;j<4;j++) f[i]+=fc[i][j+1]*tt[j];
        f[i]=fmod(f[i]*AS2R,2.0*pi);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x1, -0x34(%rbp)
cmpl $0x4, -0x34(%rbp)
jge 0x91150
movl -0x34(%rbp), %eax
subl $0x1, %eax
cltq
movsd -0x30(%rbp,%rax,8), %xmm0
mulsd -0x8(%rbp), %xmm0
movslq -0x34(%rbp), %rax
movsd %xmm0, -0x30(%rbp,%rax,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x91122
movl $0x0, -0x34(%rbp)
cmpl $0x5, -0x34(%rbp)
jge 0x91225
movslq -0x34(%rbp), %rcx
leaq 0x33964(%rip), %rax     # 0xc4ad0
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsd 0x2bc95(%rip), %xmm0    # 0xbce10
mulsd (%rax), %xmm0
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl $0x0, -0x38(%rbp)
cmpl $0x4, -0x38(%rbp)
jge 0x911e8
movslq -0x34(%rbp), %rcx
leaq 0x3392c(%rip), %rax     # 0xc4ad0
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl -0x38(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movslq -0x38(%rbp), %rax
movsd -0x30(%rbp,%rax,8), %xmm2
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x91193
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd 0x36240(%rip), %xmm0    # 0xc7438
mulsd (%rax,%rcx,8), %xmm0
movsd 0x2bc5b(%rip), %xmm1    # 0xbce60
callq 0x99f0
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x91157
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::readpcv(char const*, bamboo::pcvs_t*)
extern int readpcv(const char *file, pcvs_t *pcvs)
{
    pcv_t *pcv;
    char *ext;
    int i,stat;
    
    trace(3,"readpcv: file=%s\n",file);
    char p_file[1024] = {0};
    strcpy(p_file,file);
    if (!(ext=strrchr(p_file,'.'))) ext="";
    
    if (!strcmp(ext,".atx")||!strcmp(ext,".ATX")) {
        stat=readantex(file,pcvs);
    }
    else {
        stat=readngspcv(file,pcvs);
    }
    for (i=0;i<pcvs->n;i++) {
        pcv=pcvs->pcv+i;
        trace(4,"sat=%2d type=%20s code=%s off=%8.4f %8.4f %8.4f  %8.4f %8.4f %8.4f\n",
              pcv->sat,pcv->type,pcv->code,pcv->off[0][0],pcv->off[0][1],
              pcv->off[0][2],pcv->off[1][0],pcv->off[1][1],pcv->off[1][2]);
    }
    return stat;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdx
movl $0x3, %edi
leaq 0x365d7(%rip), %rsi     # 0xc79fa
movb $0x0, %al
callq 0x8b980
leaq -0x430(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x93d0
leaq -0x430(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x96f0
leaq -0x430(%rbp), %rdi
movl $0x2e, %esi
callq 0x9820
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x91473
leaq 0x2b898(%rip), %rax     # 0xbcd07
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x3658e(%rip), %rsi     # 0xc7a0c
callq 0x9a60
cmpl $0x0, %eax
je 0x9149d
movq -0x20(%rbp), %rdi
leaq 0x3657e(%rip), %rsi     # 0xc7a11
callq 0x9a60
cmpl $0x0, %eax
jne 0x914af
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x91580
movl %eax, -0x28(%rbp)
jmp 0x914bf
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x91b70
movl %eax, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x9156e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
imulq $0x2b8, %rcx, %rcx      # imm = 0x2B8
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %edx
movq -0x18(%rbp), %rcx
addq $0x4, %rcx
movq -0x18(%rbp), %r8
addq $0x44, %r8
movq -0x18(%rbp), %rax
movsd 0xa8(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd 0xb0(%rax), %xmm1
movq -0x18(%rbp), %rax
movsd 0xb8(%rax), %xmm2
movq -0x18(%rbp), %rax
movsd 0xc0(%rax), %xmm3
movq -0x18(%rbp), %rax
movsd 0xc8(%rax), %xmm4
movq -0x18(%rbp), %rax
movsd 0xd0(%rax), %xmm5
movl $0x4, %edi
leaq 0x364bd(%rip), %rsi     # 0xc7a16
movb $0x6, %al
callq 0x8b980
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x914c6
movl -0x28(%rbp), %eax
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::readblq(char const*, char const*, double*)
extern int readblq(const char *file, const char *sta, double *odisp)
{
    FILE *fp;
    char buff[256],staname[32]="",name[32],*p;
    
    /* station name to upper case */
    sscanf(sta,"%16s",staname);
    for (p=staname;(*p=(char)toupper((int)(*p)));p++) ;
    
    if (!(fp=fopen(file,"r"))) {
        trace(2,"blq file open error: file=%s\n",file);
        return 0;
    }
    while (fgets(buff,sizeof(buff),fp)) {
        if (!strncmp(buff,"$$",2)||strlen(buff)<2) continue;
        
        if (sscanf(buff+2,"%16s",name)<1) continue;
        for (p=name;(*p=(char)toupper((int)(*p)));p++) ;
        if (strcmp(name,staname)) continue;
        
        /* read blq record */
        if (readblqrecord(fp,odisp)) {
            fclose(fp);
            return 1;
        }
    }
    fclose(fp);
    trace(2,"no otl parameters: sta=%s file=%s\n",sta,file);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x150(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x93d0
movq -0x18(%rbp), %rdi
leaq -0x150(%rbp), %rdx
leaq 0x35648(%rip), %rsi     # 0xc7ae4
movb $0x0, %al
callq 0x9750
leaq -0x150(%rbp), %rax
movq %rax, -0x178(%rbp)
movq -0x178(%rbp), %rax
movsbl (%rax), %edi
callq 0x9ec8
movq -0x178(%rbp), %rcx
movb %al, (%rcx)
cmpb $0x0, %al
je 0x924e3
jmp 0x924cf
movq -0x178(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x178(%rbp)
jmp 0x924b1
movq -0x10(%rbp), %rdi
leaq 0x359b1(%rip), %rsi     # 0xc7e9f
callq 0x98d0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x92520
movq -0x10(%rbp), %rdx
movl $0x2, %edi
leaq 0x355dc(%rip), %rsi     # 0xc7ae9
movb $0x0, %al
callq 0x8b980
movl $0x0, -0x4(%rbp)
jmp 0x9264a
jmp 0x92522
leaq -0x130(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0x100, %esi            # imm = 0x100
callq 0x9ba0
cmpq $0x0, %rax
je 0x9261f
leaq -0x130(%rbp), %rdi
leaq 0x355b8(%rip), %rsi     # 0xc7b07
movl $0x2, %edx
callq 0x9360
cmpl $0x0, %eax
je 0x92570
leaq -0x130(%rbp), %rdi
callq 0x92e0
cmpq $0x2, %rax
jae 0x92572
jmp 0x92522
leaq -0x130(%rbp), %rdi
addq $0x2, %rdi
leaq -0x170(%rbp), %rdx
leaq 0x35559(%rip), %rsi     # 0xc7ae4
movb $0x0, %al
callq 0x9750
cmpl $0x1, %eax
jge 0x92599
jmp 0x92522
leaq -0x170(%rbp), %rax
movq %rax, -0x178(%rbp)
movq -0x178(%rbp), %rax
movsbl (%rax), %edi
callq 0x9ec8
movq -0x178(%rbp), %rcx
movb %al, (%rcx)
cmpb $0x0, %al
je 0x925d9
jmp 0x925c5
movq -0x178(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x178(%rbp)
jmp 0x925a7
leaq -0x170(%rbp), %rdi
leaq -0x150(%rbp), %rsi
callq 0x9a60
cmpl $0x0, %eax
je 0x925f6
jmp 0x92522
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x92660
cmpl $0x0, %eax
je 0x9261a
movq -0x28(%rbp), %rdi
callq 0x9770
movl $0x1, -0x4(%rbp)
jmp 0x9264a
jmp 0x92522
movq -0x28(%rbp), %rdi
callq 0x9770
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x2, %edi
leaq 0x354ce(%rip), %rsi     # 0xc7b0a
movb $0x0, %al
callq 0x8b980
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::readblqrecord(_IO_FILE*, double*)
static int readblqrecord(FILE *fp, double *odisp)
{
    double v[11];
    char buff[256];
    int i,n=0;
    
    while (fgets(buff,sizeof(buff),fp)) {
        if (!strncmp(buff,"$$",2)) continue;
        if (sscanf(buff,"%lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf",
                   v,v+1,v+2,v+3,v+4,v+5,v+6,v+7,v+8,v+9,v+10)<11) continue;
        for (i=0;i<11;i++) odisp[n+i*6]=v[i];
        if (++n==6) return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movl $0x0, -0x198(%rbp)
leaq -0x190(%rbp), %rdi
movq -0x30(%rbp), %rdx
movl $0x100, %esi            # imm = 0x100
callq 0x9ba0
cmpq $0x0, %rax
je 0x927e9
leaq -0x190(%rbp), %rdi
leaq 0x35456(%rip), %rsi     # 0xc7b07
movl $0x2, %edx
callq 0x9360
cmpl $0x0, %eax
jne 0x926c2
jmp 0x92684
leaq -0x190(%rbp), %rdi
leaq -0x90(%rbp), %rdx
leaq -0x90(%rbp), %rcx
addq $0x8, %rcx
leaq -0x90(%rbp), %r8
addq $0x10, %r8
leaq -0x90(%rbp), %r9
addq $0x18, %r9
leaq -0x90(%rbp), %r12
addq $0x20, %r12
leaq -0x90(%rbp), %r15
addq $0x28, %r15
leaq -0x90(%rbp), %r14
addq $0x30, %r14
leaq -0x90(%rbp), %rbx
addq $0x38, %rbx
leaq -0x90(%rbp), %r11
addq $0x40, %r11
leaq -0x90(%rbp), %r10
addq $0x48, %r10
leaq -0x90(%rbp), %rax
addq $0x50, %rax
leaq 0x35424(%rip), %rsi     # 0xc7b69
movq %r12, (%rsp)
movq %r15, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
movq %r11, 0x20(%rsp)
movq %r10, 0x28(%rsp)
movq %rax, 0x30(%rsp)
movb $0x0, %al
callq 0x9750
cmpl $0xb, %eax
jge 0x92778
jmp 0x92684
movl $0x0, -0x194(%rbp)
cmpl $0xb, -0x194(%rbp)
jge 0x927c7
movslq -0x194(%rbp), %rax
movsd -0x90(%rbp,%rax,8), %xmm0
movq -0x38(%rbp), %rax
movl -0x198(%rbp), %ecx
imull $0x6, -0x194(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x194(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x194(%rbp)
jmp 0x92782
movl -0x198(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x198(%rbp)
cmpl $0x6, %eax
jne 0x927e4
movl $0x1, -0x24(%rbp)
jmp 0x927f0
jmp 0x92684
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::uniqnav(bamboo::nav_t*)
extern void uniqnav(nav_t *nav)
{
    int i,j;
    
    trace(3,"uniqnav: neph=%d ngeph=%d nseph=%d\n",nav->n,nav->ng,nav->ns);
    
    /* unique ephemeris */
    uniqeph (nav);
    uniqgeph(nav);
    uniqseph(nav);
    
    /* update carrier wave length */
    for (i=0;i<MAXRTKSAT;i++) for (j=0;j<NFREQ;j++) {
        nav->lam[i][j]=satwavelen(i+1,j,nav);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x10(%rax), %r8d
movl $0x3, %edi
leaq 0x34941(%rip), %rsi     # 0xc7b9e
movb $0x0, %al
callq 0x8b980
movq -0x8(%rbp), %rdi
callq 0x932f0
movq -0x8(%rbp), %rdi
callq 0x934d0
movq -0x8(%rbp), %rdi
callq 0x936f0
movl $0x0, -0xc(%rbp)
cmpl $0x9b, -0xc(%rbp)
jge 0x932e4
movl $0x0, -0x10(%rbp)
cmpl $0x3, -0x10(%rbp)
jge 0x932d7
movl -0xc(%rbp), %edi
addl $0x1, %edi
movl -0x10(%rbp), %esi
movq -0x8(%rbp), %rdx
callq 0x938e0
movq -0x8(%rbp), %rax
addq $0x298, %rax            # imm = 0x298
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x93296
jmp 0x932d9
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x93286
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::cmpobs(void const*, void const*)
static int cmpobs(const void *p1, const void *p2)
{
    obsd_t *q1=(obsd_t *)p1,*q2=(obsd_t *)p2;
    double tt=timediff(q1->time,q2->time);
    if (fabs(tt)>DTTOL) return tt<0?-1:1;
    if (q1->rcv!=q2->rcv) return (int)q1->rcv-(int)q2->rcv;
    return (int)q1->sat-(int)q2->sat;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x50(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movsd -0x38(%rbp), %xmm0
movq -0x50(%rbp), %rsi
movsd -0x48(%rbp), %xmm1
callq 0x8e8e0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movaps 0x293d2(%rip), %xmm1    # 0xbd220
pand %xmm1, %xmm0
movsd 0x336be(%rip), %xmm1    # 0xc7518
ucomisd %xmm1, %xmm0
jbe 0x93e7e
movsd -0x30(%rbp), %xmm1
xorps %xmm0, %xmm0
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
ucomisd %xmm1, %xmm0
cmoval %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x93ebe
movq -0x20(%rbp), %rax
movzbl 0x11(%rax), %eax
movq -0x28(%rbp), %rcx
movzbl 0x11(%rcx), %ecx
cmpl %ecx, %eax
je 0x93ea9
movq -0x20(%rbp), %rax
movzbl 0x11(%rax), %eax
movq -0x28(%rbp), %rcx
movzbl 0x11(%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x93ebe
movq -0x20(%rbp), %rax
movzbl 0x10(%rax), %eax
movq -0x28(%rbp), %rcx
movzbl 0x10(%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::freenav(bamboo::nav_t*, int)
extern void freenav(nav_t *nav, int opt)
{
    if (opt&0x01) {free(nav->eph ); nav->eph =NULL; nav->n =nav->nmax =0;}
    if (opt&0x02) {free(nav->geph); nav->geph=NULL; nav->ng=nav->ngmax=0;}
    if (opt&0x04) {free(nav->seph); nav->seph=NULL; nav->ns=nav->nsmax=0;}
    if (opt&0x08) {free(nav->peph); nav->peph=NULL; nav->ne=nav->nemax=0;}
    if (opt&0x10) {free(nav->pclk); nav->pclk=NULL; nav->nc=nav->ncmax=0;}
    if (opt&0x20) {free(nav->alm ); nav->alm =NULL; nav->na=nav->namax=0;}
    if (opt&0x40) {free(nav->tec ); nav->tec =NULL; nav->nt=nav->ntmax=0;}
    if (opt&0x80) {free(nav->fcb ); nav->fcb =NULL; nav->nf=nav->nfmax=0;}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x956b8
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x9900
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movl -0xc(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x956f2
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x9900
movq -0x8(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movl -0xc(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x9572c
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x9900
movq -0x8(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movl -0xc(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x95766
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x9900
movq -0x8(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movl -0xc(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x957a0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x9900
movq -0x8(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movl -0xc(%rbp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x957da
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x9900
movq -0x8(%rbp), %rax
movq $0x0, 0x68(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x28(%rax)
movl -0xc(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x95814
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x9900
movq -0x8(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x34(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
movl -0xc(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x95850
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x9900
movq -0x8(%rbp), %rax
movq $0x0, 0x78(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x3c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x38(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::createdir(char const*)
extern void createdir(const char *path)
{
    char buff[1024],*p;
    
    tracet(3,"createdir: path=%s\n",path);
    
    strcpy(buff,path);
    if (!(p=strrchr(buff,FILEPATHSEP))) return;
    *p='\0';
    
#ifdef WIN32
    CreateDirectory(buff,NULL);
#else
    mkdir(buff,0777);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdx
movl $0x3, %edi
leaq 0x320c9(%rip), %rsi     # 0xc7e88
movb $0x0, %al
callq 0x95890
leaq -0x410(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x96f0
leaq -0x410(%rbp), %rdi
movl $0x2f, %esi
callq 0x9820
movq %rax, -0x418(%rbp)
cmpq $0x0, %rax
jne 0x95df6
jmp 0x95e11
movq -0x418(%rbp), %rax
movb $0x0, (%rax)
leaq -0x410(%rbp), %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x9330
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::repstr(char*, char const*, char const*)
static int repstr(char *str, const char *pat, const char *rep)
{
    int len=(int)strlen(pat);
    char buff[1024],*p,*q,*r;
    
    for (p=str,r=buff;*p;p=q+len) {
        if (!(q=strstr(p,pat))) break;
        strncpy(r,p,q-p);
        r+=q-p;
        r+=sprintf(r,"%s",rep);
    }
    if (p<=str) return 0;
    strcpy(r,p);
    strcpy(str,buff);
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x450, %rsp            # imm = 0x450
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x92e0
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x438(%rbp)
leaq -0x430(%rbp), %rax
movq %rax, -0x448(%rbp)
movq -0x438(%rbp), %rax
cmpb $0x0, (%rax)
je 0x9669a
movq -0x438(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x91b0
movq %rax, -0x440(%rbp)
cmpq $0x0, %rax
jne 0x9660e
jmp 0x9669a
movq -0x448(%rbp), %rdi
movq -0x438(%rbp), %rsi
movq -0x440(%rbp), %rdx
movq -0x438(%rbp), %rax
subq %rax, %rdx
callq 0x93b0
movq -0x440(%rbp), %rax
movq -0x438(%rbp), %rcx
subq %rcx, %rax
addq -0x448(%rbp), %rax
movq %rax, -0x448(%rbp)
movq -0x448(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x32784(%rip), %rsi     # 0xc8de7
movb $0x0, %al
callq 0x9150
movl %eax, %ecx
movq -0x448(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x448(%rbp)
movq -0x440(%rbp), %rax
movslq -0x24(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x438(%rbp)
jmp 0x965dc
movq -0x438(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0x966b0
movl $0x0, -0x4(%rbp)
jmp 0x966da
movq -0x448(%rbp), %rdi
movq -0x438(%rbp), %rsi
callq 0x96f0
movq -0x10(%rbp), %rdi
leaq -0x430(%rbp), %rsi
callq 0x96f0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x450, %rsp            # imm = 0x450
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::geodist(double const*, double const*, double*)
extern double geodist(const double *rs, const double *rr, double *e)
{
    double r;
    int i;
    
    if (norm(rs,3)<RE_WGS84) return -1.0;
    for (i=0;i<3;i++) e[i]=rs[i]-rr[i];
    r=norm(e,3);
    for (i=0;i<3;i++) e[i]/=r;
    return r+OMGE*(rs[0]*rr[1]-rs[1]*rr[0])/CLIGHT;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x8c820
movaps %xmm0, %xmm1
movsd 0x263ab(%rip), %xmm0    # 0xbce48
ucomisd %xmm1, %xmm0
jbe 0x96ab5
movsd 0x2832d(%rip), %xmm0    # 0xbedd8
movsd %xmm0, -0x8(%rbp)
jmp 0x96ba1
movl $0x0, -0x2c(%rbp)
cmpl $0x3, -0x2c(%rbp)
jge 0x96af4
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x96abc
movq -0x20(%rbp), %rdi
movl $0x3, %esi
callq 0x8c820
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x3, -0x2c(%rbp)
jge 0x96b3a
movsd -0x28(%rbp), %xmm1
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x96b0e
movsd -0x28(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd (%rax), %xmm2
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm3
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm1
movq -0x18(%rbp), %rax
mulsd (%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm3, %xmm2
addsd %xmm1, %xmm2
movsd 0x309a8(%rip), %xmm1    # 0xc7530
mulsd %xmm2, %xmm1
movsd 0x27214(%rip), %xmm2    # 0xbdda8
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::satazel(double const*, double const*, double*)
extern double satazel(const double *pos, const double *e, double *azel)
{
    double az=0.0,el=pi/2.0,enu[3];
    
    if (pos[2]>-RE_WGS84) {
        ecef2enu(pos,e,enu);
        az=rtk_dot(enu,enu,2)<1E-12?0.0:atan2(enu[0],enu[1]);
        if (az<0.0) az+=2*pi;
        el=asin(enu[2]);
    }
    if (azel) {azel[0]=az; azel[1]=el;}
    return el;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x262a4(%rip), %xmm0    # 0xbce78
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd 0x3094e(%rip), %xmm1    # 0xc7538
ucomisd %xmm1, %xmm0
jbe 0x96c7b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x90030
leaq -0x40(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x2, %edx
callq 0x8c7c0
movaps %xmm0, %xmm1
movsd 0x3080e(%rip), %xmm0    # 0xc7430
ucomisd %xmm1, %xmm0
jbe 0x96c32
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
jmp 0x96c46
movsd -0x40(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
callq 0x90f0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x20(%rbp), %xmm0
jbe 0x96c6c
movsd 0x261fe(%rip), %xmm0    # 0xbce60
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x9c40
movsd %xmm0, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x96c9d
movsd -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movsd -0x28(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::tropmapf(bamboo::gtime_t, double const*, double const*, double*)
extern double tropmapf(gtime_t time, const double pos[], const double azel[],
                       double *mapfw)
{
#ifdef IERS_MODEL
    const double ep[]={2000,1,1,12,0,0};
    double mjd,lat,lon,hgt,zd,gmfh,gmfw;
#endif
    trace(4,"tropmapf: pos=%10.6f %11.6f %6.1f azel=%5.1f %4.1f\n",
          pos[0]*R2D,pos[1]*R2D,pos[2],azel[0]*R2D,azel[1]*R2D);
    
    if (pos[2]<-1000.0||pos[2]>20000.0) {
        if (mapfw) *mapfw=0.0;
        return 0.0;
    }
#ifdef IERS_MODEL
    mjd=51544.5+(timediff(time,epoch2time(ep)))/86400.0;
    lat=pos[0];
    lon=pos[1];
    hgt=pos[2]-geoidh(pos); /* height in m (mean sea level) */
    zd =pi/2.0-azel[1];
    
    /* call GMF */
    gmf_(&mjd,&lat,&lon,&hgt,&zd,&gmfh,&gmfw);
    
    if (mapfw) *mapfw=gmfw;
    return gmfh;
#else
    return nmf(time,pos,azel,mapfw); /* NMF */
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x20(%rbp), %rax
movsd 0x28ca7(%rip), %xmm0    # 0xc09f0
mulsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd 0x28c97(%rip), %xmm1    # 0xc09f0
mulsd 0x8(%rax), %xmm1
movq -0x20(%rbp), %rax
movsd 0x10(%rax), %xmm2
movq -0x28(%rbp), %rax
movsd 0x28c7d(%rip), %xmm3    # 0xc09f0
mulsd (%rax), %xmm3
movq -0x28(%rbp), %rax
movsd 0x28c6d(%rip), %xmm4    # 0xc09f0
mulsd 0x8(%rax), %xmm4
movl $0x4, %edi
leaq 0x3018f(%rip), %rsi     # 0xc7f23
movb $0x5, %al
callq 0x8b980
movq -0x20(%rbp), %rax
movsd 0x2f799(%rip), %xmm0    # 0xc7540
ucomisd 0x10(%rax), %xmm0
ja 0x97dc5
movq -0x20(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd 0x2f891(%rip), %xmm1    # 0xc7650
ucomisd %xmm1, %xmm0
jbe 0x97de1
cmpq $0x0, -0x30(%rbp)
je 0x97dd7
movq -0x30(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x97e10
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rdi
movsd -0x38(%rbp), %xmm0
callq 0x97e20
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::interpvar(double, double const*)
static double interpvar(double ang, const double *var)
{
    double a=ang/5.0; /* ang=0-90 */
    int i=(int)a;
    if (i<0) return var[0]; else if (i>=18) return var[18];
    return var[i]*(1.0-a+i)+var[i+1]*(a-i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
movsd 0x253e6(%rip), %xmm1    # 0xbd770
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
cvttsd2si -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x983b0
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x9841f
cmpl $0x12, -0x24(%rbp)
jl 0x983c9
movq -0x18(%rbp), %rax
movsd 0x90(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x9841f
jmp 0x983cb
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x23a80(%rip), %xmm2    # 0xbbe60
subsd -0x20(%rbp), %xmm2
cvtsi2sdl -0x24(%rbp), %xmm1
addsd %xmm1, %xmm2
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
movsd -0x20(%rbp), %xmm3
cvtsi2sdl -0x24(%rbp), %xmm4
subsd %xmm4, %xmm3
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::antmodel_s(bamboo::pcv_t const*, double, double*)
extern void antmodel_s(const pcv_t *pcv, double nadir, double *dant)
{
    int i;
    
    trace(4,"antmodel_s: nadir=%6.1f\n",nadir*R2D);
    
    for (i=0;i<NFREQ;i++) {
        dant[i]=interpvar(nadir*R2D*5.0,pcv->var[i]);
    }
    trace(5,"antmodel_s: dant=%6.3f %6.3f\n",dant[0],dant[1]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd 0x285a3(%rip), %xmm0    # 0xc09f0
mulsd -0x10(%rbp), %xmm0
movl $0x4, %edi
leaq 0x2fb38(%rip), %rsi     # 0xc7f96
movb $0x1, %al
callq 0x8b980
movl $0x0, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0x984c1
movsd 0x28576(%rip), %xmm0    # 0xc09f0
mulsd -0x10(%rbp), %xmm0
movsd 0x252e9(%rip), %xmm1    # 0xbd770
mulsd %xmm1, %xmm0
movq -0x8(%rbp), %rdi
addq $0xf0, %rdi
movslq -0x1c(%rbp), %rax
imulq $0x98, %rax, %rax
addq %rax, %rdi
callq 0x98370
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9846c
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm1
movl $0x5, %edi
leaq 0x2fad1(%rip), %rsi     # 0xc7faf
movb $0x2, %al
callq 0x8b980
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::sunmoonpos(bamboo::gtime_t, double const*, double*, double*, double*)
extern void sunmoonpos(gtime_t tutc, const double *erpv, double *rsun,
                       double *rmoon, double *gmst)
{
    gtime_t tut;
    double rs[3],rm[3],U[9],gmst_;
    
    trace(4,"sunmoonpos: tutc=%s\n",time_str(tutc,3));
    
    tut=timeadd(tutc,erpv[2]); /* utc -> ut1 */
    
    /* sun and moon position in eci */
    sunmoonpos_eci(tut,rsun?rs:NULL,rmoon?rm:NULL);
    
    /* eci to ecef transformation matrix */
    eci2ecef(tutc,erpv,U,&gmst_);
    
    /* sun and moon postion in ecef */
    if (rsun ) matmul("NN",3,1,3,1.0,U,rs,0.0,rsun );
    if (rmoon) matmul("NN",3,1,3,1.0,U,rm,0.0,rmoon);
    if (gmst ) *gmst=gmst_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0xe8(%rbp), %rdi
movsd -0xe0(%rbp), %xmm0
movl $0x3, %esi
callq 0x8f6d0
movq %rax, %rdx
movl $0x4, %edi
leaq 0x2fa7b(%rip), %rsi     # 0xc7fcd
movb $0x0, %al
callq 0x8b980
movq -0x10(%rbp), %rax
movq %rax, -0x108(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm1
movq -0x108(%rbp), %rdi
movsd -0x100(%rbp), %xmm0
callq 0x8e860
movq %rax, -0xf8(%rbp)
movsd %xmm0, -0xf0(%rbp)
movq -0xf8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0xf0(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x118(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x110(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x985db
leaq -0x60(%rbp), %rax
movq %rax, -0x130(%rbp)
jmp 0x985e6
xorl %eax, %eax
movq %rax, -0x130(%rbp)
jmp 0x985e6
movq -0x130(%rbp), %rax
movq %rax, -0x138(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x98608
leaq -0x80(%rbp), %rax
movq %rax, -0x140(%rbp)
jmp 0x98613
xorl %eax, %eax
movq %rax, -0x140(%rbp)
jmp 0x98613
movq -0x138(%rbp), %rsi
movq -0x140(%rbp), %rdx
movq -0x118(%rbp), %rdi
movsd -0x110(%rbp), %xmm0
callq 0x98710
movq -0x10(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x120(%rbp)
movq -0x18(%rbp), %rsi
leaq -0xd0(%rbp), %rdx
movq -0x128(%rbp), %rdi
movsd -0x120(%rbp), %xmm0
leaq -0xd8(%rbp), %rcx
callq 0x90230
cmpq $0x0, -0x20(%rbp)
je 0x986ae
leaq -0xd0(%rbp), %r8
leaq -0x60(%rbp), %r9
movq -0x20(%rbp), %rax
leaq 0x2f2fe(%rip), %rdi     # 0xc798c
movl $0x3, %ecx
movl $0x1, %edx
movsd 0x237c0(%rip), %xmm0    # 0xbbe60
xorps %xmm1, %xmm1
movl %ecx, %esi
movq %rax, (%rsp)
callq 0x8ca20
cmpq $0x0, -0x28(%rbp)
je 0x986eb
leaq -0xd0(%rbp), %r8
leaq -0x80(%rbp), %r9
movq -0x28(%rbp), %rax
leaq 0x2f2c1(%rip), %rdi     # 0xc798c
movl $0x3, %ecx
movl $0x1, %edx
movsd 0x23783(%rip), %xmm0    # 0xbbe60
xorps %xmm1, %xmm1
movl %ecx, %esi
movq %rax, (%rsp)
callq 0x8ca20
cmpq $0x0, -0x30(%rbp)
je 0x98702
movsd -0xd8(%rbp), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopl (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::addpcv(bamboo::pcv_t const*, bamboo::pcvs_t*)
static void addpcv(const pcv_t *pcv, pcvs_t *pcvs)
{
    pcv_t *pcvs_pcv;
    
    if (pcvs->nmax<=pcvs->n) {
        pcvs->nmax+=256;
        if (!(pcvs_pcv=(pcv_t *)realloc(pcvs->pcv,sizeof(pcv_t)*pcvs->nmax))) {
            trace(1,"addpcv: memory allocation error\n");
            free(pcvs->pcv); pcvs->pcv=NULL; pcvs->n=pcvs->nmax=0;
            return;
        }
        pcvs->pcv=pcvs_pcv;
    }
    pcvs->pcv[pcvs->n++]=*pcv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x99888
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x100, %ecx            # imm = 0x100
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rax
imulq $0x2b8, %rax, %rsi      # imm = 0x2B8
callq 0x9c30
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x9987c
movl $0x1, %edi
leaq 0x2e993(%rip), %rsi     # 0xc81d8
movb $0x0, %al
callq 0x8b980
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x9900
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
jmp 0x998b7
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rcx
movl (%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, (%rcx)
cltq
imulq $0x2b8, %rax, %rax      # imm = 0x2B8
addq %rax, %rdi
movl $0x2b8, %edx            # imm = 0x2B8
callq 0x9610
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::decodef(char*, int, double*)
static int decodef(char *p, int n, double *v)
{
    int i;
    
    for (i=0;i<n;i++) v[i]=0.0;
    for (i=0,p=strtok(p," ");p&&i<n;p=strtok(NULL," ")) {
        v[i++]=atof(p)*1E-3;
    }
    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x998fd
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x998da
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x2e874(%rip), %rsi     # 0xc8183
callq 0x9b70
movq %rax, -0x8(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x1d(%rbp)
je 0x99930
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
setl %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x99939
jmp 0x9997b
movq -0x8(%rbp), %rdi
callq 0x9940
movsd 0x243fe(%rip), %xmm1    # 0xbdd48
mulsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
xorl %eax, %eax
movl %eax, %edi
leaq 0x2e813(%rip), %rsi     # 0xc8183
callq 0x9b70
movq %rax, -0x8(%rbp)
jmp 0x99918
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::cmpeph(void const*, void const*)
static int cmpeph(const void *p1, const void *p2)
{
    eph_t *q1=(eph_t *)p1,*q2=(eph_t *)p2;
    return q1->ttr.time!=q2->ttr.time?(int)(q1->ttr.time-q2->ttr.time):
           (q1->toe.time!=q2->toe.time?(int)(q1->toe.time-q2->toe.time):
            q1->sat-q2->sat);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x40(%rcx), %rax
je 0x999d3
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x20(%rbp), %rcx
subq 0x40(%rcx), %rax
movl %eax, -0x24(%rbp)
jmp 0x99a0f
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0x999fa
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x20(%rbp), %rcx
subq 0x20(%rcx), %rax
movl %eax, -0x28(%rbp)
jmp 0x99a09
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)