LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc740
movq -0x40(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jle 0xc382
cmpl $0x0, -0x14(%rbp)
jge 0xc392
movb $0x0, -0x1(%rbp)
movl $0x1, -0x24(%rbp)
jmp 0xc476
movq -0x40(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0xc3dc
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
movb %al, -0x41(%rbp)
jmp 0xc3ae
movb -0x41(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl $0x1, -0x24(%rbp)
jmp 0xc476
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc7e0
jmp 0xc48a
movq -0x40(%rbp), %rdi
addq $0x40, %rdi
movl -0x14(%rbp), %esi
callq 0xc770
movq (%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0xc407
movq -0x50(%rbp), %rdi
movl $0x8, %esi
callq 0x80a0
movq -0x40(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x68(%rbp)
callq 0xc7a0
movq -0x68(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, -0x60(%rbp)
callq 0xc7a0
movq -0x60(%rbp), %rdi
movq -0x40(%rbp), %rcx
movq %rax, %rdx
movslq -0x14(%rbp), %rsi
movl %esi, %eax
leaq 0x8(%rdx,%rsi,8), %rsi
movl 0x8(%rcx), %ecx
notl %eax
addl %ecx, %eax
movslq %eax, %rdx
shlq $0x3, %rdx
callq 0x80e0
movq -0x40(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x8610
movb %al, -0x51(%rbp)
jmp 0xc467
movb -0x51(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl $0x1, -0x24(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc7e0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x8290
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xc740
movq -0x38(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0xc4d7
movb $0x1, -0x1(%rbp)
movl $0x1, -0x1c(%rbp)
jmp 0xc565
movl $0x0, -0x20(%rbp)
movq -0x38(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0xc522
movq -0x38(%rbp), %rdi
addq $0x40, %rdi
movl -0x20(%rbp), %esi
callq 0xc770
movq (%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0xc515
movq -0x40(%rbp), %rdi
movl $0x8, %esi
callq 0x80a0
jmp 0xc517
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xc4de
movq -0x38(%rbp), %rdi
addq $0x40, %rdi
callq 0xc6b0
movq -0x38(%rbp), %rdi
callq 0x81a0
movb %al, -0x41(%rbp)
jmp 0xc53d
movb -0x41(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl $0x1, -0x1c(%rbp)
jmp 0xc565
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xc7e0
jmp 0xc579
leaq -0x18(%rbp), %rdi
callq 0xc7e0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x8290
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $-0x1, 0x14(%rax)
jne 0xc6d0
movb $0x0, -0x1(%rbp)
jmp 0xc728
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xc6e1
movb $0x1, -0x1(%rbp)
jmp 0xc728
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xc70a
movq -0x20(%rbp), %rdi
callq 0x85d0
movq -0x20(%rbp), %rdi
movl $0x8, %esi
callq 0x80a0
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
movl $0x0, 0x14(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xbfd0
movq -0x38(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jle 0xd647
cmpl $0x0, -0x14(%rbp)
jl 0xd647
movq -0x38(%rbp), %rdi
addq $0x40, %rdi
movl -0x14(%rbp), %esi
callq 0xc770
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x28(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, 0x14(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x2c(%rbp)
jmp 0xd659
leaq 0x17ec2(%rip), %rax     # 0x25510
movq %rax, -0x8(%rbp)
movl $0x1, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc030
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xc740
movq -0x50(%rbp), %rdi
movl 0x8(%rdi), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x80b0
movb %al, -0x41(%rbp)
jmp 0xd931
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0xd95b
jmp 0xd93a
movb $0x0, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0xda44
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xda5b
movq -0x50(%rbp), %rdi
addq $0x40, %rdi
callq 0xda70
movl %eax, -0x54(%rbp)
jmp 0xd96d
movl -0x54(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jne 0xd9db
movq -0x50(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x60(%rbp)
cvtsi2sdl -0x2c(%rbp), %xmm1
movsd 0xf69a(%rip), %xmm0     # 0x1d028
mulsd %xmm0, %xmm1
movsd 0xf686(%rip), %xmm0     # 0x1d020
ucomisd %xmm1, %xmm0
jbe 0xd9af
movsd 0xf678(%rip), %xmm0     # 0x1d020
movsd %xmm0, -0x68(%rbp)
jmp 0xd9c5
cvtsi2sdl -0x2c(%rbp), %xmm0
movsd 0xf66c(%rip), %xmm1     # 0x1d028
mulsd %xmm1, %xmm0
movsd %xmm0, -0x68(%rbp)
movq -0x60(%rbp), %rdi
movsd -0x68(%rbp), %xmm0
cvttsd2si %xmm0, %esi
callq 0xda90
jmp 0xd9d9
jmp 0xd9db
movl $0x8, %edi
callq 0x8540
movq %rax, -0x70(%rbp)
jmp 0xd9eb
movq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xdb70
jmp 0xd9fa
movq -0x50(%rbp), %rdi
addq $0x40, %rdi
movl -0x2c(%rbp), %esi
callq 0xdb90
movq %rax, -0x78(%rbp)
jmp 0xda10
movq -0x78(%rbp), %rax
movq -0x70(%rbp), %rcx
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0xda44
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x8, %esi
callq 0x80a0
jmp 0xda5b
leaq -0x28(%rbp), %rdi
callq 0xc7e0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0xc7e0
movq -0x38(%rbp), %rdi
callq 0x8290
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $-0x1, 0x14(%rax)
jne 0xdab6
movb $0x0, -0x1(%rbp)
jmp 0xdb55
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x14(%rcx), %eax
jle 0xdb47
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xdaea
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x14(%rbp), %rax
shlq $0x3, %rax
movl %eax, %esi
callq 0x81b0
jmp 0xdb35
movl $0x8, %edi
callq 0x8540
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %esi
shll $0x3, %esi
callq 0x85a0
jmp 0xdb0b
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0xdb35
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x8, %esi
callq 0x80a0
jmp 0xdb60
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x14(%rax)
jmp 0xdb51
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x10(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x8290
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xc740
movq -0x38(%rbp), %rdi
movl 0xc(%rdi), %eax
incl %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0xe2d0
movb %al, -0x2d(%rbp)
jmp 0xe27e
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0xe2a7
jmp 0xe287
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
jmp 0xe2a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xc7e0
jmp 0xe2bf
movl -0x1c(%rbp), %eax
movl %eax, -0x3c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xc7e0
movl -0x3c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x8290
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
xorl %esi, %esi
callq 0x8490
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x8090
jmp 0xf3dd
leaq -0x38(%rbp), %rdi
callq 0x8990
movq -0x58(%rbp), %rdi
leaq 0x151df(%rip), %rax     # 0x245d0
movq %rax, (%rdi)
addq $0x638, %rdi            # imm = 0x638
movq %rdi, -0x60(%rbp)
xorl %esi, %esi
callq 0x8490
jmp 0xf408
movq -0x58(%rbp), %rdi
addq $0x650, %rdi            # imm = 0x650
movq %rdi, -0x68(%rbp)
xorl %esi, %esi
callq 0x8490
jmp 0xf420
movq -0x58(%rbp), %rdi
movswl 0x16105(%rip), %esi     # 0x25530
addq $0x20, %rdi
callq 0x8e90
jmp 0xf436
movq -0x58(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, 0x630(%rdi)
movq -0x18(%rbp), %rsi
addq $0x638, %rdi            # imm = 0x638
callq 0x8560
jmp 0xf455
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x650, %rdi            # imm = 0x650
callq 0x8560
jmp 0xf46b
movq -0x58(%rbp), %rdi
callq 0xf4e0
jmp 0xf476
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8990
jmp 0xf4d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xf4cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xf4c4
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x8990
movq -0x60(%rbp), %rdi
callq 0x8990
movq -0x58(%rbp), %rdi
callq 0x8970
movq -0x40(%rbp), %rdi
callq 0x8290
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq -0x80(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x88e0
movq -0x110(%rbp), %rdi
callq 0x196e0
movq %rax, -0x108(%rbp)
jmp 0xf705
movq -0x108(%rbp), %rdi
callq 0x196b0
jmp 0xf713
leaq -0x80(%rbp), %rdi
callq 0x196f0
movq %rax, -0x118(%rbp)
jmp 0xf725
movq -0x118(%rbp), %rdi
callq 0x8680
jmp 0xf733
leaq -0xa8(%rbp), %rdi
callq 0x88c0
jmp 0xf741
leaq -0xa8(%rbp), %rdi
callq 0x8990
leaq -0xc0(%rbp), %rdi
callq 0x8320
jmp 0xf75b
leaq -0xc0(%rbp), %rdi
callq 0x8990
movl $0xffffffff, -0xc4(%rbp) # imm = 0xFFFFFFFF
callq 0x83e0
movb %al, -0x119(%rbp)
jmp 0xf77e
movb -0x119(%rbp), %al
testb $0x1, %al
jne 0xf78d
jmp 0xf885
leaq -0xe0(%rbp), %rdi
callq 0x8360
jmp 0xf79b
leaq 0xdb3f(%rip), %rsi      # 0x1d2e1
leaq -0xf8(%rbp), %rdi
callq 0x8800
jmp 0xf7b0
leaq -0xe0(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
callq 0x8710
movb %al, -0x11a(%rbp)
jmp 0xf7cb
leaq -0xf8(%rbp), %rdi
callq 0x8990
leaq -0xe0(%rbp), %rdi
callq 0x8990
movb -0x11a(%rbp), %al
testb $0x1, %al
jne 0xf7ef
jmp 0xf863
callq 0x85e0
jmp 0xf7f6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0xfc(%rbp)
jmp 0xf898
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xf8ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xf855
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xf8(%rbp), %rdi
callq 0x8990
leaq -0xe0(%rbp), %rdi
callq 0x8990
jmp 0xf8ad
callq 0xf8d0
movl %eax, -0x120(%rbp)
jmp 0xf870
movl -0x120(%rbp), %eax
movl %eax, -0xc4(%rbp)
callq 0x85e0
jmp 0xf883
jmp 0xf885
movl -0xc4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0xfc(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x86f0
movl -0x4(%rbp), %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
leaq -0x80(%rbp), %rdi
callq 0x86f0
movq -0x88(%rbp), %rdi
callq 0x8290
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq 0x5f0(%rax), %rdi
movq (%rdi), %rax
callq *0xa8(%rax)
movq %rax, %rdi
xorl %esi, %esi
callq 0x84f0
testb $0x1, %al
jne 0x13127
jmp 0x13135
movq -0x68(%rbp), %rdi
callq 0x132d0
jmp 0x1329f
movq -0x68(%rbp), %rax
movq 0x5b8(%rax), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movq 0x600(%rax), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq 0x600(%rax), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x1aa20
movq -0x70(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8500
movq -0x68(%rbp), %rax
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movq 0x608(%rax), %rdi
movq (%rdi), %rax
callq *0x90(%rax)
testb $0x1, %al
jne 0x131c1
jmp 0x131de
movq -0x68(%rbp), %rax
movq 0x608(%rax), %rdi
xorl %esi, %esi
callq 0x1aa60
movq %rax, %rdi
callq 0x1aa90
movl %eax, -0x34(%rbp)
movq -0x68(%rbp), %rax
movq 0x600(%rax), %rdi
movq (%rdi), %rax
movq 0x60(%rax), %rax
callq *%rax
movq -0x68(%rbp), %rdi
movq 0x608(%rdi), %rsi
callq 0x17a30
movq -0x68(%rbp), %rax
movq 0x5f0(%rax), %rdi
movq 0x768(%rax), %rax
movq %rax, -0x80(%rbp)
movq (%rdi), %rax
movq 0xa8(%rax), %rax
callq *%rax
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x8380
movq -0x68(%rbp), %rax
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq 0x608(%rax), %rdx
callq 0xae70
jmp 0x1324e
leaq -0x50(%rbp), %rdi
callq 0x8990
movq -0x68(%rbp), %rax
movq 0x608(%rax), %rdi
xorl %esi, %esi
callq 0x1aa60
movq %rax, %rdi
movl -0x34(%rbp), %esi
callq 0x8720
movq -0x68(%rbp), %rax
movq 0x608(%rax), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
movq -0x10(%rbp), %rdi
callq 0x8910
movq -0x68(%rbp), %rax
movq 0x5f8(%rax), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x8990
movq -0x58(%rbp), %rdi
callq 0x8290
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/tools/translator/translator.cpp
// Function: Translator::ClearFilter()
Void Translator::ClearFilter()
{
	/* Clear filter box.
	 */
	edit_filter->SetText(NIL);
	button_clear->Deactivate();

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

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

	list_filtered->Hide();

	ClearFilter(list_filtered);

	list_entries->Show();

	surface->EndPaint();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq 0x5f0(%rax), %rax
movq %rax, -0x68(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x60(%rbp)
xorl %esi, %esi
callq 0x8490
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq (%rdi), %rax
movq 0xa0(%rax), %rax
callq *%rax
jmp 0x13317
leaq -0x20(%rbp), %rdi
callq 0x8990
movq -0x70(%rbp), %rax
movq 0x5f8(%rax), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
movq -0x70(%rbp), %rax
movq 0x5b8(%rax), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movq 0x608(%rax), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq 0x608(%rax), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq %rax, -0x58(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x1aa20
movq -0x78(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x8500
movq -0x70(%rbp), %rax
movq 0x608(%rax), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
movq -0x70(%rbp), %rdi
movq 0x608(%rdi), %rsi
callq 0x17a30
movq -0x70(%rbp), %rax
movq 0x600(%rax), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
movq -0x38(%rbp), %rdi
callq 0x8910
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x8990
movq -0x28(%rbp), %rdi
callq 0x8290
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/tools/translator/translator.cpp
// Function: Translator::OnChangeEditLayerSize(smooth::GUI::Size const&)
Void Translator::OnChangeEditLayerSize(const Size &size)
{
	edit_original->SetSize(Size(size.cx - edit_original->GetX() - 7, (size.cy - 50) / 2));

	text_translated->SetY(edit_original->GetY() + edit_original->GetHeight() + 11);
	edit_translated->SetY(text_translated->GetY() - 3);

	edit_translated->SetSize(Size(edit_original->GetWidth(), edit_original->GetHeight() + (size.cy & 1)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x658(%rax), %rcx
movq %rcx, -0x58(%rbp)
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, -0x5c(%rbp)
movq 0x658(%rax), %rdi
callq 0x1a3b0
movl -0x5c(%rbp), %esi
subl %eax, %esi
subl $0x7, %esi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
subl $0x32, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %edx
leaq -0x18(%rbp), %rdi
callq 0x197b0
movq -0x58(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1a370
movq -0x38(%rbp), %rax
movq 0x660(%rax), %rcx
movq %rcx, -0x48(%rbp)
movq 0x658(%rax), %rdi
callq 0x1a420
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, -0x4c(%rbp)
movq 0x658(%rax), %rdi
callq 0x1a440
movl -0x4c(%rbp), %esi
movq -0x48(%rbp), %rdi
addl %eax, %esi
addl $0xb, %esi
callq 0x1a3d0
movq -0x38(%rbp), %rax
movq 0x668(%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x660(%rax), %rdi
callq 0x1a420
movq -0x40(%rbp), %rdi
movl %eax, %esi
subl $0x3, %esi
callq 0x1a3d0
movq -0x38(%rbp), %rax
movq 0x668(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x658(%rax), %rdi
callq 0x1a460
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, -0x2c(%rbp)
movq 0x658(%rax), %rdi
callq 0x1a440
movl -0x2c(%rbp), %esi
movl %eax, %edx
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
addl %eax, %edx
leaq -0x20(%rbp), %rdi
callq 0x197b0
movq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1a370
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x10(%rbp)
movq 0x5f0(%rax), %rdi
movq (%rdi), %rax
callq *0xa8(%rax)
movq %rax, %rdi
xorl %esi, %esi
callq 0x84f0
testb $0x1, %al
jne 0x13bec
jmp 0x13c02
movq -0x28(%rbp), %rdi
movq 0x600(%rdi), %rsi
callq 0x19440
movq %rax, -0x10(%rbp)
jmp 0x13c16
movq -0x28(%rbp), %rdi
movq 0x608(%rdi), %rsi
callq 0x19440
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x13c22
jmp 0x13d0f
movq -0x10(%rbp), %rdi
callq 0xb630
movq -0x28(%rbp), %rdi
movl %eax, -0x14(%rbp)
movq 0x600(%rdi), %rsi
movl -0x14(%rbp), %edx
callq 0x19520
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x6b8, %rdi            # imm = 0x6B8
movl -0x14(%rbp), %esi
callq 0xb550
movq -0x28(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x10(%rbp)
addq $0x6b8, %rdi            # imm = 0x6B8
movl -0x14(%rbp), %esi
callq 0x8930
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x38(%rax)
movq -0x28(%rbp), %rdi
addq $0x710, %rdi            # imm = 0x710
movl -0x14(%rbp), %esi
callq 0xb550
cmpq $0x0, (%rax)
je 0x13cb5
movq -0x10(%rbp), %rdi
callq 0x8960
movq -0x28(%rbp), %rdi
addq $0x710, %rdi            # imm = 0x710
movl -0x14(%rbp), %esi
callq 0x8930
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x12750
movq -0x28(%rbp), %rax
movq 0x5f0(%rax), %rdi
movq (%rdi), %rax
callq *0xa8(%rax)
movq %rax, %rdi
xorl %esi, %esi
callq 0x8700
testb $0x1, %al
jne 0x13ce6
jmp 0x13cf1
movq -0x28(%rbp), %rdi
callq 0x130f0
jmp 0x13d04
movq -0x28(%rbp), %rax
movq 0x600(%rax), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x78(%rax)
movq -0x28(%rbp), %rax
movb $0x1, 0x770(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x7f0, %rsp            # imm = 0x7F0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x7d0(%rbp)
callq 0x163a0
testb $0x1, %al
jne 0x15688
jmp 0x158c2
leaq -0x748(%rbp), %rdi
movq %rdi, -0x7d8(%rbp)
callq 0x8820
movq -0x7d0(%rbp), %rax
movq -0x7d8(%rbp), %rdi
movq 0x5b8(%rax), %rsi
callq 0x80f0
jmp 0x156b7
leaq 0x7daf(%rip), %rsi      # 0x1d46d
leaq -0x770(%rbp), %rdi
callq 0x8800
jmp 0x156cc
leaq 0x7dad(%rip), %rsi      # 0x1d480
leaq -0x788(%rbp), %rdi
callq 0x8800
jmp 0x156e1
leaq -0x748(%rbp), %rdi
leaq -0x770(%rbp), %rsi
leaq -0x788(%rbp), %rdx
callq 0x8230
jmp 0x156fd
leaq -0x788(%rbp), %rdi
callq 0x8990
leaq -0x770(%rbp), %rdi
callq 0x8990
leaq 0x7d6a(%rip), %rsi      # 0x1d486
leaq -0x7a0(%rbp), %rdi
callq 0x8800
jmp 0x1572a
leaq 0x7d5f(%rip), %rsi      # 0x1d490
leaq -0x7b8(%rbp), %rdi
callq 0x8800
jmp 0x1573f
leaq -0x748(%rbp), %rdi
leaq -0x7a0(%rbp), %rsi
leaq -0x7b8(%rbp), %rdx
callq 0x8230
jmp 0x1575b
leaq -0x7b8(%rbp), %rdi
callq 0x8990
leaq -0x7a0(%rbp), %rdi
callq 0x8990
leaq -0x748(%rbp), %rdi
callq 0x8370
movq %rax, -0x7e0(%rbp)
jmp 0x15788
leaq -0x7c8(%rbp), %rdi
callq 0x8eb0
jmp 0x15796
movq -0x7e0(%rbp), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
leaq -0x7c8(%rbp), %rsi
callq *%rax
movb %al, -0x7e1(%rbp)
jmp 0x157b5
leaq -0x7c8(%rbp), %rdi
callq 0x8f10
movb -0x7e1(%rbp), %al
testb $0x1, %al
jne 0x157d0
jmp 0x158b6
leaq -0x748(%rbp), %rdi
callq 0x8100
movq %rax, -0x7f0(%rbp)
jmp 0x157e5
movq -0x7f0(%rbp), %rsi
movq -0x7d0(%rbp), %rdi
callq 0x16640
jmp 0x157fa
jmp 0x158b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x750(%rbp)
movl %eax, -0x754(%rbp)
jmp 0x158cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x750(%rbp)
movl %eax, -0x754(%rbp)
jmp 0x15848
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x750(%rbp)
movl %eax, -0x754(%rbp)
leaq -0x788(%rbp), %rdi
callq 0x8990
leaq -0x770(%rbp), %rdi
callq 0x8990
jmp 0x158cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x750(%rbp)
movl %eax, -0x754(%rbp)
jmp 0x15888
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x750(%rbp)
movl %eax, -0x754(%rbp)
leaq -0x7b8(%rbp), %rdi
callq 0x8990
leaq -0x7a0(%rbp), %rdi
callq 0x8990
jmp 0x158cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x750(%rbp)
movl %eax, -0x754(%rbp)
leaq -0x7c8(%rbp), %rdi
callq 0x8f10
jmp 0x158cb
leaq -0x748(%rbp), %rdi
callq 0x8520
addq $0x7f0, %rsp            # imm = 0x7F0
popq %rbp
retq
leaq -0x748(%rbp), %rdi
callq 0x8520
movq -0x750(%rbp), %rdi
callq 0x8290
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x90(%rbp)
addq $0x6b8, %rdi            # imm = 0x6B8
callq 0xb410
cmpl $0x0, %eax
jne 0x163d4
movb $0x1, -0x1(%rbp)
jmp 0x16598
movq -0x90(%rbp), %rax
testb $0x1, 0x770(%rax)
jne 0x163f9
movq -0x90(%rbp), %rdi
callq 0x17630
movb $0x1, -0x1(%rbp)
jmp 0x16598
leaq 0x7007(%rip), %rsi      # 0x1d407
leaq -0x30(%rbp), %rdi
callq 0x8800
movq -0x90(%rbp), %rsi
movq %rsi, %rdx
addq $0x688, %rdx            # imm = 0x688
leaq -0x48(%rbp), %rdi
callq 0x17980
jmp 0x16425
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x8170
movq %rax, -0x98(%rbp)
jmp 0x1643b
leaq 0x6fe5(%rip), %rsi      # 0x1d427
leaq -0x70(%rbp), %rdi
callq 0x8800
jmp 0x1644d
movq -0x98(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x8170
movq %rax, -0xa0(%rbp)
jmp 0x16466
leaq 0x6e7a(%rip), %rsi      # 0x1d2e7
leaq -0x88(%rbp), %rdi
callq 0x8800
jmp 0x1647b
movq -0xa0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
movl $0x3, %edx
movl $0x7f02, %ecx           # imm = 0x7F02
callq 0x8350
movl %eax, -0xa4(%rbp)
jmp 0x164a0
leaq -0x88(%rbp), %rdi
callq 0x8990
leaq -0x70(%rbp), %rdi
callq 0x8990
leaq -0x48(%rbp), %rdi
callq 0x8990
leaq -0x30(%rbp), %rdi
callq 0x8990
movl -0xa4(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, -0xb0(%rbp)
subl $0x6, %eax
ja 0x16594
movq -0xb0(%rbp), %rax
leaq 0x6dc2(%rip), %rcx      # 0x1d2b8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x16553
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x1654a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x16541
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x8990
leaq -0x70(%rbp), %rdi
callq 0x8990
leaq -0x48(%rbp), %rdi
callq 0x8990
leaq -0x30(%rbp), %rdi
callq 0x8990
jmp 0x165a6
movq -0x90(%rbp), %rdi
callq 0x158f0
movq -0x90(%rbp), %rdi
callq 0x17630
movb $0x1, -0x1(%rbp)
jmp 0x16598
movq -0x90(%rbp), %rdi
callq 0x17630
movb $0x1, -0x1(%rbp)
jmp 0x16598
movb $0x0, -0x1(%rbp)
jmp 0x16598
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x8290
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x5b8(%rax), %rdi
callq 0x8640
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1a340
movq -0x40(%rbp), %rdi
movq %rax, -0x18(%rbp)
movsd 0x620(%rdi), %xmm0
movsd %xmm0, -0x30(%rbp)
cvtsi2sdl -0x14(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x34(%rbp)
movb $0x1, 0x628(%rdi)
movl -0x34(%rbp), %esi
callq 0x13440
movq -0x40(%rbp), %rax
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x620(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
leaq 0xd345(%rip), %rax      # 0x24760
movq %rax, (%rdi)
callq 0x17630
jmp 0x17425
movq -0x10(%rbp), %rax
movq 0x5c0(%rax), %rdi
callq 0x8960
jmp 0x17437
movq -0x10(%rbp), %rax
movq 0x5b8(%rax), %rdi
callq 0x8960
jmp 0x17449
movq -0x10(%rbp), %rax
movq 0x5c8(%rax), %rdi
callq 0x8960
jmp 0x1745b
movq -0x10(%rbp), %rax
movq 0x5d8(%rax), %rdi
callq 0x8960
jmp 0x1746d
movq -0x10(%rbp), %rax
movq 0x5e0(%rax), %rdi
callq 0x8960
jmp 0x1747f
movq -0x10(%rbp), %rax
movq 0x5d0(%rax), %rdi
callq 0x8960
jmp 0x17491
movq -0x10(%rbp), %rax
movq 0x5e8(%rax), %rdi
callq 0x8960
jmp 0x174a3
movq -0x10(%rbp), %rax
movq 0x5f0(%rax), %rdi
callq 0x8960
jmp 0x174b5
movq -0x10(%rbp), %rax
movq 0x5f8(%rax), %rdi
callq 0x8960
jmp 0x174c7
movq -0x10(%rbp), %rax
movq 0x600(%rax), %rdi
callq 0x8960
jmp 0x174d9
movq -0x10(%rbp), %rax
movq 0x608(%rax), %rdi
callq 0x8960
jmp 0x174eb
movq -0x10(%rbp), %rax
movq 0x610(%rax), %rdi
callq 0x8960
jmp 0x174fd
movq -0x10(%rbp), %rax
movq 0x618(%rax), %rdi
callq 0x8960
jmp 0x1750f
movq -0x10(%rbp), %rax
movq 0x630(%rax), %rdi
callq 0x8960
jmp 0x17521
movq -0x10(%rbp), %rax
movq 0x640(%rax), %rdi
callq 0x8960
jmp 0x17533
movq -0x10(%rbp), %rax
movq 0x648(%rax), %rdi
callq 0x8960
jmp 0x17545
movq -0x10(%rbp), %rax
movq 0x650(%rax), %rdi
callq 0x8960
jmp 0x17557
movq -0x10(%rbp), %rax
movq 0x658(%rax), %rdi
callq 0x8960
jmp 0x17569
movq -0x10(%rbp), %rax
movq 0x660(%rax), %rdi
callq 0x8960
jmp 0x1757b
movq -0x10(%rbp), %rax
movq 0x668(%rax), %rdi
callq 0x8960
jmp 0x1758d
movq -0x10(%rbp), %rax
movq 0x670(%rax), %rdi
callq 0x8960
jmp 0x1759f
movq -0x10(%rbp), %rax
movq 0x678(%rax), %rdi
callq 0x8960
jmp 0x175b1
movq -0x10(%rbp), %rax
movq 0x638(%rax), %rdi
callq 0x8960
jmp 0x175c3
movq -0x10(%rbp), %rax
movq 0x680(%rax), %rdi
callq 0x8960
jmp 0x175d5
movq -0x10(%rbp), %rdi
addq $0x710, %rdi            # imm = 0x710
callq 0x1a320
movq -0x10(%rbp), %rdi
addq $0x6b8, %rdi            # imm = 0x6B8
callq 0x1a320
movq -0x10(%rbp), %rdi
addq $0x6a0, %rdi            # imm = 0x6A0
callq 0x8990
movq -0x10(%rbp), %rdi
addq $0x688, %rdi            # imm = 0x688
callq 0x8990
movq -0x10(%rbp), %rdi
callq 0x84b0
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xb430
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x178(%rax)
subl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x17ae5
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq (%rdi), %rax
callq *0x180(%rax)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xba50
movq %rax, %rdi
movq 0xd4fc(%rip), %rax      # 0x24f88
movswl (%rax), %esi
callq 0x82d0
testb $0x1, %al
jne 0x17a9a
jmp 0x17aaf
movq -0x20(%rbp), %rdi
callq 0xb6b0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x17a30
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq (%rdi), %rax
callq *0x38(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x17ad5
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x17ad7
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x17a5b
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x178(%rax)
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x19501
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq (%rdi), %rax
callq *0x180(%rax)
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xba50
movq %rax, %rdi
movq 0xbaec(%rip), %rax      # 0x24f88
movswl (%rax), %esi
callq 0x82d0
testb $0x1, %al
jne 0x194aa
jmp 0x194d6
movq -0x28(%rbp), %rdi
callq 0xb6b0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x19440
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x194d4
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x19509
jmp 0x194f1
movq -0x28(%rbp), %rdi
callq 0x1aa00
testb $0x1, %al
jne 0x194e5
jmp 0x194ef
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x19509
jmp 0x194f1
jmp 0x194f3
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1946b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/tools/translator/translator.cpp
// Function: Translator::GetEntryList(smooth::GUI::List*, int)
List *Translator::GetEntryList(List *list, Int id)
{
	/* Recursively search for the list with the requested entry.
	 */
	for (Int i = list->Length() - 1; i >= 0; i--)
	{
		ListEntry	*entry = list->GetNthEntry(i);

		if (entry->GetObjectType() == Tree::classID)
		{
			List	*selected = GetEntryList(((Tree *) entry)->GetList(), id);

			if (selected != NIL) return selected;
		}
		else if (entry->GetObjectType() == StringItem::classID)
		{
			if (((StringItem *) entry)->GetID() == id) return list;
		}
	}

	return NIL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x178(%rax)
subl $0x1, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0x19609
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
movq (%rdi), %rax
callq *0x180(%rax)
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xba50
movq %rax, %rdi
movq 0xba09(%rip), %rax      # 0x24f88
movswl (%rax), %esi
callq 0x82d0
testb $0x1, %al
jne 0x1958d
jmp 0x195bc
movq -0x28(%rbp), %rdi
callq 0xb6b0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movl -0x1c(%rbp), %edx
callq 0x19520
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x195ba
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x19611
jmp 0x195f9
movq -0x28(%rbp), %rdi
callq 0xba50
movq %rax, %rdi
leaq 0xbf61(%rip), %rax      # 0x25530
movswl (%rax), %esi
callq 0x82d0
testb $0x1, %al
jne 0x195dd
jmp 0x195f7
movq -0x28(%rbp), %rdi
callq 0xb630
cmpl -0x1c(%rbp), %eax
jne 0x195f5
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x19611
jmp 0x195f7
jmp 0x195f9
jmp 0x195fb
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1954e
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/signals/signal.h
// Function: int smooth::Signal1<void, smooth::String const&>::Connect<Translator, Translator, void>(void (Translator::*)(), Translator*)
Int Connect(slotReturnTYPE (classTYPE::*proc)(), oClassTYPE *inst)
			{
				if (slots0 == NIL)
				{
					slots0 = new Array<Void *>();
					slots0->EnableLocking();
				}

				slots0->Add(new SlotClass0<classTYPE, slotReturnTYPE>(proc, inst));

				return Success();
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, 0x18(%rax)
jne 0x1999b
movl $0x58, %edi
callq 0x8540
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
callq 0xe7a0
jmp 0x19965
movq -0x70(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq 0x18(%rax), %rdi
callq 0x82b0
jmp 0x1999b
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x58, %esi
callq 0x80a0
jmp 0x19a43
movq -0x70(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x88(%rbp)
movl $0x20, %edi
callq 0x8540
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq %rdx, -0x50(%rbp)
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x1b410
jmp 0x199e1
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0xe7e0
leaq -0x68(%rbp), %rdi
callq 0x8eb0
leaq -0x68(%rbp), %rdi
callq 0x8ef0
movl %eax, -0x8c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x8f10
movl -0x8c(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x20, %esi
callq 0x80a0
movq -0x38(%rbp), %rdi
callq 0x8290
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/nonblocking/../../threads/../templates/signals/signalr.h
// Function: int smooth::SignalR0<bool>::Connect<Translator, Translator>(bool (Translator::*)(), Translator*)
Int Connect(returnTYPE (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, returnTYPE SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES>(proc, inst));

				return Success();
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0x1c02b
movl $0x58, %edi
callq 0x8540
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
callq 0xe7a0
jmp 0x1bff5
movq -0x70(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
callq 0x82b0
jmp 0x1c02b
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x58, %esi
callq 0x80a0
jmp 0x1c0d3
movq -0x70(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x88(%rbp)
movl $0x20, %edi
callq 0x8540
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq %rdx, -0x50(%rbp)
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x1c240
jmp 0x1c071
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0xe7e0
leaq -0x68(%rbp), %rdi
callq 0x8eb0
leaq -0x68(%rbp), %rdi
callq 0x8ef0
movl %eax, -0x8c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x8f10
movl -0x8c(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x20, %esi
callq 0x80a0
movq -0x38(%rbp), %rdi
callq 0x8290
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/nonblocking/../../threads/../templates/signals/signalr.h
// Function: smooth::SignalR0<bool>::RemoveNthN(int)
Void RemoveNthN(Int n)
			{
				if (slotsN == NIL)	   return;
				if (slotsN->Length() <= n) return;

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

				slotsN->RemoveNth(n);

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

					slotsN = NIL;
				}
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0x1c103
jmp 0x1c189
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xb410
cmpl -0xc(%rbp), %eax
jg 0x1c117
jmp 0x1c189
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0xbef0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1c13e
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xb410
cmpl $0x0, %eax
jne 0x1c189
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1c17d
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/nonblocking/../../threads/../templates/signals/signalr.h
// Function: smooth::SignalR0<bool>::RemoveNth0(int)
Void RemoveNth0(Int n)
			{
				if (slots0 == NIL)	   return;
				if (slots0->Length() <= n) return;

				delete (SlotRBase0<returnTYPE> *) slots0->GetNth(n);

				slots0->RemoveNth(n);

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

					slots0 = NIL;
				}
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x18(%rax)
jne 0x1c1b3
jmp 0x1c239
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xb410
cmpl -0xc(%rbp), %eax
jg 0x1c1c7
jmp 0x1c239
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0xbef0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1c1ee
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xb410
cmpl $0x0, %eax
jne 0x1c239
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1c22d
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop