LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/romkatv[P]hcproxy/src/forwarder.cc
// Function: hcproxy::Forwarder::Forward(int, int)
void Forwarder::Forward(int client_fd, int server_fd) {
  CHECK(client_fd >= 0);
  CHECK(server_fd >= 0);
  event_loop_.ScheduleOrRun(
      [=]() { LinkEventHandler::New(&event_loop_, client_fd, server_fd, opt_); });
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
testl %esi, %esi
js 0x1e3d5
testl %edx, %edx
js 0x1e41e
movq 0x18(%rdi), %rax
leaq 0x20(%rsp), %rcx
movq %rdi, (%rcx)
movl %esi, 0x8(%rcx)
movl %edx, 0xc(%rcx)
leaq 0x104(%rip), %rdx       # 0x1e4a0
movq %rdx, 0x18(%rcx)
leaq 0x6cf(%rip), %rdx       # 0x1ea76
movq %rdx, 0x10(%rcx)
movq %rax, %rdi
movq %rcx, %rsi
callq 0x20ad2
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1e3cf
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x40, %rsp
popq %rbx
retq
leaq 0xb1a9e(%rip), %rsi     # 0xcfe7a
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x13e, %edx            # imm = 0x13E
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xb1a8f(%rip), %rsi     # 0xcfe8b
movl $0xe, %edx
callq 0x8b8f0
movq 0x18(%rsp), %rdi
leaq 0xb5eb9(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
jmp 0x1e46b
leaq 0xb1a55(%rip), %rsi     # 0xcfe7a
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x13f, %edx            # imm = 0x13F
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xb1a55(%rip), %rsi     # 0xcfe9a
movl $0xe, %edx
callq 0x8b8f0
movq 0x18(%rsp), %rdi
leaq 0xb5e70(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
jmp 0x1e46b
jmp 0x1e497
jmp 0x1e46b
movq %rsp, %rdi
callq 0x18a24
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1e48f
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0xcc750
movq %rax, %rdi
callq 0x18a37
nop
// File: /workspace/github_cpp_makefile_star2_O3/romkatv[P]hcproxy/src/forwarder.cc
// Function: hcproxy::(anonymous namespace)::LinkEventHandler::OnEvent(hcproxy::EventLoop*, int)
void OnEvent(EventLoop* loop, int events) override {
    // Returns true if some data has been transferred and the link isn't broken.
    auto Process = [&]() -> bool {
      if (HasBits(events, EPOLLERR)) {
        LOG(INFO) << "[" << fd() << "] (" << name_ << ") "
                  << "connection broke: " << Errno(SockError(fd()));
        Terminate(loop);
        return false;
      }
      return (HasBits(events, EPOLLOUT) && ForwardFromOther(loop)) |
             (HasBits(events, EPOLLIN) && other_->ForwardFromOther(loop));
    };
    other_->IncRef();
    if (Process()) {
      Refresh(loop);
      other_->Refresh(loop);
    }
    other_->DecRef();
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
callq 0x1fe64
testb $0x8, %bpl
jne 0x1ede2
xorl %r15d, %r15d
movl $0x0, %r12d
testb $0x4, %bpl
je 0x1ed8b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1f0be
movzbl %al, %r12d
testb $0x1, %bpl
je 0x1eda1
movq 0x58(%rbx), %rdi
movq %r14, %rsi
callq 0x1f0be
movzbl %al, %r15d
orl %r12d, %r15d
je 0x1ee9e
cmpb $0x0, 0x50(%rbx)
jne 0x1edb6
cmpb $0x1, 0x51(%rbx)
jne 0x1edc1
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20bce
movq 0x58(%rbx), %rsi
cmpb $0x0, 0x50(%rsi)
jne 0x1edd5
cmpb $0x1, 0x51(%rsi)
jne 0x1ee9e
movq %r14, %rdi
callq 0x20bce
jmp 0x1ee9e
leaq 0xb1091(%rip), %rsi     # 0xcfe7a
movq %rsp, %r15
movq %r15, %rdi
movl $0xb5, %edx
xorl %ecx, %ecx
callq 0x2003c
movq 0x18(%r15), %rdi
leaq 0xb033d(%rip), %rsi     # 0xcf143
movl $0x1, %edx
callq 0x8b8f0
movl 0x18(%rbx), %esi
movq 0x18(%rsp), %rdi
callq 0x8c1c0
movq 0x18(%rsp), %rdi
leaq 0xb10bf(%rip), %rsi     # 0xcfee8
movl $0x3, %edx
callq 0x8b8f0
leaq 0x38(%rbx), %rsi
movq %rsp, %rdi
callq 0x19da4
movq %rax, %r15
movq 0x18(%rax), %rdi
leaq 0xb10bb(%rip), %rsi     # 0xcff08
movl $0x2, %edx
callq 0x8b8f0
movq 0x18(%r15), %rdi
leaq 0xb10a9(%rip), %rsi     # 0xcff0b
movl $0x12, %edx
callq 0x8b8f0
movl 0x18(%rbx), %edi
callq 0x1ff4c
movq 0x18(%r15), %rdi
movl %eax, %esi
callq 0x200db
movq %rsp, %rdi
callq 0x1959e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fcfa
movq 0x58(%rbx), %rdi
movq %r14, %rsi
callq 0x1fcfa
movq 0x58(%rbx), %rdi
callq 0x1fed0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1eeb8
jmp 0x1eeb8
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1959e
movq %rbx, %rdi
callq 0xcc750
nop
// File: /workspace/github_cpp_makefile_star2_O3/romkatv[P]hcproxy/src/forwarder.cc
// Function: hcproxy::(anonymous namespace)::LinkEventHandler::OnTimeout(hcproxy::EventLoop*)
void OnTimeout(EventLoop* loop) override {
    LOG(INFO) << "[" << fd() << "] (" << name_ << ") timed out waiting for IO";
    other_->IncRef();
    Terminate(loop);
    other_->DecRef();
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xb0f98(%rip), %rsi     # 0xcfe7a
movq %rsp, %r15
movq %r15, %rdi
movl $0xc6, %edx
xorl %ecx, %ecx
callq 0x2003c
movq 0x18(%r15), %rdi
leaq 0xb0244(%rip), %rsi     # 0xcf143
movl $0x1, %edx
callq 0x8b8f0
movl 0x18(%rbx), %esi
movq 0x18(%rsp), %rdi
callq 0x8c1c0
movq 0x18(%rsp), %rdi
leaq 0xb0fc6(%rip), %rsi     # 0xcfee8
movl $0x3, %edx
callq 0x8b8f0
leaq 0x38(%rbx), %rsi
movq %rsp, %rdi
callq 0x19da4
movq 0x18(%rax), %rdi
leaq 0xb1144(%rip), %rsi     # 0xd0087
movl $0x1a, %edx
callq 0x8b8f0
movq %rsp, %rdi
callq 0x1959e
movq 0x58(%rbx), %rdi
callq 0x1fe64
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fcfa
movq 0x58(%rbx), %rdi
movq %r14, %rsi
callq 0x1fcfa
movq 0x58(%rbx), %rdi
callq 0x1fed0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1ef8a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1959e
movq %rbx, %rdi
callq 0xcc750
nop
// File: /workspace/github_cpp_makefile_star2_O3/romkatv[P]hcproxy/src/forwarder.cc
// Function: hcproxy::(anonymous namespace)::LinkEventHandler::Close(hcproxy::EventLoop*)
void Close(EventLoop* loop) {
    if (readable_ || writable_) {
      LOG(INFO) << "[" << fd() << "] (" << name_ << ") close";
      readable_ = false;
      writable_ = false;
      other_->DecRef();
      loop->Remove(this);
      CHECK(close(fd()) == 0) << Errno();
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, 0x50(%rdi)
jne 0x1fd19
cmpb $0x1, 0x51(%rbx)
jne 0x1fdb9
leaq 0xb015a(%rip), %rsi     # 0xcfe7a
movq %rsp, %r15
movq %r15, %rdi
movl $0x11e, %edx            # imm = 0x11E
xorl %ecx, %ecx
callq 0x2003c
movq 0x18(%r15), %rdi
leaq 0xaf406(%rip), %rsi     # 0xcf143
movl $0x1, %edx
callq 0x8b8f0
movl 0x18(%rbx), %esi
movq 0x18(%rsp), %rdi
callq 0x8c1c0
movq 0x18(%rsp), %rdi
leaq 0xb0188(%rip), %rsi     # 0xcfee8
movl $0x3, %edx
callq 0x8b8f0
leaq 0x38(%rbx), %rsi
movq %rsp, %rdi
callq 0x19da4
movq 0x18(%rax), %rdi
leaq 0xb016b(%rip), %rsi     # 0xcfeec
movl $0x7, %edx
callq 0x8b8f0
movq %rsp, %rdi
callq 0x1959e
movw $0x0, 0x50(%rbx)
movq 0x58(%rbx), %rdi
callq 0x1fed0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x206de
movl 0x18(%rbx), %edi
callq 0x15140
testl %eax, %eax
jne 0x1fdc3
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xb00b0(%rip), %rsi     # 0xcfe7a
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x123, %edx            # imm = 0x123
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xaf8da(%rip), %rsi     # 0xcf6c4
movl $0x10, %edx
callq 0x8b8f0
movq 0x18(%rsp), %rdi
leaq 0xb44cb(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
movl (%rsp), %esi
movq 0x18(%rsp), %rdi
callq 0x200db
jmp 0x1fe19
movq %rsp, %rdi
callq 0x18a24
jmp 0x1fe23
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1959e
movq %rbx, %rdi
callq 0xcc750
// File: /workspace/github_cpp_makefile_star2_O3/romkatv[P]hcproxy/src/sock.cc
// Function: hcproxy::SockError(int)
int SockError(int fd) {
  int err = 0;
  socklen_t len = sizeof(err);
  CHECK(getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &len) == 0) << Errno();
  CHECK(len == sizeof(err));
  return err;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
leaq 0xc(%rsp), %rcx
movl $0x0, (%rcx)
leaq 0x8(%rsp), %r8
movl $0x4, (%r8)
movl $0x1, %esi
movl $0x4, %edx
callq 0x15510
testl %eax, %eax
jne 0x1ff8c
cmpl $0x4, 0x8(%rsp)
jne 0x1ffe5
movl 0xc(%rsp), %eax
addq $0x30, %rsp
popq %rbx
retq
leaq 0xb02f4(%rip), %rsi     # 0xd0287
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl $0x1b, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xb02de(%rip), %rsi     # 0xd0293
movl $0x35, %edx
callq 0x8b8f0
movq 0x28(%rsp), %rdi
leaq 0xb4300(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
movl 0x10(%rsp), %esi
movq 0x28(%rsp), %rdi
callq 0x200db
jmp 0x20032
leaq 0xb029b(%rip), %rsi     # 0xd0287
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl $0x1c, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xb02bb(%rip), %rsi     # 0xd02c9
movl $0x12, %edx
callq 0x8b8f0
movq 0x28(%rsp), %rdi
leaq 0xb42a7(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
jmp 0x20032
jmp 0x20032
leaq 0x10(%rsp), %rdi
callq 0x18a24
// File: /workspace/github_cpp_makefile_star2_O3/romkatv[P]hcproxy/src/logging.cc
// Function: hcproxy::internal_logging::operator<<(std::ostream&, hcproxy::internal_logging::Errno)
std::ostream& operator<<(std::ostream& strm, Errno e) {
  // GNU C Library uses a buffer of 1024 characters for strerror(). Mimic to avoid truncations.
  char buf[1024];
  // This temp variable ensures that we are calling the GNU-specific strerror_r().
  const char* desc = strerror_r(e.err, buf, sizeof(buf));
  return strm << desc;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movl %esi, %eax
movq %rdi, %rbx
movq %rsp, %rsi
movl $0x400, %edx            # imm = 0x400
movl %eax, %edi
callq 0x15280
testq %rax, %rax
je 0x20119
movq %rax, %r14
movq %rax, %rdi
callq 0x153a0
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8b8f0
jmp 0x20130
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x6c770
movq %rbx, %rax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/romkatv[P]hcproxy/src/event_loop.cc
// Function: hcproxy::EventLoop::EventLoop(std::chrono::duration<long, std::ratio<1l, 1000000000l>>)
EventLoop::EventLoop(Duration timeout) : timeout_(std::move(timeout)) {
  CHECK(timeout_ > Duration::zero());
  // Passing O_DIRECT to pipe2() doesn't work on WSL.
  // Setting it via fcntl() doesn't work on Linux.
  if (pipe2(pipe_, O_DIRECT) != 0) {
    CHECK(pipe(pipe_) == 0) << Errno();
    for (int fd : pipe_) AddFlags(fd, O_DIRECT);
  }
  epoll_.Add(pipe_[0], EPOLLIN, nullptr);
  loop_ = std::thread(&EventLoop::Loop, this);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x1dc28
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movq %r15, 0x48(%rbx)
movq $0x0, 0x50(%rbx)
testq %r15, %r15
jle 0x20286
movq %rbx, %rdi
movl $0x4000, %esi           # imm = 0x4000
callq 0x15070
testl %eax, %eax
je 0x201d3
movq %rbx, %rdi
callq 0x15460
testl %eax, %eax
jne 0x202cf
xorl %r15d, %r15d
movl (%rbx,%r15), %ebp
movl %ebp, %edi
movl $0x3, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x158f0
orl $0x4000, %eax           # imm = 0x4000
movl %ebp, %edi
movl $0x4, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0x158f0
testl %eax, %eax
jne 0x2022c
addq $0x4, %r15
cmpq $0x8, %r15
jne 0x2019c
movl (%rbx), %esi
movq %r14, %rdi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x1dd72
leaq 0x173(%rip), %rax       # 0x2035e
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq $0x0, 0x8(%rsi)
leaq 0x30(%rsp), %rdx
movq %rbx, (%rdx)
leaq 0x28(%rsp), %rdi
callq 0x20d80
cmpq $0x0, 0x50(%rbx)
jne 0x20358
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb00f5(%rip), %rsi     # 0xd0328
leaq 0x8(%rsp), %rdi
movl $0x26, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x20(%rsp), %rdi
leaq 0xb01e7(%rip), %rsi     # 0xd043a
movl $0x1e, %edx
callq 0x8b8f0
movq 0x20(%rsp), %rdi
leaq 0xb4062(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
movl 0x8(%rsp), %esi
movq 0x20(%rsp), %rdi
callq 0x200db
jmp 0x20332
leaq 0xb009b(%rip), %rsi     # 0xd0328
leaq 0x8(%rsp), %rdi
movl $0x2c, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x20(%rsp), %rdi
leaq 0xb008d(%rip), %rsi     # 0xd033a
movl $0x1b, %edx
callq 0x8b8f0
movq 0x20(%rsp), %rdi
leaq 0xb4008(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
jmp 0x20332
leaq 0xb0052(%rip), %rsi     # 0xd0328
leaq 0x8(%rsp), %rdi
movl $0x30, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x20(%rsp), %rdi
leaq 0xb0060(%rip), %rsi     # 0xd0356
movl $0x10, %edx
callq 0x8b8f0
movq 0x20(%rsp), %rdi
leaq 0xb3fbf(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
movl 0x8(%rsp), %esi
movq 0x20(%rsp), %rdi
callq 0x200db
jmp 0x20332
jmp 0x20332
jmp 0x2033e
jmp 0x20332
jmp 0x2033e
jmp 0x2033e
jmp 0x2033e
leaq 0x8(%rsp), %rdi
callq 0x18a24
jmp 0x2033e
movq %rax, %r15
cmpq $0x0, 0x50(%rbx)
jne 0x20358
movq %r14, %rdi
callq 0x1dcdc
movq %r15, %rdi
callq 0xcc750
callq 0x21d70
nop
// File: /workspace/github_cpp_makefile_star2_O3/romkatv[P]hcproxy/src/event_loop.cc
// Function: hcproxy::EventLoop::Add(hcproxy::EventHandler*, int)
void EventLoop::Add(EventHandler* eh, int events) {
  CHECK(eh);
  CHECK(!eh->event_loop_);
  CHECK(std::this_thread::get_id() == loop_.get_id());
  eh->IncRef();
  eh->event_loop_ = this;
  eh->deadline_ = Clock::now() + timeout_;
  expire_.AddTail(eh);
  epoll_.Add(eh->fd_, events, eh);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
testq %rsi, %rsi
je 0x205f3
movq %rsi, %rbx
cmpq $0x0, 0x28(%rsi)
jne 0x2063f
movl %edx, %ebp
movq %rdi, %r14
callq 0x15490
cmpq 0x50(%r14), %rax
jne 0x20688
movq %rbx, %rdi
callq 0x1fe64
movq %r14, 0x28(%rbx)
callq 0x2b360
addq 0x48(%r14), %rax
movq %rax, 0x20(%rbx)
leaq 0x38(%r14), %rdi
leaq 0x8(%rbx), %rsi
callq 0x184dc
addq $0x8, %r14
movl 0x18(%rbx), %esi
movq %r14, %rdi
movl %ebp, %edx
movq %rbx, %rcx
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1dd72
leaq 0xafd2e(%rip), %rsi     # 0xd0328
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x38, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xafd4d(%rip), %rsi     # 0xd0367
movl $0x2, %edx
callq 0x8b8f0
movq 0x18(%rsp), %rdi
leaq 0xb3c9b(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
jmp 0x206d5
leaq 0xafce2(%rip), %rsi     # 0xd0328
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x39, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xafd04(%rip), %rsi     # 0xd036a
movl $0x10, %edx
callq 0x8b8f0
movq 0x18(%rsp), %rdi
leaq 0xb3c4f(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
jmp 0x206d5
leaq 0xafc99(%rip), %rsi     # 0xd0328
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x3a, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xafccc(%rip), %rsi     # 0xd037b
movl $0x2c, %edx
callq 0x8b8f0
movq 0x18(%rsp), %rdi
leaq 0xb3c06(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
jmp 0x206d5
jmp 0x206d5
jmp 0x206d5
movq %rsp, %rdi
callq 0x18a24
nop
// File: /workspace/github_cpp_makefile_star2_O3/romkatv[P]hcproxy/src/event_loop.cc
// Function: hcproxy::EventLoop::Remove(hcproxy::EventHandler*)
void EventLoop::Remove(EventHandler* eh) {
  CHECK(eh);
  CHECK(eh->event_loop_ == this);
  CHECK(std::this_thread::get_id() == loop_.get_id());
  expire_.Erase(eh);
  epoll_.Remove(eh->fd_);
  eh->event_loop_ = nullptr;
  eh->DecRef();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
testq %rsi, %rsi
je 0x2073c
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rdi, 0x28(%rsi)
jne 0x2078a
callq 0x15490
cmpq 0x50(%r14), %rax
jne 0x207d5
leaq 0x38(%r14), %rdi
leaq 0x8(%rbx), %rsi
callq 0x1871a
addq $0x8, %r14
movl 0x18(%rbx), %esi
movq %r14, %rdi
callq 0x1de06
movq $0x0, 0x28(%rbx)
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x1fed0
leaq 0xafbe5(%rip), %rsi     # 0xd0328
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl $0x43, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xafc02(%rip), %rsi     # 0xd0367
movl $0x2, %edx
callq 0x8b8f0
movq 0x20(%rsp), %rdi
leaq 0xb3b50(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
jmp 0x20824
leaq 0xafb97(%rip), %rsi     # 0xd0328
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl $0x44, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xafbf5(%rip), %rsi     # 0xd03a8
movl $0x17, %edx
callq 0x8b8f0
movq 0x20(%rsp), %rdi
leaq 0xb3b02(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
jmp 0x20824
leaq 0xafb4c(%rip), %rsi     # 0xd0328
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl $0x45, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xafb7d(%rip), %rsi     # 0xd037b
movl $0x2c, %edx
callq 0x8b8f0
movq 0x20(%rsp), %rdi
leaq 0xb3ab7(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
jmp 0x20824
jmp 0x20824
jmp 0x20824
leaq 0x8(%rsp), %rdi
callq 0x18a24
// File: /workspace/github_cpp_makefile_star2_O3/romkatv[P]hcproxy/src/event_loop.cc
// Function: hcproxy::EventLoop::Modify(hcproxy::EventHandler*, int)
void EventLoop::Modify(EventHandler* eh, int events) {
  CHECK(eh);
  CHECK(eh->event_loop_ == this);
  CHECK(std::this_thread::get_id() == loop_.get_id());
  epoll_.Modify(eh->fd_, events, eh);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
testq %rsi, %rsi
je 0x20874
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rdi, 0x28(%rsi)
jne 0x208c0
movl %edx, %ebp
callq 0x15490
cmpq 0x50(%r14), %rax
jne 0x20909
addq $0x8, %r14
movl 0x18(%rbx), %esi
movq %r14, %rdi
movl %ebp, %edx
movq %rbx, %rcx
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1dee0
leaq 0xafaad(%rip), %rsi     # 0xd0328
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x4d, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xafacc(%rip), %rsi     # 0xd0367
movl $0x2, %edx
callq 0x8b8f0
movq 0x18(%rsp), %rdi
leaq 0xb3a1a(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
jmp 0x20956
leaq 0xafa61(%rip), %rsi     # 0xd0328
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x4e, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xafac1(%rip), %rsi     # 0xd03a8
movl $0x17, %edx
callq 0x8b8f0
movq 0x18(%rsp), %rdi
leaq 0xb39ce(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
jmp 0x20956
leaq 0xafa18(%rip), %rsi     # 0xd0328
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x4f, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xafa4b(%rip), %rsi     # 0xd037b
movl $0x2c, %edx
callq 0x8b8f0
movq 0x18(%rsp), %rdi
leaq 0xb3985(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
jmp 0x20956
jmp 0x20956
jmp 0x20956
movq %rsp, %rdi
callq 0x18a24
// File: /workspace/github_cpp_makefile_star2_O3/romkatv[P]hcproxy/src/event_loop.cc
// Function: hcproxy::EventLoop::Refresh(hcproxy::EventHandler*)
void EventLoop::Refresh(EventHandler* eh) {
  CHECK(eh);
  CHECK(eh->event_loop_ == this);
  CHECK(std::this_thread::get_id() == loop_.get_id());
  eh->deadline_ = Clock::now() + timeout_;
  if (auto* tail = static_cast<EventHandler*>(expire_.tail())) {
    CHECK(eh->deadline_ >= tail->deadline_);
  }
  expire_.Erase(eh);
  expire_.AddTail(eh);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
testq %rsi, %rsi
je 0x20c3e
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rdi, 0x28(%rsi)
jne 0x20c8c
callq 0x15490
cmpq 0x50(%r14), %rax
jne 0x20cda
callq 0x2b360
addq 0x48(%r14), %rax
movq %rax, 0x20(%rbx)
movq 0x40(%r14), %rcx
testq %rcx, %rcx
je 0x20c19
cmpq 0x18(%rcx), %rax
jl 0x20d25
addq $0x38, %r14
addq $0x8, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1871a
movq %r14, %rdi
movq %rbx, %rsi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x184dc
leaq 0xaf6e3(%rip), %rsi     # 0xd0328
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl $0x83, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xaf700(%rip), %rsi     # 0xd0367
movl $0x2, %edx
callq 0x8b8f0
movq 0x20(%rsp), %rdi
leaq 0xb364e(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
jmp 0x20d76
leaq 0xaf695(%rip), %rsi     # 0xd0328
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl $0x84, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xaf6f3(%rip), %rsi     # 0xd03a8
movl $0x17, %edx
callq 0x8b8f0
movq 0x20(%rsp), %rdi
leaq 0xb3600(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
jmp 0x20d76
leaq 0xaf647(%rip), %rsi     # 0xd0328
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl $0x85, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xaf678(%rip), %rsi     # 0xd037b
movl $0x2c, %edx
callq 0x8b8f0
movq 0x20(%rsp), %rdi
leaq 0xb35b2(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
jmp 0x20d76
leaq 0xaf5fc(%rip), %rsi     # 0xd0328
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl $0x88, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xaf6cb(%rip), %rsi     # 0xd0419
movl $0x20, %edx
callq 0x8b8f0
movq 0x20(%rsp), %rdi
leaq 0xb3567(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
jmp 0x20d76
jmp 0x20d76
jmp 0x20d76
jmp 0x20d76
leaq 0x8(%rsp), %rdi
callq 0x18a24
// File: /workspace/github_cpp_makefile_star2_O3/hantaoyin[P]ffxiv-crafting-mcts/ffxiv-crafting-mcts.C
// Function: main
int main() {
  Driver driver;
  for (size_t count = 0; ; ++count) {
    driver.simulate();
    driver.train();
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2642
movq %rbx, %rdi
callq 0x2744
movq %rbx, %rdi
callq 0x3038
jmp 0x256a
movq %rax, %rbx
leaq 0x1b8(%rsp), %rdi
callq 0x7052
leaq 0x180(%rsp), %rdi
callq 0x52cc
leaq 0x18(%rsp), %r14
leaq 0x30(%rsp), %rdi
callq 0x38a0
movq %r14, %rdi
callq 0x38d0
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/hantaoyin[P]ffxiv-crafting-mcts/ffxiv-crafting-mcts.C
// Function: Driver::train()
void train() {
    bool track_simulation = simulate_count % 16 == 0;
    const size_t size = training_data.size();
    for (size_t i = 0; i < 100; ++i) {
      ++train_count;
      size_t id = size * random_real();
      auto& example = training_data[id];
      scn.train(std::get<0>(example), std::get<1>(example), std::get<2>(example), step_size, track_simulation && i == 0);
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %r12
movq 0x1d0(%rdi), %rax
andl $0xf, %r12d
movq 0x1f8(%rdi), %rcx
movq %rcx, %rdx
subq 0x1d8(%rdi), %rdx
sarq $0x3, %rdx
cmpq $0x1, %rcx
adcq $-0x1, %rdx
movq 0x1e0(%rdi), %rcx
subq 0x1e8(%rdi), %rcx
sarq $0x3, %rcx
movabsq $0xf83e0f83e0f83e1, %r13 # imm = 0xF83E0F83E0F83E1
imulq %r13, %rcx
addq %rdx, %rcx
subq 0x1c0(%rdi), %rax
sarq $0x3, %rax
imulq %r13, %rax
addq %rcx, %rax
movq %rax, %xmm0
punpckldq 0x503a(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x5042(%rip), %xmm0     # 0x8100
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
leaq 0x10(%rdi), %r14
xorl %ebp, %ebp
leaq 0xa434(%rip), %r15      # 0xd510
incq 0x8(%rbx)
movq %r15, %rdi
callq 0x3248
movsd 0xa430(%rip), %xmm1     # 0xd520
movsd 0xa420(%rip), %xmm2     # 0xd518
subsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
mulsd (%rsp), %xmm1
cvttsd2si %xmm1, %rsi
movq %rsi, %rcx
sarq $0x3f, %rcx
subsd 0x4f03(%rip), %xmm1     # 0x8020
cvttsd2si %xmm1, %rax
andq %rcx, %rax
movq 0x1c0(%rbx), %rdx
movq %rdx, %rcx
subq 0x1c8(%rbx), %rcx
orq %rsi, %rax
sarq $0x3, %rcx
imulq %r13, %rcx
addq %rax, %rcx
je 0x3153
movq 0x1d8(%rbx), %rax
movq (%rax,%rcx,8), %rdx
jmp 0x3161
movq %rax, %rcx
shlq $0x8, %rcx
leaq (%rcx,%rax,8), %rax
addq %rax, %rdx
leaq 0xf0(%rdx), %rsi
movsd (%rdx), %xmm0
addq $0x8, %rdx
xorl %ecx, %ecx
movq %rbp, %rax
orq %r12, %rax
sete %cl
movq %r14, %rdi
movsd 0x4ea2(%rip), %xmm1     # 0x8028
callq 0x6c02
incq %rbp
cmpq $0x64, %rbp
jne 0x30dc
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hantaoyin[P]ffxiv-crafting-mcts/ffxiv-crafting-mcts.C
// Function: mlp::AffineMap::backward_propagate(double)
void backward_propagate(double step_size) override final {
    for (size_t j = 0; j < x.size(); ++j) {
      x.D(j) = 0.0;
    }
    for (size_t i = 0; i < y.size(); ++i) {
      for (size_t j = 0; j < x.size(); ++j) {
        x.D(j) += y.D(i) * w[i * x.size() + j];
        w[i * x.size() + j] = w[i * x.size() + j] * (1. - 2. * weight_decay * step_size) - step_size * y.D(i) * x(j);
      }
      b[i] = b[i] * (1. - 2. * weight_decay * step_size) - step_size * y.D(i);
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq (%r14), %r15
movq 0x8(%r14), %r12
movq %r12, %r13
subq %r15, %r13
sarq $0x3, %r13
cmpq %r15, %r12
je 0x42ae
movq 0x18(%r14), %rdi
cmpq $0x1, %r13
movq %r13, %rdx
adcq $0x0, %rdx
shlq $0x3, %rdx
xorl %esi, %esi
movsd %xmm0, 0x8(%rsp)
callq 0x20a0
movsd 0x8(%rsp), %xmm0
movq 0x10(%rbx), %rsi
movq 0x8(%rsi), %rax
subq (%rsi), %rax
je 0x4376
sarq $0x3, %rax
movq 0x18(%rbx), %rcx
movq 0x30(%rbx), %rdx
movsd 0x3d7d(%rip), %xmm3     # 0x8050
mulsd %xmm0, %xmm3
addsd 0x3d59(%rip), %xmm3     # 0x8038
movq 0x18(%rsi), %rsi
cmpq $0x1, %r13
movq %r13, %rdi
adcq $0x0, %rdi
cmpq $0x1, %rax
adcq $0x0, %rax
shlq $0x3, %r13
xorl %r8d, %r8d
cmpq %r15, %r12
je 0x434d
movq 0x18(%r14), %r9
xorl %r10d, %r10d
movsd (%rsi,%r8,8), %xmm1
mulsd (%rcx,%r10,8), %xmm1
addsd (%r9,%r10,8), %xmm1
movsd %xmm1, (%r9,%r10,8)
movsd (%rsi,%r8,8), %xmm1
mulsd %xmm0, %xmm1
mulsd (%r15,%r10,8), %xmm1
movsd (%rcx,%r10,8), %xmm2
mulsd %xmm3, %xmm2
subsd %xmm1, %xmm2
movsd %xmm2, (%rcx,%r10,8)
incq %r10
cmpq %r10, %rdi
jne 0x4309
movsd (%rsi,%r8,8), %xmm1
mulsd %xmm0, %xmm1
movsd (%rdx,%r8,8), %xmm2
mulsd %xmm3, %xmm2
subsd %xmm1, %xmm2
movsd %xmm2, (%rdx,%r8,8)
incq %r8
addq %r13, %rcx
cmpq %rax, %r8
jne 0x42fd
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/hantaoyin[P]ffxiv-crafting-mcts/ffxiv-crafting-mcts.C
// Function: mlp::SoftMaxAndSigmoid::forward()
void forward(void) override final {
    // SoftMax
    double xmax = x(0);
    for (size_t i = 1; i < size; ++i) {
      xmax = std::max(xmax, x(i));
    }
    ASSERT(std::fabs(xmax) < 1.e100) << xmax;

    double sum = 0.;
    for (size_t i = 0; i < size; ++i) {
      y(i) = std::exp(x(i) - xmax);
      sum += y(i);
    }
    ASSERT(sum >= 1.0 && sum <= 1.01 * size) << sum;

    sum = 1.0 / sum;
    for (size_t i = 0; i < size; ++i) {
      y(i) *= sum;
    }

    // Sigmoid
    y(size) = 1. / (1. + std::exp(bias - x(size)));
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
movq 0x18(%rdi), %rax
movq (%rcx), %rcx
movsd (%rcx), %xmm1
cmpq $0x2, %rax
jb 0x46ff
movl $0x1, %edx
movapd %xmm1, %xmm0
movsd (%rcx,%rdx,8), %xmm1
maxsd %xmm0, %xmm1
incq %rdx
movapd %xmm1, %xmm0
cmpq %rdx, %rax
jne 0x46e8
jmp 0x4708
testq %rax, %rax
je 0x478c
xorpd %xmm2, %xmm2
xorl %r14d, %r14d
movsd %xmm1, 0x8(%rsp)
movsd %xmm2, 0x10(%rsp)
movq 0x8(%rbx), %rax
movq (%rax), %rax
movsd (%rax,%r14,8), %xmm0
subsd %xmm1, %xmm0
callq 0x22a0
movsd 0x10(%rsp), %xmm2
movsd 0x8(%rsp), %xmm1
movq 0x10(%rbx), %rax
movq (%rax), %rax
movsd %xmm0, (%rax,%r14,8)
addsd %xmm0, %xmm2
incq %r14
movq 0x18(%rbx), %rax
cmpq %rax, %r14
jb 0x4715
testq %rax, %rax
je 0x478c
movsd 0x38d1(%rip), %xmm0     # 0x8038
divsd %xmm2, %xmm0
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x4774
jmp 0x478e
xorl %eax, %eax
movq 0x8(%rbx), %rcx
movq (%rcx), %rcx
movsd 0x38bb(%rip), %xmm0     # 0x8058
subsd (%rcx,%rax,8), %xmm0
callq 0x22a0
movsd 0x3889(%rip), %xmm1     # 0x8038
addsd %xmm1, %xmm0
divsd %xmm0, %xmm1
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rax), %rax
movsd %xmm1, (%rax,%rcx,8)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hantaoyin[P]ffxiv-crafting-mcts/ffxiv-crafting-mcts.C
// Function: mlp::SoftMaxAndSigmoid::backward_propagate(double)
void backward_propagate(double) override final {
    // SoftMax
    double sum = 0.;
    for (size_t i = 0; i < size; ++i) {
      x.D(i) = y(i) * y.D(i);
      sum += x.D(i);
    }
    for (size_t i = 0; i < size; ++i) {
      x.D(i) -= y(i) * sum;
    }

    // Sigmoid
    x.D(size) = y.D(size) * y(size) * (1. - y(size));
  }

// Assembly:
movq 0x10(%rdi), %rdx
movq 0x18(%rdi), %rax
movq (%rdx), %rcx
testq %rax, %rax
je 0x4843
movq 0x18(%rdx), %rdx
movq 0x8(%rdi), %rsi
movq 0x18(%rsi), %rsi
xorpd %xmm0, %xmm0
xorl %r8d, %r8d
movsd (%rcx,%r8,8), %xmm1
mulsd (%rdx,%r8,8), %xmm1
movsd %xmm1, (%rsi,%r8,8)
addsd %xmm1, %xmm0
incq %r8
cmpq %r8, %rax
jne 0x47f3
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdx
movq (%rdx), %rcx
movq 0x18(%rsi), %rsi
xorl %edi, %edi
movsd (%rsi,%rdi,8), %xmm1
movsd (%rcx,%rdi,8), %xmm2
mulsd %xmm0, %xmm2
subsd %xmm2, %xmm1
movsd %xmm1, (%rsi,%rdi,8)
incq %rdi
cmpq %rdi, %rax
jne 0x4822
jmp 0x484b
movq 0x8(%rdi), %rsi
movq 0x18(%rsi), %rsi
movq 0x18(%rdx), %rdx
movsd (%rcx,%rax,8), %xmm0
movsd (%rdx,%rax,8), %xmm1
mulsd %xmm0, %xmm1
movsd 0x37d3(%rip), %xmm2     # 0x8038
subsd %xmm0, %xmm2
mulsd %xmm1, %xmm2
movsd %xmm2, (%rsi,%rax,8)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hantaoyin[P]ffxiv-crafting-mcts/ffxiv-crafting-mcts.C
// Function: UCT::initState(State const&)
double initState(const State& s) {
    ASSERT(all_states.find(s) == all_states.end()) << s.DebugString();

    StateStatistics stat;
    const mlp::Edge& edge = scn.forward(s);
    const std::array<double, TotalActionCount>& noise = dir.gen();
    const double eps = 0.25;
    for (size_t ac_id = 0; ac_id < TotalActionCount; ++ac_id) {
      Action ac = static_cast<Action>(ac_id);
      stat.prior(ac) = edge(ac_id) * (1. - eps) + eps * noise[ac_id];
      stat.count(ac) = 0;
      stat.value(ac) = 0.;
      if (!s.CanExecuteAction(ac)) {
        stat.setValid(ac, false);
      }
    }
    all_states.emplace(s, stat);
    return edge(TotalActionCount);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2c8, %rsp            # imm = 0x2C8
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r12
xorl %r15d, %r15d
movl $0x2c0, %edx            # imm = 0x2C0
movq %r12, %rdi
xorl %esi, %esi
callq 0x20a0
movq $0x1fffffff, 0x2c0(%r12) # imm = 0x1FFFFFFF
movq 0x130(%r14), %rdi
movq %rbx, %rsi
callq 0x49bc
movq %rax, %r12
movq %r14, %rdi
callq 0x4a26
movq %rax, %r13
leaq 0x10(%rsp), %rbp
movq (%r12), %rax
movsd (%r13,%r15,8), %xmm0
mulsd 0x3773(%rip), %xmm0     # 0x8060
movsd (%rax,%r15,8), %xmm1
mulsd 0x370d(%rip), %xmm1     # 0x8008
addsd %xmm0, %xmm1
movsd %xmm1, (%rbp)
xorpd %xmm0, %xmm0
movupd %xmm0, -0x10(%rbp)
movzbl %r15b, %esi
movq %rbx, %rdi
callq 0x4aa6
testb %al, %al
jne 0x4932
movq $-0x2, %rax
movl %r15d, %ecx
rolq %cl, %rax
andq %rax, 0x2c0(%rsp)
incq %r15
addq $0x18, %rbp
cmpq $0x1d, %r15
jne 0x48da
addq $0x138, %r14            # imm = 0x138
movq %rsp, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4e02
movq (%r12), %rax
movsd 0xe8(%rax), %xmm0
addq $0x2c8, %rsp            # imm = 0x2C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/hantaoyin[P]ffxiv-crafting-mcts/ffxiv-crafting-mcts.C
// Function: State::CanExecuteAction(Action) const
bool IsActionSupported(Action ac) const {
    switch (ac) {
    case Action::Reuse:
      return false;
    default:
      return true;
    }
  }

// Assembly:
cmpl $0x18, %esi
je 0x4aec
movswl (%rdi), %eax
movzbl %sil, %ecx
movl %ecx, %edx
shll $0x4, %edx
leaq 0x702a(%rip), %rsi      # 0xbae8
movsbl 0x8(%rdx,%rsi), %edx
addl %eax, %edx
js 0x4aec
movb $0x1, %al
addl $-0x2, %ecx
cmpl $0x18, %ecx
ja 0x4aeb
leaq 0x36b0(%rip), %rdx      # 0x8188
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movb 0x9(%rdi), %al
decb %al
cmpb $0x2, %al
setb %al
retq
xorl %eax, %eax
retq
cmpb $0x0, 0xa(%rdi)
setne %al
retq
cmpb $0x0, 0x8(%rdi)
jmp 0x4b15
cmpb $0x2, 0x8(%rdi)
setae %al
retq
cmpb $0x0, 0x12(%rdi)
jmp 0x4b15
cmpb $0x0, 0xf(%rdi)
jmp 0x4b15
cmpb $0x0, 0xc(%rdi)
sete %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hantaoyin[P]ffxiv-crafting-mcts/ffxiv-crafting-mcts.C
// Function: UCT::select(State const&, double)
Action select(const State& s, double inv_temp) {
    ASSERT(all_states.find(s) != all_states.end()) << s.DebugString();
    std::array<double, TotalActionCount> p;

    double sum = 0.;
    StateStatistics& stat = all_states.at(s);
    for (size_t ac_id = 0; ac_id < TotalActionCount; ++ac_id) {
      Action ac = static_cast<Action>(ac_id);
      if (stat.valid(ac)) {
        p[ac_id] = std::pow(stat.count(ac), inv_temp);
        sum += p[ac_id];
      } else {
        p[ac_id] = 0.;
      }
    }
    if (sum == 0.) {
      return Action::NumActions; // Resign.
    }
    double r = random_real() * sum;
    for (size_t ac_id = 0; ac_id < TotalActionCount; ++ac_id) {
      Action ac = static_cast<Action>(ac_id);
      if (!stat.valid(ac)) continue;
      r -= p[ac_id];
      if (r < 0.) {
        return ac;
      }
    }
    ASSERT(false) << s.DebugString() << " " << stat.DebugString();
    return Action::NumActions;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xf8, %rsp
movsd %xmm0, 0x8(%rsp)
addq $0x138, %rdi            # imm = 0x138
callq 0x67b4
testq %rax, %rax
je 0x5c00
movq %rax, %rbx
movq %rax, %r14
addq $0x28, %r14
xorpd %xmm1, %xmm1
xorl %r15d, %r15d
movq 0x2e0(%rbx), %rax
btq %r15, %rax
jae 0x5b5d
movsd %xmm1, (%rsp)
movsd (%r14), %xmm1
unpcklps 0x25bd(%rip), %xmm1     # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x25c5(%rip), %xmm1     # 0x8100
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x2280
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
jmp 0x5b61
xorpd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp,%r15,8)
incq %r15
addq $0x18, %r14
cmpq $0x1d, %r15
jne 0x5b15
movb $0x1d, %bpl
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x5b84
jnp 0x5bf0
leaq 0x7985(%rip), %rdi      # 0xd510
movsd %xmm1, (%rsp)
callq 0x3248
movsd 0x7983(%rip), %xmm1     # 0xd520
movsd 0x7973(%rip), %xmm2     # 0xd518
subsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
xorpd %xmm2, %xmm2
movsd (%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
movq 0x2e0(%rbx), %rcx
xorl %eax, %eax
btq %rax, %rcx
jae 0x5be3
subsd 0x10(%rsp,%rax,8), %xmm0
ucomisd %xmm0, %xmm2
ja 0x5bee
incq %rax
cmpq $0x1d, %rax
jne 0x5bd1
jmp 0x5bf0
movl %eax, %ebp
movl %ebp, %eax
addq $0xf8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x29cc(%rip), %rdi      # 0x85d3
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O3/hantaoyin[P]ffxiv-crafting-mcts/ffxiv-crafting-mcts.C
// Function: State::ExecuteAction(Action)
bool ExecuteAction(Action ac) {
    const short percentage = SuccessPercentage(ac);
    const bool is_action_successful = percentage >= 100 ? true : random_real() * 100 < percentage;
    Condition next_condition = RandomlyGenNextCondition(condition);
    return DeterministicExecuteAction(ac, is_action_successful, next_condition);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzbl %sil, %ebp
andb $-0x2, %sil
movb $0x1, %r14b
cmpb $0x6, %sil
jne 0x6073
cmpb $0x0, 0x11(%rbx)
jne 0x60cf
movl %ebp, %eax
shll $0x4, %eax
leaq 0x5a69(%rip), %rcx      # 0xbae8
movzwl 0xa(%rax,%rcx), %r15d
cmpw $0x63, %r15w
jg 0x60cf
leaq 0x747d(%rip), %rdi      # 0xd510
callq 0x3248
movsd 0x7480(%rip), %xmm1     # 0xd520
movsd 0x7470(%rip), %xmm2     # 0xd518
subsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
mulsd 0x1fe4(%rip), %xmm1     # 0x80a0
movswl %r15w, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
ucomisd %xmm1, %xmm0
seta %r14b
movzbl 0x9(%rbx), %edi
callq 0x24fc
movzbl %r14b, %edx
movzbl %al, %ecx
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x67ee
nop
// File: /workspace/github_cpp_makefile_star2_O3/hantaoyin[P]ffxiv-crafting-mcts/ffxiv-crafting-mcts.C
// Function: UCT::set_target_probability(State const&, double, std::array<double, 29ul>&)
void set_target_probability(const State& s, double inv_temp,
                              std::array<double, TotalActionCount>& p) {
    ASSERT(!s.done()) << s.DebugString();
    ASSERT(all_states.find(s) != all_states.end()) << s.DebugString();
    StateStatistics& stat = all_states.at(s);
    ASSERT(stat.total_count > 0) << s.DebugString() << " " << stat.DebugString();
    double sum = 0.;
    for (size_t ac_id = 0; ac_id < TotalActionCount; ++ac_id) {
      Action ac = static_cast<Action>(ac_id);
      if (stat.valid(ac) && stat.count(ac) > 0) {
        p[ac_id] = std::pow((double)stat.count(ac), inv_temp);
      } else {
        p[ac_id] = 0.1;
      }
      sum += p[ac_id];
    }
    ASSERT(sum >= 1) << s.DebugString() << " " << stat.DebugString();
    sum = 1. / sum;
    for (size_t ac_id = 0; ac_id < TotalActionCount; ++ac_id) {
      p[ac_id] *= sum;
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movsd %xmm0, 0x8(%rsp)
addq $0x138, %rdi            # imm = 0x138
callq 0x67b4
testq %rax, %rax
je 0x61db
movq %rax, %r14
movq %rax, %r15
addq $0x28, %r15
xorpd %xmm1, %xmm1
xorl %r12d, %r12d
movsd 0x1f72(%rip), %xmm2     # 0x80a8
movq 0x2e0(%r14), %rax
btq %r12, %rax
movapd %xmm2, %xmm0
jae 0x6193
movq (%r15), %rax
movapd %xmm2, %xmm0
testq %rax, %rax
je 0x6193
movsd %xmm1, 0x10(%rsp)
movq %rax, %xmm1
punpckldq 0x1f8a(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x1f92(%rip), %xmm1     # 0x8100
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x2280
movsd 0x1f1b(%rip), %xmm2     # 0x80a8
movsd 0x10(%rsp), %xmm1
movsd %xmm0, (%rbx,%r12,8)
addsd %xmm0, %xmm1
incq %r12
addq $0x18, %r15
cmpq $0x1d, %r12
jne 0x6136
movsd 0x1e86(%rip), %xmm0     # 0x8038
divsd %xmm1, %xmm0
xorl %eax, %eax
movsd (%rbx,%rax,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%rax,8)
incq %rax
cmpq $0x1d, %rax
jne 0x61b8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x23f1(%rip), %rdi      # 0x85d3
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/hantaoyin[P]ffxiv-crafting-mcts/ffxiv-crafting-mcts.C
// Function: State::DeterministicExecuteAction(Action, bool, Condition)
bool DeterministicExecuteAction(Action ac, bool is_action_successful, Condition next_condition) {
    Check();
    ASSERT(!done()) << DebugString();
    ASSERT(SuccessPercentage(ac) < 100 || is_action_successful)
      << "Action can not fail: " << ALL_ACTIONS[Action2ID(ac)].name;
    ASSERT(CheckConditionTransition(next_condition))
      << "Impossible condition transition: " << DebugString() << " " << static_cast<unsigned>(next_condition);
    if (CanExecuteAction(ac)) {
      // Apply any effect in cp, durability, progress, quality, and inner quiet stack.  Change in cp
      // and durability is always carried out, while others only when the action is successful.
      ApplyCPDurabilityChange(ac);
      if (is_action_successful) {
        ApplyProgressChange(ac);
        ApplyQualityChange(ac);
      }
      ApplyInnerQuietChange(ac, is_action_successful);
      ApplyPersistentBuffEffect(ac);
      if (is_action_successful) {
        ApplyBuffChange(ac);
      }
      condition = next_condition;
      return true;
    } else {
      return false;
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %r13d
movl %esi, %r15d
movq %rdi, %r14
callq 0x4aa6
movl %eax, %ebp
testb %al, %al
je 0x6910
movzbl %r15b, %r12d
movq %r14, %rdi
movl %r12d, %esi
callq 0x6922
testb %r13b, %r13b
je 0x689c
movq %r14, %rdi
movl %r12d, %esi
callq 0x6982
movq %r14, %rdi
movl %r12d, %esi
callq 0x69e8
movq %r14, %rdi
movl %r12d, %esi
movl $0x1, %edx
callq 0x6b24
cmpb $0xe, %r15b
je 0x6873
cmpb $0x0, 0xd(%r14)
je 0x6873
movzwl 0x6(%r14), %eax
addl $0x5, %eax
cmpw $0x46, %ax
movl $0x46, %ecx
cmovll %eax, %ecx
movw %cx, 0x6(%r14)
movl $0xa, %eax
movb (%r14,%rax), %cl
testb %cl, %cl
je 0x6886
decb %cl
movb %cl, (%r14,%rax)
incq %rax
cmpq $0x13, %rax
jne 0x6878
movq %r14, %rdi
movl %r12d, %esi
callq 0x6b8e
jmp 0x690c
movzbl 0x8(%r14), %eax
testw %ax, %ax
je 0x68b5
cmpb $0x12, %r15b
jne 0x68cb
movzwl %ax, %eax
incl %eax
shrl %eax
jmp 0x68c7
cmpb $0xb, %r15b
je 0x68c5
cmpl $0x17, %r12d
jne 0x68cb
movb $0x3, %al
jmp 0x68c7
movb $0x1, %al
movb %al, 0x8(%r14)
cmpb $0xe, %r15b
je 0x68f1
cmpb $0x0, 0xd(%r14)
je 0x68f1
movzwl 0x6(%r14), %eax
addl $0x5, %eax
cmpw $0x46, %ax
movl $0x46, %ecx
cmovll %eax, %ecx
movw %cx, 0x6(%r14)
xorl %eax, %eax
movb 0xa(%r14,%rax), %cl
testb %cl, %cl
je 0x6903
decb %cl
movb %cl, 0xa(%r14,%rax)
incq %rax
cmpq $0x9, %rax
jne 0x68f3
movb %bl, 0x9(%r14)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hantaoyin[P]ffxiv-crafting-mcts/ffxiv-crafting-mcts.C
// Function: State::ApplyInnerQuietChange(Action, bool)
void ApplyInnerQuietChange(Action ac, bool is_action_successful) {
    if (inner_quiet > 0) {
      if (is_action_successful) {
        switch (ac) {
        case Action::BasicTouch:
        case Action::DelicateSynthesis:
        case Action::FocusedTouch:
        case Action::HastyTouch:
        case Action::PrudentTouch:
        case Action::StandardTouch:
          inner_quiet += 1;
          break;
        case Action::PreparatoryTouch:
        case Action::PreciseTouch:
          inner_quiet += 2;
          break;
        case Action::ByregotsBlessing:
          inner_quiet = 0;
          break;
        case Action::PatientTouch:
          inner_quiet *= 2;
          break;
        case Action::InnerQuiet:
          ASSERT(false) << DebugString();
          break;
        default:
          break;
        }
        if (inner_quiet > 11) {
          inner_quiet = 11;
        }
      } else if (ac == Action::PatientTouch) {
        inner_quiet = (inner_quiet + 1) / 2;
      }
    } else if (ac == Action::InnerQuiet) {
      inner_quiet = 1;
    } else if (ac == Action::Reflect) {
      inner_quiet = 3;
    }
  }

// Assembly:
movzbl 0x8(%rdi), %eax
testw %ax, %ax
je 0x6b50
testb %dl, %dl
je 0x6b63
movzbl %sil, %ecx
decl %ecx
cmpl $0x18, %ecx
ja 0x6b83
leaq 0x16a9(%rip), %rdx      # 0x81ec
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
incb %al
jmp 0x6b80
cmpb $0xb, %sil
je 0x6b72
movzbl %sil, %eax
cmpl $0x17, %eax
jne 0x6b8c
movb $0x3, %cl
jmp 0x6b89
cmpb $0x12, %sil
jne 0x6b8c
movzwl %ax, %ecx
incl %ecx
shrl %ecx
jmp 0x6b89
movb $0x1, %cl
jmp 0x6b89
addb $0x2, %al
jmp 0x6b80
xorl %ecx, %ecx
jmp 0x6b89
addb %al, %al
movb %al, 0x8(%rdi)
movb $0xb, %cl
cmpb $0xb, %al
jbe 0x6b8c
movb %cl, 0x8(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ef-gy[P]libefgy/src/test-case/matrix.cpp
// Function: testConstruction(std::ostream&)
bool testConstruction(std::ostream &log) {
  matrix<int, 3, 4> m;
  for (int i = 0; i < 3; i++) {
    for (int k = 0; k < 4; k++) {
      m[i][k] = i * k;
    }
  }

  matrix<int, 3, 4> m2(m);

  bool allCorrect = true;
  for (int i = 0; i < 3; i++) {
    for (int k = 0; k < 4; k++) {
      allCorrect &= (m2[i][k] == (i * k));
    }
  }

  if (!allCorrect) {
    log << "Actual and expected value in result of copy constructor are "
           "different";
    return false;
  }
  return true;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rsp, %rax
xorl %ecx, %ecx
xorl %edx, %edx
xorl %esi, %esi
movl %edx, (%rax,%rsi,4)
incq %rsi
addl %ecx, %edx
cmpq $0x4, %rsi
jne 0x4d3c
incq %rcx
addq $0x10, %rax
cmpq $0x3, %rcx
jne 0x4d38
movb $0x1, %bl
movq %rsp, %rax
xorl %ecx, %ecx
xorl %edx, %edx
xorl %esi, %esi
movl (%rax,%rsi,4), %r8d
cmpq %r8, %rdx
sete %r8b
andb %r8b, %bl
incq %rsi
addq %rcx, %rdx
cmpq $0x4, %rsi
jne 0x4d62
incq %rcx
addq $0x10, %rax
cmpq $0x3, %rcx
jne 0x4d5e
testb %bl, %bl
jne 0x4d9e
leaq 0xf396(%rip), %rsi      # 0x1412a
movl $0x45, %edx
callq 0x42d0
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/ef-gy[P]libefgy/src/test-case/matrix.cpp
// Function: testAssignment(std::ostream&)
bool testAssignment(std::ostream &log) {
  matrix<int, 3, 4> m;
  for (int i = 0; i < 3; i++) {
    for (int k = 0; k < 4; k++) {
      m[i][k] = i * k;
    }
  }

  matrix<int, 3, 4> m2 = m;

  bool allCorrect = true;
  for (int i = 0; i < 3; i++) {
    for (int k = 0; k < 3; k++) {
      allCorrect &= (m2[i][k] == m[i][k]);
    }
  }

  if (!allCorrect) {
    log << "Values were not copied correctly during assignment.";
    return false;
  }

  return true;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rsp, %rax
xorl %ecx, %ecx
xorl %edx, %edx
xorl %esi, %esi
movl %edx, (%rax,%rsi,4)
incq %rsi
addl %ecx, %edx
cmpq $0x4, %rsi
jne 0x4db4
incq %rcx
addq $0x10, %rax
cmpq $0x3, %rcx
jne 0x4db0
movb $0x1, %bl
movq %rsp, %rax
xorl %ecx, %ecx
xorl %edx, %edx
incq %rdx
cmpq $0x3, %rdx
jne 0x4dd8
incq %rcx
addq $0x10, %rax
cmpq $0x3, %rcx
jne 0x4dd6
testb $0x1, %bl
jne 0x4e04
leaq 0xf376(%rip), %rsi      # 0x14170
movl $0x33, %edx
callq 0x42d0
andb $0x1, %bl
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/ef-gy[P]libefgy/src/test-case/matrix.cpp
// Function: testIterator(std::ostream&)
bool testIterator(std::ostream &log) {
  matrix<int, 3, 4> m;
  int j = 0;
  for (int i = 0; i < 3; i++) {
    for (int k = 0; k < 4; k++) {
      m[i][k] = j++;
    }
  }

  auto r = range<int>(0, 3 * 4, false);

  if (!std::equal(m.begin(), m.end(), r.begin())) {
    log << "matrix iterator and range iterator did not produce the same "
           "sequence:\n";
    for (auto i : m) {
      log << "\t" << i;
    }
    log << "\nvs. expected:\n";
    for (auto i : r) {
      log << "\t" << i;
    }
    log << "\n";
    return false;
  }

  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movdqa 0xebed(%rip), %xmm0     # 0x14010
movd %eax, %xmm1
pshufd $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
por %xmm0, %xmm1
movdqu %xmm1, 0x8(%rsp,%rax,4)
addq $0x4, %rax
cmpq $0xc, %rax
jne 0x5423
xorl %eax, %eax
movl %eax, %r12d
movl %eax, %ecx
andl $0x3, %ecx
movq %rax, %rdx
andq $-0x4, %rdx
leaq (%rsp,%rdx,4), %rdx
addq $0x8, %rdx
movl (%rdx,%rcx,4), %r13d
cmpl %r13d, %eax
jne 0x5470
incq %rax
cmpq $0xc, %rax
jne 0x5442
jmp 0x551f
leaq 0xeeae(%rip), %rsi      # 0x14325
movl $0x46, %edx
movq %rbx, %rdi
callq 0x42d0
xorl %r15d, %r15d
leaq 0xeede(%rip), %r14      # 0x1436c
movl %r15d, %eax
andl $0x3, %eax
movq %r15, %rcx
andq $-0x4, %rcx
leaq (%rsp,%rcx,4), %rcx
addq $0x8, %rcx
movl (%rcx,%rax,4), %ebp
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42d0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x43f0
incq %r15
cmpq $0xc, %r15
jne 0x548e
leaq 0xee9e(%rip), %rsi      # 0x1436e
movl $0xf, %edx
movq %rbx, %rdi
callq 0x42d0
xorl %r14d, %r14d
leaq 0xee85(%rip), %r15      # 0x1436c
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x42d0
movq %rbx, %rdi
movl %r14d, %esi
callq 0x43f0
incq %r14
cmpq $0xc, %r14
jne 0x54e7
leaq 0xeda9(%rip), %rsi      # 0x142bb
movl $0x1, %edx
movq %rbx, %rdi
callq 0x42d0
cmpl %r13d, %r12d
sete %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq