LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mgo1977[P]c---parsing-argument-options/./Parser.h
// Function: Parser::findOption(char)
BaseOption*
Parser::findOption(char shortOption) {

    // iterate over the array and search for the short option
    for(int index=0; index < options.size(); ++index) {

        BaseOption* option = options.at(index);

        if ( option->matches( shortOption ) )
            return option;

    }

    return NULL;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x60, %rdi
callq 0x5cb0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x41a4
movq -0x28(%rbp), %rdi
addq $0x60, %rdi
movslq -0x18(%rbp), %rsi
callq 0x5cd0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0x5d10
testb $0x1, %al
jne 0x418d
jmp 0x4197
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x41ac
jmp 0x4199
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4141
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x33a0
movq -0x18(%rbp), %rdi
callq 0x5bc0
movb %al, -0x79(%rbp)
jmp 0x4af3
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x4afc
jmp 0x4b4c
movq -0x90(%rbp), %rdi
leaq 0x75b6(%rip), %rsi      # 0xc0c0
callq 0x3240
jmp 0x4b11
movq -0x18(%rbp), %rdi
callq 0x5be0
movb %al, -0x91(%rbp)
jmp 0x4b22
movq -0x90(%rbp), %rdi
movb -0x91(%rbp), %al
movsbl %al, %esi
callq 0x3170
jmp 0x4b39
jmp 0x4b4c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x4c3c
movq -0x18(%rbp), %rdi
callq 0x5c00
movb %al, -0x92(%rbp)
jmp 0x4b5d
movb -0x92(%rbp), %al
testb $0x1, %al
jne 0x4b6c
jmp 0x4c16
movq -0x18(%rbp), %rdi
callq 0x5bc0
movb %al, -0x93(%rbp)
jmp 0x4b7d
movb -0x93(%rbp), %al
testb $0x1, %al
jne 0x4b89
jmp 0x4b9d
movq -0x90(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3240
jmp 0x4b9b
jmp 0x4b9d
movq -0x18(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x5c80
jmp 0x4bac
leaq 0x750c(%rip), %rsi      # 0xc0bf
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x5c30
jmp 0x4bc2
movq -0x90(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3360
jmp 0x4bd4
leaq -0x58(%rbp), %rdi
callq 0x3160
leaq -0x78(%rbp), %rdi
callq 0x3160
jmp 0x4c16
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x4c0b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3160
leaq -0x78(%rbp), %rdi
callq 0x3160
jmp 0x4c3c
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x4c2c
movq -0x90(%rbp), %rdi
callq 0x3160
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x3160
movq -0x30(%rbp), %rdi
callq 0x3480
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3190
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x10, %rdi
callq 0x3190
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jbe 0x5e20
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5ea4
movl $0x0, -0x20(%rbp)
movslq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3190
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x5e9e
movq -0x18(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x32e0
movsbl (%rax), %edi
callq 0x33c0
movq -0x30(%rbp), %rdi
movl %eax, -0x3c(%rbp)
addq $0x10, %rdi
movslq -0x20(%rbp), %rsi
callq 0x32e0
movsbl (%rax), %edi
callq 0x33c0
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jne 0x5e89
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5e91
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5ea4
jmp 0x5e93
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5e27
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: mgo1977[P]c---parsing-argument-options/./Parser.h
// Function: Option<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::getValue()
TYPE getValue() {

        if ( ! found )
            return defaultValue;
        else
            return value;

    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x58(%rax)
jne 0x63ef
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x80, %rsi
callq 0x30f0
jmp 0x6400
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x60, %rsi
callq 0x30f0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rsi
callq 0x30f0
movl $0x0, -0x20(%rbp)
movq -0x40(%rbp), %rdi
movslq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x3190
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x6cb0
movq -0x40(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x34e0
movq %rax, -0x50(%rbp)
jmp 0x6c63
movq -0x50(%rbp), %rax
movsbl (%rax), %edi
callq 0x33c0
movq -0x40(%rbp), %rdi
movb %al, -0x59(%rbp)
movslq -0x20(%rbp), %rsi
callq 0x34e0
movq %rax, -0x58(%rbp)
jmp 0x6c85
movq -0x58(%rbp), %rax
movb -0x59(%rbp), %cl
movb %cl, (%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6c33
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3160
jmp 0x6ccd
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x6cc3
movq -0x40(%rbp), %rdi
callq 0x3160
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3480
nopw %cs:(%rax,%rax)
// File: 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
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x33a0
movq -0x10(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x7240
movq -0x1d0(%rbp), %rsi
movl %eax, %edx
leaq -0x1b8(%rbp), %rdi
callq 0x3420
jmp 0x8809
leaq -0x1b8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3350
movq %rax, -0x1d8(%rbp)
jmp 0x8822
movq -0x1d8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3340
movb %al, -0x1d9(%rbp)
jmp 0x8840
movb -0x1d9(%rbp), %al
testb $0x1, %al
jne 0x884c
jmp 0x8890
movb $0x1, -0x1(%rbp)
movl $0x1, -0x1c8(%rbp)
jmp 0x889e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x88c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x31d0
jmp 0x88c1
movb $0x0, -0x1(%rbp)
movl $0x1, -0x1c8(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x31d0
leaq -0x30(%rbp), %rdi
callq 0x3160
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x3160
movq -0x1c0(%rbp), %rdi
callq 0x3480
nopw %cs:(%rax,%rax)
// File: 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
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x1c8(%rbp)
movq %rdi, %rax
movq %rax, -0x1c0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x33a0
movq -0x10(%rbp), %rax
movq %rax, -0x1b8(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x7240
movq -0x1b8(%rbp), %rsi
movl %eax, %edx
leaq -0x1a0(%rbp), %rdi
callq 0x3420
jmp 0x897e
movq -0x1c8(%rbp), %rsi
leaq -0x1a0(%rbp), %rdi
callq 0x3350
jmp 0x8993
movb $0x1, -0x11(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x31d0
testb $0x1, -0x11(%rbp)
jne 0x89eb
jmp 0x89df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x89fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x31d0
jmp 0x89fb
movq -0x1c8(%rbp), %rdi
callq 0x3160
movq -0x1c0(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq -0x1c8(%rbp), %rdi
callq 0x3160
movq -0x1a8(%rbp), %rdi
callq 0x3480
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x3490
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x5690
jmp 0xa852
leaq -0x31(%rbp), %rdi
callq 0x32c0
leaq 0x1a56(%rip), %rsi      # 0xc2b8
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0xd0(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x34d0
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rcx
leaq -0x70(%rbp), %rdi
callq 0x3290
jmp 0xa89e
leaq -0x90(%rbp), %rdi
callq 0x33a0
movq -0x50(%rbp), %rdx
leaq -0x30(%rbp), %rdi
leaq 0x19ff(%rip), %rsi      # 0xc2b8
callq 0x34d0
cmpq $-0x1, %rax
je 0xa957
movq -0x50(%rbp), %rdx
incq %rdx
leaq -0xb0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movq $-0x1, %rcx
callq 0x3290
jmp 0xa8e8
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x3320
leaq -0xb0(%rbp), %rdi
callq 0x3160
jmp 0xa957
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x32c0
jmp 0xa9d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xa9c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x3160
leaq -0x70(%rbp), %rdi
callq 0x3160
jmp 0xa9c9
leaq -0x90(%rbp), %rdi
callq 0x3190
cmpq $0x0, %rax
je 0xa9a2
leaq -0x70(%rbp), %rdi
callq 0x30e0
movq -0xc8(%rbp), %rdi
movq %rax, %rsi
callq 0x82f0
jmp 0xa983
leaq -0x90(%rbp), %rdi
callq 0x30e0
movq -0xc8(%rbp), %rdi
movq %rax, %rsi
callq 0x82f0
jmp 0xa9a0
jmp 0xa9a2
leaq -0x90(%rbp), %rdi
callq 0x3160
leaq -0x70(%rbp), %rdi
callq 0x3160
leaq -0x30(%rbp), %rdi
callq 0x3160
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x3160
movq -0x40(%rbp), %rdi
callq 0x3480
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x1520e(%rip), %rcx     # 0x1aac8
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, 0x98(%rax)
je 0x58ef
movq 0x18(%rsp), %rax
movq 0x98(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x58ed
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x58ef
movq 0x18(%rsp), %rax
cmpq $0x0, 0xa0(%rax)
je 0x5922
movq 0x18(%rsp), %rax
movq 0xa0(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x5920
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x5922
movq 0x18(%rsp), %rax
cmpq $0x0, 0xa8(%rax)
je 0x5953
movq 0x18(%rsp), %rax
movq 0xa8(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x5951
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x5953
movq 0x18(%rsp), %rdi
addq $0x78, %rdi
callq 0x46a8
movq 0x18(%rsp), %rdi
addq $0x48, %rdi
callq 0x46a8
movq 0x18(%rsp), %rdi
callq 0x7510
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x20(%rsp)
addq $0x48, %rdi
callq 0x41f0
cmpq $0x0, %rax
je 0x5a5c
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
addq $0x48, %rsi
callq 0x4150
jmp 0x5b28
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
leaq 0xfb5f(%rip), %rax      # 0x155cc
movq %rax, 0x40(%rsp)
movb $0x0, 0x3f(%rsp)
addq $0x78, %rsi
callq 0x4150
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x42e0
jmp 0x5a91
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
addq $0x68, %rsi
callq 0x42e0
jmp 0x5aa6
movq 0x10(%rsp), %rdi
callq 0x41f0
movl %eax, 0x28(%rsp)
movq 0x10(%rsp), %rdi
movl 0x28(%rsp), %eax
decl %eax
movl %eax, 0x28(%rsp)
movslq %eax, %rsi
callq 0x4690
movq %rax, 0x8(%rsp)
jmp 0x5ad2
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x5afb
jmp 0x5ab4
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x46a8
jmp 0x5b32
movq 0x10(%rsp), %rdi
movl 0x28(%rsp), %eax
incl %eax
movslq %eax, %rsi
callq 0x44f0
jmp 0x5b10
movb $0x1, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0x5b26
movq 0x10(%rsp), %rdi
callq 0x46a8
jmp 0x5b28
movq 0x18(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x11ab0
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movzbl 0x1f(%rsp), %esi
andl $0x1, %esi
callq 0x5ce0
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
addl $0xffffff10, %eax       # imm = 0xFFFFFF10
movl %eax, %ecx
movq %rcx, 0x10(%rsp)
subl $0xc, %eax
ja 0x5cad
movq 0x10(%rsp), %rax
leaq 0xf5e2(%rip), %rcx      # 0x15194
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x5e70
jmp 0x5ccc
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x5ec0
jmp 0x5ccc
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x5fe0
jmp 0x5ccc
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x6120
jmp 0x5ccc
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x6290
jmp 0x5ccc
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x62f0
jmp 0x5ccc
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x6360
jmp 0x5ccc
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x6510
jmp 0x5ccc
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x6620
jmp 0x5ccc
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x6740
jmp 0x5ccc
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x68a0
jmp 0x5ccc
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x6dd0
jmp 0x5ccc
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x6ed0
jmp 0x5ccc
leaq 0xf91a(%rip), %rdi      # 0x155ce
leaq 0xf919(%rip), %rsi      # 0x155d4
movl $0x8b, %edx
leaq 0xf923(%rip), %rcx      # 0x155ea
callq 0x41d0
movl 0x18(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movb $0x0, 0x15(%rsp)
testb $0x1, 0x17(%rsp)
je 0x5d1e
movq 0x8(%rsp), %rdi
leaq 0x16(%rsp), %rsi
callq 0x75f0
movb $0x1, 0x15(%rsp)
jmp 0x5d39
movq 0x8(%rsp), %rdi
leaq 0x16(%rsp), %rsi
callq 0x7630
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x15(%rsp)
testb $0x1, 0x15(%rsp)
je 0x5e33
movzbl 0x16(%rsp), %eax
cmpl $0xef, %eax
jle 0x5deb
movzbl 0x16(%rsp), %eax
cmpl $0xfd, %eax
jge 0x5deb
movq 0x1525d(%rip), %rdi     # 0x1afc8
leaq 0xf8a1(%rip), %rsi      # 0x15613
callq 0x42f0
movq %rax, %rdi
leaq 0x150f(%rip), %rsi      # 0x7290
callq 0x4100
movq %rax, %rdi
movzbl 0x16(%rsp), %esi
callq 0x45f0
movq %rax, %rdi
leaq 0x1513(%rip), %rsi      # 0x72b0
callq 0x4100
movq %rax, %rdi
leaq 0xfbdf(%rip), %rsi      # 0x1598b
callq 0x42f0
movq %rax, %rdi
movzbl 0x16(%rsp), %eax
subl $0xf0, %eax
movslq %eax, %rcx
leaq 0x15678(%rip), %rax     # 0x1b440
movq (%rax,%rcx,8), %rsi
callq 0x42f0
movq %rax, %rdi
movq 0x151cd(%rip), %rsi     # 0x1afa8
callq 0x4360
movzbl 0x16(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x5e5d
movq 0x151d6(%rip), %rdi     # 0x1afc8
leaq 0xf824(%rip), %rsi      # 0x1561d
callq 0x42f0
movq %rax, %rdi
leaq 0x1488(%rip), %rsi      # 0x7290
callq 0x4100
movq %rax, %rdi
movzbl 0x16(%rsp), %esi
callq 0x45f0
movq %rax, %rdi
movq 0x15184(%rip), %rsi     # 0x1afa8
callq 0x4360
movl $0x0, 0x24(%rsp)
jmp 0x5e5d
movq 0x1518e(%rip), %rdi     # 0x1afc8
leaq 0xf7fa(%rip), %rsi      # 0x1563b
callq 0x42f0
movq %rax, %rdi
movq 0x15158(%rip), %rsi     # 0x1afa8
callq 0x4360
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: pelrun[P]aft/CAksFileTransfert.cpp
// Function: CAksFileTransfert::TestComunication(CAksCommand const&)
bool CAksFileTransfert::TestComunication(const CAksCommand &cmd)
{
	if (cmd != AksTestComunication)
		return false;

	Acknowledge();

	return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpl $0xf0, (%rax)
je 0x5e9c
movb $0x0, 0x27(%rsp)
jmp 0x5eab
movq 0x8(%rsp), %rdi
callq 0x70d0
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
cmpl $0xf2, (%rax)
je 0x5eef
movb $0x0, 0x37(%rsp)
jmp 0x5fc9
movq 0x18(%rsp), %rax
cmpq $0x0, 0x98(%rax)
je 0x5f22
movq 0x18(%rsp), %rax
movq 0x98(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x5f20
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x5f22
movq 0x18(%rsp), %rax
movq $0x0, 0x98(%rax)
cmpq $0x0, 0xa0(%rax)
je 0x5f60
movq 0x18(%rsp), %rax
movq 0xa0(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x5f5e
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x5f60
movq 0x18(%rsp), %rax
movq $0x0, 0xa0(%rax)
cmpq $0x0, 0xa8(%rax)
je 0x5f9c
movq 0x18(%rsp), %rax
movq 0xa8(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x5f9a
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x5f9c
movq 0x18(%rsp), %rax
movq $0x0, 0xa8(%rax)
testb $0x1, 0x40(%rax)
je 0x5fc4
movq 0x18(%rsp), %rax
movl 0x3c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x3c(%rax)
movb $0x0, 0x40(%rax)
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
cmpl $0xf1, (%rax)
je 0x600f
movb $0x0, 0x47(%rsp)
jmp 0x610d
movq 0x18(%rsp), %rdi
movb $0x1, 0x40(%rdi)
leaq 0x2e(%rsp), %rsi
callq 0x7690
movq 0x14f9f(%rip), %rdi     # 0x1afc8
leaq 0xf634(%rip), %rsi      # 0x15664
callq 0x42f0
movq %rax, %rdi
leaq 0x1251(%rip), %rsi      # 0x7290
callq 0x4100
movq %rax, %rdi
movzwl 0x2e(%rsp), %esi
callq 0x45f0
movq %rax, %rdi
leaq 0x1255(%rip), %rsi      # 0x72b0
callq 0x4100
movq %rax, %rdi
movq 0x14f3e(%rip), %rsi     # 0x1afa8
callq 0x4360
movzwl 0x2e(%rsp), %eax
cmpl $0x0, %eax
je 0x6084
movzwl 0x2e(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x608f
movl $0x10000, %eax          # imm = 0x10000
movl %eax, 0x14(%rsp)
jmp 0x608f
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, 0x28(%rsp)
cmpq $0x0, 0xa0(%rax)
je 0x6108
movslq 0x28(%rsp), %rdi
callq 0x4030
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x20(%rsp)
movq 0xa0(%rax), %rdi
movq 0x20(%rsp), %rsi
movslq 0x28(%rsp), %rdx
callq 0x4460
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movslq 0x28(%rsp), %rdx
callq 0x7810
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x6101
movq 0x8(%rsp), %rdi
callq 0x4490
movb $0x1, 0x47(%rsp)
jmp 0x610d
movb $0x0, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rax
cmpl $0xf4, (%rax)
je 0x614f
movb $0x0, 0x67(%rsp)
jmp 0x627e
movq 0x8(%rsp), %rax
movl $0x0, 0x4c(%rsp)
cmpq $0x0, 0xa0(%rax)
je 0x61fd
movq 0x8(%rsp), %rax
movq 0xa0(%rax), %rdi
callq 0x4600
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0xa0(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x44d0
movq 0x8(%rsp), %rax
movq 0xa0(%rax), %rdi
callq 0x4600
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x72d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movl %ecx, 0x4c(%rsp)
movq 0xa0(%rax), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x4480
movq 0x8(%rsp), %rdi
movl 0x4c(%rsp), %eax
sarl $0x0, %eax
andl $0xff, %eax
movb %al, 0x17(%rsp)
movzbl 0x17(%rsp), %esi
callq 0x7660
movq 0x8(%rsp), %rdi
movl 0x4c(%rsp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, 0x17(%rsp)
movzbl 0x17(%rsp), %esi
callq 0x7660
movq 0x8(%rsp), %rdi
movl 0x4c(%rsp), %eax
sarl $0x10, %eax
andl $0xff, %eax
movb %al, 0x17(%rsp)
movzbl 0x17(%rsp), %esi
callq 0x7660
movq 0x8(%rsp), %rdi
movl 0x4c(%rsp), %eax
sarl $0x18, %eax
andl $0xff, %eax
movb %al, 0x17(%rsp)
movzbl 0x17(%rsp), %esi
callq 0x7660
movb $0x1, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpl $0xf5, (%rax)
je 0x62bc
movb $0x0, 0x27(%rsp)
jmp 0x62d7
movq 0x8(%rsp), %rdi
movq %rdi, %rsi
addq $0x68, %rsi
movl $0xc, %edx
callq 0x7810
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpl $0xf3, (%rax)
je 0x631c
movb $0x0, 0x27(%rsp)
jmp 0x6347
movq 0x8(%rsp), %rax
cmpq $0x0, 0xa0(%rax)
je 0x6342
movq 0x8(%rsp), %rax
movq 0xa0(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x44d0
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rax
cmpl $0xf6, (%rax)
je 0x638f
movb $0x0, 0x67(%rsp)
jmp 0x64f7
movq 0x18(%rsp), %rdi
movq %rdi, %rsi
addq $0x68, %rsi
movl $0xc, %edx
callq 0x7730
movq 0x18(%rsp), %rax
movb $0x0, 0x74(%rax)
movq 0x14c13(%rip), %rdi     # 0x1afc8
leaq 0xf2b3(%rip), %rsi      # 0x1566f
callq 0x42f0
movq 0x18(%rsp), %rsi
movq %rax, %rdi
addq $0x68, %rsi
callq 0x4330
movq %rax, %rdi
movq 0x14bcc(%rip), %rsi     # 0x1afa8
callq 0x4360
movq 0x18(%rsp), %rax
cmpq $0x0, 0xa8(%rax)
je 0x6414
movq 0x18(%rsp), %rax
movq 0xa8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x6412
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x6414
movl $0x200, %edi            # imm = 0x200
callq 0x4310
movq 0x18(%rsp), %rsi
movq %rax, 0x8(%rsp)
movb $0x1, 0x23(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5a10
jmp 0x6439
leaq 0x30(%rsp), %rdi
callq 0x4140
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movl $0x4, %edx
callq 0x4390
jmp 0x6457
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x0, 0x23(%rsp)
movq %rcx, 0xa8(%rax)
leaq 0x30(%rsp), %rdi
callq 0x46a8
movq 0x18(%rsp), %rax
movq 0xa8(%rax), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x45d0
testb $0x1, %al
jne 0x6495
jmp 0x64e8
movq 0x18(%rsp), %rdi
callq 0x70d0
movb $0x1, 0x67(%rsp)
jmp 0x64f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x64ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x46a8
testb $0x1, 0x23(%rsp)
jne 0x64d7
jmp 0x64e6
movq 0x8(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x4320
jmp 0x6502
movq 0x18(%rsp), %rdi
callq 0x7120
movb $0x0, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x11ab0
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
cmpl $0xf7, (%rax)
je 0x653f
movb $0x0, 0x37(%rsp)
jmp 0x660f
movq 0x8(%rsp), %rdi
movb $0x1, 0x40(%rdi)
leaq 0x1e(%rsp), %rsi
callq 0x7690
movq 0x14a6f(%rip), %rdi     # 0x1afc8
leaq 0xf104(%rip), %rsi      # 0x15664
callq 0x42f0
movq %rax, %rdi
leaq 0xd21(%rip), %rsi       # 0x7290
callq 0x4100
movq %rax, %rdi
movzwl 0x1e(%rsp), %esi
callq 0x45f0
movq %rax, %rdi
leaq 0xd25(%rip), %rsi       # 0x72b0
callq 0x4100
movq %rax, %rdi
movq 0x14a0e(%rip), %rsi     # 0x1afa8
callq 0x4360
movzwl 0x1e(%rsp), %eax
movl %eax, %edi
callq 0x4030
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
movzwl 0x1e(%rsp), %eax
movl %eax, %edx
callq 0x7730
movq 0x8(%rsp), %rax
cmpq $0x0, 0xa8(%rax)
je 0x65f2
movq 0x8(%rsp), %rax
movq 0xa8(%rax), %rdi
movq 0x10(%rsp), %rsi
movzwl 0x1e(%rsp), %eax
movl %eax, %edx
callq 0x44a0
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x660a
movq (%rsp), %rdi
callq 0x4490
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
cmpl $0xf8, (%rax)
je 0x664f
movb $0x0, 0x37(%rsp)
jmp 0x6729
movq 0x18(%rsp), %rax
cmpq $0x0, 0x98(%rax)
je 0x6682
movq 0x18(%rsp), %rax
movq 0x98(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x6680
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x6682
movq 0x18(%rsp), %rax
movq $0x0, 0x98(%rax)
cmpq $0x0, 0xa0(%rax)
je 0x66c0
movq 0x18(%rsp), %rax
movq 0xa0(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x66be
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x66c0
movq 0x18(%rsp), %rax
movq $0x0, 0xa0(%rax)
cmpq $0x0, 0xa8(%rax)
je 0x66fc
movq 0x18(%rsp), %rax
movq 0xa8(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x66fa
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x66fc
movq 0x18(%rsp), %rax
movq $0x0, 0xa8(%rax)
testb $0x1, 0x40(%rax)
je 0x6724
movq 0x18(%rsp), %rax
movl 0x3c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x3c(%rax)
movb $0x0, 0x40(%rax)
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
cmpl $0xf9, (%rax)
je 0x676f
movb $0x0, 0x57(%rsp)
jmp 0x687d
movq 0x20(%rsp), %rax
movb $0x1, 0x40(%rax)
cmpq $0x0, 0x98(%rax)
je 0x67a6
movq 0x20(%rsp), %rax
movq 0x98(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x67a4
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x67a6
movq 0x20(%rsp), %rax
cmpq $0x0, 0xa8(%rax)
je 0x67d9
movq 0x20(%rsp), %rax
movq 0xa8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x67d7
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x67d9
movq 0x20(%rsp), %rdi
movq $0x0, 0xa8(%rdi)
leaq 0x3c(%rsp), %rsi
callq 0x75f0
movq 0x20(%rsp), %rdi
leaq 0x3d(%rsp), %rsi
callq 0x75f0
movq 0x20(%rsp), %rdi
leaq 0x3f(%rsp), %rsi
callq 0x75f0
movq 0x20(%rsp), %rdi
leaq 0x3e(%rsp), %rsi
callq 0x75f0
movl $0x120, %edi            # imm = 0x120
callq 0x4310
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movzbl 0x3f(%rsp), %esi
movzbl 0x3e(%rsp), %edx
callq 0xa9e0
jmp 0x6846
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x98(%rax)
movb $0x1, 0x57(%rsp)
jmp 0x687d
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl $0x120, %esi            # imm = 0x120
callq 0x4320
jmp 0x6888
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x11ab0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rax
cmpl $0xfb, (%rax)
je 0x6dff
movb $0x0, 0x67(%rsp)
jmp 0x6ebb
movq 0x18(%rsp), %rax
cmpq $0x0, 0x98(%rax)
je 0x6e99
movq 0x18(%rsp), %rsi
movq 0x98(%rsi), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x5a10
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xa270
jmp 0x6e43
leaq 0x30(%rsp), %rdi
callq 0x46a8
movq 0x18(%rsp), %rax
movq 0x98(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x6e6d
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x98(%rax)
jmp 0x6e99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x46a8
jmp 0x6ec6
movq 0x18(%rsp), %rax
testb $0x1, 0x40(%rax)
je 0x6eb6
movq 0x18(%rsp), %rax
movl 0x3c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x3c(%rax)
movb $0x0, 0x40(%rax)
movb $0x1, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x11ab0
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x70(%rsp), %rax
cmpl $0xfc, (%rax)
je 0x6f05
movb $0x0, 0x87(%rsp)
jmp 0x70b4
movq 0x38(%rsp), %rdi
movq %rdi, %rsi
addq $0x68, %rsi
movl $0xc, %edx
callq 0x7730
movq 0x38(%rsp), %rax
movb $0x0, 0x74(%rax)
cmpq $0x0, 0xa0(%rax)
je 0x6f52
movq 0x38(%rsp), %rax
movq 0xa0(%rax), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, %rax
je 0x6f50
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x6f52
movq 0x38(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x5a10
movq 0x14060(%rip), %rdi     # 0x1afc8
leaq 0xe733(%rip), %rsi      # 0x156a2
callq 0x42f0
movq %rax, 0x28(%rsp)
jmp 0x6f7b
movq 0x28(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x42b0
movq %rax, 0x20(%rsp)
jmp 0x6f91
movq 0x20(%rsp), %rdi
movq 0x1400b(%rip), %rsi     # 0x1afa8
callq 0x4360
jmp 0x6fa4
movl $0x208, %edi            # imm = 0x208
callq 0x4310
movq %rax, 0x18(%rsp)
jmp 0x6fb5
leaq 0x50(%rsp), %rdi
callq 0x4140
movq %rax, 0x8(%rsp)
movl $0x4, %edi
movl $0x8, %esi
callq 0x72e0
movl %eax, 0x14(%rsp)
jmp 0x6fd9
movl 0x14(%rsp), %edx
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdi
callq 0x4630
jmp 0x6fee
movq 0x38(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0xa0(%rax)
movq 0xa0(%rax), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x45d0
movb %al, 0x7(%rsp)
jmp 0x701b
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x7025
jmp 0x7072
movq 0x38(%rsp), %rdi
callq 0x70d0
jmp 0x7031
movb $0x1, 0x87(%rsp)
movl $0x1, 0x40(%rsp)
jmp 0x709c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x70a8
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
movl $0x208, %esi            # imm = 0x208
callq 0x4320
jmp 0x70a8
leaq 0xe631(%rip), %rdi      # 0x156aa
callq 0x4270
jmp 0x7080
movq 0x38(%rsp), %rdi
callq 0x7120
jmp 0x708c
movb $0x0, 0x87(%rsp)
movl $0x1, 0x40(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x46a8
jmp 0x70b4
leaq 0x50(%rsp), %rdi
callq 0x46a8
jmp 0x70c5
movb 0x87(%rsp), %al
andb $0x1, %al
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x11ab0
nop
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x30(%rax)
jne 0x74c3
movq 0x8(%rsp), %rdi
callq 0x7550
movq 0x8(%rsp), %rdi
movl $0x1, 0x30(%rdi)
addq $0x10, %rdi
callq 0x4140
movq 0x8(%rsp), %rcx
movq %rax, %rdi
addq $0x8, %rcx
movl $0x1c200, %esi          # imm = 0x1C200
leaq 0xe1cc(%rip), %rdx      # 0x156bc
callq 0xe550
cmpl $0x0, %eax
jne 0x7506
movq 0x8(%rsp), %rax
movl $0x0, 0x30(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x77b2
movq (%rsp), %rax
movl 0x8(%rax), %edi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rax
movl %eax, %edx
callq 0xebc0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jl 0x77a9
movslq 0xc(%rsp), %rcx
movq 0x10(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x10(%rsp)
movl 0xc(%rsp), %ecx
movq 0x20(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
jmp 0x77b0
movb $0x0, 0x37(%rsp)
jmp 0x77b7
jmp 0x7756
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x7892
movq (%rsp), %rax
movl 0x8(%rax), %edi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rax
movl %eax, %edx
callq 0xec30
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jl 0x7889
movslq 0xc(%rsp), %rcx
movq 0x10(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x10(%rsp)
movl 0xc(%rsp), %ecx
movq 0x20(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
jmp 0x7890
movb $0x0, 0x37(%rsp)
jmp 0x7897
jmp 0x7836
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xb060
movq 0x8(%rsp), %rax
leaq 0x1325c(%rip), %rcx     # 0x1ab30
addq $0x10, %rcx
movq %rcx, (%rax)
movb $0x0, 0x3a(%rax)
movb $0x0, 0x3b(%rax)
movw $0x0, 0x3c(%rax)
leaq 0x20(%rsp), %rdi
leaq 0xde4b(%rip), %rsi      # 0x15740
movl $0x23, %edx
callq 0x4260
movq 0x8(%rsp), %rdi
movq 0xde88(%rip), %rax      # 0x15793
movq %rax, 0x17(%rsp)
movb 0xde85(%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: 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:
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
movl $0x22, %edx
callq 0x4460
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x2b, %rsi
movl $0xe, %edx
callq 0x4460
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x3a, %rsi
movl $0x1, %edx
callq 0x4460
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x3b, %rsi
movl $0x1, %edx
callq 0x4460
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x3c, %rsi
movl $0x2, %edx
callq 0x4460
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x3e, %rsi
movl $0xcc, %edx
callq 0x4460
movb $0x1, %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
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
movl $0x22, %edx
callq 0x44a0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x2b, %rsi
movl $0xe, %edx
callq 0x44a0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x3a, %rsi
movl $0x1, %edx
callq 0x44a0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x3b, %rsi
movl $0x1, %edx
callq 0x44a0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x3c, %rsi
movl $0x2, %edx
callq 0x44a0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x3e, %rsi
movl $0xcc, %edx
callq 0x44a0
movb $0x1, %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)