LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/args.cpp
// Function: smooth::ArgumentsParser::ArgumentsParser(smooth::String const&)
S::ArgumentsParser::ArgumentsParser(const String &commandLine)
{
	String	 param;
	Bool	 quoted	= False;
	Bool	 first	= True;

	for (Int i = 0, j = 0; i <= commandLine.Length(); i++)
	{
		if ((commandLine[i] == ' ' && !quoted && commandLine[i - 1] != '\\') || i == commandLine.Length())
		{
			if (!param.Length()) continue;

			if (first) command = param;
			else	   args.Add(param);

			first = False;
			param = NIL;
			j     = 0;
		}
		else if (commandLine[i] == '\"')
		{
			quoted = !quoted;
		}
		else if (!(commandLine[i] == '\\' && commandLine[i + 1] == ' '))
		{
			param[j++] = commandLine[i];
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorl %esi, %esi
callq 0x58e20
leaq 0x18(%rbx), %rdi
movq %rdi, 0x8(%rsp)
callq 0x55d90
leaq 0xbe37e(%rip), %rax     # 0x161290
movq %rax, 0x58(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
leaq 0xbe2cc(%rip), %rax     # 0x1611f0
movq %rbx, (%rsp)
movq %rax, 0x18(%rbx)
leaq 0x10(%rsp), %rdi
xorl %r13d, %r13d
xorl %esi, %esi
callq 0x58e20
movb $0x1, %r12b
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %ebx, %ebx
movl %ebp, %r14d
movq %r15, %rdi
callq 0x57180
leal 0x1(%r14), %ebp
cmpl %eax, %ebp
jg 0xa3036
movq %r15, %rdi
movl %ebp, %esi
callq 0x57fe0
cmpl $0x20, %eax
jne 0xa2f80
testb $0x1, %bl
jne 0xa2f80
movq %r15, %rdi
movl %r14d, %esi
callq 0x57fe0
cmpl $0x5c, %eax
jne 0xa2f8c
movq %r15, %rdi
callq 0x57180
cmpl %eax, %ebp
jne 0xa2fb0
leaq 0x10(%rsp), %rdi
callq 0x57180
testl %eax, %eax
je 0xa2f45
testb $0x1, %r12b
je 0xa3010
movq (%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x555f0
jmp 0xa301f
movq %r15, %rdi
movl %ebp, %esi
callq 0x57fe0
cmpl $0x22, %eax
jne 0xa2fc4
xorb $0x1, %bl
jmp 0xa2f45
movq %r15, %rdi
movl %ebp, %esi
callq 0x57fe0
cmpl $0x5c, %eax
jne 0xa2feb
addl $0x2, %r14d
movq %r15, %rdi
movl %r14d, %esi
callq 0x57fe0
cmpl $0x20, %eax
je 0xa2f45
movq %r15, %rdi
movl %ebp, %esi
callq 0x57fe0
movl %eax, %r14d
leaq 0x10(%rsp), %rdi
movl %r13d, %esi
callq 0x58990
incl %r13d
movl %r14d, (%rax)
jmp 0xa2f45
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x64280
xorl %r12d, %r12d
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x579e0
xorl %r13d, %r13d
jmp 0xa2f45
leaq 0x10(%rsp), %rdi
callq 0x59200
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xa3066
movq %rax, %r14
jmp 0xa3074
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x59200
movq 0x8(%rsp), %rdi
callq 0x63e08
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x59200
movq %r14, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/array.cpp
// Function: smooth::IndexArray::IndexArray()
S::IndexArray::IndexArray()
{
	nOfEntries	  = 0;
	greatestIndex	  = 0;

	sorted		  = True;

	lastAccessedEntry = 0;

	lockingEnabled	  = False;
	lock		  = NIL;
}

// Assembly:
movq 0xc9855(%rip), %rax     # 0x16c8f8
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0xc6d27(%rip), %rax     # 0x169dd8
movq %rax, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb $0x1, 0x10(%rdi)
movl $0x0, 0x14(%rdi)
movb $0x0, 0x30(%rdi)
movq %rax, 0x38(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/array.cpp
// Function: smooth::IndexArray::InsertAtPos(int, int)
S::Bool S::IndexArray::InsertAtPos(Int position, Int index)
{
	WriteLock	 lock(*this);

	if (position > nOfEntries || position < 0) return False;

	if (!IndexAvailable(index)) return False;

	if (greatestIndex < index) greatestIndex = index;

	if (indices.Size() == nOfEntries) indices.Resize(8 > nOfEntries * 1.25 ? 8 : nOfEntries * 1.25);

	memmove(indices + position + 1, indices + position, (nOfEntries - position) * sizeof(Int));

	indices[position] = index;

	nOfEntries++;

	if ((position >=	      1 && indices[position - 1] > index) ||
	    (position <  nOfEntries - 1 && indices[position + 1] < index)) sorted = False;

	return True;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq %rdi, 0x8(%rsp)
cmpb $0x1, 0x30(%rdi)
jne 0xa3170
movq 0x38(%rbx), %rdi
callq 0x551d0
xorl %r15d, %r15d
testl %r14d, %r14d
js 0xa3242
cmpl %r14d, 0x8(%rbx)
jl 0xa3242
movq %rbx, %rdi
movl %ebp, %esi
callq 0x58f20
testb %al, %al
je 0xa31d7
cmpl %ebp, 0xc(%rbx)
jge 0xa319c
movl %ebp, 0xc(%rbx)
movl 0x8(%rbx), %eax
cmpl %eax, 0x28(%rbx)
jne 0xa31c9
leaq 0x18(%rbx), %rdi
cvtsi2sd %eax, %xmm0
mulsd 0x50e4c(%rip), %xmm0    # 0xf4000
movsd 0x50e4c(%rip), %xmm1    # 0xf4008
maxsd %xmm0, %xmm1
cvttsd2si %xmm1, %esi
callq 0xa3732
movq 0x20(%rbx), %rcx
testq %rcx, %rcx
je 0xa31dc
movq (%rcx), %rax
jmp 0xa31de
xorl %r15d, %r15d
jmp 0xa3242
xorl %eax, %eax
testq %rcx, %rcx
je 0xa31e8
movq (%rcx), %rcx
jmp 0xa31ea
xorl %ecx, %ecx
movl %r14d, %r12d
leaq (%rax,%r12,4), %rdi
addq $0x4, %rdi
leaq (%rcx,%r12,4), %rsi
movslq 0x8(%rbx), %rdx
movslq %r14d, %rax
subq %rax, %rdx
shlq $0x2, %rdx
callq 0x556d0
movq 0x20(%rbx), %rax
movq (%rax), %rax
movl %ebp, (%rax,%r12,4)
movl 0x8(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbx)
testl %r14d, %r14d
jle 0xa322c
cmpl %ebp, -0x4(%rax,%r12,4)
jg 0xa323b
movb $0x1, %r15b
cmpl %r14d, %ecx
jle 0xa3242
cmpl %ebp, 0x4(%rax,%r12,4)
jge 0xa3242
movb $0x0, 0x10(%rbx)
movb $0x1, %r15b
leaq 0x8(%rsp), %rdi
callq 0x56310
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x56310
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/array.cpp
// Function: smooth::IndexArray::IndexAvailable(int) const
S::Bool S::IndexArray::IndexAvailable(Int index) const
{
	ReadLock	 lock(*this);

	if (index > greatestIndex) return True;

	if (GetEntryNumberByIndex(index) == -1) return True;
	else					return False;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq %rdi, 0x8(%rsp)
cmpb $0x1, 0x30(%rdi)
jne 0xa3293
movq 0x38(%r14), %rdi
callq 0x56d10
movb $0x1, %bpl
cmpl %ebx, 0xc(%r14)
jl 0xa32ad
movq %r14, %rdi
movl %ebx, %esi
callq 0x58a20
cmpl $-0x1, %eax
sete %bpl
leaq 0x8(%rsp), %rdi
callq 0x578e0
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x578e0
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/array.cpp
// Function: smooth::IndexArray::Move(int, int)
S::Bool S::IndexArray::Move(Int index1, Int index2)
{
	WriteLock	 lock(*this);

	if (index1 > greatestIndex ||
	    index2 > greatestIndex) return False;

	return MoveNth(GetEntryNumberByIndex(index1), GetEntryNumberByIndex(index2));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq %rdi, 0x8(%rsp)
cmpb $0x1, 0x30(%rdi)
jne 0xa32fc
movq 0x38(%rbx), %rdi
callq 0x551d0
movl 0xc(%rbx), %eax
cmpl %r14d, %eax
setl %cl
cmpl %ebp, %eax
setl %al
orb %cl, %al
je 0xa3312
xorl %ebx, %ebx
jmp 0xa333a
movq %rbx, %rdi
movl %r14d, %esi
callq 0x58a20
movl %eax, %r14d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x58a20
movq (%rbx), %rcx
movq %rbx, %rdi
movl %r14d, %esi
movl %eax, %edx
callq *0x10(%rcx)
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x56310
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x56310
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/array.cpp
// Function: smooth::IndexArray::GetEntryNumberByIndex(int) const
S::Int S::IndexArray::GetEntryNumberByIndex(Int index) const
{
	ReadLock	 lock(*this);

	if (nOfEntries == 0) return -1;

	Int	 entryNumber  = -1;
	Int	 lastAccessed = lastAccessedEntry;

	/* Check entries around last accessed entry.
	 */
	if	(lastAccessed     <  nOfEntries && indices[lastAccessed    ] == index) entryNumber = lastAccessed;
	else if (lastAccessed     >  0 &&
		 lastAccessed     <= nOfEntries && indices[lastAccessed - 1] == index) entryNumber = lastAccessed - 1;
	else if (lastAccessed + 1 <  nOfEntries && indices[lastAccessed + 1] == index) entryNumber = lastAccessed + 1;

	/* Binary search for sorted lists.
	 */
	else if (sorted)
	{
		Int	 bottom = 0;
		Int	 top	= nOfEntries - 1;

		while (top >= bottom)
		{
			Int	 i = (top + bottom) / 2;
			Int	 e = indices[i];

			if (e == index) { entryNumber = i; break; }

			if (e < index) bottom = i + 1;
			else	       top    = i - 1;
		}
	}

	/* Linear search otherwise.
	 */
	else
	{
		for (Int i = 0; i < nOfEntries; i++)
		{
			if (indices[i] == index) { entryNumber = i; break; }
		}
	}

	if (entryNumber >= 0) lastAccessedEntry = entryNumber;

	return entryNumber;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq %rdi, 0x8(%rsp)
cmpb $0x1, 0x30(%rdi)
jne 0xa3385
movq 0x38(%rbx), %rdi
callq 0x56d10
movl 0x8(%rbx), %eax
testq %rax, %rax
je 0xa33cf
movl 0x14(%rbx), %r14d
movslq %r14d, %rcx
cmpl %eax, %ecx
jge 0xa33a8
movq 0x20(%rbx), %rdx
movq (%rdx), %rdx
cmpl %ebp, (%rdx,%rcx,4)
je 0xa344b
testl %r14d, %r14d
setle %dl
cmpl %eax, %r14d
setg %sil
orb %dl, %sil
jne 0xa33d7
movq 0x20(%rbx), %rdx
movq (%rdx), %rdx
cmpl %ebp, -0x4(%rdx,%rcx,4)
jne 0xa33d7
decq %rcx
movl %ecx, %r14d
jmp 0xa344b
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0xa3454
leal 0x1(%rcx), %r14d
cmpl %eax, %r14d
jge 0xa33ed
movq 0x20(%rbx), %rdx
movq (%rdx), %rdx
cmpl %ebp, 0x4(%rdx,%rcx,4)
je 0xa344b
cmpb $0x0, 0x10(%rbx)
je 0xa342b
decl %eax
movq 0x20(%rbx), %rcx
xorl %edx, %edx
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
cmpl %edx, %eax
jl 0xa344b
leal (%rax,%rdx), %edi
shrl %edi
movq (%rcx), %rsi
movl (%rsi,%rdi,4), %esi
cmpl %ebp, %esi
jne 0xa3419
movl %edi, %r14d
jmp 0xa3425
jl 0xa3421
decl %edi
movl %edi, %eax
jmp 0xa3425
incl %edi
movl %edi, %edx
cmpl %ebp, %esi
jne 0xa3401
jmp 0xa344b
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0xa344b
movq 0x20(%rbx), %rcx
movq (%rcx), %rdx
xorl %ecx, %ecx
cmpl %ebp, (%rdx,%rcx,4)
je 0xa33ca
incq %rcx
cmpq %rcx, %rax
jne 0xa343e
testl %r14d, %r14d
js 0xa3454
movl %r14d, 0x14(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x578e0
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/array.cpp
// Function: smooth::IndexArray::MoveNth(int, int)
S::Bool S::IndexArray::MoveNth(Int n, Int m)
{
	WriteLock	 lock(*this);

	if (nOfEntries <= n || n < 0 ||
	    nOfEntries <= m || m < 0) return False;

	Int	 backupIndex = indices[n];

	if (m < n) memmove(indices + m + 1, indices + m, (n - m) * sizeof(Int));
	else	   memmove(indices + n, indices + n + 1, (m - n) * sizeof(Int));

	indices[m] = backupIndex;

	sorted = False;

	return True;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
movq %rdi, 0x8(%rsp)
cmpb $0x1, 0x30(%rdi)
jne 0xa3492
movq 0x38(%rbx), %rdi
callq 0x551d0
movl 0x8(%rbx), %eax
cmpl %ebp, %eax
setle %cl
testl %ebp, %ebp
sets %dl
orb %cl, %dl
jne 0xa34b3
cmpl %r14d, %eax
setle %al
testl %r14d, %r14d
sets %cl
orb %al, %cl
je 0xa34b7
xorl %ebx, %ebx
jmp 0xa350b
movq 0x20(%rbx), %rax
movq (%rax), %rax
movl %ebp, %ecx
movl (%rax,%rcx,4), %r15d
movl %r14d, %edx
movl %r14d, %r12d
subl %ebp, %edx
jge 0xa34e2
leaq (%rax,%r12,4), %rsi
leaq (%rax,%r12,4), %rdi
addq $0x4, %rdi
subl %r14d, %ebp
movslq %ebp, %rdx
jmp 0xa34f1
leaq (%rax,%rcx,4), %rdi
leaq (%rax,%rcx,4), %rsi
addq $0x4, %rsi
movslq %edx, %rdx
shlq $0x2, %rdx
callq 0x556d0
movq 0x20(%rbx), %rax
movq (%rax), %rax
movl %r15d, (%rax,%r12,4)
movb $0x0, 0x10(%rbx)
movb $0x1, %bl
leaq 0x8(%rsp), %rdi
callq 0x56310
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/array.cpp
// Function: smooth::IndexArray::RemoveNth(int)
S::Bool S::IndexArray::RemoveNth(Int n)
{
	WriteLock	 lock(*this);

	if (nOfEntries <= n || n < 0) return False;

	if (nOfEntries == 1) return RemoveAll();

	memmove(indices + n, indices + n + 1, (nOfEntries - n - 1) * sizeof(Int));

	nOfEntries--;

	return True;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq %rdi, (%rsp)
cmpb $0x1, 0x30(%rdi)
jne 0xa359f
movq 0x38(%rbx), %rdi
callq 0x551d0
movl 0x8(%rbx), %eax
cmpl %ebp, %eax
setle %cl
testl %ebp, %ebp
sets %dl
orb %cl, %dl
je 0xa35b4
xorl %ebx, %ebx
jmp 0xa3605
cmpl $0x1, %eax
jne 0xa35c6
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
movl %eax, %ebx
jmp 0xa3605
movq 0x20(%rbx), %rdx
testq %rdx, %rdx
je 0xa35d4
movq (%rdx), %rcx
jmp 0xa35d6
xorl %ecx, %ecx
testq %rdx, %rdx
je 0xa35e0
movq (%rdx), %rdx
jmp 0xa35e2
xorl %edx, %edx
movl %ebp, %esi
leaq (%rcx,%rsi,4), %rdi
leaq (%rdx,%rsi,4), %rsi
addq $0x4, %rsi
notl %ebp
addl %ebp, %eax
movslq %eax, %rdx
shlq $0x2, %rdx
callq 0x556d0
decl 0x8(%rbx)
movb $0x1, %bl
movq %rsp, %rdi
callq 0x56310
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x56310
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/array.cpp
// Function: smooth::IndexArray::RemoveAll()
S::Bool S::IndexArray::RemoveAll()
{
	WriteLock	 lock(*this);

	if (nOfEntries == 0) return True;

	indices.Free();

	nOfEntries	  = 0;
	greatestIndex	  = 0;

	sorted		  = True;

	lastAccessedEntry = 0;

	return True;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rdi, 0x8(%rsp)
cmpb $0x1, 0x30(%rdi)
jne 0xa3646
movq 0x38(%rbx), %rdi
callq 0x551d0
cmpl $0x0, 0x8(%rbx)
je 0xa3668
leaq 0x18(%rbx), %rdi
callq 0xa37b8
movq $0x0, 0x8(%rbx)
movb $0x1, 0x10(%rbx)
movl $0x0, 0x14(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x56310
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/binary.cpp
// Function: smooth::Binary::GetBits(int, unsigned int, unsigned int)
S::Int S::Binary::GetBits(Int n, UnsignedInt startBit, UnsignedInt endBit)
{
	Int	retVal = 0;

	if (startBit >= 32 || endBit >= 32) return -1;

	for (UnsignedInt i = startBit; i <= endBit; i++)
	{
		retVal += (Int) Math::Pow(2l, (Signed) i - (Signed) startBit) * ((n >> i) & 1);
	}

	return retVal;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %eax
orl %esi, %eax
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpl $0x1f, %eax
ja 0xa38fd
movl %edx, %ebx
movl %esi, %r14d
xorl %r15d, %r15d
cmpl %edx, %esi
ja 0xa38fd
movl %edi, %ebp
subl %r14d, %ebx
incl %ebx
xorl %r12d, %r12d
xorl %r15d, %r15d
leal (%r14,%r12), %r13d
movl $0x2, %edi
movl %r12d, %esi
callq 0x56010
cvttsd2si %xmm0, %eax
btl %r13d, %ebp
movl $0x0, %ecx
cmovael %ecx, %eax
addl %eax, %r15d
incl %r12d
cmpl %r12d, %ebx
jne 0xa38d1
movl %r15d, %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/binary.cpp
// Function: smooth::Binary::SetBits(int&, unsigned int, unsigned int, int)
S::Int S::Binary::SetBits(Int &n, UnsignedInt startBit, UnsignedInt endBit, Int value)
{
	if (startBit >= 32 || endBit >= 32) return -1;

	for (UnsignedInt i = startBit; i <= endBit; i++)
	{
		SetBit(n, i, (value >> (i - startBit)) & 1);
	}

	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %ecx
orl %esi, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x1f, %ecx
ja 0xa395c
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
cmpl %edx, %esi
ja 0xa3959
subl %r15d, %ebp
incl %ebp
xorl %r12d, %r12d
leal (%r15,%r12), %esi
xorl %edx, %edx
btl %r12d, %ebx
setb %dl
movq %r14, %rdi
callq 0x557f0
incl %r12d
cmpl %r12d, %ebp
jne 0xa393c
movl (%r14), %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/config.cpp
// Function: smooth::Configuration::Configuration(smooth::String const&, bool)
S::Configuration::Configuration(const String &file, Bool create)
{
	ownRoot = NIL;

	configFile = NIL;

	activeConfig = ConfigurationDefaultID;

	Open(file, create);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
xorl %esi, %esi
callq 0x58e20
leaq 0x18(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x58e20
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
leaq 0xcc30c(%rip), %rsi     # 0x16fd30
movq %r14, %rdi
callq 0x555f0
movzbl %bpl, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x55460
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0xa3a56
movq %rax, %r15
movq %r14, %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x59200
movq %r15, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/config.cpp
// Function: smooth::Configuration::Close()
S::Int S::Configuration::Close()
{
	if (configFile != NIL)
	{
		delete configFile;

		configFile = NIL;

		fileName = NIL;
	}

	if (ownRoot != NIL)
	{
		delete ownRoot;

		ownRoot = NIL;
	}

	return Success();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %r14
testq %r14, %r14
je 0xa3e0d
movq %r14, %rdi
callq 0x55400
movl $0x28, %esi
movq %r14, %rdi
callq 0x55480
movq $0x0, 0x30(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x579e0
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0xa3e33
movq %r14, %rdi
callq 0x55f80
movl $0x30, %esi
movq %r14, %rdi
callq 0x55480
movq $0x0, 0x38(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/config.cpp
// Function: smooth::Configuration::Save()
S::Int S::Configuration::Save()
{
	if (configFile == NIL) return Error();

	XML::Node	*root = configFile->GetRootNode();

	if (fileName != NIL && root != NIL)
	{
		/* Create base directory first.
		 */
		Directory(File(fileName).GetFilePath()).Create();

		/* Save config file.
		 */
		XML::Node	*configurationNode = root->GetNodeByName(NodeConfigurationID);

		if (configurationNode != NIL && configurationNode->GetNOfNodes() >= 1) configFile->SaveFile(fileName);
	}

	return Success();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0xa3f2b
callq 0x56e60
movq %rax, %r14
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x56bd0
xorb $0x1, %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0xa3f30
leaq 0x20(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x58e20
leaq 0x38(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x56800
leaq 0x38(%rsp), %rdi
callq 0x580e0
movq %rax, %r15
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x58e20
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r15, %rsi
callq 0x58c60
leaq 0x68(%rsp), %rdi
callq 0x55930
leaq 0x68(%rsp), %rdi
callq 0x59210
leaq 0x8(%rsp), %rdi
callq 0x59200
leaq 0x38(%rsp), %rdi
callq 0x59178
leaq 0x20(%rsp), %rdi
callq 0x59200
leaq 0xcbe46(%rip), %rsi     # 0x16fd48
movq %r14, %rdi
callq 0x56810
xorl %ebp, %ebp
testq %rax, %rax
je 0xa3f30
movq %rax, %rdi
callq 0x56050
testl %eax, %eax
jle 0xa3f30
movq 0x30(%rbx), %rdi
movq %rbx, %rsi
callq 0x579c0
jmp 0xa3f30
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x59210
jmp 0xa3f52
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x59200
jmp 0xa3f63
jmp 0xa3f60
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x59178
jmp 0xa3f72
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/config.cpp
// Function: smooth::Configuration::AddConfiguration(smooth::String const&)
S::Int S::Configuration::AddConfiguration(const String &nConfig)
{
	if (configFile == NIL) return Error();

	XML::Node	*configuration = FindConfigurationNode(nConfig);

	if (configuration == NIL)
	{
		configFile->GetRootNode()->AddNode(NodeConfigurationID)->SetAttribute(AttributeNameID, nConfig);

		return Success();
	}

	return Error();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpq $0x0, 0x30(%rdi)
je 0xa3ff1
movq %rsi, %rbx
movq %rdi, %r14
callq 0x576f0
testq %rax, %rax
jne 0xa3ff1
movq 0x30(%r14), %rdi
callq 0x56e60
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x58e20
leaq 0xcbd7e(%rip), %rsi     # 0x16fd48
movq %r14, %rdi
movq %r15, %rdx
callq 0x55820
leaq 0xcbdcc(%rip), %rsi     # 0x16fda8
movq %rax, %rdi
movq %rbx, %rdx
callq 0x581c0
movq %rsp, %rdi
callq 0x59200
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/config.cpp
// Function: smooth::Configuration::FindConfigurationNode(smooth::String const&) const
S::XML::Node *S::Configuration::FindConfigurationNode(const String &configuration) const
{
	XML::Node	*root = configFile->GetRootNode();

	if (root == NIL) return NIL;

	for (Int i = 0; i < root->GetNOfNodes(); i++)
	{
		XML::Node	*node = root->GetNthNode(i);

		if (node->GetName() != NodeConfigurationID) continue;

		XML::Attribute	*attributeName = node->GetAttributeByName(AttributeNameID);

		if (attributeName != NIL && attributeName->GetContent() == configuration) return node;
	}

	return NIL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x30(%rdi), %rdi
callq 0x56e60
testq %rax, %rax
je 0xa40be
movq %rax, %r14
movq %rax, %rdi
callq 0x56050
testl %eax, %eax
jle 0xa40be
leaq 0xcbd00(%rip), %r15     # 0x16fd48
xorl %ebp, %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x57e20
movq %rax, %r13
movq %rax, %rdi
callq 0x57d50
movq %rax, %rdi
movq %r15, %rsi
callq 0x56fa0
movl $0x4, %ecx
testb %al, %al
jne 0xa40a5
movq %r13, %rdi
leaq 0xcbd2b(%rip), %rsi     # 0x16fda8
callq 0x58d10
testq %rax, %rax
je 0xa40a3
movq %rax, %rdi
callq 0x55720
movq %rax, %rdi
movq %rbx, %rsi
callq 0x55900
movl $0x1, %ecx
testb %al, %al
jne 0xa40a8
xorl %ecx, %ecx
movq %r12, %r13
testb $0x3, %cl
jne 0xa40c1
incl %ebp
movq %r14, %rdi
callq 0x56050
movq %r13, %r12
cmpl %eax, %ebp
jl 0xa404a
xorl %r13d, %r13d
movq %r13, %rax
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/config.cpp
// Function: smooth::Configuration::RemoveConfiguration(smooth::String const&)
S::Int S::Configuration::RemoveConfiguration(const String &rConfig)
{
	if (configFile == NIL) return Error();

	XML::Node	*configuration = FindConfigurationNode(rConfig);

	if (configuration != NIL)
	{
		if (activeConfig == rConfig) SetActiveConfiguration(ConfigurationDefaultID);

		configFile->GetRootNode()->RemoveNode(configuration);

		return Success();
	}

	return Error();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpq $0x0, 0x30(%rdi)
je 0xa412f
movq %rsi, %r15
movq %rdi, %rbx
callq 0x576f0
testq %rax, %rax
je 0xa412f
movq %rax, %r14
leaq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0x55900
testb %al, %al
je 0xa4119
leaq 0xcbc1f(%rip), %rsi     # 0x16fd30
movq %rbx, %rdi
callq 0x56630
movq 0x30(%rbx), %rdi
callq 0x56e60
movq %rax, %rdi
movq %r14, %rsi
callq 0x57e50
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/config.cpp
// Function: smooth::Configuration::SetActiveConfiguration(smooth::String const&)
S::Int S::Configuration::SetActiveConfiguration(const String &nConfig)
{
	if (configFile == NIL) return Error();

	XML::Node	*configuration = FindConfigurationNode(nConfig);

	if (configuration == NIL) AddConfiguration(nConfig);

	activeConfig = nConfig;

	return Success();
}

// Assembly:
cmpq $0x0, 0x30(%rdi)
je 0xa417b
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x576f0
testq %rax, %rax
jne 0xa4162
movq %r14, %rdi
movq %rbx, %rsi
callq 0x56290
addq $0x18, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x555f0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/config.cpp
// Function: smooth::Configuration::GetNOfConfigurations() const
S::Int S::Configuration::GetNOfConfigurations() const
{
	XML::Node	*root = configFile->GetRootNode();

	if (root == NIL) return 0;

	Int	 count = 0;

	for (Int i = 0; i < root->GetNOfNodes(); i++)
	{
		XML::Node	*node = root->GetNthNode(i);

		if (node->GetName() != NodeConfigurationID) continue;

		count++;
	}

	return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x30(%rdi), %rdi
callq 0x56e60
xorl %ebp, %ebp
testq %rax, %rax
je 0xa41e9
movq %rax, %rbx
movq %rax, %rdi
callq 0x56050
testl %eax, %eax
jle 0xa41e9
xorl %r14d, %r14d
leaq 0xcbb96(%rip), %r15     # 0x16fd48
xorl %ebp, %ebp
movq %rbx, %rdi
movl %r14d, %esi
callq 0x57e20
movq %rax, %rdi
callq 0x57d50
movq %rax, %rdi
movq %r15, %rsi
callq 0x56fa0
xorb $0x1, %al
movzbl %al, %eax
addl %eax, %ebp
incl %r14d
movq %rbx, %rdi
callq 0x56050
cmpl %eax, %r14d
jl 0xa41b4
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/config.cpp
// Function: smooth::Configuration::GetNthConfigurationName(int) const
S::String S::Configuration::GetNthConfigurationName(Int n) const
{
	XML::Node	*root = configFile->GetRootNode();

	if (root == NIL) return NIL;

	Int	 count = 0;

	for (Int i = 0; i < root->GetNOfNodes(); i++)
	{
		XML::Node	*node = root->GetNthNode(i);

		if (node->GetName() != NodeConfigurationID) continue;

		if (count++ == n)
		{
			XML::Attribute	*attributeName = node->GetAttributeByName(AttributeNameID);

			if (attributeName != NIL) return attributeName->GetContent();
			else			  return NIL;
		}
	}

	return NIL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, 0x14(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x30(%rsi), %rdi
callq 0x56e60
testq %rax, %rax
je 0xa42ca
movq %rax, %r14
movq %rax, %rdi
callq 0x56050
testl %eax, %eax
jle 0xa42ca
xorl %ebx, %ebx
leaq 0xcbb0d(%rip), %r15     # 0x16fd48
xorl %r13d, %r13d
movq %r14, %rdi
movl %r13d, %esi
callq 0x57e20
movq %rax, %r12
movq %rax, %rdi
callq 0x57d50
movq %rax, %rdi
movq %r15, %rsi
callq 0x56fa0
movl $0x4, %ecx
testb %al, %al
jne 0xa42b1
leal 0x1(%rbx), %ebp
xorl %ecx, %ecx
cmpl 0x14(%rsp), %ebx
jne 0xa42af
movq %r12, %rdi
leaq 0xcbb2b(%rip), %rsi     # 0x16fda8
callq 0x58d10
testq %rax, %rax
je 0xa429e
movq %rax, %rdi
callq 0x55720
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x570b0
jmp 0xa42aa
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x58e20
movl $0x1, %ecx
movl %ebp, %ebx
testb $0x3, %cl
jne 0xa42eb
incl %r13d
movq %r14, %rdi
callq 0x56050
cmpl %eax, %r13d
jl 0xa423e
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58e20
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rax
jmp 0xa42dc
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/config.cpp
// Function: smooth::Configuration::SetParentConfiguration(smooth::String const&)
S::Int S::Configuration::SetParentConfiguration(const String &nParent)
{
	if (configFile == NIL) return Error();

	XML::Node	*configuration = FindConfigurationNode(activeConfig);

	if (configuration == NIL) return Error();

	configuration->SetAttribute(AttributeInheritingID, nParent);

	return Success();
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpq $0x0, 0x30(%rdi)
je 0xa4326
movq %rsi, %rbx
leaq 0x18(%rdi), %rsi
callq 0x576f0
testq %rax, %rax
je 0xa4326
leaq 0xcba77(%rip), %rsi     # 0x16fd90
movq %rax, %rdi
movq %rbx, %rdx
callq 0x581c0
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/config.cpp
// Function: smooth::Configuration::GetConfigurationName() const
S::String S::Configuration::GetConfigurationName() const
{
	if (configFile == NIL) return NIL;

	XML::Node	*configuration = FindConfigurationNode(activeConfig);

	if (configuration == NIL) return NIL;

	return activeConfig;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x30(%rsi)
je 0xa435f
leaq 0x18(%rsi), %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x576f0
testq %rax, %rax
je 0xa435f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x570b0
jmp 0xa4369
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58e20
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/config.cpp
// Function: smooth::Configuration::SetConfigurationName(smooth::String const&)
S::Int S::Configuration::SetConfigurationName(const String &nName)
{
	if (configFile == NIL) return Error();

	XML::Node	*configuration = FindConfigurationNode(activeConfig);

	if (configuration == NIL) return Error();

	activeConfig = nName;

	configuration->SetAttribute(AttributeNameID, nName);

	return Success();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpq $0x0, 0x30(%rdi)
je 0xa43bd
movq %rsi, %rbx
leaq 0x18(%rdi), %r14
movq %r14, %rsi
callq 0x576f0
testq %rax, %rax
je 0xa43bd
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x555f0
leaq 0xcb9f8(%rip), %rsi     # 0x16fda8
movq %r15, %rdi
movq %rbx, %rdx
callq 0x581c0
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/config.cpp
// Function: smooth::Configuration::GetIntValue(smooth::String const&, smooth::String const&, int)
S::Int S::Configuration::GetIntValue(const String &section, const String &name, Int defValue)
{
	if (configFile == NIL) return defValue;

	XML::Node	*value = FindValueNode(section, name);

	if (value != NIL)
	{
		return value->GetContent().ToInt();
	}
	else
	{
		XML::Node	*configuration = FindConfigurationNode(activeConfig);
		XML::Attribute	*attributeInheriting = configuration->GetAttributeByName(AttributeInheritingID);

		if (attributeInheriting != NIL)
		{
			String	 oConfig = activeConfig;

			activeConfig = attributeInheriting->GetContent();

			Int	 retVal = GetIntValue(section, name, defValue);

			activeConfig = oConfig;

			return retVal;
		}

		return defValue;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
cmpq $0x0, 0x30(%rdi)
je 0xa4477
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x57190
testq %rax, %rax
je 0xa440d
movq %rax, %rdi
callq 0x58e00
movq %rax, %rdi
callq 0x568c0
movq %rax, %rbx
jmp 0xa4477
leaq 0x18(%r12), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x576f0
leaq 0xcb96c(%rip), %rsi     # 0x16fd90
movq %rax, %rdi
callq 0x58d10
testq %rax, %rax
je 0xa4477
movq %rax, %rbp
movq %rsp, %rdi
movq %r13, %rsi
callq 0x570b0
movq %rbp, %rdi
callq 0x55720
movq %r13, %rdi
movq %rax, %rsi
callq 0x555f0
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x56b10
movl %eax, %ebx
movq %rsp, %rsi
movq %r13, %rdi
callq 0x555f0
movq %rsp, %rdi
callq 0x59200
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa448a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/config.cpp
// Function: smooth::Configuration::FindValueNode(smooth::String const&, smooth::String const&) const
S::XML::Node *S::Configuration::FindValueNode(const String &sect, const String &name) const
{
	XML::Node	*section = FindSectionNode(sect);

	if (section == NIL) return NIL;

	for (Int i = 0; i < section->GetNOfNodes(); i++)
	{
		XML::Node	*node = section->GetNthNode(i);
		XML::Attribute	*attributeName = node->GetAttributeByName(AttributeNameID);

		if (attributeName != NIL && attributeName->GetContent() == name) return node;
	}

	return NIL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
callq 0x570c0
testq %rax, %rax
je 0xa451d
movq %rax, %r14
movq %rax, %rdi
callq 0x56050
testl %eax, %eax
jle 0xa451d
leaq 0xcb8dc(%rip), %r12     # 0x16fda8
xorl %ebp, %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x57e20
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x58d10
testq %rax, %rax
je 0xa4509
movq %rax, %rdi
callq 0x55720
movq %rax, %rdi
movq %rbx, %rsi
callq 0x55900
testb %al, %al
je 0xa4509
xorl %eax, %eax
movq %r13, %r15
jmp 0xa450b
movb $0x1, %al
testb %al, %al
je 0xa4520
incl %ebp
movq %r14, %rdi
callq 0x56050
cmpl %eax, %ebp
jl 0xa44ce
xorl %r15d, %r15d
movq %r15, %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/config.cpp
// Function: smooth::Configuration::SetIntValue(smooth::String const&, smooth::String const&, int)
S::Int S::Configuration::SetIntValue(const String &section, const String &name, Int newValue)
{
	if (configFile == NIL) return Error();

	XML::Node	*valueNode = FindValueNode(section, name);

	if (valueNode != NIL)
	{
		valueNode->SetContent(String::FromInt(newValue));
	}
	else
	{
		XML::Node	*sectionNode = FindSectionNode(section);

		if (sectionNode == NIL)
		{
			sectionNode = FindConfigurationNode(activeConfig)->AddNode(NodeSectionID);
			sectionNode->SetAttribute(AttributeNameID, section);
		}

		valueNode = sectionNode->AddNode(NodeValueID, String::FromInt(newValue));
		valueNode->SetAttribute(AttributeNameID, name);
	}

	return Success();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpq $0x0, 0x30(%rdi)
je 0xa4587
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
callq 0x57190
testq %rax, %rax
je 0xa4591
movq %rax, %r15
movslq %ebp, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x56cf0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x558f0
leaq 0x8(%rsp), %rdi
callq 0x59200
jmp 0xa4635
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xa4637
movq %r12, %rdi
movq %r14, %rsi
callq 0x570c0
movq %rax, %r15
testq %rax, %rax
jne 0xa45f4
leaq 0x18(%r12), %rsi
movq %r12, %rdi
callq 0x576f0
movq %rax, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x58e20
leaq 0xcb796(%rip), %rsi     # 0x16fd60
movq %r15, %rdi
movq %r12, %rdx
callq 0x55820
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x59200
leaq 0xcb7bf(%rip), %rsi     # 0x16fda8
movq %r15, %rdi
movq %r14, %rdx
callq 0x581c0
movslq %ebp, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x56cf0
leaq 0xcb76d(%rip), %rsi     # 0x16fd78
movq %r15, %rdi
movq %r14, %rdx
callq 0x55820
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x59200
leaq 0xcb77e(%rip), %rsi     # 0x16fda8
movq %r14, %rdi
movq %rbx, %rdx
callq 0x581c0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa4648
jmp 0xa4648
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/config.cpp
// Function: smooth::Configuration::FindSectionNode(smooth::String const&) const
S::XML::Node *S::Configuration::FindSectionNode(const String &section) const
{
	XML::Node	*configuration = FindConfigurationNode(activeConfig);

	if (configuration == NIL) return NIL;

	for (Int i = 0; i < configuration->GetNOfNodes(); i++)
	{
		XML::Node	*node = configuration->GetNthNode(i);
		XML::Attribute	*attributeName = node->GetAttributeByName(AttributeNameID);

		if (attributeName != NIL && attributeName->GetContent() == section) return node;
	}

	return NIL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x18(%rdi), %rsi
callq 0x576f0
testq %rax, %rax
je 0xa46e1
movq %rax, %r14
movq %rax, %rdi
callq 0x56050
testl %eax, %eax
jle 0xa46e1
leaq 0xcb718(%rip), %r12     # 0x16fda8
xorl %ebp, %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x57e20
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x58d10
testq %rax, %rax
je 0xa46cd
movq %rax, %rdi
callq 0x55720
movq %rax, %rdi
movq %rbx, %rsi
callq 0x55900
testb %al, %al
je 0xa46cd
xorl %eax, %eax
movq %r13, %r15
jmp 0xa46cf
movb $0x1, %al
testb %al, %al
je 0xa46e4
incl %ebp
movq %r14, %rdi
callq 0x56050
cmpl %eax, %ebp
jl 0xa4692
xorl %r15d, %r15d
movq %r15, %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/config.cpp
// Function: smooth::Configuration::GetStringValue(smooth::String const&, smooth::String const&, smooth::String const&)
S::String S::Configuration::GetStringValue(const String &section, const String &name, const String &defValue)
{
	if (configFile == NIL) return defValue;

	XML::Node	*value = FindValueNode(section, name);

	if (value != NIL)
	{
		return value->GetContent();
	}
	else
	{
		XML::Node	*configuration = FindConfigurationNode(activeConfig);
		XML::Attribute	*attributeInheriting = configuration->GetAttributeByName(AttributeInheritingID);

		if (attributeInheriting != NIL)
		{
			String	 oConfig = activeConfig;

			activeConfig = attributeInheriting->GetContent();

			String	 retVal = GetStringValue(section, name, defValue);

			activeConfig = oConfig;

			return retVal;
		}

		return defValue;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movq %rdi, %rbx
cmpq $0x0, 0x30(%rsi)
je 0xa47c0
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x57190
testq %rax, %rax
je 0xa4744
movq %rax, %rdi
callq 0x58e00
movq %rbx, %rdi
movq %rax, %rsi
jmp 0xa47c6
leaq 0x18(%r13), %rsi
movq %r13, %rdi
movq %rsi, 0x8(%rsp)
callq 0x576f0
leaq 0xcb634(%rip), %rsi     # 0x16fd90
movq %rax, %rdi
callq 0x58d10
testq %rax, %rax
je 0xa47c0
movq %rax, %rbp
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x570b0
movq %rbp, %rdi
callq 0x55720
movq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %rax, %rsi
callq 0x555f0
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x58140
leaq 0x10(%rsp), %rsi
movq %rbp, %rdi
callq 0x555f0
leaq 0x10(%rsp), %rdi
callq 0x59200
jmp 0xa47cb
movq %rbx, %rdi
movq %r14, %rsi
callq 0x570b0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x59200
jmp 0xa47ed
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x59200
movq %r14, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/config.cpp
// Function: smooth::Configuration::SetStringValue(smooth::String const&, smooth::String const&, smooth::String const&)
S::Int S::Configuration::SetStringValue(const String &section, const String &name, const String &newValue)
{
	if (configFile == NIL) return Error();

	XML::Node	*valueNode = FindValueNode(section, name);

	if (valueNode != NIL)
	{
		valueNode->SetContent(newValue);
	}
	else
	{
		XML::Node	*sectionNode = FindSectionNode(section);

		if (sectionNode == NIL)
		{
			sectionNode = FindConfigurationNode(activeConfig)->AddNode(NodeSectionID);
			sectionNode->SetAttribute(AttributeNameID, section);
		}

		valueNode = sectionNode->AddNode(NodeValueID, newValue);
		valueNode->SetAttribute(AttributeNameID, name);
	}

	return Success();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpq $0x0, 0x30(%rdi)
je 0xa483a
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
callq 0x57190
testq %rax, %rax
je 0xa4844
movq %rax, %rdi
movq %r14, %rsi
callq 0x558f0
jmp 0xa48cb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xa48cd
movq %r12, %rdi
movq %r15, %rsi
callq 0x570c0
movq %rax, %r13
testq %rax, %rax
jne 0xa48a7
leaq 0x18(%r12), %rsi
movq %r12, %rdi
callq 0x576f0
movq %rax, %r12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x58e20
leaq 0xcb4e3(%rip), %rsi     # 0x16fd60
movq %r12, %rdi
movq %r13, %rdx
callq 0x55820
movq %rax, %r13
leaq 0x8(%rsp), %rdi
callq 0x59200
leaq 0xcb50c(%rip), %rsi     # 0x16fda8
movq %r13, %rdi
movq %r15, %rdx
callq 0x581c0
leaq 0xcb4ca(%rip), %rsi     # 0x16fd78
movq %r13, %rdi
movq %r14, %rdx
callq 0x55820
leaq 0xcb4e8(%rip), %rsi     # 0x16fda8
movq %rax, %rdi
movq %rbx, %rdx
callq 0x581c0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/datetime.cpp
// Function: smooth::DateTime::SetYMD(int, int, int)
S::Bool S::DateTime::SetYMD(Int year, Int month, Int day)
{
	if (year  <  1900	       ) return False;
	if (month <=	0 || month > 12) return False;
	if (day	  <=	0 || day   > 31) return False;

	tm	 lt = localtime_p((time_t *) value);

	lt.tm_year = year - 1900;
	lt.tm_mon  = month - 1;
	lt.tm_mday = day;

	time_t	 t  = mktime(&lt);

	memcpy(value, &t, sizeof(time_t));

	return True;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %r14d
movl %edx, %ebp
cmpl $0x76c, %esi            # imm = 0x76C
setge %al
decl %ebp
cmpl $0xc, %ebp
setb %cl
leal -0x1(%r14), %edx
cmpl $0x1f, %edx
setb %r15b
andb %cl, %r15b
andb %al, %r15b
cmpb $0x1, %r15b
jne 0xa4a28
movl %esi, %r12d
movq %rdi, %rbx
movq (%rdi), %rdi
xorps %xmm0, %xmm0
movq %rsp, %r13
movaps %xmm0, 0x20(%r13)
movaps %xmm0, 0x10(%r13)
movaps %xmm0, (%r13)
movq $0x0, 0x30(%r13)
movq %r13, %rsi
callq 0x556c0
addl $0xfffff894, %r12d      # imm = 0xFFFFF894
movl %r12d, 0x14(%r13)
movl %ebp, 0x10(%r13)
movl %r14d, 0xc(%r13)
movq %r13, %rdi
callq 0x56300
movq (%rbx), %rcx
movq %rax, (%rcx)
movl %r15d, %eax
addq $0x38, %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/datetime.cpp
// Function: smooth::DateTime::SetHMS(int, int, int)
S::Bool S::DateTime::SetHMS(Int hour, Int min, Int sec)
{
	if (hour < 0 || hour >= 24) return False;
	if (min	 < 0 || min  >= 60) return False;
	if (sec	 < 0 || sec  >= 60) return False;

	tm	 lt = localtime_p((time_t *) value);

	lt.tm_hour = hour;
	lt.tm_min  = min;
	lt.tm_sec  = sec;

	time_t	 t  = mktime(&lt);

	memcpy(value, &t, sizeof(time_t));

	return True;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebp
cmpl $0x18, %esi
setb %al
cmpl $0x3c, %edx
setb %cl
andb %al, %cl
cmpl $0x3c, %ebp
setb %r14b
andb %cl, %r14b
cmpb $0x1, %r14b
jne 0xa4ab3
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %rbx
movq (%rdi), %rdi
xorps %xmm0, %xmm0
movq %rsp, %r13
movaps %xmm0, 0x20(%r13)
movaps %xmm0, 0x10(%r13)
movaps %xmm0, (%r13)
movq $0x0, 0x30(%r13)
movq %r13, %rsi
callq 0x556c0
movl %r12d, 0x8(%r13)
movl %r15d, 0x4(%r13)
movl %ebp, (%r13)
movq %r13, %rdi
callq 0x56300
movq (%rbx), %rcx
movq %rax, (%rcx)
movl %r14d, %eax
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/datetime.cpp
// Function: smooth::DateTime::SetYear(int)
S::Bool S::DateTime::SetYear(Int year)
{
	if (year < 0) return False;

	tm	 lt = localtime_p((time_t *) value);

	lt.tm_year = year - 1900;

	time_t	 t  = mktime(&lt);

	memcpy(value, &t, sizeof(time_t));

	return True;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebx
testl %esi, %esi
js 0xa4bb5
movq %rdi, %r14
movq (%rdi), %rdi
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, 0x20(%r15)
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq $0x0, 0x30(%r15)
movq %r15, %rsi
callq 0x556c0
leal -0x76c(%rbx), %eax
movl %eax, 0x14(%r15)
movq %r15, %rdi
callq 0x56300
movq (%r14), %rcx
movq %rax, (%rcx)
testl %ebx, %ebx
setns %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/datetime.cpp
// Function: smooth::DateTime::SetMonth(int)
S::Bool S::DateTime::SetMonth(Int month)
{
	if (month <= 0 || month > 12) return False;

	tm	 lt = localtime_p((time_t *) value);

	lt.tm_mon  = month - 1;

	time_t	 t  = mktime(&lt);

	memcpy(value, &t, sizeof(time_t));

	return True;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebx
decl %ebx
cmpl $0xb, %ebx
ja 0xa4c12
movq %rdi, %r14
movq (%rdi), %rdi
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, 0x20(%r15)
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq $0x0, 0x30(%r15)
movq %r15, %rsi
callq 0x556c0
movl %ebx, 0x10(%r15)
movq %r15, %rdi
callq 0x56300
movq (%r14), %rcx
movq %rax, (%rcx)
cmpl $0xc, %ebx
setb %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/datetime.cpp
// Function: smooth::DateTime::SetDay(int)
S::Bool S::DateTime::SetDay(Int day)
{
	if (day <= 0 || day > 31) return False;

	tm	 lt = localtime_p((time_t *) value);

	lt.tm_mday = day;

	time_t	 t  = mktime(&lt);

	memcpy(value, &t, sizeof(time_t));

	return True;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %esi, %r14d
leal -0x1(%r14), %ebp
cmpl $0x1e, %ebp
ja 0xa4c74
movq %rdi, %rbx
movq (%rdi), %rdi
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, 0x20(%r15)
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq $0x0, 0x30(%r15)
movq %r15, %rsi
callq 0x556c0
movl %r14d, 0xc(%r15)
movq %r15, %rdi
callq 0x56300
movq (%rbx), %rcx
movq %rax, (%rcx)
cmpl $0x1f, %ebp
setb %al
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/datetime.cpp
// Function: smooth::DateTime::SetHour(int)
S::Bool S::DateTime::SetHour(Int hour)
{
	if (hour < 0 || hour >= 24) return False;

	tm	 lt = localtime_p((time_t *) value);

	lt.tm_hour = hour;

	time_t	 t  = mktime(&lt);

	memcpy(value, &t, sizeof(time_t));

	return True;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebx
cmpl $0x17, %esi
ja 0xa4d68
movq %rdi, %r14
movq (%rdi), %rdi
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, 0x20(%r15)
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq $0x0, 0x30(%r15)
movq %r15, %rsi
callq 0x556c0
movl %ebx, 0x8(%r15)
movq %r15, %rdi
callq 0x56300
movq (%r14), %rcx
movq %rax, (%rcx)
cmpl $0x18, %ebx
setb %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/datetime.cpp
// Function: smooth::DateTime::SetMinute(int)
S::Bool S::DateTime::SetMinute(Int min)
{
	if (min < 0 || min >= 60) return False;

	tm	 lt = localtime_p((time_t *) value);

	lt.tm_min  = min;

	time_t	 t  = mktime(&lt);

	memcpy(value, &t, sizeof(time_t));

	return True;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebx
cmpl $0x3b, %esi
ja 0xa4dc4
movq %rdi, %r14
movq (%rdi), %rdi
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, 0x20(%r15)
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq $0x0, 0x30(%r15)
movq %r15, %rsi
callq 0x556c0
movl %ebx, 0x4(%r15)
movq %r15, %rdi
callq 0x56300
movq (%r14), %rcx
movq %rax, (%rcx)
cmpl $0x3c, %ebx
setb %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/datetime.cpp
// Function: smooth::DateTime::SetSecond(int)
S::Bool S::DateTime::SetSecond(Int sec)
{
	if (sec < 0 || sec >= 60) return False;

	tm	 lt = localtime_p((time_t *) value);

	lt.tm_sec  = sec;

	time_t	 t  = mktime(&lt);

	memcpy(value, &t, sizeof(time_t));

	return True;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebx
cmpl $0x3b, %esi
ja 0xa4e1f
movq %rdi, %r14
movq (%rdi), %rdi
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, 0x20(%r15)
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq $0x0, 0x30(%r15)
movq %r15, %rsi
callq 0x556c0
movl %ebx, (%r15)
movq %r15, %rdi
callq 0x56300
movq (%r14), %rcx
movq %rax, (%rcx)
cmpl $0x3c, %ebx
setb %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop