LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
addq $0x8, %rdi
movq 0x218(%rbx), %rsi
movl $0x10, %edx
callq 0x4270
leaq 0x88(%rbx), %rdi
callq 0x40a0
testb %al, %al
je 0x123b7
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq 0xdc32(%rip), %rdi      # 0x1fff0
leaq 0x618b(%rip), %rsi      # 0x18550
movl $0x1b, %edx
callq 0x42f0
movq 0x218(%rbx), %rsi
movq 0x220(%rbx), %rdx
movq 0xdc0c(%rip), %rdi      # 0x1fff0
callq 0x42f0
movq %rax, %r14
leaq 0x62ef(%rip), %rsi      # 0x186e2
movl $0xb, %edx
movq %rax, %rdi
callq 0x42f0
movq %r14, %rdi
callq 0x4130
movl $0x2, %edi
callq 0x4320
movq %rax, %r14
cmpl $0x1, %edx
jne 0x124d3
movq %r14, %rdi
callq 0x4110
movq %rax, %r14
movq 0xdbc0(%rip), %rdi      # 0x1fff0
leaq 0x677c(%rip), %rsi      # 0x18bb3
movl $0x1d, %edx
callq 0x42f0
movq 0x218(%rbx), %rsi
movq 0x220(%rbx), %rdx
movq 0xdb9a(%rip), %rdi      # 0x1fff0
callq 0x42f0
movq %rax, %rbx
leaq 0x6289(%rip), %rsi      # 0x186ee
movl $0xd, %edx
movq %rax, %rdi
callq 0x42f0
movq 0x18(%r14), %rsi
movl 0x10(%r14), %edx
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x20(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x42f0
movq %rax, %rdi
callq 0x41b0
leaq 0x8(%rsp), %rdi
callq 0x4919
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x124ce
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42d0
jmp 0x124ce
jmp 0x124cb
movq %rax, %r14
callq 0x4480
movq %r14, %rdi
callq 0x44e0
movq %rax, %rdi
callq 0x76d8
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
addq $0x88, %rdi
callq 0x40a0
testb %al, %al
je 0x1256f
leaq 0x8(%rbx), %rdi
callq 0x4060
leaq 0x2c0(%rbx), %rdi
callq 0x40a0
testb %al, %al
je 0x1258f
addq $0x240, %rbx            # imm = 0x240
movq %rbx, %rdi
popq %rbx
jmp 0x4060
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
leaq 0x88(%rdi), %r14
movq %r14, %rdi
callq 0x40a0
testb %al, %al
je 0x14a49
movq %r15, %rdi
callq 0x4060
movq 0x218(%rbx), %rsi
movq %r15, %rdi
movl $0x8, %edx
callq 0x4270
movq %r14, %rdi
callq 0x40a0
testb %al, %al
je 0x14a73
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0xb576(%rip), %rdi      # 0x1fff0
leaq 0x4317(%rip), %rsi      # 0x18d98
movl $0x20, %edx
callq 0x42f0
movq 0x218(%rbx), %rsi
movq 0x220(%rbx), %rdx
movq 0xb550(%rip), %rdi      # 0x1fff0
callq 0x42f0
movq %rax, %r14
leaq 0x3abd(%rip), %rsi      # 0x1856c
movl $0xa, %edx
movq %rax, %rdi
callq 0x42f0
movq %r14, %rdi
callq 0x4130
movl $0x2, %edi
callq 0x4320
movq %rax, %r14
cmpl $0x1, %edx
jne 0x14b8a
movq %r14, %rdi
callq 0x4110
movq %rax, %r14
movq 0xb504(%rip), %rdi      # 0x1fff0
leaq 0x4320(%rip), %rsi      # 0x18e13
movl $0x1c, %edx
callq 0x42f0
movq 0x218(%rbx), %rsi
movq 0x220(%rbx), %rdx
movq 0xb4de(%rip), %rdi      # 0x1fff0
callq 0x42f0
movq %rax, %rbx
leaq 0x3edc(%rip), %rsi      # 0x189fd
movl $0xc, %edx
movq %rax, %rdi
callq 0x42f0
movq 0x18(%r14), %rsi
movl 0x10(%r14), %edx
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x20(%rax)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x42f0
movq %rax, %rdi
callq 0x41b0
movq %rsp, %rdi
callq 0x4ad3
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14b85
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42d0
jmp 0x14b85
jmp 0x14b82
movq %rax, %r14
callq 0x4480
movq %r14, %rdi
callq 0x44e0
movq %rax, %rdi
callq 0x76d8
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
leaq 0x88(%rdi), %r14
movq %r14, %rdi
callq 0x40a0
testb %al, %al
je 0x15587
movq %r15, %rdi
callq 0x4060
movq 0x218(%rbx), %rsi
movq %r15, %rdi
movl $0x10, %edx
callq 0x4270
movq %r14, %rdi
callq 0x40a0
testb %al, %al
je 0x155b1
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0xaa38(%rip), %rdi      # 0x1fff0
leaq 0x37d9(%rip), %rsi      # 0x18d98
movl $0x20, %edx
callq 0x42f0
movq 0x218(%rbx), %rsi
movq 0x220(%rbx), %rdx
movq 0xaa12(%rip), %rdi      # 0x1fff0
callq 0x42f0
movq %rax, %r14
leaq 0x30f5(%rip), %rsi      # 0x186e2
movl $0xb, %edx
movq %rax, %rdi
callq 0x42f0
movq %r14, %rdi
callq 0x4130
movl $0x2, %edi
callq 0x4320
movq %rax, %r14
cmpl $0x1, %edx
jne 0x156c8
movq %r14, %rdi
callq 0x4110
movq %rax, %r14
movq 0xa9c6(%rip), %rdi      # 0x1fff0
leaq 0x37e2(%rip), %rsi      # 0x18e13
movl $0x1c, %edx
callq 0x42f0
movq 0x218(%rbx), %rsi
movq 0x220(%rbx), %rdx
movq 0xa9a0(%rip), %rdi      # 0x1fff0
callq 0x42f0
movq %rax, %rbx
leaq 0x308f(%rip), %rsi      # 0x186ee
movl $0xd, %edx
movq %rax, %rdi
callq 0x42f0
movq 0x18(%r14), %rsi
movl 0x10(%r14), %edx
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x20(%rax)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x42f0
movq %rax, %rdi
callq 0x41b0
movq %rsp, %rdi
callq 0x4b21
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x156c3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42d0
jmp 0x156c3
jmp 0x156c0
movq %rax, %r14
callq 0x4480
movq %r14, %rdi
callq 0x44e0
movq %rax, %rdi
callq 0x76d8
// File: /workspace/github_cpp_makefile_star2_O3/tonymugen[P]sampleSNPs/varfiles.cpp
// Function: sampFiles::HmpFileI::HmpFileI(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
HmpFileI::HmpFileI(const string &fileName) : HmpFile(fileName) {
    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);

    }
    char buf[3];
    _varFile.read(buf, 3);
    if ( (buf[0] == 'r') && (buf[1] == 's') && (buf[2] == '#') ) {
        _head = true;
    }
    _varFile.close();

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x75e4
leaq 0xa20c(%rip), %rax      # 0x1f920
movq %rax, (%rbx)
leaq 0x8(%rbx), %r14
leaq 0x88(%rbx), %r15
movq %r15, %rdi
callq 0x40a0
testb %al, %al
je 0x15736
movq %r14, %rdi
callq 0x4060
movq 0x218(%rbx), %rsi
movq %r14, %rdi
movl $0x8, %edx
callq 0x4270
movq %r15, %rdi
callq 0x40a0
testb %al, %al
je 0x15793
movq %rsp, %rsi
movl $0x3, %edx
movq %r14, %rdi
callq 0x4350
cmpb $0x72, (%rsp)
jne 0x15781
cmpb $0x73, 0x1(%rsp)
jne 0x15781
cmpb $0x23, 0x2(%rsp)
jne 0x15781
movb $0x1, 0x238(%rbx)
movq %r14, %rdi
callq 0x4060
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0xa856(%rip), %rdi      # 0x1fff0
leaq 0x36cd(%rip), %rsi      # 0x18e6e
movl $0x1f, %edx
callq 0x42f0
movq 0x218(%rbx), %rsi
movq 0x220(%rbx), %rdx
movq 0xa830(%rip), %rdi      # 0x1fff0
callq 0x42f0
movq %rax, %r14
leaq 0x2d9d(%rip), %rsi      # 0x1856c
movl $0xa, %edx
movq %rax, %rdi
callq 0x42f0
movq %r14, %rdi
callq 0x4130
movl $0x2, %edi
callq 0x4320
jmp 0x158b9
movq %rax, %r14
cmpl $0x1, %edx
jne 0x158bc
movq %r14, %rdi
callq 0x4110
movq %rax, %r14
movq 0xa7df(%rip), %rdi      # 0x1fff0
leaq 0x3676(%rip), %rsi      # 0x18e8e
movl $0x1c, %edx
callq 0x42f0
movq 0x218(%rbx), %rsi
movq 0x220(%rbx), %rdx
movq 0xa7b9(%rip), %rdi      # 0x1fff0
callq 0x42f0
movq %rax, %r15
leaq 0x31b7(%rip), %rsi      # 0x189fd
movl $0xc, %edx
movq %rax, %rdi
callq 0x42f0
movq 0x18(%r14), %rsi
movl 0x10(%r14), %edx
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x20(%rax)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r15, %rdi
callq 0x42f0
movq %rax, %rdi
callq 0x41b0
movq %rsp, %rdi
callq 0x4b3b
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x158aa
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42d0
jmp 0x158aa
jmp 0x158a7
movq %rax, %r14
callq 0x4480
jmp 0x158bc
movq %rax, %rdi
callq 0x76d8
movq %rax, %r14
movq %rbx, %rdi
callq 0x7480
movq %r14, %rdi
callq 0x44e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
leaq 0x88(%rdi), %r14
movq %r14, %rdi
callq 0x40a0
testb %al, %al
je 0x158f7
movq %r15, %rdi
callq 0x4060
movq 0x218(%rbx), %rsi
movq %r15, %rdi
movl $0x8, %edx
callq 0x4270
movq %r14, %rdi
callq 0x40a0
testb %al, %al
je 0x15921
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0xa6c8(%rip), %rdi      # 0x1fff0
leaq 0x353f(%rip), %rsi      # 0x18e6e
movl $0x1f, %edx
callq 0x42f0
movq 0x218(%rbx), %rsi
movq 0x220(%rbx), %rdx
movq 0xa6a2(%rip), %rdi      # 0x1fff0
callq 0x42f0
movq %rax, %r14
leaq 0x2c0f(%rip), %rsi      # 0x1856c
movl $0xa, %edx
movq %rax, %rdi
callq 0x42f0
movq %r14, %rdi
callq 0x4130
movl $0x2, %edi
callq 0x4320
movq %rax, %r14
cmpl $0x1, %edx
jne 0x15a38
movq %r14, %rdi
callq 0x4110
movq %rax, %r14
movq 0xa656(%rip), %rdi      # 0x1fff0
leaq 0x34ed(%rip), %rsi      # 0x18e8e
movl $0x1c, %edx
callq 0x42f0
movq 0x218(%rbx), %rsi
movq 0x220(%rbx), %rdx
movq 0xa630(%rip), %rdi      # 0x1fff0
callq 0x42f0
movq %rax, %rbx
leaq 0x302e(%rip), %rsi      # 0x189fd
movl $0xc, %edx
movq %rax, %rdi
callq 0x42f0
movq 0x18(%r14), %rsi
movl 0x10(%r14), %edx
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x20(%rax)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x42f0
movq %rax, %rdi
callq 0x41b0
movq %rsp, %rdi
callq 0x4b55
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15a33
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42d0
jmp 0x15a33
jmp 0x15a30
movq %rax, %r14
callq 0x4480
movq %r14, %rdi
callq 0x44e0
movq %rax, %rdi
callq 0x76d8
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
leaq 0x88(%rdi), %r14
movq %r14, %rdi
callq 0x40a0
testb %al, %al
je 0x16665
movq %r15, %rdi
callq 0x4060
movq 0x218(%rbx), %rsi
movq %r15, %rdi
movl $0x10, %edx
callq 0x4270
movq %r14, %rdi
callq 0x40a0
testb %al, %al
je 0x1668f
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x995a(%rip), %rdi      # 0x1fff0
leaq 0x27d1(%rip), %rsi      # 0x18e6e
movl $0x1f, %edx
callq 0x42f0
movq 0x218(%rbx), %rsi
movq 0x220(%rbx), %rdx
movq 0x9934(%rip), %rdi      # 0x1fff0
callq 0x42f0
movq %rax, %r14
leaq 0x2017(%rip), %rsi      # 0x186e2
movl $0xb, %edx
movq %rax, %rdi
callq 0x42f0
movq %r14, %rdi
callq 0x4130
movl $0x2, %edi
callq 0x4320
movq %rax, %r14
cmpl $0x1, %edx
jne 0x167a6
movq %r14, %rdi
callq 0x4110
movq %rax, %r14
movq 0x98e8(%rip), %rdi      # 0x1fff0
leaq 0x277f(%rip), %rsi      # 0x18e8e
movl $0x1c, %edx
callq 0x42f0
movq 0x218(%rbx), %rsi
movq 0x220(%rbx), %rdx
movq 0x98c2(%rip), %rdi      # 0x1fff0
callq 0x42f0
movq %rax, %rbx
leaq 0x1fb1(%rip), %rsi      # 0x186ee
movl $0xd, %edx
movq %rax, %rdi
callq 0x42f0
movq 0x18(%r14), %rsi
movl 0x10(%r14), %edx
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x20(%rax)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x42f0
movq %rax, %rdi
callq 0x41b0
movq %rsp, %rdi
callq 0x4bbd
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x167a1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42d0
jmp 0x167a1
jmp 0x1679e
movq %rax, %r14
callq 0x4480
movq %r14, %rdi
callq 0x44e0
movq %rax, %rdi
callq 0x76d8
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x28, %rsp
xorl %eax, %eax
movb %al, 0x7(%rsp)
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb %al, (%r14)
movw $0xfff7, %ax            # imm = 0xFFF7
rdrandq %rbx
setb 0x7(%rsp)
movb 0x7(%rsp), %cl
testb %cl, %cl
jne 0x1705c
leal 0x1(%rax), %edx
testw %ax, %ax
movl %edx, %eax
jne 0x17041
testb %cl, %cl
je 0x17082
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x17077
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x20bf(%rip), %rsi      # 0x19148
leaq 0x8(%rsp), %rdi
callq 0x43b0
movl $0x20, %edi
callq 0x4140
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rdx
cmpq %r14, %rdx
jne 0x170b7
movups (%r14), %xmm0
movups %xmm0, (%rcx)
jmp 0x170c3
movq %rdx, (%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq %r14, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
leaq 0x87da(%rip), %rsi      # 0x1f8c0
movq 0x8ed3(%rip), %rdx      # 0x1ffc0
movq %rax, %rdi
callq 0x44b0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x1710f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x44e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/tonymugen[P]sampleSNPs/random.cpp
// Function: sampFiles::GenerateMT::ranInt()
volatile uint64_t GenerateMT::ranInt(){
	
	if (_mti == _n) { // do we need to re-run the twister?
		size_t i = 0;
		for (; i < _n - _m; i++) { // first _m words
			_x     = (_mt[i]&_um)|(_mt[i + 1]&_lm);
			_mt[i] = _mt[i + _m]^(_x>>1)^_alt[static_cast<size_t>(_x&1ULL)];
		}
		for (; i < _n - 1; i++) { // rest, except for the last element
			_x     = (_mt[i]&_um)|(_mt[i+1]&_lm);
			_mt[i] = _mt[i + (_m - _n)] ^ (_x>>1)^_alt[static_cast<size_t>(_x&1ULL)];
		}
		// now set the last element
		_x          = (_mt[_n - 1]&_um)|(_mt[0]&_lm);
		_mt[_n - 1] = _mt[_m - 1]^(_x>>1)^_alt[static_cast<size_t>(_x&1ULL)];
		
		_mti = 0;

	}
	// extract pseudo-random number
	_x = _mt[_mti++];
	
	_x ^= ((_x>>_u)&_d);
	_x ^= ((_x<<_s)&_b);
	_x ^= ((_x<<_t)&_c);
	_x ^= (_x>>_l);
	
	return _x;
}

// Assembly:
movq 0x9c8(%rdi), %rax
cmpq $0x138, %rax            # imm = 0x138
jne 0x1727f
movq $-0x9c, %rcx
movq $-0x80000000, %rdx      # imm = 0x80000000
leaq 0x2008(%rip), %rax      # 0x191b0
movq 0x4e8(%rdi,%rcx,8), %rsi
movl %esi, %r8d
andl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
movq 0x4f0(%rdi,%rcx,8), %r9
andq %rdx, %r9
orq %r8, %r9
movq %r9, 0x9d0(%rdi)
shrq %r9
xorq 0x9c8(%rdi,%rcx,8), %r9
andl $0x1, %esi
xorq (%rax,%rsi,8), %r9
movq %r9, 0x4e8(%rdi,%rcx,8)
incq %rcx
jne 0x171a8
xorl %ecx, %ecx
movq $-0x80000000, %rdx      # imm = 0x80000000
movq 0x4e8(%rdi,%rcx,8), %rsi
movl %esi, %r8d
andl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
movq 0x4f0(%rdi,%rcx,8), %r9
andq %rdx, %r9
orq %r8, %r9
movq %r9, 0x9d0(%rdi)
shrq %r9
xorq 0x8(%rdi,%rcx,8), %r9
andl $0x1, %esi
xorq (%rax,%rsi,8), %r9
movq %r9, 0x4e8(%rdi,%rcx,8)
incq %rcx
cmpq $0x9b, %rcx
jne 0x171f7
movq 0x9c0(%rdi), %rcx
movl %ecx, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movq $-0x80000000, %rsi      # imm = 0x80000000
andq 0x8(%rdi), %rsi
orq %rdx, %rsi
movq %rsi, 0x9d0(%rdi)
shrq %rsi
xorq 0x4e0(%rdi), %rsi
andl $0x1, %ecx
xorq (%rax,%rcx,8), %rsi
movq %rsi, 0x9c0(%rdi)
xorl %eax, %eax
leaq 0x1(%rax), %rcx
movq %rcx, 0x9c8(%rdi)
movq 0x8(%rdi,%rax,8), %rax
movq %rax, %rcx
shrq $0x1d, %rcx
movabsq $0x555555555, %rdx      # imm = 0x555555555
andq %rcx, %rdx
xorq %rax, %rdx
movq %rdx, %rax
shlq $0x11, %rax
movabsq $0x71d67fffeda60000, %rcx # imm = 0x71D67FFFEDA60000
andq %rax, %rcx
xorq %rdx, %rcx
movl %ecx, %edx
andl $0x7ffbf77, %edx        # imm = 0x7FFBF77
shlq $0x25, %rdx
xorq %rcx, %rdx
movq %rdx, %rax
shrq $0x2b, %rax
xorq %rdx, %rax
movq %rax, 0x9d0(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/tonymugen[P]sampleSNPs/random.cpp
// Function: sampFiles::RanDraw::RanDraw()
RanDraw::RanDraw(){
	string error;
	
	unsigned int eax;
	unsigned int ebx;
	unsigned int ecx;
	unsigned int edx;
	
	unsigned int leaf    = 0;
	unsigned int subleaf = 0;
	
	// first look at vendor info
	asm volatile ("cpuid;"
				  : "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx)
				  : "a" (leaf), "c" (subleaf)
				  );
	
	if ( !(
		(memcmp(reinterpret_cast<char*>(&ebx), "Genu", 4) && memcmp(reinterpret_cast<char*>(&edx), "ineI", 4) && memcmp(reinterpret_cast<char*>(&ecx), "ntel", 4)) ||
		(memcmp(reinterpret_cast<char*>(&ebx), "Auth", 4) && memcmp(reinterpret_cast<char*>(&edx), "enti", 4) && memcmp(reinterpret_cast<char*>(&ecx), "cAMD", 4))
		)) {
		error = "CPU_unsupported";
		throw error;
	}
	
	
	// now test for RDRAND. bit 30 of ECX when CPUINFO invoked with EAX set to 01H
	leaf = 0x1;
	asm volatile ("cpuid;"
				  : "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx)
				  : "a" (leaf), "c" (subleaf)
				  );
	
	if ( (ecx & 0x40000000) == 0x40000000) { // bit mask 0x40000000 for the 30th bit
		_rng = new GenerateHR(); // have hardware random numbers
	} else {
		_rng = new GenerateMT(); // use MT
	}

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
xorl %eax, %eax
xorl %ecx, %ecx
cpuid
cmpl $0x756e6547, %ebx       # imm = 0x756E6547
sete %al
cmpl $0x49656e69, %edx       # imm = 0x49656E69
sete %sil
orb %al, %sil
cmpl $0x6c65746e, %ecx       # imm = 0x6C65746E
sete %al
orb %sil, %al
cmpb $0x1, %al
jne 0x17343
cmpl $0x68747541, %ebx       # imm = 0x68747541
je 0x173a3
cmpl $0x69746e65, %edx       # imm = 0x69746E65
je 0x173a3
cmpl $0x444d4163, %ecx       # imm = 0x444D4163
je 0x173a3
movl $0x1, %eax
xorl %ecx, %ecx
cpuid
btl $0x1e, %ecx
jb 0x17369
movl $0x9d8, %edi            # imm = 0x9D8
callq 0x42c0
movq %rax, %rbx
movq %rax, %rdi
callq 0x17118
jmp 0x17380
movl $0x8, %edi
callq 0x42c0
movq %rax, %rbx
leaq 0x89cb(%rip), %rax      # 0x1fd48
movq %rax, (%rbx)
movq %rbx, (%r14)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x17399
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42d0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1dac(%rip), %rsi      # 0x19156
movq %rsp, %rdi
callq 0x43b0
movl $0x20, %edi
callq 0x4140
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq (%rsp), %rdx
cmpq %r15, %rdx
jne 0x173d5
movups (%r15), %xmm0
movups %xmm0, (%rcx)
jmp 0x173e1
movq %rdx, (%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq %r15, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
leaq 0x84bd(%rip), %rsi      # 0x1f8c0
movq 0x8bb6(%rip), %rdx      # 0x1ffc0
movq %rax, %rdi
callq 0x44b0
movq %rax, %r14
movl $0x9d8, %esi            # imm = 0x9D8
movq %rbx, %rdi
callq 0x42d0
jmp 0x17427
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1743d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %r14, %rdi
callq 0x44e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %xmm1
punpckldq 0x1040(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x1048(%rip), %xmm1     # 0x184b0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x1cac(%rip), %xmm0     # 0x19128
ucomisd 0x10c4(%rip), %xmm0     # 0x18548
jne 0x17488
jnp 0x1744a
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/tonymugen[P]sampleSNPs/random.cpp
// Function: sampFiles::RanDraw::vitterA(double const&, double const&)
volatile uint64_t RanDraw::vitterA(const double &n, const double &N){
	// The notation follows Vitter's (1987) as closely as possible
	// Note that my runif() is on [0,1] (Vitter assumes (0,1)), so I have to sometimes adjust accordingly
	uint64_t S  = 0;
	double top  = N - n;
	double quot = top/N;
	double v;
	
	// some trivial conditions first
	if ( (n == 0) || (n > N) ) {
		return S;
	} else if (n == 1) {
		do {
			S = static_cast<uint64_t>(floor(N * this->runif()));
			
		} while (S == static_cast<uint64_t>(N)); // s == N would be a problem because it would overshoot the end of the array/file (in base-0 space); effectively sampling [0,1) uniform to prevent this
		return S;
	}
	// [0,1) uniform
	do {
		v = this->runif();
	} while (v == 1.0); // i.e. only repeat if v == 1.0
	
	double Nloc = N;
	while (quot > v) {
		S++;
		top--;
		Nloc--;
		quot = quot*top/Nloc;
	}
	
	return S;
}

// Assembly:
movsd (%rsi), %xmm0
xorl %eax, %eax
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x174a0
jnp 0x175fc
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movsd (%rdx), %xmm2
ucomisd %xmm2, %xmm0
ja 0x175f5
movq %rdi, %r14
ucomisd 0x101d(%rip), %xmm0     # 0x184e0
jne 0x17564
jp 0x17564
movapd %xmm2, (%rsp)
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %xmm1
punpckldq 0xfb6(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0xfbe(%rip), %xmm1      # 0x184b0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x1c22(%rip), %xmm0     # 0x19128
mulsd (%rsp), %xmm0
callq 0x4490
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
movsd 0x1c14(%rip), %xmm1     # 0x19138
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
andq %rdx, %rax
movsd (%rbx), %xmm2
movapd %xmm2, %xmm0
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rdx
orq %rcx, %rax
cvttsd2si %xmm2, %rcx
movq %rcx, %rsi
sarq $0x3f, %rsi
andq %rdx, %rsi
orq %rcx, %rsi
cmpq %rsi, %rax
je 0x174cf
jmp 0x175f5
movapd %xmm2, %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
divsd %xmm2, %xmm1
movsd %xmm1, (%rsp)
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %xmm1
punpckldq 0xf0f(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0xf17(%rip), %xmm1      # 0x184b0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x1b7b(%rip), %xmm0     # 0x19128
ucomisd 0xf2b(%rip), %xmm0      # 0x184e0
jne 0x175b9
jnp 0x1757b
movsd (%rsp), %xmm4
ucomisd %xmm0, %xmm4
jbe 0x175f3
movsd (%rbx), %xmm1
xorl %eax, %eax
movsd 0x1b5e(%rip), %xmm2     # 0x19130
movsd 0x10(%rsp), %xmm3
incq %rax
addsd %xmm2, %xmm3
addsd %xmm2, %xmm1
mulsd %xmm3, %xmm4
divsd %xmm1, %xmm4
ucomisd %xmm0, %xmm4
ja 0x175d8
jmp 0x175f5
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x68(%rdi), %rcx
leaq 0x120(%rdi), %r8
leaq 0x10(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x8(%rsp), %r14
leaq 0x18(%rsp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x12e0a
movq (%r14), %rdx
movq 0x8(%r14), %rax
movq %rbx, (%r15)
movq %rdx, 0x8(%r15)
movq %rax, 0x10(%r15)
testq %rax, %rax
je 0xcd45
movq 0x3d279(%rip), %rcx     # 0x49fb0
cmpb $0x0, (%rcx)
je 0xcd41
incl 0x8(%rax)
jmp 0xcd45
lock
incl 0x8(%rax)
movq 0x98(%rbx), %rdi
leaq 0xa0(%rbx), %rsi
addq $0xb8, %rbx
leaq 0x18(%rsp), %r8
xorl %ecx, %ecx
movq %rbx, %r9
callq 0x153fc
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xcd78
callq 0x1ce68
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xcd87
callq 0x1ce68
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xcda3
callq 0x1ce68
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xcdb2
callq 0x1ce68
movq %rbx, %rdi
callq 0xaa80
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5284
movapd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x5284
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
je 0x2770
sarq $0x3, %rcx
movq (%rbx), %rdx
unpcklpd (%rsp), %xmm0           # xmm0 = xmm0[0],mem[0]
xorpd %xmm1, %xmm1
xorl %esi, %esi
movsd (%rdx,%rsi,8), %xmm2
movapd %xmm2, %xmm3
movhpd (%rax,%rsi,8), %xmm3    # xmm3 = xmm3[0],mem[0]
subpd %xmm0, %xmm3
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
mulpd %xmm3, %xmm2
addpd %xmm2, %xmm1
incq %rsi
movl %esi, %edi
cmpq %rdi, %rcx
ja 0x273a
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
divsd %xmm1, %xmm0
jmp 0x2778
movsd 0x3890(%rip), %xmm0     # 0x6008
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/JorisCaze[P]NASG-EOS_Calibration/src/calib_liq-vap.cpp
// Function: computeQg(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, double)
double computeQg(vector<double> const& hGexp, vector<double> const& ThGexp, double cpG)
{
    // Purpose : compute formation energy of vapor phase 
    // See eq. (51)
    double mHg, mThg;
    mHg = meanValue(hGexp);
    mThg = meanValue(ThGexp);
    return (mHg-cpG*mThg);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
callq 0x5284
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x5284
mulsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
je 0x280d
sarq $0x3, %rcx
movq (%rdi), %rsi
movq (%rdx), %rdx
xorpd %xmm1, %xmm1
xorl %edi, %edi
movsd (%rax,%rdi,8), %xmm2
divsd (%rdx,%rdi,8), %xmm2
movapd %xmm2, %xmm3
movhpd (%rsi,%rdi,8), %xmm3    # xmm3 = xmm3[0],mem[0]
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
mulpd %xmm3, %xmm2
addpd %xmm2, %xmm1
incq %rdi
movl %edi, %r8d
cmpq %r8, %rcx
ja 0x27d5
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
divsd %xmm1, %xmm2
jmp 0x2815
movsd 0x37f3(%rip), %xmm2     # 0x6008
subsd %xmm2, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/JorisCaze[P]NASG-EOS_Calibration/src/calib_liq-vap.cpp
// Function: computeQprimG(std::vector<double, std::allocator<double>>, std::vector<double, std::allocator<double>>, double, double, double, double, double, double, double, double)
double computeQprimG(vector<double> p, vector<double> T, double cpL, double cpG, double cvL, double cvG, double qL, double qG, double pinfL, double bL)
{
    // Purpose : compute the vapor entropy constant qPrimG with LSM
    // See equation (72) 
    double A,B,C,D,E,sum(0.);
    B = (qL-qG)/(cpG-cvG);
    C = (cpG-cpL)/(cpG-cvG);
    D = (cpL-cvL)/(cpG-cvG);
    E = bL/(cpG-cvG);
    for (unsigned int i = 0; i < p.size(); i++) {
        sum += log(p[i])-(B+E*p[i])/T[i] - C*log(T[i]) - D*log(p[i]+pinfL);
    }
    A = sum/p.size();
    return (A*(cpG-cvG)+cpG-cpL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movsd %xmm7, (%rsp)
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movapd %xmm1, %xmm7
subsd %xmm3, %xmm7
subq %rax, %rcx
movsd %xmm0, 0x20(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd %xmm7, 0x10(%rsp)
je 0x2956
movq %rsi, %rbx
movq %rdi, %r14
subsd %xmm5, %xmm4
divsd %xmm7, %xmm4
movsd %xmm4, 0x30(%rsp)
movsd (%rsp), %xmm3
divsd %xmm7, %xmm3
movsd %xmm3, (%rsp)
movapd %xmm0, %xmm3
subsd %xmm2, %xmm3
subsd %xmm0, %xmm1
movapd 0x37c7(%rip), %xmm0     # 0x6050
xorpd %xmm0, %xmm1
divsd %xmm7, %xmm1
movapd %xmm1, 0x40(%rsp)
xorpd %xmm0, %xmm3
divsd %xmm7, %xmm3
movapd %xmm3, 0x50(%rsp)
xorpd %xmm1, %xmm1
movl $0x1, %ebp
xorl %r15d, %r15d
movsd %xmm6, 0x28(%rsp)
movsd %xmm1, 0x38(%rsp)
movsd (%rax,%r15,8), %xmm0
callq 0x20f0
movapd %xmm0, %xmm2
movq (%r14), %rax
movsd (%rax,%r15,8), %xmm1
mulsd (%rsp), %xmm1
addsd 0x30(%rsp), %xmm1
movq (%rbx), %rax
movsd (%rax,%r15,8), %xmm0
divsd %xmm0, %xmm1
subsd %xmm1, %xmm2
movsd %xmm2, 0x8(%rsp)
callq 0x20f0
mulsd 0x40(%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq (%r14), %rax
movsd (%rax,%r15,8), %xmm0
addsd 0x28(%rsp), %xmm0
callq 0x20f0
movsd 0x38(%rsp), %xmm1
mulsd 0x50(%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
addsd %xmm0, %xmm1
movl %ebp, %r15d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
incl %ebp
cmpq %r15, %rcx
ja 0x28b7
jmp 0x295e
sarq $0x3, %rcx
xorpd %xmm1, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
divsd %xmm0, %xmm1
mulsd 0x10(%rsp), %xmm1
addsd 0x18(%rsp), %xmm1
subsd 0x20(%rsp), %xmm1
movapd %xmm1, %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
movq %rdx, %rax
subq %rcx, %rax
sarq $0x3, %rax
cmpq %rcx, %rdx
je 0x29d1
movq (%rdi), %rdx
xorpd %xmm1, %xmm1
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm2
movsd (%rdx,%rsi,8), %xmm3
addsd %xmm0, %xmm3
divsd %xmm3, %xmm2
addsd %xmm2, %xmm1
incq %rsi
movl %esi, %edi
cmpq %rdi, %rax
ja 0x29af
jmp 0x29d5
xorpd %xmm1, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
movq %rdx, %rax
subq %rcx, %rax
sarq $0x3, %rax
cmpq %rcx, %rdx
je 0x2a2b
movq (%rdi), %rdx
xorpd %xmm1, %xmm1
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm2
movsd (%rdx,%rsi,8), %xmm3
addsd %xmm0, %xmm3
mulsd %xmm3, %xmm3
divsd %xmm3, %xmm2
addsd %xmm2, %xmm1
incq %rsi
movl %esi, %edi
cmpq %rdi, %rax
ja 0x2a05
jmp 0x2a2f
xorpd %xmm1, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
je 0x2aa3
sarq $0x3, %rcx
movq (%rdi), %rsi
movq (%rdx), %rdx
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
xorpd %xmm3, %xmm3
xorl %edi, %edi
movsd (%rax,%rdi,8), %xmm0
movsd (%rsi,%rdi,8), %xmm4
addsd %xmm2, %xmm4
divsd %xmm4, %xmm0
movapd %xmm0, %xmm4
movhpd (%rdx,%rdi,8), %xmm4    # xmm4 = xmm4[0],mem[0]
subpd %xmm1, %xmm4
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm4, %xmm0
addpd %xmm0, %xmm3
incq %rdi
movl %edi, %r8d
cmpq %r8, %rcx
ja 0x2a60
movapd %xmm3, %xmm0
unpckhpd %xmm3, %xmm0            # xmm0 = xmm0[1],xmm3[1]
divsd %xmm3, %xmm0
retq
movsd 0x355d(%rip), %xmm0     # 0x6008
retq
// File: /workspace/github_cpp_makefile_star2_O3/JorisCaze[P]NASG-EOS_Calibration/src/calib_liq-vap.cpp
// Function: computeDHeatCapDiffL(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 computeDHeatCapDiffL(vector<double> const& psatExp, vector<double> const& Texp, vector<double> const& vLexp, double mvL, double mTp, double mTp2, double pinfL)
{
    // Purpose : compute pinfL derivative of fn computeHeatCapDiffL() for computePinfL Newton-Raphson process
    double m1(0.), m2(0.), m3(0.), m4(0.), bf1(0.), bf2(0.);
    for (unsigned int i = 0; i < Texp.size(); i++) {
        bf1 = Texp[i]/(psatExp[i]+pinfL);
        bf2 = bf1/(psatExp[i]+pinfL);
        m1 += -bf2*(vLexp[i]*mvL);
        m2 += bf1*(bf1 - (1./Texp.size())*mTp);
        m3 += bf1*(vLexp[i]-mvL);
        m4 += -bf2*(bf1-mTp)+bf1*(bf2+mTp2);
    }
    return (m1*m2-m3*m4)/(m2*m2);
}

// Assembly:
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
je 0x2ba4
sarq $0x3, %rcx
movq (%rdi), %rsi
movq %rcx, %xmm4
punpckldq 0x3590(%rip), %xmm4 # xmm4 = xmm4[0],mem[0],xmm4[1],mem[1]
subpd 0x3598(%rip), %xmm4     # 0x6070
movq (%rdx), %rdx
movapd %xmm4, %xmm5
unpckhpd %xmm4, %xmm5            # xmm5 = xmm5[1],xmm4[1]
addsd %xmm4, %xmm5
movsd 0x3521(%rip), %xmm7     # 0x6010
divsd %xmm5, %xmm7
xorpd %xmm4, %xmm4
xorpd %xmm6, %xmm6
xorl %edi, %edi
movapd 0x354a(%rip), %xmm8     # 0x6050
mulsd %xmm1, %xmm7
xorpd %xmm5, %xmm5
movsd (%rax,%rdi,8), %xmm9
movsd (%rsi,%rdi,8), %xmm10
addsd %xmm3, %xmm10
divsd %xmm10, %xmm9
movapd %xmm9, %xmm11
divsd %xmm10, %xmm11
movsd (%rdx,%rdi,8), %xmm12
movapd %xmm12, %xmm10
mulsd %xmm0, %xmm10
movapd %xmm7, %xmm13
addsd %xmm9, %xmm13
unpcklpd %xmm9, %xmm10           # xmm10 = xmm10[0],xmm9[0]
subsd %xmm0, %xmm12
movapd %xmm11, %xmm14
mulsd %xmm9, %xmm12
addsd %xmm2, %xmm14
mulsd %xmm9, %xmm14
subsd %xmm1, %xmm9
mulsd %xmm11, %xmm9
xorpd %xmm8, %xmm11
unpcklpd %xmm13, %xmm11          # xmm11 = xmm11[0],xmm13[0]
mulpd %xmm11, %xmm10
addsd %xmm12, %xmm5
subsd %xmm9, %xmm14
addpd %xmm10, %xmm4
addsd %xmm14, %xmm6
incq %rdi
movl %edi, %r8d
cmpq %r8, %rcx
ja 0x2b0e
jmp 0x2bb0
xorpd %xmm4, %xmm4
xorpd %xmm5, %xmm5
xorpd %xmm6, %xmm6
mulsd %xmm6, %xmm5
movapd %xmm4, %xmm0
unpckhpd %xmm4, %xmm0            # xmm0 = xmm0[1],xmm4[1]
mulsd %xmm0, %xmm4
subsd %xmm5, %xmm4
mulsd %xmm0, %xmm0
divsd %xmm0, %xmm4
movapd %xmm4, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
je 0x2c4b
sarq $0x3, %rcx
movq (%rsi), %rsi
movq (%rdx), %rdx
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
xorpd %xmm1, %xmm1
xorpd %xmm4, %xmm4
xorl %edi, %edi
movsd (%rax,%rdi,8), %xmm5
movsd (%rsi,%rdi,8), %xmm6
movhpd (%rdx,%rdi,8), %xmm6    # xmm6 = xmm6[0],mem[0]
subpd %xmm0, %xmm6
movapd %xmm5, %xmm7
subsd %xmm2, %xmm7
mulsd %xmm5, %xmm7
unpcklpd %xmm5, %xmm5            # xmm5 = xmm5[0,0]
mulpd %xmm6, %xmm5
addpd %xmm5, %xmm1
addsd %xmm7, %xmm4
incq %rdi
movl %edi, %r8d
cmpq %r8, %rcx
ja 0x2c0f
jmp 0x2c53
xorpd %xmm1, %xmm1
xorpd %xmm4, %xmm4
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
mulsd %xmm0, %xmm3
subsd %xmm3, %xmm1
divsd %xmm4, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
je 0x2cbf
sarq $0x3, %rcx
movq (%rsi), %rdx
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
xorpd %xmm0, %xmm0
xorl %esi, %esi
movsd (%rax,%rsi,8), %xmm3
movapd %xmm3, %xmm4
movhpd (%rdx,%rsi,8), %xmm4    # xmm4 = xmm4[0],mem[0]
subpd %xmm1, %xmm4
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
mulpd %xmm4, %xmm3
addpd %xmm3, %xmm0
incq %rsi
movl %esi, %edi
cmpq %rdi, %rcx
ja 0x2c89
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
divsd %xmm0, %xmm1
jmp 0x2cc7
movsd 0x3341(%rip), %xmm1     # 0x6008
xorpd 0x3381(%rip), %xmm2     # 0x6050
mulsd %xmm1, %xmm2
movapd %xmm2, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/JorisCaze[P]NASG-EOS_Calibration/src/tools.cpp
// Function: meanValue(std::vector<double, std::allocator<double>>&)
double meanValue(vector<double> &tab)
{
    // Purpose : compute the mean value of a vector
    double buf(0.);
    for (unsigned int i = 0; i < tab.size(); i++) {
        buf += tab[i];
    }
    return (buf/tab.size());
}

// Assembly:
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq %rdx, %rax
subq %rcx, %rax
sarq $0x3, %rax
xorpd %xmm0, %xmm0
cmpq %rcx, %rdx
je 0x527a
xorl %edx, %edx
addsd (%rcx,%rdx,8), %xmm0
incq %rdx
movl %edx, %esi
cmpq %rsi, %rax
ja 0x526b
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/JorisCaze[P]NASG-EOS_Calibration/src/tools.cpp
// Function: meanValue(std::vector<double, std::allocator<double>> const&)
double meanValue(vector<double> const& tab)
{
    // Purpose : compute the mean value of a vector
    double buf(0.);
    for (unsigned int i = 0; i < tab.size(); i++) {
        buf += tab[i];
    }
    return (buf/tab.size());
}

// Assembly:
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq %rdx, %rax
subq %rcx, %rax
sarq $0x3, %rax
xorpd %xmm0, %xmm0
cmpq %rcx, %rdx
je 0x52af
xorl %edx, %edx
addsd (%rcx,%rdx,8), %xmm0
incq %rdx
movl %edx, %esi
cmpq %rsi, %rax
ja 0x52a0
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/JorisCaze[P]NASG-EOS_Calibration/src/tools.cpp
// Function: residual(std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&)
double residual(std::vector<double> &tabKnow, std::vector<double> &tabEstimated)
{
    // Purpose : compute the residual of an Ordinary Lest Squares (OLS) procedure
    // Linear fn y=f(x) - vector are y values
    double scr(0.), sct(0.);
    if (tabKnow.size() == tabEstimated.size()) {
        for (unsigned int i = 0; i < tabKnow.size(); i++) {
        scr += (tabKnow[i]-tabEstimated[i])*(tabKnow[i]-tabEstimated[i]);
        sct += (tabKnow[i]-meanValue(tabKnow))*(tabKnow[i]-meanValue(tabKnow)); 
        }
    }
    else {
        cout << "Error : residual can not be computed due to different vector size\n";
    }
    return (1.-(scr/sct));
}

// Assembly:
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rdi
movq %rdi, %rcx
subq %rax, %rcx
movq (%rsi), %rdx
movq 0x8(%rsi), %rsi
subq %rdx, %rsi
cmpq %rsi, %rcx
jne 0x5365
cmpq %rax, %rdi
je 0x537d
sarq $0x3, %rcx
cvtsi2sd %rcx, %xmm2
xorpd %xmm0, %xmm0
xorl %esi, %esi
xorpd %xmm1, %xmm1
movapd %xmm1, %xmm4
movsd (%rax,%rsi,8), %xmm3
movapd %xmm3, %xmm1
subsd (%rdx,%rsi,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm4, %xmm1
xorl %edi, %edi
xorpd %xmm4, %xmm4
addsd (%rax,%rdi,8), %xmm4
incq %rdi
movl %edi, %r8d
cmpq %r8, %rcx
ja 0x5316
divsd %xmm2, %xmm4
xorpd %xmm5, %xmm5
xorl %edi, %edi
addsd (%rax,%rdi,8), %xmm5
incq %rdi
movl %edi, %r8d
cmpq %r8, %rcx
ja 0x5330
movapd %xmm3, %xmm6
subsd %xmm4, %xmm6
divsd %xmm2, %xmm5
subsd %xmm5, %xmm3
mulsd %xmm6, %xmm3
addsd %xmm3, %xmm0
incl %esi
cmpq %rsi, %rcx
ja 0x52f6
divsd %xmm0, %xmm1
jmp 0x5385
movq 0x3c6c(%rip), %rdi      # 0x8fd8
leaq 0x122d(%rip), %rsi      # 0x65a0
movl $0x42, %edx
callq 0x2180
movsd 0xc83(%rip), %xmm1      # 0x6008
movsd 0xc93(%rip), %xmm0      # 0x6020
subsd %xmm1, %xmm0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/PeterDenton[P]Nu-Pert/src/Check.cpp
// Function: Check::l10(double)
double l10(double a)
{
	double c = cos(Hat::phi(a) - t13);
	double x = Hat::l0(a) + Hat::lm(a);
	double y = pow(Hat::l0(a) - Hat::lm(a), 2) + pow(2 * eps * c12 * s12 * Dmsqee * c, 2);
	return (x - sqrt(y)) / 2.;
}

// Assembly:
subq $0x28, %rsp
movsd %xmm0, 0x8(%rsp)
callq 0x6e4a
leaq 0xbd72(%rip), %rax      # 0xe318
subsd (%rax), %xmm0
callq 0x22c0
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x6e85
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x6bc5
addsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x6e85
movsd %xmm0, 0x18(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x6bc5
leaq 0x10b90(%rip), %rax     # 0x13190
movsd (%rax), %xmm1
addsd %xmm1, %xmm1
leaq 0xbce1(%rip), %rax      # 0xe2f0
mulsd (%rax), %xmm1
movsd 0x18(%rsp), %xmm2
subsd %xmm0, %xmm2
leaq 0xbcb4(%rip), %rax      # 0xe2d8
mulsd (%rax), %xmm1
mulsd %xmm2, %xmm2
leaq 0x10b55(%rip), %rax     # 0x13188
mulsd (%rax), %xmm1
mulsd 0x20(%rsp), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
sqrtsd %xmm1, %xmm1
movsd 0x10(%rsp), %xmm0
subsd %xmm1, %xmm0
mulsd 0xb9ad(%rip), %xmm0     # 0xe008
addq $0x28, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/PeterDenton[P]Nu-Pert/src/Check.cpp
// Function: Check::l2(double, int)
double l2(double a, int order)
{
	assert (order >= 0 && order <= 2); // order valid for 0, 1, 2
	double l2 = l20(a);
	if (order == 2)
		l2 += l22(a);
	return l2;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
cmpl $0x3, %edi
jae 0x2726
movl %edi, %ebx
movsd %xmm0, 0x8(%rsp)
callq 0x2745
cmpl $0x2, %ebx
jne 0x2720
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2814
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
leaq 0xb903(%rip), %rdi      # 0xe030
leaq 0xb915(%rip), %rsi      # 0xe049
leaq 0xb93a(%rip), %rcx      # 0xe075
movl $0x17, %edx
callq 0x20f0