LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/nickgammon[P]tinymudserver/commands.cpp
// Function: DoDirection(tPlayer*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void DoDirection (tPlayer * p, const string & sArgs)
  {
  // get current room (throws exception if not there)
  tRoom * r = FindRoom (p->room);

  // find the exit
 tExitMap::const_iterator exititer = r->exits.find (sArgs);    

  if (exititer == r->exits.end ())
    throw runtime_error ("You cannot go that way.");

  // move player
  PlayerToRoom (p, exititer->second,
                "You go " + sArgs + "\n",
                p->playername + " goes " + sArgs + "\n",
                p->playername + " enters.\n");
  
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %r15
movq %rdi, %rbx
addq $0xd4, %rdi
callq 0xc574
movq %rax, %r12
leaq 0x20(%rax), %rdi
movq %r15, %rsi
callq 0x9b56
addq $0x28, %r12
cmpq %r12, %rax
je 0x7ad9
movq %rax, %r14
leaq 0x59c6(%rip), %rsi      # 0xd3b3
leaq -0xe0(%rbp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0x90f3
leaq 0x56ce(%rip), %rdx      # 0xd0d4
leaq -0xc0(%rbp), %rdi
movq %r12, %rsi
callq 0x6851
leaq 0x90(%rbx), %r12
leaq 0x5998(%rip), %rdx      # 0xd3bb
leaq -0x60(%rbp), %rdi
movq %r12, %rsi
callq 0x9169
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movq %r15, %rdx
callq 0x53f1
leaq 0x568e(%rip), %rdx      # 0xd0d4
leaq -0xa0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x6851
leaq 0x5965(%rip), %rdx      # 0xd3c2
leaq -0x40(%rbp), %rdi
movq %r12, %rsi
callq 0x9169
addq $0x40, %r14
leaq -0xc0(%rbp), %rdx
leaq -0xa0(%rbp), %rcx
leaq -0x40(%rbp), %r8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x78f3
leaq -0x40(%rbp), %rdi
callq 0x35c8
leaq -0xa0(%rbp), %rdi
callq 0x35c8
leaq -0x80(%rbp), %rdi
callq 0x35c8
leaq -0x60(%rbp), %rdi
callq 0x35c8
leaq -0xc0(%rbp), %rdi
callq 0x35c8
leaq -0xe0(%rbp), %rdi
callq 0x35c8
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x31b0
movq %rax, %r14
leaq 0x58b0(%rip), %rsi      # 0xd39b
movq %rax, %rdi
callq 0x3140
movq 0xc4f6(%rip), %rsi      # 0x13ff0
movq 0xc4b7(%rip), %rdx      # 0x13fb8
movq %r14, %rdi
callq 0x34e0
movq %rax, %rbx
movq %r14, %rdi
callq 0x3270
jmp 0x7b6c
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x35c8
jmp 0x7b27
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x35c8
jmp 0x7b38
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x35c8
jmp 0x7b46
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x35c8
jmp 0x7b54
movq %rax, %rbx
leaq -0xc0(%rbp), %rdi
callq 0x35c8
leaq -0xe0(%rbp), %rdi
callq 0x35c8
movq %rbx, %rdi
callq 0x3500
movq %rax, %rbx
jmp 0x7b60
// File: /workspace/github_cpp_makefile_star2_O2/nickgammon[P]tinymudserver/commands.cpp
// Function: DoQuit(tPlayer*, std::istream&)
void DoQuit (tPlayer * p, istream & sArgs)
  {
  NoMore (p, sArgs);  // check no more input
    
  /* if s/he finished connecting, tell others s/he has left */
  
  if (p->connstate == ePlaying)
    {
    *p << "See you next time!\n";
    cout << "Player " << p->playername << " has left the game.\n";
    SendToAll ("Player " + p->playername + " has left the game.\n", p);   
    } /* end of properly connected */

  p->ClosePlayer ();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
callq 0x76d4
cmpl $0x5, 0x68(%rbx)
jne 0x7c26
leaq 0x5829(%rip), %rsi      # 0xd3cc
movq %rbx, %rdi
callq 0x91a2
movq 0xc40e(%rip), %rdi      # 0x13fc0
leaq 0x555c(%rip), %r14      # 0xd115
movq %r14, %rsi
callq 0x3310
leaq 0x90(%rbx), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x32e0
leaq 0x5806(%rip), %r12      # 0xd3e0
movq %rax, %rdi
movq %r12, %rsi
callq 0x3310
leaq -0x68(%rbp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x90f3
leaq -0x48(%rbp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x6851
leaq -0x48(%rbp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x52eb
leaq -0x48(%rbp), %rdi
callq 0x35c8
leaq -0x68(%rbp), %rdi
callq 0x35c8
movb $0x1, 0xd8(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x35c8
jmp 0x7c4d
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x35c8
movq %rbx, %rdi
callq 0x3500
// File: /workspace/github_cpp_makefile_star2_O2/nickgammon[P]tinymudserver/commands.cpp
// Function: DoSay(tPlayer*, std::istream&)
void DoSay (tPlayer * p, istream & sArgs)
{
  p->NeedNoFlag ("gagged"); // can't if gagged
  string what = GetMessage (sArgs, "Say what?");  // what
  *p << "You say, \"" << what << "\"\n";  // confirm
  SendToAll (p->playername + " says, \"" + what + "\"\n", 
            p, p->room);  // say it
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x55e2(%rip), %rsi      # 0xd41e
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x43b6
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x4fbc
leaq -0x50(%rbp), %rdi
callq 0x35c8
leaq 0x55c0(%rip), %rsi      # 0xd425
leaq -0x30(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0x43b6
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
movq %r14, %rsi
callq 0x7793
leaq -0x30(%rbp), %rdi
callq 0x35c8
leaq 0x559d(%rip), %rsi      # 0xd42f
movq %rbx, %rdi
callq 0x9592
leaq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0x5e24
leaq 0x558d(%rip), %rsi      # 0xd43a
movq %rax, %rdi
callq 0x94ea
leaq 0x90(%rbx), %rsi
leaq 0x557a(%rip), %rdx      # 0xd43d
leaq -0x90(%rbp), %rdi
callq 0x9169
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x53f1
leaq 0x5550(%rip), %rdx      # 0xd43a
leaq -0x30(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x6851
movl 0xd4(%rbx), %edx
leaq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x52eb
leaq -0x30(%rbp), %rdi
callq 0x35c8
leaq -0x70(%rbp), %rdi
callq 0x35c8
leaq -0x90(%rbp), %rdi
callq 0x35c8
leaq -0x50(%rbp), %rdi
callq 0x35c8
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x35c8
jmp 0x7f4d
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x35c8
jmp 0x7f5b
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x35c8
jmp 0x7f80
jmp 0x7f7d
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
jmp 0x7f84
jmp 0x7f78
jmp 0x7f7d
movq %rax, %rbx
jmp 0x7f89
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x35c8
movq %rbx, %rdi
callq 0x3500
// File: /workspace/github_cpp_makefile_star2_O2/nickgammon[P]tinymudserver/commands.cpp
// Function: DoTell(tPlayer*, std::istream&)
void DoTell (tPlayer * p, istream & sArgs)
{
  p->NeedNoFlag ("gagged"); // can't if gagged
  tPlayer * ptarget = p->GetPlayer (sArgs, "Tell whom?", true);  // who
  string what = GetMessage (sArgs, "Tell " + p->playername + " what?");  // what  
  *p << "You tell " << ptarget->playername << ", \"" << what << "\"\n";     // confirm
  *ptarget << p->playername << " tells you, \"" << what << "\"\n";    // tell them
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r12
movq %rdi, %r14
leaq 0x546f(%rip), %rsi      # 0xd41e
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x43b6
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x4fbc
leaq -0x48(%rbp), %rdi
callq 0x35c8
leaq 0x546e(%rip), %rsi      # 0xd446
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x43b6
leaq -0x88(%rbp), %rcx
movb $0x1, (%rcx)
leaq -0x48(%rbp), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x4968
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x35c8
leaq 0x90(%r14), %r15
leaq 0x5439(%rip), %rsi      # 0xd451
leaq -0x88(%rbp), %r13
movq %r13, %rdi
movq %r15, %rdx
callq 0x90f3
leaq 0x5460(%rip), %rdx      # 0xd491
leaq -0x68(%rbp), %rdi
movq %r13, %rsi
callq 0x6851
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rdx
movq %r12, %rsi
callq 0x7793
leaq -0x68(%rbp), %rdi
callq 0x35c8
leaq -0x88(%rbp), %rdi
callq 0x35c8
leaq 0x53ee(%rip), %rsi      # 0xd457
movq %r14, %rdi
callq 0x963a
leaq 0x90(%rbx), %rsi
movq %rax, %rdi
callq 0x5e24
leaq 0x5401(%rip), %rsi      # 0xd488
movq %rax, %rdi
callq 0x96e2
leaq -0x48(%rbp), %rsi
movq %rax, %rdi
callq 0x5e24
leaq 0x5398(%rip), %rsi      # 0xd43a
movq %rax, %rdi
callq 0x94ea
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5e24
leaq 0x53a5(%rip), %rsi      # 0xd461
movq %rax, %rdi
callq 0x9442
leaq -0x48(%rbp), %rsi
movq %rax, %rdi
callq 0x5e24
leaq 0x5363(%rip), %rsi      # 0xd43a
movq %rax, %rdi
callq 0x94ea
leaq -0x48(%rbp), %rdi
callq 0x35c8
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x35c8
jmp 0x8108
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
jmp 0x8123
jmp 0x811c
jmp 0x8117
jmp 0x811c
movq %rax, %rbx
jmp 0x8128
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x35c8
movq %rbx, %rdi
callq 0x3500
// File: /workspace/github_cpp_makefile_star2_O2/nickgammon[P]tinymudserver/commands.cpp
// Function: DoWho(tPlayer*, std::istream&)
void DoWho (tPlayer * p, istream & sArgs)
{
  NoMore (p, sArgs);  // check no more input
  *p << "Connected players ...\n";
  
  int count = 0;
  for (tPlayerListIterator iter = playerlist.begin ();
       iter != playerlist.end ();
       ++iter)
    {
    tPlayer * pTarget = *iter;    // the player  
    if (pTarget->IsPlaying ())
      {
      *p << "  " << pTarget->playername << 
            " in room " << pTarget->room << "\n";
      ++count;
      } // end of if playing
    } // end of doing each player
  
  *p << count << " player(s)\n";  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x76d4
leaq 0x50d0(%rip), %rsi      # 0xd498
movq %rbx, %rdi
callq 0x978a
leaq 0xc439(%rip), %r12      # 0x14810
xorl %r14d, %r14d
movq %r12, %r15
movq (%r15), %r15
cmpq %r12, %r15
je 0x8448
movq 0x10(%r15), %r13
movq %r13, %rdi
callq 0x5750
testb %al, %al
je 0x83dd
movq %rbx, %rdi
leaq 0x556e(%rip), %rsi      # 0xd96d
callq 0x94ea
leaq 0x90(%r13), %rsi
movq %rax, %rdi
callq 0x5e24
movq %rax, %rdi
leaq 0x5092(%rip), %rsi      # 0xd4af
callq 0x963a
addq $0xd4, %r13
movq %rax, %rdi
movq %r13, %rsi
callq 0x9832
movq %rax, %rdi
leaq 0x4c96(%rip), %rsi      # 0xd0d4
callq 0x92f2
incl %r14d
jmp 0x83dd
leaq -0x2c(%rbp), %rsi
movl %r14d, (%rsi)
movq %rbx, %rdi
callq 0x9832
leaq 0x505b(%rip), %rsi      # 0xd4b9
movq %rax, %rdi
callq 0x98da
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/nickgammon[P]tinymudserver/commands.cpp
// Function: DoSetFlag(tPlayer*, std::istream&)
void DoSetFlag (tPlayer * p, istream & sArgs)
{
  p->NeedFlag ("can_setflag");  // permissions
  tPlayer * ptarget = p->GetPlayer (sArgs, "Usage: setflag <who> <flag>");  // who
  string flag = GetFlag (sArgs, "Set which flag?"); // what
  NoMore (p, sArgs);  // check no more input
  if (ptarget->flags.find (flag) != ptarget->flags.end ())    // check not set
    throw runtime_error ("Flag already set.");
  
  ptarget->flags.insert (flag);   // set it
  *p << "You set the flag '" << flag << "' for " << ptarget->playername << "\n";  // confirm
      
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x5036(%rip), %rsi      # 0xd4c5
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x43b6
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x4f64
leaq -0x40(%rbp), %rdi
callq 0x35c8
leaq 0x5019(%rip), %rsi      # 0xd4d1
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x43b6
leaq -0x19(%rbp), %rcx
movb $0x0, (%rcx)
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4968
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x35c8
leaq 0x4fff(%rip), %rsi      # 0xd4ed
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x43b6
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rdx
movq %r15, %rsi
callq 0x782a
leaq -0x60(%rbp), %rdi
callq 0x35c8
movq %r15, %rsi
callq 0x76d4
leaq 0xe0(%r14), %r15
leaq -0x40(%rbp), %rsi
movq %r15, %rdi
callq 0x5c3e
leaq 0xe8(%r14), %rcx
cmpq %rcx, %rax
jne 0x85a6
leaq -0x40(%rbp), %rsi
movq %r15, %rdi
callq 0x580c
leaq 0x4fc1(%rip), %rsi      # 0xd50f
movq %rbx, %rdi
callq 0x924a
leaq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0x5e24
leaq 0x4fb9(%rip), %rsi      # 0xd522
movq %rax, %rdi
callq 0x9982
addq $0x90, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x5e24
leaq 0x4b4a(%rip), %rsi      # 0xd0d4
movq %rax, %rdi
callq 0x92f2
leaq -0x40(%rbp), %rdi
callq 0x35c8
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x31b0
movq %rax, %r14
leaq 0x4f45(%rip), %rsi      # 0xd4fd
movq %rax, %rdi
callq 0x3140
movq 0xba29(%rip), %rsi      # 0x13ff0
movq 0xb9ea(%rip), %rdx      # 0x13fb8
movq %r14, %rdi
callq 0x34e0
movq %rax, %rbx
movq %r14, %rdi
callq 0x3270
jmp 0x85fe
jmp 0x85fb
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
jmp 0x8602
jmp 0x85f6
jmp 0x85fb
jmp 0x85f6
jmp 0x85fb
movq %rax, %rbx
jmp 0x8607
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x35c8
movq %rbx, %rdi
callq 0x3500
// File: /workspace/github_cpp_makefile_star2_O2/nickgammon[P]tinymudserver/commands.cpp
// Function: DoClearFlag(tPlayer*, std::istream&)
void DoClearFlag (tPlayer * p, istream & sArgs)
{
  p->NeedFlag ("can_setflag");  // permissions
  tPlayer * ptarget = p->GetPlayer (sArgs, "Usage: clearflag <who> <flag>");  // who
  string flag = GetFlag (sArgs, "Clear which flag?"); // what
  NoMore (p, sArgs);  // check no more input
  if (ptarget->flags.find (flag) == ptarget->flags.end ())    // check set
    throw runtime_error ("Flag not set.");

  ptarget->flags.erase (flag);    // clear it
  *p << "You clear the flag '" << flag << "' for " << ptarget->playername << "\n";  // confirm
      
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x4e9c(%rip), %rsi      # 0xd4c5
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x43b6
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x4f64
leaq -0x40(%rbp), %rdi
callq 0x35c8
leaq 0x4ed7(%rip), %rsi      # 0xd529
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x43b6
leaq -0x19(%rbp), %rcx
movb $0x0, (%rcx)
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4968
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x35c8
leaq 0x4ebf(%rip), %rsi      # 0xd547
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x43b6
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rdx
movq %r15, %rsi
callq 0x782a
leaq -0x60(%rbp), %rdi
callq 0x35c8
movq %r15, %rsi
callq 0x76d4
leaq 0xe0(%r14), %r15
leaq -0x40(%rbp), %rsi
movq %r15, %rdi
callq 0x5c3e
leaq 0xe8(%r14), %rcx
cmpq %rcx, %rax
je 0x8740
leaq -0x40(%rbp), %rsi
movq %r15, %rdi
callq 0x9b9e
leaq 0x4e7f(%rip), %rsi      # 0xd567
movq %rbx, %rdi
callq 0x9a2a
leaq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0x5e24
leaq 0x4e1f(%rip), %rsi      # 0xd522
movq %rax, %rdi
callq 0x9982
addq $0x90, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x5e24
leaq 0x49b0(%rip), %rsi      # 0xd0d4
movq %rax, %rdi
callq 0x92f2
leaq -0x40(%rbp), %rdi
callq 0x35c8
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x31b0
movq %rax, %r14
leaq 0x4e07(%rip), %rsi      # 0xd559
movq %rax, %rdi
callq 0x3140
movq 0xb88f(%rip), %rsi      # 0x13ff0
movq 0xb850(%rip), %rdx      # 0x13fb8
movq %r14, %rdi
callq 0x34e0
movq %rax, %rbx
movq %r14, %rdi
callq 0x3270
jmp 0x8798
jmp 0x8795
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
jmp 0x879c
jmp 0x8790
jmp 0x8795
jmp 0x8790
jmp 0x8795
movq %rax, %rbx
jmp 0x87a1
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x35c8
movq %rbx, %rdi
callq 0x3500
// File: /workspace/github_cpp_makefile_star2_O2/nickgammon[P]tinymudserver/commands.cpp
// Function: DoShutdown(tPlayer*, std::istream&)
void DoShutdown (tPlayer * p, istream & sArgs)
{
  NoMore (p, sArgs);  // check no more input
  p->NeedFlag ("can_shutdown");
  SendToAll (p->playername + " shuts down the game\n");
  bStopNow = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0x76d4
leaq 0x4db9(%rip), %rsi      # 0xd57c
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x43b6
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x4f64
leaq -0x38(%rbp), %rdi
callq 0x35c8
addq $0x90, %rbx
leaq 0x4d96(%rip), %rdx      # 0xd589
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9169
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x52eb
leaq -0x38(%rbp), %rdi
callq 0x35c8
leaq 0xbfe2(%rip), %rax      # 0x14800
movb $0x1, (%rax)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x882c
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x35c8
jmp 0x883d
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3500
// File: /workspace/github_cpp_makefile_star2_O2/nickgammon[P]tinymudserver/commands.cpp
// Function: DoGoTo(tPlayer*, std::istream&)
void DoGoTo (tPlayer * p, istream & sArgs)
  {
  p->NeedFlag ("can_goto");

  int room;
  sArgs >> room;
  
  // check room number supplied OK
  if (sArgs.fail ())
    throw runtime_error ("Go to which room?");

  NoMore (p, sArgs);  // check no more input

  // move player
  PlayerToRoom (p, room,
                MAKE_STRING ("You go to room " << room << "\n"),
                p->playername + " disappears in a puff of smoke!\n",
                p->playername + " appears in a puff of smoke!\n");
  
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4cda(%rip), %rsi      # 0xd5a4
leaq -0x1f0(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x43b6
leaq -0x1f0(%rbp), %rsi
movq %rbx, %rdi
callq 0x4f64
leaq -0x1f0(%rbp), %rdi
callq 0x35c8
leaq -0x14(%rbp), %rsi
movq %r14, %rdi
callq 0x3210
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
jne 0x89f3
movq %r14, %rsi
callq 0x76d4
leaq -0x1f0(%rbp), %r14
movq %r14, %rdi
callq 0x33f0
movq (%r14), %rax
movq -0x18(%rax), %rax
orl $0x1, -0x1d8(%rbp,%rax)
leaq 0x4c7e(%rip), %rsi      # 0xd5bf
movq %r14, %rdi
callq 0x3310
movl -0x14(%rbp), %esi
leaq -0x1f0(%rbp), %rdi
callq 0x34f0
leaq 0x4775(%rip), %rsi      # 0xd0d4
leaq -0x1f0(%rbp), %rdi
callq 0x3310
leaq -0x1e8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x3470
leaq 0x90(%rbx), %r14
leaq 0x4c46(%rip), %rdx      # 0xd5cf
leaq -0x78(%rbp), %rdi
movq %r14, %rsi
callq 0x9169
leaq 0x4c54(%rip), %rdx      # 0xd5f0
leaq -0x58(%rbp), %rdi
movq %r14, %rsi
callq 0x9169
leaq -0x14(%rbp), %rsi
leaq -0x38(%rbp), %rdx
leaq -0x78(%rbp), %rcx
leaq -0x58(%rbp), %r8
movq %rbx, %rdi
callq 0x78f3
leaq -0x58(%rbp), %rdi
callq 0x35c8
leaq -0x78(%rbp), %rdi
callq 0x35c8
leaq -0x38(%rbp), %rdi
callq 0x35c8
leaq -0x1f0(%rbp), %rdi
callq 0x30b0
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x31b0
movq %rax, %r14
leaq 0x4ba8(%rip), %rsi      # 0xd5ad
movq %rax, %rdi
callq 0x3140
movq 0xb5dc(%rip), %rsi      # 0x13ff0
movq 0xb59d(%rip), %rdx      # 0x13fb8
movq %r14, %rdi
callq 0x34e0
movq %rax, %rbx
movq %r14, %rdi
callq 0x3270
jmp 0x8a7f
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x35c8
jmp 0x8a41
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x35c8
jmp 0x8a4f
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x35c8
jmp 0x8a73
movq %rax, %rbx
leaq -0x1f0(%rbp), %rdi
callq 0x35c8
jmp 0x8a7f
movq %rax, %rbx
jmp 0x8a7f
movq %rax, %rbx
leaq -0x1f0(%rbp), %rdi
callq 0x30b0
movq %rbx, %rdi
callq 0x3500
// File: /workspace/github_cpp_makefile_star2_O2/nickgammon[P]tinymudserver/commands.cpp
// Function: DoTransfer(tPlayer*, std::istream&)
void DoTransfer (tPlayer * p, istream & sArgs)
{
  p->NeedFlag ("can_transfer");  // permissions
  tPlayer * ptarget = p->GetPlayer (sArgs, 
    "Usage: transfer <who> [ where ] (default is here)", true);  // who
  int room;
  sArgs >> room;
  
  if (sArgs.fail ())
    room = p->room;   // if no room number, transfer to our room
  
  NoMore (p, sArgs);  // check no more input  

  *p << "You transfer " <<  ptarget->playername << " to room " << room << "\n";
  
   // move player
  PlayerToRoom (ptarget, room,
                p->playername + " transfers you to another room!\n",
                ptarget->playername + " is yanked away by unseen forces!\n",
                ptarget->playername + " appears breathlessly!\n");
     
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x4b6b(%rip), %rsi      # 0xd60e
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x43b6
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x4f64
leaq -0x48(%rbp), %rdi
callq 0x35c8
leaq 0x4b4f(%rip), %rsi      # 0xd61b
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x43b6
leaq -0x88(%rbp), %rcx
movb $0x1, (%rcx)
leaq -0x48(%rbp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4968
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x35c8
leaq -0x24(%rbp), %rsi
movq %r15, %rdi
callq 0x3210
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r15,%rax)
je 0x8b22
movl 0xd4(%rbx), %eax
movl %eax, -0x24(%rbp)
movq %r15, %rsi
callq 0x76d4
leaq 0x4b1c(%rip), %rsi      # 0xd64d
movq %rbx, %rdi
callq 0x9442
movl $0x90, %r12d
leaq (%r14,%r12), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x5e24
leaq 0x4a70(%rip), %rsi      # 0xd5c5
movq %rax, %rdi
callq 0x963a
leaq -0x24(%rbp), %rsi
movq %rax, %rdi
callq 0x9832
leaq 0x4564(%rip), %rsi      # 0xd0d4
movq %rax, %rdi
callq 0x92f2
addq %r12, %rbx
leaq 0x4ad9(%rip), %rdx      # 0xd65b
leaq -0x48(%rbp), %rdi
movq %rbx, %rsi
callq 0x9169
leaq 0x4ae7(%rip), %rdx      # 0xd67c
leaq -0x68(%rbp), %rdi
movq %r15, %rsi
callq 0x9169
leaq 0x4af7(%rip), %rdx      # 0xd69f
leaq -0x88(%rbp), %rdi
movq %r15, %rsi
callq 0x9169
leaq -0x24(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0x68(%rbp), %rcx
leaq -0x88(%rbp), %r8
movq %r14, %rdi
callq 0x78f3
leaq -0x88(%rbp), %rdi
callq 0x35c8
leaq -0x68(%rbp), %rdi
callq 0x35c8
leaq -0x48(%rbp), %rdi
callq 0x35c8
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x35c8
jmp 0x8c11
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x35c8
jmp 0x8c25
jmp 0x8c22
jmp 0x8c22
jmp 0x8c30
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x35c8
jmp 0x8c33
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3500
// File: /workspace/github_cpp_makefile_star2_O2/nickgammon[P]tinymudserver/commands.cpp
// Function: ProcessCommand(tPlayer*, std::istream&)
void ProcessCommand (tPlayer * p, istream & sArgs)
{

  string command;
  sArgs >> command >> ws;   // get command, eat whitespace after it
  
  // first see if they have entered a movement command (eg. n, s, e, w)
  set<string>::const_iterator direction_iter = directionset.find (command);
  if (direction_iter != directionset.end ())
    DoDirection (p, command);
  else
    {
    // otherwise, look up command in commands map  
    map<string, tHandler>::const_iterator command_iter = commandmap.find (command);
    if (command_iter == commandmap.end ())
       throw runtime_error ("Huh?");      // don't get it
 
    command_iter->second (p, sArgs);  // execute command (eg. DoLook)
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0x33c0
movq %rax, %rdi
callq 0x32b0
leaq 0xbc6f(%rip), %r15      # 0x148e8
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x5c3e
addq $0x8, %r15
cmpq %r15, %rax
je 0x8c9c
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x79a3
jmp 0x8cc1
leaq 0xbbb5(%rip), %r15      # 0x14858
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x9d4e
addq $0x8, %r15
cmpq %r15, %rax
je 0x8cd5
movq %rbx, %rdi
movq %r14, %rsi
callq *0x40(%rax)
leaq -0x38(%rbp), %rdi
callq 0x35c8
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x31b0
movq %rax, %r14
leaq 0x49d0(%rip), %rsi      # 0xd6b7
movq %rax, %rdi
callq 0x3140
movq 0xb2fa(%rip), %rsi      # 0x13ff0
movq 0xb2bb(%rip), %rdx      # 0x13fb8
movq %r14, %rdi
callq 0x34e0
movq %rax, %rbx
movq %r14, %rdi
callq 0x3270
jmp 0x8d1b
jmp 0x8d18
jmp 0x8d18
jmp 0x8d18
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x35c8
movq %rbx, %rdi
callq 0x3500
// File: /workspace/github_cpp_makefile_star2_O2/nickgammon[P]tinymudserver/states.cpp
// Function: PlayerEnteredGame(tPlayer*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void PlayerEnteredGame (tPlayer * p, const string & message)
{
  p->connstate = ePlaying;    // now normal player
  p->prompt = PROMPT;         // default prompt
  *p << "Welcome, " << p->playername << "\n\n"; // greet them
  *p << message;
  *p << messagemap ["motd"];  // message of the day
  p->DoCommand ("look");     // new player looks around

  // tell other players
  SendToAll (
    "Player " + p->playername + " has joined the game from " + p->GetAddress () + ".\n", 
    p);
  
  // log it
  cout << "Player " << p->playername << " has joined the game." << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x5, 0x68(%rdi)
addq $0x70, %rdi
leaq 0xa4ec(%rip), %rsi      # 0x146c0
callq 0x31d0
leaq 0x3503(%rip), %rsi      # 0xd6e3
movq %r14, %rdi
callq 0x963a
leaq 0x90(%r14), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5e24
leaq 0x2ed2(%rip), %rsi      # 0xd0d3
movq %rax, %rdi
callq 0x94ea
movq %r14, %rdi
movq %r15, %rsi
callq 0x5e24
leaq 0x34d2(%rip), %rsi      # 0xd6ed
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x43b6
leaq 0xa689(%rip), %rdi      # 0x148b8
leaq -0x38(%rbp), %rsi
callq 0x6792
movq %r14, %rdi
movq %rax, %rsi
callq 0x5e24
leaq -0x38(%rbp), %rdi
callq 0x35c8
leaq 0x3143(%rip), %rsi      # 0xd396
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x43b6
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0x4edc
leaq -0x38(%rbp), %rdi
callq 0x35c8
leaq 0x2e99(%rip), %rsi      # 0xd115
leaq -0xb8(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rdx
callq 0x90f3
leaq 0x345d(%rip), %rdx      # 0xd6f2
leaq -0x98(%rbp), %rdi
movq %r15, %rsi
callq 0x6851
leaq 0x48(%r14), %rsi
leaq -0x78(%rbp), %rdi
callq 0x3400
leaq -0x58(%rbp), %rdi
leaq -0x98(%rbp), %rsi
leaq -0x78(%rbp), %rdx
callq 0xae74
leaq 0x2db3(%rip), %rdx      # 0xd07f
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x6851
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x52eb
leaq -0x38(%rbp), %rdi
callq 0x35c8
leaq -0x58(%rbp), %rdi
callq 0x35c8
leaq -0x78(%rbp), %rdi
callq 0x35c8
leaq -0x98(%rbp), %rdi
callq 0x35c8
leaq -0xb8(%rbp), %rdi
callq 0x35c8
movq 0x9c9f(%rip), %rdi      # 0x13fc0
leaq 0x2ded(%rip), %rsi      # 0xd115
callq 0x3310
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32e0
leaq 0x33ce(%rip), %rsi      # 0xd70d
movq %rax, %rdi
callq 0x3310
movq %rax, %rdi
callq 0x31a0
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x35c8
jmp 0xa36e
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x35c8
jmp 0xa37c
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x35c8
jmp 0xa38a
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x35c8
jmp 0xa39b
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
jmp 0xa3b4
jmp 0xa3ad
jmp 0xa3a8
movq %rax, %rbx
jmp 0xa3b9
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x35c8
movq %rbx, %rdi
callq 0x3500
// File: /workspace/github_cpp_makefile_star2_O2/nickgammon[P]tinymudserver/states.cpp
// Function: ProcessNewPassword(tPlayer*, std::istream&)
void ProcessNewPassword (tPlayer * p, istream & sArgs)
{
   string password;
   sArgs >> password;
  
  /* password can't be blank */
  if (password.empty ())
    throw runtime_error ("Password cannot be blank.");
  
  p->password = password;
  p->connstate = eConfirmPassword;
  p->prompt = "Re-enter password to confirm it ... ";
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq -0x20(%rbp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x33c0
cmpq $0x0, -0x28(%rbp)
je 0xa8e4
leaq 0xb0(%rbx), %rdi
leaq -0x30(%rbp), %rsi
callq 0x31d0
movl $0x4, 0x68(%rbx)
addq $0x70, %rbx
leaq 0x2f8a(%rip), %rsi      # 0xd854
movq %rbx, %rdi
callq 0x3580
leaq -0x30(%rbp), %rdi
callq 0x35c8
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x31b0
movq %rax, %rbx
leaq 0x2f44(%rip), %rsi      # 0xd83a
movq %rax, %rdi
callq 0x3140
movq 0x96eb(%rip), %rsi      # 0x13ff0
movq 0x96ac(%rip), %rdx      # 0x13fb8
movq %rbx, %rdi
callq 0x34e0
movq %rax, %r14
movq %rbx, %rdi
callq 0x3270
jmp 0xa924
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x35c8
movq %r14, %rdi
callq 0x3500
// File: /workspace/github_cpp_makefile_star2_O2/nickgammon[P]tinymudserver/states.cpp
// Function: LoadStates()
void LoadStates ()
{

// connection states
  statemap [eAwaitingName]        = ProcessPlayerName;    // existing player
  statemap [eAwaitingPassword]    = ProcessPlayerPassword;

  statemap [eAwaitingNewName]     = ProcessNewPlayerName; // new player
  statemap [eAwaitingNewPassword] = ProcessNewPassword;
  statemap [eConfirmPassword]     = ProcessConfirmPassword;

  statemap [ePlaying]             = ProcessCommand;   // playing

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq -0x14(%rbp), %r14
andl $0x0, (%r14)
leaq 0x9abf(%rip), %rbx      # 0x14888
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb014
leaq -0xa1a(%rip), %rcx      # 0xa3c1
movq %rcx, (%rax)
movl $0x1, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb014
leaq -0x22e(%rip), %rcx      # 0xabc9
movq %rcx, (%rax)
movl $0x2, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb014
leaq -0x871(%rip), %rcx      # 0xa5a2
movq %rcx, (%rax)
movl $0x3, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb014
leaq -0x5bb(%rip), %rcx      # 0xa874
movq %rcx, (%rax)
movl $0x4, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb014
leaq -0x516(%rip), %rcx      # 0xa935
movq %rcx, (%rax)
movl $0x5, (%r14)
leaq -0x14(%rbp), %rsi
movq %rbx, %rdi
callq 0xb014
leaq -0x222d(%rip), %rcx     # 0x8c3b
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/nickgammon[P]tinymudserver/./player.h
// Function: tPlayer::Init()
void Init ()
    {
    connstate = eAwaitingName;
    room = INITIAL_ROOM;
    flags.clear ();
    prompt = "Enter your name, or 'new' to create a new character ...  "; 
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
andl $0x0, 0x68(%rdi)
movl $0x3e8, 0xd4(%rdi)      # imm = 0x3E8
addq $0xe0, %rdi
callq 0x5770
addq $0x70, %rbx
leaq 0x2930(%rip), %rsi      # 0xd936
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3580
// File: /workspace/github_cpp_makefile_star2_O2/nickgammon[P]tinymudserver/comms.cpp
// Function: CloseComms()
void CloseComms ()
  {

  cerr << "Closing all comms connections." << endl;

  // close listening socket
  if (iControl != NO_SOCKET)
    close (iControl);

  // delete all players - this will close connections
  for_each (playerlist.begin (), playerlist.end (), DeleteObject ());

  // delete all rooms
  for_each (roommap.begin (), roommap.end (), DeleteMapObject ());
 
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x87a6(%rip), %rdi      # 0x13fe8
leaq 0x21db(%rip), %rsi      # 0xda24
callq 0x3310
movq %rax, %rdi
callq 0x31a0
leaq 0x8aa3(%rip), %rax      # 0x14300
movl (%rax), %edi
cmpl $-0x1, %edi
je 0xb869
callq 0x35a0
leaq 0x8fa0(%rip), %rsi      # 0x14810
movq (%rsi), %rdi
callq 0xbd83
leaq 0x8fa9(%rip), %rsi      # 0x14828
movq 0x18(%rsi), %rdi
addq $0x8, %rsi
popq %rbp
jmp 0xbdb8
// File: /workspace/github_cpp_makefile_star2_O2/nickgammon[P]tinymudserver/comms.cpp
// Function: RemoveInactivePlayers()
void RemoveInactivePlayers ()
{
  for (tPlayerListIterator i = playerlist.begin (); i != playerlist.end (); )
    {
    if (!(*i)->Connected () ||        // no longer connected
         (*i)->closing)               // or about to leave us
      {
      delete *i;
      playerlist.erase (i++);
      }
    else
      ++i;
    } /* end of looping through players */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x8cdf(%rip), %rbx      # 0x14810
movq (%rbx), %r14
cmpq %rbx, %r14
je 0xbb7a
movq 0x10(%r14), %r15
cmpl $-0x1, (%r15)
je 0xbb4d
cmpb $0x1, 0xd8(%r15)
jne 0xbb75
movq %r15, %rdi
callq 0xbffc
movl $0x110, %esi            # imm = 0x110
movq %r15, %rdi
callq 0x3330
movq (%r14), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc07e
movq %r15, %r14
jmp 0xbb34
movq (%r14), %r14
jmp 0xbb34
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/nickgammon[P]tinymudserver/comms.cpp
// Function: ProcessPlayerInput(tPlayer*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ProcessPlayerInput (tPlayer * p, const string & s)
{
   try
    {
    istringstream is (s);
              
    // look up what to do in state map  
    map<tConnectionStates, tHandler>::iterator si = statemap.find (p->connstate);
  
    if (si != statemap.end ())
      si->second (p, is);  // execute command (eg. ProcessCommand) 
    } // end of try block

  // all errors during input processing will be caught here
  catch (runtime_error & e)
    {
    *p << e.what () << "\n";    
    }
  
  *p << p->prompt;   // re-prompt them

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdi, %rbx
leaq -0x198(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x34c0
leaq 0x68(%rbx), %rsi
leaq 0x8cd6(%rip), %r14      # 0x14888
movq %r14, %rdi
callq 0xc40a
addq $0x8, %r14
cmpq %r14, %rax
je 0xbbd0
leaq -0x198(%rbp), %rsi
movq %rbx, %rdi
callq *0x28(%rax)
leaq -0x198(%rbp), %rdi
callq 0x3190
leaq 0x70(%rbx), %rsi
movq %rbx, %rdi
callq 0x5e24
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
movq %rax, %r14
jmp 0xbc10
movq %rdx, %r15
movq %rax, %r14
leaq -0x198(%rbp), %rdi
callq 0x3190
cmpl $0x1, %r15d
jne 0xbc57
movq %r14, %rdi
callq 0x3150
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
leaq -0x198(%rbp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0xc096
leaq 0x1494(%rip), %rsi      # 0xd0d4
movq %rax, %rdi
callq 0x92f2
callq 0x34b0
jmp 0xbbdc
movq %rax, %r14
callq 0x34b0
movq %r14, %rdi
callq 0x3500
movq %rax, %rdi
callq 0x5618
// File: /workspace/github_cpp_makefile_star2_O2/nickgammon[P]tinymudserver/comms.cpp
// Function: MainLoop()
void MainLoop ()
{
  // loop processing input, output, events
  do
    {

    // We will go through this loop roughly every COMMS_WAIT_SEC/COMMS_WAIT_USEC
    // seconds (at present 0.5 seconds).
    PeriodicUpdates ();   // do things that don't rely on player input
      
    // delete players who have closed their comms - have to do it outside other loops to avoid 
    // access violations (iterating loops that have had items removed)
    RemoveInactivePlayers ();
      
    // get ready for "select" function ... 
    FD_ZERO (&in_set);
    FD_ZERO (&out_set);
    FD_ZERO (&exc_set);

    // add our control socket (for new connections)
    FD_SET (iControl, &in_set);

    // set bits in in_set, out_set etc. for each connected player
    int iMaxdesc = for_each (playerlist.begin (), playerlist.end (), 
                             setUpDescriptors (iControl)).GetMax ();
    
    // set up timeout interval
    struct timeval timeout;
    timeout.tv_sec = COMMS_WAIT_SEC;    // seconds
    timeout.tv_usec = COMMS_WAIT_USEC;  // + 1000th. of second

    // check for activity, timeout after 'timeout' seconds
    if (select (iMaxdesc + 1, &in_set, &out_set, &exc_set, &timeout) > 0)
      {
      // New connection on control port?
      if (FD_ISSET (iControl, &in_set))
        ProcessNewConnection ();
      
      // handle all player input/output
      for_each (playerlist.begin (), playerlist.end (), 
                processDescriptors ());      
      } // end of something happened
  
    }  while (!bStopNow);   // end of looping processing input

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
pushq $0x40
popq %r13
leaq 0x8dcd(%rip), %rbx      # 0x14a50
leaq 0x8b86(%rip), %r14      # 0x14810
leaq 0x8e3f(%rip), %r15      # 0x14ad0
leaq 0x8eb8(%rip), %r12      # 0x14b50
callq 0x425c
callq 0xbb20
xorl %eax, %eax
cmpq $0x80, %rax
je 0xbcb7
andq $0x0, (%rax,%rbx)
addq $0x8, %rax
jmp 0xbca4
xorl %eax, %eax
cmpq $0x80, %rax
je 0xbccc
andq $0x0, (%rax,%r15)
addq $0x8, %rax
jmp 0xbcb9
xorl %eax, %eax
cmpq $0x80, %rax
je 0xbce1
andq $0x0, (%rax,%r12)
addq $0x8, %rax
jmp 0xbcce
leaq 0x8618(%rip), %rax      # 0x14300
movl (%rax), %r8d
movl %r8d, %eax
cltd
idivl %r13d
movslq %eax, %rdx
shll $0x6, %eax
movl %r8d, %ecx
subl %eax, %ecx
pushq $0x1
popq %rax
shlq %cl, %rax
orq %rax, (%rbx,%rdx,8)
movq (%r14), %rdi
movq %r14, %rsi
movl %r8d, %edx
callq 0xc13d
andq $0x0, -0x38(%rbp)
movq $0x7a120, -0x30(%rbp)   # imm = 0x7A120
leal 0x1(%rax), %edi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
leaq -0x38(%rbp), %r8
callq 0x3300
testl %eax, %eax
jle 0xbd64
leaq 0x85be(%rip), %rax      # 0x14300
movl (%rax), %eax
cltd
idivl %r13d
cltq
movq (%rbx,%rax,8), %rax
btq %rdx, %rax
jae 0xbd59
callq 0xb88d
movq (%r14), %rdi
movq %r14, %rsi
callq 0xc178
leaq 0x8a95(%rip), %rax      # 0x14800
cmpb $0x1, (%rax)
jne 0xbc98
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/nickgammon[P]tinymudserver/./player.h
// Function: tPlayer::~tPlayer()
~tPlayer () // dtor
    {
    ProcessWrite ();    // send outstanding text
    if (s != NO_SOCKET) /* close connection if active */
      close (s);
    if (connstate == ePlaying)
      Save ();          // auto-save on close
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5252
movl (%rbx), %edi
cmpl $-0x1, %edi
je 0xc016
callq 0x35a0
cmpl $0x5, 0x68(%rbx)
jne 0xc024
movq %rbx, %rdi
callq 0x4d80
leaq 0xe0(%rbx), %rdi
callq 0xb536
leaq 0xb0(%rbx), %rdi
callq 0x35c8
leaq 0x90(%rbx), %rdi
callq 0x35c8
leaq 0x70(%rbx), %rdi
callq 0x35c8
leaq 0x48(%rbx), %rdi
callq 0x35c8
leaq 0x28(%rbx), %rdi
callq 0x35c8
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x35c8
movq %rax, %rdi
callq 0x5618
nop
// File: /workspace/github_cpp_makefile_star2_O2/nickgammon[P]tinymudserver/comms.cpp
// Function: setUpDescriptors::operator()(tPlayer const*)
void operator() (const tPlayer * p) 
    {
     /* don't bother if connection is closed */
      if (p->Connected ())
        {
        iMaxdesc = max (iMaxdesc, p->GetSocket ());
        // don't take input if they are closing down
        if (!p->closing)
          {
          FD_SET( p->GetSocket (), &in_set  );
          FD_SET( p->GetSocket (), &exc_set );
          }

        /* we are only interested in writing to sockets we have something for */
        if (p->PendingOutput ())
          FD_SET( p->GetSocket (), &out_set );
        } /* end of active player */
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rsi), %r8d
cmpl $-0x1, %r8d
je 0xc4e1
movl (%rdi), %eax
cmpl %r8d, %eax
cmovlel %r8d, %eax
movl %eax, (%rdi)
cmpb $0x0, 0xd8(%rsi)
movl $0x40, %r9d
movabsq $0x1, %rdi
jne 0xc4b9
movl %r8d, %eax
cltd
idivl %r9d
movslq %eax, %rdx
shll $0x6, %eax
movl %r8d, %ecx
subl %eax, %ecx
movq %rdi, %rax
shlq %cl, %rax
leaq 0x85a6(%rip), %rcx      # 0x14a50
orq %rax, (%rcx,%rdx,8)
leaq 0x869b(%rip), %rcx      # 0x14b50
orq %rax, (%rcx,%rdx,8)
cmpq $0x0, 0x10(%rsi)
je 0xc4e1
movl %r8d, %eax
cltd
idivl %r9d
movslq %eax, %rdx
shll $0x6, %eax
subl %eax, %r8d
movl %r8d, %ecx
shlq %cl, %rdi
leaq 0x85f3(%rip), %rax      # 0x14ad0
orq %rdi, (%rax,%rdx,8)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nickgammon[P]tinymudserver/comms.cpp
// Function: processDescriptors::operator()(tPlayer*)
void operator() (tPlayer * p) 
    {
      /* handle exceptions */
      if (p->Connected () && FD_ISSET (p->GetSocket (), &exc_set))
        p->ProcessException ();

      /* look for ones we can read from, provided they aren't closed */
      if (p->Connected () && FD_ISSET (p->GetSocket (), &in_set))
        p->ProcessRead ();

      /* look for ones we can write to, provided they aren't closed */
      if (p->Connected () && FD_ISSET (p->GetSocket (), &out_set))
        p->ProcessWrite ();
     }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl (%rsi), %ecx
cmpl $-0x1, %ecx
je 0xc56e
movq %rsi, %rbx
pushq $0x40
popq %r14
movl %ecx, %eax
cltd
idivl %r14d
cltq
leaq 0x8648(%rip), %rsi      # 0x14b50
movq (%rsi,%rax,8), %rax
btq %rdx, %rax
jae 0xc521
movq %rbx, %rdi
callq 0x4bfc
movl (%rbx), %ecx
cmpl $-0x1, %ecx
je 0xc56e
movl %ecx, %eax
cltd
idivl %r14d
cltq
leaq 0x8520(%rip), %rsi      # 0x14a50
movq (%rsi,%rax,8), %rax
btq %rdx, %rax
jae 0xc549
movq %rbx, %rdi
callq 0x5014
movl (%rbx), %ecx
cmpl $-0x1, %ecx
je 0xc56e
movl %ecx, %eax
cltd
idivl %r14d
cltq
leaq 0x8578(%rip), %rcx      # 0x14ad0
movq (%rcx,%rax,8), %rax
btq %rdx, %rax
jae 0xc56e
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5252
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nickgammon[P]tinymudserver/room.cpp
// Function: FindRoom(int const&)
tRoom * FindRoom (const int & vnum)
{
  tRoomMapIterator roomiter = roommap.find (vnum);
  
  if (roomiter == roommap.end ())
    throw runtime_error (MAKE_STRING ("Room number " << vnum << " does not exist."));

  return roomiter->second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdi, %r14
leaq 0x829a(%rip), %rbx      # 0x14828
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc680
addq $0x8, %rbx
cmpq %rbx, %rax
je 0xc5b4
movq 0x28(%rax), %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x31b0
movq %rax, %rbx
leaq -0x1b0(%rbp), %rdi
callq 0x33f0
leaq -0x1b0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
orl $0x1, -0x198(%rbp,%rax)
leaq 0x14fb(%rip), %rsi      # 0xdae3
callq 0x3310
leaq -0x1b0(%rbp), %rdi
movq %r14, %rsi
callq 0x9ad1
movq %rax, %r14
leaq 0x14ea(%rip), %rsi      # 0xdaf0
movq %rax, %rdi
callq 0x3310
addq $0x8, %r14
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x3470
movb $0x1, %r15b
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x3490
xorl %r15d, %r15d
movq 0x79b9(%rip), %rsi      # 0x13ff0
movq 0x797a(%rip), %rdx      # 0x13fb8
movq %rbx, %rdi
callq 0x34e0
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x35c8
jmp 0xc65a
movq %rax, %r14
movb $0x1, %r15b
leaq -0x1b0(%rbp), %rdi
callq 0x30b0
testb %r15b, %r15b
jne 0xc670
jmp 0xc678
movq %rax, %r14
movq %rbx, %rdi
callq 0x3270
movq %r14, %rdi
callq 0x3500
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/unordered_dense/test.cpp
// Function: test_int(unsigned int, unsigned int)
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	ankerl::unordered_dense::map<uint32_t, uint32_t, Hash32> h;
	for (i = 0, x = x0; i < n; ++i) {
		x = hash32(x);
#ifndef UDB2_TEST_DEL
		z += ++h[get_key(n, x)];
#else
		auto p = h.try_emplace(get_key(n, x), i);
		if (p.second == false) h.erase(p.first);
#endif
	}
	fprintf(stderr, "# unique keys: %ld; checksum: %u\n", h.size(), z);
	return h.size();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %r15d
movl %edi, %ebp
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
movl $0x3f4ccccd, 0x30(%r14) # imm = 0x3F4CCCCD
movb $0x3d, 0x36(%r14)
xorl %ebx, %ebx
leaq 0xc(%rsp), %r12
movl %edi, %r13d
subl $0x1, %r13d
jb 0x1583
movl %r15d, %edi
callq 0x129c
movl %eax, %r15d
movl %ebp, %edi
movl %eax, %esi
callq 0x12c7
movl %eax, 0xc(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x1872
movl 0x4(%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x4(%rax)
addl %ecx, %ebx
incl %ebx
jmp 0x154b
movq 0x2a56(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
leaq 0x10(%rsp), %r14
movq 0x8(%r14), %rdx
subq (%r14), %rdx
sarq $0x3, %rdx
leaq 0xad1(%rip), %rsi       # 0x2075
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1120
movq 0x8(%r14), %rbx
subq (%r14), %rbx
shrq $0x3, %rbx
movq %r14, %rdi
callq 0x15e6
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x15e6
movq %rbx, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/unordered_dense/./unordered_dense.h
// Function: ankerl::unordered_dense::v4_1_2::detail::table<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, ankerl::unordered_dense::v4_1_2::bucket_type::standard, false>::deallocate_buckets()
void deallocate_buckets() {
        auto ba = bucket_alloc(m_values.get_allocator());
        if (nullptr != m_buckets) {
            bucket_alloc_traits::deallocate(ba, m_buckets, bucket_count());
            m_buckets = nullptr;
        }
        m_num_buckets = 0;
        m_max_bucket_capacity = 0;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x1629
movq 0x20(%rbx), %rsi
shlq $0x3, %rsi
callq 0x1100
andq $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/unordered_dense/./unordered_dense.h
// Function: ankerl::unordered_dense::v4_1_2::detail::table<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, ankerl::unordered_dense::v4_1_2::bucket_type::standard, false>::allocate_buckets_from_shift()
void allocate_buckets_from_shift() {
        auto ba = bucket_alloc(m_values.get_allocator());
        m_num_buckets = calc_num_buckets(m_shifts);
        m_buckets = bucket_alloc_traits::allocate(ba, m_num_buckets);
        if (m_num_buckets == max_bucket_count()) {
            // reached the maximum, make sure we can use each bucket
            m_max_bucket_capacity = max_bucket_count();
        } else {
            m_max_bucket_capacity = static_cast<value_idx_type>(static_cast<float>(m_num_buckets) * max_load_factor());
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ecx, %ecx
subb 0x36(%rdi), %cl
pushq $0x1
popq %rsi
shlq %cl, %rsi
movabsq $0x100000000, %r14      # imm = 0x100000000
cmpq %r14, %rsi
cmovaeq %r14, %rsi
movq %rsi, 0x20(%rdi)
leaq 0x7(%rsp), %rdi
callq 0x1782
movq %rax, 0x18(%rbx)
movq 0x20(%rbx), %rax
testq %rax, %rax
js 0x1677
cvtsi2ss %rax, %xmm0
jmp 0x168e
movq %rax, %rcx
shrq %rcx
movl %eax, %edx
andl $0x1, %edx
orq %rcx, %rdx
cvtsi2ss %rdx, %xmm0
addss %xmm0, %xmm0
cmpq %r14, %rax
mulss 0x30(%rbx), %xmm0
cvttss2si %xmm0, %rcx
movl %ecx, %ecx
cmoveq %rax, %rcx
movq %rcx, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/unordered_dense/./unordered_dense.h
// Function: ankerl::unordered_dense::v4_1_2::detail::table<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, ankerl::unordered_dense::v4_1_2::bucket_type::standard, false>::clear_and_fill_buckets_from_values()
void clear_and_fill_buckets_from_values() {
        clear_buckets();
        for (value_idx_type value_idx = 0, end_idx = static_cast<value_idx_type>(m_values.size()); value_idx < end_idx;
             ++value_idx) {
            auto const& key = get_key(m_values[value_idx]);
            auto [dist_and_fingerprint, bucket] = next_while_less(key);

            // we know for certain that key has not yet been inserted, so no need to check it.
            place_and_shift_up({dist_and_fingerprint, value_idx}, bucket);
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x16d2
movq 0x20(%rbx), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x10b0
movq 0x8(%rbx), %rax
subq (%rbx), %rax
movabsq $0x7fffffff8, %r14      # imm = 0x7FFFFFFF8
andq %rax, %r14
xorl %r15d, %r15d
movabsq $0x100000000, %r12      # imm = 0x100000000
xorl %r13d, %r13d
cmpq %r13, %r14
je 0x1726
movq (%rbx), %rsi
addq %r13, %rsi
movq %rbx, %rdi
callq 0x17b2
movl %eax, %esi
movq %rax, %rdx
shrq $0x20, %rdx
addq %r15, %rsi
movq %rbx, %rdi
callq 0x17fc
addq $0x8, %r13
addq %r12, %r15
jmp 0x16f6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq