LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/tlestang[P]IW_gene/Walls.cpp
// Function: BottomWall::FreeSlipBC(VelSite**, VelSite**)
void BottomWall::FreeSlipBC(VelSite **sites, VelSite **_sites)
{
  int x,y;
  for (int i=0;i<nbNodes;i++)
    {
      x = nodes[i][0]; y = nodes[i][1];
      _sites[x][y].f[6] = _sites[x][y].f[7];
      _sites[x][y].f[2] = _sites[x][y].f[4];
      _sites[x][y].f[5] = _sites[x][y].f[8];
    }
}

// Assembly:
movslq 0x8(%rdi), %rax
testq %rax, %rax
jle 0x2d55
movq 0x10(%rdi), %rcx
xorl %esi, %esi
movq (%rcx,%rsi,8), %rdi
movslq (%rdi), %r8
movslq 0x4(%rdi), %rdi
movq (%rdx,%r8,8), %r8
movq %rdi, %r9
shlq $0x7, %r9
leaq (%r9,%rdi,8), %rdi
movsd 0x28(%r8,%rdi), %xmm0
movsd %xmm0, 0x18(%r8,%rdi)
movups 0x40(%r8,%rdi), %xmm0
shufps $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movups %xmm0, 0x30(%r8,%rdi)
incq %rsi
cmpq %rsi, %rax
jne 0x2d15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tlestang[P]IW_gene/Walls.cpp
// Function: BottomWall::TemperatureBC(VelSite**, ThermalSite**, double**, double***)
void BottomWall::TemperatureBC(VelSite **velSites, ThermalSite **thermalSites,
				   double **T, double ***u)
{
  int c[4][2] = {{1,0}, {0,1}, {-1,0}, {0, -1}};
  int x,y; 
  double Tcold = 0.0;
  double Tsup, rho, ub[2], usup[2];
  for (int i=0;i<nbNodes;i++)
    {
      double eu;
      x = nodes[i][0]; y = nodes[i][1];

      thermalSites[x][y+1].computeRhoAndU(Tsup);
      velSites[x][y+1].computeRhoAndU(rho, usup);
      velSites[x][y].computeRhoAndU(rho, ub);
      
      for (int k=0;k<4;k++)
	{
	  eu = c[k][0]*ub[0] + c[k][1]*ub[1];
	  thermalSites[x][y].f[k] = (Tsup/4.)*(1.+ 2.*eu) + thermalSites[x][y+1].f[k]
	    - thermalSites[x][y+1].fEq(k,Tsup,usup);
	}
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, 0x10(%rsp)
cmpl $0x0, 0x8(%rdi)
jle 0x2eb5
movq %rdx, %rbx
xorl %ecx, %ecx
leaq 0x33d1(%rip), %r14      # 0x6150
movq %rdi, 0x8(%rsp)
movq 0x10(%rdi), %rax
movq %rcx, 0x18(%rsp)
movq (%rax,%rcx,8), %rax
movslq (%rax), %r15
movslq 0x4(%rax), %rbp
movq (%rbx,%r15,8), %rax
leaq 0x1(%rbp), %rcx
movq %rcx, (%rsp)
imulq $0x70, %rbp, %r13
leaq (%rax,%r13), %rdi
addq $0x70, %rdi
movq (%rdi), %rax
leaq 0x28(%rsp), %rsi
callq *0x20(%rax)
movq 0x10(%rsp), %r12
movq (%r12,%r15,8), %rax
movq %rbp, %rcx
shlq $0x7, %rcx
leaq (%rcx,%rbp,8), %rbp
leaq (%rax,%rbp), %rdi
addq $0x88, %rdi
movq (%rdi), %rax
leaq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq *0x8(%rax)
movq (%r12,%r15,8), %rax
leaq (%rax,%rbp), %rdi
movq (%rax,%rbp), %rax
leaq 0x20(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq *0x8(%rax)
movq (%rbx,%r15,8), %rax
imulq $0x70, (%rsp), %rbp
xorl %r12d, %r12d
xorps %xmm2, %xmm2
cvtsi2sdl (%r14,%r12,8), %xmm2
xorps %xmm0, %xmm0
cvtsi2sdl 0x4(%r14,%r12,8), %xmm0
mulsd 0x38(%rsp), %xmm0
mulsd 0x30(%rsp), %xmm2
addsd %xmm0, %xmm2
movsd 0x28(%rsp), %xmm0
movapd %xmm0, %xmm1
mulsd 0x31e4(%rip), %xmm1     # 0x6028
addsd %xmm2, %xmm2
addsd 0x31c0(%rip), %xmm2     # 0x6010
mulsd %xmm1, %xmm2
leaq (%rax,%rbp), %rdi
leaq (%rax,%r13), %rcx
addsd 0x78(%rcx,%r12,8), %xmm2
movsd %xmm2, (%rsp)
movq (%rax,%rbp), %rax
movl %r12d, %esi
leaq 0x40(%rsp), %rdx
callq *(%rax)
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movq (%rbx,%r15,8), %rax
leaq (%rax,%r13), %rcx
movsd %xmm1, 0x8(%rcx,%r12,8)
incq %r12
cmpq $0x4, %r12
jne 0x2e0f
movq 0x18(%rsp), %rcx
incq %rcx
movq 0x8(%rsp), %rdi
movslq 0x8(%rdi), %rax
cmpq %rax, %rcx
jl 0x2d84
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tlestang[P]IW_gene/LatticeBoltzmann.cpp
// Function: LatticeBoltzmann::generateGeometry()
void LatticeBoltzmann::generateGeometry()
{
	double u[2] = {u0, 0};
	double a = N2/coef_force; double TT;
	
	for (int x=0; x<dims[0]; x++)
	{
		for (int y=0; y<dims[1]; y++)
		{
		  //u[0] = InitialCondition_X(x,y);
		  //u[1] = InitialCondition_Y(x,y);
		  
		  velSites[x][y].init(LatticeSite::Fluid, 1.0, u,
				      coef_force);
		  velSites_[x][y].init(LatticeSite::Fluid, 1.0, u,
				       coef_force);
		  
		  TT = a*y;
		  T[x][y]=TT;
		  thermalSites[x][y].init(LatticeSite::Fluid, TT, u,
					  coef_force);
		  thermalSites_[x][y].init(LatticeSite::Fluid, TT, u,
					   coef_force);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd 0x20(%rdi), %xmm0
movsd %xmm0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movl (%rdi), %ecx
testl %ecx, %ecx
jle 0x3c1c
movq %rdi, %rbx
movsd 0x28(%rdi), %xmm0
divsd 0x18(%rdi), %xmm0
movl 0x4(%rdi), %eax
xorl %r15d, %r15d
leaq 0x10(%rsp), %r14
movsd %xmm0, (%rsp)
testl %eax, %eax
jle 0x3c0d
xorl %r12d, %r12d
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x60(%rbx), %rax
movq (%rax,%r15,8), %rdi
movsd 0x18(%rbx), %xmm1
movq (%rdi,%r12), %rax
addq %r12, %rdi
movl $0x66, %esi
movsd 0x24b0(%rip), %xmm0     # 0x6010
movq %r14, %rdx
callq *0x18(%rax)
movq 0x68(%rbx), %rax
movq (%rax,%r15,8), %rdi
movsd 0x18(%rbx), %xmm1
movq (%rdi,%r12), %rax
addq %r12, %rdi
movl $0x66, %esi
movsd 0x2489(%rip), %xmm0     # 0x6010
movq %r14, %rdx
callq *0x18(%rax)
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
mulsd (%rsp), %xmm0
movq 0x50(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%rbp,8)
movsd %xmm0, 0x8(%rsp)
movq 0x70(%rbx), %rax
movq (%rax,%r15,8), %rdi
movsd 0x18(%rbx), %xmm1
movq (%rdi,%r13), %rax
addq %r13, %rdi
movl $0x66, %esi
movq %r14, %rdx
callq *0x18(%rax)
movq 0x78(%rbx), %rax
movq (%rax,%r15,8), %rdi
movsd 0x18(%rbx), %xmm1
movq (%rdi,%r13), %rax
addq %r13, %rdi
movl $0x66, %esi
movsd 0x8(%rsp), %xmm0
movq %r14, %rdx
callq *0x18(%rax)
incq %rbp
movslq 0x4(%rbx), %rax
addq $0x70, %r13
addq $0x88, %r12
cmpq %rax, %rbp
jl 0x3b3f
movl (%rbx), %ecx
incq %r15
movslq %ecx, %rdx
cmpq %rdx, %r15
jl 0x3b2f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tlestang[P]IW_gene/LatticeBoltzmann.cpp
// Function: LatticeBoltzmann::streamToNeighbors(int, int)
void LatticeBoltzmann::streamToNeighbors(int x, int y)
{
	for (int k=0; k<9; k++)
	{
	  int nx = (x + VelSite::e[k][0] + dims[0])%dims[0];
	  int ny = (y + VelSite::e[k][1] + dims[1])%dims[1];

	  velSites_[nx][ny].f[k] = velSites[x][y].f[k];
	}
	for (int k=0;k<4;k++)
	  {
	    int nx = (x + ThermalSite::c[k][0] + dims[0])%dims[0];
	    int ny = (y + ThermalSite::c[k][1] + dims[1])%dims[1];
	    
	    thermalSites_[nx][ny].f[k] = thermalSites[x][y].f[k];
	  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ecx
movl (%rdi), %r9d
movl 0x4(%rdi), %r10d
movq 0x60(%rdi), %rax
movslq %esi, %r11
movslq %edx, %rbx
movq 0x68(%rdi), %r14
movq %rbx, %rdx
shlq $0x7, %rdx
leaq (%rdx,%rbx,8), %r15
addq (%rax,%r11,8), %r15
movl $0x1, %r12d
leaq 0x23e8(%rip), %r13      # 0x6050
movl -0x8(%r13,%r12,8), %eax
addl %esi, %eax
addl %r9d, %eax
cltd
idivl %r9d
movl %edx, %r8d
movl -0x4(%r13,%r12,8), %eax
addl %ecx, %eax
addl %r10d, %eax
cltd
idivl %r10d
movslq %r8d, %rax
movslq %edx, %rdx
movq %rdx, %r8
shlq $0x7, %r8
leaq (%r8,%rdx,8), %rdx
addq (%r14,%rax,8), %rdx
movsd (%r15,%r12,8), %xmm0
movsd %xmm0, (%rdx,%r12,8)
incq %r12
cmpq $0xa, %r12
jne 0x3c68
movq 0x70(%rdi), %rax
movq 0x78(%rdi), %r8
imulq $0x70, %rbx, %rbx
addq (%rax,%r11,8), %rbx
movl $0x1, %r11d
leaq 0x2362(%rip), %r14      # 0x6030
movl -0x8(%r14,%r11,8), %eax
addl %esi, %eax
addl %r9d, %eax
cltd
idivl %r9d
movl %edx, %edi
movl -0x4(%r14,%r11,8), %eax
addl %ecx, %eax
addl %r10d, %eax
cltd
idivl %r10d
movslq %edi, %rax
movslq %edx, %rdx
imulq $0x70, %rdx, %rdx
addq (%r8,%rax,8), %rdx
movsd (%rbx,%r11,8), %xmm0
movsd %xmm0, (%rdx,%r11,8)
incq %r11
cmpq $0x5, %r11
jne 0x3cce
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tlestang[P]IW_gene/LatticeBoltzmann.cpp
// Function: LatticeBoltzmann::InitialCondition_X(int, int)
double LatticeBoltzmann::InitialCondition_X(int x, int y)
{
  double a = 0.0;
  double delta = 2.*h;
  double arg; double k = (2.*M_PI)/(dims[0]-1);
  arg = (y-h*sin(k*x))/delta;

  a = (h/delta)*sin(k*x)*exp(-arg);

  return u0*(1+a);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movsd 0x30(%rdi), %xmm1
movsd %xmm1, (%rsp)
movl (%rdi), %eax
decl %eax
cvtsi2sd %eax, %xmm0
addsd %xmm1, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x21f6(%rip), %xmm1     # 0x6180
cvtsi2sd %edx, %xmm2
movapd %xmm2, 0x10(%rsp)
divsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
callq 0x2080
mulsd (%rsp), %xmm0
movapd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
movsd 0x30(%rbx), %xmm0
divsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x2080
mulsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movapd 0x10(%rsp), %xmm0
xorpd 0x21ea(%rip), %xmm0     # 0x61e0
divsd 0x8(%rsp), %xmm0
callq 0x2290
mulsd (%rsp), %xmm0
addsd 0x2002(%rip), %xmm0     # 0x6010
mulsd 0x20(%rbx), %xmm0
addq $0x30, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tlestang[P]IW_gene/LatticeBoltzmann.cpp
// Function: LatticeBoltzmann::InitialCondition_Y(int, int)
double LatticeBoltzmann::InitialCondition_Y(int x, int y)
{
  double a, b, c;
  double delta = 2.*h;
  double arg; double k = (2.*M_PI)/(dims[0]-1);
  arg = (y-h*sin(k*x))/delta;

  a = u0*h*k*cos(k*x);
  b = exp(-arg);
  c = 1.+(h/delta)*sin(k*x);

  return a*b*c;

}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movsd 0x30(%rdi), %xmm1
movsd %xmm1, (%rsp)
movl (%rdi), %eax
decl %eax
cvtsi2sd %eax, %xmm0
addsd %xmm1, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x213a(%rip), %xmm2     # 0x6180
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
movapd %xmm1, 0x10(%rsp)
divsd %xmm0, %xmm2
movsd %xmm2, 0x28(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
mulsd %xmm2, %xmm0
movsd %xmm0, 0x20(%rsp)
callq 0x2080
mulsd (%rsp), %xmm0
movapd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
movsd 0x20(%rbx), %xmm0
mulsd 0x30(%rbx), %xmm0
mulsd 0x28(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x22c0
mulsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movapd 0x10(%rsp), %xmm0
xorpd 0x2120(%rip), %xmm0     # 0x61e0
divsd 0x8(%rsp), %xmm0
callq 0x2290
movsd %xmm0, 0x10(%rsp)
movsd 0x30(%rbx), %xmm0
divsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x2080
mulsd 0x8(%rsp), %xmm0
addsd 0x1f15(%rip), %xmm0     # 0x6010
movsd 0x10(%rsp), %xmm1
mulsd (%rsp), %xmm1
mulsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/tlestang[P]IW_gene/LatticeBoltzmann.cpp
// Function: LatticeBoltzmann::~LatticeBoltzmann()
LatticeBoltzmann::~LatticeBoltzmann()
{
  delete thermalSites;
  delete thermalSites_;
  delete velSites;
  delete velSites_;
  
  delete w;
  delete topo;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x70(%rdi), %rdi
movl $0x8, %esi
callq 0x21a0
movq 0x78(%rbx), %rdi
movl $0x8, %esi
callq 0x21a0
movq 0x60(%rbx), %rdi
movl $0x8, %esi
callq 0x21a0
movq 0x68(%rbx), %rdi
movl $0x8, %esi
callq 0x21a0
movq 0x80(%rbx), %rdi
movl $0x18, %esi
callq 0x21a0
movq 0x88(%rbx), %rdi
movl $0x20, %esi
popq %rbx
jmp 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ashlall[P]StreamStats/ChiSquareExperiments/VaryMemoryCategorical.cpp
// Function: name_file(char*, char**, int)
void name_file(char *str, char* argv[], int extra)
{
  time_t now = time(0);
  struct tm tstruct;
  char buf[80];
  tstruct = *localtime(&now);
  strftime(buf, sizeof(buf), "%m-%d-%Y.%X", &tstruct);

  strcpy(str, "RealCategorical_");
  strcat(str, argv[1]);
  strcat(str, "-");
  strcat(str, argv[2]);
  strcat(str, "_");
  strcat(str, argv[3]);
  strcat(str, "_");
  strcat(str, buf);

  if (extra == 0)
    strcat(str, "_log.dat");
  else if (extra == 1)
    strcat(str, "_table.dat");
  else if (extra == 2)
    strcat(str, "_extra.dat");
  else if (extra == 3)
    strcat(str, "_pvalues.dat");
  else if (extra == 4)
    strcat(str, "_actual-values.dat");
  else 
	strcat(str, "_times.dat");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
xorl %edi, %edi
callq 0x21c0
leaq -0x30(%rbp), %rdi
movq %rax, (%rdi)
callq 0x2150
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
leaq -0x70(%rbp), %rcx
movaps %xmm0, (%rcx)
movaps %xmm1, 0x10(%rcx)
movaps %xmm2, 0x20(%rcx)
movq 0x30(%rax), %rax
movq %rax, 0x30(%rcx)
leaq 0x122a(%rip), %rdx      # 0x5309
leaq -0xc0(%rbp), %r12
movl $0x50, %esi
movq %r12, %rdi
callq 0x2190
movups 0x121b(%rip), %xmm0     # 0x5315
movups %xmm0, (%r14)
movb $0x0, 0x10(%r14)
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x2350
movq %r14, %rdi
callq 0x20d0
movw $0x2d, (%r14,%rax)
movq 0x10(%r15), %rsi
movq %r14, %rdi
callq 0x2350
movq %r14, %rdi
callq 0x20d0
movw $0x5f, %r13w
movw %r13w, (%r14,%rax)
movq 0x18(%r15), %rsi
movq %r14, %rdi
callq 0x2350
movq %r14, %rdi
callq 0x20d0
movw %r13w, (%r14,%rax)
movq %r14, %rdi
movq %r12, %rsi
callq 0x2350
movq %r14, %rdi
callq 0x20d0
addq %r14, %rax
cmpl $0x4, %ebx
ja 0x41dd
movl %ebx, %ecx
leaq 0x1007(%rip), %rdx      # 0x5180
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movabsq $0x7461642e676f6c5f, %rcx # imm = 0x7461642E676F6C5F
movq %rcx, (%rax)
movb $0x0, 0x8(%rax)
jmp 0x41f1
movups 0x11b6(%rip), %xmm0     # 0x5352
movups %xmm0, (%rax)
movl $0x746164, 0xf(%rax)    # imm = 0x746164
jmp 0x41f1
movabsq $0x642e61727478655f, %rcx # imm = 0x642E61727478655F
jmp 0x41e7
movabsq $0x7461642e736575, %rcx # imm = 0x7461642E736575
movq %rcx, 0x5(%rax)
movabsq $0x7365756c6176705f, %rcx # imm = 0x7365756C6176705F
movq %rcx, (%rax)
jmp 0x41f1
movabsq $0x642e656c6261745f, %rcx # imm = 0x642E656C6261745F
jmp 0x41e7
movabsq $0x642e73656d69745f, %rcx # imm = 0x642E73656D69745F
movq %rcx, (%rax)
movl $0x746164, 0x7(%rax)    # imm = 0x746164
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ogghead[P]Moon_Boersma_Coe_CSCI2270_FinalProject/Blackjack.cpp
// Function: Blackjack::ai(player*)
void Blackjack::ai(player * player){//this function handles the different AIs and what they decide to do each turn
    int ori=player->orientation;
        while(player->stand==false){
            if(ori==0){
                break;
            }

            else if(ori==2){
                if(player->handValue < 17){
                    HitMe(player,false);
                }
            if(player->handValue >= 17){
                Stand(player);
                }
            }
            else if(ori==1){
                if(player->handValue < 16){
                    HitMe(player,false);
                }
                if(player->handValue >= 16){
                    Stand(player);
                }
            }

            else if(ori==3){
                if(player->handValue < 18){
                    HitMe(player,false);
                }
                if(player->handValue >= 18){
                    Stand(player);
                }
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x20(%rsi), %r15d
testl %r15d, %r15d
sete %al
orb 0x6c(%rsi), %al
jne 0x2808
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x1, %r15d
je 0x27e5
cmpl $0x3, %r15d
je 0x27ca
cmpl $0x2, %r15d
jne 0x2802
cmpl $0x10, 0x24(%rbx)
jg 0x27fe
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2814
cmpl $0x10, 0x24(%rbx)
jg 0x27fe
jmp 0x2802
cmpl $0x11, 0x24(%rbx)
jg 0x27fe
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2814
cmpl $0x12, 0x24(%rbx)
jge 0x27fe
jmp 0x2802
cmpl $0xf, 0x24(%rbx)
jg 0x27fe
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2814
cmpl $0xf, 0x24(%rbx)
jle 0x2802
movb $0x1, 0x6c(%rbx)
cmpb $0x1, 0x6c(%rbx)
jne 0x279d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ogghead[P]Moon_Boersma_Coe_CSCI2270_FinalProject/Blackjack.cpp
// Function: Blackjack::createPlayers(int)
void Blackjack::createPlayers(int playerNumber)
{
    player* me = new player;
    me->orientation = 0;
    me->totalMoney = 1000;

    players.push_back(me);

    srand(time(NULL));  // to make the decks more random than the same seed every time

    player* newAI = new player;//this is the dealer
    newAI->orientation = 2;
    players.push_back(newAI);

    for(int i = 1; i < playerNumber; i++)//other AIs
    {
        player* newAI = new player;
        newAI->orientation = rand() % 3 + 1;
        newAI->totalMoney = 1000;
        players.push_back(newAI);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x70, %edi
callq 0x2140
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movb $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movq %rcx, 0x38(%rax)
movups %xmm0, 0x4c(%rax)
movups %xmm0, 0x5c(%rax)
movw $0x0, 0x6c(%rax)
movq %rax, -0x40(%rbp)
movl $0x0, 0x20(%rax)
movl $0x3e8, 0x40(%rax)      # imm = 0x3E8
leaq 0x18(%r14), %r15
movq 0x20(%r14), %rsi
cmpq 0x28(%r14), %rsi
je 0x29ae
movq %rax, (%rsi)
addq $0x8, 0x20(%r14)
jmp 0x29ba
leaq -0x40(%rbp), %rdx
movq %r15, %rdi
callq 0x31ec
xorl %r12d, %r12d
xorl %edi, %edi
callq 0x2100
movl %eax, %edi
callq 0x2120
movl $0x70, %edi
callq 0x2140
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq %r12, 0x8(%rax)
movb $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movq %r12, 0x38(%rax)
movups %xmm0, 0x4c(%rax)
movups %xmm0, 0x5c(%rax)
movw $0x0, 0x6c(%rax)
movq %rax, -0x38(%rbp)
movl $0x2, 0x20(%rax)
movq 0x20(%r14), %rsi
cmpq 0x28(%r14), %rsi
je 0x2a1c
movq %rax, (%rsi)
addq $0x8, 0x20(%r14)
jmp 0x2a28
leaq -0x38(%rbp), %rdx
movq %r15, %rdi
callq 0x31ec
cmpl $0x2, %ebx
jl 0x2ac9
decl %ebx
xorl %r13d, %r13d
leaq -0x30(%rbp), %r12
movl $0x70, %edi
callq 0x2140
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq %r13, 0x8(%rax)
movb $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movq %r13, 0x38(%rax)
movups %xmm0, 0x4c(%rax)
movups %xmm0, 0x5c(%rax)
movw $0x0, 0x6c(%rax)
movq %rax, -0x30(%rbp)
callq 0x2050
cltq
imulq $0x55555556, %rax, %rcx # imm = 0x55555556
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,2), %ecx
negl %ecx
addl %eax, %ecx
incl %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x20(%rax)
movl $0x3e8, 0x40(%rax)      # imm = 0x3E8
movq 0x20(%r14), %rsi
cmpq 0x28(%r14), %rsi
je 0x2ab6
movq %rax, (%rsi)
addq $0x8, 0x20(%r14)
jmp 0x2ac1
movq %r15, %rdi
movq %r12, %rdx
callq 0x31ec
decl %ebx
jne 0x2a3a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ogghead[P]Moon_Boersma_Coe_CSCI2270_FinalProject/Blackjack.cpp
// Function: Blackjack::Split(player*)
void Blackjack::Split(player* myPlayer)
{
    card* tmp = myPlayer->hand[1];
    myPlayer->hand.pop_back();
    myPlayer->hand2.push_back(tmp);
    myPlayer->handValue = myPlayer->handValue - tmp->value;
    myPlayer->handValue2 = tmp->value;
    HitMe(myPlayer,true);
    HitMe(myPlayer,false);
    myPlayer->bet2 = myPlayer->bet;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x28(%rsi), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
addq $-0x8, 0x30(%rsi)
movq %rdi, %r14
movq 0x58(%rsi), %rsi
cmpq 0x60(%rbx), %rsi
je 0x2b87
movq %rax, (%rsi)
addq $0x8, 0x58(%rbx)
jmp 0x2b9a
leaq 0x50(%rbx), %rdi
leaq -0x20(%rbp), %r15
movq %r15, %rdx
callq 0x30b2
movq (%r15), %rax
movl (%rax), %eax
subl %eax, 0x24(%rbx)
movl %eax, 0x4c(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x2814
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2814
movl 0x44(%rbx), %eax
movl %eax, 0x68(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ogghead[P]Moon_Boersma_Coe_CSCI2270_FinalProject/Blackjack.cpp
// Function: Blackjack::Bet(int)
void Blackjack::Bet(int bet)
{
    player* player = players[0];
    int minVal = 10;
    if (bet > player->totalMoney || bet < minVal)
    {
            string betN;
            int betNew=0;
            cout<<"That is an invalid bet"<<endl;
        cout<<"How much would you like to bet?"<<endl;
        getline(cin,betN);
        betNew=stoi(betN);
        Bet(betNew);
    }else{
    player->bet = bet;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $0xa, %esi
jl 0x2bfd
movq 0x18(%rbx), %rax
movq (%rax), %rax
cmpl %esi, 0x40(%rax)
jl 0x2bfd
movl %esi, 0x44(%rax)
jmp 0x2d29
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x43b9(%rip), %r14      # 0x6fd0
leaq 0x2488(%rip), %rsi      # 0x50a6
movl $0x16, %edx
movq %r14, %rdi
callq 0x2160
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq 0x4387(%rip), %rdi      # 0x6fd0
callq 0x2030
movq %rax, %rdi
callq 0x20c0
movq 0x4373(%rip), %r14      # 0x6fd0
leaq 0x2459(%rip), %rsi      # 0x50bd
movl $0x1f, %edx
movq %r14, %rdi
callq 0x2160
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq 0x4341(%rip), %rdi      # 0x6fd0
callq 0x2030
movq %rax, %rdi
callq 0x20c0
movq 0x433d(%rip), %rdi      # 0x6fe0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %edx
movq 0x4322(%rip), %rdi      # 0x6fe0
leaq -0x48(%rbp), %rsi
callq 0x21f0
movq -0x48(%rbp), %r15
callq 0x2040
movq %rax, %r14
movl (%rax), %r13d
movl $0x0, (%rax)
leaq -0x50(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x2170
cmpq %r15, (%r12)
je 0x2d38
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x2d44
movl (%r14), %ecx
cmpl $0x22, %ecx
je 0x2d44
testl %ecx, %ecx
jne 0x2d0d
movl %r13d, (%r14)
movq %rbx, %rdi
movl %eax, %esi
callq 0x2bd0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x2d29
callq 0x2110
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x23ab(%rip), %rdi      # 0x50ea
callq 0x20a0
leaq 0x239f(%rip), %rdi      # 0x50ea
callq 0x2180
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x2d61
movl %r13d, (%r14)
jmp 0x2d61
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x2d73
callq 0x2110
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ogghead[P]Moon_Boersma_Coe_CSCI2270_FinalProject/Blackjack.cpp
// Function: Blackjack::Reset()
void Blackjack::Reset(){//reset player variables for a new round
    for (int i = 0; i < players.size(); i++){
        players[i]->handValue = 0;
        players[i]->handValue = 0;
        players[i]->bet = 0;
        players[i]->bet2 = 0;
        while (players[i]->hand.size() != 0){
            players[i]->hand.pop_back();
        }
        while (players[i]->hand2.size() != 0){
            players[i]->hand2.pop_back();
        }
        players[i]->stand = false;
        players[i]->stand2 = false;
        players[i]->isSplit = false;
    }
}

// Assembly:
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
subq %rax, %rcx
je 0x2e87
pushq %rbp
movq %rsp, %rbp
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
xorl %esi, %esi
movq (%rax,%rsi,8), %rdi
movl %edx, 0x24(%rdi)
movl %edx, 0x44(%rdi)
movl %edx, 0x68(%rdi)
movq 0x30(%rdi), %r8
cmpq 0x28(%rdi), %r8
je 0x2e4a
addq $0x30, %rdi
movq %rdi, %r9
addq $-0x8, %r8
movq %r8, (%r9)
movq (%rax,%rsi,8), %rdi
leaq 0x30(%rdi), %r9
movq 0x30(%rdi), %r8
cmpq 0x28(%rdi), %r8
jne 0x2e31
movq 0x58(%rdi), %r8
cmpq 0x50(%rdi), %r8
je 0x2e74
addq $0x58, %rdi
movq %rdi, %r9
addq $-0x8, %r8
movq %r8, (%r9)
movq (%rax,%rsi,8), %rdi
leaq 0x58(%rdi), %r9
movq 0x58(%rdi), %r8
cmpq 0x50(%rdi), %r8
jne 0x2e5b
movw $0x0, 0x6c(%rdi)
movb $0x0, 0x48(%rdi)
incq %rsi
cmpq %rcx, %rsi
jne 0x2e13
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nmmmnu[P]HM3/hm3/idgenerator/idgeneratorts.cc
// Function: hm3::idgenerator::IDGeneratorTS::_format(std::ostream&, unsigned int) const
void IDGeneratorTS::_format(std::ostream &buff, uint32_t value) const{
	if (_hex){
		buff	<< std::setfill('0') << std::setw(8) << std::hex;
	}else{
		buff	<< std::setfill('0') << std::setw(10);
	}

	buff << value;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq (%rsi), %rax
movq -0x18(%rax), %rcx
leaq (%rsi,%rcx), %r14
movb 0xe1(%rsi,%rcx), %cl
cmpb $0x1, (%rdi)
jne 0x1599
testb %cl, %cl
jne 0x1570
movq %r14, %rdi
movl $0x20, %esi
callq 0x10b0
movb $0x1, 0xe1(%r14)
movq (%rbx), %rax
movb $0x30, 0xe0(%r14)
movq -0x18(%rax), %rcx
movq $0x8, 0x10(%rbx,%rcx)
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rbx,%rax)
jmp 0x15ca
testb %cl, %cl
jne 0x15b5
movq %r14, %rdi
movl $0x20, %esi
callq 0x10b0
movb $0x1, 0xe1(%r14)
movq (%rbx), %rax
movb $0x30, 0xe0(%r14)
movq -0x18(%rax), %rax
movq $0xa, 0x10(%rbx,%rax)
movl %ebp, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1070
// File: /workspace/github_cpp_makefile_star2_O3/nmmmnu[P]HM3/hm3/idgenerator/idgeneratorts.cc
// Function: hm3::idgenerator::IDGeneratorTS::operator()[abi:cxx11]() const
std::string IDGeneratorTS::operator()() const{
	std::ostringstream buff;

	auto now = MyTime::now();

	_format(buff, MyTime::uncombine(now));

	buff << ".";

	_format(buff, MyTime::uncombine2(now));

	return buff.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0x10e0
callq 0x17d2
movq %rax, %r15
movq %rax, %rdx
shrq $0x20, %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x1534
leaq 0xa25(%rip), %rsi       # 0x203d
movq %rsp, %rdi
movl $0x1, %edx
callq 0x10d0
movq %rsp, %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x1534
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1100
movq 0x2989(%rip), %rsi      # 0x3fd0
movq %rsp, %rdi
callq 0x1060
leaq 0x70(%rsp), %rdi
callq 0x1040
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x295b(%rip), %rsi      # 0x3fd0
movq %rsp, %rdi
callq 0x1060
leaq 0x70(%rsp), %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x1120
nop
// File: /workspace/github_cpp_makefile_star2_O3/nmmmnu[P]HM3/hm3/idgenerator/idgeneratordate.cc
// Function: hm3::idgenerator::IDGeneratorDate::operator()[abi:cxx11]() const
std::string IDGeneratorDate::operator()() const{
	std::ostringstream buff;

	static const char *FORMAT = MyTime::DATA_FORMAT_NUMBER;

	buff	<< MyTime::toString(MyTime::now(), FORMAT)
		<< "."
		<< std::setfill('0') << std::setw(10)
		<< MyTime::uncombine2(MyTime::now());


	return buff.str();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x10e0
callq 0x17d2
leaq 0x98e(%rip), %rsi       # 0x203f
movq %rax, %rdi
callq 0x1824
testq %rax, %rax
je 0x16d9
movq %rax, %r14
movq %rax, %rdi
callq 0x1050
movq %rsp, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x10d0
jmp 0x16f0
movq (%rsp), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %rdi
movl 0x20(%rdi), %esi
orl $0x1, %esi
callq 0x1110
leaq 0x946(%rip), %rsi       # 0x203d
movq %rsp, %rdi
movl $0x1, %edx
callq 0x10d0
movq (%rsp), %rax
movq -0x18(%rax), %rcx
leaq (%rsp,%rcx), %r14
cmpb $0x0, 0xe1(%r14)
jne 0x1733
movq %r14, %rdi
movl $0x20, %esi
callq 0x10b0
movb $0x1, 0xe1(%r14)
movq (%rsp), %rax
movb $0x30, 0xe0(%r14)
movq -0x18(%rax), %rax
movq $0xa, 0x10(%rsp,%rax)
callq 0x17d2
movl %eax, %esi
movq %rsp, %rdi
callq 0x1070
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1100
movq 0x2865(%rip), %rsi      # 0x3fd0
movq %rsp, %rdi
callq 0x1060
leaq 0x70(%rsp), %rdi
callq 0x1040
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x283b(%rip), %rsi      # 0x3fd0
movq %rsp, %rdi
callq 0x1060
leaq 0x70(%rsp), %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x1120
nop
// File: /workspace/github_cpp_makefile_star2_O3/pokorj54[P]Pathfinder-utilities/src/Exceptions/InvalidNoArgumentsException.cpp
// Function: InvalidNoArgumentsException::Message(std::ostream&) const
void InvalidNoArgumentsException::Message(std::ostream & o) const 
{
    o << "You have entered " << noArgs << " arguments for the last command, which is ";
    if(tooMuch)
    {
        o << "too much";
    }
    else
    {
        o << "not enough";
    }
    o << std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x37e3(%rip), %rsi      # 0x9212
movl $0x11, %edx
movq %rbx, %rdi
callq 0x32a0
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x33e0
leaq 0x37d5(%rip), %rsi      # 0x9224
movl $0x2a, %edx
movq %rax, %rdi
callq 0x32a0
cmpb $0x1, 0xc(%r14)
jne 0x5a71
leaq 0x37e5(%rip), %rsi      # 0x924f
movl $0x8, %edx
jmp 0x5a7d
leaq 0x37e0(%rip), %rsi      # 0x9258
movl $0xa, %edx
movq %rbx, %rdi
callq 0x32a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3250
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3190
nop
// File: /workspace/github_cpp_makefile_star2_O3/pokorj54[P]Pathfinder-utilities/src/CommandLine.cpp
// Function: CommandLine::HandleSacredGeometry(CommandLine::Arguments&)
void CommandLine::HandleSacredGeometry(Arguments & args)
{
    int spellLevel = TryConvertingStringToInt(args.PopFirst(), 0);
    int size = args.GetNoArguments();
    int * dices = new int[size];
    for(int i = 0; i < size; ++i)
    {
        dices[i] = TryConvertingStringToInt(args.PopFirst(), i + 1);
    }
    string expression = GetDesiredExpression(spellLevel, dices, size);
    if(expression == "")
    {
        expression = "none";
    }
    (*output) << "Expression: " << expression << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x62ca
movq %rbx, %rdi
xorl %esi, %esi
callq 0x640a
movl %eax, 0x24(%rsp)
movq %r15, 0x30(%rsp)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6065
callq 0x3240
movq 0x10(%r14), %rax
movq %rax, 0x28(%rsp)
movslq %eax, %rbx
leaq (,%rbx,4), %rax
testl %ebx, %ebx
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x3030
movq %rax, %r12
testl %ebx, %ebx
jle 0x60db
movq 0x28(%rsp), %r15
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %ebp, %ebp
movq %rsp, %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x62ca
leaq 0x1(%rbp), %rbx
movq %r13, %rdi
movl %ebx, %esi
callq 0x640a
movl %eax, (%r12,%rbp,4)
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x60d3
callq 0x3240
movq %rbx, %rbp
cmpq %rbx, %r15
jne 0x60a3
movq %rsp, %rbx
movq %rbx, %rdi
movl 0x24(%rsp), %esi
movq %r12, %rdx
movq 0x28(%rsp), %rcx
callq 0x550c
leaq 0x32ef(%rip), %rsi      # 0x93e8
movq %rbx, %rdi
callq 0x30b0
testl %eax, %eax
jne 0x6120
movq %rsp, %rdi
movq 0x8(%rdi), %rdx
leaq 0x3311(%rip), %rcx      # 0x9424
movl $0x4, %r8d
xorl %esi, %esi
callq 0x3360
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rbx
leaq 0x32f9(%rip), %rsi      # 0x9429
movl $0xc, %edx
movq %rbx, %rdi
callq 0x32a0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x32a0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3250
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3190
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x618b
callq 0x3240
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
jmp 0x61b6
jmp 0x61aa
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x61c0
callq 0x3240
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O3/pokorj54[P]Pathfinder-utilities/src/CommandLine.cpp
// Function: CommandLine::Arguments::PopFirst[abi:cxx11]()
string CommandLine::Arguments::PopFirst()
{
    if(arguments.empty())
    {
        throw InvalidNoArgumentsException(noArgs, false);
    }
    string res = arguments.front();
    arguments.pop_front();
    return res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %rax
cmpq %rsi, %rax
je 0x6309
movq %rdi, %r14
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
addq %rsi, %rdx
callq 0x5974
movq (%rbx), %rsi
movq %rbx, %rdi
callq 0x7f9a
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x3130
movq %rax, %r14
movl 0x18(%rbx), %esi
movq %rax, %rdi
xorl %edx, %edx
callq 0x5a0c
leaq 0x69fe(%rip), %rsi      # 0xcd28
movq 0x6caf(%rip), %rdx      # 0xcfe0
movq %r14, %rdi
callq 0x33d0
movq %rax, %rbx
movq %r14, %rdi
callq 0x31d0
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O3/pokorj54[P]Pathfinder-utilities/src/CommandLine.cpp
// Function: CommandLine::Arguments::PopFirstIfNotEmpty[abi:cxx11]()
string CommandLine::Arguments::PopFirstIfNotEmpty()
{
    if(arguments.empty())
    {
        return "";
    }
    string res = arguments.front();
    arguments.pop_front();
    return res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
cmpq %rsi, %rax
je 0x6385
movq %rsi, %r14
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x5974
movq (%r14), %rsi
movq %r14, %rdi
callq 0x7f9a
jmp 0x639e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x3055(%rip), %rdx      # 0x93e8
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x45c4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pokorj54[P]Pathfinder-utilities/src/CommandLine.cpp
// Function: TryConvertingStringToInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
int TryConvertingStringToInt(const string & input, int argPos = 0)
{
    int res;
    try
    {
        res = stoi(input);
    }
    catch(const std::invalid_argument& e)
    {
        throw InvalidArgumentException(input,argPos);
    }
    
    if(input != to_string(res))
    {
        throw InvalidArgumentException(input,argPos);
    }            
    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %r14d
movq %rdi, 0x10(%rsp)
movq (%rdi), %r13
callq 0x3060
movq %rax, %r12
movl (%rax), %ebx
movl $0x0, (%rax)
leaq 0x18(%rsp), %rbp
movq %r13, %rdi
movq %rbp, %rsi
movl $0xa, %edx
callq 0x3300
cmpq %r13, (%rbp)
je 0x6568
movq %rax, %r15
movslq %r15d, %rax
cmpq %r15, %rax
jne 0x6574
movl (%r12), %eax
cmpl $0x22, %eax
je 0x6574
testl %eax, %eax
jne 0x6476
movl %ebx, (%r12)
movl %r15d, %ebp
negl %ebp
cmovsl %r15d, %ebp
movl $0x1, %r12d
cmpl $0xa, %ebp
jb 0x64d3
movl $0x4, %r12d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %ebp, %ecx
cmpl $0x63, %ecx
jbe 0x64ca
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x64d0
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x64d3
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r12d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0x6497
addl $-0x3, %r12d
jmp 0x64d3
addl $-0x2, %r12d
jmp 0x64d3
decl %r12d
movl %r14d, 0xc(%rsp)
movl %r15d, %r13d
shrl $0x1f, %r13d
leal (%r12,%r13), %esi
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movl $0x2d, %edx
callq 0x32b0
addq (%rbx), %r13
movq %r13, %rdi
movl %r12d, %esi
movl %ebp, %edx
callq 0x3f53
movq 0x10(%rsp), %r13
movq 0x8(%r13), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x653a
movq 0x18(%rsp), %r12
testq %rdx, %rdx
je 0x6543
movq (%r13), %rdi
movq %r12, %rsi
callq 0x3270
testl %eax, %eax
setne %bl
jmp 0x6545
movb $0x1, %bl
movq 0x18(%rsp), %r12
jmp 0x6545
xorl %ebx, %ebx
cmpq %r14, %r12
je 0x6552
movq %r12, %rdi
callq 0x3240
testb %bl, %bl
jne 0x6580
movl %r15d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ed6(%rip), %rdi      # 0x9445
callq 0x3170
leaq 0x2eca(%rip), %rdi      # 0x9445
callq 0x3310
movl $0x30, %edi
callq 0x3130
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
movl 0xc(%rsp), %edx
callq 0x5ac8
leaq 0x67e5(%rip), %rsi      # 0xcd88
leaq -0xa00(%rip), %rdx      # 0x5baa
movq %r12, %rdi
callq 0x33d0
movq %rax, %r15
movq %r12, %rdi
callq 0x31d0
jmp 0x6622
movq %rax, %r15
cmpl $0x0, (%r12)
jne 0x65cd
movl %ebx, (%r12)
cmpl $0x1, %edx
jne 0x6622
movq %r15, %rdi
callq 0x3100
movl $0x30, %edi
callq 0x3130
movq %rax, %r12
movq %rax, %rdi
movq 0x10(%rsp), %rsi
movl %r14d, %edx
callq 0x5ac8
leaq 0x678a(%rip), %rsi      # 0xcd88
leaq -0xa5b(%rip), %rdx      # 0x5baa
movq %r12, %rdi
callq 0x33d0
movq %rax, %r15
jmp 0x661d
movq %rax, %r15
movq %r12, %rdi
callq 0x31d0
callq 0x33a0
movq %r15, %rdi
callq 0x3410
movq %rax, %rdi
callq 0x4659
// File: /workspace/github_cpp_makefile_star2_O3/WShabti-Team[P]WShabtiPict/wshabtilib/api/combination.cpp
// Function: pictcore::Combination::Feasible()
int Combination::Feasible()
{
    int* workbuf = m_model->GetTask()->GetWorkbuf();

    int nWorkVals = 1;
    workbuf[ 0 ] = 0;
    for( Parameter* param : m_params )
    {
        for( int i = 0; i < nWorkVals; i++ )
        {
            workbuf[ i ] *= param->GetValueCount();
        }
        int nCurrentVal = (int) param->GetLast();
        if( param->GetBoundCount() )
        {
            for( int i = 0; i < nWorkVals; ++i )
            {
                workbuf[ i ] += nCurrentVal;
            }
        }
        else
        {
            for( int i = 0; i < nWorkVals; ++i )
            {
                for( int addend = 1; addend < param->GetValueCount(); ++addend )
                {
                    workbuf[ i + nWorkVals*addend ] = workbuf[ i ] + addend;
                }
            }
            nWorkVals *= param->GetValueCount();
        }
    }

    // Now count the zeros corresponding to the open combinations
    int zeros = 0;
    for( int i = 0; i < nWorkVals; ++i )
    {
        if( Open == m_bitvec[ workbuf[ i ] ] )
        {
            ++zeros;
        }
    }

    return zeros;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x38(%rdi), %rax
movq 0x148(%rax), %rax
movq 0x68(%rax), %rcx
movl $0x0, (%rcx)
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rsi
movl $0x1, %eax
cmpq %rsi, %rdx
je 0x5f8a
movq (%rdx), %r9
testl %eax, %eax
jle 0x5f17
movl %eax, %r8d
xorl %r10d, %r10d
movl (%rcx,%r10,4), %r11d
imull 0x38(%r9), %r11d
movl %r11d, (%rcx,%r10,4)
incq %r10
cmpq %r10, %r8
jne 0x5ee2
cmpb $0x0, 0x3d(%r9)
je 0x5f20
testl %eax, %eax
jle 0x5f79
movl 0x30(%r9), %r9d
xorl %r10d, %r10d
addl %r9d, (%rcx,%r10,4)
incq %r10
cmpq %r10, %r8
jne 0x5f09
jmp 0x5f79
cmpb $0x0, 0x3d(%r9)
je 0x5f6e
jmp 0x5f79
testl %eax, %eax
jle 0x5f6e
movl 0x38(%r9), %r14d
leaq (%rcx,%r8,4), %r10
leaq (,%r8,4), %r11
xorl %ebx, %ebx
cmpl $0x2, %r14d
jl 0x5f60
movl (%rcx,%rbx,4), %r15d
movl $0x1, %r12d
movq %r10, %r13
leal (%r15,%r12), %ebp
movl %ebp, (%r13)
incq %r12
movslq 0x38(%r9), %r14
addq %r11, %r13
cmpq %r14, %r12
jl 0x5f49
incq %rbx
addq $0x4, %r10
cmpq %r8, %rbx
jne 0x5f36
jmp 0x5f72
movl 0x38(%r9), %r14d
imull %eax, %r14d
movl %r14d, %eax
addq $0x8, %rdx
cmpq %rsi, %rdx
jne 0x5ed5
testl %eax, %eax
jle 0x5faa
movq 0x20(%rdi), %rdx
movl %eax, %esi
xorl %edi, %edi
xorl %eax, %eax
movslq (%rcx,%rdi,4), %r8
cmpb $0x1, (%rdx,%r8)
adcl $0x0, %eax
incq %rdi
cmpq %rdi, %rsi
jne 0x5f94
jmp 0x5fac
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/WShabti-Team[P]WShabtiPict/wshabtilib/api/combination.cpp
// Function: pictcore::Combination::Feasible(int)
ComboStatus Combination::Feasible( int value )
{
    if( EXCLUDED == m_bitvec[ value ] )
    {
        return Excluded;
    }
    ComboStatus retval = ( COVERED == m_bitvec[ value ] ) ? CoveredMatch : Open;
    for( ParamCollection::reverse_iterator iter = m_params.rbegin(); iter != m_params.rend(); ++iter )
    {
        if( ( *iter )->GetBoundCount() && ( *iter )->GetLast() != value % ( *iter )->GetValueCount() )
        {
            return Excluded;
        }
        value /= ( *iter )->GetValueCount();
    }

    return retval;
}

// Assembly:
movq 0x20(%rdi), %rax
movslq %esi, %rcx
movb (%rax,%rcx), %al
movl $0x2, %ecx
cmpb $-0x1, %al
je 0x6018
xorl %r8d, %r8d
cmpb $0x1, %al
sete %r8b
movq 0x8(%rdi), %r9
movq 0x10(%rdi), %rdi
cmpq %r9, %rdi
je 0x6015
movq -0x8(%rdi), %rax
cmpb $0x0, 0x3d(%rax)
je 0x6003
movq 0x30(%rax), %r11
movl 0x38(%rax), %r10d
movl %esi, %eax
cltd
idivl %r10d
movslq %edx, %rax
cmpq %rax, %r11
je 0x6007
jmp 0x6018
movl 0x38(%rax), %r10d
addq $-0x8, %rdi
movl %esi, %eax
cltd
idivl %r10d
movl %eax, %esi
jmp 0x5fdc
movl %r8d, %ecx
movl %ecx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/WShabti-Team[P]WShabtiPict/wshabtilib/api/combination.cpp
// Function: pictcore::Combination::Weight(int)
int Combination::Weight( int value )
{
    int weight = 0;
    for( ParamCollection::reverse_iterator iter = m_params.rbegin(); iter != m_params.rend(); ++iter )
    {
        Parameter* param = *iter;
        weight += param->GetWeight( value % param->GetValueCount() );
        value /= param->GetValueCount();
    }

    return weight;
}

// Assembly:
movl %esi, %eax
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdi
xorl %ecx, %ecx
cmpq %rsi, %rdi
je 0x6069
movq -0x8(%rdi), %r9
cltd
idivl 0x38(%r9)
movl $0x1, %r8d
testl %edx, %edx
js 0x6060
movq 0xa8(%r9), %r10
movq 0xb0(%r9), %r9
subq %r10, %r9
shrq $0x2, %r9
cmpl %r9d, %edx
jge 0x6060
movl %edx, %edx
movl (%r10,%rdx,4), %r8d
addl %r8d, %ecx
addq $-0x8, %rdi
jmp 0x6028
movl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/WShabti-Team[P]WShabtiPict/wshabtilib/api/combination.cpp
// Function: pictcore::Combination::AddBinding()
int Combination::AddBinding()
{
    if( ++m_boundCount == m_params.size() )
    {
        // compute which zero we're setting
        size_t value = 0;
        for( ParamCollection::iterator iter = m_params.begin(); iter != m_params.end(); ++iter )
        {
            assert( ( *iter )->GetBoundCount() );
            value = ( value * ( *iter )->GetValueCount() ) + ( *iter )->GetLast();
        }

        // check to see if it's zero
        if( OPEN == m_bitvec[ value ] )
        {
            // if so, set it and count it locally and globally
            assert( value <= (size_t) m_range );
            m_bitvec[ value ] = COVERED;
            --m_openCount;
            --m_model->GlobalZerosCount;
        }
    }

    return m_boundCount;
}

// Assembly:
pushq %rax
movslq 0x30(%rdi), %rax
incq %rax
movl %eax, 0x30(%rdi)
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rsi
movq %rsi, %rcx
subq %rdx, %rcx
sarq $0x3, %rcx
cmpq %rax, %rcx
jne 0x60d4
xorl %ecx, %ecx
cmpq %rsi, %rdx
je 0x60b1
movq (%rdx), %r8
cmpb $0x0, 0x3d(%r8)
je 0x60d6
movslq 0x38(%r8), %r9
imulq %r9, %rcx
addq 0x30(%r8), %rcx
addq $0x8, %rdx
jmp 0x6090
movq 0x20(%rdi), %rdx
cmpb $0x0, (%rdx,%rcx)
jne 0x60d4
movslq 0x28(%rdi), %rax
cmpq %rax, %rcx
ja 0x60f5
movb $0x1, (%rdx,%rcx)
decl 0x2c(%rdi)
movq 0x38(%rdi), %rax
decl (%rax)
movl 0x30(%rdi), %eax
popq %rcx
retq
leaq 0x1ff27(%rip), %rdi     # 0x26004
leaq 0x1ff3b(%rip), %rsi     # 0x2601f
leaq 0x1ff53(%rip), %rcx     # 0x2603e
movl $0x98, %edx
callq 0x52c0
leaq 0x1ff6a(%rip), %rdi     # 0x26066
leaq 0x1ff1c(%rip), %rsi     # 0x2601f
leaq 0x1ff34(%rip), %rcx     # 0x2603e
movl $0xa0, %edx
callq 0x52c0
// File: /workspace/github_cpp_makefile_star2_O3/WShabti-Team[P]WShabtiPict/wshabtilib/api/combination.cpp
// Function: pictcore::Combination::applyExclusion(pictcore::Exclusion&, int, __gnu_cxx::__normal_iterator<pictcore::Parameter**, std::vector<pictcore::Parameter*, std::allocator<pictcore::Parameter*>>>)
void Combination::applyExclusion( Exclusion& excl, int index, ParamCollection::iterator pos )
{
    if( m_params.end() == pos )
    {
        assert( index <= m_range );
        if( OPEN == m_bitvec[ index ] )
        {
            --m_openCount;
            --m_model->GlobalZerosCount;
        }
        m_bitvec[ index ] = EXCLUDED;
    }
    else
    {
        // Is *pos a parameter in the exclusion?
        Exclusion::iterator ie = find_if( excl.begin(),
                                          excl.end(),
                                          bind2nd( MatchParameterPointer(), *pos ) );
        // parameter is bound to a value in the exclusion
        if( excl.end() != ie )
        {
            applyExclusion( excl, index * ( *pos )->GetValueCount() + ie->second, pos + 1 );
        }
        // parameter ranges over all values in the exclusion
        else
        {
            for( int n = 0; n < ( *pos )->GetValueCount(); ++n )
            {
                applyExclusion( excl, index * ( *pos )->GetValueCount() + n, pos + 1 );
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rdi, 0x8(%rsp)
movq 0x10(%rdi), %r12
cmpq %rcx, %r12
je 0x617e
movq %rcx, %r14
movq 0x18(%rsi), %r13
movq %rsi, 0x10(%rsp)
leaq 0x8(%rsi), %r15
movq (%r14), %rbx
movq %r13, %rax
cmpq %r15, %r13
je 0x6163
movq %r13, %rax
cmpq %rbx, 0x20(%rax)
je 0x6163
movq %rax, %rdi
callq 0x54b0
cmpq %r15, %rax
jne 0x6150
movl 0x38(%rbx), %edx
cmpq %rax, %r15
je 0x61a6
imull %ebp, %edx
addl 0x28(%rax), %edx
addq $0x8, %r14
movl %edx, %ebp
cmpq %r14, %r12
jne 0x6142
jmp 0x6180
movl %ebp, %edx
movq 0x8(%rsp), %rsi
cmpl %edx, 0x28(%rsi)
jl 0x61e8
movq 0x20(%rsi), %rax
movslq %edx, %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x61a0
decl 0x2c(%rsi)
movq 0x38(%rsi), %rdx
decl (%rdx)
movb $-0x1, (%rax,%rcx)
jmp 0x61d9
testl %edx, %edx
movq 0x8(%rsp), %r15
movq 0x10(%rsp), %r13
jle 0x61d9
leaq 0x8(%r14), %r12
xorl %ebx, %ebx
imull %ebp, %edx
addl %ebx, %edx
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rcx
callq 0x6114
incl %ebx
movq (%r14), %rax
movl 0x38(%rax), %edx
cmpl %edx, %ebx
jl 0x61ba
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1fe91(%rip), %rdi     # 0x26080
leaq 0x1fe29(%rip), %rsi     # 0x2601f
leaq 0x1fe94(%rip), %rcx     # 0x26091
movl $0xb4, %edx
callq 0x52c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/WShabti-Team[P]WShabtiPict/wshabtilib/api/combination.cpp
// Function: pictcore::Combination::ApplyExclusion(pictcore::Exclusion&)
void Combination::ApplyExclusion( Exclusion& excl )
{
    // only if this exclusion's parameters exist in the combo
    for( Exclusion::iterator it = excl.begin(); it != excl.end(); ++it )
    {
        ParamCollection::iterator ip = find( m_params.begin(), m_params.end(), it->first );
        if( ip == m_params.end() ) return;
    }

    applyExclusion( excl, 0, m_params.begin() );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %r15
leaq 0x8(%rsi), %r13
cmpq %r13, %r15
je 0x6251
movq 0x10(%r14), %r12
movq 0x8(%r14), %rdi
leaq 0x20(%r15), %rdx
movq %r12, %rsi
callq 0x635d
movq 0x10(%r14), %r12
cmpq %r12, %rax
je 0x626b
movq %r15, %rdi
callq 0x54b0
movq %rax, %r15
cmpq %r13, %rax
jne 0x6228
movq 0x8(%r14), %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x6114
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/WShabti-Team[P]WShabtiPict/wshabtilib/api/combination.cpp
// Function: pictcore::Combination::ViolatesExclusion()
bool Combination::ViolatesExclusion()
{
    size_t nKey = 0;
    for( ParamCollection::iterator iter = m_params.begin(); iter != m_params.end(); ++iter )
    {
        nKey *= ( *iter )->GetValueCount();
        size_t nCurrentVal = ( *iter )->GetLast();
        assert( ( *iter )->GetBoundCount() );
        nKey += nCurrentVal;
    }

    return ( EXCLUDED == m_bitvec[ nKey ] );
}

// Assembly:
pushq %rax
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x62a1
movq (%rcx), %rsi
cmpb $0x0, 0x3d(%rsi)
je 0x62ae
movslq 0x38(%rsi), %r8
imulq %r8, %rax
addq 0x30(%rsi), %rax
addq $0x8, %rcx
jmp 0x6281
movq 0x20(%rdi), %rcx
cmpb $-0x1, (%rcx,%rax)
sete %al
popq %rcx
retq
leaq 0x1fd4f(%rip), %rdi     # 0x26004
leaq 0x1fd63(%rip), %rsi     # 0x2601f
leaq 0x1fe26(%rip), %rcx     # 0x260e9
movl $0xeb, %edx
callq 0x52c0
nop