LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/pollow[P]MIPSClide/assembler.cpp
// Function: Assembler::calc_label()
void Assembler::calc_label() {
    static regex label_regex("(\\w+):");
    size_t i = 0;
    while ( i < statements.size() ) {
        string &str = statements[i];
        if ( regex_match(str, label_regex) ) {
            labels.insert( {str.substr(0, str.length()-1), i} );
            statements.erase( statements.begin() + i );
        } else i++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movb 0x1edf6(%rip), %al      # 0x2b7b8
testb %al, %al
movq %rdi, -0x30(%rbp)
je 0xcb15
movq 0x20(%rbx), %r12
cmpq %r12, 0x28(%rbx)
je 0xcb06
leaq 0x20(%rbx), %rax
movq %rax, -0x88(%rbp)
leaq 0x68(%rbx), %rax
movq %rax, -0x90(%rbp)
leaq -0x50(%rbp), %r13
xorl %r14d, %r14d
movq %r13, %rbx
movq %r14, %r15
shlq $0x5, %r15
movq (%r12,%r15), %rdi
movq 0x8(%r12,%r15), %rsi
addq %rdi, %rsi
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
leaq -0x60(%rbp), %rdx
leaq 0x1ed73(%rip), %rcx     # 0x2b798
xorl %r8d, %r8d
callq 0x1c102
movl %eax, %r13d
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0xca3e
callq 0x52d0
testb %r13b, %r13b
je 0xca7e
addq %r15, %r12
movq 0x8(%r12), %rcx
decq %rcx
leaq -0x80(%rbp), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x5340
movq %rbx, %r13
movq %rbx, -0x60(%rbp)
movq -0x80(%rbp), %rax
leaq -0x70(%rbp), %r12
cmpq %r12, %rax
je 0xca86
movq %rax, -0x60(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0xca90
incq %r14
movq %rbx, %r13
jmp 0xcaea
movups (%r12), %xmm0
movups %xmm0, (%r13)
movq -0x78(%rbp), %rax
movq %rax, -0x58(%rbp)
movq %r12, -0x80(%rbp)
movq $0x0, -0x78(%rbp)
movb $0x0, -0x70(%rbp)
movl %r14d, -0x40(%rbp)
movq -0x90(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1c900
movq -0x60(%rbp), %rdi
cmpq %r13, %rdi
je 0xcaca
callq 0x52d0
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0xcad8
callq 0x52d0
movq -0x88(%rbp), %rdi
addq (%rdi), %r15
movq %r15, %rsi
callq 0x1ca32
movq -0x30(%rbp), %rax
movq 0x20(%rax), %r12
movq 0x28(%rax), %rax
subq %r12, %rax
sarq $0x5, %rax
cmpq %rax, %r14
jb 0xc9f9
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ec9c(%rip), %rdi     # 0x2b7b8
callq 0x5580
testl %eax, %eax
je 0xc9ce
leaq 0x1ec68(%rip), %rdi     # 0x2b798
leaq 0x148d4(%rip), %rsi     # 0x2140b
movl $0x10, %edx
callq 0xd66a
leaq 0xb8e(%rip), %rdi       # 0xd6d6
leaq 0x1ec49(%rip), %rsi     # 0x2b798
leaq 0x1e7c2(%rip), %rdx     # 0x2b318
callq 0x52b0
leaq 0x1ec56(%rip), %rdi     # 0x2b7b8
callq 0x5200
movq -0x30(%rbp), %rbx
jmp 0xc9ce
movq %rax, %rbx
leaq 0x1ec3e(%rip), %rdi     # 0x2b7b8
callq 0x51f0
jmp 0xcbb2
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r13, %rdi
je 0xcb92
callq 0x52d0
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rax
cmpq %rax, %rdi
jne 0xcbad
jmp 0xcbb2
movq %rax, %rbx
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0xcbb2
callq 0x52d0
movq %rbx, %rdi
callq 0x5560
// File: /workspace/github_cpp_makefile_star2_O1/pollow[P]MIPSClide/assembler.cpp
// Function: Assembler::trim()
void Assembler::trim() {
    static regex trim("(^\\s+)|(\\s+$)");
    static regex comment("\\s*#.*");
    for(auto i=statements.begin(); i!=statements.end(); i++) {
        *i = regex_replace(*i, trim, "");
        *i = regex_replace(*i, comment, "");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movb 0x1ec0c(%rip), %al      # 0x2b7e0
testb %al, %al
je 0xccc2
movb 0x1ec26(%rip), %al      # 0x2b808
testb %al, %al
je 0xcd19
movq 0x20(%rbx), %r14
cmpq 0x28(%rbx), %r14
je 0xccb3
leaq -0x38(%rbp), %r15
leaq 0x14800(%rip), %r12     # 0x21403
leaq -0x48(%rbp), %r13
movq %r15, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movl $0x0, (%rsp)
movq %r13, %rdi
leaq 0x1eb8e(%rip), %rcx     # 0x2b7c0
movq %r12, %r8
xorl %r9d, %r9d
callq 0x19421
movq %r14, %rdi
movq %r13, %rsi
callq 0x53c0
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xcc56
callq 0x52d0
movq %r15, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movl $0x0, (%rsp)
movq %r13, %rdi
leaq 0x1eb67(%rip), %rcx     # 0x2b7e8
movq %r12, %r8
xorl %r9d, %r9d
callq 0x19421
movq %r14, %rdi
movq %r13, %rsi
callq 0x53c0
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xcca5
callq 0x52d0
addq $0x20, %r14
cmpq 0x28(%rbx), %r14
jne 0xcc07
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1eb17(%rip), %rdi     # 0x2b7e0
callq 0x5580
testl %eax, %eax
je 0xcbdc
leaq 0x1eae3(%rip), %rdi     # 0x2b7c0
leaq 0x1472e(%rip), %rsi     # 0x21412
movl $0x10, %edx
callq 0xd66a
leaq 0x9e1(%rip), %rdi       # 0xd6d6
leaq 0x1eac4(%rip), %rsi     # 0x2b7c0
leaq 0x1e615(%rip), %rdx     # 0x2b318
callq 0x52b0
leaq 0x1ead1(%rip), %rdi     # 0x2b7e0
callq 0x5200
jmp 0xcbdc
leaq 0x1eae8(%rip), %rdi     # 0x2b808
callq 0x5580
testl %eax, %eax
je 0xcbea
leaq 0x1eab4(%rip), %rdi     # 0x2b7e8
leaq 0x146e5(%rip), %rsi     # 0x21420
movl $0x10, %edx
callq 0xd66a
leaq 0x98a(%rip), %rdi       # 0xd6d6
leaq 0x1ea95(%rip), %rsi     # 0x2b7e8
leaq 0x1e5be(%rip), %rdx     # 0x2b318
callq 0x52b0
leaq 0x1eaa2(%rip), %rdi     # 0x2b808
callq 0x5200
jmp 0xcbea
movq %rax, %rbx
leaq 0x1ea8e(%rip), %rdi     # 0x2b808
jmp 0xcd86
movq %rax, %rbx
leaq 0x1ea5a(%rip), %rdi     # 0x2b7e0
callq 0x51f0
jmp 0xcda0
jmp 0xcd8f
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xcda0
callq 0x52d0
movq %rbx, %rdi
callq 0x5560
// File: /workspace/github_cpp_makefile_star2_O1/pollow[P]MIPSClide/assembler.cpp
// Function: Assembler::split()
void Assembler::split() {
    stringstream buffer( content );
    string item;
    while( getline(buffer, item, '\n') ) {
        transform(item.begin(), item.end(), item.begin(), ::tolower);
        if (item.length() > 1) statements.push_back(item);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %rbx
leaq -0x1d0(%rbp), %rdi
movq %rbx, %rsi
movl $0x18, %edx
callq 0x54a0
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x20, %rbx
leaq -0x48(%rbp), %r15
leaq -0x1d0(%rbp), %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x5590
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
movq -0x48(%rbp), %r12
jne 0xce4a
movq -0x40(%rbp), %r13
testq %r13, %r13
je 0xce36
xorl %r14d, %r14d
movsbl (%r12,%r14), %edi
callq 0x5430
movb %al, (%r12,%r14)
incq %r14
cmpq %r14, %r13
jne 0xce20
cmpq $0x2, -0x40(%rbp)
jb 0xcdee
movq %rbx, %rdi
movq %r15, %rsi
callq 0xdfe4
jmp 0xcdee
leaq -0x38(%rbp), %rax
cmpq %rax, %r12
je 0xce5b
movq %r12, %rdi
callq 0x52d0
movq 0x1e106(%rip), %rsi     # 0x2af68
leaq -0x1d0(%rbp), %rdi
callq 0x5270
leaq -0x150(%rbp), %rdi
callq 0x50e0
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0xcea1
callq 0x52d0
movq 0x1e0c0(%rip), %rsi     # 0x2af68
leaq -0x1d0(%rbp), %rdi
callq 0x5270
leaq -0x150(%rbp), %rdi
callq 0x50e0
movq %rbx, %rdi
callq 0x5560
// File: /workspace/github_cpp_makefile_star2_O1/pollow[P]MIPSClide/./instruction.h
// Function: Instruction::Instruction(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, int, char)
Instruction(string &&_command, string &&_reg1, string &&_reg2, int num, char _type) :
        command(_command), reg1(_reg1), reg2(_reg2), type(_type) {
            if ( command == "sll" || command == "sra" || command == "srl" ) {
                // special case for shamt
                type = 'R';
                shamt = num;
                has_shamt = true;
            } else if ( type == 'I' ) {
                imm = num;
            }
            reg_num = 2;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, -0x30(%rbp)
movl %r8d, -0x2c(%rbp)
movq %rcx, %r13
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x38(%rbp)
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x9e42
leaq 0x20(%rbx), %r12
leaq 0x30(%rbx), %r14
movq %r14, 0x20(%rbx)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x9e42
leaq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
movq %rax, 0x40(%rbx)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
callq 0x9e42
leaq 0x70(%rbx), %rax
movq %rax, 0x60(%rbx)
movq $0x0, 0x68(%rbx)
xorl %eax, %eax
movb %al, 0x70(%rbx)
movl $0x0, 0x8c(%rbx)
movl -0x30(%rbp), %ecx
movb %cl, 0x90(%rbx)
movw $0x0, 0x91(%rbx)
movb %al, 0x93(%rbx)
leaq 0x13c13(%rip), %rsi     # 0x214bc
movq %rbx, %rdi
callq 0x50b0
testl %eax, %eax
je 0xd8f0
leaq 0x13c04(%rip), %rsi     # 0x214c0
movq %rbx, %rdi
callq 0x50b0
testl %eax, %eax
je 0xd8f0
leaq 0x13bf5(%rip), %rsi     # 0x214c4
movq %rbx, %rdi
callq 0x50b0
testl %eax, %eax
je 0xd8f0
cmpb $0x49, 0x90(%rbx)
jne 0xd910
movl -0x2c(%rbp), %eax
movw %ax, 0x88(%rbx)
jmp 0xd910
movw $0x152, 0x90(%rbx)      # imm = 0x152
movl 0x86(%rbx), %eax
movl -0x2c(%rbp), %ecx
andl $0x1f, %ecx
andl $-0x20, %eax
orl %ecx, %eax
movl %eax, 0x86(%rbx)
movl $0x2, 0x80(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%r12), %rdi
cmpq %r14, %rdi
je 0xd93f
callq 0x52d0
jmp 0xd93f
movq %rax, %r15
movq (%rbx), %rdi
cmpq -0x38(%rbp), %rdi
je 0xd94d
callq 0x52d0
movq %r15, %rdi
callq 0x5560
nop
// File: /workspace/github_cpp_makefile_star2_O1/alexandres[P]terashuf/terashuf.cc
// Function: shufFlushBuf(char*, std::vector<unsigned long, std::allocator<unsigned long>>&, std::mersenne_twister_engine<unsigned long, 64ul, 312ul, 156ul, 31ul, 13043109905998158313ul, 29ul, 6148914691236517205ul, 17ul, 8202884508482404352ul, 37ul, 18444473444759240704ul, 43ul, 6364136223846793005ul>&, char, _IO_FILE*)
ll shufFlushBuf(char *buf, std::vector<ll> &shufIndexes, std::mt19937_64 &rng, char sep, FILE *f)
{
    std::shuffle(shufIndexes.begin(), shufIndexes.end(), rng);
    ll bytesWritten = 0;
    for (auto line : shufIndexes)
    {
        ll j = 0;
        while (*(buf + line + j) != sep)
            j++;
        ll bytesToWrite = j + 1;
        bytesWritten += bytesToWrite;
        if (fwrite(buf + line, sizeof(char), bytesToWrite, f) !=
            size_t(bytesToWrite))
        {
            fprintf(stderr, "\nFATAL ERROR: failed to write line to disk. is there space left in $TMPDIR?\n");
            exit(1);
        }
    }
    return bytesWritten;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, (%rsp)
movl %ecx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
callq 0x1f8e
movq (%r15), %r13
movq 0x8(%r15), %rbx
cmpq %rbx, %r13
je 0x1d4e
xorl %eax, %eax
movq %rax, %r15
movq (%r13), %rdi
addq %r14, %rdi
xorl %r12d, %r12d
movq %r12, %rax
incq %r12
cmpb %bpl, (%rdi,%rax)
jne 0x1d1a
movl $0x1, %esi
movq %r12, %rdx
movq (%rsp), %rcx
callq 0x1200
cmpq %r12, %rax
jne 0x1d63
leaq (%r15,%r12), %rax
addq $0x8, %r13
cmpq %rbx, %r13
jne 0x1d0d
addq %r12, %r15
jmp 0x1d51
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1a70
// File: /workspace/github_cpp_makefile_star2_O1/alexandres[P]terashuf/terashuf.cc
// Function: bufferedFgetc(TmpFile&)
char bufferedFgetc(TmpFile &f)
{
    if (!f.eof && f.bufPos == f.bufN)
    {
        f.bufN = fread(f.buf, sizeof(char), IO_CHUNK, f.f);
        f.bufPos = 0;
        if (!f.bufN)
            f.eof = true;
    }
    if (f.eof)
        return EOF;
    return f.buf[f.bufPos++];
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x30(%rdi)
jne 0x1da7
movq 0x20(%rbx), %rax
cmpq 0x28(%rbx), %rax
jne 0x1da7
movq (%rbx), %rcx
movq 0x18(%rbx), %rdi
movl $0x1, %esi
movl $0x10000, %edx          # imm = 0x10000
callq 0x11a0
movq %rax, 0x28(%rbx)
movq $0x0, 0x20(%rbx)
testq %rax, %rax
jne 0x1da7
movb $0x1, 0x30(%rbx)
movb $-0x1, %al
cmpb $0x0, 0x30(%rbx)
jne 0x1dc2
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%rbx)
movb (%rax,%rcx), %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/alexandres[P]terashuf/terashuf.cc
// Function: FenwickTree::FenwickTree(std::vector<unsigned long, std::allocator<unsigned long>> const&)
FenwickTree(const std::vector<ll> &w)
    {
        n = w.size();
        d = int(std::pow(2, std::ceil(std::log2(n)))); // number of intermediates
        S = std::vector<ll>(2 * d, 0);                 // intermediates + leaves
        heapify(w);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %r15d, %r15d
movq %r15, 0x10(%rdi)
movq 0x8(%rsi), %rax
subq (%rsi), %rax
shrq $0x3, %rax
movl %eax, 0x18(%rdi)
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
callq 0x11f0
callq 0x1040
callq 0x10c0
cvttsd2si %xmm0, %eax
movl %eax, 0x1c(%rbx)
addl %eax, %eax
movslq %eax, %rsi
leaq 0x10(%rsp), %rdx
movq %r15, (%rdx)
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rcx
callq 0x21fe
leaq 0x18(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22f8
movq (%r15), %rdi
testq %rdi, %rdi
je 0x2180
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x1110
movq %rbx, %rdi
movq %r14, %rsi
callq 0x227c
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x21ac
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x1110
movq %r14, %rdi
callq 0x11e0
// File: /workspace/github_cpp_makefile_star2_O1/alexandres[P]terashuf/terashuf.cc
// Function: FenwickTree::findIndexAndDraw(unsigned long)
int findIndexAndDraw(ll p)
    {
        // Draw from from sumheap, O(log n) per draw.
        // Use binary search to find the index of the largest cumsum (represented as a
        // heap) value that is less than the probe p.
        ll i = 1;
        while (true)
        {
            S[i]--; // draw
            if (i >= d)
                break;
            // Determine if the value is in the left or right subtree.
            i *= 2;         // Point at left child
            ll left = S[i]; // Cumsum under left subtree.
            if (p > left)
            {              // Value is in right subtree.
                p -= left; // Subtract cumsum from left subtree
                i++;       // Point at right child
            }
        }
        return i - d; // return index after subtracting internal nodes
    }

// Assembly:
movq (%rdi), %rdx
movslq 0x1c(%rdi), %rcx
decq 0x8(%rdx)
movl $0x1, %eax
cmpq $0x2, %rcx
jb 0x21fa
movl $0x1, %eax
xorl %edi, %edi
movq %rax, %r8
shlq $0x4, %r8
movq (%rdx,%r8), %r8
xorl %r9d, %r9d
cmpq %r8, %rsi
seta %r9b
leaq (%r9,%rax,2), %rax
cmovbeq %rdi, %r8
subq %r8, %rsi
decq (%rdx,%rax,8)
cmpq %rcx, %rax
jb 0x21d1
subl %ecx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/alexandres[P]terashuf/terashuf.cc
// Function: FenwickTree::heapify(std::vector<unsigned long, std::allocator<unsigned long>> const&)
void heapify(const std::vector<ll> &w)
    {
        // Create sumheap from weights `w` in O(n) time.
        for (int i = 0; i < n; i++)
            S[d + i] = w[i]; // store `w` at leaves.
        for (int i = d - 1; i > 0; i--)
            S[i] = S[2 * i] + S[2 * i + 1];
    }

// Assembly:
movslq 0x18(%rdi), %rax
testq %rax, %rax
jle 0x22a5
movq (%rsi), %rcx
movslq 0x1c(%rdi), %rdx
shlq $0x3, %rdx
addq (%rdi), %rdx
xorl %esi, %esi
movq (%rcx,%rsi,8), %r8
movq %r8, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x2295
movslq 0x1c(%rdi), %rdx
cmpq $0x2, %rdx
jl 0x22da
movq (%rdi), %rax
leaq 0x1(%rdx), %rcx
shlq $0x4, %rdx
addq %rax, %rdx
addq $-0x8, %rdx
movq (%rdx), %rsi
addq -0x8(%rdx), %rsi
movq %rsi, -0x10(%rax,%rcx,8)
decq %rcx
addq $-0x10, %rdx
cmpq $0x2, %rcx
jg 0x22c1
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Rubenmp[P]Rubik/src/defineRubik.cpp
// Function: Rubik::equivalentNumber(char const&) const
int Rubik::equivalentNumber(const char& c) const{
   int number = 0;
   if (tolower(c) == 'w')
      number = 1;
   else if (tolower(c) == 'o')
      number = 2;
   else if (tolower(c) == 'g')
      number = 3;
   else if (tolower(c) == 'r')
      number = 4;
   else if (tolower(c) == 'l')
      number = 5;
   else if (tolower(c) == 'y')
      number = 6;

  return number;
}

// Assembly:
pushq %rax
movsbl (%rsi), %edi
callq 0x2210
cmpl $0x71, %eax
jg 0x35ce
cmpl $0x67, %eax
je 0x35e4
cmpl $0x6c, %eax
je 0x35f6
cmpl $0x6f, %eax
jne 0x35f2
movl $0x2, %eax
jmp 0x3602
cmpl $0x72, %eax
je 0x35eb
cmpl $0x77, %eax
je 0x35fd
cmpl $0x79, %eax
jne 0x35f2
movl $0x6, %eax
jmp 0x3602
movl $0x3, %eax
jmp 0x3602
movl $0x4, %eax
jmp 0x3602
xorl %eax, %eax
jmp 0x3602
movl $0x5, %eax
jmp 0x3602
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/Rubenmp[P]Rubik/src/defineRubik.cpp
// Function: Rubik::sequence(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<char, std::allocator<char>>&)
void Rubik::sequence(const string& sec, vector<char>& solution){
   for (unsigned int i=0; i<sec.size(); ++i){
      if ( sec[i] == 'R' )
         R(solution);
      else if ( sec[i] == 'r')
         r(solution);
      else if ( sec[i] == 'L')
         L(solution);
      else if ( sec[i] == 'l')
         l(solution);
      else if ( sec[i] == 'D')
         D(solution);
      else if ( sec[i] == 'd')
         d(solution);
      else if ( sec[i] == 'U')
         U(solution);
      else if ( sec[i] == 'u')
         u(solution);
      else if ( sec[i] == 'F')
         F(solution);
      else if ( sec[i] == 'f')
         f(solution);
      else if ( sec[i] == 'B')
         B(solution);
      else if ( sec[i] == 'b')
         b(solution);
      else
        cerr << "Error: invalid movement " << sec[i] << endl;
   }
}

// Assembly:
cmpq $0x0, 0x8(%rsi)
je 0x3d44
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %r13d
xorl %ebp, %ebp
movq 0xe41e(%rip), %r12      # 0x11ff0
movq (%r14), %rax
movzbl (%rax,%rbp), %eax
cmpl $0x61, %eax
jg 0x3c0e
cmpl $0x4b, %eax
jg 0x3c3a
cmpl $0x42, %eax
je 0x3c80
cmpl $0x44, %eax
je 0x3cba
cmpl $0x46, %eax
jne 0x3cee
movq %r15, %rdi
movq %rbx, %rsi
callq 0x415a
jmp 0x3d26
cmpl $0x6b, %eax
jg 0x3c61
cmpl $0x62, %eax
je 0x3c90
cmpl $0x64, %eax
je 0x3cc7
cmpl $0x66, %eax
jne 0x3cee
movq %r15, %rdi
movq %rbx, %rsi
callq 0x41f6
jmp 0x3d26
cmpl $0x4c, %eax
je 0x3ca0
cmpl $0x52, %eax
je 0x3cd4
cmpl $0x55, %eax
jne 0x3cee
movq %r15, %rdi
movq %rbx, %rsi
callq 0x406e
jmp 0x3d26
cmpl $0x6c, %eax
je 0x3cad
cmpl $0x72, %eax
je 0x3ce1
cmpl $0x75, %eax
jne 0x3cee
movq %r15, %rdi
movq %rbx, %rsi
callq 0x40e4
jmp 0x3d26
movq %r15, %rdi
movq %rbx, %rsi
callq 0x429a
jmp 0x3d26
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4340
jmp 0x3d26
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3e64
jmp 0x3d26
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3ef0
jmp 0x3d26
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3f82
jmp 0x3d26
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3ff8
jmp 0x3d26
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3d46
jmp 0x3d26
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3dd8
jmp 0x3d26
movl $0x18, %edx
movq %r12, %rdi
leaq 0x9a08(%rip), %rsi      # 0xd705
callq 0x21d0
movq (%r14), %rax
movb (%rax,%rbp), %al
movb %al, 0x7(%rsp)
movl $0x1, %edx
movq %r12, %rdi
leaq 0x7(%rsp), %rsi
callq 0x21d0
movq %rax, %rdi
callq 0x20b0
movl %r13d, %ebp
incl %r13d
cmpq %rbp, 0x8(%r14)
ja 0x3bd2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Rubenmp[P]Rubik/src/defineRubik.cpp
// Function: Rubik::R(std::vector<char, std::allocator<char>>&)
void Rubik::R (vector<char>& solution){
   Corner aux;
   Edge laux;

   laux = edge[1];
   edge[1] = edge[8];
   edge[8] = edge[5];
   edge[5] = edge[9];
   edge[9] = laux;

   aux.left = corner[1].right;
   aux.right = corner[1].up;
   aux.up = corner[1].left;

   corner[1].left = corner[5].up;
   corner[1].right = corner[5].right;
   corner[1].up = corner[5].left;

   corner[5].left = corner[6].up;
   corner[5].right = corner[6].left;
   corner[5].up = corner[6].right;

   corner[6].left = corner[2].left;
   corner[6].right = corner[2].up;
   corner[6].up = corner[2].right;

   corner[2] = aux;
   solution.push_back('R');
}

// Assembly:
pushq %rax
movq %rsi, %rax
movzwl 0x16(%rdi), %ecx
movzwl 0x8(%rdi), %edx
movzwl 0x10(%rdi), %esi
movw %cx, 0x8(%rdi)
movw %si, 0x16(%rdi)
movzwl 0x18(%rdi), %ecx
movw %cx, 0x10(%rdi)
movw %dx, 0x18(%rdi)
movb 0x23(%rdi), %cl
movb 0x21(%rdi), %dl
movb 0x22(%rdi), %sil
movzwl 0x2d(%rdi), %r8d
rolw $0x8, %r8w
movb 0x2f(%rdi), %r9b
movb %r9b, 0x23(%rdi)
movw %r8w, 0x21(%rdi)
movb 0x30(%rdi), %r8b
movb %r8b, 0x2e(%rdi)
movb 0x31(%rdi), %r8b
movb %r8b, 0x2f(%rdi)
movb 0x32(%rdi), %r8b
movb %r8b, 0x2d(%rdi)
movb 0x25(%rdi), %r8b
movb %r8b, 0x31(%rdi)
movb 0x24(%rdi), %r8b
movb %r8b, 0x32(%rdi)
movb 0x26(%rdi), %r8b
movb %r8b, 0x30(%rdi)
movb %sil, 0x24(%rdi)
movb %cl, 0x25(%rdi)
movb %dl, 0x26(%rdi)
leaq 0x7(%rsp), %rsi
movb $0x52, (%rsi)
movq %rax, %rdi
callq 0xc8c2
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Rubenmp[P]Rubik/src/defineRubik.cpp
// Function: Rubik::r(std::vector<char, std::allocator<char>>&)
void Rubik::r (vector<char>& solution){
   Corner aux;
   Edge laux;

   laux = edge[1];
   edge[1] = edge[9];
   edge[9] = edge[5];
   edge[5] = edge[8];
   edge[8] = laux;

   aux.left = corner[1].up;
   aux.right = corner[1].right;
   aux.up = corner[1].left;

   corner[1].left = corner[2].up;
   corner[1].right = corner[2].left;
   corner[1].up = corner[2].right;

   corner[2].left = corner[6].left;
   corner[2].right = corner[6].up;
   corner[2].up = corner[6].right;

   corner[6].left = corner[5].right;
   corner[6].right = corner[5].up;
   corner[6].up = corner[5].left;

   corner[5] = aux;
   solution.push_back('r');
}

// Assembly:
pushq %rax
movq %rsi, %rax
movzwl 0x18(%rdi), %ecx
movzwl 0x8(%rdi), %edx
movzwl 0x10(%rdi), %esi
movw %cx, 0x8(%rdi)
movw %si, 0x18(%rdi)
movzwl 0x16(%rdi), %ecx
movw %cx, 0x10(%rdi)
movw %dx, 0x16(%rdi)
movb 0x21(%rdi), %cl
movb 0x23(%rdi), %dl
movb 0x22(%rdi), %sil
movzwl 0x24(%rdi), %r8d
movw %r8w, 0x22(%rdi)
movb 0x26(%rdi), %r8b
movb %r8b, 0x21(%rdi)
movb 0x31(%rdi), %r8b
movb %r8b, 0x25(%rdi)
movb 0x30(%rdi), %r8b
movb %r8b, 0x26(%rdi)
movb 0x32(%rdi), %r8b
movb %r8b, 0x24(%rdi)
movb 0x2f(%rdi), %r8b
movb %r8b, 0x31(%rdi)
movb 0x2d(%rdi), %r8b
movb %r8b, 0x32(%rdi)
movb 0x2e(%rdi), %r8b
movb %r8b, 0x30(%rdi)
movb %sil, 0x2d(%rdi)
movb %cl, 0x2e(%rdi)
movb %dl, 0x2f(%rdi)
leaq 0x7(%rsp), %rsi
movb $0x72, (%rsi)
movq %rax, %rdi
callq 0xc8c2
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/Rubenmp[P]Rubik/src/defineRubik.cpp
// Function: Rubik::L(std::vector<char, std::allocator<char>>&)
void Rubik::L (vector<char>& solution){
   Corner aux;
   Edge laux;

   laux = edge[3];
   edge[3] = edge[10];
   edge[10] = edge[7];
   edge[7] = edge[11];
   edge[11] = laux;

   aux.left = corner[0].left;
   aux.right = corner[0].up;
   aux.up = corner[0].right;

   corner[0].left = corner[3].right;
   corner[0].right = corner[3].up;
   corner[0].up = corner[3].left;

   corner[3].left = corner[7].up;
   corner[3].right = corner[7].right;
   corner[3].up = corner[7].left;

   corner[7].left = corner[4].up;
   corner[7].right = corner[4].left;
   corner[7].up = corner[4].right;

   corner[4] = aux;
   solution.push_back('L');
}

// Assembly:
pushq %rax
movq %rsi, %rax
movzwl 0x1a(%rdi), %ecx
movzwl 0xc(%rdi), %edx
movzwl 0x14(%rdi), %esi
movw %cx, 0xc(%rdi)
movw %si, 0x1a(%rdi)
movzwl 0x1c(%rdi), %ecx
movw %cx, 0x14(%rdi)
movw %dx, 0x1c(%rdi)
movb 0x1f(%rdi), %cl
movb 0x1e(%rdi), %dl
movb 0x20(%rdi), %sil
movb 0x27(%rdi), %r8b
movb %r8b, 0x20(%rdi)
movzwl 0x28(%rdi), %r8d
movw %r8w, 0x1e(%rdi)
movb 0x33(%rdi), %r8b
movb %r8b, 0x28(%rdi)
movb 0x35(%rdi), %r8b
movb %r8b, 0x29(%rdi)
movb 0x34(%rdi), %r8b
movb %r8b, 0x27(%rdi)
movb 0x2a(%rdi), %r8b
movb %r8b, 0x34(%rdi)
movb 0x2b(%rdi), %r8b
movb %r8b, 0x35(%rdi)
movb 0x2c(%rdi), %r8b
movb %r8b, 0x33(%rdi)
movb %sil, 0x2a(%rdi)
movb %cl, 0x2b(%rdi)
movb %dl, 0x2c(%rdi)
leaq 0x7(%rsp), %rsi
movb $0x4c, (%rsi)
movq %rax, %rdi
callq 0xc8c2
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/Rubenmp[P]Rubik/src/defineRubik.cpp
// Function: Rubik::l(std::vector<char, std::allocator<char>>&)
void Rubik::l (vector<char>& solution){
   Corner aux;
   Edge laux;

   laux = edge[3];
   edge[3] = edge[11];
   edge[11] = edge[7];
   edge[7] = edge[10];
   edge[10] = laux;

   aux.left = corner[0].up;
   aux.right = corner[0].left;
   aux.up = corner[0].right;

   corner[0].left = corner[4].left;
   corner[0].right = corner[4].up;
   corner[0].up = corner[4].right;

   corner[4].left = corner[7].right;
   corner[4].right = corner[7].up;
   corner[4].up = corner[7].left;

   corner[7].left = corner[3].up;
   corner[7].right = corner[3].right;
   corner[7].up = corner[3].left;

   corner[3] = aux;
   solution.push_back('l');
}

// Assembly:
pushq %rax
movq %rsi, %rax
movzwl 0x1c(%rdi), %ecx
movzwl 0xc(%rdi), %edx
movzwl 0x14(%rdi), %esi
movw %cx, 0xc(%rdi)
movw %si, 0x1c(%rdi)
movzwl 0x1a(%rdi), %ecx
movw %cx, 0x14(%rdi)
movw %dx, 0x1a(%rdi)
movb 0x1e(%rdi), %cl
movb 0x1f(%rdi), %dl
movb 0x20(%rdi), %sil
movzwl 0x2b(%rdi), %r8d
rolw $0x8, %r8w
movb 0x2a(%rdi), %r9b
movb %r9b, 0x20(%rdi)
movw %r8w, 0x1e(%rdi)
movb 0x35(%rdi), %r8b
movb %r8b, 0x2b(%rdi)
movb 0x33(%rdi), %r8b
movb %r8b, 0x2c(%rdi)
movb 0x34(%rdi), %r8b
movb %r8b, 0x2a(%rdi)
movb 0x27(%rdi), %r8b
movb %r8b, 0x34(%rdi)
movb 0x29(%rdi), %r8b
movb %r8b, 0x35(%rdi)
movb 0x28(%rdi), %r8b
movb %r8b, 0x33(%rdi)
movb %sil, 0x27(%rdi)
movb %cl, 0x28(%rdi)
movb %dl, 0x29(%rdi)
leaq 0x7(%rsp), %rsi
movb $0x6c, (%rsi)
movq %rax, %rdi
callq 0xc8c2
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Rubenmp[P]Rubik/src/defineRubik.cpp
// Function: Rubik::D(std::vector<char, std::allocator<char>>&)
void Rubik::D (vector<char>& solution){
   Corner aux;
   Edge laux;

   laux = edge[4];
   edge[4] = edge[7];
   edge[7] = edge[6];
   edge[6] = edge[5];
   edge[5] = laux;

   aux = corner[5];
   corner[5] = corner[4];
   corner[4] = corner[7];
   corner[7] = corner[6];
   corner[6] = aux ;
   solution.push_back('D');
}

// Assembly:
pushq %rax
movq %rsi, %rax
movl 0xe(%rdi), %ecx
movzwl 0x14(%rdi), %edx
movw %dx, 0xe(%rdi)
movzwl 0x12(%rdi), %edx
movw %dx, 0x14(%rdi)
movl %ecx, 0x10(%rdi)
movb 0x2f(%rdi), %cl
movb %cl, 0x6(%rsp)
movzwl 0x2d(%rdi), %ecx
movw %cx, 0x4(%rsp)
movzwl 0x2a(%rdi), %ecx
movw %cx, 0x2d(%rdi)
movb 0x2c(%rdi), %cl
movb %cl, 0x2f(%rdi)
movzwl 0x33(%rdi), %ecx
movw %cx, 0x2a(%rdi)
movb 0x35(%rdi), %cl
movb %cl, 0x2c(%rdi)
movb 0x32(%rdi), %cl
movb %cl, 0x35(%rdi)
movzwl 0x30(%rdi), %ecx
movw %cx, 0x33(%rdi)
movb 0x6(%rsp), %cl
movb %cl, 0x32(%rdi)
movzwl 0x4(%rsp), %ecx
movw %cx, 0x30(%rdi)
leaq 0x7(%rsp), %rsi
movb $0x44, (%rsi)
movq %rax, %rdi
callq 0xc8c2
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/Rubenmp[P]Rubik/src/defineRubik.cpp
// Function: Rubik::d(std::vector<char, std::allocator<char>>&)
void Rubik::d (vector<char>& solution){
   Corner aux;
   Edge laux;

   laux = edge[4];
   edge[4] = edge[5];
   edge[5] = edge[6];
   edge[6] = edge[7];
   edge[7] = laux;

   aux = corner[5];
   corner[5] = corner[6];
   corner[6] = corner[7];
   corner[7] = corner[4];
   corner[4] = aux ;
   solution.push_back('d');
}

// Assembly:
pushq %rax
movq %rsi, %rax
movzwl 0xe(%rdi), %ecx
movzwl 0x10(%rdi), %edx
movw %dx, 0xe(%rdi)
movl 0x12(%rdi), %edx
movl %edx, 0x10(%rdi)
movw %cx, 0x14(%rdi)
movb 0x2f(%rdi), %cl
movb %cl, 0x6(%rsp)
movzwl 0x2d(%rdi), %ecx
movw %cx, 0x4(%rsp)
movzwl 0x30(%rdi), %ecx
movw %cx, 0x2d(%rdi)
movb 0x32(%rdi), %cl
movb %cl, 0x2f(%rdi)
movzwl 0x33(%rdi), %ecx
movw %cx, 0x30(%rdi)
movb 0x35(%rdi), %cl
movb %cl, 0x32(%rdi)
movb 0x2c(%rdi), %cl
movb %cl, 0x35(%rdi)
movzwl 0x2a(%rdi), %ecx
movw %cx, 0x33(%rdi)
movb 0x6(%rsp), %cl
movb %cl, 0x2c(%rdi)
movzwl 0x4(%rsp), %ecx
movw %cx, 0x2a(%rdi)
leaq 0x7(%rsp), %rsi
movb $0x64, (%rsi)
movq %rax, %rdi
callq 0xc8c2
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/Rubenmp[P]Rubik/src/defineRubik.cpp
// Function: Rubik::U(std::vector<char, std::allocator<char>>&)
void Rubik::U (vector<char>& solution){
   Corner aux;
   Edge laux;

   laux = edge[0];
   edge[0] = edge[1];
   edge[1] = edge[2];
   edge[2] = edge[3];
   edge[3] = laux;

   aux = corner[0];
   corner[0] = corner[1];
   corner[1] = corner[2];
   corner[2] = corner[3];
   corner[3] = aux;
   solution.push_back('U');
}

// Assembly:
pushq %rax
movq %rsi, %rax
movzwl 0x6(%rdi), %ecx
movzwl 0x8(%rdi), %edx
movw %dx, 0x6(%rdi)
movl 0xa(%rdi), %edx
movl %edx, 0x8(%rdi)
movw %cx, 0xc(%rdi)
movb 0x20(%rdi), %cl
movb %cl, 0x6(%rsp)
movzwl 0x1e(%rdi), %ecx
movw %cx, 0x4(%rsp)
movzwl 0x21(%rdi), %ecx
movw %cx, 0x1e(%rdi)
movb 0x23(%rdi), %cl
movb %cl, 0x20(%rdi)
movzwl 0x24(%rdi), %ecx
movw %cx, 0x21(%rdi)
movb 0x26(%rdi), %cl
movb %cl, 0x23(%rdi)
movb 0x29(%rdi), %cl
movb %cl, 0x26(%rdi)
movzwl 0x27(%rdi), %ecx
movw %cx, 0x24(%rdi)
movb 0x6(%rsp), %cl
movb %cl, 0x29(%rdi)
movzwl 0x4(%rsp), %ecx
movw %cx, 0x27(%rdi)
leaq 0x7(%rsp), %rsi
movb $0x55, (%rsi)
movq %rax, %rdi
callq 0xc8c2
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/Rubenmp[P]Rubik/src/defineRubik.cpp
// Function: Rubik::u(std::vector<char, std::allocator<char>>&)
void Rubik::u (vector<char>& solution){
   Corner aux;
   Edge laux;

   laux = edge[0];
   edge[0] = edge[3];
   edge[3] = edge[2];
   edge[2] = edge[1];
   edge[1] = laux;

   aux = corner[1];
   corner[1] = corner[0];
   corner[0] = corner[3];
   corner[3] = corner[2];
   corner[2] = aux;
   solution.push_back('u');
}

// Assembly:
pushq %rax
movq %rsi, %rax
movl 0x6(%rdi), %ecx
movzwl 0xc(%rdi), %edx
movw %dx, 0x6(%rdi)
movzwl 0xa(%rdi), %edx
movw %dx, 0xc(%rdi)
movl %ecx, 0x8(%rdi)
movb 0x23(%rdi), %cl
movb %cl, 0x6(%rsp)
movzwl 0x21(%rdi), %ecx
movw %cx, 0x4(%rsp)
movzwl 0x1e(%rdi), %ecx
movw %cx, 0x21(%rdi)
movb 0x20(%rdi), %cl
movb %cl, 0x23(%rdi)
movzwl 0x27(%rdi), %ecx
movw %cx, 0x1e(%rdi)
movb 0x29(%rdi), %cl
movb %cl, 0x20(%rdi)
movb 0x26(%rdi), %cl
movb %cl, 0x29(%rdi)
movzwl 0x24(%rdi), %ecx
movw %cx, 0x27(%rdi)
movb 0x6(%rsp), %cl
movb %cl, 0x26(%rdi)
movzwl 0x4(%rsp), %ecx
movw %cx, 0x24(%rdi)
leaq 0x7(%rsp), %rsi
movb $0x75, (%rsi)
movq %rax, %rdi
callq 0xc8c2
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/Rubenmp[P]Rubik/src/defineRubik.cpp
// Function: Rubik::F(std::vector<char, std::allocator<char>>&)
void Rubik::F (vector<char>& solution){
   Corner aux;
   Edge laux;

   laux.down = edge[0].up;
   laux.up = edge[0].down;
   edge[0].up = edge[11].down;
   edge[0].down = edge[11].up;
   edge[11].up = edge[4].down;
   edge[11].down = edge[4].up;
   edge[4].up = edge[8].down;
   edge[4].down = edge[8].up;
   edge[8] = laux;

   aux.left = corner[1].left;
   aux.right = corner[1].up;
   aux.up = corner[1].right;

   corner[1].left = corner[0].right;
   corner[1].right = corner[0].up;
   corner[1].up = corner[0].left;

   corner[0].left = corner[4].up;
   corner[0].right = corner[4].right;
   corner[0].up = corner[4].left;

   corner[4].left = corner[5].up;
   corner[4].right = corner[5].left;
   corner[4].up = corner[5].right;

   corner[5] = aux;
   solution.push_back('F');
}

// Assembly:
pushq %rax
movq %rsi, %rax
movzwl 0x6(%rdi), %ecx
movzwl 0xe(%rdi), %edx
rolw $0x8, %cx
movzwl 0x1c(%rdi), %esi
rolw $0x8, %si
movw %si, 0x6(%rdi)
rolw $0x8, %dx
movw %dx, 0x1c(%rdi)
movzwl 0x16(%rdi), %edx
rolw $0x8, %dx
movw %dx, 0xe(%rdi)
movw %cx, 0x16(%rdi)
movb 0x22(%rdi), %cl
movb 0x21(%rdi), %dl
movb 0x23(%rdi), %sil
movb 0x1e(%rdi), %r8b
movb %r8b, 0x23(%rdi)
movzwl 0x1f(%rdi), %r8d
movw %r8w, 0x21(%rdi)
movb 0x2a(%rdi), %r8b
movb %r8b, 0x1f(%rdi)
movb 0x2c(%rdi), %r8b
movb %r8b, 0x20(%rdi)
movb 0x2b(%rdi), %r8b
movb %r8b, 0x1e(%rdi)
movb 0x2d(%rdi), %r8b
movb %r8b, 0x2b(%rdi)
movb 0x2e(%rdi), %r8b
movb %r8b, 0x2c(%rdi)
movb 0x2f(%rdi), %r8b
movb %r8b, 0x2a(%rdi)
movb %sil, 0x2d(%rdi)
movb %cl, 0x2e(%rdi)
movb %dl, 0x2f(%rdi)
leaq 0x7(%rsp), %rsi
movb $0x46, (%rsi)
movq %rax, %rdi
callq 0xc8c2
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/Rubenmp[P]Rubik/src/defineRubik.cpp
// Function: Rubik::f(std::vector<char, std::allocator<char>>&)
void Rubik::f (vector<char>& solution){
   Corner aux;
   Edge laux;

   laux.up = edge[8].down;
   laux.down = edge[8].up;
   edge[8].up = edge[4].down;
   edge[8].down = edge[4].up;
   edge[4].up = edge[11].down;
   edge[4].down = edge[11].up;
   edge[11].up = edge[0].down;
   edge[11].down = edge[0].up;
   edge[0] = laux;

   aux.left = corner[1].up;
   aux.right = corner[1].left;
   aux.up = corner[1].right;

   corner[1].left = corner[5].left;
   corner[1].right = corner[5].up;
   corner[1].up = corner[5].right;

   corner[5].left = corner[4].right;
   corner[5].right = corner[4].up;
   corner[5].up = corner[4].left;

   corner[4].left = corner[0].up;
   corner[4].right = corner[0].right;
   corner[4].up = corner[0].left;

   corner[0] = aux;
   solution.push_back('f');
}

// Assembly:
pushq %rax
movzwl 0x16(%rdi), %ecx
rolw $0x8, %cx
movzwl 0x6(%rdi), %edx
movzwl 0xe(%rdi), %eax
rolw $0x8, %ax
movw %ax, 0x16(%rdi)
movzwl 0x1c(%rdi), %r8d
rolw $0x8, %r8w
movq %rsi, %rax
movw %r8w, 0xe(%rdi)
rolw $0x8, %dx
movw %dx, 0x1c(%rdi)
movw %cx, 0x6(%rdi)
movb 0x21(%rdi), %cl
movb 0x22(%rdi), %dl
movb 0x23(%rdi), %sil
movzwl 0x2d(%rdi), %r8d
rolw $0x8, %r8w
movw %r8w, 0x22(%rdi)
movb 0x2f(%rdi), %r8b
movb %r8b, 0x21(%rdi)
movb 0x2c(%rdi), %r8b
movb %r8b, 0x2e(%rdi)
movb 0x2a(%rdi), %r8b
movb %r8b, 0x2f(%rdi)
movb 0x2b(%rdi), %r8b
movb %r8b, 0x2d(%rdi)
movb 0x1e(%rdi), %r8b
movb %r8b, 0x2b(%rdi)
movb 0x20(%rdi), %r8b
movb %r8b, 0x2c(%rdi)
movb 0x1f(%rdi), %r8b
movb %r8b, 0x2a(%rdi)
movb %sil, 0x1e(%rdi)
movb %cl, 0x1f(%rdi)
movb %dl, 0x20(%rdi)
leaq 0x7(%rsp), %rsi
movb $0x66, (%rsi)
movq %rax, %rdi
callq 0xc8c2
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/Rubenmp[P]Rubik/src/defineRubik.cpp
// Function: Rubik::B(std::vector<char, std::allocator<char>>&)
void Rubik::B (vector<char>& solution){
   Corner aux;
   Edge laux;

   laux.up = edge[9].down;
   laux.down = edge[9].up;
   edge[9].up = edge[6].down;
   edge[9].down = edge[6].up;
   edge[6].up = edge[10].down;
   edge[6].down = edge[10].up;
   edge[10].up = edge[2].down;
   edge[10].down = edge[2].up;
   edge[2] = laux;

   aux.left = corner[2].right;
   aux.right = corner[2].up;
   aux.up = corner[2].left;

   corner[2].left = corner[6].up;
   corner[2].right = corner[6].right;
   corner[2].up = corner[6].left;

   corner[6].left = corner[7].up;
   corner[6].right = corner[7].left;
   corner[6].up = corner[7].right;

   corner[7].left = corner[3].left;
   corner[7].right = corner[3].up;
   corner[7].up = corner[3].right;

   corner[3] = aux;
   solution.push_back('W');
}

// Assembly:
pushq %rax
movzwl 0x18(%rdi), %ecx
rolw $0x8, %cx
movzwl 0xa(%rdi), %edx
movzwl 0x12(%rdi), %eax
rolw $0x8, %ax
movw %ax, 0x18(%rdi)
movzwl 0x1a(%rdi), %r8d
rolw $0x8, %r8w
movq %rsi, %rax
movw %r8w, 0x12(%rdi)
rolw $0x8, %dx
movw %dx, 0x1a(%rdi)
movw %cx, 0xa(%rdi)
movb 0x26(%rdi), %cl
movb 0x24(%rdi), %dl
movb 0x25(%rdi), %sil
movb 0x30(%rdi), %r8b
movb %r8b, 0x25(%rdi)
movb 0x32(%rdi), %r8b
movb %r8b, 0x26(%rdi)
movb 0x31(%rdi), %r8b
movb %r8b, 0x24(%rdi)
movb 0x33(%rdi), %r8b
movb %r8b, 0x31(%rdi)
movb 0x34(%rdi), %r8b
movb %r8b, 0x32(%rdi)
movb 0x35(%rdi), %r8b
movb %r8b, 0x30(%rdi)
movb 0x28(%rdi), %r8b
movb %r8b, 0x34(%rdi)
movb 0x27(%rdi), %r8b
movb %r8b, 0x35(%rdi)
movb 0x29(%rdi), %r8b
movb %r8b, 0x33(%rdi)
movb %sil, 0x27(%rdi)
movb %cl, 0x28(%rdi)
movb %dl, 0x29(%rdi)
leaq 0x7(%rsp), %rsi
movb $0x57, (%rsi)
movq %rax, %rdi
callq 0xc8c2
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Rubenmp[P]Rubik/src/defineRubik.cpp
// Function: Rubik::b(std::vector<char, std::allocator<char>>&)
void Rubik::b (vector<char>& solution){
   Corner aux;
   Edge laux;

   laux.up = edge[10].down;
   laux.down = edge[10].up;
   edge[10].up = edge[6].down;
   edge[10].down = edge[6].up;
   edge[6].up = edge[9].down;
   edge[6].down = edge[9].up;
   edge[9].up = edge[2].down;
   edge[9].down = edge[2].up;
   edge[2] = laux;

   aux.left = corner[3].up;
   aux.right = corner[3].left;
   aux.up = corner[3].right;

   corner[3].left = corner[7].left;
   corner[3].right = corner[7].up;
   corner[3].up = corner[7].right;

   corner[7].left = corner[6].right;
   corner[7].right = corner[6].up;
   corner[7].up = corner[6].left;

   corner[6].left = corner[2].up;
   corner[6].right = corner[2].right;
   corner[6].up = corner[2].left;

   corner[2] = aux;
   solution.push_back('w');
}

// Assembly:
pushq %rax
movzwl 0x1a(%rdi), %ecx
rolw $0x8, %cx
movzwl 0xa(%rdi), %edx
movzwl 0x12(%rdi), %eax
rolw $0x8, %ax
movw %ax, 0x1a(%rdi)
movzwl 0x18(%rdi), %r8d
rolw $0x8, %r8w
movq %rsi, %rax
movw %r8w, 0x12(%rdi)
rolw $0x8, %dx
movw %dx, 0x18(%rdi)
movw %cx, 0xa(%rdi)
movb 0x27(%rdi), %cl
movb 0x28(%rdi), %dl
movb 0x29(%rdi), %sil
movzwl 0x33(%rdi), %r8d
rolw $0x8, %r8w
movw %r8w, 0x28(%rdi)
movb 0x35(%rdi), %r8b
movb %r8b, 0x27(%rdi)
movb 0x32(%rdi), %r8b
movb %r8b, 0x34(%rdi)
movb 0x30(%rdi), %r8b
movb %r8b, 0x35(%rdi)
movb 0x31(%rdi), %r8b
movb %r8b, 0x33(%rdi)
movb 0x24(%rdi), %r8b
movb %r8b, 0x31(%rdi)
movb 0x26(%rdi), %r8b
movb %r8b, 0x32(%rdi)
movb 0x25(%rdi), %r8b
movb %r8b, 0x30(%rdi)
movb %sil, 0x24(%rdi)
movb %cl, 0x25(%rdi)
movb %dl, 0x26(%rdi)
leaq 0x7(%rsp), %rsi
movb $0x77, (%rsi)
movq %rax, %rdi
callq 0xc8c2
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/Rubenmp[P]Rubik/src/defineRubik.cpp
// Function: Rubik::Rubik()
Rubik::Rubik(){
   corner[3].up = edge[2].up = corner[2].up = edge[3].up = center[0].center = edge[1].up = 'w';
   corner[0].up = edge[0].up = corner[1].up = 'w';
   corner[3].right = edge[3].down = corner[0].left = edge[10].down = center[4].center = edge[11].down = 'o';
   corner[7].right = edge[7].down = corner[4].left = 'o';
   corner[0].right = edge[0].down = corner[1].left = edge[11].up = center[1].center = edge[8].up = corner[4].right = 'g';
   edge[4].down =  corner[5].left = 'g';
   corner[1].right = edge[1].down = corner[2].left = edge[8].down = center[2].center = edge[9].down = 'r';
   corner[5].right = edge[5].down = corner[6].left = 'r';
   corner[2].right = edge[2].down = corner[3].left = edge[9].up = center[3].center = edge[10].up = 'l';
   corner[6].right = edge[6].down = corner[7].left = 'l';
   corner[4].up = edge[4].up = corner[5].up = edge[7].up = center[5].center = edge[5].up = 'y';
   corner[7].up = edge[6].up = corner[6].up = 'y';
}

// Assembly:
movb $0x77, %al
movb %al, 0x8(%rdi)
movw $0x6777, %cx            # imm = 0x6777
movw %cx, (%rdi)
movw $0x6f77, 0xc(%rdi)      # imm = 0x6F77
movw $0x7277, 0x24(%rdi)     # imm = 0x7277
movb %al, 0xa(%rdi)
movb %al, 0x27(%rdi)
movw %cx, 0x6(%rdi)
movb $0x6f, %al
movb %al, 0x4(%rdi)
movabsq $0x6777676f776f676f, %rcx # imm = 0x6777676F776F676F
movq %rcx, 0x1b(%rdi)
movb %al, 0x29(%rdi)
movw $0x676f, %cx            # imm = 0x676F
movw %cx, 0x2b(%rdi)
movw %cx, 0x15(%rdi)
movb %al, 0x35(%rdi)
movb $0x67, %al
movb %al, 0x2e(%rdi)
movb %al, 0xf(%rdi)
movb $0x72, %al
movb %al, 0x19(%rdi)
movb %al, 0x2(%rdi)
movb %al, 0x17(%rdi)
movb %al, 0x9(%rdi)
movb %al, 0x23(%rdi)
movl $0x6c727972, 0x2f(%rdi) # imm = 0x6C727972
movb $0x6c, %al
movb %al, 0x1a(%rdi)
movb %al, 0x3(%rdi)
movb %al, 0x18(%rdi)
movb %al, 0x28(%rdi)
movb %al, 0xb(%rdi)
movb %al, 0x26(%rdi)
movw $0x796c, 0x13(%rdi)     # imm = 0x796C
movw $0x7279, 0x10(%rdi)     # imm = 0x7279
movb $0x79, %al
movb %al, 0x5(%rdi)
movb %al, 0x2d(%rdi)
movb %al, 0xe(%rdi)
movb %al, 0x2a(%rdi)
movb %al, 0x12(%rdi)
movw $0x6c79, 0x33(%rdi)     # imm = 0x6C79
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Rubenmp[P]Rubik/src/defineRubik.cpp
// Function: Rubik::operator=(Rubik const&)
Rubik& Rubik::operator = (const Rubik& rubik){
   if (this != &rubik){
      int i;
      for (i=0; i<6; ++i)
         center[i].center = rubik.getCenter(i).center;

      for (i=0; i<12; ++i){
         edge[i].up   = rubik.getEdge(i).up;
         edge[i].down = rubik.getEdge(i).down;
      }

      for (i=0; i<8; ++i){
         corner[i].up    = rubik.getCorner(i).up;
         corner[i].left  = rubik.getCorner(i).left;
         corner[i].right = rubik.getCorner(i).right;
      }
   }
   return *this;
}

// Assembly:
movq %rdi, %rax
cmpq %rsi, %rdi
je 0x952c
xorl %ecx, %ecx
movb (%rsi,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
cmpq $0x6, %rcx
jne 0x94de
xorl %ecx, %ecx
movb 0x6(%rsi,%rcx,2), %dl
movb %dl, 0x6(%rax,%rcx,2)
movb 0x7(%rsi,%rcx,2), %dl
movb %dl, 0x7(%rax,%rcx,2)
incq %rcx
cmpq $0xc, %rcx
jne 0x94ef
xorl %ecx, %ecx
movb 0x1e(%rsi,%rcx), %dl
movb %dl, 0x1e(%rax,%rcx)
movb 0x1f(%rsi,%rcx), %dl
movb %dl, 0x1f(%rax,%rcx)
movb 0x20(%rsi,%rcx), %dl
movb %dl, 0x20(%rax,%rcx)
addq $0x3, %rcx
cmpq $0x18, %rcx
jne 0x950a
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Rubenmp[P]Rubik/src/defineRubik.cpp
// Function: Rubik::mixRubik(int const&)
void Rubik::mixRubik(const int& number){
   int num;
   srand(time(NULL));
   vector<char> cad;
   num = number;
   for (int i=0; i<300; ++i){
      num = 1 + rand()%(12);
      if (num == 1)
         R(cad);
      else if (num == 2)
	      r(cad);
      else if (num == 3)
	      L(cad);
      else if (num == 4)
	      l(cad);
      else if (num == 5)
	      F(cad);
      else if (num == 6)
	      f(cad);
      else if (num == 7)
	      B(cad);
      else if (num == 8)
	      b(cad);
      else if (num == 9)
	      U(cad);
      else if (num == 10)
	      u(cad);
      else if (num == 11)
	      D(cad);
      else if (num == 12)
	      d(cad);
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x2150
movl %eax, %edi
callq 0x2160
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movl $0x12c, %ebp            # imm = 0x12C
leaq 0x3eed(%rip), %r15      # 0xd454
callq 0x2090
cltq
imulq $0x2aaaaaab, %rax, %rcx # imm = 0x2AAAAAAB
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x21, %rcx
addl %edx, %ecx
shll $0x2, %ecx
leal (%rcx,%rcx,2), %ecx
subl %ecx, %eax
cmpl $0xb, %eax
ja 0x963c
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3d46
jmp 0x963c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3ff8
jmp 0x963c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x415a
jmp 0x963c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40e4
jmp 0x963c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3e64
jmp 0x963c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3ef0
jmp 0x963c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4340
jmp 0x963c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3dd8
jmp 0x963c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x41f6
jmp 0x963c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x429a
jmp 0x963c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3f82
jmp 0x963c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x406e
decl %ebp
jne 0x9567
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x965a
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x967e
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/Rubenmp[P]Rubik/src/defineRubik.cpp
// Function: Rubik::printNumbers(std::ostream&)
void Rubik::printNumbers(std::ostream& os){
   os << "                     _______________ \n";
   os << "                     | 01 | 02 | 03 |\n";
   os << "                     _______________ \n";
   os << "                     | 04 | 05 | 06 |\n";
   os << "                     _______________ \n";
   os << "                     | 07 | 08 | 09 |\n";
   os << "    _________________________________________________________________ \n";
   os << "    || 10 | 11 | 12 || 19 | 20 | 21 || 28 | 29 | 30 || 37 | 38 | 39 ||\n";
   os << "    _________________________________________________________________ \n";
   os << "    || 13 | 14 | 15 || 22 | 23 | 24 || 31 | 32 | 33 || 40 | 41 | 42 ||\n";
   os << "    _________________________________________________________________ \n";
   os << "    || 16 | 17 | 18 || 25 | 26 | 27 || 34 | 35 | 36 || 43 | 44 | 45 ||\n";
   os << "    _________________________________________________________________ \n";
   os << "                     | 46 | 47 | 48 |\n";
   os << "                     _______________ \n";
   os << "                     | 49 | 50 | 51 |\n";
   os << "                     _______________ \n";
   os << "                     | 52 | 53 | 54 |\n";
   os << "                     _______________ "<< endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x42e3(%rip), %r14      # 0xe47a
movl $0x26, %edx
movq %r14, %rsi
callq 0x21d0
leaq 0x42f6(%rip), %rsi      # 0xe4a1
movl $0x26, %edx
movq %rbx, %rdi
callq 0x21d0
movl $0x26, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21d0
leaq 0x42f9(%rip), %rsi      # 0xe4c8
movl $0x26, %edx
movq %rbx, %rdi
callq 0x21d0
movl $0x26, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21d0
leaq 0x42fc(%rip), %rsi      # 0xe4ef
movl $0x26, %edx
movq %rbx, %rdi
callq 0x21d0
leaq 0x430f(%rip), %r15      # 0xe516
movl $0x47, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21d0
leaq 0x4340(%rip), %rsi      # 0xe55e
movl $0x47, %edx
movq %rbx, %rdi
callq 0x21d0
movl $0x47, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21d0
leaq 0x4364(%rip), %rsi      # 0xe5a6
movl $0x47, %edx
movq %rbx, %rdi
callq 0x21d0
movl $0x47, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21d0
leaq 0x4388(%rip), %rsi      # 0xe5ee
movl $0x47, %edx
movq %rbx, %rdi
callq 0x21d0
movl $0x47, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21d0
leaq 0x43ac(%rip), %rsi      # 0xe636
movl $0x26, %edx
movq %rbx, %rdi
callq 0x21d0
movl $0x26, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21d0
leaq 0x43af(%rip), %rsi      # 0xe65d
movl $0x26, %edx
movq %rbx, %rdi
callq 0x21d0
movl $0x26, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21d0
leaq 0x43b2(%rip), %rsi      # 0xe684
movl $0x26, %edx
movq %rbx, %rdi
callq 0x21d0
leaq 0x43c5(%rip), %rsi      # 0xe6ab
movl $0x25, %edx
movq %rbx, %rdi
callq 0x21d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2110
nop
// File: /workspace/github_cpp_makefile_star2_O1/Rubenmp[P]Rubik/src/defineRubik.cpp
// Function: Rubik::readSticker(char&, std::istream&)
void Rubik::readSticker(char& c, std::istream& is){
   char caracter;
   c = 'f';
   do{
      is >> caracter;
      if( ( tolower(caracter) == 'w') || ( caracter == '1' ) )
         c = 'w';
      else if( ( tolower(caracter) == 'o') || ( caracter == '2' ) )
         c = 'o';
      else if( ( tolower(caracter) == 'g') || ( caracter == '3' ) )
         c = 'g';
      else if( ( tolower(caracter) == 'r') || ( caracter == '4' ) )
         c = 'r';
      else if( ( tolower(caracter) == 'l') || ( caracter == '5' ) )
         c = 'l';
      else if( ( tolower(caracter) == 'y') || ( caracter == '6' ) )
         c = 'y';
      else
         cout << "Invalid char. Try again:\n";
   }while (c == 'f');
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movb $0x66, (%rsi)
leaq 0x7(%rsp), %r15
leaq 0x442b(%rip), %r13      # 0xe76b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21f0
movsbl 0x7(%rsp), %ebp
cmpl $0x31, %ebp
setne %r12b
movl %ebp, %edi
callq 0x2210
cmpl $0x77, %eax
setne %cl
testb %cl, %r12b
jne 0xa372
movb $0x77, (%r14)
jmp 0xa3f9
cmpl $0x6f, %eax
setne %cl
cmpb $0x32, %bpl
setne %dl
testb %cl, %dl
jne 0xa389
movb $0x6f, (%r14)
jmp 0xa3f9
cmpl $0x67, %eax
setne %cl
cmpb $0x33, %bpl
setne %dl
testb %cl, %dl
jne 0xa3a0
movb $0x67, (%r14)
jmp 0xa3f9
cmpl $0x72, %eax
setne %cl
cmpb $0x34, %bpl
setne %dl
testb %cl, %dl
jne 0xa3b7
movb $0x72, (%r14)
jmp 0xa3f9
cmpl $0x6c, %eax
setne %cl
cmpb $0x35, %bpl
setne %dl
testb %cl, %dl
jne 0xa3ce
movb $0x6c, (%r14)
jmp 0xa3f9
cmpl $0x79, %eax
setne %al
cmpb $0x36, %bpl
setne %cl
testb %al, %cl
jne 0xa3e5
movb $0x79, (%r14)
jmp 0xa3f9
movl $0x19, %edx
movq 0x7bd7(%rip), %rdi      # 0x11fc8
movq %r13, %rsi
callq 0x21d0
cmpb $0x66, (%r14)
je 0xa340
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq