LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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), %r11d
movl 0x4(%rdi), %ebx
movq 0x60(%rdi), %rax
movslq %esi, %r9
movslq %edx, %r10
movq 0x68(%rdi), %r14
movq %r10, %rdx
shlq $0x7, %rdx
leaq (%rdx,%r10,8), %r15
addq (%rax,%r9,8), %r15
movl $0x1, %r12d
leaq 0x23f7(%rip), %r13      # 0x6050
movl -0x8(%r13,%r12,8), %eax
addl %esi, %eax
addl %r11d, %eax
cltd
idivl %r11d
movl %edx, %r8d
movl -0x4(%r13,%r12,8), %eax
addl %ecx, %eax
addl %ebx, %eax
cltd
idivl %ebx
movslq %r8d, %rax
movslq %edx, %rdx
movq %rdx, %r8
shlq $0x7, %r8
leaq (%r8,%rdx,8), %rdx
addq (%r14,%rax,8), %rdx
movsd (%r15,%r12,8), %xmm0
movsd %xmm0, (%rdx,%r12,8)
incq %r12
cmpq $0xa, %r12
jne 0x3c59
movl (%rdi), %r8d
movl 0x4(%rdi), %r11d
movq 0x70(%rdi), %rax
movq 0x78(%rdi), %rbx
imulq $0x70, %r10, %r10
addq (%rax,%r9,8), %r10
movl $0x1, %r9d
leaq 0x236c(%rip), %r14      # 0x6030
movl -0x8(%r14,%r9,8), %eax
addl %esi, %eax
addl %r8d, %eax
cltd
idivl %r8d
movl %edx, %edi
movl -0x4(%r14,%r9,8), %eax
addl %ecx, %eax
addl %r11d, %eax
cltd
idivl %r11d
movslq %edi, %rax
movslq %edx, %rdx
imulq $0x70, %rdx, %rdx
addq (%rbx,%rax,8), %rdx
movsd (%r10,%r9,8), %xmm0
movsd %xmm0, (%rdx,%r9,8)
incq %r9
cmpq $0x5, %r9
jne 0x3cc4
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2202(%rip), %xmm1     # 0x6180
cvtsi2sd %edx, %xmm2
movapd %xmm2, 0x10(%rsp)
divsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
callq 0x2080
mulsd (%rsp), %xmm0
movapd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
movsd 0x30(%rbx), %xmm0
divsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x2080
mulsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movapd 0x10(%rsp), %xmm0
xorpd 0x21f6(%rip), %xmm0     # 0x61e0
divsd 0x8(%rsp), %xmm0
callq 0x2290
mulsd (%rsp), %xmm0
addsd 0x200e(%rip), %xmm0     # 0x6010
mulsd 0x20(%rbx), %xmm0
addq $0x30, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2146(%rip), %xmm2     # 0x6180
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
movapd %xmm1, 0x10(%rsp)
divsd %xmm0, %xmm2
movsd %xmm2, 0x28(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
mulsd %xmm2, %xmm0
movsd %xmm0, 0x20(%rsp)
callq 0x2080
mulsd (%rsp), %xmm0
movapd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
movsd 0x20(%rbx), %xmm0
mulsd 0x30(%rbx), %xmm0
mulsd 0x28(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x22c0
mulsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movapd 0x10(%rsp), %xmm0
xorpd 0x212c(%rip), %xmm0     # 0x61e0
divsd 0x8(%rsp), %xmm0
callq 0x2290
movsd %xmm0, 0x10(%rsp)
movsd 0x30(%rbx), %xmm0
divsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x2080
mulsd 0x8(%rsp), %xmm0
addsd 0x1f21(%rip), %xmm0     # 0x6010
movsd 0x10(%rsp), %xmm1
mulsd (%rsp), %xmm1
mulsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/tlestang[P]IW_gene/LatticeBoltzmann.cpp
// Function: LatticeBoltzmann::~LatticeBoltzmann()
LatticeBoltzmann::~LatticeBoltzmann()
{
  delete thermalSites;
  delete thermalSites_;
  delete velSites;
  delete velSites_;
  
  delete w;
  delete topo;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x70(%rdi), %rdi
testq %rdi, %rdi
je 0x4167
movl $0x8, %esi
callq 0x21a0
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x417a
movl $0x8, %esi
callq 0x21a0
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x418d
movl $0x8, %esi
callq 0x21a0
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x41a0
movl $0x8, %esi
callq 0x21a0
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x41b6
movl $0x18, %esi
callq 0x21a0
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x41cd
movl $0x20, %esi
popq %rbx
jmp 0x21a0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %rsi
jb 0x2f87
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
cmpq $0x3, %rax
ja 0x2f68
shll $0x18, %esi
testq %rax, %rax
je 0x2fb4
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 %esi, %eax
movl %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
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x28, %rsp
leaq 0x8(%rsp), %rsi
movl $0x1, %edi
callq 0x1030
testl %eax, %eax
jne 0x121b
movl $0x989680, %ebp         # imm = 0x989680
leaq 0x18(%rsp), %rbx
movl $0x1, %edi
movq %rbx, %rsi
callq 0x1030
testl %eax, %eax
jne 0x11fc
decl %ebp
jne 0x1183
leaq 0x18(%rsp), %rbx
movl $0x1, %edi
movq %rbx, %rsi
callq 0x1030
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq 0x8(%rsp), %rax
cvtsi2sd %rax, %xmm1
subq 0x10(%rsp), %rcx
cvtsi2sd %rcx, %xmm0
mulsd 0xe3b(%rip), %xmm0      # 0x2008
addsd %xmm1, %xmm0
movapd %xmm0, %xmm1
divsd 0xe33(%rip), %xmm1      # 0x2010
mulsd 0xe33(%rip), %xmm1      # 0x2018
leaq 0xe58(%rip), %rdi       # 0x2044
movb $0x2, %al
callq 0x1040
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
leaq 0xe1d(%rip), %rdi       # 0x2020
leaq 0xe1b(%rip), %rsi       # 0x2025
leaq 0xe1c(%rip), %rcx       # 0x202d
movl $0x10, %edx
callq 0x1050
leaq 0xdfe(%rip), %rdi       # 0x2020
leaq 0xdfc(%rip), %rsi       # 0x2025
leaq 0xdfd(%rip), %rcx       # 0x202d
movl $0xa, %edx
callq 0x1050
// File: /workspace/github_cpp_makefile_star2_O1/ashlall[P]StreamStats/ChiSquareExperiments/VaryMemoryCategorical.cpp
// Function: name_file(char*, char**, int)
void name_file(char *str, char* argv[], int extra)
{
  time_t now = time(0);
  struct tm tstruct;
  char buf[80];
  tstruct = *localtime(&now);
  strftime(buf, sizeof(buf), "%m-%d-%Y.%X", &tstruct);

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x20(%rsi), %r15d
testl %r15d, %r15d
sete %al
orb 0x6c(%rsi), %al
je 0x27bc
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x1, %r15d
je 0x2819
cmpl $0x3, %r15d
je 0x27ef
cmpl $0x2, %r15d
jne 0x280c
cmpl $0x10, 0x24(%rbx)
jg 0x27e7
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2834
cmpl $0x10, 0x24(%rbx)
jg 0x2808
jmp 0x280c
cmpl $0x11, 0x24(%rbx)
jg 0x2802
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2834
cmpl $0x12, 0x24(%rbx)
jl 0x280c
movb $0x1, 0x6c(%rbx)
cmpb $0x0, 0x6c(%rbx)
jne 0x27b1
testl %r15d, %r15d
jne 0x27c2
jmp 0x27b1
cmpl $0xf, 0x24(%rbx)
jg 0x282c
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2834
cmpl $0xf, 0x24(%rbx)
jg 0x2808
jmp 0x280c
// File: /workspace/github_cpp_makefile_star2_O1/ogghead[P]Moon_Boersma_Coe_CSCI2270_FinalProject/Blackjack.cpp
// Function: Blackjack::createPlayers(int)
void Blackjack::createPlayers(int playerNumber)
{
    player* me = new player;
    me->orientation = 0;
    me->totalMoney = 1000;

    players.push_back(me);

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x70, %edi
callq 0x2140
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movb $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movq %rcx, 0x38(%rax)
movups %xmm0, 0x4c(%rax)
movups %xmm0, 0x5c(%rax)
movw $0x0, 0x6c(%rax)
movq %rax, -0x40(%rbp)
movl $0x0, 0x20(%rax)
movl $0x3e8, 0x40(%rax)      # imm = 0x3E8
leaq 0x18(%r14), %r15
movq 0x20(%r14), %rsi
cmpq 0x28(%r14), %rsi
je 0x29c6
movq %rax, (%rsi)
addq $0x8, 0x20(%r14)
jmp 0x29d2
leaq -0x40(%rbp), %rdx
movq %r15, %rdi
callq 0x3208
xorl %r12d, %r12d
xorl %edi, %edi
callq 0x2100
movl %eax, %edi
callq 0x2120
movl $0x70, %edi
callq 0x2140
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq %r12, 0x8(%rax)
movb $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movq %r12, 0x38(%rax)
movups %xmm0, 0x4c(%rax)
movups %xmm0, 0x5c(%rax)
movw $0x0, 0x6c(%rax)
movq %rax, -0x38(%rbp)
movl $0x2, 0x20(%rax)
movq 0x20(%r14), %rsi
cmpq 0x28(%r14), %rsi
je 0x2a34
movq %rax, (%rsi)
addq $0x8, 0x20(%r14)
jmp 0x2a40
leaq -0x38(%rbp), %rdx
movq %r15, %rdi
callq 0x3208
cmpl $0x2, %ebx
jl 0x2ae1
decl %ebx
xorl %r13d, %r13d
leaq -0x30(%rbp), %r12
movl $0x70, %edi
callq 0x2140
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq %r13, 0x8(%rax)
movb $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movq %r13, 0x38(%rax)
movups %xmm0, 0x4c(%rax)
movups %xmm0, 0x5c(%rax)
movw $0x0, 0x6c(%rax)
movq %rax, -0x30(%rbp)
callq 0x2050
cltq
imulq $0x55555556, %rax, %rcx # imm = 0x55555556
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,2), %ecx
negl %ecx
addl %eax, %ecx
incl %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x20(%rax)
movl $0x3e8, 0x40(%rax)      # imm = 0x3E8
movq 0x20(%r14), %rsi
cmpq 0x28(%r14), %rsi
je 0x2ace
movq %rax, (%rsi)
addq $0x8, 0x20(%r14)
jmp 0x2ad9
movq %r15, %rdi
movq %r12, %rdx
callq 0x3208
decl %ebx
jne 0x2a52
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq 0x28(%rsi), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
addq $-0x8, 0x30(%rsi)
movq %rdi, %r14
movq 0x58(%rsi), %rsi
cmpq 0x60(%rbx), %rsi
je 0x2ba0
movq %rax, (%rsi)
addq $0x8, 0x58(%rbx)
jmp 0x2bad
leaq 0x50(%rbx), %rdi
leaq -0x18(%rbp), %rdx
callq 0x30ce
movq -0x18(%rbp), %rax
movl (%rax), %eax
subl %eax, 0x24(%rbx)
movl %eax, 0x4c(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x2834
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2834
movl 0x44(%rbx), %eax
movl %eax, 0x68(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ogghead[P]Moon_Boersma_Coe_CSCI2270_FinalProject/Blackjack.cpp
// Function: Blackjack::Bet(int)
void Blackjack::Bet(int bet)
{
    player* player = players[0];
    int minVal = 10;
    if (bet > player->totalMoney || bet < minVal)
    {
            string betN;
            int betNew=0;
            cout<<"That is an invalid bet"<<endl;
        cout<<"How much would you like to bet?"<<endl;
        getline(cin,betN);
        betNew=stoi(betN);
        Bet(betNew);
    }else{
    player->bet = bet;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $0xa, %esi
jl 0x2c13
movq 0x18(%rbx), %rax
movq (%rax), %rax
cmpl %esi, 0x40(%rax)
jl 0x2c13
movl %esi, 0x44(%rax)
jmp 0x2d3f
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x43a3(%rip), %r14      # 0x6fd0
leaq 0x2472(%rip), %rsi      # 0x50a6
movl $0x16, %edx
movq %r14, %rdi
callq 0x2160
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq 0x4371(%rip), %rdi      # 0x6fd0
callq 0x2030
movq %rax, %rdi
callq 0x20c0
movq 0x435d(%rip), %r14      # 0x6fd0
leaq 0x2443(%rip), %rsi      # 0x50bd
movl $0x1f, %edx
movq %r14, %rdi
callq 0x2160
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq 0x432b(%rip), %rdi      # 0x6fd0
callq 0x2030
movq %rax, %rdi
callq 0x20c0
movq 0x4327(%rip), %rdi      # 0x6fe0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %edx
movq 0x430c(%rip), %rdi      # 0x6fe0
leaq -0x48(%rbp), %rsi
callq 0x21f0
movq -0x48(%rbp), %r15
callq 0x2040
movq %rax, %r14
movl (%rax), %r13d
movl $0x0, (%rax)
leaq -0x50(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x2170
cmpq %r15, (%r12)
je 0x2d4e
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x2d5a
movl (%r14), %ecx
cmpl $0x22, %ecx
je 0x2d5a
testl %ecx, %ecx
jne 0x2d23
movl %r13d, (%r14)
movq %rbx, %rdi
movl %eax, %esi
callq 0x2be6
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x2d3f
callq 0x2110
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2395(%rip), %rdi      # 0x50ea
callq 0x20a0
leaq 0x2389(%rip), %rdi      # 0x50ea
callq 0x2180
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x2d77
movl %r13d, (%r14)
jmp 0x2d77
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x2d89
callq 0x2110
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/ogghead[P]Moon_Boersma_Coe_CSCI2270_FinalProject/Blackjack.cpp
// Function: Blackjack::Reset()
void Blackjack::Reset(){//reset player variables for a new round
    for (int i = 0; i < players.size(); i++){
        players[i]->handValue = 0;
        players[i]->handValue = 0;
        players[i]->bet = 0;
        players[i]->bet2 = 0;
        while (players[i]->hand.size() != 0){
            players[i]->hand.pop_back();
        }
        while (players[i]->hand2.size() != 0){
            players[i]->hand2.pop_back();
        }
        players[i]->stand = false;
        players[i]->stand2 = false;
        players[i]->isSplit = false;
    }
}

// Assembly:
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
subq %rax, %rcx
je 0x2ea2
pushq %rbp
movq %rsp, %rbp
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
xorl %esi, %esi
movq (%rax,%rsi,8), %rdi
movl %edx, 0x24(%rdi)
movl %edx, 0x44(%rdi)
movl %edx, 0x68(%rdi)
movq (%rax,%rsi,8), %rdi
movq 0x30(%rdi), %r8
cmpq 0x28(%rdi), %r8
je 0x2e61
addq $0x30, %rdi
addq $-0x8, %r8
movq %r8, (%rdi)
movq (%rax,%rsi,8), %r9
leaq 0x30(%r9), %rdi
movq 0x30(%r9), %r8
cmpq 0x28(%r9), %r8
jne 0x2e48
movq (%rax,%rsi,8), %rdi
movq 0x58(%rdi), %r8
cmpq 0x50(%rdi), %r8
je 0x2e8f
addq $0x58, %rdi
movq %rdi, %r9
addq $-0x8, %r8
movq %r8, (%r9)
movq (%rax,%rsi,8), %rdi
leaq 0x58(%rdi), %r9
movq 0x58(%rdi), %r8
cmpq 0x50(%rdi), %r8
jne 0x2e76
movw $0x0, 0x6c(%rdi)
movb $0x0, 0x48(%rdi)
incq %rsi
cmpq %rcx, %rsi
jne 0x2e29
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xda0(%rip), %rsi       # 0x2004
movl $0x1, %edi
movl $0xa, %edx
callq 0x129b
leaq 0xd9c(%rip), %rsi       # 0x2016
xorl %edi, %edi
movl $0xa, %edx
callq 0x129b
leaq 0xd9b(%rip), %rdi       # 0x2028
movl $0xa, %esi
callq 0x13ea
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %ebp
movb %dil, 0x6(%rsp)
testq %rsi, %rsi
je 0x12d4
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x1050
movq 0x2d11(%rip), %rdi      # 0x3fd8
movq %rbx, %rsi
movq %rax, %rdx
callq 0x10d0
jmp 0x12f2
movq 0x2cfd(%rip), %rax      # 0x3fd8
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0x1110
leaq 0x8(%rsp), %rsi
movb $0xa, (%rsi)
movq 0x2cd7(%rip), %rbx      # 0x3fd8
movl $0x1, %edx
movq %rbx, %rdi
callq 0x10d0
testl %ebp, %ebp
je 0x13b4
movl %ebp, %r12d
xorl %r14d, %r14d
leaq 0x6(%rsp), %r13
leaq 0x7(%rsp), %rbp
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%rbx,%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1070
movq %rax, %r15
movl $0x4, %edx
movq %rax, %rdi
leaq 0xce5(%rip), %rsi       # 0x2038
callq 0x10d0
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x15e6
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x10d0
movb $0xa, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x10d0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x13a8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10c0
incq %r14
cmpq %r14, %r12
jne 0x1326
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x13e2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10c0
movq %rbx, %rdi
callq 0x1120
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/idgenerator/idgeneratorts.cc
// Function: hm3::idgenerator::IDGeneratorTS::_format(std::ostream&, unsigned int) const
void IDGeneratorTS::_format(std::ostream &buff, uint32_t value) const{
	if (_hex){
		buff	<< std::setfill('0') << std::setw(8) << std::hex;
	}else{
		buff	<< std::setfill('0') << std::setw(10);
	}

	buff << value;
}

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

	auto now = MyTime::now();

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

	buff << ".";

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

	return buff.str();
}

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

	static const char *FORMAT = MyTime::DATA_FORMAT_NUMBER;

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


	return buff.str();
}

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x640a
movq %rbx, %rdi
xorl %esi, %esi
callq 0x654a
movl %eax, 0x24(%rsp)
movq %r15, 0x30(%rsp)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x61a5
callq 0x3240
movq 0x10(%r14), %rax
movq %rax, 0x28(%rsp)
movslq %eax, %rbx
leaq (,%rbx,4), %rax
testl %ebx, %ebx
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x3030
movq %rax, %r12
testl %ebx, %ebx
jle 0x621b
movq 0x28(%rsp), %r15
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %ebp, %ebp
movq %rsp, %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x640a
leaq 0x1(%rbp), %rbx
movq %r13, %rdi
movl %ebx, %esi
callq 0x654a
movl %eax, (%r12,%rbp,4)
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x6213
callq 0x3240
movq %rbx, %rbp
cmpq %rbx, %r15
jne 0x61e3
movq %rsp, %rbx
movq %rbx, %rdi
movl 0x24(%rsp), %esi
movq %r12, %rdx
movq 0x28(%rsp), %rcx
callq 0x5657
leaq 0x31af(%rip), %rsi      # 0x93e8
movq %rbx, %rdi
callq 0x30b0
testl %eax, %eax
jne 0x6260
movq %rsp, %rdi
movq 0x8(%rdi), %rdx
leaq 0x31d1(%rip), %rcx      # 0x9424
movl $0x4, %r8d
xorl %esi, %esi
callq 0x3360
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rbx
leaq 0x31b9(%rip), %rsi      # 0x9429
movl $0xc, %edx
movq %rbx, %rdi
callq 0x32a0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x32a0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3250
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3190
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x62cb
callq 0x3240
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
jmp 0x62f6
jmp 0x62ea
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x6300
callq 0x3240
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/pokorj54[P]Pathfinder-utilities/src/CommandLine.cpp
// Function: CommandLine::Arguments::PopFirst[abi:cxx11]()
string CommandLine::Arguments::PopFirst()
{
    if(arguments.empty())
    {
        throw InvalidNoArgumentsException(noArgs, false);
    }
    string res = arguments.front();
    arguments.pop_front();
    return res;
}

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %r14d
movq %rdi, 0x10(%rsp)
movq (%rdi), %r13
callq 0x3060
movq %rax, %r12
movl (%rax), %ebx
movl $0x0, (%rax)
leaq 0x18(%rsp), %rbp
movq %r13, %rdi
movq %rbp, %rsi
movl $0xa, %edx
callq 0x3300
cmpq %r13, (%rbp)
je 0x66a3
movq %rax, %r15
movslq %r15d, %rax
cmpq %r15, %rax
jne 0x66af
movl (%r12), %eax
cmpl $0x22, %eax
je 0x66af
testl %eax, %eax
jne 0x65b6
movl %ebx, (%r12)
movl %r15d, %ebp
negl %ebp
cmovsl %r15d, %ebp
movl $0x1, %r12d
cmpl $0xa, %ebp
jb 0x6613
movl $0x4, %r12d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %ebp, %ecx
cmpl $0x63, %ecx
jbe 0x660a
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x6610
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x6613
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r12d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0x65d7
addl $-0x3, %r12d
jmp 0x6613
addl $-0x2, %r12d
jmp 0x6613
decl %r12d
movl %r14d, 0xc(%rsp)
movl %r15d, %r13d
shrl $0x1f, %r13d
leal (%r12,%r13), %esi
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movl $0x2d, %edx
callq 0x32b0
addq (%rbx), %r13
movq %r13, %rdi
movl %r12d, %esi
movl %ebp, %edx
callq 0x3f80
movq 0x10(%rsp), %r13
movq 0x8(%r13), %rdx
movb $0x1, %bpl
cmpq 0x8(%rbx), %rdx
jne 0x667d
testq %rdx, %rdx
je 0x667b
movq 0x18(%rsp), %rsi
movq (%r13), %rdi
callq 0x3270
testl %eax, %eax
setne %bpl
jmp 0x667d
xorl %ebp, %ebp
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x668c
callq 0x3240
testb %bpl, %bpl
jne 0x66bb
movl %r15d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2d9b(%rip), %rdi      # 0x9445
callq 0x3170
leaq 0x2d8f(%rip), %rdi      # 0x9445
callq 0x3310
movl $0x30, %edi
callq 0x3130
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
movl 0xc(%rsp), %edx
callq 0x5c0c
leaq 0x66aa(%rip), %rsi      # 0xcd88
leaq -0x9f7(%rip), %rdx      # 0x5cee
movq %r12, %rdi
callq 0x33d0
movq %rax, %r15
movq %r12, %rdi
callq 0x31d0
jmp 0x675d
movq %rax, %r15
cmpl $0x0, (%r12)
jne 0x6708
movl %ebx, (%r12)
cmpl $0x1, %edx
jne 0x675d
movq %r15, %rdi
callq 0x3100
movl $0x30, %edi
callq 0x3130
movq %rax, %r12
movq %rax, %rdi
movq 0x10(%rsp), %rsi
movl %r14d, %edx
callq 0x5c0c
leaq 0x664f(%rip), %rsi      # 0xcd88
leaq -0xa52(%rip), %rdx      # 0x5cee
movq %r12, %rdi
callq 0x33d0
movq %rax, %r15
jmp 0x6758
movq %rax, %r15
movq %r12, %rdi
callq 0x31d0
callq 0x33a0
movq %r15, %rdi
callq 0x3410
movq %rax, %rdi
callq 0x4684
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5030
movq %rax, 0x20(%r14)
movq %rax, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x5220
testl %ebp, %ebp
jne 0x5e07
movl %ebx, 0x2c(%r14)
movq 0x38(%r14), %rax
addl %ebx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/WShabti-Team[P]WShabtiPict/wshabtilib/api/combination.cpp
// Function: pictcore::Combination::Bind(int, pictcore::WorkList&)
int Combination::Bind( int value, WorkList &worklist )
{
    int bound = 0;
    // Mark all as pending so we don't add any to the worklist
    for( auto param : m_params )
    {
        param->MarkPending();
    }

    for( ParamCollection::reverse_iterator iter =  m_params.rbegin();
                                           iter != m_params.rend();
                                         ++iter )
    {
        if( !( *iter )->GetBoundCount() )
        {
            ( *iter )->Bind( value % ( *iter )->GetValueCount(), worklist );
            ++bound;
        }
        value /= ( *iter )->GetValueCount();
    }

    return bound;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %r12
cmpq %r12, %rax
je 0x5e3c
movq (%rax), %rcx
movb $0x1, 0x3e(%rcx)
addq $0x8, %rax
jmp 0x5e2a
cmpq 0x8(%r14), %r12
je 0x5e7b
xorl %r15d, %r15d
movq -0x8(%r12), %rdi
cmpb $0x0, 0x3d(%rdi)
jne 0x5e63
movl %ebp, %eax
cltd
idivl 0x38(%rdi)
movl %edx, %esi
movq %rbx, %rdx
callq 0xee9a
incl %r15d
addq $-0x8, %r12
movq (%r12), %rcx
movl %ebp, %eax
cltd
idivl 0x38(%rcx)
movl %eax, %ebp
cmpq 0x8(%r14), %r12
jne 0x5e45
jmp 0x5e7e
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/WShabti-Team[P]WShabtiPict/wshabtilib/api/combination.cpp
// Function: pictcore::Combination::Feasible()
int Combination::Feasible()
{
    int* workbuf = m_model->GetTask()->GetWorkbuf();

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

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

    return zeros;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x38(%rdi), %rax
movq 0x148(%rax), %rax
movq 0x68(%rax), %rcx
movl $0x0, (%rcx)
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rsi
movl $0x1, %eax
cmpq %rsi, %rdx
je 0x5f59
movq (%rdx), %r8
testl %eax, %eax
jle 0x5edf
movl %eax, %r9d
xorl %r10d, %r10d
movl (%rcx,%r10,4), %r11d
imull 0x38(%r8), %r11d
movl %r11d, (%rcx,%r10,4)
incq %r10
cmpq %r10, %r9
jne 0x5eca
cmpb $0x0, 0x3d(%r8)
je 0x5f02
testl %eax, %eax
jle 0x5f50
movl 0x30(%r8), %r8d
movl %eax, %r9d
xorl %r10d, %r10d
addl %r8d, (%rcx,%r10,4)
incq %r10
cmpq %r10, %r9
jne 0x5ef4
jmp 0x5f50
testl %eax, %eax
jle 0x5f4b
movl %eax, %r9d
leaq (,%r9,4), %r10
leaq (%rcx,%r9,4), %r11
xorl %ebx, %ebx
cmpl $0x2, 0x38(%r8)
jl 0x5f3f
movl $0x1, %r14d
movq %r11, %r15
movl (%rcx,%rbx,4), %ebp
addl %r14d, %ebp
movl %ebp, (%r15)
incq %r14
movslq 0x38(%r8), %r12
addq %r10, %r15
cmpq %r12, %r14
jl 0x5f27
incq %rbx
addq $0x4, %r11
cmpq %r9, %rbx
jne 0x5f17
imull 0x38(%r8), %eax
addq $0x8, %rdx
jmp 0x5eb4
testl %eax, %eax
jle 0x5f7d
movq 0x20(%rdi), %rdx
movl %eax, %esi
xorl %edi, %edi
xorl %eax, %eax
movslq (%rcx,%rdi,4), %r8
cmpb $0x1, (%rdx,%r8)
adcl $0x0, %eax
incq %rdi
cmpq %rdi, %rsi
jne 0x5f67
jmp 0x5f7f
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/WShabti-Team[P]WShabtiPict/wshabtilib/api/combination.cpp
// Function: pictcore::Combination::Feasible(int)
ComboStatus Combination::Feasible( int value )
{
    if( EXCLUDED == m_bitvec[ value ] )
    {
        return Excluded;
    }
    ComboStatus retval = ( COVERED == m_bitvec[ value ] ) ? CoveredMatch : Open;
    for( ParamCollection::reverse_iterator iter = m_params.rbegin(); iter != m_params.rend(); ++iter )
    {
        if( ( *iter )->GetBoundCount() && ( *iter )->GetLast() != value % ( *iter )->GetValueCount() )
        {
            return Excluded;
        }
        value /= ( *iter )->GetValueCount();
    }

    return retval;
}

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

    return weight;
}

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

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

    return m_boundCount;
}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsi), %r12
cmpq %r14, 0x10(%rbx)
je 0x612b
movq 0x18(%r15), %rax
movq (%r14), %r13
cmpq %r12, %rax
je 0x6118
cmpq %r13, 0x20(%rax)
je 0x6118
movq %rax, %rdi
callq 0x54b0
jmp 0x6103
cmpq %rax, %r12
je 0x614c
imull 0x38(%r13), %ebp
addl 0x28(%rax), %ebp
addq $0x8, %r14
jmp 0x60f6
cmpl %ebp, 0x28(%rbx)
jl 0x618e
movq 0x20(%rbx), %rax
movslq %ebp, %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x6146
decl 0x2c(%rbx)
movq 0x38(%rbx), %rdx
decl (%rdx)
movb $-0x1, (%rax,%rcx)
jmp 0x617f
movq (%r14), %rax
movl 0x38(%rax), %edx
testl %edx, %edx
jle 0x617f
leaq 0x8(%r14), %r12
xorl %r13d, %r13d
imull %ebp, %edx
addl %r13d, %edx
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x60dc
incl %r13d
movq (%r14), %rax
movl 0x38(%rax), %edx
cmpl %edx, %r13d
jl 0x615d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1feeb(%rip), %rdi     # 0x26080
leaq 0x1fe83(%rip), %rsi     # 0x2601f
leaq 0x1feee(%rip), %rcx     # 0x26091
movl $0xb4, %edx
callq 0x52c0
nop