LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movslq (%rdi), %rsi
testq %rsi, %rsi
jle 0x5333d
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x18b(%rip), %rcx       # 0x53352
movl $0x60, %edx
callq 0x8c10
xorl %r14d, %r14d
cmpl $0x0, (%rbx)
movl $0x0, %eax
movq %rax, -0x30(%rbp)
jle 0x5328b
xorl %r12d, %r12d
xorl %r13d, %r13d
movq $0x0, -0x30(%rbp)
movq 0x8(%rbx), %r15
movb 0x10(%r15,%r12), %cl
movslq -0x30(%rbp), %rax
leaq (%rax,%rax,2), %rax
shlq $0x5, %rax
cmpb 0x10(%r15,%rax), %cl
jne 0x53255
addq %r15, %rax
movb 0x11(%r15,%r12), %cl
cmpb 0x11(%rax), %cl
jne 0x53255
movq (%r15,%r12), %rdi
movsd 0x8(%r15,%r12), %xmm0
movsd %xmm0, -0x40(%rbp)
movq (%rax), %rsi
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
callq 0x8330
addsd -0x40(%rbp), %xmm0
subsd -0x38(%rbp), %xmm0
ucomisd 0x176b7(%rip), %xmm0    # 0x6a908
jne 0x53255
jnp 0x53278
leaq (%r15,%r12), %rsi
movq -0x30(%rbp), %rax
incl %eax
movq %rax, -0x30(%rbp)
cltq
leaq (%rax,%rax,2), %rdi
shlq $0x5, %rdi
addq %r15, %rdi
movl $0xc, %ecx
rep  movsq (%rsi), %es:(%rdi)
incq %r13
movslq (%rbx), %rax
addq $0x60, %r12
cmpq %rax, %r13
jl 0x531f4
movq -0x30(%rbp), %rcx
leal 0x1(%rcx), %eax
movl %eax, (%rbx)
testl %ecx, %ecx
js 0x53340
movl %ecx, %r12d
xorl %eax, %eax
xorl %r14d, %r14d
movl %r14d, -0x48(%rbp)
movslq %eax, %r13
cmpl %ecx, %r13d
cmovgl %r13d, %ecx
movq %rcx, -0x50(%rbp)
leal 0x1(%rcx), %eax
movl %eax, -0x44(%rbp)
leaq (,%r13,2), %r14
addq %r13, %r14
shlq $0x5, %r14
leaq 0x68(%r14), %r15
cmpq %r12, %r13
jge 0x53321
incq %r13
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r15), %rdi
movsd (%rax,%r15), %xmm0
movsd %xmm0, -0x40(%rbp)
movq (%rax,%r14), %rsi
movsd 0x8(%rax,%r14), %xmm0
movsd %xmm0, -0x38(%rbp)
callq 0x8330
addsd -0x40(%rbp), %xmm0
subsd -0x38(%rbp), %xmm0
addq $0x60, %r15
ucomisd 0x219aa(%rip), %xmm0    # 0x74cc0
jbe 0x532cf
leal -0x1(%r13), %edx
movl %r13d, %eax
jmp 0x53328
movl -0x44(%rbp), %eax
movq -0x50(%rbp), %rdx
movl -0x48(%rbp), %r14d
incl %r14d
movq -0x30(%rbp), %rcx
cmpl %ecx, %edx
jl 0x532a4
jmp 0x53340
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1659b(%rip), %xmm1    # 0x69930
andpd %xmm0, %xmm1
ucomisd 0x2191f(%rip), %xmm1    # 0x74cc0
jbe 0x533b9
xorpd %xmm1, %xmm1
xorl %eax, %eax
ucomisd %xmm0, %xmm1
setbe %al
leal -0x1(,%rax,2), %eax
jmp 0x533d1
movzbl 0x11(%r14), %eax
movzbl 0x11(%rbx), %ecx
cmpb %cl, %al
jne 0x533cf
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_O1/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 0x53dff
movq 0x40(%rbx), %rdi
callq 0x87b0
xorl %eax, %eax
movq %rax, 0x40(%rbx)
movq %rax, (%rbx)
testb $0x2, %r14b
je 0x53e18
movq 0x48(%rbx), %rdi
callq 0x87b0
xorl %eax, %eax
movq %rax, 0x48(%rbx)
movq %rax, 0x8(%rbx)
testb $0x4, %r14b
je 0x53e31
movq 0x50(%rbx), %rdi
callq 0x87b0
xorl %eax, %eax
movq %rax, 0x50(%rbx)
movq %rax, 0x10(%rbx)
testb $0x8, %r14b
je 0x53e4a
movq 0x58(%rbx), %rdi
callq 0x87b0
xorl %eax, %eax
movq %rax, 0x58(%rbx)
movq %rax, 0x18(%rbx)
testb $0x10, %r14b
je 0x53e63
movq 0x60(%rbx), %rdi
callq 0x87b0
xorl %eax, %eax
movq %rax, 0x60(%rbx)
movq %rax, 0x20(%rbx)
testb $0x20, %r14b
je 0x53e7c
movq 0x68(%rbx), %rdi
callq 0x87b0
xorl %eax, %eax
movq %rax, 0x68(%rbx)
movq %rax, 0x28(%rbx)
testb $0x40, %r14b
je 0x53e95
movq 0x70(%rbx), %rdi
callq 0x87b0
xorl %eax, %eax
movq %rax, 0x70(%rbx)
movq %rax, 0x30(%rbx)
testb %r14b, %r14b
jns 0x53ead
movq 0x78(%rbx), %rdi
callq 0x87b0
xorl %eax, %eax
movq %rax, 0x78(%rbx)
movq %rax, 0x38(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rbx, %rdi
movl $0x2f, %esi
callq 0x86a0
testq %rax, %rax
je 0x54220
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_O1/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, %r13
movq %rsi, -0x40(%rbp)
movq %rsi, %rdi
callq 0x8290
cmpb $0x0, (%r13)
movq %r13, -0x30(%rbp)
je 0x548fd
movslq %eax, %r15
leaq -0x440(%rbp), %r12
movq %r13, %rdi
movq -0x40(%rbp), %rsi
callq 0x8160
testq %rax, %rax
je 0x54904
movq %rax, %r14
movq %rax, %rbx
subq %r13, %rbx
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x8350
addq %r12, %rbx
movq %rbx, %rdi
movq -0x38(%rbp), %rsi
callq 0x8670
subl %ebx, %eax
movslq %eax, %r12
addq %rbx, %r12
movq %r14, %r13
addq %r15, %r13
cmpb $0x0, (%r14,%r15)
jne 0x548af
jmp 0x54904
leaq -0x440(%rbp), %r12
xorl %eax, %eax
movq -0x30(%rbp), %rbx
cmpq %rbx, %r13
jbe 0x5492e
movq %r12, %rdi
movq %r13, %rsi
callq 0x85c0
leaq -0x440(%rbp), %rsi
movq %rbx, %rdi
callq 0x85c0
movl $0x1, %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_O1/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 0x54bd1
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x54bf9
sqrtsd %xmm0, %xmm0
jmp 0x54bfe
callq 0x84e0
movsd 0x15cf2(%rip), %xmm1    # 0x6a8f8
ucomisd %xmm0, %xmm1
jbe 0x54c19
movsd 0x15d9c(%rip), %xmm0    # 0x6a9b0
jmp 0x54cb2
xorl %eax, %eax
movsd (%r14,%rax,8), %xmm0
subsd (%rbx,%rax,8), %xmm0
movsd %xmm0, (%r15,%rax,8)
incq %rax
cmpq $0x3, %rax
jne 0x54c1b
xorpd %xmm0, %xmm0
movl $0x4, %eax
movsd -0x10(%r15,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
decq %rax
cmpq $0x1, %rax
ja 0x54c3e
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x54c66
sqrtsd %xmm0, %xmm0
jmp 0x54c6b
callq 0x84e0
xorl %eax, %eax
movsd (%r15,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%r15,%rax,8)
incq %rax
cmpq $0x3, %rax
jne 0x54c6d
movsd (%r14), %xmm1
movsd (%rbx), %xmm2
mulsd 0x8(%r14), %xmm2
mulsd 0x8(%rbx), %xmm1
subsd %xmm2, %xmm1
mulsd 0x20032(%rip), %xmm1    # 0x74cd8
divsd 0x170f2(%rip), %xmm1    # 0x6bda0
addsd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movsd 0x10(%rdi), %xmm0
ucomisd 0x2000a(%rip), %xmm0    # 0x74ce0
jbe 0x54d64
leaq -0x20(%rbp), %rdx
callq 0x50e51
xorpd %xmm0, %xmm0
movl $0x3, %eax
movsd -0x30(%rbp,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
decq %rax
cmpq $0x1, %rax
ja 0x54cee
xorpd %xmm2, %xmm2
movsd 0x1feef(%rip), %xmm1    # 0x74c00
ucomisd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ja 0x54d2e
movsd -0x20(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x80d0
xorpd %xmm2, %xmm2
movsd 0x15be2(%rip), %xmm1    # 0x6a918
addsd %xmm0, %xmm1
movapd %xmm0, %xmm3
cmpltsd %xmm2, %xmm3
andpd %xmm3, %xmm1
andnpd %xmm0, %xmm3
orpd %xmm1, %xmm3
movapd %xmm3, -0x30(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x8a90
movaps -0x30(%rbp), %xmm1
jmp 0x54d6f
movsd 0x15bc4(%rip), %xmm0    # 0x6a930
xorps %xmm1, %xmm1
testq %rbx, %rbx
je 0x54d7d
movsd %xmm1, (%rbx)
movsd %xmm0, 0x8(%rbx)
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1f761(%rip), %xmm1    # 0x74d70
ucomisd %xmm0, %xmm1
xorpd %xmm1, %xmm1
ja 0x5579f
ucomisd 0x1f753(%rip), %xmm0    # 0x74d78
ja 0x5579f
movq %rdx, %r14
ucomisd 0x8(%rdx), %xmm1
jae 0x5579f
movq %rsi, %rbx
maxsd %xmm0, %xmm1
movsd %xmm1, -0x28(%rbp)
movsd 0x1f733(%rip), %xmm0    # 0x74d80
mulsd %xmm1, %xmm0
addsd 0x142c7(%rip), %xmm0    # 0x69920
movsd 0x1f727(%rip), %xmm1    # 0x74d88
movsd %xmm2, -0x20(%rbp)
callq 0x8b30
mulsd 0x1f71d(%rip), %xmm0    # 0x74d90
movsd %xmm0, -0x18(%rbp)
movsd 0x1f718(%rip), %xmm2    # 0x74d98
mulsd -0x28(%rbp), %xmm2
addsd 0x1f713(%rip), %xmm2    # 0x74da0
addsd 0x1f713(%rip), %xmm2    # 0x74da8
movsd %xmm2, -0x38(%rbp)
movsd -0x20(%rbp), %xmm0
mulsd 0x1f709(%rip), %xmm0    # 0x74db0
movsd %xmm0, -0x20(%rbp)
movsd 0x1f704(%rip), %xmm0    # 0x74db8
mulsd %xmm2, %xmm0
addsd 0x1f700(%rip), %xmm0    # 0x74dc0
movsd 0x1f700(%rip), %xmm1    # 0x74dc8
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0x8b70
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x15249(%rip), %xmm0    # 0x6a930
subsd 0x8(%r14), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
mulsd 0x1f6d1(%rip), %xmm0    # 0x74dd0
movsd %xmm0, -0x18(%rbp)
movsd (%rbx), %xmm0
addsd %xmm0, %xmm0
callq 0x8c00
mulsd 0x1f6bf(%rip), %xmm0    # 0x74dd8
addsd 0x141ff(%rip), %xmm0    # 0x69920
movsd -0x28(%rbp), %xmm1
mulsd 0x1f6b2(%rip), %xmm1    # 0x74de0
divsd 0x15d42(%rip), %xmm1    # 0x6b478
addsd %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x8c00
movsd 0x1f68e(%rip), %xmm2    # 0x74de8
divsd -0x38(%rbp), %xmm2
addsd 0x1f561(%rip), %xmm2    # 0x74cc8
movsd -0x18(%rbp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, -0x18(%rbp)
mulsd 0x1f673(%rip), %xmm2    # 0x74df0
mulsd -0x30(%rbp), %xmm2
movsd %xmm2, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x8c00
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_O1/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 $0x48, %rsp
movq %r8, %rbx
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movsd 0x8(%rdx), %xmm0
callq 0x8c00
movsd %xmm0, -0x30(%rbp)
movsd (%r15), %xmm0
callq 0x8150
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd (%r15), %xmm0
callq 0x8c00
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd 0x8(%r15), %xmm0
callq 0x8150
movsd %xmm0, -0x40(%rbp)
leaq 0xa8(%r13), %rax
addq $0xf0, %r13
xorl %ecx, %ecx
movsd 0x1f2b3(%rip), %xmm0    # 0x74e30
movsd 0x14f3b(%rip), %xmm1    # 0x6aac0
movsd 0x15c3b(%rip), %xmm2    # 0x6b7c8
movsd 0x13d8b(%rip), %xmm3    # 0x69920
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm4
addsd (%r12,%rdx,8), %xmm4
movsd %xmm4, -0x70(%rbp,%rdx,8)
incq %rdx
cmpq $0x3, %rdx
jne 0x55b97
xorpd %xmm4, %xmm4
movl $0x4, %edx
movsd -0x80(%rbp,%rdx,8), %xmm5
mulsd -0x60(%rbp,%rdx,8), %xmm5
addsd %xmm5, %xmm4
decq %rdx
cmpq $0x1, %rdx
ja 0x55bba
testl %r14d, %r14d
je 0x55c0b
movsd 0x8(%r15), %xmm5
mulsd %xmm0, %xmm5
addsd %xmm1, %xmm5
imulq $0x98, %rcx, %rdx
addq %r13, %rdx
divsd %xmm2, %xmm5
cvttsd2si %xmm5, %esi
testl %esi, %esi
js 0x55c11
cmpl $0x12, %esi
jl 0x55c17
movsd 0x90(%rdx), %xmm6
jmp 0x55c3f
xorpd %xmm6, %xmm6
jmp 0x55c3f
movsd (%rdx), %xmm6
jmp 0x55c3f
movl %esi, %edi
movapd %xmm3, %xmm6
xorps %xmm7, %xmm7
cvtsi2sd %esi, %xmm7
subsd %xmm5, %xmm6
subsd %xmm7, %xmm5
mulsd 0x8(%rdx,%rdi,8), %xmm5
addsd %xmm7, %xmm6
mulsd (%rdx,%rdi,8), %xmm6
addsd %xmm5, %xmm6
subsd %xmm4, %xmm6
movsd %xmm6, (%rbx,%rcx,8)
incq %rcx
addq $0x18, %rax
cmpq $0x3, %rcx
jne 0x55b95
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
mulsd 0x191c4(%rip), %xmm0    # 0x6ee38
movsd 0x15b4c(%rip), %xmm1    # 0x6b7c8
mulsd %xmm1, %xmm0
addq $0xf0, %rdi
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movsd 0x13c89(%rip), %xmm1    # 0x69920
cvttpd2dq %xmm0, %xmm2
cvtdq2pd %xmm2, %xmm2
subsd %xmm0, %xmm1
addsd %xmm2, %xmm1
subsd %xmm2, %xmm0
xorl %ecx, %ecx
testl %eax, %eax
js 0x55cc0
cmpl $0x12, %eax
jl 0x55cc6
movsd 0x90(%rdi), %xmm2
jmp 0x55cdd
movsd (%rdi), %xmm2
jmp 0x55cdd
movsd 0x8(%rdi,%rax,8), %xmm3
mulsd %xmm0, %xmm3
movsd (%rdi,%rax,8), %xmm2
mulsd %xmm1, %xmm2
addsd %xmm3, %xmm2
movsd %xmm2, (%rsi,%rcx,8)
incq %rcx
addq $0x98, %rdi
cmpq $0x3, %rcx
jne 0x55cad
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq %rdi, %r14
movslq 0x4(%rsi), %rax
cmpl (%rsi), %eax
jg 0x567f3
addq $0x100, %rax            # imm = 0x100
movl %eax, 0x4(%rbx)
movq 0x8(%rbx), %rdi
imulq $0x2b8, %rax, %rsi      # imm = 0x2B8
callq 0x8a80
testq %rax, %rax
je 0x56817
movq %rax, 0x8(%rbx)
movslq (%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, (%rbx)
imulq $0x2b8, %rax, %rdi      # imm = 0x2B8
addq 0x8(%rbx), %rdi
movl $0x2b8, %edx            # imm = 0x2B8
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x84f0
movq 0x8(%rbx), %rdi
callq 0x87b0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14d
movq %rdi, %r15
movl %esi, %r12d
testl %esi, %esi
jle 0x56858
leaq (,%r12,8), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8390
leaq 0x1ec96(%rip), %rsi     # 0x754f5
movq %r15, %rdi
callq 0x89c0
testq %rax, %rax
sete %cl
testl %r14d, %r14d
setle %dl
xorl %r14d, %r14d
orb %cl, %dl
jne 0x568b1
xorl %r14d, %r14d
leaq 0x1ec71(%rip), %r15     # 0x754f5
movq %rax, %rdi
callq 0x87e0
mulsd 0x154e4(%rip), %xmm0    # 0x6bd78
movsd %xmm0, (%rbx,%r14,8)
incq %r14
xorl %edi, %edi
movq %r15, %rsi
callq 0x89c0
testq %rax, %rax
je 0x568b1
cmpq %r12, %r14
jb 0x56884
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::cmpeph(void const*, void const*)
static int cmpeph(const void *p1, const void *p2)
{
    eph_t *q1=(eph_t *)p1,*q2=(eph_t *)p2;
    return q1->ttr.time!=q2->ttr.time?(int)(q1->ttr.time-q2->ttr.time):
           (q1->toe.time!=q2->toe.time?(int)(q1->toe.time-q2->toe.time):
            q1->sat-q2->sat);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x40(%rdi), %rax
movq 0x40(%rsi), %rcx
cmpq %rcx, %rax
jne 0x568e1
movq 0x20(%rdi), %rax
movq 0x20(%rsi), %rcx
cmpq %rcx, %rax
jne 0x568e1
movl (%rdi), %eax
subl (%rsi), %eax
jmp 0x568e3
subl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::cmpgeph(void const*, void const*)
static int cmpgeph(const void *p1, const void *p2)
{
    geph_t *q1=(geph_t *)p1,*q2=(geph_t *)p2;
    return q1->tof.time!=q2->tof.time?(int)(q1->tof.time-q2->tof.time):
           (q1->toe.time!=q2->toe.time?(int)(q1->toe.time-q2->toe.time):
            q1->sat-q2->sat);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x28(%rdi), %rax
movq 0x28(%rsi), %rcx
cmpq %rcx, %rax
jne 0x56909
movq 0x18(%rdi), %rax
movq 0x18(%rsi), %rcx
cmpq %rcx, %rax
jne 0x56909
movl (%rdi), %eax
subl (%rsi), %eax
jmp 0x5690b
subl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/rtkcmn.cpp
// Function: bamboo::cmpseph(void const*, void const*)
static int cmpseph(const void *p1, const void *p2)
{
    seph_t *q1=(seph_t *)p1,*q2=(seph_t *)p2;
    return q1->tof.time!=q2->tof.time?(int)(q1->tof.time-q2->tof.time):
           (q1->t0.time!=q2->t0.time?(int)(q1->t0.time-q2->t0.time):
            q1->sat-q2->sat);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x18(%rdi), %rax
movq 0x18(%rsi), %rcx
cmpq %rcx, %rax
jne 0x56931
movq 0x8(%rdi), %rax
movq 0x8(%rsi), %rcx
cmpq %rcx, %rax
jne 0x56931
movl (%rdi), %eax
subl (%rsi), %eax
jmp 0x56933
subl %ecx, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/skytraq.cpp
// Function: bamboo::input_stq(bamboo::raw_t*, unsigned char)
extern int input_stq(raw_t *raw, unsigned char data)
{
    trace(5,"input_stq: data=%02x\n",data);
    
    /* synchronize frame */
    if (raw->nbyte==0) {
        if (!sync_stq(raw->buff,data)) return 0;
        raw->nbyte=2;
        return 0;
    }
    raw->buff[raw->nbyte++]=data;
    
    if (raw->nbyte==4) {
        if ((raw->len=U2(raw->buff+2)+7)>MAXRAWLEN) {
            trace(2,"stq message length error: len=%d\n",raw->len);
            raw->nbyte=0;
            return -1;
        }
    }
    if (raw->nbyte<4||raw->nbyte<raw->len) return 0;
    raw->nbyte=0;
    
    /* decode skytraq raw message */
    return decode_stq(raw);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x1ec71(%rip), %rsi     # 0x755c0
xorl %r14d, %r14d
movl $0x5, %edi
movl %r15d, %edx
xorl %eax, %eax
callq 0x4ded0
movslq 0x81a74(%rbx), %rax
testq %rax, %rax
je 0x56a0c
leal 0x1(%rax), %ecx
movl %ecx, 0x81a74(%rbx)
movb %r15b, 0x81a90(%rbx,%rax)
movl 0x81a74(%rbx), %eax
cmpl $0x4, %eax
jne 0x569e3
leaq -0x19(%rbp), %rcx
xorl %edx, %edx
movb 0x81a92(%rbx,%rdx), %sil
movb %sil, (%rcx)
decq %rcx
incq %rdx
cmpl $0x1, %edx
je 0x56993
movzwl -0x1a(%rbp), %ecx
leal 0x7(%rcx), %edx
movl %edx, 0x81a78(%rbx)
cmpl $0xffa, %ecx            # imm = 0xFFA
jb 0x569e3
leaq 0x1ec11(%rip), %rsi     # 0x755d6
movl $0x2, %edi
xorl %eax, %eax
callq 0x4ded0
movl $0x0, 0x81a74(%rbx)
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0x56a34
xorl %r14d, %r14d
cmpl $0x4, %eax
jl 0x56a34
cmpl 0x81a78(%rbx), %eax
jl 0x56a34
movl $0x0, 0x81a74(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x56a42
movb 0x81a91(%rbx), %al
movb %al, 0x81a90(%rbx)
movb %r15b, 0x81a91(%rbx)
xorb $-0x60, %al
xorb $-0x5f, %r15b
orb %al, %r15b
jne 0x56a34
movl $0x2, 0x81a74(%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/skytraq.cpp
// Function: bamboo::input_stqf(bamboo::raw_t*, _IO_FILE*)
extern int input_stqf(raw_t *raw, FILE *fp)
{
    int i,data;
    
    trace(4,"input_stqf:\n");
    
    /* synchronize frame */
    if (raw->nbyte==0) {
        for (i=0;;i++) {
            if ((data=fgetc(fp))==EOF) return -2;
            if (sync_stq(raw->buff,(unsigned char)data)) break;
            if (i>=4096) return 0;
        }
    }
    if (fread(raw->buff+2,1,2,fp)<2) return -2;
    raw->nbyte=4;
    
    if ((raw->len=U2(raw->buff+2)+7)>MAXRAWLEN) {
        trace(2,"stq message length error: len=%d\n",raw->len);
        raw->nbyte=0;
        return -1;
    }
    if (fread(raw->buff+4,1,raw->len-4,fp)<(size_t)(raw->len-4)) return -2;
    raw->nbyte=0;
    
    /* decode skytraq raw message */
    return decode_stq(raw);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1e9b4(%rip), %rsi     # 0x755f8
movl $0x4, %edi
xorl %eax, %eax
callq 0x4ded0
cmpl $0x0, 0x81a74(%rbx)
je 0x56cea
leaq 0x81a92(%rbx), %rdi
movl $0x1, %esi
movl $0x2, %edx
movq %r14, %rcx
callq 0x8930
movl $0xfffffffe, %r15d      # imm = 0xFFFFFFFE
cmpq $0x2, %rax
jb 0x56d83
movl $0x4, 0x81a74(%rbx)
movl $0x81a92, %eax          # imm = 0x81A92
leaq -0x21(%rbp), %rcx
movb (%rbx,%rax), %dl
movb %dl, (%rcx)
decq %rcx
incq %rax
cmpl $0x81a93, %eax          # imm = 0x81A93
je 0x56c99
movzwl -0x22(%rbp), %edx
leal 0x7(%rdx), %eax
movl %eax, 0x81a78(%rbx)
cmpl $0xffa, %edx            # imm = 0xFFA
jb 0x56d3a
leaq 0x1e90f(%rip), %rsi     # 0x755d6
movl $0x2, %edi
movl %eax, %edx
xorl %eax, %eax
callq 0x4ded0
movl $0x0, 0x81a74(%rbx)
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jmp 0x56d83
movq %r14, %rdi
callq 0x89d0
movl $0xfffffffe, %r15d      # imm = 0xFFFFFFFE
cmpl $-0x1, %eax
je 0x56d83
movl $0x1001, %r12d          # imm = 0x1001
movb 0x81a91(%rbx), %cl
movb %cl, 0x81a90(%rbx)
movb %al, 0x81a91(%rbx)
xorb $-0x60, %cl
xorb $-0x5f, %al
orb %cl, %al
je 0x56c5d
decl %r12d
je 0x56d80
movq %r14, %rdi
callq 0x89d0
cmpl $-0x1, %eax
jne 0x56d07
jmp 0x56d83
leaq 0x81a94(%rbx), %rdi
addq $0x3, %rdx
movl $0x1, %esi
movq %r14, %rcx
callq 0x8930
movslq 0x81a78(%rbx), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
jb 0x56d83
movl $0x0, 0x81a74(%rbx)
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x56a42
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/skytraq.cpp
// Function: bamboo::decode_stqtime(bamboo::raw_t*)
static int decode_stqtime(raw_t *raw)
{
    unsigned char *p=raw->buff+4;
    double tow;
    int week;
    
    trace(4,"decode_stqtime: len=%d\n",raw->len);
    
    raw->iod=U1(p+1);
    week    =U2(p+2);
    tow     =U4(p+4)*0.001;
    raw->time=gpst2time(week,tow);
    
    if (raw->outtype) {
        sprintf(raw->msgtype,"SKYTRAQ EPOCH (%4d): iod=%d week=%d tow=%.3f",
                raw->len,raw->iod,week,tow);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x81a78(%rdi), %edx
leaq 0x1e553(%rip), %rsi     # 0x756e3
movl $0x4, %edi
xorl %eax, %eax
callq 0x4ded0
movzbl 0x81a95(%rbx), %eax
movl %eax, 0x81a7c(%rbx)
movl $0x81a96, %eax          # imm = 0x81A96
leaq -0x11(%rbp), %rcx
movb (%rbx,%rax), %dl
movb %dl, (%rcx)
decq %rcx
incq %rax
cmpl $0x81a97, %eax          # imm = 0x81A97
je 0x571b2
movzwl -0x12(%rbp), %r14d
movl $0x81a98, %eax          # imm = 0x81A98
leaq -0x15(%rbp), %rcx
movb (%rbx,%rax), %dl
movb %dl, (%rcx)
decq %rcx
incq %rax
cmpl $0x81a9c, %eax          # imm = 0x81A9C
jne 0x571d2
movl -0x18(%rbp), %eax
cvtsi2sd %rax, %xmm0
mulsd 0x14b84(%rip), %xmm0    # 0x6bd78
movl %r14d, %edi
movsd %xmm0, -0x20(%rbp)
callq 0x4fbc6
movq %rax, (%rbx)
movsd %xmm0, 0x8(%rbx)
cmpl $0x0, 0x81a8c(%rbx)
je 0x57243
leaq 0x70e70(%rbx), %rdi
movl 0x81a78(%rbx), %edx
movl 0x81a7c(%rbx), %ecx
leaq 0x1e4cf(%rip), %rsi     # 0x756fb
movl %r14d, %r8d
movsd -0x20(%rbp), %xmm0
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x8120
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/skytraq.cpp
// Function: bamboo::decode_stqgloe(bamboo::raw_t*)
static int decode_stqgloe(raw_t *raw)
{
    int prn,sat;
    unsigned char *p=raw->buff+4;
    
    trace(4,"decode_stqgloe: len=%d\n",raw->len);
    
    if (raw->len<50) {
        trace(2,"stq glo string length error: len=%d\n",raw->len);
        return -1;
    }
    prn=U1(p+1);
    if (!(sat=satno(SYS_GLO,prn))) {
        trace(2,"stq gloe string satellite number error: prn=%d\n",prn);
        return -1;
    }
    /* set frequency channel number */
    raw->nav.geph[prn-1].frq=I1(p+2);
    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x81a78(%rdi), %edx
leaq 0x1d83b(%rip), %rsi     # 0x75a07
movl $0x4, %edi
xorl %eax, %eax
callq 0x4ded0
movl 0x81a78(%rbx), %edx
cmpl $0x31, %edx
jg 0x581f1
leaq 0x1d7a6(%rip), %rsi     # 0x75990
movl $0x2, %edi
jmp 0x5823c
movzbl 0x81a95(%rbx), %r14d
movl $0x4, %edi
movl %r14d, %esi
callq 0x4dbc5
testl %eax, %eax
je 0x5822d
movsbl 0x81a96(%rbx), %eax
movq 0x1d88(%rbx), %rcx
movl %r14d, %edx
imulq $0x98, %rdx, %rdx
movl %eax, -0x90(%rcx,%rdx)
xorl %eax, %eax
jmp 0x58248
leaq 0x1d7eb(%rip), %rsi     # 0x75a1f
movl $0x2, %edi
movl %r14d, %edx
xorl %eax, %eax
callq 0x4ded0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/skytraq.cpp
// Function: bamboo::decode_stqack(bamboo::raw_t*)
static int decode_stqack(raw_t *raw)
{
    unsigned char *p=raw->buff+4;
    
    trace(4,"decode_stqack: len=%d\n",raw->len);
    
    if (raw->len<9) {
        trace(2,"stq ack length error: len=%d\n",raw->len);
        return -1;
    }
    if (raw->outtype) {
        sprintf(raw->msgtype,"SKYTRAQ ACK   (%4d): msg=0x%02X",raw->len,
                U1(p+1));
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl 0x81a78(%rdi), %edx
leaq 0x1d51a(%rip), %rsi     # 0x75b39
xorl %ebx, %ebx
movl $0x4, %edi
xorl %eax, %eax
callq 0x4ded0
movl 0x81a78(%r14), %edx
cmpl $0x8, %edx
jg 0x58653
leaq 0x1d510(%rip), %rsi     # 0x75b50
movl $0x2, %edi
xorl %eax, %eax
callq 0x4ded0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x5867f
cmpl $0x0, 0x81a8c(%r14)
je 0x5867f
movzbl 0x81a95(%r14), %ecx
addq $0x70e70, %r14          # imm = 0x70E70
leaq 0x1d4fb(%rip), %rsi     # 0x75b6e
xorl %ebx, %ebx
movq %r14, %rdi
xorl %eax, %eax
callq 0x8120
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/skytraq.cpp
// Function: bamboo::decode_stqnack(bamboo::raw_t*)
static int decode_stqnack(raw_t *raw)
{
    unsigned char *p=raw->buff+4;
    
    trace(4,"decode_stqnack: len=%d\n",raw->len);
    
    if (raw->len<9) {
        trace(2,"stq nack length error: len=%d\n",raw->len);
        return -1;
    }
    if (raw->outtype) {
        sprintf(raw->msgtype,"SKYTRAQ NACK  (%4d): msg=0x%02X",raw->len,
                U1(p+1));
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl 0x81a78(%rdi), %edx
leaq 0x1d4f1(%rip), %rsi     # 0x75b8e
xorl %ebx, %ebx
movl $0x4, %edi
xorl %eax, %eax
callq 0x4ded0
movl 0x81a78(%r14), %edx
cmpl $0x8, %edx
jg 0x586d1
leaq 0x1d4e8(%rip), %rsi     # 0x75ba6
movl $0x2, %edi
xorl %eax, %eax
callq 0x4ded0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x586fd
cmpl $0x0, 0x81a8c(%r14)
je 0x586fd
movzbl 0x81a95(%r14), %ecx
addq $0x70e70, %r14          # imm = 0x70E70
leaq 0x1d4d4(%rip), %rsi     # 0x75bc5
xorl %ebx, %ebx
movq %r14, %rdi
xorl %eax, %eax
callq 0x8120
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/skytraq.cpp
// Function: bamboo::adj_utcweek(bamboo::gtime_t, double*)
static void adj_utcweek(gtime_t time, double *utc)
{
    int week;
    
    if (utc[3]>=256.0) return;
    time2gpst(time,&week);
    utc[3]+=week/256*256;
    if      (utc[3]<week-128) utc[3]+=256.0;
    else if (utc[3]>week+128) utc[3]-=256.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd 0x18(%rsi), %xmm1
ucomisd 0x17a4c(%rip), %xmm1    # 0x70168
jae 0x5878d
movq %rsi, %rbx
leaq -0x14(%rbp), %r14
movq %r14, %rsi
callq 0x4fc2d
movl (%r14), %eax
leal 0xff(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
addsd 0x18(%rbx), %xmm0
movsd %xmm0, 0x18(%rbx)
leal -0x80(%rax), %ecx
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x5876c
movsd 0x179fe(%rip), %xmm1    # 0x70168
jmp 0x58784
subl $-0x80, %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x5878d
movsd 0x1ce34(%rip), %xmm1    # 0x755b8
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::decodetcppath(char const*, char*, char*, char*, char*, char*, char*)
void decodetcppath(const char *path, char *addr, char *port, char *user,
		char *passwd, char *mntpnt, char *str)
	{
		char buff[MAXSTRPATH], *p, *q;

		tracet(4, "decodetcpepath: path=%s\n", path);

		if (port) *port = '\0';
		if (user) *user = '\0';
		if (passwd) *passwd = '\0';
		if (mntpnt) *mntpnt = '\0';
		if (str) *str = '\0';

		strcpy(buff, path);

		if (!(p = strrchr(buff, '@'))) p = buff;

		if ((p = strchr(p, '/'))) {
			if ((q = strchr(p + 1, ':'))) {
				*q = '\0'; if (str) strcpy(str, q + 1);
			}
			*p = '\0'; if (mntpnt) strcpy(mntpnt, p + 1);
		}
		if ((p = strrchr(buff, '@'))) {
			*p++ = '\0';
			if ((q = strchr(buff, ':'))) {
				*q = '\0'; if (passwd) strcpy(passwd, q + 1);
			}
			if (user) strcpy(user, buff);
		}
		else p = buff;

		if ((q = strchr(p, ':'))) {
			*q = '\0'; if (port) strcpy(port, q + 1);
		}
		if (addr) strcpy(addr, p);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp            # imm = 0x418
movq %r9, %rbx
movq %r8, %r13
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, -0x40(%rbp)
movq %rdi, %r14
leaq 0x1d612(%rip), %rsi     # 0x75dd8
movl $0x4, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x53ec4
testq %r12, %r12
je 0x587df
movb $0x0, (%r12)
testq %r15, %r15
je 0x587e8
movb $0x0, (%r15)
testq %r13, %r13
je 0x587f2
movb $0x0, (%r13)
movq 0x10(%rbp), %rax
testq %rbx, %rbx
je 0x587fe
movb $0x0, (%rbx)
movq %r13, -0x30(%rbp)
movq %r12, -0x38(%rbp)
testq %rax, %rax
je 0x5880e
movb $0x0, (%rax)
leaq -0x440(%rbp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x85c0
movq %r13, %rdi
movl $0x40, %esi
callq 0x86a0
testq %rax, %rax
cmoveq %r13, %rax
movq %rax, %rdi
movl $0x2f, %esi
callq 0x8250
testq %rax, %rax
je 0x5888c
movq %rax, %r14
movq %rax, %r12
incq %r12
movq %r12, %rdi
movl $0x3a, %esi
callq 0x8250
testq %rax, %rax
movq 0x10(%rbp), %rdi
je 0x58878
movb $0x0, (%rax)
testq %rdi, %rdi
je 0x58878
incq %rax
movq %rax, %rsi
callq 0x85c0
movb $0x0, (%r14)
testq %rbx, %rbx
je 0x5888c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x85c0
movq %r13, %rdi
movl $0x40, %esi
callq 0x86a0
testq %rax, %rax
movq -0x38(%rbp), %r14
je 0x588ef
movq %rax, %rbx
movb $0x0, (%rax)
leaq -0x440(%rbp), %rdi
movl $0x3a, %esi
callq 0x8250
testq %rax, %rax
movq -0x30(%rbp), %rdi
je 0x588d5
movb $0x0, (%rax)
testq %rdi, %rdi
je 0x588d5
incq %rax
movq %rax, %rsi
callq 0x85c0
incq %rbx
testq %r15, %r15
je 0x588ec
leaq -0x440(%rbp), %rsi
movq %r15, %rdi
callq 0x85c0
movq %rbx, %r13
movq %r13, %rdi
movl $0x3a, %esi
callq 0x8250
testq %rax, %rax
je 0x58917
movb $0x0, (%rax)
testq %r14, %r14
je 0x58917
incq %rax
movq %r14, %rdi
movq %rax, %rsi
callq 0x85c0
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x58928
movq %r13, %rsi
callq 0x85c0
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::strinit(bamboo::stream_t*)
extern void strinit(stream_t *stream)
	{
		tracet(3, "strinit:\n");

		stream->type = 0;
		stream->mode = 0;
		stream->state = 0;
		stream->inb = stream->inr = stream->outb = stream->outr = 0;
		stream->tick_i = stream->tick_o = stream->tact = stream->inbt = stream->outbt = 0;
		initlock(&stream->lock);
		stream->port = NULL;
		stream->path[0] = '\0';
		stream->msg[0] = '\0';
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1d49b(%rip), %rsi     # 0x75dfe
xorl %r14d, %r14d
movl $0x3, %edi
xorl %eax, %eax
callq 0x53ec4
leaq 0x30(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
xorl %esi, %esi
callq 0x8920
movq $0x0, 0x58(%rbx)
movb %r14b, 0x60(%rbx)
movb %r14b, 0x460(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::opentcpsvr(char const*, char*)
static tcpsvr_t *opentcpsvr(const char *path, char *msg)
	{
		tcpsvr_t *tcpsvr, tcpsvr0 = { {0} };
		char port[256] = "";

		tracet(3, "opentcpsvr: path=%s\n", path);

		if (!(tcpsvr = (tcpsvr_t *)malloc(sizeof(tcpsvr_t)))) return NULL;
		*tcpsvr = tcpsvr0;
		decodetcppath(path, tcpsvr->svr.saddr, port, NULL, NULL, NULL, NULL);
		if (sscanf(port, "%d", &tcpsvr->svr.port) < 1) {
			sprintf(msg, "port error: %s", port);
			tracet(1, "opentcpsvr: port error port=%s\n", port);
			free(tcpsvr);
			return NULL;
		}
		if (!gentcp(&tcpsvr->svr, 0, msg)) {
			free(tcpsvr);
			return NULL;
		}
		tcpsvr->svr.tcon = 0;
		return tcpsvr;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rsi, %r14
movq %rdi, %r15
leaq -0x120(%rbp), %rdi
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x8390
leaq 0x1cd61(%rip), %rsi     # 0x76110
movl $0x3, %edi
movq %r15, %rdx
xorl %eax, %eax
callq 0x53ec4
movl $0x12928, %edi          # imm = 0x12928
callq 0x8850
testq %rax, %rax
je 0x5947e
movq %rax, %rbx
movl $0x12928, %edx          # imm = 0x12928
movq %rax, %rdi
xorl %esi, %esi
callq 0x8390
leaq 0x4(%rbx), %rsi
movq $0x0, (%rsp)
leaq -0x120(%rbp), %r12
movq %r15, %rdi
movq %r12, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x58798
movq %rbx, %rdx
addq $0x104, %rdx            # imm = 0x104
leaq 0x1cd8c(%rip), %rsi     # 0x761a6
movq %r12, %rdi
xorl %eax, %eax
callq 0x8610
testl %eax, %eax
jle 0x59445
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x5cdef
testl %eax, %eax
je 0x59476
movl $0x0, 0x11c(%rbx)
jmp 0x59480
leaq 0x1ccd9(%rip), %rsi     # 0x76125
leaq -0x120(%rbp), %r15
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x8120
leaq 0x1cccd(%rip), %rsi     # 0x76134
movl $0x1, %edi
movq %r15, %rdx
xorl %eax, %eax
callq 0x53ec4
movq %rbx, %rdi
callq 0x87b0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::opentcpcli(char const*, char*)
static tcpcli_t *opentcpcli(const char *path, char *msg)
	{
		tcpcli_t *tcpcli, tcpcli0 = { {0} };
		char port[256] = "";

		tracet(3, "opentcpcli: path=%s\n", path);

		if (!(tcpcli = (tcpcli_t *)malloc(sizeof(tcpcli_t)))) return NULL;
		*tcpcli = tcpcli0;
		decodetcppath(path, tcpcli->svr.saddr, port, NULL, NULL, NULL, NULL);
		if (sscanf(port, "%d", &tcpcli->svr.port) < 1) {
			sprintf(msg, "port error: %s", port);
			tracet(1, "opentcp: port error port=%s\n", port);
			free(tcpcli);
			return NULL;
		}
		tcpcli->svr.tcon = 0;
		tcpcli->toinact = toinact;
		tcpcli->tirecon = ticonnect;
		return tcpcli;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rsi, %r14
movq %rdi, %r15
leaq -0x120(%rbp), %rdi
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x8390
leaq 0x1ce3c(%rip), %rsi     # 0x76301
movl $0x3, %edi
movq %r15, %rdx
xorl %eax, %eax
callq 0x53ec4
movl $0x130, %edi            # imm = 0x130
callq 0x8850
testq %rax, %rax
je 0x5959b
movq %rax, %rbx
movl $0x130, %edx            # imm = 0x130
movq %rax, %rdi
xorl %esi, %esi
callq 0x8390
leaq 0x4(%rbx), %rsi
movq $0x0, (%rsp)
leaq -0x120(%rbp), %r12
movq %r15, %rdi
movq %r12, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x58798
movq %rbx, %rdx
addq $0x104, %rdx            # imm = 0x104
leaq 0x1cc76(%rip), %rsi     # 0x761a6
movq %r12, %rdi
xorl %eax, %eax
callq 0x8610
testl %eax, %eax
jle 0x59562
movl $0x0, 0x11c(%rbx)
movl 0x3694e(%rip), %eax     # 0x8fe9c
movl %eax, 0x128(%rbx)
movl 0x36946(%rip), %eax     # 0x8fea0
movl %eax, 0x12c(%rbx)
jmp 0x5959d
leaq 0x1cbbc(%rip), %rsi     # 0x76125
leaq -0x120(%rbp), %r15
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x8120
leaq 0x1cd92(%rip), %rsi     # 0x76316
movl $0x1, %edi
movq %r15, %rdx
xorl %eax, %eax
callq 0x53ec4
movq %rbx, %rdi
callq 0x87b0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::openftp(char const*, int, char*)
static ftp_t *openftp(const char *path, int type, char *msg)
	{
		ftp_t *ftp;

		tracet(3, "openftp: path=%s type=%d\n", path, type);

		msg[0] = '\0';

		if (!(ftp = (ftp_t *)malloc(sizeof(ftp_t)))) return NULL;

		ftp->state = 0;
		ftp->proto = type;
		ftp->error = 0;
		ftp->thread = 0;
		ftp->local[0] = '\0';

		/* decode ftp path */
		decodeftppath(path, ftp->addr, ftp->file, ftp->user, ftp->passwd, ftp->topts);

		/* set first download time */
		ftp->tnext = timeadd(timeget(), 10.0);

		return ftp;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r12
leaq 0x1cba2(%rip), %rsi     # 0x76509
xorl %r13d, %r13d
movl $0x3, %edi
movq %r12, %rdx
movl %r14d, %ecx
xorl %eax, %eax
callq 0x53ec4
movb $0x0, (%rbx)
movl $0xe38, %edi            # imm = 0xE38
callq 0x8850
testq %rax, %rax
je 0x59b12
movq %rax, %rbx
movl %r13d, (%rax)
movl %r14d, 0x4(%rax)
movl %r13d, 0x8(%rax)
movq $0x0, 0xe30(%rax)
movb %r13b, 0xa0c(%rax)
leaq 0x40c(%rax), %r15
leaq 0x1cb63(%rip), %rsi     # 0x76523
movl $0x4, %edi
movq %r12, %rdx
xorl %eax, %eax
callq 0x53ec4
movb %r13b, 0x80c(%rbx)
movb %r13b, 0x90c(%rbx)
movsd 0x1c3db(%rip), %xmm0    # 0x75dc0
movups %xmm0, 0xe0c(%rbx)
leaq -0x430(%rbp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x85c0
movq %r14, %rdi
movl $0x2f, %esi
callq 0x8250
testq %rax, %rax
je 0x59a6d
movq %rax, %r12
leaq 0x1(%rax), %r13
leaq 0x1c632(%rip), %rsi     # 0x76050
movq %r13, %rdi
callq 0x8160
testq %rax, %rax
je 0x59a5f
leaq 0xe0c(%rbx), %rdx
leaq 0xe10(%rbx), %rcx
leaq 0xe14(%rbx), %r8
leaq 0xe18(%rbx), %r9
movb $0x0, (%rax)
addq $0x2, %rax
leaq 0x1cae5(%rip), %rsi     # 0x7653a
movq %rax, %rdi
xorl %eax, %eax
callq 0x8610
movq %r15, %rdi
movq %r13, %rsi
callq 0x85c0
movq %r12, %r15
leaq 0xc(%rbx), %r12
movb $0x0, (%r15)
movq %r14, %rdi
movl $0x40, %esi
callq 0x86a0
testq %rax, %rax
je 0x59ae1
movq %rax, %r15
leaq 0x80c(%rbx), %r14
movb $0x0, (%rax)
leaq -0x430(%rbp), %rdi
movl $0x3a, %esi
callq 0x8250
movq %rax, %r13
testq %rax, %rax
je 0x59ac7
movq %rbx, %rdi
addq $0x90c, %rdi            # imm = 0x90C
movb $0x0, (%r13)
movq %r13, %rsi
incq %rsi
callq 0x85c0
incq %r15
movb $0x0, (%r13)
leaq -0x430(%rbp), %rsi
movq %r14, %rdi
callq 0x85c0
movq %r15, %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0x85c0
callq 0x4febe
movsd 0x10fcf(%rip), %xmm1    # 0x6aac8
movq %rax, %rdi
callq 0x4fe63
movq %rax, 0xe20(%rbx)
movsd %xmm0, 0xe28(%rbx)
jmp 0x59b14
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::closetcpsvr(bamboo::tcpsvr_tag*)
static void closetcpsvr(tcpsvr_t *tcpsvr)
	{
		int i;

		tracet(3, "closetcpsvr:\n");

		for (i = 0; i < MAXCLI; i++) {
			if (tcpsvr->cli[i].state) closesocket(tcpsvr->cli[i].sock);
		}
		closesocket(tcpsvr->svr.sock);
		free(tcpsvr);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1c846(%rip), %rsi     # 0x76584
movl $0x3, %edi
xorl %eax, %eax
callq 0x53ec4
movl $0x240, %r14d           # imm = 0x240
cmpl $0x0, -0x118(%rbx,%r14)
je 0x59d64
movl (%rbx,%r14), %edi
callq 0x8c50
addq $0x128, %r14            # imm = 0x128
cmpq $0x12a40, %r14          # imm = 0x12A40
jne 0x59d50
movl 0x118(%rbx), %edi
callq 0x8c50
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x87b0
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::closentripc(bamboo::ntripc_t*)
static void closentripc(ntripc_t *ntripc)
	{
		tracet(3, "closentripc: state=%d\n", ntripc->state);

		closetcpsvr(ntripc->tcp);
		free(ntripc->srctbl);
		free(ntripc);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edx
leaq 0x1c7ae(%rip), %rsi     # 0x765be
movl $0x3, %edi
xorl %eax, %eax
callq 0x53ec4
movq 0x338(%rbx), %rdi
callq 0x59d2d
movq 0x308(%rbx), %rdi
callq 0x87b0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x87b0
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/stream.cpp
// Function: bamboo::strsync(bamboo::stream_t*, bamboo::stream_t*)
extern void strsync(stream_t *stream1, stream_t *stream2)
	{
		file_t *file1, *file2;
		if (stream1->type != STR_FILE || stream2->type != STR_FILE) return;
		file1 = (file_t*)stream1->port;
		file2 = (file_t*)stream2->port;
		if (file1&&file2) syncfile(file1, file2);
	}

// Assembly:
cmpl $0x2, (%rdi)
jne 0x59ee9
cmpl $0x2, (%rsi)
jne 0x59ee9
movq 0x58(%rdi), %rcx
movq 0x58(%rsi), %rax
testq %rcx, %rcx
setne %dl
testq %rax, %rax
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x59ee9
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x8(%rcx)
je 0x59ee8
cmpq $0x0, 0x8(%rax)
je 0x59ee8
movl $0x0, 0x828(%rcx)
movl $0x1, 0x828(%rax)
movl 0x85c(%rcx), %ecx
subl 0x85c(%rax), %ecx
movl %ecx, 0x82c(%rax)
popq %rbp
retq