LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/adrianphoulady[P]weighted-tsetlin-machine-cpp/./weightm.h
// Function: weightm::literal_mask()
void literal_mask() {
        int n = features << 1, flips = binomial(p, n);
        bool const target = flips <= features;
        // if flips are more than half, do it the other way; make 0s in an all-1 sequence
        if (!target)
            flips = n - flips;
        std::fill(&lmask(0), &lmask(literals), target - 1);
        while (flips) {
            auto l = fastrandrange(n), w = l / word_bits, b = l % word_bits;
            if ((lmask(w) >> b & 1) == target)
                continue;
            lmask(w) ^= (word) 1 << b;
            --flips;
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl (%rdi), %ebp
addl %ebp, %ebp
movsd 0x8(%rdi), %xmm1
cvtsi2sd %ebp, %xmm0
movsd 0x1324(%rip), %xmm2     # 0x50a0
subsd %xmm1, %xmm2
movsd %xmm0, 0x10(%rsp)
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
mulsd %xmm1, %xmm2
movsd %xmm2, (%rsp)
callq 0x317d
callq 0x2190
mulsd 0x12fd(%rip), %xmm0     # 0x50a8
mulsd (%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x3dc0
sqrtsd %xmm0, %xmm0
jmp 0x3dc5
callq 0x2180
movsd %xmm0, (%rsp)
callq 0x317d
mulsd 0x12d9(%rip), %xmm0     # 0x50b0
callq 0x2090
mulsd (%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
addsd 0x12a1(%rip), %xmm0     # 0x5090
ucomisd 0x10(%rsp), %xmm0
cvttsd2si %xmm0, %r14d
cmovael %ebp, %r14d
xorl %eax, %eax
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
cmovael %eax, %r14d
movl (%rbx), %r15d
xorl %ecx, %ecx
cmpl %r15d, %r14d
setg %cl
movl %ebp, %r12d
subl %r14d, %r12d
movq 0x48(%rbx), %rdx
movslq 0x20(%rbx), %rsi
negl %ecx
shlq $0x2, %rsi
cmpq %rax, %rsi
je 0x3e39
movl %ecx, (%rdx,%rax)
addq $0x4, %rax
jmp 0x3e2b
cmpl %r15d, %r14d
cmovlel %r14d, %r12d
testl %r12d, %r12d
je 0x3e76
cmpl %r15d, %r14d
setle %r13b
movl %ebp, %edi
callq 0x2c58
movl %eax, %ecx
shrl $0x5, %ecx
andl $0x1f, %eax
movq 0x48(%rbx), %rdx
movl (%rdx,%rcx,4), %esi
btl %eax, %esi
sbbb $0x0, %r13b
je 0x3e40
btcl %eax, %esi
movl %esi, (%rdx,%rcx,4)
decl %r12d
jmp 0x3e40
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/adrianphoulady[P]weighted-tsetlin-machine-cpp/./weightm.h
// Function: weightm::add(unsigned int*, unsigned int)
void add(word *state_word, word addend) {
        for (int b = 0; addend && b < states; ++b) {
            state_word[b] ^= addend;
            addend &= state_word[b] ^ addend;
        }
        if (addend)
            for (int b = 0; b < states; ++b)
                state_word[b] ^= addend;
    }

// Assembly:
xorl %eax, %eax
movl 0x1c(%rdi), %ecx
testl %edx, %edx
je 0x3eab
movslq %ecx, %r8
cmpq %r8, %rax
jge 0x3eab
movl (%rsi,%rax,4), %ecx
movl %ecx, %r8d
xorl %edx, %r8d
movl %r8d, (%rsi,%rax,4)
andl %ecx, %edx
incq %rax
jmp 0x3e88
testl %edx, %edx
je 0x3ec4
xorl %eax, %eax
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x3ec4
xorl %edx, (%rsi,%rax,4)
incq %rax
movl 0x1c(%rdi), %ecx
jmp 0x3eb1
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/adrianphoulady[P]weighted-tsetlin-machine-cpp/./weightm.h
// Function: weightm::subtract(unsigned int*, unsigned int)
void subtract(word *state_word, word subtrahend) {
        for (int b = 0; subtrahend && b < states; ++b) {
            state_word[b] ^= subtrahend;
            subtrahend &= ~(state_word[b] ^ subtrahend);
        }
        if (subtrahend)
            for (int b = 0; b < states; ++b)
                state_word[b] ^= subtrahend;
    }

// Assembly:
xorl %eax, %eax
movl 0x1c(%rdi), %ecx
testl %edx, %edx
je 0x3eed
movslq %ecx, %r8
cmpq %r8, %rax
jge 0x3eed
movl (%rsi,%rax,4), %ecx
movl %ecx, %r8d
xorl %edx, %r8d
movl %r8d, (%rsi,%rax,4)
notl %ecx
andl %ecx, %edx
incq %rax
jmp 0x3ec8
testl %edx, %edx
je 0x3f06
xorl %eax, %eax
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x3f06
xorl %edx, (%rsi,%rax,4)
incq %rax
movl 0x1c(%rdi), %ecx
jmp 0x3ef3
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/adrianphoulady[P]weighted-tsetlin-machine-cpp/./multiweightm.h
// Function: multiweightm::predict(unsigned int*)
int predict(word *input) {
        int mxi = 0;
        double mxv = machine(0).infer(input), v;
        for (int m = 1; m < classes; ++m)
            if (mxv < (v = machine(m).infer(input))) {
                mxv = v;
                mxi = m;
            }
        return mxi;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
xorl %ebp, %ebp
xorl %edx, %edx
callq 0x3ace
pushq $0x1
popq %r15
pushq $0x70
popq %r12
movslq 0x4(%r14), %rax
cmpq %rax, %r15
jge 0x3f6a
movq 0x10(%r14), %rdi
addq %r12, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movsd %xmm0, 0x8(%rsp)
callq 0x3ace
movsd 0x8(%rsp), %xmm1
ucomisd %xmm1, %xmm0
cmoval %r15d, %ebp
maxsd %xmm1, %xmm0
incq %r15
addq $0x70, %r12
jmp 0x3f2f
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/adrianphoulady[P]weighted-tsetlin-machine-cpp/./weightm.h
// Function: weightm::serialize(std::ostream&)
void serialize(std::ostream &os) {
        put(os, features);
        put(os, clauses);
        put(os, p);
        put(os, gamma);
        put(os, threshold);
        put(os, states);
        put(os, mcg_state);
        for (int c = 0; c < clauses; ++c)
            for (int l = 0; l < literals; ++l)
                for (int b = 0; b < states; ++b)
                    put(os, state(c, l, b));
        for (int c = 0; c < clauses; ++c)
            put(os, weight(c));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %esi
movq %rbx, %rdi
callq 0x3f79
movl 0x4(%r14), %esi
movq %rbx, %rdi
callq 0x3f79
movsd 0x8(%r14), %xmm0
movq %rbx, %rdi
callq 0x4075
movsd 0x10(%r14), %xmm0
movq %rbx, %rdi
callq 0x4075
movl 0x18(%r14), %esi
movq %rbx, %rdi
callq 0x3f79
movl 0x1c(%r14), %esi
movq %rbx, %rdi
callq 0x3f79
movq 0x41b3(%rip), %rsi      # 0x81a0
movq %rbx, %rdi
callq 0x4087
xorl %r15d, %r15d
movl 0x4(%r14), %eax
cmpl %eax, %r15d
jge 0x4047
xorl %ebp, %ebp
cmpl 0x20(%r14), %ebp
jge 0x4042
xorl %r12d, %r12d
cmpl 0x1c(%r14), %r12d
jge 0x403e
movq 0x38(%r14), %rax
movslq 0x30(%r14), %rcx
movl 0x2c(%r14), %edx
imull %r15d, %edx
addl %ebp, %edx
movslq %edx, %rdx
imulq %rcx, %rdx
addq %r12, %rdx
movl (%rax,%rdx,4), %esi
movq %rbx, %rdi
callq 0x409b
incq %r12
jmp 0x400c
incl %ebp
jmp 0x4003
incl %r15d
jmp 0x3ff8
xorl %r15d, %r15d
cltq
cmpq %rax, %r15
jge 0x406c
movq 0x68(%r14), %rax
movsd (%rax,%r15,8), %xmm0
movq %rbx, %rdi
callq 0x4075
incq %r15
movl 0x4(%r14), %eax
jmp 0x404a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/gen-bases.c
// Function: ulog2
unsigned int
ulog2 (unsigned int x)
{
  unsigned int i;
  for (i = 0;  x != 0;  i++)
    x >>= 1;
  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
testl %edi, %edi
je 0x789e
shrl %edi
incl %eax
jmp 0x7894
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/gen-bases.c
// Function: generate
void
generate (int limb_bits, int nail_bits, int base)
{
  int  numb_bits = limb_bits - nail_bits;

  mpz_set_ui (t, 1L);
  mpz_mul_2exp (t, t, numb_bits);
  mpz_set_ui (big_base, 1L);
  chars_per_limb = 0;
  for (;;)
    {
      mpz_mul_ui (big_base, big_base, (long) base);
      if (mpz_cmp (big_base, t) > 0)
        break;
      chars_per_limb++;
    }

  mpz_ui_pow_ui (big_base, (long) base, (long) chars_per_limb);

  normalization_steps = limb_bits - mpz_sizeinbase (big_base, 2);

  mpz_set_ui (t, 1L);
  mpz_mul_2exp (t, t, 2*limb_bits - normalization_steps);
  mpz_tdiv_q (big_base_inverted, t, big_base);
  mpz_set_ui (t, 1L);
  mpz_mul_2exp (t, t, limb_bits);
  mpz_sub (big_base_inverted, big_base_inverted, t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %edi, %ebx
movl %edi, %eax
subl %esi, %eax
leaq 0x6812(%rip), %r14      # 0xe0d0
movq 0x6813(%rip), %rcx      # 0xe0d8
pushq $0x1
popq %r12
movq %r12, (%rcx)
pushq $0x1
popq %r13
movl %r13d, 0x67fd(%rip)     # 0xe0d4
movslq %eax, %rdx
movq %r14, %rdi
movq %r14, %rsi
callq 0x305c
movq 0x67fc(%rip), %rax      # 0xe0e8
movq %r12, (%rax)
movl %r13d, 0x67ee(%rip)     # 0xe0e4
movslq %r15d, %r12
xorl %ecx, %ecx
leaq 0x67de(%rip), %r15      # 0xe0e0
movl %ecx, 0x67e8(%rip)      # 0xe0f0
movq %r15, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2ed3
movq %r15, %rdi
movq %r14, %rsi
callq 0x2973
movslq 0x67c8(%rip), %rdx      # 0xe0f0
leal 0x1(%rdx), %ecx
testl %eax, %eax
jle 0x7902
leaq 0x67aa(%rip), %r15      # 0xe0e0
movq %r15, %rdi
movq %r12, %rsi
callq 0x4c77
movslq %ebx, %rax
movq %rax, -0x30(%rbp)
pushq $0x2
popq %rsi
movq %r15, %rdi
callq 0x5854
movl %ebx, %ecx
subl %eax, %ecx
movl %ecx, 0x6797(%rip)      # 0xe0f4
leaq 0x676c(%rip), %r12      # 0xe0d0
movq 0x676d(%rip), %rax      # 0xe0d8
pushq $0x1
popq %r13
movq %r13, (%rax)
pushq $0x1
popq %r14
movl %r14d, 0x6757(%rip)     # 0xe0d4
addl %ebx, %ebx
subl %ecx, %ebx
movslq %ebx, %rdx
movq %r12, %rdi
movq %r12, %rsi
callq 0x305c
leaq 0x676a(%rip), %rbx      # 0xe100
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x36d3
movq 0x672d(%rip), %rax      # 0xe0d8
movq %r13, (%rax)
movl %r14d, 0x671f(%rip)     # 0xe0d4
movq %r12, %rdi
movq %r12, %rsi
movq -0x30(%rbp), %rdx
callq 0x305c
movq %rbx, %rdi
movq %rbx, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2e5a
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/gen-bases.c
// Function: header
void
header (int limb_bits, int nail_bits)
{
  int  numb_bits = limb_bits - nail_bits;

  generate (limb_bits, nail_bits, 10);

  printf ("/* This file generated by gen-bases.c - DO NOT EDIT. */\n");
  printf ("\n");
  printf ("#if GMP_NUMB_BITS != %d\n", numb_bits);
  printf ("Error, error, this data is for %d bits\n", numb_bits);
  printf ("#endif\n");
  printf ("\n");
  printf ("/* mp_bases[10] data, as literal values */\n");
  printf ("#define MP_BASES_CHARS_PER_LIMB_10      %d\n", chars_per_limb);
  printf ("#define MP_BASES_BIG_BASE_10            CNST_LIMB(0x");
  mpz_out_str (stdout, 16, big_base);
  printf (")\n");
  printf ("#define MP_BASES_BIG_BASE_INVERTED_10   CNST_LIMB(0x");
  mpz_out_str (stdout, 16, big_base_inverted);
  printf (")\n");
  printf ("#define MP_BASES_NORMALIZATION_STEPS_10 %d\n", normalization_steps);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %r14d
subl %esi, %r14d
pushq $0xa
popq %rbx
movl %ebx, %edx
callq 0x78a0
leaq 0x2b44(%rip), %rdi      # 0xa545
callq 0x1060
movl %ebx, %edi
callq 0x1040
leaq 0x20cf(%rip), %rdi      # 0x9ae3
movl %r14d, %esi
xorl %eax, %eax
callq 0x1080
leaq 0x20d7(%rip), %rdi      # 0x9afc
movl %r14d, %esi
xorl %eax, %eax
callq 0x1080
leaq 0x2b6e(%rip), %rdi      # 0xa5a4
callq 0x1060
movl %ebx, %edi
callq 0x1040
leaq 0x2ad1(%rip), %rdi      # 0xa51a
callq 0x1060
movl 0x669c(%rip), %esi      # 0xe0f0
leaq 0x20c9(%rip), %rdi      # 0x9b24
xorl %eax, %eax
callq 0x1080
leaq 0x20e7(%rip), %rdi      # 0x9b50
xorl %eax, %eax
callq 0x1080
movq 0x6561(%rip), %r15      # 0xdfd8
movq (%r15), %rdi
leaq 0x665f(%rip), %rdx      # 0xe0e0
pushq $0x10
popq %rbx
movl %ebx, %esi
callq 0x70a6
leaq 0x1eb1(%rip), %r14      # 0x9943
movq %r14, %rdi
callq 0x1060
leaq 0x20e4(%rip), %rdi      # 0x9b85
xorl %eax, %eax
callq 0x1080
movq (%r15), %rdi
leaq 0x664e(%rip), %rdx      # 0xe100
movl %ebx, %esi
callq 0x70a6
movq %r14, %rdi
callq 0x1060
movl 0x662d(%rip), %esi      # 0xe0f4
leaq 0x20ec(%rip), %rdi      # 0x9bba
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/gen-bases.c
// Function: mp_2logb
void
mp_2logb (mpz_t r, int bi, int prec)
{
  mpz_t t, t2, two, b;
  int i;

  mpz_init_set_ui (t, 1);
  mpz_mul_2exp (t, t, prec+EXTRA);

  mpz_init (t2);

  mpz_init_set_ui (two, 2);
  mpz_mul_2exp (two, two, prec+EXTRA);

  mpz_set_ui (r, 0);

  mpz_init_set_ui (b, bi);
  mpz_mul_2exp (b, b, prec+EXTRA);

  for (i = prec-1; i >= 0; i--)
    {
      mpz_mul_2exp (b, b, prec+EXTRA);
      mpz_sqrt (b, b);

      mpz_mul (t2, t, b);
      mpz_tdiv_q_2exp (t2, t2, prec+EXTRA);

      if (mpz_cmp (t2, two) < 0)	/* not too large? */
	{
	  mpz_setbit (r, i);		/* set next less significant bit */
	  mpz_set (t, t2);		/* new value acceptable */
	}
    }

  mpz_clear (t);
  mpz_clear (t2);
  mpz_clear (two);
  mpz_clear (b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, %r14d
movl %esi, -0x2c(%rbp)
movq %rdi, %rbx
pushq $0x1
popq %r15
leaq -0x80(%rbp), %r13
movl %r15d, (%r13)
pushq $0x8
popq %rdi
callq *0x6592(%rip)           # 0xe0a0
movq %rax, 0x8(%r13)
pushq $0x1
popq %r12
movq %r12, (%rax)
movl %r15d, 0x4(%r13)
movq %r14, -0x58(%rbp)
leal 0x10(%r14), %eax
movslq %eax, %r14
movq %r13, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x305c
movq %r12, -0x50(%rbp)
pushq $0x8
popq %rdi
callq *0x655d(%rip)           # 0xe0a0
movq %rax, -0x48(%rbp)
leaq -0x70(%rbp), %r13
movl %r15d, (%r13)
pushq $0x8
popq %rdi
movq %rdi, %r12
callq *0x6545(%rip)           # 0xe0a0
movq %rax, 0x8(%r13)
movq $0x2, (%rax)
movl %r15d, 0x4(%r13)
movq %r13, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x305c
movq %rbx, -0x60(%rbp)
andl $0x0, 0x4(%rbx)
movl %r15d, -0x40(%rbp)
movq %r12, %rdi
callq *0x6513(%rip)           # 0xe0a0
movl -0x2c(%rbp), %ecx
movq %rax, -0x38(%rbp)
testl %ecx, %ecx
je 0x7ba0
movslq %ecx, %rcx
movq %rcx, (%rax)
jmp 0x7ba3
xorl %r15d, %r15d
leaq -0x40(%rbp), %r12
movl %r15d, 0x4(%r12)
movq %r12, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x305c
movl -0x58(%rbp), %r15d
leaq -0x50(%rbp), %r13
leaq -0x80(%rbp), %rbx
testl %r15d, %r15d
jle 0x7c2c
decq %r15
movq %r12, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x305c
movq %r12, %rdi
movq %r12, %rsi
callq 0x5a2c
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x2f64
movq %r13, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x38b6
movq %r13, %rdi
leaq -0x70(%rbp), %rsi
callq 0x2973
testl %eax, %eax
jns 0x7bc6
movq -0x60(%rbp), %rdi
movq %r15, %rsi
callq 0x497f
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2246
jmp 0x7bc6
movq -0x78(%rbp), %rdi
xorl %esi, %esi
callq *0x6478(%rip)           # 0xe0b0
movq -0x48(%rbp), %rdi
xorl %esi, %esi
callq *0x646c(%rip)           # 0xe0b0
movq -0x68(%rbp), %rdi
xorl %esi, %esi
callq *0x6460(%rip)           # 0xe0b0
movq -0x38(%rbp), %rdi
xorl %esi, %esi
callq *0x6454(%rip)           # 0xe0b0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/gen-bases.c
// Function: main
int
main (int argc, char **argv)
{
  int  limb_bits, nail_bits;

  mpz_init (big_base);
  mpz_init (big_base_inverted);
  mpz_init (t);

  if (argc != 4)
    {
      fprintf (stderr, "Usage: gen-bases <header|table> <limbbits> <nailbits>\n");
      exit (1);
    }

  limb_bits = atoi (argv[2]);
  nail_bits = atoi (argv[3]);

  if (limb_bits <= 0
      || nail_bits < 0
      || nail_bits >= limb_bits)
    {
      fprintf (stderr, "Invalid limb/nail bits: %d %d\n",
               limb_bits, nail_bits);
      exit (1);
    }

  if (strcmp (argv[1], "header") == 0)
    header (limb_bits, nail_bits);
  else if (strcmp (argv[1], "table") == 0)
    table (limb_bits, nail_bits);
  else
    {
      fprintf (stderr, "Invalid header/table choice: %s\n", argv[1]);
      exit (1);
    }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movl %edi, %ebx
pushq $0x1
popq %r12
movq %r12, 0x6161(%rip)      # 0xe0e0
pushq $0x8
popq %r15
movq %r15, %rdi
callq *0x6114(%rip)           # 0xe0a0
movq %rax, 0x6155(%rip)      # 0xe0e8
movq %r12, 0x6166(%rip)      # 0xe100
movq %r15, %rdi
callq *0x60fd(%rip)           # 0xe0a0
movq %rax, 0x615e(%rip)      # 0xe108
movq %r12, 0x611f(%rip)      # 0xe0d0
movq %r15, %rdi
callq *0x60e6(%rip)           # 0xe0a0
movq %rax, 0x6117(%rip)      # 0xe0d8
cmpl $0x4, %ebx
jne 0x8036
movq 0x10(%r14), %rdi
callq 0x10e0
movl %eax, %ebx
movq 0x18(%r14), %rdi
callq 0x10e0
movl %eax, %r15d
testl %ebx, %ebx
jle 0x8054
testl %r15d, %r15d
js 0x8054
cmpl %ebx, %r15d
jge 0x8054
movq 0x8(%r14), %r14
leaq 0x1ccf(%rip), %rsi      # 0x9cc5
movq %r14, %rdi
callq 0x10a0
testl %eax, %eax
je 0x8021
leaq 0x1cc3(%rip), %rsi      # 0x9ccc
movq %r14, %rdi
callq 0x10a0
testl %eax, %eax
jne 0x8073
movl %ebx, %edi
movl %r15d, %esi
callq 0x7c6b
jmp 0x802b
movl %ebx, %edi
movl %r15d, %esi
callq 0x79e0
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x5fbb(%rip), %rax      # 0xdff8
movq (%rax), %rcx
leaq 0x1c28(%rip), %rdi      # 0x9c6f
pushq $0x36
popq %rsi
pushq $0x1
popq %rdx
callq 0x1100
jmp 0x808e
movq 0x5f9d(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x1c41(%rip), %rsi      # 0x9ca6
movl %ebx, %edx
movl %r15d, %ecx
xorl %eax, %eax
callq 0x10b0
jmp 0x808e
movq 0x5f7e(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x1c4e(%rip), %rsi      # 0x9cd2
movq %r14, %rdx
xorl %eax, %eax
callq 0x10b0
pushq $0x1
popq %rdi
callq 0x10f0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x58, %rsp
movq %rdi, %rbx
movb 0x1f514(%rip), %al      # 0x2a7c8
testb %al, %al
je 0xb3a8
leaq 0x20(%rbx), %r14
leaq 0x68(%rbx), %rax
movq %rax, -0x50(%rbp)
xorl %r13d, %r13d
movq %r13, %r12
shlq $0x5, %r12
movq 0x20(%rbx), %r15
movq 0x28(%rbx), %rax
subq %r15, %rax
sarq $0x5, %rax
cmpq %rax, %r13
jae 0xb399
addq %r12, %r15
movq %r15, %rdi
leaq 0x1f4b1(%rip), %rsi     # 0x2a7a8
xorl %edx, %edx
callq 0xc400
testb %al, %al
je 0xb391
movq 0x8(%r15), %rcx
decq %rcx
leaq -0x48(%rbp), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x5340
leaq -0x68(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movq -0x48(%rbp), %rax
leaq -0x38(%rbp), %rdx
cmpq %rdx, %rax
je 0xb33e
movq %rax, -0x78(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0xb344
movups (%rdx), %xmm0
movups %xmm0, (%rcx)
leaq -0x78(%rbp), %r15
movq -0x40(%rbp), %rax
movq %rdx, -0x48(%rbp)
andq $0x0, -0x40(%rbp)
movq %rax, -0x70(%rbp)
movb $0x0, -0x38(%rbp)
movl %r13d, -0x58(%rbp)
movq -0x50(%rbp), %rdi
movq %r15, %rsi
callq 0x1976a
movq %r15, %rdi
callq 0x5160
leaq -0x48(%rbp), %rdi
callq 0x5160
movq (%r14), %rsi
addq %r12, %rsi
movq %r14, %rdi
callq 0xc41c
jmp 0xb2d2
incq %r13
jmp 0xb2cb
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f419(%rip), %rdi     # 0x2a7c8
callq 0x5580
testl %eax, %eax
je 0xb2bc
leaq 0x1f3e5(%rip), %rdi     # 0x2a7a8
leaq 0x11021(%rip), %rsi     # 0x1c3eb
pushq $0x10
popq %rdx
callq 0xbb98
leaq 0x829(%rip), %rdi       # 0xbc02
leaq 0x1f3c8(%rip), %rsi     # 0x2a7a8
leaq 0x1ef41(%rip), %rdx     # 0x2a328
callq 0x52b0
leaq 0x1f3d5(%rip), %rdi     # 0x2a7c8
callq 0x5210
jmp 0xb2bc
movq %rax, %rbx
leaq 0x1f3c1(%rip), %rdi     # 0x2a7c8
callq 0x5200
jmp 0xb423
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x5160
leaq -0x48(%rbp), %rdi
callq 0x5160
movq %rbx, %rdi
callq 0x5560
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, -0x30(%rbp)
movb 0x1f3a9(%rip), %al      # 0x2a7f0
testb %al, %al
je 0xb4eb
movb 0x1f3c3(%rip), %al      # 0x2a818
testb %al, %al
je 0xb543
movq -0x30(%rbp), %rax
movq 0x20(%rax), %r14
leaq 0x1f364(%rip), %r15     # 0x2a7d0
leaq 0x10f70(%rip), %r12     # 0x1c3e3
leaq -0x50(%rbp), %r13
leaq 0x1f37a(%rip), %rbx     # 0x2a7f8
movq -0x30(%rbp), %rax
cmpq 0x28(%rax), %r14
je 0xb4dc
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0xbc8b
movq %r14, %rdi
movq %r13, %rsi
callq 0x53b0
movq %r13, %rdi
callq 0x5160
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0xbc8b
movq %r14, %rdi
movq %r13, %rsi
callq 0x53b0
movq %r13, %rdi
callq 0x5160
addq $0x20, %r14
jmp 0xb47e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f2fe(%rip), %r14     # 0x2a7f0
movq %r14, %rdi
callq 0x5580
testl %eax, %eax
je 0xb44f
leaq 0x1f2c7(%rip), %rdi     # 0x2a7d0
leaq 0x10ee2(%rip), %rsi     # 0x1c3f2
pushq $0x10
popq %rdx
callq 0xbb98
leaq 0x6e3(%rip), %rdi       # 0xbc02
leaq 0x1f2aa(%rip), %rsi     # 0x2a7d0
leaq 0x1edfb(%rip), %rdx     # 0x2a328
callq 0x52b0
leaq 0x1f2b7(%rip), %rdi     # 0x2a7f0
callq 0x5210
jmp 0xb44f
leaq 0x1f2ce(%rip), %r14     # 0x2a818
movq %r14, %rdi
callq 0x5580
testl %eax, %eax
je 0xb45d
leaq 0x1f297(%rip), %rdi     # 0x2a7f8
leaq 0x10e98(%rip), %rsi     # 0x1c400
pushq $0x10
popq %rdx
callq 0xbb98
leaq 0x68b(%rip), %rdi       # 0xbc02
leaq 0x1f27a(%rip), %rsi     # 0x2a7f8
leaq 0x1eda3(%rip), %rdx     # 0x2a328
callq 0x52b0
leaq 0x1f287(%rip), %rdi     # 0x2a818
callq 0x5210
jmp 0xb45d
jmp 0xb59d
movq %rax, %rbx
movq %r14, %rdi
callq 0x5200
movq %rbx, %rdi
callq 0x5560
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, %rbx
leaq -0x1d8(%rbp), %rdi
pushq $0x18
popq %rdx
movq %rbx, %rsi
callq 0x54a0
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x20, %rbx
movq %rbx, -0x30(%rbp)
leaq -0x50(%rbp), %r15
pushq $0xa
popq %r12
leaq -0x1d8(%rbp), %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x5590
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0xb652
movq -0x50(%rbp), %r13
movq -0x48(%rbp), %r14
xorl %ebx, %ebx
cmpq %rbx, %r14
je 0xb63d
movsbl (%r13,%rbx), %edi
callq 0x5430
movb %al, (%r13,%rbx)
incq %rbx
jmp 0xb623
cmpq $0x2, -0x48(%rbp)
jb 0xb5f9
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0xc426
jmp 0xb5f9
leaq -0x50(%rbp), %rdi
callq 0x5160
leaq -0x1d8(%rbp), %rdi
callq 0x5270
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x5160
leaq -0x1d8(%rbp), %rdi
callq 0x5270
movq %rbx, %rdi
callq 0x5560
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movl %r9d, -0x2c(%rbp)
movl %r8d, %r14d
movq %rcx, %r13
movq %rdx, %r15
movq %rdi, %rbx
callq 0x5400
leaq 0x20(%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x5400
leaq 0x40(%rbx), %rdi
movq %r13, %rsi
callq 0x5400
leaq 0x70(%rbx), %rax
movq %rax, 0x60(%rbx)
andq $0x0, 0x68(%rbx)
xorl %eax, %eax
movb %al, 0x70(%rbx)
andl $0x0, 0x8c(%rbx)
movl -0x2c(%rbp), %ecx
movb %cl, 0x90(%rbx)
andw $0x0, 0x91(%rbx)
movb %al, 0x93(%rbx)
leaq 0x105c1(%rip), %rsi     # 0x1c49c
movq %rbx, %rdi
callq 0xbdb1
testb %al, %al
jne 0xbf0d
leaq 0x105b2(%rip), %rsi     # 0x1c4a0
movq %rbx, %rdi
callq 0xbdb1
testb %al, %al
jne 0xbf0d
leaq 0x105a3(%rip), %rsi     # 0x1c4a4
movq %rbx, %rdi
callq 0xbdb1
testb %al, %al
je 0xbf45
movw $0x152, 0x90(%rbx)      # imm = 0x152
movl 0x86(%rbx), %eax
andl $0x1f, %r14d
andl $-0x20, %eax
orl %r14d, %eax
movl %eax, 0x86(%rbx)
movl $0x2, 0x80(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x49, 0x90(%rbx)
jne 0xbf2c
movw %r14w, 0x88(%rbx)
jmp 0xbf2c
movq %rax, %r14
movq %r12, %rdi
callq 0x5160
jmp 0xbf68
movq %rax, %r14
movq %rbx, %rdi
callq 0x5160
movq %r14, %rdi
callq 0x5560
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1d6f
movq (%r15), %r12
movq 0x8(%r15), %rbx
xorl %r15d, %r15d
cmpq %rbx, %r12
je 0x13c1
movq (%r12), %rdi
addq %r14, %rdi
xorl %r13d, %r13d
movq %r13, %rax
incq %r13
cmpb %bpl, (%rdi,%rax)
jne 0x1398
pushq $0x1
popq %rsi
movq %r13, %rdx
movq (%rsp), %rcx
callq 0x1220
cmpq %r13, %rax
jne 0x13d3
addq %r13, %r15
addq $0x8, %r12
jmp 0x1389
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3bfe(%rip), %rax      # 0x4fd8
movq (%rax), %rcx
leaq 0x1c88(%rip), %rdi      # 0x306c
pushq $0x4c
popq %rsi
pushq $0x1
popq %rdx
callq 0x1220
pushq $0x1
popq %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O2/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
movb 0x30(%rdi), %cl
testb %cl, %cl
jne 0x1431
movq 0x20(%rbx), %rax
cmpq 0x28(%rbx), %rax
jne 0x1431
movq (%rbx), %rcx
movq 0x18(%rbx), %rdi
pushq $0x1
popq %rsi
movl $0x10000, %edx          # imm = 0x10000
callq 0x11c0
movq %rax, 0x28(%rbx)
andq $0x0, 0x20(%rbx)
testq %rax, %rax
je 0x144d
movb 0x30(%rbx), %cl
movb $-0x1, %al
testb $0x1, %cl
jne 0x144b
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%rbx)
movb (%rax,%rcx), %al
popq %rbx
retq
movb $0x1, 0x30(%rbx)
movb $-0x1, %al
jmp 0x144b
// File: /workspace/github_cpp_makefile_star2_O2/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
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rdi
subq (%rsi), %rdi
shrq $0x3, %rdi
movl %edi, 0x18(%rbx)
callq 0x1fca
callq 0x1040
callq 0x10e0
cvttsd2si %xmm0, %eax
movl %eax, 0x1c(%rbx)
addl %eax, %eax
movslq %eax, %rsi
leaq 0x10(%rsp), %rdx
andq $0x0, (%rdx)
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rcx
callq 0x1fd4
leaq 0x18(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x217c
movq %r15, %rdi
callq 0x20b4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x202a
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20b4
movq %r14, %rdi
callq 0x1200
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %rcx
movq (%rsi), %rdx
movslq 0x1c(%rdi), %rax
movq %rax, %rsi
shlq $0x3, %rsi
addq (%rdi), %rsi
xorl %r8d, %r8d
cmpq %rcx, %r8
jge 0x2054
movq (%rdx,%r8,8), %r9
movq %r9, (%rsi,%r8,8)
incq %r8
jmp 0x2042
movq (%rdi), %rcx
leal -0x1(%rax), %edx
leaq (%rcx,%rdx,8), %rdx
leal -0x1(,%rax,2), %esi
cmpl $0x1, %eax
jle 0x2086
leal -0x1(%rsi), %edi
movl %esi, %r8d
movq (%rcx,%r8,8), %r8
addq (%rcx,%rdi,8), %r8
movq %r8, (%rdx)
decl %eax
addq $-0x8, %rdx
addl $-0x2, %esi
jmp 0x2065
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Rubenmp[P]Rubik/src/defineRubik.cpp
// Function: Rubik::explainMovements(std::vector<char, std::allocator<char>>&, unsigned int&) const
void Rubik::explainMovements(vector<char>& solution, unsigned int& movement) const{
   while (movement <= (solution.size()-1)){
      cout << "- (" << movement + 1 << ") ";
      if (solution[movement] == 'F')
	      cout << "F --> Move frontal side in clockwise.\n\n";
      else if (solution[movement] == 'f')
	      cout << "f --> Move frontal side, not in clockwise.\n\n";
      else if (solution[movement] == 'W')
	      cout << "B --> Move back side left.\n\n";
      else if (solution[movement] == 'w')
	      cout << "b --> Move back side right.\n\n";
      else if (solution[movement] == 'R')
	      cout << "R --> Move right side backward.\n\n";
      else if (solution[movement] == 'r')
	      cout << "r --> Move right side to you.\n\n";
      else if (solution[movement] == 'L')
	      cout << "L --> Move left side to you.\n\n";
      else if (solution[movement] == 'l')
	      cout << "l --> Move left side backward.\n\n";
      else if (solution[movement] == 'U')
	      cout << "U --> Move top side left.\n\n";
      else if (solution[movement] == 'u')
         cout << "u --> Move top side right.\n\n";
      else if (solution[movement] == 'D')
	      cout << "D --> Move down side right.\n\n";
      else if (solution[movement] == 'd')
	      cout << "d --> Move down side left.\n\n";

	   ++movement;
   }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl (%rdx), %eax
movq 0xcf5a(%rip), %r15      # 0xffc8
leaq 0x850b(%rip), %r12      # 0xb580
leaq 0x8508(%rip), %r13      # 0xb584
leaq 0x8504(%rip), %rbp      # 0xb587
movl %eax, %eax
movq (%r14), %rcx
notq %rcx
addq 0x8(%r14), %rcx
cmpq %rax, %rcx
jb 0x317e
movq %r15, %rdi
movq %r12, %rsi
callq 0x21b0
movl (%rbx), %esi
incl %esi
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
movq %r13, %rsi
callq 0x21b0
movl (%rbx), %eax
movq (%r14), %rcx
movzbl (%rcx,%rax), %eax
cmpl $0x44, %eax
je 0x3140
movq %rbp, %rsi
cmpl $0x46, %eax
je 0x316b
cmpl $0x4c, %eax
je 0x3164
cmpl $0x52, %eax
je 0x3152
cmpl $0x55, %eax
je 0x3113
cmpl $0x57, %eax
je 0x315b
cmpl $0x64, %eax
je 0x3125
cmpl $0x77, %eax
je 0x3149
cmpl $0x6c, %eax
je 0x311c
cmpl $0x72, %eax
je 0x312e
cmpl $0x75, %eax
je 0x3137
cmpl $0x66, %eax
jne 0x3173
leaq 0x849e(%rip), %rsi      # 0xb5af
jmp 0x316b
leaq 0x857f(%rip), %rsi      # 0xb699
jmp 0x316b
leaq 0x8555(%rip), %rsi      # 0xb678
jmp 0x316b
leaq 0x85c4(%rip), %rsi      # 0xb6f0
jmp 0x316b
leaq 0x8504(%rip), %rsi      # 0xb639
jmp 0x316b
leaq 0x8577(%rip), %rsi      # 0xb6b5
jmp 0x316b
leaq 0x858b(%rip), %rsi      # 0xb6d2
jmp 0x316b
leaq 0x84a9(%rip), %rsi      # 0xb5f9
jmp 0x316b
leaq 0x84be(%rip), %rsi      # 0xb617
jmp 0x316b
leaq 0x847a(%rip), %rsi      # 0xb5dc
jmp 0x316b
leaq 0x84ee(%rip), %rsi      # 0xb659
movq %r15, %rdi
callq 0x21b0
movl (%rbx), %eax
incl %eax
movl %eax, (%rbx)
jmp 0x3083
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
movq 0xc6cd(%rip), %r12      # 0xfff0
leaq 0x7dff(%rip), %r13      # 0xb729
movl %ebp, %ebp
cmpq %rbp, 0x8(%r14)
jbe 0x3a62
movq (%r14), %rax
movzbl (%rax,%rbp), %eax
cmpl $0x42, %eax
je 0x39f8
cmpl $0x44, %eax
je 0x39c1
cmpl $0x46, %eax
je 0x3a2c
cmpl $0x4c, %eax
je 0x3a12
cmpl $0x75, %eax
je 0x39a1
cmpl $0x55, %eax
je 0x3a1f
cmpl $0x62, %eax
je 0x39d1
cmpl $0x64, %eax
je 0x3a05
cmpl $0x66, %eax
je 0x39b1
cmpl $0x6c, %eax
je 0x39de
cmpl $0x72, %eax
je 0x39eb
cmpl $0x52, %eax
jne 0x3a39
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3a72
jmp 0x3a5b
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3dfe
jmp 0x3a5b
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3f0a
jmp 0x3a5b
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3cae
jmp 0x3a5b
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4054
jmp 0x3a5b
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3c1c
jmp 0x3a5b
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3b04
jmp 0x3a5b
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3fae
jmp 0x3a5b
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3d1e
jmp 0x3a5b
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3b90
jmp 0x3a5b
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3d8e
jmp 0x3a5b
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3e6e
jmp 0x3a5b
movq %r12, %rdi
movq %r13, %rsi
callq 0x21b0
movq (%r14), %rcx
movsbl (%rcx,%rbp), %esi
movq %rax, %rdi
callq 0x2200
movq %rax, %rdi
callq 0x20f0
incl %ebp
jmp 0x392a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0xe(%rdi), %xmm0
pshuflw $0x93, %xmm0, %xmm0     # xmm0 = xmm0[3,0,1,2,4,5,6,7]
movq %xmm0, 0xe(%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)
movzwl 0x30(%rdi), %ecx
movw %cx, 0x33(%rdi)
movb 0x32(%rdi), %cl
movb %cl, 0x35(%rdi)
movzwl 0x4(%rsp), %ecx
movw %cx, 0x30(%rdi)
movb 0x6(%rsp), %cl
movb %cl, 0x32(%rdi)
leaq 0x7(%rsp), %rsi
movb $0x44, (%rsi)
movq %rax, %rdi
callq 0xacfa
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0xe(%rdi), %xmm0
pshuflw $0x39, %xmm0, %xmm0     # xmm0 = xmm0[1,2,3,0,4,5,6,7]
movq %xmm0, 0xe(%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)
movzwl 0x2a(%rdi), %ecx
movw %cx, 0x33(%rdi)
movb 0x2c(%rdi), %cl
movb %cl, 0x35(%rdi)
movzwl 0x4(%rsp), %ecx
movw %cx, 0x2a(%rdi)
movb 0x6(%rsp), %cl
movb %cl, 0x2c(%rdi)
leaq 0x7(%rsp), %rsi
movb $0x64, (%rsi)
movq %rax, %rdi
callq 0xacfa
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x6(%rdi), %xmm0
pshuflw $0x39, %xmm0, %xmm0     # xmm0 = xmm0[1,2,3,0,4,5,6,7]
movq %xmm0, 0x6(%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)
movzwl 0x27(%rdi), %ecx
movw %cx, 0x24(%rdi)
movb 0x29(%rdi), %cl
movb %cl, 0x26(%rdi)
movzwl 0x4(%rsp), %ecx
movw %cx, 0x27(%rdi)
movb 0x6(%rsp), %cl
movb %cl, 0x29(%rdi)
leaq 0x7(%rsp), %rsi
movb $0x55, (%rsi)
movq %rax, %rdi
callq 0xacfa
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x6(%rdi), %xmm0
pshuflw $0x93, %xmm0, %xmm0     # xmm0 = xmm0[3,0,1,2,4,5,6,7]
movq %xmm0, 0x6(%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)
movzwl 0x24(%rdi), %ecx
movw %cx, 0x27(%rdi)
movb 0x26(%rdi), %cl
movb %cl, 0x29(%rdi)
movzwl 0x4(%rsp), %ecx
movw %cx, 0x24(%rdi)
movb 0x6(%rsp), %cl
movb %cl, 0x26(%rdi)
leaq 0x7(%rsp), %rsi
movb $0x75, (%rsi)
movq %rax, %rdi
callq 0xacfa
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x8578
movq %rsi, %r14
xorl %eax, %eax
cmpq $0x6, %rax
je 0x850d
movb (%r14,%rax), %cl
movb %cl, (%rbx,%rax)
incq %rax
jmp 0x84fb
pushq $0x3
popq %rax
cmpq $0xf, %rax
je 0x852b
movb (%r14,%rax,2), %cl
movb %cl, (%rbx,%rax,2)
movb 0x1(%r14,%rax,2), %cl
movb %cl, 0x1(%rbx,%rax,2)
incq %rax
jmp 0x8510
leaq 0x20(%rbx), %rbp
xorl %r12d, %r12d
leaq 0xc(%rsp), %r15
movl %r12d, 0xc(%rsp)
cmpq $0x8, %r12
je 0x8578
movq %r14, %rdi
movq %r15, %rsi
callq 0xa906
movb %al, -0x2(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xa906
movb %ah, -0x1(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xa906
shrl $0x10, %eax
movb %al, (%rbp)
incq %r12
addq $0x3, %rbp
jmp 0x8537
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x2190
movl %eax, %edi
callq 0x21a0
xorps %xmm0, %xmm0
movq %rsp, %r14
andq $0x0, 0x10(%r14)
movaps %xmm0, (%r14)
movl $0x12c, %ebp            # imm = 0x12C
pushq $0xc
popq %r15
leaq 0x2e78(%rip), %r12      # 0xb43c
subl $0x1, %ebp
jb 0x868f
callq 0x2080
cltd
idivl %r15d
cmpl $0xb, %edx
ja 0x85c4
movslq (%r12,%rdx,4), %rax
addq %r12, %rax
jmpq *%rax
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3a72
jmp 0x85c4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3d1e
jmp 0x85c4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3e6e
jmp 0x85c4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3dfe
jmp 0x85c4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3b90
jmp 0x85c4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3c1c
jmp 0x85c4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4054
jmp 0x85c4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3b04
jmp 0x85c4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3f0a
jmp 0x85c4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3fae
jmp 0x85c4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3cae
jmp 0x85c4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3d8e
jmp 0x85c4
movq %rsp, %rdi
callq 0x2f90
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2f90
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x32f3(%rip), %r14      # 0xc49e
movq %r14, %rsi
callq 0x21b0
leaq 0x330b(%rip), %rsi      # 0xc4c5
movq %rbx, %rdi
callq 0x21b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21b0
leaq 0x3318(%rip), %rsi      # 0xc4ec
movq %rbx, %rdi
callq 0x21b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21b0
leaq 0x3325(%rip), %rsi      # 0xc513
movq %rbx, %rdi
callq 0x21b0
leaq 0x333d(%rip), %r15      # 0xc53a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21b0
leaq 0x3373(%rip), %rsi      # 0xc582
movq %rbx, %rdi
callq 0x21b0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21b0
leaq 0x33a1(%rip), %rsi      # 0xc5ca
movq %rbx, %rdi
callq 0x21b0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21b0
leaq 0x33cf(%rip), %rsi      # 0xc612
movq %rbx, %rdi
callq 0x21b0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21b0
leaq 0x33fd(%rip), %rsi      # 0xc65a
movq %rbx, %rdi
callq 0x21b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21b0
leaq 0x340a(%rip), %rsi      # 0xc681
movq %rbx, %rdi
callq 0x21b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21b0
leaq 0x3417(%rip), %rsi      # 0xc6a8
movq %rbx, %rdi
callq 0x21b0
leaq 0x342f(%rip), %rsi      # 0xc6cf
movq %rbx, %rdi
callq 0x21b0
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x20f0
nop