LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: kmyk[P]topcoder-marathon-match-100-same-color-pairs/./SameColorPairs.cpp
// Function: _gnu_cxx::__normal_iterator<std::array<int, 4ul>*, std::vector<std::array<int, 4ul>, std::allocator<std::array<int, 4ul>>>> apply_unreliable_rects<__gnu_cxx::__normal_iterator<std::array<int, 4ul>*, std::vector<std::array<int, 4ul>, std::allocator<std::array<int, 4ul>>>>>(int, std::array<signed char, 10000ul>&, __gnu_cxx::__normal_iterator<std::array<int, 4ul>*, std::vector<std::array<int, 4ul>, std::allocator<std::array<int, 4ul>>>>, __gnu_cxx::__normal_iterator<std::array<int, 4ul>*, std::vector<std::array<int, 4ul>, std::allocator<std::array<int, 4ul>>>>)
InputIterator apply_unreliable_rects(int W, array<int8_t, MAX_H * MAX_W> & board, InputIterator first, InputIterator last) {
    InputIterator it = first;
    for (; first != last; ++ first) {
        int y1 = (*first)[0];
        int x1 = (*first)[1];
        int y2 = (*first)[2];
        int x2 = (*first)[3];
        // assume all conditions except is_valid_pair()
        if (not is_valid_pair(W, board, make_pair(y1, x1), make_pair(y2, x2))) continue;
        board[y1 * W + x1] = -1;
        board[y2 * W + x2] = -1;
        *(it ++) = *first;
    }
    return it;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %edi, -0x1c(%rbp)
movq %rsi, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x7010
testb $0x1, %al
jne 0x11ed5
jmp 0x12005
leaq -0x10(%rbp), %rdi
callq 0x7050
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7070
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x7050
movq %rax, %rdi
movl $0x1, %esi
callq 0x7070
movl (%rax), %eax
movl %eax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x7050
movq %rax, %rdi
movl $0x2, %esi
callq 0x7070
movl (%rax), %eax
movl %eax, -0x34(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x7050
movq %rax, %rdi
movl $0x3, %esi
callq 0x7070
movl (%rax), %eax
movl %eax, -0x38(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x2c(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x15350
movq %rax, -0x40(%rbp)
leaq -0x34(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x15350
movl -0x5c(%rbp), %edi
movq -0x58(%rbp), %rsi
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq 0x36b0
xorb $-0x1, %al
testb $0x1, %al
jne 0x11f8c
jmp 0x11f8e
jmp 0x11ff7
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %eax
imull -0x1c(%rbp), %eax
addl -0x30(%rbp), %eax
movslq %eax, %rsi
callq 0x72a0
movb $-0x1, (%rax)
movq -0x28(%rbp), %rdi
movl -0x34(%rbp), %eax
imull -0x1c(%rbp), %eax
addl -0x38(%rbp), %eax
movslq %eax, %rsi
callq 0x72a0
movb $-0x1, (%rax)
leaq -0x10(%rbp), %rdi
callq 0x7050
movq %rax, -0x68(%rbp)
leaq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x16780
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x7050
movq -0x68(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
leaq -0x10(%rbp), %rdi
callq 0x70a0
jmp 0x11ebf
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x98(%rbp)
addq $0x10, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x58f0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x5920
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x5970
testb $0x1, %al
jne 0x4f23
jmp 0x4f74
leaq -0x40(%rbp), %rdi
callq 0x59a0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
leaq -0x10(%rbp), %rsi
callq 0x3b660
testb $0x1, %al
jne 0x4f47
jmp 0x4f67
movq -0x98(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %r8
callq 0x4b20
jmp 0x500e
jmp 0x4f69
leaq -0x40(%rbp), %rdi
callq 0x59c0
jmp 0x4f10
leaq -0x10(%rbp), %rdi
leaq 0x614ca(%rip), %rsi     # 0x66449
callq 0x59e0
testb $0x1, %al
jne 0x4f8a
jmp 0x4fe1
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x80(%rbp), %rdx
movq -0x78(%rbp), %rcx
leaq -0x70(%rbp), %rdi
leaq 0x5e0ee(%rip), %rsi     # 0x6309b
callq 0x57e0
movq -0x98(%rbp), %rdi
movq -0x70(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x4a90
leaq -0x70(%rbp), %rdi
callq 0x5870
jmp 0x500e
leaq -0x90(%rbp), %rdi
leaq 0x5e0c1(%rip), %rsi     # 0x630b0
callq 0x5890
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
callq 0x4a90
addq $0xa0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movb %sil, %al
movq %rdi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq %rdx, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
movq %r8, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
addq $0x10, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x58f0
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x5920
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x5970
testb $0x1, %al
jne 0x507d
jmp 0x50c1
leaq -0x48(%rbp), %rdi
callq 0x59a0
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movsbl 0x18(%rax), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jne 0x50b4
movq -0x80(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
movq -0x38(%rbp), %r8
callq 0x4b20
jmp 0x512b
jmp 0x50b6
leaq -0x48(%rbp), %rdi
callq 0x59c0
jmp 0x506a
leaq -0x68(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq 0x5e003(%rip), %rax     # 0x630d3
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x5c00
movq -0x88(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5c20
leaq -0x68(%rbp), %rdi
movsbl -0x19(%rbp), %esi
callq 0x5b40
movq -0x80(%rbp), %rdi
movq -0x68(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x4a90
leaq -0x68(%rbp), %rdi
callq 0x5870
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x5720
testb $0x1, %al
jne 0x5163
jmp 0x5184
leaq -0x30(%rbp), %rdi
leaq 0x5df79(%rip), %rsi     # 0x630e7
callq 0x5890
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x4a90
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x63e0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
addq $0x10, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x58f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5920
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x5970
testb $0x1, %al
jne 0x555c
jmp 0x5615
leaq -0x18(%rbp), %rdi
callq 0x59a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
testb $0x1, 0x1b(%rax)
je 0x5605
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x5720
testb $0x1, %al
jne 0x558a
jmp 0x55e2
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x58(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %rcx
leaq -0x48(%rbp), %rdi
leaq 0x5db63(%rip), %rsi     # 0x63114
callq 0x57e0
movq -0x70(%rbp), %rdi
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x4a90
leaq -0x48(%rbp), %rdi
callq 0x5870
jmp 0x5603
leaq -0x68(%rbp), %rdi
leaq 0x5db44(%rip), %rsi     # 0x63131
callq 0x5890
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
callq 0x4a90
jmp 0x5605
jmp 0x5607
leaq -0x18(%rbp), %rdi
callq 0x59c0
jmp 0x5546
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0xf, -0x18(%rbp)
ja 0x607d
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpq -0x18(%rbp), %rax
jae 0x6059
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movl -0x20(%rbp), %edx
movb (%rcx,%rdx), %dl
movl -0x20(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6031
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movb $0x0, (%rdi,%rax)
movl $0xf, %eax
subq -0x18(%rbp), %rax
movb %al, -0x29(%rbp)
callq 0x5ca0
movb -0x29(%rbp), %cl
movb %cl, (%rax)
jmp 0x60b7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x18(%rbp)
jbe 0x608d
callq 0x4180
movq -0x28(%rbp), %rdi
callq 0x5ca0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movb $-0x1, (%rcx)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movl %ecx, 0x8(%rax)
movb -0x19(%rbp), %cl
andb $0x1, %cl
movb %cl, 0xc(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Alcaro[P]bridges/arlib/array.h
// Function: arrayview<unsigned char>::operator==(arrayview<unsigned char>) const
bool operator==(arrayview<T> other) const
	{
		if (size() != other.size()) return false;
		if (this->trivial_comp())
		{
			return memeq(ptr(), other.ptr(), sizeof(T)*size());
		}
		else
		{
			for (size_t i=0;i<size();i++)
			{
				if (!(items[i]==other[i])) return false;
			}
			return true;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq %rdi, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x6290
movq %rax, -0x60(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6290
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
je 0x6106
movb $0x0, -0x31(%rbp)
jmp 0x61e5
callq 0x62b0
testb $0x1, %al
jne 0x6111
jmp 0x6174
movq -0x68(%rbp), %rdi
callq 0x62c0
movq %rax, -0x78(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x62c0
movq -0x68(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0x6290
movq -0x78(%rbp), %rdx
movq -0x70(%rbp), %rcx
shlq $0x0, %rax
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4100
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
movb %al, -0x31(%rbp)
jmp 0x61e5
movq $0x0, -0x58(%rbp)
movq -0x68(%rbp), %rdi
movq -0x58(%rbp), %rax
movq %rax, -0x80(%rbp)
callq 0x6290
movq %rax, %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
jae 0x61e1
movq -0x68(%rbp), %rax
movq (%rax), %rax
movq -0x58(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x84(%rbp)
movq -0x58(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x62e0
movq %rax, %rcx
movl -0x84(%rbp), %eax
movzbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x61d1
movb $0x0, -0x31(%rbp)
jmp 0x61e5
jmp 0x61d3
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x617c
movb $0x1, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq %rax, -0x20(%rbp)
jne 0x65cb
movq -0x20(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x6a30
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %r8
leaq -0x38(%rbp), %rcx
callq 0x6570
leaq -0x38(%rbp), %rdi
callq 0x6a60
jmp 0x661b
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x661b
movq -0x10(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq -0x40(%rbp), %rsi
callq 0x6b00
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
movzbl %al, %edx
andl $0x1, %edx
callq 0x6a80
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x65d3
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x666c
jmp 0x66dd
movq -0x40(%rbp), %rdi
callq 0x6b50
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
shrq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
andq $0x7, %rax
movl %eax, %ecx
movl $0xff, %edx
shll %cl, %edx
xorl $-0x1, %edx
movq -0x38(%rbp), %rax
movzbl (%rax), %ecx
andl %edx, %ecx
movb %cl, (%rax)
movq -0x20(%rbp), %rax
addq $0x7, %rax
andq $-0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
shrq $0x3, %rax
addq %rax, %rdi
movq -0x28(%rbp), %rdx
subq -0x20(%rbp), %rdx
shrq $0x3, %rdx
xorl %esi, %esi
callq 0x4170
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0x6951
movq -0x48(%rbp), %rdi
movb $0x0, -0x21(%rbp)
callq 0x6c00
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x66f0
movq -0x48(%rbp), %rdi
callq 0x6b50
movq -0x38(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x6c20
movq -0x50(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rax
shrq $0x3, %rax
addq %rax, %rsi
movq -0x20(%rbp), %rdx
addq $0x7, %rdx
shrq $0x3, %rdx
callq 0x4280
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x694f
movq -0x48(%rbp), %rdi
callq 0x6a60
jmp 0x69cc
movq -0x48(%rbp), %rdi
movb $0x0, -0x22(%rbp)
callq 0x6c00
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x66f0
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x69b7
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rsi
addq -0x30(%rbp), %rsi
callq 0x6b00
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rsi
movzbl %al, %edx
andl $0x1, %edx
callq 0x6a80
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x6973
movb $0x1, -0x22(%rbp)
testb $0x1, -0x22(%rbp)
jne 0x69ca
movq -0x48(%rbp), %rdi
callq 0x6a60
jmp 0x69cc
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x40, 0x8(%rax)
jbe 0x6cd1
movq -0x28(%rbp), %rdi
movq 0x8(%rdi), %rsi
callq 0x6b90
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d5e0
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6bc0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x4280
jmp 0x6cdf
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x74b0
leaq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5cc0
movsbl %al, %eax
cmpl $0x0, %eax
jl 0x73d5
movq -0x80(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5cc0
movsbl %al, %eax
xorl $0xf, %eax
movzbl %al, %eax
movl %eax, -0x14(%rbp)
jmp 0x73df
movq -0x80(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %edi
callq 0x74d0
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x1ce60
leaq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x74f0
movq -0x38(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x6d50
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x7447
movq -0x90(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1d280
movl $0x1, -0x74(%rbp)
jmp 0x746b
movq -0x50(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x1ce60
movq -0x90(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1d320
movl $0x1, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1d720
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Alcaro[P]bridges/arlib/bmlwrite.cpp
// Function: bmlwriter::type(cstring, bmlwriter::mode) const
bmlwriter::mode bmlwriter::type(cstring val, mode m) const
{
	bool inlined = (m <= icol);
	if (m <= icol) m = (mode)(m+4);
	
	m = max(type_core(val), m);
	if (inlined && m != multiline && m_caninline) return (mode)(m-4);
	else return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $0x3, -0x24(%rbp)
setle %al
andb $0x1, %al
movb %al, -0x25(%rbp)
cmpl $0x3, -0x24(%rbp)
jg 0xaafa
movl -0x24(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xad70
movl %eax, %edi
movl -0x24(%rbp), %esi
callq 0xb0b0
movl %eax, -0x24(%rbp)
testb $0x1, -0x25(%rbp)
je 0xab45
cmpl $0x8, -0x24(%rbp)
je 0xab45
movq -0x40(%rbp), %rax
testb $0x1, 0x14(%rax)
je 0xab45
movl -0x24(%rbp), %eax
subl $0x4, %eax
movl %eax, -0x4(%rbp)
jmp 0xab4b
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
leaq -0x60(%rbp), %rdi
leaq 0x57c32(%rip), %rsi     # 0x630e5
callq 0x58c0
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x37e20
testb $0x1, %al
jne 0xb51d
movq -0xa8(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movq -0x48(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movq -0x70(%rbp), %rdx
movq -0x68(%rbp), %rcx
movq %rdx, -0x20(%rbp)
movq %rcx, -0x18(%rbp)
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x5c00
movq -0xb0(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x37020
jmp 0xb6b6
movq -0xa8(%rbp), %rdi
movb $0x0, -0x71(%rbp)
callq 0x7800
movq $0x1, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5cc0
movsbl %al, %eax
cmpl $0x0, %eax
jl 0xb58a
movq -0xb8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5cc0
movsbl %al, %eax
xorl $0xf, %eax
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
jmp 0xb597
movq -0xb8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0xc0(%rbp), %rax
movl -0x2c(%rbp), %ecx
cmpq %rcx, %rax
jae 0xb69e
movq -0x80(%rbp), %rax
movl %eax, %esi
leaq -0x50(%rbp), %rdi
callq 0xa1c0
movsbl %al, %eax
cmpl $0x2d, %eax
jne 0xb66d
movq -0x80(%rbp), %rax
addq $0x1, %rax
movl %eax, %esi
leaq -0x50(%rbp), %rdi
callq 0xa1c0
movsbl %al, %eax
cmpl $0x2d, %eax
jne 0xb5ff
movq -0xa8(%rbp), %rdi
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
movl $0x2d, %esi
callq 0x5b40
jmp 0xb66b
movq -0x80(%rbp), %rax
addq $0x1, %rax
movl %eax, %esi
movq -0x80(%rbp), %rax
addq $0x3, %rax
movl %eax, %edx
leaq -0x50(%rbp), %rdi
callq 0x9f90
movq %rax, -0x98(%rbp)
movq %rdx, -0x90(%rbp)
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
leaq -0x81(%rbp), %rdx
callq 0x40210
testb $0x1, %al
jne 0xb64a
jmp 0xb669
movq -0xa8(%rbp), %rdi
movq -0x80(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x80(%rbp)
movzbl -0x81(%rbp), %esi
callq 0x9f60
jmp 0xb66b
jmp 0xb68b
movq -0x80(%rbp), %rax
movl %eax, %esi
leaq -0x50(%rbp), %rdi
callq 0xa1c0
movq -0xa8(%rbp), %rdi
movsbl %al, %esi
callq 0x5b40
jmp 0xb68d
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
jmp 0xb535
movb $0x1, -0x71(%rbp)
testb $0x1, -0x71(%rbp)
jne 0xb6b4
movq -0xa8(%rbp), %rdi
callq 0x5870
jmp 0xb6b6
movq -0xa0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x7800
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rax
movl 0x10(%rax), %eax
shll %eax
movslq %eax, %rdx
leaq -0x28(%rbp), %rdi
callq 0x7850
leaq -0x28(%rbp), %rdi
callq 0x7490
movq %rax, %rdi
movq -0x30(%rbp), %rax
movl 0x10(%rax), %eax
shll %eax
movslq %eax, %rdx
movl $0x20, %esi
callq 0x4170
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xb75a
movq -0x38(%rbp), %rdi
callq 0x5870
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq 0x10(%rcx), %rax
cmpq 0x18(%rcx), %rax
jne 0xbbdd
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xbbdd
movq -0x10(%rbp), %rdi
movq %rdi, %rsi
addq $0x20, %rsi
callq 0x1caf0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq %rcx, 0x10(%rax)
movq 0x38(%rax), %rcx
movq %rcx, 0x18(%rax)
movq $0x0, 0x30(%rax)
movq $0x0, 0x38(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x20, %rdi
callq 0x6290
movq -0x28(%rbp), %rcx
subq 0x38(%rcx), %rax
cmpq -0x18(%rbp), %rax
jae 0xbcc7
movq -0x28(%rbp), %rdi
callq 0xbb80
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0x6290
movq -0x28(%rbp), %rcx
subq 0x38(%rcx), %rax
cmpq -0x18(%rbp), %rax
jae 0xbd23
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0x6290
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
subq 0x38(%rcx), %rax
cmpq -0x18(%rbp), %rax
jae 0xbd12
movq -0x20(%rbp), %rax
shlq %rax
movq %rax, -0x20(%rbp)
jmp 0xbcf3
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
movq -0x20(%rbp), %rsi
callq 0x1ce60
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, %rsi
addq $0x20, %rsi
movq 0x38(%rax), %rdx
callq 0xc460
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1ce60
movq -0x18(%rbp), %rdi
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
callq 0x1ce60
movq -0x18(%rbp), %rax
movq $0x0, 0x30(%rax)
movq $0x0, 0x38(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Alcaro[P]bridges/arlib/crc32.cpp
// Function: crc32_small(arrayview<unsigned char>, unsigned int)
static uint32_t crc32_small(arrayview<uint8_t> data, uint32_t crc)
{
	// based on Karl Malbrain's "A compact CCITT crc16 and crc32 C implementation that balances processor cache usage against speed",
	// but the table is backwards, and every entry is xor'd with 0xF0000000, which allows deleting the crc = ~crc at the start and end
	static const uint32_t lookup[] = {
		0x4dbdf21c, 0x500ae278, 0x76d3d2d4, 0x6b64c2b0, 0x3b61b38c, 0x26d6a3e8, 0x000f9344, 0x1db88320,
		0xa005713c, 0xbdb26158, 0x9b6b51f4, 0x86dc4190, 0xd6d930ac, 0xcb6e20c8, 0xedb71064, 0xf0000000,
	};
	for (size_t byte : data)
	{
		crc = (crc>>4) ^ lookup[(crc&0x0F) ^ (byte&0x0F)];
		crc = (crc>>4) ^ lookup[(crc&0x0F) ^ (byte >> 4)];
	}
	return crc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0x14(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xbac0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xbae0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0xdb28
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
shrl $0x4, %eax
movl -0x14(%rbp), %ecx
andl $0xf, %ecx
movl %ecx, %ecx
movl %ecx, %edx
movq -0x38(%rbp), %rcx
andq $0xf, %rcx
xorq %rcx, %rdx
leaq 0x55844(%rip), %rcx     # 0x63330
xorl (%rcx,%rdx,4), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
shrl $0x4, %eax
movl -0x14(%rbp), %ecx
andl $0xf, %ecx
movl %ecx, %ecx
movl %ecx, %edx
movq -0x38(%rbp), %rcx
shrq $0x4, %rcx
xorq %rcx, %rdx
leaq 0x5581c(%rip), %rcx     # 0x63330
xorl (%rcx,%rdx,4), %eax
movl %eax, -0x14(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xdab5
movl -0x14(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x1, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0xdb7e
movl -0x8(%rbp), %ecx
andl $0x1, %ecx
xorl %eax, %eax
subl %ecx, %eax
andl $0xedb88320, %eax       # imm = 0xEDB88320
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl -0x8(%rbp), %ecx
shrl %ecx
xorl %ecx, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xdb4e
jmp 0xdb80
cmpl $0x0, -0x4(%rbp)
jge 0xdbae
movl -0x8(%rbp), %ecx
shrl $0x1f, %ecx
xorl %eax, %eax
subl %ecx, %eax
andl $0xdb710641, %eax       # imm = 0xDB710641
movl %eax, -0x10(%rbp)
movl -0x8(%rbp), %eax
shll %eax
xorl -0x10(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xdb80
movl -0x8(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq $0x1001, -0x40(%rbp)    # imm = 0x1001
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
leaq -0x40(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
rolq $0x3, %rdi
rolq $0xd, %rdi
rolq $0x3d, %rdi
rolq $0x33, %rdi
xchgq %rbx, %rbx
movq %rdx, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpl $0x0, %eax
je 0xdc40
movq -0x10(%rbp), %rsi
leaq 0x55739(%rip), %rdi     # 0x63370
movb $0x0, %al
callq 0xdc70
jmp 0xdc5f
callq 0xdd70
testb $0x1, %al
jne 0xdc4b
jmp 0xdc57
movl $0x5, %edi
callq 0x4360
jmp 0xdc5d
movb $0x0, -0x1(%rbp)
jmp 0xdc63
jmp 0xdc5f
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nop
// File: Alcaro[P]bridges/arlib/debug.cpp
// Function: has_debugger()
static bool has_debugger()
{
	char buf[4096];
	int fd = open("/proc/self/status", O_RDONLY);
	if (fd < 0) return false;
	
	ssize_t bytes = read(fd, buf, sizeof(buf)-1);
	close(fd);
	
	if (bytes < 0) return false;
	buf[bytes] = '\0';
	
	const char * tracer = strstr(buf, "TracerPid:\t");
	if (!tracer) return false;
	tracer += strlen("TracerPid:\t");
	
	return (*tracer != '0');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
leaq 0x555f1(%rip), %rdi     # 0x63373
xorl %esi, %esi
movb $0x0, %al
callq 0x4230
movl %eax, -0x1014(%rbp)
cmpl $0x0, -0x1014(%rbp)
jge 0xdda3
movb $0x0, -0x1(%rbp)
jmp 0xde3c
movl -0x1014(%rbp), %edi
leaq -0x1010(%rbp), %rsi
movl $0xfff, %edx            # imm = 0xFFF
callq 0x44f0
movq %rax, -0x1020(%rbp)
movl -0x1014(%rbp), %edi
callq 0x46f0
cmpq $0x0, -0x1020(%rbp)
jge 0xdddc
movb $0x0, -0x1(%rbp)
jmp 0xde3c
movq -0x1020(%rbp), %rax
movb $0x0, -0x1010(%rbp,%rax)
leaq -0x1010(%rbp), %rdi
leaq 0x5558c(%rip), %rsi     # 0x63385
callq 0x40b0
movq %rax, -0x1028(%rbp)
cmpq $0x0, -0x1028(%rbp)
jne 0xde15
movb $0x0, -0x1(%rbp)
jmp 0xde3c
movq -0x1028(%rbp), %rax
addq $0xb, %rax
movq %rax, -0x1028(%rbp)
movq -0x1028(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopw (%rax,%rax)
// File: Alcaro[P]bridges/arlib/debug.cpp
// Function: debug_log_stack(char const*)
synchronized(log_mut)
	{
		if (log_count > 20) return;
		log_count++;
		
		debug_log_raw(text);
		
		void* addrs[20];
		int n_addrs = backtrace(addrs, ARRAY_SIZE(addrs));
		
		//*
		backtrace_symbols_fd(addrs, n_addrs, STDERR_FILENO);
		backtrace_symbols_fd(addrs, n_addrs, fileno(log_file));
		/*/
		// alternative variant that always prints offset from the start of the executable
		auto debug_log_sym = [](const char * fmt, void* ptr, const char * symname, void* sym_at)
		{
			size_t off = (char*)ptr - (char*)sym_at;
			fprintf(stderr, fmt, symname, off);
			if (log_file) fprintf(log_file, fmt, symname, off);
		};
		for (int i=0;i<n_addrs;i++)
		{
			Dl_info inf;
			dladdr(addrs[i], &inf);
			
			if (inf.dli_fname)
			{
				debug_log_sym("%s+0x%zx", addrs[i], inf.dli_fname, inf.dli_fbase);
				if (inf.dli_sname)
					debug_log_sym(" (%s+0x%zx)", addrs[i], inf.dli_sname, inf.dli_saddr);
			}
			else
			{
				fprintf(stderr, "%p", addrs[i]);
				if (log_file) fprintf(log_file, "%p", addrs[i]);
			}
			debug_log_raw("\n");
		}
		// */
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
leaq 0x73496(%rip), %rsi     # 0x81300
callq 0xe0f0
cmpl $0x14, 0x734b2(%rip)    # 0x81328
jle 0xde84
movl $0x1, -0x14(%rbp)
jmp 0xdf0b
movl 0x7349e(%rip), %eax     # 0x81328
addl $0x1, %eax
movl %eax, 0x73495(%rip)     # 0x81328
movq -0x8(%rbp), %rdi
callq 0xdf20
leaq -0xc0(%rbp), %rdi
movl $0x14, %esi
callq 0x4520
movl %eax, -0xc4(%rbp)
leaq -0xc0(%rbp), %rdi
movl -0xc4(%rbp), %esi
movl $0x2, %edx
callq 0x45d0
leaq -0xc0(%rbp), %rax
movq %rax, -0xd0(%rbp)
movl -0xc4(%rbp), %eax
movl %eax, -0xc8(%rbp)
movq 0x73445(%rip), %rdi     # 0x81330
callq 0x4380
movq -0xd0(%rbp), %rdi
movl -0xc8(%rbp), %esi
movl %eax, %edx
callq 0x45d0
movl $0x0, -0x14(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xe120
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
leaq 0x73359(%rip), %rsi     # 0x81300
callq 0xe0f0
cmpl $0x14, 0x73375(%rip)    # 0x81328
jle 0xdfbe
movl $0x1, -0x14(%rbp)
jmp 0xdfdd
movl 0x73364(%rip), %eax     # 0x81328
addl $0x1, %eax
movl %eax, 0x7335b(%rip)     # 0x81328
movq -0x8(%rbp), %rdi
callq 0xdf20
movl $0x0, -0x14(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xe120
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x4(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0xe1a1
jmp 0xe20c
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rax
movq 0x10(%rcx), %rcx
subq %rcx, %rax
cmpq $0x4, %rax
setge %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xe1c1
jmp 0xe203
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, %edx
movl 0x4(%rax), %ecx
shlq %cl, %rdx
movq %rdx, %rcx
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movl 0x4(%rax), %ecx
addl $0x20, %ecx
movl %ecx, 0x4(%rax)
movq 0x10(%rax), %rcx
addq $0x4, %rcx
movq %rcx, 0x10(%rax)
jmp 0xe20c
movq -0x20(%rbp), %rdi
callq 0xe220
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Alcaro[P]bridges/arlib/deflate-decomp.cpp
// Function: inflator::bits_read_huffman(unsigned short const*)
uint32_t inflator::bits_read_huffman(const uint16_t * huff)
{
#define HUFF_READ_FAST(huff, target)                                                       \
	{                                                                                      \
		uint16_t st = huff[bits_buf&HUFF_FAST_BITS_MASK];                                  \
		while (st & 0x8000)                                                                \
			st = huff[(st&0x7ff) | ((bits_buf>>((st&0x7800) >> 11))&HUFF_SLOW_BITS_MASK)]; \
		                                                                                   \
		size_t bits_discard = st >> 11;                                                    \
		nbits -= bits_discard;                                                             \
		bits_buf >>= bits_discard;                                                         \
		                                                                                   \
		(target) = st&0x01ff;                                                              \
	}
	
	uint32_t target;
#define bits_buf m_in_bits_buf
#define nbits m_in_nbits
	HUFF_READ_FAST(huff, target);
#undef bits_buf
#undef nbits
	return target;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rcx), %rcx
andq $0x1ff, %rcx            # imm = 0x1FF
movw (%rax,%rcx,2), %ax
movw %ax, -0x16(%rbp)
movzwl -0x16(%rbp), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0xe36d
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movzwl -0x16(%rbp), %edx
andl $0x7ff, %edx            # imm = 0x7FF
movslq %edx, %rdx
movq %rdx, -0x30(%rbp)
movq 0x8(%rcx), %rdx
movzwl -0x16(%rbp), %ecx
andl $0x7800, %ecx           # imm = 0x7800
sarl $0xb, %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq -0x30(%rbp), %rcx
andq $0x7, %rdx
orq %rdx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x16(%rbp)
jmp 0xe31b
movq -0x28(%rbp), %rax
movzwl -0x16(%rbp), %ecx
sarl $0xb, %ecx
movslq %ecx, %rcx
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdx
movl 0x4(%rax), %ecx
subq %rdx, %rcx
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rcx
movq 0x8(%rax), %rdx
shrq %cl, %rdx
movq %rdx, %rcx
movq %rcx, 0x8(%rax)
movzwl -0x16(%rbp), %eax
andl $0x1ff, %eax            # imm = 0x1FF
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1330, %rsp           # imm = 0x1330
movq %rdi, -0x1328(%rbp)
movq %rdi, %rax
movq %rax, -0x1330(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
leaq -0x12e0(%rbp), %rdi
callq 0x10060
movq -0x18(%rbp), %rax
movq %rax, -0x12f0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x12e8(%rbp)
movq -0x12f0(%rbp), %rsi
movq -0x12e8(%rbp), %rdx
leaq -0x12e0(%rbp), %rdi
movl $0x1, %ecx
callq 0x10080
movq -0x1328(%rbp), %rdi
movb $0x0, -0x12f1(%rbp)
callq 0x74b0
leaq -0x18(%rbp), %rdi
callq 0x6290
movq %rax, %rsi
shlq $0x3, %rsi
movl $0x1000, %edi           # imm = 0x1000
callq 0xfe40
movq -0x1328(%rbp), %rdi
movslq %eax, %rsi
callq 0x1ce60
movq -0x1328(%rbp), %rsi
leaq -0x1308(%rbp), %rdi
callq 0x74f0
leaq -0x12e0(%rbp), %rdi
leaq -0x1308(%rbp), %rsi
callq 0x10110
leaq -0x12e0(%rbp), %rdi
callq 0xe3b0
movl %eax, -0x130c(%rbp)
cmpl $0x3, -0x130c(%rbp)
jne 0xfdcc
movq -0x1328(%rbp), %rdi
callq 0x6290
movq -0x1328(%rbp), %rdi
movq %rax, %rsi
shlq %rsi
callq 0x1ce60
movq -0x1328(%rbp), %rsi
leaq -0x1320(%rbp), %rdi
callq 0x74f0
leaq -0x12e0(%rbp), %rdi
leaq -0x1320(%rbp), %rsi
callq 0x101d0
jmp 0xfd6b
cmpl $0x0, -0x130c(%rbp)
jne 0xfde7
leaq -0x12e0(%rbp), %rdi
callq 0x102a0
cmpq $0x0, %rax
je 0xfdf5
movq -0x1328(%rbp), %rdi
callq 0x1d1f0
jmp 0xfe10
leaq -0x12e0(%rbp), %rdi
callq 0x102d0
movq -0x1328(%rbp), %rdi
movq %rax, %rsi
callq 0x1ce60
jmp 0xfe12
movb $0x1, -0x12f1(%rbp)
testb $0x1, -0x12f1(%rbp)
jne 0xfe2e
movq -0x1328(%rbp), %rdi
callq 0x1d720
movq -0x1330(%rbp), %rax
addq $0x1330, %rsp           # imm = 0x1330
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1320, %rsp           # imm = 0x1320
movq %rdi, -0x1310(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
leaq -0x12e0(%rbp), %rdi
callq 0x10060
movq -0x10(%rbp), %rax
movq %rax, -0x12f0(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x12e8(%rbp)
movq -0x12f0(%rbp), %rsi
movq -0x12e8(%rbp), %rdx
leaq -0x12e0(%rbp), %rdi
movl $0x1, %ecx
callq 0x10080
movq -0x1310(%rbp), %rsi
leaq -0x1300(%rbp), %rdi
callq 0x74f0
leaq -0x12e0(%rbp), %rdi
leaq -0x1300(%rbp), %rsi
callq 0x10110
leaq -0x12e0(%rbp), %rdi
callq 0xe3b0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1301(%rbp)
jne 0xff6f
leaq -0x12e0(%rbp), %rdi
callq 0x102d0
movq -0x1310(%rbp), %rdi
movq %rax, -0x1318(%rbp)
callq 0x6290
movq -0x1318(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x1301(%rbp)
jne 0xff6f
leaq -0x12e0(%rbp), %rdi
callq 0x102a0
cmpq $0x0, %rax
sete %al
movb %al, -0x1301(%rbp)
movb -0x1301(%rbp), %al
andb $0x1, %al
addq $0x1320, %rsp           # imm = 0x1320
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq 0x10(%rcx), %rax
cmpq 0x18(%rcx), %rax
je 0x100b2
callq 0x4180
movq -0x28(%rbp), %rax
testb $0x1, 0x2(%rax)
je 0x100c1
callq 0x4180
leaq -0x10(%rbp), %rdi
callq 0x62c0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
leaq -0x10(%rbp), %rdi
callq 0x62c0
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x6290
movq -0x30(%rbp), %rcx
movq %rax, %rdx
movq -0x28(%rbp), %rax
addq %rdx, %rcx
movq %rcx, 0x18(%rax)
movb -0x19(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x2(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, 0x30(%rax)
je 0x10138
callq 0x4180
movq -0x40(%rbp), %rdi
callq 0xc600
testb $0x1, %al
jne 0x1016a
leaq -0x20(%rbp), %rdi
leaq 0x562f9(%rip), %rsi     # 0x66449
xorl %eax, %eax
movl %eax, %edx
callq 0x5ed0
movq -0x40(%rbp), %rsi
leaq -0x30(%rbp), %rdi
leaq -0x20(%rbp), %rdx
callq 0x10330
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rdi
movq $0x0, 0x20(%rax)
callq 0x7490
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x28(%rax)
callq 0x7490
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x30(%rax)
callq 0x7490
movq -0x40(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x6290
movq -0x48(%rbp), %rcx
movq %rax, %rdx
movq -0x38(%rbp), %rax
addq %rdx, %rcx
movq %rcx, 0x38(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x30(%rax)
jne 0x101f8
callq 0x4180
movq -0x20(%rbp), %rcx
movq 0x30(%rcx), %rax
cmpq 0x38(%rcx), %rax
je 0x1020b
callq 0x4180
movq -0x28(%rbp), %rdi
callq 0x6290
movq -0x20(%rbp), %rdx
movq 0x38(%rdx), %rcx
movq 0x28(%rdx), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jae 0x1022d
callq 0x4180
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rdi
movq 0x30(%rcx), %rax
movq 0x28(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x18(%rbp)
callq 0x7490
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
callq 0x7490
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq -0x18(%rbp), %rcx
movq %rcx, 0x30(%rax)
callq 0x7490
movq -0x28(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x6290
movq -0x30(%rbp), %rcx
movq %rax, %rdx
movq -0x20(%rbp), %rax
addq %rdx, %rcx
movq %rcx, 0x38(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Alcaro[P]bridges/arlib/deflate.h
// Function: inflator::reset()
void reset()
	{
		m_state = 0;
		m_in_nbits = 0;
		m_in_bits_buf = 0;
#ifndef ARLIB_OPT
		m_in_at = NULL;
		m_in_end = NULL;
		m_in_last = false;
		m_out_at = NULL;
#endif
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movl $0x0, 0x4(%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movb $0x0, 0x2(%rax)
movq $0x0, 0x30(%rax)
popq %rbp
retq
nopl (%rax)