LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/misc/string.cpp
// Function: smooth::String::Append(smooth::String const&)
S::String &S::String::Append(const String &str)
{
	if (str == NIL) return *this;

	Int	 len1 = Length();
	Int	 len2 = str.Length();

	wString.Resize(len1 + len2 + 1);

	wcsncpy(wString + len1, str.wString, len2);

	wString[len1 + len2] = 0;

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x59320
testb $0x1, %al
jne 0xf4639
jmp 0xf4643
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xf46be
movq -0x28(%rbp), %rdi
callq 0x5b800
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5b800
movq -0x28(%rbp), %rdi
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %esi
addl -0x20(%rbp), %esi
addl $0x1, %esi
callq 0xf5650
movq -0x28(%rbp), %rdi
callq 0xf5750
movslq -0x1c(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf5750
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movslq -0x20(%rbp), %rdx
callq 0x5d8f0
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
addl -0x20(%rbp), %esi
callq 0xf5790
movq %rax, %rcx
movq -0x28(%rbp), %rax
movl $0x0, (%rcx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/misc/string.cpp
// Function: smooth::String::Replace(smooth::String const&, smooth::String const&)
S::String &S::String::Replace(const String &str1, const String &str2)
{
	if (str1 == NIL) return *this;

	Int	 len1 = Length();
	Int	 len2 = str1.Length();
	Int	 len3 = str2.Length();

	for (Int i = 0; i <= len1 - len2; i++)
	{
		if (wcsncmp(wString + i, str1.wString, len2) == 0)
		{
			if (len2 != len3)
			{
				if (len3 > len2) wString.Resize(len1 + 1 + (len3 - len2));

				wmemmove(wString + i + len3, wString + i + len2, len1 - i - len2 + 1);

				len1 += (len3 - len2);
			}

			if (len3 > 0) wcsncpy(wString + i, str2.wString, len3);

			i += len3 - 1;
		}
	}

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x59320
testb $0x1, %al
jne 0xf478d
jmp 0xf479a
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xf48ff
movq -0x38(%rbp), %rdi
callq 0x5b800
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5b800
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5b800
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl -0x24(%rbp), %ecx
subl -0x28(%rbp), %ecx
cmpl %ecx, %eax
jg 0xf48f7
movq -0x38(%rbp), %rdi
callq 0xf5750
movslq -0x30(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf5750
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movslq -0x28(%rbp), %rdx
callq 0x5b980
cmpl $0x0, %eax
jne 0xf48e7
movl -0x28(%rbp), %eax
cmpl -0x2c(%rbp), %eax
je 0xf48a4
movl -0x2c(%rbp), %eax
cmpl -0x28(%rbp), %eax
jle 0xf483b
movq -0x38(%rbp), %rdi
movl -0x24(%rbp), %esi
addl $0x1, %esi
movl -0x2c(%rbp), %eax
subl -0x28(%rbp), %eax
addl %eax, %esi
callq 0xf5650
movq -0x38(%rbp), %rdi
callq 0xf5750
movq -0x38(%rbp), %rdi
movslq -0x30(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x2c(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
callq 0xf5750
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movslq -0x30(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movslq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movl -0x24(%rbp), %eax
subl -0x30(%rbp), %eax
subl -0x28(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x5b210
movl -0x2c(%rbp), %eax
subl -0x28(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0xf48db
movq -0x38(%rbp), %rdi
callq 0xf5750
movslq -0x30(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rdi
callq 0xf5750
movq -0x50(%rbp), %rdi
movq %rax, %rsi
movslq -0x2c(%rbp), %rdx
callq 0x5d8f0
movl -0x2c(%rbp), %eax
subl $0x1, %eax
addl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0xf48e9
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xf47c5
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/misc/string.cpp
// Function: smooth::String::CopyN(smooth::String const&, int)
S::String &S::String::CopyN(const String &str, const Int n)
{
	Clean();

	if (n > 0)
	{
		wString.Resize(n + 1);

		wcsncpy(wString, str.wString, n);

		wString[n] = 0;
	}

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x5c070
cmpl $0x0, -0x14(%rbp)
jle 0xf4a3d
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
callq 0xf5650
movq -0x20(%rbp), %rdi
callq 0xf5750
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf5750
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movslq -0x14(%rbp), %rdx
callq 0x5d8f0
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xf5790
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/misc/string.cpp
// Function: smooth::String::CompareN(smooth::String const&, int) const
S::Int S::String::CompareN(const String &str, Int n) const
{
	if (n == 0)	  return 0;
	if (Length() < n) return 1;

	if (wcsncmp(wString, str.wString, n) != 0) return 1;

	return 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)
jne 0xf4aba
movl $0x0, -0x4(%rbp)
jmp 0xf4b0c
movq -0x28(%rbp), %rdi
callq 0x5b800
cmpl -0x1c(%rbp), %eax
jge 0xf4ad1
movl $0x1, -0x4(%rbp)
jmp 0xf4b0c
movq -0x28(%rbp), %rdi
callq 0xf5750
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf5750
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movslq -0x1c(%rbp), %rdx
callq 0x5b980
cmpl $0x0, %eax
je 0xf4b05
movl $0x1, -0x4(%rbp)
jmp 0xf4b0c
movl $0x0, -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/misc/string.cpp
// Function: smooth::String::StartsWith(smooth::String const&) const
S::Bool S::String::StartsWith(const String &str) const
{
	if (str == NIL) return True;

	Int	 len1 = Length();
	Int	 len2 = str.Length();

	if (len1 >= len2)
	{
		if (wcsncmp(wString, str.wString, len2) != 0) return False;

		return True;
	}

	return False;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x59320
testb $0x1, %al
jne 0xf4b49
jmp 0xf4b4f
movb $0x1, -0x1(%rbp)
jmp 0xf4baa
movq -0x28(%rbp), %rdi
callq 0x5b800
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5b800
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jl 0xf4ba6
movq -0x28(%rbp), %rdi
callq 0xf5750
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf5750
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movslq -0x20(%rbp), %rdx
callq 0x5b980
cmpl $0x0, %eax
je 0xf4ba0
movb $0x0, -0x1(%rbp)
jmp 0xf4baa
movb $0x1, -0x1(%rbp)
jmp 0xf4baa
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/misc/string.cpp
// Function: smooth::String::EndsWith(smooth::String const&) const
S::Bool S::String::EndsWith(const String &str) const
{
	if (str == NIL) return True;

	Int	 len1 = Length();
	Int	 len2 = str.Length();

	if (len1 >= len2)
	{
		if (wcsncmp(wString + len1 - len2, str.wString, len2) != 0) return False;

		return True;
	}

	return False;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x59320
testb $0x1, %al
jne 0xf4be9
jmp 0xf4bef
movb $0x1, -0x1(%rbp)
jmp 0xf4c65
movq -0x28(%rbp), %rdi
callq 0x5b800
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5b800
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jl 0xf4c61
movq -0x28(%rbp), %rdi
callq 0xf5750
movslq -0x1c(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf5750
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movslq -0x20(%rbp), %rdx
callq 0x5b980
cmpl $0x0, %eax
je 0xf4c5b
movb $0x0, -0x1(%rbp)
jmp 0xf4c65
movb $0x1, -0x1(%rbp)
jmp 0xf4c65
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/misc/string.cpp
// Function: smooth::String::SubString(int, int) const
S::String S::String::SubString(Int start, Int number) const
{
	if (number <= 0 || start < 0 || start >= Length()) return NIL;

	String	 subString;

	subString.wString.Resize(number + 1);

	wcsncpy(subString.wString, wString + start, number);

	subString.wString[number] = 0;

	return subString;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0xf4cbd
cmpl $0x0, -0x14(%rbp)
jl 0xf4cbd
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x4c(%rbp)
callq 0x5b800
movl %eax, %ecx
movl -0x4c(%rbp), %eax
cmpl %ecx, %eax
jl 0xf4ccd
movq -0x48(%rbp), %rdi
xorl %esi, %esi
callq 0x5da90
jmp 0xf4d6d
movq -0x48(%rbp), %rdi
movb $0x0, -0x19(%rbp)
xorl %esi, %esi
callq 0x5da90
movq -0x48(%rbp), %rdi
movl -0x18(%rbp), %esi
incl %esi
callq 0xf5650
jmp 0xf4cec
movq -0x48(%rbp), %rdi
callq 0xf5750
movq %rax, -0x58(%rbp)
jmp 0xf4cfb
movq -0x38(%rbp), %rdi
callq 0xf5750
movq %rax, -0x60(%rbp)
jmp 0xf4d0a
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rax
movslq -0x14(%rbp), %rcx
leaq (%rax,%rcx,4), %rsi
movslq -0x18(%rbp), %rdx
callq 0x5d8f0
movq -0x48(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0xf5790
movq %rax, -0x68(%rbp)
jmp 0xf4d35
movq -0x68(%rbp), %rax
movl $0x0, (%rax)
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xf4d6b
jmp 0xf4d62
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x5df00
jmp 0xf4d77
movq -0x48(%rbp), %rdi
callq 0x5df00
jmp 0xf4d6d
movq -0x40(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x5b6b0
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/misc/string.cpp
// Function: smooth::String::Trim() const
S::String S::String::Trim() const
{
	Int	 length	= Length();
	Int	 triml	= 0;
	Int	 trimr	= 0;

	for (Int i = 0; i < length; i++)
	{
		if ((*this)[i] == ' '  ||
		    (*this)[i] == '\t' ||
		    (*this)[i] == '\n' ||
		    (*this)[i] == '\r' ||
		    (*this)[i] == '\0' ||
		    (*this)[i] == '\x0B') triml++;
		else			  break;
	}

	for (Int i = length - 1; i >= 0; i--)
	{
		if ((*this)[i] == ' '  ||
		    (*this)[i] == '\t' ||
		    (*this)[i] == '\n' ||
		    (*this)[i] == '\r' ||
		    (*this)[i] == '\0' ||
		    (*this)[i] == '\x0B') trimr++;
		else			  break;
	}

	return SubString(triml, length - triml - trimr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x5b800
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xf4edf
movq -0x30(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x5c900
cmpl $0x20, %eax
je 0xf4ec2
movq -0x30(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x5c900
cmpl $0x9, %eax
je 0xf4ec2
movq -0x30(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x5c900
cmpl $0xa, %eax
je 0xf4ec2
movq -0x30(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x5c900
cmpl $0xd, %eax
je 0xf4ec2
movq -0x30(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x5c900
cmpl $0x0, %eax
je 0xf4ec2
movq -0x30(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x5c900
cmpl $0xb, %eax
jne 0xf4ecd
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xf4ecf
jmp 0xf4edf
jmp 0xf4ed1
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xf4e50
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0xf4f75
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x5c900
cmpl $0x20, %eax
je 0xf4f58
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x5c900
cmpl $0x9, %eax
je 0xf4f58
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x5c900
cmpl $0xa, %eax
je 0xf4f58
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x5c900
cmpl $0xd, %eax
je 0xf4f58
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x5c900
cmpl $0x0, %eax
je 0xf4f58
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x5c900
cmpl $0xb, %eax
jne 0xf4f63
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xf4f65
jmp 0xf4f75
jmp 0xf4f67
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xf4ee8
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdi
movl -0x18(%rbp), %edx
movl -0x14(%rbp), %ecx
subl -0x18(%rbp), %ecx
subl -0x1c(%rbp), %ecx
callq 0x5dc20
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/misc/string.cpp
// Function: smooth::String::FillN(int, int)
S::String &S::String::FillN(const Int value, const Int count)
{
	Clean();

	if (count > 0)
	{
		wString.Resize(count + 1);

		wmemset(wString, value, count);

		wString[count] = 0;
	}

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x5c070
cmpl $0x0, -0x10(%rbp)
jle 0xf506e
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
addl $0x1, %esi
callq 0xf5650
movq -0x18(%rbp), %rdi
callq 0xf5750
movq %rax, %rdi
movl -0xc(%rbp), %esi
movslq -0x10(%rbp), %rdx
callq 0x5a9b0
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0xf5790
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/misc/string.cpp
// Function: smooth::String::Implode(smooth::Array<smooth::String, smooth::String> const&, smooth::String const&)
S::String S::String::Implode(const Array<String> &array, const String &delimiter)
{
	String	 string;

	for (Int i = 0; i < array.Length(); i++)
	{
		if (i > 0) string.Append(delimiter);

		string.Append(array.GetNth(i));
	}

	return string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
xorl %esi, %esi
callq 0x5da90
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5c990
movl %eax, -0x44(%rbp)
jmp 0xf54b5
movl -0x48(%rbp), %eax
movl -0x44(%rbp), %ecx
cmpl %ecx, %eax
jge 0xf551b
cmpl $0x0, -0x20(%rbp)
jle 0xf54ed
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5a710
jmp 0xf54d4
jmp 0xf54ed
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x5df00
jmp 0xf5538
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x81b20
movq %rax, -0x50(%rbp)
jmp 0xf54ff
movq -0x50(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x5a710
jmp 0xf550e
jmp 0xf5510
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xf54a1
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xf552e
movq -0x40(%rbp), %rdi
callq 0x5df00
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x5b6b0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/misc/hash/crc16.cpp
// Function: smooth::Hash::CRC16::InitTable()
S::Bool S::Hash::CRC16::InitTable()
{
	UnsignedInt16	 polynomial = 0x8005;

	for (Int i = 0; i <= 0xFF; i++)
	{
		UnsignedInt16	 value = Reflect(i, 8) << 8;

		for (Int j = 0; j < 8; j++) value = (value << 1) ^ (value & (1 << 15) ? polynomial : 0);

		table[0][i] = Reflect(value, 16);
	}

	for (Int i = 0; i <= 0xFF; i++)
	{
		for (Int j = 1; j < 8; j++) table[j][i] = table[0][table[j - 1][i] & 0xFF] ^ (table[j - 1][i] >> 8);
	}

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw $0x8005, -0x2(%rbp)     # imm = 0x8005
movl $0x0, -0x8(%rbp)
cmpl $0xff, -0x8(%rbp)
jg 0xfd7d5
movl -0x8(%rbp), %eax
movl $0x8, %esi
movzwl %ax, %edi
callq 0x59250
movzwl %ax, %eax
shll $0x8, %eax
movw %ax, -0xa(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x8, -0x10(%rbp)
jge 0xfd7a7
movzwl -0xa(%rbp), %eax
shll %eax
movl %eax, -0x1c(%rbp)
movzwl -0xa(%rbp), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0xfd789
movzwl -0x2(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0xfd790
xorl %eax, %eax
movl %eax, -0x20(%rbp)
jmp 0xfd790
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
xorl %ecx, %eax
movw %ax, -0xa(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xfd763
movl $0x10, %esi
movzwl -0xa(%rbp), %edi
callq 0x59250
movw %ax, %dx
movslq -0x8(%rbp), %rcx
movq 0x10b665(%rip), %rax    # 0x208e28
movw %dx, (%rax,%rcx,2)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xfd735
movl $0x0, -0x14(%rbp)
cmpl $0xff, -0x14(%rbp)
jg 0xfd88b
movl $0x1, -0x18(%rbp)
cmpl $0x8, -0x18(%rbp)
jge 0xfd87b
movl -0x18(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
movq 0x10b61e(%rip), %rax    # 0x208e28
shlq $0x9, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0xff, %eax
movslq %eax, %rcx
movq 0x10b600(%rip), %rax    # 0x208e28
movzwl (%rax,%rcx,2), %eax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rdx
movq 0x10b5ec(%rip), %rcx    # 0x208e28
shlq $0x9, %rdx
addq %rdx, %rcx
movslq -0x14(%rbp), %rdx
movzwl (%rcx,%rdx,2), %ecx
sarl $0x8, %ecx
xorl %ecx, %eax
movw %ax, %dx
movslq -0x18(%rbp), %rcx
movq 0x10b5ca(%rip), %rax    # 0x208e28
shlq $0x9, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xfd7f0
jmp 0xfd87d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xfd7dc
movb $0x1, %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/misc/hash/crc16.cpp
// Function: smooth::Hash::CRC16::Reflect(unsigned short, char)
S::UnsignedInt16 S::Hash::CRC16::Reflect(UnsignedInt16 ref, char ch)
{
	UnsignedInt16	 value(0);

	for (Int i = 1; i < (ch + 1); i++)
	{
		if (ref & 1) value |= 1 << (ch - i);

		ref >>= 1;
	}

	return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movw %di, %cx
movw %cx, -0x2(%rbp)
movb %al, -0x3(%rbp)
movw $0x0, -0x6(%rbp)
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
movsbl -0x3(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0xfd957
movzwl -0x2(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xfd942
movsbl -0x3(%rbp), %ecx
subl -0xc(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
movzwl -0x6(%rbp), %eax
orl %ecx, %eax
movw %ax, -0x6(%rbp)
movzwl -0x2(%rbp), %eax
sarl %eax
movw %ax, -0x2(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xfd90e
movw -0x6(%rbp), %ax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/misc/hash/crc16.cpp
// Function: smooth::Hash::CRC16::Feed(unsigned char const*, int)
S::Bool S::Hash::CRC16::Feed(const UnsignedByte *data, Int size)
{
	while (size >= 8)
	{
		crc  ^= data[1] << 8 | data[0];

		crc   =	table[7][crc & 0xFF] ^ table[6][crc >> 8] ^
			table[5][data[2]   ] ^ table[4][data[3]	] ^
			table[3][data[4]   ] ^ table[2][data[5]	] ^
			table[1][data[6]   ] ^ table[0][data[7]	];

		data += 8;
		size -= 8;
	}

	while (size--) crc = (crc >> 8) ^ table[0][(crc & 0xFF) ^ *data++];

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x8, -0x14(%rbp)
jl 0xfda91
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %edx
shll $0x8, %edx
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
orl %ecx, %edx
movzwl (%rax), %ecx
xorl %edx, %ecx
movw %cx, (%rax)
movzwl (%rax), %ecx
andl $0xff, %ecx
movslq %ecx, %rdx
movq 0x10b474(%rip), %rcx    # 0x208e28
movzwl 0xe00(%rcx,%rdx,2), %ecx
movzwl (%rax), %edx
sarl $0x8, %edx
movslq %edx, %rsi
movq 0x10b45c(%rip), %rdx    # 0x208e28
movzwl 0xc00(%rdx,%rsi,2), %edx
xorl %edx, %ecx
movq -0x10(%rbp), %rdx
movzbl 0x2(%rdx), %edx
movl %edx, %esi
movq 0x10b441(%rip), %rdx    # 0x208e28
movzwl 0xa00(%rdx,%rsi,2), %edx
xorl %edx, %ecx
movq -0x10(%rbp), %rdx
movzbl 0x3(%rdx), %edx
movl %edx, %esi
movq 0x10b426(%rip), %rdx    # 0x208e28
movzwl 0x800(%rdx,%rsi,2), %edx
xorl %edx, %ecx
movq -0x10(%rbp), %rdx
movzbl 0x4(%rdx), %edx
movl %edx, %esi
movq 0x10b40b(%rip), %rdx    # 0x208e28
movzwl 0x600(%rdx,%rsi,2), %edx
xorl %edx, %ecx
movq -0x10(%rbp), %rdx
movzbl 0x5(%rdx), %edx
movl %edx, %esi
movq 0x10b3f0(%rip), %rdx    # 0x208e28
movzwl 0x400(%rdx,%rsi,2), %edx
xorl %edx, %ecx
movq -0x10(%rbp), %rdx
movzbl 0x6(%rdx), %edx
movl %edx, %esi
movq 0x10b3d5(%rip), %rdx    # 0x208e28
movzwl 0x200(%rdx,%rsi,2), %edx
xorl %edx, %ecx
movq -0x10(%rbp), %rdx
movzbl 0x7(%rdx), %edx
movl %edx, %esi
movq 0x10b3ba(%rip), %rdx    # 0x208e28
movzwl (%rdx,%rsi,2), %edx
xorl %edx, %ecx
movw %cx, (%rax)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
subl $0x8, %eax
movl %eax, -0x14(%rbp)
jmp 0xfd977
jmp 0xfda93
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
je 0xfdadf
movq -0x20(%rbp), %rax
movzwl (%rax), %ecx
sarl $0x8, %ecx
movzwl (%rax), %edx
andl $0xff, %edx
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
addq $0x1, %rdi
movq %rdi, -0x10(%rbp)
movzbl (%rsi), %esi
xorl %esi, %edx
movslq %edx, %rsi
movq 0x10b354(%rip), %rdx    # 0x208e28
movzwl (%rdx,%rsi,2), %edx
xorl %edx, %ecx
movw %cx, (%rax)
jmp 0xfda93
movb $0x1, %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/misc/hash/crc32.cpp
// Function: smooth::Hash::CRC32::InitTable()
S::Bool S::Hash::CRC32::InitTable()
{
	UnsignedInt32	 polynomial = 0x04C11DB7;

	for (Int i = 0; i <= 0xFF; i++)
	{
		UnsignedInt32	 value = Reflect(i, 8) << 24;

		for (Int j = 0; j < 8; j++) value = (value << 1) ^ (value & (1 << 31) ? polynomial : 0);

		table[0][i] = Reflect(value, 32);
	}

	for (Int i = 0; i <= 0xFF; i++)
	{
		for (Int j = 1; j < 8; j++) table[j][i] = table[0][table[j - 1][i] & 0xFF] ^ (table[j - 1][i] >> 8);
	}

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x4c11db7, -0x4(%rbp)  # imm = 0x4C11DB7
movl $0x0, -0x8(%rbp)
cmpl $0xff, -0x8(%rbp)
jg 0xfdc98
movl -0x8(%rbp), %edi
movl $0x8, %esi
callq 0x5d260
shll $0x18, %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x8, -0x10(%rbp)
jge 0xfdc6d
movl -0xc(%rbp), %eax
shll %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
andl $0x80000000, %eax       # imm = 0x80000000
cmpl $0x0, %eax
je 0xfdc50
movl -0x4(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0xfdc57
xorl %eax, %eax
movl %eax, -0x20(%rbp)
jmp 0xfdc57
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
xorl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xfdc2d
movl -0xc(%rbp), %edi
movl $0x20, %esi
callq 0x5d260
movl %eax, %edx
movslq -0x8(%rbp), %rcx
movq 0x10a781(%rip), %rax    # 0x208408
movl %edx, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xfdc06
movl $0x0, -0x14(%rbp)
cmpl $0xff, -0x14(%rbp)
jg 0xfdd41
movl $0x1, -0x18(%rbp)
cmpl $0x8, -0x18(%rbp)
jge 0xfdd31
movl -0x18(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
movq 0x10a73f(%rip), %rax    # 0x208408
shlq $0xa, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
andl $0xff, %eax
movl %eax, %eax
movl %eax, %ecx
movq 0x10a721(%rip), %rax    # 0x208408
movl (%rax,%rcx,4), %edx
movl -0x18(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
movq 0x10a70e(%rip), %rax    # 0x208408
shlq $0xa, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
shrl $0x8, %eax
xorl %eax, %edx
movslq -0x18(%rbp), %rcx
movq 0x10a6f0(%rip), %rax    # 0x208408
shlq $0xa, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xfdcb3
jmp 0xfdd33
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xfdc9f
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/misc/hash/crc32.cpp
// Function: smooth::Hash::CRC32::Reflect(unsigned int, char)
S::UnsignedInt32 S::Hash::CRC32::Reflect(UnsignedInt32 ref, char ch)
{
	UnsignedInt32	 value(0);

	for (Int i = 1; i < (ch + 1); i++)
	{
		if (ref & 1) value |= 1 << (ch - i);

		ref >>= 1;
	}

	return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movl %edi, -0x4(%rbp)
movb %al, -0x5(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
movsbl -0x5(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0xfddfb
movl -0x4(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xfdde8
movsbl -0x5(%rbp), %ecx
subl -0x10(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
shrl %eax
movl %eax, -0x4(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xfddbb
movl -0xc(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/misc/hash/crc32.cpp
// Function: smooth::Hash::CRC32::Feed(unsigned char const*, int)
S::Bool S::Hash::CRC32::Feed(const UnsignedByte *data, Int size)
{
	while (size >= 8)
	{
		crc  ^= data[3] << 24 | data[2] << 16 | data[1] << 8 | data[0];

		crc   =	table[7][ crc	     & 0xFF] ^ table[6][(crc >>  8) & 0xFF] ^
			table[5][(crc >> 16) & 0xFF] ^ table[4][ crc >> 24	  ] ^
			table[3][data[4]	   ] ^ table[2][data[5]		  ] ^
			table[1][data[6]	   ] ^ table[0][data[7]		  ];

		data += 8;
		size -= 8;
	}

	while (size--) crc = (crc >> 8) ^ table[0][(crc & 0xFF) ^ *data++];

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x8, -0x14(%rbp)
jl 0xfdf3a
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
shll $0x18, %ecx
movq -0x10(%rbp), %rdx
movzbl 0x2(%rdx), %edx
shll $0x10, %edx
orl %edx, %ecx
movq -0x10(%rbp), %rdx
movzbl 0x1(%rdx), %edx
shll $0x8, %edx
orl %edx, %ecx
movq -0x10(%rbp), %rdx
movzbl (%rdx), %edx
orl %edx, %ecx
xorl (%rax), %ecx
movl %ecx, (%rax)
movl (%rax), %ecx
andl $0xff, %ecx
movl %ecx, %ecx
movl %ecx, %edx
movq 0x10a59e(%rip), %rcx    # 0x208408
movl 0x1c00(%rcx,%rdx,4), %ecx
movl (%rax), %edx
shrl $0x8, %edx
andl $0xff, %edx
movl %edx, %edx
movl %edx, %esi
movq 0x10a581(%rip), %rdx    # 0x208408
xorl 0x1800(%rdx,%rsi,4), %ecx
movl (%rax), %edx
shrl $0x10, %edx
andl $0xff, %edx
movl %edx, %edx
movl %edx, %esi
movq 0x10a564(%rip), %rdx    # 0x208408
xorl 0x1400(%rdx,%rsi,4), %ecx
movl (%rax), %edx
shrl $0x18, %edx
movl %edx, %edx
movl %edx, %esi
movq 0x10a54d(%rip), %rdx    # 0x208408
xorl 0x1000(%rdx,%rsi,4), %ecx
movq -0x10(%rbp), %rdx
movzbl 0x4(%rdx), %edx
movl %edx, %esi
movq 0x10a535(%rip), %rdx    # 0x208408
xorl 0xc00(%rdx,%rsi,4), %ecx
movq -0x10(%rbp), %rdx
movzbl 0x5(%rdx), %edx
movl %edx, %esi
movq 0x10a51d(%rip), %rdx    # 0x208408
xorl 0x800(%rdx,%rsi,4), %ecx
movq -0x10(%rbp), %rdx
movzbl 0x6(%rdx), %edx
movl %edx, %esi
movq 0x10a505(%rip), %rdx    # 0x208408
xorl 0x400(%rdx,%rsi,4), %ecx
movq -0x10(%rbp), %rdx
movzbl 0x7(%rdx), %edx
movl %edx, %esi
movq 0x10a4ed(%rip), %rdx    # 0x208408
xorl (%rdx,%rsi,4), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
subl $0x8, %eax
movl %eax, -0x14(%rbp)
jmp 0xfde17
jmp 0xfdf3c
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
je 0xfdf83
movq -0x20(%rbp), %rax
movl (%rax), %ecx
shrl $0x8, %ecx
movl (%rax), %edx
andl $0xff, %edx
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
addq $0x1, %rdi
movq %rdi, -0x10(%rbp)
movzbl (%rsi), %esi
xorl %esi, %edx
movl %edx, %edx
movl %edx, %esi
movq 0x10a48c(%rip), %rdx    # 0x208408
xorl (%rdx,%rsi,4), %ecx
movl %ecx, (%rax)
jmp 0xfdf3c
movb $0x1, %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/misc/hash/crc64.cpp
// Function: smooth::Hash::CRC64::InitTable()
S::Bool S::Hash::CRC64::InitTable()
{
	UnsignedInt64	 polynomial = 0x95AC9329AC4BC9B5ULL;

	for (Int i = 0; i <= 0xFF; i++)
	{
		UnsignedInt64	 value = i;

		for (Int j = 0; j < 8; j++) value = (value >> 1) ^ (value & 1 ? polynomial : 0);

		table[0][i] = value;
	}

	for (Int i = 0; i <= 0xFF; i++)
	{
		for (Int j = 1; j < 8; j++) table[j][i] = table[0][table[j - 1][i] & 0xFF] ^ (table[j - 1][i] >> 8);
	}

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movabsq $-0x6a536cd653b4364b, %rax # imm = 0x95AC9329AC4BC9B5
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0xff, -0xc(%rbp)
jg 0xfe12d
movslq -0xc(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jge 0xfe10c
movq -0x18(%rbp), %rax
shrq %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xfe0ea
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0xfe0f2
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0xfe0f2
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
xorq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xfe0c1
movq -0x18(%rbp), %rdx
movslq -0xc(%rbp), %rcx
movq 0x10a48d(%rip), %rax    # 0x2085a8
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xfe0a9
movl $0x0, -0x20(%rbp)
cmpl $0xff, -0x20(%rbp)
jg 0xfe1dd
movl $0x1, -0x24(%rbp)
cmpl $0x8, -0x24(%rbp)
jge 0xfe1cd
movl -0x24(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
movq 0x10a44a(%rip), %rax    # 0x2085a8
shlq $0xb, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
andq $0xff, %rcx
movq 0x10a42d(%rip), %rax    # 0x2085a8
movq (%rax,%rcx,8), %rdx
movl -0x24(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
movq 0x10a419(%rip), %rax    # 0x2085a8
shlq $0xb, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
shrq $0x8, %rax
xorq %rax, %rdx
movslq -0x24(%rbp), %rcx
movq 0x10a3f8(%rip), %rax    # 0x2085a8
shlq $0xb, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xfe148
jmp 0xfe1cf
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xfe134
movb $0x1, %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/misc/hash/crc64.cpp
// Function: smooth::Hash::CRC64::Feed(unsigned char const*, int)
S::Bool S::Hash::CRC64::Feed(const UnsignedByte *data, Int size)
{
	while (size >= 8)
	{
		crc   =	table[7][data[0] ^ ( crc	& 0xFF)] ^ table[6][data[1] ^ ((crc >>  8) & 0xFF)] ^
			table[5][data[2] ^ ((crc >> 16) & 0xFF)] ^ table[4][data[3] ^ ((crc >> 24) & 0xFF)] ^
			table[3][data[4] ^ ((crc >> 32) & 0xFF)] ^ table[2][data[5] ^ ((crc >> 40) & 0xFF)] ^
			table[1][data[6] ^ ((crc >> 48) & 0xFF)] ^ table[0][data[7] ^  (crc >> 56)	  ];

		data += 8;
		size -= 8;
	}

	while (size--) crc = (crc >> 8) ^ table[0][(crc & 0xFF) ^ *data++];

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x8, -0x14(%rbp)
jl 0xfe3c2
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movl %ecx, %edx
movq (%rax), %rcx
andq $0xff, %rcx
xorq %rcx, %rdx
movq 0x10a326(%rip), %rcx    # 0x2085a8
movq 0x3800(%rcx,%rdx,8), %rcx
movq -0x10(%rbp), %rdx
movzbl 0x1(%rdx), %edx
movl %edx, %esi
movq (%rax), %rdx
shrq $0x8, %rdx
andq $0xff, %rdx
xorq %rdx, %rsi
movq 0x10a2fc(%rip), %rdx    # 0x2085a8
xorq 0x3000(%rdx,%rsi,8), %rcx
movq -0x10(%rbp), %rdx
movzbl 0x2(%rdx), %edx
movl %edx, %esi
movq (%rax), %rdx
shrq $0x10, %rdx
andq $0xff, %rdx
xorq %rdx, %rsi
movq 0x10a2d2(%rip), %rdx    # 0x2085a8
xorq 0x2800(%rdx,%rsi,8), %rcx
movq -0x10(%rbp), %rdx
movzbl 0x3(%rdx), %edx
movl %edx, %esi
movq (%rax), %rdx
shrq $0x18, %rdx
andq $0xff, %rdx
xorq %rdx, %rsi
movq 0x10a2a8(%rip), %rdx    # 0x2085a8
xorq 0x2000(%rdx,%rsi,8), %rcx
movq -0x10(%rbp), %rdx
movzbl 0x4(%rdx), %edx
movl %edx, %esi
movq (%rax), %rdx
shrq $0x20, %rdx
andq $0xff, %rdx
xorq %rdx, %rsi
movq 0x10a27e(%rip), %rdx    # 0x2085a8
xorq 0x1800(%rdx,%rsi,8), %rcx
movq -0x10(%rbp), %rdx
movzbl 0x5(%rdx), %edx
movl %edx, %esi
movq (%rax), %rdx
shrq $0x28, %rdx
andq $0xff, %rdx
xorq %rdx, %rsi
movq 0x10a254(%rip), %rdx    # 0x2085a8
xorq 0x1000(%rdx,%rsi,8), %rcx
movq -0x10(%rbp), %rdx
movzbl 0x6(%rdx), %edx
movl %edx, %esi
movq (%rax), %rdx
shrq $0x30, %rdx
andq $0xff, %rdx
xorq %rdx, %rsi
movq 0x10a22a(%rip), %rdx    # 0x2085a8
xorq 0x800(%rdx,%rsi,8), %rcx
movq -0x10(%rbp), %rdx
movzbl 0x7(%rdx), %edx
movl %edx, %esi
movq (%rax), %rdx
shrq $0x38, %rdx
xorq %rdx, %rsi
movq 0x10a207(%rip), %rdx    # 0x2085a8
xorq (%rdx,%rsi,8), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
subl $0x8, %eax
movl %eax, -0x14(%rbp)
jmp 0xfe257
jmp 0xfe3c4
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
je 0xfe40e
movq -0x20(%rbp), %rax
movq (%rax), %rcx
shrq $0x8, %rcx
movq (%rax), %rsi
andq $0xff, %rsi
movq -0x10(%rbp), %rdx
movq %rdx, %rdi
addq $0x1, %rdi
movq %rdi, -0x10(%rbp)
movzbl (%rdx), %edx
xorq %rdx, %rsi
movq 0x10a1a3(%rip), %rdx    # 0x2085a8
xorq (%rdx,%rsi,8), %rcx
movq %rcx, (%rax)
jmp 0xfe3c4
movb $0x1, %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/misc/hash/md5.cpp
// Function: smooth::Hash::MD5::Reset()
S::Bool S::Hash::MD5::Reset()
{
	/* Load magic initialization constants.
	 */
	state[0] = 0x67452301;
	state[1] = 0xefcdab89;
	state[2] = 0x98badcfe;
	state[3] = 0x10325476;

	size = 0;

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x67452301, (%rax)     # imm = 0x67452301
movl $0xefcdab89, 0x4(%rax)  # imm = 0xEFCDAB89
movl $0x98badcfe, 0x8(%rax)  # imm = 0x98BADCFE
movl $0x10325476, 0xc(%rax)  # imm = 0x10325476
movq $0x0, 0x10(%rax)
movb $0x1, %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/misc/hash/md5.cpp
// Function: smooth::Hash::MD5::Feed(unsigned char const*, int)
S::Bool S::Hash::MD5::Feed(const UnsignedByte *data, Int size)
{
	buffer.Resize(buffer.Size() + size);

	memcpy(buffer + buffer.Size() - size, data, size);

	for (Int i = 0; i + 63 < buffer.Size(); i += 64) Transform(buffer + i);

	memcpy(buffer, buffer + buffer.Size() - buffer.Size() % 64, buffer.Size() % 64);

	buffer.Resize(buffer.Size() % 64);

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0x30(%rbp)
addq $0x18, %rdi
callq 0x71140
movq -0x30(%rbp), %rdi
movl %eax, %esi
addl -0x14(%rbp), %esi
callq 0x72e00
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
callq 0x71100
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x18, %rdi
callq 0x71140
movq -0x20(%rbp), %rdi
cltq
addq %rax, %rdi
movslq -0x14(%rbp), %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x593a0
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %eax
addl $0x3f, %eax
movl %eax, -0x34(%rbp)
addq $0x18, %rdi
callq 0x71140
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jge 0x10008e
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
callq 0x71100
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movslq -0x18(%rbp), %rax
addq %rax, %rsi
callq 0x5abd0
movl -0x18(%rbp), %eax
addl $0x40, %eax
movl %eax, -0x18(%rbp)
jmp 0x100044
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
callq 0x71100
movq -0x28(%rbp), %rdi
movq %rax, -0x50(%rbp)
addq $0x18, %rdi
callq 0x71100
movq -0x28(%rbp), %rdi
movq %rax, -0x60(%rbp)
addq $0x18, %rdi
callq 0x71140
movq -0x28(%rbp), %rdi
movl %eax, %ecx
movq -0x60(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
addq $0x18, %rdi
callq 0x71140
movq -0x28(%rbp), %rdi
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x58(%rbp), %rax
movslq %edx, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
addq $0x18, %rdi
callq 0x71140
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl $0x40, %ecx
cltd
idivl %ecx
movslq %edx, %rdx
callq 0x593a0
movq -0x28(%rbp), %rdi
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0x40(%rbp)
addq $0x18, %rdi
callq 0x71140
movq -0x40(%rbp), %rdi
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %esi
callq 0x72e00
movb $0x1, %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/misc/hash/sha1.cpp
// Function: smooth::Hash::SHA1::Reset()
S::Bool S::Hash::SHA1::Reset()
{
	/* Load magic initialization constants.
	 */
	state[0] = 0x67452301;
	state[1] = 0xefcdab89;
	state[2] = 0x98badcfe;
	state[3] = 0x10325476;
	state[4] = 0xc3d2e1f0;

	size = 0;

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x67452301, (%rax)     # imm = 0x67452301
movl $0xefcdab89, 0x4(%rax)  # imm = 0xEFCDAB89
movl $0x98badcfe, 0x8(%rax)  # imm = 0x98BADCFE
movl $0x10325476, 0xc(%rax)  # imm = 0x10325476
movl $0xc3d2e1f0, 0x10(%rax) # imm = 0xC3D2E1F0
movq $0x0, 0x18(%rax)
movb $0x1, %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/net/protocols/http.cpp
// Function: smooth::Net::Protocols::HTTP::HTTP(smooth::String const&)
S::Net::Protocols::HTTP::HTTP(const String &iURL) : Protocol(iURL)
{
	mode	  = HTTP_METHOD_GET;

	proxyMode = HTTP_PROXY_NONE;
	proxyPort = 0;

	out	  = NIL;

	ulStart	  = 0;
	dlStart	  = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0x5a6d0
movq -0x30(%rbp), %rdi
movq 0x106dcc(%rip), %rax    # 0x208548
addq $0x10, %rax
movq %rax, (%rdi)
addq $0xd0, %rdi
movq %rdi, -0x28(%rbp)
xorl %esi, %esi
callq 0x5da90
jmp 0x101797
movq -0x30(%rbp), %rdi
addq $0xf0, %rdi
movq %rdi, -0x38(%rbp)
xorl %esi, %esi
callq 0x5da90
jmp 0x1017af
movq -0x30(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
movq %rdi, -0x40(%rbp)
xorl %esi, %esi
callq 0x5da90
jmp 0x1017c7
movq -0x30(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
movq %rdi, -0x48(%rbp)
callq 0x104800
jmp 0x1017dd
movq -0x30(%rbp), %rdi
addq $0x178, %rdi            # imm = 0x178
movq %rdi, -0x50(%rbp)
callq 0x104800
jmp 0x1017f3
movq -0x30(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
movq %rdi, -0x58(%rbp)
callq 0x70fc0
jmp 0x101809
movq -0x30(%rbp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
movq %rdi, -0x60(%rbp)
callq 0x104800
jmp 0x10181f
movq -0x30(%rbp), %rdi
addq $0x240, %rdi            # imm = 0x240
movq %rdi, -0x68(%rbp)
xorl %esi, %esi
callq 0x5da90
jmp 0x101837
movq -0x30(%rbp), %rdi
addq $0x270, %rdi            # imm = 0x270
xorl %esi, %esi
callq 0x5da90
jmp 0x10184b
movq -0x30(%rbp), %rax
movw $0x0, 0xc8(%rax)
movw $0x0, 0xec(%rax)
movl $0x0, 0xe8(%rax)
movq $0x0, 0x258(%rax)
movq $0x0, 0x260(%rax)
movq $0x0, 0x268(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x10195f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x101956
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x10194d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x101944
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x10193b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x101932
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x101929
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x101920
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x5df00
movq -0x60(%rbp), %rdi
callq 0x104840
movq -0x58(%rbp), %rdi
callq 0x71000
movq -0x50(%rbp), %rdi
callq 0x104840
movq -0x48(%rbp), %rdi
callq 0x104840
movq -0x40(%rbp), %rdi
callq 0x5df00
movq -0x38(%rbp), %rdi
callq 0x5df00
movq -0x28(%rbp), %rdi
callq 0x5df00
movq -0x30(%rbp), %rdi
callq 0x59c90
movq -0x18(%rbp), %rdi
callq 0x5b6b0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/net/protocols/http.cpp
// Function: smooth::Net::Protocols::HTTP::SetHeaderField(smooth::String const&, smooth::String const&)
S::Int S::Net::Protocols::HTTP::SetHeaderField(const String &key, const String &value)
{
	Parameter	 field;

	field.key	= key;
	field.value	= value;

	requestFields.Add(field);

	return Success();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x5b6f0
movq -0x78(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x59760
jmp 0x101aab
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x59760
jmp 0x101aba
movq -0x80(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
leaq -0x50(%rbp), %rsi
callq 0x1048d0
jmp 0x101ad0
leaq -0x70(%rbp), %rdi
callq 0x5ca80
jmp 0x101adb
leaq -0x70(%rbp), %rdi
callq 0x59680
movl %eax, -0x84(%rbp)
jmp 0x101aec
leaq -0x70(%rbp), %rdi
callq 0x5a410
leaq -0x50(%rbp), %rdi
callq 0x5de58
movl -0x84(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x101b30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x5a410
leaq -0x50(%rbp), %rdi
callq 0x5de58
movq -0x58(%rbp), %rdi
callq 0x5b6b0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/net/protocols/http.cpp
// Function: smooth::Net::Protocols::HTTP::SetParameter(smooth::String const&, smooth::String const&)
S::Int S::Net::Protocols::HTTP::SetParameter(const String &key, const String &value)
{
	Parameter	 parameter;

	parameter.key	= key;
	parameter.value	= value;

	requestParameters.Add(parameter);

	return Success();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x5b6f0
movq -0x78(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x59760
jmp 0x101c8b
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x59760
jmp 0x101c9a
movq -0x80(%rbp), %rdi
addq $0x178, %rdi            # imm = 0x178
leaq -0x50(%rbp), %rsi
callq 0x1048d0
jmp 0x101cb0
leaq -0x70(%rbp), %rdi
callq 0x5ca80
jmp 0x101cbb
leaq -0x70(%rbp), %rdi
callq 0x59680
movl %eax, -0x84(%rbp)
jmp 0x101ccc
leaq -0x70(%rbp), %rdi
callq 0x5a410
leaq -0x50(%rbp), %rdi
callq 0x5de58
movl -0x84(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x101d10
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x5a410
leaq -0x50(%rbp), %rdi
callq 0x5de58
movq -0x58(%rbp), %rdi
callq 0x5b6b0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/net/protocols/http.cpp
// Function: smooth::Net::Protocols::HTTP::SetParameterFile(smooth::String const&, smooth::String const&)
S::Int S::Net::Protocols::HTTP::SetParameterFile(const String &key, const String &fileName)
{
	if (!S::File(fileName).Exists()) return Error();

	Parameter	 parameter;

	parameter.key	= key;
	parameter.value	= fileName;

	parameter.isFile= True;

	requestParameters.Add(parameter);

	return Success();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
xorl %esi, %esi
callq 0x5da90
movq -0xe0(%rbp), %rsi
movq -0xd8(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x5acf0
jmp 0x101d88
leaq -0x50(%rbp), %rdi
callq 0x5b4b0
movb %al, -0xe9(%rbp)
jmp 0x101d99
movb -0xe9(%rbp), %al
xorb $-0x1, %al
movb %al, -0xea(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5de78
leaq -0x68(%rbp), %rdi
callq 0x5df00
movb -0xea(%rbp), %al
testb $0x1, %al
jne 0x101dc8
jmp 0x101e5c
leaq -0x88(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5a9c0
movq -0xf8(%rbp), %rdi
callq 0x59680
movl %eax, -0xf0(%rbp)
jmp 0x101df4
movl -0xf0(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x5b5b0
jmp 0x101f2f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x101e31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5de78
leaq -0x68(%rbp), %rdi
callq 0x5df00
jmp 0x101f3b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x5b5b0
jmp 0x101f3b
leaq -0xc0(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x5b6f0
movq -0x100(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x59760
jmp 0x101e81
movq -0x20(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x59760
jmp 0x101e93
movq -0xe8(%rbp), %rdi
movb $0x1, -0x90(%rbp)
addq $0x178, %rdi            # imm = 0x178
leaq -0xc0(%rbp), %rsi
callq 0x1048d0
jmp 0x101eb6
leaq -0xd0(%rbp), %rdi
callq 0x5ca80
jmp 0x101ec4
leaq -0xd0(%rbp), %rdi
callq 0x59680
movl %eax, -0x104(%rbp)
jmp 0x101ed8
movl -0x104(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x5a410
leaq -0xc0(%rbp), %rdi
callq 0x5de58
jmp 0x101f2f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x101f21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x5a410
leaq -0xc0(%rbp), %rdi
callq 0x5de58
jmp 0x101f3b
movl -0x4(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x5b6b0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/net/protocols/http.cpp
// Function: smooth::Net::Protocols::HTTP::SetProxy(smooth::String const&, int)
S::Int S::Net::Protocols::HTTP::SetProxy(const String &nProxy, Int nProxyPort)
{
	proxy	  = nProxy;
	proxyPort = nProxyPort;

	if (proxyMode == HTTP_PROXY_NONE) proxyMode = HTTP_PROXY_HTTP;

	return Success();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq -0x10(%rbp), %rsi
addq $0xd0, %rdi
callq 0x59760
movq -0x40(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0xe8(%rax)
movswl 0xec(%rax), %eax
cmpl $0x0, %eax
jne 0x102081
movq -0x40(%rbp), %rax
movw $0x1, 0xec(%rax)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x5ca80
movq -0x50(%rbp), %rdi
callq 0x59680
movl %eax, -0x44(%rbp)
jmp 0x10209c
leaq -0x28(%rbp), %rdi
callq 0x5a410
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5a410
movq -0x30(%rbp), %rdi
callq 0x5b6b0
nopl (%rax)