LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rsi
movq %rsi, (%rsp)
movq 0x8(%rsp), %rdi
addq $0x8, %rsi
callq 0x4330
movq 0x8(%rsp), %rdi
leaq 0xdb4b(%rip), %rsi      # 0x1579c
callq 0x42f0
movq (%rsp), %rsi
movq %rax, %rdi
addq $0x2b, %rsi
callq 0x4330
movq %rax, %rdi
movq 0x13338(%rip), %rsi     # 0x1afa8
callq 0x4360
movq 0x8(%rsp), %rdi
leaq 0xdb26(%rip), %rsi      # 0x157a7
callq 0x42f0
movq %rax, %rdi
movq (%rsp), %rax
movzbl 0x3a(%rax), %esi
callq 0x45f0
movq %rax, %rdi
movq 0x13308(%rip), %rsi     # 0x1afa8
callq 0x4360
movq 0x8(%rsp), %rdi
leaq 0xdb01(%rip), %rsi      # 0x157b2
callq 0x42f0
movq %rax, %rdi
movq (%rsp), %rax
movzbl 0x3b(%rax), %esi
callq 0x45f0
movq %rax, %rdi
movq 0x132d8(%rip), %rsi     # 0x1afa8
callq 0x4360
movq 0x8(%rsp), %rdi
leaq 0xdadb(%rip), %rsi      # 0x157bc
callq 0x42f0
movq %rax, %rdi
movq (%rsp), %rax
movzwl 0x3c(%rax), %esi
callq 0x45f0
movq %rax, %rdi
movq 0x132a8(%rip), %rsi     # 0x1afa8
callq 0x4360
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xb060
movq 0x8(%rsp), %rax
leaq 0x12e4c(%rip), %rcx     # 0x1ab80
addq $0x10, %rcx
movq %rcx, (%rax)
movb $0x0, 0x3a(%rax)
movb $0x0, 0x3b(%rax)
movw $0x0, 0x3c(%rax)
leaq 0x20(%rsp), %rdi
leaq 0xda1b(%rip), %rsi      # 0x15770
movl $0x23, %edx
callq 0x4260
movq 0x8(%rsp), %rdi
movq 0xda28(%rip), %rax      # 0x15793
movq %rax, 0x17(%rsp)
movb 0xda25(%rip), %al       # 0x1579b
movb %al, 0x1f(%rsp)
addq $0x8, %rdi
leaq 0x20(%rsp), %rsi
callq 0x42c0
movq 0x8(%rsp), %rdi
addq $0x2b, %rdi
leaq 0x17(%rsp), %rsi
callq 0x42c0
movq 0x8(%rsp), %rdi
addq $0x3e, %rdi
xorl %esi, %esi
movl $0xcc, %edx
callq 0x41a0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: pelrun[P]aft/CDSKFile.cpp
// Function: CEDSKDiscHeader::DisplayInfo(std::ostream&) const
void CEDSKDiscHeader::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;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rsi
movq %rsi, (%rsp)
movq 0x8(%rsp), %rdi
addq $0x8, %rsi
callq 0x4330
movq 0x8(%rsp), %rdi
leaq 0xd6db(%rip), %rsi      # 0x1579c
callq 0x42f0
movq (%rsp), %rsi
movq %rax, %rdi
addq $0x2b, %rsi
callq 0x4330
movq %rax, %rdi
movq 0x12ec8(%rip), %rsi     # 0x1afa8
callq 0x4360
movq 0x8(%rsp), %rdi
leaq 0xd6b6(%rip), %rsi      # 0x157a7
callq 0x42f0
movq %rax, %rdi
movq (%rsp), %rax
movzbl 0x3a(%rax), %esi
callq 0x45f0
movq %rax, %rdi
movq 0x12e98(%rip), %rsi     # 0x1afa8
callq 0x4360
movq 0x8(%rsp), %rdi
leaq 0xd691(%rip), %rsi      # 0x157b2
callq 0x42f0
movq %rax, %rdi
movq (%rsp), %rax
movzbl 0x3b(%rax), %esi
callq 0x45f0
movq %rax, %rdi
movq 0x12e68(%rip), %rsi     # 0x1afa8
callq 0x4360
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: pelrun[P]aft/CDSKFile.cpp
// Function: CDSKSector::ReadHeader(std::istream&)
bool CDSKSector::ReadHeader(std::istream &str)
{
	str.read((char*)&Track, 1);
	str.read((char*)&Side, 1);
	str.read((char*)&SectorID, 1);
	str.read((char*)&SectorSize, 1);
	str.read((char*)&FDCStatus1, 1);
	str.read((char*)&FDCStatus2, 1);
	str.read((char*)&DataSize, 2);
	
	return true;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rsi
movq %rsi, (%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %edx
callq 0x4460
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x1, %rsi
movl $0x1, %edx
callq 0x4460
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x2, %rsi
movl $0x1, %edx
callq 0x4460
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x3, %rsi
movl $0x1, %edx
callq 0x4460
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x4, %rsi
movl $0x1, %edx
callq 0x4460
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x5, %rsi
movl $0x1, %edx
callq 0x4460
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x6, %rsi
movl $0x2, %edx
callq 0x4460
movb $0x1, %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: pelrun[P]aft/CDSKFile.cpp
// Function: CDSKSector::WriteHeader(std::ostream&)
bool CDSKSector::WriteHeader(std::ostream &str)
{
	str.write((char*)&Track, 1);
	str.write((char*)&Side, 1);
	str.write((char*)&SectorID, 1);
	str.write((char*)&SectorSize, 1);
	str.write((char*)&FDCStatus1, 1);
	str.write((char*)&FDCStatus2, 1);
	str.write((char*)&DataSize, 2);
	
	return true;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rsi
movq %rsi, (%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %edx
callq 0x44a0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x1, %rsi
movl $0x1, %edx
callq 0x44a0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x2, %rsi
movl $0x1, %edx
callq 0x44a0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x3, %rsi
movl $0x1, %edx
callq 0x44a0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x4, %rsi
movl $0x1, %edx
callq 0x44a0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x5, %rsi
movl $0x1, %edx
callq 0x44a0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x6, %rsi
movl $0x2, %edx
callq 0x44a0
movb $0x1, %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x83c0
movq 0x8(%rsp), %rdi
callq 0x8440
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rax), %rsi
movslq 0x14(%rsp), %rdx
callq 0x4460
movq 0x8(%rsp), %rdi
callq 0x8490
movb $0x1, %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x8(%rax)
je 0x83fa
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x83f8
movq 0x8(%rsp), %rdi
callq 0x4490
jmp 0x83fa
movq 0x10(%rsp), %rdi
movq $0x0, 0x8(%rdi)
callq 0x8440
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x842d
movslq 0x1c(%rsp), %rdi
callq 0x4030
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: pelrun[P]aft/CDSKFile.cpp
// Function: CDSKSector::GetDataSize()
int CDSKSector::GetDataSize()
{
	int sSize = 0;
	if (DataSize != 0)
	{
		sSize = DataSize;
	}
	else
	{
		sSize = (128 << SectorSize);
	}
	return sSize;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movl $0x0, -0xc(%rsp)
movzwl 0x6(%rax), %eax
cmpl $0x0, %eax
je 0x846f
movq -0x18(%rsp), %rax
movzwl 0x6(%rax), %eax
movl %eax, -0xc(%rsp)
jmp 0x8483
movq -0x18(%rsp), %rax
movzbl 0x3(%rax), %ecx
movl $0x80, %eax
shll %cl, %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
retq
nopl (%rax,%rax)
// File: pelrun[P]aft/CDSKFile.cpp
// Function: CDSKSector::Update()
void CDSKSector::Update()
{
	int sSize = GetDataSize();
	
	Checksum = 0;
	for (int i=0;i<sSize;i++)
	{
		Checksum += Data[i];
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x8440
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0xc(%rsp)
movb $0x0, 0x10(%rax)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x84ee
movq (%rsp), %rax
movq 0x8(%rax), %rcx
movslq 0x8(%rsp), %rdx
movzbl (%rcx,%rdx), %edx
movzbl 0x10(%rax), %ecx
addl %edx, %ecx
movb %cl, 0x10(%rax)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x84bd
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x4600
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x72d0
movq 0x10(%rsp), %rsi
movl %eax, 0x44(%rsp)
movq 0x48(%rsp), %rdi
movl $0xd, %edx
callq 0x4460
movq 0x10(%rsp), %rsi
movq 0x48(%rsp), %rdi
addq $0xe, %rsi
movl $0x3, %edx
callq 0x4460
movq 0x10(%rsp), %rsi
movq 0x48(%rsp), %rdi
addq $0x11, %rsi
movl $0x1, %edx
callq 0x4460
movq 0x10(%rsp), %rsi
movq 0x48(%rsp), %rdi
addq $0x12, %rsi
movl $0x1, %edx
callq 0x4460
movq 0x10(%rsp), %rsi
movq 0x48(%rsp), %rdi
addq $0x13, %rsi
movl $0x1, %edx
callq 0x4460
movq 0x10(%rsp), %rsi
movq 0x48(%rsp), %rdi
addq $0x14, %rsi
movl $0x1, %edx
callq 0x4460
movq 0x10(%rsp), %rsi
movq 0x48(%rsp), %rdi
addq $0x15, %rsi
movl $0x1, %edx
callq 0x4460
movq 0x10(%rsp), %rsi
movq 0x48(%rsp), %rdi
addq $0x16, %rsi
movl $0x1, %edx
callq 0x4460
movq 0x10(%rsp), %rsi
movq 0x48(%rsp), %rdi
addq $0x17, %rsi
movl $0x1, %edx
callq 0x4460
movq 0x10(%rsp), %rsi
movq 0x48(%rsp), %rdi
addq $0x18, %rsi
movl $0x1, %edx
callq 0x4460
movq 0x10(%rsp), %rdi
callq 0x8da0
movl $0x0, 0x2c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x2c(%rsp), %eax
movzbl 0x16(%rcx), %ecx
cmpl %ecx, %eax
jge 0x8d05
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
movslq 0x2c(%rsp), %rax
shlq $0x5, %rax
addq %rax, %rdi
movq 0x48(%rsp), %rsi
callq 0x81e0
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x8cc8
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x44(%rsp), %eax
addl $0x100, %eax            # imm = 0x100
movl %eax, %eax
movl %eax, %esi
leaq 0x18(%rsp), %rdi
callq 0xb0b0
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x4480
movl $0x0, 0x2c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x2c(%rsp), %eax
movzbl 0x16(%rcx), %ecx
cmpl %ecx, %eax
jge 0x8d7f
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
movslq 0x2c(%rsp), %rax
shlq $0x5, %rax
addq %rax, %rdi
movq 0x48(%rsp), %rsi
callq 0x8360
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x8d42
movq 0x10(%rsp), %rdi
callq 0x8f90
movb $0x1, %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x78(%rsp)
cmpq $0x0, 0x20(%rax)
je 0x8e49
movq 0x78(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x70(%rsp)
cmpq $0x0, %rax
je 0x8e47
movq 0x70(%rsp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, 0x58(%rsp)
movq -0x8(%rcx), %rdx
movq %rdx, 0x60(%rsp)
shlq $0x5, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, 0x68(%rsp)
je 0x8e30
movq 0x68(%rsp), %rdi
addq $-0x20, %rdi
movq %rdi, 0x50(%rsp)
callq 0x81a0
movq 0x70(%rsp), %rcx
movq 0x50(%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x68(%rsp)
jne 0x8e09
movq 0x58(%rsp), %rdi
movq 0x60(%rsp), %rsi
shlq $0x5, %rsi
addq $0x8, %rsi
callq 0x4660
jmp 0x8e49
movq 0x78(%rsp), %rax
movq $0x0, 0x20(%rax)
movzbl 0x16(%rax), %eax
cmpl $0x0, %eax
jne 0x8e64
jmp 0x8f15
movq 0x78(%rsp), %rax
movzbl 0x16(%rax), %eax
movq %rax, 0x38(%rsp)
movl $0x20, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
addq $0x8, %rdi
setb %al
orb %al, %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
movq %rdi, 0x30(%rsp)
callq 0x4030
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x40(%rsp)
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, 0x48(%rsp)
cmpq $0x0, %rax
je 0x8f07
movq 0x48(%rsp), %rax
movq 0x38(%rsp), %rdx
shlq $0x5, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x8150
jmp 0x8eef
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rax
addq $0x20, %rax
cmpq %rcx, %rax
movq %rax, 0x28(%rsp)
jne 0x8ede
movq 0x78(%rsp), %rax
movq 0x48(%rsp), %rcx
movq %rcx, 0x20(%rax)
addq $0x98, %rsp
retq
movq 0x48(%rsp), %rcx
movq %rax, %rsi
movq 0x18(%rsp), %rax
movq %rsi, 0x88(%rsp)
movl %edx, 0x84(%rsp)
cmpq %rax, %rcx
movq %rax, 0x10(%rsp)
je 0x8f6a
movq 0x10(%rsp), %rdi
addq $-0x20, %rdi
movq %rdi, 0x8(%rsp)
callq 0x81a0
movq 0x48(%rsp), %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x10(%rsp)
jne 0x8f43
movq 0x30(%rsp), %rsi
movq 0x40(%rsp), %rdi
callq 0x4660
movq 0x88(%rsp), %rdi
callq 0x11ab0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x18(%rsp), %rcx
movl 0x2c(%rsp), %eax
movzbl 0x16(%rcx), %ecx
cmpl %ecx, %eax
jge 0x8fe5
movq 0x18(%rsp), %rax
movl 0x2c(%rsp), %ecx
movq 0x20(%rax), %rax
movslq 0x2c(%rsp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movl %ecx, 0x14(%rax)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x8fab
movl $0x0, 0x28(%rsp)
movq 0x18(%rsp), %rcx
movl 0x28(%rsp), %eax
movzbl 0x16(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x9176
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
movq 0x18(%rsp), %rcx
movl 0x24(%rsp), %eax
movzbl 0x16(%rcx), %ecx
cmpl %ecx, %eax
jge 0x9164
movq 0x18(%rsp), %rcx
movq 0x20(%rcx), %rax
movslq 0x28(%rsp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movzbl 0x10(%rax), %eax
movq 0x20(%rcx), %rcx
movslq 0x24(%rsp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movzbl 0x10(%rcx), %ecx
cmpl %ecx, %eax
jne 0x9152
movq 0x18(%rsp), %rcx
movq 0x20(%rcx), %rax
movslq 0x28(%rsp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movzbl 0x2(%rax), %eax
movq 0x20(%rcx), %rcx
movslq 0x24(%rsp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movzbl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jne 0x9152
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
movslq 0x28(%rsp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x8440
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x14(%rsp)
movq 0x20(%rax), %rdi
movslq 0x24(%rsp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x8440
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jne 0x9152
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rcx
movslq 0x28(%rsp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%rsp)
movq 0x20(%rax), %rcx
movslq 0x24(%rsp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rsp)
movq 0x20(%rax), %rdi
movslq 0x28(%rsp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x8440
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movslq %eax, %rdx
callq 0x4170
cmpl $0x0, %eax
jne 0x9150
movq 0x18(%rsp), %rax
movl 0x28(%rsp), %ecx
movq 0x20(%rax), %rax
movslq 0x24(%rsp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movl %ecx, 0x18(%rax)
jmp 0x9152
jmp 0x9154
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x9010
jmp 0x9166
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x8fed
movq 0x18(%rsp), %rax
movb $0x1, 0x19(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x19(%rax)
jne 0x9403
movl $0x0, 0x24(%rsp)
jmp 0x945b
movl $0x100, 0x14(%rsp)      # imm = 0x100
movl $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movl 0x10(%rsp), %eax
movzbl 0x16(%rcx), %ecx
cmpl %ecx, %eax
jge 0x9453
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
movslq 0x10(%rsp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x8440
addl 0x14(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x9413
movl 0x14(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x48(%rsp)
addq $0x10, %rdi
movq 0x70(%rsp), %rsi
callq 0x7ac0
movq 0x48(%rsp), %rax
movzbl 0x4a(%rax), %eax
cmpl $0x0, %eax
jne 0xa612
movq 0x48(%rsp), %rax
movzbl 0x4b(%rax), %eax
cmpl $0x0, %eax
jne 0xa612
movb $0x0, 0x87(%rsp)
jmp 0xa7df
movq 0x48(%rsp), %rcx
movzbl 0x4a(%rcx), %eax
movzbl 0x4b(%rcx), %ecx
imull %ecx, %eax
cltq
movq %rax, 0x30(%rsp)
movl $0x28, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
addq $0x8, %rdi
setb %al
orb %al, %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
movq %rdi, 0x28(%rsp)
callq 0x4030
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x38(%rsp)
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, 0x40(%rsp)
cmpq $0x0, %rax
je 0xa6be
movq 0x40(%rsp), %rax
movq 0x30(%rsp), %rcx
imulq $0x28, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x8a50
jmp 0xa6a6
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
addq $0x28, %rax
cmpq %rcx, %rax
movq %rax, 0x20(%rsp)
jne 0xa695
movq 0x48(%rsp), %rax
movq 0x40(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x0, 0x60(%rsp)
movl $0x100, 0x5c(%rsp)      # imm = 0x100
movl $0x0, 0x58(%rsp)
movq 0x48(%rsp), %rcx
movl 0x58(%rsp), %eax
movzbl 0x4a(%rcx), %ecx
cmpl %ecx, %eax
jge 0xa7d7
movl $0x0, 0x54(%rsp)
movq 0x48(%rsp), %rcx
movl 0x54(%rsp), %eax
movzbl 0x4b(%rcx), %ecx
cmpl %ecx, %eax
jge 0xa7c5
movq 0x70(%rsp), %rdi
movl 0x5c(%rsp), %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x44d0
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rdi
movl 0x60(%rsp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
movq 0x70(%rsp), %rsi
callq 0x8b90
movq 0x48(%rsp), %rax
movzwl 0x4c(%rax), %eax
addl 0x5c(%rsp), %eax
movl %eax, 0x5c(%rsp)
movl 0x60(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x60(%rsp)
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0xa701
movq 0x40(%rsp), %rcx
movq %rax, %rsi
movq 0x10(%rsp), %rax
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
cmpq %rax, %rcx
movq %rax, 0x8(%rsp)
je 0xa7b4
movq 0x8(%rsp), %rdi
addq $-0x28, %rdi
movq %rdi, (%rsp)
callq 0x8ae0
movq 0x40(%rsp), %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x8(%rsp)
jne 0xa78f
movq 0x28(%rsp), %rsi
movq 0x38(%rsp), %rdi
callq 0x4660
jmp 0xa7f0
jmp 0xa7c7
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0xa6e4
movb $0x1, 0x87(%rsp)
movb 0x87(%rsp), %al
andb $0x1, %al
addq $0x88, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x11ab0
nopw (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x10, %rdi
movq 0x48(%rsp), %rsi
callq 0x7b70
movl $0x0, 0x44(%rsp)
movl $0x100, 0x40(%rsp)      # imm = 0x100
movl $0x0, 0x3c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x3c(%rsp), %eax
movzbl 0x4a(%rcx), %ecx
cmpl %ecx, %eax
jge 0xa957
movl $0x0, 0x38(%rsp)
movq 0x10(%rsp), %rcx
movl 0x38(%rsp), %eax
movzbl 0x4b(%rcx), %ecx
cmpl %ecx, %eax
jge 0xa945
movl 0x40(%rsp), %eax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
callq 0x4290
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x72d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
subq %rcx, %rax
movl %eax, 0x34(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0xa8fb
movslq 0x34(%rsp), %rdi
callq 0x4030
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x34(%rsp), %rdx
xorl %esi, %esi
callq 0x41a0
movq 0x48(%rsp), %rdi
movq 0x18(%rsp), %rsi
movslq 0x34(%rsp), %rdx
callq 0x44a0
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xa8f9
movq (%rsp), %rdi
callq 0x4490
jmp 0xa8fb
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movl 0x44(%rsp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
movq 0x48(%rsp), %rsi
callq 0x9190
movq 0x10(%rsp), %rax
movzwl 0x4c(%rax), %eax
addl 0x40(%rsp), %eax
movl %eax, 0x40(%rsp)
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0xa85b
jmp 0xa947
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0xa83e
movb $0x1, %al
andb $0x1, %al
addq $0x58, %rsp
retq
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
movq 0x58(%rsp), %rsi
callq 0x7fe0
movq 0x58(%rsp), %rdi
callq 0x4290
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x72d0
movl %eax, 0x54(%rsp)
movl $0x0, 0x3c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x3c(%rsp), %eax
movzbl 0x4a(%rcx), %ecx
cmpl %ecx, %eax
jge 0xaf84
movl $0x0, 0x38(%rsp)
movq 0x10(%rsp), %rcx
movl 0x38(%rsp), %eax
movzbl 0x4b(%rcx), %ecx
cmpl %ecx, %eax
jge 0xaf72
movq 0x10(%rsp), %rax
movl 0x3c(%rsp), %ecx
movzbl 0x4b(%rax), %edx
imull %edx, %ecx
addl 0x38(%rsp), %ecx
movslq %ecx, %rcx
movzbl 0x4e(%rax,%rcx), %eax
cmpl $0x0, %eax
je 0xaf60
movslq 0x54(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
callq 0x4290
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x72d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
subq %rcx, %rax
movl %eax, 0x34(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0xaf0e
movslq 0x34(%rsp), %rdi
callq 0x4030
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x34(%rsp), %rdx
xorl %esi, %esi
callq 0x41a0
movq 0x58(%rsp), %rdi
movq 0x18(%rsp), %rsi
movslq 0x34(%rsp), %rdx
callq 0x44a0
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xaf0c
movq (%rsp), %rdi
callq 0x4490
jmp 0xaf0e
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rdi
movl 0x3c(%rsp), %eax
movzbl 0x4b(%rcx), %ecx
imull %ecx, %eax
addl 0x38(%rsp), %eax
cltq
imulq $0x28, %rax, %rax
addq %rax, %rdi
movq 0x58(%rsp), %rsi
callq 0x9190
movq 0x10(%rsp), %rax
movl 0x3c(%rsp), %ecx
movzbl 0x4b(%rax), %edx
imull %edx, %ecx
addl 0x38(%rsp), %ecx
movslq %ecx, %rcx
movzbl 0x4e(%rax,%rcx), %eax
shll $0x8, %eax
addl 0x54(%rsp), %eax
movl %eax, 0x54(%rsp)
jmp 0xaf62
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0xae48
jmp 0xaf74
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0xae2b
movb $0x1, %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rcx
movl 0x1c(%rsp), %eax
movzbl 0x4a(%rcx), %ecx
cmpl %ecx, %eax
jge 0xb048
movl $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rcx
movl 0x18(%rsp), %eax
movzbl 0x4b(%rcx), %ecx
cmpl %ecx, %eax
jge 0xb036
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rdi
movl 0x1c(%rsp), %eax
movzbl 0x4b(%rcx), %ecx
imull %ecx, %eax
addl 0x18(%rsp), %eax
cltq
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x93e0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x14(%rsp)
movl 0x14(%rsp), %ecx
sarl $0x8, %ecx
movb %cl, %dl
movl 0x1c(%rsp), %ecx
movzbl 0x4b(%rax), %esi
imull %esi, %ecx
addl 0x18(%rsp), %ecx
movslq %ecx, %rcx
movb %dl, 0x4e(%rax,%rcx)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0xafc8
jmp 0xb038
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xafab
addq $0x28, %rsp
retq
nopl (%rax)
// File: pelrun[P]aft/COptionParser.cpp
// Function: COptionParser::GetOptionNbParam(char) const
int COptionParser::GetOptionNbParam(const char shortName) const
{
	int val = 0;
	int idx;
	if ((idx = optionIndex(_optionsOut, shortName)) != ERROR_UNKNOWN)
	{
		val = _optionsOut[idx].argc;
	}
	return val;
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x8(%rax), %rdi
movsbl 0x1f(%rsp), %esi
callq 0xd800
movl %eax, 0x14(%rsp)
cmpl $-0x1, %eax
je 0xc525
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x14(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x228, %rsp            # imm = 0x228
movb %sil, %al
movq %rdi, 0x220(%rsp)
movb %al, 0x21f(%rsp)
movl %edx, 0x218(%rsp)
movl %ecx, 0x214(%rsp)
movq 0x220(%rsp), %rax
movq %rax, 0x28(%rsp)
movl 0x218(%rsp), %ecx
movl %ecx, 0x210(%rsp)
movq 0x8(%rax), %rdi
movsbl 0x21f(%rsp), %esi
callq 0xd800
movl %eax, 0x20c(%rsp)
cmpl $-0x1, %eax
je 0xc75b
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x20c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movslq 0x214(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x4510
movl %eax, 0x210(%rsp)
callq 0x4050
cmpl $0x22, (%rax)
jne 0xc759
leaq 0x90(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x44c0
movq 0x18(%rsp), %rdi
leaq 0x935c(%rip), %rsi      # 0x15955
callq 0x42f0
movq %rax, 0x20(%rsp)
jmp 0xc605
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x20c(%rsp), %rcx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %rax
movslq 0x214(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x42f0
jmp 0xc637
movb $0x1, 0x37(%rsp)
movl $0x50, %edi
callq 0x4190
movq %rax, 0x8(%rsp)
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x4610
movq 0x10(%rsp), %rdx
leaq 0x92fc(%rip), %rsi      # 0x15962
leaq 0x60(%rsp), %rdi
callq 0x53b0
jmp 0xc672
leaq 0x38(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x4340
jmp 0xc686
movq 0x8(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movl $0x42, %edx
leaq 0x38(%rsp), %rcx
callq 0xbf00
movq 0x8(%rsp), %rdi
movb $0x0, 0x37(%rsp)
leaq 0xe6d8(%rip), %rsi      # 0x1ad88
leaq -0x707(%rip), %rdx      # 0xbfb0
callq 0x45e0
jmp 0xc777
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0xc74a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0xc72b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0xc721
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x46a8
leaq 0x60(%rsp), %rdi
callq 0x46a8
leaq 0x5f(%rsp), %rdi
callq 0x4380
testb $0x1, 0x37(%rsp)
jne 0xc73e
jmp 0xc748
movq 0x8(%rsp), %rdi
callq 0x4210
jmp 0xc74a
leaq 0x90(%rsp), %rdi
callq 0x40b0
jmp 0xc76a
jmp 0xc75b
movl 0x210(%rsp), %eax
addq $0x228, %rsp            # imm = 0x228
retq
movq 0x88(%rsp), %rdi
callq 0x11ab0
nopw (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, (%rsp)
movb %dl, %al
movq %rdi, %rdx
movq %rdx, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movb %al, 0x47(%rsp)
movq %rcx, 0x38(%rsp)
movl %r8d, 0x34(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0x33(%rsp)
movq 0x38(%rsp), %rsi
callq 0x4150
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movsbl 0x47(%rsp), %esi
callq 0xd800
movl %eax, 0x18(%rsp)
jmp 0xc7dc
movl 0x18(%rsp), %eax
movl %eax, 0x2c(%rsp)
cmpl $-0x1, %eax
je 0xc82f
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x2c(%rsp), %rcx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %rax
movslq 0x34(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x44e0
jmp 0xc814
jmp 0xc82f
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x46a8
jmp 0xc84e
movb $0x1, 0x33(%rsp)
testb $0x1, 0x33(%rsp)
jne 0xc844
movq (%rsp), %rdi
callq 0x46a8
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x11ab0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jge 0xd2fa
jmp 0xd47d
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xd346
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0xd339
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x4160
movq %rax, %rcx
addq $0x1, %rcx
movslq -0x24(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x24(%rbp)
jmp 0xd33b
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xd301
movq -0x8(%rbp), %rax
movslq (%rax), %rax
shlq $0x3, %rax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addl -0x24(%rbp), %eax
movslq %eax, %rdi
callq 0x44b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xd387
leaq 0x8660(%rip), %rdi      # 0x159d4
leaq 0x8677(%rip), %rsi      # 0x159f2
movl $0x55, %edx
movb $0x0, %al
callq 0x4060
movq -0x30(%rbp), %rax
movslq -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xd44f
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0xd43f
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x4160
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
callq 0x4260
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x4160
addq $0x1, %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd441
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xd3ac
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xd767
movl $0xffffffff, 0xded8(%rip) # imm = 0xFFFFFFFF
leaq 0xdee1(%rip), %rdi      # 0x1b630
leaq 0x82ab(%rip), %rsi      # 0x15a01
callq 0x42c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd7ec
jmp 0xd769
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xd7c8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movb (%rax), %al
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rdx
movsbl %al, %esi
callq 0xd4b0
cmpl $0x0, %eax
jne 0xd7bd
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xd7ec
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd769
movl $0xfffffffe, 0xde4e(%rip) # imm = 0xFFFFFFFE
leaq 0xde57(%rip), %rdi      # 0x1b630
leaq 0x8290(%rip), %rsi      # 0x15a70
callq 0x42c0
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movsbl -0x11(%rbp), %edi
callq 0x4650
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0xd864
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsbl (%rax), %edi
callq 0x4650
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xd86d
jmp 0xd878
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xd825
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xd8b5
movl $0xffffffff, 0xdd87(%rip) # imm = 0xFFFFFFFF
leaq 0xdd90(%rip), %rdi      # 0x1b630
leaq 0x81c9(%rip), %rsi      # 0x15a70
callq 0x42c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd8bb
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xdb38
jmp 0xdadc
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movb (%rax), %al
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, 0x4(%rax)
je 0xdb1d
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x4420
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movsbl -0xd(%rbp), %eax
cmpl $0x0, %eax
jne 0xdadc
movq -0x8(%rbp), %rdi
callq 0x4420
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl %r9d, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0xdb40
cmpl $0x0, %eax
je 0xe48a
callq 0xd0e0
movl %eax, -0x4(%rbp)
jmp 0xe540
cmpl $0x0, -0x30(%rbp)
jne 0xe4ea
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movl $0x63, %esi
callq 0xd800
movl %eax, -0x34(%rbp)
cmpl $-0x1, %eax
je 0xe4e8
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0xdf50
cmpl $0x0, %eax
je 0xe4e6
callq 0xd0e0
movl %eax, -0x4(%rbp)
jmp 0xe540
jmp 0xe4e8
jmp 0xe4ea
movq -0x10(%rbp), %rax
movl (%rax), %eax
cmpl -0x2c(%rbp), %eax
jg 0xe539
cmpl $0x0, -0x2c(%rbp)
jl 0xe539
leaq -0x440(%rbp), %rdi
movl -0x2c(%rbp), %edx
leaq 0x7648(%rip), %rsi      # 0x15b54
movb $0x0, %al
callq 0x4090
movl $0xfffffffb, 0xd103(%rip) # imm = 0xFFFFFFFB
leaq -0x440(%rbp), %rsi
leaq 0xd105(%rip), %rdi      # 0x1b630
callq 0x42c0
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0xe540
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
movl $0x5415, %esi           # imm = 0x5415
leaq -0x8(%rbp), %rdx
movb $0x0, %al
callq 0x4520
cmpl $-0x1, %eax
jne 0xec8f
leaq 0x6fb3(%rip), %rdi      # 0x15c3d
callq 0x4270
movl -0x8(%rbp), %eax
andl $-0x3, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $-0x5, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl $0x5418, %esi           # imm = 0x5418
leaq -0x8(%rbp), %rdx
movb $0x0, %al
callq 0x4520
cmpl $-0x1, %eax
jne 0xecc5
leaq 0x6f96(%rip), %rdi      # 0x15c56
callq 0x4270
movl -0x4(%rbp), %edi
callq 0x4670
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
movl $0x5415, %esi           # imm = 0x5415
leaq -0x8(%rbp), %rdx
movb $0x0, %al
callq 0x4520
cmpl $-0x1, %eax
jne 0xed9f
leaq 0x6ea3(%rip), %rdi      # 0x15c3d
callq 0x4270
movl -0x8(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl $0x5418, %esi           # imm = 0x5418
leaq -0x8(%rbp), %rdx
movb $0x0, %al
callq 0x4520
cmpl $-0x1, %eax
jne 0xedcc
leaq 0x6e8f(%rip), %rdi      # 0x15c56
callq 0x4270
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
movl $0x5415, %esi           # imm = 0x5415
leaq -0x8(%rbp), %rdx
movb $0x0, %al
callq 0x4520
cmpl $-0x1, %eax
jne 0xee0f
leaq 0x6e33(%rip), %rdi      # 0x15c3d
callq 0x4270
movl -0x8(%rbp), %eax
andl $-0x3, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl $0x5418, %esi           # imm = 0x5418
leaq -0x8(%rbp), %rdx
movb $0x0, %al
callq 0x4520
cmpl $-0x1, %eax
jne 0xee3c
leaq 0x6e1f(%rip), %rdi      # 0x15c56
callq 0x4270
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
movl $0x5415, %esi           # imm = 0x5415
leaq -0x8(%rbp), %rdx
movb $0x0, %al
callq 0x4520
cmpl $-0x1, %eax
jne 0xee7f
leaq 0x6dc3(%rip), %rdi      # 0x15c3d
callq 0x4270
movl -0x8(%rbp), %eax
orl $0x4, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl $0x5418, %esi           # imm = 0x5418
leaq -0x8(%rbp), %rdx
movb $0x0, %al
callq 0x4520
cmpl $-0x1, %eax
jne 0xeeac
leaq 0x6daf(%rip), %rdi      # 0x15c56
callq 0x4270
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
movl $0x5415, %esi           # imm = 0x5415
leaq -0x8(%rbp), %rdx
movb $0x0, %al
callq 0x4520
cmpl $-0x1, %eax
jne 0xeeef
leaq 0x6d53(%rip), %rdi      # 0x15c3d
callq 0x4270
movl -0x8(%rbp), %eax
andl $-0x5, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl $0x5418, %esi           # imm = 0x5418
leaq -0x8(%rbp), %rdx
movb $0x0, %al
callq 0x4520
cmpl $-0x1, %eax
jne 0xef1c
leaq 0x6d3f(%rip), %rdi      # 0x15c56
callq 0x4270
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x38(%rbp)
movq -0x38(%rbp), %rsi
movq %rsi, -0x60(%rbp)
addq $0x10, %rsi
leaq -0x48(%rbp), %rdi
callq 0x5560
movq -0x60(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movl $0x5, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
movl %ecx, -0x14(%rbp)
decl %eax
movl %eax, %ecx
movq %rcx, -0x50(%rbp)
subl $0x4, %eax
ja 0x4cdc
movq -0x50(%rbp), %rax
leaq 0x1b36d(%rip), %rcx     # 0x20040
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x58(%rbp), %rcx
movl -0x14(%rbp), %eax
negl %eax
lock
xaddl %eax, (%rcx)
movl %eax, -0x18(%rbp)
jmp 0x4d34
movq -0x58(%rbp), %rcx
movl -0x14(%rbp), %eax
negl %eax
lock
xaddl %eax, (%rcx)
movl %eax, -0x18(%rbp)
jmp 0x4d34
movq -0x58(%rbp), %rcx
movl -0x14(%rbp), %eax
negl %eax
lock
xaddl %eax, (%rcx)
movl %eax, -0x18(%rbp)
jmp 0x4d34
movq -0x58(%rbp), %rcx
movl -0x14(%rbp), %eax
negl %eax
lock
xaddl %eax, (%rcx)
movl %eax, -0x18(%rbp)
jmp 0x4d34
movq -0x58(%rbp), %rcx
movl -0x14(%rbp), %eax
negl %eax
lock
xaddl %eax, (%rcx)
movl %eax, -0x18(%rbp)
movq -0x60(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movl $0x5, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
movl -0x24(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x56f0
movl %eax, -0x64(%rbp)
jmp 0x4d61
movl -0x64(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x74(%rbp)
decl %eax
subl $0x2, %eax
jb 0x4d8b
jmp 0x4d76
movl -0x74(%rbp), %eax
subl $0x5, %eax
je 0x4d96
jmp 0x4d80
movq -0x70(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x4da9
movq -0x70(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x4da9
movq -0x70(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x4da9
movq %rax, %rdi
callq 0x56c0
cmpl $0x0, -0x2c(%rbp)
jbe 0x4dbc
movq -0x60(%rbp), %rdi
addq $0x68, %rdi
callq 0x43f0
leaq -0x48(%rbp), %rdi
callq 0x55a0
addq $0x80, %rsp
popq %rbp
retq
nop