LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: nickgammon[P]tinymudserver/strings.cpp
// Function: GetWord(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
pair<string, string> GetWord (const string & s)
{
  string rest = s;  // make copy so we can modify it
  
 // find delimiter  
  string::size_type i (rest.find (' '));

  // split into before and after delimiter
  string w (rest.substr (0, i));

  if (i == string::npos)
    rest.erase ();          // if no delimiter, remainder is empty
  else   
    rest.erase (0, i + 1);  // erase up to the delimiter

  // return first word in line, rest of line
  return make_pair (Trim (w), Trim (rest));
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xc8(%rbp)
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x41f0
movq -0xb8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0xb0(%rbp)
movl $0x20, %esi
callq 0x4580
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
leaq -0x58(%rbp), %rdi
callq 0x4460
jmp 0x6f85
cmpq $-0x1, -0x38(%rbp)
jne 0x6fc6
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
movq $-0x1, %rdx
callq 0x40f0
jmp 0x6fa2
jmp 0x6fde
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x70a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x7098
movq -0x38(%rbp), %rdx
incq %rdx
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x40f0
jmp 0x6fdc
jmp 0x6fde
leaq 0x2251b(%rip), %rdx     # 0x29500
leaq -0x88(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x6c20
jmp 0x6ff7
leaq 0x22502(%rip), %rdx     # 0x29500
leaq -0xa8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6c20
jmp 0x7010
movq -0xc8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
callq 0x72a0
jmp 0x702c
leaq -0xa8(%rbp), %rdi
callq 0x47d8
leaq -0x88(%rbp), %rdi
callq 0x47d8
leaq -0x58(%rbp), %rdi
callq 0x47d8
leaq -0x30(%rbp), %rdi
callq 0x47d8
movq -0xc0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x708c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x47d8
leaq -0x88(%rbp), %rdi
callq 0x47d8
leaq -0x58(%rbp), %rdi
callq 0x47d8
leaq -0x30(%rbp), %rdi
callq 0x47d8
movq -0x60(%rbp), %rdi
callq 0x46d0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: nickgammon[P]tinymudserver/strings.cpp
// Function: fCapitals::operator()(unsigned char const&)
unsigned char operator() (const unsigned char & c)  
    { 
    unsigned char c1;
    // capitalise depending on previous letter
    if (bUpper)
      c1 = toupper (c);
    else
      c1 = tolower (c);

    // work out whether next letter should be capitals
    bUpper = isalnum (c) == 0 && c < 0x80;
    return c1; 
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, (%rax)
je 0x76ae
movq -0x10(%rbp), %rax
movzbl (%rax), %edi
callq 0x4750
movb %al, -0x11(%rbp)
jmp 0x76bd
movq -0x10(%rbp), %rax
movzbl (%rax), %edi
callq 0x47e0
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %edi
callq 0x4450
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
jne 0x76e7
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x80, %eax
setl %al
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rax
movb -0x21(%rbp), %cl
andb $0x1, %cl
movb %cl, (%rax)
movb -0x11(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: nickgammon[P]tinymudserver/player.cpp
// Function: FindPlayer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
tPlayer * FindPlayer (const string & name)
{
  tPlayerListIterator i =
    find_if (playerlist.begin (), playerlist.end (), findPlayerName (name));

  if (i == playerlist.end ())
    return NULL;
  else
    return *i;
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x2221a(%rip), %rdi     # 0x29930
movq %rdi, -0x78(%rbp)
callq 0x8a40
movq -0x78(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x8a70
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x8aa0
movq -0x70(%rbp), %rdx
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x8960
movq %rax, -0x68(%rbp)
jmp 0x7758
movq -0x68(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8ad0
leaq 0x221c0(%rip), %rdi     # 0x29930
callq 0x8a70
movq %rax, -0x60(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x8af0
testb $0x1, %al
jne 0x778c
jmp 0x77ad
movq $0x0, -0x8(%rbp)
jmp 0x77bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8ad0
jmp 0x77ca
leaq -0x18(%rbp), %rdi
callq 0x8b20
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x46d0
nopw %cs:(%rax,%rax)
// File: nickgammon[P]tinymudserver/player.cpp
// Function: tPlayer::Load()
void tPlayer::Load ()
{
  ifstream f ((PLAYER_DIR + playername + PLAYER_EXT).c_str (), ios::in);
  if (!f)
    throw runtime_error ("That player does not exist, type 'new' to create a new one.");
  
  // read player details
  f >> password;
  f >> room;
  f.ignore (numeric_limits<int>::max(), '\n'); // skip rest of this line  
  LoadSet (f, flags);   // player flags (eg. can_shutdown) 
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdx
movq %rdx, -0x270(%rbp)
addq $0x90, %rdx
leaq 0x21850(%rip), %rsi     # 0x29568
leaq -0x250(%rbp), %rdi
movq %rdi, -0x268(%rbp)
callq 0x8c90
movq -0x268(%rbp), %rsi
leaq 0x2184f(%rip), %rdx     # 0x29588
leaq -0x230(%rbp), %rdi
callq 0x8c40
jmp 0x7d47
leaq -0x230(%rbp), %rdi
callq 0x41e0
movq %rax, %rsi
leaq -0x210(%rbp), %rdi
movl $0x8, %edx
callq 0x4730
jmp 0x7d69
leaq -0x230(%rbp), %rdi
callq 0x47d8
leaq -0x250(%rbp), %rdi
callq 0x47d8
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x4230
movb %al, -0x271(%rbp)
jmp 0x7da1
movb -0x271(%rbp), %al
testb $0x1, %al
jne 0x7db0
jmp 0x7e71
movl $0x10, %edi
callq 0x4250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x280(%rbp)
leaq 0x14397(%rip), %rsi     # 0x1c165
callq 0x41c0
jmp 0x7dd5
movq -0x280(%rbp), %rdi
movq 0x2120d(%rip), %rsi     # 0x28ff0
movq 0x211ce(%rip), %rdx     # 0x28fb8
callq 0x46a0
jmp 0x7f0d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x258(%rbp)
movl %eax, -0x25c(%rbp)
jmp 0x7e26
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x258(%rbp)
movl %eax, -0x25c(%rbp)
leaq -0x230(%rbp), %rdi
callq 0x47d8
leaq -0x250(%rbp), %rdi
callq 0x47d8
jmp 0x7f01
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x258(%rbp)
movl %eax, -0x25c(%rbp)
jmp 0x7ef5
movq -0x280(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x258(%rbp)
movl %eax, -0x25c(%rbp)
callq 0x4350
jmp 0x7ef5
movq -0x270(%rbp), %rsi
addq $0xb0, %rsi
leaq -0x210(%rbp), %rdi
callq 0x4550
jmp 0x7e8d
movq -0x270(%rbp), %rsi
addq $0xd4, %rsi
leaq -0x210(%rbp), %rdi
callq 0x42d0
jmp 0x7ea9
callq 0x8d10
movslq %eax, %rsi
leaq -0x210(%rbp), %rdi
movl $0xa, %edx
callq 0x42f0
jmp 0x7ec4
movq -0x270(%rbp), %rsi
addq $0xe0, %rsi
leaq -0x210(%rbp), %rdi
callq 0x8d20
jmp 0x7ee0
leaq -0x210(%rbp), %rdi
callq 0x4120
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
leaq -0x210(%rbp), %rdi
callq 0x4120
movq -0x258(%rbp), %rdi
callq 0x46d0
nopl (%rax)
// File: nickgammon[P]tinymudserver/player.cpp
// Function: tPlayer::Save()
void tPlayer::Save ()
{
  ofstream f ((PLAYER_DIR + playername + PLAYER_EXT).c_str (), ios::out);
  if (!f)
  {
  cerr << "Could not write to file for player " << playername << endl;
  return;
  }
  
  // write player details
  f << password << endl;
  f << room << endl;
  copy (flags.begin (), flags.end (), ostream_iterator<string> (f, " "));
  f << endl;
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2d0, %rsp            # imm = 0x2D0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdx
movq %rdx, -0x298(%rbp)
addq $0x90, %rdx
leaq 0x21630(%rip), %rsi     # 0x29568
leaq -0x248(%rbp), %rdi
movq %rdi, -0x290(%rbp)
callq 0x8c90
movq -0x290(%rbp), %rsi
leaq 0x2162f(%rip), %rdx     # 0x29588
leaq -0x228(%rbp), %rdi
callq 0x8c40
jmp 0x7f67
leaq -0x228(%rbp), %rdi
callq 0x41e0
movq %rax, %rsi
leaq -0x208(%rbp), %rdi
movl $0x10, %edx
callq 0x44b0
jmp 0x7f89
leaq -0x228(%rbp), %rdi
callq 0x47d8
leaq -0x248(%rbp), %rdi
callq 0x47d8
movq -0x208(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x208(%rbp,%rax), %rdi
callq 0x4230
movb %al, -0x299(%rbp)
jmp 0x7fc1
movb -0x299(%rbp), %al
testb $0x1, %al
jne 0x7fd0
jmp 0x8099
movq 0x21011(%rip), %rdi     # 0x28fe8
leaq 0x141c3(%rip), %rsi     # 0x1c1a1
callq 0x4410
movq %rax, -0x2a8(%rbp)
jmp 0x7fec
movq -0x2a8(%rbp), %rdi
movq -0x298(%rbp), %rsi
addq $0x90, %rsi
callq 0x43d0
movq %rax, -0x2b0(%rbp)
jmp 0x800f
movq -0x2b0(%rbp), %rdi
movq 0x20f7b(%rip), %rsi     # 0x28f98
callq 0x4480
jmp 0x8024
movl $0x1, -0x258(%rbp)
jmp 0x819a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x250(%rbp)
movl %eax, -0x254(%rbp)
jmp 0x8065
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x250(%rbp)
movl %eax, -0x254(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x47d8
leaq -0x248(%rbp), %rdi
callq 0x47d8
jmp 0x81af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x250(%rbp)
movl %eax, -0x254(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x45f0
jmp 0x81af
movq -0x298(%rbp), %rsi
addq $0xb0, %rsi
leaq -0x208(%rbp), %rdi
callq 0x43d0
movq %rax, -0x2b8(%rbp)
jmp 0x80bc
movq -0x2b8(%rbp), %rdi
movq 0x20ece(%rip), %rsi     # 0x28f98
callq 0x4480
jmp 0x80d1
movq -0x298(%rbp), %rax
movl 0xd4(%rax), %esi
leaq -0x208(%rbp), %rdi
callq 0x46c0
movq %rax, -0x2c0(%rbp)
jmp 0x80f3
movq -0x2c0(%rbp), %rdi
movq 0x20e97(%rip), %rsi     # 0x28f98
callq 0x4480
jmp 0x8108
movq -0x298(%rbp), %rdi
addq $0xe0, %rdi
movq %rdi, -0x2c8(%rbp)
callq 0x8f00
movq -0x2c8(%rbp), %rdi
movq %rax, -0x260(%rbp)
callq 0x8f30
movq %rax, -0x268(%rbp)
leaq 0x1482b(%rip), %rdx     # 0x1c96e
leaq -0x278(%rbp), %rdi
leaq -0x208(%rbp), %rsi
callq 0x8f60
jmp 0x8158
movq -0x260(%rbp), %rsi
movq -0x268(%rbp), %rdx
leaq -0x288(%rbp), %rdi
leaq -0x278(%rbp), %rcx
callq 0x8e80
jmp 0x817b
movq 0x20e16(%rip), %rsi     # 0x28f98
leaq -0x208(%rbp), %rdi
callq 0x4480
jmp 0x8190
movl $0x0, -0x258(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x45f0
addq $0x2d0, %rsp            # imm = 0x2D0
popq %rbp
retq
movq -0x250(%rbp), %rdi
callq 0x46d0
nopl (%rax,%rax)
// File: nickgammon[P]tinymudserver/player.cpp
// Function: tPlayer::ProcessWrite()
void tPlayer::ProcessWrite ()
{
  /* we will loop attempting to write all in buffer, until write blocks */
  while (s != NO_SOCKET && !outbuf.empty ())
    {

    // send a maximum of 512 at a time
    int iLength = min<int> (outbuf.size (), 512);

    // send to player
    int nWrite = write (s, outbuf.c_str (), iLength );

    // check for bad write
    if (nWrite < 0)
      {
      if (errno != EWOULDBLOCK )
        perror ("send to player");  /* some other error? */
      return;
      }

    // remove what we successfully sent from the buffer
    outbuf.erase (0, nWrite);
      
    // if partial write, exit
    if (nWrite < iLength)
       break;

    } /* end of having write loop */

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl $-0x1, (%rcx)
movb %al, -0x21(%rbp)
je 0x87f4
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x4660
xorb $-0x1, %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x8800
jmp 0x888f
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x4330
movl %eax, -0x10(%rbp)
movl $0x200, -0x14(%rbp)     # imm = 0x200
leaq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x9110
movq -0x20(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl (%rdi), %eax
movl %eax, -0x28(%rbp)
addq $0x8, %rdi
callq 0x41e0
movl -0x28(%rbp), %edi
movq %rax, %rsi
movslq -0xc(%rbp), %rdx
callq 0x4180
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x886b
callq 0x4070
cmpl $0xb, (%rax)
je 0x8869
leaq 0x139ad(%rip), %rdi     # 0x1c211
callq 0x4380
jmp 0x888f
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movslq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x40f0
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x888a
jmp 0x888f
jmp 0x87d4
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nickgammon[P]tinymudserver/./utils.h
// Function: void LoadSet<std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ciLess, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(std::istream&, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ciLess, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void LoadSet (istream & f, T & s)
{
  s.clear ();
  string sLine;
  getline (f, sLine);   // get one line
  istringstream is (sLine); // convert back to stream
  string flag;    // each flag name
  while (!is.eof ())    // read that stream
    {
    is >> flag;   // read flag
    s.insert (flag);  // and insert it
    } // end of getting each item  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x96f0
leaq -0x30(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
callq 0x45b0
movq -0x1f8(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x40e0
jmp 0x8d5e
leaq -0x1c0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x8, %edx
callq 0x4670
jmp 0x8d75
leaq -0x1e0(%rbp), %rdi
callq 0x45b0
movq -0x1c0(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x1c0(%rbp,%rax), %rdi
callq 0x4740
movb %al, -0x1f9(%rbp)
jmp 0x8da1
movb -0x1f9(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x8db2
jmp 0x8e39
leaq -0x1c0(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x4550
jmp 0x8dc7
movq -0x10(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x9710
movb %dl, -0x209(%rbp)
movq %rax, -0x208(%rbp)
jmp 0x8de6
movb -0x209(%rbp), %al
movq -0x208(%rbp), %rcx
movq %rcx, -0x1f0(%rbp)
movb %al, -0x1e8(%rbp)
jmp 0x8d81
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x8e63
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x47d8
leaq -0x1c0(%rbp), %rdi
callq 0x4240
jmp 0x8e63
leaq -0x1e0(%rbp), %rdi
callq 0x47d8
leaq -0x1c0(%rbp), %rdi
callq 0x4240
leaq -0x30(%rbp), %rdi
callq 0x47d8
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x47d8
movq -0x38(%rbp), %rdi
callq 0x46d0
nopw %cs:(%rax,%rax)
nop
// File: nickgammon[P]tinymudserver/load.cpp
// Function: LoadControlFile()
void LoadControlFile ()
{
  // load control file
  ifstream fControl (CONTROL_FILE, ios::in);
  if (!fControl)
    {
    cerr << "Could not open control file: " << CONTROL_FILE << endl;
    return;
    }

  LoadSet (fControl, directionset); // possible directions, eg. n, s, e, w
  LoadSet (fControl, badnameset);   // bad names for new players, eg. new, quit, look, admin
  LoadSet (fControl, blockedIP);    // blocked IP addresses
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq 0x1de9e(%rip), %rsi     # 0x29400
leaq -0x208(%rbp), %rdi
movl $0x8, %edx
callq 0x4730
movq -0x208(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x208(%rbp,%rax), %rdi
callq 0x4230
movb %al, -0x219(%rbp)
jmp 0xb593
movb -0x219(%rbp), %al
testb $0x1, %al
jne 0xb59f
jmp 0xb618
movq 0x1da42(%rip), %rdi     # 0x28fe8
leaq 0x10ca4(%rip), %rsi     # 0x1c251
callq 0x4410
movq %rax, -0x228(%rbp)
jmp 0xb5bb
movq -0x228(%rbp), %rdi
movq 0x1de37(%rip), %rsi     # 0x29400
callq 0x4410
movq %rax, -0x230(%rbp)
jmp 0xb5d7
movq -0x230(%rbp), %rdi
movq 0x1d9b3(%rip), %rsi     # 0x28f98
callq 0x4480
jmp 0xb5ec
movl $0x1, -0x218(%rbp)
jmp 0xb661
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x4120
jmp 0xb676
leaq 0x1e3e9(%rip), %rsi     # 0x29a08
leaq -0x208(%rbp), %rdi
callq 0x8d20
jmp 0xb62d
leaq 0x1e404(%rip), %rsi     # 0x29a38
leaq -0x208(%rbp), %rdi
callq 0x8d20
jmp 0xb642
leaq 0x1e41f(%rip), %rsi     # 0x29a68
leaq -0x208(%rbp), %rdi
callq 0xc3a0
jmp 0xb657
movl $0x0, -0x218(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x4120
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq -0x210(%rbp), %rdi
callq 0x46d0
nopw %cs:(%rax,%rax)
// File: nickgammon[P]tinymudserver/commands.cpp
// Function: NoMore(tPlayer*, std::istream&)
void NoMore (tPlayer * p, istream & sArgs)
  {
  string sLine;
  getline (sArgs, sLine);
  if (!sLine.empty ())
    throw runtime_error ("Unexpected input: " + sLine);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x45b0
movq -0x70(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x40e0
jmp 0x105af
leaq -0x30(%rbp), %rdi
callq 0x4660
testb $0x1, %al
jne 0x10658
movb $0x1, -0x61(%rbp)
movl $0x10, %edi
callq 0x4250
movq %rax, -0x78(%rbp)
leaq 0xbd95(%rip), %rsi      # 0x1c36e
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x13750
jmp 0x105e8
movq -0x78(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x4630
jmp 0x105f7
movq -0x78(%rbp), %rdi
movb $0x0, -0x61(%rbp)
movq 0x189ea(%rip), %rsi     # 0x28ff0
movq 0x189ab(%rip), %rdx     # 0x28fb8
callq 0x46a0
jmp 0x1067c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1066a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x10645
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x47d8
testb $0x1, -0x61(%rbp)
jne 0x1064d
jmp 0x10656
movq -0x78(%rbp), %rdi
callq 0x4350
jmp 0x1066a
leaq -0x30(%rbp), %rdi
callq 0x47d8
addq $0x80, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x47d8
movq -0x38(%rbp), %rdi
callq 0x46d0
nopl (%rax)
// File: nickgammon[P]tinymudserver/commands.cpp
// Function: GetMessage(std::istream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string GetMessage (istream & sArgs, const string & noMessageError)
  {
  string message;
  sArgs >> ws;  // skip leading spaces
  getline (sArgs, message); // get rest of line
  if (message.empty ()) // better have something
    throw runtime_error (noMessageError);
  return message;  
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x45b0
movq -0x10(%rbp), %rdi
movq 0x188fd(%rip), %rsi     # 0x28fb0
callq 0x4170
jmp 0x106ba
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x40e0
jmp 0x106c9
movq -0x40(%rbp), %rdi
callq 0x4660
testb $0x1, %al
jne 0x106d8
jmp 0x10735
movl $0x10, %edi
callq 0x4250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rsi
callq 0x4630
jmp 0x106f7
movq -0x48(%rbp), %rdi
movq 0x188ee(%rip), %rsi     # 0x28ff0
movq 0x188af(%rip), %rdx     # 0x28fb8
callq 0x46a0
jmp 0x10764
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x10752
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x4350
jmp 0x10752
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x10748
movq -0x40(%rbp), %rdi
callq 0x47d8
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x47d8
movq -0x28(%rbp), %rdi
callq 0x46d0
nopw %cs:(%rax,%rax)
// File: nickgammon[P]tinymudserver/commands.cpp
// Function: GetFlag(std::istream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string GetFlag (istream & sArgs, const string & noFlagError)
  {
  string flag;
  sArgs >> ws >> flag;
  if (flag.empty ())
    throw runtime_error (noFlagError);
  if (flag.find_first_not_of (valid_player_name) != string::npos)
    throw runtime_error ("Flag name not valid.");
  return flag;      
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x45b0
movq -0x10(%rbp), %rdi
movq 0x1880d(%rip), %rsi     # 0x28fb0
callq 0x4170
movq %rax, -0x38(%rbp)
jmp 0x107ae
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x4550
jmp 0x107bd
movq -0x48(%rbp), %rdi
callq 0x4660
testb $0x1, %al
jne 0x107cc
jmp 0x10832
movl $0x10, %edi
callq 0x4250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rsi
callq 0x4630
jmp 0x107eb
movq -0x50(%rbp), %rdi
movq 0x187fa(%rip), %rsi     # 0x28ff0
movq 0x187bb(%rip), %rdx     # 0x28fb8
callq 0x46a0
jmp 0x108cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x108bb
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x4350
jmp 0x108bb
movq -0x48(%rbp), %rdi
leaq 0x18f1b(%rip), %rsi     # 0x29758
xorl %eax, %eax
movl %eax, %edx
callq 0x4390
cmpq $-0x1, %rax
je 0x1089e
movl $0x10, %edi
callq 0x4250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq 0xbb1a(%rip), %rsi      # 0x1c381
callq 0x41c0
jmp 0x1086e
movq -0x58(%rbp), %rdi
movq 0x18777(%rip), %rsi     # 0x28ff0
movq 0x18738(%rip), %rdx     # 0x28fb8
callq 0x46a0
jmp 0x108cd
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x4350
jmp 0x108bb
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x108b1
movq -0x48(%rbp), %rdi
callq 0x47d8
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x47d8
movq -0x28(%rbp), %rdi
callq 0x46d0
nopl (%rax)
// File: nickgammon[P]tinymudserver/commands.cpp
// Function: PlayerToRoom(tPlayer*, int const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void PlayerToRoom (tPlayer * p,       // which player
                  const int & vnum,   // which room
                  const string & sPlayerMessage,  // what to tell the player
                  const string & sOthersDepartMessage,  // tell people in original room 
                  const string & sOthersArrriveMessage) // tell people in new room
{
  tRoom * r = FindRoom (vnum); // find the destination room (throws exception if not there)
  SendToAll (sOthersDepartMessage, p, p->room);  // tell others where s/he went
  p->room = vnum;  // move to new room
  *p << sPlayerMessage; // tell player
  p->DoCommand ("look");   // look around new room  
  SendToAll (sOthersArrriveMessage, p, p->room);  // tell others ws/he has arrived  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bbb0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl 0xd4(%rsi), %edx
callq 0x88a0
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xd4(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb450
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x46e0
movq -0x70(%rbp), %rdx
leaq 0xba4a(%rip), %rsi      # 0x1c396
leaq -0x50(%rbp), %rdi
callq 0x67d0
jmp 0x10957
movq -0x78(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x81c0
jmp 0x10966
leaq -0x50(%rbp), %rdi
callq 0x47d8
leaq -0x51(%rbp), %rdi
callq 0x44a0
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rax
movl 0xd4(%rax), %edx
callq 0x88a0
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x109bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x47d8
leaq -0x51(%rbp), %rdi
callq 0x44a0
movq -0x60(%rbp), %rdi
callq 0x46d0
nopl (%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10580
movq -0x8(%rbp), %rax
cmpl $0x5, 0x68(%rax)
jne 0x10d8d
movq -0x8(%rbp), %rdi
leaq 0xb703(%rip), %rsi      # 0x1c3cc
callq 0x13960
movq 0x182eb(%rip), %rdi     # 0x28fc0
leaq 0xb439(%rip), %rsi      # 0x1c115
movq %rsi, -0x78(%rbp)
callq 0x4410
movq %rax, %rdi
movq -0x8(%rbp), %rsi
addq $0x90, %rsi
callq 0x43d0
movq %rax, %rdi
leaq 0xb6de(%rip), %rsi      # 0x1c3e0
movq %rsi, -0x68(%rbp)
callq 0x4410
movq -0x78(%rbp), %rsi
movq -0x8(%rbp), %rdx
addq $0x90, %rdx
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x13750
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0xc6c0
jmp 0x10d3a
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
xorl %edx, %edx
callq 0x88a0
jmp 0x10d4b
leaq -0x30(%rbp), %rdi
callq 0x47d8
leaq -0x50(%rbp), %rdi
callq 0x47d8
jmp 0x10d8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x10d82
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x47d8
leaq -0x50(%rbp), %rdi
callq 0x47d8
jmp 0x10d9f
movq -0x8(%rbp), %rdi
callq 0x13a60
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x46d0
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10580
movq -0x8(%rbp), %rdi
leaq 0xa990(%rip), %rsi      # 0x1c498
callq 0x14360
movl $0x0, -0x14(%rbp)
leaq 0x17e15(%rip), %rdi     # 0x29930
callq 0x8a40
movq %rax, -0x20(%rbp)
leaq 0x17e05(%rip), %rdi     # 0x29930
callq 0x8a70
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x94f0
testb $0x1, %al
jne 0x11b4a
jmp 0x11bd6
leaq -0x20(%rbp), %rdi
callq 0x8b20
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x95e0
testb $0x1, %al
jne 0x11b69
jmp 0x11bc6
movq -0x8(%rbp), %rdi
leaq 0xadf9(%rip), %rsi      # 0x1c96d
callq 0x13f30
movq %rax, %rdi
movq -0x30(%rbp), %rsi
addq $0x90, %rsi
callq 0xb450
movq %rax, %rdi
leaq 0xa919(%rip), %rsi      # 0x1c4af
callq 0x14160
movq %rax, %rdi
movq -0x30(%rbp), %rsi
addq $0xd4, %rsi
callq 0x14460
movq %rax, %rdi
leaq 0xa51c(%rip), %rsi      # 0x1c0d4
callq 0x13b80
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11bc8
leaq -0x20(%rbp), %rdi
callq 0x9560
jmp 0x11b24
movq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x14460
movq %rax, %rdi
leaq 0xa8cc(%rip), %rsi      # 0x1c4b9
callq 0x14560
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10580
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x46e0
movq -0x70(%rbp), %rdx
leaq 0xa1bc(%rip), %rsi      # 0x1c57c
leaq -0x30(%rbp), %rdi
callq 0x67d0
jmp 0x123cb
movq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x82b0
jmp 0x123da
leaq -0x30(%rbp), %rdi
callq 0x47d8
leaq -0x31(%rbp), %rdi
callq 0x44a0
movq -0x8(%rbp), %rsi
addq $0x90, %rsi
leaq 0xa18b(%rip), %rdx      # 0x1c589
leaq -0x68(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x138e0
movq -0x80(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x88a0
jmp 0x1241a
leaq -0x68(%rbp), %rdi
callq 0x47d8
leaq 0x174f6(%rip), %rax     # 0x29920
movb $0x1, (%rax)
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x12459
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x47d8
leaq -0x31(%rbp), %rdi
callq 0x44a0
jmp 0x12479
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x47d8
movq -0x40(%rbp), %rdi
callq 0x46d0
nopw %cs:(%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x45b0
movq -0x80(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x4550
movq %rax, -0x78(%rbp)
jmp 0x12b43
movq -0x78(%rbp), %rdi
movq 0x16462(%rip), %rsi     # 0x28fb0
callq 0x4170
jmp 0x12b55
leaq 0x16eac(%rip), %rdi     # 0x29a08
leaq -0x30(%rbp), %rsi
callq 0x8fc0
movq %rax, -0x88(%rbp)
jmp 0x12b6e
movq -0x88(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0x16e88(%rip), %rdi     # 0x29a08
callq 0x8f30
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x8f90
testb $0x1, %al
jne 0x12b9c
jmp 0x12bc1
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x109d0
jmp 0x12bab
jmp 0x12c98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x12caa
leaq 0x16db0(%rip), %rdi     # 0x29978
leaq -0x30(%rbp), %rsi
callq 0x14920
movq %rax, -0x90(%rbp)
jmp 0x12bda
movq -0x90(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x14950
leaq 0x16d7f(%rip), %rdi     # 0x29978
callq 0x149a0
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x14950
leaq -0x58(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x14970
testb $0x1, %al
jne 0x12c22
jmp 0x12c7d
movl $0x10, %edi
callq 0x4250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x98(%rbp)
leaq 0x9a77(%rip), %rsi      # 0x1c6b7
callq 0x41c0
jmp 0x12c47
movq -0x98(%rbp), %rdi
movq 0x1639b(%rip), %rsi     # 0x28ff0
movq 0x1635c(%rip), %rdx     # 0x28fb8
callq 0x46a0
jmp 0x12cbc
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x4350
jmp 0x12caa
leaq -0x58(%rbp), %rdi
callq 0x149d0
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
jmp 0x12c96
jmp 0x12c98
leaq -0x30(%rbp), %rdi
callq 0x47d8
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x47d8
movq -0x38(%rbp), %rdi
callq 0x46d0
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x45b0
movq -0x48(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x4550
jmp 0x16d9c
leaq -0x30(%rbp), %rdi
callq 0x4660
testb $0x1, %al
jne 0x16dab
jmp 0x16e0b
movl $0x10, %edi
callq 0x4250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0x5a74(%rip), %rsi      # 0x1c83a
callq 0x41c0
jmp 0x16dcd
movq -0x50(%rbp), %rdi
movq 0x12218(%rip), %rsi     # 0x28ff0
movq 0x121d9(%rip), %rdx     # 0x28fb8
callq 0x46a0
jmp 0x16e63
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x16e51
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x4350
jmp 0x16e51
movq -0x8(%rbp), %rdi
addq $0xb0, %rdi
leaq -0x30(%rbp), %rsi
callq 0x4060
jmp 0x16e21
movq -0x8(%rbp), %rax
movl $0x4, 0x68(%rax)
movq -0x8(%rbp), %rdi
addq $0x70, %rdi
leaq 0x5a19(%rip), %rsi      # 0x1c854
callq 0x45a0
jmp 0x16e42
leaq -0x30(%rbp), %rdi
callq 0x47d8
addq $0x50, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x47d8
movq -0x38(%rbp), %rdi
callq 0x46d0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x12372(%rip), %rdi     # 0x299a8
leaq -0x4(%rbp), %rsi
callq 0x17a00
leaq -0x1086(%rip), %rcx     # 0x165c0
movq %rcx, (%rax)
movl $0x1, -0x8(%rbp)
leaq 0x12351(%rip), %rdi     # 0x299a8
leaq -0x8(%rbp), %rsi
callq 0x17a00
leaq -0x3f7(%rip), %rcx      # 0x17270
movq %rcx, (%rax)
movl $0x2, -0xc(%rbp)
leaq 0x12330(%rip), %rdi     # 0x299a8
leaq -0xc(%rbp), %rsi
callq 0x17a00
leaq -0xda8(%rip), %rcx      # 0x168e0
movq %rcx, (%rax)
movl $0x3, -0x10(%rbp)
leaq 0x1230f(%rip), %rdi     # 0x299a8
leaq -0x10(%rbp), %rsi
callq 0x17a00
leaq -0x939(%rip), %rcx      # 0x16d70
movq %rcx, (%rax)
movl $0x4, -0x14(%rbp)
leaq 0x122ee(%rip), %rdi     # 0x299a8
leaq -0x14(%rbp), %rsi
callq 0x17a00
leaq -0x85a(%rip), %rcx      # 0x16e70
movq %rcx, (%rax)
movl $0x5, -0x18(%rbp)
leaq 0x122cd(%rip), %rdi     # 0x299a8
leaq -0x18(%rbp), %rsi
callq 0x17a00
leaq -0x4bdb(%rip), %rcx     # 0x12b10
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0x0, 0x68(%rdi)
movl $0x3e8, 0xd4(%rdi)      # imm = 0x3E8
addq $0xe0, %rdi
callq 0x96f0
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
leaq 0x4f46(%rip), %rsi      # 0x1c936
callq 0x45a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq 0xf129(%rip), %rdi      # 0x28fe8
leaq 0x2b5e(%rip), %rsi      # 0x1ca24
callq 0x4410
movq %rax, %rdi
movq 0xf0c3(%rip), %rsi      # 0x28f98
callq 0x4480
leaq 0xf53f(%rip), %rax      # 0x29420
cmpl $-0x1, (%rax)
je 0x19ef4
leaq 0xf533(%rip), %rax      # 0x29420
movl (%rax), %edi
callq 0x47a0
leaq 0xfa35(%rip), %rdi      # 0x29930
callq 0x8a40
movq %rax, -0x8(%rbp)
leaq 0xfa25(%rip), %rdi      # 0x29930
callq 0x8a70
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1a8b0
leaq 0xfa20(%rip), %rdi      # 0x29948
callq 0x1a960
movq %rax, -0x20(%rbp)
leaq 0xfa10(%rip), %rdi      # 0x29948
callq 0xe350
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1a900
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
leaq 0xf541(%rip), %rdi      # 0x29930
callq 0x8a40
movq %rax, -0x8(%rbp)
leaq 0xf531(%rip), %rdi      # 0x29930
callq 0x8a70
movq %rax, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x94f0
testb $0x1, %al
jne 0x1a41e
jmp 0x1a4b7
leaq -0x8(%rbp), %rdi
callq 0x8b20
movq (%rax), %rdi
callq 0x9630
testb $0x1, %al
jne 0x1a435
jmp 0x1a44a
leaq -0x8(%rbp), %rdi
callq 0x8b20
movq (%rax), %rax
testb $0x1, 0xd8(%rax)
je 0x1a4a9
leaq -0x8(%rbp), %rdi
callq 0x8b20
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x1a477
movq -0x30(%rbp), %rdi
callq 0x1ac70
movq -0x30(%rbp), %rdi
movl $0x110, %esi            # imm = 0x110
callq 0x4430
leaq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x14030
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1ad80
movq -0x18(%rbp), %rsi
leaq 0xf492(%rip), %rdi      # 0x29930
callq 0x1ad30
movq %rax, -0x28(%rbp)
jmp 0x1a4b2
leaq -0x8(%rbp), %rdi
callq 0x9560
jmp 0x1a3f8
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x190(%rbp), %rdi
movl $0x8, %edx
callq 0x4670
jmp 0x1a4ea
movq -0x8(%rbp), %rsi
addq $0x68, %rsi
leaq 0xf4af(%rip), %rdi      # 0x299a8
callq 0x1ada0
movq %rax, -0x1c8(%rbp)
jmp 0x1a507
movq -0x1c8(%rbp), %rax
movq %rax, -0x1a8(%rbp)
leaq 0xf48c(%rip), %rdi      # 0x299a8
callq 0x17c80
movq %rax, -0x1b0(%rbp)
leaq -0x1a8(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x1add0
testb $0x1, %al
jne 0x1a544
jmp 0x1a632
leaq -0x1a8(%rbp), %rdi
callq 0x1ae00
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq *%rax
jmp 0x1a563
jmp 0x1a632
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x1a59a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x4240
movl -0x19c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1a65b
movq -0x198(%rbp), %rdi
callq 0x41d0
movq %rax, -0x1b8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d8(%rbp)
movq -0x1b8(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x1d8(%rbp), %rdi
movq %rax, -0x1c0(%rbp)
leaq -0x1c0(%rbp), %rsi
callq 0x1ae30
movq %rax, -0x1d0(%rbp)
jmp 0x1a5fe
movq -0x1d0(%rbp), %rdi
leaq 0x1ac8(%rip), %rsi      # 0x1c0d4
callq 0x13b80
jmp 0x1a613
callq 0x4650
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x70, %rsi
callq 0xb450
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
leaq -0x190(%rbp), %rdi
callq 0x4240
jmp 0x1a618
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
callq 0x4650
jmp 0x1a659
jmp 0x1a65b
movq -0x198(%rbp), %rdi
callq 0x46d0
movq %rax, %rdi
callq 0x6ae0
nop
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x87c0
jmp 0x1ac8b
movq -0x10(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x1aca3
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x47a0
jmp 0x1aca1
jmp 0x1aca3
movq -0x10(%rbp), %rax
cmpl $0x5, 0x68(%rax)
jne 0x1acba
movq -0x10(%rbp), %rdi
callq 0x7f10
jmp 0x1acb8
jmp 0x1acba
movq -0x10(%rbp), %rdi
addq $0xe0, %rdi
callq 0x18ef0
movq -0x10(%rbp), %rdi
addq $0xb0, %rdi
callq 0x47d8
movq -0x10(%rbp), %rdi
addq $0x90, %rdi
callq 0x47d8
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
callq 0x47d8
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x47d8
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x47d8
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x47d8
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x6ae0
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9630
testb $0x1, %al
jne 0x1b89a
jmp 0x1b9cd
movq -0x10(%rbp), %rdi
callq 0x1ba20
movq -0x20(%rbp), %rdi
movl %eax, -0x14(%rbp)
leaq -0x14(%rbp), %rsi
callq 0x1b9e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
testb $0x1, 0xd8(%rax)
jne 0x1b96d
movq -0x10(%rbp), %rdi
callq 0x1ba20
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ba20
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x30(%rbp), %rdx
movslq %eax, %rcx
leaq 0xe261(%rip), %rax      # 0x29b70
orq (%rax,%rcx,8), %rdx
leaq 0xe256(%rip), %rax      # 0x29b70
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rdi
callq 0x1ba20
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ba20
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x28(%rbp), %rdx
movslq %eax, %rcx
leaq 0xe312(%rip), %rax      # 0x29c70
orq (%rax,%rcx,8), %rdx
leaq 0xe307(%rip), %rax      # 0x29c70
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rdi
callq 0x1ba30
testb $0x1, %al
jne 0x1b97c
jmp 0x1b9cb
movq -0x10(%rbp), %rdi
callq 0x1ba20
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ba20
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x38(%rbp), %rdx
movslq %eax, %rcx
leaq 0xe234(%rip), %rax      # 0x29bf0
orq (%rax,%rcx,8), %rdx
leaq 0xe229(%rip), %rax      # 0x29bf0
movq %rdx, (%rax,%rcx,8)
jmp 0x1b9cd
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9630
testb $0x1, %al
jne 0x1ba7f
jmp 0x1bad6
movq -0x10(%rbp), %rdi
callq 0x1ba20
movl $0x40, %ecx
cltd
idivl %ecx
movslq %eax, %rcx
leaq 0xe1d6(%rip), %rax      # 0x29c70
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ba20
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x18(%rbp), %rax
movl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x1bad6
movq -0x10(%rbp), %rdi
callq 0x7ca0
movq -0x10(%rbp), %rdi
callq 0x9630
testb $0x1, %al
jne 0x1bae5
jmp 0x1bb3c
movq -0x10(%rbp), %rdi
callq 0x1ba20
movl $0x40, %ecx
cltd
idivl %ecx
movslq %eax, %rcx
leaq 0xe070(%rip), %rax      # 0x29b70
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ba20
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x20(%rbp), %rax
movl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x1bb3c
movq -0x10(%rbp), %rdi
callq 0x83c0
movq -0x10(%rbp), %rdi
callq 0x9630
testb $0x1, %al
jne 0x1bb4b
jmp 0x1bba2
movq -0x10(%rbp), %rdi
callq 0x1ba20
movl $0x40, %ecx
cltd
idivl %ecx
movslq %eax, %rcx
leaq 0xe08a(%rip), %rax      # 0x29bf0
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ba20
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x28(%rbp), %rax
movl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x1bba2
movq -0x10(%rbp), %rdi
callq 0x87c0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)