LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x655e
movq 0x78(%rbx), %rdx
addq $0x70, %rbx
leaq 0x3201(%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_O3/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 0x80b2(%rip), %rbx      # 0x15fe8
leaq 0x2af9(%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 0x8388(%rip), %rax      # 0x16300
movl (%rax), %edi
cmpl $-0x1, %edi
je 0xdf84
callq 0x35b0
leaq 0x8885(%rip), %rsi      # 0x16810
movq (%rsi), %rdi
callq 0xe6eb
leaq 0x888e(%rip), %rsi      # 0x16828
movq 0x18(%rsi), %rdi
addq $0x8, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xe731
// File: /workspace/github_cpp_makefile_star2_O3/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 0x84a8(%rip), %r15      # 0x16810
movq (%r15), %rbx
cmpq %r15, %rbx
je 0xe3bf
movq 0x10(%rbx), %r14
cmpl $-0x1, (%r14)
je 0xe384
cmpb $0x1, 0xd8(%r14)
jne 0xe3ba
movq %r14, %rdi
callq 0xea5a
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 0xe36b
movq (%rbx), %rbx
jmp 0xe36b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8493(%rip), %rcx      # 0x16888
movq 0x10(%rcx), %rsi
testq %rsi, %rsi
je 0xe437
leaq 0x8(%rcx), %rax
movl 0x68(%rbx), %edx
xorl %edi, %edi
cmpl %edx, 0x20(%rsi)
setl %dil
cmovgeq %rsi, %rax
movq 0x10(%rsi,%rdi,8), %rsi
testq %rsi, %rsi
jne 0xe405
addq $0x8, %rcx
cmpq %rcx, %rax
je 0xe437
cmpl 0x20(%rax), %edx
jl 0xe437
leaq -0x198(%rbp), %rsi
movq %rbx, %rdi
callq *0x28(%rax)
movq 0x7b6a(%rip), %rsi      # 0x15fa8
leaq -0x198(%rbp), %rdi
callq 0x33f0
leaq -0x120(%rbp), %rdi
callq 0x3110
leaq 0x70(%rbx), %rsi
movq %rbx, %rdi
callq 0x6a0a
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
movq %rax, %r14
movq 0x7b2b(%rip), %rsi      # 0x15fa8
leaq -0x198(%rbp), %rdi
callq 0x33f0
leaq -0x120(%rbp), %rdi
callq 0x3110
jmp 0xe49d
movq %rdx, %r15
movq %rax, %r14
cmpl $0x1, %r15d
jne 0xe4e7
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 0xeb42
leaq 0x1bff(%rip), %rsi      # 0x100cc
movq %rax, %rdi
callq 0xb044
callq 0x34c0
jmp 0xe456
movq %rax, %r14
callq 0x34c0
movq %r14, %rdi
callq 0x3530
movq %rax, %rdi
callq 0x6550
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5ffa
movl (%rbx), %edi
cmpl $-0x1, %edi
je 0xea74
callq 0x35b0
cmpl $0x5, 0x68(%rbx)
jne 0xea82
movq %rbx, %rdi
callq 0x586c
leaq 0xe0(%rbx), %rdi
callq 0xdbba
movq 0xb0(%rbx), %rdi
leaq 0xc0(%rbx), %rax
cmpq %rax, %rdi
je 0xeaac
movq (%rax), %rsi
incq %rsi
callq 0x32f0
movq 0x90(%rbx), %rdi
leaq 0xa0(%rbx), %rax
cmpq %rax, %rdi
je 0xeaca
movq (%rax), %rsi
incq %rsi
callq 0x32f0
movq 0x70(%rbx), %rdi
leaq 0x80(%rbx), %rax
cmpq %rax, %rdi
je 0xeae5
movq (%rax), %rsi
incq %rsi
callq 0x32f0
movq 0x48(%rbx), %rdi
leaq 0x58(%rbx), %rax
cmpq %rax, %rdi
je 0xeafd
movq (%rax), %rsi
incq %rsi
callq 0x32f0
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0xeb15
movq (%rax), %rsi
incq %rsi
callq 0x32f0
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0xeb33
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 0x6550
// File: /workspace/github_cpp_makefile_star2_O3/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 0xee25
movl (%rdi), %ecx
cmpl %eax, %ecx
cmovlel %eax, %ecx
movl %ecx, (%rdi)
cmpb $0x0, 0xd8(%rsi)
jne 0xedf4
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 0x7c6b(%rip), %rdx      # 0x16a50
orq %rdi, (%rdx,%rcx,8)
leaq 0x7d60(%rip), %rdx      # 0x16b50
orq %rdi, (%rdx,%rcx,8)
cmpq $0x0, 0x10(%rsi)
je 0xee25
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 0x7caf(%rip), %rcx      # 0x16ad0
orq %rsi, (%rcx,%rax,8)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl (%rsi), %eax
cmpl $-0x1, %eax
je 0xeec5
movq %rsi, %rbx
leal 0x3f(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
sarl $0x6, %ecx
movslq %ecx, %rcx
leaq 0x7cff(%rip), %rdx      # 0x16b50
movq (%rdx,%rcx,8), %rcx
btq %rax, %rcx
jae 0xee6a
movq %rbx, %rdi
callq 0x563c
movl (%rbx), %eax
cmpl $-0x1, %eax
je 0xeec5
leal 0x3f(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
sarl $0x6, %ecx
movslq %ecx, %rcx
leaq 0x7bd1(%rip), %rdx      # 0x16a50
movq (%rdx,%rcx,8), %rcx
btq %rax, %rcx
jae 0xee98
movq %rbx, %rdi
callq 0x5c8e
movl (%rbx), %eax
cmpl $-0x1, %eax
je 0xeec5
leal 0x3f(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
sarl $0x6, %ecx
movslq %ecx, %rcx
leaq 0x7c23(%rip), %rdx      # 0x16ad0
movq (%rdx,%rcx,8), %rcx
btq %rax, %rcx
jae 0xeec5
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5ffa
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7942(%rip), %rcx      # 0x16828
movq 0x10(%rcx), %rsi
testq %rsi, %rsi
je 0xef2d
leaq 0x8(%rcx), %rax
movl (%r14), %edx
xorl %edi, %edi
cmpl %edx, 0x20(%rsi)
setl %dil
cmovgeq %rsi, %rax
movq 0x10(%rsi,%rdi,8), %rsi
testq %rsi, %rsi
jne 0xeef6
addq $0x8, %rcx
cmpq %rcx, %rax
je 0xef2d
cmpl 0x20(%rax), %edx
jl 0xef2d
movq 0x28(%rax), %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 0x1b92(%rip), %rsi      # 0x10af5
movl $0xc, %edx
callq 0x3370
movl (%r14), %esi
leaq -0x1b0(%rbp), %rdi
callq 0x3510
leaq 0x1b7f(%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 0x7033(%rip), %rsi      # 0x15ff0
movq 0x6fec(%rip), %rdx      # 0x15fb0
movq %rbx, %rdi
callq 0x3500
movq %rax, %r14
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xeff0
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x32f0
jmp 0xeff0
movq %rax, %r14
movb $0x1, %r15b
movq 0x6fc1(%rip), %rsi      # 0x15fb8
leaq -0x1b0(%rbp), %rdi
callq 0x3190
leaq -0x140(%rbp), %rdi
callq 0x3110
testb %r15b, %r15b
jne 0xf019
jmp 0xf021
movq %rax, %r14
movq %rbx, %rdi
callq 0x3250
movq %r14, %rdi
callq 0x3530
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1872
movq %rax, 0x18(%rbx)
movq 0x20(%rbx), %rax
testq %rax, %rax
js 0x17a1
cvtsi2ss %rax, %xmm0
jmp 0x17b8
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_O3/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 0x17fc
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 0x184c
movl %eax, %r14d
xorl %r15d, %r15d
movabsq $0x100000000, %r12      # imm = 0x100000000
xorl %r13d, %r13d
movq (%rbx), %rsi
addq %r15, %rsi
movq %rbx, %rdi
callq 0x188e
movl %eax, %esi
movq %rax, %rdx
shrq $0x20, %rdx
addq %r13, %rsi
movq %rbx, %rdi
callq 0x18e0
addq %r12, %r13
addq $0x8, %r15
decq %r14
jne 0x181e
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x18d5
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 0x18c2
shlq $0x20, %rcx
movl %eax, %eax
orq %rcx, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1931
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 0x1900
jmp 0x1934
movq %rsi, %r8
andq %rax, %r8
movl %esi, %eax
orq %r8, %rax
movq %rax, (%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r8
movq 0x8(%rdi), %rax
subq %r8, %rax
sarq $0x3, %rax
cmpq 0x28(%rdi), %rax
jae 0x19d0
movl (%rbx), %edi
movabsq $-0x61c8864680b583eb, %rcx # imm = 0x9E3779B97F4A7C15
movq %rdi, %rax
mulq %rcx
xorq %rax, %rdx
movzbl %dl, %esi
movb 0x36(%r14), %cl
shrq %cl, %rdx
orl $0x100, %esi            # imm = 0x100
movq 0x18(%r14), %rax
movq 0x20(%r14), %rcx
xorl %r9d, %r9d
movl %edx, %edx
cmpl (%rax,%rdx,8), %esi
jne 0x19a2
movl 0x4(%rax,%rdx,8), %r10d
cmpl (%r8,%r10,8), %edi
jne 0x19a4
jmp 0x19b5
ja 0x19bd
addl $0x100, %esi            # imm = 0x100
incl %edx
cmpq %rdx, %rcx
cmovel %r9d, %edx
jmp 0x198e
leaq (%r8,%r10,8), %rax
xorl %edx, %edx
jmp 0x19c8
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1a30
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x19de
movq (%r14), %r8
jmp 0x195e
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1a2b
movq %rdi, %rbx
decb 0x36(%rdi)
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x1a13
movq 0x20(%rbx), %rsi
shlq $0x3, %rsi
callq 0x10e0
movq $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movq %rbx, %rdi
callq 0x1756
movq %rbx, %rdi
popq %rbx
jmp 0x17d8
callq 0x1a97
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6a7(%rip), %rsi       # 0x20f8
leaq 0xf(%rsp), %rcx
callq 0x1ae0
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 0x18e0
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_O3/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 0x29f1
movq %rbx, %rdi
callq 0x2ed6
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x35d9(%rip), %rdi      # 0x5fd8
callq 0x21d0
leaq 0x168e(%rip), %rsi      # 0x4099
movq %rax, %rdi
callq 0x2190
xorl %edi, %edi
callq 0x21e0
movq %rax, %r15
movq 0x220(%rbx), %rdi
testq %rdi, %rdi
je 0x2a2e
callq 0x2170
movq %r14, %rdi
callq 0x2bd8
movq %rbx, %rdi
callq 0x2040
movq %r15, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/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 0x34f6
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 0x3112
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 0x2ba3
callq 0x2170
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x2ba3
callq 0x2170
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x2bae
movq %rax, %r14
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x2bbf
callq 0x2170
leaq 0x18(%rbx), %rdi
callq 0x2bd8
movq %rbx, %rdi
callq 0x2bd8
movq %r14, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2c9b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x332f(%rip), %rdi      # 0x5fd8
callq 0x21d0
leaq 0x144a(%rip), %rsi      # 0x40ff
movq %rax, %rdi
callq 0x2190
xorl %edi, %edi
callq 0x21e0
movq %rax, %r15
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x2cd4
callq 0x2170
movq %rbx, %rdi
callq 0x2200
movq %r15, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/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
cmpl %edx, %ecx
setl %al
testl %ecx, %ecx
setle %r8b
orb %al, %r8b
movl $0x3, %eax
jne 0x2d8c
pushq %rbp
movq %rsp, %rbp
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
xorpd %xmm0, %xmm0
movl $0x1, %edi
movsd 0x12db(%rip), %xmm2     # 0x4010
movapd 0x12e3(%rip), %xmm3     # 0x4020
xorpd %xmm1, %xmm1
movsd (%rsi,%rdi,8), %xmm4
ucomisd %xmm2, %xmm4
jne 0x2d4e
jnp 0x2d67
movq (%rdx), %r8
movsd (%r8,%rdi,8), %xmm5
mulsd %xmm5, %xmm4
andpd %xmm3, %xmm5
addsd %xmm5, %xmm0
addsd %xmm4, %xmm1
incq %rdi
cmpq %rdi, %rcx
jne 0x2d41
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jne 0x2d7b
jnp 0x2d8b
divsd %xmm0, %xmm1
addsd 0x1291(%rip), %xmm1     # 0x4018
cvttsd2si %xmm1, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2627
movq %rsi, %r14
xorl %eax, %eax
leaq 0x18(%rsp), %r12
xorl %r13d, %r13d
movq %r15, 0x30(%rsp)
subq %rax, %rbx
jne 0x24ea
xorl %ebp, %ebp
jmp 0x2569
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 0x2510
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 0x1a72(%rip), %rcx      # 0x4010
movsbl (%rax,%rcx), %esi
leaq 0x8(%rsp), %rdi
callq 0x2100
decl %ebx
jne 0x2581
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
testq %rdx, %rdx
setne %cl
leaq (%rsi,%rdx), %rax
decq %rax
cmpq %rsi, %rax
seta %dil
andb %cl, %dil
cmpb $0x1, %dil
jne 0x25fd
incq %rsi
movb -0x1(%rsi), %cl
movb (%rax), %dl
movb %dl, -0x1(%rsi)
movb %cl, (%rax)
decq %rax
leaq 0x1(%rsi), %rcx
cmpq %rax, %rsi
movq %rcx, %rsi
jb 0x25da
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x2060
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2614
callq 0x2130
movslq %r13d, %rax
movq 0x8(%r14), %rbx
subq (%r14), %rbx
cmpq %rax, %rbx
ja 0x24e1
movq %r15, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x263b
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x264d
callq 0x2130
movq (%r15), %rdi
cmpq 0x28(%rsp), %rdi
je 0x265c
callq 0x2130
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4478
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 0x44ea
movq (%r15), %rax
movq %rax, 0x8(%r14)
movq 0x98(%rbx), %rdi
movl 0x88(%rbx), %esi
callq 0x4536
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_O3/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 0x4478
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 0x45c0
movq 0x64bd(%rip), %r12      # 0x8fd8
leaq 0x3578(%rip), %rsi      # 0x609a
movl $0x15, %edx
movq %r12, %rdi
callq 0x2170
movl 0x8(%rbx), %esi
movq %r12, %rdi
callq 0x21f0
movq %rax, %r12
leaq 0x37f6(%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 0x34ed(%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 0x4582
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 0x2bfb
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 0x4536
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 0x2c43
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x36c5
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
xorl %r12d, %r12d
movq %r15, %rdi
movl %r12d, %esi
callq 0x50da
incl %r12d
cmpl $0xea60, %r12d          # imm = 0xEA60
jne 0x3666
movq (%r14), %r15
movslq 0x8(%rbx), %r14
movq 0x200(%r15), %rdi
movl %r14d, %esi
movl $0x1, %edx
callq 0x4f8c
movl (%r15,%r14,4), %edi
callq 0x2250
movq %rbx, %rdi
callq 0x246a
movq 0x5928(%rip), %rdi      # 0x8fd8
leaq 0x2b75(%rip), %rsi      # 0x622c
movl $0x1b, %edx
callq 0x2170
xorl %ebx, %ebx
jmp 0x36e2
movq 0x590c(%rip), %rdi      # 0x8fd8
leaq 0x2b47(%rip), %rsi      # 0x621a
movl $0x11, %edx
callq 0x2170
movl $0x68, %ebx
movq 0x58ef(%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_O3/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 0x2a3e(%rip), %rdx      # 0x6179
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x519e
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 0x4812
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x378e
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_O3/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 0x37d1
movq 0x581f(%rip), %rdi      # 0x8fd8
leaq 0x2973(%rip), %rsi      # 0x6133
movl $0xc, %edx
callq 0x2170
movl $0x66, %ebx
jmp 0x383f
movq 0x5800(%rip), %r14      # 0x8fd8
leaq 0x2936(%rip), %rsi      # 0x6115
movl $0x11, %edx
movq %r14, %rdi
callq 0x2170
testq %rbx, %rbx
je 0x380d
movq %rbx, %rdi
callq 0x2070
movq 0x57d8(%rip), %rdi      # 0x8fd8
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2170
jmp 0x3825
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x21e0
movq 0x57ac(%rip), %rdi      # 0x8fd8
leaq 0x28f4(%rip), %rsi      # 0x6127
movl $0xb, %edx
callq 0x2170
xorl %ebx, %ebx
movq 0x5792(%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_O3/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 0x38f2
leal (%r8,%rcx), %eax
cmpl 0xc(%rsi), %eax
jge 0x3911
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 0x56fb(%rip), %rdi      # 0x8fd8
leaq 0x29ad(%rip), %rsi      # 0x6291
movl $0x9, %edx
callq 0x2170
xorl %ebx, %ebx
jmp 0x392e
movq 0x56df(%rip), %rdi      # 0x8fd8
leaq 0x2948(%rip), %rsi      # 0x6248
movl $0x23, %edx
callq 0x2170
movl $0x6a, %ebx
jmp 0x392e
movq 0x56c0(%rip), %rdi      # 0x8fd8
leaq 0x294d(%rip), %rsi      # 0x626c
movl $0x24, %edx
callq 0x2170
movl $0x6b, %ebx
movq 0x56a3(%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_O3/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 0x3e16
incl 0x34(%rdi)
xorl %eax, %eax
movl %eax, 0x38(%rdi)
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4950
movl %eax, (%r14)
movq %rbx, %rdi
cmpl $-0x1, %eax
je 0x44b7
movl %eax, %esi
callq 0x4536
movq 0x28(%rbx), %rax
movslq (%r14), %rcx
movq (%rax,%rcx,8), %r14
jmp 0x44dd
movl %r12d, %esi
movl %r15d, %edx
movq %r14, %rcx
callq 0x499a
movq %rax, %r14
movq 0x8(%rbx), %rdi
movl %r12d, %esi
movl %r15d, %edx
movq %rax, %rcx
xorl %r8d, %r8d
callq 0x4a9e
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x450b
callq 0x2190
movq $0x0, (%r14)
testq %rbx, %rbx
je 0x452e
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
// File: /workspace/github_cpp_makefile_star2_O3/wwdatabase[P]database/./rcdmana/../bufmanager/BufPageManager.h
// Function: BufPageManager::access(int)
void access(int index) {
		if (index == last) {
			return;
		}
		replace->access(index);
		last = index;
	}

// Assembly:
cmpl %esi, (%rdi)
je 0x4581
pushq %rbp
movq %rsp, %rbp
movq 0x18(%rdi), %rax
movq (%rax), %rdx
movq 0x8(%rdx), %rax
movslq %esi, %rcx
movl 0x4(%rax,%rcx,8), %esi
cmpl %ecx, %esi
je 0x4568
movslq %esi, %r8
movslq (%rax,%rcx,8), %r9
movl %r9d, (%rax,%r8,8)
movl %esi, 0x4(%rax,%r9,8)
movl %ecx, 0x4(%rax,%rcx,8)
movslq (%rdx), %rdx
movslq 0x4(%rax,%rdx,8), %rsi
movl %ecx, (%rax,%rsi,8)
movl %esi, 0x4(%rax,%rcx,8)
movl %edx, (%rax,%rcx,8)
movl %ecx, 0x4(%rax,%rdx,8)
movl %ecx, (%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wwdatabase[P]database/./rcdmana/rm_record.h
// Function: RM_Record::getData(char*) const
RC getData(char *pData) const{
        if (data == NULL) {
            cout << "Error with record, get data func" << endl;
        }
    	strcpy(pData, data);
    	return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
jne 0x461d
movq %rdi, %r14
movq 0x49f9(%rip), %r15      # 0x8fd8
leaq 0x1d57(%rip), %rsi      # 0x633d
movl $0x20, %edx
movq %r15, %rdi
callq 0x2170
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20c0
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x2120
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wwdatabase[P]database/./rcdmana/../bufmanager/BufPageManager.h
// Function: BufPageManager::BufPageManager(FileManager*)
BufPageManager(FileManager* fm) {
		int c = CAP;
		int m = MOD;
		last = -1;
		fileManager = fm;
		//bpl = new MyLinkList(CAP, MAX_FILE_NUM);
		dirty = new bool[CAP];
		addr = new BufType[CAP];
		hash = new MyHashMap(c, m);
	    replace = new FindReplace(c);
		for (int i = 0; i < CAP; ++ i) {
			dirty[i] = false;
			addr[i] = NULL;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0xffffffff, (%rdi)     # imm = 0xFFFFFFFF
movq %rsi, 0x8(%rdi)
movl $0xea60, %edi           # imm = 0xEA60
callq 0x2030
movq %rax, 0x20(%rbx)
movl $0x75300, %edi          # imm = 0x75300
callq 0x2030
movq %rax, 0x28(%rbx)
movl $0x18, %edi
callq 0x2150
movq %rax, %r14
movq %rax, %rdi
movl $0xea60, %esi           # imm = 0xEA60
movl $0xea60, %edx           # imm = 0xEA60
callq 0x4d4e
movq %r14, 0x10(%rbx)
movl $0x10, %edi
callq 0x2150
movq %rax, %r14
movq %rax, %rdi
movl $0xea60, %esi           # imm = 0xEA60
callq 0x4dda
movq %r14, 0x18(%rbx)
xorl %eax, %eax
movq 0x20(%rbx), %rcx
movb $0x0, (%rcx,%rax)
movq 0x28(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
cmpq $0xea60, %rax           # imm = 0xEA60
jne 0x471b
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movl $0x10, %esi
jmp 0x4751
movq %rax, %rbx
movl $0x18, %esi
movq %r14, %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x2200
nop