LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movsbq %dl, %rax
movslq %esi, %rcx
vpbroadcastq %rdi, %zmm2
leaq 0x10(%rsp), %r14
movl $0x2, %edx
movq %rdi, %rbx
decl %eax
vpbroadcastq %rcx, %zmm1
movq %r14, %rsi
vpbroadcastq %rax, %zmm0
vpmuldq 0x1cd47(%rip){1to8}, %zmm0, %zmm0 # 0x35908
vpsllq $0x2, %zmm1, %zmm1
movb $0x3f, %al
vpaddq %zmm1, %zmm2, %zmm1
kmovd %eax, %k2
kmovw %k2, 0xe(%rsp)
kmovq %k2, %k1
vpaddq %zmm0, %zmm1, %zmm0
vpxor %xmm1, %xmm1, %xmm1
vmovdqu64 %zmm0, 0x30(%rsp)
vpaddq 0x1cdc2(%rip), %zmm0, %zmm0 # 0x359c0
vpgatherqd (,%zmm0), %ymm1 {%k1}
vmovdqu32 %ymm1, (%r14) {%k2}
vzeroupper
callq 0x18c8a
vmovdqu64 0x30(%rsp), %zmm0
kmovw 0xe(%rsp), %k2
vpxor %xmm1, %xmm1, %xmm1
movl (%r14), %eax
movl 0x4(%r14), %ecx
movl $0x3, %edx
movq %rbx, %rdi
movq %r14, %rsi
vpaddq 0x1cdb8(%rip), %zmm0, %zmm0 # 0x35a00
kmovq %k2, %k1
leal -0x1(%rax,%rcx), %ebp
vpgatherqd (,%zmm0), %ymm1 {%k1}
vmovdqu32 %ymm1, (%r14) {%k2}
vzeroupper
callq 0x18c8a
movl (%r14), %eax
movl 0x8(%r14), %ecx
addl 0x4(%r14), %eax
leal -0x2(%rcx,%rax), %eax
cmpl %ebp, %eax
cmovll %eax, %ebp
movl %ebp, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
testl %edx, %edx
jle 0x18ce7
movl $0x1, %ecx
movl %edx, %eax
xorl %edx, %edx
movl %edx, %edi
movq %rcx, %r8
cmpq $0x4, %rdx
ja 0x18cc1
movslq %edi, %r9
movl (%rsi,%r9,4), %r10d
movl %r8d, %r9d
cmpl (%rsi,%r8,4), %r10d
jg 0x18cb5
movl %edi, %r9d
incq %r8
movl %r9d, %edi
cmpq $0x6, %r8
jne 0x18ca2
movl %edi, %r8d
cmpq %r8, %rdx
je 0x18cdc
movslq %edi, %rdi
movl (%rsi,%rdx,4), %r8d
movl (%rsi,%rdi,4), %r9d
movl %r9d, (%rsi,%rdx,4)
movl %r8d, (%rsi,%rdi,4)
incq %rdx
incq %rcx
cmpq %rax, %rdx
jne 0x18c97
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0xb(%rsp), %rax
movl %edx, %r14d
movb $0x1, %bpl
movq %rdi, %r15
xorl %r12d, %r12d
movq %rsi, 0x20(%rsp)
movb %r14b, (%rax)
movswq 0x2(%rsi), %rax
movq 0x10(%rdi), %rcx
shlq $0x4, %rax
leaq 0x6(%rcx,%rax), %rax
leaq 0xc(%rsp), %rcx
movb $0x1, (%rax)
movq %rax, 0x18(%rsp)
movl $0x0, (%rcx)
movswq 0x2(%rsi), %rax
leaq (%rax,%rax,8), %rax
shlq $0x3, %rax
addq 0x88(%r15), %rax
movl (%rax,%r12,4), %eax
movl %eax, 0x14(%rsp)
shrl $0x10, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x216b5
movq 0x10(%r15), %r13
movswq %ax, %rbx
shlq $0x4, %rbx
cmpb %r14b, (%r13,%rbx)
jne 0x216b5
movb $0x1, 0x6(%r13,%rbx)
leaq 0x14(%rsp), %rsi
leaq 0xc(%rsp), %rdx
leaq 0x10(%rsp), %r8
movq %r15, %rdi
movl 0x9c(%r15), %eax
movzbl 0x7(%r13,%rbx), %ecx
subl %ecx, %eax
leaq 0xb(%rsp), %rcx
movl %eax, 0x10(%rsp)
callq 0x216f2
movq 0x20(%rsp), %rsi
movb $0x0, 0x6(%r13,%rbx)
testb %al, %al
jne 0x216d5
cmpq $0x3, %r12
leaq 0x1(%r12), %rax
setb %bpl
movl %eax, 0xc(%rsp)
movq %rax, %r12
cmpq $0x4, %rax
jne 0x21638
xorl %ebp, %ebp
movq 0x18(%rsp), %rax
andb $0x1, %bpl
movb $0x0, (%rax)
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl (%rdx), %eax
movl $0x5, %ebp
movq %r8, 0x18(%rsp)
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %r13
movq %rdx, 0x20(%rsp)
leal (%rax,%rbp), %ecx
movslq %ecx, %rcx
imulq $0x2aaaaaab, %rcx, %rdx # imm = 0x2AAAAAAB
movq %rdx, %rsi
shrq $0x3f, %rsi
shrq $0x20, %rdx
addl %esi, %edx
addl %edx, %edx
leal (%rdx,%rdx,2), %edx
subl %edx, %ecx
movl %ecx, 0x14(%rsp)
movslq %ecx, %rcx
movswq 0x2(%r12), %rdx
leaq (%rdx,%rdx,8), %rdx
shlq $0x3, %rdx
addq 0x88(%r13), %rdx
movl (%rdx,%rcx,4), %ecx
movl %ecx, 0x10(%rsp)
shrl $0x10, %ecx
cmpl $0xffff, %ecx           # imm = 0xFFFF
je 0x217ca
movq 0x10(%r13), %rbx
movswq %cx, %r15
shlq $0x4, %r15
cmpb $0x0, 0x6(%rbx,%r15)
jne 0x217d9
movb (%r14), %cl
cmpb (%rbx,%r15), %cl
jne 0x217ca
movq 0x18(%rsp), %rax
movb $0x1, 0x6(%rbx,%r15)
leaq 0x10(%rsp), %rsi
leaq 0x14(%rsp), %rdx
leaq 0xc(%rsp), %r8
movq %r13, %rdi
movzbl 0x7(%rbx,%r15), %ecx
movl (%rax), %eax
subl %ecx, %eax
movq %r14, %rcx
movl %eax, 0xc(%rsp)
callq 0x216f2
movb $0x0, 0x6(%rbx,%r15)
testb %al, %al
jne 0x217e6
movq 0x20(%rsp), %rax
movl (%rax), %eax
incl %ebp
cmpl $0x8, %ebp
jne 0x2171a
xorl %eax, %eax
jmp 0x217e8
movq 0x18(%rsp), %rax
cmpl $0x0, (%rax)
setle %al
jmp 0x217e8
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/snaury[P]t-digest-simple/./merging_tdigest.hpp
// Function: MergingTDigest::quantile(double)
double quantile(double q) {
        compress();
        if (summary_.empty())
            return NAN;
        if (summary_.size() == 1)
            return summary_[0].mean;
        double index = q * (count_ - 1);
        double a = summary_[0].mean;
        double aIndex = (summary_[0].count - 1) * 0.5;
        int64_t sum = summary_[0].count;
        double b = summary_[1].mean;
        double bIndex = sum + (summary_[1].count - 1) * 0.5;
        for (size_t i = 2; i < summary_.size(); ++i) {
            if (index <= bIndex) {
                return interpolate(index, aIndex, a, bIndex, b);
            }
            a = b;
            aIndex = bIndex;
            sum += summary_[i-1].count;
            b = summary_[i].mean;
            bIndex = sum + (summary_[i].count - 1) * 0.5;
        }
        // either there are exactly two centroids or index is past the end
        return interpolate(index, aIndex, a, bIndex, b);
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
callq 0x27f4
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x2a41
subq %rax, %rcx
cmpq $0x10, %rcx
jne 0x2a4e
movsd (%rax), %xmm0
jmp 0x2b80
movsd 0x15e7(%rip), %xmm0     # 0x4030
jmp 0x2b80
movq 0x30(%rbx), %rdx
decq %rdx
movq %rdx, %xmm1
punpckldq 0x15ee(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
sarq $0x4, %rcx
subpd 0x15f2(%rip), %xmm1     # 0x4060
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x8(%rsp), %xmm0
movsd (%rax), %xmm4
movq 0x8(%rax), %rdx
leaq -0x1(%rdx), %rsi
cvtsi2sd %rsi, %xmm3
movsd 0x1577(%rip), %xmm5     # 0x4010
mulsd %xmm5, %xmm3
cvtsi2sd %rdx, %xmm2
movq 0x18(%rax), %rsi
decq %rsi
xorps %xmm1, %xmm1
cvtsi2sd %rsi, %xmm1
mulsd %xmm5, %xmm1
addsd %xmm2, %xmm1
movsd 0x10(%rax), %xmm2
cmpq $0x3, %rcx
jb 0x2b5c
ucomisd %xmm0, %xmm1
jae 0x2b1e
addq $0x28, %rax
addq $-0x2, %rcx
addq -0x10(%rax), %rdx
xorps %xmm3, %xmm3
cvtsi2sd %rdx, %xmm3
movq (%rax), %rsi
decq %rsi
xorps %xmm6, %xmm6
cvtsi2sd %rsi, %xmm6
mulsd %xmm5, %xmm6
addsd %xmm3, %xmm6
movsd -0x8(%rax), %xmm7
decq %rcx
je 0x2b4c
addq $0x10, %rax
ucomisd %xmm0, %xmm6
movapd %xmm1, %xmm3
movapd %xmm2, %xmm4
movapd %xmm6, %xmm1
movapd %xmm7, %xmm2
jb 0x2ad6
jmp 0x2b26
movapd %xmm2, %xmm7
movapd %xmm1, %xmm6
movapd %xmm6, %xmm1
subsd %xmm3, %xmm1
subsd %xmm0, %xmm6
divsd %xmm1, %xmm6
mulsd %xmm4, %xmm6
subsd %xmm3, %xmm0
divsd %xmm1, %xmm0
mulsd %xmm7, %xmm0
addsd %xmm6, %xmm0
jmp 0x2b80
movapd %xmm2, %xmm4
movapd %xmm1, %xmm3
movapd %xmm6, %xmm1
movapd %xmm7, %xmm2
movapd %xmm1, %xmm5
subsd %xmm3, %xmm5
subsd %xmm0, %xmm1
divsd %xmm5, %xmm1
mulsd %xmm4, %xmm1
subsd %xmm3, %xmm0
divsd %xmm5, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rdi), %rax
cmpq 0x20(%rdi), %rax
jb 0x2c42
movq %rbx, %rdi
callq 0x27f4
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2c5a
movups (%r14), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%rbx)
jmp 0x2c65
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2c80
movdqu 0x28(%rbx), %xmm0
pcmpeqd %xmm1, %xmm1
psubq %xmm1, %xmm0
movdqu %xmm0, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r13
movq %r8, %r14
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0x1f454(%rip), %rax     # 0x27428
movq %rax, (%rdi)
movl $0x9, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
movq %rdx, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq %r8, 0x30(%rdi)
movq %r8, %rax
shrq $0x3d, %rax
leaq (,%r8,8), %rcx
xorl %r12d, %r12d
negq %rax
sbbq %r12, %r12
movq %rcx, -0x30(%rbp)
orq %rcx, %r12
movq %r12, %rdi
callq 0x7030
movq %rax, %r15
movq %r12, %rdi
callq 0x7030
movq %rax, %r12
testq %r14, %r14
je 0x805b
movq %r13, %rsi
movq 0x10(%rbp), %r13
movq %r15, %rdi
movq -0x30(%rbp), %rdx
callq 0x71a0
movq %r15, 0x38(%rbx)
xorl %r15d, %r15d
movq (%r13,%r15,8), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, (%r12,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x8042
jmp 0x805f
movq %r15, 0x38(%rbx)
movq %r12, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movl %edi, %ebp
movl $0xf0, %edi
callq 0x32f0
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0xa136
movq %r14, %rdi
callq 0xb69a
xorl %ebx, %ebx
testb %al, %al
jne 0x3986
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x728c
leaq 0x8(%rsp), %rdi
callq 0x7484
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x73e0
movq %r14, %rdi
callq 0xb580
movl $0xf0, %esi
movq %r14, %rdi
callq 0x3300
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x73e0
jmp 0x39d7
jmp 0x39d1
movq %rdx, %r15
movq %rax, %rbx
movl $0xf0, %esi
movq %r14, %rdi
callq 0x3300
jmp 0x39d7
movq %rdx, %r15
movq %rax, %rbx
cmpl $0x2, %r15d
jne 0x3a41
movq %rbx, %rdi
callq 0x33b0
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x3aba
movq %rbx, %rdi
callq 0x3130
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x115d5(%rip), %rdi     # 0x14ff0
callq 0x3360
movq %rax, %rdi
callq 0x3150
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3a66
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3300
jmp 0x3a66
cmpl $0x1, %r15d
jne 0x3a9e
movq %rbx, %rdi
callq 0x3130
movq 0x1159a(%rip), %rdi     # 0x14ff0
movq %rax, %rsi
callq 0x32e0
movq %rax, %rdi
callq 0x3150
callq 0x34c0
movl $0x1, %ebx
jmp 0x399b
movq %rax, %rbx
callq 0x34c0
jmp 0x3a9e
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3a99
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3300
callq 0x34c0
movq %rbx, %rdi
callq 0x3540
movq %rax, %rdi
callq 0x3aae
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x4483
movq 0x28(%r15), %r14
movq (%r14), %rdi
movq 0x8(%r14), %rax
cmpq %rdi, %rax
je 0x444d
movl $0x1, %ebp
xorl %ecx, %ecx
movq (%rdi,%rcx,8), %r14
testq %r14, %r14
je 0x4422
movq %r14, %rdi
callq 0x415a
movl $0x28, %esi
movq %r14, %rdi
callq 0x3300
movl %ebp, %ecx
movq 0x28(%r15), %r14
movq (%r14), %rdi
movq 0x8(%r14), %rax
movq %rax, %rdx
subq %rdi, %rdx
sarq $0x3, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x4411
cmpq %rdi, %rax
je 0x4456
movq %rdi, 0x8(%r14)
testq %rdi, %rdi
je 0x4467
movq 0x10(%r14), %rsi
subq %rdi, %rsi
callq 0x3300
movl $0x18, %esi
movq %r14, %rdi
callq 0x3300
movq (%r15), %r15
testq %r15, %r15
jne 0x43fa
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4e2a
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, 0x8(%rsp)
movq (%rdi), %rdi
callq 0x4ea2
testq %rax, %rax
je 0x44f8
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x4fba
testq %rax, %rax
je 0x457d
movq 0x28(%rax), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x4567
movq %r15, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x4571
movl $0x18, %edi
callq 0x32f0
movq %rax, %r12
leaq 0x10(%rsp), %rsi
movq %r15, (%rsi)
leaq 0x7(%rsp), %rcx
movl $0x1, %edx
movq %rax, %rdi
callq 0x4dbe
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x3aba
movq %r12, 0x20(%r14)
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x51ae
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x4571
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3300
jmp 0x4571
leaq 0x8(%rsp), %rdx
callq 0x4ff4
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x9b33(%rip), %rdi      # 0xe0b7
callq 0x3420
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x45b0
movq 0x20(%rsp), %rsi
incq %rsi
jmp 0x45ab
movq %rax, %rbx
movl $0x18, %esi
movq %r12, %rdi
callq 0x3300
movq %rbx, %rdi
callq 0x3540
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
testq %rdx, %rdx
je 0x4692
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x4ea2
testq %rax, %rax
je 0x464b
movq (%r14), %rdi
movq %r15, %rsi
callq 0x4fba
testq %rax, %rax
je 0x469f
movq (%rbx), %rcx
cmpq %rcx, 0x8(%rbx)
je 0x4692
movq 0x28(%rax), %r14
movl $0x1, %ebp
xorl %eax, %eax
leaq (%rcx,%rax,8), %rdx
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x462a
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x4632
movq %r14, %rdi
callq 0x4ff4
movl %ebp, %eax
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
incl %ebp
cmpq %rax, %rdx
ja 0x460f
jmp 0x4692
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3aba
movq %rbx, 0x20(%r15)
movq (%r14), %rdi
movq %r15, %rsi
callq 0x51ae
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4692
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3300
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9a11(%rip), %rdi      # 0xe0b7
callq 0x3420
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x46c5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3300
movq %rbx, %rdi
callq 0x3540
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %rax
movq 0x10(%rax), %r12
testq %r12, %r12
je 0x477a
movq %rsi, %rbx
leaq 0xf(%rsp), %r14
movq 0x28(%r12), %rax
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0x476d
movl $0x1, %ebp
xorl %r15d, %r15d
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %rbx, %rdi
callq 0x3360
movb $0x9, 0xf(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x3360
movq 0x28(%r12), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r15, %rdx
jbe 0x4787
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0x41b8
movq 0x28(%r12), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
movl %ebp, %r15d
sarq $0x3, %rcx
incl %ebp
cmpq %r15, %rcx
ja 0x4708
movq (%r12), %r12
testq %r12, %r12
jne 0x46f2
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9982(%rip), %rdi      # 0xe110
movq %r15, %rsi
xorl %eax, %eax
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl %edx, %esi
callq 0x3ee6
testb %al, %al
je 0x4865
movl %ebp, 0x4(%rsp)
movq (%rbx), %rax
movq 0x10(%rax), %r13
testq %r13, %r13
je 0x4840
movq 0x28(%r13), %rax
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0x483a
leaq 0x8(%r13), %r15
movl $0x1, %ebp
xorl %r12d, %r12d
movq %r14, %rdi
movq %r15, %rsi
callq 0x40c6
movq %rax, %rdi
movl $0x9, %esi
callq 0x407c
movq 0x28(%r13), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r12, %rdx
jbe 0x4874
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
callq 0x4230
movq 0x28(%r13), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
movl %ebp, %r12d
sarq $0x3, %rcx
incl %ebp
cmpq %r12, %rcx
ja 0x47e6
movq (%r13), %r13
jmp 0x47c8
movq %r14, %rdi
callq 0x3f06
cmpb $0x0, 0x4(%rsp)
je 0x4865
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x43e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9895(%rip), %rdi      # 0xe110
movq %r12, %rsi
xorl %eax, %eax
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl %edx, %esi
callq 0x3ee6
testb %al, %al
je 0x4953
movl %ebp, 0x4(%rsp)
movq (%rbx), %rax
movq 0x10(%rax), %r13
testq %r13, %r13
je 0x492e
movq 0x28(%r13), %rax
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0x4928
leaq 0x8(%r13), %r15
movl $0x1, %ebp
xorl %r12d, %r12d
movq %r14, %rdi
movq %r15, %rsi
callq 0x40c6
movq %rax, %rdi
movl $0x9, %esi
callq 0x407c
movq 0x28(%r13), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r12, %rdx
jbe 0x4962
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
callq 0x4230
movq 0x28(%r13), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
movl %ebp, %r12d
sarq $0x3, %rcx
incl %ebp
cmpq %r12, %rcx
ja 0x48d4
movq (%r13), %r13
jmp 0x48b6
movq %r14, %rdi
callq 0x3f06
cmpb $0x0, 0x4(%rsp)
je 0x4953
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x43e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x97a7(%rip), %rdi      # 0xe110
movq %r12, %rsi
xorl %eax, %eax
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O3/ridgelab[P]Kmer-SSR/src/SSRcontainer.cpp
// Function: SSRcontainer::toString[abi:cxx11]() const
string SSRcontainer::toString() const
{
	string output = "SSRcontainer: { ";
	
	for (unordered_map<string, vector<SSR*>*>::iterator itr = this->ssrs->begin(); itr != this->ssrs->end(); ++itr)
	{
		if (itr != this->ssrs->begin())
		{
			output += ", ";
		}
		
		output += itr->first + ": { ";

		for (uint32_t i = 0; i < itr->second->size(); ++i)
		{
			if (i != 0)
			{
				output += ", ";
			}
			
			output += itr->second->at(i)->toString();
		}

		output += " }";
	}

	output += " }";

	return output;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x28(%rsp)
movq %rax, (%rdi)
leaq 0x96ef(%rip), %rsi      # 0xe08a
leaq 0x96f8(%rip), %rdx      # 0xe09a
callq 0x54f4
movq %r14, 0x30(%rsp)
movq (%r14), %r14
addq $0x10, %r14
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r15
movq (%r14), %r14
testq %r14, %r14
je 0x4ae3
movq 0x30(%rsp), %rax
movq (%rax), %rax
cmpq 0x10(%rax), %r14
je 0x49e6
movq %rbx, %rdi
leaq 0x96ba(%rip), %rsi      # 0xe09b
callq 0x35b0
movq %r13, 0x8(%rsp)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x3aba
movq %r15, %rdi
leaq 0x98d4(%rip), %rsi      # 0xe2dc
callq 0x35b0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x3100
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x4a36
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3300
movq 0x28(%r14), %rcx
movq (%rcx), %rax
cmpq %rax, 0x8(%rcx)
je 0x4acf
movl $0x1, %ebp
xorl %r12d, %r12d
cmpl $0x1, %ebp
je 0x4a6a
movq %rbx, %rdi
leaq 0x963d(%rip), %rsi      # 0xe09b
callq 0x35b0
movq 0x28(%r14), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r12, %rdx
jbe 0x4b04
movq (%rax,%r12,8), %rsi
movq %r15, %rdi
callq 0x427e
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x3100
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x4ab3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3300
movl %ebp, %r12d
movq 0x28(%r14), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
incl %ebp
cmpq %r12, %rdx
ja 0x4a4f
movq %rbx, %rdi
leaq 0x96d9(%rip), %rsi      # 0xe1b2
callq 0x35b0
jmp 0x49bd
leaq 0x96c8(%rip), %rsi      # 0xe1b2
movq %rbx, %rdi
callq 0x35b0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9605(%rip), %rdi      # 0xe110
movq %r12, %rsi
xorl %eax, %eax
callq 0x3450
jmp 0x4b3f
jmp 0x4b3f
jmp 0x4b23
jmp 0x4b23
jmp 0x4b3f
jmp 0x4b3f
jmp 0x4b3f
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x4b42
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3300
jmp 0x4b42
movq %rax, %r14
movq (%rbx), %rdi
movq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x4b5a
movq (%rax), %rsi
incq %rsi
callq 0x3300
movq %r14, %rdi
callq 0x3540
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x5d5b
movq 0x10(%r15), %r14
testq %r14, %r14
je 0x5d43
movq %r14, %rdi
callq 0x637c
movl $0x38, %esi
movq %r14, %rdi
callq 0x3300
movq (%r15), %r15
testq %r15, %r15
jne 0x5d32
movq (%rbx), %rdi
callq 0x6678
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x5d70
movq %rbx, %rdi
callq 0x6652
movl $0x38, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3300
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movl 0x8(%rsi), %ebp
movl %ebp, %esi
callq 0x5dcc
movq 0x10(%rax), %r15
movb $0x1, %bl
testq %r15, %r15
je 0x5dbe
movl 0x8(%r15), %esi
cmpl %ebp, %esi
je 0x5db7
movq %r14, %rdx
movl %ebp, %ecx
callq 0x5f4a
testb %al, %al
je 0x5dbc
movq (%r15), %r15
jmp 0x5d9c
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ridgelab[P]Kmer-SSR/src/AtomicityChecker.cpp
// Function: AtomicityChecker::calculateFactors(unsigned int)
unordered_set<uint32_t>* AtomicityChecker::calculateFactors(uint32_t x)
{
	if (this->factors->count(x))
	{
		return this->factors->at(x);
	}

	if (x == 1)
	{
		this->safeInsert(1, new unordered_set<uint32_t>( {1} ) );
		return this->factors->at(x);
	}
	
	unordered_set<uint32_t>* xfactors = new unordered_set<uint32_t>( {1, x} );

	for (uint32_t i = 2; i <= (x / 2); ++i)
	{
		if ( (x % i) == 0) // english: if i is a factor of x
		{
			xfactors->insert(i); // add i to xfactors

			if (!this->factors->count(i)) // if i is not in this->factors
			{
				this->safeInsert(i, this->calculateFactors(i)); // add it
			}
		}
	}

	this->safeInsert(x, xfactors);
	return this->factors->at(x);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x14(%rsp), %rax
movl %esi, (%rax)
movq (%rdi), %rdi
movq %rax, %rsi
callq 0x6f40
testq %rax, %rax
jne 0x5f01
movl 0x14(%rsp), %ebp
movl $0x38, %edi
callq 0x32f0
movq %rax, %r14
cmpl $0x1, %ebp
jne 0x5e47
leaq 0x1c(%rsp), %rdx
movl $0x1, -0x4(%rdx)
leaq 0xe(%rsp), %rax
movq %rax, (%rsp)
leaq 0x18(%rsp), %rsi
leaq 0x10(%rsp), %r8
leaq 0xf(%rsp), %r9
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x6800
movq %rbx, %rdi
movl $0x1, %esi
jmp 0x5ef9
leaq 0x20(%rsp), %rdx
movl $0x1, -0x8(%rdx)
movl %ebp, -0x4(%rdx)
leaq 0xe(%rsp), %rax
movq %rax, (%rsp)
leaq 0x18(%rsp), %rsi
leaq 0x10(%rsp), %r8
leaq 0xf(%rsp), %r9
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x6800
movl $0x2, 0x10(%rsp)
movl 0x14(%rsp), %eax
cmpl $0x4, %eax
jb 0x5ef4
movl $0x2, %ebp
leaq 0x10(%rsp), %r15
leaq 0x18(%rsp), %r12
xorl %edx, %edx
divl %ebp
testl %edx, %edx
jne 0x5ee2
movq %r14, 0x18(%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x6900
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x6f40
movl 0x10(%rsp), %ebp
testq %rax, %rax
jne 0x5ee2
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5dcc
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x6264
movl 0x10(%rsp), %ebp
incl %ebp
movl %ebp, 0x10(%rsp)
movl 0x14(%rsp), %eax
movl %eax, %ecx
shrl %ecx
cmpl %ecx, %ebp
jbe 0x5e98
movq %rbx, %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0x6264
movq (%rbx), %rdi
leaq 0x14(%rsp), %rsi
callq 0x722e
testq %rax, %rax
je 0x5f24
movq 0x10(%rax), %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x818c(%rip), %rdi      # 0xe0b7
callq 0x3420
jmp 0x5f32
movq %rax, %rbx
movl $0x38, %esi
movq %r14, %rdi
callq 0x3300
movq %rbx, %rdi
callq 0x3540
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
movl %ecx, 0x4(%rsp)
testl %ecx, %ecx
je 0x6024
movq %rdx, %r14
movl %ebp, %r15d
xorl %r12d, %r12d
movl $0x1, %ebx
movl %ebp, (%rsp)
movl %r12d, %edx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x3320
addl %ebp, %r12d
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x3320
movq 0x10(%rsp), %rdx
cmpq 0x30(%rsp), %rdx
jne 0x5fcb
movq 0x28(%rsp), %r13
testq %rdx, %rdx
je 0x5fd5
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x3310
testl %eax, %eax
setne %bpl
jmp 0x5fd7
movb $0x1, %bpl
movq 0x28(%rsp), %r13
jmp 0x5fd7
xorl %ebp, %ebp
leaq 0x38(%rsp), %rax
cmpq %rax, %r13
je 0x5ff1
movq 0x38(%rsp), %rsi
incq %rsi
movq %r13, %rdi
callq 0x3300
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x600d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3300
testb %bpl, %bpl
jne 0x602b
incl %ebx
cmpl 0x4(%rsp), %r12d
movl (%rsp), %ebp
jb 0x5f77
jmp 0x602e
movl $0x1, %ebx
jmp 0x602e
movl (%rsp), %ebp
movl 0x4(%rsp), %eax
xorl %edx, %edx
divl %ebp
cmpl %eax, %ebx
setne %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x6069
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3300
movq %rbx, %rdi
callq 0x3540
nop
// File: /workspace/github_cpp_makefile_star2_O3/ridgelab[P]Kmer-SSR/src/AtomicityChecker.cpp
// Function: AtomicityChecker::toString[abi:cxx11]() const
string AtomicityChecker::toString() const
{
	stringstream strm;
	strm << "AtomicityChecker: { factors: { ";

	for (unordered_map<uint32_t, unordered_set<uint32_t>*>::iterator itr = this->factors->begin(); itr != this->factors->end(); ++itr)
	{
		if (itr != this->factors->begin())
		{
			strm << ", ";
		}

		strm << itr->first << ": { ";

		for (unordered_set<uint32_t>::iterator inner_itr = itr->second->begin(); inner_itr != itr->second->end(); ++inner_itr)
		{
			if (inner_itr != itr->second->begin())
			{
				strm << ", ";
			}
			strm << *inner_itr;
		}

		strm << " }";
	}

	strm << " } }";
	return strm.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3200
leaq 0x20(%rsp), %r14
leaq 0x80f1(%rip), %rsi      # 0xe190
movl $0x1f, %edx
movq %r14, %rdi
callq 0x3360
movq %rbx, 0x8(%rsp)
movq (%r15), %rbx
addq $0x10, %rbx
leaq 0x80f3(%rip), %r13      # 0xe1b2
leaq 0x7fd5(%rip), %rbp      # 0xe09b
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x6159
movq (%r15), %rax
cmpq 0x10(%rax), %rbx
je 0x60eb
movl $0x2, %edx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x3360
movl 0x8(%rbx), %esi
movq %r14, %rdi
callq 0x31e0
movl $0x4, %edx
movq %rax, %rdi
leaq 0x81d7(%rip), %rsi      # 0xe2dc
callq 0x3360
movq 0x10(%rbx), %r12
addq $0x10, %r12
movq (%r12), %r12
testq %r12, %r12
je 0x6144
movq 0x10(%rbx), %rax
cmpq 0x10(%rax), %r12
je 0x6135
movl $0x2, %edx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x3360
movl 0x8(%r12), %esi
movq %r14, %rdi
callq 0x31e0
jmp 0x6112
movl $0x2, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x3360
jmp 0x60c6
leaq 0x8050(%rip), %rsi      # 0xe1b0
movl $0x4, %edx
movq %r14, %rdi
callq 0x3360
movq 0x8(%rsp), %rbx
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x3490
movq 0xedfa(%rip), %rsi      # 0x14f80
leaq 0x10(%rsp), %rdi
callq 0x3240
leaq 0x90(%rsp), %rdi
callq 0x3110
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x61b6
jmp 0x61b6
movq %rax, %rbx
movq 0xedc0(%rip), %rsi      # 0x14f80
leaq 0x10(%rsp), %rdi
callq 0x3240
leaq 0x90(%rsp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3540
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %r15
leaq 0x4(%rsp), %r12
movl %esi, (%r12)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x31b0
movq (%r15), %rdi
movq %r12, %rsi
callq 0x6f40
testq %rax, %rax
je 0x62ce
movq (%r15), %rdi
leaq 0x4(%rsp), %rsi
callq 0x722e
testq %rax, %rax
je 0x62f9
cmpq %r14, 0x10(%rax)
je 0x62e5
testq %r14, %r14
je 0x62bf
movq %r14, %rdi
callq 0x637c
movl $0x38, %esi
movq %r14, %rdi
callq 0x3300
jmp 0x62e5
movl 0x4(%rsp), %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movq %r14, 0x8(%rsi)
movq (%r15), %rdi
callq 0x6f9c
movq %rbx, %rdi
callq 0x34e0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x7db7(%rip), %rdi      # 0xe0b7
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O3/ridgelab[P]Kmer-SSR/src/FindSSRs.cpp
// Function: FindSSRs::FindSSRs(Arguments*)
FindSSRs::FindSSRs(Arguments* _args)
{
	this->args = _args;
	this->out_file = new OutputFile(this->args->getOutFileName());
	this->out_file->write("#Sequence_Name\tSSR\tRepeats\tPosition\n");
	this->progress_bar = new ProgressMeter(this->args->displayProgressBar());
	this->atomicity_checker = new AtomicityChecker();
	this->tasks = new TaskQueue(this->args->getMaxTaskQueueSize());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
movq %rsi, (%rdi)
movl $0x220, %edi            # imm = 0x220
callq 0x32f0
movq %rax, %r15
movq %rsp, %rdi
movq %r14, %rsi
callq 0xb850
movq %rsp, %rsi
movq %r15, %rdi
callq 0x3b84
movq %r15, 0x20(%rbx)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x72f3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3300
movq 0x20(%rbx), %r15
leaq 0x6ebb(%rip), %rsi      # 0xe1b5
movq %r15, %rdi
callq 0x3f56
movl $0x38, %edi
callq 0x32f0
movq %rax, %r15
movq (%rbx), %rdi
callq 0xb6b0
movzbl %al, %esi
movq %r15, %rdi
callq 0xd5b8
movq %r15, 0x28(%rbx)
movl $0x28, %edi
callq 0x32f0
movq %rax, %r15
movq %rax, %rdi
callq 0x558c
movq %r15, 0x30(%rbx)
movl $0x68, %edi
callq 0x32f0
movq %rax, %r15
movq (%rbx), %rdi
callq 0xb6b4
movq %r15, %rdi
movl %eax, %esi
callq 0x9736
movq %r15, 0x38(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x28, %esi
jmp 0x73b2
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7399
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3300
jmp 0x7399
movq %rax, %r14
movl $0x220, %esi            # imm = 0x220
jmp 0x73b2
movq %rax, %r14
movl $0x68, %esi
jmp 0x73b2
movq %rax, %r14
movl $0x38, %esi
movq %r15, %rdi
callq 0x3300
jmp 0x73bf
movq %rax, %r14
leaq 0x8(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x73d7
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x3300
movq %r14, %rdi
callq 0x3540
nop
// File: /workspace/github_cpp_makefile_star2_O3/ridgelab[P]Kmer-SSR/src/FindSSRs.cpp
// Function: FindSSRs::~FindSSRs()
FindSSRs::~FindSSRs()
{
	delete this->out_file;
	delete this->progress_bar;
	delete this->atomicity_checker;
	delete this->tasks;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
testq %r14, %r14
je 0x73f8
movq %r14, %rdi
callq 0x3e10
movl $0x220, %esi            # imm = 0x220
movq %r14, %rdi
callq 0x3300
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x7416
movq %r14, %rdi
callq 0xd5f4
movl $0x38, %esi
movq %r14, %rdi
callq 0x3300
movq 0x30(%rbx), %r14
testq %r14, %r14
je 0x7434
movq %r14, %rdi
callq 0x5d1e
movl $0x28, %esi
movq %r14, %rdi
callq 0x3300
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x7452
movq %r14, %rdi
callq 0x973c
movl $0x68, %esi
movq %r14, %rdi
callq 0x3300
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x747b
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3300
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ridgelab[P]Kmer-SSR/src/FindSSRs.cpp
// Function: FindSSRs::run()
uint32_t FindSSRs::run()
{
	// set up consumers
	uint32_t error = this->makeThreads(); // set up consumers

	if (error)
	{
		return error;
	}

	// find the ssrs in the sequences
	try
	{
		this->processInput(); // produce (and consume if only main thread)
	}
	catch (string e)
	{
		cerr << e << endl;
		return 1;
	}
	catch (const char* e)
	{
		cerr << e << endl;
		return 1;
	}

	// join threads
	//cerr << "About to start joining threads..." << endl;
	//usleep(3000000);
	this->joinAndForgetAllThreads(); // clean up consumers

	// we're done!
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x758a
testl %eax, %eax
jne 0x74a9
movq %rbx, %rdi
callq 0x768e
movq %rbx, %rdi
callq 0x7bd0
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
cmpl $0x2, %edx
jne 0x751d
movq %rbx, %rdi
callq 0x33b0
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x3aba
movq %rbx, %rdi
callq 0x3130
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0xdaf9(%rip), %rdi      # 0x14ff0
callq 0x3360
movq %rax, %rdi
callq 0x3150
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x7541
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3300
jmp 0x7541
cmpl $0x1, %edx
jne 0x7579
movq %rbx, %rdi
callq 0x3130
movq 0xdabf(%rip), %rdi      # 0x14ff0
movq %rax, %rsi
callq 0x32e0
movq %rax, %rdi
callq 0x3150
callq 0x34c0
movl $0x1, %eax
jmp 0x74a9
movq %rax, %rbx
callq 0x34c0
jmp 0x7579
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x7574
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3300
callq 0x34c0
movq %rbx, %rdi
callq 0x3540
movq %rax, %rdi
callq 0x3aae
nop
// File: /workspace/github_cpp_makefile_star2_O3/ridgelab[P]Kmer-SSR/src/FindSSRs.cpp
// Function: FindSSRs::makeThreads()
uint32_t FindSSRs::makeThreads()
{
	pthread_attr_t tattr;
	pthread_attr_init(&tattr);
	pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_JOINABLE);
	//pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
	
	for (uint32_t i = 1; i < this->args->getNumThreads(); ++i)
	{
		pthread_t thread;
		this->threads.push_back(thread);

		if ( pthread_create(&(this->threads[this->threads.size() - 1]), &tattr, &consume, (void*) new ConsumerArguments(this->tasks, this->progress_bar, this->out_file, this->atomicity_checker, this->args)) != 0 )
		{
			perror("creating threads");
			return errno;
		}
	}

	pthread_attr_destroy(&tattr);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x3390
movq %rbx, %rdi
xorl %esi, %esi
callq 0x33c0
movq (%r14), %rdi
callq 0xb6e4
cmpl $0x2, %eax
jb 0x765e
leaq 0x8(%r14), %r15
movl $0x1, %r12d
leaq 0x68d(%rip), %r13       # 0x7c61
leaq 0x10(%rsp), %rbp
movq 0x10(%r14), %rbx
cmpq 0x18(%r14), %rbx
je 0x75ed
addq $0x8, %rbx
movq %rbx, 0x10(%r14)
jmp 0x7601
movq %r15, %rdi
movq %rbx, %rsi
leaq 0x8(%rsp), %rdx
callq 0x8d6e
movq 0x10(%r14), %rbx
addq $-0x8, %rbx
movl $0x28, %edi
callq 0x32f0
movq 0x38(%r14), %rcx
movq (%r14), %rdx
movq 0x30(%r14), %rsi
movq %rcx, (%rax)
movdqu 0x20(%r14), %xmm0
pshufd $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movdqu %xmm0, 0x8(%rax)
movq %rsi, 0x18(%rax)
movq %rdx, 0x20(%rax)
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %rax, %rcx
callq 0x3570
testl %eax, %eax
jne 0x7679
incl %r12d
movq (%r14), %rdi
callq 0xb6e4
cmpl %eax, %r12d
jb 0x75d9
leaq 0x10(%rsp), %rdi
callq 0x34d0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6b5a(%rip), %rdi      # 0xe1da
callq 0x3270
callq 0x3040
movl (%rax), %eax
jmp 0x766a
// File: /workspace/github_cpp_makefile_star2_O3/ridgelab[P]Kmer-SSR/src/FindSSRs.cpp
// Function: FindSSRs::joinAndForgetAllThreads()
void FindSSRs::joinAndForgetAllThreads()
{
	for (uint32_t i = 0; i < this->threads.size(); ++i)
	{
		//cerr << "Attempting to join thread #" << i << " with ID=" << this->threads[i] << endl;
		long status = 0L;
		long* status_ptr = &status;

		int joinerr = 0;
		joinerr = pthread_join(this->threads[i],(void**) &status_ptr); //if ( pthread_join(this->threads[i],(void**) &status_ptr) != 0)
		if ( joinerr != 0 && joinerr != EINVAL)
		{
			perror("joining thread");
			//cerr << "joinerr,errno" << joinerr << "," << errno << endl;
		}
	}

	this->threads.clear();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdx
cmpq %rax, %rdx
je 0x7c4b
movl $0x1, %ebp
xorl %ecx, %ecx
leaq 0x8(%rsp), %r12
movq %rsp, %r14
leaq 0x65e9(%rip), %r15      # 0xe1eb
movq $0x0, 0x8(%rsp)
movq %r12, (%rsp)
movq (%rax,%rcx,8), %rdi
movq %r14, %rsi
callq 0x32c0
testl %eax, %eax
je 0x7c24
cmpl $0x16, %eax
jne 0x7c41
movl %ebp, %ecx
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdx
movq %rdx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
incl %ebp
cmpq %rcx, %rsi
ja 0x7c02
jmp 0x7c4b
movq %r15, %rdi
callq 0x3270
jmp 0x7c24
cmpq %rax, %rdx
je 0x7c54
movq %rax, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq