LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/CDSKFile.cpp
// Function: CDSKTrack::GetDSKTrackSize()
int CDSKTrack::GetDSKTrackSize()
{
	if (!Formated)
		return 0;

	int trackSize = 0x100;
	for (int s=0 ; s<NbSector ; s++)
	{
		trackSize += Sectors[s].GetDataSize();
	}

	return trackSize;
}

// Assembly:
xorl %eax, %eax
cmpb $0x1, 0x19(%rdi)
jne 0x5e4c
movzbl 0x16(%rdi), %edx
movq 0x20(%rdi), %rsi
shll $0x5, %edx
movl $0x100, %eax            # imm = 0x100
xorl %edi, %edi
cmpq %rdi, %rdx
je 0x5e4c
movzwl 0x6(%rsi,%rdi), %r8d
movb 0x3(%rsi,%rdi), %cl
movl $0x80, %r9d
shll %cl, %r9d
testl %r8d, %r8d
cmovnel %r8d, %r9d
addl %r9d, %eax
addq $0x20, %rdi
jmp 0x5e24
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/CDSKFile.cpp
// Function: CDSKTrack::SameHeader(CDSKTrack const&) const
bool CDSKTrack::SameHeader(const CDSKTrack &track) const
{
	bool equal = true;
	equal = equal && (NbSector == track.NbSector);
	equal = equal && (SectorSize == track.SectorSize);
	equal = equal && (DataRate == track.DataRate);
	equal = equal && (RecordingMode == track.RecordingMode);
	equal = equal && (GAP3Size == track.GAP3Size);
	equal = equal && (FillByte == track.FillByte);

	if (!equal || NbSector == 0)
		return equal;

	unsigned char size = Sectors[0].SectorSize;
	set<unsigned char> sectorID;
	set<unsigned char> trackSectorID;
	for (int s=0 ; s<NbSector ; s++)
	{
		if (Sectors[s].SectorSize != size ||
			track.Sectors[s].SectorSize != size)
			return false;

		sectorID.insert(Sectors[s].SectorID);
		trackSectorID.insert(track.Sectors[s].SectorID);
	}
	if (sectorID.size() != trackSectorID.size())
		return false;

	set<unsigned char>::iterator sit = sectorID.begin();
	set<unsigned char>::iterator dit = trackSectorID.begin();
	for ( ; sit != sectorID.end() ; sit++, dit++)
	{
		if ((*sit) != (*dit))
			return false;
	}
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movb 0x16(%rsi), %al
xorl %ebp, %ebp
cmpb %al, 0x16(%rdi)
jne 0x6181
movq %rsi, %rbx
movq %rdi, %r14
movb 0x15(%rsi), %cl
cmpb %cl, 0x15(%rdi)
jne 0x6181
movb 0x13(%r14), %cl
cmpb 0x13(%rbx), %cl
jne 0x617f
movb 0x14(%r14), %cl
cmpb 0x14(%rbx), %cl
jne 0x617f
movb 0x17(%r14), %cl
cmpb 0x17(%rbx), %cl
jne 0x617f
movb 0x18(%r14), %cl
cmpb 0x18(%rbx), %cl
jne 0x617f
testb %al, %al
je 0x6192
movq 0x20(%r14), %rcx
movb 0x3(%rcx), %bpl
leaq 0x10(%rsp), %rcx
andl $0x0, (%rcx)
andq $0x0, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
andq $0x0, 0x20(%rcx)
leaq 0x40(%rsp), %rcx
andl $0x0, (%rcx)
andq $0x0, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
andq $0x0, 0x20(%rcx)
pushq $0x2
popq %r13
xorl %r15d, %r15d
leaq 0x38(%rsp), %r12
movzbl %al, %eax
cmpq %rax, %r15
jae 0x6197
movq 0x20(%r14), %rsi
cmpb %bpl, 0x1(%rsi,%r13)
jne 0x61dc
movq 0x20(%rbx), %rax
cmpb %bpl, 0x1(%rax,%r13)
jne 0x61dc
addq %r13, %rsi
leaq 0x8(%rsp), %rdi
callq 0x6e70
movq 0x20(%rbx), %rsi
addq %r13, %rsi
movq %r12, %rdi
callq 0x6e70
incq %r15
movb 0x16(%r14), %al
addq $0x20, %r13
jmp 0x6130
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %bpl
jmp 0x6181
movq 0x30(%rsp), %rax
cmpq 0x60(%rsp), %rax
jne 0x61dc
movq 0x20(%rsp), %rbx
movq 0x50(%rsp), %r14
leaq 0x10(%rsp), %r15
cmpq %r15, %rbx
sete %bpl
je 0x61de
movb 0x20(%rbx), %al
cmpb 0x20(%r14), %al
jne 0x61de
movq %rbx, %rdi
callq 0x32f0
movq %rax, %rbx
movq %r14, %rdi
callq 0x32f0
movq %rax, %r14
jmp 0x61b2
xorl %ebp, %ebp
leaq 0x38(%rsp), %rdi
callq 0x6e18
leaq 0x8(%rsp), %rdi
callq 0x6e18
jmp 0x6181
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x6e18
leaq 0x8(%rsp), %rdi
callq 0x6e18
movq %rbx, %rdi
callq 0xb830
nop
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/CDSKFile.cpp
// Function: CDSKFile::OpenDSKFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
CDSKFile* CDSKFile::OpenDSKFile(const std::string &filename)
{
	TOOLS_ASSERTMSG(	filename != "a:" && filename != "A:" && 
						filename != "b:" && filename != "B:", "Unable to dump real floppy");

	std::ifstream file(filename.c_str(), std::ios::binary);

	CDSKFile *dsk = NULL;

	char header[8];
	file.read(header, 8);
	file.seekg(0, std::ios::beg);

	if (strncmp("MV - CPC", header, 8) == 0)
	{
		dsk = new CStandardDSKFile();
		dsk->readDSK(file);
		file.close();
	}
	else
	{
		if (strncmp("EXTENDED", header, 8) == 0)
		{
			dsk = new CExtendedDSKFile();
			dsk->readDSK(file);
			file.close();
		}
	}
	return dsk;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x250, %rsp            # imm = 0x250
movq %rdi, %rbx
leaq 0x8640(%rip), %rsi      # 0xe869
callq 0x6dde
testb %al, %al
je 0x6347
leaq 0x862f(%rip), %rsi      # 0xe86c
movq %rbx, %rdi
callq 0x6dde
testb %al, %al
je 0x6347
leaq 0x861b(%rip), %rsi      # 0xe86f
movq %rbx, %rdi
callq 0x6dde
testb %al, %al
je 0x6347
leaq 0x8607(%rip), %rsi      # 0xe872
movq %rbx, %rdi
callq 0x6dde
testb %al, %al
je 0x6347
movq (%rbx), %rsi
leaq 0x48(%rsp), %rbx
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x3510
leaq 0x8(%rsp), %rsi
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x3350
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x33c0
movabsq $0x435043202d20564d, %rax # imm = 0x435043202D20564D
cmpq %rax, 0x8(%rsp)
je 0x62d2
movabsq $0x4445444e45545845, %rax # imm = 0x4445444E45545845
cmpq %rax, 0x8(%rsp)
je 0x6301
xorl %ebx, %ebx
jmp 0x632e
movl $0x120, %edi            # imm = 0x120
callq 0x3290
movq %rax, %rbx
movq %rax, %rdi
callq 0x6584
movq (%rbx), %rax
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
leaq 0x48(%rsp), %rdi
callq 0x3090
jmp 0x632e
movl $0x120, %edi            # imm = 0x120
callq 0x3290
movq %rax, %rbx
movq %rax, %rdi
callq 0x6902
movq (%rbx), %rax
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
leaq 0x48(%rsp), %rdi
callq 0x3090
leaq 0x48(%rsp), %rdi
callq 0x30b0
movq %rbx, %rax
addq $0x250, %rsp            # imm = 0x250
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0x33b0
leaq 0x851a(%rip), %rsi      # 0xe875
movq %rbx, %rdi
callq 0x3270
pushq $0x50
popq %rdi
callq 0x3140
movq %rax, %rbx
leaq 0x851b(%rip), %rsi      # 0xe890
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x3c9e
leaq 0x50(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x34a0
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rcx
movq %rbx, %rdi
movl $0x224, %edx            # imm = 0x224
callq 0x6fd4
leaq 0xd9e7(%rip), %rsi      # 0x13d98
leaq 0xc6a(%rip), %rdx       # 0x7022
movq %rbx, %rdi
callq 0x34d0
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x3578
xorl %ebp, %ebp
jmp 0x63d7
movq %rax, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0x3578
testb %bpl, %bpl
jne 0x63eb
jmp 0x63f8
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
jmp 0x63f8
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x30a0
jmp 0x6411
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x30b0
movq %r14, %rdi
callq 0xb830
nop
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/CDSKFile.cpp
// Function: CStandardDSKFile::readDSK(std::istream&)
bool CStandardDSKFile::readDSK(std::istream &str)
{
	_header.Read(str);

	if (_header.NbTrack == 0 && _header.NbSide == 0)
		return false;

	_tracks = new CDSKTrack[_header.NbTrack * _header.NbSide];

	unsigned int trackNum = 0;
	unsigned int trackOff = 0x100;
	for (int t=0 ; t<_header.NbTrack ; t++)
	{
		for (int s=0 ; s<_header.NbSide ; s++)
		{
			str.seekg(trackOff, std::ios::beg);

			_tracks[trackNum].Read(str);

			trackOff += _header.TrackSize;
			trackNum++;
		}
	}

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x10, %rdi
callq 0x4f70
movb 0x4a(%r14), %bpl
movb 0x4b(%r14), %r15b
movl %ebp, %eax
orb %r15b, %al
setne 0xb(%rsp)
je 0x6807
movzbl %bpl, %eax
movzbl %r15b, %r13d
imulq %rax, %r13
imulq $0x28, %r13, %r12
leaq 0x8(%r12), %rdi
callq 0x3030
movq %r13, (%rax)
leaq 0x8(%rax), %rcx
testq %r13, %r13
je 0x678f
addq $0x28, %rax
xorl %edx, %edx
movabsq $0x6e492d6b63617254, %rsi # imm = 0x6E492D6B63617254
movabsq $0xa0d6f666e492d, %rdi  # imm = 0xA0D6F666E492D
xorl %r8d, %r8d
andq $0x0, (%rax,%r8)
movb %dl, -0x7(%rax,%r8)
andq $0x0, -0xf(%rax,%r8)
movq %rsi, -0x20(%rax,%r8)
movq %rdi, -0x1b(%rax,%r8)
andw $0x0, -0x12(%rax,%r8)
movb %dl, -0x10(%rax,%r8)
addq $0x28, %r8
cmpq %r8, %r12
jne 0x6760
movq %rcx, 0x8(%r14)
movl $0x100, %r13d           # imm = 0x100
movq $0x0, 0x10(%rsp)
xorl %ecx, %ecx
movzbl %bpl, %eax
cmpl %eax, %ecx
jae 0x6807
movl %ecx, 0xc(%rsp)
xorl %ebp, %ebp
movq 0x10(%rsp), %rax
leal (%rax,%rbp), %r12d
movzbl %r15b, %eax
cmpl %eax, %ebp
jae 0x67f3
movl %r13d, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x33c0
movl %r12d, %eax
imulq $0x28, %rax, %rdi
addq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x59be
movzwl 0x4c(%r14), %eax
addl %eax, %r13d
incl %ebp
movb 0x4b(%r14), %r15b
jmp 0x67b2
movl 0xc(%rsp), %ecx
incl %ecx
movb 0x4a(%r14), %bpl
movl %r12d, %eax
movq %rax, 0x10(%rsp)
jmp 0x67a4
movb 0xb(%rsp), %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/CDSKFile.cpp
// Function: CStandardDSKFile::writeDSK(std::ostream&)
bool CStandardDSKFile::writeDSK(std::ostream &str)
{
	_header.Write(str);

	unsigned int trackNum = 0;
	unsigned int trackOff = 0x100;
	for (int t=0 ; t<_header.NbTrack ; t++)
	{
		for (int s=0 ; s<_header.NbSide ; s++)
		{
			int nbBlank = trackOff - str.tellp();
			if (nbBlank != 0)
			{
				unsigned char *buff = new unsigned char[nbBlank];
				memset(buff, 0, nbBlank);
				str.write((char*)buff, nbBlank);
				delete[] buff;
			}
			_tracks[trackNum].Write(str);

			trackOff += _header.TrackSize;
			trackNum++;
		}
	}

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r14
addq $0x10, %rdi
callq 0x4fe6
movl $0x100, %ebp            # imm = 0x100
xorl %ecx, %ecx
xorl %r12d, %r12d
movq %r14, 0x8(%rsp)
movzbl 0x4a(%r14), %eax
cmpl %eax, %ecx
jae 0x68e8
movl %ecx, 0x4(%rsp)
xorl %r13d, %r13d
movq %r12, 0x10(%rsp)
leal (%r12,%r13), %ebx
movzbl 0x4b(%r14), %eax
cmpl %eax, %r13d
jae 0x68da
movq %r15, %rdi
callq 0x3220
movl %ebp, %ecx
subl %eax, %ecx
je 0x68bc
movq %r15, %r14
movslq %ecx, %r15
movq %r15, %rdi
callq 0x3030
movq %rax, %r12
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x3170
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %r15
movq 0x8(%rsp), %r14
callq 0x3390
movq %r12, %rdi
movq 0x10(%rsp), %r12
callq 0x3380
movl %ebx, %eax
imulq $0x28, %rax, %rdi
addq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x5caa
movzwl 0x4c(%r14), %eax
addl %eax, %ebp
incl %r13d
jmp 0x685f
movl 0x4(%rsp), %ecx
incl %ecx
movl %ebx, %r12d
jmp 0x6846
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/CDSKFile.cpp
// Function: CExtendedDSKFile::readDSK(std::istream&)
bool CExtendedDSKFile::readDSK(std::istream &str)
{
	_header.Read(str);

	if (_header.NbTrack == 0 && _header.NbSide == 0)
		return false;

	_tracks = new CDSKTrack[_header.NbTrack * _header.NbSide];

	unsigned int trackOff = 0x100;
	for (int t=0 ; t<_header.NbTrack ; t++)
	{
		for (int s=0 ; s<_header.NbSide ; s++)
		{
			if (_header.TrackSizeTable[(t*_header.NbSide) + s] != 0)
			{
				str.seekg(trackOff, std::ios::beg);

				_tracks[(t*_header.NbSide) + s].Read(str);

				trackOff += _header.TrackSizeTable[(t*_header.NbSide) + s] << 8;
			}
		}
	}

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
addq $0x10, %rdi
movq %rsi, 0x20(%rsp)
callq 0x51b4
movb 0x4a(%rbx), %bpl
movq %rbx, 0x8(%rsp)
movb 0x4b(%rbx), %r15b
movl %ebp, %eax
orb %r15b, %al
setne 0x7(%rsp)
je 0x6bcc
movzbl %bpl, %eax
movzbl %r15b, %r12d
imulq %rax, %r12
imulq $0x28, %r12, %rbx
leaq 0x8(%rbx), %rdi
callq 0x3030
movq %r12, (%rax)
leaq 0x8(%rax), %rcx
testq %r12, %r12
je 0x6b13
addq $0x28, %rax
xorl %edx, %edx
movabsq $0x6e492d6b63617254, %rsi # imm = 0x6E492D6B63617254
movabsq $0xa0d6f666e492d, %rdi  # imm = 0xA0D6F666E492D
xorl %r8d, %r8d
andq $0x0, (%rax,%r8)
movb %dl, -0x7(%rax,%r8)
andq $0x0, -0xf(%rax,%r8)
movq %rsi, -0x20(%rax,%r8)
movq %rdi, -0x1b(%rax,%r8)
andw $0x0, -0x12(%rax,%r8)
movb %dl, -0x10(%rax,%r8)
addq $0x28, %r8
cmpq %r8, %rbx
jne 0x6ae4
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
leaq 0x4e(%rax), %rdx
movq $0x0, 0x10(%rsp)
movl $0x100, %esi            # imm = 0x100
xorl %r14d, %r14d
movq %rdx, 0x18(%rsp)
movq 0x8(%rsp), %r13
movzbl %bpl, %eax
cmpl %eax, %r14d
jae 0x6bcc
xorl %ebx, %ebx
movzbl %r15b, %eax
cmpl %eax, %ebx
jae 0x6bb6
imull %r14d, %eax
addl %ebx, %eax
cmpb $0x0, (%rdx,%rax)
je 0x6bb1
movl %esi, %ebp
movl %esi, %esi
movq 0x20(%rsp), %r15
movq %r15, %rdi
xorl %edx, %edx
callq 0x33c0
movzbl 0x4b(%r13), %eax
movq 0x10(%rsp), %r12
imulq %r12, %rax
addq %rbx, %rax
imulq $0x28, %rax, %rdi
addq 0x8(%r13), %rdi
movq %r15, %rsi
callq 0x59be
movl %ebp, %esi
movq 0x18(%rsp), %rdx
movzbl 0x4b(%r13), %r15d
movq %r15, %rax
imulq %r12, %rax
addq %rdx, %rax
movzbl (%rbx,%rax), %eax
shll $0x8, %eax
addl %eax, %esi
incq %rbx
jmp 0x6b4a
incl %r14d
movq 0x8(%rsp), %rax
movb 0x4a(%rax), %bpl
incq 0x10(%rsp)
jmp 0x6b3b
movb 0x7(%rsp), %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/CDSKFile.cpp
// Function: CExtendedDSKFile::writeDSK(std::ostream&)
bool CExtendedDSKFile::writeDSK(std::ostream &str)
{
	Update();
	
	_header.Write(str);

	int trackOff = str.tellp();
	for (int t=0 ; t<_header.NbTrack ; t++)
	{
		for (int s=0 ; s<_header.NbSide ; s++)
		{
			if (_header.TrackSizeTable[(t*_header.NbSide) + s] != 0)
			{
				int nbBlank = trackOff - str.tellp();
				if (nbBlank != 0)
				{
					unsigned char *buff = new unsigned char[nbBlank];
					memset(buff, 0, nbBlank);
					str.write((char*)buff, nbBlank);
					delete[] buff;
				}

				_tracks[(t*_header.NbSide) + s].Write(str);

				trackOff += (_header.TrackSizeTable[(t*_header.NbSide) + s]) << 8;
			}
		}
	}

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x10(%r14), %rdi
movq %r12, %rsi
callq 0x522a
movq %r12, %rdi
callq 0x3220
movq %rax, %r15
leaq 0x4e(%r14), %r13
xorl %ebx, %ebx
movq %r13, 0x8(%rsp)
movzbl 0x4a(%r14), %eax
cmpl %eax, %ebx
jae 0x6cec
movb 0x4b(%r14), %al
xorl %ebp, %ebp
movzbl %al, %ecx
cmpl %ecx, %ebp
jae 0x6ce4
imull %ebx, %ecx
addl %ebp, %ecx
cmpb $0x0, (%r13,%rcx)
je 0x6cdc
movq %r12, %rdi
callq 0x3220
movl %r15d, %ecx
subl %eax, %ecx
je 0x6ca6
movq %r15, 0x10(%rsp)
movq %r14, %r15
movq %r12, %r14
movslq %ecx, %r12
movq %r12, %rdi
callq 0x3030
movq %rax, %r13
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x3170
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %r12
movq %r15, %r14
movq 0x10(%rsp), %r15
callq 0x3390
movq %r13, %rdi
movq 0x8(%rsp), %r13
callq 0x3380
movzbl 0x4b(%r14), %eax
imulq %rbx, %rax
addq %rbp, %rax
imulq $0x28, %rax, %rdi
addq 0x8(%r14), %rdi
movq %r12, %rsi
callq 0x5caa
movzbl 0x4b(%r14), %eax
movq %rax, %rcx
imulq %rbx, %rcx
addq %r13, %rcx
movzbl (%rbp,%rcx), %ecx
shll $0x8, %ecx
addl %ecx, %r15d
incq %rbp
jmp 0x6c2f
incq %rbx
jmp 0x6c1c
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/CDSKFile.cpp
// Function: CExtendedDSKFile::Update()
void CExtendedDSKFile::Update()
{
	for (int t=0 ; t<_header.NbTrack ; t++)
	{
		for (int s=0 ; s<_header.NbSide ; s++)
		{
			int trackSize = _tracks[(t*_header.NbSide) + s].GetDSKTrackSize();
			_header.TrackSizeTable[(t*_header.NbSide) + s] = trackSize >> 8;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movzbl 0x4a(%rdi), %eax
movq %rax, 0x10(%rsp)
movzbl 0x4b(%rdi), %r12d
movq 0x8(%rdi), %r13
addq $0x4e, %rbx
imulq $0x28, %r12, %rax
movq %rax, 0x8(%rsp)
xorl %r15d, %r15d
cmpq 0x10(%rsp), %r15
je 0x6d63
movq %r13, %r14
xorl %ebp, %ebp
cmpq %rbp, %r12
je 0x6d56
movq %r14, %rdi
callq 0x5e0a
movb %ah, (%rbx,%rbp)
incq %rbp
addq $0x28, %r14
jmp 0x6d3d
incq %r15
addq 0x8(%rsp), %r13
addq %r12, %rbx
jmp 0x6d31
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/COptionParser.cpp
// Function: COptionParser::GetIntOption(char, int, int) const
int COptionParser::GetIntOption(const char shortName, const int defaultVal, int paramIdx) const
{
	int val = defaultVal;
	int idx;
	if ((idx = optionIndex(_optionsOut, shortName)) != ERROR_UNKNOWN)
	{
		val = strtol(_optionsOut[idx].argv[paramIdx],NULL,0);
		TOOLS_ASSERTMSG(errno != ERANGE, "Wrong value " << _optionsOut[idx].argv[paramIdx]);
	}
	return val;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1c0, %rsp            # imm = 0x1C0
movl %ecx, %ebp
movl %edx, %r14d
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x7df4
cmpl $-0x1, %eax
je 0x7304
movq 0x8(%rbx), %rcx
movslq %eax, %r15
shlq $0x4, %r15
movq 0x8(%rcx,%r15), %rax
movslq %ebp, %r12
movq (%rax,%r12,8), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3400
movq %rax, %r14
callq 0x3040
cmpl $0x22, (%rax)
je 0x7317
movl %r14d, %eax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0x33b0
leaq 0x760b(%rip), %rsi      # 0xe936
movq %r14, %rdi
callq 0x3270
movq 0x8(%rbx), %rcx
movq 0x8(%rcx,%r15), %rcx
movq (%rcx,%r12,8), %rsi
movq %rax, %rdi
callq 0x3270
pushq $0x50
popq %rdi
callq 0x3140
movq %rax, %rbx
leaq 0x75e9(%rip), %rsi      # 0xe943
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x3c9e
leaq 0x50(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x34a0
leaq 0x28(%rsp), %rsi
pushq $0x42
popq %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x6fd4
leaq 0xca04(%rip), %rsi      # 0x13d98
leaq -0x379(%rip), %rdx      # 0x7022
movq %rbx, %rdi
callq 0x34d0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3578
xorl %ebp, %ebp
jmp 0x73ba
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x3578
testb %bpl, %bpl
jne 0x73ce
jmp 0x73db
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
jmp 0x73db
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x30a0
movq %r14, %rdi
callq 0xb830
nop
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/COptionParser.cpp
// Function: COptionParser::GetStringOption(char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) const
std::string COptionParser::GetStringOption(const char shortName, const std::string &defaultVal, int paramIdx) const
{
	std::string val = defaultVal;
	int idx;
	if ((idx = optionIndex(_optionsOut, shortName)) != ERROR_UNKNOWN)
	{
		val = _optionsOut[idx].argv[paramIdx];
	}
	return val;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movq %rcx, %rsi
callq 0x33d0
movq 0x8(%r14), %rdi
movl %r15d, %esi
callq 0x7df4
cmpl $-0x1, %eax
je 0x7438
movq 0x8(%r14), %rcx
cltq
shlq $0x4, %rax
movq 0x8(%rcx,%rax), %rax
movslq %ebp, %rcx
movq (%rax,%rcx,8), %rsi
movq %rbx, %rdi
callq 0x3540
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3578
movq %r14, %rdi
callq 0xb830
nop
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/optionParser.c
// Function: addArgv
void addArgv(int *argc, char ***argv, char *newArg)
{
	int i;
	int sizeH;
	int sizeS = 0;
	char *newArgv;
	char **newArgv2;
	char *ptr;

	for (i=0;i<(*argc);i++)
		sizeS += strlen((*argv)[i])+1;
	sizeH = ((*argc)+2)*sizeof(char*);

	newArgv = (char*)malloc(sizeH+sizeS+strlen(newArg)+1);

	if (*argv != NULL && (*argc != 0))
		memcpy(newArgv+sizeH, (*argv)[0], sizeS);
	memcpy(newArgv+sizeH+sizeS,newArg,strlen(newArg)+1);
	ptr = newArgv+sizeH;
	newArgv2 = (char**)newArgv;
	for (i=0;i<((*argc)+1);i++)
	{
		newArgv2[i]=ptr;
		if (i != (*argc))
			ptr += strlen((*argv)[i])+1;
	}
	newArgv2[(*argc)+1] = NULL;

	if (*argv != NULL && (*argc != 0))
		free(*argv);

	*argv = newArgv2;
	(*argc)++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, 0x20(%rsp)
movl (%rdi), %ebx
movslq %ebx, %r15
xorl %r12d, %r12d
testl %r15d, %r15d
movl $0x0, %ebp
cmovgl %ebx, %ebp
xorl %r13d, %r13d
cmpq %r12, %rbp
je 0x79b0
movq (%r14), %rax
movq (%rax,%r12,8), %rdi
callq 0x3120
addl %eax, %r13d
incl %r13d
incq %r12
jmp 0x7994
leal 0x10(,%rbx,8), %ebp
leal 0x10(%r13,%rbx,8), %eax
movslq %eax, %r12
movq 0x8(%rsp), %rdi
callq 0x3120
leaq (%r12,%rax), %rdi
incq %rdi
callq 0x33a0
movq %rax, %r12
movq (%r14), %rcx
testq %rcx, %rcx
sete %al
testl %ebx, %ebx
sete %dl
orb %al, %dl
movslq %ebp, %rbp
movb %dl, 0x7(%rsp)
cmpb $0x1, %dl
movq %rcx, 0x10(%rsp)
jne 0x79fe
movslq %r13d, %r13
jmp 0x7a10
leaq (%r12,%rbp), %rdi
movq (%rcx), %rsi
movslq %r13d, %r13
movq %r13, %rdx
callq 0x3200
addq %r12, %rbp
addq %rbp, %r13
movq %r13, 0x18(%rsp)
movq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x3120
leaq 0x1(%rax), %rdx
movq 0x18(%rsp), %rdi
movq %r13, %rsi
callq 0x3200
xorl %r13d, %r13d
movq 0x10(%rsp), %rdi
cmpq %r15, %r13
jg 0x7a68
movq %rbp, (%r12,%r13,8)
cmpq %r13, %rbx
je 0x7a63
movq (%rdi,%r13,8), %rdi
callq 0x3120
movq 0x10(%rsp), %rdi
addq %rax, %rbp
incq %rbp
incq %r13
jmp 0x7a41
andq $0x0, 0x8(%r12,%r15,8)
cmpb $0x0, 0x7(%rsp)
movq 0x20(%rsp), %r15
jne 0x7a82
callq 0x3320
movl (%r15), %ebx
movq %r12, (%r14)
incl %ebx
movl %ebx, (%r15)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/optionParser.c
// Function: removeArgv
void removeArgv(int *argc, char ***argv, int idx)
{
	int i,j;
	int sizeH;
	int sizeS = 0;
	char *newArgv;
	char **newArgv2;
	char *ptr;

	if ((*argc) < idx)
		return;

	for (i=0;i<(*argc);i++)
	{
		if (i != idx)
			sizeS += strlen((*argv)[i])+1;
	}
	sizeH = ((*argc))*sizeof(char*);

	newArgv = (char*)malloc(sizeH+sizeS);
	if (!newArgv)
	{
		printf( "MALLOC IMPOSSIBLE ! %s : %d \n", __FILE__, __LINE__); ;
	}

	ptr = newArgv+sizeH;
	newArgv2 = (char**)newArgv;
	j = 0;
	for (i=0;i<(*argc);i++)
	{
		if (i != idx)
		{
			memcpy(ptr,(*argv)[i],strlen((*argv)[i])+1);
			newArgv2[j]=ptr;
			ptr += strlen((*argv)[i])+1;
			j++;
		}
	}
	newArgv2[(*argc)-1] = NULL;

//	if(*argv) free(*argv);

	*argv = newArgv2;
	(*argc)--;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl (%rdi), %r12d
cmpl %edx, %r12d
jl 0x7ba2
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
movl %edx, %ebp
xorl %ebx, %ebx
testl %r12d, %r12d
movl $0x0, %r13d
cmovgl %r12d, %r13d
xorl %r15d, %r15d
cmpq %rbx, %r13
je 0x7af0
cmpq %rbx, %rbp
je 0x7aeb
movq (%r14), %rax
movq (%rax,%rbx,8), %rdi
callq 0x3120
addl %eax, %r15d
incl %r15d
incq %rbx
jmp 0x7acf
movl %r12d, %eax
shll $0x3, %r12d
leal (%r15,%rax,8), %eax
movslq %eax, %rdi
callq 0x33a0
movq %rax, %rbx
testq %rax, %rax
jne 0x7b23
leaq 0x6ea3(%rip), %rdi      # 0xe9b5
leaq 0x6eba(%rip), %rsi      # 0xe9d3
pushq $0x55
popq %rdx
xorl %eax, %eax
callq 0x3050
movslq %r12d, %r12
movq %rbx, 0x8(%rsp)
addq %rbx, %r12
xorl %r15d, %r15d
xorl %ebx, %ebx
movq 0x10(%rsp), %r13
movslq (%r13), %rax
cmpq %rax, %r15
jge 0x7b8e
cmpq %r15, %rbp
je 0x7b89
movq (%r14), %rax
movq (%rax,%r15,8), %r13
movq %r13, %rdi
callq 0x3120
leaq 0x1(%rax), %rdx
movq %r12, %rdi
movq %r13, %rsi
movq 0x10(%rsp), %r13
callq 0x3200
movslq %ebx, %rbx
movq 0x8(%rsp), %rax
movq %r12, (%rax,%rbx,8)
movq (%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x3120
addq %rax, %r12
incq %r12
incl %ebx
incq %r15
jmp 0x7b38
movq 0x8(%rsp), %rcx
andq $0x0, -0x8(%rcx,%rax,8)
movq %rcx, (%r14)
decl %eax
movl %eax, (%r13)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/optionParser.c
// Function: compareOptionString
int compareOptionString(char *argv, char shortName, const char *longName)
{
	unsigned int i;
	if (argv == NULL || longName == NULL)
		RET_ERROR(ERROR_UNKNOWN, "Internal error");

	if (argv[0] != '-')
		RET_ERROR( ERROR_UNKOPT, "Unknown option, not beginning with '-'");
	if (argv[1] != '-')
	{
		if (strlen(argv) != 2)
			RET_ERROR( ERROR_UNKOPT, "Unknown option, '-' with more than one caracter");
		if (toupper(argv[1]) == toupper(shortName))
			RET_ERROR( OPT_NO_ERROR, "No error");
		RET_ERROR( ERROR_UNKOPT, "Unknown option");
	}
	else
	{
		if ((strlen(argv)-2) != strlen(longName))
			RET_ERROR( ERROR_UNKOPT, "Unknown option");
		i = 0;
		while ((toupper(argv[i+2]) == toupper(longName[i])) && (i < strlen(longName)))
			i++;
		if (i == strlen(longName))
			RET_ERROR( OPT_NO_ERROR, "No error");
		RET_ERROR( ERROR_UNKOPT, "Unknown option");
	}
}

// Assembly:
testq %rdi, %rdi
setne %al
testq %rdx, %rdx
setne %cl
testb %cl, %al
jne 0x7bf7
orl $-0x1, 0xc9cf(%rip)     # 0x145a0
movabsq $0x6c616e7265746e49, %rax # imm = 0x6C616E7265746E49
movq %rax, 0xc9ce(%rip)      # 0x145b0
movabsq $0x726f727265206c, %rax # imm = 0x726F727265206C
movq %rax, 0xc9c4(%rip)      # 0x145b7
pushq $-0x1
popq %rax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
cmpb $0x2d, (%rdi)
jne 0x7c9a
movq %rdx, %rbx
movl %esi, %ebp
movsbq 0x1(%r14), %r12
movq %r14, %rdi
callq 0x3120
movq %rax, %r15
cmpq $0x2d, %r12
jne 0x7cdd
addq $-0x2, %r15
movq %rbx, %rdi
callq 0x3120
cmpq %rax, %r15
jne 0x7c6c
callq 0x3060
movq (%rax), %rax
xorl %ecx, %ecx
movl %ecx, %edx
cmpq %rdx, %r15
jbe 0x7c63
leal 0x2(%rcx), %esi
movsbq (%r14,%rsi), %rsi
movsbq (%rbx,%rdx), %rdi
movl (%rax,%rdi,4), %edi
incl %ecx
cmpl %edi, (%rax,%rsi,4)
je 0x7c45
cmpq %rdx, %r15
je 0x7cfc
movl $0xfffffffe, 0xc92a(%rip) # imm = 0xFFFFFFFE
movabsq $0x206e776f6e6b6e55, %rax # imm = 0x206E776F6E6B6E55
movq %rax, 0xc929(%rip)      # 0x145b0
movabsq $0x6e6f6974706f20, %rax # imm = 0x6E6F6974706F20
movq %rax, 0xc91f(%rip)      # 0x145b7
jmp 0x7cd1
movl $0xfffffffe, 0xc8fc(%rip) # imm = 0xFFFFFFFE
movups 0x6d46(%rip), %xmm0     # 0xe9f1
movaps %xmm0, 0xc8fe(%rip)     # 0x145b0
movups 0x6d48(%rip), %xmm0     # 0xea01
movaps %xmm0, 0xc900(%rip)     # 0x145c0
movabsq $0x272d2720687469, %rax # imm = 0x272D2720687469
movq %rax, 0xc8fe(%rip)      # 0x145cf
pushq $-0x2
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x2, %r15
jne 0x7d1f
callq 0x3060
movq (%rax), %rax
movl (%rax,%r12,4), %ecx
movsbq %bpl, %rdx
cmpl (%rax,%rdx,4), %ecx
jne 0x7c6c
andl $0x0, 0xc89d(%rip)      # 0x145a0
movabsq $0x726f727265206f4e, %rax # imm = 0x726F727265206F4E
movq %rax, 0xc89c(%rip)      # 0x145b0
movb $0x0, 0xc89d(%rip)      # 0x145b8
xorl %eax, %eax
jmp 0x7cd4
movl $0xfffffffe, 0xc877(%rip) # imm = 0xFFFFFFFE
movups 0x6ce8(%rip), %xmm0     # 0xea18
movaps %xmm0, 0xc879(%rip)     # 0x145b0
movups 0x6cea(%rip), %xmm0     # 0xea28
movaps %xmm0, 0xc87b(%rip)     # 0x145c0
movups 0x6cec(%rip), %xmm0     # 0xea38
movaps %xmm0, 0xc87d(%rip)     # 0x145d0
jmp 0x7cd1
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/optionParser.c
// Function: findOption
int findOption(char *argv, struct SOption *option)
{
	int i=0;
	if (option == NULL)
		RET_ERROR(ERROR_UNKNOWN, "Internal error");
	while (option[i].shortName != 0)
	{
		if (compareOptionString(argv,option[i].shortName,option[i].longName) == OPT_NO_ERROR)
			return i;
		i++;
	}
	RET_ERROR(ERROR_UNKOPT, "Unknown option");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x7d90
movq %rsi, %r14
movq %rdi, %r15
addq $0x8, %r14
xorl %ebx, %ebx
movb -0x8(%r14), %al
testb %al, %al
je 0x7dbd
movq (%r14), %rdx
movsbl %al, %esi
movq %r15, %rdi
callq 0x7bba
testl %eax, %eax
je 0x7dec
incl %ebx
addq $0x28, %r14
jmp 0x7d6e
orl $-0x1, 0xc809(%rip)     # 0x145a0
movabsq $0x6c616e7265746e49, %rax # imm = 0x6C616E7265746E49
movq %rax, 0xc808(%rip)      # 0x145b0
movabsq $0x726f727265206c, %rax # imm = 0x726F727265206C
movq %rax, 0xc7fe(%rip)      # 0x145b7
pushq $-0x1
jmp 0x7deb
movl $0xfffffffe, 0xc7d9(%rip) # imm = 0xFFFFFFFE
movabsq $0x206e776f6e6b6e55, %rax # imm = 0x206E776F6E6B6E55
movq %rax, 0xc7d8(%rip)      # 0x145b0
movabsq $0x6e6f6974706f20, %rax # imm = 0x6E6F6974706F20
movq %rax, 0xc7ce(%rip)      # 0x145b7
pushq $-0x2
popq %rbx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/optionParser.c
// Function: addOption
void addOption(struct SOptionOut **cmdOption, char **argv, struct SOption *option)
{
	int nbCmdOption=0;
	int i;
	struct SOptionOut *newCmdOption;
	

	//compte le nombre d'option possibles
	if (*cmdOption != NULL)
	{
		while ((*cmdOption)[nbCmdOption].shortName != 0)
			nbCmdOption++;
	}

	newCmdOption = (struct SOptionOut*)malloc((nbCmdOption+2)*sizeof(struct SOptionOut));
	if (!newCmdOption)
	{
		printf( "MALLOC ERROR !  %s : %d \n", __FILE__, __LINE__) ;
		printf(" nb : %d \n size : %d\ntot : %d \n", nbCmdOption+2, sizeof(struct SOptionOut), (nbCmdOption+2)*sizeof(struct SOptionOut));
		exit (-1);
	}

	if (nbCmdOption != 0)
	{
		memcpy(newCmdOption,*cmdOption,(nbCmdOption)*sizeof(struct SOptionOut));
	}
	
	newCmdOption[nbCmdOption].shortName = option->shortName;
	newCmdOption[nbCmdOption].argc = 0;
	if (option->nbArgs != 0)
	{
		for (i=0;i<option->nbArgs;i++)
		{
			addArgv(&newCmdOption[nbCmdOption].argc,&newCmdOption[nbCmdOption].argv,argv[i]);
		}
	}
	else
	{
		newCmdOption[nbCmdOption].argv = NULL;
	}
	newCmdOption[nbCmdOption+1].shortName=0;
	newCmdOption[nbCmdOption+1].argc=0;
	newCmdOption[nbCmdOption+1].argv=NULL;

	if (*cmdOption != NULL)
		free(*cmdOption);
	*cmdOption = newCmdOption;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq (%rdi), %rax
testq %rax, %rax
movq %rdi, 0x10(%rsp)
movq %rax, 0x8(%rsp)
je 0x7e8c
pushq $-0x1
popq %rbp
incl %ebp
cmpb $0x0, (%rax)
leaq 0x10(%rax), %rax
jne 0x7e7f
jmp 0x7e8e
xorl %ebp, %ebp
movl %ebp, %r12d
movq %r12, %rbx
shlq $0x4, %rbx
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x33a0
testq %rax, %rax
je 0x7f61
movq %rax, %r13
testl %ebp, %ebp
je 0x7eca
movq %r12, %rdx
shlq $0x4, %rdx
movq %r13, %rdi
movq 0x8(%rsp), %rsi
callq 0x3200
jmp 0x7ecd
xorl %r12d, %r12d
movb (%r14), %al
shlq $0x4, %r12
movb %al, (%r13,%r12)
andl $0x0, 0x4(%r13,%r12)
leaq (%r12,%r13), %rcx
movl 0x18(%r14), %eax
leaq (%r12,%r13), %rbx
addq $0x8, %rbx
testl %eax, %eax
je 0x7f2f
movq %rcx, 0x8(%rsp)
addq %r13, %r12
addq $0x4, %r12
xorl %ebp, %ebp
cltq
cmpq %rax, %rbp
jge 0x7f20
movq (%r15,%rbp,8), %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x7963
incq %rbp
movl 0x18(%r14), %eax
jmp 0x7f01
movq 0x10(%rsp), %rbx
movq (%rbx), %rdi
movq 0x8(%rsp), %rcx
jmp 0x7f3d
andq $0x0, (%rbx)
movq 0x10(%rsp), %rbx
movq 0x8(%rsp), %rdi
movb $0x0, 0x10(%rcx)
andl $0x0, 0x14(%rcx)
andq $0x0, 0x18(%rcx)
callq 0x3320
movq %r13, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addl $0x2, %ebp
leaq 0x6af5(%rip), %rdi      # 0xea60
leaq 0x6a61(%rip), %rsi      # 0xe9d3
movl $0xba, %edx
xorl %eax, %eax
callq 0x3050
leaq 0x6af5(%rip), %rdi      # 0xea7a
pushq $0x10
popq %rdx
movl %ebp, %esi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x3050
pushq $-0x1
popq %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/optionParser.c
// Function: freeOptionOut
void freeOptionOut(struct SOptionOut *cmdOptionLine)
{
	int i=0;
	char shortName;

	if (cmdOptionLine != NULL)
	{
		do
		{
			shortName = cmdOptionLine[i].shortName;
			if (cmdOptionLine[i].argc != 0)
			{
				free(cmdOptionLine[i].argv);
			}
			i++;
		}
		while (shortName != 0);
		free(cmdOptionLine);
	}
}

// Assembly:
testq %rdi, %rdi
je 0x7fd4
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movb -0x8(%r14), %bpl
cmpl $0x0, -0x4(%r14)
je 0x7fbf
movq (%r14), %rdi
callq 0x3320
addq $0x10, %r14
testb %bpl, %bpl
jne 0x7fac
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3320
retq
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/optionParser.c
// Function: parseConfigFileOption
int parseConfigFileOption(char* configFile, int *argc, char*** argv, struct SOption *option, struct SOptionOut **cmdOptionLine)
{
	FILE *f=fopen(configFile,"r");
	char arg[256];
	int i;

	if (f == NULL)
		RET_ERROR(ERROR_UNKNOWN, "Unable to open file");

	while(!feof(f))
	{
		char c;
		c=fgetc(f);
		while ((c==' ' || c=='\t' || c=='\n') && !feof(f))
			c=fgetc(f);
		if (feof(f))
			continue;
		i=0;
		if (c == ';')
		{
			char comment[256];
			fgets(comment,256,f);
		}
		else
		{
			while ((!(c==' ' || c=='\t' || c=='\n')) && !feof(f))
			{
				arg[i++] = c;
				c=fgetc(f);
			}
			arg[i]=0;
			addArgv(argc,argv,arg);
		}
	}
	fclose(f);

	return parseCommandLineOption(argc,argv,option,cmdOptionLine);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq 0x6793(%rip), %rsi      # 0xea46
callq 0x3310
testq %rax, %rax
je 0x83b3
movq %rax, %r13
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movabsq $0x100000600, %rbp      # imm = 0x100000600
movq %r13, %rdi
callq 0x3470
testl %eax, %eax
jne 0x8395
movq %r13, %rdi
callq 0x3480
movl %eax, %r14d
movl %eax, %ebx
shll $0x18, %ebx
cmpl $0x9000000, %ebx        # imm = 0x9000000
je 0x830f
cmpl $0x20000000, %ebx       # imm = 0x20000000
je 0x830f
cmpl $0xa000000, %ebx        # imm = 0xA000000
jne 0x831b
movq %r13, %rdi
callq 0x3470
testl %eax, %eax
je 0x82e7
movq %r13, %rdi
callq 0x3470
testl %eax, %eax
jne 0x82d7
cmpl $0x3b000000, %ebx       # imm = 0x3B000000
jne 0x8346
leaq 0x110(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
movq %r13, %rdx
callq 0x3490
jmp 0x82d7
xorl %ebx, %ebx
cmpb $0x20, %r14b
ja 0x8358
movzbl %r14b, %eax
btq %rax, %rbp
jb 0x8379
movq %r13, %rdi
callq 0x3470
testl %eax, %eax
jne 0x8379
movb %r14b, 0x10(%rsp,%rbx)
incq %rbx
movq %r13, %rdi
callq 0x3480
movl %eax, %r14d
jmp 0x8348
movl %ebx, %eax
movb $0x0, 0x10(%rsp,%rax)
movq %r12, %rdi
movq %r15, %rsi
leaq 0x10(%rsp), %rdx
callq 0x7963
jmp 0x82d7
movq %r13, %rdi
callq 0x3280
movq %r12, %rdi
movq %r15, %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x7fd5
jmp 0x83d5
orl $-0x1, 0xc1e6(%rip)     # 0x145a0
movups 0x6709(%rip), %xmm0     # 0xeaca
movaps %xmm0, 0xc1e8(%rip)     # 0x145b0
movl $0x656c69, 0xc1ee(%rip) # imm = 0x656C69
pushq $-0x1
popq %rax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/optionParser.c
// Function: printUsage
void printUsage(char * appliName, char* cmdOptionLine, char* description, struct SOption *option)
{
	int i=0;
	int j=0;
	printf("Usage : %s %s ",appliName, cmdOptionLine);
	while (option[i].shortName !=0)
	{
		if (option[i].nbMin == 0)
			printf("[");
		else
			printf("<");
		printf("-%c",option[i].shortName);
		for (j=0;j<option[i].nbArgs;j++)
			printf(" $%d",j+1);
		if (option[i].nbMin == 0)
		{
			printf("]");
			if (option[i].nbMax == 0)
				printf("*");
		}
		else
		{
			printf(">");
			if (option[i].nbMax == 0)
				printf("+");
		}
		printf(" ");
		i++;
	}
	printf("[-h]");
	printf("\n\n%s %s\n\n",appliName, description);
	i = 0;
	while (option[i].shortName !=0)
	{
		printf("\t-%c",option[i].shortName);
		for (j=0;j<option[i].nbArgs;j++)
			printf(" <$%d>",j+1);
		printf(" | --%s",option[i].longName);
		for (j=0;j<option[i].nbArgs;j++)
			printf(" <$%d>",j+1);
		printf("\n\t\t%s\n",option[i].description);
		i++;
	}
	printf("\t-h | --help\n\t\tDisplay help\n\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, 0x10(%rsp)
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x66d4(%rip), %rdi      # 0xeade
movq %rsi, 0x8(%rsp)
xorl %eax, %eax
callq 0x3050
leaq 0x66d0(%rip), %r13      # 0xeaed
pushq $0x20
popq %r14
xorl %r15d, %r15d
imulq $0x28, %r15, %r12
cmpb $0x0, (%rbx,%r12)
je 0x84be
addq %rbx, %r12
cmpl $0x0, 0x10(%r12)
pushq $0x3c
popq %rdi
pushq $0x5b
popq %rax
cmovel %eax, %edi
callq 0x33f0
movsbl (%r12), %esi
leaq 0x66a7(%rip), %rdi      # 0xeafd
xorl %eax, %eax
callq 0x3050
pushq $0x1
popq %rax
movl %eax, %ebp
leal -0x1(%rbp), %eax
cmpl 0x18(%r12), %eax
jge 0x847c
movq %r13, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x3050
incl %ebp
jmp 0x8462
cmpl $0x0, 0x10(%r12)
je 0x8496
pushq $0x3e
popq %rdi
callq 0x33f0
cmpl $0x0, 0x14(%r12)
pushq $0x2b
jmp 0x84a6
pushq $0x5d
popq %rdi
callq 0x33f0
cmpl $0x0, 0x14(%r12)
pushq $0x2a
popq %rdi
jne 0x84ae
callq 0x33f0
movl %r14d, %edi
callq 0x33f0
incq %r15
jmp 0x8424
leaq 0x64b6(%rip), %rdi      # 0xe97b
xorl %eax, %eax
callq 0x3050
leaq 0x661f(%rip), %rdi      # 0xeaf2
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
xorl %eax, %eax
callq 0x3050
pushq $0x1
popq %r14
leaq 0x6612(%rip), %r15      # 0xeb01
xorl %r12d, %r12d
imulq $0x28, %r12, %r13
movsbl (%rbx,%r13), %esi
testl %esi, %esi
je 0x8571
addq %rbx, %r13
leaq 0x65f3(%rip), %rdi      # 0xeafc
xorl %eax, %eax
callq 0x3050
movl %r14d, %ebp
leal -0x1(%rbp), %eax
cmpl 0x18(%r13), %eax
jge 0x852c
movq %r15, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x3050
incl %ebp
jmp 0x8513
movq 0x8(%r13), %rsi
leaq 0x65d1(%rip), %rdi      # 0xeb08
xorl %eax, %eax
callq 0x3050
movl %r14d, %ebp
leal -0x1(%rbp), %eax
cmpl 0x18(%r13), %eax
jge 0x855a
movq %r15, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x3050
incl %ebp
jmp 0x8541
movq 0x20(%r13), %rsi
leaq 0x65ab(%rip), %rdi      # 0xeb10
xorl %eax, %eax
callq 0x3050
incq %r12
jmp 0x84f2
leaq 0x65c2(%rip), %rdi      # 0xeb3a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3460
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/optionParser.c
// Function: parseCommandLine
int parseCommandLine(int *argc, char*** argv,
					 struct SOption *option, struct SOptionOut **commandLine,
					 int nbMinArg, int noConfig)
{
	if (parseCommandLineOption(argc,argv,option,commandLine) != OPT_NO_ERROR)
	{
		return getError();
	}

	if (!noConfig)
	{
		int o;
		if ((o=optionIndex(*commandLine,'c')) != ERROR_UNKNOWN)
		{
			if (parseConfigFileOption((*commandLine)[o].argv[0],argc,argv,option,commandLine) != OPT_NO_ERROR)
			{
				return getError();
			}
		}
	}

	if ((*argc) <= nbMinArg && nbMinArg >= 0)
	{
		char errorStr[1024];
		sprintf(errorStr, "Wrong number of arg, %d expected\n\n", nbMinArg);
		RET_ERROR(ERROR_NBARG, errorStr);
	}
	return OPT_NO_ERROR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movl %r9d, %ebp
movl %r8d, %ebx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
callq 0x7fd5
testl %eax, %eax
je 0x85cf
movl 0xbfe3(%rip), %eax      # 0x145a0
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %ebp, %ebp
je 0x8612
xorl %eax, %eax
testl %ebx, %ebx
js 0x85bd
cmpl %ebx, (%r14)
jg 0x85bd
leaq 0x6532(%rip), %rsi      # 0xeb17
movq %rsp, %r14
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x3080
movl $0xfffffffb, 0xbfa2(%rip) # imm = 0xFFFFFFFB
leaq 0xbfab(%rip), %rdi      # 0x145b0
movq %r14, %rsi
callq 0x3250
pushq $-0x5
popq %rax
jmp 0x85bd
movq (%r15), %rdi
pushq $0x63
popq %rsi
callq 0x7df4
cmpl $-0x1, %eax
je 0x85d3
movq (%r15), %rcx
cltq
shlq $0x4, %rax
movq 0x8(%rcx,%rax), %rax
movq (%rax), %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0x828f
testl %eax, %eax
jne 0x85b7
jmp 0x85d3
nop
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/rs232.c
// Function: RS232_CloseComport
void RS232_CloseComport(HANDLE handle)
{
  int status;

  if(ioctl(handle, TIOCMGET, &status) == -1)
  {
    perror("unable to get portstatus");
  }

  status &= ~TIOCM_DTR;    /* turn off DTR */
  status &= ~TIOCM_RTS;    /* turn off RTS */

  if(ioctl(handle, TIOCMSET, &status) == -1)
  {
    perror("unable to set portstatus");
  }

  close(handle);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
leaq 0xc(%rsp), %rdx
movl $0x5415, %esi           # imm = 0x5415
xorl %eax, %eax
callq 0x3410
cmpl $-0x1, %eax
je 0x8ad8
leaq 0xc(%rsp), %rdx
andb $-0x7, (%rdx)
movl $0x5418, %esi           # imm = 0x5418
movl %ebx, %edi
xorl %eax, %eax
callq 0x3410
cmpl $-0x1, %eax
je 0x8ae6
movl %ebx, %edi
callq 0x3560
addq $0x10, %rsp
popq %rbx
retq
leaq 0x611b(%rip), %rdi      # 0xebfa
callq 0x3210
jmp 0x8ab0
leaq 0x6126(%rip), %rdi      # 0xec13
callq 0x3210
jmp 0x8acb
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/rs232.c
// Function: RS232_enableDTR
void RS232_enableDTR(HANDLE handle)
{
  int status;

  if(ioctl(handle, TIOCMGET, &status) == -1)
  {
    perror("unable to get portstatus");
  }

  status |= TIOCM_DTR;    /* turn on DTR */

  if(ioctl(handle, TIOCMSET, &status) == -1)
  {
    perror("unable to set portstatus");
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
leaq 0xc(%rsp), %rdx
movl $0x5415, %esi           # imm = 0x5415
xorl %eax, %eax
callq 0x3410
cmpl $-0x1, %eax
je 0x8ba0
leaq 0xc(%rsp), %rdx
orb $0x2, (%rdx)
movl $0x5418, %esi           # imm = 0x5418
movl %ebx, %edi
xorl %eax, %eax
callq 0x3410
cmpl $-0x1, %eax
je 0x8bae
addq $0x10, %rsp
popq %rbx
retq
leaq 0x6053(%rip), %rdi      # 0xebfa
callq 0x3210
jmp 0x8b7f
leaq 0x605e(%rip), %rdi      # 0xec13
callq 0x3210
jmp 0x8b9a
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/rs232.c
// Function: RS232_disableDTR
void RS232_disableDTR(HANDLE handle)
{
  int status;

  if(ioctl(handle, TIOCMGET, &status) == -1)
  {
    perror("unable to get portstatus");
  }

  status &= ~TIOCM_DTR;    /* turn off DTR */

  if(ioctl(handle, TIOCMSET, &status) == -1)
  {
    perror("unable to set portstatus");
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
leaq 0xc(%rsp), %rdx
movl $0x5415, %esi           # imm = 0x5415
xorl %eax, %eax
callq 0x3410
cmpl $-0x1, %eax
je 0x8bfa
leaq 0xc(%rsp), %rdx
andb $-0x3, (%rdx)
movl $0x5418, %esi           # imm = 0x5418
movl %ebx, %edi
xorl %eax, %eax
callq 0x3410
cmpl $-0x1, %eax
je 0x8c08
addq $0x10, %rsp
popq %rbx
retq
leaq 0x5ff9(%rip), %rdi      # 0xebfa
callq 0x3210
jmp 0x8bd9
leaq 0x6004(%rip), %rdi      # 0xec13
callq 0x3210
jmp 0x8bf4
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/rs232.c
// Function: RS232_enableRTS
void RS232_enableRTS(HANDLE handle)
{
  int status;

  if(ioctl(handle, TIOCMGET, &status) == -1)
  {
    perror("unable to get portstatus");
  }

  status |= TIOCM_RTS;    /* turn on RTS */

  if(ioctl(handle, TIOCMSET, &status) == -1)
  {
    perror("unable to set portstatus");
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
leaq 0xc(%rsp), %rdx
movl $0x5415, %esi           # imm = 0x5415
xorl %eax, %eax
callq 0x3410
cmpl $-0x1, %eax
je 0x8c54
leaq 0xc(%rsp), %rdx
orb $0x4, (%rdx)
movl $0x5418, %esi           # imm = 0x5418
movl %ebx, %edi
xorl %eax, %eax
callq 0x3410
cmpl $-0x1, %eax
je 0x8c62
addq $0x10, %rsp
popq %rbx
retq
leaq 0x5f9f(%rip), %rdi      # 0xebfa
callq 0x3210
jmp 0x8c33
leaq 0x5faa(%rip), %rdi      # 0xec13
callq 0x3210
jmp 0x8c4e
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/rs232.c
// Function: RS232_disableRTS
void RS232_disableRTS(HANDLE handle)
{
  int status;

  if(ioctl(handle, TIOCMGET, &status) == -1)
  {
    perror("unable to get portstatus");
  }

  status &= ~TIOCM_RTS;    /* turn off RTS */

  if(ioctl(handle, TIOCMSET, &status) == -1)
  {
    perror("unable to set portstatus");
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
leaq 0xc(%rsp), %rdx
movl $0x5415, %esi           # imm = 0x5415
xorl %eax, %eax
callq 0x3410
cmpl $-0x1, %eax
je 0x8cae
leaq 0xc(%rsp), %rdx
andb $-0x5, (%rdx)
movl $0x5418, %esi           # imm = 0x5418
movl %ebx, %edi
xorl %eax, %eax
callq 0x3410
cmpl $-0x1, %eax
je 0x8cbc
addq $0x10, %rsp
popq %rbx
retq
leaq 0x5f45(%rip), %rdi      # 0xebfa
callq 0x3210
jmp 0x8c8d
leaq 0x5f50(%rip), %rdi      # 0xec13
callq 0x3210
jmp 0x8ca8
// File: /workspace/github_cpp_makefile_star2_O2/UBOdin[P]jitd-cpp/src/rwlock.cpp
// Function: RWLock::reader_lock()
void RWLock::reader_lock()
{
  unique_lock<std::mutex> l(lock);
  if(writers.load() || write_waiters.load())
  {
    read_waiters.fetch_add(1);
    do { read.wait(l); }
    while(writers.load() || write_waiters.load());
    read_waiters.fetch_sub(1);
  }
  readers.fetch_add(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rsi
leaq -0x28(%rbp), %rdi
callq 0x47ae
movl 0x4(%rbx), %eax
testl %eax, %eax
jne 0x4673
movl 0xc(%rbx), %eax
testl %eax, %eax
je 0x469c
lock
incl 0x8(%rbx)
leaq 0x38(%rbx), %r14
leaq -0x28(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x4090
movl 0x4(%rbx), %eax
testl %eax, %eax
jne 0x467f
movl 0xc(%rbx), %eax
testl %eax, %eax
jne 0x467f
lock
decl 0x8(%rbx)
lock
incl (%rbx)
leaq -0x28(%rbp), %rdi
callq 0x47ce
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/UBOdin[P]jitd-cpp/src/rwlock.cpp
// Function: RWLock::reader_release()
void RWLock::reader_release()
{
  unique_lock<std::mutex> l(lock);
  readers.fetch_sub(1);
  if(writers.load() > 0){
    write.notify_all();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rsi
leaq -0x18(%rbp), %rdi
callq 0x47ae
lock
decl (%rbx)
movl 0x4(%rbx), %eax
testl %eax, %eax
je 0x46e3
addq $0x68, %rbx
movq %rbx, %rdi
callq 0x43b0
leaq -0x18(%rbp), %rdi
callq 0x47ce
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/UBOdin[P]jitd-cpp/src/rwlock.cpp
// Function: RWLock::writer_lock()
void RWLock::writer_lock()
{
  unique_lock<std::mutex> l(lock);
  if(readers.load() || writers.load()){
    write_waiters.fetch_add(1);
    do { write.wait(l); }
    while(readers.load() || writers.load());
    write_waiters.fetch_sub(1);
  }
  writers.store(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rsi
leaq -0x28(%rbp), %rdi
callq 0x47ae
movl (%rbx), %eax
testl %eax, %eax
jne 0x471e
movl 0x4(%rbx), %eax
testl %eax, %eax
je 0x4746
lock
incl 0xc(%rbx)
leaq 0x68(%rbx), %r14
leaq -0x28(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x4090
movl (%rbx), %eax
testl %eax, %eax
jne 0x472a
movl 0x4(%rbx), %eax
testl %eax, %eax
jne 0x472a
lock
decl 0xc(%rbx)
pushq $0x1
popq %rax
xchgl %eax, 0x4(%rbx)
leaq -0x28(%rbp), %rdi
callq 0x47ce
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/UBOdin[P]jitd-cpp/src/rwlock.cpp
// Function: RWLock::writer_release()
void RWLock::writer_release()
{
  unique_lock<std::mutex> l(lock);
  writers.store(0);
  if(write_waiters.load()){
    write.notify_all();
  } else if(read_waiters.load()){
    read.notify_all();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rsi
leaq -0x18(%rbp), %rdi
callq 0x47ae
xorl %eax, %eax
xchgl %eax, 0x4(%rbx)
movl 0xc(%rbx), %eax
testl %eax, %eax
je 0x4789
pushq $0x68
jmp 0x4792
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0x479e
pushq $0x38
popq %rax
addq %rax, %rbx
movq %rbx, %rdi
callq 0x43b0
leaq -0x18(%rbp), %rdi
callq 0x47ce
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/UBOdin[P]jitd-cpp/src/cog_tester.cpp
// Function: build_buffer(int, int)
RecordBuffer build_buffer(int len, int max)
{
  int i;
  RecordBuffer buff(new std::vector<Record>(len));
  for(i = 0; i < len; i++){
    (*buff)[i].key = rand() % max;
    (*buff)[i].value = (Value)0xDEADBEEF;
  }
  return buff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r14
pushq $0x18
popq %rdi
callq 0x4270
movq %rax, %r12
movslq %r15d, %rsi
leaq -0x29(%rbp), %rdx
movq %rax, %rdi
callq 0x573a
movq %r14, %rdi
movq %r12, %rsi
callq 0x5d74
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
shlq $0x4, %r15
movl $0xdeadbeef, %r13d      # imm = 0xDEADBEEF
cmpq %r12, %r15
je 0x48e4
callq 0x4070
cltd
idivl %ebx
movslq %edx, %rax
movq (%r14), %rcx
movq (%rcx), %rcx
movq %rax, (%rcx,%r12)
movq %r13, 0x8(%rcx,%r12)
addq $0x10, %r12
jmp 0x48bf
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x18
popq %rsi
movq %r12, %rdi
callq 0x4280
movq %rbx, %rdi
callq 0x43e0