LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tonymugen[P]sampleSNPs/varfiles.cpp
// Function: sampFiles::BedFile::BedFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
BedFile::BedFile(const string &stubName) : GbinFile(), _fileStub{stubName} {
	_fileName = _fileStub + ".bed";
    _bimFile.exceptions(fstream::badbit);
	_famFile.exceptions(fstream::badbit);
    // _elemSize is set to sizeof(char) in the GbinFile default constructor
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x1ef90
movq -0x50(%rbp), %rdi
leaq 0x20168(%rip), %rax     # 0x2b8b0
movq %rax, (%rdi)
addq $0x248, %rdi            # imm = 0x248
movq %rdi, -0x48(%rbp)
callq 0x43f0
jmp 0xb75d
movq -0x50(%rbp), %rdi
addq $0x458, %rdi            # imm = 0x458
movq %rdi, -0x58(%rbp)
callq 0x43f0
jmp 0xb773
movq -0x50(%rbp), %rdi
addq $0x668, %rdi            # imm = 0x668
movq %rdi, -0x60(%rbp)
movq -0x10(%rbp), %rsi
callq 0x4150
jmp 0xb78d
movq -0x50(%rbp), %rsi
addq $0x668, %rsi            # imm = 0x668
leaq 0x17f76(%rip), %rdx     # 0x23715
leaq -0x40(%rbp), %rdi
callq 0x7920
jmp 0xb7aa
movq -0x50(%rbp), %rdi
addq $0x218, %rdi            # imm = 0x218
leaq -0x40(%rbp), %rsi
movq %rsi, -0x68(%rbp)
callq 0x4410
movq -0x68(%rbp), %rdi
callq 0x46d8
movq -0x50(%rbp), %rax
movq 0x458(%rax), %rcx
movq -0x18(%rcx), %rcx
leaq 0x458(%rax,%rcx), %rdi
movl $0x1, %esi
callq 0x4100
jmp 0xb7ee
movq -0x50(%rbp), %rax
movq 0x248(%rax), %rcx
movq -0x18(%rcx), %rcx
leaq 0x248(%rax,%rcx), %rdi
movl $0x1, %esi
callq 0x4100
jmp 0xb811
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0xb868
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0xb85f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0xb856
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x46d8
movq -0x58(%rbp), %rdi
callq 0x40b0
movq -0x48(%rbp), %rdi
callq 0x40b0
movq -0x50(%rbp), %rdi
callq 0x1eff0
movq -0x18(%rbp), %rdi
callq 0x4610
nopw (%rax,%rax)
// File: tonymugen[P]sampleSNPs/varfiles.cpp
// Function: sampFiles::BedFile::~BedFile()
BedFile::~BedFile(){
    if (_bimFile.is_open()) {
        _bimFile.close();
    }
    if (_famFile.is_open()) {
        _famFile.close();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
leaq 0x20015(%rip), %rax     # 0x2b8b0
movq %rax, (%rdi)
addq $0x458, %rdi            # imm = 0x458
callq 0x45e0
movb %al, -0x9(%rbp)
jmp 0xb8af
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0xb8b8
jmp 0xb8cc
movq -0x18(%rbp), %rdi
addq $0x458, %rdi            # imm = 0x458
callq 0x4060
jmp 0xb8ca
jmp 0xb8cc
movq -0x18(%rbp), %rdi
addq $0x248, %rdi            # imm = 0x248
callq 0x45e0
movb %al, -0x19(%rbp)
jmp 0xb8e1
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xb8ea
jmp 0xb8fe
movq -0x18(%rbp), %rdi
addq $0x248, %rdi            # imm = 0x248
callq 0x4060
jmp 0xb8fc
jmp 0xb8fe
movq -0x18(%rbp), %rdi
addq $0x668, %rdi            # imm = 0x668
callq 0x46d8
movq -0x18(%rbp), %rdi
addq $0x458, %rdi            # imm = 0x458
callq 0x40b0
movq -0x18(%rbp), %rdi
addq $0x248, %rdi            # imm = 0x248
callq 0x40b0
movq -0x18(%rbp), %rdi
callq 0x1eff0
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x82c0
nopw %cs:(%rax,%rax)
// File: tonymugen[P]sampleSNPs/varfiles.cpp
// Function: sampFiles::BedFile::close()
void BedFile::close(){
    if (_varFile.is_open()) {
        _varFile.close();
    }
    if (_bimFile.is_open()) {
        _bimFile.close();
    }
    if (_famFile.is_open()) {
        _famFile.close();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x8, %rdi
callq 0x45e0
testb $0x1, %al
jne 0xb973
jmp 0xb980
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x4060
movq -0x10(%rbp), %rdi
addq $0x458, %rdi            # imm = 0x458
callq 0x45e0
testb $0x1, %al
jne 0xb996
jmp 0xb9a6
movq -0x10(%rbp), %rdi
addq $0x458, %rdi            # imm = 0x458
callq 0x4060
movq -0x10(%rbp), %rdi
addq $0x248, %rdi            # imm = 0x248
callq 0x45e0
testb $0x1, %al
jne 0xb9bc
jmp 0xb9cc
movq -0x10(%rbp), %rdi
addq $0x248, %rdi            # imm = 0x248
callq 0x4060
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tonymugen[P]sampleSNPs/varfiles.cpp
// Function: sampFiles::GtxtFileI::open()
void GtxtFileI::open(){
    if (_varFile.is_open()) {
        _varFile.close();
    }
    try {
        _varFile.open(_fileName.c_str(), ios::in);
		if (!_varFile.is_open()) {
			cerr << "ERROR: failed to open file " << _fileName << " for input" << endl;
			exit(2);
		}

    } catch (system_error &error) {
        cerr << "ERROR: cannot open text file " << _fileName << " for input: " << error.code().message() << flush;
        perror(" ");
        exit(1);

    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x8, %rdi
callq 0x45e0
testb $0x1, %al
jne 0x16d66
jmp 0x16d73
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x4060
movq -0x48(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x50(%rbp)
addq $0x218, %rdi            # imm = 0x218
callq 0x4140
movq -0x50(%rbp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x42f0
jmp 0x16da1
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x45e0
movb %al, -0x51(%rbp)
jmp 0x16db3
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x16f00
jmp 0x16dc0
movq 0x15229(%rip), %rdi     # 0x2bff0
leaq 0xc76a(%rip), %rsi      # 0x23538
callq 0x4310
movq %rax, -0x60(%rbp)
jmp 0x16dd9
movq -0x60(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq $0x218, %rsi            # imm = 0x218
callq 0x42e0
movq %rax, -0x68(%rbp)
jmp 0x16df3
movq -0x68(%rbp), %rdi
leaq 0xc756(%rip), %rsi      # 0x23554
callq 0x4310
movq %rax, -0x70(%rbp)
jmp 0x16e09
movq -0x70(%rbp), %rdi
movq 0x1519c(%rip), %rsi     # 0x2bfb0
callq 0x4350
jmp 0x16e1b
movl $0x2, %edi
callq 0x4400
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x16f37
movq -0x10(%rbp), %rdi
callq 0x4130
movq %rax, -0x20(%rbp)
movq 0x1519b(%rip), %rdi     # 0x2bff0
leaq 0xcd3f(%rip), %rsi      # 0x23b9b
callq 0x4310
movq %rax, -0x78(%rbp)
jmp 0x16e67
movq -0x78(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq $0x218, %rsi            # imm = 0x218
callq 0x42e0
movq %rax, -0x80(%rbp)
jmp 0x16e81
movq -0x80(%rbp), %rdi
leaq 0xcb59(%rip), %rsi      # 0x239e5
callq 0x4310
movq %rax, -0x88(%rbp)
jmp 0x16e9a
movq -0x20(%rbp), %rdi
callq 0x1ee90
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x1eeb0
jmp 0x16eb1
movq -0x88(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x42e0
movq %rax, -0x90(%rbp)
jmp 0x16eca
movq -0x90(%rbp), %rdi
movq 0x150f0(%rip), %rsi     # 0x2bfc8
callq 0x4350
jmp 0x16edf
leaq -0x40(%rbp), %rdi
callq 0x46d8
leaq 0xc90b(%rip), %rdi      # 0x237fa
callq 0x42a0
jmp 0x16ef6
movl $0x1, %edi
callq 0x4400
jmp 0x16f2e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x16f25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x46d8
callq 0x4580
jmp 0x16f2c
jmp 0x16f37
addq $0x90, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x4610
movq %rax, %rdi
callq 0x82c0
nopl (%rax,%rax)
// File: tonymugen[P]sampleSNPs/varfiles.cpp
// Function: sampFiles::GtxtFileO::open()
void GtxtFileO::open(){
    try {
        _varFile.open(_fileName.c_str(), ios::out);
		if (!_varFile.is_open()) {
			cerr << "ERROR: failed to open file " << _fileName << " for output" << endl;
			exit(2);
		}

    } catch (system_error &error) {
        cerr << "ERROR: cannot open text file " << _fileName << " for output: " << error.code().message() << flush;
        perror(" ");
        exit(1);

    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
addq $0x218, %rdi            # imm = 0x218
callq 0x4140
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movl $0x10, %edx
callq 0x42f0
jmp 0x18bb1
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
callq 0x45e0
movb %al, -0x51(%rbp)
jmp 0x18bc3
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x18d10
jmp 0x18bd0
movq 0x13419(%rip), %rdi     # 0x2bff0
leaq 0xa95a(%rip), %rsi      # 0x23538
callq 0x4310
movq %rax, -0x60(%rbp)
jmp 0x18be9
movq -0x60(%rbp), %rdi
movq -0x50(%rbp), %rsi
addq $0x218, %rsi            # imm = 0x218
callq 0x42e0
movq %rax, -0x68(%rbp)
jmp 0x18c03
movq -0x68(%rbp), %rdi
leaq 0xaabc(%rip), %rsi      # 0x236ca
callq 0x4310
movq %rax, -0x70(%rbp)
jmp 0x18c19
movq -0x70(%rbp), %rdi
movq 0x1338c(%rip), %rsi     # 0x2bfb0
callq 0x4350
jmp 0x18c2b
movl $0x2, %edi
callq 0x4400
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x18d47
movq -0x10(%rbp), %rdi
callq 0x4130
movq %rax, -0x20(%rbp)
movq 0x1338b(%rip), %rdi     # 0x2bff0
leaq 0xaf2f(%rip), %rsi      # 0x23b9b
callq 0x4310
movq %rax, -0x78(%rbp)
jmp 0x18c77
movq -0x78(%rbp), %rdi
movq -0x50(%rbp), %rsi
addq $0x218, %rsi            # imm = 0x218
callq 0x42e0
movq %rax, -0x80(%rbp)
jmp 0x18c91
movq -0x80(%rbp), %rdi
leaq 0xaa3a(%rip), %rsi      # 0x236d6
callq 0x4310
movq %rax, -0x88(%rbp)
jmp 0x18caa
movq -0x20(%rbp), %rdi
callq 0x1ee90
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x1eeb0
jmp 0x18cc1
movq -0x88(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x42e0
movq %rax, -0x90(%rbp)
jmp 0x18cda
movq -0x90(%rbp), %rdi
movq 0x132e0(%rip), %rsi     # 0x2bfc8
callq 0x4350
jmp 0x18cef
leaq -0x40(%rbp), %rdi
callq 0x46d8
leaq 0xaafb(%rip), %rdi      # 0x237fa
callq 0x42a0
jmp 0x18d06
movl $0x1, %edi
callq 0x4400
jmp 0x18d3e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x18d35
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x46d8
callq 0x4580
jmp 0x18d3c
jmp 0x18d47
addq $0x90, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x4610
movq %rax, %rdi
callq 0x82c0
nopl (%rax,%rax)
// File: tonymugen[P]sampleSNPs/varfiles.cpp
// Function: sampFiles::TpedFile::close()
void TpedFile::close(){
    if (_varFile.is_open()) {
        _varFile.close();
    }
    if (_tfamFile.is_open()) {
        _tfamFile.close();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x8, %rdi
callq 0x45e0
testb $0x1, %al
jne 0x18e13
jmp 0x18e20
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x4060
movq -0x10(%rbp), %rdi
addq $0x240, %rdi            # imm = 0x240
callq 0x45e0
testb $0x1, %al
jne 0x18e36
jmp 0x18e46
movq -0x10(%rbp), %rdi
addq $0x240, %rdi            # imm = 0x240
callq 0x4060
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: tonymugen[P]sampleSNPs/varfiles.cpp
// Function: sampFiles::VcfFileI::open()
void VcfFileI::open(){
    if (_varFile.is_open()) {
        _varFile.close();
    }
    try {
		_varFile.open(_fileName.c_str(), ios::in);
		if (!_varFile.is_open()) {
			cerr << "ERROR: failed to open .vcf file " << _fileName << " for input" << endl;
			exit(2);
		}

	} catch (system_error &error) {
		cerr << "ERROR: cannot open VCF file " << _fileName << " for input: " << error.code().message() << flush;
		perror(" ");
		exit(1);

	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x8, %rdi
callq 0x45e0
testb $0x1, %al
jne 0x1c536
jmp 0x1c543
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x4060
movq -0x48(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x50(%rbp)
addq $0x218, %rdi            # imm = 0x218
callq 0x4140
movq -0x50(%rbp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x42f0
jmp 0x1c571
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x45e0
movb %al, -0x51(%rbp)
jmp 0x1c583
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x1c6d0
jmp 0x1c590
movq 0xfa59(%rip), %rdi      # 0x2bff0
leaq 0x77e2(%rip), %rsi      # 0x23d80
callq 0x4310
movq %rax, -0x60(%rbp)
jmp 0x1c5a9
movq -0x60(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq $0x218, %rsi            # imm = 0x218
callq 0x42e0
movq %rax, -0x68(%rbp)
jmp 0x1c5c3
movq -0x68(%rbp), %rdi
leaq 0x6f86(%rip), %rsi      # 0x23554
callq 0x4310
movq %rax, -0x70(%rbp)
jmp 0x1c5d9
movq -0x70(%rbp), %rdi
movq 0xf9cc(%rip), %rsi      # 0x2bfb0
callq 0x4350
jmp 0x1c5eb
movl $0x2, %edi
callq 0x4400
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1c707
movq -0x10(%rbp), %rdi
callq 0x4130
movq %rax, -0x20(%rbp)
movq 0xf9cb(%rip), %rdi      # 0x2bff0
leaq 0x77cf(%rip), %rsi      # 0x23dfb
callq 0x4310
movq %rax, -0x78(%rbp)
jmp 0x1c637
movq -0x78(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq $0x218, %rsi            # imm = 0x218
callq 0x42e0
movq %rax, -0x80(%rbp)
jmp 0x1c651
movq -0x80(%rbp), %rdi
leaq 0x7389(%rip), %rsi      # 0x239e5
callq 0x4310
movq %rax, -0x88(%rbp)
jmp 0x1c66a
movq -0x20(%rbp), %rdi
callq 0x1ee90
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x1eeb0
jmp 0x1c681
movq -0x88(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x42e0
movq %rax, -0x90(%rbp)
jmp 0x1c69a
movq -0x90(%rbp), %rdi
movq 0xf920(%rip), %rsi      # 0x2bfc8
callq 0x4350
jmp 0x1c6af
leaq -0x40(%rbp), %rdi
callq 0x46d8
leaq 0x713b(%rip), %rdi      # 0x237fa
callq 0x42a0
jmp 0x1c6c6
movl $0x1, %edi
callq 0x4400
jmp 0x1c6fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x1c6f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x46d8
callq 0x4580
jmp 0x1c6fc
jmp 0x1c707
addq $0x90, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x4610
movq %rax, %rdi
callq 0x82c0
nopl (%rax,%rax)
// File: tonymugen[P]sampleSNPs/varfiles.cpp
// Function: sampFiles::VcfFileO::open()
void VcfFileO::open(){
    if (_varFile.is_open()) {
        _varFile.close();
    }
    try {
		_varFile.open(_fileName.c_str(), ios::out);
		if (!_varFile.is_open()) {
			cerr << "ERROR: failed to open .vcf file " << _fileName << " for output" << endl;
			exit(2);
		}

	} catch (system_error &error) {
		cerr << "ERROR: cannot open VCF file " << _fileName << " for output: " << error.code().message() << flush;
		perror(" ");
		exit(1);

	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x8, %rdi
callq 0x45e0
testb $0x1, %al
jne 0x1d526
jmp 0x1d533
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x4060
movq -0x48(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x50(%rbp)
addq $0x218, %rdi            # imm = 0x218
callq 0x4140
movq -0x50(%rbp), %rdi
movq %rax, %rsi
movl $0x10, %edx
callq 0x42f0
jmp 0x1d561
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x45e0
movb %al, -0x51(%rbp)
jmp 0x1d573
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x1d6c0
jmp 0x1d580
movq 0xea69(%rip), %rdi      # 0x2bff0
leaq 0x67f2(%rip), %rsi      # 0x23d80
callq 0x4310
movq %rax, -0x60(%rbp)
jmp 0x1d599
movq -0x60(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq $0x218, %rsi            # imm = 0x218
callq 0x42e0
movq %rax, -0x68(%rbp)
jmp 0x1d5b3
movq -0x68(%rbp), %rdi
leaq 0x610c(%rip), %rsi      # 0x236ca
callq 0x4310
movq %rax, -0x70(%rbp)
jmp 0x1d5c9
movq -0x70(%rbp), %rdi
movq 0xe9dc(%rip), %rsi      # 0x2bfb0
callq 0x4350
jmp 0x1d5db
movl $0x2, %edi
callq 0x4400
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1d6f7
movq -0x10(%rbp), %rdi
callq 0x4130
movq %rax, -0x20(%rbp)
movq 0xe9db(%rip), %rdi      # 0x2bff0
leaq 0x67df(%rip), %rsi      # 0x23dfb
callq 0x4310
movq %rax, -0x78(%rbp)
jmp 0x1d627
movq -0x78(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq $0x218, %rsi            # imm = 0x218
callq 0x42e0
movq %rax, -0x80(%rbp)
jmp 0x1d641
movq -0x80(%rbp), %rdi
leaq 0x608a(%rip), %rsi      # 0x236d6
callq 0x4310
movq %rax, -0x88(%rbp)
jmp 0x1d65a
movq -0x20(%rbp), %rdi
callq 0x1ee90
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x1eeb0
jmp 0x1d671
movq -0x88(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x42e0
movq %rax, -0x90(%rbp)
jmp 0x1d68a
movq -0x90(%rbp), %rdi
movq 0xe930(%rip), %rsi      # 0x2bfc8
callq 0x4350
jmp 0x1d69f
leaq -0x40(%rbp), %rdi
callq 0x46d8
leaq 0x614b(%rip), %rdi      # 0x237fa
callq 0x42a0
jmp 0x1d6b6
movl $0x1, %edi
callq 0x4400
jmp 0x1d6ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x1d6e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x46d8
callq 0x4580
jmp 0x1d6ec
jmp 0x1d6f7
addq $0x90, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x4610
movq %rax, %rdi
callq 0x82c0
nopl (%rax,%rax)
// File: tonymugen[P]sampleSNPs/varfiles.cpp
// Function: sampFiles::HmpFileI::open()
void HmpFileI::open(){
    if (_varFile.is_open()) {
        _varFile.close();
    }
    try {
		_varFile.open(_fileName.c_str(), ios::in);
		if (!_varFile.is_open()) {
			cerr << "ERROR: failed to open HMP file " << _fileName << " for input" << endl;
			exit(2);
		}

	} catch (system_error &error) {
		cerr << "ERROR: cannot open HMP file " << _fileName << " for input: " << error.code().message() << flush;
		perror(" ");
		exit(1);
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x8, %rdi
callq 0x45e0
testb $0x1, %al
jne 0x1da26
jmp 0x1da33
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x4060
movq -0x48(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x50(%rbp)
addq $0x218, %rdi            # imm = 0x218
callq 0x4140
movq -0x50(%rbp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x42f0
jmp 0x1da61
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x45e0
movb %al, -0x51(%rbp)
jmp 0x1da73
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x1dbc0
jmp 0x1da80
movq 0xe569(%rip), %rdi      # 0x2bff0
leaq 0x63c8(%rip), %rsi      # 0x23e56
callq 0x4310
movq %rax, -0x60(%rbp)
jmp 0x1da99
movq -0x60(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq $0x218, %rsi            # imm = 0x218
callq 0x42e0
movq %rax, -0x68(%rbp)
jmp 0x1dab3
movq -0x68(%rbp), %rdi
leaq 0x5a96(%rip), %rsi      # 0x23554
callq 0x4310
movq %rax, -0x70(%rbp)
jmp 0x1dac9
movq -0x70(%rbp), %rdi
movq 0xe4dc(%rip), %rsi      # 0x2bfb0
callq 0x4350
jmp 0x1dadb
movl $0x2, %edi
callq 0x4400
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1dbf7
movq -0x10(%rbp), %rdi
callq 0x4130
movq %rax, -0x20(%rbp)
movq 0xe4db(%rip), %rdi      # 0x2bff0
leaq 0x635a(%rip), %rsi      # 0x23e76
callq 0x4310
movq %rax, -0x78(%rbp)
jmp 0x1db27
movq -0x78(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq $0x218, %rsi            # imm = 0x218
callq 0x42e0
movq %rax, -0x80(%rbp)
jmp 0x1db41
movq -0x80(%rbp), %rdi
leaq 0x5e99(%rip), %rsi      # 0x239e5
callq 0x4310
movq %rax, -0x88(%rbp)
jmp 0x1db5a
movq -0x20(%rbp), %rdi
callq 0x1ee90
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x1eeb0
jmp 0x1db71
movq -0x88(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x42e0
movq %rax, -0x90(%rbp)
jmp 0x1db8a
movq -0x90(%rbp), %rdi
movq 0xe430(%rip), %rsi      # 0x2bfc8
callq 0x4350
jmp 0x1db9f
leaq -0x40(%rbp), %rdi
callq 0x46d8
leaq 0x5c4b(%rip), %rdi      # 0x237fa
callq 0x42a0
jmp 0x1dbb6
movl $0x1, %edi
callq 0x4400
jmp 0x1dbee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x1dbe5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x46d8
callq 0x4580
jmp 0x1dbec
jmp 0x1dbf7
addq $0x90, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x4610
movq %rax, %rdi
callq 0x82c0
nopl (%rax,%rax)
// File: tonymugen[P]sampleSNPs/varfiles.cpp
// Function: sampFiles::HmpFileO::open()
void HmpFileO::open(){
    if (_varFile.is_open()) {
        _varFile.close();
    }
    try {
		_varFile.open(_fileName.c_str(), ios::out);
		if (!_varFile.is_open()) {
			cerr << "ERROR: failed to open HMP file " << _fileName << " for output" << endl;
			exit(2);
		}

	} catch (system_error &error) {
		cerr << "ERROR: cannot open HMP file " << _fileName << " for output: " << error.code().message() << flush;
		perror(" ");
		exit(1);

	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x8, %rdi
callq 0x45e0
testb $0x1, %al
jne 0x1ec86
jmp 0x1ec93
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x4060
movq -0x48(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x50(%rbp)
addq $0x218, %rdi            # imm = 0x218
callq 0x4140
movq -0x50(%rbp), %rdi
movq %rax, %rsi
movl $0x10, %edx
callq 0x42f0
jmp 0x1ecc1
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x45e0
movb %al, -0x51(%rbp)
jmp 0x1ecd3
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x1ee20
jmp 0x1ece0
movq 0xd309(%rip), %rdi      # 0x2bff0
leaq 0x5168(%rip), %rsi      # 0x23e56
callq 0x4310
movq %rax, -0x60(%rbp)
jmp 0x1ecf9
movq -0x60(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq $0x218, %rsi            # imm = 0x218
callq 0x42e0
movq %rax, -0x68(%rbp)
jmp 0x1ed13
movq -0x68(%rbp), %rdi
leaq 0x49ac(%rip), %rsi      # 0x236ca
callq 0x4310
movq %rax, -0x70(%rbp)
jmp 0x1ed29
movq -0x70(%rbp), %rdi
movq 0xd27c(%rip), %rsi      # 0x2bfb0
callq 0x4350
jmp 0x1ed3b
movl $0x2, %edi
callq 0x4400
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1ee57
movq -0x10(%rbp), %rdi
callq 0x4130
movq %rax, -0x20(%rbp)
movq 0xd27b(%rip), %rdi      # 0x2bff0
leaq 0x50fa(%rip), %rsi      # 0x23e76
callq 0x4310
movq %rax, -0x78(%rbp)
jmp 0x1ed87
movq -0x78(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq $0x218, %rsi            # imm = 0x218
callq 0x42e0
movq %rax, -0x80(%rbp)
jmp 0x1eda1
movq -0x80(%rbp), %rdi
leaq 0x492a(%rip), %rsi      # 0x236d6
callq 0x4310
movq %rax, -0x88(%rbp)
jmp 0x1edba
movq -0x20(%rbp), %rdi
callq 0x1ee90
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x1eeb0
jmp 0x1edd1
movq -0x88(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x42e0
movq %rax, -0x90(%rbp)
jmp 0x1edea
movq -0x90(%rbp), %rdi
movq 0xd1d0(%rip), %rsi      # 0x2bfc8
callq 0x4350
jmp 0x1edff
leaq -0x40(%rbp), %rdi
callq 0x46d8
leaq 0x49eb(%rip), %rdi      # 0x237fa
callq 0x42a0
jmp 0x1ee16
movl $0x1, %edi
callq 0x4400
jmp 0x1ee4e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x1ee45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x46d8
callq 0x4580
jmp 0x1ee4c
jmp 0x1ee57
addq $0x90, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x4610
movq %rax, %rdi
callq 0x82c0
nopl (%rax,%rax)
// File: tonymugen[P]sampleSNPs/random.cpp
// Function: sampFiles::GenerateHR::ranInt()
volatile uint64_t GenerateHR::ranInt(){
	uint64_t rInt = 0;
	
	unsigned char ok  = '\0';
	string error;
	
	unsigned short keepTrying = 10; // number of tries before giving up
	while (keepTrying) {
		keepTrying--;
		
		asm volatile ("rdrand %0; setc %1"
					  : "=r" (rInt), "=qm" (ok)
					  :
					  : "cc"
					  );
		if (ok) {
			break;
		}
	}
	
	if (!ok) {
		error = "RDRAND_failed";
		throw error;
	}
	
	return rInt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x44d0
movw $0xa, -0x3a(%rbp)
cmpw $0x0, -0x3a(%rbp)
je 0x21fa0
movw -0x3a(%rbp), %ax
addw $-0x1, %ax
movw %ax, -0x3a(%rbp)
rdrandq %rax
setb -0x11(%rbp)
movq %rax, -0x10(%rbp)
cmpb $0x0, -0x11(%rbp)
je 0x21f9e
jmp 0x21fa0
jmp 0x21f77
cmpb $0x0, -0x11(%rbp)
jne 0x22002
leaq 0x2183(%rip), %rsi      # 0x24130
leaq -0x38(%rbp), %rdi
callq 0x44c0
jmp 0x21fb8
movl $0x20, %edi
callq 0x4180
movq %rax, %rdi
movq %rdi, -0x58(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x41d0
movq -0x58(%rbp), %rdi
leaq 0x98b3(%rip), %rsi      # 0x2b890
movq 0x9fd4(%rip), %rdx      # 0x2bfb8
callq 0x45c0
jmp 0x22026
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x46d8
jmp 0x2201d
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x46d8
movq -0x60(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4610
nopw %cs:(%rax,%rax)
// File: tonymugen[P]sampleSNPs/random.cpp
// Function: sampFiles::GenerateMT::GenerateMT()
GenerateMT::GenerateMT(){
	// start by using RDTSC to set the seed
	unsigned int lo = 0;
	unsigned int hi = 0;
	uint64_t seed   = 0;
	asm volatile ("rdtsc;"
				   : "=a" (lo), "=d" (hi)
	);
	seed = (static_cast<uint64_t>(hi)<<32)|lo;
	uint64_t f = 6364136223846793005ULL;
	_mt[0]     = seed;
	_mti       = 1;
	
	for (; _mti < _n; _mti++) {
		_mt[_mti] = (f * (_mt[_mti - 1]^(_mt[_mti - 1] >> 62)) + _mti);
	}
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x22c50
movq -0x28(%rbp), %rax
leaq 0x9c8c(%rip), %rcx      # 0x2bce0
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
rdtsc
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %ecx
shlq $0x20, %rcx
movl -0xc(%rbp), %edx
orq %rdx, %rcx
movq %rcx, -0x18(%rbp)
movabsq $0x5851f42d4c957f2d, %rcx # imm = 0x5851F42D4C957F2D
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq $0x1, 0x9c8(%rax)
movq -0x28(%rbp), %rax
cmpq $0x138, 0x9c8(%rax) # imm = 0x138
jae 0x22120
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdx
movq 0x9c8(%rax), %rcx
subq $0x1, %rcx
movq 0x8(%rax,%rcx,8), %rcx
movq 0x9c8(%rax), %rsi
subq $0x1, %rsi
movq 0x8(%rax,%rsi,8), %rsi
shrq $0x3e, %rsi
xorq %rsi, %rcx
imulq %rcx, %rdx
addq 0x9c8(%rax), %rdx
movq 0x9c8(%rax), %rcx
movq %rdx, 0x8(%rax,%rcx,8)
movq -0x28(%rbp), %rax
movq 0x9c8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x9c8(%rax)
jmp 0x220b1
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tonymugen[P]sampleSNPs/random.cpp
// Function: sampFiles::RanDraw::runifnz()
volatile double RanDraw::runifnz(){
	double rnz = 0.0;
	do {
		rnz = this->runif();
	} while (rnz == 0.0); // simply reject 0.0
	
	return rnz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x22cb0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x225ac
jp 0x225ac
jmp 0x2258c
movsd -0x10(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: DMLfor[P]TinyWebServer/./ServerHttps.hpp
// Function: WebServer::Server<boost::asio::ssl::stream<boost::asio::basic_stream_socket<boost::asio::ip::tcp, boost::asio::execution::any_executor<boost::asio::execution::context_as_t<boost::asio::execution_context&>, boost::asio::execution::detail::blocking::never_t<0>, boost::asio::execution::prefer_only<boost::asio::execution::detail::blocking::possibly_t<0>>, boost::asio::execution::prefer_only<boost::asio::execution::detail::outstanding_work::tracked_t<0>>, boost::asio::execution::prefer_only<boost::asio::execution::detail::outstanding_work::untracked_t<0>>, boost::asio::execution::prefer_only<boost::asio::execution::detail::relationship::fork_t<0>>, boost::asio::execution::prefer_only<boost::asio::execution::detail::relationship::continuation_t<0>>>>>>::accept()
void accept()
		{
			auto socket = std::make_shared<HTTPS>(m_io_service, context);

			acceptor.async_accept(
					(*socket).lowest_layer(),
					[this, socket](const boost::system::error_code &ec)
					{
						accept();
			
						if(!ec)
						{
							(*socket).async_handshake(boost::asio::ssl::stream_base::server,
								[this, socket](const boost::system::error_code &ec)
								{
									if(!ec) process_request_and_respond(socket);
								});
						}
					});
		}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rdx
movq %rdx, 0x8(%rsp)
movq %rdx, %rsi
addq $0x68, %rsi
addq $0x120, %rdx            # imm = 0x120
leaq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x220a0
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdi
addq $0x98, %rax
movq %rax, 0x18(%rsp)
callq 0x22180
movq %rax, %rdi
callq 0x221b0
movq %rax, 0x20(%rsp)
jmp 0x11f39
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x221c0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
xorl %eax, %eax
movl %eax, %ecx
leaq 0x28(%rsp), %rdx
callq 0x22120
jmp 0x11f6c
leaq 0x28(%rsp), %rdi
callq 0x221f0
leaq 0x50(%rsp), %rdi
callq 0x22210
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x11fad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x221f0
leaq 0x50(%rsp), %rdi
callq 0x22210
movq 0x48(%rsp), %rdi
callq 0xc900
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: JorisCaze[P]NASG-EOS_Calibration/src/calib_liq-vap.cpp
// Function: readLiqVapInput(double&, double&, double&)
void readLiqVapInput(double &p0, double &ro0, double &c0)
{
    ifstream strmRefStates("input/refState.txt");
    string line("");
    if (strmRefStates) {
        for (int i=1; i<5; i++) {getline(strmRefStates,line);}
        p0 = stod(line);
        getline(strmRefStates,line); getline(strmRefStates,line);
        ro0 = stod(line);
        getline(strmRefStates,line); getline(strmRefStates,line);
        c0 = stod(line);
    }
    else {
        cout << "Error : reading refState.txt file\n"; exit(0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x5b52(%rip), %rsi      # 0x8070
leaq -0x220(%rbp), %rdi
movl $0x8, %edx
callq 0x2310
leaq -0x241(%rbp), %rdi
movq %rdi, -0x260(%rbp)
callq 0x22e0
movq -0x260(%rbp), %rdx
leaq 0x5c01(%rip), %rsi      # 0x8151
leaq -0x240(%rbp), %rdi
callq 0x4000
jmp 0x255e
leaq -0x241(%rbp), %rdi
callq 0x21d0
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x2230
movb %al, -0x261(%rbp)
jmp 0x258a
movb -0x261(%rbp), %al
testb $0x1, %al
jne 0x2599
jmp 0x26ee
movl $0x1, -0x258(%rbp)
cmpl $0x5, -0x258(%rbp)
jge 0x261a
leaq -0x220(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x2050
jmp 0x25c1
jmp 0x25c3
movl -0x258(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x258(%rbp)
jmp 0x25a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x250(%rbp)
movl %eax, -0x254(%rbp)
leaq -0x241(%rbp), %rdi
callq 0x21d0
jmp 0x272b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x250(%rbp)
movl %eax, -0x254(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x20e0
jmp 0x272b
xorl %eax, %eax
movl %eax, %esi
leaq -0x240(%rbp), %rdi
callq 0x40b0
movsd %xmm0, -0x270(%rbp)
jmp 0x2634
movsd -0x270(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
leaq -0x220(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x2050
jmp 0x2659
leaq -0x220(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x2050
jmp 0x266e
xorl %eax, %eax
movl %eax, %esi
leaq -0x240(%rbp), %rdi
callq 0x40b0
movsd %xmm0, -0x278(%rbp)
jmp 0x2688
movsd -0x278(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
leaq -0x220(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x2050
jmp 0x26ad
leaq -0x220(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x2050
jmp 0x26c2
xorl %eax, %eax
movl %eax, %esi
leaq -0x240(%rbp), %rdi
callq 0x40b0
movsd %xmm0, -0x280(%rbp)
jmp 0x26dc
movsd -0x280(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x270a
movq 0x88e3(%rip), %rdi      # 0xafd8
leaq 0x5987(%rip), %rsi      # 0x8083
callq 0x2180
jmp 0x2703
xorl %edi, %edi
callq 0x2210
leaq -0x240(%rbp), %rdi
callq 0x20e0
leaq -0x220(%rbp), %rdi
callq 0x2060
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
leaq -0x220(%rbp), %rdi
callq 0x2060
movq -0x250(%rbp), %rdi
callq 0x22d0
nopw %cs:(%rax,%rax)
// File: JorisCaze[P]NASG-EOS_Calibration/src/calib_liq-vap.cpp
// Function: computecpG(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&)
double computecpG(vector<double> const& hGexp, vector<double> const& ThGexp)
{
    // Purpose : compute heat capacity at constant pressure of vapor phase with LSM
    // More : the exp. data hG(T) is used
    // See eq. (50)
    double mHg, mThg, num(0.), den(0.);
    mHg = meanValue(hGexp);
    mThg = meanValue(ThGexp);
    for (unsigned int i = 0; i < hGexp.size(); i++) {
        num += ThGexp[i]*(hGexp[i]-mHg);
        den += ThGexp[i]*(ThGexp[i]-mThg);
    }
    return num/den;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x74d0
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x74d0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40f0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x284b
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd -0x50(%rbp), %xmm0
movsd (%rax), %xmm2
subsd -0x18(%rbp), %xmm2
movsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd -0x48(%rbp), %xmm0
movsd (%rax), %xmm2
subsd -0x20(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2793
movsd -0x28(%rbp), %xmm0
divsd -0x30(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: JorisCaze[P]NASG-EOS_Calibration/src/calib_liq-vap.cpp
// Function: computecvG(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, double)
double computecvG(vector<double> const& vGexp, vector<double> const& Texp, vector<double> const& psatExp, double cpG)
{
    // Purpose : commpute heat capacity at constant volum of vapor phase with LSM
    // More : vGexp, Texp and psatExp are concording experimental points
    // See eq. (55)
    double num(0.), den(0.);
    for (unsigned int i = 0; i < Texp.size(); i++) {
        num += vGexp[i]*(Texp[i]/psatExp[i]);
        den += (Texp[i]/psatExp[i])*(Texp[i]/psatExp[i]);
    }
    return (cpG - num/den);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40f0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x2a02
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd (%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd (%rax), %xmm0
movsd %xmm0, -0x68(%rbp)
movq -0x18(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd -0x68(%rbp), %xmm2
movsd -0x60(%rbp), %xmm0
divsd (%rax), %xmm2
movsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd (%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x18(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd -0x58(%rbp), %xmm0
divsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x18(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd -0x50(%rbp), %xmm2
movsd -0x48(%rbp), %xmm0
divsd (%rax), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2900
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
divsd -0x30(%rbp), %xmm1
subsd %xmm1, %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: JorisCaze[P]NASG-EOS_Calibration/src/calib_liq-vap.cpp
// Function: computeMeanTp(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, double)
double computeMeanTp(vector<double> const& psatExp, vector<double> const& Texp, double pinfL)
{
    // Purpose : compute the mean value seen in (64) and (65)
    double mtp(0.);
    for (unsigned int i = 0; i < Texp.size(); i++) {
        mtp += Texp[i]/(psatExp[i]+pinfL);  
    }
    mtp /= Texp.size(); 
    return mtp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40f0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x2dcc
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd -0x38(%rbp), %xmm0
movsd (%rax), %xmm1
addsd -0x18(%rbp), %xmm1
divsd %xmm1, %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2d64
movq -0x10(%rbp), %rdi
callq 0x40f0
movq %rax, %xmm1
movaps 0x522f(%rip), %xmm0     # 0x8010
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movapd 0x5233(%rip), %xmm0     # 0x8020
subpd %xmm0, %xmm1
movaps %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: JorisCaze[P]NASG-EOS_Calibration/src/calib_liq-vap.cpp
// Function: computeMeanTp2(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, double)
double computeMeanTp2(vector<double> const& psatExp, vector<double> const& Texp, double pinfL)
{
    // Purpose : compute a variation of the mean value seen in (64) and (65)
    double mtp(0.);
    for (unsigned int i = 0; i < Texp.size(); i++) {
        mtp += Texp[i]/((psatExp[i]+pinfL)*(psatExp[i]+pinfL));  
    }
    mtp /= Texp.size(); 
    return mtp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40f0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x2ed4
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd (%rax), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd -0x40(%rbp), %xmm1
movsd -0x38(%rbp), %xmm0
movsd (%rax), %xmm2
addsd -0x18(%rbp), %xmm2
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2e44
movq -0x10(%rbp), %rdi
callq 0x40f0
movq %rax, %xmm1
movaps 0x5127(%rip), %xmm0     # 0x8010
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movapd 0x512b(%rip), %xmm0     # 0x8020
subpd %xmm0, %xmm1
movaps %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: JorisCaze[P]NASG-EOS_Calibration/src/calib_liq-vap.cpp
// Function: computeHeatCapDiffL(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, double, double, double)
double computeHeatCapDiffL(vector<double> const& psatExp, vector<double> const& Texp, vector<double> const& vLexp, double mvL, double mTp, double pinfL)
{
    // Purpose : compute heat capacity cpL - cvL of liquid phase for pinfL iterative process with LSM 
    // More : this fn is also used to solve eq. (68) with Newton-Raphson 
    // Details : input values m'x' are the mean of the corresponding vector 'x'
    // See eq. (64)  
    double num(0.), den(0.), bf(0.);
    for (unsigned int i = 0; i < Texp.size(); i++) {
        bf = Texp[i]/(psatExp[i]+pinfL);
        num += bf*(vLexp[i]-mvL);
        den += bf*(bf-mTp);
    }
    return num/den;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40f0
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x3025
movq -0x10(%rbp), %rdi
movl -0x4c(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd (%rax), %xmm0
movsd %xmm0, -0x68(%rbp)
movq -0x8(%rbp), %rdi
movl -0x4c(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd -0x68(%rbp), %xmm0
movsd (%rax), %xmm1
addsd -0x30(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x18(%rbp), %rdi
movl -0x4c(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd -0x60(%rbp), %xmm0
movsd (%rax), %xmm2
subsd -0x20(%rbp), %xmm2
movsd -0x38(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x48(%rbp), %xmm0
movsd -0x48(%rbp), %xmm2
subsd -0x28(%rbp), %xmm2
movsd -0x40(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x2f62
movsd -0x38(%rbp), %xmm0
divsd -0x40(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: JorisCaze[P]NASG-EOS_Calibration/src/calib_liq-vap.cpp
// Function: computeCpL(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, double, double, double, double)
double computeCpL(vector<double> const& Texp, vector<double> const& hLexp, vector<double> const& psatExp, double mhL, double mp, double mT, double bL)
{
    // Purpose : compute heat cap. liquid phase at p = cst with LSM
    // More : this fn is used to solve eq. (68) with Newton-Raphson 
    // Details : input values m'x' are the mean of the corresponding vector 'x'
    // See eq. (60)
    double num1(0.), num2(0.), num(0.), den(0.);
    for (unsigned int i = 0; i < Texp.size(); i++) {
        num1 += Texp[i]*(hLexp[i]-mhL);
        num2 += Texp[i]*(psatExp[i]-mp);
        den += Texp[i]*(Texp[i]-mT);
    }
    num = num1 - bL*num2; 
    return num/den;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movsd %xmm3, -0x38(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x50(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x58(%rbp)
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40f0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x34ef
movq -0x8(%rbp), %rdi
movl -0x5c(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd (%rax), %xmm0
movsd %xmm0, -0x80(%rbp)
movq -0x10(%rbp), %rdi
movl -0x5c(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd -0x80(%rbp), %xmm0
movsd (%rax), %xmm2
subsd -0x20(%rbp), %xmm2
movsd -0x40(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movl -0x5c(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd (%rax), %xmm0
movsd %xmm0, -0x78(%rbp)
movq -0x18(%rbp), %rdi
movl -0x5c(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd -0x78(%rbp), %xmm0
movsd (%rax), %xmm2
subsd -0x28(%rbp), %xmm2
movsd -0x48(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movl -0x5c(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd (%rax), %xmm0
movsd %xmm0, -0x70(%rbp)
movq -0x8(%rbp), %rdi
movl -0x5c(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd -0x70(%rbp), %xmm0
movsd (%rax), %xmm2
subsd -0x30(%rbp), %xmm2
movsd -0x58(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x33f2
movsd -0x40(%rbp), %xmm1
movsd -0x38(%rbp), %xmm0
movsd -0x48(%rbp), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
divsd -0x58(%rbp), %xmm0
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: JorisCaze[P]NASG-EOS_Calibration/src/calib_liq-vap.cpp
// Function: computeDcpL(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, double, double, double)
double computeDcpL(vector<double> const& Texp, vector<double> const& psatExp, double mp, double mT, double dbL)
{
    // Purpose : compute pinfL derivative fn of computeCpL() for computePinfL Newton-Raphson process
    double s1(0.), s2(0.);
    for (unsigned int i = 0; i < Texp.size(); i++) {
        s1 += Texp[i]*(psatExp[i]-mp);
        s2 += Texp[i]*(Texp[i]-mT);
    }
    return -dbL*(s1/s2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40f0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x362e
movq -0x8(%rbp), %rdi
movl -0x3c(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd (%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movl -0x3c(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd -0x58(%rbp), %xmm0
movsd (%rax), %xmm2
subsd -0x18(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0x3c(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movl -0x3c(%rbp), %eax
movl %eax, %esi
callq 0x4110
movsd -0x50(%rbp), %xmm0
movsd (%rax), %xmm2
subsd -0x20(%rbp), %xmm2
movsd -0x38(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x3576
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd -0x30(%rbp), %xmm1
divsd -0x38(%rbp), %xmm1
mulsd %xmm1, %xmm0
addq $0x60, %rsp
popq %rbp
retq
nop