LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: chiku[P]cmatrix/src/impl/matrix/base.cpp
// Function: cmatrix::Matrix<double>::setSize(long, long)
void Matrix<Type>::setSize(long int rows, long int columns)
{
    if ((*this).rows() > 0 && (*this).columns() > 0 && !size.matches(rows, columns)) {
        throw Exception::InvalidSizeReset(ExceptionBody::BadSizeReset(size, rows, columns));
    }

    if (rows < 0 || columns < 0) {
        throw Exception::InvalidSizeSet(ExceptionBody::InvalidSizeSet(rows, columns));
    }

    clearMemory();

    size.set(rows, columns);

    engine.allocateMemory(size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x2b80
cmpq $0x0, %rax
jle 0x2a15
movq -0xa0(%rbp), %rdi
callq 0x2ba0
cmpq $0x0, %rax
jle 0x2a15
movq -0xa0(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2bc0
testb $0x1, %al
jne 0x2a15
movb $0x1, -0x5d(%rbp)
movl $0x10, %edi
callq 0x2090
movq %rax, %rcx
movq -0xa0(%rbp), %rax
movq %rcx, -0xa8(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0x50(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x2c10
jmp 0x29a4
movq -0xa8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2da0
jmp 0x29b6
movq -0xa8(%rbp), %rdi
movb $0x0, -0x5d(%rbp)
leaq 0x4368(%rip), %rsi      # 0x6d30
leaq 0x411(%rip), %rdx       # 0x2de0
callq 0x2260
jmp 0x2b2e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x29fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20b0
testb $0x1, -0x5d(%rbp)
jne 0x2a04
jmp 0x2a10
movq -0xa8(%rbp), %rdi
callq 0x20f0
jmp 0x2b25
cmpq $0x0, -0x10(%rbp)
jl 0x2a27
cmpq $0x0, -0x18(%rbp)
jge 0x2ac6
movb $0x1, -0x81(%rbp)
movl $0x10, %edi
callq 0x2090
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x80(%rbp), %rdi
callq 0x2e00
jmp 0x2a52
movq -0xb0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x2f00
jmp 0x2a64
movq -0xb0(%rbp), %rdi
movb $0x0, -0x81(%rbp)
leaq 0x42cf(%rip), %rsi      # 0x6d48
leaq 0x4c0(%rip), %rdx       # 0x2f40
callq 0x2260
jmp 0x2b2e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x2aad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x20b0
testb $0x1, -0x81(%rbp)
jne 0x2ab8
jmp 0x2ac4
movq -0xb0(%rbp), %rdi
callq 0x20f0
jmp 0x2b25
movq -0xa0(%rbp), %rdi
callq 0x2f60
movq -0xa0(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2b50
movq -0xa0(%rbp), %rax
movq %rax, %rdi
addq $0x10, %rdi
movq (%rax), %rcx
movq %rcx, -0x98(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x90(%rbp)
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
callq 0x2fa0
addq $0xb0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x2270
nop
// File: chiku[P]cmatrix/src/exception.h
// Function: cmatrix::ExceptionBody::BadSizeReset[abi:cxx11](cmatrix::Size, long, long)
static std::basic_string<char> BadSizeReset(Size bounds, long int rows, long int columns)
        {
            std::stringstream message;
            message << "Invalid attempt to reset rows to " << rows << " and columns to " << columns
                    << " from [" << bounds.getRows() << ", " << bounds.getColumns() << "]";
            return message.str();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x1d8(%rbp)
movq %rdi, %rax
movq %rax, -0x1d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x20d0
leaq -0x1a0(%rbp), %rdi
leaq 0x140a(%rip), %rsi      # 0x4064
callq 0x2170
movq %rax, -0x1c8(%rbp)
jmp 0x2c68
movq -0x1c8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x22a0
movq %rax, -0x1e0(%rbp)
jmp 0x2c81
movq -0x1e0(%rbp), %rdi
leaq 0x13f7(%rip), %rsi      # 0x4086
callq 0x2170
movq %rax, -0x1e8(%rbp)
jmp 0x2c9d
movq -0x1e8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x22a0
movq %rax, -0x1f0(%rbp)
jmp 0x2cb6
movq -0x1f0(%rbp), %rdi
leaq 0x13d3(%rip), %rsi      # 0x4097
callq 0x2170
movq %rax, -0x1f8(%rbp)
jmp 0x2cd2
leaq -0x18(%rbp), %rdi
callq 0x3080
movq -0x1f8(%rbp), %rdi
movq %rax, %rsi
callq 0x22a0
movq %rax, -0x200(%rbp)
jmp 0x2cf3
movq -0x200(%rbp), %rdi
leaq 0x139e(%rip), %rsi      # 0x409f
callq 0x2170
movq %rax, -0x208(%rbp)
jmp 0x2d0f
leaq -0x18(%rbp), %rdi
callq 0x30a0
movq -0x208(%rbp), %rdi
movq %rax, %rsi
callq 0x22a0
movq %rax, -0x210(%rbp)
jmp 0x2d30
movq -0x210(%rbp), %rdi
leaq 0x1364(%rip), %rsi      # 0x40a2
callq 0x2170
jmp 0x2d45
movq -0x1d8(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x2160
jmp 0x2d5a
leaq -0x1b0(%rbp), %rdi
callq 0x2100
movq -0x1d0(%rbp), %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x2100
movq -0x1b8(%rbp), %rdi
callq 0x2270
// File: DoubleString[P]eph_converter/src/B2bDecoder.cpp
// Function: B2b::m_process()
void B2b::m_process(){
	m_loadorbclk();
	nav.v_openRnxEph(toString(mjd0) + ":" + toString(sod0));
	m_genclock();
	m_geneph();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x39e0
movq -0xb0(%rbp), %rsi
movq %rsi, %rax
addq $0x20, %rax
movq %rax, -0xa8(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x6740
movq -0xa0(%rbp), %rsi
leaq 0x14065(%rip), %rdx     # 0x182a7
leaq -0x48(%rbp), %rdi
callq 0x66f0
jmp 0x424d
movq -0xb0(%rbp), %rsi
addq $0x10, %rsi
leaq -0x98(%rbp), %rdi
callq 0x67f0
jmp 0x4266
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x98(%rbp), %rdx
callq 0x6620
jmp 0x427c
movq -0xa8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x13500
jmp 0x428e
leaq -0x28(%rbp), %rdi
callq 0x31c0
leaq -0x98(%rbp), %rdi
callq 0x31c0
leaq -0x48(%rbp), %rdi
callq 0x31c0
leaq -0x68(%rbp), %rdi
callq 0x31c0
movq -0xb0(%rbp), %rdi
callq 0x4340
movq -0xb0(%rbp), %rdi
callq 0x49e0
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x432a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x4321
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x4315
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x31c0
leaq -0x98(%rbp), %rdi
callq 0x31c0
leaq -0x48(%rbp), %rdi
callq 0x31c0
leaq -0x68(%rbp), %rdi
callq 0x31c0
movq -0x70(%rbp), %rdi
callq 0x34d0
nopl (%rax)
// File: DoubleString[P]eph_converter/src/Broadcast.cpp
// Function: BroadcastEphUtils::glsinit(double*, 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
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0xfe23
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd 0x30(%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xfdf7
movl $0x3, -0x1c(%rbp)
cmpl $0x6, -0x1c(%rbp)
jge 0xfe5b
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x3, %ecx
movslq %ecx, %rcx
movsd 0x48(%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xfe2a
popq %rbp
retq
nopl (%rax)
// File: DoubleString[P]eph_converter/src/Broadcast.cpp
// Function: RnxNavFile::v_readOrbit(char const*, int, double, double*)
int RnxNavFile::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 %rbx
subq $0x78, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movsd %xmm0, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0xffffffff, -0x40(%rbp) # imm = 0xFFFFFFFF
movl -0x24(%rbp), %edi
movsd -0x30(%rbp), %xmm0
leaq -0x3c(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x15240
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x52, %eax
je 0x13371
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x43, %eax
jne 0x1332d
movq -0x68(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl -0x3c(%rbp), %ecx
movsd -0x48(%rbp), %xmm0
movsd 0x3d23(%rip), %xmm1     # 0x17018
subsd %xmm1, %xmm0
movq -0x38(%rbp), %r8
movq (%rdi), %rax
leaq 0x4fa2(%rip), %rsi      # 0x182a9
leaq -0x60(%rbp), %r9
leaq -0x58(%rbp), %rbx
leaq -0x50(%rbp), %r11
leaq -0x40(%rbp), %r10
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
callq *0x10(%rax)
movl %eax, -0xc(%rbp)
jmp 0x133aa
movq -0x68(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl -0x3c(%rbp), %ecx
movsd -0x48(%rbp), %xmm0
movq -0x38(%rbp), %r8
movq (%rdi), %rax
leaq 0x4f5e(%rip), %rsi      # 0x182a9
leaq -0x60(%rbp), %r9
leaq -0x58(%rbp), %rbx
leaq -0x50(%rbp), %r11
leaq -0x40(%rbp), %r10
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
callq *0x10(%rax)
movl %eax, -0xc(%rbp)
jmp 0x133aa
movq -0x68(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl -0x3c(%rbp), %ecx
movsd -0x48(%rbp), %xmm0
movq -0x38(%rbp), %r8
movq (%rdi), %rax
leaq 0x4f1a(%rip), %rsi      # 0x182a9
leaq -0x60(%rbp), %r9
leaq -0x58(%rbp), %r11
leaq -0x40(%rbp), %r10
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
callq *0x18(%rax)
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]eph_converter/src/Broadcast.cpp
// Function: RnxNavFile::v_readClk(char const*, int, double, double*)
int RnxNavFile::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 %rbx
subq $0x78, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movsd %xmm0, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0xffffffff, -0x40(%rbp) # imm = 0xFFFFFFFF
movl -0x24(%rbp), %edi
movsd -0x30(%rbp), %xmm0
leaq -0x3c(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x15240
movq -0x38(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x52, %eax
je 0x134ba
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x43, %eax
jne 0x13477
movq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl -0x3c(%rbp), %ecx
movsd -0x48(%rbp), %xmm0
movsd 0x3bd8(%rip), %xmm1     # 0x17018
subsd %xmm1, %xmm0
movq -0x38(%rbp), %r9
movq (%rdi), %rax
leaq 0x4ae7(%rip), %rsi      # 0x17f39
xorl %r8d, %r8d
leaq -0x58(%rbp), %rbx
leaq -0x50(%rbp), %r11
leaq -0x40(%rbp), %r10
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
callq *0x10(%rax)
movl %eax, -0xc(%rbp)
jmp 0x134f2
movq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl -0x3c(%rbp), %ecx
movsd -0x48(%rbp), %xmm0
movq -0x38(%rbp), %r9
movq (%rdi), %rax
leaq 0x4aa4(%rip), %rsi      # 0x17f39
xorl %r8d, %r8d
leaq -0x58(%rbp), %rbx
leaq -0x50(%rbp), %r11
leaq -0x40(%rbp), %r10
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
callq *0x10(%rax)
movl %eax, -0xc(%rbp)
jmp 0x134f2
movq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl -0x3c(%rbp), %ecx
movsd -0x48(%rbp), %xmm0
movq -0x38(%rbp), %r9
movq (%rdi), %rax
leaq 0x4a61(%rip), %rsi      # 0x17f39
xorl %r8d, %r8d
leaq -0x58(%rbp), %r11
leaq -0x40(%rbp), %r10
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
callq *0x18(%rax)
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: DoubleString[P]eph_converter/src/Broadcast.cpp
// Function: RnxNavFile::v_openRnxEph(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void RnxNavFile::v_openRnxEph(string ephcmd) {
	int curmjd;
	this->isOpen = 1;
	int iyear, imon, iday, ih, imin;
	double dsec, cursod;
	curmjd = atoi(ephcmd.substr(0, index_string(ephcmd.c_str(), ':')).c_str());
	cursod = atof(ephcmd.substr(index_string(ephcmd.c_str(), ':') + 1).c_str());
	mjd0 = curmjd;
	sod0 = 0.0;
	mjd1 = curmjd + 1;
	sod1 = 0.0;
	mjd2date(curmjd, cursod, &iyear, &imon, &iday, &ih, &imin, &dsec);
	memset(curFile, 0, sizeof(char) * 1024);
	for (int i = 0; i < this->navfilename.length(); i++)
		this->curFile[i] = this->navfilename[i];

	/**** using rinex3.x format to read nav ****/
	this->m_readRnxnav('M');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x98(%rbp)
movq %rdi, %rax
movq -0x98(%rbp), %rdi
movq %rdi, -0x90(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movl $0x1, 0x500(%rax)
callq 0x3130
movq %rax, %rdi
movl $0x3a, %esi
callq 0x150f0
movq -0x90(%rbp), %rsi
movslq %eax, %rcx
leaq -0x58(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x32e0
leaq -0x58(%rbp), %rdi
callq 0x3130
movq %rax, %rdi
callq 0x3440
movl %eax, -0x14(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x31c0
movq -0x90(%rbp), %rdi
callq 0x3130
movq %rax, %rdi
movl $0x3a, %esi
callq 0x150f0
movq -0x90(%rbp), %rsi
addl $0x1, %eax
movslq %eax, %rdx
leaq -0x78(%rbp), %rdi
movq $-0x1, %rcx
callq 0x32e0
leaq -0x78(%rbp), %rdi
callq 0x3130
movq %rax, %rdi
callq 0x3380
movsd %xmm0, -0x38(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x31c0
movq -0x88(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x4e8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x4f0(%rax)
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, 0x4ec(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x4f8(%rax)
movl -0x14(%rbp), %edi
movsd -0x38(%rbp), %xmm0
leaq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x24(%rbp), %r8
leaq -0x28(%rbp), %r9
leaq -0x30(%rbp), %rax
movq %rax, (%rsp)
callq 0x162e0
movq -0x88(%rbp), %rdi
addq $0xe8, %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x31a0
movl $0x0, -0x7c(%rbp)
movq -0x88(%rbp), %rdi
movslq -0x7c(%rbp), %rax
movq %rax, -0xa0(%rbp)
addq $0x700, %rdi            # imm = 0x700
callq 0x3420
movq %rax, %rcx
movq -0xa0(%rbp), %rax
cmpq %rcx, %rax
jae 0x136bd
movq -0x88(%rbp), %rdi
addq $0x700, %rdi            # imm = 0x700
movslq -0x7c(%rbp), %rsi
callq 0x3540
movq %rax, %rcx
movq -0x88(%rbp), %rax
movb (%rcx), %dl
movslq -0x7c(%rbp), %rcx
movb %dl, 0xe8(%rax,%rcx)
movl -0x7c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x7c(%rbp)
jmp 0x13657
movq -0x88(%rbp), %rdi
movl $0x4d, %esi
callq 0x10870
addq $0xb0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: DoubleString[P]eph_converter/src/Broadcast.cpp
// Function: RnxNavFile::v_readOrbit(char const*, int, double, double*, int*)
int RnxNavFile::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 %rbx
subq $0x88, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movsd %xmm0, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movl -0x24(%rbp), %edi
movsd -0x30(%rbp), %xmm0
leaq -0x44(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x15240
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x52, %eax
je 0x137d1
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x43, %eax
jne 0x1378d
movq -0x70(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl -0x44(%rbp), %ecx
movsd -0x50(%rbp), %xmm0
movsd 0x38c3(%rip), %xmm1     # 0x17018
subsd %xmm1, %xmm0
movq -0x38(%rbp), %r8
movq -0x40(%rbp), %r10
movq (%rdi), %rax
leaq 0x4b3e(%rip), %rsi      # 0x182a9
leaq -0x68(%rbp), %r9
leaq -0x60(%rbp), %rbx
leaq -0x58(%rbp), %r11
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
callq *0x10(%rax)
movl %eax, -0xc(%rbp)
jmp 0x1380a
movq -0x70(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl -0x44(%rbp), %ecx
movsd -0x50(%rbp), %xmm0
movq -0x38(%rbp), %r8
movq -0x40(%rbp), %r10
movq (%rdi), %rax
leaq 0x4afa(%rip), %rsi      # 0x182a9
leaq -0x68(%rbp), %r9
leaq -0x60(%rbp), %rbx
leaq -0x58(%rbp), %r11
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
callq *0x10(%rax)
movl %eax, -0xc(%rbp)
jmp 0x1380a
movq -0x70(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl -0x44(%rbp), %ecx
movsd -0x50(%rbp), %xmm0
movq -0x38(%rbp), %r8
movq -0x40(%rbp), %r10
movq (%rdi), %rax
leaq 0x4ab6(%rip), %rsi      # 0x182a9
leaq -0x68(%rbp), %r9
leaq -0x60(%rbp), %r11
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
callq *0x18(%rax)
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
nopw (%rax,%rax)
// File: DoubleString[P]eph_converter/src/Broadcast.cpp
// Function: RnxNavFile::v_readClk(char const*, int, double, double*, int*)
int RnxNavFile::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 %rbx
subq $0x78, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movsd %xmm0, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0x24(%rbp), %edi
movsd -0x30(%rbp), %xmm0
leaq -0x44(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x15240
movq -0x38(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x52, %eax
je 0x13917
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x43, %eax
jne 0x138d4
movq -0x68(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl -0x44(%rbp), %ecx
movsd -0x50(%rbp), %xmm0
movsd 0x377b(%rip), %xmm1     # 0x17018
subsd %xmm1, %xmm0
movq -0x38(%rbp), %r9
movq -0x40(%rbp), %r10
movq (%rdi), %rax
leaq 0x4686(%rip), %rsi      # 0x17f39
xorl %r8d, %r8d
leaq -0x60(%rbp), %rbx
leaq -0x58(%rbp), %r11
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
callq *0x10(%rax)
movl %eax, -0xc(%rbp)
jmp 0x1394f
movq -0x68(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl -0x44(%rbp), %ecx
movsd -0x50(%rbp), %xmm0
movq -0x38(%rbp), %r9
movq -0x40(%rbp), %r10
movq (%rdi), %rax
leaq 0x4643(%rip), %rsi      # 0x17f39
xorl %r8d, %r8d
leaq -0x60(%rbp), %rbx
leaq -0x58(%rbp), %r11
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
callq *0x10(%rax)
movl %eax, -0xc(%rbp)
jmp 0x1394f
movq -0x68(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl -0x44(%rbp), %ecx
movsd -0x50(%rbp), %xmm0
movq -0x38(%rbp), %r9
movq -0x40(%rbp), %r10
movq (%rdi), %rax
leaq 0x4600(%rip), %rsi      # 0x17f39
xorl %r8d, %r8d
leaq -0x60(%rbp), %r11
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
callq *0x18(%rax)
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: DoubleString[P]eph_converter/src/../include/Broadcast.h
// Function: GPSEPH::GPSEPH()
GPSEPH() {
		mjd = 0;
		sod = 0.0;
		iodc=-1;
		signal_idx=0;
		delta_A=0.0;
		A_DOT=0.0;
		delta_n_dot=0.0;
		memset(cprn, 0, sizeof(cprn));
		time(&gent);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0x0, 0x4(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rdi)
movsd 0x416d(%rip), %xmm0     # 0x17d58
movsd %xmm0, 0x100(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0xf8(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x1d8(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x1e0(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x1e8(%rdi)
xorl %esi, %esi
movl $0x4, %edx
callq 0x31a0
movq -0x10(%rbp), %rdi
addq $0xf0, %rdi
callq 0x3260
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: DoubleString[P]eph_converter/src/../include/Broadcast.h
// Function: GLSEPH::GLSEPH()
GLSEPH() {
		mjd = 0;
		sod = 0.0;
		memset(cprn, 0, sizeof(cprn));
		time(&gent);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0x0, 0x4(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rdi)
xorl %esi, %esi
movl $0x4, %edx
callq 0x31a0
movq -0x10(%rbp), %rdi
addq $0x90, %rdi
callq 0x3260
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: DoubleString[P]eph_converter/src/Com.cpp
// Function: md_julday(int, int, int)
int md_julday(int iyear,int imonth,int iday){
	int iyr, result;
	int doy_of_month[12] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304,
			334 };
	if (iyear < 0 || imonth < 0 || iday < 0 || imonth > 12 || iday > 366
			|| (imonth != 0 && iday > 31)) {
		printf("iyear = %d,imonth = %d,iday = %d,incorrect argument",iyear,imonth,iday);
		printf("iyear = %d,imonth = %d,iday = %d,incorrect argument",iyear,imonth,iday);
		exit(1);
	}
	iyr = iyear;
	if (imonth <= 2)
		iyr -= 1;
	result = 365 * iyear - 678941 + iyr / 4 - iyr / 100 + iyr / 400 + iday;
	if (imonth != 0)
		result = result + doy_of_month[imonth - 1];
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x3ea4(%rip), %rsi      # 0x18340
movl $0x30, %edx
callq 0x3230
cmpl $0x0, -0x4(%rbp)
jl 0x144d3
cmpl $0x0, -0x8(%rbp)
jl 0x144d3
cmpl $0x0, -0xc(%rbp)
jl 0x144d3
cmpl $0xc, -0x8(%rbp)
jg 0x144d3
cmpl $0x16e, -0xc(%rbp)      # imm = 0x16E
jg 0x144d3
cmpl $0x0, -0x8(%rbp)
je 0x1450b
cmpl $0x1f, -0xc(%rbp)
jle 0x1450b
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
movl -0xc(%rbp), %ecx
leaq 0x3ebd(%rip), %rdi      # 0x183a0
movb $0x0, %al
callq 0x3050
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
movl -0xc(%rbp), %ecx
leaq 0x3ea6(%rip), %rdi      # 0x183a0
movb $0x0, %al
callq 0x3050
movl $0x1, %edi
callq 0x3360
movl -0x4(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jg 0x14520
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x10(%rbp)
imull $0x16d, -0x4(%rbp), %eax # imm = 0x16D
subl $0xa5c1d, %eax          # imm = 0xA5C1D
movl %eax, -0x5c(%rbp)
movl -0x10(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x5c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x58(%rbp)
movl -0x10(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x58(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x54(%rbp)
movl -0x10(%rbp), %eax
movl $0x190, %ecx            # imm = 0x190
cltd
idivl %ecx
movl %eax, %ecx
movl -0x54(%rbp), %eax
addl %ecx, %eax
addl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x1458a
movl -0x14(%rbp), %eax
movl -0x8(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
addl -0x50(%rbp,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]eph_converter/src/Com.cpp
// Function: gpsweek(int, int, int, int*, int*)
void gpsweek(int year, int month, int day, int* week, int* wd) {
	int mjd;
	if (year != 0) {
		if (month != 0)
			mjd = md_julday(year, month, day);
		else
			mjd = md_julday(year, 1, 1) + day - 1;
	} else
		mjd = day;
	*week = (mjd - 44244) / 7;
	*wd = mjd - 44244 - (*week) * 7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x145f2
cmpl $0x0, -0x8(%rbp)
je 0x145d8
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x14480
movl %eax, -0x24(%rbp)
jmp 0x145f0
movl -0x4(%rbp), %edi
movl $0x1, %edx
movl %edx, %esi
callq 0x14480
addl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x145f8
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
subl $0xacd4, %eax           # imm = 0xACD4
movl $0x7, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x24(%rbp), %ecx
subl $0xacd4, %ecx           # imm = 0xACD4
movq -0x18(%rbp), %rax
imull $0x7, (%rax), %eax
subl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: DoubleString[P]eph_converter/src/Com.cpp
// Function: mjd2doy(int, int*, int*)
void mjd2doy(int jd, int* iyear, int* idoy) {
	*iyear = (jd + 678940) / 365;
	*idoy = jd - md_julday(*iyear, 1, 1);
	while (*idoy <= 0) {
		(*iyear)--;
		*idoy = jd - md_julday(*iyear, 1, 1) + 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x4(%rbp), %eax
addl $0xa5c1c, %eax          # imm = 0xA5C1C
movl $0x16d, %ecx            # imm = 0x16D
cltd
idivl %ecx
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
movl $0x1, %edx
movl %edx, %esi
callq 0x14480
movl -0x1c(%rbp), %ecx
subl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jg 0x146ba
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movl -0x4(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
movl $0x1, %edx
movl %edx, %esi
callq 0x14480
movl -0x20(%rbp), %ecx
subl %eax, %ecx
addl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x1467e
addq $0x20, %rsp
popq %rbp
retq
// File: DoubleString[P]eph_converter/src/Com.cpp
// Function: wksow2mjd(int, double, int*, double*)
void wksow2mjd(int week,double sow,int* mjd,double* sod){
	if(mjd!=NULL)
		*mjd = (int)(sow/86400.0) + week*7 + 44244;
	if(sod!=NULL)
		*sod = fmod(sow,86400.0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x14706
movsd -0x10(%rbp), %xmm0
movsd 0x2944(%rip), %xmm1     # 0x17030
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
imull $0x7, -0x4(%rbp), %eax
addl %eax, %ecx
addl $0xacd4, %ecx           # imm = 0xACD4
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x14727
movsd -0x10(%rbp), %xmm0
movsd 0x2916(%rip), %xmm1     # 0x17030
callq 0x33a0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: DoubleString[P]eph_converter/src/Com.cpp
// Function: rot_enu2xyz(double, double, double (*) [3])
void rot_enu2xyz(double lat, double lon, double (*rotmat)[3]) {
	double coslat, sinlat, coslon, sinlon;
	coslat = cos(lat - PI / 2);
	sinlat = sin(lat - PI / 2);
	coslon = cos(-PI / 2 - lon);
	sinlon = sin(-PI / 2 - lon);

	rotmat[0][0] = coslon;
	rotmat[0][1] = sinlon * coslat;
	rotmat[0][2] = sinlon * sinlat;
	rotmat[1][0] = -sinlon;
	rotmat[1][1] = coslon * coslat;
	rotmat[1][2] = coslon * sinlat;
	rotmat[2][0] = 0;
	rotmat[2][1] = -sinlat;
	rotmat[2][2] = coslat;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x3475(%rip), %xmm1     # 0x182d8
subsd %xmm1, %xmm0
callq 0x3500
movsd %xmm0, -0x20(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x345a(%rip), %xmm1     # 0x182d8
subsd %xmm1, %xmm0
callq 0x30b0
movsd %xmm0, -0x28(%rbp)
movsd 0x343c(%rip), %xmm0     # 0x182d0
subsd -0x10(%rbp), %xmm0
callq 0x3500
movsd %xmm0, -0x30(%rbp)
movsd 0x3425(%rip), %xmm0     # 0x182d0
subsd -0x10(%rbp), %xmm0
callq 0x30b0
movsd %xmm0, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x38(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movsd -0x38(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x38(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movsd -0x30(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movsd -0x30(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x28(%rax)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rax)
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x38(%rax)
movsd -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x40(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: DoubleString[P]eph_converter/src/Com.cpp
// Function: matmpy(double*, double*, double*, int, int, int)
void matmpy(double* A, double* B, double* C, int row, int colA, int colB) {
	int i, j, k;
	double value;
	double* dest = (double*)calloc(row * colB,sizeof(double));
	for (i = 0; i < row; i++) {
		for (j = 0; j < colB; j++) {
			value = 0;
			for (k = 0; k < colA; k++){
				value += A[i * colA + k] * B[k* colB + j];
			}
			dest[i * colB + j] = value;
		}
	}
	for(i = 0;i <row;i++){
		for(j = 0;j < colB;j++){
			C[i * colB + j] = dest[i * colB + j];
		}
	}
	free(dest);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl -0x1c(%rbp), %eax
imull -0x24(%rbp), %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x31e0
movq %rax, -0x40(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x15076
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x15066
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x1503d
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
imull -0x20(%rbp), %ecx
addl -0x30(%rbp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movl -0x30(%rbp), %ecx
imull -0x24(%rbp), %ecx
addl -0x2c(%rbp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x38(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x14fec
movsd -0x38(%rbp), %xmm0
movq -0x40(%rbp), %rax
movl -0x28(%rbp), %ecx
imull -0x24(%rbp), %ecx
addl -0x2c(%rbp), %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x14fd1
jmp 0x15068
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x14fbe
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x150d8
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x150cb
movq -0x40(%rbp), %rax
movl -0x28(%rbp), %ecx
imull -0x24(%rbp), %ecx
addl -0x2c(%rbp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movl -0x28(%rbp), %ecx
imull -0x24(%rbp), %ecx
addl -0x2c(%rbp), %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1508c
jmp 0x150cd
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1507d
movq -0x40(%rbp), %rdi
callq 0x3350
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: DoubleString[P]eph_converter/src/Com.cpp
// Function: index_string(char const*, char)
int index_string(const char* src, char key) {
	int len = strlen(src);
	int i;
	for (i = 0; i < len; i++) {
		if (src[i] == key)
			break;
	}
	if (i == len)
		return -1;
	else
		return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3160
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x15140
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x15133
jmp 0x15140
jmp 0x15135
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x15115
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x15151
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x15157
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: DoubleString[P]eph_converter/src/Com.cpp
// Function: len_trim(char const*)
int len_trim(const char* pStr) {
	int length = strlen(pStr);
	int count = length;
	int i;
	for (i = length - 1; i >= 0; i--) {
		if (pStr[i] == '\0' || pStr[i] == '\n' || pStr[i] == '\r'
				|| pStr[i] == ' ')
			count--;
		else
			break;
	}
	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3160
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x151eb
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x151d1
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
je 0x151d1
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
je 0x151d1
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0x151dc
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x151de
jmp 0x151eb
jmp 0x151e0
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x15187
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]eph_converter/src/Com.cpp
// Function: yr2year(int&)
void yr2year(int& yr) {
	if (yr > 1900)
		return;
	if (yr <= 30)
		yr += 2000;
	else
		yr += 1900;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x76c, (%rax)          # imm = 0x76C
jle 0x15216
jmp 0x1523d
movq -0x8(%rbp), %rax
cmpl $0x1e, (%rax)
jg 0x1522f
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x7d0, %ecx            # imm = 0x7D0
movl %ecx, (%rax)
jmp 0x1523d
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x76c, %ecx            # imm = 0x76C
movl %ecx, (%rax)
popq %rbp
retq
nop
// File: DoubleString[P]eph_converter/src/Com.cpp
// Function: filleph(char*, double)
void filleph(char* line,double ver){
	int i,len,cpre = 4;
	char tmp[128];
	if(ver < 3.0)
		cpre = 3;
	len = len_trim(line);
	for(i = len;i < cpre + 19 * 4;i++){
		line[i] = ' ';
	}
	line[cpre + 19 * 4] = '\0';
	for (i = 0; i < 4; i++) {
		substringEx(tmp, line + cpre + 19 * i, 0, 19);
		if (len_trim(tmp) == 0) {
			line[cpre + 19 * i + 1] = '0';
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl $0x4, -0x1c(%rbp)
movsd 0x2a4d(%rip), %xmm0     # 0x17d80
ucomisd -0x10(%rbp), %xmm0
jbe 0x15341
movl $0x3, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x15160
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0x1c(%rbp), %ecx
addl $0x4c, %ecx
cmpl %ecx, %eax
jge 0x15377
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x20, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x15353
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x4c, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x153f1
leaq -0xa0(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0x1c(%rbp), %rax
addq %rax, %rsi
imull $0x13, -0x14(%rbp), %eax
cltq
addq %rax, %rsi
xorl %edx, %edx
movl $0x13, %ecx
callq 0x15400
leaq -0xa0(%rbp), %rdi
callq 0x15160
cmpl $0x0, %eax
jne 0x153e4
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
imull $0x13, -0x14(%rbp), %edx
addl %edx, %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x30, (%rax,%rcx)
jmp 0x153e6
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1538f
addq $0xa0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: DoubleString[P]eph_converter/src/Com.cpp
// Function: substringEx(char*, char const*, int, int)
char* substringEx(char* dest, const char* src, int start, int length) {
	int i, j = 0;
	int len = strlen(src);
	if (start < 0 || start >= len || start + length > len) {
		dest[0] = '\0';
		return NULL;
	}
	for (i = start; i < start + length; i++) {
		dest[j] = src[i];
		j++;
	}
	dest[j] = '\0';
	return dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3160
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x15442
movl -0x1c(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x15442
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jle 0x15453
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x154a4
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl -0x1c(%rbp), %ecx
addl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jge 0x15490
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x15459
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: DoubleString[P]eph_converter/src/Com.cpp
// Function: genAode(char, int, double, double, int, GPSEPH*)
int genAode(char csys,int mjd,double sod,double toe,int inade,GPSEPH* eph){
	int mjd_r,ret = -1;
	double sod_r;
	if(csys == 'G' || csys == 'J')
		ret = inade;
	else if(csys == 'R'){
		timinc(mjd,sod, 19.0 - 37,&mjd_r,&sod_r);
		//ret = NINT(sod / 900.0) + 1;
		//IGMAS:
		ret = NINT(fmod(sod_r + 10800.0, 86400.0) / 900.0);
	}
	else if(csys == 'E'){
		// ret = NINT(sod / 600.0) + 1;
		//IGMAS:
		ret = inade;
	}
	else if(csys == 'C'){
		// ret = NINT(sod / 1800.0) + 1;
		//IGMAS:
		//ret = NINT(fmod(toe, 86400.0) / 450.0);
//		ret = getbdsiode(*eph);
		ret = (int)eph->iodc;
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl %esi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF
movsbl -0x1(%rbp), %eax
cmpl $0x47, %eax
je 0x154eb
movsbl -0x1(%rbp), %eax
cmpl $0x4a, %eax
jne 0x154f6
movl -0x1c(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x1557b
movsbl -0x1(%rbp), %eax
cmpl $0x52, %eax
jne 0x1554c
movl -0x8(%rbp), %edi
movsd -0x10(%rbp), %xmm0
movsd 0x2de1(%rip), %xmm1     # 0x182f0
leaq -0x2c(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x15590
movsd 0x2dc4(%rip), %xmm0     # 0x182e8
addsd -0x38(%rbp), %xmm0
movsd 0x1aff(%rip), %xmm1     # 0x17030
callq 0x33a0
movsd 0x1b0a(%rip), %xmm1     # 0x17048
divsd %xmm1, %xmm0
callq 0x16740
movl %eax, -0x30(%rbp)
jmp 0x15579
movsbl -0x1(%rbp), %eax
cmpl $0x45, %eax
jne 0x1555d
movl -0x1c(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x15577
movsbl -0x1(%rbp), %eax
cmpl $0x43, %eax
jne 0x15575
movq -0x28(%rbp), %rax
cvttsd2si 0x100(%rax), %eax
movl %eax, -0x30(%rbp)
jmp 0x15577
jmp 0x15579
jmp 0x1557b
movl -0x30(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]eph_converter/src/Com.cpp
// Function: timinc(int, double, double, int*, double*)
void timinc(int jd, double sec, double delt, int* jd1, double* sec1) {
	*sec1 = sec + delt;
	int inc = (int) (*sec1 / 86400.0);
	*jd1 = jd + inc;
	*sec1 = *sec1 - inc * 86400.0;
	if (*sec1 >= 0)
		return;
	*jd1 = *jd1 - 1;
	*sec1 = *sec1 + 86400;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
addsd -0x18(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
movsd 0x1a65(%rip), %xmm1     # 0x17030
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x2c(%rbp)
movl -0x4(%rbp), %ecx
addl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movsd (%rax), %xmm1
cvtsi2sdl -0x2c(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0x1a22(%rip), %xmm2     # 0x17030
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x15631
jmp 0x15658
movq -0x20(%rbp), %rax
movl (%rax), %ecx
subl $0x1, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movsd 0x19e4(%rip), %xmm0     # 0x17030
addsd (%rax), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: DoubleString[P]eph_converter/src/Com.cpp
// Function: CRC24(long, unsigned char const*)
unsigned long CRC24(long size, const unsigned char *buf) {
	unsigned long crc = 0;
	int ii;
	while (size--) {
		crc ^= (*buf++) << (16);
		for (ii = 0; ii < 8; ii++) {
			crc <<= 1;
			if (crc & 0x1000000) {
				crc ^= 0x01864cfb;
			}
		}
	}
	return crc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x8(%rbp)
cmpq $0x0, %rax
je 0x1626d
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movzbl (%rax), %eax
shll $0x10, %eax
cltq
xorq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jge 0x1626b
movq -0x18(%rbp), %rax
shlq %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0x1000000, %rax        # imm = 0x1000000
cmpq $0x0, %rax
je 0x1625e
movq -0x18(%rbp), %rax
xorq $0x1864cfb, %rax        # imm = 0x1864CFB
movq %rax, -0x18(%rbp)
jmp 0x16260
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1622f
jmp 0x161f4
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]eph_converter/src/Com.cpp
// Function: brdtime(char*, int*, double*)
void brdtime(char* cprn,int *mjd,double *sod){
	switch (cprn[0]) {
	case 'C':
	case 'B':
		timinc(*mjd, *sod, 14.0, mjd, sod);
		break;
	case 'R':
		//timinc(*mjd, *sod, Taiutc::s_getInstance()->m_getTaiutc(*mjd) - 19.0, mjd, sod);
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
addl $-0x42, %eax
subl $0x2, %eax
jb 0x162b2
jmp 0x162a8
movl -0x1c(%rbp), %eax
subl $0x52, %eax
je 0x162d7
jmp 0x162d9
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movsd 0xd48(%rip), %xmm1      # 0x17018
callq 0x15590
jmp 0x162d9
jmp 0x162d9
addq $0x20, %rsp
popq %rbp
retq
nop
// File: DoubleString[P]eph_converter/src/Com.cpp
// Function: mjd2date(int, double, int*, int*, int*, int*, int*, double*)
void mjd2date(int jd, double sod, int* iyear, int* imonth, int* iday, int* ih,
		int* imin, double* sec) {
	int doy = 0;
	mjd2doy(jd, iyear, &doy);
	yeardoy2monthday(*iyear, doy, imonth, iday);

	*ih =  static_cast<int>( sod / 3600.0);
	*imin = static_cast<int> ((sod - (*ih) * 3600.0) / 60.0);
	*sec = sod - (*ih) * 3600.0 - (*imin) * 60.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rsi
leaq -0x3c(%rbp), %rdx
callq 0x14630
movq -0x18(%rbp), %rax
movl (%rax), %edi
movl -0x3c(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x16410
movsd -0x10(%rbp), %xmm0
movsd 0xcc6(%rip), %xmm1      # 0x17008
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movsd -0x10(%rbp), %xmm1
movq -0x30(%rbp), %rax
cvtsi2sdl (%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0xc8c(%rip), %xmm2      # 0x17008
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0xc84(%rip), %xmm1      # 0x17010
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movsd -0x10(%rbp), %xmm0
movq -0x30(%rbp), %rax
cvtsi2sdl (%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
movsd 0xc42(%rip), %xmm2      # 0x17008
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movq -0x38(%rbp), %rax
cvtsi2sdl (%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0xc1b(%rip), %xmm2      # 0x17010
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x10(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: DoubleString[P]eph_converter/src/Com.cpp
// Function: yeardoy2monthday(int, int, int*, int*)
void yeardoy2monthday(int iyear, int idoy, int* imonth, int* iday) {
	int days_in_month[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
	int id, i;
	if ((iyear % 4 == 0 && iyear % 100 != 0) || iyear % 400 == 0)
		days_in_month[1] = 29;
	id = idoy;
	for (i = 0; i < 12; i++) {
		id = id - days_in_month[i];
		if (id > 0)
			continue;
		*iday = id + days_in_month[i];
		*imonth = i + 1;
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x1f3f(%rip), %rsi      # 0x18370
movl $0x30, %edx
callq 0x3230
movl -0x4(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x1645b
movl -0x4(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x1646b
movl -0x4(%rbp), %eax
movl $0x190, %ecx            # imm = 0x190
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x16472
movl $0x1d, -0x4c(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x54(%rbp)
movl $0x0, -0x58(%rbp)
cmpl $0xc, -0x58(%rbp)
jge 0x164c5
movl -0x54(%rbp), %eax
movslq -0x58(%rbp), %rcx
subl -0x50(%rbp,%rcx,4), %eax
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
jle 0x1649b
jmp 0x164ba
movl -0x54(%rbp), %ecx
movslq -0x58(%rbp), %rax
addl -0x50(%rbp,%rax,4), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x58(%rbp), %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x164c5
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x1647f
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: DoubleString[P]eph_converter/src/Com.cpp
// Function: unit_vector(int, double*, double*, double*)
void unit_vector(int n, double* v, double* u, double* length) {

	int i;
	*length = 0.0;
	for (i = 0; i < n; i++) {
		*length = *length + v[i] * v[i];
	}
	(*length) = sqrt(*length);
	for (i = 0; i < n; i++)
		u[i] = v[i] / (*length);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x1653e
movq -0x20(%rbp), %rax
movsd (%rax), %xmm1
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x164f9
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
callq 0x3220
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x1658f
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
divsd (%rax), %xmm0
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1655a
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)