diff --git a/Makefile b/Makefile
index 207db3f..bf85073 100644
--- a/Makefile
+++ b/Makefile
@@ -20,7 +20,7 @@ CXXFLAGS = \
 ifneq (, $(findstring -g, $(CXXFLAGS)))
 	STRIP = true
 else
-	STRIP = strip
+	STRIP = true #strip
 endif
 
 ENGINE_CXXFLAGS = \
diff --git a/game/menu.cpp b/game/menu.cpp
index 74eedde..f3b0460 100644
--- a/game/menu.cpp
+++ b/game/menu.cpp
@@ -305,7 +305,7 @@ static void menuOptions() {
                 int findResolution = -1;
                 for (auto &it : kResolutionPairs) {
                     for (auto &jt : it) {
-                        if (jt.first() == width.get() && jt.second() == height.get()) {
+                        if (jt.first == width.get() && jt.second == height.get()) {
                             findRatio = &it - kResolutionPairs.begin();
                             findResolution = &jt - it.begin();
                             break;
@@ -322,8 +322,8 @@ static void menuOptions() {
                 D(resolution) = gui::selector(nullptr, D(resolution), kResolutionStrings[D(ratio)]);
 
                 auto resolution = kResolutionPairs[D(ratio)][D(resolution)];
-                width.set(resolution.first());
-                height.set(resolution.second());
+                width.set(resolution.first);
+                height.set(resolution.second);
             gui::dedent();
 
         }
diff --git a/model.cpp b/model.cpp
index eed8a41..30d439f 100644
--- a/model.cpp
+++ b/model.cpp
@@ -356,8 +356,8 @@ struct inData {
     }
 
     void operator=(const u::pair<uint32_t, unsigned char *> &data) {
-        isHalf = data.first() == iqm::kHalf;
-        asOpaque = data.second();
+        isHalf = data.first == iqm::kHalf;
+        asOpaque = data.second;
     }
 
     void endianSwap(size_t count) {
diff --git a/texture.cpp b/texture.cpp
index d53e80e..2bf466a 100644
--- a/texture.cpp
+++ b/texture.cpp
@@ -200,19 +200,21 @@ struct jpeg : decoder {
     static constexpr int kW7 = 565;
 
     // fast integer discrete cosine transform
+    #define sls(X, Y) (int)((unsigned int)(X) << (Y))
+
     void rowIDCT(int* blk) {
         int x0, x1, x2, x3, x4, x5, x6, x7, x8;
-        if (!((x1 = u::sls(blk[4], 11))
+        if (!((x1 = sls(blk[4], 11))
             | (x2 = blk[6]) | (x3 = blk[2])
             | (x4 = blk[1]) | (x5 = blk[7])
             | (x6 = blk[5]) | (x7 = blk[3])))
         {
-            int value = u::sls(blk[0], 3);
+            int value = sls(blk[0], 3);
             for (size_t i = 0; i < 8; i++)
                 blk[i] = value;
             return;
         }
-        x0 = u::sls(blk[0], 11) + 128;
+        x0 = sls(blk[0], 11) + 128;
         x8 = kW7 * (x4 + x5);
         x4 = x8 + (kW1 - kW7) * x4;
         x5 = x8 - (kW1 + kW7) * x5;
@@ -246,7 +248,7 @@ struct jpeg : decoder {
 
     void columnIDCT(const int* blk, unsigned char *out, int stride) {
         int x0, x1, x2, x3, x4, x5, x6, x7, x8;
-        if (!((x1 = u::sls(blk[8*4], 8))
+        if (!((x1 = sls(blk[8*4], 8))
             | (x2 = blk[8*6]) | (x3 = blk[8*2])
             | (x4 = blk[8*1]) | (x5 = blk[8*7])
             | (x6 = blk[8*5]) | (x7 = blk[8*3])))
@@ -258,7 +260,7 @@ struct jpeg : decoder {
             }
             return;
         }
-        x0 = u::sls(blk[0], 8) + 8192;
+        x0 = sls(blk[0], 8) + 8192;
         x8 = kW7 * (x4 + x5) + 4;
         x4 = (x8 + (kW1 - kW7) * x4) >> 3;
         x5 = (x8 - (kW1 + kW7) * x5) >> 3;
@@ -296,14 +298,14 @@ struct jpeg : decoder {
             return 0;
         while (m_bufbits < bits) {
             if (m_size <= 0) {
-                m_buf = u::sls(m_buf, 8) | 0xFF;
+                m_buf = sls(m_buf, 8) | 0xFF;
                 m_bufbits += 8;
                 continue;
             }
             newbyte = *m_position++;
             m_size--;
             m_bufbits += 8;
-            m_buf = u::sls(m_buf, 8) | newbyte;
+            m_buf = sls(m_buf, 8) | newbyte;
             if (newbyte == 0xFF) {
                 if (m_size) {
                     unsigned char marker = *m_position++;
@@ -318,7 +320,7 @@ struct jpeg : decoder {
                         if ((marker & 0xF8) != 0xD0)
                             m_error = kMalformatted;
                         else {
-                            m_buf = u::sls(m_buf, 8) | marker;
+                            m_buf = sls(m_buf, 8) | marker;
                             m_bufbits += 8;
                         }
                     }
@@ -523,7 +525,7 @@ struct jpeg : decoder {
         if (!(bits = value & 15))
             return 0;
         if ((value = getBits(bits)) < (1 << (bits - 1)))
-            value += u::sls(-1, bits) + 1;
+            value += sls(-1, bits) + 1;
         return value;
     }
 
diff --git a/u_map.h b/u_map.h
index 674e8db..caba4b1 100644
--- a/u_map.h
+++ b/u_map.h
@@ -35,10 +35,14 @@ class map {
 
     const_iterator find(const K &key) const;
     iterator find(const K &key);
+
     pair<iterator, bool> insert(const pair<K, V> &p);
+    pair<iterator, bool> insert(pair<K, V> &&p);
+
     void erase(const_iterator where);
 
     V &operator[](const K &key);
+    V &operator[](K &&key);
 
     void swap(map &other);
 
@@ -147,8 +151,13 @@ inline typename map<K, V>::const_iterator map<K, V>::find(const K &key) const {
 
 template <typename K, typename V>
 inline pair<typename map<K, V>::iterator, bool> map<K, V>::insert(const pair<K, V> &p) {
-    auto result = make_pair(find(p.first()), false);
-    if (result.first().node != 0)
+    return insert(u::move(pair<K, V>(p)));
+}
+
+template <typename K, typename V>
+inline pair<typename map<K, V>::iterator, bool> map<K, V>::insert(pair<K, V> &&p) {
+    auto result = make_pair(find(p.first), false);
+    if (result.first.node != 0)
         return result;
 
     size_t nbuckets = (m_base.buckets.last - m_base.buckets.first);
@@ -158,29 +167,34 @@ inline pair<typename map<K, V>::iterator, bool> map<K, V>::insert(const pair<K,
         nbuckets = (m_base.buckets.last - m_base.buckets.first);
     }
 
-    size_t hh = hash(p.first()) & (nbuckets - 2);
-    typename map<K, V>::iterator &it = result.first();
+    const size_t hh = hash(p.first) & (nbuckets - 2);
+    typename map<K, V>::iterator &it = result.first;
     it.node = detail::hash_insert_new(m_base, hh);
 
     it.node->first.~hash_elem<K, V>();
-    new (&it.node->first) hash_elem<K, V>(p.first(), p.second());
+    new (&it.node->first) hash_elem<K, V>(u::move(p.first), u::move(p.second));
 
-    result.second() = true;
-    return result;
+    result.second = true;
+    return u::move(result);
 }
 
 template <typename K, typename V>
-void map<K, V>::erase(const_iterator where) {
+inline void map<K, V>::erase(const_iterator where) {
     detail::hash_erase(m_base, where.node);
 }
 
 template <typename K, typename V>
-V &map<K, V>::operator[](const K &key) {
-    return insert(make_pair(key, V())).first()->second;
+inline V &map<K, V>::operator[](const K &key) {
+    return insert(u::move(make_pair(key, V()))).first->second;
+}
+
+template <typename K, typename V>
+inline V &map<K, V>::operator[](K &&key) {
+    return insert(u::move(make_pair(u::forward<K>(key), V()))).first->second;
 }
 
 template <typename K, typename V>
-void map<K, V>::swap(map &other) {
+inline void map<K, V>::swap(map &other) {
     detail::hash_swap(m_base, other.m_base);
 }
 
diff --git a/u_misc.h b/u_misc.h
index ec23bc2..588a9a2 100644
--- a/u_misc.h
+++ b/u_misc.h
@@ -116,13 +116,6 @@ inline void print(const char *fmt, const Ts&... ts) {
     fflush(stdout);
 }
 
-template <typename T>
-inline typename enable_if<is_integral<T>::value && is_signed<T>::value,
-                          typename make_signed<T>::type>::type
-sls(T x, T n) {
-    return (typename make_signed<T>::type)((typename make_unsigned<T>::type)x << n);
-}
-
 void *moveMemory(void *dest, const void *src, size_t n);
 
 // Random number generation facilities
diff --git a/u_pair.h b/u_pair.h
index 0142305..2bbec99 100644
--- a/u_pair.h
+++ b/u_pair.h
@@ -4,367 +4,78 @@
 
 namespace u {
 
-namespace detail {
-    enum class pair_type {
-        none, first, second, both
-    };
-
-    template <bool isSame, bool firstEmpty, bool secondEmpty>
-    struct choose_pair;
-    template <bool isSame>
-    struct choose_pair<isSame, false, false> : integral_constant<pair_type, pair_type::none> {};
-    template <bool isSame>
-    struct choose_pair<isSame, true, false> : integral_constant<pair_type, pair_type::first> {};
-    template <bool isSame>
-    struct choose_pair<isSame, false, true> : integral_constant<pair_type, pair_type::second> {};
-    template <>
-    struct choose_pair<false, true, true> : integral_constant<pair_type, pair_type::both> {};
-    template <>
-    struct choose_pair<true, true, true> : integral_constant<pair_type, pair_type::first> {};
-
-    template <typename T1, typename T2>
-    using choose_compress = choose_pair<
-        is_same<typename remove_cv<T1>::type,
-                typename remove_cv<T2>::type>::value,
-        is_empty<T1>::value,
-        is_empty<T2>::value
-    >;
-
-    template <typename T1, typename T2, pair_type = choose_compress<T1, T2>::value>
-    struct compressed_pair;
-
-    ///! NONE
-    template <typename T1, typename T2>
-    struct compressed_pair<T1, T2, pair_type::none> {
-        using first_type = T1;
-        using second_type = T2;
-        using first_reference = typename remove_reference<T1>::type &;
-        using second_reference = typename remove_reference<T2>::type &;
-        using first_const_reference = typename remove_reference<T1>::type const &;
-        using second_const_reference = typename remove_reference<T2>::type const &;
-
-        constexpr compressed_pair();
-        constexpr compressed_pair(T1 f, T2 s);
-
-        first_reference first();
-        constexpr first_const_reference first() const;
-        second_reference second();
-        constexpr second_const_reference second() const;
-
-        void swap(compressed_pair &other);
-
-    private:
-        T1 m_first;
-        T2 m_second;
-    };
-
-    template <typename T1, typename T2>
-    inline constexpr compressed_pair<T1, T2, pair_type::none>::compressed_pair()
-        : m_first()
-        , m_second()
-    {
-    }
-
-    template <typename T1, typename T2>
-    inline constexpr compressed_pair<T1, T2, pair_type::none>::compressed_pair(T1 f, T2 s)
-        : m_first(f)
-        , m_second(s)
-    {
-    }
-
-    template <typename T1, typename T2>
-    inline typename compressed_pair<T1, T2, pair_type::none>::first_reference
-    compressed_pair<T1, T2, pair_type::none>::first() {
-        return m_first;
-    }
-
-    template <typename T1, typename T2>
-    inline constexpr typename compressed_pair<T1, T2, pair_type::none>::first_const_reference
-    compressed_pair<T1, T2, pair_type::none>::first() const {
-        return m_first;
-    }
-
-    template <typename T1, typename T2>
-    inline typename compressed_pair<T1, T2, pair_type::none>::second_reference
-    compressed_pair<T1, T2, pair_type::none>::second() {
-        return m_second;
-    }
-
-    template <typename T1, typename T2>
-    inline constexpr typename compressed_pair<T1, T2, pair_type::none>::second_const_reference
-    compressed_pair<T1, T2, pair_type::none>::second() const {
-        return m_second;
-    }
-
-    template <typename T1, typename T2>
-    inline void compressed_pair<T1, T2, pair_type::none>::swap(compressed_pair &other) {
-        swap(m_first, other.m_first);
-        swap(m_second, other.m_second);
-    }
-
-    ///! FIRST
-    template <typename T1, typename T2>
-    struct compressed_pair<T1, T2, pair_type::first> : private T1 {
-        using first_type = T1;
-        using second_type = T2;
-        using first_reference = T1 &;
-        using second_reference = typename remove_reference<T2>::type &;
-        using first_const_reference = T1 const &;
-        using second_const_reference = typename remove_reference<T2>::type const &;
-
-        constexpr compressed_pair();
-        constexpr compressed_pair(T1 f, T2 s);
-
-        first_reference first();
-        constexpr first_const_reference first() const;
-        second_reference second();
-        constexpr second_const_reference second() const;
-
-        void swap(compressed_pair &other);
-
-    private:
-        T2 m_second;
-    };
-
-    template <typename T1, typename T2>
-    inline constexpr compressed_pair<T1, T2, pair_type::first>::compressed_pair()
-        : T1()
-        , m_second()
-    {
-    }
-
-    template <typename T1, typename T2>
-    inline constexpr compressed_pair<T1, T2, pair_type::first>::compressed_pair(T1 f, T2 s)
-        : T1(forward<T1>(f))
-        , m_second(forward<T2>(s))
-    {
-    }
-
-    template <typename T1, typename T2>
-    inline typename compressed_pair<T1, T2, pair_type::first>::first_reference
-    compressed_pair<T1, T2, pair_type::first>::first() {
-        return *this;
-    }
-
-    template <typename T1, typename T2>
-    inline constexpr typename compressed_pair<T1, T2, pair_type::first>::first_const_reference
-    compressed_pair<T1, T2, pair_type::first>::first() const {
-        return *this;
-    }
-
-    template <typename T1, typename T2>
-    inline typename compressed_pair<T1, T2, pair_type::first>::second_reference
-    compressed_pair<T1, T2, pair_type::first>::second() {
-        return m_second;
-    }
-
-    template <typename T1, typename T2>
-    inline constexpr typename compressed_pair<T1, T2, pair_type::first>::second_const_reference
-    compressed_pair<T1, T2, pair_type::first>::second() const {
-        return m_second;
-    }
-
-    template <typename T1, typename T2>
-    inline void compressed_pair<T1, T2, pair_type::first>::swap(compressed_pair &other) {
-        swap(m_second, other.m_second);
-    }
-
-    ///! SECOND
-    template <typename T1, typename T2>
-    struct compressed_pair<T1, T2, pair_type::second> : private T2 {
-        using first_type = T1;
-        using second_type = T2;
-        using first_reference = typename remove_reference<T1>::type &;
-        using second_reference = T2 &;
-        using first_const_reference = typename remove_reference<T2>::type const &;
-        using second_const_reference = T2 const &;
-
-        constexpr compressed_pair();
-        constexpr compressed_pair(T1 f, T2 s);
-
-        first_reference first();
-        constexpr first_const_reference first() const;
-        second_reference second();
-        constexpr second_const_reference second() const;
-
-        void swap(compressed_pair &);
-
-    private:
-        T1 m_first;
-    };
-
-    template <typename T1, typename T2>
-    inline constexpr compressed_pair<T1, T2, pair_type::second>::compressed_pair()
-        : T2()
-        , m_first()
-    {
-    }
-
-    template <typename T1, typename T2>
-    inline constexpr compressed_pair<T1, T2, pair_type::second>::compressed_pair(T1 f, T2 s)
-        : T2(forward<T2>(s))
-        , m_first(forward<T1>(f))
-    {
-    }
-
-    template <typename T1, typename T2>
-    inline typename compressed_pair<T1, T2, pair_type::second>::first_reference
-    compressed_pair<T1, T2, pair_type::second>::first() {
-        return m_first;
-    }
-
-    template <typename T1, typename T2>
-    inline constexpr typename compressed_pair<T1, T2, pair_type::second>::first_const_reference
-    compressed_pair<T1, T2, pair_type::second>::first() const {
-        return m_first;
-    }
-
-    template <typename T1, typename T2>
-    inline typename compressed_pair<T1, T2, pair_type::second>::second_reference
-    compressed_pair<T1, T2, pair_type::second>::second() {
-        return *this;
-    }
-
-    template <typename T1, typename T2>
-    inline constexpr typename compressed_pair<T1, T2, pair_type::second>::second_const_reference
-    compressed_pair<T1, T2, pair_type::second>::second() const {
-        return *this;
-    }
-
-    template <typename T1, typename T2>
-    inline void compressed_pair<T1, T2, pair_type::second>::swap(compressed_pair &other) {
-        swap(m_first, other.m_first);
-    }
-
-    ///! BOTH
-    template <typename T1, typename T2>
-    struct compressed_pair<T1, T2, pair_type::both> : private T1, T2 {
-        using first_type = T1;
-        using second_type = T2;
-        using first_reference = T1 &;
-        using second_reference = T2 &;
-        using first_const_reference = T1 const &;
-        using second_const_reference = T2 const &;
-
-        constexpr compressed_pair();
-        constexpr compressed_pair(T1 f, T2 s);
-
-        first_reference first();
-        constexpr first_const_reference first() const;
-        second_reference second();
-        constexpr second_const_reference second() const;
-
-        void swap(compressed_pair &);
-    };
-
-    template <typename T1, typename T2>
-    inline constexpr compressed_pair<T1, T2, pair_type::both>::compressed_pair()
-        : T1()
-        , T2()
-    {
-    }
-
-    template <typename T1, typename T2>
-    inline constexpr compressed_pair<T1, T2, pair_type::both>::compressed_pair(T1 f, T2 s)
-        : T1(forward<T1>(f))
-        , T2(forward<T2>(s))
-    {
-    }
-
-    template <typename T1, typename T2>
-    inline typename compressed_pair<T1, T2, pair_type::both>::first_reference
-    compressed_pair<T1, T2, pair_type::both>::first() {
-        return *this;
-    }
-
-    template <typename T1, typename T2>
-    inline constexpr typename compressed_pair<T1, T2, pair_type::both>::first_const_reference
-    compressed_pair<T1, T2, pair_type::both>::first() const {
-        return *this;
-    }
-
-    template <typename T1, typename T2>
-    inline typename compressed_pair<T1, T2, pair_type::both>::second_reference
-    compressed_pair<T1, T2, pair_type::both>::second() {
-        return *this;
-    }
-
-    template <typename T1, typename T2>
-    inline constexpr typename compressed_pair<T1, T2, pair_type::both>::second_const_reference
-    compressed_pair<T1, T2, pair_type::both>::second() const {
-        return *this;
-    }
-
-    template <typename T1, typename T2>
-    inline void compressed_pair<T1, T2, pair_type::both>::swap(compressed_pair &) {
-        // Cannot swap
-    }
-}
-
 template <typename T1, typename T2>
-struct pair : private detail::compressed_pair<T1, T2> {
-private:
-    using base = detail::compressed_pair<T1, T2>;
-public:
-    using first_type = typename base::first_type;
-    using second_type = typename base::second_type;
-    using first_reference = typename base::first_reference;
-    using second_reference = typename base::second_reference;
-    using first_const_reference = typename base::first_const_reference;
-    using second_const_reference = typename base::second_const_reference;
+struct pair {
+    typedef T1 first_type;
+    typedef T2 second_type;
+
+    T1 first;
+    T2 second;
 
     constexpr pair();
-    constexpr pair(T1 f, T2 s);
+    constexpr pair(const T1 &x, const T2 &y);
 
-    first_reference first();
-    constexpr first_const_reference first() const;
-    second_reference second();
-    constexpr second_const_reference second() const;
+    pair(const pair &p) = default;
+    pair(pair &&p) = default;
 
-    void swap(pair &other);
+    pair &operator=(const pair &p);
+    pair &operator=(pair &&p);
 };
 
 template <typename T1, typename T2>
 inline constexpr pair<T1, T2>::pair()
-    : base()
+    : first()
+    , second()
 {
 }
 
 template <typename T1, typename T2>
-inline constexpr pair<T1, T2>::pair(T1 f, T2 s)
-    : base(forward<T1>(f), forward<T2>(s))
+inline constexpr pair<T1, T2>::pair(const T1 &x, const T2 &y)
+    : first(x)
+    , second(y)
 {
 }
 
 template <typename T1, typename T2>
-inline typename pair<T1, T2>::first_reference pair<T1, T2>::first() {
-    return base::first();
+inline pair<T1, T2> &pair<T1, T2>::operator=(const pair &p) {
+    first = p.first;
+    second = p.second;
+    return *this;
 }
 
 template <typename T1, typename T2>
-inline constexpr typename pair<T1, T2>::first_const_reference pair<T1, T2>::first() const {
-    return base::first();
+inline pair<T1, T2> &pair<T1, T2>::operator=(pair &&p) {
+    first = u::forward<first_type>(p.first);
+    second = u::forward<second_type>(p.second);
+    return *this;
 }
 
-template <typename T1, typename T2>
-inline typename pair<T1, T2>::second_reference pair<T1, T2>::second() {
-    return base::second();
-}
+namespace detail {
+    template <typename T>
+    struct reference_wrapper;
 
-template <typename T1, typename T2>
-inline constexpr typename pair<T1, T2>::second_const_reference pair<T1, T2>::second() const {
-    return base::second();
-}
+    template <typename T>
+    struct make_pair_type {
+        typedef T type;
+    };
+    template <typename T>
+    struct make_pair_type<reference_wrapper<T>> {
+        typedef T &type;
+    };
 
-template <typename T1, typename T2>
-inline void pair<T1, T2>::swap(pair &other) {
-    base::swap(other);
+    template <typename T>
+    struct make_pair_return {
+        typedef typename make_pair_type<typename u::decay<T>::type>::type type;
+    };
 }
 
 template <typename T1, typename T2>
-inline pair<typename decay<T1>::type, typename decay<T2>::type>
-make_pair(T1 &&first, T2 &&second) {
-    return pair<typename decay<T1>::type, typename decay<T2>::type>(forward<T1>(first), forward<T2>(second));
+inline constexpr pair<typename detail::make_pair_return<T1>::type,
+                      typename detail::make_pair_return<T2>::type>
+make_pair(T1 &&t1, T2 &&t2) {
+    return pair<typename detail::make_pair_return<T1>::type,
+                typename detail::make_pair_return<T2>::type>(u::forward<T1>(t1),
+                                                             u::forward<T2>(t2));
 }
 
 }
diff --git a/u_set.h b/u_set.h
index da33079..2fe561f 100644
--- a/u_set.h
+++ b/u_set.h
@@ -28,8 +28,11 @@ struct set {
     bool empty() const;
     size_t size() const;
 
-    iterator find(const K &key) const;
+    const_iterator find(const K &key) const;
+    iterator find(const K &key);
+
     pair<iterator, bool> insert(const K &key);
+    pair<iterator, bool> insert(K &&key);
     void erase(iterator where);
     size_t erase(const K &key);
 
@@ -110,7 +113,14 @@ inline void set<K>::clear() {
 }
 
 template <typename K>
-inline typename set<K>::iterator set<K>::find(const K &key) const {
+typename set<K>::const_iterator set<K>::find(const K &key) const {
+    iterator result;
+    result.node = detail::hash_find(m_base, key);
+    return result;
+}
+
+template <typename K>
+typename set<K>::iterator set<K>::find(const K &key) {
     iterator result;
     result.node = detail::hash_find(m_base, key);
     return result;
@@ -118,8 +128,13 @@ inline typename set<K>::iterator set<K>::find(const K &key) const {
 
 template <typename K>
 inline pair<typename set<K>::iterator, bool> set<K>::insert(const K &key) {
+    return insert(u::move(K(key)));
+}
+
+template <typename K>
+inline pair<typename set<K>::iterator, bool> set<K>::insert(K &&key) {
     auto result = make_pair(find(key), false);
-    if (result.first().node != 0)
+    if (result.first.node != 0)
         return result;
 
     size_t nbuckets = (m_base.buckets.last - m_base.buckets.first);
@@ -129,15 +144,15 @@ inline pair<typename set<K>::iterator, bool> set<K>::insert(const K &key) {
         nbuckets = (m_base.buckets.last - m_base.buckets.first);
     }
 
-    size_t hh = hash(key) & (nbuckets - 2);
-    typename set<K>::iterator &it = result.first();
+    const size_t hh = hash(key) & (nbuckets - 2);
+    typename set<K>::iterator &it = result.first;
     it.node = detail::hash_insert_new(m_base, hh);
 
     it.node->first.~hash_elem<K, void>();
-    new ((void *)&it.node->first) hash_elem<K, void>(key);
+    new ((void *)&it.node->first) hash_elem<K, void>(u::move(key));
 
-    result.second() = true;
-    return result;
+    result.second = true;
+    return u::move(result);
 }
 
 template <typename K>
diff --git a/u_traits.h b/u_traits.h
index 7f839ce..cb743a9 100644
--- a/u_traits.h
+++ b/u_traits.h
@@ -475,190 +475,6 @@ inline constexpr T &&forward(typename remove_reference<T>::type &&t) noexcept {
     return static_cast<T&&>(t);
 }
 
-namespace detail {
-    template <typename H, typename T>
-    struct types {
-        typedef H head;
-        typedef T tail;
-    };
-
-    // nat: not a type
-    struct nat {
-        nat() = delete;
-        nat(const nat&) = delete;
-        nat &operator=(const nat&) = delete;
-        ~nat() = delete;
-    };
-
-    typedef types<signed char,
-            types<signed short,
-            types<signed int,
-            types<signed long,
-            types<signed long long, nat>>>>> signed_types;
-
-    typedef types<unsigned char,
-            types<unsigned short,
-            types<unsigned int,
-            types<unsigned long,
-            types<unsigned long long, nat>>>>> unsigned_types;
-
-    // Given a type list recursively instantiate until we find the given type
-    template <typename L, size_t S, bool = S <= sizeof(typename L::head)>
-    struct find_first_type;
-    template <typename H, typename T, size_t S>
-    struct find_first_type<types<H, T>, S, true> {
-        typedef H type;
-    };
-    template <typename H, typename T, size_t S>
-    struct find_first_type<types<H, T>, S, false> {
-        typedef typename find_first_type<T, S>::type type;
-    };
-
-    // For make_signed, make_unsigned we need to also apply the right cv
-    template <typename T, typename U, bool = is_const<typename remove_reference<T>::type>::value,
-                                      bool = is_volatile<typename remove_reference<T>::type>::value>
-    struct apply_cv {
-        typedef U type;
-    };
-    template <typename T, typename U>
-    struct apply_cv<T, U, true, false> { // is_const
-        typedef const U type;
-    };
-    template <typename T, typename U>
-    struct apply_cv<T, U, false, true> { // is_volatile
-        typedef volatile U type;
-    };
-    template <typename T, typename U>
-    struct apply_cv<T, U, true, true> { // is_const && is_volatile
-        typedef const volatile U type;
-    };
-    template <typename T, typename U>
-    struct apply_cv<T&, U, true, false> { // T& is_const
-        typedef const U& type;
-    };
-    template <typename T, typename U>
-    struct apply_cv<T&, U, false, true> { // T& is_volatile
-        typedef volatile U& type;
-    };
-    template <typename T, typename U>
-    struct apply_cv<T&, U, true, true> { // T& is_const && T& is_volatile
-        typedef const volatile U& type;
-    };
-
-    template <typename T, bool = is_integral<T>::value || is_enum<T>::value>
-    struct make_signed {};
-    template <typename T, bool = is_integral<T>::value || is_enum<T>::value>
-    struct make_unsigned {};
-    template <typename T>
-    struct make_signed<T, true> {
-        typedef typename find_first_type<signed_types, sizeof(T)>::type type;
-    };
-    template <typename T>
-    struct make_unsigned<T, true> {
-        typedef typename find_first_type<unsigned_types, sizeof(T)>::type type;
-    };
-
-    template <>
-    struct make_signed<bool, true> {};
-    template <>
-    struct make_signed<signed short, true> {
-        typedef short type;
-    };
-    template <>
-    struct make_signed<unsigned short, true> {
-        typedef short type;
-    };
-    template <>
-    struct make_signed<signed int, true> {
-        typedef int type;
-    };
-    template <>
-    struct make_signed<unsigned int, true> {
-        typedef int type;
-    };
-    template <>
-    struct make_signed<signed long, true> {
-        typedef long type;
-    };
-    template <>
-    struct make_signed<unsigned long, true> {
-        typedef long type;
-    };
-    template <>
-    struct make_signed<signed long long, true> {
-        typedef long long type;
-    };
-    template <>
-    struct make_signed<unsigned long long, true> {
-        typedef long long type;
-    };
-
-    template <>
-    struct make_unsigned<bool, true> {};
-    template <>
-    struct make_unsigned<signed short, true> {
-        typedef unsigned short type;
-    };
-    template <>
-    struct make_unsigned<unsigned short, true> {
-        typedef unsigned short type;
-    };
-    template <>
-    struct make_unsigned<signed int, true> {
-        typedef unsigned int type;
-    };
-    template <>
-    struct make_unsigned<unsigned int, true> {
-        typedef unsigned int type;
-    };
-    template <>
-    struct make_unsigned<signed long,true> {
-        typedef unsigned long type;
-    };
-    template <>
-    struct make_unsigned<unsigned long,true> {
-        typedef unsigned long type;
-    };
-    template <>
-    struct make_unsigned<signed long long, true> {
-        typedef unsigned long long type;
-    };
-    template <>
-    struct make_unsigned<unsigned long long, true> {
-        typedef unsigned long long type;
-    };
-}
-
-/// make_signed
-template <typename T>
-struct make_signed {
-    typedef typename detail::apply_cv<T, typename detail::make_signed<
-        typename remove_cv<T>::type>::type>::type type;
-};
-
-/// make_unsigned
-template <typename T>
-struct make_unsigned {
-    typedef typename detail::apply_cv<T, typename detail::make_unsigned<
-        typename remove_cv<T>::type>::type>::type type;
-};
-
-namespace detail {
-    template <typename T, bool = is_integral<T>::value>
-    struct is_signed_switch : integral_constant<bool, T(-1) < T(0)> {};
-    template <typename T>
-    struct is_signed_switch<T, false> : true_type {}; // floating point
-
-    template <typename T, bool = is_arithmetic<T>::value>
-    struct is_signed : is_signed_switch<T> {};
-    template <typename T>
-    struct is_signed<T, false> : false_type {};
-}
-
-/// is_signed
-template <typename T>
-struct is_signed : detail::is_signed<T> {};
-
 /// add_pointer
 template <typename T>
 struct add_pointer {