LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: FFY00[P]uicc/include/uicc.h
// Function: UICC::encodeMccMnc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
string encodeMccMnc(string Mcc, string Mnc, int len=0) {
        string out;
        out=makeBcd(Mcc);
        out+=makeBcd(Mnc, true, len>2?len-2:0);
        return out;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rdi, -0xd0(%rbp)
movq %rdi, %rax
movq %rax, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb $0x0, -0x25(%rbp)
callq 0x33f0
movq -0xc0(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x3120
jmp 0x115b9
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x7ca0
jmp 0x115cf
movq -0xd0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movq %rsi, -0xe0(%rbp)
callq 0x3390
movq -0xe0(%rbp), %rdi
callq 0x31a0
leaq -0x68(%rbp), %rdi
callq 0x31a0
movq -0xd8(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
callq 0x3120
jmp 0x11610
cmpl $0x2, -0x24(%rbp)
jle 0x11624
movl -0x24(%rbp), %eax
subl $0x2, %eax
movl %eax, -0xe4(%rbp)
jmp 0x1162e
xorl %eax, %eax
movl %eax, -0xe4(%rbp)
jmp 0x1162e
movl -0xe4(%rbp), %ecx
leaq -0x98(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
movl $0x1, %edx
callq 0x7ca0
jmp 0x1164e
movq -0xd0(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x33b0
jmp 0x11663
leaq -0x98(%rbp), %rdi
callq 0x31a0
leaq -0xb8(%rbp), %rdi
callq 0x31a0
movb $0x1, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
jne 0x116ec
jmp 0x116e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x116fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x31a0
jmp 0x116fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x116d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x31a0
leaq -0xb8(%rbp), %rdi
callq 0x31a0
jmp 0x116fc
movq -0xd0(%rbp), %rdi
callq 0x31a0
movq -0xc8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0xd0(%rbp), %rdi
callq 0x31a0
movq -0x70(%rbp), %rdi
callq 0x34b0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: FFY00[P]uicc/include/uicc.h
// Function: USIM::fileRecordSize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int fileRecordSize(string filename) {
        openFile(filename);

        if (fileDesc.size() <= 2)
            return -1;

        return fileDesc[3];
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3120
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x1ab90
jmp 0x12474
leaq -0x38(%rbp), %rdi
callq 0x31a0
movq -0x58(%rbp), %rdi
addq $0x28, %rdi
callq 0x31f0
cmpq $0x2, %rax
ja 0x124b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x124c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31a0
jmp 0x124d1
movq -0x58(%rbp), %rdi
addq $0x28, %rdi
movl $0x3, %esi
callq 0x3520
movsbl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x34b0
nopw (%rax,%rax)
// File: FFY00[P]uicc/include/uicc.h
// Function: UICC::UICC()
UICC() {
        char *debug_env=getenv("DEBUG");

        if (debug_env != NULL &&
                (debug_env[0] == 'Y' || debug_env[0] == 'y'))
            debug=true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x0, (%rax)
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
leaq 0x11825(%rip), %rdi     # 0x257ba
callq 0x3380
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13fc4
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x59, %eax
je 0x13fbd
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x79, %eax
jne 0x13fc4
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chuckwolber[P]Cube/test/../Algorithm.cpp
// Function: Algorithm::addTurn(Turn)
void Algorithm::addTurn(Turn turn) {
    std::vector<unsigned long long int>::iterator it = algorithm.begin();
    algorithm.insert(it, getNumberForTurn(turn));

    algorithmNumber = 0;
    unsigned long long int base = 1;
    for (unsigned long long int t : algorithm) {
        algorithmNumber += t*base;
        base *= ALGORITHM_BASE;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4e40
movq %rax, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x4eb0
movq -0x68(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0x3070
movq -0x68(%rbp), %rdi
movl %eax, %eax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x4e70
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq $0x0, 0x20(%rax)
movq $0x1, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x4e40
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x4ef0
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x4f20
testb $0x1, %al
jne 0x2536
jmp 0x2572
leaq -0x50(%rbp), %rdi
callq 0x4f60
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x60(%rbp)
movq -0x60(%rbp), %rcx
imulq -0x40(%rbp), %rcx
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
imulq $0xc, -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x4f80
jmp 0x2523
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chuckwolber[P]Cube/test/../Algorithm.cpp
// Function: Algorithm::setAlgorithmNumber(unsigned long long)
void Algorithm::setAlgorithmNumber(unsigned long long int algNum) {
    algorithm.clear();
    algorithmNumber = 0;
    addTurn(initialTurn);
    addToAlgorithm(algNum);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x4d40
movq -0x20(%rbp), %rdi
movq $0x0, 0x20(%rdi)
movq 0xdaf8(%rip), %rax      # 0x10108
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x2490
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2a00
addq $0x20, %rsp
popq %rbp
retq
// File: chuckwolber[P]Cube/test/../Algorithm.cpp
// Function: Algorithm::setAlgorithm(std::vector<Turn, std::allocator<Turn>>)
void Algorithm::setAlgorithm(const std::vector<Turn> turns) {
    algorithm.clear();
    algorithmNumber = 0;
    for (Turn turn : turns)
        addTurn(turn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x4d40
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rsi
movq $0x0, 0x20(%rax)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4d60
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4d90
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4dc0
testb $0x1, %al
jne 0x2732
jmp 0x2762
leaq -0x20(%rbp), %rdi
callq 0x4e00
movq -0x48(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
callq 0x2490
leaq -0x20(%rbp), %rdi
callq 0x4e20
jmp 0x271f
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chuckwolber[P]Cube/test/../Algorithm.cpp
// Function: Algorithm::setAlgorithm(char const*)
void Algorithm::setAlgorithm(const char *algorithm) {
    if (!isValid(algorithm))
        return;
    
    this->algorithm.clear();
    Turn *turn = nullptr;
    Layer layer;

    while (*algorithm != '\0') {
        layer = Algorithm::charToLayer(*algorithm);
        if (turn != nullptr) {
            if (*algorithm == ' ') {
                addTurn(*turn);
                turn = nullptr;
            } else if (*algorithm == '\'') {
                turn->clockwise = false;
                addTurn(*turn);
                turn = nullptr;
            }
        } else if (layer != Layer::NOLAYER) {
            turn = new Turn;
            turn->clockwise = true;
            turn->layer = layer;
        }
        algorithm++;
    }
   
    if (turn != nullptr)
        addTurn(*turn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2f00
testb $0x1, %al
jne 0x287a
jmp 0x296e
movq -0x40(%rbp), %rdi
callq 0x4d40
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x294f
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x2fa0
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2917
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x28df
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x24(%rbp)
movq -0x24(%rbp), %rsi
callq 0x2490
movq $0x0, -0x18(%rbp)
jmp 0x2915
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x27, %eax
jne 0x2913
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x2c(%rbp)
movq -0x2c(%rbp), %rsi
callq 0x2490
movq $0x0, -0x18(%rbp)
jmp 0x2915
jmp 0x293e
cmpl $0xd, -0x1c(%rbp)
je 0x293c
movl $0x8, %edi
callq 0x21a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x1, 0x4(%rax)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x293e
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x288b
cmpq $0x0, -0x18(%rbp)
je 0x296e
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x34(%rbp)
movq -0x34(%rbp), %rsi
callq 0x2490
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chuckwolber[P]Cube/test/../Algorithm.cpp
// Function: Algorithm::operator=(Algorithm const&)
Algorithm& Algorithm::operator=(const Algorithm& rhs) {
    if (&rhs != this) {
        algorithm = rhs.algorithm;
        algorithmNumber = rhs.algorithmNumber;
        algorithmOrder = rhs.algorithmOrder;
    }
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq %rax, -0x10(%rbp)
je 0x29c5
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4980
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %ecx
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: chuckwolber[P]Cube/test/../Algorithm.cpp
// Function: Algorithm::addToAlgorithm(unsigned long long)
void Algorithm::addToAlgorithm(unsigned long long int addend) {
    unsigned int index = 0;
    unsigned long long int fieldCarry = 0;

    unsigned long long int addendModulus;
    unsigned long long int fieldSum;
    unsigned long long int fieldValue;
   
    algorithmNumber += addend;
    while (addend > 0 || fieldCarry > 0) {
        if (algorithm.size() < index + 1) {
            algorithm.push_back(0);
            if (addend != 0)
                addend--;
            else if (fieldCarry != 0)
                fieldCarry--;
        }

        addendModulus = addend % ALGORITHM_BASE;
        addend = (addend - addendModulus) / ALGORITHM_BASE;

        fieldSum = algorithm.at(index) + addendModulus + fieldCarry;
        fieldValue = fieldSum % ALGORITHM_BASE;
        fieldCarry = (fieldSum - fieldValue) / ALGORITHM_BASE;

        algorithm.at(index++) = fieldValue;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rcx
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movb $0x1, %al
cmpq $0x0, -0x10(%rbp)
movb %al, -0x49(%rbp)
ja 0x2a4a
cmpq $0x0, -0x20(%rbp)
seta %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x2a56
jmp 0x2b46
movq -0x48(%rbp), %rdi
callq 0x4ca0
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jae 0x2aad
movq -0x48(%rbp), %rdi
movq $0x0, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x4fa0
cmpq $0x0, -0x10(%rbp)
je 0x2a96
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2aab
cmpq $0x0, -0x20(%rbp)
je 0x2aa9
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2aab
jmp 0x2aad
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rax
movl $0xc, %ecx
xorl %edx, %edx
divq %rcx
movq %rdx, -0x28(%rbp)
movq -0x10(%rbp), %rax
subq -0x28(%rbp), %rax
movl $0xc, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x4cc0
movq -0x48(%rbp), %rdi
movq (%rax), %rax
addq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0xc, %ecx
xorl %edx, %edx
divq %rcx
movq %rdx, -0x38(%rbp)
movq -0x30(%rbp), %rax
subq -0x38(%rbp), %rax
movl $0xc, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movl %eax, %eax
movl %eax, %esi
callq 0x4cc0
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x2a33
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: chuckwolber[P]Cube/test/../Algorithm.cpp
// Function: Algorithm::operator<(Algorithm const&)
bool Algorithm::operator<(const Algorithm& rhs) {
    if (algorithm.size() > rhs.algorithm.size())
        return false;
    if (algorithm.size() < rhs.algorithm.size())
        return true;
    for (ssize_t i = (ssize_t)algorithm.size() - 1; i >= 0; i--) {
        if (algorithm.at((size_t)i) == rhs.algorithm.at((size_t)i))
            continue;
        if (algorithm.at((size_t)i) < rhs.algorithm.at((size_t)i))
            return true;
        return false;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x4ca0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4ca0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jbe 0x2c9f
movb $0x0, -0x1(%rbp)
jmp 0x2d5c
movq -0x30(%rbp), %rdi
callq 0x4ca0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4ca0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x2cca
movb $0x1, -0x1(%rbp)
jmp 0x2d5c
movq -0x30(%rbp), %rdi
callq 0x4ca0
subq $0x1, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jl 0x2d58
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4cc0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4d00
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq (%rcx), %rax
jne 0x2d11
jmp 0x2d4a
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4cc0
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4d00
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq (%rcx), %rax
jae 0x2d44
movb $0x1, -0x1(%rbp)
jmp 0x2d5c
movb $0x0, -0x1(%rbp)
jmp 0x2d5c
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2cdb
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chuckwolber[P]Cube/test/../Algorithm.cpp
// Function: Algorithm::incrementAlgorithmToAlgNum(unsigned long long)
void Algorithm::incrementAlgorithmToAlgNum(unsigned long long int algNum) {
    if (algNum == algorithmNumber)
        return;

    if (algNum < algorithmNumber)
        setAlgorithmNumber(algNum);
    else
        addToAlgorithm(algNum - algorithmNumber);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x20(%rcx), %rax
jne 0x2ec4
jmp 0x2ef2
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x20(%rcx), %rax
jae 0x2ee1
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x25e0
jmp 0x2ef2
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
subq 0x20(%rdi), %rsi
callq 0x2a00
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chuckwolber[P]Cube/test/../Algorithm.cpp
// Function: Algorithm::isValid(char const*)
bool Algorithm::isValid(const char* algorithm) {
    if (algorithm == nullptr)
        return false;
    
    bool inTurn = false;
    Layer layer;

    while (*algorithm != '\0') {
        layer = Algorithm::charToLayer(*algorithm);
        if (inTurn) {
            if (*algorithm != ' ' && *algorithm != '\'')
                return false;
            if (*algorithm == ' ')
                inTurn = false;
        } else if (layer != Layer::NOLAYER) {
            inTurn = true;
        } else {
            return false;
        }
        algorithm++;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2f19
movb $0x0, -0x1(%rbp)
jmp 0x2f94
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2f90
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x2fa0
movl %eax, -0x18(%rbp)
testb $0x1, -0x11(%rbp)
je 0x2f6e
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x2f5c
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x27, %eax
je 0x2f5c
movb $0x0, -0x1(%rbp)
jmp 0x2f94
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x2f6c
movb $0x0, -0x11(%rbp)
jmp 0x2f82
cmpl $0xd, -0x18(%rbp)
je 0x2f7a
movb $0x1, -0x11(%rbp)
jmp 0x2f80
movb $0x0, -0x1(%rbp)
jmp 0x2f94
jmp 0x2f82
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2f1d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: chuckwolber[P]Cube/test/../Algorithm.cpp
// Function: Algorithm::charToLayer(char)
Layer Algorithm::charToLayer(char lChar) {
   switch (lChar) {
      case 'F':
         return Layer::F;
         break;
      case 'U':
         return Layer::U;
         break;
      case 'R':
         return Layer::R;
         break;
      case 'D':
         return Layer::D;
         break;
      case 'L':
         return Layer::L;
         break;
      case 'B':
         return Layer::B;
         break;
      case 'M':
         return Layer::M;
         break;
      case 'E':
         return Layer::E;
         break;
      case 'S':
         return Layer::S;
         break;
      default:
         return Layer::NOLAYER;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
addl $-0x42, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x13, %eax
ja 0x3021
movq -0x10(%rbp), %rax
leaq 0xd03d(%rip), %rcx      # 0x10004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x5, -0x4(%rbp)
jmp 0x3028
movl $0x1, -0x4(%rbp)
jmp 0x3028
movl $0x6, -0x4(%rbp)
jmp 0x3028
movl $0x9, -0x4(%rbp)
jmp 0x3028
movl $0x4, -0x4(%rbp)
jmp 0x3028
movl $0x7, -0x4(%rbp)
jmp 0x3028
movl $0xa, -0x4(%rbp)
jmp 0x3028
movl $0xb, -0x4(%rbp)
jmp 0x3028
movl $0xc, -0x4(%rbp)
jmp 0x3028
movl $0xd, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: chuckwolber[P]Cube/test/../Algorithm.cpp
// Function: Algorithm::getNumberForTurn(Turn) const
unsigned int Algorithm::getNumberForTurn(Turn turn) const {
   unsigned int number;
   switch(turn.layer) {
      case Layer::F:
         number = 0;
         break;
      case Layer::U:
         number = 2;
         break;
      case Layer::R:
         number = 4;
         break;
      case Layer::D:
         number = 6;
         break;
      case Layer::L:
         number = 8;
         break;
      case Layer::B:
         number = 10;
         break;
      default:
         number = 0;
         break;
   }

   if (!turn.clockwise)
      number++;
   return number;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl -0x8(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x8, %eax
ja 0x30d6
movq -0x20(%rbp), %rax
leaq 0xcfbd(%rip), %rcx      # 0x10054
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x14(%rbp)
jmp 0x30dd
movl $0x2, -0x14(%rbp)
jmp 0x30dd
movl $0x4, -0x14(%rbp)
jmp 0x30dd
movl $0x6, -0x14(%rbp)
jmp 0x30dd
movl $0x8, -0x14(%rbp)
jmp 0x30dd
movl $0xa, -0x14(%rbp)
jmp 0x30dd
movl $0x0, -0x14(%rbp)
testb $0x1, -0x4(%rbp)
jne 0x30ec
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chuckwolber[P]Cube/test/../Algorithm.cpp
// Function: Algorithm::getAlgorithmStr[abi:cxx11]() const
std::string Algorithm::getAlgorithmStr() const {
    std::string result = "";
    for (size_t i=algorithm.size(); i > 0; i--) {
        Turn t = getTurnForNumber(algorithm[i-1]);
        result += layerToChar(t.layer);

        if (!t.clockwise)
            result += "\'";
        if (i > 1)
            result += " ";
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x22b0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0xd85c(%rip), %rsi      # 0x1099f
callq 0x4fd0
jmp 0x314a
leaq -0x12(%rbp), %rdi
callq 0x21e0
movq -0x50(%rbp), %rdi
callq 0x4ca0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jbe 0x3229
movq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rsi
decq %rsi
callq 0x5080
movq -0x50(%rbp), %rdi
movq (%rax), %rsi
callq 0x3250
movq %rax, -0x60(%rbp)
jmp 0x318d
movq -0x60(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x38(%rbp), %edi
callq 0x3370
movb %al, -0x61(%rbp)
jmp 0x31a2
movq -0x48(%rbp), %rdi
movb -0x61(%rbp), %al
movsbl %al, %esi
callq 0x20f0
jmp 0x31b3
testb $0x1, -0x34(%rbp)
jne 0x31fb
movq -0x48(%rbp), %rdi
leaq 0xd311(%rip), %rsi      # 0x104d5
callq 0x2180
jmp 0x31cb
jmp 0x31fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x21e0
jmp 0x3246
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x20e0
jmp 0x3246
cmpq $0x1, -0x30(%rbp)
jbe 0x3216
movq -0x48(%rbp), %rdi
leaq 0xd791(%rip), %rsi      # 0x1099e
callq 0x2180
jmp 0x3214
jmp 0x3216
jmp 0x3218
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3160
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x323c
movq -0x48(%rbp), %rdi
callq 0x20e0
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x22a0
nop
// File: chuckwolber[P]Cube/test/../Algorithm.cpp
// Function: Algorithm::getTurnForNumber(unsigned long long) const
Turn Algorithm::getTurnForNumber(unsigned long long int number) const {
   number = number % ALGORITHM_BASE;
   switch (number) {
      case 0:
         return {Layer::F, true};
         break;
      case 1:
         return {Layer::F, false};
         break;
      case 2:
         return {Layer::U, true};
         break;
      case 3:
         return {Layer::U, false};
         break;
      case 4:
         return {Layer::R, true};
         break;
      case 5:
         return {Layer::R, false};
         break;
      case 6:
         return {Layer::D, true};
         break;
      case 7:
         return {Layer::D, false};
         break;
      case 8:
         return {Layer::L, true};
         break;
      case 9:
         return {Layer::L, false};
         break;
      case 10:
         return {Layer::B, true};
         break;
      case 11:
         return {Layer::B, false};
         break;
      default:
         return {Layer::F, true};
         break;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
movq -0x28(%rbp), %rax
movq %rdx, %rcx
shrq %rcx
andq $-0x4, %rcx
leaq (%rcx,%rcx,2), %rcx
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
subq $0xb, %rax
ja 0x3355
movq -0x20(%rbp), %rax
leaq 0xcdd1(%rip), %rcx      # 0x10078
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x5, -0x8(%rbp)
movb $0x1, -0x4(%rbp)
jmp 0x3360
movl $0x5, -0x8(%rbp)
movb $0x0, -0x4(%rbp)
jmp 0x3360
movl $0x1, -0x8(%rbp)
movb $0x1, -0x4(%rbp)
jmp 0x3360
movl $0x1, -0x8(%rbp)
movb $0x0, -0x4(%rbp)
jmp 0x3360
movl $0x6, -0x8(%rbp)
movb $0x1, -0x4(%rbp)
jmp 0x3360
movl $0x6, -0x8(%rbp)
movb $0x0, -0x4(%rbp)
jmp 0x3360
movl $0x9, -0x8(%rbp)
movb $0x1, -0x4(%rbp)
jmp 0x3360
movl $0x9, -0x8(%rbp)
movb $0x0, -0x4(%rbp)
jmp 0x3360
movl $0x4, -0x8(%rbp)
movb $0x1, -0x4(%rbp)
jmp 0x3360
movl $0x4, -0x8(%rbp)
movb $0x0, -0x4(%rbp)
jmp 0x3360
movl $0x7, -0x8(%rbp)
movb $0x1, -0x4(%rbp)
jmp 0x3360
movl $0x7, -0x8(%rbp)
movb $0x0, -0x4(%rbp)
jmp 0x3360
movl $0x5, -0x8(%rbp)
movb $0x1, -0x4(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chuckwolber[P]Cube/test/../Algorithm.cpp
// Function: Algorithm::layerToChar(Layer)
char Algorithm::layerToChar(Layer layer) {
   switch (layer) {
      case Layer::F:
         return 'F';
         break;
      case Layer::U:
         return 'U';
         break;
      case Layer::R:
         return 'R';
         break;
      case Layer::D:
         return 'D';
         break;
      case Layer::L:
         return 'L';
         break;
      case Layer::B:
         return 'B';
         break;
      case Layer::M:
         return 'M';
         break;
      case Layer::E:
         return 'E';
         break;
      case Layer::S:
         return 'S';
         break;
      default: // Keep the GNU happy.
         return 'X';
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0xb, %eax
ja 0x33d1
movq -0x10(%rbp), %rax
leaq 0xcd16(%rip), %rcx      # 0x100a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x46, -0x1(%rbp)
jmp 0x33d5
movb $0x55, -0x1(%rbp)
jmp 0x33d5
movb $0x52, -0x1(%rbp)
jmp 0x33d5
movb $0x44, -0x1(%rbp)
jmp 0x33d5
movb $0x4c, -0x1(%rbp)
jmp 0x33d5
movb $0x42, -0x1(%rbp)
jmp 0x33d5
movb $0x4d, -0x1(%rbp)
jmp 0x33d5
movb $0x45, -0x1(%rbp)
jmp 0x33d5
movb $0x53, -0x1(%rbp)
jmp 0x33d5
movb $0x58, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw (%rax,%rax)
// File: chuckwolber[P]Cube/test/../Algorithm.cpp
// Function: Algorithm::getAlgorithm() const
std::vector<Turn> Algorithm::getAlgorithm() const {
    std::vector<Turn> a;
    for (unsigned long i=algorithm.size(); i > 0; i--)
        a.push_back(getTurnForNumber(algorithm[i-1]));
    return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x50a0
movq -0x40(%rbp), %rdi
callq 0x4ca0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x3480
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
decq %rsi
callq 0x5080
movq -0x40(%rbp), %rdi
movq (%rax), %rsi
callq 0x3250
movq %rax, -0x58(%rbp)
jmp 0x3442
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x50c0
jmp 0x3459
jmp 0x345b
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3419
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x4920
jmp 0x349d
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x3493
movq -0x50(%rbp), %rdi
callq 0x4920
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x22a0
nopw %cs:(%rax,%rax)
// File: chuckwolber[P]Cube/test/../Algorithm.cpp
// Function: Algorithm::isRedundant()
bool Algorithm::isRedundant() {
    if (hasInversion())
        return true;
    if (hasHiddenInversion())
        return true;
    if (hasTriple())
        return true;
    if (hasHiddenTriple())
        return true;
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x3530
testb $0x1, %al
jne 0x34cf
jmp 0x34d5
movb $0x1, -0x1(%rbp)
jmp 0x3518
movq -0x18(%rbp), %rdi
callq 0x3660
testb $0x1, %al
jne 0x34e4
jmp 0x34ea
movb $0x1, -0x1(%rbp)
jmp 0x3518
movq -0x18(%rbp), %rdi
callq 0x39b0
testb $0x1, %al
jne 0x34f9
jmp 0x34ff
movb $0x1, -0x1(%rbp)
jmp 0x3518
movq -0x18(%rbp), %rdi
callq 0x3aa0
testb $0x1, %al
jne 0x350e
jmp 0x3514
movb $0x1, -0x1(%rbp)
jmp 0x3518
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chuckwolber[P]Cube/test/../Algorithm.cpp
// Function: Algorithm::hasInversion()
bool Algorithm::hasInversion() {
    if (algorithm.size() < 2)
        return false;

    /* X X' */
    for (unsigned int i = 0; i < (algorithm.size() - 1); i++) {
        if (algorithm.at(i) % 2 == 0 &&
            algorithm.at(i) == algorithm.at(i+1) - 1)
            return true;

        if (algorithm.at(i) % 2 == 1 &&
            algorithm.at(i) == algorithm.at(i+1) + 1)
            return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x4ca0
cmpq $0x2, %rax
jae 0x3558
movb $0x0, -0x1(%rbp)
jmp 0x364f
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x28(%rbp)
callq 0x4ca0
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x364b
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x4cc0
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x35df
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x4cc0
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x4cc0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq (%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x35df
movb $0x1, -0x1(%rbp)
jmp 0x364f
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x4cc0
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x1, %rax
jne 0x363b
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x4cc0
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x4cc0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq (%rcx), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jne 0x363b
movb $0x1, -0x1(%rbp)
jmp 0x364f
jmp 0x363d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x355f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chuckwolber[P]Cube/test/../Algorithm.cpp
// Function: Algorithm::hasTriple()
bool Algorithm::hasTriple() {
    /* 0:0 - X X X */
    if (algorithm.size() < 3)
        return false;

    for (unsigned int i = 0; i <= (algorithm.size() - 3); i++) {
        if (algorithm.at(i)   == algorithm.at(i+1) &&
            algorithm.at(i+1) == algorithm.at(i+2))
            return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x4ca0
cmpq $0x3, %rax
jae 0x39d8
movb $0x0, -0x1(%rbp)
jmp 0x3a8a
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x28(%rbp)
callq 0x4ca0
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq $0x3, %rcx
cmpq %rcx, %rax
ja 0x3a86
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x4cc0
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x4cc0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq (%rcx), %rax
jne 0x3a76
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x4cc0
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
addl $0x2, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x4cc0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq (%rcx), %rax
jne 0x3a76
movb $0x1, -0x1(%rbp)
jmp 0x3a8a
jmp 0x3a78
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x39df
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::Cube(CubieColor, unsigned int)
Cube::Cube(CubieColor referenceColor, unsigned int cubeSize) {
    if (cubeSize < MIN_SIZE)
        cubeSize = MIN_SIZE;

    this->cubeSize = cubeSize;
    this->fInitColor = referenceColor;
    initializeCube();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl $0x2, 0x20(%rcx)
movl $0x3, 0x24(%rcx)
movl $0x3, 0x28(%rcx)
movl $0x4, 0x2c(%rcx)
movl $0x18, 0x30(%rcx)
movl -0x10(%rbp), %eax
cmpl 0x20(%rcx), %eax
jae 0x7d82
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, 0x8(%rdi)
movb -0x9(%rbp), %al
movb %al, (%rdi)
callq 0x7b30
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::Cube(Cube const&)
Cube::Cube(const Cube& obj) {
    cubeSize = obj.cubeSize;
    fInitColor = obj.fInitColor;
    initializeCube();
    copyCube(obj);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0x2, 0x20(%rdi)
movl $0x3, 0x24(%rdi)
movl $0x3, 0x28(%rdi)
movl $0x4, 0x2c(%rdi)
movl $0x18, 0x30(%rdi)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x8(%rdi)
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, (%rdi)
callq 0x7b30
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7e10
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::copyCubeAttributes(Cube const&)
void Cube::copyCubeAttributes(const Cube& from) {
    cubeSize   = from.cubeSize;
    fInitColor = from.fInitColor;
    cube       = from.cube;
    edges      = from.edges;
    fInitColor = from.fInitColor;
    uInitColor = from.uInitColor;
    dInitColor = from.dInitColor;
    lInitColor = from.lInitColor;
    rInitColor = from.rInitColor;
    bInitColor = from.bInitColor;
    fUpperLeft = from.fUpperLeft;
    uUpperLeft = from.uUpperLeft;
    lUpperLeft = from.lUpperLeft;
    rUpperLeft = from.rUpperLeft;
    fUpperLeftMax = from.fUpperLeftMax;
    uUpperLeftMax = from.uUpperLeftMax;
    lUpperLeftMax = from.lUpperLeftMax;
    rUpperLeftMax = from.rUpperLeftMax;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movb (%rcx), %cl
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movb (%rcx), %cl
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movb 0x1(%rcx), %cl
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rcx
movb 0x2(%rcx), %cl
movb %cl, 0x2(%rax)
movq -0x10(%rbp), %rcx
movb 0x3(%rcx), %cl
movb %cl, 0x3(%rax)
movq -0x10(%rbp), %rcx
movb 0x4(%rcx), %cl
movb %cl, 0x4(%rax)
movq -0x10(%rbp), %rcx
movb 0x5(%rcx), %cl
movb %cl, 0x5(%rax)
movq -0x10(%rbp), %rcx
movq 0x34(%rcx), %rcx
movq %rcx, 0x34(%rax)
movq -0x10(%rbp), %rcx
movq 0x44(%rcx), %rcx
movq %rcx, 0x44(%rax)
movq -0x10(%rbp), %rcx
movq 0x54(%rcx), %rcx
movq %rcx, 0x54(%rax)
movq -0x10(%rbp), %rcx
movq 0x64(%rcx), %rcx
movq %rcx, 0x64(%rax)
movq -0x10(%rbp), %rcx
movq 0x3c(%rcx), %rcx
movq %rcx, 0x3c(%rax)
movq -0x10(%rbp), %rcx
movq 0x4c(%rcx), %rcx
movq %rcx, 0x4c(%rax)
movq -0x10(%rbp), %rcx
movq 0x5c(%rcx), %rcx
movq %rcx, 0x5c(%rax)
movq -0x10(%rbp), %rcx
movq 0x6c(%rcx), %rcx
movq %rcx, 0x6c(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::operator=(Cube const&)
Cube& Cube::operator=(const Cube& rhs) {
    if (&rhs != this) {
        destroyCube();
        cubeSize = rhs.cubeSize;
        fInitColor = rhs.fInitColor;
        initializeCube();
        copyCube(rhs);
    }
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq %rax, -0x10(%rbp)
je 0x802f
movq -0x18(%rbp), %rdi
callq 0x8040
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x8(%rdi)
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, (%rdi)
callq 0x7b30
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7e10
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::destroyCube()
void Cube::destroyCube() {
    if (cube != nullptr) {
        for (unsigned int i=0; i<(LAYERS_PER_COL*cubeSize); i++)
            delete[] cube[i];
        delete[] cube;
        cube = nullptr;
    }

    if (edges != nullptr) {
        delete[] edges;
        edges = nullptr;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x80ca
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdx
movl -0xc(%rbp), %eax
movl 0x28(%rdx), %ecx
imull 0x8(%rdx), %ecx
cmpl %ecx, %eax
jae 0x80a3
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x8096
movq -0x20(%rbp), %rdi
callq 0x2230
jmp 0x8098
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8062
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x80be
movq -0x28(%rbp), %rdi
callq 0x2230
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x80fc
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x80f0
movq -0x30(%rbp), %rdi
callq 0x2230
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::operator=(Cube&&)
Cube& Cube::operator=(Cube&& rhs) {
    if (&rhs != this) {
        destroyCube();
        copyCubeAttributes(rhs);
        rhs.cube = nullptr;
        rhs.edges = nullptr;
    }
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq %rax, -0x10(%rbp)
je 0x815c
movq -0x18(%rbp), %rdi
callq 0x8040
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7f00
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::operator==(Cube const&)
bool Cube::operator==(const Cube& obj) {
    if (cubeSize != obj.cubeSize)
        return false;

    for (unsigned int row=0; row<LAYERS_PER_COL*cubeSize; row++)
        for (unsigned int col=0; col<LAYERS_PER_ROW*cubeSize; col++)
            if (cube[row][col] != obj.cube[row][col])
                return false;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0x8199
movb $0x0, -0x1(%rbp)
jmp 0x821f
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdx
movl -0x1c(%rbp), %eax
movl 0x28(%rdx), %ecx
imull 0x8(%rdx), %ecx
cmpl %ecx, %eax
jae 0x821b
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rdx
movl -0x20(%rbp), %eax
movl 0x2c(%rdx), %ecx
imull 0x8(%rdx), %ecx
cmpl %ecx, %eax
jae 0x820e
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x20(%rbp), %ecx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl -0x1c(%rbp), %edx
movq (%rcx,%rdx,8), %rcx
movl -0x20(%rbp), %edx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x8201
movb $0x0, -0x1(%rbp)
jmp 0x821f
jmp 0x8203
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x81b9
jmp 0x8210
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x81a0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::getCube()
std::vector<CubieColor> Cube::getCube() {
   std::vector<CubieColor> tmp;

    for (unsigned int row=0; row<LAYERS_PER_COL*cubeSize; row++)
        for (unsigned int col=0; col<LAYERS_PER_ROW*cubeSize; col++)
            tmp.push_back(cube[row][col]);

    return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x95a0
movl $0x0, -0x18(%rbp)
movq -0x38(%rbp), %rdx
movl -0x18(%rbp), %eax
movl 0x28(%rdx), %ecx
imull 0x8(%rdx), %ecx
cmpl %ecx, %eax
jae 0x835f
movl $0x0, -0x1c(%rbp)
movq -0x38(%rbp), %rdx
movl -0x1c(%rbp), %eax
movl 0x2c(%rdx), %ecx
imull 0x8(%rdx), %ecx
cmpl %ecx, %eax
jae 0x8352
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x18(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
movl -0x1c(%rbp), %eax
addq %rax, %rsi
callq 0x95c0
jmp 0x832e
jmp 0x8330
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x82fc
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x9630
jmp 0x837c
jmp 0x8354
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x82e3
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x8372
movq -0x48(%rbp), %rdi
callq 0x9630
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x22a0
nopw %cs:(%rax,%rax)
// File: chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::cubieColorToChar(CubieColor)
char Cube::cubieColorToChar(CubieColor cubie) {
    switch (cubie) {
        case CubieColor::BLUE:
            return 'b';
            break;
        case CubieColor::GREEN:
            return 'g';
            break;
        case CubieColor::ORANGE:
            return 'o';
            break;
        case CubieColor::RED:
            return 'r';
            break;
        case CubieColor::WHITE:
            return 'w';
            break;
        case CubieColor::YELLOW:
            return 'y';
            break;
        default:
            return ' ';
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movsbl -0x2(%rbp), %eax
addl $-0x62, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x17, %eax
ja 0x83e4
movq -0x10(%rbp), %rax
leaq 0x7de9(%rip), %rcx      # 0x101a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x62, -0x1(%rbp)
jmp 0x83e8
movb $0x67, -0x1(%rbp)
jmp 0x83e8
movb $0x6f, -0x1(%rbp)
jmp 0x83e8
movb $0x72, -0x1(%rbp)
jmp 0x83e8
movb $0x77, -0x1(%rbp)
jmp 0x83e8
movb $0x79, -0x1(%rbp)
jmp 0x83e8
movb $0x20, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax)
// File: chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::isSolved()
bool Cube::isSolved() {
    if (!isSolved(fUpperLeft, fUpperLeftMax))
        return false;
    if (!isSolved(uUpperLeft, uUpperLeftMax))
        return false;
    if (!isSolved(lUpperLeft, lUpperLeftMax))
        return false;
    if (!isSolved(rUpperLeft, rUpperLeftMax))
        return false;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq 0x34(%rdi), %rax
movq %rax, -0x18(%rbp)
movq 0x3c(%rdi), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x84c0
testb $0x1, %al
jne 0x842e
movb $0x0, -0x1(%rbp)
jmp 0x84b3
movq -0x58(%rbp), %rdi
movq 0x44(%rdi), %rax
movq %rax, -0x28(%rbp)
movq 0x4c(%rdi), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x84c0
testb $0x1, %al
jne 0x8459
movb $0x0, -0x1(%rbp)
jmp 0x84b3
movq -0x58(%rbp), %rdi
movq 0x54(%rdi), %rax
movq %rax, -0x38(%rbp)
movq 0x5c(%rdi), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x84c0
testb $0x1, %al
jne 0x8484
movb $0x0, -0x1(%rbp)
jmp 0x84b3
movq -0x58(%rbp), %rdi
movq 0x64(%rdi), %rax
movq %rax, -0x48(%rbp)
movq 0x6c(%rdi), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x84c0
testb $0x1, %al
jne 0x84af
movb $0x0, -0x1(%rbp)
jmp 0x84b3
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nop
// File: chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::isSolved(Coordinate, Coordinate)
bool Cube::isSolved(Coordinate upperLeft, Coordinate upperLeftMax) {
    char cubieVal = cube[upperLeft.row][upperLeft.col];
    for (unsigned int row=upperLeft.row; row<upperLeftMax.row; row++)
        for (unsigned int col=upperLeft.col; col<upperLeftMax.col; col++)
            if (cubieVal != cube[row][col])
                return false;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, -0xc(%rbp)
movq %rdx, -0x14(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x8(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x8546
movl -0x8(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x8539
movq -0x38(%rbp), %rcx
movsbl -0x21(%rbp), %eax
movq 0x10(%rcx), %rcx
movl -0x28(%rbp), %edx
movq (%rcx,%rdx,8), %rcx
movl -0x2c(%rbp), %edx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x852c
movb $0x0, -0x1(%rbp)
jmp 0x854a
jmp 0x852e
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x8500
jmp 0x853b
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x84f2
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)