LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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:
movzwl (%rdi), %r8d
xorl %eax, %eax
movq 0xbb617(%rip), %rcx     # 0x161e38
movl %edx, %r9d
cmpl $0x7, %r9d
jle 0xa68bc
xorw (%rsi,%rax), %r8w
movw %r8w, (%rdi)
movzwl %r8w, %r8d
movzbl %r8b, %r10d
shrl $0x8, %r8d
movzwl 0xc00(%rcx,%r8,2), %r8d
xorw 0xe00(%rcx,%r10,2), %r8w
movzbl 0x2(%rsi,%rax), %r10d
xorw 0xa00(%rcx,%r10,2), %r8w
movzbl 0x3(%rsi,%rax), %r10d
xorw 0x800(%rcx,%r10,2), %r8w
movzbl 0x4(%rsi,%rax), %r10d
xorw 0x600(%rcx,%r10,2), %r8w
movzbl 0x5(%rsi,%rax), %r10d
xorw 0x400(%rcx,%r10,2), %r8w
movzbl 0x6(%rsi,%rax), %r10d
xorw 0x200(%rcx,%r10,2), %r8w
movzbl 0x7(%rsi,%rax), %r10d
xorw (%rcx,%r10,2), %r8w
movw %r8w, (%rdi)
addl $-0x8, %r9d
addq $0x8, %rax
jmp 0xa6824
movl %edx, %edx
cmpl %eax, %edx
je 0xa68e4
movzwl %r8w, %r8d
movzbl (%rsi,%rax), %r9d
xorl %r8d, %r9d
shrl $0x8, %r8d
movzbl %r9b, %r9d
xorw (%rcx,%r9,2), %r8w
movw %r8w, (%rdi)
incq %rax
jmp 0xa68be
movb $0x1, %al
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
pushq $0x8
popq %rbp
pushq $0x20
popq %r14
movq 0xbaab1(%rip), %r15     # 0x161430
cmpq $0x100, %rbx            # imm = 0x100
je 0xa69bd
movl %ebx, %edi
movl %ebp, %esi
callq 0x59a70
shll $0x18, %eax
movl %ebp, %ecx
subl $0x1, %ecx
jb 0xa69aa
leal (%rax,%rax), %edx
sarl $0x1f, %eax
andl $0x4c11db7, %eax        # imm = 0x4C11DB7
xorl %edx, %eax
jmp 0xa6996
movl %eax, %edi
movl %r14d, %esi
callq 0x59a70
movl %eax, (%r15,%rbx,4)
incq %rbx
jmp 0xa697f
xorl %eax, %eax
movq %r15, %rcx
cmpq $0x100, %rax            # imm = 0x100
je 0xa69ff
movl $0x400, %edx            # imm = 0x400
cmpq $0x2000, %rdx           # imm = 0x2000
je 0xa69f6
movl -0x400(%rcx,%rdx), %esi
movzbl %sil, %edi
shrl $0x8, %esi
xorl (%r15,%rdi,4), %esi
movl %esi, (%rcx,%rdx)
addq $0x400, %rdx            # imm = 0x400
jmp 0xa69cf
incq %rax
addq $0x4, %rcx
jmp 0xa69c2
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
leal -0x1(%rsi), %ecx
pushq $0x1
popq %rdx
xorl %eax, %eax
movl %edx, %r8d
cmpl %esi, %r8d
jg 0xa6a47
movl %edi, %r9d
andl $0x1, %r9d
negl %r9d
movl %edx, %r10d
shll %cl, %r10d
andl %r9d, %r10d
orl %r10d, %eax
shrl %edi
incl %r8d
decl %ecx
jmp 0xa6a23
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movl (%rdi), %r8d
xorl %eax, %eax
movl $0xff, %r9d
movq 0xba9d5(%rip), %rcx     # 0x161430
movl %edx, %r10d
cmpl $0x7, %r10d
jle 0xa6af6
xorl (%rsi,%rax), %r8d
movl %r8d, (%rdi)
movl %r8d, %ebx
andl %r9d, %ebx
movl %r8d, %r11d
shrl $0x8, %r11d
andl %r9d, %r11d
movl 0x1800(%rcx,%r11,4), %r11d
xorl 0x1c00(%rcx,%rbx,4), %r11d
movl %r8d, %ebx
shrl $0xe, %ebx
andl $0x3fc, %ebx            # imm = 0x3FC
xorl 0x1400(%rcx,%rbx), %r11d
shrl $0x18, %r8d
xorl 0x1000(%rcx,%r8,4), %r11d
movzbl 0x4(%rsi,%rax), %r8d
xorl 0xc00(%rcx,%r8,4), %r11d
movzbl 0x5(%rsi,%rax), %r8d
xorl 0x800(%rcx,%r8,4), %r11d
movzbl 0x6(%rsi,%rax), %r8d
xorl 0x400(%rcx,%r8,4), %r11d
movzbl 0x7(%rsi,%rax), %r8d
xorl (%rcx,%r8,4), %r11d
movl %r11d, (%rdi)
addl $-0x8, %r10d
addq $0x8, %rax
movl %r11d, %r8d
jmp 0xa6a5e
movl %edx, %edx
cmpl %eax, %edx
je 0xa6b18
movzbl %r8b, %r9d
shrl $0x8, %r8d
movzbl (%rsi,%rax), %r10d
xorl %r9d, %r10d
xorl (%rcx,%r10,4), %r8d
movl %r8d, (%rdi)
incq %rax
jmp 0xa6af8
movb $0x1, %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x8
popq %rdx
movq 0xbaa24(%rip), %rax     # 0x1615d0
movabsq $-0x6a536cd653b4364b, %rsi # imm = 0x95AC9329AC4BC9B5
cmpq $0x100, %rcx            # imm = 0x100
je 0xa6be8
movl %edx, %r8d
movq %rcx, %rdi
subl $0x1, %r8d
jb 0xa6bdf
movq %rdi, %r9
shrq %r9
andl $0x1, %edi
negq %rdi
andq %rsi, %rdi
xorq %r9, %rdi
jmp 0xa6bc5
movq %rdi, (%rax,%rcx,8)
incq %rcx
jmp 0xa6bb6
xorl %ecx, %ecx
movq %rax, %rdx
cmpq $0x100, %rcx            # imm = 0x100
je 0xa6c2e
movl $0x800, %esi            # imm = 0x800
cmpq $0x4000, %rsi           # imm = 0x4000
je 0xa6c25
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
jmp 0xa6bfb
incq %rcx
addq $0x8, %rdx
jmp 0xa6bed
movb $0x1, %al
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
movq (%rdi), %r8
xorl %eax, %eax
movl $0xff, %r9d
movq 0xba979(%rip), %rcx     # 0x1615d0
movl %edx, %r10d
cmpl $0x7, %r10d
jle 0xa6d37
movzbl (%rsi,%rax), %r11d
movl %r8d, %ebx
andl %r9d, %ebx
xorl %r11d, %ebx
movzbl 0x1(%rsi,%rax), %r11d
movl %r8d, %r14d
shrl $0x8, %r14d
andl %r9d, %r14d
xorl %r11d, %r14d
movq 0x3000(%rcx,%r14,8), %r11
xorq 0x3800(%rcx,%rbx,8), %r11
movzbl 0x2(%rsi,%rax), %ebx
movl %r8d, %r14d
shrl $0x10, %r14d
andl %r9d, %r14d
xorl %ebx, %r14d
xorq 0x2800(%rcx,%r14,8), %r11
movzbl 0x3(%rsi,%rax), %ebx
movl %r8d, %r14d
shrl $0x18, %r14d
xorl %ebx, %r14d
xorq 0x2000(%rcx,%r14,8), %r11
movzbl 0x4(%rsi,%rax), %ebx
movq %r8, %r14
shrq $0x20, %r14
andl %r9d, %r14d
xorl %ebx, %r14d
xorq 0x1800(%rcx,%r14,8), %r11
movzbl 0x5(%rsi,%rax), %ebx
movq %r8, %r14
shrq $0x28, %r14
andl %r9d, %r14d
xorl %ebx, %r14d
xorq 0x1000(%rcx,%r14,8), %r11
movzbl 0x6(%rsi,%rax), %ebx
movq %r8, %r14
shrq $0x30, %r14
andl %r9d, %r14d
xorl %ebx, %r14d
xorq 0x800(%rcx,%r14,8), %r11
movzbl 0x7(%rsi,%rax), %ebx
shrq $0x38, %r8
xorl %ebx, %r8d
xorq (%rcx,%r8,8), %r11
movq %r11, (%rdi)
addl $-0x8, %r10d
addq $0x8, %rax
movq %r11, %r8
jmp 0xa6c5a
movl %edx, %edx
cmpl %eax, %edx
je 0xa6d59
movzbl %r8b, %r9d
shrq $0x8, %r8
movzbl (%rsi,%rax), %r10d
xorl %r9d, %r10d
xorq (%rcx,%r10,8), %r8
movq %r8, (%rdi)
incq %rax
jmp 0xa6d39
movb $0x1, %al
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x63b3a
movq 0x20(%r14), %rax
testq %rax, %rax
je 0xa75d2
movq (%rax), %rax
jmp 0xa75d4
xorl %eax, %eax
movslq 0x28(%r14), %rdi
addq %rax, %rdi
movslq %ebp, %rdx
subq %rdx, %rdi
movq %r15, %rsi
callq 0x562f0
xorl %r15d, %r15d
leaq 0x3f(%r15), %rdx
movslq 0x28(%r14), %rax
movq 0x20(%r14), %rcx
cmpq %rax, %rdx
jge 0xa761a
testq %rcx, %rcx
je 0xa7607
movq (%rcx), %rsi
jmp 0xa7609
xorl %esi, %esi
addq %r15, %rsi
movq %r14, %rdi
callq 0x57840
addq $0x40, %r15
jmp 0xa75ec
testq %rcx, %rcx
je 0xa7624
movq (%rcx), %rdi
jmp 0xa7626
xorl %edi, %edi
movq %rax, %rcx
addq %rdi, %rcx
pushq $0x40
popq %rbp
cltd
idivl %ebp
movslq %edx, %rax
negl %edx
movslq %edx, %rsi
addq %rcx, %rsi
movq %rax, %rdx
callq 0x562f0
movl 0x28(%r14), %eax
cltd
idivl %ebp
movq %rbx, %rdi
movl %edx, %esi
callq 0x63b3a
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x577a0
movq %rax, %r15
movq 0x20(%r14), %rax
testq %rax, %rax
je 0xa76df
movq (%rax), %rsi
jmp 0xa76e1
xorl %esi, %esi
movq %r15, %rdi
movq %r12, %rdx
callq 0x562f0
addq %r15, %r12
movslq 0xc(%rsp), %rdx
leaq 0x5a955(%rip), %rsi     # 0x102050
movq %r12, %rdi
movq %rdx, %r12
callq 0x562f0
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 0x57840
cmpl $0x39, %r12d
jl 0xa776f
movq %r15, %rsi
addq $0x40, %rsi
movq %r14, %rdi
callq 0x57840
movq %r15, %rdi
callq 0x572d0
xorl %r13d, %r13d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5a180
leaq 0x10(%rsp), %r15
leaq 0x20(%rsp), %r12
pushq $0x8
popq %rbp
cmpq $0x4, %r13
je 0xa77d2
movl (%r14,%r13,4), %esi
bswapl %esi
movq %r15, %rdi
callq 0x5a3d0
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x589c0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x573e0
movq %r12, %rdi
callq 0x5a588
movq %r15, %rdi
callq 0x5a0b0
incq %r13
jmp 0xa7791
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xa7805
movq %rax, %r14
jmp 0xa77fb
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x5a588
leaq 0x10(%rsp), %rdi
callq 0x5a0b0
movq %rbx, %rdi
callq 0x5a588
movq %r14, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/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 $0xc8, %rsp
xorl %eax, %eax
cmpq $0x10, %rax
je 0xa7919
movl (%rsi,%rax,4), %ecx
bswapl %ecx
movl %ecx, -0x80(%rsp,%rax,4)
incq %rax
jmp 0xa7905
movabsq $0x10, %rax
cmpq $0x50, %rax
je 0xa7950
movl -0xa0(%rsp,%rax,4), %ecx
xorl -0x8c(%rsp,%rax,4), %ecx
xorl -0xb8(%rsp,%rax,4), %ecx
xorl -0xc0(%rsp,%rax,4), %ecx
roll %ecx
movl %ecx, -0x80(%rsp,%rax,4)
incq %rax
jmp 0xa7923
movl (%rdi), %r8d
movl 0x4(%rdi), %esi
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %ecx
movl 0x10(%rdi), %eax
xorl %ebx, %ebx
movl %r8d, %r15d
movl %esi, %r14d
movl %edx, %r11d
movl %ecx, %r10d
movl %eax, %r9d
movl %r9d, %ebp
movl %r10d, %r9d
movl %r11d, %r10d
movl %r14d, %r11d
movl %r15d, %r14d
cmpq $0x50, %rbx
je 0xa7a0c
cmpq $0x13, %rbx
ja 0xa79a3
movl %r10d, %r15d
xorl %r9d, %r15d
andl %r11d, %r15d
xorl %r9d, %r15d
movl $0x5a827999, %r12d      # imm = 0x5A827999
jmp 0xa79e9
cmpq $0x27, %rbx
ja 0xa79ba
movl %r10d, %r15d
xorl %r11d, %r15d
xorl %r9d, %r15d
movl $0x6ed9eba1, %r12d      # imm = 0x6ED9EBA1
jmp 0xa79e9
cmpq $0x3b, %rbx
ja 0xa79da
movl %r9d, %r12d
orl %r10d, %r12d
andl %r11d, %r12d
movl %r9d, %r15d
andl %r10d, %r15d
orl %r12d, %r15d
movl $0x8f1bbcdc, %r12d      # imm = 0x8F1BBCDC
jmp 0xa79e9
movl %r10d, %r15d
xorl %r11d, %r15d
xorl %r9d, %r15d
movl $0xca62c1d6, %r12d      # imm = 0xCA62C1D6
movl %r14d, %r13d
roll $0x5, %r13d
addl %r13d, %ebp
addl %r15d, %ebp
addl %r12d, %ebp
addl -0x80(%rsp,%rbx,4), %ebp
roll $0x1e, %r11d
incq %rbx
movl %ebp, %r15d
jmp 0xa7970
addl %r8d, %r14d
movl %r14d, (%rdi)
addl %esi, %r11d
movl %r11d, 0x4(%rdi)
addl %edx, %r10d
movl %r10d, 0x8(%rdi)
addl %ecx, %r9d
movl %r9d, 0xc(%rdi)
addl %eax, %ebp
movl %ebp, 0x10(%rdi)
addq $0x40, 0x18(%rdi)
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/misc/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 0x577a0
movq %rax, %r15
movq 0x28(%r14), %rax
testq %rax, %rax
je 0xa7b77
movq (%rax), %rsi
jmp 0xa7b79
xorl %esi, %esi
shlq $0x3, %r13
movq %r15, %rdi
movq %r12, %rdx
callq 0x562f0
addq %r15, %r12
movslq 0xc(%rsp), %rdx
leaq 0x5a4f9(%rip), %rsi     # 0x102090
movq %r12, %rdi
callq 0x562f0
movl %ebp, %eax
addq %r15, %rax
pushq $0x38
popq %rcx
cmpq $-0x8, %rcx
je 0xa7bbe
movq %r13, %rdx
shrq %cl, %rdx
movb %dl, (%rax)
addq $-0x8, %rcx
incq %rax
jmp 0xa7ba7
movq %r14, %rdi
movq %r15, %rsi
callq 0x57b50
cmpl $0x38, 0xc(%rsp)
jle 0xa7bdf
movq %r15, %rsi
addq $0x40, %rsi
movq %r14, %rdi
callq 0x57b50
movq %r15, %rdi
callq 0x572d0
xorl %r13d, %r13d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5a180
leaq 0x10(%rsp), %r15
leaq 0x20(%rsp), %r12
pushq $0x8
popq %rbp
cmpq $0x5, %r13
je 0xa7c40
movl (%r14,%r13,4), %esi
movq %r15, %rdi
callq 0x5a3d0
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x589c0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x573e0
movq %r12, %rdi
callq 0x5a588
movq %r15, %rdi
callq 0x5a0b0
incq %r13
jmp 0xa7c01
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xa7c73
movq %rax, %r14
jmp 0xa7c69
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x5a588
leaq 0x10(%rsp), %rdi
callq 0x5a0b0
movq %rbx, %rdi
callq 0x5a588
movq %r14, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x573a0
movq 0xb93c1(%rip), %rax     # 0x161570
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0xd0(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x5a180
leaq 0xf0(%rbx), %r15
movq %r15, %rdi
xorl %esi, %esi
movq %r14, 0x10(%rsp)
callq 0x5a180
leaq 0x108(%rbx), %r12
movq %r12, %rdi
xorl %esi, %esi
movq %r15, 0x8(%rsp)
callq 0x5a180
leaq 0x120(%rbx), %r13
movq %r13, %rdi
callq 0xa9d06
leaq 0x178(%rbx), %rbp
movq %rbp, %rdi
callq 0xa9d06
leaq 0xadd58(%rip), %rax     # 0x155f70
movq %rax, 0x1d0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x1d8(%rbx)
leaq 0x1e8(%rbx), %r14
movq %r14, %rdi
callq 0xa9d06
leaq 0x240(%rbx), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x5a180
leaq 0x270(%rbx), %rdi
xorl %esi, %esi
callq 0x5a180
andw $0x0, 0xc8(%rbx)
andw $0x0, 0xec(%rbx)
andl $0x0, 0xe8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x258(%rbx)
andq $0x0, 0x268(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, (%rsp)
movq %r15, %rdi
callq 0x5a588
jmp 0xa82a1
movq %rax, (%rsp)
movq %r14, %rdi
callq 0xa9d1c
jmp 0xa82af
movq %rax, (%rsp)
leaq 0x1d0(%rbx), %rdi
callq 0x62d46
movq %rbp, %rdi
callq 0xa9d1c
jmp 0xa82c9
movq %rax, (%rsp)
movq %r13, %rdi
callq 0xa9d1c
jmp 0xa82d7
movq %rax, (%rsp)
movq %r12, %rdi
callq 0x5a588
movq 0x8(%rsp), %rdi
callq 0x5a588
movq 0x10(%rsp), %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x56b00
movq (%rsp), %rdi
callq 0x58260
movq %rax, (%rsp)
jmp 0xa82df
movq %rax, (%rsp)
jmp 0xa82e9
movq %rax, (%rsp)
jmp 0xa82f3
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0x582a0
movq %r12, %rdi
movq %r15, %rsi
callq 0x56630
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x56630
addq $0x120, %rbx            # imm = 0x120
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xaa07e
movq %rsp, %rdi
callq 0x5a4e0
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5a4e0
movq %rbx, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/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 0x5a180
movq %rsp, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x57940
movq %rsp, %rdi
callq 0x580a0
movl %eax, %ebp
movq %rsp, %rdi
callq 0x5a500
leaq 0x38(%rsp), %rdi
callq 0x5a588
testb %bpl, %bpl
je 0xa85c0
movq %rsp, %r12
movq %r12, %rdi
callq 0x582a0
movq %r12, %rdi
movq %r15, %rsi
callq 0x56630
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x56630
movq %rsp, %rsi
movb $0x1, 0x30(%rsi)
addq $0x178, %rbx            # imm = 0x178
movq %rbx, %rdi
callq 0xaa07e
movq %rsp, %rdi
callq 0x5a4e0
xorl %eax, %eax
jmp 0xa85c3
pushq $-0x1
popq %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5a500
jmp 0xa85e0
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x5a588
jmp 0xa85f7
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5a4e0
movq %rbx, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x56630
movl %ebp, 0xe8(%rbx)
cmpw $0x0, 0xec(%rbx)
jne 0xa8649
movw $0x1, 0xec(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5a180
movq %r14, %r15
leaq 0x178(%r14), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %r13
cmpl 0x180(%r15), %ebp
jge 0xa96a3
movq 0x8(%rsp), %rdi
movl %ebp, %esi
callq 0xaa2ae
movq %rax, %r12
testl %ebp, %ebp
je 0xa965d
movq %r13, %rdi
leaq 0x58c55(%rip), %rsi     # 0x10229a
callq 0x58c40
movq %rbx, %rdi
movq %r13, %rsi
callq 0x573e0
movq %r13, %rdi
callq 0x5a588
movq %rbx, %rdi
movq %r12, %rsi
callq 0x573e0
movq %rax, %r14
movq %r13, %rdi
leaq 0x58b98(%rip), %rsi     # 0x10220d
callq 0x58c40
movq %r14, %rdi
movq %r13, %rsi
callq 0x573e0
addq $0x18, %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0x573e0
movq %r13, %rdi
callq 0x5a588
incl %ebp
jmp 0xa961f
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa96c0
jmp 0xa96bb
jmp 0xa96bb
movq %rax, %r14
jmp 0xa96cd
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x5a588
movq %r14, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/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 0x95fc6
testb %al, %al
je 0xa9a12
xorl %ebx, %ebx
jmp 0xa9a28
movq 0x258(%r12), %rdi
imulq %r15, %rbx
movq %r14, %rsi
movl %ebx, %edx
callq 0x56bd0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb78a1(%rip), %r14     # 0x161c00
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq 0xb72c9(%rip), %rbx     # 0x161638
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq (%r14), %rdi
testq %rdi, %rdi
je 0xaa386
movq (%rdi), %rax
callq *0x8(%rax)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xaa394
movq (%rdi), %rax
callq *0x8(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xaa41a
movq %rsi, %rbx
movq 0xb7847(%rip), %r15     # 0x161c00
movq (%r15), %r14
testq %r14, %r14
jne 0xaa3d7
pushq $0x58
popq %rdi
callq 0x56700
movq %rax, %r14
movq %rax, %rdi
callq 0xaa8ea
movq %r14, (%r15)
movq 0xb725a(%rip), %r12     # 0x161638
cmpq $0x0, (%r12)
jne 0xaa3ff
pushq $0x58
popq %rdi
callq 0x56700
movq %rax, %r14
movq %rax, %rdi
callq 0x64972
movq %r14, (%r12)
movq (%r15), %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x5c03a
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x64dee
xorl %eax, %eax
jmp 0xaa41d
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xaa42b
movq %rax, %rbx
pushq $0x58
popq %rsi
movq %r14, %rdi
callq 0x564c0
movq %rbx, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x5a400
movl %eax, %ebp
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, %ebx
movl %ebp, %edi
callq 0x58740
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movl %edi, %eax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divl %ecx
leaq 0x18(%rsp), %rbx
movq %rax, (%rbx)
imull $0xf4240, %edx, %eax    # imm = 0xF4240
leaq 0x8(%rsp), %r14
movq %rax, 0x20(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x59ac0
cmpl $-0x1, %eax
jne 0xac29d
callq 0x59780
cmpl $0x4, (%rax)
jne 0xac29d
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rsp)
jmp 0xac26d
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x5a180
leaq 0xb2d90(%rip), %rbx     # 0x15f170
leaq 0x20(%rsp), %r15
leaq 0x50(%rsp), %r13
leaq 0x38(%rsp), %r12
testl %r14d, %r14d
je 0xac422
cmpl $0xc, %r14d
je 0xac4a4
movq %r15, %rdi
leaq 0x5633e(%rip), %rsi     # 0x102746
callq 0x58c40
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x573e0
movq %r15, %rdi
callq 0x5a588
movq (%rbx), %rsi
movq %r15, %rdi
callq 0x58c40
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x573e0
movq %rax, %rbp
movq %r13, %rdi
leaq 0x56304(%rip), %rsi     # 0x10274b
callq 0x58c40
movq %rbp, %rdi
movq %r13, %rsi
callq 0x573e0
movq %rax, %rdi
movq (%rsp), %rsi
callq 0x573e0
movq %rax, %rbp
movq %r12, %rdi
leaq 0x562dc(%rip), %rsi     # 0x10274c
callq 0x58c40
movq %rbp, %rdi
movq %r12, %rsi
callq 0x573e0
movq %r12, %rdi
callq 0x5a588
movq %r13, %rdi
callq 0x5a588
movq %r15, %rdi
callq 0x5a588
incl %r14d
addq $0x8, %rbx
jmp 0xac3ef
leaq 0x8(%rsp), %rdi
callq 0x598d0
movq %rax, %rbx
callq 0x596a0
testl %eax, %eax
je 0xac4d5
leaq 0x8(%rsp), %rdi
callq 0x5a588
movb $0x1, %al
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x55fd9(%rip), %rdi     # 0x1024b5
leaq 0x55fd7(%rip), %rsi     # 0x1024ba
leaq 0x55fd3(%rip), %rdx     # 0x1024bd
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x5a3f0
xorl %edi, %edi
callq 0x58310
jmp 0xac51c
jmp 0xac51c
jmp 0xac517
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x5a588
jmp 0xac524
jmp 0xac521
jmp 0xac517
movq %rax, %rbx
jmp 0xac52e
movq %rax, %rbx
jmp 0xac538
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x5a588
leaq 0x20(%rsp), %rdi
callq 0x5a588
leaq 0x8(%rsp), %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/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 0xbfc95(%rip), %al      # 0x16c1f0
testb %al, %al
je 0xac61d
leaq 0xbfc6e(%rip), %rdi     # 0x16c1d8
xorl %esi, %esi
callq 0x57d40
testb %al, %al
jne 0xac602
callq 0x563a0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x58c40
leaq 0xbfc43(%rip), %rdi     # 0x16c1d8
movq %r14, %rsi
callq 0x59e50
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x5a588
testb %bpl, %bpl
jne 0xac5dc
callq 0x563a0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x58c40
leaq 0xbfc0e(%rip), %rdi     # 0x16c1d8
movq %r14, %rsi
callq 0x573e0
leaq 0x8(%rsp), %rdi
callq 0x5a588
callq 0x563a0
leaq 0xbfbf0(%rip), %rdi     # 0x16c1d8
movq %rax, %rsi
callq 0x59180
testb %al, %al
je 0xac602
leaq 0xbfbdd(%rip), %rdi     # 0x16c1d8
xorl %esi, %esi
callq 0x58c30
leaq 0xbfbcf(%rip), %rsi     # 0x16c1d8
movq %rbx, %rdi
callq 0x58280
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xbfbcc(%rip), %rdi     # 0x16c1f0
callq 0x57210
testl %eax, %eax
je 0xac563
leaq 0xbfba0(%rip), %rdi     # 0x16c1d8
xorl %esi, %esi
callq 0x5a180
movq 0xb58ea(%rip), %rdi     # 0x161f30
leaq 0xbfb8b(%rip), %rsi     # 0x16c1d8
leaq 0xb7bec(%rip), %rdx     # 0x164240
callq 0x590a0
leaq 0xbfb90(%rip), %rdi     # 0x16c1f0
callq 0x57cf0
jmp 0xac563
movq %rax, %rbx
leaq 0xbfb7c(%rip), %rdi     # 0x16c1f0
callq 0x57520
jmp 0xac68a
jmp 0xac67d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/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 0xbfb6d(%rip), %al      # 0x16c210
testb %al, %al
je 0xac765
leaq 0xbfb46(%rip), %rdi     # 0x16c1f8
xorl %esi, %esi
callq 0x57d40
testb %al, %al
jne 0xac74a
callq 0x563a0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x58c40
leaq 0xbfb1b(%rip), %rdi     # 0x16c1f8
movq %r14, %rsi
callq 0x59e50
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x5a588
testb %bpl, %bpl
jne 0xac724
callq 0x563a0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x58c40
leaq 0xbfae6(%rip), %rdi     # 0x16c1f8
movq %r14, %rsi
callq 0x573e0
leaq 0x8(%rsp), %rdi
callq 0x5a588
callq 0x563a0
leaq 0xbfac8(%rip), %rdi     # 0x16c1f8
movq %rax, %rsi
callq 0x59180
testb %al, %al
je 0xac74a
leaq 0xbfab5(%rip), %rdi     # 0x16c1f8
xorl %esi, %esi
callq 0x58c30
leaq 0xbfaa7(%rip), %rsi     # 0x16c1f8
movq %rbx, %rdi
callq 0x58280
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xbfaa4(%rip), %rdi     # 0x16c210
callq 0x57210
testl %eax, %eax
je 0xac6ab
leaq 0xbfa78(%rip), %rdi     # 0x16c1f8
xorl %esi, %esi
callq 0x5a180
movq 0xb57a2(%rip), %rdi     # 0x161f30
leaq 0xbfa63(%rip), %rsi     # 0x16c1f8
leaq 0xb7aa4(%rip), %rdx     # 0x164240
callq 0x590a0
leaq 0xbfa68(%rip), %rdi     # 0x16c210
callq 0x57cf0
jmp 0xac6ab
movq %rax, %rbx
leaq 0xbfa54(%rip), %rdi     # 0x16c210
callq 0x57520
jmp 0xac7d2
jmp 0xac7c5
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/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 0xbedd5(%rip), %al      # 0x16c330
testb %al, %al
je 0xad684
leaq 0xbedae(%rip), %rdi     # 0x16c318
xorl %esi, %esi
callq 0x57d40
testb %al, %al
je 0xad589
leaq 0xbed9c(%rip), %rsi     # 0x16c318
movq %rbx, %rdi
callq 0x58280
jmp 0xad67a
leaq 0x54c36(%rip), %rsi     # 0x1021c6
leaq 0x20(%rsp), %rdi
callq 0x5a450
leaq 0x5524a(%rip), %rdi     # 0x1027eb
callq 0x58950
leaq 0xbed6b(%rip), %rdi     # 0x16c318
movq %rax, %rsi
callq 0x57010
leaq 0xbed5c(%rip), %rdi     # 0x16c318
xorl %esi, %esi
callq 0x56280
testb %al, %al
je 0xad5da
leaq 0xbed4a(%rip), %rdi     # 0x16c318
leaq 0x5521d(%rip), %rsi     # 0x1027f2
callq 0x57010
callq 0x563a0
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x58c40
leaq 0xbed25(%rip), %rdi     # 0x16c318
leaq 0x8(%rsp), %rsi
callq 0x59e50
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x5a588
testb %bpl, %bpl
jne 0xad63b
callq 0x563a0
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x58c40
leaq 0xbecf1(%rip), %rdi     # 0x16c318
leaq 0x8(%rsp), %rsi
callq 0x573e0
leaq 0x8(%rsp), %rdi
callq 0x5a588
callq 0x563a0
leaq 0xbecd1(%rip), %rdi     # 0x16c318
movq %rax, %rsi
callq 0x59180
testb %al, %al
je 0xad661
leaq 0xbecbe(%rip), %rdi     # 0x16c318
xorl %esi, %esi
callq 0x58c30
leaq 0xbecb0(%rip), %rsi     # 0x16c318
movq %rbx, %rdi
callq 0x58280
leaq 0x20(%rsp), %rdi
callq 0x57b90
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
leaq 0xbeca5(%rip), %rdi     # 0x16c330
callq 0x57210
testl %eax, %eax
je 0xad563
leaq 0xbec79(%rip), %rdi     # 0x16c318
xorl %esi, %esi
callq 0x5a180
movq 0xb4883(%rip), %rdi     # 0x161f30
leaq 0xbec64(%rip), %rsi     # 0x16c318
leaq 0xb6b85(%rip), %rdx     # 0x164240
callq 0x590a0
leaq 0xbec69(%rip), %rdi     # 0x16c330
callq 0x57cf0
jmp 0xad563
movq %rax, %rbx
leaq 0xbec55(%rip), %rdi     # 0x16c330
callq 0x57520
jmp 0xad704
jmp 0xad6e6
jmp 0xad6f7
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5a588
jmp 0xad6fa
jmp 0xad6f7
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x57b90
movq %rbx, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/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 0x58020
movq 0xb4570(%rip), %rax     # 0x161c90
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x48(%rbx), %r14
andq $0x0, 0x50(%rbx)
leaq 0xaa031(%rip), %rax     # 0x157768
movq %rax, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rbx)
movq %rbx, %rdi
callq 0xad946
movq %rax, 0x38(%rbx)
movq 0xb416b(%rip), %rax     # 0x1618c0
movzwl (%rax), %eax
movw %ax, 0x20(%rbx)
andl $0x0, 0x40(%rbx)
andw $0x0, 0x44(%rbx)
movq %rbx, 0x50(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x700e0
movq %rbx, %rdi
callq 0x56d00
movq %r15, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/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 0xad805
pushq $-0x1
popq %rax
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_O2/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 0xb3dd6(%rip), %r14     # 0x1617d8
movq (%r14), %rdi
testq %rdi, %rdi
je 0xada20
callq 0x56900
movq (%r14), %rdi
movb (%rbx), %bl
testq %rdi, %rdi
je 0xada22
callq 0x593e0
jmp 0xada22
movb (%rbx), %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb3d9b(%rip), %r15     # 0x1617d8
movq (%r15), %rdi
callq 0x56900
movb %bl, (%r14)
movb (%r14), %bl
movq (%r15), %rdi
callq 0x593e0
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0xb3d6e(%rip), %r14     # 0x1617d8
movq (%r14), %rdi
testq %rdi, %rdi
je 0xada89
callq 0x56900
movq (%r14), %rdi
movzwl (%rbx), %ebx
testq %rdi, %rdi
je 0xada8c
callq 0x593e0
jmp 0xada8c
movzwl (%rbx), %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/threads/access.cpp
// Function: smooth::Threads::Access::Increment(short volatile&)
S::Short S::Threads::Access::Increment(volatile Short &value)
{
	mutex->Lock();

	Short	 result = ++value;

	mutex->Release();

	return result;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xb3d34(%rip), %r14     # 0x1617d8
movq (%r14), %rdi
callq 0x56900
movzwl (%rbx), %ebp
incl %ebp
movw %bp, (%rbx)
movq (%r14), %rdi
callq 0x593e0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/threads/access.cpp
// Function: smooth::Threads::Access::Decrement(short volatile&)
S::Short S::Threads::Access::Decrement(volatile Short &value)
{
	mutex->Lock();

	Short	 result = --value;

	mutex->Release();

	return result;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xb3d06(%rip), %r14     # 0x1617d8
movq (%r14), %rdi
callq 0x56900
movzwl (%rbx), %ebp
decl %ebp
movw %bp, (%rbx)
movq (%r14), %rdi
callq 0x593e0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/threads/access.cpp
// Function: smooth::Threads::Access::Set(short volatile&, short)
S::Short S::Threads::Access::Set(volatile Short &value, Short n)
{
	mutex->Lock();

	Short	 result = value = n;

	mutex->Release();

	return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0xb3cd5(%rip), %r15     # 0x1617d8
movq (%r15), %rdi
callq 0x56900
movw %bx, (%r14)
movzwl (%r14), %ebx
movq (%r15), %rdi
callq 0x593e0
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/threads/access.cpp
// Function: smooth::Threads::Access::Value(int volatile&)
S::Int S::Threads::Access::Value(volatile Int &value)
{
	mutex->Lock();

	Int	 result = value;

	mutex->Release();

	return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xb3ca6(%rip), %r14     # 0x1617d8
movq (%r14), %rdi
callq 0x56900
movl (%rbx), %ebx
movq (%r14), %rdi
callq 0x593e0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/threads/access.cpp
// Function: smooth::Threads::Access::Increment(int volatile&)
S::Int S::Threads::Access::Increment(volatile Int &value)
{
	mutex->Lock();

	Int	 result = ++value;

	mutex->Release();

	return result;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xb3c7c(%rip), %r14     # 0x1617d8
movq (%r14), %rdi
callq 0x56900
movl (%rbx), %ebp
incl %ebp
movl %ebp, (%rbx)
movq (%r14), %rdi
callq 0x593e0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/threads/access.cpp
// Function: smooth::Threads::Access::Decrement(int volatile&)
S::Int S::Threads::Access::Decrement(volatile Int &value)
{
	mutex->Lock();

	Int	 result = --value;

	mutex->Release();

	return result;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xb3c50(%rip), %r14     # 0x1617d8
movq (%r14), %rdi
callq 0x56900
movl (%rbx), %ebp
decl %ebp
movl %ebp, (%rbx)
movq (%r14), %rdi
callq 0x593e0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/threads/access.cpp
// Function: smooth::Threads::Access::Set(int volatile&, int)
S::Int S::Threads::Access::Set(volatile Int &value, Int n)
{
	mutex->Lock();

	Int	 result = value = n;

	mutex->Release();

	return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0xb3c21(%rip), %r15     # 0x1617d8
movq (%r15), %rdi
callq 0x56900
movl %ebx, (%r14)
movl (%r14), %ebx
movq (%r15), %rdi
callq 0x593e0
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)