diff --git a/pp/bare_bones/snug_composite.h b/pp/bare_bones/snug_composite.h
index 1056b65155..e8526fe41b 100644
--- a/pp/bare_bones/snug_composite.h
+++ b/pp/bare_bones/snug_composite.h
@@ -708,266 +708,4 @@ class EncodingBimap : public GenericDecodingTable<EncodingBimap<Filament, Vector
   }
 };
 
-template <template <template <class> class> class Filament, template <class> class Vector>
-class ParallelEncodingBimap : public GenericDecodingTable<ParallelEncodingBimap<Filament, Vector>, Filament, Vector> {
-  using Base = GenericDecodingTable<ParallelEncodingBimap, Filament, Vector>;
-
-  friend class GenericDecodingTable<ParallelEncodingBimap, Filament, Vector>;
-
-  phmap::parallel_flat_hash_set<typename Base::Proxy, typename Base::Hasher, typename Base::EqualityComparator> set_;
-
-  PROMPP_ALWAYS_INLINE void after_items_load_impl(uint32_t first_loaded_id) noexcept {
-    set_.reserve(Base::items_.size());
-    for (auto id = first_loaded_id; id != Base::items_.size(); ++id) {
-      set_.emplace(typename Base::Proxy(id));
-    }
-  }
-
- public:
-  inline __attribute__((always_inline)) ParallelEncodingBimap() noexcept : set_({}, 0, Base::hasher(), Base::equality_comparator()) {}
-
-  ParallelEncodingBimap(const ParallelEncodingBimap&) = delete;
-  ParallelEncodingBimap(ParallelEncodingBimap&&) = delete;
-  ParallelEncodingBimap& operator=(const ParallelEncodingBimap&) = delete;
-  ParallelEncodingBimap& operator=(ParallelEncodingBimap&&) = delete;
-
-  template <class Class>
-  inline __attribute__((always_inline)) uint32_t find_or_emplace(const Class& c) noexcept {
-    return *set_.lazy_emplace(c, [&](const auto& ctor) {
-      uint32_t id = Base::items_.size();
-      Base::items_.emplace_back(Base::data_, c);
-      ctor(id);
-    });
-  }
-
-  template <class Class>
-  inline __attribute__((always_inline)) uint32_t find_or_emplace(const Class& c, size_t hashval) noexcept {
-    return *set_.lazy_emplace_with_hash(c, phmap::phmap_mix<sizeof(size_t)>()(hashval), [&](const auto& ctor) {
-      uint32_t id = Base::items_.size();
-      Base::items_.emplace_back(Base::data_, c);
-      ctor(id);
-    });
-  }
-
-  template <class Class>
-  inline __attribute__((always_inline)) std::optional<uint32_t> find(const Class& c) const noexcept {
-    if (auto i = set_.find(c); i != set_.end()) {
-      return *i;
-    }
-    return {};
-  }
-
-  template <class Class>
-  inline __attribute__((always_inline)) std::optional<uint32_t> find(const Class& c, size_t hashval) const noexcept {
-    if (auto i = set_.find(c, phmap::phmap_mix<sizeof(size_t)>()(hashval)); i != set_.end()) {
-      return *i;
-    }
-    return {};
-  }
-
-  inline __attribute__((always_inline)) void rollback_impl(const typename Base::checkpoint_type& s) noexcept
-    requires(!Base::kIsReadOnly)
-  {
-    assert(s.size() <= Base::items_.size());
-
-    for (uint32_t i = s.size(); i != Base::items_.size(); ++i) {
-      set_.erase(typename Base::Proxy(i));
-    }
-  }
-
-  // TODO wrap everything with read/write mutex, and test it!
-};
-
-template <template <template <class> class> class Filament, template <class> class Vector>
-class OrderedEncodingBimap : public GenericDecodingTable<OrderedEncodingBimap<Filament, Vector>, Filament, Vector> {
-  using Base = GenericDecodingTable<OrderedEncodingBimap, Filament, Vector>;
-
-  friend class GenericDecodingTable<OrderedEncodingBimap, Filament, Vector>;
-
-  using Set = phmap::btree_set<typename Base::Proxy, typename Base::LessComparator>;
-  Set set_;
-
- protected:
-  PROMPP_ALWAYS_INLINE void after_items_load_impl(uint32_t first_loaded_id) noexcept {
-    for (auto id = first_loaded_id; id != Base::items_.size(); ++id) {
-      set_.emplace(typename Base::Proxy(id));
-    }
-  }
-
- public:
-  inline __attribute__((always_inline)) OrderedEncodingBimap() noexcept : set_({}, Base::less_comparator()) {}
-
-  OrderedEncodingBimap(const OrderedEncodingBimap&) = delete;
-  OrderedEncodingBimap(OrderedEncodingBimap&&) = delete;
-  OrderedEncodingBimap& operator=(const OrderedEncodingBimap&) = delete;
-  OrderedEncodingBimap& operator=(OrderedEncodingBimap&&) = delete;
-
-  template <class Class>
-  inline __attribute__((always_inline)) uint32_t find_or_emplace(const Class& c) noexcept {
-    auto i = set_.lower_bound(c);
-    if (i != set_.end() && (*this)[*i] == c) {
-      return *i;
-    }
-
-    uint32_t id = Base::items_.size();
-    Base::items_.emplace_back(Base::data_, c);
-    set_.insert(i, typename Base::Proxy(id));
-
-    return id;
-  }
-
-  template <class Class>
-  inline __attribute__((always_inline)) uint32_t find_or_emplace(const Class& c, [[maybe_unused]] size_t hashval) noexcept {
-    return find_or_emplace(c);
-  }
-
-  template <class Class>
-  inline __attribute__((always_inline)) std::optional<uint32_t> find(const Class& c) const noexcept {
-    if (auto i = set_.find(c); i != set_.end()) {
-      return *i;
-    }
-    return {};
-  }
-
-  template <class Class>
-  inline __attribute__((always_inline)) std::optional<uint32_t> find(const Class& c, [[maybe_unused]] size_t hashval) const noexcept {
-    if (auto i = set_.find(c); i != set_.end()) {
-      return *i;
-    }
-    return {};
-  }
-
-  PROMPP_ALWAYS_INLINE void rollback_impl(const typename Base::checkpoint_type& s) noexcept
-    requires(!Base::kIsReadOnly)
-  {
-    assert(s.size() <= Base::items_.size());
-
-    for (uint32_t i = s.size(); i != Base::items_.size(); ++i) {
-      set_.erase(typename Base::Proxy(i));
-    }
-  }
-
-  inline __attribute__((always_inline)) auto begin() const noexcept {
-    return typename Base::template ItemIDIterator<typename Set::const_iterator>(this, set_.begin());
-  }
-  inline __attribute__((always_inline)) auto end() const noexcept { return typename Base::template IteratorSentinel<typename Set::const_iterator>(set_.end()); }
-
-  inline __attribute__((always_inline)) auto unordered_begin() const noexcept { return Base::begin(); }
-  inline __attribute__((always_inline)) auto unordered_end() const noexcept { return Base::end(); }
-};
-
-template <template <template <class> class> class Filament, template <class> class Vector>
-class OrderedDecodingTable : public GenericDecodingTable<OrderedDecodingTable<Filament, Vector>, Filament, Vector> {
-  using Base = GenericDecodingTable<OrderedDecodingTable, Filament, Vector>;
-
- public:
-  using Base::Base;
-  OrderedDecodingTable(const OrderedDecodingTable&) = delete;
-  OrderedDecodingTable(OrderedDecodingTable&&) = delete;
-  OrderedDecodingTable& operator=(const OrderedDecodingTable&) = delete;
-  OrderedDecodingTable& operator=(OrderedDecodingTable&&) = delete;
-
-  auto back() const noexcept { return Base::items_.back().composite(Base::data_); }
-
-  template <class Class>
-  inline __attribute__((always_inline)) uint32_t emplace_back(const Class& c) {
-    const uint32_t id = Base::items_.size();
-
-    if (id != 0 && c < back()) {
-      throw BareBones::Exception(0xf677f03159e75ee7, "Broken order of OrderedDecodingTable item emplacement");
-    }
-
-    Base::items_.emplace_back(Base::data_, c);
-
-    return id;
-  }
-};
-
-template <template <template <class> class> class Filament, template <class> class Vector>
-class EncodingBimapWithOrderedAccess : public GenericDecodingTable<EncodingBimapWithOrderedAccess<Filament, Vector>, Filament, Vector> {
-  using Base = GenericDecodingTable<EncodingBimapWithOrderedAccess, Filament, Vector>;
-
-  friend class GenericDecodingTable<EncodingBimapWithOrderedAccess, Filament, Vector>;
-
-  using OrderedSet = phmap::btree_set<typename Base::Proxy, typename Base::LessComparator>;
-  OrderedSet ordered_set_;
-
-  using Set = phmap::flat_hash_set<typename Base::Proxy, typename Base::Hasher, typename Base::EqualityComparator>;
-  Set set_;
-
-  PROMPP_ALWAYS_INLINE void after_items_load_impl(uint32_t first_loaded_id) noexcept {
-    set_.reserve(Base::items_.size());
-    for (auto id = first_loaded_id; id != Base::items_.size(); ++id) {
-      set_.emplace(typename Base::Proxy(id));
-      ordered_set_.emplace(typename Base::Proxy(id));
-    }
-  }
-
- public:
-  inline __attribute__((always_inline)) EncodingBimapWithOrderedAccess() noexcept
-      : ordered_set_({}, Base::less_comparator()), set_({}, 0, Base::hasher(), Base::equality_comparator()) {}
-
-  EncodingBimapWithOrderedAccess(const EncodingBimapWithOrderedAccess&) = delete;
-  EncodingBimapWithOrderedAccess(EncodingBimapWithOrderedAccess&&) = delete;
-  EncodingBimapWithOrderedAccess& operator=(const EncodingBimapWithOrderedAccess&) = delete;
-  EncodingBimapWithOrderedAccess& operator=(EncodingBimapWithOrderedAccess&&) = delete;
-
-  template <class Class>
-  inline __attribute__((always_inline)) uint32_t find_or_emplace(const Class& c) noexcept {
-    return *set_.lazy_emplace(c, [&](const auto& ctor) {
-      uint32_t id = Base::items_.size();
-      Base::items_.emplace_back(Base::data_, c);
-      ordered_set_.insert(typename Base::Proxy(id));
-      ctor(id);
-    });
-  }
-
-  template <class Class>
-  inline __attribute__((always_inline)) uint32_t find_or_emplace(const Class& c, size_t hashval) noexcept {
-    return *set_.lazy_emplace_with_hash(c, phmap::phmap_mix<sizeof(size_t)>()(hashval), [&](const auto& ctor) {
-      uint32_t id = Base::items_.size();
-      Base::items_.emplace_back(Base::data_, c);
-      ordered_set_.insert(typename Base::Proxy(id));
-      ctor(id);
-    });
-  }
-
-  template <class Class>
-  inline __attribute__((always_inline)) std::optional<uint32_t> find(const Class& c) const noexcept {
-    if (auto i = set_.find(c); i != set_.end()) {
-      return *i;
-    }
-    return {};
-  }
-
-  template <class Class>
-  inline __attribute__((always_inline)) std::optional<uint32_t> find(const Class& c, size_t hashval) const noexcept {
-    if (auto i = set_.find(c, phmap::phmap_mix<sizeof(size_t)>()(hashval)); i != set_.end()) {
-      return *i;
-    }
-    return {};
-  }
-
-  PROMPP_ALWAYS_INLINE void rollback_impl(const typename Base::checkpoint_type& s) noexcept
-    requires(!Base::kIsReadOnly)
-  {
-    assert(s.size() <= Base::items_.size());
-
-    for (uint32_t i = s.size(); i != Base::items_.size(); ++i) {
-      ordered_set_.erase(typename Base::Proxy(i));
-      set_.erase(typename Base::Proxy(i));
-    }
-  }
-
-  inline __attribute__((always_inline)) auto begin() const noexcept {
-    return typename Base::template ItemIDIterator<typename OrderedSet::const_iterator>(this, ordered_set_.begin());
-  }
-  inline __attribute__((always_inline)) auto end() const noexcept {
-    return typename Base::template IteratorSentinel<typename OrderedSet::const_iterator>(ordered_set_.end());
-  }
-
-  inline __attribute__((always_inline)) auto unordered_begin() const noexcept { return Base::begin(); }
-  inline __attribute__((always_inline)) auto unordered_end() const noexcept { return Base::end(); }
-};
-
 }  // namespace BareBones::SnugComposite
diff --git a/pp/bare_bones/tests/snug_composite_tests.cpp b/pp/bare_bones/tests/snug_composite_tests.cpp
index 92cdcf30ba..49f8b51ffa 100644
--- a/pp/bare_bones/tests/snug_composite_tests.cpp
+++ b/pp/bare_bones/tests/snug_composite_tests.cpp
@@ -107,11 +107,7 @@ class TestSnugCompositesStringFilament {
   }
 };
 
-typedef testing::Types<BareBones::SnugComposite::EncodingBimap<TestSnugCompositesStringFilament, Vector>,
-                       BareBones::SnugComposite::ParallelEncodingBimap<TestSnugCompositesStringFilament, Vector>,
-                       BareBones::SnugComposite::OrderedEncodingBimap<TestSnugCompositesStringFilament, Vector>,
-                       BareBones::SnugComposite::EncodingBimapWithOrderedAccess<TestSnugCompositesStringFilament, Vector>>
-    SnugCompositesBimapTypes;
+typedef testing::Types<BareBones::SnugComposite::EncodingBimap<TestSnugCompositesStringFilament, Vector>> SnugCompositesBimapTypes;
 
 template <class T>
 struct SnugComposite : public testing::Test {
@@ -141,30 +137,28 @@ TYPED_TEST(SnugComposite, should_return_same_id_for_same_data) {
 }
 
 TYPED_TEST(SnugComposite, should_return_same_id_for_same_data_with_hash) {
-  if constexpr (!std::is_same_v<TypeParam, BareBones::SnugComposite::OrderedEncodingBimap<TestSnugCompositesStringFilament, Vector>>) {
-    TypeParam outcomes;
-    this->fill_table_with_random_values(outcomes);
+  TypeParam outcomes;
+  this->fill_table_with_random_values(outcomes);
 
-    std::string v = "12";
-    auto hash_val = BareBones::XXHash::hash(v);
-    auto id = outcomes.find_or_emplace(v, hash_val);
+  std::string v = "12";
+  auto hash_val = BareBones::XXHash::hash(v);
+  auto id = outcomes.find_or_emplace(v, hash_val);
 
-    EXPECT_EQ(id, outcomes.find_or_emplace(v, hash_val));
-    EXPECT_EQ(id, outcomes.find_or_emplace(v));
+  EXPECT_EQ(id, outcomes.find_or_emplace(v, hash_val));
+  EXPECT_EQ(id, outcomes.find_or_emplace(v));
 
-    EXPECT_EQ(outcomes.find_or_emplace(v, hash_val), outcomes.find(v, hash_val));
-    EXPECT_EQ(outcomes.find_or_emplace(v, hash_val), outcomes.find(v));
+  EXPECT_EQ(outcomes.find_or_emplace(v, hash_val), outcomes.find(v, hash_val));
+  EXPECT_EQ(outcomes.find_or_emplace(v, hash_val), outcomes.find(v));
 
-    v = "21";
-    hash_val = BareBones::XXHash::hash(v);
-    id = outcomes.find_or_emplace(v);
+  v = "21";
+  hash_val = BareBones::XXHash::hash(v);
+  id = outcomes.find_or_emplace(v);
 
-    EXPECT_EQ(id, outcomes.find_or_emplace(v, hash_val));
-    EXPECT_EQ(id, outcomes.find_or_emplace(v));
+  EXPECT_EQ(id, outcomes.find_or_emplace(v, hash_val));
+  EXPECT_EQ(id, outcomes.find_or_emplace(v));
 
-    EXPECT_EQ(outcomes.find_or_emplace(v), outcomes.find(v));
-    EXPECT_EQ(outcomes.find_or_emplace(v), outcomes.find(v, hash_val));
-  }
+  EXPECT_EQ(outcomes.find_or_emplace(v), outcomes.find(v));
+  EXPECT_EQ(outcomes.find_or_emplace(v), outcomes.find(v, hash_val));
 }
 
 TYPED_TEST(SnugComposite, should_return_different_id_for_different_data) {
@@ -183,29 +177,27 @@ TYPED_TEST(SnugComposite, should_return_different_id_for_different_data) {
 }
 
 TYPED_TEST(SnugComposite, should_return_different_id_for_different_data_with_hash) {
-  if constexpr (!std::is_same_v<TypeParam, BareBones::SnugComposite::OrderedEncodingBimap<TestSnugCompositesStringFilament, Vector>>) {
-    TypeParam outcomes;
-    this->fill_table_with_random_values(outcomes);
+  TypeParam outcomes;
+  this->fill_table_with_random_values(outcomes);
 
-    std::string v = "12";
-    size_t hash_val = std::hash<std::string>()(v);
-    auto id = outcomes.find_or_emplace(v, hash_val);
+  std::string v = "12";
+  size_t hash_val = std::hash<std::string>()(v);
+  auto id = outcomes.find_or_emplace(v, hash_val);
 
-    v = "21";
-    hash_val = std::hash<std::string>()(v);
+  v = "21";
+  hash_val = std::hash<std::string>()(v);
 
-    EXPECT_NE(id, outcomes.find_or_emplace(v, hash_val));
-    EXPECT_NE(id, outcomes.find_or_emplace(v));
+  EXPECT_NE(id, outcomes.find_or_emplace(v, hash_val));
+  EXPECT_NE(id, outcomes.find_or_emplace(v));
 
-    v = "13";
-    id = outcomes.find_or_emplace(v);
+  v = "13";
+  id = outcomes.find_or_emplace(v);
 
-    v = "31";
-    hash_val = std::hash<std::string>()(v);
+  v = "31";
+  hash_val = std::hash<std::string>()(v);
 
-    EXPECT_NE(id, outcomes.find_or_emplace(v, hash_val));
-    EXPECT_NE(id, outcomes.find_or_emplace(v));
-  }
+  EXPECT_NE(id, outcomes.find_or_emplace(v, hash_val));
+  EXPECT_NE(id, outcomes.find_or_emplace(v));
 }
 
 TYPED_TEST(SnugComposite, should_assign_new_ids_after_rollback) {
diff --git a/pp/entrypoint/head/lss.h b/pp/entrypoint/head/lss.h
index 4114ab24bb..48d8cfc607 100644
--- a/pp/entrypoint/head/lss.h
+++ b/pp/entrypoint/head/lss.h
@@ -16,13 +16,10 @@ using LsIdsSlicePtr = std::unique_ptr<LsIdsSlice>;
 
 enum class LssType : uint32_t {
   kEncodingBimap = 0,
-  kOrderedEncodingBimap,
   kQueryableEncodingBimap,
   kReadonlyLss,
 };
 
-using OrderedEncodingBimap = PromPP::Primitives::SnugComposites::LabelSet::OrderedEncodingBimap<BareBones::Vector>;
-
 namespace lss_memory {
 
 thread_local inline bool has_reallocations{};
@@ -96,7 +93,7 @@ class ReallocationsDetector {
   }
 };
 
-using LssVariant = std::variant<EncodingBimap, OrderedEncodingBimap, QueryableEncodingBimap, ReadonlyLss>;
+using LssVariant = std::variant<EncodingBimap, QueryableEncodingBimap, ReadonlyLss>;
 using LssVariantPtr = std::unique_ptr<LssVariant>;
 
 static_assert(sizeof(LssVariantPtr) == sizeof(void*));
@@ -107,10 +104,6 @@ inline LssVariantPtr create_lss(LssType type) {
       return std::make_unique<LssVariant>(std::in_place_index<static_cast<int>(LssType::kEncodingBimap)>);
     }
 
-    case LssType::kOrderedEncodingBimap: {
-      return std::make_unique<LssVariant>(std::in_place_index<static_cast<int>(LssType::kOrderedEncodingBimap)>);
-    }
-
     case LssType::kQueryableEncodingBimap: {
       return std::make_unique<LssVariant>(std::in_place_index<static_cast<int>(LssType::kQueryableEncodingBimap)>);
     }
diff --git a/pp/go/cppbridge/primitives_lss.go b/pp/go/cppbridge/primitives_lss.go
index a0bef17dc9..01328ac924 100644
--- a/pp/go/cppbridge/primitives_lss.go
+++ b/pp/go/cppbridge/primitives_lss.go
@@ -9,7 +9,6 @@ import (
 
 const (
 	lssEncodingBimap uint32 = iota
-	lssOrderedEncodingBimap
 	lssQueryableEncodingBimap
 )
 
@@ -39,11 +38,6 @@ func NewLssStorage() *LabelSetStorage {
 	return newLabelSetStorage(lssEncodingBimap)
 }
 
-// NewOrderedLssStorage init new LabelSetStorage based on OrderedEncodingBimap.
-func NewOrderedLssStorage() *LabelSetStorage {
-	return newLabelSetStorage(lssOrderedEncodingBimap)
-}
-
 // NewQueryableLssStorage init new LabelSetStorage based on QueryableEncodingBimap.
 func NewQueryableLssStorage() *LabelSetStorage {
 	return newLabelSetStorage(lssQueryableEncodingBimap)
diff --git a/pp/go/cppbridge/primitives_lss_test.go b/pp/go/cppbridge/primitives_lss_test.go
index d004ef5d9c..f7e0c2c687 100644
--- a/pp/go/cppbridge/primitives_lss_test.go
+++ b/pp/go/cppbridge/primitives_lss_test.go
@@ -32,14 +32,6 @@ func (s *LSSSuite) TestLSS() {
 	s.Require().NotEqual(0, cp)
 }
 
-func (s *LSSSuite) TestOrderedLSS() {
-	lss := cppbridge.NewOrderedLssStorage()
-
-	s.Equal(uint64(0), lss.AllocatedMemory())
-	cp := lss.Pointer()
-	s.Require().NotEqual(0, cp)
-}
-
 func (s *LSSSuite) TestQueryableLSS() {
 	lss := cppbridge.NewQueryableLssStorage()
 
diff --git a/pp/integration_tests/filling_snug_composites_from_stream.cpp b/pp/integration_tests/filling_snug_composites_from_stream.cpp
index da0cda5e5f..35e1fcc8ea 100644
--- a/pp/integration_tests/filling_snug_composites_from_stream.cpp
+++ b/pp/integration_tests/filling_snug_composites_from_stream.cpp
@@ -55,13 +55,6 @@ TEST_F(SnugComposite, DecodingTable) {
   EXPECT_TRUE(std::ranges::equal(expected_result.begin(), expected_result.end(), actual_result.begin(), actual_result.end()));
 }
 
-TEST_F(SnugComposite, ParallelEncodingBimap) {
-  Primitives::SnugComposites::LabelSet::ParallelEncodingBimap<BareBones::Vector> actual_result;
-  lss_full_lz4_stream >> actual_result;
-
-  EXPECT_TRUE(std::ranges::equal(expected_result.begin(), expected_result.end(), actual_result.begin(), actual_result.end(), std::equal_to()));
-}
-
 TEST_F(SnugComposite, EncodingBimap) {
   Primitives::SnugComposites::LabelSet::EncodingBimap<BareBones::Vector> actual_result;
   lss_full_lz4_stream >> actual_result;
@@ -69,19 +62,4 @@ TEST_F(SnugComposite, EncodingBimap) {
   EXPECT_TRUE(std::ranges::equal(expected_result.begin(), expected_result.end(), actual_result.begin(), actual_result.end(), std::equal_to()));
 }
 
-TEST_F(SnugComposite, OrderedEncodingBimap) {
-  Primitives::SnugComposites::LabelSet::OrderedEncodingBimap<BareBones::Vector> actual_result;
-  lss_full_lz4_stream >> actual_result;
-
-  EXPECT_TRUE(
-      std::ranges::equal(expected_result.begin(), expected_result.end(), actual_result.unordered_begin(), actual_result.unordered_end(), std::equal_to()));
-}
-
-TEST_F(SnugComposite, OrderedIndexingTable) {
-  Primitives::SnugComposites::LabelSet::OrderedIndexingTable<BareBones::Vector> actual_result;
-  lss_full_lz4_stream >> actual_result;
-
-  EXPECT_TRUE(std::ranges::equal(expected_result.begin(), expected_result.end(), actual_result.begin(), actual_result.end(), std::equal_to()));
-}
-
 }  // namespace
diff --git a/pp/performance_tests/full_load_lss_test.cpp b/pp/performance_tests/full_load_lss_test.cpp
index 31b9cd7d40..fef198e2e7 100644
--- a/pp/performance_tests/full_load_lss_test.cpp
+++ b/pp/performance_tests/full_load_lss_test.cpp
@@ -26,24 +26,6 @@ void full_load_lss::execute(const Config& config, Metrics& metrics) const {
                          << (std::chrono::duration_cast<std::chrono::microseconds>(now - start).count()));
   }
 
-  // test load time: ParallelEncodingBimap
-  {
-    std::ifstream infile(input_file_full_name(config), std::ios_base::binary);
-    BareBones::LZ4Stream::istream in(&infile);
-    if (!infile.is_open()) {
-      throw std::runtime_error("failed to open file '" + input_file_full_name(config) + "'");
-    }
-
-    Primitives::SnugComposites::LabelSet::ParallelEncodingBimap<BareBones::Vector> lss;
-
-    auto start = std::chrono::steady_clock::now();
-    in >> lss;
-    auto now = std::chrono::steady_clock::now();
-
-    metrics << (Metric() << "parallel_encoding_bimap_load_from_file_duration_microseconds"
-                         << (std::chrono::duration_cast<std::chrono::microseconds>(now - start).count()));
-  }
-
   // test load time: EncodingBimap
   {
     std::ifstream infile(input_file_full_name(config), std::ios_base::binary);
@@ -61,40 +43,4 @@ void full_load_lss::execute(const Config& config, Metrics& metrics) const {
     metrics << (Metric() << "encoding_bimap_load_from_file_duration_microseconds"
                          << (std::chrono::duration_cast<std::chrono::microseconds>(now - start).count()));
   }
-
-  // test load time: OrderedEncodingBimap
-  {
-    std::ifstream infile(input_file_full_name(config), std::ios_base::binary);
-    if (!infile.is_open()) {
-      throw std::runtime_error("failed to open file '" + input_file_full_name(config) + "'");
-    }
-
-    Primitives::SnugComposites::LabelSet::OrderedEncodingBimap<BareBones::Vector> lss;
-
-    BareBones::LZ4Stream::istream in(&infile);
-    auto start = std::chrono::steady_clock::now();
-    in >> lss;
-    auto now = std::chrono::steady_clock::now();
-
-    metrics << (Metric() << "ordered_encoding_bimap_load_from_file_duration_microseconds"
-                         << (std::chrono::duration_cast<std::chrono::microseconds>(now - start).count()));
-  }
-
-  // test load time: OrderedIndexingTable
-  {
-    std::ifstream infile(input_file_full_name(config), std::ios_base::binary);
-    if (!infile.is_open()) {
-      throw std::runtime_error("failed to open file '" + input_file_full_name(config) + "'");
-    }
-
-    Primitives::SnugComposites::LabelSet::OrderedIndexingTable<BareBones::Vector> lss;
-
-    BareBones::LZ4Stream::istream in(&infile);
-    auto start = std::chrono::steady_clock::now();
-    in >> lss;
-    auto now = std::chrono::steady_clock::now();
-
-    metrics << (Metric() << "ordered_indexing_table_load_from_file_duration_microseconds"
-                         << (std::chrono::duration_cast<std::chrono::microseconds>(now - start).count()));
-  }
 }
diff --git a/pp/performance_tests/load_ordered_indexing_table_in_loop_test.cpp b/pp/performance_tests/load_ordered_indexing_table_in_loop_test.cpp
deleted file mode 100644
index 94a49a2731..0000000000
--- a/pp/performance_tests/load_ordered_indexing_table_in_loop_test.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-#include "load_ordered_indexing_table_in_loop_test.h"
-
-#include <chrono>
-
-#include "bare_bones/lz4_stream.h"
-#include "primitives/snug_composites.h"
-
-using namespace PromPP;  // NOLINT
-
-void load_ordered_indexing_table_in_loop::execute(const Config& config, Metrics& metrics) const {
-  Primitives::SnugComposites::LabelSet::OrderedEncodingBimap<BareBones::Vector> source_lss;
-  std::ifstream infile(input_file_full_name(config), std::ios_base::binary);
-  BareBones::LZ4Stream::istream in(&infile);
-  if (!infile.is_open()) {
-    throw std::runtime_error("failed to open file '" + input_file_full_name(config) + "'");
-  }
-
-  in >> source_lss;
-
-  // Load
-  Primitives::SnugComposites::LabelSet::OrderedIndexingTable<BareBones::Vector> lss;
-
-  auto start = std::chrono::steady_clock::now();
-  for (auto i = source_lss.begin(); i != source_lss.end(); ++i) {
-    lss.emplace_back(*i);
-  }
-  auto now = std::chrono::steady_clock::now();
-
-  metrics << (Metric() << "ordered_indexing_table_add_label_sets_one_by_one" << std::chrono::duration_cast<std::chrono::microseconds>(now - start).count());
-}
diff --git a/pp/performance_tests/load_ordered_indexing_table_in_loop_test.h b/pp/performance_tests/load_ordered_indexing_table_in_loop_test.h
deleted file mode 100644
index 17af1c89dd..0000000000
--- a/pp/performance_tests/load_ordered_indexing_table_in_loop_test.h
+++ /dev/null
@@ -1,10 +0,0 @@
-#pragma once
-
-#include "test_with_input_only.h"
-
-struct load_ordered_indexing_table_in_loop : TestWithInputOnly {
-  std::string input_file_base_name() const final { return "lss_full"; }
-  bool has_output() const final { return false; }
-  std::string output_file_base_name() const final { return ""; }
-  void execute(const Config& config, Metrics& metrics) const final;
-};
diff --git a/pp/performance_tests/performance_tests.cpp b/pp/performance_tests/performance_tests.cpp
index 39e2e7da66..269126674e 100644
--- a/pp/performance_tests/performance_tests.cpp
+++ b/pp/performance_tests/performance_tests.cpp
@@ -11,7 +11,6 @@
 #include "load_gorilla_from_wal_and_iterate_over_series_label_name_ids_test.h"
 #include "load_gorilla_from_wal_and_make_remote_write_from_it_test.h"
 #include "load_lss_from_wal_test.h"
-#include "load_ordered_indexing_table_in_loop_test.h"
 #include "load_protobuf_non_naned_wal_and_process_it_with_stale_nans.h"
 #include "load_protobuf_wal_and_save_gorilla_to_sharded_wal_test.h"
 #include "load_protobuf_wal_and_save_gorilla_to_wal_test.h"
@@ -72,7 +71,6 @@ int main([[maybe_unused]] int argc, char* argv[]) {
     test_db.add(std::make_unique<full_load_lss>());
     test_db.add(std::make_unique<performance_tests::SeriesDataEncoder>());
     test_db.add(std::make_unique<performance_tests::ChunkRecoder>());
-    test_db.add(std::make_unique<load_ordered_indexing_table_in_loop>());
     test_db.add(std::make_unique<save_gorilla_to_wal>());
     test_db.add(std::make_unique<performance_tests::series_index::GenerateSeriesReverseIndex>());
     test_db.add(std::make_unique<performance_tests::series_index::GenerateCedarppSeriesIndex>());
diff --git a/pp/performance_tests/save_lss_to_wal_test.cpp b/pp/performance_tests/save_lss_to_wal_test.cpp
index 2cd7a4eb99..ccc6fc53bc 100644
--- a/pp/performance_tests/save_lss_to_wal_test.cpp
+++ b/pp/performance_tests/save_lss_to_wal_test.cpp
@@ -15,7 +15,7 @@ void save_lss_to_wal::execute(const Config& config, Metrics& metrics) const {
 
   DummyWal::Timeseries tmsr;
   DummyWal dummy_wal(input_file_full_name(config));
-  Primitives::SnugComposites::LabelSet::ParallelEncodingBimap<BareBones::Vector> lss;
+  Primitives::SnugComposites::LabelSet::EncodingBimap<BareBones::Vector> lss;
 
   auto checkpoint = lss.checkpoint();
 
diff --git a/pp/primitives/snug_composites.h b/pp/primitives/snug_composites.h
index fb70ac6a0b..00d2226d0e 100644
--- a/pp/primitives/snug_composites.h
+++ b/pp/primitives/snug_composites.h
@@ -12,18 +12,6 @@ using DecodingTable = BareBones::SnugComposite::DecodingTable<Filaments::Symbol,
 template <template <class> class Vector>
 using EncodingBimap = BareBones::SnugComposite::EncodingBimap<Filaments::Symbol, Vector>;
 
-template <template <class> class Vector>
-using ParallelEncodingBimap = BareBones::SnugComposite::ParallelEncodingBimap<Filaments::Symbol, Vector>;
-
-template <template <class> class Vector>
-using OrderedEncodingBimap = BareBones::SnugComposite::OrderedEncodingBimap<Filaments::Symbol, Vector>;
-
-template <template <class> class Vector>
-using EncodingBimapWithOrderedAccess = BareBones::SnugComposite::EncodingBimapWithOrderedAccess<Filaments::Symbol, Vector>;
-
-template <template <class> class Vector>
-using OrderedDecodingTable = BareBones::SnugComposite::OrderedDecodingTable<Filaments::Symbol, Vector>;
-
 }  // namespace Symbol
 
 namespace LabelNameSet {
@@ -40,24 +28,6 @@ using EncodingBimapFilament = Filaments::LabelNameSet<Symbol::EncodingBimap, Vec
 template <template <class> class Vector>
 using EncodingBimap = BareBones::SnugComposite::EncodingBimap<EncodingBimapFilament, Vector>;
 
-template <template <class> class Vector>
-using OrderedEncodingBimapFilament = Filaments::LabelNameSet<Symbol::OrderedEncodingBimap, Vector>;
-
-template <template <class> class Vector>
-using OrderedEncodingBimap = BareBones::SnugComposite::OrderedEncodingBimap<OrderedEncodingBimapFilament, Vector>;
-
-template <template <class> class Vector>
-using EncodingBimapWithOrderedAccessFilament = Filaments::LabelNameSet<Symbol::EncodingBimapWithOrderedAccess, Vector>;
-
-template <template <class> class Vector>
-using EncodingBimapWithOrderedAccess = BareBones::SnugComposite::EncodingBimapWithOrderedAccess<EncodingBimapWithOrderedAccessFilament, Vector>;
-
-template <template <class> class Vector>
-using EncodingBimapWithOrderedAccessToSymbolsFilament = Filaments::LabelNameSet<Symbol::EncodingBimapWithOrderedAccess, Vector>;
-
-template <template <class> class Vector>
-using EncodingBimapWithOrderedAccessToSymbols = BareBones::SnugComposite::EncodingBimap<EncodingBimapWithOrderedAccessToSymbolsFilament, Vector>;
-
 }  // namespace LabelNameSet
 
 namespace LabelSet {
@@ -77,24 +47,6 @@ using EncodingBimap = BareBones::SnugComposite::EncodingBimap<EncodingBimapFilam
 template <template <class> class Vector>
 using ShrinkableEncodingBimap = BareBones::SnugComposite::ShrinkableEncodingBimap<EncodingBimapFilament, Vector>;
 
-template <template <class> class Vector>
-using ParallelEncodingBimapFilament = Filaments::LabelSet<Symbol::EncodingBimap, LabelNameSet::EncodingBimap, Vector>;
-
-template <template <class> class Vector>
-using ParallelEncodingBimap = BareBones::SnugComposite::ParallelEncodingBimap<EncodingBimapFilament, Vector>;
-
-template <template <class> class Vector>
-using OrderedEncodingBimapFilament = Filaments::LabelSet<Symbol::OrderedEncodingBimap, LabelNameSet::OrderedEncodingBimap, Vector>;
-
-template <template <class> class Vector>
-using OrderedEncodingBimap = BareBones::SnugComposite::OrderedEncodingBimap<OrderedEncodingBimapFilament, Vector>;
-
-template <template <class> class Vector>
-using OrderedIndexingTableFilament = Filaments::LabelSet<Symbol::EncodingBimapWithOrderedAccess, LabelNameSet::EncodingBimapWithOrderedAccessToSymbols, Vector>;
-
-template <template <class> class Vector>
-using OrderedIndexingTable = BareBones::SnugComposite::OrderedDecodingTable<OrderedIndexingTableFilament, Vector>;
-
 }  // namespace LabelSet
 
 }  // namespace PromPP::Primitives::SnugComposites
\ No newline at end of file
diff --git a/pp/primitives/tests/snug_composites_tests.cpp b/pp/primitives/tests/snug_composites_tests.cpp
index 3e5d57ffe7..870f472ca7 100644
--- a/pp/primitives/tests/snug_composites_tests.cpp
+++ b/pp/primitives/tests/snug_composites_tests.cpp
@@ -62,13 +62,6 @@ using LabelSet = GenericLabelSet<Vector>;
 
 struct SnugComposites : public testing::Test {};
 
-TEST(SnugComposites, OrderedDecodingTableWithSymbolsHandlesZeroStringAsFirstElementCorrectly) {
-  PromPP::Primitives::SnugComposites::Symbol::OrderedDecodingTable<Vector> t;
-
-  EXPECT_EQ(t.emplace_back(""), 0);
-  EXPECT_EQ(t[0], "");
-}
-
 TEST(SnugComposites, SnapshotRollbackSymbolEncodingBimap) {
   PromPP::Primitives::SnugComposites::Symbol::EncodingBimap<Vector> encoding_bimap;
 
diff --git a/pp/prometheus/tests/relabeler_tests.cpp b/pp/prometheus/tests/relabeler_tests.cpp
index 54056f0abb..83a5198fa5 100644
--- a/pp/prometheus/tests/relabeler_tests.cpp
+++ b/pp/prometheus/tests/relabeler_tests.cpp
@@ -19,7 +19,6 @@ using PromPP::Primitives::Sample;
 using PromPP::Primitives::Timestamp;
 using PromPP::Primitives::Go::SliceView;
 using PromPP::Primitives::SnugComposites::LabelSet::EncodingBimap;
-using PromPP::Primitives::SnugComposites::LabelSet::OrderedEncodingBimap;
 using PromPP::Prometheus::Relabel::hard_validate;
 using PromPP::Prometheus::Relabel::InnerSerie;
 using PromPP::Prometheus::Relabel::InnerSeries;