LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/pelrun[P]aft/CDSKFile.cpp
// Function: CDSKTrack::Write(std::ostream&)
bool CDSKTrack::Write(std::ostream &str)
{
	unsigned int trackPos = str.tellp();
	
	str.write((char*)&Header, 13);
	str.write((char*)&Unused, 3);
	str.write((char*)&TrackNumber, 1);
	str.write((char*)&SideNumber, 1);
	str.write((char*)&DataRate, 1);
	str.write((char*)&RecordingMode, 1);
	str.write((char*)&SectorSize, 1);
	str.write((char*)&NbSector, 1);
	str.write((char*)&GAP3Size, 1);
	str.write((char*)&FillByte, 1);

	int s;
	for (s=0 ; s<NbSector ; s++)
	{
		Sectors[s].WriteHeader(str);
	}

	int nbBlank = (trackPos+0x100) - str.tellp();
	if (nbBlank != 0)
	{
		unsigned char *buff = new unsigned char[nbBlank];
		memset(buff, 0, nbBlank);
		str.write((char*)buff, nbBlank);
		delete[] buff;
	}

	for (s=0 ; s<NbSector ; s++)
	{
		Sectors[s].WriteData(str);
	}

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3250
movq %rax, %r15
movl $0xd, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33c0
leaq 0xe(%r14), %rsi
movl $0x3, %edx
movq %rbx, %rdi
callq 0x33c0
leaq 0x11(%r14), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x33c0
leaq 0x12(%r14), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x33c0
leaq 0x13(%r14), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x33c0
leaq 0x14(%r14), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x33c0
leaq 0x15(%r14), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x33c0
leaq 0x16(%r14), %r12
movl $0x1, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x33c0
leaq 0x17(%r14), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x33c0
leaq 0x18(%r14), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x33c0
cmpb $0x0, 0x16(%r14)
je 0x68c4
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x20(%r14), %rdi
addq %r13, %rdi
movq %rbx, %rsi
callq 0x5caa
incq %rbp
movzbl 0x16(%r14), %eax
addq $0x20, %r13
cmpq %rax, %rbp
jb 0x68a4
movq %rbx, %rdi
callq 0x3250
subq %rax, %r15
addq $0x100, %r15            # imm = 0x100
testl %r15d, %r15d
je 0x690c
movslq %r15d, %r15
movq %r15, %rdi
callq 0x3030
movq %rax, %r13
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x3180
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x33c0
movq %r13, %rdi
callq 0x33b0
cmpb $0x0, (%r12)
je 0x6957
movl $0x8, %r15d
xorl %r12d, %r12d
movq 0x20(%r14), %rax
movzwl -0x2(%rax,%r15), %edx
movb -0x5(%rax,%r15), %cl
movl $0x80, %edi
shll %cl, %edi
testl %edx, %edx
cmovnel %edx, %edi
movq (%rax,%r15), %rsi
movslq %edi, %rdx
movq %rbx, %rdi
callq 0x33c0
incq %r12
movzbl 0x16(%r14), %eax
addq $0x20, %r15
cmpq %rax, %r12
jb 0x691c
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x69ab
movzbl 0x16(%rdi), %edx
testq %rdx, %rdx
je 0x69ac
movq 0x20(%rdi), %rsi
shll $0x5, %edx
movl $0x100, %eax            # imm = 0x100
xorl %edi, %edi
movb 0x3(%rsi,%rdi), %cl
movl $0x80, %r8d
shll %cl, %r8d
movzwl 0x6(%rsi,%rdi), %ecx
testl %ecx, %ecx
cmovnel %ecx, %r8d
addl %r8d, %eax
addq $0x20, %rdi
cmpq %rdi, %rdx
jne 0x6987
retq
movl $0x100, %eax            # imm = 0x100
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rsi, %rbx
movq %rdi, %r14
movb 0x16(%rdi), %al
xorl %ebp, %ebp
cmpb 0x16(%rsi), %al
jne 0x6d99
movb 0x15(%rbx), %cl
cmpb %cl, 0x15(%r14)
jne 0x6d99
movb 0x13(%r14), %cl
cmpb 0x13(%rbx), %cl
jne 0x6d97
movb 0x14(%r14), %cl
cmpb 0x14(%rbx), %cl
jne 0x6d97
movb 0x17(%r14), %cl
cmpb 0x17(%rbx), %cl
jne 0x6d97
movb 0x18(%r14), %cl
cmpb 0x18(%rbx), %cl
sete %bpl
jmp 0x6d99
xorl %ebp, %ebp
testb %al, %al
sete %al
movl %ebp, %ecx
xorb $0x1, %cl
orb %al, %cl
jne 0x6ea3
movq 0x20(%r14), %rax
movb 0x3(%rax), %bpl
leaq 0x10(%rsp), %rcx
xorl %eax, %eax
movl %eax, (%rcx)
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
leaq 0x40(%rsp), %rcx
movl %eax, (%rcx)
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
cmpb $0x0, 0x16(%r14)
je 0x6e3f
movl $0x2, %r13d
xorl %r15d, %r15d
leaq 0x38(%rsp), %r12
movq 0x20(%r14), %rsi
cmpb %bpl, 0x1(%rsi,%r13)
jne 0x6e8d
movq 0x20(%rbx), %rax
cmpb %bpl, 0x1(%rax,%r13)
jne 0x6e8d
addq %r13, %rsi
leaq 0x8(%rsp), %rdi
callq 0x7cec
movq 0x20(%rbx), %rsi
addq %r13, %rsi
movq %r12, %rdi
callq 0x7cec
incq %r15
movzbl 0x16(%r14), %eax
addq $0x20, %r13
cmpq %rax, %r15
jb 0x6df8
movq 0x30(%rsp), %rax
cmpq 0x60(%rsp), %rax
jne 0x6e8d
movq 0x20(%rsp), %rbx
leaq 0x10(%rsp), %r15
cmpq %r15, %rbx
sete %bpl
je 0x6e8f
movq 0x50(%rsp), %r14
movb 0x20(%rbx), %al
cmpb 0x20(%r14), %al
jne 0x6e8f
movq %rbx, %rdi
callq 0x3330
cmpq %r15, %rax
sete %bpl
je 0x6e8f
movq %rax, %rbx
movq %r14, %rdi
callq 0x3330
movq %rax, %r14
jmp 0x6e63
xorl %ebp, %ebp
leaq 0x38(%rsp), %rdi
callq 0x7c9c
leaq 0x8(%rsp), %rdi
callq 0x7c9c
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x7c9c
leaq 0x8(%rsp), %rdi
callq 0x7c9c
movq %rbx, %rdi
callq 0xcdb0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x10, %rdi
callq 0x56d6
movzbl 0x4a(%r14), %r15d
movb 0x4b(%r14), %al
movl %r15d, %ecx
orb %al, %cl
setne 0x3(%rsp)
je 0x7640
movzbl %al, %r12d
movq %r12, %r13
imulq %r15, %r13
leaq (,%r13,4), %rax
addq %r13, %rax
leaq 0x8(,%rax,8), %rdi
callq 0x3030
movq %r13, (%rax)
leaq 0x8(%rax), %rcx
testq %r13, %r13
je 0x75d1
addq $0x28, %rax
imull %r15d, %r12d
shll $0x3, %r12d
leaq (%r12,%r12,4), %rdx
xorl %esi, %esi
movabsq $0x6e492d6b63617254, %rdi # imm = 0x6E492D6B63617254
movabsq $0xa0d6f666e492d, %r8   # imm = 0xA0D6F666E492D
xorl %r9d, %r9d
movq %rsi, (%rax,%r9)
movq %rsi, -0xf(%rax,%r9)
movb %sil, -0x7(%rax,%r9)
movq %rdi, -0x20(%rax,%r9)
movq %r8, -0x1b(%rax,%r9)
movb %sil, -0x10(%rax,%r9)
movw $0x0, -0x12(%rax,%r9)
addq $0x28, %r9
cmpq %r9, %rdx
jne 0x75a3
movq %rcx, 0x8(%r14)
cmpb $0x0, 0x4a(%r14)
je 0x7640
movl $0x100, %eax            # imm = 0x100
xorl %edx, %edx
xorl %r12d, %r12d
cmpb $0x0, 0x4b(%r14)
je 0x7635
movl %edx, 0x4(%rsp)
xorl %r13d, %r13d
movl %eax, %ebp
leal (%r12,%r13), %r15d
movl %eax, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x33f0
leaq (%r15,%r15,4), %rdi
shlq $0x3, %rdi
addq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x6412
movzwl 0x4c(%r14), %eax
addl %ebp, %eax
incl %r13d
movzbl 0x4b(%r14), %ecx
cmpl %ecx, %r13d
jb 0x75f4
addl %r13d, %r12d
movl 0x4(%rsp), %edx
incl %edx
movzbl 0x4a(%r14), %ecx
cmpl %ecx, %edx
jb 0x75e6
movb 0x3(%rsp), %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq %rdi, %r14
addq $0x10, %rdi
callq 0x5754
cmpb $0x0, 0x4a(%r14)
je 0x772b
movl $0x100, %ebp            # imm = 0x100
xorl %r15d, %r15d
xorl %ecx, %ecx
movq %r14, 0x10(%rsp)
cmpb $0x0, 0x4b(%r14)
je 0x771c
movl %ecx, 0xc(%rsp)
xorl %r13d, %r13d
movq %rbx, %rdi
callq 0x3250
movl %ebp, %ecx
subl %eax, %ecx
je 0x76e7
movq %r15, %r14
movslq %ecx, %r15
movq %r15, %rdi
callq 0x3030
movq %rax, %r12
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x3180
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %r15
movq 0x10(%rsp), %r14
callq 0x33c0
movq %r12, %rdi
callq 0x33b0
leal (%r15,%r13), %eax
movl %eax, %eax
leaq (%rax,%rax,4), %rdi
shlq $0x3, %rdi
addq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x67d0
movzwl 0x4c(%r14), %eax
addl %eax, %ebp
incl %r13d
movzbl 0x4b(%r14), %eax
cmpl %eax, %r13d
jb 0x769d
addl %r13d, %r15d
movl 0xc(%rsp), %ecx
incl %ecx
movzbl 0x4a(%r14), %eax
cmpl %eax, %ecx
jb 0x768b
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x10, %rdi
callq 0x59e2
movzbl 0x4a(%r14), %r15d
movb 0x4b(%r14), %al
movl %r15d, %ecx
orb %al, %cl
setne 0x7(%rsp)
je 0x7a11
movzbl %al, %r12d
movq %r12, %r13
imulq %r15, %r13
leaq (,%r13,4), %rax
addq %r13, %rax
leaq 0x8(,%rax,8), %rdi
callq 0x3030
movq %r13, (%rax)
leaq 0x8(%rax), %rcx
testq %r13, %r13
je 0x797d
addq $0x28, %rax
imull %r15d, %r12d
shll $0x3, %r12d
leaq (%r12,%r12,4), %rdx
xorl %esi, %esi
movabsq $0x6e492d6b63617254, %rdi # imm = 0x6E492D6B63617254
movabsq $0xa0d6f666e492d, %r8   # imm = 0xA0D6F666E492D
xorl %r9d, %r9d
movq %rsi, (%rax,%r9)
movq %rsi, -0xf(%rax,%r9)
movb %sil, -0x7(%rax,%r9)
movq %rdi, -0x20(%rax,%r9)
movq %r8, -0x1b(%rax,%r9)
movb %sil, -0x10(%rax,%r9)
movw $0x0, -0x12(%rax,%r9)
addq $0x28, %r9
cmpq %r9, %rdx
jne 0x794f
movq %rcx, 0x8(%r14)
cmpb $0x0, 0x4a(%r14)
je 0x7a11
leaq 0x4e(%r14), %r15
movl $0x100, %r12d           # imm = 0x100
xorl %r13d, %r13d
movzbl 0x4b(%r14), %eax
testl %eax, %eax
je 0x7a04
xorl %ebp, %ebp
movl %eax, %eax
imulq %r13, %rax
addq %r15, %rax
cmpb $0x0, (%rbp,%rax)
je 0x79f8
movl %r12d, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x33f0
movzbl 0x4b(%r14), %eax
imulq %r13, %rax
addq %rbp, %rax
leaq (%rax,%rax,4), %rdi
shlq $0x3, %rdi
addq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x6412
movzbl 0x4b(%r14), %eax
imulq %r13, %rax
addq %r15, %rax
movzbl (%rbp,%rax), %eax
shll $0x8, %eax
addl %eax, %r12d
movzbl 0x4b(%r14), %eax
incq %rbp
cmpl %eax, %ebp
jb 0x79a4
incq %r13
movzbl 0x4a(%r14), %eax
cmpl %eax, %r13d
jb 0x7999
movb 0x7(%rsp), %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5a60
movq %r12, %rdi
callq 0x3250
cmpb $0x0, 0x4a(%r14)
je 0x7b3a
movq %rax, %r15
leaq 0x4e(%r14), %r13
xorl %ebx, %ebx
movq %r13, 0x8(%rsp)
movzbl 0x4b(%r14), %eax
testl %eax, %eax
je 0x7b2a
xorl %ebp, %ebp
movl %eax, %eax
imulq %rbx, %rax
addq %r13, %rax
cmpb $0x0, (%rbp,%rax)
je 0x7b1a
movq %r12, %rdi
callq 0x3250
movl %r15d, %ecx
subl %eax, %ecx
je 0x7ae3
movq %r15, 0x10(%rsp)
movq %r12, %r15
movslq %ecx, %r12
movq %r12, %rdi
callq 0x3030
movq %rax, %r13
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x3180
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %r12
movq 0x10(%rsp), %r15
callq 0x33c0
movq %r13, %rdi
movq 0x8(%rsp), %r13
callq 0x33b0
movzbl 0x4b(%r14), %eax
imulq %rbx, %rax
addq %rbp, %rax
leaq (%rax,%rax,4), %rdi
shlq $0x3, %rdi
addq 0x8(%r14), %rdi
movq %r12, %rsi
callq 0x67d0
movzbl 0x4b(%r14), %eax
imulq %rbx, %rax
addq %r13, %rax
movzbl (%rbp,%rax), %eax
shll $0x8, %eax
addl %eax, %r15d
movzbl 0x4b(%r14), %eax
incq %rbp
cmpl %eax, %ebp
jb 0x7a7a
incq %rbx
movzbl 0x4a(%r14), %eax
cmpl %eax, %ebx
jb 0x7a6b
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_O1/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:
movzbl 0x4a(%rdi), %eax
testq %rax, %rax
je 0x7bf2
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movzbl 0x4b(%rdi), %edx
movq 0x8(%rdi), %rsi
xorl %r8d, %r8d
testq %rdx, %rdx
je 0x7be2
movq %r8, %r9
imulq %rdx, %r9
xorl %r10d, %r10d
leaq (%r9,%r10), %r11
leaq (%r11,%r11,4), %rcx
cmpb $0x1, 0x19(%rsi,%rcx,8)
jne 0x7bcf
leaq (%rsi,%rcx,8), %rcx
movzbl 0x16(%rcx), %r14d
testq %r14, %r14
je 0x7bd3
movq 0x20(%rcx), %r15
shll $0x5, %r14d
movl $0x100, %ebx            # imm = 0x100
xorl %r12d, %r12d
movb 0x3(%r15,%r12), %cl
movl $0x80, %ebp
shll %cl, %ebp
movzwl 0x6(%r15,%r12), %ecx
testl %ecx, %ecx
cmovnel %ecx, %ebp
addl %ebp, %ebx
addq $0x20, %r12
cmpq %r12, %r14
jne 0x7ba8
shrl $0x8, %ebx
jmp 0x7bd5
xorl %ebx, %ebx
jmp 0x7bd5
movb $0x1, %bl
movb %bl, 0x4e(%rdi,%r11)
incq %r10
cmpq %rdx, %r10
jne 0x7b7b
incq %r8
cmpq %rax, %r8
jne 0x7b6c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x91b6
cmpl $-0x1, %eax
je 0x830a
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 0x3410
movq %rax, %r14
callq 0x3050
cmpl $0x22, (%rax)
je 0x831d
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 0x33e0
leaq 0x8628(%rip), %rsi      # 0x10959
movl $0xc, %edx
movq %r14, %rdi
callq 0x3320
movq 0x8(%rbx), %rax
movq 0x8(%rax,%r15), %rax
movq (%rax,%r12,8), %rsi
leaq 0x48(%rsp), %rdi
callq 0x32a0
movl $0x50, %edi
callq 0x3150
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x85f4(%rip), %rsi      # 0x10966
leaq 0x85fe(%rip), %rdx      # 0x10977
leaq 0x8(%rsp), %rdi
callq 0x3ffc
leaq 0x50(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x34c0
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rcx
movq %rbx, %rdi
movl $0x42, %edx
callq 0x7dfc
leaq 0xd9d8(%rip), %rsi      # 0x15d88
leaq -0x55d(%rip), %rdx      # 0x7e5a
movq %rbx, %rdi
callq 0x34f0
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x83dd
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32d0
xorl %ebp, %ebp
jmp 0x83e7
movq %rax, %r14
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x8406
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32d0
jmp 0x8406
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x8418
movq %rbx, %rdi
callq 0x31f0
jmp 0x8418
movq %rax, %r14
movq 0xdba1(%rip), %rsi      # 0x15fc0
leaq 0x48(%rsp), %rdi
callq 0x3160
leaq 0xb8(%rsp), %rdi
callq 0x3100
movq %r14, %rdi
callq 0xcdb0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movl %r8d, %ebp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
addq %rsi, %rdx
callq 0x3f6c
movq 0x8(%r14), %rdi
movl %r15d, %esi
callq 0x91b6
cmpl $-0x1, %eax
je 0x84ae
movq 0x8(%r14), %rcx
cltq
shlq $0x4, %rax
movq 0x8(%rcx,%rax), %rax
movslq %ebp, %rcx
movq (%rax,%rcx,8), %r14
movq 0x8(%rbx), %r15
movq %r14, %rdi
callq 0x3130
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x3480
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x84d1
movq (%r12), %rsi
incq %rsi
callq 0x32d0
movq %r14, %rdi
callq 0xcdb0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x18, %rsp
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, 0x10(%rsp)
movslq (%rdi), %rbx
testq %rbx, %rbx
jle 0x8d5c
movq (%r12), %r14
xorl %r15d, %r15d
xorl %ebp, %ebp
movq (%r14,%r15,8), %rdi
callq 0x3130
addl %eax, %ebp
incl %ebp
incq %r15
cmpq %r15, %rbx
jne 0x8d45
jmp 0x8d5e
xorl %ebp, %ebp
leal 0x10(,%rbx,8), %r14d
leal 0x10(%rbp,%rbx,8), %eax
movslq %eax, %r15
movq %r13, %rdi
callq 0x3130
leaq (%r15,%rax), %rdi
incq %rdi
callq 0x33d0
movq %rax, %r15
movq %r12, 0x8(%rsp)
movq (%r12), %r12
testq %r12, %r12
sete %al
testl %ebx, %ebx
sete %cl
orb %al, %cl
movslq %r14d, %r14
movslq %ebp, %rbp
jne 0x8db2
leaq (%r15,%r14), %rdi
movq (%r12), %rsi
movq %rbp, %rdx
callq 0x3220
addq %r15, %r14
addq %r14, %rbp
movq %r13, %rdi
callq 0x3130
leaq 0x1(%rax), %rdx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x3220
testl %ebx, %ebx
js 0x8df9
leal 0x1(%rbx), %r13d
xorl %ebp, %ebp
movq %r14, (%r15,%rbp,8)
cmpq %rbp, %rbx
je 0x8df1
movq (%r12,%rbp,8), %rdi
callq 0x3130
addq %rax, %r14
incq %r14
incq %rbp
cmpq %rbp, %r13
jne 0x8dd9
testq %r12, %r12
sete %al
movq $0x0, 0x8(%r15,%rbx,8)
testl %ebx, %ebx
sete %cl
orb %al, %cl
jne 0x8e19
movq %r12, %rdi
callq 0x3350
movq 0x8(%rsp), %rax
movq %r15, (%rax)
movq 0x10(%rsp), %rax
incl (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8f4e
movq %rsi, %r14
movq %rdi, %r13
movl %edx, %ebp
testl %r12d, %r12d
jle 0x8e82
xorl %r15d, %r15d
xorl %ebx, %ebx
cmpq %r15, %rbp
je 0x8e78
movq (%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x3130
addl %eax, %ebx
incl %ebx
incq %r15
cmpq %r15, %r12
jne 0x8e63
jmp 0x8e84
xorl %ebx, %ebx
leal (%rbx,%r12,8), %eax
movslq %eax, %rdi
callq 0x33d0
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x8eb4
leaq 0x7b37(%rip), %rdi      # 0x109d8
leaq 0x7b4e(%rip), %rsi      # 0x109f6
movl $0x55, %edx
xorl %eax, %eax
callq 0x3060
movl (%r13), %eax
testl %eax, %eax
jle 0x8f35
shll $0x3, %r12d
movslq %r12d, %rax
movq 0x8(%rsp), %r12
addq %rax, %r12
xorl %r15d, %r15d
xorl %ebx, %ebx
movq %rbp, 0x10(%rsp)
cmpq %r15, %rbp
je 0x8f29
movq (%r14), %rax
movq %r14, %rbp
movq %r13, %r14
movq (%rax,%r15,8), %r13
movq %r13, %rdi
callq 0x3130
leaq 0x1(%rax), %rdx
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %r13
movq %rbp, %r14
movq 0x10(%rsp), %rbp
callq 0x3220
movslq %ebx, %rbx
movq 0x8(%rsp), %rax
movq %r12, (%rax,%rbx,8)
movq (%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x3130
addq %rax, %r12
incq %r12
incl %ebx
incq %r15
movslq (%r13), %rax
cmpq %rax, %r15
jl 0x8ed5
cltq
movq 0x8(%rsp), %rcx
movq $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_O1/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 %rbp
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x917e
movq %rsi, %rbx
movb (%rsi), %al
testb %al, %al
je 0x914b
movq %rdi, %r14
addq $0x28, %rbx
xorl %ebp, %ebp
movq -0x20(%rbx), %rdx
movsbl %al, %esi
movq %r14, %rdi
callq 0x8f66
testl %eax, %eax
je 0x91af
movb (%rbx), %al
incl %ebp
addq $0x28, %rbx
testb %al, %al
jne 0x912c
movl $0xfffffffe, 0xd44b(%rip) # imm = 0xFFFFFFFE
movabsq $0x206e776f6e6b6e55, %rax # imm = 0x206E776F6E6B6E55
movq %rax, 0xd44a(%rip)      # 0x165b0
movabsq $0x6e6f6974706f20, %rax # imm = 0x6E6F6974706F20
movq %rax, 0xd440(%rip)      # 0x165b7
movl $0xfffffffe, %ebp       # imm = 0xFFFFFFFE
jmp 0x91af
movl $0xffffffff, 0xd418(%rip) # imm = 0xFFFFFFFF
movabsq $0x6c616e7265746e49, %rax # imm = 0x6C616E7265746E49
movq %rax, 0xd417(%rip)      # 0x165b0
movabsq $0x726f727265206c, %rax # imm = 0x726F727265206C
movq %rax, 0xd40d(%rip)      # 0x165b7
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/pelrun[P]aft/optionParser.c
// Function: optionIndex
int optionIndex(struct SOptionOut *cmdLine, char c)
{
	int i=0;
	c = toupper(c);
	while (cmdLine[i].shortName != 0 && toupper(cmdLine[i].shortName) != c)
		i++;
	if (cmdLine[i].shortName == 0)
		RET_ERROR(ERROR_UNKNOWN, "Unknown option")
	else
		return i;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x3070
movsbq (%rbx), %rdi
testq %rdi, %rdi
sete %sil
je 0x9205
movq (%rax), %rcx
movsbq %bpl, %rax
movsbl (%rcx,%rax,4), %edx
xorl %eax, %eax
cmpl %edx, (%rcx,%rdi,4)
je 0x9200
addq $0x10, %rbx
xorl %eax, %eax
movsbq (%rbx), %rdi
testq %rdi, %rdi
sete %sil
je 0x9205
incl %eax
addq $0x10, %rbx
cmpl %edx, (%rcx,%rdi,4)
jne 0x91e8
testb %sil, %sil
je 0x9236
movl $0xffffffff, 0xd391(%rip) # imm = 0xFFFFFFFF
movabsq $0x206e776f6e6b6e55, %rax # imm = 0x206E776F6E6B6E55
movq %rax, 0xd390(%rip)      # 0x165b0
movabsq $0x6e6f6974706f20, %rax # imm = 0x6E6F6974706F20
movq %rax, 0xd386(%rip)      # 0x165b7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %r12
movq (%rdi), %rax
testq %rax, %rax
movq %rax, 0x8(%rsp)
je 0x9273
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
incl %ebp
cmpb $0x0, (%rax)
leaq 0x10(%rax), %rax
jne 0x9266
jmp 0x9275
xorl %ebp, %ebp
movl %ebp, %ebx
movq %rbx, %r13
shlq $0x4, %r13
addq $0x20, %r13
movq %r13, %rdi
callq 0x33d0
testq %rax, %rax
je 0x934f
movq %r12, 0x10(%rsp)
testl %ebp, %ebp
movq %rax, (%rsp)
je 0x92b9
movq %rbx, %rdx
shlq $0x4, %rdx
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x3220
movq (%rsp), %rax
movb (%r14), %cl
shlq $0x4, %rbx
leaq (%rax,%rbx), %rbp
movb %cl, (%rax,%rbx)
movl $0x0, 0x4(%rax,%rbx)
cmpl $0x0, 0x18(%r14)
je 0x930c
cmpl $0x0, 0x18(%r14)
jle 0x9314
movq (%rsp), %rax
addq %rax, %rbx
addq $0x4, %rbx
leaq 0x8(%rbp), %r13
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x8d1b
incq %r12
movslq 0x18(%r14), %rax
cmpq %rax, %r12
jl 0x92ef
jmp 0x9314
movq $0x0, 0x8(%rbp)
movb $0x0, 0x10(%rbp)
movl $0x0, 0x14(%rbp)
movq $0x0, 0x18(%rbp)
movq 0x10(%rsp), %rbx
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x9339
callq 0x3350
movq (%rsp), %rax
movq %rax, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addl $0x2, %ebp
leaq 0x772a(%rip), %rdi      # 0x10a83
leaq 0x7696(%rip), %rsi      # 0x109f6
movl $0xba, %edx
xorl %eax, %eax
callq 0x3060
leaq 0x772a(%rip), %rdi      # 0x10a9d
movl $0x10, %edx
movl %ebp, %esi
movq %r13, %rcx
xorl %eax, %eax
callq 0x3060
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O1/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 0x93c6
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movb -0x8(%r14), %bpl
cmpl $0x0, -0x4(%r14)
je 0x93b1
movq (%r14), %rdi
callq 0x3350
addq $0x10, %r14
testb %bpl, %bpl
jne 0x939e
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3350
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7388(%rip), %rsi      # 0x10a69
callq 0x3340
testq %rax, %rax
je 0x97f2
movq %rax, %r13
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %rax, %rdi
callq 0x3490
testl %eax, %eax
jne 0x97d4
movabsq $0x100000600, %rbx      # imm = 0x100000600
movq %r13, %rdi
callq 0x34a0
movl %eax, %ebp
movl %eax, %r14d
shll $0x18, %r14d
cmpl $0x9000000, %r14d       # imm = 0x9000000
je 0x9741
cmpl $0x20000000, %r14d      # imm = 0x20000000
je 0x9741
cmpl $0xa000000, %r14d       # imm = 0xA000000
jne 0x974d
movq %r13, %rdi
callq 0x3490
testl %eax, %eax
je 0x9715
movq %r13, %rdi
callq 0x3490
testl %eax, %eax
jne 0x97c4
cmpl $0x3b000000, %r14d      # imm = 0x3B000000
jne 0x9779
leaq 0x110(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
movq %r13, %rdx
callq 0x34b0
jmp 0x97c4
xorl %r14d, %r14d
cmpb $0x20, %bpl
ja 0x978c
movzbl %bpl, %eax
btq %rax, %rbx
jb 0x97ac
movq %r13, %rdi
callq 0x3490
testl %eax, %eax
jne 0x97ac
movb %bpl, 0x10(%rsp,%r14)
incq %r14
movq %r13, %rdi
callq 0x34a0
movl %eax, %ebp
jmp 0x977c
movl %r14d, %eax
movb $0x0, 0x10(%rsp,%rax)
movq %r12, %rdi
movq %r15, %rsi
leaq 0x10(%rsp), %rdx
callq 0x8d1b
movq %r13, %rdi
callq 0x3490
testl %eax, %eax
je 0x9715
movq %r13, %rdi
callq 0x32b0
movq %r12, %rdi
movq %r15, %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x93c7
jmp 0x9819
movl $0xffffffff, 0xcda4(%rip) # imm = 0xFFFFFFFF
movups 0x72ea(%rip), %xmm0     # 0x10aed
movaps %xmm0, 0xcda6(%rip)     # 0x165b0
movl $0x656c69, 0xcdac(%rip) # imm = 0x656C69
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x93c7
testl %eax, %eax
je 0x9a3d
movl 0xcb75(%rip), %eax      # 0x165a0
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %ebp, %ebp
jne 0x9a88
movq (%r15), %rdi
movl $0x63, %esi
callq 0x91b6
cmpl $-0x1, %eax
je 0x9a82
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 0x96bd
testl %eax, %eax
sete %cl
movl 0xcb20(%rip), %eax      # 0x165a0
jmp 0x9a84
movb $0x1, %cl
testb %cl, %cl
je 0x9a2b
xorl %eax, %eax
testl %ebx, %ebx
js 0x9a2b
cmpl %ebx, (%r14)
jg 0x9a2b
leaq 0x70a0(%rip), %rsi      # 0x10b3a
movq %rsp, %r14
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x3090
movl $0xfffffffb, 0xcaed(%rip) # imm = 0xFFFFFFFB
leaq 0xcaf6(%rip), %rdi      # 0x165b0
movq %r14, %rsi
callq 0x3270
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
jmp 0x9a2b
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3420
cmpl $-0x1, %eax
je 0xa037
leaq 0xc(%rsp), %rdx
andb $-0x7, (%rdx)
movl $0x5418, %esi           # imm = 0x5418
movl %ebx, %edi
xorl %eax, %eax
callq 0x3420
cmpl $-0x1, %eax
je 0xa045
movl %ebx, %edi
callq 0x3570
addq $0x10, %rsp
popq %rbx
retq
leaq 0x6bdf(%rip), %rdi      # 0x10c1d
callq 0x3230
jmp 0xa00f
leaq 0x6bea(%rip), %rdi      # 0x10c36
callq 0x3230
jmp 0xa02a
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3420
cmpl $-0x1, %eax
je 0xa0ff
leaq 0xc(%rsp), %rdx
orb $0x2, (%rdx)
movl $0x5418, %esi           # imm = 0x5418
movl %ebx, %edi
xorl %eax, %eax
callq 0x3420
cmpl $-0x1, %eax
je 0xa10d
addq $0x10, %rsp
popq %rbx
retq
leaq 0x6b17(%rip), %rdi      # 0x10c1d
callq 0x3230
jmp 0xa0de
leaq 0x6b22(%rip), %rdi      # 0x10c36
callq 0x3230
jmp 0xa0f9