LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/lambda.cpp
// Function: bamboo::lambda_reduction(int, double const*, double*)
extern int lambda_reduction(int n, const double *Q, double *Z)
{
    double *L,*D;
    int i,j,info;
    
    if (n<=0) return -1;
    
    L=zeros(n,n); D=mat(n,1);
    
    for (i=0;i<n;i++) for (j=0;j<n;j++) {
        Z[i+j*n]=i==j?1.0:0.0;
    }
    /* LD factorization */
    if ((info=LD(n,Q,L,D))) {
        free(L); free(D);
        return info;
    }
    /* lambda reduction */
    reduction(n,L,D,Z);
     
    free(L); free(D);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edi, %edi
jle 0x33304
movq %rdx, %rbx
movq %rsi, %r13
movl %edi, %r15d
movl %edi, %esi
callq 0x4ddc1
movq %rax, %r14
movl %r15d, %edi
movl $0x1, %esi
callq 0x4dc73
movq %rax, %r12
movl %r15d, %eax
leaq (,%rax,8), %rcx
xorl %edx, %edx
movsd 0x3668c(%rip), %xmm0    # 0x69920
movq %rbx, %rsi
movq %rsi, %rdi
xorl %r8d, %r8d
movaps %xmm0, %xmm1
cmpq %r8, %rdx
je 0x332a8
xorps %xmm1, %xmm1
movsd %xmm1, (%rdi)
incq %r8
addq %rcx, %rdi
cmpq %r8, %rax
jne 0x3329d
incq %rdx
addq $0x8, %rsi
cmpq %rax, %rdx
jne 0x33297
movl %r15d, %edi
movq %r13, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x328d4
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x332f2
movl %r15d, %edi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x32a85
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x87a0
movq %r12, %rdi
callq 0x87a0
jmp 0x3330a
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movl %r13d, %eax
addq $0x8, %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/lambda.cpp
// Function: bamboo::lambda_search(int, int, double const*, double const*, double*, double*)
extern int lambda_search(int n, int m, const double *a, const double *Q,
                         double *F, double *s)
{
    double *L,*D;
    int info;
    
    if (n<=0||m<=0) return -1;
    
    L=zeros(n,n); D=mat(n,1);
    
    /* LD factorization */
    if ((info=LD(n,Q,L,D))) {
        free(L); free(D);
        return info;
    }
    /* mlambda search */
    info=search(n,m,L,D,a,F,s);
    
    free(L); free(D);
    return info;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
testl %edi, %edi
setle %al
testl %esi, %esi
setle %cl
orb %al, %cl
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jne 0x333bf
movl %esi, %r12d
movl %edi, %r13d
movq %r9, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movl %edi, %esi
callq 0x4ddc1
movq %rax, %rbx
movl %r13d, %edi
movl $0x1, %esi
callq 0x4dc73
movq %rax, %r14
movl %r13d, %edi
movq %r15, %rsi
movq %rbx, %r15
movq %rbx, %rdx
movq %rax, %rcx
callq 0x328d4
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x333af
movq -0x30(%rbp), %rax
movq %rax, (%rsp)
movl %r13d, %edi
movl %r12d, %esi
movq %r15, %rdx
movq %r14, %rcx
movq -0x38(%rbp), %r8
movq -0x40(%rbp), %r9
callq 0x32d70
movl %eax, %ebx
movq %r15, %rdi
callq 0x87a0
movq %r14, %rdi
callq 0x87a0
movl %ebx, %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/rcvraw.cpp
// Function: bamboo::getbits2(unsigned char const*, int, int, int, int)
static int getbits2(const unsigned char *buff, int p1, int l1, int p2, int l2)
{
    if (getbitu(buff,p1,1))
        return (int)((getbits(buff,p1,l1)<<l2)+getbitu(buff,p2,l2));
    else
        return (int)getbitu2(buff,p1,l1,p2,l2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %r14d
movl %edx, %r12d
movl %esi, %r13d
movq %rdi, %r15
movl $0x1, %edx
callq 0x4d9d6
movq %r15, %rdi
movl %r13d, %esi
movl %r12d, %edx
testl %eax, %eax
je 0x342da
callq 0x4da25
jmp 0x342df
callq 0x4d9d6
movl %eax, %r12d
movl %ebx, %ecx
shll %cl, %r12d
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
callq 0x4d9d6
addl %r12d, %eax
addq $0x8, %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/rcvraw.cpp
// Function: bamboo::getbits3(unsigned char const*, int, int, int, int, int, int)
static int getbits3(const unsigned char *buff, int p1, int l1, int p2, int l2,
                    int p3, int l3)
{
    if (getbitu(buff,p1,1))
        return (int)((getbits(buff,p1,l1)<<(l2+l3))+
                   (getbitu(buff,p2,l2)<<l3)+getbitu(buff,p3,l3));
    else
        return (int)getbitu3(buff,p1,l1,p2,l2,p3,l3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, -0x2c(%rbp)
movl %ecx, %r12d
movl %edx, %r13d
movl %esi, %r14d
movq %rdi, %r15
movl $0x1, %edx
callq 0x4d9d6
testl %eax, %eax
je 0x34f1a
movq %r15, %rdi
movl %r14d, %esi
movl %r13d, %edx
callq 0x4da25
movl %eax, %r14d
leal 0x16(%rbx), %ecx
shll %cl, %r14d
movq %r15, %rdi
movl %r12d, %esi
movl $0x16, %edx
callq 0x4d9d6
movl %eax, %r12d
movl %ebx, %ecx
shll %cl, %r12d
movq %r15, %rdi
movl -0x2c(%rbp), %esi
movl %ebx, %edx
callq 0x4d9d6
addl %r14d, %eax
addl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movl %r14d, %esi
movl %r13d, %edx
movl %r12d, %ecx
movl -0x2c(%rbp), %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34f3d
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/rcvraw.cpp
// Function: bamboo::test_glostr(unsigned char const*)
extern int test_glostr(const unsigned char *buff)
{
    static const unsigned char xor_8bit[256]={ /* xor of 8 bits */
        0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,
        1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,
        1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,
        0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,
        1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,
        0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,
        0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,
        1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0
    };
    static const unsigned char mask_hamming[][12]={ /* mask of hamming codes */
        {0x55,0x55,0x5A,0xAA,0xAA,0xAA,0xB5,0x55,0x6A,0xD8,0x08},
        {0x66,0x66,0x6C,0xCC,0xCC,0xCC,0xD9,0x99,0xB3,0x68,0x10},
        {0x87,0x87,0x8F,0x0F,0x0F,0x0F,0x1E,0x1E,0x3C,0x70,0x20},
        {0x07,0xF8,0x0F,0xF0,0x0F,0xF0,0x1F,0xE0,0x3F,0x80,0x40},
        {0xF8,0x00,0x0F,0xFF,0xF0,0x00,0x1F,0xFF,0xC0,0x00,0x80},
        {0x00,0x00,0x0F,0xFF,0xFF,0xFF,0xE0,0x00,0x00,0x01,0x00},
        {0xFF,0xFF,0xF0,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00},
        {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xF8}
    };
    unsigned char cs;
    int i,j,n=0;
    
    for (i=0;i<8;i++) {
        for (j=0,cs=0;j<11;j++) {
            cs^=xor_8bit[buff[j]&mask_hamming[i][j]];
        }
        if (cs) n++;
    }
    return n==0||(n==2&&cs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
leaq 0x37f64(%rip), %rdx     # 0x6cf10
leaq 0x37e5d(%rip), %rsi     # 0x6ce10
xorl %ecx, %ecx
xorl %r10d, %r10d
xorl %r11d, %r11d
movl %r11d, %r8d
movzbl (%rdi,%r10), %r9d
movzbl (%rdx,%r10), %r11d
andl %r9d, %r11d
movb (%r11,%rsi), %r9b
movl %r9d, %r11d
xorb %r8b, %r11b
incq %r10
cmpq $0xb, %r10
jne 0x34fbb
xorl %r10d, %r10d
cmpb %r8b, %r9b
setne %r10b
addl %r10d, %ecx
incq %rax
addq $0xc, %rdx
cmpq $0x8, %rax
jne 0x34fb5
cmpb %r8b, %r9b
setne %al
testl %ecx, %ecx
sete %dl
cmpl $0x2, %ecx
sete %cl
andb %al, %cl
orb %dl, %cl
movzbl %cl, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/rcvraw.cpp
// Function: bamboo::free_raw(bamboo::raw_t*)
extern void free_raw(raw_t *raw)
{
    half_cyc_t *p,*next;
    
    trace(3,"free_raw:\n");
    
    free(raw->obs.data ); raw->obs.data =NULL; raw->obs.n =0;
    free(raw->obuf.data); raw->obuf.data=NULL; raw->obuf.n=0;
    free(raw->nav.eph  ); raw->nav.eph  =NULL; raw->nav.n =0;
    free(raw->nav.alm  ); raw->nav.alm  =NULL; raw->nav.na=0;
    free(raw->nav.geph ); raw->nav.geph =NULL; raw->nav.ng=0;
    free(raw->nav.seph ); raw->nav.seph =NULL; raw->nav.ns=0;
    
    /* free half-cycle correction list */
    for (p=raw->half_cyc;p;p=next) {
        next=p->next;
        free(p);
    }
    raw->half_cyc=NULL;
    
    /* free receiver dependent data */
    switch (raw->format) {
       // case STRFMT_CMR : free_cmr (raw); break;
        case STRFMT_RT17: free_rt17(raw); break;
    }
    raw->rcv_data=NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x368ab(%rip), %rsi     # 0x6d1ca
xorl %r14d, %r14d
movl $0x3, %edi
xorl %eax, %eax
callq 0x4d55d
movq 0x1d28(%rbx), %rdi
callq 0x87a0
movq %r14, 0x1d28(%rbx)
movl %r14d, 0x1d20(%rbx)
movq 0x1d38(%rbx), %rdi
callq 0x87a0
movq %r14, 0x1d38(%rbx)
movl %r14d, 0x1d30(%rbx)
movq 0x1d80(%rbx), %rdi
callq 0x87a0
movq %r14, 0x1d80(%rbx)
movl %r14d, 0x1d40(%rbx)
movq 0x1da8(%rbx), %rdi
callq 0x87a0
movq %r14, 0x1da8(%rbx)
movl %r14d, 0x1d68(%rbx)
movq 0x1d88(%rbx), %rdi
callq 0x87a0
movq %r14, 0x1d88(%rbx)
movl %r14d, 0x1d48(%rbx)
movq 0x1d90(%rbx), %rdi
callq 0x87a0
movq %r14, 0x1d90(%rbx)
movl %r14d, 0x1d50(%rbx)
movq 0x82b90(%rbx), %rdi
testq %rdi, %rdi
je 0x369e7
movq 0x28(%rdi), %r14
callq 0x87a0
movq %r14, %rdi
testq %r14, %r14
jne 0x369d6
movq $0x0, 0x82b90(%rbx)
cmpl $0xc, 0x82b98(%rbx)
jne 0x36a03
movq %rbx, %rdi
callq 0x37150
movq $0x0, 0x82ba0(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/rcvraw.cpp
// Function: bamboo::input_raw(bamboo::raw_t*, int, unsigned char)
extern int input_raw(raw_t *raw, int format, unsigned char data)
{
    trace(5,"input_raw: format=%d data=0x%02x\n",format,data);
    
    switch (format) {
//        case STRFMT_OEM4 : return input_oem4 (raw,data);
//        case STRFMT_OEM3 : return input_oem3 (raw,data);
        case STRFMT_UBX  : return input_ubx  (raw,data);
//        case STRFMT_SS2  : return input_ss2  (raw,data);
//        case STRFMT_CRES : return input_cres (raw,data);
        case STRFMT_STQ  : return input_stq  (raw,data);
//        case STRFMT_GW10 : return input_gw10 (raw,data);
//        case STRFMT_JAVAD: return input_javad(raw,data);
//        case STRFMT_NVS  : return input_nvs  (raw,data);
        case STRFMT_BINEX: return input_bnx  (raw,data);
        case STRFMT_RT17 : return input_rt17 (raw,data);
//        case STRFMT_SEPT : return input_sbf  (raw,data);
//        case STRFMT_CMR  : return input_cmr  (raw,data);
//        case STRFMT_TERSUS: return input_tersus(raw,data);
//        case STRFMT_LEXR : return input_lexr (raw,data);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x367a8(%rip), %rsi     # 0x6d1d5
movl $0x5, %edi
movl %r15d, %edx
movl %r14d, %ecx
xorl %eax, %eax
callq 0x4d55d
addl $-0x4, %r15d
cmpl $0x8, %r15d
ja 0x36ab1
leaq 0x36374(%rip), %rax     # 0x6cdc4
movslq (%rax,%r15,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movzbl %r14b, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5eac4
movzbl %r14b, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2de9c
movzbl %r14b, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x55eb0
movzbl %r14b, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x37278
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/rcvraw.cpp
// Function: bamboo::input_rawf(bamboo::raw_t*, int, _IO_FILE*)
extern int input_rawf(raw_t *raw, int format, FILE *fp)
{
    trace(4,"input_rawf: format=%d\n",format);
    
    switch (format) {
//        case STRFMT_OEM4 : return input_oem4f (raw,fp);
//        case STRFMT_OEM3 : return input_oem3f (raw,fp);
        case STRFMT_UBX  : return input_ubxf  (raw,fp);
//        case STRFMT_SS2  : return input_ss2f  (raw,fp);
//        case STRFMT_CRES : return input_cresf (raw,fp);
        case STRFMT_STQ  : return input_stqf  (raw,fp);
//        case STRFMT_GW10 : return input_gw10f (raw,fp);
//        case STRFMT_JAVAD: return input_javadf(raw,fp);
//        case STRFMT_NVS  : return input_nvsf  (raw,fp);
        case STRFMT_BINEX: return input_bnxf  (raw,fp);
        case STRFMT_RT17 : return input_rt17f (raw,fp);
//        case STRFMT_SEPT : return input_sbff  (raw,fp);
//        case STRFMT_CMR  : return input_cmrf  (raw,fp);
//        case STRFMT_TERSUS: return input_tersusf(raw,fp);
//        case STRFMT_LEXR : return input_lexrf (raw,fp);
    }
    return -2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
leaq 0x3671f(%rip), %rsi     # 0x6d1f7
movl $0x4, %edi
movl %r15d, %edx
xorl %eax, %eax
callq 0x4d55d
addl $-0x4, %r15d
cmpl $0x8, %r15d
ja 0x36b55
leaq 0x362f0(%rip), %rax     # 0x6cde8
movslq (%rax,%r15,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x60bcf
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x32418
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x56189
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x386ec
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/rt17.cpp
// Function: bamboo::free_rt17(bamboo::raw_t*)
EXPORT void free_rt17(raw_t *Raw)
{
    rt17_t *rt17 = NULL;
    
    if (Raw->format != STRFMT_RT17)
        return;
 
    if ((rt17 = (rt17_t*) Raw->rcv_data))
    {
        if (rt17->MessageBuffer)
        {
            memset(rt17->MessageBuffer, 0, MBUFF_LENGTH);
            free(rt17->MessageBuffer);
            rt17->MessageBuffer = NULL;
        }

        if (rt17->PacketBuffer)
        {
            memset(rt17->PacketBuffer, 0, PBUFF_LENGTH);
            free(rt17->PacketBuffer);
            rt17->PacketBuffer = NULL;
        }

        memset(rt17, 0, sizeof(rt17_t));
        free(rt17);
        Raw->rcv_data = NULL;
    }
}

// Assembly:
cmpl $0xc, 0x82b98(%rdi)
jne 0x371c7
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x82ba0(%rdi), %r14
testq %r14, %r14
je 0x371c3
movq (%r14), %rdi
testq %rdi, %rdi
je 0x37192
movl $0x2000, %edx           # imm = 0x2000
xorl %esi, %esi
callq 0x8390
movq (%r14), %rdi
callq 0x87a0
movq $0x0, (%r14)
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x371b0
movl $0x105, %edx            # imm = 0x105
xorl %esi, %esi
callq 0x8390
movq 0x8(%r14), %rdi
callq 0x87a0
movq %r14, %rdi
callq 0x87a0
movq $0x0, 0x82ba0(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/rt17.cpp
// Function: bamboo::init_rt17(bamboo::raw_t*)
EXPORT int init_rt17(raw_t *Raw)
{
	rt17_t *rt17 = NULL;
    unsigned char *MessageBuffer = NULL, *PacketBuffer = NULL;

    if (Raw->format != STRFMT_RT17)
       return 0;
 
    if (!(rt17 = (rt17_t*) calloc(1, sizeof(rt17_t))))
    {
        tracet(0, "RT17: unable to allocate RT17 dependent private data structure.\n");
        return 0;
    }
    Raw->rcv_data = (void*) rt17;
    
    if (!(MessageBuffer = (unsigned char*) calloc(MBUFF_LENGTH, sizeof(unsigned char))))
    {
        tracet(0, "RT17: unable to allocate RT17 message buffer.\n");
        free_rt17(Raw);
        return 0;
    }
    rt17->MessageBuffer = MessageBuffer;

    if (!(PacketBuffer = (unsigned char*) calloc(PBUFF_LENGTH, sizeof(unsigned char))))
    {
        tracet(0, "RT17: unable to allocate RT17 packet buffer.\n");
        free_rt17(Raw);
        return 0;
    }
    rt17->PacketBuffer = PacketBuffer;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
xorl %r14d, %r14d
cmpl $0xc, 0x82b98(%rdi)
jne 0x37270
movq %rdi, %rbx
movl $0x1, %edi
movl $0x38, %esi
callq 0x8440
testq %rax, %rax
je 0x37237
movq %rax, %r14
movq %rax, 0x82ba0(%rbx)
movl $0x2000, %edi           # imm = 0x2000
movl $0x1, %esi
callq 0x8440
testq %rax, %rax
je 0x3724c
movq %rax, (%r14)
movl $0x105, %edi            # imm = 0x105
movl $0x1, %esi
callq 0x8440
testq %rax, %rax
je 0x37255
movq %rax, 0x8(%r14)
movl $0x1, %r14d
jmp 0x37270
leaq 0x360fa(%rip), %rsi     # 0x6d338
xorl %r14d, %r14d
xorl %edi, %edi
xorl %eax, %eax
callq 0x5342c
jmp 0x37270
leaq 0x36126(%rip), %rsi     # 0x6d379
jmp 0x3725c
leaq 0x3614c(%rip), %rsi     # 0x6d3a8
xorl %r14d, %r14d
xorl %edi, %edi
xorl %eax, %eax
callq 0x5342c
movq %rbx, %rdi
callq 0x37150
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/rt17.cpp
// Function: bamboo::input_rt17f(bamboo::raw_t*, _IO_FILE*)
EXPORT int input_rt17f(raw_t *Raw, FILE *fp)
{
    int i, Data, Ret;
    
    for (i = 0; i < 4096; i++)
    {
	if ((Data = fgetc(fp)) == EOF) return -2;
	    if ((Ret = input_rt17(Raw, (unsigned char) Data))) return Ret;
    }

    return 0; /* return at every 4k bytes */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1000, %r15d          # imm = 0x1000
movq %rbx, %rdi
callq 0x89c0
cmpl $-0x1, %eax
je 0x38727
movzbl %al, %esi
movq %r14, %rdi
callq 0x37278
testl %eax, %eax
jne 0x3872c
decl %r15d
jne 0x38702
xorl %eax, %eax
jmp 0x3872c
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/rt17.cpp
// Function: bamboo::SetWeek(bamboo::raw_t*, int, double)
static void SetWeek(raw_t *Raw, int Week, double Tow)
{
    rt17_t *rt17 = (rt17_t*) Raw->rcv_data;

    if (!(rt17->Flags & M_WEEK_OPTION))
    {
        if (rt17->Week)
        {
            if (Week != rt17->Week)
            {
                if (Week == (rt17->Week + 1))
                    tracet(2, "RT17: GPS WEEK rolled over from %d to %d.\n", rt17->Week, Week);
                else
                    tracet(2, "RT17: GPS WEEK changed from %d to %d.\n", rt17->Week, Week);
            }
        }
        else
            tracet(2, "RT17: GPS WEEK initially set to %d.\n", Week);

        rt17->Week = Week;
    }

    /* Also update the time if we can */
    if (Week && (Tow != 0.0))
        Raw->time = gpst2time(Week, Tow);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movq 0x82ba0(%rdi), %r15
testb $0x1, 0x18(%r15)
jne 0x387b4
movl 0x34(%r15), %edx
testl %edx, %edx
je 0x38778
cmpl %r14d, %edx
je 0x387b0
movsd %xmm0, -0x20(%rbp)
leal 0x1(%rdx), %eax
cmpl %r14d, %eax
jne 0x38795
leaq 0x3519b(%rip), %rsi     # 0x6d911
jmp 0x3879c
leaq 0x351e4(%rip), %rsi     # 0x6d963
movl $0x2, %edi
movl %r14d, %edx
xorl %eax, %eax
movsd %xmm0, -0x20(%rbp)
callq 0x5342c
jmp 0x387ab
leaq 0x351a0(%rip), %rsi     # 0x6d93c
movl $0x2, %edi
movl %r14d, %ecx
xorl %eax, %eax
callq 0x5342c
movsd -0x20(%rbp), %xmm0
movl %r14d, 0x34(%r15)
testl %r14d, %r14d
je 0x387d5
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x387c5
jnp 0x387d5
movl %r14d, %edi
callq 0x4f24a
movq %rax, (%rbx)
movsd %xmm0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/rtcm.cpp
// Function: bamboo::free_rtcm(bamboo::rtcm_t*)
extern void free_rtcm(rtcm_t *rtcm)
{
    trace(3,"free_rtcm:\n");
    
    /* free memory for observation and ephemeris buffer */
    free(rtcm->obs.data); rtcm->obs.data=NULL; rtcm->obs.n=0;
    free(rtcm->nav.eph ); rtcm->nav.eph =NULL; rtcm->nav.n=0;
    free(rtcm->nav.geph); rtcm->nav.geph=NULL; rtcm->nav.ng=0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x35570(%rip), %rsi     # 0x6e1ed
xorl %r14d, %r14d
movl $0x3, %edi
xorl %eax, %eax
callq 0x4d55d
movq 0x38(%rbx), %rdi
callq 0x87a0
movq %r14, 0x38(%rbx)
movl %r14d, 0x30(%rbx)
movq 0x80(%rbx), %rdi
callq 0x87a0
movq %r14, 0x80(%rbx)
movl %r14d, 0x40(%rbx)
movq 0x88(%rbx), %rdi
callq 0x87a0
movq %r14, 0x88(%rbx)
movl %r14d, 0x48(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/rtcm.cpp
// Function: bamboo::input_rtcm2(bamboo::rtcm_t*, unsigned char)
extern int input_rtcm2(rtcm_t *rtcm, unsigned char data)
{
    unsigned char preamb;
    int i;
    
    trace(5,"input_rtcm2: data=%02x\n",data);
    
    if ((data&0xC0)!=0x40) return 0; /* ignore if upper 2bit != 01 */
    
    for (i=0;i<6;i++,data>>=1) { /* decode 6-of-8 form */
        rtcm->word=(rtcm->word<<1)+(data&1);
        
        /* synchronize frame */
        if (rtcm->nbyte==0) {
            preamb=(unsigned char)(rtcm->word>>22);
            if (rtcm->word&0x40000000) preamb^=0xFF; /* decode preamble */
            if (preamb!=RTCM2PREAMB) continue;
            
            /* check parity */
            if (!decode_word(rtcm->word,rtcm->buff)) continue;
            rtcm->nbyte=3; rtcm->nbit=0;
            continue;
        }
        if (++rtcm->nbit<30) continue; else rtcm->nbit=0;
        
        /* check parity */
        if (!decode_word(rtcm->word,rtcm->buff+rtcm->nbyte)) {
            trace(2,"rtcm2 partity error: i=%d word=%08x\n",i,rtcm->word);
            rtcm->nbyte=0; rtcm->word&=0x3;
            continue;
        }
        rtcm->nbyte+=3;
        if (rtcm->nbyte==6) rtcm->len=(rtcm->buff[5]>>3)*3+6;
        if (rtcm->nbyte<rtcm->len) continue;
        rtcm->nbyte=0; rtcm->word&=0x3;
        
        /* decode rtcm2 message */
        return decode_rtcm2(rtcm);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x3550e(%rip), %rsi     # 0x6e1f9
movl $0x5, %edi
movl %r14d, %edx
xorl %eax, %eax
callq 0x4d55d
movl %r14d, %eax
andl $-0x40, %eax
cmpl $0x40, %eax
jne 0x38e08
leaq 0x9f0c4(%rbx), %r15
leaq 0x354fa(%rip), %r12     # 0x6e211
xorl %r13d, %r13d
movl 0x9f574(%rbx), %eax
movl %r14d, %ecx
andb $0x1, %cl
movzbl %cl, %ecx
leal (%rcx,%rax,2), %edi
movl %edi, 0x9f574(%rbx)
movslq 0x9f0b8(%rbx), %rsi
testq %rsi, %rsi
je 0x38d98
movl 0x9f0bc(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x9f0bc(%rbx)
cmpl $0x1d, %eax
jl 0x38df8
movl $0x0, 0x9f0bc(%rbx)
addq %r15, %rsi
callq 0x4dbf3
testl %eax, %eax
je 0x38dc3
movl 0x9f0b8(%rbx), %eax
addl $0x3, %eax
movl %eax, 0x9f0b8(%rbx)
cmpl $0x6, %eax
jne 0x38dee
movzbl 0x9f0c9(%rbx), %ecx
shrl $0x3, %ecx
leal (%rcx,%rcx,2), %ecx
addl $0x6, %ecx
movl %ecx, 0x9f0c0(%rbx)
jmp 0x38df4
leal (%rax,%rax), %ecx
shrl $0x16, %ecx
shll $0x2, %eax
sarl $0x1f, %eax
xorl %ecx, %eax
cmpb $0x66, %al
jne 0x38df8
movq %r15, %rsi
callq 0x4dbf3
testl %eax, %eax
je 0x38df8
movq $0x3, 0x9f0b8(%rbx)
jmp 0x38df8
movl 0x9f574(%rbx), %ecx
movl $0x2, %edi
movq %r12, %rsi
movl %r13d, %edx
xorl %eax, %eax
callq 0x4d55d
movl $0x0, 0x9f0b8(%rbx)
andl $0x3, 0x9f574(%rbx)
jmp 0x38df8
movl 0x9f0c0(%rbx), %ecx
cmpl %ecx, %eax
jge 0x38e19
incl %r13d
shrb %r14b
cmpl $0x6, %r13d
jne 0x38d1a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x0, 0x9f0b8(%rbx)
andl $0x3, 0x9f574(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x391a8
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/rtcm.cpp
// Function: bamboo::input_rtcm3(bamboo::rtcm_t*, unsigned char)
extern int input_rtcm3(rtcm_t *rtcm, unsigned char data)
{
    trace(5,"input_rtcm3: data=%02x\n",data);
    
    /* synchronize frame */
    if (rtcm->nbyte==0) {
        if (data!=RTCM3PREAMB) return 0;
        rtcm->buff[rtcm->nbyte++]=data;
        return 0;
    }
    rtcm->buff[rtcm->nbyte++]=data;
    
    if (rtcm->nbyte==3) {
        rtcm->len=getbitu(rtcm->buff,14,10)+3; /* length without parity */
    }
    if (rtcm->nbyte<3||rtcm->nbyte<rtcm->len+3) return 0;
    rtcm->nbyte=0;
    
    /* check parity */
    if (rtk_crc24q(rtcm->buff,rtcm->len)!=getbitu(rtcm->buff,rtcm->len*8,24)) {
        trace(2,"rtcm3 parity error: len=%d\n",rtcm->len);
        return 0;
    }
    /* decode rtcm3 message */
    return decode_rtcm3(rtcm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x353df(%rip), %rsi     # 0x6e236
movl $0x5, %edi
movl %r15d, %edx
xorl %eax, %eax
callq 0x4d55d
movslq 0x9f0b8(%rbx), %rax
testq %rax, %rax
je 0x38f12
leaq 0x9f0c4(%rbx), %r14
leal 0x1(%rax), %ecx
movl %ecx, 0x9f0b8(%rbx)
movb %r15b, 0x9f0c4(%rbx,%rax)
movl 0x9f0b8(%rbx), %eax
cmpl $0x3, %eax
jne 0x38eba
movq %r14, %rdi
movl $0xe, %esi
movl $0xa, %edx
callq 0x4d9d6
addl $0x3, %eax
movl %eax, 0x9f0c0(%rbx)
movl 0x9f0b8(%rbx), %eax
cmpl $0x3, %eax
jl 0x38f44
movl 0x9f0c0(%rbx), %esi
leal 0x3(%rsi), %ecx
cmpl %ecx, %eax
jl 0x38f44
movl $0x0, 0x9f0b8(%rbx)
movq %r14, %rdi
callq 0x4db73
movl %eax, %r15d
movl 0x9f0c0(%rbx), %esi
shll $0x3, %esi
movq %r14, %rdi
movl $0x18, %edx
callq 0x4d9d6
cmpl %eax, %r15d
jne 0x38f2b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3a7fc
cmpb $-0x2d, %r15b
jne 0x38f44
movl $0x1, 0x9f0b8(%rbx)
movb $-0x2d, 0x9f0c4(%rbx)
jmp 0x38f44
movl 0x9f0c0(%rbx), %edx
leaq 0x35316(%rip), %rsi     # 0x6e24e
movl $0x2, %edi
xorl %eax, %eax
callq 0x4d55d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/rtcm.cpp
// Function: bamboo::input_rtcm2f(bamboo::rtcm_t*, _IO_FILE*)
extern int input_rtcm2f(rtcm_t *rtcm, FILE *fp)
{
    int i,data=0,ret;
    
    trace(4,"input_rtcm2f: data=%02x\n",data);
    
    for (i=0;i<4096;i++) {
        if ((data=fgetc(fp))==EOF) return -2;
        if ((ret=input_rtcm2(rtcm,(unsigned char)data))) return ret;
    }
    return 0; /* return at every 4k bytes */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x35302(%rip), %rsi     # 0x6e26a
movl $0x4, %edi
xorl %edx, %edx
xorl %eax, %eax
callq 0x4d55d
movl $0x1000, %r15d          # imm = 0x1000
movq %rbx, %rdi
callq 0x89c0
cmpl $-0x1, %eax
je 0x38fa1
movzbl %al, %esi
movq %r14, %rdi
callq 0x38cd0
testl %eax, %eax
jne 0x38fa6
decl %r15d
jne 0x38f7c
xorl %eax, %eax
jmp 0x38fa6
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/rtcm.cpp
// Function: bamboo::input_rtcm3f(bamboo::rtcm_t*, _IO_FILE*)
extern int input_rtcm3f(rtcm_t *rtcm, FILE *fp)
{
    int i,data=0,ret;
    
    trace(4,"input_rtcm3f: data=%02x\n",data);
    
    for (i=0;i<4096;i++) {
        if ((data=fgetc(fp))==EOF) return -2;
        if ((ret=input_rtcm3(rtcm,(unsigned char)data))) return ret;
    }
    return 0; /* return at every 4k bytes */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x352bb(%rip), %rsi     # 0x6e283
movl $0x4, %edi
xorl %edx, %edx
xorl %eax, %eax
callq 0x4d55d
movl $0x1000, %r15d          # imm = 0x1000
movq %rbx, %rdi
callq 0x89c0
cmpl $-0x1, %eax
je 0x39001
movzbl %al, %esi
movq %r14, %rdi
callq 0x38e40
testl %eax, %eax
jne 0x39006
decl %r15d
jne 0x38fdc
xorl %eax, %eax
jmp 0x39006
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/rtcm.cpp
// Function: bamboo::gen_rtcm3(bamboo::rtcm_t*, int, int)
extern int gen_rtcm3(rtcm_t *rtcm, int type, int sync)
{
    unsigned int crc;
    int i=0;
    
    trace(4,"gen_rtcm3: type=%d sync=%d\n",type,sync);
    
    rtcm->nbit=rtcm->len=rtcm->nbyte=0;
    
    /* set preamble and reserved */
    setbitu(rtcm->buff,i, 8,RTCM3PREAMB); i+= 8;
    setbitu(rtcm->buff,i, 6,0          ); i+= 6;
    setbitu(rtcm->buff,i,10,0          ); i+=10;
    
    /* encode rtcm 3 message body */
    if (!encode_rtcm3(rtcm,type,sync)) return 0;
    
    /* padding to align 8 bit boundary */
    for (i=rtcm->nbit;i%8;i++) {
        setbitu(rtcm->buff,i,1,0);
    }
    /* message length (header+data) (bytes) */
    if ((rtcm->len=i/8)>=3+1024) {
        trace(2,"generate rtcm 3 message length error len=%d\n",rtcm->len-3);
        rtcm->nbit=rtcm->len=0;
        return 0;
    }
    /* message length without header and parity */
    setbitu(rtcm->buff,14,10,rtcm->len-3);
    
    /* crc-24q */
    crc=rtk_crc24q(rtcm->buff,rtcm->len);
    setbitu(rtcm->buff,i,24,crc);
    
    /* length total (bytes) */
    rtcm->nbyte=rtcm->len+3;
    
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r12d
movl %esi, %r13d
movq %rdi, %rbx
leaq 0x3524b(%rip), %rsi     # 0x6e2b8
xorl %r15d, %r15d
movl $0x4, %edi
movl %r13d, %edx
movl %r12d, %ecx
xorl %eax, %eax
callq 0x4d55d
movq $0x0, 0x9f0b8(%rbx)
movl $0x0, 0x9f0c0(%rbx)
leaq 0x9f0c4(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
movl $0x8, %edx
movl $0xd3, %ecx
callq 0x4da98
movq %r14, %rdi
movl $0x8, %esi
movl $0x6, %edx
xorl %ecx, %ecx
callq 0x4da98
movq %r14, %rdi
movl $0xe, %esi
movl $0xa, %edx
xorl %ecx, %ecx
callq 0x4da98
movq %rbx, %rdi
movl %r13d, %esi
movl %r12d, %edx
callq 0x43b34
testl %eax, %eax
je 0x39196
movl 0x9f0bc(%rbx), %r15d
testb $0x7, %r15b
je 0x39114
movq %r14, %rdi
movl %r15d, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x4da98
incl %r15d
jmp 0x390f7
movl %r15d, %eax
sarl $0x3, %eax
movl %eax, 0x9f0c0(%rbx)
leal -0x3(%rax), %ecx
cmpl $0x403, %eax            # imm = 0x403
jl 0x3914f
leaq 0x351a3(%rip), %rsi     # 0x6e2d4
xorl %r15d, %r15d
movl $0x2, %edi
movl %ecx, %edx
xorl %eax, %eax
callq 0x4d55d
movq $0x0, 0x9f0bc(%rbx)
jmp 0x39196
movq %r14, %rdi
movl $0xe, %esi
movl $0xa, %edx
callq 0x4da98
movl 0x9f0c0(%rbx), %esi
movq %r14, %rdi
callq 0x4db73
movq %r14, %rdi
movl %r15d, %esi
movl $0x18, %edx
movl %eax, %ecx
callq 0x4da98
movl 0x9f0c0(%rbx), %eax
addl $0x3, %eax
movl %eax, 0x9f0b8(%rbx)
movl $0x1, %r15d
movl %r15d, %eax
addq $0x8, %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/rtcm2.cpp
// Function: bamboo::decode_type3(bamboo::rtcm_t*)
static int decode_type3(rtcm_t *rtcm)
{
    int i=48;
    
    trace(4,"decode_type3: len=%d\n",rtcm->len);
    
    if (i+96<=rtcm->len*8) {
        rtcm->sta.pos[0]=getbits(rtcm->buff,i,32)*0.01; i+=32;
        rtcm->sta.pos[1]=getbits(rtcm->buff,i,32)*0.01; i+=32;
        rtcm->sta.pos[2]=getbits(rtcm->buff,i,32)*0.01;
    }
    else {
        trace(2,"rtcm2 3 length error: len=%d\n",rtcm->len);
        return -1;
    }
    return 5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x9f0c0(%rdi), %edx
leaq 0x34e38(%rip), %rsi     # 0x6e4a3
movl $0x4, %edi
xorl %eax, %eax
callq 0x4d55d
movl 0x9f0c0(%rbx), %edx
cmpl $0x12, %edx
jl 0x3970c
leaq 0x9f0c4(%rbx), %r14
movq %r14, %rdi
movl $0x30, %esi
movl $0x20, %edx
callq 0x4da25
cvtsi2sd %eax, %xmm0
mulsd 0x32115(%rip), %xmm0    # 0x6b7c0
movsd %xmm0, 0x6f108(%rbx)
movq %r14, %rdi
movl $0x50, %esi
movl $0x20, %edx
callq 0x4da25
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd 0x320ec(%rip), %xmm0    # 0x6b7c0
movsd %xmm0, 0x6f110(%rbx)
movq %r14, %rdi
movl $0x70, %esi
movl $0x20, %edx
callq 0x4da25
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd 0x320c3(%rip), %xmm0    # 0x6b7c0
movsd %xmm0, 0x6f118(%rbx)
movl $0x5, %eax
jmp 0x39724
leaq 0x34da6(%rip), %rsi     # 0x6e4b9
movl $0x2, %edi
xorl %eax, %eax
callq 0x4d55d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/rtcm2.cpp
// Function: bamboo::decode_type14(bamboo::rtcm_t*)
static int decode_type14(rtcm_t *rtcm)
{
    double zcnt;
    int i=48,week,hour,leaps;
    
    trace(4,"decode_type14: len=%d\n",rtcm->len);
    
    zcnt=getbitu(rtcm->buff,24,13);
    if (i+24<=rtcm->len*8) {
        week =getbitu(rtcm->buff,i,10); i+=10;
        hour =getbitu(rtcm->buff,i, 8); i+= 8;
        leaps=getbitu(rtcm->buff,i, 6);
    }
    else {
        trace(2,"rtcm2 14 length error: len=%d\n",rtcm->len);
        return -1;
    }
    week=adjgpsweek(week);
    rtcm->time=gpst2time(week,hour*3600.0+zcnt*0.6);
    rtcm->nav.leaps=leaps;
    return 6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x9f0c0(%rdi), %edx
leaq 0x34d90(%rip), %rsi     # 0x6e4d7
movl $0x4, %edi
xorl %eax, %eax
callq 0x4d55d
leaq 0x9f0c4(%rbx), %r15
movq %r15, %rdi
movl $0x18, %esi
movl $0xd, %edx
callq 0x4d9d6
movl 0x9f0c0(%rbx), %edx
cmpl $0x9, %edx
jl 0x3980e
movl %eax, %eax
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x30(%rbp)
movq %r15, %rdi
movl $0x30, %esi
movl $0xa, %edx
callq 0x4d9d6
movl %eax, %r12d
movq %r15, %rdi
movl $0x3a, %esi
movl $0x8, %edx
callq 0x4d9d6
movl %eax, %r13d
movl $0x6, %r14d
movq %r15, %rdi
movl $0x42, %esi
movl $0x6, %edx
callq 0x4d9d6
movl %eax, %r15d
movl %r12d, %edi
callq 0x4fe5d
xorps %xmm0, %xmm0
cvtsi2sd %r13d, %xmm0
movsd -0x30(%rbp), %xmm1
mulsd 0x34b1f(%rip), %xmm1    # 0x6e308
mulsd 0x310cf(%rip), %xmm0    # 0x6a8c0
addsd %xmm1, %xmm0
movl %eax, %edi
callq 0x4f24a
movq %rax, 0x10(%rbx)
movsd %xmm0, 0x18(%rbx)
movl %r15d, 0x2d0(%rbx)
jmp 0x39827
leaq 0x34cd9(%rip), %rsi     # 0x6e4ee
movl $0x2, %edi
xorl %eax, %eax
callq 0x4d55d
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r14d, %eax
addq $0x8, %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/rtcm2.cpp
// Function: bamboo::decode_type16(bamboo::rtcm_t*)
static int decode_type16(rtcm_t *rtcm)
{
    int i=48,n=0;
    
    trace(4,"decode_type16: len=%d\n",rtcm->len);
    
    while (i+8<=rtcm->len*8&&n<90) {
        rtcm->msg[n++]=getbitu(rtcm->buff,i,8); i+=8;
    }
    rtcm->msg[n]='\0';
    
    trace(3,"rtcm2 16 message: %s\n",rtcm->msg);
    return 9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x9f0c0(%rdi), %edx
leaq 0x34cb6(%rip), %rsi     # 0x6e50d
xorl %r15d, %r15d
movl $0x4, %edi
xorl %eax, %eax
callq 0x4d55d
cmpl $0x7, 0x9f0c0(%rbx)
jl 0x398b8
leaq 0x9f0c4(%rbx), %r14
movl $0x40, %r12d
xorl %r13d, %r13d
leal -0x10(%r12), %esi
movq %r14, %rdi
movl $0x8, %edx
callq 0x4d9d6
leaq 0x1(%r13), %r15
movb %al, 0x9b950(%rbx,%r13)
movl 0x9f0c0(%rbx), %eax
shll $0x3, %eax
cmpl %eax, %r12d
jg 0x398b8
addl $0x8, %r12d
cmpq $0x59, %r13
movq %r15, %r13
jb 0x3987f
movb $0x0, 0x9b950(%rbx,%r15)
addq $0x9b950, %rbx          # imm = 0x9B950
leaq 0x34c55(%rip), %rsi     # 0x6e524
movl $0x3, %edi
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4d55d
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/rtcm2.cpp
// Function: bamboo::decode_type22(bamboo::rtcm_t*)
static int decode_type22(rtcm_t *rtcm)
{
    double del[2][3]={{0}},hgt=0.0;
    int i=48,j,noh;
    
    trace(4,"decode_type22: len=%d\n",rtcm->len);
    
    if (i+24<=rtcm->len*8) {
        del[0][0]=getbits(rtcm->buff,i,8)/25600.0; i+=8;
        del[0][1]=getbits(rtcm->buff,i,8)/25600.0; i+=8;
        del[0][2]=getbits(rtcm->buff,i,8)/25600.0; i+=8;
    }
    else {
        trace(2,"rtcm2 22 length error: len=%d\n",rtcm->len);
        return -1;
    }
    if (i+24<=rtcm->len*8) {
        i+=5; noh=getbits(rtcm->buff,i,1); i+=1;
        hgt=noh?0.0:getbitu(rtcm->buff,i,18)/25600.0;
        i+=18;
    }
    if (i+24<=rtcm->len*8) {
        del[1][0]=getbits(rtcm->buff,i,8)/1600.0; i+=8;
        del[1][1]=getbits(rtcm->buff,i,8)/1600.0; i+=8;
        del[1][2]=getbits(rtcm->buff,i,8)/1600.0;
    }
    rtcm->sta.deltype=1; /* xyz */
    for (j=0;j<3;j++) rtcm->sta.del[j]=del[0][j];
    rtcm->sta.hgt=hgt;
    return 5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0x9f0c0(%rdi), %edx
leaq 0x340f7(%rip), %rsi     # 0x6e692
movl $0x4, %edi
xorl %eax, %eax
callq 0x4d55d
movl 0x9f0c0(%rbx), %edx
cmpl $0x9, %edx
jl 0x3a64b
leaq 0x9f0c4(%rbx), %r14
movq %r14, %rdi
movl $0x30, %esi
movl $0x8, %edx
callq 0x4da25
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x30(%rbp)
movq %r14, %rdi
movl $0x38, %esi
movl $0x8, %edx
callq 0x4da25
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x28(%rbp)
movq %r14, %rdi
movl $0x40, %esi
movl $0x8, %edx
callq 0x4da25
cvtsi2sd %eax, %xmm2
movl $0x48, %r15d
xorpd %xmm3, %xmm3
cmpl $0xb, 0x9f0c0(%rbx)
jle 0x3a691
movsd %xmm2, -0x20(%rbp)
movq %r14, %rdi
movl $0x4d, %esi
movl $0x1, %edx
callq 0x4da25
movl $0x60, %r15d
testl %eax, %eax
je 0x3a668
movsd -0x20(%rbp), %xmm2
xorpd %xmm3, %xmm3
jmp 0x3a691
leaq 0x34057(%rip), %rsi     # 0x6e6a9
movl $0x2, %edi
xorl %eax, %eax
callq 0x4d55d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x3a74c
movq %r14, %rdi
movl $0x4e, %esi
movl $0x12, %edx
callq 0x4d9d6
movl %eax, %eax
xorps %xmm3, %xmm3
cvtsi2sd %rax, %xmm3
divsd 0x33ca4(%rip), %xmm3    # 0x6e330
movsd -0x20(%rbp), %xmm2
movsd -0x30(%rbp), %xmm0
movsd 0x33c92(%rip), %xmm4    # 0x6e330
divsd %xmm4, %xmm0
movsd -0x28(%rbp), %xmm1
divsd %xmm4, %xmm1
divsd %xmm4, %xmm2
leal 0x18(%r15), %eax
movl 0x9f0c0(%rbx), %ecx
shll $0x3, %ecx
cmpl %ecx, %eax
jg 0x3a71d
movq %r14, %rdi
movl %r15d, %esi
movl $0x8, %edx
movsd %xmm0, -0x30(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x38(%rbp)
callq 0x4da25
leal 0x8(%r15), %esi
movq %r14, %rdi
movl $0x8, %edx
callq 0x4da25
orl $0x10, %r15d
movq %r14, %rdi
movl %r15d, %esi
movl $0x8, %edx
callq 0x4da25
movsd -0x38(%rbp), %xmm3
movsd -0x20(%rbp), %xmm2
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
movl $0x1, 0x6f100(%rbx)
movsd %xmm0, 0x6f120(%rbx)
movsd %xmm1, 0x6f128(%rbx)
movsd %xmm2, 0x6f130(%rbx)
movsd %xmm3, 0x6f138(%rbx)
movl $0x5, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/rtcm2.cpp
// Function: bamboo::obsindex(bamboo::obs_t*, bamboo::gtime_t, int)
static int obsindex(obs_t *obs, gtime_t time, int sat)
{
    int i,j;
    
    for (i=0;i<obs->n;i++) {
        if (obs->data[i].sat==sat) return i; /* field already exists */
    }
    if (i>=MAXOBS) return -1; /* overflow */
    
    /* add new field */
    obs->data[i].time=time;
    obs->data[i].sat=sat;
    for (j=0;j<NFREQ;j++) {
        obs->data[i].L[j]=obs->data[i].P[j]=0.0;
        obs->data[i].D[j]=0.0;
        obs->data[i].SNR[j]=obs->data[i].LLI[j]=obs->data[i].code[j]=0;
    }
    obs->n++;
    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rdi), %ecx
testl %ecx, %ecx
jle 0x3a790
movq 0x8(%rdi), %r8
addq $0x10, %r8
xorl %eax, %eax
movzbl (%r8), %r9d
cmpl %edx, %r9d
je 0x3a7f8
incq %rax
addq $0x60, %r8
cmpq %rax, %rcx
jne 0x3a76b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x3f, %ecx
jbe 0x3a792
jmp 0x3a7f8
xorl %ecx, %ecx
movq 0x8(%rdi), %r8
movl %ecx, %eax
shlq $0x5, %rax
leaq (%rax,%rax,2), %rax
movq %rsi, (%r8,%rax)
movsd %xmm0, 0x8(%r8,%rax)
movb %dl, 0x10(%r8,%rax)
xorl %edx, %edx
xorl %esi, %esi
movq 0x8(%rdi), %r8
addq %rax, %r8
movq %rdx, 0x38(%r8,%rsi,8)
movq %rdx, 0x20(%r8,%rsi,8)
movl $0x0, 0x50(%r8,%rsi,4)
movb %dl, 0x18(%rsi,%r8)
movq 0x8(%rdi), %r8
addq %rax, %r8
movb %dl, 0x15(%rsi,%r8)
movq 0x8(%rdi), %r8
addq %rax, %r8
movb %dl, 0x12(%rsi,%r8)
incq %rsi
cmpq $0x3, %rsi
jne 0x3a7b4
incl (%rdi)
movl %ecx, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/rtcm3.cpp
// Function: bamboo::decode_type1007(bamboo::rtcm_t*)
static int decode_type1007(rtcm_t *rtcm)
{
    char des[32]="";
    char *msg;
    int i=24+12,j,staid,n,setup;
    
    n=getbitu(rtcm->buff,i+12,8);
    
    if (i+28+8*n<=rtcm->len*8) {
        staid=getbitu(rtcm->buff,i,12); i+=12+8;
        for (j=0;j<n&&j<31;j++) {
            des[j]=(char)getbitu(rtcm->buff,i,8); i+=8;
        }
        setup=getbitu(rtcm->buff,i, 8);
    }
    else {
        trace(2,"rtcm3 1007 length error: len=%d\n",rtcm->len);
        return -1;
    }
    if (rtcm->outtype) {
        msg=rtcm->msgtype+strlen(rtcm->msgtype);
        sprintf(msg," staid=%4d",staid);
    }
    /* test station id */
    if (!test_staid(rtcm,staid)) return -1;
    
    strncpy(rtcm->sta.antdes,des,n); rtcm->sta.antdes[n]='\0';
    rtcm->sta.antsetup=setup;
    rtcm->sta.antsno[0]='\0';
    return 5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
leaq 0x9f0c4(%rdi), %r12
movq %r12, %rdi
movl $0x30, %esi
movl $0x8, %edx
callq 0x4d9d6
movl %eax, %r14d
leal 0x40(,%r14,8), %eax
movl 0x9f0c0(%rbx), %edx
leal (,%rdx,8), %ecx
cmpl %ecx, %eax
jle 0x3bc65
leaq 0x3346f(%rip), %rsi     # 0x6f0c3
movl $0x2, %edi
xorl %eax, %eax
callq 0x4d55d
jmp 0x3bd55
movq %r12, %rdi
movl $0x24, %esi
movl $0xc, %edx
callq 0x4d9d6
movl %eax, -0x2c(%rbp)
testl %r14d, %r14d
movq %r14, -0x38(%rbp)
jle 0x3bcc3
leal -0x1(%r14), %eax
cmpl $0x1e, %eax
movl $0x1e, %r15d
cmovbl %eax, %r15d
incl %r15d
movl $0x38, %r13d
xorl %r14d, %r14d
movq %r12, %rdi
movl %r13d, %esi
movl $0x8, %edx
callq 0x4d9d6
movb %al, -0x60(%rbp,%r14)
addl $0x8, %r13d
incq %r14
cmpq %r14, %r15
jne 0x3bca0
jmp 0x3bcc9
movl $0x38, %r13d
movq %r12, %rdi
movl %r13d, %esi
movl $0x8, %edx
callq 0x4d9d6
movl %eax, %r12d
cmpl $0x0, 0xc(%rbx)
movl -0x2c(%rbp), %r14d
je 0x3bd0e
leaq 0x9b9d0(%rbx), %rdi
callq 0x8290
leaq (%rbx,%rax), %rdi
addq $0x9b9d0, %rdi          # imm = 0x9B9D0
leaq 0x333e0(%rip), %rsi     # 0x6f0e4
movl %r14d, %edx
xorl %eax, %eax
callq 0x8120
movq %rbx, %rdi
movl %r14d, %esi
callq 0x426d9
testl %eax, %eax
movq -0x38(%rbp), %rax
je 0x3bd55
leaq 0x6efb8(%rbx), %rdi
movslq %eax, %r14
leaq -0x60(%rbp), %rsi
movq %r14, %rdx
callq 0x8350
xorl %eax, %eax
movb %al, 0x6efb8(%rbx,%r14)
movl %r12d, 0x6f0f8(%rbx)
movb %al, 0x6eff8(%rbx)
movl $0x5, %eax
jmp 0x3bd5a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x38, %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/rtcm3.cpp
// Function: bamboo::decode_type1029(bamboo::rtcm_t*)
static int decode_type1029(rtcm_t *rtcm)
{
    char *msg;
    int i=24+12,j,staid,mjd,tod,nchar,cunit;
    
    if (i+60<=rtcm->len*8) {
        staid=getbitu(rtcm->buff,i,12); i+=12;
        mjd  =getbitu(rtcm->buff,i,16); i+=16;
        tod  =getbitu(rtcm->buff,i,17); i+=17;
        nchar=getbitu(rtcm->buff,i, 7); i+= 7;
        cunit=getbitu(rtcm->buff,i, 8); i+= 8;
    }
    else {
        trace(2,"rtcm3 1029 length error: len=%d\n",rtcm->len);
        return -1;
    }
    if (i+nchar*8>rtcm->len*8) {
        trace(2,"rtcm3 1029 length error: len=%d nchar=%d\n",rtcm->len,nchar);
        return -1;
    } 
    for (j=0;j<nchar&&j<126;j++) {
        rtcm->msg[j]=getbitu(rtcm->buff,i,8); i+=8;
    }
    rtcm->msg[j]='\0';
    
    if (rtcm->outtype) {
        msg=rtcm->msgtype+strlen(rtcm->msgtype);
        sprintf(msg," staid=%4d text=%s",staid,rtcm->msg);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x9f0c0(%rdi), %edx
cmpl $0xc, %edx
jl 0x3d8e8
movq %rdi, %rbx
leaq 0x9f0c4(%rdi), %r15
movq %r15, %rdi
movl $0x24, %esi
movl $0xc, %edx
callq 0x4d9d6
movl %eax, %r12d
movq %r15, %rdi
movl $0x30, %esi
movl $0x10, %edx
callq 0x4d9d6
movq %r15, %rdi
movl $0x40, %esi
movl $0x11, %edx
callq 0x4d9d6
movq %r15, %rdi
movl $0x51, %esi
movl $0x7, %edx
callq 0x4d9d6
movl %eax, %r13d
movq %r15, %rdi
movl $0x58, %esi
movl $0x8, %edx
callq 0x4d9d6
leal 0x60(,%r13,8), %eax
movl 0x9f0c0(%rbx), %edx
leal (,%rdx,8), %ecx
cmpl %ecx, %eax
jle 0x3d913
leaq 0x31b3e(%rip), %rsi     # 0x6f415
movl $0x2, %edi
movl %r13d, %ecx
xorl %eax, %eax
callq 0x4d55d
jmp 0x3d8fb
leaq 0x31b05(%rip), %rsi     # 0x6f3f4
movl $0x2, %edi
xorl %eax, %eax
callq 0x4d55d
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %r13d, %r13d
jle 0x3d963
movl %r12d, -0x2c(%rbp)
decl %r13d
cmpl $0x7d, %r13d
movl $0x7d, %r14d
cmovbl %r13d, %r14d
incl %r14d
movl $0x60, %r13d
xorl %r12d, %r12d
movq %r15, %rdi
movl %r13d, %esi
movl $0x8, %edx
callq 0x4d9d6
movb %al, 0x9b950(%rbx,%r12)
addl $0x8, %r13d
incq %r12
cmpq %r12, %r14
jne 0x3d939
movl -0x2c(%rbp), %r12d
jmp 0x3d966
xorl %r14d, %r14d
movb $0x0, 0x9b950(%rbx,%r14)
cmpl $0x0, 0xc(%rbx)
movl $0x0, %r14d
je 0x3d901
leaq 0x9b950(%rbx), %r15
leaq 0x9b9d0(%rbx), %rdi
callq 0x8290
leaq (%rbx,%rax), %rdi
addq $0x9b9d0, %rdi          # imm = 0x9B9D0
leaq 0x31a9f(%rip), %rsi     # 0x6f43f
xorl %r14d, %r14d
movl %r12d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x8120
jmp 0x3d901
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rtklib/rtcm3.cpp
// Function: bamboo::decode_head1001(bamboo::rtcm_t*, int*)
static int decode_head1001(rtcm_t *rtcm, int *sync)
{
    double tow;
    char *msg,tstr[64];
    int i=24,staid,nsat,type;
    
    type=getbitu(rtcm->buff,i,12); i+=12;
    
    if (i+52<=rtcm->len*8) {
        staid=getbitu(rtcm->buff,i,12);       i+=12;
        tow  =getbitu(rtcm->buff,i,30)*0.001; i+=30;
        *sync=getbitu(rtcm->buff,i, 1);       i+= 1;
        nsat =getbitu(rtcm->buff,i, 5);
    }
    else {
        trace(2,"rtcm3 %d length error: len=%d\n",type,rtcm->len);
        return -1;
    }
    /* test station id */
    if (!test_staid(rtcm,staid)) return -1;
    
    adjweek(rtcm,tow);
    
    time2str(rtcm->time,tstr,2);
    trace(4,"decode_head1001: time=%s nsat=%d sync=%d\n",tstr,nsat,*sync);
    
    if (rtcm->outtype) {
        msg=rtcm->msgtype+strlen(rtcm->msgtype);
        sprintf(msg," staid=%4d %s nsat=%2d sync=%d",staid,tstr,nsat,*sync);
    }
    return nsat;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9f0c4(%rdi), %r12
movq %r12, %rdi
movl $0x18, %esi
movl $0xc, %edx
callq 0x4d9d6
movl 0x9f0c0(%r14), %ecx
cmpl $0xb, %ecx
jl 0x426ac
movq %r12, %rdi
movl $0x24, %esi
movl $0xc, %edx
callq 0x4d9d6
movl %eax, %r15d
movq %r12, %rdi
movl $0x30, %esi
movl $0x1e, %edx
callq 0x4d9d6
movl %eax, %r13d
movq %r12, %rdi
movl $0x4e, %esi
movl $0x1, %edx
callq 0x4d9d6
movl %eax, (%rbx)
movq %r12, %rdi
movl $0x4f, %esi
movl $0x5, %edx
callq 0x4d9d6
movl %eax, %r12d
movq %r14, %rdi
movl %r15d, %esi
callq 0x426d9
testl %eax, %eax
je 0x426c1
movl %r13d, %eax
cvtsi2sd %rax, %xmm0
mulsd 0x29746(%rip), %xmm0    # 0x6bd78
movq %r14, %rdi
callq 0x42786
movq 0x10(%r14), %rdi
movsd 0x18(%r14), %xmm0
leaq -0x70(%rbp), %r13
movq %r13, %rsi
movl $0x2, %edx
callq 0x4fcf1
movl (%rbx), %r8d
leaq 0x2c907(%rip), %rsi     # 0x6ef66
movl $0x4, %edi
movq %r13, %rdx
movl %r12d, %ecx
xorl %eax, %eax
callq 0x4d55d
cmpl $0x0, 0xc(%r14)
je 0x426c7
leaq 0x9b9d0(%r14), %rdi
callq 0x8290
leaq (%r14,%rax), %rdi
addq $0x9b9d0, %rdi          # imm = 0x9B9D0
movl (%rbx), %r9d
leaq 0x2c8f7(%rip), %rsi     # 0x6ef90
leaq -0x70(%rbp), %rcx
movl %r15d, %edx
movl %r12d, %r8d
xorl %eax, %eax
callq 0x8120
jmp 0x426c7
leaq 0x2c894(%rip), %rsi     # 0x6ef47
movl $0x2, %edi
movl %eax, %edx
xorl %eax, %eax
callq 0x4d55d
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl %r12d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq