LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/eryxcc[P]lois/src/solvers.cpp
// Function: lois::SolverIncremental::pump()
void pump() {
    char buf[BUFSIZE];
    int numbytes = 0;
    while(true) {
      ofs.flush();
      int bytes = read(filepipe, buf, BUFSIZE);
      if(bytes <= 0) break;
      numbytes += bytes;
      if(write(solver_input[1], buf, bytes) != bytes)
        throw other_exception("writing to solver");
      }
    if(numbytes)
      printf("Sent %dB to the solver\n", numbytes);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x5028, %rsp           # imm = 0x5028
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x7190
movl 0x21c(%rbx), %edi
leaq 0x20(%rsp), %rsi
movl $0x5000, %edx           # imm = 0x5000
callq 0x7340
movq %rax, %r12
testl %r12d, %r12d
jle 0x376c2
xorl %ebp, %ebp
leaq 0x20(%rsp), %r15
movq %r12, %r13
movl 0x20c(%rbx), %edi
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
movq %r15, %rsi
movq %r13, %rdx
callq 0x70e0
cmpq %r13, %rax
jne 0x376d4
addl %r12d, %ebp
movq %r14, %rdi
callq 0x7190
movl 0x21c(%rbx), %edi
movl $0x5000, %edx           # imm = 0x5000
movq %r15, %rsi
callq 0x7340
movq %rax, %r12
movq %rax, %r13
testl %r12d, %r12d
jg 0x3765b
leaq 0x90cc(%rip), %rdi      # 0x40774
movl %ebp, %esi
xorl %eax, %eax
addq $0x5028, %rsp           # imm = 0x5028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7050
addq $0x5028, %rsp           # imm = 0x5028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x7150
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x9071(%rip), %rsi      # 0x40762
leaq 0x907b(%rip), %rdx      # 0x40773
movq %rsp, %rdi
callq 0x1c74a
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3514c
xorl %ebp, %ebp
leaq 0x19e89(%rip), %rsi     # 0x515a0
leaq -0x2588(%rip), %rdx     # 0x35196
movq %rbx, %rdi
callq 0x7400
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3773f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7280
testb %bpl, %bpl
jne 0x37749
jmp 0x37751
movq %rax, %r14
movq %rbx, %rdi
callq 0x71b0
movq %r14, %rdi
callq 0x7430
nop
// File: /workspace/github_cpp_makefile_star2_O3/eryxcc[P]lois/src/solvers.cpp
// Function: lois::SolverIncremental::readline[abi:cxx11]()
std::string readline() {
    std::string ans;
    while(true) {
      int status;
      int wpr = waitpid(child, &status, WNOHANG);
      if(wpr == child) {
        crashed = true;
        return "";
        }

      char buf;
      int bytes = read(solver_output[0], &buf, 1);
      if(bytes<0 && errno == EAGAIN) {
        // printf("AGAIN\n");
        continue;
        }
      if(bytes > 0) {
        if(buf == 10) return ans;
        else ans += buf;
        }
      if(bytes < 0) { crashed = true; return ""; }
      }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
movb $0x0, (%rbp)
leaq 0x34(%rsp), %r15
leaq 0xf(%rsp), %r12
leaq 0x10(%rsp), %r13
movl 0x218(%r14), %edi
movq %r15, %rsi
movl $0x1, %edx
callq 0x71e0
cmpl 0x218(%r14), %eax
je 0x3780b
movl 0x210(%r14), %edi
movl $0x1, %edx
movq %r12, %rsi
callq 0x7340
testl %eax, %eax
js 0x377de
je 0x37792
movb 0xf(%rsp), %al
cmpb $0xa, %al
je 0x3782e
movsbl %al, %esi
movq %r13, %rdi
callq 0x7220
jmp 0x37792
callq 0x7040
cmpl $0xb, (%rax)
je 0x37792
movb $0x1, 0x25c(%r14)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x8e6e(%rip), %rdx      # 0x4066c
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x1c74a
jmp 0x37870
movb $0x1, 0x25c(%r14)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x8e4b(%rip), %rdx      # 0x4066c
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x1c74a
jmp 0x37870
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x10(%rsp), %rcx
cmpq %rbp, %rcx
je 0x3784d
movq %rcx, (%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x37854
movups (%rbp), %xmm0
movups %xmm0, (%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %rbp, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x37887
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x7280
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3789f
jmp 0x3789f
jmp 0x3789f
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x378b9
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x7280
movq %rbx, %rdi
callq 0x7430
nop
// File: /workspace/github_cpp_makefile_star2_O3/eryxcc[P]lois/src/solvers.cpp
// Function: lois::SolverIncremental::~SolverIncremental()
~SolverIncremental() {
    if(wearechild || crashed) {
      close(solver_input[1]);
      close(solver_output[0]);
      return;
      }
    ofs << "(exit)\n" << std::endl;
//  fprintf(stderr, "[exit %s]\n", buf);
    ofs.close();
//  fprintf(stderr, "[close %s]\n", buf);
    pump();
    int status;
    waitpid(child, &status, 0);
    close(filepipe);
    close(solver_input[1]);
    close(solver_output[0]);
//  kill(child, SIGTERM);
/*  while(true) {
      std::string s = readline();
      if(s == "") break;
      printf("bye %s\n", s.c_str());
      } */
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1a028(%rip), %rax     # 0x518f8
movq %rax, (%rdi)
cmpb $0x0, 0x1afa6(%rip)     # 0x52880
jne 0x378e5
cmpb $0x1, 0x25c(%rbx)
jne 0x37900
movl 0x20c(%rbx), %edi
callq 0x7460
movl 0x210(%rbx), %edi
callq 0x7460
jmp 0x37982
leaq 0x8(%rbx), %r14
leaq 0x8ead(%rip), %rsi      # 0x407b8
movl $0x7, %edx
movq %r14, %rdi
callq 0x72c0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x7250
movsbl %al, %esi
movq %r14, %rdi
callq 0x7030
movq %rax, %rdi
callq 0x7190
movq %r14, %rdi
callq 0x7330
movq %rbx, %rdi
callq 0x37614
movl 0x218(%rbx), %edi
leaq 0x4(%rsp), %rsi
xorl %edx, %edx
callq 0x71e0
movl 0x21c(%rbx), %edi
callq 0x7460
movl 0x20c(%rbx), %edi
callq 0x7460
movl 0x210(%rbx), %edi
callq 0x7460
movq 0x268(%rbx), %rdi
testq %rdi, %rdi
je 0x37993
callq 0x133fc
movq 0x1a626(%rip), %rax     # 0x51fc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
movq %rcx, 0x8(%rbx)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rbx,%rcx)
leaq 0x10(%rbx), %rdi
callq 0x7200
addq $0x100, %rbx            # imm = 0x100
movq %rbx, %rdi
callq 0x70d0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x133cd
// File: /workspace/github_cpp_makefile_star2_O3/eryxcc[P]lois/src/solvers.cpp
// Function: lois::SolverNamed::solve(lois::rbool)
virtual int solve(rbool phi) {
//  std::cout << "trying " << name << ": " << phi << std::endl; fflush(stdout);
    long long t = getVa();
    int r = s->solve(phi);
    std::cout << ido;
    printf("result of %s: %d, %10lld \u03bcs\n", name.c_str(), r, getVa() - t);
    return r;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x73b0
movq (%r15), %r12
movq 0x8(%r15), %r15
movq 0x28(%rbx), %rdi
movq (%r14), %rax
movq %rax, (%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x3a9d4
movq 0x17602(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x3a9d0
incl 0x8(%rax)
jmp 0x3a9d4
lock
incl 0x8(%rax)
movq (%rdi), %rax
movq %rsp, %rsi
callq *(%rax)
movl %eax, %ebp
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3a9ed
callq 0x133fc
leaq 0x17874(%rip), %rax     # 0x52268
movq (%rax), %rsi
movq 0x175d2(%rip), %rdi     # 0x51fd0
callq 0x3ab44
movq 0x8(%rbx), %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x73b0
movq (%r14), %rax
subq %r12, %rax
movq 0x8(%r14), %rdx
subq %r15, %rdx
imulq $0xf4240, %rax, %rcx    # imm = 0xF4240
addq %rdx, %rcx
leaq 0x6128(%rip), %rdi      # 0x40b5c
movq %rbx, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x7050
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3aa61
callq 0x133fc
movq %rbx, %rdi
callq 0x7430
nop
// File: /workspace/github_cpp_makefile_star2_O3/eryxcc[P]lois/src/solvers.cpp
// Function: lois::SolverNamed::solveEnv()
virtual int solveEnv() {
//  std::cout << "trying " << name << ": " << emptycontext << std::endl; fflush(stdout);
    long long t = getVa();
    int r = s->solveEnv();
    std::cout << ido;
    printf("result of %s: %d, %10lld \u03bcs\n", name.c_str(), r, getVa() - t);
    return r;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x73b0
movq (%rbx), %r12
movq 0x8(%rbx), %r13
movq 0x28(%r14), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, %ebx
leaq 0x177c7(%rip), %rax     # 0x52268
movq (%rax), %rsi
movq 0x17525(%rip), %rdi     # 0x51fd0
callq 0x3ab44
movq 0x8(%r14), %r14
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x73b0
movq (%r15), %rax
subq %r12, %rax
movq 0x8(%r15), %rdx
subq %r13, %rdx
imulq $0xf4240, %rax, %rcx    # imm = 0xF4240
addq %rdx, %rcx
leaq 0x607d(%rip), %rdi      # 0x40b5c
movq %r14, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x7050
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/eryxcc[P]lois/src/utils.cpp
// Function: lois::operator<<(std::ostream&, lois::indenter)
std::ostream& operator << (std::ostream& os, indenter a) { 
  indent += a.i;
  if(indent >= 0 && a.doit >= 2) os << std::endl; 
  if(indent >= 0 && a.doit >= 1) for(int i=0; i<indent; i++) os << " ";
  return os;
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rsi, %r14
shrq $0x20, %r14
movl 0x17d90(%rip), %eax     # 0x528e8
addl %esi, %eax
movl %eax, 0x17d88(%rip)     # 0x528e8
setns %cl
cmpl $0x2, %r14d
setge %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x3ab9e
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7250
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7030
movq %rax, %rdi
callq 0x7190
movl 0x17d4a(%rip), %eax     # 0x528e8
testl %r14d, %r14d
setg %cl
testl %eax, %eax
setg %al
andb %cl, %al
cmpb $0x1, %al
jne 0x3abd2
xorl %ebp, %ebp
leaq 0x5c51(%rip), %r14      # 0x40809
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x72c0
incl %ebp
cmpl 0x17d18(%rip), %ebp     # 0x528e8
jl 0x3abb8
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/eryxcc[P]lois/src/element.cpp
// Function: lois::Domain::getSet()
lsetof<term> Domain::getSet() {
  auto x = newvar(this);
  varlist v;
  v.push_back(x);
  lsetof<term> res;
  term tx = term(x);
  res.elts.push_back(std::make_shared<SimpleSetOf<term>>( v, ftrue, tx));
  return res;
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x78, %edi
callq 0x7270
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x12c7c(%rip), %rcx     # 0x505b8
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
leaq 0x130de(%rip), %rdx     # 0x50a28
addq $0x10, %rdx
movq %rdx, 0x10(%rax)
movq %r14, 0x20(%rax)
leaq 0x68(%rax), %rdx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movq %rdx, 0x58(%rax)
xorl %edx, %edx
movq %rdx, 0x60(%rax)
movb $0x0, 0x68(%rax)
movl $0x0, 0x50(%rax)
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
leaq 0x30(%rsp), %rsi
movq %rax, 0x8(%rsi)
movq %rcx, (%rsi)
leaq 0x50(%rsp), %rdi
movq %rdx, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x16382
leaq 0x8(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x8(%rbx)
leaq 0x14dbc(%rip), %rsi     # 0x52770
movq (%rsi), %rax
movq %rax, (%rbx)
addq $0x8, %rsi
callq 0x1615e
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x20(%rsp)
movq %rax, 0x28(%rsp)
testq %rax, %rax
je 0x3d9f1
movq 0x145e5(%rip), %rcx     # 0x51fc8
cmpb $0x0, (%rcx)
je 0x3d9ed
incl 0x8(%rax)
jmp 0x3d9f1
lock
incl 0x8(%rax)
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2d056
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x3da0f
callq 0x133fc
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x14d8d(%rip), %r8      # 0x527b0
leaq 0x10(%rsp), %rsi
leaq 0xf(%rsp), %rdx
leaq 0x50(%rsp), %rcx
leaq 0x40(%rsp), %r9
callq 0x1f2cc
leaq 0x10(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1efa8
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x3da59
callq 0x133fc
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x3da68
callq 0x133fc
leaq 0x50(%rsp), %rdi
callq 0x16466
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x3da81
callq 0x133fc
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x3daa3
callq 0x133fc
jmp 0x3daa3
movq %rax, %r14
movq 0x48(%rsp), %rdi
jmp 0x3dab2
movq %rax, %r14
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x3dabc
callq 0x133fc
movq %rbx, %rdi
callq 0x10a0c
jmp 0x3dac9
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x16466
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x3dae2
callq 0x133fc
movq %r14, %rdi
callq 0x7430
// File: /workspace/github_cpp_makefile_star2_O3/abaheti95[P]HMM-LDA/Models/cpp_hmm_lda/model.cpp
// Function: categorical(std::vector<double, std::allocator<double>>)
int categorical(vector<double> proportions) {
	// Sum all the elements and draw a random number for that
	double sum = 0;
	for(vector<double>::iterator it = proportions.begin(); it != proportions.end(); it++)
		sum += *it;
	double random_number = distribution(generator);
	double draw = sum * random_number;
	// Return the appropriate index based on the cumulative sum
	double cumsum = 0;
	int size = proportions.size();
	for(int idx = 0; idx < size; idx++) {
		cumsum += proportions[idx];
		if(draw < cumsum) {
			return idx;
		}
	}
	return size - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
xorpd %xmm0, %xmm0
cmpq %rcx, %rax
je 0x263f
addsd (%rax), %xmm0
addq $0x8, %rax
jmp 0x2630
movsd %xmm0, -0x10(%rbp)
leaq 0x9f4d(%rip), %rdi      # 0xc598
callq 0x62b0
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
subq %rcx, %rax
shrq $0x3, %rax
testl %eax, %eax
jle 0x2697
movsd 0x9f3e(%rip), %xmm1     # 0xc5a8
movsd 0x9f2e(%rip), %xmm2     # 0xc5a0
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
movsd -0x10(%rbp), %xmm2
mulsd %xmm0, %xmm2
movsd (%rcx), %xmm0
ucomisd %xmm2, %xmm0
jbe 0x269b
movb $0x1, %cl
xorl %edx, %edx
jmp 0x26d8
decl %eax
jmp 0x26e0
movl %eax, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
xorpd %xmm1, %xmm1
addsd %xmm1, %xmm0
leaq -0x1(%rsi), %rdi
xorl %edx, %edx
cmpq %rdx, %rdi
je 0x26cd
addsd 0x8(%rcx,%rdx,8), %xmm0
incq %rdx
ucomisd %xmm2, %xmm0
jbe 0x26b1
cmpq %rsi, %rdx
setb %cl
jmp 0x26d8
incq %rdx
cmpq %rsi, %rdx
setb %cl
movl %eax, %edx
decl %eax
testb $0x1, %cl
cmovnel %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/abaheti95[P]HMM-LDA/Models/cpp_hmm_lda/model.cpp
// Function: HMMLDA::~HMMLDA()
HMMLDA::~HMMLDA() {
	// Free up the 2d vectors
	int n_documents = documents.size();
	for(int document_idx = 0; document_idx < n_documents; document_idx++){
		documents[document_idx].clear();
		class_assignments[document_idx].clear();
		topic_assignments[document_idx].clear();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xa8(%rdi), %rax
movq 0xb0(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rsi
testl %esi, %esi
jle 0x2b06
movq 0xc0(%rbx), %rcx
movq 0xd8(%rbx), %rdx
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
shlq $0x3, %rsi
leaq (%rsi,%rsi,2), %rsi
xorl %edi, %edi
movq (%rax,%rdi), %r8
cmpq %r8, 0x8(%rax,%rdi)
je 0x2add
movq %r8, 0x8(%rax,%rdi)
movq (%rdx,%rdi), %r8
cmpq %r8, 0x8(%rdx,%rdi)
je 0x2aed
movq %r8, 0x8(%rdx,%rdi)
movq (%rcx,%rdi), %r8
cmpq %r8, 0x8(%rcx,%rdi)
je 0x2afd
movq %r8, 0x8(%rcx,%rdi)
addq $0x18, %rdi
cmpq %rdi, %rsi
jne 0x2acd
movq 0x168(%rbx), %rdi
testq %rdi, %rdi
je 0x2b17
callq 0x2210
leaq 0xa8(%rbx), %r14
movq 0x150(%rbx), %rdi
testq %rdi, %rdi
je 0x2b2f
callq 0x2210
leaq 0x138(%rbx), %rdi
callq 0x5a94
leaq 0x120(%rbx), %rdi
callq 0x5a94
leaq 0x108(%rbx), %rdi
callq 0x5a94
leaq 0xf0(%rbx), %rdi
callq 0x5a94
leaq 0xd8(%rbx), %rdi
callq 0x5a94
leaq 0xc0(%rbx), %rdi
callq 0x5a94
movq %r14, %rdi
callq 0x5a94
leaq 0x70(%rbx), %rdi
callq 0x606e
leaq 0x58(%rbx), %rdi
callq 0x5ae8
movq 0x38(%rbx), %rdi
addq $0x48, %rbx
cmpq %rbx, %rdi
je 0x2ba7
popq %rbx
popq %r14
popq %rbp
jmp 0x2210
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/abaheti95[P]HMM-LDA/Models/cpp_hmm_lda/model.cpp
// Function: HMMLDA::add_document(std::vector<int, std::allocator<int>>)
void HMMLDA::add_document(vector<int> document) {
	documents.push_back(document);
	// Sample random topics and classes for the words
	vector<int> topic_assignment(document.size(), 0);
	vector<int> class_assignment(document.size(), 0);
	int doc_size = document.size();
	for(int i = 0; i < doc_size; i++) {
		topic_assignment[i] = topic_dist(rng);
		if(document[i] == start_word_id)
			class_assignment[i] = START_WORD_CLASS;
		else if(document[i] ==  end_word_id)
			class_assignment[i] = END_WORD_CLASS;
		else
			class_assignment[i] = class_dist(rng);
	}
	// cout << "Printing topic assignments of a document" << endl;
	// print_vector<int>(topic_assignment);
	topic_assignments.push_back(topic_assignment);
	class_assignments.push_back(class_assignment);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r12
movq %rdi, %rbx
addq $0xa8, %rdi
callq 0x5c0c
movq 0x8(%r12), %rsi
subq (%r12), %rsi
sarq $0x2, %rsi
xorl %r14d, %r14d
leaq -0x58(%rbp), %rdx
movl %r14d, (%rdx)
leaq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %r15
movq %r15, %rcx
callq 0x5c48
movq 0x8(%r12), %rsi
subq (%r12), %rsi
sarq $0x2, %rsi
movl %r14d, (%r15)
leaq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rdx
leaq -0x29(%rbp), %rcx
callq 0x5c48
movq 0x8(%r12), %r13
movq %r12, -0x40(%rbp)
subq (%r12), %r13
shrq $0x2, %r13
testl %r13d, %r13d
jle 0x2ce4
leaq 0x1508(%rbx), %r15
leaq 0x180(%rbx), %r12
leaq 0x1510(%rbx), %rax
movq %rax, -0x38(%rbp)
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %r14d, %r14d
movq %r15, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x6c00
movq -0x70(%rbp), %rcx
movl %eax, (%rcx,%r14,4)
movq -0x40(%rbp), %rax
movq (%rax), %rax
movl (%rax,%r14,4), %eax
cmpl 0x8(%rbx), %eax
jne 0x2cbb
movl 0x10(%rbx), %eax
jmp 0x2cd4
cmpl 0xc(%rbx), %eax
jne 0x2cc5
movl 0x14(%rbx), %eax
jmp 0x2cd4
movq -0x38(%rbp), %rdi
movq %r12, %rsi
movq %rdi, %rdx
callq 0x6c00
movq -0x58(%rbp), %rcx
movl %eax, (%rcx,%r14,4)
incq %r14
cmpq %r14, %r13
jne 0x2c90
leaq 0xc0(%rbx), %rdi
leaq -0x70(%rbp), %rsi
callq 0x5c0c
addq $0xd8, %rbx
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x5c0c
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x2d15
callq 0x2210
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x2d23
callq 0x2210
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x2d4a
jmp 0x2d39
movq %rax, %rbx
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x2d4a
callq 0x2210
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x2d58
callq 0x2210
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O3/abaheti95[P]HMM-LDA/Models/cpp_hmm_lda/model.cpp
// Function: HMMLDA::train(int, int)
void HMMLDA::train(int iterations, int save_freq) {
	save_assignments(0);
	// Run Gibbs sampling
	// iterations = number of full samplings of the corpus
	int n_documents = documents.size();
	for(int i = 1; i <= iterations; i++) {
		std::clock_t start = std::clock();
		for(int document_idx = 0; document_idx < n_documents; document_idx++) {
			int doc_size = documents[document_idx].size();
			for(int word_idx = 0; word_idx < doc_size; word_idx++) {
				draw_class(document_idx, word_idx, doc_size);
				draw_topic(document_idx, word_idx, doc_size);
			}
		}
		std::cout << "Time for iteration " << i <<": " << (std::clock() - start) / (double)(CLOCKS_PER_SEC) << " s" << endl;
		if((i%save_freq) == 0)
			save_assignments(i);
		// cout << endl << endl << endl << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, -0x30(%rbp)
movl %esi, %ebx
movq %rdi, %r15
xorl %esi, %esi
callq 0x3726
movl %ebx, -0x2c(%rbp)
testl %ebx, %ebx
jle 0x3716
movq 0xb0(%r15), %rax
subq 0xa8(%r15), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r12
movq %r12, -0x38(%rbp)
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
movl $0x1, %eax
movq %rax, -0x48(%rbp)
callq 0x2140
movq %rax, -0x40(%rbp)
cmpl $0x0, -0x38(%rbp)
jle 0x3652
xorl %r14d, %r14d
movq 0xa8(%r15), %rax
leaq (%r14,%r14,2), %rcx
movq 0x8(%rax,%rcx,8), %r13
subq (%rax,%rcx,8), %r13
shrq $0x2, %r13
testl %r13d, %r13d
jle 0x364a
xorl %ebx, %ebx
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
movl %r13d, %ecx
callq 0x3f52
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
callq 0x45dc
incl %ebx
cmpl %ebx, %r13d
jne 0x3626
incq %r14
cmpq %r12, %r14
jne 0x3607
movl $0x13, %edx
movq 0x797a(%rip), %rbx      # 0xafd8
movq %rbx, %rdi
leaq 0x4a4d(%rip), %rsi      # 0x80b5
callq 0x2270
movq %rbx, %rdi
movq -0x48(%rbp), %r14
movl %r14d, %esi
callq 0x2380
movq %rax, %rbx
movl $0x2, %edx
movq %rax, %rdi
leaq 0x4a04(%rip), %rsi      # 0x8092
callq 0x2270
callq 0x2140
subq -0x40(%rbp), %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd 0x495c(%rip), %xmm0     # 0x8008
movq %rbx, %rdi
callq 0x2330
movq %rax, %rbx
movl $0x2, %edx
movq %rax, %rdi
leaq 0x4a03(%rip), %rsi      # 0x80c9
callq 0x2270
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movl %r14d, %eax
cltd
idivl -0x30(%rbp)
testl %edx, %edx
jne 0x3708
movq %r15, %rdi
movl %r14d, %esi
callq 0x3726
leal 0x1(%r14), %eax
cmpl -0x2c(%rbp), %r14d
jne 0x35f1
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/abaheti95[P]HMM-LDA/Models/cpp_hmm_lda/model.cpp
// Function: HMMLDA::add_counts_for_new_document(std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, int)
void HMMLDA::add_counts_for_new_document(vector<int> &document, vector<int> &topic_assignment, vector<int> &class_assignment, vector<int> &num_words_in_document_assigned_to_topic, int doc_size) {
	int previous_class = -1;
	for(int word_idx = 0; word_idx < doc_size; word_idx++) {
		int word = document[word_idx];
		if(class_assignment[word_idx] == 0) {		// Count the topic only when the class is 0
			//TODO: Think about how to implement num_words_in_doc_assigned_to_topic for a new document
			num_words_in_document_assigned_to_topic[topic_assignment[word_idx]]++;
			num_same_words_assigned_to_topic[word][topic_assignment[word_idx]]++;
			num_words_assigned_to_topic[topic_assignment[word_idx]]++;
		}
		num_same_words_assigned_to_class[word][class_assignment[word_idx]]++;
		num_words_assigned_to_class[class_assignment[word_idx]]++;
		int current_class = class_assignment[word_idx];
		if(previous_class != -1)
			num_transitions[previous_class][current_class]++;
		previous_class = current_class;
	}
}

// Assembly:
testl %r9d, %r9d
jle 0x4901
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rsi), %rax
movq (%rcx), %rcx
movq (%rdx), %rdx
movq (%r8), %rsi
movq %rsi, -0x30(%rbp)
movq 0x108(%rdi), %r8
movq 0x120(%rdi), %r10
movq 0x150(%rdi), %r11
movq 0x168(%rdi), %rbx
movq 0x138(%rdi), %rdi
movl %r9d, %r9d
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
xorl %r14d, %r14d
movslq (%rax,%r14,4), %r12
movl (%rcx,%r14,4), %r13d
leaq (%r12,%r12,2), %r12
testl %r13d, %r13d
jne 0x48be
movslq (%rdx,%r14,4), %r13
movq -0x30(%rbp), %rsi
incl (%rsi,%r13,4)
movslq (%rdx,%r14,4), %r13
movq (%r8,%r12,8), %rsi
incl (%rsi,%r13,4)
movslq (%rdx,%r14,4), %rsi
incl (%r11,%rsi,4)
movl (%rcx,%r14,4), %r13d
movslq %r13d, %rsi
movq (%r10,%r12,8), %r12
incl (%r12,%rsi,4)
movslq (%rcx,%r14,4), %rsi
incl (%rbx,%rsi,4)
movl (%rcx,%r14,4), %r12d
cmpl $-0x1, %r15d
je 0x48ec
movslq %r12d, %rsi
movslq %r15d, %r15
leaq (%r15,%r15,2), %r15
movq (%rdi,%r15,8), %r15
incl (%r15,%rsi,4)
incq %r14
movl %r12d, %r15d
cmpq %r14, %r9
jne 0x4889
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/abaheti95[P]HMM-LDA/Models/cpp_hmm_lda/model.cpp
// Function: HMMLDA::remove_counts_for_new_document(std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, int)
void HMMLDA::remove_counts_for_new_document(vector<int> &document, vector<int> &topic_assignment, vector<int> &class_assignment, vector<int> &num_words_in_document_assigned_to_topic, int doc_size) {
	int previous_class = -1;
	for(int word_idx = 0; word_idx < doc_size; word_idx++) {
		int word = document[word_idx];
		if(class_assignment[word_idx] == 0) {		// Count the topic only when the class is 0
			num_words_in_document_assigned_to_topic[topic_assignment[word_idx]]--;
			num_same_words_assigned_to_topic[word][topic_assignment[word_idx]]--;
			num_words_assigned_to_topic[topic_assignment[word_idx]]--;
		}
		num_same_words_assigned_to_class[word][class_assignment[word_idx]]--;
		num_words_assigned_to_class[class_assignment[word_idx]]--;
		int current_class = class_assignment[word_idx];
		if(previous_class != -1)
			num_transitions[previous_class][current_class]--;
		previous_class = current_class;
	}
}

// Assembly:
testl %r9d, %r9d
jle 0x49cf
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rsi), %rax
movq (%rcx), %rcx
movq (%rdx), %rdx
movq (%r8), %rsi
movq %rsi, -0x30(%rbp)
movq 0x108(%rdi), %r8
movq 0x120(%rdi), %r10
movq 0x150(%rdi), %r11
movq 0x168(%rdi), %rbx
movq 0x138(%rdi), %rdi
movl %r9d, %r9d
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
xorl %r14d, %r14d
movslq (%rax,%r14,4), %r12
movl (%rcx,%r14,4), %r13d
leaq (%r12,%r12,2), %r12
testl %r13d, %r13d
jne 0x498c
movslq (%rdx,%r14,4), %r13
movq -0x30(%rbp), %rsi
decl (%rsi,%r13,4)
movslq (%rdx,%r14,4), %r13
movq (%r8,%r12,8), %rsi
decl (%rsi,%r13,4)
movslq (%rdx,%r14,4), %rsi
decl (%r11,%rsi,4)
movl (%rcx,%r14,4), %r13d
movslq %r13d, %rsi
movq (%r10,%r12,8), %r12
decl (%r12,%rsi,4)
movslq (%rcx,%r14,4), %rsi
decl (%rbx,%rsi,4)
movl (%rcx,%r14,4), %r12d
cmpl $-0x1, %r15d
je 0x49ba
movslq %r12d, %rsi
movslq %r15d, %r15
leaq (%r15,%r15,2), %r15
movq (%rdi,%r15,8), %r15
decl (%r15,%rsi,4)
incq %r14
movl %r12d, %r15d
cmpq %r14, %r9
jne 0x4957
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/abaheti95[P]HMM-LDA/Models/cpp_hmm_lda/model.cpp
// Function: HMMLDA::input_to_document(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&)
int HMMLDA::input_to_document(vector<string> &words, vector<int> &document, vector<int> &topic_assignment, vector<int> &class_assignment) {
	for(int i = 0; i < (int)words.size(); i++) {
		document[i] = vocab_dict[words[i]];
		topic_assignment[i] = topic_dist(rng);
		if(document[i] == start_word_id)
			class_assignment[i] = START_WORD_CLASS;
		else if(document[i] ==  end_word_id)
			class_assignment[i] = END_WORD_CLASS;
		else
			class_assignment[i] = class_dist(rng);
	}
	return words.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, -0x60(%rbp)
movq %rcx, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq %rsi, %rax
movq (%rsi), %rsi
movq %rax, -0x48(%rbp)
movq 0x8(%rax), %rax
subq %rsi, %rax
shrq $0x5, %rax
testl %eax, %eax
jle 0x4acb
movq %rdi, %r13
leaq 0x70(%rdi), %rax
movq %rax, -0x40(%rbp)
leaq 0x1508(%rdi), %r14
leaq 0x180(%rdi), %rax
movq %rax, -0x30(%rbp)
leaq 0x1510(%rdi), %rax
movq %rax, -0x38(%rbp)
xorl %ebx, %ebx
xorl %r15d, %r15d
movq -0x50(%rbp), %r12
addq %rbx, %rsi
movq -0x40(%rbp), %rdi
callq 0x5b8c
movl (%rax), %eax
movq (%r12), %rcx
movl %eax, (%rcx,%r15,4)
movq %r14, %rdi
movq -0x30(%rbp), %rsi
movq %r14, %rdx
callq 0x6c00
movq -0x58(%rbp), %rcx
movq (%rcx), %rcx
movl %eax, (%rcx,%r15,4)
movq (%r12), %rax
movl (%rax,%r15,4), %eax
cmpl 0x8(%r13), %eax
jne 0x4a7f
movl 0x10(%r13), %eax
jmp 0x4a9b
cmpl 0xc(%r13), %eax
jne 0x4a8b
movl 0x14(%r13), %eax
jmp 0x4a9b
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rdi, %rdx
callq 0x6c00
movq -0x60(%rbp), %rcx
movq (%rcx), %rcx
movl %eax, (%rcx,%r15,4)
incq %r15
movq -0x48(%rbp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rax
subq %rsi, %rax
shrq $0x5, %rax
movslq %eax, %rcx
addq $0x20, %rbx
cmpq %rcx, %r15
jl 0x4a3b
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/abaheti95[P]HMM-LDA/Models/cpp_hmm_lda/model.cpp
// Function: void split<std::back_insert_iterator<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::back_insert_iterator<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>)
void split(const std::string &s, char delim, Out result) {
	std::stringstream ss;
	ss.str(s);
	std::string item;
	while (std::getline(ss, item, delim)) {
		*(result++) = item;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
leaq -0x1d0(%rbp), %rdi
callq 0x2170
leaq -0x1b8(%rbp), %rdi
movq %r15, %rsi
callq 0x22f0
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movsbl %r14b, %r14d
leaq -0x1d0(%rbp), %r15
leaq -0x48(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl %r14d, %edx
callq 0x23b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x5fe2
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5b40
jmp 0x5fb9
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x5ff0
callq 0x2210
movq 0x4fc1(%rip), %rsi      # 0xafb8
leaq -0x1d0(%rbp), %rdi
callq 0x21a0
leaq -0x150(%rbp), %rdi
callq 0x20b0
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x6039
jmp 0x6028
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x6039
callq 0x2210
movq 0x4f78(%rip), %rsi      # 0xafb8
leaq -0x1d0(%rbp), %rdi
callq 0x21a0
leaq -0x150(%rbp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O3/Doug0855[P]TigerZone/Adapter.cpp
// Function: Adapter::numRotations(int)
int Adapter::numRotations(const int x) {
	int numRotations = 0;
	if (x == 90)
		return numRotations = 1;
	if (x == 180)
		return numRotations = 2;
	if (x == 270)
		return numRotations = 3;

	return numRotations;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x5a, %esi
je 0xa887
cmpl $0x10e, %esi            # imm = 0x10E
je 0xa880
cmpl $0xb4, %esi
jne 0xa88e
movl $0x2, %eax
jmp 0xa890
movl $0x3, %eax
jmp 0xa890
movl $0x1, %eax
jmp 0xa890
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Doug0855[P]TigerZone/Adapter.cpp
// Function: Adapter::convertExpression(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::vector<std::string> Adapter::convertExpression(const std::string& expr) {
	// Convert to stream
	std::istringstream buf(expr);
	std::istream_iterator<std::string> begin(buf), end;

	// Store in vector and return
	std::vector<std::string> myV(begin, end);
	return myV;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x250, %rsp            # imm = 0x250
movq %rdi, %rbx
leaq -0x268(%rbp), %r14
movq %r14, %rdi
movq %rdx, %rsi
movl $0x8, %edx
callq 0x33b0
leaq -0x88(%rbp), %rdi
movq %r14, %rsi
callq 0xc664
xorl %eax, %eax
leaq -0x40(%rbp), %r14
movq %rax, -0x18(%r14)
movq %r14, -0x10(%r14)
movq %rax, -0x8(%r14)
movb %al, (%r14)
movb %al, 0x10(%r14)
movq -0x88(%rbp), %rax
movq -0x80(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
movq %rax, -0x8(%rdi)
leaq -0xa0(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x78(%rbp), %rdx
addq %rsi, %rdx
callq 0x9cc4
movb -0x60(%rbp), %al
movb %al, -0x90(%rbp)
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rsi
leaq -0xe0(%rbp), %rdi
movq %rax, -0x8(%rdi)
leaq -0xd0(%rbp), %r12
movq %r12, -0x10(%r12)
movq -0x48(%rbp), %rdx
addq %rsi, %rdx
callq 0x9cc4
movb -0x30(%rbp), %al
leaq -0xe8(%rbp), %rdx
movb %al, 0x28(%rdx)
leaq -0xb8(%rbp), %rsi
leaq -0x21(%rbp), %rcx
movq %rbx, %rdi
callq 0xc6b6
movq -0xe0(%rbp), %rdi
cmpq %r12, %rdi
je 0xa978
callq 0x3200
movq -0xb0(%rbp), %rdi
cmpq %r15, %rdi
je 0xa989
callq 0x3200
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0xa997
callq 0x3200
leaq -0x70(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa9a9
callq 0x3200
movq 0x14610(%rip), %rsi     # 0x1efc0
leaq -0x268(%rbp), %rdi
callq 0x3300
leaq -0x1f0(%rbp), %rdi
callq 0x30d0
movq %rbx, %rax
addq $0x250, %rsp            # imm = 0x250
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0xe0(%rbp), %rdi
cmpq %r12, %rdi
je 0xa9f4
callq 0x3200
jmp 0xa9f4
movq %rax, %rbx
movq -0xb0(%rbp), %rdi
cmpq %r15, %rdi
je 0xaa0a
callq 0x3200
jmp 0xaa0a
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0xaa18
callq 0x3200
leaq -0x70(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaa2f
callq 0x3200
jmp 0xaa2f
movq %rax, %rbx
movq 0x1458a(%rip), %rsi     # 0x1efc0
leaq -0x268(%rbp), %rdi
callq 0x3300
leaq -0x1f0(%rbp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O3/Doug0855[P]TigerZone/Adapter.cpp
// Function: Adapter::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string Adapter::get(const std::string& prop) {
	if (prop == "pid")
		return this->playerID;
	if (prop == "rid")
		return this->roundID;
	if (prop == "score")
		return this->score;
	if (prop == "challenges")
		return this->numChallenges;
	if (prop == "rounds")
		return this->numRounds;
	if (prop == "ptime")
		return this->planTime;
	if (prop == "mtime")
		return this->moveTime;

	return "Error";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xdae1(%rip), %rsi      # 0x18551
movq %rdx, %rdi
callq 0x30b0
testl %eax, %eax
je 0xab2c
leaq 0xdace(%rip), %rsi      # 0x18555
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
je 0xab3c
leaq 0xdabb(%rip), %rsi      # 0x18559
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
je 0xab4d
leaq 0xdaaa(%rip), %rsi      # 0x1855f
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
je 0xab5e
leaq 0xda9e(%rip), %rsi      # 0x1856a
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
je 0xab6f
leaq 0xda8e(%rip), %rsi      # 0x18571
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
je 0xab86
leaq 0xda7d(%rip), %rsi      # 0x18577
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
je 0xab9d
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xda65(%rip), %rsi      # 0x1857d
leaq 0xda63(%rip), %rdx      # 0x18582
movq %rbx, %rdi
callq 0x9d62
jmp 0xabbd
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
jmp 0xabb2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
jmp 0xabb2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
jmp 0xabb2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x60(%r14), %rsi
movq 0x68(%r14), %rdx
jmp 0xabb2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x80(%r14), %rsi
movq 0x88(%r14), %rdx
jmp 0xabb2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0xa0(%r14), %rsi
movq 0xa8(%r14), %rdx
jmp 0xabb2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0xc0(%r14), %rsi
movq 0xc8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x9cc4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Doug0855[P]TigerZone/Adapter.cpp
// Function: Adapter::set(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Adapter::set(const std::string& prop, const std::string value) {
	if (prop == "pid")
		this->playerID = value;
	if (prop == "rid")
		this->roundID = value;
	if (prop == "score")
		this->score = value;
	if (prop == "challenges")
		this->numChallenges = value;
	if (prop == "rounds")
		this->numRounds = value;
	if (prop == "ptime")
		this->planTime = value;
	if (prop == "mtime")
		this->moveTime = value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0xd96b(%rip), %rsi      # 0x18551
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
jne 0xabfd
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3140
leaq 0xd951(%rip), %rsi      # 0x18555
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
jne 0xac1c
leaq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x3140
leaq 0xd936(%rip), %rsi      # 0x18559
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
jne 0xac3b
leaq 0x40(%r14), %rdi
movq %rbx, %rsi
callq 0x3140
leaq 0xd91d(%rip), %rsi      # 0x1855f
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
jne 0xac5a
leaq 0x60(%r14), %rdi
movq %rbx, %rsi
callq 0x3140
leaq 0xd909(%rip), %rsi      # 0x1856a
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
jne 0xac7c
leaq 0x80(%r14), %rdi
movq %rbx, %rsi
callq 0x3140
leaq 0xd8ee(%rip), %rsi      # 0x18571
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
jne 0xac9e
leaq 0xa0(%r14), %rdi
movq %rbx, %rsi
callq 0x3140
leaq 0xd8d2(%rip), %rsi      # 0x18577
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
je 0xacbc
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addq $0xc0, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3140
// File: /workspace/github_cpp_makefile_star2_O3/Doug0855[P]TigerZone/Adapter.cpp
// Function: Adapter::getTileString[abi:cxx11](int const&)
std::string Adapter::getTileString(const int& index) {
	// Error check
	if (index < 0 || index > this->tileList.size())
		return "Error";

	return this->tileList[index];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq (%rdx), %rax
testq %rax, %rax
js 0xad03
movq 0xe0(%rsi), %rcx
movq 0xe8(%rsi), %rdx
subq %rcx, %rdx
sarq $0x5, %rdx
cmpq %rax, %rdx
jae 0xad22
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xd86c(%rip), %rsi      # 0x1857d
leaq 0xd86a(%rip), %rdx      # 0x18582
movq %rbx, %rdi
callq 0x9d62
jmp 0xad41
shlq $0x5, %rax
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x9cc4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Doug0855[P]TigerZone/Adapter.cpp
// Function: Adapter::convertZone(std::pair<int, int>)
int Adapter::convertZone(std::pair<int, int> location)
{
	int i = location.first;
	int j = location.second;

	if(i == 0)
	{
		if(j == 0) return 1;
		else if(j == 1) return 2;
		else if(j == 2) return 3;
	}
	else if(i == 1)
	{
		if(j == 0) return 4;
		else if(j == 1) return 5;
		else if(j == 2) return 6;
	}
	else if(i == 2)
	{
		if(j == 0) return 7;
		else if(j == 1) return 8;
		else if(j == 2) return 9;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rcx
shrq $0x20, %rcx
cmpl $0x1, %esi
je 0xadb3
testl %esi, %esi
jne 0xadca
movl $0x1, %eax
testq %rcx, %rcx
je 0xaddf
xorl %eax, %eax
cmpl $0x1, %ecx
sete %al
xorl $0x3, %eax
jmp 0xaddf
movl $0x4, %eax
testq %rcx, %rcx
je 0xaddf
xorl %eax, %eax
cmpl $0x1, %ecx
setne %al
addl $0x5, %eax
jmp 0xaddf
movl $0x7, %eax
testq %rcx, %rcx
je 0xaddf
xorl %eax, %eax
cmpl $0x1, %ecx
sete %al
xorl $0x9, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Doug0855[P]TigerZone/Game.cpp
// Function: Game::Game(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Player, Player, TileStack, Tile, std::pair<int, int>)
Game::Game(std::string gameId, Player p1, Player p2, TileStack t, Tile startingTile, std::pair<int,int> startingCoordinates)
{
	Tile *startTile = new Tile(startingTile.getNum());
	gameboard.place_tile(startingCoordinates, *startTile);

	numMeeples = 7;
	player1 = p1;
	player2 = p2;
	this->gameId = gameId;
	tileStack = t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r12
movq %r8, -0x58(%rbp)
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, -0x60(%rbp)
movq %rdi, %rbx
callq 0xf428
leaq 0x20(%rbx), %rax
movq %rax, -0x40(%rbp)
leaq 0x30(%rbx), %rax
movq %rax, -0x50(%rbp)
movq %rax, 0x20(%rbx)
movq $0x0, 0x28(%rbx)
movb $0x0, 0x30(%rbx)
leaq 0x40(%rbx), %rdi
movq %rdi, -0x48(%rbp)
callq 0x14adc
leaq 0x60(%rbx), %rdi
movq %rdi, -0x38(%rbp)
callq 0x14adc
leaq 0x80(%rbx), %rdi
movq %rdi, -0x30(%rbp)
callq 0x14b84
movl $0xe8, %edi
callq 0x3220
movq %rax, %r14
movl 0x4(%r12), %esi
movq %rax, %rdi
callq 0x15560
movq 0x10(%rbp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x11218
movl $0x7, 0x18(%rbx)
movq -0x48(%rbp), %rdi
movq %r15, %rsi
callq 0xeb5e
movl 0x18(%r15), %eax
movl %eax, 0x58(%rbx)
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0xeb5e
movl 0x18(%r13), %eax
movl %eax, 0x78(%rbx)
movq -0x40(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x3140
movq -0x30(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x955a
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x3200
jmp 0xcd2a
movq %rax, %r15
jmp 0xcd33
movq %rax, %r15
jmp 0xcd3c
movq %rax, %r15
jmp 0xcd45
movq %rax, %r15
movq -0x30(%rbp), %rdi
callq 0x14e26
movq -0x38(%rbp), %rdi
callq 0x14af0
movq -0x48(%rbp), %rdi
callq 0x14af0
movq -0x40(%rbp), %rax
movq (%rax), %rdi
cmpq -0x50(%rbp), %rdi
je 0xcd57
callq 0x3200
movq %rbx, %rdi
callq 0xf4ee
movq %r15, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Doug0855[P]TigerZone/Game.cpp
// Function: Game::printToTextFile(Board)
void Game::printToTextFile(Board gameboard)
{
	std::ofstream out_data("Levels/level.txt");
	out_data << "Level:" << std::endl;
	for (auto& inner : gameboard.m_board)
	{
		for (auto& item : inner)
		{
			if (item != NULL)
				out_data << item->getRotations() << item->getType();
			else
				out_data << '0' << '.';

		}
		out_data << std::endl;
	}
	out_data.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rsi, %r14
leaq 0xacb2(%rip), %rsi      # 0x18020
leaq -0x238(%rbp), %rbx
movq %rbx, %rdi
movl $0x10, %edx
callq 0x3250
leaq 0xaca8(%rip), %rsi      # 0x18031
movl $0x6, %edx
movq %rbx, %rdi
callq 0x3280
movq -0x238(%rbp), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x3210
movsbl %al, %esi
leaq -0x238(%rbp), %rbx
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3180
movq (%r14), %r15
movq 0x8(%r14), %rax
movq %rax, -0x38(%rbp)
cmpq %rax, %r15
je 0xd482
leaq -0x29(%rbp), %r14
movq (%r15), %r13
movq 0x8(%r15), %r12
cmpq %r12, %r13
je 0xd449
movq (%r13), %rax
testq %rax, %rax
je 0xd41b
movl (%rax), %esi
movq %rbx, %rdi
callq 0x33c0
movq (%r13), %rcx
movb 0x8(%rcx), %cl
movb %cl, -0x29(%rbp)
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x3280
jmp 0xd443
movb $0x30, -0x29(%rbp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3280
movb $0x2e, -0x29(%rbp)
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x3280
addq $0x8, %r13
jmp 0xd3e7
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3210
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3180
addq $0x18, %r15
cmpq -0x38(%rbp), %r15
jne 0xd3e0
leaq -0x238(%rbp), %rdi
callq 0x32f0
movq 0x11b23(%rip), %rax     # 0x1efb8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x230(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x238(%rbp,%rcx)
callq 0x31e0
leaq -0x140(%rbp), %rdi
callq 0x30d0
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd4da
jmp 0xd4da
movq %rax, %rbx
leaq -0x238(%rbp), %rdi
callq 0x3340
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Doug0855[P]TigerZone/Game.cpp
// Function: Game::enemyMove(Tile, int, int, int, bool, bool, std::pair<int, int>)
void Game::enemyMove(Tile tile, int i, int j, int orientation, bool tiger, bool croc, std::pair<int,int> tigerSpot)
{
	//create a tile to place
  Tile *tmpTile = new Tile(tile.getNum());
  //set the proper orientation for the tile
  for(int k = 0; k< orientation; k++)
  {
    tmpTile->rotate();
  }
	std::pair<int, int> optimalLocation(i,j);
	//place the tile at the location specified 
  gameboard.place_tile(optimalLocation, *tmpTile);
  // if there is a tiger place it 
  if(tiger) gameboard.placeMeeple(i, j, tigerSpot);
  // if there is a croc place it
  if(croc) gameboard.placeCroc(i ,j);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, -0x30(%rbp)
movl %r8d, %r13d
movq %rcx, -0x40(%rbp)
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movq 0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movb 0x10(%rbp), %al
movb %al, -0x29(%rbp)
movl $0xe8, %edi
callq 0x3220
movq %rax, %r12
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0x15560
testl %r13d, %r13d
jle 0xd54f
movq %r12, %rdi
callq 0x1679e
decl %r13d
jne 0xd542
movq -0x40(%rbp), %rbx
movq %rbx, %rax
shlq $0x20, %rax
movl %r14d, %esi
orq %rax, %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x11218
cmpb $0x0, -0x30(%rbp)
je 0xd582
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
movq -0x38(%rbp), %rcx
callq 0x11c68
cmpb $0x0, -0x29(%rbp)
je 0xd5a3
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x111f8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r12, %rdi
callq 0x3200
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Doug0855[P]TigerZone/Network.cpp
// Function: Client::Client(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Client::Client(std::string hostname, std::string port)
{
    portno = stoi(port);
    server = gethostbyname(hostname.c_str());
    if (server == NULL) {
        fprintf(stderr,"ERROR, no such host\n");
        exit(0);
    }
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
        error("ERROR opening socket");
    bzero((char *) &serv_addr, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    bcopy((char *)server->h_addr, (char *)&serv_addr.sin_addr.s_addr, server->h_length);
    serv_addr.sin_port = htons(portno);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %r12
callq 0x3040
movq %rax, %r14
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, (%r14)
leaq -0x38(%rbp), %r13
movq %r12, %rdi
movq %r13, %rsi
movl $0xa, %edx
callq 0x32e0
cmpq %r12, (%r13)
je 0xf270
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0xf27c
movl (%r14), %ecx
cmpl $0x22, %ecx
je 0xf27c
testl %ecx, %ecx
jne 0xf1fe
movl -0x2c(%rbp), %ecx
movl %ecx, (%r14)
movl %eax, 0x4(%rbx)
movq (%r15), %rdi
callq 0x3270
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0xf288
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x3080
movl %eax, (%rbx)
testl %eax, %eax
js 0xf28d
leaq 0xc(%rbx), %rdi
movl $0x10, %esi
callq 0x33d0
movw $0x2, 0xc(%rbx)
movq 0x20(%rbx), %rax
movq 0x18(%rax), %rcx
movq (%rcx), %rsi
leaq 0x10(%rbx), %rdi
movslq 0x14(%rax), %rdx
callq 0x3390
movzwl 0x4(%rbx), %eax
rolw $0x8, %ax
movw %ax, 0xe(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x90f9(%rip), %rdi      # 0x18370
callq 0x3150
leaq 0x90ed(%rip), %rdi      # 0x18370
callq 0x3320
callq 0x35e0
callq 0x35c9
cmpl $0x0, (%r14)
jne 0xf29e
movl -0x2c(%rbp), %ecx
movl %ecx, (%r14)
movq %rax, %rdi
callq 0x33f0