LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/string.cpp
// Function: string::icompare3(cstring, cstring)
int string::icompare3(cstring a, cstring b)
{
	int ret_i = a.length() - b.length();
	
	size_t cmplen = min(a.length(), b.length());
	const uint8_t* ab = a.bytes().ptr();
	const uint8_t* bb = b.bytes().ptr();
	for (size_t n=0; n<cmplen; n++)
	{
		if (ab[n] != bb[n])
		{
			if (ret_i == 0) ret_i = ab[n] - bb[n];
			
			uint8_t ac = toupper(ab[n]);
			uint8_t bc = toupper(bb[n]);
			if (ac != bc) return ac - bc;
		}
	}
	
	return ret_i;
}

// Assembly:
pushq %rbx
leaq -0x10(%rsp), %rax
movq %rdi, (%rax)
leaq -0x20(%rsp), %r8
movq %rdx, (%r8)
movq %rcx, 0x8(%r8)
movq %rsi, %r9
shrq $0x38, %r9
xorl $0xf, %r9d
movq %rcx, %r10
shrq $0x38, %r10
xorl $0xf, %r10d
testq %rcx, %rcx
cmovnsl %r10d, %ecx
cmovnsq %r8, %rdx
movq %rsi, 0x8(%rax)
testq %rsi, %rsi
cmovnsl %r9d, %esi
cmovnsq %rax, %rdi
movl %ecx, %eax
subl %esi, %eax
cmovbl %ecx, %esi
negl %eax
testl %esi, %esi
je 0x1a6c4
xorl %ecx, %ecx
leaq 0x156e1(%rip), %r8      # 0x2fd50
movzbl (%rdi,%rcx), %r10d
movzbl (%rdx,%rcx), %r9d
cmpb %r9b, %r10b
je 0x1a6b0
movl %r10d, %r11d
movl %r10d, %ebx
subl %r9d, %ebx
testl %eax, %eax
cmovel %ebx, %eax
movb (%r11,%r8), %r11b
notb %r11b
orb $-0x21, %r11b
andb %r10b, %r11b
movl %r9d, %r10d
movb (%r10,%r8), %r10b
notb %r10b
orb $-0x21, %r10b
andb %r9b, %r10b
cmpb %r10b, %r11b
jne 0x1a6ba
incq %rcx
cmpq %rcx, %rsi
jne 0x1a66f
jmp 0x1a6c4
movzbl %r10b, %ecx
movzbl %r11b, %eax
subl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/string.cpp
// Function: cstring::upper() const
string cstring::upper() const
{
	string ret = *this;
	bytesw by = ret.bytes();
	for (size_t i=0;i<by.size();i++) by[i] = toupper(by[i]);
	return ret;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movups (%rsi), %xmm0
movq %rsp, %rsi
movups %xmm0, (%rsi)
callq 0x19592
movzbl 0xf(%rbx), %eax
testb %al, %al
jns 0x1a8f4
movl 0x8(%rbx), %eax
movq (%rbx), %rcx
jmp 0x1a8fb
xorq $0xf, %rax
movq %rbx, %rcx
testq %rax, %rax
je 0x1a927
xorl %edx, %edx
leaq 0x15447(%rip), %rsi     # 0x2fd50
movzbl (%rcx,%rdx), %edi
movb (%rdi,%rsi), %r8b
notb %r8b
orb $-0x21, %r8b
andb %dil, %r8b
movb %r8b, (%rcx,%rdx)
incq %rdx
cmpq %rdx, %rax
jne 0x1a909
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/string.cpp
// Function: cstring::lower() const
string cstring::lower() const
{
	string ret = *this;
	bytesw by = ret.bytes();
	for (size_t i=0;i<by.size();i++) by[i] = tolower(by[i]);
	return ret;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movups (%rsi), %xmm0
movq %rsp, %rsi
movups %xmm0, (%rsi)
callq 0x19592
movzbl 0xf(%rbx), %eax
testb %al, %al
jns 0x1a956
movl 0x8(%rbx), %eax
movq (%rbx), %rcx
jmp 0x1a95d
xorq $0xf, %rax
movq %rbx, %rcx
testq %rax, %rax
je 0x1a986
xorl %edx, %edx
leaq 0x153e5(%rip), %rsi     # 0x2fd50
movzbl (%rcx,%rdx), %edi
movb (%rdi,%rsi), %r8b
andb $0x20, %r8b
orb %dil, %r8b
movb %r8b, (%rcx,%rdx)
incq %rdx
cmpq %rdx, %rax
jne 0x1a96b
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/string.cpp
// Function: cstring::matches_glob(cstring, bool) const
bool cstring::matches_glob(cstring pat, bool case_insensitive) const
{
	const uint8_t * s = ptr();
	const uint8_t * p = pat.ptr();
	const uint8_t * se = s + length();
	const uint8_t * pe = p + pat.length();
	
	const uint8_t * sp = se; // weirdo trick to not need a special case for the part before first asterisk
	const uint8_t * pp = p;
	if (p == pe)
		return (s == se);
	while (s < se)
	{
		if (p < pe && *p == '*')
		{
			p++;
			if (p == pe) return true;
			pp = p;
			sp = s+1;
		}
		else if (p < pe && s < se && (*p == *s || *p == '?' || (case_insensitive && tolower(*p) == tolower(*s))))
		{
			p++;
			s++;
		}
		else
		{
			p = pp;
			s = sp;
			sp++;
		}
	}
	while (p < pe && *p == '*') p++;
	return (p == pe);
}

// Assembly:
pushq %rbp
pushq %rbx
leaq -0x10(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
movzbl 0xf(%rdi), %r9d
movq %rdx, %r10
shrq $0x38, %r10
movl %r9d, %r8d
xorl $0xf, %r8d
testb %r9b, %r9b
movq (%rdi), %r9
cmovsl 0x8(%rdi), %r8d
cmovnsq %rdi, %r9
xorl $0xf, %r10d
testq %rdx, %rdx
cmovnsq %rax, %rsi
cmovnsl %r10d, %edx
testl %r8d, %r8d
sete %al
testl %edx, %edx
je 0x1ad51
addq %rsi, %rdx
testl %r8d, %r8d
je 0x1ad39
addq %r9, %r8
leaq 0x15085(%rip), %rdi     # 0x2fd50
movq %r8, %r10
movq %rsi, %rax
cmpq %rdx, %rax
jae 0x1ad29
movzbl (%rax), %r11d
cmpq $0x2a, %r11
jne 0x1acf1
incq %rax
cmpq %rdx, %rax
je 0x1ad54
leaq 0x1(%r9), %r10
movq %rax, %rsi
jmp 0x1ad32
cmpq $0x3f, %r11
je 0x1ad21
movb (%r9), %bl
cmpb %bl, %r11b
je 0x1ad21
testb %cl, %cl
je 0x1ad29
movzbl %bl, %ebx
movb (%r11,%rdi), %bpl
andb $0x20, %bpl
orb %r11b, %bpl
movb (%rbx,%rdi), %r11b
andb $0x20, %r11b
orb %bl, %r11b
cmpb %r11b, %bpl
jne 0x1ad29
incq %rax
incq %r9
jmp 0x1ad32
movq %r10, %r9
incq %r10
movq %rsi, %rax
cmpq %r8, %r9
jb 0x1acd1
jmp 0x1ad46
movq %rsi, %rax
jmp 0x1ad46
cmpb $0x2a, (%rax)
jne 0x1ad4b
incq %rax
cmpq %rdx, %rax
jb 0x1ad3e
cmpq %rdx, %rax
sete %al
popq %rbx
popq %rbp
retq
movb $0x1, %al
jmp 0x1ad51
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/string.cpp
// Function: cstring::leftPad(unsigned long, unsigned char) const
string cstring::leftPad (size_t len, uint8_t ch) const {
	if (len >= length()) return *this;
	len -= length();
	
	array<uint8_t> pad;
	pad.resize(len);
	memset(pad.ptr(), ch, len);
	return cstring(pad) + *this;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movzbl 0xf(%rsi), %eax
testb %al, %al
js 0x1ad8b
xorq $0xf, %rax
cmpq %r12, %rax
jbe 0x1ae29
movzbl %al, %eax
jmp 0x1ad98
movl 0x8(%r14), %eax
cmpq %r12, %rax
jbe 0x1ae29
subq %rax, %r12
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r15
movaps %xmm0, (%r15)
movq %r15, %rdi
movq %r12, %rsi
callq 0xdea4
movq (%r15), %rdi
movzbl %bpl, %esi
movq %r12, %rdx
callq 0x3170
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
xorl %ecx, %ecx
callq 0x5990
movq (%r14), %r13
movq 0x8(%r14), %rbp
movups (%r12), %xmm0
movq %rsp, %r14
movups %xmm0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19592
movq %r13, (%r14)
movq %rbp, 0x8(%r14)
movq %rbp, %rax
shrq $0x38, %rax
xorq $0xf, %rax
testq %rbp, %rbp
movl %ebp, %edx
cmovnsq %rax, %rdx
cmovnsq %r14, %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1967e
movq (%r15), %rdi
callq 0x3430
jmp 0x1ae3b
movups (%r14), %xmm0
movq %rsp, %rsi
movups %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x19592
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/stringconv-float.cpp
// Function: string tostring_float<double>(double)
string tostring_float(T f)
{
	// to_chars is quite close to my desired output format
	static_assert(std::numeric_limits<T>::is_iec559);
	
	// can be replaced with if (isnan(f)) f = fabs(f); under libstdc++,
	// but it's implementation defined if the weird ones are nan or nan(123), or inf or infinity, so let's just hardcode them
	if (UNLIKELY(isnan(f))) return "nan";
	if (UNLIKELY(isinf(f))) return signbit(f) ? "-inf" : "inf";
	
	bool fixed = ((fabs(f) >= (T)0.0001 && fabs(f) < (T)10000000000000000.0) || f == 0);
	
	char buf[32]; // longest possible is 24, give it a little extra
	char* end;
	if (fixed)
	{
		auto ret = std::to_chars(buf, buf+sizeof(buf), f, std::chars_format::fixed);
		end = ret.ptr;
	}
	else
	{
		auto ret = std::to_chars(buf, buf+sizeof(buf), f, std::chars_format::scientific);
		end = ret.ptr;
		if (end[-2] == '0' && end[-4] == 'e') // can't underflow, shortest possible output in scientific is 1e+01
		{
			end[-2] = end[-1];
			end--;
		}
	}
	return bytesr((uint8_t*)buf, end-buf);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
ucomisd %xmm0, %xmm0
jp 0x1af2c
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
je 0x1af36
movapd 0x15011(%rip), %xmm1    # 0x2fec0
andpd %xmm0, %xmm1
ucomisd 0x14fbd(%rip), %xmm1    # 0x2fe78
jb 0x1aecb
movsd 0x14fab(%rip), %xmm2    # 0x2fe70
ucomisd %xmm1, %xmm2
ja 0x1aed7
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1af03
jp 0x1af03
leaq 0x20(%rsp), %rsi
movq %rsp, %rdi
movl $0x2, %edx
callq 0x31b0
movq %rsp, %rsi
subq %rsi, %rax
movq %rbx, %rdi
movq %rax, %rdx
callq 0x194bc
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
leaq 0x20(%rsp), %rsi
movq %rsp, %rdi
movl $0x1, %edx
callq 0x31b0
cmpb $0x30, -0x2(%rax)
jne 0x1aee9
cmpb $0x65, -0x4(%rax)
jne 0x1aee9
movb -0x1(%rax), %cl
movb %cl, -0x2(%rax)
decq %rax
jmp 0x1aee9
movq %rbx, %rdi
callq 0x4775
jmp 0x1aefa
movq %rbx, %rdi
callq 0x474b
jmp 0x1aefa
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/stringconv.cpp
// Function: tostring_ptr(char*, unsigned long long, unsigned long)
size_t tostring_ptr(char* buf, unsigned long long val, size_t len)
{
	char* iter = buf+len;
	while (iter > buf)
	{
		*--iter = '0'+val%10;
		val /= 10;
	}
	return len;
}

// Assembly:
movq %rdx, %rcx
testq %rdx, %rdx
jle 0x1b093
leaq (%rdi,%rcx), %r8
movabsq $-0x3333333333333333, %r9 # imm = 0xCCCCCCCCCCCCCCCD
movq %rsi, %rax
mulq %r9
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
subl %eax, %esi
orb $0x30, %sil
movb %sil, -0x1(%r8)
decq %r8
movq %rdx, %rsi
cmpq %rdi, %r8
ja 0x1b06e
movq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/stringconv.cpp
// Function: tostringhex(arrayview<unsigned char>)
string tostringhex(arrayview<uint8_t> val)
{
	string ret;
	arrayvieww<uint8_t> retb = ret.construct(val.size()*2);
	for (size_t i=0;i<val.size();i++)
	{
		retb[i*2+0] = hexdigits[val[i]>>4];
		retb[i*2+1] = hexdigits[val[i]&15];
	}
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movb $0xf, 0xf(%rdi)
movb $0x0, (%rdi)
leaq (%rdx,%rdx), %rsi
callq 0x193c4
cmpb $0x0, 0xf(%r14)
movq %r14, %rax
jns 0x1b170
movq (%r14), %rax
testq %rbx, %rbx
je 0x1b1a7
xorl %ecx, %ecx
leaq 0x14da2(%rip), %rdx     # 0x2ff20
movzbl (%r15,%rcx), %esi
shrl $0x4, %esi
movb (%rsi,%rdx), %sil
movb %sil, (%rax,%rcx,2)
movzbl (%r15,%rcx), %esi
andl $0xf, %esi
movb (%rsi,%rdx), %sil
movb %sil, 0x1(%rax,%rcx,2)
incq %rcx
cmpq %rcx, %rbx
jne 0x1b17e
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/stringconv.cpp
// Function: tostringhex_ptr(char*, unsigned long long, unsigned long)
size_t tostringhex_ptr(char* buf, unsigned long long val, size_t len)
{
	char* iter = buf+len;
	while (iter > buf)
	{
		*--iter = hexdigits[val%16];
		val /= 16;
	}
	return len;
}

// Assembly:
movq %rdx, %rax
testq %rdx, %rdx
jle 0x1b1de
leaq (%rdi,%rax), %rcx
leaq 0x14d5d(%rip), %rdx     # 0x2ff20
movl %esi, %r8d
andl $0xf, %r8d
movb (%r8,%rdx), %r8b
movb %r8b, -0x1(%rcx)
decq %rcx
shrq $0x4, %rsi
cmpq %rdi, %rcx
ja 0x1b1c3
retq
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/stringconv.cpp
// Function: fromstring(cstring, bool&)
bool fromstring(cstring s, bool& out)
{
	if (s == "false" || s == "0")
	{
		out = false;
		return true;
	}
	
	if (s == "true" || s == "1")
	{
		out = true;
		return true;
	}
	
	out = false;
	return false;
}

// Assembly:
shrq $0x38, %rsi
cmpq $0xa, %rsi
jne 0x1b4dd
movabsq $0xffffffffff, %rax     # imm = 0xFFFFFFFFFF
andq %rdi, %rax
movabsq $0x65736c6166, %rcx     # imm = 0x65736C6166
cmpq %rcx, %rax
je 0x1b4ee
xorl %ecx, %ecx
jmp 0x1b50b
cmpl $0xe, %esi
sete %cl
cmpb $0x30, %dil
sete %al
testb %al, %cl
je 0x1b4f5
movb $0x1, %al
xorl %r8d, %r8d
jmp 0x1b519
xorq $0xb, %rsi
movl %edi, %eax
xorq $0x65757274, %rax       # imm = 0x65757274
movb $0x1, %r8b
orq %rsi, %rax
movb $0x1, %al
je 0x1b519
cmpb $0x31, %dil
sete %r8b
andb %cl, %r8b
movl %r8d, %eax
movb %r8b, (%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/stringconv.cpp
// Function: fromstringhex(cstring, arrayvieww<unsigned char>)
bool fromstringhex(cstring s, arrayvieww<uint8_t> val)
{
	if (val.size()*2 != s.length()) return false;
	bool ok = true;
	for (size_t i=0;i<val.size();i++)
	{
		ok &= fromstringhex(s.substr(i*2, i*2+2), val[i]);
	}
	return ok;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rdi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x8(%rdx), %rax
leaq (%rax,%rax), %rcx
movq %rsi, %rdx
shrq $0x38, %rdx
xorl $0xf, %edx
testq %rsi, %rsi
cmovsq %rsi, %rdx
movl %edx, %edx
cmpq %rdx, %rcx
jne 0x1b5d3
testq %rax, %rax
je 0x1b5d7
movb $0x1, %r13b
xorl %esi, %esi
movq %rsp, %r15
xorl %r14d, %r14d
leal 0x2(%rsi), %ebp
leaq 0x8(%rsp), %rdi
movl %ebp, %edx
callq 0x6b28
movq (%rbx), %r12
movq %rax, 0x18(%rsp)
movq %rdx, %rcx
shrq $0x38, %rcx
xorl $0xf, %ecx
testq %rdx, %rdx
leaq 0x18(%rsp), %rsi
cmovnsq %rsi, %rax
movq %rdx, 0x20(%rsp)
cmovsq %rdx, %rcx
movl %ecx, %esi
movq %rax, %rdi
movq %r15, %rdx
callq 0x4a6d
movl %eax, %ecx
movq (%rsp), %rax
movb %al, (%r12,%r14)
cmpq $0x100, %rax            # imm = 0x100
setb %al
andb %r13b, %al
andb %cl, %al
incq %r14
movl %ebp, %esi
movl %eax, %r13d
cmpq 0x8(%rbx), %r14
jb 0x1b568
jmp 0x1b5d9
xorl %eax, %eax
jmp 0x1b5d9
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/stringconv.cpp
// Function: string tostring_inner<unsigned long long>(unsigned long long)
string tostring_inner(T val)
{
	size_t len = tostring_len(val);
	string ret;
	char* ptr = (char*)ret.construct(len).ptr();
	tostring_ptr(ptr, val, len);
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rsi, %r15
orq $0x1, %r15
bsrq %r15, %rax
leal (%rax,%rax,8), %ecx
leal (%rax,%rcx,2), %ecx
shrl $0x6, %ecx
shrq %cl, %r15
movq %rdi, %r14
leaq 0x14856(%rip), %rax     # 0x2ff30
addq (%rax,%rcx,8), %r15
shrq $0x38, %r15
leaq 0x1(%r15), %rsi
movb $0xf, 0xf(%rdi)
movb $0x0, (%rdi)
callq 0x193c4
cmpb $0x0, 0xf(%r14)
movq %r14, %rcx
jns 0x1b6ff
movq (%r14), %rcx
leaq (%rcx,%r15), %rsi
incq %rsi
movabsq $-0x3333333333333333, %rdi # imm = 0xCCCCCCCCCCCCCCCD
movq %rbx, %rax
mulq %rdi
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
subl %eax, %ebx
orb $0x30, %bl
movb %bl, -0x1(%rsi)
decq %rsi
movq %rdx, %rbx
cmpq %rcx, %rsi
ja 0x1b710
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/stringconv.cpp
// Function: string tostringhex_inner<unsigned long long>(unsigned long long, unsigned long)
string tostringhex_inner(T val, size_t mindigits)
{
	uint8_t buf[16];
	uint8_t* bufend = buf+sizeof(buf);
	uint8_t* iter = bufend;
	do {
		*--iter = hexdigits[val%16];
		val /= 16;
	} while (val);
	while ((size_t)(bufend-iter) < mindigits) *--iter = '0';
	return string(bytesr(iter, bufend-iter));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rdi, %rbx
movl $0xf, %eax
leaq 0x10(%rsp), %r14
xorl %edx, %edx
leaq 0x147c2(%rip), %rcx     # 0x2ff20
movq %rsi, %rdi
movl %esi, %r8d
andl $0xf, %r8d
movb (%r8,%rcx), %r8b
movb %r8b, (%rsp,%rax)
shrq $0x4, %rdi
incq %rdx
decq %rax
cmpq $0xf, %rsi
movq %rdi, %rsi
ja 0x1b761
movq %r15, %rax
subq %rdx, %rax
jbe 0x1b7aa
movq %rsp, %r14
subq %r15, %r14
addq $0x10, %r14
movq %r14, %rdi
movl $0x30, %esi
movq %rax, %rdx
callq 0x3170
movq %r15, %rdx
jmp 0x1b7ad
subq %rdx, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x194bc
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/strtoken.cpp
// Function: strtoken(char const*, char const*, char)
bool strtoken(const char * haystack, const char * needle, char separator)
{
	//token lists are annoyingly complex to parse
	//I suspect 'people using fixed-size buffers, then extension list grows and app explodes'
	// isn't the only reason GL_EXTENSIONS string was deprecated from OpenGL
	size_t nlen = strlen(needle);
	
	while (true)
	{
		const char * found = strstr(haystack, needle);
		if (!found) break;
		
		if ((found==haystack || found[-1]==separator) && // ensure the match is the start of a word
				(found[nlen]==separator || found[nlen]=='\0')) // ensure the match is the end of a word
		{
			return true;
		}
		
		haystack = strchr(found, separator); // try again, could've found GL_foobar_limited when looking for GL_foobar
		if (!haystack) return false;
	}
	return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r12
movq %rsi, %rdi
callq 0x30f0
movq %rax, %r15
movq %r12, %rdi
movq %r14, %rsi
callq 0x30b0
testq %rax, %rax
je 0x1b81d
cmpq %r12, %rax
je 0x1b7fd
cmpb %bl, -0x1(%rax)
jne 0x1b80b
movb (%rax,%r15), %dl
movb $0x1, %cl
cmpb %bl, %dl
je 0x1b81f
testb %dl, %dl
je 0x1b81f
movq %rax, %rdi
movl %ebx, %esi
callq 0x30e0
movq %rax, %r12
testq %rax, %rax
jne 0x1b7e3
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/thread/pthread-thr.cpp
// Function: thread_create(function<void ()>&&, priority_t)
void thread_create(function<void()>&& start, priority_t pri)
{
	pthread_attr_t attr;
	if (pthread_attr_init(&attr) < 0) abort();
	
	sched_param sched;
	if (pthread_attr_getschedparam(&attr, &sched) >= 0)
	{
		static const int8_t prios[] = { 0, -10, 10, 19 };
		sched.sched_priority = prios[pri];
		pthread_attr_setschedparam(&attr, &sched);
	}
	
	thread_create_inner(std::move(start), &attr);
	pthread_attr_destroy(&attr);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3450
testl %eax, %eax
js 0x1bba6
leaq 0x10(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x3710
testl %eax, %eax
js 0x1bb4e
movl %ebp, %eax
leaq 0x1448f(%rip), %rcx     # 0x2ffc8
movsbl (%rax,%rcx), %eax
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x3160
movl $0x18, %edi
callq 0x1597c
movups (%rbx), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq $0x0, 0x10(%rbx)
leaq 0x8e(%rip), %rdx        # 0x1bc03
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %rax, %rcx
callq 0x36b0
testl %eax, %eax
jne 0x1bba6
movq 0x8(%rsp), %rdi
callq 0x3220
leaq 0x10(%rsp), %rdi
callq 0x3630
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
callq 0x3180
nop
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/zip.cpp
// Function: zip::getendofcdr(arrayview<unsigned char>)
zip::endofcdr* zip::getendofcdr(arrayview<uint8_t> data)
{
	//must be somewhere in zip::, they're private
	static_assert(sizeof(zip::locfhead)==30);
	static_assert(sizeof(zip::centdirrec)==46);
	static_assert(sizeof(zip::endofcdr)==22);
	
	for (size_t commentlen=0;commentlen<65536;commentlen++)
	{
		if (data.size() < sizeof(endofcdr)+commentlen) return nullptr;
		
		size_t trystart = data.size()-sizeof(endofcdr)-commentlen;
		endofcdr* ret = (endofcdr*)data.slice(trystart, sizeof(endofcdr)).ptr();
		if (ret->signature == ret->signature_expected)
		{
			if (ret->diskid_this != 0) return nullptr;
			return ret;
		}
	}
	
	return nullptr;
}

// Assembly:
cmpq $0x16, %rdx
jae 0x1bd19
xorl %eax, %eax
retq
leaq -0x16(%rdx), %rax
movl $0xffff, %ecx           # imm = 0xFFFF
cmpq %rcx, %rax
cmovbq %rax, %rcx
incq %rcx
addq %rsi, %rdx
addq $-0x16, %rdx
xorl %eax, %eax
cmpl $0x6054b50, (%rdx)      # imm = 0x6054B50
je 0x1bd46
decq %rdx
decq %rcx
jne 0x1bd35
retq
xorl %eax, %eax
cmpw $0x0, 0x4(%rdx)
cmoveq %rdx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/zip.cpp
// Function: zip::replace_idx(unsigned long, arrayview<unsigned char>, long)
void zip::replace_idx(size_t id, arrayview<uint8_t> data, time_t date)
{
	if (!data)
	{
		filenames.remove(id);
		filedat.remove(id);
		return;
	}
	
	file& f = filedat[id];
	f.decomplen = data.size();
	f.crc32 = crc32(data);
	if (date) f.dosdate = todosdate(date); // else leave unchanged, or leave as 0
	
	array<uint8_t> comp;
	comp.resize(data.size());
	size_t complen = tdefl_compress_mem_to_mem(comp.ptr(), comp.size(), data.ptr(), data.size(), TDEFL_DEFAULT_MAX_PROBES);
	if (complen != 0 && complen < data.size())
	{
		comp.resize(complen);
		f.method = 8;
		f.data = std::move(comp);
	}
	else
	{
		f.method = 0;
		f.data = data;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r12
movq %rdi, %r14
testq %rcx, %rcx
je 0x1c74e
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r15
movq 0x10(%r14), %rbp
shlq $0x5, %r12
leaq (%r12,%rbp), %r14
movl %ebx, (%rbp,%r12)
movq %rdx, %rdi
movq %rcx, %rsi
xorl %edx, %edx
callq 0x7f18
movl %eax, 0x18(%rbp,%r12)
testq %r13, %r13
je 0x1c6dc
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x10(%rsp), %r12
movq %r12, %rsi
callq 0x3720
movl 0x14(%r12), %eax
movl 0x10(%r12), %ecx
movl 0xc(%r12), %edx
movl 0x8(%r12), %esi
movl (%r12), %edi
movl 0x4(%r12), %r8d
shll $0x19, %eax
addl $0x60000000, %eax       # imm = 0x60000000
shll $0x15, %ecx
addl $0x200000, %ecx         # imm = 0x200000
orl %eax, %ecx
shll $0x10, %edx
shll $0xb, %esi
orl %edx, %esi
shll $0x5, %r8d
orl %esi, %r8d
orl %ecx, %r8d
sarl %edi
orl %r8d, %edi
movl %edi, 0x1c(%r14)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r12
movaps %xmm0, (%r12)
movq %r12, %rdi
movq %rbx, %rsi
callq 0xdea4
movq (%r12), %rdi
movq 0x8(%r12), %rsi
movq %r15, %rdx
movq %rbx, %rcx
movl $0x80, %r8d
callq 0x2d0ad
testq %rax, %rax
sete %cl
cmpq %rbx, %rax
setae %dl
orb %cl, %dl
jne 0x1c776
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xdea4
movw $0x8, 0x4(%r14)
movaps (%rbx), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%rbx)
movq 0x8(%r14), %rdi
movups %xmm0, 0x8(%r14)
callq 0x3430
jmp 0x1c78f
movq %r14, %rdi
movq %r12, %rsi
callq 0x132f0
addq $0x10, %r14
movq %r14, %rdi
movq %r12, %rsi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1cf3e
movw $0x0, 0x4(%r14)
addq $0x8, %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xe34c
movq 0x10(%rsp), %rdi
callq 0x3430
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/zip.cpp
// Function: zip::write(cstring, arrayview<unsigned char>, long)
void zip::write(cstring name, arrayview<uint8_t> data, time_t date)
{
	size_t id = find_file(name);
	
	if (id == (size_t)-1)
	{
		if (!data) return;
		
		id = filenames.size();
		filenames.append(name);
		filedat.append();
		if (!date) date = time(NULL);
	}
	
	replace_idx(id, data, date);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r15
movq %r8, %rbx
movq %rcx, (%rsp)
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %r12
callq 0x1c2ee
cmpq $-0x1, %rax
je 0x1c7fb
movq %rax, %r13
movq %r12, %rdi
movq %r13, %rsi
movq (%rsp), %rdx
movq %rbx, %rcx
movq %r15, %r8
callq 0x1c62e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testq %rbx, %rbx
je 0x1c7ec
movq 0x8(%r12), %r13
leaq 0x18(%rsp), %rsi
movq %r14, (%rsi)
movq %rbp, 0x8(%rsi)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x19592
movq 0x8(%r12), %rsi
movq %r12, %rdi
movq %r14, %rdx
callq 0x13192
cmpb $0x0, 0xf(%r14)
jns 0x1c83f
movq 0x8(%rsp), %rdi
callq 0x3430
leaq 0x10(%r12), %rdi
callq 0x1cf94
testq %r15, %r15
jne 0x1c7d7
xorl %edi, %edi
callq 0x3310
movq %rax, %r15
jmp 0x1c7d7
nop
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/zip.cpp
// Function: zip::clean()
bool zip::clean()
{
	bool any = false;
	for (size_t i=0;i<filenames.size();i++)
	{
		if (filenames[i].startswith("__MACOSX/") || filenames[i].endswith("/.DS_Store") || filenames[i].iendswith("/thumbs.db"))
		{
			filenames.remove(i);
			filedat.remove(i);
			i--;
			any = true;
		}
	}
	return any;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpq $0x0, 0x8(%rdi)
je 0x1c9b5
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
xorl %r15d, %r15d
xorl %ebp, %ebp
movq %r15, %r12
shlq $0x4, %r12
movq (%rbx), %r13
addq %r12, %r13
movl $0x9, %edx
leaq 0x28(%rsp), %rdi
leaq 0x13719(%rip), %rsi     # 0x30018
movl $0x1, %ecx
callq 0x5990
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r13, %rdi
callq 0x198f2
testb %al, %al
jne 0x1c98a
movq (%rbx), %r13
addq %r12, %r13
movl $0xa, %edx
leaq 0x18(%rsp), %rdi
leaq 0x136ec(%rip), %rsi     # 0x30022
movl $0x1, %ecx
callq 0x5990
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %r13, %rdi
callq 0x19952
testb %al, %al
jne 0x1c98a
addq (%rbx), %r12
movl $0xa, %edx
leaq 0x8(%rsp), %rdi
leaq 0x136c3(%rip), %rsi     # 0x3002d
movl $0x1, %ecx
callq 0x5990
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r12, %rdi
callq 0x19bce
testb %al, %al
je 0x1c9a6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x132f0
movq %r14, %rdi
movq %r15, %rsi
callq 0x1cf3e
decq %r15
movb $0x1, %bpl
incq %r15
cmpq 0x8(%rbx), %r15
jb 0x1c8e1
jmp 0x1c9b7
xorl %ebp, %ebp
andb $0x1, %bpl
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/zip.cpp
// Function: zip::repack()
void zip::repack()
{
	for (size_t i=0;i<filedat.size();i++)
	{
		array<uint8_t> data = read_idx(i);
		if (!data) continue;
		
		file& f = filedat[i];
		array<uint8_t> comp;
		comp.resize(data.size());
		size_t complen = tdefl_compress_mem_to_mem(comp.ptr(), comp.size(), data.ptr(), data.size(), TDEFL_DEFAULT_MAX_PROBES);
		if (complen != 0 && complen < f.data.size())
		{
			comp.resize(complen);
			f.method = 8;
			f.data = std::move(comp);
		}
	}
}

// Assembly:
cmpq $0x0, 0x18(%rdi)
je 0x1cabe
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl $0x10, %r13d
xorl %r14d, %r14d
leaq 0x10(%rsp), %r15
movq %rsp, %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x1c354
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x1ca95
movq 0x10(%rbx), %rbp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq %r12, %rdi
callq 0xdea4
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movl $0x80, %r8d
callq 0x2d0ad
testq %rax, %rax
je 0x1ca8c
cmpq (%rbp,%r13), %rax
jae 0x1ca8c
movq %r12, %rdi
movq %rax, %rsi
callq 0xdea4
movw $0x8, -0xc(%rbp,%r13)
movaps (%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%rsp)
movq -0x8(%rbp,%r13), %rdi
movups %xmm0, -0x8(%rbp,%r13)
callq 0x3430
movq (%rsp), %rdi
callq 0x3430
movq 0x10(%rsp), %rdi
callq 0x3430
incq %r14
addq $0x20, %r13
cmpq 0x18(%rbx), %r14
jb 0x1c9f9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/zip.cpp
// Function: zip::sort()
void zip::sort()
{
	for (size_t a=0;a<filenames.size();a++)
	{
		size_t b;
		for (b=0;b<a;b++)
		{
			if (string::less(filenames[a], filenames[b])) break;
		}
		filenames.swap(a, b);
		filedat.swap(a, b);
	}
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x1cbbd
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
testq %r14, %r14
je 0x1cb22
movl $0x8, %r12d
movq %r14, %r13
shlq $0x4, %r13
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r13), %rdi
movq 0x8(%rax,%r13), %rsi
movq -0x8(%rax,%r12), %rdx
movq (%rax,%r12), %rcx
callq 0x1a5ac
testl %eax, %eax
js 0x1cb25
incq %r15
addq $0x10, %r12
cmpq %r15, %r14
jne 0x1caf3
movq %r14, %r15
jmp 0x1cb25
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x1cba3
movq (%rbx), %rax
movq %r14, %rcx
shlq $0x4, %rcx
movups (%rax,%rcx), %xmm0
movaps %xmm0, (%rsp)
movq %r15, %rdx
shlq $0x4, %rdx
movups (%rax,%rdx), %xmm0
movups %xmm0, (%rax,%rcx)
movq (%rbx), %rax
movaps (%rsp), %xmm0
movups %xmm0, (%rax,%rdx)
movq 0x10(%rbx), %rax
movq %r14, %rcx
shlq $0x5, %rcx
movups (%rax,%rcx), %xmm0
movups 0x10(%rax,%rcx), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
shlq $0x5, %r15
movups (%rax,%r15), %xmm0
movups 0x10(%rax,%r15), %xmm1
movups %xmm0, (%rax,%rcx)
movups %xmm1, 0x10(%rax,%rcx)
movq 0x10(%rbx), %rax
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movups %xmm1, 0x10(%rax,%r15)
movups %xmm0, (%rax,%r15)
incq %r14
cmpq 0x8(%rbx), %r14
jb 0x1cade
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/zlibhead.cpp
// Function: inflator::zlibhead::adler32(arrayview<unsigned char>, unsigned int)
uint32_t inflator::zlibhead::adler32(bytesr by, uint32_t adler_prev)
{
	// could simd this, but not much point, it's not a bottleneck
	uint32_t a = adler_prev&0xFFFF;
	uint32_t b = adler_prev>>16;
	
	size_t i = 0;
	while (i < (by.size()&~4095)) // 5552 is safe, but 4096 is easier to deal with
	{
		do {
			a += by[i++]; b += a;
			a += by[i++]; b += a;
			a += by[i++]; b += a;
			a += by[i++]; b += a;
		} while (i&4095);
		a %= 65521;
		b %= 65521;
	}
	while (i < (by.size()&~3))
	{
		a += by[i++]; b += a;
		a += by[i++]; b += a;
		a += by[i++]; b += a;
		a += by[i++]; b += a;
	}
	while (i < by.size())
	{
		a += by[i++];
		b += a;
	}
	a %= 65521;
	b %= 65521;
	
	return a | (b<<16);
}

// Assembly:
movl %edx, %eax
movzwl %ax, %ecx
shrl $0x10, %eax
movq %rsi, %r8
andq $-0x1000, %r8           # imm = 0xF000
je 0x1d258
movl $0x4, %edx
movl $0x80078071, %r9d       # imm = 0x80078071
movzbl -0x4(%rdi,%rdx), %r10d
addl %ecx, %r10d
addl %r10d, %eax
movzbl -0x3(%rdi,%rdx), %ecx
addl %r10d, %ecx
addl %ecx, %eax
movzbl -0x2(%rdi,%rdx), %r10d
addl %ecx, %r10d
addl %r10d, %eax
movzbl -0x1(%rdi,%rdx), %ecx
addl %r10d, %ecx
addl %ecx, %eax
testl $0xffc, %edx            # imm = 0xFFC
jne 0x1d252
movl %ecx, %r10d
imulq %r9, %r10
shrq $0x2f, %r10
imull $0xfff1, %r10d, %r10d   # imm = 0xFFF1
subl %r10d, %ecx
movl %eax, %r10d
imulq %r9, %r10
shrq $0x2f, %r10
imull $0xfff1, %r10d, %r10d   # imm = 0xFFF1
subl %r10d, %eax
cmpq %r8, %rdx
jae 0x1d25a
addq $0x4, %rdx
jmp 0x1d1ef
xorl %edx, %edx
movq %rsi, %r8
andq $-0x4, %r8
cmpq %r8, %rdx
jae 0x1d297
movzbl (%rdi,%rdx), %r9d
addl %ecx, %r9d
addl %r9d, %eax
movzbl 0x1(%rdi,%rdx), %ecx
addl %r9d, %ecx
addl %ecx, %eax
movzbl 0x2(%rdi,%rdx), %r9d
addl %ecx, %r9d
addl %r9d, %eax
movzbl 0x3(%rdi,%rdx), %ecx
addq $0x4, %rdx
addl %r9d, %ecx
addl %ecx, %eax
jmp 0x1d261
cmpq %rsi, %rdx
jae 0x1d2ae
movzbl (%rdi,%rdx), %r8d
incq %rdx
addl %r8d, %ecx
addl %ecx, %eax
cmpq %rdx, %rsi
jne 0x1d29c
movl %ecx, %edx
movl $0x80078071, %esi       # imm = 0x80078071
imulq %rsi, %rdx
shrq $0x2f, %rdx
imull $0xfff1, %edx, %edx     # imm = 0xFFF1
subl %edx, %ecx
movl %eax, %edx
imulq %rsi, %rdx
shrq $0x2f, %rdx
imull $0xfff1, %edx, %edx     # imm = 0xFFF1
subl %edx, %eax
shll $0x10, %eax
orl %ecx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/zlibhead.cpp
// Function: inflator::zlibhead::inflate()
inflator::ret_t inflator::zlibhead::inflate()
{
	if (inf.m_state >= 254)
	{
	process_tail:
		inf.bits_refill_fast();
		if (inf.m_in_nbits < 32) return ret_more_input; // state 254 only needs 16 bits, but the other 16 will be used soon anyways
		if (inf.m_state == 254) // zlib header
		{
			uint32_t head = inf.bits_extract(16);
			if ((head&0x000F) != 0x0008 || // CMF.CF == DEFLATE (ZIP supports 8=DEFLATE and 0=uncompressed, but zlib only supports 8)
			// ignore 00F0 CMF.CINFO, inflator ignores window size (and it's almost always 7, the maximum)
			// ignore C000 FLG.FLEVEL, it's just informational, and there are too many compressors for it to make sense anymore
			    (head&0x2000) != 0x0000 || // FLG.FDICT, not supported
			    (__builtin_bswap16(head)%31) != 0) return ret_error; // FLG.FCHECK (1F00 bits), must be a multiple of 31
			// (are both 0 and 31 allowed in FCHECK if 0 is the correct checksum? I think they are)
			
			inf.m_state = 0;
		}
		else // zlib footer
		{
			inf.m_in_bits_buf >>= inf.m_in_nbits&7;
			inf.m_in_nbits &= ~7;
			uint32_t adler_head = __builtin_bswap32(inf.bits_extract(32)); // zlib header is big endian, even though DEFLATE is little...
			if (adler_head != adler) return ret_error;
			return ret_done;
		}
	}
	
	const uint8_t * out_prev = inf.m_out_at;
	ret_t ret = inf.inflate();
	adler = adler32(bytesr(out_prev, inf.m_out_at - out_prev), adler);
	if (ret != ret_done) return ret;
	
	inf.m_state = 255;
	goto process_tail;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
cmpb $-0x2, 0x8(%rdi)
jb 0x1d340
movq %r14, %rdi
callq 0x86a4
movl 0xc(%rbx), %eax
cmpq $0x20, %rax
jb 0x1d36b
cmpb $-0x2, (%r14)
jne 0x1d372
movq %r14, %rdi
movl $0x10, %esi
callq 0x871a
movl %eax, %ecx
andl $0x200f, %ecx           # imm = 0x200F
movl $0x1, %ebp
cmpl $0x8, %ecx
jne 0x1d398
rolw $0x8, %ax
imull $0x7bdf, %eax, %eax     # imm = 0x7BDF
movzwl %ax, %eax
cmpl $0x842, %eax            # imm = 0x842
ja 0x1d398
movb $0x0, (%r14)
movq 0x38(%rbx), %r15
movq %r14, %rdi
callq 0x8788
movl %eax, %ebp
movq 0x38(%rbx), %rsi
subq %r15, %rsi
movl (%rbx), %edx
movq %r15, %rdi
callq 0x1d1d0
movl %eax, (%rbx)
testl %ebp, %ebp
jne 0x1d398
movb $-0x1, (%r14)
jmp 0x1d2f2
movl $0x2, %ebp
jmp 0x1d398
movl %eax, %ecx
andb $0x7, %cl
shrq %cl, 0x10(%rbx)
andl $-0x8, %eax
movl %eax, 0xc(%rbx)
movq %r14, %rdi
movl $0x20, %esi
callq 0x871a
bswapl %eax
xorl %ebp, %ebp
cmpl (%rbx), %eax
setne %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/zlibhead.cpp
// Function: inflator::zlibhead::inflate(arrayview<unsigned char>)
bytearray inflator::zlibhead::inflate(bytesr in)
{
	inflator::zlibhead inf;
	inf.set_input(in, true);
	bytearray ret;
	ret.resize(max(4096, in.size()*8));
	inf.set_output_first(ret);
again:
	inflator::ret_t err = inf.inflate();
	if (err == inflator::ret_more_output)
	{
		ret.resize(ret.size()*2);
		inf.set_output_grow(ret);
		goto again;
	}
	else if (err != inflator::ret_done || inf.unused_input() != 0) ret.reset();
	else ret.resize(inf.output_in_last());
	
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x12e8, %rsp           # imm = 0x12E8
movq %rdi, %rbx
movl $0x1, 0x18(%rsp)
xorl %r15d, %r15d
movq %r15, 0x24(%rsp)
movl $0x0, 0x2c(%rsp)
movb $-0x2, 0x20(%rsp)
movq %rsi, 0x30(%rsp)
addq %rdx, %rsi
movq %rsi, 0x38(%rsp)
movb $0x1, 0x22(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leal (,%rdx,8), %eax
cmpl $0x1001, %eax           # imm = 0x1001
movl $0x1000, %esi           # imm = 0x1000
cmovgel %eax, %esi
callq 0xdea4
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1d413
movq (%rbx), %rcx
jmp 0x1d41a
leaq 0x15052(%rip), %rcx     # 0x3246c
leaq 0x20(%rsp), %r14
movq %r15, 0x20(%r14)
movq %rcx, 0x28(%r14)
movq %rcx, 0x30(%r14)
addq %rcx, %rax
movq %rax, 0x38(%r14)
leaq 0x18(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r15, %rdi
callq 0x1d2de
cmpl $0x3, %eax
jne 0x1d46d
movq 0x8(%rbx), %rsi
addq %rsi, %rsi
movq %rbx, %rdi
callq 0xdea4
movups (%rbx), %xmm0
movups %xmm0, 0x8(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x93a4
jmp 0x1d43c
testl %eax, %eax
jne 0x1d49b
movq 0x38(%rsp), %rax
subq 0x30(%rsp), %rax
movl 0x24(%rsp), %ecx
shrl $0x3, %ecx
addq %rax, %rcx
jne 0x1d49b
movq 0x50(%rsp), %rsi
subq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0xdea4
jmp 0x1d4c2
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1d4c2
cmpq $0x9, %rax
jb 0x1d4ba
movq (%rbx), %rdi
movl $0x8, %esi
callq 0x159f7
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x12e8, %rsp           # imm = 0x12E8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/zlibhead.cpp
// Function: inflator::zlibhead::inflate(arrayvieww<unsigned char>, arrayview<unsigned char>)
bool inflator::zlibhead::inflate(bytesw out, bytesr in)
{
	inflator::zlibhead inf;
	inf.set_input(in, true);
	inf.set_output_first(out);
	return (inf.inflate() == inflator::ret_done && inf.output_in_last() == out.size() && inf.unused_input() == 0);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x12d8, %rsp           # imm = 0x12D8
movq %rdi, %r14
movl $0x1, 0x8(%rsp)
xorl %ebx, %ebx
movq %rbx, 0x14(%rsp)
movl $0x0, 0x1c(%rsp)
movb $-0x2, 0x10(%rsp)
movq %rsi, 0x20(%rsp)
addq %rsi, %rdx
movq %rdx, 0x28(%rsp)
movb $0x1, 0x12(%rsp)
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x1d51d
movq (%r14), %rcx
jmp 0x1d524
leaq 0x14f48(%rip), %rcx     # 0x3246c
leaq 0x8(%rsp), %rdi
movq %rbx, 0x28(%rdi)
movq %rcx, 0x30(%rdi)
movq %rcx, 0x38(%rdi)
addq %rcx, %rax
movq %rax, 0x40(%rdi)
callq 0x1d2de
testl %eax, %eax
jne 0x1d570
movq 0x40(%rsp), %rax
subq 0x38(%rsp), %rax
cmpq 0x8(%r14), %rax
jne 0x1d56e
movq 0x28(%rsp), %rax
subq 0x20(%rsp), %rax
movl 0x14(%rsp), %ecx
shrl $0x3, %ecx
addq %rax, %rcx
sete %bl
jmp 0x1d570
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x12d8, %rsp           # imm = 0x12D8
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/font.cpp
// Function: font::init_from_image(image const&)
void font::init_from_image(const image& img)
{
	memset(characters, 0, sizeof(characters));
	memset(width, 0, sizeof(uint8_t)*32);
	
	int cw = img.width/16;
	int ch = img.height/6;
	
	for (int cy=0;cy<6;cy++)
	for (int cx=0;cx<16;cx++)
	{
		uint8_t charid = 32 + cy*16 + cx;
		
		uint8_t maxbits = 1;
		for (int y=0;y<ch;y++)
		{
			int ty = cy*ch + y;
			uint32_t* pixels = img.pixels32 + img.stride/sizeof(uint32_t)*ty;
			
			uint8_t bits = 0;
			for (int x=0;x<cw;x++)
			{
				int tx = cx*cw + x;
				bits |= !(pixels[tx]&1) << x;
			}
			characters[charid][y] = bits;
			maxbits |= bits;
		}
		
		width[charid] = ilog2(maxbits)+2; // +1 because maxbits=1 has width 1 but log2(1)=0, +1 because letter spacing
	}
	
	height = ch;
	scale = 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq $0x0, 0x8(%rsp)
movl $0x420, %edx            # imm = 0x420
movq %rdi, (%rsp)
xorl %esi, %esi
callq 0x3170
movl (%r14), %eax
movl 0x4(%r14), %ecx
movl %eax, %esi
shrl $0x4, %esi
movl $0xaaaaaaab, %edx       # imm = 0xAAAAAAAB
movq %rcx, 0x28(%rsp)
imulq %rcx, %rdx
movq %rdx, %r8
shrq $0x22, %r8
shrq $0x20, %rdx
movl %esi, %ecx
shll $0x2, %ecx
movq %rcx, 0x20(%rsp)
andl $-0x4, %edx
movq %rdx, 0x10(%rsp)
xorl %edx, %edx
movq %rdx, 0x18(%rsp)
shlq $0x4, %rdx
addq $0x20, %rdx
movq %rdx, 0x30(%rsp)
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x30(%rsp), %rcx
leaq (%rcx,%r13), %rbp
movb $0x1, %dil
cmpl $0x6, 0x28(%rsp)
jb 0x1d93c
movq (%rsp), %rcx
leaq (%rcx,%rbp,8), %r10
movq 0x8(%rsp), %r15
xorl %edx, %edx
cmpl $0x10, %eax
jae 0x1d8f6
xorl %ebx, %ebx
jmp 0x1d929
movl 0xc(%r14), %r9d
shrl $0x2, %r9d
movq 0x10(%r14), %rcx
addq %r12, %rcx
imulq %r15, %r9
addq %rcx, %r9
xorl %ecx, %ecx
xorl %ebx, %ebx
movl (%r9,%rcx,4), %r11d
notl %r11d
andl $0x1, %r11d
shll %cl, %r11d
orb %r11b, %bl
incq %rcx
cmpq %rcx, %rsi
jne 0x1d910
movb %bl, (%rdx,%r10)
orb %bl, %dil
incq %rdx
addq $0x4, %r15
cmpq %r8, %rdx
jne 0x1d8ed
movzbl %dil, %ecx
bsrl %ecx, %ecx
xorl $0x7, %ecx
movb $0x9, %dl
subb %cl, %dl
movq (%rsp), %rcx
movb %dl, 0x400(%rcx,%rbp)
incq %r13
addq 0x20(%rsp), %r12
cmpq $0x10, %r13
jne 0x1d8cb
movq 0x18(%rsp), %rdx
incq %rdx
movq 0x10(%rsp), %rcx
addq %rcx, 0x8(%rsp)
cmpq $0x6, %rdx
jne 0x1d8b3
movq (%rsp), %rax
movb %r8b, 0x480(%rax)
movb $0x1, 0x488(%rax)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/font.cpp
// Function: font::measure(cstring, float)
uint32_t font::measure(cstring text, float spacesize)
{
	float ret = 0;
	for (size_t i=0;i<text.length();i++)
	{
		if (text[i] == ' ') ret += spacesize;
		ret += width[(uint8_t)text[i]] * scale;
	}
	return ret;
}

// Assembly:
movq %rsi, -0x10(%rsp)
movq %rdx, -0x8(%rsp)
movq %rdx, %rcx
shrq $0x38, %rcx
xorl $0xf, %ecx
testq %rdx, %rdx
movl %edx, %eax
cmovnsl %ecx, %eax
testl %eax, %eax
je 0x1da26
testq %rdx, %rdx
leaq -0x10(%rsp), %rcx
cmovsq %rsi, %rcx
movzbl 0x488(%rdi), %edx
xorps %xmm1, %xmm1
xorl %esi, %esi
movabsq $0x100000000, %r8       # imm = 0x100000000
movq %rsi, %r9
sarq $0x20, %r9
movzbl (%rcx,%r9), %r9d
cmpq $0x20, %r9
jne 0x1d9fc
addss %xmm0, %xmm1
movaps %xmm1, %xmm2
movzbl 0x400(%rdi,%r9), %r9d
imull %edx, %r9d
xorps %xmm1, %xmm1
cvtsi2ss %r9d, %xmm1
addss %xmm2, %xmm1
addq %r8, %rsi
decq %rax
jne 0x1d9e6
cvttss2si %xmm1, %rax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/font.cpp
// Function: font::render_justified(image&, int, int, unsigned int, unsigned int, cstring, bool) const
void font::render_justified(image& img, int32_t x, int32_t y, uint32_t width1, uint32_t width2, cstring text, bool align) const
{
	size_t linestart = 0;
	size_t numspaces = 0;
	
	uint32_t linewidth = 0;
	for (size_t i=0;i<=text.length();i++)
	{
		if (i == text.length() || text[i] == '\n')
		{
			linewidth *= this->scale;
			
			float spacesize;
			if (linewidth >= width1 && linewidth <= width2) spacesize = ((width2 - linewidth) / (float)numspaces);
			else spacesize = 0;
			
			this->render(img, x, y, text.substr(linestart, i), spacesize, align);
			
			y += this->height * this->scale;
			linestart = i+1;
			linewidth = 0;
			numspaces = 0;
			continue;
		}
		
		if (text[i] == ' ') numspaces++;
		linewidth += this->width[(uint8_t)text[i]];
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, 0x18(%rsp)
movl %r8d, 0x14(%rsp)
movl %ecx, %r14d
movl %edx, 0x10(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdi, %r13
leaq 0x60(%rsp), %rbx
xorl %esi, %esi
movzbl 0x70(%rsp), %eax
movl %eax, 0xc(%rsp)
movabsq $0x100000000, %r12      # imm = 0x100000000
movzbl 0xf(%rbx), %ecx
movl 0x8(%rbx), %edx
movq %rbx, %r8
testb %cl, %cl
jns 0x1dcf8
movq (%rbx), %r8
movq %rcx, %r9
xorq $0xf, %r9
movq %rsi, %r10
shlq $0x20, %r10
xorl %edi, %edi
xorl %eax, %eax
movq %rsi, %rbp
testb %cl, %cl
js 0x1dd1e
movq %r9, %r11
cmpq %r9, %rbp
jbe 0x1dd2a
jmp 0x1de10
movq %rdx, %r11
cmpq %rdx, %rbp
ja 0x1de10
cmpq %r11, %rbp
je 0x1dd63
movq %r10, %r11
sarq $0x20, %r11
movzbl (%r8,%r11), %r11d
cmpq $0xa, %r11
je 0x1dd63
xorl %r15d, %r15d
cmpq $0x20, %r11
sete %r15b
addq %r15, %rdi
movzbl 0x400(%r13,%r11), %r11d
addl %r11d, %eax
incq %rbp
addq %r12, %r10
jmp 0x1dd0d
testq %rdi, %rdi
js 0x1dd72
xorps %xmm0, %xmm0
cvtsi2ss %rdi, %xmm0
jmp 0x1dd8a
movq %rdi, %rcx
shrq %rcx
andl $0x1, %edi
orq %rcx, %rdi
xorps %xmm0, %xmm0
cvtsi2ss %rdi, %xmm0
addss %xmm0, %xmm0
movzbl 0x488(%r13), %ecx
imull %ecx, %eax
movl 0x18(%rsp), %ecx
xorps %xmm2, %xmm2
xorps %xmm1, %xmm1
subl %eax, %ecx
jb 0x1ddaf
xorps %xmm1, %xmm1
cvtsi2ss %rcx, %xmm1
divss %xmm0, %xmm1
cmpl 0x14(%rsp), %eax
jb 0x1ddb8
movaps %xmm1, %xmm2
movss %xmm2, 0x1c(%rsp)
movq %rbx, %rdi
movl %ebp, %edx
callq 0x6b28
movq %rdx, %r9
movl 0xc(%rsp), %ecx
movl %ecx, (%rsp)
movq %r13, %rdi
movq 0x20(%rsp), %rsi
movl 0x10(%rsp), %edx
movl %r14d, %ecx
movq %rax, %r8
movss 0x1c(%rsp), %xmm0
callq 0x1da2a
movzbl 0x480(%r13), %eax
movzbl 0x488(%r13), %ecx
imull %eax, %ecx
addl %ecx, %r14d
incq %rbp
movq %rbp, %rsi
jmp 0x1dce7
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/font.cpp
// Function: font::render_wrap(image&, int, int, unsigned int, cstring) const
void font::render_wrap(image& img, int32_t x, int32_t y, uint32_t width, cstring text) const
{
	size_t linestart = 0;
	size_t numspaces = 0;
	
	size_t lastspace = 0; // index to the string
	uint32_t widthlastspace = 0; // text width (pixels) from linestart to lastspace
	
	uint32_t linewidth = 0; // text width (pixels) from linestart to i
	
	for (size_t i=0;i<=text.length();i++)
	{
		if (i == text.length() || text[i] == '\n' || linewidth >= width)
		{
			float spacesize = 0;
			if (linewidth >= width)
			{
				i = lastspace;
				linewidth = widthlastspace;
				spacesize = ((width - linewidth) / (float)(numspaces-1));
			}
			
			this->render(img, x, y, text.substr(linestart, i), spacesize, true);
			
			y += this->height * this->scale;
			linestart = i+1;
			linewidth = 0;
			numspaces = 0;
			continue;
		}
		
		if (text[i] == ' ')
		{
			lastspace = i;
			widthlastspace = linewidth;
			numspaces++;
		}
		linewidth += this->width[(uint8_t)text[i]] * this->scale;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, 0x18(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdi, %r12
xorl %ecx, %ecx
leaq 0x60(%rsp), %r13
xorl %r15d, %r15d
xorl %edi, %edi
xorl %eax, %eax
xorl %r14d, %r14d
xorl %esi, %esi
movl %ebx, %edx
movl %edi, 0x10(%rsp)
subl %edi, %edx
xorps %xmm0, %xmm0
cvtsi2ss %rdx, %xmm0
movss %xmm0, 0x14(%rsp)
movzbl 0xf(%r13), %edx
testb %dl, %dl
js 0x1de87
movq %rdx, %rdi
xorq $0xf, %rdi
cmpq %rdi, %r14
ja 0x1df8e
movzbl %dil, %edi
jmp 0x1de94
movl 0x8(%r13), %edi
cmpq %rdi, %r14
ja 0x1df8e
cmpq %rdi, %r14
je 0x1deb9
movq %r13, %rdi
testb %dl, %dl
jns 0x1dea4
movq (%r13), %rdi
movslq %r14d, %rdx
movzbl (%rdi,%rdx), %edx
cmpq $0xa, %rdx
je 0x1deb9
cmpl %ebx, %eax
jb 0x1df52
decq %rcx
js 0x1dec8
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
jmp 0x1dee0
movq %rcx, %rdx
shrq %rdx
andl $0x1, %ecx
orq %rdx, %rcx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
xorps %xmm1, %xmm1
cmpl %ebx, %eax
cmovaeq %r15, %r14
jb 0x1def5
movss 0x14(%rsp), %xmm1
divss %xmm0, %xmm1
movss %xmm1, 0x1c(%rsp)
movq %r13, %rdi
movl %r14d, %edx
callq 0x6b28
movq %rdx, %r9
movl $0x1, (%rsp)
movq %r12, %rdi
movq 0x20(%rsp), %rsi
movl 0x18(%rsp), %edx
movl %ebp, %ecx
movq %rax, %r8
movss 0x1c(%rsp), %xmm0
callq 0x1da2a
movzbl 0x480(%r12), %eax
movzbl 0x488(%r12), %ecx
imull %eax, %ecx
addl %ecx, %ebp
incq %r14
xorl %ecx, %ecx
xorl %eax, %eax
movq %r14, %rsi
jmp 0x1de68
xorl %edi, %edi
cmpq $0x20, %rdx
sete %dil
cmoveq %r14, %r15
movl 0x10(%rsp), %r8d
cmovel %eax, %r8d
addq %rdi, %rcx
movzbl 0x400(%r12,%rdx), %edx
movzbl 0x488(%r12), %edi
imull %edx, %edi
addl %edi, %eax
movl %r8d, %edi
incq %r14
jmp 0x1de52
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/game.cpp
// Function: (anonymous namespace)::game_impl::save(arrayvieww<unsigned char>)
void save(bytesw dat)
	{
		if (dat.size() != savedat_size) abort();
		
		dat[0] = unlocked;
		dat[1] = seen_random_tutorial;
		
#ifdef ARLIB_THREAD
		writeu_le64(dat.skip(2 ).ptr(), gamegen_next[0]);
		writeu_le32(dat.skip(10).ptr(), gamegen_diff_expect[0]);
		writeu_le64(dat.skip(14).ptr(), gamegen_next[1]);
		writeu_le32(dat.skip(22).ptr(), gamegen_diff_expect[1]);
		writeu_le64(dat.skip(26).ptr(), gamegen_next[2]);
		writeu_le32(dat.skip(34).ptr(), gamegen_diff_expect[2]);
#else
		writeu_le64(dat.skip(2 ).ptr(), 0);
		writeu_le32(dat.skip(10).ptr(), 0);
		writeu_le64(dat.skip(14).ptr(), 0);
		writeu_le32(dat.skip(22).ptr(), 0);
		writeu_le64(dat.skip(26).ptr(), 0);
		writeu_le32(dat.skip(34).ptr(), 0);
#endif
	}

// Assembly:
cmpq $0x26, 0x8(%rsi)
jne 0x21ffe
movb 0x4c(%rdi), %al
movq (%rsi), %rcx
movb %al, (%rcx)
movb 0x24acd(%rdi), %al
movq (%rsi), %rcx
movb %al, 0x1(%rcx)
movq (%rsi), %rax
movq 0x24a80(%rdi), %rcx
movq %rcx, 0x2(%rax)
movq (%rsi), %rax
movl 0x24aac(%rdi), %ecx
movl %ecx, 0xa(%rax)
movq (%rsi), %rax
movq 0x24a88(%rdi), %rcx
movq %rcx, 0xe(%rax)
movq (%rsi), %rax
movl 0x24ab0(%rdi), %ecx
movl %ecx, 0x16(%rax)
movq (%rsi), %rax
movq 0x24a90(%rdi), %rcx
movq %rcx, 0x1a(%rax)
movq (%rsi), %rax
movl 0x24ab4(%rdi), %ecx
movl %ecx, 0x22(%rax)
retq
pushq %rax
callq 0x3180