LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 $0x28, %rsp
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
xorl %r15d, %r15d
movq %rsi, %rdi
xorl %esi, %esi
callq 0x59270
movl %eax, %r12d
leal -0x2b(%r12), %ebx
andl $-0x3, %ebx
movq %r14, %rdi
callq 0x58370
movl %eax, %ebp
cmpl $0x1, %ebx
adcl $0x1, %r15d
leal -0x1(%r15), %r13d
cmpl %ebp, %r13d
jge 0xa0260
movq %r14, %rdi
movl %r13d, %esi
callq 0x59270
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0xa0260
incl %r15d
jmp 0xa023f
movq %r14, %rdi
movl %r13d, %esi
callq 0x59270
xorl %ebx, %ebx
cmpl $0x2e, %eax
jne 0xa0291
xorl %ecx, %ecx
movl %ecx, %ebx
leal (%r15,%rbx), %esi
cmpl %ebp, %esi
jge 0xa0291
movq %r14, %rdi
callq 0x59270
addl $-0x30, %eax
leal 0x1(%rbx), %ecx
cmpl $0xa, %eax
jb 0xa0274
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x56fb0
movq (%r13), %rax
movq %rax, %rcx
sarq $0x3f, %rcx
orq $0x1, %rcx
testq %rax, %rax
cmoveq %rax, %rcx
imulq %rax, %rcx
cvtsi2sd %rcx, %xmm0
movsd %xmm0, (%rsp)
movq %r13, %rdi
callq 0x5a0b0
pushq $-0x1
popq %r13
pushq $0xa
popq %rbp
leal (%rbx,%r13), %eax
cmpl $-0x1, %eax
je 0xa031b
movq %r14, %rdi
movl %r15d, %esi
callq 0x59270
addl $-0x30, %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x10(%rsp)
movl %ebp, %edi
movl %r13d, %esi
callq 0x570f0
mulsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
decl %r13d
incl %r15d
jmp 0xa02d4
xorl %eax, %eax
cmpl $0x2d, %r12d
setne %al
leal -0x1(,%rax,2), %eax
cvtsi2sd %eax, %xmm1
movsd (%rsp), %xmm0
mulsd %xmm1, %xmm0
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x571a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x59270
movl %eax, %r15d
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x59270
xorl $0x30, %r15d
andl $-0x21, %eax
xorl $0x58, %eax
xorl %ebp, %ebp
orl %r15d, %eax
sete %bpl
addl %ebp, %ebp
movq %r14, %rdi
callq 0x58370
movl %eax, %r15d
movabsq $0x3f0000003f, %rbx     # imm = 0x3F0000003F
movl %ebp, %r12d
cmpl %r15d, %r12d
jge 0xa03e1
movq %r14, %rdi
movl %r12d, %esi
callq 0x59270
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
jb 0xa03d8
addl $-0x41, %eax
cmpl $0x25, %eax
ja 0xa03e1
btq %rax, %rbx
jae 0xa03e1
incl %r12d
addq $0x4, %r13
jmp 0xa03b2
xorl %r15d, %r15d
testq %r13, %r13
je 0xa0429
movq %r14, %rdi
movl %ebp, %esi
callq 0x59270
leal -0x30(%rax), %ecx
cmpl $0x9, %ecx
ja 0xa03ff
movl %ecx, %eax
jmp 0xa0417
leal -0x41(%rax), %ecx
cmpl $0x5, %ecx
ja 0xa040c
addl $-0x37, %eax
jmp 0xa0417
leal -0x61(%rax), %ecx
cmpl $0x5, %ecx
ja 0xa0421
addl $-0x57, %eax
leal -0x4(%r13), %ecx
shlq %cl, %rax
addq %rax, %r15
incl %ebp
addq $-0x4, %r13
jmp 0xa03e4
movq (%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5a3d0
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_O2/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 0xa0542
movq %rsi, %r14
xorl %ebp, %ebp
movq %rbx, (%rsp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5a180
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 0x574c0
cvttsd2si %xmm0, %r13d
movl %r13d, %r12d
movq (%r14), %rbx
cmpl %r13d, %ebp
jg 0xa0504
movq %rbx, %r15
sarq $0x3f, %r15
orq $0x1, %r15
testq %rbx, %rbx
cmoveq %rbx, %r15
pushq $0xa
popq %rdi
movl %r12d, %esi
callq 0x570f0
movsd %xmm0, 0x8(%rsp)
movq (%rsp), %rdi
movl %ebp, %esi
callq 0x59cc0
movq %rax, %rcx
imulq %rbx, %r15
cvtsi2sd %r15, %xmm0
divsd 0x8(%rsp), %xmm0
cvttsd2si %xmm0, %rax
cqto
pushq $0xa
popq %rsi
idivq %rsi
addl $0x30, %edx
movl %edx, (%rcx)
incl %ebp
decl %r12d
jmp 0xa04a3
testq %rbx, %rbx
movq (%rsp), %rbx
jns 0xa0551
leaq 0xc4a8c(%rip), %rsi     # 0x164fa0
leaq 0x10(%rsp), %rdi
callq 0x58280
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x573e0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x56630
leaq 0x10(%rsp), %rdi
callq 0x5a588
jmp 0xa0551
leaq 0xc4a3f(%rip), %rsi     # 0x164f88
movq %rbx, %rdi
callq 0x58280
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa0576
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x5a588
jmp 0xa0579
jmp 0xa0576
movq %rax, %r14
movq (%rsp), %rdi
callq 0x5a588
movq %r14, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/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 0x5a180
pushq $0x3c
popq %r12
cmpq $-0x4, %r12
je 0xa08f0
movq (%r14), %r13
movl %r12d, %ecx
sarq %cl, %r13
andl $0xf, %r13d
cmpq $0xa, %r13
jb 0xa08b5
movq %rbx, %rdi
movl %r15d, %esi
callq 0x59cc0
incl %r15d
addl $0x57, %r13d
jmp 0xa08cc
testq %r13, %r13
je 0xa08d5
movq %rbx, %rdi
movl %r15d, %esi
callq 0x59cc0
incl %r15d
orl $0x30, %r13d
movl %r13d, (%rax)
addq $-0x4, %r12
jmp 0xa0888
testl %r15d, %r15d
jle 0xa08cf
movq %rbx, %rdi
movl %r15d, %esi
callq 0x59cc0
incl %r15d
movl $0x30, (%rax)
jmp 0xa08cf
cmpl $-0x1, %ebp
je 0xa096c
movq %rbx, %rdi
callq 0x58370
cmpl %ebp, %eax
jge 0xa0940
movq %rsp, %rdi
xorl %esi, %esi
callq 0x5a180
movq %rbx, %rdi
callq 0x58370
movl %ebp, %edx
subl %eax, %edx
movq %rsp, %rdi
pushq $0x30
popq %rsi
callq 0x58e70
movq %rax, %rdi
movq %rbx, %rsi
callq 0x573e0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x56630
movq %rsp, %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58370
cmpl %ebp, %eax
jle 0xa096c
movq %rsp, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x59220
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x56630
movq %rsp, %rdi
callq 0x5a588
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa0984
jmp 0xa0993
jmp 0xa0993
movq %rax, %r14
movq %rsp, %rdi
callq 0x5a588
jmp 0xa0996
jmp 0xa0993
movq %rax, %r14
movq %rbx, %rdi
callq 0x5a588
movq %r14, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x58af0
testq %r14, %r14
je 0xa0ad1
movq %r14, %rdi
callq 0x58410
movq %rax, %r15
incl %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0xa260a
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xa0ac4
movq (%rax), %rdi
jmp 0xa0ac6
xorl %edi, %edi
movslq %r15d, %rdx
movq %r14, %rsi
callq 0x5a030
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa0b66
movq %rsi, %r15
movq %rbx, %rdi
callq 0x58af0
movslq 0x10(%r15), %r14
testq %r14, %r14
jle 0xa0b66
movq %rbx, %rdi
movl %r14d, %esi
callq 0xa260a
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xa0b4c
movq (%rax), %rdi
jmp 0xa0b4e
xorl %edi, %edi
movq 0x8(%r15), %rax
testq %rax, %rax
je 0xa0b5c
movq (%rax), %rsi
jmp 0xa0b5e
xorl %esi, %esi
movq %r14, %rdx
callq 0x5a030
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movl %edi, %ebp
leaq 0xc07a9(%rip), %rdi     # 0x161330
callq 0x57820
movq %rax, %rbx
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0xa0bf7
leaq 0x8(%rax), %r14
movl 0x8(%rcx), %eax
movzbl %bpl, %ecx
leal (%rax,%rcx,8), %r15d
addl $-0x8, %r15d
xorl %r12d, %r12d
cmpl %r15d, %r12d
jge 0xa0bde
movq (%r14), %rdi
callq 0x6185c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xa0bce
callq 0x572d0
movq (%r14), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x18(%rax)
incl %r12d
jmp 0xa0bb4
testb %bpl, %bpl
je 0xa0c48
movq (%r14), %rdi
testq %rdi, %rdi
je 0xa0bf1
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, (%r14)
jmp 0xa0bfc
testb %bpl, %bpl
je 0xa0c48
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xa0c0e
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
movq %rax, %r14
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0xa0c25
callq 0x572d0
leaq 0x18(%r14), %r14
leaq 0x20(%rbx), %rbx
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xa0c40
callq 0x572d0
andq $0x0, (%r14)
andq $0x0, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
leaq 0xc06c7(%rip), %rdi     # 0x161330
callq 0x57820
leaq 0x8(%rax), %r14
movq (%r14), %rbx
testq %rbx, %rbx
jne 0xa0c93
pushq $0x58
popq %rdi
callq 0x56700
movq %rax, %rbx
movq %rax, %rdi
callq 0xa25e2
movq %rbx, (%r14)
cmpl $0x8, 0x8(%rbx)
jl 0xa0ca3
xorl %edi, %edi
callq 0x59720
movq (%r14), %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xa25f8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
pushq $0x58
popq %rsi
movq %rbx, %rdi
callq 0x564c0
movq %r14, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/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 0xa0dab
leaq 0x61453(%rip), %rax     # 0x1021c6
movq %rsi, %rdi
movq %rax, %rsi
callq 0x58b90
movq %rax, %r14
movq %rax, %rdi
callq 0x57460
movq %rax, %r15
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movl %r15d, %esi
callq 0x62d56
movq 0x8(%r12), %rax
testq %rax, %rax
je 0xa0db7
movq (%rax), %rdi
jmp 0xa0db9
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5a180
jmp 0xa0df7
xorl %edi, %edi
movslq %r15d, %rdx
movq %r14, %rsi
callq 0x566f0
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x57900
leaq 0x8(%rsp), %rsi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x59f90
leaq 0x8(%rsp), %rdi
callq 0x57020
leaq 0x10(%rsp), %rdi
callq 0x62d46
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x57020
jmp 0xa0e18
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x62d46
movq %rbx, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x10(%rsi)
je 0xa1026
movq %rsi, %r14
leaq 0xb4f96(%rip), %rax     # 0x155f70
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5a180
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x57900
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x5a3c0
leaq 0x8(%rsp), %rdi
callq 0x57020
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xa1032
movq (%rax), %rdx
jmp 0xa1034
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5a180
jmp 0xa104d
xorl %edx, %edx
leaq 0x6118b(%rip), %rsi     # 0x1021c6
movq %rbx, %rdi
callq 0x57ab0
leaq 0x10(%rsp), %rdi
callq 0x62d46
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0xa1069
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x57020
jmp 0xa106c
movq %rax, %r14
movq %rbx, %rdi
callq 0x5a588
jmp 0xa1079
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x62d46
movq %r14, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x60e38(%rip), %rax     # 0x1021c6
movq %rdi, %r14
movq %rax, %rdi
testq %r14, %r14
je 0xa138e
leaq 0xbff90(%rip), %rdi     # 0x161330
callq 0x57820
movq %rax, %r15
movq 0x18(%rax), %rbx
testq %rbx, %rbx
je 0xa13c3
movq %r14, %rdi
movq %rbx, %rsi
callq 0x58e40
testl %eax, %eax
je 0xa1419
leaq 0x18(%r15), %r13
andq $0x0, (%r13)
leaq 0x60df0(%rip), %r15     # 0x1021c6
movq %r14, %rdi
movq %r15, %rsi
callq 0x58e40
testl %eax, %eax
je 0xa140c
movq %r14, %rdi
callq 0x57460
incl %eax
movslq %eax, %r12
movq %r12, %rdi
callq 0x577a0
movq %rax, (%r13)
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x566f0
testq %rbx, %rbx
je 0xa141c
movq %rbx, %rdi
callq 0x59bf0
movq %rbx, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x60d68(%rip), %rax     # 0x1021c6
movq %rdi, %r14
movq %rax, %rdi
testq %r14, %r14
je 0xa145e
leaq 0xbfec0(%rip), %rdi     # 0x161330
callq 0x57820
movq %rax, %r15
movq 0x20(%rax), %rbx
testq %rbx, %rbx
je 0xa1493
movq %r14, %rdi
movq %rbx, %rsi
callq 0x58e40
testl %eax, %eax
je 0xa14e9
leaq 0x20(%r15), %r13
andq $0x0, (%r13)
leaq 0x60d20(%rip), %r15     # 0x1021c6
movq %r14, %rdi
movq %r15, %rsi
callq 0x58e40
testl %eax, %eax
je 0xa14dc
movq %r14, %rdi
callq 0x57460
incl %eax
movslq %eax, %r12
movq %r12, %rdi
callq 0x577a0
movq %rax, (%r13)
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x566f0
testq %rbx, %rbx
je 0xa14ec
movq %rbx, %rdi
callq 0x59bf0
movq %rbx, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
testl %esi, %esi
js 0xa17a9
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leal 0x1(%rbx), %eax
cmpl 0x10(%rdi), %eax
jl 0xa1791
movq %r14, %rdi
callq 0x58370
movl %eax, %ebp
xorl %r15d, %r15d
pushq $0xa
popq %rcx
movl %ebx, %eax
xorl %edx, %edx
divl %ecx
movl $0x186a0, %esi          # imm = 0x186A0
cmpl %esi, %eax
cmovbl %eax, %esi
cmpl $0xb, %esi
cmovbl %ecx, %esi
addl %ebx, %esi
movq %r14, %rdi
callq 0xa260a
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xa177c
movq (%rax), %r15
movslq %ebp, %rax
leaq (%r15,%rax,4), %rdi
movslq 0x10(%r14), %rdx
subq %rax, %rdx
xorl %esi, %esi
callq 0x57660
movq 0x8(%r14), %rcx
movl %ebx, %eax
shlq $0x2, %rax
addq (%rcx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc3830(%rip), %rax     # 0x164fe0
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x58370
movl %eax, %ebx
movq %r14, %rdi
callq 0x58370
movl %eax, %ecx
movl %ebx, %eax
subl %ecx, %eax
jne 0xa1912
testl %ebx, %ebx
jle 0xa1910
movq 0x8(%r15), %rax
testq %rax, %rax
je 0xa18ee
movq (%rax), %rdi
jmp 0xa18f0
xorl %edi, %edi
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xa18fe
movq (%rax), %rsi
jmp 0xa1900
xorl %esi, %esi
movl %ebx, %edx
callq 0x584e0
testl %eax, %eax
je 0xa1910
pushq $0x1
popq %rax
jmp 0xa1912
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/misc/string.cpp
// Function: smooth::String::operator==(smooth::String const&) const
S::Bool S::String::operator ==(const String &str) const
{
	if (wString.Size() == 0 && str.wString.Size() == 0) return True;
	if (wString.Size() == 0 && str.wString.Size() != 0) if (str.wString[0] == 0) return True;
	if (wString.Size() != 0 && str.wString.Size() == 0) if (wString[0] == 0) return True;
	if (wString.Size() == 0 || str.wString.Size() == 0) return False;

	if (!Compare(str)) return True;
	else		   return False;
}

// Assembly:
cmpl $0x0, 0x10(%rdi)
movl 0x10(%rsi), %eax
je 0xa19cd
testl %eax, %eax
je 0xa19d7
pushq %rax
callq 0x598b0
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
testl %eax, %eax
je 0xa19e5
movq 0x8(%rsi), %rax
jmp 0xa19db
movq 0x8(%rdi), %rax
movq (%rax), %rax
cmpl $0x0, (%rax)
sete %al
retq
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/misc/string.cpp
// Function: smooth::String::operator!=(smooth::String const&) const
S::Bool S::String::operator !=(const String &str) const
{
	if (wString.Size() == 0 && str.wString.Size() == 0) return False;
	if (wString.Size() == 0 && str.wString.Size() != 0) if (str.wString[0] == 0) return False;
	if (wString.Size() != 0 && str.wString.Size() == 0) if (wString[0] == 0) return False;
	if (wString.Size() == 0 || str.wString.Size() == 0) return True;

	if (Compare(str) != 0) return True;
	else		       return False;
}

// Assembly:
cmpl $0x0, 0x10(%rdi)
movl 0x10(%rsi), %eax
je 0xa1b51
testl %eax, %eax
je 0xa1b5b
pushq %rax
callq 0x598b0
testl %eax, %eax
setne %al
addq $0x8, %rsp
retq
testl %eax, %eax
je 0xa1b69
movq 0x8(%rsi), %rax
jmp 0xa1b5f
movq 0x8(%rdi), %rax
movq (%rax), %rax
cmpl $0x0, (%rax)
setne %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa1bb0
movq 0x8(%rsi), %rax
movq (%rax), %rsi
cmpl $0x0, (%rsi)
je 0xa1bb0
pushq $-0x1
popq %rbx
cmpl $0x0, 0x10(%rdi)
je 0xa1bb0
movq 0x8(%rdi), %rax
movq (%rax), %r14
cmpl $0x0, (%r14)
je 0xa1bb0
movq %r14, %rdi
callq 0x57360
testq %rax, %rax
je 0xa1bb0
subq %r14, %rax
shrq $0x2, %rax
movl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdi, %r14
cmpl $0x0, 0x10(%rsi)
je 0xa1c23
movq %rsi, %r15
movq 0x8(%rsi), %rax
movq (%rax), %rbx
cmpl $0x0, (%rbx)
je 0xa1c23
movq %r14, %rdi
callq 0x58370
movl %eax, %ebp
movq %r15, %rdi
callq 0x58370
subl %eax, %ebp
movq 0x8(%r14), %r12
movslq %eax, %r15
pushq $-0x1
popq %r14
testl %ebp, %ebp
js 0xa1c36
testq %r12, %r12
je 0xa1c08
movq (%r12), %rax
jmp 0xa1c0a
xorl %eax, %eax
movl %ebp, %ecx
leaq (%rax,%rcx,4), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x584e0
testl %eax, %eax
je 0xa1c33
decl %ebp
jmp 0xa1bf9
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x58370
movl %ebp, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
cmpl $0x0, 0x10(%rsi)
je 0xa1cc7
movq %rsi, %r14
movq 0x8(%rsi), %rax
movq (%rax), %rax
cmpl $0x0, (%rax)
je 0xa1cc7
movq %rbx, %rdi
callq 0x58370
movl %eax, %r12d
movq %r14, %rdi
callq 0x58370
movl %eax, %r15d
leal (%r15,%r12), %esi
incl %esi
movq %rbx, %rdi
callq 0xa260a
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xa1c94
movq (%rax), %rax
jmp 0xa1c96
xorl %eax, %eax
leal (%r15,%r12), %ebp
movslq %r12d, %rcx
leaq (%rax,%rcx,4), %rdi
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xa1caf
movq (%rax), %rsi
jmp 0xa1cb1
xorl %esi, %esi
movslq %r15d, %rdx
callq 0x5a030
movq 0x8(%rbx), %rax
movq (%rax), %rax
movslq %ebp, %rcx
andl $0x0, (%rax,%rcx,4)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 $0x48, %rsp
movq %rdx, 0x10(%rsp)
movq %rdi, %r14
movq %rsi, (%rsp)
cmpl $0x0, 0x10(%rsi)
je 0xa1ec3
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpl $0x0, (%rax)
je 0xa1ec3
movq %r14, %rdi
callq 0x58370
movl %eax, %r12d
movq (%rsp), %rdi
callq 0x58370
movl %eax, %r13d
movq 0x10(%rsp), %rdi
callq 0x58370
movslq %r13d, %rdx
movl %eax, %esi
movq %rdx, 0x20(%rsp)
subl %edx, %esi
movq %rsi, 0x40(%rsp)
leal 0x1(%rsi), %ecx
movq %rcx, 0x30(%rsp)
movl %eax, 0xc(%rsp)
cltq
leaq (,%rax,4), %rcx
movq %rcx, 0x28(%rsp)
movl %eax, %ecx
movq %rcx, 0x18(%rsp)
movq %rax, 0x38(%rsp)
decl %eax
movl %eax, 0x8(%rsp)
xorl %ebp, %ebp
movl %r12d, %eax
subl %r13d, %eax
cmpl %eax, %ebp
jg 0xa1ec3
movq 0x8(%r14), %rbx
testq %rbx, %rbx
je 0xa1de9
movq (%rbx), %rax
jmp 0xa1deb
xorl %eax, %eax
movq (%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0xa1dfd
movq (%rcx), %rsi
jmp 0xa1dff
xorl %esi, %esi
movslq %ebp, %r15
leaq (%rax,%r15,4), %rdi
movq 0x20(%rsp), %rdx
callq 0x584e0
testl %eax, %eax
jne 0xa1ebc
cmpl %r13d, 0xc(%rsp)
je 0xa1e7e
jle 0xa1e36
movq 0x30(%rsp), %rax
leal (%rax,%r12), %esi
movq %r14, %rdi
callq 0xa260a
movq 0x8(%r14), %rbx
testq %rbx, %rbx
je 0xa1e4d
movq (%rbx), %rax
leaq (%rax,%r15,4), %rcx
movq 0x38(%rsp), %rdx
leaq (%rcx,%rdx,4), %rdi
jmp 0xa1e58
movq 0x28(%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 (%r13,%rbp), %eax
negl %eax
addl %r12d, %eax
incl %eax
movslq %eax, %rdx
callq 0x57e00
addl 0x40(%rsp), %r12d
cmpl $0x0, 0x18(%rsp)
jle 0xa1eb8
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xa1e93
movq (%rax), %rax
jmp 0xa1e95
xorl %eax, %eax
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0xa1ea8
movq (%rcx), %rsi
jmp 0xa1eaa
xorl %esi, %esi
leaq (%rax,%r15,4), %rdi
movq 0x18(%rsp), %rdx
callq 0x5a030
addl 0x8(%rsp), %ebp
incl %ebp
jmp 0xa1dcd
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x58af0
testl %r14d, %r14d
jle 0xa1f99
leal 0x1(%r14), %esi
movq %rbx, %rdi
callq 0xa260a
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xa1f70
movq (%rax), %rdi
jmp 0xa1f72
xorl %edi, %edi
movq 0x8(%r15), %rax
testq %rax, %rax
je 0xa1f80
movq (%rax), %rsi
jmp 0xa1f82
xorl %esi, %esi
movl %r14d, %r14d
movq %r14, %rdx
callq 0x5a030
movq 0x8(%rbx), %rax
movq (%rax), %rax
andl $0x0, (%rax,%r14,4)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa1fcf
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0x58370
cmpl %ebx, %eax
jge 0xa1fd2
pushq $0x1
popq %rax
jmp 0xa2003
xorl %eax, %eax
retq
movq 0x8(%r15), %rax
testq %rax, %rax
je 0xa1fe0
movq (%rax), %rdi
jmp 0xa1fe2
xorl %edi, %edi
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xa1ff0
movq (%rax), %rsi
jmp 0xa1ff2
xorl %esi, %esi
movslq %ebx, %rdx
callq 0x584e0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0xa206c
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq 0x8(%rsi), %rcx
movq (%rcx), %rbx
cmpl $0x0, (%rbx)
je 0xa2062
movq %rdi, %r14
callq 0x58370
movl %eax, %ebp
movq %r15, %rdi
callq 0x58370
cmpl %eax, %ebp
jge 0xa2042
xorl %eax, %eax
jmp 0xa2062
movq 0x8(%r14), %rcx
testq %rcx, %rcx
je 0xa2050
movq (%rcx), %rdi
jmp 0xa2052
xorl %edi, %edi
movslq %eax, %rdx
movq %rbx, %rsi
callq 0x584e0
testl %eax, %eax
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0xa20e2
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq 0x8(%rsi), %rcx
movq (%rcx), %rbx
cmpl $0x0, (%rbx)
je 0xa20d8
movq %rdi, %r14
callq 0x58370
movl %eax, %ebp
movq %r15, %rdi
callq 0x58370
cmpl %eax, %ebp
jge 0xa20a6
xorl %eax, %eax
jmp 0xa20d8
movq 0x8(%r14), %rcx
testq %rcx, %rcx
je 0xa20b4
movq (%rcx), %rcx
jmp 0xa20b6
xorl %ecx, %ecx
movslq %ebp, %rdx
leaq (%rcx,%rdx,4), %rdi
movslq %eax, %rdx
leaq (,%rdx,4), %rax
subq %rax, %rdi
movq %rbx, %rsi
callq 0x584e0
testl %eax, %eax
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0xa2134
movl %edx, %ebp
movq %rsi, %r15
movq %rsi, %rdi
callq 0x58370
cmpl %ebp, %eax
jle 0xa2134
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5a180
leal 0x1(%r14), %esi
movq %rbx, %rdi
callq 0xa260a
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xa2140
movq (%rax), %rdi
jmp 0xa2142
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5a180
jmp 0xa216f
xorl %edi, %edi
movq 0x8(%r15), %rax
testq %rax, %rax
je 0xa2150
movq (%rax), %rax
jmp 0xa2152
xorl %eax, %eax
movl %ebp, %ecx
leaq (%rax,%rcx,4), %rsi
movl %r14d, %r14d
movq %r14, %rdx
callq 0x5a030
movq 0x8(%rbx), %rax
movq (%rax), %rax
andl $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 0x5a588
movq %r14, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/misc/string.cpp
// Function: smooth::String::Trim() const
S::String S::String::Trim() const
{
	Int	 length	= Length();
	Int	 triml	= 0;
	Int	 trimr	= 0;

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x58370
movl %eax, %r15d
xorl %ebp, %ebp
testl %eax, %eax
movl %eax, %r12d
cmovlel %ebp, %r12d
movabsq $0x100002e01, %r13      # imm = 0x100002E01
cmpl %ebp, %r12d
je 0xa2223
movq %r14, %rdi
movl %ebp, %esi
callq 0x59270
cmpl $0x20, %eax
ja 0xa2247
movl %eax, %eax
btq %rax, %r13
jae 0xa2247
incl %ebp
jmp 0xa2203
movl %r12d, %ebp
jmp 0xa2247
leal -0x1(%r15), %r12d
movq %r14, %rdi
movl %r12d, %esi
callq 0x59270
cmpl $0x20, %eax
ja 0xa224c
movl %eax, %eax
btq %rax, %r13
jae 0xa224c
movl %r12d, %r15d
testl %r15d, %r15d
jg 0xa2228
subl %ebp, %r15d
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %r15d, %ecx
callq 0x5a2c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x58af0
testl %r14d, %r14d
jle 0xa22f7
leal 0x1(%r14), %esi
movq %rbx, %rdi
callq 0xa260a
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xa22dc
movq (%rax), %rdi
jmp 0xa22de
xorl %edi, %edi
movl %r14d, %r14d
movl %ebp, %esi
movq %r14, %rdx
callq 0x57660
movq 0x8(%rbx), %rax
movq (%rax), %rax
andl $0x0, (%rax,%r14,4)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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, 0x8(%rsp)
callq 0x64972
movq %r15, %rdi
callq 0x58370
movl %eax, 0x14(%rsp)
xorl %r12d, %r12d
leaq 0x30(%rsp), %r13
movl 0x14(%rsp), %ebp
subl %r12d, %ebp
jle 0xa251a
movq %r13, %rdi
movq %r15, %rsi
movl %r12d, %edx
movl %ebp, %ecx
callq 0x5a2c0
movq %r13, %rdi
movq %r14, %rsi
callq 0x58830
movl %eax, %ebx
movq %r13, %rdi
callq 0x5a588
movq %r13, %rdi
xorl %esi, %esi
callq 0x5a180
cmpl $-0x1, %ebx
je 0xa24c0
leaq 0x18(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
movl %r12d, %edx
movl %ebx, %ecx
callq 0x5a2c0
movq %r13, %rdi
movq %rbp, %rsi
callq 0x56630
movq %rbp, %rdi
jmp 0xa24e3
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
movl %ebp, %ecx
callq 0x5a2c0
movq %r13, %rdi
movq %rbx, %rsi
callq 0x56630
movq %rbx, %rdi
callq 0x5a588
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x64dee
movq %r13, %rdi
callq 0x58370
movl %eax, %ebx
movq %r14, %rdi
callq 0x58370
addl %eax, %r12d
addl %ebx, %r12d
movq %r13, %rdi
callq 0x5a588
jmp 0xa245a
movq 0x8(%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa2543
jmp 0xa2532
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x5a588
jmp 0xa2546
jmp 0xa2543
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x5a588
jmp 0xa2557
jmp 0xa2554
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x64988
movq %rbx, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x5a180
cmpl 0x8(%r15), %ebp
jge 0xa25b1
testl %ebp, %ebp
je 0xa2598
movq %rbx, %rdi
movq %r14, %rsi
callq 0x573e0
movq %r15, %rdi
movl %ebp, %esi
callq 0x6bb28
movq %rbx, %rdi
movq %rax, %rsi
callq 0x573e0
incl %ebp
jmp 0xa2583
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5a588
movq %r14, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/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 0x58370
movl %eax, %ebp
movq (%r14), %rdi
pushq $0x4
popq %rcx
cltd
idivl %ecx
leal (%rax,%rax,2), %esi
incl %esi
callq 0x63b3a
movslq %ebp, %rax
movq %rax, 0x10(%rsp)
xorl %r12d, %r12d
pushq $0x3e
popq %r13
xorl %ebp, %ebp
cmpq 0x10(%rsp), %r12
jge 0xa6394
movaps 0x5bd82(%rip), %xmm0    # 0x102030
movaps %xmm0, (%rsp)
xorl %r15d, %r15d
cmpq $0x4, %r15
je 0xa6304
leal (%r12,%r15), %esi
movq %rbx, %rdi
callq 0x59270
leal -0x41(%rax), %ecx
cmpl $0x1a, %ecx
jb 0xa62e9
leal -0x61(%rax), %ecx
cmpl $0x19, %ecx
ja 0xa62dc
addl $-0x47, %eax
jmp 0xa62e7
leal -0x30(%rax), %ecx
cmpl $0x9, %ecx
ja 0xa62f2
addl $0x4, %eax
movl %eax, %ecx
movl %ecx, (%rsp,%r15,4)
incq %r15
jmp 0xa62b5
movl %r13d, %ecx
cmpl $0x2b, %eax
je 0xa62e9
cmpl $0x2f, %eax
jne 0xa62ed
pushq $0x3f
popq %rcx
jmp 0xa62e9
movl (%rsp), %ecx
cmpl $0x40, %ecx
je 0xa6394
movl 0x4(%rsp), %eax
cmpl $0x40, %eax
je 0xa6335
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 0xa635a
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 0xa637a
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
jmp 0xa629c
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_O2/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 %r15d, %r15d
xorl %esi, %esi
callq 0x5a180
movq %r14, %rdi
callq 0x58370
movl %eax, %ebp
leaq 0x38(%rsp), %rbx
xorl %r13d, %r13d
cmpl %ebp, %r15d
jge 0xa6695
movq %r14, %rdi
movl %r15d, %esi
callq 0x59270
cmpl $0x25, %eax
jne 0xa666c
leal 0x1(%r15), %edx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
pushq $0x2
popq %rcx
callq 0x5a2c0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x56ab0
movq %rbx, %rdi
callq 0x5a280
movq %rax, %r12
leaq 0x8(%rsp), %rdi
movl %r13d, %esi
callq 0x59cc0
movl %r12d, (%rax)
movq %rbx, %rdi
callq 0x5a0b0
leaq 0x20(%rsp), %rdi
callq 0x5a588
addl $0x2, %r15d
jmp 0xa668a
movq %r14, %rdi
movl %r15d, %esi
callq 0x59270
movl %eax, %r12d
leaq 0x8(%rsp), %rdi
movl %r13d, %esi
callq 0x59cc0
movl %r12d, (%rax)
incl %r13d
incl %r15d
jmp 0xa65fe
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x5a180
leaq 0x5b49a(%rip), %rsi     # 0x101b41
leaq 0x8(%rsp), %rdi
movq (%rsp), %r14
callq 0x58b90
leaq 0x5bb0a(%rip), %rsi     # 0x1021c6
movq %r14, %rdi
movq %rax, %rdx
callq 0x57ab0
leaq 0x8(%rsp), %rdi
callq 0x5a588
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 0xa6706
jmp 0xa670d
jmp 0xa670d
movq %rax, %rbx
jmp 0xa6701
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x5a0b0
leaq 0x20(%rsp), %rdi
callq 0x5a588
jmp 0xa6710
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/misc/hash/crc16.cpp
// Function: smooth::Hash::CRC16::InitTable()
S::Bool S::Hash::CRC16::InitTable()
{
	UnsignedInt16	 polynomial = 0x8005;

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

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

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

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

	return True;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %r15d, %r15d
pushq $0x8
popq %rbx
pushq $0x10
popq %rbp
movq 0xbb6fd(%rip), %r14     # 0x161e38
cmpq $0x100, %r15            # imm = 0x100
je 0xa677d
movzwl %r15w, %edi
movl %ebx, %esi
callq 0x561e0
shll $0x8, %eax
movl %ebx, %ecx
subl $0x1, %ecx
jb 0xa6769
leal (%rax,%rax), %edx
cwtl
sarl $0xf, %eax
andl $0xffff8005, %eax       # imm = 0xFFFF8005
xorl %edx, %eax
jmp 0xa6754
movzwl %ax, %edi
movl %ebp, %esi
callq 0x561e0
movw %ax, (%r14,%r15,2)
incq %r15
jmp 0xa673b
xorl %eax, %eax
movq %r14, %rcx
cmpq $0x100, %rax            # imm = 0x100
je 0xa67c2
movl $0x200, %edx            # imm = 0x200
cmpq $0x1000, %rdx           # imm = 0x1000
je 0xa67b9
movzwl -0x200(%rcx,%rdx), %esi
movzbl %sil, %edi
shrl $0x8, %esi
xorw (%r14,%rdi,2), %si
movw %si, (%rcx,%rdx)
addq $0x200, %rdx            # imm = 0x200
jmp 0xa678f
incq %rax
addq $0x2, %rcx
jmp 0xa6782
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
leal -0x1(%rsi), %ecx
pushq $0x1
popq %rdx
xorl %eax, %eax
movl %edx, %r8d
cmpl %esi, %r8d
jg 0xa6812
movl %edi, %r9d
andl $0x1, %r9d
negl %r9d
movzwl %di, %edi
movl %edx, %r10d
shll %cl, %r10d
andl %r9d, %r10d
orl %r10d, %eax
shrl %edi
incl %r8d
decl %ecx
jmp 0xa67eb
retq
nop