LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Unreality3D[P]Unreality3D/indie-studio/source/MapGenerator/MapGenerator.cpp
// Function: Map::draw_rooms()
void	Map::draw_rooms()
{
  int	x = 0;
  int	y = 0;

  for (size_t i = 0;i < _rooms.size();i++)
    {
      x = _rooms[i]._size.x + _rooms[i]._pos.x + 2;
      y = _rooms[i]._size.y + _rooms[i]._pos.y + 2;
      for (int p = _rooms[i]._pos.y + 1; p <= y;p++)
	{
	  for (int o = _rooms[i]._pos.x + 1; o <= x;o++)
	    {
	      if (o == x || o == _rooms[i]._pos.x + 1)
		_map[p][o] = '#';
	      else if  (p == y || p == _rooms[i]._pos.y + 1)
	      	_map[p][o] = '#';
	      else
		_map[p][o] = ' ';
	    }
	}
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x3c(%rsp)
movl $0x0, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x40, %rdi
callq 0x6360
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x764b
movq 0x20(%rsp), %rdi
addq $0x40, %rdi
movq 0x30(%rsp), %rsi
callq 0x6a30
movq 0x20(%rsp), %rdi
movl 0x8(%rax), %eax
movl %eax, 0x10(%rsp)
addq $0x40, %rdi
movq 0x30(%rsp), %rsi
callq 0x6a30
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl 0x10(%rsp), %eax
addl (%rcx), %eax
addl $0x2, %eax
movl %eax, 0x3c(%rsp)
addq $0x40, %rdi
movq 0x30(%rsp), %rsi
callq 0x6a30
movq 0x20(%rsp), %rdi
movl 0xc(%rax), %eax
movl %eax, 0x14(%rsp)
addq $0x40, %rdi
movq 0x30(%rsp), %rsi
callq 0x6a30
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl 0x14(%rsp), %eax
addl 0x4(%rcx), %eax
addl $0x2, %eax
movl %eax, 0x38(%rsp)
addq $0x40, %rdi
movq 0x30(%rsp), %rsi
callq 0x6a30
movl 0x4(%rax), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x38(%rsp), %eax
jg 0x7636
movq 0x20(%rsp), %rdi
addq $0x40, %rdi
movq 0x30(%rsp), %rsi
callq 0x6a30
movl (%rax), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jg 0x7624
movl 0x28(%rsp), %eax
cmpl 0x3c(%rsp), %eax
je 0x756a
movq 0x20(%rsp), %rdi
movl 0x28(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0x40, %rdi
movq 0x30(%rsp), %rsi
callq 0x6a30
movq %rax, %rcx
movl 0xc(%rsp), %eax
movl (%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jne 0x7592
movq 0x20(%rsp), %rdi
addq $0x58, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x6a90
movq %rax, %rdi
movslq 0x28(%rsp), %rsi
callq 0x6b10
movb $0x23, (%rax)
jmp 0x7612
movl 0x2c(%rsp), %eax
cmpl 0x38(%rsp), %eax
je 0x75c8
movq 0x20(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, 0x8(%rsp)
addq $0x40, %rdi
movq 0x30(%rsp), %rsi
callq 0x6a30
movq %rax, %rcx
movl 0x8(%rsp), %eax
movl 0x4(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jne 0x75ed
movq 0x20(%rsp), %rdi
addq $0x58, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x6a90
movq %rax, %rdi
movslq 0x28(%rsp), %rsi
callq 0x6b10
movb $0x23, (%rax)
jmp 0x7610
movq 0x20(%rsp), %rdi
addq $0x58, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x6a90
movq %rax, %rdi
movslq 0x28(%rsp), %rsi
callq 0x6b10
movb $0x20, (%rax)
jmp 0x7612
jmp 0x7614
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x7527
jmp 0x7626
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x74fd
jmp 0x7638
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x743c
addq $0x48, %rsp
retq
// File: Unreality3D[P]Unreality3D/indie-studio/source/MapGenerator/MapGenerator.cpp
// Function: Map::draw_hallways_walls()
void		Map::draw_hallways_walls()
{
  for (size_t i = 1;i < _map.size() - 1;i++)
    {
      for (size_t x = 1;x < _map[i].length()- 1;x++)
	{
	  if ((_map[i][x] == '.' && _map[i][x + 1] == ' ')
	      || (_map[i][x] == '.' && _map[i][x - 1] == ' '))
	    _map[i][x] = '|';
	  else if ((_map[i][x] == '.' && _map[i-1][x] == ' ')
	      || (_map[i][x] == '.' && _map[i+1][x] == ' '))
	    _map[i][x] = '-';
	}
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq $0x1, 0x28(%rsp)
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x58, %rdi
callq 0x6a70
movq %rax, %rcx
movq 0x10(%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x8273
movq $0x1, 0x20(%rsp)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x58, %rdi
movq 0x28(%rsp), %rsi
callq 0x6a90
movq %rax, %rdi
callq 0x67c0
movq %rax, %rcx
movq 0x8(%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x825e
movq 0x18(%rsp), %rdi
addq $0x58, %rdi
movq 0x28(%rsp), %rsi
callq 0x6a90
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x6b10
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x8100
movq 0x18(%rsp), %rdi
addq $0x58, %rdi
movq 0x28(%rsp), %rsi
callq 0x6a90
movq %rax, %rdi
movq 0x20(%rsp), %rsi
addq $0x1, %rsi
callq 0x6b10
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x8154
movq 0x18(%rsp), %rdi
addq $0x58, %rdi
movq 0x28(%rsp), %rsi
callq 0x6a90
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x6b10
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x817c
movq 0x18(%rsp), %rdi
addq $0x58, %rdi
movq 0x28(%rsp), %rsi
callq 0x6a90
movq %rax, %rdi
movq 0x20(%rsp), %rsi
subq $0x1, %rsi
callq 0x6b10
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x817c
movq 0x18(%rsp), %rdi
addq $0x58, %rdi
movq 0x28(%rsp), %rsi
callq 0x6a90
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x6b10
movb $0x7c, (%rax)
jmp 0x8249
movq 0x18(%rsp), %rdi
addq $0x58, %rdi
movq 0x28(%rsp), %rsi
callq 0x6a90
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x6b10
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x81d0
movq 0x18(%rsp), %rdi
addq $0x58, %rdi
movq 0x28(%rsp), %rsi
subq $0x1, %rsi
callq 0x6a90
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x6b10
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x8224
movq 0x18(%rsp), %rdi
addq $0x58, %rdi
movq 0x28(%rsp), %rsi
callq 0x6a90
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x6b10
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x8247
movq 0x18(%rsp), %rdi
addq $0x58, %rdi
movq 0x28(%rsp), %rsi
addq $0x1, %rsi
callq 0x6a90
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x6b10
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x8247
movq 0x18(%rsp), %rdi
addq $0x58, %rdi
movq 0x28(%rsp), %rsi
callq 0x6a90
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x6b10
movb $0x2d, (%rax)
jmp 0x8249
jmp 0x824b
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x8072
jmp 0x8260
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x803c
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: Unreality3D[P]Unreality3D/indie-studio/source/MapGenerator/MgUtils.cpp
// Function: Leaf::create_rooms(std::vector<Rooms, std::allocator<Rooms>>&, Size)
void	Leaf::create_rooms(std::vector<Rooms>& _rooms, Size maxS)
{
  if (leftChild != NULL || rightChild != NULL)
    {
      if (leftChild != NULL)
	leftChild->create_rooms(_rooms, maxS);
      if (rightChild != NULL)
	rightChild->create_rooms(_rooms, maxS);
    }
  else
    {
      if (_size.x <= maxS.x && _size.y <= maxS.y)
	{
	  ++ids;
	  _rooms.push_back(Rooms(_pos, _size, ids));
	}
    }
}

// Assembly:
subq $0x78, %rsp
movq %rdx, 0x70(%rsp)
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rax)
jne 0xc0b0
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0xc111
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0xc0de
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x60(%rsp), %rsi
movq 0x70(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdx
callq 0x69a0
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0xc10c
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x60(%rsp), %rsi
movq 0x70(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdx
callq 0x69a0
jmp 0xc1b9
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
cmpl 0x70(%rsp), %eax
jg 0xc1b7
movq 0x10(%rsp), %rax
movl 0xc(%rax), %eax
cmpl 0x74(%rsp), %eax
jg 0xc1b7
movq 0x10(%rsp), %rax
movl 0x4478(%rip), %ecx      # 0x105b8
incl %ecx
movl %ecx, 0x4470(%rip)      # 0x105b8
movq 0x60(%rsp), %rcx
movq %rcx, (%rsp)
movq (%rax), %rcx
movq %rcx, 0x30(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movl 0x4450(%rip), %ecx      # 0x105b8
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x3c(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x66a0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x6070
jmp 0xc191
leaq 0x3c(%rsp), %rdi
callq 0x6050
jmp 0xc1b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x3c(%rsp), %rdi
callq 0x6050
jmp 0xc1be
jmp 0xc1b9
addq $0x78, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x6a10
nopl (%rax,%rax)
// File: lhartmann[P]orangepi-i2s-steppers/stepper_test.cpp
// Function: main
int main() {
	Stepper s;
	s.prepare(10,100);
	for (int i=0; i<120; ++i) {
		cout
			<< i << " "
			<< (s.step() ? "STEP " : "     ")
			<< (s.done() ? "DONE " : "     ")
			<< endl;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x12c0
leaq -0x18(%rbp), %rdi
movl $0xa, %esi
movl $0x64, %edx
callq 0x12e0
movl $0x0, -0x1c(%rbp)
cmpl $0x78, -0x1c(%rbp)
jge 0x12ab
movl -0x1c(%rbp), %esi
movq 0x2dd2(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
leaq 0xdf9(%rip), %rsi       # 0x200e
callq 0x1040
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1330
testb $0x1, %al
jne 0x122d
jmp 0x123a
leaq 0xdd0(%rip), %rax       # 0x2004
movq %rax, -0x30(%rbp)
jmp 0x1247
leaq 0xdc9(%rip), %rax       # 0x200a
movq %rax, -0x30(%rbp)
jmp 0x1247
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1040
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1390
testb $0x1, %al
jne 0x1267
jmp 0x1274
leaq 0xda2(%rip), %rax       # 0x2010
movq %rax, -0x40(%rbp)
jmp 0x1281
leaq 0xd8f(%rip), %rax       # 0x200a
movq %rax, -0x40(%rbp)
jmp 0x1281
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x1040
movq %rax, %rdi
movq 0x2d30(%rip), %rsi      # 0x3fc8
callq 0x1050
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x11f2
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tewalds[P]morat/gomoku/board.h
// Function: Morat::Gomoku::Board::size(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool size(std::string s) {
		if (!valid_size(s))
			return false;
		size_ = from_str<int>(s);
		neighbor_list_ = gen_neighbor_list();
		num_cells_ = vec_size();
		cells_.resize(vec_size());
		clear();
		return true;
	}

// Assembly:
subq $0x48, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, %rax
movq 0x8(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq %rax, 0x38(%rsp)
movq %rdi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x100a0
testb $0x1, %al
jne 0xfe9a
movb $0x0, 0x47(%rsp)
jmp 0xff10
movq 0x10(%rsp), %rdi
callq 0x100e0
movq 0x18(%rsp), %rsi
movb %al, (%rsi)
leaq 0x20(%rsp), %rdi
callq 0x34250
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
leaq 0x20(%rsp), %rsi
callq 0x10160
leaq 0x20(%rsp), %rdi
callq 0xff20
movq 0x18(%rsp), %rdi
callq 0x10190
movq 0x18(%rsp), %rdi
movw %ax, 0x2(%rdi)
movq %rdi, %rax
addq $0x10, %rax
movq %rax, (%rsp)
callq 0x10190
movq (%rsp), %rdi
movslq %eax, %rsi
callq 0x101b0
movq 0x18(%rsp), %rdi
callq 0x10250
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: tewalds[P]morat/gomoku/board.h
// Function: Morat::Gomoku::Board::clear()
void clear() {
		last_move_ = M_NONE;
		num_moves_ = 0;
		to_play_ = Side::P1;
		outcome_ = Outcome::UNKNOWN;
		hash.clear();

		for(int y = 0; y < size_; y++){
			for(int x = 0; x < size_; x++){
				MoveValid pos = move_valid(x, y);
				Side s = (on_board(x, y) ? Side::NONE : Side::UNDEF);
				cells_[pos.xy] = Cell(s, init_pattern(pos));
			}
		}
	}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x3e(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0xfdd0
movq 0x8(%rsp), %rdi
movw 0x3e(%rsp), %ax
movw %ax, 0x6(%rdi)
movw $0x0, 0x4(%rdi)
leaq 0x56247(%rip), %rax     # 0x664d4
movb (%rax), %al
movb %al, 0x8(%rdi)
leaq 0x5623f(%rip), %rax     # 0x664d8
movb (%rax), %al
movb %al, 0x9(%rdi)
addq $0x28, %rdi
callq 0x10020
movl $0x0, 0x38(%rsp)
movq 0x8(%rsp), %rcx
movl 0x38(%rsp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x103a1
movl $0x0, 0x34(%rsp)
movq 0x8(%rsp), %rcx
movl 0x34(%rsp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x1038f
movq 0x8(%rsp), %rdi
movl 0x34(%rsp), %esi
movl 0x38(%rsp), %edx
callq 0x111f0
movq 0x8(%rsp), %rdi
movl %eax, 0x30(%rsp)
movl 0x34(%rsp), %esi
movl 0x38(%rsp), %edx
callq 0x11240
testb $0x1, %al
jne 0x1030d
jmp 0x1031a
leaq 0x561bf(%rip), %rax     # 0x664d3
movq %rax, (%rsp)
jmp 0x10327
leaq 0x561b1(%rip), %rax     # 0x664d2
movq %rax, (%rsp)
jmp 0x10327
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movb (%rax), %al
movb %al, 0x2f(%rsp)
movb 0x2f(%rsp), %al
movb %al, 0x17(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x112e0
movq %rax, %rdx
leaq 0x18(%rsp), %rdi
movzbl 0x17(%rsp), %esi
callq 0x113c0
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movswq 0x32(%rsp), %rsi
callq 0x113f0
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x102cb
jmp 0x10391
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x102af
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tewalds[P]morat/gomoku/board.h
// Function: Morat::Gomoku::Board::move(Morat::MoveValid const&, bool, bool)
bool move(const MoveValid & pos, bool checkwin = true, bool permanent = true) {
		assert(!outcome_.solved());

		if(!valid_move(pos))
			return false;

		if(checkwin) {
			outcome_ = test_outcome(pos, to_play_);
		}

		last_move_ = pos;
		num_moves_++;

		Cell& cell = cells_[pos.xy];
		cell.piece = to_play_;
		cell.perm = permanent;

		update_hash(pos, to_play_); //depends on num_moves_
		update_pattern(pos, to_play_);

		to_play_ = ~to_play_;

		return true;
	}

// Assembly:
subq $0x38, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
andb $0x1, %cl
movb %cl, 0x1f(%rsp)
andb $0x1, %al
movb %al, 0x1e(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x9, %rdi
callq 0x1c910
xorb $-0x1, %al
testb $0x1, %al
jne 0x1f249
jmp 0x1f24b
jmp 0x1f26a
leaq 0x29605(%rip), %rdi     # 0x48857
leaq 0x285e1(%rip), %rsi     # 0x4783a
movl $0xbb, %edx
leaq 0x29605(%rip), %rcx     # 0x4886a
callq 0x52a0
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x1f370
testb $0x1, %al
jne 0x1f286
movb $0x0, 0x37(%rsp)
jmp 0x1f364
testb $0x1, 0x1f(%rsp)
je 0x1f2b8
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
movb 0x8(%rdi), %al
movb %al, 0x1c(%rsp)
movzbl 0x1c(%rsp), %edx
callq 0x1f3e0
movb %al, %cl
movq (%rsp), %rax
movb %cl, 0x1d(%rsp)
movb 0x1d(%rsp), %cl
movb %cl, 0x9(%rax)
movq (%rsp), %rdi
movq 0x20(%rsp), %rax
movw (%rax), %ax
movw %ax, 0x6(%rdi)
movw 0x4(%rdi), %ax
addw $0x1, %ax
movw %ax, 0x4(%rdi)
addq $0x10, %rdi
movq 0x20(%rsp), %rax
movswq 0x2(%rax), %rsi
callq 0x113f0
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movb 0x8(%rdi), %cl
movb %cl, (%rax)
movb 0x1e(%rsp), %cl
andb $0x1, %cl
movq 0x10(%rsp), %rax
movb %cl, 0x1(%rax)
movq 0x20(%rsp), %rsi
movb 0x8(%rdi), %al
movb %al, 0xf(%rsp)
movzbl 0xf(%rsp), %edx
callq 0x1f5f0
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
movb 0x8(%rdi), %al
movb %al, 0xe(%rsp)
movzbl 0xe(%rsp), %edx
callq 0x1f650
movq (%rsp), %rax
movb 0x8(%rax), %al
movb %al, 0xc(%rsp)
movzbl 0xc(%rsp), %edi
callq 0x1c480
movb %al, %cl
movq (%rsp), %rax
movb %cl, 0xd(%rsp)
movb 0xd(%rsp), %cl
movb %cl, 0x8(%rax)
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: tewalds[P]morat/gomoku/../lib/board_grid_oct.h
// Function: Morat::BoardGridOct<Morat::Gomoku::Board>::local(int, Morat::Side) const
int local(int i,               Side turn) const {
		Pattern p = pattern(i);
		Pattern x = ((p & 0xAAAAAAAAAAAAull) >> 1) ^ (p & 0x555555555555ull); // p1 is now when p1 or p2 but not both (ie off the board)
		p = x & (turn == Side::P1 ? p : p >> 1); // now just the selected player
		return (p & 0x00000000FFFF ? 3 : 0) |
		       (p & 0x0000FFFF0000 ? 2 : 0) |
		       (p & 0xFFFF00000000 ? 1 : 0);
	}

// Assembly:
subq $0x38, %rsp
movb %dl, %al
movb %al, 0x37(%rsp)
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x1fa80
movq %rax, 0x18(%rsp)
movabsq $0xaaaaaaaaaaaa, %rax   # imm = 0xAAAAAAAAAAAA
andq 0x18(%rsp), %rax
shrq %rax
movabsq $0x555555555555, %rcx   # imm = 0x555555555555
andq 0x18(%rsp), %rcx
xorq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x37(%rsp), %rdi
leaq 0x46aef(%rip), %rsi     # 0x664d4
callq 0x1f7c0
testb $0x1, %al
jne 0x1f9f0
jmp 0x1f9fb
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
jmp 0x1fa07
movq 0x18(%rsp), %rax
shrq %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
andq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdx
andq $0xffff, %rdx           # imm = 0xFFFF
xorl %eax, %eax
movl $0x3, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movabsq $0xffff0000, %rsi       # imm = 0xFFFF0000
andq 0x18(%rsp), %rsi
xorl %ecx, %ecx
movl $0x2, %edx
cmpq $0x0, %rsi
cmovnel %edx, %ecx
orl %ecx, %eax
movabsq $0xffff00000000, %rsi   # imm = 0xFFFF00000000
andq 0x18(%rsp), %rsi
xorl %ecx, %ecx
movl $0x1, %edx
cmpq $0x0, %rsi
cmovnel %edx, %ecx
orl %ecx, %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: tewalds[P]morat/gomoku/agentmctsthread.cpp
// Function: Morat::Gomoku::AgentMCTS::AgentThread::add_knowledge(Morat::Gomoku::Board const&, Morat::Gomoku::AgentMCTS::Node*, Morat::Gomoku::AgentMCTS::Node*)
void AgentMCTS::AgentThread::add_knowledge(const Board & board, Node * node, Node * child){
	if(agent->localreply){ //boost for moves near the previous move
		int dist = board.dist(node->move, child->move);
		if(dist < 4)
			child->know += agent->localreply * (4 - dist);
	}

	if(agent->locality) //boost for moves near previous stones
		child->know += agent->locality * board.local(child->move, board.to_play());
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rax), %rax
cmpl $0x0, 0xac(%rax)
je 0x28072
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
addq $0x24, %rsi
movq 0x28(%rsp), %rdx
addq $0x24, %rdx
callq 0x28ab0
movl %eax, 0x24(%rsp)
cmpl $0x4, 0x24(%rsp)
jge 0x28070
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rax
movl 0xac(%rax), %edx
movl $0x4, %eax
subl 0x24(%rsp), %eax
imull %eax, %edx
movq 0x28(%rsp), %rax
movswl 0x20(%rax), %ecx
addl %edx, %ecx
movw %cx, 0x20(%rax)
jmp 0x28072
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rax
cmpl $0x0, 0xb0(%rax)
je 0x280e5
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rax
movl 0xb0(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rax
addq $0x24, %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x1a6a0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movb %al, 0x23(%rsp)
movzbl 0x23(%rsp), %edx
callq 0x28b20
movl 0x14(%rsp), %edx
imull %eax, %edx
movq 0x28(%rsp), %rax
movswl 0x20(%rax), %ecx
addl %edx, %ecx
movw %cx, 0x20(%rax)
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: tewalds[P]morat/gomoku/agentmctsthread.cpp
// Function: Morat::Gomoku::AgentMCTS::AgentThread::rollout_choose_move(Morat::Gomoku::Board&, Morat::Move const&)
Move AgentMCTS::AgentThread::rollout_choose_move(Board & board, const Move & prev){
	//reuse the last good reply
	if(agent->lastgoodreply){
		Move move = last_good_reply.choose_move(board, prev);
		if(move != M_UNKNOWN)
			return move;
	}

	return random_policy.choose_move(board, prev);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rax), %rax
cmpl $0x0, 0xb8(%rax)
je 0x28268
movq 0x8(%rsp), %rdi
addq $0x4c, %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x28e10
movw %ax, 0x36(%rsp)
movl $0xfffffffc, 0x14(%rsp) # imm = 0xFFFFFFFC
leaq 0x36(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x28f20
testb $0x1, %al
jne 0x28264
jmp 0x28266
jmp 0x28288
jmp 0x28268
movq 0x8(%rsp), %rdi
addq $0xa14, %rdi            # imm = 0xA14
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x28f40
movw %ax, 0x36(%rsp)
movw 0x36(%rsp), %ax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tewalds[P]morat/gomoku/agentpns.h
// Function: Morat::Gomoku::AgentPNS::AgentPNS(Morat::Gomoku::Board const&)
AgentPNS(const Board & b) : Agent(b), pool(this) {
		ab = 2;
		df = true;
		epsilon = 0.25;
		ties = Side::NONE;
		numthreads = 1;
		pool.set_num_threads(numthreads);
		gclimit = 5;

		nodes = 0;
		reset();

		set_memlimit(1000*1024*1024);
	}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x38(%rsp), %rsi
callq 0x1b360
movq 0x18(%rsp), %rdi
leaq 0x2cc9a(%rip), %rax     # 0x65b48
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x68, %rdi
movq %rdi, 0x20(%rsp)
callq 0x39fb0
jmp 0x38ec5
movq 0x18(%rsp), %rsi
movq %rsi, %rdi
addq $0x1428, %rdi           # imm = 0x1428
movq %rdi, 0x10(%rsp)
callq 0x3a040
jmp 0x38ee0
movq 0x18(%rsp), %rdi
addq $0x152c, %rdi           # imm = 0x152C
callq 0xfdf0
jmp 0x38ef3
movq 0x18(%rsp), %rdi
addq $0x1538, %rdi           # imm = 0x1538
movq %rdi, 0x8(%rsp)
callq 0x2dc40
jmp 0x38f0b
movq 0x18(%rsp), %rax
movl $0x2, 0x1520(%rax)
movb $0x1, 0x1524(%rax)
movl $0x3e800000, 0x1528(%rax) # imm = 0x3E800000
leaq 0x2d5a1(%rip), %rcx     # 0x664d3
movb (%rcx), %cl
movb %cl, 0x152c(%rax)
movl $0x1, 0x1530(%rax)
movq %rax, %rdi
addq $0x1428, %rdi           # imm = 0x1428
movl 0x1530(%rax), %esi
callq 0x2fab0
jmp 0x38f5b
movq 0x18(%rsp), %rdi
movl $0x5, 0x60(%rdi)
movq $0x0, 0x50(%rdi)
callq 0x32230
jmp 0x38f76
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
movl $0x3e800000, %esi       # imm = 0x3E800000
callq *%rax
jmp 0x38f8b
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x38fec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x38fe2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x38fd8
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x2dc80
movq 0x10(%rsp), %rdi
callq 0x302d0
movq 0x20(%rsp), %rdi
callq 0x30340
movq 0x18(%rsp), %rdi
callq 0x1e190
movq 0x30(%rsp), %rdi
callq 0x5760
// File: tewalds[P]morat/gomoku/../lib/board_grid_oct.h
// Function: Morat::BoardGridOct<Morat::Gomoku::Board>::pattern_symmetry(unsigned long)
static Pattern pattern_symmetry(Pattern p) { //takes a pattern and returns the representative version
		Pattern m = p;                 //0123
		m = std::min(m, (p = pattern_rotate(p)));//3012
		m = std::min(m, (p = pattern_rotate(p)));//2301
		m = std::min(m, (p = pattern_rotate(p)));//3120
		m = std::min(m, (p = pattern_mirror(pattern_rotate(p))));//0123 -> 0321
		m = std::min(m, (p = pattern_rotate(p)));//1032
		m = std::min(m, (p = pattern_rotate(p)));//2103
		m = std::min(m, (p = pattern_rotate(p)));//3210
		return m;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x3a920
movq %rax, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x10cc0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x3a920
movq %rax, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x10cc0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x3a920
movq %rax, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x10cc0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x3a920
movq %rax, %rdi
callq 0x3a950
movq %rax, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x10cc0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x3a920
movq %rax, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x10cc0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x3a920
movq %rax, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x10cc0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x3a920
movq %rax, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x10cc0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: tewalds[P]morat/gomoku/../lib/board_grid_oct.h
// Function: Morat::BoardGridOct<Morat::Gomoku::Board>::pattern_mirror(unsigned long)
static Pattern pattern_mirror(Pattern p) {
		/*
		 *  8  16 9 17 10    10 17  9 16  8
		 * 23  0  1  2 18    18  2  1  0 23
		 * 15  7  X  3 11 => 11  3  X  7 15
		 * 22  6  5  4 19    19  4  5  6 22
		 * 14 21 13 20 12    12 20 13 21 14
		 */

		// pull out an entry
		#define e(a) (p & (3ull << (2 * a)))

		// swap two entries, a > b
		#define s(a, b) ((e(a) >> (2 * (a - b))) | e(b) << (2 * (a - b)))

		return e(9) | e(1) | e(5) | e(13) |
		       s(17, 16) | s( 2,  0) | s( 7,  3) | s( 6,  4) | s(21, 20) |
		       s(10,  8) | s(23, 18) | s(15, 11) | s(22, 19) | s(14, 12);

		#undef e
		#undef s
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
andq $0xc0000, %rax          # imm = 0xC0000
movq -0x8(%rsp), %rcx
andq $0xc, %rcx
orq %rcx, %rax
movq -0x8(%rsp), %rcx
andq $0xc00, %rcx            # imm = 0xC00
orq %rcx, %rax
movq -0x8(%rsp), %rcx
andq $0xc000000, %rcx        # imm = 0xC000000
orq %rcx, %rax
movabsq $0xc00000000, %rcx      # imm = 0xC00000000
andq -0x8(%rsp), %rcx
shrq $0x2, %rcx
movabsq $0x300000000, %rdx      # imm = 0x300000000
andq -0x8(%rsp), %rdx
shlq $0x2, %rdx
orq %rdx, %rcx
orq %rcx, %rax
movq -0x8(%rsp), %rcx
andq $0x30, %rcx
shrq $0x4, %rcx
movq -0x8(%rsp), %rdx
andq $0x3, %rdx
shlq $0x4, %rdx
orq %rdx, %rcx
orq %rcx, %rax
movq -0x8(%rsp), %rcx
andq $0xc000, %rcx           # imm = 0xC000
shrq $0x8, %rcx
movq -0x8(%rsp), %rdx
andq $0xc0, %rdx
shlq $0x8, %rdx
orq %rdx, %rcx
orq %rcx, %rax
movq -0x8(%rsp), %rcx
andq $0x3000, %rcx           # imm = 0x3000
shrq $0x4, %rcx
movq -0x8(%rsp), %rdx
andq $0x300, %rdx            # imm = 0x300
shlq $0x4, %rdx
orq %rdx, %rcx
orq %rcx, %rax
movabsq $0xc0000000000, %rcx    # imm = 0xC0000000000
andq -0x8(%rsp), %rcx
shrq $0x2, %rcx
movabsq $0x30000000000, %rdx    # imm = 0x30000000000
andq -0x8(%rsp), %rdx
shlq $0x2, %rdx
orq %rdx, %rcx
orq %rcx, %rax
movq -0x8(%rsp), %rcx
andq $0x300000, %rcx         # imm = 0x300000
shrq $0x4, %rcx
movq -0x8(%rsp), %rdx
andq $0x30000, %rdx          # imm = 0x30000
shlq $0x4, %rdx
orq %rdx, %rcx
orq %rcx, %rax
movabsq $0xc00000000000, %rcx   # imm = 0xC00000000000
andq -0x8(%rsp), %rcx
shrq $0xa, %rcx
movabsq $0x3000000000, %rdx     # imm = 0x3000000000
andq -0x8(%rsp), %rdx
shlq $0xa, %rdx
orq %rdx, %rcx
orq %rcx, %rax
movabsq $0xc0000000, %rcx       # imm = 0xC0000000
andq -0x8(%rsp), %rcx
shrq $0x8, %rcx
movq -0x8(%rsp), %rdx
andq $0xc00000, %rdx         # imm = 0xC00000
shlq $0x8, %rdx
orq %rdx, %rcx
orq %rcx, %rax
movabsq $0x300000000000, %rcx   # imm = 0x300000000000
andq -0x8(%rsp), %rcx
shrq $0x6, %rcx
movabsq $0xc000000000, %rdx     # imm = 0xC000000000
andq -0x8(%rsp), %rdx
shlq $0x6, %rdx
orq %rdx, %rcx
orq %rcx, %rax
movq -0x8(%rsp), %rcx
andq $0x30000000, %rcx       # imm = 0x30000000
shrq $0x4, %rcx
movq -0x8(%rsp), %rdx
andq $0x3000000, %rdx        # imm = 0x3000000
shlq $0x4, %rdx
orq %rdx, %rcx
orq %rcx, %rax
retq
nopl (%rax)
// File: bakeunbin[P]inverse_mix_column_precalculated/invmc.cpp
// Function: aes::soft::gmul(unsigned char, unsigned char)
uint8_t gmul (uint8_t a, uint8_t b) noexcept
	{
		uint8_t c = 0;

		for (int i = 0 ; i < 8 ; i ++)
		{
			if ((b & 1) != 0)
				c ^= a;
			
			uint8_t h = (uint8_t) ((signed char) a >> 7);

			a = (a << 1) ^ (0x1b & h);
			b >>= 1;
		}

		return c;
	}

// Assembly:
movb %sil, %al
movb %dil, %cl
movb %cl, -0x1(%rsp)
movb %al, -0x2(%rsp)
movb $0x0, -0x3(%rsp)
movl $0x0, -0x8(%rsp)
cmpl $0x8, -0x8(%rsp)
jge 0x23a8
movzbl -0x2(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x236f
movzbl -0x1(%rsp), %ecx
movzbl -0x3(%rsp), %eax
xorl %ecx, %eax
movb %al, -0x3(%rsp)
movsbl -0x1(%rsp), %eax
sarl $0x7, %eax
movb %al, -0x9(%rsp)
movzbl -0x1(%rsp), %eax
shll %eax
movzbl -0x9(%rsp), %ecx
andl $0x1b, %ecx
xorl %ecx, %eax
movb %al, -0x1(%rsp)
movzbl -0x2(%rsp), %eax
sarl %eax
movb %al, -0x2(%rsp)
movl -0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rsp)
jmp 0x234b
movb -0x3(%rsp), %al
retq
nopl (%rax)
// File: bakeunbin[P]inverse_mix_column_precalculated/invmc.cpp
// Function: aes::soft::inv_sr(unsigned char*)
void inv_sr (uint8_t * data) noexcept
	{
		uint8_t temp [16];
		
		memcpy (temp, data, 16);
		
		data [ 0] = temp [ 0], data [ 1] = temp [13], data [ 2] = temp [10], data [ 3] = temp [ 7];
		data [ 4] = temp [ 4], data [ 5] = temp [ 1], data [ 6] = temp [14], data [ 7] = temp [11];
		data [ 8] = temp [ 8], data [ 9] = temp [ 5], data [10] = temp [ 2], data [11] = temp [15];
		data [12] = temp [12], data [13] = temp [ 9], data [14] = temp [ 6], data [15] = temp [ 3];
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rcx
movq %rcx, -0x18(%rsp)
movq 0x8(%rax), %rax
movq %rax, -0x10(%rsp)
movb -0x18(%rsp), %cl
movq -0x8(%rsp), %rax
movb %cl, (%rax)
movb -0xb(%rsp), %cl
movq -0x8(%rsp), %rax
movb %cl, 0x1(%rax)
movb -0xe(%rsp), %cl
movq -0x8(%rsp), %rax
movb %cl, 0x2(%rax)
movb -0x11(%rsp), %cl
movq -0x8(%rsp), %rax
movb %cl, 0x3(%rax)
movb -0x14(%rsp), %cl
movq -0x8(%rsp), %rax
movb %cl, 0x4(%rax)
movb -0x17(%rsp), %cl
movq -0x8(%rsp), %rax
movb %cl, 0x5(%rax)
movb -0xa(%rsp), %cl
movq -0x8(%rsp), %rax
movb %cl, 0x6(%rax)
movb -0xd(%rsp), %cl
movq -0x8(%rsp), %rax
movb %cl, 0x7(%rax)
movb -0x10(%rsp), %cl
movq -0x8(%rsp), %rax
movb %cl, 0x8(%rax)
movb -0x13(%rsp), %cl
movq -0x8(%rsp), %rax
movb %cl, 0x9(%rax)
movb -0x16(%rsp), %cl
movq -0x8(%rsp), %rax
movb %cl, 0xa(%rax)
movb -0x9(%rsp), %cl
movq -0x8(%rsp), %rax
movb %cl, 0xb(%rax)
movb -0xc(%rsp), %cl
movq -0x8(%rsp), %rax
movb %cl, 0xc(%rax)
movb -0xf(%rsp), %cl
movq -0x8(%rsp), %rax
movb %cl, 0xd(%rax)
movb -0x12(%rsp), %cl
movq -0x8(%rsp), %rax
movb %cl, 0xe(%rax)
movb -0x15(%rsp), %cl
movq -0x8(%rsp), %rax
movb %cl, 0xf(%rax)
retq
nopl (%rax,%rax)
// File: bakeunbin[P]inverse_mix_column_precalculated/invmc.cpp
// Function: mixed_precalc(unsigned char*, unsigned char const*)
void mixed_precalc (uint8_t * data, const uint8_t obj [176])
{
	aes::soft::ar (data, obj, 0);

	for (int i = 1 ; i < 10; i ++)
	{
		aes::soft::inv_sb (data);
		aes::soft::inv_sr (data);
		aes::soft::inv_mc_pre (data);
		aes::soft::ar (data, obj, i);
	}
	
	aes::soft::inv_sb (data);
	aes::soft::inv_sr (data);
	aes::soft::ar (data, obj, 10);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x29a0
movl $0x1, 0x4(%rsp)
cmpl $0xa, 0x4(%rsp)
jge 0x2a6c
movq 0x10(%rsp), %rdi
callq 0x23b0
movq 0x10(%rsp), %rdi
callq 0x2400
movq 0x10(%rsp), %rdi
callq 0x24e0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %edx
callq 0x29a0
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2a27
movq 0x10(%rsp), %rdi
callq 0x23b0
movq 0x10(%rsp), %rdi
callq 0x2400
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0xa, %edx
callq 0x29a0
addq $0x18, %rsp
retq
nopl (%rax)
// File: bakeunbin[P]inverse_mix_column_precalculated/invmc.cpp
// Function: mixed_gmul(unsigned char*, unsigned char const*)
void mixed_gmul (uint8_t * data, const uint8_t obj [176])
{
	aes::soft::ar (data, obj, 0);

	for (int i = 1 ; i < 10; i ++)
	{
		aes::soft::inv_sb (data);
		aes::soft::inv_sr (data);
		aes::soft::inv_mc_gmul (data);
		aes::soft::ar (data, obj, i);
	}
	
	aes::soft::inv_sb (data);
	aes::soft::inv_sr (data);
	aes::soft::ar (data, obj, 10);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x29a0
movl $0x1, 0x4(%rsp)
cmpl $0xa, 0x4(%rsp)
jge 0x2b0c
movq 0x10(%rsp), %rdi
callq 0x23b0
movq 0x10(%rsp), %rdi
callq 0x2400
movq 0x10(%rsp), %rdi
callq 0x2740
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %edx
callq 0x29a0
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2ac7
movq 0x10(%rsp), %rdi
callq 0x23b0
movq 0x10(%rsp), %rdi
callq 0x2400
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0xa, %edx
callq 0x29a0
addq $0x18, %rsp
retq
nopl (%rax)
// File: bakeunbin[P]inverse_mix_column_precalculated/invmc.cpp
// Function: decrypt_full_aesni(unsigned char const*, unsigned char (&) [131072], unsigned char const*)
auto decrypt_full_aesni (const uint8_t obj [AES_128_KEY_OBJ_SIZE], uint8_t (& output) [VECTOR_SIZE], const uint8_t input [VECTOR_SIZE])
{
	memcpy (output, input, VECTOR_SIZE);
	
	auto start = std::chrono::high_resolution_clock::now ();
	
	for (size_t i = 0 ; i < BLOCK_COUNT ; i ++)
		full_aesni (output + BLOCK_SIZE * i, obj);
	
	auto end = std::chrono::high_resolution_clock::now ();
	
	return std::chrono::duration_cast <std::chrono::nanoseconds> (end - start).count ();
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl $0x20000, %edx          # imm = 0x20000
callq 0x20d0
callq 0x2030
movq %rax, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
cmpq $0x2000, 0x20(%rsp)     # imm = 0x2000
jae 0x2bb0
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq 0x40(%rsp), %rsi
callq 0x4759
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x2b7a
callq 0x2030
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x3330
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x3300
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x3380
addq $0x48, %rsp
retq
nopl (%rax)
// File: bakeunbin[P]inverse_mix_column_precalculated/invmc.cpp
// Function: decrypt_mixed_precalc(unsigned char const*, unsigned char (&) [131072], unsigned char const*)
auto decrypt_mixed_precalc (const uint8_t obj [AES_128_KEY_OBJ_SIZE], uint8_t (& output) [VECTOR_SIZE], const uint8_t input [VECTOR_SIZE])
{
	memcpy (output, input, VECTOR_SIZE);
	
	auto start = std::chrono::high_resolution_clock::now ();
	
	for (size_t i = 0 ; i < BLOCK_COUNT ; i ++)
		mixed_precalc (output + BLOCK_SIZE * i, obj);
	
	auto end = std::chrono::high_resolution_clock::now ();
	
	return std::chrono::duration_cast <std::chrono::nanoseconds> (end - start).count ();
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl $0x20000, %edx          # imm = 0x20000
callq 0x20d0
callq 0x2030
movq %rax, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
cmpq $0x2000, 0x20(%rsp)     # imm = 0x2000
jae 0x2c60
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq 0x40(%rsp), %rsi
callq 0x2a00
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x2c2a
callq 0x2030
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x3330
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x3300
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x3380
addq $0x48, %rsp
retq
nopl (%rax)
// File: bakeunbin[P]inverse_mix_column_precalculated/invmc.cpp
// Function: decrypt_mixed_gmul(unsigned char const*, unsigned char (&) [131072], unsigned char const*)
auto decrypt_mixed_gmul (const uint8_t obj [AES_128_KEY_OBJ_SIZE], uint8_t (& output) [VECTOR_SIZE], const uint8_t input [VECTOR_SIZE])
{
	memcpy (output, input, VECTOR_SIZE);
	
	auto start = std::chrono::high_resolution_clock::now ();
	
	for (size_t i = 0 ; i < BLOCK_COUNT ; i ++)
		mixed_gmul (output + BLOCK_SIZE * i, obj);
	
	auto end = std::chrono::high_resolution_clock::now ();
	
	return std::chrono::duration_cast <std::chrono::nanoseconds> (end - start).count ();
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl $0x20000, %edx          # imm = 0x20000
callq 0x20d0
callq 0x2030
movq %rax, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
cmpq $0x2000, 0x20(%rsp)     # imm = 0x2000
jae 0x2d10
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq 0x40(%rsp), %rsi
callq 0x2aa0
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x2cda
callq 0x2030
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x3330
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x3300
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x3380
addq $0x48, %rsp
retq
nopl (%rax)
// File: zencoders[P]algoritmica/./algorithms/sorting/insertsort.hpp
// Function: void algoritmica::algorithms::sorting::insertsort<int>(int*, int)
void insertsort(T1 s[], int size)
{
    for(int i = 1; i < size; i++)
    {
        int j = i;
        while((j > 0) && (s[j] < s[j-1]))
        {
            details::swap(&s[j], &s[j-1]);
            j--;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5acb
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x15(%rbp)
jle 0x5a80
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movl -0x14(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
setl %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x5a89
jmp 0x5abb
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movl -0x14(%rbp), %eax
subl $0x1, %eax
cltq
shlq $0x2, %rax
addq %rax, %rsi
callq 0x5ca0
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5a54
jmp 0x5abd
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5a46
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: zencoders[P]algoritmica/./algorithms/sorting/quicksort.hpp
// Function: void algoritmica::algorithms::sorting::quicksort<int>(int*, int, int)
void quicksort(T1 s[], int l, int h)
{
    int p;
    if(h > l)
    {
        p = details::partition(s, l, h);
        quicksort(s, l, p - 1);
        quicksort(s, p + 1, h);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jle 0x8520
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x8530
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x14(%rbp), %edx
subl $0x1, %edx
callq 0x84d0
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
movl -0x10(%rbp), %edx
callq 0x84d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zencoders[P]algoritmica/./algorithms/sorting/quicksort.hpp
// Function: int algoritmica::algorithms::sorting::details::partition<int>(int*, int, int)
int partition(T1 s[], int l, int h)
    {
        int pivot = h;
        int firsthigh = l;
        for(int i = l; i < pivot; ++i)
        {
            if(s[i] < s[pivot])
            {
                details::swap(&s[i], &s[firsthigh]);
                firsthigh++;
            }
        }
        details::swap(&s[firsthigh], &s[pivot]);
        return firsthigh;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x85ad
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x85a0
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movslq -0x18(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x5ca0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x85a2
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8554
movq -0x8(%rbp), %rdi
movslq -0x18(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movslq -0x14(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x5ca0
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: zencoders[P]algoritmica/./algorithms/sorting/selectionsort.hpp
// Function: void algoritmica::algorithms::sorting::selectionsort<int>(int*, int)
void selectionsort(T1 s[], int size)
{
    for(int i = 0; i < size; i++)
    {
        int min = i;

        for(int j = i + 1; j < size; ++j)
        {
            if(s[j] < s[min])
                min = j;
        }
        details::swap(&s[i], &s[min]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xac1e
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xabf0
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0xabe3
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0xabe5
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xabbd
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movslq -0x14(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x5ca0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xaba6
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: zencoders[P]algoritmica/tests/littletest.hpp
// Function: littletest::test_runner::clear_runner()
void clear_runner()
        {
            last_checkpoint_file = "";
            last_checkpoint_line = -1;
            test_counter = 1;
            success_counter = 0;
            failures_counter = 0;
            good_time_total = 0.0,
            total_set_up_time = 0.0;
            total_tear_down_time = 0.0;
            total_time = 0.0;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
leaq 0xb28(%rip), %rsi       # 0xd0b3
callq 0x3220
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
movl $0x1, 0x24(%rax)
movl $0x0, 0x28(%rax)
movl $0x0, 0x2c(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x48(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zencoders[P]algoritmica/tests/littletest.hpp
// Function: littletest::test_runner& littletest::test_runner::run<littletest::test_base>(littletest::test_base*)
test_runner& run(test_impl* t)
        {
            std::cout << "Running test (" << 
                test_counter << "): " << 
                t->__lt_name__ << std::endl;

            t->run_test(this);

            test_counter++;
            return *this;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x58d9(%rip), %rdi      # 0x11fd8
leaq 0xb80(%rip), %rsi       # 0xd286
callq 0x3190
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x24(%rax), %esi
callq 0x3290
movq %rax, %rdi
leaq 0xb71(%rip), %rsi       # 0xd295
callq 0x3190
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3190
movq %rax, %rdi
movq 0x587d(%rip), %rsi      # 0x11fc0
callq 0x31c0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x18(%rbp), %rax
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: IncredibleHannes[P]QMUL-ChessGame/src/Model/Chessman/Bishop.cpp
// Function: Bishop::getPossibleMoves[abi:cxx11](Board const&) const
std::list<Move> Bishop::getPossibleMoves(const Board &board) const {
  std::list<Move> moves;
  if (!isCaptured()) {
    bool leftTop = true;
    bool rightTop = true;
    bool leftBottom = true;
    bool rightBottom = true;
    int i = 1;

    while (leftTop || rightTop || leftBottom || rightBottom) {
      checkMove(board, moves, leftTop, i, -i);
      checkMove(board, moves, rightTop, i, i);
      checkMove(board, moves, leftBottom, -i, -i);
      checkMove(board, moves, rightBottom, -i, i);
      i++;
    }
  }
  return moves;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x3220
movq -0x40(%rbp), %rdi
callq 0x57d0
movb %al, -0x35(%rbp)
jmp 0x30ae
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x31ad
jmp 0x30bb
movb $0x1, -0x2d(%rbp)
movb $0x1, -0x2e(%rbp)
movb $0x1, -0x2f(%rbp)
movb $0x1, -0x30(%rbp)
movl $0x1, -0x34(%rbp)
movb $0x1, %al
testb $0x1, -0x2d(%rbp)
movb %al, -0x51(%rbp)
jne 0x30f9
movb $0x1, %al
testb $0x1, -0x2e(%rbp)
movb %al, -0x51(%rbp)
jne 0x30f9
movb $0x1, %al
testb $0x1, -0x2f(%rbp)
movb %al, -0x51(%rbp)
jne 0x30f9
movb -0x30(%rbp), %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x3105
jmp 0x31ab
movq -0x50(%rbp), %rdx
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x34(%rbp), %r8d
movl %r8d, %r9d
negl %r9d
leaq -0x2d(%rbp), %rcx
callq 0x4840
jmp 0x3126
movq -0x50(%rbp), %rdx
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x34(%rbp), %r9d
leaq -0x2e(%rbp), %rcx
movl %r9d, %r8d
callq 0x4840
jmp 0x3144
movq -0x50(%rbp), %rdx
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x34(%rbp), %r9d
negl %r9d
leaq -0x2f(%rbp), %rcx
movl %r9d, %r8d
callq 0x4840
jmp 0x3165
movq -0x50(%rbp), %rdx
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x34(%rbp), %r9d
movl %r9d, %r8d
negl %r8d
leaq -0x30(%rbp), %rcx
callq 0x4840
jmp 0x3186
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x30d2
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3240
jmp 0x31ca
jmp 0x31ad
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x31c0
movq -0x50(%rbp), %rdi
callq 0x3240
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2260
nopw %cs:(%rax,%rax)
nopl (%rax)