LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/ksabry[P]bfbrute/src/DataCache.h
// Function: DataCache<32ul, 12ul>::Create()
void Create()
	{
		CreateZero();
		CreateOne();
		for (uint_fast32_t size = 2; size <= max_cache_size; size++)
		{
			CreateSize(size);
			std::cout << " Created cache size " << size << " / " << max_cache_size << "\r" << std::flush;
		}
		std::cout << std::endl;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
movq %rax, 0x88(%rdi)
movq %rcx, 0xf8(%rdi)
xorl %eax, %eax
movq %rax, 0x1e8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x1a0(%rdi)
movups %xmm0, 0x1b0(%rdi)
movq %rax, 0x1c0(%rdi)
movq $0x10, 0x1c8(%rdi)
movq $-0x10, 0x1d0(%rdi)
callq 0x3c68
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
movq %rax, 0x90(%rbx)
movq %rcx, 0x100(%rbx)
movq %rbx, %rdi
callq 0x3836
movl $0x2, %r15d
movq 0x99a1(%rip), %r14      # 0xcfd8
leaq 0x5abe(%rip), %r13      # 0x90fc
leaq 0x5fca(%rip), %rbp      # 0x960f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x390a
movl $0x14, %edx
movq %r14, %rdi
leaq 0x5a88(%rip), %rsi      # 0x90e7
callq 0x2270
movq %r14, %rdi
movq %r15, %rsi
callq 0x2140
movq %rax, %r12
movl $0x3, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2270
movl $0xc, %esi
movq %r12, %rdi
callq 0x2140
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2270
movq %r12, %rdi
callq 0x2150
incq %r15
cmpq $0xd, %r15
jne 0x3645
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2150
// File: /workspace/github_cpp_makefile_star2_O1/ksabry[P]bfbrute/src/ProgramSearch.h
// Function: ProgramSearch<ProgramIterator<400ul, 32ul, 12ul, 32ul>, DataCache<32ul, 12ul>>::Setup()
void Setup()
	{
		programResult = std::string();
		for (uint_fast32_t i = 0; i < THREAD_COUNT; i++)
		{
			if (threads[i]) delete threads[i];
			threads[i] = nullptr;

			iterators[i].SetCache(&cache);
			iterators[i].SetDivisionTable(&divisionTable);
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
addq $0x859f8, %rdi          # imm = 0x859F8
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x2290
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x3737
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
leaq 0x401f8(%rbx), %r14
leaq 0x8(%rbx), %r15
leaq 0x1f8(%rbx), %r12
leaq 0x40320(%rbx), %r13
xorl %ebp, %ebp
movq 0x85978(%rbx,%rbp,8), %rdi
testq %rdi, %rdi
je 0x376f
cmpq $0x0, (%rdi)
jne 0x37c7
movl $0x8, %esi
callq 0x2230
movq $0x0, 0x85978(%rbx,%rbp,8)
imulq $0x4578, %rbp, %rcx     # imm = 0x4578
leaq (%r14,%rcx), %rax
movq %r15, (%r14,%rcx)
xorl %ecx, %ecx
movq %r15, (%r13,%rcx)
addq $0x1e8, %rcx            # imm = 0x1E8
cmpq $0x3d00, %rcx           # imm = 0x3D00
jne 0x378c
movq %r12, 0x4460(%rax)
incq %rbp
addq $0x4578, %r13           # imm = 0x4578
cmpq $0x10, %rbp
jne 0x3752
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2070
// File: /workspace/github_cpp_makefile_star2_O1/ksabry[P]bfbrute/src/DataCache.h
// Function: DataCache<32ul, 12ul>::CreateOne()
void CreateOne()
	{
		currentProgramSize = 1;
		memset(currentData, 0, data_size);
		
		currentDataIdx = 0;
		currentDataStart = 0;
		currentDataEnd = 1;
		
		currentProgram[0] = '+';
		currentData[zeroDataIdx] = 1;
		AddData();

		currentProgram[0] = '-';
		currentData[zeroDataIdx] = 255;
		AddData();

		currentData[zeroDataIdx] = 0;
		currentDataStart = data_size / 2;
		currentDataEnd = -static_cast<int>(data_size) / 2;
		
		currentProgram[0] = '>';
		currentDataIdx = 1;
		AddData();

		currentProgram[0] = '<';
		currentDataIdx = -1;
		AddData();

		bordersBalanced[2] = dataBalancedCount;
		bordersUnbalanced[2] = dataUnbalancedCount;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %r14d
movq %r14, 0x1e8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x1a0(%rdi)
movups %xmm0, 0x1b0(%rdi)
movups %xmm0, 0x1c0(%rdi)
movq %r14, 0x1d0(%rdi)
movb $0x2b, 0x1d8(%rdi)
movq (%rdi), %rax
movb $0x1, 0x1a0(%rdi,%rax)
callq 0x3c68
movb $0x2d, 0x1d8(%rbx)
movq (%rbx), %rax
movb $-0x1, 0x1a0(%rbx,%rax)
movq %rbx, %rdi
callq 0x3c68
movq (%rbx), %rax
movb $0x0, 0x1a0(%rbx,%rax)
movq $0x10, 0x1c8(%rbx)
movq $-0x10, 0x1d0(%rbx)
movb $0x3e, 0x1d8(%rbx)
movq %r14, 0x1c0(%rbx)
movq %rbx, %rdi
callq 0x3c68
movb $0x3c, 0x1d8(%rbx)
movq $-0x1, 0x1c0(%rbx)
movq %rbx, %rdi
callq 0x3c68
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
movq %rax, 0x98(%rbx)
movq %rcx, 0x108(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ksabry[P]bfbrute/src/DataCache.h
// Function: DataCache<32ul, 12ul>::AddData()
void AddData()
	{
		auto lookup = LookupData<data_size>(currentDataIdx, currentData);
		if (dataSet.count(lookup) > 0)
			return;
		dataSet.insert(lookup);

		bool balanced = currentDataIdx == 0;
		std::vector<AlignedData<data_size>>& data = balanced ? dataBalanced : dataUnbalanced;
		std::vector<char>& programs = balanced ? programsBalanced : programsUnbalanced;
		uint_fast32_t& dataCount = balanced ? dataBalancedCount : dataUnbalancedCount;

		data.resize(dataCount + 1);
		programs.resize((dataCount + 1) * max_cache_size + 1);
		
		memcpy(&data[dataCount].data, currentData, data_size);
		data[dataCount].idx = currentDataIdx;
		data[dataCount].start = currentDataStart;
		data[dataCount].end = currentDataEnd;
		
		memcpy(&programs[dataCount * max_cache_size], currentProgram, currentProgramSize);
		programs[dataCount * max_cache_size + currentProgramSize] = '\0';

		dataCount++;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x1c0(%rdi), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movups 0x1a0(%rdi), %xmm0
movups 0x1b0(%rdi), %xmm1
movups %xmm0, 0x8(%rsi)
movups %xmm1, 0x18(%rsi)
leaq 0x168(%rdi), %r14
movq %r14, %rdi
callq 0x3e34
testq %rax, %rax
jne 0x3db7
leaq 0x1a0(%rbx), %r13
movq %rsp, %rdx
movq %r14, (%rdx)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x3f1e
leaq 0x40(%rbx), %rax
leaq 0x28(%rbx), %r15
leaq 0x70(%rbx), %rcx
xorl %r12d, %r12d
cmpq $0x0, 0x1c0(%rbx)
leaq 0x58(%rbx), %r14
setne %r12b
cmovneq %rax, %r15
cmovneq %rcx, %r14
movq 0x18(%rbx,%r12,8), %rsi
incq %rsi
movq %r15, %rdi
callq 0x3dc6
movq 0x18(%rbx,%r12,8), %rax
leaq (%rax,%rax,2), %rax
leaq 0xd(,%rax,4), %rsi
movq %r14, %rdi
callq 0x3e08
movq (%r15), %rax
imulq $0x38, 0x18(%rbx,%r12,8), %rcx
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups %xmm1, 0x10(%rax,%rcx)
movups %xmm0, (%rax,%rcx)
movq 0x1c0(%rbx), %rax
movq (%r15), %rcx
imulq $0x38, 0x18(%rbx,%r12,8), %rdx
movq %rax, 0x20(%rcx,%rdx)
movq 0x1c8(%rbx), %rax
imulq $0x38, 0x18(%rbx,%r12,8), %rdx
movq %rax, 0x28(%rcx,%rdx)
movq 0x1d0(%rbx), %rax
imulq $0x38, 0x18(%rbx,%r12,8), %rdx
movq %rax, 0x30(%rcx,%rdx)
movq 0x18(%rbx,%r12,8), %rax
leaq (%rax,%rax,2), %rdi
shlq $0x2, %rdi
addq (%r14), %rdi
leaq 0x1d8(%rbx), %rsi
movq 0x1e8(%rbx), %rdx
callq 0x2190
movq 0x18(%rbx,%r12,8), %rax
leaq (%rax,%rax,2), %rax
shlq $0x2, %rax
movq 0x1e8(%rbx), %rcx
addq (%r14), %rax
movb $0x0, (%rcx,%rax)
incq 0x18(%rbx,%r12,8)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ksabry[P]bfbrute/src/ProgramSearch.h
// Function: ProgramSearch<ProgramIterator<400ul, 32ul, 12ul, 32ul>, DataCache<32ul, 12ul>>::SetupSize()
void SetupSize()
	{
		std::cout << "Setting up size " << programSize << std::endl;

		sizeStart = std::chrono::system_clock::now();
		for (uint_fast32_t thread_idx = 0; thread_idx < THREAD_COUNT; thread_idx++)
		{
			auto& iterator = iterators[thread_idx];
			iterator.Start(programSize, thread_idx, THREAD_COUNT);
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8383(%rip), %r14      # 0xcfd8
leaq 0x45ad(%rip), %rsi      # 0x9209
movl $0x10, %edx
movq %r14, %rdi
callq 0x2270
movq 0x85a20(%rbx), %rsi
movq %r14, %rdi
callq 0x2140
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
callq 0x2040
movq %rax, 0x85a30(%rbx)
leaq 0x401f8(%rbx), %r14
xorl %r15d, %r15d
movq 0x85a20(%rbx), %rsi
movl $0x10, %ecx
movq %r14, %rdi
movq %r15, %rdx
callq 0x5a7c
incq %r15
addq $0x4578, %r14           # imm = 0x4578
cmpq $0x10, %r15
jne 0x4cb8
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ksabry[P]bfbrute/src/ProgramSearch.h
// Function: ProgramSearch<ProgramIterator<400ul, 32ul, 12ul, 32ul>, DataCache<32ul, 12ul>>::FindStringSize()
void FindStringSize()
	{
		CountSize();

		for (uint_fast32_t i = 0; i < THREAD_COUNT; i++)
		{
			if (threads[i]) delete threads[i];
			threads[i] = new std::thread(&ProgramSearch::FindStringThread, this, i);
		}
		for (uint_fast32_t i = 0; i < THREAD_COUNT; i++)
		{
			threads[i]->join();
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x6024
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
xorl %eax, %eax
leaq 0x1475(%rip), %rbp      # 0x6186
leaq 0x18(%rsp), %r15
leaq 0x10(%rsp), %r12
movq 0x85978(%rbx,%rax,8), %rdi
testq %rdi, %rdi
je 0x4d38
cmpq $0x0, (%rdi)
jne 0x4dac
movl $0x8, %esi
callq 0x2230
movl $0x8, %edi
callq 0x2220
movq %rax, %r13
movq %rbp, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq %rbx, 0x10(%rsp)
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x6f3c
movq 0x8(%rsp), %rax
movq %r13, 0x85978(%rbx,%rax,8)
incq %rax
movq %rax, 0x8(%rsp)
cmpq $0x10, %rax
jb 0x4d1b
xorl %r14d, %r14d
movq 0x85978(%rbx,%r14,8), %rdi
callq 0x2380
incq %r14
cmpq $0x10, %r14
jne 0x4d87
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2070
movq %rax, %rbx
movl $0x8, %esi
movq %r13, %rdi
callq 0x2230
movq %rbx, %rdi
callq 0x23a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/ksabry[P]bfbrute/src/ProgramSearch.h
// Function: ProgramSearch<ProgramIterator<400ul, 32ul, 12ul, 32ul>, DataCache<32ul, 12ul>>::StringToHex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string StringToHex(const std::string& input)
	{
		static const char hex_digits[] = "0123456789ABCDEF";

		std::string output;
		output.reserve(input.length() * 2);
		for (unsigned char c : input)
		{
			output.push_back(hex_digits[c >> 4]);
			output.push_back(hex_digits[c & 15]);
		}
		return output;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rdx), %rsi
addq %rsi, %rsi
callq 0x2310
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x57ec
movq (%r14), %r14
xorl %r13d, %r13d
leaq 0x3fd4(%rip), %rbp      # 0x9790
movzbl (%r14,%r13), %r15d
movl %r15d, %eax
shrl $0x4, %eax
movsbl (%rax,%rbp), %esi
movq %rbx, %rdi
callq 0x21b0
andl $0xf, %r15d
movsbl (%r15,%rbp), %esi
movq %rbx, %rdi
callq 0x21b0
incq %r13
cmpq %r13, %r12
jne 0x57bc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5800
movq %rax, %r14
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x581b
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2230
movq %r14, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O1/ksabry[P]bfbrute/src/LinearIterator.h
// Function: LinearIterator<32ul, 12ul, 32ul>::Deserialize(std::istream&)
bool Deserialize(std::istream& input)
	{
		input >> stackSize;
		input >> firstCacheSize;
		for (uint_fast32_t i = 0; i < max_stack_size; i++)
		{
			input >> indexStack[i];
		}
		for (uint_fast32_t i = 0; i < max_stack_size; i++)
		{
			input >> balancedStack[i];
		}
		input >> first;

		// Restore dataStack
		for (int i = stackSize - 1; i >= 0; i--) CalcData(i);

		return true;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %rsi
movq %r14, %rdi
callq 0x20f0
leaq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x20f0
movl $0x18, %r15d
leaq (%rbx,%r15), %rsi
movq %r14, %rdi
callq 0x20f0
addq $0x8, %r15
cmpq $0x30, %r15
jne 0x58b9
movl $0x30, %r15d
leaq (%rbx,%r15), %rsi
movq %r14, %rdi
callq 0x21c0
incq %r15
cmpq $0x33, %r15
jne 0x58d5
leaq 0xe0(%rbx), %rsi
movq %r14, %rdi
callq 0x21c0
movl 0x8(%rbx), %eax
decl %eax
js 0x591a
movl %eax, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5922
leaq -0x1(%r14), %rax
testq %r14, %r14
movq %rax, %r14
jg 0x5903
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ksabry[P]bfbrute/src/LinearIterator.h
// Function: LinearIterator<32ul, 12ul, 32ul>::CalcData(unsigned long)
void CalcData(uint_fast32_t idx)
	{
		AlignedData<data_size>& data = balancedStack[idx] ? cache->dataBalanced[indexStack[idx]] : cache->dataUnbalanced[indexStack[idx]];
		if (idx == stackSize - 1)
		{
			dataStack[idx] = data;
		}
		else
		{
			AddData<data_size>(dataStack[idx], dataStack[idx + 1], data);
		}
	}

// Assembly:
cmpb $0x0, 0x30(%rdi,%rsi)
movl $0x28, %eax
movl $0x40, %ecx
cmovneq %rax, %rcx
imulq $0x38, 0x18(%rdi,%rsi,8), %rdx
movq (%rdi), %rax
movq 0x8(%rdi), %r8
addq (%rax,%rcx), %rdx
decq %r8
imulq $0x38, %rsi, %rcx
leaq (%rdi,%rcx), %rax
addq $0x38, %rax
cmpq %rsi, %r8
jne 0x5979
movq 0x30(%rdx), %rcx
movq %rcx, 0x30(%rax)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups 0x20(%rdx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
retq
addq $0x38, %rdi
leaq (%rcx,%rdi), %rsi
addq $0x38, %rsi
movq %rax, %rdi
jmp 0x598d
// File: /workspace/github_cpp_makefile_star2_O1/ksabry[P]bfbrute/src/Util.h
// Function: bool AddData<32ul>(AlignedData<32ul>&, AlignedData<32ul> const&, AlignedData<32ul> const&)
bool AddData(AlignedData<data_size>& dest, const AlignedData<data_size>& srcFirst, const AlignedData<data_size>& srcSecond)
{
	constexpr int_fast32_t data_size_s = static_cast<int_fast32_t>(data_size);
	constexpr int_fast32_t lowDataIdx = -data_size_s / 2;
	constexpr int_fast32_t highDataIdx = data_size_s - data_size_s / 2;

	int_fast32_t newDataIndex = srcFirst.idx + srcSecond.idx;
	if (newDataIndex < lowDataIdx || newDataIndex >= highDataIdx)
		return false;
	dest.idx = newDataIndex;

	int_fast32_t secondStart = Max(srcSecond.start + srcFirst.idx, lowDataIdx);
	int_fast32_t secondEnd = Min(srcSecond.end + srcFirst.idx, highDataIdx);
	dest.start = Min(srcFirst.start, secondStart);
	dest.end = Max(srcFirst.end, secondEnd);

	memset(dest.data, 0, data_size);
	if (srcFirst.end > srcFirst.start)
	{
		memcpy(
			&dest.data[srcFirst.start + data_size / 2], 
			&srcFirst.data[srcFirst.start + data_size / 2], 
			srcFirst.end - srcFirst.start
		);
	}
	
	for (int_fast32_t i = secondStart; i < secondEnd; i++)
	{
		dest.data[i + data_size / 2] += srcSecond.data[i - srcFirst.idx + data_size / 2];
	}
	
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x20(%rsi), %rcx
movq 0x20(%rdx), %rax
leaq (%rax,%rcx), %r12
addq $0x10, %r12
cmpq $0x1f, %r12
ja 0x5a66
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
addq %rcx, %rax
movq %rax, 0x20(%rdi)
movq 0x20(%rsi), %rax
movq 0x28(%rsi), %rcx
movq 0x28(%rdx), %rdx
addq %rax, %rdx
cmpq $-0xf, %rdx
movq $-0x10, %rbp
cmovgeq %rdx, %rbp
addq 0x30(%r14), %rax
cmpq $0x10, %rax
movl $0x10, %r13d
cmovlq %rax, %r13
cmpq %rbp, %rcx
cmovgeq %rbp, %rcx
movq %rcx, 0x28(%rdi)
movq 0x30(%rsi), %rax
cmpq %r13, %rax
cmovleq %r13, %rax
movq %rax, 0x30(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movq 0x28(%rsi), %rax
movq 0x30(%rsi), %rdx
subq %rax, %rdx
jle 0x5a38
leaq (%r15,%rax), %rdi
addq $0x10, %rdi
leaq (%rbx,%rax), %rsi
addq $0x10, %rsi
callq 0x2190
subq %rbp, %r13
jle 0x5a66
leaq (%r15,%rbp), %rax
addq $0x10, %rax
leaq (%r14,%rbp), %rcx
addq $0x10, %rcx
xorl %edx, %edx
movq %rcx, %rsi
subq 0x20(%rbx), %rsi
movb (%rsi,%rdx), %sil
addb %sil, (%rax,%rdx)
incq %rdx
cmpq %rdx, %r13
jne 0x5a4f
cmpq $0x20, %r12
setb %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ksabry[P]bfbrute/src/ProgramIterator.h
// Function: ProgramIterator<400ul, 32ul, 12ul, 32ul>::Start(unsigned long, unsigned long, unsigned long)
void Start(uint_fast32_t programSize, uint_fast32_t threadOffset, uint_fast32_t threadDelta)
	{
		this->programSize = programSize;
		this->currentCount = 0;
		
		this->threadOffset = threadOffset;
		this->threadDelta = threadDelta;

		memset(iteratorSizes, 0, max_program_size * sizeof(int_fast32_t));

		iteratorCount = 1;
		iteratorSizes[0] = programSize;
		firstIteratorWithNonZeroDataDelta = 0;
		lastExecutionMaxProgramIdx = 0;
		bracketIdx = 0;

		bracketIdx = 0;
		brackets[0].bracket = Bracket::EMPTY;
		brackets[0].depth = 0;
		jumps[0].zero = jumps[0].nonzero = 1;
		
		if (!NextValidIteratorSizes(threadOffset))
		{
			return;
		}
		bracketIdx = 0;
		while (!NextBrackets())
		{
			if (!NextValidIteratorSizes(threadDelta))
			{
				return;
			}
			bracketIdx = 0;
		}
		lastExecutionMaxProgramIdx = iteratorCount - 1;

		iteratorIdx = 0;
		iterators[0].Start(iteratorSizes[0]);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, 0x18(%rdi)
xorl %r13d, %r13d
movq %r13, 0x4270(%rdi)
movq %rdx, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
addq $0x28, %rdi
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x2100
movl $0x1, %eax
movq %rax, 0x20(%rbx)
movq %r12, 0x28(%rbx)
movq %r13, 0x4240(%rbx)
movq %r13, 0x4470(%rbx)
movq %r13, 0x4230(%rbx)
movl $0x0, 0x3e30(%rbx)
movq %r13, 0x3e38(%rbx)
movq %rax, 0x4038(%rbx)
movq %rax, 0x4030(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5b66
testb %al, %al
je 0x5b26
movq $0x0, 0x4230(%rbx)
movq %rbx, %rdi
callq 0x5c84
testb %al, %al
jne 0x5b30
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x5afe
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rsi
decq %rax
movq %rax, 0x4470(%rbx)
movq $0x0, 0x4238(%rbx)
addq $0x128, %rbx            # imm = 0x128
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x5e3e
nop
// File: /workspace/github_cpp_makefile_star2_O1/ksabry[P]bfbrute/src/ProgramIterator.h
// Function: ProgramIterator<400ul, 32ul, 12ul, 32ul>::NextValidIteratorSizes(unsigned long)
bool NextValidIteratorSizes(uint_fast32_t count)
	{
		for (int_fast32_t c = count; c > 0; c--)
		{
			while (!NextIteratorSizes())
			{
#ifdef SINGLE_ITER_COUNT
				if (iteratorCount == 1) iteratorCount = SINGLE_ITER_COUNT;
				else return false;
#else
				iteratorCount += 2;
#endif
				remainingSize = programSize - iteratorCount + 1;
				if (remainingSize <= 0) return false;

				for (uint_fast32_t i = 0; i < iteratorCount - 2; i++)
				{
					assert(i >= 0 && i < max_program_size);
					iteratorSizes[i] = 0;
				}
#ifdef INITIAL_ZERO
				iteratorSizes[0] = 1;
				remainingSize--;
				if (remainingSize < 0) return false;
#endif
				assert(iteratorCount - 2 >= 0 && iteratorCount - 2 < max_program_size);
				// Set to -1 so that after the first call to NextIteratorSizes it will be 0
				iteratorSizes[iteratorCount - 2] = -1;
				remainingSize++;
				firstIteratorWithNonZeroDataDelta = 0;
			}
		}
		return true;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
setle %bl
jle 0x5c34
movq %rsi, %r15
movq %rdi, %r14
movabsq $0x7ffffffffffffffe, %r12 # imm = 0x7FFFFFFFFFFFFFFE
movq %r14, %rdi
callq 0x5ed6
testb %al, %al
jne 0x5c20
movq 0x18(%r14), %rcx
movq 0x20(%r14), %rax
leaq 0x2(%rax), %rdx
movq %rdx, 0x20(%r14)
subq %rdx, %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x3e28(%r14)
cmpq %r12, %rcx
ja 0x5c34
testq %rax, %rax
je 0x5bdb
xorl %ecx, %ecx
cmpq $0x20, %rcx
je 0x5c45
movq $0x0, 0x28(%r14,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x5bc4
movq $0x1, 0x28(%r14)
movq 0x3e28(%r14), %rcx
leaq -0x1(%rcx), %rdx
movq %rdx, 0x3e28(%r14)
testq %rcx, %rcx
jle 0x5c34
cmpq $0x20, %rax
jae 0x5c64
movq $-0x1, 0x28(%r14,%rax,8)
incq 0x3e28(%r14)
movq $0x0, 0x4240(%r14)
jmp 0x5b8a
leaq -0x1(%r15), %rax
cmpq $0x2, %r15
setl %bl
movq %rax, %r15
jge 0x5b8a
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x35ce(%rip), %rdi      # 0x921a
leaq 0x35e6(%rip), %rsi      # 0x9239
leaq 0x35f5(%rip), %rcx      # 0x924f
movl $0x103, %edx            # imm = 0x103
callq 0x2120
leaq 0x367d(%rip), %rdi      # 0x92e8
leaq 0x35c7(%rip), %rsi      # 0x9239
leaq 0x35d6(%rip), %rcx      # 0x924f
movl $0x10b, %edx            # imm = 0x10B
callq 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O1/ksabry[P]bfbrute/src/LinearIterator.h
// Function: LinearIterator<32ul, 12ul, 32ul>::Start(unsigned long)
void Start(uint_fast32_t programSize)
	{
		stackSize = programSize == 0 ? 1 : (programSize - 1) / cache_size + 1;
		firstCacheSize = programSize == 0 ? 0 : (programSize - 1) % cache_size + 1;
	
		indexStack[0] = cache->bordersBalanced[firstCacheSize];
		balancedStack[0] = true;
		for (uint_fast32_t i = 1; i < stackSize; i++)
		{
			indexStack[i] = cache->bordersBalanced[cache_size];
			balancedStack[i] = true;
		}
		first = true;
	}

// Assembly:
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
testq %rsi, %rsi
je 0x5e5d
leaq -0x1(%rsi), %rax
mulq %rcx
shrq $0x3, %rdx
incq %rdx
jmp 0x5e62
movl $0x1, %edx
movq %rdx, 0x8(%rdi)
testq %rsi, %rsi
je 0x5e87
decq %rsi
movq %rsi, %rax
mulq %rcx
shrq %rdx
andq $-0x4, %rdx
leaq (%rdx,%rdx,2), %rax
subq %rax, %rsi
incq %rsi
jmp 0x5e89
xorl %esi, %esi
movq %rsi, 0x10(%rdi)
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq 0x88(%rax,%rsi,8), %rdx
movq %rdx, 0x18(%rdi)
movb $0x1, 0x30(%rdi)
cmpq $0x2, %rcx
jb 0x5ece
xorl %ecx, %ecx
movq 0xe8(%rax), %rdx
movq %rdx, 0x20(%rdi,%rcx,8)
movb $0x1, 0x31(%rdi,%rcx)
leaq 0x1(%rcx), %rdx
addq $0x2, %rcx
cmpq 0x8(%rdi), %rcx
movq %rdx, %rcx
jb 0x5eac
movb $0x1, 0xe0(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/ksabry[P]bfbrute/src/ProgramIterator.h
// Function: ProgramIterator<400ul, 32ul, 12ul, 32ul>::NextIteratorSizes()
bool NextIteratorSizes()
	{
		int_fast32_t iteratorSizesIdx;
	restart:;
		iteratorSizesIdx = iteratorCount - 2;
		while (iteratorSizesIdx >= 0)
		{
			if (remainingSize == 0)
			{
				remainingSize += iteratorSizes[iteratorSizesIdx];
				assert(iteratorSizesIdx >= 0 && iteratorSizesIdx < max_program_size);
				iteratorSizes[iteratorSizesIdx] = 0;
				iteratorSizesIdx--;
			}
			else
			{
				assert(iteratorSizesIdx >= 0 && iteratorSizesIdx < max_program_size);
#ifdef MAX_FIRST_SIZE
				if (iteratorSizesIdx == 0 && iteratorSizes[0] >= MAX_FIRST_SIZE)
					return false;
#endif
				iteratorSizes[iteratorSizesIdx]++;
				assert(iteratorCount - 1 >= 0 && iteratorCount - 1 < max_program_size);
				remainingSize--;
#ifdef NO_ENDING
				if (remainingSize != 0) goto restart;
#endif
				iteratorSizes[iteratorCount - 1] = remainingSize;
				return true;
			}
		}
		return false;
	}

// Assembly:
pushq %rax
movq 0x20(%rdi), %rcx
addq $-0x2, %rcx
js 0x5f4c
movq %rcx, %rax
cmpq $0x0, 0x3e28(%rdi)
jne 0x5f11
movq 0x28(%rdi,%rax,8), %rdx
movq %rdx, 0x3e28(%rdi)
cmpq $0x20, %rcx
jae 0x5f50
movq $0x0, 0x28(%rdi,%rax,8)
addq $-0x1, %rax
jb 0x5ee4
jmp 0x5f4c
cmpq $0x20, %rax
jae 0x5f6f
testq %rax, %rax
jne 0x5f23
cmpq $0x0, 0x28(%rdi)
jg 0x5f4c
incq 0x28(%rdi,%rax,8)
movq 0x20(%rdi), %rax
leaq -0x1(%rax), %rcx
cmpq $0x20, %rcx
jae 0x5f8e
decq 0x3e28(%rdi)
jne 0x5ed7
movq $0x0, 0x20(%rdi,%rax,8)
movb $0x1, %al
jmp 0x5f4e
xorl %eax, %eax
popq %rcx
retq
leaq 0x33d0(%rip), %rdi      # 0x9327
leaq 0x32db(%rip), %rsi      # 0x9239
leaq 0x33ff(%rip), %rcx      # 0x9364
movl $0x1db, %edx            # imm = 0x1DB
callq 0x2120
leaq 0x33b1(%rip), %rdi      # 0x9327
leaq 0x32bc(%rip), %rsi      # 0x9239
leaq 0x33e0(%rip), %rcx      # 0x9364
movl $0x1e1, %edx            # imm = 0x1E1
callq 0x2120
leaq 0x3456(%rip), %rdi      # 0x93eb
leaq 0x329d(%rip), %rsi      # 0x9239
leaq 0x33c1(%rip), %rcx      # 0x9364
movl $0x1e7, %edx            # imm = 0x1E7
callq 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O1/ksabry[P]bfbrute/src/ProgramIterator.h
// Function: ProgramIterator<400ul, 32ul, 12ul, 32ul>::SetJumps()
void SetJumps()
	{
		uint_fast32_t leftBracketStack[max_program_size];

		for (uint_fast32_t i = 0; i < iteratorCount - 1; i++)
		{
			if (brackets[i].bracket == Bracket::LEFT)
			{
				leftBracketStack[brackets[i].depth] = i;
			}
			else
			{
				uint_fast32_t lbracket = leftBracketStack[brackets[i - 1].depth];
				jumps[i].zero = jumps[lbracket].zero = i + 1;
				jumps[i].nonzero = jumps[lbracket].nonzero = lbracket + 1;
			}
		}
	}

// Assembly:
movq 0x20(%rdi), %rax
cmpq $0x1, %rax
je 0x6023
subq $0x88, %rsp
leaq 0x4030(%rdi), %rcx
addq $0x3e28, %rdi           # imm = 0x3E28
movl $0x1, %edx
cmpl $0x1, 0x8(%rdi)
jne 0x5fe7
leaq -0x1(%rdx), %rsi
movq 0x10(%rdi), %r8
movq %rsi, -0x80(%rsp,%r8,8)
jmp 0x6010
movq (%rdi), %rsi
movq -0x80(%rsp,%rsi,8), %rsi
movq %rsi, %r8
shlq $0x4, %r8
movq %rdx, (%rcx,%r8)
movq %rdx, 0x208(%rdi)
incq %rsi
movq %rsi, 0x8(%rcx,%r8)
movq %rsi, 0x210(%rdi)
addq $0x10, %rdi
incq %rdx
cmpq %rdx, %rax
jne 0x5fd2
addq $0x88, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ksabry[P]bfbrute/src/ProgramSearch.h
// Function: ProgramSearch<ProgramIterator<400ul, 32ul, 12ul, 32ul>, DataCache<32ul, 12ul>>::CountSize()
void CountSize()
	{
		PIteratorT iterator;
		iterator.SetCache(&cache);
		iterator.SetDivisionTable(&divisionTable);

		std::cout << " Calculating program count for size " << programSize << "...\r" << std::flush;
		programSizeCount = iterator.TotalCount(programSize);
		std::cout << std::endl << " Completed program count calculation for size " << programSize << std::endl;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x4578, %rsp           # imm = 0x4578
movq %rdi, %rbx
movl $0x128, %eax            # imm = 0x128
movq $0x0, (%rsp,%rax)
addq $0x1e8, %rax            # imm = 0x1E8
cmpq $0x3e28, %rax           # imm = 0x3E28
jne 0x603a
xorps %xmm0, %xmm0
movups %xmm0, 0x4258(%rsp)
movups %xmm0, 0x4248(%rsp)
movq $0x0, 0x4268(%rsp)
leaq 0x8(%rbx), %rax
movq %rax, (%rsp)
movl $0x128, %ecx            # imm = 0x128
movq %rax, (%rsp,%rcx)
addq $0x1e8, %rcx            # imm = 0x1E8
cmpq $0x3e28, %rcx           # imm = 0x3E28
jne 0x607c
leaq 0x1f8(%rbx), %rax
movq %rsp, %r15
movq %rax, 0x4460(%r15)
movq 0x6f30(%rip), %r14      # 0xcfd8
leaq 0x34e3(%rip), %rsi      # 0x9592
movl $0x24, %edx
movq %r14, %rdi
callq 0x2270
movq 0x85a20(%rbx), %rsi
movq %r14, %rdi
callq 0x2140
movq %rax, %r12
leaq 0x34e2(%rip), %rsi      # 0x95b7
movl $0x4, %edx
movq %rax, %rdi
callq 0x2270
movq %r12, %rdi
callq 0x2150
movq 0x85a20(%rbx), %rsi
movq %r15, %rdi
callq 0x6fd6
movq %rax, 0x85a28(%rbx)
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq %rax, %r14
leaq 0x348b(%rip), %rsi      # 0x95bc
movl $0x2e, %edx
movq %rax, %rdi
callq 0x2270
movq 0x85a20(%rbx), %rsi
movq %r14, %rdi
callq 0x2140
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
addq $0x4578, %rsp           # imm = 0x4578
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ksabry[P]bfbrute/src/ProgramIterator.h
// Function: ProgramIterator<400ul, 32ul, 12ul, 32ul>::TotalCount(unsigned long)
uint_fast64_t TotalCount(uint_fast32_t programSize)
	{
		uint_fast64_t result = 0;
		
		Start(programSize, 0, 1);
		while (true)
		{
			uint_fast64_t iteratorsResult = 1;
			for (uint_fast32_t i = 0; i < iteratorCount; i++)
			{
				iteratorsResult *= iterators[0].SizeCount(iteratorSizes[i]);
			}
			result += iteratorsResult;

			while (!NextBrackets())
			{
				if (!NextValidIteratorSizes(threadDelta))
				{
					return result;
				}
				bracketIdx = 0;
			}
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
movl $0x1, %ecx
xorl %edx, %edx
callq 0x5a7c
leaq 0x128(%rbx), %r14
movq %rax, %r12
cmpq $0x0, 0x20(%rbx)
movl $0x1, %r13d
je 0x7026
xorl %ebp, %ebp
movq 0x28(%rbx,%rbp,8), %rsi
movq %r14, %rdi
callq 0x7096
imulq %rax, %r13
incq %rbp
cmpq 0x20(%rbx), %rbp
jb 0x700c
addq %r13, %r15
movq %rbx, %rdi
callq 0x5c84
movl %eax, %ebp
testb %al, %al
je 0x703c
movq %r12, %rax
jmp 0x707d
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x5b66
movl %eax, %ecx
movq %r15, %rax
testb %cl, %cl
je 0x707d
movq $0x0, 0x4230(%rbx)
movq %rbx, %rdi
callq 0x5c84
movl %eax, %ebp
testb %al, %al
jne 0x7037
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x5b66
testb %al, %al
jne 0x7051
movq %r15, %rax
testb %bpl, %bpl
jne 0x6ffa
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ksabry[P]bfbrute/src/LinearIterator.h
// Function: LinearIterator<32ul, 12ul, 32ul>::SizeCount(unsigned long)
uint_fast64_t SizeCount(uint_fast32_t programSize)
	{
		uint_fast32_t stackSize = programSize == 0 ? 1 : (programSize - 1) / cache_size + 1;
		uint_fast32_t firstCacheSize = programSize == 0 ? 0 : (programSize - 1) % cache_size + 1;

		uint_fast32_t cacheSizeCount = cache->SizeCount(cache_size);
		uint_fast64_t result = cache->SizeCount(firstCacheSize);
		for (uint_fast32_t i = 1; i < stackSize; i++)
		{
			result *= cacheSizeCount;
		}
		return result;
	}

// Assembly:
movabsq $-0x5555555555555555, %r8 # imm = 0xAAAAAAAAAAAAAAAB
testq %rsi, %rsi
je 0x70b8
leaq -0x1(%rsi), %rax
mulq %r8
movq %rdx, %rcx
shrq $0x3, %rcx
incq %rcx
jmp 0x70bd
movl $0x1, %ecx
testq %rsi, %rsi
je 0x70de
decq %rsi
movq %rsi, %rax
mulq %r8
shrq %rdx
andq $-0x4, %rdx
leaq (%rdx,%rdx,2), %rax
subq %rax, %rsi
incq %rsi
jmp 0x70e0
xorl %esi, %esi
movq (%rdi), %rdi
movq 0x88(%rdi,%rsi,8), %rdx
movq 0x90(%rdi,%rsi,8), %rax
addq 0x100(%rdi,%rsi,8), %rax
addq 0xf8(%rdi,%rsi,8), %rdx
subq %rdx, %rax
cmpq $0x2, %rcx
jb 0x7137
movq 0xe8(%rdi), %rsi
movq 0xf0(%rdi), %rdx
addq 0x160(%rdi), %rdx
addq 0x158(%rdi), %rsi
subq %rsi, %rdx
decq %rcx
imulq %rdx, %rax
decq %rcx
jne 0x712e
retq
// File: /workspace/github_cpp_makefile_star2_O1/ksabry[P]bfbrute/src/ProgramIterator.h
// Function: ProgramIterator<400ul, 32ul, 12ul, 32ul>::Next()
bool Next()
	{
		serializeLock.lock();
		while (!NextIterators())
		{
			int_fast64_t iteratorsCount = 1;
			for (uint_fast32_t i = 0; i < iteratorCount; i++)
			{
				iteratorsCount *= iterators[0].SizeCount(iteratorSizes[i]);
			}
			currentCount += iteratorsCount;

			while (!NextBrackets())
			{
				if (!NextValidIteratorSizes(threadDelta))
				{
					serializeLock.unlock();
					return false;
				}
				bracketIdx = 0;
			}
			iteratorIdx = 0;
			iterators[0].Start(iteratorSizes[0]);
			lastExecutionMaxProgramIdx = iteratorCount - 1;
		}
		serializeLock.unlock();
		return true;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x4248(%rdi), %rbx
movq %rbx, %rdi
callq 0x22d0
testl %eax, %eax
jne 0x722e
leaq 0x128(%r14), %r15
movq %r14, %rdi
callq 0x7720
movl %eax, %ebp
testb %al, %al
jne 0x7215
cmpq $0x0, 0x20(%r14)
je 0x71a2
movl $0x1, %r12d
xorl %r13d, %r13d
movq 0x28(%r14,%r13,8), %rsi
movq %r15, %rdi
callq 0x7096
imulq %rax, %r12
incq %r13
cmpq 0x20(%r14), %r13
jb 0x7186
jmp 0x71a8
movl $0x1, %r12d
addq %r12, 0x4270(%r14)
movq %r14, %rdi
callq 0x5c84
movl %eax, %r12d
testb %al, %al
jne 0x71db
movq 0x10(%r14), %rsi
movq %r14, %rdi
callq 0x5b66
testb %al, %al
je 0x7202
movq $0x0, 0x4230(%r14)
jmp 0x71af
movq $0x0, 0x4238(%r14)
movq 0x28(%r14), %rsi
movq %r15, %rdi
callq 0x5e3e
movq 0x20(%r14), %rax
decq %rax
movq %rax, 0x4470(%r14)
jmp 0x720a
movq %rbx, %rdi
callq 0x2170
testb %r12b, %r12b
jne 0x7164
jmp 0x721d
movq %rbx, %rdi
callq 0x2170
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x2130
nop
// File: /workspace/github_cpp_makefile_star2_O1/ksabry[P]bfbrute/src/ProgramIterator.h
// Function: ProgramIterator<400ul, 32ul, 12ul, 32ul>::GetProgram()
char* GetProgram()
	{
		char* output = currentProgram;
		for (uint32_t i = 0; i < iteratorCount; i++)
		{
			char* iterProg = iterators[i].GetProgram();
			strcpy(output, iterProg); 
			output += strlen(output);
			if (i < iteratorCount - 1)
			{
				output[0] = brackets[i].bracket == Bracket::LEFT ? '[' : brackets[i].bracket == Bracket::RIGHT ? ']' : '_';
			}
			output++;
			assert(output <= currentProgram + sizeof(currentProgram));
		}
		output[0] = '\0';
		return currentProgram;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x4478(%rdi), %r15
cmpq $0x0, 0x20(%rdi)
movq %r15, 0x8(%rsp)
je 0x72fc
movq %rdi, %r14
leaq 0x128(%rdi), %r12
leaq 0x3e30(%rdi), %rax
movq %rax, 0x10(%rsp)
movl $0x4478, %r13d          # imm = 0x4478
movl $0x1, %ebp
xorl %ebx, %ebx
movq 0x8(%rsp), %r15
imulq $0x1e8, %rbx, %rdi      # imm = 0x1E8
addq %r12, %rdi
callq 0x7a58
movq %r15, %rdi
movq %rax, %rsi
callq 0x21f0
movq %r15, %rdi
callq 0x20c0
addq %r13, %rax
movq 0x20(%r14), %rcx
decq %rcx
cmpq %rbx, %rcx
jbe 0x72dd
shlq $0x4, %rbx
movq 0x10(%rsp), %rcx
movl (%rcx,%rbx), %ecx
cmpl $0x2, %ecx
setne %dl
addb %dl, %dl
orb $0x5d, %dl
cmpl $0x1, %ecx
movzbl %dl, %ecx
movl $0x5b, %edx
cmovel %edx, %ecx
movb %cl, (%r14,%rax)
cmpq $0x4578, %rax           # imm = 0x4578
jge 0x7314
leaq (%r14,%rax), %r15
incq %r15
incq %rax
movl %ebp, %ebx
incl %ebp
movq %rax, %r13
cmpq %rbx, 0x20(%r14)
ja 0x7283
movb $0x0, (%r15)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2301(%rip), %rdi      # 0x961c
leaq 0x1f17(%rip), %rsi      # 0x9239
leaq 0x2325(%rip), %rcx      # 0x964e
movl $0x3ab, %edx            # imm = 0x3AB
callq 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O1/ksabry[P]bfbrute/src/ProgramSearch.h
// Function: ProgramSearch<ProgramIterator<400ul, 32ul, 12ul, 32ul>, DataCache<32ul, 12ul>>::SaveFindStringProgress()
void SaveFindStringProgress()
	{
		lock.lock();

		std::string filename = Filename();
		std::ofstream file(filename, std::ofstream::trunc);
		
		file << programSize << "\n";
		int64_t elapsed = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now() - sizeStart).count();
		file << elapsed << "\n\n";

		for (uint_fast32_t i = 0; i < THREAD_COUNT; i++)
		{
			iterators[i].Serialize(file);
			file << "\n\n";
		}
		file.close();

		lock.unlock();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
leaq 0x5ec4(%rip), %rdi      # 0xd210
callq 0x22d0
testl %eax, %eax
jne 0x7499
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4dca
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movl $0x20, %edx
callq 0x23d0
movq 0x85a20(%rbx), %rsi
leaq 0x28(%rsp), %rdi
callq 0x2140
leaq 0x233d(%rip), %rsi      # 0x96d0
movl $0x1, %edx
movq %rax, %rdi
callq 0x2270
callq 0x2040
subq 0x85a30(%rbx), %rax
movabsq $0x112e0be826d694b3, %rcx # imm = 0x112E0BE826D694B3
imulq %rcx
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x1a, %rdx
addq %rdx, %rsi
leaq 0x28(%rsp), %rdi
callq 0x2200
leaq 0x22f7(%rip), %rsi      # 0x96cf
movl $0x2, %edx
movq %rax, %rdi
callq 0x2270
addq $0x401f8, %rbx          # imm = 0x401F8
xorl %r12d, %r12d
leaq 0x28(%rsp), %r14
leaq 0x22d4(%rip), %r15      # 0x96cf
leaq (%rbx,%r12), %rdi
movq %r14, %rsi
callq 0x7b02
movl $0x2, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2270
addq $0x4578, %r12           # imm = 0x4578
cmpq $0x45780, %r12          # imm = 0x45780
jne 0x73fb
leaq 0x28(%rsp), %rdi
callq 0x22b0
leaq 0x5dd8(%rip), %rdi      # 0xd210
callq 0x2170
movq 0x5b8c(%rip), %rax      # 0xcfd0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x30(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x28(%rsp,%rcx)
callq 0x21a0
leaq 0x120(%rsp), %rdi
callq 0x2090
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x748a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x2130
movq %rax, %rbx
jmp 0x74b6
jmp 0x74a9
jmp 0x74a9
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x22e0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x74d1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x23a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/ksabry[P]bfbrute/src/ProgramIterator.h
// Function: ProgramIterator<400ul, 32ul, 12ul, 32ul>::NextIterators()
bool NextIterators()
	{
		if (iteratorIdx == iteratorCount - 1 && !lastExecutionSuccessful)
		{
			iteratorIdx = lastExecutionMaxProgramIdx;
		}

		while (iteratorIdx >= 0)
		{
			if (NextSingleIterator())
			{
				if (iteratorIdx == iteratorCount - 1)
				{
					return true;
				}
				iteratorIdx++;
				iterators[iteratorIdx].Start(iteratorSizes[iteratorIdx]);
			}
			else
			{
				iteratorIdx--;
			}
		}
		return false;
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rax
decq %rax
cmpq %rax, 0x4238(%rdi)
jne 0x774e
cmpb $0x0, 0x4468(%rbx)
jne 0x774e
movq 0x4470(%rbx), %rax
movq %rax, 0x4238(%rbx)
cmpq $0x0, 0x4238(%rbx)
setns %bpl
js 0x77bb
leaq 0x128(%rbx), %r14
movq %rbx, %rdi
callq 0x77c6
movq 0x4238(%rbx), %rcx
testb %al, %al
je 0x77a3
movq 0x20(%rbx), %rax
decq %rax
cmpq %rax, %rcx
je 0x77bb
leaq 0x1(%rcx), %rax
movq %rax, 0x4238(%rbx)
imulq $0x1e8, %rax, %rdi      # imm = 0x1E8
addq %r14, %rdi
movq 0x30(%rbx,%rcx,8), %rsi
callq 0x5e3e
jmp 0x77ad
decq %rcx
movq %rcx, 0x4238(%rbx)
cmpq $0x0, 0x4238(%rbx)
setns %bpl
jns 0x7763
andb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ksabry[P]bfbrute/src/ProgramIterator.h
// Function: ProgramIterator<400ul, 32ul, 12ul, 32ul>::NextSingleIterator()
bool NextSingleIterator()
	{
		while (iterators[iteratorIdx].Next())
		{
#if defined INITIAL_ZERO || defined INITIAL_DATA_SYMMETRIC
			// Check that the first iterator has a right delta
			if (iteratorIdx <= firstIteratorWithNonZeroDataDelta)
			{
				int_fast32_t dataDelta = iterators[iteratorIdx].DataDelta();
				if (dataDelta < 0)
				{
					continue;
				}
				else if (dataDelta > 0)
				{
					firstIteratorWithNonZeroDataDelta = iteratorIdx;
				}
				else
				{
					firstIteratorWithNonZeroDataDelta = iteratorIdx + 1;
				}
			}
#endif

#ifdef INITIAL_ZERO
			// Do not permit guaranteed 0 after initial iterator or meaningless movements at the beginning
			auto& data = iterators[0].Data();
			if (iteratorIdx == 0 && (data.data[data.idx + cache_data_size / 2] == 0 || data.data[cache_data_size / 2] == 0))
			{
				continue;
			}
#endif

			// Remove patterns equivalent to [+]
			// Note that while [+*] and [-*] are not necessarily equivalent in behavior to [+], the cases in which they are not equivalent are always infinite loops and so can be safely pruned
			if (
				iteratorIdx > 0
				&& brackets[iteratorIdx - 1].bracket == Bracket::LEFT
				&& brackets[iteratorIdx].bracket == Bracket::RIGHT
				&&
				(
					// Do not permit [-*] with any amount of minuses
					iterators[iteratorIdx].Data().data[cache_data_size / 2] == 256 - iteratorSizes[iteratorIdx]
					// Do not permit [+*] with more than 1 plus
					|| iteratorSizes[iteratorIdx] > 1 && iterators[iteratorIdx].Data().data[cache_data_size / 2] == iteratorSizes[iteratorIdx]
				)
			)
			{
				continue;
			}

			return true;
		}
		return false;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
imulq $0x1e8, 0x4238(%rdi), %rax # imm = 0x1E8
addq %rax, %rdi
addq $0x128, %rdi            # imm = 0x128
callq 0x78b8
testb %al, %al
je 0x78b0
leaq 0x3e30(%rbx), %r14
leaq 0x128(%rbx), %r15
movq 0x4238(%rbx), %rcx
cmpq 0x4240(%rbx), %rcx
jg 0x7831
imulq $0x1e8, %rcx, %rdx      # imm = 0x1E8
movq 0x58(%r15,%rdx), %rdx
testq %rdx, %rdx
js 0x7895
cmpq $0x1, %rdx
movq %rcx, %rdx
adcq $0x0, %rdx
movq %rdx, 0x4240(%rbx)
testq %rcx, %rcx
jne 0x7850
movq 0x180(%rbx), %rdx
cmpb $0x0, 0x170(%rbx,%rdx)
je 0x7895
cmpb $0x0, 0x170(%rbx)
je 0x7895
testq %rcx, %rcx
jle 0x78b0
movq %rcx, %rdx
shlq $0x4, %rdx
cmpl $0x1, -0x10(%rdx,%r14)
jne 0x78b0
cmpl $0x2, (%r14,%rdx)
jne 0x78b0
imulq $0x1e8, %rcx, %rdx      # imm = 0x1E8
movzbl 0x48(%r15,%rdx), %edx
movq 0x28(%rbx,%rcx,8), %rcx
movl $0x100, %esi            # imm = 0x100
subq %rcx, %rsi
cmpq %rdx, %rsi
je 0x7895
cmpq $0x2, %rcx
jl 0x78b0
cmpq %rdx, %rcx
jne 0x78b0
imulq $0x1e8, 0x4238(%rbx), %rdi # imm = 0x1E8
addq %r15, %rdi
callq 0x78b8
testb %al, %al
jne 0x77fe
andb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ksabry[P]bfbrute/src/LinearIterator.h
// Function: LinearIterator<32ul, 12ul, 32ul>::Next()
bool Next()
	{
		if (first)
		{
			first = false;
			for (int i = stackSize - 1; i >= 0; i--) CalcData(i);
			return true;
		}
		return Inc();
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0xe0(%rdi)
jne 0x78fa
movb $0x0, 0xe0(%rbx)
movl 0x8(%rbx), %eax
decl %eax
js 0x78f0
movl %eax, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5922
leaq -0x1(%r14), %rax
testq %r14, %r14
movq %rax, %r14
jg 0x78d9
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x790a
nop
// File: /workspace/github_cpp_makefile_star2_O1/ksabry[P]bfbrute/src/LinearIterator.h
// Function: LinearIterator<32ul, 12ul, 32ul>::Inc()
bool Inc()
	{
		if (IncSingle(indexStack[0], balancedStack[0], firstCacheSize))
		{
			CalcData(0);
			return true;
		}
		for (uint_fast32_t i = 1; i < stackSize; i++)
		{
			if (IncSingle(indexStack[i], balancedStack[i], cache_size))
			{
				for (int j = i; j >= 0; j--) CalcData(j);
				return true;
			}
		}
		return false;
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %rsi
leaq 0x30(%rdi), %rdx
movq 0x10(%rdi), %rcx
callq 0x79fe
testb %al, %al
je 0x7938
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5922
movb $0x1, %bpl
jmp 0x79f3
cmpq $0x2, 0x8(%rbx)
setae %bpl
jb 0x79f3
movl $0x31, %r14d
movb (%rbx,%r14), %cl
movq (%rbx), %rax
leaq 0x160(%rax), %rdx
leaq 0xf0(%rax), %rsi
testb %cl, %cl
cmovneq %rsi, %rdx
movq -0x168(%rbx,%r14,8), %rsi
incq %rsi
cmpq (%rdx), %rsi
movq %rsi, -0x168(%rbx,%r14,8)
jb 0x79cc
testb %cl, %cl
je 0x798d
cmpq $0x0, 0x10(%rbx)
je 0x79a1
jmp 0x79b8
movq 0xe8(%rax), %rax
movq %rax, -0x168(%rbx,%r14,8)
movb $0x1, (%rbx,%r14)
leaq 0x1(%r14), %rax
addq $-0x2f, %r14
cmpq 0x8(%rbx), %r14
setb %bpl
movq %rax, %r14
jb 0x794d
jmp 0x79f3
movq 0x158(%rax), %rax
movq %rax, -0x168(%rbx,%r14,8)
movb $0x0, (%rbx,%r14)
addq $-0x30, %r14
testl %r14d, %r14d
js 0x79f3
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5922
leaq -0x1(%r14), %rax
testq %r14, %r14
movq %rax, %r14
jg 0x79dc
andb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ksabry[P]bfbrute/src/LinearIterator.h
// Function: LinearIterator<32ul, 12ul, 32ul>::IncSingle(unsigned long&, bool&, unsigned long)
bool IncSingle(uint_fast32_t& index, bool& balanced, uint_fast32_t frame_size)
	{
		uint_fast32_t end = balanced ? cache->bordersBalanced[frame_size + 1] : cache->bordersUnbalanced[frame_size + 1];
		
		if (++index >= end)
		{
			if (balanced)
			{
				if (firstCacheSize == 0) return false;
				index = cache->bordersUnbalanced[frame_size];
				balanced = false;
				return true;
			}
			else
			{
				index = cache->bordersBalanced[frame_size];
				balanced = true;
				return false;
			}
		}
		return true;
	}

// Assembly:
movb (%rdx), %r8b
movq (%rdi), %r9
leaq 0x88(%r9), %rax
leaq 0xf8(%r9), %r10
testb %r8b, %r8b
cmovneq %rax, %r10
movq (%rsi), %r11
incq %r11
movb $0x1, %al
cmpq 0x8(%r10,%rcx,8), %r11
movq %r11, (%rsi)
jb 0x7a3f
testb %r8b, %r8b
je 0x7a40
movl $0xf8, %r10d
xorl %eax, %eax
cmpq $0x0, 0x10(%rdi)
jne 0x7a48
retq
movb $0x1, %al
movl $0x88, %r10d
addq %r10, %r9
movq (%r9,%rcx,8), %rcx
movq %rcx, (%rsi)
movb %al, (%rdx)
movl %r8d, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/ksabry[P]bfbrute/src/LinearIterator.h
// Function: LinearIterator<32ul, 12ul, 32ul>::GetProgram()
char* GetProgram()
	{
		uint_fast32_t pIndex = 0;

		for (int i = static_cast<int>(stackSize - 1); i >= 0; i--)
		{
			uint_fast32_t idx = indexStack[i];
			uint_fast32_t size = i == 0 ? firstCacheSize : cache_size;
			
			char* part;
			if (balancedStack[i])
				part = cache->programsBalanced.data() + (idx * cache_size);
			else
				part = cache->programsUnbalanced.data() + (idx * cache_size);
			
			memcpy(currentProgram + pIndex, part, size * sizeof(char));
			pIndex += size;
		}
		currentProgram[pIndex] = '\0';
		return currentProgram;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %eax
decl %eax
js 0x7add
leaq 0xe1(%rbx), %r15
movl %eax, %r12d
addq $0x30, %r12
xorl %ebp, %ebp
movl $0x58, %r13d
movl $0xc, %r14d
cmpq $0x30, %r12
jne 0x7a93
movq 0x10(%rbx), %r14
movq -0x168(%rbx,%r12,8), %rax
leaq (%rax,%rax,2), %rsi
shlq $0x2, %rsi
cmpb $0x0, (%rbx,%r12)
movl $0x70, %eax
cmovneq %r13, %rax
movq (%rbx), %rcx
addq (%rcx,%rax), %rsi
leaq (%r15,%rbp), %rdi
movq %r14, %rdx
callq 0x2190
addq %rbp, %r14
leaq -0x1(%r12), %rax
addq $-0x30, %r12
movq %r14, %rbp
testq %r12, %r12
movq %rax, %r12
jg 0x7a83
jmp 0x7ae0
xorl %r14d, %r14d
movb $0x0, 0xe1(%rbx,%r14)
addq $0xe1, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ksabry[P]bfbrute/src/LinearIterator.h
// Function: LinearIterator<32ul, 12ul, 32ul>::Serialize(std::ostream&)
void Serialize(std::ostream& output)
	{
		output << stackSize << " " << firstCacheSize << " ";
		for (uint_fast32_t i = 0; i < max_stack_size; i++)
		{
			output << indexStack[i] << " ";
		}
		for (uint_fast32_t i = 0; i < max_stack_size; i++)
		{
			output << balancedStack[i] << " ";
		}
		output << first;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rsi
movq %rbx, %rdi
callq 0x2140
movq %rax, %r12
leaq 0x1236(%rip), %r15      # 0x90fe
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2270
movq 0x10(%r14), %rsi
movq %r12, %rdi
callq 0x2140
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2270
xorl %r12d, %r12d
movq 0x18(%r14,%r12,8), %rsi
movq %rbx, %rdi
callq 0x2140
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2270
incq %r12
cmpq $0x3, %r12
jne 0x7ef7
movq $-0x3, %r12
leaq 0x11d3(%rip), %r15      # 0x90fe
movzbl 0x33(%r14,%r12), %esi
movq %rbx, %rdi
callq 0x2360
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2270
incq %r12
jne 0x7f2b
movzbl 0xe0(%r14), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2360
nop
// File: /workspace/github_cpp_makefile_star2_O1/ksabry[P]bfbrute/src/ModDivisionTable.cpp
// Function: ModDivisionTable::ModDivisionTable()
ModDivisionTable::ModDivisionTable()
{
	for (uint_fast32_t d = 0; d < 256; d++)
	{
		for (uint_fast32_t k = 0; k < 256; k++)
		{
			table[d][k] = -1;
		}
	}

	for (int k = 1; k < 256; k++)
	{
		table[0][k] = 0;
		
		uint8_t mult = k;
		int cnt = 1;
		while (mult)
		{
			table[mult][256 - k] = cnt;
			cnt++;
			mult += k;
		}
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x40000, %edx          # imm = 0x40000
movl $0xff, %esi
callq 0x2100
movl $0x1, %eax
movl $0x0, (%rbx,%rax,4)
movl $0x100, %ecx            # imm = 0x100
subq %rax, %rcx
movl $0x1, %edx
movl %eax, %esi
movl %esi, %edi
shlq $0xa, %rdi
addq %rbx, %rdi
movl %edx, (%rdi,%rcx,4)
incl %edx
addl %eax, %esi
andl $0xff, %esi
jne 0x886e
incq %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x8858
popq %rbx
retq
nop