LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: craigbarstow[P]cmd-line-text-editor/document.cc
// Function: text_ed::save_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool text_ed::save_file (string filename) { // Save the text under the new name; remember the new name in current_file.
 ofstream savefile;
 int i;
 savefile.open(filename.c_str());
 for (i=1; i<=last_line; i++) { //save each line from document arry to file
   savefile << document[i]; 
   savefile << endl;
 }
 savefile.close();
 return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rsi, -0x238(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x240(%rbp)
leaq -0x210(%rbp), %rdi
movq %rdi, -0x230(%rbp)
callq 0x3360
movq -0x238(%rbp), %rdi
callq 0x30d0
movq -0x230(%rbp), %rdi
movq %rax, %rsi
movl $0x10, %edx
callq 0x3050
jmp 0x85ba
movl $0x1, -0x214(%rbp)
movq -0x240(%rbp), %rcx
movl -0x214(%rbp), %eax
cmpl 0x10(%rcx), %eax
jg 0x8644
movq -0x240(%rbp), %rax
movq (%rax), %rsi
movslq -0x214(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
leaq -0x210(%rbp), %rdi
callq 0x31d0
jmp 0x85fc
movq 0x39b5(%rip), %rsi      # 0xbfb8
leaq -0x210(%rbp), %rdi
callq 0x3210
jmp 0x8611
jmp 0x8613
movl -0x214(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x214(%rbp)
jmp 0x85c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x3300
jmp 0x866b
leaq -0x210(%rbp), %rdi
callq 0x32e0
jmp 0x8652
leaq -0x210(%rbp), %rdi
callq 0x3300
movb $0x1, %al
andb $0x1, %al
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq -0x220(%rbp), %rdi
callq 0x3380
nopw (%rax,%rax)
// File: craigbarstow[P]cmd-line-text-editor/document.cc
// Function: text_ed::delete_lines(int, int)
bool text_ed::delete_lines(int start, int end) { // Delete lines from start position to end position.
  int i;
  int num_lines = end-start;
  for (i=start; i<=last_line; i++) { //delete lines from start to end positions
    document[i] = document[i+num_lines+1];
  }
  last_line = last_line-num_lines-1;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x10(%rcx), %eax
jg 0x86ed
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movl -0x14(%rbp), %ecx
addl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x5, %rcx
addq %rcx, %rsi
movq (%rax), %rdi
movslq -0x14(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x3040
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x86a9
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
subl -0x18(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, 0x10(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: craigbarstow[P]cmd-line-text-editor/document.cc
// Function: text_ed::get_line(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int)
bool text_ed::get_line(string& dest, int n) { // Copy line n into dest.
  if (n>last_line) {
    return false;
  }
 dest = document[n];
 return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0x10(%rcx), %eax
jle 0x8739
movb $0x0, -0x1(%rbp)
jmp 0x8758
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movslq -0x1c(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdi
callq 0x3040
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: craigbarstow[P]cmd-line-text-editor/document.cc
// Function: text_ed::copy_lines(int, int, int)
bool text_ed::copy_lines(int start, int end, int location) { //copy lines start through end to follow line location.
  int buff_capacity=end-start+1;
  copy_to_buffer(start,end);
  open_up(location, buff_capacity);
  copy_to_document(start,end,location);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x7a30
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x7c60
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
callq 0x7b50
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: craigbarstow[P]cmd-line-text-editor/document.cc
// Function: text_ed::move_lines(int, int, int)
bool text_ed::move_lines(int start, int end, int location) { //move lines between two given lines (start to end) to after the given line location
  if (location<start || location>end) { //make sure new line location isnt between the start and end selections
    copy_lines(start,end,location);
    delete_lines(start,end); //delete the original lines so there aren't duplicates
    return true;
  } else {
    cout << "Error. Make sure location given is not between the two lines selected." << endl;
    return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jl 0x87fd
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x8824
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x8770
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x8680
movb $0x1, -0x1(%rbp)
jmp 0x884a
movq 0x379d(%rip), %rdi      # 0xbfc8
leaq 0xc60(%rip), %rsi       # 0x9492
callq 0x31f0
movq %rax, %rdi
movq 0x3777(%rip), %rsi      # 0xbfb8
callq 0x3210
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: craigbarstow[P]cmd-line-text-editor/document.cc
// Function: text_ed::replace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
bool text_ed::replace(string oldstr, string newstr, int start, int end) { //replace old word with new word between given lines (start to end)
  int i, j;
  for (i=start; i<=end; i++) { //for each line in the given area
    for(j=0;j<document[i].length(); j++){ //for character in string
      if(document[i].substr(j,oldstr.length())==oldstr){ //if substring found starting at the character position
	document[i].replace(j,oldstr.length(),newstr); //replace old string with new string
      }
    }
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0x899a
movl $0x0, -0x28(%rbp)
movq -0x50(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movq (%rax), %rdi
movslq -0x24(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x3310
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x898a
movq -0x60(%rbp), %rdi
movq -0x50(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x80(%rbp)
movslq -0x28(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x3310
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq %rax, %rcx
leaq -0x48(%rbp), %rdi
callq 0x3200
movq -0x60(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x89b0
movb %al, -0x69(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3160
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x8933
jmp 0x897a
movq -0x60(%rbp), %rdi
movq -0x50(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x90(%rbp)
movslq -0x28(%rbp), %rax
movq %rax, -0x88(%rbp)
callq 0x3310
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq -0x58(%rbp), %rcx
movq %rax, %rdx
callq 0x30b0
jmp 0x897c
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x88a7
jmp 0x898c
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8894
movb $0x1, %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: tdv[P]boss/boss/src/class_factory/class_factory.cpp
// Function: Boss::ClassFactory::FinalizeConstruct()
void ClassFactory::FinalizeConstruct()
  {
    Locator = Boss::Private::GetServiceLocator();
    if (Locator.Get() && Locator->AddService(Service::Locator::Id::ClassFactoryService, GetThisIBase()))
      throw ClassFactoryException("Failed to put ClassFactory into ServiceLocator");
    
    //CleanerThread.reset(new std::thread(&ClassFactory::Clean, this));
  }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x8eb50
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
addq $0xd0, %rdi
callq 0x8b0c0
jmp 0x9355a
leaq 0x38(%rsp), %rdi
callq 0x90a50
movq 0x18(%rsp), %rdi
addq $0xd0, %rdi
callq 0x8d5e0
cmpq $0x0, %rax
je 0x93627
movq 0x18(%rsp), %rdi
addq $0xd0, %rdi
callq 0x8fb10
movq 0x18(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x10(%rsp), %rdi
movq %rax, %rdx
movq (%rdi), %rax
movl $0x16d1a76d, %esi       # imm = 0x16D1A76D
callq *0x30(%rax)
cmpl $0x0, %eax
je 0x93627
movl $0x10, %edi
callq 0x8d310
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0xada30(%rip), %rsi     # 0x141004
callq 0x8c000
jmp 0x935db
movq 0x8(%rsp), %rdi
movq 0xed779(%rip), %rsi     # 0x180d60
movq 0xecd7a(%rip), %rdx     # 0x180368
callq 0x8dc90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x90a50
jmp 0x9362c
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x8b5c0
jmp 0x9362c
addq $0x48, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x13e4c0
nopw %cs:(%rax,%rax)
// File: tdv[P]boss/boss/src/class_factory/class_factory.cpp
// Function: Boss::ClassFactory::BeforeRelease()
void ClassFactory::BeforeRelease()
  {
    std::lock_guard<std::recursive_mutex> Lock(Mtx);
    IsRunCleaner = false;
    //CleanerThread->join();
    CleanerThread.reset();
    Registry.Release();
    for (auto &i : Modules)
    {
      try
      {
        assert(!i.second->GetModule().GetRefCount() && "Module has not null reference counter.");
      }
      catch (...)
      {
        assert(false && "Failed to get module reference counter.");
      }
    }
    if (Locator.Get())
      Locator->DelService(Service::Locator::Id::ClassFactoryService);
  }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rsi
movq %rsi, 0x20(%rsp)
addq $0x20, %rsi
leaq 0x58(%rsp), %rdi
callq 0x8d2f0
movq 0x20(%rsp), %rdi
movb $0x0, 0xb8(%rdi)
addq $0xc0, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8da70
movq 0x20(%rsp), %rdi
addq $0xc8, %rdi
callq 0x907c0
jmp 0x93690
movq 0x20(%rsp), %rax
addq $0x80, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x8e780
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x8d4d0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x8fac0
testb $0x1, %al
jne 0x936d6
jmp 0x937bb
leaq 0x38(%rsp), %rdi
callq 0x8f210
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
callq 0x8d050
movq %rax, %rdi
callq 0x8bc40
movq %rax, 0x18(%rsp)
jmp 0x93702
movq 0x18(%rsp), %rdi
callq 0x8d3d0
movl %eax, 0x14(%rsp)
jmp 0x93712
movl 0x14(%rsp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x13(%rsp)
jne 0x93729
movb $0x1, %al
movb %al, 0x13(%rsp)
jmp 0x93729
movb 0x13(%rsp), %al
testb $0x1, %al
jne 0x93733
jmp 0x93735
jmp 0x937a8
leaq 0xad91e(%rip), %rdi     # 0x14105a
leaq 0xad968(%rip), %rsi     # 0x1410ab
movl $0x5d, %edx
leaq 0xad985(%rip), %rcx     # 0x1410d4
callq 0x8bfd0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x90590
jmp 0x9381a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
movq 0x50(%rsp), %rdi
callq 0x8b730
leaq 0xad96d(%rip), %rdi     # 0x1410fd
leaq 0xad914(%rip), %rsi     # 0x1410ab
movl $0x61, %edx
leaq 0xad931(%rip), %rcx     # 0x1410d4
callq 0x8bfd0
jmp 0x937aa
jmp 0x937ac
leaq 0x38(%rsp), %rdi
callq 0x8bfa0
jmp 0x936be
movq 0x20(%rsp), %rdi
addq $0xd0, %rdi
callq 0x8d5e0
movq %rax, 0x8(%rsp)
jmp 0x937d3
movq 0x8(%rsp), %rax
cmpq $0x0, %rax
je 0x9380b
movq 0x20(%rsp), %rdi
addq $0xd0, %rdi
callq 0x8fb10
movq %rax, (%rsp)
jmp 0x937f5
movq (%rsp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
movl $0x16d1a76d, %esi       # imm = 0x16D1A76D
callq *%rax
jmp 0x93809
jmp 0x9380b
leaq 0x58(%rsp), %rdi
callq 0x90590
addq $0x68, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x13e4c0
nopw %cs:(%rax,%rax)
// File: tdv[P]boss/boss/src/class_factory/class_factory.cpp
// Function: Boss::ClassFactory::SetRegistry(Boss::IServiceRegistry*)
RetCode BOSS_CALL ClassFactory::SetRegistry(IServiceRegistry *registry)
  {
    try
    {
      std::lock_guard<std::recursive_mutex> Lock(Mtx);
      Registry = registry;
    }
    catch (...)
    {
      return Status::Fail;
    }
    return Status::Ok;
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rsi
movq %rsi, (%rsp)
addq $0x20, %rsi
leaq 0x18(%rsp), %rdi
callq 0x8d2f0
jmp 0x94257
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
addq $0xc8, %rdi
callq 0x90440
jmp 0x9426e
leaq 0x18(%rsp), %rdi
callq 0x90590
jmp 0x942bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
jmp 0x942a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x90590
movq 0x10(%rsp), %rdi
callq 0x8b730
movl $0x2, 0x34(%rsp)
callq 0x8e640
jmp 0x942c3
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: tdv[P]boss/boss/include/plugin/module_holder.h
// Function: Boss::ModuleHolder::GetRefCount() const
UInt const GetRefCount() const
    {
      typedef RetCode (*PFNBossGetRefCount)(UInt *);
      auto *BossGetRefCount = Dll.GetProc<PFNBossGetRefCount>("BossGetRefCount");
      UInt RefCount = 0;
      if (BossGetRefCount(&RefCount) != Status::Ok)
        throw ModuleHolderException("Failed to call BossGetRefCount.");
      return RefCount;
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x8c940
movq 0x18(%rsp), %rdx
leaq 0xac4a2(%rip), %rsi     # 0x141130
leaq 0x38(%rsp), %rdi
callq 0x90550
jmp 0x94c9a
movq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x8e6a0
movq %rax, 0x8(%rsp)
jmp 0x94cb0
leaq 0x38(%rsp), %rdi
callq 0x8dfd0
leaq 0x37(%rsp), %rdi
callq 0x8f540
movq 0x8(%rsp), %rax
movq %rax, 0x58(%rsp)
movl $0x0, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
callq *0x58(%rsp)
cmpl $0x0, %eax
je 0x94d6e
movl $0x10, %edi
callq 0x8d310
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0xac43d(%rip), %rsi     # 0x141140
callq 0x8b0a0
jmp 0x94d0a
movq (%rsp), %rdi
movq 0xebc93(%rip), %rsi     # 0x1809a8
movq 0xebe3c(%rip), %rdx     # 0x180b58
callq 0x8dc90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x94d49
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x8dfd0
leaq 0x37(%rsp), %rdi
callq 0x8f540
jmp 0x94d77
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x8b5c0
jmp 0x94d77
movl 0x20(%rsp), %eax
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x13e4c0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: tdv[P]boss/boss/src/class_factory/class_factory.cpp
// Function: Boss::ClassFactory::ModuleHolderEx::ModuleHolderEx(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
ModuleHolderEx(std::string const &path)
      : Module(std::move(DllHolder(path)))
    {
      auto Locator = Private::GetServiceLocator();
      if (Locator.Get())
      {
        Module.SetServiceLocator(Locator.Get());
        LocatorExists = false;
      }
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, (%rax)
addq $0x8, %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rsi
leaq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x901a0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x8bd30
jmp 0x9a849
leaq 0x40(%rsp), %rdi
callq 0x8bf70
leaq 0x28(%rsp), %rdi
callq 0x8eb50
jmp 0x9a85f
leaq 0x28(%rsp), %rdi
callq 0x8d5e0
cmpq $0x0, %rax
je 0x9a8e4
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x8d5e0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x8fee0
jmp 0x9a896
movq 0x10(%rsp), %rax
movb $0x0, (%rax)
jmp 0x9a8e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x8bf70
jmp 0x9a8fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x9a8f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x90a50
jmp 0x9a8f3
leaq 0x28(%rsp), %rdi
callq 0x90a50
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x8e880
movq 0x38(%rsp), %rdi
callq 0x13e4c0
nopw (%rax,%rax)
// File: tetsuok[P]kernel-pa/kernel_pa.cc
// Function: kernel::(anonymous namespace)::Usage(char const*)
[[noreturn]] void Usage(const char* name) {
  cerr << "usage: " << name << " [-C FLOAT] [-d INT] [-t INT] [-o FILE] FILE\n"
      "-C hyperparameter passive-aggressive. C should be positive. (default: " << kC << ")\n"
      "-d the degree of polynomial kernel (supported: d = 1, 2, 3, and 4) (deafult: " << kKernelDegree << ")\n"
      "-t the number of iterations (default: " << kNumIter << ")\n"
      "-o model filename (default " << kModel << ")\n";
  exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xe48d(%rip), %rdi      # 0x10ff0
leaq 0x84fe(%rip), %rsi      # 0xb068
callq 0x21b0
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x21b0
movq %rax, %rdi
leaq 0x84eb(%rip), %rsi      # 0xb070
callq 0x21b0
movq %rax, %rdi
movsd 0x8473(%rip), %xmm0     # 0xb008
callq 0x23b0
movq %rax, %rdi
leaq 0x8540(%rip), %rsi      # 0xb0e4
callq 0x21b0
movq %rax, %rdi
movl $0x2, %esi
callq 0x2360
movq %rax, %rdi
leaq 0x8574(%rip), %rsi      # 0xb134
callq 0x21b0
movq %rax, %rdi
movl $0x3, %esi
callq 0x2360
movq %rax, %rdi
leaq 0x8581(%rip), %rsi      # 0xb15d
callq 0x21b0
movq %rax, %rdi
leaq 0x8425(%rip), %rsi      # 0xb010
callq 0x21b0
movq %rax, %rdi
leaq 0x8581(%rip), %rsi      # 0xb17b
callq 0x21b0
movl $0x1, %edi
callq 0x2240
nopl (%rax)
// File: davmac314[P]dinit/src/dinit.cc
// Function: sigquit_cb(dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>&)
static void sigquit_cb(eventloop_t &eloop) noexcept
{
    // This performs an immediate shutdown, without service rollback.
    close_control_socket();
    execl(shutdown_exec.c_str(), shutdown_exec.c_str(), "--system", (char *) 0);
    log(loglevel_t::ERROR, error_exec_sd, strerror(errno));
    sync(); // since a hard poweroff might be required at this point...
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0xdb00
leaq 0x6a145(%rip), %rdi     # 0x76f4d
callq 0xfb50
movq %rax, -0x18(%rbp)
jmp 0xce13
leaq 0x6a133(%rip), %rdi     # 0x76f4d
callq 0xfb50
movq %rax, -0x20(%rbp)
jmp 0xce25
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
leaq 0x69385(%rip), %rdx     # 0x761b9
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0xa8d0
callq 0xa060
movl (%rax), %edi
callq 0xa1f0
movq %rax, -0x10(%rbp)
movl $0x3, %edi
leaq 0x6a101(%rip), %rsi     # 0x76f5c
leaq -0x10(%rbp), %rdx
callq 0xdeb0
callq 0xa6b0
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xfa30
nopw (%rax,%rax)
// File: davmac314[P]dinit/src/dinit.cc
// Function: flush_log()
static void flush_log() noexcept
{
    log_flush_timer.reset();
    log_flush_timer.arm_timer_rel(event_loop, timespec{5,0}); // 5 seconds
    while (!is_log_flushed() && !log_flush_timer.has_expired()) {
        event_loop.run();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x9b739(%rip), %rdi     # 0xa8de8
callq 0xf1a0
jmp 0xd6b6
movq $0x5, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
leaq 0x9b71b(%rip), %rdi     # 0xa8de8
leaq 0x9b48c(%rip), %rsi     # 0xa8b60
leaq -0x10(%rbp), %rdx
callq 0x18220
callq 0x6b3a0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0xd707
leaq 0x9b6f3(%rip), %rdi     # 0xa8de8
callq 0xf1c0
movb %al, -0x12(%rbp)
jmp 0xd6ff
movb -0x12(%rbp), %al
xorb $-0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xd710
jmp 0xd723
leaq 0x9b449(%rip), %rdi     # 0xa8b60
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xfa80
jmp 0xd6dd
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xfa30
nopw %cs:(%rax,%rax)
// File: davmac314[P]dinit/src/dinit.cc
// Function: control_socket_ready()
static void control_socket_ready() noexcept
{
    if (!control_socket_open || socket_ready_fd < 0) {
        return;
    }
    write(socket_ready_fd, control_socket_path, strlen(control_socket_path) + 1);
    // Once done with, close it (but leave stdout/stderr alone)
    if (socket_ready_fd > 2) {
        close(socket_ready_fd);
    }
    // Ensure that we don't try to issue readiness again:
    socket_ready_fd = -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
testb $0x1, 0x9b3c4(%rip)     # 0xa8e53
je 0xda9a
cmpl $0x0, 0x9ac68(%rip)     # 0xa8700
jge 0xda9c
jmp 0xdaeb
movl 0x9ac5e(%rip), %eax     # 0xa8700
movl %eax, -0xc(%rbp)
movq 0x9ac64(%rip), %rdi     # 0xa8710
movq %rdi, -0x8(%rbp)
callq 0xa280
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rsi
movq %rax, %rdx
incq %rdx
callq 0xa200
jmp 0xdac9
cmpl $0x2, 0x9ac30(%rip)     # 0xa8700
jle 0xdae1
movl 0x9ac28(%rip), %edi     # 0xa8700
callq 0xad80
jmp 0xdadf
jmp 0xdae1
movl $0xffffffff, 0x9ac15(%rip) # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xfa30
nopl (%rax)
// File: davmac314[P]dinit/src/dinit.cc
// Function: close_control_socket()
static void close_control_socket() noexcept
{
    if (control_socket_open) {
        int fd = control_socket_io.get_watched_fd();
        control_socket_io.deregister(event_loop);
        close(fd);
        
        // Unlink the socket:
        unlink(control_socket_path);

        control_socket_open = false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
testb $0x1, 0x9b344(%rip)     # 0xa8e53
je 0xdb51
leaq 0x9b280(%rip), %rdi     # 0xa8d98
movq %rdi, -0x10(%rbp)
callq 0x17d50
movq -0x10(%rbp), %rdi
movl %eax, -0x4(%rbp)
leaq 0x9b031(%rip), %rsi     # 0xa8b60
callq 0x17d20
movl -0x4(%rbp), %edi
callq 0xad80
jmp 0xdb3e
movq 0x9abcb(%rip), %rdi     # 0xa8710
callq 0xa2c0
movb $0x0, 0x9b302(%rip)     # 0xa8e53
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xfa30
nop
// File: davmac314[P]dinit/src/dinit.cc
// Function: rootfs_is_rw()
void rootfs_is_rw() noexcept
{
    open_control_socket(true);
    control_socket_ready();
    if (!log_is_syslog && !external_log_open) {
        // Try (again) to open log file if we couldn't do so earlier.
        setup_external_log();
    }
    if (!did_log_boot) {
        did_log_boot = log_boot();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
callq 0xd230
callq 0xda80
testb $0x1, 0x9a7da(%rip)     # 0xa8718
jne 0xdf4e
testb $0x1, 0x9ad81(%rip)     # 0xa8cc8
jne 0xdf4e
callq 0xd740
testb $0x1, 0x9aefc(%rip)     # 0xa8e51
jne 0xdf6c
callq 0xfb90
movb %al, -0x1(%rbp)
jmp 0xdf61
movb -0x1(%rbp), %al
andb $0x1, %al
movb %al, 0x9aee5(%rip)      # 0xa8e51
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xfa30
nopw (%rax,%rax)
// File: davmac314[P]dinit/src/dinit.cc
// Function: control_socket_cb(dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>*, int)
static void control_socket_cb(eventloop_t *loop, int sockfd) noexcept
{
    // Considered keeping a limit the number of active connections, however, there doesn't
    // seem much to be gained from that. Only root can create connections and not being
    // able to establish a control connection is as much a denial-of-service as is not being
    // able to start a service due to lack of fd's.

    // Accept a connection
    int newfd = dinit_accept4(sockfd, nullptr, nullptr, SOCK_NONBLOCK | SOCK_CLOEXEC);

    if (newfd != -1) {
        try {
            new control_conn_t(*loop, services, newfd);  // will delete itself when it's finished
        }
        catch (std::exception &exc) {
            log(loglevel_t::ERROR, "Error accepting control connection: ", exc.what());
            close(newfd);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
xorl %eax, %eax
movl %eax, %edx
movl $0x80800, %ecx          # imm = 0x80800
movq %rdx, %rsi
callq 0xe300
movl %eax, -0x34(%rbp)
jmp 0xe228
movl -0x34(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $-0x1, -0x10(%rbp)
je 0xe2df
movl $0x510, %edi            # imm = 0x510
callq 0xa700
movq %rax, -0x40(%rbp)
jmp 0xe248
movq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq 0x9abf1(%rip), %rdx     # 0xa8e48
movl -0x10(%rbp), %ecx
callq 0x11200
jmp 0xe261
jmp 0xe2dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0xe28b
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x510, %esi            # imm = 0x510
callq 0xa720
movl -0x1c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0xe2ed
movq -0x18(%rbp), %rdi
callq 0xa240
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, -0x30(%rbp)
leaq 0x67f7c(%rip), %rsi     # 0x76238
movl $0x3, %edi
leaq -0x30(%rbp), %rdx
callq 0xe330
movl -0x10(%rbp), %edi
callq 0xad80
jmp 0xe2d4
callq 0xac30
jmp 0xe2db
jmp 0xe2dd
jmp 0xe2df
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xfa30
movq -0x18(%rbp), %rdi
callq 0xfa30
nopw %cs:(%rax,%rax)
// File: davmac314[P]dinit/src/../dasynq/include/dasynq.h
// Function: dasynq::v2::dprivate::signal_watcher_impl<dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>, (anonymous namespace)::callback_signal_handler>::dispatch(void*)
void dispatch(void *loop_ptr) noexcept override
    {
        EventLoop &loop = *static_cast<EventLoop *>(loop_ptr);
        loop_access::get_base_lock(loop).unlock();

        auto rearm_type = static_cast<Derived *>(this)->received(loop, this->siginfo.get_signo(), this->siginfo);

        loop_access::get_base_lock(loop).lock();

        if (rearm_type != rearm::REMOVED) {

            this->active = false;
            if (this->deleteme) {
                // We don't want a watch that is marked "deleteme" to re-arm itself.
                rearm_type = rearm::REMOVE;
            }

            loop_access::process_signal_rearm(loop, this, rearm_type);

            post_dispatch(loop, this, rearm_type);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11100
movq %rax, %rdi
callq 0x11120
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x20, %rdi
callq 0x164d0
movl %eax, -0x20(%rbp)
jmp 0xe9cb
movl -0x20(%rbp), %edx
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdi
movq %rdi, %rcx
addq $0x20, %rcx
callq 0xeae0
movl %eax, -0x34(%rbp)
jmp 0xe9e7
movl -0x34(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11100
movq %rax, %rdi
callq 0x11130
cmpl $0x4, -0x1c(%rbp)
je 0xea4a
movq -0x30(%rbp), %rax
movb 0xc(%rax), %cl
andb $-0x2, %cl
orb $0x0, %cl
movb %cl, 0xc(%rax)
movb 0xc(%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0xea2a
movl $0x3, -0x1c(%rbp)
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %edx
callq 0x164e0
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %edx
callq 0x11170
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xfa30
nopl (%rax,%rax)
// File: davmac314[P]dinit/src/../dasynq/include/dasynq.h
// Function: dasynq::v2::dprivate::signal_watcher<dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>>::add_watch(dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>&, int, int)
inline void add_watch(event_loop_t &eloop, int signo, int prio = DEFAULT_PRIORITY)
    {
        base_watcher::init();
        this->priority = prio;
        this->siginfo.set_signo(signo);
        eloop.register_signal(this, signo);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x135c0
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, 0x18(%rdi)
addq $0x20, %rdi
movl -0x14(%rbp), %esi
callq 0x1bb70
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
callq 0x1bb90
addq $0x20, %rsp
popq %rbp
retq
nop
// File: davmac314[P]dinit/src/includes/service.h
// Function: log_service_load_failure(service_description_exc&)
inline void log_service_load_failure(service_description_exc &exc)
{
    if (exc.input_pos.get_line_num() != (unsigned)-1) {
        if (exc.setting_name == nullptr) {
            log(loglevel_t::ERROR, "Error in service description for '", exc.service_name,
                    "' (file ", exc.input_pos.get_file_name(), ", line ", exc.input_pos.get_line_num(), "): ",
                    exc.exc_description);
        }
        else {
            log(loglevel_t::ERROR, "Error in service description for '", exc.service_name, "': setting '", exc.setting_name, "' "
                    "(file ", exc.input_pos.get_file_name(), ", line ", exc.input_pos.get_line_num(), "): ",
                    exc.exc_description);
        }
    }
    else {
        // If no line number, setting name must be present
        log(loglevel_t::ERROR, "Error in service description for '", exc.service_name, "' setting '", exc.setting_name, "': ",
                exc.exc_description);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x17560
cmpl $-0x1, %eax
je 0xf9e5
movq -0x18(%rbp), %rax
cmpq $0x0, 0x68(%rax)
jne 0xf956
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x17570
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x17560
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %r8
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rax
movl $0x3, %edi
leaq 0x67293(%rip), %rsi     # 0x76bb8
leaq 0x672af(%rip), %rcx     # 0x76bdb
leaq 0x672b1(%rip), %r9      # 0x76be4
leaq -0x1c(%rbp), %r11
leaq 0x692cc(%rip), %r10     # 0x78c0a
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0xeb10
jmp 0xf9e3
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x17570
movq %rax, %r14
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x17560
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %r8
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rax
movl $0x3, %edi
leaq 0x67212(%rip), %rsi     # 0x76bb8
leaq 0x6723f(%rip), %rcx     # 0x76bec
leaq 0x67227(%rip), %r9      # 0x76bdb
leaq 0x67229(%rip), %rbx     # 0x76be4
leaq -0x20(%rbp), %r11
leaq 0x69244(%rip), %r10     # 0x78c0a
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0xeb80
jmp 0xfa1c
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %r8
addq $0x68, %r8
movq -0x18(%rbp), %rax
addq $0x20, %rax
movl $0x3, %edi
leaq 0x671b3(%rip), %rsi     # 0x76bb8
leaq 0x671ed(%rip), %rcx     # 0x76bf9
leaq 0x671f2(%rip), %r9      # 0x76c05
movq %rax, (%rsp)
callq 0xec00
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: davmac314[P]dinit/src/includes/dinit-utmp.h
// Function: log_boot()
inline bool log_boot()
{
    struct utmpx record;
    memset(&record, 0, sizeof(record));
    record.ut_type = BOOT_TIME;

    set_current_time(&record);

    // On FreeBSD, putxline will update all appropriate databases. On Linux, it only updates
    // the utmp database: we need to update the wtmp database explicitly:
#if USE_UPDWTMPX
    updwtmpx(_PATH_WTMPX, &record);
#endif

#if CLEAR_UTMP_ON_BOOT
    truncate(_PATH_UTMPX, 0);
#endif

    setutxent();
    bool success = (pututxline(&record) != NULL);
    endutxent();

    return success;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
leaq -0x180(%rbp), %rdi
xorl %esi, %esi
movl $0x180, %edx            # imm = 0x180
callq 0xa3a0
movw $0x2, -0x180(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x17ce0
leaq 0x670f2(%rip), %rdi     # 0x76cbc
leaq -0x180(%rbp), %rsi
callq 0xaba0
leaq 0x670ed(%rip), %rdi     # 0x76cca
xorl %eax, %eax
movl %eax, %esi
callq 0xa9b0
callq 0xa2e0
leaq -0x180(%rbp), %rdi
callq 0xa0c0
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x181(%rbp)
callq 0xa120
movb -0x181(%rbp), %al
andb $0x1, %al
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
nopl (%rax)
// File: davmac314[P]dinit/src/../dasynq/include/dasynq.h
// Function: dasynq::v2::dprivate::bidi_fd_watcher<dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>>::add_watch(dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>&, int, int, int, int)
void add_watch(event_loop_t &eloop, int fd, int flags, int inprio = DEFAULT_PRIORITY, int outprio = DEFAULT_PRIORITY)
    {
        base_watcher::init();
        this->out_watcher.base_watcher::init();
        this->watch_fd = fd;
        this->watch_flags = flags | dprivate::multi_watch;
        this->read_removed = false;
        this->write_removed = false;
        this->priority = inprio;
        this->set_priority(this->out_watcher, outprio);
        eloop.register_fd(this, fd, flags, true);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x135c0
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x135c0
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, 0x1c(%rdi)
movl -0x18(%rbp), %eax
orl $0x4, %eax
movl %eax, 0x20(%rdi)
movb 0x48(%rdi), %al
andb $-0x2, %al
orb $0x0, %al
movb %al, 0x48(%rdi)
movb 0x48(%rdi), %al
andb $-0x3, %al
orb $0x0, %al
movb %al, 0x48(%rdi)
movl -0x1c(%rbp), %eax
movl %eax, 0x18(%rdi)
addq $0x28, %rdi
movl -0x20(%rbp), %esi
callq 0x13620
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl $0x1, %r8d
callq 0x13640
addq $0x30, %rsp
popq %rbp
retq
// File: davmac314[P]dinit/src/../dasynq/include/dasynq.h
// Function: dasynq::v2::dprivate::bidi_fd_watcher_impl<dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>, control_conn_watcher>::dispatch(void*)
void dispatch(void *loop_ptr) noexcept override
    {
        EventLoop &loop = *static_cast<EventLoop *>(loop_ptr);
        this->emulate_enabled = false;
        loop_access::get_base_lock(loop).unlock();

        auto rearm_type = static_cast<Derived *>(this)->read_ready(loop, this->watch_fd);

        loop_access::get_base_lock(loop).lock();

        if (rearm_type != rearm::REMOVED) {
            this->event_flags &= ~IN_EVENTS;
            this->active = false;
            if (this->deleteme) {
                // We don't want a watch that is marked "deleteme" to re-arm itself.
                rearm_type = rearm::REMOVE;
            }

            rearm_type = loop_access::process_primary_rearm(loop, this, rearm_type);

            auto &outwatcher = bidi_fd_watcher<EventLoop>::out_watcher;
            post_dispatch(loop, this, &outwatcher, rearm_type);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movb 0xc(%rax), %cl
andb $-0x9, %cl
movb %cl, 0xc(%rax)
movq -0x18(%rbp), %rdi
callq 0x11100
movq %rax, %rdi
callq 0x11120
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl 0x1c(%rdi), %edx
callq 0x11980
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11100
movq %rax, %rdi
callq 0x11130
jmp 0x11610
cmpl $0x4, -0x1c(%rbp)
je 0x1167b
movq -0x30(%rbp), %rax
movl 0x24(%rax), %ecx
andl $-0x2, %ecx
movl %ecx, 0x24(%rax)
movb 0xc(%rax), %cl
andb $-0x2, %cl
orb $0x0, %cl
movb %cl, 0xc(%rax)
movb 0xc(%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x11645
movl $0x3, -0x1c(%rbp)
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %edx
callq 0x119b0
movq -0x30(%rbp), %rsi
movl %eax, -0x1c(%rbp)
movq %rsi, %rax
addq $0x28, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x119e0
jmp 0x11679
jmp 0x1167b
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xfa30
nopl (%rax)
// File: davmac314[P]dinit/src/../dasynq/include/dasynq.h
// Function: dasynq::v2::dprivate::bidi_fd_watcher_impl<dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>, control_conn_watcher>::dispatch_second(void*)
void dispatch_second(void *loop_ptr) noexcept override
    {
        auto &outwatcher = bidi_fd_watcher<EventLoop>::out_watcher;

        EventLoop &loop = *static_cast<EventLoop *>(loop_ptr);
        loop_access::get_base_lock(loop).unlock();

        auto rearm_type = static_cast<Derived *>(this)->write_ready(loop, this->watch_fd);

        loop_access::get_base_lock(loop).lock();

        if (rearm_type != rearm::REMOVED) {
            this->event_flags &= ~OUT_EVENTS;
            outwatcher.active = false;
            if (outwatcher.deleteme) {
                // We don't want a watch that is marked "deleteme" to re-arm itself.
                rearm_type = rearm::REMOVE;
            }

            rearm_type = loop_access::process_secondary_rearm(loop, this, &outwatcher, rearm_type);

            if (rearm_type == rearm::REQUEUE) {
                post_dispatch(loop, &outwatcher, rearm_type);
            }
            else {
                post_dispatch(loop, this, &outwatcher, rearm_type);
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x28, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x11100
movq %rax, %rdi
callq 0x11120
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl 0x1c(%rdi), %edx
callq 0x12fd0
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x11100
movq %rax, %rdi
callq 0x11130
jmp 0x116ef
cmpl $0x4, -0x24(%rbp)
je 0x1177b
movq -0x30(%rbp), %rax
movl 0x24(%rax), %ecx
andl $-0x3, %ecx
movl %ecx, 0x24(%rax)
movq -0x18(%rbp), %rax
movb 0xc(%rax), %cl
andb $-0x2, %cl
orb $0x0, %cl
movb %cl, 0xc(%rax)
movq -0x18(%rbp), %rax
movb 0xc(%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x11730
movl $0x3, -0x24(%rbp)
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x13000
movl %eax, -0x24(%rbp)
cmpl $0x5, -0x24(%rbp)
jne 0x11761
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x11170
jmp 0x1175f
jmp 0x11779
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x119e0
jmp 0x11777
jmp 0x11779
jmp 0x1177b
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xfa30
nopl (%rax)
// File: davmac314[P]dinit/src/../dasynq/include/dasynq.h
// Function: void dasynq::v2::dprivate::post_dispatch<dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>>(dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>&, dasynq::v2::dprivate::bidi_fd_watcher<dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>>*, dasynq::v2::dprivate::base_watcher*, dasynq::rearm)
void post_dispatch(Loop &loop, bidi_fd_watcher<Loop> *bdfd_watcher,
            base_watcher *out_watcher, rearm rearm_type)
    {
        base_watcher *watcher = (base_watcher *)bdfd_watcher;
        if (rearm_type == rearm::REMOVE) {
            loop_access::get_base_lock(loop).unlock();
            loop_access::release_watcher(loop, watcher);
            loop_access::release_watcher(loop, out_watcher);
            watcher->watch_removed();
            loop_access::get_base_lock(loop).lock();
        }
        else if (rearm_type == rearm::REQUEUE) {
            loop_access::requeue_watcher(loop, watcher);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x3, -0x1c(%rbp)
jne 0x11a4d
movq -0x8(%rbp), %rdi
callq 0x11100
movq %rax, %rdi
callq 0x11120
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x12e40
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x12e40
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x11100
movq %rax, %rdi
callq 0x11130
jmp 0x11a62
cmpl $0x5, -0x1c(%rbp)
jne 0x11a60
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x11ee0
jmp 0x11a62
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: davmac314[P]dinit/src/includes/control.h
// Function: control_conn_cb(dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>*, control_conn_watcher*, int)
inline dasynq::rearm control_conn_cb(eventloop_t * loop, control_conn_watcher * watcher, int revents)
{
    // Get the address of the containing control_connt_t object:
    _Pragma ("GCC diagnostic push")
    _Pragma ("GCC diagnostic ignored \"-Winvalid-offsetof\"")
    uintptr_t cc_addr = reinterpret_cast<uintptr_t>(watcher) - offsetof(control_conn_t, iob);
    control_conn_t *conn = reinterpret_cast<control_conn_t *>(cc_addr);
    _Pragma ("GCC diagnostic pop")

    if (revents & dasynq::IN_EVENTS) {
        if (conn->data_ready()) {
            delete conn;
            return dasynq::rearm::REMOVED;
        }
    }
    if (revents & dasynq::OUT_EVENTS) {
        if (conn->send_data()) {
            delete conn;
            return dasynq::rearm::REMOVED;
        }
    }
    
    // Accept more commands unless the output buffer high water mark is exceeded
    int watch_flags = 0;
    if (!conn->bad_conn_close && conn->outbuf_size < OUTBUF_LIMIT) {
        watch_flags |= dasynq::IN_EVENTS;
    }
    if (!conn->outbuf.empty() || conn->bad_conn_close) {
        watch_flags |= dasynq::OUT_EVENTS;
    }
    watcher->set_watches(watch_flags);

    return dasynq::rearm::NOOP;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
subq $0x10, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x11b17
movq -0x30(%rbp), %rdi
callq 0x5cc50
testb $0x1, %al
jne 0x11af1
jmp 0x11b15
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x11b09
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl $0x4, -0x4(%rbp)
jmp 0x11bba
jmp 0x11b17
movl -0x1c(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x11b54
movq -0x30(%rbp), %rdi
callq 0x5ce50
testb $0x1, %al
jne 0x11b31
jmp 0x11b52
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x11b49
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl $0x4, -0x4(%rbp)
jmp 0x11bba
jmp 0x11b54
movl $0x0, -0x34(%rbp)
movq -0x30(%rbp), %rax
testb $0x1, 0x78(%rax)
jne 0x11b7e
movq -0x30(%rbp), %rax
cmpl $0x4000, 0x508(%rax)    # imm = 0x4000
jae 0x11b7e
movl -0x34(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
addq $0x4f0, %rdi            # imm = 0x4F0
callq 0x11bd0
testb $0x1, %al
jne 0x11b94
jmp 0x11b9e
movq -0x30(%rbp), %rax
testb $0x1, 0x78(%rax)
je 0x11ba7
movl -0x34(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x11bf0
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: davmac314[P]dinit/src/../dasynq/include/dasynq.h
// Function: dasynq::v2::dprivate::bidi_fd_watcher<dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>>::set_watches(dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>&, int)
void set_watches(event_loop_t &eloop, int new_flags) noexcept
    {
        std::lock_guard<mutex_t> guard(eloop.get_base_lock());
        bool use_emulation = this->emulatefd || this->out_watcher.emulatefd;
        if (use_emulation || EventLoop::loop_traits_t::has_separate_rw_fd_watches) {
            set_watch_enabled(eloop, true, (new_flags & IN_EVENTS) != 0);
            set_watch_enabled(eloop, false, (new_flags & OUT_EVENTS) != 0);
        }
        else {
            this->watch_flags = (this->watch_flags & ~IO_EVENTS) | new_flags;
            eloop.set_fd_enabled_nolock((dprivate::base_watcher *) this, this->watch_fd, this->watch_flags & IO_EVENTS, true);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x111e0
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x11d10
jmp 0x11c52
movq -0x30(%rbp), %rax
movb 0xc(%rax), %al
shrb $0x2, %al
andb $0x1, %al
movzbl %al, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
jne 0x11c83
movq -0x30(%rbp), %rax
movb 0x34(%rax), %al
shrb $0x2, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
movb %al, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
je 0x11cc6
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %ecx
andl $0x1, %ecx
movl $0x1, %edx
callq 0x11d40
jmp 0x11cab
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %ecx
andl $0x2, %ecx
shrl %ecx
xorl %edx, %edx
callq 0x11d40
jmp 0x11cc4
jmp 0x11cee
movq -0x30(%rbp), %rsi
movl 0x20(%rsi), %eax
andl $-0x4, %eax
orl -0x14(%rbp), %eax
movl %eax, 0x20(%rsi)
movq -0x10(%rbp), %rdi
movl 0x1c(%rsi), %edx
movl 0x20(%rsi), %ecx
andl $0x3, %ecx
movl $0x1, %r8d
callq 0x11e60
leaq -0x20(%rbp), %rdi
callq 0x11ec0
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xfa30
nopw %cs:(%rax,%rax)
nop