LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: yogesh1q2w[P]Dynamic-Graph-Algorithms/MST.cpp
// Function: MST::add_vertex(int)
void MST::add_vertex(int u) {
	vertices.insert(u);
	min_spf.push_back(EulerTourTree());
	adj.push_back(unordered_map<int, multiset<pair<int,int>>>());
	treeadj.push_back(unordered_map<int, multiset<pair<int,int>>>());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
addq $0x38, %rdi
leaq -0xc(%rbp), %rsi
callq 0xa7c0
movq %rax, %rcx
movq -0x1d8(%rbp), %rax
movq %rcx, -0x20(%rbp)
movb %dl, -0x18(%rbp)
addq $0x68, %rax
movq %rax, -0x1d0(%rbp)
leaq -0x138(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
xorl %esi, %esi
movl $0x118, %edx            # imm = 0x118
callq 0x20c0
movq -0x1c8(%rbp), %rdi
callq 0xa840
movq -0x1d0(%rbp), %rdi
movq -0x1c8(%rbp), %rsi
callq 0xa810
jmp 0x132c1
leaq -0x138(%rbp), %rdi
callq 0xa8c0
movq -0x1d8(%rbp), %rax
addq $0xb8, %rax
movq %rax, -0x1e8(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x160(%rbp)
movaps %xmm0, -0x170(%rbp)
movaps %xmm0, -0x180(%rbp)
movq $0x0, -0x150(%rbp)
leaq -0x180(%rbp), %rdi
movq %rdi, -0x1e0(%rbp)
callq 0x149d0
movq -0x1e8(%rbp), %rdi
movq -0x1e0(%rbp), %rsi
callq 0x149a0
jmp 0x1332c
leaq -0x180(%rbp), %rdi
callq 0x149f0
movq -0x1d8(%rbp), %rax
addq $0xd0, %rax
movq %rax, -0x1f8(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x1a0(%rbp)
movaps %xmm0, -0x1b0(%rbp)
movaps %xmm0, -0x1c0(%rbp)
movq $0x0, -0x190(%rbp)
leaq -0x1c0(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
callq 0x149d0
movq -0x1f8(%rbp), %rdi
movq -0x1f0(%rbp), %rsi
callq 0x149a0
jmp 0x13397
leaq -0x1c0(%rbp), %rdi
callq 0x149f0
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
leaq -0x138(%rbp), %rdi
callq 0xa8c0
jmp 0x1340a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x149f0
jmp 0x1340a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x149f0
movq -0x140(%rbp), %rdi
callq 0x2250
nopw %cs:(%rax,%rax)
// File: yogesh1q2w[P]Dynamic-Graph-Algorithms/MST.cpp
// Function: MST::add_edge(int, int, int)
bool MST::add_edge(int u, int v, int wt) {
	if(!vertices.count(u) || !vertices.count(v)) {
        return false;
    }

    adj_list[u].push_back(make_pair(v,wt));
	adj_list[v].push_back(make_pair(u,wt));
    weight[make_pair(u,v)] = wt;
	weight[make_pair(v,u)] = wt;

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x38, %rdi
leaq -0x14(%rbp), %rsi
callq 0xad30
cmpq $0x0, %rax
je 0x13bd7
movq -0x48(%rbp), %rdi
addq $0x38, %rdi
leaq -0x18(%rbp), %rsi
callq 0xad30
cmpq $0x0, %rax
jne 0x13be0
movb $0x0, -0x1(%rbp)
jmp 0x13ca2
movq -0x48(%rbp), %rdi
addq $0x80, %rdi
leaq -0x14(%rbp), %rsi
callq 0x14b50
movq %rax, -0x60(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x3520
movq -0x60(%rbp), %rdi
movq %rax, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x14b80
movq -0x48(%rbp), %rdi
addq $0x80, %rdi
leaq -0x18(%rbp), %rsi
callq 0x14b50
movq %rax, -0x58(%rbp)
leaq -0x14(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x3520
movq -0x58(%rbp), %rdi
movq %rax, -0x2c(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0x14b80
movl -0x1c(%rbp), %eax
movl %eax, -0x50(%rbp)
leaq -0x14(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3520
movq -0x48(%rbp), %rdi
movq %rax, -0x34(%rbp)
leaq -0x34(%rbp), %rsi
callq 0x14aa0
movl -0x50(%rbp), %ecx
movl %ecx, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4c(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x3520
movq -0x48(%rbp), %rdi
movq %rax, -0x3c(%rbp)
leaq -0x3c(%rbp), %rsi
callq 0x14aa0
movl -0x4c(%rbp), %ecx
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: yogesh1q2w[P]Dynamic-Graph-Algorithms/MST.cpp
// Function: MST::find_MST()
set <pair<pair<int,int>,int>> MST::find_MST()  {
	set <pair<pair<int,int>,int>> res;
	treeadj[0].erase(-1);
	for(auto &i:treeadj[0]) {
		for(auto &k:i.second) {
			res.insert(make_pair(make_pair(i.first,k.second),k.first));
		}
	}
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x14c20
movq -0xa8(%rbp), %rdi
addq $0xd0, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x14a10
movq %rax, %rdi
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
leaq -0x18(%rbp), %rsi
callq 0x14c40
jmp 0x140e4
movq -0xa8(%rbp), %rdi
addq $0xd0, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x14a10
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x14c70
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x14ca0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x14cd0
testb $0x1, %al
jne 0x1412f
jmp 0x14265
leaq -0x38(%rbp), %rdi
callq 0x14d00
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x14bd0
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x14d30
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x14d60
testb $0x1, %al
jne 0x14178
jmp 0x14255
leaq -0x58(%rbp), %rdi
callq 0x14c00
movq %rax, -0x68(%rbp)
movq -0x48(%rbp), %rdi
movq -0x68(%rbp), %rsi
addq $0x4, %rsi
callq 0x14e20
movq %rax, -0xc0(%rbp)
jmp 0x1419f
movq -0xc0(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x68(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x14de0
movl %edx, -0xcc(%rbp)
movq %rax, -0xc8(%rbp)
jmp 0x141c6
movq -0xb8(%rbp), %rdi
movl -0xcc(%rbp), %eax
movq -0xc8(%rbp), %rcx
movq %rcx, -0x90(%rbp)
movl %eax, -0x88(%rbp)
movl -0x88(%rbp), %eax
movl %eax, -0x70(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x78(%rbp), %rsi
callq 0x14d90
movb %dl, -0xd9(%rbp)
movq %rax, -0xd8(%rbp)
jmp 0x14213
movb -0xd9(%rbp), %al
movq -0xd8(%rbp), %rcx
movq %rcx, -0xa0(%rbp)
movb %al, -0x98(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x14e50
jmp 0x14162
movq -0xb8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x14eb0
jmp 0x1428b
jmp 0x14257
leaq -0x38(%rbp), %rdi
callq 0x14e80
jmp 0x14119
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x1427b
movq -0xb8(%rbp), %rdi
callq 0x14eb0
movq -0xb0(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2250
nopw %cs:(%rax,%rax)
// File: yogesh1q2w[P]Dynamic-Graph-Algorithms/SPT.cpp
// Function: SPT::add_edge(int, int, int)
bool SPT::add_edge(int u, int v, int wt) {
    if(!vertices.count(u) || !vertices.count(v)) {
        return false;
    }

    adj[u].push_back(v);
    revadj[v].push_back(u);
    weight[make_pair(u,v)] = wt;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x40, %rdi
leaq -0x14(%rbp), %rsi
callq 0xad30
cmpq $0x0, %rax
je 0x1d767
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
leaq -0x18(%rbp), %rsi
callq 0xad30
cmpq $0x0, %rax
jne 0x1d76d
movb $0x0, -0x1(%rbp)
jmp 0x1d7e3
movq -0x30(%rbp), %rdi
addq $0x70, %rdi
leaq -0x14(%rbp), %rsi
callq 0x1fe50
movq %rax, %rdi
leaq -0x18(%rbp), %rsi
callq 0x1feb0
movq -0x30(%rbp), %rdi
addq $0xa8, %rdi
leaq -0x18(%rbp), %rsi
callq 0x1fe50
movq %rax, %rdi
leaq -0x14(%rbp), %rsi
callq 0x1feb0
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, -0x34(%rbp)
addq $0x8, %rax
movq %rax, -0x40(%rbp)
leaq -0x14(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3520
movq -0x40(%rbp), %rdi
movq %rax, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x14aa0
movl -0x34(%rbp), %ecx
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: yogesh1q2w[P]Dynamic-Graph-Algorithms/main.cpp
// Function: main
int main() {
	srand(0);
	int ch = 1;
	string st;
	while(ch != 0) {
		cout << "Enter choice -\n1- Fully dynamic connectivity\n2- Decremental MST\n3- Fully dynamic SPT\nand file name to run on:" << endl;
		cin >> ch >> st;
		test(ch,st);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
xorl %edi, %edi
callq 0x2150
movl $0x1, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x21e0
cmpl $0x0, -0x8(%rbp)
je 0x25c06
movq 0x18469(%rip), %rdi     # 0x3dfd0
leaq 0x2546(%rip), %rsi      # 0x280b4
callq 0x2160
movq %rax, -0x60(%rbp)
jmp 0x25b79
movq -0x60(%rbp), %rdi
movq 0x1843c(%rip), %rsi     # 0x3dfc0
callq 0x2190
jmp 0x25b8b
movq 0x1844e(%rip), %rdi     # 0x3dfe0
leaq -0x8(%rbp), %rsi
callq 0x20f0
movq %rax, -0x68(%rbp)
jmp 0x25ba1
movq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x21c0
jmp 0x25bb0
movl -0x8(%rbp), %eax
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x20a0
jmp 0x25bc5
movl -0x6c(%rbp), %edi
leaq -0x58(%rbp), %rsi
callq 0x24a80
jmp 0x25bd3
leaq -0x58(%rbp), %rdi
callq 0x2100
jmp 0x25b56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x25c1f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2100
jmp 0x25c1f
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2100
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x2100
movq -0x30(%rbp), %rdi
callq 0x2250
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/src/lib/redirect/fileio/test_fileio.c
// Function: test_stat
void test_stat(const char *path)
{
  struct stat s;

  stat(path, &s);

  printf("st_size: %ld\n", (long) s.st_size);

  lstat(path, &s);

  printf("st_size: %ld\n", (long) s.st_size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x1050
movq -0x68(%rbp), %rsi
leaq 0xe7a(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movq -0x8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x1040
movq -0x68(%rbp), %rsi
leaq 0xe58(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: suyash[P]chan/examples/pointers.cc
// Function: consumer(std::weak_ptr<chan::unbuffered_chan<int>>)
void consumer(std::weak_ptr<chan::unbuffered_chan<int>> ch) {
	for (int i = 0 ; ; i++) {
		int x = 0;
		ch.lock()->recv(x);
		printf("r %d\n", x);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x38(%rbp), %rsi
movl $0x0, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x2750
movq -0x40(%rbp), %rdi
callq 0x2780
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0x27f0
jmp 0x2466
leaq -0x20(%rbp), %rdi
callq 0x27d0
movl -0x10(%rbp), %esi
leaq 0x3b91(%rip), %rdi      # 0x600a
movb $0x0, %al
callq 0x2040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2437
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x27d0
movq -0x28(%rbp), %rdi
callq 0x21b0
nopl (%rax)
// File: suyash[P]chan/examples/pointers.cc
// Function: main
int main() {
	auto ch = std::make_shared<chan::unbuffered_chan<int>>();

	std::thread t1(producer, ch);
	std::thread t2(consumer, ch);

	std::this_thread::sleep_for(std::chrono::milliseconds(1));

	t1.detach();
	t2.detach();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x2820
movq -0x48(%rbp), %rdx
leaq -0x140(%rip), %rsi      # 0x2390
leaq -0x18(%rbp), %rdi
callq 0x2890
jmp 0x24db
leaq -0xc2(%rip), %rsi       # 0x2420
leaq -0x30(%rbp), %rdi
leaq -0x10(%rbp), %rdx
callq 0x2890
jmp 0x24f1
movl $0x1, -0x3c(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x2a00
jmp 0x2507
leaq -0x38(%rbp), %rdi
callq 0x2950
jmp 0x2512
leaq -0x18(%rbp), %rdi
callq 0x21a0
jmp 0x251d
leaq -0x30(%rbp), %rdi
callq 0x21a0
jmp 0x2528
leaq -0x30(%rbp), %rdi
callq 0x2a20
leaq -0x18(%rbp), %rdi
callq 0x2a20
leaq -0x10(%rbp), %rdi
callq 0x27d0
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2585
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x257c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2a20
leaq -0x18(%rbp), %rdi
callq 0x2a20
leaq -0x10(%rbp), %rdi
callq 0x27d0
movq -0x20(%rbp), %rdi
callq 0x21b0
nopw (%rax,%rax)
// File: chrissimpkins[P]octopus/src/main.cpp
// Function: create_CL_vector[abi:cxx11](int, char const**)
inline vector<string> create_CL_vector(int argc, char const *argv[]){
	vector<string> vs;
	for (int i = 0; i < argc; ++i){
		vs.push_back(argv[i]);
	}
	return vs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0xdff0
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xb800
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x78(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3510
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0xb580
jmp 0xb79d
movq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xe010
jmp 0xb7ac
leaq -0x40(%rbp), %rdi
callq 0x31b0
leaq -0x41(%rbp), %rdi
callq 0x3350
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xb761
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xb7ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x31b0
leaq -0x41(%rbp), %rdi
callq 0x3350
movq -0x68(%rbp), %rdi
callq 0xdf90
jmp 0xb820
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xb813
movq -0x68(%rbp), %rdi
callq 0xdf90
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3500
nopl (%rax)
// File: chrissimpkins[P]octopus/src/main.cpp
// Function: currentDate[abi:cxx11]()
inline string currentDate() {
	time_t now = time(0);
    struct tm tstruct;
    char buf[80];
    tstruct = *localtime(&now);
    strftime(buf, sizeof(buf), "%Y-%m-%d", &tstruct);
    return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xd0(%rbp)
movq %rdi, %rax
movq %rax, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x32c0
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3210
movq 0x30(%rax), %rcx
movq %rcx, -0x20(%rbp)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movaps %xmm2, -0x30(%rbp)
movaps %xmm1, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
leaq 0x6a03(%rip), %rdx      # 0x1357f
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
movl $0x50, %esi
leaq -0x50(%rbp), %rcx
callq 0x3240
leaq -0xa1(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x3510
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
movq -0xc0(%rbp), %rdx
callq 0xb580
jmp 0xcbc7
leaq -0xa1(%rbp), %rdi
callq 0x3350
movq -0xd8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa1(%rbp), %rdi
callq 0x3350
movq -0xb0(%rbp), %rdi
callq 0x3500
nopl (%rax)
// File: chrissimpkins[P]octopus/src/main.cpp
// Function: replaceChar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char, char)
inline string replaceChar(string str, char ch1, char ch2) {
  for (size_t i = 0; i < str.size(); ++i) {
    if (str[i] == ch1)
      str[i] = ch2;
  }
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movb %cl, %al
movb %dl, %cl
movq %rdi, %rdx
movq %rdx, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %cl, -0x11(%rbp)
movb %al, -0x12(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x31e0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0xcd6e
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3580
movsbl (%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0xcd5e
movq -0x38(%rbp), %rdi
movb -0x12(%rbp), %al
movb %al, -0x41(%rbp)
movq -0x20(%rbp), %rsi
callq 0x3580
movb -0x41(%rbp), %cl
movb %cl, (%rax)
jmp 0xcd60
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xcd11
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x31a0
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: chrissimpkins[P]octopus/src/main.cpp
// Function: isDirPresent(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
inline int isDirPresent(string& dir) {
	const char * pathname = dir.c_str();
	struct stat sb;
	if (stat(pathname, &sb) == 0 && S_ISDIR(sb.st_mode))
	{
		//directory present, return 1
	    return 1;
	}
	else {
		//directory not present, return 0
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3110
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x32b0
cmpl $0x0, %eax
jne 0xdf7c
movl -0x90(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
jne 0xdf7c
movl $0x1, -0x4(%rbp)
jmp 0xdf83
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: chrissimpkins[P]octopus/src/opts.cpp
// Function: Options::get_options[abi:cxx11]()
vector<string> Options::get_options() {
	vector<string> return_opts;
	//start at i = 2 because first two positions represent commands
	for (int i = 2; i < argc; ++i){
		if (!optionvec[i].empty()){
			string oi = optionvec[i];
			if (oi.substr(0,1) == "-" || oi.substr(0,2) == "--"){
				//it is an option, so load it into the vector
				return_opts.push_back(oi);
			}
		}

	}
	return return_opts;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xdff0
movl $0x2, -0x18(%rbp)
movq -0x98(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl (%rcx), %eax
jge 0xf1fd
movq -0x98(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x18(%rbp), %rsi
callq 0xeef0
movq %rax, %rdi
callq 0x34c0
testb $0x1, %al
jne 0xf1ed
movq -0x98(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x18(%rbp), %rsi
callq 0xeef0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x3120
jmp 0xf097
movb $0x0, -0x89(%rbp)
xorl %eax, %eax
movl %eax, %edx
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movl $0x1, %ecx
callq 0x3310
jmp 0xf0b6
leaq 0x3d7a(%rip), %rsi      # 0x12e37
leaq -0x68(%rbp), %rdi
callq 0xb870
movb %al, -0xa9(%rbp)
jmp 0xf0ce
movb -0xa9(%rbp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0xaa(%rbp)
jne 0xf12e
jmp 0xf0e3
xorl %eax, %eax
movl %eax, %edx
leaq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movl $0x2, %ecx
callq 0x3310
jmp 0xf0fe
movb $0x1, -0x89(%rbp)
leaq 0x44e9(%rip), %rsi      # 0x135f5
leaq -0x88(%rbp), %rdi
callq 0xb870
movb %al, -0xab(%rbp)
jmp 0xf120
movb -0xab(%rbp), %al
movb %al, -0xaa(%rbp)
jmp 0xf12e
movb -0xaa(%rbp), %al
movb %al, -0xac(%rbp)
testb $0x1, -0x89(%rbp)
jne 0xf145
jmp 0xf151
leaq -0x88(%rbp), %rdi
callq 0x31b0
leaq -0x68(%rbp), %rdi
callq 0x31b0
movb -0xac(%rbp), %al
testb $0x1, %al
jne 0xf166
jmp 0xf1d7
movq -0xa8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xfae0
jmp 0xf178
jmp 0xf1d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xf223
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xf1e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xf1cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
testb $0x1, -0x89(%rbp)
jne 0xf1be
jmp 0xf1ca
leaq -0x88(%rbp), %rdi
callq 0x31b0
jmp 0xf1cc
leaq -0x68(%rbp), %rdi
callq 0x31b0
jmp 0xf1e2
leaq -0x38(%rbp), %rdi
callq 0x31b0
jmp 0xf1ed
leaq -0x38(%rbp), %rdi
callq 0x31b0
jmp 0xf223
jmp 0xf1ef
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xf03f
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xf213
movq -0xa8(%rbp), %rdi
callq 0xdf90
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0xdf90
movq -0x40(%rbp), %rdi
callq 0x3500
nopl (%rax,%rax)
// File: chrissimpkins[P]octopus/src/opts.cpp
// Function: Options::get_input[abi:cxx11]()
string Options::get_input(){
	string inputflag = "-i";
	string inputfile = "";
	for (auto iter = optionvec.begin(); iter < optionvec.end(); ++iter){
		if (*iter == inputflag){
			inputfile = *(iter + 1);
			return inputfile;
		}
	}
	return inputfile;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3510
movq -0x70(%rbp), %rdx
leaq 0x3410(%rip), %rsi      # 0x12951
leaq -0x30(%rbp), %rdi
callq 0xb580
jmp 0xf54c
leaq -0x31(%rbp), %rdi
callq 0x3350
movb $0x0, -0x45(%rbp)
leaq -0x46(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3510
movq -0x88(%rbp), %rdi
movq -0x90(%rbp), %rdx
leaq 0x38f9(%rip), %rsi      # 0x12e77
callq 0xb580
jmp 0xf585
leaq -0x46(%rbp), %rdi
callq 0x3350
movq -0x78(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xfb50
movq %rax, -0x50(%rbp)
movq -0x78(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xfbc0
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xfb80
testb $0x1, %al
jne 0xf5c6
jmp 0xf675
leaq -0x50(%rbp), %rdi
callq 0xfc80
movq %rax, %rdi
leaq -0x30(%rbp), %rsi
callq 0xfbf0
testb $0x1, %al
jne 0xf5e4
jmp 0xf665
leaq -0x50(%rbp), %rdi
movl $0x1, %esi
callq 0xfca0
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xfc80
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x3030
jmp 0xf610
movb $0x1, -0x45(%rbp)
movl $0x1, -0x64(%rbp)
jmp 0xf680
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x3350
jmp 0xf6b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x46(%rbp), %rdi
callq 0x3350
jmp 0xf6a8
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x31b0
jmp 0xf6a8
jmp 0xf667
leaq -0x50(%rbp), %rdi
callq 0xfce0
jmp 0xf59f
movb $0x1, -0x45(%rbp)
movl $0x1, -0x64(%rbp)
testb $0x1, -0x45(%rbp)
jne 0xf692
movq -0x88(%rbp), %rdi
callq 0x31b0
leaq -0x30(%rbp), %rdi
callq 0x31b0
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x31b0
movq -0x40(%rbp), %rdi
callq 0x3500
nopw (%rax,%rax)
// File: chrissimpkins[P]octopus/src/opts.cpp
// Function: Options::get_output[abi:cxx11]()
string Options::get_output(){
	string outputflag = "-o";
	string outputfile = "";
	for (auto iter = optionvec.begin(); iter < optionvec.end(); ++iter){
		if (*iter == outputflag){
			outputfile = *(iter + 1);
			return outputfile;
		}
	}
	return outputfile;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3510
movq -0x70(%rbp), %rdx
leaq 0x4007(%rip), %rsi      # 0x13708
leaq -0x30(%rbp), %rdi
callq 0xb580
jmp 0xf70c
leaq -0x31(%rbp), %rdi
callq 0x3350
movb $0x0, -0x45(%rbp)
leaq -0x46(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3510
movq -0x88(%rbp), %rdi
movq -0x90(%rbp), %rdx
leaq 0x3739(%rip), %rsi      # 0x12e77
callq 0xb580
jmp 0xf745
leaq -0x46(%rbp), %rdi
callq 0x3350
movq -0x78(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xfb50
movq %rax, -0x50(%rbp)
movq -0x78(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xfbc0
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xfb80
testb $0x1, %al
jne 0xf786
jmp 0xf835
leaq -0x50(%rbp), %rdi
callq 0xfc80
movq %rax, %rdi
leaq -0x30(%rbp), %rsi
callq 0xfbf0
testb $0x1, %al
jne 0xf7a4
jmp 0xf825
leaq -0x50(%rbp), %rdi
movl $0x1, %esi
callq 0xfca0
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xfc80
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x3030
jmp 0xf7d0
movb $0x1, -0x45(%rbp)
movl $0x1, -0x64(%rbp)
jmp 0xf840
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x3350
jmp 0xf871
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x46(%rbp), %rdi
callq 0x3350
jmp 0xf868
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x31b0
jmp 0xf868
jmp 0xf827
leaq -0x50(%rbp), %rdi
callq 0xfce0
jmp 0xf75f
movb $0x1, -0x45(%rbp)
movl $0x1, -0x64(%rbp)
testb $0x1, -0x45(%rbp)
jne 0xf852
movq -0x88(%rbp), %rdi
callq 0x31b0
leaq -0x30(%rbp), %rdi
callq 0x31b0
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x31b0
movq -0x40(%rbp), %rdi
callq 0x3500
nopw (%rax,%rax)
// File: chrissimpkins[P]octopus/src/opts.cpp
// Function: Options::get_last_positional[abi:cxx11]()
string Options::get_last_positional(){
	auto iter_end = optionvec.end();
	//return the last argument on the command line
	string laststring = *(iter_end - 1);
	return laststring;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xfbc0
movq %rax, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0xfd00
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xfc80
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x3120
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xf8ea
movq -0x30(%rbp), %rdi
callq 0x31b0
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chrissimpkins[P]octopus/src/opts.cpp
// Function: Options::fill_arg_vector(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
int Options::fill_arg_vector(vector<string>& fill_vector){
	for (auto iter = optionvec.begin() + 2; iter < optionvec.end(); ++iter){
		char c = (*iter)[0];
		switch(c) {
			// if it is a short option (starts with '-') or long option (starts with '-')
			case '-':
				return 1;  //then break out of the vector fill loop and return because done filling the vector
			default:
				fill_vector.push_back(*iter);  //fill the vector with the string arguments up until the first option
				break;
		}
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x8(%rax), %rdi
callq 0xfb50
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x2, %esi
callq 0xfca0
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xfbc0
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xfb80
testb $0x1, %al
jne 0xf95b
jmp 0xf9b1
leaq -0x20(%rbp), %rdi
callq 0xfc80
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3370
movb (%rax), %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
subb $0x2d, %al
jne 0xf987
jmp 0xf97e
movl $0x1, -0x4(%rbp)
jmp 0xf9b8
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xfc80
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xfae0
jmp 0xf9a6
leaq -0x20(%rbp), %rdi
callq 0xfce0
jmp 0xf937
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chrissimpkins[P]octopus/src/opts.cpp
// Function: Options::contains(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Options::contains(string optionflag){
	vector<string> optv = get_options();
	int i = 0;
	//check the options vector and determine whether it contains the requested optionflag
	for (auto s : optv){
		if (s == optionflag){
			i = 1;
		}
	}
	if (i){
		return true;
	}
	else{
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xf000
movl $0x0, -0x34(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0xe4e0
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0xe320
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xfd40
testb $0x1, %al
jne 0xfa33
jmp 0xfa94
leaq -0x48(%rbp), %rdi
callq 0xea90
movq %rax, %rsi
leaq -0x70(%rbp), %rdi
callq 0x3120
jmp 0xfa4a
movq -0x88(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0xfbf0
testb $0x1, %al
jne 0xfa60
jmp 0xfa80
movl $0x1, -0x34(%rbp)
jmp 0xfa80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xdf90
jmp 0xfac9
leaq -0x70(%rbp), %rdi
callq 0x31b0
leaq -0x48(%rbp), %rdi
callq 0xfd80
jmp 0xfa20
cmpl $0x0, -0x34(%rbp)
je 0xfaa7
movb $0x1, -0x1(%rbp)
movl $0x1, -0x80(%rbp)
jmp 0xfab2
movb $0x0, -0x1(%rbp)
movl $0x1, -0x80(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xdf90
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x3500
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: chrissimpkins[P]octopus/src/io.cpp
// Function: IO::get_string(std::basic_ifstream<char, std::char_traits<char>>&)
void IO::get_string(ifstream& inputstream){
	while (inputstream.good()) {
		//load the input stream from the file into a string stream
		int next = inputstream.get();
		if (next == EOF){
			break;
		}
		//implicit conversion of the int char to a string
		inputstring += next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x34d0
testb $0x1, %al
jne 0x10b5e
jmp 0x10b87
movq -0x10(%rbp), %rdi
callq 0x33a0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x10b72
jmp 0x10b87
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
addq $0x60, %rdi
movsbl %al, %esi
callq 0x31c0
jmp 0x10b48
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: chrissimpkins[P]octopus/src/io.cpp
// Function: IO::get_first_line[abi:cxx11]()
string& IO::get_first_line(){
	ifstream in;
	ifstream& inr = in;
	ifstream& rinr = (get_input_stream(inr));
	get_lines(THE_BEGINNING , 1 , rinr);
	string& isr = inputstring;
	return isr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x248(%rbp)
leaq -0x210(%rbp), %rdi
movq %rdi, -0x250(%rbp)
callq 0x3390
movq -0x250(%rbp), %rax
movq -0x248(%rbp), %rdi
movq %rax, -0x218(%rbp)
movq -0x218(%rbp), %rsi
callq 0x10c80
movq %rax, -0x240(%rbp)
jmp 0x10be7
movq -0x248(%rbp), %rdi
movq -0x240(%rbp), %rax
movq %rax, -0x220(%rbp)
movq -0x220(%rbp), %rcx
xorl %esi, %esi
movl $0x1, %edx
callq 0x10f30
jmp 0x10c11
movq -0x248(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x238(%rbp)
movq -0x238(%rbp), %rax
movq %rax, -0x258(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x3090
movq -0x258(%rbp), %rax
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x3090
movq -0x228(%rbp), %rdi
callq 0x3500
nopw (%rax,%rax)
// File: chrissimpkins[P]octopus/src/io.cpp
// Function: IO::get_first_n_lines[abi:cxx11](int&)
string& IO::get_first_n_lines(int& n) {
	ifstream in;
	ifstream& inr = in;
	ifstream& rinr = (get_input_stream(inr));
	get_lines(THE_BEGINNING, n , rinr);
	string& isr = inputstring;
	return isr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x250(%rbp)
leaq -0x218(%rbp), %rdi
movq %rdi, -0x258(%rbp)
callq 0x3390
movq -0x258(%rbp), %rax
movq -0x250(%rbp), %rdi
movq %rax, -0x220(%rbp)
movq -0x220(%rbp), %rsi
callq 0x10c80
movq %rax, -0x248(%rbp)
jmp 0x111ab
movq -0x250(%rbp), %rdi
movq -0x248(%rbp), %rax
movq %rax, -0x228(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edx
movq -0x228(%rbp), %rcx
xorl %esi, %esi
callq 0x10f30
jmp 0x111d6
movq -0x250(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x240(%rbp)
movq -0x240(%rbp), %rax
movq %rax, -0x260(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x3090
movq -0x260(%rbp), %rax
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x3090
movq -0x230(%rbp), %rdi
callq 0x3500
nopl (%rax)
// File: vygr[P]C-Chess/chess.cpp
// Function: display_board(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
auto display_board(const board &brd)
{
	cls();
	std::cout << "\n  a   b   c   d   e   f   g   h\n";
	std::cout << "┏━━━┳━━━┳━━━┳━━━┳━━━┳━━━┳━━━┳━━━┓\n";
	for (auto row = 0; row < 8; ++row)
 	{
		for (auto col = 0; col < 8; ++col)
		{
			std::cout << "┃" << " " << unicode_pieces[brd[row*8+col]] << " ";
		}
		std::cout << "┃" << 8-row << "\n";
		if (row != 7)
		{
			std::cout << "┣━━━╋━━━╋━━━╋━━━╋━━━╋━━━╋━━━╋━━━┫\n";
		}
	}
	std::cout << "┗━━━┻━━━┻━━━┻━━━┻━━━┻━━━┻━━━┻━━━┛\n";
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
callq 0x44c0
movq 0x21adb(%rip), %rdi     # 0x25fd0
leaq 0x165f9(%rip), %rsi     # 0x1aaf5
callq 0x2210
movq 0x21ac8(%rip), %rdi     # 0x25fd0
leaq 0x16608(%rip), %rsi     # 0x1ab17
callq 0x2210
movl $0x0, 0xc(%rsp)
cmpl $0x8, 0xc(%rsp)
jge 0x460a
movl $0x0, 0x8(%rsp)
cmpl $0x8, 0x8(%rsp)
jge 0x45ab
movq 0x21a93(%rip), %rdi     # 0x25fd0
leaq 0x16638(%rip), %rsi     # 0x1ab7c
callq 0x2210
movq %rax, %rdi
leaq 0x1675e(%rip), %rsi     # 0x1acb1
callq 0x2210
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
shll $0x3, %eax
addl 0x8(%rsp), %eax
movslq %eax, %rsi
callq 0x2270
movq %rax, %rsi
leaq 0x21cc2(%rip), %rdi     # 0x26240
callq 0x9be0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x21e0
movq %rax, %rdi
leaq 0x16718(%rip), %rsi     # 0x1acb1
callq 0x2210
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x452f
movq 0x21a1e(%rip), %rdi     # 0x25fd0
leaq 0x165c3(%rip), %rsi     # 0x1ab7c
callq 0x2210
movq %rax, %rdi
movl $0x8, %esi
subl 0xc(%rsp), %esi
callq 0x2370
movq %rax, %rdi
leaq 0x1671c(%rip), %rsi     # 0x1acf5
callq 0x2210
cmpl $0x7, 0xc(%rsp)
je 0x45f8
movq 0x219e4(%rip), %rdi     # 0x25fd0
leaq 0x1658d(%rip), %rsi     # 0x1ab80
callq 0x2210
jmp 0x45fa
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x451c
movq 0x219bf(%rip), %rdi     # 0x25fd0
leaq 0x165cd(%rip), %rsi     # 0x1abe5
callq 0x2210
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: vygr[P]C-Chess/chess.cpp
// Function: piece_scans(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int, std::vector<vector, std::allocator<vector>> const&)
auto piece_scans(const board &brd, unsigned int index, const vectors &vectors)
{
	auto yield = std::string{}; yield.reserve(8);
	auto cx = int(index % 8);
	auto cy = int(index / 8);
	for (auto &vector : vectors)
 	{
		auto dx = vector.dx;
		auto dy = vector.dy;
		auto length = vector.length;
		auto x = cx;
		auto y = cy;
		for (;length > 0; --length)
		{
			x += dx;
			y += dy;
			if ((0 <= x) && (x < 8) && (0 <= y) && (y < 8))
			{
				//still on the board
				auto piece = brd[y*8+x];
				if (piece != ' ')
				{
					//not empty square so yield piece
					yield.push_back(piece);
					break;
				}
			}
		}
	}
	return yield;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movl %edx, 0x74(%rsp)
movq %rcx, 0x68(%rsp)
movb $0x0, 0x67(%rsp)
callq 0x22f0
movq 0x8(%rsp), %rdi
movl $0x8, %esi
callq 0x2330
jmp 0x4674
movl 0x74(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x50(%rsp)
movl 0x74(%rsp), %eax
shrl $0x3, %eax
movl %eax, 0x4c(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x9cd0
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x9d00
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x9d30
testb $0x1, %al
jne 0x46ca
jmp 0x47c7
leaq 0x38(%rsp), %rdi
callq 0x9d70
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x1c(%rsp)
movl 0x50(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x1c(%rsp)
jle 0x47b6
movl 0x24(%rsp), %eax
addl 0x18(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x20(%rsp), %eax
addl 0x14(%rsp), %eax
movl %eax, 0x14(%rsp)
xorl %eax, %eax
cmpl 0x18(%rsp), %eax
jg 0x47a4
cmpl $0x8, 0x18(%rsp)
jge 0x47a4
xorl %eax, %eax
cmpl 0x14(%rsp), %eax
jg 0x47a4
cmpl $0x8, 0x14(%rsp)
jge 0x47a4
movq 0x78(%rsp), %rdi
movl 0x14(%rsp), %eax
shll $0x3, %eax
addl 0x18(%rsp), %eax
movslq %eax, %rsi
callq 0x2270
movb (%rax), %al
movb %al, 0x13(%rsp)
movsbl 0x13(%rsp), %eax
cmpl $0x20, %eax
je 0x47a2
movq 0x8(%rsp), %rdi
movsbl 0x13(%rsp), %esi
callq 0x21b0
jmp 0x4786
jmp 0x47b6
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
callq 0x2140
jmp 0x47e9
jmp 0x47a4
jmp 0x47a6
movl 0x1c(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x470c
jmp 0x47b8
leaq 0x38(%rsp), %rdi
callq 0x9d80
jmp 0x46b2
movb $0x1, 0x67(%rsp)
testb $0x1, 0x67(%rsp)
jne 0x47dd
movq 0x8(%rsp), %rdi
callq 0x2140
movq (%rsp), %rax
addq $0x88, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x2380
nopw %cs:(%rax,%rax)
// File: vygr[P]C-Chess/chess.cpp
// Function: in_check(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, unsigned long&)
auto in_check(const board &brd, int colour, std::size_t &king_index)
{
	auto king_piece = 'K';
	auto tests = white_tests;
	if (colour == black)
 	{
		//testing black king in check rather than white
		king_piece = 'k';
		tests = black_tests;
	}
	//find king index on board
	if (brd[king_index] != king_piece)
 	{
		king_index = brd.find(king_piece);
	}
	for (auto &test : tests)
 	{
		if (test.pieces.find_first_of(piece_scans(brd, static_cast<unsigned int>(king_index), *test.vectors))
			!= std::string::npos) return true;
	}
	//not in check
	return false;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movl %esi, 0x94(%rsp)
movq %rdx, 0x88(%rsp)
movb $0x4b, 0x87(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x21bbe(%rip), %rsi     # 0x263f0
callq 0x9da0
cmpl $-0x1, 0x94(%rsp)
jne 0x487b
movb $0x6b, 0x87(%rsp)
leaq 0x21bb8(%rip), %rsi     # 0x26408
leaq 0x68(%rsp), %rdi
callq 0x9ea0
jmp 0x485c
jmp 0x487b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x98d0
jmp 0x49bd
movq 0x98(%rsp), %rdi
movq 0x88(%rsp), %rax
movq (%rax), %rsi
callq 0x2270
movsbl (%rax), %eax
movsbl 0x87(%rsp), %ecx
cmpl %ecx, %eax
je 0x48c9
movq 0x98(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movsbl 0x87(%rsp), %esi
callq 0x22b0
movq %rax, %rcx
movq 0x88(%rsp), %rax
movq %rcx, (%rax)
leaq 0x68(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0xa160
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0xa190
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xa1c0
testb $0x1, %al
jne 0x4909
jmp 0x4992
leaq 0x48(%rsp), %rdi
callq 0xa200
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x98(%rsp), %rsi
movq 0x88(%rsp), %rcx
movl (%rcx), %edx
movq 0x20(%rax), %rcx
leaq 0x18(%rsp), %rdi
callq 0x4630
jmp 0x4944
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x21f0
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
callq 0x2140
movq (%rsp), %rax
cmpq $-0x1, %rax
je 0x4981
movb $0x1, 0xa7(%rsp)
movl $0x1, 0x14(%rsp)
jmp 0x49a2
jmp 0x4983
leaq 0x48(%rsp), %rdi
callq 0xa210
jmp 0x48f1
movb $0x0, 0xa7(%rsp)
movl $0x1, 0x14(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x98d0
movb 0xa7(%rsp), %al
andb $0x1, %al
addq $0xa8, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x2380
nopw (%rax,%rax)
// File: vygr[P]C-Chess/chess.cpp
// Function: evaluate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
auto evaluate(const board &brd, int colour)
{
	auto black_score = 0;
	auto white_score = 0;
	auto len = int(brd.length());
	for (auto index = 0; index < len; ++index)
	{
		//add score for position on the board, near center, clear lines etc
		auto piece = brd[index];
		if (piece == ' ') continue;
		if (piece > 'Z')
		{
			black_score += (*piece_positions[piece])[63-index];
		}
		else
		{
			white_score += (*piece_positions[piece])[index];
		}
		//add score for piece type, queen, rook etc
		auto values = piece_values[piece];
		black_score += values.first;
		white_score += values.second;
	}
	return (white_score - black_score) * colour;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2310
movl %eax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x4ad7
movq 0x20(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0x2270
movb (%rax), %al
movb %al, 0xb(%rsp)
movsbl 0xb(%rsp), %eax
cmpl $0x20, %eax
jne 0x4a35
jmp 0x4ac7
movsbl 0xb(%rsp), %eax
cmpl $0x5a, %eax
jle 0x4a70
leaq 0x21a0a(%rip), %rdi     # 0x26450
leaq 0xb(%rsp), %rsi
callq 0xa230
movq (%rax), %rdi
movl $0x3f, %eax
subl 0xc(%rsp), %eax
movslq %eax, %rsi
callq 0xa320
movl (%rax), %eax
addl 0x18(%rsp), %eax
movl %eax, 0x18(%rsp)
jmp 0x4a98
leaq 0x219d9(%rip), %rdi     # 0x26450
leaq 0xb(%rsp), %rsi
callq 0xa230
movq (%rax), %rdi
movslq 0xc(%rsp), %rsi
callq 0xa320
movl (%rax), %eax
addl 0x14(%rsp), %eax
movl %eax, 0x14(%rsp)
leaq 0x21981(%rip), %rdi     # 0x26420
leaq 0xb(%rsp), %rsi
callq 0xa350
movq (%rax), %rax
movq %rax, (%rsp)
movl (%rsp), %eax
addl 0x18(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x4(%rsp), %eax
addl 0x14(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x4a03
movl 0x14(%rsp), %eax
subl 0x18(%rsp), %eax
imull 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: vygr[P]C-Chess/chess.cpp
// Function: all_moves(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
auto all_moves(const board &brd, int colour)
{
	//enumarate the board square by square
	auto yield = score_boards{}; yield.reserve(max_chess_moves);
	std::size_t king_index = 0;
	auto is_black = (colour == black);
	auto len = int(brd.length());
	for (auto index = 0; index < len; ++index)
	{
		auto piece = brd[index];
		if (piece == ' ') continue;
		if (piece > 'Z' != is_black) continue;
		//one of our pieces ! so gather all boards from possible moves of this piece
		piece_moves(yield, brd, index, colour, (*moves_map[piece]), king_index);
	}
	return yield;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movl %edx, 0x74(%rsp)
movb $0x0, 0x73(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0xa6c0
movq 0x20(%rsp), %rdi
movl $0x6d, %esi
callq 0xa6d0
jmp 0x527e
movq $0x0, 0x58(%rsp)
cmpl $-0x1, 0x74(%rsp)
sete %al
andb $0x1, %al
movb %al, 0x57(%rsp)
movq 0x78(%rsp), %rdi
callq 0x2310
movl %eax, 0x50(%rsp)
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
cmpl 0x50(%rsp), %eax
jge 0x53a3
movq 0x78(%rsp), %rdi
movslq 0x4c(%rsp), %rsi
callq 0x2270
movb (%rax), %al
movb %al, 0x4b(%rsp)
movsbl 0x4b(%rsp), %eax
cmpl $0x20, %eax
jne 0x52f0
jmp 0x5379
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x53c6
movsbl 0x4b(%rsp), %eax
cmpl $0x5a, %eax
setg %al
andb $0x1, %al
movzbl %al, %eax
movb 0x57(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x5310
jmp 0x5379
movq 0x78(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x20e0
jmp 0x5321
movl 0x4c(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x74(%rsp), %eax
movl %eax, 0xc(%rsp)
leaq 0x20fe0(%rip), %rdi     # 0x26318
leaq 0x4b(%rsp), %rsi
callq 0xa7e0
movq %rax, 0x10(%rsp)
jmp 0x5349
movl 0xc(%rsp), %ecx
movl 0x8(%rsp), %edx
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %r8
leaq 0x28(%rsp), %rsi
leaq 0x58(%rsp), %r9
callq 0x4af0
jmp 0x536f
leaq 0x28(%rsp), %rdi
callq 0x2140
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x52ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x2140
jmp 0x53c6
movb $0x1, 0x73(%rsp)
testb $0x1, 0x73(%rsp)
jne 0x53b9
movq 0x20(%rsp), %rdi
callq 0xa8d0
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xa8d0
movq 0x68(%rsp), %rdi
callq 0x2380
nopw (%rax,%rax)
// File: sagarvare[P]reinforcement-learning-rock-paper-scissor/helper.cpp
// Function: parse_CSV(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<string> parse_CSV(string str1) {
	stringstream ss(str1);
	vector<string> result;

    string i;
	while( ss.good() )
	{
		string substr;
		getline( ss, substr, ',' );
		result.push_back( substr );
	}
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rsi, -0x200(%rbp)
movq %rdi, -0x1f8(%rbp)
movq %rdi, %rax
movq %rax, -0x208(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0xa6d0
movq -0x200(%rbp), %rsi
movl %eax, %edx
leaq -0x198(%rbp), %rdi
callq 0x3350
movq -0x1f8(%rbp), %rdi
movb $0x0, -0x199(%rbp)
callq 0x4e70
leaq -0x1c0(%rbp), %rdi
callq 0x32f0
movq -0x198(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x198(%rbp,%rax), %rdi
callq 0x33b0
movb %al, -0x209(%rbp)
jmp 0x9cce
movb -0x209(%rbp), %al
testb $0x1, %al
jne 0x9cdd
jmp 0x9d61
leaq -0x1f0(%rbp), %rdi
movq %rdi, -0x218(%rbp)
callq 0x32f0
movq -0x218(%rbp), %rsi
leaq -0x198(%rbp), %rdi
movl $0x2c, %edx
callq 0x3420
jmp 0x9d0a
movq -0x1f8(%rbp), %rdi
leaq -0x1f0(%rbp), %rsi
callq 0xa6f0
jmp 0x9d1f
leaq -0x1f0(%rbp), %rdi
callq 0x3120
jmp 0x9cae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
jmp 0x9d7f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0x3120
jmp 0x9d7f
movb $0x1, -0x199(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x3120
testb $0x1, -0x199(%rbp)
jne 0x9db1
jmp 0x9da5
leaq -0x1c0(%rbp), %rdi
callq 0x3120
movq -0x1f8(%rbp), %rdi
callq 0x4ec0
leaq -0x198(%rbp), %rdi
callq 0x3180
jmp 0x9dcd
movq -0x1f8(%rbp), %rdi
callq 0x4ec0
leaq -0x198(%rbp), %rdi
callq 0x3180
movq -0x208(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq -0x1c8(%rbp), %rdi
callq 0x33f0
nopl (%rax)
// File: sagarvare[P]reinforcement-learning-rock-paper-scissor/helper.cpp
// Function: ternary_to_decimal(std::vector<int, std::allocator<int>>)
int ternary_to_decimal(vector<int> input ){
	/*
	Takes in a vector of 1,0,-1 i.e. a ternary encoding
	And returns the decimal value

	Currently theres mistake here
	*/

	int out = 0;
	while(!input.empty()){
		int temp = input.back();
		input.pop_back();
		out = out + temp*pow(3,(input.size()));
	}
	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa760
xorb $-0x1, %al
testb $0x1, %al
jne 0x9e08
jmp 0x9e67
movq -0x18(%rbp), %rdi
callq 0xa7a0
movq -0x18(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x10(%rbp)
callq 0xa7e0
movq -0x18(%rbp), %rdi
cvtsi2sdl -0xc(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
cvtsi2sdl -0x10(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0xa860
movq %rax, %rsi
movl $0x3, %edi
callq 0xa810
movsd -0x28(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x20(%rbp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0xc(%rbp)
jmp 0x9df7
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq