LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: kryffin[P]software-rasterizer/./geometry.cpp
// Function: Mat4f::operator*(Mat4f)
Mat4f operator* (Mat4f in) {
		Mat4f out = Mat4f();
		for (int i = 0; i < 4; i++)
			for (int j = 0; j < 4; j++)
				for (int k = 0; k < 4; k++)
					out.m[i][j] += m[i][k] * in.m[k][j];
		return out;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x51d0
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jge 0x5584
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jge 0x5574
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x5567
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rdx
movslq -0xc(%rbp), %rsi
shlq $0x4, %rsi
addq %rsi, %rdx
movslq -0x14(%rbp), %rsi
movss (%rdx,%rsi,4), %xmm0
movslq -0x14(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movslq -0x10(%rbp), %rdx
movss (%rcx,%rdx,4), %xmm2
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5501
jmp 0x5569
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x54f4
jmp 0x5576
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x54e3
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x19(%rbp)
jl 0x5907
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0x5890
movl -0x2c(%rbp), %ecx
movl %eax, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x19(%rbp)
jge 0x5907
xorl %eax, %eax
cmpl $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
jl 0x5907
cmpl $0x3, -0x18(%rbp)
setl %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x5910
jmp 0x5912
jmp 0x5931
leaq 0x5766(%rip), %rdi      # 0xb07f
leaq 0x578f(%rip), %rsi      # 0xb0af
movl $0x54, %edx
leaq 0x5790(%rip), %rcx      # 0xb0bc
callq 0x2140
cmpl $0x0, -0x18(%rbp)
jne 0x594f
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movslq -0x14(%rbp), %rsi
callq 0x6990
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x5985
cmpl $0x1, -0x18(%rbp)
jne 0x596e
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movslq -0x14(%rbp), %rsi
callq 0x6990
movl 0x4(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x5985
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movslq -0x14(%rbp), %rsi
callq 0x6990
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: kryffin[P]software-rasterizer/./geometry.cpp
// Function: Mat4f::operator*(Vec3f)
Vec3f operator* (Vec3f in) {
		Vec3f out = Vec3f(
			out.x = in.x * m[0][0] + in.y * m[1][0] + in.z * m[2][0] + m[3][0],
			out.y = in.x * m[0][1] + in.y * m[1][1] + in.z * m[2][1] + m[3][1],
			out.z = in.x * m[0][2] + in.y * m[1][2] + in.z * m[2][2] + m[3][2]
		);

		float w = in.x * m[0][3] + in.y * m[1][3] + in.z * m[2][3] + m[3][3];

		if (w != 0.f) {
			out.x /= w;
			out.y /= w;
			out.z /= w;
		}

		return out;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movlpd %xmm0, -0x28(%rbp)
movss %xmm1, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x10(%rbp)
movq %rdi, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movss -0x18(%rbp), %xmm1
movss (%rax), %xmm2
movss -0x14(%rbp), %xmm0
mulss 0x10(%rax), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movss -0x10(%rbp), %xmm0
movss 0x20(%rax), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
addss 0x30(%rax), %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x18(%rbp), %xmm2
movss 0x4(%rax), %xmm3
movss -0x14(%rbp), %xmm1
mulss 0x14(%rax), %xmm1
mulss %xmm3, %xmm2
addss %xmm1, %xmm2
movss -0x10(%rbp), %xmm1
movss 0x24(%rax), %xmm3
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
addss 0x34(%rax), %xmm1
movss %xmm1, -0x8(%rbp)
movss -0x18(%rbp), %xmm3
movss 0x8(%rax), %xmm4
movss -0x14(%rbp), %xmm2
mulss 0x18(%rax), %xmm2
mulss %xmm4, %xmm3
addss %xmm2, %xmm3
movss -0x10(%rbp), %xmm2
movss 0x28(%rax), %xmm4
mulss %xmm4, %xmm2
addss %xmm3, %xmm2
addss 0x38(%rax), %xmm2
movss %xmm2, -0x4(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x5d40
movq -0x50(%rbp), %rax
movss -0x18(%rbp), %xmm1
movss 0xc(%rax), %xmm2
movss -0x14(%rbp), %xmm0
mulss 0x1c(%rax), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movss -0x10(%rbp), %xmm0
movss 0x2c(%rax), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
addss 0x3c(%rax), %xmm0
movss %xmm0, -0x34(%rbp)
movss -0x34(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x5c09
jp 0x5c09
jmp 0x5c42
movss -0x34(%rbp), %xmm1
movss -0xc(%rbp), %xmm0
divss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x34(%rbp), %xmm1
movss -0x8(%rbp), %xmm0
divss %xmm1, %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x34(%rbp), %xmm1
movss -0x4(%rbp), %xmm0
divss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movss -0x40(%rbp), %xmm1
addq $0x50, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x51c0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x51e0
jmp 0x2447
leaq -0x12(%rbp), %rdi
callq 0x5250
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x24b6
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x30(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
callq 0x5270
movq -0x60(%rbp), %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x2460
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x5250
jmp 0x24d3
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x24c9
movq -0x50(%rbp), %rdi
callq 0x5290
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2270
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jle 0x251c
cmpq $0x0, -0x20(%rbp)
jle 0x251c
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq -0x20(%rbp), %rcx
cqto
idivq %rcx
movq %rax, -0x68(%rbp)
leaq -0x2a(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x51c0
movq -0x58(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
callq 0x51e0
jmp 0x2560
leaq -0x2a(%rbp), %rdi
callq 0x5250
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x25c7
movq -0x58(%rbp), %rdi
movq -0x48(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x28(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
callq 0x5270
movq -0x70(%rbp), %rcx
movq %rcx, (%rax)
movq -0x48(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x2571
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x2a(%rbp), %rdi
callq 0x5250
jmp 0x25e4
movb $0x1, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x25da
movq -0x58(%rbp), %rdi
callq 0x5290
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2270
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movups 0xa26e(%rip), %xmm0     # 0xd030
movaps %xmm0, -0x10(%rbp)
movaps -0x10(%rbp), %xmm0
movaps %xmm0, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x52f0
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0x2400
movq -0x130(%rbp), %rdi
callq 0x54b0
movq %rax, -0x128(%rbp)
movaps -0x10(%rbp), %xmm0
movaps %xmm0, -0x90(%rbp)
leaq 0x26bd(%rip), %rsi      # 0x54d0
leaq -0xb0(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x54e0
movq -0x128(%rbp), %rsi
movq -0x120(%rbp), %r8
movq -0x90(%rbp), %rdx
movq -0x88(%rbp), %rcx
leaq -0x80(%rbp), %rdi
callq 0x5330
jmp 0x2e4d
leaq -0xb0(%rbp), %rdi
callq 0x5570
leaq -0x60(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5fe0
movq (%rax), %rdx
leaq -0xf0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x5590
jmp 0x2e7b
leaq -0xf0(%rbp), %rdi
callq 0x6010
leaq 0xa290(%rip), %rdi      # 0xd11e
leaq 0xa1eb(%rip), %rsi      # 0xd080
movl $0x2f, %edx
leaq 0xa283(%rip), %rcx      # 0xd124
callq 0x2100
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x5570
jmp 0x2f65
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
movl -0xbc(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x2f5c
movq -0xb8(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x2200
movq %rax, %rsi
leaq -0x118(%rbp), %rdi
callq 0x6030
jmp 0x2f0e
movq -0x138(%rbp), %rdi
callq 0x2080
leaq -0x118(%rbp), %rdi
callq 0x60b0
callq 0x2250
jmp 0x2f2d
jmp 0x2f2f
leaq -0x80(%rbp), %rdi
callq 0x5880
leaq -0x28(%rbp), %rdi
callq 0x5290
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x5880
leaq -0x28(%rbp), %rdi
callq 0x5290
movq -0xb8(%rbp), %rdi
callq 0x2270
movq %rax, %rdi
callq 0x60a0
nopw %cs:(%rax,%rax)
// File: schaefed[P]Ndarray/test/test_ndarray.cpp
// Function: main
int main(){

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

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x25f0
callq 0x2db0
callq 0x2f90
callq 0x45c0
callq 0x4d10
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %r8, -0xd0(%rbp)
movq %rdi, -0xe0(%rbp)
movq %rdi, %rax
movq %rax, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rsi, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movups -0x18(%rbp), %xmm0
movaps %xmm0, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x52f0
movq -0xd0(%rbp), %rsi
movq %rax, -0xc8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x7b00
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x7bb0
jmp 0x53be
movups -0x18(%rbp), %xmm0
movaps %xmm0, -0x90(%rbp)
movups -0x18(%rbp), %xmm0
movaps %xmm0, -0xb0(%rbp)
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x7c30
movq %rdx, -0xf0(%rbp)
movq %rax, -0xe8(%rbp)
jmp 0x53f7
movq -0xc8(%rbp), %rsi
movq -0xe0(%rbp), %rdi
movq -0xf0(%rbp), %rax
movq -0xe8(%rbp), %rcx
movq %rcx, -0xa0(%rbp)
movq %rax, -0x98(%rbp)
movq -0x90(%rbp), %r8
movq -0x88(%rbp), %r9
movups -0xa0(%rbp), %xmm0
movq %rsp, %rax
movups %xmm0, (%rax)
xorl %eax, %eax
movl %eax, %edx
leaq -0x50(%rbp), %rcx
callq 0x7cd0
jmp 0x544b
leaq -0x50(%rbp), %rdi
callq 0x6d20
leaq -0x70(%rbp), %rdi
callq 0x5570
movq -0xd8(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x5490
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x6d20
leaq -0x70(%rbp), %rdi
callq 0x5570
movq -0x78(%rbp), %rdi
callq 0x2270
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xd0(%rbp)
movq %rdi, %rax
movq %rax, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0xc0(%rbp)
callq 0x8c60
movq -0xc0(%rbp), %rdx
movq -0x98(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x8cb0
movq -0x98(%rbp), %rax
movups 0x20(%rax), %xmm0
movaps %xmm0, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x1, %edx
movq %rdx, -0x90(%rbp)
callq 0x8e90
movq -0xc0(%rbp), %rsi
movq -0x98(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xb8(%rbp)
addq $0x30, %rdi
callq 0x5fe0
movq %rax, %rcx
movq -0xb8(%rbp), %rax
movq (%rcx), %rcx
imulq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x8f00
movq -0x98(%rbp), %rdi
movq %rax, -0xb0(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rdi), %rcx
addq %rcx, %rax
movq %rax, -0xa8(%rbp)
addq $0x10, %rdi
movq %rdi, -0xa0(%rbp)
callq 0x6ca0
movq -0xa0(%rbp), %rsi
movq -0x38(%rbp), %rcx
leaq (%rax,%rcx,8), %rdx
leaq -0x50(%rbp), %rdi
callq 0x8f40
movq -0x98(%rbp), %rax
movq -0x90(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movups 0x30(%rax), %xmm0
movaps %xmm0, -0x70(%rbp)
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x8e90
movq %rax, -0x88(%rbp)
jmp 0x56e2
movq -0xa8(%rbp), %rdx
movq -0xb0(%rbp), %rsi
movq -0xd0(%rbp), %rdi
movq -0x88(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %r8
movq -0x60(%rbp), %r9
leaq -0x50(%rbp), %rcx
callq 0x8f70
jmp 0x5715
leaq -0x50(%rbp), %rdi
callq 0x6d20
movq -0xc8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x6d20
movq -0x78(%rbp), %rdi
callq 0x2270
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x94a0
movq -0x28(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x94f0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x63a0
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movq -0x20(%rbp), %rax
imulq (%rcx), %rax
movq %rax, -0x18(%rbp)
addq $0x10, %rdi
callq 0x6ca0
movq -0x18(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movb $0x0, -0x19(%rbp)
leaq -0x1a(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x51c0
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x51e0
jmp 0x6735
leaq -0x1a(%rbp), %rdi
callq 0x5250
leaq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xae60
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0xae80
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
je 0x6843
movq -0x40(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0xaec0
jmp 0x677d
movq -0x98(%rbp), %rdi
callq 0xb060
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xb090
leaq -0x60(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xb0d0
movq -0xb0(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0xb060
movq -0x98(%rbp), %rdi
movq %rax, -0x80(%rbp)
movq -0x68(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq -0x80(%rbp), %rcx
callq 0xafb0
movq %rax, -0xa8(%rbp)
jmp 0x67df
movq -0xa8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5290
movq -0x40(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x40(%rbp)
jmp 0x6760
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1a(%rbp), %rdi
callq 0x5250
jmp 0x6875
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x6869
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5290
jmp 0x6869
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x6859
movq -0x98(%rbp), %rdi
callq 0x5290
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x5290
movq -0x28(%rbp), %rdi
callq 0x2270
nop
// File: schaefed[P]Ndarray/src/funcs.hpp
// Function: std::array<unsigned long, 2ul> calcStrides<unsigned long, 2ul, unsigned long>(std::array<unsigned long, 2ul>)
array<T, N> calcStrides(const array<T, N> arg){
	/* This name is misleading, as the function returns standard strides for a given shape */
	array<T, N> out;
	out.back() = 1;
	for (int64_t i=arg.size()-2; i>=0 ; --i){
		out[i] = arg[i+1] * out[i+1]; 
	}
	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x87c0
movq $0x1, (%rax)
leaq -0x20(%rbp), %rdi
callq 0x87e0
subq $0x2, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jl 0x7cc2
movq -0x28(%rbp), %rsi
addq $0x1, %rsi
leaq -0x20(%rbp), %rdi
callq 0x87f0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rsi
addq $0x1, %rsi
leaq -0x10(%rbp), %rdi
callq 0x5fe0
movq %rax, %rcx
movq -0x38(%rbp), %rax
imulq (%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x5fe0
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x7c61
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
// File: schaefed[P]Ndarray/src/ndarray.hpp
// Function: NdarrayBase<long, 2ul>::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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x1, -0x18(%rbp)
jbe 0x8d92
movb $0x1, -0x4d(%rbp)
movl $0x28, %edi
callq 0x20c0
movq %rax, -0x90(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x2280
movq -0x88(%rbp), %rdx
leaq 0x48e4(%rip), %rsi      # 0xd5f1
leaq -0x38(%rbp), %rdi
callq 0x8fb0
jmp 0x8d18
movq -0x90(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x9060
jmp 0x8d2a
movq -0x90(%rbp), %rdi
movb $0x0, -0x4d(%rbp)
leaq 0xaea4(%rip), %rsi      # 0x13be0
leaq -0x2c93(%rip), %rdx     # 0x60b0
callq 0x2260
jmp 0x8e8c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x8d70
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20f0
leaq -0x39(%rbp), %rdi
callq 0x21c0
testb $0x1, -0x4d(%rbp)
jne 0x8d81
jmp 0x8d8d
movq -0x90(%rbp), %rdi
callq 0x2130
jmp 0x8e83
cmpq $0x0, -0x10(%rbp)
jl 0x8dc8
movq -0x80(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
addq $0x20, %rdi
movq -0x18(%rbp), %rsi
callq 0x87f0
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq (%rcx), %rax
jl 0x8e7a
movb $0x1, -0x72(%rbp)
movl $0x28, %edi
callq 0x20c0
movq %rax, -0xa8(%rbp)
leaq -0x71(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x2280
movq -0xa0(%rbp), %rdx
leaq 0x480f(%rip), %rsi      # 0xd60a
leaq -0x70(%rbp), %rdi
callq 0x8fb0
jmp 0x8e06
movq -0xa8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x9060
jmp 0x8e18
movq -0xa8(%rbp), %rdi
movb $0x0, -0x72(%rbp)
leaq 0xadb6(%rip), %rsi      # 0x13be0
leaq -0x2d81(%rip), %rdx     # 0x60b0
callq 0x2260
jmp 0x8e8c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x8e5b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x20f0
leaq -0x71(%rbp), %rdi
callq 0x21c0
testb $0x1, -0x72(%rbp)
jne 0x8e6c
jmp 0x8e78
movq -0xa8(%rbp), %rdi
callq 0x2130
jmp 0x8e83
addq $0xb0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2270
nopl (%rax)
// File: schaefed[P]Ndarray/src/utils.hpp
// Function: std::array<unsigned long, 1ul> subarray<unsigned long, 1ul, 2ul>(std::array<unsigned long, 2ul>, unsigned long)
array<T, N> subarray(array<T, M> arr, size_t offset=0){
	array<T, N> out;
	for (size_t i=0; i<N; i++){
		out[i] = arr[offset+i];
	}
	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x1, -0x28(%rbp)
jae 0x8eed
movq -0x20(%rbp), %rsi
addq -0x28(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x5fe0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x63a0
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x8eac
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x9a00
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7a40
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7a60
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x995a
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x994a
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x9a20
jmp 0x9931
jmp 0x994a
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x99a0
jmp 0x9977
jmp 0x994c
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
jmp 0x9906
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x996d
movq -0x58(%rbp), %rdi
callq 0x99a0
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2270
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x10(%rbp)
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq %rcx, -0x18(%rbp)
movq 0x18(%rax), %rdi
callq 0x87e0
subq $0x1, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jl 0xa4af
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x87f0
movq %rax, %rcx
movq -0x58(%rbp), %rax
xorl %edx, %edx
divq (%rcx)
movq -0x48(%rbp), %rax
movq %rdx, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movq 0x20(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x87f0
movq -0x50(%rbp), %rcx
movq %rax, %rdx
movq -0x48(%rbp), %rax
imulq (%rdx), %rcx
addq -0x10(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x87f0
movq (%rax), %rcx
movq -0x18(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xa41d
cmpq $0x0, -0x18(%rbp)
jbe 0xa507
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x87f0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x60(%rbp)
movq 0x20(%rax), %rsi
leaq -0x40(%rbp), %rdi
callq 0x98c0
leaq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9980
movq %rax, %rcx
movq -0x60(%rbp), %rax
imulq (%rcx), %rax
movq %rax, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x99a0
movq -0x48(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, (%rax)
jge 0xa558
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jge 0xa573
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movslq 0x14(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x37b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x29ac
movq 0x20(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0x37d0
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq 0x20(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0x37d0
movsd (%rsp), %xmm0
movsd (%rax), %xmm2
movsd 0x18(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x293a
movsd 0x18(%rsp), %xmm0
callq 0x2190
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movl $0x1, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x3566
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x2300
cmpl $0x0, %eax
jne 0x3557
movl 0x4(%rsp), %eax
movl 0x14(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x354d
movq 0x18(%rsp), %rsi
leaq 0xeba5(%rip), %rdi      # 0x120e1
movb $0x0, %al
callq 0x2050
movl $0x1, %edi
callq 0x22c0
movl 0x4(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x356e
jmp 0x3559
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x34fa
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x68, %rdi
leaq 0x1c(%rsp), %rsi
callq 0x64a0
movq (%rsp), %rdi
addq $0x98, %rdi
leaq 0x14(%rsp), %rsi
callq 0x64a0
movq (%rsp), %rdi
addq $0x80, %rdi
leaq 0x18(%rsp), %rsi
callq 0x64a0
leaq 0x1c(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x6600
movq (%rsp), %rdi
movq %rax, 0xc(%rsp)
leaq 0xc(%rsp), %rsi
callq 0x6510
movq %rax, %rdi
leaq 0x18(%rsp), %rsi
callq 0x3dc0
movl $0x1, (%rax)
addq $0x28, %rsp
retq
// File: 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:
subq $0x48, %rsp
movl 0x50(%rsp), %eax
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movl %edx, 0x38(%rsp)
movl %ecx, 0x34(%rsp)
movl %r8d, 0x30(%rsp)
movl %r9d, 0x2c(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl 0x3c(%rsp), %esi
movl 0x38(%rsp), %edx
movl 0x34(%rsp), %ecx
callq 0xc130
movq 0x10(%rsp), %rdi
movsd %xmm0, 0x20(%rsp)
movl 0x30(%rsp), %esi
movl 0x2c(%rsp), %edx
movl 0x50(%rsp), %ecx
callq 0xc130
movq 0x10(%rsp), %rax
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
addsd 0x58(%rax), %xmm0
ucomisd 0x18(%rsp), %xmm0
jbe 0xa35a
movq 0x10(%rsp), %rdi
movsd 0x58(%rdi), %xmm0
addsd 0x20(%rsp), %xmm0
subsd 0x18(%rsp), %xmm0
addsd 0x38(%rdi), %xmm0
movsd %xmm0, 0x38(%rdi)
movl 0x3c(%rsp), %esi
movl 0x38(%rsp), %edx
movl 0x34(%rsp), %ecx
movl 0x30(%rsp), %r8d
movl 0x2c(%rsp), %r9d
movl 0x50(%rsp), %eax
movl %eax, (%rsp)
callq 0xc310
addq $0x48, %rsp
retq
nop
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl %edx, 0x48(%rsp)
movl %ecx, 0x44(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rsp)
testb $0x1, 0xe0c1(%rip)      # 0x1a220
je 0xc238
movl $0x0, 0x34(%rsp)
movq 0x28(%rsp), %rcx
movl 0x34(%rsp), %eax
cmpl 0x30(%rcx), %eax
jge 0xc233
movq 0x28(%rsp), %rdi
addq $0xe0, %rdi
movslq 0x48(%rsp), %rsi
callq 0x7fb0
movq %rax, %rdi
movslq 0x34(%rsp), %rsi
callq 0x37d0
movq 0x28(%rsp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
addq $0xe0, %rdi
movslq 0x4c(%rsp), %rsi
callq 0x7fb0
movq %rax, %rdi
movslq 0x34(%rsp), %rsi
callq 0x37d0
movsd 0x18(%rsp), %xmm0
movq 0x28(%rsp), %rdi
subsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
addq $0xc8, %rdi
movslq 0x44(%rsp), %rsi
callq 0x7fb0
movq %rax, %rdi
movslq 0x34(%rsp), %rsi
callq 0x37d0
movsd 0x20(%rsp), %xmm0
subsd (%rax), %xmm0
movaps 0x5e4d(%rip), %xmm1     # 0x12060
pand %xmm1, %xmm0
addsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0xc16d
jmp 0xc302
movl $0x0, 0x30(%rsp)
movq 0x28(%rsp), %rcx
movl 0x30(%rsp), %eax
cmpl 0x30(%rcx), %eax
jge 0xc300
movq 0x28(%rsp), %rdi
addq $0xe0, %rdi
movslq 0x48(%rsp), %rsi
callq 0x7fb0
movq %rax, %rdi
movslq 0x30(%rsp), %rsi
callq 0x37d0
movq 0x28(%rsp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
addq $0xe0, %rdi
movslq 0x4c(%rsp), %rsi
callq 0x7fb0
movq %rax, %rdi
movslq 0x30(%rsp), %rsi
callq 0x37d0
movsd 0x8(%rsp), %xmm0
movq 0x28(%rsp), %rdi
subsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
addq $0xc8, %rdi
movslq 0x44(%rsp), %rsi
callq 0x7fb0
movq %rax, %rdi
movslq 0x30(%rsp), %rsi
callq 0x37d0
movsd 0x10(%rsp), %xmm0
subsd (%rax), %xmm0
callq 0x2900
addsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0xc240
jmp 0xc302
movsd 0x38(%rsp), %xmm0
addq $0x58, %rsp
retq
nopl (%rax)
// File: 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
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x268(%rbp)
movq %rdi, -0x8(%rbp)
movb 0x16614(%rip), %al      # 0x1b350
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x4d4b
jmp 0x4e93
movq -0x268(%rbp), %rdi
callq 0x4180
movq %rax, %rsi
leaq -0x210(%rbp), %rdi
movl $0x4, %edx
callq 0x4620
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x4590
movb %al, -0x269(%rbp)
jmp 0x4d8b
movb -0x269(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4e72
movq -0x268(%rbp), %rdx
leaq 0xf29f(%rip), %rsi      # 0x1404c
leaq -0x260(%rbp), %rdi
callq 0x4f80
jmp 0x4dbb
leaq 0xf294(%rip), %rdx      # 0x14056
leaq -0x240(%rbp), %rdi
leaq -0x260(%rbp), %rsi
callq 0x4ef0
jmp 0x4dd7
leaq -0x240(%rbp), %rdi
callq 0x4180
movq %rax, -0x278(%rbp)
jmp 0x4dec
movq -0x278(%rbp), %rdi
callq 0x4310
jmp 0x4dfa
leaq -0x240(%rbp), %rdi
callq 0x4200
jmp 0x4e08
leaq -0x260(%rbp), %rdi
callq 0x4200
jmp 0x4e16
jmp 0x4e79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
jmp 0x4e9c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
jmp 0x4e62
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x4200
jmp 0x4e60
jmp 0x4e62
leaq -0x260(%rbp), %rdi
callq 0x4200
jmp 0x4e70
jmp 0x4e9c
movb $0x0, 0x164d7(%rip)     # 0x1b350
leaq -0x210(%rbp), %rdi
callq 0x40d0
jmp 0x4e87
leaq -0x210(%rbp), %rdi
callq 0x4100
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
leaq -0x210(%rbp), %rdi
callq 0x4100
jmp 0x4eaa
jmp 0x4eac
movq -0x218(%rbp), %rdi
callq 0x45e0
movq %rax, %rdi
callq 0x4ec0
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x1, 0x8(%rax)
jne 0x6f72
movl $0x0, -0xc(%rbp)
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0x106a0
movq %rax, %rcx
movl -0x3c(%rbp), %eax
movq %rcx, -0x14(%rbp)
cmpl -0x14(%rbp), %eax
jge 0x6f70
movl $0x24, %edi
callq 0x4af0
movl -0xc(%rbp), %eax
movl %eax, -0x44(%rbp)
callq 0x4110
movq -0x38(%rbp), %rdi
movl %eax, -0x40(%rbp)
callq 0x106a0
movl -0x44(%rbp), %esi
movq %rax, %rcx
movl -0x40(%rbp), %eax
movq %rcx, -0x24(%rbp)
cltd
idivl -0x20(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0x4ed0
movq -0x1c(%rbp), %rdi
callq 0x4c50
leaq 0xd1c4(%rip), %rdi      # 0x14122
movb $0x0, %al
callq 0x4070
movl -0xc(%rbp), %eax
addl $0x5, %eax
movl %eax, -0xc(%rbp)
jmp 0x6ef5
jmp 0x6f72
xorl %edi, %edi
movl $0x1, %esi
callq 0x4c00
callq 0x4c30
movl $0x24, %edi
callq 0x4af0
movl $0x0, -0x28(%rbp)
movq -0x38(%rbp), %rax
cvtsi2ssl -0x28(%rbp), %xmm0
movss %xmm0, -0x48(%rbp)
movq 0x38(%rax), %rdi
callq 0xcb90
movss 0xd0c9(%rip), %xmm1     # 0x1407c
mulss %xmm1, %xmm0
callq 0x76a0
movss -0x48(%rbp), %xmm1
ucomiss %xmm1, %xmm0
jbe 0x7051
movq -0x38(%rbp), %rdi
callq 0x106a0
movq %rax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %edi
subl $0x5, %edi
addl -0x28(%rbp), %edi
movl $0x1, %esi
callq 0x4c00
movq -0x38(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0xcb90
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x7019
leaq 0xd114(%rip), %rdi      # 0x14124
movb $0x0, %al
callq 0x4070
jmp 0x7041
movq -0x38(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0xcb90
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jbe 0x703f
leaq 0xd0ee(%rip), %rdi      # 0x14126
movb $0x0, %al
callq 0x4070
jmp 0x7041
jmp 0x7043
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x6f94
callq 0x4b80
movq -0x38(%rbp), %rdi
callq 0x105f0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movss %xmm1, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x45f0
movq -0x60(%rbp), %rdx
leaq 0xccda(%rip), %rsi      # 0x14128
leaq -0x40(%rbp), %rdi
callq 0x4490
jmp 0x7459
movq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x72a0
jmp 0x7468
leaq -0x40(%rbp), %rdi
callq 0x4200
jmp 0x7473
leaq -0x41(%rbp), %rdi
callq 0x4400
movq -0x68(%rbp), %rdi
leaq 0x137b9(%rip), %rax     # 0x1ac40
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x60, %rdi
callq 0x8aa0
jmp 0x7499
movq -0x68(%rbp), %rdi
movss -0x14(%rbp), %xmm0
movss %xmm0, 0x68(%rdi)
movss -0x18(%rbp), %xmm0
movss %xmm0, 0x6c(%rdi)
addq $0x74, %rdi
callq 0x7a30
jmp 0x74bc
movq -0x68(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, 0x80(%rdi)
movq -0x8(%rbp), %rax
movq %rax, 0x18(%rdi)
movq 0x18(%rdi), %rax
movq %rax, 0x74(%rdi)
callq 0xec50
jmp 0x74e2
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x750f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4200
jmp 0x750d
jmp 0x750f
leaq -0x41(%rbp), %rdi
callq 0x4400
jmp 0x7533
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x8a30
jmp 0x7531
jmp 0x7533
movq -0x50(%rbp), %rdi
callq 0x45e0
movq %rax, %rdi
callq 0x4ec0
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq 0x13a75(%rip), %rdi     # 0x1afe0
leaq -0x14(%rbp), %rsi
callq 0x40c0
movq 0x13a65(%rip), %rax     # 0x1afe0
movq (%rax), %rax
movq 0x13a5b(%rip), %rdi     # 0x1afe0
addq -0x18(%rax), %rdi
callq 0x4030
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x7612
movq 0x13a41(%rip), %rax     # 0x1afe0
movq (%rax), %rax
movq 0x13a37(%rip), %rdi     # 0x1afe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x4580
callq 0x8ac0
movq %rax, %rsi
movq 0x13a1d(%rip), %rdi     # 0x1afe0
movl $0xa, %edx
callq 0x4210
movq -0x8(%rbp), %rax
movq %rax, -0x1c(%rbp)
movq -0x1c(%rbp), %rdi
callq 0x4c50
movq -0x28(%rbp), %rdi
callq 0x4180
movq %rax, %rsi
leaq 0xcbb0(%rip), %rdi      # 0x141a1
movb $0x0, %al
callq 0x4070
callq 0x4c30
movq 0x139dc(%rip), %rdi     # 0x1afe0
leaq -0x14(%rbp), %rsi
callq 0x40c0
jmp 0x7574
movq 0x139c7(%rip), %rdi     # 0x1afe0
callq 0x4610
movq 0x139bb(%rip), %rax     # 0x1afe0
movq (%rax), %rax
movq 0x139b1(%rip), %rdi     # 0x1afe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x4580
movq 0x1399f(%rip), %rdi     # 0x1afe0
callq 0x43b0
movss -0x14(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x7890
movq -0x68(%rbp), %rdi
leaq 0x1356c(%rip), %rax     # 0x1ad10
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x38, %rdi
movq %rdi, -0x60(%rbp)
callq 0x7930
jmp 0x77ba
movq -0x68(%rbp), %rax
movb $0x0, 0x31(%rax)
leaq -0x1c(%rbp), %rdi
movl $0x2, %edx
movl %edx, %esi
callq 0x4ed0
jmp 0x77d4
movq -0x68(%rbp), %rax
movq -0x1c(%rbp), %rcx
movq %rcx, 0x18(%rax)
callq 0x7110
movq %rax, -0x70(%rbp)
jmp 0x77eb
movq -0x68(%rbp), %rax
movq -0x70(%rbp), %rcx
movq %rcx, -0x24(%rbp)
movq -0x24(%rbp), %rcx
movq %rcx, 0x20(%rax)
leaq -0x58(%rbp), %rdi
callq 0x7930
jmp 0x780a
movq -0x68(%rbp), %rdi
addq $0x38, %rdi
leaq -0x58(%rbp), %rsi
callq 0x7950
jmp 0x781d
leaq -0x58(%rbp), %rdi
callq 0x7980
jmp 0x7828
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x7870
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x7863
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x7980
jmp 0x7861
jmp 0x7863
movq -0x60(%rbp), %rdi
callq 0x7980
jmp 0x786e
jmp 0x7870
movq -0x68(%rbp), %rdi
callq 0x79a0
jmp 0x787b
jmp 0x787d
movq -0x10(%rbp), %rdi
callq 0x45e0
movq %rax, %rdi
callq 0x4ec0
nop
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rcx
movq %rcx, 0x18(%rax)
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movl $0x20, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
addq $0x8, %rdi
setb %al
orb %al, %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x4040
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, -0x28(%rbp)
cmpq $0x0, %rax
je 0xbdfc
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rdx
shlq $0x5, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x50(%rbp)
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x44a0
jmp 0xbde7
movq -0x50(%rbp), %rcx
movq -0x58(%rbp), %rax
addq $0x20, %rax
cmpq %rcx, %rax
movq %rax, -0x48(%rbp)
jne 0xbdd8
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rcx
movq %rax, %rsi
movq -0x58(%rbp), %rax
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq %rax, %rcx
movq %rax, -0x60(%rbp)
je 0xbe4c
movq -0x60(%rbp), %rdi
addq $-0x20, %rdi
movq %rdi, -0x68(%rbp)
callq 0x4200
jmp 0xbe3b
movq -0x68(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq %rcx, %rax
movq %rax, -0x60(%rbp)
jne 0xbe28
movq -0x30(%rbp), %rdi
callq 0x4470
movq -0x18(%rbp), %rdi
callq 0x45e0
movq %rax, %rdi
callq 0x4ec0
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jb 0x8a15
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0x8a15
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0x89fb
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rdx
movq 0x8(%rcx,%rdx,8), %rdx
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x89c4
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8a1d
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)