LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: dsharlet[P]array/include/array/z_order.h
// Function: void nda::internal::for_each_in_z_order_impl<nda::internal::split_result<3l>, nda::internal::split_result<-9l>, void nda::for_all_in_z_order<nda::test_split_z_order_2d_body()::$_0, nda::internal::split_result<3l>, nda::internal::split_result<-9l>>(std::tuple<nda::internal::split_result<3l>, nda::internal::split_result<-9l>> const&, nda::test_split_z_order_2d_body()::$_0 const&)::'lambda'(nda::test_split_z_order_2d_body()::$_0 const&), 0ul, 1ul>(std::tuple<nda::internal::split_result<3l>, nda::internal::split_result<-9l>> const&, void nda::for_all_in_z_order<nda::test_split_z_order_2d_body()::$_0, nda::internal::split_result<3l>, nda::internal::split_result<-9l>>(std::tuple<nda::internal::split_result<3l>, nda::internal::split_result<-9l>> const&, nda::test_split_z_order_2d_body()::$_0 const&)::'lambda'(nda::test_split_z_order_2d_body()::$_0 const&) const&, std::integer_sequence<unsigned long, 0ul, 1ul>)
NDARRAY_UNIQUE void for_each_in_z_order_impl(
    const std::tuple<Ranges...>& ranges, const Fn& fn, index_sequence<Is...>) {
  constexpr size_t Rank = sizeof...(Is);
  std::array<index_t, Rank> extents = {
      {(std::end(std::get<Is>(ranges)) - std::begin(std::get<Is>(ranges)))...}};
  for_each_index_in_z_order(extents, [&](const std::array<index_t, Rank>& i) {
    fn(std::make_tuple(*(std::begin(std::get<Is>(ranges)) + std::get<Is>(i))...));
  });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x2, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d86b0
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x1d8680
movq -0x10(%rbp), %rdi
callq 0x1d86b0
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
callq 0x1d86d0
leaq -0x48(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1d0e00
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d8730
movq %rax, %rsi
leaq -0x78(%rbp), %rdi
callq 0x1d8700
movq -0x10(%rbp), %rdi
callq 0x1d8730
movq %rax, %rsi
leaq -0x90(%rbp), %rdi
callq 0x1d8750
leaq -0x78(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x1d0630
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x1d6400
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dsharlet[P]array/include/array/z_order.h
// Function: nda::internal::next_power_of_two(long)
inline index_t next_power_of_two(index_t x) { 
  index_t result = 1;
  while (result < x) {
    result <<= 1;
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x1, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
jge 0x1d7b07
movq -0x10(%rbp), %rax
shlq %rax
movq %rax, -0x10(%rbp)
jmp 0x1d7af0
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: tewalds[P]morat/havannah/board.h
// Function: Morat::Havannah::Board::size(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool size(std::string s) {
		if (!valid_size(s))
			return false;
		size_r_ = from_str<int>(s);
		size_r_m1_ = size_r_ - 1;
		size_ = size_r_ * 2 - 1;
		neighbor_list_ = gen_neighbor_list();
		num_cells_ = vec_size() - size_r_ * size_r_m1_;
		cells_.resize(vec_size());
		clear();
		return true;
	}

// Assembly:
subq $0x48, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, %rax
movq 0x8(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq %rax, 0x38(%rsp)
movq %rdi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x10220
testb $0x1, %al
jne 0xffed
movb $0x0, 0x47(%rsp)
jmp 0x10089
movq 0x10(%rsp), %rdi
callq 0x10260
movq 0x18(%rsp), %rsi
movb %al, 0x1(%rsi)
movsbl 0x1(%rsi), %eax
subl $0x1, %eax
movb %al, 0x2(%rsi)
movsbl 0x1(%rsi), %eax
shll %eax
subl $0x1, %eax
movb %al, (%rsi)
leaq 0x20(%rsp), %rdi
callq 0x38390
movq 0x18(%rsp), %rdi
addq $0x88, %rdi
leaq 0x20(%rsp), %rsi
callq 0x102e0
leaq 0x20(%rsp), %rdi
callq 0x100a0
movq 0x18(%rsp), %rdi
callq 0x10310
movq 0x18(%rsp), %rdi
movsbl 0x1(%rdi), %ecx
movsbl 0x2(%rdi), %edx
imull %edx, %ecx
subl %ecx, %eax
movw %ax, 0x4(%rdi)
movq %rdi, %rax
addq $0x10, %rax
movq %rax, (%rsp)
callq 0x10310
movq (%rsp), %rdi
movslq %eax, %rsi
callq 0x10330
movq 0x18(%rsp), %rdi
callq 0x103d0
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: tewalds[P]morat/havannah/board.h
// Function: Morat::Havannah::Board::clear()
void clear() {
		last_move_ = M_NONE;
		num_moves_ = 0;
		to_play_ = Side::P1;
		outcome_ = Outcome::UNKNOWN;
		win_type_ = -1;
		check_rings = true;
		perm_rings = 0;
		hash.clear();

		for(int y = 0; y < size_; y++){
			for(int x = 0; x < size_; x++){
				MoveValid pos = move_valid(x, y);
				Side s = (on_board(x, y) ? Side::NONE : Side::UNDEF);
				cells_[pos.xy] = Cell(s, pos.xy, 1, (1 << iscorner(x, y)), (1 << isedge(x, y)), init_pattern(pos));
			}
		}
	}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x5e(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0xff20
movq 0x28(%rsp), %rdi
movw 0x5e(%rsp), %ax
movw %ax, 0x8(%rdi)
movw $0x0, 0x6(%rdi)
leaq 0x5f0cf(%rip), %rax     # 0x6f4dc
movb (%rax), %al
movb %al, 0xa(%rdi)
leaq 0x5f0c7(%rip), %rax     # 0x6f4e0
movb (%rax), %al
movb %al, 0xb(%rdi)
movb $-0x1, 0xc(%rdi)
movb $0x1, 0x98(%rdi)
movl $0x0, 0x9c(%rdi)
addq $0x28, %rdi
callq 0x101a0
movl $0x0, 0x58(%rsp)
movq 0x28(%rsp), %rcx
movl 0x58(%rsp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x10594
movl $0x0, 0x54(%rsp)
movq 0x28(%rsp), %rcx
movl 0x54(%rsp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x10582
movq 0x28(%rsp), %rdi
movl 0x54(%rsp), %esi
movl 0x58(%rsp), %edx
callq 0x113f0
movq 0x28(%rsp), %rdi
movl %eax, 0x50(%rsp)
movl 0x54(%rsp), %esi
movl 0x58(%rsp), %edx
callq 0x11440
testb $0x1, %al
jne 0x104a2
jmp 0x104b0
leaq 0x5f032(%rip), %rax     # 0x6f4db
movq %rax, 0x20(%rsp)
jmp 0x104be
leaq 0x5f023(%rip), %rax     # 0x6f4da
movq %rax, 0x20(%rsp)
jmp 0x104be
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movb (%rax), %al
movb %al, 0x4f(%rsp)
movb 0x4f(%rsp), %al
movb %al, 0x37(%rsp)
movswl 0x52(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x54(%rsp), %esi
movl 0x58(%rsp), %edx
callq 0x38620
movq 0x28(%rsp), %rdi
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, 0x18(%rsp)
movl 0x54(%rsp), %esi
movl 0x58(%rsp), %edx
callq 0x38730
movq 0x28(%rsp), %rdi
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, 0x1c(%rsp)
leaq 0x50(%rsp), %rsi
callq 0x114f0
movl 0x14(%rsp), %edx
movl 0x18(%rsp), %r8d
movl 0x1c(%rsp), %r9d
leaq 0x38(%rsp), %rdi
movl $0x1, %ecx
movzbl 0x37(%rsp), %esi
movq %rax, (%rsp)
callq 0x115d0
movq 0x28(%rsp), %rdi
addq $0x10, %rdi
movswq 0x52(%rsp), %rsi
callq 0x11630
movq 0x38(%rsp), %rcx
movq %rcx, (%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x10460
jmp 0x10584
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x10444
addq $0x68, %rsp
retq
nopl (%rax)
// File: tewalds[P]morat/havannah/board.h
// Function: Morat::Havannah::Board::encirclable(Morat::Move, Morat::Side) const
bool encirclable(const Move pos, Side player) const {
		Side otherplayer = ~player;
		int posxy = xy(pos);

		const Cell * g = & cells_[find_group(posxy)];
		if(g->piece == otherplayer && (g->edge || g->corner))
			return false;

		for (auto m : neighbors_small(posxy)) {
			if(!m.on_board())
				return false;

			const Cell * g = cell(find_group(m.xy));
			if(g->piece == otherplayer && (g->edge || g->corner))
				return false;
		}
		return true;
	}

// Assembly:
subq $0x68, %rsp
movb %dl, %al
movw %si, %cx
movw %cx, 0x65(%rsp)
movb %al, 0x64(%rsp)
movq %rdi, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
movb 0x64(%rsp), %al
movb %al, 0x56(%rsp)
movzbl 0x56(%rsp), %edi
callq 0x1c850
movq (%rsp), %rdi
movb %al, 0x57(%rsp)
leaq 0x65(%rsp), %rsi
callq 0x116d0
movq (%rsp), %rdi
movl %eax, 0x50(%rsp)
movq %rdi, %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
movl 0x50(%rsp), %esi
callq 0x20080
movq 0x8(%rsp), %rdi
movslq %eax, %rsi
callq 0x20300
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x57(%rsp), %rsi
callq 0x1fe90
testb $0x1, %al
jne 0x2b4b8
jmp 0x2b4d8
movq 0x48(%rsp), %rax
cmpb $0x0, 0x5(%rax)
jne 0x2b4ce
movq 0x48(%rsp), %rax
cmpb $0x0, 0x4(%rax)
je 0x2b4d8
movb $0x0, 0x67(%rsp)
jmp 0x2b5b1
movq (%rsp), %rdi
movl 0x50(%rsp), %esi
callq 0x202c0
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x11810
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
callq 0x11820
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0x2b5ac
movq 0x28(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
leaq 0x1c(%rsp), %rdi
callq 0x11830
testb $0x1, %al
jne 0x2b547
movb $0x0, 0x67(%rsp)
jmp 0x2b5b1
movq (%rsp), %rdi
movswl 0x1e(%rsp), %esi
callq 0x20080
movq (%rsp), %rdi
movl %eax, %esi
callq 0x2b680
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x57(%rsp), %rsi
callq 0x1fe90
testb $0x1, %al
jne 0x2b57a
jmp 0x2b597
movq 0x10(%rsp), %rax
cmpb $0x0, 0x5(%rax)
jne 0x2b590
movq 0x10(%rsp), %rax
cmpb $0x0, 0x4(%rax)
je 0x2b597
movb $0x0, 0x67(%rsp)
jmp 0x2b5b1
jmp 0x2b599
movq 0x28(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x28(%rsp)
jmp 0x2b517
movb $0x1, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopl (%rax)
// File: tewalds[P]morat/havannah/lbdist.h
// Function: Morat::Havannah::LBDists::_get(int, Morat::Side)
int _get(int pos, Side player) {
		int list[6];
		for(int i = 0; i < 6; i++)
			list[i] = dist(i, player, pos);
		partialsort(list, 2);
		int corners = list[0] + list[1] - 1;

		for(int i = 6; i < 12; i++)
			list[i-6] = dist(i, player, pos);
		partialsort(list, 3);
		int edges = list[0] + list[1] + list[2] - 2;

		return std::min(corners, edges);
	}

// Assembly:
subq $0x58, %rsp
movb %dl, %al
movb %al, 0x57(%rsp)
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0x1c(%rsp)
cmpl $0x6, 0x1c(%rsp)
jge 0x2b721
movq (%rsp), %rdi
movl 0x1c(%rsp), %esi
movb 0x57(%rsp), %al
movb %al, 0x1b(%rsp)
movl 0x44(%rsp), %ecx
movzbl 0x1b(%rsp), %edx
callq 0x2b7d0
movl (%rax), %ecx
movslq 0x1c(%rsp), %rax
movl %ecx, 0x20(%rsp,%rax,4)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2b6e4
movq (%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0x2, %edx
callq 0x2b840
movl 0x20(%rsp), %eax
addl 0x24(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x14(%rsp)
movl $0x6, 0x10(%rsp)
cmpl $0xc, 0x10(%rsp)
jge 0x2b78c
movq (%rsp), %rdi
movl 0x10(%rsp), %esi
movb 0x57(%rsp), %al
movb %al, 0xf(%rsp)
movl 0x44(%rsp), %ecx
movzbl 0xf(%rsp), %edx
callq 0x2b7d0
movl (%rax), %ecx
movl 0x10(%rsp), %eax
subl $0x6, %eax
cltq
movl %ecx, 0x20(%rsp,%rax,4)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x2b74b
movq (%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0x3, %edx
callq 0x2b840
movl 0x20(%rsp), %eax
addl 0x24(%rsp), %eax
addl 0x28(%rsp), %eax
subl $0x2, %eax
movl %eax, 0x8(%rsp)
leaq 0x14(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2b910
movl (%rax), %eax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: tewalds[P]morat/havannah/../lib/lbdist.h
// Function: Morat::LBDistsBase<Morat::Havannah::LBDists, Morat::Havannah::Board>::partialsort(int*, int)
void partialsort(int * list, int max){
	//partially sort the list with selection sort
		for(int i = 0; i < max; i++){
			int mini = i;

			for(int j = i+1; j < 6; j++)
				if(list[mini] > list[j])
					mini = j;

			if(mini != i){
				int t = list[i];
				list[i] = list[mini];
				list[mini] = t;
			}
		}
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl $0x0, -0x18(%rsp)
movl -0x18(%rsp), %eax
cmpl -0x14(%rsp), %eax
jge 0x2b909
movl -0x18(%rsp), %eax
movl %eax, -0x1c(%rsp)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
cmpl $0x6, -0x20(%rsp)
jge 0x2b8b1
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rsp), %rcx
movslq -0x20(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jle 0x2b8a2
movl -0x20(%rsp), %eax
movl %eax, -0x1c(%rsp)
jmp 0x2b8a4
movl -0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x2b877
movl -0x1c(%rsp), %eax
cmpl -0x18(%rsp), %eax
je 0x2b8f7
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rsp)
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x24(%rsp), %edx
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x2b8f9
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x2b856
retq
nopw (%rax,%rax)
// File: tewalds[P]morat/havannah/board.cpp
// Function: Morat::Havannah::Board::iscorner(int, int) const
int Board::iscorner(int x, int y) const {
	if(!on_board(x,y))
		return -1;

	int m = size_r_m1_, e = size_ - 1;

	if(x == 0 && y == 0) return 0;
	if(x == m && y == 0) return 1;
	if(x == e && y == m) return 2;
	if(x == e && y == e) return 3;
	if(x == m && y == e) return 4;
	if(x == 0 && y == m) return 5;

	return -1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
callq 0x11440
testb $0x1, %al
jne 0x38658
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x38721
movq (%rsp), %rax
movsbl 0x2(%rax), %ecx
movl %ecx, 0xc(%rsp)
movsbl (%rax), %eax
subl $0x1, %eax
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x38689
cmpl $0x0, 0x10(%rsp)
jne 0x38689
movl $0x0, 0x24(%rsp)
jmp 0x38721
movl 0x14(%rsp), %eax
cmpl 0xc(%rsp), %eax
jne 0x386a4
cmpl $0x0, 0x10(%rsp)
jne 0x386a4
movl $0x1, 0x24(%rsp)
jmp 0x38721
movl 0x14(%rsp), %eax
cmpl 0x8(%rsp), %eax
jne 0x386c2
movl 0x10(%rsp), %eax
cmpl 0xc(%rsp), %eax
jne 0x386c2
movl $0x2, 0x24(%rsp)
jmp 0x38721
movl 0x14(%rsp), %eax
cmpl 0x8(%rsp), %eax
jne 0x386e0
movl 0x10(%rsp), %eax
cmpl 0x8(%rsp), %eax
jne 0x386e0
movl $0x3, 0x24(%rsp)
jmp 0x38721
movl 0x14(%rsp), %eax
cmpl 0xc(%rsp), %eax
jne 0x386fe
movl 0x10(%rsp), %eax
cmpl 0x8(%rsp), %eax
jne 0x386fe
movl $0x4, 0x24(%rsp)
jmp 0x38721
cmpl $0x0, 0x14(%rsp)
jne 0x38719
movl 0x10(%rsp), %eax
cmpl 0xc(%rsp), %eax
jne 0x38719
movl $0x5, 0x24(%rsp)
jmp 0x38721
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tewalds[P]morat/havannah/board.cpp
// Function: Morat::Havannah::Board::isedge(int, int) const
int Board::isedge(int x, int y) const {
	if(!on_board(x,y))
		return -1;

	int m = size_r_m1_, e = size_ - 1;

	if(y   == 0 && x != 0 && x != m) return 0;
	if(x-y == m && x != m && x != e) return 1;
	if(x   == e && y != m && y != e) return 2;
	if(y   == e && x != e && x != m) return 3;
	if(y-x == m && x != m && x != 0) return 4;
	if(x   == 0 && y != m && y != 0) return 5;

	return -1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
callq 0x11440
testb $0x1, %al
jne 0x38768
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x38875
movq (%rsp), %rax
movsbl 0x2(%rax), %ecx
movl %ecx, 0xc(%rsp)
movsbl (%rax), %eax
subl $0x1, %eax
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x10(%rsp)
jne 0x387a3
cmpl $0x0, 0x14(%rsp)
je 0x387a3
movl 0x14(%rsp), %eax
cmpl 0xc(%rsp), %eax
je 0x387a3
movl $0x0, 0x24(%rsp)
jmp 0x38875
movl 0x14(%rsp), %eax
subl 0x10(%rsp), %eax
cmpl 0xc(%rsp), %eax
jne 0x387d2
movl 0x14(%rsp), %eax
cmpl 0xc(%rsp), %eax
je 0x387d2
movl 0x14(%rsp), %eax
cmpl 0x8(%rsp), %eax
je 0x387d2
movl $0x1, 0x24(%rsp)
jmp 0x38875
movl 0x14(%rsp), %eax
cmpl 0x8(%rsp), %eax
jne 0x387fa
movl 0x10(%rsp), %eax
cmpl 0xc(%rsp), %eax
je 0x387fa
movl 0x10(%rsp), %eax
cmpl 0x8(%rsp), %eax
je 0x387fa
movl $0x2, 0x24(%rsp)
jmp 0x38875
movl 0x10(%rsp), %eax
cmpl 0x8(%rsp), %eax
jne 0x38822
movl 0x14(%rsp), %eax
cmpl 0x8(%rsp), %eax
je 0x38822
movl 0x14(%rsp), %eax
cmpl 0xc(%rsp), %eax
je 0x38822
movl $0x3, 0x24(%rsp)
jmp 0x38875
movl 0x10(%rsp), %eax
subl 0x14(%rsp), %eax
cmpl 0xc(%rsp), %eax
jne 0x3884b
movl 0x14(%rsp), %eax
cmpl 0xc(%rsp), %eax
je 0x3884b
cmpl $0x0, 0x14(%rsp)
je 0x3884b
movl $0x4, 0x24(%rsp)
jmp 0x38875
cmpl $0x0, 0x14(%rsp)
jne 0x3886d
movl 0x10(%rsp), %eax
cmpl 0xc(%rsp), %eax
je 0x3886d
cmpl $0x0, 0x10(%rsp)
je 0x3886d
movl $0x5, 0x24(%rsp)
jmp 0x38875
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: tewalds[P]morat/havannah/board.cpp
// Function: Morat::Havannah::Board::checkring_df(Morat::MoveValid const&, Morat::Side) const
bool Board::checkring_df(const MoveValid & pos, const Side turn) const {
	const Cell * start = cell(pos);
	start->mark = 1;
	bool success = false;
	for(int i = 0; i < 4; i++){ //4 instead of 6 since any ring must have its first endpoint in the first 4
		MoveValid loc = neighbors(pos)[i];

		if(!loc.on_board())
			continue;

		const Cell * g = cell(loc);

		if(turn != g->piece)
			continue;

		g->mark = 1;
		success = followring(loc, i, turn, (perm_rings - g->perm));
		g->mark = 0;

		if(success)
			break;
	}
	start->mark = 0;
	return success;
}

// Assembly:
subq $0x48, %rsp
movb %dl, %al
movb %al, 0x47(%rsp)
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x30(%rsp), %rsi
callq 0x39580
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movb $0x1, 0x6(%rax)
movb $0x0, 0x27(%rsp)
movl $0x0, 0x20(%rsp)
cmpl $0x4, 0x20(%rsp)
jge 0x38986
movq (%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x2c830
movslq 0x20(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x1c(%rsp)
leaq 0x1c(%rsp), %rdi
callq 0x11830
testb $0x1, %al
jne 0x388f7
jmp 0x38976
movq (%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0x39580
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
leaq 0x47(%rsp), %rdi
callq 0x2a820
testb $0x1, %al
jne 0x3891f
jmp 0x38921
jmp 0x38976
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movb $0x1, 0x6(%rax)
movl 0x9c(%rdi), %eax
movq 0x10(%rsp), %rcx
movzbl 0x7(%rcx), %ecx
subl %ecx, %eax
movl %eax, 0xc(%rsp)
leaq 0x1c(%rsp), %rsi
leaq 0x20(%rsp), %rdx
leaq 0x47(%rsp), %rcx
leaq 0xc(%rsp), %r8
callq 0x389a0
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x10(%rsp), %rax
movb $0x0, 0x6(%rax)
testb $0x1, 0x27(%rsp)
je 0x38974
jmp 0x38986
jmp 0x38976
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x388c2
movq 0x28(%rsp), %rax
movb $0x0, 0x6(%rax)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: tewalds[P]morat/havannah/board.cpp
// Function: Morat::Havannah::Board::followring(Morat::MoveValid const&, int const&, Morat::Side const&, int const&) const
bool Board::followring(const MoveValid & cur, const int & dir, const Side & turn, const int & permsneeded) const {
	for(int i = 5; i <= 7; i++){
		int nd = (dir + i) % 6;
		MoveValid next = neighbors(cur)[nd];

		if(!next.on_board())
			continue;

		const Cell * g = cell(next);

		if(g->mark)
			return (permsneeded <= 0);

		if(turn != g->piece)
			continue;

		g->mark = 1;
		bool success = followring(next, nd, turn, (permsneeded - g->perm));
		g->mark = 0;

		if(success)
			return true;
	}
	return false;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movl $0x5, 0x24(%rsp)
cmpl $0x7, 0x24(%rsp)
jg 0x38ad3
movq (%rsp), %rdi
movq 0x38(%rsp), %rax
movl (%rax), %eax
addl 0x24(%rsp), %eax
movl $0x6, %ecx
cltd
idivl %ecx
movl %edx, 0x20(%rsp)
movq 0x40(%rsp), %rsi
callq 0x2c830
movslq 0x20(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x1c(%rsp)
leaq 0x1c(%rsp), %rdi
callq 0x11830
testb $0x1, %al
jne 0x38a1d
jmp 0x38ac3
movq (%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0x39580
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpb $0x0, 0x6(%rax)
je 0x38a51
movq 0x28(%rsp), %rax
cmpl $0x0, (%rax)
setle %al
andb $0x1, %al
movb %al, 0x57(%rsp)
jmp 0x38ad8
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2a820
testb $0x1, %al
jne 0x38a66
jmp 0x38a68
jmp 0x38ac3
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movb $0x1, 0x6(%rax)
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %rax
movl (%rax), %eax
movq 0x10(%rsp), %rdx
movzbl 0x7(%rdx), %edx
subl %edx, %eax
movl %eax, 0x8(%rsp)
leaq 0x1c(%rsp), %rsi
leaq 0x20(%rsp), %rdx
leaq 0x8(%rsp), %r8
callq 0x389a0
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movb $0x0, 0x6(%rax)
testb $0x1, 0xf(%rsp)
je 0x38ac1
movb $0x1, 0x57(%rsp)
jmp 0x38ad8
jmp 0x38ac3
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x389ce
movb $0x0, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: snaury[P]t-digest-simple/./merging_tdigest.hpp
// Function: MergingTDigest::add(MergingTDigest::Centroid const&)
void add(const Centroid& c) {
        if (buffer_size_ >= max_buffer_size_) {
            compress();
        }
        summary_.push_back(c);
        ++buffer_size_;
        ++count_;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq 0x28(%rcx), %rax
cmpq 0x20(%rcx), %rax
jb 0x396b
movq -0x18(%rbp), %rdi
callq 0x2c70
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x39d0
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: snaury[P]t-digest-simple/./merging_tdigest.hpp
// Function: MergingTDigest::interpolate(double, double, double, double, double)
static double interpolate(double x, double x1, double y1, double x2, double y2) {
        double d = x2 - x1;
        double a = (x2 - x) / d;
        double b = (x - x1) / d;
        return a * y1 + b * y2;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x20(%rbp)
movsd %xmm4, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
subsd -0x8(%rbp), %xmm0
divsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x8(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
divsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
movsd -0x18(%rbp), %xmm2
movsd -0x40(%rbp), %xmm1
mulsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yasz24[P]eau2/src/network/./network.h
// Function: Directory::Directory(unsigned long, unsigned long, unsigned long, unsigned long, unsigned long*, String**)
Directory(size_t sender, size_t target, size_t id, size_t i_clients, size_t* i_ports, String** i_addresses) {
        kind_ = (enum MsgKind)9;
        sender_ = sender;
        target_ = target;
        id_ = id;
        clients = i_clients;
        size_t* tmp_ports = new size_t[i_clients];
        String** tmp_addresses = new String*[i_clients];
        for(int i = 0;  i < i_clients; i++) {
            tmp_ports[i] = i_ports[i];
        }
        ports = tmp_ports;
        for(int i = 0; i < i_clients; i++) {
            tmp_addresses[i] = i_addresses[i]->clone();
        }
        addresses = tmp_addresses; 
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x9f90
movq -0x68(%rbp), %rax
leaq 0x308d9(%rip), %rcx     # 0x3a2d8
movq %rcx, (%rax)
movl $0x9, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x8030
movq %rax, -0x60(%rbp)
jmp 0x9a4e
movq -0x60(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x8030
movq %rax, -0x70(%rbp)
jmp 0x9a7b
movq -0x70(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x0, -0x54(%rbp)
movslq -0x54(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x9ace
movq -0x30(%rbp), %rax
movslq -0x54(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x38(%rbp), %rax
movslq -0x54(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x9a8a
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0xa160
jmp 0x9b36
movq -0x68(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x38(%rax)
movl $0x0, -0x58(%rbp)
movslq -0x58(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x9b21
movq 0x10(%rbp), %rax
movslq -0x58(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
movq %rax, -0x78(%rbp)
jmp 0x9b06
movq -0x78(%rbp), %rdx
movq -0x50(%rbp), %rax
movslq -0x58(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x9ae1
movq -0x68(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x40(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x83e0
nop
// File: ridgelab[P]Kmer-SSR/src/main.cpp
// Function: main
int main(int argc, char* argv[])
{
	int ret_val = 0;
	
	Arguments* args;

	try
	{
		args = new Arguments(argc, argv);

		if(!args->helpOrVersionDisplayed())
		{
			FindSSRs find_ssrs(args);
			ret_val = find_ssrs.run();
		}
	}
	catch (string error)
	{
		cerr << error << endl;
		return 1;
	}
	catch (const char* error)
	{
		cerr << error << endl;
		return 1;
	}
	
	delete args;

	return ret_val;
	//pthread_exit(NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0xf0, %edi
callq 0x43a0
movq %rax, -0xa0(%rbp)
jmp 0x4b33
movq -0xa0(%rbp), %rdi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x186b0
jmp 0x4b48
movq -0xa0(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x19ba0
movb %al, -0xa1(%rbp)
jmp 0x4b64
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0x4cd6
jmp 0x4b74
movq -0x20(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x10d30
jmp 0x4b83
leaq -0x70(%rbp), %rdi
callq 0x11000
movl %eax, -0xa8(%rbp)
jmp 0x4b94
movl -0xa8(%rbp), %eax
movl %eax, -0x14(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x10f30
jmp 0x4cd6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x4bed
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0xf0, %esi
callq 0x43b0
jmp 0x4bed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x10f30
movl -0x2c(%rbp), %eax
movl %eax, -0xac(%rbp)
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x4c7a
movq -0x28(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x44d0
movq %rax, %rsi
leaq -0x98(%rbp), %rdi
callq 0x4170
jmp 0x4c20
movq -0xb8(%rbp), %rdi
callq 0x4150
movq 0x2d3bd(%rip), %rdi     # 0x31ff0
leaq -0x98(%rbp), %rsi
callq 0x4340
movq %rax, -0xc0(%rbp)
jmp 0x4c48
movq -0xc0(%rbp), %rdi
movq 0x2d33a(%rip), %rsi     # 0x31f90
callq 0x43e0
jmp 0x4c5d
movl $0x1, -0x4(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x4788
callq 0x4640
jmp 0x4d40
movl -0xac(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x4d4c
movq -0x28(%rbp), %rdi
callq 0x4150
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rsi
movq 0x2d34b(%rip), %rdi     # 0x31ff0
callq 0x4390
movq %rax, -0xc8(%rbp)
jmp 0x4cb3
movq -0xc8(%rbp), %rdi
movq 0x2d2cf(%rip), %rsi     # 0x31f90
callq 0x43e0
jmp 0x4cc8
movl $0x1, -0x4(%rbp)
callq 0x4640
jmp 0x4d40
jmp 0x4d0c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x4640
jmp 0x4d4c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x4788
callq 0x4640
jmp 0x4d0a
jmp 0x4d4c
movq -0x20(%rbp), %rax
movq %rax, -0xd0(%rbp)
cmpq $0x0, %rax
je 0x4d3a
movq -0xd0(%rbp), %rdi
callq 0x19a90
movq -0xd0(%rbp), %rdi
movl $0xf0, %esi
callq 0x43b0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x46e0
movq %rax, %rdi
callq 0x4d60
nopl (%rax)
// File: ridgelab[P]Kmer-SSR/src/SSRcontainer.cpp
// Function: SSRcontainer::clear()
void SSRcontainer::clear()
{
	for (unordered_map<string, vector<SSR*>*>::iterator itr = this->ssrs->begin(); itr != this->ssrs->end(); ++itr)
	{
		//delete itr->first;
		
		for (uint32_t i = 0; i < itr->second->size(); ++i)
		{
			delete itr->second->at(i);
		}

		itr->second->clear();

		delete itr->second;
	}

	this->ssrs->clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rax), %rdi
callq 0x6c10
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x6c70
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x6c40
testb $0x1, %al
jne 0x5bb6
jmp 0x5c7a
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x6ca0
movq 0x20(%rax), %rdi
callq 0x6bb0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x5c2a
leaq -0x10(%rbp), %rdi
callq 0x6ca0
movq 0x20(%rax), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x6bd0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x5c1d
movq -0x38(%rbp), %rdi
callq 0x5770
movq -0x38(%rbp), %rdi
movl $0x28, %esi
callq 0x43b0
jmp 0x5c1f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5bbd
leaq -0x10(%rbp), %rdi
callq 0x6ca0
movq 0x20(%rax), %rdi
callq 0x6cd0
leaq -0x10(%rbp), %rdi
callq 0x6ca0
movq 0x20(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x5c6a
movq -0x40(%rbp), %rdi
callq 0x6cf0
movq -0x40(%rbp), %rdi
movl $0x18, %esi
callq 0x43b0
jmp 0x5c6c
leaq -0x10(%rbp), %rdi
callq 0x6d50
jmp 0x5b90
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x6d80
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: ridgelab[P]Kmer-SSR/src/SSRcontainer.cpp
// Function: SSRcontainer::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, SSR*)
void SSRcontainer::add(const string &identifier, SSR* ssr)
{
	if (this->ssrs->count(identifier)) // if the key (and thus the associated vector) already exists in the map
	{
		this->ssrs->at(identifier)->push_back(ssr);
	}
	else // if it doesn't yet exist in the map
	{
		vector<SSR*>* temp_ptr = new vector<SSR*>( { ssr } ); // create the vector
		std::pair<string, vector<SSR*>*> temp_pair(identifier, temp_ptr); // create the pair
		this->ssrs->insert(temp_pair); // add the pair to the map
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x6980
cmpq $0x0, %rax
je 0x5d28
movq -0x90(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x69b0
movq (%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x69e0
jmp 0x5e47
movl $0x18, %edi
callq 0x43a0
movq %rax, -0xa0(%rbp)
movq %rax, -0xa8(%rbp)
movb $0x1, -0x4d(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x1, -0x28(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x6a50
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rcx
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x6a70
jmp 0x5d89
movb $0x0, -0x4d(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x6af0
movq -0xa8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x78(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
leaq -0x20(%rbp), %rdx
callq 0x6b10
movq -0x90(%rbp), %rax
movq -0xc0(%rbp), %rsi
movq (%rax), %rdi
callq 0x6b50
movb %dl, -0xb1(%rbp)
movq %rax, -0xb0(%rbp)
jmp 0x5dde
movb -0xb1(%rbp), %al
movq -0xb0(%rbp), %rcx
movq %rcx, -0x88(%rbp)
movb %al, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x6b90
jmp 0x5e47
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x6af0
testb $0x1, -0x4d(%rbp)
jne 0x5e1d
jmp 0x5e2e
movq -0xa8(%rbp), %rdi
movl $0x18, %esi
callq 0x43b0
jmp 0x5e50
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x6b90
jmp 0x5e50
addq $0xc0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x46e0
nopl (%rax)
// File: ridgelab[P]Kmer-SSR/src/SSRcontainer.cpp
// Function: SSRcontainer::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<SSR*, std::allocator<SSR*>>*)
void SSRcontainer::add(const string &identifier, vector<SSR*>* ssrs_vec)
{
	if (ssrs_vec != nullptr)
	{
		if (this->ssrs->count(identifier)) // if the key (and thus the associated vector) already exists in the map
		{
			vector<SSR*>* temp_ptr = this->ssrs->at(identifier); // get the vector

			// add each SSR* in ssrs_vec into the vector pointed to by the identifier in the map (this->ssrs)
			for (uint32_t i = 0; i < ssrs_vec->size(); ++i)
			{
				temp_ptr->push_back(ssrs_vec->at(i));
			}
		}
		else // if it doesn't yet exist in the map
		{
			std::pair<string, vector<SSR*>*> temp_pair(identifier, ssrs_vec);
			this->ssrs->insert(temp_pair);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5f81
movq -0x78(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x6980
cmpq $0x0, %rax
je 0x5f0f
movq -0x78(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x69b0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6bb0
movq %rax, %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
jae 0x5f0d
movq -0x20(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x6bd0
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x69e0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5ebe
jmp 0x5f7f
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
leaq -0x18(%rbp), %rdx
callq 0x6b10
movq -0x78(%rbp), %rax
movq -0xa0(%rbp), %rsi
movq (%rax), %rdi
callq 0x6b50
movb %dl, -0x91(%rbp)
movq %rax, -0x90(%rbp)
jmp 0x5f49
movb -0x91(%rbp), %al
movq -0x90(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movb %al, -0x68(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x6b90
jmp 0x5f7f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x6b90
jmp 0x5f8a
jmp 0x5f81
addq $0xa0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x46e0
nopw %cs:(%rax,%rax)
// File: ridgelab[P]Kmer-SSR/src/SSRcontainer.cpp
// Function: SSRcontainer::writeToFile(std::basic_ofstream<char, std::char_traits<char>>&) const
void SSRcontainer::writeToFile(ofstream &ofd) const
{
	for (unordered_map<string, vector<SSR*>*>::iterator itr = this->ssrs->begin(); itr != this->ssrs->end(); ++itr)
	{
		for (uint32_t i = 0; i < itr->second->size(); ++i)
		{
			ofd << itr->first << '\t';
			itr->second->at(i)->writeToFile(ofd);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rax), %rdi
callq 0x6c10
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x6c70
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6c40
testb $0x1, %al
jne 0x5fea
jmp 0x607e
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6ca0
movq 0x20(%rax), %rdi
callq 0x6bb0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x606e
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6ca0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x4340
movq %rax, %rdi
movl $0x9, %esi
callq 0x4470
leaq -0x18(%rbp), %rdi
callq 0x6ca0
movq 0x20(%rax), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x6bd0
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x5880
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5ff1
jmp 0x6070
leaq -0x18(%rbp), %rdi
callq 0x6d50
jmp 0x5fc4
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ridgelab[P]Kmer-SSR/src/SSRcontainer.cpp
// Function: SSRcontainer::writeToFile(OutputFile&, bool, bool)
void SSRcontainer::writeToFile(OutputFile &ofd, bool block, bool clear)
{
	if (ofd.obtainLock(block))
	{
		for (unordered_map<string, vector<SSR*>*>::iterator itr = this->ssrs->begin(); itr != this->ssrs->end(); ++itr)
		{
			for (uint32_t i = 0; i < itr->second->size(); ++i)
			{
				ofd << itr->first << '\t';
				itr->second->at(i)->writeToFile(ofd);
			}
		}

		ofd.unlock();

		if (clear)
		{
			this->clear();
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %cl
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x52a0
testb $0x1, %al
jne 0x60d1
jmp 0x61b5
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x6c10
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x6c70
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6c40
testb $0x1, %al
jne 0x6107
jmp 0x619b
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6ca0
movq 0x20(%rax), %rdi
callq 0x6bb0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x618b
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6ca0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x55e0
movq %rax, %rdi
movl $0x9, %esi
callq 0x5520
leaq -0x20(%rbp), %rdi
callq 0x6ca0
movq 0x20(%rax), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0x6bd0
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x58f0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x610e
jmp 0x618d
leaq -0x20(%rbp), %rdi
callq 0x6d50
jmp 0x60e1
movq -0x10(%rbp), %rdi
callq 0x5320
testb $0x1, -0x12(%rbp)
je 0x61b3
movq -0x38(%rbp), %rdi
callq 0x5b70
jmp 0x61b5
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ridgelab[P]Kmer-SSR/src/SSRcontainer.cpp
// Function: SSRcontainer::writeToFile(OutputFile*, bool, bool)
void SSRcontainer::writeToFile(OutputFile* ofd, bool block, bool clear)
{
	if (ofd->obtainLock(block))
	{
		for (unordered_map<string, vector<SSR*>*>::iterator itr = this->ssrs->begin(); itr != this->ssrs->end(); ++itr)
		{
			for (uint32_t i = 0; i < itr->second->size(); ++i)
			{
				*ofd << itr->first << '\t';
				itr->second->at(i)->writeToFile(*ofd);
			}
		}

		ofd->unlock();

		if (clear)
		{
			this->clear();
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %cl
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x52a0
testb $0x1, %al
jne 0x6201
jmp 0x62e5
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x6c10
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x6c70
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6c40
testb $0x1, %al
jne 0x6237
jmp 0x62cb
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6ca0
movq 0x20(%rax), %rdi
callq 0x6bb0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x62bb
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6ca0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x55e0
movq %rax, %rdi
movl $0x9, %esi
callq 0x5520
leaq -0x20(%rbp), %rdi
callq 0x6ca0
movq 0x20(%rax), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0x6bd0
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x58f0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x623e
jmp 0x62bd
leaq -0x20(%rbp), %rdi
callq 0x6d50
jmp 0x6211
movq -0x10(%rbp), %rdi
callq 0x5320
testb $0x1, -0x12(%rbp)
je 0x62e3
movq -0x38(%rbp), %rdi
callq 0x5b70
jmp 0x62e5
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ridgelab[P]Kmer-SSR/src/AtomicityChecker.cpp
// Function: AtomicityChecker::~AtomicityChecker()
AtomicityChecker::~AtomicityChecker()
{
	for (unordered_map<uint32_t, unordered_set<uint32_t>*>::iterator itr = this->factors->begin(); itr != this->factors->end(); ++itr)
	{
		delete itr->second;
	}
	this->factors->clear();
	delete this->factors;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rdi
callq 0xb5b0
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0xb610
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xb5e0
testb $0x1, %al
jne 0xaac3
jmp 0xaafe
leaq -0x10(%rbp), %rdi
callq 0xb640
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xaaf1
movq -0x28(%rbp), %rdi
callq 0xb520
movq -0x28(%rbp), %rdi
movl $0x38, %esi
callq 0x43b0
jmp 0xaaf3
leaq -0x10(%rbp), %rdi
callq 0xb670
jmp 0xaaa0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0xb6a0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xab32
movq -0x30(%rbp), %rdi
callq 0xb6c0
movq -0x30(%rbp), %rdi
movl $0x38, %esi
callq 0x43b0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ridgelab[P]Kmer-SSR/src/AtomicityChecker.cpp
// Function: AtomicityChecker::isAtomic(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool AtomicityChecker::isAtomic(const string &base_ssr)
{
	uint32_t period = base_ssr.size();

	// get the factors (calculate them if necessary)
	unordered_set<uint32_t>* period_factors = this->calculateFactors(period);

	// check if it's atomic
	for (unordered_set<uint32_t>::iterator itr = period_factors->begin(); itr != period_factors->end(); ++itr)
	{
		if ( (*itr != period) && (!this->checkAtomicityAtFactor(*itr, base_ssr, period)) )
		{
			return false; // basically, skip the check if *itr == period. Given that, if it's not atomic, return false
		}
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4260
movq -0x40(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
callq 0xac00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xb6e0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xb740
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xb710
testb $0x1, %al
jne 0xaba1
jmp 0xabe3
leaq -0x30(%rbp), %rdi
callq 0xb770
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
je 0xabd6
leaq -0x30(%rbp), %rdi
callq 0xb770
movq -0x40(%rbp), %rdi
movl (%rax), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0xaed0
testb $0x1, %al
jne 0xabd6
movb $0x0, -0x1(%rbp)
jmp 0xabe7
jmp 0xabd8
leaq -0x30(%rbp), %rdi
callq 0xb7a0
jmp 0xab81
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ridgelab[P]Kmer-SSR/src/AtomicityChecker.cpp
// Function: AtomicityChecker::checkAtomicityAtFactor(unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int) const
bool AtomicityChecker::checkAtomicityAtFactor(uint32_t factor, const string &base_ssr, uint32_t period) const
{
	uint32_t count = 1;

	for (uint32_t i = 0; i < period; i += factor)
	{
		if ( base_ssr.substr(i, factor) != base_ssr.substr(i + factor, factor) )
		{
			break;
		}
		++count;
	}

	return count != (period / factor);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x1, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0xaf90
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %eax
movl %eax, %edx
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq -0x48(%rbp), %rdi
callq 0x43c0
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %eax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl %edx, %eax
movl %eax, %edx
leaq -0x68(%rbp), %rdi
callq 0x43c0
jmp 0xaf35
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xba20
movb %al, -0x75(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4788
leaq -0x48(%rbp), %rdi
callq 0x4788
movb -0x75(%rbp), %al
testb $0x1, %al
jne 0xaf60
jmp 0xaf79
jmp 0xaf90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4788
jmp 0xafb3
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0xc(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0xaef7
movl -0x20(%rbp), %eax
movl %eax, -0x7c(%rbp)
movl -0x1c(%rbp), %eax
xorl %edx, %edx
divl -0xc(%rbp)
movl %eax, %ecx
movl -0x7c(%rbp), %eax
cmpl %ecx, %eax
setne %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x46e0
nopl (%rax)
// File: ridgelab[P]Kmer-SSR/src/AtomicityChecker.cpp
// Function: AtomicityChecker::safeInsert(unsigned int, std::unordered_set<unsigned int, std::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<unsigned int>>*)
void AtomicityChecker::safeInsert(uint32_t x, unordered_set<uint32_t>* xfactors)
{
	sem_wait(&(this->lock));
	if (!this->factors->count(x)) // if x is not already in this->factors
	{
		std::pair<uint32_t, unordered_set<uint32_t> * > temp_pair(x, xfactors);
		this->factors->insert(temp_pair); // add it
	}
	else if (this->factors->at(x) != xfactors) // else if x is already in this->factors, but has a different set than xfactors
	{
		delete xfactors;
	}
	sem_post(&(this->lock));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x8, %rdi
callq 0x41f0
movq -0x40(%rbp), %rax
movq (%rax), %rdi
leaq -0xc(%rbp), %rsi
callq 0xb910
cmpq $0x0, %rax
jne 0xb344
leaq -0x28(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0xb940
movq -0x40(%rbp), %rax
movq (%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0xb970
movq %rax, -0x38(%rbp)
movb %dl, -0x30(%rbp)
jmp 0xb386
movq -0x40(%rbp), %rax
movq (%rax), %rdi
leaq -0xc(%rbp), %rsi
callq 0xb9b0
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
je 0xb384
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0xb382
movq -0x48(%rbp), %rdi
callq 0xb520
movq -0x48(%rbp), %rdi
movl $0x38, %esi
callq 0x43b0
jmp 0xb384
jmp 0xb386
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
callq 0x4670
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)