LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/tlestang[P]IW_gene/Walls.cpp
// Function: TopWall::TemperatureBC(VelSite**, ThermalSite**, double**, double***)
void TopWall::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 Tinf, rho, ub[2], uinf[2];
  for (int i=0;i<nbNodes;i++)
    {
      double eu;
      x = nodes[i][0]; y = nodes[i][1];

      thermalSites[x][y-1].computeRhoAndU(Tinf);
      velSites[x][y-1].computeRhoAndU(rho, uinf);
      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] = (Tinf/4.)*(1.+2.*eu) + thermalSites[x][y-1].f[k]
	    - thermalSites[x][y-1].fEq(k,Tinf,uinf);
	}
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rsi, 0x10(%rsp)
xorl %ecx, %ecx
leaq 0x26cd(%rip), %r14      # 0x5150
movq %rdi, 0x8(%rsp)
movslq 0x8(%rdi), %rax
cmpq %rax, %rcx
jge 0x2bbb
movq 0x10(%rdi), %rax
movq %rcx, 0x18(%rsp)
movq (%rax,%rcx,8), %rax
movslq (%rax), %r15
movslq 0x4(%rax), %r12
movq (%rbx,%r15,8), %rax
leaq -0x1(%r12), %rcx
movq %rcx, (%rsp)
imulq $0x70, %r12, %r13
leaq (%rax,%r13), %rdi
addq $-0x70, %rdi
movq (%rdi), %rax
leaq 0x28(%rsp), %rsi
callq *0x20(%rax)
movq 0x10(%rsp), %rbp
movq (%rbp,%r15,8), %rax
imulq $0x88, %r12, %r12
leaq (%r12,%rax), %rdi
addq $-0x88, %rdi
movq (%rdi), %rax
leaq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq *0x8(%rax)
movq (%rbp,%r15,8), %rax
leaq (%rax,%r12), %rdi
movq (%rax,%r12), %rax
leaq 0x20(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq *0x8(%rax)
imulq $0x70, (%rsp), %rbp
xorl %r12d, %r12d
cmpq $0x4, %r12
je 0x2ba9
cvtsi2sdl (%r14,%r12,8), %xmm2
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 0x24d4(%rip), %xmm1     # 0x5028
addsd %xmm2, %xmm2
addsd 0x24b0(%rip), %xmm2     # 0x5010
mulsd %xmm1, %xmm2
movq (%rbx,%r15,8), %rax
leaq (%rax,%rbp), %rdi
leaq (%rax,%r13), %rcx
addsd -0x68(%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
addq %r13, %rax
movsd %xmm1, 0x8(%rax,%r12,8)
incq %r12
jmp 0x2b1b
movq 0x18(%rsp), %rcx
incq %rcx
movq 0x8(%rsp), %rdi
jmp 0x2a88
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tlestang[P]IW_gene/Walls.cpp
// Function: BottomWall::BottomWall(int const*)
BottomWall::BottomWall(const int d[2])
{
  nbNodes = d[0];
  nodes = new int*[nbNodes];
  for (int i=0;i<nbNodes;i++)
    {nodes[i] = new int[2];}

  int cc = 0;

  for (int x=0;x<d[0];x++)
    {
      nodes[cc][0] = x; nodes[cc][1] = 0;
      cc += 1;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x5156(%rip), %rax      # 0x7d38
movq %rax, (%rdi)
movslq (%rsi), %r12
leaq (,%r12,8), %rax
testq %r12, %r12
movl %r12d, 0x8(%rdi)
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, 0x10(%r14)
xorl %r13d, %r13d
testl %r12d, %r12d
movl $0x0, %ebp
cmovgl %r12d, %ebp
pushq $0x8
popq %r15
cmpq %r13, %rbp
je 0x2c34
movq %r15, %rdi
callq 0x2030
movq 0x10(%r14), %rcx
movq %rax, (%rcx,%r13,8)
incq %r13
jmp 0x2c1a
movq 0x10(%r14), %rax
xorl %ecx, %ecx
cmpl %ecx, %r12d
jle 0x2c51
movq (%rax,%rcx,8), %rdx
movl %ecx, (%rdx)
andl $0x0, 0x4(%rdx)
incq %rcx
movl (%rbx), %r12d
jmp 0x2c3a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x10(%rdi), %rcx
xorl %esi, %esi
cmpq %rax, %rsi
jge 0x2d0a
movq (%rcx,%rsi,8), %rdi
movslq (%rdi), %r8
movslq 0x4(%rdi), %rdi
movq (%rdx,%r8,8), %r8
imulq $0x88, %rdi, %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
jmp 0x2ccc
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdx, %rbx
movq %rsi, 0x10(%rsp)
xorl %ecx, %ecx
leaq 0x2425(%rip), %r14      # 0x5150
movq %rdi, 0x8(%rsp)
movslq 0x8(%rdi), %rax
cmpq %rax, %rcx
jge 0x2e66
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
imulq $0x88, %rbp, %rbp
movl $0x88, %ecx
leaq (%rcx,%rbp), %rdi
addq %rax, %rdi
movq 0x88(%rbp,%rax), %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)
imulq $0x70, (%rsp), %rbp
xorl %r12d, %r12d
cmpq $0x4, %r12
je 0x2e54
cvtsi2sdl (%r14,%r12,8), %xmm2
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 0x2229(%rip), %xmm1     # 0x5028
addsd %xmm2, %xmm2
addsd 0x2205(%rip), %xmm2     # 0x5010
mulsd %xmm1, %xmm2
movq (%rbx,%r15,8), %rax
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
addq %r13, %rax
movsd %xmm1, 0x8(%rax,%r12,8)
incq %r12
jmp 0x2dc6
movq 0x18(%rsp), %rcx
incq %rcx
movq 0x8(%rsp), %rdi
jmp 0x2d30
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rbx
movsd 0x20(%rdi), %xmm0
movq %rsp, %rax
movsd %xmm0, (%rax)
andq $0x0, 0x8(%rax)
movsd 0x28(%rdi), %xmm0
divsd 0x18(%rdi), %xmm0
movsd %xmm0, 0x18(%rsp)
xorl %r15d, %r15d
pushq $0x66
popq %rbp
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0x3b0b
xorl %r12d, %r12d
xorl %r13d, %r13d
xorl %r14d, %r14d
movslq 0x4(%rbx), %rax
cmpq %rax, %r14
jge 0x3b03
movq 0x60(%rbx), %rax
movq (%rax,%r15,8), %rdi
movsd 0x18(%rbx), %xmm1
movq (%rdi,%r12), %rax
addq %r12, %rdi
pushq $0x66
popq %rsi
movsd 0x15a7(%rip), %xmm0     # 0x5010
movq %rsp, %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 %ebp, %esi
movsd 0x1583(%rip), %xmm0     # 0x5010
movq %rsp, %rdx
callq *0x18(%rax)
cvtsi2sd %r14d, %xmm0
mulsd 0x18(%rsp), %xmm0
movq 0x50(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r14,8)
movsd %xmm0, 0x20(%rsp)
movq 0x70(%rbx), %rax
movq (%rax,%r15,8), %rdi
movsd 0x18(%rbx), %xmm1
movq (%rdi,%r13), %rax
addq %r13, %rdi
movl %ebp, %esi
movq %rsp, %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 %ebp, %esi
movsd 0x20(%rsp), %xmm0
movq %rsp, %rdx
callq *0x18(%rax)
incq %r14
addq $0x70, %r13
addq $0x88, %r12
jmp 0x3a3d
incq %r15
jmp 0x3a28
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
imulq $0x88, %rbx, %r15
addq (%rax,%r11,8), %r15
movabsq $0x1, %r12
leaq 0x14fa(%rip), %r13      # 0x5050
cmpq $0xa, %r12
je 0x3b9d
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
movsd (%r15,%r12,8), %xmm0
movslq %r8d, %rax
movslq %edx, %rdx
imulq $0x88, %rdx, %rdx
addq (%r14,%rax,8), %rdx
movsd %xmm0, (%rdx,%r12,8)
incq %r12
jmp 0x3b56
movq 0x70(%rdi), %rax
movq 0x78(%rdi), %r8
imulq $0x70, %rbx, %rbx
addq (%rax,%r11,8), %rbx
movabsq $0x1, %r11
leaq 0x1472(%rip), %r14      # 0x5030
cmpq $0x5, %r11
je 0x3c01
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
movsd (%rbx,%r11,8), %xmm0
movslq %edi, %rax
movslq %edx, %rdx
imulq $0x70, %rdx, %rdx
addq (%r8,%rax,8), %rdx
movsd %xmm0, (%rdx,%r11,8)
incq %r11
jmp 0x3bbe
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1312(%rip), %xmm1     # 0x5180
cvtsi2sd %edx, %xmm2
movapd %xmm2, 0x10(%rsp)
divsd %xmm0, %xmm1
cvtsi2sd %esi, %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
callq 0x2070
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 0x2070
mulsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movapd 0x10(%rsp), %xmm0
xorpd 0x1309(%rip), %xmm0     # 0x51e0
divsd 0x8(%rsp), %xmm0
callq 0x2260
mulsd (%rsp), %xmm0
addsd 0x1121(%rip), %xmm0     # 0x5010
mulsd 0x20(%rbx), %xmm0
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x125a(%rip), %xmm2     # 0x5180
cvtsi2sd %edx, %xmm1
movapd %xmm1, 0x10(%rsp)
divsd %xmm0, %xmm2
movsd %xmm2, 0x28(%rsp)
cvtsi2sd %esi, %xmm0
mulsd %xmm2, %xmm0
movsd %xmm0, 0x20(%rsp)
callq 0x2070
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 0x2290
mulsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movapd 0x10(%rsp), %xmm0
xorpd 0x1246(%rip), %xmm0     # 0x51e0
divsd 0x8(%rsp), %xmm0
callq 0x2260
movsd %xmm0, 0x10(%rsp)
movsd 0x30(%rbx), %xmm0
divsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x2070
mulsd 0x8(%rsp), %xmm0
addsd 0x103b(%rip), %xmm0     # 0x5010
movsd 0x10(%rsp), %xmm1
mulsd (%rsp), %xmm1
mulsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x70(%rdi), %rdi
pushq $0x8
popq %r14
movq %r14, %rsi
callq 0x2170
movq 0x78(%rbx), %rdi
movq %r14, %rsi
callq 0x2170
movq 0x60(%rbx), %rdi
movq %r14, %rsi
callq 0x2170
movq 0x68(%rbx), %rdi
movq %r14, %rsi
callq 0x2170
movq 0x80(%rbx), %rdi
pushq $0x18
popq %rsi
callq 0x2170
movq 0x88(%rbx), %rdi
pushq $0x20
popq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2170
// File: /workspace/github_cpp_makefile_star2_O2/funny-falcon[P]fanom_hash/./lucky777.h
// Function: lucky777_permute_string(unsigned char const*, unsigned long, unsigned int, unsigned int, unsigned int)
static uint32_t
lucky777_permute_string(const uint8_t *v, size_t len, uint32_t seed1, uint32_t seed2, uint32_t seed3)
{
	uint32_t a=seed1;
	uint32_t b=seed2;
	uint32_t l = len << 24;
	uint32_t t = 0;
	for (;len > 3; len-=4, v+=4) {
		t = lucky777_load_u32(v);
		lucky777_permute(t, &a, &b);
	}
	if (len) l |= lucky777_load_u24(v, len);
	lucky777_permute(l, &a, &b);
	/* note: next line is quite optional. Just last insane "sanity" option.
	 * It could be ommited, or could be `b ^= seed3`, or you could modify a
	 * instead. */
	b += seed3;
	return lucky777_finalize(a, b);
}

// Assembly:
movq %rsi, %rax
cmpq $0x4, %rax
jb 0x2e62
addl (%rdi), %edx
xorl %edx, %ecx
roll $0x7, %edx
addl %ecx, %edx
roll $0x19, %ecx
xorl %edx, %ecx
roll $0x7, %edx
addq $-0x4, %rax
addq $0x4, %rdi
jmp 0x2e41
shll $0x18, %esi
testq %rax, %rax
je 0x2e8d
movzbl (%rdi), %r9d
movq %rax, %r10
shrq %r10
movzbl (%rdi,%r10), %r10d
shll $0x8, %r10d
orl %r9d, %r10d
movzbl -0x1(%rdi,%rax), %eax
shll $0x10, %eax
orl %r10d, %eax
orl %eax, %esi
addl %edx, %esi
xorl %esi, %ecx
roll $0x7, %esi
addl %ecx, %esi
roll $0x19, %ecx
xorl %esi, %ecx
roll $0x7, %esi
addl %r8d, %ecx
xorl %ecx, %esi
movl %ecx, %edx
roll $0x1d, %edx
addl %esi, %edx
movl %edx, %esi
roll $0x5, %esi
xorl %edx, %ecx
addl %ecx, %esi
xorl %esi, %edx
movl %esi, %eax
roll $0x18, %eax
addl %edx, %eax
xorl %eax, %esi
roll $0x10, %eax
addl %esi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/kuszmaul[P]6886/clock.c
// Function: main
int main (int argc __attribute__((unused)), char *argv[] __attribute__((unused))) {
    struct timespec start, end;
    {
	int r = clock_gettime(CLOCK_MONOTONIC, &start);
	assert(r==0);
    }
    int N = 10000000;
    for (int i=0; i<N; i++) {
	struct timespec now;
	int r = clock_gettime(CLOCK_MONOTONIC, &now);
	assert(r==0);
    }
    clock_gettime(CLOCK_MONOTONIC, &end);
    double tdiff = ((end.tv_sec-start.tv_sec)
		    + 1e-9*(end.tv_nsec-start.tv_nsec));
    printf("Time %.6fs (%gns per call to clock_gettime(CLOCK_MONOTONIC,...)\n",
	   tdiff, 1e9*(tdiff/(double)N));
    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
pushq $0x1
popq %rdi
movq %rsp, %rsi
callq 0x1030
testl %eax, %eax
jne 0x1217
movl $0x989680, %ebp         # imm = 0x989680
pushq $0x1
popq %rbx
leaq 0x10(%rsp), %r14
subl $0x1, %ebp
jb 0x11b4
movl %ebx, %edi
movq %r14, %rsi
callq 0x1030
testl %eax, %eax
je 0x1184
leaq 0xe82(%rip), %rdi       # 0x2020
leaq 0xe80(%rip), %rsi       # 0x2025
leaq 0xe81(%rip), %rcx       # 0x202d
pushq $0x10
popq %rdx
callq 0x1050
pushq $0x1
popq %rdi
leaq 0x10(%rsp), %rbx
movq %rbx, %rsi
callq 0x1030
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq (%rsp), %rax
cvtsi2sd %rax, %xmm1
subq 0x8(%rsp), %rcx
cvtsi2sd %rcx, %xmm0
mulsd 0xe22(%rip), %xmm0      # 0x2008
addsd %xmm1, %xmm0
movapd %xmm0, %xmm1
divsd 0xe1a(%rip), %xmm1      # 0x2010
mulsd 0xe1a(%rip), %xmm1      # 0x2018
leaq 0xe3f(%rip), %rdi       # 0x2044
movb $0x2, %al
callq 0x1040
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xe02(%rip), %rdi       # 0x2020
leaq 0xe00(%rip), %rsi       # 0x2025
leaq 0xe01(%rip), %rcx       # 0x202d
pushq $0xa
jmp 0x11ae
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2180
leaq -0x30(%rbp), %rdi
movq %rax, (%rdi)
callq 0x2120
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 0x1888(%rip), %rdx      # 0x530a
leaq -0xc0(%rbp), %r12
pushq $0x50
popq %rsi
movq %r12, %rdi
callq 0x2160
movups 0x187b(%rip), %xmm0     # 0x5316
movups %xmm0, (%r14)
movb $0x0, 0x10(%r14)
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x22e0
movq %r14, %rdi
callq 0x20b0
movw $0x2d, (%r14,%rax)
movq 0x10(%r15), %rsi
movq %r14, %rdi
callq 0x22e0
movq %r14, %rdi
callq 0x20b0
movw $0x5f, %r13w
movw %r13w, (%r14,%rax)
movq 0x18(%r15), %rsi
movq %r14, %rdi
callq 0x22e0
movq %r14, %rdi
callq 0x20b0
movw %r13w, (%r14,%rax)
movq %r14, %rdi
movq %r12, %rsi
callq 0x22e0
movq %r14, %rdi
callq 0x20b0
addq %r14, %rax
cmpl $0x4, %ebx
ja 0x3b7e
movl %ebx, %ecx
leaq 0x1666(%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 0x3b92
movups 0x1816(%rip), %xmm0     # 0x5353
movups %xmm0, (%rax)
movl $0x746164, 0xf(%rax)    # imm = 0x746164
jmp 0x3b92
movabsq $0x642e61727478655f, %rcx # imm = 0x642E61727478655F
jmp 0x3b88
movabsq $0x7461642e736575, %rcx # imm = 0x7461642E736575
movq %rcx, 0x5(%rax)
movabsq $0x7365756c6176705f, %rcx # imm = 0x7365756C6176705F
movq %rcx, (%rax)
jmp 0x3b92
movabsq $0x642e656c6261745f, %rcx # imm = 0x642E656C6261745F
jmp 0x3b88
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
// File: /workspace/github_cpp_makefile_star2_O2/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
je 0x2536
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0x6c(%rbx)
jne 0x2536
cmpl $0x1, %r15d
je 0x2517
cmpl $0x3, %r15d
je 0x24fc
cmpl $0x2, %r15d
jne 0x24c9
cmpl $0x10, 0x24(%rbx)
jg 0x2530
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2542
cmpl $0x10, 0x24(%rbx)
jle 0x24c9
jmp 0x2530
cmpl $0x11, 0x24(%rbx)
jg 0x2530
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2542
cmpl $0x12, 0x24(%rbx)
jl 0x24c9
jmp 0x2530
cmpl $0xf, 0x24(%rbx)
jg 0x2530
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2542
cmpl $0xf, 0x24(%rbx)
jle 0x24c9
movb $0x1, 0x6c(%rbx)
jmp 0x24c9
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ogghead[P]Moon_Boersma_Coe_CSCI2270_FinalProject/Blackjack.cpp
// Function: Blackjack::HitMe(player*, bool)
void Blackjack::HitMe(player* currentPlayer, bool secondHand)//this boolean checks
//if the hand to deal to is the 2nd one, if a player has split
{
    int index = deck.size() - 1;
    card* tmp = deck[index];

    if (secondHand == false) //if this was the first hand
    {
        currentPlayer->hand.push_back(tmp);
        if((tmp->value==11)&&(currentPlayer->handValue+11 > 21)) //if the ace being 11 would bust the player
        //than the ace would be worth 1
        {
            currentPlayer->handValue=currentPlayer->handValue+1;
        }
        else
        {
        currentPlayer->handValue=currentPlayer->handValue + tmp->value;
         if(currentPlayer->handValue>21){   //if the player busts, this would force them into stand position
             currentPlayer->stand=true;
         }
        }
    }

    else
    {
        currentPlayer->hand2.push_back(tmp);
        if((tmp->value==11)&&(currentPlayer->handValue2+11 > 21)){  //same as above but with hand 2
            currentPlayer->handValue2=currentPlayer->handValue2+1;
        }else{
        currentPlayer->handValue2=currentPlayer->handValue2 + tmp->value;
        }
         if(currentPlayer->handValue2>21){
             currentPlayer->stand2=true;
         }
    }

            //card counting math
    if (tmp->value == 2 || tmp->value == 3 || tmp->value == 4 ||
        tmp->value == 5 || tmp->value == 6)
        {
            cardCounter = cardCounter + 1;
        }
    else if (tmp->value == 7 || tmp->value == 8 || tmp->value == 9)
        {
            cardCounter = cardCounter;
        }
    else if (tmp->value >= 10)
        {
            cardCounter = cardCounter - 1;
        }
    deck.pop_back();
    //delete tmp;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
shlq $0x1d, %rcx
movabsq $-0x100000000, %rsi     # imm = 0xFFFFFFFF00000000
addq %rcx, %rsi
sarq $0x1d, %rsi
movq (%rax,%rsi), %rax
movq %rax, -0x20(%rbp)
testl %edx, %edx
je 0x25b7
leaq 0x50(%r14), %rdi
leaq -0x20(%rbp), %r15
movq %r15, %rsi
callq 0x2ad8
movq (%r15), %rax
movl (%rax), %eax
movl 0x4c(%r14), %ecx
cmpl $0xb, %ecx
pushq $0x1
popq %rdx
cmovll %eax, %edx
cmpl $0xb, %eax
cmovnel %eax, %edx
addl %ecx, %edx
movl %edx, 0x4c(%r14)
cmpl $0x16, %edx
jl 0x2600
movb $0x1, 0x6d(%r14)
jmp 0x2600
leaq 0x28(%r14), %rdi
leaq -0x20(%rbp), %r15
movq %r15, %rsi
callq 0x2ad8
movq (%r15), %rax
movl (%rax), %eax
cmpl $0xb, %eax
sete %dl
movl 0x24(%r14), %ecx
cmpl $0xb, %ecx
setge %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x25f0
incl %ecx
movl %ecx, 0x24(%r14)
pushq $-0x1
jmp 0x260a
addl %eax, %ecx
movl %ecx, 0x24(%r14)
cmpl $0x16, %ecx
jl 0x2600
movb $0x1, 0x6c(%r14)
leal -0x2(%rax), %ecx
cmpl $0x5, %ecx
jae 0x2610
pushq $0x1
popq %rax
addl %eax, 0x30(%rbx)
jmp 0x2618
leal -0x7(%rax), %ecx
cmpl $0x3, %ecx
jae 0x2628
addq $-0x8, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0xa, %eax
jge 0x25ec
jmp 0x2618
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x70
popq %r12
movq %r12, %rdi
callq 0x2160
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
andq $0x0, 0x8(%rax)
xorl %r15d, %r15d
movb %r15b, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
andq $0x0, 0x38(%rax)
movups %xmm0, 0x4c(%rax)
andw $0x0, 0x6c(%rax)
movups %xmm0, 0x5c(%rax)
andl $0x0, 0x20(%rax)
leaq -0x40(%rbp), %rsi
movq %rax, (%rsi)
movl $0x3e8, 0x40(%rax)      # imm = 0x3E8
addq $0x18, %r14
movq %r14, %rdi
callq 0x2b5c
xorl %edi, %edi
callq 0x2120
movl %eax, %edi
callq 0x2140
movq %r12, %rdi
callq 0x2160
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
andq $0x0, 0x8(%rax)
movb %r15b, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
andq $0x0, 0x38(%rax)
movups %xmm0, 0x4c(%rax)
andw $0x0, 0x6c(%rax)
movups %xmm0, 0x5c(%rax)
leaq -0x38(%rbp), %rsi
movq %rax, (%rsi)
movl $0x2, 0x20(%rax)
movq %r14, %rdi
callq 0x2b5c
pushq $0x1
popq %r13
pushq $0x3
popq %r15
leaq -0x30(%rbp), %r12
cmpl %ebx, %r13d
jge 0x276a
pushq $0x70
popq %rdi
callq 0x2160
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
andq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
andq $0x0, 0x38(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x4c(%rax)
movups %xmm0, 0x5c(%rax)
andw $0x0, 0x6c(%rax)
movq %rax, -0x30(%rbp)
callq 0x2050
cltd
idivl %r15d
incl %edx
movq -0x30(%rbp), %rax
movl %edx, 0x20(%rax)
movl $0x3e8, 0x40(%rax)      # imm = 0x3E8
movq %r14, %rdi
movq %r12, %rsi
callq 0x2b5c
incl %r13d
jmp 0x2707
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %r14
movq 0x28(%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x20(%rbp), %r15
movq %rax, (%r15)
addq $-0x8, 0x30(%rsi)
leaq 0x50(%rsi), %rdi
movq %r15, %rsi
callq 0x2ad8
movq (%r15), %rax
movl (%rax), %eax
subl %eax, 0x24(%rbx)
movl %eax, 0x4c(%rbx)
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2542
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2542
movl 0x44(%rbx), %eax
movl %eax, 0x68(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $0xa, %esi
jl 0x2876
movq 0x18(%rbx), %rax
movq (%rax), %rax
cmpl %esi, 0x40(%rax)
jl 0x2876
movl %esi, 0x44(%rax)
jmp 0x28ed
leaq -0x18(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x373b(%rip), %rdi      # 0x5fc8
leaq 0x17ce(%rip), %rsi      # 0x4062
callq 0x2150
movq %rax, %rdi
callq 0x20a0
movq 0x3720(%rip), %rdi      # 0x5fc8
leaq 0x17ca(%rip), %rsi      # 0x4079
callq 0x2150
movq %rax, %rdi
callq 0x20a0
movq 0x371d(%rip), %rdi      # 0x5fe0
leaq -0x28(%rbp), %rsi
callq 0x2040
leaq -0x28(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x2bd7
movq %rbx, %rdi
movl %eax, %esi
callq 0x2854
leaq -0x28(%rbp), %rdi
callq 0x2090
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
xorl %edx, %edx
cmpq %rcx, %rdx
je 0x29ce
movq (%rax,%rdx,8), %rsi
andl $0x0, 0x24(%rsi)
andl $0x0, 0x44(%rsi)
andl $0x0, 0x68(%rsi)
movq 0x30(%rsi), %rdi
cmpq 0x28(%rsi), %rdi
je 0x29b6
addq $-0x8, %rdi
movq %rdi, 0x30(%rsi)
movq (%rax,%rdx,8), %rsi
jmp 0x2992
addq $-0x8, %rdi
movq %rdi, 0x58(%rsi)
movq (%rax,%rdx,8), %rsi
movq 0x58(%rsi), %rdi
cmpq 0x50(%rsi), %rdi
jne 0x29aa
andw $0x0, 0x6c(%rsi)
movb $0x0, 0x48(%rsi)
incq %rdx
jmp 0x297d
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ogghead[P]Moon_Boersma_Coe_CSCI2270_FinalProject/Blackjack.cpp
// Function: Blackjack::show()
void Blackjack::show(){//end of round printing of hands
for(int z=2;z< players.size();z++){
        cout<<"Player "<< z << " has: "<<endl;
    for (int i = 0; i < players[z]->hand.size();i++)
            {
                cout << players[z]->hand[i]->name << " of " << players[z]->hand[i]->sui << endl;
            }
            cout << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x2
popq %r14
movq 0x35ce(%rip), %r15      # 0x5fc8
leaq 0x16a0(%rip), %r12      # 0x40a1
movq 0x20(%rbx), %rax
subq 0x18(%rbx), %rax
sarq $0x3, %rax
cmpq %r14, %rax
jbe 0x2aba
movq %r15, %rdi
leaq 0x1679(%rip), %rsi      # 0x4099
callq 0x2150
movq %rax, %rdi
movl %r14d, %esi
callq 0x21b0
movq %rax, %rdi
leaq 0x177d(%rip), %rsi      # 0x41b7
callq 0x2150
movq %rax, %rdi
callq 0x20a0
xorl %r13d, %r13d
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rcx
movq 0x28(%rcx), %rax
movq 0x30(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
jbe 0x2aaa
movq (%rax,%r13,8), %rsi
addq $0x28, %rsi
movq %r15, %rdi
callq 0x2110
movq %rax, %rdi
movq %r12, %rsi
callq 0x2150
movq 0x18(%rbx), %rcx
movq (%rcx,%r14,8), %rcx
movq 0x28(%rcx), %rcx
movq (%rcx,%r13,8), %rsi
addq $0x8, %rsi
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
callq 0x20a0
incq %r13
jmp 0x2a4a
movq %r15, %rdi
callq 0x20a0
incq %r14
jmp 0x2a01
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/test/test_idgenerator.cc
// Function: main
int main(){
	namespace idg = hm3::idgenerator;

	test( idg::IDGeneratorTS{ true },	"IDGeneratorTS@Hex"	);
	test( idg::IDGeneratorTS{ false },	"IDGeneratorTS@Dec"	);
	test( idg::IDGeneratorDate{},		"IDGeneratorDate"	);
}

// Assembly:
pushq %rbx
leaq 0xdb0(%rip), %rsi       # 0x2004
pushq $0x1
popq %rdi
pushq $0xa
popq %rbx
movl %ebx, %edx
callq 0x1283
leaq 0xdae(%rip), %rsi       # 0x2016
xorl %edi, %edi
movl %ebx, %edx
callq 0x1283
leaq 0xdb0(%rip), %rdi       # 0x2028
movl %ebx, %esi
callq 0x134a
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/test/test_idgenerator.cc
// Function: void test<hm3::idgenerator::IDGeneratorTS>(hm3::idgenerator::IDGeneratorTS, char const*, unsigned int)
void test(T id, const char *name, unsigned count = 10){
	std::cout	<< name
			<< '\n';

	for(unsigned i = 0; i < count; ++i)
		std::cout	<< std::setw (3) << i
				<< " => "
				<< id()
				<< '\n';
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r15d
leaq 0x7(%rsp), %rax
movb %dil, (%rax)
movq 0x2d35(%rip), %r14      # 0x3fd8
movq %r14, %rdi
callq 0x10b0
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x10c0
movl %r15d, %ebp
xorl %r15d, %r15d
leaq 0xd75(%rip), %r12       # 0x2038
leaq 0x8(%rsp), %r13
cmpq %r15, %rbp
je 0x1326
movq (%r14), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%r14,%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x1060
movq %rax, %rdi
movq %r12, %rsi
callq 0x10b0
movq %rax, %rbx
movq %r13, %rdi
leaq 0x7(%rsp), %rsi
callq 0x1464
movq %rbx, %rdi
movq %r13, %rsi
callq 0x10a0
movq %rax, %rdi
pushq $0xa
popq %rsi
callq 0x10c0
movq %r13, %rdi
callq 0x1050
incq %r15
jmp 0x12c8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1050
movq %rbx, %rdi
callq 0x1110
// File: /workspace/github_cpp_makefile_star2_O2/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
movb (%rdi), %r14b
pushq $0x30
popq %rsi
movq %rbx, %rdi
callq 0x10f0
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
cmpb $0x1, %r14b
jne 0x144d
movq $0x8, 0x10(%rax,%rdx)
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
jmp 0x1456
movq $0xa, 0x10(%rax,%rdx)
movl %ebp, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1060
// File: /workspace/github_cpp_makefile_star2_O2/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 0x10d0
callq 0x15b2
movq %rax, %r15
movq %rax, %rdx
shrq $0x20, %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x140c
leaq 0xb99(%rip), %rsi       # 0x203d
movq %rsp, %rdi
callq 0x10b0
movq %rsp, %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x140c
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1100
movq %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 %rsp, %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x1110
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %r14, %rdi
callq 0x10d0
callq 0x15b2
leaq 0xb27(%rip), %rsi       # 0x203f
movq %rax, %rdi
callq 0x15e8
movq %r14, %rdi
movq %rax, %rsi
callq 0x10b0
leaq 0xb0b(%rip), %rsi       # 0x203d
movq %rax, %rdi
callq 0x10b0
pushq $0x30
popq %rsi
movq %rax, %rdi
callq 0x10f0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rax
movq $0xa, 0x10(%r14,%rax)
callq 0x15b2
movl %eax, %esi
movq %r14, %rdi
callq 0x1060
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1100
movq %rsp, %rdi
callq 0x1040
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x1110
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/pokorj54[P]Pathfinder-utilities/src/CommandLine.cpp
// Function: CommandLine::HandleHelp(CommandLine::Arguments&)
void CommandLine::HandleHelp(Arguments & args)
{
    string cmd = args.PopFirstIfNotEmpty();
    args.ThrowIfNotEmpty();
    if(cmd == "")
    {
        vector<pair<string, string>> commands;
        for(const pair<string, pair<CommandLine::HandleCmd, string>> & c : cmdTranslation)
        {
            commands.push_back(make_pair(c.first, c.second.second));
        }
        sort(commands.begin(), commands.end());
        for(const pair<string,string> p : commands)
        {
            *output << p.first << " - " << p.second << endl;
        }
        return;
    }
    try
    {
        *output << cmdTranslation.at(cmd).second << endl;
    }
    catch(const out_of_range & e)
    {
        *output << "Unknown command" << endl;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rdi
callq 0x54ea
movq %r14, %rdi
callq 0x5532
leaq 0x3370(%rip), %rsi      # 0x83b8
leaq 0x18(%rsp), %rdi
callq 0x4ec3
testb %al, %al
je 0x50be
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
leaq 0x81ec(%rip), %rbp      # 0xd258
leaq 0x68(%rsp), %r15
leaq 0x38(%rsp), %r12
leaq 0x88(%rsp), %r13
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x50ec
leaq 0x8(%rbp), %rsi
movq %r12, %rdi
callq 0x5e2c
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x6160
movq %r14, %rdi
movq %r13, %rsi
callq 0x6eaa
movq %r13, %rdi
callq 0x5e66
movq %r12, %rdi
callq 0x5e7c
jmp 0x507e
movq 0x8(%rbx), %r14
leaq 0x817f(%rip), %rdi      # 0xd248
leaq 0x18(%rsp), %rsi
callq 0x6d9c
addq $0x10, %rax
movq %r14, %rdi
movq %rax, %rsi
callq 0x3200
movq %rax, %rdi
callq 0x3120
jmp 0x5164
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x7083
movq (%rsp), %r14
movq 0x8(%rsp), %rbp
leaq 0x58(%rsp), %r15
leaq 0x38(%rsp), %r12
leaq 0x32dc(%rip), %r13      # 0x83f0
cmpq %rbp, %r14
je 0x515c
movq %r12, %rdi
movq %r14, %rsi
callq 0x5e92
movq 0x8(%rbx), %rdi
movq %r12, %rsi
callq 0x3200
movq %rax, %rdi
movq %r13, %rsi
callq 0x3240
movq %rax, %rdi
movq %r15, %rsi
callq 0x3200
movq %rax, %rdi
callq 0x3120
movq %r12, %rdi
callq 0x5e66
addq $0x40, %r14
jmp 0x5114
movq %rsp, %rdi
callq 0x5ecc
leaq 0x18(%rsp), %rdi
callq 0x3110
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x51cf
movq %rax, %r14
jmp 0x520a
movq %rax, %r14
cmpl $0x1, %edx
jne 0x520a
movq %r14, %rdi
callq 0x30e0
movq 0x8(%rbx), %rdi
leaq 0x323b(%rip), %rsi      # 0x83e0
callq 0x3240
movq %rax, %rdi
callq 0x3120
callq 0x3370
jmp 0x5164
jmp 0x5182
movq %rax, %r14
callq 0x3370
jmp 0x520a
movq %rax, %rdi
callq 0x4094
jmp 0x51cf
movq %rax, %r14
jmp 0x5202
movq %rax, %r14
jmp 0x51e9
movq %rax, %r14
leaq 0x88(%rsp), %rdi
callq 0x5e66
leaq 0x38(%rsp), %rdi
callq 0x5e7c
jmp 0x5202
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x5e66
movq %rsp, %rdi
callq 0x5ecc
leaq 0x18(%rsp), %rdi
callq 0x3110
movq %r14, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x30(%rsp)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x547a
xorl %ebx, %ebx
movq %r15, %rdi
xorl %esi, %esi
callq 0x558e
movl %eax, 0xc(%rsp)
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x3110
movq 0x10(%r14), %r15
movslq %r15d, %rax
leaq (,%rax,4), %rcx
testl %eax, %eax
pushq $-0x1
popq %rdi
cmovnsq %rcx, %rdi
movl $0x0, %ebp
cmovgl %r15d, %ebp
callq 0x3030
movq %rax, %r13
cmpq %rbx, %rbp
je 0x5334
movq %r12, %rdi
movq %r14, %rsi
callq 0x547a
leal 0x1(%rbx), %esi
movq %r12, %rdi
callq 0x558e
movl %eax, (%r13,%rbx,4)
movq %r12, %rdi
callq 0x3110
incq %rbx
jmp 0x5307
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl 0xc(%rsp), %esi
movq %r13, %rdx
movl %r15d, %ecx
callq 0x4ac8
leaq 0x3066(%rip), %rsi      # 0x83b8
movq %r14, %rdi
callq 0x4ec3
testb %al, %al
je 0x536f
leaq 0x308f(%rip), %rsi      # 0x83f4
leaq 0x10(%rsp), %rdi
callq 0x33e0
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x307a(%rip), %rsi      # 0x83f9
callq 0x3240
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x3200
movq %rax, %rdi
callq 0x3120
leaq 0x10(%rsp), %rdi
callq 0x3110
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x53b6
jmp 0x53b6
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %rsi
cmpq %rbx, %rsi
je 0x54a8
movq %rdi, %r14
addq $0x10, %rsi
callq 0x32c0
movq %rbx, %rdi
callq 0x5df2
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x3130
movq %rax, %r14
movl 0x18(%rbx), %esi
movq %rax, %rdi
xorl %edx, %edx
callq 0x4ed0
leaq 0x7861(%rip), %rsi      # 0xcd28
movq 0x7b12(%rip), %rdx      # 0xcfe0
movq %r14, %rdi
callq 0x3390
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
cmpq %r14, %rsi
je 0x5512
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x32c0
movq %r14, %rdi
callq 0x5df2
jmp 0x5526
leaq 0x2e9f(%rip), %rsi      # 0x83b8
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x30d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebx
movq %rdi, %r14
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x5dfa
movl %eax, %ebp
movq %rsp, %r15
movq %r15, %rdi
movl %eax, %esi
callq 0x3afe
movq %r14, %rdi
movq %r15, %rsi
callq 0x5e16
movl %eax, %r12d
movq %r15, %rdi
callq 0x3110
testb %r12b, %r12b
jne 0x55e2
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x30
popq %rdi
callq 0x3130
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x4f58
leaq 0x7787(%rip), %rsi      # 0xcd88
leaq -0x624(%rip), %rdx      # 0x4fe4
movq %r12, %rdi
callq 0x3390
movq %rax, %r15
movq %r12, %rdi
callq 0x31c0
jmp 0x5670
movq %rax, %r15
cmpl $0x1, %edx
jne 0x5670
movq %r15, %rdi
callq 0x30e0
pushq $0x30
popq %rdi
callq 0x3130
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x4f58
leaq 0x773c(%rip), %rsi      # 0xcd88
leaq -0x66f(%rip), %rdx      # 0x4fe4
movq %r12, %rdi
callq 0x3390
movq %rax, %r15
jmp 0x566b
movq %rax, %r15
movq %r12, %rdi
callq 0x31c0
callq 0x3370
movq %r15, %rdi
callq 0x33c0
movq %rax, %rdi
callq 0x4094
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/combination.cpp
// Function: pictcore::Combination::SetMapSize(int, unsigned char)
void Combination::SetMapSize( int size, TrackType trackType )
{
    m_range = size;
    m_bitvec = new TrackType[ size ];

    memset( m_bitvec, trackType, size * sizeof( TrackType ) );
    if( OPEN == trackType )
    {
        m_openCount = size;
        m_model->GlobalZerosCount += size;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
movl %esi, 0x28(%rdi)
movslq %esi, %r15
movq %r15, %rdi
callq 0x6030
movq %rax, 0x20(%r14)
movq %rax, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x6260
testl %ebp, %ebp
jne 0x6b17
movl %ebx, 0x2c(%r14)
movq 0x38(%r14), %rax
addl %ebx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq