LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc1d0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc240
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x17620
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc240
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x17670
testb $0x1, %al
jne 0x175e3
jmp 0x175e5
jmp 0x1760b
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x17720
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x176b0
movq %rax, -0x48(%rbp)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: bauerj4[P]Riemann1D/src/Context.cpp
// Function: delimitString(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int delimitString(vector<string> &tokens, string line, string delimiter)
{
  int pos = 0;
  int newpos = 0;
  string token;
  while(1)
    {
      newpos = line.find(' ');
      token = line.substr(0,newpos);
      line.erase(0,newpos+1);

      tokens.push_back(token);
      if (newpos == string::npos)
        {
          break;
        }
    }
}

// Assembly:
subq $0x88, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movl $0x0, 0x6c(%rsp)
movl $0x0, 0x68(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x2330
jmp 0x268a
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, 0x8(%rsp)
movl $0x20, %esi
callq 0x2320
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movl %eax, 0x68(%rsp)
movslq 0x68(%rsp), %rcx
leaq 0x28(%rsp), %rdi
callq 0x2260
jmp 0x26c1
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movq %rsi, (%rsp)
callq 0x22e0
movq (%rsp), %rdi
callq 0x2140
movq 0x10(%rsp), %rdi
movl 0x68(%rsp), %eax
incl %eax
movslq %eax, %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x2080
jmp 0x26f6
movq 0x80(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x3100
jmp 0x270a
movslq 0x68(%rsp), %rax
cmpq $-0x1, %rax
jne 0x2731
jmp 0x2736
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x2140
jmp 0x2738
jmp 0x2688
ud2
movq 0x20(%rsp), %rdi
callq 0x23d0
nopw %cs:(%rax,%rax)
// File: 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 %rax
movq %rdi, (%rsp)
leaq 0x15105(%rip), %rdi     # 0x18081
movb $0x0, %al
callq 0x2040
movq (%rsp), %rax
movl (%rax), %esi
leaq 0x15103(%rip), %rdi     # 0x18093
movb $0x0, %al
callq 0x2040
movq (%rsp), %rax
movsd 0x8(%rax), %xmm0
leaq 0x15102(%rip), %rdi     # 0x180a9
movb $0x1, %al
callq 0x2040
movq (%rsp), %rax
movsd 0x10(%rax), %xmm0
leaq 0x150f9(%rip), %rdi     # 0x180b7
movb $0x1, %al
callq 0x2040
movq (%rsp), %rax
movsd 0x48(%rax), %xmm0
leaq 0x150f0(%rip), %rdi     # 0x180c5
movb $0x1, %al
callq 0x2040
movq (%rsp), %rax
movsd 0x18(%rax), %xmm0
leaq 0x150fa(%rip), %rdi     # 0x180e6
movb $0x1, %al
callq 0x2040
movq (%rsp), %rax
movsd 0x38(%rax), %xmm0
leaq 0x150f4(%rip), %rdi     # 0x180f7
movb $0x1, %al
callq 0x2040
movq (%rsp), %rax
movsd 0x28(%rax), %xmm0
leaq 0x150ec(%rip), %rdi     # 0x18106
movb $0x1, %al
callq 0x2040
movq (%rsp), %rax
movsd 0x20(%rax), %xmm0
leaq 0x150e4(%rip), %rdi     # 0x18115
movb $0x1, %al
callq 0x2040
movq (%rsp), %rax
movsd 0x40(%rax), %xmm0
leaq 0x150de(%rip), %rdi     # 0x18126
movb $0x1, %al
callq 0x2040
movq (%rsp), %rax
movsd 0x30(%rax), %xmm0
leaq 0x150d6(%rip), %rdi     # 0x18135
movb $0x1, %al
callq 0x2040
movq (%rsp), %rax
movsd 0x58(%rax), %xmm0
leaq 0x150ce(%rip), %rdi     # 0x18144
movb $0x1, %al
callq 0x2040
movq (%rsp), %rax
movsd 0x50(%rax), %xmm0
leaq 0x150ce(%rip), %rdi     # 0x1815b
movb $0x1, %al
callq 0x2040
movq 0x19f3d(%rip), %rdi     # 0x1cfd8
leaq 0x150cf(%rip), %rsi     # 0x18171
callq 0x2220
movq %rax, %rdi
movq (%rsp), %rsi
addq $0x80, %rsi
callq 0x2200
movq %rax, %rdi
movl $0xa, %esi
callq 0x22c0
movq 0x19f0a(%rip), %rdi     # 0x1cfd8
leaq 0x150ad(%rip), %rsi     # 0x18182
callq 0x2220
movq %rax, %rdi
movq (%rsp), %rsi
addq $0x60, %rsi
callq 0x2200
movq %rax, %rdi
movl $0xa, %esi
callq 0x22c0
ud2
nopl (%rax)
// File: 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:
movsd %xmm0, -0x10(%rsp)
movsd %xmm1, -0x18(%rsp)
xorps %xmm0, %xmm0
ucomisd -0x10(%rsp), %xmm0
jb 0x50da
movsd 0x131e1(%rip), %xmm0    # 0x182b0
movsd %xmm0, -0x8(%rsp)
jmp 0x5223
movsd -0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x514b
movsd 0x131cf(%rip), %xmm0    # 0x182c0
ucomisd -0x10(%rsp), %xmm0
jb 0x514b
movsd 0x131af(%rip), %xmm1    # 0x182b0
subsd -0x18(%rsp), %xmm1
movsd 0x131a9(%rip), %xmm0    # 0x182b8
mulsd %xmm1, %xmm0
movsd -0x10(%rsp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm1, %xmm0
movsd 0x13174(%rip), %xmm1    # 0x182b0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rsp)
jmp 0x5223
movsd -0x10(%rsp), %xmm0
movsd 0x13167(%rip), %xmm1    # 0x182c0
ucomisd %xmm1, %xmm0
jbe 0x5180
movsd 0x13149(%rip), %xmm0    # 0x182b0
ucomisd -0x10(%rsp), %xmm0
jb 0x5180
movsd -0x18(%rsp), %xmm0
movsd %xmm0, -0x8(%rsp)
jmp 0x5223
movsd -0x10(%rsp), %xmm0
movsd 0x13122(%rip), %xmm1    # 0x182b0
ucomisd %xmm1, %xmm0
jbe 0x51e7
movsd 0x1311c(%rip), %xmm0    # 0x182b8
ucomisd -0x10(%rsp), %xmm0
jb 0x51e7
movsd 0x13104(%rip), %xmm0    # 0x182b0
subsd -0x18(%rsp), %xmm0
movsd -0x10(%rsp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm1, %xmm0
movsd 0x130d5(%rip), %xmm1    # 0x182b0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rsp)
jmp 0x5223
movsd -0x10(%rsp), %xmm0
movsd 0x130c3(%rip), %xmm1    # 0x182b8
ucomisd %xmm1, %xmm0
jbe 0x5219
movsd -0x18(%rsp), %xmm0
addsd %xmm0, %xmm0
movsd 0x130bb(%rip), %xmm1    # 0x182c8
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rsp)
jmp 0x5223
jmp 0x521b
jmp 0x521d
jmp 0x521f
jmp 0x5221
ud2
movsd -0x8(%rsp), %xmm0
retq
nopw (%rax,%rax)
// File: 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:
movsd %xmm0, -0x10(%rsp)
movsd %xmm1, -0x18(%rsp)
xorps %xmm0, %xmm0
ucomisd -0x10(%rsp), %xmm0
jb 0x525a
movsd 0x13061(%rip), %xmm0    # 0x182b0
movsd %xmm0, -0x8(%rsp)
jmp 0x52e4
movsd -0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x52bc
movsd 0x1303f(%rip), %xmm0    # 0x182b0
ucomisd -0x10(%rsp), %xmm0
jb 0x52bc
movsd 0x1302f(%rip), %xmm0    # 0x182b0
subsd -0x18(%rsp), %xmm0
movsd -0x10(%rsp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm1, %xmm0
movsd 0x13000(%rip), %xmm1    # 0x182b0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rsp)
jmp 0x52e4
movsd -0x10(%rsp), %xmm0
movsd 0x12fe6(%rip), %xmm1    # 0x182b0
ucomisd %xmm1, %xmm0
jbe 0x52de
movsd -0x18(%rsp), %xmm0
movsd %xmm0, -0x8(%rsp)
jmp 0x52e4
jmp 0x52e0
jmp 0x52e2
ud2
movsd -0x8(%rsp), %xmm0
retq
nopl (%rax,%rax)
// File: 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:
subq $0xa8, %rsp
movq %rsi, 0x28(%rsp)
movq %rdi, %rax
movq 0x28(%rsp), %rdi
movq %rax, 0x30(%rsp)
movq %rax, %rcx
movq %rcx, 0x38(%rsp)
movq %rax, 0xa0(%rsp)
movq %rdi, 0x98(%rsp)
movsd 0x12d47(%rip), %xmm0    # 0x182d0
movsd %xmm0, 0x90(%rsp)
callq 0x12850
cmpq $0x3, %rax
je 0x55bf
leaq 0x12d60(%rip), %rdi     # 0x18304
movb $0x0, %al
callq 0x2040
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x12870
jmp 0x5771
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4ff0
movq 0x28(%rsp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, 0x88(%rsp)
movl $0x1, %esi
callq 0x4ff0
movq 0x28(%rsp), %rdi
movsd (%rax), %xmm0
movsd 0x88(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x80(%rsp)
movl $0x2, %esi
callq 0x4ff0
movsd (%rax), %xmm0
movsd 0x88(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x78(%rsp)
movsd 0x78(%rsp), %xmm0
movsd 0x80(%rsp), %xmm2
movsd 0x12c98(%rip), %xmm3    # 0x182d8
movaps %xmm2, %xmm1
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x70(%rsp)
movsd 0x70(%rsp), %xmm0
movsd 0x88(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x90(%rsp), %xmm1
movsd 0x12c4f(%rip), %xmm2    # 0x182c8
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x68(%rsp)
movb $0x0, 0x67(%rsp)
movq $0x0, 0x58(%rsp)
leaq 0x57(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x128a0
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rcx
movl $0x3, %esi
leaq 0x58(%rsp), %rdx
callq 0x128b0
jmp 0x56bf
leaq 0x57(%rsp), %rdi
callq 0x12930
movq 0x30(%rsp), %rdi
movsd 0x88(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x4ff0
movsd 0x8(%rsp), %xmm0
movq 0x30(%rsp), %rdi
movsd %xmm0, (%rax)
movsd 0x80(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movl $0x1, %esi
callq 0x4ff0
movsd 0x10(%rsp), %xmm0
movq 0x30(%rsp), %rdi
movsd %xmm0, (%rax)
movsd 0x68(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0x2, %esi
callq 0x4ff0
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rax)
movb $0x1, 0x67(%rsp)
testb $0x1, 0x67(%rsp)
jne 0x576f
jmp 0x5765
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x57(%rsp), %rdi
callq 0x12930
jmp 0x577e
movq 0x30(%rsp), %rdi
callq 0x12940
jmp 0x5771
movq 0x38(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x23d0
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x160e5
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0xc(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0xc(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm3
leaq 0x2505(%rip), %rdi      # 0x185d6
movb $0x4, %al
callq 0x2040
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x16071
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x208, %rsp            # imm = 0x208
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
movl %edx, 0x1f4(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x2180
leaq 0x78(%rsp), %rdi
movq 0x1f8(%rsp), %rsi
subq $-0x80, %rsi
callq 0x2200
movq %rax, 0x18(%rsp)
jmp 0x16135
movq 0x18(%rsp), %rdi
movl 0x1f4(%rsp), %esi
callq 0x23b0
jmp 0x16148
leaq 0x30(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x2210
jmp 0x16159
leaq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x20e0
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x2140
movq 0x8(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x246f(%rip), %rsi      # 0x185fa
callq 0x22d0
movq %rax, 0x10(%rsp)
jmp 0x16197
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq 0x200(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x16252
movq 0x28(%rsp), %rdi
movq 0x200(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x24(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x200(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x24(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq 0x200(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x24(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq 0x200(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x24(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm3
leaq 0x23db(%rip), %rsi      # 0x185fc
movb $0x4, %al
callq 0x2340
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x161a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x21a0
jmp 0x16272
movq 0x28(%rsp), %rdi
callq 0x2230
jmp 0x1625e
leaq 0x68(%rsp), %rdi
callq 0x21a0
xorl %eax, %eax
addq $0x208, %rsp            # imm = 0x208
retq
movq 0x60(%rsp), %rdi
callq 0x23d0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq -0x1020(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %r8
leaq 0x119f5(%rip), %rsi     # 0x14004
movb $0x0, %al
callq 0x2080
movq 0x179bb(%rip), %rax     # 0x19fd8
movq (%rax), %rdi
leaq -0x1020(%rbp), %rdx
leaq 0x119f2(%rip), %rsi     # 0x14020
movb $0x0, %al
callq 0x2370
movl $0x1, %edi
callq 0x22f0
nop
// File: gpertea[P]gclib/GBase.cpp
// Function: GError(char const*, ...)
void GError(const char* format,...){
  #ifdef _WIN32
    char msg[4096];
    va_list arguments;
    va_start(arguments,format);
    _vsnprintf(msg, 4095, format, arguments);
    vfprintf(stderr, format, arguments); // if a console is available
    msg[4095]=0;
    va_end(arguments);
    OutputDebugString(msg);
    MessageBox(NULL,msg,NULL,MB_OK|MB_ICONEXCLAMATION|MB_APPLMODAL);
  #else
    va_list arguments;
    va_start(arguments,format);
    vfprintf(stderr,format,arguments);
    va_end(arguments);
    #ifdef DEBUG
     // comment this if you do NOT want a core dump
     //abort();
    #endif
  #endif
    exit(1);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x2675
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x17911(%rip), %rax     # 0x19fd8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x2340
leaq -0x20(%rbp), %rax
movl $0x1, %edi
callq 0x22f0
nopw %cs:(%rax,%rax)
// File: gpertea[P]gclib/GBase.cpp
// Function: GMessage(char const*, ...)
void GMessage(const char* format,...){
  #ifdef _WIN32
    char msg[4096];
    va_list arguments;
    va_start(arguments,format);
    vfprintf(stderr, format , arguments); // if a console is available
    _vsnprintf(msg, 4095, format, arguments);
    msg[4095]=0;
    va_end(arguments);
    fflush(stderr);
    //OutputDebugString(msg);
  #else
    va_list arguments;
    va_start(arguments,format);
    vfprintf(stderr,format,arguments);
    va_end(arguments);
    fflush(stderr);
  #endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x2725
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0xd0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq 0x17864(%rip), %rax     # 0x19fd8
movq %rax, -0xd8(%rbp)
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x2340
movq -0xd8(%rbp), %rax
movq (%rax), %rdi
callq 0x22c0
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x27d0
movq $0x0, -0x8(%rbp)
jmp 0x281f
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2140
movq %rax, %rsi
addq $0x1, %rsi
movslq -0x14(%rbp), %rax
addq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x58f0
testb $0x1, %al
jne 0x280a
leaq 0x11820(%rip), %rdi     # 0x14023
movb $0x0, %al
callq 0x2640
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2240
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: gpertea[P]gclib/GBase.cpp
// Function: newEmptyStr()
char* newEmptyStr() {
  char* zs=NULL;
  GMALLOC(zs,1);
  zs[0]=0;
  return zs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, -0x8(%rbp)
leaq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x58f0
testb $0x1, %al
jne 0x2860
leaq 0x117ca(%rip), %rdi     # 0x14023
movb $0x0, %al
callq 0x2640
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x289e
cmpq $0x0, -0x18(%rbp)
jne 0x28ab
movq $0x0, -0x8(%rbp)
jmp 0x2936
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x28c9
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x28d4
callq 0x2830
movq %rax, -0x8(%rbp)
jmp 0x2936
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
subq %rax, %rsi
addq $0x2, %rsi
leaq -0x20(%rbp), %rdi
callq 0x58f0
testb $0x1, %al
jne 0x28fe
leaq 0x1172c(%rip), %rdi     # 0x14023
movb $0x0, %al
callq 0x2640
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
subq %rax, %rdx
addq $0x1, %rdx
callq 0x2190
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rdx
subq %rdx, %rcx
movb $0x0, 0x1(%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2961
cmpq $0x0, -0x18(%rbp)
jne 0x297b
movq -0x10(%rbp), %rdx
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq $0x0, %rdx
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x29a7
cmpl $0x0, -0x1c(%rbp)
jge 0x2993
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2350
movl %eax, -0x4(%rbp)
jmp 0x29a7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x2180
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: gpertea[P]gclib/GBase.cpp
// Function: Gmktempdir(char*)
void Gmktempdir(char* templ) {
#ifdef _WIN32
  int blen=strlen(templ);
  char* pt=templ+blen-1;
  //on Windows this needs a plain file name template, without directory prefix
  blen=1;
  while (pt!=templ) {
    if (*pt=='/' || *pt=='\\') { pt++; break;}
    --pt; blen++;
  }
  if (_mktemp_s(pt, blen)!=0)
     GError("Error creating template file name %s!\n", pt);
  Gmkdir(templ, true);
#else
  char* cdir=mkdtemp(templ);
  if (cdir==NULL)
	  GError("Error creating temp dir %s!(%s)\n", templ, strerror(errno));
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2450
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2a49
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x2040
movl (%rax), %edi
callq 0x20e0
movq -0x18(%rbp), %rsi
movq %rax, %rdx
leaq 0x115fb(%rip), %rdi     # 0x1403d
movb $0x0, %al
callq 0x2640
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2a96
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2a94
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x2a86
movq -0x10(%rbp), %rax
movb $0x2f, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2a67
jmp 0x2a96
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: gpertea[P]gclib/GBase.cpp
// Function: fileExists(char const*)
int fileExists(const char* fname) {
  struct stat stFileInfo;
  int r=0;
  // Attempt to get the path attributes
  int fs = stat(fname,&stFileInfo);
  if (fs == 0) {
      r=3;
      // We were able to get the file attributes
      // so the path exists
      if (S_ISREG (stFileInfo.st_mode)) {
         r=2;
         }
      if (S_ISDIR (stFileInfo.st_mode)) {
          r=1;
          }
      }
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x9c(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x2220
movl %eax, -0xa0(%rbp)
cmpl $0x0, -0xa0(%rbp)
jne 0x2ec6
movl $0x3, -0x9c(%rbp)
movl -0x80(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x2eab
movl $0x2, -0x9c(%rbp)
movl -0x80(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x2ec4
movl $0x1, -0x9c(%rbp)
jmp 0x2ec6
movl -0x9c(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2f45
movq -0x8(%rbp), %rdi
leaq 0x11166(%rip), %rsi     # 0x140a0
callq 0x22d0
movq %rax, -0x18(%rbp)
jmp 0x2f56
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x22d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2f86
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x2040
movl (%rax), %edi
callq 0x20e0
movq -0x20(%rbp), %rsi
movq %rax, %rdx
leaq 0x11124(%rip), %rdi     # 0x140a3
movb $0x0, %al
callq 0x26f0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movb $0x1, -0x21(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5b60
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
je 0x3514
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
setl %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x3520
jmp 0x35d4
testb $0x1, -0x21(%rbp)
je 0x3543
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0x28(%rbp), %rax
addq %rax, %rsi
callq 0x5b80
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb (%rax,%rcx), %al
movq -0x18(%rbp), %rsi
movsbl %al, %edi
callq 0x35e0
testb $0x1, %al
jne 0x3564
jmp 0x35c6
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x2a(%rbp)
je 0x35a9
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb (%rax,%rcx), %al
movq -0x18(%rbp), %rsi
movsbl %al, %edi
callq 0x35e0
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0x35b2
jmp 0x35bd
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3579
movb $0x1, -0x21(%rbp)
jmp 0x34f2
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x34f2
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: gpertea[P]gclib/GBase.cpp
// Function: chrInStr(char, char const*)
bool chrInStr(char c, const char* str) {
 if (str==NULL || *str=='\0') return false;
 for (const char* p=str; (*p)!='\0'; p++) {
   if ((*p)==c) return true;
   }
 return false;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3601
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x3607
movb $0x0, -0x1(%rbp)
jmp 0x3644
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x3640
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x2(%rbp), %ecx
cmpl %ecx, %eax
jne 0x3630
movb $0x1, -0x1(%rbp)
jmp 0x3644
jmp 0x3632
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x360f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movb $0x1, -0x1d(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5b60
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x25(%rbp)
je 0x36a5
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
setl %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x36b1
jmp 0x375a
testb $0x1, -0x1d(%rbp)
je 0x36d4
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0x24(%rbp), %rax
addq %rax, %rsi
callq 0x5b80
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movb $0x0, -0x1d(%rbp)
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x374c
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x26(%rbp)
je 0x372f
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x26(%rbp)
movb -0x26(%rbp), %al
testb $0x1, %al
jne 0x3738
jmp 0x3743
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3701
movb $0x1, -0x1d(%rbp)
jmp 0x3683
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3683
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movb $0x1, -0x19(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5b60
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
je 0x37c0
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
setl %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x37cc
jmp 0x389c
testb $0x1, -0x19(%rbp)
je 0x37ef
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0x20(%rbp), %rax
addq %rax, %rsi
callq 0x5b80
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x3815
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
jne 0x388e
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x22(%rbp)
je 0x3871
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, -0x23(%rbp)
je 0x386b
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0x23(%rbp)
movb -0x23(%rbp), %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
testb $0x1, %al
jne 0x387a
jmp 0x3885
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x382a
movb $0x1, -0x19(%rbp)
jmp 0x379e
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x379e
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x38d2
cmpq $0x0, -0x18(%rbp)
jne 0x38df
movq $0x0, -0x8(%rbp)
jmp 0x39bd
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x38f7
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x3905
callq 0x2830
movq %rax, -0x8(%rbp)
jmp 0x39bd
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x391c
movq $0x0, -0x8(%rbp)
jmp 0x39bd
cmpq $0x0, -0x20(%rbp)
jne 0x3945
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, 0x1(%rax)
je 0x3943
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x392b
jmp 0x3945
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x395a
callq 0x2830
movq %rax, -0x8(%rbp)
jmp 0x39bd
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
addq $0x1, %rax
movl %eax, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movslq -0x24(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x58f0
testb $0x1, %al
jne 0x3993
leaq 0x10697(%rip), %rdi     # 0x14023
movb $0x0, %al
callq 0x2640
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x24(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rdx
callq 0x21f0
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x39f3
movq -0x10(%rbp), %rdi
callq 0x5a90
cmpq $0x0, -0x18(%rbp)
jne 0x3a04
movq $0x0, -0x8(%rbp)
jmp 0x3a52
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2140
movq -0x20(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0x58f0
testb $0x1, %al
jne 0x3a37
leaq 0x105f3(%rip), %rdi     # 0x14023
movb $0x0, %al
callq 0x2640
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2240
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl -0x14(%rbp), %eax
subl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rax
movsbl (%rax), %esi
movl -0x34(%rbp), %eax
movl %eax, %edx
callq 0x22b0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x3b01
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x1, %rsi
movl -0x24(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
callq 0x2150
cmpl $0x0, %eax
jne 0x3ae3
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x3b09
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rax
subq %rax, %rcx
movl -0x34(%rbp), %eax
subq %rcx, %rax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x3a8a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3b43
movq $0x0, -0x8(%rbp)
jmp 0x3b9f
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2140
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jb 0x3b97
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x3b89
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3b9f
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3b66
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, 0x40(%rax)
je 0x3dec
movq -0x30(%rbp), %rdi
movb $0x0, 0x40(%rdi)
addq $0x8, %rdi
callq 0x5cc0
movq %rax, -0x8(%rbp)
jmp 0x3f44
movq -0x30(%rbp), %rdi
movl $0x0, -0x24(%rbp)
movl $0x0, 0x28(%rdi)
addq $0x8, %rdi
callq 0x5d40
movq -0x18(%rbp), %rdi
callq 0x20c0
movl %eax, -0x24(%rbp)
cmpl $-0x1, %eax
je 0x3ed3
cmpl $0xa, -0x24(%rbp)
je 0x3e2c
cmpl $0xd, -0x24(%rbp)
jne 0x3ead
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x5ca0
movq -0x30(%rbp), %rdi
movl %eax, 0x28(%rdi)
addq $0x8, %rdi
xorl %esi, %esi
callq 0x5c30
cmpl $0xd, -0x24(%rbp)
jne 0x3e80
movq -0x18(%rbp), %rdi
callq 0x20c0
movl %eax, -0x24(%rbp)
cmpl $0xa, %eax
je 0x3e70
movl -0x24(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x2070
jmp 0x3e7e
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x3e80
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl 0x44(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x44(%rdi)
addq $0x8, %rdi
callq 0x5cc0
movq %rax, -0x8(%rbp)
jmp 0x3f44
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
addq $0x8, %rdi
movl -0x24(%rbp), %eax
movsbl %al, %esi
callq 0x5c30
jmp 0x3e07
cmpl $-0x1, -0x24(%rbp)
jne 0x3f0b
movq -0x30(%rbp), %rdi
movb $0x1, 0x2c(%rdi)
addq $0x8, %rdi
callq 0x5ca0
movq -0x30(%rbp), %rdi
movl %eax, 0x28(%rdi)
addq $0x8, %rdi
callq 0x5ca0
cmpl $0x0, %eax
jne 0x3f09
movq $0x0, -0x8(%rbp)
jmp 0x3f44
jmp 0x3f0b
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x5ca0
movq -0x30(%rbp), %rdi
movl %eax, 0x28(%rdi)
addq $0x8, %rdi
xorl %esi, %esi
callq 0x5c30
movq -0x30(%rbp), %rdi
movl 0x44(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x44(%rdi)
addq $0x8, %rdi
callq 0x5cc0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3f86
cmpq $0x0, -0x18(%rbp)
je 0x3f86
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x3f86
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x3f90
movq $0x0, -0x8(%rbp)
jmp 0x3fcc
movq -0x10(%rbp), %rdi
callq 0x2140
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2060
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x3fbe
movq $0x0, -0x8(%rbp)
jmp 0x3fcc
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4000
movq $0x0, -0x8(%rbp)
jmp 0x4084
movq -0x10(%rbp), %rdi
callq 0x2140
movl %eax, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x58f0
testb $0x1, %al
jne 0x4038
leaq 0xfff2(%rip), %rdi      # 0x14023
movb $0x0, %al
callq 0x2640
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x407c
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x2440
movb %al, %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x404b
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x40b0
movq $0x0, -0x8(%rbp)
jmp 0x4134
movq -0x10(%rbp), %rdi
callq 0x2140
movl %eax, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x58f0
testb $0x1, %al
jne 0x40e8
leaq 0xff42(%rip), %rdi      # 0x14023
movb $0x0, %al
callq 0x2640
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x412c
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x2380
movb %al, %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x40fb
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: gpertea[P]gclib/GBase.cpp
// Function: strlower(char*)
char* strlower(char * str) {//changes string in place
  if (str==NULL) return NULL;
  int i=0;
  while (str[i]!=0) { str[i]=tolower(str[i]); i++; }
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x415d
movq $0x0, -0x8(%rbp)
jmp 0x41a6
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x419e
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x2380
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4164
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: gpertea[P]gclib/GBase.cpp
// Function: strupper(char*)
char* strupper(char * str) {//changes string in place
  if (str==NULL) return NULL;
  int i=0;
  while (str[i]!=0) { str[i]=toupper(str[i]); i++; }
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x41cd
movq $0x0, -0x8(%rbp)
jmp 0x4216
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x420e
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x2440
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x41d4
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq