LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: kipa00[P]AplusB-mc/compiler/chunk.cpp
// Function: need_progress(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int need_progress(int stage, string name) {
	if (stage == 0 && name == "") return 1;
	else if (stage == 1 && name == "Level") return 2;
	else if (stage == 2 && name == "Sections") return 3;
	else if (stage == 3 && name == "Palette") return 4;
	else if (stage == 4 && name == "Properties") return 5;
	return stage;
}

// Assembly:
subq $0x18, %rsp
movq %rsi, (%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpl $0x0, 0x10(%rsp)
jne 0x794b
movq (%rsp), %rdi
leaq 0xbbd5(%rip), %rsi      # 0x13508
callq 0x9810
testb $0x1, %al
jne 0x793e
jmp 0x794b
movl $0x1, 0x14(%rsp)
jmp 0x79fa
cmpl $0x1, 0x10(%rsp)
jne 0x7975
movq (%rsp), %rdi
leaq 0xb9d7(%rip), %rsi      # 0x13334
callq 0x9810
testb $0x1, %al
jne 0x7968
jmp 0x7975
movl $0x2, 0x14(%rsp)
jmp 0x79fa
cmpl $0x2, 0x10(%rsp)
jne 0x799c
movq (%rsp), %rdi
leaq 0xb9b3(%rip), %rsi      # 0x1333a
callq 0x9810
testb $0x1, %al
jne 0x7992
jmp 0x799c
movl $0x3, 0x14(%rsp)
jmp 0x79fa
cmpl $0x3, 0x10(%rsp)
jne 0x79c3
movq (%rsp), %rdi
leaq 0xb995(%rip), %rsi      # 0x13343
callq 0x9810
testb $0x1, %al
jne 0x79b9
jmp 0x79c3
movl $0x4, 0x14(%rsp)
jmp 0x79fa
cmpl $0x4, 0x10(%rsp)
jne 0x79ea
movq (%rsp), %rdi
leaq 0xb976(%rip), %rsi      # 0x1334b
callq 0x9810
testb $0x1, %al
jne 0x79e0
jmp 0x79ea
movl $0x5, 0x14(%rsp)
jmp 0x79fa
jmp 0x79ec
jmp 0x79ee
jmp 0x79f0
jmp 0x79f2
movl 0x10(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: kipa00[P]AplusB-mc/compiler/chunk.cpp
// Function: chunk::init()
void chunk::init() {
	this->block = 0;
	this->y = 255;
	this->palette.clear();
	this->world_data = new byte *[16];
	this->attr = 0;
	memset(this->world_data, 0, sizeof(byte *) * 16);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x0, 0xc(%rdi)
movl $0xff, 0x4(%rdi)
addq $0x18, %rdi
callq 0x9870
movl $0x80, %edi
callq 0x2030
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
movl $0x0, 0x10(%rax)
movq 0x30(%rax), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x20f0
addq $0x18, %rsp
retq
nopl (%rax)
// File: kipa00[P]AplusB-mc/compiler/chunk.cpp
// Function: chunk::flush_section()
void chunk::flush_section() {
	if (0 <= this->y && this->y < 16) {
		if (!this->br.init_needed()) {
			if (this->world_data[this->y]) {
				fprintf(stderr, "Error: duplicate section y = %d; did you edit the world using hex editor?\n", this->y);
				throw DUPLICATE_Y_SECTION_ERROR;
			}
			this->world_data[this->y] = new byte[4096];
			const int needed_bit = this->palette.size() < 2U ? 4 : std::max(4, 32 - __builtin_clz((int)this->palette.size() - 1));
			for (int i=0; i<4096; ++i) {
				int x = this->br.read(needed_bit);
				this->world_data[this->y][i] = this->palette[x];
			}
		}
	}
	this->block = 0;
	this->y = 255;
	this->palette.clear();
	this->br.init(nullptr);
#ifdef CHUNK_DEBUG
	printf("section end\n");
#endif
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, 0x10(%rsp)
xorl %eax, %eax
cmpl 0x4(%rcx), %eax
jg 0x88c2
movq 0x10(%rsp), %rax
cmpl $0x10, 0x4(%rax)
jge 0x88c2
movq 0x10(%rsp), %rdi
addq $0x38, %rdi
callq 0x9bb0
testb $0x1, %al
jne 0x88c0
movq 0x10(%rsp), %rcx
movq 0x30(%rcx), %rax
movslq 0x4(%rcx), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x87da
movq 0x10(%rsp), %rax
movq 0x1183d(%rip), %rcx     # 0x19fe0
movq (%rcx), %rdi
movl 0x4(%rax), %edx
leaq 0xad59(%rip), %rsi      # 0x13509
movb $0x0, %al
callq 0x2290
movl $0x4, %edi
callq 0x20d0
movq %rax, %rdi
movl $0xfffffffd, (%rdi)     # imm = 0xFFFFFFFD
movq 0x117f7(%rip), %rsi     # 0x19fc8
xorl %eax, %eax
movl %eax, %edx
callq 0x22f0
movl $0x1000, %edi           # imm = 0x1000
callq 0x2030
movq 0x10(%rsp), %rdi
movq %rax, %rdx
movq 0x30(%rdi), %rax
movslq 0x4(%rdi), %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x18, %rdi
callq 0x5540
cmpq $0x2, %rax
jae 0x8812
movl $0x4, %eax
movl %eax, 0xc(%rsp)
jmp 0x8851
movq 0x10(%rsp), %rdi
movl $0x4, 0x28(%rsp)
addq $0x18, %rdi
callq 0x5540
subl $0x1, %eax
bsrl %eax, %ecx
xorl $0x1f, %ecx
movl $0x20, %eax
subl %ecx, %eax
movl %eax, 0x24(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x24(%rsp), %rsi
callq 0x9890
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x2c(%rsp)
movl $0x0, 0x20(%rsp)
cmpl $0x1000, 0x20(%rsp)     # imm = 0x1000
jge 0x88be
movq 0x10(%rsp), %rdi
addq $0x38, %rdi
movl 0x2c(%rsp), %esi
callq 0x9a80
movq 0x10(%rsp), %rdi
movl %eax, 0x1c(%rsp)
addq $0x18, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x98d0
movq 0x10(%rsp), %rcx
movl (%rax), %eax
movb %al, %dl
movq 0x30(%rcx), %rax
movslq 0x4(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x20(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x8861
jmp 0x88c0
jmp 0x88c2
movq 0x10(%rsp), %rdi
movl $0x0, 0xc(%rdi)
movl $0xff, 0x4(%rdi)
addq $0x18, %rdi
callq 0x9870
movq 0x10(%rsp), %rdi
addq $0x38, %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x9b80
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: kipa00[P]AplusB-mc/compiler/chunk.cpp
// Function: chunk::flush_block()
void chunk::flush_block() {
	this->palette.push_back(this->block);
	// attribute validation
	const int attributes[] = {
		0, 0, 0, 0, ATTR_POWER | ATTR_EAST | ATTR_WEST | ATTR_SOUTH | ATTR_NORTH /* wire */,
		ATTR_LIT /* torch */, ATTR_LIT | ATTR_FACING /* wall torch */,
		ATTR_FACING | ATTR_MODE | ATTR_POWERED /* comparator */,
		ATTR_DELAY | ATTR_FACING | ATTR_LOCKED | ATTR_POWERED,
		ATTR_DELAY | ATTR_FACING | ATTR_LOCKED | ATTR_POWERED /* repeater */,
		ATTR_LIT /* lamp */, ATTR_FACE | ATTR_FACING | ATTR_POWERED /* lever */, 0
	};
	if (attributes[this->block >> 4] != this->attr) {
		fprintf(stderr, "Error: block has missing or extra attribute; did you edit the world using hex editor?\n");
		throw ATTR_MISMATCH_ERROR;
	}
#ifdef CHUNK_DEBUG
	printf("block = %02X\n", this->block);
#endif
	this->block = 0;
	this->attr = 0;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rsi
movq %rsi, 0x8(%rsp)
movq %rsi, %rdi
addq $0x18, %rdi
addq $0xc, %rsi
callq 0x4820
leaq 0x10(%rsp), %rdi
leaq 0xa9d1(%rip), %rsi      # 0x13300
movl $0x34, %edx
callq 0x2160
movq 0x8(%rsp), %rcx
movl 0xc(%rcx), %eax
sarl $0x4, %eax
cltq
movl 0x10(%rsp,%rax,4), %eax
cmpl 0x10(%rcx), %eax
je 0x898a
movq 0x1168a(%rip), %rax     # 0x19fe0
movq (%rax), %rdi
leaq 0xabf4(%rip), %rsi      # 0x13554
movb $0x0, %al
callq 0x2290
movl $0x4, %edi
callq 0x20d0
movq %rax, %rdi
movl $0xfffffff8, (%rdi)     # imm = 0xFFFFFFF8
movq 0x11647(%rip), %rsi     # 0x19fc8
xorl %eax, %eax
movl %eax, %edx
callq 0x22f0
movq 0x8(%rsp), %rax
movl $0x0, 0xc(%rax)
movl $0x0, 0x10(%rax)
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: kipa00[P]AplusB-mc/compiler/chunk.cpp
// Function: chunk::~chunk()
chunk::~chunk() {
	if (this->world_data) {
		int i;
		for (i=0; i<16; ++i) {
			if (this->world_data[i]) {
				delete [](this->world_data[i]);
			}
		}
		delete []this->world_data;
		this->world_data = nullptr;
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x30(%rax)
je 0x9583
movl $0x0, 0x1c(%rsp)
cmpl $0x10, 0x1c(%rsp)
jge 0x955a
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movslq 0x1c(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x954b
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x9549
movq 0x8(%rsp), %rdi
callq 0x2270
jmp 0x954b
jmp 0x954d
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x9506
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x9576
movq (%rsp), %rdi
callq 0x2270
movq 0x10(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
callq 0x4b10
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: kipa00[P]AplusB-mc/compiler/chunk.cpp
// Function: chunk::getXYZ(int, int, int)
byte chunk::getXYZ(int x, int y, int z) {
	if (!this->world_data) return AIR;
	int idx = y >> 4;
	if (!this->world_data[idx]) return AIR;
	return this->world_data[idx][((y & 15) << 8) | ((z & 15) << 4) | (x & 15)];
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movl %edx, -0x18(%rsp)
movl %ecx, -0x1c(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
cmpq $0x0, 0x30(%rax)
jne 0x95c9
movb $0x0, -0x1(%rsp)
jmp 0x962b
movq -0x28(%rsp), %rax
movl -0x18(%rsp), %ecx
sarl $0x4, %ecx
movl %ecx, -0x20(%rsp)
movq 0x30(%rax), %rax
movslq -0x20(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x95f0
movb $0x0, -0x1(%rsp)
jmp 0x962b
movq -0x28(%rsp), %rax
movq 0x30(%rax), %rax
movslq -0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x18(%rsp), %ecx
andl $0xf, %ecx
shll $0x8, %ecx
movl -0x1c(%rsp), %edx
andl $0xf, %edx
shll $0x4, %edx
orl %edx, %ecx
movl -0x14(%rsp), %edx
andl $0xf, %edx
orl %edx, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x1(%rsp)
movb -0x1(%rsp), %al
retq
// File: kipa00[P]AplusB-mc/compiler/chunk.cpp
// Function: chunk::has_world_data(int) const
bool chunk::has_world_data(int cy) const {
	if (!(0 <= cy && cy < 16)) return false;
	if (!this->world_data) return false;
	if (!this->world_data[cy]) return false;
	return true;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
xorl %eax, %eax
cmpl -0x14(%rsp), %eax
jg 0x9652
cmpl $0x10, -0x14(%rsp)
jl 0x9659
movb $0x0, -0x1(%rsp)
jmp 0x968d
movq -0x20(%rsp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x966c
movb $0x0, -0x1(%rsp)
jmp 0x968d
movq -0x20(%rsp), %rax
movq 0x30(%rax), %rax
movslq -0x14(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x9688
movb $0x0, -0x1(%rsp)
jmp 0x968d
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: kipa00[P]AplusB-mc/compiler/chunk.cpp
// Function: chunk::troubleshoot(int, int)
bool chunk::troubleshoot(int x, int z) {
	const int target = (int)this->palette.size();
	if (0 <= this->y && this->y < 16 && !this->br.init_needed()) {
		for (int i=0; i<4096; ++i) {
			int x = this->br.read(this->troubleshoot_bit);
			if (x == target) {
				const int y_coord = (this->y << 4) | (i >> 8);
				if (0 <= y_coord && y_coord < 256) {
					fprintf(stderr, "exact location might be (%d, %d, %d)\n", (x << 4) | (i & 15), y_coord, (z << 4) | ((i >> 4) & 15));
				} else {
					fprintf(stderr, "exact location might be (%d, ?, %d)\n", (x << 4) | (i & 15), (z << 4) | ((i >> 4) & 15));
				}
				return true;
			}
		}
	}
	return false;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x18, %rdi
callq 0x5540
movq 0x8(%rsp), %rcx
movl %eax, 0x1c(%rsp)
xorl %eax, %eax
cmpl 0x4(%rcx), %eax
jg 0x97fd
movq 0x8(%rsp), %rax
cmpl $0x10, 0x4(%rax)
jge 0x97fd
movq 0x8(%rsp), %rdi
addq $0x38, %rdi
callq 0x9bb0
testb $0x1, %al
jne 0x97fd
movl $0x0, 0x18(%rsp)
cmpl $0x1000, 0x18(%rsp)     # imm = 0x1000
jge 0x97fb
movq 0x8(%rsp), %rax
movq %rax, %rdi
addq $0x38, %rdi
movl 0x14(%rax), %esi
callq 0x9a80
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jne 0x97e9
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
shll $0x4, %eax
movl 0x18(%rsp), %ecx
sarl $0x8, %ecx
orl %ecx, %eax
movl %eax, 0x10(%rsp)
xorl %eax, %eax
cmpl 0x10(%rsp), %eax
jg 0x97a7
cmpl $0x100, 0x10(%rsp)      # imm = 0x100
jge 0x97a7
movq 0x10876(%rip), %rax     # 0x19fe0
movq (%rax), %rdi
movl 0x14(%rsp), %edx
shll $0x4, %edx
movl 0x18(%rsp), %eax
andl $0xf, %eax
orl %eax, %edx
movl 0x10(%rsp), %ecx
movl 0x20(%rsp), %r8d
shll $0x4, %r8d
movl 0x18(%rsp), %eax
sarl $0x4, %eax
andl $0xf, %eax
orl %eax, %r8d
leaq 0x9e2a(%rip), %rsi      # 0x135c8
movb $0x0, %al
callq 0x2290
jmp 0x97e2
movq 0x10832(%rip), %rax     # 0x19fe0
movq (%rax), %rdi
movl 0x14(%rsp), %edx
shll $0x4, %edx
movl 0x18(%rsp), %eax
andl $0xf, %eax
orl %eax, %edx
movl 0x20(%rsp), %ecx
shll $0x4, %ecx
movl 0x18(%rsp), %eax
sarl $0x4, %eax
andl $0xf, %eax
orl %eax, %ecx
leaq 0x9e13(%rip), %rsi      # 0x135ee
movb $0x0, %al
callq 0x2290
movb $0x1, 0x37(%rsp)
jmp 0x9802
jmp 0x97eb
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x9705
jmp 0x97fd
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: kipa00[P]AplusB-mc/compiler/predicate.cpp
// Function: bytes_to_string[abi:cxx11](unsigned char const*, int)
string bytes_to_string(const byte *data, int len) {
	char *str = new char[len + 1];
	memcpy(str, data, len);
	str[len] = 0;
	string res(str);
	delete []str;
	return res;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movl 0x54(%rsp), %eax
incl %eax
movslq %eax, %rdi
callq 0x2030
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movq 0x58(%rsp), %rsi
movslq 0x54(%rsp), %rdx
callq 0x2160
movq 0x48(%rsp), %rax
movslq 0x54(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movb $0x0, 0x47(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x46(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x2310
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x4760
jmp 0x9a08
leaq 0x46(%rsp), %rdi
callq 0x2200
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x9a2c
movq 0x8(%rsp), %rdi
callq 0x2270
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0x9a5e
jmp 0x9a54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x46(%rsp), %rdi
callq 0x2200
jmp 0x9a68
movq 0x18(%rsp), %rdi
callq 0x2100
movq 0x10(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x2300
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: kipa00[P]AplusB-mc/compiler/bitstream.cpp
// Function: bitreader::read(int)
int bitreader::read(int bit) {
	int x = 0, u = 0;
	if (this->remaining < bit) {
		x = this->temp;
		bit -= this->remaining;
		u = this->remaining;
		this->remaining = 64;
		this->temp = 0;
		for (int i=0; i<8; ++i) {
			(this->temp <<= 8) |= this->data[this->pos++];
		}
	}
	x |= (this->temp & ((1ULL << bit) - 1)) << u;
	this->temp >>= bit;
	this->remaining -= bit;
	return x;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movl $0x0, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movl 0xc(%rax), %eax
cmpl -0xc(%rsp), %eax
jge 0x9b28
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rcx
movl %ecx, -0x10(%rsp)
movl 0xc(%rax), %edx
movl -0xc(%rsp), %ecx
subl %edx, %ecx
movl %ecx, -0xc(%rsp)
movl 0xc(%rax), %ecx
movl %ecx, -0x14(%rsp)
movl $0x40, 0xc(%rax)
movq $0x0, 0x10(%rax)
movl $0x0, -0x18(%rsp)
cmpl $0x8, -0x18(%rsp)
jge 0x9b26
movq -0x20(%rsp), %rax
movq (%rax), %rcx
movl 0x8(%rax), %edx
movl %edx, %esi
addl $0x1, %esi
movl %esi, 0x8(%rax)
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
movq 0x10(%rax), %rdx
shlq $0x8, %rdx
movq %rdx, 0x10(%rax)
orq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x9ae4
jmp 0x9b28
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rdx
movl -0xc(%rsp), %ecx
movl $0x1, %esi
shlq %cl, %rsi
movq %rsi, %rcx
subq $0x1, %rcx
andq %rcx, %rdx
movl -0x14(%rsp), %ecx
shlq %cl, %rdx
movslq -0x10(%rsp), %rcx
orq %rdx, %rcx
movl %ecx, -0x10(%rsp)
movl -0xc(%rsp), %ecx
movq 0x10(%rax), %rdx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
movq %rcx, 0x10(%rax)
movl -0xc(%rsp), %edx
movl 0xc(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0xc(%rax)
movl -0x10(%rsp), %eax
retq
nop
// File: kipa00[P]AplusB-mc/compiler/bitstream.cpp
// Function: bitreader::init(unsigned char const*, bool)
void bitreader::init(const byte *data, bool copy) {
	// TODO: implement copy if needed
	this->data = data;
	this->pos = 0;
	this->remaining = 0;
}

// Assembly:
movb %dl, %al
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
andb $0x1, %al
movb %al, -0x11(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movq %rcx, (%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
retq
nop
// File: kipa00[P]AplusB-mc/compiler/world.cpp
// Function: world::getXYZ(int, int, int) const
byte world::getXYZ(int x, int y, int z) const {
	if (!(0 <= x && x < 512 && 0 <= y && y < 255 && 0 <= z && z < 512)) return AIR;
	if (!this->world_data) return AIR;
	int idx = ((x >> 4) & 31) | (((z >> 4) & 31) << 5);
	if (!this->world_data[idx]) return AIR;
	return this->world_data[idx]->getXYZ(x, y, z);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
xorl %eax, %eax
cmpl 0x14(%rsp), %eax
jg 0xa174
cmpl $0x200, 0x14(%rsp)      # imm = 0x200
jge 0xa174
xorl %eax, %eax
cmpl 0x10(%rsp), %eax
jg 0xa174
cmpl $0xff, 0x10(%rsp)
jge 0xa174
xorl %eax, %eax
cmpl 0xc(%rsp), %eax
jg 0xa174
cmpl $0x200, 0xc(%rsp)       # imm = 0x200
jl 0xa17b
movb $0x0, 0x27(%rsp)
jmp 0xa1e8
movq (%rsp), %rax
cmpq $0x0, (%rax)
jne 0xa18c
movb $0x0, 0x27(%rsp)
jmp 0xa1e8
movq (%rsp), %rax
movl 0x14(%rsp), %ecx
sarl $0x4, %ecx
andl $0x1f, %ecx
movl 0xc(%rsp), %edx
sarl $0x4, %edx
andl $0x1f, %edx
shll $0x5, %edx
orl %edx, %ecx
movl %ecx, 0x8(%rsp)
movq (%rax), %rax
movslq 0x8(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0xa1c3
movb $0x0, 0x27(%rsp)
jmp 0xa1e8
movq (%rsp), %rax
movq (%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
callq 0x95a0
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: kipa00[P]AplusB-mc/compiler/world.cpp
// Function: world::~world()
world::~world() {
	if (this->world_data) {
		int i;
		for (i=0; i<1024; ++i) {
			if (this->world_data[i]) {
				delete this->world_data[i];
			}
		}
		delete []this->world_data;
		this->world_data = nullptr;
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, (%rax)
je 0xa2b0
movl $0x0, 0x1c(%rsp)
cmpl $0x400, 0x1c(%rsp)      # imm = 0x400
jge 0xa289
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0x1c(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xa27a
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xa278
movq 0x8(%rsp), %rdi
callq 0x94e0
movq 0x8(%rsp), %rdi
movl $0x50, %esi
callq 0x21c0
jmp 0xa27a
jmp 0xa27c
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xa225
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xa2a4
movq (%rsp), %rdi
callq 0x2270
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: kipa00[P]AplusB-mc/compiler/world.cpp
// Function: world::has_world_data(int, int, int) const
bool world::has_world_data(int cx, int cy, int cz) const {
	if (!(0 <= cx && cx < 32 && 0 <= cy && cy < 16 && 0 <= cz && cz < 32)) return false;
	if (!this->world_data) return false;
	if (!this->world_data[(cz << 5) | cx]) return false;
	return this->world_data[(cz << 5) | cx]->has_world_data(cy);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
xorl %eax, %eax
cmpl 0x14(%rsp), %eax
jg 0xa30b
cmpl $0x20, 0x14(%rsp)
jge 0xa30b
xorl %eax, %eax
cmpl 0x10(%rsp), %eax
jg 0xa30b
cmpl $0x10, 0x10(%rsp)
jge 0xa30b
xorl %eax, %eax
cmpl 0xc(%rsp), %eax
jg 0xa30b
cmpl $0x20, 0xc(%rsp)
jl 0xa312
movb $0x0, 0x27(%rsp)
jmp 0xa36e
movq (%rsp), %rax
cmpq $0x0, (%rax)
jne 0xa323
movb $0x0, 0x27(%rsp)
jmp 0xa36e
movq (%rsp), %rax
movq (%rax), %rax
movl 0xc(%rsp), %ecx
shll $0x5, %ecx
orl 0x14(%rsp), %ecx
movslq %ecx, %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0xa346
movb $0x0, 0x27(%rsp)
jmp 0xa36e
movq (%rsp), %rax
movq (%rax), %rax
movl 0xc(%rsp), %ecx
shll $0x5, %ecx
orl 0x14(%rsp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
movl 0x10(%rsp), %esi
callq 0x9630
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: kipa00[P]AplusB-mc/compiler/analyze.cpp
// Function: test_facing(world const&, int, int, int, std::function<bool (world const&, int, int, int)>)
bool test_facing(const world &w, int x, int y, int z, std::function<bool(const world &, int, int, int)> f) {
	byte b = w.getXYZ(x, y, z);
	switch (b & 3) {
		case EAST:
			++x;
			break;
		case WEST:
			--x;
			break;
		case SOUTH:
			++z;
			break;
		case NORTH:
			--z;
			break;
	}
	return f(w, x, y, z);
}

// Assembly:
subq $0x38, %rsp
movq %r8, (%rsp)
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq %r8, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0x28(%rsp), %edx
movl 0x24(%rsp), %ecx
callq 0xa120
movb %al, 0x17(%rsp)
movzbl 0x17(%rsp), %eax
andl $0x3, %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x3, %eax
ja 0xa513
movq 0x8(%rsp), %rax
leaq 0x91c8(%rip), %rcx      # 0x136a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0xa513
movl 0x2c(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0xa513
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xa513
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x24(%rsp)
movq (%rsp), %rdi
movq 0x30(%rsp), %rsi
movl 0x2c(%rsp), %edx
movl 0x28(%rsp), %ecx
movl 0x24(%rsp), %r8d
callq 0x11f30
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: kipa00[P]AplusB-mc/compiler/check.cpp
// Function: is_redstone_component(world const&, int, int, int)
bool is_redstone_component(const world &w, int x, int y, int z) {
	byte fetched = w.getXYZ(x, y, z);
	if ((fetched & BLOCK_ONLY) == REDSTONE_WALL_TORCH || (fetched & BLOCK_ONLY) == LEVER) {
		switch (fetched & 3) {
			case EAST: --x; break;
			case WEST: ++x; break;
			case SOUTH: --z; break;
			case NORTH: ++z; break;
		}
		if (!is_opaque(w.getXYZ(x, y, z))) {
			throw NO_SUPPORTING_BLOCK_ERROR;
		}
		return true;
	} else if ((fetched & BLOCK_ONLY) == REDSTONE_WIRE || (fetched & BLOCK_ONLY) == REDSTONE_TORCH || is_repeater(fetched) || (fetched & BLOCK_ONLY) == COMPARATOR) {
		if (!is_opaque(w.getXYZ(x, y-1, z))) {
			throw NO_SUPPORTING_BLOCK_ERROR;
		}
		return true;
	}
	return (fetched & BLOCK_ONLY) == REDSTONE_LAMP;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
callq 0xa120
movb %al, 0xb(%rsp)
movzbl 0xb(%rsp), %eax
andl $0xf0, %eax
cmpl $0x60, %eax
je 0x12343
movzbl 0xb(%rsp), %eax
andl $0xf0, %eax
cmpl $0xb0, %eax
jne 0x123eb
movzbl 0xb(%rsp), %eax
andl $0x3, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x3, %eax
ja 0x1239c
movq (%rsp), %rax
leaq 0x1937(%rip), %rcx      # 0x13c98
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1239c
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1239c
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1239c
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
callq 0xa120
movzbl %al, %edi
callq 0x12a70
testb $0x1, %al
jne 0x123e1
movl $0x4, %edi
callq 0x20d0
movq %rax, %rdi
movl $0xfffffffa, (%rdi)     # imm = 0xFFFFFFFA
movq 0x7bf0(%rip), %rsi      # 0x19fc8
xorl %eax, %eax
movl %eax, %edx
callq 0x22f0
movb $0x1, 0x27(%rsp)
jmp 0x1248f
movzbl 0xb(%rsp), %eax
andl $0xf0, %eax
cmpl $0x40, %eax
je 0x12426
movzbl 0xb(%rsp), %eax
andl $0xf0, %eax
cmpl $0x50, %eax
je 0x12426
movzbl 0xb(%rsp), %edi
callq 0x12a50
testb $0x1, %al
jne 0x12426
movzbl 0xb(%rsp), %eax
andl $0xf0, %eax
cmpl $0x70, %eax
jne 0x12475
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
subl $0x1, %edx
movl 0xc(%rsp), %ecx
callq 0xa120
movzbl %al, %edi
callq 0x12a70
testb $0x1, %al
jne 0x1246e
movl $0x4, %edi
callq 0x20d0
movq %rax, %rdi
movl $0xfffffffa, (%rdi)     # imm = 0xFFFFFFFA
movq 0x7b63(%rip), %rsi      # 0x19fc8
xorl %eax, %eax
movl %eax, %edx
callq 0x22f0
movb $0x1, 0x27(%rsp)
jmp 0x1248f
jmp 0x12477
movzbl 0xb(%rsp), %eax
andl $0xf0, %eax
cmpl $0xa0, %eax
sete %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: kipa00[P]AplusB-mc/compiler/block.cpp
// Function: is_opaque(unsigned char)
bool is_opaque(byte block) {
	switch (block & BLOCK_ONLY) {
		case BEDROCK:
		case STONE:
		case SANDSTONE:
		case REDSTONE_LAMP:
		case CONCRETE:
			return true;
	}
	return false;
}

// Assembly:
movb %dil, %al
movb %al, -0x2(%rsp)
movzbl -0x2(%rsp), %eax
andl $-0x10, %eax
movl %eax, -0x8(%rsp)
subl $0x10, %eax
je 0x12aba
jmp 0x12a8a
movl -0x8(%rsp), %eax
subl $0x20, %eax
je 0x12aba
jmp 0x12a95
movl -0x8(%rsp), %eax
subl $0x30, %eax
je 0x12aba
jmp 0x12aa0
movl -0x8(%rsp), %eax
subl $0xa0, %eax
je 0x12aba
jmp 0x12aad
movl -0x8(%rsp), %eax
subl $0xc0, %eax
jne 0x12ac1
jmp 0x12aba
movb $0x1, -0x1(%rsp)
jmp 0x12ac6
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopl (%rax)
// File: smuething[P]dune-cxx11/17-unique_ptr.cc
// Function: main
int main()
{
  std::shared_ptr<int> p1(new int(3));
  std::shared_ptr<int> p2(std::move(p1));
  assert(*p2 == 3);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl $0x4, %edi
callq 0x1060
movq %rax, %rsi
movl $0x3, (%rsi)
leaq -0x18(%rbp), %rdi
callq 0x1240
leaq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1270
leaq -0x28(%rbp), %rdi
callq 0x12a0
cmpl $0x3, (%rax)
jne 0x11f8
jmp 0x1217
leaq 0xe05(%rip), %rdi       # 0x2004
leaq 0xe07(%rip), %rsi       # 0x200d
movl $0x8, %edx
leaq 0xe0c(%rip), %rcx       # 0x201e
callq 0x1050
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x12d0
leaq -0x18(%rbp), %rdi
callq 0x12d0
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: zhjw1998[P]Merkle-Tree/src/main.cpp
// Function: OptiTest()
void OptiTest(){
    std::cout << std::setw(24)  << "Node Num" << std::setw(24) << "Create Merkle Time" << std::setw(24) \
    << "Create Tire Time" << std::setw(24) << "SlowDown of Creation" << std::setw(24) <<"Search Merkel Tree" \
    << std::setw(24) << "Search Tire Tree" << std::setw(24) << "Speedup of Search" << std::endl;
    TimeCal(100);
    TimeCal(1000);
    TimeCal(10000);
    TimeCal(100000);
    TimeCal(1000000);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x18, %edi
callq 0x3ca0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %esi
movq 0x15549(%rip), %rdi     # 0x17fd8
callq 0x2270
movq %rax, %rdi
leaq 0xd57a(%rip), %rsi      # 0x10018
callq 0x21b0
movq %rax, -0x50(%rbp)
movl $0x18, %edi
callq 0x3ca0
movq -0x50(%rbp), %rdi
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %esi
callq 0x2270
movq %rax, %rdi
leaq 0xd557(%rip), %rsi      # 0x10021
callq 0x21b0
movq %rax, -0x48(%rbp)
movl $0x18, %edi
callq 0x3ca0
movq -0x48(%rbp), %rdi
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %esi
callq 0x2270
movq %rax, %rdi
leaq 0xd53e(%rip), %rsi      # 0x10034
callq 0x21b0
movq %rax, -0x40(%rbp)
movl $0x18, %edi
callq 0x3ca0
movq -0x40(%rbp), %rdi
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %esi
callq 0x2270
movq %rax, %rdi
leaq 0xd523(%rip), %rsi      # 0x10045
callq 0x21b0
movq %rax, -0x38(%rbp)
movl $0x18, %edi
callq 0x3ca0
movq -0x38(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
callq 0x2270
movq %rax, %rdi
leaq 0xd50c(%rip), %rsi      # 0x1005a
callq 0x21b0
movq %rax, -0x30(%rbp)
movl $0x18, %edi
callq 0x3ca0
movq -0x30(%rbp), %rdi
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
callq 0x2270
movq %rax, %rdi
leaq 0xd4f3(%rip), %rsi      # 0x1006d
callq 0x21b0
movq %rax, -0x28(%rbp)
movl $0x18, %edi
callq 0x3ca0
movq -0x28(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
callq 0x2270
movq %rax, %rdi
leaq 0xd4d8(%rip), %rsi      # 0x1007e
callq 0x21b0
movq %rax, %rdi
movq 0x15413(%rip), %rsi     # 0x17fc8
callq 0x2200
movl $0x64, %edi
callq 0x2540
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x2540
movl $0x2710, %edi           # imm = 0x2710
callq 0x2540
movl $0x186a0, %edi          # imm = 0x186A0
callq 0x2540
movl $0xf4240, %edi          # imm = 0xF4240
callq 0x2540
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zhjw1998[P]Merkle-Tree/src/../include/picosha2.h
// Function: void picosha2::hash256_hex_string<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void hash256_hex_string(InIter first, InIter last, std::string& hex_str) {
    byte_t hashed[k_digest_size];
    hash256(first, last, hashed, hashed + k_digest_size);
    std::ostringstream oss;
    output_hex(hashed, hashed + k_digest_size, oss);
    hex_str.assign(oss.str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x20(%rbp), %rcx
movq %rcx, -0x208(%rbp)
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0x40(%rbp), %rdx
movq %rdx, -0x210(%rbp)
movl $0x100000, %r8d         # imm = 0x100000
callq 0x43a0
leaq -0x1c8(%rbp), %rdi
movq %rdi, -0x200(%rbp)
callq 0x22d0
movq -0x210(%rbp), %rdi
movq -0x208(%rbp), %rsi
movq -0x200(%rbp), %rdx
callq 0x43f0
jmp 0x431f
movq -0x18(%rbp), %rax
movq %rax, -0x218(%rbp)
leaq -0x1f8(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x21f0
jmp 0x433f
movq -0x218(%rbp), %rdi
leaq -0x1f8(%rbp), %rsi
callq 0x21d0
leaq -0x1f8(%rbp), %rdi
callq 0x20f0
leaq -0x1c8(%rbp), %rdi
callq 0x2050
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x2050
movq -0x1d0(%rbp), %rdi
callq 0x2340
nopl (%rax)
// File: zhjw1998[P]Merkle-Tree/src/../include/picosha2.h
// Function: void picosha2::output_hex<unsigned char*>(unsigned char*, unsigned char*, std::ostream&)
void output_hex(InIter first, InIter last, std::ostream& os) {
    os.setf(std::ios::hex, std::ios::basefield);
    while (first != last) {
        os.width(2);
        os.fill('0');
        os << static_cast<unsigned int>(*first);
        ++first;
    }
    os.setf(std::ios::dec, std::ios::basefield);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x8, %esi
movl $0x4a, %edx
callq 0x7430
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x4470
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x2, %esi
callq 0x7490
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x30, %esi
callq 0x2240
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movzbl (%rax), %esi
callq 0x22c0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x441e
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x2, %esi
movl $0x4a, %edx
callq 0x7430
addq $0x20, %rsp
popq %rbp
retq
// File: zhjw1998[P]Merkle-Tree/src/../include/picosha2.h
// Function: void picosha2::impl::hash256_impl<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, unsigned char*>(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, unsigned char*, unsigned char*, int, std::random_access_iterator_tag)
void hash256_impl(RaIter first, RaIter last, OutIter first2, OutIter last2, int,
                  std::random_access_iterator_tag) {
    hash256_one_by_one hasher;
    // hasher.init();
    hasher.process(first, last);
    hasher.finish();
    hasher.get_hash_bytes(first2, last2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x4560
movq -0xd0(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xb0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
callq 0x45b0
jmp 0x44f4
leaq -0xa8(%rbp), %rdi
callq 0x4780
jmp 0x4502
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0xa8(%rbp), %rdi
callq 0x48d0
jmp 0x4518
leaq -0xa8(%rbp), %rdi
callq 0x49a0
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x49a0
movq -0xc0(%rbp), %rdi
callq 0x2340
nopw (%rax,%rax)
// File: zhjw1998[P]Merkle-Tree/src/../include/picosha2.h
// Function: void picosha2::hash256_one_by_one::process<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
void process(RaIter first, RaIter last) {
        add_to_data_length(std::distance(first, last));
        std::copy(first, last, std::back_inserter(buffer_));
        std::size_t i = 0;
        for (; i + 64 <= buffer_.size(); i += 64) {
            detail::hash256_block(h_, buffer_.begin() + i,
                                  buffer_.begin() + i + 64);
        }
        buffer_.erase(buffer_.begin(), buffer_.begin() + i);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x50a0
movq -0xb0(%rbp), %rdi
movq %rax, %rsi
callq 0x5000
movq -0xb0(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x5150
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x50e0
movq %rax, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq -0xb0(%rbp), %rdi
movq -0x50(%rbp), %rax
addq $0x40, %rax
movq %rax, -0xb8(%rbp)
callq 0x5180
movq %rax, %rcx
movq -0xb8(%rbp), %rax
cmpq %rcx, %rax
ja 0x46f0
movq -0xb0(%rbp), %rdi
movq %rdi, %rax
addq $0x38, %rax
movq %rax, -0xc0(%rbp)
callq 0x5750
movq %rax, -0x60(%rbp)
movq -0x50(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x5780
movq -0xb0(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x5750
movq %rax, -0x78(%rbp)
movq -0x50(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x5780
movq %rax, -0x70(%rbp)
leaq -0x70(%rbp), %rdi
movl $0x40, %esi
callq 0x5780
movq -0xc0(%rbp), %rdi
movq %rax, -0x68(%rbp)
movq -0x58(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0x51a0
movq -0x50(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x50(%rbp)
jmp 0x463b
movq -0xb0(%rbp), %rdi
callq 0x5750
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x5850
movq -0xb0(%rbp), %rdi
callq 0x5750
movq %rax, -0xa0(%rbp)
movq -0x50(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x5780
movq %rax, -0x98(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x5850
movq -0xb0(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x90(%rbp), %rdx
callq 0x57c0
movq %rax, -0xa8(%rbp)
addq $0xc0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: zhjw1998[P]Merkle-Tree/src/../include/picosha2.h
// Function: picosha2::hash256_one_by_one::finish()
void finish() {
        byte_t temp[64];
        std::fill(temp, temp + 64, 0);
        std::size_t remains = buffer_.size();
        std::copy(buffer_.begin(), buffer_.end(), temp);
        temp[remains] = 0x80;

        if (remains > 55) {
            std::fill(temp + remains + 1, temp + 64, 0);
            detail::hash256_block(h_, temp, temp + 64);
            std::fill(temp, temp + 64 - 4, 0);
        } else {
            std::fill(temp + remains + 1, temp + 64 - 4, 0);
        }

        write_data_bit_length(&(temp[56]));
        detail::hash256_block(h_, temp, temp + 64);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x50(%rbp), %rsi
addq $0x40, %rsi
movl $0x0, -0x54(%rbp)
leaq -0x54(%rbp), %rdx
callq 0x6ae0
movq -0x88(%rbp), %rdi
callq 0x5180
movq -0x88(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x5750
movq -0x88(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x5dd0
movq %rax, -0x70(%rbp)
leaq -0x50(%rbp), %rdx
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x6b10
movq -0x60(%rbp), %rax
movb $-0x80, -0x50(%rbp,%rax)
cmpq $0x37, -0x60(%rbp)
jbe 0x4869
leaq -0x50(%rbp), %rdi
addq -0x60(%rbp), %rdi
addq $0x1, %rdi
leaq -0x50(%rbp), %rsi
addq $0x40, %rsi
movl $0x0, -0x74(%rbp)
leaq -0x74(%rbp), %rdx
callq 0x6ae0
movq -0x88(%rbp), %rdi
addq $0x38, %rdi
leaq -0x50(%rbp), %rsi
leaq -0x50(%rbp), %rdx
addq $0x40, %rdx
callq 0x6b70
leaq -0x50(%rbp), %rdi
leaq -0x50(%rbp), %rsi
addq $0x40, %rsi
addq $-0x4, %rsi
movl $0x0, -0x78(%rbp)
leaq -0x78(%rbp), %rdx
callq 0x6ae0
jmp 0x4891
leaq -0x50(%rbp), %rdi
addq -0x60(%rbp), %rdi
addq $0x1, %rdi
leaq -0x50(%rbp), %rsi
addq $0x40, %rsi
addq $-0x4, %rsi
movl $0x0, -0x7c(%rbp)
leaq -0x7c(%rbp), %rdx
callq 0x6ae0
movq -0x88(%rbp), %rdi
leaq -0x50(%rbp), %rsi
addq $0x38, %rsi
callq 0x7060
movq -0x88(%rbp), %rdi
addq $0x38, %rdi
leaq -0x50(%rbp), %rsi
leaq -0x50(%rbp), %rdx
addq $0x40, %rdx
callq 0x6b70
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: zhjw1998[P]Merkle-Tree/src/../include/picosha2.h
// Function: void picosha2::hash256_one_by_one::get_hash_bytes<unsigned char*>(unsigned char*, unsigned char*) const
void get_hash_bytes(OutIter first, OutIter last) const {
        for (const word_t* iter = h_; iter != h_ + 8; ++iter) {
            for (std::size_t i = 0; i < 4 && first != last; ++i) {
                *(first++) = detail::mask_8bit(
                    static_cast<byte_t>((*iter >> (24 - 8 * i))));
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x38, %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
addq $0x38, %rcx
addq $0x40, %rcx
cmpq %rcx, %rax
je 0x498e
movq $0x0, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x4, -0x28(%rbp)
movb %al, -0x31(%rbp)
jae 0x492f
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x4938
jmp 0x497b
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rdx
shlq $0x3, %rdx
movl $0x18, %ecx
subq %rdx, %rcx
shrq %cl, %rax
movzbl %al, %edi
callq 0x6410
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4915
jmp 0x497d
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0x48f4
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: zhjw1998[P]Merkle-Tree/src/../include/picosha2.h
// Function: picosha2::hash256_one_by_one::init()
void init() {
        buffer_.clear();
        std::fill(data_length_digits_, data_length_digits_ + 4, 0);
        std::copy(detail::initial_message_digest,
                  detail::initial_message_digest + 8, h_);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x4b50
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0x18, %rdi
addq $0x18, %rsi
addq $0x20, %rsi
movl $0x0, -0xc(%rbp)
leaq -0xc(%rbp), %rdx
callq 0x4b70
movq -0x18(%rbp), %rdx
addq $0x38, %rdx
leaq 0xb9f5(%rip), %rdi      # 0x10420
movq %rdi, %rsi
addq $0x40, %rsi
callq 0x4ba0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: zhjw1998[P]Merkle-Tree/src/../include/picosha2.h
// Function: picosha2::hash256_one_by_one::add_to_data_length(unsigned long)
void add_to_data_length(word_t n) {
        word_t carry = 0;
        data_length_digits_[0] += n;
        for (std::size_t i = 0; i < 4; ++i) {
            data_length_digits_[i] += carry;
            if (data_length_digits_[i] >= 65536u) {
                carry = data_length_digits_[i] >> 16;
                data_length_digits_[i] &= 65535u;
            } else {
                break;
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rcx
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq $0x0, -0x20(%rbp)
cmpq $0x4, -0x20(%rbp)
jae 0x509a
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
addq 0x18(%rax,%rcx,8), %rdx
movq %rdx, 0x18(%rax,%rcx,8)
movq -0x20(%rbp), %rcx
cmpq $0x10000, 0x18(%rax,%rcx,8) # imm = 0x10000
jb 0x5088
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rcx
shrq $0x10, %rcx
movq %rcx, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rdx
andq $0xffff, %rdx           # imm = 0xFFFF
movq %rdx, 0x18(%rax,%rcx,8)
jmp 0x508a
jmp 0x509a
jmp 0x508c
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5030
popq %rbp
retq
nopl (%rax)
// File: zhjw1998[P]Merkle-Tree/src/../include/picosha2.h
// Function: picosha2::hash256_one_by_one::write_data_bit_length(unsigned char*)
void write_data_bit_length(byte_t* begin) {
        word_t data_bit_length_digits[4];
        std::copy(data_length_digits_, data_length_digits_ + 4,
                  data_bit_length_digits);

        // convert byte length to bit length (multiply 8 or shift 3 times left)
        word_t carry = 0;
        for (std::size_t i = 0; i < 4; ++i) {
            word_t before_val = data_bit_length_digits[i];
            data_bit_length_digits[i] <<= 3;
            data_bit_length_digits[i] |= carry;
            data_bit_length_digits[i] &= 65535u;
            carry = (before_val >> (16 - 3)) & 65535u;
        }

        // write data_bit_length
        for (int i = 3; i >= 0; --i) {
            (*begin++) = static_cast<byte_t>(data_bit_length_digits[i] >> 8);
            (*begin++) = static_cast<byte_t>(data_bit_length_digits[i]);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, %rdi
addq $0x18, %rdi
addq $0x18, %rsi
addq $0x20, %rsi
leaq -0x30(%rbp), %rdx
callq 0x7320
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x4, -0x40(%rbp)
jae 0x7109
movq -0x40(%rbp), %rax
movq -0x30(%rbp,%rax,8), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq -0x30(%rbp,%rax,8), %rcx
shlq $0x3, %rcx
movq %rcx, -0x30(%rbp,%rax,8)
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rax
orq -0x30(%rbp,%rax,8), %rcx
movq %rcx, -0x30(%rbp,%rax,8)
movq -0x40(%rbp), %rax
movq -0x30(%rbp,%rax,8), %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
movq %rcx, -0x30(%rbp,%rax,8)
movq -0x48(%rbp), %rax
shrq $0xd, %rax
andq $0xffff, %rax           # imm = 0xFFFF
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x709c
movl $0x3, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
jl 0x715d
movslq -0x4c(%rbp), %rax
movq -0x30(%rbp,%rax,8), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movslq -0x4c(%rbp), %rax
movq -0x30(%rbp,%rax,8), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movl -0x4c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x7110
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: zhjw1998[P]Merkle-Tree/src/merkle_tree.cpp
// Function: MerkleTree::deleteTree(Node*, bool)
void MerkleTree::deleteTree(Node* node, bool deleaf) {
    if (node) {
        if(node->left) deleteTree(node->left, deleaf);
        if(node->right) deleteTree(node->right, deleaf);
        if(deleaf || node->left || node->right) {
            delete node;
            node = nullptr;    
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %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, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x90dd
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x906e
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x9020
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x9092
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x9020
testb $0x1, -0x11(%rbp)
jne 0x90ae
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x90ae
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x90db
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x90d3
movq -0x28(%rbp), %rdi
callq 0xa6c0
movq -0x28(%rbp), %rdi
movl $0x30, %esi
callq 0x21e0
movq $0x0, -0x10(%rbp)
jmp 0x90dd
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zhjw1998[P]Merkle-Tree/src/merkle_tree.cpp
// Function: MerkleTree::MakeEmpty(TrieTreeNode*)
void MerkleTree::MakeEmpty(TrieTreeNode *treeNode){
    if (treeNode != nullptr){
        for (int i = 0; i < SIZE; i++){
            MakeEmpty(treeNode->child[i]);
        }
        delete treeNode;
    }
    treeNode = nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x915b
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0x913d
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rsi
callq 0x90f0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9116
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x9159
movq -0x28(%rbp), %rdi
movl $0x90, %esi
callq 0x21e0
jmp 0x915b
movq $0x0, -0x10(%rbp)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: zhjw1998[P]Merkle-Tree/src/merkle_tree.cpp
// Function: MerkleTree::printTree(Node*, int)
void MerkleTree::printTree(Node* node, int index) {
    if (node) {
        if (node->left) {
            printTree(node->left, index + 4);
        }
        if (index) {
            std::cout << std::setw(index);
        }
        std::cout << node->hash[0] << "\n";
        if (node->right) {
             printTree(node->right, index + 4);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9247
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x91d8
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movl -0x14(%rbp), %edx
addl $0x4, %edx
callq 0x9190
cmpl $0x0, -0x14(%rbp)
je 0x91f8
movl -0x14(%rbp), %edi
callq 0x3ca0
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
movq 0xede5(%rip), %rdi      # 0x17fd8
callq 0x2270
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x23b0
movq 0xedcc(%rip), %rdi      # 0x17fd8
movsbl (%rax), %esi
callq 0x2290
movq %rax, %rdi
leaq 0x750b(%rip), %rsi      # 0x10729
callq 0x21b0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x9245
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movl -0x14(%rbp), %edx
addl $0x4, %edx
callq 0x9190
jmp 0x9247
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)