LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/schaefed[P]Ndarray/src/ndarray.hpp
// Function: Ndarray<long, 2ul> Ndarray<long, 2ul>::operator[]<1ul>(Slice<1ul>)
Ndarray<T,N> operator[](Slice<DIM> slc){
		static_assert(DIM < N, "Invalid index dimension!");

		slc.update(this->shape[DIM]);
		this->checkIndex(slc);

		auto newshape = this->shape;
		auto newstrides = this->strides;
		auto start = slc.start * newstrides[DIM];
		newshape[DIM] = ceil((slc.stop - slc.start) / static_cast<double>(slc.step));
		newstrides[DIM] = newstrides[DIM] * slc.step;
		return Ndarray<T,N>(product(newshape),
							start + this->offset,
							shared_ptr<T>(this->data, (this->data).get()+start),
							newshape,
							newstrides // is start+data accesibly from the smart pointer?
							);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rsp), %r13
movq 0x28(%rsi), %rax
movq (%r13), %rcx
testq %rcx, %rcx
jns 0x500b
addq %rax, %rcx
movq %rcx, (%r13)
movq 0x8(%r13), %rcx
testq %rcx, %rcx
jns 0x501b
addq %rax, %rcx
movq %rcx, 0x8(%r13)
movq (%r13), %r15
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x5f46
movq 0x20(%r14), %rbp
movq 0x30(%r14), %rax
movq %rax, (%rsp)
movq 0x38(%r14), %r12
movq 0x8(%r13), %rax
movq 0x10(%r13), %r13
subq %r15, %rax
cvtsi2sd %rax, %xmm0
movq %r13, %xmm1
punpckldq 0x1fb4(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x1fbc(%rip), %xmm1     # 0x7020
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
callq 0x2030
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x1fa3(%rip), %xmm0     # 0x7030
cvttsd2si %xmm0, %rax
andq %rdx, %rax
orq %rcx, %rax
movq %rbp, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movl $0x1, %ecx
xorl %edx, %edx
imull 0x8(%rsp,%rdx), %ecx
addq $0x8, %rdx
cmpq $0x10, %rdx
jne 0x50a9
imulq %r12, %r15
imulq %r12, %r13
movslq %ecx, %rdx
movq 0x8(%r14), %rcx
addq %r15, %rcx
shlq $0x3, %r15
addq 0x10(%r14), %r15
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x50ec
movq 0x4ef6(%rip), %rsi      # 0x9fd8
cmpb $0x0, (%rsi)
je 0x50fd
incl 0x8(%rdi)
jmp 0x5101
movq %rdx, (%rbx)
movq %rcx, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movq %rdi, 0x18(%rbx)
jmp 0x5139
lock
incl 0x8(%rdi)
movq %rdx, (%rbx)
movq %rcx, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movq %rdi, 0x18(%rbx)
testq %rdi, %rdi
je 0x511f
cmpb $0x0, (%rsi)
je 0x5135
incl 0x8(%rdi)
jmp 0x5139
movq %rbp, 0x20(%rbx)
movq %rax, 0x28(%rbx)
movq (%rsp), %rax
movq %rax, 0x30(%rbx)
movq %r13, 0x38(%rbx)
jmp 0x5157
lock
incl 0x8(%rdi)
movq %rbp, 0x20(%rbx)
movq %rax, 0x28(%rbx)
movq (%rsp), %rax
movq %rax, 0x30(%rbx)
movq %r13, 0x38(%rbx)
testq %rdi, %rdi
je 0x5157
callq 0x5924
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/schaefed[P]Ndarray/src/ndarray.hpp
// Function: Ndarray<long, 1ul>::operator[](Slice<0ul>)
Ndarray<T,1> operator[](Slice<0> slc){

		slc.update(this->shape[0]);
		this->checkIndex(slc);

		auto newshape = this->shape;
		auto newstrides = this->strides;
		auto start = slc.start * newstrides[0];

		newshape[0] = ceil((slc.stop - slc.start) / static_cast<double>(slc.step));
		newstrides[0] = newstrides[0] * slc.step;

		return Ndarray<T,1>(1,
							start + this->offset,
							shared_ptr<T>(this->data, (this->data).get()+start),
							newshape,
							newstrides // is start+data accesibly from the smart pointer?
							);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x40(%rsp), %r13
movq 0x20(%rsi), %rax
movq (%r13), %rcx
testq %rcx, %rcx
jns 0x5358
addq %rax, %rcx
movq %rcx, (%r13)
movq 0x8(%r13), %rcx
testq %rcx, %rcx
jns 0x5368
addq %rax, %rcx
movq %rcx, 0x8(%r13)
movq (%r13), %r12
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x6142
movq 0x18(%r15), %r14
movq 0x28(%r15), %rbp
movq %rbp, (%rsp)
imulq %r12, %rbp
movq 0x8(%r13), %rax
movq 0x10(%r13), %r13
subq %r12, %rax
cvtsi2sd %rax, %xmm0
movq %r13, %xmm1
punpckldq 0x1c6a(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x1c72(%rip), %xmm1     # 0x7020
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
callq 0x2030
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
subsd 0x1c5d(%rip), %xmm0     # 0x7030
sarq $0x3f, %rdx
cvttsd2si %xmm0, %rax
andq %rdx, %rax
orq %rcx, %rax
imulq (%rsp), %r13
movq 0x8(%r15), %rcx
addq %rbp, %rcx
shlq $0x3, %rbp
addq 0x10(%r15), %rbp
testq %r14, %r14
je 0x540d
movq 0x4bd6(%rip), %rdx      # 0x9fd8
cmpb $0x0, (%rdx)
je 0x5422
incl 0x8(%r14)
jmp 0x5427
movq $0x1, (%rbx)
movq %rcx, 0x8(%rbx)
movq %rbp, 0x10(%rbx)
movq %r14, 0x18(%rbx)
jmp 0x5459
lock
incl 0x8(%r14)
movq $0x1, (%rbx)
movq %rcx, 0x8(%rbx)
movq %rbp, 0x10(%rbx)
movq %r14, 0x18(%rbx)
testq %r14, %r14
je 0x544a
cmpb $0x0, (%rdx)
je 0x5454
incl 0x8(%r14)
jmp 0x5459
movq %rax, 0x20(%rbx)
movq %r13, 0x28(%rbx)
jmp 0x546e
lock
incl 0x8(%r14)
movq %rax, 0x20(%rbx)
movq %r13, 0x28(%rbx)
testq %r14, %r14
je 0x546e
movq %r14, %rdi
callq 0x5924
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/schaefed[P]Ndarray/src/utils.hpp
// Function: std::vector<long, std::allocator<long>> concat<long>(std::initializer_list<std::vector<long, std::allocator<long>>>)
vector<T> concat(const initializer_list<vector<T>> args){
	vector<T> out (vector<T>(0));
	for (auto a: args){
		out.insert(out.end(), a.begin(), a.end());
	}
	return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
testq %rdx, %rdx
je 0x5686
movq %rsi, %r14
shlq $0x3, %rdx
leaq (%rdx,%rdx,2), %r12
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x6596
movq 0x8(%rbx), %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x6616
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x567c
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2120
addq $0x18, %r14
addq $-0x18, %r12
jne 0x5646
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x56b3
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x56b3
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2120
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x56c7
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2120
movq %r14, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O1/schaefed[P]Ndarray/src/ndarray.hpp
// Function: Ndarray<long, 2ul> NdarrayBase<long, 1ul>::broadcastTo<2ul>(std::array<unsigned long, 2ul>) const
Ndarray<T, M> broadcastTo(const array<size_t, M> newshape) const {
		static_assert(N <= M, "Can only broadcast to equal or higher dimensionality!");

	 	auto newstrides = filledArray<size_t, M>(0);
		auto offset = newshape.size() - shape.size();

		for (int64_t i=shape.size()-1; i>=0; --i){
			if (newshape[i+offset] == shape[i]){
				newstrides[i+offset] = strides[i];
			} else if (shape[i] != 1){
				throw DimensionError("Operands could not be braodcast together");
			}
		}
		return Ndarray<T, M>(product(newshape), this->offset, this->data, newshape, newstrides);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x20(%rsi), %rax
cmpq %rcx, %rax
jne 0x57ca
movq 0x28(%rsi), %rax
jmp 0x57d6
cmpq $0x1, %rax
jne 0x5896
xorl %eax, %eax
movq %rdx, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movl $0x1, %edi
xorl %r8d, %r8d
imull 0x8(%rsp,%r8), %edi
addq $0x8, %r8
cmpq $0x10, %r8
jne 0x57e8
movslq %edi, %r10
movq 0x8(%rsi), %r9
movq 0x10(%rsi), %r8
movq 0x18(%rsi), %rdi
testq %rdi, %rdi
je 0x581d
movq 0x47c5(%rip), %rsi      # 0x9fd8
cmpb $0x0, (%rsi)
je 0x582e
incl 0x8(%rdi)
jmp 0x5832
movq %r10, (%rbx)
movq %r9, 0x8(%rbx)
movq %r8, 0x10(%rbx)
movq %rdi, 0x18(%rbx)
jmp 0x5850
lock
incl 0x8(%rdi)
movq %r10, (%rbx)
movq %r9, 0x8(%rbx)
movq %r8, 0x10(%rbx)
movq %rdi, 0x18(%rbx)
testq %rdi, %rdi
je 0x5850
cmpb $0x0, (%rsi)
je 0x5866
incl 0x8(%rdi)
jmp 0x586a
movq %rdx, 0x20(%rbx)
movq %rcx, 0x28(%rbx)
movq $0x0, 0x30(%rbx)
movq %rax, 0x38(%rbx)
jmp 0x5888
lock
incl 0x8(%rdi)
movq %rdx, 0x20(%rbx)
movq %rcx, 0x28(%rbx)
movq $0x0, 0x30(%rbx)
movq %rax, 0x38(%rbx)
testq %rdi, %rdi
je 0x5888
callq 0x5924
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x2080
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1d7b(%rip), %rsi      # 0x762e
leaq 0x1d9c(%rip), %rdx      # 0x7656
leaq 0x18(%rsp), %rdi
callq 0x60b2
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x684e
xorl %ebp, %ebp
leaq 0x449b(%rip), %rsi      # 0x9d78
leaq 0xfb4(%rip), %rdx       # 0x6898
movq %rbx, %rdi
callq 0x2190
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x590e
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2120
jmp 0x590e
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x591b
movq %rbx, %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/schaefed[P]Ndarray/src/ndarray.hpp
// Function: NdarrayBase<long, 1ul>::checkIndex(long, unsigned long) const
void checkIndex(const int64_t idx, const uint64_t dim) const {
		if (N < 1){
			throw IndexError("Too many indices!");
		}
		if (dim > (N-1)){
			throw IndexError("Invalid index dimension!");
		}
		if ((idx < 0) or (idx >= static_cast<int64_t>(shape[dim]))) {
			throw IndexError("Index out of bounds");
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
testq %rdx, %rdx
jne 0x6167
testq %rsi, %rsi
js 0x61bf
cmpq %rsi, 0x20(%rdi)
jle 0x61bf
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x2080
movq %rax, %rbx
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x144b(%rip), %rsi      # 0x75cf
leaq 0x145c(%rip), %rdx      # 0x75e7
leaq 0x28(%rsp), %rdi
callq 0x60b2
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x6068
xorl %ebp, %ebp
leaq 0x3aaa(%rip), %rsi      # 0x9c58
leaq -0xeb7(%rip), %rdx      # 0x52fe
movq %rbx, %rdi
callq 0x2190
jmp 0x6215
movl $0x28, %edi
callq 0x2080
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x140c(%rip), %rsi      # 0x75e8
leaq 0x1418(%rip), %rdx      # 0x75fb
leaq 0x8(%rsp), %rdi
callq 0x60b2
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6068
xorl %ebp, %ebp
leaq 0x3a52(%rip), %rsi      # 0x9c58
leaq -0xf0f(%rip), %rdx      # 0x52fe
movq %rbx, %rdi
callq 0x2190
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x624d
movq 0x18(%rsp), %rsi
jmp 0x623d
jmp 0x6247
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x624d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2120
jmp 0x624d
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x625a
movq %rbx, %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O1/schaefed[P]Ndarray/src/utils.hpp
// Function: std::vector<unsigned long, std::allocator<unsigned long>> filterZeros<unsigned long, 2ul, unsigned long>(std::array<unsigned long, 2ul> const&)
vector<T> filterZeros(const array<T, N>& arg) {
	vector<T> out;
  for (auto e: arg){
  	if (e != 0){
  		out.push_back(e);
  	}
  }
  return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %r12d, %r12d
movq %rsp, %r15
movq (%r14,%r12), %rax
movq %rax, (%rsp)
testq %rax, %rax
je 0x62b3
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x62a8
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x62b3
movq %rbx, %rdi
movq %r15, %rdx
callq 0x62ec
addq $0x8, %r12
cmpq $0x10, %r12
jne 0x6284
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x62e3
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2120
movq %r14, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/schaefed[P]Ndarray/src/iterator.hpp
// Function: DataIterator<long, 2ul>::increment()
void increment(){
		size_t inc = 0;
		size_t tmp = ++iter;
		for (int64_t i=shape.size()-1; i>= 0; --i){
			auto n = tmp%(shape[i]);
			inc += (n*strides[i]);
			tmp /= shape[i];
		}
		if (tmp > 0){
			inc = shape[0] * filterZeros(strides)[0];
		}
		pos = buffer + inc;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rsi
incq %rax
movq %rax, 0x10(%rdi)
movq 0x20(%rdi), %rdi
movl $0x2, %r8d
xorl %r15d, %r15d
movq %rax, %rcx
movq -0x8(%rsi,%r8,8), %r9
xorl %edx, %edx
divq %r9
imulq -0x8(%rdi,%r8,8), %rdx
addq %rdx, %r15
decq %r8
jg 0x6450
cmpq %rcx, %r9
ja 0x649b
movq 0x18(%rbx), %rax
movq (%rax), %r15
movq 0x20(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x6262
movq (%r14), %rdi
movq 0x10(%r14), %rsi
imulq (%rdi), %r15
subq %rdi, %rsi
callq 0x2120
shlq $0x3, %r15
addq (%rbx), %r15
movq %r15, 0x8(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/thunlp[P]KB2E/TransE/Train_TransE.cpp
// Function: vec_len(std::vector<double, std::allocator<double>>&)
double vec_len(vector<double> &a)
{
	double res=0;
    for (int i=0; i<a.size(); i++)
		res+=a[i]*a[i];
	res = sqrt(res);
	return res;
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
subq %rax, %rcx
je 0x28cb
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rdx
cmpq %rdx, %rcx
jne 0x28b6
ucomisd %xmm1, %xmm0
jb 0x2150
sqrtsd %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/thunlp[P]KB2E/TransE/Train_TransE.cpp
// Function: ArgPos(char*, int, char**)
int ArgPos(char *str, int argc, char **argv) {
  int a;
  for (a = 1; a < argc; a++) if (!strcmp(str, argv[a])) {
    if (a == argc - 1) {
      printf("Argument missing for %s\n", str);
      exit(1);
    }
    return a;
  }
  return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpl $0x2, %esi
jl 0x3110
movq %rdx, %r14
movq %rdi, %rbx
movl %esi, %r12d
movl $0x1, %r15d
movq (%r14,%r15,8), %rsi
movq %rbx, %rdi
callq 0x2230
testl %eax, %eax
je 0x3107
incq %r15
decq %r12
cmpq $0x1, %r12
jne 0x30e9
jmp 0x3110
cmpl $0x2, %r12d
je 0x311b
movl %r15d, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3fcf(%rip), %rdi      # 0x70f1
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2050
movl $0x1, %edi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/thunlp[P]KB2E/TransE/Train_TransE.cpp
// Function: Train::add(int, int, int)
void add(int x,int y,int z)
    {
        fb_h.push_back(x);
        fb_r.push_back(z);
        fb_l.push_back(y);
        ok[make_pair(x,z)][y]=1;
    }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movl %esi, %eax
movq %rdi, %rbx
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movq 0x70(%rdi), %rsi
cmpq 0x78(%rdi), %rsi
je 0x35f2
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x70(%rbx)
jmp 0x3600
leaq 0x68(%rbx), %rdi
leaq 0x14(%rsp), %rdx
callq 0x3e14
movq 0xa0(%rbx), %rsi
cmpq 0xa8(%rbx), %rsi
je 0x3623
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0xa0(%rbx)
jmp 0x3634
leaq 0x98(%rbx), %rdi
leaq 0xc(%rsp), %rdx
callq 0x3e14
movq 0x88(%rbx), %rsi
cmpq 0x90(%rbx), %rsi
je 0x3657
movl 0x10(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x88(%rbx)
jmp 0x3668
leaq 0x80(%rbx), %rdi
leaq 0x10(%rsp), %rdx
callq 0x3e14
movl 0x14(%rsp), %eax
movl 0xc(%rsp), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
leaq 0x18(%rsp), %rsi
movq %rcx, (%rsi)
movq %rbx, %rdi
callq 0x3d86
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x3562
movl $0x1, (%rax)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/thunlp[P]KB2E/TransE/Train_TransE.cpp
// Function: Train::train_kb(int, int, int, int, int, int)
void train_kb(int e1_a,int e2_a,int rel_a,int e1_b,int e2_b,int rel_b)
    {
        double sum1 = calc_sum(e1_a,e2_a,rel_a);
        double sum2 = calc_sum(e1_b,e2_b,rel_b);
        if (sum1+margin>sum2)
        {
        	res+=margin+sum1-sum2;
        	gradient( e1_a, e2_a, rel_a, e1_b, e2_b, rel_b);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebp
movl %r8d, %r14d
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r13
movl 0x50(%rsp), %ebx
movl %ecx, 0x4(%rsp)
callq 0x5230
movsd %xmm0, 0x10(%rsp)
movq %r13, %rdi
movl %r14d, 0x8(%rsp)
movl %r14d, %esi
movl %ebp, 0xc(%rsp)
movl %ebp, %edx
movl %ebx, %ecx
callq 0x5230
movsd 0x10(%rsp), %xmm1
addsd 0x58(%r13), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x4ed6
subsd %xmm0, %xmm1
addsd 0x38(%r13), %xmm1
movsd %xmm1, 0x38(%r13)
movq %r13, %rdi
movl %r12d, %esi
movl %r15d, %edx
movl 0x4(%rsp), %ecx
movl 0x8(%rsp), %r8d
movl 0xc(%rsp), %r9d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5300
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/thunlp[P]KB2E/TransE/Train_TransE.cpp
// Function: Train::calc_sum(int, int, int)
double calc_sum(int e1,int e2,int rel)
    {
        double sum=0;
        if (L1_flag)
        	for (int ii=0; ii<n; ii++)
            	sum+=fabs(entity_vec[e2][ii]-entity_vec[e1][ii]-relation_vec[rel][ii]);
        else
        	for (int ii=0; ii<n; ii++)
            	sum+=sqr(entity_vec[e2][ii]-entity_vec[e1][ii]-relation_vec[rel][ii]);
        return sum;
    }

// Assembly:
movl 0x30(%rdi), %eax
cmpb $0x0, 0x4f66(%rip)      # 0xa1a0
je 0x52a2
testl %eax, %eax
jle 0x52fb
movslq %edx, %rdx
movq 0xc8(%rdi), %r8
movq 0xe0(%rdi), %rdi
leaq (%rdx,%rdx,2), %rdx
movq (%rdi,%rdx,8), %rdx
movslq %esi, %rsi
leaq (%rsi,%rsi,2), %rsi
movq (%rdi,%rsi,8), %rsi
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq (%r8,%rcx,8), %rcx
xorpd %xmm0, %xmm0
xorl %edi, %edi
movapd 0x1def(%rip), %xmm1     # 0x7070
movsd (%rdx,%rdi,8), %xmm2
subsd (%rsi,%rdi,8), %xmm2
subsd (%rcx,%rdi,8), %xmm2
andpd %xmm1, %xmm2
addsd %xmm2, %xmm0
incq %rdi
cmpq %rdi, %rax
jne 0x5281
jmp 0x52fa
testl %eax, %eax
jle 0x52fb
movslq %edx, %rdx
movq 0xc8(%rdi), %r8
movq 0xe0(%rdi), %rdi
leaq (%rdx,%rdx,2), %rdx
movq (%rdi,%rdx,8), %rdx
movslq %esi, %rsi
leaq (%rsi,%rsi,2), %rsi
movq (%rdi,%rsi,8), %rsi
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq (%r8,%rcx,8), %rcx
xorpd %xmm0, %xmm0
xorl %edi, %edi
movsd (%rdx,%rdi,8), %xmm1
subsd (%rsi,%rdi,8), %xmm1
subsd (%rcx,%rdi,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rdi
cmpq %rdi, %rax
jne 0x52db
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Jacobious52[P]Tanks/ConsoleTools.cpp
// Function: ConsoleTools::play_music(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void ConsoleTools::play_music(std::string filename)
{
    if (audio == false)
    {
        return;
    }

    std::ifstream file(filename.c_str(), std::ios::binary);
    if (file.good() == true)
    {
        #ifdef __APPLE__
            system(std::string("afplay " + filename + "&").c_str());
        #elif __linux__
            system(std::string("aplay -q " + filename + " &").c_str());
        #endif
    }
    else
    {
        audio = false;
    }
    file.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x250, %rsp            # imm = 0x250
cmpb $0x0, 0xd8a5(%rip)      # 0x11268
je 0x3a7d
movq %rdi, %rbx
movq (%rdi), %rsi
leaq -0x258(%rbp), %r14
movq %r14, %rdi
movl $0x4, %edx
callq 0x3470
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, -0x238(%rbp,%rax)
je 0x39fd
movb $0x0, 0xd86d(%rip)      # 0x11268
jmp 0x3a65
leaq 0x8648(%rip), %rsi      # 0xc04c
leaq -0x50(%rbp), %rdi
movq %rbx, %rdx
callq 0x3ae4
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
addq %rsi, %rdx
leaq -0x30(%rbp), %rdi
callq 0x3b70
leaq 0x8623(%rip), %rsi      # 0xc056
leaq -0x30(%rbp), %rdi
callq 0x3490
movq -0x30(%rbp), %rdi
callq 0x3210
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x3a53
callq 0x3240
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a65
callq 0x3240
leaq -0x258(%rbp), %rdi
callq 0x3090
leaq -0x258(%rbp), %rdi
callq 0x30c0
addq $0x250, %rsp            # imm = 0x250
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x3a8b
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x3aa1
callq 0x3240
jmp 0x3aa1
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3aba
callq 0x3240
jmp 0x3aba
jmp 0x3ab7
movq %rax, %rbx
leaq -0x258(%rbp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x3440
movq %rax, %rdi
callq 0x3ad6
// File: /workspace/github_cpp_makefile_star2_O1/Jacobious52[P]Tanks/GameView.cpp
// Function: GameView::draw()
void GameView::draw()
{
    // draw rain
    if (tag == 1)
    {
        for (int i = 0; i < get_size().x; i+=5)
        {
            ConsoleTools::set_fcolor(ConsoleTools::cyan);
            ConsoleTools::set_cursor(Point<int>(i, rand() % get_size().y));
            printf("|");
        }
    }

    //clear top line
    ConsoleTools::set_cursor(0, 1);
    ConsoleTools::clear_line();
    // print wind speed arrows
    ConsoleTools::set_fcolor(ConsoleTools::cyan);
    for (int i = 0; i < std::abs(_terrain->get_wind_speed()*10); ++i)
    {
        ConsoleTools::set_cursor(get_size().x/2 - 5 + i, 1);
        if (_terrain->get_wind_speed() > 0)
        {
            printf(">");
        }
        else if (_terrain->get_wind_speed() < 0)
        {
            printf("<");
        }
    }
    ConsoleTools::end_color();

    // draw children
    View::draw();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x1, 0x8(%rdi)
jne 0x4c75
movq %rbx, %rdi
callq 0x9a56
testl %eax, %eax
jle 0x4c75
xorl %r15d, %r15d
movl $0x24, %edi
callq 0x3852
callq 0x30d0
movl %eax, %r14d
movq %rbx, %rdi
callq 0x9a56
movq %rax, %rcx
shrq $0x20, %rcx
movl %r14d, %eax
cltd
idivl %ecx
shlq $0x20, %rdx
leaq (%rdx,%r15), %rdi
callq 0x3926
movl $0x7c, %edi
callq 0x3310
addq $0x5, %r15
movq %rbx, %rdi
callq 0x9a56
cmpl %eax, %r15d
jl 0x4c26
movl $0x1, %r14d
xorl %edi, %edi
movl $0x1, %esi
callq 0x38fc
callq 0x3912
movl $0x24, %edi
callq 0x3852
movq 0x38(%rbx), %rdi
callq 0x7f4e
mulss 0x73e1(%rip), %xmm0     # 0xc088
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
je 0x4d39
movq %rbx, %rdi
callq 0x9a56
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
leal (%r14,%rcx), %edi
addl $-0x6, %edi
movl $0x1, %esi
callq 0x38fc
movq 0x38(%rbx), %rdi
callq 0x7f4e
movl $0x3e, %edi
ucomiss 0x73a2(%rip), %xmm0     # 0xc08c
ja 0x4d02
movq 0x38(%rbx), %rdi
callq 0x7f4e
movl $0x3c, %edi
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x4d07
callq 0x3310
xorps %xmm0, %xmm0
cvtsi2ss %r14d, %xmm0
movss %xmm0, -0x1c(%rbp)
movq 0x38(%rbx), %rdi
callq 0x7f4e
mulss 0x7363(%rip), %xmm0     # 0xc088
andps 0x7374(%rip), %xmm0     # 0xc0a0
incl %r14d
ucomiss -0x1c(%rbp), %xmm0
ja 0x4cb3
callq 0x3898
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x9a0a
// File: /workspace/github_cpp_makefile_star2_O1/Jacobious52[P]Tanks/./Bullet.h
// Function: Bullet::Bullet(Point<int>, float, float, Terrain*)
Bullet(Point<int> start, float angle, float power, Terrain *terrain)
        : Sprite("*"),
        _angle(angle), _power(power)
    {
        _terrain = terrain;
         _position = start;
         _start_pos = _position;
        _init();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movss %xmm1, -0x30(%rbp)
movss %xmm0, -0x2c(%rbp)
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x40(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x714f(%rip), %rsi      # 0xc142
leaq 0x7149(%rip), %rdx      # 0xc143
leaq -0x50(%rbp), %r12
movq %r12, %rdi
callq 0x5744
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4ee6
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x501f
callq 0x3240
leaq 0xbc3a(%rip), %rax      # 0x10c60
addq $0x10, %rax
movq %rax, (%rbx)
movq $0x0, 0x60(%rbx)
movss -0x2c(%rbp), %xmm0
movss %xmm0, 0x68(%rbx)
movss -0x30(%rbp), %xmm0
movss %xmm0, 0x6c(%rbx)
movq %r14, 0x80(%rbx)
movq %r15, 0x18(%rbx)
movq %r15, 0x74(%rbx)
movq %rbx, %rdi
callq 0x8c14
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x570c
jmp 0x5095
movq %rax, %rdi
callq 0x3ad6
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x5095
callq 0x3240
movq %r14, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O1/Jacobious52[P]Tanks/./ConsoleTools.h
// Function: float ConsoleTools::get_input<float>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Point<int>)
static T get_input(std::string error_message, Point<int> ret_pos)
    {
        T input;

        std::cin >> input;

        // repeat until valid imput entered
        while (std::cin.fail() == true)
        {
            std::cin.clear();
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

            // set back to original pos
            set_cursor(ret_pos);
            printf("%s", error_message.c_str());
            clear_line();
            std::cin >> input;
        }

        // clear the buffer
        std::cin.ignore();
        std::cin.clear();
        std::cin.sync();

        return input;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq 0xbf27(%rip), %rbx      # 0x10fe0
leaq -0x2c(%rbp), %rsi
movq %rbx, %rdi
callq 0x34a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
testb $0x5, 0x20(%rbx,%rdi)
je 0x5136
addq %rbx, %rdi
leaq 0x70de(%rip), %r13      # 0xc1bb
leaq -0x2c(%rbp), %r12
xorl %esi, %esi
callq 0x3410
movq %rbx, %rdi
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
movl $0xa, %edx
callq 0x3160
movq %r14, %rdi
callq 0x3926
movq (%r15), %rsi
movq %r13, %rdi
xorl %eax, %eax
callq 0x3060
callq 0x3912
movq %rbx, %rdi
movq %r12, %rsi
callq 0x34a0
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
testb $0x5, 0x20(%rbx,%rax)
jne 0x50e1
movq %rbx, %rdi
callq 0x3460
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
xorl %esi, %esi
callq 0x3410
movq %rbx, %rdi
callq 0x3280
movss -0x2c(%rbp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Jacobious52[P]Tanks/./DebugView.h
// Function: DebugView::DebugView()
DebugView() : View()
    {
        show = false;
        _position = Point<int>(2, 2);
        _size = Point<int>::zero();
        _deb_map = std::map<std::string, float>();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
callq 0x5298
leaq 0xbb46(%rip), %rax      # 0x10d30
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x38(%rbx), %r14
leaq 0x40(%rbx), %rax
xorl %ecx, %ecx
movl %ecx, 0x40(%rbx)
movq %rcx, 0x48(%rbx)
movq %rax, 0x50(%rbx)
movq %rax, 0x58(%rbx)
movq %rcx, 0x60(%rbx)
movb $0x0, 0x31(%rbx)
movabsq $0x200000002, %rax      # imm = 0x200000002
movq %rax, 0x18(%rbx)
movq %rcx, 0x20(%rbx)
leaq -0x40(%rbp), %rax
movl %ecx, (%rax)
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x5390
leaq -0x48(%rbp), %rdi
movq 0x10(%rdi), %rsi
callq 0x5588
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x5273
movq %rax, %r15
leaq -0x48(%rbp), %rdi
movq 0x10(%rdi), %rsi
callq 0x5588
movq 0x48(%rbx), %rsi
movq %r14, %rdi
callq 0x5588
movq %rbx, %rdi
callq 0x530e
movq %r15, %rdi
callq 0x3440
movq %rax, %rdi
callq 0x3ad6
nop
// File: /workspace/github_cpp_makefile_star2_O1/Jacobious52[P]Tanks/EndView.cpp
// Function: EndView::draw()
void EndView::draw()
{
    // draw rain
    if (tag == 1)
    {
        for (int i = 0; i < get_size().x; i+=5)
        {
            ConsoleTools::set_fcolor(ConsoleTools::cyan);
            ConsoleTools::set_cursor(Point<int>(i, rand() % get_size().y));
            printf("|");
        }
    }

    // draw children
    View::draw();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x1, 0x8(%rdi)
jne 0x6869
movq %rbx, %rdi
callq 0x9a56
testl %eax, %eax
jle 0x6869
xorl %r15d, %r15d
movl $0x24, %edi
callq 0x3852
callq 0x30d0
movl %eax, %r14d
movq %rbx, %rdi
callq 0x9a56
movq %rax, %rcx
shrq $0x20, %rcx
movl %r14d, %eax
cltd
idivl %ecx
shlq $0x20, %rdx
leaq (%rdx,%r15), %rdi
callq 0x3926
movl $0x7c, %edi
callq 0x3310
addq $0x5, %r15
movq %rbx, %rdi
callq 0x9a56
cmpl %eax, %r15d
jl 0x681a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x9a0a
nop
// File: /workspace/github_cpp_makefile_star2_O1/Jacobious52[P]Tanks/Sprite.cpp
// Function: Sprite::draw()
void Sprite::draw()
{
    vstring lines = StringTools::split(get_texture(), "\n");
    for (int i = 0; i < lines.get_count(); ++i)
    {
        // draw relative to parent
        Point<int> parent_pos;
        if (get_parent() != 0)
        {
            parent_pos = get_parent()->get_position();
        }
        else
        {
            parent_pos = Point<int>::zero();
        }

        // set position
        ConsoleTools::set_cursor(parent_pos.x + get_position().x, parent_pos.y + get_position().y + i);
        // set color
        ConsoleTools::set_color(get_fcolor(), get_bcolor());
        // draw
        printf("%s\n", lines[i].c_str());
        // end color
        ConsoleTools::end_color();
    }

    View::draw();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq -0x98(%rbp), %r14
movq %r14, -0x10(%r14)
movq 0x38(%rdi), %rsi
movq 0x40(%rdi), %rdx
addq %rsi, %rdx
leaq -0xa8(%rbp), %rdi
callq 0x3b70
leaq -0x78(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x585f(%rip), %rsi      # 0xc1f5
leaq 0x5859(%rip), %rdx      # 0xc1f6
leaq -0x88(%rbp), %rdi
callq 0x5744
leaq -0x68(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x6c76
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x69d1
callq 0x3240
movq -0xa8(%rbp), %rdi
cmpq %r14, %rdi
je 0x69e2
callq 0x3240
cmpq $0x0, -0x60(%rbp)
je 0x6ac0
movl $0x8, %r14d
xorl %r13d, %r13d
movq %rbx, %rdi
callq 0x98d4
testq %rax, %rax
je 0x6a18
movq %rbx, %rdi
callq 0x98d4
movq %rax, %rdi
callq 0x9a42
movq %rax, %r15
jmp 0x6a1b
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x9a42
movq %rax, %r12
movq %rbx, %rdi
callq 0x9a42
movq %r15, %rcx
shrq $0x20, %rcx
addl %r15d, %r12d
shrq $0x20, %rax
addl %ecx, %eax
addl %r13d, %eax
movl %r12d, %edi
movl %eax, %esi
callq 0x38fc
movl 0x58(%rbx), %edi
movl 0x5c(%rbx), %esi
callq 0x387e
cmpq %r13, -0x60(%rbp)
jbe 0x6a7f
movq -0x68(%rbp), %rax
leaq -0x38(%rbp), %r15
movq %r15, -0x48(%rbp)
movq -0x8(%rax,%r14), %rsi
movq (%rax,%r14), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x3b70
jmp 0x6a93
leaq -0x38(%rbp), %r15
movq %r15, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
movq -0x48(%rbp), %rdi
callq 0x3380
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x6aaa
callq 0x3240
callq 0x3898
incq %r13
addq $0x20, %r14
cmpq %r13, -0x60(%rbp)
ja 0x69f6
movq %rbx, %rdi
callq 0x9a0a
leaq -0x68(%rbp), %rdi
callq 0x6b32
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6b15
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x6afe
callq 0x3240
jmp 0x6afe
movq %rax, %rbx
movq -0xa8(%rbp), %rdi
cmpq %r14, %rdi
je 0x6b21
callq 0x3240
jmp 0x6b21
jmp 0x6b15
jmp 0x6b15
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x6b32
movq %rbx, %rdi
callq 0x3440
movq %rax, %rdi
callq 0x3ad6
nop
// File: /workspace/github_cpp_makefile_star2_O1/Jacobious52[P]Tanks/StringTools.cpp
// Function: StringTools::string_width(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int StringTools::string_width(std::string instring)
{
    size_t count = 0;
    count = instring.find_first_of("\n");

    if (count == std::string::npos)
    {
        count = instring.length();
    }

    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5497(%rip), %rsi      # 0xc1f5
movl $0x1, %ecx
xorl %edx, %edx
callq 0x3360
cmpq $-0x1, %rax
jne 0x6d74
movq 0x8(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Jacobious52[P]Tanks/StringTools.cpp
// Function: StringTools::replace_all(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string StringTools::replace_all(std::string instring,
                                     std::string from,
                                     std::string to)
{
    size_t i = 0;
    while ((i = instring.find(from)) != std::string::npos)
    {
        instring.replace(i, from.length(), to);
        i += to.length();
    }
    return instring;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rsi
movq 0x8(%rdx), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x3430
cmpq $-0x1, %rax
je 0x6eac
movq 0x8(%r12), %rdx
movq (%r15), %rcx
movq 0x8(%r15), %r8
movq %r14, %rdi
movq %rax, %rsi
callq 0x32c0
movq (%r12), %rsi
movq 0x8(%r12), %rcx
jmp 0x6e7a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3b70
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Jacobious52[P]Tanks/StringTools.cpp
// Function: StringTools::readall(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string StringTools::readall(std::string filename)
{
    std::ifstream file(filename.c_str());
    std::stringstream ss;
    ss << file.rdbuf();
    if (!file)
    {
        return "$NO FILE";
    }
    file.close();
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x398, %rsp            # imm = 0x398
movq %rdi, %rbx
movq (%rsi), %rsi
leaq -0x210(%rbp), %rdi
movl $0x8, %edx
callq 0x3470
leaq -0x398(%rbp), %rdi
callq 0x31a0
leaq -0x388(%rbp), %rdi
leaq -0x200(%rbp), %rsi
callq 0x30a0
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x1f0(%rbp,%rax)
je 0x6f48
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x52b3(%rip), %rsi      # 0xc1ea
leaq 0x52b4(%rip), %rdx      # 0xc1f2
movq %rbx, %rdi
callq 0x5744
jmp 0x6f63
leaq -0x210(%rbp), %rdi
callq 0x3090
leaq -0x380(%rbp), %rsi
movq %rbx, %rdi
callq 0x33b0
leaq -0x398(%rbp), %rdi
callq 0x31d0
leaq -0x210(%rbp), %rdi
callq 0x30c0
movq %rbx, %rax
addq $0x398, %rsp            # imm = 0x398
popq %rbx
popq %rbp
retq
jmp 0x6f8a
movq %rax, %rbx
leaq -0x398(%rbp), %rdi
callq 0x31d0
jmp 0x6f9e
movq %rax, %rbx
leaq -0x210(%rbp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x3440
movq %rax, %rdi
callq 0x3ad6
// File: /workspace/github_cpp_makefile_star2_O1/Jacobious52[P]Tanks/StringTools.cpp
// Function: StringTools::readlines(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vstring StringTools::readlines(std::string filename)
{
    vstring lines;
    std::string line;
    std::ifstream file(filename.c_str());

    if (!file)
    {
        return lines;
    }

    while (getline(file, line))
    {
        lines.add(line);
    }
    file.close();
    return lines;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rsi, %r14
movq %rdi, %rbx
movl $0x80, %esi
callq 0x773c
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq (%r14), %rsi
leaq -0x270(%rbp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x3470
movq -0x270(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x250(%rbp,%rax)
jne 0x70a4
leaq -0x58(%rbp), %r13
leaq -0x48(%rbp), %r15
leaq -0x68(%rbp), %r12
movq -0x270(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3260
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3480
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x7094
movq %r13, -0x68(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x3b70
movq %rbx, %rdi
movq %r12, %rsi
callq 0x76fe
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x702e
callq 0x3240
jmp 0x702e
leaq -0x270(%rbp), %rdi
leaq -0x38(%rbp), %r15
callq 0x3090
leaq -0x270(%rbp), %rdi
callq 0x30c0
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x70be
callq 0x3240
movq %rbx, %rax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x70ed
movq %rax, %r14
jmp 0x70fc
movq %rax, %r14
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x70f0
callq 0x3240
jmp 0x70f0
movq %rax, %r14
leaq -0x270(%rbp), %rdi
callq 0x30c0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x710e
callq 0x3240
movq %rbx, %rdi
callq 0x6b32
movq %r14, %rdi
callq 0x3440
movq %rax, %rdi
callq 0x3ad6
// File: /workspace/github_cpp_makefile_star2_O1/Jacobious52[P]Tanks/StringTools.cpp
// Function: StringTools::ltrim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string StringTools::ltrim(std::string instring, std::string whitespaces)
{
    size_t i = instring.find_first_not_of(whitespaces);
    if (i == std::string::npos)
    {
        return instring;
    }
    else
    {
        return instring.substr(i, instring.size());
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rsi
movq 0x8(%rdx), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x3400
cmpq $-0x1, %rax
je 0x75c8
movq 0x8(%r14), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x3290
jmp 0x75e1
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3b70
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Jacobious52[P]Tanks/StringTools.cpp
// Function: StringTools::rtrim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string StringTools::rtrim(std::string instring, std::string whitespaces)
{
    size_t i = instring.find_last_not_of(whitespaces);
    if (i == std::string::npos)
    {
        return instring;
    }
    else
    {
        return instring.substr(0, i+1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rsi
movq 0x8(%rdx), %rcx
movq %r14, %rdi
movq $-0x1, %rdx
callq 0x33d0
cmpq $-0x1, %rax
je 0x7628
incq %rax
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x3290
jmp 0x7641
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3b70
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Jacobious52[P]Tanks/./MutableArray.h
// Function: MutableArray<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void add(T item)
    {
        if (_count >= _size)
        {
            // increasr the size of the array if we need
            _resize();
        }
        _items[_count++] = item;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
cmpq 0x10(%rdi), %rax
jb 0x771d
movq %r14, %rdi
callq 0x77b6
movq 0x8(%r14), %rdi
leaq 0x1(%rdi), %rax
movq %rax, 0x8(%r14)
shlq $0x5, %rdi
addq (%r14), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x3140
// File: /workspace/github_cpp_makefile_star2_O1/Jacobious52[P]Tanks/./MutableArray.h
// Function: MutableArray<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::init(unsigned long)
void init(size_t size)
    {
        _count = 0;
        _size = size;
        _increment_size = _size;
        _items = new T[_size];
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
movq %rsi, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
movq %rsi, %rax
shrq $0x3b, %rax
movq %rsi, %r15
shlq $0x5, %r15
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %r15, %rdi
orq $0x8, %rdi
callq 0x3030
movq %r14, (%rax)
leaq 0x8(%rax), %rcx
testq %r14, %r14
je 0x77a7
addq $0x18, %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x20, %rax
addq $-0x20, %r15
jne 0x778e
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Jacobious52[P]Tanks/./MutableArray.h
// Function: MutableArray<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::_resize()
void _resize()
    {
        size_t new_size = _size + _increment_size;

        T *new_items = new T[new_size];
        std::copy(_items, _items+_size, new_items);

        _size = new_size;
        delete[] _items;
        _items = new_items;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rbx
movq %rdi, -0x30(%rbp)
movq 0x18(%rdi), %r13
addq %rbx, %r13
movq %r13, %rax
shrq $0x3b, %rax
movq %r13, %r15
shlq $0x5, %r15
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %r15, %rdi
orq $0x8, %rdi
callq 0x3030
movq %rax, %r14
movq %r13, (%rax)
testq %r13, %r13
je 0x781d
leaq 0x18(%r14), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x20, %rax
addq $-0x20, %r15
jne 0x7804
addq $0x8, %r14
testq %rbx, %rbx
jle 0x784f
movq -0x30(%rbp), %rax
movq (%rax), %r15
incq %rbx
movq %r14, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x3140
addq $0x20, %r15
addq $0x20, %r12
decq %rbx
cmpq $0x1, %rbx
jg 0x7833
movq -0x30(%rbp), %rax
movq %r13, 0x10(%rax)
movq %rax, %r13
movq (%rax), %rax
testq %rax, %rax
je 0x789f
leaq -0x8(%rax), %r15
movq -0x8(%rax), %rbx
testq %rbx, %rbx
je 0x7897
shlq $0x5, %rbx
leaq (%rbx,%rax), %r12
addq $-0x10, %r12
negq %rbx
movq -0x10(%r12), %rdi
cmpq %rdi, %r12
je 0x788d
callq 0x3240
addq $-0x20, %r12
addq $0x20, %rbx
jne 0x787e
movq %r15, %rdi
callq 0x3300
movq %r14, (%r13)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Jacobious52[P]Tanks/Terrain.cpp
// Function: Terrain::_gen_terrain(int, int, int*)
void Terrain::_gen_terrain(int start, int length, int *height_map)
{
    int amp = (rand() % get_size().y/5) + 5;
    int period = (rand() % 40) + 10;
    int height = (rand() % get_size().y/10) + 5;
    int phase = rand() % get_size().x;

    for (int i = start; i < length; ++i)
    {
        height_map[i] = std::abs(amp*sin(((float)i/(float)period) - phase) + height) + 5;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, -0x50(%rbp)
movl %edx, %r12d
movl %esi, %r13d
movq %rdi, %r14
callq 0x30d0
movl %eax, -0x2c(%rbp)
movq %r14, %rdi
callq 0x9a56
movq %rax, -0x48(%rbp)
callq 0x30d0
movl %eax, -0x40(%rbp)
callq 0x30d0
movl %eax, -0x38(%rbp)
movq %r14, %rdi
callq 0x9a56
movq %rax, %r15
callq 0x30d0
movl %eax, %ebx
movq %r14, %rdi
callq 0x9a56
cmpl %r12d, %r13d
jge 0x7cc2
movq %rax, %rcx
movl %ebx, %eax
cltd
idivl %ecx
movl %edx, %ecx
shrq $0x20, %r15
movl -0x38(%rbp), %eax
cltd
idivl %r15d
movslq %edx, %rax
imulq $0x66666667, %rax, %rax # imm = 0x66666667
movq %rax, %rdx
shrq $0x20, %rdx
sarl $0x2, %edx
shrq $0x3f, %rax
leal (%rdx,%rax), %esi
addl $0x5, %esi
movslq -0x40(%rbp), %rax
imulq $0x66666667, %rax, %rdx # imm = 0x66666667
movq %rdx, %rdi
shrq $0x3f, %rdi
shrq $0x20, %rdx
sarl $0x4, %edx
addl %edi, %edx
shll $0x3, %edx
leal (%rdx,%rdx,4), %edx
negl %edx
leal (%rax,%rdx), %edi
addl $0xa, %edi
movq -0x48(%rbp), %r8
shrq $0x20, %r8
movl -0x2c(%rbp), %eax
cltd
idivl %r8d
movslq %edx, %rax
imulq $0x66666667, %rax, %rax # imm = 0x66666667
movq %rax, %rdx
shrq $0x20, %rdx
sarl %edx
shrq $0x3f, %rax
cvtsi2ss %edi, %xmm0
movss %xmm0, -0x2c(%rbp)
addl %edx, %eax
addl $0x5, %eax
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
movss %xmm0, -0x48(%rbp)
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x40(%rbp)
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
movsd %xmm0, -0x38(%rbp)
movslq %r13d, %rax
movslq %r12d, %rbx
movq -0x50(%rbp), %rcx
leaq (%rcx,%rax,4), %r14
movl %r13d, %r15d
subq %rax, %rbx
xorl %r12d, %r12d
leal (%r15,%r12), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss -0x2c(%rbp), %xmm0
subss -0x48(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x30b0
mulsd -0x40(%rbp), %xmm0
addsd -0x38(%rbp), %xmm0
andpd 0x4566(%rip), %xmm0     # 0xc210
addsd 0x456e(%rip), %xmm0     # 0xc220
cvttsd2si %xmm0, %eax
movl %eax, (%r14,%r12,4)
incq %r12
cmpq %r12, %rbx
jne 0x7c7a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Jacobious52[P]Tanks/Terrain.cpp
// Function: Terrain::get_floor(int)
int Terrain::get_floor(int x)
{
    // the minimum y value is the top of the terrian
    int min = INT_MAX;
    LOOPV(i, this)
    {
        Point<int> tile_pos = get_child(i)->get_position();
        if (tile_pos.x == x && tile_pos.y < min)
        {
            min = tile_pos.y;
        }
    }
    return min;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x98e8
cmpq $0x0, 0x8(%rax)
je 0x7d37
movl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x992e
movq %rax, %rdi
callq 0x9a42
movq %rax, %r12
shrq $0x20, %r12
cmpl %r12d, %r13d
cmovll %r13d, %r12d
cmpl %ebx, %eax
cmovnel %r13d, %r12d
incq %r15
movq %r14, %rdi
callq 0x98e8
movl %r12d, %r13d
cmpq 0x8(%rax), %r15
jb 0x7cfa
jmp 0x7d3d
movl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Jacobious52[P]Tanks/Terrain.cpp
// Function: Terrain::update(int)
void Terrain::update(int t)
{
    // update children
    LOOPV(i, this)
    {
        get_child(i)->update(t);
        if (get_child(i)->should_remove_from_parent() == true)
        {
            delete get_children()->remove(i);
            --i;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x98e8
cmpq $0x0, 0x8(%rax)
je 0x800a
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x992e
movq (%rax), %rcx
movq %rax, %rdi
movl %ebx, %esi
callq *0x10(%rcx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x992e
movq %rax, %rdi
callq 0x9a00
testb %al, %al
je 0x7ff5
movq %r14, %rdi
callq 0x98e8
movq 0x8(%rax), %rcx
cmpq %r15, %rcx
jbe 0x7fe5
movq (%rax), %rdx
movq (%rdx,%r15,8), %rdi
movq %r15, %rdx
movq (%rax), %rsi
movq 0x8(%rsi,%rdx,8), %r8
movq %r8, (%rsi,%rdx,8)
leaq 0x1(%rdx), %rsi
movq %rsi, %rdx
cmpq %rsi, %rcx
jne 0x7fc4
decq %rcx
movq %rcx, 0x8(%rax)
jmp 0x7fe7
xorl %edi, %edi
testq %rdi, %rdi
je 0x7ff2
movq (%rdi), %rax
callq *0x8(%rax)
decq %r15
incq %r15
movq %r14, %rdi
callq 0x98e8
cmpq 0x8(%rax), %r15
jb 0x7f7c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop