LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x70, %rsp
movb %r9b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movb %al, -0x25(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rsi
callq 0x61d0
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x40(%rbp)
movq -0x18(%rbp), %rsi
callq 0x61d0
jmp 0x15971
movq -0x50(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x58(%rbp)
movq -0x20(%rbp), %rsi
callq 0x61d0
jmp 0x15988
movq -0x50(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x68(%rbp)
callq 0x65f0
movq -0x50(%rbp), %rdi
movl $0x0, 0x8c(%rdi)
movb -0x25(%rbp), %al
movb %al, 0x90(%rdi)
movb $0x0, 0x91(%rdi)
movb $0x0, 0x92(%rdi)
movb $0x0, 0x93(%rdi)
leaq 0x34b64(%rip), %rsi     # 0x4a530
callq 0x15570
movb %al, -0x59(%rbp)
jmp 0x159d6
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x15a1b
jmp 0x159df
movq -0x50(%rbp), %rdi
leaq 0x34b4a(%rip), %rsi     # 0x4a534
callq 0x15570
movb %al, -0x69(%rbp)
jmp 0x159f4
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x15a1b
jmp 0x159fd
movq -0x50(%rbp), %rdi
leaq 0x34b30(%rip), %rsi     # 0x4a538
callq 0x15570
movb %al, -0x6a(%rbp)
jmp 0x15a12
movb -0x6a(%rbp), %al
testb $0x1, %al
jne 0x15a1b
jmp 0x15a85
movq -0x50(%rbp), %rax
movb $0x52, 0x90(%rax)
movl -0x24(%rbp), %edx
movl 0x86(%rax), %ecx
andl $0x1f, %edx
andl $-0x20, %ecx
orl %edx, %ecx
movl %ecx, 0x86(%rax)
movb $0x1, 0x91(%rax)
jmp 0x15abb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x15ad8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x15acf
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x62a0
movq -0x58(%rbp), %rdi
callq 0x62a0
jmp 0x15acf
movq -0x50(%rbp), %rax
movsbl 0x90(%rax), %eax
cmpl $0x49, %eax
jne 0x15ab9
movq -0x50(%rbp), %rax
movl -0x24(%rbp), %edx
movl 0x86(%rax), %ecx
andl $0xffff, %edx           # imm = 0xFFFF
shll $0x10, %edx
andl $0xffff, %ecx           # imm = 0xFFFF
orl %edx, %ecx
movl %ecx, 0x86(%rax)
jmp 0x15abb
movq -0x50(%rbp), %rax
movl $0x2, 0x80(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x62a0
movq -0x48(%rbp), %rdi
callq 0x62a0
movq -0x30(%rbp), %rdi
callq 0x6790
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3700
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3730
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x3490
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x3700
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x3730
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3760
testb $0x1, %al
jne 0x2418
jmp 0x24c0
leaq -0x50(%rbp), %rdi
callq 0x37a0
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x8(%rbp), %rax
addq -0x60(%rbp), %rax
movq -0x68(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
je 0x2456
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
jmp 0x2430
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
addq -0x60(%rbp), %rdi
movq -0x70(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x1, %esi
callq 0x2240
cmpq -0x70(%rbp), %rax
je 0x24b0
movq 0x8b43(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x4bb5(%rip), %rsi      # 0x7054
movb $0x0, %al
callq 0x21b0
movl $0x1, %edi
callq 0x2150
jmp 0x24b2
leaq -0x50(%rbp), %rdi
callq 0x37c0
jmp 0x2402
movq -0x40(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x30(%rax)
jne 0x2542
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jne 0x2542
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movl $0x1, %esi
movl $0x10000, %edx          # imm = 0x10000
callq 0x21c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x2540
movq -0x10(%rbp), %rax
movb $0x1, 0x30(%rax)
jmp 0x2542
movq -0x10(%rbp), %rax
testb $0x1, 0x30(%rax)
je 0x2552
movb $-0x1, -0x1(%rbp)
jmp 0x2573
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdx
movq 0x20(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x20(%rdx)
movb (%rax,%rcx), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: alexandres[P]terashuf/terashuf.cc
// Function: readLine(char*, char, TmpFile&)
ll readLine(char *buf, char sep, TmpFile &f)
{
    ll bufPos = 0;
    char c = 0;
    while ((c = bufferedFgetc(f)) != EOF)
    {
        buf[bufPos++] = c;
        if (c == sep)
        {
            return bufPos;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
movq -0x20(%rbp), %rdi
callq 0x24d0
movb %al, -0x29(%rbp)
movsbl %al, %eax
cmpl $-0x1, %eax
je 0x25e7
movb -0x29(%rbp), %dl
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x28(%rbp)
movb %dl, (%rax,%rcx)
movsbl -0x29(%rbp), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x25e5
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x25ef
jmp 0x25a2
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x3900
movq -0x10(%rbp), %rdi
callq 0x3870
movq %rax, %rcx
movq -0x58(%rbp), %rax
movl %ecx, 0x18(%rax)
movl 0x18(%rax), %edi
callq 0x3f60
movsd %xmm0, -0x50(%rbp)
jmp 0x3b09
movsd -0x50(%rbp), %xmm0
callq 0x2040
movl $0x2, %edi
callq 0x3f30
movsd %xmm0, -0x68(%rbp)
jmp 0x3b24
movq -0x60(%rbp), %rax
movsd -0x68(%rbp), %xmm0
cvttsd2si %xmm0, %ecx
movl %ecx, 0x1c(%rax)
movl 0x1c(%rax), %eax
addl %eax, %eax
cltq
movq %rax, -0x78(%rbp)
movq $0x0, -0x40(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3f80
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rcx
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x3fa0
jmp 0x3b6b
movq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movq %rsi, -0x80(%rbp)
callq 0x4020
movq -0x80(%rbp), %rdi
callq 0x3d60
leaq -0x41(%rbp), %rdi
callq 0x4050
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4070
jmp 0x3b9d
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x3bc9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x4050
movq -0x58(%rbp), %rdi
callq 0x3d60
movq -0x18(%rbp), %rdi
callq 0x2210
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x1, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4a00
movq -0x28(%rbp), %rcx
movq (%rax), %rdx
addq $-0x1, %rdx
movq %rdx, (%rax)
movq -0x18(%rbp), %rax
movslq 0x1c(%rcx), %rcx
cmpq %rcx, %rax
jb 0x3c8a
jmp 0x3cd0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
shlq %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x4a00
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x3cce
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3c60
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movslq 0x1c(%rcx), %rcx
subq %rcx, %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x18(%rcx), %eax
jge 0x40d3
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x49e0
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl 0x1c(%rdi), %eax
addl -0x14(%rbp), %eax
movslq %eax, %rsi
callq 0x4a00
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x408f
movq -0x20(%rbp), %rax
movl 0x1c(%rax), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x413f
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %eax
shll %eax
movslq %eax, %rsi
callq 0x4a00
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movl -0x18(%rbp), %eax
shll %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x4a00
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movq -0x38(%rbp), %rax
addq (%rcx), %rax
movq %rax, -0x30(%rbp)
movslq -0x18(%rbp), %rsi
callq 0x4a00
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x40e0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: viniciu21[P]sortingAlgorithmsProject/src/sortingAlgorithm.cpp
// Function: bubbleSort(int*, int)
void bubbleSort(int lista[], int tam)
{
	int k = 1;
	int aux = 0;
	for (int i = 0; i < tam; i++)
	{
		for (int j = k; j < tam; j++)
		{
			if (lista[i] > lista[j])
			{
				aux = lista[i];
				lista[i] = lista[j];
				lista[j] = aux;
			}
		}
		k++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3474
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x345d
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jle 0x3450
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x3452
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x33fe
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x33f0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: viniciu21[P]sortingAlgorithmsProject/src/sortingAlgorithm.cpp
// Function: partition(int*, int, int)
int partition(int lista[], int left, int right)
{
	int pivot = lista[right];
	int i = (left - 1);

	for (int j = left; j <= right - 1; j++)
	{
		if (lista[j] <= pivot)
		{
			i++;
			swap(lista[i], lista[j]);
		}
	}
	swap(lista[i + 1], lista[right]);
	return (i + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jg 0x3535
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jg 0x3528
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x18(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movslq -0x1c(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x3480
jmp 0x352a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x34df
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %eax
addl $0x1, %eax
cltq
shlq $0x2, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movslq -0x10(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x3480
movl -0x18(%rbp), %eax
addl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: viniciu21[P]sortingAlgorithmsProject/src/sortingAlgorithm.cpp
// Function: quickSort(int*, int, int)
void quickSort(int lista[], int left, int right)
{
	if (left < right)
	{
		int pi = partition(lista, left, right);
		quickSort(lista, left, pi - 1);
		quickSort(lista, pi + 1, right);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x35c0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x34b0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x14(%rbp), %edx
subl $0x1, %edx
callq 0x3570
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
movl -0x10(%rbp), %edx
callq 0x3570
addq $0x20, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x2340
cmpl $0x77, %eax
jne 0x4224
movl $0x1, -0x14(%rbp)
jmp 0x42ae
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x2340
cmpl $0x6f, %eax
jne 0x423e
movl $0x2, -0x14(%rbp)
jmp 0x42ac
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x2340
cmpl $0x67, %eax
jne 0x4258
movl $0x3, -0x14(%rbp)
jmp 0x42aa
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x2340
cmpl $0x72, %eax
jne 0x4272
movl $0x4, -0x14(%rbp)
jmp 0x42a8
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x2340
cmpl $0x6c, %eax
jne 0x428c
movl $0x5, -0x14(%rbp)
jmp 0x42a6
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x2340
cmpl $0x79, %eax
jne 0x42a4
movl $0x6, -0x14(%rbp)
jmp 0x42a6
jmp 0x42a8
jmp 0x42aa
jmp 0x42ac
jmp 0x42ae
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movw 0x8(%rax), %cx
movw %cx, -0x15(%rbp)
movw 0x16(%rax), %cx
movw %cx, 0x8(%rax)
movw 0x10(%rax), %cx
movw %cx, 0x16(%rax)
movw 0x18(%rax), %cx
movw %cx, 0x10(%rax)
movw -0x15(%rbp), %cx
movw %cx, 0x18(%rax)
movb 0x23(%rax), %cl
movb %cl, -0x12(%rbp)
movb 0x21(%rax), %cl
movb %cl, -0x11(%rbp)
movb 0x22(%rax), %cl
movb %cl, -0x13(%rbp)
movb 0x2d(%rax), %cl
movb %cl, 0x22(%rax)
movb 0x2f(%rax), %cl
movb %cl, 0x23(%rax)
movb 0x2e(%rax), %cl
movb %cl, 0x21(%rax)
movb 0x30(%rax), %cl
movb %cl, 0x2e(%rax)
movb 0x31(%rax), %cl
movb %cl, 0x2f(%rax)
movb 0x32(%rax), %cl
movb %cl, 0x2d(%rax)
movb 0x25(%rax), %cl
movb %cl, 0x31(%rax)
movb 0x24(%rax), %cl
movb %cl, 0x32(%rax)
movb 0x26(%rax), %cl
movb %cl, 0x30(%rax)
movw -0x13(%rbp), %cx
movw %cx, 0x24(%rax)
movb -0x11(%rbp), %cl
movb %cl, 0x26(%rax)
movq -0x10(%rbp), %rdi
movb $0x52, -0x16(%rbp)
leaq -0x16(%rbp), %rsi
callq 0x16000
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movw 0x8(%rax), %cx
movw %cx, -0x15(%rbp)
movw 0x18(%rax), %cx
movw %cx, 0x8(%rax)
movw 0x10(%rax), %cx
movw %cx, 0x18(%rax)
movw 0x16(%rax), %cx
movw %cx, 0x10(%rax)
movw -0x15(%rbp), %cx
movw %cx, 0x16(%rax)
movb 0x21(%rax), %cl
movb %cl, -0x12(%rbp)
movb 0x23(%rax), %cl
movb %cl, -0x11(%rbp)
movb 0x22(%rax), %cl
movb %cl, -0x13(%rbp)
movb 0x24(%rax), %cl
movb %cl, 0x22(%rax)
movb 0x25(%rax), %cl
movb %cl, 0x23(%rax)
movb 0x26(%rax), %cl
movb %cl, 0x21(%rax)
movb 0x31(%rax), %cl
movb %cl, 0x25(%rax)
movb 0x30(%rax), %cl
movb %cl, 0x26(%rax)
movb 0x32(%rax), %cl
movb %cl, 0x24(%rax)
movb 0x2f(%rax), %cl
movb %cl, 0x31(%rax)
movb 0x2d(%rax), %cl
movb %cl, 0x32(%rax)
movb 0x2e(%rax), %cl
movb %cl, 0x30(%rax)
movw -0x13(%rbp), %cx
movw %cx, 0x2d(%rax)
movb -0x11(%rbp), %cl
movb %cl, 0x2f(%rax)
movq -0x10(%rbp), %rdi
movb $0x72, -0x16(%rbp)
leaq -0x16(%rbp), %rsi
callq 0x16000
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movw 0xc(%rax), %cx
movw %cx, -0x15(%rbp)
movw 0x1a(%rax), %cx
movw %cx, 0xc(%rax)
movw 0x14(%rax), %cx
movw %cx, 0x1a(%rax)
movw 0x1c(%rax), %cx
movw %cx, 0x14(%rax)
movw -0x15(%rbp), %cx
movw %cx, 0x1c(%rax)
movb 0x1f(%rax), %cl
movb %cl, -0x12(%rbp)
movb 0x1e(%rax), %cl
movb %cl, -0x11(%rbp)
movb 0x20(%rax), %cl
movb %cl, -0x13(%rbp)
movb 0x29(%rax), %cl
movb %cl, 0x1f(%rax)
movb 0x27(%rax), %cl
movb %cl, 0x20(%rax)
movb 0x28(%rax), %cl
movb %cl, 0x1e(%rax)
movb 0x33(%rax), %cl
movb %cl, 0x28(%rax)
movb 0x35(%rax), %cl
movb %cl, 0x29(%rax)
movb 0x34(%rax), %cl
movb %cl, 0x27(%rax)
movb 0x2a(%rax), %cl
movb %cl, 0x34(%rax)
movb 0x2b(%rax), %cl
movb %cl, 0x35(%rax)
movb 0x2c(%rax), %cl
movb %cl, 0x33(%rax)
movw -0x13(%rbp), %cx
movw %cx, 0x2a(%rax)
movb -0x11(%rbp), %cl
movb %cl, 0x2c(%rax)
movq -0x10(%rbp), %rdi
movb $0x4c, -0x16(%rbp)
leaq -0x16(%rbp), %rsi
callq 0x16000
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movw 0xc(%rax), %cx
movw %cx, -0x15(%rbp)
movw 0x1c(%rax), %cx
movw %cx, 0xc(%rax)
movw 0x14(%rax), %cx
movw %cx, 0x1c(%rax)
movw 0x1a(%rax), %cx
movw %cx, 0x14(%rax)
movw -0x15(%rbp), %cx
movw %cx, 0x1a(%rax)
movb 0x1e(%rax), %cl
movb %cl, -0x12(%rbp)
movb 0x1f(%rax), %cl
movb %cl, -0x11(%rbp)
movb 0x20(%rax), %cl
movb %cl, -0x13(%rbp)
movb 0x2b(%rax), %cl
movb %cl, 0x1f(%rax)
movb 0x2a(%rax), %cl
movb %cl, 0x20(%rax)
movb 0x2c(%rax), %cl
movb %cl, 0x1e(%rax)
movb 0x35(%rax), %cl
movb %cl, 0x2b(%rax)
movb 0x33(%rax), %cl
movb %cl, 0x2c(%rax)
movb 0x34(%rax), %cl
movb %cl, 0x2a(%rax)
movb 0x27(%rax), %cl
movb %cl, 0x34(%rax)
movb 0x29(%rax), %cl
movb %cl, 0x35(%rax)
movb 0x28(%rax), %cl
movb %cl, 0x33(%rax)
movw -0x13(%rbp), %cx
movw %cx, 0x27(%rax)
movb -0x11(%rbp), %cl
movb %cl, 0x29(%rax)
movq -0x10(%rbp), %rdi
movb $0x6c, -0x16(%rbp)
leaq -0x16(%rbp), %rsi
callq 0x16000
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movw 0xe(%rax), %cx
movw %cx, -0x15(%rbp)
movw 0x14(%rax), %cx
movw %cx, 0xe(%rax)
movw 0x12(%rax), %cx
movw %cx, 0x14(%rax)
movw 0x10(%rax), %cx
movw %cx, 0x12(%rax)
movw -0x15(%rbp), %cx
movw %cx, 0x10(%rax)
movw 0x2d(%rax), %cx
movw %cx, -0x13(%rbp)
movb 0x2f(%rax), %cl
movb %cl, -0x11(%rbp)
movw 0x2a(%rax), %cx
movw %cx, 0x2d(%rax)
movb 0x2c(%rax), %cl
movb %cl, 0x2f(%rax)
movw 0x33(%rax), %cx
movw %cx, 0x2a(%rax)
movb 0x35(%rax), %cl
movb %cl, 0x2c(%rax)
movw 0x30(%rax), %cx
movw %cx, 0x33(%rax)
movb 0x32(%rax), %cl
movb %cl, 0x35(%rax)
movw -0x13(%rbp), %cx
movw %cx, 0x30(%rax)
movb -0x11(%rbp), %cl
movb %cl, 0x32(%rax)
movq -0x10(%rbp), %rdi
movb $0x44, -0x16(%rbp)
leaq -0x16(%rbp), %rsi
callq 0x16000
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movw 0xe(%rax), %cx
movw %cx, -0x15(%rbp)
movw 0x10(%rax), %cx
movw %cx, 0xe(%rax)
movw 0x12(%rax), %cx
movw %cx, 0x10(%rax)
movw 0x14(%rax), %cx
movw %cx, 0x12(%rax)
movw -0x15(%rbp), %cx
movw %cx, 0x14(%rax)
movw 0x2d(%rax), %cx
movw %cx, -0x13(%rbp)
movb 0x2f(%rax), %cl
movb %cl, -0x11(%rbp)
movw 0x30(%rax), %cx
movw %cx, 0x2d(%rax)
movb 0x32(%rax), %cl
movb %cl, 0x2f(%rax)
movw 0x33(%rax), %cx
movw %cx, 0x30(%rax)
movb 0x35(%rax), %cl
movb %cl, 0x32(%rax)
movw 0x2a(%rax), %cx
movw %cx, 0x33(%rax)
movb 0x2c(%rax), %cl
movb %cl, 0x35(%rax)
movw -0x13(%rbp), %cx
movw %cx, 0x2a(%rax)
movb -0x11(%rbp), %cl
movb %cl, 0x2c(%rax)
movq -0x10(%rbp), %rdi
movb $0x64, -0x16(%rbp)
leaq -0x16(%rbp), %rsi
callq 0x16000
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movw 0x6(%rax), %cx
movw %cx, -0x15(%rbp)
movw 0x8(%rax), %cx
movw %cx, 0x6(%rax)
movw 0xa(%rax), %cx
movw %cx, 0x8(%rax)
movw 0xc(%rax), %cx
movw %cx, 0xa(%rax)
movw -0x15(%rbp), %cx
movw %cx, 0xc(%rax)
movw 0x1e(%rax), %cx
movw %cx, -0x13(%rbp)
movb 0x20(%rax), %cl
movb %cl, -0x11(%rbp)
movw 0x21(%rax), %cx
movw %cx, 0x1e(%rax)
movb 0x23(%rax), %cl
movb %cl, 0x20(%rax)
movw 0x24(%rax), %cx
movw %cx, 0x21(%rax)
movb 0x26(%rax), %cl
movb %cl, 0x23(%rax)
movw 0x27(%rax), %cx
movw %cx, 0x24(%rax)
movb 0x29(%rax), %cl
movb %cl, 0x26(%rax)
movw -0x13(%rbp), %cx
movw %cx, 0x27(%rax)
movb -0x11(%rbp), %cl
movb %cl, 0x29(%rax)
movq -0x10(%rbp), %rdi
movb $0x55, -0x16(%rbp)
leaq -0x16(%rbp), %rsi
callq 0x16000
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movw 0x6(%rax), %cx
movw %cx, -0x15(%rbp)
movw 0xc(%rax), %cx
movw %cx, 0x6(%rax)
movw 0xa(%rax), %cx
movw %cx, 0xc(%rax)
movw 0x8(%rax), %cx
movw %cx, 0xa(%rax)
movw -0x15(%rbp), %cx
movw %cx, 0x8(%rax)
movw 0x21(%rax), %cx
movw %cx, -0x13(%rbp)
movb 0x23(%rax), %cl
movb %cl, -0x11(%rbp)
movw 0x1e(%rax), %cx
movw %cx, 0x21(%rax)
movb 0x20(%rax), %cl
movb %cl, 0x23(%rax)
movw 0x27(%rax), %cx
movw %cx, 0x1e(%rax)
movb 0x29(%rax), %cl
movb %cl, 0x20(%rax)
movw 0x24(%rax), %cx
movw %cx, 0x27(%rax)
movb 0x26(%rax), %cl
movb %cl, 0x29(%rax)
movw -0x13(%rbp), %cx
movw %cx, 0x24(%rax)
movb -0x11(%rbp), %cl
movb %cl, 0x26(%rax)
movq -0x10(%rbp), %rdi
movb $0x75, -0x16(%rbp)
leaq -0x16(%rbp), %rsi
callq 0x16000
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movb 0x6(%rax), %cl
movb %cl, -0x14(%rbp)
movb 0x7(%rax), %cl
movb %cl, -0x15(%rbp)
movb 0x1d(%rax), %cl
movb %cl, 0x6(%rax)
movb 0x1c(%rax), %cl
movb %cl, 0x7(%rax)
movb 0xf(%rax), %cl
movb %cl, 0x1c(%rax)
movb 0xe(%rax), %cl
movb %cl, 0x1d(%rax)
movb 0x17(%rax), %cl
movb %cl, 0xe(%rax)
movb 0x16(%rax), %cl
movb %cl, 0xf(%rax)
movw -0x15(%rbp), %cx
movw %cx, 0x16(%rax)
movb 0x22(%rax), %cl
movb %cl, -0x12(%rbp)
movb 0x21(%rax), %cl
movb %cl, -0x11(%rbp)
movb 0x23(%rax), %cl
movb %cl, -0x13(%rbp)
movb 0x20(%rax), %cl
movb %cl, 0x22(%rax)
movb 0x1e(%rax), %cl
movb %cl, 0x23(%rax)
movb 0x1f(%rax), %cl
movb %cl, 0x21(%rax)
movb 0x2a(%rax), %cl
movb %cl, 0x1f(%rax)
movb 0x2c(%rax), %cl
movb %cl, 0x20(%rax)
movb 0x2b(%rax), %cl
movb %cl, 0x1e(%rax)
movb 0x2d(%rax), %cl
movb %cl, 0x2b(%rax)
movb 0x2e(%rax), %cl
movb %cl, 0x2c(%rax)
movb 0x2f(%rax), %cl
movb %cl, 0x2a(%rax)
movw -0x13(%rbp), %cx
movw %cx, 0x2d(%rax)
movb -0x11(%rbp), %cl
movb %cl, 0x2f(%rax)
movq -0x10(%rbp), %rdi
movb $0x46, -0x16(%rbp)
leaq -0x16(%rbp), %rsi
callq 0x16000
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movb 0x17(%rax), %cl
movb %cl, -0x15(%rbp)
movb 0x16(%rax), %cl
movb %cl, -0x14(%rbp)
movb 0xf(%rax), %cl
movb %cl, 0x16(%rax)
movb 0xe(%rax), %cl
movb %cl, 0x17(%rax)
movb 0x1d(%rax), %cl
movb %cl, 0xe(%rax)
movb 0x1c(%rax), %cl
movb %cl, 0xf(%rax)
movb 0x7(%rax), %cl
movb %cl, 0x1c(%rax)
movb 0x6(%rax), %cl
movb %cl, 0x1d(%rax)
movw -0x15(%rbp), %cx
movw %cx, 0x6(%rax)
movb 0x21(%rax), %cl
movb %cl, -0x12(%rbp)
movb 0x22(%rax), %cl
movb %cl, -0x11(%rbp)
movb 0x23(%rax), %cl
movb %cl, -0x13(%rbp)
movb 0x2e(%rax), %cl
movb %cl, 0x22(%rax)
movb 0x2d(%rax), %cl
movb %cl, 0x23(%rax)
movb 0x2f(%rax), %cl
movb %cl, 0x21(%rax)
movb 0x2c(%rax), %cl
movb %cl, 0x2e(%rax)
movb 0x2a(%rax), %cl
movb %cl, 0x2f(%rax)
movb 0x2b(%rax), %cl
movb %cl, 0x2d(%rax)
movb 0x1e(%rax), %cl
movb %cl, 0x2b(%rax)
movb 0x20(%rax), %cl
movb %cl, 0x2c(%rax)
movb 0x1f(%rax), %cl
movb %cl, 0x2a(%rax)
movw -0x13(%rbp), %cx
movw %cx, 0x1e(%rax)
movb -0x11(%rbp), %cl
movb %cl, 0x20(%rax)
movq -0x10(%rbp), %rdi
movb $0x66, -0x16(%rbp)
leaq -0x16(%rbp), %rsi
callq 0x16000
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movb 0x19(%rax), %cl
movb %cl, -0x15(%rbp)
movb 0x18(%rax), %cl
movb %cl, -0x14(%rbp)
movb 0x13(%rax), %cl
movb %cl, 0x18(%rax)
movb 0x12(%rax), %cl
movb %cl, 0x19(%rax)
movb 0x1b(%rax), %cl
movb %cl, 0x12(%rax)
movb 0x1a(%rax), %cl
movb %cl, 0x13(%rax)
movb 0xb(%rax), %cl
movb %cl, 0x1a(%rax)
movb 0xa(%rax), %cl
movb %cl, 0x1b(%rax)
movw -0x15(%rbp), %cx
movw %cx, 0xa(%rax)
movb 0x26(%rax), %cl
movb %cl, -0x12(%rbp)
movb 0x24(%rax), %cl
movb %cl, -0x11(%rbp)
movb 0x25(%rax), %cl
movb %cl, -0x13(%rbp)
movb 0x30(%rax), %cl
movb %cl, 0x25(%rax)
movb 0x32(%rax), %cl
movb %cl, 0x26(%rax)
movb 0x31(%rax), %cl
movb %cl, 0x24(%rax)
movb 0x33(%rax), %cl
movb %cl, 0x31(%rax)
movb 0x34(%rax), %cl
movb %cl, 0x32(%rax)
movb 0x35(%rax), %cl
movb %cl, 0x30(%rax)
movb 0x28(%rax), %cl
movb %cl, 0x34(%rax)
movb 0x27(%rax), %cl
movb %cl, 0x35(%rax)
movb 0x29(%rax), %cl
movb %cl, 0x33(%rax)
movw -0x13(%rbp), %cx
movw %cx, 0x27(%rax)
movb -0x11(%rbp), %cl
movb %cl, 0x29(%rax)
movq -0x10(%rbp), %rdi
movb $0x57, -0x16(%rbp)
leaq -0x16(%rbp), %rsi
callq 0x16000
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movb 0x1b(%rax), %cl
movb %cl, -0x15(%rbp)
movb 0x1a(%rax), %cl
movb %cl, -0x14(%rbp)
movb 0x13(%rax), %cl
movb %cl, 0x1a(%rax)
movb 0x12(%rax), %cl
movb %cl, 0x1b(%rax)
movb 0x19(%rax), %cl
movb %cl, 0x12(%rax)
movb 0x18(%rax), %cl
movb %cl, 0x13(%rax)
movb 0xb(%rax), %cl
movb %cl, 0x18(%rax)
movb 0xa(%rax), %cl
movb %cl, 0x19(%rax)
movw -0x15(%rbp), %cx
movw %cx, 0xa(%rax)
movb 0x27(%rax), %cl
movb %cl, -0x12(%rbp)
movb 0x28(%rax), %cl
movb %cl, -0x11(%rbp)
movb 0x29(%rax), %cl
movb %cl, -0x13(%rbp)
movb 0x34(%rax), %cl
movb %cl, 0x28(%rax)
movb 0x33(%rax), %cl
movb %cl, 0x29(%rax)
movb 0x35(%rax), %cl
movb %cl, 0x27(%rax)
movb 0x32(%rax), %cl
movb %cl, 0x34(%rax)
movb 0x30(%rax), %cl
movb %cl, 0x35(%rax)
movb 0x31(%rax), %cl
movb %cl, 0x33(%rax)
movb 0x24(%rax), %cl
movb %cl, 0x31(%rax)
movb 0x26(%rax), %cl
movb %cl, 0x32(%rax)
movb 0x25(%rax), %cl
movb %cl, 0x30(%rax)
movw -0x13(%rbp), %cx
movw %cx, 0x24(%rax)
movb -0x11(%rbp), %cl
movb %cl, 0x26(%rax)
movq -0x10(%rbp), %rdi
movb $0x77, -0x16(%rbp)
leaq -0x16(%rbp), %rsi
callq 0x16000
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x77, 0x8(%rax)
movb $0x77, (%rax)
movb $0x77, 0xc(%rax)
movb $0x77, 0x24(%rax)
movb $0x77, 0xa(%rax)
movb $0x77, 0x27(%rax)
movb $0x77, 0x21(%rax)
movb $0x77, 0x6(%rax)
movb $0x77, 0x1e(%rax)
movb $0x6f, 0x1d(%rax)
movb $0x6f, 0x4(%rax)
movb $0x6f, 0x1b(%rax)
movb $0x6f, 0x1f(%rax)
movb $0x6f, 0xd(%rax)
movb $0x6f, 0x29(%rax)
movb $0x6f, 0x2b(%rax)
movb $0x6f, 0x15(%rax)
movb $0x6f, 0x35(%rax)
movb $0x67, 0x2c(%rax)
movb $0x67, 0x16(%rax)
movb $0x67, 0x1(%rax)
movb $0x67, 0x1c(%rax)
movb $0x67, 0x22(%rax)
movb $0x67, 0x7(%rax)
movb $0x67, 0x20(%rax)
movb $0x67, 0x2e(%rax)
movb $0x67, 0xf(%rax)
movb $0x72, 0x19(%rax)
movb $0x72, 0x2(%rax)
movb $0x72, 0x17(%rax)
movb $0x72, 0x25(%rax)
movb $0x72, 0x9(%rax)
movb $0x72, 0x23(%rax)
movb $0x72, 0x31(%rax)
movb $0x72, 0x11(%rax)
movb $0x72, 0x2f(%rax)
movb $0x6c, 0x1a(%rax)
movb $0x6c, 0x3(%rax)
movb $0x6c, 0x18(%rax)
movb $0x6c, 0x28(%rax)
movb $0x6c, 0xb(%rax)
movb $0x6c, 0x26(%rax)
movb $0x6c, 0x34(%rax)
movb $0x6c, 0x13(%rax)
movb $0x6c, 0x32(%rax)
movb $0x79, 0x10(%rax)
movb $0x79, 0x5(%rax)
movb $0x79, 0x14(%rax)
movb $0x79, 0x2d(%rax)
movb $0x79, 0xe(%rax)
movb $0x79, 0x2a(%rax)
movb $0x79, 0x30(%rax)
movb $0x79, 0x12(%rax)
movb $0x79, 0x33(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq -0x10(%rbp), %rax
je 0x11d10
movl $0x0, -0x14(%rbp)
cmpl $0x6, -0x14(%rbp)
jge 0x11bfa
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x158e0
movb %al, %cl
movq -0x30(%rbp), %rax
movb %cl, -0x15(%rbp)
movb -0x15(%rbp), %dl
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11bc9
movl $0x0, -0x14(%rbp)
cmpl $0xc, -0x14(%rbp)
jge 0x11c58
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x15920
movw %ax, %cx
movq -0x30(%rbp), %rax
movw %cx, -0x17(%rbp)
movb -0x17(%rbp), %dl
movslq -0x14(%rbp), %rcx
movb %dl, 0x6(%rax,%rcx,2)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x15920
movw %ax, %cx
movq -0x30(%rbp), %rax
movw %cx, -0x19(%rbp)
movb -0x18(%rbp), %dl
movslq -0x14(%rbp), %rcx
movb %dl, 0x7(%rax,%rcx,2)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11c01
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jge 0x11d0e
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
movq %rsi, -0x38(%rbp)
callq 0x15980
movq -0x38(%rbp), %rsi
movl %eax, %ecx
movq -0x30(%rbp), %rax
movw %cx, %dx
movw %dx, -0x1c(%rbp)
shrl $0x10, %ecx
movb %cl, -0x1a(%rbp)
movb -0x1c(%rbp), %dl
movslq -0x14(%rbp), %rcx
leaq (%rcx,%rcx,2), %rcx
movb %dl, 0x1e(%rax,%rcx)
movq -0x10(%rbp), %rdi
callq 0x15980
movq -0x38(%rbp), %rsi
movl %eax, %ecx
movq -0x30(%rbp), %rax
movw %cx, %dx
movw %dx, -0x1f(%rbp)
shrl $0x10, %ecx
movb %cl, -0x1d(%rbp)
movb -0x1e(%rbp), %dl
movslq -0x14(%rbp), %rcx
leaq (%rcx,%rcx,2), %rcx
movb %dl, 0x1f(%rax,%rcx)
movq -0x10(%rbp), %rdi
callq 0x15980
movl %eax, %ecx
movq -0x30(%rbp), %rax
movw %cx, %dx
movw %dx, -0x22(%rbp)
shrl $0x10, %ecx
movb %cl, -0x20(%rbp)
movb -0x20(%rbp), %cl
addq $0x1e, %rax
movslq -0x14(%rbp), %rdx
imulq $0x3, %rdx, %rdx
addq %rdx, %rax
movb %cl, 0x2(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11c5f
jmp 0x11d10
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x2200
movl %eax, %edi
callq 0x2220
leaq -0x30(%rbp), %rdi
callq 0x3900
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0x12c, -0x34(%rbp)     # imm = 0x12C
jge 0x11ee7
callq 0x20a0
movl $0xc, %ecx
cltd
idivl %ecx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x11db5
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x55b0
jmp 0x11d96
jmp 0x11ed7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3a10
jmp 0x11ef6
cmpl $0x2, -0x14(%rbp)
jne 0x11dcf
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5660
jmp 0x11dca
jmp 0x11ed5
cmpl $0x3, -0x14(%rbp)
jne 0x11de9
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5710
jmp 0x11de4
jmp 0x11ed3
cmpl $0x4, -0x14(%rbp)
jne 0x11e03
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x57c0
jmp 0x11dfe
jmp 0x11ed1
cmpl $0x5, -0x14(%rbp)
jne 0x11e1d
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5af0
jmp 0x11e18
jmp 0x11ecf
cmpl $0x6, -0x14(%rbp)
jne 0x11e37
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5bb0
jmp 0x11e32
jmp 0x11ecd
cmpl $0x7, -0x14(%rbp)
jne 0x11e4e
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5c70
jmp 0x11e4c
jmp 0x11ecb
cmpl $0x8, -0x14(%rbp)
jne 0x11e65
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5d30
jmp 0x11e63
jmp 0x11ec9
cmpl $0x9, -0x14(%rbp)
jne 0x11e7c
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x59b0
jmp 0x11e7a
jmp 0x11ec7
cmpl $0xa, -0x14(%rbp)
jne 0x11e93
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5a50
jmp 0x11e91
jmp 0x11ec5
cmpl $0xb, -0x14(%rbp)
jne 0x11eaa
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5870
jmp 0x11ea8
jmp 0x11ec3
cmpl $0xc, -0x14(%rbp)
jne 0x11ec1
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5910
jmp 0x11ebf
jmp 0x11ec1
jmp 0x11ec3
jmp 0x11ec5
jmp 0x11ec7
jmp 0x11ec9
jmp 0x11ecb
jmp 0x11ecd
jmp 0x11ecf
jmp 0x11ed1
jmp 0x11ed3
jmp 0x11ed5
jmp 0x11ed7
jmp 0x11ed9
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x11d61
leaq -0x30(%rbp), %rdi
callq 0x3a10
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x23c0
nop