LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/hash/crc16.cpp
// Function: smooth::Hash::CRC16::InitTable()
S::Bool S::Hash::CRC16::InitTable()
{
	UnsignedInt16	 polynomial = 0x8005;

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

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

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

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

	return True;
}

// Assembly:
xorl %edx, %edx
movq 0xc0ecb(%rip), %rax     # 0x16ce38
movl $0x7, %ecx
xorl %esi, %esi
movl %edx, %edi
movl %edi, %r8d
andl $0x1, %r8d
negl %r8d
movzwl %di, %edi
movl $0x1, %r9d
shll %cl, %r9d
andl %r8d, %r9d
orl %r9d, %esi
shrl %edi
addl $-0x1, %ecx
jb 0xabf76
shll $0x8, %esi
movl $0x8, %ecx
leal (%rsi,%rsi), %edi
movswl %si, %esi
sarl $0xf, %esi
andl $0xffff8005, %esi       # imm = 0xFFFF8005
xorl %edi, %esi
decl %ecx
jne 0xabfa1
movl $0xf, %ecx
xorl %edi, %edi
movl %esi, %r8d
andl $0x1, %r8d
negl %r8d
movzwl %si, %esi
movl $0x1, %r9d
shll %cl, %r9d
andl %r8d, %r9d
orl %r9d, %edi
shrl %esi
addl $-0x1, %ecx
jb 0xabfbd
movw %di, (%rax,%rdx,2)
incq %rdx
cmpq $0x100, %rdx            # imm = 0x100
jne 0xabf6d
xorl %ecx, %ecx
movq %rax, %rdx
movl $0x200, %esi            # imm = 0x200
movzwl -0x200(%rdx,%rsi), %edi
movzbl %dil, %r8d
shrl $0x8, %edi
xorw (%rax,%r8,2), %di
movw %di, (%rdx,%rsi)
addq $0x200, %rsi            # imm = 0x200
cmpq $0x1000, %rsi           # imm = 0x1000
jne 0xabffe
incq %rcx
addq $0x2, %rdx
cmpq $0x100, %rcx            # imm = 0x100
jne 0xabff9
movb $0x1, %al
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/hash/crc16.cpp
// Function: smooth::Hash::CRC16::Reflect(unsigned short, char)
S::UnsignedInt16 S::Hash::CRC16::Reflect(UnsignedInt16 ref, char ch)
{
	UnsignedInt16	 value(0);

	for (Int i = 1; i < (ch + 1); i++)
	{
		if (ref & 1) value |= 1 << (ch - i);

		ref >>= 1;
	}

	return value;
}

// Assembly:
movl %esi, %ecx
testb %cl, %cl
jle 0xac071
decl %ecx
xorl %eax, %eax
movl %edi, %edx
andl $0x1, %edx
negl %edx
movzwl %di, %edi
movl $0x1, %esi
shll %cl, %esi
andl %edx, %esi
orl %esi, %eax
shrl %edi
addl $-0x1, %ecx
jb 0xac054
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/hash/crc16.cpp
// Function: smooth::Hash::CRC16::Feed(unsigned char const*, int)
S::Bool S::Hash::CRC16::Feed(const UnsignedByte *data, Int size)
{
	while (size >= 8)
	{
		crc  ^= data[1] << 8 | data[0];

		crc   =	table[7][crc & 0xFF] ^ table[6][crc >> 8] ^
			table[5][data[2]   ] ^ table[4][data[3]	] ^
			table[3][data[4]   ] ^ table[2][data[5]	] ^
			table[1][data[6]   ] ^ table[0][data[7]	];

		data += 8;
		size -= 8;
	}

	while (size--) crc = (crc >> 8) ^ table[0][(crc & 0xFF) ^ *data++];

	return True;
}

// Assembly:
cmpl $0x8, %edx
jl 0xac111
movzwl (%rdi), %ecx
movq 0xc0db1(%rip), %rax     # 0x16ce38
xorw (%rsi), %cx
movw %cx, (%rdi)
movzwl %cx, %ecx
movzbl %cl, %r8d
shrl $0x8, %ecx
movzwl 0xc00(%rax,%rcx,2), %ecx
xorw 0xe00(%rax,%r8,2), %cx
movzbl 0x2(%rsi), %r8d
xorw 0xa00(%rax,%r8,2), %cx
movzbl 0x3(%rsi), %r8d
xorw 0x800(%rax,%r8,2), %cx
movzbl 0x4(%rsi), %r8d
xorw 0x600(%rax,%r8,2), %cx
movzbl 0x5(%rsi), %r8d
xorw 0x400(%rax,%r8,2), %cx
movzbl 0x6(%rsi), %r8d
xorw 0x200(%rax,%r8,2), %cx
movzbl 0x7(%rsi), %r8d
xorw (%rax,%r8,2), %cx
movw %cx, (%rdi)
addq $0x8, %rsi
leal -0x8(%rdx), %r9d
cmpl $0xf, %edx
movl %r9d, %edx
jg 0xac087
jmp 0xac114
movl %edx, %r9d
testl %r9d, %r9d
je 0xac14d
movzwl (%rdi), %r8d
movl %r9d, %eax
xorl %ecx, %ecx
movq 0xc0d0f(%rip), %rdx     # 0x16ce38
movzwl %r8w, %r8d
movzbl (%rsi,%rcx), %r9d
xorl %r8d, %r9d
shrl $0x8, %r8d
movzbl %r9b, %r9d
xorw (%rdx,%r9,2), %r8w
movw %r8w, (%rdi)
incq %rcx
cmpl %ecx, %eax
jne 0xac129
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/hash/crc32.cpp
// Function: smooth::Hash::CRC32::InitTable()
S::Bool S::Hash::CRC32::InitTable()
{
	UnsignedInt32	 polynomial = 0x04C11DB7;

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

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

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

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

	return True;
}

// Assembly:
xorl %edx, %edx
movq 0xc0227(%rip), %rax     # 0x16c430
movl $0x7, %ecx
xorl %esi, %esi
movl %edx, %edi
movl %edi, %r8d
andl $0x1, %r8d
negl %r8d
movl $0x1, %r9d
shll %cl, %r9d
andl %r8d, %r9d
orl %r9d, %esi
shrl %edi
addl $-0x1, %ecx
jb 0xac212
shll $0x18, %esi
movl $0x8, %ecx
leal (%rsi,%rsi), %edi
sarl $0x1f, %esi
andl $0x4c11db7, %esi        # imm = 0x4C11DB7
xorl %edi, %esi
decl %ecx
jne 0xac23a
xorl %edi, %edi
movl $0x1f, %ecx
movl %esi, %r8d
andl $0x1, %r8d
negl %r8d
movl $0x1, %r9d
shll %cl, %r9d
andl %r8d, %r9d
orl %r9d, %edi
shrl %esi
addl $-0x1, %ecx
jb 0xac253
movl %edi, (%rax,%rdx,4)
incq %rdx
cmpq $0x100, %rdx            # imm = 0x100
jne 0xac209
xorl %ecx, %ecx
movq %rax, %rdx
movl $0x400, %esi            # imm = 0x400
movl -0x400(%rdx,%rsi), %edi
movzbl %dil, %r8d
shrl $0x8, %edi
xorl (%rax,%r8,4), %edi
movl %edi, (%rdx,%rsi)
addq $0x400, %rsi            # imm = 0x400
cmpq $0x2000, %rsi           # imm = 0x2000
jne 0xac28c
incq %rcx
addq $0x4, %rdx
cmpq $0x100, %rcx            # imm = 0x100
jne 0xac287
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/hash/crc32.cpp
// Function: smooth::Hash::CRC32::Reflect(unsigned int, char)
S::UnsignedInt32 S::Hash::CRC32::Reflect(UnsignedInt32 ref, char ch)
{
	UnsignedInt32	 value(0);

	for (Int i = 1; i < (ch + 1); i++)
	{
		if (ref & 1) value |= 1 << (ch - i);

		ref >>= 1;
	}

	return value;
}

// Assembly:
movl %esi, %ecx
testb %cl, %cl
jle 0xac2fc
decl %ecx
xorl %eax, %eax
movl %edi, %edx
andl $0x1, %edx
negl %edx
movl $0x1, %esi
shll %cl, %esi
andl %edx, %esi
orl %esi, %eax
shrl %edi
addl $-0x1, %ecx
jb 0xac2e2
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/hash/crc32.cpp
// Function: smooth::Hash::CRC32::Feed(unsigned char const*, int)
S::Bool S::Hash::CRC32::Feed(const UnsignedByte *data, Int size)
{
	while (size >= 8)
	{
		crc  ^= data[3] << 24 | data[2] << 16 | data[1] << 8 | data[0];

		crc   =	table[7][ crc	     & 0xFF] ^ table[6][(crc >>  8) & 0xFF] ^
			table[5][(crc >> 16) & 0xFF] ^ table[4][ crc >> 24	  ] ^
			table[3][data[4]	   ] ^ table[2][data[5]		  ] ^
			table[1][data[6]	   ] ^ table[0][data[7]		  ];

		data += 8;
		size -= 8;
	}

	while (size--) crc = (crc >> 8) ^ table[0][(crc & 0xFF) ^ *data++];

	return True;
}

// Assembly:
cmpl $0x8, %edx
jl 0xac3ac
movl (%rdi), %r9d
movl $0xff, %eax
movq 0xc0118(%rip), %rcx     # 0x16c430
xorl (%rsi), %r9d
movl %r9d, (%rdi)
movl %r9d, %r10d
andl %eax, %r10d
movl %r9d, %r8d
shrl $0x8, %r8d
andl %eax, %r8d
movl 0x1800(%rcx,%r8,4), %r8d
xorl 0x1c00(%rcx,%r10,4), %r8d
movl %r9d, %r10d
shrl $0xe, %r10d
andl $0x3fc, %r10d           # imm = 0x3FC
xorl 0x1400(%rcx,%r10), %r8d
shrl $0x18, %r9d
xorl 0x1000(%rcx,%r9,4), %r8d
movzbl 0x4(%rsi), %r9d
xorl 0xc00(%rcx,%r9,4), %r8d
movzbl 0x5(%rsi), %r9d
xorl 0x800(%rcx,%r9,4), %r8d
movzbl 0x6(%rsi), %r9d
xorl 0x400(%rcx,%r9,4), %r8d
movzbl 0x7(%rsi), %r9d
xorl (%rcx,%r9,4), %r8d
movl %r8d, (%rdi)
addq $0x8, %rsi
leal -0x8(%rdx), %r10d
movl %r8d, %r9d
cmpl $0xf, %edx
movl %r10d, %edx
jg 0xac318
jmp 0xac3af
movl %edx, %r10d
testl %r10d, %r10d
je 0xac3e7
movl (%rdi), %r9d
movl %r10d, %eax
xorl %ecx, %ecx
movq 0xc006d(%rip), %rdx     # 0x16c430
movl %r9d, %r8d
shrl $0x8, %r8d
movzbl %r9b, %r9d
movzbl (%rsi,%rcx), %r10d
xorl %r9d, %r10d
xorl (%rdx,%r10,4), %r8d
movl %r8d, (%rdi)
incq %rcx
movl %r8d, %r9d
cmpl %ecx, %eax
jne 0xac3c6
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/hash/crc64.cpp
// Function: smooth::Hash::CRC64::InitTable()
S::Bool S::Hash::CRC64::InitTable()
{
	UnsignedInt64	 polynomial = 0x95AC9329AC4BC9B5ULL;

	for (Int i = 0; i <= 0xFF; i++)
	{
		UnsignedInt64	 value = i;

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

		table[0][i] = value;
	}

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

	return True;
}

// Assembly:
xorl %ecx, %ecx
movabsq $-0x6a536cd653b4364b, %rdx # imm = 0x95AC9329AC4BC9B5
movq 0xc011d(%rip), %rax     # 0x16c5d0
movl $0x8, %esi
movq %rcx, %rdi
movq %rdi, %r8
shrq %r8
andl $0x1, %edi
negq %rdi
andq %rdx, %rdi
xorq %r8, %rdi
decl %esi
jne 0xac4bb
movq %rdi, (%rax,%rcx,8)
incq %rcx
cmpq $0x100, %rcx            # imm = 0x100
jne 0xac4b3
xorl %ecx, %ecx
movq %rax, %rdx
movl $0x800, %esi            # imm = 0x800
movq -0x800(%rdx,%rsi), %rdi
movzbl %dil, %r8d
shrq $0x8, %rdi
xorq (%rax,%r8,8), %rdi
movq %rdi, (%rdx,%rsi)
addq $0x800, %rsi            # imm = 0x800
cmpq $0x4000, %rsi           # imm = 0x4000
jne 0xac4eb
incq %rcx
addq $0x8, %rdx
cmpq $0x100, %rcx            # imm = 0x100
jne 0xac4e6
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/hash/crc64.cpp
// Function: smooth::Hash::CRC64::Feed(unsigned char const*, int)
S::Bool S::Hash::CRC64::Feed(const UnsignedByte *data, Int size)
{
	while (size >= 8)
	{
		crc   =	table[7][data[0] ^ ( crc	& 0xFF)] ^ table[6][data[1] ^ ((crc >>  8) & 0xFF)] ^
			table[5][data[2] ^ ((crc >> 16) & 0xFF)] ^ table[4][data[3] ^ ((crc >> 24) & 0xFF)] ^
			table[3][data[4] ^ ((crc >> 32) & 0xFF)] ^ table[2][data[5] ^ ((crc >> 40) & 0xFF)] ^
			table[1][data[6] ^ ((crc >> 48) & 0xFF)] ^ table[0][data[7] ^  (crc >> 56)	  ];

		data += 8;
		size -= 8;
	}

	while (size--) crc = (crc >> 8) ^ table[0][(crc & 0xFF) ^ *data++];

	return True;
}

// Assembly:
cmpl $0x8, %edx
jl 0xac62c
movq (%rdi), %r8
movl $0xff, %eax
movq 0xc007e(%rip), %rcx     # 0x16c5d0
movzbl (%rsi), %r9d
movl %r8d, %r10d
andl %eax, %r10d
xorl %r9d, %r10d
movzbl 0x1(%rsi), %r9d
movl %r8d, %r11d
shrl $0x8, %r11d
andl %eax, %r11d
xorl %r9d, %r11d
movq 0x3000(%rcx,%r11,8), %r9
xorq 0x3800(%rcx,%r10,8), %r9
movzbl 0x2(%rsi), %r10d
movl %r8d, %r11d
shrl $0x10, %r11d
andl %eax, %r11d
xorl %r10d, %r11d
xorq 0x2800(%rcx,%r11,8), %r9
movzbl 0x3(%rsi), %r10d
movl %r8d, %r11d
shrl $0x18, %r11d
xorl %r10d, %r11d
xorq 0x2000(%rcx,%r11,8), %r9
movzbl 0x4(%rsi), %r10d
movq %r8, %r11
shrq $0x20, %r11
andl %eax, %r11d
xorl %r10d, %r11d
xorq 0x1800(%rcx,%r11,8), %r9
movzbl 0x5(%rsi), %r10d
movq %r8, %r11
shrq $0x28, %r11
andl %eax, %r11d
xorl %r10d, %r11d
xorq 0x1000(%rcx,%r11,8), %r9
movzbl 0x6(%rsi), %r10d
movq %r8, %r11
shrq $0x30, %r11
andl %eax, %r11d
xorl %r10d, %r11d
xorq 0x800(%rcx,%r11,8), %r9
movzbl 0x7(%rsi), %r10d
shrq $0x38, %r8
xorl %r10d, %r8d
xorq (%rcx,%r8,8), %r9
movq %r9, (%rdi)
addq $0x8, %rsi
leal -0x8(%rdx), %r10d
movq %r9, %r8
cmpl $0xf, %edx
movl %r10d, %edx
jg 0xac552
jmp 0xac62f
movl %edx, %r10d
testl %r10d, %r10d
je 0xac667
movq (%rdi), %r9
movl %r10d, %eax
xorl %ecx, %ecx
movq 0xbff8d(%rip), %rdx     # 0x16c5d0
movq %r9, %r8
shrq $0x8, %r8
movzbl %r9b, %r9d
movzbl (%rsi,%rcx), %r10d
xorl %r9d, %r10d
xorq (%rdx,%r10,8), %r8
movq %r8, (%rdi)
incq %rcx
movq %r8, %r9
cmpl %ecx, %eax
jne 0xac646
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/hash/md5.cpp
// Function: smooth::Hash::MD5::Feed(unsigned char const*, int)
S::Bool S::Hash::MD5::Feed(const UnsignedByte *data, Int size)
{
	buffer.Resize(buffer.Size() + size);

	memcpy(buffer + buffer.Size() - size, data, size);

	for (Int i = 0; i + 63 < buffer.Size(); i += 64) Transform(buffer + i);

	memcpy(buffer, buffer + buffer.Size() - buffer.Size() % 64, buffer.Size() % 64);

	buffer.Resize(buffer.Size() % 64);

	return True;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movl 0x28(%rdi), %esi
addl %edx, %esi
movq %rbx, %rdi
callq 0x62eaa
movq 0x20(%r14), %rax
testq %rax, %rax
je 0xacf24
movq (%rax), %rax
jmp 0xacf26
xorl %eax, %eax
movslq 0x28(%r14), %rdi
addq %rax, %rdi
movslq %ebp, %rdx
subq %rdx, %rdi
movq %r15, %rsi
callq 0x552d0
movl 0x28(%r14), %eax
cmpl $0x40, %eax
jl 0xacf72
xorl %r15d, %r15d
movq 0x20(%r14), %rax
testq %rax, %rax
je 0xacf55
movq (%rax), %rsi
jmp 0xacf57
xorl %esi, %esi
addq %r15, %rsi
movq %r14, %rdi
callq 0x56700
addq $0x40, %r15
movl 0x28(%r14), %eax
leal 0x3f(%r15), %ecx
cmpl %eax, %ecx
jl 0xacf47
movq 0x20(%r14), %rcx
testq %rcx, %rcx
je 0xacf80
movq (%rcx), %rdi
jmp 0xacf82
xorl %edi, %edi
testq %rcx, %rcx
je 0xacf8c
movq (%rcx), %rcx
jmp 0xacf8e
xorl %ecx, %ecx
cltq
addq %rax, %rcx
leal 0x3f(%rax), %edx
testl %eax, %eax
cmovnsl %eax, %edx
andl $-0x40, %edx
subl %edx, %eax
movslq %eax, %rdx
negl %eax
movslq %eax, %rsi
addq %rcx, %rsi
callq 0x552d0
movl 0x28(%r14), %esi
leal 0x3f(%rsi), %eax
testl %esi, %esi
cmovnsl %esi, %eax
andl $-0x40, %eax
subl %eax, %esi
movq %rbx, %rdi
callq 0x62eaa
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/hash/md5.cpp
// Function: smooth::Hash::MD5::Finish()
S::String S::Hash::MD5::Finish()
{
	UnsignedInt64	 bits	= (buffer.Size() + size) * 8;
	Int		 index	= buffer.Size();

	/* Pad out to 56 mod 64.
	 */
	Int		 padLen	= (index < 56) ? (56 - index) : (120 - index);

	UnsignedByte	*end = new UnsignedByte [128];

	memcpy(end, buffer, index);
	memcpy(end + index, PADDING, padLen);

	end[index + padLen    ] = bits	     & 0xFF;
	end[index + padLen + 1] = bits >>  8 & 0xFF;
	end[index + padLen + 2] = bits >> 16 & 0xFF;
	end[index + padLen + 3] = bits >> 24 & 0xFF;
	end[index + padLen + 4] = bits >> 32 & 0xFF;
	end[index + padLen + 5] = bits >> 40 & 0xFF;
	end[index + padLen + 6] = bits >> 48 & 0xFF;
	end[index + padLen + 7] = bits >> 56 & 0xFF;

	Transform(end);

	if (padLen > 56) Transform(end + 64);

	delete [] end;

	String	 string;

	for (Int i = 0; i < 4; i++) string.Append(Number((Int64) REVERSE_INT32(state[i])).ToHexString(8));

	return string;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x28(%rsi), %r12
xorl %r13d, %r13d
cmpq $0x38, %r12
setge %r13b
movq 0x10(%rsi), %rbp
addq %r12, %rbp
shlq $0x3, %rbp
shll $0x6, %r13d
orl $0x38, %r13d
movl %r13d, %eax
subl %r12d, %eax
movl %eax, 0xc(%rsp)
movl $0x80, %edi
callq 0x56670
movq %rax, %r15
movq 0x20(%r14), %rax
testq %rax, %rax
je 0xad051
movq (%rax), %rsi
jmp 0xad053
xorl %esi, %esi
movq %r15, %rdi
movq %r12, %rdx
callq 0x552d0
addq %r15, %r12
movslq 0xc(%rsp), %rdx
leaq 0x65f43(%rip), %rsi     # 0x112fb0
movq %r12, %rdi
movq %rdx, %r12
callq 0x552d0
movl %r13d, %eax
movw %bp, (%r15,%rax)
movl %ebp, %ecx
shrl $0x10, %ecx
movb %cl, 0x2(%r15,%rax)
movl %ebp, %ecx
shrl $0x18, %ecx
movb %cl, 0x3(%r15,%rax)
movq %rbp, %rcx
shrq $0x20, %rcx
movb %cl, 0x4(%r15,%rax)
movq %rbp, %rcx
shrq $0x28, %rcx
movb %cl, 0x5(%r15,%rax)
movq %rbp, %rcx
shrq $0x30, %rcx
movb %cl, 0x6(%r15,%rax)
shrq $0x38, %rbp
movb %bpl, 0x7(%r15,%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x56700
cmpl $0x39, %r12d
jl 0xad0e1
movq %r15, %rsi
addq $0x40, %rsi
movq %r14, %rdi
callq 0x56700
movq %r15, %rdi
callq 0x561e0
xorl %r13d, %r13d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58e20
leaq 0x10(%rsp), %r15
leaq 0x20(%rsp), %r12
movl (%r14,%r13,4), %esi
bswapl %esi
movq %r15, %rdi
callq 0x59050
movq %r12, %rdi
movq %r15, %rsi
movl $0x8, %edx
callq 0x57780
movq %rbx, %rdi
movq %r12, %rsi
callq 0x562f0
movq %r12, %rdi
callq 0x59200
movq %r15, %rdi
callq 0x58d60
incq %r13
cmpq $0x4, %r13
jne 0xad100
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xad175
movq %rax, %r14
jmp 0xad16b
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x59200
leaq 0x10(%rsp), %rdi
callq 0x58d60
movq %rbx, %rdi
callq 0x59200
movq %r14, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/hash/sha1.cpp
// Function: smooth::Hash::SHA1::Transform(unsigned char*)
S::Void S::Hash::SHA1::Transform(UnsignedByte *buffer)
{
	UnsignedInt32	 word[80];

	for (Int j =  0; j < 16; j++) word[j] = buffer[j * 4 + 0] * 0x1000000 + buffer[j * 4 + 1] * 0x10000 + buffer[j * 4 + 2] * 0x100 + buffer[j * 4 + 3];
	for (Int j = 16; j < 80; j++) word[j] = ROTATE_LEFT((word[j - 3] ^ word[j - 8] ^ word[j - 14] ^ word[j - 16]), 1);

	UnsignedInt32	 a = state[0];
	UnsignedInt32	 b = state[1];
	UnsignedInt32	 c = state[2];
	UnsignedInt32	 d = state[3];
	UnsignedInt32	 e = state[4];

	for (int m = 0; m < 80; m++)
	{
		UnsignedInt32	 f = 0;
		UnsignedInt32	 k = 0;

		if	(m <= 19) { f = (b & c) | ((~b) & d);	     k = 0x5a827999; }
		else if (m <= 39) { f = b ^ c ^ d;		     k = 0x6ed9eba1; }
		else if (m <= 59) { f = (b & c) | (b & d) | (c & d); k = 0x8f1bbcdc; }
		else		  { f = b ^ c ^ d;		     k = 0xca62c1d6; }

		UnsignedInt32	 temp = (ROTATE_LEFT(a, 5) + f + e + k + word[m]) & 0xFFFFFFFF;

		e = d;
		d = c;
		c = ROTATE_LEFT(b, 30);
		b = a;

		a = temp;
	}

	state[0] += a;
	state[1] += b;
	state[2] += c;
	state[3] += d;
	state[4] += e;

	size += 64;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
xorl %eax, %eax
movl (%rsi,%rax,4), %ecx
bswapl %ecx
movl %ecx, -0x70(%rsp,%rax,4)
incq %rax
cmpq $0x10, %rax
jne 0xad283
movl $0x10, %eax
movl -0x90(%rsp,%rax,4), %ecx
xorl -0x7c(%rsp,%rax,4), %ecx
xorl -0xa8(%rsp,%rax,4), %ecx
xorl -0xb0(%rsp,%rax,4), %ecx
roll %ecx
movl %ecx, -0x70(%rsp,%rax,4)
incq %rax
cmpq $0x50, %rax
jne 0xad29a
movl (%rdi), %r8d
movl 0x4(%rdi), %esi
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %ecx
movl 0x10(%rdi), %r14d
xorl %r11d, %r11d
movl %r14d, -0x74(%rsp)
movl %ecx, %r12d
movl %edx, %r13d
movl %esi, %ebp
movl %r8d, %r15d
movl %r15d, %eax
movl %ebp, %ebx
movl %r13d, %r10d
movl %r12d, %r9d
cmpq $0x13, %r11
ja 0xad30a
movl %r10d, %r15d
xorl %r9d, %r15d
andl %ebx, %r15d
xorl %r9d, %r15d
movl $0x5a827999, %r12d      # imm = 0x5A827999
jmp 0xad34f
cmpq $0x27, %r11
ja 0xad321
movl %r10d, %r15d
xorl %ebx, %r15d
xorl %r9d, %r15d
movl $0x6ed9eba1, %r12d      # imm = 0x6ED9EBA1
jmp 0xad34f
cmpq $0x3b, %r11
ja 0xad340
movl %r9d, %ebp
orl %r10d, %ebp
andl %ebx, %ebp
movl %r9d, %r15d
andl %r10d, %r15d
orl %ebp, %r15d
movl $0x8f1bbcdc, %r12d      # imm = 0x8F1BBCDC
jmp 0xad34f
movl %r10d, %r15d
xorl %ebx, %r15d
xorl %r9d, %r15d
movl $0xca62c1d6, %r12d      # imm = 0xCA62C1D6
movl %eax, %ebp
roll $0x5, %ebp
addl %ebp, %r14d
addl %r15d, %r14d
addl %r12d, %r14d
movl %r14d, %r15d
addl -0x70(%rsp,%r11,4), %r15d
roll $0x1e, %ebx
incq %r11
movl %r9d, %r14d
movl %r10d, %r12d
movl %ebx, %r13d
movl %eax, %ebp
cmpq $0x50, %r11
jne 0xad2e5
addl %r8d, %r15d
movl %r15d, (%rdi)
addl %esi, %eax
movl %eax, 0x4(%rdi)
addl %edx, %ebx
movl %ebx, 0x8(%rdi)
addl %ecx, %r10d
movl %r10d, 0xc(%rdi)
addl -0x74(%rsp), %r9d
movl %r9d, 0x10(%rdi)
addq $0x40, 0x18(%rdi)
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/misc/hash/sha1.cpp
// Function: smooth::Hash::SHA1::Finish()
S::String S::Hash::SHA1::Finish()
{
	UnsignedInt64	 bits	= (buffer.Size() + size) * 8;
	Int		 index	= buffer.Size();

	/* Pad out to 56 mod 64.
	 */
	Int		 padLen	= (index < 56) ? (56 - index) : (120 - index);

	UnsignedByte	*end = new UnsignedByte [128];

	memcpy(end, buffer, index);
	memcpy(end + index, PADDING, padLen);

	for (Int i = 0; i < 8; i++) end[index + padLen + i] = bits >> 8 * (7 - i) & 0xFF;

	Transform(end);

	if (padLen > 56) Transform(end + 64);

	delete [] end;

	String	 string;

	for (Int i = 0; i < 5; i++) string.Append(Number((Int64) ((UnsignedInt32 *) state)[i]).ToHexString(8));

	return string;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x30(%rsi), %r12
xorl %ebp, %ebp
cmpq $0x38, %r12
setge %bpl
movq 0x18(%rsi), %r13
addq %r12, %r13
shll $0x6, %ebp
orl $0x38, %ebp
movl %ebp, %eax
subl %r12d, %eax
movl %eax, 0xc(%rsp)
movl $0x80, %edi
callq 0x56670
movq %rax, %r15
movq 0x28(%r14), %rax
testq %rax, %rax
je 0xad50b
movq (%rax), %rsi
jmp 0xad50d
xorl %esi, %esi
shlq $0x3, %r13
movq %r15, %rdi
movq %r12, %rdx
callq 0x552d0
addq %r15, %r12
movslq 0xc(%rsp), %rdx
leaq 0x65ac5(%rip), %rsi     # 0x112ff0
movq %r12, %rdi
callq 0x552d0
movl %ebp, %eax
addq %r15, %rax
movl $0x38, %ecx
movq %r13, %rdx
shrq %cl, %rdx
movb %dl, (%rax)
addq $-0x8, %rcx
incq %rax
cmpq $-0x8, %rcx
jne 0xad53d
movq %r14, %rdi
movq %r15, %rsi
callq 0x569f0
cmpl $0x38, 0xc(%rsp)
jle 0xad573
movq %r15, %rsi
addq $0x40, %rsi
movq %r14, %rdi
callq 0x569f0
movq %r15, %rdi
callq 0x561e0
xorl %r13d, %r13d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58e20
leaq 0x10(%rsp), %r15
leaq 0x20(%rsp), %r12
movl (%r14,%r13,4), %esi
movq %r15, %rdi
callq 0x59050
movq %r12, %rdi
movq %r15, %rsi
movl $0x8, %edx
callq 0x57780
movq %rbx, %rdi
movq %r12, %rsi
callq 0x562f0
movq %r12, %rdi
callq 0x59200
movq %r15, %rdi
callq 0x58d60
incq %r13
cmpq $0x5, %r13
jne 0xad592
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xad605
movq %rax, %r14
jmp 0xad5fb
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x59200
leaq 0x10(%rsp), %rdi
callq 0x58d60
movq %rbx, %rdi
callq 0x59200
movq %r14, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/net/protocols/http.cpp
// Function: smooth::Net::Protocols::HTTP::HTTP(smooth::String const&)
S::Net::Protocols::HTTP::HTTP(const String &iURL) : Protocol(iURL)
{
	mode	  = HTTP_METHOD_GET;

	proxyMode = HTTP_PROXY_NONE;
	proxyPort = 0;

	out	  = NIL;

	ulStart	  = 0;
	dlStart	  = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x562b0
movq 0xbe9f5(%rip), %rax     # 0x16c570
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0xd0(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x58e20
leaq 0xf0(%rbx), %r15
movq %r15, %rdi
xorl %esi, %esi
movq %r14, 0x10(%rsp)
callq 0x58e20
leaq 0x108(%rbx), %r12
movq %r12, %rdi
xorl %esi, %esi
movq %r15, 0x8(%rsp)
callq 0x58e20
movq %r12, (%rsp)
leaq 0x120(%rbx), %r13
movq %r13, %rdi
callq 0x55d90
leaq 0xbc3cf(%rip), %r15     # 0x169fa8
movq %r15, 0x160(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x168(%rbx)
leaq 0xbc317(%rip), %r12     # 0x169f08
movq %r12, 0x120(%rbx)
leaq 0x178(%rbx), %rbp
movq %rbp, %rdi
callq 0x55d90
movq %r15, 0x1b8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x1c0(%rbx)
movq %r12, 0x178(%rbx)
leaq 0xb330a(%rip), %rax     # 0x160f30
movq %rax, 0x1d0(%rbx)
movups %xmm0, 0x1d8(%rbx)
leaq 0x1e8(%rbx), %r14
movq %r14, %rdi
callq 0x55d90
movq %r15, 0x228(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x230(%rbx)
movq %r12, 0x1e8(%rbx)
leaq 0x240(%rbx), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x58e20
leaq 0x270(%rbx), %rdi
xorl %esi, %esi
callq 0x58e20
xorl %eax, %eax
movw %ax, 0xc8(%rbx)
movw %ax, 0xec(%rbx)
movl $0x0, 0xe8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x258(%rbx)
movq $0x0, 0x268(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq %r15, %rdi
callq 0x59200
jmp 0xadcc8
movq %rax, %r12
movq %r14, %rdi
callq 0xaf87e
jmp 0xadcd5
movq %rax, %r12
leaq 0x1d0(%rbx), %rdi
leaq 0xb324d(%rip), %rax     # 0x160f30
movq %rax, (%rdi)
callq 0x6207e
movq %rbp, %rdi
callq 0xaf87e
jmp 0xadcf8
movq %rax, %r12
movq %r13, %rdi
callq 0xaf87e
jmp 0xadd05
movq %rax, %r12
movq (%rsp), %rdi
callq 0x59200
movq 0x8(%rsp), %rdi
callq 0x59200
movq 0x10(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x55a80
movq %r12, %rdi
callq 0x57090
movq %rax, %r12
jmp 0xadd0e
movq %rax, %r12
jmp 0xadd18
movq %rax, %r12
jmp 0xadd22
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/net/protocols/http.cpp
// Function: smooth::Net::Protocols::HTTP::SetHeaderField(smooth::String const&, smooth::String const&)
S::Int S::Net::Protocols::HTTP::SetHeaderField(const String &key, const String &value)
{
	Parameter	 field;

	field.key	= key;
	field.value	= value;

	requestFields.Add(field);

	return Success();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0x570d0
movq %r12, %rdi
movq %r14, %rsi
callq 0x555f0
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x555f0
addq $0x120, %rbx            # imm = 0x120
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xafc12
movq %r14, %rdi
callq 0x59200
movq %rsp, %rdi
callq 0x59200
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x59200
movq %rsp, %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/net/protocols/http.cpp
// Function: smooth::Net::Protocols::HTTP::SetParameterFile(smooth::String const&, smooth::String const&)
S::Int S::Net::Protocols::HTTP::SetParameterFile(const String &key, const String &fileName)
{
	if (!S::File(fileName).Exists()) return Error();

	Parameter	 parameter;

	parameter.key	= key;
	parameter.value	= fileName;

	parameter.isFile= True;

	requestParameters.Add(parameter);

	return Success();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x58e20
movq %rsp, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x56800
movq %rsp, %rdi
callq 0x56ef0
movl %eax, %ebp
movq %rsp, %rdi
callq 0x59178
leaq 0x38(%rsp), %rdi
callq 0x59200
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb %bpl, %bpl
je 0xae054
movq %rsp, %r12
movq %r12, %rdi
callq 0x570d0
movq %r12, %rdi
movq %r15, %rsi
callq 0x555f0
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x555f0
movq %rsp, %rsi
movb $0x1, 0x30(%rsi)
addq $0x178, %rbx            # imm = 0x178
movq %rbx, %rdi
callq 0xafc12
movq %r15, %rdi
callq 0x59200
movq %rsp, %rdi
callq 0x59200
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x59178
jmp 0xae071
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
jmp 0xae088
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x59200
movq %rsp, %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/net/protocols/http.cpp
// Function: smooth::Net::Protocols::HTTP::SetProxy(smooth::String const&, int)
S::Int S::Net::Protocols::HTTP::SetProxy(const String &nProxy, Int nProxyPort)
{
	proxy	  = nProxy;
	proxyPort = nProxyPort;

	if (proxyMode == HTTP_PROXY_NONE) proxyMode = HTTP_PROXY_HTTP;

	return Success();
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
addq $0xd0, %rdi
callq 0x555f0
movl %ebp, 0xe8(%rbx)
cmpw $0x0, 0xec(%rbx)
jne 0xae0df
movw $0x1, 0xec(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/net/protocols/http.cpp
// Function: smooth::Net::Protocols::HTTP::GetParametersURLEncoded() const
S::String S::Net::Protocols::HTTP::GetParametersURLEncoded() const
{
	String	 str;

	for (Int i = 0; i < requestParameters.Length(); i++)
	{
		const Parameter	&parameter = requestParameters.GetNth(i);

		if (i > 0) str.Append("&");

		str.Append(parameter.key).Append("=").Append(parameter.value);
	}

	return str;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x58e20
cmpl $0x0, 0x180(%r14)
jle 0xaf204
movq %r14, %r15
leaq 0x178(%r14), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %r13
movq 0x8(%rsp), %rdi
movl %ebp, %esi
callq 0xafe6e
movq %rax, %r12
testl %ebp, %ebp
je 0xaf1ba
movq %r13, %rdi
leaq 0x64058(%rip), %rsi     # 0x1131fa
callq 0x579f0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x562f0
movq %r13, %rdi
callq 0x59200
movq %rbx, %rdi
movq %r12, %rsi
callq 0x562f0
movq %rax, %r14
movq %r13, %rdi
leaq 0x63f9b(%rip), %rsi     # 0x11316d
callq 0x579f0
movq %r14, %rdi
movq %r13, %rsi
callq 0x562f0
addq $0x18, %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0x562f0
movq %r13, %rdi
callq 0x59200
incl %ebp
cmpl 0x180(%r15), %ebp
jl 0xaf185
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xaf21c
jmp 0xaf221
jmp 0xaf21c
movq %rax, %r14
jmp 0xaf22e
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x59200
movq %r14, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/net/protocols/http.cpp
// Function: smooth::Net::Protocols::httpWrite(char*, unsigned long, unsigned long, void*)
size_t S::Net::Protocols::httpWrite(char *buffer, size_t size, size_t n, void *data)
{
	HTTP	*http = (HTTP *) data;

	/* Cancel download if requested.
	 */
	if (http->doCancelDownload.Call()) return 0;

	/* Write data to output file.
	 */
	http->out->OutputData(buffer, size * n);

	return size * n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0xa0(%rcx), %rdi
callq 0x9a5fe
testb %al, %al
je 0xaf587
xorl %ebx, %ebx
jmp 0xaf59d
movq 0x258(%r12), %rdi
imulq %r15, %rbx
movq %r14, %rsi
movl %ebx, %edx
callq 0x55b50
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/net/protocols/protocol.cpp
// Function: smooth::Net::Protocols::Protocol::RemoveAllProtocols()
S::Int S::Net::Protocols::Protocol::RemoveAllProtocols()
{
	protocol_creators->RemoveAll();
	protocol_magics->RemoveAll();

	delete protocol_creators;
	delete protocol_magics;

	return Success();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0xbcccd(%rip), %r14     # 0x16cc00
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq 0xbc6f5(%rip), %rbx     # 0x16c638
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq (%r14), %rdi
testq %rdi, %rdi
je 0xaff5a
movq (%rdi), %rax
callq *0x8(%rax)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xaff68
movq (%rdi), %rax
callq *0x8(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/net/protocols/protocol.cpp
// Function: smooth::Net::Protocols::Protocol::AddProtocol(smooth::Net::Protocols::Protocol* (*)(smooth::String const&), smooth::String const&)
S::Int S::Net::Protocols::Protocol::AddProtocol(Protocol *(*protocol)(const String &), const String &magic)
{
	if (protocol == NIL) return Error();

	if (protocol_creators == NIL)	protocol_creators = new Array<Protocol *(*)(const String &), Void *>;
	if (protocol_magics == NIL)	protocol_magics = new Array<String>;

	protocol_creators->Add(protocol);
	protocol_magics->Add(magic);

	return Success();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
testq %rdi, %rdi
je 0xb002b
movq %rsi, %rbx
movq 0xbcc6f(%rip), %r15     # 0x16cc00
cmpq $0x0, (%r15)
jne 0xaffcc
movl $0x58, %edi
callq 0x556b0
movq %rax, %r14
movq %rax, %rdi
callq 0x55d90
leaq 0xb082d(%rip), %rax     # 0x1607e0
movq %rax, 0x40(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r14)
leaq 0xba04a(%rip), %rax     # 0x16a010
movq %rax, (%r14)
movq %r14, (%r15)
movq 0xbc665(%rip), %r12     # 0x16c638
cmpq $0x0, (%r12)
jne 0xb0010
movl $0x58, %edi
callq 0x556b0
movq %rax, %r14
movq %rax, %rdi
callq 0x55d90
leaq 0xb129a(%rip), %rax     # 0x161290
movq %rax, 0x40(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r14)
leaq 0xb11e7(%rip), %rax     # 0x1611f0
movq %rax, (%r14)
movq %r14, (%r12)
movq (%r15), %rdi
movq %rsp, %rsi
callq 0x5af08
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x64280
xorl %eax, %eax
jmp 0xb0030
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xb003e
movq %rax, %rbx
movl $0x58, %esi
movq %r14, %rdi
callq 0x55480
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/system/event.cpp
// Function: smooth::System::EventProcessor::ProcessNextEvent()
S::Bool S::System::EventProcessor::ProcessNextEvent()
{
	Int	 suspendCount = GUI::Application::Lock::SuspendLock();
	Bool	 result	      = backend->ProcessNextEvent();

	GUI::Application::Lock::ResumeLock(suspendCount);

	return result;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x59080
movl %eax, %ebp
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, %ebx
movl %ebp, %edi
callq 0x57540
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/system/system.cpp
// Function: smooth::System::System::Sleep(unsigned int)
S::Bool S::System::System::Sleep(UnsignedInt mSeconds)
{
#ifdef __WIN32__
	::Sleep(mSeconds);
#else
	timespec	 req;
	timespec	 rem;

	req.tv_sec  = mSeconds / 1000;
	req.tv_nsec = (mSeconds % 1000) * 1000000;

	while (nanosleep(&req, &rem) == -1)
	{
		if (errno != EINTR) break;

		req.tv_sec  = rem.tv_sec;
		req.tv_nsec = rem.tv_nsec;
	}
#endif

	return True;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edi, %eax
imulq $0x10624dd3, %rax, %rcx # imm = 0x10624DD3
shrq $0x26, %rcx
leaq 0x10(%rsp), %rax
movq %rcx, (%rax)
imull $0x3e8, %ecx, %ecx      # imm = 0x3E8
subl %ecx, %edi
imull $0xf4240, %edi, %ecx    # imm = 0xF4240
movq %rcx, 0x8(%rax)
movq %rsp, %rsi
movq %rax, %rdi
callq 0x587c0
cmpl $-0x1, %eax
jne 0xb1fbc
callq 0x58490
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %rsp, %r15
cmpl $0x4, (%rbx)
jne 0xb1fbc
movups (%rsp), %xmm0
movups %xmm0, 0x10(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x587c0
cmpl $-0x1, %eax
je 0xb1f9e
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/system/system.cpp
// Function: smooth::System::System::OpenURL(smooth::String const&)
S::Bool S::System::System::OpenURL(const String &url)
{
#if defined __WIN32__
	ShellExecute(NULL, (wchar_t *) L"open", url, NULL, NULL, SW_SHOW);
#elif defined __APPLE__
	const char	*args = url;

	if (!fork()) { execl("/usr/bin/open", "open", args, NULL); exit(0); }
#elif defined __HAIKU__
	const char	*args = url;

	if (!fork()) { execl("/boot/system/bin/open", "open", args, NULL); exit(0); }
#else
	/* Try the open commands from freedesktop.org and the Gnome, KDE
	 * and Xfce desktops first, then try some widely used browsers.
	 */
	static const char	*browsers[] = { "xdg-open", "gnome-open", "kde-open", "exo-open",
						"firefox", "safari", "chrome", "opera", "mozilla", "netscape", "epiphany", "konqueror",
						NIL };

	String	 command;

	for (int i = 0; browsers[i] != NIL; i++)
	{
		if (i > 0) command.Append(" || ");

		command.Append(browsers[i]).Append(" \"").Append(url).Append("\"");
	}

	const char	*cmd = command;

	if (!fork()) { execl("/bin/sh", "sh", "-c", cmd, NULL); exit(0); }
#endif

	return True;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, (%rsp)
leaq 0x8(%rsp), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x58e20
leaq 0xb8050(%rip), %rbx     # 0x16a150
leaq 0x20(%rsp), %r15
leaq 0x50(%rsp), %r13
leaq 0x38(%rsp), %r12
testl %r14d, %r14d
je 0xb2142
cmpl $0xc, %r14d
je 0xb21c4
movq %r15, %rdi
leaq 0x61569(%rip), %rsi     # 0x113691
callq 0x579f0
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x562f0
movq %r15, %rdi
callq 0x59200
movq (%rbx), %rsi
movq %r15, %rdi
callq 0x579f0
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x562f0
movq %rax, %rbp
movq %r13, %rdi
leaq 0x6152f(%rip), %rsi     # 0x113696
callq 0x579f0
movq %rbp, %rdi
movq %r13, %rsi
callq 0x562f0
movq %rax, %rdi
movq (%rsp), %rsi
callq 0x562f0
movq %rax, %rbp
movq %r12, %rdi
leaq 0x61507(%rip), %rsi     # 0x113697
callq 0x579f0
movq %rbp, %rdi
movq %r12, %rsi
callq 0x562f0
movq %r12, %rdi
callq 0x59200
movq %r13, %rdi
callq 0x59200
movq %r15, %rdi
callq 0x59200
incl %r14d
addq $0x8, %rbx
jmp 0xb210f
leaq 0x8(%rsp), %rdi
callq 0x585e0
movq %rax, %rbx
callq 0x583e0
testl %eax, %eax
je 0xb21f5
leaq 0x8(%rsp), %rdi
callq 0x59200
movb $0x1, %al
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x61204(%rip), %rdi     # 0x113400
leaq 0x61202(%rip), %rsi     # 0x113405
leaq 0x611fe(%rip), %rdx     # 0x113408
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x59070
xorl %edi, %edi
callq 0x57120
jmp 0xb223c
jmp 0xb223c
jmp 0xb2237
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x59200
jmp 0xb2244
jmp 0xb2241
jmp 0xb2237
movq %rax, %rbx
jmp 0xb224e
movq %rax, %rbx
jmp 0xb2258
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x59200
leaq 0x20(%rsp), %rdi
callq 0x59200
leaq 0x8(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/system/system.cpp
// Function: smooth::System::System::GetWindowsRootDirectory()
S::String S::System::System::GetWindowsRootDirectory()
{
	static String	 windowsDir;

	if (windowsDir != NIL) return windowsDir;

#ifdef __WIN32__
	Buffer<wchar_t>	 buffer(32768 + 1);

	GetWindowsDirectory(buffer, buffer.Size());

	windowsDir = buffer;
#endif

	if (!windowsDir.EndsWith(Directory::GetDirectoryDelimiter())) windowsDir.Append(Directory::GetDirectoryDelimiter());
	if ( windowsDir == Directory::GetDirectoryDelimiter())	      windowsDir = NIL;

	return windowsDir;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movb 0xc4db5(%rip), %al      # 0x177030
testb %al, %al
je 0xb233d
leaq 0xc4d8e(%rip), %rdi     # 0x177018
xorl %esi, %esi
callq 0x56bd0
testb %al, %al
jne 0xb2322
callq 0x55370
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x579f0
leaq 0xc4d63(%rip), %rdi     # 0x177018
movq %r14, %rsi
callq 0x58b10
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x59200
testb %bpl, %bpl
jne 0xb22fc
callq 0x55370
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x579f0
leaq 0xc4d2e(%rip), %rdi     # 0x177018
movq %r14, %rsi
callq 0x562f0
leaq 0x8(%rsp), %rdi
callq 0x59200
callq 0x55370
leaq 0xc4d10(%rip), %rdi     # 0x177018
movq %rax, %rsi
callq 0x57ef0
testb %al, %al
je 0xb2322
leaq 0xc4cfd(%rip), %rdi     # 0x177018
xorl %esi, %esi
callq 0x579e0
leaq 0xc4cef(%rip), %rsi     # 0x177018
movq %rbx, %rdi
callq 0x570b0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xc4cec(%rip), %rdi     # 0x177030
callq 0x56120
testl %eax, %eax
je 0xb2283
leaq 0xc4cc0(%rip), %rdi     # 0x177018
xorl %esi, %esi
callq 0x58e20
movq 0xbabca(%rip), %rdi     # 0x16cf30
leaq 0xc4cab(%rip), %rsi     # 0x177018
leaq 0xbcd0c(%rip), %rdx     # 0x16f080
callq 0x57e10
leaq 0xc4cb0(%rip), %rdi     # 0x177030
callq 0x56b80
jmp 0xb2283
movq %rax, %rbx
leaq 0xc4c9c(%rip), %rdi     # 0x177030
callq 0x56420
jmp 0xb23aa
jmp 0xb239d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/system/system.cpp
// Function: smooth::System::System::GetProgramFilesDirectory()
S::String S::System::System::GetProgramFilesDirectory()
{
	static String	 programsDir;

	if (programsDir != NIL) return programsDir;

#ifdef __WIN32__
	HKEY	 currentVersion;

	if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion", 0, KEY_QUERY_VALUE, &currentVersion) == ERROR_SUCCESS)
	{
		DWORD		 size = (32768 + 1) * sizeof(wchar_t);
		Buffer<BYTE>	 buffer(size);

		RegQueryValueEx(currentVersion, L"ProgramFilesDir", 0, NIL, buffer, &size);

		programsDir = (wchar_t *) (BYTE *) buffer;

		RegCloseKey(currentVersion);
	}

	if (programsDir == NIL)
	{
		/* Failed to get the program files directory from the registry.
		 * Get the directory name from the environment variable.
		 */
		Buffer<wchar_t>	 buffer(32768 + 1);

		ExpandEnvironmentStrings(String("%ProgramFiles%"), buffer, buffer.Size());

		programsDir = buffer;
	}
#endif

	if (!programsDir.EndsWith(Directory::GetDirectoryDelimiter())) programsDir.Append(Directory::GetDirectoryDelimiter());
	if ( programsDir == Directory::GetDirectoryDelimiter())	       programsDir = NIL;

	return programsDir;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movb 0xc4c8d(%rip), %al      # 0x177050
testb %al, %al
je 0xb2485
leaq 0xc4c66(%rip), %rdi     # 0x177038
xorl %esi, %esi
callq 0x56bd0
testb %al, %al
jne 0xb246a
callq 0x55370
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x579f0
leaq 0xc4c3b(%rip), %rdi     # 0x177038
movq %r14, %rsi
callq 0x58b10
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x59200
testb %bpl, %bpl
jne 0xb2444
callq 0x55370
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x579f0
leaq 0xc4c06(%rip), %rdi     # 0x177038
movq %r14, %rsi
callq 0x562f0
leaq 0x8(%rsp), %rdi
callq 0x59200
callq 0x55370
leaq 0xc4be8(%rip), %rdi     # 0x177038
movq %rax, %rsi
callq 0x57ef0
testb %al, %al
je 0xb246a
leaq 0xc4bd5(%rip), %rdi     # 0x177038
xorl %esi, %esi
callq 0x579e0
leaq 0xc4bc7(%rip), %rsi     # 0x177038
movq %rbx, %rdi
callq 0x570b0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xc4bc4(%rip), %rdi     # 0x177050
callq 0x56120
testl %eax, %eax
je 0xb23cb
leaq 0xc4b98(%rip), %rdi     # 0x177038
xorl %esi, %esi
callq 0x58e20
movq 0xbaa82(%rip), %rdi     # 0x16cf30
leaq 0xc4b83(%rip), %rsi     # 0x177038
leaq 0xbcbc4(%rip), %rdx     # 0x16f080
callq 0x57e10
leaq 0xc4b88(%rip), %rdi     # 0x177050
callq 0x56b80
jmp 0xb23cb
movq %rax, %rbx
leaq 0xc4b74(%rip), %rdi     # 0x177050
callq 0x56420
jmp 0xb24f2
jmp 0xb24e5
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/system/system.cpp
// Function: smooth::System::System::GetTempDirectory()
S::String S::System::System::GetTempDirectory()
{
	static String	 tempDir;

	if (tempDir != NIL) return tempDir;

	String::InputFormat	 inputFormat("UTF-8");

#if defined __WIN32__
	Buffer<wchar_t>	 buffer(32768 + 1);

	GetTempPath(buffer.Size(), buffer);

	tempDir = buffer;
#elif defined __HAIKU__
	FILE		*pstdin = popen("finddir B_COMMON_TEMP_DIRECTORY", "r");
	Buffer<char>	 buffer(PATH_MAX + 1);

	buffer.Zero();

	fscanf(pstdin, String("%[^\n]").Append(String::FromInt(buffer.Size() - 1)), (char *) buffer);

	pclose(pstdin);

	tempDir = buffer;
#else
	tempDir = getenv("TMPDIR");

	if (tempDir == NIL) tempDir = "/var/tmp";
#endif

	if (!tempDir.EndsWith(Directory::GetDirectoryDelimiter())) tempDir.Append(Directory::GetDirectoryDelimiter());
	if ( tempDir == Directory::GetDirectoryDelimiter())	   tempDir = NIL;

	return tempDir;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movb 0xc3cc9(%rip), %al      # 0x177170
testb %al, %al
je 0xb35d0
leaq 0xc3ca2(%rip), %rdi     # 0x177158
xorl %esi, %esi
callq 0x56bd0
testb %al, %al
je 0xb34d5
leaq 0xc3c90(%rip), %rsi     # 0x177158
movq %rbx, %rdi
callq 0x570b0
jmp 0xb35c6
leaq 0x5fc4a(%rip), %rsi     # 0x113126
leaq 0x20(%rsp), %rdi
callq 0x590d0
leaq 0x60249(%rip), %rdi     # 0x113736
callq 0x57720
leaq 0xc3c5f(%rip), %rdi     # 0x177158
movq %rax, %rsi
callq 0x55f40
leaq 0xc3c50(%rip), %rdi     # 0x177158
xorl %esi, %esi
callq 0x55260
testb %al, %al
je 0xb3526
leaq 0xc3c3e(%rip), %rdi     # 0x177158
leaq 0x6021c(%rip), %rsi     # 0x11373d
callq 0x55f40
callq 0x55370
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x579f0
leaq 0xc3c19(%rip), %rdi     # 0x177158
leaq 0x8(%rsp), %rsi
callq 0x58b10
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x59200
testb %bpl, %bpl
jne 0xb3587
callq 0x55370
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x579f0
leaq 0xc3be5(%rip), %rdi     # 0x177158
leaq 0x8(%rsp), %rsi
callq 0x562f0
leaq 0x8(%rsp), %rdi
callq 0x59200
callq 0x55370
leaq 0xc3bc5(%rip), %rdi     # 0x177158
movq %rax, %rsi
callq 0x57ef0
testb %al, %al
je 0xb35ad
leaq 0xc3bb2(%rip), %rdi     # 0x177158
xorl %esi, %esi
callq 0x579e0
leaq 0xc3ba4(%rip), %rsi     # 0x177158
movq %rbx, %rdi
callq 0x570b0
leaq 0x20(%rsp), %rdi
callq 0x56a30
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
leaq 0xc3b99(%rip), %rdi     # 0x177170
callq 0x56120
testl %eax, %eax
je 0xb34af
leaq 0xc3b6d(%rip), %rdi     # 0x177158
xorl %esi, %esi
callq 0x58e20
movq 0xb9937(%rip), %rdi     # 0x16cf30
leaq 0xc3b58(%rip), %rsi     # 0x177158
leaq 0xbba79(%rip), %rdx     # 0x16f080
callq 0x57e10
leaq 0xc3b5d(%rip), %rdi     # 0x177170
callq 0x56b80
jmp 0xb34af
movq %rax, %rbx
leaq 0xc3b49(%rip), %rdi     # 0x177170
callq 0x56420
jmp 0xb3650
jmp 0xb3632
jmp 0xb3643
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x59200
jmp 0xb3646
jmp 0xb3643
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x56a30
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/system/timer.cpp
// Function: smooth::System::Timer::Timer()
S::System::Timer::Timer()
{
	backend = TimerBackend::CreateBackendInstance(this);

	type = classID;

	interval = 0;
	status = TIMER_STOPPED;

	onInterval.SetParentObject(this);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x56e70
movq 0xb9624(%rip), %rax     # 0x16cc90
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x48(%rbx), %r14
movq $0x0, 0x50(%rbx)
leaq 0xaf0c2(%rip), %rax     # 0x162748
movq %rax, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rbx)
movq %rbx, %rdi
callq 0xb38fa
movq %rax, 0x38(%rbx)
movq 0xb921c(%rip), %rax     # 0x16c8c0
movzwl (%rax), %eax
movw %ax, 0x20(%rbx)
movl $0x0, 0x40(%rbx)
movw $0x0, 0x44(%rbx)
movq %rbx, 0x50(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x703d2
movq %rbx, %rdi
callq 0x55c60
movq %r15, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/system/timer.cpp
// Function: smooth::System::Timer::Start(int)
S::Int S::System::Timer::Start(Int iInterval)
{
	if (status == TIMER_RUNNING) return Error();

	interval = iInterval;
	status = TIMER_RUNNING;

	return backend->Start(interval);
}

// Assembly:
cmpw $0x1, 0x44(%rdi)
jne 0xb3781
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
movl %esi, 0x40(%rdi)
movw $0x1, 0x44(%rdi)
movq 0x38(%rdi), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
jmpq *%rax
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/threads/access.cpp
// Function: smooth::Threads::Access::Value(bool volatile&)
S::Bool S::Threads::Access::Value(volatile Bool &value)
{
	if (mutex != NIL) mutex->Lock();

	Bool	 result = value;

	if (mutex != NIL) mutex->Release();

	return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xb8e0c(%rip), %r14     # 0x16c7d8
movq (%r14), %rdi
testq %rdi, %rdi
je 0xb39d9
callq 0x558a0
movb (%rbx), %bl
movq (%r14), %rdi
testq %rdi, %rdi
je 0xb39e8
callq 0x58150
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/threads/access.cpp
// Function: smooth::Threads::Access::Set(bool volatile&, bool)
S::Bool S::Threads::Access::Set(volatile Bool &value, Bool n)
{
	mutex->Lock();

	Bool	 result = value = n;

	mutex->Release();

	return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0xb8dd5(%rip), %r15     # 0x16c7d8
movq (%r15), %rdi
callq 0x558a0
movb %bl, (%r14)
movb (%r14), %bl
movq (%r15), %rdi
callq 0x58150
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/threads/access.cpp
// Function: smooth::Threads::Access::Value(short volatile&)
S::Short S::Threads::Access::Value(volatile Short &value)
{
	if (mutex != NIL) mutex->Lock();

	Short	 result = value;

	if (mutex != NIL) mutex->Release();

	return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xb8da8(%rip), %r14     # 0x16c7d8
movq (%r14), %rdi
testq %rdi, %rdi
je 0xb3a3d
callq 0x558a0
movzwl (%rbx), %ebx
movq (%r14), %rdi
testq %rdi, %rdi
je 0xb3a4d
callq 0x58150
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop