diff --git a/3party/cttrie/README.md b/3party/cttrie/README.md
new file mode 100644
index 0000000..79748dd
--- /dev/null
+++ b/3party/cttrie/README.md
@@ -0,0 +1,28 @@
+# Compile-time TRIE based string matcher (C++11)
+
+Usage:
+
+```
+#include "cttrie.h"
+
+...
+
+  TRIE(str)
+    ... error case
+  CASE("abc")
+    ... str matches abc ...
+  CASE("ad")
+    ... etc
+  ENDTRIE;   // <- trailing semicolon!
+```
+
+* compile with optimization enabled!
+* cases may return a value (see e.g. test_cttrie.cpp)
+  -> return types must match! (deduced from error case)
+
+#### => [Slides](https://smilingthax.github.io/slides/cttrie/)
+
+Copyright (c) 2016 Tobias Hoffmann
+
+License: http://opensource.org/licenses/MIT
+
diff --git a/3party/cttrie/cstr.h b/3party/cttrie/cstr.h
new file mode 100644
index 0000000..d6e9e61
--- /dev/null
+++ b/3party/cttrie/cstr.h
@@ -0,0 +1,30 @@
+#ifndef _CSTR_H
+#define _CSTR_H
+
+// C++2x: std::fixed_string ?
+
+template <unsigned char... Chars>
+struct string_t {
+  static constexpr unsigned int size() {
+    return sizeof...(Chars);
+  }
+  static const char *data() {
+    static constexpr const char data[]={Chars...};
+    return data;
+  }
+};
+
+namespace detail {
+template <typename Str,unsigned int N,unsigned char... Chars>
+struct make_string_t : make_string_t<Str,N-1,Str().chars[N-1],Chars...> {};
+
+template <typename Str,unsigned char... Chars>
+struct make_string_t<Str,0,Chars...> { typedef string_t<Chars...> type; };
+} // namespace detail
+
+#define CSTR(str) []{ \
+    struct Str { const char *chars = str; }; \
+    return typename ::detail::make_string_t<Str,sizeof(str)>::type(); \
+  }()
+
+#endif
diff --git a/3party/cttrie/cttrie-print.h b/3party/cttrie/cttrie-print.h
new file mode 100644
index 0000000..791c6af
--- /dev/null
+++ b/3party/cttrie/cttrie-print.h
@@ -0,0 +1,36 @@
+#ifndef _CTTRIE_PRINT_H
+#define _CTTRIE_PRINT_H
+
+#include "cttrie.h"
+#include <stdio.h>
+
+namespace CtTrie {
+
+// <typename String>  would be ambiguous...
+template <unsigned char... Chars,unsigned int I>
+void printTrie_hlp(string_t<Chars...> s,Transition<-1,int_c<I>>)
+{
+  printf("%d: %.*s\n",I,s.size(),s.data());
+}
+
+template <typename String=string_t<>>
+void printTrie(TrieNode<>)
+{
+}
+
+template <unsigned char... Chars,int Ch0,typename Next>
+void printTrie_hlp(string_t<Chars...>,Transition<Ch0,Next>)
+{
+  printTrie<string_t<Chars...,Ch0>>(Next());
+}
+
+template <typename String=string_t<>,typename Transition0,typename... Transitions>
+void printTrie(TrieNode<Transition0,Transitions...>)
+{
+  printTrie_hlp(String(),Transition0());
+  printTrie<String>(TrieNode<Transitions...>());
+}
+
+} // namespace CtTrie
+
+#endif
diff --git a/3party/cttrie/cttrie.h b/3party/cttrie/cttrie.h
new file mode 100644
index 0000000..3946c8b
--- /dev/null
+++ b/3party/cttrie/cttrie.h
@@ -0,0 +1,187 @@
+#ifndef _CTTRIE_H
+#define _CTTRIE_H
+
+/* Usage:
+
+  TRIE(str)
+    ... error case
+  CASE("abc")
+    ... str matches abc ...
+  CASE("ad")
+    ... etc
+  ENDTRIE;   // <- trailing semicolon!
+
+  - compile with optimization enabled!
+  - cases may return a value
+    -> return types must match! (deduced from error case)
+
+*/
+
+#include "cstr.h"
+#include "getindex.h"
+#include "stringview.h"
+#include <type_traits>
+
+namespace CtTrie {
+
+using pack_tools::detail::int_c;
+
+template <int Char,typename Next>
+struct Transition {};
+
+// multiple inheritance required for cttrie_sw256 ...
+template <typename... Transitions>
+struct TrieNode : Transitions... {};
+
+namespace detail {
+  struct nil {};
+
+  // template <bool B> using Sfinae=char(*)[2*B-1]; // just [B] does not work with MSVC and clang; MSVC still does weird things with [2*B-1]...
+  template <bool B> using Sfinae=typename std::enable_if<B>::type;
+
+  // not available in c++11
+  template <unsigned int... Is>
+  struct index_sequence {};
+
+  template <unsigned int N,unsigned int... Is,typename =Sfinae<N==0>>
+  constexpr index_sequence<Is...> make_index_sequence(...)
+  { return {}; }
+
+  template <unsigned int N,unsigned int... Is,typename =Sfinae<(N>0)>>
+  constexpr auto make_index_sequence(...)
+    -> decltype(make_index_sequence<N-1,N-1,Is...>(nil())) // argument forces ADL
+  { return {}; }
+
+  // end of new chain
+  template <unsigned int Index>
+  constexpr Transition<-1,int_c<Index>> transitionAdd(nil,string_t<0>) // strip trailing '\0'
+  { return {}; }
+//  constexpr Transition<-1,int_c<Index>> transitionAdd(nil,string_t<>) { return {}; }
+
+  // create new chain
+  template <unsigned int Index,unsigned char Ch0,unsigned char... Chars>
+  constexpr Transition<Ch0,TrieNode<decltype(transitionAdd<Index>(nil(),string_t<Chars...>()))>> transitionAdd(nil,string_t<Ch0,Chars...>)
+  { return {}; }
+
+  template <unsigned int Index,unsigned char... Chars,typename... Prefix,typename... Transitions,
+            typename =Sfinae<(sizeof...(Chars)==0 || sizeof...(Transitions)==0)>>
+  constexpr auto insertSorted(nil,string_t<Chars...> s,TrieNode<Prefix...>,Transitions...)
+    -> TrieNode<Prefix...,decltype(transitionAdd<Index>(nil(),s)),Transitions...>
+  { return {}; }
+
+  template <unsigned int Index,unsigned char Ch0,unsigned char... Chars,typename... Prefix,int Ch,typename Next,typename... Transitions,
+            typename =Sfinae<(Ch>Ch0)>>
+  constexpr auto insertSorted(nil,string_t<Ch0,Chars...> s,TrieNode<Prefix...>,Transition<Ch,Next>,Transitions...)
+    -> TrieNode<Prefix...,decltype(transitionAdd<Index>(nil(),s)),Transition<Ch,Next>,Transitions...>
+  { return {}; }
+
+  template <unsigned int Index,typename String,typename... Transitions>
+  constexpr auto trieAdd(TrieNode<Transitions...>)
+    -> decltype(insertSorted<Index>(nil(),String(),TrieNode<>(),Transitions()...)) // nil forces adl
+  { return {}; }
+
+  template <unsigned int Index,unsigned char Ch0,unsigned char... Chars,typename... Prefix,int Ch,typename Next,typename... Transitions,
+            typename =Sfinae<(Ch==Ch0)>>
+  constexpr auto insertSorted(nil,string_t<Ch0,Chars...> s,TrieNode<Prefix...>,Transition<Ch,Next>,Transitions...)
+    -> TrieNode<Prefix...,Transition<Ch,decltype(trieAdd<Index,string_t<Chars...>>(Next()))>,Transitions...>
+  { return {}; }
+
+  template <unsigned int Index,unsigned char Ch0,unsigned char... Chars,typename... Prefix,int Ch,typename Next,typename... Transitions,
+            typename =Sfinae<(Ch<Ch0)>>
+  constexpr auto insertSorted(nil,string_t<Ch0,Chars...> s,TrieNode<Prefix...>,Transition<Ch,Next>,Transitions...)
+    -> decltype(insertSorted<Index>(nil(),s,TrieNode<Prefix...,Transition<Ch,Next>>(),Transitions()...))
+  { return {}; }
+
+  template <unsigned int I>
+  constexpr TrieNode<> makeTrie(nil) // nil forces adl
+  { return {}; }
+
+  template <unsigned int I,typename String0,typename... Strings>
+  constexpr auto makeTrie(nil,String0,Strings...)
+    -> decltype(trieAdd<I,String0>(makeTrie<I+1>(nil(),Strings()...)))
+  { return {}; }
+
+#if 1
+  #include "cttrie_sw32.tcc"
+  #include "cttrie_sw256.tcc"
+#else
+  template <typename Stringview,typename... Transitions,typename FnE,typename... Fns>
+  auto Switch(unsigned char ch,Stringview&& str,TrieNode<Transitions...>,FnE&& fne,Fns&&... fns)
+    -> decltype(fne())
+  {
+    switch (ch) {
+    { case (Transitions::Char):
+        return checkTrie(Transitions::Next(),(Stringview&&)str,(FnE&&)fne,(Fns&&)fns...); }...
+    }
+    return fne();
+  }
+#endif
+
+  // handle trivial cases already here
+  template <typename Stringview,typename FnE,typename... Fns>
+  constexpr auto checkTrie(TrieNode<>,Stringview&&,FnE&& fne,Fns&&...) // possible via Transition<-1>
+    -> decltype(fne())
+  {
+    return fne();
+  }
+  template <int Char,typename Next,typename Stringview,typename FnE,typename... Fns,typename =Sfinae<(Char>=0)>>
+  constexpr auto checkTrie(TrieNode<Transition<Char,Next>>,Stringview&& str,FnE&& fne,Fns&&... fns)
+    -> decltype(fne())
+  {
+    return (!str.empty() && (*str==Char)) ? checkTrie(Next(),str.substr(1),(FnE&&)fne,(Fns&&)fns...) : fne();
+  }
+
+  template <typename... Transitions,typename Stringview,typename FnE,typename... Fns>
+  constexpr auto checkTrie(TrieNode<Transitions...> trie,Stringview&& str,FnE&& fne,Fns&&... fns)
+    -> decltype(fne())
+  {
+    return (!str.empty()) ? Switch(*str,str.substr(1),trie,(FnE&&)fne,(Fns&&)fns...) : fne();
+  }
+
+  template <unsigned int Index,typename... Transitions,typename Stringview,typename FnE,typename... Fns>
+  constexpr auto checkTrie(TrieNode<Transition<-1,int_c<Index>>,Transitions...>,Stringview&& str,FnE&& fne,Fns&&... fns)
+    -> decltype(fne())
+  {
+    return (str.empty()) ? pack_tools::get_index<Index>((Fns&&)fns...)()
+                         : checkTrie(TrieNode<Transitions...>(),(Stringview&&)str,(FnE&&)fne,(Fns&&)fns...);
+  }
+
+  template <unsigned int... Is,typename Stringview,typename ArgE,typename... Args>
+  constexpr auto doTrie(index_sequence<Is...>,Stringview&& str,ArgE&& argE,Args&&... args)
+    -> decltype(argE())
+  {
+    return checkTrie(makeTrie<0>(nil(),pack_tools::get_index<(2*Is)>((Args&&)args...)...),
+                     (Stringview&&)str,(ArgE&&)argE,
+                     pack_tools::get_index<(2*Is+1)>((Args&&)args...)...);
+  }
+
+} // namespace detail
+
+template <typename TrieNode,typename Stringview,typename FnE,typename... Fns>
+constexpr auto checkTrie(TrieNode trie,Stringview&& str,FnE&& fne,Fns&&... fns)
+  -> decltype(fne())
+{
+  return detail::checkTrie(trie,(Stringview&&)str,(FnE&&)fne,(Fns&&)fns...); // also used for adl dance
+}
+
+template <typename Stringview,typename ArgE,typename... Args>
+constexpr auto doTrie(Stringview&& str,ArgE&& argE,Args&&... args)
+  -> decltype(argE())
+{
+  return detail::doTrie(detail::make_index_sequence<sizeof...(args)/2>(),(Stringview&&)str,(ArgE&&)argE,(Args&&)args...);
+}
+
+// Strings must be string_t
+template <typename... Strings>
+constexpr auto makeTrie(Strings... strs)
+  -> decltype(detail::makeTrie<0>(detail::nil(),strs...))
+{ return {}; }
+
+} // namespace CtTrie
+
+#define TRIE(str)  TRIE2(stringview,str)
+#define TRIE2(sv,str)  CtTrie::doTrie<sv>((str),[&]{
+#define CASE(str)      },CSTR(str),[&]{
+#define ENDTRIE        })
+
+#endif
diff --git a/3party/cttrie/cttrie_sw256-boost.tcc b/3party/cttrie/cttrie_sw256-boost.tcc
new file mode 100644
index 0000000..e8ae982
--- /dev/null
+++ b/3party/cttrie/cttrie_sw256-boost.tcc
@@ -0,0 +1,69 @@
+
+#include <boost/preprocessor/repetition/repeat.hpp>
+#include <boost/preprocessor/punctuation/comma_if.hpp>
+
+#define XREP 256
+
+// or:  typedef decltype(make_index_sequence<256>()) base_seq;
+typedef index_sequence<
+#define X(z,n,data) BOOST_PP_COMMA_IF(n) n                 // or: just use  X() n   +   BOOST_PP_ENUM(XREP,X,dummy)
+  BOOST_PP_REPEAT(XREP,X,dummy)
+#undef X
+  > base_seq;
+
+template <typename...> struct type_array {};
+
+// requires TrieNode to multiple inherit all Transitions
+template <int Char,typename Next>
+constexpr Next select(Transition<Char,Next>)
+{ return {}; }
+
+template <int Char>
+constexpr nil select(...)
+{ return {}; }
+
+template <typename TrieNode,unsigned int... Is>
+constexpr auto mkidx(TrieNode trie,index_sequence<Is...>)
+  -> type_array<decltype(select<Is>(trie))...>
+{ return {}; }
+
+// c++17: constexpr if
+template <typename T> struct is_nil { static constexpr bool value = false; }; // ... : false_type
+template <> struct is_nil<nil> { static constexpr bool value = true; }; // or: std::is_same
+
+template <typename Stringview,typename FnE,typename... Fns> // never called, but must be instantiable ...
+constexpr auto checkTrie(nil,Stringview&& str,FnE&& fne,Fns&&... fns)
+  -> decltype(fne())
+{
+  return fne();
+}
+
+template <typename Stringview,
+#define X(z,n,data) data ## n,
+  BOOST_PP_REPEAT(XREP,X,typename A)
+#undef X
+  typename FnE,typename... Fns>
+/*constexpr*/ auto Switch256(unsigned char ch,Stringview&& str,type_array<
+#define X(z,n,data) BOOST_PP_COMMA_IF(n) data ## n
+  BOOST_PP_REPEAT(XREP,X,A)
+#undef X
+  >,FnE&& fne,Fns&&... fns)
+  -> decltype(fne())
+{
+  switch (ch) {
+#define X(z,n,data) case n : if (is_nil<data ## n>::value) break; return checkTrie(data ## n (),(Stringview&&)str,(FnE&&)fne,(Fns&&)fns...);
+  BOOST_PP_REPEAT(XREP,X,A)
+#undef X
+  }
+  return fne();
+}
+
+template <typename Stringview,typename TrieNode,typename FnE,typename... Fns>
+constexpr auto Switch(unsigned char ch,Stringview&& str,TrieNode trie,FnE&& fne,Fns&&... fns)
+  -> decltype(fne())
+{
+  return Switch256(ch,(Stringview&&)str,mkidx(trie,base_seq()),(FnE&&)fne,(Fns&&)fns...);
+}
+
+#undef XREP
+
diff --git a/3party/cttrie/cttrie_sw256.tcc b/3party/cttrie/cttrie_sw256.tcc
new file mode 100644
index 0000000..07614be
--- /dev/null
+++ b/3party/cttrie/cttrie_sw256.tcc
@@ -0,0 +1,81 @@
+
+#define X16(p) \
+  X(p,0) SEP X(p,1) SEP X(p,2) SEP X(p,3) SEP X(p,4) SEP X(p,5) SEP X(p,6) SEP X(p,7) SEP \
+  X(p,8) SEP X(p,9) SEP X(p,a) SEP X(p,b) SEP X(p,c) SEP X(p,d) SEP X(p,e) SEP X(p,f)
+
+#define XBLOCK \
+  X16(0) SEP X16(1) SEP X16(2) SEP X16(3) SEP X16(4) SEP X16(5) SEP X16(6) SEP X16(7) SEP \
+  X16(8) SEP X16(9) SEP X16(a) SEP X16(b) SEP X16(c) SEP X16(d) SEP X16(e) SEP X16(f)
+
+// or:  typedef decltype(make_index_sequence<256>()) base_seq;
+typedef index_sequence<
+#define X(p,q) 0x ## p ## q
+#define SEP ,
+  XBLOCK
+#undef SEP
+#undef X
+  > base_seq;
+
+template <typename...> struct type_array {};
+
+// requires TrieNode to multiple inherit all Transitions
+template <int Char,typename Next>
+constexpr Next select(Transition<Char,Next>)
+{ return {}; }
+
+template <int Char>
+constexpr nil select(...)
+{ return {}; }
+
+template <typename TrieNode,unsigned int... Is>
+constexpr auto mkidx(TrieNode trie,index_sequence<Is...>)
+  -> type_array<decltype(select<Is>(trie))...>
+{ return {}; }
+
+template <typename T> struct is_nil { static constexpr bool value = false; }; // ... : false_type
+template <> struct is_nil<nil> { static constexpr bool value = true; }; // or: std::is_same
+
+// c++17: constexpr if
+template <typename Stringview,typename FnE,typename... Fns> // never called, but must be instantiable ...
+constexpr auto checkTrie(nil,Stringview&& str,FnE&& fne,Fns&&... fns)
+  -> decltype(fne())
+{
+  return fne();
+}
+
+template <typename Stringview,
+#define X(p,q) typename A ## p ## q
+#define SEP ,
+  XBLOCK,
+#undef SEP
+#undef X
+  typename FnE,typename... Fns>
+/*constexpr*/ auto Switch256(unsigned char ch,Stringview&& str,type_array<
+#define X(p,q) A ## p ## q
+#define SEP ,
+  XBLOCK
+#undef SEP
+#undef X
+  >,FnE&& fne,Fns&&... fns)
+  -> decltype(fne())
+{
+  switch (ch) {
+#define X(p,q) case 0x ## p ## q : if (is_nil<A ## p ## q>::value) break; return checkTrie(A ## p ## q(),(Stringview &&)str,(FnE&&)fne,(Fns&&)fns...);
+#define SEP
+    XBLOCK
+#undef SEP
+#undef X
+  }
+  return fne();
+}
+
+template <typename Stringview,typename TrieNode,typename FnE,typename... Fns>
+constexpr auto Switch(unsigned char ch,Stringview&& str,TrieNode trie,FnE&& fne,Fns&&... fns)
+  -> decltype(fne())
+{
+  return Switch256(ch,(Stringview&&)str,mkidx(trie,base_seq()),(FnE&&)fne,(Fns&&)fns...);
+}
+
+#undef X16
+#undef XBLOCK
+
diff --git a/3party/cttrie/cttrie_sw32-boost.tcc b/3party/cttrie/cttrie_sw32-boost.tcc
new file mode 100644
index 0000000..26c3830
--- /dev/null
+++ b/3party/cttrie/cttrie_sw32-boost.tcc
@@ -0,0 +1,31 @@
+
+#include <boost/preprocessor/iteration/local.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
+#include <boost/preprocessor/punctuation/comma_if.hpp>
+
+#define XSUB1(z,p,data) int Char ## p,typename Next ## p,
+#define XSUB2(z,p,data) BOOST_PP_COMMA_IF(p) Transition<Char ## p,Next ## p>
+#define XSUB3(z,p,data) case Char ## p: return checkTrie(Next ## p(),(Stringview&&)str,(FnE&&)fne,(Fns&&)fns...);
+
+#define BOOST_PP_LOCAL_MACRO(n) \
+  template <typename Stringview, \
+    BOOST_PP_REPEAT(n,XSUB1,dummy) \
+    typename FnE,typename... Fns> \
+  auto Switch(unsigned char ch,Stringview&& str,TrieNode< \
+    BOOST_PP_REPEAT(n,XSUB2,dummy) \
+    >,FnE&& fne,Fns&&... fns) \
+    -> decltype(fne()) \
+  { \
+    switch (ch) { \
+      BOOST_PP_REPEAT(n,XSUB3,dummy) \
+    } \
+    return fne(); \
+  }
+
+#define BOOST_PP_LOCAL_LIMITS (2,32)
+#include BOOST_PP_LOCAL_ITERATE()
+
+#undef XSUB1
+#undef XSUB2
+#undef XSUB3
+
diff --git a/3party/cttrie/cttrie_sw32.tcc b/3party/cttrie/cttrie_sw32.tcc
new file mode 100644
index 0000000..57668dd
--- /dev/null
+++ b/3party/cttrie/cttrie_sw32.tcc
@@ -0,0 +1,167 @@
+
+#define XTMPLATE \
+  template <typename Stringview, \
+    XBLOCK(XSUB1,XCOMMA), \
+    typename FnE,typename... Fns> \
+  auto Switch(unsigned char ch,Stringview&& str,TrieNode< \
+    XBLOCK(XSUB2,XCOMMA) \
+    >,FnE&& fne,Fns&&... fns) \
+    -> decltype(fne()) \
+  { \
+    switch (ch) { \
+      XBLOCK(XSUB3,XSEMIC); \
+    } \
+    return fne(); \
+  }
+
+#define XCOMMA() ,
+#define XSEMIC() ;
+#define XSUB1(p) int Char ## p,typename Next ## p
+#define XSUB2(p) Transition<Char ## p,Next ## p>
+#define XSUB3(p) case Char ## p: return checkTrie(Next ## p(),(Stringview&&)str,(FnE&&)fne,(Fns&&)fns...)
+
+#define XCAT(x,p,q) x(p ## q)
+#define XBLOCK0(p,x,sep) XCAT(x,p,0)
+#define XBLOCK1(p,x,sep) XBLOCK0(p,x,sep) sep() XCAT(x,p,1)
+#define XBLOCK2(p,x,sep) XBLOCK1(p,x,sep) sep() XCAT(x,p,2)
+#define XBLOCK3(p,x,sep) XBLOCK2(p,x,sep) sep() XCAT(x,p,3)
+#define XBLOCK4(p,x,sep) XBLOCK3(p,x,sep) sep() XCAT(x,p,4)
+#define XBLOCK5(p,x,sep) XBLOCK4(p,x,sep) sep() XCAT(x,p,5)
+#define XBLOCK6(p,x,sep) XBLOCK5(p,x,sep) sep() XCAT(x,p,6)
+#define XBLOCK7(p,x,sep) XBLOCK6(p,x,sep) sep() XCAT(x,p,7)
+
+#define XXBLOCK(x,sep)
+#define XXNUM 0
+/* unused
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK0(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+*/
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK1(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK2(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK3(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK4(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK5(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK6(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK7(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#undef XXNUM
+#undef XXBLOCK
+
+#define XXBLOCK(x,sep) XBLOCK7(0,x,sep) sep()
+#define XXNUM 1
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK0(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK1(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK2(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK3(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK4(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK5(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK6(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK7(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#undef XXNUM
+#undef XXBLOCK
+
+#define XXBLOCK(x,sep) XBLOCK7(0,x,sep) sep() XBLOCK7(1,x,sep) sep()
+#define XXNUM 2
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK0(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK1(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK2(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK3(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK4(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK5(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK6(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK7(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#undef XXNUM
+#undef XXBLOCK
+
+#define XXBLOCK(x,sep) XBLOCK7(0,x,sep) sep() XBLOCK7(1,x,sep) sep() XBLOCK7(2,x,sep) sep()
+#define XXNUM 3
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK0(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK1(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK2(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK3(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK4(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK5(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK6(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#define XBLOCK(x,sep) XXBLOCK(x,sep) XBLOCK7(XXNUM,x,sep)
+XTMPLATE
+#undef XBLOCK
+#undef XXNUM
+#undef XXBLOCK
+
+#undef XBLOCK7
+#undef XBLOCK6
+#undef XBLOCK5
+#undef XBLOCK4
+#undef XBLOCK3
+#undef XBLOCK2
+#undef XBLOCK1
+#undef XBLOCK0
+#undef XCAT
+
+#undef XSUB3
+#undef XSUB2
+#undef XSUB1
+#undef XSEMIC
+#undef XCOMMA
+#undef XTMPLATE
+
diff --git a/3party/cttrie/getindex.h b/3party/cttrie/getindex.h
new file mode 100644
index 0000000..eaab2b4
--- /dev/null
+++ b/3party/cttrie/getindex.h
@@ -0,0 +1,43 @@
+#ifndef _GETINDEX_H
+#define _GETINDEX_H
+
+// provides  pack_tools::get_index<I>(Ts&&... ts)
+
+// (similar to what  std::get<I>(std::make_tuple(ts...))  does)
+
+namespace pack_tools {
+
+namespace detail {
+  template <unsigned int> struct int_c {};
+
+  template <unsigned int I>
+  constexpr void *get_index_impl(int_c<I>) // invalid index
+  {
+    return {};
+  }
+
+  template <typename T0,typename... Ts>
+  constexpr T0&& get_index_impl(int_c<0>,T0&& t0,Ts&&...)
+  {
+    return (T0&&)t0;
+  }
+
+  template <unsigned int I,typename T0,typename... Ts>
+  constexpr auto get_index_impl(int_c<I>,T0&&,Ts&&... ts)
+    -> decltype(get_index_impl(int_c<I-1>(),(Ts&&)ts...))
+  {
+    return get_index_impl(int_c<I-1>(),(Ts&&)ts...);
+  }
+} // namespace detail
+
+template <unsigned int I,typename... Ts>
+constexpr auto get_index(Ts&&... ts)
+  -> decltype(detail::get_index_impl(detail::int_c<I>(),(Ts&&)ts...))
+{
+  static_assert((I<sizeof...(Ts)),"Invalid Index");
+  return detail::get_index_impl(detail::int_c<I>(),(Ts&&)ts...);
+}
+
+} // namespace pack_tools
+
+#endif
diff --git a/3party/cttrie/lc_stringview.h b/3party/cttrie/lc_stringview.h
new file mode 100644
index 0000000..6bb7d76
--- /dev/null
+++ b/3party/cttrie/lc_stringview.h
@@ -0,0 +1,20 @@
+#ifndef _LC_STRINGVIEW_H
+#define _LC_STRINGVIEW_H
+
+#include "stringview.h"
+#include <cctype>
+
+struct lc_stringview : public stringview {
+  lc_stringview(const char *s) : stringview(s) {}
+  constexpr lc_stringview(stringview &&s) : stringview(std::move(s)) {}
+
+  char operator*() const {
+    return std::tolower(stringview::operator*());
+  }
+
+  constexpr lc_stringview substr(unsigned int start) const {
+    return stringview::substr(start);
+  }
+};
+
+#endif
diff --git a/3party/cttrie/stringview.h b/3party/cttrie/stringview.h
new file mode 100644
index 0000000..0381a42
--- /dev/null
+++ b/3party/cttrie/stringview.h
@@ -0,0 +1,45 @@
+#ifndef _STRINGVIEW_H
+#define _STRINGVIEW_H
+
+#include <cstring>
+#include <utility>
+
+struct stringview {
+  template <unsigned int N>
+  constexpr stringview(const char (&ar)[N]) : begin(ar),size((ar[N-1]==0) ? N-1 : N) {}  // strips trailing \0     // implicit
+
+  template <typename String,typename Sfinae=decltype(std::declval<String>().c_str(),std::declval<String>().size())>
+  constexpr stringview(String&& str) : begin(str.c_str()),size(str.size()) {}
+
+  stringview(const char *begin) : begin(begin),size(std::strlen(begin)) {}
+
+  constexpr stringview(const char *begin,unsigned int size) : begin(begin),size(size) {}
+
+  constexpr bool empty() const {
+    return (size==0);
+  }
+
+  constexpr char operator*() const {
+    // assert(!empty());  // or: throw ?
+    return *begin;
+  }
+
+  constexpr stringview substr(unsigned int start) const {
+    return { begin+start,
+             (start<size) ? size-start : 0 };
+  }
+
+  // (not actually used by cttrie)
+  constexpr stringview substr(unsigned int start,unsigned int len) const {
+    return { begin+start,
+             (start<size) ?
+               (len<size-start) ? len : size-start
+             : 0 };
+  }
+
+private:
+  const char *begin;
+  unsigned int size;
+};
+
+#endif
diff --git a/3party/cttrie/test_cstr.cpp b/3party/cttrie/test_cstr.cpp
new file mode 100644
index 0000000..9eb3a7c
--- /dev/null
+++ b/3party/cttrie/test_cstr.cpp
@@ -0,0 +1,16 @@
+#include "cstr.h"
+#include <stdio.h>
+
+template <typename String>
+void test(String str) {
+//  struct {}_=String();
+  printf("%d: %s\n",str.size(),str.data());
+}
+
+int main()
+{
+  test(CSTR("Hello"));
+
+  return 0;
+}
+
diff --git a/3party/cttrie/test_cttrie.cpp b/3party/cttrie/test_cttrie.cpp
new file mode 100644
index 0000000..507722c
--- /dev/null
+++ b/3party/cttrie/test_cttrie.cpp
@@ -0,0 +1,35 @@
+#include "cttrie.h"
+#include <stdio.h>
+#include "lc_stringview.h"
+
+int main(int argc,char **argv)
+{
+  const char *str=(argc>1) ? argv[1] : "abc";
+
+  printf("%d\n",
+    TRIE2(lc_stringview,str) return -1;
+    CASE("abc") return 0;
+    CASE("bcd") return 1;
+    ENDTRIE
+  );
+
+  TRIE(str)
+    printf("E\n");
+  CASE("Rosten")
+    printf("6\n");
+  CASE("Raben")
+    printf("0\n");
+  CASE("Rasen")
+    printf("1\n");
+  CASE("Rasten")
+    printf("2\n");
+  CASE("Raster")
+    printf("3\n");
+  CASE("Rastender")
+    printf("4\n");
+  CASE("Raban")
+    printf("5\n");
+  ENDTRIE;
+
+  return 0;
+}
diff --git a/3party/cttrie/test_cttrie_print.cpp b/3party/cttrie/test_cttrie_print.cpp
new file mode 100644
index 0000000..b27699f
--- /dev/null
+++ b/3party/cttrie/test_cttrie_print.cpp
@@ -0,0 +1,20 @@
+#include "cttrie-print.h"
+#include <stdio.h>
+
+int main()
+{
+  auto trie=CtTrie::makeTrie(
+    CSTR("Rosten"),
+    CSTR("Raben"),
+    CSTR("Rasen"),
+    CSTR("Rasten"),
+    CSTR("Raster"),
+    CSTR("Rastender"),
+    CSTR("Raban")
+  );
+  // trie is not constexpr, but decltype(trie) is.
+
+  CtTrie::printTrie(trie);
+
+  return 0;
+}
diff --git a/3party/cttrie/test_getindex.cpp b/3party/cttrie/test_getindex.cpp
new file mode 100644
index 0000000..69c7893
--- /dev/null
+++ b/3party/cttrie/test_getindex.cpp
@@ -0,0 +1,46 @@
+#include "getindex.h"
+#include <stdio.h>
+
+template <unsigned int... Is>
+struct index_list {};
+
+static inline void invoke()
+{
+}
+
+template <typename Fn0,typename... Fns>
+static inline void invoke(Fn0&& fn0,Fns&&... fns)
+{
+  fn0();
+  invoke((Fns&&)fns...);
+}
+
+template <unsigned int... Is,typename... Fns>
+void test1(index_list<Is...>,Fns&&... fns)
+{
+  invoke(pack_tools::get_index<Is>((Fns&&)fns...)...);
+}
+
+template <unsigned int... Is,typename... Ts>
+void test2(Ts&&... args)
+{
+  { const int k[]={printf("%s ",pack_tools::get_index<Is>(args...))...}; (void)k; } // (,0) not needed
+}
+
+int main(int argc,char **argv)
+{
+  test1(index_list<1,0,1>(),[&](){
+    printf("1 %d\n",argc);
+  },[&](){
+    printf("2\n");
+  },[&](){
+    printf("3\n");
+  });
+
+//  printf("%s\n",pack_tools::get_index<0>("The","other","thing"));
+  test2<0,1,1,2>("The","other","thing");
+  printf("\n");
+
+  return 0;
+}
+