LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/math.cpp
// Function: smooth::Math::Pow(int, int)
S::Float S::Math::Pow(Int in, Int ie)
{
	Float	 value = 1;

	if (ie >= 0) for (Int i = 0; i <  ie; i++) value *= in;
	else	     for (Int i = 0; i < -ie; i++) value /= in;

	return value;
}

// Assembly:
testl %esi, %esi
js 0xa4f12
je 0xa4f34
cvtsi2sd %edi, %xmm1
movsd 0x4f480(%rip), %xmm0    # 0xf4388
mulsd %xmm1, %xmm0
decl %esi
jne 0xa4f08
jmp 0xa4f33
negl %esi
cvtsi2sd %edi, %xmm1
cmpl $0x2, %esi
movl $0x1, %eax
cmovgel %esi, %eax
movsd 0x4f45d(%rip), %xmm0    # 0xf4388
divsd %xmm1, %xmm0
decl %eax
jne 0xa4f2b
retq
movsd 0x4f44c(%rip), %xmm0    # 0xf4388
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/math.cpp
// Function: smooth::Math::Pow(long long, long long)
S::Float S::Math::Pow(Int64 in, Int64 ie)
{
	Float	 value = 1;

	if (ie >= 0) for (Int i = 0; i <  ie; i++) value *= in;
	else	     for (Int i = 0; i < -ie; i++) value /= in;

	return value;
}

// Assembly:
testq %rsi, %rsi
js 0xa4f5d
je 0xa4f84
cvtsi2sd %rdi, %xmm1
movsd 0x4f436(%rip), %xmm0    # 0xf4388
mulsd %xmm1, %xmm0
decq %rsi
jne 0xa4f52
jmp 0xa4f83
negq %rsi
cvtsi2sd %rdi, %xmm1
cmpq $0x2, %rsi
movl $0x1, %eax
cmovgeq %rsi, %rax
movsd 0x4f40e(%rip), %xmm0    # 0xf4388
divsd %xmm1, %xmm0
decq %rax
jne 0xa4f7a
retq
movsd 0x4f3fc(%rip), %xmm0    # 0xf4388
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/memory.cpp
// Function: smooth::Memory::Resize(int)
S::Bool S::Memory::Resize(Int size)
{
	UnsignedByte	*oldMemory = memory;

	if ((memory = (UnsignedByte *) realloc(memory, size)) == NIL)
	{
		free(oldMemory);

		return False;
	}

	return True;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movq (%rdi), %rbx
movslq %esi, %rsi
movq %rbx, %rdi
callq 0x553d0
movq %rax, %r14
movq %rax, (%r15)
testq %rax, %rax
jne 0xa509d
movq %rbx, %rdi
callq 0x55790
testq %r14, %r14
setne %al
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/number.cpp
// Function: smooth::Number::FromIntString(smooth::String const&)
S::Number S::Number::FromIntString(const String &string)
{
	Int	 first = string[0];
	Int	 sign  = (first == '-' ? -1 : 1);
	Int	 skip  = 0;

	if (first == '-' || first == '+') skip = 1;

	Int	 length = string.Length();
	Int	 digits = 0;

	for (Int i = skip; i < length; i++)
	{
		Int	 digit = string[i];

		if ((digit >= '0' && digit <= '9')) digits++;
		else				    break;
	}

	Int64	 value = 0;

	for (Int i = 0; i < digits; i++)
	{
		value += Int64(string[skip + i] - '0') * (Int64) Math::Pow(10, digits - i - 1);
	}

	return value * sign;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, (%rsp)
xorl %ebp, %ebp
movq %rsi, %rdi
xorl %esi, %esi
callq 0x57fe0
movl %eax, %r14d
leal -0x2b(%r14), %eax
xorl %r12d, %r12d
testl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
sete %r12b
movq %r15, %rdi
callq 0x57180
cmpl %r12d, %eax
jle 0xa5335
movl %eax, %r13d
decl %r13d
xorl %ebp, %ebp
movl %r12d, %ebx
movq %r15, %rdi
movl %ebx, %esi
callq 0x57fe0
addl $-0x30, %eax
cmpl $0xa, %eax
adcl $0x0, %ebp
cmpl $0x9, %eax
ja 0xa5335
leal 0x1(%rbx), %eax
cmpl %ebx, %r13d
movl %eax, %ebx
jne 0xa5313
testl %ebp, %ebp
jle 0xa5370
decl %ebp
xorl %ebx, %ebx
movq %r15, %rdi
movl %r12d, %esi
callq 0x57fe0
addl $-0x30, %eax
movslq %eax, %r13
movl $0xa, %edi
movl %ebp, %esi
callq 0x56010
cvttsd2si %xmm0, %rax
imulq %r13, %rax
addq %rax, %rbx
incl %r12d
addl $-0x1, %ebp
jb 0xa533d
jmp 0xa5372
xorl %ebx, %ebx
movq %rbx, %rsi
negq %rsi
cmpl $0x2d, %r14d
cmovneq %rbx, %rsi
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x59050
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/number.cpp
// Function: smooth::Number::FromFloatString(smooth::String const&)
S::Number S::Number::FromFloatString(const String &string)
{
	Int	 first = string[0];
	Int	 sign  = (first == '-' ? -1 : 1);
	Int	 skip  = 0;

	if (first == '-' || first == '+') skip = 1;

	Int	 length = string.Length();
	Int	 digits = 0;

	for (Int i = skip; i < length; i++)
	{
		Int	 digit = string[i];

		if ((digit >= '0' && digit <= '9')) digits++;
		else				    break;
	}

	Int	 digitsafp = 0;

	if (string[skip + digits] == '.')
	{
		for (Int i = skip + digits + 1; i < length; i++)
		{
			Int	 digit = string[i];

			if ((digit >= '0' && digit <= '9')) digitsafp++;
			else				    break;
		}
	}

	Float	 value = Math::Abs(Int64(Number::FromIntString(string)));

	for (Int i = 0; i < digitsafp; i++)
	{
		value += Float(string[skip + digits + 1 + i] - '0') * Math::Pow(10, 0 - i - 1);
	}

	return value * sign;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, 0x18(%rsp)
xorl %ebx, %ebx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x57fe0
movq %rax, 0x10(%rsp)
addl $-0x2b, %eax
xorl %r13d, %r13d
testl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
sete %r13b
movq %r14, %rdi
callq 0x57180
movl %eax, %r12d
movl $0x0, %r15d
movq %r13, 0x8(%rsp)
cmpl %r13d, %eax
jle 0xa5422
leal -0x1(%r12), %ebp
xorl %r15d, %r15d
movq 0x8(%rsp), %r13
movq %r14, %rdi
movl %r13d, %esi
callq 0x57fe0
addl $-0x30, %eax
cmpl $0xa, %eax
adcl $0x0, %r15d
cmpl $0x9, %eax
ja 0xa5422
leal 0x1(%r13), %eax
cmpl %r13d, %ebp
movl %eax, %r13d
jne 0xa53fc
movq 0x8(%rsp), %r13
leal (%r15,%r13), %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x57fe0
cmpl $0x2e, %eax
jne 0xa5460
addl %r13d, %r15d
incl %r15d
xorl %ebx, %ebx
leal (%r15,%rbx), %esi
cmpl %r12d, %esi
jge 0xa5460
movq %r14, %rdi
callq 0x57fe0
addl $-0x30, %eax
incl %ebx
cmpl $0xa, %eax
jb 0xa5442
adcl $-0x1, %ebx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x55ee0
movq (%r12), %rax
movq %rax, %rcx
sarq $0x3f, %rcx
orq $0x1, %rcx
testq %rax, %rax
cmoveq %rax, %rcx
imulq %rax, %rcx
cvtsi2sd %rcx, %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
callq 0x58d60
testl %ebx, %ebx
jle 0xa5503
incl %ebp
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movsd 0x8(%rsp), %xmm1
movsd %xmm1, 0x8(%rsp)
movq %r14, %rdi
movl %ebp, %esi
callq 0x57fe0
addl $-0x30, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x20(%rsp)
movl $0xa, %edi
movl %r12d, %esi
callq 0x56010
movsd 0x8(%rsp), %xmm1
mulsd 0x20(%rsp), %xmm0
addsd %xmm0, %xmm1
leal (%rbx,%r12), %eax
decl %eax
movl %r12d, %ecx
decl %ecx
incl %ebp
movl %ecx, %r12d
cmpl $-0x1, %eax
jne 0xa54af
jmp 0xa5509
movsd 0x8(%rsp), %xmm1
xorl %eax, %eax
cmpl $0x2d, 0x10(%rsp)
setne %al
leal -0x1(%rax,%rax), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd %xmm1, %xmm0
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x560c0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/number.cpp
// Function: smooth::Number::FromHexString(smooth::String const&)
S::Number S::Number::FromHexString(const String &string)
{
	Int	 first  = string[0];
	Int	 second = string[1];
	Int	 skip	= 0;

	if (first == '0' && (second == 'x' || second == 'X')) skip = 2;

	Int	 length = string.Length();
	Int	 digits = 0;

	for (Int i = skip; i < length; i++)
	{
		Int	 digit = string[i];

		if ((digit >= '0' && digit <= '9') ||
		    (digit >= 'A' && digit <= 'F') ||
		    (digit >= 'a' && digit <= 'f')) digits++;
		else				    break;
	}

	Int64	 value = 0;

	for (Int i = 0; i < digits; i++)
	{
		Int	 digit = string[skip + i];

		if	(digit >= '0' && digit <= '9') value += (Int64(digit - '0')	 << ((digits - i - 1) * 4));
		else if (digit >= 'A' && digit <= 'F') value += (Int64(digit - 'A' + 10) << ((digits - i - 1) * 4));
		else if (digit >= 'a' && digit <= 'f') value += (Int64(digit - 'a' + 10) << ((digits - i - 1) * 4));
	}

	return value;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, (%rsp)
xorl %r13d, %r13d
movq %rsi, %rdi
xorl %esi, %esi
callq 0x57fe0
movl %eax, %r15d
movq %r14, %rdi
movl $0x1, %esi
callq 0x57fe0
xorl $0x30, %r15d
andl $-0x21, %eax
xorl $0x58, %eax
xorl %ebp, %ebp
orl %r15d, %eax
sete %bpl
addl %ebp, %ebp
movq %r14, %rdi
callq 0x57180
cmpl %eax, %ebp
jge 0xa55e1
movl %eax, %r15d
decl %r15d
xorl %r13d, %r13d
movabsq $0x3f0000003f, %rbx     # imm = 0x3F0000003F
movl %ebp, %r12d
movq %r14, %rdi
movl %r12d, %esi
callq 0x57fe0
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
jb 0xa55cb
movb $0x1, %cl
addl $-0x41, %eax
cmpl $0x25, %eax
ja 0xa55d0
btq %rax, %rbx
jae 0xa55d0
incl %r13d
xorl %ecx, %ecx
testb %cl, %cl
jne 0xa55e1
leal 0x1(%r12), %eax
cmpl %r12d, %r15d
movl %eax, %r12d
jne 0xa55a8
testl %r13d, %r13d
jle 0xa5638
movl %r13d, %ebx
leal -0x4(,%r13,4), %r12d
xorl %r15d, %r15d
movq %r14, %rdi
movl %ebp, %esi
callq 0x57fe0
leal -0x30(%rax), %ecx
cmpl $0x9, %ecx
ja 0xa560a
movl %ecx, %eax
jmp 0xa5622
leal -0x41(%rax), %ecx
cmpl $0x5, %ecx
ja 0xa5617
addl $-0x37, %eax
jmp 0xa5622
leal -0x61(%rax), %ecx
cmpl $0x5, %ecx
ja 0xa562b
addl $-0x57, %eax
movl %r12d, %ecx
shlq %cl, %rax
addq %rax, %r15
incl %ebp
addl $-0x4, %r12d
decq %rbx
jne 0xa55f4
jmp 0xa563b
xorl %r15d, %r15d
movq (%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x59050
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/number.cpp
// Function: smooth::Number::ToIntString() const
S::String S::Number::ToIntString() const
{
	if (intValue == 0) return kZero;

	String	 string;
	Int	 length = (Int) Math::Log10(Math::Abs(intValue)) + 1;

	for (Int i = 0; i < length; i++)
	{
		string[i] = '0' + Int64(Math::Abs(intValue) / Math::Pow(10, length - i - 1)) % 10;
	}

	if (intValue < 0) string = String(kMinus).Append(string);

	return string;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpq $0x0, (%rsi)
je 0xa576e
movq %rsi, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58e20
movq (%r14), %rax
movq %rax, %rcx
sarq $0x3f, %rcx
orq $0x1, %rcx
testq %rax, %rax
cmoveq %rax, %rcx
imulq %rax, %rcx
cvtsi2sd %rcx, %xmm0
callq 0x563c0
cvttsd2si %xmm0, %ebp
testl %ebp, %ebp
js 0xa5733
xorl %r15d, %r15d
movq (%r14), %r12
movq %r12, %r13
sarq $0x3f, %r13
orq $0x1, %r13
testq %r12, %r12
cmoveq %r12, %r13
movl $0xa, %edi
movl %ebp, %esi
callq 0x56010
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x58990
movq %rax, %rcx
imulq %r12, %r13
xorps %xmm0, %xmm0
cvtsi2sd %r13, %xmm0
divsd 0x8(%rsp), %xmm0
cvttsd2si %xmm0, %rsi
movq %rsi, %rax
movabsq $0x6666666666666667, %rdx # imm = 0x6666666666666667
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0x2, %rdx
addl %eax, %edx
addl %edx, %edx
leal (%rdx,%rdx,4), %eax
subl %eax, %esi
addl $0x30, %esi
movl %esi, (%rcx)
incl %r15d
addl $-0x1, %ebp
jb 0xa56b6
cmpq $0x0, (%r14)
jns 0xa577d
leaq 0xca6a0(%rip), %rsi     # 0x16fde0
leaq 0x10(%rsp), %rdi
callq 0x570b0
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x562f0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x555f0
leaq 0x10(%rsp), %rdi
callq 0x59200
jmp 0xa577d
leaq 0xca653(%rip), %rsi     # 0x16fdc8
movq %rbx, %rdi
callq 0x570b0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa57a2
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x59200
jmp 0xa57a5
jmp 0xa57a2
movq %rax, %r14
movq %rbx, %rdi
callq 0x59200
movq %r14, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/number.cpp
// Function: smooth::Number::ToHexString(int) const
S::String S::Number::ToHexString(Int length) const
{
	String	 string;
	Int	 stringPos = 0;

	for (Int i = 0; i < 16; i++)
	{
		if	(((intValue >> (4 * (15 - i))) & 15) >= 10) string[stringPos++] = 'a' + ((intValue >> (4 * (15 - i))) & 15) - 10;
		else if (((intValue >> (4 * (15 - i))) & 15) >=  1) string[stringPos++] = '0' + ((intValue >> (4 * (15 - i))) & 15);
		else if (stringPos			     >   0) string[stringPos++] = '0';
	}

	if (length != -1)
	{
		/* Add leading zeros if necessary.
		 */
		if (string.Length() < length) string = String().FillN('0', length - string.Length()).Append(string);

		/* Cut string if too long.
		 */
		if (string.Length() > length) string = string.Tail(length);
	}

	return string;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %esi, %esi
callq 0x58e20
movl $0x3c, %r12d
movq (%r14), %r13
movl %r12d, %ecx
sarq %cl, %r13
andl $0xf, %r13d
cmpq $0xa, %r13
jb 0xa5b13
movq %rbx, %rdi
movl %r15d, %esi
callq 0x58990
incl %r15d
addl $0x57, %r13d
jmp 0xa5b2a
testq %r13, %r13
je 0xa5b39
movq %rbx, %rdi
movl %r15d, %esi
callq 0x58990
incl %r15d
orl $0x30, %r13d
movl %r13d, (%rax)
addq $-0x4, %r12
cmpq $-0x4, %r12
jne 0xa5aec
jmp 0xa5b54
testl %r15d, %r15d
jle 0xa5b2d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x58990
incl %r15d
movl $0x30, (%rax)
jmp 0xa5b2d
cmpl $-0x1, %ebp
je 0xa5bd2
movq %rbx, %rdi
callq 0x57180
cmpl %ebp, %eax
jge 0xa5ba6
movq %rsp, %rdi
xorl %esi, %esi
callq 0x58e20
movq %rbx, %rdi
callq 0x57180
movl %ebp, %edx
subl %eax, %edx
movq %rsp, %rdi
movl $0x30, %esi
callq 0x57bf0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x562f0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x555f0
movq %rsp, %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57180
cmpl %ebp, %eax
jle 0xa5bd2
movq %rsp, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x57f90
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x555f0
movq %rsp, %rdi
callq 0x59200
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa5bea
jmp 0xa5bf9
jmp 0xa5bf9
movq %rax, %r14
movq %rsp, %rdi
callq 0x59200
jmp 0xa5bfc
jmp 0xa5bf9
movq %rax, %r14
movq %rbx, %rdi
callq 0x59200
movq %r14, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/string.cpp
// Function: smooth::String::operator=(wchar_t const*)
S::String &S::String::operator =(const wchar_t *newString)
{
	Clean();

	if (newString != NIL)
	{
		Int	 size = wcslen(newString) + 1;

		wString.Resize(size);

		wcsncpy(wString, newString, size);
	}

	return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
callq 0xa7dce
testq %r14, %r14
je 0xa5d3f
movq %r14, %rdi
callq 0x57220
movq %rax, %r15
incl %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0xa7dce
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xa5d32
movq (%rax), %rdi
jmp 0xa5d34
xorl %edi, %edi
movslq %r15d, %rdx
movq %r14, %rsi
callq 0x58ce0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/string.cpp
// Function: smooth::String::operator=(smooth::String const&)
S::String &S::String::operator =(const String &newString)
{
	if (&newString == this) return *this;

	Clean();

	if (newString.wString.Size() > 0)
	{
		Int	 size = newString.wString.Size();

		wString.Resize(size);

		wcsncpy(wString, newString.wString, size);
	}

	return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rdi, %rsi
je 0xa5dd8
movq %rsi, %r15
movq %rbx, %rdi
xorl %esi, %esi
callq 0xa7dce
movslq 0x10(%r15), %r14
testq %r14, %r14
jle 0xa5dd8
movq %rbx, %rdi
movl %r14d, %esi
callq 0xa7dce
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xa5dbe
movq (%rax), %rdi
jmp 0xa5dc0
xorl %edi, %edi
movq 0x8(%r15), %rax
testq %rax, %rax
je 0xa5dce
movq (%rax), %rsi
jmp 0xa5dd0
xorl %esi, %esi
movq %r14, %rdx
callq 0x58ce0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/string.cpp
// Function: smooth::String::DeleteTemporaryBuffers(bool)
S::Void S::String::DeleteTemporaryBuffers(Bool all)
{
	/* Free all but the most recent 8 buffers.
	 */
	if (allocatedBuffers != NIL)
	{
		Int	 nOfEntries = allocatedBuffers->Length();

		for (Int i = 0; i < nOfEntries - (all ? 0 : 8); i++)
		{
			delete [] allocatedBuffers->GetFirst();

			allocatedBuffers->RemoveNth(0);
		}

		if (all)
		{
			delete allocatedBuffers;

			allocatedBuffers = NIL;
		}
	}

	/* When purging all, also free iconv buffer and I/O format strings.
	 */
	if (all)
	{
		if (iconvBuffer) delete iconvBuffer;

		if (inputFormat	 != NIL) delete [] inputFormat;
		if (outputFormat != NIL) delete [] outputFormat;

		inputFormat  = NIL;
		outputFormat = NIL;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebp
leaq 0xc652e(%rip), %rdi     # 0x16c330
callq 0x566e0
movq %rax, %rbx
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0xa5e70
leaq 0x8(%rax), %r14
movl 0x8(%rcx), %eax
movzbl %bpl, %ecx
leal (%rax,%rcx,8), %r15d
addl $-0x8, %r15d
testl %r15d, %r15d
jle 0xa5e56
movq (%r14), %rdi
callq 0x60a9c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xa5e46
callq 0x561e0
movq (%r14), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x18(%rax)
decl %r15d
jne 0xa5e31
testb %bpl, %bpl
je 0xa5ec1
movq (%r14), %rdi
testq %rdi, %rdi
je 0xa5e69
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%r14)
testb %bpl, %bpl
je 0xa5ec1
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xa5e87
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
movq %rax, %r14
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0xa5e9e
callq 0x561e0
leaq 0x18(%r14), %r14
leaq 0x20(%rbx), %rbx
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xa5eb9
callq 0x561e0
xorl %eax, %eax
movq %rax, (%r14)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/string.cpp
// Function: smooth::String::AddTemporaryBuffer(char*)
S::Void S::String::AddTemporaryBuffer(char *buffer)
{
	/* Free old buffers and add new.
	 */
	if (allocatedBuffers == NIL) allocatedBuffers = new BufferArray();

	if (allocatedBuffers->Length() >= 8) DeleteTemporaryBuffers();

	allocatedBuffers->Add(buffer);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc6449(%rip), %rdi     # 0x16c330
callq 0x566e0
leaq 0x8(%rax), %r15
cmpq $0x0, (%r15)
jne 0xa5f2e
movl $0x58, %edi
callq 0x556b0
movq %rax, %r14
movq %rax, %rdi
callq 0x55d90
leaq 0xba8cb(%rip), %rax     # 0x1607e0
movq %rax, 0x40(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r14)
leaq 0xc3f10(%rip), %rax     # 0x169e38
movq %rax, (%r14)
movq %r14, (%r15)
movq (%r15), %rax
cmpl $0x8, 0x8(%rax)
jl 0xa5f3e
xorl %edi, %edi
callq 0x58440
movq (%r15), %rdi
leaq 0x8(%rsp), %rsi
movq %rbx, (%rsi)
callq 0x5af08
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x58, %esi
movq %r14, %rdi
callq 0x55480
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/string.cpp
// Function: smooth::String::EncodeBase64() const
S::String S::String::EncodeBase64() const
{
	if (wString.Size() == 0) return NIL;

	const char		*utf8string = ConvertTo("UTF-8");
	int			 length	    = strlen(utf8string);

	Buffer<UnsignedByte>	 buffer(length);

	strncpy((char *) (UnsignedByte *) buffer, utf8string, length);

	return Encoding::Base64(buffer).Encode();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x10(%rsi)
je 0xa6067
leaq 0x6d0f7(%rip), %rax     # 0x113126
movq %rsi, %rdi
movq %rax, %rsi
callq 0x57940
movq %rax, %r14
movq %rax, %rdi
callq 0x56370
movq %rax, %r15
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movl %r15d, %esi
callq 0x62006
movq 0x8(%r12), %rax
testq %rax, %rax
je 0xa6073
movq (%rax), %rdi
jmp 0xa6075
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58e20
jmp 0xa60bf
xorl %edi, %edi
movslq %r15d, %rdx
movq %r14, %rsi
callq 0x556a0
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x567c0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x58c40
leaq 0x8(%rsp), %rdi
callq 0x55f50
leaq 0xbae7e(%rip), %rax     # 0x160f30
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
callq 0x6207e
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x55f50
jmp 0xa60e0
movq %rax, %rbx
leaq 0xbae49(%rip), %rax     # 0x160f30
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
callq 0x6207e
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/string.cpp
// Function: smooth::String::DecodeBase64() const
S::String S::String::DecodeBase64() const
{
	if (wString.Size() == 0) return NIL;

	Buffer<UnsignedByte>	 buffer;
	String			 string;

	Encoding::Base64(buffer).Decode(*this);

	string.ImportFrom("UTF-8", (char *) (UnsignedByte *) buffer);

	return string;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x10(%rsi)
je 0xa6342
movq %rsi, %r14
leaq 0xbac34(%rip), %r15     # 0x160f30
movq %r15, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58e20
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0x567c0
movq %rsp, %rdi
movq %r14, %rsi
callq 0x59040
movq %rsp, %rdi
callq 0x55f50
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xa634e
movq (%rax), %rdx
jmp 0xa6350
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58e20
jmp 0xa636c
xorl %edx, %edx
leaq 0x6cdcf(%rip), %rsi     # 0x113126
movq %rbx, %rdi
callq 0x56950
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
callq 0x6207e
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xa6388
movq %rax, %r14
movq %rsp, %rdi
callq 0x55f50
jmp 0xa638b
movq %rax, %r14
movq %rbx, %rdi
callq 0x59200
jmp 0xa6398
movq %rax, %r14
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
callq 0x6207e
movq %r14, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/string.cpp
// Function: smooth::String::SetInputFormat(char const*)
const char *S::String::SetInputFormat(const char *iFormat)
{
	if (iFormat == NIL) return SetInputFormat(GetDefaultEncoding());

	/* Return immediately if requested format equals current.
	 */
	if (inputFormat != NIL && strcmp(iFormat, inputFormat) == 0) return inputFormat;

	/* Backup input format and set new one.
	 */
	char	*previousInputFormat = inputFormat;

	inputFormat = NIL;

	if (strcmp(iFormat, GetDefaultEncoding()) != 0)
	{
		int	 length = strlen(iFormat) + 1;

		inputFormat = new char [length];

		strncpy(inputFormat, iFormat, length);
	}

	/* Add previous format to temporary buffers list.
	 */
	if (previousInputFormat != NIL)
	{
		AddTemporaryBuffer(previousInputFormat);

		return previousInputFormat;
	}

	return GetDefaultEncoding();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x6c9e6(%rip), %rax     # 0x113126
movq %rdi, %r14
movq %rax, %rdi
testq %r14, %r14
je 0xa6740
leaq 0xc5bde(%rip), %rdi     # 0x16c330
callq 0x566e0
movq %rax, %r15
movq 0x18(%rax), %rbx
testq %rbx, %rbx
je 0xa6775
movq %r14, %rdi
movq %rbx, %rsi
callq 0x57bc0
testl %eax, %eax
je 0xa67ce
leaq 0x18(%r15), %r13
movq $0x0, (%r13)
leaq 0x6c99b(%rip), %r15     # 0x113126
movq %r14, %rdi
movq %r15, %rsi
callq 0x57bc0
testl %eax, %eax
je 0xa67c1
movq %r14, %rdi
callq 0x56370
incl %eax
movslq %eax, %r12
movq %r12, %rdi
callq 0x56670
movq %rax, (%r13)
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x556a0
testq %rbx, %rbx
je 0xa67d1
movq %rbx, %rdi
callq 0x588c0
movq %rbx, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/string.cpp
// Function: smooth::String::SetOutputFormat(char const*)
const char *S::String::SetOutputFormat(const char *oFormat)
{
	if (oFormat == NIL) return SetOutputFormat(GetDefaultEncoding());

	/* Return immediately if requested format equals current.
	 */
	if (outputFormat != NIL && strcmp(oFormat, outputFormat) == 0) return outputFormat;

	/* Backup output format and set new one.
	 */
	char	*previousOutputFormat = outputFormat;

	outputFormat = NIL;

	if (strcmp(oFormat, GetDefaultEncoding()) != 0)
	{
		int	 length = strlen(oFormat) + 1;

		outputFormat = new char [length];

		strncpy(outputFormat, oFormat, length);
	}

	/* Add previous format to temporary buffers list.
	 */
	if (previousOutputFormat != NIL)
	{
		AddTemporaryBuffer(previousOutputFormat);

		return previousOutputFormat;
	}

	return GetDefaultEncoding();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x6c914(%rip), %rax     # 0x113126
movq %rdi, %r14
movq %rax, %rdi
testq %r14, %r14
je 0xa6812
leaq 0xc5b0c(%rip), %rdi     # 0x16c330
callq 0x566e0
movq %rax, %r15
movq 0x20(%rax), %rbx
testq %rbx, %rbx
je 0xa6847
movq %r14, %rdi
movq %rbx, %rsi
callq 0x57bc0
testl %eax, %eax
je 0xa68a0
leaq 0x20(%r15), %r13
movq $0x0, (%r13)
leaq 0x6c8c9(%rip), %r15     # 0x113126
movq %r14, %rdi
movq %r15, %rsi
callq 0x57bc0
testl %eax, %eax
je 0xa6893
movq %r14, %rdi
callq 0x56370
incl %eax
movslq %eax, %r12
movq %r12, %rdi
callq 0x56670
movq %rax, (%r13)
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x556a0
testq %rbx, %rbx
je 0xa68a3
movq %rbx, %rdi
callq 0x588c0
movq %rbx, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/string.cpp
// Function: smooth::String::operator[](int)
wchar_t &S::String::operator [](int n)
{
	static wchar_t	 dummy = 0;

	if (n < 0) return dummy;

	if (n + 1 >= wString.Size())
	{
		Int	 length = Length();

		/* Allocate more memory than actually
		 * needed to speed up string operations.
		 */
		wString.Resize(n + Math::Max(10, Math::Min(n / 10, 100000)));

		wmemset(wString + length, 0, wString.Size() - length);
	}

	return wString[n];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
js 0xa6b33
movl %esi, %r15d
movq %rdi, %r14
leal 0x1(%r15), %ecx
movl 0x10(%rdi), %eax
movl %esi, %ebx
cmpl %eax, %ecx
jl 0xa6b9d
testl %eax, %eax
je 0xa6b3c
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xa6b41
movq (%rax), %rdi
jmp 0xa6b43
leaq 0xc92e6(%rip), %rbx     # 0x16fe20
jmp 0xa6ba8
xorl %r12d, %r12d
jmp 0xa6b4b
xorl %edi, %edi
callq 0x57220
movq %rax, %r12
movl $0xcccccccd, %eax       # imm = 0xCCCCCCCD
imulq %rbx, %rax
shrq $0x23, %rax
movl $0x186a0, %ecx          # imm = 0x186A0
cmpl %ecx, %eax
cmovll %eax, %ecx
cmpl $0xb, %ecx
movl $0xa, %esi
cmovgel %ecx, %esi
addl %r15d, %esi
movq %r14, %rdi
callq 0xa7dce
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xa6b86
movq (%rax), %rax
jmp 0xa6b88
xorl %eax, %eax
movslq %r12d, %rcx
leaq (%rax,%rcx,4), %rdi
movslq 0x10(%r14), %rdx
subq %rcx, %rdx
xorl %esi, %esi
callq 0x56550
movq 0x8(%r14), %rax
shlq $0x2, %rbx
addq (%rax), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/string.cpp
// Function: smooth::String::Compare(smooth::String const&) const
S::Int S::String::Compare(const String &str) const
{
	Int	 len1 = Length();
	Int	 len2 = str.Length();

	if	(len1 != len2)					       return len1 - len2;
	else if (len1 > 0 && wcsncmp(wString, str.wString, len1) != 0) return 1;

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
xorl %r12d, %r12d
cmpl $0x0, 0x10(%rdi)
movl $0x0, %r14d
je 0xa6cf3
movq 0x8(%r15), %rax
testq %rax, %rax
je 0xa6ce9
movq (%rax), %rdi
jmp 0xa6ceb
xorl %edi, %edi
callq 0x57220
movq %rax, %r14
cmpl $0x0, 0x10(%rbx)
je 0xa6d11
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xa6d07
movq (%rax), %rdi
jmp 0xa6d09
xorl %edi, %edi
callq 0x57220
movq %rax, %r12
movl %r14d, %eax
subl %r12d, %eax
jne 0xa6d53
testl %r14d, %r14d
jle 0xa6d51
movq 0x8(%r15), %rax
testq %rax, %rax
je 0xa6d2c
movq (%rax), %rdi
jmp 0xa6d2e
xorl %edi, %edi
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xa6d3c
movq (%rax), %rsi
jmp 0xa6d3e
xorl %esi, %esi
movl %r14d, %edx
callq 0x572f0
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0xa6d53
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/string.cpp
// Function: smooth::String::Find(smooth::String const&) const
S::Int S::String::Find(const String &str) const
{
	if (str	  == NIL) return 0;
	if (*this == NIL) return -1;

	wchar_t* start = wcsstr(wString, str.wString);

	if (start != NIL) return start - wString;

	return -1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpl $0x0, 0x10(%rsi)
je 0xa7076
movq 0x8(%rsi), %rax
movq (%rax), %rax
cmpl $0x0, (%rax)
je 0xa7076
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x0, 0x10(%rdi)
je 0xa7076
movq 0x8(%rdi), %rax
movq (%rax), %rax
cmpl $0x0, (%rax)
je 0xa7076
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0xa7045
movq (%r14), %rdi
jmp 0xa7047
xorl %edi, %edi
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0xa7055
movq (%rax), %rsi
jmp 0xa7057
xorl %esi, %esi
callq 0x56270
testq %rax, %rax
je 0xa7076
testq %r14, %r14
je 0xa706b
movq (%r14), %rcx
jmp 0xa706d
xorl %ecx, %ecx
subq %rcx, %rax
shrq $0x2, %rax
movl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/string.cpp
// Function: smooth::String::FindLast(smooth::String const&) const
S::Int S::String::FindLast(const String &str) const
{
	if (str == NIL) return Length();

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

	for (Int i = len1 - len2; i >= 0; i--)
	{
		if (wcsncmp(wString + i, str.wString, len2) == 0) return i;
	}

	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl 0x10(%rsi), %ebp
testl %ebp, %ebp
je 0xa70c1
movq %rsi, %r15
movq 0x8(%rsi), %rax
movq (%rax), %rax
cmpl $0x0, (%rax)
je 0xa70c1
xorl %r13d, %r13d
cmpl $0x0, 0x10(%r14)
movl $0x0, %ebx
je 0xa70f4
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xa70ea
movq (%rax), %rdi
jmp 0xa70ec
cmpl $0x0, 0x10(%r14)
je 0xa70d6
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xa70de
movq (%rax), %rdi
jmp 0xa70e0
xorl %r12d, %r12d
jmp 0xa7167
xorl %edi, %edi
callq 0x57220
movq %rax, %r12
jmp 0xa7167
xorl %edi, %edi
callq 0x57220
movq %rax, %rbx
testl %ebp, %ebp
je 0xa7110
movq 0x8(%r15), %rax
testq %rax, %rax
je 0xa7106
movq (%rax), %rdi
jmp 0xa7108
xorl %edi, %edi
callq 0x57220
movq %rax, %r13
subl %r13d, %ebx
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
js 0xa7167
movq 0x8(%r14), %rbp
movq 0x8(%r15), %r15
movslq %r13d, %r14
movl %ebx, %r13d
shlq $0x2, %r13
testq %rbp, %rbp
je 0xa7138
movq (%rbp), %rdi
jmp 0xa713a
xorl %edi, %edi
testq %r15, %r15
je 0xa7144
movq (%r15), %rsi
jmp 0xa7146
xorl %esi, %esi
addq %r13, %rdi
movq %r14, %rdx
callq 0x572f0
testl %eax, %eax
je 0xa7164
leal -0x1(%rbx), %eax
addq $-0x4, %r13
testl %ebx, %ebx
movl %eax, %ebx
jg 0xa712d
jmp 0xa7167
movl %ebx, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x10(%rsi), %ebp
testl %ebp, %ebp
je 0xa7238
movq %rsi, %r14
movq 0x8(%rsi), %rax
movq (%rax), %rax
cmpl $0x0, (%rax)
je 0xa7238
xorl %r15d, %r15d
cmpl $0x0, 0x10(%rbx)
movl $0x0, %r12d
je 0xa71ca
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xa71c0
movq (%rax), %rdi
jmp 0xa71c2
xorl %edi, %edi
callq 0x57220
movq %rax, %r12
testl %ebp, %ebp
je 0xa71e6
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xa71dc
movq (%rax), %rdi
jmp 0xa71de
xorl %edi, %edi
callq 0x57220
movq %rax, %r15
leal (%r15,%r12), %esi
incl %esi
movq %rbx, %rdi
callq 0xa7dce
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xa7202
movq (%rax), %rax
jmp 0xa7204
xorl %eax, %eax
leal (%r15,%r12), %ebp
movslq %r12d, %rcx
leaq (%rax,%rcx,4), %rdi
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xa721d
movq (%rax), %rsi
jmp 0xa721f
xorl %esi, %esi
movslq %r15d, %rdx
callq 0x58ce0
movq 0x8(%rbx), %rax
movq (%rax), %rax
movslq %ebp, %rcx
movl $0x0, (%rax,%rcx,4)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa7dce
testl %r14d, %r14d
jle 0xa755c
leal 0x1(%r14), %esi
movq %rbx, %rdi
callq 0xa7dce
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xa7530
movq (%rax), %rdi
jmp 0xa7532
xorl %edi, %edi
movq 0x8(%r15), %rax
testq %rax, %rax
je 0xa7540
movq (%rax), %rsi
jmp 0xa7542
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_O1/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 0xa7599
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x0, 0x10(%rdi)
je 0xa759c
movq 0x8(%r15), %rax
testq %rax, %rax
je 0xa75a0
movq (%rax), %rdi
jmp 0xa75a2
xorl %eax, %eax
retq
xorl %ecx, %ecx
jmp 0xa75aa
xorl %edi, %edi
callq 0x57220
movq %rax, %rcx
movl $0x1, %eax
cmpl %ebx, %ecx
jl 0xa75e4
movq 0x8(%r15), %rax
testq %rax, %rax
je 0xa75c1
movq (%rax), %rdi
jmp 0xa75c3
xorl %edi, %edi
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xa75d1
movq (%rax), %rsi
jmp 0xa75d3
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_O1/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 0xa77bb
movl %edx, %ebp
movq %rsi, %r15
cmpl $0x0, 0x10(%rsi)
je 0xa7788
movq 0x8(%r15), %rax
testq %rax, %rax
je 0xa778c
movq (%rax), %rdi
jmp 0xa778e
xorl %eax, %eax
jmp 0xa7793
xorl %edi, %edi
callq 0x57220
cmpl %ebp, %eax
jle 0xa77bb
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58e20
leal 0x1(%r14), %esi
movq %rbx, %rdi
callq 0xa7dce
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xa77c7
movq (%rax), %rdi
jmp 0xa77c9
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58e20
jmp 0xa77f9
xorl %edi, %edi
movq 0x8(%r15), %rax
testq %rax, %rax
je 0xa77d7
movq (%rax), %rax
jmp 0xa77d9
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_O1/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
xorl %r15d, %r15d
movl $0x0, %ecx
testq %r12, %r12
je 0xa78a9
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xa789f
movq (%rax), %rdi
jmp 0xa78a1
xorl %edi, %edi
callq 0x57220
movq %rax, %rcx
movl %ecx, %eax
testl %ecx, %ecx
jle 0xa793a
movq 0x8(%r14), %rdx
movq %rax, %rsi
negq %rsi
movl $0x1, %r15d
cmpq %r12, %r15
jl 0xa78da
leaq (%rsi,%r15), %rdi
incq %rdi
incq %r15
cmpq $0x1, %rdi
jne 0xa78c3
jmp 0xa7937
jge 0xa78c8
movq (%rdx), %rdi
cmpl $0x20, -0x4(%rdi,%r15,4)
je 0xa78c8
cmpq %r12, %r15
jge 0xa78c8
movq (%rdx), %rdi
cmpl $0x9, -0x4(%rdi,%r15,4)
je 0xa78c8
cmpq %r12, %r15
jge 0xa78c8
movq (%rdx), %rdi
cmpl $0xa, -0x4(%rdi,%r15,4)
je 0xa78c8
cmpq %r12, %r15
jge 0xa78c8
movq (%rdx), %rdi
cmpl $0xd, -0x4(%rdi,%r15,4)
je 0xa78c8
movq (%rdx), %rdi
cmpl $0x0, -0x4(%rdi,%r15,4)
je 0xa78c8
cmpq %r12, %r15
jge 0xa7932
movq (%rdx), %rdi
cmpl $0xb, -0x4(%rdi,%r15,4)
je 0xa78c8
decl %r15d
jmp 0xa793a
movl %ecx, %r15d
testl %ecx, %ecx
jle 0xa7992
movq 0x8(%r14), %rsi
xorl %edx, %edx
cmpq %r12, %rax
jge 0xa7985
movq (%rsi), %rdi
cmpl $0x20, -0x4(%rdi,%rax,4)
je 0xa7985
movq (%rsi), %rdi
cmpl $0x9, -0x4(%rdi,%rax,4)
je 0xa7985
movq (%rsi), %rdi
cmpl $0xa, -0x4(%rdi,%rax,4)
je 0xa7985
movq (%rsi), %rdi
cmpl $0xd, -0x4(%rdi,%rax,4)
je 0xa7985
movq (%rsi), %rdi
cmpl $0x0, -0x4(%rdi,%rax,4)
je 0xa7985
movq (%rsi), %rdi
cmpl $0xb, -0x4(%rdi,%rax,4)
jne 0xa7994
incl %edx
decq %rax
cmpl %edx, %ecx
jne 0xa7944
movl %ecx, %edx
jmp 0xa7994
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_O1/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 0xa7dce
testl %r14d, %r14d
jle 0xa7a62
leal 0x1(%r14), %esi
movq %rbx, %rdi
callq 0xa7dce
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xa7a44
movq (%rax), %rdi
jmp 0xa7a46
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_O1/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 0xb96db(%rip), %rax     # 0x161290
movq %rax, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
leaq 0xb9629(%rip), %rax     # 0x1611f0
movq %rbx, 0x8(%rsp)
movq %rax, (%rbx)
cmpl $0x0, 0x10(%r15)
movq %r15, 0x10(%rsp)
je 0xa7be9
movq 0x8(%r15), %rax
testq %rax, %rax
je 0xa7bee
movq (%rax), %rdi
jmp 0xa7bf0
xorl %r12d, %r12d
jmp 0xa7bf8
xorl %edi, %edi
callq 0x57220
movq %rax, %r12
testl %r12d, %r12d
jle 0xa7d00
xorl %ebp, %ebp
leaq 0x30(%rsp), %r13
movl %r12d, %ebx
subl %ebp, %ebx
movq %r13, %rdi
movq 0x10(%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 0xa7c6b
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
movl %ebp, %edx
movl %r15d, %ecx
callq 0x58f50
movq %r13, %rdi
movq %rbx, %rsi
callq 0x555f0
movq %rbx, %rdi
jmp 0xa7c8f
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq 0x10(%rsp), %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x58f50
movq %r13, %rdi
movq %r15, %rsi
callq 0x555f0
movq %r15, %rdi
callq 0x59200
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x64280
xorl %r15d, %r15d
cmpl $0x0, 0x40(%rsp)
movl $0x0, %ebx
je 0xa7cc9
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0xa7cbf
movq (%rax), %rdi
jmp 0xa7cc1
xorl %edi, %edi
callq 0x57220
movq %rax, %rbx
cmpl $0x0, 0x10(%r14)
je 0xa7ce8
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xa7cde
movq (%rax), %rdi
jmp 0xa7ce0
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 0xa7c08
movq 0x8(%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa7d1a
jmp 0xa7d30
jmp 0xa7d30
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x59200
jmp 0xa7d33
jmp 0xa7d2b
movq %rax, %rbx
jmp 0xa7d3d
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x59200
movq 0x8(%rsp), %rdi
callq 0x63e08
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xa7d9c
testl %ebp, %ebp
je 0xa7d7f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x562f0
movq %r15, %rdi
movl %ebp, %esi
callq 0x6b6a6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x562f0
incl %ebp
cmpl 0x8(%r15), %ebp
jl 0xa7d70
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_O1/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 0x62eaa
testl %r15d, %r15d
jle 0xabbde
xorl %r12d, %r12d
xorl %ebp, %ebp
movaps 0x674af(%rip), %xmm0    # 0x112f90
movaps %xmm0, (%rsp)
xorl %r13d, %r13d
leal (%r12,%r13), %esi
movq %rbx, %rdi
callq 0x57fe0
leal -0x41(%rax), %ecx
cmpl $0x1a, %ecx
jb 0xabb16
leal -0x61(%rax), %ecx
cmpl $0x19, %ecx
ja 0xabb09
addl $-0x47, %eax
jmp 0xabb14
leal -0x30(%rax), %ecx
cmpl $0x9, %ecx
ja 0xabb25
addl $0x4, %eax
movl %eax, %ecx
movl %ecx, (%rsp,%r13,4)
incq %r13
cmpq $0x4, %r13
jne 0xabae8
jmp 0xabb3d
cmpl $0x2b, %eax
je 0xabb36
cmpl $0x2f, %eax
jne 0xabb1a
movl $0x3f, %ecx
jmp 0xabb16
movl $0x3e, %ecx
jmp 0xabb16
movl (%rsp), %eax
cmpl $0x40, %eax
je 0xabbca
movl 0x4(%rsp), %ecx
cmpl $0x40, %ecx
je 0xabb73
leal (,%rax,4), %edx
movl %ecx, %esi
shrl $0x4, %esi
orl %edx, %esi
movq (%r14), %rdx
movq 0x8(%rdx), %rdx
movq (%rdx), %rdx
movslq %ebp, %rdi
incl %ebp
movb %sil, (%rdx,%rdi)
movl 0x8(%rsp), %edx
cmpl $0x40, %edx
je 0xabb99
shll $0x4, %ecx
movl %edx, %esi
shrl $0x2, %esi
orl %ecx, %esi
movq (%r14), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rcx
movslq %ebp, %rdi
incl %ebp
movb %sil, (%rcx,%rdi)
movl 0xc(%rsp), %ecx
cmpl $0x40, %ecx
je 0xabbb9
shll $0x6, %edx
orl %edx, %ecx
movq (%r14), %rdx
movq 0x8(%rdx), %rdx
movq (%rdx), %rdx
movslq %ebp, %rsi
incl %ebp
movb %cl, (%rdx,%rsi)
movq (%r14), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rcx
movslq %ebp, %rdx
movb $0x0, (%rcx,%rdx)
cmpl $0x40, %eax
je 0xabbe0
addq $0x4, %r12
cmpl %r12d, %r15d
jg 0xabada
jmp 0xabbe0
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0xabed5
xorl %r15d, %r15d
leaq 0x38(%rsp), %r13
xorl %ebx, %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x57fe0
cmpl $0x25, %eax
jne 0xabeab
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 0xabec8
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 0xabe47
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x58e20
leaq 0x66bba(%rip), %rsi     # 0x112aa1
leaq 0x8(%rsp), %rdi
movq (%rsp), %r14
callq 0x57940
leaq 0x6722a(%rip), %rsi     # 0x113126
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 0xabf46
jmp 0xabf4d
jmp 0xabf4d
movq %rax, %rbx
jmp 0xabf41
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x58d60
leaq 0x20(%rsp), %rdi
callq 0x59200
jmp 0xabf50
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
nop