Index: uspace/lib/cpp/include/impl/unordered_map.hpp
===================================================================
--- uspace/lib/cpp/include/impl/unordered_map.hpp	(revision a2f01c4367b069fcd4748385926f31f5b844d02d)
+++ uspace/lib/cpp/include/impl/unordered_map.hpp	(revision 784c8b6d88aec628f43883502ab23828e314f9e8)
@@ -757,7 +757,7 @@
 
             explicit unordered_multimap(size_type bucket_count,
-                                   const hasher& hf = hasher{},
-                                   const key_equal& eql = key_equal{},
-                                   const allocator_type& alloc = allocator_type{})
+                                        const hasher& hf = hasher{},
+                                        const key_equal& eql = key_equal{},
+                                        const allocator_type& alloc = allocator_type{})
                 : table_{bucket_count, hf, eql}, allocator_{alloc}
             { /* DUMMY BODY */ }
@@ -765,8 +765,8 @@
             template<class InputIterator>
             unordered_multimap(InputIterator first, InputIterator last,
-                          size_type bucket_count = default_bucket_count_,
-                          const hasher& hf = hasher{},
-                          const key_equal& eql = key_equal{},
-                          const allocator_type& alloc = allocator_type{})
+                               size_type bucket_count = default_bucket_count_,
+                               const hasher& hf = hasher{},
+                               const key_equal& eql = key_equal{},
+                               const allocator_type& alloc = allocator_type{})
                 : unordered_multimap{bucket_count, hf, eql, alloc}
             {
@@ -795,8 +795,8 @@
 
             unordered_multimap(initializer_list<value_type> init,
-                          size_type bucket_count = default_bucket_count_,
-                          const hasher& hf = hasher{},
-                          const key_equal& eql = key_equal{},
-                          const allocator_type& alloc = allocator_type{})
+                               size_type bucket_count = default_bucket_count_,
+                               const hasher& hf = hasher{},
+                               const key_equal& eql = key_equal{},
+                               const allocator_type& alloc = allocator_type{})
                 : unordered_multimap{bucket_count, hf, eql, alloc}
             {
@@ -808,5 +808,6 @@
             { /* DUMMY BODY */ }
 
-            unordered_multimap(size_type bucket_count, const hasher& hf, const allocator_type& alloc)
+            unordered_multimap(size_type bucket_count, const hasher& hf,
+                               const allocator_type& alloc)
                 : unordered_multimap{bucket_count, hf, key_equal{}, alloc}
             { /* DUMMY BODY */ }
@@ -814,5 +815,5 @@
             template<class InputIterator>
             unordered_multimap(InputIterator first, InputIterator last,
-                          size_type bucket_count, const allocator_type& alloc)
+                               size_type bucket_count, const allocator_type& alloc)
                 : unordered_multimap{first, last, bucket_count, hasher{}, key_equal{}, alloc}
             { /* DUMMY BODY */ }
@@ -820,15 +821,16 @@
             template<class InputIterator>
             unordered_multimap(InputIterator first, InputIterator last,
-                          size_type bucket_count, const hasher& hf, const allocator_type& alloc)
+                               size_type bucket_count, const hasher& hf,
+                               const allocator_type& alloc)
                 : unordered_multimap{first, last, bucket_count, hf, key_equal{}, alloc}
             { /* DUMMY BODY */ }
 
             unordered_multimap(initializer_list<value_type> init, size_type bucket_count,
-                          const allocator_type& alloc)
+                               const allocator_type& alloc)
                 : unordered_multimap{init, bucket_count, hasher{}, key_equal{}, alloc}
             { /* DUMMY BODY */ }
 
             unordered_multimap(initializer_list<value_type> init, size_type bucket_count,
-                          const hasher& hf, const allocator_type& alloc)
+                               const hasher& hf, const allocator_type& alloc)
                 : unordered_multimap{init, bucket_count, hf, key_equal{}, alloc}
             { /* DUMMY BODY */ }
@@ -917,5 +919,5 @@
 
             template<class... Args>
-            pair<iterator, bool> emplace(Args&&... args)
+            iterator emplace(Args&&... args)
             {
                 return table_.emplace(forward<Args>(args)...);
@@ -925,13 +927,13 @@
             iterator emplace_hint(const_iterator, Args&&... args)
             {
-                return emplace(forward<Args>(args)...).first;
-            }
-
-            pair<iterator, bool> insert(const value_type& val)
+                return emplace(forward<Args>(args)...);
+            }
+
+            iterator insert(const value_type& val)
             {
                 return table_.insert(val);
             }
 
-            pair<iterator, bool> insert(value_type&& val)
+            iterator insert(value_type&& val)
             {
                 return table_.insert(forward<value_type>(val));
@@ -942,5 +944,5 @@
                 class = enable_if_t<is_constructible_v<value_type, T&&>, void>
             >
-            pair<iterator, bool> insert(T&& val)
+            iterator insert(T&& val)
             {
                 return emplace(forward<T>(val));
@@ -949,10 +951,10 @@
             iterator insert(const_iterator, const value_type& val)
             {
-                return insert(val).first;
+                return insert(val);
             }
 
             iterator insert(const_iterator, value_type&& val)
             {
-                return insert(forward<value_type>(val)).first;
+                return insert(forward<value_type>(val));
             }