LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ksabry[P]bfbrute/src/ProgramSearch.h
// Function: ProgramSearch<ProgramIterator<400ul, 32ul, 12ul, 32ul>, DataCache<32ul, 12ul>>::FindString()
void FindString()
	{
		if (!LoadFindStringProgress())
		{
			programSize = SIZE_START;
			SetupSize();
		}
		
		FindStringSize();

		while (true)
		{
			programSize++;
			SetupSize();
			FindStringSize();
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xb980
testb $0x1, %al
jne 0x4341
movq -0x10(%rbp), %rdi
movq $0x10, 0x85a20(%rdi)
callq 0xbe60
movq -0x10(%rbp), %rdi
callq 0xbf20
movq -0x10(%rbp), %rdi
movq 0x85a20(%rdi), %rax
addq $0x1, %rax
movq %rax, 0x85a20(%rdi)
callq 0xbe60
movq -0x10(%rbp), %rdi
callq 0xbf20
jmp 0x434a
// File: ksabry[P]bfbrute/src/RawSourceExecutor.h
// Function: RawSourceExecutor<400ul, 32ul>::Parse()
void Parse()
	{
		int_fast32_t depth = 0;
		for (int source_idx = 0; source_idx < source.length(); source_idx++)
		{
			switch (source[source_idx])
			{
				case '[':
					leftBracketStack[depth] = source_idx;
					depth++;
					break;
				case ']':
					uint_fast32_t lbracket = leftBracketStack[depth-1];
					jumps[source_idx].zero = jumps[lbracket].zero = source_idx + 1;
					jumps[source_idx].nonzero = jumps[lbracket].nonzero = lbracket + 1;
					depth--;
					break;
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x3410
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x4868
movq -0x28(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3570
movsbl (%rax), %eax
movl %eax, -0x34(%rbp)
subl $0x5b, %eax
je 0x47ab
jmp 0x479e
movl -0x34(%rbp), %eax
subl $0x5d, %eax
je 0x47d0
jmp 0x4858
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, 0x220(%rax,%rcx,8)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4858
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
movq 0x220(%rax,%rcx,8), %rcx
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rdx
movq %rax, %rcx
addq $0x20, %rcx
movq -0x20(%rbp), %rsi
shlq $0x4, %rsi
addq %rsi, %rcx
movq %rdx, (%rcx)
movq %rax, %rcx
addq $0x20, %rcx
movslq -0x14(%rbp), %rsi
shlq $0x4, %rsi
addq %rsi, %rcx
movq %rdx, (%rcx)
movq -0x20(%rbp), %rcx
addq $0x1, %rcx
movq %rax, %rdx
addq $0x20, %rdx
movq -0x20(%rbp), %rsi
shlq $0x4, %rsi
addq %rsi, %rdx
movq %rcx, 0x8(%rdx)
addq $0x20, %rax
movslq -0x14(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x485a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4763
addq $0x40, %rsp
popq %rbp
retq
nop
// File: ksabry[P]bfbrute/src/ProgramSearch.h
// Function: ProgramSearch<ProgramIterator<400ul, 32ul, 12ul, 32ul>, DataCache<32ul, 12ul>>::GetStringSizes(std::vector<char const*, std::allocator<char const*>>)
static std::vector<uint_fast32_t> GetStringSizes(std::vector<const char*> strs)
	{
		std::vector<uint_fast32_t> result;
		for (uint_fast32_t i = 0; i < strs.size(); i++)
			result.push_back(strlen(strs[i]));
		return result;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x59c0
movq $0x0, -0x20(%rbp)
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x5180
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x55bc
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5a10
movq (%rax), %rdi
callq 0x30e0
movq -0x48(%rbp), %rdi
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x59e0
jmp 0x5595
jmp 0x5597
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5550
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x5960
jmp 0x55d9
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x55cf
movq -0x48(%rbp), %rdi
callq 0x5960
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x34d0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x7210
movq -0x18(%rbp), %rdi
callq 0x72b0
movq $0x2, -0x10(%rbp)
cmpq $0xc, -0x10(%rbp)
ja 0x6705
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x73b0
movq 0x1592b(%rip), %rdi     # 0x1bfd0
leaq 0xcb03(%rip), %rsi      # 0x131af
callq 0x32a0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x3060
movq %rax, %rdi
leaq 0xcafd(%rip), %rsi      # 0x131c4
callq 0x32a0
movq %rax, %rdi
movl $0xc, %esi
callq 0x3060
movq %rax, %rdi
leaq 0xd078(%rip), %rsi      # 0x1375b
callq 0x32a0
movq %rax, %rdi
movq 0x158e6(%rip), %rsi     # 0x1bfd8
callq 0x32d0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x668a
movq 0x158c4(%rip), %rdi     # 0x1bfd0
movq 0x158a5(%rip), %rsi     # 0x1bfb8
callq 0x32d0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x33a0
movq -0x38(%rbp), %rdi
addq $0x859f8, %rdi          # imm = 0x859F8
leaq -0x28(%rbp), %rsi
callq 0x3350
leaq -0x28(%rbp), %rdi
callq 0x3160
movq $0x0, -0x30(%rbp)
cmpq $0x10, -0x30(%rbp)
jae 0x681b
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq $0x0, 0x85978(%rax,%rcx,8)
je 0x67b3
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq 0x85978(%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x67b1
movq -0x40(%rbp), %rdi
callq 0xb630
movq -0x40(%rbp), %rdi
movl $0x8, %esi
callq 0x32c0
jmp 0x67b3
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rax
movq $0x0, 0x85978(%rsi,%rax,8)
movq %rsi, %rdi
addq $0x401f8, %rdi          # imm = 0x401F8
imulq $0x4578, -0x30(%rbp), %rax # imm = 0x4578
addq %rax, %rdi
addq $0x8, %rsi
callq 0xb660
movq -0x38(%rbp), %rsi
movq %rsi, %rdi
addq $0x401f8, %rdi          # imm = 0x401F8
imulq $0x4578, -0x30(%rbp), %rax # imm = 0x4578
addq %rax, %rdi
addq $0x1f8, %rsi            # imm = 0x1F8
callq 0xb6d0
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x6762
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ksabry[P]bfbrute/src/DataCache.h
// Function: DataCache<32ul, 12ul>::CreateZero()
void CreateZero()
	{
		bordersBalanced[0] = dataBalancedCount;
		bordersUnbalanced[0] = dataUnbalancedCount;
		currentProgramSize = 0;
		memset(currentData, 0, data_size);

		currentDataIdx = 0;
		currentDataStart = data_size / 2;
		currentDataEnd = -static_cast<int>(data_size) / 2;
		AddData();

		bordersBalanced[1] = dataBalancedCount;
		bordersUnbalanced[1] = dataUnbalancedCount;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq 0x18(%rdi), %rax
movq %rax, 0x88(%rdi)
movq 0x20(%rdi), %rax
movq %rax, 0xf8(%rdi)
movq $0x0, 0x1e8(%rdi)
addq $0x1a0, %rdi            # imm = 0x1A0
xorl %esi, %esi
movl $0x20, %edx
callq 0x3110
movq -0x10(%rbp), %rdi
movq $0x0, 0x1c0(%rdi)
movq $0x10, 0x1c8(%rdi)
movq $-0x10, 0x1d0(%rdi)
callq 0x77d0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq %rcx, 0x90(%rax)
movq 0x20(%rax), %rcx
movq %rcx, 0x100(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq $0x1, 0x1e8(%rdi)
addq $0x1a0, %rdi            # imm = 0x1A0
xorl %esi, %esi
movl $0x20, %edx
callq 0x3110
movq -0x10(%rbp), %rdi
movq $0x0, 0x1c0(%rdi)
movq $0x0, 0x1c8(%rdi)
movq $0x1, 0x1d0(%rdi)
movb $0x2b, 0x1d8(%rdi)
movq (%rdi), %rax
movb $0x1, 0x1a0(%rdi,%rax)
callq 0x77d0
movq -0x10(%rbp), %rdi
movb $0x2d, 0x1d8(%rdi)
movq (%rdi), %rax
movb $-0x1, 0x1a0(%rdi,%rax)
callq 0x77d0
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movb $0x0, 0x1a0(%rdi,%rax)
movq $0x10, 0x1c8(%rdi)
movq $-0x10, 0x1d0(%rdi)
movb $0x3e, 0x1d8(%rdi)
movq $0x1, 0x1c0(%rdi)
callq 0x77d0
movq -0x10(%rbp), %rdi
movb $0x3c, 0x1d8(%rdi)
movq $-0x1, 0x1c0(%rdi)
callq 0x77d0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq %rcx, 0x98(%rax)
movq 0x20(%rax), %rcx
movq %rcx, 0x108(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: ksabry[P]bfbrute/src/LookupData.h
// Function: std::hash<LookupData<32ul>>::operator()(LookupData<32ul> const&) const
size_t operator()(const LookupData<data_size>& data) const
		{
			size_t result = static_cast<size_t>(data.dataIndex);
			for (int i = 0; i < data_size; i++)
			{
				uint_fast32_t offset = (i + 5) % (8 * data_size);
				result ^= static_cast<size_t>(data.data[i]) << offset;
				result ^= static_cast<size_t>(data.data[i]) >> (8 * data_size - offset);
			}
			return result;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
cmpq $0x20, %rax
jae 0x7e92
movl -0x1c(%rbp), %eax
addl $0x5, %eax
cltq
andq $0xff, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl 0x8(%rax,%rcx), %eax
movq -0x28(%rbp), %rcx
shlq %cl, %rax
xorq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl 0x8(%rax,%rcx), %eax
movl $0x100, %ecx            # imm = 0x100
subq -0x28(%rbp), %rcx
shrq %cl, %rax
xorq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7e2e
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: ksabry[P]bfbrute/src/LookupData.h
// Function: LookupData<32ul>::operator==(LookupData<32ul> const&) const
bool operator==(const LookupData<data_size>& other) const
	{
		if (dataIndex != other.dataIndex)
			return false;
		for (int i = 0; i < data_size; i++)
			if (data[i] != other.data[i])
				return false;
		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
je 0x81a6
movb $0x0, -0x1(%rbp)
jmp 0x81ec
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
cmpq $0x20, %rax
jae 0x81e8
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl 0x8(%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movzbl 0x8(%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x81db
movb $0x0, -0x1(%rbp)
jmp 0x81ec
jmp 0x81dd
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x81ad
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x10155(%rip), %rdi     # 0x1bfd0
leaq 0x744f(%rip), %rsi      # 0x132d1
callq 0x32a0
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq 0x85a20(%rax), %rsi
callq 0x3060
movq %rax, %rdi
movq 0x10114(%rip), %rsi     # 0x1bfb8
callq 0x32d0
callq 0x3030
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0x85a30(%rax)
movq $0x0, -0x18(%rbp)
cmpq $0x10, -0x18(%rbp)
jae 0xbf17
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x401f8, %rcx          # imm = 0x401F8
imulq $0x4578, -0x18(%rbp), %rdx # imm = 0x4578
addq %rdx, %rcx
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq 0x85a20(%rax), %rsi
movq -0x18(%rbp), %rdx
movl $0x10, %ecx
callq 0xd5f0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xbecc
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0xe2f0
movq $0x0, -0x10(%rbp)
cmpq $0x10, -0x10(%rbp)
jae 0xc015
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq $0x0, 0x85978(%rax,%rcx,8)
je 0xbf92
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x85978(%rax,%rcx,8), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0xbf90
movq -0x50(%rbp), %rdi
callq 0xb630
movq -0x50(%rbp), %rdi
movl $0x8, %esi
callq 0x32c0
jmp 0xbf92
movl $0x8, %edi
callq 0x32b0
movq %rax, %rdi
movq -0x48(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x58(%rbp)
leaq 0x24ff(%rip), %rcx      # 0xe4b0
movq %rcx, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdx
leaq -0x10(%rbp), %rcx
callq 0xf4d0
jmp 0xbfd4
movq -0x48(%rbp), %rax
movq -0x58(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, 0x85978(%rax,%rcx,8)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xbf41
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x8, %esi
callq 0x32c0
jmp 0xc04d
movq $0x0, -0x40(%rbp)
cmpq $0x10, -0x40(%rbp)
jae 0xc047
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
movq 0x85978(%rax,%rcx,8), %rdi
callq 0x34b0
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0xc01d
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x34d0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x33a0
movq -0x18(%rbp), %rdi
callq 0x3410
movq -0x58(%rbp), %rdi
movq %rax, %rsi
addq %rsi, %rsi
callq 0x3430
jmp 0xcc92
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3280
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3520
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xced0
testb $0x1, %al
jne 0xccc7
jmp 0xcd33
leaq -0x40(%rbp), %rdi
callq 0xcf10
movq -0x58(%rbp), %rdi
movb (%rax), %al
movb %al, -0x49(%rbp)
movzbl -0x49(%rbp), %eax
shrl $0x4, %eax
leaq 0x6bf9(%rip), %rcx      # 0x138e0
movsbl (%rax,%rcx), %esi
callq 0x3220
jmp 0xccf2
movq -0x58(%rbp), %rdi
movzbl -0x49(%rbp), %eax
andl $0xf, %eax
leaq 0x6bdc(%rip), %rcx      # 0x138e0
movsbl (%rax,%rcx), %esi
callq 0x3220
jmp 0xcd0f
jmp 0xcd11
leaq -0x40(%rbp), %rdi
callq 0xcf30
jmp 0xccb4
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3160
jmp 0xcd50
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xcd46
movq -0x58(%rbp), %rdi
callq 0x3160
movq -0x60(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x34d0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x30(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rsi
callq 0x33b0
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x10, %rsi
callq 0x33b0
movq $0x0, -0x18(%rbp)
cmpq $0x3, -0x18(%rbp)
jae 0xd2ef
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x18, %rsi
movq -0x18(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x33b0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xd2be
movq $0x0, -0x20(%rbp)
cmpq $0x3, -0x20(%rbp)
jae 0xd321
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x30, %rsi
addq -0x20(%rbp), %rsi
callq 0x3230
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xd2f7
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xe0, %rsi
callq 0x3230
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
subq $0x1, %rax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0xd362
movq -0x30(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0xd370
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xd344
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
testb $0x1, 0x30(%rax,%rcx)
je 0xd3b2
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rsi
callq 0x7c00
movq %rax, -0x28(%rbp)
jmp 0xd3cf
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x40, %rdi
movq -0x10(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rsi
callq 0x7c00
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0xd40c
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x38, %rdi
imulq $0x38, -0x10(%rbp), %rax
addq %rax, %rdi
movl $0x38, %edx
callq 0x3200
jmp 0xd43b
movq -0x20(%rbp), %rsi
movq %rsi, %rdi
addq $0x38, %rdi
imulq $0x38, -0x10(%rbp), %rax
addq %rax, %rdi
addq $0x38, %rsi
movq -0x10(%rbp), %rax
addq $0x1, %rax
imulq $0x38, %rax, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0xd450
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0x18(%rdi)
movq $0x0, 0x4270(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x10(%rdi)
addq $0x28, %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x3110
movq -0x28(%rbp), %rdi
movq $0x1, 0x20(%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x28(%rdi)
movq $0x0, 0x4240(%rdi)
movq $0x0, 0x4470(%rdi)
movq $0x0, 0x4230(%rdi)
movq $0x0, 0x4230(%rdi)
movl $0x0, 0x3e30(%rdi)
movq $0x0, 0x3e38(%rdi)
movq $0x1, 0x4038(%rdi)
movq $0x1, 0x4030(%rdi)
movq -0x18(%rbp), %rsi
callq 0xd740
testb $0x1, %al
jne 0xd6bd
jmp 0xd732
movq -0x28(%rbp), %rax
movq $0x0, 0x4230(%rax)
movq -0x28(%rbp), %rdi
callq 0xd920
xorb $-0x1, %al
testb $0x1, %al
jne 0xd6dd
jmp 0xd701
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xd740
testb $0x1, %al
jne 0xd6f0
jmp 0xd732
movq -0x28(%rbp), %rax
movq $0x0, 0x4230(%rax)
jmp 0xd6cc
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rcx
subq $0x1, %rcx
movq %rcx, 0x4470(%rax)
movq $0x0, 0x4238(%rax)
movq %rax, %rdi
addq $0x128, %rdi            # imm = 0x128
movq 0x28(%rax), %rsi
callq 0xdc20
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xdc46
movl $0x1, %eax
movq %rax, -0x28(%rbp)
jmp 0xdc60
movq -0x10(%rbp), %rax
subq $0x1, %rax
movl $0xc, %ecx
xorl %edx, %edx
divq %rcx
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x10(%rbp)
jne 0xdc7b
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0xdc98
movq -0x10(%rbp), %rax
subq $0x1, %rax
movl $0xc, %ecx
xorl %edx, %edx
divq %rcx
movq %rdx, %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq (%rax), %rcx
movq 0x10(%rax), %rdx
movq 0x88(%rcx,%rdx,8), %rcx
movq %rcx, 0x18(%rax)
movb $0x1, 0x30(%rax)
movq $0x1, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0xdcff
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq 0xe8(%rcx), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, 0x18(%rax,%rcx,8)
movq -0x18(%rbp), %rcx
movb $0x1, 0x30(%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xdcc3
movq -0x20(%rbp), %rax
movb $0x1, 0xe0(%rax)
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, 0x4230(%rcx)
movb %al, -0x9(%rbp)
jl 0xdf25
movq -0x18(%rbp), %rax
cmpq $0x20, 0x4230(%rax)
setb %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0xdf2e
jmp 0xdf30
jmp 0xdf4f
leaq 0x55bb(%rip), %rdi      # 0x134f2
leaq 0x53c3(%rip), %rsi      # 0x13301
movl $0x1a4, %edx            # imm = 0x1A4
leaq 0x565b(%rip), %rcx      # 0x135a5
callq 0x3180
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x3e30, %rcx           # imm = 0x3E30
movq 0x4230(%rax), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movl $0x1, (%rcx)
cmpq $0x0, 0x4230(%rax)
jne 0xdf86
movl $0x1, %eax
movq %rax, -0x20(%rbp)
jmp 0xdfb1
movq -0x18(%rbp), %rcx
movq %rcx, %rax
addq $0x3e30, %rax           # imm = 0x3E30
movq 0x4230(%rcx), %rcx
subq $0x1, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdx
movq %rax, %rcx
addq $0x3e30, %rcx           # imm = 0x3E30
movq 0x4230(%rax), %rsi
shlq $0x4, %rsi
addq %rsi, %rcx
movq %rdx, 0x8(%rcx)
movq 0x4230(%rax), %rcx
cmpq $0x0, 0x28(%rax,%rcx,8)
jg 0xe025
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x4230(%rcx)
movb %al, -0x21(%rbp)
jle 0xe090
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x3e30, %rcx           # imm = 0x3E30
movq 0x4230(%rax), %rax
subq $0x1, %rax
shlq $0x4, %rax
addq %rax, %rcx
xorl %eax, %eax
cmpl $0x1, (%rcx)
movb %al, -0x21(%rbp)
jne 0xe090
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x3e30, %rcx           # imm = 0x3E30
movq 0x4230(%rax), %rax
shlq $0x4, %rax
addq %rax, %rcx
xorl %eax, %eax
cmpq $0x2, 0x8(%rcx)
movb %al, -0x21(%rbp)
ja 0xe090
movq -0x18(%rbp), %rcx
movb $0x1, %al
cmpq $0x0, 0x4230(%rcx)
movb %al, -0x22(%rbp)
je 0xe08a
movq -0x18(%rbp), %rcx
movq %rcx, %rax
addq $0x3e30, %rax           # imm = 0x3E30
movq 0x4230(%rcx), %rcx
subq $0x1, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
seta %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, 0x4230(%rcx)
movb %al, -0x9(%rbp)
jle 0xe0d5
movq -0x18(%rbp), %rax
cmpq $0x20, 0x4230(%rax)
setb %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0xe0de
jmp 0xe0e0
jmp 0xe0ff
leaq 0x5542(%rip), %rdi      # 0x13629
leaq 0x5213(%rip), %rsi      # 0x13301
movl $0x1b7, %edx            # imm = 0x1B7
leaq 0x555f(%rip), %rcx      # 0x13659
callq 0x3180
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x3e30, %rcx           # imm = 0x3E30
movq 0x4230(%rax), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movl $0x2, (%rcx)
movq %rax, %rcx
addq $0x3e30, %rcx           # imm = 0x3E30
movq 0x4230(%rax), %rdx
subq $0x1, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rdx
subq $0x1, %rdx
movq %rax, %rcx
addq $0x3e30, %rcx           # imm = 0x3E30
movq 0x4230(%rax), %rsi
shlq $0x4, %rsi
addq %rsi, %rcx
movq %rdx, 0x8(%rcx)
movq 0x4230(%rax), %rcx
cmpq $0x0, 0x28(%rax,%rcx,8)
setg %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x128(%rbp)
movq $0x0, -0x118(%rbp)
movq -0x128(%rbp), %rcx
movq -0x118(%rbp), %rax
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0xe2e6
movq -0x128(%rbp), %rax
addq $0x3e30, %rax           # imm = 0x3E30
movq -0x118(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x1, (%rax)
jne 0xe217
movq -0x128(%rbp), %rax
movq -0x118(%rbp), %rcx
addq $0x3e30, %rax           # imm = 0x3E30
movq -0x118(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq 0x8(%rax), %rax
movq %rcx, -0x110(%rbp,%rax,8)
jmp 0xe2cd
movq -0x128(%rbp), %rax
movq %rax, %rcx
addq $0x3e30, %rcx           # imm = 0x3E30
movq -0x118(%rbp), %rdx
subq $0x1, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movq -0x110(%rbp,%rcx,8), %rcx
movq %rcx, -0x120(%rbp)
movq -0x118(%rbp), %rdx
addq $0x1, %rdx
movq %rax, %rcx
addq $0x4030, %rcx           # imm = 0x4030
movq -0x120(%rbp), %rsi
shlq $0x4, %rsi
addq %rsi, %rcx
movq %rdx, (%rcx)
movq %rax, %rcx
addq $0x4030, %rcx           # imm = 0x4030
movq -0x118(%rbp), %rsi
shlq $0x4, %rsi
addq %rsi, %rcx
movq %rdx, (%rcx)
movq -0x120(%rbp), %rcx
addq $0x1, %rcx
movq %rax, %rdx
addq $0x4030, %rdx           # imm = 0x4030
movq -0x120(%rbp), %rsi
shlq $0x4, %rsi
addq %rsi, %rdx
movq %rcx, 0x8(%rdx)
addq $0x4030, %rax           # imm = 0x4030
movq -0x118(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
jmp 0xe2cf
movq -0x118(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x118(%rbp)
jmp 0xe1a5
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x45e0, %rsp           # imm = 0x45E0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x45a0(%rbp)
leaq -0x4580(%rbp), %rdi
movq %rdi, -0x4598(%rbp)
callq 0x6430
movq -0x45a0(%rbp), %rsi
movq -0x4598(%rbp), %rdi
addq $0x8, %rsi
callq 0xb660
jmp 0xe336
movq -0x45a0(%rbp), %rsi
addq $0x1f8, %rsi            # imm = 0x1F8
leaq -0x4580(%rbp), %rdi
callq 0xb6d0
movq 0xdc79(%rip), %rdi      # 0x1bfd0
leaq 0x5380(%rip), %rsi      # 0x136de
callq 0x32a0
movq %rax, -0x45a8(%rbp)
jmp 0xe36c
movq -0x45a8(%rbp), %rdi
movq -0x45a0(%rbp), %rax
movq 0x85a20(%rax), %rsi
callq 0x3060
movq %rax, -0x45b0(%rbp)
jmp 0xe38f
movq -0x45b0(%rbp), %rdi
leaq 0x5366(%rip), %rsi      # 0x13703
callq 0x32a0
movq %rax, -0x45b8(%rbp)
jmp 0xe3ab
movq -0x45b8(%rbp), %rdi
movq 0xdc1f(%rip), %rsi      # 0x1bfd8
callq 0x32d0
jmp 0xe3c0
movq -0x45a0(%rbp), %rax
movq 0x85a20(%rax), %rsi
leaq -0x4580(%rbp), %rdi
callq 0xf5a0
movq %rax, -0x45c0(%rbp)
jmp 0xe3e3
movq -0x45a0(%rbp), %rax
movq -0x45c0(%rbp), %rcx
movq %rcx, 0x85a28(%rax)
movq 0xdbd1(%rip), %rdi      # 0x1bfd0
movq 0xdbb2(%rip), %rsi      # 0x1bfb8
callq 0x32d0
movq %rax, -0x45c8(%rbp)
jmp 0xe414
movq -0x45c8(%rbp), %rdi
leaq 0x52e6(%rip), %rsi      # 0x13708
callq 0x32a0
movq %rax, -0x45d0(%rbp)
jmp 0xe430
movq -0x45d0(%rbp), %rdi
movq -0x45a0(%rbp), %rax
movq 0x85a20(%rax), %rsi
callq 0x3060
movq %rax, -0x45d8(%rbp)
jmp 0xe453
movq -0x45d8(%rbp), %rdi
movq 0xdb57(%rip), %rsi      # 0x1bfb8
callq 0x32d0
jmp 0xe468
leaq -0x4580(%rbp), %rdi
callq 0x64f0
addq $0x45e0, %rsp           # imm = 0x45E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x4588(%rbp)
movl %eax, -0x458c(%rbp)
leaq -0x4580(%rbp), %rdi
callq 0x64f0
movq -0x4588(%rbp), %rdi
callq 0x34d0
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
callq 0xd5f0
movq $0x1, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq 0x20(%rcx), %rax
jae 0xf623
movq -0x30(%rbp), %rax
movq %rax, %rdi
addq $0x128, %rdi            # imm = 0x128
movq -0x28(%rbp), %rcx
movq 0x28(%rax,%rcx,8), %rsi
callq 0xf680
imulq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xf5e2
movq -0x20(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rdi
callq 0xd920
xorb $-0x1, %al
testb $0x1, %al
jne 0xf640
jmp 0xf66c
movq -0x30(%rbp), %rdi
movq 0x10(%rdi), %rsi
callq 0xd740
testb $0x1, %al
jne 0xf65b
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rax
movq $0x0, 0x4230(%rax)
jmp 0xf62f
jmp 0xf5d2
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xf6aa
movl $0x1, %eax
movq %rax, -0x48(%rbp)
jmp 0xf6c4
movq -0x10(%rbp), %rax
subq $0x1, %rax
movl $0xc, %ecx
xorl %edx, %edx
divq %rcx
addq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xf6db
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0xf6f8
movq -0x10(%rbp), %rax
subq $0x1, %rax
movl $0xc, %ecx
xorl %edx, %edx
divq %rcx
movq %rdx, %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq (%rax), %rdi
movl $0xc, %esi
callq 0xf770
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0xf770
movq %rax, -0x30(%rbp)
movq $0x1, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xf759
movq -0x28(%rbp), %rax
imulq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xf734
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x4248, %rdi           # imm = 0x4248
callq 0xc060
movq -0x28(%rbp), %rdi
callq 0x10290
xorb $-0x1, %al
testb $0x1, %al
jne 0xf7f4
jmp 0xf8de
movq $0x1, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x20(%rcx), %rax
jae 0xf845
movq -0x28(%rbp), %rax
movq %rax, %rdi
addq $0x128, %rdi            # imm = 0x128
movq -0x20(%rbp), %rcx
movq 0x28(%rax,%rcx,8), %rsi
callq 0xf680
imulq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xf804
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
addq 0x4270(%rax), %rcx
movq %rcx, 0x4270(%rax)
movq -0x28(%rbp), %rdi
callq 0xd920
xorb $-0x1, %al
testb $0x1, %al
jne 0xf86c
jmp 0xf8a4
movq -0x28(%rbp), %rdi
movq 0x10(%rdi), %rsi
callq 0xd740
testb $0x1, %al
jne 0xf893
movq -0x28(%rbp), %rdi
addq $0x4248, %rdi           # imm = 0x4248
callq 0xc7f0
movb $0x0, -0x1(%rbp)
jmp 0xf8f2
movq -0x28(%rbp), %rax
movq $0x0, 0x4230(%rax)
jmp 0xf85b
movq -0x28(%rbp), %rax
movq $0x0, 0x4238(%rax)
movq %rax, %rdi
addq $0x128, %rdi            # imm = 0x128
movq 0x28(%rax), %rsi
callq 0xdc20
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rcx
subq $0x1, %rcx
movq %rcx, 0x4470(%rax)
jmp 0xf7e0
movq -0x28(%rbp), %rdi
addq $0x4248, %rdi           # imm = 0x4248
callq 0xc7f0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x4478, %rax           # imm = 0x4478
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpq 0x20(%rcx), %rax
jae 0xfb3b
movq -0x28(%rbp), %rdi
addq $0x128, %rdi            # imm = 0x128
movl -0x14(%rbp), %eax
imulq $0x1e8, %rax, %rax      # imm = 0x1E8
addq %rax, %rdi
callq 0x109e0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3270
movq -0x10(%rbp), %rdi
callq 0x30e0
movq -0x28(%rbp), %rcx
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0xfae3
movq -0x28(%rbp), %rax
addq $0x3e30, %rax           # imm = 0x3E30
movl -0x14(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x1, (%rax)
jne 0xfaa9
movb $0x5b, %al
movb %al, -0x29(%rbp)
jmp 0xfada
movq -0x28(%rbp), %rax
addq $0x3e30, %rax           # imm = 0x3E30
movl -0x14(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %ecx
movb $0x5d, %al
movb $0x5f, %dl
movb %dl, -0x2b(%rbp)
cmpl $0x2, %ecx
movb %al, -0x2a(%rbp)
je 0xfad4
movb -0x2b(%rbp), %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x4478, %rcx           # imm = 0x4478
addq $0x100, %rcx            # imm = 0x100
cmpq %rcx, %rax
ja 0xfb0c
jmp 0xfb2b
leaq 0x3c55(%rip), %rdi      # 0x13768
leaq 0x37e7(%rip), %rsi      # 0x13301
movl $0x3ab, %edx            # imm = 0x3AB
leaq 0x3c74(%rip), %rcx      # 0x1379a
callq 0x3180
jmp 0xfb2d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xfa25
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movb $0x0, (%rcx)
addq $0x4478, %rax           # imm = 0x4478
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x270(%rbp)
leaq 0xc73f(%rip), %rdi      # 0x1c2e0
callq 0xc060
movq -0x270(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x268(%rbp)
callq 0xc090
movq -0x268(%rbp), %rsi
leaq -0x228(%rbp), %rdi
movl $0x20, %edx
callq 0x3540
jmp 0xfbd7
movq -0x270(%rbp), %rax
movq 0x85a20(%rax), %rsi
leaq -0x228(%rbp), %rdi
callq 0x3060
movq %rax, -0x278(%rbp)
jmp 0xfbfa
movq -0x278(%rbp), %rdi
leaq 0x3c14(%rip), %rsi      # 0x1381c
callq 0x32a0
jmp 0xfc0f
callq 0x3030
movq -0x270(%rbp), %rsi
movq %rax, -0x258(%rbp)
addq $0x85a30, %rsi          # imm = 0x85A30
leaq -0x258(%rbp), %rdi
callq 0xf930
movq %rax, -0x280(%rbp)
jmp 0xfc3e
movq -0x280(%rbp), %rax
movq %rax, -0x250(%rbp)
leaq -0x250(%rbp), %rdi
callq 0xf900
movq %rax, -0x288(%rbp)
jmp 0xfc61
movq -0x288(%rbp), %rax
movq %rax, -0x248(%rbp)
leaq -0x248(%rbp), %rdi
callq 0xd260
movq %rax, -0x240(%rbp)
movq -0x240(%rbp), %rsi
leaq -0x228(%rbp), %rdi
callq 0x3510
movq %rax, -0x290(%rbp)
jmp 0xfc9e
movq -0x290(%rbp), %rdi
leaq 0x3b6f(%rip), %rsi      # 0x1381b
callq 0x32a0
jmp 0xfcb3
movq $0x0, -0x260(%rbp)
cmpq $0x10, -0x260(%rbp)
jae 0xfd56
movq -0x270(%rbp), %rax
movq -0x260(%rbp), %rcx
imulq $0x4578, %rcx, %rcx     # imm = 0x4578
leaq 0x401f8(%rax,%rcx), %rdi
leaq -0x228(%rbp), %rsi
callq 0x10af0
jmp 0xfcf7
leaq 0x3b1d(%rip), %rsi      # 0x1381b
leaq -0x228(%rbp), %rdi
callq 0x32a0
jmp 0xfd0c
jmp 0xfd0e
movq -0x260(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x260(%rbp)
jmp 0xfcbe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
jmp 0xfd90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x3400
jmp 0xfd90
leaq -0x228(%rbp), %rdi
callq 0x33c0
jmp 0xfd64
leaq 0xc575(%rip), %rdi      # 0x1c2e0
callq 0xc7f0
jmp 0xfd72
leaq -0x228(%rbp), %rdi
callq 0x3400
leaq -0x28(%rbp), %rdi
callq 0x3160
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x3160
movq -0x230(%rbp), %rdi
callq 0x34d0
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq 0x4238(%rcx), %rax
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x102d7
movq -0x18(%rbp), %rax
testb $0x1, 0x4468(%rax)
jne 0x102d7
movq -0x18(%rbp), %rax
movq 0x4470(%rax), %rcx
movq %rcx, 0x4238(%rax)
jmp 0x102d9
movq -0x18(%rbp), %rax
cmpq $0x0, 0x4238(%rax)
jl 0x10374
movq -0x18(%rbp), %rdi
callq 0x10390
testb $0x1, %al
jne 0x102fa
jmp 0x10359
movq -0x18(%rbp), %rcx
movq 0x4238(%rcx), %rax
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x10318
movb $0x1, -0x1(%rbp)
jmp 0x10378
movq -0x18(%rbp), %rax
movq 0x4238(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x4238(%rax)
movq %rax, %rdi
addq $0x128, %rdi            # imm = 0x128
imulq $0x1e8, 0x4238(%rax), %rcx # imm = 0x1E8
addq %rcx, %rdi
movq 0x4238(%rax), %rcx
movq 0x28(%rax,%rcx,8), %rsi
callq 0xdc20
jmp 0x1036f
movq -0x18(%rbp), %rax
movq 0x4238(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x4238(%rax)
jmp 0x102d9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0xe0(%rax)
je 0x105f7
movq -0x20(%rbp), %rax
movb $0x0, 0xe0(%rax)
movq 0x8(%rax), %rax
subq $0x1, %rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x105f1
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0xd370
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x105d3
movb $0x1, -0x1(%rbp)
jmp 0x10605
movq -0x20(%rbp), %rdi
callq 0x10650
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq