LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mittman[P]project254/cycle.cpp
// Function: Cycle::getIO(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string const Cycle::getIO(const string column9) {
	if(column9 == "Wr") {
		return "Write";
	}
	else if (column9 == "Rd") {
		return "Read";
	}
	else {
		return "???";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x48(%rbp)
movq %rdi, %rax
movq -0x48(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq %rax, %rcx
movq %rcx, -0x38(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
leaq 0x901f(%rip), %rsi      # 0xd010
callq 0x4a80
testb $0x1, %al
jne 0x3ffc
jmp 0x4047
leaq -0x19(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3450
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x8ffb(%rip), %rsi      # 0xd013
callq 0x4ab0
jmp 0x401f
leaq -0x19(%rbp), %rdi
callq 0x32d0
jmp 0x40e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x32d0
jmp 0x40f1
movq -0x48(%rbp), %rdi
leaq 0x8fc7(%rip), %rsi      # 0xd019
callq 0x4a80
testb $0x1, %al
jne 0x405d
jmp 0x40a2
leaq -0x2d(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3450
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x8fa3(%rip), %rsi      # 0xd01c
callq 0x4ab0
jmp 0x4080
leaq -0x2d(%rbp), %rdi
callq 0x32d0
jmp 0x40e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x2d(%rbp), %rdi
callq 0x32d0
jmp 0x40f1
leaq -0x2e(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3450
movq -0x40(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0x8f63(%rip), %rsi      # 0xd021
callq 0x4ab0
jmp 0x40c5
leaq -0x2e(%rbp), %rdi
callq 0x32d0
jmp 0x40e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x2e(%rbp), %rdi
callq 0x32d0
jmp 0x40f1
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3440
nopw (%rax,%rax)
// File: mittman[P]project254/cycle.cpp
// Function: Cycle::resetElapsed(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Cycle::resetElapsed(const string cycle, const string direction) {
	if(direction == "D-to-S" && cycle == "Read") {
		dsrTime = 0;
	}
	else if(direction == "D-to-S" && cycle == "Write") {
		dswTime = 0;
	}
	else if(direction == "S-to-D" && cycle == "Read") {
		sdrTime = 0;
	}
	else if(direction == "S-to-D" && cycle == "Write") {
		sdwTime = 0;
	}
	else {
		errTime = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x38(%rbp)
movq %rdi, %rax
movq -0x38(%rbp), %rdi
movq %rsi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x8bf8(%rip), %rsi      # 0xd02e
callq 0x4a80
testb $0x1, %al
jne 0x4441
jmp 0x4468
movq -0x30(%rbp), %rdi
leaq 0x8bd0(%rip), %rsi      # 0xd01c
callq 0x4a80
testb $0x1, %al
jne 0x4457
jmp 0x4468
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
jmp 0x452b
movq -0x28(%rbp), %rdi
leaq 0x8bbb(%rip), %rsi      # 0xd02e
callq 0x4a80
testb $0x1, %al
jne 0x447e
jmp 0x44a5
movq -0x30(%rbp), %rdi
leaq 0x8b8a(%rip), %rsi      # 0xd013
callq 0x4a80
testb $0x1, %al
jne 0x4494
jmp 0x44a5
movq -0x20(%rbp), %rax
movq $0x0, 0x20(%rax)
jmp 0x4529
movq -0x28(%rbp), %rdi
leaq 0x8b85(%rip), %rsi      # 0xd035
callq 0x4a80
testb $0x1, %al
jne 0x44bb
jmp 0x44df
movq -0x30(%rbp), %rdi
leaq 0x8b56(%rip), %rsi      # 0xd01c
callq 0x4a80
testb $0x1, %al
jne 0x44d1
jmp 0x44df
movq -0x20(%rbp), %rax
movq $0x0, 0x28(%rax)
jmp 0x4527
movq -0x28(%rbp), %rdi
leaq 0x8b4b(%rip), %rsi      # 0xd035
callq 0x4a80
testb $0x1, %al
jne 0x44f5
jmp 0x4519
movq -0x30(%rbp), %rdi
leaq 0x8b13(%rip), %rsi      # 0xd013
callq 0x4a80
testb $0x1, %al
jne 0x450b
jmp 0x4519
movq -0x20(%rbp), %rax
movq $0x0, 0x30(%rax)
jmp 0x4525
movq -0x20(%rbp), %rax
movq $0x0, 0x38(%rax)
jmp 0x4527
jmp 0x4529
jmp 0x452b
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mittman[P]project254/cycle.cpp
// Function: Cycle::setElapsed(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Cycle::setElapsed(const string cycle, const double elapsed, const string direction) {
	if(direction == "D-to-S" && cycle == "Read") {
		dsrTime += elapsed;
	}
	else if(direction == "D-to-S" && cycle == "Write") {
		dswTime += elapsed;
	}
	else if(direction == "S-to-D" && cycle == "Read") {
		sdrTime += elapsed;
	}
	else if(direction == "S-to-D" && cycle == "Write") {
		sdwTime += elapsed;
	}
	else {
		errTime += elapsed;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x40(%rbp)
movq %rdi, %rax
movq -0x40(%rbp), %rdi
movq %rsi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x8ab3(%rip), %rsi      # 0xd02e
callq 0x4a80
testb $0x1, %al
jne 0x4586
jmp 0x45bd
movq -0x38(%rbp), %rdi
leaq 0x8a8b(%rip), %rsi      # 0xd01c
callq 0x4a80
testb $0x1, %al
jne 0x459c
jmp 0x45bd
movq -0x28(%rbp), %rax
movsd -0x18(%rbp), %xmm1
cvtsi2sdq 0x18(%rax), %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, 0x18(%rax)
jmp 0x46c0
movq -0x30(%rbp), %rdi
leaq 0x8a66(%rip), %rsi      # 0xd02e
callq 0x4a80
testb $0x1, %al
jne 0x45d3
jmp 0x460a
movq -0x38(%rbp), %rdi
leaq 0x8a35(%rip), %rsi      # 0xd013
callq 0x4a80
testb $0x1, %al
jne 0x45e9
jmp 0x460a
movq -0x28(%rbp), %rax
movsd -0x18(%rbp), %xmm1
cvtsi2sdq 0x20(%rax), %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, 0x20(%rax)
jmp 0x46be
movq -0x30(%rbp), %rdi
leaq 0x8a20(%rip), %rsi      # 0xd035
callq 0x4a80
testb $0x1, %al
jne 0x4620
jmp 0x4654
movq -0x38(%rbp), %rdi
leaq 0x89f1(%rip), %rsi      # 0xd01c
callq 0x4a80
testb $0x1, %al
jne 0x4636
jmp 0x4654
movq -0x28(%rbp), %rax
movsd -0x18(%rbp), %xmm1
cvtsi2sdq 0x28(%rax), %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, 0x28(%rax)
jmp 0x46bc
movq -0x30(%rbp), %rdi
leaq 0x89d6(%rip), %rsi      # 0xd035
callq 0x4a80
testb $0x1, %al
jne 0x466a
jmp 0x469e
movq -0x38(%rbp), %rdi
leaq 0x899e(%rip), %rsi      # 0xd013
callq 0x4a80
testb $0x1, %al
jne 0x4680
jmp 0x469e
movq -0x28(%rbp), %rax
movsd -0x18(%rbp), %xmm1
cvtsi2sdq 0x30(%rax), %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, 0x30(%rax)
jmp 0x46ba
movq -0x28(%rbp), %rax
movsd -0x18(%rbp), %xmm1
cvtsi2sdq 0x38(%rax), %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, 0x38(%rax)
jmp 0x46bc
jmp 0x46be
jmp 0x46c0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mittman[P]project254/cycle.cpp
// Function: Cycle::plusType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Cycle::plusType(const string cycle, const string direction) {
	if(direction == "D-to-S" && cycle == "Read") {
		++dsReads;
	}
	else if(direction == "D-to-S" && cycle == "Write") {
		++dsWrites;
	}
	else if(direction == "S-to-D" && cycle == "Read") {
		++sdReads;
	}
	else if(direction == "S-to-D" && cycle == "Write") {
		++sdWrites;
	}
	else {
		++errors;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x38(%rbp)
movq %rdi, %rax
movq -0x38(%rbp), %rdi
movq %rsi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x8928(%rip), %rsi      # 0xd02e
callq 0x4a80
testb $0x1, %al
jne 0x4711
jmp 0x4737
movq -0x30(%rbp), %rdi
leaq 0x8900(%rip), %rsi      # 0xd01c
callq 0x4a80
testb $0x1, %al
jne 0x4727
jmp 0x4737
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x47fe
movq -0x28(%rbp), %rdi
leaq 0x88ec(%rip), %rsi      # 0xd02e
callq 0x4a80
testb $0x1, %al
jne 0x474d
jmp 0x4775
movq -0x30(%rbp), %rdi
leaq 0x88bb(%rip), %rsi      # 0xd013
callq 0x4a80
testb $0x1, %al
jne 0x4763
jmp 0x4775
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
jmp 0x47fc
movq -0x28(%rbp), %rdi
leaq 0x88b5(%rip), %rsi      # 0xd035
callq 0x4a80
testb $0x1, %al
jne 0x478b
jmp 0x47b0
movq -0x30(%rbp), %rdi
leaq 0x8886(%rip), %rsi      # 0xd01c
callq 0x4a80
testb $0x1, %al
jne 0x47a1
jmp 0x47b0
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x47fa
movq -0x28(%rbp), %rdi
leaq 0x887a(%rip), %rsi      # 0xd035
callq 0x4a80
testb $0x1, %al
jne 0x47c6
jmp 0x47eb
movq -0x30(%rbp), %rdi
leaq 0x8842(%rip), %rsi      # 0xd013
callq 0x4a80
testb $0x1, %al
jne 0x47dc
jmp 0x47eb
movq -0x20(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
jmp 0x47f8
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x47fa
jmp 0x47fc
jmp 0x47fe
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mittman[P]project254/cycle.cpp
// Function: Cycle::getBits(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Cycle::getBits(const string cycle, const string direction) {
	if(direction == "D-to-S" && cycle == "Read") {
		return dsReads * 32;
	}
	else if(direction == "D-to-S" && cycle == "Write") {
		return dsWrites * 32;
	}
	else if(direction == "S-to-D" && cycle == "Read") {
		return sdReads * 32;
	}
	else if(direction == "S-to-D" && cycle == "Write") {
		return sdWrites * 32;
	}
	else {
		return errors * 32;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x40(%rbp)
movq %rdi, %rax
movq -0x40(%rbp), %rdi
movq %rsi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x87e8(%rip), %rsi      # 0xd02e
callq 0x4a80
testb $0x1, %al
jne 0x4851
jmp 0x4878
movq -0x38(%rbp), %rdi
leaq 0x87c0(%rip), %rsi      # 0xd01c
callq 0x4a80
testb $0x1, %al
jne 0x4867
jmp 0x4878
movq -0x28(%rbp), %rax
movl (%rax), %eax
shll $0x5, %eax
movl %eax, -0x4(%rbp)
jmp 0x4939
movq -0x30(%rbp), %rdi
leaq 0x87ab(%rip), %rsi      # 0xd02e
callq 0x4a80
testb $0x1, %al
jne 0x488e
jmp 0x48b6
movq -0x38(%rbp), %rdi
leaq 0x877a(%rip), %rsi      # 0xd013
callq 0x4a80
testb $0x1, %al
jne 0x48a4
jmp 0x48b6
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
shll $0x5, %eax
movl %eax, -0x4(%rbp)
jmp 0x4939
movq -0x30(%rbp), %rdi
leaq 0x8774(%rip), %rsi      # 0xd035
callq 0x4a80
testb $0x1, %al
jne 0x48cc
jmp 0x48f1
movq -0x38(%rbp), %rdi
leaq 0x8745(%rip), %rsi      # 0xd01c
callq 0x4a80
testb $0x1, %al
jne 0x48e2
jmp 0x48f1
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
shll $0x5, %eax
movl %eax, -0x4(%rbp)
jmp 0x4939
movq -0x30(%rbp), %rdi
leaq 0x8739(%rip), %rsi      # 0xd035
callq 0x4a80
testb $0x1, %al
jne 0x4907
jmp 0x492c
movq -0x38(%rbp), %rdi
leaq 0x8701(%rip), %rsi      # 0xd013
callq 0x4a80
testb $0x1, %al
jne 0x491d
jmp 0x492c
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
shll $0x5, %eax
movl %eax, -0x4(%rbp)
jmp 0x4939
movq -0x28(%rbp), %rax
movl 0x10(%rax), %eax
shll $0x5, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mittman[P]project254/cycle.cpp
// Function: Cycle::getElapsed(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
long Cycle::getElapsed(const string cycle, const string direction) {
	if(direction == "D-to-S" && cycle == "Read") {
		return dsrTime;
	}
	else if(direction == "D-to-S" && cycle == "Write") {
		return dswTime;
	}
	else if(direction == "S-to-D" && cycle == "Read") {
		return sdrTime;
	}
	else if(direction == "S-to-D" && cycle == "Write") {
		return sdwTime;
	}
	else {
		return errTime;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x40(%rbp)
movq %rdi, %rax
movq -0x40(%rbp), %rdi
movq %rsi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x86a8(%rip), %rsi      # 0xd02e
callq 0x4a80
testb $0x1, %al
jne 0x4991
jmp 0x49b8
movq -0x38(%rbp), %rdi
leaq 0x8680(%rip), %rsi      # 0xd01c
callq 0x4a80
testb $0x1, %al
jne 0x49a7
jmp 0x49b8
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4a75
movq -0x30(%rbp), %rdi
leaq 0x866b(%rip), %rsi      # 0xd02e
callq 0x4a80
testb $0x1, %al
jne 0x49ce
jmp 0x49f5
movq -0x38(%rbp), %rdi
leaq 0x863a(%rip), %rsi      # 0xd013
callq 0x4a80
testb $0x1, %al
jne 0x49e4
jmp 0x49f5
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4a75
movq -0x30(%rbp), %rdi
leaq 0x8635(%rip), %rsi      # 0xd035
callq 0x4a80
testb $0x1, %al
jne 0x4a0b
jmp 0x4a2f
movq -0x38(%rbp), %rdi
leaq 0x8606(%rip), %rsi      # 0xd01c
callq 0x4a80
testb $0x1, %al
jne 0x4a21
jmp 0x4a2f
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4a75
movq -0x30(%rbp), %rdi
leaq 0x85fb(%rip), %rsi      # 0xd035
callq 0x4a80
testb $0x1, %al
jne 0x4a45
jmp 0x4a69
movq -0x38(%rbp), %rdi
leaq 0x85c3(%rip), %rsi      # 0xd013
callq 0x4a80
testb $0x1, %al
jne 0x4a5b
jmp 0x4a69
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4a75
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: mittman[P]project254/datarate.cpp
// Function: DataRate::MegaBits(int, long)
float const DataRate::MegaBits(const int words, const long nanoSec) {
	int bits = words * 32;
	float microSec = 0;
	microSec = nanoSec / 1000;
	return bits / microSec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
shll $0x5, %eax
movl %eax, -0x1c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
cvtsi2ss %rax, %xmm0
movss %xmm0, -0x20(%rbp)
cvtsi2ssl -0x1c(%rbp), %xmm0
divss -0x20(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mittman[P]project254/output.cpp
// Function: Output::setMode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Output::setMode(const string mode) {
	stdout = false;
	logfile = false;

	if(mode == "print") {
		stdout = true;
	}
	else if(mode == "file") {
		logfile = true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, %rax
movq -0x28(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x0, (%rax)
movb $0x0, 0x1(%rax)
leaq 0x7ef7(%rip), %rsi      # 0xd09c
callq 0x4a80
testb $0x1, %al
jne 0x51b0
jmp 0x51b9
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
jmp 0x51d9
movq -0x20(%rbp), %rdi
leaq 0x7ede(%rip), %rsi      # 0xd0a2
callq 0x4a80
testb $0x1, %al
jne 0x51cf
jmp 0x51d7
movq -0x18(%rbp), %rax
movb $0x1, 0x1(%rax)
jmp 0x51d9
addq $0x30, %rsp
popq %rbp
retq
nop
// File: mittman[P]project254/output.cpp
// Function: Output::writeBlank(std::basic_fstream<char, std::char_traits<char>>&)
void const Output::writeBlank(fstream &f) {
	if(stdout) {
		cout << endl;
	}

	if(logfile) {
		f << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, (%rax)
je 0x5210
movq 0xcdcc(%rip), %rdi      # 0x11fd0
movq 0xcdb5(%rip), %rsi      # 0x11fc0
callq 0x32b0
movq -0x18(%rbp), %rax
testb $0x1, 0x1(%rax)
je 0x522e
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq 0xcd97(%rip), %rsi      # 0x11fc0
callq 0x32b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mittman[P]project254/output.cpp
// Function: Output::writeCommand(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::basic_fstream<char, std::char_traits<char>>&)
void const Output::writeCommand(const string cycle, const int words, const int num, const string direction, fstream &f) {
	if(stdout) {
		cout << "Line " << num << ": ";
		cout << cycle << " " << direction << " command: ";
		cout << words << " words" << endl;
	}

	if(logfile) {
		f << "Line " << num << ": ";
		f << cycle << " " << direction << " command: ";
		f << words << " words" << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x40(%rbp)
movq %r8, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, (%rax)
je 0x530b
movq 0xcd52(%rip), %rdi      # 0x11fd0
leaq 0x7e22(%rip), %rsi      # 0xd0a7
callq 0x3260
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0x3420
movq %rax, %rdi
leaq 0x7e16(%rip), %rsi      # 0xd0b5
callq 0x3260
movq -0x40(%rbp), %rsi
movq 0xcd21(%rip), %rdi      # 0x11fd0
callq 0x3240
movq %rax, %rdi
leaq 0x7df8(%rip), %rsi      # 0xd0b6
callq 0x3260
movq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x3240
movq %rax, %rdi
leaq 0x7dd4(%rip), %rsi      # 0xd0ad
callq 0x3260
movl -0x14(%rbp), %esi
movq 0xcce8(%rip), %rdi      # 0x11fd0
callq 0x3420
movq %rax, %rdi
leaq 0x7dc1(%rip), %rsi      # 0xd0b8
callq 0x3260
movq %rax, %rdi
movq 0xccba(%rip), %rsi      # 0x11fc0
callq 0x32b0
movq -0x30(%rbp), %rax
testb $0x1, 0x1(%rax)
je 0x53b0
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
leaq 0x7d7f(%rip), %rsi      # 0xd0a7
callq 0x3260
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0x3420
movq %rax, %rdi
leaq 0x7d73(%rip), %rsi      # 0xd0b5
callq 0x3260
movq -0x40(%rbp), %rsi
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
callq 0x3240
movq %rax, %rdi
leaq 0x7d54(%rip), %rsi      # 0xd0b6
callq 0x3260
movq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x3240
movq %rax, %rdi
leaq 0x7d30(%rip), %rsi      # 0xd0ad
callq 0x3260
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movl -0x14(%rbp), %esi
callq 0x3420
movq %rax, %rdi
leaq 0x7d1c(%rip), %rsi      # 0xd0b8
callq 0x3260
movq %rax, %rdi
movq 0xcc15(%rip), %rsi      # 0x11fc0
callq 0x32b0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mittman[P]project254/output.cpp
// Function: Output::writeRate(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::basic_fstream<char, std::char_traits<char>>&)
void const Output::writeRate(const string rate, const string cycle, const string direction, fstream &f) {
	if(stdout) {
		cout << cycle << " " << direction << ": " << rate << endl;
	}

	if(logfile) {
		f << cycle << " " << direction << ": " << rate << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq %rcx, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, (%rax)
je 0x544a
movq -0x40(%rbp), %rsi
movq 0xcbd0(%rip), %rdi      # 0x11fd0
callq 0x3240
movq %rax, %rdi
leaq 0x7ca7(%rip), %rsi      # 0xd0b6
callq 0x3260
movq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x3240
movq %rax, %rdi
leaq 0x7c8b(%rip), %rsi      # 0xd0b5
callq 0x3260
movq -0x48(%rbp), %rsi
movq %rax, %rdi
callq 0x3240
movq %rax, %rdi
movq 0xcb7b(%rip), %rsi      # 0x11fc0
callq 0x32b0
movq -0x30(%rbp), %rax
testb $0x1, 0x1(%rax)
je 0x54aa
movq -0x40(%rbp), %rsi
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
callq 0x3240
movq %rax, %rdi
leaq 0x7c47(%rip), %rsi      # 0xd0b6
callq 0x3260
movq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x3240
movq %rax, %rdi
leaq 0x7c2b(%rip), %rsi      # 0xd0b5
callq 0x3260
movq -0x48(%rbp), %rsi
movq %rax, %rdi
callq 0x3240
movq %rax, %rdi
movq 0xcb1b(%rip), %rsi      # 0x11fc0
callq 0x32b0
addq $0x50, %rsp
popq %rbp
retq
// File: mittman[P]project254/output.cpp
// Function: Output::writeWords(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, std::basic_fstream<char, std::char_traits<char>>&)
void const Output::writeWords(const string data, const int wordPos, const int num, fstream &f) {
	if(stdout) {
		cout << "Line " << num << ": Word " << wordPos << ": " << data << endl;
	}

	if(logfile) {
		f << "Line " << num << ": Word " << wordPos << ": " << data << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, (%rax)
je 0x553d
movq 0xcaee(%rip), %rdi      # 0x11fd0
leaq 0x7bbe(%rip), %rsi      # 0xd0a7
callq 0x3260
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0x3420
movq %rax, %rdi
leaq 0x7bbc(%rip), %rsi      # 0xd0bf
callq 0x3260
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x3420
movq %rax, %rdi
leaq 0x7b98(%rip), %rsi      # 0xd0b5
callq 0x3260
movq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x3240
movq %rax, %rdi
movq 0xca88(%rip), %rsi      # 0x11fc0
callq 0x32b0
movq -0x28(%rbp), %rax
testb $0x1, 0x1(%rax)
je 0x55aa
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
leaq 0x7b51(%rip), %rsi      # 0xd0a7
callq 0x3260
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0x3420
movq %rax, %rdi
leaq 0x7b4f(%rip), %rsi      # 0xd0bf
callq 0x3260
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x3420
movq %rax, %rdi
leaq 0x7b2b(%rip), %rsi      # 0xd0b5
callq 0x3260
movq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x3240
movq %rax, %rdi
movq 0xca1b(%rip), %rsi      # 0x11fc0
callq 0x32b0
addq $0x30, %rsp
popq %rbp
retq
// File: elarielcl[P]ArielsSequitur/TestSequitur.cpp
// Function: numberOfRulesTest(char*, int)
void numberOfRulesTest(char string[], int expectedNOR) {
  cout << "INPUT=" << string << endl;
  SequiturGrammar* grammar = new SequiturGrammar();
  for (int i = 0; string[i]!=0; ++i)
    grammar->put(string[i]);
  if (grammar->numberOfRules == expectedNOR) cout << "SUCCESSFUL TEST (GrammarSize == expected)" << endl;
  else {
    cout << "WRONG TEST (NumberOfRules(" << grammar->numberOfRules << ") != expected("<< expectedNOR << "))" << endl;
    exit(1);
  }

  cout << "================" << endl << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0xe112(%rip), %rdi      # 0x10fd8
leaq 0x8232(%rip), %rsi      # 0xb0ff
callq 0x2150
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x2150
movq %rax, %rdi
movq 0xe0e0(%rip), %rsi      # 0x10fc8
callq 0x2190
movl $0x28, %edi
callq 0x2160
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movl $0x100, %esi            # imm = 0x100
movl $0x774dfe0, %edx        # imm = 0x774DFE0
callq 0x7ef0
jmp 0x2f12
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x2f71
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0x7ff0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2f21
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x28, %esi
callq 0x2170
jmp 0x303c
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x2fa1
movq 0xe054(%rip), %rdi      # 0x10fd8
leaq 0x81b4(%rip), %rsi      # 0xb13f
callq 0x2150
movq %rax, %rdi
movq 0xe02e(%rip), %rsi      # 0x10fc8
callq 0x2190
jmp 0x3005
movq 0xe030(%rip), %rdi      # 0x10fd8
leaq 0x81e5(%rip), %rsi      # 0xb194
callq 0x2150
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x2250
movq %rax, %rdi
leaq 0x81b5(%rip), %rsi      # 0xb182
callq 0x2150
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2250
movq %rax, %rdi
leaq 0x81aa(%rip), %rsi      # 0xb191
callq 0x2150
movq %rax, %rdi
movq 0xdfd2(%rip), %rsi      # 0x10fc8
callq 0x2190
movl $0x1, %edi
callq 0x21f0
movq 0xdfcc(%rip), %rdi      # 0x10fd8
leaq 0x80a2(%rip), %rsi      # 0xb0b5
callq 0x2150
movq %rax, %rdi
movq 0xdfa6(%rip), %rsi      # 0x10fc8
callq 0x2190
movq %rax, %rdi
movq 0xdf97(%rip), %rsi      # 0x10fc8
callq 0x2190
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2260
nopw %cs:(%rax,%rax)
// File: elarielcl[P]ArielsSequitur/TestSequitur.cpp
// Function: grammarSizeTest(char*, int)
void grammarSizeTest(char string[], int expectedGrammarSize) {
  cout << "INPUT=" << string << endl;
  SequiturGrammar* grammar = new SequiturGrammar();
  for (int i = 0; string[i]!=0; ++i)
    grammar->put(string[i]);
  if (grammar->grammarSize == expectedGrammarSize) cout << "SUCCESSFUL TEST (GrammarSize == expected)" << endl;
  else {
    cout << "WRONG TEST (GrammarSize(" << grammar->grammarSize << ") != expected("<< expectedGrammarSize << "))" << endl;
    exit(1);
  }

  cout << "================" << endl << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0xdf72(%rip), %rdi      # 0x10fd8
leaq 0x8092(%rip), %rsi      # 0xb0ff
callq 0x2150
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x2150
movq %rax, %rdi
movq 0xdf40(%rip), %rsi      # 0x10fc8
callq 0x2190
movl $0x28, %edi
callq 0x2160
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movl $0x100, %esi            # imm = 0x100
movl $0x774dfe0, %edx        # imm = 0x774DFE0
callq 0x7ef0
jmp 0x30b2
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x3111
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0x7ff0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x30c1
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x28, %esi
callq 0x2170
jmp 0x31dc
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x3141
movq 0xdeb4(%rip), %rdi      # 0x10fd8
leaq 0x8014(%rip), %rsi      # 0xb13f
callq 0x2150
movq %rax, %rdi
movq 0xde8e(%rip), %rsi      # 0x10fc8
callq 0x2190
jmp 0x31a5
movq 0xde90(%rip), %rdi      # 0x10fd8
leaq 0x801a(%rip), %rsi      # 0xb169
callq 0x2150
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x2250
movq %rax, %rdi
leaq 0x8015(%rip), %rsi      # 0xb182
callq 0x2150
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2250
movq %rax, %rdi
leaq 0x800a(%rip), %rsi      # 0xb191
callq 0x2150
movq %rax, %rdi
movq 0xde32(%rip), %rsi      # 0x10fc8
callq 0x2190
movl $0x1, %edi
callq 0x21f0
movq 0xde2c(%rip), %rdi      # 0x10fd8
leaq 0x7f02(%rip), %rsi      # 0xb0b5
callq 0x2150
movq %rax, %rdi
movq 0xde06(%rip), %rsi      # 0x10fc8
callq 0x2190
movq %rax, %rdi
movq 0xddf7(%rip), %rsi      # 0x10fc8
callq 0x2190
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2260
nopw %cs:(%rax,%rax)
// File: Tarstingo[P]rarcrack/crackrar.cpp
// Function: CAes(unsigned char*, std::vector<unsigned char, std::allocator<unsigned char>>, unsigned char*)
void CAes(muchar *B,std::vector<muchar> s,muchar *C)
{
    muchar ins[16];
    muchar Bcp[16];//re arrange the sequence of B
    for(int i=0;i<4;i++)
    {
        for(int j=0;j<4;j++)
            Bcp[4*i+j]=B[4*i+3-j];
    }
    AES_KEY keyaes;

    AES_set_decrypt_key(Bcp,128,&keyaes);
    for(int i=0;i<16;i++)
        ins[i]=s[i];
    AES_ecb_encrypt(ins,C,&keyaes,AES_DECRYPT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rsi, -0x148(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x44(%rbp)
cmpl $0x4, -0x44(%rbp)
jge 0x2da5
movl $0x0, -0x48(%rbp)
cmpl $0x4, -0x48(%rbp)
jge 0x2d98
movq -0x8(%rbp), %rax
movl -0x44(%rbp), %ecx
shll $0x2, %ecx
addl $0x3, %ecx
subl -0x48(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movl -0x44(%rbp), %eax
shll $0x2, %eax
addl -0x48(%rbp), %eax
cltq
movb %cl, -0x40(%rbp,%rax)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x2d62
jmp 0x2d9a
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x2d55
leaq -0x40(%rbp), %rdi
movl $0x80, %esi
leaq -0x13c(%rbp), %rdx
callq 0x21c0
movl $0x0, -0x140(%rbp)
cmpl $0x10, -0x140(%rbp)
jge 0x2dfe
movq -0x148(%rbp), %rdi
movslq -0x140(%rbp), %rsi
callq 0x3510
movb (%rax), %cl
movslq -0x140(%rbp), %rax
movb %cl, -0x30(%rbp,%rax)
movl -0x140(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x140(%rbp)
jmp 0x2dc4
leaq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x13c(%rbp), %rdx
xorl %ecx, %ecx
callq 0x20d0
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopl (%rax)
// File: ridgelab[P]Kmer-SSR/test/src/task.cpp
// Function: main
int main()
{
	Task task1 = Task();
	Task task2("SomeSeqID", "ACGTGTACGATCGACTACGATCACACACGT", 237, 946);

	//cout << task1.toString() << endl;
	//cout << task2.toString() << endl;
	
	cout << "\n\033[0;34mTask Test: ";

	bool pass = true;

	if (pass)
	{
		cout << "\033[0;32mOK\033[0m" << endl;
	}
	else
	{
		cout << "\033[0;31mFAIL\033[0m" << endl;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movl $0x0, -0x4(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x29c0
leaq -0xb9(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x2270
movq -0x100(%rbp), %rdx
leaq 0x1b88(%rip), %rsi      # 0x4004
leaq -0xb8(%rbp), %rdi
callq 0x2670
jmp 0x248a
leaq -0xf1(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x2270
movq -0x108(%rbp), %rdx
leaq 0x1b63(%rip), %rsi      # 0x400e
leaq -0xf0(%rbp), %rdi
callq 0x2670
jmp 0x24b9
leaq -0x98(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
leaq -0xf0(%rbp), %rdx
movl $0xed, %ecx
movl $0x3b2, %r8d            # imm = 0x3B2
callq 0x2a00
jmp 0x24e0
leaq -0xf0(%rbp), %rdi
callq 0x20c0
leaq -0xf1(%rbp), %rdi
callq 0x21b0
leaq -0xb8(%rbp), %rdi
callq 0x20c0
leaq -0xb9(%rbp), %rdi
callq 0x21b0
movq 0x3ac1(%rip), %rdi      # 0x5fd8
leaq 0x1b0f(%rip), %rsi      # 0x402d
callq 0x2170
jmp 0x2525
movb $0x1, -0xf2(%rbp)
testb $0x1, -0xf2(%rbp)
je 0x25fb
movq 0x3a98(%rip), %rdi      # 0x5fd8
leaq 0x1afa(%rip), %rsi      # 0x4041
callq 0x2170
movq %rax, -0x110(%rbp)
jmp 0x2555
movq -0x110(%rbp), %rdi
movq 0x3a65(%rip), %rsi      # 0x5fc8
callq 0x2190
jmp 0x256a
jmp 0x262e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0x25cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0x25b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x20c0
leaq -0xf1(%rbp), %rdi
callq 0x21b0
leaq -0xb8(%rbp), %rdi
callq 0x20c0
leaq -0xb9(%rbp), %rdi
callq 0x21b0
jmp 0x2656
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x2aa0
jmp 0x2656
movq 0x39d6(%rip), %rdi      # 0x5fd8
leaq 0x1a46(%rip), %rsi      # 0x404f
callq 0x2170
movq %rax, -0x118(%rbp)
jmp 0x2617
movq -0x118(%rbp), %rdi
movq 0x39a3(%rip), %rsi      # 0x5fc8
callq 0x2190
jmp 0x262c
jmp 0x262e
movl $0x0, -0x4(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x2aa0
leaq -0x50(%rbp), %rdi
callq 0x2aa0
movl -0x4(%rbp), %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
leaq -0x50(%rbp), %rdi
callq 0x2aa0
movq -0xc8(%rbp), %rdi
callq 0x2260
nopl (%rax,%rax)
// File: Distrotech[P]stund/server.cxx
// Function: usage()
void 
usage()
{
   cerr << "Usage: " << endl
        << " ./server [-v] [-h] [-h IP_Address] [-a IP_Address] [-p port] [-o port] [-m mediaport]" << endl
        << " " << endl
        << " If the IP addresses of your NIC are 10.0.1.150 and 10.0.1.151, run this program with" << endl
        << "    ./server -v  -h 10.0.1.150 -a 10.0.1.151" << endl
        << " STUN servers need two IP addresses and two ports, these can be specified with:" << endl
        << "  -h sets the primary IP" << endl
        << "  -a sets the secondary IP" << endl
        << "  -p sets the primary port and defaults to 3478" << endl
        << "  -o sets the secondary port and defaults to 3479" << endl
        << "  -b makes the program run in the backgroud" << endl
        << "  -m sets up a STERN server starting at port m" << endl
        << "  -v runs in verbose mode" << endl
      // in makefile too
        << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xbae5(%rip), %rdi      # 0xdff0
leaq 0x7af2(%rip), %rsi      # 0xa004
callq 0x21f0
movq %rax, %rdi
movq 0xbaa7(%rip), %rsi      # 0xdfc8
callq 0x2200
movq %rax, %rdi
leaq 0x7adc(%rip), %rsi      # 0xa00c
callq 0x21f0
movq %rax, %rdi
movq 0xba89(%rip), %rsi      # 0xdfc8
callq 0x2200
movq %rax, %rdi
leaq 0x7d60(%rip), %rsi      # 0xa2ae
callq 0x21f0
movq %rax, %rdi
movq 0xba6b(%rip), %rsi      # 0xdfc8
callq 0x2200
movq %rax, %rdi
leaq 0x7af7(%rip), %rsi      # 0xa063
callq 0x21f0
movq %rax, %rdi
movq 0xba4d(%rip), %rsi      # 0xdfc8
callq 0x2200
movq %rax, %rdi
leaq 0x7b2f(%rip), %rsi      # 0xa0b9
callq 0x21f0
movq %rax, %rdi
movq 0xba2f(%rip), %rsi      # 0xdfc8
callq 0x2200
movq %rax, %rdi
leaq 0x7b3e(%rip), %rsi      # 0xa0e6
callq 0x21f0
movq %rax, %rdi
movq 0xba11(%rip), %rsi      # 0xdfc8
callq 0x2200
movq %rax, %rdi
leaq 0x7b70(%rip), %rsi      # 0xa136
callq 0x21f0
movq %rax, %rdi
movq 0xb9f3(%rip), %rsi      # 0xdfc8
callq 0x2200
movq %rax, %rdi
leaq 0x7b6b(%rip), %rsi      # 0xa14f
callq 0x21f0
movq %rax, %rdi
movq 0xb9d5(%rip), %rsi      # 0xdfc8
callq 0x2200
movq %rax, %rdi
leaq 0x7b68(%rip), %rsi      # 0xa16a
callq 0x21f0
movq %rax, %rdi
movq 0xb9b7(%rip), %rsi      # 0xdfc8
callq 0x2200
movq %rax, %rdi
leaq 0x7b7a(%rip), %rsi      # 0xa19a
callq 0x21f0
movq %rax, %rdi
movq 0xb999(%rip), %rsi      # 0xdfc8
callq 0x2200
movq %rax, %rdi
leaq 0x7b8e(%rip), %rsi      # 0xa1cc
callq 0x21f0
movq %rax, %rdi
movq 0xb97b(%rip), %rsi      # 0xdfc8
callq 0x2200
movq %rax, %rdi
leaq 0x7b9c(%rip), %rsi      # 0xa1f8
callq 0x21f0
movq %rax, %rdi
movq 0xb95d(%rip), %rsi      # 0xdfc8
callq 0x2200
movq %rax, %rdi
leaq 0x7bad(%rip), %rsi      # 0xa227
callq 0x21f0
movq %rax, %rdi
movq 0xb93f(%rip), %rsi      # 0xdfc8
callq 0x2200
movq %rax, %rdi
movq 0xb930(%rip), %rsi      # 0xdfc8
callq 0x2200
popq %rbp
retq
nop
// File: attractivechaos[P]udb2/c++11/test.cpp
// Function: test_int(unsigned int, unsigned int)
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	std::unordered_map<uint32_t, uint32_t, Hash32> h;
	for (i = 0, x = x0; i < n; ++i) {
		x = hash32(x);
		z += ++h[get_key(n, x)];
	}
	fprintf(stderr, "# unique keys: %ld; checksum: %u\n", h.size(), z);
	return h.size();
}

// Assembly:
subq $0x88, %rsp
movl %edi, 0x84(%rsp)
movl %esi, 0x80(%rsp)
movl $0x0, 0x74(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x1760
movl $0x0, 0x7c(%rsp)
movl 0x80(%rsp), %eax
movl %eax, 0x78(%rsp)
movl 0x7c(%rsp), %eax
cmpl 0x84(%rsp), %eax
jae 0x16e1
movl 0x78(%rsp), %edi
callq 0x12b0
movl %eax, 0x24(%rsp)
jmp 0x166a
movl 0x24(%rsp), %eax
movl %eax, 0x78(%rsp)
movl 0x84(%rsp), %edi
movl 0x78(%rsp), %esi
callq 0x1320
movl %eax, 0x20(%rsp)
jmp 0x1688
movl 0x20(%rsp), %eax
movl %eax, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1770
movq %rax, 0x18(%rsp)
jmp 0x16a6
movq 0x18(%rsp), %rcx
movl (%rcx), %eax
addl $0x1, %eax
movl %eax, (%rcx)
addl 0x74(%rsp), %eax
movl %eax, 0x74(%rsp)
movl 0x7c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x7c(%rsp)
jmp 0x164a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x17b0
jmp 0x1738
movq 0x48f8(%rip), %rax      # 0x5fe0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x17a0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl 0x74(%rsp), %ecx
leaq 0x196c(%rip), %rsi      # 0x3079
movb $0x0, %al
callq 0x10f0
leaq 0x38(%rsp), %rdi
callq 0x17a0
movl %eax, 0x14(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x17b0
movl 0x14(%rsp), %eax
addq $0x88, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x1130
nopw %cs:(%rax,%rax)
// File: MarkCBell[P]twister/./twister/kernel/global.cpp
// Function: set_globals_to_defaults()
void set_globals_to_defaults()
{
	// Reset the global options to their defaults.
	GLOBAL_debugging_level = 0;
	GLOBAL_warnings = true;
	GLOBAL_optimise = true;
	GLOBAL_calculate_peripheral_curves = true;
	GLOBAL_message_stream = "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, 0x30832(%rip)     # 0x35410
movb $0x1, 0x30723(%rip)     # 0x35308
movb $0x1, 0x3071d(%rip)     # 0x35309
movb $0x1, 0x30717(%rip)     # 0x3530a
leaq 0x3081e(%rip), %rdi     # 0x35418
leaq 0x226f1(%rip), %rsi     # 0x272f2
callq 0x3420
popq %rbp
retq
nopl (%rax,%rax)
// File: MarkCBell[P]twister/./twister/kernel/global.cpp
// Function: output_error(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void output_error(const std::string strn)
{
	if (GLOBAL_warnings)
		GLOBAL_message_stream += "Error: " + strn + "\n";
	
	throw -1;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
testb $0x1, 0x305b1(%rip)     # 0x35308
je 0x4ddf
movq -0x60(%rbp), %rdx
leaq 0x222f9(%rip), %rsi     # 0x27061
leaq -0x48(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4ec0
movq -0x68(%rbp), %rsi
leaq 0x222df(%rip), %rdx     # 0x2705f
leaq -0x28(%rbp), %rdi
callq 0x4fd0
jmp 0x4d8b
leaq 0x30686(%rip), %rdi     # 0x35418
leaq -0x28(%rbp), %rsi
callq 0x33e0
jmp 0x4d9d
leaq -0x28(%rbp), %rdi
callq 0x35f8
leaq -0x48(%rbp), %rdi
callq 0x35f8
jmp 0x4ddf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x4dd4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x35f8
leaq -0x48(%rbp), %rdi
callq 0x35f8
jmp 0x4e02
movl $0x4, %edi
callq 0x3160
movq %rax, %rdi
movl $0xffffffff, (%rdi)     # imm = 0xFFFFFFFF
movq 0x301af(%rip), %rsi     # 0x34fa8
xorl %eax, %eax
movl %eax, %edx
callq 0x3520
movq -0x50(%rbp), %rdi
callq 0x3550
nopl (%rax,%rax)
// File: MarkCBell[P]twister/./twister/kernel/twister.h
// Function: perm::perm(int, int, int, int)
perm(int im0, int im1, int im2, int im3)
	{
		image[0] = im0;
		image[1] = im1;
		image[2] = im2;
		image[3] = im3;
		
		// Make sure the thing that we've just made is a permutation.
		// As users have no direct control over permutations, this is to check hard coded permutations are valid.
		for (int i=0; i<4; i++)
			for (int j=i+1; j<4; j++)
				if (image[i] == image[j]) output_error("Invalid permutation.");
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x9dc0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
cmpl $0x4, -0x20(%rbp)
jge 0x9db0
movq -0x60(%rbp), %rcx
movslq -0x1c(%rbp), %rax
movl (%rcx,%rax,4), %eax
movslq -0x20(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x9da0
leaq -0x41(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x3560
movq -0x68(%rbp), %rdx
leaq 0x1d4ea(%rip), %rsi     # 0x27232
leaq -0x40(%rbp), %rdi
callq 0x4e10
jmp 0x9d53
leaq -0x40(%rbp), %rdi
callq 0x4d40
jmp 0x9d5e
leaq -0x40(%rbp), %rdi
callq 0x35f8
leaq -0x41(%rbp), %rdi
callq 0x3360
jmp 0x9da0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x9d95
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x35f8
leaq -0x41(%rbp), %rdi
callq 0x3360
jmp 0x9dc6
jmp 0x9da2
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x9d12
jmp 0x9db2
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9cff
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3550
nop
// File: MarkCBell[P]twister/./twister/kernel/parsing.cpp
// Function: count_substring(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int count_substring(const std::string inpt, const std::string search_for)
{
	int count = 0;
	for (size_t pos = inpt.find(search_for); pos != std::string::npos; count++)
		pos = inpt.find(search_for, pos + 1);
	
	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
xorl %eax, %eax
movl %eax, %edx
callq 0x35e0
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
je 0x11c07
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rdx
addq $0x1, %rdx
callq 0x35e0
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11bdc
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: MarkCBell[P]twister/./twister/kernel/parsing.cpp
// Function: remove_whitespace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string remove_whitespace(const std::string inpt)
{
	std::string output = "";
	output.reserve(inpt.size());
	size_t marker = 0, next_marker = 0;
	
	do
	{
		next_marker = inpt.find_first_of(" \t", marker);  // Could filter out more characters here.
		output += inpt.substr(marker, next_marker - marker);
		marker = next_marker + 1;  // Skip over the bad character.
	} while (marker != 0);  // When next_marker == std::string::npos, marker == std::string::npos + 1 == 0.
	
	return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x78(%rbp)
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3560
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0x15570(%rip), %rsi     # 0x272f2
callq 0x4e10
jmp 0x11d89
leaq -0x12(%rbp), %rdi
callq 0x3360
movq -0x78(%rbp), %rdi
callq 0x31f0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x34b0
jmp 0x11da9
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x78(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0x15528(%rip), %rsi     # 0x272f0
callq 0x3170
movq -0x78(%rbp), %rsi
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
subq %rdx, %rcx
leaq -0x58(%rbp), %rdi
callq 0x3320
jmp 0x11deb
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x33e0
jmp 0x11dfa
leaq -0x58(%rbp), %rdi
callq 0x35f8
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x11db9
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x11e67
jmp 0x11e5e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x3360
jmp 0x11e7d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x11e74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x35f8
jmp 0x11e74
movq -0x68(%rbp), %rdi
callq 0x35f8
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x35f8
movq -0x20(%rbp), %rdi
callq 0x3550
nopw %cs:(%rax,%rax)
// File: MarkCBell[P]twister/./twister/kernel/parsing.cpp
// Function: digit_length(int)
int digit_length(int n)
{
	int c = 0;
	if (n <= 0) c++;
	while (n != 0)
	{
	   n  /= 10;
	   c++;
	}
	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jg 0x1228d
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1228f
cmpl $0x0, -0x4(%rbp)
je 0x122ae
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1228f
movl -0x8(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: MarkCBell[P]twister/./twister/kernel/twister.cpp
// Function: perm::inverse() const
perm perm::inverse() const
{
	perm outp;
	
	for (int i = 0; i < 4; i++)
		outp.image[image[i]] = i;
	
	return outp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x16ea0
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x16ff6
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %edx
movslq -0x14(%rbp), %rsi
movslq (%rcx,%rsi,4), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x16fcf
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: MarkCBell[P]twister/./twister/kernel/twister.cpp
// Function: perm::of(perm const&) const
perm perm::of(const perm &other) const
{
	perm outp;
	
	for (int i=0; i<4; i++)
		outp.image[i] = image[other.image[i]];
	
	return outp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x16ea0
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x17062
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rdx
movslq -0x1c(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movl (%rcx,%rdx,4), %edx
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x17033
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: MarkCBell[P]twister/./twister/kernel/twister.cpp
// Function: manifold::onemore(tetra*)
void manifold::onemore(tetra *newguy)
{
	if (last_tetra == NULL)  // If our manifold contains no tetra to begin with, use newguy to start the list.
	{
		first_tetra = newguy;
		last_tetra = newguy;
	}
	else
	{
		last_tetra->set_next(newguy);
		newguy->set_prev(last_tetra);
		last_tetra = newguy;
	}
	
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x172f4
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x17322
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x212a0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x8(%rax), %rsi
callq 0x212c0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: MarkCBell[P]twister/./twister/kernel/twister.cpp
// Function: tetra::gluesym(tetra*, int, perm const&)
void tetra::gluesym(tetra *whereglue, int whichface, const perm &how)
{
	if ( (gluedto[whichface] != NULL) || (whereglue->gluedto[how[whichface]] != NULL) )
		output_error("Invalid gluing. Possible causes; self-intersecting curves, intersecting 2-handles.");
	
	this->set_gluedto(whichface, whereglue);
	this->set_gluing(whichface,how);
	
	whereglue->set_gluedto(how[whichface], this);
	whereglue->set_gluing(how[whichface], how.inverse());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movslq -0x14(%rbp), %rcx
cmpq $0x0, 0x10(%rax,%rcx,8)
jne 0x173e9
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x16f80
movl %eax, %ecx
movq -0x88(%rbp), %rax
movslq %ecx, %rcx
cmpq $0x0, 0x10(%rax,%rcx,8)
je 0x17462
leaq -0x41(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3560
movq -0x90(%rbp), %rdx
leaq 0x1007b(%rip), %rsi     # 0x27482
leaq -0x40(%rbp), %rdi
callq 0x4e10
jmp 0x17412
leaq -0x40(%rbp), %rdi
callq 0x4d40
jmp 0x1741d
leaq -0x40(%rbp), %rdi
callq 0x35f8
leaq -0x41(%rbp), %rdi
callq 0x3360
jmp 0x17462
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x17454
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x35f8
leaq -0x41(%rbp), %rdi
callq 0x3360
jmp 0x1750d
movq -0x80(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x209e0
movl -0x14(%rbp), %eax
movl %eax, -0xac(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x64(%rbp), %rdi
callq 0x16ee0
movl -0xac(%rbp), %esi
movq -0x80(%rbp), %rdi
leaq -0x64(%rbp), %rdx
callq 0x20a10
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x16f80
movq -0xa8(%rbp), %rdi
movq -0x80(%rbp), %rdx
movl %eax, %esi
callq 0x209e0
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x16f80
movl %eax, -0x94(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x74(%rbp), %rdi
callq 0x16fa0
movq -0xa0(%rbp), %rdi
movl -0x94(%rbp), %esi
leaq -0x74(%rbp), %rdx
callq 0x20a10
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3550
nopw %cs:(%rax,%rax)