LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Alcaro[P]bridges/arlib/image.h
// Function: image::init_ptr(void const*, unsigned int, unsigned int, unsigned long, imagefmt)
void init_ptr(const void * pixels, uint32_t width, uint32_t height, size_t stride, imagefmt fmt)
	{
		this->pixelsv = (void*)pixels;
		this->width = width;
		this->height = height;
		this->stride = stride;
		this->fmt = fmt;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, (%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rcx
movl %ecx, 0xc(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0x8(%rax)
popq %rbp
retq
// File: Alcaro[P]bridges/arlib/image.h
// Function: image::init_ref(image const&)
void init_ref(const image& other)
	{
		width = other.width;
		height = other.height;
		fmt = other.fmt;
		stride = other.stride;
		pixelsv = other.pixelsv;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Alcaro[P]bridges/arlib/image.h
// Function: image::init_ref_sub(image const&, unsigned int, unsigned int, unsigned int, unsigned int)
void init_ref_sub(const image& other, uint32_t x, uint32_t y, uint32_t width, uint32_t height)
	{
		init_ref(other);
		pixels8 += x*byteperpix(fmt) + y*stride;
		this->width = width;
		this->height = height;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1af30
movq -0x28(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, -0x2c(%rbp)
movl 0x8(%rax), %edi
callq 0x1ae50
movl -0x2c(%rbp), %edx
movb %al, %cl
movq -0x28(%rbp), %rax
movzbl %cl, %ecx
imull %ecx, %edx
movl -0x18(%rbp), %ecx
imull 0xc(%rax), %ecx
addl %ecx, %edx
movq 0x10(%rax), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %ecx
movl %ecx, 0x4(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Alcaro[P]bridges/arlib/array.h
// Function: array<signed char>::clone(arrayview<signed char> const&)
void clone(const arrayview<T>& other)
	{
		this->count = other.size(); // I can't access non-this instances of my base class, so let's just use the public interface
		this->items = xmalloc(sizeof(T)*capacity_for(this->count));
		if (this->trivial_copy())
		{
			memcpy((void*)this->items, (void*)other.ptr(), sizeof(T)*this->count);
		}
		else
		{
			for (size_t i=0;i<this->count;i++)
			{
				new(&this->items[i]) T(other.ptr()[i]);
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1baa0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rdi
callq 0x1b970
movq %rax, %rdi
shlq $0x0, %rdi
callq 0x2d5e0
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1bac0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
callq 0x1bae0
testb $0x1, %al
jne 0x1ba13
jmp 0x1ba41
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1baf0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdx
shlq $0x0, %rdx
callq 0x4280
jmp 0x1ba98
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0x1ba96
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1baf0
movq -0x40(%rbp), %rcx
movq %rax, %rdx
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rsi
movb (%rdx,%rsi), %dl
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1ba49
jmp 0x1ba98
addq $0x40, %rsp
popq %rbp
retq
nop
// File: Alcaro[P]bridges/arlib/array.h
// Function: array<signed char>::swap(array<signed char>&)
void swap(array<T>& other)
	{
		T* newitems = other.items;
		size_t newcount = other.count;
		other.items = this->items;
		other.count = this->count;
		this->items = newitems;
		this->count = newcount;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, -0x20(%rbp)
movq (%rax), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, (%rcx)
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, 0x8(%rcx)
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
popq %rbp
retq
nop
// File: Alcaro[P]bridges/arlib/array.h
// Function: arrayvieww<signed char>::swap(unsigned long, unsigned long)
void swap(size_t a, size_t b)
	{
		if (a == b) return;
		
		char tmp[sizeof(T)];
		memcpy(tmp, (void*)(this->items+a), sizeof(T));
		memcpy((void*)(this->items+a), (void*)(this->items+b), sizeof(T));
		memcpy((void*)(this->items+b), tmp, sizeof(T));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x1bbb4
jmp 0x1bbe8
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rdx
movb (%rcx,%rdx), %cl
movb %cl, -0x19(%rbp)
movq (%rax), %rcx
movq -0x10(%rbp), %rdx
movq (%rax), %rsi
movq -0x18(%rbp), %rdi
movb (%rsi,%rdi), %sil
movb %sil, (%rcx,%rdx)
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movb -0x19(%rbp), %dl
movb %dl, (%rax,%rcx)
popq %rbp
retq
nopw (%rax,%rax)
// File: Alcaro[P]bridges/arlib/array.h
// Function: array<signed char>::resize_shrink_noinit(unsigned long)
void resize_shrink_noinit(size_t newcount)
	{
		if (this->count <= newcount) return;
		size_t new_bufsize = capacity_for(newcount);
		if (this->count > new_bufsize) this->items = xrealloc(this->items, sizeof(T)*new_bufsize);
		this->count = newcount;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
ja 0x1bce4
jmp 0x1bd46
movq -0x10(%rbp), %rdi
callq 0x1b970
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jbe 0x1bd3a
movq -0x30(%rbp), %rax
movq (%rax), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1bca0
movq -0x18(%rbp), %rsi
shlq $0x0, %rsi
movq -0x28(%rbp), %rdi
callq 0x2d690
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1bac0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Alcaro[P]bridges/arlib/array.h
// Function: array<cstring>::resize_grow(unsigned long)
void resize_grow(size_t newcount)
	{
		if (this->count >= newcount) return;
		size_t prevcount = this->count;
		resize_grow_noinit(newcount);
		if constexpr (arrayview<T>::trivial_cons())
		{
			memset(this->items+prevcount, 0, sizeof(T)*(newcount-prevcount));
		}
		else
		{
			for (size_t i=prevcount;i<newcount;i++)
			{
				new(&this->items[i]) T();
			}
		}
	}

// 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 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jb 0x263f4
jmp 0x26440
movq -0x28(%rbp), %rdi
movq 0x8(%rdi), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x26270
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x26440
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x5f70
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x26411
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Alcaro[P]bridges/arlib/array.h
// Function: array<string>::resize_shrink(unsigned long)
void resize_shrink(size_t newcount)
	{
		if (this->count <= newcount) return;
		for (size_t i=newcount;i<this->count;i++)
		{
			this->items[i].~T();
		}
		resize_shrink_noinit(newcount);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
ja 0x27624
jmp 0x2766c
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0x2765f
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x5870
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2762c
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x274f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Alcaro[P]bridges/arlib/array.h
// Function: array<signed char>::insert(unsigned long, signed char&&)
T& insert(size_t index, T&& item)
	{
		char tmp[sizeof(T)]; // in case 'item' points into the current array
		new(&tmp) T(std::move(item));
		
		resize_grow_noinit(this->count+1);
		memmove((void*)(this->items+index+1), (void*)(this->items+index), sizeof(T)*(this->count-1-index));
		memcpy((void*)(&this->items[index]), tmp, sizeof(T));
		return this->items[index];
	}

// 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)
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movq 0x8(%rdi), %rsi
addq $0x1, %rsi
callq 0x1bbf0
movq -0x28(%rbp), %rax
movq (%rax), %rdi
addq -0x10(%rbp), %rdi
addq $0x1, %rdi
movq (%rax), %rsi
addq -0x10(%rbp), %rsi
movq 0x8(%rax), %rdx
subq $0x1, %rdx
subq -0x10(%rbp), %rdx
shlq $0x0, %rdx
callq 0x45f0
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rdx
movb -0x19(%rbp), %sil
movb %sil, (%rcx,%rdx)
movq (%rax), %rax
addq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Alcaro[P]bridges/arlib/array.h
// Function: array<signed char>::insert(unsigned long)
T& insert(size_t index)
	{
		resize_grow_noinit(this->count+1);
		memmove((void*)(this->items+index+1), (void*)(this->items+index), sizeof(T)*(this->count-1-index));
		new(&this->items[index]) T();
		return this->items[index];
	}

// 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 0x8(%rdi), %rsi
addq $0x1, %rsi
callq 0x1bbf0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
addq -0x10(%rbp), %rdi
addq $0x1, %rdi
movq (%rax), %rsi
addq -0x10(%rbp), %rsi
movq 0x8(%rax), %rdx
subq $0x1, %rdx
subq -0x10(%rbp), %rdx
shlq $0x0, %rdx
callq 0x45f0
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rdx
movb $0x0, (%rcx,%rdx)
movq (%rax), %rax
addq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Alcaro[P]bridges/arlib/array.h
// Function: array<string>::operator=(arrayview<string>)
array<T>& operator=(arrayview<T> other)
	{
		if (other.ptr() >= this->ptr() && other.ptr() < this->ptr()+this->size())
		{
			size_t start = other.ptr()-this->ptr();
			size_t len = other.size();
			
			for (size_t i=0;i<start;i++) this->items[i].~T();
			memmove((void*)this->ptr(), (void*)(this->ptr()+start), sizeof(T)*len);
			for (size_t i=start+len;i<this->count;i++) this->items[i].~T();
			
			resize_shrink_noinit(len);
		}
		else
		{
			for (size_t i=0;i<this->count;i++) this->items[i].~T();
			free(this->items);
			clone(other);
		}
		return *this;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x272c0
movq -0x50(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x28040
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jb 0x27fdf
leaq -0x10(%rbp), %rdi
callq 0x272c0
movq -0x50(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x28040
movq -0x50(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x27270
movq -0x60(%rbp), %rcx
movq %rax, %rdx
movq -0x58(%rbp), %rax
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x27fdf
leaq -0x10(%rbp), %rdi
callq 0x272c0
movq -0x50(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x28040
movq %rax, %rcx
movq -0x68(%rbp), %rax
subq %rcx, %rax
sarq $0x4, %rax
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x27270
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x27f5c
movq -0x50(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x5870
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x27f2d
movq -0x50(%rbp), %rdi
callq 0x28040
movq -0x50(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0x28040
movq -0x70(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rsi
movq -0x28(%rbp), %rdx
shlq $0x4, %rdx
callq 0x45f0
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x50(%rbp), %rcx
movq -0x38(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0x27fd0
movq -0x50(%rbp), %rax
movq (%rax), %rdi
movq -0x38(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x5870
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x27f9d
movq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x274f0
jmp 0x28033
movq $0x0, -0x40(%rbp)
movq -0x50(%rbp), %rcx
movq -0x40(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0x2801a
movq -0x50(%rbp), %rax
movq (%rax), %rdi
movq -0x40(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x5870
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x27fe7
movq -0x50(%rbp), %rax
movq (%rax), %rdi
callq 0x4420
movq -0x50(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x27170
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: Alcaro[P]bridges/arlib/array.h
// Function: array<string>::operator+=(arrayview<string>)
array<T>& operator+=(arrayview<T> other)
	{
		size_t prevcount = this->size();
		size_t othercount = other.size();
		
		const T* src;
		T* dst;
		
		if (other.ptr() >= this->ptr() && other.ptr() < this->ptr()+this->size())
		{
			size_t start = other.ptr()-this->ptr();
			
			resize_grow_noinit(prevcount + othercount);
			src = this->items+start;
			dst = this->items+prevcount;
		}
		else
		{
			resize_grow_noinit(prevcount + othercount);
			src = other.ptr();
			dst = this->items+prevcount;
		}
		
		if constexpr (arrayview<T>::trivial_copy())
		{
			memcpy(dst, src, sizeof(T)*othercount);
		}
		else
		{
			for (size_t i=0;i<othercount;i++)
			{
				new(&dst[i]) T(src[i]);
			}
		}
		
		return *this;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x27270
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x27270
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x272c0
movq -0x58(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x28040
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jb 0x28155
leaq -0x10(%rbp), %rdi
callq 0x272c0
movq -0x58(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x28040
movq -0x58(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x27270
movq -0x68(%rbp), %rcx
movq %rax, %rdx
movq -0x60(%rbp), %rax
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x28155
leaq -0x10(%rbp), %rdi
callq 0x272c0
movq -0x58(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0x28040
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movq -0x70(%rbp), %rax
subq %rcx, %rax
sarq $0x4, %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rsi
addq -0x28(%rbp), %rsi
callq 0x27420
movq -0x58(%rbp), %rax
movq (%rax), %rcx
movq -0x40(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq %rcx, -0x30(%rbp)
movq (%rax), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x2818c
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq -0x28(%rbp), %rsi
callq 0x27420
leaq -0x10(%rbp), %rdi
callq 0x272c0
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq (%rax), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x281cf
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq -0x30(%rbp), %rsi
movq -0x48(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rsi
callq 0x272e0
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x28194
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: Alcaro[P]bridges/arlib/array.h
// Function: array<signed char>::create_usurp(arrayvieww<signed char>)
static array<T> create_usurp(arrayvieww<T> data)
	{
		array<T> ret;
		ret.items = xrealloc(data.ptr(), sizeof(T)*capacity_for(data.size()));
		ret.count = data.size();
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1c900
movq -0x38(%rbp), %rdi
callq 0x1c690
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x1bca0
movq -0x38(%rbp), %rdi
callq 0x1baa0
movq %rax, %rdi
callq 0x1b970
movq %rax, %rsi
shlq $0x0, %rsi
movq -0x28(%rbp), %rdi
callq 0x2d690
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1bac0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
callq 0x1baa0
movq -0x30(%rbp), %rdi
movq %rax, 0x8(%rdi)
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x1c8e9
movq -0x30(%rbp), %rdi
callq 0x1c7e0
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Alcaro[P]bridges/arlib/array.h
// Function: array<signed char>::release()
arrayvieww<T> release()
	{
		arrayvieww<T> ret = *this;
		this->items = NULL;
		this->count = 0;
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x20(%rbp)
callq 0x1c970
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq $0x0, (%rcx)
movq $0x0, 0x8(%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Alcaro[P]bridges/arlib/array.h
// Function: array<string>::remove_range(unsigned long, unsigned long)
void remove_range(size_t start, size_t end)
	{
		for (size_t n=start;n<end;n++)
			this->items[n].~T();
		memmove((void*)(this->items+start), (void*)(this->items+end), sizeof(T)*(this->count-end));
		resize_shrink_noinit(this->count - (end-start));
	}

// 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 -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x27b13
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x5870
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x27ae4
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rdi
movq (%rax), %rsi
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rsi
movq 0x8(%rax), %rdx
subq -0x18(%rbp), %rdx
shlq $0x4, %rdx
callq 0x45f0
movq -0x28(%rbp), %rdi
movq 0x8(%rdi), %rsi
movq -0x18(%rbp), %rax
subq -0x10(%rbp), %rax
subq %rax, %rsi
callq 0x274f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Alcaro[P]bridges/arlib/json.cpp
// Function: jsonparser::nextch()
uint8_t jsonparser::nextch()
{
again: ;
	uint8_t ret = *(m_data++);
	if (ret >= 33) return ret;
	if (LIKELY(isspace(ret))) goto again;
	if (m_data > m_data_end)
	{
		m_data--;
		return '\0';
	}
	return '\1'; // all pre-space non-whitespace is invalid, just pick one at random
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rcx)
movb (%rax), %al
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x21, %eax
jl 0x2851d
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x2855a
movzbl -0x11(%rbp), %edi
callq 0x28570
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x28530
jmp 0x28532
jmp 0x284f4
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rax
cmpq 0x18(%rcx), %rax
jbe 0x28556
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x2855a
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Alcaro[P]bridges/arlib/json.cpp
// Function: jsonparser::skipcomma(unsigned long)
bool jsonparser::skipcomma(size_t depth)
{
	uint8_t ch = nextch();
	if (ch == ',' || ch == '\0')
	{
		if ((m_nesting.size() >= depth) == (ch == '\0')) return false;
		if (m_nesting.get_or(m_nesting.size()-depth, false) == true)
			m_want_key = true;
		if (ch == ',')
			m_need_value = true;
		return true;
	}
	if (ch == ']' || ch == '}')
	{
		m_data--;
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x284e0
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
cmpl $0x2c, %eax
je 0x285d6
movzbl -0x19(%rbp), %eax
cmpl $0x0, %eax
jne 0x2865c
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x9ee0
cmpq -0x18(%rbp), %rax
setae %al
andb $0x1, %al
movzbl %al, %eax
movzbl -0x19(%rbp), %ecx
cmpl $0x0, %ecx
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x28609
movb $0x0, -0x1(%rbp)
jmp 0x28688
movq -0x28(%rbp), %rdi
movq %rdi, %rax
addq $0x28, %rax
movq %rax, -0x30(%rbp)
addq $0x28, %rdi
callq 0x9ee0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
subq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x9f00
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x28645
movq -0x28(%rbp), %rax
movb $0x1, 0x20(%rax)
movzbl -0x19(%rbp), %eax
cmpl $0x2c, %eax
jne 0x28656
movq -0x28(%rbp), %rax
movb $0x1, 0x21(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x28688
movzbl -0x19(%rbp), %eax
cmpl $0x5d, %eax
je 0x2866e
movzbl -0x19(%rbp), %eax
cmpl $0x7d, %eax
jne 0x28684
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x28688
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Alcaro[P]bridges/arlib/json.cpp
// Function: JSON::parse(string)
bool JSON::parse(string s)
{
	// it would not do to have some function changing the value of null for everybody else
	// this check is only needed here; all of JSON's other members are conceptually const, though most aren't marked as such
	if (this == &c_null)
		abort();
	
	m_chld_list.reset();
	m_chld_map.reset();
	
	jsonparser p(std::move(s));
	bool ok = true;
	jsonparser::event ev = p.next();
	construct(p, ev, &ok, 1000);
	
	ev = p.next();
	if (!ok || ev.action != jsonparser::finish)
	{
		m_action = jsonparser::error;
		return false;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0xb0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq 0x569f4(%rip), %rcx     # 0x81380
cmpq %rcx, %rax
jne 0x2a996
callq 0x4180
movq -0xa8(%rbp), %rdi
addq $0x20, %rdi
callq 0x2adc0
movq -0xa8(%rbp), %rdi
addq $0x30, %rdi
callq 0x2ade0
movq -0xb0(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x5d40
leaq -0x50(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2ae00
leaq -0x60(%rbp), %rdi
callq 0x5870
movb $0x1, -0x61(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x286a0
movq -0xa8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x80(%rbp), %rdx
leaq -0x61(%rbp), %rcx
movl $0x3e8, %r8d            # imm = 0x3E8
callq 0x2a650
leaq -0x98(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x286a0
movq -0x98(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x70(%rbp)
testb $0x1, -0x61(%rbp)
je 0x2aa48
cmpl $0xc, -0x80(%rbp)
je 0x2aa65
movq -0xa8(%rbp), %rax
movl $0xb, (%rax)
movb $0x0, -0x1(%rbp)
movl $0x1, -0x9c(%rbp)
jmp 0x2aa73
movb $0x1, -0x1(%rbp)
movl $0x1, -0x9c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2af90
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Alcaro[P]bridges/arlib/set.h
// Function: set<map<string, JSON>::node>::construct()
void construct()
	{
		m_data = NULL;
		m_valid.resize(8);
		m_count = 0;
		m_used_slots = 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq $0x0, (%rdi)
addq $0x8, %rdi
movl $0x8, %esi
callq 0x66f0
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq $0x0, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Alcaro[P]bridges/arlib/set.h
// Function: set<map<string, JSON>::node>::destruct()
void destruct()
	{
		for (size_t i=0;i<m_valid.size();i++)
		{
			if (m_valid[i])
			{
				m_data[i].~T();
			}
		}
		m_count = 0;
		m_used_slots = 0;
		free(m_data);
		m_valid.reset();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x8, %rdi
callq 0x9ee0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x2b799
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0xa130
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xa160
testb $0x1, %al
jne 0x2b775
jmp 0x2b789
movq -0x28(%rbp), %rax
movq (%rax), %rdi
imulq $0x68, -0x10(%rbp), %rax
addq %rax, %rdi
callq 0x2b7d0
jmp 0x2b78b
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2b72c
movq -0x28(%rbp), %rax
movq $0x0, 0x20(%rax)
movq $0x0, 0x18(%rax)
movq (%rax), %rdi
callq 0x4420
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x2b800
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Alcaro[P]bridges/arlib/set.h
// Function: map<string, JSON>::node& set<map<string, JSON>::node>::get_create<string>(string const&, bool)
T& get_create(const T2& item, bool known_new = false)
	{
		if (!m_data)
			rehash(m_valid.size());
		
		size_t pos = known_new ? -1 : find_pos_insert(item);
		
		if (pos == (size_t)-1 || !m_valid[pos])
		{
			grow();
			pos = find_pos_insert(item); // recalculate this, grow() may have moved it
			//do not move grow() earlier; it invalidates references, get_create(item_that_exists) is not allowed to do that
			
			if (tag(pos) == i_empty) m_used_slots++;
			new(&m_data[pos]) T(item);
			m_valid[pos] = true;
			m_count++;
		}
		
		return m_data[pos];
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, (%rax)
jne 0x2ba5e
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x9ee0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x2bb70
testb $0x1, -0x11(%rbp)
je 0x2ba71
movq $-0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x2ba82
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2bcd0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x1, %al
cmpq $-0x1, -0x20(%rbp)
movb %al, -0x51(%rbp)
je 0x2babd
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
callq 0xa130
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa160
xorb $-0x1, %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x2bac9
jmp 0x2bb57
movq -0x48(%rbp), %rdi
callq 0x2bd00
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2bcd0
movq -0x48(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x2bda0
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x2bb08
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x48(%rbp), %rax
movq (%rax), %rdi
imulq $0x68, -0x20(%rbp), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x2bdc0
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
callq 0xa130
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x2be00
movq -0x48(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
movq -0x48(%rbp), %rax
movq (%rax), %rax
imulq $0x68, -0x20(%rbp), %rcx
addq %rcx, %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: Alcaro[P]bridges/arlib/set.h
// Function: set<map<string, JSON>::node>::rehash(unsigned long)
void rehash(size_t newsize)
	{
		T* prev_data = m_data;
		bitarray prev_valid = std::move(m_valid);
		
		m_data = xcalloc(newsize, sizeof(T));
		static_assert(sizeof(T) >= 1); // otherwise the tags mess up (zero-size objects are useless in sets, 
		m_valid.reset();               // and I'm not sure if they're expressible in standard C++, but no reason not to check)
		m_valid.resize(newsize);
		
		for (size_t i=0;i<prev_valid.size();i++)
		{
			if (!prev_valid[i]) continue;
			
			size_t pos = find_pos_full<true, false>(prev_data[i]);
			//this is known to not overwrite any existing object; if it does, someone screwed up
			memcpy((void*)&m_data[pos], (void*)&prev_data[i], sizeof(T));
			m_valid[pos] = true;
		}
		free(prev_data);
		m_used_slots = m_count;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x68(%rbp)
movq (%rsi), %rax
movq %rax, -0x18(%rbp)
addq $0x8, %rsi
leaq -0x28(%rbp), %rdi
callq 0x2be40
movq -0x10(%rbp), %rdi
movl $0x68, %esi
callq 0x2d730
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2be70
movq -0x68(%rbp), %rdi
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x2b800
movq -0x68(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x66f0
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9ee0
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0x2bca2
movq -0x38(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0xa130
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xa160
xorb $-0x1, %al
testb $0x1, %al
jne 0x2bc27
jmp 0x2bc29
jmp 0x2bc91
movq -0x68(%rbp), %rdi
movq -0x18(%rbp), %rsi
imulq $0x68, -0x38(%rbp), %rax
addq %rax, %rsi
callq 0x2be90
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq (%rax), %rdi
imulq $0x68, -0x50(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
imulq $0x68, -0x38(%rbp), %rax
addq %rax, %rsi
movl $0x68, %edx
callq 0x4280
movq -0x68(%rbp), %rdi
addq $0x8, %rdi
movq -0x50(%rbp), %rsi
callq 0xa130
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
leaq -0x60(%rbp), %rdi
movl $0x1, %esi
callq 0x2be00
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x2bbe0
movq -0x18(%rbp), %rdi
callq 0x4420
movq -0x68(%rbp), %rax
movq 0x20(%rax), %rcx
movq %rcx, 0x18(%rax)
leaq -0x28(%rbp), %rdi
callq 0x6a60
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Alcaro[P]bridges/arlib/set.h
// Function: set<map<string, JSON>::node>::grow()
void grow()
	{
		// half full -> rehash
		if (m_count >= m_valid.size()/2)
			rehash(m_valid.size()*2);
		else if (m_used_slots >= m_valid.size()/4*3)
			rehash(m_valid.size());
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq 0x20(%rdi), %rax
movq %rax, -0x10(%rbp)
addq $0x8, %rdi
callq 0x9ee0
movq %rax, %rcx
movq -0x10(%rbp), %rax
shrq %rcx
cmpq %rcx, %rax
jb 0x2bd52
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x9ee0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
shlq %rsi
callq 0x2bb70
jmp 0x2bd96
movq -0x18(%rbp), %rdi
movq 0x18(%rdi), %rax
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
callq 0x9ee0
movq %rax, %rcx
movq -0x20(%rbp), %rax
shrq $0x2, %rcx
imulq $0x3, %rcx, %rcx
cmpq %rcx, %rax
jb 0x2bd94
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x9ee0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x2bb70
jmp 0x2bd96
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Alcaro[P]bridges/arlib/set.h
// Function: unsigned long set<map<string, JSON>::node>::find_pos_full<true, true, string>(string const&) const
size_t find_pos_full(const T2& item) const
	{
		if (!m_data) return -1;
		
		size_t hashv = hash_shuffle(local_hash<T2>(item, 0));
		size_t i = 0;
		
		size_t emptyslot = -1;
		
		while (true)
		{
			//I could use hashv + i+(i+1)/2 <http://stackoverflow.com/a/15770445>
			//but due to hash_shuffle, it hurts as much as it helps.
			size_t pos = (hashv + i) & (m_valid.size()-1);
			if (want_used && m_valid[pos] && m_data[pos] == item)
				return pos;
			if (!m_valid[pos])
			{
				if (emptyslot == (size_t)-1) emptyslot = pos;
				if (tag(pos) == i_empty)
				{
					if (want_empty) return emptyslot;
					else return -1;
				}
			}
			i++;
//if(i > m_valid.size()) *(char*)1=1;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, (%rax)
jne 0x2c1db
movq $-0x1, -0x8(%rbp)
jmp 0x2c2c2
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x2c2d0
movq %rax, %rdi
callq 0x2bfb0
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $-0x1, -0x30(%rbp)
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0x8, %rdi
callq 0x9ee0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movq -0x48(%rbp), %rax
subq $0x1, %rcx
andq %rcx, %rax
movq %rax, -0x38(%rbp)
addq $0x8, %rdi
movq -0x38(%rbp), %rsi
callq 0x2c040
testb $0x1, %al
jne 0x2c244
jmp 0x2c26c
movq -0x40(%rbp), %rax
movq (%rax), %rdi
imulq $0x68, -0x38(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x2c2f0
testb $0x1, %al
jne 0x2c262
jmp 0x2c26c
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2c2c2
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
movq -0x38(%rbp), %rsi
callq 0x2c040
testb $0x1, %al
jne 0x2c2b1
cmpq $-0x1, -0x30(%rbp)
jne 0x2c290
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x2c070
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x2c2af
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2c2c2
jmp 0x2c2b1
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2c202
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: Alcaro[P]bridges/arlib/hash.h
// Function: hash_shuffle(unsigned long)
inline uint64_t hash_shuffle(uint64_t val)
{
	//http://zimbry.blogspot.se/2011/09/better-bit-mixing-improving-on.html Mix13
	// update staticmap.cpp if changing this
	val ^= val >> 30;
	val *= 0xbf58476d1ce4e5b9;
	val ^= val >> 27;
	val *= 0x94d049bb133111eb;
	val ^= val >> 31;
	return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x1e, %rax
xorq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movabsq $-0x40a7b892e31b1a47, %rax # imm = 0xBF58476D1CE4E5B9
imulq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x1b, %rax
xorq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movabsq $-0x6b2fb644ecceee15, %rax # imm = 0x94D049BB133111EB
imulq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x1f, %rax
xorq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Alcaro[P]bridges/arlib/json.h
// Function: jsonwriter::comma()
void comma()
	{
		if (m_comma) m_data += ',';
		m_comma = true;
		
		if (UNLIKELY(m_indent_block == 0))
		{
			if (m_indent_is_value)
			{
				m_data += ' ';
				m_indent_is_value = false;
			}
			else if (m_indent_depth)
			{
				cstring indent_str = (&"        "[8-m_indent_size]);
				m_data += '\n';
				for (int i=0;i<m_indent_depth;i++)
				{
					m_data += indent_str;
				}
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
testb $0x1, 0x10(%rax)
je 0x2c8f8
movq -0x38(%rbp), %rdi
movl $0x2c, %esi
callq 0x5b40
movq -0x38(%rbp), %rax
movb $0x1, 0x10(%rax)
movzbl 0x12(%rax), %eax
cmpl $0x0, %eax
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2c917
jmp 0x2c9ba
movq -0x38(%rbp), %rax
testb $0x1, 0x11(%rax)
je 0x2c939
movq -0x38(%rbp), %rdi
movl $0x20, %esi
callq 0x5b40
movq -0x38(%rbp), %rax
movb $0x0, 0x11(%rax)
jmp 0x2c9b8
movq -0x38(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x2c9b6
movq -0x38(%rbp), %rax
movzbl 0x13(%rax), %ecx
movl $0x8, %eax
subl %ecx, %eax
cltq
leaq 0x37172(%rip), %rsi     # 0x63acd
addq %rax, %rsi
leaq -0x18(%rbp), %rdi
callq 0x58c0
movq -0x38(%rbp), %rdi
movl $0xa, %esi
callq 0x5b40
movl $0x0, -0x1c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x14(%rcx), %eax
jge 0x2c9b4
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x5e00
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2c97c
jmp 0x2c9b6
jmp 0x2c9b8
jmp 0x2c9ba
addq $0x40, %rsp
popq %rbp
retq
// File: Alcaro[P]bridges/arlib/memmem.cpp
// Function: memmem_arlib(void const*, unsigned long, void const*, unsigned long)
void* memmem_arlib(const void * haystack, size_t haystacklen, const void * needle, size_t needlelen)
{
	if (UNLIKELY(needlelen == 0)) return (void*)haystack;
	
	const void * hay_orig = haystack;
	haystack = memchr(haystack, *(uint8_t*)needle, haystacklen);
	if (!haystack) return NULL;
	if (needlelen == 1) return (void*)haystack;
	
	haystacklen -= (uint8_t*)haystack - (uint8_t*)hay_orig;
	if (UNLIKELY(needlelen > haystacklen)) return NULL;
	
#ifdef runtime__SSE4_2__
	// don't use this for needle length 16, both do one byte per iteration and _mm_cmpestri is slow
	if (needlelen <= 15 && runtime__SSE4_2__) return (void*)memmem_sse42((uint8_t*)haystack, haystacklen, (uint8_t*)needle, needlelen);
#endif
	
#if !defined(_WIN32) && !defined(ARLIB_TEST) // for long needles, use libc; we're roughly equally fast, and code reuse means smaller
	return memmem(haystack, haystacklen, needle, needlelen);
#endif
	
	return (void*)memmem_rollhash((uint8_t*)haystack, haystacklen, (uint8_t*)needle, needlelen);
}

// 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)
cmpq $0x0, -0x28(%rbp)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2d1fa
jmp 0x2d207
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2d2d2
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movzbl (%rax), %esi
movq -0x18(%rbp), %rdx
callq 0x43a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2d23b
movq $0x0, -0x8(%rbp)
jmp 0x2d2d2
cmpq $0x1, -0x28(%rbp)
jne 0x2d24f
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2d2d2
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
subq %rax, %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
seta %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2d27a
jmp 0x2d284
movq $0x0, -0x8(%rbp)
jmp 0x2d2d2
cmpq $0xf, -0x28(%rbp)
ja 0x2d2b9
leaq 0x54062(%rip), %rax     # 0x812f4
movl (%rax), %eax
andl $0x100000, %eax         # imm = 0x100000
cmpl $0x0, %eax
je 0x2d2b9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x2d2e0
movq %rax, -0x8(%rbp)
jmp 0x2d2d2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x4610
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Alcaro[P]bridges/arlib/misc.cpp
// Function: xmalloc(unsigned long)
anyptr xmalloc(size_t size)
{
	_test_malloc();
	if (size >= 0x80000000) malloc_fail(size);
	void* ret = try_malloc(size);
	if (size && !ret) malloc_fail(size);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x80000000, %eax       # imm = 0x80000000
cmpq %rax, -0x10(%rbp)
jb 0x2d600
movq -0x10(%rbp), %rdi
callq 0x2d650
movq -0x10(%rbp), %rdi
callq 0x2eed0
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2ef00
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2d631
cmpq $0x0, -0x18(%rbp)
jne 0x2d631
movq -0x10(%rbp), %rdi
callq 0x2d650
movq -0x18(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x2ef20
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Alcaro[P]bridges/arlib/misc.cpp
// Function: xrealloc(anyptr, unsigned long)
anyptr xrealloc(anyptr ptr, size_t size)
{
	if ((void*)ptr) _test_free();
	if (size) _test_malloc();
	if (size >= 0x80000000) malloc_fail(size);
	void* ret = try_realloc(ptr, size);
	if (size && !ret) malloc_fail(size);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x2ef00
cmpq $0x0, %rax
je 0x2d6b1
jmp 0x2d6b1
cmpq $0x0, -0x18(%rbp)
je 0x2d6ba
jmp 0x2d6ba
movl $0x80000000, %eax       # imm = 0x80000000
cmpq %rax, -0x18(%rbp)
jb 0x2d6ce
movq -0x18(%rbp), %rdi
callq 0x2d650
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x2ef40
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2ef00
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2d70b
cmpq $0x0, -0x20(%rbp)
jne 0x2d70b
movq -0x18(%rbp), %rdi
callq 0x2d650
movq -0x20(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x2ef20
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Alcaro[P]bridges/arlib/misc.cpp
// Function: hash(unsigned char const*, unsigned long)
size_t hash(const uint8_t * val, size_t n)
{
	// update staticmap.cpp if changing this
	
	size_t hash = 5381;
	while (n >= sizeof(size_t))
	{
		size_t tmp;
		memcpy(&tmp, val, sizeof(size_t));        // extra >>7 because otherwise bottom byte of output would
		hash = (hash^(hash>>7)^tmp) * 2546270801; //  only be affected by every 8th byte of input
		val += sizeof(size_t);                    // the number is just a random prime between 2^31 and 2^32
		n -= sizeof(size_t);
	}
	while (n)
	{
		hash = (hash ^ *val) * 31; // 31 is a quite common multiplier, don't know why
		val++;
		n--;
	}
	return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x1505, -0x18(%rbp)    # imm = 0x1505
cmpq $0x8, -0x10(%rbp)
jb 0x2d805
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
shrq $0x7, %rcx
xorq %rcx, %rax
xorq -0x20(%rbp), %rax
movabsq $0x97c50251, %rcx       # imm = 0x97C50251
imulq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
subq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x2d7b4
jmp 0x2d807
cmpq $0x0, -0x10(%rbp)
je 0x2d83e
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
xorq %rcx, %rax
imulq $0x1f, %rax, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2d807
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Alcaro[P]bridges/arlib/misc.cpp
// Function: debugc8(long long vector[2] const&)
void debugc8(const __m128i& vals)
{
	char inner[sizeof(__m128i)/sizeof(char)];
	memcpy(inner, &vals, sizeof(__m128i));
	for (size_t i : range(ARRAY_SIZE(inner)))
		printf("%c%c", inner[i], (i == ARRAY_SIZE(inner)-1 ? '\n' : ' '));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
leaq -0x60(%rbp), %rdi
movl $0x10, %esi
callq 0x2d990
leaq -0x60(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x13f00
movq %rax, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
movq -0x48(%rbp), %rdi
callq 0x13f30
movq %rax, -0x80(%rbp)
movq %rdx, -0x78(%rbp)
leaq -0x70(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x80(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x2ee87
leaq -0x70(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movsbl -0x40(%rbp,%rax), %eax
movl %eax, -0x90(%rbp)
movq -0x88(%rbp), %rcx
movb $0xa, %al
movb $0x20, %dl
movb %dl, -0x8a(%rbp)
cmpq $0xf, %rcx
movb %al, -0x89(%rbp)
je 0x2ee4f
movb -0x8a(%rbp), %al
movb %al, -0x89(%rbp)
movl -0x90(%rbp), %esi
movb -0x89(%rbp), %al
movsbl %al, %edx
leaq 0x34c8b(%rip), %rdi     # 0x63af0
movb $0x0, %al
callq 0x4050
leaq -0x70(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x2edda
addq $0x90, %rsp
popq %rbp
retq
// File: Alcaro[P]bridges/arlib/opengl/ctx-x11.cpp
// Function: aropengl_base::context::create(unsigned int, unsigned int, unsigned long, unsigned long*, unsigned int)
aropengl::context* aropengl::context::create(uint32_t width, uint32_t height, uintptr_t parent, uintptr_t* window, uint32_t flags)
{
	aropengl_x11* ret = new aropengl_x11();
	if (ret->init(width, height, parent, window, flags)) return ret;
	
	delete ret;
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl $0x20, %edi
callq 0x4340
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
xorl %esi, %esi
movl $0x20, %edx
callq 0x4170
movq -0x38(%rbp), %rdi
callq 0x2f330
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl -0x24(%rbp), %r9d
callq 0x2f370
testb $0x1, %al
jne 0x2f2f9
jmp 0x2f303
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f323
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x2f31b
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Alcaro[P]bridges/arlib/opengl/ctx-x11.cpp
// Function: (anonymous namespace)::aropengl_x11::destroy()
void destroy()
	{
		glx.MakeCurrent(window_x11.display, None, NULL);
		glx.DestroyContext(window_x11.display, ctx);
		
		XDestroyWindow(window_x11.display, win);
		libUnload();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x51bfd(%rip), %rax     # 0x813e8
leaq 0x51b76(%rip), %rcx     # 0x81368
movq (%rcx), %rdi
xorl %ecx, %ecx
movl %ecx, %edx
movq %rdx, %rsi
callq *%rax
movq -0x10(%rbp), %rcx
movq 0x51c0f(%rip), %rax     # 0x81418
leaq 0x51b58(%rip), %rdx     # 0x81368
movq (%rdx), %rdi
movq 0x8(%rcx), %rsi
callq *%rax
movq -0x10(%rbp), %rax
leaq 0x51b44(%rip), %rcx     # 0x81368
movq (%rcx), %rdi
movq 0x10(%rax), %rsi
callq 0x45b0
callq 0x2f8b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Alcaro[P]bridges/arlib/opengl/ctx-x11.cpp
// Function: (anonymous namespace)::libLoad()
static bool libLoad()
{
	glx.lib = dlopen("libGL.so", RTLD_LAZY);
	if (!glx.lib) return false;
	
	const char * names = glx_proc_names;
	funcptr* functions=(funcptr*)&glx;
	while (*names)
	{
		*functions = (funcptr)dlsym(glx.lib, names);
		if (!*functions) return false;
		
		functions++;
		names += strlen(names)+1;
	}
	
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x342a3(%rip), %rdi     # 0x63b72
movl $0x1, %esi
callq 0x44b0
movq %rax, 0x51b48(%rip)     # 0x81428
cmpq $0x0, 0x51b40(%rip)     # 0x81428
jne 0x2f8f0
movb $0x0, -0x1(%rbp)
jmp 0x2f960
leaq 0x34289(%rip), %rax     # 0x63b80
movq %rax, -0x10(%rbp)
leaq 0x51ad6(%rip), %rax     # 0x813d8
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2f95c
movq 0x51b12(%rip), %rdi     # 0x81428
movq -0x10(%rbp), %rsi
callq 0x4330
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2f939
movb $0x0, -0x1(%rbp)
jmp 0x2f960
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40f0
addq $0x1, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x2f906
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)