diff --git a/lab3/CMakeLists.txt b/lab3/CMakeLists.txt
new file mode 100644
index 0000000..30cef60
--- /dev/null
+++ b/lab3/CMakeLists.txt
@@ -0,0 +1,22 @@
+cmake_minimum_required(VERSION 3.14)
+project(flat_hash_map_lab)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+add_compile_options(-msse2 -Wall -Wextra -Wpedantic)
+
+include(FetchContent)
+FetchContent_Declare(
+    googletest
+    GIT_REPOSITORY https://github.com/google/googletest.git
+    GIT_TAG v1.14.0
+)
+FetchContent_MakeAvailable(googletest)
+
+enable_testing()
+
+add_executable(flat_hash_map_tests tests.cpp)
+target_link_libraries(flat_hash_map_tests GTest::gtest_main)
+
+include(GoogleTest)
+gtest_discover_tests(flat_hash_map_tests)
diff --git a/lab3/flat_hash_map.cpp b/lab3/flat_hash_map.cpp
new file mode 100644
index 0000000..013efe9
--- /dev/null
+++ b/lab3/flat_hash_map.cpp
@@ -0,0 +1,792 @@
+#include <algorithm>
+#include <emmintrin.h>
+#include <stdexcept>
+
+#include "flat_hash_map.hpp"
+
+template <class Key, class T, class Hash, class KeyEqual>
+typename flat_hash_map<Key, T, Hash, KeyEqual>::value_type*
+flat_hash_map<Key, T, Hash, KeyEqual>::Slot::ptr() {
+  return reinterpret_cast<value_type*>(storage);
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+const typename flat_hash_map<Key, T, Hash, KeyEqual>::value_type*
+flat_hash_map<Key, T, Hash, KeyEqual>::Slot::ptr() const {
+  return reinterpret_cast<const value_type*>(storage);
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+typename flat_hash_map<Key, T, Hash, KeyEqual>::size_type
+flat_hash_map<Key, T, Hash, KeyEqual>::CalculateCapacity(size_type requested) {
+  if (requested == 0) return 16;
+  
+  size_type capacity = 16;
+  while (capacity < requested) {
+    capacity *= 2;
+  }
+  return capacity;
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+uint8_t flat_hash_map<Key, T, Hash, KeyEqual>::H2(size_t hash_value) {
+  uint8_t h = static_cast<uint8_t>(hash_value >> 7);
+  if (h >= kDeleted) {
+    h = kDeleted - 1;
+  }
+  return h;
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+typename flat_hash_map<Key, T, Hash, KeyEqual>::size_type
+flat_hash_map<Key, T, Hash, KeyEqual>::FindSlot(const Key& key,
+                                                 size_t hash_value) const {
+  if (capacity_ == 0) return 0;
+
+  const uint8_t h2_value = H2(hash_value);
+  size_type index = hash_value & (capacity_ - 1);
+  const size_type start_index = index;
+
+  while (true) {
+    const size_type group_start = index & ~15;
+    
+    __m128i group = _mm_loadu_si128(
+        reinterpret_cast<const __m128i*>(metadata_ + group_start));
+
+    __m128i target = _mm_set1_epi8(h2_value);
+    __m128i cmp_match = _mm_cmpeq_epi8(group, target);
+    
+    __m128i empty_vec = _mm_set1_epi8(kEmpty);
+    __m128i cmp_empty = _mm_cmpeq_epi8(group, empty_vec);
+
+    int match_mask = _mm_movemask_epi8(cmp_match);
+    int empty_mask = _mm_movemask_epi8(cmp_empty);
+
+    while (match_mask != 0) {
+      int bit_pos = __builtin_ctz(match_mask);
+      size_type slot_index = (group_start + bit_pos) & (capacity_ - 1);
+
+      if (metadata_[slot_index] == h2_value &&
+          equal_(slots_[slot_index].ptr()->first, key)) {
+        return slot_index;
+      }
+
+      match_mask &= (match_mask - 1);
+    }
+
+    if (empty_mask != 0) {
+      return capacity_;
+    }
+
+    index = (group_start + 16) & (capacity_ - 1);
+
+    if (index == (start_index & ~15)) {
+      break;
+    }
+  }
+
+  return capacity_;
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+typename flat_hash_map<Key, T, Hash, KeyEqual>::size_type
+flat_hash_map<Key, T, Hash, KeyEqual>::FindInsertSlot(
+    const Key& key, size_t hash_value) const {
+  if (capacity_ == 0) return 0;
+
+  const uint8_t h2_value = H2(hash_value);
+  size_type index = hash_value & (capacity_ - 1);
+  size_type first_deleted = capacity_;
+  const size_type start_index = index;
+
+  while (true) {
+    const size_type group_start = index & ~15;
+    
+    __m128i group = _mm_loadu_si128(
+        reinterpret_cast<const __m128i*>(metadata_ + group_start));
+
+    __m128i target = _mm_set1_epi8(h2_value);
+    __m128i cmp_match = _mm_cmpeq_epi8(group, target);
+    
+    __m128i empty_vec = _mm_set1_epi8(kEmpty);
+    __m128i cmp_empty = _mm_cmpeq_epi8(group, empty_vec);
+    
+    __m128i deleted_vec = _mm_set1_epi8(kDeleted);
+    __m128i cmp_deleted = _mm_cmpeq_epi8(group, deleted_vec);
+
+    int match_mask = _mm_movemask_epi8(cmp_match);
+    int empty_mask = _mm_movemask_epi8(cmp_empty);
+    int deleted_mask = _mm_movemask_epi8(cmp_deleted);
+
+    while (match_mask != 0) {
+      int bit_pos = __builtin_ctz(match_mask);
+      size_type slot_index = (group_start + bit_pos) & (capacity_ - 1);
+
+      if (metadata_[slot_index] == h2_value &&
+          equal_(slots_[slot_index].ptr()->first, key)) {
+        return slot_index;
+      }
+
+      match_mask &= (match_mask - 1);
+    }
+
+    if (first_deleted == capacity_ && deleted_mask != 0) {
+      int bit_pos = __builtin_ctz(deleted_mask);
+      first_deleted = (group_start + bit_pos) & (capacity_ - 1);
+    }
+
+    if (empty_mask != 0) {
+      if (first_deleted != capacity_) {
+        return first_deleted;
+      }
+      int bit_pos = __builtin_ctz(empty_mask);
+      return (group_start + bit_pos) & (capacity_ - 1);
+    }
+
+    index = (group_start + 16) & (capacity_ - 1);
+
+    if (index == (start_index & ~15)) {
+      if (first_deleted != capacity_) {
+        return first_deleted;
+      }
+      break;
+    }
+  }
+
+  return capacity_;
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+void flat_hash_map<Key, T, Hash, KeyEqual>::Allocate(size_type new_capacity) {
+  slots_ = static_cast<Slot*>(::operator new(new_capacity * sizeof(Slot)));
+  metadata_ = new uint8_t[new_capacity];
+  std::fill(metadata_, metadata_ + new_capacity, kEmpty);
+  capacity_ = new_capacity;
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+void flat_hash_map<Key, T, Hash, KeyEqual>::Deallocate() {
+  if (slots_) {
+    for (size_type i = 0; i < capacity_; ++i) {
+      if (metadata_[i] < kDeleted) {
+        slots_[i].ptr()->~value_type();
+      }
+    }
+    ::operator delete(slots_);
+    delete[] metadata_;
+  }
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+void flat_hash_map<Key, T, Hash, KeyEqual>::RehashImpl(
+    size_type new_capacity) {
+  Slot* old_slots = slots_;
+  uint8_t* old_metadata = metadata_;
+  size_type old_capacity = capacity_;
+
+  Allocate(new_capacity);
+  size_ = 0;
+
+  for (size_type i = 0; i < old_capacity; ++i) {
+    if (old_metadata[i] < kDeleted) {
+      value_type* old_val = old_slots[i].ptr();
+      Key key_copy = std::move(const_cast<Key&>(old_val->first));
+      mapped_type val_copy = std::move(old_val->second);
+      old_val->~value_type();
+      InsertImpl(std::move(key_copy), std::move(val_copy));
+    }
+  }
+
+  ::operator delete(old_slots);
+  delete[] old_metadata;
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+std::pair<typename flat_hash_map<Key, T, Hash, KeyEqual>::iterator, bool>
+flat_hash_map<Key, T, Hash, KeyEqual>::InsertImpl(const Key& key,
+                                                   const mapped_type& value) {
+  if (capacity_ == 0) {
+    Allocate(CalculateCapacity(16));
+  }
+
+  if (static_cast<float>(size_ + 1) > capacity_ * max_load_factor_) {
+    RehashImpl(capacity_ * 2);
+  }
+
+  size_t hash_value = hash_(key);
+  size_type slot = FindInsertSlot(key, hash_value);
+
+  if (slot < capacity_ && metadata_[slot] < kDeleted) {
+    return {iterator(this, slot), false};
+  }
+
+  if (slot == capacity_) {
+    RehashImpl(capacity_ * 2);
+    hash_value = hash_(key);
+    slot = FindInsertSlot(key, hash_value);
+  }
+
+  new (slots_[slot].ptr()) value_type(key, value);
+  metadata_[slot] = H2(hash_value);
+  ++size_;
+
+  return {iterator(this, slot), true};
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+std::pair<typename flat_hash_map<Key, T, Hash, KeyEqual>::iterator, bool>
+flat_hash_map<Key, T, Hash, KeyEqual>::InsertImpl(Key&& key,
+                                                   mapped_type&& value) {
+  if (capacity_ == 0) {
+    Allocate(CalculateCapacity(16));
+  }
+
+  if (static_cast<float>(size_ + 1) > capacity_ * max_load_factor_) {
+    RehashImpl(capacity_ * 2);
+  }
+
+  size_t hash_value = hash_(key);
+  size_type slot = FindInsertSlot(key, hash_value);
+
+  if (slot < capacity_ && metadata_[slot] < kDeleted) {
+    return {iterator(this, slot), false};
+  }
+
+  if (slot == capacity_) {
+    RehashImpl(capacity_ * 2);
+    hash_value = hash_(key);
+    slot = FindInsertSlot(key, hash_value);
+  }
+
+  new (slots_[slot].ptr()) value_type(std::move(key), std::move(value));
+  metadata_[slot] = H2(hash_value);
+  ++size_;
+
+  return {iterator(this, slot), true};
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+flat_hash_map<Key, T, Hash, KeyEqual>::iterator::iterator(flat_hash_map* map,
+                                                           size_type index)
+    : map_(map), index_(index) {}
+
+template <class Key, class T, class Hash, class KeyEqual>
+flat_hash_map<Key, T, Hash, KeyEqual>::iterator::iterator()
+    : map_(nullptr), index_(0) {}
+
+template <class Key, class T, class Hash, class KeyEqual>
+typename flat_hash_map<Key, T, Hash, KeyEqual>::iterator::reference
+flat_hash_map<Key, T, Hash, KeyEqual>::iterator::operator*() const {
+  return *map_->slots_[index_].ptr();
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+typename flat_hash_map<Key, T, Hash, KeyEqual>::iterator::pointer
+flat_hash_map<Key, T, Hash, KeyEqual>::iterator::operator->() const {
+  return map_->slots_[index_].ptr();
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+typename flat_hash_map<Key, T, Hash, KeyEqual>::iterator&
+flat_hash_map<Key, T, Hash, KeyEqual>::iterator::operator++() {
+  ++index_;
+  while (index_ < map_->capacity_ &&
+         map_->metadata_[index_] >= flat_hash_map::kDeleted) {
+    ++index_;
+  }
+  return *this;
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+typename flat_hash_map<Key, T, Hash, KeyEqual>::iterator
+flat_hash_map<Key, T, Hash, KeyEqual>::iterator::operator++(int) {
+  iterator tmp = *this;
+  ++(*this);
+  return tmp;
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+bool flat_hash_map<Key, T, Hash, KeyEqual>::iterator::operator==(
+    const iterator& other) const {
+  return map_ == other.map_ && index_ == other.index_;
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+bool flat_hash_map<Key, T, Hash, KeyEqual>::iterator::operator!=(
+    const iterator& other) const {
+  return !(*this == other);
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+flat_hash_map<Key, T, Hash, KeyEqual>::const_iterator::const_iterator(
+    const flat_hash_map* map, size_type index)
+    : map_(map), index_(index) {}
+
+template <class Key, class T, class Hash, class KeyEqual>
+flat_hash_map<Key, T, Hash, KeyEqual>::const_iterator::const_iterator()
+    : map_(nullptr), index_(0) {}
+
+template <class Key, class T, class Hash, class KeyEqual>
+flat_hash_map<Key, T, Hash, KeyEqual>::const_iterator::const_iterator(
+    const iterator& it)
+    : map_(it.map_), index_(it.index_) {}
+
+template <class Key, class T, class Hash, class KeyEqual>
+typename flat_hash_map<Key, T, Hash, KeyEqual>::const_iterator::reference
+flat_hash_map<Key, T, Hash, KeyEqual>::const_iterator::operator*() const {
+  return *map_->slots_[index_].ptr();
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+typename flat_hash_map<Key, T, Hash, KeyEqual>::const_iterator::pointer
+flat_hash_map<Key, T, Hash, KeyEqual>::const_iterator::operator->() const {
+  return map_->slots_[index_].ptr();
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+typename flat_hash_map<Key, T, Hash, KeyEqual>::const_iterator&
+flat_hash_map<Key, T, Hash, KeyEqual>::const_iterator::operator++() {
+  ++index_;
+  while (index_ < map_->capacity_ &&
+         map_->metadata_[index_] >= flat_hash_map::kDeleted) {
+    ++index_;
+  }
+  return *this;
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+typename flat_hash_map<Key, T, Hash, KeyEqual>::const_iterator
+flat_hash_map<Key, T, Hash, KeyEqual>::const_iterator::operator++(int) {
+  const_iterator tmp = *this;
+  ++(*this);
+  return tmp;
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+bool flat_hash_map<Key, T, Hash, KeyEqual>::const_iterator::operator==(
+    const const_iterator& other) const {
+  return map_ == other.map_ && index_ == other.index_;
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+bool flat_hash_map<Key, T, Hash, KeyEqual>::const_iterator::operator!=(
+    const const_iterator& other) const {
+  return !(*this == other);
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+flat_hash_map<Key, T, Hash, KeyEqual>::flat_hash_map()
+    : slots_(nullptr),
+      metadata_(nullptr),
+      capacity_(0),
+      size_(0),
+      max_load_factor_(0.75f),
+      hash_(),
+      equal_() {}
+
+template <class Key, class T, class Hash, class KeyEqual>
+flat_hash_map<Key, T, Hash, KeyEqual>::flat_hash_map(size_type bucket_count,
+                                                      const Hash& hash,
+                                                      const KeyEqual& equal)
+    : slots_(nullptr),
+      metadata_(nullptr),
+      capacity_(0),
+      size_(0),
+      max_load_factor_(0.75f),
+      hash_(hash),
+      equal_(equal) {
+  if (bucket_count > 0) {
+    Allocate(CalculateCapacity(bucket_count));
+  }
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+template <class InputIt>
+flat_hash_map<Key, T, Hash, KeyEqual>::flat_hash_map(InputIt first,
+                                                      InputIt last,
+                                                      size_type bucket_count,
+                                                      const Hash& hash,
+                                                      const KeyEqual& equal)
+    : flat_hash_map(bucket_count, hash, equal) {
+  insert(first, last);
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+flat_hash_map<Key, T, Hash, KeyEqual>::flat_hash_map(
+    std::initializer_list<value_type> init, size_type bucket_count,
+    const Hash& hash, const KeyEqual& equal)
+    : flat_hash_map(bucket_count, hash, equal) {
+  insert(init);
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+flat_hash_map<Key, T, Hash, KeyEqual>::flat_hash_map(
+    const flat_hash_map& other)
+    : slots_(nullptr),
+      metadata_(nullptr),
+      capacity_(0),
+      size_(0),
+      max_load_factor_(other.max_load_factor_),
+      hash_(other.hash_),
+      equal_(other.equal_) {
+  if (other.capacity_ > 0) {
+    Allocate(other.capacity_);
+    for (size_type i = 0; i < other.capacity_; ++i) {
+      metadata_[i] = other.metadata_[i];
+      if (metadata_[i] < kDeleted) {
+        new (slots_[i].ptr()) value_type(*other.slots_[i].ptr());
+        ++size_;
+      }
+    }
+  }
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+flat_hash_map<Key, T, Hash, KeyEqual>::flat_hash_map(
+    flat_hash_map&& other) noexcept
+    : slots_(other.slots_),
+      metadata_(other.metadata_),
+      capacity_(other.capacity_),
+      size_(other.size_),
+      max_load_factor_(other.max_load_factor_),
+      hash_(std::move(other.hash_)),
+      equal_(std::move(other.equal_)) {
+  other.slots_ = nullptr;
+  other.metadata_ = nullptr;
+  other.capacity_ = 0;
+  other.size_ = 0;
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+flat_hash_map<Key, T, Hash, KeyEqual>::~flat_hash_map() {
+  Deallocate();
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+flat_hash_map<Key, T, Hash, KeyEqual>&
+flat_hash_map<Key, T, Hash, KeyEqual>::operator=(const flat_hash_map& other) {
+  if (this != &other) {
+    flat_hash_map tmp(other);
+    swap(tmp);
+  }
+  return *this;
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+flat_hash_map<Key, T, Hash, KeyEqual>&
+flat_hash_map<Key, T, Hash, KeyEqual>::operator=(
+    flat_hash_map&& other) noexcept {
+  if (this != &other) {
+    Deallocate();
+    slots_ = other.slots_;
+    metadata_ = other.metadata_;
+    capacity_ = other.capacity_;
+    size_ = other.size_;
+    max_load_factor_ = other.max_load_factor_;
+    hash_ = std::move(other.hash_);
+    equal_ = std::move(other.equal_);
+
+    other.slots_ = nullptr;
+    other.metadata_ = nullptr;
+    other.capacity_ = 0;
+    other.size_ = 0;
+  }
+  return *this;
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+flat_hash_map<Key, T, Hash, KeyEqual>&
+flat_hash_map<Key, T, Hash, KeyEqual>::operator=(
+    std::initializer_list<value_type> init) {
+  clear();
+  insert(init);
+  return *this;
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+void flat_hash_map<Key, T, Hash, KeyEqual>::swap(
+    flat_hash_map& other) noexcept {
+  std::swap(slots_, other.slots_);
+  std::swap(metadata_, other.metadata_);
+  std::swap(capacity_, other.capacity_);
+  std::swap(size_, other.size_);
+  std::swap(max_load_factor_, other.max_load_factor_);
+  std::swap(hash_, other.hash_);
+  std::swap(equal_, other.equal_);
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+typename flat_hash_map<Key, T, Hash, KeyEqual>::iterator
+flat_hash_map<Key, T, Hash, KeyEqual>::begin() noexcept {
+  size_type i = 0;
+  while (i < capacity_ && metadata_[i] >= kDeleted) {
+    ++i;
+  }
+  return iterator(this, i);
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+typename flat_hash_map<Key, T, Hash, KeyEqual>::const_iterator
+flat_hash_map<Key, T, Hash, KeyEqual>::begin() const noexcept {
+  size_type i = 0;
+  while (i < capacity_ && metadata_[i] >= kDeleted) {
+    ++i;
+  }
+  return const_iterator(this, i);
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+typename flat_hash_map<Key, T, Hash, KeyEqual>::const_iterator
+flat_hash_map<Key, T, Hash, KeyEqual>::cbegin() const noexcept {
+  return begin();
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+typename flat_hash_map<Key, T, Hash, KeyEqual>::iterator
+flat_hash_map<Key, T, Hash, KeyEqual>::end() noexcept {
+  return iterator(this, capacity_);
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+typename flat_hash_map<Key, T, Hash, KeyEqual>::const_iterator
+flat_hash_map<Key, T, Hash, KeyEqual>::end() const noexcept {
+  return const_iterator(this, capacity_);
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+typename flat_hash_map<Key, T, Hash, KeyEqual>::const_iterator
+flat_hash_map<Key, T, Hash, KeyEqual>::cend() const noexcept {
+  return end();
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+bool flat_hash_map<Key, T, Hash, KeyEqual>::empty() const noexcept {
+  return size_ == 0;
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+typename flat_hash_map<Key, T, Hash, KeyEqual>::size_type
+flat_hash_map<Key, T, Hash, KeyEqual>::size() const noexcept {
+  return size_;
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+void flat_hash_map<Key, T, Hash, KeyEqual>::clear() noexcept {
+  for (size_type i = 0; i < capacity_; ++i) {
+    if (metadata_[i] < kDeleted) {
+      slots_[i].ptr()->~value_type();
+      metadata_[i] = kEmpty;
+    }
+  }
+  size_ = 0;
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+std::pair<typename flat_hash_map<Key, T, Hash, KeyEqual>::iterator, bool>
+flat_hash_map<Key, T, Hash, KeyEqual>::insert(const value_type& value) {
+  return InsertImpl(value.first, value.second);
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+std::pair<typename flat_hash_map<Key, T, Hash, KeyEqual>::iterator, bool>
+flat_hash_map<Key, T, Hash, KeyEqual>::insert(value_type&& value) {
+  Key key_copy = std::move(const_cast<Key&>(value.first));
+  return InsertImpl(std::move(key_copy), std::move(value.second));
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+template <class InputIt>
+void flat_hash_map<Key, T, Hash, KeyEqual>::insert(InputIt first,
+                                                    InputIt last) {
+  for (auto it = first; it != last; ++it) {
+    insert(*it);
+  }
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+void flat_hash_map<Key, T, Hash, KeyEqual>::insert(
+    std::initializer_list<value_type> init) {
+  insert(init.begin(), init.end());
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+template <class... Args>
+std::pair<typename flat_hash_map<Key, T, Hash, KeyEqual>::iterator, bool>
+flat_hash_map<Key, T, Hash, KeyEqual>::emplace(Args&&... args) {
+  value_type temp(std::forward<Args>(args)...);
+  return insert(std::move(temp));
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+typename flat_hash_map<Key, T, Hash, KeyEqual>::size_type
+flat_hash_map<Key, T, Hash, KeyEqual>::erase(const key_type& key) {
+  if (capacity_ == 0) return 0;
+
+  size_t hash_value = hash_(key);
+  size_type slot = FindSlot(key, hash_value);
+
+  if (slot == capacity_) {
+    return 0;
+  }
+
+  slots_[slot].ptr()->~value_type();
+  metadata_[slot] = kDeleted;
+  --size_;
+  return 1;
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+typename flat_hash_map<Key, T, Hash, KeyEqual>::iterator
+flat_hash_map<Key, T, Hash, KeyEqual>::erase(iterator pos) {
+  if (pos.index_ < capacity_ && metadata_[pos.index_] < kDeleted) {
+    slots_[pos.index_].ptr()->~value_type();
+    metadata_[pos.index_] = kDeleted;
+    --size_;
+  }
+  ++pos;
+  return pos;
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+void flat_hash_map<Key, T, Hash, KeyEqual>::reserve(size_type new_capacity) {
+  if (new_capacity > capacity_) {
+    RehashImpl(CalculateCapacity(new_capacity));
+  }
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+typename flat_hash_map<Key, T, Hash, KeyEqual>::size_type
+flat_hash_map<Key, T, Hash, KeyEqual>::capacity() const noexcept {
+  return capacity_;
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+float flat_hash_map<Key, T, Hash, KeyEqual>::load_factor() const noexcept {
+  return capacity_ == 0 ? 0.0f : static_cast<float>(size_) / capacity_;
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+void flat_hash_map<Key, T, Hash, KeyEqual>::max_load_factor(float ml) {
+  max_load_factor_ = ml;
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+float flat_hash_map<Key, T, Hash, KeyEqual>::max_load_factor() const noexcept {
+  return max_load_factor_;
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+typename flat_hash_map<Key, T, Hash, KeyEqual>::mapped_type&
+flat_hash_map<Key, T, Hash, KeyEqual>::operator[](const key_type& key) {
+  if (capacity_ == 0) {
+    Allocate(CalculateCapacity(16));
+  }
+
+  size_t hash_value = hash_(key);
+  size_type slot = FindInsertSlot(key, hash_value);
+
+  if (slot < capacity_ && metadata_[slot] < kDeleted) {
+    return slots_[slot].ptr()->second;
+  }
+
+  auto result = InsertImpl(key, mapped_type{});
+  return result.first->second;
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+typename flat_hash_map<Key, T, Hash, KeyEqual>::mapped_type&
+flat_hash_map<Key, T, Hash, KeyEqual>::operator[](key_type&& key) {
+  if (capacity_ == 0) {
+    Allocate(CalculateCapacity(16));
+  }
+
+  size_t hash_value = hash_(key);
+  size_type slot = FindInsertSlot(key, hash_value);
+
+  if (slot < capacity_ && metadata_[slot] < kDeleted) {
+    return slots_[slot].ptr()->second;
+  }
+
+  auto result = InsertImpl(std::move(key), mapped_type{});
+  return result.first->second;
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+typename flat_hash_map<Key, T, Hash, KeyEqual>::mapped_type&
+flat_hash_map<Key, T, Hash, KeyEqual>::at(const key_type& key) {
+  if (capacity_ == 0) {
+    throw std::out_of_range("key not found");
+  }
+
+  size_t hash_value = hash_(key);
+  size_type slot = FindSlot(key, hash_value);
+
+  if (slot == capacity_) {
+    throw std::out_of_range("key not found");
+  }
+
+  return slots_[slot].ptr()->second;
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+const typename flat_hash_map<Key, T, Hash, KeyEqual>::mapped_type&
+flat_hash_map<Key, T, Hash, KeyEqual>::at(const key_type& key) const {
+  if (capacity_ == 0) {
+    throw std::out_of_range("key not found");
+  }
+
+  size_t hash_value = hash_(key);
+  size_type slot = FindSlot(key, hash_value);
+
+  if (slot == capacity_) {
+    throw std::out_of_range("key not found");
+  }
+
+  return slots_[slot].ptr()->second;
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+typename flat_hash_map<Key, T, Hash, KeyEqual>::iterator
+flat_hash_map<Key, T, Hash, KeyEqual>::find(const key_type& key) {
+  if (capacity_ == 0) {
+    return end();
+  }
+
+  size_t hash_value = hash_(key);
+  size_type slot = FindSlot(key, hash_value);
+
+  if (slot == capacity_) {
+    return end();
+  }
+
+  return iterator(this, slot);
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+typename flat_hash_map<Key, T, Hash, KeyEqual>::const_iterator
+flat_hash_map<Key, T, Hash, KeyEqual>::find(const key_type& key) const {
+  if (capacity_ == 0) {
+    return end();
+  }
+
+  size_t hash_value = hash_(key);
+  size_type slot = FindSlot(key, hash_value);
+
+  if (slot == capacity_) {
+    return end();
+  }
+
+  return const_iterator(this, slot);
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+bool flat_hash_map<Key, T, Hash, KeyEqual>::contains(
+    const key_type& key) const {
+  return find(key) != end();
+}
+
+template <class Key, class T, class Hash, class KeyEqual>
+typename flat_hash_map<Key, T, Hash, KeyEqual>::size_type
+flat_hash_map<Key, T, Hash, KeyEqual>::count(const key_type& key) const {
+  return contains(key) ? 1 : 0;
+}
diff --git a/lab3/flat_hash_map.hpp b/lab3/flat_hash_map.hpp
new file mode 100644
index 0000000..bbf440e
--- /dev/null
+++ b/lab3/flat_hash_map.hpp
@@ -0,0 +1,185 @@
+#ifndef FLAT_HASH_MAP_HPP_
+#define FLAT_HASH_MAP_HPP_
+
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <initializer_list>
+#include <utility>
+
+template <class Key, class T, class Hash = std::hash<Key>,
+          class KeyEqual = std::equal_to<Key>>
+class flat_hash_map {
+ public:
+  using key_type = Key;
+  using mapped_type = T;
+  using value_type = std::pair<const Key, T>;
+  using size_type = std::size_t;
+  using hasher = Hash;
+  using key_equal = KeyEqual;
+
+  class iterator;
+  class const_iterator;
+
+  flat_hash_map();
+
+  explicit flat_hash_map(size_type bucket_count, const Hash& hash = Hash(),
+                         const KeyEqual& equal = KeyEqual());
+
+  template <class InputIt>
+  flat_hash_map(InputIt first, InputIt last, size_type bucket_count = 0,
+                const Hash& hash = Hash(), const KeyEqual& equal = KeyEqual());
+
+  flat_hash_map(std::initializer_list<value_type> init,
+                size_type bucket_count = 0, const Hash& hash = Hash(),
+                const KeyEqual& equal = KeyEqual());
+
+  flat_hash_map(const flat_hash_map& other);
+  flat_hash_map(flat_hash_map&& other) noexcept;
+
+  ~flat_hash_map();
+
+  flat_hash_map& operator=(const flat_hash_map& other);
+  flat_hash_map& operator=(flat_hash_map&& other) noexcept;
+  flat_hash_map& operator=(std::initializer_list<value_type> init);
+
+  void swap(flat_hash_map& other) noexcept;
+
+  iterator begin() noexcept;
+  const_iterator begin() const noexcept;
+  const_iterator cbegin() const noexcept;
+
+  iterator end() noexcept;
+  const_iterator end() const noexcept;
+  const_iterator cend() const noexcept;
+
+  bool empty() const noexcept;
+  size_type size() const noexcept;
+  void clear() noexcept;
+
+  std::pair<iterator, bool> insert(const value_type& value);
+  std::pair<iterator, bool> insert(value_type&& value);
+
+  template <class InputIt>
+  void insert(InputIt first, InputIt last);
+
+  void insert(std::initializer_list<value_type> init);
+
+  template <class... Args>
+  std::pair<iterator, bool> emplace(Args&&... args);
+
+  size_type erase(const key_type& key);
+  iterator erase(iterator pos);
+
+  void reserve(size_type new_capacity);
+  size_type capacity() const noexcept;
+  float load_factor() const noexcept;
+  void max_load_factor(float ml);
+  float max_load_factor() const noexcept;
+
+  mapped_type& operator[](const key_type& key);
+  mapped_type& operator[](key_type&& key);
+
+  mapped_type& at(const key_type& key);
+  const mapped_type& at(const key_type& key) const;
+
+  iterator find(const key_type& key);
+  const_iterator find(const key_type& key) const;
+
+  bool contains(const key_type& key) const;
+  size_type count(const key_type& key) const;
+
+ private:
+  static constexpr uint8_t kEmpty = 0xFF;
+  static constexpr uint8_t kDeleted = 0xFE;
+
+  struct Slot {
+    alignas(value_type) uint8_t storage[sizeof(value_type)];
+    value_type* ptr();
+    const value_type* ptr() const;
+  };
+
+  Slot* slots_;
+  uint8_t* metadata_;
+  size_type capacity_;
+  size_type size_;
+  float max_load_factor_;
+  Hash hash_;
+  KeyEqual equal_;
+
+  static size_type CalculateCapacity(size_type requested);
+  static uint8_t H2(size_t hash_value);
+
+  size_type FindSlot(const Key& key, size_t hash_value) const;
+  size_type FindInsertSlot(const Key& key, size_t hash_value) const;
+
+  void Allocate(size_type new_capacity);
+  void Deallocate();
+  void RehashImpl(size_type new_capacity);
+
+  std::pair<iterator, bool> InsertImpl(const Key& key,
+                                       const mapped_type& value);
+  std::pair<iterator, bool> InsertImpl(Key&& key, mapped_type&& value);
+};
+
+template <class Key, class T, class Hash, class KeyEqual>
+class flat_hash_map<Key, T, Hash, KeyEqual>::iterator {
+  friend class flat_hash_map;
+  friend class const_iterator;
+
+  flat_hash_map* map_;
+  size_type index_;
+
+  iterator(flat_hash_map* map, size_type index);
+
+ public:
+  using difference_type = std::ptrdiff_t;
+  using value_type = flat_hash_map::value_type;
+  using pointer = value_type*;
+  using reference = value_type&;
+  using iterator_category = std::forward_iterator_tag;
+
+  iterator();
+
+  reference operator*() const;
+  pointer operator->() const;
+
+  iterator& operator++();
+  iterator operator++(int);
+
+  bool operator==(const iterator& other) const;
+  bool operator!=(const iterator& other) const;
+};
+
+template <class Key, class T, class Hash, class KeyEqual>
+class flat_hash_map<Key, T, Hash, KeyEqual>::const_iterator {
+  friend class flat_hash_map;
+
+  const flat_hash_map* map_;
+  size_type index_;
+
+  const_iterator(const flat_hash_map* map, size_type index);
+
+ public:
+  using difference_type = std::ptrdiff_t;
+  using value_type = flat_hash_map::value_type;
+  using pointer = const value_type*;
+  using reference = const value_type&;
+  using iterator_category = std::forward_iterator_tag;
+
+  const_iterator();
+  const_iterator(const iterator& it);
+
+  reference operator*() const;
+  pointer operator->() const;
+
+  const_iterator& operator++();
+  const_iterator operator++(int);
+
+  bool operator==(const const_iterator& other) const;
+  bool operator!=(const const_iterator& other) const;
+};
+
+#include "flat_hash_map.cpp"
+
+#endif  // FLAT_HASH_MAP_HPP_
diff --git a/lab3/tests.cpp b/lab3/tests.cpp
new file mode 100644
index 0000000..0c58443
--- /dev/null
+++ b/lab3/tests.cpp
@@ -0,0 +1,257 @@
+#include "flat_hash_map.hpp"
+#include <gtest/gtest.h>
+#include <string>
+#include <vector>
+
+class FlatHashMapTest : public ::testing::Test {
+protected:
+    flat_hash_map<int, std::string> map;
+    flat_hash_map<std::string, int> str_map;
+};
+
+TEST_F(FlatHashMapTest, DefaultConstructor) {
+    flat_hash_map<int, int> m;
+    EXPECT_TRUE(m.empty());
+    EXPECT_EQ(m.size(), 0);
+}
+
+TEST_F(FlatHashMapTest, BucketCountConstructor) {
+    flat_hash_map<int, int> m(100);
+    EXPECT_TRUE(m.empty());
+    EXPECT_GE(m.capacity(), 100);
+}
+
+TEST_F(FlatHashMapTest, InitializerListConstructor) {
+    flat_hash_map<int, std::string> m = {{1, "one"}, {2, "two"}, {3, "three"}};
+    EXPECT_EQ(m.size(), 3);
+    EXPECT_EQ(m[1], "one");
+}
+
+TEST_F(FlatHashMapTest, CopyConstructor) {
+    map[1] = "one";
+    map[2] = "two";
+    flat_hash_map<int, std::string> copy(map);
+    EXPECT_EQ(copy.size(), 2);
+    EXPECT_EQ(copy[1], "one");
+}
+
+TEST_F(FlatHashMapTest, MoveConstructor) {
+    map[1] = "one";
+    flat_hash_map<int, std::string> moved(std::move(map));
+    EXPECT_EQ(moved[1], "one");
+    EXPECT_EQ(map.size(), 0);
+}
+
+TEST_F(FlatHashMapTest, CopyAssignment) {
+    map[1] = "one";
+    flat_hash_map<int, std::string> copy;
+    copy = map;
+    EXPECT_EQ(copy[1], "one");
+}
+
+TEST_F(FlatHashMapTest, MoveAssignment) {
+    map[1] = "one";
+    flat_hash_map<int, std::string> moved;
+    moved = std::move(map);
+    EXPECT_EQ(moved[1], "one");
+}
+
+TEST_F(FlatHashMapTest, Swap) {
+    map[1] = "one";
+    flat_hash_map<int, std::string> other;
+    other[2] = "two";
+    map.swap(other);
+    EXPECT_EQ(map[2], "two");
+    EXPECT_EQ(other[1], "one");
+}
+
+TEST_F(FlatHashMapTest, Iterator) {
+    map = {{1, "one"}, {2, "two"}, {3, "three"}};
+    int count = 0;
+    for (auto it = map.begin(); it != map.end(); ++it) {
+        count++;
+    }
+    EXPECT_EQ(count, 3);
+}
+
+TEST_F(FlatHashMapTest, RangeBasedFor) {
+    map = {{1, "one"}, {2, "two"}};
+    int count = 0;
+    for (const auto& pair : map) {
+        count++;
+    }
+    EXPECT_EQ(count, 2);
+}
+
+TEST_F(FlatHashMapTest, Empty) {
+    EXPECT_TRUE(map.empty());
+    map[1] = "one";
+    EXPECT_FALSE(map.empty());
+}
+
+TEST_F(FlatHashMapTest, Size) {
+    EXPECT_EQ(map.size(), 0);
+    map[1] = "one";
+    EXPECT_EQ(map.size(), 1);
+}
+
+TEST_F(FlatHashMapTest, Clear) {
+    map = {{1, "one"}, {2, "two"}};
+    map.clear();
+    EXPECT_TRUE(map.empty());
+}
+
+TEST_F(FlatHashMapTest, InsertLvalue) {
+    std::pair<const int, std::string> value(1, "one");
+    auto result = map.insert(value);
+    EXPECT_TRUE(result.second);
+    EXPECT_EQ(map.size(), 1);
+}
+
+TEST_F(FlatHashMapTest, InsertDuplicate) {
+    map.insert({1, "one"});
+    auto result = map.insert({1, "uno"});
+    EXPECT_FALSE(result.second);
+    EXPECT_EQ(map[1], "one");
+}
+
+TEST_F(FlatHashMapTest, Emplace) {
+    auto result = map.emplace(1, "one");
+    EXPECT_TRUE(result.second);
+    EXPECT_EQ(map[1], "one");
+}
+
+TEST_F(FlatHashMapTest, EraseByKey) {
+    map = {{1, "one"}, {2, "two"}};
+    size_t erased = map.erase(2);
+    EXPECT_EQ(erased, 1);
+    EXPECT_EQ(map.size(), 1);
+}
+
+TEST_F(FlatHashMapTest, EraseByIterator) {
+    map = {{1, "one"}, {2, "two"}};
+    auto it = map.find(2);
+    map.erase(it);
+    EXPECT_FALSE(map.contains(2));
+}
+
+TEST_F(FlatHashMapTest, Reserve) {
+    map.reserve(100);
+    EXPECT_GE(map.capacity(), 100);
+}
+
+TEST_F(FlatHashMapTest, LoadFactor) {
+    map.reserve(100);
+    for (int i = 0; i < 50; ++i) {
+        map[i] = std::to_string(i);
+    }
+    EXPECT_GT(map.load_factor(), 0.0f);
+}
+
+TEST_F(FlatHashMapTest, SubscriptOperator) {
+    map[1] = "one";
+    EXPECT_EQ(map[1], "one");
+}
+
+TEST_F(FlatHashMapTest, AtValid) {
+    map[1] = "one";
+    EXPECT_EQ(map.at(1), "one");
+}
+
+TEST_F(FlatHashMapTest, AtInvalid) {
+    EXPECT_THROW(map.at(99), std::out_of_range);
+}
+
+TEST_F(FlatHashMapTest, Find) {
+    map[1] = "one";
+    auto it = map.find(1);
+    ASSERT_NE(it, map.end());
+    EXPECT_EQ(it->second, "one");
+}
+
+TEST_F(FlatHashMapTest, Contains) {
+    map[1] = "one";
+    EXPECT_TRUE(map.contains(1));
+    EXPECT_FALSE(map.contains(99));
+}
+
+TEST_F(FlatHashMapTest, Count) {
+    map[1] = "one";
+    EXPECT_EQ(map.count(1), 1);
+    EXPECT_EQ(map.count(99), 0);
+}
+
+TEST_F(FlatHashMapTest, LargeInsertion) {
+    for (int i = 0; i < 1000; ++i) {
+        map[i] = std::to_string(i);
+    }
+    EXPECT_EQ(map.size(), 1000);
+}
+
+TEST_F(FlatHashMapTest, RangeConstructor) {
+    std::vector<std::pair<int, std::string>> vec = {{1, "one"}, {2, "two"}, {3, "three"}};
+    flat_hash_map<int, std::string> m(vec.begin(), vec.end());
+    EXPECT_EQ(m.size(), 3);
+    EXPECT_EQ(m[2], "two");
+}
+
+TEST_F(FlatHashMapTest, RangeInsert) {
+    std::vector<std::pair<int, std::string>> vec = {{1, "one"}, {2, "two"}};
+    map.insert(vec.begin(), vec.end());
+    EXPECT_EQ(map.size(), 2);
+    EXPECT_EQ(map[1], "one");
+}
+
+TEST_F(FlatHashMapTest, SubscriptOperatorRvalue) {
+    int key = 42;
+    map[std::move(key)] = "value";
+    EXPECT_EQ(map[42], "value");
+}
+
+TEST_F(FlatHashMapTest, AtConstVersion) {
+    map[1] = "one";
+    const auto& const_map = map;
+    EXPECT_EQ(const_map.at(1), "one");
+}
+
+TEST_F(FlatHashMapTest, FindConstVersion) {
+    map[1] = "one";
+    const auto& const_map = map;
+    auto it = const_map.find(1);
+    EXPECT_NE(it, const_map.end());
+    EXPECT_EQ(it->second, "one");
+}
+
+TEST_F(FlatHashMapTest, ConstIterators) {
+    map = {{1, "one"}, {2, "two"}};
+    const auto& const_map = map;
+    int count = 0;
+    for (auto it = const_map.cbegin(); it != const_map.cend(); ++it) {
+        count++;
+    }
+    EXPECT_EQ(count, 2);
+}
+
+TEST_F(FlatHashMapTest, AssignmentOperatorInitList) {
+    map = {{1, "one"}, {2, "two"}, {3, "three"}};
+    EXPECT_EQ(map.size(), 3);
+    EXPECT_EQ(map[2], "two");
+}
+
+TEST_F(FlatHashMapTest, EraseIteratorReturnValue) {
+    map = {{1, "one"}, {2, "two"}, {3, "three"}};
+    auto it = map.find(1);
+    auto next_it = map.erase(it);
+    EXPECT_NE(next_it, map.end());
+}
+
+TEST_F(FlatHashMapTest, MaxLoadFactor) {
+    EXPECT_EQ(map.max_load_factor(), 0.75f);
+    map.max_load_factor(0.5f);
+    EXPECT_EQ(map.max_load_factor(), 0.5f);
+}
+
+int main(int argc, char **argv) {
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}