LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: funny-falcon[P]fanom_hash/./check.inc.cpp
// Function: dehexify(char*, long)
void dehexify(char* s, ssize_t len) {
	ssize_t i, j;
	for (i=0,j=0; i<len; i+=2, j++) {
		char c1 = s[i];
		char c2 = s[i+1];
		assert(c1 != -1 && c2 != -1);
		s[j] = (c1<<4) + c2;
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jge 0x2a0c
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, 0x7(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movb 0x1(%rax,%rcx), %al
movb %al, 0x6(%rsp)
movsbl 0x7(%rsp), %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, 0x5(%rsp)
je 0x29a2
movsbl 0x6(%rsp), %eax
cmpl $-0x1, %eax
setne %al
movb %al, 0x5(%rsp)
movb 0x5(%rsp), %al
testb $0x1, %al
jne 0x29ac
jmp 0x29ae
jmp 0x29cd
leaq 0x56ce(%rip), %rdi      # 0x8083
leaq 0x569c(%rip), %rsi      # 0x8058
movl $0x71, %edx
leaq 0x56d0(%rip), %rcx      # 0x8098
callq 0x2100
movsbl 0x7(%rsp), %eax
shll $0x4, %eax
movsbl 0x6(%rsp), %ecx
addl %ecx, %eax
movb %al, %dl
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x10(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2950
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: funny-falcon[P]fanom_hash/./fanom_hash.h
// Function: fanom64_load_u24(unsigned char const*, unsigned int)
static inline uint32_t
fanom64_load_u24(const uint8_t *v, unsigned len)
{
	uint32_t x = 0;
	switch (len) {
	case 3: x = ((uint32_t)v[2]<<16) | *(uint16_t*)v;
		break;
	case 2: x = *(uint16_t*)v;
		break;
	case 1: x = v[0];
		break;
	}
	return x;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl $0x0, -0x10(%rsp)
movl -0xc(%rsp), %eax
movl %eax, -0x14(%rsp)
subl $0x1, %eax
je 0x40d0
jmp 0x4090
movl -0x14(%rsp), %eax
subl $0x2, %eax
je 0x40c2
jmp 0x409b
movl -0x14(%rsp), %eax
subl $0x3, %eax
jne 0x40dc
jmp 0x40a6
movq -0x8(%rsp), %rax
movzbl 0x2(%rax), %eax
shll $0x10, %eax
movq -0x8(%rsp), %rcx
movzwl (%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x10(%rsp)
jmp 0x40dc
movq -0x8(%rsp), %rax
movzwl (%rax), %eax
movl %eax, -0x10(%rsp)
jmp 0x40dc
movq -0x8(%rsp), %rax
movzbl (%rax), %eax
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: superblocks[P]superblocks/list-jkc.cpp
// Function: main
int main() {

	cout << "[JKC] Junkcoin - Superblock list" << endl << endl;
	cout << "BLOCK, REWARD" << endl;
	for (int nHeight = 0; nHeight <= list_length; nHeight++) {
		random::mt19937 gen(nHeight);
		random::uniform_int_distribution<> dist(1, 100000);
		int rand = dist(gen);
		if(rand > 99990) {
			cout << nHeight << ", 1000" << endl;
		} else if (rand < 1001) {
			cout << nHeight << ", 150" << endl;
		} 
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x9e0, %rsp            # imm = 0x9E0
movl $0x0, -0x4(%rbp)
movq 0x2def(%rip), %rdi      # 0x3fd8
leaq 0xe14(%rip), %rsi       # 0x2004
callq 0x1050
movq %rax, %rdi
movq 0x2dc9(%rip), %rsi      # 0x3fc8
callq 0x1060
movq %rax, %rdi
movq 0x2dba(%rip), %rsi      # 0x3fc8
callq 0x1060
movq 0x2dbe(%rip), %rdi      # 0x3fd8
leaq 0xe04(%rip), %rsi       # 0x2025
callq 0x1050
movq %rax, %rdi
movq 0x2d98(%rip), %rsi      # 0x3fc8
callq 0x1060
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x2e13(%rip), %eax      # 0x4058
jg 0x131c
movl -0x8(%rbp), %eax
movl %eax, -0x9d4(%rbp)
leaq -0x9d0(%rbp), %rdi
leaq -0x9d4(%rbp), %rsi
callq 0x1330
leaq -0x9dc(%rbp), %rdi
movl $0x1, %esi
movl $0x186a0, %edx          # imm = 0x186A0
callq 0x1360
leaq -0x9dc(%rbp), %rdi
leaq -0x9d0(%rbp), %rsi
callq 0x13b0
movl %eax, -0x9e0(%rbp)
cmpl $0x18696, -0x9e0(%rbp)  # imm = 0x18696
jle 0x12d1
movl -0x8(%rbp), %esi
movq 0x2d2c(%rip), %rdi      # 0x3fd8
callq 0x1080
movq %rax, %rdi
leaq 0xd78(%rip), %rsi       # 0x2033
callq 0x1050
movq %rax, %rdi
movq 0x2cfe(%rip), %rsi      # 0x3fc8
callq 0x1060
jmp 0x130c
cmpl $0x3e9, -0x9e0(%rbp)    # imm = 0x3E9
jge 0x130a
movl -0x8(%rbp), %esi
movq 0x2cf1(%rip), %rdi      # 0x3fd8
callq 0x1080
movq %rax, %rdi
leaq 0xd44(%rip), %rsi       # 0x203a
callq 0x1050
movq %rax, %rdi
movq 0x2cc3(%rip), %rsi      # 0x3fc8
callq 0x1060
jmp 0x130c
jmp 0x130e
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x123c
xorl %eax, %eax
addq $0x9e0, %rsp            # imm = 0x9E0
popq %rbp
retq
nopw (%rax,%rax)
// File: moporgic[P]2048-Framework/./statistics.h
// Function: operator>>(std::istream&, statistics&)
std::istream& operator >>(std::istream& in, statistics& stat) {
		for (std::string line; std::getline(in, line) && line.size(); ) {
			stat.data.emplace_back();
			std::stringstream(line) >> stat.data.back();
		}
		stat.total = std::max(stat.total, stat.data.size());
		stat.count = stat.data.size();
		return in;
	}

// Assembly:
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
leaq 0x1b8(%rsp), %rdi
callq 0x43d0
movq 0x1e0(%rsp), %rdi
leaq 0x1b8(%rsp), %rsi
callq 0x40a0
movq %rax, 0x10(%rsp)
jmp 0x62f0
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x4360
movb %al, 0xf(%rsp)
jmp 0x630a
movb 0xf(%rsp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xe(%rsp)
jne 0x631b
jmp 0x6333
leaq 0x1b8(%rsp), %rdi
callq 0x4250
cmpq $0x0, %rax
setne %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0x6366
leaq 0x1b8(%rsp), %rdi
callq 0x4210
jmp 0x6402
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1b0(%rsp)
movl %eax, 0x1ac(%rsp)
jmp 0x63f3
movq 0x1d8(%rsp), %rdi
addq $0x20, %rdi
callq 0x9d80
jmp 0x6379
movl $0x10, %edi
movl $0x8, %esi
callq 0x6b90
movl %eax, 0x8(%rsp)
jmp 0x638e
movl 0x8(%rsp), %edx
leaq 0x20(%rsp), %rdi
leaq 0x1b8(%rsp), %rsi
callq 0x4460
jmp 0x63a6
movq 0x1d8(%rsp), %rdi
addq $0x20, %rdi
callq 0x9e10
movq %rax, %rsi
leaq 0x20(%rsp), %rdi
callq 0x9de0
jmp 0x63c6
leaq 0x20(%rsp), %rdi
callq 0x4260
jmp 0x62d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1b0(%rsp)
movl %eax, 0x1ac(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x4260
leaq 0x1b8(%rsp), %rdi
callq 0x4210
jmp 0x6470
movq 0x1d8(%rsp), %rax
movq %rax, (%rsp)
movq 0x1d8(%rsp), %rdi
addq $0x20, %rdi
callq 0x9e40
movq (%rsp), %rdi
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x9770
movq (%rax), %rcx
movq 0x1d8(%rsp), %rax
movq %rcx, (%rax)
movq 0x1d8(%rsp), %rdi
addq $0x20, %rdi
callq 0x9e40
movq %rax, %rcx
movq 0x1d8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x1e0(%rsp), %rax
addq $0x1e8, %rsp            # imm = 0x1E8
retq
movq 0x1b0(%rsp), %rdi
callq 0x44f0
nopl (%rax)
// File: moporgic[P]2048-Framework/./episode.h
// Function: episode::apply_action(action)
bool apply_action(action move) {
		board::reward reward = move.apply(state());
		if (reward == -1) return false;
		ep_moves.emplace_back(move, reward, millisec() - ep_time);
		ep_score += reward;
		return true;
	}

// Assembly:
subq $0x48, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x69e0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x6cc0
movl %eax, 0x2c(%rsp)
cmpl $-0x1, 0x2c(%rsp)
jne 0x6a31
movb $0x0, 0x47(%rsp)
jmp 0x6a82
movq 0x10(%rsp), %rax
addq $0x50, %rax
movq %rax, 0x8(%rsp)
callq 0x11000
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rcx
subq 0x68(%rcx), %rax
movq %rax, 0x20(%rsp)
leaq 0x2c(%rsp), %rdx
leaq 0x20(%rsp), %rcx
callq 0x11110
movq 0x10(%rsp), %rax
movslq 0x2c(%rsp), %rcx
addq 0x48(%rax), %rcx
movq %rcx, 0x48(%rax)
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax)
// File: moporgic[P]2048-Framework/./action.h
// Function: action::operator<<(std::istream&)
virtual std::istream& operator <<(std::istream& in) {
		auto state = in.rdstate();
		for (auto proto = entries().begin(); proto != entries().end(); proto++) {
			if (proto->second->reinterpret(this) << in) return in;
			in.clear(state);
		}
		return in.ignore(2);
	}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x4290
movl %eax, 0x2c(%rsp)
callq 0x5f30
movq %rax, %rdi
callq 0x75d0
movq %rax, 0x20(%rsp)
callq 0x5f30
movq %rax, %rdi
callq 0x6fe0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x6fc0
testb $0x1, %al
jne 0x6e96
jmp 0x6f09
leaq 0x20(%rsp), %rdi
callq 0x7010
movq 0x8(%rsp), %rsi
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq %rax, %rdi
movq 0x30(%rsp), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x4360
testb $0x1, %al
jne 0x6ed2
jmp 0x6ede
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x6f1d
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl 0x2c(%rsp), %esi
callq 0x44c0
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x7600
movq %rax, 0x10(%rsp)
jmp 0x6e6f
movq 0x30(%rsp), %rdi
movl $0x2, %esi
callq 0x4070
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: moporgic[P]2048-Framework/./action.h
// Function: action::slide::operator<<(std::istream&)
std::istream& operator <<(std::istream& in) {
		if (in.peek() == '#' && in) {
			char v;
			in.ignore(1) >> v;
			const char* opc = "URDL";
			unsigned oper = std::find(opc, opc + 4, v) - opc;
			if (oper < 4) {
				operator= (action::slide(oper));
				return in;
			}
		}
		in.setstate(std::ios::failbit);
		return in;
	}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
callq 0x4120
cmpl $0x23, %eax
jne 0x785b
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x4360
testb $0x1, %al
jne 0x77d4
jmp 0x785b
movq 0x30(%rsp), %rdi
movl $0x1, %esi
callq 0x4070
movq %rax, %rdi
leaq 0x2f(%rsp), %rsi
callq 0x4390
leaq 0xb8af(%rip), %rax      # 0x130a6
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rsi
addq $0x4, %rsi
leaq 0x2f(%rsp), %rdx
callq 0x8400
movq 0x20(%rsp), %rcx
subq %rcx, %rax
movl %eax, 0x1c(%rsp)
cmpl $0x4, 0x1c(%rsp)
jae 0x7859
movl 0x1c(%rsp), %esi
leaq 0x8(%rsp), %rdi
callq 0x8480
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x8450
leaq 0x8(%rsp), %rdi
callq 0x76b0
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x787b
jmp 0x785b
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x4, %esi
callq 0x4220
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: moporgic[P]2048-Framework/./board.h
// Function: board::slide(unsigned int)
reward slide(unsigned opcode) {
		switch (opcode & 0b11) {
		case 0: return slide_up();
		case 1: return slide_right();
		case 2: return slide_down();
		case 3: return slide_left();
		default: return -1;
		}
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movl 0x14(%rsp), %eax
andl $0x3, %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x3, %eax
ja 0x793a
movq 0x8(%rsp), %rax
leaq 0xb70f(%rip), %rcx      # 0x13004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rsp), %rdi
callq 0x7980
movl %eax, 0x24(%rsp)
jmp 0x7942
movq (%rsp), %rdi
callq 0x79c0
movl %eax, 0x24(%rsp)
jmp 0x7942
movq (%rsp), %rdi
callq 0x7a00
movl %eax, 0x24(%rsp)
jmp 0x7942
movq (%rsp), %rdi
callq 0x7a40
movl %eax, 0x24(%rsp)
jmp 0x7942
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: moporgic[P]2048-Framework/./board.h
// Function: board::slide_up()
reward slide_up() {
		rotate_clockwise();
		reward score = slide_right();
		rotate_counterclockwise();
		return score;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x7c20
movq (%rsp), %rdi
callq 0x79c0
movq (%rsp), %rdi
movl %eax, 0xc(%rsp)
callq 0x7c50
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: moporgic[P]2048-Framework/./board.h
// Function: board::slide_right()
reward slide_right() {
		reflect_horizontal();
		reward score = slide_left();
		reflect_horizontal();
		return score;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x7d20
movq (%rsp), %rdi
callq 0x7a40
movq (%rsp), %rdi
movl %eax, 0xc(%rsp)
callq 0x7d20
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: moporgic[P]2048-Framework/./board.h
// Function: board::slide_down()
reward slide_down() {
		rotate_clockwise();
		reward score = slide_left();
		rotate_counterclockwise();
		return score;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x7c20
movq (%rsp), %rdi
callq 0x7a40
movq (%rsp), %rdi
movl %eax, 0xc(%rsp)
callq 0x7c50
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: moporgic[P]2048-Framework/./board.h
// Function: board::slide_left()
reward slide_left() {
		board prev = *this;
		reward score = 0;
		for (int r = 0; r < 4; r++) {
			auto& row = tile[r];
			int top = 0, hold = 0;
			for (int c = 0; c < 4; c++) {
				int tile = row[c];
				if (tile == 0) continue;
				row[c] = 0;
				if (hold) {
					if (tile == hold) {
						row[top++] = ++tile;
						score += (1 << tile);
						hold = 0;
					} else {
						row[top++] = hold;
						hold = tile;
					}
				} else {
					hold = tile;
				}
			}
			if (hold) tile[r][top] = hold;
		}
		return (*this != prev) ? score : -1;
	}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rsi
movq %rsi, 0x10(%rsp)
leaq 0x38(%rsp), %rdi
movl $0x48, %edx
callq 0x4280
movl $0x0, 0x34(%rsp)
movl $0x0, 0x30(%rsp)
cmpl $0x4, 0x30(%rsp)
jge 0x7be3
movq 0x10(%rsp), %rdi
movslq 0x30(%rsp), %rsi
callq 0x7e20
movq %rax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
cmpl $0x4, 0x1c(%rsp)
jge 0x7ba0
movq 0x28(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x7e50
movl (%rax), %eax
movl %eax, 0x18(%rsp)
cmpl $0x0, 0x18(%rsp)
jne 0x7ade
jmp 0x7b90
movq 0x28(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x7e50
movl $0x0, (%rax)
cmpl $0x0, 0x20(%rsp)
je 0x7b86
movl 0x18(%rsp), %eax
cmpl 0x20(%rsp), %eax
jne 0x7b54
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl %eax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rsp)
movslq %eax, %rsi
callq 0x7e50
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
movl 0x18(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
addl 0x34(%rsp), %eax
movl %eax, 0x34(%rsp)
movl $0x0, 0x20(%rsp)
jmp 0x7b84
movl 0x20(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rsp)
movslq %eax, %rsi
callq 0x7e50
movl 0x8(%rsp), %ecx
movl %ecx, (%rax)
movl 0x18(%rsp), %eax
movl %eax, 0x20(%rsp)
jmp 0x7b8e
movl 0x18(%rsp), %eax
movl %eax, 0x20(%rsp)
jmp 0x7b90
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x7ab2
cmpl $0x0, 0x20(%rsp)
je 0x7bd1
movq 0x10(%rsp), %rdi
movl 0x20(%rsp), %eax
movl %eax, 0x4(%rsp)
movslq 0x30(%rsp), %rsi
callq 0x7e20
movq %rax, %rdi
movslq 0x24(%rsp), %rsi
callq 0x7e50
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
jmp 0x7bd3
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x7a7b
movq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x7f90
testb $0x1, %al
jne 0x7bf8
jmp 0x7c01
movl 0x34(%rsp), %eax
movl %eax, (%rsp)
jmp 0x7c0b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, (%rsp)
jmp 0x7c0b
movl (%rsp), %eax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: moporgic[P]2048-Framework/./action.h
// Function: action::place::operator<<(std::istream&)
std::istream& operator <<(std::istream& in) {
		const char* idx = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
		if (in.peek() != '#' && in) {
			char v = in.peek();
			unsigned pos = std::find(idx, idx + 16, v) - idx;
			in.ignore(1) >> v;
			unsigned tile = std::find(idx, idx + 36, v) - idx;
			if (pos < 16 && tile < 36) {
				operator =(action::place(pos, tile));
				return in;
			}
		}
		in.setstate(std::ios::failbit);
		return in;
	}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
leaq 0xa183(%rip), %rax      # 0x130d1
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x4120
cmpl $0x23, %eax
je 0x9038
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x4360
testb $0x1, %al
jne 0x8f80
jmp 0x9038
movq 0x30(%rsp), %rdi
callq 0x4120
movb %al, 0x27(%rsp)
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x10, %rsi
leaq 0x27(%rsp), %rdx
callq 0x8400
movq 0x28(%rsp), %rcx
subq %rcx, %rax
movl %eax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movl $0x1, %esi
callq 0x4070
movq %rax, %rdi
leaq 0x27(%rsp), %rsi
callq 0x4390
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x24, %rsi
leaq 0x27(%rsp), %rdx
callq 0x8400
movq 0x28(%rsp), %rcx
subq %rcx, %rax
movl %eax, 0x1c(%rsp)
cmpl $0x10, 0x20(%rsp)
jae 0x9036
cmpl $0x24, 0x1c(%rsp)
jae 0x9036
movl 0x20(%rsp), %esi
movl 0x1c(%rsp), %edx
leaq 0x8(%rsp), %rdi
callq 0x9220
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x91f0
leaq 0x8(%rsp), %rdi
callq 0x8df0
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x9058
jmp 0x9038
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x4, %esi
callq 0x4220
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: moporgic[P]2048-Framework/./board.h
// Function: board::place(unsigned int, unsigned int)
reward place(unsigned pos, cell tile) {
		if (pos >= 16 || operator()(pos)) return -1;
		if (tile != 1 && tile != 2) return -1;
		operator()(pos) = tile;
		return 0;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x10, 0x14(%rsp)
jae 0x90d5
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x9170
cmpl $0x0, (%rax)
je 0x90df
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x911b
cmpl $0x1, 0x10(%rsp)
je 0x90f7
cmpl $0x2, 0x10(%rsp)
je 0x90f7
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x911b
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x14(%rsp), %esi
callq 0x9170
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: moporgic[P]2048-Framework/./episode.h
// Function: operator>>(std::istream&, episode::move&)
std::istream& operator >>(std::istream& in, move& m) {
			in >> m.code;
			m.reward = 0;
			m.time = 0;
			if (in.peek() == '[') {
				in.ignore(1);
				in >> std::dec >> m.reward;
				in.ignore(1);
			}
			if (in.peek() == '(') {
				in.ignore(1);
				in >> std::dec >> m.time;
				in.ignore(1);
			}
			return in;
		}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xc260
movq 0x8(%rsp), %rax
movl $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x10(%rsp), %rdi
callq 0x4120
cmpl $0x5b, %eax
jne 0xb635
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x4070
movq 0x10(%rsp), %rdi
leaq 0x490(%rip), %rsi       # 0xbaa0
callq 0x44b0
movq %rax, %rdi
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
callq 0x4200
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x4070
movq 0x10(%rsp), %rdi
callq 0x4120
cmpl $0x28, %eax
jne 0xb684
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x4070
movq 0x10(%rsp), %rdi
leaq 0x441(%rip), %rsi       # 0xbaa0
callq 0x44b0
movq %rax, %rdi
movq 0x8(%rsp), %rsi
addq $0x18, %rsi
callq 0x41e0
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x4070
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: moporgic[P]2048-Framework/./episode.h
// Function: episode::step(unsigned int) const
size_t step(unsigned who = -1u) const {
		int size = ep_moves.size(); // 'int' is important for handling 0
		switch (who) {
		case action::slide::type: return (size - 1) / 2;
		case action::place::type: return (size - (size - 1) / 2);
		default:                  return size;
		}
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
addq $0x50, %rdi
callq 0xa470
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0xc(%rsp)
subl $0x70000000, %eax       # imm = 0x70000000
je 0xcef5
jmp 0xced0
movl 0xc(%rsp), %eax
subl $0x73000000, %eax       # imm = 0x73000000
jne 0xcf1d
jmp 0xcedd
movl 0x10(%rsp), %eax
subl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
cltq
movq %rax, 0x20(%rsp)
jmp 0xcf27
movl 0x10(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x10(%rsp), %eax
subl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0x8(%rsp), %eax
subl %ecx, %eax
cltq
movq %rax, 0x20(%rsp)
jmp 0xcf27
movslq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: moporgic[P]2048-Framework/./episode.h
// Function: episode::time(unsigned int) const
time_t time(unsigned who = -1u) const {
		time_t time = 0;
		size_t i = 2;
		switch (who) {
		case action::place::type:
			if (ep_moves.size()) time += ep_moves[0].time, i = 1;
			// no break;
		case action::slide::type:
			while (i < ep_moves.size()) time += ep_moves[i].time, i += 2;
			break;
		default:
			time = ep_close.when - ep_open.when;
			break;
		}
		return time;
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x2, 0x18(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x14(%rsp)
subl $0x70000000, %eax       # imm = 0x70000000
je 0xcf8a
jmp 0xcf7a
movl 0x14(%rsp), %eax
subl $0x73000000, %eax       # imm = 0x73000000
je 0xcfc9
jmp 0xd021
movq 0x8(%rsp), %rdi
addq $0x50, %rdi
callq 0xa470
cmpq $0x0, %rax
je 0xcfc7
movq 0x8(%rsp), %rdi
addq $0x50, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd330
movq 0x18(%rax), %rax
addq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
movq $0x1, 0x18(%rsp)
jmp 0xcfc9
jmp 0xcfcb
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
addq $0x50, %rdi
callq 0xa470
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0xd01f
movq 0x8(%rsp), %rdi
addq $0x50, %rdi
movq 0x18(%rsp), %rsi
callq 0xd330
movq 0x18(%rax), %rax
addq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x18(%rsp)
jmp 0xcfcb
jmp 0xd039
movq 0x8(%rsp), %rcx
movq 0xb8(%rcx), %rax
subq 0x90(%rcx), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: moporgic[P]2048-Framework/./agent.h
// Function: random_slider::take_action(board const&)
virtual action take_action(const board& before) {
		std::shuffle(opcode.begin(), opcode.end(), engine);
		for (int op : opcode) {
			board::reward reward = board(before).slide(op);
			if (reward != -1) return action::slide(op);
		}
		return action();
	}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq 0xb8(%rsp), %rdi
movq %rdi, 0x20(%rsp)
addq $0x40, %rdi
callq 0x10160
movq 0x20(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x40, %rdi
callq 0x10170
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rdx
movq %rax, %rsi
addq $0x38, %rdx
callq 0xfec0
movq 0x20(%rsp), %rax
addq $0x40, %rax
movq %rax, 0xa8(%rsp)
movq 0xa8(%rsp), %rdi
callq 0x10160
movq %rax, 0xa0(%rsp)
movq 0xa8(%rsp), %rdi
callq 0x10170
movq %rax, 0x98(%rsp)
movq 0xa0(%rsp), %rax
cmpq 0x98(%rsp), %rax
je 0xd87c
movq 0xa0(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x94(%rsp)
movq 0xb0(%rsp), %rsi
leaq 0x48(%rsp), %rdi
movl $0x48, %edx
callq 0x4280
movl 0x94(%rsp), %esi
leaq 0x48(%rsp), %rdi
callq 0x78c0
movl %eax, 0x90(%rsp)
cmpl $-0x1, 0x90(%rsp)
je 0xd861
movl 0x94(%rsp), %esi
leaq 0x38(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x8480
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x6a90
jmp 0xd83b
leaq 0x38(%rsp), %rdi
callq 0x76b0
jmp 0xd88b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x76b0
jmp 0xd898
jmp 0xd863
movq 0xa0(%rsp), %rax
addq $0x4, %rax
movq %rax, 0xa0(%rsp)
jmp 0xd7b6
movq 0x8(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5ec0
movq 0x10(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x44f0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: moporgic[P]2048-Framework/./agent.h
// Function: agent::agent(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
agent(const std::string& args = "") {
		std::stringstream ss("name=unknown role=unknown " + args);
		for (std::string pair; ss >> pair; ) {
			std::string key = pair.substr(0, pair.find('='));
			std::string value = pair.substr(pair.find('=') + 1);
			meta[key] = { value };
		}
	}

// Assembly:
subq $0x298, %rsp            # imm = 0x298
movq %rdi, 0x290(%rsp)
movq %rsi, 0x288(%rsp)
movq 0x290(%rsp), %rdi
movq %rdi, 0x40(%rsp)
leaq 0xd13d(%rip), %rax      # 0x1acd8
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, 0x48(%rsp)
callq 0xe0c0
movq 0x288(%rsp), %rdx
leaq 0x55e4(%rip), %rsi      # 0x1319f
leaq 0xe0(%rsp), %rdi
callq 0xd350
jmp 0xdbca
movl $0x10, %edi
movl $0x8, %esi
callq 0x6b90
movl %eax, 0x3c(%rsp)
jmp 0xdbdf
movl 0x3c(%rsp), %edx
leaq 0x100(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0x4460
jmp 0xdbfa
leaq 0xe0(%rsp), %rdi
callq 0x4210
leaq 0xb0(%rsp), %rdi
callq 0x43d0
leaq 0x100(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x4370
movq %rax, 0x30(%rsp)
jmp 0xdc30
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x4360
movb %al, 0x2f(%rsp)
jmp 0xdc4a
movb 0x2f(%rsp), %al
testb $0x1, %al
jne 0xdcbe
jmp 0xdc54
leaq 0xb0(%rsp), %rdi
callq 0x4210
jmp 0xde13
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd8(%rsp)
movl %eax, 0xd4(%rsp)
jmp 0xde28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd8(%rsp)
movl %eax, 0xd4(%rsp)
leaq 0xe0(%rsp), %rdi
callq 0x4210
jmp 0xde28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd8(%rsp)
movl %eax, 0xd4(%rsp)
jmp 0xddf7
xorl %eax, %eax
movl %eax, %edx
movq %rdx, 0x20(%rsp)
leaq 0xb0(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x3d, %esi
callq 0x4380
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %rax, %rcx
leaq 0x90(%rsp), %rdi
callq 0x4300
jmp 0xdcfa
xorl %eax, %eax
movl %eax, %edx
leaq 0xb0(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x3d, %esi
callq 0x4380
movq 0x10(%rsp), %rsi
movq %rax, %rdx
incq %rdx
leaq 0x70(%rsp), %rdi
movq $-0x1, %rcx
callq 0x4300
jmp 0xdd33
leaq 0x50(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x4160
jmp 0xdd44
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
leaq 0x90(%rsp), %rsi
callq 0xe0d0
movq %rax, 0x8(%rsp)
jmp 0xdd61
movq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xe1c0
leaq 0x50(%rsp), %rdi
callq 0xe1f0
leaq 0x70(%rsp), %rdi
callq 0x4210
leaq 0x90(%rsp), %rdi
callq 0x4210
jmp 0xdc14
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd8(%rsp)
movl %eax, 0xd4(%rsp)
jmp 0xddea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd8(%rsp)
movl %eax, 0xd4(%rsp)
jmp 0xdde0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd8(%rsp)
movl %eax, 0xd4(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xe1f0
leaq 0x70(%rsp), %rdi
callq 0x4210
leaq 0x90(%rsp), %rdi
callq 0x4210
leaq 0xb0(%rsp), %rdi
callq 0x4210
leaq 0x100(%rsp), %rdi
callq 0x4260
jmp 0xde28
leaq 0x100(%rsp), %rdi
callq 0x4260
addq $0x298, %rsp            # imm = 0x298
retq
movq 0x48(%rsp), %rdi
callq 0xe200
movq 0xd8(%rsp), %rdi
callq 0x44f0
nop
// File: moporgic[P]2048-Framework/./agent.h
// Function: random_placer::take_action(board const&)
virtual action take_action(const board& after) {
		std::shuffle(space.begin(), space.end(), engine);
		for (int pos : space) {
			if (after(pos) != 0) continue;
			board::cell tile = popup(engine) ? 1 : 2;
			return action::place(pos, tile);
		}
		return action();
	}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x28(%rsp)
addq $0x40, %rdi
callq 0x10bb0
movq 0x28(%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x40, %rdi
callq 0x10bc0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rdx
movq %rax, %rsi
addq $0x38, %rdx
callq 0xfec0
movq 0x28(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdi
callq 0x10bb0
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rdi
callq 0x10bc0
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rax
cmpq 0x58(%rsp), %rax
je 0x10b52
movq 0x60(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x54(%rsp)
movq 0x70(%rsp), %rdi
movl 0x54(%rsp), %esi
callq 0xd290
cmpl $0x0, (%rax)
je 0x10ace
jmp 0x10b3f
movq 0x28(%rsp), %rsi
movq %rsi, %rdi
subq $-0x80, %rdi
addq $0x38, %rsi
callq 0x10be0
movl %eax, %ecx
xorl %eax, %eax
subl $0x1, %ecx
adcl $0x1, %eax
movl %eax, 0x50(%rsp)
movl 0x54(%rsp), %esi
movl 0x50(%rsp), %edx
leaq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x9220
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x6a90
jmp 0x10b19
leaq 0x40(%rsp), %rdi
callq 0x8df0
jmp 0x10b61
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x8df0
jmp 0x10b6e
movq 0x60(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x60(%rsp)
jmp 0x10a9e
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5ec0
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x44f0
nopl (%rax,%rax)
// File: moporgic[P]2048-Framework/./episode.h
// Function: operator<<(std::ostream&, episode const&)
std::ostream& operator <<(std::ostream& out, const episode& ep) {
		out << ep.ep_open << '|';
		for (const move& mv : ep.ep_moves) out << mv;
		out << '|' << ep.ep_close;
		return out;
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x70, %rsi
callq 0x117b0
movq %rax, %rdi
movl $0x7c, %esi
callq 0x4340
movq 0x28(%rsp), %rax
addq $0x50, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11810
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11840
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x11870
testb $0x1, %al
jne 0x116df
jmp 0x11709
leaq 0x18(%rsp), %rdi
callq 0x118b0
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x118c0
leaq 0x18(%rsp), %rdi
callq 0x11980
jmp 0x116ca
movq 0x30(%rsp), %rdi
movl $0x7c, %esi
callq 0x4340
movq %rax, %rdi
movq 0x28(%rsp), %rsi
addq $0x98, %rsi
callq 0x117b0
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: moporgic[P]2048-Framework/./episode.h
// Function: operator<<(std::ostream&, episode::move const&)
std::ostream& operator <<(std::ostream& out, const move& m) {
			out << m.code;
			if (m.reward) out << '[' << std::dec << m.reward << ']';
			if (m.time) out << '(' << std::dec << m.time << ')';
			return out;
		}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x119d0
movq 0x8(%rsp), %rax
cmpl $0x0, 0x10(%rax)
je 0x11923
movq 0x10(%rsp), %rdi
movl $0x5b, %esi
callq 0x4340
movq %rax, %rdi
leaq -0x5e61(%rip), %rsi     # 0xbaa0
callq 0x4100
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x10(%rax), %esi
callq 0x44e0
movq %rax, %rdi
movl $0x5d, %esi
callq 0x4340
movq 0x8(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1196b
movq 0x10(%rsp), %rdi
movl $0x28, %esi
callq 0x4340
movq %rax, %rdi
leaq -0x5ea8(%rip), %rsi     # 0xbaa0
callq 0x4100
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x4520
movq %rax, %rdi
movl $0x29, %esi
callq 0x4340
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: Konano[P]Artificial-Intelligence-Input-Method/training.cpp
// Function: main
int main()
{
	ReadData();

	char Filename[30] = "sina_news_gbk/S-00";

	int f = 1, ST, ED;

	printf("�ӵڼ����ļ���ʼ��\n");
	scanf("%d", &ST); f = ST-1;

	while (true)
	{
		//printf("��ǰ������Ϊ %d\n", Times_2.size());
		printf("ָ���������ڼ����ļ���\n");
		scanf("%d", &ED);
		if (ED == -1) break;

		while (f < ED)
		{
			f++;
			printf("\n��ʼ��ȡ�� %d ���ļ�����\n\n", f);

			Filename[16] = f/10 + '0';
			Filename[17] = f%10 + '0';

			ReadInput(Filename);
			StoreData(f);
			printf("%d ����ϵ����Ϊ %d\n", f, Times_2.size());
			Times_2.clear();
		}
	}
	return 0;
}

// Assembly:
subq $0x38, %rsp
movl $0x0, 0x34(%rsp)
callq 0x3a70
movq 0x77b8(%rip), %rax      # 0xb010
movq %rax, 0x10(%rsp)
movq 0x77b4(%rip), %rax      # 0xb018
movq %rax, 0x18(%rsp)
movq 0x77b0(%rip), %rax      # 0xb020
movq %rax, 0x20(%rsp)
movl 0x77ad(%rip), %eax      # 0xb028
movl %eax, 0x28(%rsp)
movw 0x77a6(%rip), %ax       # 0xb02c
movw %ax, 0x2c(%rsp)
movl $0x1, 0xc(%rsp)
leaq 0x77b4(%rip), %rdi      # 0xb04e
movb $0x0, %al
callq 0x3050
leaq 0x77ba(%rip), %rdi      # 0xb062
leaq 0x8(%rsp), %rsi
movb $0x0, %al
callq 0x3290
movl 0x8(%rsp), %eax
subl $0x1, %eax
movl %eax, 0xc(%rsp)
leaq 0x779f(%rip), %rdi      # 0xb065
movb $0x0, %al
callq 0x3050
leaq 0x778e(%rip), %rdi      # 0xb062
leaq 0x4(%rsp), %rsi
movb $0x0, %al
callq 0x3290
cmpl $-0x1, 0x4(%rsp)
jne 0x38ec
jmp 0x3991
jmp 0x38ee
movl 0xc(%rsp), %eax
cmpl 0x4(%rsp), %eax
jge 0x398c
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %esi
leaq 0x776b(%rip), %rdi      # 0xb07d
movb $0x0, %al
callq 0x3050
movl 0xc(%rsp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
addl $0x30, %eax
movb %al, 0x20(%rsp)
movl 0xc(%rsp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
addl $0x30, %edx
movb %dl, %al
movb %al, 0x21(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x3d60
movl 0xc(%rsp), %edi
callq 0x41b0
movl 0xc(%rsp), %eax
movl %eax, (%rsp)
leaq 0x502c4de(%rip), %rdi   # 0x502fe40
callq 0x4340
movl (%rsp), %esi
movq %rax, %rdx
leaq 0x7725(%rip), %rdi      # 0xb099
movb $0x0, %al
callq 0x3050
leaq 0x502c4be(%rip), %rdi   # 0x502fe40
callq 0x4350
jmp 0x38ee
jmp 0x38bf
xorl %eax, %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: Konano[P]Artificial-Intelligence-Input-Method/training.cpp
// Function: StoreData(int)
inline void StoreData(int f)
{
	// ============================================ 1-Gram

	// #ifdef FIRST
	// ofstream fout1("1-word");
	// #else
	// ofstream fout1("1-word-tmp");
	// #endif

	// for(int i=1; i<=WordTotal; i++)
	// 	fout1 << Word[i] << ' ' << JoinPinyin(i) << ' ' << Times_1[i] << endl;

	// ============================================ 2-Gram

	char Filename[30] = "data/00";

	Filename[5] = f/10 + '0';
	Filename[6] = f%10 + '0';

	ofstream fout2(Filename);

	for(map<long long,int>::iterator iter = Times_2.begin(); iter != Times_2.end(); iter++)
		fout2 << iter->first << ' ' << iter->second << endl;
}

// Assembly:
subq $0x268, %rsp            # imm = 0x268
movl %edi, 0x264(%rsp)
movq 0x6e6b(%rip), %rax      # 0xb030
movq %rax, 0x240(%rsp)
movq 0x6e64(%rip), %rax      # 0xb038
movq %rax, 0x248(%rsp)
movq 0x6e5d(%rip), %rax      # 0xb040
movq %rax, 0x250(%rsp)
movl 0x6e57(%rip), %eax      # 0xb048
movl %eax, 0x258(%rsp)
movw 0x6e4d(%rip), %ax       # 0xb04c
movw %ax, 0x25c(%rsp)
movl 0x264(%rsp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
addl $0x30, %eax
movb %al, 0x245(%rsp)
movl 0x264(%rsp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
addl $0x30, %edx
movb %dl, %al
movb %al, 0x246(%rsp)
leaq 0x240(%rsp), %rsi
leaq 0x40(%rsp), %rdi
movl $0x10, %edx
callq 0x3260
leaq 0x502bbe7(%rip), %rdi   # 0x502fe40
callq 0xa080
movq %rax, 0x38(%rsp)
leaq 0x502bbd6(%rip), %rdi   # 0x502fe40
callq 0x8a10
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xa0b0
testb $0x1, %al
jne 0x428c
jmp 0x4321
leaq 0x38(%rsp), %rdi
callq 0xa0d0
movq (%rax), %rsi
leaq 0x40(%rsp), %rdi
callq 0x3110
movq %rax, 0x10(%rsp)
jmp 0x42aa
movq 0x10(%rsp), %rdi
movl $0x20, %esi
callq 0x32a0
movq %rax, 0x8(%rsp)
jmp 0x42c0
leaq 0x38(%rsp), %rdi
callq 0xa0d0
movq 0x8(%rsp), %rdi
movl 0x8(%rax), %esi
callq 0x33c0
movq %rax, (%rsp)
jmp 0x42dd
movq (%rsp), %rdi
movq 0xbce8(%rip), %rsi      # 0xffd0
callq 0x3220
jmp 0x42ef
jmp 0x42f1
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0xa0f0
movq %rax, 0x18(%rsp)
jmp 0x4263
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x3340
jmp 0x4333
leaq 0x40(%rsp), %rdi
callq 0x3340
addq $0x268, %rsp            # imm = 0x268
retq
movq 0x28(%rsp), %rdi
callq 0x33d0
nopl (%rax)
// File: Konano[P]Artificial-Intelligence-Input-Method/./function.h
// Function: Word_ID(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
inline int Word_ID(string wd, string py)
{
	int H = PinyinHash(py);
	if (Word_map.count(make_pair(wd, H)))
		return Word_map[make_pair(wd, H)];

	WordTotal ++;
	Word[WordTotal] = wd;
	Word_map[make_pair(wd, H)] = WordTotal;
	SplitPinyin(WordTotal, py);

	return WordTotal;
}

// Assembly:
subq $0x158, %rsp            # imm = 0x158
movq %rdi, 0x50(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdi, 0x148(%rsp)
movq %rsi, 0x140(%rsp)
leaq 0x118(%rsp), %rdi
movq %rdi, 0x60(%rsp)
callq 0x30e0
movq 0x60(%rsp), %rdi
callq 0x5370
movl %eax, 0x6c(%rsp)
jmp 0x4f53
leaq 0x118(%rsp), %rdi
callq 0x3150
movl 0x6c(%rsp), %eax
movq 0x50(%rsp), %rsi
movl %eax, 0x13c(%rsp)
leaq 0xe0(%rsp), %rdi
movq %rdi, 0x40(%rsp)
leaq 0x13c(%rsp), %rdx
callq 0x55b0
movq 0x40(%rsp), %rsi
leaq 0x502ae7a(%rip), %rdi   # 0x502fe10
callq 0x5550
movq %rax, 0x48(%rsp)
jmp 0x4fa2
leaq 0xe0(%rsp), %rdi
callq 0x4aa0
movq 0x48(%rsp), %rax
cmpq $0x0, %rax
je 0x5087
movq 0x50(%rsp), %rsi
leaq 0xb8(%rsp), %rdi
movq %rdi, 0x30(%rsp)
leaq 0x13c(%rsp), %rdx
callq 0x55b0
movq 0x30(%rsp), %rsi
leaq 0x502ae27(%rip), %rdi   # 0x502fe10
callq 0x55f0
movq %rax, 0x38(%rsp)
jmp 0x4ff5
movq 0x38(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x154(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0x4aa0
jmp 0x5197
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x110(%rsp)
movl %eax, 0x10c(%rsp)
leaq 0x118(%rsp), %rdi
callq 0x3150
jmp 0x51a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x110(%rsp)
movl %eax, 0x10c(%rsp)
leaq 0xe0(%rsp), %rdi
callq 0x4aa0
jmp 0x51a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x110(%rsp)
movl %eax, 0x10c(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0x4aa0
jmp 0x51a6
movq 0x50(%rsp), %rsi
movl 0xb1c6(%rip), %eax      # 0x10258
incl %eax
movl %eax, 0xb1be(%rip)      # 0x10258
movslq 0xb1b7(%rip), %rax      # 0x10258
shlq $0x5, %rax
leaq 0xf064(%rip), %rdi      # 0x14110
addq %rax, %rdi
callq 0x3040
movq 0x50(%rsp), %rsi
movl 0xb199(%rip), %eax      # 0x10258
movl %eax, 0x1c(%rsp)
leaq 0x90(%rsp), %rdi
movq %rdi, 0x20(%rsp)
leaq 0x13c(%rsp), %rdx
callq 0x55b0
movq 0x20(%rsp), %rsi
leaq 0x502ad27(%rip), %rdi   # 0x502fe10
callq 0x55f0
movq %rax, 0x28(%rsp)
jmp 0x50f5
movq 0x28(%rsp), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, (%rax)
leaq 0x90(%rsp), %rdi
callq 0x4aa0
movq 0x58(%rsp), %rsi
movl 0xb140(%rip), %eax      # 0x10258
movl %eax, 0xc(%rsp)
leaq 0x70(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x30e0
movl 0xc(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x56e0
jmp 0x513b
leaq 0x70(%rsp), %rdi
callq 0x3150
movl 0xb10d(%rip), %eax      # 0x10258
movl %eax, 0x154(%rsp)
jmp 0x5197
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x110(%rsp)
movl %eax, 0x10c(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x4aa0
jmp 0x51a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x110(%rsp)
movl %eax, 0x10c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x3150
jmp 0x51a6
movl 0x154(%rsp), %eax
addq $0x158, %rsp            # imm = 0x158
retq
movq 0x110(%rsp), %rdi
callq 0x33d0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Konano[P]Artificial-Intelligence-Input-Method/./function.h
// Function: PinyinHash(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
inline int PinyinHash(string py)
{
	int L = py.length();
	int num = 0;
	int S = 0, E = py.find('-', S);

	while (E != -1)
	{
		num = (2333LL * num + Pinyin_ID(py.substr(S, E-S))) % 1000000007;
		S = E + 1;
		E = py.find('-', S);
	}
	num = (2333LL * num + Pinyin_ID(py.substr(S, L-S))) % 1000000007;
	return num;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x38(%rsp)
movq %rdi, 0xa0(%rsp)
callq 0x3350
movq 0x38(%rsp), %rdi
movl %eax, 0x9c(%rsp)
movl $0x0, 0x98(%rsp)
movl $0x0, 0x94(%rsp)
movslq 0x94(%rsp), %rdx
movl $0x2d, %esi
callq 0x3300
movl %eax, 0x90(%rsp)
cmpl $-0x1, 0x90(%rsp)
je 0x549d
movq 0x38(%rsp), %rsi
movslq 0x98(%rsp), %rax
imulq $0x91d, %rax, %rax      # imm = 0x91D
movq %rax, 0x20(%rsp)
movslq 0x94(%rsp), %rdx
movl %edx, %ecx
movl 0x90(%rsp), %eax
subl %ecx, %eax
movslq %eax, %rcx
leaq 0x70(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x3200
movq 0x28(%rsp), %rdi
callq 0x58c0
movl %eax, 0x34(%rsp)
jmp 0x5420
movq 0x20(%rsp), %rax
movl 0x34(%rsp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movl $0x3b9aca07, %ecx       # imm = 0x3B9ACA07
cqto
idivq %rcx
movl %edx, %eax
movl %eax, 0x98(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x3150
movq 0x38(%rsp), %rdi
movl 0x90(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x94(%rsp)
movslq 0x94(%rsp), %rdx
movl $0x2d, %esi
callq 0x3300
movl %eax, 0x90(%rsp)
jmp 0x53c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x3150
jmp 0x553e
movq 0x38(%rsp), %rsi
movslq 0x98(%rsp), %rax
imulq $0x91d, %rax, %rax      # imm = 0x91D
movq %rax, 0x8(%rsp)
movslq 0x94(%rsp), %rdx
movl %edx, %ecx
movl 0x9c(%rsp), %eax
subl %ecx, %eax
movslq %eax, %rcx
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x3200
movq 0x10(%rsp), %rdi
callq 0x58c0
movl %eax, 0x1c(%rsp)
jmp 0x54eb
movq 0x8(%rsp), %rax
movl 0x1c(%rsp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movl $0x3b9aca07, %ecx       # imm = 0x3B9ACA07
cqto
idivq %rcx
movl %edx, %eax
movl %eax, 0x98(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x3150
movl 0x98(%rsp), %eax
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x3150
movq 0x68(%rsp), %rdi
callq 0x33d0
nopl (%rax,%rax)
// File: Konano[P]Artificial-Intelligence-Input-Method/./function.h
// Function: SplitPinyin(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
inline void SplitPinyin(int id, string py)
{
	int L = py.length();
	int S = 0, E = py.find('-', S);

	while (E != -1)
	{
		Word_pinyin[id].push_back(Pinyin_ID(py.substr(S, E-S)));
		S = E + 1;
		E = py.find('-', S);
	}

	Word_pinyin[id].push_back(Pinyin_ID(py.substr(S, L-S)));
}

// Assembly:
subq $0xb8, %rsp
movq %rsi, 0x38(%rsp)
movl %edi, %eax
movq 0x38(%rsp), %rdi
movq %rdi, 0x40(%rsp)
movl %eax, 0xb4(%rsp)
movq %rdi, 0xa8(%rsp)
callq 0x3350
movq 0x40(%rsp), %rdi
movl %eax, 0xa4(%rsp)
movl $0x0, 0xa0(%rsp)
movslq 0xa0(%rsp), %rdx
movl $0x2d, %esi
callq 0x3300
movl %eax, 0x9c(%rsp)
cmpl $-0x1, 0x9c(%rsp)
je 0x581a
movq 0x40(%rsp), %rsi
movslq 0xb4(%rsp), %rax
leaq (%rax,%rax,2), %rcx
leaq 0x2dd55ae(%rip), %rax   # 0x2ddad10
leaq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
movslq 0xa0(%rsp), %rdx
movl %edx, %ecx
movl 0x9c(%rsp), %eax
subl %ecx, %eax
movslq %eax, %rcx
leaq 0x78(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x3200
movq 0x28(%rsp), %rdi
callq 0x58c0
movl %eax, 0x34(%rsp)
jmp 0x57a0
movq 0x20(%rsp), %rdi
movl 0x34(%rsp), %eax
movl %eax, 0x98(%rsp)
leaq 0x98(%rsp), %rsi
callq 0x7dc0
jmp 0x57bf
leaq 0x78(%rsp), %rdi
callq 0x3150
movq 0x40(%rsp), %rdi
movl 0x9c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xa0(%rsp)
movslq 0xa0(%rsp), %rdx
movl $0x2d, %esi
callq 0x3300
movl %eax, 0x9c(%rsp)
jmp 0x573c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x3150
jmp 0x58b3
movq 0x40(%rsp), %rsi
movslq 0xb4(%rsp), %rax
leaq (%rax,%rax,2), %rcx
leaq 0x2dd54de(%rip), %rax   # 0x2ddad10
leaq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movslq 0xa0(%rsp), %rdx
movl %edx, %ecx
movl 0xa4(%rsp), %eax
subl %ecx, %eax
movslq %eax, %rcx
leaq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x3200
movq 0x10(%rsp), %rdi
callq 0x58c0
movl %eax, 0x1c(%rsp)
jmp 0x5870
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0x68(%rsp)
leaq 0x68(%rsp), %rsi
callq 0x7dc0
jmp 0x5889
leaq 0x48(%rsp), %rdi
callq 0x3150
addq $0xb8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x3150
movq 0x70(%rsp), %rdi
callq 0x33d0
nopl (%rax)
// File: Konano[P]Artificial-Intelligence-Input-Method/./function.h
// Function: Pinyin_ID(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
inline int Pinyin_ID(string py)
{
	if (py=="n") py="en";
	if (py=="lve") py="lue";
	if (py=="nve") py="nue";

	if (Pinyin_map[py] == 0)
		return Pinyin[Pinyin_map[py] = ++PinyinTotal] = py, PinyinTotal;
	return Pinyin_map[py];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, 0x18(%rsp)
leaq 0x57e7(%rip), %rsi      # 0xb0bc
callq 0x59d0
testb $0x1, %al
jne 0x58e0
jmp 0x58f1
movq 0x10(%rsp), %rdi
leaq 0x57cf(%rip), %rsi      # 0xb0bb
callq 0x3310
movq 0x10(%rsp), %rdi
leaq 0x57c1(%rip), %rsi      # 0xb0be
callq 0x59d0
testb $0x1, %al
jne 0x5908
jmp 0x5919
movq 0x10(%rsp), %rdi
leaq 0x57ae(%rip), %rsi      # 0xb0c2
callq 0x3310
movq 0x10(%rsp), %rdi
leaq 0x57a1(%rip), %rsi      # 0xb0c6
callq 0x59d0
testb $0x1, %al
jne 0x5930
jmp 0x5941
movq 0x10(%rsp), %rdi
leaq 0x578e(%rip), %rsi      # 0xb0ca
callq 0x3310
movq 0x10(%rsp), %rsi
leaq 0xe793(%rip), %rdi      # 0x140e0
callq 0x5a00
cmpl $0x0, (%rax)
jne 0x59aa
movq 0x10(%rsp), %rsi
movl 0xa8f2(%rip), %eax      # 0x10254
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl %eax, 0xa8e5(%rip)      # 0x10254
leaq 0xe76a(%rip), %rdi      # 0x140e0
callq 0x5a00
movq 0x10(%rsp), %rsi
movq %rax, %rcx
movl 0xc(%rsp), %eax
movl %eax, (%rcx)
cltq
leaq 0xa8ce(%rip), %rdi      # 0x10260
shlq $0x5, %rax
addq %rax, %rdi
callq 0x3040
movl 0xa8b0(%rip), %eax      # 0x10254
movl %eax, 0x24(%rsp)
jmp 0x59c1
movq 0x10(%rsp), %rsi
leaq 0xe72a(%rip), %rdi      # 0x140e0
callq 0x5a00
movl (%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: nmmmnu[P]HM3/hm3/test/test_list.cc
// Function: main
int main(int argc, char **argv){
	hm3::STLVectorList svl;
		list_test("STLVector", svl);

	// =========================

	hm3::VectorList vl;
		list_test("Vector", vl);

	// =========================

	hm3::LinkList ll;
		list_test("LinkList", ll);

	// =========================

	hm3::SkipList sl;
		list_test("SkipList", sl);
		if (0)
			skiplist_lanes_test(sl);

	// =========================
/*
	hm3::HashList<VectorList<> > hl_vl;
		list_test("HashList@Vector", hl_vl);

	// =========================

	hm3::HashList<LinkList> hl_ll;
		list_test("HashList@LinkList", hl_ll);

	// =========================
*/

	hm3::HashList<std::vector<hm3::SkipList> > hl_sl;
		list_test("HashList@SkipList", hl_sl);

	// =========================

	hm3::BlackHoleList bhl;
		list_test("BlackHoleList", bhl);


}

// Assembly:
subq $0x2c8, %rsp            # imm = 0x2C8
movl %edi, 0x2c4(%rsp)
movq %rsi, 0x2b8(%rsp)
leaq 0x298(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x9970
movq (%rsp), %rsi
leaq 0x1455c(%rip), %rdi     # 0x1704e
callq 0x2ca0
jmp 0x2af9
leaq 0x260(%rsp), %rdi
movl $0x10, %esi
callq 0x11bb0
jmp 0x2b0d
leaq 0x1453d(%rip), %rdi     # 0x17051
leaq 0x260(%rsp), %rsi
callq 0x3af0
jmp 0x2b23
leaq 0x248(%rsp), %rdi
callq 0x126f0
jmp 0x2b32
leaq 0x1451f(%rip), %rdi     # 0x17058
leaq 0x248(%rsp), %rsi
callq 0x4930
jmp 0x2b48
leaq 0x30(%rsp), %rdi
movl $0x20, %esi
callq 0x132b0
jmp 0x2b59
leaq 0x1450a(%rip), %rdi     # 0x1706a
leaq 0x30(%rsp), %rsi
callq 0x5780
jmp 0x2b6c
xorl %eax, %eax
movl %eax, %esi
leaq 0x10(%rsp), %rdi
callq 0x99a0
jmp 0x2b7c
leaq 0x144de(%rip), %rdi     # 0x17061
leaq 0x10(%rsp), %rsi
callq 0x6550
jmp 0x2b8f
leaq 0x144dd(%rip), %rdi     # 0x17073
leaq 0xf(%rsp), %rsi
callq 0x23a0
jmp 0x2ba2
leaq 0x10(%rsp), %rdi
callq 0x9a40
leaq 0x30(%rsp), %rdi
callq 0x133e0
leaq 0x248(%rsp), %rdi
callq 0x9a50
leaq 0x260(%rsp), %rdi
callq 0x9a70
leaq 0x298(%rsp), %rdi
callq 0x9a90
xorl %eax, %eax
addq $0x2c8, %rsp            # imm = 0x2C8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x290(%rsp)
movl %eax, 0x28c(%rsp)
jmp 0x2c84
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x290(%rsp)
movl %eax, 0x28c(%rsp)
jmp 0x2c77
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x290(%rsp)
movl %eax, 0x28c(%rsp)
jmp 0x2c6a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x290(%rsp)
movl %eax, 0x28c(%rsp)
jmp 0x2c60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x290(%rsp)
movl %eax, 0x28c(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x9a40
leaq 0x30(%rsp), %rdi
callq 0x133e0
leaq 0x248(%rsp), %rdi
callq 0x9a50
leaq 0x260(%rsp), %rdi
callq 0x9a70
leaq 0x298(%rsp), %rdi
callq 0x9a90
movq 0x290(%rsp), %rdi
callq 0x2220
nop