LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/pelrun[P]aft/CAksFileTransfert.cpp
// Function: CAksFileTransfert::OpenFile(CAksCommand const&)
bool CAksFileTransfert::OpenFile(const CAksCommand &cmd)
{
	if (cmd != AksOpenFile)
		return false;

	ReadWaitBuffer(_amsFilename, 12);
	_amsFilename[12] = 0;

	if (_inStream != NULL)
		delete _inStream;

	std::string fileName = GetFilename();
	
	std::cout << "file : " << fileName << std::endl;
	
	_inStream = new std::ifstream(fileName.c_str(), std::ios::binary | std::ios::in);

	if (_inStream->good())
	{
		Acknowledge();
		
		return true;
	}
	else
	{
		perror("File access error");
		NotAcknowledge();
		return false;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpl $0xfc, (%rsi)
jne 0x51b6
movq %rdi, %rbx
leaq 0x68(%rdi), %rsi
movl $0xc, %edx
callq 0x55a4
movb $0x0, 0x74(%rbx)
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x50f7
movq (%rdi), %rax
callq *0x8(%rax)
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x4246
movq 0x10ebf(%rip), %rdi     # 0x15fc8
leaq 0xb57a(%rip), %rsi      # 0x1068a
movl $0x7, %edx
callq 0x3320
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x10e9e(%rip), %rdi     # 0x15fc8
callq 0x3320
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
movl $0x208, %edi            # imm = 0x208
callq 0x32c0
movq %rax, %r14
movq (%rsp), %rsi
movq %rax, %rdi
movl $0xc, %edx
callq 0x3530
movq %r14, 0xa0(%rbx)
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%r14,%rax)
sete %bpl
jne 0x51c3
movq %rbx, %rdi
callq 0x5212
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x51b8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32d0
jmp 0x51b8
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xb4c8(%rip), %rdi      # 0x10692
callq 0x3230
movq %rbx, %rdi
callq 0x5270
jmp 0x5199
movq %rax, %rbx
movl $0x208, %esi            # imm = 0x208
movq %r14, %rdi
callq 0x32d0
jmp 0x51ee
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5209
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32d0
movq %rbx, %rdi
callq 0xce30
nop
// File: /workspace/github_cpp_makefile_star2_O3/pelrun[P]aft/CCPCBooster.cpp
// Function: CCPCBooster::OpenPort()
void CCPCBooster::OpenPort()
{
	if (_currentState == PortOpened)
	{
		ClosePort();
	}

	_currentState = PortFailed;

	if (RS232_OpenComport(_COMPort.c_str(), 115200, "8N1", &_COMPortHandle) == 0)
	{
	    _currentState = PortOpened ;
	}
	
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x30(%rdi)
jne 0x541e
movl 0x8(%rbx), %edi
callq 0xa070
movl $0x1, 0x30(%rbx)
movq 0x10(%rbx), %rdi
leaq 0x8(%rbx), %rcx
leaq 0xb270(%rip), %rdx      # 0x106a4
movl $0x1c200, %esi          # imm = 0x1C200
callq 0x9b50
testl %eax, %eax
jne 0x5449
movl $0x0, 0x30(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pelrun[P]aft/CCPCBooster.cpp
// Function: CCPCBooster::ReadWaitWord(unsigned short&)
void CCPCBooster::ReadWaitWord(unsigned short &val)
{
	unsigned char byte1, byte2;

	ReadWaitByte(byte1);
	ReadWaitByte(byte2);

  val = byte2<<8 | byte1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xf(%rsp), %r15
movl 0x8(%r14), %edi
movq %r15, %rsi
movl $0x1, %edx
callq 0xa045
cmpl $0x1, %eax
jne 0x552c
leaq 0xe(%rsp), %r15
movl 0x8(%r14), %edi
movq %r15, %rsi
movl $0x1, %edx
callq 0xa045
cmpl $0x1, %eax
jne 0x5547
movzbl 0xe(%rsp), %eax
shll $0x8, %eax
movzbl 0xf(%rsp), %ecx
orl %eax, %ecx
movw %cx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pelrun[P]aft/CCPCBooster.cpp
// Function: CCPCBooster::ReadWaitBuffer(unsigned char*, long)
bool CCPCBooster::ReadWaitBuffer(unsigned char *buffer, const  long nbBytes)
{
	long bytesLeft = nbBytes;
  
	while(bytesLeft != 0)
	{
		int i = RS232_PollComport(_COMPortHandle, buffer, bytesLeft);
		if (i >= 0) {
			bytesLeft -= i;
			buffer += i;
		}
    else
    {
      // error!
      return false;
    }
	}
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %r15
testq %rdx, %rdx
je 0x55d5
movl 0x8(%r14), %edi
movq %rbx, %rsi
movl %r15d, %edx
callq 0xa045
movl %eax, %ecx
movq %r15, %rdx
subq %rcx, %rdx
addq %rcx, %rbx
testl %eax, %eax
jns 0x55af
testq %r15, %r15
sete %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pelrun[P]aft/CCPCBooster.cpp
// Function: CCPCBooster::WriteBuffer(unsigned char*, long)
bool CCPCBooster::WriteBuffer(unsigned char *buffer, const  long nbBytes)
{
	long bytesLeft = nbBytes;
  
	while(bytesLeft != 0)
	{
		int i = RS232_SendBuf(_COMPortHandle, buffer, bytesLeft);
		if (i >= 0) {
			bytesLeft -= i;
			buffer += i;
		}
    else
    {
      // error!
      return false;
    }
	}
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %r15
testq %rdx, %rdx
je 0x5621
movl 0x8(%r14), %edi
movq %rbx, %rsi
movl %r15d, %edx
callq 0xa068
movl %eax, %ecx
movq %r15, %rdx
subq %rcx, %rdx
addq %rcx, %rbx
testl %eax, %eax
jns 0x55fb
testq %r15, %r15
sete %al
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/pelrun[P]aft/CDSKFile.cpp
// Function: CSDSKDiscHeader::DisplayInfo(std::ostream&) const
void CSDSKDiscHeader::DisplayInfo(std::ostream &str) const
{
	str << Header;
	str << "\tCreator\t:" << Creator << std::endl;
	str << "\tNbTrack\t:" << (int)NbTrack << std::endl;
	str << "\tNbSide\t:" << (int)NbSide << std::endl;
	str << "\tTrackSize\t:" << (int)TrackSize << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %r15
movq %r15, %rdi
callq 0x3130
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x3320
leaq 0xaf49(%rip), %rsi      # 0x10743
movl $0xa, %edx
movq %rbx, %rdi
callq 0x3320
leaq 0x2b(%r14), %r15
movq %r15, %rdi
callq 0x3130
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x3320
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
leaq 0xaeff(%rip), %rsi      # 0x1074e
movl $0xa, %edx
movq %rbx, %rdi
callq 0x3320
movzbl 0x3a(%r14), %esi
movq %rbx, %rdi
callq 0x3500
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
leaq 0xaebf(%rip), %rsi      # 0x10759
movl $0x9, %edx
movq %rbx, %rdi
callq 0x3320
movzbl 0x3b(%r14), %esi
movq %rbx, %rdi
callq 0x3500
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
leaq 0xae7e(%rip), %rsi      # 0x10763
movl $0xc, %edx
movq %rbx, %rdi
callq 0x3320
movzwl 0x3c(%r14), %esi
movq %rbx, %rdi
callq 0x3500
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x31d0
// File: /workspace/github_cpp_makefile_star2_O3/pelrun[P]aft/CDSKFile.cpp
// Function: CEDSKDiscHeader::CEDSKDiscHeader()
CEDSKDiscHeader::CEDSKDiscHeader() :
NbTrack(0),
NbSide(0),
Unused(0)
{
	char h[] = "EXTENDED CPC DSK File\r\nDisk-Info\r\n";
	char c[] = "CDSKFile";

	strcpy((char*)Header, h);
	strcpy((char*)Creator, c);
	memset(TrackSizeTable, 0, 204);
}

// Assembly:
leaq 0x102ab(%rip), %rax     # 0x15be0
movq %rax, (%rdi)
movl $0x0, 0x3a(%rdi)
movaps 0xadda(%rip), %xmm0     # 0x10720
movups %xmm0, 0x8(%rdi)
movaps 0xaddf(%rip), %xmm0     # 0x10730
movups %xmm0, 0x18(%rdi)
movl $0xa0d6f, 0x27(%rdi)    # imm = 0xA0D6F
movabsq $0x656c69464b534443, %rax # imm = 0x656C69464B534443
movq %rax, 0x2b(%rdi)
movb $0x0, 0x33(%rdi)
addq $0x3e, %rdi
movl $0xcc, %edx
xorl %esi, %esi
jmp 0x3180
// File: /workspace/github_cpp_makefile_star2_O3/pelrun[P]aft/CDSKFile.cpp
// Function: CDSKSector::ReadData(std::istream&)
bool CDSKSector::ReadData(std::istream &str)
{
	Allocate();
	
	int sSize = GetDataSize();
	str.read((char*)Data, sSize);

	Update();

	return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x5da2
movzwl 0x6(%rbx), %eax
movb 0x3(%rbx), %cl
movl $0x80, %ebp
movl $0x80, %edx
shll %cl, %edx
testl %eax, %eax
cmovnel %eax, %edx
movq 0x8(%rbx), %rsi
movslq %edx, %rdx
movq %r14, %rdi
callq 0x3380
movzwl 0x6(%rbx), %eax
movb 0x3(%rbx), %cl
shll %cl, %ebp
testl %eax, %eax
cmovnel %eax, %ebp
movb $0x0, 0x10(%rbx)
testl %ebp, %ebp
jle 0x5d9a
movq 0x8(%rbx), %rax
movl %ebp, %ecx
xorl %edx, %edx
xorl %esi, %esi
addb (%rax,%rdx), %sil
movb %sil, 0x10(%rbx)
incq %rdx
cmpq %rdx, %rcx
jne 0x5d8a
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pelrun[P]aft/CDSKFile.cpp
// Function: CDSKSector::Allocate()
void CDSKSector::Allocate()
{
	if (Data != NULL)
		delete[] Data;
	Data = NULL;

	int sSize = GetDataSize();

	if (sSize != 0)
	{
		Data = new unsigned char[sSize];
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x5db4
callq 0x33b0
movq $0x0, 0x8(%rbx)
movzwl 0x6(%rbx), %edx
movb 0x3(%rbx), %cl
movl $0x80, %eax
shll %cl, %eax
testl %edx, %edx
cmovnel %edx, %eax
testl %eax, %eax
je 0x5ddf
movslq %eax, %rdi
callq 0x3030
movq %rax, 0x8(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pelrun[P]aft/CDSKFile.cpp
// Function: CDSKSector::Update()
int CDSKSector::GetDataSize()
{
	int sSize = 0;
	if (DataSize != 0)
	{
		sSize = DataSize;
	}
	else
	{
		sSize = (128 << SectorSize);
	}
	return sSize;
}

// Assembly:
movzwl 0x6(%rdi), %eax
movb 0x3(%rdi), %cl
movl $0x80, %edx
shll %cl, %edx
testl %eax, %eax
cmovnel %eax, %edx
movb $0x0, 0x10(%rdi)
testl %edx, %edx
jle 0x5e2b
movq 0x8(%rdi), %rax
movl %edx, %ecx
xorl %edx, %edx
xorl %esi, %esi
addb (%rax,%rdx), %sil
movb %sil, 0x10(%rdi)
incq %rdx
cmpq %rdx, %rcx
jne 0x5e1b
retq
// File: /workspace/github_cpp_makefile_star2_O3/pelrun[P]aft/CDSKFile.cpp
// Function: CDSKTrack::Read(std::istream&)
bool CDSKTrack::Read(std::istream &str)
{
	unsigned int trackPos = str.tellg();
	
	str.read((char*)&Header, 13);
	str.read((char*)&Unused, 3);
	str.read((char*)&TrackNumber, 1);
	str.read((char*)&SideNumber, 1);
	str.read((char*)&DataRate, 1);
	str.read((char*)&RecordingMode, 1);
	str.read((char*)&SectorSize, 1);
	str.read((char*)&NbSector, 1);
	str.read((char*)&GAP3Size, 1);
	str.read((char*)&FillByte, 1);

	Allocate();

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

	str.seekg(trackPos + 0x100);
	for (s=0 ; s<NbSector ; s++)
	{
		Sectors[s].ReadData(str);
	}

	Update();

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3510
movq %rax, %r15
movl $0xd, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3380
leaq 0xe(%rbx), %rsi
movl $0x3, %edx
movq %r14, %rdi
callq 0x3380
leaq 0x11(%rbx), %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0x3380
leaq 0x12(%rbx), %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0x3380
leaq 0x13(%rbx), %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0x3380
leaq 0x14(%rbx), %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0x3380
leaq 0x15(%rbx), %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0x3380
leaq 0x16(%rbx), %r12
movl $0x1, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x3380
leaq 0x17(%rbx), %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0x3380
leaq 0x18(%rbx), %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0x3380
movq %rbx, %rdi
callq 0x6544
cmpb $0x0, 0x16(%rbx)
je 0x64ea
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x20(%rbx), %rdi
addq %r13, %rdi
movq %r14, %rsi
callq 0x5c18
incq %rbp
movzbl 0x16(%rbx), %eax
addq $0x20, %r13
cmpq %rax, %rbp
jb 0x64cb
addl $0x100, %r15d           # imm = 0x100
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x33a0
cmpb $0x0, (%r12)
je 0x652a
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x20(%rbx), %rdi
addq %r15, %rdi
movq %r14, %rsi
callq 0x5d34
incq %r12
movzbl 0x16(%rbx), %eax
addq $0x20, %r15
cmpq %rax, %r12
jb 0x650b
movq %rbx, %rdi
callq 0x65fa
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pelrun[P]aft/CDSKFile.cpp
// Function: CDSKTrack::Allocate()
void CDSKTrack::Allocate()
{
	if (Sectors != NULL)
		delete[] Sectors;
	Sectors = NULL;
	
	if (NbSector == 0)
		return;

	Sectors = new CDSKSector[NbSector];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %r12
testq %r12, %r12
je 0x6597
leaq -0x8(%r12), %r14
movq -0x8(%r12), %r15
testq %r15, %r15
je 0x6584
movq %r15, %r13
shlq $0x5, %r13
movq -0x18(%r12,%r13), %rdi
testq %rdi, %rdi
je 0x657e
callq 0x33b0
addq $-0x20, %r13
jne 0x656f
shlq $0x5, %r15
orq $0x8, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3560
movq $0x0, 0x20(%rbx)
movzbl 0x16(%rbx), %r15d
testq %r15, %r15
je 0x65ef
movl %r15d, %r14d
shll $0x5, %r14d
leaq 0x8(%r14), %rdi
callq 0x3030
movq %r15, (%rax)
leaq 0x8(%rax), %rcx
addq $0x20, %rax
xorl %edx, %edx
movabsq $-0x100000000, %rsi     # imm = 0xFFFFFFFF00000000
xorps %xmm0, %xmm0
movq %rsi, -0x4(%rax,%rdx)
movups %xmm0, -0x18(%rax,%rdx)
movb $0x0, -0x8(%rax,%rdx)
addq $0x20, %rdx
cmpq %rdx, %r14
jne 0x65d3
movq %rcx, 0x20(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pelrun[P]aft/CDSKFile.cpp
// Function: CDSKTrack::Update()
void CDSKTrack::Update()
{
	for (int s=0 ; s<NbSector ; s++)
	{
		Sectors[s].Index = s;
	}

	for (int s1=0 ; s1<NbSector-1 ; s1++)
	{
		for (int s2=s1+1 ; s2 < NbSector ; s2++)
		{
			if (Sectors[s1].Checksum == Sectors[s2].Checksum && 
				Sectors[s1].SectorID == Sectors[s2].SectorID && 
				Sectors[s1].GetDataSize() == Sectors[s2].GetDataSize())
			{
				if (memcmp(Sectors[s1].Data, Sectors[s2].Data, Sectors[s1].GetDataSize()) == 0)
				{
					Sectors[s2].CopyOf = s1;
				}
			}
		}
	}

	Formated = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, 0x10(%rsp)
movzbl 0x16(%rdi), %eax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x679b
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rsp), %rdx
leal 0x1(%rdx), %ecx
andl $-0x2, %ecx
decq %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
addq $0x34, %rax
movdqa 0xa074(%rip), %xmm1     # 0x106c0
xorl %edx, %edx
movdqa 0xa07a(%rip), %xmm2     # 0x106d0
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0xa07a(%rip), %xmm4     # 0x106e0
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %esi
notl %esi
testb $0x1, %sil
je 0x669b
movl %edx, -0x20(%rax)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x66af
leal 0x1(%rdx), %esi
movl %esi, (%rax)
addq $0x2, %rdx
paddq %xmm4, %xmm1
addq $0x40, %rax
cmpq %rdx, %rcx
jne 0x6666
cmpl $0x1, 0x8(%rsp)
je 0x679b
movq 0x8(%rsp), %rax
decl %eax
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x18(%rsp)
leaq 0x22(%rax), %rbx
movl $0x1, %ebp
xorl %eax, %eax
movq %rax, %rcx
incq %rax
movq %rax, 0x28(%rsp)
movq %rcx, %rax
movq %rcx, 0x30(%rsp)
shlq $0x5, %rax
movq 0x18(%rsp), %rcx
leaq (%rcx,%rax), %r15
movb 0x10(%rcx,%rax), %r12b
movq 0x8(%rsp), %r14
movq %rbx, %r13
cmpb 0xe(%r13), %r12b
jne 0x6778
movb 0x2(%r15), %al
cmpb (%r13), %al
jne 0x6778
movb 0x3(%r15), %cl
movl $0x80, %eax
shll %cl, %eax
movzwl 0x6(%r15), %ecx
testl %ecx, %ecx
cmovnel %ecx, %eax
movzwl 0x4(%r13), %edx
movb 0x1(%r13), %cl
movl $0x80, %esi
shll %cl, %esi
testl %edx, %edx
cmovnel %edx, %esi
cmpl %esi, %eax
jne 0x6778
movq 0x8(%r15), %rdi
movq 0x6(%r13), %rsi
movslq %eax, %rdx
callq 0x32e0
testl %eax, %eax
jne 0x6778
movq 0x30(%rsp), %rax
movl %eax, 0x16(%r13)
addq $0x20, %r13
decq %r14
cmpq %r14, %rbp
jne 0x671d
incq %rbp
addq $0x20, %rbx
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
jne 0x66f0
movq 0x10(%rsp), %rax
movb $0x1, 0x19(%rax)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x68a8
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x20(%r14), %rdi
addq %r13, %rdi
movq %rbx, %rsi
callq 0x5ca6
incq %rbp
movzbl 0x16(%r14), %eax
addq $0x20, %r13
cmpq %rax, %rbp
jb 0x6888
movq %rbx, %rdi
callq 0x3250
subq %rax, %r15
addq $0x100, %r15            # imm = 0x100
testl %r15d, %r15d
je 0x68f0
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 0x693b
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 0x6900
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_O3/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 0x698f
movzbl 0x16(%rdi), %edx
testq %rdx, %rdx
je 0x6990
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 0x696b
retq
movl $0x100, %eax            # imm = 0x100
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6e73
movq %rsi, %rbx
movq %rdi, %r14
movb 0x15(%rsi), %cl
cmpb %cl, 0x15(%rdi)
jne 0x6e73
movb 0x13(%r14), %cl
cmpb 0x13(%rbx), %cl
jne 0x6e71
movb 0x14(%r14), %cl
cmpb 0x14(%rbx), %cl
jne 0x6e71
movb 0x17(%r14), %cl
cmpb 0x17(%rbx), %cl
jne 0x6e71
movb 0x18(%r14), %cl
cmpb 0x18(%rbx), %cl
jne 0x6e71
testb %al, %al
je 0x6e9c
movq 0x20(%r14), %rax
movb 0x3(%rax), %bpl
leaq 0x10(%rsp), %rax
xorl %r13d, %r13d
movl %r13d, (%rax)
movq %r13, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %r13, 0x20(%rax)
leaq 0x40(%rsp), %rax
movl %r13d, (%rax)
movq %r13, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %r13, 0x20(%rax)
movl $0x2, %r15d
leaq 0x38(%rsp), %r12
movq 0x20(%r14), %rsi
cmpb %bpl, 0x1(%rsi,%r15)
jne 0x6e84
movq 0x20(%rbx), %rax
cmpb %bpl, 0x1(%rax,%r15)
jne 0x6e84
addq %r15, %rsi
leaq 0x8(%rsp), %rdi
callq 0x7d5e
movq 0x20(%rbx), %rsi
addq %r15, %rsi
movq %r12, %rdi
callq 0x7d5e
incq %r13
movzbl 0x16(%r14), %eax
addq $0x20, %r15
cmpq %rax, %r13
jb 0x6ddc
movq 0x30(%rsp), %rax
cmpq 0x60(%rsp), %rax
jne 0x6e84
movq 0x20(%rsp), %rbx
leaq 0x10(%rsp), %r15
cmpq %r15, %rbx
je 0x6ea1
movq 0x50(%rsp), %r14
movb 0x20(%rbx), %al
cmpb 0x20(%r14), %al
sete %bpl
jne 0x6e86
movq %rbx, %rdi
callq 0x3330
movq %rax, %rbx
movq %r14, %rdi
callq 0x3330
movq %rax, %r14
cmpq %r15, %rbx
jne 0x6e47
jmp 0x6e86
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
leaq 0x38(%rsp), %rdi
callq 0x7d0e
leaq 0x8(%rsp), %rdi
callq 0x7d0e
jmp 0x6e73
movb $0x1, %bpl
jmp 0x6e73
movb $0x1, %bpl
jmp 0x6e86
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x7d0e
leaq 0x8(%rsp), %rdi
callq 0x7d0e
movq %rbx, %rdi
callq 0xce30
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x56d2
movb 0x4a(%r14), %cl
movb 0x4b(%r14), %r15b
movl %ecx, %eax
orb %r15b, %al
setne 0x3(%rsp)
je 0x7659
movb %cl, 0x4(%rsp)
movzbl %cl, %r13d
movzbl %r15b, %r12d
movq %r12, %rbp
imulq %r13, %rbp
leaq (,%rbp,4), %rax
addq %rbp, %rax
leaq 0x8(,%rax,8), %rdi
callq 0x3030
movq %rbp, (%rax)
leaq 0x8(%rax), %rcx
testq %rbp, %rbp
je 0x75dc
addq $0x28, %rax
imull %r13d, %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 0x75ae
movq %rcx, 0x8(%r14)
movb 0x4(%rsp), %dl
testb %dl, %dl
je 0x7659
movl $0x100, %eax            # imm = 0x100
xorl %esi, %esi
xorl %ebp, %ebp
xorl %r12d, %r12d
testb %r15b, %r15b
je 0x764d
movl %esi, 0x4(%rsp)
movl %eax, %r15d
leal (%r12,%rbp), %r13d
movl %eax, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x33f0
leaq (,%r13,4), %rdi
addq %r13, %rdi
shlq $0x3, %rdi
addq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x63f0
movzwl 0x4c(%r14), %eax
addl %r15d, %eax
incl %r12d
movzbl 0x4b(%r14), %r15d
cmpl %r15d, %r12d
jb 0x75fd
movb 0x4a(%r14), %dl
addl %r12d, %ebp
movl 0x4(%rsp), %esi
jmp 0x7650
xorl %r15d, %r15d
incl %esi
movzbl %dl, %ecx
cmpl %ecx, %esi
jb 0x75f1
movb 0x3(%rsp), %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5750
movb 0x4a(%r14), %al
testb %al, %al
je 0x774b
movb 0x4b(%r14), %cl
movl $0x100, %ebp            # imm = 0x100
xorl %r15d, %r15d
xorl %esi, %esi
movq %r14, 0x10(%rsp)
xorl %r13d, %r13d
testb %cl, %cl
je 0x773c
movl %esi, 0xc(%rsp)
movq %rbx, %rdi
callq 0x3250
movl %ebp, %ecx
subl %eax, %ecx
je 0x7701
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 0x67b4
movzwl 0x4c(%r14), %eax
addl %eax, %ebp
incl %r13d
movzbl 0x4b(%r14), %ecx
cmpl %ecx, %r13d
jb 0x76b7
movb 0x4a(%r14), %al
addl %r13d, %r15d
movl 0xc(%rsp), %esi
jmp 0x773e
xorl %ecx, %ecx
incl %esi
movzbl %al, %edx
cmpl %edx, %esi
jb 0x76a8
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_O3/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 $0x18, %rsp
movq %rdi, %r14
addq $0x10, %rdi
movq %rsi, 0x10(%rsp)
callq 0x59de
movb 0x4a(%r14), %cl
movb 0x4b(%r14), %r15b
movl %ecx, %eax
orb %r15b, %al
setne 0xb(%rsp)
je 0x7a61
movl %ecx, %ebp
movzbl %cl, %r12d
movzbl %r15b, %ebx
movq %rbx, %r13
imulq %r12, %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 0x79a6
addq $0x28, %rax
imull %r12d, %ebx
shll $0x3, %ebx
leaq (%rbx,%rbx,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 0x7978
movq %rcx, 0x8(%r14)
testb %bpl, %bpl
je 0x7a61
movl %ebp, %esi
leaq 0x4e(%r14), %r12
movl $0x100, %r13d           # imm = 0x100
xorl %ebp, %ebp
movl %r15d, %eax
xorl %edx, %edx
testb %al, %al
je 0x7a4e
movl %edx, 0xc(%rsp)
movzbl %al, %eax
xorl %ebx, %ebx
movl %eax, %eax
imulq %rbp, %rax
addq %r12, %rax
cmpb $0x0, (%rbx,%rax)
je 0x7a36
movl %r13d, %esi
movq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %edx, %edx
callq 0x33f0
movzbl 0x4b(%r14), %eax
imulq %rbp, %rax
addq %rbx, %rax
leaq (%rax,%rax,4), %rdi
shlq $0x3, %rdi
addq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x63f0
movzbl 0x4b(%r14), %eax
movq %rax, %rcx
imulq %rbp, %rcx
addq %r12, %rcx
movzbl (%rbx,%rcx), %ecx
shll $0x8, %ecx
addl %ecx, %r13d
movl %eax, %r15d
jmp 0x7a3a
movzbl %r15b, %eax
incq %rbx
cmpl %eax, %ebx
jb 0x79d7
movb 0x4a(%r14), %sil
movl %r15d, %eax
movl 0xc(%rsp), %edx
jmp 0x7a50
xorl %eax, %eax
incl %edx
movzbl %sil, %ecx
incq %rbp
cmpl %ecx, %edx
jb 0x79c6
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_O3/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 $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x5a5c
movq %rbx, 0x8(%rsp)
movq %rbx, %rdi
callq 0x3250
movb 0x4a(%r14), %cl
testb %cl, %cl
je 0x7bad
movq %rax, %r15
leaq 0x4e(%r14), %r12
movb 0x4b(%r14), %al
xorl %ebx, %ebx
movl %eax, %edx
xorl %edi, %edi
movq %r12, 0x18(%rsp)
testb %dl, %dl
je 0x7b9b
movl %edi, 0x14(%rsp)
movzbl %dl, %ecx
xorl %ebp, %ebp
movl %ecx, %ecx
imulq %rbx, %rcx
addq %r12, %rcx
cmpb $0x0, (%rbp,%rcx)
je 0x7b81
movq 0x8(%rsp), %rdi
callq 0x3250
movl %r15d, %ecx
subl %eax, %ecx
je 0x7b41
movq %r15, 0x20(%rsp)
movslq %ecx, %r12
movq %r12, %rdi
callq 0x3030
movq %rax, %r13
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x3180
movq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movq 0x20(%rsp), %r15
movq 0x18(%rsp), %r12
callq 0x33c0
movq %r13, %rdi
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 0x8(%rsp), %rsi
callq 0x67b4
movzbl 0x4b(%r14), %ecx
movq %rcx, %rax
imulq %rbx, %rax
addq %r12, %rax
movzbl (%rbp,%rax), %eax
shll $0x8, %eax
addl %eax, %r15d
movl %ecx, %eax
jmp 0x7b84
movzbl %al, %ecx
incq %rbp
cmpl %ecx, %ebp
jb 0x7ada
movb 0x4a(%r14), %cl
movl %eax, %edx
movl 0x14(%rsp), %edi
jmp 0x7b9d
xorl %edx, %edx
incl %edi
movzbl %cl, %esi
incq %rbx
cmpl %esi, %edi
jb 0x7ac9
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7c64
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 0x7c54
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 0x7c41
leaq (%rsi,%rcx,8), %rcx
movzbl 0x16(%rcx), %r14d
testq %r14, %r14
je 0x7c45
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 0x7c1a
shrl $0x8, %ebx
jmp 0x7c47
xorl %ebx, %ebx
jmp 0x7c47
movb $0x1, %bl
movb %bl, 0x4e(%rdi,%r11)
incq %r10
cmpq %rdx, %r10
jne 0x7bed
incq %r8
cmpq %rax, %r8
jne 0x7bde
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x924a
cmpl $-0x1, %eax
je 0x837a
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 0x838d
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 0x85b8(%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, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8584(%rip), %rsi      # 0x10966
leaq 0x858e(%rip), %rdx      # 0x10977
leaq 0x8(%rsp), %rdi
callq 0x400a
leaq 0x50(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x34c0
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rcx
movq %r14, %rdi
movl $0x42, %edx
callq 0x7e6c
leaq 0xd968(%rip), %rsi      # 0x15d88
leaq -0x55d(%rip), %rdx      # 0x7eca
movq %r14, %rdi
callq 0x34f0
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x844d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32d0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x8492
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32d0
jmp 0x8492
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x8485
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32d0
jmp 0x8485
movq %rax, %rbx
movq %r14, %rdi
callq 0x31f0
jmp 0x8492
movq %rax, %rbx
movq 0xdb27(%rip), %rsi      # 0x15fc0
leaq 0x48(%rsp), %rdi
callq 0x3160
leaq 0xb8(%rsp), %rdi
callq 0x3100
movq %rbx, %rdi
callq 0xce30
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3f74
movq 0x8(%r14), %rdi
movl %r15d, %esi
callq 0x924a
cmpl $-0x1, %eax
je 0x8528
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 0x854b
movq (%r12), %rsi
incq %rsi
callq 0x32d0
movq %r14, %rdi
callq 0xce30
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, 0x20(%rsp)
movslq (%rdi), %r12
movl %r12d, %ebx
movq %rsi, 0x18(%rsp)
movq (%rsi), %r15
testq %r12, %r12
jle 0x8dde
xorl %r14d, %r14d
xorl %ebp, %ebp
movq (%r15,%r14,8), %rdi
callq 0x3130
addl %eax, %ebp
incl %ebp
incq %r14
cmpq %r14, %rbx
jne 0x8dc7
jmp 0x8de0
xorl %ebp, %ebp
leal 0x10(,%r12,8), %r14d
leal 0x10(%rbp,%r12,8), %eax
movslq %eax, %r13
movq 0x8(%rsp), %rdi
callq 0x3130
leaq (%rax,%r13), %rdi
incq %rdi
callq 0x33d0
movq %rax, %r13
testq %r15, %r15
sete %al
movq %r12, 0x10(%rsp)
testl %r12d, %r12d
sete %cl
orb %al, %cl
movslq %r14d, %r12
cmpb $0x1, %cl
movb %cl, 0x7(%rsp)
jne 0x8e2d
movslq %ebp, %rbp
jmp 0x8e3f
leaq (%r12,%r13), %rdi
movq (%r15), %rsi
movslq %ebp, %rbp
movq %rbp, %rdx
callq 0x3220
addq %r13, %r12
addq %r12, %rbp
movq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3130
leaq 0x1(%rax), %rdx
movq %rbp, %rdi
movq %r14, %rsi
callq 0x3220
cmpl $0x0, 0x10(%rsp)
js 0x8e90
leaq 0x1(%rbx), %rbp
xorl %r14d, %r14d
movq %r12, (%r13,%r14,8)
cmpq %r14, %rbx
je 0x8e88
movq (%r15,%r14,8), %rdi
callq 0x3130
addq %rax, %r12
incq %r12
incq %r14
cmpq %r14, %rbp
jne 0x8e6f
movq 0x10(%rsp), %rcx
movq $0x0, 0x8(%r13,%rcx,8)
cmpb $0x0, 0x7(%rsp)
movq 0x20(%rsp), %rbx
jne 0x8eb4
movq %r15, %rdi
callq 0x3350
movl (%rbx), %ecx
movq 0x18(%rsp), %rax
movq %r13, (%rax)
incl %ecx
movl %ecx, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rdi, 0x10(%rsp)
movl (%rdi), %r12d
cmpl %edx, %r12d
jl 0x8fe5
movq %rsi, %r14
movl %edx, %ebp
testl %r12d, %r12d
jle 0x8f1c
xorl %r15d, %r15d
xorl %ebx, %ebx
cmpq %r15, %rbp
je 0x8f12
movq (%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x3130
addl %eax, %ebx
incl %ebx
incq %r15
cmpq %r15, %r12
jne 0x8efd
jmp 0x8f1e
xorl %ebx, %ebx
leal (%rbx,%r12,8), %eax
movslq %eax, %rdi
callq 0x33d0
movl %r12d, %edx
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x8f58
leaq 0x7a9a(%rip), %rdi      # 0x109d8
leaq 0x7ab1(%rip), %rsi      # 0x109f6
movl $0x55, %edx
xorl %eax, %eax
callq 0x3060
movq 0x10(%rsp), %rax
movl (%rax), %edx
testl %edx, %edx
jle 0x8fc8
shll $0x3, %r12d
movslq %r12d, %rcx
movq 0x8(%rsp), %r12
addq %rcx, %r12
xorl %ebx, %ebx
xorl %r15d, %r15d
cmpq %rbx, %rbp
je 0x8fbb
movq (%r14), %rax
movq (%rax,%rbx,8), %r13
movq %r13, %rdi
callq 0x3130
leaq 0x1(%rax), %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x3220
movslq %r15d, %r15
movq 0x8(%rsp), %rax
movq %r12, (%rax,%r15,8)
movq (%r14), %rax
movq (%rax,%rbx,8), %rdi
callq 0x3130
addq %rax, %r12
incq %r12
incl %r15d
movq 0x10(%rsp), %rax
movl (%rax), %edx
incq %rbx
movslq %edx, %rcx
cmpq %rcx, %rbx
jl 0x8f70
jmp 0x8fcb
movslq %edx, %rcx
movq 0x8(%rsp), %rax
movq $0x0, -0x8(%rax,%rcx,8)
movq %rax, (%r14)
decl %edx
movq 0x10(%rsp), %rcx
movl %edx, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9212
movq %rsi, %rbx
movb (%rsi), %al
testb %al, %al
je 0x91df
movq %rdi, %r14
addq $0x28, %rbx
xorl %ebp, %ebp
movq -0x20(%rbx), %rdx
movsbl %al, %esi
movq %r14, %rdi
callq 0x8ffd
testl %eax, %eax
je 0x9243
movb (%rbx), %al
incl %ebp
addq $0x28, %rbx
testb %al, %al
jne 0x91c0
movl $0xfffffffe, 0xd3b7(%rip) # imm = 0xFFFFFFFE
movabsq $0x206e776f6e6b6e55, %rax # imm = 0x206E776F6E6B6E55
movq %rax, 0xd3b6(%rip)      # 0x165b0
movabsq $0x6e6f6974706f20, %rax # imm = 0x6E6F6974706F20
movq %rax, 0xd3ac(%rip)      # 0x165b7
movl $0xfffffffe, %ebp       # imm = 0xFFFFFFFE
jmp 0x9243
movl $0xffffffff, 0xd384(%rip) # imm = 0xFFFFFFFF
movabsq $0x6c616e7265746e49, %rax # imm = 0x6C616E7265746E49
movq %rax, 0xd383(%rip)      # 0x165b0
movabsq $0x726f727265206c, %rax # imm = 0x726F727265206C
movq %rax, 0xd379(%rip)      # 0x165b7
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movb (%rbx), %cl
testb %cl, %cl
je 0x9283
movq (%rax), %rdx
movsbq %bpl, %rax
movsbl (%rdx,%rax,4), %esi
addq $0x10, %rbx
xorl %eax, %eax
movsbq %cl, %rcx
cmpl %esi, (%rdx,%rcx,4)
je 0x92b4
movb (%rbx), %cl
incl %eax
addq $0x10, %rbx
testb %cl, %cl
jne 0x926e
movl $0xffffffff, 0xd313(%rip) # imm = 0xFFFFFFFF
movabsq $0x206e776f6e6b6e55, %rax # imm = 0x206E776F6E6B6E55
movq %rax, 0xd312(%rip)      # 0x165b0
movabsq $0x6e6f6974706f20, %rax # imm = 0x6E6F6974706F20
movq %rax, 0xd308(%rip)      # 0x165b7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %r13
movq (%rdi), %rax
testq %rax, %rax
movq %rax, 0x8(%rsp)
je 0x92f1
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
incl %ebp
cmpb $0x0, (%rax)
leaq 0x10(%rax), %rax
jne 0x92e4
jmp 0x92f3
xorl %ebp, %ebp
movl %ebp, %ebx
movq %rbx, %r12
shlq $0x4, %r12
addq $0x20, %r12
movq %r12, %rdi
callq 0x33d0
testq %rax, %rax
je 0x93de
testl %ebp, %ebp
movq %rax, 0x10(%rsp)
je 0x933a
movq %rbx, %rdx
shlq $0x4, %rdx
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %r12
movq %r12, %rsi
callq 0x3220
movq 0x10(%rsp), %rax
jmp 0x9341
xorl %ebx, %ebx
movq 0x8(%rsp), %r12
movb (%r14), %cl
shlq $0x4, %rbx
leaq (%rax,%rbx), %rbp
movb %cl, (%rax,%rbx)
movl $0x0, 0x4(%rax,%rbx)
cmpl $0x0, 0x18(%r14)
je 0x939e
jle 0x93a6
movq %r13, 0x8(%rsp)
addq %rax, %rbx
addq $0x4, %rbx
leaq 0x8(%rbp), %r12
xorl %r13d, %r13d
movq (%r15,%r13,8), %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8d97
incq %r13
movslq 0x18(%r14), %rax
cmpq %rax, %r13
jl 0x9373
movq 0x8(%rsp), %r13
movq (%r13), %r12
movq 0x10(%rsp), %rax
jmp 0x93a6
movq $0x0, 0x8(%rbp)
movb $0x0, 0x10(%rbp)
movl $0x0, 0x14(%rbp)
movq $0x0, 0x18(%rbp)
testq %r12, %r12
je 0x93cb
movq %r12, %rdi
callq 0x3350
movq 0x10(%rsp), %rax
movq %rax, (%r13)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addl $0x2, %ebp
leaq 0x769b(%rip), %rdi      # 0x10a83
leaq 0x7607(%rip), %rsi      # 0x109f6
movl $0xba, %edx
xorl %eax, %eax
callq 0x3060
leaq 0x769b(%rip), %rdi      # 0x10a9d
movl $0x10, %edx
movl %ebp, %esi
movq %r12, %rcx
xorl %eax, %eax
callq 0x3060
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9455
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movb -0x8(%r14), %bpl
cmpl $0x0, -0x4(%r14)
je 0x9440
movq (%r14), %rdi
callq 0x3350
addq $0x10, %r14
testb %bpl, %bpl
jne 0x942d
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3350
retq