LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x0, (%r14)
leaq 0x9308(%rip), %rbx      # 0x16888
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd7d4
leaq -0xea8(%rip), %rcx      # 0xc6ea
movq %rcx, (%rax)
movl $0x1, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd7d4
leaq -0x29d(%rip), %rcx      # 0xd311
movq %rcx, (%rax)
movl $0x2, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd7d4
leaq -0xc7e(%rip), %rcx      # 0xc94c
movq %rcx, (%rax)
movl $0x3, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd7d4
leaq -0x81c(%rip), %rcx      # 0xcdca
movq %rcx, (%rax)
movl $0x4, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd7d4
leaq -0x749(%rip), %rcx      # 0xceb9
movq %rcx, (%rax)
movl $0x5, (%r14)
leaq -0x14(%rbp), %rsi
movq %rbx, %rdi
callq 0xd7d4
leaq -0x2e0c(%rip), %rcx     # 0xa813
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x0, 0x68(%rdi)
movl $0x3e8, 0xd4(%rdi)      # imm = 0x3E8
addq $0xe0, %rdi
callq 0x6592
movq 0x78(%rbx), %rdx
addq $0x70, %rbx
leaq 0x318b(%rip), %rcx      # 0x10948
movl $0x39, %r8d
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq 0x802e(%rip), %rbx      # 0x15fe8
leaq 0x2a75(%rip), %rsi      # 0x10a36
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x3370
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3220
leaq 0x8304(%rip), %rax      # 0x16300
movl (%rax), %edi
cmpl $-0x1, %edi
je 0xe008
callq 0x35b0
leaq 0x8801(%rip), %rsi      # 0x16810
movq (%rsi), %rdi
callq 0xe785
leaq 0x880a(%rip), %rsi      # 0x16828
movq 0x18(%rsi), %rdi
addq $0x8, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xe7cb
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8424(%rip), %r15      # 0x16810
movq (%r15), %rbx
cmpq %r15, %rbx
je 0xe443
movq 0x10(%rbx), %r14
cmpl $-0x1, (%r14)
je 0xe408
cmpb $0x1, 0xd8(%r14)
jne 0xe43e
movq %r14, %rdi
callq 0xeaf4
movl $0x110, %esi            # imm = 0x110
movq %r14, %rdi
callq 0x32f0
movq (%rbx), %r14
decq 0x10(%r15)
movq %rbx, %rdi
callq 0x34b0
movl $0x18, %esi
movq %rbx, %rdi
callq 0x32f0
movq %r14, %rbx
jmp 0xe3ef
movq (%rbx), %rbx
jmp 0xe3ef
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x8, %edx
callq 0x34d0
leaq 0x840f(%rip), %rcx      # 0x16888
movq 0x10(%rcx), %rsi
leaq 0x8(%rcx), %rax
movq %rax, %rdx
testq %rsi, %rsi
je 0xe4a8
leaq 0x8(%rcx), %rdx
movl 0x68(%rbx), %edi
xorl %r8d, %r8d
cmpl %edi, 0x20(%rsi)
setl %r8b
cmovgeq %rsi, %rdx
movq 0x10(%rsi,%r8,8), %rsi
testq %rsi, %rsi
jne 0xe490
movq %rax, %r8
cmpq %rax, %rdx
je 0xe4c1
movl 0x68(%rbx), %esi
addq $0x8, %rcx
cmpl 0x20(%rdx), %esi
cmovgeq %rdx, %rcx
movq %rcx, %r8
cmpq %rax, %r8
je 0xe4d4
leaq -0x198(%rbp), %rsi
movq %rbx, %rdi
callq *0x28(%r8)
movq 0x7acd(%rip), %rsi      # 0x15fa8
leaq -0x198(%rbp), %rdi
callq 0x33f0
leaq -0x120(%rbp), %rdi
callq 0x3110
leaq 0x70(%rbx), %rsi
movq %rbx, %rdi
callq 0x6a44
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
movq %rax, %r14
movq 0x7a8e(%rip), %rsi      # 0x15fa8
leaq -0x198(%rbp), %rdi
callq 0x33f0
leaq -0x120(%rbp), %rdi
callq 0x3110
jmp 0xe53a
movq %rdx, %r15
movq %rax, %r14
cmpl $0x1, %r15d
jne 0xe584
movq %r14, %rdi
callq 0x3140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
leaq -0x198(%rbp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0xebdc
leaq 0x1b62(%rip), %rsi      # 0x100cc
movq %rax, %rdi
callq 0xb0b0
callq 0x34c0
jmp 0xe4f3
movq %rax, %r14
callq 0x34c0
movq %r14, %rdi
callq 0x3530
movq %rax, %rdi
callq 0x6584
// File: /workspace/github_cpp_makefile_star2_O1/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 0x602c
movl (%rbx), %edi
cmpl $-0x1, %edi
je 0xeb0e
callq 0x35b0
cmpl $0x5, 0x68(%rbx)
jne 0xeb1c
movq %rbx, %rdi
callq 0x58aa
leaq 0xe0(%rbx), %rdi
callq 0xdc3e
movq 0xb0(%rbx), %rdi
leaq 0xc0(%rbx), %rax
cmpq %rax, %rdi
je 0xeb46
movq (%rax), %rsi
incq %rsi
callq 0x32f0
movq 0x90(%rbx), %rdi
leaq 0xa0(%rbx), %rax
cmpq %rax, %rdi
je 0xeb64
movq (%rax), %rsi
incq %rsi
callq 0x32f0
movq 0x70(%rbx), %rdi
leaq 0x80(%rbx), %rax
cmpq %rax, %rdi
je 0xeb7f
movq (%rax), %rsi
incq %rsi
callq 0x32f0
movq 0x48(%rbx), %rdi
leaq 0x58(%rbx), %rax
cmpq %rax, %rdi
je 0xeb97
movq (%rax), %rsi
incq %rsi
callq 0x32f0
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0xebaf
movq (%rax), %rsi
incq %rsi
callq 0x32f0
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0xebcd
movq (%rbx), %rsi
incq %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x32f0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rdi
callq 0x6584
// File: /workspace/github_cpp_makefile_star2_O1/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), %eax
cmpl $-0x1, %eax
je 0xeebf
movl (%rdi), %ecx
cmpl %eax, %ecx
cmovlel %eax, %ecx
movl %ecx, (%rdi)
cmpb $0x0, 0xd8(%rsi)
jne 0xee8e
leal 0x3f(%rax), %edx
testl %eax, %eax
cmovnsl %eax, %edx
movl %edx, %edi
andl $-0x40, %edi
movl %eax, %ecx
subl %edi, %ecx
movl $0x1, %edi
shlq %cl, %rdi
sarl $0x6, %edx
movslq %edx, %rcx
leaq 0x7bd1(%rip), %rdx      # 0x16a50
orq %rdi, (%rdx,%rcx,8)
leaq 0x7cc6(%rip), %rdx      # 0x16b50
orq %rdi, (%rdx,%rcx,8)
cmpq $0x0, 0x10(%rsi)
je 0xeebf
leal 0x3f(%rax), %edx
testl %eax, %eax
cmovnsl %eax, %edx
movl %edx, %ecx
andl $-0x40, %ecx
subl %ecx, %eax
movl $0x1, %esi
movl %eax, %ecx
shlq %cl, %rsi
sarl $0x6, %edx
movslq %edx, %rax
leaq 0x7c15(%rip), %rcx      # 0x16ad0
orq %rsi, (%rcx,%rax,8)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movq %rsi, %rbx
movl (%rsi), %eax
cmpl $-0x1, %eax
je 0xeef9
leal 0x3f(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
sarl $0x6, %ecx
movslq %ecx, %rcx
leaq 0x7c69(%rip), %rdx      # 0x16b50
movq (%rdx,%rcx,8), %rcx
btq %rax, %rcx
jae 0xeef9
movq %rbx, %rdi
callq 0x5678
movl (%rbx), %eax
cmpl $-0x1, %eax
je 0xef27
leal 0x3f(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
sarl $0x6, %ecx
movslq %ecx, %rcx
leaq 0x7b3b(%rip), %rdx      # 0x16a50
movq (%rdx,%rcx,8), %rcx
btq %rax, %rcx
jae 0xef27
movq %rbx, %rdi
callq 0x5ccc
movl (%rbx), %eax
cmpl $-0x1, %eax
je 0xef5b
leal 0x3f(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
sarl $0x6, %ecx
movslq %ecx, %rcx
leaq 0x7b8d(%rip), %rdx      # 0x16ad0
movq (%rdx,%rcx,8), %rcx
btq %rax, %rcx
jae 0xef5b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x602c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x78aa(%rip), %rcx      # 0x16828
movq 0x10(%rcx), %rsi
leaq 0x8(%rcx), %rax
movq %rax, %rdx
testq %rsi, %rsi
je 0xefad
leaq 0x8(%rcx), %rdx
movl (%r14), %edi
xorl %r8d, %r8d
cmpl %edi, 0x20(%rsi)
setl %r8b
cmovgeq %rsi, %rdx
movq 0x10(%rsi,%r8,8), %rsi
testq %rsi, %rsi
jne 0xef95
movq %rax, %rsi
cmpq %rax, %rdx
je 0xefc6
movl (%r14), %esi
addq $0x8, %rcx
cmpl 0x20(%rdx), %esi
cmovgeq %rdx, %rcx
movq %rcx, %rsi
cmpq %rax, %rsi
je 0xefdd
movq 0x28(%rsi), %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x3180
movq %rax, %rbx
leaq -0x1b0(%rbp), %rdi
callq 0x33d0
leaq -0x1b0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
orl $0x1, -0x198(%rbp,%rax)
leaq 0x1ae2(%rip), %rsi      # 0x10af5
movl $0xc, %edx
callq 0x3370
movl (%r14), %esi
leaq -0x1b0(%rbp), %rdi
callq 0x3510
leaq 0x1acf(%rip), %rsi      # 0x10b02
leaq -0x1b0(%rbp), %rdi
movl $0x10, %edx
callq 0x3370
leaq -0x1a8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x3480
movb $0x1, %r15b
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x3490
xorl %r15d, %r15d
movq 0x6f83(%rip), %rsi      # 0x15ff0
movq 0x6f3c(%rip), %rdx      # 0x15fb0
movq %rbx, %rdi
callq 0x3500
movq %rax, %r14
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf0a0
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x32f0
jmp 0xf0a0
movq %rax, %r14
movb $0x1, %r15b
movq 0x6f11(%rip), %rsi      # 0x15fb8
leaq -0x1b0(%rbp), %rdi
callq 0x3190
leaq -0x140(%rbp), %rdi
callq 0x3110
jmp 0xf0c7
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0xf0d4
movq %rbx, %rdi
callq 0x3250
movq %r14, %rdi
callq 0x3530
// File: /workspace/github_cpp_makefile_star2_O1/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
movb 0x36(%rdi), %al
subb %al, %cl
movl $0x1, %esi
shlq %cl, %rsi
movabsq $0x100000000, %r14      # imm = 0x100000000
cmpq %r14, %rsi
cmovaeq %r14, %rsi
movq %rsi, 0x20(%rdi)
leaq 0x7(%rsp), %rdi
xorl %edx, %edx
callq 0x186a
movq %rax, 0x18(%rbx)
movq 0x20(%rbx), %rax
testq %rax, %rax
js 0x1799
cvtsi2ss %rax, %xmm0
jmp 0x17b0
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_O1/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 0x17f4
movq 0x20(%rbx), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x1090
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
testl %eax, %eax
je 0x1844
movl %eax, %r14d
xorl %r15d, %r15d
movabsq $0x100000000, %r12      # imm = 0x100000000
xorl %r13d, %r13d
movq (%rbx), %rsi
addq %r15, %rsi
movq %rbx, %rdi
callq 0x1886
movl %eax, %esi
movq %rax, %rdx
shrq $0x20, %rdx
addq %r13, %rsi
movq %rbx, %rdi
callq 0x18d8
addq %r12, %r13
addq $0x8, %r15
decq %r14
jne 0x1816
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/unordered_dense/./unordered_dense.h
// Function: ankerl::unordered_dense::v4_1_2::bucket_type::standard 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>::next_while_less<unsigned int>(unsigned int const&) const
[[nodiscard]] constexpr auto mixed_hash(K const& key) const -> uint64_t {
        if constexpr (is_detected_v<detect_avalanching, Hash>) {
            // we know that the hash is good because is_avalanching.
            if constexpr (sizeof(decltype(m_hash(key))) < sizeof(uint64_t)) {
                // 32bit hash and is_avalanching => multiply with a constant to avalanche bits upwards
                return m_hash(key) * UINT64_C(0x9ddfea08eb382d69);
            } else {
                // 64bit and is_avalanching => only use the hash itself.
                return m_hash(key);
            }
        } else {
            // not is_avalanching => apply wyhash
            return wyhash::hash(m_hash(key));
        }
    }

// Assembly:
movl (%rsi), %eax
movabsq $-0x61c8864680b583eb, %rcx # imm = 0x9E3779B97F4A7C15
mulq %rcx
xorq %rax, %rdx
movzbl %dl, %eax
orl $0x100, %eax            # imm = 0x100
movb 0x36(%rdi), %cl
shrq %cl, %rdx
movq 0x18(%rdi), %rsi
movl %edx, %ecx
cmpl (%rsi,%rcx,8), %eax
jae 0x18cd
movq 0x20(%rdi), %rdi
xorl %r8d, %r8d
movl %edx, %ecx
addl $0x100, %eax            # imm = 0x100
incl %ecx
cmpq %rcx, %rdi
cmovel %r8d, %ecx
cmpl (%rsi,%rcx,8), %eax
jb 0x18ba
shlq $0x20, %rcx
movl %eax, %eax
orq %rcx, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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>::place_and_shift_up(ankerl::unordered_dense::v4_1_2::bucket_type::standard, unsigned int)
void place_and_shift_up(Bucket bucket, value_idx_type place) {
        while (0 != at(m_buckets, place).m_dist_and_fingerprint) {
            bucket = std::exchange(at(m_buckets, place), bucket);
            bucket.m_dist_and_fingerprint = dist_inc(bucket.m_dist_and_fingerprint);
            place = next(place);
        }
        at(m_buckets, place) = bucket;
    }

// Assembly:
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq 0x18(%rdi), %rcx
movl %edx, %r8d
leaq (%rcx,%r8,8), %rcx
cmpl $0x0, (%rcx)
je 0x1929
xorl %r9d, %r9d
movq %rsi, %r10
movq (%rcx), %r8
andq %rax, %r10
movl %esi, %esi
orq %r10, %rsi
movq %rsi, (%rcx)
leal 0x100(%r8), %esi
incl %edx
movq 0x18(%rdi), %rcx
cmpq %rdx, 0x20(%rdi)
cmovel %r9d, %edx
leaq (%rcx,%rdx,8), %rcx
cmpl $0x0, (%rcx)
movq %r8, %r10
jne 0x18f8
jmp 0x192c
movq %rsi, %r8
andq %rax, %r8
movl %esi, %eax
orq %r8, %rax
movq %rax, (%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/unordered_dense/./unordered_dense.h
// Function: std::pair<__gnu_cxx::__normal_iterator<std::pair<unsigned int, unsigned int>*, std::vector<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>>>, bool> 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>::do_try_emplace<unsigned int>(unsigned int&&)
auto do_try_emplace(K&& key, Args&&... args) -> std::pair<iterator, bool> {
        if (ANKERL_UNORDERED_DENSE_UNLIKELY(is_full())) {
            increase_size();
        }

        auto hash = mixed_hash(key);
        auto dist_and_fingerprint = dist_and_fingerprint_from_hash(hash);
        auto bucket_idx = bucket_idx_from_hash(hash);

        while (true) {
            auto* bucket = &at(m_buckets, bucket_idx);
            if (dist_and_fingerprint == bucket->m_dist_and_fingerprint) {
                if (m_equal(key, get_key(m_values[bucket->m_value_idx]))) {
                    return {begin() + static_cast<difference_type>(bucket->m_value_idx), false};
                }
            } else if (dist_and_fingerprint > bucket->m_dist_and_fingerprint) {
                return do_place_element(dist_and_fingerprint, bucket_idx, std::forward<K>(key), std::forward<Args>(args)...);
            }
            dist_and_fingerprint = dist_inc(dist_and_fingerprint);
            bucket_idx = next(bucket_idx);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
subq (%rdi), %rax
movq %rsi, %r14
sarq $0x3, %rax
cmpq 0x28(%rdi), %rax
jae 0x19dd
movl (%r14), %eax
movabsq $-0x61c8864680b583eb, %rcx # imm = 0x9E3779B97F4A7C15
mulq %rcx
movq %rdx, %r15
xorq %rax, %r15
movzbl %r15b, %ebp
orl $0x100, %ebp            # imm = 0x100
movb 0x36(%rbx), %cl
shrq %cl, %r15
xorl %r12d, %r12d
movq 0x18(%rbx), %rcx
movl %r15d, %esi
cmpl (%rcx,%rsi,8), %ebp
jne 0x19a7
movl 0x4(%rcx,%rsi,8), %ecx
movq (%rbx), %rsi
movl (%r14), %edi
cmpl (%rsi,%rcx,8), %edi
jne 0x19bd
leaq (%rsi,%rcx,8), %rax
xorl %edx, %edx
jmp 0x19b9
jbe 0x19bd
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
movq %r14, %rcx
callq 0x1a3c
xorl %ecx, %ecx
jmp 0x19d0
addl $0x100, %ebp            # imm = 0x100
incl %r15d
cmpq %r15, 0x20(%rbx)
cmovel %r12d, %r15d
movb $0x1, %cl
testb %cl, %cl
jne 0x1984
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x19ea
jmp 0x195b
// File: /workspace/github_cpp_makefile_star2_O1/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>::increase_size()
void increase_size() {
        if (ANKERL_UNORDERED_DENSE_UNLIKELY(m_max_bucket_capacity == max_bucket_count())) {
            on_error_bucket_overflow();
        }
        --m_shifts;
        deallocate_buckets();
        allocate_buckets_from_shift();
        clear_and_fill_buckets_from_values();
    }

// Assembly:
pushq %rbx
movabsq $0x100000000, %rax      # imm = 0x100000000
cmpq %rax, 0x28(%rdi)
je 0x1a37
movq %rdi, %rbx
decb 0x36(%rdi)
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x1a1f
movq 0x20(%rbx), %rsi
shlq $0x3, %rsi
callq 0x10e0
movq $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movq %rbx, %rdi
callq 0x174e
movq %rbx, %rdi
popq %rbx
jmp 0x17d0
callq 0x1aa3
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/unordered_dense/./unordered_dense.h
// Function: std::pair<__gnu_cxx::__normal_iterator<std::pair<unsigned int, unsigned int>*, std::vector<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>>>, bool> 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>::do_place_element<unsigned int>(unsigned int, unsigned int, unsigned int&&)
auto do_place_element(dist_and_fingerprint_type dist_and_fingerprint, value_idx_type bucket_idx, K&& key, Args&&... args)
        -> std::pair<iterator, bool> {

        // emplace the new value. If that throws an exception, no harm done; index is still in a valid state
        m_values.emplace_back(std::piecewise_construct,
                              std::forward_as_tuple(std::forward<K>(key)),
                              std::forward_as_tuple(std::forward<Args>(args)...));

        // place element and shift up until we find an empty spot
        auto value_idx = static_cast<value_idx_type>(m_values.size() - 1);
        place_and_shift_up({dist_and_fingerprint, value_idx}, bucket_idx);
        return {begin() + static_cast<difference_type>(value_idx), true};
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x10(%rsp), %rdx
movq %rcx, (%rdx)
leaq 0x69b(%rip), %rsi       # 0x20f8
leaq 0xf(%rsp), %rcx
callq 0x1aec
movq 0x8(%rbx), %r15
subq (%rbx), %r15
shrq $0x3, %r15
decl %r15d
movq %r15, %rax
shlq $0x20, %rax
movl %r14d, %esi
orq %rax, %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x18d8
shlq $0x3, %r15
addq (%rbx), %r15
movq %r15, %rax
movb $0x1, %dl
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/bowbowbow[P]CollaborativeFiltering/recommender.cpp
// Function: InputReader::InputReader(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
InputReader(string filename) {
        fin.open(filename);
        if(!fin) {
            cout << filename << " file could not be opened\n";
            exit(0);
        }
        parse();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0x21c0
leaq 0x208(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x228(%rbx)
movups %xmm0, 0x218(%rbx)
movups %xmm0, 0x208(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
movl $0x8, %edx
callq 0x2150
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
jne 0x2a09
movq %rbx, %rdi
callq 0x2edc
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x35c1(%rip), %rdi      # 0x5fd8
callq 0x21d0
leaq 0x169e(%rip), %rsi      # 0x40c1
movq %rax, %rdi
callq 0x2190
xorl %edi, %edi
callq 0x21e0
movq %rax, %r15
movq 0x220(%rbx), %rdi
testq %rdi, %rdi
je 0x2a46
callq 0x2170
movq %r14, %rdi
callq 0x2bf0
movq %rbx, %rdi
callq 0x2040
movq %r15, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/bowbowbow[P]CollaborativeFiltering/recommender.cpp
// Function: CF::CF(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>)
CF(MAT userToItem) {
        this->userToItem = userToItem;
        
        userSize = (int)userToItem.size()-1;
        itemSize = (int)userToItem.back().size()-1;
        average = vector<double> (userSize+1, 0.0);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq $0x0, 0x40(%rdi)
callq 0x3510
movq 0x8(%r14), %rax
movq %rax, %rcx
subq (%r14), %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
leal -0x1(%rdx), %ecx
movl %ecx, 0x4c(%rbx)
movq -0x10(%rax), %rcx
subq -0x18(%rax), %rcx
shrq $0x3, %rcx
decl %ecx
movl %ecx, 0x48(%rbx)
movslq %edx, %rsi
leaq -0x38(%rbp), %rdx
movq $0x0, (%rdx)
leaq -0x30(%rbp), %rdi
leaq -0x11(%rbp), %rcx
callq 0x312c
movq 0x30(%rbx), %rdi
movq -0x30(%rbp), %rax
movq %rax, 0x30(%rbx)
movq -0x28(%rbp), %rax
movq %rax, 0x38(%rbx)
movq -0x20(%rbp), %rax
movq %rax, 0x40(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
testq %rdi, %rdi
je 0x2bad
callq 0x2170
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x2bbb
callq 0x2170
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x2bc6
movq %rax, %r14
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x2bd7
callq 0x2170
leaq 0x18(%rbx), %rdi
callq 0x2bf0
movq %rbx, %rdi
callq 0x2bf0
movq %r14, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/bowbowbow[P]CollaborativeFiltering/recommender.cpp
// Function: OutputPrinter::OutputPrinter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
OutputPrinter(string filename) {
        this->filename = filename;
        fout.open(filename);
        if(!fout) {
            cout << filename << " file could not be writed\n";
            exit(0);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
callq 0x2250
leaq 0x200(%rbx), %r14
leaq 0x210(%rbx), %r12
movq %r12, 0x200(%rbx)
movq $0x0, 0x208(%rbx)
movb $0x0, 0x210(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x20c0
movq %rbx, %rdi
movq %r15, %rsi
movl $0x10, %edx
callq 0x20a0
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
jne 0x2ca9
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x3321(%rip), %rdi      # 0x5fd8
callq 0x21d0
leaq 0x1464(%rip), %rsi      # 0x4127
movq %rax, %rdi
callq 0x2190
xorl %edi, %edi
callq 0x21e0
movq %rax, %r15
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x2ce2
callq 0x2170
movq %rbx, %rdi
callq 0x2200
movq %r15, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/bowbowbow[P]CollaborativeFiltering/recommender.cpp
// Function: CF::predict(int, int)
int predict(int user, int item) {
        double top = 0;
        double bottom = 0;
        
        // given untrained items
        if(item > itemSize) {
            return 3;
        }
        
        for(int i=1;i<=itemSize; i++) {
            if(userToItem[user][i] == EMPTY) continue;
            
            bottom += abs(itemToItem[item][i]);
            top += itemToItem[item][i]*userToItem[user][i];
        }
        
        if(bottom == 0) {
            return 3;
        }
        
        double rating = top/bottom;
        // return rating;
        return rating+0.5;
    }

// Assembly:
movl 0x48(%rdi), %ecx
movl $0x3, %eax
cmpl %edx, %ecx
jl 0x2d92
pushq %rbp
movq %rsp, %rbp
xorpd %xmm0, %xmm0
xorpd %xmm2, %xmm2
xorpd %xmm1, %xmm1
testl %ecx, %ecx
jle 0x2d79
movslq %esi, %rsi
movq (%rdi), %r8
leaq (%rsi,%rsi,2), %rsi
movq (%r8,%rsi,8), %rsi
movslq %edx, %rdx
leaq (%rdx,%rdx,2), %rdx
shlq $0x3, %rdx
addq 0x18(%rdi), %rdx
incq %rcx
movl $0x1, %edi
movsd 0x1305(%rip), %xmm3     # 0x4048
movapd 0x12e5(%rip), %xmm4     # 0x4030
movsd (%rsi,%rdi,8), %xmm5
ucomisd %xmm3, %xmm5
jne 0x2d58
jnp 0x2d71
movq (%rdx), %r8
movsd (%r8,%rdi,8), %xmm6
mulsd %xmm6, %xmm5
andpd %xmm4, %xmm6
addsd %xmm6, %xmm1
addsd %xmm5, %xmm2
incq %rdi
cmpq %rdi, %rcx
jne 0x2d4b
ucomisd %xmm0, %xmm1
jne 0x2d81
jnp 0x2d91
divsd %xmm1, %xmm2
addsd 0x12c3(%rip), %xmm2     # 0x4050
cvttsd2si %xmm2, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Agade09[P]CG-Send-Binary/Binary_To_Base85.cpp
// Function: encode_85[abi:cxx11](std::vector<unsigned char, std::allocator<unsigned char>> const&)
string encode_85(const vector<unsigned char> &data){
	string out;
	int data_ptr{0};
	while(data_ptr<data.size()){
		unsigned int acc{0};
		int bytes=min(static_cast<size_t>(4),data.size()-data_ptr);
		for(int i=0;i<bytes;++i){
			unsigned char ch=data[data_ptr++];
			acc+=pow(256,3-i)*ch;
		}
		string sub;
		for(int i=0;i<5;++i){
			int val=acc%85;
			acc/=85;
			sub+=en85[val];
		}
		reverse(sub.begin(),sub.end());
		out+=sub;
	}
	return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r15
leaq 0x10(%rdi), %rax
movq %rax, 0x28(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rbx
subq (%rsi), %rbx
je 0x2629
movq %rsi, %r14
xorl %eax, %eax
leaq 0x18(%rsp), %r12
xorl %r13d, %r13d
movq %r15, 0x30(%rsp)
subq %rax, %rbx
jne 0x24eb
xorl %ebp, %ebp
jmp 0x256a
cmpq $0x4, %rbx
movl $0x4, %eax
cmovaeq %rax, %rbx
cmpl $0x2, %ebx
movl $0x1, %eax
cmovbl %eax, %ebx
movslq %r13d, %r13
shll $0x3, %ebx
xorl %ebp, %ebp
movl $0x18, %r12d
movq (%r14), %rax
movzbl (%rax,%r13), %r15d
incq %r13
movl %r12d, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
callq 0x2120
xorps %xmm1, %xmm1
cvtsi2sd %r15d, %xmm1
movl %ebp, %eax
xorps %xmm2, %xmm2
cvtsi2sd %rax, %xmm2
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
cvttsd2si %xmm1, %rbp
leal (%rbx,%r12), %eax
addl $-0x8, %eax
movl %r12d, %ecx
addl $-0x8, %ecx
movl %ecx, %r12d
cmpl $0x18, %eax
jne 0x2511
movq 0x30(%rsp), %r15
leaq 0x18(%rsp), %r12
movq %r12, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movl $0x5, %ebx
movl %ebp, %eax
movl %ebp, %ebp
movl $0xc0c0c0c1, %ecx       # imm = 0xC0C0C0C1
imulq %rcx, %rbp
shrq $0x26, %rbp
imull $0x55, %ebp, %ecx
subl %ecx, %eax
leaq 0x1a71(%rip), %rcx      # 0x4010
movsbl (%rax,%rcx), %esi
leaq 0x8(%rsp), %rdi
callq 0x2100
decl %ebx
jne 0x2582
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
testq %rcx, %rcx
setne %dl
addq %rax, %rcx
decq %rcx
cmpq %rax, %rcx
seta %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x25f5
incq %rax
movb -0x1(%rax), %dl
movb (%rcx), %sil
movb %sil, -0x1(%rax)
movb %dl, (%rcx)
decq %rcx
leaq 0x1(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jb 0x25da
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x2060
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2616
callq 0x2130
movslq %r13d, %rax
movq 0x8(%r14), %rbx
subq (%r14), %rbx
cmpq %rax, %rbx
ja 0x24e2
movq %r15, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x263d
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x264f
callq 0x2130
movq (%r15), %rdi
cmpq 0x28(%rsp), %rdi
je 0x265e
callq 0x2130
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O1/wwdatabase[P]database/./rcdmana/rm_filehandle.h
// Function: RM_FileHandle::cleanFileHandle()
RC RM_FileHandle::cleanFileHandle(){
    this->fileName = NULL;
    this->bufType = NULL;
    this->bitmap = NULL;
    this->fileID = 0;
    this->pageID = 0;
    this->index = 0;
    this->recordSize = 0;
    this->attrNum = 0;
    this->priKeyNum = 0;
    this->attrType.clear();
    this->attrLength.clear();
    this->isNull.clear();
    this->tagSize = 0;
    this->recordNumForEachPage = 0;
    this->recordNumForAllPages = 0;
    this->bitmapSize = 0;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movq %rax, 0x80(%rdi)
movq %rax, 0x70(%rdi)
movl %eax, 0x78(%rdi)
movl %eax, 0x88(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rax, 0x10(%rdi)
movq 0x18(%rdi), %rax
cmpq %rax, 0x20(%rdi)
je 0x249c
movq %rax, 0x20(%rdi)
movq 0x30(%rdi), %rax
cmpq %rax, 0x38(%rdi)
je 0x24aa
movq %rax, 0x38(%rdi)
movq 0x48(%rdi), %rax
cmpq %rax, 0x50(%rdi)
je 0x24b8
movq %rax, 0x50(%rdi)
movups %xmm0, 0x60(%rdi)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wwdatabase[P]database/./rcdmana/rm_filehandle.h
// Function: RM_FileHandle::init()
RC RM_FileHandle::init() {
    this->recordSize = 0;
    this->recordNumForEachPage = 0;
    this->tagSize = 0;
    this->recordNumForAllPages = 0;
    this->bitmapSize = 0;
    this->bitmap = 0;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, 0xc(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rdi)
movq $0x0, 0x70(%rdi)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wwdatabase[P]database/./rcdmana/rm_filehandle.h
// Function: RM_FileHandle::getRec(RID const&, RM_Record&)
RC RM_FileHandle::getRec(const RID &rid, RM_Record &rec){
    rid.getPageNum(this->pageID);
    this->bufType = bpm->getPage(this->fileID,
                                 this->pageID,
                                 this->index);
    BufType b = this->bufType;
    int tagID ;
    rid.getSlotNum(tagID);

    int tagInt = tagID / 32;
    int tagBit = tagID % 32;
    unsigned int &tagBlock = b[PAGE_INT_NUM-1-tagInt];

    // check bit correct
    if ((tagBlock & (1 << tagBit)) == 0) {
        // cout << "error delete" << endl;
        return 108;
    }
    //cout << "get record : " << this->pageID << ", " << tagID << endl;
    //cout << "size of buttype : " << b[0] << endl;
    char *rcd = (char *)(b + this->recordSize * tagID);
    //cout << string(rcd) << endl;
    char data[this->recordSize];
    strncpy(data, rcd, this->recordSize);
    rec.setData(data);
    rec.rid = rid;

    bpm->access(this->index);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl (%rsi), %edx
movl %edx, 0x78(%rdi)
movq 0x98(%rdi), %rdi
movl 0x8(%rbx), %esi
leaq 0x88(%rbx), %rcx
callq 0x4570
movq %rax, 0x80(%rbx)
movl 0x4(%r15), %ecx
leal 0x1f(%rcx), %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
sarl $0x5, %edx
negl %edx
movslq %edx, %rdx
movl 0x1ffc(%rax,%rdx,4), %edx
btl %ecx, %edx
jae 0x25e5
movq %rsp, %r13
movl 0xc(%rbx), %edx
imull %edx, %ecx
movslq %ecx, %rcx
leaq (%rax,%rcx,4), %rsi
movq %rsp, %r12
addq $0xf, %rdx
andq $-0x10, %rdx
subq %rdx, %r12
movq %r12, %rsp
movslq 0xc(%rbx), %rdx
movq %r12, %rdi
callq 0x2080
movq %r14, %rdi
movq %r12, %rsi
callq 0x45e2
movq (%r15), %rax
movq %rax, 0x8(%r14)
movq 0x98(%rbx), %rdi
movl 0x88(%rbx), %esi
callq 0x462e
xorl %eax, %eax
movq %r13, %rsp
jmp 0x25ea
movl $0x6c, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wwdatabase[P]database/./rcdmana/rm_filehandle.h
// Function: RM_FileHandle::updateRec(RM_Record const&)
RC RM_FileHandle::updateRec(const RM_Record &rec) {
    rec.rid.getPageNum(this->pageID);
    this->bufType = bpm->getPage(this->fileID,
                                 this->pageID,
                                 this->index);
    BufType b = this->bufType;
    int tagID ;
    rec.rid.getSlotNum(tagID);

    char *rcd = (char *)(b + recordSize * tagID);
    rec.getData(rcd);
    cout << ">>> update record : (" << fileID << ", " << pageID << ", " << tagID << ") " 
         << string(rcd) << endl;

    bpm->markDirty(index);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movl 0x8(%rsi), %edx
movl %edx, 0x78(%rdi)
movq 0x98(%rdi), %rdi
movl 0x8(%rbx), %esi
leaq 0x88(%rbx), %rcx
callq 0x4570
movq %rax, 0x80(%rbx)
movslq 0xc(%r12), %r15
movslq 0xc(%rbx), %rcx
imulq %r15, %rcx
leaq (%rax,%rcx,4), %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0x46bc
movq 0x646b(%rip), %r12      # 0x8fd8
leaq 0x3526(%rip), %rsi      # 0x609a
movl $0x15, %edx
movq %r12, %rdi
callq 0x2170
movl 0x8(%rbx), %esi
movq %r12, %rdi
callq 0x21f0
movq %rax, %r12
leaq 0x37a4(%rip), %r13      # 0x633a
movl $0x2, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2170
movl 0x78(%rbx), %esi
movq %r12, %rdi
callq 0x21f0
movq %rax, %r12
movl $0x2, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2170
movq %r12, %rdi
movl %r15d, %esi
callq 0x21f0
movq %rax, %r15
leaq 0x349b(%rip), %rsi      # 0x6074
movl $0x2, %edx
movq %rax, %rdi
callq 0x2170
leaq -0x50(%rbp), %r12
leaq -0x29(%rbp), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x467e
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x2170
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20c0
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c4d
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2160
movq 0x98(%rbx), %rdi
movslq 0x88(%rbx), %rsi
movq 0x20(%rdi), %rax
movb $0x1, (%rax,%rsi)
callq 0x462e
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c95
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O1/wwdatabase[P]database/./rcdmana/rm.h
// Function: RecordManager::closeFile(RM_FileHandle&)
RC RecordManager::closeFile(RM_FileHandle &fileHandle) {
    if (fileHandle.fileName == NULL){
        cout << "close file error." << endl;
        return 104;
    }

    bpm->close();
    pfm->closeFile(fileHandle.fileID);
    fileHandle.cleanFileHandle();
    cout << ">>> close file sucessfully." << endl;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpq $0x0, (%rsi)
je 0x3751
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
xorl %r12d, %r12d
movq %r15, %rdi
movl %r12d, %esi
callq 0x51b6
incl %r12d
cmpl $0xea60, %r12d          # imm = 0xEA60
jne 0x36f2
movq (%r14), %r15
movslq 0x8(%rbx), %r14
movq 0x200(%r15), %rdi
movl %r14d, %esi
movl $0x1, %edx
callq 0x50cc
movl (%r15,%r14,4), %edi
callq 0x2250
movq %rbx, %rdi
callq 0x246a
movq 0x589c(%rip), %rdi      # 0x8fd8
leaq 0x2ae9(%rip), %rsi      # 0x622c
movl $0x1b, %edx
callq 0x2170
xorl %ebx, %ebx
jmp 0x376e
movq 0x5880(%rip), %rdi      # 0x8fd8
leaq 0x2abb(%rip), %rsi      # 0x621a
movl $0x11, %edx
callq 0x2170
movl $0x68, %ebx
movq 0x5863(%rip), %r14      # 0x8fd8
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20c0
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wwdatabase[P]database/./rcdmana/rm.h
// Function: RecordManager::parseTableStruct[abi:cxx11](char const*)
map<string, string> RecordManager::parseTableStruct(const char *table) {
    string identifier = "";
    vector<string> strList;
    int idx, len = sizeof(table);
    while (idx < len) {
        if ((table[idx] == ' ') || (table[idx] == ',')) {
            if (identifier != "")
                strList.push_back(identifier);
            identifier = "";
        }
        else {
            identifier += table[idx];
        }
        idx ++;
    }
    map<string, string> tableStruct;
    for (idx = 0; idx < strList.size(); ++idx) {
      //  tableStruct.insert(map<string, string>::value_type(strList[idx], strList[++idx])); 
    }

    return tableStruct;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x29b2(%rip), %rdx      # 0x6179
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x5280
xorl %eax, %eax
leaq -0x50(%rbp), %rdi
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
leaq 0x8(%rbx), %rcx
movl $0x0, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rcx, 0x18(%rbx)
movq %rcx, 0x20(%rbx)
movq %rax, 0x28(%rbx)
callq 0x490c
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x381a
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wwdatabase[P]database/./rcdmana/rm.h
// Function: RecordManager::destroyFile(char const*)
RC RecordManager::destroyFile(const char *fileName) {
    //cout << "remove :" << fileName << endl;
    if (remove(fileName) == 0) {
        cout << ">>> destroy file " << fileName << " sucessful." << endl;
        return 0;
    }
    else{
        cout << "error remove" << endl;
        return 102;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x2230
testl %eax, %eax
je 0x385d
movq 0x5793(%rip), %rdi      # 0x8fd8
leaq 0x28e7(%rip), %rsi      # 0x6133
movl $0xc, %edx
callq 0x2170
movl $0x66, %ebx
jmp 0x38cb
movq 0x5774(%rip), %r14      # 0x8fd8
leaq 0x28aa(%rip), %rsi      # 0x6115
movl $0x11, %edx
movq %r14, %rdi
callq 0x2170
testq %rbx, %rbx
je 0x3899
movq %rbx, %rdi
callq 0x2070
movq 0x574c(%rip), %rdi      # 0x8fd8
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2170
jmp 0x38b1
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x21e0
movq 0x5720(%rip), %rdi      # 0x8fd8
leaq 0x2868(%rip), %rsi      # 0x6127
movl $0xb, %edx
callq 0x2170
xorl %ebx, %ebx
movq 0x5706(%rip), %r14      # 0x8fd8
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20c0
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wwdatabase[P]database/./rcdmana/rm_filescan.h
// Function: RM_FileScan::openScan(RM_FileHandle&, int, int, int, int, void*)
RC RM_FileScan::openScan(RM_FileHandle &fileHandle,
                         AttrType      attrType,
                         int           attrLength,
                         int           attrOffset,  
                         CompOp        compOp,
                         void          *value) {
  fh = &fileHandle;
  if (fh->fileName == NULL) {
    cout << "scan file error with file not open." << endl;
    return 106;
  }
  if ((attrOffset+attrLength) >= fh->recordSize) {
    cout << "scan record error with size invalid." << endl;
    return 107;
  }

  this->rid = RID(1, 0);
  this->recordScanNum = 0;
  this->attrType = attrType;
  this->attrLength = attrLength;
  this->attrOffset = attrOffset;
  this->compOp = compOp;
  this->value = value;
  cout << "Open scan" << endl;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, (%rdi)
cmpq $0x0, (%rsi)
je 0x397e
leal (%r8,%rcx), %eax
cmpl 0xc(%rsi), %eax
jge 0x399d
movq 0x10(%rbp), %rax
movq $0x1, 0x34(%rdi)
movl $0x0, 0x30(%rdi)
movl %edx, 0x8(%rdi)
movl %ecx, 0xc(%rdi)
movl %r8d, 0x10(%rdi)
movl %r9d, 0x14(%rdi)
movq %rax, 0x18(%rdi)
movq 0x566f(%rip), %rdi      # 0x8fd8
leaq 0x2921(%rip), %rsi      # 0x6291
movl $0x9, %edx
callq 0x2170
xorl %ebx, %ebx
jmp 0x39ba
movq 0x5653(%rip), %rdi      # 0x8fd8
leaq 0x28bc(%rip), %rsi      # 0x6248
movl $0x23, %edx
callq 0x2170
movl $0x6a, %ebx
jmp 0x39ba
movq 0x5634(%rip), %rdi      # 0x8fd8
leaq 0x28c1(%rip), %rsi      # 0x626c
movl $0x24, %edx
callq 0x2170
movl $0x6b, %ebx
movq 0x5617(%rip), %r14      # 0x8fd8
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20c0
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wwdatabase[P]database/./rcdmana/rm_filescan.h
// Function: RM_FileScan::incRID()
RC RM_FileScan::incRID() {
  if ((this->rid.slotNum+1) < this->fh->recordNumForEachPage) {
    this->rid.slotNum ++;
  }
  else{
    this->rid.pageNum ++;
    this->rid.slotNum = 0;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x38(%rdi), %eax
incl %eax
movq (%rdi), %rcx
cmpl 0x64(%rcx), %eax
jl 0x3ea4
incl 0x34(%rdi)
xorl %eax, %eax
movl %eax, 0x38(%rdi)
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wwdatabase[P]database/./rcdmana/../bufmanager/BufPageManager.h
// Function: BufPageManager::getPage(int, int, int&)
BufType getPage(int fileID, int pageID, int& index) {
		index = hash->findIndex(fileID, pageID);
		if (index != -1) {
			access(index);
			return addr[index];
		} else {
			BufType b = fetchPage(fileID, pageID, index);
			fileManager->readPage(fileID, pageID, b, 0);
			return b;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x4a48
movl %eax, (%r14)
movq %rbx, %rdi
cmpl $-0x1, %eax
je 0x45af
movl %eax, %esi
callq 0x462e
movq 0x28(%rbx), %rax
movslq (%r14), %rcx
movq (%rax,%rcx,8), %r14
jmp 0x45d5
movl %r12d, %esi
movl %r15d, %edx
movq %r14, %rcx
callq 0x4a92
movq %rax, %r14
movq 0x8(%rbx), %rdi
movl %r12d, %esi
movl %r15d, %edx
movq %rax, %rcx
xorl %r8d, %r8d
callq 0x4b38
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wwdatabase[P]database/./rcdmana/rm_record.h
// Function: RM_Record::setData(char const*)
RC setData(const char *pData) {
        if (this->data != NULL) {
            delete [] this->data;
            this->data = NULL;
        }
        if (pData == NULL)
            return 0;
        int len = strlen(pData);
        this->data = new char[len];
        strcpy(this->data, pData);
        return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x4603
callq 0x2190
movq $0x0, (%r14)
testq %rbx, %rbx
je 0x4626
movq %rbx, %rdi
callq 0x2070
movslq %eax, %rdi
callq 0x2030
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2120
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop