LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8826(%rip), %rdi      # 0xcfd8
leaq 0x3a50(%rip), %rsi      # 0x8209
callq 0x2210
movq 0x85a20(%rbx), %rsi
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
callq 0x20d0
callq 0x2030
movq %rax, 0x85a30(%rbx)
leaq 0x401f8(%rbx), %r14
xorl %r15d, %r15d
pushq $0x10
popq %r12
cmpq $0x10, %r15
je 0x4816
movq 0x85a20(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
movq %r12, %rcx
callq 0x51ec
incq %r15
addq $0x4578, %r14           # imm = 0x4578
jmp 0x47ef
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x578e
xorl %eax, %eax
pushq $0x8
popq %r14
leaq 0x18(%rsp), %r15
leaq 0x10(%rsp), %r12
leaq 0x8(%rsp), %r13
movq %rax, 0x8(%rsp)
cmpq $0x10, %rax
jae 0x48bd
movq 0x85978(%rbx,%rax,8), %rbp
testq %rbp, %rbp
je 0x4878
movq %rbp, %rdi
callq 0x4460
movq %rbp, %rdi
movq %r14, %rsi
callq 0x2230
movq %r14, %rdi
callq 0x2220
movq %rax, %rbp
leaq 0xfc8(%rip), %rax       # 0x5852
movq %rax, 0x18(%rsp)
andq $0x0, 0x20(%rsp)
movq %rbx, 0x10(%rsp)
movq %rbp, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x609c
movq 0x8(%rsp), %rax
movq %rbp, 0x85978(%rbx,%rax,8)
incq %rax
jmp 0x484d
xorl %r14d, %r14d
cmpq $0x10, %r14
je 0x48d8
movq 0x85978(%rbx,%r14,8), %rdi
callq 0x2370
incq %r14
jmp 0x48c0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x8
popq %rsi
movq %rbp, %rdi
callq 0x2230
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdx, %r14
movb $0x0, 0x10(%rdi)
movq 0x8(%rdx), %rsi
addq %rsi, %rsi
callq 0x2300
movq (%r14), %r15
movq 0x8(%r14), %r14
xorl %r12d, %r12d
leaq 0x393e(%rip), %r13      # 0x8810
cmpq %r12, %r14
je 0x4f04
movzbl (%r15,%r12), %ebp
movl %ebp, %eax
shrl $0x4, %eax
movsbl (%rax,%r13), %esi
movq %rbx, %rdi
callq 0x21a0
andl $0xf, %ebp
movsbl (%rbp,%r13), %esi
movq %rbx, %rdi
callq 0x21a0
incq %r12
jmp 0x4ed2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4f18
movq %rax, %r14
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x18
popq %r15
cmpq $0x30, %r15
je 0x505d
leaq (%rbx,%r15), %rsi
movq %r14, %rdi
callq 0x20f0
addq $0x8, %r15
jmp 0x5045
pushq $0x30
popq %r15
cmpq $0x33, %r15
je 0x5078
leaq (%rbx,%r15), %rsi
movq %r14, %rdi
callq 0x21b0
incq %r15
jmp 0x5061
leaq 0xe0(%rbx), %rsi
movq %r14, %rdi
callq 0x21b0
movl 0x8(%rbx), %r14d
decq %r14
testl %r14d, %r14d
js 0x50a6
movl %r14d, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movq %rbx, %rdi
callq 0x50ae
jmp 0x508b
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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)
pushq $0x28
popq %rax
pushq $0x40
popq %rcx
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 0x5101
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 0x5115
// File: /workspace/github_cpp_makefile_star2_O2/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 0x51d5
movq %rdx, %rbx
movq %rsi, %r14
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
pushq $-0x10
popq %r13
cmovgeq %rdx, %r13
addq 0x30(%rbx), %rax
cmpq $0x10, %rax
pushq $0x10
popq %rbp
cmovlq %rax, %rbp
cmpq %r13, %rcx
cmovgeq %r13, %rcx
movq %rcx, 0x28(%rdi)
movq 0x30(%rsi), %rax
cmpq %rbp, %rax
cmovleq %rbp, %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 0x51d0
leaq (%r15,%rax), %rdi
addq $0x10, %rdi
leaq (%r14,%rax), %rsi
addq $0x10, %rsi
callq 0x2190
jmp 0x51d0
movq %rbx, %rax
subq 0x20(%r14), %rax
movb 0x10(%rax,%r13), %al
addb %al, 0x10(%r15,%r13)
incq %r13
cmpq %rbp, %r13
jl 0x51bc
cmpq $0x20, %r12
setb %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, 0x18(%rdi)
andq $0x0, 0x4270(%rdi)
movq %rdx, %r12
movq %rdx, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
addq $0x30, %rdi
movl $0xf8, %edx
xorl %esi, %esi
callq 0x2100
pushq $0x1
popq %rax
movq %rax, 0x20(%rbx)
movq %r15, 0x28(%rbx)
andq $0x0, 0x4240(%rbx)
andq $0x0, 0x4470(%rbx)
andq $0x0, 0x4230(%rbx)
andl $0x0, 0x3e30(%rbx)
andq $0x0, 0x3e38(%rbx)
movq %rax, 0x4038(%rbx)
movq %rax, 0x4030(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x52d0
testb %al, %al
je 0x528f
andq $0x0, 0x4230(%rbx)
movq %rbx, %rdi
callq 0x53c6
testb %al, %al
jne 0x529b
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x526a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rsi
decq %rax
movq %rax, 0x4470(%rbx)
andq $0x0, 0x4238(%rbx)
addq $0x128, %rbx            # imm = 0x128
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x54ce
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0x7ffffffffffffffe, %r15 # imm = 0x7FFFFFFFFFFFFFFE
testq %rbx, %rbx
jle 0x537c
movq %r14, %rdi
callq 0x553e
testb %al, %al
jne 0x5374
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 %r15, %rcx
ja 0x537c
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x5335
cmpq $0x20, %rcx
je 0x5388
andq $0x0, 0x28(%r14,%rcx,8)
incq %rcx
jmp 0x531f
movq $0x1, 0x28(%r14)
movq 0x3e28(%r14), %rcx
leaq -0x1(%rcx), %rdx
movq %rdx, 0x3e28(%r14)
testq %rcx, %rcx
jle 0x537c
cmpq $0x20, %rax
jae 0x53a7
orq $-0x1, 0x28(%r14,%rax,8)
incq 0x3e28(%r14)
andq $0x0, 0x4240(%r14)
jmp 0x52ee
decq %rbx
jmp 0x52e5
testq %rbx, %rbx
setle %al
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2e8b(%rip), %rdi      # 0x821a
leaq 0x2ea3(%rip), %rsi      # 0x8239
leaq 0x2eb2(%rip), %rcx      # 0x824f
movl $0x103, %edx            # imm = 0x103
callq 0x2120
leaq 0x2f3a(%rip), %rdi      # 0x82e8
leaq 0x2e84(%rip), %rsi      # 0x8239
leaq 0x2e93(%rip), %rcx      # 0x824f
movl $0x10b, %edx            # imm = 0x10B
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/ksabry[P]bfbrute/src/ProgramIterator.h
// Function: ProgramIterator<400ul, 32ul, 12ul, 32ul>::NextBrackets()
bool NextBrackets()
	{
		while (bracketIdx >= 0)
		{
			uint_fast32_t remainingBrackets = iteratorCount - bracketIdx - 1;
			bool left_valid = bracketIdx == 0 ? remainingBrackets >= 2 : remainingBrackets >= brackets[bracketIdx - 1].depth + 2;
			bool right_valid = bracketIdx == 0 ? false : brackets[bracketIdx - 1].depth > 0;

			// EMPTY -> LEFT -> RIGHT -> EMPTY
			assert(bracketIdx >= 0 && bracketIdx < max_program_size);
			if (brackets[bracketIdx].bracket == Bracket::EMPTY)
			{
				if (left_valid)
				{
					if (!SetBracketLeft()) continue;
					bracketIdx++;
				}
				else if (right_valid)
				{
					if (!SetBracketRight()) continue;
					if (bracketIdx == iteratorCount - 2)
					{
						SetJumps();
						return true;
					}
					bracketIdx++;
				}
				else
				{
					bracketIdx--;
				}
			}
			else if (brackets[bracketIdx].bracket == Bracket::LEFT)
			{
				if (right_valid)
				{
					if (!SetBracketRight()) continue;
					if (bracketIdx == iteratorCount - 2)
					{
						SetJumps();
						return true;
					}
					bracketIdx++;
				}
				else
				{
					brackets[bracketIdx].bracket = Bracket::EMPTY;
					bracketIdx--;
				}
			}
			else
			{
				brackets[bracketIdx].bracket = Bracket::EMPTY;
				bracketIdx--;
			}
		}
		return false;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x3e30(%rdi), %r14
movq 0x4230(%rbx), %r15
testq %r15, %r15
js 0x54a3
movq %r15, %rax
notq %rax
addq 0x20(%rbx), %rax
testq %r15, %r15
je 0x541b
movq %r15, %rcx
shlq $0x4, %rcx
movq -0x8(%rcx,%r14), %rdx
leaq 0x2(%rdx), %rcx
cmpq %rcx, %rax
setae %cl
testq %rdx, %rdx
setne %al
cmpq $0x20, %r15
jb 0x5424
jmp 0x54af
cmpq $0x2, %rax
setae %cl
xorl %eax, %eax
movq %r15, %rsi
shlq $0x4, %rsi
leaq (%r14,%rsi), %rdx
movl (%r14,%rsi), %esi
cmpl $0x1, %esi
je 0x5455
testl %esi, %esi
jne 0x5459
testb %cl, %cl
je 0x5464
movq %rbx, %rdi
callq 0x560c
testb %al, %al
je 0x53d5
movq 0x4230(%rbx), %rax
jmp 0x548c
testb %al, %al
jne 0x5468
andl $0x0, (%rdx)
decq %r15
movq %r15, %rax
jmp 0x548f
testb %al, %al
je 0x545c
movq %rbx, %rdi
callq 0x56b6
testb %al, %al
je 0x53d5
movq 0x4230(%rbx), %rax
movq 0x20(%rbx), %rcx
addq $-0x2, %rcx
cmpq %rcx, %rax
je 0x549b
incq %rax
movq %rax, 0x4230(%rbx)
jmp 0x53d5
movq %rbx, %rdi
callq 0x571a
testq %r15, %r15
setns %al
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2f74(%rip), %rdi      # 0x842a
leaq 0x2d7c(%rip), %rsi      # 0x8239
leaq 0x2f97(%rip), %rcx      # 0x845b
movl $0x170, %edx            # imm = 0x170
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/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:
testq %rsi, %rsi
je 0x54ed
decq %rsi
pushq $0xc
popq %rcx
movq %rsi, %rax
xorl %edx, %edx
divq %rcx
incq %rax
movq %rax, 0x8(%rdi)
incq %rdx
jmp 0x54fa
movq $0x1, 0x8(%rdi)
pushq $0x1
popq %rax
xorl %edx, %edx
movq %rdx, 0x10(%rdi)
movq (%rdi), %rcx
movq 0x88(%rcx,%rdx,8), %rdx
movq %rdx, 0x18(%rdi)
movb $0x1, 0x30(%rdi)
xorl %edx, %edx
leaq 0x1(%rdx), %rsi
cmpq %rax, %rsi
jae 0x5536
movq 0xe8(%rcx), %rax
movq %rax, 0x20(%rdi,%rdx,8)
movb $0x1, 0x31(%rdi,%rdx)
movq 0x8(%rdi), %rax
movq %rsi, %rdx
jmp 0x5513
movb $0x1, 0xe0(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %rax
addq $-0x2, %rax
testq %rax, %rax
js 0x55ab
cmpq $0x0, 0x3e28(%rdi)
jne 0x5573
movq 0x28(%rdi,%rax,8), %rcx
movq %rcx, 0x3e28(%rdi)
cmpq $0x20, %rax
jae 0x55af
andq $0x0, 0x28(%rdi,%rax,8)
decq %rax
jmp 0x5547
cmpq $0x20, %rax
jae 0x55ce
testq %rax, %rax
jne 0x5585
cmpq $0x0, 0x28(%rdi)
jg 0x55ab
incq 0x28(%rdi,%rax,8)
movq 0x20(%rdi), %rax
leaq -0x1(%rax), %rcx
cmpq $0x20, %rcx
jae 0x55ed
decq 0x3e28(%rdi)
jne 0x5543
andq $0x0, 0x20(%rdi,%rax,8)
movb $0x1, %al
jmp 0x55ad
xorl %eax, %eax
popq %rcx
retq
leaq 0x2d71(%rip), %rdi      # 0x8327
leaq 0x2c7c(%rip), %rsi      # 0x8239
leaq 0x2da0(%rip), %rcx      # 0x8364
movl $0x1db, %edx            # imm = 0x1DB
callq 0x2120
leaq 0x2d52(%rip), %rdi      # 0x8327
leaq 0x2c5d(%rip), %rsi      # 0x8239
leaq 0x2d81(%rip), %rcx      # 0x8364
movl $0x1e1, %edx            # imm = 0x1E1
callq 0x2120
leaq 0x2df7(%rip), %rdi      # 0x83eb
leaq 0x2c3e(%rip), %rsi      # 0x8239
leaq 0x2d62(%rip), %rcx      # 0x8364
movl $0x1e7, %edx            # imm = 0x1E7
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/ksabry[P]bfbrute/src/ProgramIterator.h
// Function: ProgramIterator<400ul, 32ul, 12ul, 32ul>::SetBracketLeft()
inline bool SetBracketLeft()
	{
		assert(bracketIdx >= 0 && bracketIdx < max_program_size);
		brackets[bracketIdx].bracket = Bracket::LEFT;
		brackets[bracketIdx].depth = bracketIdx == 0 ? 1 : brackets[bracketIdx - 1].depth + 1;

		return (
			iteratorSizes[bracketIdx] > 0
			|| (bracketIdx > 0 && brackets[bracketIdx - 1].bracket == Bracket::LEFT)
		)
#ifdef MAX_BRACKET_DEPTH
		&& brackets[bracketIdx].depth <= MAX_BRACKET_DEPTH
#endif
#ifdef SINGLE_BRACKET_HIERARCHY
		&& (bracketIdx == 0 || brackets[bracketIdx - 1].depth > 0)
#endif 
		;
	}

// Assembly:
movq 0x4230(%rdi), %rcx
cmpq $0x20, %rcx
jae 0x5696
leaq 0x3e30(%rdi), %rdx
movq %rcx, %rax
shlq $0x4, %rax
movl $0x1, 0x3e30(%rdi,%rax)
testq %rcx, %rcx
je 0x5641
movq -0x8(%rax,%rdx), %rsi
incq %rsi
jmp 0x5644
pushq $0x1
popq %rsi
movq %rsi, 0x8(%rdx,%rax)
cmpq $0x0, 0x28(%rdi,%rcx,8)
jle 0x5668
cmpq $0x3, %rsi
setb %al
testq %rcx, %rcx
je 0x5692
cmpq $0x2, %rsi
ja 0x5692
decq %rcx
jmp 0x5685
testq %rcx, %rcx
je 0x5693
decq %rcx
movq %rcx, %rdi
shlq $0x4, %rdi
xorl %eax, %eax
cmpl $0x1, (%rdx,%rdi)
jne 0x5692
cmpq $0x3, %rsi
jae 0x5692
shlq $0x4, %rcx
cmpq $0x0, 0x8(%rdx,%rcx)
setne %al
retq
xorl %eax, %eax
retq
pushq %rax
leaq 0x2d8c(%rip), %rdi      # 0x842a
leaq 0x2b94(%rip), %rsi      # 0x8239
leaq 0x2e31(%rip), %rcx      # 0x84dd
movl $0x1a4, %edx            # imm = 0x1A4
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/ksabry[P]bfbrute/src/ProgramIterator.h
// Function: ProgramIterator<400ul, 32ul, 12ul, 32ul>::SetBracketRight()
inline bool SetBracketRight()
	{
		assert(bracketIdx > 0 && bracketIdx < max_program_size);
		brackets[bracketIdx].bracket = Bracket::RIGHT;
		brackets[bracketIdx].depth = brackets[bracketIdx - 1].depth - 1;

		return iteratorSizes[bracketIdx] > 0;
	}

// Assembly:
movq 0x4230(%rdi), %rax
leaq -0x1(%rax), %rcx
cmpq $0x1f, %rcx
jae 0x56fa
movq %rax, %rdx
shlq $0x4, %rdx
movl $0x2, 0x3e30(%rdi,%rdx)
shlq $0x4, %rcx
movq 0x3e38(%rdi,%rcx), %rcx
decq %rcx
movq %rcx, 0x3e38(%rdi,%rdx)
cmpq $0x0, 0x28(%rdi,%rax,8)
setg %al
retq
pushq %rax
leaq 0x2e5f(%rip), %rdi      # 0x8561
leaq 0x2b30(%rip), %rsi      # 0x8239
leaq 0x2e81(%rip), %rcx      # 0x8591
movl $0x1b7, %edx            # imm = 0x1B7
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/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:
subq $0x88, %rsp
movq 0x20(%rdi), %rax
decq %rax
leaq 0x3e30(%rdi), %rcx
addq $0x4030, %rdi           # imm = 0x4030
xorl %edx, %edx
cmpq %rax, %rdx
jae 0x5786
movq %rdx, %rsi
shlq $0x4, %rsi
cmpl $0x1, (%rcx,%rsi)
jne 0x575b
addq %rcx, %rsi
movq 0x8(%rsi), %rsi
movq %rdx, -0x80(%rsp,%rsi,8)
incq %rdx
jmp 0x5738
movq -0x8(%rsi,%rcx), %r8
movq -0x80(%rsp,%r8,8), %r8
incq %rdx
movq %r8, %r9
shlq $0x4, %r9
movq %rdx, (%rdi,%r9)
movq %rdx, (%rdi,%rsi)
incq %r8
movq %r8, 0x8(%rdi,%r9)
movq %r8, 0x8(%rdi,%rsi)
jmp 0x5738
addq $0x88, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x4580, %rsp           # imm = 0x4580
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x31a6
leaq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x446e
leaq 0x1f8(%rbx), %rax
movq %rax, 0x4460(%r14)
movq 0x780d(%rip), %r15      # 0xcfd8
leaq 0x2e44(%rip), %rsi      # 0x8616
movq %r15, %rdi
callq 0x2210
movq 0x85a20(%rbx), %rsi
movq %rax, %rdi
callq 0x2140
leaq 0x2e4b(%rip), %rsi      # 0x863b
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
callq 0x2150
movq 0x85a20(%rbx), %rsi
movq %r14, %rdi
callq 0x6122
movq %rax, 0x85a28(%rbx)
movq %r15, %rdi
callq 0x20d0
leaq 0x2e1b(%rip), %rsi      # 0x8640
movq %rax, %rdi
callq 0x2210
movq 0x85a20(%rbx), %rsi
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
callq 0x20d0
addq $0x4580, %rsp           # imm = 0x4580
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14d, %r14d
pushq $0x1
popq %r15
xorl %edx, %edx
movq %r15, %rcx
callq 0x51ec
leaq 0x128(%rbx), %r12
movq %r15, %r13
xorl %ebp, %ebp
cmpq 0x20(%rbx), %rbp
jae 0x6169
movq 0x28(%rbx,%rbp,8), %rsi
movq %r12, %rdi
callq 0x61a4
imulq %rax, %r13
incq %rbp
jmp 0x614d
addq %r13, %r14
movq %rbx, %rdi
callq 0x53c6
testb %al, %al
jne 0x6148
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x52d0
testb %al, %al
je 0x6192
andq $0x0, 0x4230(%rbx)
jmp 0x616c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
testq %rsi, %rsi
je 0x61bf
decq %rsi
pushq $0xc
popq %rcx
movq %rsi, %rax
xorl %edx, %edx
divq %rcx
incq %rax
incq %rdx
jmp 0x61c4
pushq $0x1
popq %rax
xorl %edx, %edx
movq (%rdi), %rdi
movq 0xf0(%rdi), %rsi
addq 0x160(%rdi), %rsi
movq 0xe8(%rdi), %rcx
addq 0x158(%rdi), %rcx
subq %rcx, %rsi
movq 0x88(%rdi,%rdx,8), %r8
movq 0x90(%rdi,%rdx,8), %rcx
addq 0x100(%rdi,%rdx,8), %rcx
addq 0xf8(%rdi,%rdx,8), %r8
subq %r8, %rcx
decq %rax
subq $0x1, %rax
jb 0x6218
imulq %rsi, %rcx
jmp 0x620c
movq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x48fe
leaq 0x128(%r14), %r15
movq %r14, %rdi
callq 0x67d0
movl %eax, %ebp
testb %al, %al
jne 0x62c5
pushq $0x1
popq %r13
xorl %r12d, %r12d
cmpq 0x20(%r14), %r12
jae 0x6271
movq 0x28(%r14,%r12,8), %rsi
movq %r15, %rdi
callq 0x61a4
imulq %rax, %r13
incq %r12
jmp 0x6255
addq %r13, 0x4270(%r14)
movq %r14, %rdi
callq 0x53c6
testb %al, %al
jne 0x629e
movq 0x10(%r14), %rsi
movq %r14, %rdi
callq 0x52d0
testb %al, %al
je 0x62c5
andq $0x0, 0x4230(%r14)
jmp 0x6278
andq $0x0, 0x4238(%r14)
movq 0x28(%r14), %rsi
movq %r15, %rdi
callq 0x54ce
movq 0x20(%r14), %rax
decq %rax
movq %rax, 0x4470(%r14)
jmp 0x6240
movq %rbx, %rdi
callq 0x2170
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movq %rdi, %rbx
leaq 0x128(%rdi), %r15
leaq 0x3e30(%rdi), %r12
movl $0x4478, %ebp           # imm = 0x4478
xorl %r13d, %r13d
leaq (%rbx,%rbp), %r14
movl %r13d, %r13d
cmpq %r13, 0x20(%rbx)
jbe 0x6378
imulq $0x1e8, %r13, %rdi      # imm = 0x1E8
addq %r15, %rdi
callq 0x6a82
movq %r14, %rdi
movq %rax, %rsi
callq 0x21f0
movq %r14, %rdi
callq 0x20a0
addq %rbp, %rax
movq 0x20(%rbx), %rcx
decq %rcx
cmpq %r13, %rcx
jbe 0x6365
movq %r13, %rcx
shlq $0x4, %rcx
movl (%r12,%rcx), %ecx
cmpl $0x2, %ecx
setne %dl
addb %dl, %dl
orb $0x5d, %dl
cmpl $0x1, %ecx
movzbl %dl, %ecx
pushq $0x5b
popq %rdx
cmovel %edx, %ecx
movb %cl, (%rbx,%rax)
cmpq $0x4578, %rax           # imm = 0x4578
jge 0x6395
incq %rax
incl %r13d
movq %rax, %rbp
jmp 0x6302
addq $0x4478, %rbx           # imm = 0x4478
movb $0x0, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2304(%rip), %rdi      # 0x86a0
leaq 0x1e96(%rip), %rsi      # 0x8239
leaq 0x2328(%rip), %rcx      # 0x86d2
movl $0x3ab, %edx            # imm = 0x3AB
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6e4c(%rip), %rdi      # 0xd218
callq 0x48fe
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4912
leaq 0x28(%rsp), %rdi
pushq $0x20
popq %rdx
movq %r14, %rsi
callq 0x23d0
movq 0x85a20(%rbx), %rsi
leaq 0x28(%rsp), %rdi
callq 0x2140
leaq 0x234b(%rip), %rsi      # 0x8754
movq %rax, %rdi
callq 0x2210
callq 0x2030
subq 0x85a30(%rbx), %rax
movl $0x3b9aca00, %ecx       # imm = 0x3B9ACA00
cqto
idivq %rcx
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x2200
leaq 0x2318(%rip), %rsi      # 0x8753
movq %rax, %rdi
callq 0x2210
addq $0x401f8, %rbx          # imm = 0x401F8
xorl %r12d, %r12d
leaq 0x28(%rsp), %r14
leaq 0x22fa(%rip), %r15      # 0x8753
cmpq $0x45780, %r12          # imm = 0x45780
je 0x6482
leaq (%rbx,%r12), %rdi
movq %r14, %rsi
callq 0x6b06
movq %r14, %rdi
movq %r15, %rsi
callq 0x2210
addq $0x4578, %r12           # imm = 0x4578
jmp 0x6459
leaq 0x28(%rsp), %rdi
callq 0x22b0
leaq 0x6d85(%rip), %rdi      # 0xd218
callq 0x2170
leaq 0x28(%rsp), %rdi
callq 0x22e0
leaq 0x8(%rsp), %rdi
callq 0x20b0
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x64d1
jmp 0x64c4
jmp 0x64c4
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x22e0
leaq 0x8(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x4238(%rdi), %r14
movq 0x20(%rdi), %rax
decq %rax
cmpq %rax, %r14
jne 0x6802
cmpb $0x0, 0x4468(%rbx)
jne 0x6802
movq 0x4470(%rbx), %r14
movq %r14, 0x4238(%rbx)
leaq 0x128(%rbx), %r15
testq %r14, %r14
js 0x6864
movq %rbx, %rdi
callq 0x6870
movq 0x4238(%rbx), %rcx
testb %al, %al
je 0x6855
movq 0x20(%rbx), %rax
decq %rax
cmpq %rax, %rcx
je 0x6864
leaq 0x1(%rcx), %rax
movq %rax, 0x4238(%rbx)
imulq $0x1e8, %rax, %rdi      # imm = 0x1E8
addq %r15, %rdi
movq 0x30(%rbx,%rcx,8), %rsi
callq 0x54ce
movq 0x4238(%rbx), %r14
jmp 0x6809
decq %rcx
movq %rcx, 0x4238(%rbx)
movq %rcx, %r14
jmp 0x6809
testq %r14, %r14
setns %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6990
movb $0x0, 0xe0(%rbx)
movl 0x8(%rbx), %r14d
decq %r14
testl %r14d, %r14d
js 0x6986
movl %r14d, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movq %rbx, %rdi
callq 0x50ae
jmp 0x696b
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x69a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %rsi
leaq 0x30(%rdi), %rdx
movq 0x10(%rdi), %rcx
callq 0x6a28
testb %al, %al
je 0x69cd
movq %rbx, %rdi
xorl %esi, %esi
callq 0x50ae
jmp 0x6a17
leaq 0x20(%rbx), %r14
leaq 0x31(%rbx), %r15
pushq $0x1
popq %r13
pushq $0xc
popq %r12
cmpq 0x8(%rbx), %r13
jae 0x6a1b
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x6a28
testb %al, %al
jne 0x6a12
incq %r13
addq $0x8, %r14
incq %r15
jmp 0x69dd
movl %r13d, %esi
movq %rbx, %rdi
callq 0x50ae
decl %r13d
testl %r13d, %r13d
jns 0x6a04
movb $0x1, %al
jmp 0x6a1d
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6a69
testb %r8b, %r8b
je 0x6a6a
movl $0xf8, %r10d
xorl %eax, %eax
cmpq $0x0, 0x10(%rdi)
jne 0x6a72
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_O2/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), %r12d
leaq 0xe1(%rdi), %r14
decq %r12
xorl %r13d, %r13d
pushq $0x70
popq %rbp
testl %r12d, %r12d
js 0x6aee
pushq $0xc
popq %r15
testl %r12d, %r12d
jne 0x6ab6
movq 0x10(%rbx), %r15
movl %r12d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
imulq $0xc, 0x18(%rbx,%rax,8), %rsi
cmpb $0x0, 0x30(%rbx,%rax)
movq %rbp, %rax
pushq $0x58
popq %rcx
cmovneq %rcx, %rax
movq (%rbx), %rcx
addq (%rcx,%rax), %rsi
leaq (%r14,%r13), %rdi
movq %r15, %rdx
callq 0x2190
addq %r15, %r13
decq %r12
jmp 0x6aa4
movb $0x0, (%r14,%r13)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x12fd(%rip), %r15      # 0x80fe
movq %rax, %rdi
movq %r15, %rsi
callq 0x2210
movq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
movq %r15, %rsi
callq 0x2210
xorl %r12d, %r12d
cmpq $0x3, %r12
je 0x6e49
movq 0x18(%r14,%r12,8), %rsi
movq %rbx, %rdi
callq 0x2140
movq %rax, %rdi
movq %r15, %rsi
callq 0x2210
incq %r12
jmp 0x6e26
pushq $-0x3
popq %r12
leaq 0x12aa(%rip), %r15      # 0x80fe
testq %r12, %r12
je 0x6e77
movzbl 0x33(%r14,%r12), %esi
movq %rbx, %rdi
callq 0x2360
movq %rax, %rdi
movq %r15, %rsi
callq 0x2210
incq %r12
jmp 0x6e54
movzbl 0xe0(%r14), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2360
// File: /workspace/github_cpp_makefile_star2_O2/ksabry[P]bfbrute/src/ProgramIterator.h
// Function: ProgramIterator<400ul, 32ul, 12ul, 32ul>::ApplyData(AlignedData<32ul>&)
inline void ApplyData(AlignedData<cache_data_size>& argData)
	{
		//uint_fast32_t sseLow = argData.start / 16;
		//uint_fast32_t sseHigh = argData.end / 16;
		//
		//__m128i sseArgData = reinterpret_cast<__m128i*> argData.data;
		//__m123i sseData = reinterpret_cast<__m128i*> data + dataIdx;

		for (int_fast32_t i = argData.start; i < argData.end; i++)
		{
			data[dataIdx + i] += argData.data[i + cache_data_size / 2];
		}
	}

// Assembly:
movq 0x28(%rsi), %rax
leaq 0x4278(%rdi), %rcx
cmpq 0x30(%rsi), %rax
jge 0x6ee6
movb 0x10(%rsi,%rax), %dl
movq 0x4448(%rdi), %r8
addq %rcx, %r8
addb %dl, (%rax,%r8)
incq %rax
jmp 0x6ec9
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %eax, %eax
movq %rdi, %rcx
cmpq $0x100, %rax            # imm = 0x100
je 0x76b1
xorl %edx, %edx
cmpq $0x100, %rdx            # imm = 0x100
je 0x76a5
orl $-0x1, (%rcx,%rdx,4)
incq %rdx
jmp 0x7693
incq %rax
addq $0x400, %rcx            # imm = 0x400
jmp 0x7689
pushq $0x1
popq %rax
pushq $0x1
popq %rcx
cmpq $0x100, %rax            # imm = 0x100
je 0x76f2
andl $0x0, (%rdi,%rax,4)
movl $0x100, %edx            # imm = 0x100
subq %rax, %rdx
movl %eax, %esi
movl %ecx, %r8d
andl $0xff, %esi
je 0x76ed
movl %esi, %r9d
shll $0xa, %r9d
addq %rdi, %r9
movl %r8d, (%r9,%rdx,4)
incl %r8d
addl %eax, %esi
jmp 0x76d0
incq %rax
jmp 0x76b7
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH17_SpecializedLibraryFacilities/examples/badgetc.cc
// Function: main
int main()
{
	char ch;    // using a char here invites disaster!

	// the return from cin.get is converted to char 
	// and then compared to an int
	while ((ch = cin.get()) != EOF)
         	cout.put(ch);
	cout << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x2e16(%rip), %rbx      # 0x3fe0
movq 0x2dff(%rip), %r14      # 0x3fd0
movq %rbx, %rdi
callq 0x1060
cmpb $-0x1, %al
je 0x11ea
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
jmp 0x11d1
movq 0x2ddf(%rip), %rdi      # 0x3fd0
callq 0x1040
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/sflinfo/../../pkgs/R3Surfels/R3SurfelTree.h
// Function: gaps::R3SurfelTree::NSurfels(int) const
inline long long R3SurfelTree::
NSurfels(RNBoolean leaves_only) const
{
  // Return number of surfels in tree
  long long n = 0;
  for (int i = 0; i < NNodes(); i++) {
    R3SurfelNode *node = Node(i);
    if (leaves_only && (node->NParts() > 0)) continue;
    for (int j = 0; j < node->NBlocks(); j++) {
      R3SurfelBlock *block = node->Block(j);
      n += block->NSurfels();
    }
  }
  return n;
}

// Assembly:
pushq %rbx
movl 0x24(%rdi), %ecx
movq 0x18(%rdi), %rdx
xorl %edi, %edi
testl %ecx, %ecx
cmovlel %edi, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
cmpq %rcx, %r8
je 0x17a1c
movq (%rdx,%r8,8), %r9
testl %esi, %esi
je 0x179f5
cmpl $0x0, 0x3c(%r9)
jle 0x179f5
incq %r8
jmp 0x179dc
movl 0x4c(%r9), %r10d
testl %r10d, %r10d
cmovlel %edi, %r10d
xorl %r11d, %r11d
cmpq %r11, %r10
je 0x179f0
movq 0x40(%r9), %rbx
movq (%rbx,%r11,8), %rbx
movslq 0x8(%rbx), %rbx
addq %rbx, %rax
incq %r11
jmp 0x17a03
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Se6[P]CmdLineArgs/./CmdLineArgs.h
// Function: CmdLineArgs::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
std::vector<std::string> CmdLineArgs::split(const std::string &s, char delim)
{
    std::vector<std::string> elems;
    std::stringstream ss(s);
    std::string item;

    while(getline(ss, item, delim))
        elems.push_back(item);

    return elems;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl %edx, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x20(%rsp), %rdi
pushq $0x18
popq %rdx
callq 0x3300
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movsbl %bpl, %ebp
leaq 0x20(%rsp), %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x33c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x359b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5396
jmp 0x3573
movq %rsp, %rdi
callq 0x30e0
leaq 0x20(%rsp), %rdi
callq 0x31b0
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x35d8
movq %rax, %r14
movq %rsp, %rdi
callq 0x30e0
leaq 0x20(%rsp), %rdi
callq 0x31b0
movq %rbx, %rdi
callq 0x53c2
movq %r14, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/Se6[P]CmdLineArgs/./CmdLineArgs.h
// Function: CmdLineArgs::CmdLineArgs(int, char**, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
CmdLineArgs::CmdLineArgs(int argc, char **argv, const std::string &usage_intro, bool allow_set_with_equal)
    :usage_intro_(usage_intro)
{
    for(int i=1; i<argc; ++i) {
        if (allow_set_with_equal) {
            auto vec = split(argv[i], '=');
            args_.reserve(args_.size() + vec.size());
            args_.insert(args_.end(), vec.begin(), vec.end());
        } else {
            args_.push_back(argv[i]);
        }
    }

    usage_intro_ += "\nOptions are:";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r8d, %ebp
movq %rdx, %r13
movl %esi, %r14d
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
addq $0x18, %rdi
movq %rdi, 0x8(%rsp)
movq %rcx, %rsi
callq 0x32a0
leaq 0x38(%rbx), %rax
movq %rax, 0x30(%rsp)
leaq 0x48(%rbx), %rax
movq %rax, 0x38(%rbx)
andq $0x0, 0x40(%rbx)
movb $0x0, 0x48(%rbx)
andq $0x0, 0x68(%rbx)
leaq 0x58(%rbx), %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rbx)
movslq %r14d, %r12
pushq $0x1
popq %r14
leaq 0x38(%rsp), %r15
cmpq %r12, %r14
jge 0x3704
testb %bpl, %bpl
je 0x36d7
movq (%r13,%r14,8), %rsi
movq %r15, %rdi
leaq 0x7(%rsp), %rdx
callq 0x53e4
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
pushq $0x3d
popq %rdx
callq 0x352c
movq %r15, %rdi
callq 0x30e0
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x5, %rax
movq 0x18(%rsp), %rsi
subq 0x10(%rsp), %rsi
sarq $0x5, %rsi
addq %rax, %rsi
movq %rbx, %rdi
callq 0x5420
movq 0x8(%rbx), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %rbx, %rdi
callq 0x54b4
leaq 0x10(%rsp), %rdi
callq 0x53c2
jmp 0x36fc
movq (%r13,%r14,8), %rsi
movq %r15, %rdi
leaq 0x10(%rsp), %rdx
callq 0x53e4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x632a
movq %r15, %rdi
callq 0x30e0
incq %r14
jmp 0x3659
leaq 0x4919(%rip), %rsi      # 0x8024
movq 0x8(%rsp), %rdi
callq 0x33d0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x373e
movq %rax, %r14
jmp 0x3770
jmp 0x373e
jmp 0x372f
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x53c2
jmp 0x3752
movq %rax, %r14
jmp 0x3752
jmp 0x3745
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x30e0
movq 0x28(%rsp), %rdi
callq 0x54d4
movq 0x30(%rsp), %rdi
callq 0x30e0
movq 0x8(%rsp), %rdi
callq 0x30e0
movq %rbx, %rdi
callq 0x53c2
movq %r14, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/Se6[P]CmdLineArgs/./CmdLineArgs.h
// Function: CmdLineArgs::findLongName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::vector<std::string>::iterator CmdLineArgs::findLongName(const std::string &name)
{
    std::vector<std::string>::iterator pos;
    bool found = false;

    for( pos=args_.begin(); pos!=args_.end(); ++pos ) {

        if( pos->size()<3 || pos->substr(0,2) != "--")
            continue;

        if( pos->substr(2) == name.substr(0,pos->size()-2) ){
            found = true;
            break;
        }
    }

    return found ? pos : args_.end();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, (%rsp)
movq %rdi, %r15
movq (%rdi), %r14
leaq 0x8(%rsp), %r12
pushq $0x2
popq %r13
leaq 0x28(%rsp), %rbp
movq 0x8(%r15), %rax
cmpq %rax, %r14
je 0x383b
cmpq $0x3, 0x8(%r14)
jb 0x382f
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r13, %rcx
callq 0x3240
movq %r12, %rdi
leaq 0x4872(%rip), %rsi      # 0x8046
callq 0x54f5
movl %eax, %ebx
movq %r12, %rdi
callq 0x30e0
testb %bl, %bl
jne 0x382f
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
pushq $-0x1
popq %rcx
callq 0x3240
movq 0x8(%r14), %rcx
addq $-0x2, %rcx
movq %rbp, %rdi
movq (%rsp), %rsi
xorl %edx, %edx
callq 0x3240
movq %r12, %rdi
movq %rbp, %rsi
callq 0x54ff
movl %eax, %ebx
movq %rbp, %rdi
callq 0x30e0
movq %r12, %rdi
callq 0x30e0
testb %bl, %bl
jne 0x3838
addq $0x20, %r14
jmp 0x37a6
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x384c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x30e0
movq %rbx, %rdi
callq 0x3390
nop