LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::eor(unsigned char)
inline void eor(unsigned char value)
    {
        if (CB.debugMessage) strcpy(DD.mne, "EOR");
        R.a ^= value;
        updateStatusN(R.a & 0x80);
        updateStatusZ(R.a == 0);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x1fc99
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
addq $0x2, %rdi
leaq 0x36c2(%rip), %rsi      # 0x23356
callq 0x10c0
movq -0x18(%rbp), %rdi
movzbl -0x9(%rbp), %ecx
movzbl 0x89a(%rdi), %eax
xorl %ecx, %eax
movb %al, 0x89a(%rdi)
movzbl 0x89a(%rdi), %eax
andl $0x80, %eax
cmpl $0x0, %eax
setne %al
movzbl %al, %esi
andl $0x1, %esi
xorl %edx, %edx
callq 0x1e7a0
movq -0x18(%rbp), %rdi
movzbl 0x89a(%rdi), %eax
cmpl $0x0, %eax
sete %al
movzbl %al, %esi
andl $0x1, %esi
xorl %edx, %edx
callq 0x1e880
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::cp(char const*, int, unsigned char)
inline void cp(const char* mne, int m, unsigned char value)
    {
        if (CB.debugMessage) strcpy(DD.mne, mne);
        updateStatusN((m - value) & 0x80 ? true : false);
        updateStatusZ(m == value);
        updateStatusC(m >= value);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x1fd7c
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
addq $0x2, %rdi
movq -0x10(%rbp), %rsi
callq 0x10c0
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movzbl -0x15(%rbp), %ecx
subl %ecx, %eax
sarb $0x7, %al
movzbl %al, %esi
andl $0x1, %esi
xorl %edx, %edx
callq 0x1e7a0
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movzbl -0x15(%rbp), %ecx
cmpl %ecx, %eax
sete %al
movzbl %al, %esi
andl $0x1, %esi
xorl %edx, %edx
callq 0x1e880
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movzbl -0x15(%rbp), %ecx
cmpl %ecx, %eax
setge %al
movzbl %al, %esi
andl $0x1, %esi
xorl %edx, %edx
callq 0x1f700
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::pl(char const*, unsigned char*)
inline void pl(const char* mne, unsigned char* r)
    {
        if (CB.debugMessage) strcpy(DD.mne, mne);
        consumeClock();
        *r = pull();
        consumeClock();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x1ff48
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
addq $0x2, %rdi
movq -0x10(%rbp), %rsi
callq 0x10c0
movq -0x20(%rbp), %rdi
callq 0x1e960
movq -0x20(%rbp), %rdi
callq 0x1ff80
movq -0x20(%rbp), %rdi
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
callq 0x1e960
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::transfer(char const*, unsigned char, unsigned char*, bool)
inline void transfer(const char* mne, unsigned char src, unsigned char* dst, bool updateStatus)
    {
        if (CB.debugMessage) strcpy(DD.mne, mne);
        *dst = src;
        if (updateStatus) {
            updateStatusN(src & 0x80);
            updateStatusZ(src == 0);
        }
        consumeClock();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %dl, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x20003
movq -0x30(%rbp), %rdi
addq $0x60, %rdi
addq $0x2, %rdi
movq -0x10(%rbp), %rsi
callq 0x10c0
movb -0x11(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
testb $0x1, -0x21(%rbp)
je 0x2004d
movq -0x30(%rbp), %rdi
movzbl -0x11(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
setne %al
movzbl %al, %esi
andl $0x1, %esi
xorl %edx, %edx
callq 0x1e7a0
movq -0x30(%rbp), %rdi
movzbl -0x11(%rbp), %eax
cmpl $0x0, %eax
sete %al
movzbl %al, %esi
andl $0x1, %esi
xorl %edx, %edx
callq 0x1e880
movq -0x30(%rbp), %rdi
callq 0x1e960
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::asl(unsigned char)
inline unsigned char asl(unsigned char value)
    {
        if (CB.debugMessage) strcpy(DD.mne, "ASL");
        int work = value;
        work <<= 1;
        unsigned char result = work & 0xFF;
        updateStatusN(result & 0x80);
        updateStatusZ(result == 0);
        updateStatusC(work & 0xFF00 ? true : false);
        consumeClock();
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x20099
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
addq $0x2, %rdi
leaq 0x32fa(%rip), %rsi      # 0x2338e
callq 0x10c0
movq -0x20(%rbp), %rdi
movzbl -0x9(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addl %eax, %eax
movl %eax, -0x10(%rbp)
movb -0x10(%rbp), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
shrb $0x7, %al
movzbl %al, %esi
xorl %edx, %edx
movl %edx, -0x24(%rbp)
callq 0x1e7a0
movl -0x24(%rbp), %edx
movq -0x20(%rbp), %rdi
movb -0x11(%rbp), %al
testb %al, %al
sete %al
movzbl %al, %esi
callq 0x1e880
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rdi
movb -0xf(%rbp), %cl
negb %cl
sbbl %eax, %eax
movzbl %al, %esi
andl $0x1, %esi
xorl %edx, %edx
callq 0x1f700
movq -0x20(%rbp), %rdi
callq 0x1e960
movb -0x11(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::writeMemoryWithDummy(unsigned short, unsigned char, unsigned char)
inline void writeMemoryWithDummy(unsigned short addr, unsigned char before, unsigned char after)
    {
        if (CB.writeMemory) {
            CB.writeMemory(CB.arg, addr, before);
            CB.writeMemory(CB.arg, addr, after);
        }
        consumeClock();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movb %dl, %cl
movw %si, %dx
movq %rdi, -0x8(%rbp)
movw %dx, -0xa(%rbp)
movb %cl, -0xb(%rbp)
movb %al, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x2016e
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rax
movq 0x58(%rcx), %rdi
movw -0xa(%rbp), %cx
movzwl %cx, %esi
movzbl -0xb(%rbp), %edx
callq *%rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rax
movq 0x58(%rcx), %rdi
movw -0xa(%rbp), %cx
movzwl %cx, %esi
movzbl -0xc(%rbp), %edx
callq *%rax
movq -0x18(%rbp), %rdi
callq 0x1e960
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::lsr(unsigned char)
inline unsigned char lsr(unsigned char value)
    {
        if (CB.debugMessage) strcpy(DD.mne, "LSR");
        if (CB.debugMessage && !DD.opp[0]) sprintf(DD.opp, "A<$%02X>", R.a);
        updateStatusC(value & 0x01 ? true : false);
        value &= 0xFE;
        value >>= 1;
        updateStatusN(false);
        updateStatusZ(value == 0);
        consumeClock();
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x201b9
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
addq $0x2, %rdi
leaq 0x31de(%rip), %rsi      # 0x23392
callq 0x10c0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x201f2
movq -0x18(%rbp), %rax
cmpb $0x0, 0x66(%rax)
jne 0x201f2
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0x60, %rdi
addq $0x6, %rdi
movzbl 0x89a(%rax), %edx
leaq 0x31ab(%rip), %rsi      # 0x23396
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rdi
movb -0x9(%rbp), %al
andb $0x1, %al
negb %al
movzbl %al, %esi
andl $0x1, %esi
xorl %edx, %edx
callq 0x1f700
movq -0x18(%rbp), %rdi
movzbl -0x9(%rbp), %eax
andl $0xfe, %eax
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
sarl %eax
movb %al, -0x9(%rbp)
xorl %edx, %edx
movl %edx, %esi
callq 0x1e7a0
movq -0x18(%rbp), %rdi
movzbl -0x9(%rbp), %eax
cmpl $0x0, %eax
sete %al
movzbl %al, %esi
andl $0x1, %esi
xorl %edx, %edx
callq 0x1e880
movq -0x18(%rbp), %rdi
callq 0x1e960
movb -0x9(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::rol(unsigned char)
inline unsigned char rol(unsigned char value)
    {
        if (CB.debugMessage) strcpy(DD.mne, "ROL");
        if (CB.debugMessage && !DD.opp[0]) sprintf(DD.opp, "A<$%02X>", R.a);
        updateStatusC(value & 0x80 ? true : false);
        value &= 0x7F;
        value <<= 1;
        value |= getStatusC() ? 0x01 : 0x00;
        updateStatusN(value & 0x80 ? true : false);
        updateStatusZ(value == 0);
        consumeClock();
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x20299
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
addq $0x2, %rdi
leaq 0x310b(%rip), %rsi      # 0x2339f
callq 0x10c0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x202d2
movq -0x18(%rbp), %rax
cmpb $0x0, 0x66(%rax)
jne 0x202d2
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0x60, %rdi
addq $0x6, %rdi
movzbl 0x89a(%rax), %edx
leaq 0x30cb(%rip), %rsi      # 0x23396
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rdi
movb -0x9(%rbp), %al
shrb $0x7, %al
movzbl %al, %esi
xorl %edx, %edx
callq 0x1f700
movq -0x18(%rbp), %rdi
movb -0x9(%rbp), %al
andb $0x7f, %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
addb %al, %al
movb %al, -0x9(%rbp)
callq 0x1f6e0
movq -0x18(%rbp), %rdi
movzbl %al, %ecx
movzbl -0x9(%rbp), %eax
orl %ecx, %eax
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
sarb $0x7, %al
movzbl %al, %esi
andl $0x1, %esi
xorl %edx, %edx
callq 0x1e7a0
movq -0x18(%rbp), %rdi
movzbl -0x9(%rbp), %eax
cmpl $0x0, %eax
sete %al
movzbl %al, %esi
andl $0x1, %esi
xorl %edx, %edx
callq 0x1e880
movq -0x18(%rbp), %rdi
callq 0x1e960
movb -0x9(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::ror(unsigned char)
inline unsigned char ror(unsigned char value)
    {
        if (CB.debugMessage) strcpy(DD.mne, "ROR");
        if (CB.debugMessage && !DD.opp[0]) sprintf(DD.opp, "A<$%02X>", R.a);
        updateStatusC(value & 0x01 ? true : false);
        value &= 0xFE;
        value >>= 1;
        value |= getStatusC() ? 0x80 : 0x00;
        updateStatusN(value & 0x80 ? true : false);
        updateStatusZ(value == 0);
        consumeClock();
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x20389
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
addq $0x2, %rdi
leaq 0x301f(%rip), %rsi      # 0x233a3
callq 0x10c0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x203c2
movq -0x18(%rbp), %rax
cmpb $0x0, 0x66(%rax)
jne 0x203c2
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0x60, %rdi
addq $0x6, %rdi
movzbl 0x89a(%rax), %edx
leaq 0x2fdb(%rip), %rsi      # 0x23396
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rdi
movzbl -0x9(%rbp), %esi
andl $0x1, %esi
xorl %edx, %edx
callq 0x1f700
movq -0x18(%rbp), %rdi
movb -0x9(%rbp), %al
andb $-0x2, %al
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
shrl %eax
movb %al, -0x9(%rbp)
callq 0x1f6e0
movq -0x18(%rbp), %rdi
movzbl %al, %ecx
shll $0x7, %ecx
movzbl -0x9(%rbp), %eax
orl %ecx, %eax
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
sarb $0x7, %al
movzbl %al, %esi
andl $0x1, %esi
xorl %edx, %edx
callq 0x1e7a0
movq -0x18(%rbp), %rdi
movzbl -0x9(%rbp), %eax
cmpl $0x0, %eax
sete %al
movzbl %al, %esi
andl $0x1, %esi
xorl %edx, %edx
callq 0x1e880
movq -0x18(%rbp), %rdi
callq 0x1e960
movb -0x9(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::dec(char const*, unsigned char)
inline unsigned char dec(const char* mne, unsigned char value)
    {
        if (CB.debugMessage) strcpy(DD.mne, mne);
        value--;
        updateStatusN(value & 0x80);
        updateStatusZ(value == 0);
        consumeClock();
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x20489
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
addq $0x2, %rdi
movq -0x10(%rbp), %rsi
callq 0x10c0
movq -0x20(%rbp), %rdi
movb -0x11(%rbp), %al
addb $-0x1, %al
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
setne %al
movzbl %al, %esi
andl $0x1, %esi
xorl %edx, %edx
callq 0x1e7a0
movq -0x20(%rbp), %rdi
movzbl -0x11(%rbp), %eax
cmpl $0x0, %eax
sete %al
movzbl %al, %esi
andl $0x1, %esi
xorl %edx, %edx
callq 0x1e880
movq -0x20(%rbp), %rdi
callq 0x1e960
movb -0x11(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::bit(unsigned char)
inline void bit(unsigned char value)
    {
        if (CB.debugMessage) strcpy(DD.mne, "BIT");
        unsigned char w = R.a & value;
        updateStatusN(value & 0b10000000);
        updateStatusV(value & 0b01000000);
        updateStatusZ(w == 0);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x205a9
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
addq $0x2, %rdi
leaq 0x2e17(%rip), %rsi      # 0x233bb
callq 0x10c0
movq -0x18(%rbp), %rdi
movzbl 0x89a(%rdi), %eax
movzbl -0x9(%rbp), %ecx
andl %ecx, %eax
movb %al, -0xa(%rbp)
movzbl -0x9(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
setne %al
movzbl %al, %esi
andl $0x1, %esi
xorl %edx, %edx
callq 0x1e7a0
movq -0x18(%rbp), %rdi
movzbl -0x9(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
setne %al
movzbl %al, %esi
andl $0x1, %esi
xorl %edx, %edx
callq 0x1f8b0
movq -0x18(%rbp), %rdi
movzbl -0xa(%rbp), %eax
cmpl $0x0, %eax
sete %al
movzbl %al, %esi
andl $0x1, %esi
xorl %edx, %edx
callq 0x1e880
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::updateStatusI(bool, bool)
inline void updateStatusI(bool i, bool consume = false)
    {
        i ? R.p |= 0b00000100 : R.p &= 0b11111011;
        if (consume) {
            consumeClock();
            if (CB.debugMessage) strcpy(DD.mne, i ? "SEI" : "CLI");
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
andb $0x1, %cl
movb %cl, -0x9(%rbp)
andb $0x1, %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x2066e
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x894, %rcx            # imm = 0x894
addq $0x9, %rcx
movzbl 0x89d(%rax), %ecx
orl $0x4, %ecx
movb %cl, 0x89d(%rax)
jmp 0x20693
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x894, %rcx            # imm = 0x894
addq $0x9, %rcx
movzbl 0x89d(%rax), %ecx
andl $0xfb, %ecx
movb %cl, 0x89d(%rax)
testb $0x1, -0xa(%rbp)
je 0x206ec
movq -0x18(%rbp), %rdi
callq 0x1e960
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x206ea
movq -0x18(%rbp), %rax
addq $0x60, %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
testb $0x1, -0x9(%rbp)
je 0x206d0
leaq 0x2cf5(%rip), %rax      # 0x233bf
movq %rax, -0x28(%rbp)
jmp 0x206dd
leaq 0x2cec(%rip), %rax      # 0x233c3
movq %rax, -0x28(%rbp)
jmp 0x206dd
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x10c0
jmp 0x206ec
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::updateStatusD(bool, bool)
inline void updateStatusD(bool d, bool consume = false)
    {
        d ? R.p |= 0b00001000 : R.p &= 0b11110111;
        if (consume) {
            consumeClock();
            if (CB.debugMessage) strcpy(DD.mne, d ? "SED" : "CLD");
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
andb $0x1, %cl
movb %cl, -0x9(%rbp)
andb $0x1, %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x2074e
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x894, %rcx            # imm = 0x894
addq $0x9, %rcx
movzbl 0x89d(%rax), %ecx
orl $0x8, %ecx
movb %cl, 0x89d(%rax)
jmp 0x20773
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x894, %rcx            # imm = 0x894
addq $0x9, %rcx
movzbl 0x89d(%rax), %ecx
andl $0xf7, %ecx
movb %cl, 0x89d(%rax)
testb $0x1, -0xa(%rbp)
je 0x207cc
movq -0x18(%rbp), %rdi
callq 0x1e960
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x207ca
movq -0x18(%rbp), %rax
addq $0x60, %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
testb $0x1, -0x9(%rbp)
je 0x207b0
leaq 0x2c1d(%rip), %rax      # 0x233c7
movq %rax, -0x28(%rbp)
jmp 0x207bd
leaq 0x2c14(%rip), %rax      # 0x233cb
movq %rax, -0x28(%rbp)
jmp 0x207bd
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x10c0
jmp 0x207cc
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::branch(char const*, bool)
inline void branch(const char* mne, bool isBranch)
    {
        if (CB.debugMessage) strcpy(DD.mne, mne);
        int rel = (signed char)fetch();
        if (0 == rel) {
            if (CB.onError) CB.onError(CB.arg, M6502_ERROR_BRANCH_ZERO);
        }
        if (CB.debugMessage) sprintf(DD.opp, "$%04X%s$%02X", R.pc, rel & 0x80 ? "-" : "+", abs(rel));
        if (!isBranch) return; // not branch
        if ((R.pc & 0xFF00) != ((R.pc + rel) & 0xFF00)) {
            consumeClock(); // consume a penalty cycle (page crossover)
        }
        R.pc += rel;
        consumeClock();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x2081b
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
addq $0x2, %rdi
movq -0x10(%rbp), %rsi
callq 0x10c0
movq -0x20(%rbp), %rdi
callq 0x1e9b0
movsbl %al, %eax
movl %eax, -0x18(%rbp)
xorl %eax, %eax
cmpl -0x18(%rbp), %eax
jne 0x20851
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x2084f
movq -0x20(%rbp), %rcx
movq 0x20(%rcx), %rax
movq 0x58(%rcx), %rdi
movl $0xdead0002, %esi       # imm = 0xDEAD0002
callq *%rax
jmp 0x20851
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x208c6
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x60, %rcx
addq $0x6, %rcx
movq %rcx, -0x30(%rbp)
movzwl 0x898(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x18(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x20893
leaq 0x2c71(%rip), %rax      # 0x234fe
movq %rax, -0x38(%rbp)
jmp 0x208a0
leaq 0x2b46(%rip), %rax      # 0x233e0
movq %rax, -0x38(%rbp)
jmp 0x208a0
movl -0x24(%rbp), %edx
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rcx
movl -0x18(%rbp), %r8d
movl %r8d, %eax
negl %eax
cmovnsl %eax, %r8d
leaq 0x2b14(%rip), %rsi      # 0x233d3
movb $0x0, %al
callq 0x1040
testb $0x1, -0x11(%rbp)
jne 0x208ce
jmp 0x20917
movq -0x20(%rbp), %rcx
movzwl 0x898(%rcx), %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl 0x898(%rcx), %ecx
addl -0x18(%rbp), %ecx
andl $0xff00, %ecx           # imm = 0xFF00
cmpl %ecx, %eax
je 0x208fb
movq -0x20(%rbp), %rdi
callq 0x1e960
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %ecx
movzwl 0x898(%rdi), %eax
addl %ecx, %eax
movw %ax, 0x898(%rdi)
callq 0x1e960
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::executeInterrupt(unsigned short, bool)
inline void executeInterrupt(unsigned short addr, bool isBreak)
    {
        unsigned char pcH = (R.pc & 0xFF00) >> 8;
        unsigned char pcL = R.pc & 0x00FF;
        push(pcH);
        push(pcL);
        push(R.p);
        updateStatusI(true);
        updateStatusB(isBreak);
        pcL = readMemory(addr);
        pcH = readMemory(addr + 1);
        R.pc = pcH;
        R.pc <<= 8;
        R.pc |= pcL;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movw %si, %cx
movq %rdi, -0x8(%rbp)
movw %cx, -0xa(%rbp)
andb $0x1, %al
movb %al, -0xb(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movzwl 0x898(%rdi), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movb %al, -0xc(%rbp)
movzwl 0x898(%rdi), %eax
andl $0xff, %eax
movb %al, -0xd(%rbp)
movzbl -0xc(%rbp), %esi
callq 0x1fec0
movq -0x18(%rbp), %rdi
movzbl -0xd(%rbp), %esi
callq 0x1fec0
movq -0x18(%rbp), %rax
movq %rax, %rdi
movzbl 0x89d(%rax), %esi
callq 0x1fec0
movq -0x18(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x20620
movq -0x18(%rbp), %rdi
movb -0xb(%rbp), %al
xorl %edx, %edx
andb $0x1, %al
movzbl %al, %esi
callq 0x20a80
movq -0x18(%rbp), %rdi
movzwl -0xa(%rbp), %esi
callq 0x1e9f0
movq -0x18(%rbp), %rdi
movb %al, -0xd(%rbp)
movzwl -0xa(%rbp), %eax
addl $0x1, %eax
movzwl %ax, %esi
callq 0x1e9f0
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, -0xc(%rbp)
movzbl -0xc(%rbp), %ecx
movw %cx, 0x898(%rax)
movzwl 0x898(%rax), %ecx
shll $0x8, %ecx
movw %cx, 0x898(%rax)
movzbl -0xd(%rbp), %edx
movzwl 0x898(%rax), %ecx
orl %edx, %ecx
movw %cx, 0x898(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::updateStatusB(bool, bool)
inline void updateStatusB(bool b, bool consume = false)
    {
        b ? R.p |= 0b00010000 : R.p &= 0b11101111;
        if (consume) {
            consumeClock();
            if (CB.debugMessage) strcpy(DD.mne, b ? "SEB" : "CLB");
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
andb $0x1, %cl
movb %cl, -0x9(%rbp)
andb $0x1, %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x20ace
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x894, %rcx            # imm = 0x894
addq $0x9, %rcx
movzbl 0x89d(%rax), %ecx
orl $0x10, %ecx
movb %cl, 0x89d(%rax)
jmp 0x20af3
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x894, %rcx            # imm = 0x894
addq $0x9, %rcx
movzbl 0x89d(%rax), %ecx
andl $0xef, %ecx
movb %cl, 0x89d(%rax)
testb $0x1, -0xa(%rbp)
je 0x20b4c
movq -0x18(%rbp), %rdi
callq 0x1e960
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x20b4a
movq -0x18(%rbp), %rax
addq $0x60, %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
testb $0x1, -0x9(%rbp)
je 0x20b30
leaq 0x28ec(%rip), %rax      # 0x23416
movq %rax, -0x28(%rbp)
jmp 0x20b3d
leaq 0x28e3(%rip), %rax      # 0x2341a
movq %rax, -0x28(%rbp)
jmp 0x20b3d
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x10c0
jmp 0x20b4c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: cssartori[P]ga-qap/src/datafile.cpp
// Function: DataFile::write_solution(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Solution const&)
int DataFile::write_solution(const std::string& filename, const Solution& s){
	FILE *file = fopen(filename.c_str(), "wt");
	
	if(file == NULL)
		return -1;

	fprintf(file, "%li %i\n", n, s.fitness());
	for(size_t i=0;i<n;i++){
		fprintf(file, "%i ", s[i]);
	}
	fprintf(file, "\n");

	fclose(file);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20a0
movq %rax, %rdi
leaq 0xc76e(%rip), %rsi      # 0xf00d
callq 0x2220
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x28bb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2961
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5fc0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
movl %eax, %ecx
leaq 0xc727(%rip), %rsi      # 0xf010
movb $0x0, %al
callq 0x2260
movq $0x0, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
cmpq 0x30(%rcx), %rax
jae 0x293f
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rax
movl %eax, %esi
callq 0x5f90
movq -0x50(%rbp), %rdi
movl %eax, %edx
leaq 0xc6ee(%rip), %rsi      # 0xf018
movb $0x0, %al
callq 0x2260
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x28f8
movq -0x28(%rbp), %rdi
leaq 0xc6be(%rip), %rsi      # 0xf008
movb $0x0, %al
callq 0x2260
movq -0x28(%rbp), %rdi
callq 0x21a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: cssartori[P]ga-qap/src/datafile.cpp
// Function: DataFile::print()
void DataFile::print(){
	std::cout << "====================================" << std::endl;
	std::cout << "n = " << this->n << std::endl;
	
	std::cout << "A :" << std::endl;
	for(size_t i=0;i<this->n;i++){
		for(size_t j=0;j<this->n;j++){
			std::cout << this->flow[i][j] << " ";
		}
		std::cout << std::endl;
	}
	std::cout << "B :" << std::endl;
	for(size_t i=0;i<this->n;i++){
		for(size_t j=0;j<this->n;j++){
			std::cout << this->distance[i][j] << " ";
		}
		std::cout << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x1364d(%rip), %rdi     # 0x15fd8
leaq 0xc68a(%rip), %rsi      # 0xf01c
callq 0x2190
movq %rax, %rdi
movq 0x13627(%rip), %rsi     # 0x15fc8
callq 0x21d0
movq 0x1362b(%rip), %rdi     # 0x15fd8
leaq 0xc68d(%rip), %rsi      # 0xf041
callq 0x2190
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x2060
movq %rax, %rdi
movq 0x135f5(%rip), %rsi     # 0x15fc8
callq 0x21d0
movq 0x135f9(%rip), %rdi     # 0x15fd8
leaq 0xc660(%rip), %rsi      # 0xf046
callq 0x2190
movq %rax, %rdi
movq 0x135d3(%rip), %rsi     # 0x15fc8
callq 0x21d0
movq $0x0, -0x10(%rbp)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x30(%rcx), %rax
jae 0x2a8e
movq $0x0, -0x18(%rbp)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x30(%rcx), %rax
jae 0x2a6a
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2cd0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x2cf0
movl (%rax), %esi
movq 0x13590(%rip), %rdi     # 0x15fd8
callq 0x22c0
movq %rax, %rdi
leaq 0xc5ed(%rip), %rsi      # 0xf044
callq 0x2190
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2a18
movq 0x13567(%rip), %rdi     # 0x15fd8
movq 0x13550(%rip), %rsi     # 0x15fc8
callq 0x21d0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2a02
movq 0x13543(%rip), %rdi     # 0x15fd8
leaq 0xc5ae(%rip), %rsi      # 0xf04a
callq 0x2190
movq %rax, %rdi
movq 0x1351d(%rip), %rsi     # 0x15fc8
callq 0x21d0
movq $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x30(%rcx), %rax
jae 0x2b4c
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq 0x30(%rcx), %rax
jae 0x2b28
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
movq -0x20(%rbp), %rsi
callq 0x2cd0
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x2cf0
movl (%rax), %esi
movq 0x134d2(%rip), %rdi     # 0x15fd8
callq 0x22c0
movq %rax, %rdi
leaq 0xc52f(%rip), %rsi      # 0xf044
callq 0x2190
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2ad2
movq 0x134a9(%rip), %rdi     # 0x15fd8
movq 0x13492(%rip), %rsi     # 0x15fc8
callq 0x21d0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2ab8
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: cssartori[P]ga-qap/src/objectivefunction.cpp
// Function: ObjectiveFunction::eval(Solution const&) const
int ObjectiveFunction::eval(const Solution& s) const{
	int fitness = 0;
	/*Function to minimize*/
	for(size_t i=0;i<data.n;i++){
		for(size_t j=0;j<data.n;j++){
			/*There is a flow between two locations i and j, but also there is a distance between facilities p(i) and p(j)*/
			fitness += data.flow[i][j]*data.distance[s[i]][s[j]];
		}
	}

	return fitness;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rcx), %rcx
cmpq 0x30(%rcx), %rax
jae 0x6629
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq (%rcx), %rcx
cmpq 0x30(%rcx), %rax
jae 0x6616
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x7040
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x6150
movq %rax, %rcx
movq -0x30(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x34(%rbp)
movq (%rax), %rax
addq $0x18, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
callq 0x5f90
movq -0x48(%rbp), %rdi
movslq %eax, %rsi
callq 0x7040
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movl %eax, %esi
callq 0x5f90
movq -0x40(%rbp), %rdi
movslq %eax, %rsi
callq 0x6150
movq %rax, %rcx
movl -0x34(%rbp), %eax
imull (%rcx), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x6574
jmp 0x6618
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6557
movl -0x14(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cssartori[P]ga-qap/src/localsearch.cpp
// Function: LocalSearch::all_pair_changes(Solution)
Solution LocalSearch::all_pair_changes(Solution s){

	for(size_t t=0;t<data.n;t++){
		for(size_t u=t+1;u<data.n;u++){
			int f = of.eval_pair_change(s, t, u);

			if(f < s.fitness()){
				int temp = s[t];
				s[t] = s[u];
				s[u] = temp;
				s.set_fitness(f);
			}
		}
	}
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rcx), %rcx
cmpq 0x30(%rcx), %rax
jae 0x9455
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq (%rcx), %rcx
cmpq 0x30(%rcx), %rax
jae 0x9442
movq -0x50(%rbp), %rsi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x6640
movq -0x50(%rbp), %rdi
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x54(%rbp)
callq 0x5fc0
movl %eax, %ecx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jge 0x942f
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
callq 0x5f60
movq -0x50(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl %eax, %esi
callq 0x5f60
movq -0x50(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
movq -0x20(%rbp), %rax
movl %eax, %esi
callq 0x5f60
movl -0x5c(%rbp), %ecx
movq -0x50(%rbp), %rdi
movl %ecx, (%rax)
movl -0x30(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movl %eax, %esi
callq 0x5f60
movl -0x58(%rbp), %ecx
movq -0x50(%rbp), %rdi
movl %ecx, (%rax)
movl -0x2c(%rbp), %esi
callq 0x5fe0
jmp 0x9431
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x9384
jmp 0x9444
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x9363
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x91a0
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: cssartori[P]ga-qap/src/localsearch.cpp
// Function: LocalSearch::perturbation(Solution&, int, std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>&)
void LocalSearch::perturbation(Solution& s, int u, std::default_random_engine& generator){
	std::uniform_int_distribution<int> rand_place(0,data.n-1);
	int p = 0;
	
	while(p < u){
		p++;
		/*Pick two locations randomly*/
		int t = rand_place(generator);
		int v = rand_place(generator);	
		while(v == t)
			v = rand_place(generator);	

		/*Evaluate the exchange*/
		int f = of.eval_pair_change(s, t, v);
		/*Exhcange points (wheter it is better or not)*/
		s.set_fitness(f);
		int temp = s[t];
		s[t] = s[v];
		s[v] = temp;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq (%rax), %rax
movq 0x30(%rax), %rax
subq $0x1, %rax
movl %eax, %edx
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x7390
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x9834
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x74a0
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x74a0
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x30(%rbp), %eax
jne 0x97bd
movq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x74a0
movl %eax, -0x34(%rbp)
jmp 0x97a3
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movslq -0x30(%rbp), %rdx
movslq -0x34(%rbp), %rcx
callq 0x6640
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl -0x38(%rbp), %esi
callq 0x5fe0
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0x5f60
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x5f60
movl (%rax), %eax
movl %eax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0x5f60
movl -0x50(%rbp), %ecx
movl %ecx, (%rax)
movl -0x3c(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x5f60
movl -0x4c(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x976e
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: cssartori[P]ga-qap/src/geneticalgorithm.cpp
// Function: GeneticAlgorithm::GeneticAlgorithm(DataFile const&, unsigned long, unsigned long, unsigned long, double, unsigned long, bool)
GeneticAlgorithm::GeneticAlgorithm(const DataFile& _data, size_t pop_size, size_t max_generations, size_t k, double pc, size_t seed, bool prints) : data(_data){
	this->pop_size = pop_size;
	this->max_generations = max_generations;
	this->k = k;
	this->pc = pc;
	this->seed = seed;
	this->prints = prints;

	this->generator = std::default_random_engine(seed);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb 0x10(%rbp), %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movsd %xmm0, -0x30(%rbp)
movq %r9, -0x38(%rbp)
andb $0x1, %al
movb %al, -0x39(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
addq $0x38, %rdi
movq %rdi, -0x78(%rbp)
xorl %esi, %esi
movl %esi, -0x64(%rbp)
callq 0x5e60
movq -0x70(%rbp), %rdi
movl -0x64(%rbp), %esi
addq $0x58, %rdi
movq %rdi, -0x60(%rbp)
callq 0x5e60
jmp 0x9aa7
movq -0x70(%rbp), %rdi
subq $-0x80, %rdi
callq 0xb830
jmp 0x9ab6
movq -0x70(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x28(%rax)
movb -0x39(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x30(%rax)
movq -0x38(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xb850
jmp 0x9afc
movq -0x70(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x80(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x9b37
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x5840
movq -0x78(%rbp), %rdi
callq 0x5840
movq -0x48(%rbp), %rdi
callq 0x22d0
nopl (%rax)
// File: cssartori[P]ga-qap/src/geneticalgorithm.cpp
// Function: GeneticAlgorithm::tournament(std::vector<Solution, std::allocator<Solution>> const&, unsigned long, int&)
Solution GeneticAlgorithm::tournament(const std::vector<Solution>& population, size_t k, int& except){
	/*Selects a random individual from the population that is not the except one*/
	std::uniform_int_distribution<int> rand_pop(0, pop_size-1);
	int r = rand_pop(generator);

	while(r == except) r = rand_pop(generator);
	
	Solution selected = population[r];
	except = r;
	
	/*Runs the tournament k-1 times and selects the best from this tournament*/
	for(size_t i=1;i<k;i++){
		r = rand_pop(generator);
		while(r == except) r = rand_pop(generator);
		if(population[r] < selected){
			selected = population[r];
			except = r;
		}
	}

	/*Returns the best permutation*/
	return selected;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq 0x10(%rax), %rax
subq $0x1, %rax
movl %eax, %edx
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x7390
movq -0x58(%rbp), %rsi
addq $0x80, %rsi
leaq -0x30(%rbp), %rdi
callq 0x74a0
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jne 0xa9a2
movq -0x58(%rbp), %rsi
addq $0x80, %rsi
leaq -0x30(%rbp), %rdi
callq 0x74a0
movl %eax, -0x34(%rbp)
jmp 0xa97e
movb $0x0, -0x35(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0xb8e0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x8c00
movl -0x34(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq $0x1, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xaa98
movq -0x58(%rbp), %rsi
subq $-0x80, %rsi
leaq -0x30(%rbp), %rdi
callq 0x74a0
movl %eax, -0x6c(%rbp)
jmp 0xa9f4
movl -0x6c(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jne 0xaa3a
movq -0x58(%rbp), %rsi
subq $-0x80, %rsi
leaq -0x30(%rbp), %rdi
callq 0x74a0
movl %eax, -0x70(%rbp)
jmp 0xaa1b
movl -0x70(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0xa9fa
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x5840
jmp 0xaab8
movq -0x18(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0xb8e0
movq -0x68(%rbp), %rsi
movq %rax, %rdi
callq 0x6000
movb %al, -0x71(%rbp)
jmp 0xaa58
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0xaa61
jmp 0xaa85
movq -0x18(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0xb8e0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x9880
jmp 0xaa7c
movl -0x34(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
jmp 0xaa87
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0xa9d0
movb $0x1, -0x35(%rbp)
testb $0x1, -0x35(%rbp)
jne 0xaaab
movq -0x68(%rbp), %rdi
callq 0x5840
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x22d0
nopw %cs:(%rax,%rax)
// File: Vanuan[P]pocketbook_free_swupdate/main.cpp
// Function: main
int main(int argc, char ** argv)
{
  if(argc != 3) {
    cout << "Usage:" << argv[0] << " SWUPDATE.BIN_filename output_dir" << endl;
    return -1;
  }
  PocketBookUpdate update(argv[1]);
  update.print();
  update.extract(argv[2]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0x3658
movq 0x89ba(%rip), %rdi      # 0xbfd0
leaq 0x49e7(%rip), %rsi      # 0x8004
callq 0x3250
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x3250
movq %rax, %rdi
leaq 0x49d0(%rip), %rsi      # 0x800b
callq 0x3250
movq %rax, %rdi
movq 0x8976(%rip), %rsi      # 0xbfc0
callq 0x3290
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x36a3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x37d0
movq -0xc0(%rbp), %rdi
callq 0x4550
jmp 0x3681
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x3f60
jmp 0x3697
leaq -0xa8(%rbp), %rdi
callq 0x3ec0
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x3ec0
movq -0xb0(%rbp), %rdi
callq 0x3410
nopl (%rax)
// File: Vanuan[P]pocketbook_free_swupdate/PocketBookUpdate.cpp
// Function: convertInt[abi:cxx11](int)
string convertInt(int number)
{
   if( number == 0) return "";
   stringstream ss;//create a stringstream
   ss << number;//add number to the stream
   return ss.str();//return a string with the contents of the stream
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x1b8(%rbp)
movq %rdi, %rax
movq %rax, -0x1b0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x3757
leaq -0xd(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
callq 0x3420
movq -0x1b8(%rbp), %rdi
movq -0x1c0(%rbp), %rdx
leaq 0x49bd(%rip), %rsi      # 0x80eb
callq 0x4860
jmp 0x3735
leaq -0xd(%rbp), %rdi
callq 0x32b0
jmp 0x37b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xd(%rbp), %rdi
callq 0x32b0
jmp 0x37c1
leaq -0x1a8(%rbp), %rdi
callq 0x31a0
leaq -0x198(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x3400
jmp 0x3774
movq -0x1b8(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x3240
jmp 0x3789
leaq -0x1a8(%rbp), %rdi
callq 0x31c0
jmp 0x37b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x31c0
jmp 0x37c1
movq -0x1b0(%rbp), %rax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3410
nopw (%rax,%rax)
// File: Vanuan[P]pocketbook_free_swupdate/PocketBookUpdate.cpp
// Function: PocketBookUpdate::printField(unsigned int, unsigned int, char const*)
int PocketBookUpdate::printField(unsigned offset, unsigned size, const char* name)
{
  cout.width(10);
  cout << showbase << hex;
  cout << offset << " ";
  cout.width(10);
  cout << offset+size << "\t\t" << name << ":\t\t";
  cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq 0x7bf3(%rip), %rax      # 0xbfd0
movq (%rax), %rax
movq 0x7be9(%rip), %rdi      # 0xbfd0
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x4f70
movq 0x7bd4(%rip), %rdi      # 0xbfd0
leaq 0xb9d(%rip), %rsi       # 0x4fa0
callq 0x30e0
movq %rax, %rdi
leaq 0xbbe(%rip), %rsi       # 0x4fd0
callq 0x30e0
movl -0xc(%rbp), %esi
movq 0x7baf(%rip), %rdi      # 0xbfd0
callq 0x3370
movq %rax, %rdi
leaq 0x3cd0(%rip), %rsi      # 0x8100
callq 0x3250
movq 0x7b94(%rip), %rax      # 0xbfd0
movq (%rax), %rax
movq 0x7b8a(%rip), %rdi      # 0xbfd0
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x4f70
movl -0xc(%rbp), %esi
addl -0x10(%rbp), %esi
movq 0x7b6f(%rip), %rdi      # 0xbfd0
callq 0x3370
movq %rax, %rdi
leaq 0x3c79(%rip), %rsi      # 0x80e9
callq 0x3250
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x3250
movq %rax, %rdi
leaq 0x3bfa(%rip), %rsi      # 0x8085
callq 0x3250
movq 0x7b39(%rip), %rdi      # 0xbfd0
movq 0x7b22(%rip), %rsi      # 0xbfc0
callq 0x3290
ud2
nopw %cs:(%rax,%rax)
// File: Vanuan[P]pocketbook_free_swupdate/PocketBookUpdate.cpp
// Function: PocketBookUpdate::printField(unsigned int)
int PocketBookUpdate::printField(unsigned i)
{
  static const int fieldsNumber = 7;
  if( i >= fieldsNumber ) return 0;
  static const int sizes[] = {
    sizeof(header->magic),
    sizeof(header->model),
    sizeof(header->unknownBuffer1),
    sizeof(header->padding1),
    sizeof(header->unknownUInt32),
    sizeof(header->padding2),
    sizeof(header->fwParts)
  };
  const char* fieldNames[] = {
    "Magic",
    "Model",
    "Unknown buffer 1",
    "Padding1",
    "UnknownUInt32",
    "Padding2",
    "Partition table"
  };
  static int offset = 0;
  printField(offset, sizes[i], fieldNames[i]);
  offset += sizes[i];
  return sizes[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpl $0x7, -0x14(%rbp)
jb 0x44d6
movl $0x0, -0x4(%rbp)
jmp 0x453e
leaq -0x50(%rbp), %rdi
leaq 0x787f(%rip), %rsi      # 0xbd60
movl $0x38, %edx
callq 0x31f0
movq -0x58(%rbp), %rdi
movl 0x7d63(%rip), %esi      # 0xc258
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x3c3f(%rip), %rax      # 0x8140
movl (%rax,%rcx,4), %edx
movl -0x14(%rbp), %eax
movq -0x50(%rbp,%rax,8), %rcx
callq 0x43c0
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x3c23(%rip), %rax      # 0x8140
movl (%rax,%rcx,4), %eax
addl 0x7d32(%rip), %eax      # 0xc258
movl %eax, 0x7d2c(%rip)      # 0xc258
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x3c08(%rip), %rax      # 0x8140
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: neubig[P]egret/Egret/src/Bijection.h
// Function: Bijection<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int>::queryX2Y(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int&) const
bool Bijection<TypeX,TypeY>::
	queryX2Y(const TypeX& input, TypeY& result)const
{
	if(X2YMap.find(input)!=X2YMap.end())
	{
		result=X2YMap.find(input)->second;
		return true;
	}
	else
	{
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq -0x18(%rbp), %rsi
callq 0xab50
movq -0x40(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0xab80
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xab20
testb $0x1, %al
jne 0xaad9
jmp 0xab02
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xab50
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xabb0
movl 0x20(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0xab06
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: neubig[P]egret/Egret/src/Bijection.h
// Function: Bijection<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int>::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int const&)
bool Bijection<TypeX,TypeY>::
	add(const TypeX& X, const TypeY& Y)
{
	if(!containX(X)&&!containY(Y))
	{
		X2YMap[X]=Y;
		Y2XMap[Y]=X;
		return true;
		
	}
	else return false;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x18(%rbp), %rsi
callq 0x1c800
testb $0x1, %al
jne 0x1c8d0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1d300
testb $0x1, %al
jne 0x1c8d0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rsi
callq 0x1d350
movl -0x34(%rbp), %ecx
movq -0x28(%rbp), %rdi
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x30, %rdi
movq -0x20(%rbp), %rsi
callq 0x1d430
movq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x4050
movb $0x1, -0x1(%rbp)
jmp 0x1c8d4
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: neubig[P]egret/Egret/src/Bijection.h
// Function: Bijection<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int>::queryY2X(int const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const
bool Bijection<TypeX,TypeY>::
	queryY2X(const TypeY& input, TypeX& result)const
{
	if(Y2XMap.find(input)!=Y2XMap.end())
	{
		result=Y2XMap.find(input)->second;
		return true;
	}
	else
	{
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x30, %rdi
movq -0x18(%rbp), %rsi
callq 0x1ccf0
movq -0x40(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x30, %rdi
callq 0x1cd20
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1ccc0
testb $0x1, %al
jne 0x1cc71
jmp 0x1cca5
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rsi
callq 0x1ccf0
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1cd50
movq %rax, %rsi
addq $0x8, %rsi
movq -0x20(%rbp), %rdi
callq 0x4050
movb $0x1, -0x1(%rbp)
jmp 0x1cca9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop