diff --git a/sdk/include/loki/HierarchyGenerators.h b/sdk/include/loki/HierarchyGenerators.h
index 17108017814..a59753d26ed 100644
--- a/sdk/include/loki/HierarchyGenerators.h
+++ b/sdk/include/loki/HierarchyGenerators.h
@@ -29,9 +29,302 @@
 #define HIERARCHYGENERATORS_INC_
 
 #include "Typelist.h"
+#include "TypeManip.h"
+#include "EmptyType.h"
 
 namespace Loki
 {
+////////////////////////////////////////////////////////////////////////////////
+// class template GenScatterHierarchy
+// Generates a scattered hierarchy starting from a typelist and a template
+// Invocation (TList is a typelist, Model is a template of one arg):
+// GenScatterHierarchy<TList, Model>
+// The generated class inherits all classes generated by instantiating the 
+// template 'Model' with the types contained in TList 
+////////////////////////////////////////////////////////////////////////////////
+
+
+    template <typename T, template <typename> class Unit>
+    class GenScatterHierarchy;
+
+    namespace Private
+    {
+    // for some reason VC7 needs the base definition altough not in use
+    template <typename TListTag> 
+    struct GenScatterHierarchyHelper1
+    {
+        template <typename T, template <typename> class Unit>
+        struct In 
+        { 
+            typedef typename T::ERROR_THIS_INSTANCE_SELECTED Result; 
+        };
+    };
+
+    template <typename TListTag> 
+    struct GenScatterHierarchyHelper2
+    {
+        template <typename T, template <typename> class Unit>
+        struct In 
+        { 
+            typedef typename T::ERROR_THIS_INSTANCE_SELECTED Result; 
+        };
+    };
+
+    
+    template <> 
+    struct GenScatterHierarchyHelper1<TL::Typelist_tag>
+    {
+        template <class TList, template <typename> class Unit>
+        struct In
+        {
+            typedef GenScatterHierarchy<typename TList::Head, Unit> Result;
+        };
+    };
+
+    template <> 
+    struct GenScatterHierarchyHelper2<TL::Typelist_tag>
+    {
+        template <class TList, template <typename> class Unit>
+        struct In
+        {
+            typedef GenScatterHierarchy<typename TList::Tail, Unit> Result;
+        };
+    };
+    
+
+    template <> 
+    struct GenScatterHierarchyHelper1<TL::NoneList_tag>
+    {
+        template <typename AtomicType, template <typename> class Unit>
+        struct In { typedef Unit<AtomicType> Result; };
+    };
+
+    template <> 
+    struct GenScatterHierarchyHelper2<TL::NoneList_tag>
+    {
+        template <typename AtomicType, template <typename> class Unit>
+        struct In { struct Result {}; };        
+    };
+
+
+    template <> 
+    struct GenScatterHierarchyHelper1<TL::NullType_tag>
+    {
+        template <class TList, template <typename> class Unit>
+        struct In { struct Result {}; };        
+    };
+
+    template <> 
+    struct GenScatterHierarchyHelper2<TL::NullType_tag>
+    {
+        template <class TList, template <typename> class Unit>
+        struct In { struct Result {}; };        
+    };
+
+    } // namespace Private
+
+    template <typename T, template <typename> class Unit>
+    class GenScatterHierarchy
+        : public Private::GenScatterHierarchyHelper1
+          <
+            typename TL::is_Typelist<T>::type_tag
+          >
+          ::template In<T, Unit>::Result
+
+        , public Private::GenScatterHierarchyHelper2
+          <
+            typename TL::is_Typelist<T>::type_tag
+          >
+          ::template In<T, Unit>::Result
+    {
+    public:
+
+        typedef typename Private::GenScatterHierarchyHelper1
+        <
+            typename TL::is_Typelist<T>::type_tag
+        >
+        ::template In<T, Unit>::Result LeftBase;
+
+        typedef typename Private::GenScatterHierarchyHelper2
+        <
+            typename TL::is_Typelist<T>::type_tag
+        >
+        ::template In<T, Unit>::Result RightBase;
+    
+    
+        typedef typename Select
+        <
+            TL::is_Typelist<T>::value, T, void
+        >
+        ::Result TList;
+
+        template <typename U> struct Rebind
+        {
+            typedef Unit<U> Result;
+        };
+    };
+
+     
+////////////////////////////////////////////////////////////////////////////////
+// function template Field
+// Accesses a field in an object of a type generated with GenScatterHierarchy
+// Invocation (obj is an object of a type H generated with GenScatterHierarchy,
+//     T is a type in the typelist used to generate H):
+// Field<T>(obj)
+// returns a reference to Unit<T>, where Unit is the template used to generate H 
+////////////////////////////////////////////////////////////////////////////////
+
+    template <class T, class H>
+    typename H::template Rebind<T>::Result &
+    Field(H& obj)
+    {
+        return obj;
+    }
+     
+    template <class T, class H>
+    typename H::template Rebind<T>::Result const &
+    Field(H const & obj)
+    {
+        return obj;
+    }
+
+////////////////////////////////////////////////////////////////////////////////
+// function template TupleUnit
+// The building block of tuples 
+////////////////////////////////////////////////////////////////////////////////
+
+    template <class T>
+    struct TupleUnit
+    {
+        T value_;
+        operator T&() { return value_; }
+        operator const T&() const { return value_; }
+    };
+
+////////////////////////////////////////////////////////////////////////////////
+// class template Tuple
+// Implements a tuple class that holds a number of values and provides field 
+//     access to them via the Field function (below) 
+////////////////////////////////////////////////////////////////////////////////
+
+    template <class TList>
+    struct Tuple : public GenScatterHierarchy<TList, TupleUnit>
+    {
+    };
+
+
+////////////////////////////////////////////////////////////////////////////////
+// helper class template FieldHelper
+// See Field below
+////////////////////////////////////////////////////////////////////////////////
+    
+    template <unsigned int i>
+    struct FieldHelper
+    {            
+        template<class H>
+        struct In
+        {
+        private:
+            typedef typename TL::TypeAt<typename H::TList, i>::Result ElementType;
+            typedef typename H::template Rebind<ElementType>::Result UnitType;
+            
+            static constexpr bool isConst = std::is_const_v<H>;
+
+            typedef typename Select
+            <
+                isConst,
+                const typename H::RightBase,
+                typename H::RightBase
+            > 
+            ::Result RightBase;
+
+            typedef typename Select
+            <
+                IsSameType<UnitType, TupleUnit<ElementType> >::value, 
+                ElementType, 
+                UnitType
+            >
+            ::Result UnqualifiedResultType;
+
+        public:
+            typedef typename Select
+            <
+                isConst,
+                const UnqualifiedResultType,
+                UnqualifiedResultType
+            >
+            ::Result ResultType;
+            
+            static ResultType& Do(H& obj)
+            {
+                RightBase& rightBase = obj;
+                return FieldHelper<i - 1>::template In<RightBase>::Do(rightBase);
+            }
+        };
+    };
+
+    template <>
+    struct FieldHelper<0>
+    {            
+        template<class H>
+        struct In
+        {
+        private:
+            typedef typename H::TList::Head ElementType;
+            typedef typename H::template Rebind<ElementType>::Result UnitType;
+            
+            static constexpr bool isConst = std::is_const_v<H>;
+
+            typedef typename Select
+            <
+                isConst,
+                const typename H::LeftBase,
+                typename H::LeftBase
+            > 
+            ::Result LeftBase;
+
+            typedef typename Select
+            <
+                IsSameType<UnitType, TupleUnit<ElementType> >::value, 
+                ElementType, 
+                UnitType
+            >
+            ::Result UnqualifiedResultType;
+
+        public:
+            typedef typename Select
+            <
+                isConst,
+                const UnqualifiedResultType,
+                UnqualifiedResultType
+            >
+            ::Result ResultType;
+            
+            static ResultType& Do(H& obj)
+            {
+                LeftBase& leftBase = obj;
+                return leftBase;
+            }
+        };
+    };
+
+////////////////////////////////////////////////////////////////////////////////
+// function template Field
+// Accesses a field in an object of a type generated with GenScatterHierarchy
+// Invocation (obj is an object of a type H generated with GenScatterHierarchy,
+//     i is the index of a type in the typelist used to generate H):
+// Field<i>(obj)
+// returns a reference to Unit<T>, where Unit is the template used to generate H
+//     and T is the i-th type in the typelist 
+////////////////////////////////////////////////////////////////////////////////
+
+    template <unsigned int i, class H>
+    typename FieldHelper<i>::template In<H>::ResultType&
+    Field(H& obj)
+    {
+        return FieldHelper<i>::template In<H>::Do(obj);
+    }
+                
 ////////////////////////////////////////////////////////////////////////////////
 // class template GenLinearHierarchy
 // Generates a linear hierarchy starting from a typelist and a template
@@ -39,18 +332,80 @@ namespace Loki
 // GenLinearHierarchy<TList, Model, Root>
 ////////////////////////////////////////////////////////////////////////////////
     
-    template <typename, template <typename, typename> typename, typename Root = EmptyType>
-    struct GenLinearHierarchy;
+    template
+    <
+        class TList,
+        template <class AtomicType, class UnitBase> class Unit,
+        class Root = EmptyType
+    >
+    class GenLinearHierarchy;
+
+    namespace Private
+    {
+    
+    template <typename TListTag> 
+    struct GenLinearHierarchyHelper
+    {
+        template<class TList, template <class, class> class Unit, class Root>
+        struct In 
+        {
+            typedef typename TList::ERROR_THIS_INSTANCE_SELECTED Result; 
+        };
+    };
+    
+    template <> 
+    struct GenLinearHierarchyHelper<TL::Typelist_tag>
+    {
+        template<class TList, template <class, class> class Unit, class Root>
+        struct In 
+        {
+        private:
+            typedef typename TList::Head Head;
+            typedef typename TList::Tail Tail;
 
-    template <typename T, template <typename, typename> typename Unit, typename Root>
-    struct GenLinearHierarchy<Typelist<T>, Unit, Root>
-        : Unit<T, Root>
-    { };
+        public:
+            typedef Unit< Head, GenLinearHierarchy<Tail, Unit, Root> > Result; 
+        };
+    };
 
-    template <typename T, typename... Ts, template <typename, typename> typename Unit, typename Root>
-    struct GenLinearHierarchy<Typelist<T, Ts...>, Unit, Root>
-        : Unit<T, GenLinearHierarchy<Typelist<Ts...>, Unit, Root>>
-    { };
+    template <> 
+    struct GenLinearHierarchyHelper<TL::NullType_tag>
+    {
+        template<class TList, template <class, class> class Unit, class Root>
+        struct In
+        {
+        private:
+            typedef typename TList::Head Head;
+
+        public:
+            typedef Unit<Head, Root> Result;
+        };
+    };
+
+    } // namespace Private
+
+    template
+    <
+        class TList,
+        template <class AtomicType, class UnitBase> class Unit,
+        class Root
+    >
+    class GenLinearHierarchy
+        : public Private::GenLinearHierarchyHelper
+          <
+            typename TL::is_Typelist<typename TList::Tail>::type_tag
+          >
+          ::template In<TList, Unit, Root>::Result
+    {
+        ASSERT_TYPELIST(TList); // TList must not be NullType
+
+    public:
+        typedef typename Private::GenLinearHierarchyHelper
+        <
+            typename TL::is_Typelist<typename TList::Tail>::type_tag
+        >
+        ::template In<TList, Unit, Root>::Result LinBase;
+    };
 
 }   // namespace Loki
 
@@ -62,3 +417,7 @@ namespace Loki
 
 #endif // HIERARCHYGENERATORS_INC_
 
+#ifdef _MSC_VER
+#pragma warning( pop )
+#endif // _MSC_VER
+
diff --git a/sdk/include/loki/TypeManip.h b/sdk/include/loki/TypeManip.h
index 33a4b6fcaca..dc175fa6843 100644
--- a/sdk/include/loki/TypeManip.h
+++ b/sdk/include/loki/TypeManip.h
@@ -60,17 +60,7 @@ namespace Loki
     template <bool flag, typename T, typename U>
     struct Select
     {
-    private:
-        template<bool>
-        struct In 
-        { typedef T Result; };
-
-        template<>
-        struct In<false>
-        { typedef U Result; };
-
-    public:
-        typedef typename In<flag>::Result Result;
+        using Result = std::conditional_t<flag, T, U>;
     };
     
 
@@ -84,20 +74,8 @@ namespace Loki
 ////////////////////////////////////////////////////////////////////////////////
 
     template <typename T, typename U>
-    struct IsSameType
-    {
-    private:
-        template<typename>
-        struct In 
-        { enum { value = false }; };
-
-        template<>
-        struct In<T>
-        { enum { value = true };  };
-
-    public:
-        enum { value = In<U>::value };
-    };
+    struct IsSameType : std::is_same<T, U>
+    {};
     
 ////////////////////////////////////////////////////////////////////////////////
 // Helper types Small and Big - guarantee that sizeof(Small) < sizeof(Big)
diff --git a/sdk/include/loki/Typelist.h b/sdk/include/loki/Typelist.h
index 04de2072891..7f2e3a7a0a0 100644
--- a/sdk/include/loki/Typelist.h
+++ b/sdk/include/loki/Typelist.h
@@ -19,8 +19,334 @@
 #ifndef TYPELIST_INC_
 #define TYPELIST_INC_
 
-#include <type_traits>
-#include "EmptyType.h"
+#include "static_check.h"
+#include "NullType.h"
+
+////////////////////////////////////////////////////////////////////////////////
+// macros TYPELIST_1, TYPELIST_2, ... TYPELIST_50
+// Each takes a number of arguments equal to its numeric suffix
+// The arguments are type names. TYPELIST_NN generates a typelist containing 
+//     all types passed as arguments, in that order.
+// Example: TYPELIST_2(char, int) generates a type containing char and int.
+////////////////////////////////////////////////////////////////////////////////
+
+#define TYPELIST_1(T1) ::Loki::Typelist<T1, ::Loki::NullType>
+
+#define TYPELIST_2(T1, T2) ::Loki::Typelist<T1, TYPELIST_1(T2) >
+
+#define TYPELIST_3(T1, T2, T3) ::Loki::Typelist<T1, TYPELIST_2(T2, T3) >
+
+#define TYPELIST_4(T1, T2, T3, T4) \
+    ::Loki::Typelist<T1, TYPELIST_3(T2, T3, T4) >
+
+#define TYPELIST_5(T1, T2, T3, T4, T5) \
+    ::Loki::Typelist<T1, TYPELIST_4(T2, T3, T4, T5) >
+
+#define TYPELIST_6(T1, T2, T3, T4, T5, T6) \
+    ::Loki::Typelist<T1, TYPELIST_5(T2, T3, T4, T5, T6) >
+
+#define TYPELIST_7(T1, T2, T3, T4, T5, T6, T7) \
+    ::Loki::Typelist<T1, TYPELIST_6(T2, T3, T4, T5, T6, T7) >
+
+#define TYPELIST_8(T1, T2, T3, T4, T5, T6, T7, T8) \
+    ::Loki::Typelist<T1, TYPELIST_7(T2, T3, T4, T5, T6, T7, T8) >
+
+#define TYPELIST_9(T1, T2, T3, T4, T5, T6, T7, T8, T9) \
+    ::Loki::Typelist<T1, TYPELIST_8(T2, T3, T4, T5, T6, T7, T8, T9) >
+
+#define TYPELIST_10(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) \
+    ::Loki::Typelist<T1, TYPELIST_9(T2, T3, T4, T5, T6, T7, T8, T9, T10) >
+
+#define TYPELIST_11(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) \
+    ::Loki::Typelist<T1, TYPELIST_10(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) >
+
+#define TYPELIST_12(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) \
+    ::Loki::Typelist<T1, TYPELIST_11(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12) >
+
+#define TYPELIST_13(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) \
+    ::Loki::Typelist<T1, TYPELIST_12(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13) >
+
+#define TYPELIST_14(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14) \
+    ::Loki::Typelist<T1, TYPELIST_13(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14) >
+
+#define TYPELIST_15(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15) \
+    ::Loki::Typelist<T1, TYPELIST_14(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15) >
+
+#define TYPELIST_16(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16) \
+    ::Loki::Typelist<T1, TYPELIST_15(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16) >
+
+#define TYPELIST_17(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17) \
+    ::Loki::Typelist<T1, TYPELIST_16(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17) >
+
+#define TYPELIST_18(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18) \
+    ::Loki::Typelist<T1, TYPELIST_17(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18) >
+
+#define TYPELIST_19(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19) \
+    ::Loki::Typelist<T1, TYPELIST_18(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19) >
+
+#define TYPELIST_20(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) \
+    ::Loki::Typelist<T1, TYPELIST_19(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) >
+
+#define TYPELIST_21(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) \
+    ::Loki::Typelist<T1, TYPELIST_20(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) >
+
+#define TYPELIST_22(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) \
+    ::Loki::Typelist<T1, TYPELIST_21(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) >
+
+#define TYPELIST_23(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) \
+    ::Loki::Typelist<T1, TYPELIST_22(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) >
+
+#define TYPELIST_24(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) \
+    ::Loki::Typelist<T1, TYPELIST_23(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) >
+
+#define TYPELIST_25(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25) \
+    ::Loki::Typelist<T1, TYPELIST_24(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25) >
+
+#define TYPELIST_26(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26) \
+    ::Loki::Typelist<T1, TYPELIST_25(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26) >
+
+#define TYPELIST_27(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27) \
+    ::Loki::Typelist<T1, TYPELIST_26(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27) >
+
+#define TYPELIST_28(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28) \
+    ::Loki::Typelist<T1, TYPELIST_27(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28) >
+
+#define TYPELIST_29(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29) \
+    ::Loki::Typelist<T1, TYPELIST_28(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29) >
+
+#define TYPELIST_30(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30) \
+    ::Loki::Typelist<T1, TYPELIST_29(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30) >
+
+#define TYPELIST_31(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31) \
+    ::Loki::Typelist<T1, TYPELIST_30(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31) >
+
+#define TYPELIST_32(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32) \
+    ::Loki::Typelist<T1, TYPELIST_31(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32) >
+
+#define TYPELIST_33(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33) \
+    ::Loki::Typelist<T1, TYPELIST_32(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33) >
+
+#define TYPELIST_34(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34) \
+    ::Loki::Typelist<T1, TYPELIST_33(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34) >
+
+#define TYPELIST_35(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35) \
+    ::Loki::Typelist<T1, TYPELIST_34(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35) >
+
+#define TYPELIST_36(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36) \
+    ::Loki::Typelist<T1, TYPELIST_35(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36) >
+
+#define TYPELIST_37(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36, T37) \
+    ::Loki::Typelist<T1, TYPELIST_36(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36, T37) >
+
+#define TYPELIST_38(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36, T37, T38) \
+    ::Loki::Typelist<T1, TYPELIST_37(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36, T37, T38) >
+
+#define TYPELIST_39(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36, T37, T38, T39) \
+    ::Loki::Typelist<T1, TYPELIST_38(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36, T37, T38, T39) >
+
+#define TYPELIST_40(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36, T37, T38, T39, T40) \
+    ::Loki::Typelist<T1, TYPELIST_39(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36, T37, T38, T39, T40) >
+
+#define TYPELIST_41(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41) \
+    ::Loki::Typelist<T1, TYPELIST_40(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41) >
+
+#define TYPELIST_42(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42) \
+    ::Loki::Typelist<T1, TYPELIST_41(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42) >
+
+#define TYPELIST_43(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43) \
+    ::Loki::Typelist<T1, TYPELIST_42(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43) >
+
+#define TYPELIST_44(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44) \
+    ::Loki::Typelist<T1, TYPELIST_43(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44) >
+
+#define TYPELIST_45(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
+        T41, T42, T43, T44, T45) \
+    ::Loki::Typelist<T1, TYPELIST_44(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
+        T41, T42, T43, T44, T45) >
+
+#define TYPELIST_46(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
+        T41, T42, T43, T44, T45, T46) \
+    ::Loki::Typelist<T1, TYPELIST_45(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
+        T41, T42, T43, T44, T45, T46) >
+
+#define TYPELIST_47(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
+        T41, T42, T43, T44, T45, T46, T47) \
+    ::Loki::Typelist<T1, TYPELIST_46(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
+        T41, T42, T43, T44, T45, T46, T47) >
+
+#define TYPELIST_48(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
+        T41, T42, T43, T44, T45, T46, T47, T48) \
+    ::Loki::Typelist<T1, TYPELIST_47(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
+        T41, T42, T43, T44, T45, T46, T47, T48) >
+
+#define TYPELIST_49(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
+        T41, T42, T43, T44, T45, T46, T47, T48, T49) \
+    ::Loki::Typelist<T1, TYPELIST_48(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
+        T41, T42, T43, T44, T45, T46, T47, T48, T49) >
+
+#define TYPELIST_50(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
+        T41, T42, T43, T44, T45, T46, T47, T48, T49, T50) \
+    ::Loki::Typelist<T1, TYPELIST_49(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
+        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
+        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
+        T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
+        T41, T42, T43, T44, T45, T46, T47, T48, T49, T50) >
 
 namespace Loki
 {
@@ -33,32 +359,121 @@ namespace Loki
 //     Tail (second element, can be another typelist)
 ////////////////////////////////////////////////////////////////////////////////
 
-    template <typename... Ts> struct Typelist;
-
-    template <typename T, typename... Ts>
-    struct Typelist<T, Ts ...> {
-        using Head = T;
-    };
-
-    template <> struct Typelist<> {
-        using Head = EmptyType;
+    template <class T, class U>
+    struct Typelist
+    {
+       typedef T Head;
+       typedef U Tail;
     };
 
     namespace TL
     {
 
+////////////////////////////////////////////////////////////////////////////////
+// class template MakeTypelist
+// Takes a number of arguments equal to its numeric suffix
+// The arguments are type names.
+// MakeTypelist<T1, T2, ...>::Result
+// returns a typelist that is of T1, T2, ...
+////////////////////////////////////////////////////////////////////////////////
+
+        template
+        <
+            typename T1  = NullType, typename T2  = NullType, typename T3  = NullType,
+            typename T4  = NullType, typename T5  = NullType, typename T6  = NullType,
+            typename T7  = NullType, typename T8  = NullType, typename T9  = NullType,
+            typename T10 = NullType, typename T11 = NullType, typename T12 = NullType,
+            typename T13 = NullType, typename T14 = NullType, typename T15 = NullType,
+            typename T16 = NullType, typename T17 = NullType, typename T18 = NullType
+        > 
+        struct MakeTypelist
+        {
+        private:
+            typedef typename MakeTypelist
+            <
+                T2 , T3 , T4 , 
+                T5 , T6 , T7 , 
+                T8 , T9 , T10, 
+                T11, T12, T13,
+                T14, T15, T16, 
+                T17, T18
+            >
+            ::Result TailResult;
+
+        public:
+            typedef Typelist<T1, TailResult> Result;
+        };
+
+        template<>
+        struct MakeTypelist
+        <
+            NullType, NullType, NullType, 
+            NullType, NullType, NullType, 
+            NullType, NullType, NullType, 
+            NullType, NullType, NullType,
+            NullType, NullType, NullType,
+            NullType, NullType, NullType
+        >{
+            typedef NullType Result;
+        };
+
+
 ////////////////////////////////////////////////////////////////////////////////
 // class template is_Typelist
 // detects if type is Typelist (including Nulltype)
 // Invocation :
 // is_Typelist<T>::value
 // returns a compile-time boolean constant containing true iff T is some Typelist<T1,T2>
+// is_Typelist<T>::type_tag
+// returns a compile-time unsigned constant containing 
+// 1 iff T == Typelist<T1,T2>, 2 iff T == NullType and 3 otherwise
 ////////////////////////////////////////////////////////////////////////////////
-        template <typename>
-        struct is_Typelist : std::false_type { };
+        struct Typelist_tag {};
+        struct NullType_tag {};
+        struct NoneList_tag {};
+        
+        enum 
+        {
+            Typelist_ID = 1,
+            NullType_ID = 2,
+            NoneList_ID = 3
+        };
 
-        template <typename... Ts>
-        struct is_Typelist<Typelist<Ts ...>> : std::true_type { };
+        template<typename T>
+        struct is_Typelist : std::false_type
+        {
+            static constexpr int type_it = NoneList_ID;
+            using type_tag = NoneList_tag;
+        };
+
+        template<typename Head, typename Tail>
+        struct is_Typelist<Typelist<Head, Tail>> : std::true_type
+        {
+            static constexpr int type_id = Typelist_ID;
+            using type_tag = Typelist_tag;
+        };
+
+        template<>
+        struct is_Typelist<NullType> : std::true_type
+        {
+            static constexpr int type_id = NullType_ID;
+            using type_tag = NullType_tag;
+        };
+
+
+#ifndef TL_FAST_COMPILATION
+
+// this macro will cause compile time error if _type_ is not a Typelist or NullType
+#define ASSERT_TYPELIST(_type_) \
+STATIC_CHECK( ::Loki::TL::is_Typelist<_type_>::value, TList_is_not_legal_Typelist )
+
+#else
+
+// might improve the compilation time
+#define ASSERT_TYPELIST(_type_) \
+typedef char _type_##_is_not_a_Typelist[true]
+
+#endif // ndef TL_FAST_COMPILATION
 
 ////////////////////////////////////////////////////////////////////////////////
 // class template Length
@@ -69,13 +484,15 @@ namespace Loki
 //     the end terminator (which by convention is NullType)
 ////////////////////////////////////////////////////////////////////////////////
 
-        // Length
-        template <typename>
-        struct Length;
+        template <class TList> struct Length;
+        
+        template <> 
+        struct Length<NullType>
+        : std::integral_constant<int, 0> {};
 
-        template <typename... Ts>
-        struct Length<Typelist<Ts...>>
-         : std::integral_constant<size_t, sizeof...(Ts)> { };
+        template <class Head, class Tail>
+        struct Length<Typelist<Head, Tail>>
+        : std::integral_constant<int, 1 + Length<Tail>::value> {};
 
 ////////////////////////////////////////////////////////////////////////////////
 // class template TypeAt
@@ -87,19 +504,21 @@ namespace Loki
 // If you pass an out-of-bounds index, the result is a compile-time error
 ////////////////////////////////////////////////////////////////////////////////
 
-        template <typename, size_t>
-        struct TypeAt;
+        template <class TList, unsigned int index> 
+        struct TypeAt
+        {
+            using Result = typename TypeAt<typename TList::Tail, index - 1>::Result;
 
-        template <typename T, typename... Ts>
-        struct TypeAt<Typelist<T, Ts...>, 0> {
-          using type = T;
+        private:
+            ASSERT_TYPELIST(TList);
         };
 
-        template <size_t ix, typename T, typename... Ts>
-        struct TypeAt<Typelist<T, Ts...>, ix> {
-          using type = typename TypeAt<Typelist<Ts...>, ix - 1>::type;
+        template <class TList>
+        struct TypeAt<TList, 0>
+        {
+            using Result = typename TList::Head;
         };
-        
+
 ////////////////////////////////////////////////////////////////////////////////
 // class template TypeAtNonStrict
 // Finds the type at a given index in a typelist
@@ -113,22 +532,26 @@ namespace Loki
 ////////////////////////////////////////////////////////////////////////////////
 
 
-        template <typename, size_t>
-        struct TypeAtNonStrict;
+        template <class TList, unsigned int index, typename DefaultType = NullType> 
+        struct TypeAtNonStrict
+        {
+            using Tail = typename TList::Tail;
+            using Result = typename TypeAtNonStrict<Tail, index - 1, DefaultType>::Result;
 
-        template <size_t ix>
-        struct TypeAtNonStrict<Typelist<>, ix> {
-          using type = EmptyType;
+        private:
+            ASSERT_TYPELIST(TList);
         };
 
-        template <typename T, typename... Ts>
-        struct TypeAtNonStrict<Typelist<T, Ts...>, 0> {
-          using type = T;
+        template <unsigned int index, typename DefaultType>
+        struct TypeAtNonStrict<NullType, index, DefaultType>
+        {
+            using Result = DefaultType;
         };
 
-        template <typename T, typename... Ts, size_t ix>
-        struct TypeAtNonStrict<Typelist<T, Ts...>, ix> {
-          using type = typename TypeAtNonStrict<Typelist<Ts...>, ix - 1>::type;
+        template <class TList, typename DefaultType>
+        struct TypeAtNonStrict<TList, 0, DefaultType>
+        {
+            using Result = typename TList::Head;
         };
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -136,36 +559,310 @@ namespace Loki
 // Finds the index of a type in a typelist
 // Invocation (TList is a typelist and T is a type):
 // IndexOf<TList, T>::value
-// returns the position of T in TList, or NullType if T is not found in TList
+// returns the position of T in TList, or -1 if T is not found in TList
 ////////////////////////////////////////////////////////////////////////////////
 
-        template<typename, typename>
+        template <class TList, class T>
         struct IndexOf;
 
-        template <typename T, typename... Ts>
-        struct IndexOf<Typelist<T, Ts...>, T>
-            : std::integral_constant<int, 0>
+        template <class T>
+        struct IndexOf<NullType, T>
+            : std::integral_constant<int, -1>
         {};
 
-        template <typename T, typename TOther, typename... Ts>
-        struct IndexOf<Typelist<TOther, Ts...>, T>
-            : std::integral_constant<int, 1 + IndexOf<Typelist<Ts...>, T>::value>
+        template <class Tail, class T>
+        struct IndexOf<Typelist<T, Tail>, T>
+            : std::integral_constant<int, 0>
         {};
 
-        template <typename T>
-        struct IndexOf<Typelist<>, T>
-            : std::integral_constant<int, -1>
+        template <class Head, class Tail, class T>
+        struct IndexOf<Typelist<Head, Tail>, T>
+            : std::integral_constant<int, 1 + IndexOf<Tail, T>::value>
         {};
 
+////////////////////////////////////////////////////////////////////////////////
+// class template Append
+// Appends a type or a typelist to another
+// Invocation (TList is a typelist and T is either a type or a typelist):
+// Append<TList, T>::Result
+// returns a typelist that is TList followed by T and NullType-terminated
+////////////////////////////////////////////////////////////////////////////////
+
+        template <class TList, class T>
+        struct Append;
+
+        template <class Head, class Tail, class T>
+        struct Append<Typelist<Head, Tail>, T>
+        {
+            using Result = Typelist<Head, typename Append<Tail, T>::Result>;
+        };
+
+        template <class T>
+        struct Append<NullType, T>
+        {
+            using Result = std::conditional_t<is_Typelist<T>::value,
+                T,
+                TYPELIST_1(T)>;
+        };
+
+////////////////////////////////////////////////////////////////////////////////
+// class template Erase
+// Erases the first occurence, if any, of a type in a typelist
+// Invocation (TList is a typelist and T is a type):
+// Erase<TList, T>::Result
+// returns a typelist that is TList without the first occurence of T
+////////////////////////////////////////////////////////////////////////////////
 
-        template<typename, typename>
-        struct Prepend;
+        template <class TList, class T>
+        struct Erase;
+
+        template <class Head, class Tail, class T>
+        struct Erase<Typelist<Head, Tail>, T>
+        {
+            using Result = std::conditional_t<std::is_same_v<Head, T>,
+                Tail,
+                Typelist<Head, typename Erase<Tail, T>::Result>>;
+        };
+
+        template <class T>
+        struct Erase<NullType, T>
+        {
+            using Result = NullType;
+        };
+
+
+////////////////////////////////////////////////////////////////////////////////
+// class template EraseAll
+// Erases all first occurences, if any, of a type in a typelist
+// Invocation (TList is a typelist and T is a type):
+// EraseAll<TList, T>::Result
+// returns a typelist that is TList without any occurence of T
+////////////////////////////////////////////////////////////////////////////////
+
+        template <class TList, class T>
+        struct EraseAll;
+
+        template <class Head, class Tail, class T>
+        struct EraseAll<Typelist<Head, Tail>, T>
+        {
+            using Result = std::conditional_t<std::is_same_v<Head, T>,
+                typename EraseAll<Tail, T>::Result,
+                Typelist<Head, typename EraseAll<Tail, T>::Result>>;
+        };
+
+        template <class T>
+        struct EraseAll<NullType, T>
+        {
+            using Result = NullType;
+        };
+
+////////////////////////////////////////////////////////////////////////////////
+// class template NoDuplicates
+// Removes all duplicate types in a typelist
+// Invocation (TList is a typelist):
+// NoDuplicates<TList, T>::Result
+////////////////////////////////////////////////////////////////////////////////
+
+        template <class TList>
+        struct NoDuplicates
+        {
+        private:
+            typedef typename TList::Head Head;
+            typedef typename TList::Tail Tail;
+
+            ASSERT_TYPELIST(TList);
+
+            typedef typename NoDuplicates<Tail>::Result L1;
+            typedef typename Erase<L1, Head>::Result    L2;
+
+        public:
+            typedef Typelist<Head, L2> Result;
+        };
+
+        template <>
+        struct NoDuplicates<NullType>
+        {
+            typedef NullType Result;
+        };
+
+////////////////////////////////////////////////////////////////////////////////
+// class template Replace
+// Replaces the first occurence of a type in a typelist, with another type
+// Invocation (TList is a typelist, T, U are types):
+// Replace<TList, T, U>::Result
+// returns a typelist in which the first occurence of T is replaced with U
+////////////////////////////////////////////////////////////////////////////////
+
+        template <class TList, class T, class U>
+        struct Replace;
+
+        template <class Head, class Tail, class T, class U>
+        struct Replace<Typelist<Head, Tail>, T, U>
+        {
+            using Result = std::conditional_t<std::is_same_v<Head, T>,
+                Typelist<U, Tail>,
+                Typelist<Head, typename Replace<Tail, T, U>::Result>>;
+        };
+
+        template <class T, class U>
+        struct Replace<NullType, T, U>
+        {
+            using Result = NullType;
+        };
+
+////////////////////////////////////////////////////////////////////////////////
+// class template ReplaceAll
+// Replaces all occurences of a type in a typelist, with another type
+// Invocation (TList is a typelist, T, U are types):
+// Replace<TList, T, U>::Result
+// returns a typelist in which all occurences of T is replaced with U
+////////////////////////////////////////////////////////////////////////////////
+
+        template <class TList, class T, class U>
+        struct ReplaceAll;
+
+        template <class Head, class Tail, class T, class U>
+        struct ReplaceAll<Typelist<Head, Tail>, T, U>
+        {
+            using Result = std::conditional_t<std::is_same_v<Head, T>,
+                Typelist<U, typename ReplaceAll<Tail, T, U>::Result>,
+                Typelist<Head, typename ReplaceAll<Tail, T, U>::Result>>;
+        };
+
+        template <class T, class U>
+        struct ReplaceAll<NullType, T, U>
+        {
+            using Result = NullType;
+        };
+
+////////////////////////////////////////////////////////////////////////////////
+// class template Reverse
+// Reverses a typelist
+// Invocation (TList is a typelist):
+// Reverse<TList>::Result
+// returns a typelist that is TList reversed
+////////////////////////////////////////////////////////////////////////////////
+
+        template <class TList> struct Reverse;
+        
+        template <>
+        struct Reverse<NullType>
+        {
+            typedef NullType Result;
+        };
+        
+        template <class TList> 
+        struct Reverse
+        {
+        private:
+            typedef typename TList::Head Head;
+            typedef typename TList::Tail Tail;
+        
+            ASSERT_TYPELIST(TList);
+
+        public:
+            typedef typename Append<
+                typename Reverse<Tail>::Result, Head>::Result Result;
+        };
+
+
+////////////////////////////////////////////////////////////////////////////////
+// class template MostDerived
+// Finds the type in a typelist that is the most derived from a given type
+// Invocation (TList is a typelist, T is a type):
+// Replace<TList, T>::Result
+// returns the type in TList that's the most derived from T
+////////////////////////////////////////////////////////////////////////////////
+
+        template <class TList, class T>
+        struct MostDerived;
+
+        template <class Head, class Tail, class T>
+        struct MostDerived<Typelist<Head, Tail>, T>
+        {
+        private:
+            using Candidate = typename MostDerived<Tail, T>::Result;
+
+        public:
+            using Result = std::conditional_t<std::is_base_of_v<Candidate, Head>,
+                Head,
+                Candidate>;
+        };
+
+        template <class T>
+        struct MostDerived<NullType, T>
+        {
+            using Result = T;
+        };
+
+////////////////////////////////////////////////////////////////////////////////
+// class template DerivedToFront
+// Arranges the types in a typelist so that the most derived types appear first
+// Invocation (TList is a typelist):
+// DerivedToFront<TList>::Result
+// returns the reordered TList 
+////////////////////////////////////////////////////////////////////////////////
+        
+        template <class TList> struct DerivedToFront;
+        
+        template <>
+        struct DerivedToFront<NullType>
+        {
+            typedef NullType Result;
+        };
+        
+        template <class TList>
+        struct DerivedToFront
+        {
+        private:
+            ASSERT_TYPELIST(TList);
+
+            typedef typename TList::Head Head;
+            typedef typename TList::Tail Tail;
+        
+            typedef typename MostDerived<Tail, Head>::Result TheMostDerived;
+            typedef typename Replace<Tail, TheMostDerived, Head>::Result Temp;
+            typedef typename DerivedToFront<Temp>::Result L;
+
+        public:
+            typedef Typelist<TheMostDerived, L> Result;
+        };
+                
+
+////////////////////////////////////////////////////////////////////////////////
+// class template DerivedToFrontAll
+// Arranges all the types in a typelist so that the most derived types appear first
+// Invocation (TList is a typelist):
+// DerivedToFront<TList>::Result
+// returns the reordered TList 
+////////////////////////////////////////////////////////////////////////////////
+        
+        template <class TList> struct DerivedToFrontAll;
+        
+        template <>
+        struct DerivedToFrontAll<NullType>
+        {
+            typedef NullType Result;
+        };
+        
+        template <class TList>
+        struct DerivedToFrontAll
+        {
+        private:
+            ASSERT_TYPELIST(TList);
+
+            typedef typename TList::Head Head;
+            typedef typename TList::Tail Tail;
+        
+            typedef typename MostDerived<Tail, Head>::Result TheMostDerived;
+            typedef typename Replace<Tail, TheMostDerived, Head>::Result L;
+            
+            typedef typename DerivedToFrontAll<L>::Result TailResult;
 
-        template <typename T, typename... Ts>
-        struct Prepend<T, Typelist<Ts...>>
-        { 
-            using result = Typelist<T, Ts...>;
+        public:
+            typedef Typelist<TheMostDerived, TailResult> Result;
         };
+                                    
     }   // namespace TL
 }   // namespace Loki
 
diff --git a/src/Common/PlatformLinux.inl b/src/Common/PlatformLinux.inl
index 6fa73c445ba..989cc1d9052 100644
--- a/src/Common/PlatformLinux.inl
+++ b/src/Common/PlatformLinux.inl
@@ -49,6 +49,7 @@
 #define CALLBACK
 #define TEXT(x) strdup(x)
 
+/*
 inline char* _strlwr_l(char* str, locale_t loc)
 {
 //TODO
@@ -58,6 +59,7 @@ inline char* _strupr_l(char* str, locale_t loc)
 {
 //TODO
 }
+*/
 
 #define VOID void
 #define HKL void*
diff --git a/src/utils/xrSE_Factory/xrSE_Factory.vcxproj b/src/utils/xrSE_Factory/xrSE_Factory.vcxproj
index 1f7ddd97dd0..4a2bd7654b3 100644
--- a/src/utils/xrSE_Factory/xrSE_Factory.vcxproj
+++ b/src/utils/xrSE_Factory/xrSE_Factory.vcxproj
@@ -244,7 +244,14 @@
       <PrecompiledHeaderOutputFile Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(IntDir)$(ProjectName)_script.pch</PrecompiledHeaderOutputFile>
       <PrecompiledHeaderOutputFile Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(IntDir)$(ProjectName)_script.pch</PrecompiledHeaderOutputFile>
     </ClCompile>
-    <ClCompile Include="..\..\xrServerEntities\PHNetState.cpp" />
+    <ClCompile Include="..\..\xrServerEntities\PHNetState.cpp">
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">NotUsing</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Mixed|Win32'">NotUsing</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Mixed|x64'">NotUsing</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">NotUsing</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
+    </ClCompile>
     <ClCompile Include="..\..\xrServerEntities\PHSynchronize.cpp" />
     <ClCompile Include="..\..\xrServerEntities\script_fcolor_script.cpp">
       <PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">pch_script.h</PrecompiledHeaderFile>
diff --git a/src/xrGame/accumulative_states.h b/src/xrGame/accumulative_states.h
index e4ee75a36fd..713522bde87 100644
--- a/src/xrGame/accumulative_states.h
+++ b/src/xrGame/accumulative_states.h
@@ -56,9 +56,10 @@ struct accumulative_pair_t
 }; // struct accumulative_pair_t
 } // namespace detail
 
-#define ACCUMULATIVE_STATE_LIST Loki::Typelist<>
-#define ADD_ACCUMULATIVE_STATE(id, type) using Accumulative_State_Type_##type =                   \
-        Loki::TL::Prepend<detail::accumulative_pair_t<id, type>, ACCUMULATIVE_STATE_LIST>::result
+#define ACCUMULATIVE_STATE_LIST Loki::NullType
+#define ADD_ACCUMULATIVE_STATE(id, type)                                                   \
+    typedef Loki::Typelist<detail::accumulative_pair_t<id, type>, ACCUMULATIVE_STATE_LIST> \
+        Accumulative_State_Type_##type;
 #define SAVE_TYPE_LIST(id, type) Accumulative_State_Type_##type
 
 } // namespace award_system
diff --git a/src/xrGame/alife_registry_container.cpp b/src/xrGame/alife_registry_container.cpp
index 6c90a7fca33..da7e7887e8d 100644
--- a/src/xrGame/alife_registry_container.cpp
+++ b/src/xrGame/alife_registry_container.cpp
@@ -12,35 +12,35 @@
 #include "alife_space.h"
 #include "Common/object_type_traits.h"
 
-template <typename, typename>
+template <typename TContainer, typename TList>
 struct RegistryHelper;
 
 template <typename TContainer>
-struct RegistryHelper<TContainer, Loki::Typelist<>>
+struct RegistryHelper<TContainer, Loki::NullType>
 {
     static void Save(TContainer*, IWriter&) {};
     static void Load(TContainer*, IReader&) {};
 };
 
-template <typename TContainer, typename T, typename... Ts>
-struct RegistryHelper<TContainer, Loki::Typelist<T, Ts...>>
+template <typename TContainer, typename Head, typename Tail>
+struct RegistryHelper<TContainer, Loki::Typelist<Head, Tail>>
 {
-    static constexpr bool isSerializable = object_type_traits::is_base_and_derived<ISerializable, T>::value;
+    static constexpr bool isSerializable =
+        object_type_traits::is_base_and_derived<ISerializable, Head>::value;
 
     static void Save(TContainer* self, IWriter& writer)
     {
         if constexpr (isSerializable)
-            self->T::save(writer);
-        RegistryHelper<TContainer, Loki::Typelist<Ts...>>::Save(self, writer);
+            self->Head::save(writer);
+        RegistryHelper<TContainer, Tail>::Save(self, writer);
     };
 
     static void Load(TContainer* self, IReader& reader)
     {
         if constexpr (isSerializable)
-            self->T::load(reader);
-        RegistryHelper<TContainer, Loki::Typelist<Ts...>>::Load(self, reader);
+            self->Head::load(reader);
+        RegistryHelper<TContainer, Tail>::Load(self, reader);
     }
-
 };
 
 void CALifeRegistryContainer::load(IReader& file_stream)
diff --git a/src/xrGame/alife_registry_container.h b/src/xrGame/alife_registry_container.h
index a77947ba9ad..d67b71a9999 100644
--- a/src/xrGame/alife_registry_container.h
+++ b/src/xrGame/alife_registry_container.h
@@ -17,7 +17,7 @@ struct CLinearRegistryType : public _base, public _type
 {
 };
 
-class CALifeRegistryContainer : public Loki::GenLinearHierarchy<registry_type_list, CLinearRegistryType>
+class CALifeRegistryContainer : public Loki::GenLinearHierarchy<registry_type_list, CLinearRegistryType>::LinBase
 {
 private:
     typedef registry_type_list TYPE_LIST;
diff --git a/src/xrGame/alife_registry_container_space.h b/src/xrGame/alife_registry_container_space.h
index aa692f619d8..7c96fa368d2 100644
--- a/src/xrGame/alife_registry_container_space.h
+++ b/src/xrGame/alife_registry_container_space.h
@@ -9,7 +9,7 @@
 #pragma once
 
 #include <loki/HierarchyGenerators.h>
-#define registry_type_list Loki::Typelist<>
-#define add_to_registry_type_list(a) using registry_##a = Loki::TL::Prepend<a, registry_type_list>::result;
+#define registry_type_list Loki::NullType
+#define add_to_registry_type_list(a) typedef Loki::Typelist<a, registry_type_list> registry_##a;
 #define define_constant(a) (a*)0
 #define save_registry_type_list(a) registry_##a
diff --git a/src/xrGame/alife_simulator_script.cpp b/src/xrGame/alife_simulator_script.cpp
index 795dda59a5c..537ccebe469 100644
--- a/src/xrGame/alife_simulator_script.cpp
+++ b/src/xrGame/alife_simulator_script.cpp
@@ -348,10 +348,9 @@ SCRIPT_EXPORT(CALifeSimulator, (), {
                          .def("actor", &get_actor)
                          .def("has_info", &has_info)
                          .def("dont_has_info", &dont_has_info)
-#ifndef LINUX // FIXME!!!
-                         .def("switch_distance", &CALifeSimulator::switch_distance)
-                         .def("set_switch_distance", &CALifeSimulator::set_switch_distance) //Alundaio: renamed to set_switch_distance from switch_distance
-#endif
+                         .def("switch_distance", (float (CALifeSimulator::*)())(&CALifeSimulator::switch_distance))
+                         .def("set_switch_distance", (void (CALifeSimulator::*)(float))
+                            (&CALifeSimulator::set_switch_distance)) //Alundaio: renamed to set_switch_distance from switch_distance
                          //Alundaio: extend alife simulator exports
                          .def("teleport_object", &teleport_object)
                          //Alundaio: END
diff --git a/src/xrGame/base_client_classes_wrappers.h b/src/xrGame/base_client_classes_wrappers.h
index 19507116251..9b02f0e7dad 100644
--- a/src/xrGame/base_client_classes_wrappers.h
+++ b/src/xrGame/base_client_classes_wrappers.h
@@ -34,8 +34,9 @@ struct linear_registrator<_type, Loki::EmptyType> : public _type
 template <typename _1, typename _2>
 struct heritage
 {
-    using tl = Loki::Typelist<_1, _2>;
-    using result = Loki::GenLinearHierarchy<tl, linear_registrator>;
+    typedef Loki::Typelist<_1, Loki::Typelist<_2, Loki::NullType>> tl;
+    typedef typename Loki::TL::Erase<tl, Loki::EmptyType>::Result pure_tl;
+    typedef typename Loki::GenLinearHierarchy<pure_tl, linear_registrator>::LinBase result;
 };
 
 template <typename base>
diff --git a/src/xrGame/game_state_accumulator.h b/src/xrGame/game_state_accumulator.h
index 51768c4deac..ea1a4d0dbbf 100644
--- a/src/xrGame/game_state_accumulator.h
+++ b/src/xrGame/game_state_accumulator.h
@@ -81,7 +81,6 @@ class game_state_accumulator : public game_events_handler
     bool check_accumulative_value(enum_accumulative_player_values param_id, u32_binary_function* func, u32 right_arg);
 
     using accumulative_values_collection_t = AssociativeVector<enum_accumulative_player_values, player_state_param*>;
-
 private:
     // average_values_collection_t			m_average_values;
     accumulative_values_collection_t m_accumulative_values;
diff --git a/src/xrGame/game_state_accumulator_inline.h b/src/xrGame/game_state_accumulator_inline.h
new file mode 100644
index 00000000000..a64e42fe249
--- /dev/null
+++ b/src/xrGame/game_state_accumulator_inline.h
@@ -0,0 +1,11 @@
+template <typename TypeListElement>
+void game_state_accumulator::init_acpv_list()
+{
+    static_assert(Loki::TL::is_Typelist<TypeListElement>::value,
+        "Type must have a Loki Type List type use ADD_ACCUMULATIVE_STATE macro define.");
+    init_acpv_list<TypeListElement::Tail>();
+
+    player_state_param* tmp_obj_inst = new typename TypeListElement::Head::value_type(this);
+
+    m_accumulative_values.insert(std::make_pair(TypeListElement::Head::value_id, tmp_obj_inst));
+}
diff --git a/src/xrGame/game_state_accumulator_state_register.cpp b/src/xrGame/game_state_accumulator_state_register.cpp
index b3b987a4483..3819406bcde 100644
--- a/src/xrGame/game_state_accumulator_state_register.cpp
+++ b/src/xrGame/game_state_accumulator_state_register.cpp
@@ -32,25 +32,26 @@
 
 namespace award_system
 {
+
 template <typename>
 struct AccumulatorHelper;
 
 template <>
-struct AccumulatorHelper<Loki::Typelist<>> {
+struct AccumulatorHelper<Loki::NullType> {
 	static void init_acpv(game_state_accumulator*,
 		game_state_accumulator::accumulative_values_collection_t&)
 	{
 	}
 };
 
-template <typename T, typename... Ts>
-struct AccumulatorHelper<Loki::Typelist<T, Ts...>> {
+template <typename Head, typename Tail>
+struct AccumulatorHelper<Loki::Typelist<Head, Tail>> {
 	static void init_acpv(game_state_accumulator* self,
 		game_state_accumulator::accumulative_values_collection_t& accumulative_values)
 	{
-		AccumulatorHelper<Loki::Typelist<Ts...>>::init_acpv(self, accumulative_values);
-		player_state_param* tmp_obj_inst = new typename T::value_type(self);
-		accumulative_values.insert(std::make_pair(T::value_id, tmp_obj_inst));
+		AccumulatorHelper<Tail>::init_acpv(self, accumulative_values);
+		player_state_param* tmp_obj_inst = new typename Head::value_type(self);
+		accumulative_values.insert(std::make_pair(Head::value_id, tmp_obj_inst));
 	}
 };
 
diff --git a/src/xrGame/level_script.cpp b/src/xrGame/level_script.cpp
index 14d70bafd23..f36d9d8abd2 100644
--- a/src/xrGame/level_script.cpp
+++ b/src/xrGame/level_script.cpp
@@ -781,9 +781,7 @@ IC static void CLevel_Export(lua_State* luaState)
     ];
 
     module(luaState)[def("command_line", &command_line),
-#ifndef LINUX // FIXME!!!
-        def("IsGameTypeSingle", &IsGameTypeSingle),
-#endif
+        def("IsGameTypeSingle", (bool (*)())&IsGameTypeSingle),
         def("IsDynamicMusic", &IsDynamicMusic), def("render_get_dx_level", &render_get_dx_level),
         def("IsImportantSave", &IsImportantSave)];
 
diff --git a/src/xrGame/login_manager_script.cpp b/src/xrGame/login_manager_script.cpp
index 38c11c31776..f634038b145 100644
--- a/src/xrGame/login_manager_script.cpp
+++ b/src/xrGame/login_manager_script.cpp
@@ -32,13 +32,13 @@ SCRIPT_EXPORT(profile, (), {
         luaState)[class_<profile>("profile").def("unique_nick", &profile::unique_nick).def("online", &profile::online)];
 });
 
+#ifndef LINUX // FIXME!!!
 SCRIPT_EXPORT(login_operation_cb, (), {
     module(luaState)[class_<gamespy_gp::login_operation_cb>("login_operation_cb")
                          .def(constructor<>())
                          .def(constructor<gamespy_gp::login_operation_cb::lua_object_type,
                              gamespy_gp::login_operation_cb::lua_function_type>())
-#ifndef LINUX // FIXME!!!
                          .def("bind", &gamespy_gp::login_operation_cb::bind)
-#endif
                          .def("clear", &gamespy_gp::login_operation_cb::clear)];
 });
+#endif
\ No newline at end of file
diff --git a/src/xrGame/profile_data_types_script.cpp b/src/xrGame/profile_data_types_script.cpp
index 72b00c1d889..3f14be70908 100644
--- a/src/xrGame/profile_data_types_script.cpp
+++ b/src/xrGame/profile_data_types_script.cpp
@@ -20,13 +20,13 @@ SCRIPT_EXPORT(profile_data_script_registrator, (), {
             .def_readonly("second", &all_best_scores_t::value_type::second)];
 });
 
+#ifndef LINUX // FIXME!!!
 SCRIPT_EXPORT(store_operation_cb, (), {
     module(luaState)[class_<gamespy_profile::store_operation_cb>("store_operation_cb")
                          .def(constructor<>())
                          .def(constructor<gamespy_profile::store_operation_cb::lua_object_type,
                              gamespy_profile::store_operation_cb::lua_function_type>())
-#ifndef LINUX // FIXME!!!
                          .def("bind", &gamespy_profile::store_operation_cb::bind)
-#endif
                          .def("clear", &gamespy_profile::store_operation_cb::clear)];
 });
+#endif
diff --git a/src/xrGame/ui/UIListBox_script.cpp b/src/xrGame/ui/UIListBox_script.cpp
index e7f5ba1538c..118ffb96f7d 100644
--- a/src/xrGame/ui/UIListBox_script.cpp
+++ b/src/xrGame/ui/UIListBox_script.cpp
@@ -64,15 +64,15 @@ SCRIPT_EXPORT(SServerFilters, (), {
                          .def_readwrite("listen_servers", &SServerFilters::listen_servers)];
 });
 
+#ifndef LINUX // FIXME!!!
 SCRIPT_EXPORT(connect_error_cb, (), {
     module(luaState)[class_<connect_error_cb>("connect_error_cb")
                          .def(constructor<>())
                          .def(constructor<connect_error_cb::lua_object_type, connect_error_cb::lua_function_type>())
-#ifndef LINUX // FIXME!!!
                          .def("bind", &connect_error_cb::bind)
-#endif
                          .def("clear", &connect_error_cb::clear)];
 });
+#endif
 
 SCRIPT_EXPORT(CServerList, (CUIWindow), {
     module(luaState)[class_<CServerList, CUIWindow>("CServerList")
diff --git a/src/xrGame/ui/UIWindow.h b/src/xrGame/ui/UIWindow.h
index cc156aee3d1..1c7ee6add0e 100644
--- a/src/xrGame/ui/UIWindow.h
+++ b/src/xrGame/ui/UIWindow.h
@@ -81,7 +81,7 @@ class CUIWindow : public CUISimpleWindow
     void ShowChildren(bool show);
 
     //абсолютные координаты
-    IC void GetAbsoluteRect(Frect& r);
+    void GetAbsoluteRect(Frect& r);
     IC void GetAbsolutePos(Fvector2& p)
     {
         Frect abs;
diff --git a/src/xrGame/xrGame.vcxproj b/src/xrGame/xrGame.vcxproj
index c141fd8388a..2d7682b4180 100644
--- a/src/xrGame/xrGame.vcxproj
+++ b/src/xrGame/xrGame.vcxproj
@@ -856,6 +856,7 @@
     <ClInclude Include="game_path_manager.h" />
     <ClInclude Include="game_path_manager_inline.h" />
     <ClInclude Include="game_state_accumulator.h" />
+    <ClInclude Include="game_state_accumulator_inline.h" />
     <ClInclude Include="game_sv_artefacthunt.h" />
     <ClInclude Include="game_sv_base.h" />
     <ClInclude Include="game_sv_base_console_vars.h" />
@@ -1642,7 +1643,14 @@
       <PrecompiledHeaderFile>pch_script.h</PrecompiledHeaderFile>
       <PrecompiledHeaderOutputFile>$(IntDir)$(ProjectName)_script.pch</PrecompiledHeaderOutputFile>
     </ClCompile>
-    <ClCompile Include="..\xrServerEntities\PHNetState.cpp" />
+    <ClCompile Include="..\xrServerEntities\PHNetState.cpp">
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">NotUsing</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Mixed|Win32'">NotUsing</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Mixed|x64'">NotUsing</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">NotUsing</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
+    </ClCompile>
     <ClCompile Include="..\xrServerEntities\script_fcolor_script.cpp">
       <PrecompiledHeaderFile>pch_script.h</PrecompiledHeaderFile>
       <PrecompiledHeaderOutputFile>$(IntDir)$(ProjectName)_script.pch</PrecompiledHeaderOutputFile>
diff --git a/src/xrGame/xrGame.vcxproj.filters b/src/xrGame/xrGame.vcxproj.filters
index 7e335f0c41c..870d092c18c 100644
--- a/src/xrGame/xrGame.vcxproj.filters
+++ b/src/xrGame/xrGame.vcxproj.filters
@@ -5682,6 +5682,9 @@
     <ClInclude Include="game_state_accumulator.h">
       <Filter>Core\Server\Games\client\mp\award_system\player_state</Filter>
     </ClInclude>
+    <ClInclude Include="game_state_accumulator_inline.h">
+      <Filter>Core\Server\Games\client\mp\award_system\player_state</Filter>
+    </ClInclude>
     <ClInclude Include="hits_store.h">
       <Filter>Core\Server\Games\client\mp\award_system\player_state</Filter>
     </ClInclude>
diff --git a/src/xrPhysics/xrPhysics.vcxproj b/src/xrPhysics/xrPhysics.vcxproj
index e968aceb71c..2b7849c3b1f 100644
--- a/src/xrPhysics/xrPhysics.vcxproj
+++ b/src/xrPhysics/xrPhysics.vcxproj
@@ -138,7 +138,14 @@
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemGroup>
-    <ClCompile Include="..\xrServerEntities\PHNetState.cpp" />
+    <ClCompile Include="..\xrServerEntities\PHNetState.cpp">
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">NotUsing</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Mixed|Win32'">NotUsing</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Mixed|x64'">NotUsing</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">NotUsing</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
+    </ClCompile>
     <ClCompile Include="ActorCameraCollision.cpp" />
     <ClCompile Include="collisiondamagereceiver.cpp" />
     <ClCompile Include="console_vars.cpp" />
diff --git a/src/xrServerEntities/script_flags_script.cpp b/src/xrServerEntities/script_flags_script.cpp
index 48b5749646d..c38dee66496 100644
--- a/src/xrServerEntities/script_flags_script.cpp
+++ b/src/xrServerEntities/script_flags_script.cpp
@@ -53,17 +53,16 @@ void one(T* self)
     self->assign(typename T::TYPE(-1));
 }
 
+#ifndef LINUX // FIXME!!!
 SCRIPT_EXPORT(Flags8, (),
 {
     module(luaState)
     [
         class_<Flags8>("flags8")
             .def(constructor<>())
-#ifndef LINUX // FIXME!!!
             .def("get", &Flags8::get)
             .def("zero", &Flags8::zero)
             .def("one", &one<Flags8>)
-#endif
             .def("invert", (Flags8 & (Flags8::*)())(&Flags8::invert))
             .def("invert", (Flags8 & (Flags8::*)(const Flags8&))(&Flags8::invert))
             .def("invert", (Flags8 & (Flags8::*)(const Flags8::TYPE))(&Flags8::invert))
@@ -88,11 +87,9 @@ SCRIPT_EXPORT(Flags16, (),
     [
         class_<Flags16>("flags16")
             .def(constructor<>())
-#ifndef LINUX // FIXME!!!
             .def("get", &Flags16::get)
             .def("zero", &Flags16::zero)
             .def("one", &one<Flags16>)
-#endif
             .def("invert", (Flags16 & (Flags16::*)())(&Flags16::invert))
             .def("invert", (Flags16 & (Flags16::*)(const Flags16&))(&Flags16::invert))
             .def("invert", (Flags16 & (Flags16::*)(const Flags16::TYPE))(&Flags16::invert))
@@ -117,11 +114,9 @@ SCRIPT_EXPORT(Flags32, (),
     [
         class_<Flags32>("flags32")
             .def(constructor<>())
-#ifndef LINUX // FIXME!!!
             .def("get", &Flags32::get)
             .def("zero", &Flags32::zero)
             .def("one", &Flags32::one)
-#endif
             .def("invert", (Flags32 & (Flags32::*)())(&Flags32::invert))
             .def("invert", (Flags32 & (Flags32::*)(const Flags32&))(&Flags32::invert))
             .def("invert", (Flags32 & (Flags32::*)(const Flags32::TYPE))(&Flags32::invert))
@@ -139,3 +134,4 @@ SCRIPT_EXPORT(Flags32, (),
             .def("equal", (bool(*)(Flags32*, const Flags32&, const Flags32::TYPE))(&equal<Flags32>))
     ];
 });
+#endif
diff --git a/src/xrServerEntities/smart_cast_impl0.h b/src/xrServerEntities/smart_cast_impl0.h
index 95929c629d1..9d7e0dd8f7f 100644
--- a/src/xrServerEntities/smart_cast_impl0.h
+++ b/src/xrServerEntities/smart_cast_impl0.h
@@ -41,16 +41,16 @@ struct CTypeHelper
     };
 
     template <>
-    struct add<Loki::EmptyType>
+    struct add<Loki::NullType>
     {
-        typedef Loki::Typelist<Loki::Typelist<T, Loki::Typelist<P, Loki::EmptyType>>, List> result;
+        typedef Loki::Typelist<Loki::Typelist<T, Loki::Typelist<P, Loki::NullType>>, List> result;
     };
 
     typedef typename add<List>::result result;
 };
 };
 
-#define cast_type_list Loki::EmptyType
+#define cast_type_list Loki::NullType
 #define add_to_cast_list(B, A) typedef SmartDynamicCast::CTypeHelper<cast_type_list, A, B>::result TypeList_##A##B
 #define save_cast_list(B, A) TypeList_##A##B
 
diff --git a/src/xrServerEntities/smart_cast_impl1.h b/src/xrServerEntities/smart_cast_impl1.h
index d49012282db..bac443b9457 100644
--- a/src/xrServerEntities/smart_cast_impl1.h
+++ b/src/xrServerEntities/smart_cast_impl1.h
@@ -59,7 +59,7 @@ struct exists
     };
 
     template <>
-    struct iterator<Loki::EmptyType>
+    struct iterator<Loki::NullType>
     {
         enum
         {
@@ -83,7 +83,7 @@ struct merge
     };
 
     template <>
-    struct iterator<Loki::EmptyType>
+    struct iterator<Loki::NullType>
     {
         typedef List2 result;
     };
@@ -116,9 +116,9 @@ struct has_conversion
     };
 
     template <>
-    struct search_base<Loki::EmptyType>
+    struct search_base<Loki::NullType>
     {
-        typedef Loki::EmptyType result;
+        typedef Loki::NullType result;
     };
 
     template <typename T>
@@ -149,7 +149,7 @@ struct has_conversion
     };
 
     template <>
-    struct search_conversion<Loki::EmptyType>
+    struct search_conversion<Loki::NullType>
     {
         enum
         {
@@ -197,7 +197,7 @@ struct has_any_conversion
     };
 
     template <>
-    struct iterator<Loki::EmptyType>
+    struct iterator<Loki::NullType>
     {
         enum
         {
@@ -233,14 +233,14 @@ struct CMatcher
                 template <bool>
                 struct _selector
                 {
-                    typedef Loki::Typelist<typename PrevHead::Head, Loki::Typelist<Target, Loki::EmptyType>> result;
+                    typedef Loki::Typelist<typename PrevHead::Head, Loki::Typelist<Target, Loki::NullType>> result;
                 };
 
                 template <>
                 struct _selector<false>
                 {
                     typedef Loki::Typelist<typename PrevHead::Head,
-                        Loki::Typelist<Head, Loki::Typelist<Target, Loki::EmptyType>>>
+                        Loki::Typelist<Head, Loki::Typelist<Target, Loki::NullType>>>
                         result;
                 };
 
@@ -258,7 +258,7 @@ struct CMatcher
         };
 
         template <>
-        struct CMatchHelper3<Loki::EmptyType>
+        struct CMatchHelper3<Loki::NullType>
         {
             typedef typename CMatchHelper<typename T::Tail>::result result;
         };
@@ -290,9 +290,9 @@ struct CMatcher
     };
 
     template <>
-    struct CMatchHelper<Loki::EmptyType>
+    struct CMatchHelper<Loki::NullType>
     {
-        typedef Loki::EmptyType result;
+        typedef Loki::NullType result;
     };
 
     typedef typename CMatchHelper<cast_type_list>::result result;
@@ -326,7 +326,7 @@ struct conversion_sequence
                 typedef search_result result;
             };
 
-            typedef typename selector<is_type<Loki::EmptyType, search_result>::value>::result result;
+            typedef typename selector<is_type<Loki::NullType, search_result>::value>::result result;
         };
 
         template <bool>
@@ -346,7 +346,7 @@ struct conversion_sequence
                 typedef typename list_iterator<Tail>::result result;
             };
 
-            typedef typename _selector<!is_type<Loki::EmptyType, helper_result>::value>::result result;
+            typedef typename _selector<!is_type<Loki::NullType, helper_result>::value>::result result;
         };
 
         template <>
@@ -369,7 +369,7 @@ struct conversion_sequence
                     typedef typename list_iterator<Tail>::result result;
                 };
 
-                typedef typename _selector2<!is_type<Loki::EmptyType, helper_result>::value>::result result;
+                typedef typename _selector2<!is_type<Loki::NullType, helper_result>::value>::result result;
             };
 
             template <>
@@ -386,9 +386,9 @@ struct conversion_sequence
     };
 
     template <>
-    struct list_iterator<Loki::EmptyType>
+    struct list_iterator<Loki::NullType>
     {
-        typedef Loki::EmptyType result;
+        typedef Loki::NullType result;
     };
 
     template <int length>
@@ -410,7 +410,7 @@ struct conversion_sequence
             typedef typename list_iterator<cast_type_list>::result result;
         };
 
-        typedef typename _selector<!is_type<Loki::EmptyType, nearest>::value>::result result;
+        typedef typename _selector<!is_type<Loki::NullType, nearest>::value>::result result;
     };
 
     template <>
@@ -422,7 +422,7 @@ struct conversion_sequence
     template <>
     struct selector<0>
     {
-        typedef Loki::EmptyType result;
+        typedef Loki::NullType result;
     };
 
     typedef typename selector<max_length>::result result;
@@ -451,7 +451,7 @@ struct CSmartCaster
     };
 
     template <>
-    struct CHelper<Loki::EmptyType>
+    struct CHelper<Loki::NullType>
     {
         IC static Target* smart_cast(Head* p) { return (SmartDynamicCast::smart_cast<Target>(p)); }
     };
@@ -474,7 +474,7 @@ struct CSmartMatcher
     }
 
     template <>
-    IC static T1* smart_cast<Loki::EmptyType>(T2* p)
+    IC static T1* smart_cast<Loki::NullType>(T2* p)
     {
 #ifdef SHOW_SMART_CAST_UNOPTIMIZED_CASES
 #pragma todo("Dima to all : this smart_cast is not optimized!")