LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/FFY00[P]uicc/include/uicc.h
// Function: UICC::verifyChv(char, char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool verifyChv(char cla, char chv, string pwd) {
        string order;
        order+=cla;
        order+=string(u8"\x20\x00",2);
        order+=chv;
        order+=(char)8;
        order+=pwd;

        for (int i=pwd.size(); i<8 ; i++)
            order+='\xff';

        string answer (u8"\x90\x00",2);
        return send_check(order, answer);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r15
movl %edx, %r12d
movq %rdi, %r14
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq -0x68(%rbp), %rdi
callq 0x2200
leaq -0x38(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movw $0x20, (%rbx)
movq $0x2, -0x8(%rbx)
movb $0x0, 0x2(%rbx)
leaq -0x68(%rbp), %rdi
movl $0x2, %edx
movq %rbx, %rsi
callq 0x20d0
movq -0x48(%rbp), %rdi
cmpq %rbx, %rdi
je 0x13745
callq 0x2220
movsbl %r12b, %esi
leaq -0x68(%rbp), %rdi
callq 0x2200
leaq -0x68(%rbp), %rdi
movl $0x8, %esi
callq 0x2200
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq -0x68(%rbp), %rdi
callq 0x20d0
movl 0x8(%r15), %r12d
cmpl $0x7, %r12d
jg 0x13794
addl $-0x8, %r12d
leaq -0x68(%rbp), %r15
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x2200
incl %r12d
jne 0x13782
movq %rbx, -0x48(%rbp)
movw $0x90, -0x38(%rbp)
movq $0x2, -0x40(%rbp)
movb $0x0, -0x36(%rbp)
leaq -0x98(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
addq %rsi, %rdx
leaq -0xa8(%rbp), %rdi
callq 0x1394e
leaq -0x78(%rbp), %r12
movq %r12, -0x10(%r12)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %rdi
callq 0x1394e
leaq -0xa8(%rbp), %rsi
leaq -0x88(%rbp), %rdx
movq %r14, %rdi
callq 0xeb32
movl %eax, %r14d
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0x13816
callq 0x2220
movq -0xa8(%rbp), %rdi
cmpq %r15, %rdi
je 0x13827
callq 0x2220
movq -0x48(%rbp), %rdi
cmpq %rbx, %rdi
je 0x13835
callq 0x2220
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x13843
callq 0x2220
movl %r14d, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0x13871
callq 0x2220
jmp 0x13871
movq %rax, %r14
movq -0xa8(%rbp), %rdi
cmpq %r15, %rdi
je 0x13889
callq 0x2220
jmp 0x13889
jmp 0x13886
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %rbx, %rdi
je 0x1389e
callq 0x2220
jmp 0x1389e
jmp 0x1389b
movq %rax, %r14
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x138ac
callq 0x2220
movq %r14, %rdi
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O3/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 0x29e8
testb %al, %al
je 0x267a
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x25fb
movq %rax, 0x8(%rbx)
movb (%r14), %r12b
testb %r12b, %r12b
je 0x267a
incq %r14
xorl %r15d, %r15d
movsbl %r12b, %edi
callq 0x2a40
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
testq %r15, %r15
je 0x267a
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
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x26aa
movq %rsi, %r14
movq %rbx, %rdi
callq 0x33ca
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_O3/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 0x27e7
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %r9
movq 0x8(%rdi), %rsi
movl $0x1, %r13d
movq %rsp, %r14
movabsq $-0x5555555555555555, %rbp # imm = 0xAAAAAAAAAAAAAAAB
xorl %r15d, %r15d
movq %rsi, %rax
subq %r9, %rax
sarq $0x3, %rax
movl %r13d, %ecx
cmpq %rcx, %rax
jae 0x274d
movq $0x0, (%rsp)
cmpq 0x10(%rbx), %rsi
je 0x2736
movq $0x0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2741
movq %rbx, %rdi
movq %r14, %rdx
callq 0x356e
testq %r12, %r12
je 0x27d3
decq %r12
movq %r12, %rcx
leal -0x1(%r13), %eax
movl %eax, %r8d
movq (%rbx), %r9
movq 0x8(%rbx), %rsi
movq %rsi, %rdx
subq %r9, %rdx
sarq $0x3, %rdx
cmpq %r8, %rdx
jbe 0x27f6
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 (%r9,%r8,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, (%r9,%r8,8)
incl %r13d
cmpq $0xb, %rcx
ja 0x2705
cmpq $0xb, %rdi
ja 0x2705
jmp 0x27e7
subq $0x1, %r15
movl $0x0, %eax
cmovbq %rax, %r15
xorl %ecx, %ecx
jmp 0x2750
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6a0b(%rip), %rdi      # 0x9208
movq %r8, %rsi
xorl %eax, %eax
callq 0x2170
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
movq (%rsi), %rdi
movq 0x8(%rsi), %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %rax, %rdx
jbe 0x28fc
xorl %eax, %eax
jmp 0x2926
movb $0x1, %al
jb 0x2926
leaq -0x1(%rdx), %rsi
leaq 0x1(%rsi), %rax
testq %rax, %rax
jle 0x28f8
cmpq %rsi, %rdx
jbe 0x2928
movq (%rdi,%rsi,8), %rax
leaq -0x1(%rsi), %r8
cmpq %rax, (%rcx,%rsi,8)
movq %r8, %rsi
je 0x2904
setb %al
popq %rcx
retq
leaq 0x68d9(%rip), %rdi      # 0x9208
xorl %eax, %eax
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2a34
movq %rdi, %r14
movb (%rdi), %al
movb $0x1, %bl
testb %al, %al
je 0x2a36
incq %r14
xorl %ecx, %ecx
testb $0x1, %cl
je 0x2a19
cmpb $0x27, %al
je 0x2a12
movzbl %al, %ecx
cmpl $0x20, %ecx
jne 0x2a34
cmpb $0x20, %al
setne %cl
jmp 0x2a28
movsbl %al, %edi
callq 0x2a40
movb $0x1, %cl
cmpl $0xd, %eax
je 0x2a34
movb (%r14), %al
incq %r14
testb %al, %al
jne 0x2a01
jmp 0x2a36
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6f1a(%rip), %rdx      # 0x99e3
movq %rdx, %rsi
callq 0x368e
movq 0x8(%r14), %rbp
subq (%r14), %rbp
je 0x2bb5
sarq $0x3, %rbp
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
leaq 0x6515(%rip), %r15      # 0x9008
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 0x2b78
movb $0x1, %r12b
movl $0x7, %edi
jmp 0x2b78
movl $0x6, %edi
jmp 0x2b75
movb $0x1, %r12b
movl $0x4, %edi
jmp 0x2b78
movl $0x1, %edi
jmp 0x2b75
movb $0x1, %r12b
movl $0x1, %edi
jmp 0x2b78
movb $0x1, %r12b
movl $0x9, %edi
jmp 0x2b78
movb $0x1, %r12b
movl $0x6, %edi
jmp 0x2b78
movl $0x9, %edi
jmp 0x2b75
movl $0x7, %edi
jmp 0x2b75
movl $0x4, %edi
xorl %r12d, %r12d
callq 0x2c1e
movsbl %al, %esi
movq %rbx, %rdi
callq 0x20e0
testb %r12b, %r12b
je 0x2b9c
movq %rbx, %rdi
leaq 0x6982(%rip), %rsi      # 0x9519
callq 0x21c0
decq %rbp
je 0x2bb5
movq %rbx, %rdi
leaq 0x6e37(%rip), %rsi      # 0x99e2
callq 0x21c0
jmp 0x2af3
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 0x2be2
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2120
movq %r14, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2cb2
movq %rsi, %r14
sarq $0x3, %r12
leaq 0x6451(%rip), %rbp      # 0x90b8
leaq 0x64aa(%rip), %r13      # 0x9118
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 0x3724
decq %r12
jne 0x2c71
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 0x2cdb
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2120
movq %r14, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2d16
testb %al, %al
jne 0x2d09
movq %rbx, %rdi
callq 0x2d86
testb %al, %al
jne 0x2d09
movq %rbx, %rdi
callq 0x2efa
testb %al, %al
je 0x2d0d
movb $0x1, %al
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x2f6a
// File: /workspace/github_cpp_makefile_star2_O3/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), %rax
movq 0x8(%rdi), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq $0x2, %rdx
jb 0x2d70
movq %rdx, %rcx
decq %rcx
je 0x2d70
movl $0x1, %r8d
xorl %esi, %esi
movq (%rax,%rsi,8), %rdi
movl %r8d, %esi
testb $0x1, %dil
jne 0x2d56
cmpq %rsi, %rdx
jbe 0x2d78
movq (%rax,%rsi,8), %r8
decq %r8
jmp 0x2d62
cmpq %rsi, %rdx
jbe 0x2d78
movq (%rax,%rsi,8), %r8
incq %r8
cmpq %r8, %rdi
je 0x2d74
leal 0x1(%rsi), %r8d
cmpq %rsi, %rcx
ja 0x2d3b
xorl %eax, %eax
popq %rcx
retq
movb $0x1, %al
jmp 0x2d72
leaq 0x6489(%rip), %rdi      # 0x9208
xorl %eax, %eax
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O3/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), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq $0x3, %rdx
jb 0x2f47
leaq -0x3(%rdx), %rdi
movl $0x1, %r8d
xorl %eax, %eax
movl %r8d, %esi
cmpq %rsi, %rdx
jbe 0x2f4f
movq (%rcx,%rax,8), %r8
cmpq (%rcx,%rsi,8), %r8
jne 0x2f3b
leal 0x1(%rsi), %eax
cmpq %rax, %rdx
jbe 0x2f58
cmpq (%rcx,%rax,8), %r8
je 0x2f4b
leal 0x1(%rsi), %r8d
movq %rsi, %rax
cmpq %rsi, %rdi
jae 0x2f1b
xorl %eax, %eax
popq %rcx
retq
movb $0x1, %al
jmp 0x2f49
leaq 0x62b2(%rip), %rdi      # 0x9208
jmp 0x2f62
leaq 0x62a9(%rip), %rdi      # 0x9208
movq %rax, %rsi
xorl %eax, %eax
callq 0x2170
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x391e
movl 0x2c(%rbx), %r15d
imull %r14d, %r15d
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x2030
movq 0x10(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
incq %r13
cmpq %r13, %r12
jne 0x38d7
testq %r12, %r12
je 0x391e
imull 0x2c(%rbx), %r14d
movq 0x10(%rbx), %r15
xorl %r13d, %r13d
testq %r14, %r14
je 0x3916
movq (%r15,%r13,8), %rdi
movl $0x20, %esi
movq %r14, %rdx
callq 0x2070
incq %r13
cmpq %r13, %r12
jne 0x3900
movq %rbx, %rdi
callq 0x42cc
movq %rbx, %rdi
callq 0x43b0
movl 0x8(%rbx), %esi
movl 0x2c(%rbx), %r8d
xorl %edi, %edi
movl $0x5, %eax
xorl %edx, %edx
divl %r8d
imull %esi, %edx
leal (%r8,%r8), %r9d
cmpl $0x6, %r9d
setb %cl
movl %esi, %eax
shll %cl, %eax
cmpl $0x6, %r8d
cmovael %edi, %eax
movl %edx, 0x38(%rbx)
movl %eax, 0x34(%rbx)
addl %esi, %eax
addl %esi, %edx
cmpl $0x1, %r8d
movl %esi, %r10d
cmovel %edi, %r10d
movl %eax, 0x3c(%rbx)
testl %r9d, %r9d
sete %cl
movl %esi, %eax
shll %cl, %eax
movl %edx, 0x40(%rbx)
cmpl $0x2, %r8d
cmovael %edi, %eax
movl %r10d, 0x48(%rbx)
movl %eax, 0x44(%rbx)
addl %esi, %eax
movl %eax, 0x4c(%rbx)
addl %esi, %r10d
movl %r10d, 0x50(%rbx)
movl $0x4, %eax
xorl %edx, %edx
divl %r8d
imull %esi, %edx
movl %edx, 0x58(%rbx)
cmpl $0x5, %r9d
setb %cl
movl %esi, %eax
shll %cl, %eax
cmpl $0x5, %r8d
cmovael %edi, %eax
movl %eax, 0x54(%rbx)
addl %esi, %eax
movl %eax, 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 $0x7, %r9d
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
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5843(%rip), %xmm0     # 0x92a0
movups %xmm0, 0x20(%rdi)
movl $0x18, 0x30(%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movb (%rsi), %al
movb %al, (%rdi)
callq 0x389e
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3a8a
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3b8e
movq %rsi, %r14
movq %rbx, %rdi
callq 0x3b9a
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
movb (%r14), %al
movb %al, (%rbx)
movq %rbx, %rdi
callq 0x389e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3a8a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x3bf7
movl 0x8(%rbx), %eax
movl 0x28(%rbx), %ecx
movl %eax, %edx
imull %ecx, %edx
testl %edx, %edx
je 0x3bea
xorl %r14d, %r14d
movq 0x10(%rbx), %rdx
movq (%rdx,%r14,8), %rdi
testq %rdi, %rdi
je 0x3bd4
callq 0x2160
movl 0x8(%rbx), %eax
movl 0x28(%rbx), %ecx
incq %r14
movl %eax, %edx
imull %ecx, %edx
cmpq %rdx, %r14
jb 0x3bbc
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x3bef
callq 0x2160
movq $0x0, 0x10(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x3c0d
callq 0x2160
movq $0x0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3c40
movq %rsi, %r14
movq %rbx, %rdi
callq 0x3b9a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3af8
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_O3/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 0x3ca2
movl 0x28(%rdi), %r8d
imull %ecx, %r8d
movb $0x1, %al
testl %r8d, %r8d
je 0x3ca4
pushq %rbx
imull 0x2c(%rdi), %ecx
movq 0x10(%rdi), %rdx
movq 0x10(%rsi), %rsi
movl %r8d, %edi
xorl %r8d, %r8d
testq %rcx, %rcx
je 0x3c98
movq (%rdx,%r8,8), %r9
movq (%rsi,%r8,8), %r10
xorl %r11d, %r11d
movb (%r9,%r11), %bl
cmpb (%r10,%r11), %bl
jne 0x3ca5
incq %r11
cmpq %r11, %rcx
jne 0x3c86
incq %r8
cmpq %rdi, %r8
jne 0x3c76
jmp 0x3ca7
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl 0x28(%rsi), %edx
movl %eax, %ecx
imull %edx, %ecx
testl %ecx, %ecx
je 0x3d4b
movq %rsi, %r14
movl 0x2c(%rsi), %ecx
xorl %r15d, %r15d
movl %eax, %esi
imull %ecx, %esi
testl %esi, %esi
je 0x3d3e
xorl %r12d, %r12d
movq 0x10(%r14), %rdx
movq (%rdx,%r15,8), %rdx
addq %r12, %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3d1d
movb (%rdx), %dl
movb %dl, (%rsi)
incq %rsi
movq %rsi, 0x8(%rbx)
jmp 0x3d2d
movq %rbx, %rdi
callq 0x48d4
movl 0x8(%r14), %eax
movl 0x2c(%r14), %ecx
incq %r12
movl %eax, %edx
imull %ecx, %edx
cmpq %rdx, %r12
jb 0x3cfb
movl 0x28(%r14), %edx
incq %r15
movl %eax, %esi
imull %edx, %esi
cmpq %rsi, %r15
jb 0x3cef
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 0x3d71
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2120
movq %r14, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3de4
testb %al, %al
je 0x3de0
movq 0x44(%rbx), %rsi
movq 0x4c(%rbx), %rdx
movq %rbx, %rdi
callq 0x3de4
testb %al, %al
je 0x3de0
movq 0x54(%rbx), %rsi
movq 0x5c(%rbx), %rdx
movq %rbx, %rdi
callq 0x3de4
testb %al, %al
je 0x3de0
movq 0x64(%rbx), %rsi
movq 0x6c(%rbx), %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x3de4
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movb $0x1, %al
cmpl %edx, %esi
jae 0x3e45
pushq %r14
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
xorl %r11d, %r11d
cmpl %r8d, %ecx
jae 0x3e31
movq (%rdi,%rsi,8), %rbx
addq %rcx, %rbx
xorl %r14d, %r14d
cmpb (%rbx,%r14), %r9b
jne 0x3e3f
incq %r14
cmpl %r14d, %r10d
jne 0x3e23
incq %rsi
cmpq %rdx, %rsi
setae %r11b
jne 0x3e14
jmp 0x3e42
movl %r11d, %eax
popq %rbx
popq %r14
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movabsq $0x100000000, %r12      # imm = 0x100000000
leaq 0x5418(%rip), %r15      # 0x92b0
leaq 0x4(%r12), %rax
movq %rax, (%rsp)
leaq 0x9(%r12), %rbp
leaq 0x5(%r12), %r13
leal -0x1(%r14), %eax
cmpl $0xb, %eax
ja 0x3f5f
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
andq %r12, %r14
movq %r14, %rsi
orq $0x6, %rsi
movq %rbx, %rdi
callq 0x3e76
xorq (%rsp), %r14
jmp 0x3eab
andq %r12, %r14
movq %r14, %rsi
xorq %r13, %rsi
movq %rbx, %rdi
callq 0x3e76
orq $0x7, %r14
jmp 0x3eab
andq %r12, %r14
movq %r14, %rsi
orq $0x1, %rsi
movq %rbx, %rdi
callq 0x3e76
xorq %rbp, %r14
jmp 0x3eab
movl $0x10, %ebp
jmp 0x3f2c
movl $0x14, %ebp
jmp 0x3f2c
xorl %ebp, %ebp
jmp 0x3f2c
movl $0x4, %ebp
jmp 0x3f2c
movl $0x8, %ebp
jmp 0x3f2c
movl $0xc, %ebp
xorl %r15d, %r15d
testq %r12, %r14
setne %r15b
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x3f6e
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4144
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
testl %eax, %eax
je 0x41fb
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl %eax, %ecx
imull %esi, %ecx
leal 0x3(%rbx), %esi
imull %eax, %esi
movq %rsi, 0x28(%rsp)
leal 0x2(%rbx), %r12d
imull %eax, %r12d
incl %ebx
imull %eax, %ebx
movl %ecx, %r13d
xorl %r15d, %r15d
movzbl %dl, %ebp
movq 0x18(%r14), %rax
leal (%r15,%r13), %ecx
leal (%rbx,%r15), %edx
movsd (%rax,%rdx,8), %xmm0
movsd (%rax,%rcx,8), %xmm1
movlhps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movaps %xmm1, 0x30(%rsp)
leal (%r12,%r15), %ecx
movq 0x28(%rsp), %rdx
addl %r15d, %edx
movsd (%rax,%rdx,8), %xmm0
movsd (%rax,%rcx,8), %xmm1
movlhps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movaps %xmm1, 0x40(%rsp)
movaps 0x30(%rsp), %xmm0
movaps 0x40(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
callq 0x4238
incq %r15
movl 0x8(%r14), %eax
cmpq %rax, %r15
jb 0x4188
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x456d
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
xorl %r10d, %r10d
movl %ecx, %r11d
leal (%rsi,%r10), %ebx
movl %ecx, (%rdx,%r10,8)
movl %ebx, 0x4(%rdx,%r10,8)
leal (%r9,%r10), %ebx
movl 0x8(%rdi), %r14d
leal (%r10,%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 %r10d, %r14d
notl %r14d
addl %esi, %r14d
addl %ebx, %r14d
leal (%r10,%rbx,2), %ebx
movl %ebp, (%rdx,%rbx,8)
movl %r14d, 0x4(%rdx,%rbx,8)
movl 0x8(%rdi), %ebx
leal (%r11,%rbx), %ebp
leal (%rbx,%rbx,2), %ebx
addl %r10d, %ebx
movl %ebp, (%rdx,%rbx,8)
movl %r8d, 0x4(%rdx,%rbx,8)
incq %r10
movl 0x8(%rdi), %ebx
decl %r11d
cmpq %rbx, %r10
jb 0x4501
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x44b2
movq %rbx, %rdi
callq 0x456e
movq %rbx, %rdi
callq 0x45ec
movq %rbx, %rdi
callq 0x468a
movq %rbx, %rdi
callq 0x4752
movq %rbx, %rdi
popq %rbx
jmp 0x4804
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
cmpl $0x3, %eax
ja 0x4424
movl 0x8(%rdi), %r13d
movl $0x1, %r14d
movl $0x1, %eax
jmp 0x4452
movl 0x8(%rdi), %r13d
movl 0x2c(%rdi), %r9d
xorl %r10d, %r10d
movl %esi, %eax
xorl %edx, %edx
divl %r9d
movl %edx, %r14d
imull %r13d, %r14d
leal (%r9,%r9), %eax
cmpl %esi, %eax
setbe %cl
movl %r13d, %eax
shll %cl, %eax
cmpl %esi, %r9d
cmoval %r10d, %eax
leal (%rax,%r13), %ecx
cmpl %ecx, %eax
jae 0x44a3
leal (%r14,%r13), %r15d
movq 0x10(%rdi), %rdx
movq %rdx, 0x10(%rsp)
movl %r14d, %edx
movq %rdx, 0x8(%rsp)
decl %r13d
incq %r13
movl %eax, %ebx
movl %ecx, %r12d
movzbl %r8b, %ebp
cmpl %r15d, %r14d
jae 0x449b
movq 0x10(%rsp), %rax
movq (%rax,%rbx,8), %rdi
addq 0x8(%rsp), %rdi
movl %ebp, %esi
movq %r13, %rdx
callq 0x2070
incq %rbx
cmpq %rbx, %r12
jne 0x447e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4a04
callq 0x502d
callq 0x50b7
callq 0x565f
callq 0x5902
callq 0x5cb2
callq 0x5f5f
callq 0x6770
callq 0x6c6d
callq 0x7096
callq 0x849a
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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), %rdi
subq %rax, %rdi
movq (%rsi), %rcx
movq 0x8(%rsi), %rsi
movq %rsi, %rdx
subq %rcx, %rdx
cmpq %rdx, %rdi
jne 0x8726
cmpq %rcx, %rsi
je 0x86e6
sarq $0x3, %rdx
movl $0x1, %esi
xorl %edi, %edi
movl (%rcx,%rdi,8), %r8d
cmpl (%rax,%rdi,8), %r8d
jne 0x8707
movb 0x4(%rcx,%rdi,8), %r8b
cmpb 0x4(%rax,%rdi,8), %r8b
jne 0x86e8
movl %esi, %edi
incl %esi
cmpq %rdi, %rdx
ja 0x86c7
popq %rax
retq
leaq 0x12ae(%rip), %rdi      # 0x999d
leaq 0xc27(%rip), %rsi       # 0x931d
leaq 0x123c(%rip), %rcx      # 0x9939
movl $0x244, %edx            # imm = 0x244
callq 0x2090
leaq 0x1263(%rip), %rdi      # 0x9971
leaq 0xc08(%rip), %rsi       # 0x931d
leaq 0x121d(%rip), %rcx      # 0x9939
movl $0x243, %edx            # imm = 0x243
callq 0x2090
leaq 0x11ea(%rip), %rdi      # 0x9917
leaq 0xbe9(%rip), %rsi       # 0x931d
leaq 0x11fe(%rip), %rcx      # 0x9939
movl $0x241, %edx            # imm = 0x241
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O3/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), %rcx
movq (%rcx), %rsi
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0x11a086
movq 0x18(%rcx), %rcx
movsd (%rcx), %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, %r8
sarq $0x3f, %r8
subsd 0x189058(%rip), %xmm0   # 0x2a30a8
cvttsd2si %xmm0, %rdx
andq %r8, %rdx
orq %rcx, %rdx
addq $0x50, %rdi
movq %rdi, %rcx
xorl %r8d, %r8d
cmpq %rsi, 0x20(%rax)
setb %r8b
cmovaeq %rax, %rcx
movq 0x10(%rax,%r8,8), %rax
testq %rax, %rax
jne 0x11a062
cmpq %rdi, %rcx
je 0x11a086
cmpq 0x20(%rcx), %rsi
jae 0x11a09a
leaq 0x18dc75(%rip), %rdi    # 0x2a7d02
xorl %eax, %eax
callq 0x114050
xorpd %xmm0, %xmm0
popq %rax
retq
movq 0x28(%rcx), %rax
movq (%rax), %rcx
cmpq %rdx, %rcx
jae 0x11a0b6
leaq 0x18dc9d(%rip), %rdi    # 0x2a7d4a
xorl %eax, %eax
callq 0x114050
jmp 0x11a094
leaq -0x1(%rdx), %rsi
xorpd %xmm0, %xmm0
cmpq %rcx, %rsi
jae 0x11a098
movq %rdx, 0x8(%rax)
movsd 0x188fe1(%rip), %xmm0   # 0x2a30b0
jmp 0x11a098
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r8d, (%rsp)
movq %rdx, 0x10(%rsp)
movl %edi, 0x4(%rsp)
movl (%rsi), %r12d
leaq 0x813ac3(%rip), %r13    # 0x820314
movl (%r13), %eax
cmpl %eax, %r12d
jge 0xc8de
movl %ecx, %r15d
movq %rsi, %r14
movq %r9, 0x8(%rsp)
leaq 0x813ab0(%rip), %rbp    # 0x820320
movslq %r12d, %rcx
movzbl (%rbp,%rcx), %ecx
cmpl $0xa, %ecx
je 0xc883
testl %ecx, %ecx
jne 0xc88d
jmp 0xc8db
movq 0x10(%rsp), %rax
incl (%rax)
movl (%r14), %r12d
movslq %r12d, %rax
movsbl (%rbp,%rax), %ebx
testb %r15b, %r15b
jne 0xc8a5
movl %ebx, %edi
callq 0x3080
testl %eax, %eax
jne 0xc8b1
cmpb 0x4(%rsp), %bl
je 0xc8c2
cmpb $0x0, (%rsp)
je 0xc8de
incl %r12d
movl %r12d, (%r14)
movl (%r13), %eax
cmpl %eax, %r12d
jl 0xc870
jmp 0xc8de
leal 0x1(%r12), %eax
movl %eax, (%r14)
movb $0x1, %al
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
je 0xc8e0
movl %r12d, (%rcx)
jmp 0xc8e0
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_O3/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 0x92b2
leaq 0x8f75(%rip), %rax      # 0x17290
movq (%rax), %rsi
leaq 0x43bd(%rip), %rdi      # 0x126e2
xorl %eax, %eax
callq 0x89f6
leaq 0x43c3(%rip), %rdi      # 0x126f6
xorl %eax, %eax
callq 0x89f6
leaq 0x4403(%rip), %rdi      # 0x12744
xorl %eax, %eax
callq 0x89f6
leaq 0x441e(%rip), %rdi      # 0x1276d
xorl %eax, %eax
callq 0x89f6
leaq 0x443a(%rip), %rdi      # 0x12797
xorl %eax, %eax
callq 0x89f6
leaq 0x4457(%rip), %rdi      # 0x127c2
xorl %eax, %eax
callq 0x89f6
leaq 0x447e(%rip), %rdi      # 0x127f7
xorl %eax, %eax
callq 0x89f6
leaq 0x449b(%rip), %rdi      # 0x12822
xorl %eax, %eax
callq 0x89f6
leaq 0x44b8(%rip), %rdi      # 0x1284d
xorl %eax, %eax
callq 0x89f6
leaq 0x44e0(%rip), %rdi      # 0x12883
xorl %eax, %eax
callq 0x89f6
leaq 0x4509(%rip), %rdi      # 0x128ba
xorl %eax, %eax
callq 0x89f6
leaq 0x453c(%rip), %rdi      # 0x128fb
xorl %eax, %eax
callq 0x89f6
leaq 0x4570(%rip), %rdi      # 0x1293d
xorl %eax, %eax
callq 0x89f6
leaq 0x45a5(%rip), %rdi      # 0x12980
xorl %eax, %eax
callq 0x89f6
leaq 0x45c4(%rip), %rdi      # 0x129ad
xorl %eax, %eax
callq 0x89f6
leaq 0x45f9(%rip), %rdi      # 0x129f0
xorl %eax, %eax
callq 0x89f6
movl $0x1, %edi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O3/brianwu02[P]ImageProcessing/briansFunctions.cpp
// Function: floatCopyToBuffer(imageS*, int, int, float*)
void floatCopyToBuffer(imageP I1, int row, int bufRowsRequired, float *buffer) {
    int height = I1->height;
    int width = I1->width;
    unsigned char *in;
    float *ptr;
    in = I1->image;

    int bufStartIndex = (row % bufRowsRequired) * width;

    ptr = &buffer[bufStartIndex+1];
    for (int x=0; x<width; x++) {
        ptr[0] = in[row*width+x];
        ptr++;
    }
}

// Assembly:
movslq (%rdi), %r9
testq %r9, %r9
jle 0x320f
movl %edx, %r8d
movl %esi, %eax
cltd
idivl %r8d
imull %r9d, %edx
movslq %edx, %rdx
imull %r9d, %esi
movslq %esi, %rax
addq 0x8(%rdi), %rax
leaq (%rcx,%rdx,4), %rcx
addq $0x4, %rcx
xorl %edx, %edx
movzbl (%rax,%rdx), %esi
xorps %xmm0, %xmm0
cvtsi2ss %esi, %xmm0
movss %xmm0, (%rcx,%rdx,4)
incq %rdx
cmpq %rdx, %r9
jne 0x31f7
retq
// File: /workspace/github_cpp_makefile_star2_O3/brianwu02[P]ImageProcessing/briansFunctions.cpp
// Function: copyToBufferPadded(imageS*, int, int, unsigned char*)
void copyToBufferPadded(imageP I1, int row, int bufRowsRequired, unsigned char *buffer) {
    int height = I1->height;
    int width = I1->width;
    unsigned char *in, *ptr;
    in = I1->image;

    int bufStartIndex = (row % bufRowsRequired) * width;

    ptr = &buffer[bufStartIndex];
    for (int x=0; x<width; x++) {
        ptr[0] = in[row*width+x];
        ptr++;
    }
}

// Assembly:
movslq (%rdi), %r9
testq %r9, %r9
jle 0x3248
movl %edx, %r8d
movl %esi, %eax
cltd
idivl %r8d
imull %r9d, %edx
movslq %edx, %rax
addq %rax, %rcx
imull %r9d, %esi
movslq %esi, %rax
addq 0x8(%rdi), %rax
xorl %edx, %edx
movb (%rax,%rdx), %sil
movb %sil, (%rcx,%rdx)
incq %rdx
cmpq %rdx, %r9
jne 0x3238
retq
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH06_Functions/examples/errMsg_initList.cc
// Function: error_msg(ErrCode, std::initializer_list<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
void error_msg(ErrCode e, initializer_list<string> il)
{
	cout << e.msg() << ": ";
	for (const auto &elem : il)
		cout << elem << " " ;
	cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq -0x2c(%rbp), %rsi
movl %edi, (%rsi)
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x2e8e
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x3a95(%rip), %r15      # 0x5fd8
movq %r15, %rdi
callq 0x2130
leaq 0x1ab2(%rip), %rsi      # 0x4004
movl $0x2, %edx
movq %rax, %rdi
callq 0x2130
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2578
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2110
testq %rbx, %rbx
je 0x25ba
shlq $0x5, %rbx
addq %r14, %rbx
movq 0x3a4d(%rip), %r12      # 0x5fd8
leaq 0x1a73(%rip), %r13      # 0x4005
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r12, %rdi
callq 0x2130
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2130
addq $0x20, %r14
cmpq %rbx, %r14
jne 0x2592
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x260c
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2110
movq %rbx, %rdi
callq 0x21a0