LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/mgo1977[P]c---parsing-argument-options/./Parser.h
// Function: Parser::getOptionText[abi:cxx11](BaseOption*, char const*)
std::string
Parser::getOptionText(BaseOption* option, const char* separator) {

    std::string optionBase;

    if ( option->hasShortOption() ) {
        optionBase += "-";
        optionBase += option->getShortOption();
    }

    if ( option->hasLongOption() ) {

        if ( option->hasShortOption() )
            optionBase += separator;

        optionBase += "--" + option->getLongOption();
    }

    return optionBase;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdx, %r14
movb $0x0, 0x10(%rdi)
cmpb $0x0, 0x8(%rdx)
je 0x305c
leaq 0x3079(%rip), %rsi      # 0x60c0
movq %rbx, %rdi
callq 0x2300
movsbl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x2160
cmpq $0x0, 0x18(%r14)
je 0x30b7
cmpb $0x0, 0x8(%r14)
je 0x3075
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2300
addq $0x10, %r14
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x2230
leaq 0x3033(%rip), %rsi      # 0x60bf
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x380f
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x2320
leaq -0x58(%rbp), %rdi
callq 0x20b0
leaq -0x38(%rbp), %rdi
callq 0x20b0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x20b0
jmp 0x30d6
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x20b0
jmp 0x30e6
jmp 0x30e3
movq %rax, %r14
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/mgo1977[P]c---parsing-argument-options/./Parser.h
// Function: BaseOption::bestMatch(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
int bestMatch(const std::string& lOption) const {

        // The idea is to determine the number of chars
        // that matches the requested option
        int matches = 0;

        // is greater don't waste time
        if ( lOption.size() > longOption.size() )
            return matches;

        for(int index=0; index < lOption.size(); ++index) {
            if ( std::tolower(lOption[index]) == std::tolower(longOption[index]) )
                matches++;
            else
                return matches;
        }

        return matches;

    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rsi), %r14
xorl %eax, %eax
cmpq 0x18(%rdi), %r14
ja 0x3927
movq (%rsi), %r15
movq 0x10(%rdi), %r13
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x3924
movsbl (%r15,%r12), %edi
callq 0x2240
movl %eax, %ebx
movsbl (%r13,%r12), %edi
callq 0x2240
cmpl %eax, %ebx
jne 0x3921
incq %r12
jmp 0x38fc
movq %r12, %r14
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mgo1977[P]c---parsing-argument-options/./Parser.h
// Function: BaseOption::toLower(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
std::string toLower(const std::string& original) const {
        std::string lc = original;

        for(int index=0; index<lc.size(); ++index)
            lc[index] = std::tolower(lc[index]);

        return lc;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x2230
xorl %r14d, %r14d
cmpq %r14, 0x8(%rbx)
jbe 0x3d1c
movq (%rbx), %r15
movsbl (%r15,%r14), %edi
callq 0x2240
movb %al, (%r15,%r14)
incq %r14
jmp 0x3d00
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mgo1977[P]c---parsing-argument-options/./Parser.h
// Function: bool canBeConvertedTo<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool canBeConvertedTo(const std::string& str) {

    T result;

    std::stringstream text(str);

    if ( text >> result )
        return true;
    else
        return false;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %rsi
leaq -0x18(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x1b0(%rbp), %rdi
pushq $0x18
popq %rdx
callq 0x22a0
leaq -0x1b0(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2200
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
sete %bl
leaq -0x1b0(%rbp), %rdi
callq 0x2130
leaq -0x28(%rbp), %rdi
callq 0x20b0
movl %ebx, %eax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x1b0(%rbp), %rdi
callq 0x2130
jmp 0x44d6
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mgo1977[P]c---parsing-argument-options/./Parser.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> fromString<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
T fromString(const std::string& str) {

    T result;

    std::stringstream text(str);

    text >> result;

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq -0x198(%rbp), %rdi
pushq $0x18
popq %rdx
callq 0x22a0
leaq -0x198(%rbp), %rdi
movq %rbx, %rsi
callq 0x2200
leaq -0x198(%rbp), %rdi
callq 0x2130
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq -0x198(%rbp), %rdi
callq 0x2130
jmp 0x4566
movq %rax, %r14
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/mgo1977[P]c---parsing-argument-options/./Parser.h
// Function: RangeNumberOption<int>::setValue(char const*)
void setValue(const char* readValue) {

        std::string fullRange = readValue;
        size_t pos = fullRange.find(",");

        std::string begin = fullRange.substr(0, pos); 
        std::string end;

        if ( fullRange.find(",", pos) != std::string::npos ) {
            end = fullRange.substr(pos + 1);
        }

        if ( end.size() != 0 ) {
            ListOption<T>::setValue(begin.c_str());
            ListOption<T>::setValue(end.c_str());
        } // if is 0 some error occur in the params

    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq -0x78(%rbp), %r15
leaq -0x58(%rbp), %rdx
movq %r15, %rdi
callq 0x36b6
leaq 0x1492(%rip), %rsi      # 0x62b8
movq %r15, %rdi
xorl %edx, %edx
callq 0x2330
movq %rax, %r14
leaq -0x58(%rbp), %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x21d0
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x145d(%rip), %rsi      # 0x62b8
leaq -0x78(%rbp), %rdi
movq %r14, %rdx
callq 0x2330
cmpq $-0x1, %rax
je 0x4ea1
incq %r14
leaq -0x98(%rbp), %rdi
leaq -0x78(%rbp), %rsi
pushq $-0x1
popq %rcx
movq %r14, %rdx
callq 0x21d0
leaq -0x38(%rbp), %rdi
leaq -0x98(%rbp), %r14
movq %r14, %rsi
callq 0x21f0
movq %r14, %rdi
callq 0x20b0
cmpq $0x0, -0x30(%rbp)
je 0x4ec0
movq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x4236
movq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x4236
leaq -0x38(%rbp), %rdi
callq 0x20b0
leaq -0x58(%rbp), %rdi
callq 0x20b0
leaq -0x78(%rbp), %rdi
callq 0x20b0
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4ef0
movq %rax, %rbx
jmp 0x4f05
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20b0
leaq -0x58(%rbp), %rdi
callq 0x20b0
leaq -0x78(%rbp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/CAksFileTransfert.cpp
// Function: CAksFileTransfert::~CAksFileTransfert()
CAksFileTransfert::~CAksFileTransfert()
{
	if (_EDSKFile != NULL)
		delete _EDSKFile;
	if (_inStream != NULL)
		delete _inStream;
	if (_outStream != NULL)
		delete _outStream;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xfcbd(%rip), %rax      # 0x13b38
movq %rax, (%rdi)
movq 0x98(%rdi), %rdi
testq %rdi, %rdi
je 0x3e90
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x3ea2
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
je 0x3eb4
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x78(%rbx), %rdi
callq 0x3578
leaq 0x48(%rbx), %rdi
callq 0x3578
movq %rbx, %rdi
popq %rbx
jmp 0x4d30
nop
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/CAksFileTransfert.cpp
// Function: CAksFileTransfert::GetFilename[abi:cxx11]() const
std::string CAksFileTransfert::GetFilename() const
{
	if (_filename.size() != 0)
		return _filename;
	#ifdef _WIN32
		const char* pathseparator = "\\";
	#else
		const char* pathseparator = "/";
	#endif
	std::string result = _filepath;
	result += pathseparator;
	result += (char*)_amsFilename;
	
	int i = result.size();
	while(result[--i] == ' ');
	result.resize(i + 1);
	
	return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x50(%rsi)
je 0x3f1e
addq $0x48, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33d0
jmp 0x3f88
leaq 0x78(%r14), %rsi
movq %rbx, %rdi
callq 0x33d0
leaq 0xa683(%rip), %rsi      # 0xe5b4
movq %rbx, %rdi
callq 0x3530
addq $0x68, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3530
movslq 0x8(%rbx), %rcx
movq (%rbx), %rax
addq %rcx, %rax
decq %rax
shlq $0x20, %rcx
movabsq $0x100000000, %rsi      # imm = 0x100000000
addq %rcx, %rsi
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
addq %rcx, %rsi
cmpb $0x20, (%rax)
leaq -0x1(%rax), %rax
je 0x3f70
sarq $0x20, %rsi
movq %rbx, %rdi
callq 0x33e0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x3f95
movq %rax, %r14
movq %rbx, %rdi
callq 0x3578
movq %r14, %rdi
callq 0xb830
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/CAksFileTransfert.cpp
// Function: CAksFileTransfert::Run(bool)
CAksCommand CAksFileTransfert::Run(bool wait)
{
	CAksCommand cmd = GetCommand(wait);

	switch(cmd)
	{
	case AksTestComunication :	{ TestComunication(cmd);	break; }
	case AksEndTransfert :		{ EndTransfert(cmd);		break; }
	case AksSend:				{ Send(cmd);				break; }
	case AksSendFileSize:		{ SendFileSize(cmd);		break; }
	case AksSendFilename:		{ SendFilename(cmd);		break; }
	case AksRewind:				{ Rewind(cmd);				break; }
	case AksCreateFile:			{ CreateFile(cmd);			break; }
	case AksAddData:			{ AddData(cmd);				break; }
	case AksCloseFile:			{ CloseFile(cmd);			break; }
	case AksInitDSK:			{ InitDSK(cmd);				break; }
	case AksWaitTrack:			{ WaitTrack(cmd);			break; }
	case AksNoMoreTrack:		{ NoMoreTrack(cmd);			break; }
	case AksOpenFile:			{ OpenFile(cmd);			break; }
	default: assert(false);
	}

	return cmd;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x40d8
movl %eax, %ebx
movl %eax, 0x4(%rsp)
leal -0xf0(%rbx), %eax
cmpl $0xc, %eax
ja 0x40b8
leaq 0xa1a4(%rip), %rcx      # 0xe17c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x41d8
jmp 0x40ae
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x4a56
jmp 0x40ae
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x4352
jmp 0x40ae
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x4aee
jmp 0x40ae
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x469c
jmp 0x40ae
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x41f4
jmp 0x40ae
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x4432
jmp 0x40ae
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x4554
jmp 0x40ae
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x4270
jmp 0x40ae
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x4410
jmp 0x40ae
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x445e
jmp 0x40ae
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x4776
jmp 0x40ae
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x4620
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xa4f7(%rip), %rdi      # 0xe5b6
leaq 0xa4f6(%rip), %rsi      # 0xe5bc
leaq 0xa505(%rip), %rcx      # 0xe5d2
movl $0x8b, %edx
callq 0x31a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/CAksFileTransfert.cpp
// Function: CAksFileTransfert::GetCommand(bool)
CAksCommand CAksFileTransfert::GetCommand(bool wait)
{
  //Read the command code
	unsigned char command;
	bool readed = false;
	if (wait)
	{
		ReadWaitByte(command);
		readed = true;
	}
	else
	{
		readed = ReadByte(command);
	}
	
  //Check its validity
	if (readed)
	{
		if (command > AksMinCommand && command < AksMaxCommand)
		{
			std::cout << "Command #" << std::hex << (int)command << std::dec << " : " << AksCommandShortDesc[command-(AksMinCommand+1)] << std::endl;

			return ((CAksCommand)command);
		}
		else
		{
			std::cout << "Unknown command received : 0x" << std::hex << (int)command << std::endl;
			return AksUnknownCommand;
		}
	}
	else
	{
		std::cout << "Unknown command not wait" << std::endl;

		return AksUnknownCommand;
	}
}

// Assembly:
pushq %rax
testl %esi, %esi
je 0x40e9
leaq 0x7(%rsp), %rsi
callq 0x4d96
jmp 0x40fb
leaq 0x7(%rsp), %rsi
callq 0x4dbc
testl %eax, %eax
je 0x41b9
movb 0x7(%rsp), %al
addb $0x10, %al
movq 0xfec0(%rip), %rdi      # 0x13fc8
cmpb $0xc, %al
ja 0x4189
leaq 0xa4e8(%rip), %rsi      # 0xe5fb
callq 0x3270
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movzbl 0x7(%rsp), %esi
movq %rax, %rdi
callq 0x34e0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
leaq 0xa816(%rip), %rsi      # 0xe96c
movq %rax, %rdi
callq 0x3270
movzbl 0x7(%rsp), %ecx
leaq 0x10246(%rip), %rdx     # 0x143b0
movq -0x780(%rdx,%rcx,8), %rsi
movq %rax, %rdi
callq 0x3270
movq %rax, %rdi
callq 0x3130
movzbl 0x7(%rsp), %eax
jmp 0x41d6
leaq 0xa475(%rip), %rsi      # 0xe605
callq 0x3270
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movzbl 0x7(%rsp), %esi
movq %rax, %rdi
callq 0x34e0
jmp 0x41cc
movq 0xfe08(%rip), %rdi      # 0x13fc8
leaq 0xa45c(%rip), %rsi      # 0xe623
callq 0x3270
movq %rax, %rdi
callq 0x3130
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/CAksFileTransfert.cpp
// Function: CAksFileTransfert::EndTransfert(CAksCommand const&)
bool CAksFileTransfert::EndTransfert(const CAksCommand &cmd)
{
	if (cmd != AksEndTransfert)
		return false;

	if (_EDSKFile != NULL)
		delete _EDSKFile;
	_EDSKFile = NULL;
	if (_inStream != NULL)
		delete _inStream;
	_inStream = NULL;
	if (_outStream != NULL)
		delete _outStream;
	_outStream = NULL;

	if (_transferingData)
	{
		_nbTransfert++;
		_transferingData = false;
	}

	return true;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl (%rsi), %ebp
cmpl $0xf2, %ebp
jne 0x425f
movq %rdi, %rbx
movq 0x98(%rdi), %rdi
testq %rdi, %rdi
je 0x4216
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x98(%rbx)
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x4230
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0xa0(%rbx)
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
je 0x424a
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0xa8(%rbx)
cmpb $0x1, 0x40(%rbx)
jne 0x425f
incl 0x3c(%rbx)
movb $0x0, 0x40(%rbx)
cmpl $0xf2, %ebp
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/CAksFileTransfert.cpp
// Function: CAksFileTransfert::Send(CAksCommand const&)
bool CAksFileTransfert::Send(const CAksCommand &cmd)
{
	if (cmd != AksSend)
		return false;
	
	_transferingData = true;

	// Read a word, send word bytes
	unsigned short s;
	ReadWaitWord(s);

	std::cout << "Read word " << std::hex << (int)s << std::dec << std::endl;

	int size = (s != 0) ? s : 0x10000;

	if (_inStream != NULL)
	{
		unsigned char *buffer = new unsigned char [size];
	
		_inStream->read((char*)buffer, size);

		WriteBuffer(buffer, size);
		
		delete[] buffer;

		return true;
	}
	
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpl $0xf1, (%rsi)
jne 0x4340
movq %rdi, %rbx
movb $0x1, 0x40(%rdi)
leaq 0xe(%rsp), %r14
movq %r14, %rsi
callq 0x4dd8
movq 0xfd25(%rip), %rdi      # 0x13fc8
leaq 0xa3a2(%rip), %rsi      # 0xe64c
callq 0x3270
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movzwl (%r14), %esi
movq %rax, %rdi
callq 0x34e0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
movq %rax, %rdi
callq 0x3130
movq 0xa0(%rbx), %r14
testq %r14, %r14
setne %bpl
je 0x4342
movzwl 0xe(%rsp), %eax
testq %rax, %rax
movl $0x10000, %r15d         # imm = 0x10000
cmovneq %rax, %r15
movq %r15, %rdi
callq 0x3030
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x3350
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4e92
movq %r12, %rdi
callq 0x3380
jmp 0x4342
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/CAksFileTransfert.cpp
// Function: CAksFileTransfert::SendFileSize(CAksCommand const&)
bool CAksFileTransfert::SendFileSize(const CAksCommand &cmd)
{
	if (cmd != AksSendFileSize)
		return false;

	int fileSize = 0;
	
	if (_inStream != NULL)
	{
		std::streampos pos = _inStream->tellg();
		
		_inStream->seekg(0,std::ios::end);
		fileSize = _inStream->tellg();
		_inStream->seekg(pos);
	}

	unsigned char c;
	c = (fileSize >> 0) & 0xFF;
	WriteByte(c);
	c = (fileSize >> 8) & 0xFF;
	WriteByte(c);
	c = (fileSize >> 16) & 0xFF;
	WriteByte(c);
	c = (fileSize >> 24) & 0xFF;
	WriteByte(c);

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl (%rsi), %ebp
cmpl $0xf4, %ebp
jne 0x43fe
movq %rdi, %rbx
movq 0xa0(%rdi), %rdi
testq %rdi, %rdi
je 0x43b6
callq 0x34f0
movq %rax, %r15
movq %rdx, %r12
movq 0xa0(%rbx), %rdi
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0x33c0
movq 0xa0(%rbx), %rdi
callq 0x34f0
movq %rax, %r14
movq 0xa0(%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3370
jmp 0x43b9
xorl %r14d, %r14d
movl $0xff, %r15d
movl %r14d, %esi
andl %r15d, %esi
movq %rbx, %rdi
callq 0x4dc8
movl %r14d, %esi
shrl $0x8, %esi
andl %r15d, %esi
movq %rbx, %rdi
callq 0x4dc8
movl %r14d, %esi
shrl $0x10, %esi
andl %r15d, %esi
movq %rbx, %rdi
callq 0x4dc8
shrl $0x18, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4dc8
cmpl $0xf4, %ebp
sete %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/CAksFileTransfert.cpp
// Function: CAksFileTransfert::SendFilename(CAksCommand const&)
bool CAksFileTransfert::SendFilename(const CAksCommand &cmd)
{
	if (cmd != AksSendFilename)
		return false;

	WriteBuffer(_amsFilename, 12);

	return true;
}

// Assembly:
pushq %rbx
movl (%rsi), %ebx
cmpl $0xf5, %ebx
jne 0x4427
leaq 0x68(%rdi), %rsi
pushq $0xc
popq %rdx
callq 0x4e92
cmpl $0xf5, %ebx
sete %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/CAksFileTransfert.cpp
// Function: CAksFileTransfert::Rewind(CAksCommand const&)
bool CAksFileTransfert::Rewind(const CAksCommand &cmd)
{
	if (cmd != AksRewind)
		return false;

	if (_inStream != NULL)
	{
		_inStream->seekg(0,std::ios::beg);
	}

	return true;
}

// Assembly:
pushq %rbx
movl (%rsi), %ebx
cmpl $0xf3, %ebx
jne 0x4452
movq 0xa0(%rdi), %rdi
testq %rdi, %rdi
je 0x4452
xorl %esi, %esi
xorl %edx, %edx
callq 0x33c0
cmpl $0xf3, %ebx
sete %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/CAksFileTransfert.cpp
// Function: CAksFileTransfert::CreateFile(CAksCommand const&)
bool CAksFileTransfert::CreateFile(const CAksCommand &cmd)
{
	if (cmd != AksCreateFile)
		return false;

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

	std::cout << "Filename " << _amsFilename << std::endl;

	if (_outStream != NULL)
		delete _outStream;

	_outStream = new std::ofstream(GetFilename().c_str(), std::ios::binary);

	if (_outStream->good())
	{
		Acknowledge();
		return true;
	}
	else
	{
		NotAcknowledge();
		return false;
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0xf6, (%rsi)
jne 0x4517
movq %rdi, %rbx
leaq 0x68(%rdi), %r14
pushq $0xc
popq %rdx
movq %r14, %rsi
callq 0x4e46
movb $0x0, 0x74(%rbx)
movq 0xfb3a(%rip), %rdi      # 0x13fc8
leaq 0xa1c2(%rip), %rsi      # 0xe657
callq 0x3270
movq %rax, %rdi
movq %r14, %rsi
callq 0x3270
movq %rax, %rdi
callq 0x3130
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
je 0x44bf
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x200, %edi            # imm = 0x200
callq 0x3290
movq %rax, %r14
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x3efc
movq 0x8(%rsp), %rsi
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x32d0
movq %r14, 0xa8(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x3578
movq 0xa8(%rbx), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
cmpl $0x0, 0x20(%rax,%rcx)
je 0x4521
movq %rbx, %rdi
callq 0x4c16
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x4be8
movb $0x1, %al
jmp 0x4519
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3578
jmp 0x453f
movq %rax, %rbx
movl $0x200, %esi            # imm = 0x200
movq %r14, %rdi
callq 0x32a0
movq %rbx, %rdi
callq 0xb830
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/CAksFileTransfert.cpp
// Function: CAksFileTransfert::AddData(CAksCommand const&)
bool CAksFileTransfert::AddData(const CAksCommand &cmd)
{
	if (cmd != AksAddData)
		return false;

	_transferingData = true;

	unsigned short size;

	ReadWaitWord(size);
	
	std::cout << "Read word " << std::hex << (int)size << std::dec << std::endl;

	unsigned char *buffer = new unsigned char[size];

	ReadWaitBuffer(buffer, size);

	if (_outStream != NULL)
	{
		_outStream->write((char*)buffer, size);
	}

	delete[] buffer;

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl (%rsi), %ebp
cmpl $0xf7, %ebp
jne 0x460c
movq %rdi, %rbx
movb $0x1, 0x40(%rdi)
leaq 0x6(%rsp), %r14
movq %r14, %rsi
callq 0x4dd8
movq 0xfa44(%rip), %rdi      # 0x13fc8
leaq 0xa0c1(%rip), %rsi      # 0xe64c
callq 0x3270
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movzwl (%r14), %esi
movq %rax, %rdi
callq 0x34e0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
movq %rax, %rdi
callq 0x3130
movzwl (%r14), %r15d
movq %r15, %rdi
callq 0x3030
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x4e46
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
je 0x4604
movzwl 0x6(%rsp), %edx
movq %r14, %rsi
callq 0x3390
movq %r14, %rdi
callq 0x3380
cmpl $0xf7, %ebp
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/CAksFileTransfert.cpp
// Function: CAksFileTransfert::CloseFile(CAksCommand const&)
bool CAksFileTransfert::CloseFile(const CAksCommand &cmd)
{
	if (cmd != AksCloseFile)
		return false;

	if (_EDSKFile != NULL)
		delete _EDSKFile;
	_EDSKFile = NULL;
	if (_inStream != NULL)
		delete _inStream;
	_inStream = NULL;
	if (_outStream != NULL)
		delete _outStream;
	_outStream = NULL;

	if (_transferingData)
	{
		_nbTransfert ++;
		_transferingData = false;
	}

	return true;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl (%rsi), %ebp
cmpl $0xf8, %ebp
jne 0x468b
movq %rdi, %rbx
movq 0x98(%rdi), %rdi
testq %rdi, %rdi
je 0x4642
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x98(%rbx)
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x465c
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0xa0(%rbx)
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
je 0x4676
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0xa8(%rbx)
cmpb $0x1, 0x40(%rbx)
jne 0x468b
incl 0x3c(%rbx)
movb $0x0, 0x40(%rbx)
cmpl $0xf8, %ebp
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/CAksFileTransfert.cpp
// Function: CAksFileTransfert::InitDSK(CAksCommand const&)
bool CAksFileTransfert::InitDSK(const CAksCommand &cmd)
{
	if (cmd != AksInitDSK)
		return false;

	_transferingData = true;

	if (_EDSKFile != NULL)
		delete _EDSKFile;

	if (_outStream != NULL)
		delete _outStream;
	_outStream = NULL;

	unsigned char nbTrack;
	unsigned char nbSide;
	unsigned char creator[2];
	
	ReadWaitByte(creator[0]);
	ReadWaitByte(creator[1]);
	ReadWaitByte(nbTrack);
	ReadWaitByte(nbSide);

	_EDSKFile = new CExtendedDSKFile(nbTrack, nbSide);

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl (%rsi), %ebp
cmpl $0xf9, %ebp
jne 0x4748
movq %rdi, %rbx
movb $0x1, 0x40(%rdi)
movq 0x98(%rdi), %rdi
testq %rdi, %rdi
je 0x46cf
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
je 0x46e1
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0xa8(%rbx)
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x4d96
leaq 0xd(%rsp), %rsi
movq %rbx, %rdi
callq 0x4d96
leaq 0xf(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4d96
leaq 0xe(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4d96
movl $0x120, %edi            # imm = 0x120
callq 0x3290
movq %rax, %r14
movzbl (%r15), %esi
movzbl (%r12), %edx
movq %rax, %rdi
callq 0x6960
movq %r14, 0x98(%rbx)
cmpl $0xf9, %ebp
sete %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x120, %esi            # imm = 0x120
movq %r14, %rdi
callq 0x32a0
movq %rbx, %rdi
callq 0xb830
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/CAksFileTransfert.cpp
// Function: CAksFileTransfert::NoMoreTrack(CAksCommand const&)
bool CAksFileTransfert::NoMoreTrack(const CAksCommand &cmd)
{
	if (cmd != AksNoMoreTrack)
		return false;

	// Release EDSK file
	if (_EDSKFile != NULL)
	{
		_EDSKFile->SaveDSKFile(GetFilename());

		delete _EDSKFile;
		_EDSKFile = NULL;
	}

	if (_transferingData)
	{
		_nbTransfert ++;
		_transferingData = false;
	}

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl (%rsi), %ebp
cmpl $0xfb, %ebp
jne 0x4ac5
movq %rdi, %rbx
movq 0x98(%rdi), %r14
testq %r14, %r14
je 0x4ab8
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3efc
movq %r14, %rdi
movq %r15, %rsi
callq 0x64b6
leaq 0x8(%rsp), %rdi
callq 0x3578
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x4ab0
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x98(%rbx)
cmpb $0x1, 0x40(%rbx)
jne 0x4ac5
incl 0x3c(%rbx)
movb $0x0, 0x40(%rbx)
cmpl $0xfb, %ebp
sete %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3578
movq %rbx, %rdi
callq 0xb830
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4ba0
movq %rdi, %rbx
leaq 0x68(%rdi), %rsi
pushq $0xc
popq %rdx
callq 0x4e46
movb $0x0, 0x74(%rbx)
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x4b27
movq (%rdi), %rax
callq *0x8(%rax)
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x3efc
movq 0xf48f(%rip), %rdi      # 0x13fc8
leaq 0x9b4a(%rip), %rsi      # 0xe68a
callq 0x3270
movq %rsp, %rsi
movq %rax, %rdi
callq 0x3240
movq %rax, %rdi
callq 0x3130
movl $0x208, %edi            # imm = 0x208
callq 0x3290
movq %rax, %r14
movq (%rsp), %rsi
pushq $0xc
popq %rdx
movq %rax, %rdi
callq 0x3510
movq %r14, 0xa0(%rbx)
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%r14,%rax)
sete %bpl
jne 0x4bad
movq %rbx, %rdi
callq 0x4be8
movq %rsp, %rdi
callq 0x3578
jmp 0x4ba2
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x9ade(%rip), %rdi      # 0xe692
callq 0x3210
movq %rbx, %rdi
callq 0x4c16
jmp 0x4b96
movq %rax, %rbx
movl $0x208, %esi            # imm = 0x208
movq %r14, %rdi
callq 0x32a0
jmp 0x4bd8
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3578
movq %rbx, %rdi
callq 0xb830
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4d06
movq %rbx, %rdi
callq 0x4d58
movl $0x1, 0x30(%rbx)
movq 0x10(%rbx), %rdi
leaq 0x8(%rbx), %rcx
leaq 0x9988(%rip), %rdx      # 0xe6a4
movl $0x1c200, %esi          # imm = 0x1C200
callq 0x8650
testl %eax, %eax
jne 0x4d2e
andl $0x0, 0x30(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4e77
movl 0x8(%r14), %edi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x8a6a
movl %eax, %ecx
movq %r15, %rdx
subq %rcx, %rdx
addq %rcx, %rbx
testl %eax, %eax
jns 0x4e51
testq %r15, %r15
sete %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4ec3
movl 0x8(%r14), %edi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x8a8b
movl %eax, %ecx
movq %r15, %rdx
subq %rcx, %rdx
addq %rcx, %rbx
testl %eax, %eax
jns 0x4e9d
testq %r15, %r15
sete %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/CDSKFile.cpp
// Function: CSDSKDiscHeader::CSDSKDiscHeader()
CSDSKDiscHeader::CSDSKDiscHeader() :
NbTrack(0),
NbSide(0),
TrackSize(0)
{
	char h[] = "MV - CPCEMU Disk-File\r\nDisk-Info\r\n";
	char c[] = "CDSKFile";

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

// Assembly:
leaq 0xecc9(%rip), %rax      # 0x13ba0
movq %rax, (%rdi)
andl $0x0, 0x3a(%rdi)
movaps 0x97db(%rip), %xmm0     # 0xe6c0
movups %xmm0, 0x8(%rdi)
movaps 0x97e0(%rip), %xmm0     # 0xe6d0
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 0x3170
nop
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/CDSKFile.cpp
// Function: CSDSKDiscHeader::Read(std::istream&)
bool CSDSKDiscHeader::Read(std::istream &str)
{
	str.read((char*)&Header, 34);
	str.read((char*)&Creator, 14);
	str.read((char*)&NbTrack, 1);
	str.read((char*)&NbSide, 1);
	str.read((char*)&TrackSize, 2);
	str.read((char*)&Unused, 204);
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rsi
pushq $0x22
popq %rdx
movq %rbx, %rdi
callq 0x3350
leaq 0x2b(%r14), %rsi
pushq $0xe
popq %rdx
movq %rbx, %rdi
callq 0x3350
leaq 0x3a(%r14), %rsi
pushq $0x1
popq %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3350
leaq 0x3b(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3350
leaq 0x3c(%r14), %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x3350
addq $0x3e, %r14
movl $0xcc, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3350
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/CDSKFile.cpp
// Function: CSDSKDiscHeader::Write(std::ostream&) const
bool CSDSKDiscHeader::Write(std::ostream &str) const
{
	str.write((char*)&Header, 34);
	str.write((char*)&Creator, 14);
	str.write((char*)&NbTrack, 1);
	str.write((char*)&NbSide, 1);
	str.write((char*)&TrackSize, 2);
	str.write((char*)&Unused, 204);
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rsi
pushq $0x22
popq %rdx
movq %rbx, %rdi
callq 0x3390
leaq 0x2b(%r14), %rsi
pushq $0xe
popq %rdx
movq %rbx, %rdi
callq 0x3390
leaq 0x3a(%r14), %rsi
pushq $0x1
popq %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3390
leaq 0x3b(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3390
leaq 0x3c(%r14), %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x3390
addq $0x3e, %r14
movl $0xcc, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3390
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %rsi
movq %r14, %rdi
callq 0x3270
leaq 0x969a(%rip), %rsi      # 0xe713
movq %r14, %rdi
callq 0x3270
leaq 0x2b(%rbx), %rsi
movq %rax, %rdi
callq 0x3270
movq %rax, %rdi
callq 0x3130
leaq 0x9682(%rip), %rsi      # 0xe71e
movq %r14, %rdi
callq 0x3270
movzbl 0x3a(%rbx), %esi
movq %rax, %rdi
callq 0x34e0
movq %rax, %rdi
callq 0x3130
leaq 0x966a(%rip), %rsi      # 0xe729
movq %r14, %rdi
callq 0x3270
movzbl 0x3b(%rbx), %esi
movq %rax, %rdi
callq 0x34e0
movq %rax, %rdi
callq 0x3130
leaq 0x9651(%rip), %rsi      # 0xe733
movq %r14, %rdi
callq 0x3270
movzwl 0x3c(%rbx), %esi
movq %rax, %rdi
callq 0x34e0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3130
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xeae3(%rip), %rax      # 0x13bf0
movq %rax, (%rdi)
andl $0x0, 0x3a(%rdi)
movaps 0x95d5(%rip), %xmm0     # 0xe6f0
movups %xmm0, 0x8(%rdi)
movaps 0x95da(%rip), %xmm0     # 0xe700
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 0x3170
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %rsi
movq %r14, %rdi
callq 0x3270
leaq 0x9456(%rip), %rsi      # 0xe713
movq %r14, %rdi
callq 0x3270
leaq 0x2b(%rbx), %rsi
movq %rax, %rdi
callq 0x3270
movq %rax, %rdi
callq 0x3130
leaq 0x943e(%rip), %rsi      # 0xe71e
movq %r14, %rdi
callq 0x3270
movzbl 0x3a(%rbx), %esi
movq %rax, %rdi
callq 0x34e0
movq %rax, %rdi
callq 0x3130
leaq 0x9426(%rip), %rsi      # 0xe729
movq %r14, %rdi
callq 0x3270
movzbl 0x3b(%rbx), %esi
movq %rax, %rdi
callq 0x34e0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3130
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %r15
movq %rsi, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3350
leaq 0x1(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3350
leaq 0x2(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3350
leaq 0x3(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3350
leaq 0x4(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3350
leaq 0x5(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3350
addq $0x6, %r14
pushq $0x2
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3350
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %r15
movq %rsi, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3390
leaq 0x1(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3390
leaq 0x2(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3390
leaq 0x3(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3390
leaq 0x4(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3390
leaq 0x5(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3390
addq $0x6, %r14
pushq $0x2
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3390
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5498
movzwl 0x6(%r14), %eax
movb 0x3(%r14), %cl
movl $0x80, %edx
shll %cl, %edx
testl %eax, %eax
cmovnel %eax, %edx
movq 0x8(%r14), %rsi
movslq %edx, %rdx
movq %rbx, %rdi
callq 0x3350
movq %r14, %rdi
callq 0x54e8
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x54aa
callq 0x3380
andq $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 0x54d2
movslq %eax, %rdi
callq 0x3030
movq %rax, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movb 0x3(%rdi), %cl
movl $0x80, %eax
shll %cl, %eax
movzwl 0x6(%rdi), %ecx
testl %ecx, %ecx
cmovnel %ecx, %eax
movb $0x0, 0x10(%rdi)
movq 0x8(%rdi), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
xorl %esi, %esi
cmpq %rdx, %rax
je 0x551e
addb (%rcx,%rdx), %sil
movb %sil, 0x10(%rdi)
incq %rdx
jmp 0x550c
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x34f0
movq %rax, %r15
pushq $0xd
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3350
leaq 0xe(%rbx), %rsi
pushq $0x3
popq %rdx
movq %r14, %rdi
callq 0x3350
leaq 0x11(%rbx), %rsi
pushq $0x1
popq %r13
movq %r14, %rdi
movq %r13, %rdx
callq 0x3350
leaq 0x12(%rbx), %rsi
movq %r14, %rdi
movq %r13, %rdx
callq 0x3350
leaq 0x13(%rbx), %rsi
movq %r14, %rdi
movq %r13, %rdx
callq 0x3350
leaq 0x14(%rbx), %rsi
movq %r14, %rdi
movq %r13, %rdx
callq 0x3350
leaq 0x15(%rbx), %rsi
movq %r14, %rdi
movq %r13, %rdx
callq 0x3350
leaq 0x16(%rbx), %r12
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x3350
leaq 0x17(%rbx), %rsi
movq %r14, %rdi
movq %r13, %rdx
callq 0x3350
leaq 0x18(%rbx), %rsi
movq %r14, %rdi
movq %r13, %rdx
callq 0x3350
movq %rbx, %rdi
callq 0x5afa
xorl %r13d, %r13d
xorl %ebp, %ebp
movzbl (%r12), %eax
cmpq %rax, %rbp
jae 0x5aa5
movq 0x20(%rbx), %rdi
addq %r13, %rdi
movq %r14, %rsi
callq 0x534e
incq %rbp
addq $0x20, %r13
jmp 0x5a83
addl $0x100, %r15d           # imm = 0x100
xorl %r13d, %r13d
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3370
xorl %r15d, %r15d
movzbl (%r12), %eax
cmpq %rax, %r15
jae 0x5ae1
movq 0x20(%rbx), %rdi
addq %r13, %rdi
movq %r14, %rsi
callq 0x5452
incq %r15
addq $0x20, %r13
jmp 0x5abf
movq %rbx, %rdi
callq 0x5baa
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_O2/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 0x5b4b
leaq -0x8(%r12), %r14
movq -0x8(%r12), %r15
testq %r15, %r15
je 0x5b38
addq $-0x20, %r12
movq %r15, %r13
shlq $0x5, %r13
leaq (%r12,%r13), %rdi
callq 0x5340
addq $-0x20, %r13
jne 0x5b29
shlq $0x5, %r15
orq $0x8, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3550
andq $0x0, 0x20(%rbx)
movzbl 0x16(%rbx), %r15d
testq %r15, %r15
je 0x5ba0
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 0x5b84
movq %rcx, 0x20(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x18, %rsp
movzbl 0x16(%rdi), %r14d
movq %rdi, (%rsp)
movq 0x20(%rdi), %rax
addq $0x14, %rax
xorl %ecx, %ecx
cmpq %rcx, %r14
je 0x5bdb
movl %ecx, (%rax)
incq %rcx
addq $0x20, %rax
jmp 0x5bcb
cmpl $0x2, %r14d
pushq $0x1
popq %rax
cmovgel %r14d, %eax
decl %eax
movq %rax, 0x8(%rsp)
pushq $0x1
popq %r13
pushq $0x22
popq %rcx
xorl %r15d, %r15d
cmpq 0x8(%rsp), %r15
je 0x5c92
movq (%rsp), %rax
movq 0x20(%rax), %rbx
movq %r15, %rbp
shlq $0x5, %rbp
addq %rbx, %rbp
movq %rcx, 0x10(%rsp)
addq %rcx, %rbx
movq %r13, %r12
cmpq %r14, %r12
jae 0x5c7e
movb 0x10(%rbp), %al
cmpb 0xe(%rbx), %al
jne 0x5c75
movb 0x2(%rbp), %al
cmpb (%rbx), %al
jne 0x5c75
movb 0x3(%rbp), %cl
movl $0x80, %eax
shll %cl, %eax
movzwl 0x6(%rbp), %ecx
testl %ecx, %ecx
cmovnel %ecx, %eax
movzwl 0x4(%rbx), %edx
movb 0x1(%rbx), %cl
movl $0x80, %esi
shll %cl, %esi
testl %edx, %edx
cmovnel %edx, %esi
cmpl %esi, %eax
jne 0x5c75
movq 0x8(%rbp), %rdi
movq 0x6(%rbx), %rsi
movslq %eax, %rdx
callq 0x32b0
testl %eax, %eax
jne 0x5c75
movl %r15d, 0x16(%rbx)
incq %r12
addq $0x20, %rbx
jmp 0x5c1f
incq %r15
incq %r13
movq 0x10(%rsp), %rcx
addq $0x20, %rcx
jmp 0x5bf7
movq (%rsp), %rax
movb $0x1, 0x19(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pelrun[P]aft/CDSKFile.cpp
// Function: 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 0x3220
movq %rax, %r15
pushq $0xd
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3390
leaq 0xe(%r14), %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x3390
leaq 0x11(%r14), %rsi
pushq $0x1
popq %r13
movq %rbx, %rdi
movq %r13, %rdx
callq 0x3390
leaq 0x12(%r14), %rsi
movq %rbx, %rdi
movq %r13, %rdx
callq 0x3390
leaq 0x13(%r14), %rsi
movq %rbx, %rdi
movq %r13, %rdx
callq 0x3390
leaq 0x14(%r14), %rsi
movq %rbx, %rdi
movq %r13, %rdx
callq 0x3390
leaq 0x15(%r14), %rsi
movq %rbx, %rdi
movq %r13, %rdx
callq 0x3390
leaq 0x16(%r14), %r12
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x3390
leaq 0x17(%r14), %rsi
movq %rbx, %rdi
movq %r13, %rdx
callq 0x3390
leaq 0x18(%r14), %rsi
movq %rbx, %rdi
movq %r13, %rdx
callq 0x3390
xorl %r13d, %r13d
xorl %ebp, %ebp
movzbl (%r12), %eax
cmpq %rax, %rbp
jae 0x5d89
movq 0x20(%r14), %rdi
addq %r13, %rdi
movq %rbx, %rsi
callq 0x53d0
incq %rbp
addq $0x20, %r13
jmp 0x5d67
movq %rbx, %rdi
callq 0x3220
subq %rax, %r15
addq $0x100, %r15            # imm = 0x100
testl %r15d, %r15d
je 0x5dd1
movslq %r15d, %r15
movq %r15, %rdi
callq 0x3030
movq %rax, %r13
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x3170
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x3390
movq %r13, %rdi
callq 0x3380
xorl %r15d, %r15d
xorl %r13d, %r13d
movzbl (%r12), %eax
cmpq %rax, %r13
jae 0x5df9
movq 0x20(%r14), %rdi
addq %r15, %rdi
movq %rbx, %rsi
callq 0x5520
incq %r13
addq $0x20, %r15
jmp 0x5dd7
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq