LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/argparse.cpp
// Function: argparse::single_arg(cstring, char const*, argparse::arglevel_t, bool*)
void argparse::single_arg(cstring name, const char * value, arglevel_t arglevel, bool* used_value)
{
	for (arg_base& arg : m_args)
	{
		if (arg.name == name)
		{
			single_arg(arg, value, arglevel, used_value);
			return;
		}
	}
	if (name != "") error("unknown argument: --"+name);
	else error("positional arguments not supported");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, 0x10(%rsp)
movl %r8d, 0x4(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %rsi, (%r12)
movq %rdx, 0x8(%r12)
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %rbp
shlq $0x3, %rbp
xorl %r15d, %r15d
cmpq %r15, %rbp
je 0x3da8
movq (%r14,%r15), %r13
leaq 0x8(%r13), %rdi
movq %r12, %rsi
callq 0x1550e
addq $0x8, %r15
testb %al, %al
je 0x3d63
movq %rbx, %rdi
movq %r13, %rsi
movq 0x8(%rsp), %rdx
movl 0x4(%rsp), %ecx
movq 0x10(%rsp), %r8
callq 0x3b82
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2762a(%rip), %rsi     # 0x2b3d9
leaq 0x18(%rsp), %rdi
callq 0x41ee
testb %al, %al
je 0x3ddd
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
leaq 0x242cd(%rip), %rsi     # 0x2809b
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x41b8
jmp 0x3df1
leaq 0x242cc(%rip), %rsi     # 0x280b0
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x41e2
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x3b2a
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/argparse.cpp
// Function: argparse::single_arg(char, char const*, argparse::arglevel_t, bool*)
void argparse::single_arg(char sname, const char * value, arglevel_t arglevel, bool* used_value)
{
	for (arg_base& arg : m_args)
	{
		if (arg.sname == sname)
		{
			single_arg(arg, value, arglevel, used_value);
			return;
		}
	}
	string e = "unknown argument: -";
	e += sname; // no operator+(string, char), too high risk it's hit by an accidental operator+(string, int)
	error(e);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rdi
shlq $0x3, %rdi
xorl %r9d, %r9d
cmpq %r9, %rdi
je 0x3e3f
movq (%rax,%r9), %rsi
addq $0x8, %r9
cmpb %bpl, 0x18(%rsi)
jne 0x3e1c
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x3b82
leaq 0x2428d(%rip), %rsi     # 0x280d3
movq %rsp, %r14
movq %r14, %rdi
callq 0x4242
movzbl %bpl, %esi
movq %r14, %rdi
callq 0x4354
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x3b2a
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/argparse.cpp
// Function: argparse::parse_pre(char const* const*)
void argparse::parse_pre(const char * const * argv)
{
#ifndef ARLIB_OPT
	if (m_appname)
	{
		error("internal error: argparse::parse called twice");
	}
#endif
	m_appname = argv[0];
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movzbl 0xf(%rdi), %eax
testb %al, %al
jns 0x3e83
movl 0x8(%rbx), %eax
jmp 0x3e86
xorl $0xf, %eax
testl %eax, %eax
jne 0x3e9c
movq (%rsi), %rsi
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x438e
leaq 0x24244(%rip), %rsi     # 0x280e7
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x41e2
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x3b2a
nop
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/argparse.cpp
// Function: argparse::parse_post()
void argparse::parse_post()
{
	for (arg_base& arg : m_args)
	{
		if (arg.must_use)
		{
			if (arg.name) error("missing required argument --"+arg.name);
			else error("missing required positional argument");
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x413a
movq (%rcx,%rsi), %rax
addq $0x8, %rsi
cmpb $0x1, 0x1b(%rax)
jne 0x411a
movzbl 0x17(%rax), %ecx
testb %cl, %cl
jns 0x4142
movl 0x10(%rax), %ecx
jmp 0x4145
addq $0x28, %rsp
popq %rbx
popq %r14
retq
xorl $0xf, %ecx
testl %ecx, %ecx
jne 0x415f
leaq 0x23fe1(%rip), %rsi     # 0x28131
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x41e2
jmp 0x417b
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
leaq 0x23fa6(%rip), %rsi     # 0x28114
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x41b8
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x3b2a
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/string.h
// Function: cstring::init_from_nocopy(unsigned char const*, unsigned long, bool)
void init_from_nocopy(const uint8_t * str, size_t len, bool has_nul = false)
	{
		if (len <= MAX_INLINE)
		{
			for (uint32_t i=0;i<len;i++) m_inline[i] = str[i]; // memcpy's constant overhead is huge if len is unknown
			m_inline[len] = '\0';
			m_inline_len_w() = MAX_INLINE-len;
		}
		else
		{
			if (len > 0xFFFFFFFF) abort();
			m_inline_len_w() = -1;
			
			m_data = (uint8_t*)str;
			m_len = len;
			m_nul = has_nul;
		}
	}

// Assembly:
cmpq $0xf, %rdx
ja 0x431b
xorl %eax, %eax
cmpl %edx, %eax
jae 0x430f
movb (%rsi,%rax), %cl
movb %cl, (%rdi,%rax)
incq %rax
jmp 0x4300
movb $0x0, (%rdi,%rdx)
movb $0xf, %al
subb %dl, %al
movb %al, 0xf(%rdi)
retq
movq %rdx, %rax
shrq $0x20, %rax
jne 0x4332
movb $-0x1, 0xf(%rdi)
movq %rsi, (%rdi)
movl %edx, 0x8(%rdi)
movb %cl, 0xc(%rdi)
retq
pushq %rax
callq 0x3180
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/array.cpp
// Function: bitarray::set_slice(unsigned long, unsigned long, bitarray const&, unsigned long)
void bitarray::set_slice(size_t start, size_t num, const bitarray& other, size_t other_start)
{
	if (&other == this)
	{
		//TODO: optimize
		bitarray copy = other;
		set_slice(start, num, copy, other_start);
		return;
	}
	//TODO: optimize
	for (size_t i=0;i<num;i++)
	{
		set(start+i, other.get(other_start+i));
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpq %rdi, %rcx
je 0x440d
subq $0x1, %r14
jb 0x4439
movq %r13, %rdi
movq %rbx, %rsi
callq 0x4682
movzbl %al, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x4656
incq %r15
incq %rbx
jmp 0x43e6
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x46a2
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbp, %rcx
movq %rbx, %r8
callq 0x43c4
movq %rbp, %rdi
callq 0x470a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/array.cpp
// Function: bitarray::clear_unused(unsigned long, unsigned long)
void bitarray::clear_unused(size_t start, size_t nbytes)
{
	size_t low = start;
	size_t high = nbytes*8;
	
	if (low == high) return; // don't wipe bits()[8] if they're both 64
	
	uint8_t* ptr = bits();
	uint8_t& byte = ptr[low/8];
	byte &=~ (0xFF<<(low&7));
	low = (low+7)&~7;
	
	memset(ptr+low/8, 0, (high-low)/8);
}

// Assembly:
shlq $0x3, %rdx
cmpq %rsi, %rdx
jne 0x4452
retq
cmpq $0x41, 0x8(%rdi)
jb 0x445c
movq (%rdi), %rdi
movq %rsi, %rax
shrq $0x3, %rax
movl %esi, %ecx
andb $0x7, %cl
movb $-0x1, %r8b
shlb %cl, %r8b
notb %r8b
andb %r8b, (%rdi,%rax)
addq $0x7, %rsi
movq %rsi, %rax
andq $-0x8, %rax
shrq $0x3, %rsi
addq %rdi, %rsi
subq %rax, %rdx
shrq $0x3, %rdx
movq %rsi, %rdi
xorl %esi, %esi
jmp 0x3170
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/array.cpp
// Function: bitarray::slice(unsigned long, unsigned long) const
bitarray bitarray::slice(size_t first, size_t count) const
{
	if ((first&7) == 0)
	{
		bitarray ret;
		ret.resize(count);
		memcpy(ret.bits(), this->bits() + first/8, (count+7)/8);
		return ret;
	}
	else
	{
		//TODO: optimize
		bitarray ret;
		ret.resize(count);
		for (size_t i=0;i<count;i++) ret.set(i, this->get(first+i));
		return ret;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rcx, %rsi
callq 0x4498
testb $0x7, %r15b
je 0x4614
xorl %r13d, %r13d
cmpq %r13, %r14
je 0x4649
leaq (%r15,%r13), %rsi
movq %r12, %rdi
callq 0x4682
movzbl %al, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4656
incq %r13
jmp 0x45f0
cmpq $0x41, 0x8(%rbx)
jb 0x4620
movq (%rbx), %rdi
jmp 0x4623
movq %rbx, %rdi
cmpq $0x41, 0x8(%r12)
jb 0x462f
movq (%r12), %r12
shrq $0x3, %r15
addq %r12, %r15
addq $0x7, %r14
shrq $0x3, %r14
movq %r15, %rsi
movq %r14, %rdx
callq 0x3280
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/array.h
// Function: bitarray::construct(bitarray const&)
void construct(const bitarray& other)
	{
		nbits = other.nbits;
		if (nbits > n_inline)
		{
			size_t nbytes = alloc_size(nbits);
			bits_outline = xmalloc(nbytes);
			memcpy(bits_outline, other.bits_outline, nbytes);
		}
		else
		{
			memcpy(bits_inline, other.bits_inline, sizeof(bits_inline));
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
cmpq $0x41, %rax
jb 0x46fd
addq $0x7, %rax
movq %rax, %rcx
shrq $0x3, %rcx
decq %rcx
bsrq %rcx, %rcx
pushq $0x2
popq %rdx
shlq %cl, %rdx
cmpq $0x10, %rax
pushq $0x1
popq %r15
cmovaeq %rdx, %r15
movq %r15, %rdi
callq 0x11544
movq %rax, (%r14)
movq (%rbx), %rsi
movq %rax, %rdi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x3280
movq (%rbx), %rax
movq %rax, (%r14)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/base64dec.cpp
// Function: base64_dec(cstring)
array<uint8_t> base64_dec(cstring text)
{
	array<uint8_t> ret;
	ret.resize(base64_dec_len(text.length()));
	size_t actual = base64_dec_raw(ret, text);
	if (!actual) return NULL;
	ret.resize(actual);
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %rax
shrq $0x38, %rax
xorps %xmm0, %xmm0
movq %rsp, %r12
movaps %xmm0, (%r12)
xorl $0xf, %eax
testq %rdx, %rdx
cmovsq %rdx, %rax
movl %eax, %eax
addq $0x3, %rax
shrq $0x2, %rax
leaq (%rax,%rax,2), %rsi
movq %r12, %rdi
callq 0xbaee
movaps (%r12), %xmm0
leaq 0x18(%rsp), %rdi
movups %xmm0, (%rdi)
movq %r15, %rsi
movq %r14, %rdx
callq 0x471c
testq %rax, %rax
je 0x4980
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0xbaee
movaps (%r14), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r14)
movups %xmm0, (%rbx)
xorl %edi, %edi
jmp 0x498a
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq (%rsp), %rdi
callq 0x3430
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/base64enc.cpp
// Function: base64_enc_raw(arrayvieww<unsigned char>, arrayview<unsigned char>)
void base64_enc_raw(arrayvieww<uint8_t> out, arrayview<uint8_t> bytes)
{
	if (!bytes.size()) return;
	
	uint8_t* outp = out.ptr();
	const uint8_t* inp = bytes.ptr();
	const uint8_t* inpe = inp + bytes.size();
	
	while (inp+4 <= inpe)
	{
		uint32_t three = readu_be32(inp) >> 8;
		outp[0] = encode[(three>>18)   ];
		outp[1] = encode[(three>>12)&63];
		outp[2] = encode[(three>>6 )&63];
		outp[3] = encode[(three>>0 )&63];
		inp += 3;
		outp += 4;
	}
	
	uint32_t three = inp[0]<<16;
	if (inp+1 < inpe) three |= inp[1]<<8;
	if (inp+2 < inpe) three |= inp[2]<<0;
	
	outp[0] = encode[(three>>18)   ];
	outp[1] = encode[(three>>12)&63];
	outp[2] = encode[(three>>6 )&63];
	outp[3] = encode[(three>>0 )&63];
	
	if (inp+1 >= inpe) outp[2] = '='; // don't move the outp[2,3] above into elses, it optimizes better this way
	if (inp+2 >= inpe) outp[3] = '=';
}

// Assembly:
testq %rdx, %rdx
je 0x4a94
movq (%rdi), %rax
addq %rsi, %rdx
addq $0x2, %rsi
addq $0x3, %rax
leaq 0x23842(%rip), %rcx     # 0x28200
leaq 0x2(%rsi), %rdi
cmpq %rdx, %rdi
ja 0x4a18
movl -0x2(%rsi), %edi
bswapl %edi
movl %edi, %r8d
shrl $0x8, %r8d
movl %edi, %r9d
shrl $0x1a, %r9d
movb (%r9,%rcx), %r9b
movb %r9b, -0x3(%rax)
movl %edi, %r9d
shrl $0x14, %r9d
andl $0x3f, %r9d
movb (%r9,%rcx), %r9b
movb %r9b, -0x2(%rax)
shrl $0xe, %edi
andl $0x3f, %edi
movb (%rdi,%rcx), %dil
movb %dil, -0x1(%rax)
andl $0x3f, %r8d
movb (%r8,%rcx), %dil
movb %dil, (%rax)
addq $0x3, %rsi
addq $0x4, %rax
jmp 0x49be
movzbl -0x2(%rsi), %r8d
shll $0x10, %r8d
leaq -0x1(%rsi), %rdi
cmpq %rdx, %rdi
jae 0x4a38
movzbl (%rdi), %r9d
shll $0x8, %r9d
orl %r8d, %r9d
movl %r9d, %r8d
cmpq %rdx, %rsi
jae 0x4a44
movzbl (%rsi), %r9d
orl %r9d, %r8d
movl %r8d, %r9d
shrl $0x12, %r9d
movl %r8d, %r10d
shrl $0xc, %r10d
andl $0x3f, %r10d
movl %r8d, %r11d
shrl $0x6, %r11d
andl $0x3f, %r11d
andl $0x3f, %r8d
movb (%r9,%rcx), %r9b
movb %r9b, -0x3(%rax)
movb (%r10,%rcx), %r9b
movb %r9b, -0x2(%rax)
movb (%r11,%rcx), %r9b
movb %r9b, -0x1(%rax)
movb (%r8,%rcx), %cl
movb %cl, (%rax)
cmpq %rdx, %rdi
jb 0x4a8c
movb $0x3d, -0x1(%rax)
cmpq %rdx, %rsi
jb 0x4a94
movb $0x3d, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/bmlparse.cpp
// Function: bml_size_white(cstring const&)
static size_t bml_size_white(const cstring& data)
{
	size_t i = 0;
	while (i < data.length() && (data[i]==' ' || data[i]=='\t')) i++;
	if (i < data.length() && data[i]=='#') return data.length();
	if (i+1 < data.length() && data[i]=='/' && data[i+1]=='/') return data.length();
	else return i;
}

// Assembly:
movzbl 0xf(%rdi), %ecx
movl %ecx, %eax
xorl $0xf, %eax
testb %cl, %cl
cmovsl 0x8(%rdi), %eax
cmovsq (%rdi), %rdi
xorl %edx, %edx
movabsq $0x100000000, %rsi      # imm = 0x100000000
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x53ae
movq %rdx, %r8
sarq $0x20, %r8
movzbl (%rdi,%r8), %r9d
cmpl $0x20, %r9d
je 0x53a6
cmpl $0x9, %r9d
jne 0x53d3
incq %rcx
addq %rsi, %rdx
jmp 0x5389
movq %rax, %rcx
leaq 0x1(%rcx), %rdx
cmpq %rax, %rdx
jae 0x53cf
movslq %ecx, %rsi
cmpb $0x2f, (%rdi,%rsi)
jne 0x53cf
movslq %edx, %rdx
cmpb $0x2f, (%rdi,%rdx)
cmovneq %rcx, %rax
retq
movq %rcx, %rax
retq
cmpq %rax, %rcx
jae 0x53b1
cmpb $0x23, (%rdi,%r8)
jne 0x53b1
retq
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/bmlparse.cpp
// Function: bmlparser::getline(bool)
inline bool bmlparser::getline(bool allow_empty)
{
nextline:
	if (!m_data)
	{
null:
		m_thisline = "";
		m_indent = "";
		return true;
	}
	
	m_thisline = cutline(m_data);
	size_t indentlen = bml_size_white(m_thisline);
	if (indentlen == m_thisline.length())
	{
		if (allow_empty) goto nextline;
		else goto null;
	}
	
	size_t sharedindent = min(indentlen, m_indent.length());
	bool badwhite = (memcmp(m_thisline.bytes().ptr(), m_indent.bytes().ptr(), sharedindent) != 0);
	
	m_indent = cut(m_thisline, 0, indentlen, 0);
	
	return !badwhite;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, 0x14(%rsp)
movq %rdi, %r14
leaq 0x10(%rdi), %r15
leaq 0x20(%rdi), %rax
movq %rax, 0x8(%rsp)
movabsq $0x100000000, %rbp      # imm = 0x100000000
movzbl 0x1f(%r14), %edx
testb %dl, %dl
jns 0x5471
movl 0x18(%r14), %ecx
jmp 0x5476
movl %edx, %ecx
xorl $0xf, %ecx
testl %ecx, %ecx
je 0x5509
movq %r15, %rax
testb %dl, %dl
jns 0x5488
movq (%r15), %rax
movl %ecx, %edx
xorl %esi, %esi
xorl %ecx, %ecx
cmpq %rcx, %rdx
je 0x54b0
movq %rsi, %rdi
sarq $0x20, %rdi
movzbl (%rax,%rdi), %edi
cmpl $0xa, %edi
je 0x54bb
cmpl $0xd, %edi
je 0x54b4
incq %rcx
addq %rbp, %rsi
jmp 0x548e
xorl %ecx, %ecx
jmp 0x54c1
movq %rcx, %rdx
pushq $0x2
jmp 0x54c0
movq %rcx, %rdx
pushq $0x1
popq %rcx
movq %r15, %rdi
xorl %esi, %esi
callq 0x53e0
movq %rax, %r13
movq %rdx, %rbx
movq %rax, 0x20(%r14)
movq %rdx, 0x28(%r14)
movq 0x8(%rsp), %rdi
callq 0x5368
movq %rax, %r12
movq %rbx, %rax
shrq $0x38, %rax
xorl $0xf, %eax
testq %rbx, %rbx
cmovsq %rbx, %rax
movl %eax, %eax
cmpq %rax, %r12
jne 0x5530
cmpb $0x0, 0x14(%rsp)
jne 0x5462
leaq 0x25ec9(%rip), %rbx     # 0x2b3d9
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x42ce
addq $0x40, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x438e
movb $0x1, %bl
jmp 0x558a
movzbl 0x4f(%r14), %eax
movl %eax, %ecx
xorl $0xf, %ecx
testb %al, %al
cmovsl 0x48(%r14), %ecx
leaq 0x40(%r14), %r15
movq 0x40(%r14), %rsi
cmovnsq %r15, %rsi
cmpq %r12, %rcx
movq %r12, %rdx
cmovbq %rcx, %rdx
testq %rbx, %rbx
movq 0x8(%rsp), %r14
cmovnsq %r14, %r13
movq %r13, %rdi
callq 0x3380
testl %eax, %eax
sete %bl
movq %r14, %rdi
xorl %esi, %esi
movl %r12d, %edx
xorl %ecx, %ecx
callq 0x53e0
movq %r15, %rdi
movq %rax, %rsi
callq 0x5682
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/bmlwrite.cpp
// Function: bmlwriter::type_core(cstring)
bmlwriter::mode bmlwriter::type_core(cstring val)
{
	if (val == "") return anon;
	
	char first = val[0];
	char last = val[val.length()-1];
	
	if (val.contains("\n") || first==' ' || first=='\t' || last==' ' || last=='\t') return multiline;
	if (val.contains("\"")) return col;
	if (val.contains(" ") || val.contains("\t")) return quote;
	return eq;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rsi, %rax
shrq $0x38, %rax
cmpq $0xf, %rax
jne 0x5b1a
pushq $0x4
jmp 0x5bd4
xorl $0xf, %eax
testq %rsi, %rsi
leaq 0x8(%rsp), %rbx
cmovnsq %rbx, %rdi
cmovnsl %eax, %esi
movb (%rdi), %bpl
decl %esi
movslq %esi, %rax
movb (%rdi,%rax), %r15b
leaq 0x22da8(%rip), %rsi     # 0x288e7
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0x42ce
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x5f5a
movl %eax, %ecx
pushq $0x8
popq %rax
cmpb $0x9, %r15b
je 0x5bd5
cmpb $0x20, %r15b
je 0x5bd5
cmpb $0x9, %bpl
je 0x5bd5
cmpb $0x20, %bpl
je 0x5bd5
testb %cl, %cl
jne 0x5bd5
leaq 0x227cc(%rip), %rsi     # 0x2834f
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
callq 0x42ce
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
leaq 0x8(%rsp), %rdi
callq 0x5f5a
testb %al, %al
je 0x5ba9
pushq $0x7
jmp 0x5bd4
leaq 0x22ecc(%rip), %rsi     # 0x28a7c
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x42ce
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
leaq 0x8(%rsp), %rdi
callq 0x5f5a
testb %al, %al
je 0x5be0
pushq $0x6
popq %rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x227e8(%rip), %rsi     # 0x283cf
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x42ce
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
leaq 0x8(%rsp), %rdi
callq 0x5f5a
movzbl %al, %eax
addl $0x5, %eax
jmp 0x5bd5
nop
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/bmlwrite.cpp
// Function: bmlwriter::escape(cstring)
string bmlwriter::escape(cstring val)
{
	string esc = "-";
	bool needescape = (val.startswith("-"));
	for (uint8_t c : val.bytes())
	{
		if (isalnum(c) || c=='.') esc+=c;
		else if (c=='-') esc+="--";
		else { esc+="-"+tostringhex<2>((uint8_t)c); needescape=true; }
	}
	if (needescape) return esc;
	else return val;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, (%rsp)
leaq 0x28(%rsp), %r14
movq %rsi, (%r14)
movq %rdx, 0x8(%r14)
leaq 0x224b2(%rip), %rbx     # 0x280e5
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x4242
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x42ce
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x14a3e
movl %eax, %ebx
movzbl 0xf(%r14), %ebp
testb %bpl, %bpl
jns 0x5c76
movl 0x30(%rsp), %ebp
movq 0x28(%rsp), %r14
jmp 0x5c7a
xorq $0xf, %rbp
xorl %r13d, %r13d
leaq 0x2300c(%rip), %r12     # 0x28c90
leaq 0x8(%rsp), %r15
cmpq %r13, %rbp
je 0x5d24
movzbl (%r14,%r13), %eax
movzbl %al, %esi
cmpq $0x2e, %rax
je 0x5cbe
movb (%r12,%rax), %cl
andb $0x60, %cl
jne 0x5cbe
cmpb $0x2d, %al
jne 0x5cc8
movq %r15, %rdi
leaq 0x223f6(%rip), %rsi     # 0x280ad
callq 0x426a
jmp 0x5d1c
movq %r15, %rdi
callq 0x4354
jmp 0x5d1c
leaq 0x18(%rsp), %rdi
callq 0x5fb3
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq %r12, %rbx
leaq 0x38(%rsp), %r12
movq %r12, %rdi
leaq 0x223f7(%rip), %rsi     # 0x280e5
callq 0x41b8
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq %r15, %rdi
callq 0x4296
movq %r12, %rdi
movq %rbx, %r12
callq 0x56b4
leaq 0x18(%rsp), %rdi
callq 0x56b4
movb $0x1, %bl
incq %r13
jmp 0x5c89
testb $0x1, %bl
je 0x5d41
movups 0x8(%rsp), %xmm0
movq (%rsp), %rbx
movups %xmm0, (%rbx)
movb $0xf, 0x17(%rsp)
movb $0x0, 0x8(%rsp)
jmp 0x5d5a
movups 0x28(%rsp), %xmm0
leaq 0x38(%rsp), %rsi
movups %xmm0, (%rsi)
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x14754
leaq 0x8(%rsp), %rdi
callq 0x56b4
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/bmlwrite.cpp
// Function: bmlwriter::unescape(cstring)
string bmlwriter::unescape(cstring val)
{
	if (!val.startswith("-")) return val;
	
	string out;
	for (size_t i=1;i<val.length();i++)
	{
		if (val[i]=='-')
		{
			uint8_t tmp;
			if (val[i+1]=='-')
			{
				i++;
				out += '-';
			}
			else if (fromstringhex(val.substr(i+1, i+3), tmp))
			{
				i += 2;
				out += tmp;
			}
		}
		else out += val[i];
	}
	return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %rsi, (%r14)
movq %rdx, 0x8(%r14)
leaq 0x2234e(%rip), %rsi     # 0x280e5
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x42ce
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x14a3e
testb %al, %al
je 0x5e44
movb $0xf, 0xf(%rbx)
movb $0x0, (%rbx)
pushq $0x1
popq %r12
leaq 0x18(%rsp), %r15
movzbl 0x17(%rsp), %ecx
movl %ecx, %eax
xorl $0xf, %eax
testb %cl, %cl
cmovsl 0x10(%rsp), %eax
cmpq %rax, %r12
jae 0x5e59
movq %r14, %rax
testb %cl, %cl
jns 0x5ded
movq 0x8(%rsp), %rax
movslq %r12d, %rcx
movb (%rax,%rcx), %cl
cmpb $0x2d, %cl
jne 0x5e34
leaq 0x1(%r12), %rsi
movslq %esi, %rdx
movb $0x2d, %cl
cmpb $0x2d, (%rax,%rdx)
jne 0x5e0d
movq %rsi, %r12
jmp 0x5e34
leal 0x3(%r12), %edx
movq %r14, %rdi
callq 0x55aa
movq %rax, %rdi
movq %rdx, %rsi
movq %r15, %rdx
callq 0x168ca
testb %al, %al
je 0x5e3f
addq $0x2, %r12
movb 0x18(%rsp), %cl
movzbl %cl, %esi
movq %rbx, %rdi
callq 0x4354
incq %r12
jmp 0x5dcb
movups 0x8(%rsp), %xmm0
leaq 0x18(%rsp), %rsi
movups %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x14754
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/bmlwrite.cpp
// Function: bmlwriter::indent()
inline string bmlwriter::indent()
{
	string ret;
	arrayvieww<uint8_t> bytes = ret.construct(m_indent*2);
	memset(bytes.ptr(), ' ', m_indent*2);
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb $0xf, 0xf(%rdi)
movb $0x0, (%rdi)
movslq 0x10(%rsi), %rdx
addq %rdx, %rdx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4af2
movq (%r15), %rdi
movslq 0x10(%rbx), %rdx
addq %rdx, %rdx
pushq $0x20
popq %rsi
callq 0x3170
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/bytepipe.cpp
// Function: bytepipe::try_swap()
void bytepipe::try_swap()
{
	if (buf1st == buf1end && buf2end != 0)
	{
		buf1.swap(buf2);
		buf1st = buf2st;
		buf1end = buf2end;
		buf2st = 0;
		buf2end = 0;
	}
}

// Assembly:
movq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
jne 0x6008
movq 0x38(%rdi), %rax
testq %rax, %rax
je 0x6008
movq 0x20(%rdi), %rcx
movups (%rdi), %xmm0
movups 0x28(%rdi), %xmm1
movups %xmm0, 0x20(%rdi)
movq %rcx, (%rdi)
movups %xmm1, 0x8(%rdi)
movq %rax, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/bytepipe.cpp
// Function: bytepipe::push_begin(unsigned long)
bytesw bytepipe::push_begin(size_t nbytes)
{
	if (buf2.size() - buf2end < nbytes)
		try_swap();
	if (buf2.size() - buf2end < nbytes)
	{
		size_t b2s = buf2.size();
		while (b2s-buf2end < nbytes)
			b2s *= 2;
		buf2.resize(b2s);
	}
	return buf2.skip(buf2end);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rsi), %rdx
movq 0x38(%rsi), %rax
movq %rdx, %rcx
subq %rax, %rcx
cmpq %r15, %rcx
jae 0x6088
movq %r14, %rdi
callq 0x5fd4
movq 0x28(%r14), %rdx
movq 0x38(%r14), %rax
movq %rdx, %rcx
subq %rax, %rcx
leaq 0x20(%r14), %r12
cmpq %r15, %rcx
jae 0x60b5
movq %rdx, %rsi
movq %rdx, %rcx
subq %rax, %rcx
addq %rdx, %rdx
cmpq %r15, %rcx
jb 0x6091
movq %r12, %rdi
callq 0xbaee
movq 0x28(%r14), %rcx
movq 0x38(%r14), %rax
subq %rax, %rcx
addq (%r12), %rax
movq %rax, (%rbx)
movq %rcx, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/bytepipe.cpp
// Function: bytepipe::pull_begin(unsigned long)
bytesw bytepipe::pull_begin(size_t nbytes)
{
	// - if the requested amount doesn't exist, just say so
	// - if buf1 is empty, swap the buffers
	// - if the requested amount exists in buf1 (after the swap, if applicable), return that
	// - if the requested amount fits in buf1, memmove+memcpy and set buf2st nonzero
	// - else an allocation must be made
	if (size() < nbytes)
	{
		return {};
	}
	try_swap();
	size_t size1 = buf1end - buf1st;
	if (size1 >= nbytes)
	{
		return buf1.slice(buf1st, size1);
	}
	if (nbytes <= buf1.size())
	{
		size_t size2 = nbytes - size1;
		if (buf1st != 0)
			memmove(buf1.ptr(), buf1.ptr()+buf1st, size1);
		memcpy(buf1.ptr()+size1, buf2.ptr()+buf2st, size2);
		buf1st = 0;
		buf1end = nbytes;
		buf2st += size2;
		return buf1.slice(0, nbytes);
	}
	else
	{
		size_t size2 = buf2end-buf2st;
		bytearray newbuf;
		newbuf.resize(bitround(size()));
		memcpy(newbuf.ptr(), buf1.ptr()+buf1st, size1);
		memcpy(newbuf.ptr()+size1, buf2.ptr()+buf2st, size2);
		buf1 = std::move(newbuf);
		buf1st = 0;
		buf1end = size1+size2;
		buf2st = 0;
		buf2end = 0;
		return buf1.slice(0, buf1end);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rcx
addq 0x38(%rsi), %rcx
addq 0x30(%rsi), %rax
subq %rax, %rcx
cmpq %rdx, %rcx
jae 0x6104
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x6231
movq %rdx, %r12
movq %rsi, %r14
movq %rsi, %rdi
callq 0x5fd4
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rax
movq %rax, %r15
subq %rsi, %r15
movq %r12, %r13
subq %r15, %r13
jbe 0x61e5
cmpq %r12, 0x8(%r14)
jae 0x61f1
leaq 0x30(%r14), %rbp
movq 0x30(%r14), %rcx
movq 0x38(%r14), %r12
xorps %xmm0, %xmm0
movq %rsp, %r13
movaps %xmm0, (%r13)
addq %r12, %rax
subq %rcx, %r12
addq %rcx, %rsi
subq %rsi, %rax
leaq -0x1(%rax), %rcx
bsrq %rcx, %rcx
pushq $0x2
popq %rdx
shlq %cl, %rdx
cmpq $0x2, %rax
pushq $0x1
popq %rsi
cmovaeq %rdx, %rsi
movq %r13, %rdi
callq 0xbaee
movq (%r13), %rdi
movq (%r14), %rsi
addq 0x10(%r14), %rsi
movq %r15, %rdx
callq 0x3280
movq (%r13), %rdi
addq %r15, %rdi
movq 0x20(%r14), %rsi
addq 0x30(%r14), %rsi
movq %r12, %rdx
callq 0x3280
movaps (%r13), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r13)
movq (%r14), %rdi
movups %xmm0, (%r14)
callq 0x3430
andq $0x0, 0x10(%r14)
addq %r15, %r12
movq %r12, 0x18(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rbp)
movq (%r14), %rax
movq %rax, (%rbx)
movq %r12, 0x8(%rbx)
movq (%r13), %rdi
callq 0x3430
jmp 0x6231
addq (%r14), %rsi
movq %rsi, (%rbx)
movq %r15, 0x8(%rbx)
jmp 0x6231
testq %rsi, %rsi
je 0x6204
movq (%r14), %rdi
addq %rdi, %rsi
movq %r15, %rdx
callq 0x3600
addq (%r14), %r15
movq 0x20(%r14), %rsi
addq 0x30(%r14), %rsi
movq %r15, %rdi
movq %r13, %rdx
callq 0x3280
andq $0x0, 0x10(%r14)
movq %r12, 0x18(%r14)
addq %r13, 0x30(%r14)
movq (%r14), %rax
movq %rax, (%rbx)
movq %r12, 0x8(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/bytepipe.cpp
// Function: bytepipe::pull_line(unsigned long)
bytesr bytepipe::pull_line(size_t skip)
{
	size_t skipped = 0;
	bytesr chunk1 = buf1.slice(buf1st, buf1end-buf1st);
	if (skip <= chunk1.size())
	{
		chunk1 = chunk1.skip(skip);
		skipped += skip;
		skip = 0;
		const uint8_t * nl1 = (uint8_t*)memchr(chunk1.ptr(), '\n', chunk1.size());
		if (nl1)
			return pull(skipped + nl1+1 - chunk1.ptr());
	}
	else
	{
		skip -= chunk1.size();
	}
	
	bytesr chunk2 = buf2.slice(buf2st, buf2end-buf2st);
	chunk2 = chunk2.skip(skip);
	skipped += skip;
	const uint8_t * nl2 = (uint8_t*)memchr(chunk2.ptr(), '\n', chunk2.size());
	if (nl2)
		return pull(skipped + nl2+1 - chunk2.ptr() + chunk1.size());
	
	return {};
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %r12
movq 0x18(%rdi), %rax
subq %r12, %rax
movq %rax, %r15
subq %rsi, %r15
jae 0x6278
movq %r14, %r13
subq %rax, %r13
xorl %r14d, %r14d
movq %rax, %r15
jmp 0x62ab
addq (%rbx), %r12
addq %r14, %r12
pushq $0xa
popq %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x33b0
testq %rax, %rax
je 0x62a8
addq %r14, %rax
subq %r12, %rax
incq %rax
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
jmp 0x62e6
xorl %r13d, %r13d
movq 0x38(%rbx), %rdx
movq 0x30(%rbx), %r12
addq %r13, %r12
subq %r12, %rdx
addq 0x20(%rbx), %r12
pushq $0xa
popq %rsi
movq %r12, %rdi
callq 0x33b0
testq %rax, %rax
je 0x62f4
addq %r14, %rax
addq %r13, %rax
subq %r12, %r15
leaq (%r15,%rax), %rdx
incq %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x639c
movq (%r14), %rax
movq 0x8(%r14), %rdx
jmp 0x62f8
xorl %edx, %edx
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/bytepipe.cpp
// Function: bytepipe::reset(unsigned long)
void bytepipe::reset(size_t bufsize)
{
	buf1.resize(bufsize);
	buf1st = 0;
	buf1end = 0;
	buf2.resize(bufsize);
	buf2st = 0;
	buf2end = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xbaee
leaq 0x20(%r14), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq %rbx, %rsi
callq 0xbaee
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/crc32.cpp
// Function: crc32_update(arrayview<unsigned char>, unsigned int)
uint32_t crc32_update(arrayview<uint8_t> data, uint32_t crc)
{
#ifdef runtime__PCLMUL__
	// crc32_small is slow per byte, but pclmul has a pretty high constant factor; small wins for size <= 4
	// (crc32_small needs to exist for machines without pclmul support)
	if (data.size() >= 4 && runtime__PCLMUL__) return crc32_pclmul(data, crc);
#endif
	return crc32_small(data, crc);
}

// Assembly:
cmpq $0x4, %rsi
jb 0x647e
leaq 0x3ae5b(%rip), %rax     # 0x412d4
testb $0x2, (%rax)
jne 0x64c2
xorl %eax, %eax
leaq 0x21ee9(%rip), %rcx     # 0x28370
cmpq %rax, %rsi
je 0x64bf
movzbl (%rdi,%rax), %r8d
movl %r8d, %r9d
xorl %edx, %r9d
shrl $0x4, %edx
andl $0xf, %r9d
xorl (%rcx,%r9,4), %edx
movl %edx, %r9d
shrl $0x4, %r9d
andl $0xf, %edx
shrl $0x4, %r8d
xorl %edx, %r8d
xorl (%rcx,%r8,4), %r9d
incq %rax
movl %r9d, %edx
jmp 0x6487
movl %edx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/crc32.cpp
// Function: crc32_poly_exp(int)
static inline constexpr uint32_t crc32_poly_exp(int dist)
{
	uint32_t out = 1;
	while (dist > 0)
	{
		uint32_t eor = -(out&1) & 0xEDB88320;
		out = eor ^ (out>>1);
		dist--;
	}
	while (dist < 0)
	{
		uint32_t eor = -(out>>31) & 0xDB710641;
		out = (out<<1) ^ eor;
		dist++;
	}
	return out;
}

// Assembly:
pushq $0x1
popq %rax
movl %edi, %ecx
testl %ecx, %ecx
jle 0x6961
movl %eax, %edx
andl $0x1, %edx
negl %edx
andl $0xedb88320, %edx       # imm = 0xEDB88320
shrl %eax
xorl %edx, %eax
decl %ecx
jmp 0x6948
movl %edi, %ecx
sarl $0x1f, %ecx
andl %edi, %ecx
testl %ecx, %ecx
je 0x697f
movl %eax, %edx
sarl $0x1f, %edx
andl $0xdb710641, %edx       # imm = 0xDB710641
addl %eax, %eax
xorl %edx, %eax
incl %ecx
jmp 0x6968
retq
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/debug.cpp
// Function: debug_break(char const*)
bool debug_break(const char * text)
{
	if (RUNNING_ON_VALGRIND) VALGRIND_PRINTF_BACKTRACE("%s", text);
	else if (has_debugger()) raise(SIGTRAP);
	else return false;
	return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1018, %rsp           # imm = 0x1018
leaq 0x10(%rsp), %rax
movq $0x1001, (%rax)         # imm = 0x1001
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rcx, 0x28(%rax)
xorl %edx, %edx
rolq $0x3, %rdi
rolq $0xd, %rdi
rolq $0x3d, %rdi
rolq $0x33, %rdi
xchgq %rbx, %rbx
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rax
testl %eax, %eax
je 0x69dd
movq %rdi, %rsi
xorl %eax, %eax
callq 0x6a4c
movb $0x1, %al
jmp 0x6a37
leaq 0x219cf(%rip), %rdi     # 0x283b3
xorl %esi, %esi
xorl %eax, %eax
callq 0x3230
testl %eax, %eax
js 0x6a35
movl %eax, %ebx
leaq 0x10(%rsp), %rsi
movl $0xfff, %edx            # imm = 0xFFF
movl %eax, %edi
callq 0x3500
movq %rax, %r14
movl %ebx, %edi
callq 0x3700
testq %r14, %r14
js 0x6a35
movb $0x0, 0x10(%rsp,%r14)
leaq 0x219a5(%rip), %rsi     # 0x283c5
leaq 0x10(%rsp), %rdi
callq 0x30b0
testq %rax, %rax
je 0x6a35
cmpb $0x30, 0xb(%rax)
jne 0x6a42
xorl %eax, %eax
addq $0x1018, %rsp           # imm = 0x1018
popq %rbx
popq %r14
retq
pushq $0x5
popq %rdi
callq 0x3360
jmp 0x69d9
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/debug.cpp
// Function: debug_log(char const*)
void debug_log(const char * text)
{
	synchronized(log_mut) { 
		if (log_count > 20) return;
		log_count++;
		
		debug_log_raw(text);
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x3a6f2(%rip), %rdi     # 0x412e0
callq 0x3520
movl 0x3a70f(%rip), %eax     # 0x41308
cmpl $0x14, %eax
jg 0x6c0e
incl %eax
movl %eax, 0x3a702(%rip)     # 0x41308
movq %rbx, %rdi
callq 0x6b8b
leaq 0x3a6cb(%rip), %rdi     # 0x412e0
popq %rbx
jmp 0x3250
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/deflate-decomp.cpp
// Function: inflator::bits_refill_fast()
void inflator::bits_refill_fast()
{
	if (m_in_nbits&32) return;
	if (LIKELY(m_in_end - m_in_at >= 4))
	{
		m_in_bits_buf |= (uint64_t)readu_le32(m_in_at) << m_in_nbits;
		m_in_nbits += 32;
		m_in_at += 4;
	}
	else bits_refill_all(); // refill to max (after this, m_in is known empty)
}

// Assembly:
movl 0x4(%rdi), %ecx
testb $0x20, %cl
jne 0x6cc4
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rdx
subq %rax, %rdx
cmpq $0x4, %rdx
jl 0x6cc6
movl (%rax), %edx
shlq %cl, %rdx
orq %rdx, 0x8(%rdi)
orl $0x20, %ecx
movl %ecx, 0x4(%rdi)
addq $0x4, %rax
movq %rax, 0x10(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/deflate-decomp.cpp
// Function: inflator::inflate(arrayview<unsigned char>)
bytearray inflator::inflate(bytesr in)
{
	inflator 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 %rbx
subq $0x12f0, %rsp           # imm = 0x12F0
movq %rdx, %r15
xorl %eax, %eax
leaq 0x28(%rsp), %r14
movb %al, (%r14)
movb %al, 0x2(%r14)
andq $0x0, 0x30(%r14)
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%r14)
movups %xmm0, 0x10(%r14)
pushq $0x1
popq %rcx
movq %r14, %rdi
callq 0x7922
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
shll $0x3, %r15d
cmpl $0x1001, %r15d          # imm = 0x1001
movl $0x1000, %esi           # imm = 0x1000
cmovgel %r15d, %esi
movq %rbx, %rdi
callq 0xbaee
movq (%rbx), %rax
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%rsi)
movq %r14, %rdi
callq 0x7948
leaq 0x8(%rsp), %r15
movq %r14, %rdi
callq 0x6d6c
cmpl $0x3, %eax
jne 0x783f
movq 0x8(%rbx), %rsi
addq %rsi, %rsi
movq %rbx, %rdi
callq 0xbaee
movq (%rbx), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rbx), %rax
movq %rax, 0x10(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x7982
jmp 0x7805
testl %eax, %eax
jne 0x786d
movq 0x40(%rsp), %rax
subq 0x38(%rsp), %rax
movl 0x2c(%rsp), %ecx
shrl $0x3, %ecx
addq %rax, %rcx
jne 0x786d
movq 0x58(%rsp), %rsi
subq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0xbaee
jmp 0x7875
movq %rbx, %rdi
callq 0xbc86
movq %rbx, %rax
addq $0x12f0, %rsp           # imm = 0x12F0
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/deflate-decomp.cpp
// Function: inflator::inflate(arrayvieww<unsigned char>, arrayview<unsigned char>)
bool inflator::inflate(bytesw out, bytesr in)
{
	inflator 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 %r15
pushq %r14
pushq %rbx
subq $0x12e0, %rsp           # imm = 0x12E0
xorl %ebx, %ebx
leaq 0x18(%rsp), %r15
movb %bl, (%r15)
movb %bl, 0x2(%r15)
andq $0x0, 0x30(%r15)
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%r15)
movups %xmm0, 0x10(%r15)
pushq $0x1
popq %rcx
movq %r15, %rdi
callq 0x7922
movq (%r14), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rsi)
movq %r15, %rdi
callq 0x7948
movq %r15, %rdi
callq 0x6d6c
testl %eax, %eax
jne 0x7912
movq 0x48(%rsp), %rax
subq 0x40(%rsp), %rax
cmpq 0x8(%r14), %rax
jne 0x7910
movq 0x30(%rsp), %rax
subq 0x28(%rsp), %rax
movl 0x1c(%rsp), %ecx
shrl $0x3, %ecx
addq %rax, %rcx
sete %bl
jmp 0x7912
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x12e0, %rsp           # imm = 0x12E0
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/deflate.h
// Function: inflator::set_input(arrayview<unsigned char>, bool)
void set_input(bytesr by, bool last)
	{
#ifndef ARLIB_OPT
		if (m_in_at != m_in_end) abort();
		if (m_in_last) abort();
#endif
		m_in_at = by.ptr();
		m_in_end = by.ptr()+by.size();
		m_in_last = last;
	}

// Assembly:
pushq %rax
movq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
jne 0x7943
cmpb $0x1, 0x2(%rdi)
je 0x7943
movq %rsi, 0x10(%rdi)
addq %rsi, %rdx
movq %rdx, 0x18(%rdi)
movb %cl, 0x2(%rdi)
popq %rax
retq
callq 0x3180
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/deflate.h
// Function: inflator::set_output_first(arrayvieww<unsigned char>)
void set_output_first(bytesw by)
	{
#ifndef ARLIB_OPT
		if (m_out_at) abort();
		if (!by) by = bytesw((uint8_t*)"", 0); // so the m_out_at check on set_output_grow passes if input is null
#endif
		m_out_prev = NULL;
		m_out_start = by.ptr();
		m_out_at = by.ptr();
		m_out_end = by.ptr()+by.size();
	}

// Assembly:
cmpq $0x0, 0x30(%rdi)
jne 0x797c
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x795d
movq (%rsi), %rcx
jmp 0x7967
leaq 0x23a75(%rip), %rcx     # 0x2b3d9
movq %rcx, (%rsi)
andq $0x0, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq %rcx, 0x30(%rdi)
addq %rcx, %rax
movq %rax, 0x38(%rdi)
retq
pushq %rax
callq 0x3180
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/deflate.h
// Function: inflator::set_output_grow(arrayvieww<unsigned char>)
void set_output_grow(bytesw by)
	{
#ifndef ARLIB_OPT
		if (!m_out_at) abort();
		if (m_out_at != m_out_end) abort();
		if (by.size() < (size_t)(m_out_end-m_out_start)) abort();
#endif
		size_t off = m_out_at-m_out_start;
		m_out_start = by.ptr();
		m_out_at = by.ptr()+off;
		m_out_end = by.ptr()+by.size();
	}

// Assembly:
pushq %rax
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x79b6
cmpq 0x38(%rdi), %rax
jne 0x79b6
movq 0x8(%rsi), %rcx
subq 0x28(%rdi), %rax
cmpq %rax, %rcx
jb 0x79b6
movq (%rsi), %rdx
movq %rdx, 0x28(%rdi)
addq %rdx, %rax
movq %rax, 0x30(%rdi)
addq %rdx, %rcx
movq %rcx, 0x38(%rdi)
popq %rax
retq
callq 0x3180
nop
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/dylib.cpp
// Function: dylib::init(char const*)
bool dylib::init(const char * filename)
{
#ifndef ARLIB_OPT
	if (handle) abort();
#endif
	//synchronized(dylib_lock)
	{
		handle = dlopen(filename, RTLD_LAZY);
	}
	return handle;
}

// Assembly:
pushq %rbx
cmpq $0x0, (%rdi)
jne 0x79de
movq %rdi, %rbx
pushq $0x1
popq %rax
movq %rsi, %rdi
movl %eax, %esi
callq 0x34c0
movq %rax, (%rbx)
testq %rax, %rax
setne %al
popq %rbx
retq
callq 0x3180
nop
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/dylib.cpp
// Function: dylib::sym_multi(void (**)(), char const*)
bool dylib::sym_multi(funcptr* out, const char * names)
{
	bool all = true;
	
	while (*names)
	{
		*out = this->sym_func(names);
		if (!*out) all = false;
		
		out++;
		names += strlen(names)+1;
	}
	
	return all;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movb $0x1, %bl
cmpb $0x0, (%r14)
je 0x7a4f
movq %r12, %rdi
movq %r14, %rsi
callq 0x79e4
movq %rax, (%r15)
testq %rax, %rax
setne %al
andb %al, %bl
addq $0x8, %r15
movq %r14, %rdi
callq 0x30f0
addq %rax, %r14
incq %r14
jmp 0x7a1f
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/file-unix.cpp
// Function: file::open_impl_fs(cstring, file::mode)
file::impl* file::open_impl_fs(cstring filename, mode m)
{
	static const int flags[] = { O_RDONLY, O_RDWR|O_CREAT, O_RDWR, O_RDWR|O_CREAT|O_TRUNC, O_RDWR|O_CREAT|O_EXCL };
	int fd = ::open(filename.c_str(), flags[m]|O_CLOEXEC, 0644);
	if (fd<0) return NULL;
	
	struct stat st;
	fstat(fd, &st);
	if (!S_ISREG(st.st_mode)) // no opening directories
	{
		::close(fd);
		return NULL;
	}
	
	return new file_unix(fd);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movl %edx, %ebx
movq %rsp, %rax
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x7ff6
movq (%r14), %rdi
movl %ebx, %eax
leaq 0x20979(%rip), %rcx     # 0x28490
movl $0x80000, %esi          # imm = 0x80000
orl (%rcx,%rax,4), %esi
xorl %ebx, %ebx
movl $0x1a4, %edx            # imm = 0x1A4
xorl %eax, %eax
callq 0x3230
movl %eax, %ebp
movq %r14, %rdi
callq 0x802e
testl %ebp, %ebp
js 0x7b7c
leaq 0x10(%rsp), %rbx
movl %ebp, %edi
movq %rbx, %rsi
callq 0x3640
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rbx), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x7b73
pushq $0x10
popq %rdi
callq 0x3340
movq %rax, %rbx
leaq 0x38b05(%rip), %rax     # 0x40670
movq %rax, (%rbx)
movl %ebp, 0x8(%rbx)
jmp 0x7b7c
movl %ebp, %edi
callq 0x3700
xorl %ebx, %ebx
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/file-unix.cpp
// Function: file::mkdir_fs(cstring)
bool file::mkdir_fs(cstring filename)
{
	int ret = ::mkdir(filename.c_str(), 0755);
	if (ret==0) return true;
	if (ret==-1 && errno==EEXIST)
	{
		struct stat st;
		if (lstat(filename.c_str(), &st) < 0) return false;
		return (S_ISDIR(st.st_mode));
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rsp, %rax
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x7ff6
movq (%r14), %rdi
movl $0x1ed, %esi            # imm = 0x1ED
callq 0x3110
movl %eax, %ebx
movq %r14, %rdi
callq 0x802e
testl %ebx, %ebx
je 0x7c23
cmpl $-0x1, %ebx
jne 0x7c1f
callq 0x3040
cmpl $0x11, (%rax)
jne 0x7c1f
leaq 0x10(%rsp), %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x7ff6
movq (%rbx), %rdi
leaq 0x20(%rsp), %r14
movq %r14, %rsi
callq 0x36f0
testl %eax, %eax
setns %bpl
movq %rbx, %rdi
callq 0x802e
movl 0x18(%r14), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
sete %al
andb %bpl, %al
jmp 0x7c25
xorl %eax, %eax
jmp 0x7c25
movb $0x1, %al
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/file-unix.cpp
// Function: file::listdir(cstring)
array<string> file::listdir(cstring path)
{
	DIR* dir = opendir(path.c_str());
	if (!dir) return NULL;
	
	array<string> ret;
	dirent* ent;
	while ((ent = readdir(dir)))
	{
		// don't use strcmp, its constant overhead is suboptimal at best
		if (UNLIKELY(ent->d_name[0] == '.'))
		{
			if (ent->d_name[1] == '\0') continue;
			if (ent->d_name[1] == '.' && ent->d_name[2] == '\0') continue;
		}
		
		string childpath = path + ent->d_name;
		if (ent->d_type == DT_UNKNOWN)
		{
			struct stat st;
			stat(childpath, &st);
			if (S_ISDIR(st.st_mode)) childpath += "/";
		}
		else if (ent->d_type == DT_DIR) childpath += "/";
		ret.append(std::move(childpath));
	}
	closedir(dir);
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x7ff6
movq (%r15), %rdi
callq 0x3570
movq %rax, %r14
movq %r15, %rdi
callq 0x802e
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
testq %r14, %r14
je 0x7da7
leaq 0x8(%rsp), %r15
leaq 0x21276(%rip), %r12     # 0x28f60
leaq 0x28(%rsp), %r13
movq %r14, %rdi
callq 0x3580
testq %rax, %rax
je 0x7d9f
movq %rax, %rbp
cmpb $0x2e, 0x13(%rax)
je 0x7d7b
movq %rbp, %rcx
addq $0x13, %rcx
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %r15, %rdi
callq 0x5ee3
movzbl 0x12(%rbp), %eax
cmpl $0x4, %eax
je 0x7d58
testl %eax, %eax
jne 0x7d63
cmpb $0x0, 0x17(%rsp)
movq %r15, %rdi
jns 0x7d3e
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x32f0
movl 0x40(%rsp), %eax
movl $0xf000, %ecx           # imm = 0xF000
andl %ecx, %eax
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x7d63
movq %r15, %rdi
movq %r12, %rsi
callq 0x426a
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf338
movq %r15, %rdi
callq 0x56b4
jmp 0x7cef
movzbl 0x14(%rbp), %eax
testl %eax, %eax
je 0x7cef
cmpl $0x2e, %eax
jne 0x7d09
cmpb $0x0, 0x15(%rbp)
jne 0x7d09
jmp 0x7cef
movq %r14, %rdi
callq 0x35f0
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/file-unix.cpp
// Function: file2::open(cstrnul, file2::mode)
bool file2::open(cstrnul filename, mode m)
{
	reset();
	static const int flags[] = {
		O_RDONLY              |O_CLOEXEC, // m_read
		O_RDWR|O_CREAT        |O_CLOEXEC, // m_write
		O_RDWR                |O_CLOEXEC, // m_wr_existing
		O_RDWR|O_CREAT|O_TRUNC|O_CLOEXEC, // m_replace
		O_RDWR|O_CREAT|O_EXCL |O_CLOEXEC  // m_create_excl
	};
	fd = ::open(filename, flags[m&7], 0644);
	if (m & m_exclusive)
	{
		int op;
		if ((m&7) == m_read)
			op = LOCK_SH|LOCK_NB;
		else
			op = LOCK_EX|LOCK_NB;
		if (flock(fd, op) < 0)
			close();
	}
	
	return (fd >= 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r12
movq %rsi, (%r12)
movq %rdx, 0x8(%r12)
callq 0x803e
testq %r14, %r14
cmovsq %r15, %r12
movl %ebp, %r14d
andl $0x7, %r14d
leaq 0x206b7(%rip), %rax     # 0x284b0
movl (%rax,%r14,4), %esi
movq %r12, %rdi
movl $0x1a4, %edx            # imm = 0x1A4
xorl %eax, %eax
callq 0x3230
movl %eax, (%rbx)
testb $0x8, %bpl
je 0x7e31
cmpl $0x1, %r14d
pushq $0x6
popq %rsi
sbbl $0x0, %esi
movl %eax, %edi
callq 0x36d0
testl %eax, %eax
jns 0x7e31
movq %rbx, %rdi
callq 0x803e
cmpl $0x0, (%rbx)
setns %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Alcaro[P]bridges/arlib/file-unix.cpp
// Function: file2::mmap_t::map(arrayview<unsigned char>&, file2&, bool)
void file2::mmap_t::map(bytesr& by, file2& src, bool writable)
{
	by = nullptr;
	
	size_t size = src.size();
	if (!size) return;
	
	uint8_t * data = (uint8_t*)::mmap(NULL, size, PROT_READ | (writable * PROT_WRITE), MAP_SHARED, src.fd, 0);
	if (data == MAP_FAILED) return;
	
	by = { data, size };
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsi, %rdi
callq 0x8054
testq %rax, %rax
je 0x7e94
movq %rax, %r14
movzbl %bpl, %eax
leal 0x1(,%rax,2), %edx
movl (%r15), %r8d
pushq $0x1
popq %rcx
xorl %edi, %edi
movq %r14, %rsi
xorl %r9d, %r9d
callq 0x3680
cmpq $-0x1, %rax
je 0x7e94
movq %rax, (%rbx)
movq %r14, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop