LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/kryffin[P]software-rasterizer/./geometry.cpp
// Function: Vec3f::cross(Vec3f)
Vec3f cross (Vec3f in) {
		return Vec3f(
        		(y * in.z) - (z * in.y),
        		(z * in.x) - (x * in.z),
        		(x * in.y) - (y * in.x)
        	);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss (%rdi), %xmm4
movss 0x4(%rdi), %xmm3
movss 0x8(%rdi), %xmm5
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2     # xmm2 = xmm2[1,1],xmm0[1,1]
movaps %xmm2, %xmm6
mulss %xmm5, %xmm6
mulss %xmm0, %xmm5
mulss %xmm3, %xmm0
mulss %xmm1, %xmm3
subss %xmm6, %xmm3
mulss %xmm4, %xmm1
subss %xmm1, %xmm5
unpcklps %xmm5, %xmm3            # xmm3 = xmm3[0],xmm5[0],xmm3[1],xmm5[1]
mulss %xmm4, %xmm2
subss %xmm0, %xmm2
movaps %xmm3, %xmm0
movaps %xmm2, %xmm1
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kryffin[P]software-rasterizer/./parser.cpp
// Function: Model::triangleVertice(int, int)
int triangleVertice (int ti, int i) {
	    assert(ti >= 0 && ti < nTriangles() && i >= 0 && i < 3);
	    if (i == 0) return triangles[ti].x;
	    if (i == 1) return triangles[ti].y;
	    return triangles[ti].z;
	}

// Assembly:
testl %esi, %esi
js 0x3b2e
movl %edx, %ecx
movq 0x18(%rdi), %r8
movq 0x20(%rdi), %rax
subq %r8, %rax
pushq $0xc
popq %rdi
cqto
idivq %rdi
cmpl $0x2, %ecx
ja 0x3b2e
cmpl %esi, %eax
jle 0x3b2e
movl %esi, %eax
imulq $0xc, %rax, %rax
cmpl $0x1, %ecx
je 0x3b1a
testl %ecx, %ecx
jne 0x3b23
addq %rax, %r8
jmp 0x3b2a
addq %rax, %r8
addq $0x4, %r8
jmp 0x3b2a
addq %rax, %r8
addq $0x8, %r8
movl (%r8), %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1566(%rip), %rdi      # 0x509f
leaq 0x158f(%rip), %rsi      # 0x50cf
leaq 0x1595(%rip), %rcx      # 0x50dc
pushq $0x54
popq %rdx
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/schaefed[P]Ndarray/src/utils.hpp
// Function: range(long)
vector<int64_t> range(int64_t stop){
	vector<int64_t> out(stop);
	int64_t i = 0;
	for (int64_t x=0 ; x < stop ; x++){
		out[i++] = x;
	}
	return out;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x7(%rsp), %rdx
callq 0x40bc
movq (%rbx), %rax
xorl %ecx, %ecx
testq %r14, %r14
cmovleq %rcx, %r14
cmpq %rcx, %r14
je 0x234a
movq %rcx, (%rax,%rcx,8)
incq %rcx
jmp 0x233c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/schaefed[P]Ndarray/src/utils.hpp
// Function: range(long, long, long)
vector<int64_t> range(int64_t start, int64_t stop, int64_t step=1){

	if ((start > stop) and (step > 0)){
		start = stop;
	}

	int64_t i = 0;
	vector<int64_t> out((stop-start)/step);
	for (int64_t x=start ; x < stop ; x = x + step){
		out[i++] = x;
	}
	return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
cmpq %rdx, %rsi
movq %rdx, %r12
cmovlq %rsi, %r12
testq %rcx, %rcx
cmovleq %rsi, %r12
movq %rdx, %rax
subq %r12, %rax
cqto
idivq %rcx
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0x40bc
movq (%r15), %rax
cmpq %r14, %r12
jge 0x23a3
movq %r12, (%rax)
addq %rbx, %r12
addq $0x8, %rax
jmp 0x2392
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/schaefed[P]Ndarray/test/test_ndarray.cpp
// Function: testOutOfBounds()
void testOutOfBounds(){
	array<size_t, 2> shape = {16, 16};
	vector<int64_t> basevec  = range(product<size_t>(shape));
	auto array = ndarray<int64_t, 2>(basevec.data(), shape);

	try{
		array[array.shape[0]];
		assert(false); // exception not thrown!
	} catch(IndexError){}
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rsp, %rbx
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
callq 0x231c
leaq 0x18(%rsp), %r8
andq $0x0, 0x8(%r8)
movq (%rbx), %rsi
leaq 0x193d(%rip), %rax      # 0x41af
movq %rax, (%r8)
leaq 0x285a(%rip), %rax      # 0x50d6
movq %rax, 0x18(%r8)
leaq 0x2857(%rip), %rax      # 0x50de
movq %rax, 0x10(%r8)
leaq 0x38(%rsp), %rdi
pushq $0x10
popq %rcx
movq %rcx, %rdx
callq 0x410d
leaq 0x18(%rsp), %rdi
callq 0x41b0
leaq 0x38(%rsp), %rsi
movq 0x20(%rsi), %rdx
leaq 0xa0(%rsp), %rdi
callq 0x41cc
leaq 0xa0(%rsp), %rdi
callq 0x460e
leaq 0x3803(%rip), %rdi      # 0x60d2
leaq 0x3772(%rip), %rsi      # 0x6048
leaq 0x37fb(%rip), %rcx      # 0x60d8
pushq $0x2f
popq %rdx
callq 0x20c0
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x2937
movq %rbx, %rdi
callq 0x2140
leaq 0x78(%rsp), %rdi
movq %rax, %rsi
callq 0x4618
movq %rbx, %rdi
callq 0x2070
leaq 0x78(%rsp), %rdi
callq 0x465c
callq 0x21a0
leaq 0x50(%rsp), %rdi
callq 0x4adc
movq %rsp, %rdi
callq 0x4c0c
addq $0xd0, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x4adc
jmp 0x2958
movq %rax, %rdi
callq 0x4651
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x41b0
movq %rsp, %rdi
callq 0x4c0c
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/schaefed[P]Ndarray/test/test_ndarray.cpp
// Function: main
int main(){

	testAssignment();
	testOutOfBounds();
	testSlicing();
	testIterator();
	testBroadcasting();

	return 0;
}

// Assembly:
pushq %rax
callq 0x23b2
callq 0x2846
callq 0x2968
callq 0x3943
callq 0x3e1c
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/schaefed[P]Ndarray/src/funcs.hpp
// Function: Ndarray<long, 2ul> ndarray<long, 2ul>(long*, std::array<unsigned long, 2ul>, std::function<void (long*)>)
Ndarray<T, N> ndarray(T* data_, array<size_t, N> shape_, function<void(T*)> destructor_=_deleteNothing<T>){
	return Ndarray<T,N>(product(shape_),
						0,
						shared_ptr<T>(data_, destructor_),
						shape_,
						calcStrides(shape_)
						);	
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r8, %rsi
callq 0x4ce6
movq %rsp, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x4d2c
movl %r15d, %eax
imull %r14d, %eax
cltq
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
leaq 0x10(%rbx), %rdi
movq %rsp, %rsi
callq 0x4bac
movq %r15, 0x20(%rbx)
movq %r14, 0x28(%rbx)
movq %r14, 0x30(%rbx)
movq $0x1, 0x38(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x4adc
leaq 0x10(%rsp), %rdi
callq 0x41b0
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x41b0
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/schaefed[P]Ndarray/src/ndarray.hpp
// Function: Ndarray<long, 2ul>::operator[](long)
Ndarray<T,N-1> operator[](int64_t idx){

		idx = this->updateIndex(idx, 0);
		this->checkIndex(idx, 0);

		auto newshape = subarray<size_t, N-1>(this->shape, 1);
		auto start = idx * this->strides[0];

		return Ndarray<T, N-1>(product(newshape),
							   start + this->offset,
							   shared_ptr<T>(this->data, this->data.get()+start),
							   newshape,
							   subarray<size_t, N-1>(this->strides, 1)
							   );
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %r15
sarq $0x3f, %r15
andq 0x20(%rsi), %r15
addq %rdx, %r15
movq %rsi, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x5100
movq 0x28(%r14), %r13
imulq 0x30(%r14), %r15
movq 0x8(%r14), %rbp
addq %r15, %rbp
shlq $0x3, %r15
addq 0x10(%r14), %r15
movslq %r13d, %r12
leaq 0x10(%rsp), %rdi
movq %r15, -0x8(%rdi)
leaq 0x18(%r14), %rsi
movq %rdi, %r15
callq 0x4bc0
movq 0x38(%r14), %r14
movq %r12, (%rbx)
movq %rbp, 0x8(%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x4bac
movq %r13, 0x20(%rbx)
movq %r14, 0x28(%rbx)
movq %r15, %rdi
callq 0x4adc
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/schaefed[P]Ndarray/src/ndarray.hpp
// Function: Ndarray<long, 1ul>::operator[](long)
T& operator[](int64_t idx){
		idx = this->updateIndex(idx, 0);
		this->checkIndex(idx, 0);
		auto start = idx * this->strides[0];
		return this->data.get()[start];
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %r14
sarq $0x3f, %r14
andq 0x20(%rdi), %r14
addq %rsi, %r14
movq %r14, %rsi
xorl %edx, %edx
callq 0x52f2
imulq 0x28(%rbx), %r14
shlq $0x3, %r14
addq 0x10(%rbx), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rsi), %rsi
leaq 0x60(%rsp), %r15
movq %r15, %rdi
callq 0x5650
movq (%r15), %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x5100
movq 0x20(%r14), %rbp
movq %rbp, 0x8(%rsp)
movq 0x30(%r14), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%r14), %rcx
movq %rcx, (%rsp)
movq (%r15), %r12
movq 0x8(%r15), %rax
subq %r12, %rax
imulq %rcx, %r12
cvtsi2sd %rax, %xmm0
movq 0x10(%r15), %rax
movq %rax, %xmm1
movq %rax, %r15
punpckldq 0x1c12(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x1c1a(%rip), %xmm1     # 0x6020
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
callq 0x2030
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x1c01(%rip), %xmm0     # 0x6030
cvttsd2si %xmm0, %r13
andq %rcx, %r13
orq %rax, %r13
imulq (%rsp), %r15
movq %r15, (%rsp)
movl %ebp, %eax
imull %r13d, %eax
movq 0x8(%r14), %r15
addq %r12, %r15
shlq $0x3, %r12
addq 0x10(%r14), %r12
movslq %eax, %rbp
leaq 0x20(%rsp), %rdi
movq %r12, -0x8(%rdi)
addq $0x18, %r14
movq %rdi, %r12
movq %r14, %rsi
callq 0x4bc0
movq %rbp, (%rbx)
movq %r15, 0x8(%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x18(%rsp), %rsi
callq 0x4bac
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rbx)
movq %r13, 0x28(%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rbx)
movq (%rsp), %rax
movq %rax, 0x38(%rbx)
movq %r12, %rdi
callq 0x4adc
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %rsi
leaq 0x50(%rsp), %r15
movq %r15, %rdi
callq 0x5722
movq (%r15), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x52f2
movq 0x28(%r14), %rcx
movq %rcx, (%rsp)
movq (%r15), %r13
movq 0x8(%r15), %rax
subq %r13, %rax
imulq %rcx, %r13
cvtsi2sd %rax, %xmm0
movq 0x10(%r15), %r12
movq %r12, %xmm1
punpckldq 0x1936(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x193e(%rip), %xmm1     # 0x6020
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
callq 0x2030
cvttsd2si %xmm0, %rax
movq %rax, %rcx
subsd 0x1929(%rip), %xmm0     # 0x6030
cvttsd2si %xmm0, %rbp
sarq $0x3f, %rcx
andq %rcx, %rbp
orq %rax, %rbp
movq 0x8(%r14), %r15
addq %r13, %r15
shlq $0x3, %r13
addq 0x10(%r14), %r13
imulq (%rsp), %r12
leaq 0x10(%rsp), %rdi
movq %r13, -0x8(%rdi)
addq $0x18, %r14
movq %rdi, %r13
movq %r14, %rsi
callq 0x4bc0
movq $0x1, (%rbx)
movq %r15, 0x8(%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x4bac
movq %rbp, 0x20(%rbx)
movq %r12, 0x28(%rbx)
movq %r13, %rdi
callq 0x4adc
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_O2/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 %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
xorl %esi, %esi
movq %r15, %rdx
callq 0x40bc
imulq $0x18, %r12, %r12
testq %r12, %r12
je 0x490e
movq %r15, %rdi
movq %r14, %rsi
callq 0x5742
movq 0x8(%rbx), %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x5790
movq %r15, %rdi
callq 0x4c0c
addq $0x18, %r14
addq $-0x18, %r12
jmp 0x48d7
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x492d
movq %rax, %r14
movq %rsp, %rdi
callq 0x4c0c
movq %rbx, %rdi
callq 0x4c0c
movq %r14, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
movq 0x20(%rsi), %rax
cmpq %rcx, %rax
jne 0x49f9
movq 0x28(%rsi), %rax
movq %rax, 0x10(%rsp)
jmp 0x4a08
cmpq $0x1, %rax
jne 0x4a6c
movq $0x0, 0x10(%rsp)
movl %r15d, %eax
imull %r14d, %eax
movslq %eax, %rbp
movq 0x8(%rsi), %r13
addq $0x10, %rsi
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x4bac
movq %rbp, (%rbx)
movq %r13, 0x8(%rbx)
leaq 0x10(%rbx), %rdi
movq %r12, %rsi
callq 0x4bac
movq %r15, 0x20(%rbx)
movq %r14, 0x28(%rbx)
andq $0x0, 0x30(%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rbx)
leaq 0x20(%rsp), %rdi
callq 0x4adc
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x20a0
movq %rax, %rbx
leaq 0x1bb0(%rip), %rsi      # 0x662e
leaq 0x28(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x51ea
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x59a4
xorl %ebp, %ebp
leaq 0x52d2(%rip), %rsi      # 0x9d78
leaq 0xf2d(%rip), %rdx       # 0x59da
movq %rbx, %rdi
callq 0x21b0
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x2090
testb %bpl, %bpl
jne 0x4acc
jmp 0x4ad4
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x50, %rsp
testq %rdx, %rdx
jne 0x5313
testq %rsi, %rsi
js 0x535e
cmpq %rsi, 0x20(%rdi)
jle 0x535e
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x20a0
movq %rax, %rbx
leaq 0x12aa(%rip), %rsi      # 0x65cf
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x51ea
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x5226
xorl %ebp, %ebp
leaq 0x48d3(%rip), %rsi      # 0x9c20
leaq -0xcf8(%rip), %rdx      # 0x465c
movq %rbx, %rdi
callq 0x21b0
jmp 0x53a7
pushq $0x28
popq %rdi
callq 0x20a0
movq %rax, %rbx
leaq 0x1278(%rip), %rsi      # 0x65e8
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x51ea
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x5226
xorl %ebp, %ebp
leaq 0x4888(%rip), %rsi      # 0x9c20
leaq -0xd43(%rip), %rdx      # 0x465c
movq %rbx, %rdi
callq 0x21b0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
jmp 0x53bb
jmp 0x53c7
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x2090
testb %bpl, %bpl
jne 0x53ca
jmp 0x53d2
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %r12d, %r12d
movq %rsp, %r15
cmpq $0x10, %r12
je 0x541d
movq (%r14,%r12), %rax
movq %rax, (%rsp)
testq %rax, %rax
je 0x5417
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5440
addq $0x8, %r12
jmp 0x53f9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x55ba
movq %r14, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %rcx
incq %rax
movq %rax, 0x10(%rdi)
movq 0x20(%rdi), %rsi
pushq $0x2
popq %rdi
xorl %r15d, %r15d
testq %rdi, %rdi
jle 0x5617
xorl %edx, %edx
divq -0x8(%rcx,%rdi,8)
imulq -0x8(%rsi,%rdi,8), %rdx
decq %rdi
addq %rdx, %r15
jmp 0x55fd
testq %rax, %rax
je 0x563b
movq (%rcx), %r15
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x53da
movq (%r14), %rax
imulq (%rax), %r15
movq %r14, %rdi
callq 0x55ba
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_O2/schaefed[P]Ndarray/src/slice.hpp
// Function: Slice<1ul>::update(unsigned long)
void update(size_t length){
		if (start < 0){
			start += length;
		}
		if (stop < 0){
			stop += length;
		}
	}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
jns 0x565e
addq %rsi, %rax
movq %rax, (%rdi)
movq 0x8(%rdi), %rax
testq %rax, %rax
js 0x5668
retq
addq %rsi, %rax
movq %rax, 0x8(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
subq %rax, %rcx
sarq $0x3, %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x2823
movsd (%rax,%rdx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rdx
jmp 0x280c
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x2130
sqrtsd %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movslq %esi, %r12
leal -0x2(%r12), %r13d
pushq $0x1
popq %r15
pushq $-0x1
popq %rbp
cmpq %r12, %r15
jge 0x2e1b
movq (%r14,%r15,8), %rsi
movq %rbx, %rdi
callq 0x2230
testl %eax, %eax
je 0x2e13
incq %r15
decl %r13d
jmp 0x2df6
testl %r13d, %r13d
je 0x2e2c
movl %r15d, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x32be(%rip), %rdi      # 0x60f1
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2040
pushq $0x1
popq %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/thunlp[P]KB2E/TransE/Train_TransE.cpp
// Function: main
int main(int argc,char**argv)
{
    srand((unsigned) time(NULL));
    int method = 1;
    int n = 100;
    double rate = 0.001;
    double margin = 1;
    int i;
    if ((i = ArgPos((char *)"-size", argc, argv)) > 0) n = atoi(argv[i + 1]);
    if ((i = ArgPos((char *)"-margin", argc, argv)) > 0) margin = atoi(argv[i + 1]);
    if ((i = ArgPos((char *)"-method", argc, argv)) > 0) method = atoi(argv[i + 1]);
    cout<<"size = "<<n<<endl;
    cout<<"learing rate = "<<rate<<endl;
    cout<<"margin = "<<margin<<endl;
    if (method)
        version = "bern";
    else
        version = "unif";
    cout<<"method = "<<version<<endl;
    prepare();
    train.run(n,rate,margin,method);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %ebp
xorl %edi, %edi
callq 0x2170
movl %eax, %edi
callq 0x2180
leaq 0x32a4(%rip), %rdi      # 0x610a
movl %ebp, %esi
movq %r14, %rdx
callq 0x2dd6
testl %eax, %eax
jle 0x2e84
movl %eax, %eax
movq 0x8(%r14,%rax,8), %rdi
callq 0x2270
movl %eax, %ebx
jmp 0x2e87
pushq $0x64
popq %rbx
leaq 0x3282(%rip), %rdi      # 0x6110
movl %ebp, %esi
movq %r14, %rdx
callq 0x2dd6
testl %eax, %eax
jle 0x2eae
movl %eax, %eax
movq 0x8(%r14,%rax,8), %rdi
callq 0x2270
cvtsi2sd %eax, %xmm0
jmp 0x2eb6
movsd 0x3162(%rip), %xmm0     # 0x6018
movsd %xmm0, (%rsp)
leaq 0x3256(%rip), %rdi      # 0x6118
movl %ebp, %esi
movq %r14, %rdx
callq 0x2dd6
testl %eax, %eax
jle 0x2ee0
movl %eax, %eax
movq 0x8(%r14,%rax,8), %rdi
callq 0x2270
movl %eax, %ebp
jmp 0x2ee3
pushq $0x1
popq %rbp
movq 0x70ee(%rip), %r14      # 0x9fd8
leaq 0x322f(%rip), %rsi      # 0x6120
movq %r14, %rdi
callq 0x2190
movq %rax, %rdi
movl %ebx, %esi
callq 0x22c0
movq %rax, %rdi
callq 0x20c0
leaq 0x3216(%rip), %rsi      # 0x6128
movq %r14, %rdi
callq 0x2190
movsd 0x30fe(%rip), %xmm0     # 0x6020
movq %rax, %rdi
callq 0x2290
movq %rax, %rdi
callq 0x20c0
leaq 0x31ff(%rip), %rsi      # 0x6138
movq %r14, %rdi
callq 0x2190
movq %rax, %rdi
movsd (%rsp), %xmm0
callq 0x2290
movq %rax, %rdi
callq 0x20c0
testl %ebp, %ebp
leaq 0x31e8(%rip), %rax      # 0x6147
leaq 0x31dc(%rip), %rsi      # 0x6142
cmoveq %rax, %rsi
leaq 0x7267(%rip), %r15      # 0xa1d8
movq %r15, %rdi
callq 0x2310
leaq 0x31cc(%rip), %rsi      # 0x614c
movq %r14, %rdi
callq 0x2190
movq %rax, %rdi
movq %r15, %rsi
callq 0x2160
movq %rax, %rdi
callq 0x20c0
callq 0x2836
leaq 0x38121(%rip), %rdi     # 0x3b0c8
movl %ebx, %esi
movsd 0x306f(%rip), %xmm0     # 0x6020
movsd (%rsp), %xmm1
movl %ebp, %edx
callq 0x32cc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0xc(%rsp), %r15
movl %esi, (%r15)
leaq 0x8(%rsp), %rbx
movl %edx, (%rbx)
leaq 0x4(%rsp), %r12
movl %ecx, (%r12)
addq $0x68, %rdi
movq %r15, %rsi
callq 0x3972
leaq 0x98(%r14), %rdi
movq %r12, %rsi
callq 0x3972
leaq 0x80(%r14), %rdi
movq %rbx, %rsi
callq 0x3972
movl (%r15), %eax
movl (%r12), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
leaq 0x10(%rsp), %rsi
movq %rcx, (%rsi)
movq %r14, %rdi
callq 0x3990
movq %rax, %rdi
movq %rbx, %rsi
callq 0x31a4
movl $0x1, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4dfe
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 0x4dfe
movsd 0x10(%rsp), %xmm1
addsd 0x58(%r13), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x49bc
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 0x4eac
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %r8d
movslq %edx, %rax
movq 0xe0(%rdi), %r9
imulq $0x18, %rax, %rax
addq %r9, %rax
movslq %esi, %rdx
imulq $0x18, %rdx, %rdx
addq %r9, %rdx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
xorl %esi, %esi
addq 0xc8(%rdi), %rcx
testl %r8d, %r8d
cmovgl %r8d, %esi
cmpb $0x0, 0x536d(%rip)      # 0xa1a8
je 0x4e78
xorpd %xmm0, %xmm0
xorl %edi, %edi
movapd 0x1225(%rip), %xmm1     # 0x6070
cmpq %rdi, %rsi
je 0x4eab
movq (%rax), %r8
movsd (%r8,%rdi,8), %xmm2
movq (%rdx), %r8
subsd (%r8,%rdi,8), %xmm2
movq (%rcx), %r8
subsd (%r8,%rdi,8), %xmm2
andpd %xmm1, %xmm2
addsd %xmm2, %xmm0
incq %rdi
jmp 0x4e4b
xorpd %xmm0, %xmm0
xorl %edi, %edi
cmpq %rdi, %rsi
je 0x4eab
movq (%rax), %r8
movsd (%r8,%rdi,8), %xmm1
movq (%rdx), %r8
subsd (%r8,%rdi,8), %xmm1
movq (%rcx), %r8
subsd (%r8,%rdi,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rdi
jmp 0x4e7e
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, 0xd8b5(%rip)      # 0x11288
je 0x3a65
movq %rdi, %rbx
movq (%rdi), %rsi
leaq -0x258(%rbp), %r14
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x3480
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, -0x238(%rbp,%rax)
je 0x3a0b
movb $0x0, 0xd87f(%rip)      # 0x11288
jmp 0x3a4d
leaq 0x763a(%rip), %rsi      # 0xb04c
leaq -0x30(%rbp), %rdi
movq %rbx, %rdx
callq 0x3afc
leaq 0x7631(%rip), %rdx      # 0xb056
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3abc
movq -0x50(%rbp), %rdi
callq 0x3250
leaq -0x50(%rbp), %rdi
callq 0x3340
leaq -0x30(%rbp), %rdi
callq 0x3340
leaq -0x258(%rbp), %rdi
callq 0x3090
leaq -0x258(%rbp), %rdi
callq 0x30c0
addq $0x250, %rsp            # imm = 0x250
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3340
jmp 0x3a84
jmp 0x3a8f
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x3340
jmp 0x3a92
movq %rax, %rbx
leaq -0x258(%rbp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x3450
movq %rax, %rdi
callq 0x3aae
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x1, 0x8(%rdi)
jne 0x49d7
xorl %r13d, %r13d
pushq $0x24
popq %r14
pushq $0x7c
popq %r15
movq %rbx, %rdi
callq 0x8d2e
cltq
cmpq %rax, %r13
jge 0x49d7
movl %r14d, %edi
callq 0x386e
callq 0x30d0
movl %eax, %r12d
movq %rbx, %rdi
callq 0x8d2e
movq %rax, %rcx
shrq $0x20, %rcx
movl %r12d, %eax
cltd
idivl %ecx
shlq $0x20, %rdx
leaq (%rdx,%r13), %rdi
callq 0x3938
movl %r15d, %edi
callq 0x3370
addq $0x5, %r13
jmp 0x4988
pushq $0x1
popq %r14
xorl %edi, %edi
movl %r14d, %esi
callq 0x390e
callq 0x3924
pushq $0x24
popq %rdi
callq 0x386e
pushq $-0x5
popq %r15
pushq $0x2
popq %r12
pushq $0x3e
popq %r13
leal 0x5(%r15), %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x2c(%rbp)
movq 0x38(%rbx), %rdi
callq 0x7630
mulss 0x6644(%rip), %xmm0     # 0xb060
andps 0x665d(%rip), %xmm0     # 0xb080
ucomiss -0x2c(%rbp), %xmm0
jbe 0x4a74
movq %rbx, %rdi
callq 0x8d2e
cltd
idivl %r12d
leal (%rax,%r15), %edi
movl %r14d, %esi
callq 0x390e
movq 0x38(%rbx), %rdi
callq 0x7630
ucomiss 0x6613(%rip), %xmm0     # 0xb064
movl %r13d, %edi
ja 0x4a6a
movq 0x38(%rbx), %rdi
callq 0x7630
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
pushq $0x3c
popq %rdi
jbe 0x4a6f
callq 0x3370
incl %r15d
jmp 0x49fe
callq 0x38b4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8cec
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x38, %rsp
movq %rdx, %r14
movss %xmm1, -0x24(%rbp)
movss %xmm0, -0x20(%rbp)
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x6459(%rip), %rsi      # 0xb112
leaq -0x48(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x3120
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x4be2
leaq -0x48(%rbp), %rdi
callq 0x3340
leaq 0xbf7e(%rip), %rax      # 0x10c60
addq $0x10, %rax
movq %rax, (%rbx)
andq $0x0, 0x60(%rbx)
movss -0x20(%rbp), %xmm0
movss %xmm0, 0x68(%rbx)
movss -0x24(%rbp), %xmm0
movss %xmm0, 0x6c(%rbx)
movq %r14, 0x80(%rbx)
movq %r15, 0x18(%rbx)
movq %r15, 0x74(%rbx)
movq %rbx, %rdi
callq 0x813c
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5496
jmp 0x4d4a
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x3340
jmp 0x4d4a
movq %rax, %rdi
callq 0x3aae
movq %rax, %r14
movq %r14, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc273(%rip), %rbx      # 0x10fe0
pushq $0xa
popq %r13
leaq 0x6413(%rip), %r12      # 0xb18b
movq %rbx, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x34e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
testb $0x5, 0x20(%rbx,%rdi)
je 0x4dcd
addq %rbx, %rdi
xorl %esi, %esi
callq 0x3430
movq %rbx, %rdi
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
movl %r13d, %edx
callq 0x31a0
movq %r14, %rdi
callq 0x3938
movq (%r15), %rsi
movq %r12, %rdi
xorl %eax, %eax
callq 0x3050
callq 0x3924
jmp 0x4d78
movq %rbx, %rdi
callq 0x3470
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
xorl %esi, %esi
callq 0x3430
movq %rbx, %rdi
callq 0x32e0
movss -0x2c(%rbp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4f36
leaq 0xbea0(%rip), %rax      # 0x10d30
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x40(%rbx), %rax
andl $0x0, 0x40(%rbx)
andq $0x0, 0x48(%rbx)
movq %rax, 0x50(%rbx)
movq %rax, 0x58(%rbx)
andq $0x0, 0x60(%rbx)
leaq 0x38(%rbx), %r14
movb $0x0, 0x31(%rbx)
movabsq $0x200000002, %rax      # imm = 0x200000002
movq %rax, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
leaq -0x40(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x5026
leaq -0x48(%rbp), %rdi
callq 0x5452
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x4f16
movq %rax, %r15
leaq -0x48(%rbp), %rdi
callq 0x5452
movq %r14, %rdi
callq 0x5452
movq %rbx, %rdi
callq 0x4f8c
movq %r15, %rdi
callq 0x3450
movq %rax, %rdi
callq 0x3aae
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $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 0x6f6b
addq $0x18, %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x20, %rax
addq $-0x20, %r15
jne 0x6f55
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Jacobious52[P]Tanks/./MutableArray.h
// Function: MutableArray<View*>::remove(unsigned long)
T remove(size_t index)
    {
        if (index >= 0 && index < _count)
        {
            // get item being removed
            T item = _items[index];
            // shift everything right once
            for (size_t i = index; i < _count; ++i)
            {
                _items[i] = _items[i+1];
            }

            --_count;

            return item;
        }

        return T();
    }

// Assembly:
movq 0x8(%rdi), %rcx
cmpq %rsi, %rcx
jbe 0x5493
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq (%rax,%rsi,8), %rax
cmpq %rcx, %rsi
jae 0x548a
movq (%rdi), %rdx
movq 0x8(%rdx,%rsi,8), %r8
movq %r8, (%rdx,%rsi,8)
incq %rsi
jmp 0x5474
decq %rcx
movq %rcx, 0x8(%rdi)
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x1, 0x8(%rdi)
jne 0x62e7
xorl %r13d, %r13d
pushq $0x24
popq %r14
pushq $0x7c
popq %r15
movq %rbx, %rdi
callq 0x8d2e
cltq
cmpq %rax, %r13
jge 0x62e7
movl %r14d, %edi
callq 0x386e
callq 0x30d0
movl %eax, %r12d
movq %rbx, %rdi
callq 0x8d2e
movq %rax, %rcx
shrq $0x20, %rcx
movl %r12d, %eax
cltd
idivl %ecx
shlq $0x20, %rdx
leaq (%rdx,%r13), %rdi
callq 0x3938
movl %r15d, %edi
callq 0x3370
addq $0x5, %r13
jmp 0x6298
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8cec
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x38(%rdi), %rsi
leaq -0x88(%rbp), %rdi
callq 0x3360
leaq 0x4dcb(%rip), %rsi      # 0xb1c5
leaq -0x68(%rbp), %rdi
leaq -0xa8(%rbp), %rdx
callq 0x3120
leaq -0x48(%rbp), %rdi
leaq -0x88(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x66bc
leaq -0x68(%rbp), %rdi
callq 0x3340
leaq -0x88(%rbp), %rdi
callq 0x3340
xorl %r14d, %r14d
leaq -0xa8(%rbp), %r15
cmpq %r14, -0x40(%rbp)
jbe 0x64d7
movq %rbx, %rdi
callq 0x8c14
testq %rax, %rax
je 0x6469
movq %rbx, %rdi
callq 0x8c14
movq %rax, %rdi
callq 0x8d1a
movq %rax, %r13
jmp 0x646c
xorl %r13d, %r13d
movq %rbx, %rdi
callq 0x8d1a
movq %rax, %r12
movq %rbx, %rdi
callq 0x8d1a
movq %r13, %rcx
shrq $0x20, %rcx
addl %r13d, %r12d
shrq $0x20, %rax
addl %ecx, %eax
addl %r14d, %eax
movl %r12d, %edi
movl %eax, %esi
callq 0x390e
movl 0x58(%rbx), %edi
movl 0x5c(%rbx), %esi
callq 0x389a
movq %r15, %rdi
leaq -0x48(%rbp), %rsi
movq %r14, %rdx
callq 0x65f2
movq -0xa8(%rbp), %rdi
callq 0x33e0
movq %r15, %rdi
callq 0x3340
callq 0x38b4
incq %r14
jmp 0x643d
movq %rbx, %rdi
callq 0x8cec
leaq -0x48(%rbp), %rdi
callq 0x653c
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x651f
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x3340
jmp 0x650d
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x3340
jmp 0x652b
jmp 0x651f
jmp 0x651f
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x653c
movq %rbx, %rdi
callq 0x3450
movq %rax, %rdi
callq 0x3aae
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4a5d(%rip), %rsi      # 0xb1c5
xorl %edx, %edx
callq 0x3160
cmpq $-0x1, %rax
jne 0x6779
movq 0x8(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x34d0
cmpq $-0x1, %rax
je 0x684d
movq 0x8(%r12), %rdx
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rcx
callq 0x3110
jmp 0x6825
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3360
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 -0x218(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x3480
leaq -0x3a0(%rbp), %rdi
callq 0x31d0
leaq -0x390(%rbp), %rdi
leaq -0x208(%rbp), %rsi
callq 0x30a0
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x1f8(%rbp,%rax)
je 0x68ce
leaq 0x48fa(%rip), %rsi      # 0xb1ba
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0x3120
jmp 0x68e9
leaq -0x218(%rbp), %rdi
callq 0x3090
leaq -0x388(%rbp), %rsi
movq %rbx, %rdi
callq 0x3400
leaq -0x3a0(%rbp), %rdi
callq 0x3200
leaq -0x218(%rbp), %rdi
callq 0x30c0
movq %rbx, %rax
addq $0x398, %rsp            # imm = 0x398
popq %rbx
popq %rbp
retq
jmp 0x6910
movq %rax, %rbx
leaq -0x3a0(%rbp), %rdi
callq 0x3200
jmp 0x6924
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x3450
movq %rax, %rdi
callq 0x3aae
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x250, %rsp            # imm = 0x250
movq %rsi, %r14
movq %rdi, %rbx
callq 0x6eb8
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%r14), %rsi
leaq -0x268(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x3480
movq -0x268(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x248(%rbp,%rax)
jne 0x69e8
leaq -0x268(%rbp), %r14
leaq -0x40(%rbp), %r15
leaq -0x60(%rbp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x3080
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x69dc
movq %r12, %rdi
movq %r15, %rsi
callq 0x3360
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6ec8
movq %r12, %rdi
callq 0x3340
jmp 0x69a3
leaq -0x268(%rbp), %rdi
callq 0x3090
leaq -0x268(%rbp), %rdi
callq 0x30c0
leaq -0x40(%rbp), %rdi
callq 0x3340
movq %rbx, %rax
addq $0x250, %rsp            # imm = 0x250
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6a2a
movq %rax, %r14
jmp 0x6a42
movq %rax, %r14
jmp 0x6a39
movq %rax, %r14
leaq -0x60(%rbp), %rdi
callq 0x3340
jmp 0x6a2d
movq %rax, %r14
leaq -0x268(%rbp), %rdi
callq 0x30c0
leaq -0x40(%rbp), %rdi
callq 0x3340
movq %rbx, %rdi
callq 0x653c
movq %r14, %rdi
callq 0x3450
movq %rax, %rdi
callq 0x3aae