LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, 0x10(%rsp)
movq %rdi, %r14
movq %rsi, 0x28(%rsp)
cmpl $0x0, 0x10(%rsi)
je 0xa683a
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rbx
cmpl $0x0, (%rbx)
je 0xa683a
movq $0x0, 0x8(%rsp)
cmpl $0x0, 0x10(%r14)
movl $0x0, %r13d
je 0xa66c4
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xa66ba
movq (%rax), %rdi
jmp 0xa66bc
xorl %edi, %edi
callq 0x57220
movq %rax, %r13
movq %rbx, %rdi
callq 0x57220
movq %rax, %rbp
movq 0x10(%rsp), %rax
cmpl $0x0, 0x10(%rax)
je 0xa66f9
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xa66ed
movq (%rax), %rdi
jmp 0xa66ef
xorl %edi, %edi
callq 0x57220
movq %rax, 0x8(%rsp)
cmpl %ebp, %r13d
jl 0xa683a
movslq %ebp, %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rax
movl %eax, %ecx
subl %ebp, %ecx
movq %rcx, 0x48(%rsp)
incl %ecx
movq %rcx, 0x38(%rsp)
cltq
leaq (,%rax,4), %rcx
movq %rcx, 0x30(%rsp)
movl %eax, %ecx
movq %rcx, 0x50(%rsp)
movq %rax, 0x40(%rsp)
decl %eax
movl %eax, 0x1c(%rsp)
xorl %r12d, %r12d
movq 0x8(%r14), %rbx
testq %rbx, %rbx
je 0xa6751
movq (%rbx), %rax
jmp 0xa6753
xorl %eax, %eax
movq 0x28(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0xa6766
movq (%rcx), %rsi
jmp 0xa6768
xorl %esi, %esi
movslq %r12d, %r15
leaq (%rax,%r15,4), %rdi
movq 0x20(%rsp), %rdx
callq 0x572f0
testl %eax, %eax
jne 0xa6824
cmpl %ebp, 0x8(%rsp)
je 0xa67e5
jle 0xa679e
movq 0x38(%rsp), %rax
leal (%rax,%r13), %esi
movq %r14, %rdi
callq 0xa7094
movq 0x8(%r14), %rbx
testq %rbx, %rbx
je 0xa67b5
movq (%rbx), %rax
leaq (%rax,%r15,4), %rcx
movq 0x40(%rsp), %rdx
leaq (%rcx,%rdx,4), %rdi
jmp 0xa67c0
movq 0x30(%rsp), %rax
leaq (%rax,%r15,4), %rdi
xorl %eax, %eax
leaq (%rax,%r15,4), %rax
movq 0x20(%rsp), %rcx
leaq (%rax,%rcx,4), %rsi
leal (%r15,%rbp), %eax
negl %eax
addl %r13d, %eax
incl %eax
movslq %eax, %rdx
callq 0x56c80
addl 0x48(%rsp), %r13d
cmpl $0x0, 0x8(%rsp)
jle 0xa681f
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xa67fa
movq (%rax), %rax
jmp 0xa67fc
xorl %eax, %eax
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0xa680f
movq (%rcx), %rsi
jmp 0xa6811
xorl %esi, %esi
leaq (%rax,%r15,4), %rdi
movq 0x50(%rsp), %rdx
callq 0x58ce0
addl 0x1c(%rsp), %r12d
leal 0x1(%r12), %eax
movl %r13d, %ecx
subl %ebp, %ecx
cmpl %ecx, %r12d
movl %eax, %r12d
jl 0xa6743
movq %r14, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
xorl %esi, %esi
callq 0xa7094
testl %r14d, %r14d
jle 0xa6914
leal 0x1(%r14), %esi
movq %rbx, %rdi
callq 0xa7094
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xa68e8
movq (%rax), %rdi
jmp 0xa68ea
xorl %edi, %edi
movq 0x8(%r15), %rax
testq %rax, %rax
je 0xa68f8
movq (%rax), %rsi
jmp 0xa68fa
xorl %esi, %esi
movl %r14d, %r14d
movq %r14, %rdx
callq 0x58ce0
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl $0x0, (%rax,%r14,4)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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:
testl %edx, %edx
je 0xa6951
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x0, 0x10(%rdi)
je 0xa6954
movq 0x8(%r15), %rax
testq %rax, %rax
je 0xa6958
movq (%rax), %rdi
jmp 0xa695a
xorl %eax, %eax
retq
xorl %ecx, %ecx
jmp 0xa6962
xorl %edi, %edi
callq 0x57220
movq %rax, %rcx
movl $0x1, %eax
cmpl %ebx, %ecx
jl 0xa699c
movq 0x8(%r15), %rax
testq %rax, %rax
je 0xa6979
movq (%rax), %rdi
jmp 0xa697b
xorl %edi, %edi
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xa6989
movq (%rax), %rsi
jmp 0xa698b
xorl %esi, %esi
movslq %ebx, %rdx
callq 0x572f0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movb $0x1, %al
cmpl $0x0, 0x10(%rsi)
je 0xa6a17
pushq %r15
pushq %r14
pushq %rbx
movq 0x8(%rsi), %rcx
movq (%rcx), %rbx
cmpl $0x0, (%rbx)
je 0xa6a12
movq %rdi, %r14
cmpl $0x0, 0x10(%rdi)
je 0xa69d2
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xa69d7
movq (%rax), %rdi
jmp 0xa69d9
xorl %r15d, %r15d
jmp 0xa69e1
xorl %edi, %edi
callq 0x57220
movq %rax, %r15
movq %rbx, %rdi
callq 0x57220
cmpl %eax, %r15d
jge 0xa69f2
xorl %eax, %eax
jmp 0xa6a12
movq 0x8(%r14), %rcx
testq %rcx, %rcx
je 0xa6a00
movq (%rcx), %rdi
jmp 0xa6a02
xorl %edi, %edi
movslq %eax, %rdx
movq %rbx, %rsi
callq 0x572f0
testl %eax, %eax
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movb $0x1, %al
cmpl $0x0, 0x10(%rsi)
je 0xa6a9f
pushq %r15
pushq %r14
pushq %rbx
movq 0x8(%rsi), %rcx
movq (%rcx), %rbx
cmpl $0x0, (%rbx)
je 0xa6a9a
movq %rdi, %r14
cmpl $0x0, 0x10(%rdi)
je 0xa6a48
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xa6a4d
movq (%rax), %rdi
jmp 0xa6a4f
xorl %r15d, %r15d
jmp 0xa6a57
xorl %edi, %edi
callq 0x57220
movq %rax, %r15
movq %rbx, %rdi
callq 0x57220
cmpl %eax, %r15d
jge 0xa6a68
xorl %eax, %eax
jmp 0xa6a9a
movq 0x8(%r14), %rcx
testq %rcx, %rcx
je 0xa6a76
movq (%rcx), %rcx
jmp 0xa6a78
xorl %ecx, %ecx
movslq %r15d, %rdx
leaq (%rcx,%rdx,4), %rdi
movslq %eax, %rdx
leaq (,%rdx,4), %rax
subq %rax, %rdi
movq %rbx, %rsi
callq 0x572f0
testl %eax, %eax
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r14d
movq %rdi, %rbx
testl %ecx, %ecx
setle %al
testl %edx, %edx
sets %cl
orb %al, %cl
jne 0xa6b07
movl %edx, %ebp
movq %rsi, %r15
cmpl $0x0, 0x10(%rsi)
je 0xa6ad4
movq 0x8(%r15), %rax
testq %rax, %rax
je 0xa6ad8
movq (%rax), %rdi
jmp 0xa6ada
xorl %eax, %eax
jmp 0xa6adf
xorl %edi, %edi
callq 0x57220
cmpl %ebp, %eax
jle 0xa6b07
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58e20
leal 0x1(%r14), %esi
movq %rbx, %rdi
callq 0xa7094
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xa6b13
movq (%rax), %rdi
jmp 0xa6b15
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58e20
jmp 0xa6b45
xorl %edi, %edi
movq 0x8(%r15), %rax
testq %rax, %rax
je 0xa6b23
movq (%rax), %rax
jmp 0xa6b25
xorl %eax, %eax
movl %ebp, %ecx
leaq (%rax,%rcx,4), %rsi
movl %r14d, %r14d
movq %r14, %rdx
callq 0x58ce0
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl $0x0, (%rax,%r14,4)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x59200
movq %r14, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x10(%rsi), %r12
testq %r12, %r12
je 0xa6be6
movq 0x8(%r14), %rax
xorl %r15d, %r15d
testq %rax, %rax
je 0xa6bf0
movq (%rax), %rdi
jmp 0xa6bf2
xorl %r15d, %r15d
xorl %ecx, %ecx
jmp 0xa6c76
xorl %edi, %edi
callq 0x57220
movq %rax, %rcx
testl %ecx, %ecx
jle 0xa6c76
movq 0x8(%r14), %rdx
movl %ecx, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
xorl %r15d, %r15d
movabsq $0x100002e01, %rax      # imm = 0x100002E01
leaq 0x1(%r15), %rdi
cmpq %r12, %rdi
jge 0xa6c33
movq (%rdx), %r8
movl (%r8,%r15,4), %r8d
cmpq $0x20, %r8
ja 0xa6c3e
btq %r8, %rax
jae 0xa6c3e
movq %rdi, %r15
cmpq %rdi, %rsi
jne 0xa6c17
movl %ecx, %r15d
testl %ecx, %ecx
jle 0xa6c76
movq 0x8(%r14), %rsi
movl %ecx, %edi
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
xorl %edx, %edx
cmpq %r12, %rdi
jge 0xa6c69
movq (%rsi), %r8
movl -0x4(%r8,%rdi,4), %r8d
cmpq $0x20, %r8
ja 0xa6c78
btq %r8, %rax
jae 0xa6c78
incl %edx
decq %rdi
cmpl %edx, %ecx
jne 0xa6c50
movl %ecx, %edx
jmp 0xa6c78
xorl %edx, %edx
addl %r15d, %edx
subl %edx, %ecx
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x58f50
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
xorl %esi, %esi
callq 0xa7094
testl %r14d, %r14d
jle 0xa6d24
leal 0x1(%r14), %esi
movq %rbx, %rdi
callq 0xa7094
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xa6d06
movq (%rax), %rdi
jmp 0xa6d08
xorl %edi, %edi
movl %r14d, %r14d
movl %ebp, %esi
movq %r14, %rdx
callq 0x56550
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl $0x0, (%rax,%r14,4)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/misc/string.cpp
// Function: smooth::String::Explode(smooth::String const&) const
S::Array<S::String> S::String::Explode(const String &delimiter) const
{
	/* Split string and add entries to array.
	 */
	Array<String>	 array;
	Int		 length	= Length();

	for (Int i = 0; i < length; )
	{
		Int	 index = SubString(i, length - i).Find(delimiter);
		String	 part;

		if (index == -1) part = SubString(i, length - i);
		else		 part = SubString(i, index);

		array.Add(part);

		i += part.Length() + delimiter.Length();
	}

	return array;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x55d90
leaq 0xb9439(%rip), %rax     # 0x1602b0
movq %rax, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
leaq 0xb9387(%rip), %rax     # 0x160210
movq %rbx, 0x10(%rsp)
movq %rax, (%rbx)
movq %r15, 0x8(%rsp)
cmpl $0x0, 0x10(%r15)
je 0xa6fc6
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xa6eb4
movq (%rax), %rdi
jmp 0xa6eb6
xorl %edi, %edi
callq 0x57220
movq %rax, %r12
testl %r12d, %r12d
jle 0xa6fc6
xorl %ebp, %ebp
leaq 0x30(%rsp), %r13
movl %r12d, %ebx
subl %ebp, %ebx
movq %r13, %rdi
movq 0x8(%rsp), %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x58f50
movq %r13, %rdi
movq %r14, %rsi
callq 0x57610
movl %eax, %r15d
movq %r13, %rdi
callq 0x59200
movq %r13, %rdi
xorl %esi, %esi
callq 0x58e20
cmpl $-0x1, %r15d
je 0xa6f31
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movl %ebp, %edx
movl %r15d, %ecx
callq 0x58f50
movq %r13, %rdi
movq %rbx, %rsi
callq 0x555f0
movq %rbx, %rdi
jmp 0xa6f55
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq 0x8(%rsp), %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x58f50
movq %r13, %rdi
movq %r15, %rsi
callq 0x555f0
movq %r15, %rdi
callq 0x59200
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x642ac
xorl %r15d, %r15d
cmpl $0x0, 0x40(%rsp)
movl $0x0, %ebx
je 0xa6f8f
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0xa6f85
movq (%rax), %rdi
jmp 0xa6f87
xorl %edi, %edi
callq 0x57220
movq %rax, %rbx
cmpl $0x0, 0x10(%r14)
je 0xa6fae
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xa6fa4
movq (%rax), %rdi
jmp 0xa6fa6
xorl %edi, %edi
callq 0x57220
movq %rax, %r15
addl %ebp, %ebx
addl %r15d, %ebx
movq %r13, %rdi
callq 0x59200
movl %ebx, %ebp
cmpl %r12d, %ebx
jl 0xa6ece
movq 0x10(%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa6fe0
jmp 0xa6ff6
jmp 0xa6ff6
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x59200
jmp 0xa6ff9
jmp 0xa6ff1
movq %rax, %rbx
jmp 0xa7003
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x59200
movq 0x10(%rsp), %rdi
callq 0x63e3c
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x58e20
cmpl $0x0, 0x8(%r15)
jle 0xa7062
testl %ebp, %ebp
je 0xa7045
movq %rbx, %rdi
movq %r14, %rsi
callq 0x562f0
movq %r15, %rdi
movl %ebp, %esi
callq 0x6b610
movq %rbx, %rdi
movq %rax, %rsi
callq 0x562f0
incl %ebp
cmpl 0x8(%r15), %ebp
jl 0xa7036
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x59200
movq %r14, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/misc/encoding/base64.cpp
// Function: smooth::Encoding::Base64::Decode(smooth::String const&)
S::Int S::Encoding::Base64::Decode(const String &string)
{
	Int	 bytes	= 0;
	Int	 length = string.Length();

	buffer.Resize(length / 4 * 3 + 1);

	for (Int i = 0; i < length; i += 4)
	{
		Int	 val[4] = { 64, 64, 64, 64 };

		for (Int j = 0; j < 4; j++)
		{
			wchar_t	 value = string[i + j];

			if	(value >= 'A' && value <= 'Z')	val[j] = value - 'A' +  0;
			else if (value >= 'a' && value <= 'z')	val[j] = value - 'a' + 26;
			else if (value >= '0' && value <= '9')	val[j] = value - '0' + 52;
			else if (value == '+')			val[j] = 62;
			else if (value == '/')			val[j] = 63;
		}

		if (val[0] == 64) break;

		if (val[1] != 64) buffer[bytes++] = ( val[0]       << 2) | (val[1] >> 4);
		if (val[2] != 64) buffer[bytes++] = ((val[1] & 15) << 4) | (val[2] >> 2);
		if (val[3] != 64) buffer[bytes++] = ((val[2] &  3) << 6) | (val[3]);

		buffer[bytes] = 0;
	}

	return bytes;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x57180
movl %eax, %r15d
movq (%r14), %rdi
leal 0x3(%r15), %eax
testl %r15d, %r15d
cmovnsl %r15d, %eax
sarl $0x2, %eax
leal (%rax,%rax,2), %esi
incl %esi
callq 0x62f32
testl %r15d, %r15d
jle 0xaae6f
xorl %r12d, %r12d
xorl %ebp, %ebp
movaps 0x673b3(%rip), %xmm0    # 0x112130
movaps %xmm0, (%rsp)
xorl %r13d, %r13d
leal (%r12,%r13), %esi
movq %rbx, %rdi
callq 0x57fe0
leal -0x41(%rax), %ecx
cmpl $0x1a, %ecx
jb 0xaadb2
leal -0x61(%rax), %ecx
cmpl $0x19, %ecx
ja 0xaada5
addl $-0x47, %eax
jmp 0xaadb0
leal -0x30(%rax), %ecx
cmpl $0x9, %ecx
ja 0xaadc1
addl $0x4, %eax
movl %eax, %ecx
movl %ecx, (%rsp,%r13,4)
incq %r13
cmpq $0x4, %r13
jne 0xaad84
jmp 0xaadd9
cmpl $0x2b, %eax
je 0xaadd2
cmpl $0x2f, %eax
jne 0xaadb6
movl $0x3f, %ecx
jmp 0xaadb2
movl $0x3e, %ecx
jmp 0xaadb2
movl (%rsp), %ecx
cmpl $0x40, %ecx
je 0xaae71
movl 0x4(%rsp), %eax
cmpl $0x40, %eax
je 0xaae0a
shll $0x2, %ecx
movl %eax, %edx
shrl $0x4, %edx
orl %ecx, %edx
movq (%r14), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rcx
movslq %ebp, %rsi
incl %ebp
movb %dl, (%rcx,%rsi)
movl 0x8(%rsp), %ecx
cmpl $0x40, %ecx
je 0xaae2f
shll $0x4, %eax
movl %ecx, %edx
shrl $0x2, %edx
orl %eax, %edx
movq (%r14), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq %ebp, %rsi
incl %ebp
movb %dl, (%rax,%rsi)
movl 0xc(%rsp), %eax
cmpl $0x40, %eax
je 0xaae4f
shll $0x6, %ecx
orl %ecx, %eax
movq (%r14), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rcx
movslq %ebp, %rdx
incl %ebp
movb %al, (%rcx,%rdx)
movq (%r14), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq %ebp, %rcx
movb $0x0, (%rax,%rcx)
addq $0x4, %r12
cmpl %r12d, %r15d
jg 0xaad76
jmp 0xaae71
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/misc/encoding/urlencode.cpp
// Function: smooth::Encoding::URLEncode::Decode(smooth::String const&)
S::String S::Encoding::URLEncode::Decode(const String &encoded)
{
	/* Decode URL encoded string to UTF-8.
	 */
	String	 utf8;
	Int	 length = encoded.Length();

	for (Int i = 0, d = 0; i < length; i++)
	{
		if (encoded[i] == '%')
		{
			utf8[d++] = (Int64) Number::FromHexString(encoded.SubString(i + 1, 2));

			i += 2;
		}
		else
		{
			utf8[d++] = encoded[i];
		}
	}

	/* Import string from UTF-8.
	 */
	String	 string;

	string.ImportFrom("UTF-8", utf8.ConvertTo("ISO-8859-1"));

	return string;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, (%rsp)
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x58e20
movq %r14, %rdi
callq 0x57180
movl %eax, %ebp
testl %eax, %eax
jle 0xab165
xorl %r15d, %r15d
leaq 0x38(%rsp), %r13
xorl %ebx, %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x57fe0
cmpl $0x25, %eax
jne 0xab13b
leal 0x1(%rbx), %edx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movl $0x2, %ecx
callq 0x58f50
movq %r13, %rdi
movq %r12, %rsi
callq 0x55a40
movq %r13, %rdi
callq 0x58f10
movq %rax, %r12
leaq 0x8(%rsp), %rdi
movl %r15d, %esi
callq 0x58990
movl %r12d, (%rax)
movq %r13, %rdi
callq 0x58d60
leaq 0x20(%rsp), %rdi
callq 0x59200
addl $0x2, %ebx
jmp 0xab158
movq %r14, %rdi
movl %ebx, %esi
callq 0x57fe0
movl %eax, %r12d
leaq 0x8(%rsp), %rdi
movl %r15d, %esi
callq 0x58990
movl %r12d, (%rax)
incl %r15d
incl %ebx
cmpl %ebp, %ebx
jl 0xab0d7
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x58e20
leaq 0x66aca(%rip), %rsi     # 0x111c41
leaq 0x8(%rsp), %rdi
movq (%rsp), %r14
callq 0x57940
leaq 0x6714a(%rip), %rsi     # 0x1122d6
movq %r14, %rdi
movq %rax, %rdx
callq 0x56950
leaq 0x8(%rsp), %rdi
callq 0x59200
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
jmp 0xab1d6
jmp 0xab1dd
jmp 0xab1dd
movq %rax, %rbx
jmp 0xab1d1
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x58d60
leaq 0x20(%rsp), %rdi
callq 0x59200
jmp 0xab1e0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %edx, %edx
movq 0xc0c3b(%rip), %rax     # 0x16be38
movl $0x7, %ecx
xorl %esi, %esi
movl %edx, %edi
movl %edi, %r8d
andl $0x1, %r8d
negl %r8d
movzwl %di, %edi
movl $0x1, %r9d
shll %cl, %r9d
andl %r8d, %r9d
orl %r9d, %esi
shrl %edi
addl $-0x1, %ecx
jb 0xab206
shll $0x8, %esi
movl $0x8, %ecx
leal (%rsi,%rsi), %edi
movswl %si, %esi
sarl $0xf, %esi
andl $0xffff8005, %esi       # imm = 0xFFFF8005
xorl %edi, %esi
decl %ecx
jne 0xab231
movl $0xf, %ecx
xorl %edi, %edi
movl %esi, %r8d
andl $0x1, %r8d
negl %r8d
movzwl %si, %esi
movl $0x1, %r9d
shll %cl, %r9d
andl %r8d, %r9d
orl %r9d, %edi
shrl %esi
addl $-0x1, %ecx
jb 0xab24d
movw %di, (%rax,%rdx,2)
incq %rdx
cmpq $0x100, %rdx            # imm = 0x100
jne 0xab1fd
xorl %ecx, %ecx
movq %rax, %rdx
movzwl (%rax,%rcx,2), %esi
movl $0x200, %edi            # imm = 0x200
movzbl %sil, %r8d
movzwl %si, %esi
shrl $0x8, %esi
xorw (%rax,%r8,2), %si
movw %si, (%rdx,%rdi)
addq $0x200, %rdi            # imm = 0x200
cmpq $0x1000, %rdi           # imm = 0x1000
jne 0xab292
incq %rcx
addq $0x2, %rdx
cmpq $0x100, %rcx            # imm = 0x100
jne 0xab289
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl %esi, %ecx
testb %cl, %cl
jle 0xab2ff
decl %ecx
xorl %eax, %eax
movl %edi, %edx
andl $0x1, %edx
negl %edx
movzwl %di, %edi
movl $0x1, %esi
shll %cl, %esi
andl %edx, %esi
orl %esi, %eax
shrl %edi
addl $-0x1, %ecx
jb 0xab2e2
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movzwl (%rdi), %eax
cmpl $0x8, %edx
jl 0xab39f
movq 0xc0b23(%rip), %rcx     # 0x16be38
xorw (%rsi), %ax
movw %ax, (%rdi)
movzwl %ax, %eax
movzbl %al, %r8d
shrl $0x8, %eax
movzwl 0xc00(%rcx,%rax,2), %eax
xorw 0xe00(%rcx,%r8,2), %ax
movzbl 0x2(%rsi), %r8d
xorw 0xa00(%rcx,%r8,2), %ax
movzbl 0x3(%rsi), %r8d
xorw 0x800(%rcx,%r8,2), %ax
movzbl 0x4(%rsi), %r8d
xorw 0x600(%rcx,%r8,2), %ax
movzbl 0x5(%rsi), %r8d
xorw 0x400(%rcx,%r8,2), %ax
movzbl 0x6(%rsi), %r8d
xorw 0x200(%rcx,%r8,2), %ax
movzbl 0x7(%rsi), %r8d
xorw (%rcx,%r8,2), %ax
movw %ax, (%rdi)
addq $0x8, %rsi
leal -0x8(%rdx), %r8d
cmpl $0xf, %edx
movl %r8d, %edx
ja 0xab315
jmp 0xab3a2
movl %edx, %r8d
testl %r8d, %r8d
je 0xab3d4
movl %r8d, %ecx
xorl %edx, %edx
movq 0xc0a85(%rip), %r8      # 0x16be38
movzwl %ax, %eax
movzbl (%rsi,%rdx), %r9d
xorl %eax, %r9d
shrl $0x8, %eax
movzbl %r9b, %r9d
xorw (%r8,%r9,2), %ax
movw %ax, (%rdi)
incq %rdx
cmpl %edx, %ecx
jne 0xab3b3
movb $0x1, %al
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %edx, %edx
movq 0xbff9f(%rip), %rax     # 0x16b430
movl $0x7, %ecx
xorl %esi, %esi
movl %edx, %edi
movl %edi, %r8d
andl $0x1, %r8d
negl %r8d
movl $0x1, %r9d
shll %cl, %r9d
andl %r8d, %r9d
orl %r9d, %esi
shrl %edi
addl $-0x1, %ecx
jb 0xab49a
shll $0x18, %esi
movl $0x8, %ecx
leal (%rsi,%rsi), %edi
sarl $0x1f, %esi
andl $0x4c11db7, %esi        # imm = 0x4C11DB7
xorl %edi, %esi
decl %ecx
jne 0xab4c2
xorl %edi, %edi
movl $0x1f, %ecx
movl %esi, %r8d
andl $0x1, %r8d
negl %r8d
movl $0x1, %r9d
shll %cl, %r9d
andl %r8d, %r9d
orl %r9d, %edi
shrl %esi
addl $-0x1, %ecx
jb 0xab4db
movl %edi, (%rax,%rdx,4)
incq %rdx
cmpq $0x100, %rdx            # imm = 0x100
jne 0xab491
xorl %ecx, %ecx
movq %rax, %rdx
movl (%rax,%rcx,4), %esi
movl $0x400, %edi            # imm = 0x400
movzbl %sil, %r8d
shrl $0x8, %esi
xorl (%rax,%r8,4), %esi
movl %esi, (%rdx,%rdi)
addq $0x400, %rdi            # imm = 0x400
cmpq $0x2000, %rdi           # imm = 0x2000
jne 0xab517
incq %rcx
addq $0x4, %rdx
cmpq $0x100, %rcx            # imm = 0x100
jne 0xab50f
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl %esi, %ecx
testb %cl, %cl
jle 0xab580
decl %ecx
xorl %eax, %eax
movl %edi, %edx
andl $0x1, %edx
negl %edx
movl $0x1, %esi
shll %cl, %esi
andl %edx, %esi
orl %esi, %eax
shrl %edi
addl $-0x1, %ecx
jb 0xab566
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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:
movl (%rdi), %r9d
cmpl $0x8, %edx
jl 0xab62d
movl $0xff, %ecx
movq 0xbfe94(%rip), %r8      # 0x16b430
xorl (%rsi), %r9d
movl %r9d, (%rdi)
movl %r9d, %r10d
andl %ecx, %r10d
movl %r9d, %eax
shrl $0x8, %eax
andl %ecx, %eax
movl 0x1800(%r8,%rax,4), %eax
xorl 0x1c00(%r8,%r10,4), %eax
movl %r9d, %r10d
shrl $0xe, %r10d
andl $0x3fc, %r10d           # imm = 0x3FC
xorl 0x1400(%r8,%r10), %eax
shrl $0x18, %r9d
xorl 0x1000(%r8,%r9,4), %eax
movzbl 0x4(%rsi), %r9d
xorl 0xc00(%r8,%r9,4), %eax
movzbl 0x5(%rsi), %r9d
xorl 0x800(%r8,%r9,4), %eax
movzbl 0x6(%rsi), %r9d
xorl 0x400(%r8,%r9,4), %eax
movzbl 0x7(%rsi), %r9d
xorl (%r8,%r9,4), %eax
movl %eax, (%rdi)
addq $0x8, %rsi
leal -0x8(%rdx), %r10d
movl %eax, %r9d
cmpl $0xf, %edx
movl %r10d, %edx
ja 0xab59c
jmp 0xab633
movl %r9d, %eax
movl %edx, %r10d
testl %r10d, %r10d
je 0xab667
movl %r10d, %ecx
xorl %edx, %edx
movq 0xbfdec(%rip), %r8      # 0x16b430
movl %eax, %r9d
shrl $0x8, %r9d
movzbl %al, %eax
movzbl (%rsi,%rdx), %r10d
xorl %eax, %r10d
xorl (%r8,%r10,4), %r9d
movl %r9d, (%rdi)
incq %rdx
movl %r9d, %eax
cmpl %edx, %ecx
jne 0xab647
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %ecx, %ecx
movabsq $-0x6a536cd653b4364b, %rdx # imm = 0x95AC9329AC4BC9B5
movq 0xbfe9d(%rip), %rax     # 0x16b5d0
movl $0x8, %esi
movq %rcx, %rdi
movq %rdi, %r8
shrq %r8
andl $0x1, %edi
negq %rdi
andq %rdx, %rdi
xorq %r8, %rdi
decl %esi
jne 0xab73b
movq %rdi, (%rax,%rcx,8)
incq %rcx
cmpq $0x100, %rcx            # imm = 0x100
jne 0xab733
xorl %ecx, %ecx
movq %rax, %rdx
movq (%rax,%rcx,8), %rsi
movl $0x800, %edi            # imm = 0x800
movzbl %sil, %r8d
shrq $0x8, %rsi
xorq (%rax,%r8,8), %rsi
movq %rsi, (%rdx,%rdi)
addq $0x800, %rdi            # imm = 0x800
cmpq $0x4000, %rdi           # imm = 0x4000
jne 0xab76f
incq %rcx
addq $0x8, %rdx
cmpq $0x100, %rcx            # imm = 0x100
jne 0xab766
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq (%rdi), %r9
cmpl $0x8, %edx
jl 0xab8a6
movl $0xff, %ecx
movq 0xbfe02(%rip), %r8      # 0x16b5d0
movzbl (%rsi), %eax
movl %r9d, %r10d
andl %ecx, %r10d
xorl %eax, %r10d
movzbl 0x1(%rsi), %eax
movl %r9d, %r11d
shrl $0x8, %r11d
andl %ecx, %r11d
xorl %eax, %r11d
movq 0x3000(%r8,%r11,8), %rax
xorq 0x3800(%r8,%r10,8), %rax
movzbl 0x2(%rsi), %r10d
movl %r9d, %r11d
shrl $0x10, %r11d
andl %ecx, %r11d
xorl %r10d, %r11d
xorq 0x2800(%r8,%r11,8), %rax
movzbl 0x3(%rsi), %r10d
movl %r9d, %r11d
shrl $0x18, %r11d
xorl %r10d, %r11d
xorq 0x2000(%r8,%r11,8), %rax
movzbl 0x4(%rsi), %r10d
movq %r9, %r11
shrq $0x20, %r11
andl %ecx, %r11d
xorl %r10d, %r11d
xorq 0x1800(%r8,%r11,8), %rax
movzbl 0x5(%rsi), %r10d
movq %r9, %r11
shrq $0x28, %r11
andl %ecx, %r11d
xorl %r10d, %r11d
xorq 0x1000(%r8,%r11,8), %rax
movzbl 0x6(%rsi), %r10d
movq %r9, %r11
shrq $0x30, %r11
andl %ecx, %r11d
xorl %r10d, %r11d
xorq 0x800(%r8,%r11,8), %rax
movzbl 0x7(%rsi), %r10d
shrq $0x38, %r9
xorl %r10d, %r9d
xorq (%r8,%r9,8), %rax
movq %rax, (%rdi)
addq $0x8, %rsi
leal -0x8(%rdx), %r10d
movq %rax, %r9
cmpl $0xf, %edx
movl %r10d, %edx
ja 0xab7ce
jmp 0xab8ac
movq %r9, %rax
movl %edx, %r10d
testl %r10d, %r10d
je 0xab8e0
movl %r10d, %ecx
xorl %edx, %edx
movq 0xbfd13(%rip), %r8      # 0x16b5d0
movq %rax, %r9
shrq $0x8, %r9
movzbl %al, %eax
movzbl (%rsi,%rdx), %r10d
xorl %eax, %r10d
xorq (%r8,%r10,8), %r9
movq %r9, (%rdi)
incq %rdx
movq %r9, %rax
cmpl %edx, %ecx
jne 0xab8c0
movb $0x1, %al
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movl 0x28(%rdi), %esi
addl %edx, %esi
movq %rbx, %rdi
callq 0x62f32
movq 0x20(%r14), %rax
testq %rax, %rax
je 0xac19c
movq (%rax), %rax
jmp 0xac19e
xorl %eax, %eax
movslq 0x28(%r14), %rdi
addq %rax, %rdi
movslq %ebp, %rdx
subq %rdx, %rdi
movq %r15, %rsi
callq 0x552d0
movl 0x28(%r14), %eax
cmpl $0x40, %eax
jl 0xac1ea
xorl %r15d, %r15d
movq 0x20(%r14), %rax
testq %rax, %rax
je 0xac1cd
movq (%rax), %rsi
jmp 0xac1cf
xorl %esi, %esi
addq %r15, %rsi
movq %r14, %rdi
callq 0x56700
addq $0x40, %r15
movl 0x28(%r14), %eax
leal 0x3f(%r15), %ecx
cmpl %eax, %ecx
jl 0xac1bf
movq 0x20(%r14), %rcx
testq %rcx, %rcx
je 0xac1f8
movq (%rcx), %rdi
jmp 0xac1fa
xorl %edi, %edi
cltq
leaq (%rdi,%rax), %rcx
leal 0x3f(%rax), %edx
testl %eax, %eax
cmovnsl %eax, %edx
andl $-0x40, %edx
subl %edx, %eax
movslq %eax, %rdx
negl %eax
movslq %eax, %rsi
addq %rcx, %rsi
callq 0x552d0
movl 0x28(%r14), %esi
leal 0x3f(%rsi), %eax
testl %esi, %esi
cmovnsl %esi, %eax
andl $-0x40, %eax
subl %eax, %esi
movq %rbx, %rdi
callq 0x62f32
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/misc/hash/md5.cpp
// Function: smooth::Hash::MD5::Finish()
S::String S::Hash::MD5::Finish()
{
	UnsignedInt64	 bits	= (buffer.Size() + size) * 8;
	Int		 index	= buffer.Size();

	/* Pad out to 56 mod 64.
	 */
	Int		 padLen	= (index < 56) ? (56 - index) : (120 - index);

	UnsignedByte	*end = new UnsignedByte [128];

	memcpy(end, buffer, index);
	memcpy(end + index, PADDING, padLen);

	end[index + padLen    ] = bits	     & 0xFF;
	end[index + padLen + 1] = bits >>  8 & 0xFF;
	end[index + padLen + 2] = bits >> 16 & 0xFF;
	end[index + padLen + 3] = bits >> 24 & 0xFF;
	end[index + padLen + 4] = bits >> 32 & 0xFF;
	end[index + padLen + 5] = bits >> 40 & 0xFF;
	end[index + padLen + 6] = bits >> 48 & 0xFF;
	end[index + padLen + 7] = bits >> 56 & 0xFF;

	Transform(end);

	if (padLen > 56) Transform(end + 64);

	delete [] end;

	String	 string;

	for (Int i = 0; i < 4; i++) string.Append(Number((Int64) REVERSE_INT32(state[i])).ToHexString(8));

	return string;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x28(%rsi), %r12
xorl %r13d, %r13d
cmpq $0x38, %r12
setge %r13b
movq 0x10(%rsi), %rbp
addq %r12, %rbp
shlq $0x3, %rbp
shll $0x6, %r13d
orl $0x38, %r13d
movl %r13d, %eax
subl %r12d, %eax
movl %eax, 0xc(%rsp)
movl $0x80, %edi
callq 0x56670
movq %rax, %r15
movq 0x20(%r14), %rax
testq %rax, %rax
je 0xac2bf
movq (%rax), %rsi
jmp 0xac2c1
xorl %esi, %esi
movq %r15, %rdi
movq %r12, %rdx
callq 0x552d0
addq %r15, %r12
movslq 0xc(%rsp), %rdx
leaq 0x65e75(%rip), %rsi     # 0x112150
movq %r12, %rdi
movq %rdx, %r12
callq 0x552d0
movl %r13d, %eax
movw %bp, (%r15,%rax)
movl %ebp, %ecx
shrl $0x10, %ecx
movb %cl, 0x2(%r15,%rax)
movl %ebp, %ecx
shrl $0x18, %ecx
movb %cl, 0x3(%r15,%rax)
movq %rbp, %rcx
shrq $0x20, %rcx
movb %cl, 0x4(%r15,%rax)
movq %rbp, %rcx
shrq $0x28, %rcx
movb %cl, 0x5(%r15,%rax)
movq %rbp, %rcx
shrq $0x30, %rcx
movb %cl, 0x6(%r15,%rax)
shrq $0x38, %rbp
movb %bpl, 0x7(%r15,%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x56700
cmpl $0x39, %r12d
jl 0xac34f
movq %r15, %rsi
addq $0x40, %rsi
movq %r14, %rdi
callq 0x56700
movq %r15, %rdi
callq 0x561e0
xorl %r13d, %r13d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58e20
leaq 0x10(%rsp), %r15
leaq 0x20(%rsp), %r12
movl (%r14,%r13,4), %esi
bswapl %esi
movq %r15, %rdi
callq 0x59050
movq %r12, %rdi
movq %r15, %rsi
movl $0x8, %edx
callq 0x57780
movq %rbx, %rdi
movq %r12, %rsi
callq 0x562f0
movq %r12, %rdi
callq 0x59200
movq %r15, %rdi
callq 0x58d60
incq %r13
cmpq $0x4, %r13
jne 0xac36e
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xac3e3
movq %rax, %r14
jmp 0xac3d9
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x59200
leaq 0x10(%rsp), %rdi
callq 0x58d60
movq %rbx, %rdi
callq 0x59200
movq %r14, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/misc/hash/sha1.cpp
// Function: smooth::Hash::SHA1::Transform(unsigned char*)
S::Void S::Hash::SHA1::Transform(UnsignedByte *buffer)
{
	UnsignedInt32	 word[80];

	for (Int j =  0; j < 16; j++) word[j] = buffer[j * 4 + 0] * 0x1000000 + buffer[j * 4 + 1] * 0x10000 + buffer[j * 4 + 2] * 0x100 + buffer[j * 4 + 3];
	for (Int j = 16; j < 80; j++) word[j] = ROTATE_LEFT((word[j - 3] ^ word[j - 8] ^ word[j - 14] ^ word[j - 16]), 1);

	UnsignedInt32	 a = state[0];
	UnsignedInt32	 b = state[1];
	UnsignedInt32	 c = state[2];
	UnsignedInt32	 d = state[3];
	UnsignedInt32	 e = state[4];

	for (int m = 0; m < 80; m++)
	{
		UnsignedInt32	 f = 0;
		UnsignedInt32	 k = 0;

		if	(m <= 19) { f = (b & c) | ((~b) & d);	     k = 0x5a827999; }
		else if (m <= 39) { f = b ^ c ^ d;		     k = 0x6ed9eba1; }
		else if (m <= 59) { f = (b & c) | (b & d) | (c & d); k = 0x8f1bbcdc; }
		else		  { f = b ^ c ^ d;		     k = 0xca62c1d6; }

		UnsignedInt32	 temp = (ROTATE_LEFT(a, 5) + f + e + k + word[m]) & 0xFFFFFFFF;

		e = d;
		d = c;
		c = ROTATE_LEFT(b, 30);
		b = a;

		a = temp;
	}

	state[0] += a;
	state[1] += b;
	state[2] += c;
	state[3] += d;
	state[4] += e;

	size += 64;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
xorl %eax, %eax
movl (%rsi,%rax,4), %ecx
bswapl %ecx
movl %ecx, -0x70(%rsp,%rax,4)
incq %rax
cmpq $0x10, %rax
jne 0xac4f3
movl $0x10, %eax
movl -0x90(%rsp,%rax,4), %ecx
xorl -0x7c(%rsp,%rax,4), %ecx
xorl -0xa8(%rsp,%rax,4), %ecx
xorl -0xb0(%rsp,%rax,4), %ecx
roll %ecx
movl %ecx, -0x70(%rsp,%rax,4)
incq %rax
cmpq $0x50, %rax
jne 0xac50a
movl (%rdi), %r8d
movl 0x4(%rdi), %esi
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %ecx
movl 0x10(%rdi), %r14d
xorl %r11d, %r11d
movl %r14d, -0x74(%rsp)
movl %ecx, %r12d
movl %edx, %r13d
movl %esi, %ebp
movl %r8d, %r15d
movl %r15d, %eax
movl %ebp, %ebx
movl %r13d, %r10d
movl %r12d, %r9d
cmpq $0x13, %r11
ja 0xac57a
movl %r10d, %r15d
xorl %r9d, %r15d
andl %ebx, %r15d
xorl %r9d, %r15d
movl $0x5a827999, %r12d      # imm = 0x5A827999
jmp 0xac5bf
cmpq $0x27, %r11
ja 0xac591
movl %r10d, %r15d
xorl %ebx, %r15d
xorl %r9d, %r15d
movl $0x6ed9eba1, %r12d      # imm = 0x6ED9EBA1
jmp 0xac5bf
cmpq $0x3b, %r11
ja 0xac5b0
movl %r9d, %ebp
orl %r10d, %ebp
andl %ebx, %ebp
movl %r9d, %r15d
andl %r10d, %r15d
orl %ebp, %r15d
movl $0x8f1bbcdc, %r12d      # imm = 0x8F1BBCDC
jmp 0xac5bf
movl %r10d, %r15d
xorl %ebx, %r15d
xorl %r9d, %r15d
movl $0xca62c1d6, %r12d      # imm = 0xCA62C1D6
movl %eax, %ebp
roll $0x5, %ebp
addl %ebp, %r14d
addl %r15d, %r14d
addl %r12d, %r14d
movl %r14d, %r15d
addl -0x70(%rsp,%r11,4), %r15d
roll $0x1e, %ebx
incq %r11
movl %r9d, %r14d
movl %r10d, %r12d
movl %ebx, %r13d
movl %eax, %ebp
cmpq $0x50, %r11
jne 0xac555
addl %r8d, %r15d
movl %r15d, (%rdi)
addl %esi, %eax
movl %eax, 0x4(%rdi)
addl %edx, %ebx
movl %ebx, 0x8(%rdi)
addl %ecx, %r10d
movl %r10d, 0xc(%rdi)
addl -0x74(%rsp), %r9d
movl %r9d, 0x10(%rdi)
addq $0x40, 0x18(%rdi)
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/misc/hash/sha1.cpp
// Function: smooth::Hash::SHA1::Finish()
S::String S::Hash::SHA1::Finish()
{
	UnsignedInt64	 bits	= (buffer.Size() + size) * 8;
	Int		 index	= buffer.Size();

	/* Pad out to 56 mod 64.
	 */
	Int		 padLen	= (index < 56) ? (56 - index) : (120 - index);

	UnsignedByte	*end = new UnsignedByte [128];

	memcpy(end, buffer, index);
	memcpy(end + index, PADDING, padLen);

	for (Int i = 0; i < 8; i++) end[index + padLen + i] = bits >> 8 * (7 - i) & 0xFF;

	Transform(end);

	if (padLen > 56) Transform(end + 64);

	delete [] end;

	String	 string;

	for (Int i = 0; i < 5; i++) string.Append(Number((Int64) ((UnsignedInt32 *) state)[i]).ToHexString(8));

	return string;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x30(%rsi), %r13
xorl %ebp, %ebp
cmpq $0x38, %r13
setge %bpl
movq 0x18(%rsi), %r12
addq %r13, %r12
shlq $0x3, %r12
shll $0x6, %ebp
orl $0x38, %ebp
movl %ebp, %eax
subl %r13d, %eax
movl %eax, 0xc(%rsp)
movl $0x80, %edi
callq 0x56670
movq %rax, %r15
movq 0x28(%r14), %rcx
testq %rcx, %rcx
je 0xac775
movq (%rcx), %rsi
jmp 0xac777
xorl %esi, %esi
movq %r15, %rdi
movq %r13, %rdx
callq 0x552d0
addq %r15, %r13
movslq 0xc(%rsp), %rdx
leaq 0x65a0f(%rip), %rsi     # 0x1121a0
movq %r13, %rdi
movq %rdx, %r13
callq 0x552d0
movq %r12, %xmm1
pshufd $0x44, %xmm1, %xmm0     # xmm0 = xmm1[0,1,0,1]
movdqa %xmm1, %xmm2
movdqa %xmm1, %xmm3
movdqa %xmm1, %xmm4
psrlq $0x8, %xmm4
punpcklqdq %xmm1, %xmm4    # xmm4 = xmm4[0],xmm1[0]
psrlq $0x38, %xmm1
movdqa %xmm0, %xmm5
psrlq $0x30, %xmm5
movsd %xmm1, %xmm5            # xmm5 = xmm1[0],xmm5[1]
psrlq $0x28, %xmm2
movdqa %xmm0, %xmm1
psrlq $0x20, %xmm1
movsd %xmm2, %xmm1            # xmm1 = xmm2[0],xmm1[1]
movl %ebp, %eax
psrlq $0x18, %xmm3
psrlq $0x10, %xmm0
movsd %xmm3, %xmm0            # xmm0 = xmm3[0],xmm0[1]
movdqa 0x65999(%rip), %xmm2    # 0x112190
pand %xmm2, %xmm4
andpd %xmm2, %xmm0
packuswb %xmm4, %xmm0
andpd %xmm2, %xmm1
andpd %xmm2, %xmm5
packuswb %xmm1, %xmm5
packuswb %xmm0, %xmm5
packuswb %xmm5, %xmm5
movq %xmm5, (%r15,%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x569f0
cmpl $0x39, %r13d
jl 0xac83d
movq %r15, %rsi
addq $0x40, %rsi
movq %r14, %rdi
callq 0x569f0
movq %r15, %rdi
callq 0x561e0
xorl %r13d, %r13d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58e20
leaq 0x10(%rsp), %r15
leaq 0x20(%rsp), %r12
movl (%r14,%r13,4), %esi
movq %r15, %rdi
callq 0x59050
movq %r12, %rdi
movq %r15, %rsi
movl $0x8, %edx
callq 0x57780
movq %rbx, %rdi
movq %r12, %rsi
callq 0x562f0
movq %r12, %rdi
callq 0x59200
movq %r15, %rdi
callq 0x58d60
incq %r13
cmpq $0x5, %r13
jne 0xac85c
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xac8cf
movq %rax, %r14
jmp 0xac8c5
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x59200
leaq 0x10(%rsp), %rdi
callq 0x58d60
movq %rbx, %rdi
callq 0x59200
movq %r14, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x562b0
movq 0xbe731(%rip), %rax     # 0x16b570
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0xd0(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x58e20
leaq 0xf0(%rbx), %r15
movq %r15, %rdi
xorl %esi, %esi
movq %r14, 0x10(%rsp)
callq 0x58e20
leaq 0x108(%rbx), %r12
movq %r12, %rdi
xorl %esi, %esi
movq %r15, 0x8(%rsp)
callq 0x58e20
movq %r12, (%rsp)
leaq 0x120(%rbx), %r13
movq %r13, %rdi
callq 0x55d90
leaq 0xbc10b(%rip), %r15     # 0x168fa8
movq %r15, 0x160(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x168(%rbx)
leaq 0xbc053(%rip), %r12     # 0x168f08
movq %r12, 0x120(%rbx)
leaq 0x178(%rbx), %rbp
movq %rbp, %rdi
callq 0x55d90
movq %r15, 0x1b8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x1c0(%rbx)
movq %r12, 0x178(%rbx)
leaq 0xb3066(%rip), %rax     # 0x15ff50
movq %rax, 0x1d0(%rbx)
movups %xmm0, 0x1d8(%rbx)
leaq 0x1e8(%rbx), %r14
movq %r14, %rdi
callq 0x55d90
movq %r15, 0x228(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x230(%rbx)
movq %r12, 0x1e8(%rbx)
leaq 0x240(%rbx), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x58e20
leaq 0x270(%rbx), %rdi
xorl %esi, %esi
callq 0x58e20
xorl %eax, %eax
movw %ax, 0xc8(%rbx)
movw %ax, 0xec(%rbx)
movl $0x0, 0xe8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x258(%rbx)
movq $0x0, 0x268(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq %r15, %rdi
callq 0x59200
jmp 0xacf8c
movq %rax, %r12
movq %r14, %rdi
callq 0xaeac6
jmp 0xacf99
movq %rax, %r12
leaq 0x1d0(%rbx), %rdi
leaq 0xb2fa9(%rip), %rax     # 0x15ff50
movq %rax, (%rdi)
callq 0x62130
movq %rbp, %rdi
callq 0xaeac6
jmp 0xacfbc
movq %rax, %r12
movq %r13, %rdi
callq 0xaeac6
jmp 0xacfc9
movq %rax, %r12
movq (%rsp), %rdi
callq 0x59200
movq 0x8(%rsp), %rdi
callq 0x59200
movq 0x10(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x55a80
movq %r12, %rdi
callq 0x57090
movq %rax, %r12
jmp 0xacfd2
movq %rax, %r12
jmp 0xacfdc
movq %rax, %r12
jmp 0xacfe6
nop
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x58e20
movq %rsp, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x56800
movq %rsp, %rdi
callq 0x56ef0
movl %eax, %ebp
movq %rsp, %rdi
callq 0x59178
leaq 0x38(%rsp), %rdi
callq 0x59200
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb %bpl, %bpl
je 0xad2ec
movq %rsp, %r12
movq %r12, %rdi
callq 0x570d0
movq %r12, %rdi
movq %r15, %rsi
callq 0x555f0
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x555f0
movq %rsp, %rsi
movb $0x1, 0x30(%rsi)
addq $0x178, %rbx            # imm = 0x178
movq %rbx, %rdi
callq 0xaee4e
movq %r15, %rdi
callq 0x59200
movq %rsp, %rdi
callq 0x59200
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x59178
jmp 0xad309
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
jmp 0xad320
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x59200
movq %rsp, %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
addq $0xd0, %rdi
callq 0x555f0
movl %ebp, 0xe8(%rbx)
cmpw $0x0, 0xec(%rbx)
jne 0xad377
movw $0x1, 0xec(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq