LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Alcaro[P]bridges/arlib/opengl/helpers.cpp
// Function: aropengl_base::create(aropengl_base::context*, char const*, void (**)())
bool aropengl_base::create(context* core, const char * symNames, funcptr* symDest)
{
	destroy();
	
	this->core = core;
#ifdef ARLIB_GUI
	this->port = NULL;
#endif
	if (!core) return false;
	
	while (*symNames)
	{
		*symDest = core->getProcAddress(symNames);
		//nulls here are fine, don't worry about them
		symDest++;
		symNames += strlen(symNames)+1;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x2fa50
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
cmpq $0x0, -0x18(%rbp)
jne 0x2f9ed
movb $0x0, -0x1(%rbp)
jmp 0x2fa37
jmp 0x2f9ef
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2fa33
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x40f0
addq $0x1, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x2f9ef
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Alcaro[P]bridges/arlib/random.cpp
// Function: random_base_t<true>::rand32()
uint32_t random_base_t<true>::rand32()
{
	uint64_t prev = lock_read<lock_loose>(&state);
	while (true)
	{
		uint64_t prev2 = lock_cmpxchg<lock_loose,lock_loose>(&state, prev, prev*multiplier + increment);
		if (prev == prev2) break;
		prev = prev2;
	}
	return permute(prev);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x2fc10
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movabsq $0x5851f42d4c957f2d, %rdx # imm = 0x5851F42D4C957F2D
imulq -0x10(%rbp), %rdx
movabsq $0x14057b7ef767814f, %rax # imm = 0x14057B7EF767814F
addq %rax, %rdx
callq 0x2fc30
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x2fb76
jmp 0x2fb80
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x2fb3d
movq -0x10(%rbp), %rdi
callq 0x2fae0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Alcaro[P]bridges/arlib/random.cpp
// Function: random_base_t<false>::rand_mod(unsigned int)
uint32_t random_base_t<is_global>::rand_mod(uint32_t limit)
{
	// if RAND_MAX+1 is not a multiple of 'limit', rand() mod limit becomes biased towards lower values
	// to avoid that, find the highest multiple of limit <= RAND_MAX+1,
	// and if the returned value is higher than that, discard it and create a new one
	// alternatively and equivalently, that many values can be discarded from the lower end of the results
	// the size of the discarded section must be (RAND_MAX+1) mod limit, and discarding low ones is easier
	
	// unfortunately, RAND_MAX+1 is 2^32, which won't fit in a uint32
	// however, for a >= b, a%b equals (a-b)%b, and UINT32_MAX+1 is always greater than limit
	// the extra -1 +1 needed to avoid an overflow can also be avoided, by using how unsigned integer overflow is defined
	// so the calculation needed is simply
	uint32_t minvalid = -limit % limit;
	
	while (true)
	{
		uint32_t candidate = rand32();
		if (candidate < minvalid) continue;
		return candidate%limit;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
subl -0xc(%rbp), %eax
xorl %edx, %edx
divl -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2fa90
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x2fd5a
jmp 0x2fd44
movl -0x14(%rbp), %eax
xorl %edx, %edx
divl -0xc(%rbp)
movl %edx, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Alcaro[P]bridges/arlib/random.cpp
// Function: random_base_t<false>::rand_mod(unsigned long)
uint64_t random_base_t<is_global>::rand_mod(uint64_t limit)
{
	if (LIKELY(limit <= 0xFFFFFFFF)) return rand_mod((uint32_t)limit);
	uint64_t minvalid = -limit % limit;
	
	while (true)
	{
		uint64_t candidate = rand64();
		if (candidate < minvalid) continue;
		return candidate%limit;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x18(%rbp)
setbe %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2fd9e
jmp 0x2fdb5
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %esi
callq 0x2fd20
movl %eax, %eax
movq %rax, -0x8(%rbp)
jmp 0x2fdf0
xorl %eax, %eax
subq -0x18(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2fce0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x2fde0
jmp 0x2fdc7
movq -0x28(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Alcaro[P]bridges/arlib/runloop-poll.cpp
// Function: runloop2::run(async<void>)
void run(async<void> event)
	{
		waiter<void, void> wait;
		event.then(&wait);
		auto& loop = get_loop();
		while (wait.is_waiting())
			loop.step(true);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x31ce0
movq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x133a0
callq 0x30140
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x31d10
testb $0x1, %al
jne 0x3057e
jmp 0x3058e
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x301b0
jmp 0x3056f
leaq -0x18(%rbp), %rdi
callq 0x31d30
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Alcaro[P]bridges/arlib/runloop-poll.cpp
// Function: (anonymous namespace)::runloop2_poll::fds_t::reallocate(unsigned long)
void reallocate(size_t newsize)
		{
#ifdef EXTRA_POLLFDS
			size_t cursize = max_used;
#else
			size_t cursize = waiting.size();
#endif
			waiting.resize(newsize);
			wait_fd.resize(newsize);
			for (size_t i=0;i<cursize;i++)
				waiting[i].prod.moved();
#ifndef EXTRA_POLLFDS
			for (size_t i=cursize;i<newsize;i++)
				wait_fd[i].fd = ~(i+1);
#endif
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x30870
movq -0x30(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x30890
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x31e40
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x307e4
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x308c0
movq %rax, %rdi
callq 0x308e0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x307b7
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x30829
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
addq $0x1, %rax
xorq $-0x1, %rax
movl %eax, -0x34(%rbp)
addq $0x10, %rdi
movq -0x28(%rbp), %rsi
callq 0x31e70
movl -0x34(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x307ec
addq $0x40, %rsp
popq %rbp
retq
nop
// File: Alcaro[P]bridges/arlib/runloop2.h
// Function: producer<void, (anonymous namespace)::runloop2_poll::fds_t::waiter_node::prod_t>::cancel_s(producer_base<void>*)
static void cancel_s(producer_base<T>* self)
	{
		if (self->wait)
			self->wait->prod = nullptr;
		self->wait = nullptr;
		if constexpr (!std::is_same_v<T2, void>)
		{
			static_assert(std::is_base_of_v<producer, T2>);
			((T2*)self)->cancel();
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x30c84
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x30ca0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: Alcaro[P]bridges/arlib/runloop2.h
// Function: std::enable_if<std::is_same_v<void, void> && std::is_same_v<void, void>, void>::type producer<void, (anonymous namespace)::runloop2_poll::fds_t::waiter_node::prod_t>::complete<void>()
std::enable_if_t<std::is_same_v<T, void> && std::is_same_v<T, Tx>>
	complete()
	{
		waiter_base<T>* wait = this->wait;
		this->wait = nullptr;
#ifndef ARLIB_OPT
		if (wait == nullptr)
			debug_fatal_stack("attempt to complete() a producer with no waiter; did you mean complete_sync()?");
#endif
		wait->prod = nullptr; // if it crashes here, you probably called complete when you meant complete_sync
		wait->complete(wait);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq $0x0, (%rax)
cmpq $0x0, -0x10(%rbp)
jne 0x31321
leaq 0x32958(%rip), %rdi     # 0x63c74
callq 0xe080
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
// File: Alcaro[P]bridges/arlib/runloop-poll.cpp
// Function: (anonymous namespace)::runloop2_poll::fds_t::await_fd(int, bool)
async<void> await_fd(int fd, bool want_write)
		{
			reserve_space(1);
			
			static short rd_ev = (POLLIN |POLLHUP|POLLERR|POLLNVAL); // kernel always returns HUP/ERR/NVAL, whether requested or not
			static short wr_ev = (POLLOUT|POLLHUP|POLLERR|POLLNVAL); // let's set them anyways, it looks cleaner
			waiter_node& ch = waiting[freelist];
			struct pollfd& pfd = wait_fd[freelist];
			freelist = ~pfd.fd;
			pfd = { fd, (want_write ? wr_ev : rd_ev), 0 };
			return &ch.prod;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl $0x1, %esi
callq 0x31520
movq -0x40(%rbp), %rdi
movq 0x20(%rdi), %rsi
callq 0x308c0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq %rax, %rdi
addq $0x10, %rdi
movq 0x20(%rax), %rsi
callq 0x31e70
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movl (%rcx), %ecx
xorl $-0x1, %ecx
movslq %ecx, %rcx
movq %rcx, 0x20(%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
leaq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x38(%rbp)
testb $0x1, -0x15(%rbp)
je 0x314df
movw 0x4fb39(%rip), %ax      # 0x81012
movw %ax, -0x52(%rbp)
jmp 0x314ea
movw 0x4fb2a(%rip), %ax      # 0x81010
movw %ax, -0x52(%rbp)
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rax
movw -0x52(%rbp), %cx
movw %cx, (%rax)
movw $0x0, -0x2a(%rbp)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rsi
callq 0x32730
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: Alcaro[P]bridges/arlib/runloop2.h
// Function: allocatable_array<(anonymous namespace)::runloop2_poll::timeout_t::waiter_node, (anonymous namespace)::runloop2_poll::timeout_t::$_0{}, (anonymous namespace)::runloop2_poll::timeout_t::$_1{}>::alloc()
T* alloc()
	{
		if (freelist == inner.size())
		{
			if (inner.size() == 0)
				reallocate(8);
			else
				reallocate(inner.size()*2);
		}
		
		T* ret = &inner[freelist];
		freelist = get_freelist(ret)[0];
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq 0x10(%rdi), %rax
movq %rax, -0x18(%rbp)
callq 0x31670
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jne 0x31636
movq -0x20(%rbp), %rdi
callq 0x31670
cmpq $0x0, %rax
jne 0x3161c
movq -0x20(%rbp), %rdi
movl $0x8, %esi
callq 0x31690
jmp 0x31634
movq -0x20(%rbp), %rdi
callq 0x31670
movq -0x20(%rbp), %rdi
movq %rax, %rsi
shlq %rsi
callq 0x31690
jmp 0x31636
movq -0x20(%rbp), %rdi
movq 0x10(%rdi), %rsi
callq 0x31750
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x32676(%rip), %rdi     # 0x63cc8
callq 0x31400
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Alcaro[P]bridges/arlib/runloop2.h
// Function: allocatable_array<(anonymous namespace)::runloop2_poll::timeout_t::waiter_node, (anonymous namespace)::runloop2_poll::timeout_t::$_0{}, (anonymous namespace)::runloop2_poll::timeout_t::$_1{}>::reallocate(unsigned long)
void reallocate(size_t newsize)
	{
		size_t cursize = inner.size();
		inner.resize(newsize);
		for (size_t i=0;i<cursize;i++)
		{
			if constexpr (!std::is_same_v<decltype(on_move), nullptr_t>)
				on_move(&inner[i]);
		}
		for (size_t i=cursize;i<newsize;i++)
			get_freelist(&inner[i])[0] = i+1;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x31670
movq -0x30(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x31770
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x316fa
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x31750
movq %rax, %rsi
leaq 0x325e9(%rip), %rdi     # 0x63cd0
callq 0x317a0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x316c6
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x31749
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rsi
callq 0x31750
movq %rax, %rsi
leaq 0x32599(%rip), %rdi     # 0x63cc8
callq 0x31400
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x31702
addq $0x40, %rsp
popq %rbp
retq
nop
// File: Alcaro[P]bridges/arlib/array.h
// Function: fifo<std::__n4861::coroutine_handle<void>>::push(std::__n4861::coroutine_handle<void>)
void push(T item)
	{
		if (wr == capacity)
		{
			if (rd <= capacity/2)
			{
				if (capacity == 0)
					capacity = 8;
				else
					capacity *= 2;
				items = xrealloc(items, sizeof(T)*capacity);
			}
			for (size_t n=0;n<rd;n++)
				items[n].~T();
			memmove(items, items+rd, sizeof(T)*(wr-rd));
			wr -= rd;
			rd = 0;
		}
		new(&items[wr]) T(std::move(item));
		wr++;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq 0x18(%rcx), %rax
cmpq 0x8(%rcx), %rax
jne 0x32393
movq -0x30(%rbp), %rcx
movq 0x10(%rcx), %rax
movq 0x8(%rcx), %rcx
shrq %rcx
cmpq %rcx, %rax
ja 0x3232e
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x322e3
movq -0x30(%rbp), %rax
movq $0x8, 0x8(%rax)
jmp 0x322f2
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
shlq %rcx
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rsi
leaq -0x20(%rbp), %rdi
callq 0x323c0
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rsi
shlq $0x3, %rsi
movq -0x20(%rbp), %rdi
callq 0x2d690
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x323e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0x32352
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x32336
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq (%rax), %rsi
movq 0x10(%rax), %rcx
shlq $0x3, %rcx
addq %rcx, %rsi
movq 0x18(%rax), %rdx
subq 0x10(%rax), %rdx
shlq $0x3, %rdx
callq 0x45f0
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x18(%rax)
movq $0x0, 0x10(%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq 0x18(%rax), %rdx
movq -0x8(%rbp), %rsi
movq %rsi, (%rcx,%rdx,8)
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Alcaro[P]bridges/arlib/time.h
// Function: timestamp::operator-(timestamp) const
duration operator-(timestamp other) const
	{
		duration ret;
		ret.sec = sec - other.sec;
		ret.nsec = nsec - other.nsec;
		if (ret.nsec < 0)
		{
			ret.sec--;
			ret.nsec += 1000000000;
		}
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq %rdi, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
subq -0x20(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jge 0x3260c
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x3b9aca00, %rax       # imm = 0x3B9ACA00
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Alcaro[P]bridges/arlib/runloop-test.cpp
// Function: (anonymous namespace)::inner_awaitable_t::cancel()
void cancel()
	{
		if (test_state == 7)
		{
			assert_eq(test_state++, 7);
			assert_eq(test_state++, 8);
		}
		else
		{
			assert_eq(test_state++, 9);
			assert_eq(test_state++, 10);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpl $0x7, 0x4eb19(%rip)     # 0x81458
jne 0x32961
movl 0x4eb11(%rip), %eax     # 0x81458
addl $0x1, %eax
movl %eax, 0x4eb08(%rip)     # 0x81458
movl 0x4eb02(%rip), %eax     # 0x81458
addl $0x1, %eax
movl %eax, 0x4eaf9(%rip)     # 0x81458
jmp 0x3297f
movl 0x4eaf1(%rip), %eax     # 0x81458
addl $0x1, %eax
movl %eax, 0x4eae8(%rip)     # 0x81458
movl 0x4eae2(%rip), %eax     # 0x81458
addl $0x1, %eax
movl %eax, 0x4ead9(%rip)     # 0x81458
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Alcaro[P]bridges/arlib/staticmap.cpp
// Function: staticmap::open(cstrnul, bool)
bool staticmap::open(cstrnul fn, bool map_writable)
{
	if (!f.open(fn, (file2::mode)(file2::m_write | file2::m_exclusive))) return false;
	this->map_writable = map_writable;
	this->sector_size = f.sector_size();
	
	mmap = f.mmapw(map_writable);
	if (mmap.size() == 0)
		create();
	else if (rd64(off_header) == t_meta+off_r_objsize && rd64(off_r_sig) == sig_passive)
		{} // do nothing
	else if (rd64(off_header) == t_meta+off_r_objsize && rd64(off_r_sig) == sig_active)
	{
		if (mmap.size() <= 1024 || rd64(off_r_entries) == 0)
			create();
		else
			recover();
	}
	else
		f.close();
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x4, %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl $0x9, %ecx
callq 0x10e50
testb $0x1, %al
jne 0x32af6
movb $0x0, -0x1(%rbp)
jmp 0x32c1f
movq -0x50(%rbp), %rdi
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, 0x18(%rdi)
addq $0x4, %rdi
callq 0x352f0
movq -0x50(%rbp), %rsi
movl %eax, 0x1c(%rsi)
addq $0x4, %rsi
movb -0x21(%rbp), %al
leaq -0x48(%rbp), %rdi
andb $0x1, %al
movzbl %al, %edx
callq 0x35320
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
leaq -0x48(%rbp), %rsi
callq 0x35390
leaq -0x48(%rbp), %rdi
callq 0x353d0
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
callq 0x6290
cmpq $0x0, %rax
jne 0x32b62
movq -0x50(%rbp), %rdi
callq 0x32c30
jmp 0x32c1b
movq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x353f0
cmpq $0x202, %rax            # imm = 0x202
jne 0x32b99
movq -0x50(%rbp), %rdi
movl $0x8, %esi
callq 0x353f0
movabsq $0x70616d736c7261, %rcx # imm = 0x70616D736C7261
cmpq %rcx, %rax
jne 0x32b99
jmp 0x32c19
movq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x353f0
cmpq $0x202, %rax            # imm = 0x202
jne 0x32c0a
movq -0x50(%rbp), %rdi
movl $0x8, %esi
callq 0x353f0
movabsq $0x170616d736c7261, %rcx # imm = 0x170616D736C7261
cmpq %rcx, %rax
jne 0x32c0a
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
callq 0x6290
cmpq $0x400, %rax            # imm = 0x400
jbe 0x32bf4
movq -0x50(%rbp), %rdi
movl $0x20, %esi
callq 0x353f0
cmpq $0x0, %rax
jne 0x32bff
movq -0x50(%rbp), %rdi
callq 0x32c30
jmp 0x32c08
movq -0x50(%rbp), %rdi
callq 0x33030
jmp 0x32c17
movq -0x50(%rbp), %rdi
addq $0x4, %rdi
callq 0x115d0
jmp 0x32c19
jmp 0x32c1b
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Alcaro[P]bridges/arlib/staticmap.cpp
// Function: staticmap::hashmap_locate(unsigned long, arrayview<unsigned char>)
uint64_t staticmap::hashmap_locate(uint64_t hash, bytesr key)
{
	uint64_t ret = 0;
	uint64_t hashmap_pos = rd64(off_r_hm_ptr);
	uint64_t hashmap_size = rd64(hashmap_pos+off_header) & ~t_typemask;
	
	// ignore bottom 4 bits of hash
	uint64_t off = hash & (hashmap_size-off_h_nodesize);
	while (true)
	{
		if (off == 0)
			off = off_h_nodesize;
		uint64_t node_addr = rd64(hashmap_pos+off+off_h_ptr);
		uint64_t node_hash = rd64(hashmap_pos+off+off_h_hash);
		if (node_addr <= 1)
		{
			if (ret == 0)
				ret = hashmap_pos+off;
			if (node_addr == 0)
				return ret;
		}
		if (node_addr > 1 && node_hash == hash)
		{
			bytesr node_key = mmap.slice(node_addr+off_d_keystart, rd64(node_addr+off_d_keysz));
			if (key == node_key)
				return hashmap_pos+off;
		}
		off = (off+off_h_nodesize) & (hashmap_size-off_h_nodesize);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq %rdi, -0x90(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x10, %esi
callq 0x353f0
movq -0x90(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
addq $0x0, %rsi
callq 0x353f0
andq $-0x10, %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
subq $0x10, %rcx
andq %rcx, %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x33c6a
movq $0x10, -0x48(%rbp)
movq -0x90(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq -0x48(%rbp), %rsi
addq $0x0, %rsi
callq 0x353f0
movq -0x90(%rbp), %rdi
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rsi
addq -0x48(%rbp), %rsi
addq $0x8, %rsi
callq 0x353f0
movq %rax, -0x58(%rbp)
cmpq $0x1, -0x50(%rbp)
ja 0x33cd2
cmpq $0x0, -0x30(%rbp)
jne 0x33cbc
movq -0x38(%rbp), %rax
addq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x33cd0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x33d9f
jmp 0x33cd2
cmpq $0x1, -0x50(%rbp)
jbe 0x33d83
movq -0x58(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x33d83
movq -0x90(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0xa0(%rbp)
movq -0x50(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x98(%rbp)
movq -0x50(%rbp), %rsi
addq $0x8, %rsi
callq 0x353f0
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
movq %rax, %rcx
leaq -0x78(%rbp), %rdi
callq 0xc4c0
movq -0x78(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x18(%rbp), %rdi
callq 0x60c0
testb $0x1, %al
jne 0x33d73
jmp 0x33d81
movq -0x38(%rbp), %rax
addq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x33d9f
jmp 0x33d83
movq -0x48(%rbp), %rax
addq $0x10, %rax
movq -0x40(%rbp), %rcx
subq $0x10, %rcx
andq %rcx, %rax
movq %rax, -0x48(%rbp)
jmp 0x33c5b
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: Alcaro[P]bridges/arlib/staticmap.cpp
// Function: staticmap::get_or_empty(arrayview<unsigned char>, bool*)
bytesw staticmap::get_or_empty(bytesr key, bool* found)
{
//puts("GET "+tostringhex(key));
	uint64_t hash = sm_hash(key);
	uint64_t hashmap_pos = hashmap_locate(hash, key);
	
	uint64_t ptr = rd64(hashmap_pos+off_h_ptr);
	if (found)
		*found = (ptr > 1);
	if (ptr > 1)
		return mmap.slice(ptr+off_d_keystart+key.size(), rd64(ptr+off_d_valsz));
	return {};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rsi, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x33710
movq -0x68(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %rcx
callq 0x33bf0
movq -0x68(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
addq $0x0, %rsi
callq 0x353f0
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x34179
cmpq $0x1, -0x60(%rbp)
seta %cl
movq -0x28(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
cmpq $0x1, -0x60(%rbp)
jbe 0x341e2
movq -0x68(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x88(%rbp)
movq -0x60(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x90(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6290
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movq -0x90(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x80(%rbp)
movq -0x60(%rbp), %rsi
addq $0x10, %rsi
callq 0x353f0
movq -0x78(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq %rax, %rcx
callq 0xc4c0
jmp 0x341fb
movq -0x78(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x4170
movq -0x78(%rbp), %rdi
callq 0x7530
movq -0x70(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Alcaro[P]bridges/arlib/staticmap.cpp
// Function: staticmap::desync()
void staticmap::desync()
{
	if (!f) return;
	if (*synced)
		f.pwrite(off_r_sigactive, synced);
	*synced = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x4, %rdi
callq 0x35e20
testb $0x1, %al
jne 0x34763
jmp 0x347a7
movq -0x20(%rbp), %rax
cmpb $0x0, 0x19(%rax)
je 0x3479f
movq -0x20(%rbp), %rsi
movq %rsi, %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
addq $0x19, %rsi
leaq -0x18(%rbp), %rdi
callq 0x35dd0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0xf, %esi
callq 0x35470
movq -0x20(%rbp), %rax
movb $0x0, 0x19(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Alcaro[P]bridges/arlib/staticmap.cpp
// Function: staticmap::remove(arrayview<unsigned char>)
void staticmap::remove(bytesr key)
{
//puts("REMOVE "+tostringhex(key));
	desync();
	
	uint64_t hash = sm_hash(key);
	uint64_t hashmap_pos = hashmap_locate(hash, key);
	
	uint64_t ptr = rd64(hashmap_pos+off_h_ptr);
	if (ptr > 1)
	{
		free(ptr);
		wr64(hashmap_pos+off_h_ptr, 1);
		wr64(off_r_entries, rd64(off_r_entries)-1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x34740
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x33710
movq -0x58(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0x33bf0
movq -0x58(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
addq $0x0, %rsi
callq 0x353f0
movq %rax, -0x50(%rbp)
cmpq $0x1, -0x50(%rbp)
jbe 0x348cd
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x33760
movq -0x58(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x0, %rsi
movl $0x1, %edx
callq 0x35960
movq -0x58(%rbp), %rdi
movl $0x20, %esi
callq 0x353f0
movq -0x58(%rbp), %rdi
movq %rax, %rdx
subq $0x1, %rdx
movl $0x20, %esi
callq 0x356d0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Alcaro[P]bridges/arlib/staticmap.cpp
// Function: staticmap::sync()
void staticmap::sync()
{
	if (!*synced)
	{
		f.pwrite(off_r_sigactive, synced);
		f.sync();
	}
	*synced = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpb $0x0, 0x19(%rax)
jne 0x34969
movq -0x20(%rbp), %rsi
movq %rsi, %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
addq $0x19, %rsi
leaq -0x18(%rbp), %rdi
callq 0x35dd0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0xf, %esi
callq 0x35470
movq -0x20(%rbp), %rdi
addq $0x4, %rdi
callq 0x35e00
movq -0x20(%rbp), %rax
movb $0x1, 0x19(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Alcaro[P]bridges/arlib/staticmap.cpp
// Function: staticmap::iterator::operator*()
staticmap::node staticmap::iterator::operator*()
{
	it = next(it, nullptr);
	uint64_t keylen = readu_le64(it+off_d_keysz);
	uint64_t vallen = readu_le64(it+off_d_valsz);
	return { bytesr(it+off_d_keystart, keylen), bytesw(it+off_d_keystart+keylen, vallen) };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x34980
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rcx
addq $0x8, %rcx
movq %rcx, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq (%rax), %rcx
addq $0x10, %rcx
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq (%rax), %rsi
addq $0x18, %rsi
movq -0x38(%rbp), %rdx
callq 0x5d70
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rax
addq $0x10, %rdi
movq (%rax), %rsi
addq $0x18, %rsi
addq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x5ed0
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Alcaro[P]bridges/arlib/staticmap.cpp
// Function: staticmap::iterator::operator!=(staticmap::iterator const&)
bool staticmap::iterator::operator!=(const iterator& other)
{
	uint8_t* a = it;
	uint8_t* b = other.it;
	if (it < other.it) a = next(a, b);
	else b = next(b, a);
	return (a != b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, -0x20(%rbp)
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x34b55
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x34980
movq %rax, -0x18(%rbp)
jmp 0x34b66
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x34980
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
setne %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Alcaro[P]bridges/arlib/staticmap.h
// Function: bool staticmap::wr64<long, int, unsigned long>(unsigned long, long, int, unsigned long)
bool wr64(uint64_t pos, Ts... vals)
	{
		uint8_t buf[sizeof...(vals) * 8];
		size_t n = 0;
		((writeu_le64(buf+(n++)*8, vals)), ...);
		return (f.pwrite(pos, buf) == sizeof(buf));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
movq %rdx, -0x48(%rbp)
movl %ecx, -0x4c(%rbp)
movq %r8, -0x58(%rbp)
movq -0x38(%rbp), %rax
movq $0x0, -0x78(%rbp)
leaq -0x70(%rbp), %rdx
movq -0x78(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x78(%rbp)
shlq $0x3, %rcx
addq %rcx, %rdx
movq -0x48(%rbp), %rcx
movq %rdx, -0x8(%rbp)
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rdx
movq %rdx, (%rcx)
leaq -0x70(%rbp), %rdx
movq -0x78(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x78(%rbp)
shlq $0x3, %rcx
addq %rcx, %rdx
movslq -0x4c(%rbp), %rcx
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rdx
movq %rdx, (%rcx)
leaq -0x70(%rbp), %rdx
movq -0x78(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x78(%rbp)
shlq $0x3, %rcx
addq %rcx, %rdx
movq -0x58(%rbp), %rcx
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rdx
movq %rdx, (%rcx)
addq $0x4, %rax
movq %rax, -0x98(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x35da0
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
movq -0x80(%rbp), %rcx
callq 0x35470
cmpq $0x18, %rax
sete %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Alcaro[P]bridges/arlib/string.cpp
// Function: string::init_from_outline(unsigned char const*, unsigned long)
void string::init_from_outline(const uint8_t * str, size_t len)
{
	if (len <= max_inline())
	{
		memcpy(m_inline, str, len);
		m_inline[len] = '\0';
		m_inline_len_w() = max_inline()-len;
	}
	else
	{
		init_from_large(str, len);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x5c90
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, %ecx
cmpq %rcx, %rax
ja 0x36f81
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4280
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
callq 0x5c90
movq -0x28(%rbp), %rdi
movl %eax, %eax
subq -0x18(%rbp), %rax
movb %al, -0x29(%rbp)
callq 0x5ca0
movb -0x29(%rbp), %cl
movb %cl, (%rax)
jmp 0x36f92
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x36fa0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Alcaro[P]bridges/arlib/string.cpp
// Function: string::init_from_large(unsigned char const*, unsigned long)
void string::init_from_large(const uint8_t * str, size_t len)
{
	m_inline_len_w() = -1;
	
	m_data = xmalloc(bytes_for(len));
	memcpy(m_data, str, len);
	m_data[len]='\0';
	
	m_len = len;
	m_nul = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x5ca0
movb $-0x1, (%rax)
movq -0x18(%rbp), %rdi
callq 0x3dca0
movq %rax, %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), %rsi
movq -0x18(%rbp), %rdx
callq 0x4280
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rdx
movb $0x0, (%rcx,%rdx)
movq -0x18(%rbp), %rcx
movl %ecx, 0x8(%rax)
movb $0x1, 0xc(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Alcaro[P]bridges/arlib/string.cpp
// Function: string::init_from(cstring const&)
void string::init_from(const cstring& other)
{
	if (other.inlined())
		memcpy((void*)this, (void*)&other, sizeof(*this));
	else
		init_from_large(other.m_data, other.m_len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5cc0
movsbl %al, %eax
cmpl $0x0, %eax
jl 0x37069
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x37082
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %edx
callq 0x36fa0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Alcaro[P]bridges/arlib/string.cpp
// Function: string::create_usurp(char*)
string string::create_usurp(char * str)
{
	cstring tmp(str);
	string ret;
	memcpy((void*)&ret, (void*)&tmp, sizeof(string));
	if (tmp.inlined()) free(str);
	else ret.m_data = xrealloc(ret.m_data, bytes_for(ret.m_len));
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x58c0
movq -0x48(%rbp), %rdi
movb $0x0, -0x29(%rbp)
callq 0x7800
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, (%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x8(%rdi)
leaq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5cc0
movsbl %al, %eax
cmpl $0x0, %eax
jl 0x377cc
movq -0x18(%rbp), %rdi
callq 0x4420
jmp 0x3780d
movq -0x48(%rbp), %rax
movq (%rax), %rsi
leaq -0x40(%rbp), %rdi
callq 0x6be0
movq -0x48(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %edi
callq 0x3dca0
movq %rax, %rsi
movq -0x40(%rbp), %rdi
callq 0x2d690
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6bc0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x37820
movq -0x48(%rbp), %rdi
callq 0x5870
movq -0x50(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Alcaro[P]bridges/arlib/string.cpp
// Function: string::string(array<unsigned char>&&)
string::string(array<uint8_t>&& bytes) : cstrnul(noinit())
{
	cstring tmp(bytes);
	memcpy((void*)this, (void*)&tmp, sizeof(string));
	
	uint8_t* ptr = bytes.release().ptr();
	if (tmp.inlined()) free(ptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x5c00
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x2ac10
movq -0x60(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x1d840
leaq -0x58(%rbp), %rdi
callq 0x7490
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5cc0
movsbl %al, %eax
cmpl $0x0, %eax
jl 0x378c0
movq -0x48(%rbp), %rdi
callq 0x4420
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Alcaro[P]bridges/arlib/string.cpp
// Function: cstring::upper() const
string cstring::upper() const
{
	string ret = *this;
	bytesw by = ret.bytes();
	for (size_t i=0;i<by.size();i++) by[i] = toupper(by[i]);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x50(%rbp)
movq %rsi, -0x58(%rbp)
movq -0x58(%rbp), %rax
movb $0x0, -0x59(%rbp)
movq (%rax), %rcx
movq %rcx, -0x70(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x70(%rbp), %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq %rax, -0x38(%rbp)
movq %rdi, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x5c00
movq -0xa0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x37020
movq -0x98(%rbp), %rdi
leaq -0x80(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x30(%rbp)
movq -0x30(%rbp), %rax
leaq -0x80(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x90(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5cc0
movsbl %al, %eax
cmpl $0x0, %eax
jl 0x3cac3
movq -0x90(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5cc0
movq -0x90(%rbp), %rsi
movsbl %al, %eax
xorl $0xf, %eax
movzbl %al, %eax
movl %eax, %edx
leaq -0x80(%rbp), %rdi
callq 0x5ed0
jmp 0x3cadb
movq -0x90(%rbp), %rax
movq (%rax), %rsi
movl 0x8(%rax), %eax
movl %eax, %edx
leaq -0x80(%rbp), %rdi
callq 0x5ed0
movq $0x0, -0x88(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x6290
movq %rax, %rcx
movq -0xb0(%rbp), %rax
cmpq %rcx, %rax
jae 0x3cb56
movq -0x88(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x3dcc0
movzbl (%rax), %edi
callq 0x3c1d0
movb %al, -0xb1(%rbp)
movq -0x88(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x3dcc0
movb -0xb1(%rbp), %cl
movb %cl, (%rax)
movq -0x88(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x88(%rbp)
jmp 0x3cae6
movb $0x1, -0x59(%rbp)
testb $0x1, -0x59(%rbp)
jne 0x3cb6c
movq -0x98(%rbp), %rdi
callq 0x5870
movq -0xa8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax)
// File: Alcaro[P]bridges/arlib/string.cpp
// Function: cstring::trim() const
cstring cstring::trim() const
{
	const uint8_t * chars = ptr();
	int start = 0;
	int end = length();
	while (end > start && isspace(chars[end-1])) end--;
	while (start < end && isspace(chars[start])) start++;
	return substr(start, end);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x70(%rbp)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5cc0
movsbl %al, %eax
cmpl $0x0, %eax
jl 0x3cd62
movq -0x68(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x3cd6d
movq -0x68(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x70(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movl $0x0, -0x5c(%rbp)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x78(%rbp)
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5cc0
movsbl %al, %eax
cmpl $0x0, %eax
jl 0x3cdc0
movq -0x78(%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 0x3cdca
movq -0x78(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x60(%rbp)
movl -0x60(%rbp), %ecx
xorl %eax, %eax
cmpl -0x5c(%rbp), %ecx
movb %al, -0x79(%rbp)
jle 0x3cdf6
movq -0x58(%rbp), %rax
movl -0x60(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
callq 0x3ce70
movb %al, -0x79(%rbp)
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x3cdff
jmp 0x3ce0a
movl -0x60(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x3cdd0
jmp 0x3ce0c
movl -0x5c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x60(%rbp), %ecx
movb %al, -0x7a(%rbp)
jge 0x3ce2d
movq -0x58(%rbp), %rax
movslq -0x5c(%rbp), %rcx
movzbl (%rax,%rcx), %edi
callq 0x3ce70
movb %al, -0x7a(%rbp)
movb -0x7a(%rbp), %al
testb $0x1, %al
jne 0x3ce36
jmp 0x3ce41
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x3ce0c
movq -0x70(%rbp), %rdi
movl -0x5c(%rbp), %esi
movl -0x60(%rbp), %edx
callq 0x9f90
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rdx
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: Alcaro[P]bridges/arlib/string.cpp
// Function: cstring::contains_nul() const
bool cstring::contains_nul() const
{
#ifdef __SSE2__
	static_assert(sizeof(cstring) == 16);
	if (inlined())
	{
		int iszero = _mm_movemask_epi8(_mm_cmpeq_epi8(_mm_loadu_si128((__m128i*)this), _mm_setzero_si128()));
		// m_inline[0] becomes the 0001 bit, [1] -> 0002, etc
		// m_inline_len is number of bytes at the end of the object we don't care about, not counting the NUL terminator
		// iszero << m_inline_len puts the NUL at the 0x8000 bit; if anything lower is also true, that's a NUL in the input
		return ((iszero << m_inline_len()) & 0x7FFF);
	}
	else
	{
		// similar design to operator==(cstring,cstring)
		
		auto hasnul16 = [](const uint8_t * ap)
		{
			__m128i a = _mm_loadu_si128((__m128i*)ap);
			return (_mm_movemask_epi8(_mm_cmpeq_epi8(a, _mm_setzero_si128())) != 0x0000);
		};
		
		const uint8_t * ptr = m_data;
		size_t stop = m_len - 16;
		
		size_t iter = 0;
		do {
			if (hasnul16(ptr+iter)) return true;
			iter += 16;
		} while (iter < stop);
		
		return (hasnul16(ptr+stop));
	}
#else
	return memchr(ptr(), '\0', length());
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x88(%rbp)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x5cc0
movsbl %al, %eax
cmpl $0x0, %eax
jl 0x3cf3e
movq -0x88(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq -0x48(%rbp), %rax
movups (%rax), %xmm1
xorps %xmm0, %xmm0
movaps %xmm0, -0x10(%rbp)
movaps -0x10(%rbp), %xmm0
movaps %xmm1, -0x20(%rbp)
movaps %xmm0, -0x30(%rbp)
movaps -0x20(%rbp), %xmm0
movaps -0x30(%rbp), %xmm1
pcmpeqb %xmm1, %xmm0
movdqa %xmm0, -0x40(%rbp)
movdqa -0x40(%rbp), %xmm0
pmovmskb %xmm0, %eax
movl %eax, -0x64(%rbp)
movl -0x64(%rbp), %eax
movl %eax, -0x8c(%rbp)
callq 0x5cc0
movb %al, %cl
movl -0x8c(%rbp), %eax
movsbl %cl, %ecx
shll %cl, %eax
andl $0x7fff, %eax           # imm = 0x7FFF
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x51(%rbp)
jmp 0x3cfb2
movq -0x88(%rbp), %rax
movb 0x26ea6(%rip), %cl      # 0x63df1
movb %cl, -0x65(%rbp)
movq (%rax), %rcx
movq %rcx, -0x70(%rbp)
movl 0x8(%rax), %eax
subl $0x10, %eax
movl %eax, %eax
movq %rax, -0x78(%rbp)
movq $0x0, -0x80(%rbp)
movq -0x70(%rbp), %rsi
addq -0x80(%rbp), %rsi
leaq -0x65(%rbp), %rdi
callq 0x3cfc0
testb $0x1, %al
jne 0x3cf80
jmp 0x3cf86
movb $0x1, -0x51(%rbp)
jmp 0x3cfb2
movq -0x80(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
cmpq -0x78(%rbp), %rax
jb 0x3cf69
movq -0x70(%rbp), %rsi
addq -0x78(%rbp), %rsi
leaq -0x65(%rbp), %rdi
callq 0x3cfc0
andb $0x1, %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
// File: Alcaro[P]bridges/arlib/string.cpp
// Function: string::codepoint(unsigned char*, unsigned int)
size_t string::codepoint(uint8_t* out, uint32_t cp)
{
	if (LIKELY(cp <= 0x7F))
	{
		out[0] = cp;
		return 1;
	}
	
	if (cp >= 0xD800 && cp <= 0xDFFF) cp = 0xFFFD; // curse utf16 forever
	if (cp > 0x10FFFF) cp = 0xFFFD;
	
	// some bit magic on the codepoint / utf8 representation, smaller and faster than more obvious approaches
	uint32_t bits = cp;
	bits = (bits&0x00fff000)<<4 | (bits&0x00000fff);
	bits = (bits&0x0fc00fc0)<<2 | (bits&0x003f003f);
	
	// check how many bytes that'd need, fill in the mandatory 1 bits, and write it out
	if (bits <= 0x00001fff) // cp <= 0x7ff
	{
		writeu_be32(out, (bits|0xC080)<<16);
		return 2;
	}
	else if (bits <= 0x000fffff) // cp <= 0xffff
	{
		writeu_be32(out, (bits|0xE08080)<<8);
		return 3;
	}
	else
	{
		writeu_be32(out, bits|0xF0808080);
		return 4;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x40(%rbp)
movl %esi, -0x44(%rbp)
cmpl $0x7f, -0x44(%rbp)
setbe %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3d03c
jmp 0x3d054
movl -0x44(%rbp), %eax
movb %al, %cl
movq -0x40(%rbp), %rax
movb %cl, (%rax)
movq $0x1, -0x38(%rbp)
jmp 0x3d155
cmpl $0xd800, -0x44(%rbp)    # imm = 0xD800
jb 0x3d06d
cmpl $0xdfff, -0x44(%rbp)    # imm = 0xDFFF
ja 0x3d06d
movl $0xfffd, -0x44(%rbp)    # imm = 0xFFFD
cmpl $0x10ffff, -0x44(%rbp)  # imm = 0x10FFFF
jbe 0x3d07d
movl $0xfffd, -0x44(%rbp)    # imm = 0xFFFD
movl -0x44(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
andl $0xfff000, %eax         # imm = 0xFFF000
shll $0x4, %eax
movl -0x48(%rbp), %ecx
andl $0xfff, %ecx            # imm = 0xFFF
orl %ecx, %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
andl $0xfc00fc0, %eax        # imm = 0xFC00FC0
shll $0x2, %eax
movl -0x48(%rbp), %ecx
andl $0x3f003f, %ecx         # imm = 0x3F003F
orl %ecx, %eax
movl %eax, -0x48(%rbp)
cmpl $0x1fff, -0x48(%rbp)    # imm = 0x1FFF
ja 0x3d0ef
movq -0x40(%rbp), %rcx
movl -0x48(%rbp), %eax
orl $0xc080, %eax           # imm = 0xC080
shll $0x10, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
bswapl %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq $0x2, -0x38(%rbp)
jmp 0x3d155
cmpl $0xfffff, -0x48(%rbp)   # imm = 0xFFFFF
ja 0x3d129
movq -0x40(%rbp), %rcx
movl -0x48(%rbp), %eax
orl $0xe08080, %eax         # imm = 0xE08080
shll $0x8, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
bswapl %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movq $0x3, -0x38(%rbp)
jmp 0x3d155
movq -0x40(%rbp), %rcx
movl -0x48(%rbp), %eax
orl $0xf0808080, %eax       # imm = 0xF0808080
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
bswapl %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
movq $0x4, -0x38(%rbp)
movq -0x38(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)