LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/kryffin[P]software-rasterizer/./geometry.cpp
// Function: rotationZ(float)
Mat4f rotationZ (float angle) {
	Mat4f out;
	out.m[2][2] = 1.f;
	out.m[0][0] = cosf(angle);
	out.m[1][0] = -sinf(angle);
	out.m[0][1] = sinf(angle);
	out.m[1][1] = cosf(angle);
	out.m[3][3] = 1.f;
	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movss %xmm0, -0x14(%rbp)
movq %rdi, %rbx
xorps %xmm1, %xmm1
movups %xmm1, 0x28(%rdi)
movups %xmm1, 0x18(%rdi)
movups %xmm1, 0x8(%rdi)
movl $0x0, 0x38(%rdi)
movl $0x3f800000, %r14d      # imm = 0x3F800000
movl %r14d, 0x28(%rdi)
callq 0x2120
movss %xmm0, (%rbx)
movss -0x14(%rbp), %xmm0
callq 0x2140
xorps 0x2847(%rip), %xmm0     # 0x5050
movss %xmm0, 0x10(%rbx)
movss -0x14(%rbp), %xmm0
callq 0x2140
movss %xmm0, 0x4(%rbx)
movss -0x14(%rbp), %xmm0
callq 0x2120
movss %xmm0, 0x14(%rbx)
movl %r14d, 0x3c(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/kryffin[P]software-rasterizer/./geometry.cpp
// Function: rotationY(float)
Mat4f rotationY (float angle) {
	Mat4f out;
	out.m[1][1] = 1.f;
	out.m[0][0] = cosf(angle);
	out.m[2][0] = sinf(angle);
	out.m[0][2] = -sinf(angle);
	out.m[2][2] = cosf(angle);
	out.m[3][3] = 1.f;
	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movss %xmm0, -0x14(%rbp)
movq %rdi, %rbx
xorps %xmm1, %xmm1
movups %xmm1, 0x14(%rdi)
movups %xmm1, 0x24(%rdi)
movups %xmm1, 0x4(%rdi)
movq $0x0, 0x34(%rdi)
movl $0x3f800000, %r14d      # imm = 0x3F800000
movl %r14d, 0x14(%rdi)
callq 0x2120
movss %xmm0, (%rbx)
movss -0x14(%rbp), %xmm0
callq 0x2140
movss %xmm0, 0x20(%rbx)
movss -0x14(%rbp), %xmm0
callq 0x2140
xorps 0x27b7(%rip), %xmm0     # 0x5050
movss %xmm0, 0x8(%rbx)
movss -0x14(%rbp), %xmm0
callq 0x2120
movss %xmm0, 0x28(%rbx)
movl %r14d, 0x3c(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/kryffin[P]software-rasterizer/./geometry.cpp
// Function: rotationX(float)
Mat4f rotationX (float angle) {
	Mat4f out;
	out.m[0][0] = 1.f;
	out.m[1][1] = cosf(angle);
	out.m[2][1] = -sinf(angle);
	out.m[1][2] = sinf(angle);
	out.m[2][2] = cosf(angle);
	out.m[3][3] = 1.f;
	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movss %xmm0, -0x14(%rbp)
movq %rdi, %rbx
xorps %xmm1, %xmm1
movups %xmm1, 0x24(%rdi)
movups %xmm1, 0x14(%rdi)
movups %xmm1, 0x4(%rdi)
movq $0x0, 0x34(%rdi)
movl $0x3f800000, %r14d      # imm = 0x3F800000
movl %r14d, (%rdi)
callq 0x2120
movss %xmm0, 0x14(%rbx)
movss -0x14(%rbp), %xmm0
callq 0x2140
xorps 0x2745(%rip), %xmm0     # 0x5050
movss %xmm0, 0x24(%rbx)
movss -0x14(%rbp), %xmm0
callq 0x2140
movss %xmm0, 0x18(%rbx)
movss -0x14(%rbp), %xmm0
callq 0x2120
movss %xmm0, 0x28(%rbx)
movl %r14d, 0x3c(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/kryffin[P]software-rasterizer/rasterizer.cpp
// Function: mix_channels(std::vector<int, std::allocator<int>>, std::vector<int, std::allocator<int>>)
std::vector<int> mix_channels(std::vector<int> buffR, std::vector<int> buffB){
    std::vector<int>frameBuffer(WIDTH * HEIGHT * 3); //vector representing the anaglyph render
    
    //red buffer goes in red channel, blue buffer in blue channel
    for (int x = 0; x < WIDTH; x++) {
        for (int y = 0; y < HEIGHT; y++) {
            frameBuffer[((x + (y * WIDTH)) * 3) + 0] = buffR[x + (y * WIDTH)]; //red
            frameBuffer[((x + (y * WIDTH)) * 3) + 1] = 0; //green
            frameBuffer[((x + (y * WIDTH)) * 3) + 2] = buffB[x + (y * WIDTH)]; //blue
        }
    }

    return frameBuffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, -0x30(%rbp)
movq %rsi, %r12
movq %rdi, %rbx
movl $0x753000, %edi         # imm = 0x753000
callq 0x2190
movq %rax, %r14
movq %rax, (%rbx)
leaq 0x753000(%rax), %r15
movq %r15, 0x10(%rbx)
xorl %r13d, %r13d
movl $0x753000, %edx         # imm = 0x753000
movq %rax, %rdi
xorl %esi, %esi
callq 0x20c0
movq %r15, 0x8(%rbx)
movq (%r12), %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
addq $0x8, %r14
movq %r14, %rdx
xorl %esi, %esi
movl (%rax,%rsi), %edi
movl %edi, -0x8(%rdx)
movl $0x0, -0x4(%rdx)
movl (%rcx,%rsi), %edi
movl %edi, (%rdx)
addq $0xc80, %rsi            # imm = 0xC80
addq $0x2580, %rdx           # imm = 0x2580
cmpq $0x271000, %rsi         # imm = 0x271000
jne 0x3709
incq %r13
addq $0x4, %rax
addq $0x4, %rcx
addq $0xc, %r14
cmpq $0x320, %r13            # imm = 0x320
jne 0x3704
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_O3/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 0x3e1c
cmpl $0x2, %edx
ja 0x3e1c
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
imull $0xaaaaaaab, %ecx, %ecx # imm = 0xAAAAAAAB
cmpl %esi, %ecx
jle 0x3e1c
movl %esi, %ecx
leaq (%rcx,%rcx,2), %rcx
cmpl $0x1, %edx
je 0x3e07
testl %edx, %edx
jne 0x3e11
leaq (%rax,%rcx,4), %rax
jmp 0x3e19
leaq (%rax,%rcx,4), %rax
addq $0x4, %rax
jmp 0x3e19
leaq (%rax,%rcx,4), %rax
addq $0x8, %rax
movl (%rax), %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1278(%rip), %rdi      # 0x509f
leaq 0x12a1(%rip), %rsi      # 0x50cf
leaq 0x12a7(%rip), %rcx      # 0x50dc
movl $0x54, %edx
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4d92
testq %r14, %r14
jle 0x23ce
movq (%rbx), %rax
leaq 0x1(%r14), %rcx
andq $-0x2, %rcx
decq %r14
movq %r14, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa 0x4cb7(%rip), %xmm1     # 0x7010
xorl %edx, %edx
movdqa 0x4cbd(%rip), %xmm2     # 0x7020
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x4cbd(%rip), %xmm4     # 0x7030
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %esi
notl %esi
testb $0x1, %sil
je 0x23a9
movq %rdx, (%rax,%rdx,8)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x23c1
leaq 0x1(%rdx), %rsi
movq %rsi, 0x8(%rax,%rdx,8)
addq $0x2, %rdx
paddq %xmm4, %xmm1
cmpq %rdx, %rcx
jne 0x2373
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %r15
movq %rdi, %r14
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 0x4d92
cmpq %r12, %r15
jle 0x24d7
leaq (%r12,%rbx), %rax
xorl %edi, %edi
cmpq %rax, %r15
cmovleq %rax, %r15
movq (%r14), %rcx
setg %dil
addq %rdi, %rax
subq %rax, %r15
xorl %esi, %esi
movq %r15, %rax
xorl %edx, %edx
divq %rbx
addq %rdi, %rax
movq %rax, %xmm0
andq $-0x2, %rax
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
addq $0x2, %rax
leaq (%rbx,%rbx), %rdx
movdqa 0x4baf(%rip), %xmm1     # 0x7010
movdqa 0x4bb7(%rip), %xmm2     # 0x7020
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x4bb7(%rip), %xmm4     # 0x7030
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %edi
notl %edi
testb $0x1, %dil
je 0x24af
movq %r12, (%rcx,%rsi,8)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %edi
testb $0x1, %dil
je 0x24c7
leaq (%rbx,%r12), %rdi
movq %rdi, 0x8(%rcx,%rsi,8)
addq $0x2, %rsi
paddq %xmm4, %xmm1
addq %rdx, %r12
cmpq %rsi, %rax
jne 0x2479
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/schaefed[P]Ndarray/test/test_ndarray.cpp
// Function: main
int main(){

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

	return 0;
}

// Assembly:
pushq %rax
callq 0x24e6
callq 0x2b8e
callq 0x2d7f
callq 0x4240
callq 0x4a1b
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5b9c
movq %rsp, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x5bfa
movl %r15d, %eax
imull %r14d, %eax
cltq
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movq (%rsp), %rax
movq %rax, 0x10(%rbx)
movq 0x8(%rsp), %rdi
movq %rdi, 0x18(%rbx)
testq %rdi, %rdi
je 0x4ea5
movq 0x5151(%rip), %rax      # 0x9fd8
cmpb $0x0, (%rax)
je 0x4ebb
incl 0x8(%rdi)
movq %r15, 0x20(%rbx)
movq %r14, 0x28(%rbx)
movq %r14, 0x30(%rbx)
movq $0x1, 0x38(%rbx)
jmp 0x4edd
movq %r15, 0x20(%rbx)
movq %r14, 0x28(%rbx)
movq %r14, 0x30(%rbx)
movq $0x1, 0x38(%rbx)
jmp 0x4ee2
lock
incl 0x8(%rdi)
movq 0x8(%rsp), %rdi
movq %r15, 0x20(%rbx)
movq %r14, 0x28(%rbx)
movq %r14, 0x30(%rbx)
movq $0x1, 0x38(%rbx)
testq %rdi, %rdi
je 0x4ee2
callq 0x5a38
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x4efb
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x4f32
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x4f2a
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x541a
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %r14
sarq $0x3f, %r14
andq 0x20(%rsi), %r14
addq %rdx, %r14
movq %rsi, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x5f94
movq 0x18(%r15), %rdi
imulq 0x30(%r15), %r14
movq 0x28(%r15), %rax
movslq %eax, %rsi
movq 0x8(%r15), %rcx
addq %r14, %rcx
shlq $0x3, %r14
addq 0x10(%r15), %r14
testq %rdi, %rdi
je 0x4faa
movq 0x504b(%rip), %rdx      # 0x9fd8
cmpb $0x0, (%rdx)
je 0x4fcb
incl 0x8(%rdi)
movq 0x38(%r15), %rdx
movq %rsi, (%rbx)
movq %rcx, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq %rdi, 0x18(%rbx)
jmp 0x4fe7
movq 0x38(%r15), %rdx
movq %rsi, (%rbx)
movq %rcx, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq $0x0, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %rdx, 0x28(%rbx)
jmp 0x4ff7
lock
incl 0x8(%rdi)
cmpb $0x0, (%rdx)
movq 0x38(%r15), %rdx
movq %rsi, (%rbx)
movq %rcx, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq %rdi, 0x18(%rbx)
je 0x5000
incl 0x8(%rdi)
movq %rax, 0x20(%rbx)
movq %rdx, 0x28(%rbx)
callq 0x5a38
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
lock
incl 0x8(%rdi)
jmp 0x4fea
// File: /workspace/github_cpp_makefile_star2_O3/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), %rcx
movq 0x28(%rsi), %rax
movq (%rcx), %r12
testq %r12, %r12
jns 0x512b
addq %rax, %r12
movq %r12, (%rcx)
movq 0x8(%rcx), %r15
testq %r15, %r15
jns 0x513b
addq %rax, %r15
movq %r15, 0x8(%rcx)
movl $0x1, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x5f94
movq 0x18(%r14), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%r14), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%r14), %rax
movq %rax, (%rsp)
movq 0x38(%r14), %rbp
movq %rbp, %r13
imulq %r12, %r13
subq %r12, %r15
cvtsi2sd %r15, %xmm0
leaq 0x50(%rsp), %rax
movq 0x10(%rax), %r12
movq %r12, %xmm1
punpckldq 0x1eb2(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x1eba(%rip), %xmm1     # 0x7050
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
callq 0x2030
movq 0x8(%rsp), %r9
movq 0x10(%rsp), %r8
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x1ee7(%rip), %xmm0     # 0x70b0
cvttsd2si %xmm0, %rax
andq %rdx, %rax
orq %rcx, %rax
imulq %rbp, %r12
movl %r9d, %ecx
imull %eax, %ecx
movslq %ecx, %rdx
movq 0x8(%r14), %rcx
addq %r13, %rcx
shlq $0x3, %r13
addq 0x10(%r14), %r13
testq %r8, %r8
je 0x521a
movq (%rsp), %rdi
movq 0x4dd8(%rip), %rsi      # 0x9fd8
cmpb $0x0, (%rsi)
je 0x5243
incl 0x8(%r8)
movq %rdx, (%rbx)
movq %rcx, 0x8(%rbx)
movq %r13, 0x10(%rbx)
movq %r8, 0x18(%rbx)
jmp 0x525c
movq %rdx, (%rbx)
movq %rcx, 0x8(%rbx)
movq %r13, 0x10(%rbx)
movq $0x0, 0x18(%rbx)
movq %r9, 0x20(%rbx)
movq %rax, 0x28(%rbx)
movq (%rsp), %rax
movq %rax, 0x30(%rbx)
movq %r12, 0x38(%rbx)
jmp 0x5278
lock
incl 0x8(%r8)
cmpb $0x0, (%rsi)
movq %rdx, (%rbx)
movq %rcx, 0x8(%rbx)
movq %r13, 0x10(%rbx)
movq %r8, 0x18(%rbx)
je 0x528a
incl 0x8(%r8)
movq %r9, 0x20(%rbx)
movq %rax, 0x28(%rbx)
movq %rdi, 0x30(%rbx)
movq %r12, 0x38(%rbx)
movq %r8, %rdi
callq 0x5a38
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
lock
incl 0x8(%r8)
jmp 0x5260
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movq %rdi, %rbx
leaq 0x40(%rsp), %rcx
movq 0x20(%rsi), %rax
movq (%rcx), %r12
testq %r12, %r12
jns 0x547e
addq %rax, %r12
movq %r12, (%rcx)
movq 0x8(%rcx), %r15
testq %r15, %r15
jns 0x548e
addq %rax, %r15
movq %r15, 0x8(%rcx)
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x6194
movq 0x18(%r14), %rax
movq %rax, (%rsp)
movq 0x28(%r14), %rbp
movq %rbp, %r13
imulq %r12, %r13
subq %r12, %r15
cvtsi2sd %r15, %xmm0
leaq 0x40(%rsp), %rax
movq 0x10(%rax), %r12
movq %r12, %xmm1
punpckldq 0x1b74(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x1b7c(%rip), %xmm1     # 0x7050
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
callq 0x2030
movq (%rsp), %rdi
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
subsd 0x1bb3(%rip), %xmm0     # 0x70b0
sarq $0x3f, %rdx
cvttsd2si %xmm0, %rax
andq %rdx, %rax
orq %rcx, %rax
imulq %rbp, %r12
movq 0x8(%r14), %rcx
addq %r13, %rcx
shlq $0x3, %r13
addq 0x10(%r14), %r13
testq %rdi, %rdi
je 0x5548
movq 0x4aad(%rip), %rdx      # 0x9fd8
cmpb $0x0, (%rdx)
je 0x5569
incl 0x8(%rdi)
movq $0x1, (%rbx)
movq %rcx, 0x8(%rbx)
movq %r13, 0x10(%rbx)
movq %rdi, 0x18(%rbx)
jmp 0x5585
movq $0x1, (%rbx)
movq %rcx, 0x8(%rbx)
movq %r13, 0x10(%rbx)
movq $0x0, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %r12, 0x28(%rbx)
jmp 0x5595
lock
incl 0x8(%rdi)
cmpb $0x0, (%rdx)
movq $0x1, (%rbx)
movq %rcx, 0x8(%rbx)
movq %r13, 0x10(%rbx)
movq %rdi, 0x18(%rbx)
je 0x55a7
incl 0x8(%rdi)
movq %rax, 0x20(%rbx)
movq %r12, 0x28(%rbx)
callq 0x5a38
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
lock
incl 0x8(%rdi)
jmp 0x5588
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x57ab
movq %rsi, %r14
shlq $0x3, %rdx
leaq (%rdx,%rdx,2), %r12
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x65bc
movq 0x8(%rbx), %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x663c
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x57a1
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2120
addq $0x18, %r14
addq $-0x18, %r12
jne 0x576b
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x57d8
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x57d8
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2120
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x57ec
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2120
movq %r14, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x28, %rsp
movq %rdi, %rbx
movq 0x20(%rsi), %rax
cmpq %rcx, %rax
jne 0x590a
movq 0x28(%rsi), %rax
jmp 0x5916
cmpq $0x1, %rax
jne 0x59ad
xorl %eax, %eax
movl %edx, %edi
imull %ecx, %edi
movslq %edi, %r10
movq 0x8(%rsi), %r9
movq 0x10(%rsi), %r8
movq 0x18(%rsi), %rdi
testq %rdi, %rdi
je 0x5940
movq 0x46a2(%rip), %rsi      # 0x9fd8
cmpb $0x0, (%rsi)
je 0x5965
incl 0x8(%rdi)
jmp 0x5969
movq %r10, (%rbx)
movq %r9, 0x8(%rbx)
movq %r8, 0x10(%rbx)
movq %rdi, 0x18(%rbx)
movq %rdx, 0x20(%rbx)
movq %rcx, 0x28(%rbx)
movq $0x0, 0x30(%rbx)
movq %rax, 0x38(%rbx)
jmp 0x599f
lock
incl 0x8(%rdi)
movq %r10, (%rbx)
movq %r9, 0x8(%rbx)
movq %r8, 0x10(%rbx)
movq %rdi, 0x18(%rbx)
cmpb $0x0, (%rsi)
je 0x5982
incl 0x8(%rdi)
jmp 0x5986
lock
incl 0x8(%rdi)
movq %rdx, 0x20(%rbx)
movq %rcx, 0x28(%rbx)
movq $0x0, 0x30(%rbx)
movq %rax, 0x38(%rbx)
callq 0x5a38
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x2080
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1ce4(%rip), %rsi      # 0x76ae
leaq 0x1d05(%rip), %rdx      # 0x76d6
leaq 0x8(%rsp), %rdi
callq 0x60fe
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x683c
xorl %ebp, %ebp
leaq 0x4384(%rip), %rsi      # 0x9d78
leaq 0xe8b(%rip), %rdx       # 0x6886
movq %rbx, %rdi
callq 0x2190
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x5a1d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2120
testb %bpl, %bpl
jne 0x5a27
jmp 0x5a2f
movq %rax, %r14
movq %rbx, %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x61b9
testq %rsi, %rsi
js 0x6211
cmpq %rsi, 0x20(%rdi)
jle 0x6211
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 0x1479(%rip), %rsi      # 0x764f
leaq 0x148a(%rip), %rdx      # 0x7667
leaq 0x28(%rsp), %rdi
callq 0x60fe
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x60b4
xorl %ebp, %ebp
leaq 0x3a90(%rip), %rsi      # 0x9c90
leaq -0xde1(%rip), %rdx      # 0x5426
movq %rbx, %rdi
callq 0x2190
jmp 0x6267
movl $0x28, %edi
callq 0x2080
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x143a(%rip), %rsi      # 0x7668
leaq 0x1446(%rip), %rdx      # 0x767b
leaq 0x8(%rsp), %rdi
callq 0x60fe
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x60b4
xorl %ebp, %ebp
leaq 0x3a38(%rip), %rsi      # 0x9c90
leaq -0xe39(%rip), %rdx      # 0x5426
movq %rbx, %rdi
callq 0x2190
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6297
movq 0x18(%rsp), %rsi
jmp 0x628f
jmp 0x629e
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x6297
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2120
testb %bpl, %bpl
jne 0x62a1
jmp 0x62a9
movq %rax, %r14
movq %rbx, %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6302
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x62f7
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x6302
movq %rbx, %rdi
movq %r15, %rdx
callq 0x633a
addq $0x8, %r12
cmpq $0x10, %r12
jne 0x62d3
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 0x6332
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2120
movq %r14, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O3/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), %rdi
incq %rax
movq %rax, 0x10(%rbx)
movq 0x20(%rbx), %rsi
movl $0x1, %r8d
xorl %r15d, %r15d
movq %rax, %rcx
movq (%rdi,%r8,8), %r9
xorl %edx, %edx
divq %r9
imulq (%rsi,%r8,8), %rdx
addq %rdx, %r15
addq $-0x1, %r8
jb 0x649e
cmpq %rcx, %r9
ja 0x64e0
movq (%rdi), %r15
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x62b1
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_O3/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 0x3112
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 0x3109
incq %r15
decq %r12
cmpq $0x1, %r12
jne 0x30eb
jmp 0x3112
cmpl $0x2, %r12d
je 0x311d
movl %r15d, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3fcd(%rip), %rdi      # 0x70f1
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2050
movl $0x1, %edi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %ecx, %r14d
movl %edx, %ebp
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 0x3602
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x70(%rbx)
jmp 0x3610
leaq 0x68(%rbx), %rdi
leaq 0x14(%rsp), %rdx
callq 0x3e2c
movq 0xa0(%rbx), %rsi
cmpq 0xa8(%rbx), %rsi
je 0x3630
movl %r14d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0xa0(%rbx)
jmp 0x3641
leaq 0x98(%rbx), %rdi
leaq 0xc(%rsp), %rdx
callq 0x3e2c
movq 0x88(%rbx), %rsi
cmpq 0x90(%rbx), %rsi
je 0x3660
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x88(%rbx)
jmp 0x3671
leaq 0x80(%rbx), %rdi
leaq 0x10(%rsp), %rdx
callq 0x3e2c
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 0x3da2
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x3568
movl $0x1, (%rax)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5238
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 0x5238
movsd 0x10(%rsp), %xmm1
addsd 0x58(%r13), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x4ed0
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 0x5308
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x4f5e(%rip)      # 0xa1a0
je 0x52aa
testl %eax, %eax
jle 0x5303
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 0x1de7(%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 0x5289
jmp 0x5302
testl %eax, %eax
jle 0x5303
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 0x52e3
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, 0xd8ad(%rip)      # 0x11260
je 0x3a6d
movq %rdi, %rbx
movq (%rdi), %rsi
leaq -0x258(%rbp), %r14
movq %r14, %rdi
movl $0x4, %edx
callq 0x3460
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, -0x238(%rbp,%rax)
je 0x39ed
movb $0x0, 0xd875(%rip)      # 0x11260
jmp 0x3a55
leaq 0x8658(%rip), %rsi      # 0xc04c
leaq -0x50(%rbp), %rdi
movq %rbx, %rdx
callq 0x3ad4
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
addq %rsi, %rdx
leaq -0x30(%rbp), %rdi
callq 0x3b60
leaq 0x8633(%rip), %rsi      # 0xc056
leaq -0x30(%rbp), %rdi
callq 0x3480
movq -0x30(%rbp), %rdi
callq 0x3200
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x3a43
callq 0x3230
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a55
callq 0x3230
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 0x3a7b
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x3a91
callq 0x3230
jmp 0x3a91
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3aaa
callq 0x3230
jmp 0x3aaa
jmp 0x3aa7
movq %rax, %rbx
leaq -0x258(%rbp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x3430
movq %rax, %rdi
callq 0x3ac6
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4c81
movq %rbx, %rdi
callq 0x9a66
testl %eax, %eax
jle 0x4c81
xorl %r15d, %r15d
movl $0x24, %edi
callq 0x3842
callq 0x30d0
movl %eax, %r14d
movq %rbx, %rdi
callq 0x9a66
movq %rax, %rcx
shrq $0x20, %rcx
movl %r14d, %eax
cltd
idivl %ecx
shlq $0x20, %rdx
leaq (%rdx,%r15), %rdi
callq 0x3916
movl $0x7c, %edi
callq 0x3300
addq $0x5, %r15
movq %rbx, %rdi
callq 0x9a66
cmpl %eax, %r15d
jl 0x4c32
movl $0x1, %r14d
xorl %edi, %edi
movl $0x1, %esi
callq 0x38ec
callq 0x3902
movl $0x24, %edi
callq 0x3842
movq 0x38(%rbx), %rdi
callq 0x7f60
mulss 0x73d5(%rip), %xmm0     # 0xc088
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
je 0x4d45
movq %rbx, %rdi
callq 0x9a66
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
leal (%r14,%rcx), %edi
addl $-0x6, %edi
movl $0x1, %esi
callq 0x38ec
movq 0x38(%rbx), %rdi
callq 0x7f60
movl $0x3e, %edi
ucomiss 0x7396(%rip), %xmm0     # 0xc08c
ja 0x4d0e
movq 0x38(%rbx), %rdi
callq 0x7f60
movl $0x3c, %edi
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x4d13
callq 0x3300
xorps %xmm0, %xmm0
cvtsi2ss %r14d, %xmm0
movss %xmm0, -0x1c(%rbp)
movq 0x38(%rbx), %rdi
callq 0x7f60
mulss 0x7357(%rip), %xmm0     # 0xc088
andps 0x7368(%rip), %xmm0     # 0xc0a0
incl %r14d
ucomiss -0x1c(%rbp), %xmm0
ja 0x4cbf
callq 0x3888
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x9a1a
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7141(%rip), %rsi      # 0xc142
leaq 0x713b(%rip), %rdx      # 0xc143
leaq -0x50(%rbp), %r12
movq %r12, %rdi
callq 0x574e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4ef4
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x502d
callq 0x3230
leaq 0xbc2c(%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 0x8c20
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5716
jmp 0x50a3
movq %rax, %rdi
callq 0x3ac6
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x50a3
callq 0x3230
movq %r14, %rdi
callq 0x3430
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xbf19(%rip), %rbx      # 0x10fe0
leaq -0x2c(%rbp), %rsi
movq %rbx, %rdi
callq 0x3490
movq (%rbx), %rax
movq -0x18(%rax), %rdi
testb $0x5, 0x20(%rbx,%rdi)
je 0x5144
addq %rbx, %rdi
leaq 0x70d0(%rip), %r13      # 0xc1bb
leaq -0x2c(%rbp), %r12
xorl %esi, %esi
callq 0x3400
movq %rbx, %rdi
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
movl $0xa, %edx
callq 0x3160
movq %r14, %rdi
callq 0x3916
movq (%r15), %rsi
movq %r13, %rdi
xorl %eax, %eax
callq 0x3060
callq 0x3902
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3490
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
testb $0x5, 0x20(%rbx,%rax)
jne 0x50ef
movq %rbx, %rdi
callq 0x3450
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
xorl %esi, %esi
callq 0x3400
movq %rbx, %rdi
callq 0x3270
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_O3/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 0x52a6
leaq 0xbb38(%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 0x539a
leaq -0x48(%rbp), %rdi
movq 0x10(%rdi), %rsi
callq 0x5598
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x5281
movq %rax, %r15
leaq -0x48(%rbp), %rdi
movq 0x10(%rdi), %rsi
callq 0x5598
movq 0x48(%rbx), %rsi
movq %r14, %rdi
callq 0x5598
movq %rbx, %rdi
callq 0x531c
movq %r15, %rdi
callq 0x3430
movq %rax, %rdi
callq 0x3ac6
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6865
movq %rbx, %rdi
callq 0x9a66
testl %eax, %eax
jle 0x6865
xorl %r15d, %r15d
movl $0x24, %edi
callq 0x3842
callq 0x30d0
movl %eax, %r14d
movq %rbx, %rdi
callq 0x9a66
movq %rax, %rcx
shrq $0x20, %rcx
movl %r14d, %eax
cltd
idivl %ecx
shlq $0x20, %rdx
leaq (%rdx,%r15), %rdi
callq 0x3916
movl $0x7c, %edi
callq 0x3300
addq $0x5, %r15
movq %rbx, %rdi
callq 0x9a66
cmpl %eax, %r15d
jl 0x6816
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x9a1a
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3b60
leaq -0x78(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x5863(%rip), %rsi      # 0xc1f5
leaq 0x585d(%rip), %rdx      # 0xc1f6
leaq -0x88(%rbp), %rdi
callq 0x574e
leaq -0x68(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x6c76
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x69cd
callq 0x3230
movq -0xa8(%rbp), %rdi
cmpq %r14, %rdi
je 0x69de
callq 0x3230
cmpq $0x0, -0x60(%rbp)
je 0x6ac3
movl $0x8, %r13d
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x98e0
testq %rax, %rax
je 0x6a14
movq %rbx, %rdi
callq 0x98e0
movq %rax, %rdi
callq 0x9a52
movq %rax, %r15
jmp 0x6a17
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x9a52
movq %rax, %r12
movq %rbx, %rdi
callq 0x9a52
movq %r15, %rcx
shrq $0x20, %rcx
addl %r15d, %r12d
shrq $0x20, %rax
addl %ecx, %eax
addl %r14d, %eax
movl %r12d, %edi
movl %eax, %esi
callq 0x38ec
movl 0x58(%rbx), %edi
movl 0x5c(%rbx), %esi
callq 0x386e
cmpq %r14, -0x60(%rbp)
jbe 0x6a83
movq -0x68(%rbp), %rax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq -0x8(%rax,%r13), %rsi
movq (%rax,%r13), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x3b60
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %r15
jmp 0x6a9a
leaq -0x38(%rbp), %r15
movq %r15, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
movq %r15, %rdi
callq 0x3370
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x6aad
callq 0x3230
callq 0x3888
incq %r14
addq $0x20, %r13
cmpq %r14, -0x60(%rbp)
ja 0x69f2
movq %rbx, %rdi
callq 0x9a1a
leaq -0x68(%rbp), %rdi
callq 0x6b34
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6b18
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x6b01
callq 0x3230
jmp 0x6b01
movq %rax, %rbx
movq -0xa8(%rbp), %rdi
cmpq %r14, %rdi
je 0x6b24
callq 0x3230
jmp 0x6b24
jmp 0x6b18
jmp 0x6b18
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x6b34
movq %rbx, %rdi
callq 0x3430
movq %rax, %rdi
callq 0x3ac6
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3350
cmpq $-0x1, %rax
jne 0x6d74
movq 0x8(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3420
cmpq $-0x1, %rax
je 0x6eac
movq 0x8(%r12), %rdx
movq (%r15), %rcx
movq 0x8(%r15), %r8
movq %r14, %rdi
movq %rax, %rsi
callq 0x32b0
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 0x3b60
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3460
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 0x574e
jmp 0x6f63
leaq -0x210(%rbp), %rdi
callq 0x3090
leaq -0x380(%rbp), %rsi
movq %rbx, %rdi
callq 0x33a0
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 0x3430
movq %rax, %rdi
callq 0x3ac6