LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
callq 0x2a98
movl %eax, %eax
movq %rsp, %rdx
movq %rax, (%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3664
movq $0x0, 0x20(%rbx)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x23d8
movl $0x1, %edx
xorl %esi, %esi
movq (%rax), %rdi
imulq %rdx, %rdi
addq %rdi, %rsi
movq %rsi, 0x20(%rbx)
shlq $0x2, %rdx
leaq (%rdx,%rdx,2), %rdx
addq $0x8, %rax
cmpq %rcx, %rax
jne 0x23b9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x243d
movq %rax, 0x8(%r14)
movq $0x0, 0x20(%r14)
movabsq $0x100000005, %rsi      # imm = 0x100000005
movq %r14, %rdi
callq 0x237c
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x26ce
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x2507
movq %rax, 0x8(%rbx)
movq $0x0, 0x20(%rbx)
movq (%rsi), %r14
movq 0x8(%rsi), %r15
cmpq %r15, %r14
je 0x252c
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x237c
addq $0x8, %r14
jmp 0x2516
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x29f4
testb %al, %al
je 0x267f
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x25fb
movq %rax, 0x8(%rbx)
movb (%r14), %r12b
testb %r12b, %r12b
je 0x2664
incq %r14
xorl %r15d, %r15d
movsbl %r12b, %edi
callq 0x2a56
testq %r15, %r15
je 0x2628
cmpb $0x27, %r12b
je 0x2644
movzbl %r12b, %eax
cmpl $0x20, %eax
je 0x2649
jmp 0x2657
movl %eax, %ebp
cmpl $0xd, %eax
je 0x2654
movl $0x8, %edi
callq 0x2110
movq %rax, %r15
movb $0x1, 0x4(%rax)
movl %ebp, (%rax)
jmp 0x2657
movb $0x0, 0x4(%r15)
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x237c
xorl %r15d, %r15d
movb (%r14), %r12b
incq %r14
testb %r12b, %r12b
jne 0x2609
jmp 0x2667
xorl %r15d, %r15d
testq %r15, %r15
je 0x267f
movq (%r15), %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x237c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rdi, %rsi
je 0x26ae
movq %rsi, %r14
movq %rbx, %rdi
callq 0x3556
movq 0x20(%r14), %rax
movq %rax, 0x20(%rbx)
movl 0x18(%r14), %eax
movl %eax, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
addq %rsi, 0x20(%rdi)
testq %rsi, %rsi
je 0x27e4
movq %rsi, %r12
movq %rdi, %rbx
movl $0x1, %r13d
movq %rsp, %r14
movabsq $-0x5555555555555555, %rbp # imm = 0xAAAAAAAAAAAAAAAB
xorl %r15d, %r15d
movq 0x8(%rbx), %rsi
movq %rsi, %rax
subq (%rbx), %rax
sarq $0x3, %rax
movl %r13d, %ecx
cmpq %rcx, %rax
jae 0x274e
movq $0x0, (%rsp)
cmpq 0x10(%rbx), %rsi
je 0x2737
movq $0x0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2742
movq %rbx, %rdi
movq %r14, %rdx
callq 0x36ec
testq %r12, %r12
je 0x27d0
decq %r12
movq %r12, %rcx
leal -0x1(%r13), %eax
movl %eax, %esi
movq (%rbx), %r8
movq 0x8(%rbx), %rdx
subq %r8, %rdx
sarq $0x3, %rdx
cmpq %rsi, %rdx
jbe 0x27f3
movq %rcx, %rax
mulq %rbp
movq %rdx, %r12
shrq $0x3, %r12
leaq (,%r12,4), %rax
leaq (%rax,%rax,2), %rax
movq %rcx, %rdi
subq %rax, %rdi
addq %r15, %rdi
addq (%r8,%rsi,8), %rdi
movq %rdi, %rax
mulq %rbp
movq %rdx, %r15
shrq $0x3, %r15
leaq (,%r15,4), %rax
leaq (%rax,%rax,2), %rax
movq %rdi, %rdx
subq %rax, %rdx
movq %rdx, (%r8,%rsi,8)
incl %r13d
cmpq $0xb, %rcx
ja 0x2702
cmpq $0xb, %rdi
ja 0x2702
jmp 0x27e4
subq $0x1, %r15
movl $0x0, %eax
cmovbq %rax, %r15
xorl %ecx, %ecx
jmp 0x2751
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7a0e(%rip), %rdi      # 0xa208
xorl %eax, %eax
callq 0x2170
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rax
movq (%rdi), %r8
movq 0x8(%rdi), %rdx
subq %r8, %rdx
sarq $0x3, %rdx
movq (%rsi), %rdi
movq 0x8(%rsi), %rcx
subq %rdi, %rcx
sarq $0x3, %rcx
cmpq %rcx, %rdx
jbe 0x28f6
xorl %eax, %eax
jmp 0x2925
movb $0x1, %al
jb 0x2925
leaq -0x1(%rdx), %rsi
leaq 0x1(%rsi), %rax
testq %rax, %rax
jle 0x28f2
cmpq %rsi, %rdx
jbe 0x2927
cmpq %rsi, %rcx
jbe 0x2930
movq (%rdi,%rsi,8), %rax
leaq -0x1(%rsi), %r9
cmpq %rax, (%r8,%rsi,8)
movq %r9, %rsi
je 0x28fe
setb %al
popq %rcx
retq
leaq 0x78da(%rip), %rdi      # 0xa208
jmp 0x293a
leaq 0x78d1(%rip), %rdi      # 0xa208
movq %rcx, %rdx
xorl %eax, %eax
callq 0x2170
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x2a49
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rdi), %cl
testb %cl, %cl
sete %al
je 0x2a4e
incq %rbx
xorl %ebp, %ebp
xorl %edx, %edx
testb $0x1, %dl
je 0x2a2c
cmpb $0x27, %cl
je 0x2a21
movzbl %cl, %eax
cmpl $0x20, %eax
jne 0x2a4c
cmpb $0x20, %cl
movzbl %dl, %edx
cmovel %ebp, %edx
jmp 0x2a3b
movsbl %cl, %edi
callq 0x2a56
movb $0x1, %dl
cmpl $0xd, %eax
je 0x2a4c
movb (%rbx), %cl
incq %rbx
testb %cl, %cl
sete %al
jne 0x2a0f
jmp 0x2a4e
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
leaq 0x7f04(%rip), %rdx      # 0xa9e3
movq %rdx, %rsi
callq 0x380c
movq 0x8(%r14), %rbp
subq (%r14), %rbp
je 0x2bd0
sarq $0x3, %rbp
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
leaq 0x74ff(%rip), %r15      # 0xa008
movq (%r14), %rax
movq -0x8(%rax,%rbp,8), %rcx
movq %rcx, %rax
mulq %r13
shrq %rdx
andq $-0x4, %rdx
leaq (%rdx,%rdx,2), %rax
subq %rax, %rcx
movl $0x5, %edi
movslq (%r15,%rcx,4), %rax
addq %r15, %rax
jmpq *%rax
movb $0x1, %r12b
jmp 0x2b8e
movb $0x1, %r12b
movl $0x7, %edi
jmp 0x2b8e
movl $0x6, %edi
jmp 0x2b8b
movb $0x1, %r12b
movl $0x4, %edi
jmp 0x2b8e
movl $0x1, %edi
jmp 0x2b8b
movb $0x1, %r12b
movl $0x1, %edi
jmp 0x2b8e
movb $0x1, %r12b
movl $0x9, %edi
jmp 0x2b8e
movb $0x1, %r12b
movl $0x6, %edi
jmp 0x2b8e
movl $0x9, %edi
jmp 0x2b8b
movl $0x7, %edi
jmp 0x2b8b
movl $0x4, %edi
xorl %r12d, %r12d
callq 0x2c3a
movsbl %al, %esi
movq %rbx, %rdi
callq 0x20e0
testb %r12b, %r12b
je 0x2bb2
movq %rbx, %rdi
leaq 0x796c(%rip), %rsi      # 0xa519
callq 0x21c0
cmpq $0x1, %rbp
je 0x2bc7
movq %rbx, %rdi
leaq 0x7e20(%rip), %rsi      # 0xa9e2
callq 0x21c0
decq %rbp
jne 0x2b09
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x2bfd
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2120
movq %r14, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r12
subq (%rsi), %r12
je 0x2cce
movq %rsi, %r14
sarq $0x3, %r12
leaq 0x7435(%rip), %rbp      # 0xa0b8
leaq 0x748e(%rip), %r13      # 0xa118
movq %rsp, %r15
movq (%r14), %rax
movq -0x8(%rax,%r12,8), %rcx
movq %rcx, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rdx
shrl %edx
andl $-0x4, %edx
leal (%rdx,%rdx,2), %eax
subl %eax, %ecx
shll $0x3, %ecx
movq (%rcx,%r13), %rax
orq (%rcx,%rbp), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x389c
decq %r12
jne 0x2c8d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2cf7
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2120
movq %r14, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
callq 0x2d32
testb %al, %al
jne 0x2d25
movq %rbx, %rdi
callq 0x2db6
testb %al, %al
jne 0x2d25
movq %rbx, %rdi
callq 0x2fac
testb %al, %al
je 0x2d29
movb $0x1, %al
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x3020
// File: /workspace/github_cpp_makefile_star2_O1/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 %rax
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq $0x2, %rdx
jae 0x2d4b
xorl %eax, %eax
jmp 0x2da3
movq %rdx, %rdi
decq %rdi
setne %al
je 0x2da3
movl $0x1, %r8d
xorl %esi, %esi
cmpq %rsi, %rdx
jbe 0x2da7
movq (%rcx,%rsi,8), %r9
movl %r8d, %esi
testb $0x1, %r9b
jne 0x2d87
cmpq %rsi, %rdx
jbe 0x2da7
movq (%rcx,%rsi,8), %r10
decq %r10
cmpq %r10, %r9
je 0x2da3
testb $0x1, %r9b
je 0x2d98
cmpq %rsi, %rdx
jbe 0x2da7
movq (%rcx,%rsi,8), %r10
incq %r10
cmpq %r10, %r9
je 0x2da3
incl %r8d
cmpq %rsi, %rdi
seta %al
ja 0x2d5e
andb $0x1, %al
popq %rcx
retq
leaq 0x745a(%rip), %rdi      # 0xa208
xorl %eax, %eax
callq 0x2170
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rax
movq (%rdi), %r8
movq 0x8(%rdi), %rdx
subq %r8, %rdx
sarq $0x3, %rdx
cmpq $0x3, %rdx
jae 0x2fc5
xorl %eax, %eax
jmp 0x3002
leaq -0x3(%rdx), %rdi
movb $0x1, %al
movl $0x1, %r9d
xorl %ecx, %ecx
movl %r9d, %esi
cmpq %rsi, %rdx
jbe 0x3006
movq (%r8,%rsi,8), %r9
cmpq %r9, (%r8,%rcx,8)
jne 0x2ff3
leal 0x1(%rsi), %ecx
cmpq %rcx, %rdx
jbe 0x300f
cmpq (%r8,%rcx,8), %r9
je 0x3002
leal 0x1(%rsi), %r9d
movq %rsi, %rcx
cmpq %rsi, %rdi
setae %al
jae 0x2fd3
andb $0x1, %al
popq %rcx
retq
leaq 0x71fb(%rip), %rdi      # 0xa208
jmp 0x3019
leaq 0x71f2(%rip), %rdi      # 0xa208
movq %rcx, %rsi
xorl %eax, %eax
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::initializeCube()
void Cube::initializeCube() {
    cube = new CubieColor*[LAYERS_PER_COL*cubeSize];
    for (unsigned int i=0; i<(LAYERS_PER_COL*cubeSize); i++)
        cube[i] = new CubieColor[LAYERS_PER_ROW*cubeSize];

    for (unsigned int row=0; row<LAYERS_PER_COL*cubeSize; row++)
        for (unsigned int col=0; col<LAYERS_PER_ROW*cubeSize; col++)
            cube[row][col] = CubieColor::NOCOLOR;
   
    initializeLayers();
    initializeEdges();

    getLayerUpperLeft(fUpperLeft, Layer::F);
    fUpperLeftMax.row = fUpperLeft.row + cubeSize;
    fUpperLeftMax.col = fUpperLeft.col + cubeSize;

    getLayerUpperLeft(uUpperLeft, Layer::U);
    uUpperLeftMax.row = uUpperLeft.row + cubeSize;
    uUpperLeftMax.col = uUpperLeft.col + cubeSize;

    getLayerUpperLeft(lUpperLeft, Layer::L);
    lUpperLeftMax.row = lUpperLeft.row + cubeSize;
    lUpperLeftMax.col = lUpperLeft.col + cubeSize;

    getLayerUpperLeft(rUpperLeft, Layer::R);
    rUpperLeftMax.row = rUpperLeft.row + cubeSize;
    rUpperLeftMax.col = rUpperLeft.col + cubeSize;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %r14d
movl 0x28(%rdi), %r12d
imull %r14d, %r12d
leaq (,%r12,8), %rdi
callq 0x2030
movq %rax, 0x10(%rbx)
testl %r12d, %r12d
je 0x3a8c
movl 0x2c(%rbx), %r15d
imull %r14d, %r15d
movl %r12d, %r12d
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x2030
movq 0x10(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
incq %r13
cmpq %r13, %r12
jne 0x3a4a
imull 0x2c(%rbx), %r14d
movq 0x10(%rbx), %r15
xorl %r13d, %r13d
testq %r14, %r14
je 0x3a84
movq (%r15,%r13,8), %rdi
movl $0x20, %esi
movq %r14, %rdx
callq 0x2070
incq %r13
cmpq %r13, %r12
jne 0x3a6e
movq %rbx, %rdi
callq 0x4524
movq %rbx, %rdi
callq 0x4604
movl 0x8(%rbx), %esi
movl 0x2c(%rbx), %r8d
xorl %edi, %edi
movl $0x5, %eax
xorl %edx, %edx
divl %r8d
imull %esi, %edx
cmpl $0x3, %r8d
setb %cl
movl %esi, %r9d
shll %cl, %r9d
movl %edx, 0x38(%rbx)
cmpl $0x6, %r8d
movl %r9d, %eax
cmovael %edi, %eax
movl %eax, 0x34(%rbx)
addl %esi, %eax
movl %eax, 0x3c(%rbx)
addl %esi, %edx
movl %edx, 0x40(%rbx)
cmpl $0x1, %r8d
movl %esi, %eax
cmovel %edi, %eax
movl %eax, 0x48(%rbx)
movl %esi, %ecx
cmoval %edi, %ecx
movl %ecx, 0x44(%rbx)
addl %esi, %ecx
movl %ecx, 0x4c(%rbx)
addl %esi, %eax
movl %eax, 0x50(%rbx)
movl $0x4, %eax
xorl %edx, %edx
divl %r8d
imull %esi, %edx
movl %edx, 0x58(%rbx)
cmpl $0x5, %r8d
cmovael %edi, %r9d
movl %r9d, 0x54(%rbx)
addl %esi, %r9d
movl %r9d, 0x5c(%rbx)
addl %esi, %edx
movl %edx, 0x60(%rbx)
movl $0x6, %eax
xorl %edx, %edx
divl %r8d
imull %esi, %edx
movl %edx, 0x68(%rbx)
cmpl $0x4, %r8d
setb %cl
movl %esi, %eax
shll %cl, %eax
cmpl $0x7, %r8d
cmovael %edi, %eax
movl %eax, 0x64(%rbx)
addl %esi, %eax
movl %eax, 0x6c(%rbx)
addl %esi, %edx
movl %edx, 0x70(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movaps 0x66ed(%rip), %xmm0     # 0xa2a0
movups %xmm0, 0x20(%rdi)
movl $0x18, 0x30(%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movb (%rsi), %al
movb %al, (%rdi)
callq 0x3a0e
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3be0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movb (%rsi), %al
movb %al, (%rdi)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
movq 0x18(%rsi), %rax
movq %rax, 0x18(%rdi)
movb (%rsi), %al
movb %al, (%rdi)
movb 0x1(%rsi), %al
movb %al, 0x1(%rdi)
movb 0x2(%rsi), %al
movb %al, 0x2(%rdi)
movb 0x3(%rsi), %al
movb %al, 0x3(%rdi)
movb 0x4(%rsi), %al
movb %al, 0x4(%rdi)
movb 0x5(%rsi), %al
movb %al, 0x5(%rdi)
movq 0x34(%rsi), %rax
movq %rax, 0x34(%rdi)
movq 0x44(%rsi), %rax
movq %rax, 0x44(%rdi)
movq 0x54(%rsi), %rax
movq %rax, 0x54(%rdi)
movq 0x64(%rsi), %rax
movq %rax, 0x64(%rdi)
movq 0x3c(%rsi), %rax
movq %rax, 0x3c(%rdi)
movq 0x4c(%rsi), %rax
movq %rax, 0x4c(%rdi)
movq 0x5c(%rsi), %rax
movq %rax, 0x5c(%rdi)
movq 0x6c(%rsi), %rax
movq %rax, 0x6c(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rdi, %rsi
je 0x3d02
movq %rsi, %r14
movq %rbx, %rdi
callq 0x3d0e
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
movb (%r14), %al
movb %al, (%rbx)
movq %rbx, %rdi
callq 0x3a0e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3be0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x3d61
movl 0x8(%rbx), %eax
imull 0x28(%rbx), %eax
testl %eax, %eax
je 0x3d4b
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x3d3c
callq 0x2160
incq %r14
movl 0x8(%rbx), %eax
imull 0x28(%rbx), %eax
cmpq %rax, %r14
jb 0x3d2a
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x3d59
callq 0x2160
movq $0x0, 0x10(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x3d77
callq 0x2160
movq $0x0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rdi, %rsi
je 0x3daa
movq %rsi, %r14
movq %rbx, %rdi
callq 0x3d0e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3c4e
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl 0x8(%rdi), %ecx
cmpl 0x8(%rsi), %ecx
jne 0x3e44
movl 0x28(%rdi), %r9d
imull %ecx, %r9d
testl %r9d, %r9d
sete %al
je 0x3e46
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
imull 0x2c(%rdi), %ecx
movl %ecx, %edx
addl $-0x1, %edx
setb %r8b
movq 0x10(%rdi), %rdi
movq 0x10(%rsi), %rsi
movl %r9d, %r9d
xorl %r10d, %r10d
testl %ecx, %ecx
je 0x3e31
movq (%rdi,%r10,8), %r11
movq (%rsi,%r10,8), %rbx
movb (%r11), %r14b
movl %r8d, %ebp
cmpb (%rbx), %r14b
jne 0x3e2c
xorl %r14d, %r14d
cmpl %r14d, %edx
je 0x3e31
movb 0x1(%r11,%r14), %bpl
leaq 0x1(%r14), %r15
cmpb 0x1(%rbx,%r14), %bpl
movq %r15, %r14
je 0x3e0d
cmpl %ecx, %r15d
setb %bpl
testb %bpl, %bpl
jne 0x3e3c
incq %r10
cmpq %r9, %r10
setae %al
jne 0x3df3
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3e46
xorl %eax, %eax
andb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl 0x8(%rsi), %eax
imull 0x28(%rsi), %eax
testl %eax, %eax
je 0x3ee4
movq %rsi, %r14
xorl %r15d, %r15d
movl 0x8(%r14), %eax
imull 0x2c(%r14), %eax
testl %eax, %eax
je 0x3ed3
xorl %r12d, %r12d
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rdx
addq %r12, %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3eba
movb (%rdx), %al
movb %al, (%rsi)
incq %rsi
movq %rsi, 0x8(%rbx)
jmp 0x3ec2
movq %rbx, %rdi
callq 0x4b28
incq %r12
movl 0x8(%r14), %eax
imull 0x2c(%r14), %eax
cmpq %rax, %r12
jb 0x3e98
incq %r15
movl 0x8(%r14), %eax
imull 0x28(%r14), %eax
cmpq %rax, %r15
jb 0x3e88
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3f0a
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2120
movq %r14, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movq 0x34(%rdi), %rsi
movq 0x3c(%rdi), %rdx
callq 0x3f7c
testb %al, %al
je 0x3f78
movq 0x44(%rbx), %rsi
movq 0x4c(%rbx), %rdx
movq %rbx, %rdi
callq 0x3f7c
testb %al, %al
je 0x3f78
movq 0x54(%rbx), %rsi
movq 0x5c(%rbx), %rdx
movq %rbx, %rdi
callq 0x3f7c
testb %al, %al
je 0x3f78
movq 0x64(%rbx), %rsi
movq 0x6c(%rbx), %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x3f7c
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl %edx, %esi
setae %al
jae 0x3fd0
pushq %rbx
movq %rsi, %rcx
shrq $0x20, %rcx
movq %rdx, %r8
shrq $0x20, %r8
movq 0x10(%rdi), %rdi
movl %esi, %esi
movq (%rdi,%rsi,8), %r9
movb (%r9,%rcx), %r9b
movl %edx, %edx
movl %r8d, %r10d
subl %ecx, %r10d
cmpl %r8d, %ecx
jae 0x3fc4
movq (%rdi,%rsi,8), %r11
addq %rcx, %r11
xorl %ebx, %ebx
cmpb (%r11,%rbx), %r9b
jne 0x3fcf
incq %rbx
cmpl %ebx, %r10d
jne 0x3fb6
incq %rsi
cmpq %rdx, %rsi
setae %al
jne 0x3fa8
popq %rbx
andb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::turn(Turn)
void Cube::turn(Turn t) {
    switch (t.layer) {
        case Layer::F:
            rotateLayer(t.layer, t.clockwise);
            rotateEdges(Edges::UpFace, t.clockwise);
            break;
        case Layer::U:
            rotateLayer(t.layer, t.clockwise);
            rotateEdges(Edges::FaceUp, t.clockwise);
            break;
        case Layer::R:
            rotateLayer(t.layer, t.clockwise);
            rotateEdges(Edges::UpRight, t.clockwise);
            break;
        case Layer::D:
            rotateLayer(t.layer, t.clockwise);
            rotateEdges(Edges::FaceDown, t.clockwise);
            break;
        case Layer::L:
            rotateLayer(t.layer, t.clockwise);
            rotateEdges(Edges::UpLeft, t.clockwise);
            break;
        case Layer::B:
            rotateLayer(t.layer, t.clockwise);
            rotateEdges(Edges::UpBack, t.clockwise);
            break;
        case Layer::M:
            turn({Layer::R, t.clockwise});
            turn({Layer::L, !t.clockwise});
            break;
        case Layer::E:
            turn({Layer::U, t.clockwise});
            turn({Layer::D, !t.clockwise});
            break;
        case Layer::S:
            turn({Layer::F, !t.clockwise});
            turn({Layer::B, t.clockwise});
            break;
        case Layer::NOLAYER:
        default:
            break;
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movabsq $0x100000000, %r12      # imm = 0x100000000
leaq 0x6289(%rip), %r13      # 0xa2b0
leaq 0x4(%r12), %rax
movq %rax, 0x10(%rsp)
leaq 0x9(%r12), %rax
movq %rax, 0x8(%rsp)
leaq 0x5(%r12), %rbp
leal -0x1(%r15), %eax
cmpl $0xb, %eax
ja 0x416f
movq %r15, %r14
shrq $0x20, %r14
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
andq %r12, %r15
movq %r15, %rsi
orq $0x6, %rsi
movq %rbx, %rdi
callq 0x4002
xorq 0x10(%rsp), %r15
jmp 0x4040
andq %r12, %r15
movq %r15, %rsi
xorq %rbp, %rsi
movq %rbx, %rdi
callq 0x4002
orq $0x7, %r15
jmp 0x4040
andq %r12, %r15
movq %r15, %rsi
orq $0x1, %rsi
movq %rbx, %rdi
callq 0x4002
xorq 0x8(%rsp), %r15
jmp 0x4040
andl $0x1, %r14d
movq %rbx, %rdi
movl $0x9, %esi
movl %r14d, %edx
callq 0x417e
movq %rbx, %rdi
movl $0x10, %esi
jmp 0x4159
andl $0x1, %r14d
movq %rbx, %rdi
movl $0x7, %esi
movl %r14d, %edx
callq 0x417e
movq %rbx, %rdi
movl $0x14, %esi
jmp 0x4159
andl $0x1, %r14d
movq %rbx, %rdi
movl $0x5, %esi
movl %r14d, %edx
callq 0x417e
movq %rbx, %rdi
xorl %esi, %esi
jmp 0x4159
andl $0x1, %r14d
movq %rbx, %rdi
movl $0x1, %esi
movl %r14d, %edx
callq 0x417e
movq %rbx, %rdi
movl $0x4, %esi
jmp 0x4159
andl $0x1, %r14d
movq %rbx, %rdi
movl $0x4, %esi
movl %r14d, %edx
callq 0x417e
movq %rbx, %rdi
movl $0x8, %esi
jmp 0x4159
andl $0x1, %r14d
movq %rbx, %rdi
movl $0x6, %esi
movl %r14d, %edx
callq 0x417e
movq %rbx, %rdi
movl $0xc, %esi
movl %r14d, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x434c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::rotateEdges(Cube::Edges, bool)
void Cube::rotateEdges(Edges start, bool clockwise) {
    unsigned int index0 = start*cubeSize;
    unsigned int index1 = index0 + cubeSize;
    unsigned int index2 = index1 + cubeSize;
    unsigned int index3 = index2 + cubeSize;
   
    for (unsigned int i=0; i<cubeSize; i++)
        fourWayRotate({{edges[index0 + i].row, edges[index0 + i].col},
                       {edges[index1 + i].row, edges[index1 + i].col},
                       {edges[index2 + i].row, edges[index2 + i].col},
                       {edges[index3 + i].row, edges[index3 + i].col}},
                       clockwise);
}

// Assembly:
movl 0x8(%rdi), %eax
testq %rax, %rax
je 0x4452
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %eax, %ecx
imull %esi, %ecx
movq 0x10(%rdi), %r8
movq %r8, -0x20(%rsp)
movq 0x18(%rdi), %rdi
leal 0x3(%rsi), %r9d
imull %eax, %r9d
leal 0x2(%rsi), %r10d
imull %eax, %r10d
incl %esi
imull %eax, %esi
movl %edx, -0x24(%rsp)
movq %rax, -0x8(%rsp)
movl %ecx, %r11d
movl (%rdi,%r11,8), %ebp
movl 0x4(%rdi,%r11,8), %ebx
movl %esi, %r11d
movl (%rdi,%r11,8), %eax
movq %rax, -0x10(%rsp)
movl 0x4(%rdi,%r11,8), %eax
movq %rax, -0x18(%rsp)
movl %r10d, %r14d
movl (%rdi,%r14,8), %r12d
movl 0x4(%rdi,%r14,8), %r14d
movl %r9d, %r13d
movl (%rdi,%r13,8), %r8d
movl 0x4(%rdi,%r13,8), %r13d
testb %dl, %dl
movl %ebp, %r15d
cmovnel %r12d, %r15d
movq -0x20(%rsp), %rax
movq (%rax,%r8,8), %r8
movl %ebx, %edx
cmovnel %r14d, %edx
movb (%r8,%r13), %r11b
movb %r11b, -0x25(%rsp)
movq (%rax,%r15,8), %r15
movb (%r15,%rdx), %r11b
movb %r11b, (%r8,%r13)
cmovnel %ebp, %r12d
movq -0x10(%rsp), %r8
movq (%rax,%r8,8), %r8
movq -0x18(%rsp), %r13
movb (%r8,%r13), %r11b
movb %r11b, (%r15,%rdx)
cmovnel %ebx, %r14d
movq (%rax,%r12,8), %rdx
movq -0x8(%rsp), %rax
movb (%rdx,%r14), %r11b
movb %r11b, (%r8,%r13)
movb -0x25(%rsp), %r8b
movb %r8b, (%rdx,%r14)
movl -0x24(%rsp), %edx
incl %r9d
incl %r10d
incl %esi
incl %ecx
decq %rax
jne 0x438d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::initializeFaceEdges()
void Cube::getLayerUpperLeft(Coordinate& coord, Layer l) {
    /* Layers that are not (yet?) supported. */
    if (l == Layer::M || l == Layer::E || l == Layer::S)
        return;

    if (l == Layer::NOLAYER)
        return;

    coord.col = (l%LAYERS_PER_ROW)*cubeSize;
    if (l < LAYERS_PER_ROW)
        coord.row = 0;
    else if (l < LAYERS_PER_ROW*2)
        coord.row = cubeSize;
    else
        coord.row = cubeSize*2;
}

// Assembly:
movl 0x8(%rdi), %esi
movl 0x2c(%rdi), %r8d
xorl %r9d, %r9d
movl $0x5, %eax
xorl %edx, %edx
divl %r8d
leal (%r8,%r8), %eax
cmpl $0x6, %eax
setb %cl
movl %esi, %eax
shll %cl, %eax
cmpl $0x6, %r8d
cmovael %r9d, %eax
testl %esi, %esi
je 0x47c0
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
imull %edx, %esi
leal -0x1(%rax), %ecx
movq 0x18(%rdi), %rdx
leal -0x1(%rsi), %r8d
movl %eax, %r9d
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
xorl %r11d, %r11d
leal (%rsi,%r11), %ebx
movl %ecx, (%rdx,%r11,8)
movl %ebx, 0x4(%rdx,%r11,8)
leal (%r9,%r11), %ebx
movl 0x8(%rdi), %r14d
leal (%r11,%r14), %r15d
addl %esi, %r14d
movl %ebx, (%rdx,%r15,8)
movl %r14d, 0x4(%rdx,%r15,8)
movl 0x8(%rdi), %ebx
leal (%rbx,%rax), %ebp
movl %r11d, %r14d
notl %r14d
addl %esi, %r14d
addl %ebx, %r14d
leal (%r11,%rbx,2), %ebx
movl %ebp, (%rdx,%rbx,8)
movl %r14d, 0x4(%rdx,%rbx,8)
movl 0x8(%rdi), %ebx
leal (%r10,%r9), %ebp
addl %ebx, %ebp
leal (%rbx,%rbx,2), %ebx
addl %r11d, %ebx
movl %ebp, (%rdx,%rbx,8)
movl %r8d, 0x4(%rdx,%rbx,8)
incq %r11
movl 0x8(%rdi), %ebx
decq %r10
cmpq %rbx, %r11
jb 0x4752
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::fourWayRotate(Cube::Square, bool)
void Cube::fourWayRotate(Square square, bool clockwise) {
    CubieColor tmp = cube[square.ll.row][square.ll.col];
    if (clockwise) {
        cube[square.ll.row][square.ll.col] = cube[square.lr.row][square.lr.col];
        cube[square.lr.row][square.lr.col] = cube[square.ur.row][square.ur.col];
        cube[square.ur.row][square.ur.col] = cube[square.ul.row][square.ul.col];
        cube[square.ul.row][square.ul.col] = tmp;
    } else {
        cube[square.ll.row][square.ll.col] = cube[square.ul.row][square.ul.col];
        cube[square.ul.row][square.ul.col] = cube[square.ur.row][square.ur.col];
        cube[square.ur.row][square.ur.col] = cube[square.lr.row][square.lr.col];
        cube[square.lr.row][square.lr.col] = tmp;
    }
}

// Assembly:
leaq 0x8(%rsp), %rax
movq 0x10(%rdi), %rcx
movl 0x18(%rax), %edx
movl 0x1c(%rax), %edi
movq (%rcx,%rdx,8), %r8
movb (%r8,%rdi), %dl
testl %esi, %esi
je 0x44de
movl 0x10(%rax), %esi
movl 0x14(%rax), %r9d
movq (%rcx,%rsi,8), %r10
movb (%r10,%r9), %sil
movb %sil, (%r8,%rdi)
movl 0x8(%rax), %esi
movl 0xc(%rax), %edi
movq (%rcx,%rsi,8), %r8
leaq (%r8,%rdi), %rsi
movb (%r8,%rdi), %dil
movb %dil, (%r10,%r9)
movl $0x4, %edi
movq %rax, %r8
jmp 0x450f
movl (%rax), %esi
movl 0x4(%rax), %r9d
movq (%rcx,%rsi,8), %r10
movb (%r10,%r9), %sil
movb %sil, (%r8,%rdi)
movl 0x8(%rax), %esi
movl 0xc(%rax), %edi
movq (%rcx,%rsi,8), %r8
leaq (%r8,%rdi), %rsi
movb (%r8,%rdi), %dil
movb %dil, (%r10,%r9)
leaq 0x10(%rax), %r8
movl $0x14, %edi
movl (%r8), %r8d
movq (%rcx,%r8,8), %rcx
movl (%rax,%rdi), %eax
movb (%rcx,%rax), %dil
movb %dil, (%rsi)
movb %dl, (%rcx,%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::initializeEdges()
void Cube::initializeEdges() {
    edges = new Coordinate[NUM_EDGE_TYPES*cubeSize];

    initializeFaceEdges();
    initializeUpEdges();
    initializeLeftEdges();
    initializeRightEdges();
    initializeDownEdges();
    initializeBackEdges();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %edi
imull 0x30(%rbx), %edi
shlq $0x3, %rdi
callq 0x2030
movq %rax, 0x18(%rbx)
movq %rbx, %rdi
callq 0x4700
movq %rbx, %rdi
callq 0x47c2
movq %rbx, %rdi
callq 0x4840
movq %rbx, %rdi
callq 0x48de
movq %rbx, %rdi
callq 0x49a6
movq %rbx, %rdi
popq %rbx
jmp 0x4a58
nop
// File: /workspace/github_cpp_makefile_star2_O1/chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::initializeLayer(Layer, CubieColor)
void Cube::initializeLayer(Layer layer, CubieColor color) {
    /**
     * We have to set this to a throw-away value because -Ofast optimization
     * causes an unassigned variable to emit -Werror=maybe-uninitialized. This
     * warning cannot be squelched when using LLVM because of LLVM bug
     * https://bugs.llvm.org/show_bug.cgi?id=24979
     */
    Coordinate ul = {Layer::U, true};
    getLayerUpperLeft(ul, layer);

    for (unsigned int r = ul.row; r < (ul.row + cubeSize); r++)
        for (unsigned int c = ul.col; c < (ul.col + cubeSize); c++)
            cube[r][c] = color;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r8d
leal -0xa(%rsi), %eax
movl $0x1, %ebx
movl $0x1, %ecx
cmpl $0x4, %eax
jb 0x469c
movl 0x8(%rdi), %r9d
movl 0x2c(%rdi), %r10d
xorl %ecx, %ecx
movl %esi, %eax
xorl %edx, %edx
divl %r10d
movl %edx, %ebx
imull %r9d, %ebx
cmpl %esi, %r10d
ja 0x469c
addl %r10d, %r10d
cmpl %esi, %r10d
setbe %cl
shll %cl, %r9d
movl %r9d, %ecx
movl 0x8(%rdi), %r14d
leal (%r14,%rcx), %eax
cmpl %eax, %ecx
jae 0x46f1
leal (%r14,%rbx), %r15d
movq 0x10(%rdi), %rdx
movq %rdx, 0x10(%rsp)
movl %ebx, %edx
movq %rdx, 0x8(%rsp)
decl %r14d
incq %r14
movl %ecx, %r12d
movl %eax, %r13d
movzbl %r8b, %ebp
cmpl %r15d, %ebx
jae 0x46e9
movq 0x10(%rsp), %rax
movq (%rax,%r12,8), %rdi
addq 0x8(%rsp), %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x2070
incq %r12
cmpq %r12, %r13
jne 0x46cc
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chuckwolber[P]Cube/test/test_algorithm.cpp
// Function: main
int main() {
    test_constructors();
    test_inequalities();
    test_sequences();
    test_skip();
    test_addTurn();
    test_setAlgorithm();
    test_inversions();
    test_hidden_inversions();
    test_triples();
    test_hidden_triples();
    test_string();

    return 0;
}

// Assembly:
pushq %rax
callq 0x4c58
callq 0x5315
callq 0x539f
callq 0x59ab
callq 0x5c60
callq 0x60b3
callq 0x63a2
callq 0x6bfb
callq 0x70f8
callq 0x7521
callq 0x8925
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/chuckwolber[P]Cube/test/test_algorithm.cpp
// Function: verify_turns(std::vector<Turn, std::allocator<Turn>>, std::vector<Turn, std::allocator<Turn>>)
void verify_turns(std::vector<Turn> results, std::vector<Turn> expected) {
    assert(results.size() == expected.size());
    for (unsigned int i = 0; i < expected.size(); i++) {
        assert(expected.at(i).layer     == results.at(i).layer);
        assert(expected.at(i).clockwise == results.at(i).clockwise);
    }
}

// Assembly:
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movq (%rsi), %rcx
movq 0x8(%rsi), %rsi
movq %rsi, %rdi
subq %rcx, %rdi
sarq $0x3, %rdi
cmpq %rdi, %rdx
jne 0x8bcb
cmpq %rcx, %rsi
je 0x8b7d
movl $0x1, %r8d
xorl %esi, %esi
cmpq %rsi, %rdx
jbe 0x8bbd
movl (%rcx,%rsi,8), %r9d
cmpl (%rax,%rsi,8), %r9d
jne 0x8b9e
movb 0x4(%rcx,%rsi,8), %r9b
cmpb 0x4(%rax,%rsi,8), %r9b
jne 0x8b7f
movl %r8d, %esi
incl %r8d
cmpq %rsi, %rdi
ja 0x8b57
popq %rax
retq
leaq 0x1e17(%rip), %rdi      # 0xa99d
leaq 0x1790(%rip), %rsi      # 0xa31d
leaq 0x1da5(%rip), %rcx      # 0xa939
movl $0x244, %edx            # imm = 0x244
callq 0x2090
leaq 0x1dcc(%rip), %rdi      # 0xa971
leaq 0x1771(%rip), %rsi      # 0xa31d
leaq 0x1d86(%rip), %rcx      # 0xa939
movl $0x243, %edx            # imm = 0x243
callq 0x2090
leaq 0x1644(%rip), %rdi      # 0xa208
xorl %eax, %eax
callq 0x2170
leaq 0x1d45(%rip), %rdi      # 0xa917
leaq 0x1744(%rip), %rsi      # 0xa31d
leaq 0x1d59(%rip), %rcx      # 0xa939
movl $0x241, %edx            # imm = 0x241
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk-extras/exprtk_vector_resize_inline_example.cpp
// Function: my_vv_size_handler_t<double>::operator()(exprtk::type_store<double>::parameter_list)
inline T operator()(parameter_list_t parameters) override
   {
      vector_t vector(parameters[0]);
      size_t   new_size = static_cast<std::size_t>(scalar_t(parameters[1])());
      void*    key      = static_cast<void*>(&vector[0]);

      typename map_t::iterator itr = vector_map_.find(key);

      if (itr == vector_map_.end())
      {
         printf("my_vv_size_handler - Error: failed to find vector_view for address: %p\n",key);
         return T(0);
      }

      exprtk::vector_view<T>& vv = *itr->second;

      if (vv.base_size() < new_size)
      {
         printf("my_vv_size_handler - Error: vector_view for address: %p new size of %d greater than base_size of %d\n",
                key,
                static_cast<unsigned int>(new_size),
                static_cast<unsigned int>(vv.base_size()));
         return T(0);
      }

      return vv.set_size(new_size) ? T(1) : T(0);
   }

// Assembly:
pushq %rax
movq (%rsi), %rax
movq (%rax), %rsi
movq 0x58(%rdi), %rdx
addq $0x50, %rdi
movq %rdi, %rcx
testq %rdx, %rdx
je 0x11bf4d
movq %rdi, %rcx
xorl %r8d, %r8d
cmpq %rsi, 0x20(%rdx)
setb %r8b
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%r8,8), %rdx
testq %rdx, %rdx
jne 0x11bf34
movq %rdi, %r8
cmpq %rdi, %rcx
je 0x11bf60
cmpq 0x20(%rcx), %rsi
cmovbq %rdi, %rcx
movq %rcx, %r8
cmpq %rdi, %r8
je 0x11bfa8
movq 0x18(%rax), %rax
movsd (%rax), %xmm0
cvttsd2si %xmm0, %rax
subsd 0x1aa11e(%rip), %xmm0   # 0x2c6098
movq %rax, %rcx
sarq $0x3f, %rcx
cvttsd2si %xmm0, %rdx
andq %rcx, %rdx
orq %rax, %rdx
movq 0x28(%r8), %rax
movq (%rax), %rcx
cmpq %rdx, %rcx
jae 0x11bfbc
leaq 0x1aed33(%rip), %rdi    # 0x2cacd2
xorl %eax, %eax
callq 0x116050
jmp 0x11bfb6
leaq 0x1aecdb(%rip), %rdi    # 0x2cac8a
xorl %eax, %eax
callq 0x116050
xorpd %xmm0, %xmm0
popq %rax
retq
leaq -0x1(%rdx), %rsi
xorpd %xmm0, %xmm0
cmpq %rcx, %rsi
jae 0x11bfba
movq %rdx, 0x8(%rax)
movsd 0x1aa0cb(%rip), %xmm0   # 0x2c60a0
jmp 0x11bfba
nop
// File: /workspace/github_cpp_makefile_star2_O1/FreeSlave[P]vhlt/ripent/ripent.cpp
// Function: ScanForToken(char, int&, int&, bool, bool, int*)
bool ScanForToken(char cToken, int &iIndex, int &iLine, bool bIgnoreWhiteSpace, bool bIgnoreOthers, int *iToken = 0)
{
	for(; iIndex < g_entdatasize; iIndex++)
	{
		// If we found a null char, consider it end of data.
		if(g_dentdata[iIndex] == '\0')
		{
			iIndex = g_entdatasize;
			return false;
		}

		// Count lines (for error message).
		if(g_dentdata[iIndex] == '\n')
		{
			iLine++;
		}

		// Ignore white space, if we are ignoring it.
		if(!bIgnoreWhiteSpace && isspace(g_dentdata[iIndex]))
		{
			continue;
		}

		if(g_dentdata[iIndex] != cToken)
		{
			if(bIgnoreOthers)
				continue;
			else
				return false;
		}

		// Advance the index past the token.
		iIndex++;

		// Return the index of the token if requested.
		if(iToken != 0)
		{
			*iToken = iIndex - 1;
		}

		return true;
	}

	// End of data.
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r15d
movq %rdx, 0x10(%rsp)
movl (%rsi), %ecx
leaq 0x813931(%rip), %rbx    # 0x820324
movl (%rbx), %eax
cmpl %eax, %ecx
jge 0xca75
movl %r8d, %ebp
movq %rsi, %r14
movl %edi, %r13d
movq %r9, 0x8(%rsp)
leaq 0x813922(%rip), %r12    # 0x820330
movslq %ecx, %rcx
movzbl (%r12,%rcx), %ecx
cmpl $0xa, %ecx
je 0xca21
testl %ecx, %ecx
jne 0xca28
jmp 0xca72
movq 0x10(%rsp), %rax
incl (%rax)
testb %r15b, %r15b
jne 0xca3e
movslq (%r14), %rax
movsbl (%r12,%rax), %edi
callq 0x3080
testl %eax, %eax
jne 0xca4c
movslq (%r14), %rcx
cmpb %r13b, (%r12,%rcx)
je 0xca5c
testb %bpl, %bpl
je 0xca75
movl (%r14), %ecx
incl %ecx
movl %ecx, (%r14)
movl (%rbx), %eax
cmpl %eax, %ecx
jl 0xca0e
jmp 0xca75
leal 0x1(%rcx), %eax
movl %eax, (%r14)
movb $0x1, %al
movq 0x8(%rsp), %rdx
testq %rdx, %rdx
je 0xca77
movl %ecx, (%rdx)
jmp 0xca77
movl %eax, (%r14)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/FreeSlave[P]vhlt/ripent/ripent.cpp
// Function: Usage()
static void     Usage(void)
{
    //Log("%s " ZHLT_VERSIONSTRING "\n" MODIFICATIONS_STRING "\n", g_Program);
    //Log("  Usage: ripent [-import|-export] [-texdata n] bspname\n");

	// Modified to behave like other tools by Nem.

	Banner();
	Log("\n-= %s Options =-\n\n", g_Program);

#ifdef ZHLT_CONSOLE
	Log("    -console #      : Set to 0 to turn off the pop-up console (default is 1)\n");
#endif
#ifdef ZHLT_LANGFILE
	Log("    -lang file      : localization file\n");
#endif
	Log("    -export         : Export entity data\n");
	Log("    -import         : Import entity data\n\n");

	Log("    -parse          : Parse and format entity data\n\n");
#ifdef RIPENT_TEXTURE
	Log("    -textureexport  : Export texture data\n");
	Log("    -textureimport  : Import texture data\n");
	Log("    -textureparse   : Parse and format texture data\n\n");
#endif
#ifdef ZHLT_64BIT_FIX
	Log("    -writeextentfile : Create extent file for the map\n");
#endif
#ifdef ZHLT_EMBEDLIGHTMAP
#ifdef RIPENT_TEXTURE
	Log("    -deleteembeddedlightmaps : Delete textures created by hlrad\n");
#endif
#endif

    Log("    -texdata #      : Alter maximum texture memory limit (in kb)\n");
    Log("    -lightdata #    : Alter maximum lighting memory limit (in kb)\n");
	Log("    -chart          : Display bsp statitics\n");
	Log("    -noinfo         : Do not show tool configuration information\n\n");
#ifdef RIPENT_PAUSE
	Log("    -pause          : Pause before exit\n\n");
#endif

	Log("    mapfile         : The mapfile to process\n\n");

    exit(1);
}

// Assembly:
pushq %rax
callq 0x93aa
leaq 0x8dd3(%rip), %rax      # 0x172a0
movq (%rax), %rsi
leaq 0x421b(%rip), %rdi      # 0x126f2
xorl %eax, %eax
callq 0x8aee
leaq 0x4221(%rip), %rdi      # 0x12706
xorl %eax, %eax
callq 0x8aee
leaq 0x4261(%rip), %rdi      # 0x12754
xorl %eax, %eax
callq 0x8aee
leaq 0x427c(%rip), %rdi      # 0x1277d
xorl %eax, %eax
callq 0x8aee
leaq 0x4298(%rip), %rdi      # 0x127a7
xorl %eax, %eax
callq 0x8aee
leaq 0x42b5(%rip), %rdi      # 0x127d2
xorl %eax, %eax
callq 0x8aee
leaq 0x42dc(%rip), %rdi      # 0x12807
xorl %eax, %eax
callq 0x8aee
leaq 0x42f9(%rip), %rdi      # 0x12832
xorl %eax, %eax
callq 0x8aee
leaq 0x4316(%rip), %rdi      # 0x1285d
xorl %eax, %eax
callq 0x8aee
leaq 0x433e(%rip), %rdi      # 0x12893
xorl %eax, %eax
callq 0x8aee
leaq 0x4367(%rip), %rdi      # 0x128ca
xorl %eax, %eax
callq 0x8aee
leaq 0x439a(%rip), %rdi      # 0x1290b
xorl %eax, %eax
callq 0x8aee
leaq 0x43ce(%rip), %rdi      # 0x1294d
xorl %eax, %eax
callq 0x8aee
leaq 0x4403(%rip), %rdi      # 0x12990
xorl %eax, %eax
callq 0x8aee
leaq 0x4422(%rip), %rdi      # 0x129bd
xorl %eax, %eax
callq 0x8aee
leaq 0x4457(%rip), %rdi      # 0x12a00
xorl %eax, %eax
callq 0x8aee
movl $0x1, %edi
callq 0x3310