LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::rebuildOrderHeap()
void rebuildOrderHeap() {
    order_heap.clear();
    for (size_t v = 0; v < nVars(); ++v)
      if (value(v) == Status::Undef)
        order_heap.emplace(activity[v], v);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xf0(%rdi), %r14
movq %r14, %rdi
callq 0x6702
movq $0x0, 0x8(%rsp)
movq 0x1e8(%rbx), %rax
testq %rax, %rax
je 0x66f7
xorl %esi, %esi
leaq 0x8(%rsp), %r15
movslq %esi, %rcx
movq 0x68(%rbx), %rdx
cmpb $0x2, (%rdx,%rcx)
jne 0x66ea
shlq $0x3, %rsi
addq 0x98(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x676c
movq 0x8(%rsp), %rsi
movq 0x1e8(%rbx), %rax
incq %rsi
movq %rsi, 0x8(%rsp)
cmpq %rax, %rsi
jb 0x66bb
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::removeSatisfied(std::vector<std::unique_ptr<MiniSat::Clause, std::default_delete<MiniSat::Clause>>, std::allocator<std::unique_ptr<MiniSat::Clause, std::default_delete<MiniSat::Clause>>>>&)
void removeSatisfied(std::vector<Clause::Ptr> &cs) {
    size_t j = 0;
    for (auto &c : cs) {
      if (satisfied(*c))
        removeClause(c);
      else {
        for (size_t k = 2; k < c->size(); ++k)
          if (value(c->at(k)) == Status::False) {
            c->at(k--) = c->back();
            c->pop_back();
          }
        cs[j++] = std::move(c);
      }
    }
    cs.resize(j);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %r15
movq 0x8(%rsi), %r13
cmpq %r13, %r15
je 0x6d3c
movq %rdi, %r14
xorl %r12d, %r12d
movq (%r15), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
cmpq %rdx, %rcx
je 0x6c98
movq 0x68(%r14), %rsi
movq %rcx, %rdi
movl (%rdi), %r8d
movl %r8d, %r9d
sarl %r9d
movslq %r9d, %r9
movb (%rsi,%r9), %r9b
cmpb $0x2, %r9b
je 0x6c8f
andb $0x1, %r8b
xorb %r9b, %r8b
cmpb $0x1, %r8b
je 0x6d22
addq $0x4, %rdi
cmpq %rdx, %rdi
jne 0x6c68
movq %rdx, %rsi
subq %rcx, %rsi
cmpq $0x9, %rsi
jb 0x6cf8
leaq 0x8(%rax), %r8
movq 0x68(%r14), %rsi
movl $0x2, %edi
movl (%rcx,%rdi,4), %r9d
movl %r9d, %r10d
sarl %r10d
movslq %r10d, %r10
andb $0x1, %r9b
cmpb %r9b, (%rsi,%r10)
jne 0x6cde
movl -0x4(%rdx), %eax
addq $-0x4, %rdx
movl %eax, (%rcx,%rdi,4)
decq %rdi
movq %rdx, (%r8)
movq (%r15), %rax
movq (%rax), %rcx
incq %rdi
leaq 0x8(%rax), %r8
movq 0x8(%rax), %rdx
movq %rdx, %r9
subq %rcx, %r9
sarq $0x2, %r9
cmpq %r9, %rdi
jb 0x6cb1
leaq 0x1(%r12), %rbp
movq (%rbx), %rcx
movq $0x0, (%r15)
movq (%rcx,%r12,8), %rsi
movq %rax, (%rcx,%r12,8)
testq %rsi, %rsi
je 0x6d1d
leaq (%rcx,%r12,8), %rdi
callq 0x4e98
movq %rbp, %r12
jmp 0x6d2d
movq %r14, %rdi
movq %r15, %rsi
callq 0x6d58
addq $0x8, %r15
cmpq %r13, %r15
jne 0x6c52
jmp 0x6d3f
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6dae
// File: /workspace/github_cpp_makefile_star2_O3/jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::removeClause(std::unique_ptr<MiniSat::Clause, std::default_delete<MiniSat::Clause>>&)
void removeClause(Clause::Ptr &cr) {
    Clause &c = *cr;
    detachClause(&c);
    if (locked(&c))
      vardata[c[0].var()].reason = nullptr;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rsi), %rbx
movq %rbx, %rsi
callq 0x6dd8
movq (%rbx), %rax
movl (%rax), %ecx
movl %ecx, %eax
sarl %eax
cltq
movq 0x68(%r14), %rdx
movb (%rdx,%rax), %dl
cmpb $0x2, %dl
je 0x6da6
andb $0x1, %cl
xorb %cl, %dl
cmpb $0x1, %dl
jne 0x6da6
movq 0x80(%r14), %rcx
shlq $0x4, %rax
cmpq %rbx, (%rcx,%rax)
jne 0x6da6
addq %rax, %rcx
movq $0x0, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::detachClause(MiniSat::Clause*)
void detachClause(Clause *cr) {
    const Clause &c = *cr;
    watcheErase(watches[~c[0]], cr);
    watcheErase(watches[~c[1]], cr);
    if (c.learnt())
      learnts_literals -= c.size();
    else
      num_clauses++, clauses_literals -= c.size();
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x120(%rdi), %r15
movq (%rsi), %rax
movl (%rax), %eax
xorl $0x1, %eax
leaq 0xc(%rsp), %rsi
movl %eax, (%rsi)
movq %r15, %rdi
callq 0x4718
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x6e6a
movq (%r14), %rax
movl 0x4(%rax), %eax
xorl $0x1, %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movq %r15, %rdi
callq 0x4718
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x6e6a
movl $0x200, %eax            # imm = 0x200
cmpb $0x0, 0x18(%r14)
jne 0x6e51
incq 0x1f0(%rbx)
movl $0x1f8, %eax            # imm = 0x1F8
movq 0x8(%r14), %rcx
subq (%r14), %rcx
sarq $0x2, %rcx
subq %rcx, (%rbx,%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::watcheErase(std::vector<MiniSat::JinkelaSat::Watcher, std::allocator<MiniSat::JinkelaSat::Watcher>>&, MiniSat::Clause*)
void watcheErase(std::vector<Watcher> &watche, Clause *cr) {
    auto it = std::find(watche.begin(), watche.end(), cr);
    if (it == watche.end())
      return;
    watche.erase(it);
  }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0x8(%rsp), %rax
movq %rdx, (%rax)
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
movq %rax, %rdx
callq 0x6eb8
movq 0x8(%rbx), %rdx
cmpq %rdx, %rax
je 0x6eb2
leaq 0x10(%rax), %rsi
cmpq %rdx, %rsi
je 0x6eaa
subq %rsi, %rdx
movq %rax, %rdi
callq 0x2210
movq 0x8(%rbx), %rdx
addq $-0x10, %rdx
movq %rdx, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/bauerj4[P]Riemann1D/src/Context.cpp
// Function: printContext(context_t&)
int printContext(context_t &context)
{
  printf("THE CONTEXT IS: \n");
  printf("MESH_RESOLUTION = %d\n",context.MESH_RESOLUTION);
  printf("X0 = %10.10f\n", context.X0);
  printf("X1 = %10.10f\n", context.X1);
  printf("INITIAL_DISCONTINUITY = %10.10f\n", context.INITIAL_DISCONTINUITY);
  printf("RHO_L = %10.10f\n", context.RHO_L);
  printf("P_L = %10.10f\n", context.P_L);
  printf("U_L = %10.10f\n", context.U_L);
  printf("RHO_R = %10.10f\n", context.RHO_R);
  printf("P_R = %10.10f\n", context.P_R);
  printf("U_R = %10.10f\n", context.U_R);

  printf("EVOLVE_TIME = %10.10f\n", context.EVOLVE_TIME);
  printf("CFL_NUMBER = %10.10f\n", context.CFL_NUMBER);

  cout << "SNAPSHOT_PATH = " << context.SNAPSHOT_PATH << '\n';
  cout << "SOLUTION_METHOD = " << context.SOLUTION_METHOD << '\n';

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8715(%rip), %rdi      # 0xb1c7
callq 0x2290
movl (%rbx), %esi
leaq 0x85c1(%rip), %rdi      # 0xb081
xorl %eax, %eax
callq 0x2030
movsd 0x8(%rbx), %xmm0
leaq 0x85c4(%rip), %rdi      # 0xb097
movb $0x1, %al
callq 0x2030
movsd 0x10(%rbx), %xmm0
leaq 0x85bf(%rip), %rdi      # 0xb0a5
movb $0x1, %al
callq 0x2030
movsd 0x48(%rbx), %xmm0
leaq 0x85ba(%rip), %rdi      # 0xb0b3
movb $0x1, %al
callq 0x2030
movsd 0x18(%rbx), %xmm0
leaq 0x85c8(%rip), %rdi      # 0xb0d4
movb $0x1, %al
callq 0x2030
movsd 0x38(%rbx), %xmm0
leaq 0x85c6(%rip), %rdi      # 0xb0e5
movb $0x1, %al
callq 0x2030
movsd 0x28(%rbx), %xmm0
leaq 0x85c2(%rip), %rdi      # 0xb0f4
movb $0x1, %al
callq 0x2030
movsd 0x20(%rbx), %xmm0
leaq 0x85be(%rip), %rdi      # 0xb103
movb $0x1, %al
callq 0x2030
movsd 0x40(%rbx), %xmm0
leaq 0x85bc(%rip), %rdi      # 0xb114
movb $0x1, %al
callq 0x2030
movsd 0x30(%rbx), %xmm0
leaq 0x85b8(%rip), %rdi      # 0xb123
movb $0x1, %al
callq 0x2030
movsd 0x58(%rbx), %xmm0
leaq 0x85b4(%rip), %rdi      # 0xb132
movb $0x1, %al
callq 0x2030
movsd 0x50(%rbx), %xmm0
leaq 0x85b8(%rip), %rdi      # 0xb149
movb $0x1, %al
callq 0x2030
movq 0xb439(%rip), %r14      # 0xdfd8
leaq 0x85b9(%rip), %rsi      # 0xb15f
movq %r14, %rdi
callq 0x21a0
leaq 0x80(%rbx), %rsi
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
movl $0xa, %esi
callq 0x2210
leaq 0x859f(%rip), %rsi      # 0xb170
movq %r14, %rdi
callq 0x21a0
addq $0x60, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2180
movq %rax, %rdi
movl $0xa, %esi
callq 0x2210
nop
// File: /workspace/github_cpp_makefile_star2_O3/bauerj4[P]Riemann1D/src/Fluxes.cpp
// Function: SUPERBEE(double, double)
double SUPERBEE(double r, double c)
{
  if (r <= 0 )
    {
      return 1.0;
    }
  else if(r > 0 && r <= 0.5)
    {
      return (1. - (2.*(1. - c) * r));
    }
  else if (r > 0.5 && r <= 1.0)
    {
      return c;
    }
  else if (r > 1.0 && r <= 2.0)
    {
      return (1. - ((1. - c)*r));
    }
  else if (r > 2.0)
    {
      return ((2. * c) - 1.);
    }
  /*
  else if (r!=r)
    {
      return 0;
      }*/
  
}

// Assembly:
xorpd %xmm2, %xmm2
ucomisd %xmm0, %xmm2
jae 0x33c5
ucomisd %xmm2, %xmm0
jbe 0x33d2
movsd 0x7f2e(%rip), %xmm2     # 0xb2c8
ucomisd %xmm0, %xmm2
jb 0x33d2
movsd 0x7f18(%rip), %xmm3     # 0xb2c0
movapd %xmm3, %xmm2
subsd %xmm1, %xmm2
mulsd 0x7f28(%rip), %xmm2     # 0xb2e0
mulsd %xmm0, %xmm2
addsd %xmm3, %xmm2
movapd %xmm2, %xmm0
retq
movsd 0x7ef3(%rip), %xmm1     # 0xb2c0
movapd %xmm1, %xmm0
retq
ucomisd 0x7eee(%rip), %xmm0     # 0xb2c8
jbe 0x33ea
movsd 0x7edc(%rip), %xmm2     # 0xb2c0
ucomisd %xmm0, %xmm2
jae 0x33cd
ucomisd 0x7ece(%rip), %xmm0     # 0xb2c0
jbe 0x341c
movsd 0x7ed4(%rip), %xmm2     # 0xb2d0
ucomisd %xmm0, %xmm2
jb 0x341c
movsd 0x7eb6(%rip), %xmm2     # 0xb2c0
movapd %xmm2, %xmm3
subsd %xmm1, %xmm3
mulsd %xmm0, %xmm3
subsd %xmm3, %xmm2
jmp 0x33c0
addsd %xmm1, %xmm1
addsd 0x7eb0(%rip), %xmm1     # 0xb2d8
jmp 0x33cd
// File: /workspace/github_cpp_makefile_star2_O3/bauerj4[P]Riemann1D/src/Fluxes.cpp
// Function: MINBEE(double, double)
double MINBEE(double r, double c)
{
  if (r <= 0.)
    {
      return 1.0;
    }
  else if(r > 0. && r <= 1.) 
    {
      return (1 - (1 - c)*r);
    }
  else if(r > 1)
    {
      return c;
    }
}

// Assembly:
xorpd %xmm2, %xmm2
ucomisd %xmm0, %xmm2
jae 0x345d
ucomisd %xmm2, %xmm0
jbe 0x3465
movsd 0x7e7e(%rip), %xmm2     # 0xb2c0
ucomisd %xmm0, %xmm2
jb 0x3465
movapd %xmm2, %xmm3
subsd %xmm1, %xmm3
mulsd %xmm0, %xmm3
subsd %xmm3, %xmm2
movapd %xmm2, %xmm0
retq
movsd 0x7e5b(%rip), %xmm1     # 0xb2c0
movaps %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/bauerj4[P]Riemann1D/src/Fluxes.cpp
// Function: primativeTo1DConservative(std::vector<double, std::allocator<double>>)
vector<double> primativeTo1DConservative(vector<double> primative)
{
  if (primative.size()!=3)
    {
      printf("INCORRECT PRIMATIVE VARIABLE SIZE!\n");
      return primative;
    }
  double gamma = 1.4;
  double density = primative[0];
  double velocity = primative[1];
  double pressure = primative[2];
  double conservative_2 = density * velocity;
  //primative[1] *= primative[0];
  // Compute energy from pressure
  double int_energy = pressure / (density * (gamma - 1.));
  double kinetic_energy = 0.5 * velocity * velocity;

  double conservative_3 = density * (int_energy + kinetic_energy);
  vector<double> conservative(3,0.0);
  conservative[0] = density;
  conservative[1] = conservative_2;
  conservative[2] = conservative_3;
  //primative[2] = energy * primative[0] + pow(primative[1]/primative[0],2.0);
  return conservative;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
cmpq $0x18, %rcx
jne 0x3511
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
shufps $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movaps %xmm0, 0x20(%rsp)
movl $0x18, %edi
callq 0x21c0
movq %rax, (%rbx)
leaq 0x18(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq %rcx, 0x8(%rbx)
movsd 0x7e24(%rip), %xmm0     # 0xb2e8
movapd 0x10(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x8(%rsp), %xmm3
divsd %xmm0, %xmm3
movapd %xmm1, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
movsd 0x7ddc(%rip), %xmm1     # 0xb2c8
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm3, %xmm1
movapd %xmm2, %xmm0
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
mulpd 0x20(%rsp), %xmm0
movlpd %xmm2, (%rax)
movupd %xmm0, 0x8(%rax)
jmp 0x3542
movq %rsi, %r14
leaq 0x7f40(%rip), %rdi      # 0xb45b
callq 0x2290
movupd (%r14), %xmm0
movupd %xmm0, (%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
xorpd %xmm0, %xmm0
movupd %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/bauerj4[P]Riemann1D/src/Fluxes.cpp
// Function: conservativeTo1DPrimative(std::vector<double, std::allocator<double>>)
vector<double> conservativeTo1DPrimative(vector<double> conservative)
{
  double gamma = 1.4;

  if (conservative.size()!=3)
    {
      printf("INCORRECT CONSERVATIVE VARIABLE SIZE!\n");
      return conservative;
    }


  double density = conservative[0]; 
  double velocity = conservative[1] / density;
  double spec_energy = conservative[2] / density;
  //from eq of state
  double int_energy = spec_energy - 0.5 * velocity * velocity;
  double pressure = int_energy * density*(gamma -1.);

  vector<double> primative(3,0.0);
  primative[0] = density;
  primative[1] = velocity;
  primative[2] = pressure;

  return primative;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
cmpq $0x18, %rcx
jne 0x35ec
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rax), %xmm0
movsd %xmm0, (%rsp)
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movl $0x18, %edi
callq 0x21c0
movq %rax, (%rbx)
leaq 0x18(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq %rcx, 0x8(%rbx)
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm2
divsd %xmm1, %xmm2
movsd 0x7d36(%rip), %xmm0     # 0xb2f0
mulsd %xmm2, %xmm0
movsd 0x10(%rsp), %xmm3
divsd %xmm1, %xmm3
mulsd %xmm2, %xmm0
addsd %xmm3, %xmm0
mulsd %xmm1, %xmm0
mulsd 0x7d0c(%rip), %xmm0     # 0xb2e8
movsd %xmm1, (%rax)
movsd %xmm2, 0x8(%rax)
movsd %xmm0, 0x10(%rax)
jmp 0x361d
movq %rsi, %r14
leaq 0x7e88(%rip), %rdi      # 0xb47e
callq 0x2290
movupd (%r14), %xmm0
movupd %xmm0, (%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
xorpd %xmm0, %xmm0
movupd %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/bauerj4[P]Riemann1D/src/Mesh.cpp
// Function: PrintMeshData(mesh_t&)
int PrintMeshData(mesh_t &mesh)
{
  for (int k = 0; k < mesh.NCells; k++)
    {
      printf("%10.10f, %10.10f, %10.10f, %10.10f\n", mesh.FirstMeshElement[k], mesh.FirstDensityElement[k],
             mesh.FirstPressureElement[k], mesh.FirstVelocityElement[k]);
    }
  return 0;
}

// Assembly:
cmpl $0x0, (%rdi)
jle 0x9c70
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
leaq 0x19c0(%rip), %r14      # 0xb5ee
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movsd (%rax,%r15,8), %xmm0
movsd (%rcx,%r15,8), %xmm1
movq 0x18(%rbx), %rax
movsd (%rax,%r15,8), %xmm2
movq 0x20(%rbx), %rax
movsd (%rax,%r15,8), %xmm3
movq %r14, %rdi
movb $0x4, %al
callq 0x2030
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0x9c2e
popq %rbx
popq %r14
popq %r15
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/bauerj4[P]Riemann1D/src/Mesh.cpp
// Function: PrintDataToFile(mesh_t&, context_t&, int)
int PrintDataToFile(mesh_t &mesh, context_t &RiemannContext, int snapno)
{
  stringstream cppPath;
  cppPath <<  RiemannContext.SNAPSHOT_PATH << snapno;
  const char * PATH = (cppPath.str()).c_str();
  FILE * f = fopen(PATH, "w");
  
  for (int i = 0; i < mesh.NCells; i++)
    {
      fprintf(f,"%10.5f %10.5f %10.5f %10.5f\n", mesh.FirstMeshElement[i], 
	      mesh.FirstDensityElement[i], mesh.FirstPressureElement[i], mesh.FirstVelocityElement[i]);
    }
  fclose(f);
  
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2120
leaq 0x38(%rsp), %rdi
movq 0x80(%r14), %rsi
movq 0x88(%r14), %rdx
callq 0x2200
movq %rax, %rdi
movl %ebp, %esi
callq 0x22e0
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x22b0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %r14
cmpq %rax, %r14
je 0x9ce3
movq 0x18(%rsp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x21d0
leaq 0x1928(%rip), %rsi      # 0xb612
movq %r14, %rdi
callq 0x2220
movq %rax, %r14
cmpl $0x0, (%rbx)
jle 0x9d44
xorl %r12d, %r12d
leaq 0x1910(%rip), %r15      # 0xb614
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movsd (%rax,%r12,8), %xmm0
movsd (%rcx,%r12,8), %xmm1
movq 0x18(%rbx), %rax
movsd (%rax,%r12,8), %xmm2
movq 0x20(%rbx), %rax
movsd (%rax,%r12,8), %xmm3
movq %r14, %rdi
movq %r15, %rsi
movb $0x4, %al
callq 0x2260
incq %r12
movslq (%rbx), %rax
cmpq %rax, %r12
jl 0x9d04
movq %r14, %rdi
callq 0x21b0
movq 0x426d(%rip), %rsi      # 0xdfc0
leaq 0x28(%rsp), %rdi
callq 0x2140
leaq 0xa8(%rsp), %rdi
callq 0x20a0
xorl %eax, %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9d7e
movq %rax, %rbx
movq 0x4238(%rip), %rsi      # 0xdfc0
leaq 0x28(%rsp), %rdi
callq 0x2140
leaq 0xa8(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O3/gpertea[P]gclib/GBase.cpp
// Function: GAssert(char const*, char const*, unsigned int)
void GAssert(const char* expression, const char* filename, unsigned int lineno){
  char msg[4096];
  sprintf(msg,"%s(%d): ASSERT(%s) failed.\n",filename,lineno,expression);
  fprintf(stderr,"%s",msg);
  #ifdef DEBUG
  // modify here if you [don't] want a core dump
    abort();
  #endif
  exit(1);
}

// Assembly:
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movl %edx, %ecx
movq %rsi, %rdx
movq %rdi, %r8
leaq 0xb7c1(%rip), %rsi      # 0xe004
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2080
movq 0x11781(%rip), %rax     # 0x13fd8
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x22b0
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O3/gpertea[P]gclib/GBase.cpp
// Function: Gstrdup(char const*, int)
char* Gstrdup(const char* str, int xtracap) {
  if (str==NULL) return NULL;
  char *copy=NULL;
  GMALLOC(copy, strlen(str)+1+xtracap);
  strcpy(copy,str);
  return copy;
  }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x293e
movl %esi, %ebp
movq %rdi, %rbx
callq 0x2140
movslq %ebp, %rdi
addq %rax, %rdi
incq %rdi
je 0x2947
callq 0x2330
testq %rax, %rax
je 0x2947
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2220
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xb6d2(%rip), %rdi      # 0xe020
xorl %eax, %eax
callq 0x286c
// File: /workspace/github_cpp_makefile_star2_O3/gpertea[P]gclib/GBase.cpp
// Function: newEmptyStr()
char* newEmptyStr() {
  char* zs=NULL;
  GMALLOC(zs,1);
  zs[0]=0;
  return zs;
}

// Assembly:
pushq %rax
movl $0x1, %edi
callq 0x2330
testq %rax, %rax
je 0x296a
movb $0x0, (%rax)
popq %rcx
retq
leaq 0xb6af(%rip), %rdi      # 0xe020
xorl %eax, %eax
callq 0x286c
// File: /workspace/github_cpp_makefile_star2_O3/gpertea[P]gclib/GBase.cpp
// Function: Gstrdup(char const*, char const*)
char* Gstrdup(const char* sfrom, const char* sto) {
  if (sfrom==NULL || sto==NULL) return NULL;
  char *copy=NULL;
  if (sfrom[0]==0 || sto<sfrom) return newEmptyStr();
  GMALLOC(copy, sto-sfrom+2);
  strncpy(copy, sfrom, sto-sfrom+1);
  copy[sto-sfrom+1]=0;
  return copy;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x2992
xorl %r15d, %r15d
jmp 0x29ce
movq %rsi, %rbx
movq %rdi, %r14
subq %rdi, %rbx
jb 0x29d7
cmpb $0x0, (%r14)
je 0x29d7
movq %rbx, %rdi
addq $0x2, %rdi
je 0x29e1
callq 0x2330
testq %rax, %rax
je 0x29e1
movq %rax, %r15
leaq 0x1(%rbx), %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2180
movb $0x0, 0x1(%r15,%rbx)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
popq %rbx
popq %r14
popq %r15
jmp 0x2955
leaq 0xb638(%rip), %rdi      # 0xe020
xorl %eax, %eax
callq 0x286c
// File: /workspace/github_cpp_makefile_star2_O3/gpertea[P]gclib/GBase.cpp
// Function: Gstrcmp(char const*, char const*, int)
int Gstrcmp(const char* a, const char* b, int n) {
 if (a==NULL || b==NULL) {
   return a==NULL ? -1 : 1;
   }
 else {
   if (n<0) return strcmp(a,b);
       else return strncmp(a,b,n);
 }
}

// Assembly:
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
testb %cl, %al
jne 0x2a0b
xorl %eax, %eax
cmpq $0x1, %rdi
sbbl %eax, %eax
orl $0x1, %eax
retq
testl %edx, %edx
js 0x2350
movl %edx, %edx
jmp 0x2170
// File: /workspace/github_cpp_makefile_star2_O3/gpertea[P]gclib/GBase.cpp
// Function: to_unix_path(char*)
char *to_unix_path(char *p) {
    if (p != NULL) {
        char *pp = p;
        while (*pp != 0) {
            if (*pp == '\\')
                *pp = '/';
            ++pp;
        }
    }
    return p;
}

// Assembly:
movq %rdi, %rax
testq %rdi, %rdi
je 0x2a75
movq %rax, %rcx
movzbl (%rcx), %edx
cmpl $0x5c, %edx
je 0x2a6d
testl %edx, %edx
jne 0x2a70
jmp 0x2a75
movb $0x2f, (%rcx)
incq %rcx
jmp 0x2a5f
retq
// File: /workspace/github_cpp_makefile_star2_O3/gpertea[P]gclib/GBase.cpp
// Function: Gfopen(char const*, char*)
FILE* Gfopen(const char *path, char *mode) {
	FILE* f=NULL;
	if (mode==NULL) f=fopen(path, "rb");
	    	   else f=fopen(path, mode);
	if (f==NULL)
		GMessage("Error opening file '%s':  %s\n", path, strerror(errno));
	return f;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
leaq 0xb342(%rip), %rax      # 0xe09b
cmoveq %rax, %rsi
callq 0x22d0
movq %rax, %r14
testq %rax, %rax
je 0x2d75
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x2567
jmp 0x2d6a
nop
// File: /workspace/github_cpp_makefile_star2_O3/gpertea[P]gclib/GBase.cpp
// Function: strsplit(char*, GDynArray<char*>&, char const*, int)
int strsplit(char* str, GDynArray<char*>& fields, const char* delim, int maxfields) {
 //splits by placing 0 where any of the delim chars are found, setting fields[] to the beginning
 //of each field (stopping after maxfields); returns number of fields parsed
 int tidx=0;
 bool afterdelim=true;
 int i=0;
 fields.Reset();
 while (str[i]!=0 && tidx<maxfields) {
    if (afterdelim) {
       fields.Add(str+i);
       tidx++;
    }
    afterdelim=false;
    if (chrInStr(str[i],(char*)delim)) {
        str[i]=0;
        i++;
        while (str[i]!=0 && chrInStr(str[i], (char*)delim)) i++;
        afterdelim=true;
        continue;
    }
    i++;
 }
 return tidx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, 0x10(%rsp)
movl $0x0, 0x18(%rsi)
movb (%rdi), %sil
testb %sil, %sil
sete %al
testl %ecx, %ecx
setle %dl
xorl %ebp, %ebp
orb %al, %dl
jne 0x3146
movl %ecx, %r15d
movq %rdi, %r12
leaq 0x1(%r14), %rax
movq %rax, 0x8(%rsp)
movb $0x1, %al
xorl %ebx, %ebx
movq %rdi, %r13
xorl %ebp, %ebp
testb $0x1, %al
je 0x30ad
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x4586
incl %ebp
movb (%r13), %sil
testq %r14, %r14
je 0x312a
movb (%r14), %al
testb %al, %al
je 0x312a
cmpb %sil, %al
je 0x30d5
movq 0x8(%rsp), %rax
movb (%rax), %dl
cmpb %sil, %dl
je 0x30d1
incq %rax
testb %dl, %dl
jne 0x30c3
testb %dl, %dl
je 0x312a
movb $0x0, (%r13)
movslq %ebx, %rbx
movb 0x1(%r12,%rbx), %r9b
incq %rbx
movb $0x1, %al
testb %r9b, %r9b
je 0x312e
movb (%r14), %dl
movl %ebx, %esi
movq 0x8(%rsp), %r10
testb %dl, %dl
je 0x312e
cmpb %r9b, %dl
je 0x3117
movq %r10, %rdi
movb (%rdi), %r8b
cmpb %r9b, %r8b
je 0x3112
incq %rdi
testb %r8b, %r8b
jne 0x3102
testb %r8b, %r8b
je 0x312e
incl %esi
movb 0x1(%r12,%rbx), %r9b
incq %rbx
testb %r9b, %r9b
jne 0x30f6
movl %esi, %ebx
jmp 0x312e
incl %ebx
xorl %eax, %eax
movslq %ebx, %r13
movb (%r12,%r13), %sil
testb %sil, %sil
je 0x3146
addq %r12, %r13
cmpl %r15d, %ebp
jl 0x3096
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/gpertea[P]gclib/GBase.cpp
// Function: strsplit(char*, GDynArray<char*>&, char, int)
int strsplit(char* str, GDynArray<char*>& fields, const char delim, int maxfields) {
  //splits by placing 0 where delim is found, setting fields[] to the beginning
  //of each field (stopping after maxfields); returns number of fields parsed
  int tidx=0;
  bool afterdelim=true;
  int i=0;
  fields.Reset();
  while (str[i]!=0 && tidx<maxfields) {
     if (afterdelim) {
    	 fields.Add(str+i);
         tidx++;
     }
     afterdelim=false;
     if (str[i]==delim) {
         str[i]=0;
         i++;
         while (str[i]!=0 && str[i]==delim) i++;
         afterdelim=true;
         continue;
     }
     i++;
  }
  return tidx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, 0x10(%rsp)
movl $0x0, 0x18(%rsi)
movb (%rdi), %cl
testb %cl, %cl
sete %al
testl %ebx, %ebx
setle %dl
xorl %r12d, %r12d
orb %al, %dl
jne 0x3221
movq %rdi, %r15
leaq 0x1(%rdi), %rax
movq %rax, 0x8(%rsp)
movb $0x1, %al
xorl %r14d, %r14d
movq %rdi, %r13
xorl %r12d, %r12d
testb $0x1, %al
je 0x31e3
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x4586
incl %r12d
movb (%r13), %cl
cmpb %bpl, %cl
sete %al
jne 0x320b
movb $0x0, (%r13)
movslq %r14d, %rcx
addq 0x8(%rsp), %rcx
movb (%rcx), %dl
incl %r14d
testb %dl, %dl
je 0x320e
incq %rcx
cmpb %bpl, %dl
je 0x31f8
jmp 0x320e
incl %r14d
movslq %r14d, %r13
movb (%r15,%r13), %cl
testb %cl, %cl
je 0x3221
addq %r15, %r13
cmpl %ebx, %r12d
jl 0x31cb
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/gpertea[P]gclib/GBase.cpp
// Function: strsplit(char*, GDynArray<char*>&, int)
int strsplit(char* str,  GDynArray<char*>& fields, int maxfields) {
  //splits by placing 0 where delim is found, setting fields[] to the beginning
  //of each field (stopping after maxfields); returns number of fields parsed
  int tidx=0;
  bool afterdelim=true;
  int i=0;
  fields.Reset();
  while (str[i]!=0 && tidx<maxfields) {
     if (afterdelim) {
        fields.Add(str+i);
        tidx++;
     }
     afterdelim=false;
     if (str[i]==' ' || str[i]=='\t') {
         str[i]=0;
         i++;
         while (str[i]!=0 && (str[i]=='\t' || str[i]==' ')) i++;
         afterdelim=true;
         continue;
     }
     i++;
  }
  return tidx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, (%rsp)
movl $0x0, 0x18(%rsi)
movb (%rdi), %al
testb %al, %al
sete %cl
testl %edx, %edx
setle %dl
xorl %ebp, %ebp
orb %cl, %dl
jne 0x32d0
movq %rdi, %r15
leaq 0x1(%rdi), %r13
movb $0x1, %cl
xorl %r14d, %r14d
movq %rdi, %r12
xorl %ebp, %ebp
testb $0x1, %cl
je 0x3285
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x4586
incl %ebp
movb (%r12), %al
cmpb $0x20, %al
je 0x3291
movzbl %al, %eax
cmpl $0x9, %eax
jne 0x32b9
movb $0x0, (%r12)
movslq %r14d, %rax
leal 0x1(%rax), %r14d
addq %r13, %rax
movzbl (%rax), %ecx
cmpl $0x20, %ecx
je 0x32ad
cmpl $0x9, %ecx
jne 0x32b5
incl %r14d
incq %rax
jmp 0x32a0
movb $0x1, %cl
jmp 0x32be
incl %r14d
xorl %ecx, %ecx
movslq %r14d, %r12
movb (%r15,%r12), %al
testb %al, %al
je 0x32d0
addq %r15, %r12
cmpl %ebx, %ebp
jl 0x326e
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/gpertea[P]gclib/GBase.cpp
// Function: Gsubstr(char const*, char*, char*)
char* Gsubstr(const char* str, char* from, char* to) {
 //extract (and allocate) a substring, including boundaries (from/to)
 if (str==NULL || from==NULL) return NULL;
 if (from[0]==0 || str[0]==0) return newEmptyStr();
 if (from<str) return NULL;
 if (to==NULL) {
    to=from;
    while (to[1]) to++;
    }
 if (to<from) return newEmptyStr();
 int newlen=to-from+1;
 char* subs=NULL;
 GMALLOC(subs, newlen);
 memcpy(subs, str, newlen-1);
 subs[newlen]='\0';
 return subs;
 }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x330b
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpb $0x0, (%rsi)
je 0x333b
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x333b
cmpq %rbx, %rsi
jb 0x32f9
movq %rdx, %r14
testq %rdx, %rdx
jne 0x3336
leaq -0x1(%rsi), %rax
leaq 0x1(%rax), %r14
cmpb $0x0, 0x2(%rax)
movq %r14, %rax
jne 0x3329
cmpq %rsi, %r14
jae 0x334b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2955
subl %esi, %r14d
shlq $0x20, %r14
movabsq $0x100000000, %r15      # imm = 0x100000000
addq %r14, %r15
je 0x3391
sarq $0x20, %r15
movq %r15, %rdi
callq 0x2330
testq %rax, %rax
je 0x3391
movq %rax, %r12
sarq $0x20, %r14
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x21e0
movb $0x0, (%r12,%r15)
jmp 0x32fc
leaq 0xac88(%rip), %rdi      # 0xe020
xorl %eax, %eax
callq 0x286c
// File: /workspace/github_cpp_makefile_star2_O3/gpertea[P]gclib/GBase.cpp
// Function: replaceStr(char*&, char*)
char* replaceStr(char* &str, char* newvalue) {
 if (str!=NULL) GFREE(str);
 if (newvalue==NULL) { return NULL; }
 GMALLOC(str, strlen(newvalue)+1);
 strcpy(str,newvalue);
 return str;
 }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x33bd
callq 0x22e0
movq $0x0, (%r14)
testq %rbx, %rbx
je 0x33f8
movq %rbx, %rdi
callq 0x2140
movq $0x0, (%r14)
incq %rax
je 0x3402
movq %rax, %rdi
callq 0x2330
movq %rax, (%r14)
testq %rax, %rax
je 0x3402
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2220
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xac17(%rip), %rdi      # 0xe020
xorl %eax, %eax
callq 0x286c
// File: /workspace/github_cpp_makefile_star2_O3/gpertea[P]gclib/GBase.cpp
// Function: Gmemscan(void*, unsigned int, void*, unsigned int)
void* Gmemscan(void *mem, unsigned int len,
                   void *part, unsigned int partlen) {
char* p;
unsigned int restlen=len-partlen+1;
void* oldp=mem;
while ( (p=(char*)memchr(oldp, ((char*)part)[0], restlen))!=NULL) {
  //located first char, try to match the rest:
  p++;
  if (memcmp(p, &((char*)part)[1], partlen-1)==0) return p-1;
  //no string match, prepare next iteration
  restlen-=(p-(char*)oldp);
  oldp=p;
  }//while
return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
subl %ecx, %r15d
incl %r15d
movsbl (%rdx), %esi
movl %esi, 0x4(%rsp)
movq %r15, %rdx
callq 0x22a0
testq %rax, %rax
je 0x347e
movq %rax, %r13
incq %r14
decl %ebx
leaq 0x1(%r13), %rbp
movq %rbp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2260
testl %eax, %eax
je 0x3481
subl %ebp, %r12d
addl %r12d, %r15d
movq %rbp, %rdi
movl 0x4(%rsp), %esi
movq %r15, %rdx
callq 0x22a0
movq %rax, %r13
movq %rbp, %r12
testq %rax, %rax
jne 0x3448
xorl %r13d, %r13d
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/gpertea[P]gclib/GBase.cpp
// Function: rstrchr(char*, char)
char* rstrchr(char* str, char ch) {  /* returns a pointer to the rightmost
  occurence of ch in str  */
 char *p;
 if (str==NULL) return NULL;
 p=str+strlen(str)-1;
 while (p>=str) {
    if (*p==ch) return p;
    p--;
    }
 return NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x34cd
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x2140
leaq (%rax,%r14), %rcx
decq %rcx
xorl %eax, %eax
cmpq %r14, %rcx
jb 0x34c5
leaq -0x1(%rcx), %rdx
cmpb %bl, (%rcx)
movq %rdx, %rcx
jne 0x34af
incq %rdx
movq %rdx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/gpertea[P]gclib/GBase.cpp
// Function: fgetline(char*&, int&, _IO_FILE*, long*, int*)
char* fgetline(char* & buf, int& buf_cap, FILE *stream, off_t* f_pos, int* linelen) {
  //reads a char at a time until \n and/or \r are encountered
  int c=0;
  GDynArray<char> arr(buf, buf_cap);
  off_t fpos=(f_pos!=NULL) ? *f_pos : 0;
  while ((c=getc(stream))!=EOF) {
    if (c=='\n' || c=='\r') {
       if (c=='\r') {
         if ((c=getc(stream))!='\n') ungetc(c,stream);
                                else fpos++;
         }
       fpos++;
       break;
       }
    fpos++;
    arr.Push((char)c);
    } //while i<buf_cap-1
  //if (linelen!=NULL) *linelen=i;
  if (linelen!=NULL) *linelen=arr.Count();
  if (f_pos!=NULL) *f_pos=fpos;
  //if (c==EOF && i==0) return NULL;
  if (c==EOF && arr.Count()==0) return NULL;
  arr.Push('\0');
  buf=arr();
  buf_cap=arr.Capacity();
  return buf;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r12
movq %rcx, %r15
movq %rdx, %r13
movq %rdi, %r14
movq (%rdi), %rax
movq %rsi, 0x20(%rsp)
movl (%rsi), %ecx
leaq 0x107f5(%rip), %rdx     # 0x13cf0
movq %rdx, (%rsp)
movb $0x1, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movl %ecx, 0x1c(%rsp)
testq %r15, %r15
je 0x351f
movq (%r15), %rbx
jmp 0x3521
xorl %ebx, %ebx
movq %rsp, %rbp
movq %r13, %rdi
callq 0x20c0
cmpl $-0x1, %eax
je 0x354b
cmpl $0xa, %eax
je 0x355f
cmpl $0xd, %eax
je 0x354f
incq %rbx
movsbl %al, %esi
movq %rbp, %rdi
callq 0x45d2
jmp 0x3524
movb $0x1, %al
jmp 0x3578
movq %r13, %rdi
callq 0x20c0
cmpl $0xa, %eax
jne 0x3563
incq %rbx
xorl %eax, %eax
jmp 0x3575
movl %eax, %ebp
movl %eax, %edi
movq %r13, %rsi
callq 0x2070
cmpl $-0x1, %ebp
sete %al
incq %rbx
testq %r12, %r12
je 0x3585
movl 0x18(%rsp), %ecx
movl %ecx, (%r12)
testq %r15, %r15
je 0x358d
movq %rbx, (%r15)
cmpl $0x0, 0x18(%rsp)
sete %cl
testb %cl, %al
je 0x359e
xorl %r15d, %r15d
jmp 0x35bb
movq %rsp, %rdi
xorl %esi, %esi
callq 0x45d2
movq 0x10(%rsp), %r15
movq %r15, (%r14)
movl 0x1c(%rsp), %eax
movq 0x20(%rsp), %rcx
movl %eax, (%rcx)
leaq 0x1072e(%rip), %rax     # 0x13cf0
movq %rax, (%rsp)
cmpb $0x0, 0x8(%rsp)
jne 0x35dc
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x35dc
callq 0x22e0
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x35f0
movq %rax, %rbx
leaq 0x106f6(%rip), %rax     # 0x13cf0
movq %rax, (%rsp)
cmpb $0x0, 0x8(%rsp)
jne 0x3614
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3614
callq 0x22e0
movq %rbx, %rdi
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O3/gpertea[P]gclib/GBase.cpp
// Function: GLineReader::getLine(_IO_FILE*, long&)
char* GLineReader::getLine(FILE* stream, off_t& f_pos) {
   if (pushed) { pushed=false; return buf(); }
   //reads a char at a time until \n and/or \r are encountered
   int c=0;
   textlen=0;
   buf.Reset(); //len = 0
   while ((c=getc(stream))!=EOF) {
     if (c=='\n' || c=='\r') {
       textlen=buf.Count();
       buf.Push('\0');
       if (c=='\r') { //DOS file -- special case
         if ((c=getc(stream))!='\n') ungetc(c,stream);
                                else f_pos++;
         }
       f_pos++;
       lcount++;
       return buf();
     }
     f_pos++;
     buf.Push(c);
     } //while i<buf_cap-1
   if (c==EOF) {
     isEOF=true;
     textlen=buf.Count();
     if (buf.Count()==0) return NULL;
     }
   textlen=buf.Count();
   buf.Push('\0');
   lcount++;
   return buf();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x40(%rdi)
jne 0x3636
movb $0x0, 0x40(%rbx)
jmp 0x36c3
movq %rdx, %r14
movq %rsi, %r15
xorl %eax, %eax
movl %eax, 0x28(%rbx)
leaq 0x8(%rbx), %r12
movl %eax, 0x20(%rbx)
movq %r15, %rdi
callq 0x20c0
cmpl $-0x1, %eax
je 0x3699
movl %eax, %ebp
cmpl $0xd, %eax
je 0x3672
cmpl $0xa, %ebp
je 0x3672
incq (%r14)
movsbl %bpl, %esi
movq %r12, %rdi
callq 0x45d2
jmp 0x3648
movl 0x20(%rbx), %eax
movl %eax, 0x28(%rbx)
movq %r12, %rdi
xorl %esi, %esi
callq 0x45d2
cmpl $0xd, %ebp
jne 0x36bd
movq %r15, %rdi
callq 0x20c0
cmpl $0xa, %eax
jne 0x36b3
incq (%r14)
jmp 0x36bd
movb $0x1, 0x2c(%rbx)
movl 0x20(%rbx), %eax
movl %eax, 0x28(%rbx)
testl %eax, %eax
je 0x36d0
movq %r12, %rdi
xorl %esi, %esi
callq 0x45d2
jmp 0x36c0
movl %eax, %edi
movq %r15, %rsi
callq 0x2070
incq (%r14)
incl 0x44(%rbx)
movq 0x18(%rbx), %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x36c7
// File: /workspace/github_cpp_makefile_star2_O3/gpertea[P]gclib/GBase.cpp
// Function: strchrs(char const*, char const*)
char* strchrs(const char* s, const char* chrs) {
  if (s==NULL || chrs==NULL || *chrs=='\0' || *s=='\0')
         return NULL;
  unsigned int l=strlen(s);
  unsigned int r=strcspn(s, chrs);
  if (r==l) return NULL;
  return ((char*)s+r);
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x36e7
xorl %eax, %eax
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
cmpb $0x0, (%rsi)
je 0x3725
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x3725
movq %rbx, %rdi
callq 0x2140
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2060
movq %rax, %rcx
movl %ecx, %edx
addq %rbx, %rdx
xorl %eax, %eax
cmpl %r15d, %ecx
cmovneq %rdx, %rax
jmp 0x3727
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/gpertea[P]gclib/GBase.cpp
// Function: upCase(char const*)
char* upCase(const char* str) {
 if (str==NULL) return NULL;
 int len=strlen(str);
 char* upstr=NULL;
 GMALLOC(upstr, len+1);
 upstr[len]='\0';
 for (int i=0;i<len;i++) upstr[i]=toupper(str[i]);
 return upstr;
 }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x379c
movq %rdi, %rbx
callq 0x2140
movq %rax, %r12
shlq $0x20, %r12
movabsq $0x100000000, %rdi      # imm = 0x100000000
addq %r12, %rdi
je 0x37ae
movq %rax, %r14
sarq $0x20, %rdi
callq 0x2330
testq %rax, %rax
je 0x37ae
movq %rax, %r15
sarq $0x20, %r12
movb $0x0, (%rax,%r12)
testl %r14d, %r14d
jle 0x379f
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %r12d, %r12d
movsbl (%rbx,%r12), %edi
callq 0x2430
movb %al, (%r15,%r12)
incq %r12
cmpq %r12, %r14
jne 0x3784
jmp 0x379f
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xa86b(%rip), %rdi      # 0xe020
xorl %eax, %eax
callq 0x286c
// File: /workspace/github_cpp_makefile_star2_O3/gpertea[P]gclib/GBase.cpp
// Function: loCase(char const*)
char* loCase(const char* str) {
 if (str==NULL) return NULL;
 int len=strlen(str);
 char* lostr=NULL;
 GMALLOC(lostr, len+1);
 lostr[len]='\0';
 for (int i=0;i<len;i++) lostr[i]=tolower(str[i]);
 return lostr;
 }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x382b
movq %rdi, %rbx
callq 0x2140
movq %rax, %r12
shlq $0x20, %r12
movabsq $0x100000000, %rdi      # imm = 0x100000000
addq %r12, %rdi
je 0x383d
movq %rax, %r14
sarq $0x20, %rdi
callq 0x2330
testq %rax, %rax
je 0x383d
movq %rax, %r15
sarq $0x20, %r12
movb $0x0, (%rax,%r12)
testl %r14d, %r14d
jle 0x382e
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %r12d, %r12d
movsbl (%rbx,%r12), %edi
callq 0x2380
movb %al, (%r15,%r12)
incq %r12
cmpq %r12, %r14
jne 0x3813
jmp 0x382e
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xa7dc(%rip), %rdi      # 0xe020
xorl %eax, %eax
callq 0x286c
// File: /workspace/github_cpp_makefile_star2_O3/gpertea[P]gclib/GBase.cpp
// Function: rstrfind(char const*, char const*)
char* rstrfind(const char* str, const char* substr) {
/* like rindex() for a string */
 int l,i;
 if (str==NULL || *str=='\0') return NULL;
 if (substr==NULL || *substr=='\0') return NULL;
 l=strlen(substr);
 char* p=(char*)str+strlen(str)-l;
   //rightmost position that could match

 while (p>=str) {
    for (i=0; i<l && *(p+i) == *(substr+i); i++) ;
    if (i==l) return p; //found!
    p--;
    }
 return NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x3902
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
xorl %eax, %eax
testq %rsi, %rsi
je 0x3942
movq %rdi, %r14
cmpb $0x0, (%rdi)
je 0x3942
cmpb $0x0, (%rbx)
je 0x38fe
movq %rbx, %rdi
callq 0x2140
movq %rax, %r15
movq %r14, %rdi
callq 0x2140
movq %rax, %rcx
addq %r14, %rcx
movslq %r15d, %rax
subq %rax, %rcx
cmpq %r14, %rcx
jae 0x3905
xorl %eax, %eax
jmp 0x3942
xorl %eax, %eax
retq
movl %r15d, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %eax, %eax
movl $0x0, %esi
testl %r15d, %r15d
jle 0x3930
xorl %esi, %esi
movb (%rcx,%rsi), %dil
cmpb (%rbx,%rsi), %dil
jne 0x3930
incq %rsi
cmpq %rsi, %rdx
jne 0x391c
jmp 0x393f
cmpl %r15d, %esi
je 0x393f
decq %rcx
cmpq %r14, %rcx
jae 0x3910
jmp 0x3942
movq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/gpertea[P]gclib/GBase.cpp
// Function: strifind(char const*, char const*)
char* strifind(const char* str,  const char* substr) {
 // case insensitive version of strstr -- finding a string within another
  int l,i;
  if (str==NULL || *str==0) return NULL;
  if (substr==NULL || *substr==0) return NULL;
  l=strlen(substr);
  char* smax=(char*)str+strlen(str)-l;
  //rightmost position that could match
  char* p=(char*)str;
  while (p<=smax) {
     for (i=0; i<l && tolower(*(p+i))==tolower(*(substr+i)); i++) ;
     if (i==l) return p;
     p++;
     }
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x3995
movq %rsi, %r14
xorl %r15d, %r15d
testq %rsi, %rsi
je 0x3998
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x3998
cmpb $0x0, (%r14)
je 0x3995
movq %r14, %rdi
callq 0x2140
movq %rax, %rbp
movq %rbx, %rdi
callq 0x2140
addq %rbx, %rax
movslq %ebp, %rcx
subq %rcx, %rax
cmpq %rbx, %rax
jae 0x39aa
xorl %r15d, %r15d
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %r12d
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r15d, %r15d
movq %rbp, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movl $0x0, %r13d
testl %ebp, %ebp
jle 0x39fc
xorl %r13d, %r13d
movsbl (%rbx,%r13), %edi
callq 0x2380
movl %eax, %ebp
movsbl (%r14,%r13), %edi
callq 0x2380
cmpl %eax, %ebp
jne 0x39f2
incq %r13
cmpq %r13, %r12
jne 0x39ce
jmp 0x3a0b
movq 0x10(%rsp), %rbp
movq 0x8(%rsp), %rax
cmpl %ebp, %r13d
je 0x3a0b
incq %rbx
cmpq %rax, %rbx
jbe 0x39c1
jmp 0x3998
movq %rbx, %r15
jmp 0x3998
// File: /workspace/github_cpp_makefile_star2_O3/gpertea[P]gclib/GBase.cpp
// Function: endsWith(char const*, char const*)
bool endsWith(const char* s, const char* suffix) {
 if (suffix==NULL || s==NULL) return false;
 if (suffix[0]==0) return true; //special case: empty suffix
 int j=strlen(suffix)-1;
 int i=strlen(s)-1;
 if (i<j) return false;
 while (j>=0 && s[i]==suffix[j]) { i--; j--; }
 return (j==-1);
}

// Assembly:
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
je 0x3ab5
xorl %eax, %eax
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x0, (%rsi)
je 0x3aea
movq %rdi, %r14
movq %rbx, %rdi
callq 0x2140
movq %rax, %r15
leal -0x1(%rax), %r12d
movq %r14, %rdi
callq 0x2140
decl %eax
cmpl %r12d, %eax
jge 0x3aee
xorl %eax, %eax
jmp 0x3b1d
movb $0x1, %al
jmp 0x3b1d
testl %r12d, %r12d
js 0x3b16
cltq
addq %rax, %r14
leal -0x1(%r15), %r12d
movb (%r14), %al
cmpb (%rbx,%r12), %al
jne 0x3b16
decq %r14
decl %r15d
testl %r15d, %r15d
jg 0x3af8
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
cmpl $-0x1, %r12d
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/gpertea[P]gclib/GBase.cpp
// Function: endsiWith(char const*, char const*)
bool endsiWith(const char* s, const char* suffix) {
 if (suffix==NULL || s==NULL) return false;
 if (suffix[0]==0) return true; //special case: empty suffix
 int j=strlen(suffix)-1;
 int i=strlen(s)-1;
 if (i<j) return false;
 while (j>=0 && tolower(s[i])==tolower(suffix[j])) { i--; j--; }
 return (j==-1);
}

// Assembly:
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
je 0x3b3c
xorl %eax, %eax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x0, (%rsi)
je 0x3b6f
movq %rdi, %r14
movq %rbx, %rdi
callq 0x2140
movq %rax, %r15
decl %r15d
movq %r14, %rdi
callq 0x2140
decl %eax
cmpl %r15d, %eax
jge 0x3b73
xorl %eax, %eax
jmp 0x3bb5
movb $0x1, %al
jmp 0x3bb5
testl %r15d, %r15d
js 0x3bae
cltq
movl %r15d, %r15d
addq %rax, %r14
movsbl (%r14), %edi
callq 0x2380
movl %eax, %ebp
movsbl (%rbx,%r15), %edi
callq 0x2380
cmpl %eax, %ebp
jne 0x3bae
leaq -0x1(%r15), %rax
decq %r14
testq %r15, %r15
movq %rax, %r15
jg 0x3b80
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpl $-0x1, %r15d
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/gpertea[P]gclib/GBase.cpp
// Function: trimSuffix(char*, char const*)
bool trimSuffix(char* s, const char* suffix) {
	if (suffix==NULL || s==NULL) return false;
	if (suffix[0]==0) return true; //special case: empty suffix
	int j=strlen(suffix)-1;
	int i=strlen(s)-1;
	if (i<j) return false;
	while (j>=0 && s[i]==suffix[j]) { i--; j--; }
	if (j==-1) { //suffix found
		s[i+1]='\0'; //cut here
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x3c01
movq %rsi, %r15
movb $0x1, %bl
cmpb $0x0, (%rsi)
je 0x3c03
movq %rdi, %r14
movq %r15, %rdi
callq 0x2140
movq %rax, %r12
leal -0x1(%rax), %ebp
movq %r14, %rdi
callq 0x2140
decl %eax
cmpl %ebp, %eax
jge 0x3c0e
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
testl %ebp, %ebp
js 0x3c32
movslq %eax, %rcx
addq %r14, %rcx
movl %r12d, %edx
decl %edx
movb (%rcx), %sil
cmpb (%r15,%rdx), %sil
jne 0x3c01
decq %rcx
testl %edx, %edx
jg 0x3c1b
subl %r12d, %eax
jmp 0x3c37
testl %r12d, %r12d
jne 0x3c01
cltq
movb $0x0, 0x1(%r14,%rax)
jmp 0x3c03
// File: /workspace/github_cpp_makefile_star2_O3/gpertea[P]gclib/GBase.cpp
// Function: trimiSuffix(char*, char const*)
bool trimiSuffix(char* s, const char* suffix) {
	if (suffix==NULL || s==NULL) return false;
	if (suffix[0]==0) return true; //special case: empty suffix
	int j=strlen(suffix)-1;
	int i=strlen(s)-1;
	if (i<j) return false;
	while (j>=0 && tolower(s[i])==tolower(suffix[j])) { i--; j--; }
	if (j==-1) { //suffix found
		s[i+1]='\0'; //cut here
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x3c8b
movq %rsi, %r15
movb $0x1, %r13b
cmpb $0x0, (%rsi)
je 0x3c8e
movq %rdi, %r14
movq %r15, %rdi
callq 0x2140
movq %rax, %rbp
leal -0x1(%rax), %ebx
movq %r14, %rdi
callq 0x2140
movq %rax, %r12
decl %r12d
cmpl %ebx, %r12d
jge 0x3ca0
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %ebx, %ebx
js 0x3cda
movslq %r12d, %r13
movl %ebx, %ebx
subl %ebp, %r12d
incq %rbx
addq %r14, %r13
movsbl (%r13), %edi
callq 0x2380
movl %eax, %ebp
movsbl -0x1(%r15,%rbx), %edi
callq 0x2380
cmpl %eax, %ebp
jne 0x3c8b
decq %r13
decq %rbx
jg 0x3cb2
movb $0x1, %r13b
jmp 0x3cde
testl %ebp, %ebp
jne 0x3c8b
movslq %r12d, %rax
movb $0x0, 0x1(%r14,%rax)
jmp 0x3c8e
// File: /workspace/github_cpp_makefile_star2_O3/gpertea[P]gclib/GBase.cpp
// Function: reverseChars(char*, int)
char* reverseChars(char* str, int slen) {
  if (slen==0) slen=strlen(str);
  int l=0;
  int r=slen-1;
  char c;
  while (l<r) {
     c=str[l];str[l]=str[r];
     str[r]=c;
     l++;r--;
     }
  return str;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jne 0x3cfc
movq %rbx, %rdi
callq 0x2140
movq %rax, %rsi
cmpl $0x2, %esi
jl 0x3d28
movl %esi, %eax
addq $-0x2, %rax
xorl %ecx, %ecx
movb (%rbx,%rcx), %dl
movb 0x1(%rbx,%rax), %sil
movb %sil, (%rbx,%rcx)
movb %dl, 0x1(%rbx,%rax)
incq %rcx
leaq -0x1(%rax), %rdx
cmpq %rax, %rcx
movq %rdx, %rax
jl 0x3d09
movq %rbx, %rax
popq %rbx
retq