LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movsd 0x20(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x28(%rax), %xmm0
divsd 0x18(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x40(%rbp), %rcx
movl -0x34(%rbp), %eax
cmpl (%rcx), %eax
jge 0x6609
movl $0x0, -0x38(%rbp)
movq -0x40(%rbp), %rcx
movl -0x38(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x65f9
movq -0x40(%rbp), %rax
movq 0x60(%rax), %rcx
movslq -0x34(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movslq -0x38(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rdi
leaq -0x20(%rbp), %rdx
movsd 0x18(%rax), %xmm1
movq (%rdi), %rax
movl $0x66, %esi
movsd 0x2b0f(%rip), %xmm0     # 0x9028
callq *0x18(%rax)
movq -0x40(%rbp), %rax
movq 0x68(%rax), %rcx
movslq -0x34(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movslq -0x38(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rdi
leaq -0x20(%rbp), %rdx
movsd 0x18(%rax), %xmm1
movq (%rdi), %rax
movl $0x66, %esi
movsd 0x2ad5(%rip), %xmm0     # 0x9028
callq *0x18(%rax)
movq -0x40(%rbp), %rax
movsd -0x28(%rbp), %xmm0
cvtsi2sdl -0x38(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movq 0x50(%rax), %rcx
movslq -0x34(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x38(%rbp), %rdx
movsd %xmm0, (%rcx,%rdx,8)
movq 0x70(%rax), %rcx
movslq -0x34(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movslq -0x38(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rdi
movsd -0x30(%rbp), %xmm0
leaq -0x20(%rbp), %rdx
movsd 0x18(%rax), %xmm1
movq (%rdi), %rax
movl $0x66, %esi
callq *0x18(%rax)
movq -0x40(%rbp), %rax
movq 0x78(%rax), %rcx
movslq -0x34(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movslq -0x38(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rdi
movsd -0x30(%rbp), %xmm0
leaq -0x20(%rbp), %rdx
movsd 0x18(%rax), %xmm1
movq (%rdi), %rax
movl $0x66, %esi
callq *0x18(%rax)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x64d2
jmp 0x65fb
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x64bc
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x9, -0x14(%rbp)
jge 0x66ca
movq -0x30(%rbp), %rcx
movl -0xc(%rbp), %eax
movslq -0x14(%rbp), %rsi
leaq 0x2a17(%rip), %rdx      # 0x9060
addl (%rdx,%rsi,8), %eax
addl (%rcx), %eax
cltd
idivl (%rcx)
movl %edx, -0x18(%rbp)
movl -0x10(%rbp), %eax
movslq -0x14(%rbp), %rsi
leaq 0x29fe(%rip), %rdx      # 0x9060
addl 0x4(%rdx,%rsi,8), %eax
addl 0x4(%rcx), %eax
cltd
idivl 0x4(%rcx)
movq -0x30(%rbp), %rax
movl %edx, -0x1c(%rbp)
movq 0x60(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x10(%rbp), %rdx
imulq $0x88, %rdx, %rdx
addq %rdx, %rcx
movslq -0x14(%rbp), %rdx
movsd 0x8(%rcx,%rdx,8), %xmm0
movq 0x68(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movsd %xmm0, 0x8(%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x662d
movl $0x0, -0x20(%rbp)
cmpl $0x4, -0x20(%rbp)
jge 0x6768
movq -0x30(%rbp), %rcx
movl -0xc(%rbp), %eax
movslq -0x20(%rbp), %rsi
leaq 0x2953(%rip), %rdx      # 0x9040
addl (%rdx,%rsi,8), %eax
addl (%rcx), %eax
cltd
idivl (%rcx)
movl %edx, -0x24(%rbp)
movl -0x10(%rbp), %eax
movslq -0x20(%rbp), %rsi
leaq 0x293a(%rip), %rdx      # 0x9040
addl 0x4(%rdx,%rsi,8), %eax
addl 0x4(%rcx), %eax
cltd
idivl 0x4(%rcx)
movq -0x30(%rbp), %rax
movl %edx, -0x28(%rbp)
movq 0x70(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x10(%rbp), %rdx
imulq $0x70, %rdx, %rdx
addq %rdx, %rcx
movslq -0x20(%rbp), %rdx
movsd 0x8(%rcx,%rdx,8), %xmm0
movq 0x78(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movsd %xmm0, 0x8(%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x66d1
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x268e(%rip), %xmm0     # 0x91d8
mulsd 0x30(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movl (%rax), %ecx
subl $0x1, %ecx
cvtsi2sd %ecx, %xmm1
movsd 0x266b(%rip), %xmm0     # 0x91d0
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
cvtsi2sdl -0x10(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd 0x30(%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x30(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
mulsd %xmm1, %xmm0
callq 0x3090
movsd -0x58(%rbp), %xmm1
movq -0x40(%rbp), %rax
movaps %xmm0, %xmm2
movsd -0x50(%rbp), %xmm0
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x30(%rax), %xmm0
divsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x30(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
mulsd %xmm1, %xmm0
callq 0x3090
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
callq 0x33a0
movq -0x40(%rbp), %rax
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x20(%rax), %xmm0
movsd 0x23e3(%rip), %xmm1     # 0x9028
addsd -0x18(%rbp), %xmm1
mulsd %xmm1, %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movsd 0x2556(%rip), %xmm0     # 0x91d8
mulsd 0x30(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movl (%rax), %ecx
subl $0x1, %ecx
cvtsi2sd %ecx, %xmm1
movsd 0x2533(%rip), %xmm0     # 0x91d0
divsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
cvtsi2sdl -0x10(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
movsd 0x30(%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x40(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
mulsd %xmm1, %xmm0
callq 0x3090
movsd -0x68(%rbp), %xmm1
movq -0x50(%rbp), %rax
movaps %xmm0, %xmm2
movsd -0x60(%rbp), %xmm0
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0x20(%rax), %xmm0
mulsd 0x30(%rax), %xmm0
mulsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x40(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
mulsd %xmm1, %xmm0
callq 0x33d0
movaps %xmm0, %xmm1
movsd -0x58(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x38(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
callq 0x33a0
movq -0x50(%rbp), %rax
movsd %xmm0, -0x20(%rbp)
movsd 0x30(%rax), %xmm0
divsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x40(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
mulsd %xmm1, %xmm0
callq 0x3090
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd 0x2289(%rip), %xmm1     # 0x9028
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x70(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x6e60
movq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0x3230
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x6e80
movq -0x20(%rbp), %rdi
movl $0x8, %esi
callq 0x3230
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x6ea0
movq -0x28(%rbp), %rdi
movl $0x8, %esi
callq 0x3230
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x6ec0
movq -0x30(%rbp), %rdi
movl $0x8, %esi
callq 0x3230
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x6ee3
movq -0x38(%rbp), %rdi
movl $0x18, %esi
callq 0x3230
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x6f06
movq -0x40(%rbp), %rdi
movl $0x20, %esi
callq 0x3230
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
movl %r8d, 0x1c(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rax
shlq $0x18, %rax
movl %eax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x3, 0x28(%rsp)
jbe 0x3b77
movq 0x30(%rsp), %rdi
callq 0x3bd0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %edi
leaq 0x18(%rsp), %rsi
leaq 0x14(%rsp), %rdx
callq 0x3be0
movq 0x28(%rsp), %rax
subq $0x4, %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x30(%rsp)
jmp 0x3b30
cmpq $0x0, 0x28(%rsp)
je 0x3b98
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movl %eax, %esi
callq 0x3c80
orl 0x10(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %edi
leaq 0x18(%rsp), %rsi
leaq 0x14(%rsp), %rdx
callq 0x3be0
movl 0x1c(%rsp), %eax
addl 0x14(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x18(%rsp), %edi
movl 0x14(%rsp), %esi
callq 0x3ce0
addq $0x38, %rsp
retq
nopl (%rax)
// File: funny-falcon[P]fanom_hash/./lucky777.h
// Function: lucky777_permute(unsigned int, unsigned int*, unsigned int*)
static inline void
lucky777_permute(uint32_t v, uint32_t *a, uint32_t *b)
{
	*a += v;
	*b ^= *a;
	*a = l7_rotl(*a, 7) + *b;
	*b = l7_rotr(*b, 7) ^ *a;
	*a = l7_rotl(*a, 7);
}

// Assembly:
movl %edi, -0x4(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl -0x4(%rsp), %ecx
movq -0x10(%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x10(%rsp), %rax
movl (%rax), %ecx
movq -0x18(%rsp), %rax
xorl (%rax), %ecx
movl %ecx, (%rax)
movq -0x10(%rsp), %rax
movl (%rax), %ecx
shll $0x7, %ecx
movq -0x10(%rsp), %rax
movl (%rax), %eax
shrl $0x19, %eax
orl %eax, %ecx
movq -0x18(%rsp), %rax
addl (%rax), %ecx
movq -0x10(%rsp), %rax
movl %ecx, (%rax)
movq -0x18(%rsp), %rax
movl (%rax), %ecx
shll $0x19, %ecx
movq -0x18(%rsp), %rax
movl (%rax), %eax
shrl $0x7, %eax
orl %eax, %ecx
movq -0x10(%rsp), %rax
xorl (%rax), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movq -0x10(%rsp), %rax
movl (%rax), %ecx
shll $0x7, %ecx
movq -0x10(%rsp), %rax
movl (%rax), %eax
shrl $0x19, %eax
orl %eax, %ecx
movq -0x10(%rsp), %rax
movl %ecx, (%rax)
retq
nopw %cs:(%rax,%rax)
// File: funny-falcon[P]fanom_hash/./lucky777.h
// Function: lucky777_load_u24(unsigned char const*, unsigned int)
static inline uint32_t
lucky777_load_u24(const uint8_t *v, unsigned len)
{
	uint32_t x = v[0];
	x |= (uint32_t)v[len/2] << 8;
	x |= (uint32_t)v[len-1] << 16;
	return x;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movzbl (%rax), %eax
movl %eax, -0x10(%rsp)
movq -0x8(%rsp), %rax
movl -0xc(%rsp), %ecx
shrl %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
shll $0x8, %eax
orl -0x10(%rsp), %eax
movl %eax, -0x10(%rsp)
movq -0x8(%rsp), %rax
movl -0xc(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
shll $0x10, %eax
orl -0x10(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: funny-falcon[P]fanom_hash/./lucky777.h
// Function: lucky777_finalize(unsigned int, unsigned int)
static inline uint32_t
lucky777_finalize(uint32_t a, uint32_t b)
{
	a ^= b; a += l7_rotr(b, 3);
	b ^= a; b += l7_rotl(a, 5);
	a ^= b; a += l7_rotr(b, 8);
	b ^= a; b += l7_rotl(a, 16);
	return b;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movl -0x8(%rsp), %eax
xorl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x8(%rsp), %eax
shll $0x1d, %eax
movl -0x8(%rsp), %ecx
shrl $0x3, %ecx
orl %ecx, %eax
addl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
xorl -0x8(%rsp), %eax
movl %eax, -0x8(%rsp)
movl -0x4(%rsp), %eax
shll $0x5, %eax
movl -0x4(%rsp), %ecx
shrl $0x1b, %ecx
orl %ecx, %eax
addl -0x8(%rsp), %eax
movl %eax, -0x8(%rsp)
movl -0x8(%rsp), %eax
xorl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x8(%rsp), %eax
shll $0x18, %eax
movl -0x8(%rsp), %ecx
shrl $0x8, %ecx
orl %ecx, %eax
addl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
xorl -0x8(%rsp), %eax
movl %eax, -0x8(%rsp)
movl -0x4(%rsp), %eax
shll $0x10, %eax
movl -0x4(%rsp), %ecx
shrl $0x10, %ecx
orl %ecx, %eax
addl -0x8(%rsp), %eax
movl %eax, -0x8(%rsp)
movl -0x8(%rsp), %eax
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
leaq -0x20(%rbp), %rsi
callq 0x1030
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x118f
jmp 0x11ae
leaq 0xe82(%rip), %rdi       # 0x2018
leaq 0xe80(%rip), %rsi       # 0x201d
movl $0xa, %edx
leaq 0xe7c(%rip), %rcx       # 0x2025
callq 0x1050
movl $0x989680, -0x38(%rbp)  # imm = 0x989680
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x38(%rbp), %eax
jge 0x1209
movl $0x1, %edi
leaq -0x50(%rbp), %rsi
callq 0x1030
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
jne 0x11dd
jmp 0x11fc
leaq 0xe34(%rip), %rdi       # 0x2018
leaq 0xe32(%rip), %rsi       # 0x201d
movl $0x10, %edx
leaq 0xe2e(%rip), %rcx       # 0x2025
callq 0x1050
jmp 0x11fe
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x11bc
movl $0x1, %edi
leaq -0x30(%rbp), %rsi
callq 0x1030
movq -0x30(%rbp), %rax
subq -0x20(%rbp), %rax
cvtsi2sd %rax, %xmm1
movq -0x28(%rbp), %rax
subq -0x18(%rbp), %rax
cvtsi2sd %rax, %xmm0
movsd 0xdd7(%rip), %xmm2      # 0x2010
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x60(%rbp), %xmm0
movsd -0x60(%rbp), %xmm2
cvtsi2sdl -0x38(%rbp), %xmm1
divsd %xmm1, %xmm2
movsd 0xda7(%rip), %xmm1      # 0x2008
mulsd %xmm2, %xmm1
leaq 0xdd0(%rip), %rdi       # 0x203c
movb $0x2, %al
callq 0x1040
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
// File: 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
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x2160
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x20f0
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
movl $0x38, %edx
callq 0x2140
leaq -0xb0(%rbp), %rdi
movl $0x50, %esi
leaq 0x573d(%rip), %rdx      # 0xa28d
leaq -0x58(%rbp), %rcx
callq 0x2130
movq -0x8(%rbp), %rdi
leaq 0x5735(%rip), %rsi      # 0xa299
callq 0x2170
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x22f0
movq -0x8(%rbp), %rdi
leaq 0x5725(%rip), %rsi      # 0xa2aa
callq 0x22f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x22f0
movq -0x8(%rbp), %rdi
leaq 0x5702(%rip), %rsi      # 0xa2a8
callq 0x22f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x22f0
movq -0x8(%rbp), %rdi
leaq 0x56e1(%rip), %rsi      # 0xa2a8
callq 0x22f0
movq -0x8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x22f0
cmpl $0x0, -0x14(%rbp)
jne 0x4bf4
movq -0x8(%rbp), %rdi
leaq 0x56bf(%rip), %rsi      # 0xa2ac
callq 0x22f0
jmp 0x4c6c
cmpl $0x1, -0x14(%rbp)
jne 0x4c0c
movq -0x8(%rbp), %rdi
leaq 0x56b0(%rip), %rsi      # 0xa2b5
callq 0x22f0
jmp 0x4c6a
cmpl $0x2, -0x14(%rbp)
jne 0x4c24
movq -0x8(%rbp), %rdi
leaq 0x56a3(%rip), %rsi      # 0xa2c0
callq 0x22f0
jmp 0x4c68
cmpl $0x3, -0x14(%rbp)
jne 0x4c3c
movq -0x8(%rbp), %rdi
leaq 0x5696(%rip), %rsi      # 0xa2cb
callq 0x22f0
jmp 0x4c66
cmpl $0x4, -0x14(%rbp)
jne 0x4c54
movq -0x8(%rbp), %rdi
leaq 0x568b(%rip), %rsi      # 0xa2d8
callq 0x22f0
jmp 0x4c64
movq -0x8(%rbp), %rdi
leaq 0x568c(%rip), %rsi      # 0xa2eb
callq 0x22f0
jmp 0x4c66
jmp 0x4c68
jmp 0x4c6a
jmp 0x4c6c
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movb 0x6c(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x2925
cmpl $0x0, -0x14(%rbp)
jne 0x2872
jmp 0x2925
cmpl $0x2, -0x14(%rbp)
jne 0x28aa
movq -0x10(%rbp), %rax
cmpl $0x11, 0x24(%rax)
jge 0x2891
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x2930
movq -0x10(%rbp), %rax
cmpl $0x11, 0x24(%rax)
jl 0x28a8
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2ae0
jmp 0x291e
cmpl $0x1, -0x14(%rbp)
jne 0x28e2
movq -0x10(%rbp), %rax
cmpl $0x10, 0x24(%rax)
jge 0x28c9
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x2930
movq -0x10(%rbp), %rax
cmpl $0x10, 0x24(%rax)
jl 0x28e0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2ae0
jmp 0x291c
cmpl $0x3, -0x14(%rbp)
jne 0x291a
movq -0x10(%rbp), %rax
cmpl $0x12, 0x24(%rax)
jge 0x2901
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x2930
movq -0x10(%rbp), %rax
cmpl $0x12, 0x24(%rax)
jl 0x2918
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2ae0
jmp 0x291a
jmp 0x291c
jmp 0x291e
jmp 0x2920
jmp 0x2852
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x70, %edi
callq 0x2190
movq %rax, %rdi
movq %rdi, -0x48(%rbp)
callq 0x3670
movq -0x48(%rbp), %rax
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
movl $0x3e8, 0x40(%rax)      # imm = 0x3E8
addq $0x18, %rdi
leaq -0x18(%rbp), %rsi
callq 0x36d0
xorl %eax, %eax
movl %eax, %edi
callq 0x2150
movl %eax, %edi
callq 0x2170
movl $0x70, %edi
callq 0x2190
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
callq 0x3670
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x2, 0x20(%rax)
addq $0x18, %rdi
leaq -0x20(%rbp), %rsi
callq 0x36d0
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2c11
movl $0x70, %edi
callq 0x2190
movq %rax, %rdi
movq %rdi, -0x50(%rbp)
callq 0x3670
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x2050
movq -0x38(%rbp), %rdi
movl $0x3, %ecx
cltd
idivl %ecx
addl $0x1, %edx
movq -0x30(%rbp), %rax
movl %edx, 0x20(%rax)
movq -0x30(%rbp), %rax
movl $0x3e8, 0x40(%rax)      # imm = 0x3E8
addq $0x18, %rdi
leaq -0x30(%rbp), %rsi
callq 0x36d0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2bad
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
movl $0x1, %esi
callq 0x3620
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x3640
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
leaq -0x18(%rbp), %rsi
callq 0x3460
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x24(%rax), %ecx
movq -0x18(%rbp), %rax
subl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4c(%rax)
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x2930
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x2930
movq -0x10(%rbp), %rax
movl 0x44(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x68(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3850
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl $0xa, -0x1c(%rbp)
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x40(%rcx), %eax
jg 0x2dfd
movl -0xc(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2ec2
leaq -0x40(%rbp), %rdi
callq 0x21d0
movl $0x0, -0x44(%rbp)
movq 0x71b4(%rip), %rdi      # 0x9fc8
leaq 0x4247(%rip), %rsi      # 0x7062
callq 0x2180
movq %rax, -0x68(%rbp)
jmp 0x2e26
movq -0x68(%rbp), %rdi
movq 0x7187(%rip), %rsi      # 0x9fb8
callq 0x21a0
jmp 0x2e38
movq 0x7189(%rip), %rdi      # 0x9fc8
leaq 0x4233(%rip), %rsi      # 0x7079
callq 0x2180
movq %rax, -0x70(%rbp)
jmp 0x2e51
movq -0x70(%rbp), %rdi
movq 0x715c(%rip), %rsi      # 0x9fb8
callq 0x21a0
jmp 0x2e63
movq 0x7176(%rip), %rdi      # 0x9fe0
leaq -0x40(%rbp), %rsi
callq 0x2040
jmp 0x2e75
xorl %eax, %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
movl $0xa, %edx
callq 0x3870
movl %eax, -0x74(%rbp)
jmp 0x2e8c
movq -0x60(%rbp), %rdi
movl -0x74(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %esi
callq 0x2db0
jmp 0x2ea0
leaq -0x40(%rbp), %rdi
callq 0x20f0
jmp 0x2ecc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x20f0
jmp 0x2ed5
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x44(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x2230
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x18, %rdi
callq 0x3830
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x3148
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0x3850
movq -0x18(%rbp), %rdi
movq (%rax), %rax
movl $0x0, 0x24(%rax)
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0x3850
movq -0x18(%rbp), %rdi
movq (%rax), %rax
movl $0x0, 0x24(%rax)
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0x3850
movq -0x18(%rbp), %rdi
movq (%rax), %rax
movl $0x0, 0x44(%rax)
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0x3850
movq (%rax), %rax
movl $0x0, 0x68(%rax)
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0x3850
movq (%rax), %rdi
addq $0x28, %rdi
callq 0x3600
cmpq $0x0, %rax
je 0x30ae
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0x3850
movq (%rax), %rdi
addq $0x28, %rdi
callq 0x3640
jmp 0x306c
jmp 0x30b0
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0x3850
movq (%rax), %rdi
addq $0x50, %rdi
callq 0x3600
cmpq $0x0, %rax
je 0x30f2
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0x3850
movq (%rax), %rdi
addq $0x50, %rdi
callq 0x3640
jmp 0x30b0
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0x3850
movq -0x18(%rbp), %rdi
movq (%rax), %rax
movb $0x0, 0x6c(%rax)
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0x3850
movq -0x18(%rbp), %rdi
movq (%rax), %rax
movb $0x0, 0x6d(%rax)
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0x3850
movq (%rax), %rax
movb $0x0, 0x48(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2fdb
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x2, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x18, %rdi
callq 0x3830
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x32ee
movq 0x6e01(%rip), %rdi      # 0x9fc8
leaq 0x3ecb(%rip), %rsi      # 0x7099
callq 0x2180
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2220
movq %rax, %rdi
leaq 0x3f44(%rip), %rsi      # 0x712c
callq 0x2180
movq %rax, %rdi
movq 0x6dc1(%rip), %rsi      # 0x9fb8
callq 0x21a0
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0x3850
movq (%rax), %rdi
addq $0x28, %rdi
callq 0x3600
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x32cd
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0x3850
movq (%rax), %rdi
addq $0x28, %rdi
movslq -0x10(%rbp), %rsi
callq 0x3620
movq (%rax), %rsi
addq $0x28, %rsi
movq 0x6d61(%rip), %rdi      # 0x9fc8
callq 0x2140
movq %rax, %rdi
leaq 0x3e2b(%rip), %rsi      # 0x70a1
callq 0x2180
movq -0x18(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0x3850
movq (%rax), %rdi
addq $0x28, %rdi
movslq -0x10(%rbp), %rsi
callq 0x3620
movq -0x30(%rbp), %rdi
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x2140
movq %rax, %rdi
movq 0x6cfe(%rip), %rsi      # 0x9fb8
callq 0x21a0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3203
movq 0x6cf4(%rip), %rdi      # 0x9fc8
movq 0x6cdd(%rip), %rsi      # 0x9fb8
callq 0x21a0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x319b
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rax
leaq 0x7(%rsp), %rdi
movl $0x1, %esi
callq 0x1410
leaq 0xd4d(%rip), %rsi       # 0x2004
movl $0xa, %edx
movzbl 0x7(%rsp), %edi
callq 0x1300
leaq 0x6(%rsp), %rdi
xorl %esi, %esi
callq 0x1410
leaq 0xd3d(%rip), %rsi       # 0x2016
movl $0xa, %edx
movzbl 0x6(%rsp), %edi
callq 0x1300
leaq 0xd39(%rip), %rdi       # 0x2028
movl $0xa, %esi
callq 0x1430
xorl %eax, %eax
popq %rcx
retq
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movb %dil, %al
movb %al, 0x67(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movq 0x58(%rsp), %rsi
movq 0x2cb8(%rip), %rdi      # 0x3fd8
callq 0x10d0
movq %rax, %rdi
movl $0xa, %esi
callq 0x1100
movl $0x0, 0x50(%rsp)
movl 0x50(%rsp), %eax
cmpl 0x54(%rsp), %eax
jae 0x13f3
movl $0x3, %edi
callq 0x1530
movl %eax, 0x4c(%rsp)
movl 0x4c(%rsp), %esi
movq 0x2c77(%rip), %rdi      # 0x3fd8
callq 0x10f0
movq %rax, %rdi
movl 0x50(%rsp), %esi
callq 0x1110
movq %rax, %rdi
leaq 0xcbc(%rip), %rsi       # 0x2038
callq 0x10d0
movq %rax, (%rsp)
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x67(%rsp), %rsi
callq 0x1620
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x10c0
movq %rax, 0x10(%rsp)
jmp 0x13ae
movq 0x10(%rsp), %rdi
movl $0xa, %esi
callq 0x1100
jmp 0x13bf
leaq 0x28(%rsp), %rdi
callq 0x1080
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x133a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x1080
jmp 0x13f8
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x1150
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x40(%rsp), %rax
testb $0x1, (%rax)
je 0x15c5
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x30, %edi
callq 0x1710
movq 0x10(%rsp), %rdi
movb %al, 0x33(%rsp)
movzbl 0x33(%rsp), %esi
callq 0x1140
movq %rax, 0x18(%rsp)
movl $0x8, %edi
callq 0x1530
movq 0x18(%rsp), %rdi
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %esi
callq 0x10f0
movq %rax, %rdi
leaq 0x172(%rip), %rsi       # 0x1730
callq 0x1060
jmp 0x160b
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movl $0x30, %edi
callq 0x1710
movq (%rsp), %rdi
movb %al, 0x2b(%rsp)
movzbl 0x2b(%rsp), %esi
callq 0x1140
movq %rax, 0x8(%rsp)
movl $0xa, %edi
callq 0x1530
movq 0x8(%rsp), %rdi
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %esi
callq 0x10f0
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x1110
addq $0x48, %rsp
retq
nop
// File: 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:
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x1c0(%rsp)
movq %rsi, 0x1b8(%rsp)
movq 0x1b8(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x1120
callq 0x1750
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x1760
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl %eax, %edx
callq 0x1550
jmp 0x1687
leaq 0x9af(%rip), %rsi       # 0x203d
leaq 0x40(%rsp), %rdi
callq 0x10d0
jmp 0x169a
movq 0x38(%rsp), %rdi
callq 0x1770
movq 0x18(%rsp), %rdi
movl %eax, %edx
leaq 0x40(%rsp), %rsi
callq 0x1550
jmp 0x16b7
movq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x10e0
jmp 0x16c8
leaq 0x40(%rsp), %rdi
callq 0x1040
movq 0x10(%rsp), %rax
addq $0x1c8, %rsp            # imm = 0x1C8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x1040
movq 0x30(%rsp), %rdi
callq 0x1150
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
leaq 0x60(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x1120
callq 0x1750
movq %rax, %rdi
movq 0x27d6(%rip), %rsi      # 0x40c8
callq 0x1b30
movq 0x38(%rsp), %rdi
movq %rax, %rsi
callq 0x10d0
movq %rax, 0x40(%rsp)
jmp 0x190b
movq 0x40(%rsp), %rdi
leaq 0x726(%rip), %rsi       # 0x203d
callq 0x10d0
movq %rax, 0x20(%rsp)
jmp 0x1923
movl $0x30, %edi
callq 0x1710
movb %al, 0x1f(%rsp)
jmp 0x1933
movq 0x20(%rsp), %rdi
movb 0x1f(%rsp), %al
movb %al, 0x53(%rsp)
movzbl 0x53(%rsp), %esi
callq 0x1140
movq %rax, 0x10(%rsp)
jmp 0x1951
movl $0xa, %edi
callq 0x1530
movl %eax, 0xc(%rsp)
jmp 0x1961
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, 0x4c(%rsp)
movl 0x4c(%rsp), %esi
callq 0x10f0
movq %rax, (%rsp)
jmp 0x197d
callq 0x1750
movq %rax, %rdi
callq 0x1770
movq (%rsp), %rdi
movl %eax, %esi
callq 0x1110
jmp 0x1997
movq 0x28(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x10e0
jmp 0x19a8
leaq 0x60(%rsp), %rdi
callq 0x1040
movq 0x30(%rsp), %rax
addq $0x1e8, %rsp            # imm = 0x1E8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x1040
movq 0x58(%rsp), %rdi
callq 0x1150
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
leaq 0x9a3f(%rip), %rsi      # 0x111e2
callq 0x32e0
movq %rax, %rdi
movq (%rsp), %rax
movl 0x8(%rax), %esi
callq 0x3470
movq %rax, %rdi
leaq 0x9a33(%rip), %rsi      # 0x111f4
callq 0x32e0
movq (%rsp), %rax
testb $0x1, 0xc(%rax)
je 0x77e3
movq 0x8(%rsp), %rdi
leaq 0x9a43(%rip), %rsi      # 0x1121f
callq 0x32e0
jmp 0x77f4
movq 0x8(%rsp), %rdi
leaq 0x9a39(%rip), %rsi      # 0x11228
callq 0x32e0
movq 0x8(%rsp), %rdi
movq 0x107a8(%rip), %rsi     # 0x17fa8
callq 0x3310
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0xd8(%rsp), %rsi
leaq 0xb0(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x8320
movq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0x8570
movl %eax, 0x4c(%rsp)
jmp 0x7fc0
leaq 0xb0(%rsp), %rdi
callq 0x31f0
movl 0x4c(%rsp), %eax
movl %eax, 0xd4(%rsp)
movq 0xd8(%rsp), %rdi
callq 0x8560
movl %eax, 0xa0(%rsp)
movslq 0xa0(%rsp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3040
movq %rax, 0x98(%rsp)
movl $0x0, 0x94(%rsp)
movl 0x94(%rsp), %eax
cmpl 0xa0(%rsp), %eax
jge 0x80e9
movq 0xd8(%rsp), %rsi
leaq 0x70(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x8320
movq 0x28(%rsp), %rdi
movl 0x94(%rsp), %esi
incl %esi
callq 0x8570
movl %eax, 0x34(%rsp)
jmp 0x806c
movl 0x34(%rsp), %edx
movq 0x98(%rsp), %rax
movslq 0x94(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
leaq 0x70(%rsp), %rdi
callq 0x31f0
movl 0x94(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x94(%rsp)
jmp 0x8028
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x31f0
jmp 0x81bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x31f0
jmp 0x81bb
movl 0xd4(%rsp), %esi
movq 0x98(%rsp), %rdx
movl 0xa0(%rsp), %ecx
leaq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x6e50
movq 0x18(%rsp), %rdi
leaq 0x92a4(%rip), %rsi      # 0x113be
callq 0x7700
movb %al, 0x27(%rsp)
jmp 0x8125
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0x812f
jmp 0x8164
leaq 0x92c4(%rip), %rsi      # 0x113fa
leaq 0x50(%rsp), %rdi
callq 0x3370
jmp 0x8142
jmp 0x8164
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x31f0
jmp 0x81bb
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x928b(%rip), %rsi      # 0x113ff
callq 0x32e0
movq %rax, 0x10(%rsp)
jmp 0x8180
movq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x3290
movq %rax, 0x8(%rsp)
jmp 0x8196
movq 0x8(%rsp), %rdi
movq 0xfe06(%rip), %rsi      # 0x17fa8
callq 0x3310
jmp 0x81a9
leaq 0x50(%rsp), %rdi
callq 0x31f0
addq $0xe8, %rsp
retq
movq 0xa8(%rsp), %rdi
callq 0x3490
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x9b50
testb $0x1, %al
jne 0x8350
jmp 0x83a8
movl $0x10, %edi
callq 0x3160
movq %rax, %rdi
movq 0x20(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x8(%rsp)
movl 0x18(%rax), %esi
xorl %edx, %edx
callq 0x7730
jmp 0x8376
movq 0x8(%rsp), %rdi
leaq 0xf966(%rip), %rsi      # 0x17ce8
leaq -0xb49(%rip), %rdx      # 0x7840
callq 0x3450
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x3240
jmp 0x83ee
movq 0x20(%rsp), %rdi
movb $0x0, 0x2b(%rsp)
callq 0x9b70
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x3130
movq 0x20(%rsp), %rdi
callq 0x9ba0
movb $0x1, 0x2b(%rsp)
testb $0x1, 0x2b(%rsp)
jne 0x83e4
movq 0x10(%rsp), %rdi
callq 0x31f0
movq 0x18(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x3490
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x9b50
testb $0x1, %al
jne 0x8430
jmp 0x847b
leaq 0x37(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x34a0
movq 0x8(%rsp), %rdi
movq (%rsp), %rdx
leaq 0x8f70(%rip), %rsi      # 0x113be
callq 0x3380
jmp 0x8455
leaq 0x37(%rsp), %rdi
callq 0x3320
jmp 0x84b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x37(%rsp), %rdi
callq 0x3320
jmp 0x84c3
movq 0x18(%rsp), %rdi
movb $0x0, 0x23(%rsp)
callq 0x9b70
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x3130
movq 0x18(%rsp), %rdi
callq 0x9ba0
movb $0x1, 0x23(%rsp)
testb $0x1, 0x23(%rsp)
jne 0x84b7
movq 0x8(%rsp), %rdi
callq 0x31f0
jmp 0x84b9
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x3490
nopl (%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movq 0x70(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x9c00
movl %eax, 0x2c(%rsp)
jmp 0x8596
movl 0x2c(%rsp), %eax
movl %eax, 0x68(%rsp)
jmp 0x8647
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
movl 0x5c(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x86e6
movq 0x60(%rsp), %rdi
callq 0x3110
movq %rax, 0x50(%rsp)
movl $0x30, %edi
callq 0x3160
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq 0x70(%rsp), %rsi
movl 0x6c(%rsp), %edx
callq 0x78c0
jmp 0x85f6
movq 0x20(%rsp), %rdi
leaq 0xf776(%rip), %rsi      # 0x17d78
leaq -0xc49(%rip), %rdx      # 0x79c0
callq 0x3450
jmp 0x86f8
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
callq 0x3240
jmp 0x863b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
callq 0x3430
jmp 0x8642
jmp 0x86e6
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x68(%rsp), %esi
leaq 0x30(%rsp), %rdi
callq 0x41e0
movq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x9c50
movb %al, 0x1f(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x31f0
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x8686
jmp 0x86dd
movl $0x30, %edi
callq 0x3160
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rsi
movl 0x6c(%rsp), %edx
callq 0x78c0
jmp 0x86ab
movq 0x8(%rsp), %rdi
leaq 0xf6c1(%rip), %rsi      # 0x17d78
leaq -0xcfe(%rip), %rdx      # 0x79c0
callq 0x3450
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
callq 0x3240
jmp 0x86e6
movl 0x68(%rsp), %eax
addq $0x78, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x3490
movq %rax, %rdi
callq 0x5240
nopl (%rax,%rax)