LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: xiangzejun[P]Optimizing_Implementations_of_Linear_Layers/strategy.cpp
// Function: update_seq_str(std::vector<xpair, std::allocator<xpair>>, int*)
vector<xpair> update_seq_str(vector<xpair> seq, int tab[SIZE])
{	
	vector<xpair> tmp_seq;
	for(int i = 0; i < seq.size(); i++)
	{	
		if(!seq[i].flag)
		{
			tmp_seq.push_back(seq[i]);
		}
	}

	for(int i = seq.size() - 1; i >= 0; i--)
	{	

		if(seq[i].flag)
		{	
			xpair new_ele;
			new_ele.src = tab[seq[i].dst];
			new_ele.dst = tab[seq[i].src];
			new_ele.flag = false;
			tmp_seq.push_back(new_ele);
		}
	}
	return tmp_seq;
}

// Assembly:
subq $0x78, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movb $0x0, 0x5f(%rsp)
callq 0x5d30
movl $0x0, 0x58(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x3280
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x4f4c
movq 0x20(%rsp), %rdi
movslq 0x58(%rsp), %rsi
callq 0x3430
testb $0x1, 0x8(%rax)
jne 0x4f3a
movq 0x20(%rsp), %rdi
movslq 0x58(%rsp), %rsi
callq 0x3430
movq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x5de0
jmp 0x4f1b
jmp 0x4f3a
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0x3220
jmp 0x501f
jmp 0x4f3c
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x4ec7
movq 0x20(%rsp), %rdi
callq 0x3280
subq $0x1, %rax
movl %eax, 0x48(%rsp)
cmpl $0x0, 0x48(%rsp)
jl 0x4fff
movq 0x20(%rsp), %rdi
movslq 0x48(%rsp), %rsi
callq 0x3430
testb $0x1, 0x8(%rax)
je 0x4fed
movq 0x20(%rsp), %rdi
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movslq 0x48(%rsp), %rsi
callq 0x3430
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movq 0x8(%rsp), %rax
movslq 0x4(%rcx), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x3c(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movslq 0x48(%rsp), %rsi
callq 0x3430
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movq 0x10(%rsp), %rax
movslq (%rcx), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x40(%rsp)
movb $0x0, 0x44(%rsp)
leaq 0x3c(%rsp), %rsi
callq 0x5de0
jmp 0x4feb
jmp 0x4fed
jmp 0x4fef
movl 0x48(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x4f5e
movb $0x1, 0x5f(%rsp)
testb $0x1, 0x5f(%rsp)
jne 0x5015
movq 0x28(%rsp), %rdi
callq 0x3220
movq 0x30(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x22a0
nopl (%rax)
// File: xiangzejun[P]Optimizing_Implementations_of_Linear_Layers/strategy.cpp
// Function: get_ones(std::vector<std::bitset<32ul>, std::allocator<std::bitset<32ul>>>)
int get_ones(vector<ROW> m)
{
	int s = 0;
	for(int i = 0; i < m.size(); i++)
		s += m[i].count();
	return s;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x32a0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x5ab2
movq 0x10(%rsp), %rdi
movslq 0x18(%rsp), %rsi
callq 0x33d0
movq %rax, %rdi
callq 0x60b0
movq %rax, %rcx
movslq 0x1c(%rsp), %rax
addq %rcx, %rax
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x5a5e
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: xiangzejun[P]Optimizing_Implementations_of_Linear_Layers/matrix.cpp
// Function: get_matrix()
vector<ROW> get_matrix()
{
	vector<ROW> m{
				0x01818080,
				0x81c14040,
				0x40602020,
				0x21311010,
				0x11190808,
				0x080c0404,
				0x04060202,
				0x02030101,
				0x80018180,
				0x4081c140,
				0x20406020,
				0x10213110,
				0x08111908,
				0x04080c04,
				0x02040602,
				0x01020301,
				0x80800181,
				0x404081c1,
				0x20204060,
				0x10102131,
				0x08081119,
				0x0404080c,
				0x02020406,
				0x01010203,
				0x81808001,
				0xc1404081,
				0x60202040,
				0x31101021,
				0x19080811,
				0x0c040408,
				0x06020204,
				0x03010102
	};
	return m;
}

// Assembly:
subq $0x158, %rsp            # imm = 0x158
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0x150(%rsp)
movb $0x0, 0x14f(%rsp)
leaq 0x5916(%rip), %rsi      # 0xe0e0
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x100, %edx            # imm = 0x100
callq 0x20f0
movq 0x8(%rsp), %rax
movq %rax, 0x138(%rsp)
movq $0x20, 0x140(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x62e0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq 0x138(%rsp), %rsi
movq 0x140(%rsp), %rdx
callq 0x8880
jmp 0x8827
leaq 0x37(%rsp), %rdi
callq 0x36e0
movb $0x1, 0x14f(%rsp)
testb $0x1, 0x14f(%rsp)
jne 0x8869
jmp 0x885f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x37(%rsp), %rdi
callq 0x36e0
jmp 0x8875
movq 0x10(%rsp), %rdi
callq 0x30c0
movq (%rsp), %rax
addq $0x158, %rsp            # imm = 0x158
retq
movq 0x28(%rsp), %rdi
callq 0x22a0
nop
// File: xiangzejun[P]Optimizing_Implementations_of_Linear_Layers/reduce.cpp
// Function: get_reduced_matrix(std::vector<xpair, std::allocator<xpair>>, std::vector<std::bitset<32ul>, std::allocator<std::bitset<32ul>>>)
vector<ROW> get_reduced_matrix(vector<xpair> seq, vector<ROW> m)
{
	vector<ROW> tmp_m(m);
	for(int i = 0; i < seq.size(); i++)
		tmp_m[seq[i].dst] ^= tmp_m[seq[i].src];
	return tmp_m;
}

// Assembly:
subq $0x58, %rsp
movq %rdx, 0x18(%rsp)
movq %rsi, %rax
movq 0x18(%rsp), %rsi
movq %rax, 0x20(%rsp)
movq %rdi, 0x28(%rsp)
movq %rdi, %rcx
movq %rcx, 0x30(%rsp)
movq %rdi, 0x50(%rsp)
movq %rax, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movb $0x0, 0x3f(%rsp)
callq 0x2fc0
movl $0x0, 0x38(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x3280
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x8d4d
movq 0x20(%rsp), %rdi
movslq 0x38(%rsp), %rsi
callq 0x3430
movq 0x28(%rsp), %rdi
movslq (%rax), %rsi
callq 0x33d0
movq 0x20(%rsp), %rdi
movq %rax, 0x8(%rsp)
movslq 0x38(%rsp), %rsi
callq 0x3430
movq 0x28(%rsp), %rdi
movslq 0x4(%rax), %rsi
callq 0x33d0
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x3450
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x8cd4
movb $0x1, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0x8d63
movq 0x28(%rsp), %rdi
callq 0x30c0
movq 0x30(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: xiangzejun[P]Optimizing_Implementations_of_Linear_Layers/reduce.cpp
// Function: get_identity()
vector<ROW> get_identity()
{
	vector<ROW> m;
	ROW tmp(0);
	for(int i = 0; i < SIZE; i++)
	{
		m.push_back(tmp);
		m[i][SIZE - 1 - i] = 1;
	}
	return m;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x50(%rsp)
movb $0x0, 0x4f(%rsp)
callq 0x5e50
leaq 0x40(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x60e0
movl $0x0, 0x3c(%rsp)
cmpl $0x20, 0x3c(%rsp)
jge 0x8e2a
movq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x61d0
jmp 0x8dbe
movq 0x8(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0x33d0
movq %rax, %rsi
movl 0x3c(%rsp), %ecx
movl $0x1f, %eax
subl %ecx, %eax
movslq %eax, %rdx
leaq 0x18(%rsp), %rdi
callq 0x5d50
jmp 0x8dea
leaq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0xc7c0
leaq 0x18(%rsp), %rdi
callq 0x5dd0
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x8da6
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x30c0
jmp 0x8e4a
movb $0x1, 0x4f(%rsp)
testb $0x1, 0x4f(%rsp)
jne 0x8e40
movq 0x8(%rsp), %rdi
callq 0x30c0
movq 0x10(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x22a0
nopw %cs:(%rax,%rax)
// File: xiangzejun[P]Optimizing_Implementations_of_Linear_Layers/reduce.cpp
// Function: exchange(xpair, xpair)
bool exchange(xpair a, xpair b)
{
	if(a.dst == b.dst)
		return true;
	if(a.src == b.src)
		return true;
	if((a.src != b.dst) && (a.dst != b.src))
		return true;
	return false;
}

// Assembly:
movb %cl, %al
movb %sil, %cl
movq %rdi, -0x20(%rsp)
movb %cl, -0x18(%rsp)
movq -0x20(%rsp), %rcx
movq %rcx, -0x10(%rsp)
movl -0x18(%rsp), %ecx
movl %ecx, -0x8(%rsp)
movq %rdx, -0x3c(%rsp)
movb %al, -0x34(%rsp)
movq -0x3c(%rsp), %rax
movq %rax, -0x2c(%rsp)
movl -0x34(%rsp), %eax
movl %eax, -0x24(%rsp)
movl -0xc(%rsp), %eax
cmpl -0x28(%rsp), %eax
jne 0x8eac
movb $0x1, -0x1(%rsp)
jmp 0x8edd
movl -0x10(%rsp), %eax
cmpl -0x2c(%rsp), %eax
jne 0x8ebd
movb $0x1, -0x1(%rsp)
jmp 0x8edd
movl -0x10(%rsp), %eax
cmpl -0x28(%rsp), %eax
je 0x8ed8
movl -0xc(%rsp), %eax
cmpl -0x2c(%rsp), %eax
je 0x8ed8
movb $0x1, -0x1(%rsp)
jmp 0x8edd
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: xiangzejun[P]Optimizing_Implementations_of_Linear_Layers/reduce.cpp
// Function: delete_table(int**, int)
void delete_table(int** table, int size)
{
	if(table != NULL)
	{
		for(int i = 0; i < size; i++)
			delete[] table[i];
		delete[] table;
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x9385
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x9369
movq 0x20(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x935a
movq 0x10(%rsp), %rdi
callq 0x21b0
jmp 0x935c
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x932d
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x9383
movq 0x8(%rsp), %rdi
callq 0x21b0
jmp 0x9385
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: xiangzejun[P]Optimizing_Implementations_of_Linear_Layers/reduce.cpp
// Function: exchange_set(std::vector<xpair, std::allocator<xpair>>, int, int, xpair)
bool exchange_set(vector<xpair> seq, int start, int end, xpair p)
{
	if(start <= end)
	{
		for(int i = start; i <= end; i++)
		{
			if(!exchange(p, seq[i]))
				return false;
		}
	}
	else
	{
		for(int i = start; i >= end; i--)
		{
			if(!exchange(p, seq[i]))
				return false;
		}
	}
	return true;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0x8(%rsp)
movb %r8b, %al
movq %rcx, 0x98(%rsp)
movb %al, 0xa0(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0xa8(%rsp)
movl 0xa0(%rsp), %eax
movl %eax, 0xb0(%rsp)
movq %rdi, 0x90(%rsp)
movl %esi, 0x8c(%rsp)
movl %edx, 0x88(%rsp)
movl 0x8c(%rsp), %eax
cmpl 0x88(%rsp), %eax
jg 0x94c4
movl 0x8c(%rsp), %eax
movl %eax, 0x84(%rsp)
movl 0x84(%rsp), %eax
cmpl 0x88(%rsp), %eax
jg 0x94bf
movq 0x8(%rsp), %rdi
movq 0xa8(%rsp), %rax
movq %rax, 0x78(%rsp)
movl 0xb0(%rsp), %eax
movl %eax, 0x80(%rsp)
movslq 0x84(%rsp), %rsi
callq 0x3430
movq (%rax), %rcx
movq %rcx, 0x6c(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x74(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x5c(%rsp)
movl 0x80(%rsp), %eax
movl %eax, 0x64(%rsp)
movq 0x5c(%rsp), %rdi
movb 0x64(%rsp), %al
movq 0x6c(%rsp), %rcx
movq %rcx, 0x4c(%rsp)
movl 0x74(%rsp), %ecx
movl %ecx, 0x54(%rsp)
movq 0x4c(%rsp), %rdx
movzbl %al, %esi
movzbl 0x54(%rsp), %ecx
callq 0x8e60
testb $0x1, %al
jne 0x94a7
movb $0x0, 0xb7(%rsp)
jmp 0x957f
jmp 0x94a9
movl 0x84(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x84(%rsp)
jmp 0x9404
jmp 0x9577
movl 0x8c(%rsp), %eax
movl %eax, 0x48(%rsp)
movl 0x48(%rsp), %eax
cmpl 0x88(%rsp), %eax
jl 0x9575
movq 0x8(%rsp), %rdi
movq 0xa8(%rsp), %rax
movq %rax, 0x3c(%rsp)
movl 0xb0(%rsp), %eax
movl %eax, 0x44(%rsp)
movslq 0x48(%rsp), %rsi
callq 0x3430
movq (%rax), %rcx
movq %rcx, 0x30(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x38(%rsp)
movq 0x3c(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x44(%rsp), %eax
movl %eax, 0x28(%rsp)
movq 0x20(%rsp), %rdi
movb 0x28(%rsp), %al
movq 0x30(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movl 0x38(%rsp), %ecx
movl %ecx, 0x18(%rsp)
movq 0x10(%rsp), %rdx
movzbl %al, %esi
movzbl 0x18(%rsp), %ecx
callq 0x8e60
testb $0x1, %al
jne 0x9563
movb $0x0, 0xb7(%rsp)
jmp 0x957f
jmp 0x9565
movl 0x48(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x94cf
jmp 0x9577
movb $0x1, 0xb7(%rsp)
movb 0xb7(%rsp), %al
andb $0x1, %al
addq $0xb8, %rsp
retq
// File: xiangzejun[P]Optimizing_Implementations_of_Linear_Layers/reduce.cpp
// Function: reduce_thread(void*)
void* reduce_thread(void *d)
{
	thread_data* data = (thread_data*)d;
	get_equivalent_seq(data->seq, data->gap, data->start);
	data->len = reduce_step(data->seq);
	pthread_exit(NULL);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x18(%rax), %esi
movq 0x8(%rsp), %rax
movl 0x1c(%rax), %edx
callq 0xbc30
movq 0x8(%rsp), %rdi
callq 0xb5f0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x20(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x22b0
nopw (%rax,%rax)
// File: xiangzejun[P]Optimizing_Implementations_of_Linear_Layers/reduce.cpp
// Function: check_consistence(std::vector<xpair, std::allocator<xpair>>)
bool check_consistence(vector<xpair> seq)
{
	vector<ROW> m = get_matrix();
	for(int i = 0; i < seq.size(); i++)
		m[seq[i].dst] ^= m[seq[i].src];
	if(get_ones(m) == SIZE)
		return true;
	else
		return false;

}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, 0x68(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x87a0
movl $0x0, 0x4c(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x4c(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x3280
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0xc1a9
movq 0x18(%rsp), %rdi
movslq 0x4c(%rsp), %rsi
callq 0x3430
movslq (%rax), %rsi
leaq 0x50(%rsp), %rdi
callq 0x33d0
movq 0x18(%rsp), %rdi
movq %rax, 0x8(%rsp)
movslq 0x4c(%rsp), %rsi
callq 0x3430
movslq 0x4(%rax), %rsi
leaq 0x50(%rsp), %rdi
callq 0x33d0
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x3450
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0xc130
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x2fc0
jmp 0xc1ba
leaq 0x30(%rsp), %rdi
callq 0x5a40
movl %eax, 0x4(%rsp)
jmp 0xc1ca
leaq 0x30(%rsp), %rdi
callq 0x30c0
movl 0x4(%rsp), %eax
cmpl $0x20, %eax
jne 0xc216
movb $0x1, 0x77(%rsp)
movl $0x1, 0x20(%rsp)
jmp 0xc223
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0xc238
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x30c0
jmp 0xc238
movb $0x0, 0x77(%rsp)
movl $0x1, 0x20(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x30c0
movb 0x77(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
leaq 0x50(%rsp), %rdi
callq 0x30c0
movq 0x28(%rsp), %rdi
callq 0x22a0
nopl (%rax)
// File: adamnovak[P]rlcsa/sampler_test.cpp
// Function: printUsage()
void
printUsage()
{
  std::cout << "Usage: sampler_test [parameters] base_name weights" << std::endl;
  std::cout << "  -b   Use backward edge weights (locate for LF, display for Psi)." << std::endl;
  std::cout << "  -g#  Select # (float) part of samples greedily, and the rest at regular intervals." << std::endl;
  std::cout << "  -m#  Multiply weights by # (float)." << std::endl;
  std::cout << "  -t#  Use # threads." << std::endl;
  std::cout << "  -w   Write the sampled positions into sample file." << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x33365(%rip), %rdi     # 0x37fd0
leaq 0x244b7(%rip), %rsi     # 0x29129
callq 0x32a0
movq %rax, %rdi
movq 0x3332f(%rip), %rsi     # 0x37fb0
callq 0x3300
movq 0x33343(%rip), %rdi     # 0x37fd0
leaq 0x244c8(%rip), %rsi     # 0x2915c
callq 0x32a0
movq %rax, %rdi
movq 0x3330d(%rip), %rsi     # 0x37fb0
callq 0x3300
movq 0x33321(%rip), %rdi     # 0x37fd0
leaq 0x244e9(%rip), %rsi     # 0x2919f
callq 0x32a0
movq %rax, %rdi
movq 0x332eb(%rip), %rsi     # 0x37fb0
callq 0x3300
movq 0x332ff(%rip), %rdi     # 0x37fd0
leaq 0x2451c(%rip), %rsi     # 0x291f4
callq 0x32a0
movq %rax, %rdi
movq 0x332c9(%rip), %rsi     # 0x37fb0
callq 0x3300
movq 0x332dd(%rip), %rdi     # 0x37fd0
leaq 0x24520(%rip), %rsi     # 0x2921a
callq 0x32a0
movq %rax, %rdi
movq 0x332a7(%rip), %rsi     # 0x37fb0
callq 0x3300
movq 0x332bb(%rip), %rdi     # 0x37fd0
leaq 0x24514(%rip), %rsi     # 0x29230
callq 0x32a0
movq %rax, %rdi
movq 0x33285(%rip), %rsi     # 0x37fb0
callq 0x3300
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/rlcsa.cpp
// Function: CSA::RLCSA::RLCSA(unsigned char*, unsigned int, unsigned int, unsigned int, unsigned int, bool)
RLCSA::RLCSA(uchar* data, usint bytes, usint block_size, usint sa_sample_rate, usint threads, bool delete_data) :
  ok(false),
  alphabet(0),
  sa_samples(0), support_locate(false), support_display(false),
  sample_rate(sa_sample_rate), end_points(0)
{
  for(usint c = 0; c < CHARS; c++) { this->array[c] = 0; }
 
  if(!data || bytes == 0)
  {
    std::cerr << "RLCSA: No input data given!" << std::endl;
    if(delete_data) { delete[] data; }
    return;
  }
  if(block_size < 2 * sizeof(usint) || block_size % sizeof(usint) != 0)
  {
    std::cerr << "RLCSA: Block size must be a multiple of " << sizeof(usint) << " bytes!" << std::endl;
    if(delete_data) { delete[] data; }
    return;
  }

  this->buildRLCSA(data, 0, bytes, block_size, threads, 0, true, delete_data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb 0x10(%rbp), %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, (%rax)
movq $0x0, 0x808(%rax)
movq $0x0, 0x810(%rax)
movb $0x0, 0x818(%rax)
movb $0x0, 0x819(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x81c(%rax)
movq $0x0, 0x828(%rax)
movl $0x0, -0x28(%rbp)
cmpl $0x100, -0x28(%rbp)     # imm = 0x100
jae 0x7374
movq -0x30(%rbp), %rax
movl -0x28(%rbp), %ecx
movq $0x0, 0x8(%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x7350
cmpq $0x0, -0x10(%rbp)
je 0x7381
cmpl $0x0, -0x14(%rbp)
jne 0x73c7
movq 0x30c68(%rip), %rdi     # 0x37ff0
leaq 0x22075(%rip), %rsi     # 0x29404
callq 0x32a0
movq %rax, %rdi
movq 0x30c12(%rip), %rsi     # 0x37fb0
callq 0x3300
testb $0x1, -0x21(%rbp)
je 0x73c2
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x73c0
movq -0x38(%rbp), %rdi
callq 0x33e0
jmp 0x73c2
jmp 0x7472
movl -0x18(%rbp), %eax
cmpq $0x8, %rax
jb 0x73dd
movl -0x18(%rbp), %eax
andq $0x3, %rax
cmpq $0x0, %rax
je 0x743c
movq 0x30c0c(%rip), %rdi     # 0x37ff0
leaq 0x22035(%rip), %rsi     # 0x29420
callq 0x32a0
movq %rax, %rdi
movl $0x4, %esi
callq 0x30d0
movq %rax, %rdi
leaq 0x22042(%rip), %rsi     # 0x29449
callq 0x32a0
movq %rax, %rdi
movq 0x30b9a(%rip), %rsi     # 0x37fb0
callq 0x3300
testb $0x1, -0x21(%rbp)
je 0x743a
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x7438
movq -0x40(%rbp), %rdi
callq 0x33e0
jmp 0x743a
jmp 0x7472
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl -0x20(%rbp), %r9d
movb -0x21(%rbp), %al
xorl %edx, %edx
andb $0x1, %al
movq $0x0, (%rsp)
movl $0x1, 0x8(%rsp)
movzbl %al, %eax
movl %eax, 0x10(%rsp)
callq 0x7480
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: adamnovak[P]rlcsa/rlcsa.cpp
// Function: CSA::RLCSA::strip()
void
RLCSA::strip()
{
  for(usint c = 0; c < CHARS; c++)
  {
    if(this->array[c] != 0) { this->array[c]->strip(); }
  }
  if(this->sa_samples != 0) { this->sa_samples->strip(); }
  this->end_points->strip();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jae 0x8841
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
cmpq $0x0, 0x8(%rax,%rcx,8)
je 0x8834
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movq 0x8(%rax,%rcx,8), %rdi
callq 0x1f750
jmp 0x8836
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x880b
movq -0x18(%rbp), %rax
cmpq $0x0, 0x810(%rax)
je 0x885f
movq -0x18(%rbp), %rax
movq 0x810(%rax), %rdi
callq 0x14d40
movq -0x18(%rbp), %rax
movq 0x828(%rax), %rdi
callq 0x1f750
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/rlcsa.cpp
// Function: CSA::RLCSA::mergeSamples(CSA::RLCSA&, CSA::RLCSA&, unsigned int*)
void
RLCSA::mergeSamples(RLCSA& index, RLCSA& increment, usint* positions)
{
  if(index.sa_samples == 0 || increment.sa_samples == 0) { return; }

  positions += increment.number_of_sequences;
  this->sa_samples = new SASamples(*(index.sa_samples), *(increment.sa_samples), positions, increment.data_size, this->number_of_sequences);

  this->support_locate = this->sa_samples->supportsLocate();
  this->support_display = this->sa_samples->supportsDisplay();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x810(%rax)
je 0x8c8c
movq -0x18(%rbp), %rax
cmpq $0x0, 0x810(%rax)
jne 0x8c91
jmp 0x8d32
movq -0x18(%rbp), %rax
movl 0x820(%rax), %eax
movl %eax, %ecx
movq -0x20(%rbp), %rax
leaq (%rax,%rcx,4), %rax
movq %rax, -0x20(%rbp)
movl $0x30, %edi
callq 0x32c0
movq %rax, %rdi
movq -0x38(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x40(%rbp)
movq -0x10(%rbp), %rcx
movq 0x810(%rcx), %rsi
movq -0x18(%rbp), %r8
movq 0x810(%r8), %rdx
movq -0x20(%rbp), %rcx
movl 0x4(%r8), %r8d
movl 0x820(%rax), %r9d
callq 0x13f70
jmp 0x8ced
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x810(%rax)
movq 0x810(%rax), %rdi
callq 0xd4c0
movb %al, %cl
movq -0x38(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x818(%rax)
movq 0x810(%rax), %rdi
callq 0xd4e0
movb %al, %cl
movq -0x38(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x819(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x30, %esi
callq 0x32d0
movq -0x28(%rbp), %rdi
callq 0x3530
nopl (%rax,%rax)
// File: adamnovak[P]rlcsa/rlcsa.cpp
// Function: CSA::RLCSA::~RLCSA()
RLCSA::~RLCSA()
{
  for(usint c = 0; c < CHARS; c++) { delete this->array[c]; this->array[c] = 0; }
  delete this->alphabet; this->alphabet = 0;
  delete this->sa_samples; this->sa_samples = 0;
  delete this->end_points; this->end_points = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jae 0x8dcc
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x8db1
movq -0x20(%rbp), %rdi
callq 0x20a40
movq -0x20(%rbp), %rdi
movl $0x48, %esi
callq 0x32d0
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movq $0x0, 0x8(%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8d7b
movq -0x18(%rbp), %rax
movq 0x808(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x8df8
movq -0x28(%rbp), %rdi
callq 0xda50
movq -0x28(%rbp), %rdi
movl $0x1010, %esi           # imm = 0x1010
callq 0x32d0
movq -0x18(%rbp), %rax
movq $0x0, 0x808(%rax)
movq 0x810(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x8e2f
movq -0x30(%rbp), %rdi
callq 0x14600
movq -0x30(%rbp), %rdi
movl $0x30, %esi
callq 0x32d0
movq -0x18(%rbp), %rax
movq $0x0, 0x810(%rax)
movq 0x828(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x8e66
movq -0x38(%rbp), %rdi
callq 0x20050
movq -0x38(%rbp), %rdi
movl $0x48, %esi
callq 0x32d0
movq -0x18(%rbp), %rax
movq $0x0, 0x828(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: adamnovak[P]rlcsa/rlcsa.cpp
// Function: CSA::RLCSA::count(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
pair_type
RLCSA::count(const std::string& pattern) const
{
  if(pattern.length() == 0) { return this->getSARange(); }

  std::string::const_reverse_iterator iter = pattern.rbegin();
  pair_type index_range = this->getCharRange((uchar)*iter);
  
  if(isEmpty(index_range)) { return index_range; }

  for(++iter; iter != pattern.rend(); ++iter)
  {
    index_range = this->LF(index_range, (uchar)*iter);
    
    if(isEmpty(index_range)) { return EMPTY_PAIR; }
  }
  
  this->convertToSARange(index_range);

  return index_range;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3470
cmpq $0x0, %rax
jne 0x93c9
movq -0x58(%rbp), %rdi
callq 0x94d0
movq %rax, -0x8(%rbp)
jmp 0x94b7
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x3480
leaq -0x20(%rbp), %rdi
callq 0xdac0
movq -0x58(%rbp), %rdi
movzbl (%rax), %esi
callq 0x9510
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xdaf0
testb $0x1, %al
jne 0x9406
jmp 0x9413
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x94b7
leaq -0x20(%rbp), %rdi
callq 0xdb10
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x3070
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xdb40
testb $0x1, %al
jne 0x943c
jmp 0x94a2
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xdac0
movq -0x58(%rbp), %rdi
movzbl (%rax), %edx
movq -0x48(%rbp), %rsi
callq 0x9570
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xdb70
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0xdaf0
testb $0x1, %al
jne 0x9485
jmp 0x9492
movq 0x20288(%rip), %rax     # 0x29714
movq %rax, -0x8(%rbp)
jmp 0x94b7
jmp 0x9494
leaq -0x20(%rbp), %rdi
callq 0xdb10
jmp 0x941c
movq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x96e0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/rlcsa.cpp
// Function: CSA::RLCSA::LF(std::pair<unsigned int, unsigned int>, unsigned int) const
pair_type
RLCSA::LF(pair_type range, usint c) const
{
  if(c >= CHARS || this->array[c] == 0) { return EMPTY_PAIR; }
  PsiVector::Iterator iter(*(this->array[c]));

  usint start = this->alphabet->cumulative(c) + this->number_of_sequences - 1;
  range.first = start + iter.rank(range.first, true);
  range.second = start + iter.rank(range.second);

  return range;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xb8(%rbp)
cmpl $0x100, -0x1c(%rbp)     # imm = 0x100
jae 0x95ac
movq -0xb8(%rbp), %rax
movl -0x1c(%rbp), %ecx
cmpq $0x0, 0x8(%rax,%rcx,8)
jne 0x95bc
movq 0x20161(%rip), %rax     # 0x29714
movq %rax, -0x8(%rbp)
jmp 0x96bb
movq -0xb8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq 0x8(%rax,%rcx,8), %rsi
leaq -0x98(%rbp), %rdi
callq 0x20a90
movq -0xb8(%rbp), %rax
movq 0x808(%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0xdc20
movl %eax, -0xbc(%rbp)
jmp 0x95f5
movl -0xbc(%rbp), %ecx
movq -0xb8(%rbp), %rax
movl 0x820(%rax), %edx
movl %ecx, %eax
movl %edx, %ecx
leal -0x1(%rax,%rcx), %eax
movl %eax, -0x9c(%rbp)
movl -0x9c(%rbp), %eax
movl %eax, -0xc4(%rbp)
movl -0x10(%rbp), %esi
leaq -0x98(%rbp), %rdi
movl $0x1, %edx
callq 0x20ae0
movl %eax, -0xc0(%rbp)
jmp 0x963e
movl -0xc0(%rbp), %ecx
movl -0xc4(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x9c(%rbp), %eax
movl %eax, -0xcc(%rbp)
movl -0xc(%rbp), %esi
leaq -0x98(%rbp), %rdi
xorl %edx, %edx
callq 0x20ae0
movl %eax, -0xc8(%rbp)
jmp 0x9674
movl -0xc8(%rbp), %ecx
movl -0xcc(%rbp), %eax
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x20ac0
jmp 0x96bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x20ac0
jmp 0x96c8
movq -0x8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x3530
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/rlcsa.cpp
// Function: CSA::RLCSA::reportPositions(unsigned char*, unsigned int, unsigned int*) const
void
RLCSA::reportPositions(uchar* data, usint length, usint* positions) const
{
  if(data == 0 || length == 0 || positions == 0) { return; }

  PsiVector::Iterator** iters = this->getIterators();

  usint current = this->number_of_sequences - 1;
  positions[length] = current; // "immediately after current"
  for(sint i = (sint)(length - 1); i >= 0; i--)
  {
    usint c = (usint)data[i];
    if(this->array[c] != 0)
    {
      current = this->LF(current, c, *(iters[c]));
    }
    else
    {
      if(c < this->alphabet->getFirstChar()) // No previous characters either.
      {
        current = this->number_of_sequences - 1;
      }
      else
      {
        current = this->alphabet->cumulative(c) - 1 + this->number_of_sequences;
      }
    }
    positions[i] = current; // "immediately after current"
  }

  this->deleteIterators(iters);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9753
cmpl $0x0, -0x14(%rbp)
je 0x9753
cmpq $0x0, -0x20(%rbp)
jne 0x9758
jmp 0x9854
movq -0x40(%rbp), %rdi
callq 0x9860
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x28(%rbp)
movl 0x820(%rax), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %edx
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jl 0x9847
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x30(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
movl %ecx, -0x34(%rbp)
movl -0x34(%rbp), %ecx
cmpq $0x0, 0x8(%rax,%rcx,8)
je 0x97d5
movq -0x40(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x34(%rbp), %edx
movq -0x28(%rbp), %rax
movl -0x34(%rbp), %ecx
movq (%rax,%rcx,8), %rcx
callq 0xdba0
movl %eax, -0x2c(%rbp)
jmp 0x982b
movq -0x40(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %ecx, -0x44(%rbp)
movq 0x808(%rax), %rdi
callq 0xdc00
movl %eax, %ecx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
jae 0x9806
movq -0x40(%rbp), %rax
movl 0x820(%rax), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x9829
movq -0x40(%rbp), %rax
movq 0x808(%rax), %rdi
movl -0x34(%rbp), %esi
callq 0xdc20
movq -0x40(%rbp), %rcx
subl $0x1, %eax
addl 0x820(%rcx), %eax
movl %eax, -0x2c(%rbp)
jmp 0x982b
movl -0x2c(%rbp), %edx
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x30(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x978e
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x9930
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: adamnovak[P]rlcsa/rlcsa.cpp
// Function: CSA::RLCSA::getIterators() const
PsiVector::Iterator**
RLCSA::getIterators() const
{
  PsiVector::Iterator** iters = new PsiVector::Iterator*[CHARS];
  for(usint i = 0; i < CHARS; i++)
  {
    if(this->array[i] == 0) { iters[i] = 0; }
    else                    { iters[i] = new PsiVector::Iterator(*(this->array[i])); }
  }
  return iters;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x800, %edi            # imm = 0x800
callq 0x3030
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
jae 0x991a
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %ecx
cmpq $0x0, 0x8(%rax,%rcx,8)
jne 0x98b6
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
jmp 0x990a
movl $0x78, %edi
callq 0x32c0
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x38(%rbp)
movl -0x14(%rbp), %ecx
movq 0x8(%rax,%rcx,8), %rsi
callq 0x20a90
jmp 0x98dd
movq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
jmp 0x990a
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x78, %esi
callq 0x32d0
jmp 0x9924
jmp 0x990c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9889
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3530
nopl (%rax)
// File: adamnovak[P]rlcsa/rlcsa.cpp
// Function: CSA::RLCSA::locate(std::pair<unsigned int, unsigned int>, bool, bool) const
usint*
RLCSA::locate(pair_type range, bool direct, bool steps) const
{
  if(!(this->support_locate) || isEmpty(range) || range.second >= this->data_size) { return 0; }

  usint* data = new usint[length(range)];
  if(direct) { this->directLocate(range, data, steps); }
  else       { this->locateUnsafe(range, data, steps); }

  return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movb %dl, %cl
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
andb $0x1, %cl
movb %cl, -0x19(%rbp)
andb $0x1, %al
movb %al, -0x1a(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
testb $0x1, 0x818(%rax)
je 0x9a01
movq -0x10(%rbp), %rax
movq %rax, -0x24(%rbp)
movq -0x24(%rbp), %rdi
callq 0xdaf0
testb $0x1, %al
jne 0x9a01
movq -0x50(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x4(%rcx), %eax
jb 0x9a0e
movq $0x0, -0x8(%rbp)
jmp 0x9a98
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xdc40
movl %eax, %eax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, -0x30(%rbp)
testb $0x1, -0x19(%rbp)
je 0x9a6f
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdx
movb -0x1a(%rbp), %al
movq -0x40(%rbp), %rsi
andb $0x1, %al
movzbl %al, %ecx
callq 0x9ab0
jmp 0x9a90
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rdx
movb -0x1a(%rbp), %al
movq -0x48(%rbp), %rsi
andb $0x1, %al
movzbl %al, %ecx
callq 0x9b30
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/rlcsa.cpp
// Function: CSA::RLCSA::directLocate(std::pair<unsigned int, unsigned int>, unsigned int*, bool) const
void
RLCSA::directLocate(pair_type range, usint* data, bool steps) const
{
  // range is in SA coordinates, so first we need to convert to BWT coordinates.
  this->convertToBWTRange(range);
  for(usint i = 0, j = range.first; j <= range.second; i++, j++)
  {
    data[i] = this->directLocate(j, steps);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
leaq -0x8(%rbp), %rsi
callq 0xa110
movl $0x0, -0x20(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
ja 0x9b25
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x9f40
movl %eax, %edx
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x9ae9
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: adamnovak[P]rlcsa/rlcsa.cpp
// Function: CSA::RLCSA::locate(std::pair<unsigned int, unsigned int>, unsigned int*, bool, bool) const
usint*
RLCSA::locate(pair_type range, usint* data, bool direct, bool steps) const
{
  if(!(this->support_locate) || isEmpty(range) || range.second >= this->data_size || data == 0) { return 0; }

  if(direct) { this->directLocate(range, data, steps); }
  else       { this->locateUnsafe(range, data, steps); }

  return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %r8b, %al
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %cl
movb %cl, -0x21(%rbp)
andb $0x1, %al
movb %al, -0x22(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
testb $0x1, 0x818(%rax)
je 0x9e4b
movq -0x10(%rbp), %rax
movq %rax, -0x2c(%rbp)
movq -0x2c(%rbp), %rdi
callq 0xdaf0
testb $0x1, %al
jne 0x9e4b
movq -0x48(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x4(%rcx), %eax
jae 0x9e4b
cmpq $0x0, -0x20(%rbp)
jne 0x9e55
movq $0x0, -0x8(%rbp)
jmp 0x9ea7
testb $0x1, -0x21(%rbp)
je 0x9e7e
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x34(%rbp)
movq -0x20(%rbp), %rdx
movb -0x22(%rbp), %al
movq -0x34(%rbp), %rsi
andb $0x1, %al
movzbl %al, %ecx
callq 0x9ab0
jmp 0x9e9f
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x3c(%rbp)
movq -0x20(%rbp), %rdx
movb -0x22(%rbp), %al
movq -0x3c(%rbp), %rsi
andb $0x1, %al
movzbl %al, %ecx
callq 0x9b30
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/rlcsa.cpp
// Function: CSA::RLCSA::directLocate(unsigned int, bool) const
usint
RLCSA::directLocate(usint index, bool steps) const
{
  // Note that index is in BWT coordinates initially.
  
  // This keeps track of how far along the sequence we had to go to find an SA
  // sample.
  usint offset = 0;
  while(true)
  {
    // First try in BWT space, so we can account for the text end characters.
    if(this->hasImplicitSample(index))
    {
      // If we took an implicit sample at this index in the BWT (due to us being
      // in the range occupied by sequence start characters), we know where it
      // falls in the original sequences: at the endpoint of the appropriate
      // text.
      if(steps) { return offset; }
      else      { return this->getImplicitSample(index) - offset; }
    }
    // Pop index into SA space, where the SA samples live
    index -= this->number_of_sequences;
    if(this->sa_samples->isSampled(index))
    {
      // If we took a real SA sample here, we know where it falls in the
      // original sequences.
      return (steps ? offset : this->sa_samples->getSampleAt(index) - offset);
    }
    
    // If we get here, we couldn't map this position. Proceed forwards (towards
    // the end of the sequence), in hopes of hitting either a sample or the
    // sequence end character. Note that psi maps from SA position to the *BWT*
    // position of the subsequent character, popping index back into BWT space.
    index = this->psi(index);
    offset++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xdc60
testb $0x1, %al
jne 0x9f77
jmp 0x9f9c
testb $0x1, -0x15(%rbp)
je 0x9f88
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa00f
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xdc80
subl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa00f
movq -0x28(%rbp), %rax
movl 0x820(%rax), %edx
movl -0x14(%rbp), %ecx
subl %edx, %ecx
movl %ecx, -0x14(%rbp)
movq 0x810(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0xdd20
testb $0x1, %al
jne 0x9fc3
jmp 0x9ff2
testb $0x1, -0x15(%rbp)
je 0x9fd1
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x9fea
movq -0x28(%rbp), %rax
movq 0x810(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0xddb0
subl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa00f
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xde60
movl %eax, -0x14(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9f65
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: adamnovak[P]rlcsa/rlcsa.cpp
// Function: CSA::RLCSA::directInverseLocate(unsigned int) const
usint
RLCSA::directInverseLocate(usint location) const
{
  // Get the SA value and SA index (in that order) of the last SA sample
  // before the given text location.
  pair_type last_sample = this->sa_samples->inverseSA(location);
  
  // TODO: catch the (size, size) sentinel.
  while(last_sample.first < location) {
    // We're not at the desired text location, so we must be before it.
    
    // Advance the text location (SA value) by 1
    last_sample.first += 1;
    
    // Advance the SA index to that corresponding to the next character. Note
    // that psi returns BWT coordinates, so we have to convert back to SA
    // coordinates.
    last_sample.second = (this->psi(last_sample.second) - 
      this->number_of_sequences);
      
  }
  
  if(last_sample.first != location) {
    // We managed to start on the wrong side of what we're trying to locate;
    // inverseSA lied to us.
    throw "Somehow skipped desired inverse locate position";
  }
  
  // Return the answer (SA index) in BWT coordinates. It will probably be
  // immediately converted back to SA coordinates, but it's worth it for
  // consistency with the directLocate function, which takes in BWT coordinates.
  return last_sample.second + this->number_of_sequences;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x810(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x14b50
movq %rax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0xa0c6
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %esi
callq 0xde60
movq -0x20(%rbp), %rcx
subl 0x820(%rcx), %eax
movl %eax, -0x10(%rbp)
jmp 0xa09a
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0xa0f5
movl $0x8, %edi
callq 0x3170
movq %rax, %rdi
leaq 0x1f469(%rip), %rax     # 0x2954b
movq %rax, (%rdi)
movq 0x2decc(%rip), %rsi     # 0x37fb8
xorl %eax, %eax
movl %eax, %edx
callq 0x3500
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %eax
addl 0x820(%rcx), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: adamnovak[P]rlcsa/rlcsa.cpp
// Function: CSA::RLCSA::display(unsigned int, bool) const
uchar*
RLCSA::display(usint sequence, bool include_end_marker) const
{
  if(!(this->support_display)) { return 0; }

  pair_type seq_range = this->getSequenceRange(sequence);
  if(isEmpty(seq_range)) { return 0; }

  uchar* data = new uchar[length(seq_range) + include_end_marker];
  this->displayUnsafe(seq_range, data);
  if(include_end_marker) { data[length(seq_range)] = 0; }

  return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
testb $0x1, 0x819(%rax)
jne 0xa484
movq $0x0, -0x8(%rbp)
jmp 0xa531
movq -0x50(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xa540
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xdaf0
testb $0x1, %al
jne 0xa4ab
jmp 0xa4b5
movq $0x0, -0x8(%rbp)
jmp 0xa531
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xdc40
movb -0x15(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x3030
movq -0x50(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdx
movq -0x40(%rbp), %rsi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0xa680
testb $0x1, -0x15(%rbp)
je 0xa529
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0xdc40
movl %eax, %ecx
movq -0x58(%rbp), %rax
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: adamnovak[P]rlcsa/rlcsa.cpp
// Function: CSA::RLCSA::getSequenceRange(unsigned int) const
pair_type
RLCSA::getSequenceRange(usint number) const
{
  if(number >= this->number_of_sequences) { return EMPTY_PAIR; }

  pair_type result;
  DeltaVector::Iterator iter(*(this->end_points));
  if(number == 0)
  {
    result.first = 0;
    result.second = iter.select(number);
  }
  else
  {
    result.first = nextMultipleOf(this->sample_rate, iter.select(number - 1));
    result.second = iter.selectNext();
  }

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0xa8(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x820(%rcx), %eax
jb 0xa578
movq 0x1f1a5(%rip), %rax     # 0x29714
movq %rax, -0x8(%rbp)
jmp 0xa667
leaq -0x8(%rbp), %rdi
callq 0xe530
movq -0xa8(%rbp), %rax
movq 0x828(%rax), %rsi
leaq -0x90(%rbp), %rdi
callq 0x200a0
cmpl $0x0, -0x14(%rbp)
jne 0xa5f0
movl $0x0, -0x8(%rbp)
movl -0x14(%rbp), %esi
leaq -0x90(%rbp), %rdi
callq 0x20200
movl %eax, -0xac(%rbp)
jmp 0xa5bf
movl -0xac(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa65b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x200d0
jmp 0xa674
movq -0xa8(%rbp), %rax
movl 0x81c(%rax), %eax
movl %eax, -0xb4(%rbp)
movl -0x14(%rbp), %esi
decl %esi
leaq -0x90(%rbp), %rdi
callq 0x20200
movl %eax, -0xb0(%rbp)
jmp 0xa61c
movl -0xb0(%rbp), %esi
movl -0xb4(%rbp), %edi
callq 0xe550
movl %eax, -0xb8(%rbp)
jmp 0xa635
movl -0xb8(%rbp), %eax
movl %eax, -0x8(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x202a0
movl %eax, -0xbc(%rbp)
jmp 0xa652
movl -0xbc(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x200d0
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x3530
// File: adamnovak[P]rlcsa/rlcsa.cpp
// Function: CSA::RLCSA::display(unsigned int, std::pair<unsigned int, unsigned int>) const
uchar*
RLCSA::display(usint sequence, pair_type range) const
{
  if(!(this->support_display) || isEmpty(range)) { return 0; }

  pair_type seq_range = this->getSequenceRange(sequence);
  if(isEmpty(seq_range)) { return 0; }

  range.first += seq_range.first; range.second += seq_range.first;
  if(range.second > seq_range.second) { return 0; }

  uchar* data = new uchar[length(range)];
  this->displayUnsafe(range, data);

  return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
testb $0x1, 0x819(%rax)
je 0xa89b
movq -0x10(%rbp), %rax
movq %rax, -0x24(%rbp)
movq -0x24(%rbp), %rdi
callq 0xdaf0
testb $0x1, %al
jne 0xa89b
jmp 0xa8a8
movq $0x0, -0x8(%rbp)
jmp 0xa943
movq -0x58(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xa540
movq %rax, -0x2c(%rbp)
movq -0x2c(%rbp), %rax
movq %rax, -0x34(%rbp)
movq -0x34(%rbp), %rdi
callq 0xdaf0
testb $0x1, %al
jne 0xa8cf
jmp 0xa8d9
movq $0x0, -0x8(%rbp)
jmp 0xa943
movl -0x2c(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x2c(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x28(%rbp), %eax
jbe 0xa8fd
movq $0x0, -0x8(%rbp)
jmp 0xa943
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0xdc40
movl %eax, %eax
movl %eax, %edi
callq 0x3030
movq -0x58(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rdx
movq -0x50(%rbp), %rsi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0xa680
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: adamnovak[P]rlcsa/rlcsa.cpp
// Function: CSA::RLCSA::display(unsigned int, std::pair<unsigned int, unsigned int>, unsigned char*) const
uchar*
RLCSA::display(usint sequence, pair_type range, uchar* data) const
{
  if(!(this->support_display) || isEmpty(range) || data == 0) { return 0; }

  pair_type seq_range = this->getSequenceRange(sequence);
  if(isEmpty(seq_range)) { return 0; }

  range.first += seq_range.first; range.second += seq_range.first;
  if(range.second > seq_range.second) { return 0; }

  this->displayUnsafe(range, data);
  return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
testb $0x1, 0x819(%rax)
je 0xa994
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xdaf0
testb $0x1, %al
jne 0xa994
cmpq $0x0, -0x28(%rbp)
jne 0xa99e
movq $0x0, -0x8(%rbp)
jmp 0xaa1b
movq -0x50(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xa540
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0xdaf0
testb $0x1, %al
jne 0xa9c5
jmp 0xa9cf
movq $0x0, -0x8(%rbp)
jmp 0xaa1b
movl -0x38(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x38(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x34(%rbp), %eax
jbe 0xa9f3
movq $0x0, -0x8(%rbp)
jmp 0xaa1b
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdx
movq -0x48(%rbp), %rsi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0xa680
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)