LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/FFY00[P]uicc/include/uicc.h
// Function: UICC::UICC()
UICC() {
        char *debug_env=getenv("DEBUG");

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x0, (%rdi)
orl $-0x1, 0x4(%rdi)
leaq 0x8791(%rip), %rdi      # 0x133e0
callq 0x22f0
testq %rax, %rax
je 0xac67
movzbl (%rax), %eax
orl $0x20, %eax
cmpl $0x79, %eax
jne 0xac67
movb $0x1, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/FFY00[P]uicc/include/uicc.h
// Function: UICC::read[abi:cxx11](unsigned long)
string read(size_t s = 1024) {
        size_t got=0;
        string data="";

        while (got < s) {
            int ret;
            char buf;
            Assert( (ret=::read(fd, &buf, 1)) >= 0, "Error from read");

            switch (ret) {
            case 1:
                got++;
                data+=buf;
                break;

            case 0: // for time out: no more data
                if (debug)
                    dump_hex("Received", data);

                return data;
                break;

            default:
                fprintf(stderr,"Error from read > 1 char\n");
            }
        }

        if (debug)
            dump_hex("Received", data);

        return data;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r15
movq %rsi, %r14
leaq 0x8703(%rip), %rsi      # 0x13392
leaq -0x29(%rbp), %r12
movq %rdi, -0x38(%rbp)
movq %r12, %rdx
callq 0x20f0
xorl %ebx, %ebx
pushq $0x1
popq %r13
cmpq %r15, %rbx
jae 0xacfa
movl 0x4(%r14), %edi
movq %r12, %rsi
movq %r13, %rdx
callq 0x2370
testl %eax, %eax
js 0xad9b
cmpl $0x1, %eax
jne 0xacd8
movsbl -0x29(%rbp), %esi
movq -0x38(%rbp), %rdi
callq 0x21f0
incq %rbx
jmp 0xaca5
testl %eax, %eax
je 0xad35
movq 0xe2ed(%rip), %rax      # 0x18fd0
movq (%rax), %rcx
leaq 0x8933(%rip), %rdi      # 0x13620
pushq $0x19
popq %rsi
movq %r13, %rdx
callq 0x2460
jmp 0xaca5
cmpb $0x1, (%r14)
jne 0xad85
leaq 0x890c(%rip), %rsi      # 0x13617
leaq -0x58(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x20f0
leaq -0x98(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x2330
leaq -0x58(%rbp), %r14
leaq -0x98(%rbp), %r15
jmp 0xad6a
cmpb $0x1, (%r14)
jne 0xad85
leaq 0x88d5(%rip), %rsi      # 0x13617
leaq -0x78(%rbp), %rdi
leaq -0x2a(%rbp), %rdx
callq 0x20f0
leaq -0xb8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x2330
leaq -0x78(%rbp), %r14
leaq -0xb8(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x7a66
movq %r15, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2120
movq -0x38(%rbp), %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xe22e(%rip), %r14      # 0x18fd0
movq (%r14), %rbx
callq 0x2040
movl (%rax), %edi
callq 0x20c0
leaq 0x87d2(%rip), %rsi      # 0x1358a
leaq 0x8853(%rip), %rdx      # 0x13612
leaq 0x86c6(%rip), %rcx      # 0x1348c
movq %rbx, %rdi
movl $0xeb, %r8d
movq %rax, %r9
xorl %eax, %eax
callq 0x2360
movq 0xe1c8(%rip), %rax      # 0x18fa8
movq (%rax), %rdi
callq 0x22c0
movq (%r14), %rdi
callq 0x22c0
pushq $0x1
popq %rdi
callq 0x22e0
movq %rax, %r14
leaq -0x78(%rbp), %rdi
jmp 0xae0a
jmp 0xae13
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x2120
jmp 0xae16
jmp 0xae13
movq %rax, %r14
movq -0x38(%rbp), %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2400
nop
// File: /workspace/github_cpp_makefile_star2_O2/FFY00[P]uicc/include/uicc.h
// Function: USIM::openFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool openFile(string filename) {
        string order(u8"\x00\xa4\x08\x04",4);
        string answer(u8"\x61",1);
        string filenameBin=UICCFile(filename);

        if (! send_check(order+(char)(filenameBin.size())+filenameBin, answer))
            return false;

        string size=read(1);

        if (size.size() !=1)
            return false;

        return readFileInfo(size);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %rbx
leaq -0x100(%rbp), %rax
movq %rax, -0x10(%rax)
movl $0x408a400, (%rax)      # imm = 0x408A400
movq $0x4, -0x8(%rax)
movb $0x0, 0x4(%rax)
leaq -0xe0(%rbp), %rax
movq %rax, -0x10(%rax)
movw $0x61, (%rax)
movq $0x1, -0x8(%rax)
leaq -0xd0(%rbp), %rdi
callq 0x2330
leaq -0x50(%rbp), %rdi
leaq -0xd0(%rbp), %rdx
movq %rbx, %rsi
callq 0xd78a
leaq -0xd0(%rbp), %rdi
callq 0x2120
movsbl -0x48(%rbp), %edx
leaq -0x30(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0xe412
leaq -0xb0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0xe3e9
leaq -0x90(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x2330
leaq -0xb0(%rbp), %rsi
leaq -0x90(%rbp), %rdx
movq %rbx, %rdi
callq 0xb426
movl %eax, %r14d
leaq -0x90(%rbp), %rdi
callq 0x2120
leaq -0xb0(%rbp), %rdi
callq 0x2120
leaq -0x30(%rbp), %rdi
callq 0x2120
testb %r14b, %r14b
je 0xd6d1
leaq -0x30(%rbp), %rdi
pushq $0x1
popq %rdx
movq %rbx, %rsi
callq 0xac6e
cmpq $0x1, -0x28(%rbp)
jne 0xd6d5
leaq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2330
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0xe44e
movl %eax, %ebx
leaq -0x70(%rbp), %rdi
callq 0x2120
jmp 0xd6d7
xorl %ebx, %ebx
jmp 0xd6e0
xorl %ebx, %ebx
leaq -0x30(%rbp), %rdi
callq 0x2120
leaq -0x50(%rbp), %rdi
callq 0x2120
leaq -0xf0(%rbp), %rdi
callq 0x2120
leaq -0x110(%rbp), %rdi
callq 0x2120
movl %ebx, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
jmp 0xd737
jmp 0xd73e
jmp 0xd74c
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x2120
jmp 0xd730
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x2120
jmp 0xd741
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2120
jmp 0xd74f
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2120
leaq -0xf0(%rbp), %rdi
callq 0x2120
leaq -0x110(%rbp), %rdi
callq 0x2120
movq %rbx, %rdi
callq 0x2400
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
jmp 0xd753
movq %rax, %rbx
jmp 0xd758
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movl %edx, %r15d
movq %rdi, %rbx
leaq -0x58(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x68(%rbp), %rdi
callq 0x21f0
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movw $0x20, (%r12)
movq $0x2, -0x8(%r12)
movb $0x0, 0x2(%r12)
leaq -0x68(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2470
leaq -0x48(%rbp), %rdi
callq 0x2120
movsbl %r15b, %esi
leaq -0x68(%rbp), %rdi
callq 0x21f0
leaq -0x68(%rbp), %rdi
pushq $0x8
popq %rsi
callq 0x21f0
leaq -0x68(%rbp), %rdi
movq %r14, %rsi
callq 0x2470
movl 0x8(%r14), %r13d
leaq -0x68(%rbp), %r14
pushq $-0x1
popq %r15
cmpl $0x8, %r13d
jge 0xefd4
movq %r14, %rdi
movl %r15d, %esi
callq 0x21f0
incl %r13d
jmp 0xefbe
movq %r12, -0x48(%rbp)
movw $0x90, -0x38(%rbp)
movq $0x2, -0x40(%rbp)
movb $0x0, -0x36(%rbp)
leaq -0xa8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x2330
leaq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2330
leaq -0xa8(%rbp), %rsi
leaq -0x88(%rbp), %rdx
movq %rbx, %rdi
callq 0xb426
movl %eax, %ebx
leaq -0x88(%rbp), %rdi
callq 0x2120
leaq -0xa8(%rbp), %rdi
callq 0x2120
leaq -0x48(%rbp), %rdi
callq 0x2120
leaq -0x68(%rbp), %rdi
callq 0x2120
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x2120
jmp 0xf074
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x2120
jmp 0xf087
jmp 0xf084
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x2120
jmp 0xf097
jmp 0xf094
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x2120
movq %rbx, %rdi
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O2/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 0x28fa
movl %eax, %eax
movq %rsp, %rdx
movq %rax, (%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x36f6
andq $0x0, 0x20(%rbx)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
pushq $0x1
popq %rsi
xorl %edx, %edx
cmpq %rcx, %rax
je 0x23ac
imulq $0xc, %rsi, %rdi
imulq (%rax), %rsi
addq %rsi, %rdx
movq %rdx, 0x20(%rbx)
addq $0x8, %rax
movq %rdi, %rsi
jmp 0x238f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2401
movq %rax, 0x8(%r14)
andq $0x0, 0x20(%r14)
movabsq $0x100000005, %rsi      # imm = 0x100000005
movq %r14, %rdi
callq 0x235c
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2642
// File: /workspace/github_cpp_makefile_star2_O2/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 0x249b
movq %rax, 0x8(%rbx)
andq $0x0, 0x20(%rbx)
movq (%rsi), %r14
movq 0x8(%rsi), %r15
cmpq %r15, %r14
je 0x24bd
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x235c
addq $0x8, %r14
jmp 0x24a7
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x286c
testb %al, %al
je 0x25ef
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x2570
movq %rax, 0x8(%rbx)
xorl %r12d, %r12d
pushq $0x8
popq %r15
movzbl (%r14), %r13d
testl %r13d, %r13d
je 0x25d0
movsbl %r13b, %edi
callq 0x28ba
testq %r12, %r12
je 0x259c
cmpl $0x27, %r13d
je 0x25b6
cmpl $0x20, %r13d
je 0x25bc
jmp 0x25cb
movl %eax, %ebp
cmpl $0xd, %eax
je 0x25c8
movq %r15, %rdi
callq 0x2150
movq %rax, %r12
movb $0x1, 0x4(%rax)
movl %ebp, (%rax)
jmp 0x25cb
movb $0x0, 0x4(%r12)
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x235c
xorl %r12d, %r12d
incq %r14
jmp 0x2577
testq %r12, %r12
je 0x25ef
movq (%r12), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x235c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2624
movq %rsi, %r14
movq %rbx, %rdi
callq 0x33d0
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_O2/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
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %rbx
addq %rsi, 0x20(%rdi)
xorl %r15d, %r15d
xorl %ebp, %ebp
pushq $0xc
popq %r14
movq %r12, %rax
orq %r15, %rax
je 0x26fb
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
leal 0x1(%rbp), %ecx
movq %rcx, 0x8(%rsp)
cmpq %rcx, %rax
jae 0x26b4
andq $0x0, 0x10(%rsp)
movq %rbx, %rdi
leaq 0x10(%rsp), %rsi
callq 0x3898
testq %r12, %r12
je 0x26a4
decq %r12
jmp 0x26b4
subq $0x1, %r15
movl $0x0, %eax
cmovbq %rax, %r15
xorl %r12d, %r12d
movq %r12, %rax
xorl %edx, %edx
divq %r14
movq %rdx, %r13
movl %ebp, %ebp
movq %rax, %r12
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x34ce
addq %r15, %r13
addq (%rax), %r13
movq %r13, %rax
xorl %edx, %edx
divq %r14
movq %rdx, %r13
movq %rax, %r15
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x34ce
movq %r13, (%rax)
movq 0x8(%rsp), %rbp
jmp 0x2663
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chuckwolber[P]Cube/test/../Algorithm.cpp
// Function: Algorithm::isValid(char const*)
bool Algorithm::isValid(const char* algorithm) {
    if (algorithm == nullptr)
        return false;
    
    bool inTurn = false;
    Layer layer;

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x28af
movq %rdi, %rbx
xorl %ecx, %ecx
movzbl (%rbx), %eax
testl %eax, %eax
sete %bpl
je 0x28b1
testb $0x1, %cl
je 0x289b
cmpl $0x27, %eax
je 0x2893
cmpl $0x20, %eax
jne 0x28b1
cmpl $0x20, %eax
setne %cl
jmp 0x28aa
movsbl %al, %edi
callq 0x28ba
movb $0x1, %cl
cmpl $0xd, %eax
je 0x28b1
incq %rbx
jmp 0x2879
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x701d(%rip), %rsi      # 0x9953
leaq 0x7(%rsp), %rdx
callq 0x3512
movq 0x8(%r14), %r15
subq (%r14), %r15
sarq $0x3, %r15
leaq 0x7000(%rip), %r12      # 0x9952
movq %r15, %rbp
subq $0x1, %rbp
jb 0x29ab
movq (%r14), %rax
movq (%rax,%rbp,8), %rsi
callq 0x29d0
movq %rax, %r13
movl %r13d, %edi
callq 0x29f6
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2120
shrq $0x20, %r13
jne 0x2992
movq %rbx, %rdi
leaq 0x6afc(%rip), %rsi      # 0x9489
callq 0x21e0
cmpq $0x1, %r15
movq %rbp, %r15
je 0x2952
movq %rbx, %rdi
movq %r12, %rsi
callq 0x21e0
movq %rbp, %r15
jmp 0x2952
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
callq 0x20a0
movq %r14, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r12
subq (%rsi), %r12
sarq $0x3, %r12
movq %rsp, %r15
subq $0x1, %r12
jb 0x2a56
movq (%r14), %rax
movq (%rax,%r12,8), %rsi
callq 0x29d0
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3964
jmp 0x2a33
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x358c
movq %r14, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2aaa
testb %al, %al
jne 0x2a9d
movq %rbx, %rdi
callq 0x2b78
testb %al, %al
jne 0x2a9d
movq %rbx, %rdi
callq 0x2dbe
testb %al, %al
je 0x2aa1
movb $0x1, %al
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x2e4e
// File: /workspace/github_cpp_makefile_star2_O2/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), %r15d
movl 0x28(%rdi), %r12d
imull %r15d, %r12d
leaq (,%r12,8), %rdi
callq 0x2030
movq %rax, 0x10(%rbx)
movl 0x2c(%rbx), %r14d
imull %r15d, %r14d
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x3b14
movq %r14, %rdi
callq 0x2030
movq 0x10(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
incq %r13
jmp 0x3afa
imull 0x2c(%rbx), %r15d
xorl %eax, %eax
cmpq %r12, %rax
je 0x3b3d
movq 0x10(%rbx), %rcx
xorl %edx, %edx
cmpq %rdx, %r15
je 0x3b38
movq (%rcx,%rax,8), %rsi
movb $0x20, (%rsi,%rdx)
incq %rdx
jmp 0x3b26
incq %rax
jmp 0x3b1b
movq %rbx, %rdi
callq 0x43f2
movq %rbx, %rdi
callq 0x44c6
leaq 0x34(%rbx), %rsi
pushq $0x5
popq %rdx
movq %rbx, %rdi
callq 0x4326
movdqu 0x8(%rbx), %xmm0
movq 0x34(%rbx), %xmm1
pshufd $0x50, %xmm0, %xmm0     # xmm0 = xmm0[0,0,1,1]
paddd %xmm1, %xmm0
movq %xmm0, 0x3c(%rbx)
leaq 0x44(%rbx), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x4326
movdqu 0x8(%rbx), %xmm0
movq 0x44(%rbx), %xmm1
pshufd $0x50, %xmm0, %xmm0     # xmm0 = xmm0[0,0,1,1]
paddd %xmm1, %xmm0
movq %xmm0, 0x4c(%rbx)
leaq 0x54(%rbx), %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x4326
movdqu 0x8(%rbx), %xmm0
movq 0x54(%rbx), %xmm1
pshufd $0x50, %xmm0, %xmm0     # xmm0 = xmm0[0,0,1,1]
paddd %xmm1, %xmm0
movq %xmm0, 0x5c(%rbx)
leaq 0x64(%rbx), %rsi
pushq $0x6
popq %rdx
movq %rbx, %rdi
callq 0x4326
movdqu 0x8(%rbx), %xmm0
movq 0x64(%rbx), %xmm1
pshufd $0x50, %xmm0, %xmm0     # xmm0 = xmm0[0,0,1,1]
paddd %xmm1, %xmm0
movq %xmm0, 0x6c(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x55c3(%rip), %xmm0     # 0x9210
movups %xmm0, 0x20(%rdi)
movl $0x18, 0x30(%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movb (%rsi), %al
movb %al, (%rdi)
callq 0x3ac6
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3c7a
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
movups 0x10(%rsi), %xmm0
movups %xmm0, 0x10(%rdi)
movl (%rsi), %eax
movl %eax, (%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_O2/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 0x3d76
movq %rsi, %r14
movq %rbx, %rdi
callq 0x3d82
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
movb (%r14), %al
movb %al, (%rbx)
movq %rbx, %rdi
callq 0x3ac6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3c7a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3dc5
xorl %r14d, %r14d
movl 0x8(%rbx), %eax
imull 0x28(%rbx), %eax
movq 0x10(%rbx), %rdi
cmpq %rax, %r14
jae 0x3db6
movq (%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x3db1
callq 0x2180
incq %r14
jmp 0x3d93
testq %rdi, %rdi
je 0x3dc0
callq 0x2180
andq $0x0, 0x10(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x3dd8
callq 0x2180
andq $0x0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3e0a
movq %rsi, %r14
movq %rbx, %rdi
callq 0x3d82
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3ce0
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_O2/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), %eax
cmpl 0x8(%rsi), %eax
jne 0x3e5f
movl 0x28(%rdi), %ecx
imull %eax, %ecx
imull 0x2c(%rdi), %eax
movq 0x10(%rdi), %rdx
movq 0x10(%rsi), %rsi
xorl %edi, %edi
cmpq %rcx, %rdi
je 0x3e62
xorl %r8d, %r8d
cmpq %r8, %rax
je 0x3e5a
movq (%rdx,%rdi,8), %r9
movb (%r9,%r8), %r9b
movq (%rsi,%rdi,8), %r10
leaq 0x1(%r8), %r11
cmpb (%r10,%r8), %r9b
movq %r11, %r8
je 0x3e3a
jmp 0x3e5f
incq %rdi
jmp 0x3e32
xorl %eax, %eax
retq
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movl 0x8(%rsi), %eax
xorl %r15d, %r15d
movl 0x28(%r14), %ecx
imull %eax, %ecx
cmpq %rcx, %r15
jae 0x3ed5
xorl %r12d, %r12d
movl 0x2c(%r14), %ecx
imull %eax, %ecx
cmpq %rcx, %r12
jae 0x3ed0
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0x48ee
incq %r12
movl 0x8(%r14), %eax
jmp 0x3ea8
incq %r15
jmp 0x3e99
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x490c
movq %r14, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3f62
testb %al, %al
je 0x3f5e
movq 0x44(%rbx), %rsi
movq 0x4c(%rbx), %rdx
movq %rbx, %rdi
callq 0x3f62
testb %al, %al
je 0x3f5e
movq 0x54(%rbx), %rsi
movq 0x5c(%rbx), %rdx
movq %rbx, %rdi
callq 0x3f62
testb %al, %al
je 0x3f5e
movq 0x64(%rbx), %rsi
movq 0x6c(%rbx), %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x3f62
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl %esi, %eax
shrq $0x20, %rsi
movl %edx, %ecx
shrq $0x20, %rdx
movq 0x10(%rdi), %rdi
movq (%rdi,%rax,8), %r8
movb (%r8,%rsi), %r8b
cmpq %rcx, %rax
jae 0x3f9f
movq %rsi, %r9
cmpq %rdx, %r9
jae 0x3f9a
movq (%rdi,%rax,8), %r10
leaq 0x1(%r9), %r11
cmpb (%r10,%r9), %r8b
movq %r11, %r9
je 0x3f82
jmp 0x3f9f
incq %rax
jmp 0x3f7a
cmpq %rcx, %rax
setae %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x522c(%rip), %r15      # 0x9220
leaq 0x4(%r12), %rax
movq %rax, (%rsp)
leaq 0x9(%r12), %rbp
leaq 0x5(%r12), %r13
leal -0x1(%r14), %eax
cmpl $0xb, %eax
ja 0x40ad
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
andq %r12, %r14
movq %r14, %rsi
orq $0x6, %rsi
movq %rbx, %rdi
callq 0x3fd2
xorq (%rsp), %r14
jmp 0x4007
andq %r12, %r14
movq %r14, %rsi
xorq %r13, %rsi
movq %rbx, %rdi
callq 0x3fd2
orq $0x7, %r14
jmp 0x4007
andq %r12, %r14
movq %r14, %rsi
orq $0x1, %rsi
movq %rbx, %rdi
callq 0x3fd2
xorq %rbp, %r14
jmp 0x4007
pushq $0x10
jmp 0x4079
pushq $0x14
jmp 0x4079
xorl %ebp, %ebp
jmp 0x407a
pushq $0x4
jmp 0x4079
pushq $0x8
jmp 0x4079
pushq $0xc
popq %rbp
xorl %r15d, %r15d
testq %r12, %r14
setne %r15b
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x40bc
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 0x4272
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl 0x8(%rdi), %eax
movl %eax, %ecx
imull %esi, %ecx
movq %rcx, 0x28(%rsp)
leal 0x3(%rbx), %r12d
imull %eax, %r12d
leal 0x2(%rbx), %r13d
imull %eax, %r13d
incl %ebx
imull %eax, %ebx
xorl %r15d, %r15d
movzbl %dl, %ebp
movl %eax, %eax
cmpq %rax, %r15
jae 0x4317
movq 0x18(%r14), %rax
movq 0x28(%rsp), %rcx
addl %r15d, %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 (%r13,%r15), %ecx
leal (%r12,%r15), %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 0x4362
incq %r15
movl 0x8(%r14), %eax
jmp 0x42ad
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::getLayerUpperLeft(Coordinate&, Layer)
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 %edx, %r8d
leal -0xa(%r8), %eax
cmpl $0x4, %eax
jb 0x4360
movl 0x8(%rdi), %r9d
movl 0x2c(%rdi), %edi
xorl %r10d, %r10d
movl %r8d, %eax
xorl %edx, %edx
divl %edi
imull %r9d, %edx
movl %edx, 0x4(%rsi)
leal (%rdi,%rdi), %eax
cmpl %r8d, %eax
setbe %cl
shll %cl, %r9d
cmpl %r8d, %edi
cmoval %r10d, %r9d
movl %r9d, (%rsi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x43ae
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)
pushq $0x4
popq %rdi
movq %rax, %r8
jmp 0x43dd
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
pushq $0x14
popq %rdi
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_O2/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 0x4578
movq %rbx, %rdi
callq 0x4620
movq %rbx, %rdi
callq 0x46a4
movq %rbx, %rdi
callq 0x4732
movq %rbx, %rdi
callq 0x47ce
movq %rbx, %rdi
popq %rbx
jmp 0x4848
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %edx
movq %rdi, %r14
movabsq $0x100000001, %rax      # imm = 0x100000001
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %r15, %rsi
callq 0x4326
movl (%r15), %eax
movl 0x4(%r15), %ecx
movl 0x8(%r14), %edx
leal (%rcx,%rdx), %esi
addl %eax, %edx
cmpl %edx, %eax
jae 0x456e
movq 0x10(%r14), %rdi
movl %eax, %r8d
movq %rcx, %r9
cmpq %rsi, %r9
jae 0x456a
movq (%rdi,%r8,8), %r10
movb %bl, (%r10,%r9)
incq %r9
jmp 0x4558
incl %eax
jmp 0x454a
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::initializeFaceEdges()
void Cube::initializeFaceEdges() {
    Coordinate ul;
    getLayerUpperLeft(ul, Layer::F);

    for (unsigned int i=0; i<cubeSize; i++) {
        Coordinate c1;
        c1.row = ul.row - 1;
        c1.col = ul.col + i;
        edges[i + Edges::UpFace*cubeSize] = c1;

        Coordinate c2;
        c2.row = ul.row + i;
        c2.col = ul.col + cubeSize;
        edges[i + Edges::RightFace*cubeSize] = c2;

        Coordinate c3;
        c3.row = ul.row + cubeSize;
        c3.col = ul.col + cubeSize - 1 - i;
        edges[i + Edges::DownFace*cubeSize] = c3;

        Coordinate c4;
        c4.row = ul.row + cubeSize - 1 - i;
        c4.col = ul.col - 1;
        edges[i + Edges::LeftFace*cubeSize] = c4;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
pushq $0x5
popq %rdx
movq %r14, %rsi
callq 0x4326
movl (%r14), %eax
movl 0x4(%r14), %ecx
leal -0x1(%rax), %edx
movq 0x18(%rbx), %rsi
leal -0x1(%rcx), %edi
xorl %r8d, %r8d
movl %edi, %r9d
movl %edx, %r10d
movl 0x8(%rbx), %r11d
cmpq %r11, %r8
jae 0x4614
leal (%rcx,%r8), %r11d
movl %edx, (%rsi,%r8,8)
movl %r11d, 0x4(%rsi,%r8,8)
leal (%rax,%r8), %r11d
movl 0x8(%rbx), %r14d
leal (%r8,%r14), %r15d
addl %ecx, %r14d
movl %r11d, (%rsi,%r15,8)
movl %r14d, 0x4(%rsi,%r15,8)
movl 0x8(%rbx), %r11d
leal (%r11,%rax), %ebp
leal (%r9,%r11), %r14d
leal (%r8,%r11,2), %r11d
movl %ebp, (%rsi,%r11,8)
movl %r14d, 0x4(%rsi,%r11,8)
movl 0x8(%rbx), %r11d
leal (%r10,%r11), %ebp
leal (%r11,%r11,2), %r11d
addl %r8d, %r11d
movl %ebp, (%rsi,%r11,8)
movl %edi, 0x4(%rsi,%r11,8)
incq %r8
decl %r10d
decl %r9d
jmp 0x45aa
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::initializeUpEdges()
void Cube::initializeUpEdges() {
    Coordinate ul;
    getLayerUpperLeft(ul, Layer::U);

    for (unsigned int i=0; i<cubeSize; i++) {
        Coordinate c1;
        c1.row = cubeSize;
        c1.col = ul.col + cubeSize - 1 - i;
        edges[i + Edges::FaceUp*cubeSize] = c1;

        Coordinate c2;
        c2.row = cubeSize;
        c2.col = ul.col - 1 - i;
        edges[i + Edges::LeftUp*cubeSize] = c2;

        Coordinate c3;
        c3.row = cubeSize;
        c3.col = ul.col + cubeSize*3 - 1 - i;
        edges[i + Edges::BackUp*cubeSize] = c3;

        Coordinate c4;
        c4.row = cubeSize;
        c4.col = ul.col + cubeSize*2 - 1 - i;
        edges[i + Edges::RightUp*cubeSize] = c4;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
pushq $0x1
popq %rdx
movq %r14, %rsi
callq 0x4326
movl 0x4(%r14), %eax
movq 0x18(%rbx), %rcx
decl %eax
xorl %edx, %edx
movl 0x8(%rbx), %esi
cmpl %esi, %edx
jae 0x469b
leal (%rax,%rsi), %edi
leal (%rdx,%rsi,4), %r8d
movl %esi, (%rcx,%r8,8)
movl %edi, 0x4(%rcx,%r8,8)
movl 0x8(%rbx), %esi
leal (%rsi,%rsi,4), %edi
addl %edx, %edi
movl %esi, (%rcx,%rdi,8)
movl %eax, 0x4(%rcx,%rdi,8)
movl 0x8(%rbx), %esi
leal (%rsi,%rsi,2), %edi
addl %eax, %edi
imull $0x6, %esi, %r8d
addl %edx, %r8d
movl %esi, (%rcx,%r8,8)
movl %edi, 0x4(%rcx,%r8,8)
movl 0x8(%rbx), %esi
leal (%rax,%rsi,2), %edi
imull $0x7, %esi, %r8d
addl %edx, %r8d
movl %esi, (%rcx,%r8,8)
movl %edi, 0x4(%rcx,%r8,8)
incl %edx
decl %eax
jmp 0x4641
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::initializeLeftEdges()
void Cube::initializeLeftEdges() {
    Coordinate ul;
    getLayerUpperLeft(ul, Layer::L);

    for (unsigned int i=0; i<cubeSize; i++) {
        Coordinate c1;
        c1.row = i;
        c1.col = cubeSize;
        edges[i + Edges::UpLeft*cubeSize] = c1;

        Coordinate c2;
        c2.row = ul.row + i;
        c2.col = cubeSize;
        edges[i + Edges::FaceLeft*cubeSize] = c2;

        Coordinate c3;
        c3.row = ul.row + cubeSize + i;
        c3.col = cubeSize;
        edges[i + Edges::DownLeft*cubeSize] = c3;

        Coordinate c4;
        c4.row = ul.row + cubeSize - 1 - i;
        c4.col = cubeSize*4 - 1;
        edges[i + Edges::BackLeft*cubeSize] = c4;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
pushq $0x4
popq %rdx
movq %r14, %rsi
callq 0x4326
movq 0x18(%rbx), %rax
movl (%r14), %ecx
leal -0x1(%rcx), %edx
xorl %esi, %esi
movl 0x8(%rbx), %edi
cmpl %edi, %esi
jae 0x472a
leal (%rsi,%rdi,8), %r8d
movl %esi, (%rax,%r8,8)
movl %edi, 0x4(%rax,%r8,8)
leal (%rcx,%rsi), %edi
movl 0x8(%rbx), %r8d
leal (%r8,%r8,8), %r9d
addl %esi, %r9d
movl %edi, (%rax,%r9,8)
movl %r8d, 0x4(%rax,%r9,8)
movl 0x8(%rbx), %r8d
addl %r8d, %edi
imull $0xa, %r8d, %r9d
addl %esi, %r9d
movl %edi, (%rax,%r9,8)
movl %r8d, 0x4(%rax,%r9,8)
movl 0x8(%rbx), %edi
leal (%rdx,%rdi), %r8d
leal -0x1(,%rdi,4), %r9d
imull $0xb, %edi, %edi
addl %esi, %edi
movl %r8d, (%rax,%rdi,8)
movl %r9d, 0x4(%rax,%rdi,8)
incl %esi
decl %edx
jmp 0x46c5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::initializeRightEdges()
void Cube::initializeRightEdges() {
    Coordinate ul;
    getLayerUpperLeft(ul, Layer::R);

    for (unsigned int i=0; i<cubeSize; i++) {
        Coordinate c1;
        c1.row = ul.row - 1 - i;
        c1.col = ul.col - 1;
        edges[i + Edges::UpRight*cubeSize] = c1;

        Coordinate c2;
        c2.row = ul.row + i;
        c2.col = ul.col + cubeSize;
        edges[i + Edges::BackRight*cubeSize] = c2;

        Coordinate c3;
        c3.row = ul.row + cubeSize*2 - 1 - i;
        c3.col = ul.col - 1;
        edges[i + Edges::DownRight*cubeSize] = c3;

        Coordinate c4;
        c4.row = ul.row + cubeSize - 1 - i;
        c4.col = ul.col - 1;
        edges[i + Edges::FaceRight*cubeSize] = c4;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
pushq $0x6
popq %rdx
movq %r14, %rsi
callq 0x4326
movl (%r14), %eax
movl 0x4(%r14), %ecx
leal -0x1(%rcx), %edx
movq 0x18(%rbx), %rsi
leal -0x1(%rax), %edi
xorl %r8d, %r8d
movl 0x8(%rbx), %r9d
cmpl %r9d, %r8d
jae 0x47c6
imull $0xc, %r9d, %r9d
addl %r8d, %r9d
movl %edi, (%rsi,%r9,8)
movl %edx, 0x4(%rsi,%r9,8)
leal (%rax,%r8), %r9d
movl 0x8(%rbx), %r10d
imull $0xd, %r10d, %r11d
addl %ecx, %r10d
addl %r8d, %r11d
movl %r9d, (%rsi,%r11,8)
movl %r10d, 0x4(%rsi,%r11,8)
movl 0x8(%rbx), %r9d
leal (%rdi,%r9,2), %r10d
imull $0xe, %r9d, %r9d
addl %r8d, %r9d
movl %r10d, (%rsi,%r9,8)
movl %edx, 0x4(%rsi,%r9,8)
movl 0x8(%rbx), %r9d
leal (%rdi,%r9), %r10d
imull $0xf, %r9d, %r9d
addl %r8d, %r9d
movl %r10d, (%rsi,%r9,8)
movl %edx, 0x4(%rsi,%r9,8)
incl %r8d
decl %edi
jmp 0x475b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::initializeDownEdges()
void Cube::initializeDownEdges() {
    Coordinate ul;
    getLayerUpperLeft(ul, Layer::D);

    for (unsigned int i=0; i<cubeSize; i++) {
        Coordinate c1;
        c1.row = ul.row - 1;
        c1.col = ul.col + i;
        edges[i + Edges::FaceDown*cubeSize] = c1;

        Coordinate c2;
        c2.row = ul.row - 1;
        c2.col = ul.col + cubeSize + i;
        edges[i + Edges::RightDown*cubeSize] = c2;

        Coordinate c3;
        c3.row = ul.row - 1;
        c3.col = ul.col + cubeSize*2 + i;
        edges[i + Edges::BackDown*cubeSize] = c3;

        Coordinate c4;
        c4.row = ul.row - 1;
        c4.col = i;
        edges[i + Edges::LeftDown*cubeSize] = c4;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
pushq $0x9
popq %rdx
movq %r14, %rsi
callq 0x4326
movl (%r14), %eax
movl 0x4(%r14), %ecx
decl %eax
movq 0x18(%rbx), %rdx
xorl %esi, %esi
movl 0x8(%rbx), %edi
cmpl %edi, %esi
jae 0x4840
shll $0x4, %edi
addl %esi, %edi
movl %eax, (%rdx,%rdi,8)
movl %ecx, 0x4(%rdx,%rdi,8)
movl 0x8(%rbx), %edi
leal (%rcx,%rdi), %r8d
imull $0x11, %edi, %edi
addl %esi, %edi
movl %eax, (%rdx,%rdi,8)
movl %r8d, 0x4(%rdx,%rdi,8)
movl 0x8(%rbx), %edi
leal (%rcx,%rdi,2), %r8d
imull $0x12, %edi, %edi
addl %esi, %edi
movl %eax, (%rdx,%rdi,8)
movl %r8d, 0x4(%rdx,%rdi,8)
imull $0x13, 0x8(%rbx), %edi
addl %esi, %edi
movl %eax, (%rdx,%rdi,8)
movl %esi, 0x4(%rdx,%rdi,8)
incl %esi
incl %ecx
jmp 0x47f2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::initializeBackEdges()
void Cube::initializeBackEdges() {
    Coordinate ul;
    getLayerUpperLeft(ul, Layer::B);

    for (unsigned int i=0; i<cubeSize; i++) {
        Coordinate c1;
        c1.row = 0;
        c1.col = cubeSize*2 - 1 - i;
        edges[i + Edges::UpBack*cubeSize] = c1;

        Coordinate c2;
        c2.row = cubeSize + i;
        c2.col = 0;
        edges[i + Edges::LeftBack*cubeSize] = c2;

        Coordinate c3;
        c3.row = cubeSize*3 - 1;
        c3.col = cubeSize + i;
        edges[i + Edges::DownBack*cubeSize] = c3;

        Coordinate c4;
        c4.row = ul.row + cubeSize - 1 - i;
        c4.col = ul.col - 1;
        edges[i + Edges::RightBack*cubeSize] = c4;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
pushq $0x7
popq %rdx
movq %r14, %rsi
callq 0x4326
movq 0x18(%rbx), %rax
movl (%r14), %ecx
movl 0x4(%r14), %edx
decl %edx
xorl %esi, %esi
pushq $-0x1
popq %rdi
movl 0x8(%rbx), %r8d
cmpl %r8d, %esi
jae 0x48e6
leal (%rdi,%r8,2), %r9d
imull $0x14, %r8d, %r8d
addl %esi, %r8d
andl $0x0, (%rax,%r8,8)
movl %r9d, 0x4(%rax,%r8,8)
movl 0x8(%rbx), %r8d
leal (%rsi,%r8), %r9d
imull $0x15, %r8d, %r8d
addl %esi, %r8d
movl %r9d, (%rax,%r8,8)
andl $0x0, 0x4(%rax,%r8,8)
movl 0x8(%rbx), %r8d
leal (%r8,%r8,2), %r9d
decl %r9d
leal (%rsi,%r8), %r10d
imull $0x16, %r8d, %r8d
addl %esi, %r8d
movl %r9d, (%rax,%r8,8)
movl %r10d, 0x4(%rax,%r8,8)
movl 0x8(%rbx), %r8d
leal (%rcx,%rdi), %r9d
addl %r8d, %r9d
imull $0x17, %r8d, %r8d
addl %esi, %r8d
movl %r9d, (%rax,%r8,8)
movl %edx, 0x4(%rax,%r8,8)
incl %esi
decl %edi
jmp 0x486f
addq $0x8, %rsp
popq %rbx
popq %r14
retq