// File: /workspace/github_cpp_makefile_star2_O1/Rubenmp[P]Rubik/src/Rubik.cpp
// Function: main
int main(int argc, char* argv[]){
   Rubik rubik;
   char character;
   vector<char> solution;

   // Options
   if (argc == 1) {
     // Print help and exit
     arguments(argv[0]);
     return 1;    
   }
   else if (argc <= 4){
     // Probably there are better implementations to handle options
     if (argv[1][0] == '-'){
       if (strlen(argv[1]) != 2){ // Two or more options
         if (argv[1][1] == 'M'){ // Execute movement
           ifstream is;
           is.open(argv[2]);
         
           if (!is){
             cerr << "Error: not readable file " << argv[2] << "." << endl;
             return 1;
           }
           is >> rubik; // Read cube
           is.close();

           char mov = argv[1][2];
           if (mov == 'F')
             rubik.F(solution);
           else if (mov == 'f')
             rubik.f(solution);
           else if (mov == 'B')
             rubik.B(solution);
           else if (mov == 'b')
             rubik.b(solution);
           else if (mov == 'R')
             rubik.R(solution);
           else if (mov == 'r')
             rubik.r(solution);
           else if (mov == 'L')
             rubik.L(solution);
           else if (mov == 'l')
             rubik.l(solution);
           else if (mov == 'U')
             rubik.U(solution);
           else if (mov == 'u')
             rubik.u(solution);
           else if (mov == 'D')
             rubik.D(solution);
           else if (mov == 'd')
             rubik.d(solution);
           else{
             cerr << "Error: invalid movement (" << mov << ") to execute." << endl;
             return 1;
           }
           ofstream os;
           os.open(argv[2]);
           
           if (!os){
             cerr << "Error: not writable file " << argv[2] << endl;
             return 1;
           }
           os << rubik; // Write cube
           os.close();
         }
         else{
           cerr << "Error: too many options " << argv[1] << endl;
           return 1;
         }
       }
       else if ((argv[1][1] == 's' || argv[1][1] == 'p') && argc == 3){
         ifstream is;
         is.open(argv[2]);
         
         if (!is){
           cerr << "Error: not readable file " << argv[2] << endl;
           return 1;
         }
         is >> rubik; // Read cube
         is.close();
         if (argv[1][1] == 's'){
           if (rubik.isSolved())
             cout << "y" << endl;
           else
             cout << "n" << endl;
         }
         else
           rubik.printAll();
       }
       else{ // See options
         if (argv[1][1] == 'e') // Example
           Rubik::fileExample();
         else if (argv[1][1] == 'h') // Help
           arguments(argv[0]);
         else if (argv[1][1] == 'i'){ // Interactive mode
           char entry;
           do{
             cout << "Do you want to read of an file (1) or keyboard (2)." << endl;
             cin >> entry;
             cin.ignore(1024, '\n');
           }while(entry != '1' && entry != '2');
           
           if (entry == '1'){
             bool repeat = true;
             char anyKey[100];
             ifstream is;
             
             while (repeat){
               strcpy(anyKey, "");
               cout << "Create a file \"./data/rubik.dat\" with colours in valid order (see -e for explanation of valid file). ";
               cout << "Press any key to continue." << endl;
               cin.getline(anyKey, '\n');
               is.open("./data/rubik.dat");
               if (is)
                 repeat = false;
               else
                 cout << "It's imposible open \"./data/rubik.dat\"" << endl;
               
               is.close();
             }
             
             is.open("./data/rubik.dat");
             is >> rubik;
             is.close();
           }
           else{
             cout << "Reading rubik's cube in terminal (not recommended):" << endl;
             cin >> rubik;
           }
           
           rubik.printAll();
           do{
             cout << "Do you want to correct any position [y/n]?" << endl;
             cin >> character;
           }while (tolower(character) != 'y' && tolower(character) != 'n');
           
           if (tolower(character) == 'y')
             rubik.correctMistakes();
           
           rubik.solveStepByStep(solution);
         }
         else if (argv[1][1] == 'm') // Explain movements
           movements();
         else if (argv[1][1] == 'r'){ // Random solution
           bool boolean = true;
           Rubik aux;
           while (boolean){
             /*
               This is a trick, it will not fail ever... or you will not notice
               (Supposedly it will never repeat the loop if program is correct)
              */
             rubik = Rubik::randomRubik();
             aux = rubik;
             rubik.solve(solution);
             
             if (rubik.isSolved())
               boolean = false;
           }
           aux.printAll();
           cout << endl;
           cout << "Solution: ";
           for (unsigned int i=0; i<solution.size(); ++i)
             cout << solution[i];

           cout << endl << endl;
           rubik.printAll();
           cout << endl;
         }
         else if (argv[1][1] == 'R') // Random Rubik's cube
           cout << Rubik::randomRubik();
         else{
           if (argv[1][1] == 's'){
             cerr << "Error: -s option needs extra argument <input_file>." << endl;
             return 1;
           }
           else{
             cerr << "Error: invalid argument '" << argv[1][1] << "'." << endl;
             return 1;
           }
         }
       }
     }
     else if (argc <= 3) { // Files configuration
       ifstream file;
       file.open(argv[1]);
       if (!file) {
         cerr << "Error: not readable file " << argv[1] << "." << endl;
         return 1;
       }
       else{
         file >> rubik;
         file.close();
         rubik.solve(solution);
         
         if (argc == 2){
           for (unsigned int i=0; i<solution.size(); ++i)
             cout << solution[i];
           cout << endl;
         }
         else if (argc == 3){
           ofstream outFile(argv[2]);
           if (outFile.is_open()) {
             for (unsigned int i=0; i<solution.size(); ++i)
               outFile << solution[i];
             outFile << endl;
             outFile.close();
           }
           else{
             cerr << "Error: can not open " << argv[2] << "." << endl;
             return 1;
           }
         }
         else{
           cerr << "Error: invalid arguments, -h for help." << endl;
           return 1;
         }        
       }
     }
   }  
   else{
     cerr << "Error: invalid number of arguments." << endl;
     return 1;
   }

   return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4b8, %rsp            # imm = 0x4B8
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x32(%rsp), %rdi
callq 0x942e
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
cmpl $0x1, %ebp
jne 0x24f2
movq (%rbx), %rsi
leaq 0x88(%rsp), %rdi
leaq 0xa8(%rsp), %rdx
callq 0x32f0
leaq 0x88(%rsp), %rdi
callq 0xc75d
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x24e8
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x21a0
movl $0x1, %ebx
jmp 0x31a8
cmpl $0x4, %ebp
jg 0x2533
movq 0x8(%rbx), %r14
cmpb $0x2d, (%r14)
jne 0x2587
movq %r14, %rdi
callq 0x20a0
movzbl 0x1(%r14), %ecx
cmpq $0x2, %rax
jne 0x2614
cmpl $0x73, %ecx
jne 0x26ab
cmpl $0x3, %ebp
je 0x26b5
jmp 0x272f
movl $0x23, %edx
leaq 0xad5e(%rip), %rbx      # 0xd29d
movq 0xfaaa(%rip), %rdi      # 0x11ff0
movq %rbx, %rsi
callq 0x21d0
movq 0xfa9b(%rip), %rdi      # 0x11ff0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq 0xfa80(%rip), %rdi      # 0x11ff0
callq 0x2030
movl $0x1, %ebx
movq %rax, %rdi
callq 0x2110
jmp 0x31a8
cmpl $0x4, %ebp
je 0x31a6
leaq 0xa8(%rsp), %rdi
callq 0x21c0
movq 0x8(%rbx), %rsi
leaq 0xa8(%rsp), %rdi
movl $0x8, %edx
callq 0x20e0
movq 0xa8(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0xc8(%rsp,%rax)
je 0x278d
movq 0xfa1c(%rip), %r14      # 0x11ff0
leaq 0xaa65(%rip), %rsi      # 0xd040
movl $0x19, %edx
movq %r14, %rdi
callq 0x21d0
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0x283d
movq %rbx, %rdi
callq 0x20a0
movq 0xf9ec(%rip), %rdi      # 0x11ff0
movq %rbx, %rsi
movq %rax, %rdx
callq 0x21d0
jmp 0x2855
cmpl $0x4d, %ecx
jne 0x2755
leaq 0xa8(%rsp), %rdi
callq 0x21c0
movq 0x10(%rbx), %rsi
leaq 0xa8(%rsp), %rdi
movl $0x8, %edx
callq 0x20e0
movq 0xa8(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0xc8(%rsp,%rax)
je 0x28da
movq 0xf98f(%rip), %rdi      # 0x11ff0
leaq 0xa9d8(%rip), %rsi      # 0xd040
movl $0x19, %edx
callq 0x21d0
movq 0x10(%rbx), %rsi
movq 0xf973(%rip), %rdi      # 0x11ff0
callq 0x2180
movq %rax, %r14
leaq 0xabd3(%rip), %rsi      # 0xd25f
movl $0x1, %edx
movq %rax, %rdi
callq 0x21d0
movl $0x1, %ebx
movq %r14, %rdi
callq 0x20b0
jmp 0x3195
cmpl $0x3, %ebp
jne 0x272f
cmpb $0x70, %cl
jne 0x272f
leaq 0xa8(%rsp), %rdi
callq 0x21c0
movq 0x10(%rbx), %rsi
leaq 0xa8(%rsp), %rdi
movl $0x8, %edx
callq 0x20e0
movq 0xa8(%rsp), %rax
movq -0x18(%rax), %rax
movl 0xc8(%rsp,%rax), %ebp
testb $0x5, %bpl
je 0x2946
movq 0xf8f4(%rip), %rdi      # 0x11ff0
leaq 0xa93d(%rip), %rsi      # 0xd040
movl $0x19, %edx
callq 0x21d0
movq 0x10(%rbx), %rsi
movq 0xf8d8(%rip), %rdi      # 0x11ff0
callq 0x2180
movl $0x1, %ebx
movq %rax, %rdi
callq 0x20b0
jmp 0x2aed
leal -0x65(%rcx), %eax
cmpl $0xe, %eax
ja 0x2a7a
leaq 0xa8c2(%rip), %rcx      # 0xd004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0xafb6
jmp 0x31a6
movq 0xf894(%rip), %r14      # 0x11ff0
leaq 0xa939(%rip), %rsi      # 0xd09c
movl $0x18, %edx
movq %r14, %rdi
callq 0x21d0
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0x28bd
movq %rbx, %rdi
callq 0x20a0
movq %rax, %rdx
jmp 0x253f
leaq 0xa8(%rsp), %rdi
leaq 0x32(%rsp), %rsi
callq 0xc4d6
leaq 0xa8(%rsp), %rdi
callq 0x2060
leaq 0x2b0(%rsp), %rdx
movb $0x42, (%rdx)
leaq 0x32(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xaf5e
cmpl $0x3, %ebp
je 0x29b3
cmpl $0x2, %ebp
jne 0x2a51
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x282a
movl $0x1, %ebp
xorl %ecx, %ecx
movq 0xf7d6(%rip), %rbx      # 0x11fc8
leaq 0x2b0(%rsp), %r14
movb (%rax,%rcx), %al
movb %al, 0x2b0(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21d0
movl %ebp, %ecx
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdx
subq %rax, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x27fa
movq 0xf797(%rip), %rdi      # 0x11fc8
callq 0x20b0
xorl %ebx, %ebx
movb $0x1, %bpl
jmp 0x28a2
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2260
movq 0xf794(%rip), %rbx      # 0x11ff0
leaq 0xa9fc(%rip), %rsi      # 0xd25f
movl $0x1, %edx
movq %rbx, %rdi
callq 0x21d0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq 0xf762(%rip), %rdi      # 0x11ff0
callq 0x2030
movq %rax, %rdi
callq 0x2110
movl $0x1, %ebx
xorl %ebp, %ebp
leaq 0xa8(%rsp), %rdi
callq 0x2080
testb %bpl, %bpl
jne 0x31a6
jmp 0x31a8
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2260
jmp 0x254e
leaq 0xa8(%rsp), %rdi
leaq 0x32(%rsp), %rsi
callq 0xc4d6
leaq 0xa8(%rsp), %rdi
callq 0x2060
movq 0x8(%rbx), %rax
movb 0x2(%rax), %bpl
movzbl %bpl, %eax
cmpl $0x61, %eax
jg 0x2aa9
cmpl $0x4b, %eax
jg 0x2f06
cmpl $0x42, %eax
je 0x3071
cmpl $0x44, %eax
je 0x30b5
cmpl $0x46, %eax
jne 0x31d3
leaq 0x32(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x415a
jmp 0x30f7
leaq 0xa8(%rsp), %rdi
leaq 0x32(%rsp), %rsi
callq 0xc4d6
leaq 0xa8(%rsp), %rdi
callq 0x2060
movq 0x8(%rbx), %rax
cmpb $0x73, 0x1(%rax)
jne 0x2ae1
leaq 0x32(%rsp), %rdi
callq 0x9686
leaq 0xa731(%rip), %rcx      # 0xd0b5
leaq 0xa72c(%rip), %rsi      # 0xd0b7
testb %al, %al
cmovneq %rcx, %rsi
movq 0xf630(%rip), %rdi      # 0x11fc8
movl $0x1, %edx
callq 0x21d0
movq 0xf61f(%rip), %rdi      # 0x11fc8
callq 0x20b0
jmp 0x2aeb
movq 0x10(%rbx), %rsi
leaq 0x2b0(%rsp), %rdi
movl $0x10, %edx
callq 0x21b0
leaq 0x320(%rsp), %rdi
callq 0x2070
movl %eax, %ebp
testb %al, %al
je 0x2ea8
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x2a30
movl $0x1, %r15d
xorl %ecx, %ecx
leaq 0x2b0(%rsp), %rbx
leaq 0xe(%rsp), %r14
movb (%rax,%rcx), %al
movb %al, 0xe(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21d0
movl %r15d, %ecx
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdx
subq %rax, %rdx
incl %r15d
cmpq %rcx, %rdx
ja 0x2a01
leaq 0x2b0(%rsp), %rdi
callq 0x20b0
xorl %ebx, %ebx
leaq 0x2b0(%rsp), %rdi
callq 0x2200
jmp 0x2ef4
movq 0xf598(%rip), %rdi      # 0x11ff0
leaq 0xa817(%rip), %rsi      # 0xd276
movl $0x26, %edx
callq 0x21d0
movq 0xf580(%rip), %rdi      # 0x11ff0
callq 0x20b0
jmp 0x289b
cmpl $0x52, %ecx
jne 0x2b09
leaq 0xa8(%rsp), %rdi
callq 0xb21c
movq 0xf531(%rip), %rdi      # 0x11fc8
leaq 0xa8(%rsp), %rsi
callq 0xb232
jmp 0x31a6
cmpl $0x6b, %eax
jg 0x2f35
cmpl $0x62, %eax
je 0x3082
cmpl $0x64, %eax
je 0x30c6
cmpl $0x66, %eax
jne 0x31d3
leaq 0x32(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x41f6
jmp 0x30f7
leaq 0x32(%rsp), %rdi
callq 0xa412
xorl %ebx, %ebx
leaq 0xa8(%rsp), %rdi
callq 0x2080
testb $0x5, %bpl
jne 0x31a8
jmp 0x31a6
movq 0xf4e0(%rip), %rdi      # 0x11ff0
leaq 0xa72d(%rip), %rsi      # 0xd244
movl $0x19, %edx
callq 0x21d0
movq 0x8(%rbx), %rax
movb 0x1(%rax), %al
leaq 0xa8(%rsp), %rsi
movb %al, (%rsi)
movq 0xf4b7(%rip), %rdi      # 0x11ff0
movl $0x1, %edx
callq 0x21d0
movq %rax, %r14
leaq 0xa711(%rip), %rsi      # 0xd25e
movl $0x2, %edx
movq %rax, %rdi
callq 0x21d0
jmp 0x2d1e
movq 0xf462(%rip), %rbx      # 0x11fc8
leaq 0xa54c(%rip), %r15      # 0xd0b9
movq 0xf464(%rip), %r14      # 0x11fd8
leaq 0xe(%rsp), %r12
movl $0x33, %edx
movq %rbx, %rdi
movq %r15, %rsi
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
callq 0x2110
movq %r14, %rdi
movq %r12, %rsi
callq 0x21f0
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdi
movl $0xa, %edx
callq 0x20f0
movb 0xe(%rsp), %al
leal -0x33(%rax), %ecx
cmpb $-0x2, %cl
jb 0x2b79
cmpb $0x31, %al
jne 0x2f64
leaq 0xa8(%rsp), %rdi
callq 0x21c0
movb $0x1, %r12b
leaq 0x2b0(%rsp), %r13
leaq 0xa56e(%rip), %rbp      # 0xd16e
leaq 0xa8(%rsp), %r15
testb $0x1, %r12b
je 0x2f9b
movb $0x0, 0x2b0(%rsp)
movl $0x65, %edx
movq %rbx, %rdi
leaq 0xa4c4(%rip), %rsi      # 0xd0ed
callq 0x21d0
movl $0x1a, %edx
movq %rbx, %rdi
leaq 0xa516(%rip), %rsi      # 0xd153
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
callq 0x2110
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %ecx
movl $0xa, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x22a0
movq %r15, %rdi
movq %rbp, %rsi
movl $0x8, %edx
callq 0x20e0
movq 0xa8(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0xc8(%rsp,%rax)
je 0x2cf3
movl $0x26, %edx
movq %rbx, %rdi
leaq 0xa4ba(%rip), %rsi      # 0xd17f
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
callq 0x2110
jmp 0x2cf6
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x2060
jmp 0x2c08
movq 0xf2e6(%rip), %r14      # 0x11ff0
leaq 0xa4ff(%rip), %rsi      # 0xd210
movl $0x33, %edx
movq %r14, %rdi
callq 0x21d0
movl $0x1, %ebx
movq %r14, %rdi
callq 0x20b0
jmp 0x31a8
callq 0xc6f1
jmp 0x31a6
movq (%rbx), %rsi
leaq 0x68(%rsp), %rdi
leaq 0xa8(%rsp), %rdx
callq 0x32f0
leaq 0x68(%rsp), %rdi
callq 0xc75d
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x31a6
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x31a6
leaq 0xa8(%rsp), %rdi
callq 0x942e
movb $0x1, %bpl
leaq 0x2b0(%rsp), %rbx
leaq 0x32(%rsp), %r14
leaq 0xa8(%rsp), %r15
leaq 0x10(%rsp), %r12
xorl %r13d, %r13d
movq %rbx, %rdi
callq 0xb21c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x94d4
movq %r15, %rdi
movq %r14, %rsi
callq 0x94d4
movb $0x42, 0x2b0(%rsp)
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xaf5e
movq %r14, %rdi
callq 0x9686
movzbl %bpl, %ebp
testb %al, %al
cmovnel %r13d, %ebp
testb $0x1, %bpl
jne 0x2daa
leaq 0xa8(%rsp), %rdi
callq 0xa412
movq 0xf1be(%rip), %rdi      # 0x11fc8
callq 0x20b0
movq 0xf1b2(%rip), %rdi      # 0x11fc8
leaq 0xa3e8(%rip), %rsi      # 0xd205
movl $0xa, %edx
callq 0x21d0
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x2e79
movl $0x1, %ebp
xorl %ecx, %ecx
movq 0xf187(%rip), %rbx      # 0x11fc8
leaq 0x2b0(%rsp), %r14
movb (%rax,%rcx), %al
movb %al, 0x2b0(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21d0
movl %ebp, %ecx
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdx
subq %rax, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x2e49
movq 0xf148(%rip), %rdi      # 0x11fc8
callq 0x20b0
movq %rax, %rdi
callq 0x20b0
leaq 0x32(%rsp), %rdi
callq 0xa412
movq 0xf12a(%rip), %rdi      # 0x11fc8
callq 0x20b0
jmp 0x31a6
movq 0xf141(%rip), %rdi      # 0x11ff0
leaq 0xa3ab(%rip), %rsi      # 0xd261
movl $0x14, %edx
callq 0x21d0
movq 0x10(%rbx), %rsi
movq 0xf125(%rip), %rdi      # 0x11ff0
callq 0x2180
movq %rax, %r14
leaq 0xa385(%rip), %rsi      # 0xd25f
movl $0x1, %edx
movq %rax, %rdi
callq 0x21d0
movl $0x1, %ebx
movq %r14, %rdi
callq 0x20b0
leaq 0x2b0(%rsp), %rdi
callq 0x2220
jmp 0x28a2
cmpl $0x4c, %eax
je 0x3093
cmpl $0x52, %eax
je 0x30d7
cmpl $0x55, %eax
jne 0x31d3
leaq 0x32(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x406e
jmp 0x30f7
cmpl $0x6c, %eax
je 0x30a4
cmpl $0x72, %eax
je 0x30e8
cmpl $0x75, %eax
jne 0x31d3
leaq 0x32(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x40e4
jmp 0x30f7
movq 0xf05d(%rip), %rdi      # 0x11fc8
leaq 0xa234(%rip), %rsi      # 0xd1a6
movl $0x33, %edx
callq 0x21d0
movq 0xf045(%rip), %rdi      # 0x11fc8
callq 0x20b0
movq 0xf049(%rip), %rdi      # 0x11fd8
leaq 0x32(%rsp), %rsi
callq 0xc4d6
jmp 0x2fe0
leaq 0xa1cc(%rip), %rsi      # 0xd16e
leaq 0xa8(%rsp), %rdi
movl $0x8, %edx
callq 0x20e0
leaq 0xa8(%rsp), %rdi
leaq 0x32(%rsp), %rsi
callq 0xc4d6
leaq 0xa8(%rsp), %rdi
callq 0x2060
leaq 0xa8(%rsp), %rdi
callq 0x2080
leaq 0x32(%rsp), %rdi
callq 0xa412
leaq 0xa1e9(%rip), %r14      # 0xd1da
movq 0xefe0(%rip), %r15      # 0x11fd8
leaq 0xf(%rsp), %r12
movl $0x2a, %edx
movq %rbx, %rdi
movq %r14, %rsi
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
callq 0x2110
movq %r15, %rdi
movq %r12, %rsi
callq 0x21f0
movsbl 0xf(%rsp), %edi
callq 0x2210
cmpl $0x6e, %eax
je 0x305d
cmpl $0x79, %eax
jne 0x2ffd
leaq 0x32(%rsp), %rdi
callq 0x9bee
leaq 0x32(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xabe0
jmp 0x31a6
leaq 0x32(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x429a
jmp 0x30f7
leaq 0x32(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4340
jmp 0x30f7
leaq 0x32(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3e64
jmp 0x30f7
leaq 0x32(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3ef0
jmp 0x30f7
leaq 0x32(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3f82
jmp 0x30f7
leaq 0x32(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3ff8
jmp 0x30f7
leaq 0x32(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3d46
jmp 0x30f7
leaq 0x32(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3dd8
leaq 0x2b0(%rsp), %rdi
callq 0x2270
movq 0x10(%rbx), %rsi
leaq 0x2b0(%rsp), %rdi
movl $0x10, %edx
callq 0x2050
movq 0x2b0(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x2d0(%rsp,%rax)
je 0x3167
movq 0xeeb9(%rip), %rdi      # 0x11ff0
leaq 0x9f44(%rip), %rsi      # 0xd082
movl $0x19, %edx
callq 0x21d0
movq 0x10(%rbx), %rsi
movq 0xee9d(%rip), %rdi      # 0x11ff0
callq 0x2180
movl $0x1, %ebx
movq %rax, %rdi
callq 0x20b0
jmp 0x3188
leaq 0x2b0(%rsp), %rdi
leaq 0x32(%rsp), %rsi
callq 0xb232
xorl %ebx, %ebx
leaq 0x2b0(%rsp), %rdi
callq 0x2200
leaq 0x2b0(%rsp), %rdi
callq 0x2220
leaq 0xa8(%rsp), %rdi
callq 0x2080
testl %ebx, %ebx
jne 0x31a8
xorl %ebx, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x31bf
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
movl %ebx, %eax
addq $0x4b8, %rsp            # imm = 0x4B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xee16(%rip), %rdi      # 0x11ff0
leaq 0x9e79(%rip), %rsi      # 0xd05a
movl $0x19, %edx
callq 0x21d0
leaq 0x2b0(%rsp), %rsi
movb %bpl, (%rsi)
movq 0xedf3(%rip), %rdi      # 0x11ff0
movl $0x1, %edx
callq 0x21d0
movq %rax, %r14
leaq 0x9e63(%rip), %rsi      # 0xd074
movl $0xd, %edx
movq %rax, %rdi
callq 0x21d0
movl $0x1, %ebx
movq %r14, %rdi
callq 0x20b0
jmp 0x3195
jmp 0x32cd
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32d0
movq 0x78(%rsp), %rsi
jmp 0x32ad
jmp 0x32cd
jmp 0x32cd
jmp 0x32b9
jmp 0x32b9
jmp 0x32b9
jmp 0x32b9
jmp 0x32cd
jmp 0x326d
jmp 0x32b9
jmp 0x32cd
jmp 0x32cd
jmp 0x32cd
jmp 0x326d
jmp 0x32cd
movq %rax, %rbx
leaq 0x2b0(%rsp), %rdi
callq 0x2220
jmp 0x32bc
jmp 0x32cd
jmp 0x32cd
jmp 0x32b9
jmp 0x32b9
jmp 0x32b9
jmp 0x32cd
jmp 0x32cd
jmp 0x32cd
jmp 0x32b9
movq %rax, %rbx
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32d0
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x32d0
jmp 0x32cd
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x2080
jmp 0x32d0
jmp 0x32cd
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x32e7
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x2280
nop