LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/outstream.cpp
// Function: smooth::IO::OutStream::CompleteBitstream()
S::Bool S::IO::OutStream::CompleteBitstream()
{
	if (bitLength > 0)
	{
		Int	out = 0;

		for (Int i = 0; i < 8; i++)
		{
			if (i < bitLength) out = out | (bitBuffer[i] << i);
		}

		keepBits = True;
		OutputNumber(out, 1);
		keepBits = False;
	}

	bitstreamActive = 0;

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x64(%rax)
jle 0xe7786
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x8, -0x10(%rbp)
jge 0xe7768
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x64(%rcx), %eax
jge 0xe775b
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
movslq -0x10(%rbp), %rdx
movb 0x68(%rcx,%rdx), %cl
andb $0x1, %cl
movzbl %cl, %edx
movl -0x10(%rbp), %ecx
shll %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movl %eax, -0xc(%rbp)
jmp 0xe775d
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xe7728
movq -0x18(%rbp), %rdi
movb $0x1, 0x61(%rdi)
movslq -0xc(%rbp), %rsi
movl $0x1, %edx
callq 0x598f0
movq -0x18(%rbp), %rax
movb $0x0, 0x61(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x60(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/outstream.cpp
// Function: smooth::IO::OutStream::OutputNumber(long long, int)
S::Bool S::IO::OutStream::OutputNumber(Int64 number, Int bytes)
{
	if (streamType == STREAM_NONE)	{ lastError = IO_ERROR_NOTOPEN; return False; }
	if (packageSize <= 0)		{ lastError = IO_ERROR_UNKNOWN; return False; }
	if (bytes > 8 || bytes < 0)	{ lastError = IO_ERROR_BADPARAM; return False; }

	if (bitstreamActive && !keepBits) CompleteBitstream();

	for (Int i = 0; i < bytes; i++)
	{
		if (currentBufferPos >= packageSize)
		{
			if (!WriteData()) { lastError = IO_ERROR_UNKNOWN; return False; }
		}

		dataBuffer[currentBufferPos] = IOGetByte(number, i);
		if (currentFilePos == size) size++;
		currentBufferPos++;
		currentFilePos++;
	}

	if (currentBufferPos >= packageSize)
	{
		if (!WriteData()) { lastError = IO_ERROR_UNKNOWN; return False; }
	}

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movswl 0x8(%rax), %eax
cmpl $0x0, %eax
jne 0xe77da
movq -0x28(%rbp), %rax
movw $0x5, 0xf8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xe793a
movq -0x28(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jg 0xe77fa
movq -0x28(%rbp), %rax
movw $0x4, 0xf8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xe793a
cmpl $0x8, -0x1c(%rbp)
jg 0xe7806
cmpl $0x0, -0x1c(%rbp)
jge 0xe781c
movq -0x28(%rbp), %rax
movw $0x2, 0xf8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xe793a
movq -0x28(%rbp), %rax
testb $0x1, 0x60(%rax)
je 0xe7839
movq -0x28(%rbp), %rax
testb $0x1, 0x61(%rax)
jne 0xe7839
movq -0x28(%rbp), %rdi
callq 0x5a7a0
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xe7908
movq -0x28(%rbp), %rcx
movl 0x50(%rcx), %eax
cmpl 0x38(%rcx), %eax
jl 0xe787d
movq -0x28(%rbp), %rdi
callq 0x5be10
testb $0x1, %al
jne 0xe787b
movq -0x28(%rbp), %rax
movw $0x4, 0xf8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xe793a
jmp 0xe787d
cmpl $0x7, -0x20(%rbp)
jle 0xe788b
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0xe78a4
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
sarq %cl, %rax
andq $0xff, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movb %cl, -0x31(%rbp)
movq %rax, %rdi
addq $0x20, %rdi
movl 0x50(%rax), %esi
callq 0x717e0
movb -0x31(%rbp), %dl
movq -0x28(%rbp), %rcx
movb %dl, (%rax)
movq 0x48(%rcx), %rax
cmpq 0x10(%rcx), %rax
jne 0xe78e1
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movl 0x50(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x50(%rax)
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xe7840
movq -0x28(%rbp), %rcx
movl 0x50(%rcx), %eax
cmpl 0x38(%rcx), %eax
jl 0xe7936
movq -0x28(%rbp), %rdi
callq 0x5be10
testb $0x1, %al
jne 0xe7934
movq -0x28(%rbp), %rax
movw $0x4, 0xf8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xe793a
jmp 0xe7936
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/outstream.cpp
// Function: smooth::IO::OutStream::OutputNumberRaw(long long, int)
S::Bool S::IO::OutStream::OutputNumberRaw(Int64 number, Int bytes)
{
	if (streamType == STREAM_NONE)	{ lastError = IO_ERROR_NOTOPEN; return False; }
	if (packageSize <= 0)		{ lastError = IO_ERROR_UNKNOWN; return False; }
	if (bytes > 8 || bytes < 0)	{ lastError = IO_ERROR_BADPARAM; return False; }

	if (bitstreamActive && !keepBits) CompleteBitstream();

	for (Int i = bytes - 1; i >= 0; i--)
	{
		if (currentBufferPos >= packageSize)
		{
			if (!WriteData()) { lastError = IO_ERROR_UNKNOWN; return False; }
		}

		dataBuffer[currentBufferPos] = IOGetByte(number, i);
		if (currentFilePos == size) size++;
		currentBufferPos++;
		currentFilePos++;
	}

	if (currentBufferPos >= packageSize)
	{
		if (!WriteData()) { lastError = IO_ERROR_UNKNOWN; return False; }
	}

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movswl 0x8(%rax), %eax
cmpl $0x0, %eax
jne 0xe7b5a
movq -0x28(%rbp), %rax
movw $0x5, 0xf8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xe7cba
movq -0x28(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jg 0xe7b7a
movq -0x28(%rbp), %rax
movw $0x4, 0xf8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xe7cba
cmpl $0x8, -0x1c(%rbp)
jg 0xe7b86
cmpl $0x0, -0x1c(%rbp)
jge 0xe7b9c
movq -0x28(%rbp), %rax
movw $0x2, 0xf8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xe7cba
movq -0x28(%rbp), %rax
testb $0x1, 0x60(%rax)
je 0xe7bb9
movq -0x28(%rbp), %rax
testb $0x1, 0x61(%rax)
jne 0xe7bb9
movq -0x28(%rbp), %rdi
callq 0x5a7a0
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0xe7c88
movq -0x28(%rbp), %rcx
movl 0x50(%rcx), %eax
cmpl 0x38(%rcx), %eax
jl 0xe7bfd
movq -0x28(%rbp), %rdi
callq 0x5be10
testb $0x1, %al
jne 0xe7bfb
movq -0x28(%rbp), %rax
movw $0x4, 0xf8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xe7cba
jmp 0xe7bfd
cmpl $0x7, -0x20(%rbp)
jle 0xe7c0b
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0xe7c24
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
sarq %cl, %rax
andq $0xff, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movb %cl, -0x31(%rbp)
movq %rax, %rdi
addq $0x20, %rdi
movl 0x50(%rax), %esi
callq 0x717e0
movb -0x31(%rbp), %dl
movq -0x28(%rbp), %rcx
movb %dl, (%rax)
movq 0x48(%rcx), %rax
cmpq 0x10(%rcx), %rax
jne 0xe7c61
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movl 0x50(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x50(%rax)
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xe7bc2
movq -0x28(%rbp), %rcx
movl 0x50(%rcx), %eax
cmpl 0x38(%rcx), %eax
jl 0xe7cb6
movq -0x28(%rbp), %rdi
callq 0x5be10
testb $0x1, %al
jne 0xe7cb4
movq -0x28(%rbp), %rax
movw $0x4, 0xf8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xe7cba
jmp 0xe7cb6
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/outstream.cpp
// Function: smooth::IO::OutStream::OutputLine(smooth::String const&)
S::Bool S::IO::OutStream::OutputLine(const String &string)
{
	if (string != NIL && !OutputString(string)) return False;

#if (defined __WIN32__ || defined MSDOS) && !defined __CYGWIN32__
	OutputNumber(13, 1);
#endif

	OutputNumber(10, 1);

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x5b110
testb $0x1, %al
jne 0xe80d9
jmp 0xe80f0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x59cc0
testb $0x1, %al
jne 0xe80f0
movb $0x0, -0x1(%rbp)
jmp 0xe8107
movq -0x20(%rbp), %rdi
movl $0xa, %esi
movl $0x1, %edx
callq 0x598f0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/outstream.cpp
// Function: smooth::IO::OutStream::SetPackageSize(int)
S::Bool S::IO::OutStream::SetPackageSize(Int newPackageSize)
{
	if (streamType == STREAM_NONE)	{ lastError = IO_ERROR_NOTOPEN; return False; }
	if (!allowpackset)		{ lastError = IO_ERROR_OPNOTAVAIL; return False; }
	if (newPackageSize <= 0)	{ lastError = IO_ERROR_BADPARAM; return False; }

	Flush();

	dataBuffer.Resize(newPackageSize);

	packageSize = newPackageSize;
	stdpacksize = packageSize;

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movswl 0x8(%rax), %eax
cmpl $0x0, %eax
jne 0xe82f3
movq -0x20(%rbp), %rax
movw $0x5, 0xf8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xe8356
movq -0x20(%rbp), %rax
testb $0x1, 0x44(%rax)
jne 0xe8310
movq -0x20(%rbp), %rax
movw $0x6, 0xf8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xe8356
cmpl $0x0, -0x14(%rbp)
jg 0xe8329
movq -0x20(%rbp), %rax
movw $0x2, 0xf8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xe8356
movq -0x20(%rbp), %rdi
callq 0x5d960
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movl -0x14(%rbp), %esi
callq 0x72e00
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x38(%rax)
movl 0x38(%rax), %ecx
movl %ecx, 0x3c(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/outstream.cpp
// Function: smooth::IO::OutStream::SetFilter(smooth::IO::Filter*)
S::Bool S::IO::OutStream::SetFilter(Filter *newFilter)
{
	if (streamType == STREAM_NONE)	{ lastError = IO_ERROR_NOTOPEN; return False; }
	if (filter != NIL)		{ lastError = IO_ERROR_BADPARAM; return False; }

	newFilter->SetDriver(driver);

	if (newFilter->Activate() == False) { lastError = IO_ERROR_UNKNOWN; return False; }

	if (bitstreamActive && !keepBits) CompleteBitstream();

	Flush();

	filter = newFilter;

	allowpackset = True;

	if (filter->GetPackageSize() > 0)
	{
		SetPackageSize(filter->GetPackageSize());	// package size must be eqv filter size

		allowpackset = False;
	}
	else if (filter->GetPackageSize() == -1)
	{
		SetPackageSize(defaultPackageSize);

		allowpackset = False;
	}

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movswl 0x8(%rax), %eax
cmpl $0x0, %eax
jne 0xe83a7
movq -0x20(%rbp), %rax
movw $0x5, 0xf8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xe84ad
movq -0x20(%rbp), %rax
cmpq $0x0, 0xf0(%rax)
je 0xe83cb
movq -0x20(%rbp), %rax
movw $0x2, 0xf8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xe84ad
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movq 0xe8(%rax), %rsi
callq 0x59bf0
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xe8409
movq -0x20(%rbp), %rax
movw $0x4, 0xf8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xe84ad
movq -0x20(%rbp), %rax
testb $0x1, 0x60(%rax)
je 0xe8426
movq -0x20(%rbp), %rax
testb $0x1, 0x61(%rax)
jne 0xe8426
movq -0x20(%rbp), %rdi
callq 0x5a7a0
movq -0x20(%rbp), %rdi
callq 0x5d960
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0xf0(%rax)
movb $0x1, 0x44(%rax)
movq 0xf0(%rax), %rdi
callq 0x5b7a0
cmpl $0x0, %eax
jle 0xe8478
movq -0x20(%rbp), %rax
movq 0xf0(%rax), %rdi
callq 0x5b7a0
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x5a770
movq -0x20(%rbp), %rax
movb $0x0, 0x44(%rax)
jmp 0xe84a9
movq -0x20(%rbp), %rax
movq 0xf0(%rax), %rdi
callq 0x5b7a0
cmpl $-0x1, %eax
jne 0xe84a7
movq -0x20(%rbp), %rdi
movq 0x120308(%rip), %rax    # 0x2087a0
movl (%rax), %esi
callq 0x5a770
movq -0x20(%rbp), %rax
movb $0x0, 0x44(%rax)
jmp 0xe84a9
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/outstream.cpp
// Function: smooth::IO::OutStream::RemoveFilter()
S::Bool S::IO::OutStream::RemoveFilter()
{
	if (streamType == STREAM_NONE)	{ lastError = IO_ERROR_NOTOPEN; return False; }
	if (filter == NIL)		{ lastError = IO_ERROR_BADPARAM; return False; }

	if (bitstreamActive && !keepBits) CompleteBitstream();

	Int	 oldcpos = currentBufferPos;

	if (filter->GetPackageSize() > 0 && currentBufferPos != 0)
	{
		for (Int i = 0; i < (packageSize - oldcpos); i++) OutputNumber(0, 1);
	}
	else
	{
		if (filter->GetPackageSize() == -1) allowpackset = True;

		Flush();
	}

	allowpackset = True;

	filter->Deactivate();
	filter = NIL;

	SetPackageSize(origpacksize);

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movswl 0x8(%rax), %eax
cmpl $0x0, %eax
jne 0xe84f3
movq -0x20(%rbp), %rax
movw $0x5, 0xf8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xe85e6
movq -0x20(%rbp), %rax
cmpq $0x0, 0xf0(%rax)
jne 0xe8517
movq -0x20(%rbp), %rax
movw $0x2, 0xf8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xe85e6
movq -0x20(%rbp), %rax
testb $0x1, 0x60(%rax)
je 0xe8534
movq -0x20(%rbp), %rax
testb $0x1, 0x61(%rax)
jne 0xe8534
movq -0x20(%rbp), %rdi
callq 0x5a7a0
movq -0x20(%rbp), %rax
movl 0x50(%rax), %ecx
movl %ecx, -0x14(%rbp)
movq 0xf0(%rax), %rdi
callq 0x5b7a0
cmpl $0x0, %eax
jle 0xe8590
movq -0x20(%rbp), %rax
cmpl $0x0, 0x50(%rax)
je 0xe8590
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
movl 0x38(%rcx), %ecx
subl -0x14(%rbp), %ecx
cmpl %ecx, %eax
jge 0xe858e
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x598f0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xe8560
jmp 0xe85b6
movq -0x20(%rbp), %rax
movq 0xf0(%rax), %rdi
callq 0x5b7a0
cmpl $-0x1, %eax
jne 0xe85ad
movq -0x20(%rbp), %rax
movb $0x1, 0x44(%rax)
movq -0x20(%rbp), %rdi
callq 0x5d960
movq -0x20(%rbp), %rax
movb $0x1, 0x44(%rax)
movq 0xf0(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x20(%rbp), %rdi
movq $0x0, 0xf0(%rdi)
movl 0x40(%rdi), %esi
callq 0x5a770
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/outstream.cpp
// Function: smooth::IO::OutStream::Close()
S::Bool S::IO::OutStream::Close()
{
	if (streamType == STREAM_NONE)	{ lastError = IO_ERROR_NOTOPEN; return False; }

	while (filter != NIL) RemoveFilter();

	Flush();

	if (crosslinked)
	{
		if (closefile) inStream->closefile = True;

		inStream->crosslinked	= False;
		inStream->outStream	= NIL;

		closefile = False;
	}

	if (closefile) delete driver;

	streamType = STREAM_NONE;

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movswl 0x8(%rax), %eax
cmpl $0x0, %eax
jne 0xe8633
movq -0x18(%rbp), %rax
movw $0x5, 0xf8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xe86d9
jmp 0xe8635
movq -0x18(%rbp), %rax
cmpq $0x0, 0xf0(%rax)
je 0xe864f
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0xe8635
movq -0x18(%rbp), %rdi
callq 0x5d960
movq -0x18(%rbp), %rax
testb $0x1, 0xa(%rax)
je 0xe86a0
movq -0x18(%rbp), %rax
testb $0x1, 0xb(%rax)
je 0xe867b
movq -0x18(%rbp), %rax
movq 0x100(%rax), %rax
movb $0x1, 0xb(%rax)
movq -0x18(%rbp), %rax
movq 0x100(%rax), %rcx
movb $0x0, 0xa(%rcx)
movq 0x100(%rax), %rcx
movq $0x0, 0x100(%rcx)
movb $0x0, 0xb(%rax)
movq -0x18(%rbp), %rax
testb $0x1, 0xb(%rax)
je 0xe86cb
movq -0x18(%rbp), %rax
movq 0xe8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xe86c9
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0xe86cb
movq -0x18(%rbp), %rax
movw $0x0, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/outstream.cpp
// Function: smooth::IO::OutStream::Seek(long long)
S::Bool S::IO::OutStream::Seek(Int64 position)
{
	if (streamType == STREAM_NONE)	{ lastError = IO_ERROR_NOTOPEN; return False; }

	Flush();

	if (driver->Seek(position) == -1) return False;

	currentFilePos	 = position;
	currentBufferPos = 0;

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movswl 0x8(%rax), %eax
cmpl $0x0, %eax
jne 0xe8724
movq -0x20(%rbp), %rax
movw $0x5, 0xf8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xe8765
movq -0x20(%rbp), %rdi
callq 0x5d960
movq -0x20(%rbp), %rax
movq 0xe8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
cmpq $-0x1, %rax
jne 0xe874e
movb $0x0, -0x1(%rbp)
jmp 0xe8765
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x48(%rax)
movl $0x0, 0x50(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/outstream.cpp
// Function: smooth::IO::OutStream::Truncate(long long)
S::Bool S::IO::OutStream::Truncate(Int64 size)
{
	if (streamType == STREAM_NONE)	{ lastError = IO_ERROR_NOTOPEN; return False; }

	if (!driver->Truncate(size)) return False;

	Seek(size);

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movswl 0x8(%rax), %eax
cmpl $0x0, %eax
jne 0xe8804
movq -0x20(%rbp), %rax
movw $0x5, 0xf8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xe8835
movq -0x20(%rbp), %rax
movq 0xe8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x28(%rax)
testb $0x1, %al
jne 0xe8823
movb $0x0, -0x1(%rbp)
jmp 0xe8835
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x28(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/stream.cpp
// Function: smooth::IO::Stream::Stream()
S::IO::Stream::Stream()
{
	streamType	 = STREAM_NONE;
	size		 = 0;

	currentFilePos	 = 0;
	currentBufferPos = 0;

	bitstreamActive	 = False;
	keepBits	 = False;
	bitLength	 = 0;

	closefile	 = True;
	crosslinked	 = False;

	driver		 = NIL;
	filter		 = NIL;

	allowpackset	 = True;
	packageSize	 = 1;
	stdpacksize	 = packageSize;
	origpacksize	 = packageSize;
	origsize	 = 0;
	origfilepos	 = 0;

	lastError	 = IO_ERROR_OK;

	memset(&bitBuffer, 0, sizeof(bitBuffer));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq 0x120125(%rip), %rax    # 0x208980
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x20, %rdi
callq 0x70fc0
movq -0x10(%rbp), %rdi
movw $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x48(%rdi)
movl $0x0, 0x50(%rdi)
movb $0x0, 0x60(%rdi)
movb $0x0, 0x61(%rdi)
movl $0x0, 0x64(%rdi)
movb $0x1, 0xb(%rdi)
movb $0x0, 0xa(%rdi)
movq $0x0, 0xe8(%rdi)
movq $0x0, 0xf0(%rdi)
movb $0x1, 0x44(%rdi)
movl $0x1, 0x38(%rdi)
movl 0x38(%rdi), %eax
movl %eax, 0x3c(%rdi)
movl 0x38(%rdi), %eax
movl %eax, 0x40(%rdi)
movq $0x0, 0x18(%rdi)
movq $0x0, 0x58(%rdi)
movw $0x0, 0xf8(%rdi)
addq $0x68, %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x5a200
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/drivers/driver_ansi.cpp
// Function: smooth::IO::DriverANSI::ReadData(unsigned char*, int)
S::Int S::IO::DriverANSI::ReadData(UnsignedByte *data, Int dataSize)
{
	if (!stream || dataSize <= 0) return 0;

	/* Switch between read and write mode.
	 */
	if (position == -1) fseeko(stream, 0, SEEK_CUR);

	position = 1;

	/* Perform actual read operation.
	 */
	return fread(data, 1, dataSize, stream);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x38(%rax)
je 0xe8f18
cmpl $0x0, -0x1c(%rbp)
jg 0xe8f21
movl $0x0, -0x4(%rbp)
jmp 0xe8f67
movq -0x28(%rbp), %rax
cmpq $-0x1, 0x10(%rax)
jne 0xe8f42
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x59270
movq -0x28(%rbp), %rax
movq $0x1, 0x10(%rax)
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rdx
movq 0x38(%rax), %rcx
movl $0x1, %esi
callq 0x5af50
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/drivers/driver_ansi.cpp
// Function: smooth::IO::DriverANSI::WriteData(unsigned char const*, int)
S::Int S::IO::DriverANSI::WriteData(const UnsignedByte *data, Int dataSize)
{
	if (!stream || dataSize <= 0) return 0;

	/* Switch between read and write mode.
	 */
	if (position == 1) fseeko(stream, 0, SEEK_CUR);

	position = -1;

	/* Perform actual write operation.
	 */
	return fwrite(data, 1, dataSize, stream);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x38(%rax)
je 0xe8f98
cmpl $0x0, -0x1c(%rbp)
jg 0xe8fa1
movl $0x0, -0x4(%rbp)
jmp 0xe8fe7
movq -0x28(%rbp), %rax
cmpq $0x1, 0x10(%rax)
jne 0xe8fc2
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x59270
movq -0x28(%rbp), %rax
movq $-0x1, 0x10(%rax)
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rdx
movq 0x38(%rax), %rcx
movl $0x1, %esi
callq 0x5d410
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/drivers/driver_ansi.cpp
// Function: smooth::IO::DriverANSI::Seek(long long)
S::Int64 S::IO::DriverANSI::Seek(Int64 newPos)
{
	if (!stream || fseeko(stream, newPos, SEEK_SET) != 0) return -1;

	/* Reset read/write mode indicator.
	 */
	position = 0;

	return GetPos();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x38(%rax)
je 0xe9027
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x59270
cmpl $0x0, %eax
je 0xe9031
movq $-0x1, -0x8(%rbp)
jmp 0xe9047
movq -0x20(%rbp), %rdi
movq $0x0, 0x10(%rdi)
movq (%rdi), %rax
callq *0x48(%rax)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/drivers/driver_ansi.cpp
// Function: smooth::IO::DriverANSI::Close()
S::Bool S::IO::DriverANSI::Close()
{
	if (!stream || !closeStream || fclose(stream) != 0) return False;

	stream	    = NIL;
	closeStream = False;

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x38(%rax)
je 0xe9157
movq -0x18(%rbp), %rax
testb $0x1, 0x40(%rax)
je 0xe9157
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x5a8f0
cmpl $0x0, %eax
je 0xe915d
movb $0x0, -0x1(%rbp)
jmp 0xe9171
movq -0x18(%rbp), %rax
movq $0x0, 0x38(%rax)
movb $0x0, 0x40(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/drivers/driver_ansi.cpp
// Function: smooth::IO::DriverANSI::GetSize() const
S::Int64 S::IO::DriverANSI::GetSize() const
{
	if (!stream) return -1;

	Int64	 oldPos = GetPos();

	if (fseeko(stream,      0, SEEK_END) != 0) return -1;

	Int64	 size = GetPos();

	if (fseeko(stream, oldPos, SEEK_SET) != 0) return -1;

	return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x38(%rax)
jne 0xe91a5
movq $-0x1, -0x8(%rbp)
jmp 0xe9216
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq 0x38(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x59270
cmpl $0x0, %eax
je 0xe91db
movq $-0x1, -0x8(%rbp)
jmp 0xe9216
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x38(%rax), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x59270
cmpl $0x0, %eax
je 0xe920e
movq $-0x1, -0x8(%rbp)
jmp 0xe9216
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/drivers/driver_ansi.cpp
// Function: smooth::IO::DriverANSI::SetBufferSize(int)
S::Bool S::IO::DriverANSI::SetBufferSize(Int size)
{
	if (!stream) return False;

	Int64	 pos  = GetPos();
	Int	 mode = size > 0 ? _IOFBF : _IONBF;

	if (setvbuf(stream, NULL, mode, size) != 0) return False;
	if (Seek(pos) < 0)			    return False;

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x38(%rax)
jne 0xe9294
movb $0x0, -0x1(%rbp)
jmp 0xe92f9
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %esi
movl $0x2, %ecx
xorl %edx, %edx
cmpl $0x0, %esi
cmovgl %edx, %ecx
movl %ecx, -0x24(%rbp)
movq 0x38(%rax), %rdi
movl -0x24(%rbp), %edx
movslq -0x14(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x5aab0
cmpl $0x0, %eax
je 0xe92db
movb $0x0, -0x1(%rbp)
jmp 0xe92f9
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
cmpq $0x0, %rax
jge 0xe92f5
movb $0x0, -0x1(%rbp)
jmp 0xe92f9
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/drivers/driver_https.cpp
// Function: smooth::IO::DriverHTTPS::ReadData(unsigned char*, int)
S::Int S::IO::DriverHTTPS::ReadData(UnsignedByte *data, Int dataSize)
{
	if (dataSize <= 0) return 0;

	int	 bytes = recv(stream, (char *) data, dataSize, 0);

	if (bytes <= 0) return -1;
	else		return bytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0xe9dda
movl $0x0, -0x4(%rbp)
jmp 0xe9e08
movq -0x28(%rbp), %rax
movl 0x38(%rax), %edi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
xorl %ecx, %ecx
callq 0x5ccb0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jg 0xe9e02
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe9e08
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/drivers/driver_https.cpp
// Function: smooth::IO::DriverHTTPS::Close()
S::Bool S::IO::DriverHTTPS::Close()
{
#if defined __WIN32__
	if (!closeStream || closesocket(stream) != 0) return False;
#else
	if (!closeStream || close(stream)	!= 0) return False;
#endif

	closeStream = False;

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x3c(%rax)
je 0xe9e9b
movq -0x18(%rbp), %rax
movl 0x38(%rax), %edi
callq 0x59d30
cmpl $0x0, %eax
je 0xe9ea1
movb $0x0, -0x1(%rbp)
jmp 0xe9ead
movq -0x18(%rbp), %rax
movb $0x0, 0x3c(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/drivers/driver_memory.cpp
// Function: smooth::IO::DriverMemory::ReadData(unsigned char*, int)
S::Int S::IO::DriverMemory::ReadData(UnsignedByte *data, Int dataSize)
{
	if (dataSize <= 0) return 0;

	dataSize = Math::Min(dataSize, size - position);

	memcpy(data, (unsigned char *) stream + position, dataSize);

	position += dataSize;

	return dataSize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0xe9f8a
movl $0x0, -0x4(%rbp)
jmp 0xe9fd2
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %edi
movq 0x8(%rax), %rsi
subq 0x10(%rax), %rsi
callq 0x5bc90
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movq 0x38(%rax), %rsi
addq 0x10(%rax), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x593a0
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/drivers/driver_memory.cpp
// Function: smooth::IO::DriverMemory::WriteData(unsigned char const*, int)
S::Int S::IO::DriverMemory::WriteData(const UnsignedByte *data, Int dataSize)
{
	if (dataSize <= 0) return 0;

	dataSize = Math::Min(dataSize, size - position);

	memcpy((unsigned char *) stream + position, data, dataSize);

	position += dataSize;

	return dataSize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0xea00a
movl $0x0, -0x4(%rbp)
jmp 0xea052
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %edi
movq 0x8(%rax), %rsi
subq 0x10(%rax), %rsi
callq 0x5bc90
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x1c(%rbp)
movq 0x38(%rax), %rdi
addq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x593a0
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/drivers/driver_posix.cpp
// Function: smooth::IO::DriverPOSIX::Close()
S::Bool S::IO::DriverPOSIX::Close()
{
	if (stream == -1 || !closeStream || close(stream) != 0) return False;

	stream	    = -1;
	closeStream = False;

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $-0x1, 0x38(%rax)
je 0xea605
movq -0x18(%rbp), %rax
testb $0x1, 0x3c(%rax)
je 0xea605
movq -0x18(%rbp), %rax
movl 0x38(%rax), %edi
callq 0x59d30
cmpl $0x0, %eax
je 0xea60b
movb $0x0, -0x1(%rbp)
jmp 0xea61e
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x38(%rax) # imm = 0xFFFFFFFF
movb $0x0, 0x3c(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/drivers/driver_posix.cpp
// Function: smooth::IO::DriverPOSIX::GetSize() const
S::Int64 S::IO::DriverPOSIX::GetSize() const
{
	if (stream == -1) return -1;

	Int64	 oldPos = GetPos();
	Int64	 size = lseek64(stream, 0, SEEK_END);

	lseek64(stream, oldPos, SEEK_SET);

	return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $-0x1, 0x38(%rax)
jne 0xea654
movq $-0x1, -0x8(%rbp)
jmp 0xea69b
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x18(%rbp)
movl 0x38(%rax), %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x5cab0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movl 0x38(%rax), %edi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x5cab0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/drivers/driver_socket.cpp
// Function: smooth::IO::DriverSocket::DriverSocket(smooth::String const&, int)
S::IO::DriverSocket::DriverSocket(const String &hostName, Int port) : Driver()
{
	closeStream = False;

	stream	    = -1;
	size	    = -1;

	mode	    = MODE_SOCKET_BLOCKING;
	timeout	    = 0;

	if (hostName.Length() > 255) { lastError = IO_ERROR_BADPARAM; return; }

	/* Open TCP/IP socket.
	 */
	stream = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

	if (stream == (unsigned) (~0)) { lastError = IO_ERROR_UNEXPECTED; return; }

	closeStream = True;

	/* Get server hostname.
	 */
	hostent		*host = gethostbyname(hostName);

	if (host == NIL) { Close(); lastError = IO_ERROR_UNEXPECTED; return; }

	/* Connect to server.
	 */
	sockaddr_in	 saddr;

	saddr.sin_family = AF_INET;
	saddr.sin_addr	 = *((in_addr *) *host->h_addr_list);
	saddr.sin_port	 = htons((short) port);

	memset(&saddr.sin_zero, 0, sizeof(saddr.sin_zero));

	if (connect(stream, (sockaddr *) &saddr, sizeof(struct sockaddr)) == -1) { Close(); lastError = IO_ERROR_UNEXPECTED; return; }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x5cff0
movq -0x50(%rbp), %rax
movq 0x11dc1d(%rip), %rcx    # 0x208348
addq $0x10, %rcx
movq %rcx, (%rax)
movb $0x0, 0x3c(%rax)
movl $0xffffffff, 0x38(%rax) # imm = 0xFFFFFFFF
movq $-0x1, 0x8(%rax)
movq $0x0, 0x40(%rax)
movl $0x0, 0x48(%rax)
movq -0x10(%rbp), %rdi
callq 0x5b800
movl %eax, -0x44(%rbp)
jmp 0xea762
movl -0x44(%rbp), %eax
cmpl $0xff, %eax
jle 0xea796
movq -0x50(%rbp), %rax
movl $0x2, 0x18(%rax)
jmp 0xea884
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x5b1a0
jmp 0xea88a
movl $0x2, %edi
movl $0x1, %esi
movl $0x6, %edx
callq 0x5ab00
movl %eax, %ecx
movq -0x50(%rbp), %rax
movl %ecx, 0x38(%rax)
cmpl $-0x1, 0x38(%rax)
jne 0xea7c9
movq -0x50(%rbp), %rax
movl $0x3, 0x18(%rax)
jmp 0xea884
movq -0x50(%rbp), %rax
movb $0x1, 0x3c(%rax)
movq -0x10(%rbp), %rdi
callq 0x5d090
movq %rax, -0x58(%rbp)
jmp 0xea7e0
movq -0x58(%rbp), %rdi
callq 0x5a990
movq %rax, -0x60(%rbp)
jmp 0xea7ef
movq -0x60(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xea81a
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
jmp 0xea80d
movq -0x50(%rbp), %rax
movl $0x3, 0x18(%rax)
jmp 0xea884
movw $0x2, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movzwl -0x14(%rbp), %edi
callq 0x5ba50
movw %ax, %cx
movq -0x50(%rbp), %rax
movw %cx, -0x3e(%rbp)
movq $0x0, -0x38(%rbp)
movl 0x38(%rax), %edi
leaq -0x40(%rbp), %rsi
movl $0x10, %edx
callq 0x5a630
movl %eax, -0x64(%rbp)
jmp 0xea862
movl -0x64(%rbp), %eax
cmpl $-0x1, %eax
jne 0xea884
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
jmp 0xea879
movq -0x50(%rbp), %rax
movl $0x3, 0x18(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5b6b0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/drivers/driver_socket.cpp
// Function: smooth::IO::DriverSocket::DriverSocket(unsigned int)
S::IO::DriverSocket::DriverSocket(unsigned int iStream) : Driver()
{
	size	    = -1;

	stream	    = iStream;
	closeStream = False;
	timeout	    = 0;

	SetMode(MODE_SOCKET_BLOCKING);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x5cff0
movq -0x28(%rbp), %rdi
movq 0x11da81(%rip), %rax    # 0x208348
addq $0x10, %rax
movq %rax, (%rdi)
movq $-0x1, 0x8(%rdi)
movl -0xc(%rbp), %eax
movl %eax, 0x38(%rdi)
movb $0x0, 0x3c(%rdi)
movl $0x0, 0x48(%rdi)
xorl %esi, %esi
callq 0x5cb40
jmp 0xea8f0
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x5b1a0
movq -0x18(%rbp), %rdi
callq 0x5b6b0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/drivers/driver_socket.cpp
// Function: smooth::IO::DriverSocket::SetMode(int)
S::Bool S::IO::DriverSocket::SetMode(Int nm)
{
	switch (nm)
	{
		default:
			return False;

		case MODE_SOCKET_BLOCKING:
		case MODE_SOCKET_NONBLOCKING:
			mode = nm;

			break;
	}

#if defined __WIN32__
	if (ioctlsocket(stream, FIONBIO, &mode) != 0) return False;
	else					      return True;
#else
	if (ioctl(stream, FIONBIO, &mode)	!= 0) return False;
	else					      return True;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
subl $0x2, %eax
jb 0xea947
jmp 0xea941
movb $0x0, -0x1(%rbp)
jmp 0xea979
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x20(%rbp), %rdx
movl 0x38(%rdx), %edi
addq $0x40, %rdx
movl $0x5421, %esi           # imm = 0x5421
movb $0x0, %al
callq 0x596c0
cmpl $0x0, %eax
je 0xea975
movb $0x0, -0x1(%rbp)
jmp 0xea979
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/drivers/driver_socket.cpp
// Function: smooth::IO::DriverSocket::ReadData(unsigned char*, int)
S::Int S::IO::DriverSocket::ReadData(UnsignedByte *data, Int dataSize)
{
	if (dataSize <= 0) return 0;

	if (mode == MODE_SOCKET_BLOCKING && timeout != 0)
	{
#if defined __WIN32__
		TIMEVAL	 tv = {timeout, 0};
		FD_SET	 sock;

		FD_ZERO(&sock);
		FD_SET(stream, &sock);

		if (select(0, &sock, 0, 0, &tv) != 1) return 0;
#endif
	}

	int	 bytes = recv(stream, (char *) data, dataSize, 0);

	if (bytes <= 0) return -1;
	else		return bytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0xeaa3a
movl $0x0, -0x4(%rbp)
jmp 0xeaa7f
movq -0x28(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0xeaa51
movq -0x28(%rbp), %rax
cmpl $0x0, 0x48(%rax)
je 0xeaa51
jmp 0xeaa51
movq -0x28(%rbp), %rax
movl 0x38(%rax), %edi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
xorl %ecx, %ecx
callq 0x5ccb0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jg 0xeaa79
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xeaa7f
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/drivers/driver_socket.cpp
// Function: smooth::IO::DriverSocket::WriteData(unsigned char const*, int)
S::Int S::IO::DriverSocket::WriteData(const UnsignedByte *data, Int dataSize)
{
	if (dataSize <= 0) return 0;

	if (mode == MODE_SOCKET_BLOCKING && timeout != 0)
	{
#if defined __WIN32__
		TIMEVAL	 tv = { timeout, 0 };
		FD_SET	 sock;

		FD_ZERO(&sock);
		FD_SET(stream, &sock);

		if (select(0, 0, &sock, 0, &tv) != 1) return 0;
#endif
	}

	return send(stream, (const char *) data, dataSize, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0xeaaba
movl $0x0, -0x4(%rbp)
jmp 0xeaaea
movq -0x28(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0xeaad1
movq -0x28(%rbp), %rax
cmpl $0x0, 0x48(%rax)
je 0xeaad1
jmp 0xeaad1
movq -0x28(%rbp), %rax
movl 0x38(%rax), %edi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
xorl %ecx, %ecx
callq 0x5a4f0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/drivers/driver_socket.cpp
// Function: smooth::IO::DriverSocket::SetTimeout(int)
S::Bool S::IO::DriverSocket::SetTimeout(Int nt)
{
	if (mode != MODE_SOCKET_BLOCKING) return False;
	if (timeout < 0)		  return False;

	timeout = nt;

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x40(%rax)
je 0xeab70
movb $0x0, -0x1(%rbp)
jmp 0xeab8e
movq -0x20(%rbp), %rax
cmpl $0x0, 0x48(%rax)
jge 0xeab80
movb $0x0, -0x1(%rbp)
jmp 0xeab8e
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x48(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/drivers/driver_socks4.cpp
// Function: smooth::IO::DriverSOCKS4::ReadData(unsigned char*, int)
S::Int S::IO::DriverSOCKS4::ReadData(UnsignedByte *data, Int dataSize)
{
	if (dataSize <= 0) return 0;

	int	 bytes = recv(stream, (char *) data, dataSize, 0);

	if (bytes <= 0) return -1;
	else		return bytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0xeb48a
movl $0x0, -0x4(%rbp)
jmp 0xeb4b8
movq -0x28(%rbp), %rax
movl 0x38(%rax), %edi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
xorl %ecx, %ecx
callq 0x5ccb0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jg 0xeb4b2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xeb4b8
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/drivers/driver_socks4.cpp
// Function: smooth::IO::DriverSOCKS4::Close()
S::Bool S::IO::DriverSOCKS4::Close()
{
#if defined __WIN32__
	if (!closeStream || closesocket(stream) != 0) return False;
#else
	if (!closeStream || close(stream)	!= 0) return False;
#endif

	closeStream = False;

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x3c(%rax)
je 0xeb54b
movq -0x18(%rbp), %rax
movl 0x38(%rax), %edi
callq 0x59d30
cmpl $0x0, %eax
je 0xeb551
movb $0x0, -0x1(%rbp)
jmp 0xeb55d
movq -0x18(%rbp), %rax
movb $0x0, 0x3c(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/drivers/driver_socks5.cpp
// Function: smooth::IO::DriverSOCKS5::ReadData(unsigned char*, int)
S::Int S::IO::DriverSOCKS5::ReadData(UnsignedByte *data, Int dataSize)
{
	if (dataSize <= 0) return 0;

	int	 bytes = recv(stream, (char *) data, dataSize, 0);

	if (bytes <= 0) return -1;
	else		return bytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0xec46a
movl $0x0, -0x4(%rbp)
jmp 0xec498
movq -0x28(%rbp), %rax
movl 0x38(%rax), %edi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
xorl %ecx, %ecx
callq 0x5ccb0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jg 0xec492
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xec498
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/filters/filter_bzip2.cpp
// Function: smooth::IO::FilterBZip2::WriteData(smooth::Buffer<unsigned char> const&)
S::Int S::IO::FilterBZip2::WriteData(const Buffer<UnsignedByte> &data)
{
	if (driver == NIL) return -1;

	int		 outsize = data.Size() + data.Size() / 100 + 1000;
	unsigned char	*dest = new unsigned char [outsize];

	BZ2_bzBuffToBuffCompress((char *) dest, (unsigned int *) &outsize, const_cast<char *>((const char *) (const UnsignedByte *) data), data.Size(), 5, 0, 0);

	driver->WriteData(dest, outsize);

	delete [] dest;

	return outsize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0xec6cb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xec777
movq -0x18(%rbp), %rdi
callq 0x71140
movl %eax, -0x4c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x71140
movl $0x64, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x4c(%rbp), %eax
addl %ecx, %eax
addl $0x3e8, %eax            # imm = 0x3E8
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rdi
callq 0x5ab20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x71100
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x71140
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
movl %eax, %ecx
leaq -0x1c(%rbp), %rsi
movl $0x5, %r8d
xorl %r9d, %r9d
movl $0x0, (%rsp)
callq 0x59390
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x28(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xec771
movq -0x38(%rbp), %rdi
callq 0x5a5e0
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/io/filters/filter_bzip2.cpp
// Function: smooth::IO::FilterBZip2::ReadData(smooth::Buffer<unsigned char>&)
S::Int S::IO::FilterBZip2::ReadData(Buffer<UnsignedByte> &data)
{
	if (driver == NIL) return -1;

	/* Try guessing the size of uncompressed data.
	 */
	int	 size = data.Size();
	int	 outsize;

	if	(size < (200 * 1024))	    outsize = size * 100 + 10000;
	else if (size > (20 * 1024 * 1024)) outsize = size *   5 + 10000;
	else				    outsize = size *  10 + 10000;

	/* Now decompress.
	 */
	unsigned char	*src = new unsigned char [size];

	driver->ReadData(src, size);

	data.Resize(outsize);

	BZ2_bzBuffToBuffDecompress((char *) (UnsignedByte *) data, (unsigned int *) &outsize, (char *) src, size, 0, 0);

	delete [] src;

	return outsize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0xec7ab
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xec863
movq -0x18(%rbp), %rdi
callq 0x71140
movl %eax, -0x1c(%rbp)
cmpl $0x32000, -0x1c(%rbp)   # imm = 0x32000
jge 0xec7ce
imull $0x64, -0x1c(%rbp), %eax
addl $0x2710, %eax           # imm = 0x2710
movl %eax, -0x20(%rbp)
jmp 0xec7f3
cmpl $0x1400000, -0x1c(%rbp) # imm = 0x1400000
jle 0xec7e5
imull $0x5, -0x1c(%rbp), %eax
addl $0x2710, %eax           # imm = 0x2710
movl %eax, -0x20(%rbp)
jmp 0xec7f1
imull $0xa, -0x1c(%rbp), %eax
addl $0x2710, %eax           # imm = 0x2710
movl %eax, -0x20(%rbp)
jmp 0xec7f3
movslq -0x1c(%rbp), %rdi
callq 0x5ab20
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rdi
movq -0x28(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x72e00
movq -0x18(%rbp), %rdi
callq 0x71100
movq %rax, %rdi
movq -0x28(%rbp), %rdx
movl -0x1c(%rbp), %ecx
leaq -0x20(%rbp), %rsi
xorl %r9d, %r9d
movl %r9d, %r8d
callq 0x5c150
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xec85d
movq -0x38(%rbp), %rdi
callq 0x5a5e0
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)