LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/qhan1028[P]JPEG-Decoder/jpeg-decoder.cpp
// Function: process_other(std::basic_ifstream<char, std::char_traits<char>>&, unsigned int)
void process_other(ifstream& jpegfile, unsigned int opt) {
    switch (opt) {
        case 0xE0: case 0xE1: case 0xE2: case 0xE3:
        case 0xE4: case 0xE5: case 0xE6: case 0xE7:
        case 0xE8: case 0xE9: case 0xEA: case 0xEB:
        case 0xEC: case 0xED: case 0xEE: case 0xEF:
            if (debug)
                cout << "[APP" << to_uint(opt) % 16 << "] len = ";
            skip(jpegfile);
            break;
        
        case COM:
            if (debug)
                cout << "[COM] len = ";
            skip(jpegfile);
            break;
        
        case DRI:
            if (debug)
                cout << "[DRI] len = ";
            skip(jpegfile);
            USE_RST = true;
            break;

        default:
            printf("[Error] unknown tag: %04X\n", opt);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
leal -0xe0(%r14), %eax
cmpl $0x10, %eax
jae 0x4ada
cmpb $0x1, 0x4772(%rip)      # 0x91fa
jne 0x4ac8
movq 0x453f(%rip), %r15      # 0x8fd0
leaq 0x1844(%rip), %rsi      # 0x62dc
movl $0x4, %edx
movq %r15, %rdi
callq 0x2210
andl $0xf, %r14d
movq %r15, %rdi
movq %r14, %rsi
callq 0x2110
leaq 0x16cf(%rip), %rsi      # 0x618a
movl $0x8, %edx
movq %rax, %rdi
callq 0x2210
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x249c
cmpl $0xdd, %r14d
je 0x4b0a
cmpl $0xfe, %r14d
jne 0x4b45
cmpb $0x1, 0x4707(%rip)      # 0x91fa
jne 0x4ac8
movq 0x44d4(%rip), %rdi      # 0x8fd0
leaq 0x17de(%rip), %rsi      # 0x62e1
movl $0xc, %edx
jmp 0x4ac3
cmpb $0x1, 0x46e9(%rip)      # 0x91fa
jne 0x4b2b
movq 0x44b6(%rip), %rdi      # 0x8fd0
leaq 0x17cd(%rip), %rsi      # 0x62ee
movl $0xc, %edx
callq 0x2210
movq %rbx, %rdi
callq 0x249c
movb $0x1, 0x46c1(%rip)      # 0x91fb
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x17af(%rip), %rdi      # 0x62fb
movl %r14d, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2050
// File: /workspace/github_cpp_makefile_star2_O1/ef-gy[P]libefgy/src/test-case/trigonometric.cpp
// Function: testSine(std::ostream&)
bool testSine(std::ostream &log) {
  double s, c;

  for (double x : range<double>(0, 3.14, 30, true)) {
    s = sines(x, c);

    log << "sine(" << x << ") = " << s << ":" << c << "\n";
  }

  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %r14
xorl %r12d, %r12d
leaq 0xf687(%rip), %r13      # 0x14145
leaq 0xf6f1(%rip), %rbp      # 0x141b6
xorps %xmm1, %xmm1
cvtsi2sd %r12, %xmm1
mulsd 0xf533(%rip), %xmm1     # 0x14008
addsd 0xf533(%rip), %xmm1     # 0x14010
movsd %xmm1, 0x8(%rsp)
movq $0xa, 0x30(%rsp)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x38(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movups %xmm0, 0x8(%r14)
movsd %xmm1, 0x60(%rsp)
movaps %xmm0, 0x20(%rsp)
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
leaq 0x58(%rsp), %rdx
leaq 0x48(%rsp), %rcx
leaq 0x20(%rsp), %r8
callq 0x13270
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movl $0x5, %edx
movq %rbx, %rdi
leaq 0xf5f0(%rip), %rsi      # 0x1413a
callq 0x42a0
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x4360
movq %rax, %r15
movl $0x4, %edx
movq %rax, %rdi
leaq 0xf5d1(%rip), %rsi      # 0x14140
callq 0x42a0
movq %r15, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x4360
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x42a0
movq %r15, %rdi
movsd 0x18(%rsp), %xmm0
callq 0x4360
movl $0x1, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x42a0
incq %r12
cmpq $0x1e, %r12
jne 0x4ac5
movb $0x1, %al
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jenniferdr[P]proyectoIAI/a_estrella.cc
// Function: compactar_full(char*)
long long int compactar_full(int8 estado[16]) {
  long long int res = 0;
  for (int i = 0; i < 16; i++) {
    res = (estado[i] | res) << 4;
  }
  res = res >> 4;
  return res;
}

// Assembly:
xorl %ecx, %ecx
xorl %eax, %eax
movsbq (%rdi,%rcx), %rdx
orq %rdx, %rax
shlq $0x4, %rax
incq %rcx
cmpq $0x10, %rcx
jne 0x2510
sarq $0x4, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/jenniferdr[P]proyectoIAI/algoritmos.cc
// Function: make_root(char*)
Nodo* make_root(int8 estado[16]){
  Nodo* n= new Nodo();

  for(int i=0; i<16;i++){
    n->estado[i]= estado[i];
  }
  n->distancia= 0;
  n->predecesor= NULL;

  return n;  
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x28, %edi
callq 0x2180
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
movups (%rbx), %xmm0
movups %xmm0, (%rax)
movb $0x0, 0x10(%rax)
movq %rcx, 0x18(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/jenniferdr[P]proyectoIAI/algoritmos.cc
// Function: make_node(Nodo*, char*)
Nodo* make_node(Nodo* padre,int8 estado[16]){
  Nodo* n= new Nodo();
  
  for(int i=0; i<16;i++){
    n->estado[i]= estado[i];
  }
  n->distancia= padre->distancia +1;
  n->predecesor= padre;

  return n;  
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x28, %edi
callq 0x2180
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movups (%rbx), %xmm0
movups %xmm0, (%rax)
movb 0x10(%r14), %cl
incb %cl
movb %cl, 0x10(%rax)
movq %r14, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/jenniferdr[P]proyectoIAI/algoritmos.cc
// Function: extract_solution[abi:cxx11](Nodo*)
std::list<Nodo*> extract_solution(Nodo* n){
  std::list<Nodo*> camino;
  while(n!= NULL){
    camino.push_front(n);
    n= n->predecesor;
  }
  return camino;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
movq $0x0, 0x10(%rdi)
testq %rsi, %rsi
je 0x3691
movq %rsi, %r14
movq (%rbx), %r15
movl $0x18, %edi
callq 0x2180
movq %r14, 0x10(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x2050
incq 0x10(%rbx)
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x3668
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x36ba
movq (%rdi), %r15
movl $0x18, %esi
callq 0x2190
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x36a5
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/jenniferdr[P]proyectoIAI/algoritmos.cc
// Function: heuristicaManhattan(char*)
int heuristicaManhattan(int8 estado[16]){
  return matrizH[estado[0]][0] + matrizH[estado[1]][1]
    + matrizH[estado[2]][2] + matrizH[estado[3]][3]
    + matrizH[estado[4]][4] + matrizH[estado[5]][5]
    + matrizH[estado[6]][6] + matrizH[estado[7]][7]
    + matrizH[estado[8]][8] + matrizH[estado[9]][9]
    + matrizH[estado[10]][10] + matrizH[estado[11]][11]
    + matrizH[estado[12]][12] + matrizH[estado[13]][13]
    + matrizH[estado[14]][14] + matrizH[estado[15]][15];
}

// Assembly:
movsbq (%rdi), %rcx
shlq $0x4, %rcx
leaq 0x5ac7(%rip), %rax      # 0x91a0
movsbl (%rcx,%rax), %ecx
movsbq 0x1(%rdi), %rdx
shlq $0x4, %rdx
movsbl 0x1(%rdx,%rax), %edx
addl %ecx, %edx
movsbq 0x2(%rdi), %rcx
shlq $0x4, %rcx
movsbl 0x2(%rcx,%rax), %ecx
movsbq 0x3(%rdi), %rsi
shlq $0x4, %rsi
movsbl 0x3(%rsi,%rax), %esi
addl %ecx, %esi
addl %edx, %esi
movsbq 0x4(%rdi), %rcx
shlq $0x4, %rcx
movsbl 0x4(%rcx,%rax), %ecx
movsbq 0x5(%rdi), %rdx
shlq $0x4, %rdx
movsbl 0x5(%rdx,%rax), %edx
addl %ecx, %edx
movsbq 0x6(%rdi), %rcx
shlq $0x4, %rcx
movsbl 0x6(%rcx,%rax), %r8d
addl %edx, %r8d
addl %esi, %r8d
movsbq 0x7(%rdi), %rcx
shlq $0x4, %rcx
movsbl 0x7(%rcx,%rax), %ecx
movsbq 0x8(%rdi), %rdx
shlq $0x4, %rdx
movsbl 0x8(%rdx,%rax), %edx
addl %ecx, %edx
movsbq 0x9(%rdi), %rcx
shlq $0x4, %rcx
movsbl 0x9(%rcx,%rax), %esi
addl %edx, %esi
movsbq 0xa(%rdi), %rcx
shlq $0x4, %rcx
movsbl 0xa(%rcx,%rax), %ecx
addl %esi, %ecx
addl %r8d, %ecx
movsbq 0xb(%rdi), %rdx
shlq $0x4, %rdx
movsbl 0xb(%rdx,%rax), %edx
movsbq 0xc(%rdi), %rsi
shlq $0x4, %rsi
movsbl 0xc(%rsi,%rax), %esi
addl %edx, %esi
movsbq 0xd(%rdi), %rdx
shlq $0x4, %rdx
movsbl 0xd(%rdx,%rax), %edx
addl %esi, %edx
movsbq 0xe(%rdi), %rsi
shlq $0x4, %rsi
movsbl 0xe(%rsi,%rax), %esi
addl %edx, %esi
movsbq 0xf(%rdi), %rdx
shlq $0x4, %rdx
movsbl 0xf(%rdx,%rax), %eax
addl %esi, %eax
addl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/jenniferdr[P]proyectoIAI/algoritmos.cc
// Function: is_goal(Nodo*)
bool is_goal(Nodo* n){
  bool r = true;
  for (int i = 0; i<16 && r; i++) {
    r = r && matrizR[i]==n->estado[i];
  }
  return r;
}

// Assembly:
xorl %eax, %eax
leaq 0x5ac5(%rip), %rcx      # 0x92a0
movb (%rdi,%rax), %dl
movb (%rax,%rcx), %sil
cmpq $0xe, %rax
ja 0x37f0
incq %rax
cmpb %dl, %sil
je 0x37db
cmpb %dl, %sil
sete %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jenniferdr[P]proyectoIAI/basepatrones.cc
// Function: compactar(char*, bool*)
int compactar(char estado[16], bool set[16]) {

  int res = 0;
  int p[6];
  int indice = 0;

  for (int i = 0; i < 16; i++) {
    if (i != 0 and !set[i]) continue;

    for (int j = 0; j <16; j++) {
      if (estado[j] == i) {
	p[indice] = j;
	indice++;
      }
    }
  }

  for (int i = 0; i< 6; i++) {
    res = (p[i] | res) << 4;
  }
  res = res >> 4;

  return res;
}

// Assembly:
xorl %eax, %eax
xorl %ecx, %ecx
testq %rax, %rax
je 0x3807
cmpb $0x1, (%rsi,%rax)
jne 0x3828
xorl %edx, %edx
movsbq (%rdi,%rdx), %r8
movl %r8d, %r8d
cmpq %r8, %rax
jne 0x381f
movslq %ecx, %rcx
movl %edx, -0x18(%rsp,%rcx,4)
incl %ecx
incq %rdx
cmpq $0x10, %rdx
jne 0x3809
incq %rax
cmpq $0x10, %rax
jne 0x37fc
xorl %ecx, %ecx
xorl %eax, %eax
orl -0x18(%rsp,%rcx,4), %eax
shll $0x4, %eax
incq %rcx
cmpq $0x6, %rcx
jne 0x3835
sarl $0x4, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/jenniferdr[P]proyectoIAI/basepatrones.cc
// Function: puedeMoverse(int, int)
bool puedeMoverse(int dist, int posicion_cero) {
  if (posicion_cero + dist > 15 or posicion_cero + dist < 0) return false;

  switch (posicion_cero) {
  case 4:
  case 8:
  case 12:
    return dist != -1;
    break;
  case 3:
  case 7:
  case 11:
    return dist != 1;
  }

  return true;
}

// Assembly:
leal (%rsi,%rdi), %eax
cmpl $0xf, %eax
jbe 0x3854
xorl %eax, %eax
retq
movb $0x1, %al
cmpl $0xc, %esi
ja 0x3853
movl $0x888, %ecx            # imm = 0x888
btl %esi, %ecx
jb 0x3874
movl $0x1110, %ecx           # imm = 0x1110
btl %esi, %ecx
jae 0x3853
cmpl $-0x1, %edi
jmp 0x3877
cmpl $0x1, %edi
setne %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/jenniferdr[P]proyectoIAI/basepatrones.cc
// Function: h_static55_M(char*)
int h_static55_M(int8 estado[16]) {
  // Busca el estado actual en dos bases de datos
  int res = bd1[compactar(estado, set1)] + bd2[compactar(estado, set2)];
  // A eso le suma la distancia manhattan del resto de las fichas
  for (int i = 0; i < 16; i++) {
    if (!set3[i]) continue;
    for (int j = 0; j < 16; j++) {
      if (estado[j] == i) {
	res += matrizH[i][j];
      }
    }
  }
  return res;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5516(%rip), %rsi      # 0x92b0
callq 0x37f8
cltq
leaq 0x5588(%rip), %rcx      # 0x9330
movzbl (%rax,%rcx), %ebp
leaq 0x550d(%rip), %rsi      # 0x92c0
movq %rbx, %rdi
callq 0x37f8
cltq
leaq 0x100556c(%rip), %rcx   # 0x1009330
movzbl (%rax,%rcx), %eax
addl %ebp, %eax
leaq 0x53cf(%rip), %rcx      # 0x91a0
xorl %edx, %edx
leaq 0x54f6(%rip), %rsi      # 0x92d0
cmpb $0x1, (%rdx,%rsi)
jne 0x3dfb
xorl %edi, %edi
movsbq (%rbx,%rdi), %r8
movl %r8d, %r8d
cmpq %r8, %rdx
jne 0x3df2
addl (%rcx,%rdi,4), %eax
incq %rdi
cmpq $0x10, %rdi
jne 0x3de2
incq %rdx
addq $0x40, %rcx
cmpq $0x10, %rdx
jne 0x3dda
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jenniferdr[P]proyectoIAI/basepatrones.cc
// Function: h_static5_M(char*)
int h_static5_M(int8 estado[16]) {
  // Busca el estado actual en la primera base de datos y suma la distancia
  // manhattan del resto de las fichas.
  int res = bd1[compactar(estado, set1)];
  for (int i = 0; i < 16; i++) {
    if (set1[i]) continue;
    for (int j = 0; j < 16; j++) {
      if (estado[j] == i) {
	res += matrizH[i][j];
      }
    }
  }
  return res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5493(%rip), %r14      # 0x92b0
movq %r14, %rsi
callq 0x37f8
cltq
leaq 0x5502(%rip), %rcx      # 0x9330
movzbl (%rax,%rcx), %eax
leaq 0x5367(%rip), %rcx      # 0x91a0
xorl %edx, %edx
cmpb $0x0, (%rdx,%r14)
jne 0x3e5c
xorl %esi, %esi
movsbq (%rbx,%rsi), %rdi
movl %edi, %edi
cmpq %rdi, %rdx
jne 0x3e53
addl (%rcx,%rsi,4), %eax
incq %rsi
cmpq $0x10, %rsi
jne 0x3e44
incq %rdx
addq $0x40, %rcx
cmpq $0x10, %rdx
jne 0x3e3b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jenniferdr[P]proyectoIAI/conflictos.cc
// Function: h_conflictos(char*)
int h_conflictos(int8 estado[16]) {
  int res = heuristicaManhattan(estado);
  for (int i = 0; i < 4; i++) {
    for (int j = i; j < 4; j++) {
      res += conflictos[estado[i]][estado[j]][i][j];
    }
  }
  for (int i = 4; i < 8; i++) {
    for (int j = i; j < 8; j++) {
      res += conflictos[estado[i]][estado[j]][i][j];
    }
  }
  for (int i = 8; i < 12; i++) {
    for (int j = i; j < 12; j++) {
      res += conflictos[estado[i]][estado[j]][i][j];
    }
  }
  for (int i = 8; i < 16; i++) {
    for (int j = i; j < 16; j++) {
      res += conflictos[estado[i]][estado[j]][i][j];
    }
  }

  return res;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x36ca
leaq 0x3004e51(%rip), %rcx   # 0x3009340
xorl %edx, %edx
movq %rbx, %rsi
movsbq (%rbx,%rdx), %rdi
shlq $0xe, %rdi
addq %rcx, %rdi
xorl %r8d, %r8d
movsbq (%rsi,%r8), %r9
shlq $0xa, %r9
addq %rdi, %r9
addl (%r9,%r8,4), %eax
leaq (%rdx,%r8), %r9
incq %r9
incq %r8
cmpq $0x4, %r9
jne 0x4503
incq %rdx
incq %rsi
addq $0x44, %rcx
cmpq $0x4, %rdx
jne 0x44f4
movl $0x4, %ecx
leaq 0x3004f11(%rip), %rdx   # 0x3009450
xorl %esi, %esi
movsbq (%rbx,%rcx), %rdi
shlq $0xe, %rdi
addq %rdx, %rdi
movq %rsi, %r8
movsbq 0x4(%rbx,%r8), %r9
shlq $0xa, %r9
addl (%rdi,%r9), %eax
incq %r8
addq $0x4, %rdi
cmpq $0x4, %r8
jne 0x4550
incq %rcx
incq %rsi
addq $0x44, %rdx
cmpq $0x8, %rcx
jne 0x4541
movl $0x8, %ecx
leaq 0x3004fd9(%rip), %rdx   # 0x3009560
xorl %esi, %esi
movsbq (%rbx,%rcx), %rdi
shlq $0xe, %rdi
addq %rdx, %rdi
movq %rsi, %r8
movsbq 0x8(%rbx,%r8), %r9
shlq $0xa, %r9
addl (%rdi,%r9), %eax
incq %r8
addq $0x4, %rdi
cmpq $0x4, %r8
jne 0x4598
incq %rcx
incq %rsi
addq $0x44, %rdx
cmpq $0xc, %rcx
jne 0x4589
movl $0x8, %ecx
leaq 0x3004f91(%rip), %rdx   # 0x3009560
xorl %esi, %esi
movsbq (%rbx,%rcx), %rdi
shlq $0xe, %rdi
addq %rdx, %rdi
movq %rsi, %r8
movsbq 0x8(%rbx,%r8), %r9
shlq $0xa, %r9
addl (%rdi,%r9), %eax
incq %r8
addq $0x4, %rdi
cmpq $0x8, %r8
jne 0x45e0
incq %rcx
incq %rsi
addq $0x44, %rdx
cmpq $0x10, %rcx
jne 0x45d1
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/jenniferdr[P]proyectoIAI/ida_estrella.cc
// Function: DFS_acotado(int, int, int (*)(char*))
std::pair<Nodo*,int> DFS_acotado(int nodo,int t,int (*h)(int8 estado[16])){
  //std::cout << (int) n->distancia << std::endl;
  Nodo* n = &nodos[nodo];

  int c = n->distancia + peso*(*h)(n->estado);
  if ( c > t ){
    return std::pair<Nodo*,int>(NULL,c);
  }

  if (is_goal(n)) {
    return std::pair<Nodo*,int>(n,n->distancia);
  }

  int nueva_t = 1000;

  int posCero;
  //buscar posicion del cero
  for(int i = 0; i < 16; i++){
    if(n->estado[i]==0){
      posCero=i;
      break;
    }
  }
  
  for(int i=0; i<4 ;i++){

    if(!puedeMoverse(movimientos[i],posCero)) continue;

    int8* nuevoEstado = nodos[nodo+1].estado;
 
    // Generar el nuevo estado
    memcpy(nuevoEstado,n->estado,sizeof(int8)*16);
    nuevoEstado[posCero]= nuevoEstado[posCero+movimientos[i]];
    nuevoEstado[posCero+movimientos[i]]=0;

    num_nodos++;
   
    //	  if (num_nodos == 500000000) { std::exit(0); }
    //std::cout << num_nodos << "\n";

    nodos[nodo+1].distancia = nodos[nodo].distancia + 1;
    nodos[nodo+1].predecesor = n;

    std::pair<Nodo*,int> par= DFS_acotado(nodo+1, t,h);
    if (par.first!=NULL) return par;
    nueva_t= std::min(nueva_t,par.second);
  }
  return std::pair<Nodo*,int>(NULL,nueva_t);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r13d
movl %edi, %r14d
movslq %edi, %rax
leaq (%rax,%rax,4), %rax
leaq 0x3044d1e(%rip), %rcx   # 0x3049350
leaq (%rcx,%rax,8), %rbx
movsbl 0x10(%rbx), %ebp
movl 0x3044d03(%rip), %r15d  # 0x3049344
movq %rbx, %rdi
movq %rdx, 0x10(%rsp)
callq *%rdx
movl %eax, %r12d
imull %r15d, %r12d
addl %ebp, %r12d
movl %r13d, 0xc(%rsp)
cmpl %r13d, %r12d
jg 0x4725
movq %rbx, %rdi
callq 0x37d2
testb %al, %al
je 0x4679
movsbl 0x10(%rbx), %r12d
jmp 0x4727
xorl %eax, %eax
cmpb $0x0, (%rbx,%rax)
je 0x468f
incq %rax
cmpq $0x10, %rax
jne 0x467b
movl $0x10, %eax
incl %r14d
movl %r14d, 0x8(%rsp)
movslq %r14d, %rcx
leaq (%rcx,%rcx,4), %rcx
leaq 0x3044cab(%rip), %rdx   # 0x3049350
leaq (%rdx,%rcx,8), %rbp
movl %eax, %r13d
movl $0x3e8, %r12d           # imm = 0x3E8
xorl %r15d, %r15d
leaq 0x1a84(%rip), %rax      # 0x6140
movl (%r15,%rax), %r14d
movl %r14d, %edi
movl %r13d, %esi
callq 0x3849
testb %al, %al
je 0x471b
movups (%rbx), %xmm0
movups %xmm0, (%rbp)
addl %r13d, %r14d
movslq %r14d, %rax
movb (%rbp,%rax), %cl
movb %cl, (%rbp,%r13)
movb $0x0, (%rbp,%rax)
incq 0x3044c57(%rip)         # 0x3049348
movb 0x10(%rbx), %al
incb %al
movb %al, 0x10(%rbp)
movq %rbx, 0x18(%rbp)
movl 0x8(%rsp), %edi
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rdx
callq 0x4610
testq %rax, %rax
jne 0x473c
cmpl %r12d, %edx
cmovll %edx, %r12d
addq $0x4, %r15
cmpq $0x10, %r15
jne 0x46b5
xorl %ebx, %ebx
movq %rbx, %rax
movl %r12d, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl %edx, %r12d
jmp 0x4727
// File: /workspace/github_cpp_makefile_star2_O1/jenniferdr[P]proyectoIAI/ida_estrella.cc
// Function: ida_estrella[abi:cxx11](char*, int (*)(char*))
std::list<Nodo*> ida_estrella(int8 estado[16], int (*h)(int8 inicial[16])){
  // Por eficiencia todos los nodos estaran en nodos[]
  
  // Atributos del nodo raiz
  for (int i = 0; i < 16; i++) {
    nodos[0].estado[i] = estado[i];
  }
  nodos[0].distancia = 0;
  nodos[0].predecesor = NULL;

  // (*h) es la funcion heuristica
  int t = (*h)((&nodos[0])->estado)*peso;
  Nodo* solucion;
  std::pair<Nodo*,int> par;

  while (solucion==NULL and t<1000){
    num_nodos=0;
    par = DFS_acotado(0,t,h);
    solucion= par.first;
    t= par.second;
    std::cout << " " << t;
  }
  std::cout <<" "<< num_nodos;
  return extract_solution(solucion);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x3044bfc(%rip), %rcx   # 0x3049350
movb (%rsi,%rax), %dil
movb %dil, (%rax,%rcx)
incq %rax
cmpq $0x10, %rax
jne 0x4754
movb $0x0, 0x3044bf4(%rip)   # 0x3049360
leaq 0x3044bdd(%rip), %rdi   # 0x3049350
movq $0x0, 0x3044bea(%rip) # 0x3049368
callq *%rdx
movq 0x4851(%rip), %r14      # 0x8fd8
leaq 0x1a37(%rip), %rsi      # 0x61c5
movl $0x1, %edx
movq %r14, %rdi
callq 0x21a0
movq 0x3044ba6(%rip), %rsi   # 0x3049348
movq %r14, %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x3649
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/ef-gy[P]libefgy/include/ef.gy/big-integers.h
// Function: efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u>::bigIntegers(long long)
bigIntegers(Ts pInteger) : negative(pInteger < Ts(0)), cell(0) {
    if (pInteger == Ts(0)) {
      negative = false;
    } else {
      cellType v[cellsPerLong];
      Tu q = ((pInteger < Ts(0)) ? -pInteger : pInteger);
      cellType s = 0;

      for (cellType i = 0; (q != 0) && (i < cellsPerLong); i++) {
        v[i] = cellType(q & lowMask);
        q >>= cellBitCount;
        if (v[i] != 0) {
          s = i + 1;
        }
      }

      cell.resize(s);

      for (cellType i = 0; i < s; i++) {
        cell[i] = v[i];
      }
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rax
shrq $0x3f, %rax
movb %al, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
testq %rsi, %rsi
je 0x9c66
leaq 0x8(%rbx), %r14
movq %rsi, %rax
negq %rax
cmovsq %rsi, %rax
xorl %ecx, %ecx
xorl %ebp, %ebp
movl %ebp, %esi
movl %eax, %edi
movl %eax, (%rsp,%rcx,4)
shrq $0x20, %rax
leaq 0x1(%rcx), %rdx
testl %edi, %edi
movl %edx, %ebp
cmovel %esi, %ebp
testq %rax, %rax
je 0x9c40
testq %rcx, %rcx
movq %rdx, %rcx
je 0x9c1d
movl %ebp, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x182f2
testl %ebp, %ebp
je 0x9c69
movq (%r14), %rdi
shlq $0x2, %r15
movq %rsp, %rsi
movq %r15, %rdx
callq 0x4200
jmp 0x9c69
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x9c8b
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x4260
movq %r15, %rdi
callq 0x43f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/ef-gy[P]libefgy/include/ef.gy/big-integers.h
// Function: efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u>::operator<<=(unsigned int const&)
bigIntegers &operator<<=(const cellType &b) {
    if (*this == zero()) {
      return *this;
    }

    if (b == zero()) {
      return *this;
    }

    if ((cell.size() * cellBitCount + b) <= longBitCount) {
      *this = bigIntegers((*this).toInteger() << b, false);
      return *this;
    }

    if (b < cellBitCount) {
      const cellType &q = b;
      const cellType negQ = (cellBitCount - q);
      const cellType mask = ((1 << q) - 1) << negQ;

      if ((cell[(cell.size() - 1)] & mask) == 0) {
        /* no additional cells needed */
        cellType overflow = 0;

        for (cellType i = 0; i < cell.size(); i++) {
          cellType newContent = (cell[i] << q) | overflow;
          overflow = (cell[i] & mask) >> negQ;
          cell[i] = newContent;
        }

        return *this;
      }
    }

    return (*this = (*this << b));
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq 0x10(%rbx), %r9
subq %rdi, %r9
je 0x9dd0
movq %rsi, %rdx
movl (%rsi), %eax
testq %rax, %rax
je 0x9dd0
leaq 0x8(%rbx), %r14
movq 0x10(%rbx), %rsi
movq %rsi, %r8
subq %rdi, %r8
leaq (%rax,%r8,8), %rcx
cmpq $0x40, %rcx
ja 0x9d2e
sarq $0x2, %r9
xorl %ecx, %ecx
xorl %edx, %edx
xorl %esi, %esi
movl (%rdi,%rdx,4), %r8d
shlq %cl, %r8
orq %r8, %rsi
incq %rdx
movl %edx, %r8d
addl $0x20, %ecx
cmpq %r8, %r9
ja 0x9ce2
movl %eax, %ecx
shlq %cl, %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
xorl %edx, %edx
callq 0x18694
cmpq %rbx, %r15
je 0x9db9
leaq 0x10(%rsp), %rsi
movb -0x8(%rsi), %al
movb %al, (%rbx)
movq %r14, %rdi
callq 0x18980
jmp 0x9db9
cmpl $0x1f, %eax
ja 0x9d92
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
movl %eax, %ecx
shll %cl, %r9d
notl %r9d
movl %eax, %ecx
negl %ecx
shll %cl, %r9d
movl -0x4(%rdi,%r8), %r10d
testl %r9d, %r10d
jne 0x9d92
cmpq %rdi, %rsi
je 0x9d8d
sarq $0x2, %r8
movl $0x20, %esi
subl %eax, %esi
xorl %eax, %eax
xorl %r11d, %r11d
movl (%rdi,%rax,4), %ebp
movb (%rdx), %cl
movl %ebp, %r15d
shll %cl, %r15d
orl %r11d, %r15d
andl %r9d, %ebp
movl %esi, %ecx
shrl %cl, %ebp
movl %r15d, (%rdi,%rax,4)
incq %rax
movl %eax, %ecx
movl %ebp, %r11d
cmpq %rcx, %r8
ja 0x9d67
testl %r9d, %r10d
je 0x9dd0
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1873a
cmpq %rbx, %r15
je 0x9db9
leaq 0x10(%rsp), %rsi
movb -0x8(%rsi), %al
movb %al, (%rbx)
movq %r14, %rdi
callq 0x18980
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x9dd0
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9de0
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x9dfa
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq %rbx, %rdi
callq 0x43f0
// File: /workspace/github_cpp_makefile_star2_O1/ef-gy[P]libefgy/include/ef.gy/big-integers.h
// Function: efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u>::bigIntegers(unsigned long long, bool)
bigIntegers(Tu pInteger, bool pNegative)
      : cell(0), negative((pInteger == 0) ? false : pNegative) {
    if (pInteger == Tu(0)) {
      negative = false;
    } else {
      cellType v[cellsPerLong];
      Tu q = pInteger;

      cellType s = 0;

      for (cellType i = 0; (q != 0) && (i < cellsPerLong); i++) {
        v[i] = cellType(q & lowMask);
        q >>= cellBitCount;
        if (v[i] != 0) {
          s = i + 1;
        }
      }

      cell.resize(s);

      for (cellType i = 0; i < s; i++) {
        cell[i] = v[i];
      }
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
setne %al
andb %dl, %al
movb %al, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
testq %rsi, %rsi
je 0x1870d
leaq 0x8(%rbx), %r14
xorl %eax, %eax
xorl %ebp, %ebp
movl %ebp, %edx
movl %esi, %edi
movl %esi, (%rsp,%rax,4)
shrq $0x20, %rsi
leaq 0x1(%rax), %rcx
testl %edi, %edi
movl %ecx, %ebp
cmovel %edx, %ebp
testq %rsi, %rsi
je 0x186e7
testq %rax, %rax
movq %rcx, %rax
je 0x186c4
movl %ebp, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x182f2
testl %ebp, %ebp
je 0x18710
movq (%r14), %rdi
shlq $0x2, %r15
movq %rsp, %rsi
movq %r15, %rdx
callq 0x4200
jmp 0x18710
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x18732
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x4260
movq %r15, %rdi
callq 0x43f0
// File: /workspace/github_cpp_makefile_star2_O1/ef-gy[P]libefgy/include/ef.gy/big-integers.h
// Function: efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u>::shrink()
void shrink(void) {
    cellType i = cell.size();
    cellType rem = 0;

    if (i == 0) {
      negative = false;
      return;
    }

    while (i > 0) {
      i--;

      if (cell[i] == cellType(0)) {
        rem++;
      } else {
        break;
      }
    }

    if (rem == 0) {
      return;
    }

    cell.resize(cell.size() - rem);

    if (cell.size() == 0) {
      negative = false;
    }
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rsi
subq %rax, %rsi
sarq $0x2, %rsi
testl %esi, %esi
je 0x18aa8
leaq 0x8(%rbx), %rdi
movl %esi, %ecx
leaq (%rax,%rcx,4), %rdx
addq $-0x4, %rdx
xorl %eax, %eax
cmpl $0x0, (%rdx)
jne 0x18a90
incq %rax
addq $-0x4, %rdx
cmpq %rax, %rcx
jne 0x18a7d
movl %esi, %eax
testl %eax, %eax
je 0x18aab
movl %eax, %eax
subq %rax, %rsi
callq 0x182f2
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rax
jne 0x18aab
movb $0x0, (%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ef-gy[P]libefgy/include/ef.gy/big-integers.h
// Function: efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u>::operator>(efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u> const&) const
bool operator>(const bigIntegers &b) const {
    if (!negative && b.negative) {
      return true;
    }

    if (!negative && !b.negative) {
      if (cell.size() > b.cell.size()) {
        return true;
      }

      if (cell.size() < b.cell.size()) {
        return false;
      }

      for (cellType j = cell.size(); j > 0; j--) {
        const cellType &i = (j - 1);

        if (cell[i] > b.cell[i]) {
          return true;
        }
        if (cell[i] < b.cell[i]) {
          return false;
        }
      }

      return false;
    }

    if (negative && b.negative) {
      if (cell.size() < b.cell.size()) {
        return true;
      }

      if (cell.size() > b.cell.size()) {
        return false;
      }

      for (cellType j = cell.size(); j > 0; j--) {
        const cellType &i = (j - 1);

        if (cell[i] < b.cell[i]) {
          return true;
        }
        if (cell[i] > b.cell[i]) {
          return false;
        }
      }

      return false;
    }

    return false;
  }

// Assembly:
movb (%rdi), %cl
testb %cl, %cl
je 0x19152
cmpb $0x1, (%rsi)
jne 0x1918d
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdi
subq %rcx, %rdi
sarq $0x2, %rdi
movq 0x8(%rsi), %rdx
movq 0x10(%rsi), %rsi
subq %rdx, %rsi
sarq $0x2, %rsi
movb $0x1, %al
cmpq %rsi, %rdi
jb 0x19151
ja 0x1918d
movl %edi, %esi
subq $0x1, %rsi
jb 0x1918d
movl (%rcx,%rsi,4), %edi
movl (%rdx,%rsi,4), %r8d
cmpl %r8d, %edi
setbe %r9b
setb %r10b
andb %r9b, %al
orb %r10b, %al
cmpl %r8d, %edi
je 0x1912e
retq
movb $0x1, %al
cmpb $0x0, (%rsi)
jne 0x19151
testb %cl, %cl
jne 0x190fc
cmpb $0x0, (%rsi)
je 0x19168
testb %cl, %cl
jne 0x190fc
jmp 0x1918d
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdi
subq %rcx, %rdi
sarq $0x2, %rdi
movq 0x8(%rsi), %rdx
movq 0x10(%rsi), %rsi
subq %rdx, %rsi
sarq $0x2, %rsi
cmpq %rsi, %rdi
ja 0x19151
jae 0x19190
xorl %eax, %eax
retq
movl %edi, %esi
subq $0x1, %rsi
jb 0x1918d
movl (%rcx,%rsi,4), %edi
movl (%rdx,%rsi,4), %r8d
cmpl %r8d, %edi
seta %r9b
setae %r10b
andb %r10b, %al
orb %r9b, %al
cmpl %r8d, %edi
je 0x19192
jmp 0x19151
nop
// File: /workspace/github_cpp_makefile_star2_O1/ef-gy[P]libefgy/include/ef.gy/big-integers.h
// Function: efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u>::doModuloHorner(efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u> const&, unsigned int const&, bool)
void doModuloHorner(const bigIntegers &a, const cellType &b,
                      bool allocate = true) {
    Tu modulus = Tu(b);
    Tu result = Tu(0);
    const Tu factor = (Tu(1) << cellBitCount) % modulus;

    for (cellType i = a.cell.size(); i > 0; i--) {
      result *= factor;
      result %= modulus;
      result += (Tu(a.cell[(i - 1)]) % modulus);
      result %= modulus;
    }

    cell.resize(1);

    cell[0] = result;

    shrink();
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdx), %edi
xorl %r14d, %r14d
movabsq $0x100000000, %rax      # imm = 0x100000000
xorl %edx, %edx
divq %rdi
movq 0x8(%rsi), %r8
movq 0x10(%rsi), %rax
subq %r8, %rax
shrq $0x2, %rax
testl %eax, %eax
je 0x1921a
movq %rdx, %rcx
movl %eax, %r9d
xorl %r14d, %r14d
imulq %rcx, %r14
movq %r14, %rax
xorl %edx, %edx
divq %rdi
movq %rdx, %rsi
movl -0x4(%r8,%r9,4), %eax
xorl %edx, %edx
divl %edi
addq %rdx, %rsi
movq %rsi, %rax
xorl %edx, %edx
divq %rdi
movq %rdx, %r14
decq %r9
jne 0x191ef
leaq 0x8(%rbx), %rdi
movl $0x1, %esi
callq 0x182f2
movq 0x8(%rbx), %rax
movl %r14d, (%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x18a56
// File: /workspace/github_cpp_makefile_star2_O1/ef-gy[P]libefgy/include/ef.gy/big-integers.h
// Function: efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u>::doModulo(efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u> const&, efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u> const&, bool)
void doModulo(const bigIntegers &a, const bigIntegers &b,
                bool allocate = true) {
    cell.resize(0);

    for (cellType i = a.cell.size(); i > 0; i--) {
      cellType ir = i - 1;
      cellType c = a.cell[ir];

      for (cellType j = cellBitCount; j > 0; j--) {
        cellType jr = j - 1;

        *this <<= 1;

        if (c & (1 << jr)) {
          if (cell.size() == 0) {
            cell.resize(1);
            cell[0] = cellType(1);
          } else {
            cell[0] |= 1;
          }
        }

        if (*this >= b) {
          *this -= b;
        }
      }
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rdi), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x182f2
movq 0x10(%r14), %rax
movq %r14, 0x8(%rsp)
subq 0x8(%r14), %rax
shrq $0x2, %rax
testl %eax, %eax
je 0x19319
movl %eax, %ecx
leaq 0x4(%rsp), %r13
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl -0x4(%rax,%rcx,4), %r14d
decq %rcx
movq %rcx, 0x10(%rsp)
movl $0x1f, %ebp
movl $0x1, 0x4(%rsp)
movq %r15, %rdi
movq %r13, %rsi
callq 0x9c94
btl %ebp, %r14d
jae 0x192dd
movq 0x8(%r15), %rax
cmpq %rax, 0x10(%r15)
je 0x192c6
orb $0x1, (%rax)
jmp 0x192dd
movl $0x1, %esi
movq %r12, %rdi
callq 0x182f2
movq (%r12), %rax
movl $0x1, (%rax)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x193a2
testb %al, %al
jne 0x192fb
movq %r15, %rdi
movq %rbx, %rsi
callq 0x190f6
testb %al, %al
je 0x19306
movq %r15, %rdi
movq %rbx, %rsi
callq 0x19328
addl $-0x1, %ebp
jb 0x1929e
movq 0x10(%rsp), %rcx
testq %rcx, %rcx
jne 0x19283
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ef-gy[P]libefgy/include/ef.gy/big-integers.h
// Function: efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u>::doAdd(efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u> const&, efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u> const&, bool)
void doAdd(const bigIntegers &a, const bigIntegers &b, bool allocate = true) {
    /*
    if ((a.cell.size() <= cellsPerLong) && (b.cell.size() <= cellsPerLong))
    {
        *this = bigIntegers(Tu(a) + Tu(b), negative);
        if ((*this >= a) && (*this >= b))
        {
            return;
        }
    }
    */

    bool overflow = false;

    if (allocate) {
      cell.resize((a.cell.size() > b.cell.size()) ? a.cell.size()
                                                  : b.cell.size());
      if (cell.size() == 0) {
        return;
      }
    }

    if (cell.size() == 0) {
      return;
    }

    for (cellType i = 0; i < cell.size(); i++) {
      cellType av = (i < a.cell.size()) ? a.cell[i] : 0;
      cellType bv = (i < b.cell.size()) ? b.cell[i] : 0;

      if (overflow) {
        bv = bv + 1;

        overflow = (bv == 0);
      }

      cell[i] = (overflow ? av : (av + bv));

      overflow = overflow || ((cell[i] < av) || (cell[i] < bv));
    }

    if (overflow)  // overflow in the most significant cell, add extra cell
    {
      cell.push_back(cellType(1));
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testl %ecx, %ecx
je 0x196ad
leaq 0x8(%rbx), %rdi
movq 0x10(%r15), %rax
subq 0x8(%r15), %rax
sarq $0x2, %rax
movq 0x10(%r14), %rsi
subq 0x8(%r14), %rsi
sarq $0x2, %rsi
cmpq %rsi, %rax
cmovaq %rax, %rsi
callq 0x182f2
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rax
je 0x1978a
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rsi
movq %rsi, %rcx
subq %rax, %rcx
je 0x1978a
movq %rbx, %rdi
leaq 0x8(%rbx), %rdx
movq %rdx, 0x10(%rsp)
sarq $0x2, %rcx
movq 0x8(%r15), %rdx
movq 0x10(%r15), %r8
subq %rdx, %r8
sarq $0x2, %r8
movq 0x8(%r14), %r9
movq 0x10(%r14), %r10
subq %r9, %r10
sarq $0x2, %r10
xorl %r11d, %r11d
xorl %r14d, %r14d
xorl %r15d, %r15d
movl $0x0, %ebp
cmpq %r14, %r8
jbe 0x19706
movl (%rdx,%r14,4), %ebp
xorl %r13d, %r13d
cmpq %r14, %r10
jbe 0x19712
movl (%r9,%r14,4), %r13d
movl %r13d, %r12d
incl %r12d
sete %bl
testb $0x1, %r15b
jne 0x19724
movl %r13d, %r12d
andb %bl, %r15b
testb $0x1, %r15b
movl %r12d, %ebx
cmovnel %r11d, %ebx
addl %ebp, %ebx
setb %bpl
movl %ebx, (%rax,%r14,4)
orb %r15b, %bpl
cmpl %r12d, %ebx
setb %r15b
orb %bpl, %r15b
andb $0x1, %r15b
incq %r14
movl %r14d, %ebx
cmpq %rbx, %rcx
ja 0x196f8
testb %r15b, %r15b
je 0x1978a
movl $0x1, 0xc(%rsp)
cmpq 0x18(%rdi), %rsi
je 0x1977b
movl $0x1, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x10(%rdi)
jmp 0x1978a
leaq 0xc(%rsp), %rdx
movq 0x10(%rsp), %rdi
callq 0x199b2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ef-gy[P]libefgy/include/ef.gy/big-integers.h
// Function: efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u>::operator>>(unsigned int const&) const
bigIntegers operator>>(const cellType &b) const {
    if (cell.size() == 0) {
      return *this;
    }

    if (cell.size() <= cellsPerLong) {
      return bigIntegers(toInteger() >> b, false);
    }

    cellType nukeCells = 0;
    cellType q = b;

    while (q > cellBitCount) {
      nukeCells++;
      q -= cellBitCount;
    }

    if (nukeCells >= cell.size()) {
      return bigIntegers();
    }

    bigIntegers r;

    r.cell.resize(cell.size() - nukeCells);

    for (cellType i = 0; i < r.cell.size(); i++) {
      cellType j = i + 1;

      if (j < r.cell.size()) {
        r.cell[i] = ((Tu(cell[(j + nukeCells)]) << cellBitCount) |
                     (Tu(cell[(i + nukeCells)]))) >>
                    q;
      } else {
        r.cell[i] = (cell[(i + nukeCells)] >> q);
      }
    }

    r.shrink();

    return r;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x8(%rsi), %r12
movq 0x8(%rsi), %rdi
movq 0x10(%rsi), %rsi
subq %rdi, %rsi
je 0x19e09
sarq $0x2, %rsi
cmpq $0x2, %rsi
ja 0x19e2f
movq 0x10(%rax), %rax
xorl %ecx, %ecx
subq %rdi, %rax
je 0x19eea
sarq $0x2, %rax
xorl %r8d, %r8d
xorl %esi, %esi
movl (%rdi,%r8,4), %r9d
shlq %cl, %r9
orq %r9, %rsi
incq %r8
movl %r8d, %r9d
addl $0x20, %ecx
cmpq %r9, %rax
ja 0x19dec
jmp 0x19eec
movb (%rax), %al
movb %al, (%rbx)
leaq 0x8(%rbx), %rdi
movq %r12, %rsi
callq 0x18aae
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rax
jne 0x19efb
movb $0x0, (%rbx)
jmp 0x19efb
movl (%rdx), %r14d
xorl %eax, %eax
cmpl $0x21, %r14d
jb 0x19e51
leal -0x21(%r14), %ecx
movl %ecx, %eax
shrl $0x5, %eax
andl $-0x20, %ecx
incl %eax
negl %ecx
addl %ecx, %r14d
addl $-0x20, %r14d
movl %eax, %r13d
movb $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
subq %r13, %rsi
jbe 0x19efb
leaq 0x8(%rbx), %r15
movq %r15, %rdi
callq 0x182f2
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rsi
subq %rdx, %rsi
je 0x19ee0
sarq $0x2, %rsi
movq (%r12), %rdi
movl %r14d, %eax
leaq 0x1(%r13), %r8
xorl %r9d, %r9d
leaq 0x1(%r9), %r10
movl %r10d, %ecx
cmpq %rcx, %rsi
jbe 0x19ec3
leal (%r8,%r9), %ecx
movl (%rdi,%rcx,4), %ecx
shlq $0x20, %rcx
leal (%r9,%r13), %r11d
movl (%rdi,%r11,4), %r11d
orq %rcx, %r11
movl %eax, %ecx
shrq %cl, %r11
jmp 0x19ed1
leal (%r9,%r13), %ecx
movl (%rdi,%rcx,4), %r11d
movl %r14d, %ecx
shrl %cl, %r11d
movl %r11d, (%rdx,%r9,4)
movl %r10d, %ecx
movq %r10, %r9
cmpq %rcx, %rsi
ja 0x19e9a
movq %rbx, %rdi
callq 0x18a56
jmp 0x19efb
xorl %esi, %esi
movb (%rdx), %cl
shrq %cl, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18694
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%r15), %rdi
testq %rdi, %rdi
je 0x19f1f
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x4260
movq %r14, %rdi
callq 0x43f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 1>::load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void load(std::string filename) {

            const char * cfilename = filename.c_str();
            std::ifstream file(cfilename, std::ios::binary);

            file.seekg(0, file.end);
            int fileSizeInBytes = file.tellg();
            file.seekg(0, file.beg);

            int numberOfSamples = fileSizeInBytes / (sizeof(T) * channels);
            std::cout << sizeof(T) << '\n';
            data_vector.resize(numberOfSamples);

            file.read((char*)&data_vector[0], fileSizeInBytes);
            std::cout << "File loaded." << '\n';
            file.close();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdi, %rbx
movq (%rsi), %rsi
leaq -0x228(%rbp), %r14
movq %r14, %rdi
movl $0x4, %edx
callq 0x2250
movq %r14, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x21a0
leaq -0x228(%rbp), %rdi
callq 0x2220
movq %rax, %r14
leaq -0x228(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21a0
movslq %r14d, %r14
movslq 0x18(%rbx), %rcx
movq %r14, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %r15
movq 0x653d(%rip), %rdi      # 0xbfd8
movl $0x1, %esi
callq 0x20b0
leaq -0x19(%rbp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2150
movslq %r15d, %rsi
movq %rbx, %rdi
callq 0x76b0
movq (%rbx), %rsi
leaq -0x228(%rbp), %rdi
movq %r14, %rdx
callq 0x2180
movq 0x64fb(%rip), %rdi      # 0xbfd8
leaq 0x35d0(%rip), %rsi      # 0x90b4
movl $0xc, %edx
callq 0x2150
leaq -0x19(%rbp), %rsi
movb $0xa, (%rsi)
movq 0x64dc(%rip), %rdi      # 0xbfd8
movl $0x1, %edx
callq 0x2150
leaq -0x228(%rbp), %rdi
callq 0x2030
leaq -0x228(%rbp), %rdi
callq 0x2040
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5b32
jmp 0x5b32
jmp 0x5b32
movq %rax, %rbx
leaq -0x228(%rbp), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O1/adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 1>::operator+(MRXADA002::Audio<signed char, 1> const&)
Audio<T, N> operator+(const Audio<T, N> & rhs) {
            Audio<T, N> a(*this);
            int m = std::min(a.data_vector.size(), rhs.data_vector.size());
            for (int i = 0; i < m; ++i) {
                int newVal = a.data_vector[i] + rhs.data_vector[i]; //add amplitudes
                if (sizeof(T)==1) {
                    if (newVal > INT8_MAX) {    //clamp value for  8 bit
                        newVal = INT8_MAX;
                    }
                    a.data_vector[i] = newVal;
                }
                if (sizeof(T)==2) {             //clamp value for 16 bit
                    if (newVal > INT16_MAX) {
                        newVal = INT16_MAX;
                    }
                    a.data_vector[i] = newVal;
                }
            }
            return a;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x7800
movl 0x18(%r15), %eax
movl %eax, 0x18(%r14)
movq 0x8(%r14), %rcx
subq (%r14), %rcx
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cmpq %rcx, %rax
cmovaeq %rcx, %rax
testl %eax, %eax
jle 0x5bb5
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movl $0x7f, %edx
movq (%r14), %rsi
movsbl (%rsi,%rcx), %edi
movq (%rbx), %r8
movsbl (%r8,%rcx), %r8d
addl %edi, %r8d
cmpl $0x7f, %r8d
cmovgel %edx, %r8d
movb %r8b, (%rsi,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x5b8f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 1>::save(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void save(std::string filename) {
            filename = filename + ".raw";
            const char * cfilename = filename.c_str();
            std::ofstream file(cfilename, std::ios::binary);

            int fileSizeInBytes = data_vector.size() * sizeof(T) * channels; //calculate bytes to be written
            file.write((char*)&data_vector[0], fileSizeInBytes);
            std::cout << "File saved." << '\n';
            file.close();

        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x218(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x228(%rbp), %r15
movq %r15, %rdi
callq 0x7616
leaq 0x34d3(%rip), %rsi      # 0x90db
movq %r15, %rdi
callq 0x2260
movq %r14, %rdi
movq %r15, %rsi
callq 0x2160
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x5c28
callq 0x2120
movq (%r14), %rsi
leaq -0x228(%rbp), %r14
movq %r14, %rdi
movl $0x4, %edx
callq 0x2140
movl 0x8(%rbx), %eax
movq (%rbx), %rsi
subl %esi, %eax
imull 0x18(%rbx), %eax
movslq %eax, %rdx
movq %r14, %rdi
callq 0x2190
movq 0x637b(%rip), %rdi      # 0xbfd8
leaq 0x347c(%rip), %rsi      # 0x90e0
movl $0xb, %edx
callq 0x2150
leaq -0x21(%rbp), %rsi
movb $0xa, (%rsi)
movq 0x635c(%rip), %rdi      # 0xbfd8
movl $0x1, %edx
callq 0x2150
leaq -0x228(%rbp), %rdi
callq 0x21b0
movq 0x6337(%rip), %rax      # 0xbfd0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x220(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x228(%rbp,%rcx)
callq 0x2100
leaq -0x130(%rbp), %rdi
callq 0x2060
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x228(%rbp), %rdi
cmpq %r12, %rdi
je 0x5cfd
callq 0x2120
jmp 0x5cfd
movq %rax, %rbx
leaq -0x228(%rbp), %rdi
callq 0x21c0
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O1/adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 2>::operator+(MRXADA002::Audio<signed char, 2> const&)
Audio<T, 2> operator+(const Audio<T, 2> & rhs) {
            Audio<T, 2> a(*this);
            int m = std::min(a.data_vector.size(), rhs.data_vector.size());
            for (int i = 0; i < m; ++i) {
                int newValLEFT = a.data_vector[i].first + rhs.data_vector[i].first; //add amplitudes of lefts
                int newValRIGHT = a.data_vector[i].second + rhs.data_vector[i].second; //add amplitudes of rights
                if (sizeof(T)==1) {
                    if (newValLEFT > INT8_MAX) {    //clamp value for  8 bit
                        newValLEFT = INT8_MAX;
                    }
                    if (newValRIGHT > INT8_MAX) {    //clamp value for  8 bit
                        newValRIGHT = INT8_MAX;
                    }
                    a.data_vector[i].first = newValLEFT;
                    a.data_vector[i].second = newValRIGHT;
                }
                if (sizeof(T)==2) {
                    if (newValLEFT > INT16_MAX) {    //clamp left value for 16 bit
                        newValLEFT = INT16_MAX;
                    }
                    if (newValRIGHT > INT16_MAX) {    //clamp right value for 16 bit
                        newValRIGHT = INT16_MAX;
                    }
                    a.data_vector[i].first = newValLEFT;
                    a.data_vector[i].second = newValRIGHT;
                }
            }
            return a;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x7c38
movl 0x18(%r15), %eax
movl %eax, 0x18(%rbx)
movq (%rbx), %rax
movq 0x8(%rbx), %rsi
subq %rax, %rsi
sarq %rsi
movq (%r14), %rcx
movq 0x8(%r14), %rdx
subq %rcx, %rdx
sarq %rdx
cmpq %rsi, %rdx
cmovaeq %rsi, %rdx
testl %edx, %edx
jle 0x616d
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %esi, %esi
movl $0x7f, %edi
movsbl (%rax,%rsi,2), %r8d
movsbl (%rcx,%rsi,2), %r9d
addl %r8d, %r9d
movsbl 0x1(%rax,%rsi,2), %r8d
movsbl 0x1(%rcx,%rsi,2), %r10d
addl %r8d, %r10d
cmpl %edi, %r9d
cmovgel %edi, %r9d
cmpl $0x7f, %r10d
cmovgel %edi, %r10d
movb %r9b, (%rax,%rsi,2)
movb %r10b, 0x1(%rax,%rsi,2)
incq %rsi
cmpq %rsi, %rdx
jne 0x6131
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 1>::operator|(MRXADA002::Audio<signed char, 1> const&)
Audio<T, N> operator|(const Audio<T,N> & rhs) {
            Audio<T, N> a(*this);                       //use copy constructor on lhs audio
            for (int i = 0; i < rhs.data_vector.size(); ++i) {
                a.data_vector.push_back(rhs.data_vector[i]);         //append rhs's values onto data_vector
            }
            return a;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x7800
movl 0x18(%r15), %eax
movl %eax, 0x18(%rbx)
movq (%r14), %rdx
cmpq %rdx, 0x8(%r14)
je 0x65fc
xorl %r15d, %r15d
addq %r15, %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x65e2
movb (%rdx), %al
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x65ea
movq %rbx, %rdi
callq 0x7ec6
incq %r15
movq (%r14), %rdx
movq 0x8(%r14), %rax
subq %rdx, %rax
cmpq %r15, %rax
ja 0x65cb
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x661a
callq 0x2120
movq %r14, %rdi
callq 0x2230