LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::time2gpst(bamboo::gtime_t, int*)
extern double time2gpst(gtime_t t, int *week)
{
    gtime_t t0=epoch2time(gpst0);
    time_t sec=t.time-t0.time;
    int w=(int)(sec/(86400*7));
    
    if (week) *week=w;
    return (double)(sec-(double)w*86400*7)+t.sec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movsd %xmm0, -0x18(%rbp)
movq %rdi, %rbx
leaq 0x21592(%rip), %rdi     # 0x686a0
callq 0x46ee2
subq %rax, %rbx
movl $0x93a80, %ecx          # imm = 0x93A80
movq %rbx, %rax
cqto
idivq %rcx
testq %r14, %r14
je 0x4712b
movl %eax, (%r14)
cvtsi2sd %rbx, %xmm1
cvtsi2sd %eax, %xmm0
mulsd 0x1acb4(%rip), %xmm0    # 0x61df0
mulsd 0x1978c(%rip), %xmm0    # 0x608d0
addsd %xmm1, %xmm0
addsd -0x18(%rbp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::gst2time(int, double)
extern gtime_t gst2time(int week, double sec)
{
    gtime_t t=epoch2time(gst0);
    
    if (sec<-1E9||1E9<sec) sec=0.0;
    t.time+=(time_t)86400*7*week+(int)sec;
    t.sec=sec-(int)sec;
    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movaps %xmm0, -0x20(%rbp)
movl %edi, %ebx
leaq 0x21564(%rip), %rdi     # 0x686d0
callq 0x46ee2
movapd 0x187b7(%rip), %xmm1    # 0x5f930
movapd -0x20(%rbp), %xmm2
andpd %xmm2, %xmm1
movsd 0x23a06(%rip), %xmm0    # 0x6ab90
cmpltsd %xmm1, %xmm0
andnpd %xmm2, %xmm0
movslq %ebx, %rcx
imulq $0x93a80, %rcx, %rcx    # imm = 0x93A80
cvttsd2si %xmm0, %edx
movslq %edx, %rdx
addq %rcx, %rax
cvttpd2dq %xmm0, %xmm1
cvtdq2pd %xmm1, %xmm1
addq %rdx, %rax
subsd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::time2gst(bamboo::gtime_t, int*)
extern double time2gst(gtime_t t, int *week)
{
    gtime_t t0=epoch2time(gst0);
    time_t sec=t.time-t0.time;
    int w=(int)(sec/(86400*7));
    
    if (week) *week=w;
    return (double)(sec-(double)w*86400*7)+t.sec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movsd %xmm0, -0x18(%rbp)
movq %rdi, %rbx
leaq 0x214f6(%rip), %rdi     # 0x686d0
callq 0x46ee2
subq %rax, %rbx
movl $0x93a80, %ecx          # imm = 0x93A80
movq %rbx, %rax
cqto
idivq %rcx
testq %r14, %r14
je 0x471f7
movl %eax, (%r14)
cvtsi2sd %rbx, %xmm1
cvtsi2sd %eax, %xmm0
mulsd 0x1abe8(%rip), %xmm0    # 0x61df0
mulsd 0x196c0(%rip), %xmm0    # 0x608d0
addsd %xmm1, %xmm0
addsd -0x18(%rbp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::bdt2time(int, double)
extern gtime_t bdt2time(int week, double sec)
{
    gtime_t t=epoch2time(bdt0);
    
    if (sec<-1E9||1E9<sec) sec=0.0;
    t.time+=(time_t)86400*7*week+(int)sec;
    t.sec=sec-(int)sec;
    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movaps %xmm0, -0x20(%rbp)
movl %edi, %ebx
leaq 0x214c8(%rip), %rdi     # 0x68700
callq 0x46ee2
movapd 0x186eb(%rip), %xmm1    # 0x5f930
movapd -0x20(%rbp), %xmm2
andpd %xmm2, %xmm1
movsd 0x2393a(%rip), %xmm0    # 0x6ab90
cmpltsd %xmm1, %xmm0
andnpd %xmm2, %xmm0
movslq %ebx, %rcx
imulq $0x93a80, %rcx, %rcx    # imm = 0x93A80
cvttsd2si %xmm0, %edx
movslq %edx, %rdx
addq %rcx, %rax
cvttpd2dq %xmm0, %xmm1
cvtdq2pd %xmm1, %xmm1
addq %rdx, %rax
subsd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::time2bdt(bamboo::gtime_t, int*)
extern double time2bdt(gtime_t t, int *week)
{
    gtime_t t0=epoch2time(bdt0);
    time_t sec=t.time-t0.time;
    int w=(int)(sec/(86400*7));
    
    if (week) *week=w;
    return (double)(sec-(double)w*86400*7)+t.sec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movsd %xmm0, -0x18(%rbp)
movq %rdi, %rbx
leaq 0x2145a(%rip), %rdi     # 0x68700
callq 0x46ee2
subq %rax, %rbx
movl $0x93a80, %ecx          # imm = 0x93A80
movq %rbx, %rax
cqto
idivq %rcx
testq %r14, %r14
je 0x472c3
movl %eax, (%r14)
cvtsi2sd %rbx, %xmm1
cvtsi2sd %eax, %xmm0
mulsd 0x1ab1c(%rip), %xmm0    # 0x61df0
mulsd 0x195f4(%rip), %xmm0    # 0x608d0
addsd %xmm1, %xmm0
addsd -0x18(%rbp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::timeget()
extern gtime_t timeget(void)
{
    gtime_t time;
    double ep[6]={0};
#ifdef WIN32
    SYSTEMTIME ts;
    
    GetSystemTime(&ts); /* utc */
    ep[0]=ts.wYear; ep[1]=ts.wMonth;  ep[2]=ts.wDay;
    ep[3]=ts.wHour; ep[4]=ts.wMinute; ep[5]=ts.wSecond+ts.wMilliseconds*1E-3;
#else
    struct timeval tv;
    struct tm *tt;
    
    if (!gettimeofday(&tv,NULL)&&(tt=gmtime(&tv.tv_sec))) {
        ep[0]=tt->tm_year+1900; ep[1]=tt->tm_mon+1; ep[2]=tt->tm_mday;
        ep[3]=tt->tm_hour; ep[4]=tt->tm_min; ep[5]=tt->tm_sec+tv.tv_usec*1E-6;
    }
#endif
    time=epoch2time(ep);
    
#ifdef CPUTIME_IN_GPST /* cputime operated in gpst */
    time=gpst2utc(time);
#endif
    return timeadd(time,timeoffset_);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
xorpd %xmm0, %xmm0
movapd %xmm0, -0x20(%rbp)
movapd %xmm0, -0x30(%rbp)
movapd %xmm0, -0x40(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x8a30
testl %eax, %eax
jne 0x473da
leaq -0x50(%rbp), %rdi
callq 0x8540
testq %rax, %rax
je 0x473da
movl $0x76c, %ecx            # imm = 0x76C
addl 0x14(%rax), %ecx
cvtsi2sd %ecx, %xmm0
movsd %xmm0, -0x40(%rbp)
movl 0x10(%rax), %ecx
incl %ecx
cvtsi2sd %ecx, %xmm0
movsd %xmm0, -0x38(%rbp)
cvtsi2sdl 0xc(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
cvtsi2sdl 0x8(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
cvtsi2sdl 0x4(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
cvtsi2sdl (%rax), %xmm0
cvtsi2sdq -0x48(%rbp), %xmm1
mulsd 0x1b86f(%rip), %xmm1    # 0x62c40
addsd %xmm0, %xmm1
movsd %xmm1, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x46ee2
movq %rax, %rbx
addsd 0x42c0a(%rip), %xmm0    # 0x89ff8
movsd %xmm0, -0x10(%rbp)
callq 0x8ac0
cvttsd2si %xmm0, %eax
cltq
addq %rbx, %rax
movsd -0x10(%rbp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::gpst2utc(bamboo::gtime_t)
extern gtime_t gpst2utc(gtime_t t)
{
    gtime_t tu;
    int i;
    
    for (i=0;leaps[i][0]>0;i++) {
        tu=timeadd(t,leaps[i][6]);
        if (timediff(tu,epoch2time(leaps[i]))>=0.0) return tu;
    }
    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, -0x28(%rbp)
movq %rdi, %rbx
leaq 0x3f922(%rip), %r14     # 0x87070
xorpd %xmm1, %xmm1
movsd (%r14), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x477c0
movsd 0x30(%r14), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x8ac0
cvttsd2si %xmm0, %eax
movslq %eax, %r15
addq %rbx, %r15
movsd -0x20(%rbp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, -0x20(%rbp)
movq %r14, %rdi
callq 0x46ee2
movsd %xmm0, -0x30(%rbp)
movq %r15, %rdi
movq %rax, %rsi
callq 0x8340
movsd -0x20(%rbp), %xmm2
xorpd %xmm1, %xmm1
addsd %xmm2, %xmm0
subsd -0x30(%rbp), %xmm0
addq $0x38, %r14
ucomisd %xmm1, %xmm0
jb 0x47752
jmp 0x477c8
movq %rbx, %r15
movsd -0x28(%rbp), %xmm2
movq %r15, %rax
movapd %xmm2, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::utc2gpst(bamboo::gtime_t)
extern gtime_t utc2gpst(gtime_t t)
{
    int i;
    
    for (i=0;leaps[i][0]>0;i++) {
        if (timediff(t,epoch2time(leaps[i]))>=0.0) return timeadd(t,-leaps[i][6]);
    }
    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movapd %xmm0, %xmm1
movq %rdi, %rbx
leaq 0x3f87d(%rip), %r14     # 0x87070
xorpd %xmm2, %xmm2
movsd %xmm0, -0x18(%rbp)
movsd (%r14), %xmm0
ucomisd %xmm2, %xmm0
jbe 0x47861
movq %r14, %rdi
callq 0x46ee2
movsd %xmm0, -0x20(%rbp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8340
xorpd %xmm2, %xmm2
movsd -0x18(%rbp), %xmm1
addsd %xmm1, %xmm0
subsd -0x20(%rbp), %xmm0
addq $0x38, %r14
ucomisd %xmm2, %xmm0
jb 0x477fc
subsd -0x8(%r14), %xmm1
movsd %xmm1, -0x18(%rbp)
movapd %xmm1, %xmm0
callq 0x8ac0
movsd -0x18(%rbp), %xmm1
cvttsd2si %xmm0, %eax
cltq
addq %rax, %rbx
subsd %xmm0, %xmm1
movq %rbx, %rax
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::utc2gmst(bamboo::gtime_t, double)
extern double utc2gmst(gtime_t t, double ut1_utc)
{
    const double ep2000[]={2000,1,1,12,0,0};
    gtime_t tut,tut0;
    double ut,t1,t2,t3,gmst0,gmst;
    
    tut=timeadd(t,ut1_utc);
    ut=time2sec(tut,&tut0);
    t1=timediff(tut0,epoch2time(ep2000))/86400.0/36525.0;
    t2=t1*t1; t3=t2*t1;
    gmst0=24110.54841+8640184.812866*t1+0.093104*t2-6.2E-6*t3;
    gmst=gmst0+1.002737909350795*ut;
    
    return fmod(gmst,86400.0)*pi/43200.0; /* 0 <= gmst <= 2*pi */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %r14
xorps %xmm2, %xmm2
leaq -0x60(%rbp), %rbx
movaps %xmm2, 0x20(%rbx)
movabsq $0x409f400000000000, %rax # imm = 0x409F400000000000
movq %rax, (%rbx)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movabsq $0x4028000000000000, %rax # imm = 0x4028000000000000
movq %rax, 0x18(%rbx)
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x8ac0
cvttsd2si %xmm0, %eax
movslq %eax, %rdi
addq %r14, %rdi
movsd -0x18(%rbp), %xmm1
subsd %xmm0, %xmm1
leaq -0x90(%rbp), %r14
movapd %xmm1, %xmm0
movq %r14, %rsi
callq 0x46fbf
movsd 0x18(%r14), %xmm1
movsd 0x20(%r14), %xmm0
mulsd 0x18f36(%rip), %xmm0    # 0x608a8
mulsd 0x18f36(%rip), %xmm1    # 0x608b0
addsd %xmm0, %xmm1
addsd 0x28(%r14), %xmm1
movsd %xmm1, -0x18(%rbp)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x18(%r14)
andq $0x0, 0x28(%r14)
movq %r14, %rdi
callq 0x46ee2
movq %rax, %r14
movsd %xmm0, -0x28(%rbp)
movq %rbx, %rdi
callq 0x46ee2
movsd %xmm0, -0x20(%rbp)
movq %r14, %rdi
movq %rax, %rsi
callq 0x8340
addsd -0x28(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
movsd 0x18eee(%rip), %xmm1    # 0x608c0
divsd %xmm1, %xmm0
divsd 0x231c2(%rip), %xmm0    # 0x6aba0
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
movapd %xmm0, %xmm3
mulsd %xmm2, %xmm3
mulsd 0x231b2(%rip), %xmm0    # 0x6aba8
addsd 0x231b2(%rip), %xmm0    # 0x6abb0
mulsd 0x231b2(%rip), %xmm2    # 0x6abb8
addsd %xmm2, %xmm0
mulsd 0x231ae(%rip), %xmm3    # 0x6abc0
addsd %xmm3, %xmm0
movsd -0x18(%rbp), %xmm2
mulsd 0x231a5(%rip), %xmm2    # 0x6abc8
addsd %xmm2, %xmm0
callq 0x8840
mulsd 0x18ecc(%rip), %xmm0    # 0x60900
divsd 0x1a3ac(%rip), %xmm0    # 0x61de8
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %r15
cmpl $0xc, %edx
pushq $0xc
popq %rax
cmovbl %edx, %eax
xorl %ebx, %ebx
testl %edx, %edx
cmovnsl %eax, %ebx
movsd 0x17ead(%rip), %xmm1    # 0x5f920
movsd %xmm0, -0x20(%rbp)
subsd %xmm0, %xmm1
movsd %xmm1, -0x28(%rbp)
cvtsi2sd %ebx, %xmm1
movsd 0x1902b(%rip), %xmm0    # 0x60ab8
callq 0x8b20
movsd 0x1a1de(%rip), %xmm1    # 0x61c78
divsd %xmm0, %xmm1
xorl %edi, %edi
ucomisd -0x28(%rbp), %xmm1
seta %dil
xorpd %xmm0, %xmm0
ja 0x47ab4
movsd -0x20(%rbp), %xmm0
addq %r15, %rdi
leaq -0x60(%rbp), %r15
movq %r15, %rsi
callq 0x46fbf
movsd (%r15), %xmm0
movsd 0x8(%r15), %xmm1
movsd 0x10(%r15), %xmm2
movsd 0x18(%r15), %xmm3
movsd 0x20(%r15), %xmm4
leal 0x3(%rbx), %eax
testl %ebx, %ebx
pushq $0x2
popq %rdx
cmovnel %eax, %edx
movsd 0x28(%r15), %xmm5
leaq 0x2358f(%rip), %rsi     # 0x6b087
movq %r14, %rdi
movl %ebx, %ecx
movb $0x6, %al
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8110
// File: /workspace/github_cpp_makefile_star2_O2/DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::time2doy(bamboo::gtime_t)
extern double time2doy(gtime_t t)
{
    double ep[6];
    
    time2epoch(t,ep);
    ep[1]=ep[2]=1.0; ep[3]=ep[4]=ep[5]=0.0;
    return timediff(t,epoch2time(ep))/86400.0+1.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movsd %xmm0, -0x20(%rbp)
movq %rdi, %rbx
leaq -0x50(%rbp), %r14
movq %r14, %rsi
callq 0x46fbf
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x10(%r14)
movq %rax, 0x8(%r14)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x18(%r14)
andq $0x0, 0x28(%r14)
movq %r14, %rdi
callq 0x46ee2
movsd %xmm0, -0x18(%rbp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8340
addsd -0x20(%rbp), %xmm0
subsd -0x18(%rbp), %xmm0
divsd 0x18d27(%rip), %xmm0    # 0x608c0
addsd 0x17d7f(%rip), %xmm0    # 0x5f920
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::adjgpsweek(int)
extern int adjgpsweek(int week)
{
    int w;
    (void)time2gpst(utc2gpst(timeget()),&w);
    if (w<1560) w=1560; /* use 2009/12/1 if time is earlier than 2009/12/1 */
    return week+(w-week+512)/1024*1024;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
callq 0x47349
movq %rax, %rdi
callq 0x477da
leaq -0x14(%rbp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x470f1
movl (%r14), %ecx
cmpl $0x619, %ecx            # imm = 0x619
movl $0x618, %eax            # imm = 0x618
cmovgel %ecx, %eax
subl %ebx, %eax
addl $0x200, %eax            # imm = 0x200
movl $0x400, %ecx            # imm = 0x400
cltd
idivl %ecx
shll $0xa, %eax
addl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0x28, %rsp
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rbx
movaps %xmm0, (%rbx)
movaps %xmm0, -0x20(%rbp)
pushq $0x4
popq %rdi
movq %rbx, %rsi
callq 0x85a0
testl %eax, %eax
je 0x47c3c
leaq -0x20(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8a30
movl $0x3e8, %ecx            # imm = 0x3E8
jmp 0x47c41
movl $0xf4240, %ecx          # imm = 0xF4240
imull $0x3e8, (%rbx), %esi    # imm = 0x3E8
movq 0x8(%rbx), %rax
cqto
idivq %rcx
addl %esi, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
testl %edi, %edi
jle 0x47c8d
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x3e8, %ecx            # imm = 0x3E8
movl %edi, %eax
xorl %edx, %edx
divl %ecx
leaq -0x10(%rbp), %rdi
movq %rax, (%rdi)
imull $0xf4240, %edx, %eax    # imm = 0xF4240
movq %rax, 0x8(%rdi)
xorl %esi, %esi
callq 0x8200
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movaps 0x17c8f(%rip), %xmm1    # 0x5f930
movaps %xmm0, -0x50(%rbp)
andps %xmm0, %xmm1
movaps %xmm1, -0x20(%rbp)
cvtsi2sd %esi, %xmm1
movsd 0x1a0d0(%rip), %xmm0    # 0x61d88
callq 0x8b20
movsd %xmm0, -0x10(%rbp)
movapd -0x20(%rbp), %xmm0
callq 0x8ac0
movapd %xmm0, -0x40(%rbp)
movapd -0x20(%rbp), %xmm1
subsd %xmm0, %xmm1
mulsd 0x18bc6(%rip), %xmm1    # 0x608a8
movapd %xmm1, -0x20(%rbp)
movapd %xmm1, %xmm0
callq 0x8ac0
movsd %xmm0, 0x8(%rbx)
movapd -0x20(%rbp), %xmm1
movsd %xmm0, -0x28(%rbp)
subsd %xmm0, %xmm1
mulsd 0x18b9d(%rip), %xmm1    # 0x608a8
divsd -0x10(%rbp), %xmm1
addsd 0x19f60(%rip), %xmm1    # 0x61c78
movapd %xmm1, %xmm0
callq 0x8ac0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x10(%rbx)
ucomisd 0x18b75(%rip), %xmm0    # 0x608a8
jae 0x47d3c
movapd -0x40(%rbp), %xmm3
jmp 0x47d6f
andq $0x0, 0x10(%rbx)
movsd -0x28(%rbp), %xmm0
addsd 0x17bd2(%rip), %xmm0    # 0x5f920
movsd %xmm0, 0x8(%rbx)
ucomisd 0x18b4d(%rip), %xmm0    # 0x608a8
movapd -0x40(%rbp), %xmm3
jb 0x47d6f
andq $0x0, 0x8(%rbx)
addsd 0x17bb1(%rip), %xmm3    # 0x5f920
movapd 0x18d49(%rip), %xmm0    # 0x60ac0
xorpd %xmm3, %xmm0
xorpd %xmm1, %xmm1
movapd -0x50(%rbp), %xmm2
cmpltsd %xmm1, %xmm2
andpd %xmm2, %xmm0
andnpd %xmm3, %xmm2
orpd %xmm0, %xmm2
movlpd %xmm2, (%rbx)
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::ecef2pos(double const*, double*)
extern void ecef2pos(const double *r, double *pos)
{
    double e2=FE_WGS84*(2.0-FE_WGS84),r2=rtk_dot(r,r,2),z,zk,v=RE_WGS84,sinp;
    
    for (z=r[2],zk=0.0;fabs(z-zk)>=1E-4;) {
        zk=z;
        sinp=z/sqrt(r2+z*z);
        v=RE_WGS84/sqrt(1.0-e2*sinp*sinp);
        z=r[2]+v*e2*sinp;
    }
    pos[0]=r2>1E-12?atan(z/sqrt(r2)):(r[2]>0.0?pi/2.0:-pi/2.0);
    pos[1]=r2>1E-12?atan2(r[1],r[0]):0.0;
    pos[2]=sqrt(r2+z*z)-v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x2
popq %rdx
movq %rdi, %rsi
callq 0x45e0c
movapd %xmm0, %xmm3
movsd 0x10(%r14), %xmm1
movsd 0x18abd(%rip), %xmm5    # 0x608e8
xorpd %xmm6, %xmm6
xorpd %xmm0, %xmm0
movapd %xmm1, %xmm4
movsd %xmm3, -0x28(%rbp)
movapd %xmm4, %xmm2
subsd %xmm0, %xmm2
andpd 0x17ae4(%rip), %xmm2    # 0x5f930
ucomisd 0x18abc(%rip), %xmm2    # 0x60910
movsd %xmm4, -0x20(%rbp)
jb 0x47efd
movapd %xmm4, %xmm0
mulsd %xmm4, %xmm0
addsd %xmm3, %xmm0
ucomisd %xmm6, %xmm0
jb 0x47e77
sqrtsd %xmm0, %xmm0
jmp 0x47e85
callq 0x84e0
xorpd %xmm6, %xmm6
movsd -0x20(%rbp), %xmm4
movapd %xmm4, %xmm7
divsd %xmm0, %xmm7
movapd %xmm7, %xmm0
mulsd 0x22d37(%rip), %xmm0    # 0x6abd0
mulsd %xmm7, %xmm0
addsd 0x17a7b(%rip), %xmm0    # 0x5f920
ucomisd %xmm6, %xmm0
jb 0x47eb1
sqrtsd %xmm0, %xmm0
jmp 0x47ec9
movsd %xmm7, -0x18(%rbp)
callq 0x84e0
movsd -0x18(%rbp), %xmm7
xorpd %xmm6, %xmm6
movsd -0x20(%rbp), %xmm4
movsd -0x28(%rbp), %xmm3
movsd 0x18a12(%rip), %xmm5    # 0x608e8
divsd %xmm0, %xmm5
movsd 0x10(%r14), %xmm1
movapd %xmm4, %xmm0
movapd %xmm5, %xmm4
mulsd 0x22ce8(%rip), %xmm4    # 0x6abd8
mulsd %xmm7, %xmm4
addsd %xmm1, %xmm4
jmp 0x47e3c
ucomisd 0x22cdb(%rip), %xmm3    # 0x6abe0
movsd %xmm5, -0x18(%rbp)
xorpd %xmm0, %xmm0
jbe 0x47f1c
ucomisd %xmm0, %xmm3
jb 0x47f37
sqrtsd %xmm3, %xmm0
jmp 0x47f45
xorl %eax, %eax
ucomisd %xmm0, %xmm1
seta %al
leaq 0x22ff4(%rip), %rcx     # 0x6af20
movsd (%rcx,%rax,8), %xmm1
movsd %xmm1, (%rbx)
jmp 0x47f75
movapd %xmm3, %xmm0
callq 0x84e0
movsd -0x20(%rbp), %xmm4
divsd %xmm0, %xmm4
movapd %xmm4, %xmm0
callq 0x8510
movsd %xmm0, (%rbx)
movsd (%r14), %xmm1
movsd 0x8(%r14), %xmm0
callq 0x80c0
movsd -0x20(%rbp), %xmm4
movsd -0x28(%rbp), %xmm3
movsd -0x18(%rbp), %xmm5
movsd %xmm0, 0x8(%rbx)
mulsd %xmm4, %xmm4
addsd %xmm3, %xmm4
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm4
jb 0x47f92
sqrtsd %xmm4, %xmm0
jmp 0x47fa0
movapd %xmm4, %xmm0
callq 0x84e0
movsd -0x18(%rbp), %xmm5
subsd %xmm5, %xmm0
movsd %xmm0, 0x10(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd (%rdi), %xmm0
callq 0x8160
movsd %xmm0, -0x18(%rbp)
movsd (%r14), %xmm0
callq 0x8bf0
movsd %xmm0, -0x30(%rbp)
movsd 0x8(%r14), %xmm0
callq 0x8160
movsd %xmm0, -0x28(%rbp)
movsd 0x8(%r14), %xmm0
callq 0x8bf0
movsd 0x22bcd(%rip), %xmm1    # 0x6abd0
movsd -0x18(%rbp), %xmm2
mulsd %xmm2, %xmm1
mulsd %xmm2, %xmm1
addsd 0x17908(%rip), %xmm1    # 0x5f920
movapd %xmm0, %xmm3
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x4802c
sqrtsd %xmm1, %xmm0
jmp 0x4803f
movapd %xmm1, %xmm0
movsd %xmm3, -0x20(%rbp)
callq 0x84e0
movsd -0x20(%rbp), %xmm3
movsd 0x188a1(%rip), %xmm1    # 0x608e8
divsd %xmm0, %xmm1
movsd 0x10(%r14), %xmm0
addsd %xmm1, %xmm0
movsd -0x30(%rbp), %xmm2
mulsd %xmm2, %xmm0
mulsd %xmm0, %xmm3
movsd %xmm3, (%rbx)
movsd 0x10(%r14), %xmm0
addsd %xmm1, %xmm0
mulsd %xmm2, %xmm0
movsd -0x28(%rbp), %xmm2
mulsd %xmm0, %xmm2
movsd %xmm2, 0x8(%rbx)
mulsd 0x22b5e(%rip), %xmm1    # 0x6abe8
addsd 0x10(%r14), %xmm1
movsd -0x18(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd (%rdi), %xmm0
callq 0x8160
movaps %xmm0, -0x40(%rbp)
movsd (%r14), %xmm0
callq 0x8bf0
movsd %xmm0, -0x18(%rbp)
movsd 0x8(%r14), %xmm0
callq 0x8160
movaps %xmm0, -0x30(%rbp)
movsd 0x8(%r14), %xmm0
callq 0x8bf0
movapd 0x189ca(%rip), %xmm1    # 0x60ac0
movapd -0x30(%rbp), %xmm5
movapd %xmm5, %xmm2
xorpd %xmm1, %xmm2
movlpd %xmm2, (%rbx)
movsd %xmm0, 0x18(%rbx)
andq $0x0, 0x30(%rbx)
movapd -0x40(%rbp), %xmm3
xorpd %xmm3, %xmm1
movsd -0x18(%rbp), %xmm4
movapd %xmm4, %xmm2
mulsd %xmm0, %xmm2
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rbx)
mulsd %xmm5, %xmm1
movsd %xmm1, 0x20(%rbx)
movsd %xmm4, 0x38(%rbx)
movsd %xmm2, 0x10(%rbx)
mulsd %xmm5, %xmm4
movsd %xmm4, 0x28(%rbx)
movsd %xmm3, 0x40(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movsd %xmm0, -0x40(%rbp)
pushq $0x1
popq %rax
movapd %xmm0, %xmm1
cmpq $0x4, %rax
je 0x48c36
mulsd %xmm0, %xmm1
movsd %xmm1, -0x40(%rbp,%rax,8)
incq %rax
jmp 0x48c21
leaq 0x1fb6b(%rip), %r14     # 0x687a8
xorl %r15d, %r15d
leaq 0x1fb59(%rip), %r12     # 0x687a0
cmpq $0x5, %r15
je 0x48ca0
imulq $0x28, %r15, %rax
movsd (%rax,%r12), %xmm0
mulsd 0x17c51(%rip), %xmm0    # 0x608b0
xorl %eax, %eax
cmpq $0x4, %rax
je 0x48c7c
movsd (%r14,%rax,8), %xmm1
mulsd -0x40(%rbp,%rax,8), %xmm1
incq %rax
addsd %xmm1, %xmm0
jmp 0x48c61
mulsd 0x21fa4(%rip), %xmm0    # 0x6ac28
movsd 0x17c7c(%rip), %xmm1    # 0x60908
callq 0x8840
movsd %xmm0, (%rbx,%r15,8)
incq %r15
addq $0x28, %r14
jmp 0x48c47
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::satwavelen(int, int, bamboo::nav_t const*)
extern double satwavelen(int sat, int frq, const nav_t *nav)
{
    const double freq_glo[]={FREQ1_GLO,FREQ2_GLO};
    const double dfrq_glo[]={DFRQ1_GLO,DFRQ2_GLO};
    int i,sys=satsys(sat,NULL);
    
    if (sys==SYS_GLO) {
        if (0<=frq&&frq<=1) { /* L1,L2 */
            for (i=0;i<nav->ng;i++) {
                if (nav->geph[i].sat!=sat) continue;
                return CLIGHT/(freq_glo[frq]+dfrq_glo[frq]*nav->geph[i].frq);
            }
        }
        else if (frq==2) { /* L3 */
            return CLIGHT/FREQ3_GLO;
        }
    }
    else if (sys==SYS_CMP) {
        if      (frq==0) return CLIGHT/FREQ1_CMP; /* B1 */
        else if (frq==1) return CLIGHT/FREQ2_CMP; /* B2 */
        else if (frq==2) return CLIGHT/FREQ3_CMP; /* B3 */
    }
    else if (sys==SYS_GAL) {
        if      (frq==0) return CLIGHT/FREQ1; /* E1 */
        else if (frq==1) return CLIGHT/FREQ7; /* E5b */
        else if (frq==2) return CLIGHT/FREQ5; /* E5a */
        else if (frq==3) return CLIGHT/FREQ6; /* E6 */
        else if (frq==5) return CLIGHT/FREQ8; /* E5ab */
    }
    else { /* GPS,QZS */
        if      (frq==0) return CLIGHT/FREQ1; /* L1 */
        else if (frq==1) return CLIGHT/FREQ2; /* L2 */
        else if (frq==2) return CLIGHT/FREQ5; /* L5 */
        else if (frq==3) return CLIGHT/FREQ6; /* L6/LEX */
        else if (frq==6) return CLIGHT/FREQ9; /* S */
    }
    return 0.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebx
movl %edi, %r15d
xorl %esi, %esi
callq 0x45362
cmpl $0x20, %eax
je 0x4a03a
cmpl $0x8, %eax
je 0x4a02a
cmpl $0x4, %eax
jne 0x4a04a
cmpl $0x1, %ebx
ja 0x4a05f
movl 0x8(%r14), %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
imulq $0x98, %rcx, %rcx
addq $0x98, %rcx
leaq 0x98(%rax), %rdx
cmpq %rdx, %rcx
je 0x4a06e
movq 0x48(%r14), %rsi
cmpl %r15d, (%rsi,%rax)
movq %rdx, %rax
jne 0x49fdc
movl %ebx, %eax
leaq 0x1a77e(%rip), %rcx     # 0x64780
leaq 0x1a767(%rip), %rdi     # 0x64770
cvtsi2sdl -0x90(%rsi,%rdx), %xmm1
mulsd (%rdi,%rax,8), %xmm1
addsd (%rcx,%rax,8), %xmm1
movsd 0x17d7c(%rip), %xmm0    # 0x61da0
divsd %xmm1, %xmm0
jmp 0x4a072
cmpl $0x6, %ebx
jae 0x4a06e
movl %ebx, %eax
leaq 0x20ad8(%rip), %rcx     # 0x6ab10
jmp 0x4a058
cmpl $0x3, %ebx
jae 0x4a06e
movl %ebx, %eax
leaq 0x20ab0(%rip), %rcx     # 0x6aaf8
jmp 0x4a058
cmpl $0x7, %ebx
jae 0x4a06e
movl %ebx, %eax
leaq 0x20ae8(%rip), %rcx     # 0x6ab40
movsd (%rcx,%rax,8), %xmm0
jmp 0x4a072
cmpl $0x2, %ebx
jne 0x4a06e
movsd 0x20c2c(%rip), %xmm0    # 0x6ac98
jmp 0x4a072
xorpd %xmm0, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::sortobs(bamboo::obs_t*)
extern int sortobs(obs_t *obs)
{
    int i,j,n;
    
    trace(3,"sortobs: nobs=%d\n",obs->n);
    
    if (obs->n<=0) return 0;
    
    qsort(obs->data,obs->n,sizeof(obsd_t),cmpobs);
    
    /* delete duplicated data */
    for (i=j=0;i<obs->n;i++) {
        if (obs->data[i].sat!=obs->data[j].sat||
            obs->data[i].rcv!=obs->data[j].rcv||
            timediff(obs->data[i].time,obs->data[j].time)!=0.0) {
            obs->data[++j]=obs->data[i];
        }
    }
    obs->n=j+1;
    
    for (i=n=0;i<obs->n;i=j,n++) {
        for (j=i+1;j<obs->n;j++) {
            if (timediff(obs->data[j].time,obs->data[i].time)>DTTOL) break;
        }
    }
    return n;
}

// Assembly:
movslq (%rdi), %rsi
testq %rsi, %rsi
jle 0x4a1e3
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x13e(%rip), %rcx       # 0x4a1e6
pushq $0x60
popq %rdx
callq 0x8c10
xorl %r12d, %r12d
pushq $0xc
popq %r8
xorl %r13d, %r13d
xorl %edx, %edx
movslq (%rbx), %rax
movslq %edx, %r14
cmpq %rax, %r13
jge 0x4a154
movq 0x8(%rbx), %r15
movb 0x10(%r15,%r12), %cl
imulq $0x60, %r14, %rax
cmpb 0x10(%r15,%rax), %cl
jne 0x4a132
addq %r15, %rax
movb 0x11(%r15,%r12), %cl
cmpb 0x11(%rax), %cl
jne 0x4a132
movq (%r15,%r12), %rdi
movsd 0x8(%r15,%r12), %xmm0
movsd %xmm0, -0x40(%rbp)
movq (%rax), %rsi
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq %r8, %r14
callq 0x8340
movq %r14, %r8
movq -0x30(%rbp), %rdx
addsd -0x40(%rbp), %xmm0
subsd -0x38(%rbp), %xmm0
ucomisd 0x167ca(%rip), %xmm0    # 0x608f8
jne 0x4a132
jnp 0x4a148
leaq (%r15,%r12), %rsi
incl %edx
movslq %edx, %rax
imulq $0x60, %rax, %rdi
addq %r15, %rdi
movq %r8, %rcx
rep  movsq (%rsi), %es:(%rdi)
incq %r13
addq $0x60, %r12
jmp 0x4a0bc
leal 0x1(%rdx), %eax
movl %eax, -0x44(%rbp)
movl %eax, (%rbx)
xorl %eax, %eax
xorl %r13d, %r13d
movq %rdx, -0x30(%rbp)
cmpl %edx, %r13d
jg 0x4a1d4
movl %eax, -0x48(%rbp)
movslq %r13d, %r13
imulq $0x60, %r13, %r15
leaq 0x68(%r15), %r12
cmpq %r14, %r13
jge 0x4a1c3
incq %r13
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r12), %rdi
movsd (%rax,%r12), %xmm0
movsd %xmm0, -0x40(%rbp)
movq (%rax,%r15), %rsi
movsd 0x8(%rax,%r15), %xmm0
movsd %xmm0, -0x38(%rbp)
callq 0x8340
addsd -0x40(%rbp), %xmm0
subsd -0x38(%rbp), %xmm0
addq $0x60, %r12
ucomisd 0x20ae1(%rip), %xmm0    # 0x6aca0
jbe 0x4a178
jmp 0x4a1c9
movl -0x44(%rbp), %eax
movl %eax, %r13d
movq -0x30(%rbp), %rdx
movl -0x48(%rbp), %eax
incl %eax
jmp 0x4a165
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movsd 0x8(%r14), %xmm0
movsd %xmm0, -0x20(%rbp)
movq (%rsi), %rsi
movsd 0x8(%rbx), %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x8340
addsd -0x20(%rbp), %xmm0
subsd -0x18(%rbp), %xmm0
movapd 0x15707(%rip), %xmm1    # 0x5f930
andpd %xmm0, %xmm1
ucomisd 0x20a6b(%rip), %xmm1    # 0x6aca0
jbe 0x4a24d
xorpd %xmm1, %xmm1
xorl %eax, %eax
ucomisd %xmm0, %xmm1
setbe %al
leal -0x1(,%rax,2), %eax
jmp 0x4a265
movzbl 0x11(%r14), %eax
movzbl 0x11(%rbx), %ecx
cmpb %cl, %al
jne 0x4a263
movzbl 0x10(%r14), %eax
movzbl 0x10(%rbx), %ecx
subl %ecx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
testb $0x1, %r14b
je 0x4ac2d
movq 0x40(%rbx), %rdi
callq 0x8780
andq $0x0, 0x40(%rbx)
andq $0x0, (%rbx)
testb $0x2, %r14b
je 0x4ac46
movq 0x48(%rbx), %rdi
callq 0x8780
andq $0x0, 0x48(%rbx)
andq $0x0, 0x8(%rbx)
testb $0x4, %r14b
je 0x4ac5f
movq 0x50(%rbx), %rdi
callq 0x8780
andq $0x0, 0x50(%rbx)
andq $0x0, 0x10(%rbx)
testb $0x8, %r14b
je 0x4ac78
movq 0x58(%rbx), %rdi
callq 0x8780
andq $0x0, 0x58(%rbx)
andq $0x0, 0x18(%rbx)
testb $0x10, %r14b
je 0x4ac91
movq 0x60(%rbx), %rdi
callq 0x8780
andq $0x0, 0x60(%rbx)
andq $0x0, 0x20(%rbx)
testb $0x20, %r14b
je 0x4acaa
movq 0x68(%rbx), %rdi
callq 0x8780
andq $0x0, 0x68(%rbx)
andq $0x0, 0x28(%rbx)
testb $0x40, %r14b
je 0x4acc3
movq 0x70(%rbx), %rdi
callq 0x8780
andq $0x0, 0x70(%rbx)
andq $0x0, 0x30(%rbx)
testb %r14b, %r14b
jns 0x4acdb
movq 0x78(%rbx), %rdi
callq 0x8780
andq $0x0, 0x78(%rbx)
andq $0x0, 0x38(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %rsi
leaq -0x410(%rbp), %rbx
movq %rbx, %rdi
callq 0x85c0
pushq $0x2f
popq %rsi
movq %rbx, %rdi
callq 0x8690
testq %rax, %rax
je 0x4b00e
movb $0x0, (%rax)
leaq -0x410(%rbp), %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x82d0
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp            # imm = 0x418
movq %rdx, -0x38(%rbp)
movq %rdi, %r14
movq %rsi, -0x40(%rbp)
movq %rsi, %rdi
callq 0x8290
movslq %eax, %r15
leaq -0x440(%rbp), %r12
movq %r14, -0x30(%rbp)
cmpb $0x0, (%r14)
je 0x4b659
movq %r14, %rdi
movq -0x40(%rbp), %rsi
callq 0x8170
testq %rax, %rax
je 0x4b659
movq %rax, %rbx
movq %rax, %r13
subq %r14, %r13
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x8360
addq %r12, %r13
movq %r13, %rdi
movq -0x38(%rbp), %rsi
callq 0x8660
subl %r13d, %eax
movslq %eax, %r12
addq %r13, %r12
addq %r15, %rbx
movq %rbx, %r14
jmp 0x4b60b
xorl %eax, %eax
movq -0x30(%rbp), %rbx
cmpq %rbx, %r14
jbe 0x4b681
movq %r12, %rdi
movq %r14, %rsi
callq 0x85c0
leaq -0x440(%rbp), %rsi
movq %rbx, %rdi
callq 0x85c0
pushq $0x1
popq %rax
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x3
popq %rsi
callq 0x45e31
movsd 0x15064(%rip), %xmm1    # 0x608e8
ucomisd %xmm0, %xmm1
jbe 0x4b894
movsd 0x1510e(%rip), %xmm0    # 0x609a0
jmp 0x4b906
xorl %eax, %eax
cmpq $0x3, %rax
je 0x4b8b2
movsd (%r14,%rax,8), %xmm0
subsd (%rbx,%rax,8), %xmm0
movsd %xmm0, (%r15,%rax,8)
incq %rax
jmp 0x4b896
pushq $0x3
popq %rsi
movq %r15, %rdi
callq 0x45e31
xorl %eax, %eax
cmpq $0x3, %rax
je 0x4b8da
movsd (%r15,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%r15,%rax,8)
incq %rax
jmp 0x4b8bf
movsd (%r14), %xmm1
movsd (%rbx), %xmm2
mulsd 0x8(%r14), %xmm2
mulsd 0x8(%rbx), %xmm1
subsd %xmm2, %xmm1
mulsd 0x1f3be(%rip), %xmm1    # 0x6acb8
divsd 0x1649e(%rip), %xmm1    # 0x61da0
addsd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movsd 0x10(%rdi), %xmm0
ucomisd 0x1f394(%rip), %xmm0    # 0x6acc0
jbe 0x4b9a7
leaq -0x30(%rbp), %r14
movq %r14, %rdx
callq 0x4815a
pushq $0x2
popq %rdx
movq %r14, %rdi
movq %r14, %rsi
callq 0x45e0c
xorpd %xmm2, %xmm2
movsd 0x1f28c(%rip), %xmm1    # 0x6abe0
ucomisd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ja 0x4b971
movsd -0x30(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0x80c0
xorpd %xmm2, %xmm2
movsd 0x14f8f(%rip), %xmm1    # 0x60908
addsd %xmm0, %xmm1
movapd %xmm0, %xmm3
cmpltsd %xmm2, %xmm3
andpd %xmm3, %xmm1
andnpd %xmm0, %xmm3
orpd %xmm1, %xmm3
movapd %xmm3, -0x40(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x8a80
movaps -0x40(%rbp), %xmm1
jmp 0x4b9b2
movsd 0x14f71(%rip), %xmm0    # 0x60920
xorps %xmm1, %xmm1
testq %rbx, %rbx
je 0x4b9c0
movsd %xmm1, (%rbx)
movsd %xmm0, 0x8(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::tropmodel(bamboo::gtime_t, double const*, double const*, double)
extern double tropmodel(gtime_t time, const double *pos, const double *azel,
                        double humi)
{
    const double temp0=15.0; /* temparature at sea level */
    double hgt,pres,temp,e,z,trph,trpw;
    
    if (pos[2]<-100.0||1E4<pos[2]||azel[1]<=0) return 0.0;
    
    /* standard atmosphere */
    hgt=pos[2]<0.0?0.0:pos[2];
    
    pres=1013.25*pow(1.0-2.2557E-5*hgt,5.2568);
    temp=temp0-6.5E-3*hgt+273.16;
    e=6.108*humi*exp((17.15*temp-4684.0)/(temp-38.45));
    
    /* saastamoninen model */
    z=pi/2.0-azel[1];
    trph=0.0022768*pres/(1.0-0.00266*cos(2.0*pos[0])-0.00028*hgt/1E3)/cos(z);
    trpw=0.002277*(1255.0/temp+0.05)*e/cos(z);
    return trph+trpw;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movapd %xmm1, %xmm2
movsd 0x10(%rsi), %xmm0
movsd 0x1eb74(%rip), %xmm1    # 0x6ad50
ucomisd %xmm0, %xmm1
xorpd %xmm1, %xmm1
ja 0x4c36c
ucomisd 0x1eb66(%rip), %xmm0    # 0x6ad58
ja 0x4c36c
movq %rdx, %r14
ucomisd 0x8(%rdx), %xmm1
jae 0x4c36c
movq %rsi, %rbx
maxsd %xmm0, %xmm1
movsd %xmm1, -0x28(%rbp)
movsd 0x1eb46(%rip), %xmm0    # 0x6ad60
mulsd %xmm1, %xmm0
addsd 0x136fa(%rip), %xmm0    # 0x5f920
movsd 0x1eb3a(%rip), %xmm1    # 0x6ad68
movsd %xmm2, -0x20(%rbp)
callq 0x8b20
mulsd 0x1eb30(%rip), %xmm0    # 0x6ad70
movsd %xmm0, -0x18(%rbp)
movsd 0x1eb2b(%rip), %xmm2    # 0x6ad78
mulsd -0x28(%rbp), %xmm2
addsd 0x1eb26(%rip), %xmm2    # 0x6ad80
addsd 0x1eb26(%rip), %xmm2    # 0x6ad88
movsd %xmm2, -0x38(%rbp)
movsd -0x20(%rbp), %xmm0
mulsd 0x1eb1c(%rip), %xmm0    # 0x6ad90
movsd %xmm0, -0x20(%rbp)
movsd 0x1eb17(%rip), %xmm0    # 0x6ad98
mulsd %xmm2, %xmm0
addsd 0x1eb13(%rip), %xmm0    # 0x6ada0
movsd 0x1eb13(%rip), %xmm1    # 0x6ada8
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0x8b60
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x1466c(%rip), %xmm0    # 0x60920
subsd 0x8(%r14), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
mulsd 0x1eae4(%rip), %xmm0    # 0x6adb0
movsd %xmm0, -0x18(%rbp)
movsd (%rbx), %xmm0
addsd %xmm0, %xmm0
callq 0x8bf0
mulsd 0x1ead2(%rip), %xmm0    # 0x6adb8
addsd 0x13632(%rip), %xmm0    # 0x5f920
movsd -0x28(%rbp), %xmm1
mulsd 0x1eac5(%rip), %xmm1    # 0x6adc0
divsd 0x15165(%rip), %xmm1    # 0x61468
addsd %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x8bf0
movsd 0x1eaa1(%rip), %xmm2    # 0x6adc8
divsd -0x38(%rbp), %xmm2
addsd 0x1e974(%rip), %xmm2    # 0x6aca8
movsd -0x18(%rbp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, -0x18(%rbp)
mulsd 0x1ea86(%rip), %xmm2    # 0x6add0
mulsd -0x30(%rbp), %xmm2
movsd %xmm2, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x8bf0
movsd -0x28(%rbp), %xmm1
divsd %xmm0, %xmm1
addsd -0x18(%rbp), %xmm1
movapd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::antmodel(bamboo::pcv_t const*, double const*, double const*, int, double*)
extern void antmodel(const pcv_t *pcv, const double *del, const double *azel,
                     int opt, double *dant)
{
    double e[3],off[3],cosel=cos(azel[1]);
    int i,j;
    
    trace(4,"antmodel: azel=%6.1f %4.1f opt=%d\n",azel[0]*R2D,azel[1]*R2D,opt);
    
    e[0]=sin(azel[0])*cosel;
    e[1]=cos(azel[0])*cosel;
    e[2]=sin(azel[1]);
    
    for (i=0;i<NFREQ;i++) {
        for (j=0;j<3;j++) off[j]=pcv->off[i][j]+del[j];
        
        dant[i]=-rtk_dot(off,e,3)+(opt?interpvar(90.0-azel[1]*R2D,pcv->var[i]):0.0);
    }
    trace(5,"antmodel: dant=%6.3f %6.3f\n",dant[0],dant[1]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %rbx
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, -0x38(%rbp)
movsd 0x8(%rdx), %xmm0
callq 0x8bf0
movsd %xmm0, -0x30(%rbp)
movsd (%r15), %xmm0
callq 0x8160
mulsd -0x30(%rbp), %xmm0
leaq -0x80(%rbp), %r13
movsd %xmm0, (%r13)
movsd (%r15), %xmm0
callq 0x8bf0
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x8(%r13)
movq %r15, -0x40(%rbp)
movsd 0x8(%r15), %xmm0
callq 0x8160
movsd %xmm0, 0x10(%r13)
movq -0x38(%rbp), %rax
leaq 0xa8(%rax), %r13
addq $0xf0, %rax
movq %rax, -0x38(%rbp)
xorl %r15d, %r15d
cmpq $0x3, %r15
je 0x4c69a
xorl %eax, %eax
cmpq $0x3, %rax
je 0x4c632
movsd (%r13,%rax,8), %xmm0
addsd (%r12,%rax,8), %xmm0
movsd %xmm0, -0x60(%rbp,%rax,8)
incq %rax
jmp 0x4c614
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
pushq $0x3
popq %rdx
callq 0x45e0c
movapd %xmm0, %xmm1
testl %r14d, %r14d
je 0x4c680
movq -0x40(%rbp), %rax
movsd 0x8(%rax), %xmm0
mulsd 0x1e7b4(%rip), %xmm0    # 0x6ae10
addsd 0x1444c(%rip), %xmm0    # 0x60ab0
imulq $0x98, %r15, %rdi
addq -0x38(%rbp), %rdi
movsd %xmm1, -0x30(%rbp)
callq 0x4c6a9
movsd -0x30(%rbp), %xmm1
jmp 0x4c684
xorpd %xmm0, %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rbx,%r15,8)
incq %r15
addq $0x18, %r13
jmp 0x4c608
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
divsd 0x150eb(%rip), %xmm0    # 0x617a0
cvttsd2si %xmm0, %eax
testl %eax, %eax
js 0x4c6cc
cmpl $0x12, %eax
jb 0x4c6d2
movsd 0x90(%rdi), %xmm0
jmp 0x4c6ff
movsd (%rdi), %xmm0
jmp 0x4c6ff
movl %eax, %ecx
movsd 0x13244(%rip), %xmm1    # 0x5f920
subsd %xmm0, %xmm1
cvtsi2sd %eax, %xmm2
addsd %xmm2, %xmm1
subsd %xmm2, %xmm0
mulsd 0x8(%rdi,%rcx,8), %xmm0
mulsd (%rdi,%rcx,8), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
mulsd 0x17fd7(%rip), %xmm0    # 0x646f0
mulsd 0x1507f(%rip), %xmm0    # 0x617a0
movsd %xmm0, -0x20(%rbp)
addq $0xf0, %r14
xorl %r15d, %r15d
cmpq $0x3, %r15
je 0x4c755
movsd -0x20(%rbp), %xmm0
movq %r14, %rdi
callq 0x4c6a9
movsd %xmm0, (%rbx,%r15,8)
incq %r15
addq $0x98, %r14
jmp 0x4c730
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x4(%rsi), %rax
movl (%rsi), %ecx
cmpl %ecx, %eax
jle 0x4d20e
movq 0x8(%r14), %rax
jmp 0x4d234
addq $0x100, %rax            # imm = 0x100
movl %eax, 0x4(%r14)
movq 0x8(%r14), %rdi
imulq $0x2b8, %rax, %rsi      # imm = 0x2B8
callq 0x8a70
testq %rax, %rax
je 0x4d258
movq %rax, 0x8(%r14)
movl (%r14), %ecx
leal 0x1(%rcx), %edx
movl %edx, (%r14)
movslq %ecx, %rcx
imulq $0x2b8, %rcx, %rdi      # imm = 0x2B8
addq %rax, %rdi
movl $0x2b8, %edx            # imm = 0x2B8
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x84f0
movq 0x8(%r14), %rdi
callq 0x8780
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %r15d
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %ecx
cmovgl %esi, %ecx
cmpq %rax, %rcx
je 0x4d299
andq $0x0, (%rbx,%rax,8)
incq %rax
jmp 0x4d28a
leaq 0x1e245(%rip), %r14     # 0x6b4e5
movq %r14, %rsi
callq 0x89a0
movslq %r15d, %r12
xorl %r15d, %r15d
testq %rax, %rax
je 0x4d2dd
cmpq %r12, %r15
jge 0x4d2dd
movq %rax, %rdi
callq 0x87b0
mulsd 0x14ab0(%rip), %xmm0    # 0x61d78
movsd %xmm0, (%rbx,%r15,8)
incq %r15
xorl %edi, %edi
movq %r14, %rsi
callq 0x89a0
jmp 0x4d2ae
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq