LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/nmmmnu[P]asyncore_cpp/net/asyncloop_impl.h
// Function: net::AsyncLoop<net::selector::PollSelector, net::worker::EchoWorker, net::ClientBuffer<1024ul>>::insertFD_(int)
bool AsyncLoop<SELECTOR, WORKER, CLIENTBUFFER>::insertFD_(int const fd){
	// one for server fd
	if (connectedClients_ + 1 >= selector_.maxFD() )
		return false;

	bool const result = selector_.insertFD(fd);

	if (result == false)
		return false;

	//clients_.insert(std::make_pair(fd, CLIENTBUFFER{}));
	clients_[fd];

	++connectedClients_;

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
movl %esi, -0x1c(%rbp)
movl 0x68(%rdi), %r14d
incl %r14d
callq 0x33c8
cmpl %eax, %r14d
jae 0x2cd9
xorl %r14d, %r14d
movq %rbx, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x3446
testb %al, %al
je 0x2cdc
leaq 0x38(%rbx), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x2cea
incl 0x68(%rbx)
movb $0x1, %r14b
jmp 0x2cdc
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nmmmnu[P]asyncore_cpp/net/sockets.cc
// Function: net::socket_create(net::SOCKET_TCP, char const*, unsigned short, unsigned short, int)
int socket_create(const SOCKET_TCP,  const char *ip, uint16_t const port, uint16_t const backlog, int const options) noexcept{
	int fd = socket(AF_INET , SOCK_STREAM , 0);

	if(fd < 0)
		return SOCKET_ERROR_CREATE;

	int const opt = 1;
	if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, & opt, sizeof opt) < 0){
		::close(fd);
		return SOCKET_ERROR_OPTIONS;
	}

	if (options & SOCKET_NONBLOCK)
	if (! socket_makeNonBlocking(fd) ){
		::close(fd);
		return SOCKET_ERROR_NONBLOCK;
	}

	if (options & SOCKET_TCPNODELAY)
	if (! socket_makeTCPNoDelay(fd) ){
		::close(fd);
		return SOCKET_ERROR_NODELAY;
	}

	struct sockaddr_in address;

	address.sin_family = AF_INET;
	address.sin_addr.s_addr = INADDR_ANY;
	address.sin_port = htons(port);

	if (bind(fd, (struct sockaddr *) & address, sizeof address) < 0){
		::close(fd);
		return SOCKET_ERROR_BIND;
	}

	if (listen(fd, backlog ? backlog : SOMAXCONN) < 0){
		::close(fd);
		return SOCKET_ERROR_BACKLOG;
	}

	return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %r12d
movl %edx, %r14d
movl %esi, %r15d
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2080
testl %eax, %eax
js 0x37b9
movl %eax, %ebx
leaq -0x24(%rbp), %rcx
movl $0x1, (%rcx)
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x2230
testl %eax, %eax
js 0x37c0
testb $0x1, %r12b
je 0x3737
movl %ebx, %edi
callq 0x362f
testb %al, %al
je 0x37ce
testb $0x2, %r12b
je 0x3766
leaq -0x34(%rbp), %rcx
movl $0x1, (%rcx)
movl %ebx, %edi
movl $0x6, %esi
movl $0x1, %edx
movl $0x4, %r8d
callq 0x2230
testl %eax, %eax
js 0x37ea
leaq -0x34(%rbp), %rsi
movw $0x2, (%rsi)
movl $0x0, 0x4(%rsi)
rolw $0x8, %r15w
movw %r15w, 0x2(%rsi)
movl %ebx, %edi
movl $0x10, %edx
callq 0x2060
testl %eax, %eax
js 0x37dc
testw %r14w, %r14w
movl $0x1000, %eax           # imm = 0x1000
cmovnel %r14d, %eax
movzwl %ax, %esi
movl %ebx, %edi
callq 0x21b0
testl %eax, %eax
jns 0x37f6
movl %ebx, %edi
callq 0x2240
movl $0xfffffffa, %ebx       # imm = 0xFFFFFFFA
jmp 0x37f6
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x37f6
movl %ebx, %edi
callq 0x2240
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
jmp 0x37f6
movl %ebx, %edi
callq 0x2240
movl $0xfffffffd, %ebx       # imm = 0xFFFFFFFD
jmp 0x37f6
movl %ebx, %edi
callq 0x2240
movl $0xfffffffb, %ebx       # imm = 0xFFFFFFFB
jmp 0x37f6
movl %ebx, %edi
callq 0x2240
movl $0xfffffffc, %ebx       # imm = 0xFFFFFFFC
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x2758
// File: /workspace/github_cpp_makefile_star2_O3/nmmmnu[P]asyncore_cpp/net/sockets.cc
// Function: net::socket_create(net::SOCKET_UNIX, char const*, unsigned short, int)
int socket_create(const SOCKET_UNIX, const char *path, uint16_t const backlog, int const options) noexcept{
	struct sockaddr_un address;

	if (sizeof address.sun_path < strlen(path))
		return SOCKET_NAME_SIZE;


	int fd = socket(AF_UNIX , SOCK_STREAM , 0);

	if(fd < 0)
		return SOCKET_ERROR_CREATE;

	if (options & SOCKET_NONBLOCK)
	if (! socket_makeNonBlocking(fd) ){
		::close(fd);
		return SOCKET_ERROR_NONBLOCK;
	}

	//struct sockaddr_in address
	address.sun_family = AF_UNIX;
	strcpy(address.sun_path, path);

	unlink(address.sun_path);

	if (bind(fd, (struct sockaddr *) & address, sizeof address) < 0){
		::close(fd);
		return SOCKET_ERROR_BIND;
	}

	if (listen(fd, backlog ? backlog : SOMAXCONN) < 0){
		::close(fd);
		return SOCKET_ERROR_BACKLOG;
	}

	return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movl %edx, %r12d
movl %esi, %r14d
movq %rdi, %r15
callq 0x20e0
movl $0xfffffff9, %ebx       # imm = 0xFFFFFFF9
cmpq $0x6c, %rax
ja 0x38e4
movl $0x1, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2080
testl %eax, %eax
js 0x38c3
movl %eax, %ebx
testb $0x1, %r12b
je 0x3861
movl %ebx, %edi
callq 0x362f
testb %al, %al
je 0x38d8
leaq -0x8c(%rbp), %r12
movw $0x1, -0x2(%r12)
movq %r12, %rdi
movq %r15, %rsi
callq 0x2160
movq %r12, %rdi
callq 0x20f0
leaq -0x8e(%rbp), %rsi
movl %ebx, %edi
movl $0x6e, %edx
callq 0x2060
testl %eax, %eax
js 0x38ca
testw %r14w, %r14w
movl $0x1000, %eax           # imm = 0x1000
cmovnel %r14d, %eax
movzwl %ax, %esi
movl %ebx, %edi
callq 0x21b0
testl %eax, %eax
jns 0x38e4
movl %ebx, %edi
callq 0x2240
movl $0xfffffffa, %ebx       # imm = 0xFFFFFFFA
jmp 0x38e4
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x38e4
movl %ebx, %edi
callq 0x2240
movl $0xfffffffb, %ebx       # imm = 0xFFFFFFFB
jmp 0x38e4
movl %ebx, %edi
callq 0x2240
movl $0xfffffffd, %ebx       # imm = 0xFFFFFFFD
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x2758
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/test/demos/fstream/fstream.cc
// Function: ifstream_test(char const*)
void ifstream_test(const char *file)
{
  scdc::ifstream ifs;
  string line;

  ifs.open(file, ios_base::in);
  int i = 1;
  while (getline(ifs, line)) {
    cout << i << ": " << line << '\n';
    i++;
  }
  ifs.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movq %rdi, %r14
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0xc966
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0xca4c
movl $0x1, %ebp
leaq 0x8(%rsp), %r14
leaq 0x54349(%rip), %r12     # 0x60b0b
leaq 0x7(%rsp), %r13
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb510
movsbl %al, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbab0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0xc845
movq 0x6d7d0(%rip), %rdi     # 0x79fd0
movl %ebp, %esi
callq 0xba20
movq %rax, %r15
movl $0x2, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0xb650
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0xb650
movb $0xa, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0xb650
incl %ebp
jmp 0xc7c7
leaq 0x28(%rsp), %rdi
callq 0xca7a
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xc86b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb550
leaq 0x6b276(%rip), %rax     # 0x77ae8
leaq 0x150(%rsp), %rbx
movq %rax, -0x128(%rbx)
leaq 0x6b288(%rip), %rax     # 0x77b10
movq %rax, (%rbx)
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0xcc64
leaq 0x6b299(%rip), %rax     # 0x77b38
movq %rax, -0x10(%r14)
leaq 0x6b2b6(%rip), %rax     # 0x77b60
movq %rax, (%rbx)
movq $0x0, -0x8(%r14)
movq %rbx, %rdi
callq 0xb1a0
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc8d3
jmp 0xc8d3
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xc8f2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb550
leaq 0x28(%rsp), %rdi
callq 0xcaa6
movq %rbx, %rdi
callq 0xba50
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/test/demos/fstream/fstream.cc
// Function: main
int main(int argc, char** argv)
{
  scdc_init(SCDC_INIT_DEFAULT);

  scdc_dataprov_t dpFS = scdc_dataprov_open("storeFS", "fs", "store/");

  const char *uri = "scdc:/storeFS/test.in";

  ifstream_test(uri);

  scdc_dataprov_close(dpFS);

  scdc_release();

  return 0;
}

// Assembly:
pushq %rbx
leaq 0x51d01(%rip), %rdi     # 0x5e60d
xorl %eax, %eax
callq 0xe9a5
leaq 0x506ea(%rip), %rdi     # 0x5d004
leaq 0x52b61(%rip), %rsi     # 0x5f482
leaq 0x506e4(%rip), %rdx     # 0x5d00c
xorl %eax, %eax
callq 0xed5f
movq %rax, %rbx
leaq 0x506da(%rip), %rdi     # 0x5d013
callq 0xc76c
movq %rbx, %rdi
callq 0xee5a
callq 0xeaa6
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/test/demos/fstream/../../../src/lib/redirect/fstream/basic_file_scdc.h
// Function: scdc::__basic_file_scdc<char>::xsputn(char const*, long)
streamsize 
      xsputn(const char* __s, streamsize __n)
      {
        TRACE(__class__, __func__, "n: %lld", (long long) __n);

        streamsize ret = -1;
        streamsize noffset = offset;

        if (!do_write) goto do_return;

#if BASIC_FILE_SCDC_APPEND
        if (do_append) noffset = 0;
#endif

        scdc_dataset_input_t input;

        scdc_dataset_input_unset(&input);
        SCDC_DATASET_INOUT_BUF_PTR(&input) = const_cast<char *>(__s);
        SCDC_DATASET_INOUT_BUF_SIZE(&input) = __n;
        SCDC_DATASET_INOUT_BUF_CURRENT(&input) = __n;
        input.total_size = __n;
        input.total_size_given = SCDC_DATASET_INOUT_TOTAL_SIZE_GIVEN_EXACT;

        char cmd[256];
        sprintf(cmd, "put %" scdcint_fmt "%c:%" scdcint_fmt,
#if BASIC_FILE_SCDC_APPEND
        (do_append)?0:
#endif
        noffset,
#if BASIC_FILE_SCDC_APPEND
        (do_append)?'B':
#endif
        'F', __n);

        if (scdc_dataset_cmd(_M_dataset, cmd, &input, NULL) != SCDC_SUCCESS) goto do_return;

        ret = __n;
        noffset += __n;

do_return:
        if (ret >= 0)
        {
#if BASIC_FILE_SCDC_APPEND
          if (!do_append)
#endif
          {
            offset = noffset;
          }
        }

        TRACE(__class__, __func__, "return: %lld, offset: %lld", (long long) ret, (long long) offset);

        return ret;
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
movq $-0x1, %r14
cmpb $0x1, 0xa(%rdi)
jne 0xde96
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r15
movq 0x10(%rdi), %r12
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x20672
movq %r13, 0x10(%rbp)
movq %rbx, 0x18(%rbp)
movq %rbx, 0x20(%rbp)
movq %rbx, 0x28(%rbp)
movb $0x78, 0x30(%rbp)
leaq 0x4f1d4(%rip), %rsi     # 0x5d029
leaq 0x60(%rsp), %r13
movq %r13, %rdi
movq %r12, %rdx
movl $0x46, %ecx
movq %rbx, %r8
xorl %eax, %eax
callq 0xb0e0
movq (%r15), %rdi
movq %r13, %rsi
movq %rbp, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x103cb
cmpq $0x1, %rax
jne 0xde96
testq %rbx, %rbx
js 0xde93
addq %rbx, %r12
movq %r12, 0x10(%r15)
movq %rbx, %r14
movq %r14, %rax
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/test/demos/fstream/../../../src/lib/redirect/fstream/basic_file_scdc.h
// Function: scdc::__basic_file_scdc<char>::seekoff(long, std::_Ios_Seekdir)
streamoff
      seekoff(streamoff __off, ios_base::seekdir __way) throw ()
      {
        TRACE(__class__, __func__, "");

        streamoff ret = -1;

        if (__way == ios_base::end)
        {
          char buf[32];
          scdc_dataset_output_t output;

          scdc_dataset_output_unset(&output);
          SCDC_DATASET_INOUT_BUF_PTR(&output) = buf;
          SCDC_DATASET_INOUT_BUF_SIZE(&output) = sizeof(buf) - 1;

          if (scdc_dataset_cmd(_M_dataset, "ls", NULL, &output) != SCDC_SUCCESS) goto do_return;

          long long o;
          std::string s(static_cast<const char *>(SCDC_DATASET_INOUT_BUF_PTR(&output)), SCDC_DATASET_INOUT_BUF_CURRENT(&output));
          sscanf(s.c_str(), "f:%lld|", &o);
          offset = o;
          __way = ios_base::cur;

          while (output.next) output.next(&output, 0);
        }

        switch (__way)
        {
          case ios_base::beg:
            offset = std::max(static_cast<streamoff>(0), __off);
            ret = offset;
            break;
          case ios_base::cur:
            offset += __off;
            ret = offset;
            break;
          default:
            ret = -1;
            break;
        }

        if (ret >= 0) eof = false;

do_return:
        return ret;
      }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
testl %edx, %edx
je 0xe08f
cmpl $0x1, %edx
je 0xe0b4
movq $-0x1, %r15
cmpl $0x2, %edx
jne 0xe0c9
leaq 0x28(%rsp), %rdi
callq 0x20692
leaq 0x80(%rsp), %rax
leaq 0x28(%rsp), %rcx
movq %rax, 0x10(%rcx)
movq $0x1f, 0x18(%rcx)
movq (%r14), %rdi
leaq 0x4ff29(%rip), %rsi     # 0x5df4d
xorl %edx, %edx
xorl %eax, %eax
callq 0x103cb
cmpq $0x1, %rax
jne 0xe0c9
movq 0x38(%rsp), %rsi
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x48(%rsp), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0xe0e6
movq (%rsp), %rdi
leaq 0x505c6(%rip), %rsi     # 0x5e627
leaq 0x20(%rsp), %r15
movq %r15, %rdx
xorl %eax, %eax
callq 0xb520
movq (%r15), %rax
movq %rax, 0x10(%r14)
leaq 0x28(%rsp), %r15
movq 0x60(%rsp), %rax
testq %rax, %rax
je 0xe09e
movq %r15, %rdi
xorl %esi, %esi
callq *%rax
jmp 0xe07c
xorl %eax, %eax
testq %rbx, %rbx
cmovleq %rax, %rbx
movq %rbx, 0x10(%r14)
jmp 0xe0c1
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xe0b4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb550
addq 0x10(%r14), %rbx
movq %rbx, 0x10(%r14)
movq %rbx, %r15
js 0xe0c9
movb $0x0, 0x18(%r14)
movq %rbx, %r15
movq %r15, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xe0dd
movq %rax, %rdi
callq 0xcb2b
nop
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/app/icnf/icnf.c
// Function: msg
static void msg (const char * fmt, ...) {
  va_list ap;
  fflush (stderr);
  printf ("c [icnf] ");
  va_start (ap, fmt);
  vprintf (fmt, ap);
  va_end (ap);
  fputc ('\n', stdout);
  fflush (stdout);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x1fd0
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0x15021(%rip), %rax     # 0x16ff8
movq (%rax), %rdi
callq 0x1150
leaq 0xe2c9(%rip), %rdi      # 0x102af
xorl %eax, %eax
callq 0x10b0
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsi)
movq %r14, 0x10(%rsi)
movq %rbx, %rdi
callq 0x1170
movq 0x14fb4(%rip), %rbx     # 0x16fd0
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x1100
movq (%rbx), %rdi
callq 0x1150
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/iTruth[P]klotski/./klotski_board.h
// Function: klotski_board::klotski_board<std::vector<int, std::allocator<int>>>(std::vector<int, std::allocator<int>> const&, int, int)
klotski_board::klotski_board(const T& situation_array, int dx, int dy):
	dx(dx), dy(dy),
	x_distribution(std::uniform_int_distribution<>(0, dx-1)),
	y_distribution(std::uniform_int_distribution<>(0, dy-1)){
		resize_board_to_fit();
		auto const_array_iterator = situation_array.cbegin();
		for(auto& i: situation){
			for(auto& n: i){
				if(const_array_iterator != situation_array.cend()){
					n = *const_array_iterator++;
				}else{
					throw std::invalid_argument("situation array is not fit");
				}
			}
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8a40(%rip), %rax      # 0xeca0
addq $0x10, %rax
movq %rax, (%rdi)
movl %edx, 0x8(%rdi)
movl %ecx, 0xc(%rdi)
decl %edx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
xorl %eax, %eax
movl %eax, 0x30(%rdi)
movl %edx, 0x34(%rdi)
decl %ecx
movl %eax, 0x38(%rdi)
movl %ecx, 0x3c(%rdi)
movabsq $0x3fe0000000000000, %rax # imm = 0x3FE0000000000000
movq %rax, 0x40(%rdi)
callq 0x687e
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
cmpq %rcx, %rax
je 0x62db
movq (%r14), %rdx
movq 0x8(%r14), %rsi
movq (%rax), %rdi
movq 0x8(%rax), %r8
cmpq %r8, %rdi
je 0x62d2
cmpq %rsi, %rdx
je 0x62e1
movl (%rdx), %r9d
addq $0x4, %rdx
movl %r9d, (%rdi)
addq $0x4, %rdi
jmp 0x62b8
addq $0x18, %rax
cmpq %rcx, %rax
jne 0x62b1
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x30f0
movq %rax, %r15
leaq 0x41e1(%rip), %rsi      # 0xa4d6
movq %rax, %rdi
callq 0x3400
movq 0x8ccc(%rip), %rsi      # 0xefd0
movq 0x8cad(%rip), %rdx      # 0xefb8
movq %r15, %rdi
callq 0x33b0
jmp 0x6315
movq %rax, %r14
jmp 0x6325
movq %rax, %r14
movq %r15, %rdi
callq 0x31a0
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x59fa
movq %r14, %rdi
callq 0x33d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/iTruth[P]klotski/klotski_board.cpp
// Function: klotski_board::resize_board_to_fit()
void klotski_board::resize_board_to_fit(){
	situation.resize(dy);
	situation.shrink_to_fit();
	std::for_each(situation.begin(), situation.end(),
			[this](std::vector<int>& vec){vec.resize(dx); vec.shrink_to_fit();});
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movslq 0xc(%rdi), %rsi
movq %r14, %rdi
callq 0x798e
movq 0x28(%rbx), %r15
cmpq 0x20(%rbx), %r15
je 0x68ac
movq %r14, %rdi
callq 0x5d68
movq 0x20(%rbx), %r15
movq (%r14), %r14
cmpq %r15, %r14
je 0x68d8
movslq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x82e4
movq 0x10(%r14), %rax
cmpq 0x8(%r14), %rax
je 0x68d2
movq %r14, %rdi
callq 0x8424
addq $0x18, %r14
jmp 0x68af
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/iTruth[P]klotski/klotski_board.cpp
// Function: klotski_board::klotski_board(std::basic_fstream<char, std::char_traits<char>>&, int, int)
klotski_board::klotski_board(std::fstream& file, int dx, int dy):
	dx(dx), dy(dy),
	x_distribution(std::uniform_int_distribution<>(0, dx-1)),
	y_distribution(std::uniform_int_distribution<>(0, dy-1)){
		if(!file.is_open()){
			throw std::runtime_error("file is not open");
		}
		resize_board_to_fit();
		for(auto& i:situation){
			for(int& n: i){
				if(file.eof()){
					throw std::runtime_error("file is not fit");
				}
				file>>n;
				if(file.fail()){
					throw std::runtime_error("file is not a valid board file");
				}

			}
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x83ba(%rip), %rax      # 0xecb0
movq %rax, (%rdi)
movl %edx, 0x8(%rdi)
movl %ecx, 0xc(%rdi)
decl %edx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
xorl %eax, %eax
movl %eax, 0x30(%rdi)
movl %edx, 0x34(%rdi)
decl %ecx
movl %eax, 0x38(%rdi)
movl %ecx, 0x3c(%rdi)
movabsq $0x3fe0000000000000, %rax # imm = 0x3FE0000000000000
movq %rax, 0x40(%rdi)
leaq 0x80(%rsi), %rdi
callq 0x3060
testb %al, %al
je 0x69fa
movq %rbx, %rdi
callq 0x687e
movq 0x18(%rbx), %r12
movq 0x20(%rbx), %r13
cmpq %r13, %r12
je 0x699b
movq (%r12), %r15
movq 0x8(%r12), %rbp
cmpq %rbp, %r15
je 0x6995
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x20(%r14,%rax), %eax
testb $0x2, %al
jne 0x69aa
movq %r14, %rdi
movq %r15, %rsi
callq 0x3140
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x20(%r14,%rax), %eax
testb $0x5, %al
jne 0x69c8
addq $0x4, %r15
cmpq %rbp, %r15
jne 0x696d
addq $0x18, %r12
jmp 0x694e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x30f0
movq %rax, %r15
leaq 0x3d14(%rip), %rsi      # 0xa6d2
movq %rax, %rdi
callq 0x30b0
jmp 0x69e4
movl $0x10, %edi
callq 0x30f0
movq %rax, %r15
leaq 0x39ba(%rip), %rsi      # 0xa396
movq %rax, %rdi
callq 0x30b0
movq 0x8605(%rip), %rsi      # 0xeff0
movq 0x85a6(%rip), %rdx      # 0xef98
movq %r15, %rdi
callq 0x33b0
movl $0x10, %edi
callq 0x30f0
movq %rax, %r15
leaq 0x3cb3(%rip), %rsi      # 0xa6c1
movq %rax, %rdi
callq 0x30b0
movq 0x85d3(%rip), %rsi      # 0xeff0
movq 0x8574(%rip), %rdx      # 0xef98
movq %r15, %rdi
callq 0x33b0
jmp 0x6a32
jmp 0x6a41
jmp 0x6a32
movq %rax, %r14
movq %r15, %rdi
callq 0x31a0
jmp 0x6a44
jmp 0x6a41
movq %rax, %r14
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x59fa
movq %r14, %rdi
callq 0x33d0
// File: /workspace/github_cpp_makefile_star2_O3/iTruth[P]klotski/klotski_board.cpp
// Function: klotski_board::reset()
void klotski_board::reset() noexcept{
	resize_board_to_fit();
	int inc = 1;
	for(auto& i: situation){
		for(int& n: i){
			n = inc++;
		}
	}
	situation[dy - 1][dx - 1] = 0;
	zero_x = dx - 1;
	zero_y = dy - 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x687e
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
cmpq %rcx, %rax
je 0x6ad5
movl $0x1, %edx
movq %rax, %rsi
movq (%rsi), %rdi
movq 0x8(%rsi), %r8
cmpq %r8, %rdi
je 0x6acc
movl %edx, (%rdi)
incl %edx
addq $0x4, %rdi
jmp 0x6abd
addq $0x18, %rsi
cmpq %rcx, %rsi
jne 0x6ab6
movslq 0xc(%rbx), %rcx
leaq (%rcx,%rcx,2), %rcx
movslq 0x8(%rbx), %rdx
movq -0x18(%rax,%rcx,8), %rax
movl $0x0, -0x4(%rax,%rdx,4)
movq 0x8(%rbx), %xmm0
pcmpeqd %xmm1, %xmm1
paddd %xmm0, %xmm1
movq %xmm1, 0x10(%rbx)
popq %rbx
retq
movq %rax, %rdi
callq 0x5609
// File: /workspace/github_cpp_makefile_star2_O3/iTruth[P]klotski/klotski_board.cpp
// Function: klotski_board::upset(int)
void klotski_board::upset(int depth) noexcept{
	bool is_horizontal = orientation_distribution(random_engine);
	for (int i = 0; i < depth; ++i) {
		if(is_horizontal){
			while(!move_item(x_distribution(random_engine), zero_y));
		}else{
			while(!move_item(zero_x, y_distribution(random_engine)));
		}
		is_horizontal = !is_horizontal;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x888f(%rip), %rdi      # 0xf3b0
callq 0x7a03
movl %ebx, 0x4(%rsp)
testl %ebx, %ebx
jle 0x6bab
movsd 0x40(%r14), %xmm1
ucomisd %xmm0, %xmm1
seta %bl
leaq 0x38(%r14), %r15
leaq 0x30(%r14), %r12
movl $0x0, (%rsp)
leaq 0x885f(%rip), %r13      # 0xf3b0
testb $0x1, %bl
je 0x6b78
movq %r12, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x7c94
movl 0x14(%r14), %edx
movq (%r14), %rcx
movq %r14, %rdi
movl %eax, %esi
callq *(%rcx)
testb %al, %al
je 0x6b56
jmp 0x6b9a
movl 0x10(%r14), %ebp
movq %r15, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x7c94
movq (%r14), %rcx
movq %r14, %rdi
movl %ebp, %esi
movl %eax, %edx
callq *(%rcx)
testb %al, %al
je 0x6b78
xorb $0x1, %bl
movl (%rsp), %eax
incl %eax
movl %eax, (%rsp)
cmpl 0x4(%rsp), %eax
jne 0x6b51
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6bbe
jmp 0x6bbe
movq %rax, %rdi
callq 0x5609
// File: /workspace/github_cpp_makefile_star2_O3/iTruth[P]klotski/klotski_board.cpp
// Function: klotski_board::print_line(int, int, std::ostream&)
void klotski_board::print_line(int dx, int space_n, std::ostream& os) noexcept{
	os<<std::setw(space_n)<<" ";
	for(int j=0; j<dx; ++j){
		os<<std::setw(space_n+1)<<std::setfill('-')<<"+";
	}
	os<<'+'<<std::endl<<std::setfill(' ');
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movl %esi, %r14d
movl %edi, %ebp
movq (%rdx), %rax
movq -0x18(%rax), %rax
movslq %esi, %rcx
movq %rcx, 0x10(%rdx,%rax)
leaq 0x3417(%rip), %rsi      # 0xa3f9
movl $0x1, %edx
movq %rbx, %rdi
callq 0x3290
testl %ebp, %ebp
jle 0x704f
incl %r14d
movslq %r14d, %r12
leaq 0x36e2(%rip), %r14      # 0xa6e2
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movq %r12, 0x10(%rbx,%rcx)
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %r15
cmpb $0x0, 0xe1(%rbx,%rax)
jne 0x7033
movq %r15, %rdi
movl $0x20, %esi
callq 0x3230
movb $0x1, 0xe1(%r15)
movb $0x2d, 0xe0(%r15)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3290
decl %ebp
jne 0x7000
leaq 0xf(%rsp), %rsi
movb $0x2b, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x3290
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3160
movq %rax, %rbx
movq (%rbx), %rcx
movq -0x18(%rcx), %rcx
addq %rcx, %rbx
cmpb $0x0, 0xe1(%rax,%rcx)
jne 0x70b9
movq %rbx, %rdi
movl $0x20, %esi
callq 0x3230
movb $0x1, 0xe1(%rbx)
movb $0x20, 0xe0(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x70cf
movq %rax, %rdi
callq 0x5609
nop
// File: /workspace/github_cpp_makefile_star2_O3/iTruth[P]klotski/klotski_board.cpp
// Function: klotski_board::move_item(int, int)
bool klotski_board::move_item(int x, int y){
	auto info = get_pos_info(x, y);
	if(info->is_item_can_move){
		if(info->zero_distance != 1){
			if(info->Orientation == pos_info::Horizontal){
				move_item(x, info->is_zero_in_top_or_left?y-1:y+1);
			}else{
				move_item(info->is_zero_in_top_or_left?x-1:x+1, y);
			}
		}
		std::swap(situation[y][x], get_zero());
		zero_x = x;
		zero_y = y;
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movq %rsp, %rbx
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
movl %ebp, %ecx
callq 0x7198
movq (%rbx), %rax
movb 0x5(%rax), %bl
cmpb $0x1, %bl
jne 0x7160
cmpl $0x1, 0x8(%rax)
je 0x7132
movl (%rax), %esi
movzbl 0x4(%rax), %eax
negl %eax
orl $0x1, %eax
xorl %edx, %edx
testl %esi, %esi
movq (%r14), %rcx
cmovnel %eax, %esi
cmovel %eax, %edx
addl %r15d, %esi
addl %ebp, %edx
movq %r14, %rdi
callq *(%rcx)
movslq %ebp, %rax
movq 0x18(%r14), %rcx
leaq (%rax,%rax,2), %rax
movq (%rcx,%rax,8), %r12
movq %r14, %rdi
callq 0x72ee
movslq %r15d, %rcx
movl (%r12,%rcx,4), %edx
movl (%rax), %esi
movl %esi, (%r12,%rcx,4)
movl %edx, (%rax)
movl %r15d, 0x10(%r14)
movl %ebp, 0x14(%r14)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x716f
callq 0x5614
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x7190
callq 0x5614
movq %rbx, %rdi
callq 0x33d0
// File: /workspace/github_cpp_makefile_star2_O3/iTruth[P]klotski/klotski_board.cpp
// Function: klotski_board::get_pos_info(int, int) const
std::shared_ptr<klotski_board::pos_info> klotski_board::get_pos_info(int x, int y) const noexcept{
	auto info = std::make_shared<pos_info>();
	try{
		if(situation.at(y).at(x) == 0){
			info->is_item_can_move = false;
			return info;
		}
	}catch(const std::out_of_range&){
		info->is_item_can_move = false;
		return info;
	}
	for(int i=0; i<dy; ++i){
		if(situation[i][x] == 0){
			info->is_item_can_move = true;
			info->is_zero_in_top_or_left = y - i > 0;
			info->Orientation = pos_info::Horizontal;
			info->zero_distance = abs(y - i);
			zero_x = x;
			zero_y = i;
			return info;
		}
	}
	for(int i=0; i<dx; ++i){
		if(situation[y][i] == 0){
			info->is_item_can_move = true;
			info->is_zero_in_top_or_left = x - i > 0;
			info->Orientation = pos_info::Vertical;
			info->zero_distance = abs(x - i);
			zero_x = i;
			zero_y = y;
			return info;
		}
	}
	info->is_item_can_move = false;
	return info;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movl $0x20, %edi
callq 0x3250
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x7b2f(%rip), %rcx      # 0xecf8
movq %rcx, (%rax)
movq %rax, %rcx
addq $0x10, %rcx
movq $0x0, 0x10(%rax)
movl $0x0, 0x18(%rax)
movq %rax, 0x8(%rbx)
movq %rcx, (%rbx)
movslq %ebp, %rsi
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rcx
subq %rdi, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x72bd
leaq (%rsi,%rsi,2), %rdx
movslq %r15d, %rsi
movq (%rdi,%rdx,8), %rcx
movq 0x8(%rdi,%rdx,8), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rsi, %rdx
jbe 0x72bd
cmpl $0x0, (%rcx,%rsi,4)
je 0x72af
movslq 0xc(%r14), %r8
testq %r8, %r8
jle 0x7259
xorl %edx, %edx
movq (%rdi), %r9
cmpl $0x0, (%r9,%rsi,4)
je 0x7274
incq %rdx
addq $0x18, %rdi
cmpq %rdx, %r8
jne 0x7243
movslq 0x8(%r14), %rsi
testq %rsi, %rsi
jle 0x72af
xorl %edx, %edx
cmpl $0x0, (%rcx,%rdx,4)
je 0x7282
incq %rdx
cmpq %rdx, %rsi
jne 0x7264
jmp 0x72af
movb $0x1, 0x15(%rax)
subl %edx, %ebp
xorl %ecx, %ecx
movl %ebp, %esi
movl %edx, %ebp
jmp 0x7294
movb $0x1, 0x15(%rax)
subl %edx, %r15d
movl $0x1, %ecx
movl %r15d, %esi
movl %edx, %r15d
testl %esi, %esi
setg 0x14(%rax)
movl %esi, %edx
negl %edx
cmovsl %esi, %edx
movl %ecx, 0x10(%rax)
movl %edx, 0x18(%rax)
movl %r15d, 0x10(%r14)
movl %ebp, 0x14(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3445(%rip), %rdi      # 0xa709
xorl %eax, %eax
callq 0x3330
cmpl $0x2, %edx
jne 0x72e6
movq %rax, %rdi
callq 0x30c0
movq (%rbx), %rax
movb $0x0, 0x5(%rax)
callq 0x3390
jmp 0x72af
movq %rax, %rdi
callq 0x5609
// File: /workspace/github_cpp_makefile_star2_O3/iTruth[P]klotski/klotski_board.cpp
// Function: klotski_board::get_zero()
int& klotski_board::get_zero(){
	if(situation[zero_y][zero_x] != 0){
		for(int i=0; i<dy; ++i){
			for(int j=0; j<dx; ++j){
				if(situation[i][j] == 0){
					zero_x = j;
					zero_y = i;
					return situation[i][j];
				}
			}
		}
	}else{
		return situation[zero_y][zero_x];
	}
	throw std::runtime_error("Can not find zero on klotski board");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movslq 0x14(%rdi), %rax
movq 0x18(%rdi), %rcx
leaq (%rax,%rax,2), %rdx
movslq 0x10(%rdi), %rax
movq (%rcx,%rdx,8), %rdx
cmpl $0x0, (%rdx,%rax,4)
je 0x737f
movslq 0xc(%rdi), %rdx
testq %rdx, %rdx
jle 0x7344
movl 0x8(%rdi), %r8d
xorl %esi, %esi
testl %r8d, %r8d
jle 0x733c
leaq (%rsi,%rsi,2), %rax
movq (%rcx,%rax,8), %rax
xorl %r9d, %r9d
cmpl $0x0, (%rax)
je 0x7376
incq %r9
addq $0x4, %rax
cmpq %r9, %r8
jne 0x732b
incq %rsi
cmpq %rdx, %rsi
jne 0x731b
movl $0x10, %edi
callq 0x30f0
movq %rax, %rbx
leaq 0x338e(%rip), %rsi      # 0xa6e6
movq %rax, %rdi
callq 0x30b0
movq 0x7c89(%rip), %rsi      # 0xeff0
movq 0x7c2a(%rip), %rdx      # 0xef98
movq %rbx, %rdi
callq 0x33b0
movl %r9d, 0x10(%rdi)
movl %esi, 0x14(%rdi)
jmp 0x7383
leaq (%rdx,%rax,4), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x31a0
movq %r14, %rdi
callq 0x33d0
// File: /workspace/github_cpp_makefile_star2_O3/iTruth[P]klotski/klotski_board.cpp
// Function: klotski_board::is_valid() const
bool klotski_board::is_valid() const{
	if(!is_nums_linear()){
		return false;
	}
	std::vector<int> linear_situation;
	for(const auto& i: situation){
		for(int j: i){
			linear_situation.push_back(j);
		}
	}

	int rn = 0;
	int situation_size = linear_situation.size();
	for (int i = 0; i < situation_size - 1; ++i) {
		if(linear_situation[i] == 0){
			continue;
		}
		for (int j = i + 1; j < situation_size; ++j) {
			if(linear_situation[j] != 0
					&&linear_situation[i] > linear_situation[j]){
				rn ^= 1;
			}
		}
	}

	if((dx & 1) == 0){
		update_zero_pos();
		rn ^= (dy - 1 - zero_y) & 1;
	}
	return rn == 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
je 0x74a9
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%rbx), %r13
movq 0x20(%rbx), %rax
xorl %r12d, %r12d
movq %rax, 0x30(%rsp)
cmpq %rax, %r13
je 0x74b0
movq %rbx, 0x28(%rsp)
movq %rsp, %r14
leaq 0x24(%rsp), %r15
movq (%r13), %rbx
movq 0x8(%r13), %rbp
cmpq %rbp, %rbx
je 0x748e
movl (%rbx), %eax
movl %eax, 0x24(%rsp)
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x747d
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x7488
movq %r14, %rdi
movq %r15, %rdx
callq 0x60a4
addq $0x4, %rbx
jmp 0x7459
addq $0x18, %r13
cmpq 0x30(%rsp), %r13
jne 0x7451
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rbx
jmp 0x74b4
xorl %ebx, %ebx
jmp 0x754d
xorl %edi, %edi
xorl %eax, %eax
subq %rdi, %rax
shrq $0x2, %rax
cmpl $0x2, %eax
jl 0x7512
leal -0x1(%rax), %ecx
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
movq %rdi, %rsi
xorl %r12d, %r12d
movl (%rdi,%rdx,4), %r8d
testl %r8d, %r8d
je 0x7503
movl $0x1, %r9d
movl (%rsi,%r9,4), %r10d
testl %r10d, %r10d
setne %r11b
cmpl %r10d, %r8d
setg %r10b
andb %r11b, %r10b
movzbl %r10b, %r10d
xorl %r10d, %r12d
incq %r9
cmpq %r9, %rax
jne 0x74df
incq %rdx
addq $0x4, %rsi
decq %rax
cmpq %rcx, %rdx
jne 0x74d0
testb $0x1, 0x8(%rbx)
jne 0x7535
movq %rbx, %rdi
callq 0x7582
movl 0x14(%rbx), %eax
notl %eax
addl 0xc(%rbx), %eax
andl $0x1, %eax
xorl %r12d, %eax
movq (%rsp), %rdi
movl %eax, %r12d
testl %r12d, %r12d
sete %bl
testq %rdi, %rdi
je 0x754d
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x3260
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7560
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x7579
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x3260
movq %rbx, %rdi
callq 0x33d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/iTruth[P]klotski/klotski_board.cpp
// Function: klotski_board::update_zero_pos() const
void klotski_board::update_zero_pos() const{
	if(situation[zero_y][zero_x] == 0){
		return;
	}
	for (int i = 0; i < dy; ++i) {
		for (int j = 0; j < dx; ++j) {
			if(situation[i][j] == 0){
				zero_x = j;
				zero_y = i;
				return;
			}
		}
	}
	throw std::runtime_error("Can not find zero on klotski board");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movslq 0x14(%rdi), %rcx
movq 0x18(%rdi), %rax
leaq (%rcx,%rcx,2), %rcx
movslq 0x10(%rdi), %rdx
movq (%rax,%rcx,8), %rcx
cmpl $0x0, (%rcx,%rdx,4)
je 0x760d
movslq 0xc(%rdi), %rcx
testq %rcx, %rcx
jle 0x75d4
movl 0x8(%rdi), %esi
xorl %edx, %edx
testl %esi, %esi
jle 0x75cc
leaq (%rdx,%rdx,2), %r8
movq (%rax,%r8,8), %r9
xorl %r8d, %r8d
cmpl $0x0, (%r9,%r8,4)
je 0x7606
incq %r8
cmpq %r8, %rsi
jne 0x75bd
incq %rdx
cmpq %rcx, %rdx
jne 0x75ae
movl $0x10, %edi
callq 0x30f0
movq %rax, %rbx
leaq 0x30fe(%rip), %rsi      # 0xa6e6
movq %rax, %rdi
callq 0x30b0
movq 0x79f9(%rip), %rsi      # 0xeff0
movq 0x799a(%rip), %rdx      # 0xef98
movq %rbx, %rdi
callq 0x33b0
movl %r8d, 0x10(%rdi)
movl %edx, 0x14(%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x31a0
movq %r14, %rdi
callq 0x33d0
// File: /workspace/github_cpp_makefile_star2_O3/iTruth[P]klotski/klotski_search.cpp
// Function: klotski_search::build_route(klotski_search::record_item const&)
void klotski_search::build_route(const record_item& item){
	const record_item* cur_item = &item;
	last_route.clear();
	auto last_orientation = record_item::Undefined;
	while(cur_item != nullptr){
		if(cur_item->Orientation != last_orientation){
			last_route.push_front(cur_item->situation);
			last_orientation = cur_item->Orientation;
		}
		cur_item = cur_item->prev;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x20, %r14
movq %r14, %rdi
callq 0x8ba8
movl $0x2, %eax
cmpl %eax, 0x18(%rbx)
je 0x8b74
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8bfa
movl 0x18(%rbx), %eax
movq 0x20(%rbx), %rbx
testq %rbx, %rbx
jne 0x8b61
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/veghead[P]vintage-wireless-keypad/cletus.cpp
// Function: Cletus::foundbit(int)
void Cletus::foundbit(int b) {
    if (debug) std::cout << "BIT:" << b << std::endl;
    // shift a bit into our store. 
    working_byte  = ((working_byte << 1) | (b & 1));
    // Once we have a 
    // byte's worth, push it into our vector
    if (++gotbits % BITS_PER_BYTE == 0) {
        bytes.push_back(working_byte);
        working_byte = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
cmpb $0x1, 0x7c(%rdi)
jne 0x2422
movq 0x3bf7(%rip), %r15      # 0x5fd0
leaq 0x1c38(%rip), %rsi      # 0x4018
movl $0x4, %edx
movq %r15, %rdi
callq 0x2170
movq %r15, %rdi
movl %r14d, %esi
callq 0x2220
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
andl $0x1, %r14d
movl 0x5c(%rbx), %eax
movl 0x78(%rbx), %ecx
leal (%r14,%rax,2), %eax
movl %eax, 0x5c(%rbx)
incl %ecx
movl %ecx, 0x78(%rbx)
testb $0x7, %cl
jne 0x246d
leaq 0x5c(%rbx), %r14
movq 0x68(%rbx), %rsi
cmpq 0x70(%rbx), %rsi
je 0x2457
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x68(%rbx)
jmp 0x2466
addq $0x60, %rbx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x349c
movl $0x0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/veghead[P]vintage-wireless-keypad/cletus.cpp
// Function: Cletus::dumpcode()
void Cletus::dumpcode() {
    if (bytes.size() < 1) return;

    for (int val : bytes) {
        try {
            std::string button = buttons.at(val);
            std::cout << button << " ";
        } catch (std::exception e) {
            std::cout << "Invalid (" << std::hex << val << ") ";
        }
    }
    std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x60(%rdi), %r15
movq 0x68(%rdi), %r13
cmpq %r15, %r13
je 0x25fc
movq %rdi, %r14
leaq -0x50(%rbp), %r12
movq 0x3b28(%rip), %rbx      # 0x5fd0
movq 0x3b19(%rip), %rax      # 0x5fc8
addq $0x10, %rax
movq %rax, -0x68(%rbp)
movl (%r15), %eax
movl %eax, -0x34(%rbp)
movq %r14, %rdi
leaq -0x34(%rbp), %rsi
callq 0x35d4
testq %rax, %rax
je 0x2526
movq %r12, -0x60(%rbp)
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0x3360
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq %rbx, %rdi
callq 0x2170
movl $0x1, %edx
movq %rax, %rdi
leaq 0x1b23(%rip), %rsi      # 0x4028
callq 0x2170
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x2518
callq 0x2140
addq $0x4, %r15
cmpq %r13, %r15
jne 0x24b7
jmp 0x25d5
leaq 0x1be6(%rip), %rdi      # 0x4113
callq 0x21b0
jmp 0x260b
movq %rdx, -0x40(%rbp)
movq %rax, -0x30(%rbp)
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x254d
callq 0x2140
movq -0x40(%rbp), %rdx
jmp 0x2557
movq %rax, -0x30(%rbp)
cmpl $0x1, %edx
jne 0x261d
movq -0x30(%rbp), %rdi
callq 0x2180
movq -0x68(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2080
movl $0x9, %edx
movq %rbx, %rdi
leaq 0x1a94(%rip), %rsi      # 0x401d
callq 0x2170
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rbx,%rax)
movl -0x34(%rbp), %esi
movq %rbx, %rdi
callq 0x2220
movl $0x2, %edx
movq %rax, %rdi
leaq 0x1a6a(%rip), %rsi      # 0x4027
callq 0x2170
leaq -0x60(%rbp), %rdi
callq 0x2250
callq 0x2210
jmp 0x2518
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, -0x30(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2250
callq 0x2210
movq -0x30(%rbp), %rdi
callq 0x2230
movq %rax, %rdi
callq 0x2ada
// File: /workspace/github_cpp_makefile_star2_O3/veghead[P]vintage-wireless-keypad/cletus.cpp
// Function: Cletus::reset()
void Cletus::reset() {
    if (debug) std::cout << "RESET" << std::endl;
    dumpcode();
    bytes.clear();
    gotbits = 0;
    working_byte = 0;
    sample_num = 0;
    lastlevel = 0;
    lastchange = 0;
    state = CletusState::QUIET;
    ticklength = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x7c(%rdi)
jne 0x2680
movq 0x398b(%rip), %r14      # 0x5fd0
leaq 0x19de(%rip), %rsi      # 0x402a
movl $0x5, %edx
movq %r14, %rdi
callq 0x2170
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2478
movq 0x60(%rbx), %rax
cmpq %rax, 0x68(%rbx)
je 0x2696
movq %rax, 0x68(%rbx)
xorl %eax, %eax
movl %eax, 0x78(%rbx)
movl %eax, 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x50(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/veghead[P]vintage-wireless-keypad/cletus.cpp
// Function: main
int main(int argc, char* argv[]) {
    std::string filename = "/dev/stdin";
    if (argc > 1) {
        filename = argv[1];
    }
    usage();
    std::ifstream data(filename, std::ios::binary|std::ios::in);
    uint8_t buf[2];
    int level = 0;
    int lowcount = 0;
    int lowlen = LOW_AFTER_SAMPLES;
    Cletus cletus;
    
    while(!data.eof()) {
        data.read((char *)buf,2);
        
        // convert the I/Q data to a nice real plot
        int i = buf[0] - 127;
        int q = buf[1] - 127;
        int sig = sqrt(i * i + q * q);

        // filter out everything but an on or off signal.
        if (sig > SIGNAL_THRESHOLD) {
            level = 1;
            lowcount = 0;
        } else if (level == 1) {
            if (lowcount++ > lowlen) {
                level = 0;
                lowcount = 0;
            }
        }
        cletus.processSample(level);
    }
    
    data.close();
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2b8, %rsp            # imm = 0x2B8
movq %rsi, %rbx
movl %edi, %r14d
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x1761(%rip), %rsi      # 0x40a2
leaq 0x1764(%rip), %rdx      # 0x40ac
leaq -0x50(%rbp), %rdi
callq 0x33fe
cmpl $0x2, %r14d
jl 0x297e
movq 0x8(%rbx), %rbx
leaq -0x50(%rbp), %r14
movq 0x8(%r14), %r15
movq %rbx, %rdi
callq 0x2090
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %rbx, %rcx
movq %rax, %r8
callq 0x21e0
callq 0x288f
leaq -0x2d8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0xc, %edx
callq 0x21f0
leaq -0xd0(%rbp), %rdi
callq 0x2ae8
leaq -0x2d8(%rbp), %rbx
leaq -0x2a(%rbp), %r14
leaq -0xd0(%rbp), %r15
xorl %r13d, %r13d
xorl %r12d, %r12d
movq -0x2d8(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x2b8(%rbp,%rax)
jne 0x2a4b
movl $0x2, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2190
movzbl -0x2a(%rbp), %eax
addl $-0x7f, %eax
movzbl -0x29(%rbp), %ecx
addl $-0x7f, %ecx
imull %eax, %eax
imull %ecx, %ecx
addl %eax, %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
sqrtsd %xmm0, %xmm0
cvttsd2si %xmm0, %eax
cmpl $0xa, %eax
jle 0x2a16
movl $0x1, %r12d
xorl %r13d, %r13d
jmp 0x2a3b
cmpl $0x1, %r12d
jne 0x2a38
xorl %r12d, %r12d
cmpl $0xb, %r13d
leal 0x1(%r13), %eax
setl %r12b
movl $0x0, %ecx
cmovgel %ecx, %eax
movl %eax, %r13d
jmp 0x2a3b
xorl %r12d, %r12d
movq %r15, %rdi
movl %r12d, %esi
callq 0x26ae
jmp 0x29bc
leaq -0x2d8(%rbp), %rdi
callq 0x2040
leaq -0xd0(%rbp), %rdi
callq 0x2e28
leaq -0x2d8(%rbp), %rdi
callq 0x2050
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x2a81
callq 0x2140
xorl %eax, %eax
addq $0x2b8, %rsp            # imm = 0x2B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2aa5
movq %rax, %rbx
jmp 0x2ab4
jmp 0x2a9e
movq %rax, %rbx
jmp 0x2ac0
jmp 0x2aa5
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
callq 0x2e28
leaq -0x2d8(%rbp), %rdi
callq 0x2050
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x2ad2
callq 0x2140
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk-extras/exprtk_exprgen.cpp
// Function: gen_perm(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, std::deque<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<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 void gen_perm(const std::string& s,
                     const std::size_t n,
                     std::deque<std::string>& perm_list,
                     const std::string prefix = "")
{
   if (n == 0)
   {
      perm_list.push_back(prefix);
      return;
   }

   for (std::size_t i = 0; i < s.size(); ++i)
   {
      gen_perm(s, n - 1, perm_list,prefix + s[i]);
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %rbp
movq %rsi, (%rsp)
testq %rsi, %rsi
je 0x5645
movq %rdi, %r12
cmpq $0x0, 0x8(%rdi)
je 0x5636
decq (%rsp)
xorl %r14d, %r14d
leaq 0x8(%rsp), %r13
movq (%r12), %rax
movsbl (%rax,%r14), %r15d
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x591a
movq 0x10(%rsp), %rsi
movl $0x1, %ecx
movq %r13, %rdi
xorl %edx, %edx
movl %r15d, %r8d
callq 0x2190
movq %r12, %rdi
movq (%rsp), %rsi
movq %rbp, %rdx
movq %r13, %rcx
callq 0x5587
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x562c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20f0
incq %r14
cmpq 0x8(%r12), %r14
jb 0x55c2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbp, %rdi
movq %rbx, %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5688
jmp 0x5660
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x567f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20f0
movq %rbx, %rdi
callq 0x2170
nop
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/sheap.c
// Function: sheap_pull
SCORE*
sheap_pull(SHEAP *shp)
{
    if (shp->hole < shp->count)
        shp->vec[shp->hole] = shp->vec[--shp->count];
    assert(shp->count > 0);
    SCORE *head = shp->vec[shp->hole = 0];
    int i;
    for (; (i = 2*shp->hole + 1) < shp->count; shp->hole = i) {
        i += i + 1 < shp->count && *shp->vec[i] >= *shp->vec[i+1];
        shp->vec[shp->hole] = shp->vec[i];
    }

    shp->count -= shp->count == shp->hole + 1;
    return head;
}

// Assembly:
pushq %rax
movslq 0x8(%rdi), %rax
movl 0x4(%rdi), %ecx
cmpl %ecx, %eax
jge 0x169f
movslq %ecx, %rdx
movq 0x10(%rdi), %rsi
leaq -0x1(%rdx), %rcx
movl %ecx, 0x4(%rdi)
movq -0x8(%rsi,%rdx,8), %rdx
movq %rdx, (%rsi,%rax,8)
testl %ecx, %ecx
jle 0x172c
movq 0x10(%rdi), %rax
movl $0x0, 0x8(%rdi)
movq (%rax), %rax
movl $0x1, %edx
cmpl $0x1, %ecx
je 0x171d
xorl %r9d, %r9d
movl $0x1, %esi
xorl %r8d, %r8d
addl $0x2, %r9d
movq 0x10(%rdi), %r10
movl $0x0, %edx
cmpl %ecx, %r9d
jge 0x16f5
movslq %esi, %rdx
movq (%r10,%rdx,8), %rdx
movl (%rdx), %r11d
movslq %r9d, %rdx
movq (%r10,%rdx,8), %r9
xorl %edx, %edx
cmpl (%r9), %r11d
setge %dl
addl %esi, %edx
movslq %edx, %r9
movq (%r10,%r9,8), %rsi
movslq %r8d, %r8
movq %rsi, (%r10,%r8,8)
movl %r9d, 0x8(%rdi)
leal 0x1(,%r9,2), %esi
addl %r9d, %r9d
movl %edx, %r8d
cmpl %ecx, %esi
jl 0x16ca
incl %edx
xorl %esi, %esi
cmpl %edx, %ecx
sete %sil
subl %esi, %ecx
movl %ecx, 0x4(%rdi)
popq %rcx
retq
leaq 0x19c7(%rip), %rdi      # 0x30fa
leaq 0x19cf(%rip), %rsi      # 0x3109
leaq 0x19f0(%rip), %rcx      # 0x3131
movl $0x3a, %edx
callq 0x10a0
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/sheap.c
// Function: sheap_push
void
sheap_push(SHEAP *shp, SCORE *scp)
{
    assert(sheap_count(shp) < shp->size);
    shp->count += shp->count == shp->hole;
    int i;
    while ((i = shp->hole - 1) >= 0 && *shp->vec[i /= 2] > *scp) {
        shp->vec[shp->hole] = shp->vec[i];
        shp->hole = i;
    }

    shp->vec[shp->hole] = scp;
    shp->hole = shp->count;
}

// Assembly:
pushq %rax
movl 0x4(%rdi), %edx
movl 0x8(%rdi), %ecx
xorl %eax, %eax
cmpl %edx, %ecx
setl %al
movl %edx, %r8d
subl %eax, %r8d
cmpl (%rdi), %r8d
jge 0x17b2
xorl %eax, %eax
cmpl %ecx, %edx
sete %al
addl %edx, %eax
movl %eax, 0x4(%rdi)
testl %ecx, %ecx
jle 0x17a0
leal -0x1(%rcx), %r8d
movq 0x10(%rdi), %r9
movl %r8d, %edx
shrl %edx
movq (%r9,%rdx,8), %r10
movl (%r10), %r11d
cmpl (%rsi), %r11d
jle 0x17a0
movl %ecx, %ecx
movq %r10, (%r9,%rcx,8)
movl %edx, 0x8(%rdi)
movl %edx, %ecx
cmpl $0x1, %r8d
ja 0x1774
jmp 0x17a2
movl %ecx, %edx
movq 0x10(%rdi), %rcx
movslq %edx, %rdx
movq %rsi, (%rcx,%rdx,8)
movl %eax, 0x8(%rdi)
popq %rax
retq
leaq 0x1993(%rip), %rdi      # 0x314c
leaq 0x1949(%rip), %rsi      # 0x3109
leaq 0x19a2(%rip), %rcx      # 0x3169
movl $0x49, %edx
callq 0x10a0