LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x5a180
movq %rbx, 0x8(%rsp)
leaq 0x18(%rbx), %rdi
movq %rdi, (%rsp)
callq 0x64972
leaq 0x10(%rsp), %rdi
xorl %r13d, %r13d
xorl %esi, %esi
callq 0x5a180
movb $0x1, %r12b
pushq $-0x1
popq %rbp
xorl %ebx, %ebx
movl %ebp, %r14d
movq %r15, %rdi
callq 0x58370
leal 0x1(%r14), %ebp
cmpl %eax, %ebp
jg 0x9e1a2
movq %r15, %rdi
movl %ebp, %esi
callq 0x59270
cmpl $0x20, %eax
setne %al
orb %bl, %al
testb $0x1, %al
jne 0x9e0e9
movq %r15, %rdi
movl %r14d, %esi
callq 0x59270
cmpl $0x5c, %eax
jne 0x9e0f5
movq %r15, %rdi
callq 0x58370
cmpl %eax, %ebp
jne 0x9e11a
leaq 0x10(%rsp), %rdi
callq 0x58370
testl %eax, %eax
je 0x9e0ac
testb $0x1, %r12b
je 0x9e131
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x56630
jmp 0x9e13f
movq %r15, %rdi
movl %ebp, %esi
callq 0x59270
cmpl $0x22, %eax
jne 0x9e156
xorb $0x1, %bl
jmp 0x9e0ac
movq (%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x64dee
xorl %r12d, %r12d
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x58c30
xorl %r13d, %r13d
jmp 0x9e0ac
movq %r15, %rdi
movl %ebp, %esi
callq 0x59270
cmpl $0x5c, %eax
jne 0x9e17d
addl $0x2, %r14d
movq %r15, %rdi
movl %r14d, %esi
callq 0x59270
cmpl $0x20, %eax
je 0x9e0ac
movq %r15, %rdi
movl %ebp, %esi
callq 0x59270
movl %eax, %r14d
leaq 0x10(%rsp), %rdi
movl %r13d, %esi
callq 0x59cc0
incl %r13d
movl %r14d, (%rax)
jmp 0x9e0ac
leaq 0x10(%rsp), %rdi
callq 0x5a588
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x9e1d2
movq %rax, %r14
jmp 0x9e1db
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x5a588
movq (%rsp), %rdi
callq 0x64988
movq 0x8(%rsp), %rdi
callq 0x5a588
movq %r14, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/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 0xc36ed(%rip), %rax     # 0x1618f8
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0xc0bdf(%rip), %rax     # 0x15edf8
movq %rax, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
andq $0x0, 0x8(%rdi)
movb $0x1, 0x10(%rdi)
andl $0x0, 0x14(%rdi)
movb $0x0, 0x30(%rdi)
andq $0x0, 0x38(%rdi)
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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)
callq 0x56300
xorl %r15d, %r15d
testl %r14d, %r14d
js 0x9e380
cmpl %r14d, 0x8(%rbx)
jl 0x9e380
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5a290
testb %al, %al
je 0x9e321
cmpl %ebp, 0xc(%rbx)
jge 0x9e2e6
movl %ebp, 0xc(%rbx)
movl 0x28(%rbx), %eax
cmpl 0x8(%rbx), %eax
jne 0x9e313
leaq 0x18(%rbx), %rdi
cvtsi2sd %eax, %xmm0
mulsd 0x44d02(%rip), %xmm0    # 0xe3000
movsd 0x44d02(%rip), %xmm1    # 0xe3008
maxsd %xmm0, %xmm1
cvttsd2si %xmm1, %esi
callq 0x9e7f2
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x9e326
movq (%rax), %rax
jmp 0x9e328
xorl %r15d, %r15d
jmp 0x9e380
xorl %eax, %eax
movl %r14d, %r12d
leaq (%rax,%r12,4), %rsi
leaq (%rax,%r12,4), %rdi
addq $0x4, %rdi
movslq 0x8(%rbx), %rdx
movslq %r14d, %rax
subq %rax, %rdx
shlq $0x2, %rdx
callq 0x56720
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
je 0x9e36a
cmpl %ebp, -0x4(%rax,%r12,4)
jg 0x9e379
movb $0x1, %r15b
cmpl %r14d, %ecx
jle 0x9e380
cmpl %ebp, 0x4(%rax,%r12,4)
jge 0x9e380
movb $0x0, 0x10(%rbx)
movb $0x1, %r15b
leaq 0x8(%rsp), %rdi
callq 0x57400
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 0x57400
movq %rbx, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/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)
callq 0x56300
movl 0xc(%rbx), %eax
cmpl %r14d, %eax
setl %cl
cmpl %ebp, %eax
setl %al
orb %cl, %al
je 0x9e43c
xorl %ebx, %ebx
jmp 0x9e464
movq %rbx, %rdi
movl %r14d, %esi
callq 0x59d60
movl %eax, %r14d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x59d60
movq (%rbx), %rcx
movq %rbx, %rdi
movl %r14d, %esi
movl %eax, %edx
callq *0x10(%rcx)
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x57400
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x57400
movq %rbx, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/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, %r14d
movq %rdi, %rbx
movq %rdi, 0x8(%rsp)
callq 0x58e30
movl 0x8(%rbx), %eax
pushq $-0x1
popq %rbp
testl %eax, %eax
je 0x9e507
movl 0x14(%rbx), %ecx
movslq %ecx, %rdx
cmpl %eax, %edx
jge 0x9e4c7
movq 0x20(%rbx), %rsi
movq (%rsi), %rsi
cmpl %r14d, (%rsi,%rdx,4)
je 0x9e4fc
testl %ecx, %ecx
setle %sil
cmpl %eax, %ecx
setg %dil
orb %sil, %dil
jne 0x9e4e7
decl %ecx
movq 0x20(%rbx), %rsi
movq (%rsi), %rsi
cmpl %r14d, (%rsi,%rcx,4)
je 0x9e502
leal 0x1(%rdx), %ecx
cmpl %eax, %ecx
jge 0x9e51c
movq 0x20(%rbx), %rsi
movq (%rsi), %rsi
cmpl %r14d, 0x4(%rsi,%rdx,4)
jne 0x9e51c
movl %ecx, %ebp
testl %ecx, %ecx
js 0x9e507
movl %ecx, 0x14(%rbx)
movl %ecx, %ebp
leaq 0x8(%rsp), %rdi
callq 0x58b30
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cmpb $0x0, 0x10(%rbx)
je 0x9e54c
decl %eax
movq 0x20(%rbx), %rdx
xorl %esi, %esi
cmpl %esi, %eax
jl 0x9e507
leal (%rax,%rsi), %ecx
shrl %ecx
movq (%rdx), %rdi
movl (%rdi,%rcx,4), %edi
cmpl %r14d, %edi
je 0x9e502
jl 0x9e546
decl %ecx
movl %ecx, %eax
jmp 0x9e52a
incl %ecx
movl %ecx, %esi
jmp 0x9e52a
movq 0x20(%rbx), %rdx
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpq %rcx, %rax
je 0x9e507
movq (%rdx), %rsi
cmpl %r14d, (%rsi,%rcx,4)
je 0x9e4fc
incq %rcx
jmp 0x9e557
// File: /workspace/github_c_makefile_star2_O2/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, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq %rdi, 0x8(%rsp)
callq 0x56300
movl 0x8(%rbx), %eax
cmpl %r14d, %eax
setle %cl
testl %r14d, %r14d
sets %dl
orb %cl, %dl
jne 0x9e5a9
cmpl %ebp, %eax
setle %al
testl %ebp, %ebp
sets %cl
orb %al, %cl
je 0x9e5ad
xorl %ebx, %ebx
jmp 0x9e60a
movq 0x20(%rbx), %rax
movq (%rax), %rax
movl %r14d, %ecx
movl (%rax,%rcx,4), %r15d
movl %ebp, %edx
subl %r14d, %edx
jae 0x9e5e2
movl %ebp, %r12d
leaq (%rax,%r12,4), %rsi
leaq (%rax,%r12,4), %rdi
addq $0x4, %rdi
subl %ebp, %r14d
movslq %r14d, %rdx
shlq $0x2, %rdx
callq 0x56720
jmp 0x9e5f9
leaq (%rax,%rcx,4), %rdi
leaq 0x4(%rdi), %rsi
movslq %edx, %rdx
shlq $0x2, %rdx
callq 0x56720
movl %ebp, %r12d
movq 0x20(%rbx), %rax
movq (%rax), %rax
movl %r15d, (%rax,%r12,4)
movb $0x0, 0x10(%rbx)
movb $0x1, %bl
leaq 0x8(%rsp), %rdi
callq 0x57400
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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)
callq 0x56300
movl 0x8(%rbx), %eax
cmpl %ebp, %eax
setle %cl
testl %ebp, %ebp
sets %dl
orb %cl, %dl
je 0x9e6a0
xorl %ebx, %ebx
jmp 0x9e6e5
cmpl $0x1, %eax
jne 0x9e6b2
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
movl %eax, %ebx
jmp 0x9e6e5
movq 0x20(%rbx), %rcx
testq %rcx, %rcx
je 0x9e6c0
movq (%rcx), %rcx
jmp 0x9e6c2
xorl %ecx, %ecx
movl %ebp, %edx
leaq (%rcx,%rdx,4), %rdi
leaq (%rcx,%rdx,4), %rsi
addq $0x4, %rsi
notl %ebp
addl %ebp, %eax
movslq %eax, %rdx
shlq $0x2, %rdx
callq 0x56720
decl 0x8(%rbx)
movb $0x1, %bl
movq %rsp, %rdi
callq 0x57400
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x57400
movq %rbx, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/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)
callq 0x56300
cmpl $0x0, 0x8(%rbx)
je 0x9e738
leaq 0x18(%rbx), %rdi
callq 0x9e874
andq $0x0, 0x8(%rbx)
movb $0x1, 0x10(%rbx)
andl $0x0, 0x14(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x57400
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
cmpl $0x1f, %eax
ja 0x9e995
movl %edx, %ebx
movl %esi, %r14d
movl %edi, %ebp
xorl %r13d, %r13d
xorl %r15d, %r15d
leal (%r14,%r13), %r12d
cmpl %ebx, %r12d
ja 0x9e999
pushq $0x2
popq %rdi
movl %r13d, %esi
callq 0x570f0
cvttsd2si %xmm0, %eax
btl %r12d, %ebp
movl $0x0, %ecx
cmovael %ecx, %eax
addl %eax, %r15d
incl %r13d
jmp 0x9e969
pushq $-0x1
popq %r15
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_O2/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:
movl %edx, %eax
orl %esi, %eax
cmpl $0x1f, %eax
ja 0x9e9e8
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
xorl %r12d, %r12d
leal (%r15,%r12), %esi
cmpl %ebp, %esi
ja 0x9e9ec
xorl %edx, %edx
btl %r12d, %ebx
setb %dl
movq %r14, %rdi
callq 0x56850
incl %r12d
jmp 0x9e9ca
pushq $-0x1
popq %rax
retq
movl (%r14), %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5a180
leaq 0x18(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x5a180
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
leaq 0xc643c(%rip), %rsi     # 0x164ef0
movq %r14, %rdi
callq 0x56630
movzbl %bpl, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x564a0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x9eae6
movq %rax, %r15
movq %r14, %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x5a588
movq %r15, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/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 0x9ee84
movq %r14, %rdi
callq 0x56440
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x564c0
andq $0x0, 0x30(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58c30
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x9eea5
movq %r14, %rdi
callq 0x57050
pushq $0x30
popq %rsi
movq %r14, %rdi
callq 0x564c0
andq $0x0, 0x38(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x9ef9d
callq 0x58010
movq %rax, %r14
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x57d40
xorb $0x1, %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x9efa0
leaq 0x20(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x5a180
leaq 0x38(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x57940
leaq 0x38(%rsp), %rdi
callq 0x59370
movq %rax, %r15
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x5a180
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r15, %rsi
callq 0x59fb0
leaq 0x68(%rsp), %rdi
callq 0x56990
leaq 0x68(%rsp), %rdi
callq 0x5a598
leaq 0x8(%rsp), %rdi
callq 0x5a588
leaq 0x38(%rsp), %rdi
callq 0x5a500
leaq 0x20(%rsp), %rdi
callq 0x5a588
leaq 0xc5f94(%rip), %rsi     # 0x164f08
movq %r14, %rdi
callq 0x57950
xorl %ebp, %ebp
testq %rax, %rax
je 0x9efa0
movq %rax, %rdi
callq 0x57130
testl %eax, %eax
jle 0x9efa0
movq 0x30(%rbx), %rdi
movq %rbx, %rsi
callq 0x58c10
jmp 0x9efa0
pushq $-0x1
popq %rbp
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 0x5a598
jmp 0x9efc2
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5a588
jmp 0x9efd3
jmp 0x9efd0
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x5a500
jmp 0x9efe2
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/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
pushq $-0x1
popq %rbp
cmpq $0x0, 0x30(%rdi)
je 0x9f05f
movq %rsi, %rbx
movq %rdi, %r14
callq 0x58910
testq %rax, %rax
jne 0x9f05f
movq 0x30(%r14), %rdi
callq 0x58010
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x5a180
leaq 0xc5ed0(%rip), %rsi     # 0x164f08
movq %r14, %rdi
movq %r15, %rdx
callq 0x56880
leaq 0xc5f1e(%rip), %rsi     # 0x164f68
movq %rax, %rdi
movq %rbx, %rdx
callq 0x59460
movq %rsp, %rdi
callq 0x5a588
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 0x5a588
movq %rbx, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x58010
testq %rax, %rax
je 0x9f10a
movq %rax, %r14
leaq 0xc5e62(%rip), %r15     # 0x164f08
leaq 0xc5ebb(%rip), %r12     # 0x164f68
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x57130
cmpl %eax, %ebp
jge 0x9f10a
movq %r14, %rdi
movl %ebp, %esi
callq 0x590b0
movq %rax, %r13
movq %rax, %rdi
callq 0x58fd0
movq %rax, %rdi
movq %r15, %rsi
callq 0x58150
testb %al, %al
jne 0x9f106
movq %r13, %rdi
movq %r12, %rsi
callq 0x5a060
testq %rax, %rax
je 0x9f106
movq %rax, %rdi
callq 0x56780
movq %rax, %rdi
movq %rbx, %rsi
callq 0x56960
testb %al, %al
jne 0x9f10d
incl %ebp
jmp 0x9f0af
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_O2/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
pushq $-0x1
popq %rbp
cmpq $0x0, 0x30(%rdi)
je 0x9f179
movq %rsi, %r15
movq %rdi, %rbx
callq 0x58910
testq %rax, %rax
je 0x9f179
movq %rax, %r14
leaq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0x56960
testb %al, %al
je 0x9f163
leaq 0xc5d95(%rip), %rsi     # 0x164ef0
movq %rbx, %rdi
callq 0x57740
movq 0x30(%rbx), %rdi
callq 0x58010
movq %rax, %rdi
movq %r14, %rsi
callq 0x590e0
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9f1c5
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x58910
testq %rax, %rax
jne 0x9f1ac
movq %r14, %rdi
movq %rbx, %rsi
callq 0x57380
addq $0x18, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x56630
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $-0x1
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x58010
testq %rax, %rax
je 0x9f221
movq %rax, %r14
xorl %ebx, %ebx
leaq 0xc5d1d(%rip), %r15     # 0x164f08
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x57130
cmpl %eax, %ebp
jge 0x9f223
movq %r14, %rdi
movl %ebp, %esi
callq 0x590b0
movq %rax, %rdi
callq 0x58fd0
movq %rax, %rdi
movq %r15, %rsi
callq 0x58150
xorb $0x1, %al
movzbl %al, %eax
addl %eax, %ebx
incl %ebp
jmp 0x9f1ed
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
movq 0x30(%rsi), %rdi
callq 0x58010
testq %rax, %rax
je 0x9f2d3
movq %rax, %r14
movq %rbx, (%rsp)
xorl %r15d, %r15d
leaq 0xc5ca5(%rip), %r12     # 0x164f08
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x57130
cmpl %eax, %r15d
jge 0x9f2cf
movq %r14, %rdi
movl %r15d, %esi
callq 0x590b0
movq %rax, %r13
movq %rax, %rdi
callq 0x58fd0
movq %rax, %rdi
movq %r12, %rsi
callq 0x58150
testb %al, %al
jne 0x9f29d
cmpl %ebp, %ebx
je 0x9f2a2
incl %ebx
incl %r15d
jmp 0x9f265
leaq 0xc5cbf(%rip), %rsi     # 0x164f68
movq %r13, %rdi
callq 0x5a060
testq %rax, %rax
je 0x9f2cf
movq %rax, %rdi
callq 0x56780
movq (%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x58280
jmp 0x9f2dd
movq (%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5a180
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/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
pushq $-0x1
popq %rbp
cmpq $0x0, 0x30(%rdi)
je 0x9f322
movq %rsi, %rbx
leaq 0x18(%rdi), %rsi
callq 0x58910
testq %rax, %rax
je 0x9f322
leaq 0xc5c3b(%rip), %rsi     # 0x164f50
movq %rax, %rdi
movq %rbx, %rdx
callq 0x59460
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x9f35b
leaq 0x18(%rsi), %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x58910
testq %rax, %rax
je 0x9f35b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x58280
jmp 0x9f365
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5a180
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $-0x1
popq %rbp
cmpq $0x0, 0x30(%rdi)
je 0x9f3b7
movq %rsi, %rbx
leaq 0x18(%rdi), %r14
movq %r14, %rsi
callq 0x58910
testq %rax, %rax
je 0x9f3b7
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x56630
leaq 0xc5bbe(%rip), %rsi     # 0x164f68
movq %r15, %rdi
movq %rbx, %rdx
callq 0x59460
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9f471
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x58380
testq %rax, %rax
je 0x9f407
movq %rax, %rdi
callq 0x5a160
movq %rax, %rdi
callq 0x57a10
movq %rax, %rbx
jmp 0x9f471
leaq 0x18(%r12), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x58910
leaq 0xc5b32(%rip), %rsi     # 0x164f50
movq %rax, %rdi
callq 0x5a060
testq %rax, %rax
je 0x9f471
movq %rax, %rbp
movq %rsp, %rdi
movq %r13, %rsi
callq 0x58280
movq %rbp, %rdi
callq 0x56780
movq %r13, %rdi
movq %rax, %rsi
callq 0x56630
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x57c80
movl %eax, %ebx
movq %rsp, %rsi
movq %r13, %rdi
callq 0x56630
movq %rsp, %rdi
callq 0x5a588
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9f484
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/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, %r14
callq 0x58290
xorl %ebx, %ebx
testq %rax, %rax
je 0x9f505
movq %rax, %r15
leaq 0xc5aac(%rip), %r12     # 0x164f68
xorl %ebp, %ebp
movq %r15, %rdi
callq 0x57130
cmpl %eax, %ebp
jge 0x9f505
movq %r15, %rdi
movl %ebp, %esi
callq 0x590b0
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x5a060
testq %rax, %rax
je 0x9f4fe
movq %rax, %rdi
callq 0x56780
movq %rax, %rdi
movq %r14, %rsi
callq 0x56960
testb %al, %al
jne 0x9f502
incl %ebp
jmp 0x9f4be
movq %r13, %rbx
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/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 0x9f56d
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
callq 0x58380
testq %rax, %rax
je 0x9f575
movq %rax, %r15
movslq %ebp, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x57e80
movq %r15, %rdi
movq %rbx, %rsi
callq 0x56950
leaq 0x8(%rsp), %rdi
callq 0x5a588
jmp 0x9f619
pushq $-0x1
popq %rax
jmp 0x9f61b
movq %r12, %rdi
movq %r14, %rsi
callq 0x58290
movq %rax, %r15
testq %rax, %rax
jne 0x9f5d8
leaq 0x18(%r12), %rsi
movq %r12, %rdi
callq 0x58910
movq %rax, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x5a180
leaq 0xc5972(%rip), %rsi     # 0x164f20
movq %r15, %rdi
movq %r12, %rdx
callq 0x56880
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x5a588
leaq 0xc599b(%rip), %rsi     # 0x164f68
movq %r15, %rdi
movq %r14, %rdx
callq 0x59460
movslq %ebp, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x57e80
leaq 0xc5949(%rip), %rsi     # 0x164f38
movq %r15, %rdi
movq %r14, %rdx
callq 0x56880
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5a588
leaq 0xc595a(%rip), %rsi     # 0x164f68
movq %r14, %rdi
movq %rbx, %rdx
callq 0x59460
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9f62c
jmp 0x9f62c
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/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, %r14
leaq 0x18(%rdi), %rsi
callq 0x58910
xorl %ebx, %ebx
testq %rax, %rax
je 0x9f6b3
movq %rax, %r15
leaq 0xc58fe(%rip), %r12     # 0x164f68
xorl %ebp, %ebp
movq %r15, %rdi
callq 0x57130
cmpl %eax, %ebp
jge 0x9f6b3
movq %r15, %rdi
movl %ebp, %esi
callq 0x590b0
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x5a060
testq %rax, %rax
je 0x9f6ac
movq %rax, %rdi
callq 0x56780
movq %rax, %rdi
movq %r14, %rsi
callq 0x56960
testb %al, %al
jne 0x9f6b0
incl %ebp
jmp 0x9f66c
movq %r13, %rbx
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/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 0x9f790
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x58380
testq %rax, %rax
je 0x9f714
movq %rax, %rdi
callq 0x5a160
movq %rbx, %rdi
movq %rax, %rsi
jmp 0x9f796
leaq 0x18(%r13), %rsi
movq %r13, %rdi
movq %rsi, 0x8(%rsp)
callq 0x58910
leaq 0xc5824(%rip), %rsi     # 0x164f50
movq %rax, %rdi
callq 0x5a060
testq %rax, %rax
je 0x9f790
movq %rax, %rbp
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x58280
movq %rbp, %rdi
callq 0x56780
movq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %rax, %rsi
callq 0x56630
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x593d0
leaq 0x10(%rsp), %rsi
movq %rbp, %rdi
callq 0x56630
leaq 0x10(%rsp), %rdi
callq 0x5a588
jmp 0x9f79b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x58280
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 0x5a588
jmp 0x9f7bd
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x5a588
movq %r14, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x9f80a
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
callq 0x58380
testq %rax, %rax
je 0x9f812
movq %rax, %rdi
movq %r14, %rsi
callq 0x56950
jmp 0x9f899
pushq $-0x1
popq %rax
jmp 0x9f89b
movq %r12, %rdi
movq %r15, %rsi
callq 0x58290
movq %rax, %r13
testq %rax, %rax
jne 0x9f875
leaq 0x18(%r12), %rsi
movq %r12, %rdi
callq 0x58910
movq %rax, %r12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x5a180
leaq 0xc56d5(%rip), %rsi     # 0x164f20
movq %r12, %rdi
movq %r13, %rdx
callq 0x56880
movq %rax, %r13
leaq 0x8(%rsp), %rdi
callq 0x5a588
leaq 0xc56fe(%rip), %rsi     # 0x164f68
movq %r13, %rdi
movq %r15, %rdx
callq 0x59460
leaq 0xc56bc(%rip), %rsi     # 0x164f38
movq %r13, %rdi
movq %r14, %rdx
callq 0x56880
leaq 0xc56da(%rip), %rsi     # 0x164f68
movq %rax, %rdi
movq %rbx, %rdx
callq 0x59460
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 0x5a588
movq %rbx, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x9f9d2
movl %esi, %r12d
movq %rdi, %rbx
movq (%rdi), %rsi
movq %rsp, %r13
movq %r13, %rdi
callq 0x9f9e4
addl $0xfffff894, %r12d      # imm = 0xFFFFF894
movl %r12d, 0x14(%r13)
movl %ebp, 0x10(%r13)
movl %r14d, 0xc(%r13)
movq %r13, %rdi
callq 0x573f0
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_O2/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 0x9fa6b
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %rbx
movq (%rdi), %rsi
movq %rsp, %r13
movq %r13, %rdi
callq 0x9f9e4
movl %r12d, 0x8(%r13)
movl %r15d, 0x4(%r13)
movl %ebp, (%r13)
movq %r13, %rdi
callq 0x573f0
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_O2/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 0x9fb1a
movq %rdi, %r14
movq (%rdi), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x9f9e4
leal -0x76c(%rbx), %eax
movl %eax, 0x14(%r15)
movq %r15, %rdi
callq 0x573f0
movq (%r14), %rcx
movq %rax, (%rcx)
testl %ebx, %ebx
setns %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x9fb61
movq %rdi, %r14
movq (%rdi), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x9f9e4
movl %ebx, 0x10(%r15)
movq %r15, %rdi
callq 0x573f0
movq (%r14), %rcx
movq %rax, (%rcx)
cmpl $0xc, %ebx
setb %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x9fbab
movq %rdi, %rbx
movq (%rdi), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x9f9e4
movl %r14d, 0xc(%r15)
movq %r15, %rdi
callq 0x573f0
movq (%rbx), %rcx
movq %rax, (%rcx)
cmpl $0x1f, %ebp
setb %al
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9fc4b
movq %rdi, %r14
movq (%rdi), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x9f9e4
movl %ebx, 0x8(%r15)
movq %r15, %rdi
callq 0x573f0
movq (%r14), %rcx
movq %rax, (%rcx)
cmpl $0x18, %ebx
setb %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x9fc91
movq %rdi, %r14
movq (%rdi), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x9f9e4
movl %ebx, 0x4(%r15)
movq %r15, %rdi
callq 0x573f0
movq (%r14), %rcx
movq %rax, (%rcx)
cmpl $0x3c, %ebx
setb %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x9fcd6
movq %rdi, %r14
movq (%rdi), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x9f9e4
movl %ebx, (%r15)
movq %r15, %rdi
callq 0x573f0
movq (%r14), %rcx
movq %rax, (%rcx)
cmpl $0x3c, %ebx
setb %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/misc/math.cpp
// Function: smooth::Math::Pow(int, int)
S::Float S::Math::Pow(Int in, Int ie)
{
	Float	 value = 1;

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

	return value;
}

// Assembly:
cvtsi2sd %edi, %xmm1
movsd 0x435b6(%rip), %xmm0    # 0xe3370
testl %esi, %esi
jns 0x9fdce
testl %esi, %esi
je 0x9fdd3
divsd %xmm1, %xmm0
incl %esi
jmp 0x9fdbe
mulsd %xmm1, %xmm0
subl $0x1, %esi
jae 0x9fdca
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/misc/math.cpp
// Function: smooth::Math::Pow(long long, long long)
S::Float S::Math::Pow(Int64 in, Int64 ie)
{
	Float	 value = 1;

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

	return value;
}

// Assembly:
cvtsi2sd %rdi, %xmm1
movsd 0x4358f(%rip), %xmm0    # 0xe3370
testq %rsi, %rsi
jns 0x9fdf8
testq %rsi, %rsi
je 0x9fdfe
divsd %xmm1, %xmm0
incq %rsi
jmp 0x9fde6
mulsd %xmm1, %xmm0
subq $0x1, %rsi
jae 0x9fdf4
retq
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/misc/memory.cpp
// Function: smooth::Memory::Resize(int)
S::Bool S::Memory::Resize(Int size)
{
	UnsignedByte	*oldMemory = memory;

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

		return False;
	}

	return True;
}

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

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

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

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

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

	Int64	 value = 0;

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

	return value * sign;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
movq %rsi, %rdi
xorl %esi, %esi
callq 0x59270
movq %rax, 0x8(%rsp)
addl $-0x2b, %eax
xorl %r12d, %r12d
testl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
sete %r12b
movq %r14, %rdi
callq 0x58370
movl %eax, %ebp
pushq $-0x1
popq %r13
leal (%r12,%r13), %esi
incl %esi
cmpl %ebp, %esi
jge 0xa0197
movq %r14, %rdi
callq 0x59270
addl $-0x30, %eax
cmpl $0xa, %eax
jae 0xa0197
incl %r13d
jmp 0xa0178
xorl %ebx, %ebx
pushq $0xa
popq %rbp
cmpl $-0x1, %r13d
je 0xa01d1
movq %r14, %rdi
movl %r12d, %esi
callq 0x59270
addl $-0x30, %eax
movslq %eax, %r15
movl %ebp, %edi
movl %r13d, %esi
callq 0x570f0
cvttsd2si %xmm0, %rax
imulq %r15, %rax
addq %rax, %rbx
decl %r13d
incl %r12d
jmp 0xa019c
movq %rbx, %rsi
negq %rsi
cmpl $0x2d, 0x8(%rsp)
cmovneq %rbx, %rsi
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x5a3d0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop