LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::gpst2time(int, double)
extern gtime_t gpst2time(int week, double sec)
{
    gtime_t t=epoch2time(gpst0);
    
    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 0x23440(%rip), %rdi     # 0x726a0
callq 0x4f027
movapd 0x1a6c3(%rip), %xmm1    # 0x69930
movapd -0x20(%rbp), %xmm2
andpd %xmm2, %xmm1
movsd 0x25912(%rip), %xmm0    # 0x74b90
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_O3/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 0x233d2(%rip), %rdi     # 0x726a0
callq 0x4f027
subq %rax, %rbx
movabsq $0x377aef2669de1559, %rcx # imm = 0x377AEF2669DE1559
movq %rbx, %rax
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0x11, %rdx
addl %eax, %edx
testq %r14, %r14
je 0x4f2fb
movl %edx, (%r14)
cvtsi2sd %rbx, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
mulsd 0x1caf1(%rip), %xmm0    # 0x6be00
mulsd 0x1b5c9(%rip), %xmm0    # 0x6a8e0
addsd %xmm1, %xmm0
addsd -0x18(%rbp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x23391(%rip), %rdi     # 0x726d0
callq 0x4f027
movapd 0x1a5e4(%rip), %xmm1    # 0x69930
movapd -0x20(%rbp), %xmm2
andpd %xmm2, %xmm1
movsd 0x25833(%rip), %xmm0    # 0x74b90
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_O3/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 0x23323(%rip), %rdi     # 0x726d0
callq 0x4f027
subq %rax, %rbx
movabsq $0x377aef2669de1559, %rcx # imm = 0x377AEF2669DE1559
movq %rbx, %rax
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0x11, %rdx
addl %eax, %edx
testq %r14, %r14
je 0x4f3da
movl %edx, (%r14)
cvtsi2sd %rbx, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
mulsd 0x1ca12(%rip), %xmm0    # 0x6be00
mulsd 0x1b4ea(%rip), %xmm0    # 0x6a8e0
addsd %xmm1, %xmm0
addsd -0x18(%rbp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x232e2(%rip), %rdi     # 0x72700
callq 0x4f027
movapd 0x1a505(%rip), %xmm1    # 0x69930
movapd -0x20(%rbp), %xmm2
andpd %xmm2, %xmm1
movsd 0x25754(%rip), %xmm0    # 0x74b90
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_O3/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 0x23274(%rip), %rdi     # 0x72700
callq 0x4f027
subq %rax, %rbx
movabsq $0x377aef2669de1559, %rcx # imm = 0x377AEF2669DE1559
movq %rbx, %rax
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0x11, %rdx
addl %eax, %edx
testq %r14, %r14
je 0x4f4b9
movl %edx, (%r14)
cvtsi2sd %rbx, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
mulsd 0x1c933(%rip), %xmm0    # 0x6be00
mulsd 0x1b40b(%rip), %xmm0    # 0x6a8e0
addsd %xmm1, %xmm0
addsd -0x18(%rbp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4f5e5
leaq -0x50(%rbp), %rdi
callq 0x8540
testq %rax, %rax
je 0x4f5e5
movl $0x76c, %ecx            # imm = 0x76C
addl 0x14(%rax), %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
movsd %xmm0, -0x40(%rbp)
movl 0x10(%rax), %ecx
incl %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
movsd %xmm0, -0x38(%rbp)
xorps %xmm0, %xmm0
cvtsi2sdl 0xc(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
cvtsi2sdl 0x8(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
cvtsi2sdl 0x4(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
cvtsi2sdl (%rax), %xmm0
cvtsi2sdq -0x48(%rbp), %xmm1
mulsd 0x1d664(%rip), %xmm1    # 0x6cc40
addsd %xmm0, %xmm1
movsd %xmm1, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4f027
movq %rax, %rbx
addsd 0x429ef(%rip), %xmm0    # 0x91fe8
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_O3/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
movq %rdi, %rbx
movsd 0x3f698(%rip), %xmm1    # 0x8f060
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
jbe 0x4fa57
leaq 0x3f683(%rip), %r14     # 0x8f060
movsd %xmm0, -0x28(%rbp)
movsd 0x30(%r14), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, -0x20(%rbp)
movapd %xmm1, %xmm0
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 0x4f027
movsd %xmm0, -0x30(%rbp)
movq %r15, %rdi
movq %rax, %rsi
callq 0x8330
movsd -0x20(%rbp), %xmm2
xorpd %xmm1, %xmm1
addsd %xmm2, %xmm0
subsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jae 0x4fa5e
movsd 0x38(%r14), %xmm0
addq $0x38, %r14
ucomisd %xmm1, %xmm0
movsd -0x28(%rbp), %xmm0
ja 0x4f9e2
movq %rbx, %r15
movapd %xmm0, %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_O3/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
movsd %xmm0, -0x18(%rbp)
movq %rdi, %rbx
movsd 0x3f5d5(%rip), %xmm0    # 0x8f060
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x4fb06
leaq 0x3f5c4(%rip), %r14     # 0x8f060
movq %r14, %rdi
callq 0x4f027
movsd %xmm0, -0x20(%rbp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8330
xorpd %xmm1, %xmm1
addsd -0x18(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jae 0x4fada
movsd 0x38(%r14), %xmm0
addq $0x38, %r14
ucomisd %xmm1, %xmm0
ja 0x4fa9c
jmp 0x4fb06
movsd -0x18(%rbp), %xmm0
subsd 0x30(%r14), %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x8ac0
cvttsd2si %xmm0, %eax
cltq
addq %rax, %rbx
movsd -0x18(%rbp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, -0x18(%rbp)
movq %rbx, %rax
movsd -0x18(%rbp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4f104
movsd 0x20(%r14), %xmm0
mulsd 0x1aca6(%rip), %xmm0    # 0x6a8b8
movsd 0x18(%r14), %xmm1
mulsd 0x1aca0(%rip), %xmm1    # 0x6a8c0
addsd %xmm0, %xmm1
addsd 0x28(%r14), %xmm1
movsd %xmm1, -0x18(%rbp)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x18(%r14)
movq $0x0, 0x28(%r14)
movq %r14, %rdi
callq 0x4f027
movq %rax, %r14
movsd %xmm0, -0x28(%rbp)
movq %rbx, %rdi
callq 0x4f027
movsd %xmm0, -0x20(%rbp)
movq %r14, %rdi
movq %rax, %rsi
callq 0x8330
addsd -0x28(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
movsd 0x1ac55(%rip), %xmm1    # 0x6a8d0
divsd %xmm1, %xmm0
divsd 0x24f19(%rip), %xmm0    # 0x74ba0
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
movapd %xmm0, %xmm3
mulsd %xmm2, %xmm3
mulsd 0x24f09(%rip), %xmm0    # 0x74ba8
addsd 0x24f09(%rip), %xmm0    # 0x74bb0
mulsd 0x24f09(%rip), %xmm2    # 0x74bb8
addsd %xmm2, %xmm0
mulsd 0x24f05(%rip), %xmm3    # 0x74bc0
addsd %xmm3, %xmm0
movsd -0x18(%rbp), %xmm2
mulsd 0x24efc(%rip), %xmm2    # 0x74bc8
addsd %xmm2, %xmm0
callq 0x8850
mulsd 0x1ac33(%rip), %xmm0    # 0x6a910
divsd 0x1c113(%rip), %xmm0    # 0x6bdf8
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0xc, %eax
cmovbl %edx, %eax
xorl %ebx, %ebx
testl %edx, %edx
cmovnsl %eax, %ebx
movsd 0x19c02(%rip), %xmm1    # 0x69920
movsd %xmm0, -0x20(%rbp)
subsd %xmm0, %xmm1
movsd %xmm1, -0x28(%rbp)
xorps %xmm1, %xmm1
cvtsi2sd %ebx, %xmm1
movsd 0x1ad8d(%rip), %xmm0    # 0x6aac8
callq 0x8b20
movsd 0x1bf30(%rip), %xmm1    # 0x6bc78
divsd %xmm0, %xmm1
xorl %edi, %edi
ucomisd -0x28(%rbp), %xmm1
seta %dil
xorpd %xmm0, %xmm0
ja 0x4fd62
movsd -0x20(%rbp), %xmm0
addq %r15, %rdi
leaq -0x60(%rbp), %r15
movq %r15, %rsi
callq 0x4f104
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
movl $0x2, %edx
cmovnel %eax, %edx
movsd 0x28(%r15), %xmm5
leaq 0x252c9(%rip), %rsi     # 0x75071
movq %r14, %rdi
movl %ebx, %ecx
movb $0x6, %al
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8120
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4f104
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x10(%r14)
movq %rax, 0x8(%r14)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x18(%r14)
movq $0x0, 0x28(%r14)
movq %r14, %rdi
callq 0x4f027
movsd %xmm0, -0x18(%rbp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8330
addsd -0x20(%rbp), %xmm0
subsd -0x18(%rbp), %xmm0
divsd 0x1aa84(%rip), %xmm0    # 0x6a8d0
addsd 0x19acc(%rip), %xmm0    # 0x69920
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl %edi, %ebx
callq 0x4f542
movq %rax, %rdi
callq 0x4fa70
movq %rax, %r14
leaq 0x22823(%rip), %rdi     # 0x726a0
callq 0x4f027
subq %rax, %r14
movabsq $0x377aef2669de1559, %rcx # imm = 0x377AEF2669DE1559
movq %r14, %rax
imulq %rcx
movq %rdx, %rcx
shrq $0x3f, %rcx
shrq $0x11, %rdx
addl %edx, %ecx
cmpl $0x619, %ecx            # imm = 0x619
movl $0x618, %eax            # imm = 0x618
cmovgel %ecx, %eax
subl %ebx, %eax
leal 0x200(%rax), %ecx
addl $0x5ff, %eax            # imm = 0x5FF
testl %ecx, %ecx
cmovnsl %ecx, %eax
andl $0xfffffc00, %eax       # imm = 0xFFFFFC00
addl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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)
movl $0x4, %edi
movq %rbx, %rsi
callq 0x85a0
testl %eax, %eax
je 0x4ff0b
leaq -0x20(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8a30
movl $0x3e8, %ecx            # imm = 0x3E8
jmp 0x4ff10
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_O3/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 0x199b3(%rip), %xmm1    # 0x69930
movaps %xmm0, -0x50(%rbp)
andps %xmm0, %xmm1
movaps %xmm1, -0x20(%rbp)
xorps %xmm1, %xmm1
cvtsi2sd %esi, %xmm1
movsd 0x1bdf1(%rip), %xmm0    # 0x6bd88
callq 0x8b20
movsd %xmm0, -0x10(%rbp)
movapd -0x20(%rbp), %xmm0
callq 0x8ac0
movapd %xmm0, -0x40(%rbp)
movapd -0x20(%rbp), %xmm1
subsd %xmm0, %xmm1
mulsd 0x1a8f7(%rip), %xmm1    # 0x6a8b8
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 0x1a8ce(%rip), %xmm1    # 0x6a8b8
divsd -0x10(%rbp), %xmm1
addsd 0x1bc81(%rip), %xmm1    # 0x6bc78
movapd %xmm1, %xmm0
callq 0x8ac0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x10(%rbx)
ucomisd 0x1a8a6(%rip), %xmm0    # 0x6a8b8
jae 0x5001b
movapd -0x40(%rbp), %xmm3
jmp 0x50054
movq $0x0, 0x10(%rbx)
movsd -0x28(%rbp), %xmm0
addsd 0x198f0(%rip), %xmm0    # 0x69920
movsd %xmm0, 0x8(%rbx)
ucomisd 0x1a87b(%rip), %xmm0    # 0x6a8b8
movapd -0x40(%rbp), %xmm3
jb 0x50054
movq $0x0, 0x8(%rbx)
addsd 0x198cc(%rip), %xmm3    # 0x69920
movapd 0x1aa74(%rip), %xmm0    # 0x6aad0
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_O3/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
movsd (%rdi), %xmm2
movsd 0x8(%rdi), %xmm0
mulsd %xmm0, %xmm0
xorpd %xmm5, %xmm5
addsd %xmm5, %xmm0
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
movsd 0x10(%rdi), %xmm1
movapd 0x19813(%rip), %xmm0    # 0x69930
andpd %xmm1, %xmm0
ucomisd 0x1a7f7(%rip), %xmm0    # 0x6a920
movsd %xmm2, -0x28(%rbp)
jae 0x50141
movsd 0x1a7c0(%rip), %xmm3    # 0x6a8f8
movapd %xmm1, %xmm4
jmp 0x50201
movapd %xmm1, %xmm6
movapd %xmm6, %xmm0
mulsd %xmm6, %xmm0
addsd %xmm2, %xmm0
ucomisd %xmm5, %xmm0
movsd %xmm6, -0x18(%rbp)
jb 0x50162
sqrtsd %xmm0, %xmm0
jmp 0x50170
callq 0x84e0
movsd -0x18(%rbp), %xmm6
xorpd %xmm5, %xmm5
movapd %xmm6, %xmm7
divsd %xmm0, %xmm7
movapd %xmm7, %xmm0
mulsd 0x24a4c(%rip), %xmm0    # 0x74bd0
mulsd %xmm7, %xmm0
addsd 0x19790(%rip), %xmm0    # 0x69920
ucomisd %xmm5, %xmm0
jb 0x5019c
sqrtsd %xmm0, %xmm0
jmp 0x501b4
movsd %xmm7, -0x20(%rbp)
callq 0x84e0
movsd -0x20(%rbp), %xmm7
movsd -0x18(%rbp), %xmm6
xorpd %xmm5, %xmm5
movsd -0x28(%rbp), %xmm2
movsd 0x1a737(%rip), %xmm3    # 0x6a8f8
divsd %xmm0, %xmm3
movsd 0x10(%r14), %xmm1
movapd %xmm3, %xmm4
mulsd 0x24a01(%rip), %xmm4    # 0x74bd8
mulsd %xmm7, %xmm4
addsd %xmm1, %xmm4
movapd %xmm4, %xmm0
subsd %xmm6, %xmm0
andpd 0x19741(%rip), %xmm0    # 0x69930
ucomisd 0x1a729(%rip), %xmm0    # 0x6a920
movapd %xmm4, %xmm6
jae 0x50145
ucomisd 0x249d7(%rip), %xmm2    # 0x74be0
movsd %xmm3, -0x18(%rbp)
xorpd %xmm0, %xmm0
jbe 0x50228
ucomisd %xmm0, %xmm2
movsd %xmm4, -0x20(%rbp)
jb 0x50243
xorps %xmm0, %xmm0
sqrtsd %xmm2, %xmm0
jmp 0x50251
xorl %eax, %eax
ucomisd %xmm0, %xmm1
seta %al
leaq 0x24cd8(%rip), %rcx     # 0x74f10
movsd (%rcx,%rax,8), %xmm1
movsd %xmm1, (%rbx)
jmp 0x50281
movapd %xmm2, %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 0x80d0
movsd -0x20(%rbp), %xmm4
movsd -0x28(%rbp), %xmm2
movsd -0x18(%rbp), %xmm3
movsd %xmm0, 0x8(%rbx)
mulsd %xmm4, %xmm4
addsd %xmm2, %xmm4
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm4
jb 0x502a1
xorps %xmm0, %xmm0
sqrtsd %xmm4, %xmm0
jmp 0x502af
movapd %xmm4, %xmm0
callq 0x84e0
movsd -0x18(%rbp), %xmm3
subsd %xmm3, %xmm0
movsd %xmm0, 0x10(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8150
movsd %xmm0, -0x18(%rbp)
movsd (%r14), %xmm0
callq 0x8bf0
movsd %xmm0, -0x30(%rbp)
movsd 0x8(%r14), %xmm0
callq 0x8150
movsd %xmm0, -0x28(%rbp)
movsd 0x8(%r14), %xmm0
callq 0x8bf0
movsd 0x248be(%rip), %xmm1    # 0x74bd0
movsd -0x18(%rbp), %xmm2
mulsd %xmm2, %xmm1
mulsd %xmm2, %xmm1
addsd 0x195f9(%rip), %xmm1    # 0x69920
movapd %xmm0, %xmm3
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x5033e
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
jmp 0x50351
movapd %xmm1, %xmm0
movsd %xmm3, -0x20(%rbp)
callq 0x84e0
movsd -0x20(%rbp), %xmm3
movsd 0x1a59f(%rip), %xmm1    # 0x6a8f8
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 0x2484c(%rip), %xmm1    # 0x74be8
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_O3/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 0x8150
movaps %xmm0, -0x40(%rbp)
movsd (%r14), %xmm0
callq 0x8bf0
movsd %xmm0, -0x18(%rbp)
movsd 0x8(%r14), %xmm0
callq 0x8150
movaps %xmm0, -0x30(%rbp)
movsd 0x8(%r14), %xmm0
callq 0x8bf0
movapd 0x1a6c8(%rip), %xmm1    # 0x6aad0
movapd -0x30(%rbp), %xmm5
movapd %xmm5, %xmm2
xorpd %xmm1, %xmm2
movlpd %xmm2, (%rbx)
movsd %xmm0, 0x18(%rbx)
movq $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_O3/DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::covenu(double const*, double const*, double*)
extern void covenu(const double *pos, const double *P, double *Q)
{
    double E[9],EP[9];
    
    xyz2enu(pos,E);
    matmul("NN",3,3,3,1.0,E,P,0.0,EP);
    matmul("NT",3,3,3,1.0,EP,E,0.0,Q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movsd (%rdi), %xmm0
callq 0x8150
movaps %xmm0, -0x50(%rbp)
movsd (%r15), %xmm0
callq 0x8bf0
movsd %xmm0, -0x28(%rbp)
movsd 0x8(%r15), %xmm0
callq 0x8150
movaps %xmm0, -0x40(%rbp)
movsd 0x8(%r15), %xmm0
callq 0x8bf0
movapd 0x1a408(%rip), %xmm1    # 0x6aad0
movapd -0x40(%rbp), %xmm5
movapd %xmm5, %xmm2
xorpd %xmm1, %xmm2
leaq -0xf0(%rbp), %r15
movlpd %xmm2, (%r15)
movsd %xmm0, 0x18(%r15)
movq $0x0, 0x30(%r15)
movapd -0x50(%rbp), %xmm3
xorpd %xmm3, %xmm1
movsd -0x28(%rbp), %xmm4
movapd %xmm4, %xmm2
mulsd %xmm0, %xmm2
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8(%r15)
mulsd %xmm5, %xmm1
movsd %xmm1, 0x20(%r15)
movsd %xmm4, 0x38(%r15)
movsd %xmm2, 0x10(%r15)
mulsd %xmm5, %xmm4
movsd %xmm4, 0x28(%r15)
movsd %xmm3, 0x40(%r15)
leaq -0xa0(%rbp), %r12
movq %r12, (%rsp)
leaq 0x24920(%rip), %rdi     # 0x75067
movsd 0x191d1(%rip), %xmm0    # 0x69920
xorpd %xmm1, %xmm1
movl $0x3, %esi
movl $0x3, %edx
movl $0x3, %ecx
movq %r15, %r8
movq %r14, %r9
callq 0x4dfb0
movq %rbx, (%rsp)
leaq 0x282fb(%rip), %rdi     # 0x78a73
xorpd %xmm1, %xmm1
movl $0x3, %esi
movl $0x3, %edx
movl $0x3, %ecx
movsd 0x1918d(%rip), %xmm0    # 0x69920
movq %r12, %r8
movq %r15, %r9
callq 0x4dfb0
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::covecef(double const*, double const*, double*)
extern void covecef(const double *pos, const double *Q, double *P)
{
    double E[9],EQ[9];
    
    xyz2enu(pos,E);
    matmul("TN",3,3,3,1.0,E,Q,0.0,EQ);
    matmul("NN",3,3,3,1.0,EQ,E,0.0,P);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movsd (%rdi), %xmm0
callq 0x8150
movaps %xmm0, -0x50(%rbp)
movsd (%r15), %xmm0
callq 0x8bf0
movsd %xmm0, -0x28(%rbp)
movsd 0x8(%r15), %xmm0
callq 0x8150
movaps %xmm0, -0x40(%rbp)
movsd 0x8(%r15), %xmm0
callq 0x8bf0
movapd 0x1a2c9(%rip), %xmm1    # 0x6aad0
movapd -0x40(%rbp), %xmm5
movapd %xmm5, %xmm2
xorpd %xmm1, %xmm2
leaq -0xf0(%rbp), %r15
movlpd %xmm2, (%r15)
movsd %xmm0, 0x18(%r15)
movq $0x0, 0x30(%r15)
movapd -0x50(%rbp), %xmm3
xorpd %xmm3, %xmm1
movsd -0x28(%rbp), %xmm4
movapd %xmm4, %xmm2
mulsd %xmm0, %xmm2
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8(%r15)
mulsd %xmm5, %xmm1
movsd %xmm1, 0x20(%r15)
movsd %xmm4, 0x38(%r15)
movsd %xmm2, 0x10(%r15)
mulsd %xmm5, %xmm4
movsd %xmm4, 0x28(%r15)
movsd %xmm3, 0x40(%r15)
leaq -0xa0(%rbp), %r12
movq %r12, (%rsp)
leaq 0x1c3da(%rip), %rdi     # 0x6cc60
movsd 0x19092(%rip), %xmm0    # 0x69920
xorpd %xmm1, %xmm1
movl $0x3, %esi
movl $0x3, %edx
movl $0x3, %ecx
movq %r15, %r8
movq %r14, %r9
callq 0x4dfb0
movq %rbx, (%rsp)
leaq 0x247b0(%rip), %rdi     # 0x75067
xorpd %xmm1, %xmm1
movl $0x3, %esi
movl $0x3, %edx
movl $0x3, %ecx
movsd 0x1904e(%rip), %xmm0    # 0x69920
movq %r12, %r8
movq %r15, %r9
callq 0x4dfb0
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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)
movl $0x1, %eax
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, -0x40(%rbp,%rax,8)
incq %rax
cmpq $0x4, %rax
jne 0x51219
leaq 0x21575(%rip), %r14     # 0x727a8
xorl %r15d, %r15d
leaq 0x21563(%rip), %r12     # 0x727a0
leaq (%r15,%r15,4), %rax
movsd (%r12,%rax,8), %xmm0
mulsd 0x19671(%rip), %xmm0    # 0x6a8c0
xorl %eax, %eax
movsd (%r14,%rax,8), %xmm1
mulsd -0x40(%rbp,%rax,8), %xmm1
leaq 0x1(%rax), %rcx
addsd %xmm1, %xmm0
movq %rcx, %rax
cmpq $0x4, %rcx
jne 0x51251
mulsd 0x239b2(%rip), %xmm0    # 0x74c28
movsd 0x1969a(%rip), %xmm1    # 0x6a918
callq 0x8850
movsd %xmm0, (%rbx,%r15,8)
incq %r15
addq $0x28, %r14
cmpq $0x5, %r15
jne 0x5123d
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
leal -0x9c(%rdi), %eax
cmpl $-0x7b, %eax
jae 0x526a8
cmpl $0x7, %esi
jae 0x52717
movl %esi, %eax
leaq 0x2249f(%rip), %rcx     # 0x74b40
movsd (%rcx,%rax,8), %xmm0
jmp 0x5271b
cmpl $0x3c, %edi
jae 0x526db
cmpl $0x1, %esi
ja 0x526f0
movslq 0x8(%rdx), %rcx
testq %rcx, %rcx
jle 0x52717
movq 0x48(%rdx), %rax
imulq $0x98, %rcx, %rdx
xorl %ecx, %ecx
cmpl %edi, (%rax,%rcx)
je 0x5271d
addq $0x98, %rcx
cmpq %rcx, %rdx
jne 0x526c8
jmp 0x52717
cmpl $0x60, %edi
jae 0x526ff
cmpl $0x6, %esi
jae 0x52717
movl %esi, %eax
leaq 0x22422(%rip), %rcx     # 0x74b10
jmp 0x526a1
cmpl $0x2, %esi
jne 0x52717
movsd 0x2259b(%rip), %xmm0    # 0x74c98
jmp 0x5271b
cmpl $0x85, %edi
jae 0x52693
cmpl $0x3, %esi
jae 0x52717
movl %esi, %eax
leaq 0x223e3(%rip), %rcx     # 0x74af8
jmp 0x526a1
xorpd %xmm0, %xmm0
popq %rbp
retq
movl %esi, %edx
leaq 0x1c69a(%rip), %rsi     # 0x6edc0
leaq 0x1c683(%rip), %rdi     # 0x6edb0
cvtsi2sdl 0x8(%rax,%rcx), %xmm1
mulsd (%rdi,%rdx,8), %xmm1
addsd (%rsi,%rdx,8), %xmm1
movsd 0x1965b(%rip), %xmm0    # 0x6bda0
divsd %xmm1, %xmm0
jmp 0x5271b
// File: /workspace/github_cpp_makefile_star2_O3/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 0x52845
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rax
movq 0x8(%rdi), %rdi
leaq 0x169(%rip), %rcx       # 0x528df
movq %rax, -0x38(%rbp)
movl $0x60, %edx
callq 0x8c00
movq -0x38(%rbp), %rdx
movl (%rdx), %r13d
testl %r13d, %r13d
jle 0x52848
xorl %r15d, %r15d
xorl %r12d, %r12d
xorl %r14d, %r14d
movq 0x8(%rdx), %rbx
movb 0x10(%rbx,%r15), %cl
movslq %r14d, %rax
leaq (%rax,%rax,2), %rax
shlq $0x5, %rax
cmpb 0x10(%rbx,%rax), %cl
jne 0x52800
addq %rbx, %rax
movb 0x11(%rbx,%r15), %cl
cmpb 0x11(%rax), %cl
jne 0x52800
movq (%rbx,%r15), %rdi
movsd 0x8(%rbx,%r15), %xmm0
movsd %xmm0, -0x48(%rbp)
movq (%rax), %rsi
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
callq 0x8330
movq -0x38(%rbp), %rdx
addsd -0x48(%rbp), %xmm0
subsd -0x40(%rbp), %xmm0
ucomisd 0x1810c(%rip), %xmm0    # 0x6a908
jne 0x52800
jnp 0x52820
leaq (%rbx,%r15), %rsi
incl %r14d
movslq %r14d, %rax
leaq (%rax,%rax,2), %rdi
shlq $0x5, %rdi
addq %rbx, %rdi
movl $0xc, %ecx
rep  movsq (%rsi), %es:(%rdi)
movl (%rdx), %r13d
incq %r12
movslq %r13d, %rax
addq $0x60, %r15
cmpq %rax, %r12
jl 0x5279d
leal 0x1(%r14), %eax
movl %eax, (%rdx)
testl %r14d, %r14d
jns 0x52851
xorl %eax, %eax
jmp 0x528d0
xorl %eax, %eax
retq
movl $0x1, (%rdx)
xorl %r14d, %r14d
movl %r14d, %r15d
xorl %r12d, %r12d
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
movslq %r12d, %r12
leal -0x1(%r12), %r13d
leaq (%r12,%r12,2), %rbx
shlq $0x5, %rbx
leaq 0x68(%rbx), %r14
cmpq %r15, %r12
jge 0x528cb
incq %r12
movq 0x8(%rdx), %rax
movq -0x8(%rax,%r14), %rdi
movsd (%rax,%r14), %xmm0
movsd %xmm0, -0x48(%rbp)
movq (%rax,%rbx), %rsi
movsd 0x8(%rax,%rbx), %xmm0
movsd %xmm0, -0x40(%rbp)
callq 0x8330
movq -0x38(%rbp), %rdx
addsd -0x48(%rbp), %xmm0
subsd -0x40(%rbp), %xmm0
incl %r13d
addq $0x60, %r14
ucomisd 0x223e3(%rip), %xmm0    # 0x74ca0
jbe 0x52870
movl -0x2c(%rbp), %eax
incl %eax
cmpl %r13d, %r15d
jg 0x52859
jmp 0x528d0
movl -0x2c(%rbp), %eax
incl %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/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 0x8330
addsd -0x20(%rbp), %xmm0
subsd -0x18(%rbp), %xmm0
movapd 0x1700e(%rip), %xmm1    # 0x69930
andpd %xmm0, %xmm1
ucomisd 0x22372(%rip), %xmm1    # 0x74ca0
jbe 0x52946
xorpd %xmm1, %xmm1
xorl %eax, %eax
ucomisd %xmm0, %xmm1
setbe %al
leal -0x1(,%rax,2), %eax
jmp 0x5295e
movzbl 0x11(%r14), %eax
movzbl 0x11(%rbx), %ecx
cmpb %cl, %al
jne 0x5295c
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_O3/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 0x53367
movq 0x40(%rbx), %rdi
callq 0x87a0
xorl %eax, %eax
movq %rax, 0x40(%rbx)
movq %rax, (%rbx)
testb $0x2, %r14b
je 0x53380
movq 0x48(%rbx), %rdi
callq 0x87a0
xorl %eax, %eax
movq %rax, 0x48(%rbx)
movq %rax, 0x8(%rbx)
testb $0x4, %r14b
je 0x53399
movq 0x50(%rbx), %rdi
callq 0x87a0
xorl %eax, %eax
movq %rax, 0x50(%rbx)
movq %rax, 0x10(%rbx)
testb $0x8, %r14b
je 0x533b2
movq 0x58(%rbx), %rdi
callq 0x87a0
xorl %eax, %eax
movq %rax, 0x58(%rbx)
movq %rax, 0x18(%rbx)
testb $0x10, %r14b
je 0x533cb
movq 0x60(%rbx), %rdi
callq 0x87a0
xorl %eax, %eax
movq %rax, 0x60(%rbx)
movq %rax, 0x20(%rbx)
testb $0x20, %r14b
je 0x533e4
movq 0x68(%rbx), %rdi
callq 0x87a0
xorl %eax, %eax
movq %rax, 0x68(%rbx)
movq %rax, 0x28(%rbx)
testb $0x40, %r14b
je 0x533fd
movq 0x70(%rbx), %rdi
callq 0x87a0
xorl %eax, %eax
movq %rax, 0x70(%rbx)
movq %rax, 0x30(%rbx)
testb %r14b, %r14b
jns 0x53415
movq 0x78(%rbx), %rdi
callq 0x87a0
xorl %eax, %eax
movq %rax, 0x78(%rbx)
movq %rax, 0x38(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
movq %rsi, -0x40(%rbp)
movq %rsi, %rdi
callq 0x8290
xorl %ecx, %ecx
cmpb $0x0, (%rbx)
je 0x53e89
movslq %eax, %r12
leaq -0x440(%rbp), %r13
movq %rbx, -0x30(%rbp)
movq %rbx, %rdi
movq -0x40(%rbp), %rsi
callq 0x8160
testq %rax, %rax
je 0x53e5c
movq %rax, %r15
movq %rax, %r14
subq %rbx, %r14
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x8350
addq %r13, %r14
movq %r14, %rdi
movq -0x38(%rbp), %rsi
callq 0x8670
subl %r14d, %eax
movslq %eax, %r13
addq %r14, %r13
movq %r15, %rbx
addq %r12, %rbx
cmpb $0x0, (%r15,%r12)
jne 0x53e0f
movq -0x30(%rbp), %r14
cmpq %r14, %rbx
movl $0x0, %ecx
jbe 0x53e89
movq %r13, %rdi
movq %rbx, %rsi
callq 0x85c0
leaq -0x440(%rbp), %rsi
movq %r14, %rdi
callq 0x85c0
movl $0x1, %ecx
movl %ecx, %eax
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/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
xorpd %xmm0, %xmm0
movl $0x4, %eax
movsd -0x10(%r14,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
decq %rax
cmpq $0x1, %rax
ja 0x5412e
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x54156
sqrtsd %xmm0, %xmm0
jmp 0x5415b
callq 0x84e0
movsd 0x16795(%rip), %xmm1    # 0x6a8f8
ucomisd %xmm0, %xmm1
jbe 0x54176
movsd 0x1683f(%rip), %xmm0    # 0x6a9b0
jmp 0x5420f
xorl %eax, %eax
movsd (%r14,%rax,8), %xmm0
subsd (%rbx,%rax,8), %xmm0
movsd %xmm0, (%r15,%rax,8)
incq %rax
cmpq $0x3, %rax
jne 0x54178
xorpd %xmm0, %xmm0
movl $0x4, %eax
movsd -0x10(%r15,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
decq %rax
cmpq $0x1, %rax
ja 0x5419b
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x541c3
sqrtsd %xmm0, %xmm0
jmp 0x541c8
callq 0x84e0
xorl %eax, %eax
movsd (%r15,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%r15,%rax,8)
incq %rax
cmpq $0x3, %rax
jne 0x541ca
movsd (%r14), %xmm1
movsd (%rbx), %xmm2
mulsd 0x8(%r14), %xmm2
mulsd 0x8(%rbx), %xmm1
subsd %xmm2, %xmm1
mulsd 0x20ab5(%rip), %xmm1    # 0x74cb8
divsd 0x17b95(%rip), %xmm1    # 0x6bda0
addsd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x20a8b(%rip), %xmm0    # 0x74cc0
jbe 0x542c3
leaq -0x40(%rbp), %r14
movq %r14, %rdx
callq 0x5046f
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm1, %xmm2
xorpd %xmm4, %xmm4
addsd %xmm4, %xmm2
movapd %xmm0, %xmm3
mulsd %xmm0, %xmm3
addsd %xmm2, %xmm3
movsd 0x2096a(%rip), %xmm2    # 0x74be0
ucomisd %xmm3, %xmm2
xorpd %xmm2, %xmm2
ja 0x5428d
callq 0x80d0
xorpd %xmm4, %xmm4
movapd %xmm0, %xmm2
movsd 0x16683(%rip), %xmm0    # 0x6a918
addsd %xmm2, %xmm0
movapd %xmm2, %xmm1
cmpltsd %xmm4, %xmm1
andpd %xmm1, %xmm0
andnpd %xmm2, %xmm1
orpd %xmm0, %xmm1
movapd %xmm1, -0x20(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x8a80
movaps -0x20(%rbp), %xmm1
jmp 0x542ce
movsd 0x16665(%rip), %xmm0    # 0x6a930
xorps %xmm1, %xmm1
testq %rbx, %rbx
je 0x542dc
movsd %xmm1, (%rbx)
movsd %xmm0, 0x8(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x201e1(%rip), %xmm1    # 0x74d50
ucomisd %xmm0, %xmm1
xorpd %xmm1, %xmm1
ja 0x54cff
ucomisd 0x201d3(%rip), %xmm0    # 0x74d58
ja 0x54cff
movq %rdx, %r14
ucomisd 0x8(%rdx), %xmm1
jae 0x54cff
movq %rsi, %rbx
maxsd %xmm0, %xmm1
movsd %xmm1, -0x28(%rbp)
movsd 0x201b3(%rip), %xmm0    # 0x74d60
mulsd %xmm1, %xmm0
addsd 0x14d67(%rip), %xmm0    # 0x69920
movsd 0x201a7(%rip), %xmm1    # 0x74d68
movsd %xmm2, -0x20(%rbp)
callq 0x8b20
mulsd 0x2019d(%rip), %xmm0    # 0x74d70
movsd %xmm0, -0x18(%rbp)
movsd 0x20198(%rip), %xmm2    # 0x74d78
mulsd -0x28(%rbp), %xmm2
addsd 0x20193(%rip), %xmm2    # 0x74d80
addsd 0x20193(%rip), %xmm2    # 0x74d88
movsd %xmm2, -0x38(%rbp)
movsd -0x20(%rbp), %xmm0
mulsd 0x20189(%rip), %xmm0    # 0x74d90
movsd %xmm0, -0x20(%rbp)
movsd 0x20184(%rip), %xmm0    # 0x74d98
mulsd %xmm2, %xmm0
addsd 0x20180(%rip), %xmm0    # 0x74da0
movsd 0x20180(%rip), %xmm1    # 0x74da8
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0x8b60
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x15ce9(%rip), %xmm0    # 0x6a930
subsd 0x8(%r14), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
mulsd 0x20151(%rip), %xmm0    # 0x74db0
movsd %xmm0, -0x18(%rbp)
movsd (%rbx), %xmm0
addsd %xmm0, %xmm0
callq 0x8bf0
mulsd 0x2013f(%rip), %xmm0    # 0x74db8
addsd 0x14c9f(%rip), %xmm0    # 0x69920
movsd -0x28(%rbp), %xmm1
mulsd 0x20132(%rip), %xmm1    # 0x74dc0
divsd 0x167e2(%rip), %xmm1    # 0x6b478
addsd %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x8bf0
movsd 0x2010e(%rip), %xmm2    # 0x74dc8
divsd -0x38(%rbp), %xmm2
addsd 0x1ffe1(%rip), %xmm2    # 0x74ca8
movsd -0x18(%rbp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, -0x18(%rbp)
mulsd 0x200f3(%rip), %xmm2    # 0x74dd0
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