LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/ublox.cpp
// Function: bamboo::decode_ephem(int, bamboo::raw_t*)
static int decode_ephem(int sat, raw_t *raw)
{
    eph_t eph={0};
    
    trace(4,"decode_ephem: sat=%2d\n",sat);
    
    if (decode_frame(raw->subfrm[sat-1]   ,&eph,NULL,NULL,NULL,NULL)!=1||
        decode_frame(raw->subfrm[sat-1]+30,&eph,NULL,NULL,NULL,NULL)!=2||
        decode_frame(raw->subfrm[sat-1]+60,&eph,NULL,NULL,NULL,NULL)!=3) return 0;
    
    if (!strstr(raw->opt,"-EPHALL")) {
        if (eph.iode==raw->nav.eph[sat-1].iode&&
            eph.iodc==raw->nav.eph[sat-1].iodc) return 0; /* unchanged */
    }
    eph.sat=sat;
    raw->nav.eph[sat-1]=eph;
    raw->ephsat=sat;
    return 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rsi, %r12
movl %edi, %r14d
leaq -0x150(%rbp), %r13
xorl %r15d, %r15d
movl $0x120, %edx            # imm = 0x120
movq %r13, %rdi
xorl %esi, %esi
callq 0x8390
leaq 0x13beb(%rip), %rsi     # 0x75934
movl $0x4, %edi
movl %r14d, %edx
xorl %eax, %eax
callq 0x4ded0
leal -0x1(%r14), %eax
movslq %eax, %rbx
imulq $0x17c, %rbx, %rax      # imm = 0x17C
movq %r12, -0x30(%rbp)
addq %rax, %r12
addq $0x70f70, %r12          # imm = 0x70F70
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x35e5c
cmpl $0x1, %eax
jne 0x61e5a
leaq 0x1e(%r12), %rdi
xorl %r15d, %r15d
leaq -0x150(%rbp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x35e5c
cmpl $0x2, %eax
jne 0x61e5a
addq $0x3c, %r12
xorl %r15d, %r15d
leaq -0x150(%rbp), %rsi
movq %r12, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x35e5c
cmpl $0x3, %eax
jne 0x61e5a
movq -0x30(%rbp), %rax
leaq 0x82a90(%rax), %rdi
leaq 0xa8d7(%rip), %rsi      # 0x6c6c7
callq 0x8160
leaq (%rbx,%rbx,8), %rdi
testq %rax, %rax
jne 0x61e2a
movl -0x14c(%rbp), %edx
movq -0x30(%rbp), %rax
movq 0x1d80(%rax), %rax
movq %rdi, %rcx
shlq $0x5, %rcx
cmpl 0x4(%rax,%rcx), %edx
jne 0x61e2a
addq %rcx, %rax
movl -0x148(%rbp), %ecx
cmpl 0x8(%rax), %ecx
je 0x61e5a
leaq -0x150(%rbp), %rsi
movl %r14d, (%rsi)
shlq $0x5, %rdi
movq -0x30(%rbp), %rbx
addq 0x1d80(%rbx), %rdi
movl $0x120, %edx            # imm = 0x120
callq 0x84f0
movl %r14d, 0x70e40(%rbx)
movl $0x2, %r15d
movl %r15d, %eax
addq $0x128, %rsp            # imm = 0x128
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/ublox.cpp
// Function: bamboo::decode_alm1(int, bamboo::raw_t*)
static int decode_alm1(int sat, raw_t *raw)
{
    int sys=satsys(sat,NULL);
    
    trace(4,"decode_alm1 : sat=%2d\n",sat);
    
    if (sys==SYS_GPS) {
        decode_frame(raw->subfrm[sat-1]+90,NULL,raw->nav.alm,raw->nav.ion_gps,
                     raw->nav.utc_gps,&raw->nav.leaps);
        adj_utcweek(raw->time,raw->nav.utc_gps);
    }
    else if (sys==SYS_QZS) {
        decode_frame(raw->subfrm[sat-1]+90,NULL,raw->nav.alm,raw->nav.ion_qzs,
                     raw->nav.utc_qzs,&raw->nav.leaps);
        adj_utcweek(raw->time,raw->nav.utc_qzs);
    }
    return 9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
xorl %esi, %esi
callq 0x4dc2a
movl %eax, %r15d
leaq 0x13abb(%rip), %rsi     # 0x7594b
movl $0x4, %edi
movl %r14d, %edx
xorl %eax, %eax
callq 0x4ded0
cmpl $0x1, %r15d
je 0x61eb8
cmpl $0x10, %r15d
jne 0x61f13
movl $0x1e30, %r15d          # imm = 0x1E30
movl $0x1f10, %ecx           # imm = 0x1F10
jmp 0x61ec3
movl $0x1dd0, %r15d          # imm = 0x1DD0
movl $0x1eb0, %ecx           # imm = 0x1EB0
decl %r14d
movslq %r14d, %rax
imulq $0x17c, %rax, %rax      # imm = 0x17C
leaq (%rbx,%rax), %rdi
addq $0x70fca, %rdi          # imm = 0x70FCA
movq 0x1da8(%rbx), %rdx
addq %rbx, %rcx
addq %rbx, %r15
leaq 0x1fd0(%rbx), %r9
xorl %esi, %esi
movq %r15, %r8
callq 0x35e5c
movq (%rbx), %rdi
movsd 0x8(%rbx), %xmm0
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x61ff6
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/ublox.cpp
// Function: bamboo::decode_alm2(int, bamboo::raw_t*)
static int decode_alm2(int sat, raw_t *raw)
{
    int sys=satsys(sat,NULL);
    
    trace(4,"decode_alm2 : sat=%2d\n",sat);
    
    if (sys==SYS_GPS) {
        decode_frame(raw->subfrm[sat-1]+120,NULL,raw->nav.alm,NULL,NULL,NULL);
    }
    else if (sys==SYS_QZS) {
        decode_frame(raw->subfrm[sat-1]+120,NULL,raw->nav.alm,raw->nav.ion_qzs,
                     raw->nav.utc_qzs,&raw->nav.leaps);
        adj_utcweek(raw->time,raw->nav.utc_qzs);
    }
    return  0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
xorl %esi, %esi
callq 0x4dc2a
movl %eax, %r15d
leaq 0x13a23(%rip), %rsi     # 0x75962
movl $0x4, %edi
movl %r14d, %edx
xorl %eax, %eax
callq 0x4ded0
cmpl $0x10, %r15d
je 0x61f96
cmpl $0x1, %r15d
jne 0x61feb
decl %r14d
movslq %r14d, %rax
imulq $0x17c, %rax, %rax      # imm = 0x17C
leaq (%rbx,%rax), %rdi
addq $0x70fe8, %rdi          # imm = 0x70FE8
movq 0x1da8(%rbx), %rdx
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x35e5c
decl %r14d
movslq %r14d, %rax
imulq $0x17c, %rax, %rax      # imm = 0x17C
leaq (%rbx,%rax), %rdi
addq $0x70fe8, %rdi          # imm = 0x70FE8
movq 0x1da8(%rbx), %rdx
leaq 0x1f10(%rbx), %rcx
leaq 0x1e30(%rbx), %r14
leaq 0x1fd0(%rbx), %r9
xorl %esi, %esi
movq %r14, %r8
callq 0x35e5c
movq (%rbx), %rdi
movsd 0x8(%rbx), %xmm0
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x61ff6
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/ublox.cpp
// Function: bamboo::decode_nav(bamboo::raw_t*, int, int)
static int decode_nav(raw_t *raw, int sat, int off)
{
    unsigned int words[10];
    int i,id;
    unsigned char *p=raw->buff+6+off;
    
    if (raw->len<48+off) {
        trace(2,"ubx rawsfrbx length error: sat=%d len=%d\n",sat,raw->len);
        return -1;
    }
    if ((U4(p)>>24)==PREAMB_CNAV) {
        trace(3,"ubx rawsfrbx cnav not supported sat=%d prn=%d\n",sat,
              (U4(p)>>18)&0x3F);
        return 0;
    }
    for (i=0;i<10;i++,p+=4) words[i]=U4(p)>>6; /* 24 bits without parity */
    
    id=(words[1]>>2)&7;
    if (id<1||5<id) {
        trace(2,"ubx rawsfrbx subfrm id error: sat=%2d id=%d len=%d\n",sat,id,
              raw->len);
        return -1;
    }
    for (i=0;i<10;i++) {
        setbitu(raw->subfrm[sat-1]+(id-1)*30,i*24,24,words[i]);
    }
    if (id==3) return decode_ephem(sat,raw);
    if (id==4) return decode_alm1 (sat,raw);
    if (id==5) return decode_alm2 (sat,raw);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %r9d
movl 0x81a78(%rdi), %r8d
leal 0x30(%rdx), %eax
cmpl %eax, %r8d
jge 0x620cc
leaq 0x16e31(%rip), %rsi     # 0x78ee3
movl $0x2, %edi
movl %r9d, %edx
movl %r8d, %ecx
xorl %eax, %eax
callq 0x4ded0
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
jmp 0x62107
movq %rdi, %r14
movl %edx, %eax
movl 0x81a96(%rdi,%rax), %ecx
movl %ecx, %edx
andl $0xff000000, %edx       # imm = 0xFF000000
cmpl $0x8b000000, %edx       # imm = 0x8B000000
jne 0x62119
shrl $0x12, %ecx
andl $0x3f, %ecx
leaq 0x16e18(%rip), %rsi     # 0x78f0d
xorl %r12d, %r12d
movl $0x3, %edi
movl %r9d, %edx
xorl %eax, %eax
callq 0x4ded0
movl %r12d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq %r14, %rax
addq $0x81a96, %rax          # imm = 0x81A96
xorl %ecx, %ecx
movl (%rax,%rcx,4), %edx
shrl $0x6, %edx
movl %edx, -0x60(%rbp,%rcx,4)
incq %rcx
cmpq $0xa, %rcx
jne 0x62124
movl -0x5c(%rbp), %r15d
shrl $0x2, %r15d
andl $0x7, %r15d
leal -0x6(%r15), %eax
cmpl $-0x5, %eax
jae 0x6216a
leaq 0x16de9(%rip), %rsi     # 0x78f3c
movl $0x2, %edi
movl %r9d, %edx
movl %r15d, %ecx
xorl %eax, %eax
callq 0x4ded0
jmp 0x620c4
movq %r9, -0x30(%rbp)
leal -0x1(%r9), %eax
cltq
imulq $0x17c, %rax, %rax      # imm = 0x17C
addq %r14, %rax
movl %r15d, %edx
shll $0x5, %edx
subq %r15, %rdx
subq %r15, %rdx
leaq (%rdx,%rax), %r12
addq $0x70f52, %r12          # imm = 0x70F52
leaq -0x60(%rbp), %rbx
xorl %r13d, %r13d
movl (%rbx), %ecx
movq %r12, %rdi
movl %r13d, %esi
movl $0x18, %edx
callq 0x4e403
addq $0x18, %r13
addq $0x4, %rbx
cmpq $0xf0, %r13
jne 0x6219c
xorl %r12d, %r12d
cmpl $0x5, %r15d
je 0x62205
cmpl $0x4, %r15d
movq -0x30(%rbp), %rdi
je 0x621f2
cmpl $0x3, %r15d
jne 0x62107
movq %r14, %rsi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x61d0f
movq %r14, %rsi
callq 0x61e6f
movl $0x9, %r12d
jmp 0x62107
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x61f1e
jmp 0x62107
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rtklib/ublox.cpp
// Function: bamboo::decode_snav(bamboo::raw_t*, int, int)
static int decode_snav(raw_t *raw, int sat, int off)
{
    int i,j,k,prn,tow,week;
    unsigned char *p=raw->buff+6+off,buff[64];
    
    if (raw->len<40+off) {
        trace(2,"ubx rawsfrbx snav length error: len=%d\n",raw->len);
        return -1;
    }
    tow=(int)time2gpst(timeadd(raw->time,-1.0),&week);
    satsys(sat,&prn);
    raw->sbsmsg.prn=prn;
    raw->sbsmsg.tow=tow;
    raw->sbsmsg.week=week;
    for (i=k=0;i<8;i++,p+=4) for (j=0;j<4;j++) {
        buff[k++]=p[3-j];
    }
    memcpy(raw->sbsmsg.msg,buff,29);
    raw->sbsmsg.msg[28]&=0xC0;
    return 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, %eax
movl 0x81a78(%rdi), %edx
leal 0x28(%rax), %ecx
cmpl %ecx, %edx
jge 0x62b61
leaq 0x1657b(%rip), %rsi     # 0x790c6
movl $0x2, %edi
xorl %eax, %eax
callq 0x4ded0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x62c17
movl %esi, %r14d
movq %rdi, %rbx
movl %eax, %eax
movq %rax, -0x30(%rbp)
movq (%rdi), %rdi
movsd 0x8(%rbx), %xmm0
movsd 0x7e33(%rip), %xmm1     # 0x6a9b0
callq 0x4fe63
leaq -0x34(%rbp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4fc2d
cvttsd2si %xmm0, %r13d
leaq -0x38(%rbp), %r12
movl %r14d, %edi
movq %r12, %rsi
callq 0x4dc2a
movl (%r12), %eax
movl %eax, 0x70e4c(%rbx)
movl %r13d, 0x70e48(%rbx)
movl (%r15), %eax
movl %eax, 0x70e44(%rbx)
movq -0x30(%rbp), %rax
addq %rbx, %rax
addq $0x81a99, %rax          # imm = 0x81A99
xorl %ecx, %ecx
xorl %edx, %edx
movslq %edx, %rdx
xorl %esi, %esi
movb (%rax,%rsi), %dil
movb %dil, -0x80(%rbp,%rdx)
incq %rdx
decq %rsi
cmpq $-0x4, %rsi
jne 0x62bd5
incl %ecx
addq $0x4, %rax
cmpl $0x8, %ecx
jne 0x62bd0
movups -0x73(%rbp), %xmm0
movups %xmm0, 0x70e5d(%rbx)
movaps -0x80(%rbp), %xmm0
movups %xmm0, 0x70e50(%rbx)
andb $-0x40, 0x70e6c(%rbx)
movl $0x3, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/VrsObs/VrsNtripClient.cpp
// Function: bamboo::VrsNtripClient::openStream()
void VrsNtripClient::openStream() {
	lcont = true;
	configs_sav = Deploy::s_getConfigures();
	time(&lastCheck);
	def_thread_t pid_handle;
#ifdef _WIN32
	CreateThread(NULL, 0, s_pthVrsStream_win, this, 0, NULL);
#else
	if (0 != pthread_create(&pid_handle, NULL, &s_pthVrsStream, this)) {
		cout
			<< "***ERROR(s_VRSMain):cant create thread to handle request!"
			<< endl;
		exit(1);
	}
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2048, %rsp           # imm = 0x2048
movq %rdi, %rbx
movb $0x1, (%rdi)
leaq -0x2068(%rbp), %r14
movq %r14, %rdi
callq 0x2af0e
leaq 0x10(%rbx), %r15
movl $0x6b0, %edx            # imm = 0x6B0
movq %r15, %rdi
movq %r14, %rsi
callq 0x84f0
leaq 0x6c0(%rbx), %r12
movl $0xaa, %r14d
leaq -0x19b8(%rbp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x8380
addq $0x20, %r13
addq $0x20, %r12
decq %r14
jne 0x62ce7
movq -0x478(%rbp), %rax
movq %rax, 0x1c00(%rbx)
leaq -0x2068(%rbp), %rax
cmpq %rax, %r15
je 0x62d2f
leaq -0x470(%rbp), %rdx
leaq 0x1c08(%rbx), %rdi
movq (%rdx), %rsi
callq 0x28156
leaq 0x1c20(%rbx), %rdi
leaq -0x458(%rbp), %rsi
callq 0x2839e
leaq 0x1c50(%rbx), %rdi
leaq -0x428(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x84f0
leaq -0x2068(%rbp), %rdi
callq 0x2aec0
leaq 0x8(%rbx), %rdi
callq 0x85b0
leaq 0x66(%rip), %rdx        # 0x62ddc
leaq -0x2068(%rbp), %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x8bc0
testl %eax, %eax
jne 0x62d9d
addq $0x2048, %rsp           # imm = 0x2048
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2b224(%rip), %rdi     # 0x8dfc8
leaq 0x8c96(%rip), %rsi      # 0x6ba41
callq 0x8620
movq %rax, %rdi
callq 0x8300
movl $0x1, %edi
callq 0x87c0
jmp 0x62dc4
movq %rax, %rbx
leaq -0x2068(%rbp), %rdi
callq 0x2aec0
movq %rbx, %rdi
callq 0x8b40
nop
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/VrsObs/VrsNtripClient.cpp
// Function: bamboo::VrsNtripClient::openStream(std::__cxx11::list<bamboo::RtConverter*, std::allocator<bamboo::RtConverter*>>)
void VrsNtripClient::openStream(list<RtConverter*> svrs_in) {
	lcont = true;
	configs_sav = Deploy::s_getConfigures();
	time(&lastCheck);
	def_thread_t pid_handle;
#ifdef _WIN32
	CreateThread(NULL, 0, s_pthVrsStream_win, this, 0, NULL);
#else
	if (0 != pthread_create(&pid_handle, NULL, &s_pthVrsStream, this)) {
		cout
			<< "***ERROR(s_VRSMain):cant create thread to handle request!"
			<< endl;
		exit(1);
	}
#endif
	this->m_svrs = svrs_in;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2048, %rsp           # imm = 0x2048
movq %rsi, -0x30(%rbp)
movq %rdi, %r14
movb $0x1, (%rdi)
leaq -0x2070(%rbp), %rbx
movq %rbx, %rdi
callq 0x2af0e
leaq 0x10(%r14), %r12
movl $0x6b0, %edx            # imm = 0x6B0
movq %r12, %rdi
movq %rbx, %rsi
callq 0x84f0
leaq 0x6c0(%r14), %r13
movl $0xaa, %r15d
leaq -0x19c0(%rbp), %rbx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x8380
addq $0x20, %rbx
addq $0x20, %r13
decq %r15
jne 0x62e3f
movq -0x480(%rbp), %rax
movq %rax, 0x1c00(%r14)
leaq -0x2070(%rbp), %rax
cmpq %rax, %r12
je 0x62e87
leaq -0x478(%rbp), %rdx
leaq 0x1c08(%r14), %rdi
movq (%rdx), %rsi
callq 0x28156
leaq 0x1c20(%r14), %rdi
leaq -0x460(%rbp), %rsi
callq 0x2839e
leaq 0x1c50(%r14), %rdi
leaq -0x430(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x84f0
leaq -0x2070(%rbp), %rdi
callq 0x2aec0
leaq 0x8(%r14), %rdi
callq 0x85b0
leaq -0xf2(%rip), %rdx       # 0x62ddc
leaq -0x2070(%rbp), %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0x8bc0
testl %eax, %eax
jne 0x62f10
addq $0x2050, %r14           # imm = 0x2050
movq -0x30(%rbp), %rdx
cmpq %rdx, %r14
je 0x62efe
movq (%rdx), %rsi
movq %r14, %rdi
callq 0x28e90
addq $0x2048, %rsp           # imm = 0x2048
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2b0b1(%rip), %rdi     # 0x8dfc8
leaq 0x8b23(%rip), %rsi      # 0x6ba41
callq 0x8620
movq %rax, %rdi
callq 0x8300
movl $0x1, %edi
callq 0x87c0
jmp 0x62f37
movq %rax, %rbx
leaq -0x2070(%rbp), %rdi
callq 0x2aec0
movq %rbx, %rdi
callq 0x8b40
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/VrsObs/VrsNtripClient.cpp
// Function: bamboo::VrsNtripClient::m_newConnection(bamboo::VrsStaItem&)
void VrsNtripClient::m_newConnection(VrsStaItem& item) {
	stream_t* str_m;
	rtcm_t* rtcm_m;
	str_m = (stream_t*)calloc(1, sizeof(stream_t));
	strinit(str_m);
	rtcm_m = (rtcm_t*)calloc(1, sizeof(rtcm_t));
	init_rtcm(rtcm_m);
	stropen(str_m, STR_NTRIPCLI, STR_MODE_RW, item.strpath.c_str());
	strsettimeout(str_m, 60000, 10000); /// 60s for timeout 10s for reconnect
	m_streams[item.staname] = str_m;
	m_rtcms[item.staname] = rtcm_m;
	m_stas[item.staname] = item;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x860, %esi            # imm = 0x860
callq 0x8440
movq %rax, %r12
movq %rax, %rdi
callq 0x58952
movl $0x1, %edi
movl $0x9fe48, %esi          # imm = 0x9FE48
callq 0x8440
movq %rax, %r13
movq %rax, %rdi
callq 0x38fe4
leaq 0x40(%rbx), %rax
movq %rax, -0x30(%rbp)
movq 0x40(%rbx), %rcx
movq %r12, %rdi
movl $0x7, %esi
movl $0x3, %edx
callq 0x589a3
movq %r12, %rdi
movl $0xea60, %esi           # imm = 0xEA60
movl $0x2710, %edx           # imm = 0x2710
callq 0x5c59e
leaq 0x2068(%r14), %rdi
leaq 0x20(%rbx), %r15
movq %r15, %rsi
callq 0x64162
movq %r12, (%rax)
leaq 0x2098(%r14), %rdi
movq %r15, %rsi
callq 0x64062
movq %r13, (%rax)
addq $0x20c8, %r14           # imm = 0x20C8
movq %r14, %rdi
movq %r15, %rsi
callq 0x63fe2
movq %rax, %r14
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
leaq 0x20(%rax), %rdi
movq %r15, %rsi
callq 0x8380
leaq 0x40(%r14), %rdi
movq -0x30(%rbp), %rsi
callq 0x8380
movl 0x60(%rbx), %eax
movl %eax, 0x60(%r14)
addq $0x8, %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/VrsObs/VrsNtripClient.cpp
// Function: bamboo::VrsNtripClient::m_deleteConnection(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void VrsNtripClient::m_deleteConnection(string staname) {
	map<string, stream_t*>::iterator streamItr;
	map<string, rtcm_t*>::iterator rtcmItr;
	map<string, VrsStaItem>::iterator vrsItr;

	streamItr = m_streams.find(staname);
	rtcmItr = m_rtcms.find(staname);
	vrsItr = m_stas.find(staname);

	if (streamItr != m_streams.end()) {
		strclose((*streamItr).second);
		free((*streamItr).second);
		m_streams.erase(streamItr);
	}
	if (rtcmItr != m_rtcms.end()) {
		free_rtcm((*rtcmItr).second);
		free((*rtcmItr).second);
		m_rtcms.erase(rtcmItr);
	}
	if (vrsItr != m_stas.end())
		m_stas.erase(vrsItr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x2068(%rdi), %r14
movq %r14, %rdi
callq 0x64d98
movq %rax, %r15
leaq 0x2098(%rbx), %rdi
movq %rdi, -0x30(%rbp)
movq %r12, %rsi
callq 0x64e36
movq %rax, %r13
leaq 0x20c8(%rbx), %rdi
movq %rdi, -0x38(%rbp)
movq %r12, %rsi
callq 0x64e86
movq %rax, %r12
leaq 0x2070(%rbx), %rax
cmpq %rax, %r15
je 0x63f82
movq 0x40(%r15), %rdi
callq 0x59b29
movq 0x40(%r15), %rdi
callq 0x87b0
movq %r14, %rdi
movq %r15, %rsi
callq 0x64ed6
leaq 0x20a0(%rbx), %rax
cmpq %rax, %r13
je 0x63fac
movq 0x40(%r13), %rdi
callq 0x392c1
movq 0x40(%r13), %rdi
callq 0x87b0
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0x64f16
addq $0x20d0, %rbx           # imm = 0x20D0
cmpq %rbx, %r12
je 0x63fd2
movq -0x38(%rbp), %rdi
movq %r12, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x64f56
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rnxbrd/BroadcastEphUtils.cpp
// Function: bamboo::BroadcastEphUtils::glsinit(double*, bamboo::GLSEPH&)
void BroadcastEphUtils::glsinit(double* x,GLSEPH& eph){
	int i;
	for (i = 0; i < 3; i++)
		x[i] = eph.pos[i];
	for (i = 3; i < 6; i++)
		x[i] = eph.vel[i - 3];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movsd 0x30(%rdx,%rax,8), %xmm0
movsd %xmm0, (%rsi,%rax,8)
incq %rax
cmpq $0x3, %rax
jne 0x6665a
xorl %eax, %eax
movsd 0x48(%rdx,%rax,8), %xmm0
movsd %xmm0, 0x18(%rsi,%rax,8)
incq %rax
cmpq $0x3, %rax
jne 0x66670
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rnxbrd/BroadcastEphUtils.cpp
// Function: bamboo::BroadcastEphUtils::glsrkf4(double, double*, bamboo::GLSEPH&)
void BroadcastEphUtils::glsrkf4(double h, double* x, GLSEPH& eph){
	int i, j;
	double coef[4], xj[6], acc[6], funct[6];
	coef[0] = h / 2;
	coef[1] = h / 2;
	coef[2] = h;
	coef[3] = h;
	for (i = 0; i < 6; i++)
		xj[i] = x[i];
	glsfright(xj, acc, eph);
	for (i = 0; i < 6; i++)
		funct[i] = xj[i];
	for (j = 0; j < 3; j++) {
		for (i = 0; i < 6; i++) {
			xj[i] = x[i] + coef[j] * acc[i];
			funct[i] = funct[i] + coef[j + 1] * acc[i] / 3.0;
		}
		glsfright(xj, acc, eph);
	}
	for (i = 0; i < 6; i++)
		x[i] = funct[i] + h * acc[i] / 6.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movsd 0x55ce(%rip), %xmm1     # 0x6bc78
mulsd %xmm0, %xmm1
movsd %xmm1, -0x50(%rbp)
movsd %xmm1, -0x48(%rbp)
movsd %xmm0, -0x40(%rbp)
movsd %xmm0, -0x30(%rbp)
movsd %xmm0, -0x38(%rbp)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
leaq -0xe0(%rbp), %r15
movaps %xmm0, (%r15)
movaps %xmm1, 0x10(%r15)
movaps %xmm2, 0x20(%r15)
leaq -0xb0(%rbp), %r12
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x66b10
movapd (%r15), %xmm0
movapd 0x10(%r15), %xmm1
movapd 0x20(%r15), %xmm2
movapd %xmm2, -0x60(%rbp)
movapd %xmm1, -0x70(%rbp)
movapd %xmm0, -0x80(%rbp)
xorl %r13d, %r13d
movsd 0x41c1(%rip), %xmm4     # 0x6a8e8
movsd -0x50(%rbp,%r13,8), %xmm0
movsd -0x48(%rbp,%r13,8), %xmm1
incq %r13
xorl %eax, %eax
movsd -0xb0(%rbp,%rax,8), %xmm2
movapd %xmm0, %xmm3
mulsd %xmm2, %xmm3
addsd (%rbx,%rax,8), %xmm3
mulsd %xmm1, %xmm2
divsd %xmm4, %xmm2
addsd -0x80(%rbp,%rax,8), %xmm2
movsd %xmm3, -0xe0(%rbp,%rax,8)
movsd %xmm2, -0x80(%rbp,%rax,8)
incq %rax
cmpq $0x6, %rax
jne 0x6673a
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x66b10
movsd 0x415c(%rip), %xmm4     # 0x6a8e8
cmpq $0x3, %r13
jne 0x66727
xorl %eax, %eax
movsd 0x429c(%rip), %xmm0     # 0x6aa38
movsd -0x30(%rbp), %xmm2
movsd -0xb0(%rbp,%rax,8), %xmm1
mulsd %xmm2, %xmm1
divsd %xmm0, %xmm1
addsd -0x80(%rbp,%rax,8), %xmm1
movsd %xmm1, (%rbx,%rax,8)
incq %rax
cmpq $0x6, %rax
jne 0x667a1
addq $0xb8, %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/Rnxbrd/BroadcastEphUtils.cpp
// Function: bamboo::BroadcastEphUtils::glsfright(double*, double*, bamboo::GLSEPH&)
void BroadcastEphUtils::glsfright(double* x, double* acc,GLSEPH& eph){
	const double c20 = -1.08262575e-3;
	const double GMEARTH = 3.986004418e5;
	const double EROT = 7.292115e-5;
	const double ER = 6.378136e3;
	int i;
	double factor1, factor2, r, vec1[3], vec2[3];
	r = sqrt(x[0] * x[0] + x[1] * x[1] + x[2] * x[2]);
	factor1 = -GMEARTH / pow(r, 3);
	factor2 = 1.5 * GMEARTH * c20 * ER * ER / pow(r, 5);
	vec1[0] = EROT * EROT * x[0] + 2.0 * EROT * x[4];
	vec1[1] = EROT * EROT * x[1] - 2.0 * EROT * x[3];
	vec1[2] = 0.0;
	vec2[0] = x[0] * (1.0 - 5.0 * pow((x[2] / r), 2));
	vec2[1] = x[1] * (1.0 - 5.0 * pow((x[2] / r), 2));
	vec2[2] = x[2] * (3.0 - 5.0 * pow((x[2] / r), 2));
	for (i = 0; i < 3; i++) {
		acc[i] = x[i + 3];
		acc[i + 3] = eph.acc[i] + vec1[i] + factor2 * vec2[i] + factor1 * x[i];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movsd (%rsi), %xmm1
movsd 0x8(%rsi), %xmm0
mulsd %xmm0, %xmm0
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd 0x10(%rsi), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x66b58
sqrtsd %xmm0, %xmm0
jmp 0x66b5d
callq 0x84e0
movsd 0x3d83(%rip), %xmm1     # 0x6a8e8
movsd %xmm0, -0x20(%rbp)
callq 0x8b30
movsd 0x12829(%rip), %xmm1    # 0x793a0
divsd %xmm0, %xmm1
movsd %xmm1, -0x28(%rbp)
movsd 0x4c40(%rip), %xmm1     # 0x6b7c8
movsd -0x20(%rbp), %xmm0
callq 0x8b30
movsd (%r15), %xmm2
movsd 0x20(%r15), %xmm1
mulsd 0x1280b(%rip), %xmm1    # 0x793b0
movsd 0x1280b(%rip), %xmm3    # 0x793b8
movapd %xmm2, %xmm4
mulsd %xmm3, %xmm4
addsd %xmm1, %xmm4
movsd 0x127e7(%rip), %xmm1    # 0x793a8
movsd %xmm4, -0x60(%rbp)
movsd 0x18(%r15), %xmm4
mulsd 0x127ec(%rip), %xmm4    # 0x793c0
divsd %xmm0, %xmm1
mulsd 0x8(%r15), %xmm3
addsd %xmm4, %xmm3
movsd %xmm3, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
movsd 0x10(%r15), %xmm0
movsd -0x20(%rbp), %xmm5
divsd %xmm5, %xmm0
mulsd %xmm0, %xmm0
movsd 0x127be(%rip), %xmm3    # 0x793c8
mulsd %xmm3, %xmm0
movsd 0x2d0a(%rip), %xmm4     # 0x69920
addsd %xmm4, %xmm0
mulsd %xmm2, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd 0x10(%r15), %xmm0
divsd %xmm5, %xmm0
mulsd %xmm0, %xmm0
mulsd %xmm3, %xmm0
addsd %xmm4, %xmm0
mulsd 0x8(%r15), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0x10(%r15), %xmm0
movapd %xmm0, %xmm2
divsd %xmm5, %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm3, %xmm2
movsd -0x28(%rbp), %xmm3
addsd 0x3c81(%rip), %xmm2     # 0x6a8e8
mulsd %xmm0, %xmm2
movsd %xmm2, -0x30(%rbp)
xorl %eax, %eax
movsd 0x18(%r15,%rax), %xmm0
movsd %xmm0, (%r14,%rax)
movsd 0x60(%rbx,%rax), %xmm0
addsd -0x60(%rbp,%rax), %xmm0
movsd -0x40(%rbp,%rax), %xmm2
mulsd %xmm1, %xmm2
addsd %xmm0, %xmm2
movsd (%r15,%rax), %xmm0
mulsd %xmm3, %xmm0
addsd %xmm2, %xmm0
movsd %xmm0, 0x18(%r14,%rax)
addq $0x8, %rax
cmpq $0x18, %rax
jne 0x66c72
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rnxbrd/RnxEphFileAdapter.cpp
// Function: bamboo::RnxEphFileAdapter::RnxEphFileAdapter()
RnxEphFileAdapter::RnxEphFileAdapter() {
	memset(neph, 0, sizeof(int) * MAXSYS);
	mjd0 = mjd1 = leap = 0;
	sod0 = sod1 = ver = 0.0;
	memset(ionc, 0, sizeof(char) * MAXSYS * 2 * LEN_EPHION);
	memset(ion, 0, sizeof(double) * MAXSYS * 2 * 4);
	memset(timc, 0, sizeof(char) * MAXSYS * 2 * LEN_EPHION);
	memset(tim, 0, sizeof(double) * MAXSYS * 2 * 4);
	isOpen = 0;
	orbType = ORB_BRD;
	clkType = CLK_BRD;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x26ddd(%rip), %rax     # 0x8dd18
movq %rax, (%rdi)
addq $0x8, %rdi
movl $0x2ac, %edx            # imm = 0x2AC
xorl %esi, %esi
callq 0x8390
movl $0x0, 0x2c0(%rbx)
leaq 0x26d01(%rip), %rax     # 0x8dc60
movq %rax, (%rbx)
leaq 0x26d7f(%rip), %rax     # 0x8dce8
movq %rax, 0x2b8(%rbx)
movb $0x0, 0x2c4(%rbx)
movabsq $0x4008cccccccccccd, %rax # imm = 0x4008CCCCCCCCCCCD
movq %rax, 0x2c8(%rbx)
leaq 0x26af9(%rip), %rax     # 0x8da88
addq $0x10, %rax
movq %rax, 0x6d0(%rbx)
movl $0x6f8, %eax            # imm = 0x6F8
leaq (%rbx,%rax), %rcx
movq %rcx, 0x8(%rbx,%rax)
movq %rcx, (%rbx,%rax)
movq $0x0, 0x10(%rbx,%rax)
addq $0x18, %rax
cmpq $0x7a0, %rax            # imm = 0x7A0
jne 0x66f9f
leaq 0x7a0(%rbx), %rax
movq %rax, 0x7a8(%rbx)
movq %rax, 0x7a0(%rbx)
movq $0x0, 0x7b0(%rbx)
leaq 0x26af0(%rip), %rax     # 0x8dad8
movq %rax, (%rbx)
leaq 0x26b7e(%rip), %rax     # 0x8db70
movq %rax, 0x2b8(%rbx)
leaq 0x26ba0(%rip), %rax     # 0x8dba0
movq %rax, 0x6d0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x6d8(%rbx)
movups %xmm0, 0x6e4(%rbx)
leaq 0xdd0(%rbx), %r14
leaq 0x7b8(%rbx), %rdi
movl $0x1f8, %edx            # imm = 0x1F8
xorl %esi, %esi
callq 0x8390
xorps %xmm0, %xmm0
movups %xmm0, 0xdb0(%rbx)
movups %xmm0, 0xdbc(%rbx)
movl $0x204, %edx            # imm = 0x204
movq %r14, %rdi
xorl %esi, %esi
callq 0x8390
movl $0x3, 0x2c0(%rbx)
movl $0x6, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rnxbrd/RnxEphFileAdapter.cpp
// Function: bamboo::RnxEphFileAdapter::v_closeRnxEph()
void RnxEphFileAdapter::v_closeRnxEph() {
	int isys;
	for (isys = 0; isys < MAXSYS; isys++) {
		this->gnssEph[isys].clear();
	}
	this->glsEph.clear();
	memset(neph, 0, sizeof(int) * MAXSYS);
	this->isOpen = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6f8(%rdi), %r14
xorl %r15d, %r15d
leaq (%r15,%r15,2), %rax
leaq (%r14,%rax,8), %r12
movq (%r12), %rdi
cmpq %r12, %rdi
je 0x68554
movq (%rdi), %r13
callq 0x85d0
movq %r13, %rdi
cmpq %r12, %r13
jne 0x68544
movq %r12, 0x8(%r12)
movq %r12, (%r12)
movq $0x0, 0x10(%r12)
incq %r15
cmpq $0x7, %r15
jne 0x68533
leaq 0x7a0(%rbx), %r14
movq 0x7a0(%rbx), %rdi
cmpq %r14, %rdi
je 0x68592
movq (%rdi), %r15
callq 0x85d0
movq %r15, %rdi
cmpq %r14, %r15
jne 0x68582
movq %r14, 0x7a8(%rbx)
movq %r14, 0x7a0(%rbx)
movq $0x0, 0x7b0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x6d8(%rbx)
movups %xmm0, 0x6e4(%rbx)
movl $0x0, 0xdc8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rnxbrd/RnxEphFileAdapter.cpp
// Function: bamboo::RnxEphFileAdapter::v_readClk(char const*, int, double, double*)
int RnxEphFileAdapter::v_readClk(const char* cprn, int mjd, double sod,
		double* sclk) {
	// using rinex navigation file to acquire satellite clock
	int wk, iode = -1;
	double sow, tgd, dtmin;
	mjd2wksow(mjd, sod, &wk, &sow);
	*sclk = 0.0;
	if (cprn[0] != 'R')
		if (cprn[0] == 'C')
			return this->m_brd2xyz("ynn", cprn, wk, sow - 14.0, NULL, sclk,
					&dtmin, &tgd, &iode);
		else
			return this->m_brd2xyz("ynn", cprn, wk, sow, NULL, sclk, &dtmin,
					&tgd, &iode);
	else
		return this->m_gls2xyz("ynn", cprn, wk, sow, NULL, sclk, &dtmin, &iode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
leaq -0x44(%rbp), %r12
leaq -0x50(%rbp), %r13
movl %edx, %edi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1d5a4
movq $0x0, (%rbx)
movzbl (%r14), %eax
addq $0x6d0, %r15            # imm = 0x6D0
movl (%r12), %ecx
movsd (%r13), %xmm0
cmpl $0x52, %eax
je 0x6866f
cmpl $0x43, %eax
jne 0x6863a
addsd 0xc57e(%rip), %xmm0     # 0x74bb8
movq (%r15), %rax
subq $0x8, %rsp
leaq -0x2c(%rbp), %r10
leaq -0x40(%rbp), %r11
leaq -0x38(%rbp), %r12
leaq 0x10e24(%rip), %rsi     # 0x79478
movq %r15, %rdi
movq %r14, %rdx
xorl %r8d, %r8d
movq %rbx, %r9
pushq %r10
pushq %r11
pushq %r12
callq *0x10(%rax)
addq $0x20, %rsp
jmp 0x68698
movq (%r15), %rax
leaq -0x2c(%rbp), %r10
leaq -0x38(%rbp), %r11
leaq 0x10df7(%rip), %rsi     # 0x79478
movq %r15, %rdi
movq %r14, %rdx
xorl %r8d, %r8d
movq %rbx, %r9
pushq %r10
pushq %r11
callq *0x18(%rax)
addq $0x10, %rsp
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rnxbrd/RnxEphFileAdapter.cpp
// Function: bamboo::RnxEphFileAdapter::v_readClk(char const*, int, double, double*, int*)
int RnxEphFileAdapter::v_readClk(const char* cprn, int mjd, double sod,
		double* sclk, int* iode) {
	int wk;
	double sow, tgd, dtmin;
	mjd2wksow(mjd, sod, &wk, &sow);
	*sclk = 0.0;
	if (cprn[0] != 'R')
		if (cprn[0] == 'C')
			return this->m_brd2xyz("ynn", cprn, wk, sow - 14.0, NULL, sclk,
					&dtmin, &tgd, iode);
		else
			return this->m_brd2xyz("ynn", cprn, wk, sow, NULL, sclk, &dtmin,
					&tgd, iode);
	else
		return this->m_gls2xyz("ynn", cprn, wk, sow, NULL, sclk, &dtmin, iode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, -0x30(%rbp)
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq -0x44(%rbp), %r13
leaq -0x50(%rbp), %rbx
movl %edx, %edi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x1d5a4
movq $0x0, (%r14)
movzbl (%r15), %eax
addq $0x6d0, %r12            # imm = 0x6D0
movl (%r13), %ecx
movsd (%rbx), %xmm0
cmpl $0x52, %eax
je 0x6873a
cmpl $0x43, %eax
jne 0x68707
addsd 0xc4b1(%rip), %xmm0     # 0x74bb8
movq (%r12), %rax
subq $0x8, %rsp
leaq -0x40(%rbp), %r10
leaq -0x38(%rbp), %r11
leaq 0x10d5a(%rip), %rsi     # 0x79478
movq %r12, %rdi
movq %r15, %rdx
xorl %r8d, %r8d
movq %r14, %r9
pushq -0x30(%rbp)
pushq %r10
pushq %r11
callq *0x10(%rax)
addq $0x20, %rsp
jmp 0x68761
movq (%r12), %rax
leaq -0x38(%rbp), %r10
leaq 0x10d2f(%rip), %rsi     # 0x79478
movq %r12, %rdi
movq %r15, %rdx
xorl %r8d, %r8d
movq %r14, %r9
pushq -0x30(%rbp)
pushq %r10
callq *0x18(%rax)
addq $0x10, %rsp
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/Rnxbrd/RnxEphFileAdapter.cpp
// Function: bamboo::RnxEphFileAdapter::v_readOrbit(char const*, int, double, double*)
int RnxEphFileAdapter::v_readOrbit(const char* cprn, int mjd, double sod,
		double* xsat) {
	// using rinex navigation file to acquire orbit
	int wk, iode = -1;
	double sow, tgd, dtmin, sclk;
	mjd2wksow(mjd, sod, &wk, &sow);
	if (cprn[0] != 'R')
		if (cprn[0] == 'C')
			return this->m_brd2xyz("yyy", cprn, wk, sow - 14.0, xsat, &sclk,
					&dtmin, &tgd, &iode);
		else
			return this->m_brd2xyz("yyy", cprn, wk, sow, xsat, &sclk, &dtmin,
					&tgd, &iode);
	else
		return this->m_gls2xyz("yyy", cprn, wk, sow, xsat, &sclk, &dtmin, &iode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
leaq -0x4c(%rbp), %r12
leaq -0x58(%rbp), %r13
movl %edx, %edi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1d5a4
movzbl (%r14), %eax
addq $0x6d0, %r15            # imm = 0x6D0
movl (%r12), %ecx
movsd (%r13), %xmm0
cmpl $0x52, %eax
je 0x68803
cmpl $0x43, %eax
jne 0x687cd
addsd 0xc3eb(%rip), %xmm0     # 0x74bb8
movq (%r15), %rax
subq $0x8, %rsp
leaq -0x2c(%rbp), %r10
leaq -0x48(%rbp), %r11
leaq -0x40(%rbp), %r12
leaq 0x10d09(%rip), %rsi     # 0x794f0
leaq -0x38(%rbp), %r9
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %r8
pushq %r10
pushq %r11
pushq %r12
callq *0x10(%rax)
addq $0x20, %rsp
jmp 0x6882d
movq (%r15), %rax
leaq -0x2c(%rbp), %r10
leaq -0x40(%rbp), %r11
leaq 0x10cdb(%rip), %rsi     # 0x794f0
leaq -0x38(%rbp), %r9
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %r8
pushq %r10
pushq %r11
callq *0x18(%rax)
addq $0x10, %rsp
addq $0x38, %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/Rnxbrd/RnxEphFileAdapter.cpp
// Function: bamboo::RnxEphFileAdapter::v_readOrbit(char const*, int, double, double*, int*)
int RnxEphFileAdapter::v_readOrbit(const char* cprn, int mjd, double sod,
		double* xsat, int* iode) {
	// using rinex navigation file to acquire orbit
	// using rinex navigation file to acquire orbit
	int wk;
	double sow, tgd, dtmin, sclk;
	mjd2wksow(mjd, sod, &wk, &sow);
	if (cprn[0] != 'R')
		if (cprn[0] == 'C')
			return this->m_brd2xyz("yyy", cprn, wk, sow - 14.0, xsat, &sclk,
					&dtmin, &tgd, iode);
		else
			return this->m_brd2xyz("yyy", cprn, wk, sow, xsat, &sclk, &dtmin,
					&tgd, iode);
	else
		return this->m_gls2xyz("yyy", cprn, wk, sow, xsat, &sclk, &dtmin, iode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, -0x30(%rbp)
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq -0x4c(%rbp), %r13
leaq -0x58(%rbp), %rbx
movl %edx, %edi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x1d5a4
movzbl (%r15), %eax
addq $0x6d0, %r12            # imm = 0x6D0
movl (%r13), %ecx
movsd (%rbx), %xmm0
cmpl $0x52, %eax
je 0x688da
cmpl $0x43, %eax
jne 0x688a6
addsd 0xc312(%rip), %xmm0     # 0x74bb8
movq (%r12), %rax
subq $0x8, %rsp
leaq -0x48(%rbp), %r10
leaq -0x40(%rbp), %r11
leaq 0x10c33(%rip), %rsi     # 0x794f0
leaq -0x38(%rbp), %r9
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %r8
pushq -0x30(%rbp)
pushq %r10
pushq %r11
callq *0x10(%rax)
addq $0x20, %rsp
jmp 0x68902
movq (%r12), %rax
leaq -0x40(%rbp), %r10
leaq 0x10c07(%rip), %rsi     # 0x794f0
leaq -0x38(%rbp), %r9
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %r8
pushq -0x30(%rbp)
pushq %r10
callq *0x18(%rax)
addq $0x10, %rsp
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rnxbrd/RnxEphFileAdapter.cpp
// Function: bamboo::RnxEphFileAdapter::m_getCurrentEph_G(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, double)
list<GPSEPH> RnxEphFileAdapter::m_getCurrentEph_G(string cprn, int mjd, double sod) {
	int isys,wk;
	double dt,sow,dtmin = 2.0;
	list<GPSEPH> list_out;
	list<GPSEPH>::iterator gpsItr;
	mjd2wksow(mjd, sod, &wk, &sow);
	isys = index_string(SYS, cprn[0]);
	for (gpsItr = this->gnssEph[isys].begin(); gpsItr != this->gnssEph[isys].end(); ++gpsItr) {
		if (strstr((*gpsItr).cprn, cprn.c_str())) {
			dt = (wk - (*gpsItr).week) * 168.0 + (sow - (*gpsItr).toe) / 3600.0;
			if (fabs(dt) < dtmin) {
				list_out.push_back(*gpsItr);
			}
		}
	}
	return list_out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
movq %rdi, -0x30(%rbp)
movq $0x0, 0x10(%rdi)
leaq -0x34(%rbp), %rsi
leaq -0x40(%rbp), %rdx
movl %ecx, %edi
callq 0x1d5a4
movq (%r14), %rax
movsbl (%rax), %esi
leaq 0x10e94(%rip), %rdi     # 0x797fe
callq 0x1db90
cltq
leaq (%rax,%rax,2), %rax
leaq (%r15,%rax,8), %r13
addq $0x6f8, %r13            # imm = 0x6F8
movq (%r13), %rbx
cmpq %r13, %rbx
je 0x68a21
leaq 0x10(%rbx), %r15
movq (%r14), %rsi
movq %r15, %rdi
callq 0x8160
testq %rax, %rax
je 0x68a19
xorps %xmm0, %xmm0
cvtsi2sdl -0x34(%rbp), %xmm0
subsd 0xc8(%rbx), %xmm0
movsd -0x40(%rbp), %xmm1
subsd 0x78(%rbx), %xmm1
divsd 0x1efd(%rip), %xmm1     # 0x6a8c0
mulsd 0x1099d(%rip), %xmm0    # 0x79368
addsd %xmm1, %xmm0
andpd 0xf59(%rip), %xmm0      # 0x69930
movsd 0x33d1(%rip), %xmm1     # 0x6bdb0
ucomisd %xmm0, %xmm1
jbe 0x68a19
movl $0x100, %edi            # imm = 0x100
callq 0x8640
movq %rax, %r12
movq %rax, %rdi
addq $0x10, %rdi
movl $0xf0, %edx
movq %r15, %rsi
callq 0x84f0
movq %r12, %rdi
movq -0x30(%rbp), %r15
movq %r15, %rsi
callq 0x80c0
incq 0x10(%r15)
movq (%rbx), %rbx
jmp 0x68984
movq -0x30(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x68a36
movq %rax, %r14
movq -0x30(%rbp), %r15
movq (%r15), %rdi
cmpq %r15, %rdi
je 0x68a55
movq (%rdi), %rbx
callq 0x85d0
movq %rbx, %rdi
cmpq %r15, %rbx
jne 0x68a45
movq %r14, %rdi
callq 0x8b40
nop
// File: /workspace/github_cpp_makefile_star2_O1/DoubleString[P]RtConverter/src/Rnxbrd/RnxEphFileAdapter.cpp
// Function: bamboo::RnxEphFileAdapter::m_getCurrentEph_R(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, double)
list<GLSEPH> RnxEphFileAdapter::m_getCurrentEph_R(string cprn, int mjd, double sod) {
	double dt,dtmin = 1.0;
	list<GLSEPH> list_out;
	list<GLSEPH>::iterator glsItr;
	for (glsItr = this->glsEph.begin(); glsItr != this->glsEph.end(); ++glsItr) {
		if (strstr((*glsItr).cprn, cprn.c_str())) {
			dt = (mjd - (*glsItr).mjd) * 24.0 + (sod - (*glsItr).sod) / 3600.0;
			if (fabs(dt) < dtmin) {
				list_out.push_back(*glsItr);
			}
		}
	}
	return list_out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, -0x40(%rbp)
movl %ecx, -0x34(%rbp)
movq %rsi, %r12
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
movq %rdi, -0x30(%rbp)
movq $0x0, 0x10(%rdi)
movq 0x7a0(%rsi), %rbx
addq $0x7a0, %r12            # imm = 0x7A0
cmpq %r12, %rbx
je 0x68b3c
movq %rdx, %r15
leaq 0x10(%rbx), %r13
movq (%r15), %rsi
movq %r13, %rdi
callq 0x8160
testq %rax, %rax
je 0x68b30
movl -0x34(%rbp), %eax
subl 0x14(%rbx), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd -0x40(%rbp), %xmm1
subsd 0x20(%rbx), %xmm1
divsd 0x1de6(%rip), %xmm1     # 0x6a8c0
mulsd 0xc266(%rip), %xmm0     # 0x74d48
addsd %xmm1, %xmm0
andpd 0xe42(%rip), %xmm0      # 0x69930
movsd 0xe2a(%rip), %xmm1      # 0x69920
ucomisd %xmm0, %xmm1
jbe 0x68b30
movl $0xa0, %edi
callq 0x8640
movq %rax, %r14
movq %rax, %rdi
addq $0x10, %rdi
movl $0x90, %edx
movq %r13, %rsi
callq 0x84f0
movq %r14, %rdi
movq -0x30(%rbp), %r14
movq %r14, %rsi
callq 0x80c0
incq 0x10(%r14)
movq (%rbx), %rbx
cmpq %r12, %rbx
jne 0x68aa7
movq -0x30(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x30(%rbp), %r15
movq (%r15), %rdi
cmpq %r15, %rdi
je 0x68b6e
movq (%rdi), %rbx
callq 0x85d0
movq %rbx, %rdi
cmpq %r15, %rbx
jne 0x68b5e
movq %r14, %rdi
callq 0x8b40
// File: /workspace/github_cpp_makefile_star2_O1/bestcoder12[P]Sudoku_Game/functions.cpp
// Function: s_brd::Sudoku::chk_num(int, int, int)
int Sudoku::chk_num(int temp_num, int t_row, int t_col)
{
	if (temp_num > 9 || temp_num < 1)
	{
		return -1;
	}
	int i = 0, j = 0;
	
	for (j = 0; j < 9; j++)
	{
		if (temp_num == board[t_row][j].get_Int())
		{
			return -1;
		}
	}
	
	for (i = 0; i < 9; i++)
	{
		if (temp_num == board[i][t_col].get_Int())
		{
			return -1;
		}
	}

	i = t_row - (t_row%3);
	j = t_col - (t_col%3);
	int row_lim = i+3;
	int col_lim = j+3;

	for (i = t_row - (t_row%3); i < row_lim; i++)
	{
		for (j = t_col - (t_col%3); j < col_lim; j++)
		{
			if (temp_num == board[i][j].get_Int())
			{
				return -1;
			}
		}
	}
	return 0;
}

// Assembly:
leal -0xa(%rsi), %eax
cmpl $-0x9, %eax
jae 0x2784
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
movslq %edx, %rax
leaq (%rax,%rax,8), %rdx
leaq (%rdi,%rdx,8), %r8
xorl %r9d, %r9d
cmpl %esi, (%r8,%r9,8)
je 0x277e
incq %r9
cmpq $0x9, %r9
jne 0x2792
movslq %ecx, %r9
leaq (%rdi,%r9,8), %rcx
movq $-0x288, %r8            # imm = 0xFD78
cmpl %esi, 0x288(%rcx,%r8)
je 0x277e
addq $0x48, %r8
jne 0x27af
pushq %rbx
imulq $0x55555556, %rax, %r10 # imm = 0x55555556
movq %r10, %rcx
shrq $0x3f, %rcx
shrq $0x20, %r10
addl %ecx, %r10d
leal (%r10,%r10,2), %ecx
subl %ecx, %eax
imulq $0x55555556, %r9, %r11  # imm = 0x55555556
movq %r11, %r8
shrq $0x3f, %r8
shrq $0x20, %r11
addl %r8d, %r11d
leal (%r11,%r11,2), %r8d
movl %r9d, %ebx
subl %r8d, %ebx
movslq %ecx, %r8
leal (%r11,%r11,2), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
leal 0x2(%r10,%r10,2), %r10d
movslq %r10d, %r10
movslq %ebx, %rbx
movq %rbx, %r11
notq %r11
addq %r9, %r11
shlq $0x3, %r9
leaq (%r9,%rdx,8), %rdx
shlq $0x3, %rbx
subq %rbx, %rdx
cltq
shlq $0x3, %rax
leaq (%rax,%rax,8), %rax
subq %rax, %rdx
addq %rdx, %rdi
movq %rdi, %rax
movq %r11, %rdx
cmpl %esi, (%rax)
je 0x2864
incq %rdx
addq $0x8, %rax
cmpq %rcx, %rdx
jl 0x2840
leaq 0x1(%r8), %rdx
addq $0x48, %rdi
xorl %eax, %eax
cmpq %r10, %r8
movq %rdx, %r8
jl 0x283a
jmp 0x2869
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/bestcoder12[P]Sudoku_Game/functions.cpp
// Function: user_gm::Player::timer(std::chrono::time_point<std::chrono::_V2::steady_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>>)
void Player::timer(std::chrono::steady_clock::time_point start)
{
    std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
    std::chrono::duration<double,std::milli> t_diff = end-start;
    time_diff = t_diff.count() / 1000;
    int minute = 15 - (time_diff / 60);
    int seconds = 60 - ((int)time_diff % 60);   
    cout << "\t\t\t\t\t\t\t" << "Time left  " << minute << ":" << seconds << "\n";
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2150
subq %rbx, %rax
cvtsi2sd %rax, %xmm0
divsd 0x177d(%rip), %xmm0     # 0x4008
divsd 0x177d(%rip), %xmm0     # 0x4010
movsd %xmm0, (%r14)
cvttsd2si %xmm0, %eax
divsd 0x1774(%rip), %xmm0     # 0x4018
addsd 0x1774(%rip), %xmm0     # 0x4020
cvttsd2si %xmm0, %ebp
cltq
imulq $-0x77777777, %rax, %rcx # imm = 0x88888889
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
sarl $0x5, %ecx
addl %edx, %ecx
imull $0x3c, %ecx, %ebx
subl %eax, %ebx
addl $0x3c, %ebx
movq 0x36f0(%rip), %r14      # 0x5fc8
leaq 0x17df(%rip), %rsi      # 0x40be
movl $0x7, %edx
movq %r14, %rdi
callq 0x2130
leaq 0x17d3(%rip), %rsi      # 0x40c6
movl $0xb, %edx
movq %r14, %rdi
callq 0x2130
movq %r14, %rdi
movl %ebp, %esi
callq 0x21a0
movq %rax, %r14
leaq 0x17be(%rip), %rsi      # 0x40d2
movl $0x1, %edx
movq %rax, %rdi
callq 0x2130
movq %r14, %rdi
movl %ebx, %esi
callq 0x21a0
leaq 0x1aac(%rip), %rsi      # 0x43de
movl $0x1, %edx
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2130
nop
// File: /workspace/github_cpp_makefile_star2_O1/bestcoder12[P]Sudoku_Game/functions.cpp
// Function: s_brd::Sudoku::print_board()
void Sudoku::print_board()
{
	for (int i = 0; i < 9; i++)
	{
		cout << "-------------------------------------" << "\n";
		for (int j = 0; j < 9; j++)
		{
			if (board[i][j].get_Int() == -1)
			{
				cout << "|" << "   "; 
				
				/*skips or jumps out of the condition if the row or column lies outside the range*/
				continue;
			}
			cout << "| " << board[i][j].get_Int() << " "; 
		}
		cout << "|" << "\n";
	}
	cout << "-------------------------------------" << "\n";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
movq 0x30fb(%rip), %r14      # 0x5fc8
leaq 0x150a(%rip), %r13      # 0x43de
leaq 0x1453(%rip), %r15      # 0x432e
leaq 0x144a(%rip), %r12      # 0x432c
movl $0x25, %edx
movq %r14, %rdi
leaq 0x1411(%rip), %rsi      # 0x4302
callq 0x2130
movl $0x1, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x2130
xorl %r13d, %r13d
cmpl $-0x1, (%rbx,%r13,8)
je 0x2f39
movl $0x2, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2130
movl (%rbx,%r13,8), %esi
movq %r14, %rdi
callq 0x21a0
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
jmp 0x2f5c
movl $0x1, %edx
movq %r14, %rdi
leaq 0x13e0(%rip), %rsi      # 0x4328
callq 0x2130
movl $0x3, %edx
movq %r14, %rdi
leaq 0x13ce(%rip), %rsi      # 0x432a
callq 0x2130
incq %r13
cmpq $0x9, %r13
jne 0x2f09
movl $0x1, %edx
movq %r14, %rdi
leaq 0x13af(%rip), %rsi      # 0x4328
callq 0x2130
movl $0x1, %edx
movq %r14, %rdi
leaq 0x1451(%rip), %r13      # 0x43de
movq %r13, %rsi
callq 0x2130
incq %rbp
addq $0x48, %rbx
cmpq $0x9, %rbp
jne 0x2ee2
movq 0x301b(%rip), %rbx      # 0x5fc8
leaq 0x134e(%rip), %rsi      # 0x4302
movl $0x25, %edx
movq %rbx, %rdi
callq 0x2130
leaq 0x1416(%rip), %rsi      # 0x43de
movl $0x1, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2130
nop
// File: /workspace/github_cpp_makefile_star2_O1/bestcoder12[P]Sudoku_Game/functions.cpp
// Function: s_brd::Sudoku::chk_win()
int Sudoku::chk_win()
{
	int err_chk = 0;

	for (int i = 0; i < 9; i++)
	{
		for (int j = 0; j < 9; j++)
		{
			if (board[i][j].get_Int() == -1)
			{
				return 0;
			}
		}
	}
	
	#ifdef __linux__
        err_chk = system("clear");
    #elif defined(_WIN32)
        err_chk = system("cls");
    #endif

	if (err_chk != 0)
	{
		cerr << "Error! Unable to clear the screen." << endl;
	}

	cout << "\n\n\n\n\t\t\t\tYOU HAVE WON THE GAME! CONGRATULATIONS!" << endl;
	return 1;
}

// Assembly:
pushq %rbx
xorl %eax, %eax
xorl %ecx, %ecx
xorl %edx, %edx
cmpl $-0x1, (%rdi,%rdx,8)
je 0x3014
incq %rdx
cmpq $0x9, %rdx
jne 0x2feb
cmpq $0x8, %rax
leaq 0x1(%rax), %rdx
setae %cl
addq $0x48, %rdi
movq %rdx, %rax
cmpq $0x9, %rdx
jne 0x2fe9
jmp 0x301f
xorl %eax, %eax
testb $0x1, %cl
je 0x30b8
leaq 0x130b(%rip), %rdi      # 0x4331
callq 0x20c0
testl %eax, %eax
je 0x3071
movq 0x2fba(%rip), %rbx      # 0x5ff0
leaq 0x12fa(%rip), %rsi      # 0x4337
movl $0x22, %edx
movq %rbx, %rdi
callq 0x2130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2090
movq 0x2f50(%rip), %rbx      # 0x5fc8
leaq 0x12db(%rip), %rsi      # 0x435a
movl $0x2f, %edx
movq %rbx, %rdi
callq 0x2130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2090
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/bestcoder12[P]Sudoku_Game/sudokusolver.cpp
// Function: findEmptyPlace(s_brd::cell (*) [9], int&, int&)
bool findEmptyPlace(cell t_board[9][9],int &row, int &col)
{ 
	for (row = 0; row < 9; row++)
	{
		for (col = 0; col < 9; col++)
		{
			if (t_board[row][col].get_Int() == -1) 
			{
				return true;
			}
		}
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x0, (%rsi)
movb $0x1, %bpl
movl $0x0, (%rbx)
xorl %eax, %eax
movslq (%r14), %rcx
cltq
leaq (%rcx,%rcx,8), %rcx
leaq (%r15,%rcx,8), %rcx
leaq (%rcx,%rax,8), %rdi
callq 0x2352
cmpl $-0x1, %eax
je 0x33ce
movl (%rbx), %ecx
leal 0x1(%rcx), %eax
movl %eax, (%rbx)
cmpl $0x8, %ecx
jl 0x3395
movl (%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%r14)
cmpl $0x8, %eax
setl %bpl
jl 0x338d
andb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq