LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/romkatv[P]hcproxy/src/thread_pool.cc
// Function: hcproxy::ThreadPool::~ThreadPool()
ThreadPool::~ThreadPool() {
  {
    std::lock_guard<std::mutex> lock(mutex_);
    exit_ = true;
  }
  cv_.notify_all();
  sleeper_cv_.notify_one();
  for (std::thread& t : threads_) t.join();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %r14, %rdi
callq 0x15820
testl %eax, %eax
jne 0x1c333
movb $0x1, 0x8(%rbx)
movq %r14, %rdi
callq 0x158d0
leaq 0x38(%rbx), %r14
movq %r14, %rdi
callq 0x2e7c0
leaq 0x68(%rbx), %r15
movq %r15, %rdi
callq 0x2e7b0
movq 0xb8(%rbx), %r12
movq 0xc0(%rbx), %r13
cmpq %r13, %r12
je 0x1c2ff
movq %r12, %rdi
callq 0x9ed20
addq $0x8, %r12
jmp 0x1c2ec
leaq 0xb8(%rbx), %rdi
callq 0x1c75c
addq $0x98, %rbx
movq %rbx, %rdi
callq 0x1c798
movq %r15, %rdi
callq 0x2e780
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2e780
movl %eax, %edi
callq 0x173c7
jmp 0x1c33c
movq %rax, %rdi
callq 0x18abd
// File: /workspace/github_cpp_makefile_star2_O1/romkatv[P]hcproxy/src/thread_pool.cc
// Function: hcproxy::ThreadPool::Schedule(std::chrono::time_point<std::chrono::_V2::steady_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>>, std::function<void ()>)
void ThreadPool::Schedule(Time t, std::function<void()> f) {
  std::condition_variable* wake = nullptr;
  {
    std::unique_lock<std::mutex> lock(mutex_);
    work_.push(Work{std::move(t), ++last_idx_, std::move(f)});
    if (work_.top().idx == last_idx_) wake = have_sleeper_ ? &sleeper_cv_ : &cv_;
  }
  if (wake) wake->notify_one();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rsp, %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x1b5f0
movb $0x1, 0x8(%r14)
leaq 0x98(%rbx), %rdi
leaq 0x20(%rsp), %r14
movq %r12, -0x10(%r14)
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
movq %rax, -0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x18(%r15), %rax
movq %rax, 0x18(%r14)
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x1c3c7
movups (%r15), %xmm1
addq $0x10, %r15
movups %xmm1, (%r14)
movq %rax, 0x30(%rsp)
movups %xmm0, (%r15)
leaq 0x10(%rsp), %rsi
callq 0x1ceb4
movq 0x98(%rbx), %rdi
movq 0xa0(%rbx), %rsi
callq 0x1cd7d
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1c3fb
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
movq 0x98(%rbx), %rax
movq 0x8(%rax), %r14
movq (%rbx), %r15
movb 0x9(%rbx), %bpl
movq %rsp, %rdi
callq 0x1b5da
cmpq %r15, %r14
jne 0x1c432
leaq 0x38(%rbx), %rax
addq $0x68, %rbx
testb $0x1, %bpl
cmoveq %rax, %rbx
movq %rbx, %rdi
callq 0x2e7b0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1c46b
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1c45b
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
movq %rsp, %rdi
callq 0x1b5da
movq %rbx, %rdi
callq 0xcc900
movq %rax, %rdi
callq 0x18abd
nop
// File: /workspace/github_cpp_makefile_star2_O1/romkatv[P]hcproxy/src/hcproxy.cc
// Function: main
int main(int argc, char* argv[]) {
  if (argc != 1) {
    std::cerr << "Usage: " << argv[0] << "\n\n"
              << "To customize, modify `opt` in `main()` (defined in " << __FILE__ << ")"
              << " and recompile." << std::endl;
    return 1;
  }
  hcproxy::Options opt;
  hcproxy::RunProxy(opt);
  LOG(FATAL) << "RunProxy is not supposed to return";
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xc8, %rsp
cmpl $0x1, %edi
je 0x1d24b
movq %rsi, %r14
leaq 0xf52df(%rip), %rbx     # 0x112440
leaq 0xb2af2(%rip), %rsi     # 0xcfc5a
movl $0x7, %edx
movq %rbx, %rdi
callq 0x8bab0
movq (%r14), %r14
testq %r14, %r14
je 0x1d199
movq %r14, %rdi
callq 0x153a0
leaq 0xf52b4(%rip), %rdi     # 0x112440
movq %r14, %rsi
movq %rax, %rdx
callq 0x8bab0
jmp 0x1d1b0
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x6c930
leaq 0xb2aab(%rip), %rsi     # 0xcfc62
movl $0x2, %edx
movq %rbx, %rdi
callq 0x8bab0
leaq 0xb2a9a(%rip), %rsi     # 0xcfc65
movl $0x33, %edx
movq %rbx, %rdi
callq 0x8bab0
leaq 0xb2aba(%rip), %rsi     # 0xcfc99
movl $0xe, %edx
movq %rbx, %rdi
callq 0x8bab0
leaq 0xb322c(%rip), %rsi     # 0xd041f
movl $0x1, %edx
movq %rbx, %rdi
callq 0x8bab0
leaq 0xb2aa1(%rip), %rsi     # 0xcfca8
movl $0xf, %edx
movq %rbx, %rdi
callq 0x8bab0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6cc00
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8b5b0
movq %rax, %rdi
callq 0x8ab80
movl $0x1, %eax
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movl $0x2e302e30, (%rax)     # imm = 0x2E302E30
movl $0x302e302e, 0x3(%rax)  # imm = 0x302E302E
movq $0x7, -0x8(%rax)
movb $0x0, 0x7(%rax)
movw $0x22b9, 0x10(%rax)     # imm = 0x22B9
movq $0x40, 0x18(%rax)
movq $0x400, 0x20(%rax)      # imm = 0x400
movabsq $0x12a05f200, %rcx      # imm = 0x12A05F200
movq %rcx, 0x28(%rax)
movq $0x8, 0x30(%rax)
movabsq $0x45d964b800, %rcx     # imm = 0x45D964B800
movq %rcx, 0x38(%rax)
movabsq $0x1176592e00, %rcx     # imm = 0x1176592E00
movq %rcx, 0x40(%rax)
movabsq $0x34630b8a000, %rcx    # imm = 0x34630B8A000
movq %rcx, 0x48(%rax)
movabsq $0x2540be400, %rcx      # imm = 0x2540BE400
movq %rcx, 0x50(%rax)
movq $0x1000, 0x58(%rax)     # imm = 0x1000
movq $0x2000, 0x60(%rax)     # imm = 0x2000
movabsq $0x8bb2c97000, %rcx     # imm = 0x8BB2C97000
movq %rcx, 0x68(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rax)
movups %xmm0, 0x80(%rax)
movups %xmm0, 0x90(%rax)
xorl %ecx, %ecx
movq %rcx, 0xa0(%rax)
leaq 0xb8(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movq %rcx, 0x8(%rax)
movups %xmm0, -0x8(%rax)
leaq 0x8(%rsp), %rdi
callq 0x1d353
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1d62c
movq %rbx, %rdi
callq 0xcc900
// File: /workspace/github_cpp_makefile_star2_O1/romkatv[P]hcproxy/src/epoll.cc
// Function: hcproxy::EPoll::Add(int, int, void*)
void EPoll::Add(int fd, int events, void* data) {
  epoll_event event = {};
  event.events = events;
  event.data.ptr = data;
  CHECK(epoll_ctl(epoll_, EPOLL_CTL_ADD, fd, &event) == 0) << Errno();
  ++total_events_;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movl %esi, %eax
movq %rdi, %rbx
leaq 0x20(%rsp), %r8
movq $0x0, (%r8)
movl $0x0, 0x8(%r8)
movl %edx, (%r8)
movq %rcx, 0x4(%r8)
movl (%rdi), %edi
movl $0x1, %esi
movl %eax, %edx
movq %r8, %rcx
callq 0x154e0
testl %eax, %eax
jne 0x1df2e
incq 0x20(%rbx)
addq $0x30, %rsp
popq %rbx
retq
leaq 0xb1e04(%rip), %rsi     # 0xcfd39
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x23, %edx
movl $0x3, %ecx
callq 0x2019c
movq 0x18(%rbx), %rdi
leaq 0xb1e25(%rip), %rsi     # 0xcfd7a
movl $0x31, %edx
callq 0x8bab0
movq 0x18(%rsp), %rdi
leaq 0xb63a0(%rip), %rsi     # 0xd430b
movl $0x2, %edx
callq 0x8bab0
movl (%rsp), %esi
movq 0x18(%rsp), %rdi
callq 0x2023b
jmp 0x1df84
movq %rsp, %rdi
callq 0x18aaa
// File: /workspace/github_cpp_makefile_star2_O1/romkatv[P]hcproxy/src/epoll.cc
// Function: hcproxy::EPoll::Remove(int)
void EPoll::Remove(int fd) {
  CHECK(total_events_ > 0);
  epoll_event event;
  CHECK(epoll_ctl(epoll_, EPOLL_CTL_DEL, fd, &event) == 0) << Errno();
  --total_events_;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
cmpq $0x0, 0x20(%rdi)
je 0x1dfbc
movl %esi, %edx
movq %rdi, %rbx
movl (%rdi), %edi
leaq 0x24(%rsp), %rcx
movl $0x2, %esi
callq 0x154e0
testl %eax, %eax
jne 0x1e005
decq 0x20(%rbx)
addq $0x30, %rsp
popq %rbx
retq
leaq 0xb1d76(%rip), %rsi     # 0xcfd39
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x28, %edx
movl $0x3, %ecx
callq 0x2019c
movq 0x18(%rbx), %rdi
leaq 0xb1dc9(%rip), %rsi     # 0xcfdac
movl $0x11, %edx
callq 0x8bab0
movq 0x18(%rsp), %rdi
leaq 0xb6312(%rip), %rsi     # 0xd430b
movl $0x2, %edx
callq 0x8bab0
jmp 0x1e05d
leaq 0xb1d2d(%rip), %rsi     # 0xcfd39
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x2a, %edx
movl $0x3, %ecx
callq 0x2019c
movq 0x18(%rbx), %rdi
leaq 0xb1d92(%rip), %rsi     # 0xcfdbe
movl $0x31, %edx
callq 0x8bab0
movq 0x18(%rsp), %rdi
leaq 0xb62c9(%rip), %rsi     # 0xd430b
movl $0x2, %edx
callq 0x8bab0
movl (%rsp), %esi
movq 0x18(%rsp), %rdi
callq 0x2023b
jmp 0x1e05d
jmp 0x1e05d
movq %rsp, %rdi
callq 0x18aaa
nop
// File: /workspace/github_cpp_makefile_star2_O1/romkatv[P]hcproxy/src/epoll.cc
// Function: hcproxy::EPoll::Modify(int, int, void*)
void EPoll::Modify(int fd, int events, void* data) {
  CHECK(total_events_ > 0);
  epoll_event event = {};
  event.events = events;
  event.data.ptr = data;
  CHECK(epoll_ctl(epoll_, EPOLL_CTL_MOD, fd, &event) == 0) << Errno();
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
cmpq $0x0, 0x20(%rdi)
je 0x1e0aa
movl %esi, %eax
leaq 0x20(%rsp), %r8
movq $0x0, (%r8)
movl $0x0, 0x8(%r8)
movl %edx, (%r8)
movq %rcx, 0x4(%r8)
movl (%rdi), %edi
movl $0x3, %esi
movl %eax, %edx
movq %r8, %rcx
callq 0x154e0
testl %eax, %eax
jne 0x1e0f3
addq $0x30, %rsp
popq %rbx
retq
leaq 0xb1c88(%rip), %rsi     # 0xcfd39
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x2f, %edx
movl $0x3, %ecx
callq 0x2019c
movq 0x18(%rbx), %rdi
leaq 0xb1cdb(%rip), %rsi     # 0xcfdac
movl $0x11, %edx
callq 0x8bab0
movq 0x18(%rsp), %rdi
leaq 0xb6224(%rip), %rsi     # 0xd430b
movl $0x2, %edx
callq 0x8bab0
jmp 0x1e14b
leaq 0xb1c3f(%rip), %rsi     # 0xcfd39
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x33, %edx
movl $0x3, %ecx
callq 0x2019c
movq 0x18(%rbx), %rdi
leaq 0xb1cd6(%rip), %rsi     # 0xcfdf0
movl $0x31, %edx
callq 0x8bab0
movq 0x18(%rsp), %rdi
leaq 0xb61db(%rip), %rsi     # 0xd430b
movl $0x2, %edx
callq 0x8bab0
movl (%rsp), %esi
movq 0x18(%rsp), %rdi
callq 0x2023b
jmp 0x1e14b
jmp 0x1e14b
movq %rsp, %rdi
callq 0x18aaa
nop
// File: /workspace/github_cpp_makefile_star2_O1/romkatv[P]hcproxy/src/epoll.cc
// Function: hcproxy::EPoll::Wait(std::optional<std::chrono::duration<long, std::ratio<1l, 1000000000l>>>)
void EPoll::Wait(std::optional<Duration> timeout) {
  if (total_events_ > events_.size()) {
    events_.resize(total_events_);
    events_.resize(events_.capacity());
  }
  int ms = timeout ? std::max<int>(0, ceil<milliseconds>(*timeout).count()) : -1;
  CHECK((ready_events_ = epoll_wait(epoll_, events_.data(), events_.size(), ms)) >= 0) << Errno();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x20(%rdi), %rsi
subq 0x8(%rdi), %rax
sarq $0x2, %rax
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r12, %rax
cmpq %rax, %rsi
jbe 0x1e1af
leaq 0x8(%rbx), %r15
movq %r15, %rdi
callq 0x1e280
movq 0x18(%rbx), %rsi
subq 0x8(%rbx), %rsi
sarq $0x2, %rsi
imulq %r12, %rsi
movq %r15, %rdi
callq 0x1e280
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %bpl
je 0x1e1f1
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
movq %r14, %rax
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x12, %rdx
addq %rax, %rdx
imulq $0xf4240, %rdx, %rax    # imm = 0xF4240
xorl %esi, %esi
cmpq %r14, %rax
setl %sil
addl %edx, %esi
xorl %ecx, %ecx
testl %esi, %esi
cmovgl %esi, %ecx
movl (%rbx), %edi
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
subq %rsi, %rax
shrq $0x2, %rax
imull $0xaaaaaaab, %eax, %edx # imm = 0xAAAAAAAB
callq 0x156d0
movl %eax, 0x28(%rbx)
testl %eax, %eax
js 0x1e221
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb1b11(%rip), %rsi     # 0xcfd39
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x3c, %edx
movl $0x3, %ecx
callq 0x2019c
movq 0x18(%rbx), %rdi
leaq 0xb1bda(%rip), %rsi     # 0xcfe22
movl $0x4d, %edx
callq 0x8bab0
movq 0x18(%rsp), %rdi
leaq 0xb60ad(%rip), %rsi     # 0xd430b
movl $0x2, %edx
callq 0x8bab0
movl (%rsp), %esi
movq 0x18(%rsp), %rdi
callq 0x2023b
jmp 0x1e277
movq %rsp, %rdi
callq 0x18aaa
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1e56f
testl %edx, %edx
js 0x1e5b8
movq 0x18(%rdi), %rax
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rcx
movaps %xmm0, (%rcx)
movaps %xmm0, 0x10(%rcx)
movq %rdi, (%rcx)
movl %esi, 0x8(%rcx)
movl %edx, 0xc(%rcx)
leaq 0x104(%rip), %rdx       # 0x1e63a
movq %rdx, 0x18(%rcx)
leaq 0x6cf(%rip), %rdx       # 0x1ec10
movq %rdx, 0x10(%rcx)
movq %rax, %rdi
movq %rcx, %rsi
callq 0x20c4e
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1e569
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x40, %rsp
popq %rbx
retq
leaq 0xb1986(%rip), %rsi     # 0xcfefc
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x13e, %edx            # imm = 0x13E
movl $0x3, %ecx
callq 0x2019c
movq 0x18(%rbx), %rdi
leaq 0xb1977(%rip), %rsi     # 0xcff0d
movl $0xe, %edx
callq 0x8bab0
movq 0x18(%rsp), %rdi
leaq 0xb5d5f(%rip), %rsi     # 0xd430b
movl $0x2, %edx
callq 0x8bab0
jmp 0x1e605
leaq 0xb193d(%rip), %rsi     # 0xcfefc
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x13f, %edx            # imm = 0x13F
movl $0x3, %ecx
callq 0x2019c
movq 0x18(%rbx), %rdi
leaq 0xb193d(%rip), %rsi     # 0xcff1c
movl $0xe, %edx
callq 0x8bab0
movq 0x18(%rsp), %rdi
leaq 0xb5d16(%rip), %rsi     # 0xd430b
movl $0x2, %edx
callq 0x8bab0
jmp 0x1e605
jmp 0x1e631
jmp 0x1e605
movq %rsp, %rdi
callq 0x18aaa
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1e629
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0xcc900
movq %rax, %rdi
callq 0x18abd
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1ffce
testb $0x8, %bpl
jne 0x1ef5a
xorl %r15d, %r15d
movl $0x0, %r12d
testb $0x4, %bpl
je 0x1ef03
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1f236
movzbl %al, %r12d
testb $0x1, %bpl
je 0x1ef19
movq 0x58(%rbx), %rdi
movq %r14, %rsi
callq 0x1f236
movzbl %al, %r15d
orl %r12d, %r15d
je 0x1f016
cmpb $0x0, 0x50(%rbx)
jne 0x1ef2e
cmpb $0x1, 0x51(%rbx)
jne 0x1ef39
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20d76
movq 0x58(%rbx), %rsi
cmpb $0x0, 0x50(%rsi)
jne 0x1ef4d
cmpb $0x1, 0x51(%rsi)
jne 0x1f016
movq %r14, %rdi
callq 0x20d76
jmp 0x1f016
leaq 0xb0f9b(%rip), %rsi     # 0xcfefc
movq %rsp, %r15
movq %r15, %rdi
movl $0xb5, %edx
xorl %ecx, %ecx
callq 0x2019c
movq 0x18(%r15), %rdi
leaq 0xb01c4(%rip), %rsi     # 0xcf142
movl $0x1, %edx
callq 0x8bab0
movl 0x18(%rbx), %esi
movq 0x18(%rsp), %rdi
callq 0x8c380
movq 0x18(%rsp), %rdi
leaq 0xb0fc9(%rip), %rsi     # 0xcff6a
movl $0x3, %edx
callq 0x8bab0
leaq 0x38(%rbx), %rsi
movq %rsp, %rdi
callq 0x19e52
movq %rax, %r15
movq 0x18(%rax), %rdi
leaq 0xb0fc5(%rip), %rsi     # 0xcff8a
movl $0x2, %edx
callq 0x8bab0
movq 0x18(%r15), %rdi
leaq 0xb0fb3(%rip), %rsi     # 0xcff8d
movl $0x12, %edx
callq 0x8bab0
movl 0x18(%rbx), %edi
callq 0x200ac
movq 0x18(%r15), %rdi
movl %eax, %esi
callq 0x2023b
movq %rsp, %rdi
callq 0x19688
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fe92
movq 0x58(%rbx), %rdi
movq %r14, %rsi
callq 0x1fe92
movq 0x58(%rbx), %rdi
callq 0x20036
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1f030
jmp 0x1f030
movq %rax, %rbx
movq %rsp, %rdi
callq 0x19688
movq %rbx, %rdi
callq 0xcc900
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb0ea2(%rip), %rsi     # 0xcfefc
movq %rsp, %r15
movq %r15, %rdi
movl $0xc6, %edx
xorl %ecx, %ecx
callq 0x2019c
movq 0x18(%r15), %rdi
leaq 0xb00cb(%rip), %rsi     # 0xcf142
movl $0x1, %edx
callq 0x8bab0
movl 0x18(%rbx), %esi
movq 0x18(%rsp), %rdi
callq 0x8c380
movq 0x18(%rsp), %rdi
leaq 0xb0ed0(%rip), %rsi     # 0xcff6a
movl $0x3, %edx
callq 0x8bab0
leaq 0x38(%rbx), %rsi
movq %rsp, %rdi
callq 0x19e52
movq 0x18(%rax), %rdi
leaq 0xb104e(%rip), %rsi     # 0xd0109
movl $0x1a, %edx
callq 0x8bab0
movq %rsp, %rdi
callq 0x19688
movq 0x58(%rbx), %rdi
callq 0x1ffce
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fe92
movq 0x58(%rbx), %rdi
movq %r14, %rsi
callq 0x1fe92
movq 0x58(%rbx), %rdi
callq 0x20036
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1f102
movq %rax, %rbx
movq %rsp, %rdi
callq 0x19688
movq %rbx, %rdi
callq 0xcc900
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1feb1
cmpb $0x1, 0x51(%rbx)
jne 0x1ff51
leaq 0xb0044(%rip), %rsi     # 0xcfefc
movq %rsp, %r15
movq %r15, %rdi
movl $0x11e, %edx            # imm = 0x11E
xorl %ecx, %ecx
callq 0x2019c
movq 0x18(%r15), %rdi
leaq 0xaf26d(%rip), %rsi     # 0xcf142
movl $0x1, %edx
callq 0x8bab0
movl 0x18(%rbx), %esi
movq 0x18(%rsp), %rdi
callq 0x8c380
movq 0x18(%rsp), %rdi
leaq 0xb0072(%rip), %rsi     # 0xcff6a
movl $0x3, %edx
callq 0x8bab0
leaq 0x38(%rbx), %rsi
movq %rsp, %rdi
callq 0x19e52
movq 0x18(%rax), %rdi
leaq 0xb0055(%rip), %rsi     # 0xcff6e
movl $0x7, %edx
callq 0x8bab0
movq %rsp, %rdi
callq 0x19688
movw $0x0, 0x50(%rbx)
movq 0x58(%rbx), %rdi
callq 0x20036
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20850
movl 0x18(%rbx), %edi
callq 0x15140
testl %eax, %eax
jne 0x1ff5b
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xaff9a(%rip), %rsi     # 0xcfefc
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x123, %edx            # imm = 0x123
movl $0x3, %ecx
callq 0x2019c
movq 0x18(%rbx), %rdi
leaq 0xaf752(%rip), %rsi     # 0xcf6d4
movl $0x10, %edx
callq 0x8bab0
movq 0x18(%rsp), %rdi
leaq 0xb4373(%rip), %rsi     # 0xd430b
movl $0x2, %edx
callq 0x8bab0
movl (%rsp), %esi
movq 0x18(%rsp), %rdi
callq 0x2023b
jmp 0x1ffb1
movq %rsp, %rdi
callq 0x18aaa
jmp 0x1ffbb
movq %rax, %rbx
movq %rsp, %rdi
callq 0x19688
movq %rbx, %rdi
callq 0xcc900
// File: /workspace/github_cpp_makefile_star2_O1/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 0x200ec
cmpl $0x4, 0x8(%rsp)
jne 0x20145
movl 0xc(%rsp), %eax
addq $0x30, %rsp
popq %rbx
retq
leaq 0xb01c6(%rip), %rsi     # 0xd02b9
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl $0x1b, %edx
movl $0x3, %ecx
callq 0x2019c
movq 0x18(%rbx), %rdi
leaq 0xb01b0(%rip), %rsi     # 0xd02c5
movl $0x35, %edx
callq 0x8bab0
movq 0x28(%rsp), %rdi
leaq 0xb41e0(%rip), %rsi     # 0xd430b
movl $0x2, %edx
callq 0x8bab0
movl 0x10(%rsp), %esi
movq 0x28(%rsp), %rdi
callq 0x2023b
jmp 0x20192
leaq 0xb016d(%rip), %rsi     # 0xd02b9
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl $0x1c, %edx
movl $0x3, %ecx
callq 0x2019c
movq 0x18(%rbx), %rdi
leaq 0xb018d(%rip), %rsi     # 0xd02fb
movl $0x12, %edx
callq 0x8bab0
movq 0x28(%rsp), %rdi
leaq 0xb4187(%rip), %rsi     # 0xd430b
movl $0x2, %edx
callq 0x8bab0
jmp 0x20192
jmp 0x20192
leaq 0x10(%rsp), %rdi
callq 0x18aaa
// File: /workspace/github_cpp_makefile_star2_O1/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 0x20279
movq %rax, %r14
movq %rax, %rdi
callq 0x153a0
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8bab0
jmp 0x20290
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x6c930
movq %rbx, %rax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1dda0
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movq %r15, 0x48(%rbx)
movq $0x0, 0x50(%rbx)
testq %r15, %r15
jle 0x203e6
movq %rbx, %rdi
movl $0x4000, %esi           # imm = 0x4000
callq 0x15070
testl %eax, %eax
je 0x20333
movq %rbx, %rdi
callq 0x15460
testl %eax, %eax
jne 0x2042f
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 0x2038c
addq $0x4, %r15
cmpq $0x8, %r15
jne 0x202fc
movl (%rbx), %esi
movq %r14, %rdi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x1deea
leaq 0x173(%rip), %rax       # 0x204be
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq $0x0, 0x8(%rsi)
leaq 0x30(%rsp), %rdx
movq %rbx, (%rdx)
leaq 0x28(%rsp), %rdi
callq 0x20f28
cmpq $0x0, 0x50(%rbx)
jne 0x204b8
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xaffc9(%rip), %rsi     # 0xd035c
leaq 0x8(%rsp), %rdi
movl $0x26, %edx
movl $0x3, %ecx
callq 0x2019c
movq 0x20(%rsp), %rdi
leaq 0xb00bb(%rip), %rsi     # 0xd046e
movl $0x1e, %edx
callq 0x8bab0
movq 0x20(%rsp), %rdi
leaq 0xb3f42(%rip), %rsi     # 0xd430b
movl $0x2, %edx
callq 0x8bab0
movl 0x8(%rsp), %esi
movq 0x20(%rsp), %rdi
callq 0x2023b
jmp 0x20492
leaq 0xaff6f(%rip), %rsi     # 0xd035c
leaq 0x8(%rsp), %rdi
movl $0x2c, %edx
movl $0x3, %ecx
callq 0x2019c
movq 0x20(%rsp), %rdi
leaq 0xaff61(%rip), %rsi     # 0xd036e
movl $0x1b, %edx
callq 0x8bab0
movq 0x20(%rsp), %rdi
leaq 0xb3ee8(%rip), %rsi     # 0xd430b
movl $0x2, %edx
callq 0x8bab0
jmp 0x20492
leaq 0xaff26(%rip), %rsi     # 0xd035c
leaq 0x8(%rsp), %rdi
movl $0x30, %edx
movl $0x3, %ecx
callq 0x2019c
movq 0x20(%rsp), %rdi
leaq 0xaff34(%rip), %rsi     # 0xd038a
movl $0x10, %edx
callq 0x8bab0
movq 0x20(%rsp), %rdi
leaq 0xb3e9f(%rip), %rsi     # 0xd430b
movl $0x2, %edx
callq 0x8bab0
movl 0x8(%rsp), %esi
movq 0x20(%rsp), %rdi
callq 0x2023b
jmp 0x20492
jmp 0x20492
jmp 0x2049e
jmp 0x20492
jmp 0x2049e
jmp 0x2049e
jmp 0x2049e
leaq 0x8(%rsp), %rdi
callq 0x18aaa
jmp 0x2049e
movq %rax, %r15
cmpq $0x0, 0x50(%rbx)
jne 0x204b8
movq %r14, %rdi
callq 0x1de54
movq %r15, %rdi
callq 0xcc900
callq 0x21f30
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x20765
movq %rsi, %rbx
cmpq $0x0, 0x28(%rsi)
jne 0x207b1
movl %edx, %ebp
movq %rdi, %r14
callq 0x15490
cmpq 0x50(%r14), %rax
jne 0x207fa
movq %rbx, %rdi
callq 0x1ffce
movq %r14, 0x28(%rbx)
callq 0x2b520
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 0x1deea
leaq 0xafbf0(%rip), %rsi     # 0xd035c
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x38, %edx
movl $0x3, %ecx
callq 0x2019c
movq 0x18(%rbx), %rdi
leaq 0xafc0f(%rip), %rsi     # 0xd039b
movl $0x2, %edx
callq 0x8bab0
movq 0x18(%rsp), %rdi
leaq 0xb3b69(%rip), %rsi     # 0xd430b
movl $0x2, %edx
callq 0x8bab0
jmp 0x20847
leaq 0xafba4(%rip), %rsi     # 0xd035c
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x39, %edx
movl $0x3, %ecx
callq 0x2019c
movq 0x18(%rbx), %rdi
leaq 0xafbc6(%rip), %rsi     # 0xd039e
movl $0x10, %edx
callq 0x8bab0
movq 0x18(%rsp), %rdi
leaq 0xb3b1d(%rip), %rsi     # 0xd430b
movl $0x2, %edx
callq 0x8bab0
jmp 0x20847
leaq 0xafb5b(%rip), %rsi     # 0xd035c
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x3a, %edx
movl $0x3, %ecx
callq 0x2019c
movq 0x18(%rbx), %rdi
leaq 0xafb8e(%rip), %rsi     # 0xd03af
movl $0x2c, %edx
callq 0x8bab0
movq 0x18(%rsp), %rdi
leaq 0xb3ad4(%rip), %rsi     # 0xd430b
movl $0x2, %edx
callq 0x8bab0
jmp 0x20847
jmp 0x20847
jmp 0x20847
movq %rsp, %rdi
callq 0x18aaa
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x208ae
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rdi, 0x28(%rsi)
jne 0x208fc
callq 0x15490
cmpq 0x50(%r14), %rax
jne 0x20947
leaq 0x38(%r14), %rdi
leaq 0x8(%rbx), %rsi
callq 0x18774
addq $0x8, %r14
movl 0x18(%rbx), %esi
movq %r14, %rdi
callq 0x1df8c
movq $0x0, 0x28(%rbx)
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x20036
leaq 0xafaa7(%rip), %rsi     # 0xd035c
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl $0x43, %edx
movl $0x3, %ecx
callq 0x2019c
movq 0x18(%rbx), %rdi
leaq 0xafac4(%rip), %rsi     # 0xd039b
movl $0x2, %edx
callq 0x8bab0
movq 0x20(%rsp), %rdi
leaq 0xb3a1e(%rip), %rsi     # 0xd430b
movl $0x2, %edx
callq 0x8bab0
jmp 0x20996
leaq 0xafa59(%rip), %rsi     # 0xd035c
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl $0x44, %edx
movl $0x3, %ecx
callq 0x2019c
movq 0x18(%rbx), %rdi
leaq 0xafab7(%rip), %rsi     # 0xd03dc
movl $0x17, %edx
callq 0x8bab0
movq 0x20(%rsp), %rdi
leaq 0xb39d0(%rip), %rsi     # 0xd430b
movl $0x2, %edx
callq 0x8bab0
jmp 0x20996
leaq 0xafa0e(%rip), %rsi     # 0xd035c
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl $0x45, %edx
movl $0x3, %ecx
callq 0x2019c
movq 0x18(%rbx), %rdi
leaq 0xafa3f(%rip), %rsi     # 0xd03af
movl $0x2c, %edx
callq 0x8bab0
movq 0x20(%rsp), %rdi
leaq 0xb3985(%rip), %rsi     # 0xd430b
movl $0x2, %edx
callq 0x8bab0
jmp 0x20996
jmp 0x20996
jmp 0x20996
leaq 0x8(%rsp), %rdi
callq 0x18aaa
// File: /workspace/github_cpp_makefile_star2_O1/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 0x209e6
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rdi, 0x28(%rsi)
jne 0x20a32
movl %edx, %ebp
callq 0x15490
cmpq 0x50(%r14), %rax
jne 0x20a7b
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 0x1e066
leaq 0xaf96f(%rip), %rsi     # 0xd035c
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x4d, %edx
movl $0x3, %ecx
callq 0x2019c
movq 0x18(%rbx), %rdi
leaq 0xaf98e(%rip), %rsi     # 0xd039b
movl $0x2, %edx
callq 0x8bab0
movq 0x18(%rsp), %rdi
leaq 0xb38e8(%rip), %rsi     # 0xd430b
movl $0x2, %edx
callq 0x8bab0
jmp 0x20ac8
leaq 0xaf923(%rip), %rsi     # 0xd035c
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x4e, %edx
movl $0x3, %ecx
callq 0x2019c
movq 0x18(%rbx), %rdi
leaq 0xaf983(%rip), %rsi     # 0xd03dc
movl $0x17, %edx
callq 0x8bab0
movq 0x18(%rsp), %rdi
leaq 0xb389c(%rip), %rsi     # 0xd430b
movl $0x2, %edx
callq 0x8bab0
jmp 0x20ac8
leaq 0xaf8da(%rip), %rsi     # 0xd035c
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x4f, %edx
movl $0x3, %ecx
callq 0x2019c
movq 0x18(%rbx), %rdi
leaq 0xaf90d(%rip), %rsi     # 0xd03af
movl $0x2c, %edx
callq 0x8bab0
movq 0x18(%rsp), %rdi
leaq 0xb3853(%rip), %rsi     # 0xd430b
movl $0x2, %edx
callq 0x8bab0
jmp 0x20ac8
jmp 0x20ac8
jmp 0x20ac8
movq %rsp, %rdi
callq 0x18aaa
// File: /workspace/github_cpp_makefile_star2_O1/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 0x20de6
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rdi, 0x28(%rsi)
jne 0x20e34
callq 0x15490
cmpq 0x50(%r14), %rax
jne 0x20e82
callq 0x2b520
addq 0x48(%r14), %rax
movq %rax, 0x20(%rbx)
movq 0x40(%r14), %rcx
testq %rcx, %rcx
je 0x20dc1
cmpq 0x18(%rcx), %rax
jl 0x20ecd
addq $0x38, %r14
addq $0x8, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x18774
movq %r14, %rdi
movq %rbx, %rsi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x184dc
leaq 0xaf56f(%rip), %rsi     # 0xd035c
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl $0x83, %edx
movl $0x3, %ecx
callq 0x2019c
movq 0x18(%rbx), %rdi
leaq 0xaf58c(%rip), %rsi     # 0xd039b
movl $0x2, %edx
callq 0x8bab0
movq 0x20(%rsp), %rdi
leaq 0xb34e6(%rip), %rsi     # 0xd430b
movl $0x2, %edx
callq 0x8bab0
jmp 0x20f1e
leaq 0xaf521(%rip), %rsi     # 0xd035c
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl $0x84, %edx
movl $0x3, %ecx
callq 0x2019c
movq 0x18(%rbx), %rdi
leaq 0xaf57f(%rip), %rsi     # 0xd03dc
movl $0x17, %edx
callq 0x8bab0
movq 0x20(%rsp), %rdi
leaq 0xb3498(%rip), %rsi     # 0xd430b
movl $0x2, %edx
callq 0x8bab0
jmp 0x20f1e
leaq 0xaf4d3(%rip), %rsi     # 0xd035c
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl $0x85, %edx
movl $0x3, %ecx
callq 0x2019c
movq 0x18(%rbx), %rdi
leaq 0xaf504(%rip), %rsi     # 0xd03af
movl $0x2c, %edx
callq 0x8bab0
movq 0x20(%rsp), %rdi
leaq 0xb344a(%rip), %rsi     # 0xd430b
movl $0x2, %edx
callq 0x8bab0
jmp 0x20f1e
leaq 0xaf488(%rip), %rsi     # 0xd035c
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl $0x88, %edx
movl $0x3, %ecx
callq 0x2019c
movq 0x18(%rbx), %rdi
leaq 0xaf557(%rip), %rsi     # 0xd044d
movl $0x20, %edx
callq 0x8bab0
movq 0x20(%rsp), %rdi
leaq 0xb33ff(%rip), %rsi     # 0xd430b
movl $0x2, %edx
callq 0x8bab0
jmp 0x20f1e
jmp 0x20f1e
jmp 0x20f1e
jmp 0x20f1e
leaq 0x8(%rsp), %rdi
callq 0x18aaa
// File: /workspace/github_cpp_makefile_star2_O1/hantaoyin[P]ffxiv-crafting-mcts/ffxiv-crafting-mcts.C
// Function: RandomlyGenNextCondition(Condition)
Condition RandomlyGenNextCondition(Condition last_condition) {
  switch (last_condition) {
  case Condition::Normal:
    // 1. Condition Excellent is not simulated: I don't have a good approximation on the probability
    // of transition Normal -> Excellent.  One source quotes the number 0.02, but that looks too
    // high to me.  Even the 0.25 probability of Normal -> Good is likely too high.
    return random_real() > 0.75 ? Condition::Good : Condition::Normal;
  case Condition::Good:
    return Condition::Normal;
  case Condition::Excellent:
    return Condition::Poor;
  case Condition::Poor:
    return Condition::Normal;
  default:
    ASSERT(false) << "Unsupported condition: " << static_cast<unsigned char>(last_condition);
    // Suppress compiler warning if ASSERT() is disabled.
    return Condition::Normal;
  }
}

// Assembly:
cmpl $0x2, %edi
je 0x253e
testl %edi, %edi
jne 0x2541
pushq %rax
leaq 0xb003(%rip), %rdi      # 0xd510
callq 0x3219
movsd 0xb006(%rip), %xmm1     # 0xd520
movsd 0xaff6(%rip), %xmm2     # 0xd518
subsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
ucomisd 0x5ad2(%rip), %xmm1     # 0x8008
seta %al
addq $0x8, %rsp
retq
movb $0x3, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x300e
jmp 0x256a
movq %rax, %rbx
leaq 0x1b8(%rsp), %rdi
callq 0x70bc
leaq 0x180(%rsp), %rdi
callq 0x52e6
leaq 0x18(%rsp), %r14
leaq 0x30(%rsp), %rdi
callq 0x3884
movq %r14, %rdi
callq 0x38b4
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5064(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x506c(%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 0xa45e(%rip), %r15      # 0xd510
incq 0x8(%rbx)
movq %r15, %rdi
callq 0x3219
movsd 0xa45a(%rip), %xmm1     # 0xd520
movsd 0xa44a(%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 0x4f2d(%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 0x3129
movq 0x1d8(%rbx), %rax
movq (%rax,%rcx,8), %rdx
jmp 0x3137
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 0x4ecc(%rip), %xmm1     # 0x8028
callq 0x6c66
incq %rbp
cmpq $0x64, %rbp
jne 0x30b2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x428e
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), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
je 0x4356
sarq $0x3, %rcx
movq 0x18(%rbx), %rdx
movq 0x30(%rbx), %rsi
movsd 0x3d9d(%rip), %xmm3     # 0x8050
mulsd %xmm0, %xmm3
addsd 0x3d79(%rip), %xmm3     # 0x8038
movq 0x18(%rax), %rdi
cmpq $0x1, %r13
movq %r13, %r8
adcq $0x0, %r8
cmpq $0x1, %rcx
adcq $0x0, %rcx
shlq $0x3, %r13
xorl %r9d, %r9d
cmpq %r15, %r12
je 0x432d
movq 0x18(%rax), %r10
movq 0x18(%r14), %r11
xorl %ebx, %ebx
movsd (%r10,%r9,8), %xmm1
mulsd (%rdx,%rbx,8), %xmm1
addsd (%r11,%rbx,8), %xmm1
movsd %xmm1, (%r11,%rbx,8)
movsd (%r10,%r9,8), %xmm1
mulsd %xmm0, %xmm1
mulsd (%r15,%rbx,8), %xmm1
movsd (%rdx,%rbx,8), %xmm2
mulsd %xmm3, %xmm2
subsd %xmm1, %xmm2
movsd %xmm2, (%rdx,%rbx,8)
incq %rbx
cmpq %rbx, %r8
jne 0x42ec
movsd (%rdi,%r9,8), %xmm1
mulsd %xmm0, %xmm1
movsd (%rsi,%r9,8), %xmm2
mulsd %xmm3, %xmm2
subsd %xmm1, %xmm2
movsd %xmm2, (%rsi,%r9,8)
incq %r9
addq %r13, %rdx
cmpq %rcx, %r9
jne 0x42dd
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %xmm0
cmpq $0x2, %rax
jb 0x46db
movl $0x1, %edx
movsd (%rcx,%rdx,8), %xmm1
maxsd %xmm0, %xmm1
incq %rdx
movapd %xmm1, %xmm0
cmpq %rdx, %rax
jne 0x46c4
jmp 0x46df
movapd %xmm0, %xmm1
movq 0x18(%rbx), %rax
xorpd %xmm2, %xmm2
testq %rax, %rax
je 0x473a
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 0x46f5
movsd 0x38f6(%rip), %xmm0     # 0x8038
testq %rax, %rax
je 0x476a
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 0x4754
movq 0x8(%rbx), %rcx
movq (%rcx), %rcx
movsd 0x38df(%rip), %xmm0     # 0x8058
subsd (%rcx,%rax,8), %xmm0
callq 0x22a0
movsd 0x38ad(%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_O1/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 0x18(%rdi), %rax
testq %rax, %rax
je 0x47ef
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdx
movq (%rdx), %rcx
movq 0x18(%rdx), %rdx
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 0x47cf
jmp 0x47f3
xorpd %xmm0, %xmm0
testq %rax, %rax
je 0x4828
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rcx
movq (%rcx), %rcx
movq 0x18(%rdx), %rdx
xorl %esi, %esi
movsd (%rdx,%rsi,8), %xmm1
movsd (%rcx,%rsi,8), %xmm2
mulsd %xmm0, %xmm2
subsd %xmm2, %xmm1
movsd %xmm1, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x4809
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdx
movq (%rdx), %rsi
movq 0x18(%rdx), %rdx
movsd (%rsi,%rax,8), %xmm0
movsd (%rdx,%rax,8), %xmm1
mulsd %xmm0, %xmm1
movsd 0x37eb(%rip), %xmm2     # 0x8038
subsd %xmm0, %xmm2
mulsd %xmm1, %xmm2
movq 0x18(%rcx), %rcx
movsd %xmm2, (%rcx,%rax,8)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x49a8
movq %rax, %r12
movq %r14, %rdi
callq 0x4a12
movq %rax, %r13
leaq 0x10(%rsp), %rbp
movq (%r12), %rax
movsd (%r13,%r15,8), %xmm0
mulsd 0x3787(%rip), %xmm0     # 0x8060
movsd (%rax,%r15,8), %xmm1
mulsd 0x3721(%rip), %xmm1     # 0x8008
addsd %xmm0, %xmm1
movsd %xmm1, (%rbp)
xorpd %xmm0, %xmm0
movupd %xmm0, -0x10(%rbp)
movzbl %r15b, %esi
movq %rbx, %rdi
callq 0x4a92
testb %al, %al
jne 0x491e
movq $-0x2, %rax
movl %r15d, %ecx
rolq %cl, %rax
andq %rax, 0x2c0(%rsp)
incq %r15
addq $0x18, %rbp
cmpq $0x1d, %r15
jne 0x48c6
addq $0x138, %r14            # imm = 0x138
movq %rsp, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4dee
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_O1/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 0x4ad8
movswl (%rdi), %eax
movzbl %sil, %ecx
movl %ecx, %edx
shll $0x4, %edx
leaq 0x700e(%rip), %rsi      # 0xbab8
movsbl 0x8(%rdx,%rsi), %edx
addl %eax, %edx
js 0x4ad8
movb $0x1, %al
addl $-0x2, %ecx
cmpl $0x18, %ecx
ja 0x4ad7
leaq 0x36c4(%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 0x4b01
cmpb $0x2, 0x8(%rdi)
setae %al
retq
cmpb $0x0, 0x12(%rdi)
jmp 0x4b01
cmpb $0x0, 0xf(%rdi)
jmp 0x4b01
cmpb $0x0, 0xc(%rdi)
sete %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6834
testq %rax, %rax
je 0x5c61
movq %rax, %rbx
movq %rax, %r14
addq $0x28, %r14
xorpd %xmm0, %xmm0
xorl %r15d, %r15d
movq 0x2e0(%rbx), %rax
btq %r15, %rax
jae 0x5bb0
movsd (%r14), %xmm1
unpcklps 0x2580(%rip), %xmm1     # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x2588(%rip), %xmm1     # 0x8100
movsd %xmm0, (%rsp)
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x2280
movsd %xmm0, 0x10(%rsp,%r15,8)
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
jmp 0x5bb9
movq $0x0, 0x10(%rsp,%r15,8)
incq %r15
addq $0x18, %r14
cmpq $0x1d, %r15
jne 0x5b57
movb $0x1d, %bpl
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x5bd5
jnp 0x5c51
leaq 0x7934(%rip), %rdi      # 0xd510
movsd %xmm0, (%rsp)
callq 0x3219
movsd 0x7932(%rip), %xmm1     # 0xd520
movsd 0x7922(%rip), %xmm2     # 0xd518
subsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
movsd (%rsp), %xmm0
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
movq 0x2e0(%rbx), %rax
xorl %ecx, %ecx
btq %rcx, %rax
jae 0x5c36
subsd 0x10(%rsp,%rcx,8), %xmm0
xorl %esi, %esi
ucomisd %xmm0, %xmm1
seta %sil
movzbl %dl, %edx
cmoval %ecx, %edx
jmp 0x5c3b
movl $0x7, %esi
cmpl $0x7, %esi
je 0x5c44
testl %esi, %esi
jne 0x5c4f
incq %rcx
cmpq $0x1d, %rcx
jne 0x5c18
jmp 0x5c51
movl %edx, %ebp
movl %ebp, %eax
addq $0xf8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x296b(%rip), %rdi      # 0x85d3
callq 0x21e0
nop