LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0xdd7e(%rip), %rdi      # 0x29948
callq 0x1bd80
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xe530
leaq 0xdd61(%rip), %rdi      # 0x29948
callq 0xe350
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xe530
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1bdb0
testb $0x1, %al
jne 0x1bc13
jmp 0x1bd58
movb $0x1, -0x1cd(%rbp)
movl $0x10, %edi
callq 0x4250
movq %rax, -0x1d8(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x4590
jmp 0x1bc39
leaq -0x13030(%rip), %rsi    # 0x8c10
leaq -0x1c0(%rbp), %rdi
callq 0x8be0
movq %rax, -0x1e0(%rbp)
jmp 0x1bc55
movq -0x1e0(%rbp), %rdi
leaq 0xe80(%rip), %rsi       # 0x1cae3
callq 0x1be10
movq %rax, -0x1e8(%rbp)
jmp 0x1bc71
movq -0x1e8(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x148c0
movq %rax, -0x1f0(%rbp)
jmp 0x1bc8a
movq -0x1f0(%rbp), %rdi
leaq 0xe58(%rip), %rsi       # 0x1caf0
callq 0x1bde0
movq %rax, -0x1f8(%rbp)
jmp 0x1bca6
movq -0x1f8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x4440
jmp 0x1bcb8
movq -0x1d8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4630
jmp 0x1bcca
movq -0x1d8(%rbp), %rdi
movb $0x0, -0x1cd(%rbp)
movq 0xd311(%rip), %rsi      # 0x28ff0
movq 0xd2d2(%rip), %rdx      # 0x28fb8
callq 0x46a0
jmp 0x1bd7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
jmp 0x1bd3f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
jmp 0x1bd33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x47d8
leaq -0x1c0(%rbp), %rdi
callq 0x4100
testb $0x1, -0x1cd(%rbp)
jne 0x1bd4a
jmp 0x1bd56
movq -0x1d8(%rbp), %rdi
callq 0x4350
jmp 0x1bd6e
leaq -0x10(%rbp), %rdi
callq 0x1be40
movq 0x8(%rax), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x1c8(%rbp), %rdi
callq 0x46d0
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/unordered_dense/test.cpp
// Function: test_int(unsigned int, unsigned int)
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	ankerl::unordered_dense::map<uint32_t, uint32_t, Hash32> h;
	for (i = 0, x = x0; i < n; ++i) {
		x = hash32(x);
#ifndef UDB2_TEST_DEL
		z += ++h[get_key(n, x)];
#else
		auto p = h.try_emplace(get_key(n, x), i);
		if (p.second == false) h.erase(p.first);
#endif
	}
	fprintf(stderr, "# unique keys: %ld; checksum: %u\n", h.size(), z);
	return h.size();
}

// Assembly:
subq $0x88, %rsp
movl %edi, 0x84(%rsp)
movl %esi, 0x80(%rsp)
movl $0x0, 0x74(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x17a0
movl $0x0, 0x7c(%rsp)
movl 0x80(%rsp), %eax
movl %eax, 0x78(%rsp)
movl 0x7c(%rsp), %eax
cmpl 0x84(%rsp), %eax
jae 0x1721
movl 0x78(%rsp), %edi
callq 0x12f0
movl %eax, 0x24(%rsp)
jmp 0x16aa
movl 0x24(%rsp), %eax
movl %eax, 0x78(%rsp)
movl 0x84(%rsp), %edi
movl 0x78(%rsp), %esi
callq 0x1360
movl %eax, 0x20(%rsp)
jmp 0x16c8
movl 0x20(%rsp), %eax
movl %eax, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1820
movq %rax, 0x18(%rsp)
jmp 0x16e6
movq 0x18(%rsp), %rcx
movl (%rcx), %eax
addl $0x1, %eax
movl %eax, (%rcx)
addl 0x74(%rsp), %eax
movl %eax, 0x74(%rsp)
movl 0x7c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x7c(%rsp)
jmp 0x168a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x1880
jmp 0x1778
movq 0x58b8(%rip), %rax      # 0x6fe0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x1870
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl 0x74(%rsp), %ecx
leaq 0x2930(%rip), %rsi      # 0x407d
movb $0x0, %al
callq 0x1120
leaq 0x38(%rsp), %rdi
callq 0x1870
movl %eax, 0x14(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x1880
movl 0x14(%rsp), %eax
addq $0x88, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x1170
nopw %cs:(%rax,%rax)
// File: 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>::reserve(unsigned long)
void reserve(size_t capa) {
        capa = (std::min)(capa, max_size());
        if constexpr (has_reserve<value_container_type>) {
            // std::deque doesn't have reserve(). Make sure we only call when available
            m_values.reserve(capa);
        }
        auto shifts = calc_shifts_for_size((std::max)(capa, size()));
        if (0 == m_num_buckets || shifts < m_shifts) {
            m_shifts = shifts;
            deallocate_buckets();
            allocate_buckets_from_shift();
            clear_and_fill_buckets_from_values();
        }
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x1c30
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1bf0
movq 0x8(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rsi
callq 0x1c40
movq 0x8(%rsp), %rdi
callq 0x1870
movq %rax, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1e40
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
callq 0x1d50
movq 0x8(%rsp), %rcx
movb %al, 0x1f(%rsp)
xorl %eax, %eax
cmpq 0x20(%rcx), %rax
je 0x1ac6
movq 0x8(%rsp), %rcx
movzbl 0x1f(%rsp), %eax
movzbl 0x36(%rcx), %ecx
cmpl %ecx, %eax
jge 0x1aeb
movq 0x8(%rsp), %rdi
movb 0x1f(%rsp), %al
movb %al, 0x36(%rdi)
callq 0x1e80
movq 0x8(%rsp), %rdi
callq 0x1f50
movq 0x8(%rsp), %rdi
callq 0x20b0
addq $0x38, %rsp
retq
// File: 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>::calc_shifts_for_size(unsigned long) const
[[nodiscard]] constexpr auto calc_shifts_for_size(size_t s) const -> uint8_t {
        auto shifts = initial_shifts;
        while (shifts > 0 && static_cast<size_t>(static_cast<float>(calc_num_buckets(shifts)) * max_load_factor()) < s) {
            --shifts;
        }
        return shifts;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movb $0x3d, 0x27(%rsp)
movzbl 0x27(%rsp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x17(%rsp)
jle 0x1e19
movzbl 0x27(%rsp), %edi
callq 0x2600
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, 0xc(%rsp)
testq %rax, %rax
movss %xmm0, 0x10(%rsp)
js 0x1dc4
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movss 0x10(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
callq 0x2650
movaps %xmm0, %xmm1
movss 0x8(%rsp), %xmm0
mulss %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttss2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movss 0x2226(%rip), %xmm1     # 0x4024
subss %xmm1, %xmm0
cvttss2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
cmpq 0x28(%rsp), %rax
setb %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x1e23
jmp 0x1e32
movb 0x27(%rsp), %al
addb $-0x1, %al
movb %al, 0x27(%rsp)
jmp 0x1d6d
movb 0x27(%rsp), %al
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/unordered_dense/./unordered_dense.h
// Function: ankerl::unordered_dense::v4_1_2::detail::table<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, ankerl::unordered_dense::v4_1_2::bucket_type::standard, false>::deallocate_buckets()
void deallocate_buckets() {
        auto ba = bucket_alloc(m_values.get_allocator());
        if (nullptr != m_buckets) {
            bucket_alloc_traits::deallocate(ba, m_buckets, bucket_count());
            m_buckets = nullptr;
        }
        m_num_buckets = 0;
        m_max_bucket_capacity = 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rsi
movq %rsi, 0x10(%rsp)
leaq 0x2e(%rsp), %rdi
callq 0x2670
leaq 0x2f(%rsp), %rdi
leaq 0x2e(%rsp), %rsi
callq 0x26b0
leaq 0x2e(%rsp), %rdi
callq 0x19e0
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq 0x18(%rcx), %rax
je 0x1f13
movq 0x10(%rsp), %rdi
movq 0x18(%rdi), %rax
movq %rax, 0x8(%rsp)
callq 0x2700
movq 0x8(%rsp), %rsi
movq %rax, %rdx
leaq 0x2f(%rsp), %rdi
callq 0x26d0
jmp 0x1eea
movq 0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
jmp 0x1f13
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x2f(%rsp), %rdi
callq 0x2710
jmp 0x1f37
movq 0x10(%rsp), %rax
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
leaq 0x2f(%rsp), %rdi
callq 0x2710
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x1170
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rsi
movq %rsi, 0x28(%rsp)
leaq 0x4e(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x2670
movq 0x18(%rsp), %rsi
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x26b0
movq 0x18(%rsp), %rdi
callq 0x19e0
movq 0x28(%rsp), %rax
movzbl 0x36(%rax), %edi
callq 0x2600
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x20(%rax), %rsi
callq 0x27a0
movq %rax, 0x30(%rsp)
jmp 0x1fbf
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x2660
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jne 0x201b
callq 0x2660
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x28(%rax)
jmp 0x2090
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x4f(%rsp), %rdi
callq 0x2710
jmp 0x209f
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, 0x8(%rsp)
testq %rax, %rax
movss %xmm0, 0xc(%rsp)
js 0x205d
movss 0x8(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
callq 0x2650
movq 0x28(%rsp), %rax
movaps %xmm0, %xmm1
movss 0x4(%rsp), %xmm0
mulss %xmm1, %xmm0
cvttss2si %xmm0, %rcx
movl %ecx, %ecx
movq %rcx, 0x28(%rax)
leaq 0x4f(%rsp), %rdi
callq 0x2710
addq $0x58, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x1170
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x2850
movq 0x8(%rsp), %rdi
movl $0x0, 0x2c(%rsp)
callq 0x2190
movl %eax, 0x28(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x28(%rsp), %eax
jae 0x2149
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x28b0
movq %rax, %rdi
callq 0x28a0
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
callq 0x28d0
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x1c(%rsp), %edx
movq 0x10(%rsp), %rsi
callq 0x2980
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x20de
addq $0x38, %rsp
retq
nop
// File: 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]] auto next_while_less(K const& key) const -> Bucket {
        auto hash = mixed_hash(key);
        auto dist_and_fingerprint = dist_and_fingerprint_from_hash(hash);
        auto bucket_idx = bucket_idx_from_hash(hash);

        while (dist_and_fingerprint < at(m_buckets, bucket_idx).m_dist_and_fingerprint) {
            dist_and_fingerprint = dist_inc(dist_and_fingerprint);
            bucket_idx = next(bucket_idx);
        }
        return {dist_and_fingerprint, bucket_idx};
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x20(%rsp), %rsi
callq 0x2a30
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
callq 0x2a60
movq 0x8(%rsp), %rdi
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rsi
callq 0x2a80
movl %eax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, 0x4(%rsp)
movq 0x18(%rax), %rdi
movl 0x10(%rsp), %eax
movl %eax, %esi
callq 0x2aa0
movq %rax, %rcx
movl 0x4(%rsp), %eax
cmpl (%rcx), %eax
jae 0x2965
movl 0x14(%rsp), %edi
callq 0x2ac0
movq 0x8(%rsp), %rdi
movl %eax, 0x14(%rsp)
movl 0x10(%rsp), %esi
callq 0x2ad0
movl %eax, 0x10(%rsp)
jmp 0x291d
movl 0x14(%rsp), %eax
movl %eax, 0x30(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x34(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x18(%rax), %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x2aa0
movq %rax, %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x2a06
movq (%rsp), %rax
movq 0x18(%rax), %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x2aa0
movq %rax, %rdi
leaq 0x20(%rsp), %rsi
callq 0x2bf0
movq %rax, 0xc(%rsp)
movq 0xc(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x20(%rsp), %edi
callq 0x2ac0
movq (%rsp), %rdi
movl %eax, 0x20(%rsp)
movl 0x14(%rsp), %esi
callq 0x2ad0
movl %eax, 0x14(%rsp)
jmp 0x299b
movq (%rsp), %rax
movq 0x18(%rax), %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x2aa0
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rax), %rax
movq %rax, 0x8(%rsp)
callq 0x2660
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jne 0x2f92
callq 0x3160
movq (%rsp), %rdi
movb 0x36(%rdi), %al
addb $-0x1, %al
movb %al, 0x36(%rdi)
callq 0x1e80
movq (%rsp), %rdi
callq 0x1f50
movq (%rsp), %rdi
callq 0x20b0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl %edx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rsi
leaq 0x38(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x32b0
callq 0x32e0
movq (%rsp), %rdx
movq 0x8(%rsp), %rdi
leaq 0x1038(%rip), %rsi      # 0x4110
leaq 0x37(%rsp), %rcx
callq 0x3210
movq 0x8(%rsp), %rdi
callq 0x2190
movq 0x8(%rsp), %rdi
decl %eax
movl %eax, 0x30(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x28(%rsp)
movl 0x30(%rsp), %eax
movl %eax, 0x2c(%rsp)
movl 0x48(%rsp), %edx
movq 0x28(%rsp), %rsi
callq 0x2980
movq 0x8(%rsp), %rdi
callq 0x2ff0
movq %rax, 0x18(%rsp)
movl 0x30(%rsp), %eax
movl %eax, %esi
leaq 0x18(%rsp), %rdi
callq 0x3020
movq %rax, 0x20(%rsp)
movb $0x1, 0x17(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x17(%rsp), %rdx
callq 0x3060
movq 0x58(%rsp), %rax
movb 0x60(%rsp), %dl
addq $0x68, %rsp
retq
// File: 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
subq $0x60, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x21a0
movq -0x30(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
movq %rdi, -0x40(%rbp)
callq 0x3270
movq -0x30(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
movq %rdi, -0x38(%rbp)
callq 0x3290
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x8, %edx
callq 0x2110
jmp 0x2a34
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2090
movb %al, -0x49(%rbp)
jmp 0x2a4c
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x2a55
jmp 0x2aad
movq -0x28(%rbp), %rsi
movq 0xa578(%rip), %rdi      # 0xcfd8
callq 0x2130
movq %rax, -0x58(%rbp)
jmp 0x2a6b
movq -0x58(%rbp), %rdi
leaq 0x5643(%rip), %rsi      # 0x80b9
callq 0x2150
jmp 0x2a7d
xorl %edi, %edi
callq 0x21b0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3190
movq -0x40(%rbp), %rdi
callq 0x2d40
movq -0x30(%rbp), %rdi
callq 0x2040
jmp 0x2abe
movq -0x48(%rbp), %rdi
callq 0x32b0
jmp 0x2ab8
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2250
nopw (%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
callq 0x3270
movq -0x58(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x68(%rbp)
callq 0x3270
movq -0x58(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x60(%rbp)
callq 0x56b0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x56d0
jmp 0x2c5c
movq -0x50(%rbp), %rdi
callq 0x5920
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movq -0x70(%rbp), %rax
decl %ecx
movl %ecx, 0x4c(%rax)
callq 0x5950
movq %rax, %rdi
callq 0x4f10
movq %rax, %rcx
movq -0x70(%rbp), %rax
decl %ecx
movl %ecx, 0x48(%rax)
movl 0x4c(%rax), %eax
incl %eax
cltq
movq %rax, -0x80(%rbp)
movq $0x0, -0x40(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3740
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rcx
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x3760
jmp 0x2cc5
movq -0x70(%rbp), %rdi
addq $0x30, %rdi
leaq -0x38(%rbp), %rsi
callq 0x5990
leaq -0x38(%rbp), %rdi
callq 0x38d0
leaq -0x41(%rbp), %rdi
callq 0x3930
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x2d14
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x3930
movq -0x60(%rbp), %rdi
callq 0x38d0
movq -0x68(%rbp), %rdi
callq 0x2d40
movq -0x58(%rbp), %rdi
callq 0x2d40
movq -0x18(%rbp), %rdi
callq 0x2250
nopl (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x2230
movq -0x38(%rbp), %rdi
addq $0x200, %rdi            # imm = 0x200
movq %rdi, -0x30(%rbp)
callq 0x21d0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2030
jmp 0x2e9b
movq -0x28(%rbp), %rsi
movq -0x40(%rbp), %rdi
movl $0x10, %edx
callq 0x20a0
jmp 0x2eaf
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2090
movb %al, -0x41(%rbp)
jmp 0x2ec7
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x2ed0
jmp 0x2f1f
movq -0x28(%rbp), %rsi
movq 0xa0fd(%rip), %rdi      # 0xcfd8
callq 0x2130
movq %rax, -0x50(%rbp)
jmp 0x2ee6
movq -0x50(%rbp), %rdi
leaq 0x522e(%rip), %rsi      # 0x811f
callq 0x2150
jmp 0x2ef8
xorl %edi, %edi
callq 0x21b0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x20e0
movq -0x38(%rbp), %rdi
callq 0x21f0
jmp 0x2f25
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2250
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x18(%rbp), %eax
cmpl 0x48(%rcx), %eax
jle 0x2fbe
movl $0x3, -0x4(%rbp)
jmp 0x30db
movl $0x1, -0x2c(%rbp)
movq -0x40(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x48(%rcx), %eax
jg 0x309f
movq -0x40(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3950
movq %rax, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x3970
movsd (%rax), %xmm0
movsd 0x504e(%rip), %xmm1     # 0x8048
ucomisd %xmm1, %xmm0
jne 0x3007
jp 0x3007
jmp 0x3091
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
movslq -0x18(%rbp), %rsi
callq 0x3950
movq %rax, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x3970
movsd (%rax), %xmm0
callq 0x7b60
movq -0x40(%rbp), %rdi
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
addq $0x18, %rdi
movslq -0x18(%rbp), %rsi
callq 0x3950
movq %rax, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x3970
movq -0x40(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movslq -0x14(%rbp), %rsi
callq 0x3950
movq %rax, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x3970
movsd -0x48(%rbp), %xmm0
movsd (%rax), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2fc5
movsd -0x28(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x30b8
jp 0x30b8
movl $0x3, -0x4(%rbp)
jmp 0x30db
movsd -0x20(%rbp), %xmm0
divsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0x4f71(%rip), %xmm0     # 0x8040
addsd -0x38(%rbp), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Agade09[P]CG-Send-Binary/Binary_To_Base85.cpp
// Function: decode_85(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string decode_85(const string &base85_string){
	string out;
	size_t str_ptr{0};
	while(str_ptr<base85_string.size()){
		unsigned int acc{0};
		for(int i=0;i<5;++i){
			unsigned char ch=base85_string[str_ptr++];
			int de{de85[ch]};
			acc=acc*85+de;
		}
		string sub;
		for(int i=0;i<4;++i){
			int val=acc%256;
			acc/=256;
			sub+=static_cast<char>(val);
		}
		reverse(sub.begin(),sub.end());
		out+=sub;
	}
	return out;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movb $0x0, 0x87(%rsp)
callq 0x2270
movq $0x0, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x88(%rsp), %rdi
callq 0x2120
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x2630
movl $0x0, 0x74(%rsp)
movl $0x0, 0x70(%rsp)
cmpl $0x5, 0x70(%rsp)
jge 0x256d
movq 0x88(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, 0x78(%rsp)
callq 0x2210
movb (%rax), %al
movb %al, 0x6f(%rsp)
movzbl 0x6f(%rsp), %eax
movl %eax, %ecx
leaq 0x5ca5(%rip), %rax      # 0x81f0
movsbl (%rax,%rcx), %eax
movl %eax, 0x68(%rsp)
imull $0x55, 0x74(%rsp), %eax
addl 0x68(%rsp), %eax
movl %eax, 0x74(%rsp)
movl 0x70(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x70(%rsp)
jmp 0x2512
leaq 0x48(%rsp), %rdi
callq 0x2270
movl $0x0, 0x44(%rsp)
cmpl $0x4, 0x44(%rsp)
jge 0x25de
movzbl 0x74(%rsp), %eax
movl %eax, 0x40(%rsp)
movl 0x74(%rsp), %eax
shrl $0x8, %eax
movl %eax, 0x74(%rsp)
movsbl 0x40(%rsp), %esi
leaq 0x48(%rsp), %rdi
callq 0x2100
jmp 0x25ab
jmp 0x25ad
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x257f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x20f0
movq 0x10(%rsp), %rdi
callq 0x20f0
jmp 0x2659
leaq 0x48(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x2170
movq (%rsp), %rdi
movq %rax, 0x28(%rsp)
callq 0x20e0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x35d0
jmp 0x2610
movq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x2240
jmp 0x2621
leaq 0x48(%rsp), %rdi
callq 0x20f0
jmp 0x24da
movb $0x1, 0x87(%rsp)
testb $0x1, 0x87(%rsp)
jne 0x264c
movq 0x10(%rsp), %rdi
callq 0x20f0
movq 0x18(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x2300
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movb $0x0, 0xa7(%rsp)
callq 0x2270
movl $0x0, 0xa0(%rsp)
movslq 0xa0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0xa8(%rsp), %rdi
callq 0x3610
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x28d6
movl $0x0, 0x9c(%rsp)
movq $0x4, 0x90(%rsp)
movq 0xa8(%rsp), %rdi
callq 0x3610
movslq 0xa0(%rsp), %rcx
subq %rcx, %rax
movq %rax, 0x88(%rsp)
leaq 0x90(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x3630
movq %rax, 0x18(%rsp)
jmp 0x272a
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl %eax, 0x98(%rsp)
movl $0x0, 0x78(%rsp)
movl 0x78(%rsp), %eax
cmpl 0x98(%rsp), %eax
jge 0x27ea
movq 0xa8(%rsp), %rdi
movslq 0xa0(%rsp), %rsi
movl %esi, %eax
incl %eax
movl %eax, 0xa0(%rsp)
callq 0x3670
movb (%rax), %al
movb %al, 0x77(%rsp)
movl 0x78(%rsp), %eax
movl $0x3, %esi
subl %eax, %esi
movl $0x100, %edi            # imm = 0x100
callq 0x3690
movsd %xmm0, 0x10(%rsp)
jmp 0x2795
movsd 0x10(%rsp), %xmm0
movzbl 0x77(%rsp), %eax
cvtsi2sd %eax, %xmm2
movl 0x9c(%rsp), %eax
cvtsi2sd %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movl %eax, 0x9c(%rsp)
movl 0x78(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x78(%rsp)
jmp 0x2741
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x28ff
leaq 0x50(%rsp), %rdi
callq 0x2270
movl $0x0, 0x4c(%rsp)
cmpl $0x5, 0x4c(%rsp)
jge 0x2882
movl 0x9c(%rsp), %eax
movl %eax, %edx
movl %edx, %eax
movl $0xc0c0c0c1, %ecx       # imm = 0xC0C0C0C1
imulq %rcx, %rdx
shrq $0x26, %rdx
imull $0x55, %edx, %edx
subl %edx, %eax
movl %eax, 0x48(%rsp)
movl 0x9c(%rsp), %eax
imulq %rcx, %rax
shrq $0x26, %rax
movl %eax, 0x9c(%rsp)
movslq 0x48(%rsp), %rax
leaq 0x27ca(%rip), %rcx      # 0x5010
movsbl (%rax,%rcx), %esi
leaq 0x50(%rsp), %rdi
callq 0x2100
jmp 0x2856
jmp 0x2858
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x27fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x20f0
jmp 0x28ff
leaq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x2170
movq 0x8(%rsp), %rdi
movq %rax, 0x40(%rsp)
callq 0x20e0
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x35d0
jmp 0x28b6
movq 0x28(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x2240
jmp 0x28c7
leaq 0x50(%rsp), %rdi
callq 0x20f0
jmp 0x26ac
movb $0x1, 0xa7(%rsp)
testb $0x1, 0xa7(%rsp)
jne 0x28f2
movq 0x28(%rsp), %rdi
callq 0x20f0
movq 0x30(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x20f0
movq 0x80(%rsp), %rdi
callq 0x2300
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq $0x0, (%rdi)
movq $0x0, 0x80(%rdi)
movq $0x0, 0x70(%rdi)
movl $0x0, 0x8(%rdi)
movl $0x0, 0x78(%rdi)
movl $0x0, 0x88(%rdi)
movl $0x0, 0xc(%rdi)
movl $0x0, 0x10(%rdi)
movl $0x0, 0x14(%rdi)
addq $0x18, %rdi
callq 0x5180
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x5180
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x5180
movq -0x10(%rbp), %rax
movl $0x0, 0x60(%rax)
movl $0x0, 0x64(%rax)
movl $0x0, 0x68(%rax)
movl $0x0, 0x6c(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movl $0x0, 0x64(%rax)
movl $0x0, 0x60(%rax)
movl $0x0, 0x68(%rax)
movl $0x0, 0x6c(%rax)
movq $0x0, 0x70(%rax)
xorl %eax, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x60(%rbp)
movq -0x18(%rbp), %rdi
addq $0x78, %rsi
callq 0x4e80
movq -0x60(%rbp), %rcx
movq 0x98(%rcx), %rdi
movl 0x8(%rcx), %esi
movl 0x78(%rcx), %edx
addq $0x88, %rcx
callq 0x4ea0
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, 0x80(%rax)
movq 0x80(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x4f50
movl -0x2c(%rbp), %eax
movl $0x20, %ecx
cltd
idivl %ecx
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
movl $0x20, %ecx
cltd
idivl %ecx
movl %edx, -0x34(%rbp)
movq -0x28(%rbp), %rax
movl $0x7ff, %ecx            # imm = 0x7FF
subl -0x30(%rbp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl (%rax), %eax
movl -0x34(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x27f7
movl $0x6c, -0x4(%rbp)
jmp 0x2886
movq -0x60(%rbp), %rax
movq -0x28(%rbp), %rcx
movl 0xc(%rax), %edx
movl -0x2c(%rbp), %esi
imull %esi, %edx
movslq %edx, %rdx
leaq (%rcx,%rdx,4), %rcx
movq %rcx, -0x48(%rbp)
movl 0xc(%rax), %ecx
movq %rsp, %rdx
movq %rdx, -0x50(%rbp)
movq %rcx, %rdx
addq $0xf, %rdx
andq $-0x10, %rdx
movq %rsp, %rdi
subq %rdx, %rdi
movq %rdi, -0x68(%rbp)
movq %rdi, %rsp
movq %rcx, -0x58(%rbp)
movq -0x48(%rbp), %rsi
movslq 0xc(%rax), %rdx
callq 0x20e0
movq -0x68(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0x4f70
movq -0x60(%rbp), %rax
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq (%rdx), %rdx
movq %rdx, 0x8(%rcx)
movq 0x98(%rax), %rdi
movl 0x88(%rax), %esi
callq 0x5000
movl $0x0, -0x4(%rbp)
movq -0x50(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x88(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
addq $0x78, %rsi
callq 0x4e80
movq -0x88(%rbp), %rcx
movq 0x98(%rcx), %rdi
movl 0x8(%rcx), %esi
movl 0x78(%rcx), %edx
addq $0x88, %rcx
callq 0x4ea0
movq %rax, %rcx
movq -0x88(%rbp), %rax
movq %rcx, 0x80(%rax)
movq 0x80(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
leaq -0x1c(%rbp), %rsi
callq 0x4f50
movq -0x88(%rbp), %rcx
movq -0x18(%rbp), %rax
movl 0xc(%rcx), %ecx
movl -0x1c(%rbp), %edx
imull %edx, %ecx
movslq %ecx, %rcx
leaq (%rax,%rcx,4), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x5120
movq 0xafe9(%rip), %rdi      # 0xdfd8
leaq 0x60c0(%rip), %rsi      # 0x90b6
callq 0x21c0
movq %rax, %rdi
movq -0x88(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x2300
movq %rax, %rdi
leaq 0x6352(%rip), %rsi      # 0x9369
movq %rsi, -0x80(%rbp)
callq 0x21c0
movq %rax, %rdi
movq -0x88(%rbp), %rax
movl 0x78(%rax), %esi
callq 0x2300
movq -0x80(%rbp), %rsi
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movl -0x1c(%rbp), %esi
callq 0x2300
movq %rax, %rdi
leaq 0x603d(%rip), %rsi      # 0x9090
callq 0x21c0
movq %rax, -0x78(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x2320
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x5070
jmp 0x3084
movq -0x78(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x21a0
movq %rax, -0x90(%rbp)
jmp 0x309a
movq -0x90(%rbp), %rdi
movq 0xaf20(%rip), %rsi      # 0xdfc8
callq 0x2200
jmp 0x30af
leaq -0x48(%rbp), %rdi
callq 0x2110
leaq -0x49(%rbp), %rdi
callq 0x2220
movq -0x88(%rbp), %rax
movq 0x98(%rax), %rdi
movl 0x88(%rax), %esi
callq 0x5040
xorl %eax, %eax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3108
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2110
leaq -0x49(%rbp), %rdi
callq 0x2220
movq -0x58(%rbp), %rdi
callq 0x2310
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x3bdd
movq 0xa41f(%rip), %rdi      # 0xdfd8
leaq 0x5689(%rip), %rsi      # 0x9249
callq 0x21c0
movq %rax, %rdi
movq 0xa3f9(%rip), %rsi      # 0xdfc8
callq 0x2200
movl $0x68, -0x4(%rbp)
jmp 0x3c2f
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5770
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x57c0
movq -0x18(%rbp), %rdi
callq 0x2600
movq 0xa3cb(%rip), %rdi      # 0xdfd8
leaq 0x5647(%rip), %rsi      # 0x925b
callq 0x21c0
movq %rax, %rdi
movq 0xa3a5(%rip), %rsi      # 0xdfc8
callq 0x2200
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x2320
movq -0x80(%rbp), %rdx
leaq 0x5528(%rip), %rsi      # 0x91a8
leaq -0x38(%rbp), %rdi
callq 0x5070
jmp 0x3c8b
leaq -0x39(%rbp), %rdi
callq 0x2220
leaq -0x68(%rbp), %rdi
callq 0x55c0
movl $0x8, -0x70(%rbp)
movl -0x6c(%rbp), %eax
cmpl -0x70(%rbp), %eax
jge 0x3d83
movq -0x18(%rbp), %rax
movslq -0x6c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x3cd6
movq -0x18(%rbp), %rax
movslq -0x6c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2c, %eax
jne 0x3d5c
leaq 0x54cb(%rip), %rsi      # 0x91a8
leaq -0x38(%rbp), %rdi
callq 0x55e0
movb %al, -0x91(%rbp)
jmp 0x3cee
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x3cfa
jmp 0x3d48
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x5610
jmp 0x3d09
jmp 0x3d48
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x2220
jmp 0x3e02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x56e0
leaq -0x38(%rbp), %rdi
callq 0x2110
jmp 0x3e02
leaq 0x5459(%rip), %rsi      # 0x91a8
leaq -0x38(%rbp), %rdi
callq 0x22a0
jmp 0x3d5a
jmp 0x3d75
movq -0x18(%rbp), %rax
movslq -0x6c(%rbp), %rcx
movsbl (%rax,%rcx), %esi
leaq -0x38(%rbp), %rdi
callq 0x2120
jmp 0x3d73
jmp 0x3d75
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x3ca4
movq -0x90(%rbp), %rdi
movb $0x0, -0x71(%rbp)
callq 0x5680
movl $0x0, -0x6c(%rbp)
movslq -0x6c(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x56a0
movq %rax, %rcx
movq -0xa0(%rbp), %rax
cmpq %rcx, %rax
jae 0x3dca
jmp 0x3dbf
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x3d9a
movb $0x1, -0x71(%rbp)
testb $0x1, -0x71(%rbp)
jne 0x3de0
movq -0x90(%rbp), %rdi
callq 0x56c0
leaq -0x68(%rbp), %rdi
callq 0x56e0
leaq -0x38(%rbp), %rdi
callq 0x2110
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2310
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2360
cmpl $0x0, %eax
jne 0x3e74
movq 0xa1a3(%rip), %rdi      # 0xdfd8
leaq 0x5308(%rip), %rsi      # 0x9144
callq 0x21c0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x21c0
movq %rax, %rdi
leaq 0x52ff(%rip), %rsi      # 0x9156
callq 0x21c0
movq %rax, %rdi
movq 0xa162(%rip), %rsi      # 0xdfc8
callq 0x2200
movl $0x0, -0x4(%rbp)
jmp 0x3e9d
movq 0xa15d(%rip), %rdi      # 0xdfd8
leaq 0x52e0(%rip), %rsi      # 0x9162
callq 0x21c0
movq %rax, %rdi
movq 0xa137(%rip), %rsi      # 0xdfc8
callq 0x2200
movl $0x66, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq (%rax), %rax
cmpq $0x0, (%rax)
jne 0x3fa8
movq 0xa057(%rip), %rdi      # 0xdfd8
leaq 0x52ef(%rip), %rsi      # 0x9277
callq 0x21c0
movq %rax, %rdi
movq 0xa031(%rip), %rsi      # 0xdfc8
callq 0x2200
movl $0x6a, -0x4(%rbp)
jmp 0x405e
movq -0x38(%rbp), %rcx
movl -0x24(%rbp), %eax
addl -0x20(%rbp), %eax
movq (%rcx), %rcx
cmpl 0xc(%rcx), %eax
jl 0x3fe5
movq 0xa017(%rip), %rdi      # 0xdfd8
leaq 0x52d3(%rip), %rsi      # 0x929b
callq 0x21c0
movq %rax, %rdi
movq 0x9ff1(%rip), %rsi      # 0xdfc8
callq 0x2200
movl $0x6b, -0x4(%rbp)
jmp 0x405e
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x58b0
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x34(%rax)
leaq -0x30(%rbp), %rdi
callq 0x58a0
movq -0x38(%rbp), %rax
movl $0x0, 0x30(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x20(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl -0x28(%rbp), %ecx
movl %ecx, 0x14(%rax)
movq 0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq 0x9f9c(%rip), %rdi      # 0xdfd8
leaq 0x527d(%rip), %rsi      # 0x92c0
callq 0x21c0
movq %rax, %rdi
movq 0x9f76(%rip), %rsi      # 0xdfc8
callq 0x2200
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movl 0x38(%rcx), %eax
addl $0x1, %eax
movq (%rcx), %rcx
cmpl 0x64(%rcx), %eax
jge 0x462d
movq -0x10(%rbp), %rax
movl 0x38(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x38(%rax)
jmp 0x4641
movq -0x10(%rbp), %rax
movl 0x34(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x34(%rax)
movl $0x0, 0x38(%rax)
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)