LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/FastFilter[P]BlockBloomSimulator/src/bitset.c
// Function: bitset_symmetric_difference_count
size_t  bitset_symmetric_difference_count(const bitset_t *restrict b1, const bitset_t * restrict b2) {
  size_t minlength = b1->arraysize < b2->arraysize ? b1->arraysize : b2->arraysize;
  size_t k = 0;
  size_t answer = 0;
  for( ; k < minlength; ++k) {
    answer += __builtin_popcountll(b1->array[k] ^ b2->array[k]);
  }
  if(b2->arraysize > b1->arraysize) {
    for( ; k < b2->arraysize; ++k) {
      answer += __builtin_popcountll(b2->array[k]);
    }
  } else {
    for( ; k < b1->arraysize; ++k) {
      answer += __builtin_popcountll(b1->array[k]);
    }
  }
  return answer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x8(%rdi), %r11
movq 0x8(%rsi), %rbx
cmpq %rbx, %r11
movq %rbx, %rcx
cmovbq %r11, %rcx
movabsq $0x5555555555555555, %rdx # imm = 0x5555555555555555
movabsq $0x3333333333333333, %r8 # imm = 0x3333333333333333
movabsq $0xf0f0f0f0f0f0f0f, %r9 # imm = 0xF0F0F0F0F0F0F0F
movabsq $0x101010101010101, %r10 # imm = 0x101010101010101
testq %rcx, %rcx
je 0x35a7
movq (%rdi), %r14
movq (%rsi), %r15
xorl %eax, %eax
xorl %r12d, %r12d
movq (%r15,%r12,8), %r13
xorq (%r14,%r12,8), %r13
movq %r13, %rbp
shrq %rbp
andq %rdx, %rbp
subq %rbp, %r13
movq %r13, %rbp
andq %r8, %rbp
shrq $0x2, %r13
andq %r8, %r13
addq %rbp, %r13
movq %r13, %rbp
shrq $0x4, %rbp
addq %r13, %rbp
andq %r9, %rbp
imulq %r10, %rbp
shrq $0x38, %rbp
addq %rbp, %rax
incq %r12
cmpq %r12, %rcx
jne 0x3561
jmp 0x35a9
xorl %eax, %eax
cmpq %rbx, %r11
jae 0x35f3
movq (%rsi), %rsi
movq (%rsi,%rcx,8), %rdi
movq %rdi, %r11
shrq %r11
andq %rdx, %r11
subq %r11, %rdi
movq %rdi, %r11
andq %r8, %r11
shrq $0x2, %rdi
andq %r8, %rdi
addq %r11, %rdi
movq %rdi, %r11
shrq $0x4, %r11
addq %rdi, %r11
andq %r9, %r11
imulq %r10, %r11
shrq $0x38, %r11
addq %r11, %rax
incq %rcx
cmpq %rcx, %rbx
jne 0x35b1
jmp 0x3638
jbe 0x3638
movq (%rdi), %rsi
movq (%rsi,%rcx,8), %rdi
movq %rdi, %rbx
shrq %rbx
andq %rdx, %rbx
subq %rbx, %rdi
movq %rdi, %rbx
andq %r8, %rbx
shrq $0x2, %rdi
andq %r8, %rdi
addq %rbx, %rdi
movq %rdi, %rbx
shrq $0x4, %rbx
addq %rdi, %rbx
andq %r9, %rbx
imulq %r10, %rbx
shrq $0x38, %rbx
addq %rbx, %rax
incq %rcx
cmpq %rcx, %r11
jne 0x35f8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/FastFilter[P]BlockBloomSimulator/src/bitset.c
// Function: bitset_trim
bool bitset_trim(bitset_t * bitset) {
  size_t newsize = bitset->arraysize;
  while(newsize > 0) {
    if(bitset->array[newsize - 1] == 0)
        newsize -= 1;
    else
        break;
  }
  if(bitset->capacity == newsize) return true; // nothing to do
  bitset->capacity = newsize;
  bitset->arraysize = newsize;
  uint64_t *newarray;
  if ((newarray = (uint64_t *) realloc(bitset->array, sizeof(uint64_t) * bitset->capacity)) == NULL) {
      free(bitset->array);
      return false;
  }
  bitset->array = newarray;
  return true;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
leaq (,%rax,8), %rdx
negq %rdx
movq %rax, %rcx
movq %rdx, %rsi
subq $0x1, %rax
jb 0x3672
movq (%rbx), %rdi
leaq 0x8(%rsi), %rdx
cmpq $0x0, (%rdi,%rax,8)
je 0x3658
movb $0x1, %bpl
cmpq %rcx, 0x10(%rbx)
je 0x36a2
movq %rcx, 0x10(%rbx)
movq %rcx, 0x8(%rbx)
movq (%rbx), %rdi
negq %rsi
callq 0x10e0
testq %rax, %rax
je 0x3698
movq %rax, (%rbx)
jmp 0x36a2
movq (%rbx), %rdi
callq 0x1040
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/tools/translator/infoitem.cpp
// Function: InfoItem::InfoItem(smooth::String const&, smooth::String const&)
InfoItem::InfoItem(const String &iName, const String &iValue) : ListEntry(NIL)
{
	type	= classID;

	name	= iName;
	value	= iValue;

	UpdateText();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x7480
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7090
leaq 0x8(%rsp), %rdi
callq 0x7980
leaq 0x1061b(%rip), %rax     # 0x18178
movq %rax, (%rbx)
leaq 0x630(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x7480
leaq 0x648(%rbx), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x7480
movzwl 0x11951(%rip), %eax     # 0x194da
movw %ax, 0x20(%rbx)
movq %r14, %rdi
movq %r12, %rsi
callq 0x7550
movq %r13, %rdi
movq %r15, %rsi
callq 0x7550
movq %rbx, %rdi
callq 0x7bf6
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
jmp 0x7bdd
movq %rax, %r15
jmp 0x7be5
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x7980
jmp 0x7bed
movq %rax, %r15
movq %r13, %rdi
callq 0x7980
movq %r14, %rdi
callq 0x7980
movq %rbx, %rdi
callq 0x7960
movq %r15, %rdi
callq 0x7290
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/signals/signal.h
// Function: int smooth::Signal1<void, smooth::GUI::ListEntry*>::Disconnect<Section, Section, void>(void (Section::*)(smooth::GUI::ListEntry*), Section*)
Int Disconnect(slotReturnTYPE (classTYPE::*proc)(SIGNALS_ARGUMENT_TYPES), oClassTYPE *inst)
			{
				if (slotsN == NIL) return Error();

				SIGNALS_SLOT_CLASS_CLASS_NAME<classTYPE, slotReturnTYPE SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES>	 slot(proc, inst);

				for (Int i = slotsN->Length() - 1; i >= 0; i--)
				{
					if ((*((SIGNALS_SLOT_BASE_CLASS_NAME<Void SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES> *) slotsN->GetNth(i))) == slot)
					{
						RemoveNthN(i);

						break;
					}
				}

				return Success();
			}

// Assembly:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x8f92
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0xf679(%rip), %rdi      # 0x185c0
movq %rsp, %r14
movq %rdi, (%r14)
movq %rsi, 0x10(%r14)
movq %rdx, 0x18(%r14)
movq %rcx, 0x8(%r14)
movl 0x8(%rax), %ebp
testl %ebp, %ebp
jle 0x8f87
decl %ebp
movq 0x10(%rbx), %rdi
movl %ebp, %esi
callq 0x920c
movq (%rax), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x20(%rax)
testb %al, %al
je 0x8f5c
movq %rbx, %rdi
movl %ebp, %esi
callq 0x9160
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/signals/signal.h
// Function: int smooth::Signal1<void, smooth::GUI::ListEntry*>::Connect<Section, Section, void>(void (Section::*)(smooth::GUI::ListEntry*), Section*)
Int Connect(slotReturnTYPE (classTYPE::*proc)(SIGNALS_ARGUMENT_TYPES), oClassTYPE *inst)
			{
				if (slotsN == NIL)
				{
					slotsN = new Array<Void *>();
					slotsN->EnableLocking();
				}

				slotsN->Add(new SIGNALS_SLOT_CLASS_CLASS_NAME<classTYPE, slotReturnTYPE SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES>(proc, inst));

				return Success();
			}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq 0x10(%rdi), %r13
testq %r13, %r13
jne 0x8fff
movq %rdi, %r12
movl $0x58, %edi
callq 0x7530
movq %rax, %r13
movq %rax, %rdi
callq 0x7130
leaq 0xf6ea(%rip), %rax      # 0x186c0
movq %rax, 0x40(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r13)
leaq 0xf637(%rip), %rax      # 0x18620
movq %rax, (%r13)
movq %r13, 0x10(%r12)
movq %r13, %rdi
callq 0x72b0
movq 0x10(%r12), %r13
movl $0x20, %edi
callq 0x7530
leaq 0xf5b0(%rip), %rcx      # 0x185c0
movq %rcx, (%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r13, %rdi
callq 0xa62c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x58, %esi
movq %r13, %rdi
callq 0x70a0
movq %rbx, %rdi
callq 0x7290
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/signals/signal.h
// Function: smooth::Signal1<void, smooth::GUI::ListEntry*>::Emit(smooth::GUI::ListEntry*) const
Void Emit(SIGNALS_ARGUMENT_PARAMETER_LIST) const
			{
				if (slotsN == NIL && slots0 == NIL) return;

				ProtectParent();

				for (Int i = 0; slotsN != NIL && i < slotsN->Length(); i++) ((SIGNALS_SLOT_BASE_CLASS_NAME<Void SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES> *) slotsN->GetNth(i))->Emit(SIGNALS_ARGUMENT_PARAMETERS);
				for (Int j = 0; slots0 != NIL && j < slots0->Length(); j++) ((SlotBase0<Void> *) slots0->GetNth(j))->Emit();

				UnprotectParent();
			}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x18(%rbx), %rax
orq %rdi, %rax
je 0x90f7
movq %rsi, %r14
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x908c
addq $0x1c, %rax
movq %rax, %rdi
callq 0x77e0
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x90b6
xorl %ebp, %ebp
cmpl 0x8(%rdi), %ebp
jge 0x90b6
movl %ebp, %esi
callq 0x920c
movq (%rax), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x18(%rax)
incl %ebp
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
jne 0x9093
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x90e1
xorl %ebp, %ebp
cmpl 0x8(%rdi), %ebp
jge 0x90e1
movl %ebp, %esi
callq 0x920c
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
incl %ebp
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
jne 0x90c1
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x90f7
addq $0x1c, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7120
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/signals/signal.h
// Function: smooth::Signal1<void, smooth::GUI::ListEntry*>::RemoveNthN(int)
Void RemoveNthN(Int n)
			{
				if (slotsN == NIL)	   return;
				if (slotsN->Length() <= n) return;

				delete (SIGNALS_SLOT_BASE_CLASS_NAME<Void SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES> *) slotsN->GetNth(n);

				slotsN->RemoveNth(n);

				if (slotsN->Length() == 0)
				{
					delete slotsN;

					slotsN = NIL;
				}
			}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x91af
movl %esi, %ebp
cmpl %esi, 0x8(%rdi)
jle 0x91af
movl %ebp, %esi
callq 0x920c
movq (%rax), %rdi
testq %rdi, %rdi
je 0x918b
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *0x18(%rax)
movq 0x10(%rbx), %rdi
cmpl $0x0, 0x8(%rdi)
jne 0x91af
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/signals/signal.h
// Function: smooth::Signal1<void, smooth::GUI::ListEntry*>::RemoveNth0(int)
Void RemoveNth0(Int n)
			{
				if (slots0 == NIL)	   return;
				if (slots0->Length() <= n) return;

				delete (SlotBase0<Void> *) slots0->GetNth(n);

				slots0->RemoveNth(n);

				if (slots0->Length() == 0)
				{
					delete slots0;

					slots0 = NIL;
				}
			}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x9205
movl %esi, %ebp
cmpl %esi, 0x8(%rdi)
jle 0x9205
movl %ebp, %esi
callq 0x920c
movq (%rax), %rdi
testq %rdi, %rdi
je 0x91e1
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *0x18(%rax)
movq 0x18(%rbx), %rdi
cmpl $0x0, 0x8(%rdi)
jne 0x9205
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/array/arraybackend.h
// Function: smooth::ArrayBackend<void*>::GetNth(int) const
const s &GetNth(Int n) const
			{
				ReadLock	 lock(*this);

				if (nOfEntries > n && n >= 0)
				{
					const s	&entry = entries[n]->value;

					lastAccessedEntry = n;

					return entry;
				}

				return nullValue;
			}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq %rdi, 0x8(%rsp)
cmpb $0x1, 0x30(%rdi)
jne 0x922e
movq 0x38(%r14), %rdi
callq 0x7240
leaq 0x102cb(%rip), %r15     # 0x19500
testl %ebx, %ebx
js 0x9250
cmpl %ebx, 0x8(%r14)
jle 0x9250
movq 0x48(%r14), %rax
movq (%rax), %rax
movl %ebx, %ecx
movq (%rax,%rcx,8), %r15
movl %ebx, 0x14(%r14)
leaq 0x8(%rsp), %rdi
callq 0x9268
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/array/arraybackend.h
// Function: smooth::ArrayBackend<StringItem*>::MoveNth(int, int)
Bool MoveNth(Int n, Int m)
			{
				WriteLock	 lock(*this);

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

				ArrayEntry
	*backupEntry = entries[n];

				if (m < n) memmove(entries + m + 1, entries + m, (n - m) * sizeof(ArrayEntry
 *));
				else	   memmove(entries + n, entries + n + 1, (m - n) * sizeof(ArrayEntry
 *));

				entries[m] = backupEntry;

				return IndexArray::MoveNth(n, m);
			}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movq %rdi, 0x8(%rsp)
cmpb $0x1, 0x30(%rdi)
jne 0x92c5
movq 0x38(%r14), %rdi
callq 0x74d0
movl 0x8(%r14), %eax
cmpl %ebp, %eax
setle %cl
testl %ebp, %ebp
sets %dl
orb %cl, %dl
jne 0x92e5
cmpl %ebx, %eax
setle %al
testl %ebx, %ebx
sets %cl
orb %al, %cl
je 0x92e9
xorl %ebx, %ebx
jmp 0x934d
movq 0x48(%r14), %rax
movq (%rax), %rax
movl %ebp, %ecx
movq (%rax,%rcx,8), %r15
movl %ebx, %edx
subl %ebp, %edx
jae 0x931d
movl %ebx, %r12d
leaq (%rax,%r12,8), %rsi
leaq (%rax,%r12,8), %rdi
addq $0x8, %rdi
movl %ebp, %eax
subl %ebx, %eax
movslq %eax, %rdx
shlq $0x3, %rdx
callq 0x70e0
jmp 0x9334
leaq (%rax,%rcx,8), %rdi
leaq 0x8(%rdi), %rsi
movslq %edx, %rdx
shlq $0x3, %rdx
callq 0x70e0
movl %ebx, %r12d
movq 0x48(%r14), %rax
movq (%rax), %rax
movq %r15, (%rax,%r12,8)
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x76d0
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x954e
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x954e
movq %rbx, %rdi
callq 0x7290
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/array/arraybackend.h
// Function: smooth::ArrayBackend<StringItem*>::RemoveNth(int)
Bool RemoveNth(Int n)
			{
				WriteLock	 lock(*this);

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

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

				delete entries[n];

				memmove(entries + n, entries + n + 1, (nOfEntries - n - 1) * sizeof(ArrayEntry
 *));

				return IndexArray::RemoveNth(n);
			}

// 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 0x939d
movq 0x38(%rbx), %rdi
callq 0x74d0
movl 0x8(%rbx), %eax
cmpl %ebp, %eax
setle %cl
testl %ebp, %ebp
sets %dl
orb %cl, %dl
je 0x93b2
xorl %ebx, %ebx
jmp 0x9415
cmpl $0x1, %eax
jne 0x93c2
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
jmp 0x9413
movq 0x48(%rbx), %rax
movq (%rax), %rax
movl %ebp, %r14d
movq (%rax,%r14,8), %rdi
movl $0x8, %esi
callq 0x70a0
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0x93e8
movq (%rax), %rax
jmp 0x93ea
xorl %eax, %eax
leaq (%rax,%r14,8), %rdi
leaq (%rax,%r14,8), %rsi
addq $0x8, %rsi
movl %ebp, %eax
notl %eax
addl 0x8(%rbx), %eax
movslq %eax, %rdx
shlq $0x3, %rdx
callq 0x70e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7600
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x954e
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x954e
movq %rbx, %rdi
callq 0x7290
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/array/arraybackend.h
// Function: smooth::ArrayBackend<StringItem*>::RemoveAll()
Bool RemoveAll()
			{
				WriteLock	 lock(*this);

				if (nOfEntries == 0) return True;

				for (Int i = 0; i < nOfEntries; i++) delete entries[i];

				entries.Free();

				return IndexArray::RemoveAll();
			}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdi, (%rsp)
cmpb $0x1, 0x30(%rdi)
jne 0x945a
movq 0x38(%rbx), %rdi
callq 0x74d0
cmpl $0x0, 0x8(%rbx)
je 0x949b
jle 0x9486
xorl %r14d, %r14d
movq 0x48(%rbx), %rax
movq (%rax), %rax
movq (%rax,%r14,8), %rdi
movl $0x8, %esi
callq 0x70a0
incq %r14
movslq 0x8(%rbx), %rax
cmpq %rax, %r14
jl 0x9465
leaq 0x40(%rbx), %rdi
callq 0x950c
movq %rbx, %rdi
callq 0x71a0
movl %eax, %ebx
jmp 0x949d
movb $0x1, %bl
movq %rsp, %rdi
callq 0x954e
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x954e
movq %rbx, %rdi
callq 0x7290
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/buffer/buffer.h
// Function: smooth::Buffer<smooth::ArrayEntry<StringItem*>*>::Free()
Bool Free()
			{
				/* Check if this is actually our memory.
				 */
				if (allocated == -1) return False;

				/* Nothing to free?
				 */
				if (memory == NIL) return True;

				delete memory;

				memory		= NIL;

				size		= 0;
				allocated	= 0;

				return True;
			}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl 0x14(%rdi), %ebp
cmpl $-0x1, %ebp
je 0x9543
movq %rdi, %rbx
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x9543
addq $0x8, %rbx
movq %r14, %rdi
callq 0x75c0
movl $0x8, %esi
movq %r14, %rdi
callq 0x70a0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
cmpl $-0x1, %ebp
setne %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/array/arraybackend.h
// Function: smooth::ArrayBackend<StringItem*>::GetNthReference(int)
s &GetNthReference(Int n)
			{
				ReadLock	 lock(*this);

				if (nOfEntries > n && n >= 0)
				{
					s	&entry = entries[n]->value;

					lastAccessedEntry = n;

					return entry;
				}

				return nullValue;
			}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq %rdi, 0x8(%rsp)
cmpb $0x1, 0x30(%rdi)
jne 0x9b1e
movq 0x38(%r14), %rdi
callq 0x7240
leaq 0xf9e3(%rip), %r15      # 0x19508
testl %ebx, %ebx
js 0x9b40
cmpl %ebx, 0x8(%r14)
jle 0x9b40
movq 0x48(%r14), %rax
movq (%rax), %rax
movl %ebx, %ecx
movq (%rax,%rcx,8), %r15
movl %ebx, 0x14(%r14)
leaq 0x8(%rsp), %rdi
callq 0x9268
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/array/arraybackend.h
// Function: smooth::ArrayBackend<smooth::GUI::ListEntry*>::Add(smooth::GUI::ListEntry* const&, int)
Bool Add(const s &value, Int index)
			{
				WriteLock	 lock(*this);
				Int		 nOfEntries = this->nOfEntries;

				if (!IndexArray::InsertAtPos(nOfEntries, index)) return False;

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

				entries[nOfEntries] = new ArrayEntry
(value);

				return True;
			}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, (%rsp)
cmpb $0x1, 0x30(%rdi)
jne 0x9ce6
movq 0x38(%rbx), %rdi
callq 0x74d0
movl 0x8(%rbx), %r15d
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x70b0
movl %eax, %ebp
testb %al, %al
je 0x9d47
cmpl %r15d, 0x50(%rbx)
jne 0x9d29
leaq 0x40(%rbx), %rdi
cvtsi2sd %r15d, %xmm0
mulsd 0x831c(%rip), %xmm0     # 0x12030
movsd 0x831c(%rip), %xmm1     # 0x12038
maxsd %xmm0, %xmm1
cvttsd2si %xmm1, %esi
callq 0x9d70
movl $0x8, %edi
callq 0x7530
movslq %r15d, %rcx
movq (%r14), %rdx
movq %rdx, (%rax)
movq 0x48(%rbx), %rdx
movq (%rdx), %rdx
movq %rax, (%rdx,%rcx,8)
movq %rsp, %rdi
callq 0x954e
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x954e
movq %rbx, %rdi
callq 0x7290
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/buffer/buffer.h
// Function: smooth::Buffer<smooth::ArrayEntry<smooth::GUI::ListEntry*>*>::Resize(int)
Bool Resize(Int nSize)
			{
				/* Check if this is actually our memory.
				 */
				if (allocated == -1) return False;

				/* Let's see if we really need to reallocate.
				 */
				if (nSize > allocated)
				{
					if (memory != NIL) memory->Resize(nSize * sizeof(t));
					else		   memory = new Memory(nSize * sizeof(t));

					size		= nSize;
					allocated	= nSize;
				}
				else
				{
					size		= nSize;
				}

				return True;
			}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x14(%rdi), %ebp
cmpl $-0x1, %ebp
je 0x9dcd
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, %ebp
jge 0x9d9f
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x9da5
leal (,%rbx,8), %esi
callq 0x71b0
jmp 0x9dc5
movl %ebx, 0x10(%r14)
jmp 0x9dcd
movl $0x8, %edi
callq 0x7530
movq %rax, %r15
leal (,%rbx,8), %esi
movq %rax, %rdi
callq 0x7590
movq %r15, 0x8(%r14)
movl %ebx, 0x10(%r14)
movl %ebx, 0x14(%r14)
cmpl $-0x1, %ebp
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x8, %esi
movq %r15, %rdi
callq 0x70a0
movq %rbx, %rdi
callq 0x7290
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/array/arraybackend.h
// Function: smooth::ArrayBackend<smooth::GUI::Tree*>::Add(smooth::GUI::Tree* const&)
Int Add(const s &value)
			{
				WriteLock	 lock(*this);
				Int		 index = greatestIndex + 1;

				if (!Add(value, index))	index = -1;

				return index;
			}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, 0x8(%rsp)
cmpb $0x1, 0x30(%rdi)
jne 0xa130
movq 0x38(%r14), %rdi
callq 0x74d0
movl 0xc(%r14), %ebp
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0xa178
testb %al, %al
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmovnel %ebp, %ebx
leaq 0x8(%rsp), %rdi
callq 0x954e
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x954e
movq %rbx, %rdi
callq 0x7290
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/tools/translator/stringitem.cpp
// Function: StringItem::StringItem(int, smooth::String const&, smooth::String const&)
StringItem::StringItem(Int iID, const String &iOriginal, const String &iTranslation) : ListEntry(NIL)
{
	type		= classID;

	id		= iID;

	original	= iOriginal;
	translation	= iTranslation;

	UpdateText();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x7480
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7090
movq %rsp, %rdi
callq 0x7980
leaq 0xde8c(%rip), %rax      # 0x186f0
movq %rax, (%rbx)
leaq 0x638(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x7480
leaq 0x650(%rbx), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x7480
movzwl 0xec98(%rip), %eax      # 0x19528
movw %ax, 0x20(%rbx)
movl %ebp, 0x630(%rbx)
movq %r14, %rdi
movq %r12, %rsi
callq 0x7550
movq %r13, %rdi
movq %r15, %rsi
callq 0x7550
movq %rbx, %rdi
callq 0xa902
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0xa8e9
movq %rax, %r15
jmp 0xa8f1
movq %rax, %r15
movq %rsp, %rdi
callq 0x7980
jmp 0xa8f9
movq %rax, %r15
movq %r13, %rdi
callq 0x7980
movq %r14, %rdi
callq 0x7980
movq %rbx, %rdi
callq 0x7960
movq %r15, %rdi
callq 0x7290
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/tools/translator/../../include/smooth/main.h
// Function: main
int main(int argc, char **argv)
{
	ArgumentsParser	 args(argc, argv);

	GUI::Application::SetCommand(args.GetCommand());
	GUI::Application::SetArguments(args.GetArguments());

	GUI::Application::GetStartupDirectory();
	GUI::Application::GetApplicationDirectory();

	Int	 retValue = -1;

	if (Init())
	{
		if (System::System::GetAPIVersion() != (String) SMOOTH_APIVERSION)
		{
			Free();

			return -1;
		}

		retValue = Main();

		Free();
	}

	return retValue;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x838, %rsp            # imm = 0x838
movq %rsi, %rdx
movl %edi, %esi
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0x78d0
movq 0xe5b6(%rip), %rdi      # 0x18fc8
movq %rbx, %rsi
callq 0x7550
leaq 0x68(%rsp), %rdi
callq 0x7670
leaq 0x38(%rsp), %rdi
callq 0x78b0
leaq 0x38(%rsp), %rdi
callq 0x7980
leaq 0x20(%rsp), %rdi
callq 0x7320
leaq 0x20(%rsp), %rdi
callq 0x7980
callq 0x73e0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testb %al, %al
je 0xaaf2
leaq 0xc0(%rsp), %rdi
callq 0x7360
leaq 0x787f(%rip), %rsi      # 0x122f1
leaq 0x8(%rsp), %rdi
callq 0x77f0
leaq 0xc0(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x7700
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x7980
leaq 0xc0(%rsp), %rdi
callq 0x7980
testb %bpl, %bpl
je 0xaab3
callq 0x75d0
jmp 0xaaf2
movq 0xe4c6(%rip), %rdi      # 0x18f80
xorl %esi, %esi
callq 0x10908
leaq 0xc0(%rsp), %rdi
movq %rax, %rsi
callq 0xab54
leaq 0xc0(%rsp), %rdi
callq 0x7780
movl %eax, %ebx
leaq 0xc0(%rsp), %rdi
callq 0xee16
callq 0x75d0
leaq 0x50(%rsp), %rdi
callq 0x76e0
movl %ebx, %eax
addq $0x838, %rsp            # imm = 0x838
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0xee16
jmp 0xab42
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7980
jmp 0xab2c
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0x7980
jmp 0xab42
jmp 0xab3f
jmp 0xab3f
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x76e0
movq %rbx, %rdi
callq 0x7290
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/tools/translator/translator.cpp
// Function: Translator::FilterEntries()
Void Translator::FilterEntries()
{
	/* Clean up if filter text is empty.
	 */
	if (edit_filter->GetText() == NIL)
	{
		ClearFilter();

		return;
	}

	/* Update entries and exchange list widgets.
	 */
	Surface	*surface = wnd->GetDrawSurface();

	surface->StartPaint(Rect(list_entries->GetRealPosition(), list_entries->GetRealSize()));

	Int	 scrollbarPos = -1;

	if (list_filtered->IsVisible()) scrollbarPos = ((Scrollbar *) list_filtered->GetNthObject(0))->GetValue();

	list_entries->Hide();

	ClearFilter(list_filtered);

	dataSection->Filter(edit_filter->GetText().ToLower(), list_filtered);

	((Scrollbar *) list_filtered->GetNthObject(0))->SetValue(scrollbarPos);

	list_filtered->Show();

	surface->EndPaint();

	/* Activate clear button.
	 */
	button_clear->Activate();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x5f0(%rdi), %rdi
movq (%rdi), %rax
callq *0xa8(%rax)
movq %rax, %rdi
xorl %esi, %esi
callq 0x74e0
testb %al, %al
je 0xc807
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xc956
movq 0x5b8(%rbx), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, %r14
movq 0x600(%rbx), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movq %rax, %r15
movq %rax, %r12
shrq $0x20, %r12
movq 0x600(%rbx), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
leal (%rax,%r15), %ecx
shrq $0x20, %rax
leaq 0x8(%rsp), %rsi
movl %r15d, (%rsi)
movl %r12d, 0x4(%rsi)
movl %ecx, 0x8(%rsi)
addl %r12d, %eax
movl %eax, 0xc(%rsi)
movq %r14, %rdi
callq 0x74f0
movq 0x608(%rbx), %rdi
movq (%rdi), %rax
callq *0x90(%rax)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testb %al, %al
je 0xc897
movq 0x608(%rbx), %rdi
addq $0x38, %rdi
xorl %esi, %esi
callq 0x920c
movq (%rax), %rax
movq 0x5d0(%rax), %rax
movl (%rax), %ebp
movq 0x600(%rbx), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
movq 0x608(%rbx), %rsi
movq %rbx, %rdi
callq 0xf268
movq 0x768(%rbx), %r15
movq 0x5f0(%rbx), %rdi
movq (%rdi), %rax
callq *0xa8(%rax)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x7380
movq 0x608(%rbx), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x8c10
leaq 0x8(%rsp), %rdi
callq 0x7980
movq 0x608(%rbx), %rdi
addq $0x38, %rdi
xorl %esi, %esi
callq 0x920c
movq (%rax), %rdi
movl %ebp, %esi
callq 0x7710
movq 0x608(%rbx), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
movq %r14, %rdi
callq 0x7900
movq 0x5f8(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7980
movq %rbx, %rdi
callq 0x7290
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/tools/translator/translator.cpp
// Function: Translator::NewEntry()
Void Translator::NewEntry()
{
	Int	 id = 1;

	if (entries.Length() > 7)
	{
		StringItem	*entry = (StringItem *) entries.GetLast();

		id = Math::Max(entry->GetID(), 0) + 1;
	}

	text_id->Activate();
	edit_id->Activate();
	text_original->Activate();
	edit_original->Activate();
	text_translated->Activate();
	edit_translated->Activate();
	button_save->Activate();
	button_remove->Activate();
	button_copy->Activate();

	menu_entry->GetNthEntry(2)->Activate();
	menu_entry->GetNthEntry(3)->Activate();

	text_original->SetText("Original:");
	text_translated->SetText("Translation:");

	edit_id->SetText(String::FromInt(id));
	edit_original->SetText(NIL);
	edit_translated->SetText(NIL);

	modified = True;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x1, %r14d
cmpl $0x8, 0x6c0(%rdi)
jl 0xce16
leaq 0x6b8(%rbx), %rdi
callq 0x111cc
movq (%rax), %rax
movl 0x630(%rax), %eax
xorl %r14d, %r14d
testl %eax, %eax
cmovgl %eax, %r14d
incl %r14d
movq 0x640(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq 0x648(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq 0x650(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq 0x658(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq 0x660(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq 0x668(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq 0x670(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq 0x678(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq 0x680(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq 0x5e0(%rbx), %rdi
movq (%rdi), %rax
movl $0x2, %esi
callq *0x180(%rax)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x68(%rcx)
movq 0x5e0(%rbx), %rdi
movq (%rdi), %rax
movl $0x3, %esi
callq *0x180(%rax)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x68(%rcx)
movq 0x650(%rbx), %r15
leaq 0x54f9(%rip), %rsi      # 0x123ce
movq %rsp, %r12
movq %r12, %rdi
callq 0x77f0
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0xa0(%rax)
movq %rsp, %rdi
callq 0x7980
movq 0x660(%rbx), %r15
leaq 0x54d3(%rip), %rsi      # 0x123d8
movq %rsp, %r12
movq %r12, %rdi
callq 0x77f0
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0xa0(%rax)
movq %rsp, %rdi
callq 0x7980
movq 0x648(%rbx), %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x7220
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0xa0(%rax)
movq %rsp, %rdi
callq 0x7980
movq 0x658(%rbx), %r14
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x7480
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0xa0(%rax)
movq %rsp, %rdi
callq 0x7980
movq 0x668(%rbx), %r14
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x7480
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0xa0(%rax)
movq %rsp, %rdi
callq 0x7980
movb $0x1, 0x770(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xcfc4
jmp 0xcfc4
jmp 0xcfc4
jmp 0xcfc4
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7980
movq %rbx, %rdi
callq 0x7290
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/tools/translator/translator.cpp
// Function: Translator::RemoveEntry()
Void Translator::RemoveEntry()
{
	/* Get selected entry.
	 */
	StringItem	*entry = NIL;

	if (edit_filter->GetText() == NIL) entry = (StringItem *) GetSelectedEntry(list_entries);
	else				   entry = (StringItem *) GetSelectedEntry(list_filtered);

	if (entry == NIL) return;

	/* Find list corresponding to selected entry.
	 */
	Int	 id   = entry->GetID();
	List	*list = GetEntryList(list_entries, id);

	entry = (StringItem *) entries.Get(id);

	/* Remove entry.
	 */
	entries.Remove(id);

	list->Remove(entry);

	if (createdEntries.Get(id) != NIL)
	{
		DeleteObject(entry);

		createdEntries.Remove(id);
	}

	SelectEntry(NIL);

	if (edit_filter->GetText() != NIL) FilterEntries();
	else				   list_entries->Paint(SP_PAINT);

	modified = True;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x5f0(%rdi), %rdi
movq (%rdi), %rax
callq *0xa8(%rax)
movq %rax, %rdi
xorl %esi, %esi
callq 0x74e0
xorb $0x1, %al
movzbl %al, %eax
movq 0x600(%rbx,%rax,8), %rsi
movq %rbx, %rdi
callq 0x10024
testq %rax, %rax
je 0xd0d0
movl 0x630(%rax), %ebp
movq 0x600(%rbx), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x100b6
movq %rax, %r15
leaq 0x6b8(%rbx), %r12
movq %r12, %rdi
movl %ebp, %esi
callq 0x9c10
movq (%rax), %r14
movq %r12, %rdi
movl %ebp, %esi
callq 0x7920
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x38(%rax)
leaq 0x710(%rbx), %r15
movq %r15, %rdi
movl %ebp, %esi
callq 0x9c10
cmpq $0x0, (%rax)
je 0xd088
movq %r14, %rdi
callq 0x7950
movq %r15, %rdi
movl %ebp, %esi
callq 0x7920
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc2de
movq 0x5f0(%rbx), %rdi
movq (%rdi), %rax
callq *0xa8(%rax)
movq %rax, %rdi
xorl %esi, %esi
callq 0x76f0
testb %al, %al
je 0xd0ba
movq %rbx, %rdi
callq 0xc7c6
jmp 0xd0c9
movq 0x600(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x78(%rax)
movb $0x1, 0x770(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/tools/translator/translator.cpp
// Function: Translator::OpenFile()
Void Translator::OpenFile()
{
	if (!ExitProc()) return;

	FileSelection	 dialog;

	dialog.SetParentWindow(wnd);

	dialog.AddFilter("XML Language Files", "*.xml");
	dialog.AddFilter("All Files", "*.*");

	if (dialog.ShowDialog() == Success())
	{
		OpenFileName(dialog.GetFileName());
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x778, %rsp            # imm = 0x778
movq %rdi, %rbx
callq 0xe5fc
testb %al, %al
je 0xdfcc
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x7810
movq 0x5b8(%rbx), %rsi
movq %r14, %rdi
callq 0x70f0
leaq 0x458e(%rip), %rsi      # 0x1247d
leaq 0x8(%rsp), %rdi
callq 0x77f0
leaq 0x4590(%rip), %rsi      # 0x12490
leaq 0x20(%rsp), %rdi
callq 0x77f0
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x7230
leaq 0x20(%rsp), %rdi
callq 0x7980
leaq 0x8(%rsp), %rdi
callq 0x7980
leaq 0x455d(%rip), %rsi      # 0x12496
leaq 0x8(%rsp), %rdi
callq 0x77f0
leaq 0x4556(%rip), %rsi      # 0x124a0
leaq 0x20(%rsp), %rdi
callq 0x77f0
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x7230
leaq 0x20(%rsp), %rdi
callq 0x7980
leaq 0x8(%rsp), %rdi
callq 0x7980
leaq 0x38(%rsp), %rdi
callq 0x7370
movq 0xb043(%rip), %rcx      # 0x18fd0
addq $0x10, %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movl $0x0, 0x8(%rsi)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
testb %al, %al
je 0xdfc2
leaq 0x38(%rsp), %rdi
callq 0x7100
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe7a0
leaq 0x38(%rsp), %rdi
callq 0x7510
addq $0x778, %rsp            # imm = 0x778
popq %rbx
popq %r14
retq
jmp 0xdfff
jmp 0xdfdf
jmp 0xdfee
jmp 0xdfff
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x7980
jmp 0xdff1
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7980
jmp 0xe002
jmp 0xdfff
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x7510
movq %rbx, %rdi
callq 0x7290
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/tools/translator/translator.cpp
// Function: Translator::ExitProc()
Bool Translator::ExitProc()
{
	if (entries.Length() == 0) return True;

	if (!modified)
	{
		CloseFile();

		return True;
	}

	Int	 id = QuickMessage(String("Do you want to save changes in ").Append(GetShortFileName(fileName)).Append("?"), "smooth Translator", Message::Buttons::YesNoCancel, Message::Icon::Question);

	switch (id)
	{
		case Message::Button::Yes:
			SaveFile();
			CloseFile();

			return True;
		case Message::Button::No:
			CloseFile();

			return True;
		case Message::Button::Cancel:
		case Message::Button::Close:
			return False;
	}

	return True;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movb $0x1, %bl
cmpl $0x0, 0x6c0(%rdi)
je 0xe6f4
movq %rdi, %r14
cmpb $0x0, 0x770(%rdi)
je 0xe6ec
leaq 0x3dec(%rip), %rsi      # 0x12417
leaq 0x48(%rsp), %rdi
callq 0x77f0
leaq 0x688(%r14), %rdx
leaq 0x30(%rsp), %rdi
callq 0xf1f6
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x7170
movq %rax, %r15
leaq 0x3dd8(%rip), %rsi      # 0x12437
leaq 0x18(%rsp), %rdi
callq 0x77f0
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0x7170
movq %rax, %r15
leaq 0x3c77(%rip), %rsi      # 0x122f7
movq %rsp, %rdi
callq 0x77f0
movq %rsp, %rsi
movq %r15, %rdi
movl $0x3, %edx
movl $0x7f02, %ecx           # imm = 0x7F02
callq 0x7350
movl %eax, %r15d
movq %rsp, %rdi
callq 0x7980
leaq 0x18(%rsp), %rdi
callq 0x7980
leaq 0x30(%rsp), %rdi
callq 0x7980
leaq 0x48(%rsp), %rdi
callq 0x7980
addl $-0x2, %r15d
cmpl $0x6, %r15d
ja 0xe6f4
leaq 0x3bf1(%rip), %rax      # 0x122c8
movslq (%rax,%r15,4), %rcx
addq %rax, %rcx
jmpq *%rcx
xorl %ebx, %ebx
jmp 0xe6f4
movq %r14, %rdi
callq 0xe014
movq %r14, %rdi
callq 0xef8a
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7980
jmp 0xe712
jmp 0xe70f
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x7980
jmp 0xe723
jmp 0xe720
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x7980
leaq 0x48(%rsp), %rdi
callq 0x7980
movq %rbx, %rdi
callq 0x7290
movq %rax, %rbx
jmp 0xe72d
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/tools/translator/translator.cpp
// Function: Translator::OnChangeSize(smooth::GUI::Size const&)
Void Translator::OnChangeSize(const Size &size)
{
	Size	 clientSize  = wnd->GetClientRect().GetSize();

	Float	 splitFactor = this->splitFactor;
	Int	 splitterPos = Float(clientSize.cy) * splitFactor;

	updateSplitter = True;

	OnDragSplitter(splitterPos);

	this->splitFactor = splitFactor;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x5b8(%rdi), %rdi
callq 0x7630
shrq $0x20, %rdx
shrq $0x20, %rax
subl %eax, %edx
movsd 0x620(%rbx), %xmm1
movsd %xmm1, 0x8(%rsp)
cvtsi2sd %edx, %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %esi
movb $0x1, 0x628(%rbx)
movq %rbx, %rdi
callq 0xca6c
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x620(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/tools/translator/translator.cpp
// Function: Translator::~Translator()
Translator::~Translator()
{
	CloseFile();

	DeleteObject(title);
	DeleteObject(wnd);
	DeleteObject(menubar);
	DeleteObject(menu_file);
	DeleteObject(menu_entry);
	DeleteObject(statusbar);

	DeleteObject(text_filter);
	DeleteObject(edit_filter);
	DeleteObject(button_clear);

	DeleteObject(list_entries);
	DeleteObject(list_filtered);

	DeleteObject(droparea);

	DeleteObject(splitter);

	DeleteObject(layer_edit);

	DeleteObject(text_id);
	DeleteObject(edit_id);
	DeleteObject(text_original);
	DeleteObject(edit_original);
	DeleteObject(text_translated);
	DeleteObject(edit_translated);
	DeleteObject(button_save);
	DeleteObject(button_remove);
	DeleteObject(button_new);
	DeleteObject(button_copy);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x9a5f(%rip), %rax      # 0x18880
movq %rax, (%rdi)
callq 0xef8a
movq 0x5c0(%rbx), %rdi
callq 0x7950
movq 0x5b8(%rbx), %rdi
callq 0x7950
movq 0x5c8(%rbx), %rdi
callq 0x7950
movq 0x5d8(%rbx), %rdi
callq 0x7950
movq 0x5e0(%rbx), %rdi
callq 0x7950
movq 0x5d0(%rbx), %rdi
callq 0x7950
movq 0x5e8(%rbx), %rdi
callq 0x7950
movq 0x5f0(%rbx), %rdi
callq 0x7950
movq 0x5f8(%rbx), %rdi
callq 0x7950
movq 0x600(%rbx), %rdi
callq 0x7950
movq 0x608(%rbx), %rdi
callq 0x7950
movq 0x610(%rbx), %rdi
callq 0x7950
movq 0x618(%rbx), %rdi
callq 0x7950
movq 0x630(%rbx), %rdi
callq 0x7950
movq 0x640(%rbx), %rdi
callq 0x7950
movq 0x648(%rbx), %rdi
callq 0x7950
movq 0x650(%rbx), %rdi
callq 0x7950
movq 0x658(%rbx), %rdi
callq 0x7950
movq 0x660(%rbx), %rdi
callq 0x7950
movq 0x668(%rbx), %rdi
callq 0x7950
movq 0x670(%rbx), %rdi
callq 0x7950
movq 0x678(%rbx), %rdi
callq 0x7950
movq 0x638(%rbx), %rdi
callq 0x7950
movq 0x680(%rbx), %rdi
callq 0x7950
leaq 0x710(%rbx), %rdi
callq 0x1073a
leaq 0x6b8(%rbx), %rdi
callq 0x1073a
leaq 0x6a0(%rbx), %rdi
callq 0x7980
leaq 0x688(%rbx), %rdi
callq 0x7980
movq %rbx, %rdi
popq %rbx
jmp 0x74a0
movq %rax, %rdi
callq 0x8ee8
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/tools/translator/translator.cpp
// Function: Translator::ClearFilter(smooth::GUI::List*)
Void Translator::ClearFilter(List *list)
{
	/* Recursively clear this and subordinate sections.
	 */
	for (Int i = list->Length() - 1; i >= 0; i--)
	{
		ListEntry	*entry = list->GetNthEntry(i);

		if (entry->GetObjectType() == Tree::classID) ClearFilter(((Tree *) entry)->GetList());

		list->Remove(entry);

		delete entry;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x178(%rax)
testl %eax, %eax
jle 0xf2e7
movl %eax, %r15d
movq 0x9cf8(%rip), %rax      # 0x18f88
incl %r15d
movswl (%rax), %ebp
leal -0x2(%r15), %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x180(%rax)
movq %rax, %r12
leaq 0x20(%rax), %rdi
movl %ebp, %esi
callq 0x72d0
testb %al, %al
je 0xf2c8
leaq 0x630(%r12), %rsi
movq %r14, %rdi
callq 0xf268
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
callq *0x38(%rax)
movq (%r12), %rax
movq %r12, %rdi
callq *0x10(%rax)
decl %r15d
cmpl $0x1, %r15d
ja 0xf296
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/tools/translator/translator.cpp
// Function: Translator::OpenTemplate(smooth::String const&)
Int Translator::OpenTemplate(const String &fileName)
{
	if (!File(fileName).Exists()) return Error();

	XML::Document	 doc;

	if (doc.LoadFile(fileName) == Error()) return Error();

	XML::Node	*data = doc.GetRootNode()->GetNodeByName("data");

	dataSection->Parse(data, list_entries, entries);

	return Success();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x7480
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x7660
leaq 0x18(%rsp), %rdi
callq 0x7730
movl %eax, %r15d
leaq 0x18(%rsp), %rdi
callq 0x7250
movq %rsp, %rdi
callq 0x7980
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testb %r15b, %r15b
je 0xf3cc
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x7310
movq %r15, %rdi
movq %r14, %rsi
callq 0x70c0
cmpl $-0x1, %eax
je 0xf3bd
leaq 0x18(%rsp), %rdi
callq 0x7260
movq %rax, %r14
leaq 0x3129(%rip), %rsi      # 0x124a4
movq %rsp, %rdi
callq 0x77f0
movq %rsp, %rsi
movq %r14, %rdi
callq 0x76a0
movq %rax, %r14
movq %rsp, %rdi
callq 0x7980
movq 0x600(%rbx), %rdx
movq 0x768(%rbx), %rdi
addq $0x6b8, %rbx            # imm = 0x6B8
xorl %ebp, %ebp
movq %r14, %rsi
movq %rbx, %rcx
callq 0x7fac
jmp 0xf3c2
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x18(%rsp), %rdi
callq 0x7500
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7980
jmp 0xf3ed
jmp 0xf3ea
jmp 0xf3ea
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x7500
jmp 0xf413
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x7250
jmp 0xf40b
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7980
movq %rbx, %rdi
callq 0x7290
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/tools/translator/translator.cpp
// Function: Translator::ReplaceLineEndings(smooth::String const&)
Void Translator::ReplaceLineEndings(const String &file)
{
	String::InputFormat	 inputFormat("UTF-8");
	String::OutputFormat	 outputFormat("UTF-8");

	IO::InStream	 in(IO::STREAM_FILE, file, IO::IS_READ);

	String		 xmlString = in.InputString(in.Size());

	/* Replace line endings.
	 */
	xmlString.Replace("\n", "&#10;");
	xmlString.Replace(">&#10;", ">\n");

	IO::OutStream	 out(IO::STREAM_FILE, file, IO::OS_REPLACE);

	out.OutputString(xmlString);

	out.Close();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
movq %rsi, %rbx
leaq 0x2a55(%rip), %r14      # 0x12513
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0x107f4
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x1083e
leaq 0x170(%rsp), %rdi
movl $0x3, %esi
movq %rbx, %rdx
movl $0x2, %ecx
callq 0x7400
cmpw $0x0, 0x178(%rsp)
je 0xfb06
movl 0x180(%rsp), %edx
jmp 0xfb15
movw $0x5, 0x268(%rsp)
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
leaq 0x20(%rsp), %rdi
leaq 0x170(%rsp), %rsi
callq 0x78f0
leaq 0x2a13(%rip), %rsi      # 0x12541
leaq 0x68(%rsp), %rdi
callq 0x77f0
leaq 0x29fb(%rip), %rsi      # 0x1253a
leaq 0x8(%rsp), %rdi
callq 0x77f0
leaq 0x20(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x72e0
leaq 0x8(%rsp), %rdi
callq 0x7980
leaq 0x68(%rsp), %rdi
callq 0x7980
leaq 0x29c1(%rip), %rsi      # 0x12539
leaq 0x68(%rsp), %rdi
callq 0x77f0
leaq 0x29b7(%rip), %rsi      # 0x12540
leaq 0x8(%rsp), %rdi
callq 0x77f0
leaq 0x20(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x72e0
leaq 0x8(%rsp), %rdi
callq 0x7980
leaq 0x68(%rsp), %rdi
callq 0x7980
leaq 0x68(%rsp), %rdi
movl $0x3, %esi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x7880
leaq 0x68(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x75b0
leaq 0x68(%rsp), %rdi
callq 0x7690
leaq 0x68(%rsp), %rdi
callq 0x7610
leaq 0x20(%rsp), %rdi
callq 0x7980
leaq 0x170(%rsp), %rdi
callq 0x7520
leaq 0x38(%rsp), %rdi
callq 0x10888
leaq 0x50(%rsp), %rdi
callq 0x108b6
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r14
retq
jmp 0xfc51
jmp 0xfc33
jmp 0xfc42
jmp 0xfc51
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7980
jmp 0xfc45
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x7980
jmp 0xfc72
movq %rax, %rbx
jmp 0xfc72
movq %rax, %rbx
jmp 0xfc7c
movq %rax, %rbx
jmp 0xfc89
movq %rax, %rbx
jmp 0xfc93
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x7610
leaq 0x20(%rsp), %rdi
callq 0x7980
leaq 0x170(%rsp), %rdi
callq 0x7520
leaq 0x38(%rsp), %rdi
callq 0x10888
leaq 0x50(%rsp), %rdi
callq 0x108b6
movq %rbx, %rdi
callq 0x7290
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/tools/translator/translator.cpp
// Function: Translator::GetSelectedEntry(smooth::GUI::List*)
ListEntry *Translator::GetSelectedEntry(List *list)
{
	/* Recursively search for the list with the selected entry.
	 */
	for (Int i = list->Length() - 1; i >= 0; i--)
	{
		ListEntry	*entry = list->GetNthEntry(i);

		if (entry->GetObjectType() == Tree::classID)
		{
			ListEntry	*selected = GetSelectedEntry(((Tree *) entry)->GetList());

			if (selected != NIL) return selected;
		}
		else if (entry->IsSelected())
		{
			return entry;
		}
	}

	return NIL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x178(%rax)
testl %eax, %eax
jle 0x100a1
movl %eax, %r15d
movq 0x8f3c(%rip), %rax      # 0x18f88
incl %r15d
movswl (%rax), %ebp
leal -0x2(%r15), %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x180(%rax)
movq %rax, %r12
leaq 0x20(%rax), %rdi
movl %ebp, %esi
callq 0x72d0
testb %al, %al
je 0x1008d
addq $0x630, %r12            # imm = 0x630
movq %r14, %rdi
movq %r12, %rsi
callq 0x10024
testq %rax, %rax
je 0x10098
jmp 0x100b0
cmpb $0x0, 0x5b9(%r12)
jne 0x100a4
decl %r15d
cmpl $0x1, %r15d
ja 0x10052
xorl %r12d, %r12d
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
jmp 0x100a4
nop