eolian-js: Add prototype registration

author: Felipe Magno de Almeida <felipe@expertisesolutions.com.br> 2018-01-17 13:36:59 -0200
committer: Felipe Magno de Almeida <felipe@expertisesolutions.com.br> 2018-01-17 13:36:59 -0200
commit: 166c371e93505adfcc6217c706ec704c30b99450 (patch)
tree: 2b11f1e704a4f7c2400b882fd8ab6202eb5b0d4b
parent: f8e36dce771c6ff0b44e4714437dc143b9354c9a (diff)
download: efl-166c371e93505adfcc6217c706ec704c30b99450.tar.gz
20 files changed, 11969 insertions, 227 deletions
diff --git a/src/Makefile_Efl_Js.am b/src/Makefile_Efl_Js.am
index e253fa70e4..81b4dab9eb 100644
--- a/src/Makefile_Efl_Js.am
+++ b/src/Makefile_Efl_Js.am
@@ -56,14 +56,26 @@ bin_efl_js_eflv8js_LDADD = \
 
 endif
 
-ordered_generated_js_bindings = $(sort $(GENERATED_JS_BINDINGS))
-
 AM_V_EOLJS_LINK = $(am__v_EOLJS_LINK_@AM_V@)
 am__v_EOLJS_LINK_ = $(am__v_EOLJS_LINK_@AM_DEFAULT_V@)
 am__v_EOLJS__LINK_0 = @echo "  EOLJS_LINK  " $@;
 
-bindings/js/efl_js/eolian_js_bindings.js.hh: $(GENERATED_JS_BINDINGS:%.eo.js.cc=%.eo) $(_EOLIAN_JS_DEP)
-	$(AM_V_EOLJS_LINK)$(EOLIAN_JS) -l $(EOLIAN_FLAGS) -o $@ $(filter %.eo, $(^))
+$(elm_legacy_eolian_files:%.eo=%.eo.js.cc): %.eo.js.cc : %.eo $(_EOLIAN_JS_DEP)
+	$(AM_V_EOLJS)$(EOLIAN_JS) $(EOLIAN_FLAGS) -d -o $@ $<
+
+bindings/js/efl_js/eolian_include_generated.js.hh: $(GENERATED_JS_BINDINGS) $(elm_legacy_eolian_files:%.eo=%.eo.js.cc)
+	@echo @ECHO_E@ "" > $@
+	@for i in $(^); do echo "#include <$$i>" >> $@; done
+
+CLEANFILES += bindings/js/efl_js/eolian_js_bindings.js.hh
+
+bindings/js/efl_js/eolian_js_bindings.js.hh bindings/js/efl_js/eolian_js_bindings.js.hh.params: $(GENERATED_JS_BINDINGS:%.eo.js.cc=%.eo) $(_EOLIAN_JS_DEP)
+	echo > $@.params
+	for i in $(addprefix -l ,$(addprefix $(srcdir)/,$(elm_legacy_eolian_files))); do echo "$$i" >> $@.params; done
+	echo -o >> $@.params
+	echo $@ >> $@.params
+	for i in $(filter %.eo, $(^)); do echo "$$i" >> $@.params;done
+	$(AM_V_EOLJS_LINK)$(EOLIAN_JS) --link --params $@.params $(EOLIAN_FLAGS)
 
 CLEANFILES += bindings/js/efl_js/eolian_js_bindings.js.hh
 
@@ -147,7 +159,7 @@ bindings/js/eio_js/eio_js.cc \
 bindings/js/efl_js/efl_js.cc \
 bindings/js/ethumb_js/ethumb_js_client.cc
 
-bindings/js/efl_js/bindings_js_efl_js_libefl_js_la-efl_js.l$(OBJEXT): bindings/js/efl_js/eolian_js_bindings.js.hh
+bindings/js/efl_js/bindings_js_efl_js_libefl_js_la-efl_js.l$(OBJEXT): bindings/js/efl_js/eolian_js_bindings.js.hh bindings/js/efl_js/eolian_include_generated.js.hh
 
 bindings/js/efl_js/efl_js.cc $(bindings_js_efl_js_libefl_js_la_SOURCES): $(ecore_eolian_cxx_public_hh) $(ecore_eolian_cxx_public_impl_hh) $(eo_eolian_cxx_public_hh) $(eo_eolian_cxx_public_impl_hh) $(efl_eolian_cxx_public_hh) $(efl_eolian_cxx_public_impl_hh) lib/ecore/Ecore.eo.hh
 
diff --git a/src/Makefile_Elementary.am b/src/Makefile_Elementary.am
index 5b292a5445..3c521a7ff7 100644
--- a/src/Makefile_Elementary.am
+++ b/src/Makefile_Elementary.am
@@ -97,6 +97,7 @@ elm_public_eolian_files = \
 	lib/elementary/efl_access_window.eo \
 	lib/elementary/efl_config_global.eo \
 	lib/elementary/elm_code_widget.eo \
+	lib/elementary/efl_ui_list_precise_layouter.eo \
 	$(NULL)
 
 # More public files -- FIXME
@@ -220,7 +221,6 @@ elm_legacy_eolian_files = \
 	lib/elementary/elm_slideshow_item.eo \
 	lib/elementary/elm_table.eo \
 	lib/elementary/elm_thumb.eo \
-	lib/elementary/efl_ui_list_precise_layouter.eo \
 	$(NULL)
 
 elm_eolian_type_files = \
diff --git a/src/bin/eolian_js/eolian/grammar/class_registration.hpp b/src/bin/eolian_js/eolian/grammar/class_registration.hpp
index 11ab61f4bf..d6e5cac4b4 100644
--- a/src/bin/eolian_js/eolian/grammar/class_registration.hpp
+++ b/src/bin/eolian_js/eolian/grammar/class_registration.hpp
@@ -4,6 +4,10 @@
 #include <grammar/klass_def.hpp>
 #include <grammar/indentation.hpp>
 #include <grammar/string.hpp>
+#include <grammar/attribute_reorder.hpp>
+#include <grammar/attributed.hpp>
+#include <grammar/attribute_replace.hpp>
+#include <eolian/grammar/stub_function_definition.hpp>
 
 namespace eolian { namespace js { namespace grammar {
 
@@ -38,25 +42,91 @@ struct class_registration_generator
 
     as_generator
       (
-          "namespace efl { namespace js { namespace binding { namespace {\nstatic void register_"
+       *stub_function_definition(cls)
+      ).generate(sink, cls.functions, context);
+    
+    as_generator
+      (
+       attribute_reorder<0, 1, 2, 3, 0, 1, 0, 1>
+       (
+         "static void register_prototype_"
+       << lower_case[*(string << "_")]
+       << lower_case[string]
+       << "(v8::Handle<v8::Object> global, v8::Local<v8::ObjectTemplate> prototype, v8::Isolate* isolate)\n"
+       << "{\n"
+       << *attribute_reorder<1, 1, 1, 1>
+           (
+               scope_tab << "prototype->Set( ::efl::eina::js::compatibility_new<v8::String>(isolate, \""
+            << attribute_replace(&eolian::js::format::format_method)[string] << "\")\n"
+            << scope_tab(2) << ", ::efl::eina::js::compatibility_new<v8::FunctionTemplate>(isolate\n"
+            << scope_tab(3) << ", & ::efl::js::binding::stub_function_"
+            << attributed(std::make_tuple(cls.namespaces, cls.cxx_name))
+               [
+                   lower_case[*(string << "_")]
+                << lower_case[string] << "_"
+               ]
+            << lower_case[string]
+       << "));\n"
+           )
+       << 
+        *(
+            scope_tab << "register_prototype_"
+            << lower_case[*(string << "_")]
+            << lower_case[string]
+            << "(global, prototype, isolate);\n"
+         )
+       << "}\nvoid register_constructor_"
+       << lower_case[*(string << "_")]
+       << lower_case[string]
+       << "(v8::Handle<v8::Object> global, v8::Local<v8::FunctionTemplate> constructor, v8::Isolate* isolate)\n"
+       << "{\n"
+       << scope_tab << "v8::Local<v8::ObjectTemplate> instance = constructor->InstanceTemplate();\n"
+       << scope_tab << "instance->SetInternalFieldCount(1);\n"
+       << scope_tab << "v8::Local<v8::ObjectTemplate> prototype = constructor->PrototypeTemplate();\n"
+       << scope_tab << "register_prototype_"
+       << lower_case[*(string << "_")]
+       << lower_case[string]
+       << "(global, prototype, isolate);\n"
+       << "}\n"
+        )).generate(sink, std::make_tuple(cls.namespaces, cls.cxx_name, cls.functions, cls.immediate_inherits), context);
+    
+    as_generator
+      (
+       attribute_reorder<0, 1, 0, 1, 0, 1, 0, 1>
+       (
+         "v8::Local<v8::Function> register_"
        << lower_case[*(string << "_")]
        << lower_case[string]
        << "(v8::Handle<v8::Object> global, v8::Isolate* isolate)\n"
        << "{\n"
        << scope_tab << "v8::Handle<v8::FunctionTemplate> constructor = ::efl::eina::js::compatibility_new<v8::FunctionTemplate>\n"
-       << scope_tab << scope_tab << "(isolate, & ::efl::eo::js::constructor, ::efl::eina::js::compatibility_new<v8::External>(isolate, const_cast<Efl_Class*>("<< class_name << ")));\n"
+       << scope_tab(2) << "(isolate, & ::efl::eo::js::constructor, ::efl::eina::js::compatibility_new<v8::External>(isolate, const_cast<Efl_Class*>("<< class_name << ")));\n"
+       << scope_tab << "register_constructor_"
+       << lower_case[*(string << "_")]
+       << lower_case[string]
+       << "(global, constructor, isolate);\n"
        << scope_tab << "(void)" << class_name << ";\n"
        << scope_tab << "(void)global; (void)isolate; (void)constructor;\n"
+       << scope_tab << "return constructor->GetFunction();\n"
        << "}\n"
-       << "} } } } // namespace efl { namespace js { namespace binding { namespace {\n\n"
-       ).generate(sink, std::make_tuple(cls.namespaces, cls.cxx_name), context);
+       << "struct register_"
+       << lower_case[*(string << "_")]
+       << lower_case[string]
+       << "_functor\n{\n"
+       << scope_tab << "v8::Local<v8::Function> operator()(v8::Handle<v8::Object> global, v8::Isolate* isolate)\n"
+       << scope_tab << "{\n" << scope_tab(2) << "return ::efl::js::binding::register_"
+       << lower_case[*(string << "_")]
+       << lower_case[string]
+       << "(global, isolate);\n"
+       << scope_tab << "}\n"
+       << "};\n"
+       )).generate(sink, std::make_tuple(cls.namespaces, cls.cxx_name), context);
 
     // constructors ?
 
     // v8::Handle<v8::FunctionTemplate> constructor = ::efl::eina::js::compatibility_new<v8::FunctionTemplate>
     //  (isolate, &efl::eo::js::constructor, efl::eina::js::compatibility_new<v8::External>(isolate, const_cast<Efl_Class*>(EFL_UI_WIN_CLASS)));
 
-    
     // methods
 
     // events
diff --git a/src/bin/eolian_js/eolian/grammar/stub_function_definition.hpp b/src/bin/eolian_js/eolian/grammar/stub_function_definition.hpp
new file mode 100644
index 0000000000..d5d7169431
--- /dev/null
+++ b/src/bin/eolian_js/eolian/grammar/stub_function_definition.hpp
@@ -0,0 +1,110 @@
+#ifndef EOLIAN_JS_STUB_FUNCTION_DEFINITION_HPP
+#define EOLIAN_JS_STUB_FUNCTION_DEFINITION_HPP
+
+#include <grammar/klass_def.hpp>
+#include <grammar/indentation.hpp>
+#include <grammar/string.hpp>
+#include <grammar/attribute_reorder.hpp>
+
+namespace eolian { namespace js { namespace grammar {
+
+namespace attributes = efl::eolian::grammar::attributes;
+
+struct stub_function_definition_generator
+{
+  stub_function_definition_generator(attributes::klass_def klass)
+    : klass(klass) {}
+  
+  template <typename OutputIterator, typename Context>
+  bool generate(OutputIterator sink, attributes::function_def const& f, Context const& context) const
+  {
+    using namespace efl::eolian::grammar;
+    using efl::eolian::grammar::attributes::unused;
+
+     // std::string suffix;
+     // switch(cls.type)
+     //   {
+     //   case attributes::class_type::regular:
+     //   case attributes::class_type::abstract_:
+     //     suffix = "CLASS";
+     //     break;
+     //   case attributes::class_type::mixin:
+     //     suffix = "MIXIN";
+     //     break;
+     //   case attributes::class_type::interface_:
+     //     suffix = "INTERFACE";
+     //     break;
+     //   }
+
+    std::size_t ins = 0;
+    for(auto&& parameters : f.parameters)
+      {
+        if(parameters.direction == attributes::parameter_direction::in)
+          ++ins;
+      }
+    
+    as_generator
+      (
+       //attribute_reorder<0, 1, 0, 1, 0, 1>
+       (
+        "eina::js::compatibility_return_type stub_function_"
+       << lower_case[*(string << "_")]
+       << lower_case[string]
+       << "_"
+       << lower_case[string]
+       << "(eina::js::compatibility_callback_info_type args)\n"
+       << "{\n"
+        << scope_tab << "if(/*input_parameters*/" << std::to_string(ins) << " != args.Length())\n"
+       << scope_tab << "{\n"
+       << scope_tab(2) << "v8::Local<v8::Object> self = args.This();\n"
+       << scope_tab(2) << "v8::Local<v8::Value> external = self->GetInternalField(0);\n"
+       << scope_tab(2) << "Eo* eo = static_cast<Eo*>(v8::External::Cast(*external)->Value());\n"
+       << scope_tab(2) << "try\n"
+       << scope_tab(2) << "{\n"
+       << scope_tab(3) << ";"
+       << scope_tab(2) << "}\n"
+       << scope_tab(2) << "catch(std::logic_error const&)\n"
+       << scope_tab(2) << "{\n"
+       << scope_tab(3) << "return eina::js::compatibility_return();\n"
+       << scope_tab(2) << "}\n"
+       << scope_tab << "}\n"
+       << scope_tab << "else\n"
+       << scope_tab << "{\n"
+       << scope_tab(2) << "return eina::js::compatibility_throw\n"
+       << scope_tab(3) << "(v8::Exception::TypeError\n"
+       << scope_tab(4) << "(eina::js::compatibility_new<v8::String>(nullptr, \"Expected more arguments for this call\")));\n"
+       << scope_tab << "}\n"
+       << "}\n"
+       )).generate(sink, std::make_tuple(klass.namespaces, klass.cxx_name, f.name), context);
+    
+    // methods
+
+    // events
+    
+    return true;
+  }
+
+  attributes::klass_def klass;
+};
+
+
+struct stub_function_definition_generator_
+{
+  stub_function_definition_generator operator()(attributes::klass_def const& klass) const
+  {
+    return {klass};
+  }
+} const stub_function_definition = {};
+      
+} } }
+
+namespace efl { namespace eolian { namespace grammar {
+
+template <>
+struct is_generator< ::eolian::js::grammar::stub_function_definition_generator> : std::true_type {};
+template <>
+struct is_eager_generator< ::eolian::js::grammar::stub_function_definition_generator> : std::true_type {};
+      
+} } }
+
+#endif
diff --git a/src/bin/eolian_js/main.cc b/src/bin/eolian_js/main.cc
index a68e7cbb16..6d755da249 100644
--- a/src/bin/eolian_js/main.cc
+++ b/src/bin/eolian_js/main.cc
@@ -438,9 +438,11 @@ int main(int argc, char** argv)
   namespace format = eolian::js::format;
 
   std::vector<std::string> include_paths;
-  std::string out_file, in_file;
+  std::string out_file, in_file, params_file;
   std::vector<std::string> in_files;
   bool linking = false;
+  std::set<Eolian_Class const*> legacy_klasses;
+  bool dummy_generation = false;
 
   efl::eina::eina_init eina_init;
   struct eolian_init
@@ -453,49 +455,197 @@ int main(int argc, char** argv)
     {
        { "in",        required_argument, 0,  'I' },
        { "out-file",  required_argument, 0,  'o' },
+       { "legacy",    required_argument, 0,  'l' },
        { "version",   no_argument,       0,  'v' },
        { "help",      no_argument,       0,  'h' },
-       { "link",      no_argument,       0,  'l' },
+       { "link",      no_argument,       0,  'i' },
+       { "params",    required_argument, 0,  'p' },
+       { "dummy",     no_argument,       0,  'd' },
        { 0,           0,                 0,   0  }
     };
-   const char* options = "I:D:o:c:arvhl";
+   const char* options = "I:o:l:p:vhid";
 
-   // get command line options
-   int c, idx;
-   while ( (c = getopt_long(argc, argv, options, long_options, &idx)) != -1)
+   Eolian* eolian = eolian_new();
+   Eolian_Unit* eolian_unit = static_cast<Eolian_Unit*>(static_cast<void*>(eolian));
+
+   auto cmd_options = [&] (char c)
      {
         if (c == 'I')
           {
-            include_paths.push_back(optarg);
-            std::cout << "-I" << optarg << std::endl;
+            if (!::eolian_directory_scan(eolian, optarg))
+              {
+                EINA_CXX_DOM_LOG_WARN(eolian::js::domain)
+                << "Couldn't load eolian from '" << optarg << "'.";
+              }
           }
         else if (c == 'o')
           {
             if(!out_file.empty())
               {
                 // _usage(argv[0]);
-                return 1;
+                exit(1);
               }
+            std::cout << "out file " << optarg << std::endl;
             out_file = optarg;
           }
         else if (c == 'h')
           {
              // _usage(argv[0]);
-            return 1;
+            exit(1);
           }
         else if (c == 'v')
           {
              // _print_version();
              // if (argc == 2) exit(EXIT_SUCCESS);
           }
-        else if(c == 'l')
+        else if(c == 'i')
           {
             linking = true;
           }
+        else if(c == 'l')
+          {
+            // legacy  file
+            // std::cout << "legacy file|" << optarg << '|' << std::endl;
+            // if (!::eolian_file_parse(eolian, optarg))
+            //   {
+            //      std::cout
+            //        << "Failed parsing: " << optarg << "." << std::endl;
+            //      EINA_CXX_DOM_LOG_WARN(eolian::js::domain)
+            //        << "Failed parsing: " << optarg << ".";
+            //      assert(false && "Error parsing input file");
+            //   }
+            // char* dup = strdup(optarg);
+            // char *bn = basename(dup);
+            
+            // Eolian_Class const* klass = ::eolian_class_get_by_file(eolian_unit, bn);
+
+            // free(dup);
+            
+            // std::cout << " class pointer " << klass << std::endl;
+            // assert(!!klass);
+            // legacy_klasses.insert(klass);
+          }
+        else if(c == 'p')
+          {
+            params_file = optarg;
+          }
+        else if(c == 'd')
+          {
+            dummy_generation = true;
+          }
+     };
+   
+   // get command line options
+   int c, idx = 0;
+   while ( (c = getopt_long(argc, argv, options, long_options, &idx)) != -1)
+     {
+       std::cout << "reading, idx " << idx << " optind " << optind << std::endl;
+       std::cout << "char " << (char)c << std::endl;
+       cmd_options(c);
      }
 
-   std::cout << "optind " << optind << " argc " << argc << std::endl;
+     if(!linking)
+       {
+         if (optind == argc-1)
+           {
+             in_file = argv[optind];
+           }
+       }
+     else
+       {
+         if (!::eolian_all_eot_files_parse(eolian))
+           {
+             EINA_CXX_DOM_LOG_WARN(eolian::js::domain)
+               << "Eolian failed parsing eot files";
+             assert(false && "Error parsing eot files");
+           }
+         int optional_index = optind;
+         while (optional_index != argc)
+           {
+             std::cout << "opening " << argv[optional_index] << std::endl;
+             if (!::eolian_file_parse(eolian, argv[optional_index]))
+               {
+                 std::cout
+                   << "Failed parsing: " << argv[optional_index] << "." << std::endl;
+                 EINA_CXX_DOM_LOG_WARN(eolian::js::domain)
+                   << "Failed parsing: " << argv[optional_index] << ".";
+                 assert(false && "Error parsing input file");
+               }
+             in_files.push_back(argv[optind]);
+             optional_index++;
+           }
+       }
+   
+   if(!params_file.empty())
+     {
+       std::ifstream param_stream(params_file.c_str());
+       if(param_stream.is_open())
+         {
+           std::vector<std::string> lines{argv[0]};
+           std::string line;
+           while(std::getline(param_stream, line))
+             {
+               std::cout << "line read " << line << std::endl;
+               if(!line.empty())
+                 lines.push_back(line);
+             }
+
+           std::vector<const char*> more_args(lines.size());
+           std::size_t i = 0;
+           for(auto&& l : lines)
+             {
+               more_args[i] = l.c_str();
+               ++i;
+             }
+           optind = 1;
+           idx = 0;
+           while ( (c = getopt_long(lines.size(), const_cast<char*const*>(&more_args[0]), options, long_options, &idx)) != -1)
+             {
+               std::cout << "reading, idx " << idx << " optind " << optind << std::endl;
+               std::cout << "char " << (char)c << std::endl;
+               cmd_options(c);
+             }
+           std::cout << "while finished idx " << idx << " optind " << optind << std::endl;
+
+           if(!linking)
+             {
+               if (optind == more_args.size()-1)
+                 {
+                   in_file = lines[optind];
+                 }
+             }
+           else
+             {
+               if (!::eolian_all_eot_files_parse(eolian))
+                 {
+                   EINA_CXX_DOM_LOG_WARN(eolian::js::domain)
+                     << "Eolian failed parsing eot files";
+                   assert(false && "Error parsing eot files");
+                 }
+               int optional_index = optind;
+               std::cout << "optional_index " << optional_index << std::endl;
+               assert(optional_index <= more_args.size());
+               while (optional_index != more_args.size())
+                 {
+                   std::cout << "opening in params " << lines[optional_index] << std::endl;
+                   if (!::eolian_file_parse(eolian, lines[optional_index].c_str()))
+                     {
+                       std::cout
+                         << "Failed parsing: " << lines[optional_index] << "." << std::endl;
+                       EINA_CXX_DOM_LOG_WARN(eolian::js::domain)
+                         << "Failed parsing: " << lines[optional_index] << ".";
+                       assert(false && "Error parsing input file");
+                     }
+                   in_files.push_back(lines[optional_index]);
+                   optional_index++;
+                 }
+             }
+
+         }
+     }
 
+   std::cout << "going on" << std::endl;
+   
    std::ofstream os (out_file.c_str());
    if(!os.is_open())
      {
@@ -507,27 +657,7 @@ int main(int argc, char** argv)
 
    if(!linking)
    {
-     Eolian* eolian = eolian_new();
-     Eolian_Unit* eolian_unit = static_cast<Eolian_Unit*>(static_cast<void*>(eolian));
-
-     if (optind == argc-1)
-       {
-         in_file = argv[optind];
-       }
-     
      // Add include paths to eolian library
-     for(auto src : include_paths)
-       if (!::eolian_directory_scan(eolian, src.c_str()))
-         {
-           EINA_CXX_DOM_LOG_WARN(eolian::js::domain)
-             << "Couldn't load eolian from '" << src << "'.";
-         }
-     if (!::eolian_all_eot_files_parse(eolian))
-       {
-         EINA_CXX_DOM_LOG_WARN(eolian::js::domain)
-           << "Eolian failed parsing eot files";
-         assert(false && "Error parsing eot files");
-       }
      if (!::eolian_file_parse(eolian, in_file.c_str()))
        {
          EINA_CXX_DOM_LOG_WARN(eolian::js::domain)
@@ -557,22 +687,18 @@ int main(int argc, char** argv)
      // probably not eot file
      if(klass)
        {
-         os << "#if !defined(EFL_JAVASCRIPT_EOLIAN_GENERATE_REGISTER_STRUCT)\n";
+         //os << "#if !defined(EFL_JAVASCRIPT_EOLIAN_GENERATE_REGISTER_STRUCT)\n";
          // function to iterate through all inheritance class
          std::function<void(Eolian_Class const*, std::function<void(Eolian_Class const*)>)>
            recurse_inherits
            = [&] (Eolian_Class const* klass, std::function<void(Eolian_Class const*)> function)
            {
-             for(efl::eina::iterator<const char> first ( ::eolian_class_inherits_get(klass))
-                   , last; first != last; ++first)
+             for(efl::eina::iterator<Eolian_Class const> inherit_iterator ( ::eolian_class_inherits_get(klass))
+                   , inherit_last; inherit_iterator != inherit_last; ++inherit_iterator)
                {
-                 EINA_CXX_DOM_LOG_WARN(eolian::js::domain) << &*first << std::endl;
-                 Eolian_Class const* base = ::eolian_class_get_by_name(eolian_unit, &*first);
-                 if(base)
-                   {
-                     function(base);
-                     recurse_inherits(base, function);
-                   }
+                 Eolian_Class const* base = &*inherit_iterator;
+                 function(base);
+                 recurse_inherits(base, function);
                }
            };
 
@@ -591,46 +717,70 @@ int main(int argc, char** argv)
          using efl::eolian::grammar::attributes::unused;
          using efl::eolian::grammar::context_null;
          efl::eolian::grammar::attributes::klass_def klass_def(klass, eolian_unit);
-         if (!eolian::js::grammar::class_registration.generate(iterator, klass_def, context_null{}))
+         using efl::eolian::grammar::lower_case;
+         using efl::eolian::grammar::string;
+         using efl::eolian::grammar::as_generator;
+         if(!dummy_generation)
            {
-             throw std::runtime_error("Failed to generate class");
+             context_null context;
+             
+             as_generator("namespace efl { namespace js { namespace binding { namespace {\n")
+               .generate(iterator, unused, context);
+             
+             {
+               for(efl::eina::iterator<Eolian_Class const> inherit_iterator ( ::eolian_class_inherits_get(klass))
+                     , inherit_last; inherit_iterator != inherit_last; ++inherit_iterator)
+                 {
+                   efl::eolian::grammar::attributes::klass_def klass_def
+                     ( &*inherit_iterator, eolian_unit);
+                   as_generator
+                     (
+                      "static void register_prototype_"
+                      << lower_case[*(string << "_")]
+                      << lower_case[string]
+                      << "(v8::Handle<v8::Object>, v8::Local<v8::ObjectTemplate>, v8::Isolate*);\n"
+                     ).generate(iterator, std::make_tuple(klass_def.namespaces, klass_def.cxx_name), context);
+                 }
+             }
+
+             if (!eolian::js::grammar::class_registration.generate(iterator, klass_def, context))
+               {
+                 throw std::runtime_error("Failed to generate class");
+               }
+
+             as_generator("} } } } // namespace efl { namespace js { namespace binding { namespace {\n\n")
+               .generate(iterator, unused, context);
+           }
+         else
+           {
+             as_generator
+               (
+                 "namespace efl { namespace js { namespace binding { namespace {\n"
+                 "static void register_prototype_"
+                 << lower_case[*(string << "_")]
+                 << lower_case[string]
+                 << "(v8::Handle<v8::Object>, v8::Local<v8::ObjectTemplate>, v8::Isolate*)\n"
+                    "{\n}\n"
+                    "} } } }\n\n"
+                ).generate(iterator, std::make_tuple(klass_def.namespaces, klass_def.cxx_name), context_null{});
            }
 
-         os << "#else\n";
+         //os << "#else\n";
          // if (!eolian::js::grammar::call_registration.generate(iterator, klass_def, context_null{}))
          // {
          //   throw std::runtime_error("Failed to generate class");
          // }
-         os << "#endif\n";
+         //os << "#endif\n";
        }
      }
    else
      {
-       Eolian* eolian = eolian_new();
-       Eolian_Unit* eolian_unit = static_cast<Eolian_Unit*>(static_cast<void*>(eolian));
-
-       for(auto src : include_paths)
-         if (!::eolian_directory_scan(eolian, src.c_str()))
-           {
-             EINA_CXX_DOM_LOG_WARN(eolian::js::domain)
-               << "Couldn't load eolian from '" << src << "'.";
-           }
-
-       int optional_index = optind;
-       while (optional_index != argc)
-         {
-           std::cout << "opening " << argv[optional_index] << std::endl;
-           if (!::eolian_file_parse(eolian, argv[optional_index]))
-             {
-               std::cout
-                 << "Failed parsing: " << argv[optional_index] << "." << std::endl;
-               EINA_CXX_DOM_LOG_WARN(eolian::js::domain)
-                 << "Failed parsing: " << argv[optional_index] << ".";
-               assert(false && "Error parsing input file");
-             }
-           // in_files.push_back(argv[optind]);
-           optional_index++;
-         }
+       // for(auto src : include_paths)
+       //   if (!::eolian_directory_scan(eolian, src.c_str()))
+       //     {
+       //       EINA_CXX_DOM_LOG_WARN(eolian::js::domain)
+       //         << "Couldn't load eolian from '" << src << "'.";
+       //     }
 
        // if(!::eolian_all_eo_files_parse(eolian))
        //   {
@@ -638,23 +788,48 @@ int main(int argc, char** argv)
        //       << "Eolian failed parsing eo files";
        //     assert(false && "Error parsing eot files");
        //   }
-       if (!::eolian_all_eot_files_parse(eolian))
-         {
-           EINA_CXX_DOM_LOG_WARN(eolian::js::domain)
-             << "Eolian failed parsing eot files";
-           assert(false && "Error parsing eot files");
-         }
+       // if (!::eolian_all_eot_files_parse(eolian))
+       //   {
+       //     EINA_CXX_DOM_LOG_WARN(eolian::js::domain)
+       //       << "Eolian failed parsing eot files";
+       //     assert(false && "Error parsing eot files");
+       //   }
 
        // ns -> items
-       std::map<std::string, std::set<std::string>> all_names;
+       std::map<std::string, std::set<std::string>> namespace_map;
+       std::map<std::string, std::set<std::string>> class_map;
 
-       efl::eina::iterator<Eolian_Class const> klasses (eolian_all_classes_get(eolian_unit));
-       for(;klasses != efl::eina::iterator<Eolian_Class const>{}
-             ;++klasses)
+       auto fix_name = [] (std::string& name)
+         {
+           std::transform(name.begin()
+                          , name.end()
+                          , name.begin()
+                          , [] (char c)
+         {
+           c = ::tolower(c);
+           if(c == '.')
+             c = '_';
+           return c;
+         });
+         };
+       
+       // efl::eina::iterator<Eolian_Class const> klasses (eolian_all_classes_get(eolian_unit));
+       // for(;klasses != efl::eina::iterator<Eolian_Class const>{}
+       //       ;++klasses)
+       for(auto&& file : in_files)
          {
+           // if(legacy_klasses.find(&*klasses) != legacy_klasses.end())
+           //   continue;
+           char* dup = strdup(file.c_str());
+           char *bn = basename(dup);
+            
+           Eolian_Class const* klass = ::eolian_class_get_by_file(eolian_unit, bn);
+           
            std::string outer_namespace; // starts with global
-           std::string name = ::eolian_class_full_name_get(&*klasses);
+           std::string name = ::eolian_class_full_name_get(klass);
 
+           std::cout << "not considered legacy " << name << std::endl;
+           
            auto iterator_old = name.begin();
            auto iterator = std::find(iterator_old, name.end(), '.');
            while(iterator != name.end())
@@ -663,7 +838,8 @@ int main(int argc, char** argv)
 
                // std::cout << "outer namespace " << outer_namespace << " name " << namespace_name << std::endl;
                
-               all_names[outer_namespace].insert(namespace_name);
+               // other identifiers are namespaces
+               namespace_map[outer_namespace].insert(namespace_name);
                iterator_old = std::next(iterator);
                if(outer_namespace.empty())
                  outer_namespace = namespace_name;
@@ -675,39 +851,28 @@ int main(int argc, char** argv)
                // std::cout << "before loop outer namespace " << outer_namespace << " name " << namespace_name << std::endl;
                iterator = std::find(iterator_old, name.end(), '.');
              }
-           all_names[outer_namespace].insert({iterator_old, iterator});
+           // last identifier is the class name
+           std::string class_name {iterator_old, iterator};
+           fix_name(class_name);
+           class_map[outer_namespace].insert(class_name);
+           // outer_namespace is still a namespace
+           namespace_map[outer_namespace]; // namespace
          }
 
        // os << "typedef efl::eo::js::namespace_object"
-       for(auto&& item : all_names)
+       for(auto&& item : namespace_map)
          {
-           std::vector<std::string> classes;
+           std::set<std::string> classes;
 
-           std::cout << "namespace " << item.first << std::endl;
-
-           for(auto&& object : item.second)
-             {
-               std::string ns = item.first;
-               if(!ns.empty())
-                 ns += '.';
-               if(all_names.find(ns + object) == all_names.end()) // class name
-                 classes.push_back(object);
-             }
+           auto mirrored_iterator = class_map.find(item.first);
+           if(mirrored_iterator != class_map.end())
+             classes = mirrored_iterator->second;
 
            std::cout << "generating classes structs" << std::endl;
-           //if(!classes.empty())
+
              {
                std::string classes_struct_name = item.first;
-               std::transform(classes_struct_name.begin()
-                              , classes_struct_name.end()
-                              , classes_struct_name.begin()
-                              , [] (char c)
-                              {
-                                c = ::tolower(c);
-                                if(c == '.')
-                                  c = '_';
-                                return c;
-                              });
+               fix_name(classes_struct_name);
                os << "struct " << classes_struct_name << "_classes\n"
                   << "{\n"
                   << "    typedef efl::eo::js::list\n"
@@ -726,7 +891,9 @@ int main(int argc, char** argv)
                          os << ", ";
                        ++char_iterator;
                      }
-                   os << ">, std::false_type>";
+                   std::string full_name = (item.first == "" ? "" : item.first + '.') + cls;
+                   fix_name(full_name);
+                   os << ">, ::efl::js::binding::register_" << full_name << "_functor>";
                    cls_iterator++;
                    if(cls_iterator != classes.end())
                      os << ", ";
@@ -737,28 +904,18 @@ int main(int argc, char** argv)
              }
          }
        
-       for(auto item_iterator = all_names.rbegin()
-             , last_item_iterator = all_names.rend()
+       for(auto item_iterator = namespace_map.rbegin()
+             , last_item_iterator = namespace_map.rend()
              ;item_iterator != last_item_iterator
              ;++item_iterator)
          {
            auto&& item = *item_iterator;
            
-           std::vector<std::string> namespaces;
+           std::set<std::string> namespaces = item.second;
            //bool is_there_classes = false;
 
            std::cout << "namespace " << item.first << std::endl;
 
-           for(auto&& object : item.second)
-             {
-               std::cout << "searching if " << object << " is a namespace" << std::endl;
-               std::string ns = item.first;
-               if(!ns.empty())
-                 ns += '.';
-               if(all_names.find(ns + object) != all_names.end()) // namespace name
-                 namespaces.push_back(object);
-             }
-
            //if(!namespaces.empty())
              {
                std::string classes_struct_name = item.first;
diff --git a/src/bindings/cxx/eina_cxx/eina_tpl_char_switch.hh b/src/bindings/cxx/eina_cxx/eina_tpl_char_switch.hh
index cc76bc5f04..98546e02c2 100644
--- a/src/bindings/cxx/eina_cxx/eina_tpl_char_switch.hh
+++ b/src/bindings/cxx/eina_cxx/eina_tpl_char_switch.hh
@@ -999,6 +999,11174 @@ struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C1
   }
 };
 
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55, char C56>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    case C56:
+      typename F::template apply<C56>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55, char C56, char C57>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56, C57>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    case C56:
+      typename F::template apply<C56>::type{}(args...);
+      break;
+    case C57:
+      typename F::template apply<C57>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55, char C56, char C57, char C58>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56, C57, C58>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    case C56:
+      typename F::template apply<C56>::type{}(args...);
+      break;
+    case C57:
+      typename F::template apply<C57>::type{}(args...);
+      break;
+    case C58:
+      typename F::template apply<C58>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55, char C56, char C57, char C58, char C59>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56, C57, C58, C59>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    case C56:
+      typename F::template apply<C56>::type{}(args...);
+      break;
+    case C57:
+      typename F::template apply<C57>::type{}(args...);
+      break;
+    case C58:
+      typename F::template apply<C58>::type{}(args...);
+      break;
+    case C59:
+      typename F::template apply<C59>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55, char C56, char C57, char C58, char C59, char C60>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56, C57, C58, C59, C60>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    case C56:
+      typename F::template apply<C56>::type{}(args...);
+      break;
+    case C57:
+      typename F::template apply<C57>::type{}(args...);
+      break;
+    case C58:
+      typename F::template apply<C58>::type{}(args...);
+      break;
+    case C59:
+      typename F::template apply<C59>::type{}(args...);
+      break;
+    case C60:
+      typename F::template apply<C60>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55, char C56, char C57, char C58, char C59, char C60, char C61>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56, C57, C58, C59, C60, C61>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    case C56:
+      typename F::template apply<C56>::type{}(args...);
+      break;
+    case C57:
+      typename F::template apply<C57>::type{}(args...);
+      break;
+    case C58:
+      typename F::template apply<C58>::type{}(args...);
+      break;
+    case C59:
+      typename F::template apply<C59>::type{}(args...);
+      break;
+    case C60:
+      typename F::template apply<C60>::type{}(args...);
+      break;
+    case C61:
+      typename F::template apply<C61>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55, char C56, char C57, char C58, char C59, char C60, char C61, char C62>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56, C57, C58, C59, C60, C61, C62>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    case C56:
+      typename F::template apply<C56>::type{}(args...);
+      break;
+    case C57:
+      typename F::template apply<C57>::type{}(args...);
+      break;
+    case C58:
+      typename F::template apply<C58>::type{}(args...);
+      break;
+    case C59:
+      typename F::template apply<C59>::type{}(args...);
+      break;
+    case C60:
+      typename F::template apply<C60>::type{}(args...);
+      break;
+    case C61:
+      typename F::template apply<C61>::type{}(args...);
+      break;
+    case C62:
+      typename F::template apply<C62>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55, char C56, char C57, char C58, char C59, char C60, char C61, char C62, char C63>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56, C57, C58, C59, C60, C61, C62, C63>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    case C56:
+      typename F::template apply<C56>::type{}(args...);
+      break;
+    case C57:
+      typename F::template apply<C57>::type{}(args...);
+      break;
+    case C58:
+      typename F::template apply<C58>::type{}(args...);
+      break;
+    case C59:
+      typename F::template apply<C59>::type{}(args...);
+      break;
+    case C60:
+      typename F::template apply<C60>::type{}(args...);
+      break;
+    case C61:
+      typename F::template apply<C61>::type{}(args...);
+      break;
+    case C62:
+      typename F::template apply<C62>::type{}(args...);
+      break;
+    case C63:
+      typename F::template apply<C63>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55, char C56, char C57, char C58, char C59, char C60, char C61, char C62, char C63, char C64>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56, C57, C58, C59, C60, C61, C62, C63, C64>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    case C56:
+      typename F::template apply<C56>::type{}(args...);
+      break;
+    case C57:
+      typename F::template apply<C57>::type{}(args...);
+      break;
+    case C58:
+      typename F::template apply<C58>::type{}(args...);
+      break;
+    case C59:
+      typename F::template apply<C59>::type{}(args...);
+      break;
+    case C60:
+      typename F::template apply<C60>::type{}(args...);
+      break;
+    case C61:
+      typename F::template apply<C61>::type{}(args...);
+      break;
+    case C62:
+      typename F::template apply<C62>::type{}(args...);
+      break;
+    case C63:
+      typename F::template apply<C63>::type{}(args...);
+      break;
+    case C64:
+      typename F::template apply<C64>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55, char C56, char C57, char C58, char C59, char C60, char C61, char C62, char C63, char C64, char C65>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56, C57, C58, C59, C60, C61, C62, C63, C64, C65>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    case C56:
+      typename F::template apply<C56>::type{}(args...);
+      break;
+    case C57:
+      typename F::template apply<C57>::type{}(args...);
+      break;
+    case C58:
+      typename F::template apply<C58>::type{}(args...);
+      break;
+    case C59:
+      typename F::template apply<C59>::type{}(args...);
+      break;
+    case C60:
+      typename F::template apply<C60>::type{}(args...);
+      break;
+    case C61:
+      typename F::template apply<C61>::type{}(args...);
+      break;
+    case C62:
+      typename F::template apply<C62>::type{}(args...);
+      break;
+    case C63:
+      typename F::template apply<C63>::type{}(args...);
+      break;
+    case C64:
+      typename F::template apply<C64>::type{}(args...);
+      break;
+    case C65:
+      typename F::template apply<C65>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55, char C56, char C57, char C58, char C59, char C60, char C61, char C62, char C63, char C64, char C65, char C66>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56, C57, C58, C59, C60, C61, C62, C63, C64, C65, C66>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    case C56:
+      typename F::template apply<C56>::type{}(args...);
+      break;
+    case C57:
+      typename F::template apply<C57>::type{}(args...);
+      break;
+    case C58:
+      typename F::template apply<C58>::type{}(args...);
+      break;
+    case C59:
+      typename F::template apply<C59>::type{}(args...);
+      break;
+    case C60:
+      typename F::template apply<C60>::type{}(args...);
+      break;
+    case C61:
+      typename F::template apply<C61>::type{}(args...);
+      break;
+    case C62:
+      typename F::template apply<C62>::type{}(args...);
+      break;
+    case C63:
+      typename F::template apply<C63>::type{}(args...);
+      break;
+    case C64:
+      typename F::template apply<C64>::type{}(args...);
+      break;
+    case C65:
+      typename F::template apply<C65>::type{}(args...);
+      break;
+    case C66:
+      typename F::template apply<C66>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55, char C56, char C57, char C58, char C59, char C60, char C61, char C62, char C63, char C64, char C65, char C66, char C67>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56, C57, C58, C59, C60, C61, C62, C63, C64, C65, C66, C67>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    case C56:
+      typename F::template apply<C56>::type{}(args...);
+      break;
+    case C57:
+      typename F::template apply<C57>::type{}(args...);
+      break;
+    case C58:
+      typename F::template apply<C58>::type{}(args...);
+      break;
+    case C59:
+      typename F::template apply<C59>::type{}(args...);
+      break;
+    case C60:
+      typename F::template apply<C60>::type{}(args...);
+      break;
+    case C61:
+      typename F::template apply<C61>::type{}(args...);
+      break;
+    case C62:
+      typename F::template apply<C62>::type{}(args...);
+      break;
+    case C63:
+      typename F::template apply<C63>::type{}(args...);
+      break;
+    case C64:
+      typename F::template apply<C64>::type{}(args...);
+      break;
+    case C65:
+      typename F::template apply<C65>::type{}(args...);
+      break;
+    case C66:
+      typename F::template apply<C66>::type{}(args...);
+      break;
+    case C67:
+      typename F::template apply<C67>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55, char C56, char C57, char C58, char C59, char C60, char C61, char C62, char C63, char C64, char C65, char C66, char C67, char C68>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56, C57, C58, C59, C60, C61, C62, C63, C64, C65, C66, C67, C68>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    case C56:
+      typename F::template apply<C56>::type{}(args...);
+      break;
+    case C57:
+      typename F::template apply<C57>::type{}(args...);
+      break;
+    case C58:
+      typename F::template apply<C58>::type{}(args...);
+      break;
+    case C59:
+      typename F::template apply<C59>::type{}(args...);
+      break;
+    case C60:
+      typename F::template apply<C60>::type{}(args...);
+      break;
+    case C61:
+      typename F::template apply<C61>::type{}(args...);
+      break;
+    case C62:
+      typename F::template apply<C62>::type{}(args...);
+      break;
+    case C63:
+      typename F::template apply<C63>::type{}(args...);
+      break;
+    case C64:
+      typename F::template apply<C64>::type{}(args...);
+      break;
+    case C65:
+      typename F::template apply<C65>::type{}(args...);
+      break;
+    case C66:
+      typename F::template apply<C66>::type{}(args...);
+      break;
+    case C67:
+      typename F::template apply<C67>::type{}(args...);
+      break;
+    case C68:
+      typename F::template apply<C68>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55, char C56, char C57, char C58, char C59, char C60, char C61, char C62, char C63, char C64, char C65, char C66, char C67, char C68, char C69>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56, C57, C58, C59, C60, C61, C62, C63, C64, C65, C66, C67, C68, C69>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    case C56:
+      typename F::template apply<C56>::type{}(args...);
+      break;
+    case C57:
+      typename F::template apply<C57>::type{}(args...);
+      break;
+    case C58:
+      typename F::template apply<C58>::type{}(args...);
+      break;
+    case C59:
+      typename F::template apply<C59>::type{}(args...);
+      break;
+    case C60:
+      typename F::template apply<C60>::type{}(args...);
+      break;
+    case C61:
+      typename F::template apply<C61>::type{}(args...);
+      break;
+    case C62:
+      typename F::template apply<C62>::type{}(args...);
+      break;
+    case C63:
+      typename F::template apply<C63>::type{}(args...);
+      break;
+    case C64:
+      typename F::template apply<C64>::type{}(args...);
+      break;
+    case C65:
+      typename F::template apply<C65>::type{}(args...);
+      break;
+    case C66:
+      typename F::template apply<C66>::type{}(args...);
+      break;
+    case C67:
+      typename F::template apply<C67>::type{}(args...);
+      break;
+    case C68:
+      typename F::template apply<C68>::type{}(args...);
+      break;
+    case C69:
+      typename F::template apply<C69>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55, char C56, char C57, char C58, char C59, char C60, char C61, char C62, char C63, char C64, char C65, char C66, char C67, char C68, char C69, char C70>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56, C57, C58, C59, C60, C61, C62, C63, C64, C65, C66, C67, C68, C69, C70>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    case C56:
+      typename F::template apply<C56>::type{}(args...);
+      break;
+    case C57:
+      typename F::template apply<C57>::type{}(args...);
+      break;
+    case C58:
+      typename F::template apply<C58>::type{}(args...);
+      break;
+    case C59:
+      typename F::template apply<C59>::type{}(args...);
+      break;
+    case C60:
+      typename F::template apply<C60>::type{}(args...);
+      break;
+    case C61:
+      typename F::template apply<C61>::type{}(args...);
+      break;
+    case C62:
+      typename F::template apply<C62>::type{}(args...);
+      break;
+    case C63:
+      typename F::template apply<C63>::type{}(args...);
+      break;
+    case C64:
+      typename F::template apply<C64>::type{}(args...);
+      break;
+    case C65:
+      typename F::template apply<C65>::type{}(args...);
+      break;
+    case C66:
+      typename F::template apply<C66>::type{}(args...);
+      break;
+    case C67:
+      typename F::template apply<C67>::type{}(args...);
+      break;
+    case C68:
+      typename F::template apply<C68>::type{}(args...);
+      break;
+    case C69:
+      typename F::template apply<C69>::type{}(args...);
+      break;
+    case C70:
+      typename F::template apply<C70>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55, char C56, char C57, char C58, char C59, char C60, char C61, char C62, char C63, char C64, char C65, char C66, char C67, char C68, char C69, char C70, char C71>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56, C57, C58, C59, C60, C61, C62, C63, C64, C65, C66, C67, C68, C69, C70, C71>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    case C56:
+      typename F::template apply<C56>::type{}(args...);
+      break;
+    case C57:
+      typename F::template apply<C57>::type{}(args...);
+      break;
+    case C58:
+      typename F::template apply<C58>::type{}(args...);
+      break;
+    case C59:
+      typename F::template apply<C59>::type{}(args...);
+      break;
+    case C60:
+      typename F::template apply<C60>::type{}(args...);
+      break;
+    case C61:
+      typename F::template apply<C61>::type{}(args...);
+      break;
+    case C62:
+      typename F::template apply<C62>::type{}(args...);
+      break;
+    case C63:
+      typename F::template apply<C63>::type{}(args...);
+      break;
+    case C64:
+      typename F::template apply<C64>::type{}(args...);
+      break;
+    case C65:
+      typename F::template apply<C65>::type{}(args...);
+      break;
+    case C66:
+      typename F::template apply<C66>::type{}(args...);
+      break;
+    case C67:
+      typename F::template apply<C67>::type{}(args...);
+      break;
+    case C68:
+      typename F::template apply<C68>::type{}(args...);
+      break;
+    case C69:
+      typename F::template apply<C69>::type{}(args...);
+      break;
+    case C70:
+      typename F::template apply<C70>::type{}(args...);
+      break;
+    case C71:
+      typename F::template apply<C71>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55, char C56, char C57, char C58, char C59, char C60, char C61, char C62, char C63, char C64, char C65, char C66, char C67, char C68, char C69, char C70, char C71, char C72>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56, C57, C58, C59, C60, C61, C62, C63, C64, C65, C66, C67, C68, C69, C70, C71, C72>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    case C56:
+      typename F::template apply<C56>::type{}(args...);
+      break;
+    case C57:
+      typename F::template apply<C57>::type{}(args...);
+      break;
+    case C58:
+      typename F::template apply<C58>::type{}(args...);
+      break;
+    case C59:
+      typename F::template apply<C59>::type{}(args...);
+      break;
+    case C60:
+      typename F::template apply<C60>::type{}(args...);
+      break;
+    case C61:
+      typename F::template apply<C61>::type{}(args...);
+      break;
+    case C62:
+      typename F::template apply<C62>::type{}(args...);
+      break;
+    case C63:
+      typename F::template apply<C63>::type{}(args...);
+      break;
+    case C64:
+      typename F::template apply<C64>::type{}(args...);
+      break;
+    case C65:
+      typename F::template apply<C65>::type{}(args...);
+      break;
+    case C66:
+      typename F::template apply<C66>::type{}(args...);
+      break;
+    case C67:
+      typename F::template apply<C67>::type{}(args...);
+      break;
+    case C68:
+      typename F::template apply<C68>::type{}(args...);
+      break;
+    case C69:
+      typename F::template apply<C69>::type{}(args...);
+      break;
+    case C70:
+      typename F::template apply<C70>::type{}(args...);
+      break;
+    case C71:
+      typename F::template apply<C71>::type{}(args...);
+      break;
+    case C72:
+      typename F::template apply<C72>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55, char C56, char C57, char C58, char C59, char C60, char C61, char C62, char C63, char C64, char C65, char C66, char C67, char C68, char C69, char C70, char C71, char C72, char C73>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56, C57, C58, C59, C60, C61, C62, C63, C64, C65, C66, C67, C68, C69, C70, C71, C72, C73>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    case C56:
+      typename F::template apply<C56>::type{}(args...);
+      break;
+    case C57:
+      typename F::template apply<C57>::type{}(args...);
+      break;
+    case C58:
+      typename F::template apply<C58>::type{}(args...);
+      break;
+    case C59:
+      typename F::template apply<C59>::type{}(args...);
+      break;
+    case C60:
+      typename F::template apply<C60>::type{}(args...);
+      break;
+    case C61:
+      typename F::template apply<C61>::type{}(args...);
+      break;
+    case C62:
+      typename F::template apply<C62>::type{}(args...);
+      break;
+    case C63:
+      typename F::template apply<C63>::type{}(args...);
+      break;
+    case C64:
+      typename F::template apply<C64>::type{}(args...);
+      break;
+    case C65:
+      typename F::template apply<C65>::type{}(args...);
+      break;
+    case C66:
+      typename F::template apply<C66>::type{}(args...);
+      break;
+    case C67:
+      typename F::template apply<C67>::type{}(args...);
+      break;
+    case C68:
+      typename F::template apply<C68>::type{}(args...);
+      break;
+    case C69:
+      typename F::template apply<C69>::type{}(args...);
+      break;
+    case C70:
+      typename F::template apply<C70>::type{}(args...);
+      break;
+    case C71:
+      typename F::template apply<C71>::type{}(args...);
+      break;
+    case C72:
+      typename F::template apply<C72>::type{}(args...);
+      break;
+    case C73:
+      typename F::template apply<C73>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55, char C56, char C57, char C58, char C59, char C60, char C61, char C62, char C63, char C64, char C65, char C66, char C67, char C68, char C69, char C70, char C71, char C72, char C73, char C74>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56, C57, C58, C59, C60, C61, C62, C63, C64, C65, C66, C67, C68, C69, C70, C71, C72, C73, C74>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    case C56:
+      typename F::template apply<C56>::type{}(args...);
+      break;
+    case C57:
+      typename F::template apply<C57>::type{}(args...);
+      break;
+    case C58:
+      typename F::template apply<C58>::type{}(args...);
+      break;
+    case C59:
+      typename F::template apply<C59>::type{}(args...);
+      break;
+    case C60:
+      typename F::template apply<C60>::type{}(args...);
+      break;
+    case C61:
+      typename F::template apply<C61>::type{}(args...);
+      break;
+    case C62:
+      typename F::template apply<C62>::type{}(args...);
+      break;
+    case C63:
+      typename F::template apply<C63>::type{}(args...);
+      break;
+    case C64:
+      typename F::template apply<C64>::type{}(args...);
+      break;
+    case C65:
+      typename F::template apply<C65>::type{}(args...);
+      break;
+    case C66:
+      typename F::template apply<C66>::type{}(args...);
+      break;
+    case C67:
+      typename F::template apply<C67>::type{}(args...);
+      break;
+    case C68:
+      typename F::template apply<C68>::type{}(args...);
+      break;
+    case C69:
+      typename F::template apply<C69>::type{}(args...);
+      break;
+    case C70:
+      typename F::template apply<C70>::type{}(args...);
+      break;
+    case C71:
+      typename F::template apply<C71>::type{}(args...);
+      break;
+    case C72:
+      typename F::template apply<C72>::type{}(args...);
+      break;
+    case C73:
+      typename F::template apply<C73>::type{}(args...);
+      break;
+    case C74:
+      typename F::template apply<C74>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55, char C56, char C57, char C58, char C59, char C60, char C61, char C62, char C63, char C64, char C65, char C66, char C67, char C68, char C69, char C70, char C71, char C72, char C73, char C74, char C75>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56, C57, C58, C59, C60, C61, C62, C63, C64, C65, C66, C67, C68, C69, C70, C71, C72, C73, C74, C75>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    case C56:
+      typename F::template apply<C56>::type{}(args...);
+      break;
+    case C57:
+      typename F::template apply<C57>::type{}(args...);
+      break;
+    case C58:
+      typename F::template apply<C58>::type{}(args...);
+      break;
+    case C59:
+      typename F::template apply<C59>::type{}(args...);
+      break;
+    case C60:
+      typename F::template apply<C60>::type{}(args...);
+      break;
+    case C61:
+      typename F::template apply<C61>::type{}(args...);
+      break;
+    case C62:
+      typename F::template apply<C62>::type{}(args...);
+      break;
+    case C63:
+      typename F::template apply<C63>::type{}(args...);
+      break;
+    case C64:
+      typename F::template apply<C64>::type{}(args...);
+      break;
+    case C65:
+      typename F::template apply<C65>::type{}(args...);
+      break;
+    case C66:
+      typename F::template apply<C66>::type{}(args...);
+      break;
+    case C67:
+      typename F::template apply<C67>::type{}(args...);
+      break;
+    case C68:
+      typename F::template apply<C68>::type{}(args...);
+      break;
+    case C69:
+      typename F::template apply<C69>::type{}(args...);
+      break;
+    case C70:
+      typename F::template apply<C70>::type{}(args...);
+      break;
+    case C71:
+      typename F::template apply<C71>::type{}(args...);
+      break;
+    case C72:
+      typename F::template apply<C72>::type{}(args...);
+      break;
+    case C73:
+      typename F::template apply<C73>::type{}(args...);
+      break;
+    case C74:
+      typename F::template apply<C74>::type{}(args...);
+      break;
+    case C75:
+      typename F::template apply<C75>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55, char C56, char C57, char C58, char C59, char C60, char C61, char C62, char C63, char C64, char C65, char C66, char C67, char C68, char C69, char C70, char C71, char C72, char C73, char C74, char C75, char C76>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56, C57, C58, C59, C60, C61, C62, C63, C64, C65, C66, C67, C68, C69, C70, C71, C72, C73, C74, C75, C76>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    case C56:
+      typename F::template apply<C56>::type{}(args...);
+      break;
+    case C57:
+      typename F::template apply<C57>::type{}(args...);
+      break;
+    case C58:
+      typename F::template apply<C58>::type{}(args...);
+      break;
+    case C59:
+      typename F::template apply<C59>::type{}(args...);
+      break;
+    case C60:
+      typename F::template apply<C60>::type{}(args...);
+      break;
+    case C61:
+      typename F::template apply<C61>::type{}(args...);
+      break;
+    case C62:
+      typename F::template apply<C62>::type{}(args...);
+      break;
+    case C63:
+      typename F::template apply<C63>::type{}(args...);
+      break;
+    case C64:
+      typename F::template apply<C64>::type{}(args...);
+      break;
+    case C65:
+      typename F::template apply<C65>::type{}(args...);
+      break;
+    case C66:
+      typename F::template apply<C66>::type{}(args...);
+      break;
+    case C67:
+      typename F::template apply<C67>::type{}(args...);
+      break;
+    case C68:
+      typename F::template apply<C68>::type{}(args...);
+      break;
+    case C69:
+      typename F::template apply<C69>::type{}(args...);
+      break;
+    case C70:
+      typename F::template apply<C70>::type{}(args...);
+      break;
+    case C71:
+      typename F::template apply<C71>::type{}(args...);
+      break;
+    case C72:
+      typename F::template apply<C72>::type{}(args...);
+      break;
+    case C73:
+      typename F::template apply<C73>::type{}(args...);
+      break;
+    case C74:
+      typename F::template apply<C74>::type{}(args...);
+      break;
+    case C75:
+      typename F::template apply<C75>::type{}(args...);
+      break;
+    case C76:
+      typename F::template apply<C76>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55, char C56, char C57, char C58, char C59, char C60, char C61, char C62, char C63, char C64, char C65, char C66, char C67, char C68, char C69, char C70, char C71, char C72, char C73, char C74, char C75, char C76, char C77>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56, C57, C58, C59, C60, C61, C62, C63, C64, C65, C66, C67, C68, C69, C70, C71, C72, C73, C74, C75, C76, C77>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    case C56:
+      typename F::template apply<C56>::type{}(args...);
+      break;
+    case C57:
+      typename F::template apply<C57>::type{}(args...);
+      break;
+    case C58:
+      typename F::template apply<C58>::type{}(args...);
+      break;
+    case C59:
+      typename F::template apply<C59>::type{}(args...);
+      break;
+    case C60:
+      typename F::template apply<C60>::type{}(args...);
+      break;
+    case C61:
+      typename F::template apply<C61>::type{}(args...);
+      break;
+    case C62:
+      typename F::template apply<C62>::type{}(args...);
+      break;
+    case C63:
+      typename F::template apply<C63>::type{}(args...);
+      break;
+    case C64:
+      typename F::template apply<C64>::type{}(args...);
+      break;
+    case C65:
+      typename F::template apply<C65>::type{}(args...);
+      break;
+    case C66:
+      typename F::template apply<C66>::type{}(args...);
+      break;
+    case C67:
+      typename F::template apply<C67>::type{}(args...);
+      break;
+    case C68:
+      typename F::template apply<C68>::type{}(args...);
+      break;
+    case C69:
+      typename F::template apply<C69>::type{}(args...);
+      break;
+    case C70:
+      typename F::template apply<C70>::type{}(args...);
+      break;
+    case C71:
+      typename F::template apply<C71>::type{}(args...);
+      break;
+    case C72:
+      typename F::template apply<C72>::type{}(args...);
+      break;
+    case C73:
+      typename F::template apply<C73>::type{}(args...);
+      break;
+    case C74:
+      typename F::template apply<C74>::type{}(args...);
+      break;
+    case C75:
+      typename F::template apply<C75>::type{}(args...);
+      break;
+    case C76:
+      typename F::template apply<C76>::type{}(args...);
+      break;
+    case C77:
+      typename F::template apply<C77>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55, char C56, char C57, char C58, char C59, char C60, char C61, char C62, char C63, char C64, char C65, char C66, char C67, char C68, char C69, char C70, char C71, char C72, char C73, char C74, char C75, char C76, char C77, char C78>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56, C57, C58, C59, C60, C61, C62, C63, C64, C65, C66, C67, C68, C69, C70, C71, C72, C73, C74, C75, C76, C77, C78>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    case C56:
+      typename F::template apply<C56>::type{}(args...);
+      break;
+    case C57:
+      typename F::template apply<C57>::type{}(args...);
+      break;
+    case C58:
+      typename F::template apply<C58>::type{}(args...);
+      break;
+    case C59:
+      typename F::template apply<C59>::type{}(args...);
+      break;
+    case C60:
+      typename F::template apply<C60>::type{}(args...);
+      break;
+    case C61:
+      typename F::template apply<C61>::type{}(args...);
+      break;
+    case C62:
+      typename F::template apply<C62>::type{}(args...);
+      break;
+    case C63:
+      typename F::template apply<C63>::type{}(args...);
+      break;
+    case C64:
+      typename F::template apply<C64>::type{}(args...);
+      break;
+    case C65:
+      typename F::template apply<C65>::type{}(args...);
+      break;
+    case C66:
+      typename F::template apply<C66>::type{}(args...);
+      break;
+    case C67:
+      typename F::template apply<C67>::type{}(args...);
+      break;
+    case C68:
+      typename F::template apply<C68>::type{}(args...);
+      break;
+    case C69:
+      typename F::template apply<C69>::type{}(args...);
+      break;
+    case C70:
+      typename F::template apply<C70>::type{}(args...);
+      break;
+    case C71:
+      typename F::template apply<C71>::type{}(args...);
+      break;
+    case C72:
+      typename F::template apply<C72>::type{}(args...);
+      break;
+    case C73:
+      typename F::template apply<C73>::type{}(args...);
+      break;
+    case C74:
+      typename F::template apply<C74>::type{}(args...);
+      break;
+    case C75:
+      typename F::template apply<C75>::type{}(args...);
+      break;
+    case C76:
+      typename F::template apply<C76>::type{}(args...);
+      break;
+    case C77:
+      typename F::template apply<C77>::type{}(args...);
+      break;
+    case C78:
+      typename F::template apply<C78>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55, char C56, char C57, char C58, char C59, char C60, char C61, char C62, char C63, char C64, char C65, char C66, char C67, char C68, char C69, char C70, char C71, char C72, char C73, char C74, char C75, char C76, char C77, char C78, char C79>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56, C57, C58, C59, C60, C61, C62, C63, C64, C65, C66, C67, C68, C69, C70, C71, C72, C73, C74, C75, C76, C77, C78, C79>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    case C56:
+      typename F::template apply<C56>::type{}(args...);
+      break;
+    case C57:
+      typename F::template apply<C57>::type{}(args...);
+      break;
+    case C58:
+      typename F::template apply<C58>::type{}(args...);
+      break;
+    case C59:
+      typename F::template apply<C59>::type{}(args...);
+      break;
+    case C60:
+      typename F::template apply<C60>::type{}(args...);
+      break;
+    case C61:
+      typename F::template apply<C61>::type{}(args...);
+      break;
+    case C62:
+      typename F::template apply<C62>::type{}(args...);
+      break;
+    case C63:
+      typename F::template apply<C63>::type{}(args...);
+      break;
+    case C64:
+      typename F::template apply<C64>::type{}(args...);
+      break;
+    case C65:
+      typename F::template apply<C65>::type{}(args...);
+      break;
+    case C66:
+      typename F::template apply<C66>::type{}(args...);
+      break;
+    case C67:
+      typename F::template apply<C67>::type{}(args...);
+      break;
+    case C68:
+      typename F::template apply<C68>::type{}(args...);
+      break;
+    case C69:
+      typename F::template apply<C69>::type{}(args...);
+      break;
+    case C70:
+      typename F::template apply<C70>::type{}(args...);
+      break;
+    case C71:
+      typename F::template apply<C71>::type{}(args...);
+      break;
+    case C72:
+      typename F::template apply<C72>::type{}(args...);
+      break;
+    case C73:
+      typename F::template apply<C73>::type{}(args...);
+      break;
+    case C74:
+      typename F::template apply<C74>::type{}(args...);
+      break;
+    case C75:
+      typename F::template apply<C75>::type{}(args...);
+      break;
+    case C76:
+      typename F::template apply<C76>::type{}(args...);
+      break;
+    case C77:
+      typename F::template apply<C77>::type{}(args...);
+      break;
+    case C78:
+      typename F::template apply<C78>::type{}(args...);
+      break;
+    case C79:
+      typename F::template apply<C79>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55, char C56, char C57, char C58, char C59, char C60, char C61, char C62, char C63, char C64, char C65, char C66, char C67, char C68, char C69, char C70, char C71, char C72, char C73, char C74, char C75, char C76, char C77, char C78, char C79, char C80>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56, C57, C58, C59, C60, C61, C62, C63, C64, C65, C66, C67, C68, C69, C70, C71, C72, C73, C74, C75, C76, C77, C78, C79, C80>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    case C56:
+      typename F::template apply<C56>::type{}(args...);
+      break;
+    case C57:
+      typename F::template apply<C57>::type{}(args...);
+      break;
+    case C58:
+      typename F::template apply<C58>::type{}(args...);
+      break;
+    case C59:
+      typename F::template apply<C59>::type{}(args...);
+      break;
+    case C60:
+      typename F::template apply<C60>::type{}(args...);
+      break;
+    case C61:
+      typename F::template apply<C61>::type{}(args...);
+      break;
+    case C62:
+      typename F::template apply<C62>::type{}(args...);
+      break;
+    case C63:
+      typename F::template apply<C63>::type{}(args...);
+      break;
+    case C64:
+      typename F::template apply<C64>::type{}(args...);
+      break;
+    case C65:
+      typename F::template apply<C65>::type{}(args...);
+      break;
+    case C66:
+      typename F::template apply<C66>::type{}(args...);
+      break;
+    case C67:
+      typename F::template apply<C67>::type{}(args...);
+      break;
+    case C68:
+      typename F::template apply<C68>::type{}(args...);
+      break;
+    case C69:
+      typename F::template apply<C69>::type{}(args...);
+      break;
+    case C70:
+      typename F::template apply<C70>::type{}(args...);
+      break;
+    case C71:
+      typename F::template apply<C71>::type{}(args...);
+      break;
+    case C72:
+      typename F::template apply<C72>::type{}(args...);
+      break;
+    case C73:
+      typename F::template apply<C73>::type{}(args...);
+      break;
+    case C74:
+      typename F::template apply<C74>::type{}(args...);
+      break;
+    case C75:
+      typename F::template apply<C75>::type{}(args...);
+      break;
+    case C76:
+      typename F::template apply<C76>::type{}(args...);
+      break;
+    case C77:
+      typename F::template apply<C77>::type{}(args...);
+      break;
+    case C78:
+      typename F::template apply<C78>::type{}(args...);
+      break;
+    case C79:
+      typename F::template apply<C79>::type{}(args...);
+      break;
+    case C80:
+      typename F::template apply<C80>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55, char C56, char C57, char C58, char C59, char C60, char C61, char C62, char C63, char C64, char C65, char C66, char C67, char C68, char C69, char C70, char C71, char C72, char C73, char C74, char C75, char C76, char C77, char C78, char C79, char C80, char C81>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56, C57, C58, C59, C60, C61, C62, C63, C64, C65, C66, C67, C68, C69, C70, C71, C72, C73, C74, C75, C76, C77, C78, C79, C80, C81>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    case C56:
+      typename F::template apply<C56>::type{}(args...);
+      break;
+    case C57:
+      typename F::template apply<C57>::type{}(args...);
+      break;
+    case C58:
+      typename F::template apply<C58>::type{}(args...);
+      break;
+    case C59:
+      typename F::template apply<C59>::type{}(args...);
+      break;
+    case C60:
+      typename F::template apply<C60>::type{}(args...);
+      break;
+    case C61:
+      typename F::template apply<C61>::type{}(args...);
+      break;
+    case C62:
+      typename F::template apply<C62>::type{}(args...);
+      break;
+    case C63:
+      typename F::template apply<C63>::type{}(args...);
+      break;
+    case C64:
+      typename F::template apply<C64>::type{}(args...);
+      break;
+    case C65:
+      typename F::template apply<C65>::type{}(args...);
+      break;
+    case C66:
+      typename F::template apply<C66>::type{}(args...);
+      break;
+    case C67:
+      typename F::template apply<C67>::type{}(args...);
+      break;
+    case C68:
+      typename F::template apply<C68>::type{}(args...);
+      break;
+    case C69:
+      typename F::template apply<C69>::type{}(args...);
+      break;
+    case C70:
+      typename F::template apply<C70>::type{}(args...);
+      break;
+    case C71:
+      typename F::template apply<C71>::type{}(args...);
+      break;
+    case C72:
+      typename F::template apply<C72>::type{}(args...);
+      break;
+    case C73:
+      typename F::template apply<C73>::type{}(args...);
+      break;
+    case C74:
+      typename F::template apply<C74>::type{}(args...);
+      break;
+    case C75:
+      typename F::template apply<C75>::type{}(args...);
+      break;
+    case C76:
+      typename F::template apply<C76>::type{}(args...);
+      break;
+    case C77:
+      typename F::template apply<C77>::type{}(args...);
+      break;
+    case C78:
+      typename F::template apply<C78>::type{}(args...);
+      break;
+    case C79:
+      typename F::template apply<C79>::type{}(args...);
+      break;
+    case C80:
+      typename F::template apply<C80>::type{}(args...);
+      break;
+    case C81:
+      typename F::template apply<C81>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55, char C56, char C57, char C58, char C59, char C60, char C61, char C62, char C63, char C64, char C65, char C66, char C67, char C68, char C69, char C70, char C71, char C72, char C73, char C74, char C75, char C76, char C77, char C78, char C79, char C80, char C81, char C82>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56, C57, C58, C59, C60, C61, C62, C63, C64, C65, C66, C67, C68, C69, C70, C71, C72, C73, C74, C75, C76, C77, C78, C79, C80, C81, C82>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    case C56:
+      typename F::template apply<C56>::type{}(args...);
+      break;
+    case C57:
+      typename F::template apply<C57>::type{}(args...);
+      break;
+    case C58:
+      typename F::template apply<C58>::type{}(args...);
+      break;
+    case C59:
+      typename F::template apply<C59>::type{}(args...);
+      break;
+    case C60:
+      typename F::template apply<C60>::type{}(args...);
+      break;
+    case C61:
+      typename F::template apply<C61>::type{}(args...);
+      break;
+    case C62:
+      typename F::template apply<C62>::type{}(args...);
+      break;
+    case C63:
+      typename F::template apply<C63>::type{}(args...);
+      break;
+    case C64:
+      typename F::template apply<C64>::type{}(args...);
+      break;
+    case C65:
+      typename F::template apply<C65>::type{}(args...);
+      break;
+    case C66:
+      typename F::template apply<C66>::type{}(args...);
+      break;
+    case C67:
+      typename F::template apply<C67>::type{}(args...);
+      break;
+    case C68:
+      typename F::template apply<C68>::type{}(args...);
+      break;
+    case C69:
+      typename F::template apply<C69>::type{}(args...);
+      break;
+    case C70:
+      typename F::template apply<C70>::type{}(args...);
+      break;
+    case C71:
+      typename F::template apply<C71>::type{}(args...);
+      break;
+    case C72:
+      typename F::template apply<C72>::type{}(args...);
+      break;
+    case C73:
+      typename F::template apply<C73>::type{}(args...);
+      break;
+    case C74:
+      typename F::template apply<C74>::type{}(args...);
+      break;
+    case C75:
+      typename F::template apply<C75>::type{}(args...);
+      break;
+    case C76:
+      typename F::template apply<C76>::type{}(args...);
+      break;
+    case C77:
+      typename F::template apply<C77>::type{}(args...);
+      break;
+    case C78:
+      typename F::template apply<C78>::type{}(args...);
+      break;
+    case C79:
+      typename F::template apply<C79>::type{}(args...);
+      break;
+    case C80:
+      typename F::template apply<C80>::type{}(args...);
+      break;
+    case C81:
+      typename F::template apply<C81>::type{}(args...);
+      break;
+    case C82:
+      typename F::template apply<C82>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55, char C56, char C57, char C58, char C59, char C60, char C61, char C62, char C63, char C64, char C65, char C66, char C67, char C68, char C69, char C70, char C71, char C72, char C73, char C74, char C75, char C76, char C77, char C78, char C79, char C80, char C81, char C82, char C83>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56, C57, C58, C59, C60, C61, C62, C63, C64, C65, C66, C67, C68, C69, C70, C71, C72, C73, C74, C75, C76, C77, C78, C79, C80, C81, C82, C83>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    case C56:
+      typename F::template apply<C56>::type{}(args...);
+      break;
+    case C57:
+      typename F::template apply<C57>::type{}(args...);
+      break;
+    case C58:
+      typename F::template apply<C58>::type{}(args...);
+      break;
+    case C59:
+      typename F::template apply<C59>::type{}(args...);
+      break;
+    case C60:
+      typename F::template apply<C60>::type{}(args...);
+      break;
+    case C61:
+      typename F::template apply<C61>::type{}(args...);
+      break;
+    case C62:
+      typename F::template apply<C62>::type{}(args...);
+      break;
+    case C63:
+      typename F::template apply<C63>::type{}(args...);
+      break;
+    case C64:
+      typename F::template apply<C64>::type{}(args...);
+      break;
+    case C65:
+      typename F::template apply<C65>::type{}(args...);
+      break;
+    case C66:
+      typename F::template apply<C66>::type{}(args...);
+      break;
+    case C67:
+      typename F::template apply<C67>::type{}(args...);
+      break;
+    case C68:
+      typename F::template apply<C68>::type{}(args...);
+      break;
+    case C69:
+      typename F::template apply<C69>::type{}(args...);
+      break;
+    case C70:
+      typename F::template apply<C70>::type{}(args...);
+      break;
+    case C71:
+      typename F::template apply<C71>::type{}(args...);
+      break;
+    case C72:
+      typename F::template apply<C72>::type{}(args...);
+      break;
+    case C73:
+      typename F::template apply<C73>::type{}(args...);
+      break;
+    case C74:
+      typename F::template apply<C74>::type{}(args...);
+      break;
+    case C75:
+      typename F::template apply<C75>::type{}(args...);
+      break;
+    case C76:
+      typename F::template apply<C76>::type{}(args...);
+      break;
+    case C77:
+      typename F::template apply<C77>::type{}(args...);
+      break;
+    case C78:
+      typename F::template apply<C78>::type{}(args...);
+      break;
+    case C79:
+      typename F::template apply<C79>::type{}(args...);
+      break;
+    case C80:
+      typename F::template apply<C80>::type{}(args...);
+      break;
+    case C81:
+      typename F::template apply<C81>::type{}(args...);
+      break;
+    case C82:
+      typename F::template apply<C82>::type{}(args...);
+      break;
+    case C83:
+      typename F::template apply<C83>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
+template <char C0, char C1, char C2, char C3, char C4, char C5, char C6, char C7, char C8, char C9, char C10, char C11, char C12, char C13, char C14, char C15, char C16, char C17, char C18, char C19, char C20, char C21, char C22, char C23, char C24, char C25, char C26, char C27, char C28, char C29, char C30, char C31, char C32, char C33, char C34, char C35, char C36, char C37, char C38, char C39, char C40, char C41, char C42, char C43, char C44, char C45, char C46, char C47, char C48, char C49, char C50, char C51, char C52, char C53, char C54, char C55, char C56, char C57, char C58, char C59, char C60, char C61, char C62, char C63, char C64, char C65, char C66, char C67, char C68, char C69, char C70, char C71, char C72, char C73, char C74, char C75, char C76, char C77, char C78, char C79, char C80, char C81, char C82, char C83, char C84>
+struct tpl_char_switch<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56, C57, C58, C59, C60, C61, C62, C63, C64, C65, C66, C67, C68, C69, C70, C71, C72, C73, C74, C75, C76, C77, C78, C79, C80, C81, C82, C83, C84>
+{
+  template <typename F, typename Fail, typename...Args>
+  constexpr void operator()(char c, Fail const fail, Args&&...args) const
+  {
+    switch(c)
+    {
+    case C0:
+      typename F::template apply<C0>::type{}(args...);
+      break;
+    case C1:
+      typename F::template apply<C1>::type{}(args...);
+      break;
+    case C2:
+      typename F::template apply<C2>::type{}(args...);
+      break;
+    case C3:
+      typename F::template apply<C3>::type{}(args...);
+      break;
+    case C4:
+      typename F::template apply<C4>::type{}(args...);
+      break;
+    case C5:
+      typename F::template apply<C5>::type{}(args...);
+      break;
+    case C6:
+      typename F::template apply<C6>::type{}(args...);
+      break;
+    case C7:
+      typename F::template apply<C7>::type{}(args...);
+      break;
+    case C8:
+      typename F::template apply<C8>::type{}(args...);
+      break;
+    case C9:
+      typename F::template apply<C9>::type{}(args...);
+      break;
+    case C10:
+      typename F::template apply<C10>::type{}(args...);
+      break;
+    case C11:
+      typename F::template apply<C11>::type{}(args...);
+      break;
+    case C12:
+      typename F::template apply<C12>::type{}(args...);
+      break;
+    case C13:
+      typename F::template apply<C13>::type{}(args...);
+      break;
+    case C14:
+      typename F::template apply<C14>::type{}(args...);
+      break;
+    case C15:
+      typename F::template apply<C15>::type{}(args...);
+      break;
+    case C16:
+      typename F::template apply<C16>::type{}(args...);
+      break;
+    case C17:
+      typename F::template apply<C17>::type{}(args...);
+      break;
+    case C18:
+      typename F::template apply<C18>::type{}(args...);
+      break;
+    case C19:
+      typename F::template apply<C19>::type{}(args...);
+      break;
+    case C20:
+      typename F::template apply<C20>::type{}(args...);
+      break;
+    case C21:
+      typename F::template apply<C21>::type{}(args...);
+      break;
+    case C22:
+      typename F::template apply<C22>::type{}(args...);
+      break;
+    case C23:
+      typename F::template apply<C23>::type{}(args...);
+      break;
+    case C24:
+      typename F::template apply<C24>::type{}(args...);
+      break;
+    case C25:
+      typename F::template apply<C25>::type{}(args...);
+      break;
+    case C26:
+      typename F::template apply<C26>::type{}(args...);
+      break;
+    case C27:
+      typename F::template apply<C27>::type{}(args...);
+      break;
+    case C28:
+      typename F::template apply<C28>::type{}(args...);
+      break;
+    case C29:
+      typename F::template apply<C29>::type{}(args...);
+      break;
+    case C30:
+      typename F::template apply<C30>::type{}(args...);
+      break;
+    case C31:
+      typename F::template apply<C31>::type{}(args...);
+      break;
+    case C32:
+      typename F::template apply<C32>::type{}(args...);
+      break;
+    case C33:
+      typename F::template apply<C33>::type{}(args...);
+      break;
+    case C34:
+      typename F::template apply<C34>::type{}(args...);
+      break;
+    case C35:
+      typename F::template apply<C35>::type{}(args...);
+      break;
+    case C36:
+      typename F::template apply<C36>::type{}(args...);
+      break;
+    case C37:
+      typename F::template apply<C37>::type{}(args...);
+      break;
+    case C38:
+      typename F::template apply<C38>::type{}(args...);
+      break;
+    case C39:
+      typename F::template apply<C39>::type{}(args...);
+      break;
+    case C40:
+      typename F::template apply<C40>::type{}(args...);
+      break;
+    case C41:
+      typename F::template apply<C41>::type{}(args...);
+      break;
+    case C42:
+      typename F::template apply<C42>::type{}(args...);
+      break;
+    case C43:
+      typename F::template apply<C43>::type{}(args...);
+      break;
+    case C44:
+      typename F::template apply<C44>::type{}(args...);
+      break;
+    case C45:
+      typename F::template apply<C45>::type{}(args...);
+      break;
+    case C46:
+      typename F::template apply<C46>::type{}(args...);
+      break;
+    case C47:
+      typename F::template apply<C47>::type{}(args...);
+      break;
+    case C48:
+      typename F::template apply<C48>::type{}(args...);
+      break;
+    case C49:
+      typename F::template apply<C49>::type{}(args...);
+      break;
+    case C50:
+      typename F::template apply<C50>::type{}(args...);
+      break;
+    case C51:
+      typename F::template apply<C51>::type{}(args...);
+      break;
+    case C52:
+      typename F::template apply<C52>::type{}(args...);
+      break;
+    case C53:
+      typename F::template apply<C53>::type{}(args...);
+      break;
+    case C54:
+      typename F::template apply<C54>::type{}(args...);
+      break;
+    case C55:
+      typename F::template apply<C55>::type{}(args...);
+      break;
+    case C56:
+      typename F::template apply<C56>::type{}(args...);
+      break;
+    case C57:
+      typename F::template apply<C57>::type{}(args...);
+      break;
+    case C58:
+      typename F::template apply<C58>::type{}(args...);
+      break;
+    case C59:
+      typename F::template apply<C59>::type{}(args...);
+      break;
+    case C60:
+      typename F::template apply<C60>::type{}(args...);
+      break;
+    case C61:
+      typename F::template apply<C61>::type{}(args...);
+      break;
+    case C62:
+      typename F::template apply<C62>::type{}(args...);
+      break;
+    case C63:
+      typename F::template apply<C63>::type{}(args...);
+      break;
+    case C64:
+      typename F::template apply<C64>::type{}(args...);
+      break;
+    case C65:
+      typename F::template apply<C65>::type{}(args...);
+      break;
+    case C66:
+      typename F::template apply<C66>::type{}(args...);
+      break;
+    case C67:
+      typename F::template apply<C67>::type{}(args...);
+      break;
+    case C68:
+      typename F::template apply<C68>::type{}(args...);
+      break;
+    case C69:
+      typename F::template apply<C69>::type{}(args...);
+      break;
+    case C70:
+      typename F::template apply<C70>::type{}(args...);
+      break;
+    case C71:
+      typename F::template apply<C71>::type{}(args...);
+      break;
+    case C72:
+      typename F::template apply<C72>::type{}(args...);
+      break;
+    case C73:
+      typename F::template apply<C73>::type{}(args...);
+      break;
+    case C74:
+      typename F::template apply<C74>::type{}(args...);
+      break;
+    case C75:
+      typename F::template apply<C75>::type{}(args...);
+      break;
+    case C76:
+      typename F::template apply<C76>::type{}(args...);
+      break;
+    case C77:
+      typename F::template apply<C77>::type{}(args...);
+      break;
+    case C78:
+      typename F::template apply<C78>::type{}(args...);
+      break;
+    case C79:
+      typename F::template apply<C79>::type{}(args...);
+      break;
+    case C80:
+      typename F::template apply<C80>::type{}(args...);
+      break;
+    case C81:
+      typename F::template apply<C81>::type{}(args...);
+      break;
+    case C82:
+      typename F::template apply<C82>::type{}(args...);
+      break;
+    case C83:
+      typename F::template apply<C83>::type{}(args...);
+      break;
+    case C84:
+      typename F::template apply<C84>::type{}(args...);
+      break;
+    default:
+      fail(c);
+    };
+  }
+};
+
     
 } } }
 
diff --git a/src/bindings/js/efl_js/efl_js.cc b/src/bindings/js/efl_js/efl_js.cc
index a6cd5313f5..d1a9326683 100644
--- a/src/bindings/js/efl_js/efl_js.cc
+++ b/src/bindings/js/efl_js/efl_js.cc
@@ -68,46 +68,14 @@ struct object_registration_abc
   }
 };
 
+#include <eolian_include_generated.js.hh>
+
 namespace {
 
 namespace _mpl {
 
 #include <eolian_js_bindings.js.hh>
 
-// struct efl_elementary_classes
-// {
-//   typedef efl::eo::js::list
-//   <efl::eo::js::class_object<efl::eo::js::name<'W', 'i', 'n'>, std::false_type>> type;
-// };
-
-// struct afl_elementary_classes
-// {
-//   typedef efl::eo::js::list
-//   <efl::eo::js::class_object<efl::eo::js::name<'W', 'i', 'n'>, std::false_type>> type;
-// };
-  
-// struct efl_namespaces
-// {
-//   typedef efl::eo::js::list
-//   <efl::eo::js::namespace_object<efl::eo::js::name<'E', 'l', 'e', 'm', 'e', 'n', 't', 'a', 'r', 'y'>, std::false_type, efl_elementary_classes, efl::eo::js::empty>> type;
-// };
-
-// struct afl_namespaces
-// {
-//   typedef efl::eo::js::list
-//   <efl::eo::js::namespace_object<efl::eo::js::name<'E', 'l', 'e', 'm', 'e', 'n', 't', 'a', 'r', 'y'>, std::false_type, afl_elementary_classes, efl::eo::js::empty>> type;
-// };
-  
-// struct global_namespaces
-// {
-//   typedef efl::eo::js::list
-//   <efl::eo::js::namespace_object<efl::eo::js::name<'E', 'f', 'l'>, std::false_type
-//                                  , efl::eo::js::empty, efl_namespaces>
-//    , efl::eo::js::namespace_object<efl::eo::js::name<'A', 'f', 'l'>, std::false_type
-//                                    , efl::eo::js::empty, afl_namespaces>
-//   > type;
-// };
-
 typedef efl::eo::js::namespace_object<efl::eo::js::name<>
                                       , _classes, _namespaces
                                       > global_namespace;
@@ -135,7 +103,7 @@ struct found_item
   void operator()(efl::eo::js::namespace_object<Name, Classes, InnerNamespaces> const) const
   {
     typedef efl::eo::js::namespace_object<Name, Classes, InnerNamespaces> type;
-    std::cout << "returned namespace item" << std::endl;
+    std::cout << "returned namespace item " << typeid(typename type::name).name() << std::endl;
     if(is_registered<type>::yes)
     {
       std::cout << "Already registered" << std::endl;
@@ -159,7 +127,29 @@ struct found_item
   template <typename Name, typename Registration>
   void operator()(efl::eo::js::class_object<Name, Registration> const) const
   {
-    //std::cout << "returned class item" << std::endl;
+    typedef efl::eo::js::class_object<Name, Registration> type;
+    std::cout << "returned class item " << typeid(typename type::name).name() << std::endl;
+    if(is_registered<type>::yes)
+    {
+      std::cout << "Already registered" << std::endl;
+    }
+    else
+    {
+      std::cout << "Not registered yet" << std::endl;
+      is_registered<type>::yes = true;
+
+      auto registered = Registration{}(info.This(), info.GetIsolate());
+
+      v8::Isolate* isolate = info.GetIsolate();
+      info.This()->Set(::efl::eina::js::compatibility_new<v8::String>(isolate, name.data())
+                       , registered);
+      info.GetReturnValue().Set(registered);
+    }
+  }
+
+  void operator()(efl::eo::js::empty const) const
+  {
+    std::cout << "not found" << std::endl;
     // must register
   }
 };
diff --git a/src/bindings/js/eo_js/eo_js_constructor.hh b/src/bindings/js/eo_js/eo_js_constructor.hh
index f977d09190..b5f63753da 100644
--- a/src/bindings/js/eo_js/eo_js_constructor.hh
+++ b/src/bindings/js/eo_js/eo_js_constructor.hh
@@ -17,6 +17,7 @@ namespace efl { namespace eo { namespace js {
 
 inline eina::js::compatibility_return_type constructor(eina::js::compatibility_callback_info_type args)
 {
+  std::cout << "constructor for Eo object" << std::endl;
   if(args.IsConstructCall())
     {
        std::size_t argc = args.Length();
@@ -34,6 +35,7 @@ inline eina::js::compatibility_return_type constructor(eina::js::compatibility_c
        // constructor with parent
        else if(argc == 1)
          {
+            std::cout << "Constructor has 1 param" << std::endl;
             auto arg_0 = args[0];
             v8::Local<v8::Object> obj_arg0;
             v8::Local<v8::Object> self = args.This();
@@ -42,12 +44,14 @@ inline eina::js::compatibility_return_type constructor(eina::js::compatibility_c
             if(arg_0->IsObject() && (obj_arg0 = arg_0->ToObject())->InternalFieldCount() == 1
                && (external = v8::External::Cast(*obj_arg0->GetInternalField(0)))) // parent
               {
+                 std::cout << "param is parent" << std::endl;
                  Eo* parent = static_cast<Eo*>(external->Value());
                  eo = _efl_add_internal_start(__FILE__, __LINE__, kls, parent, EINA_TRUE, EINA_TRUE);
                  self->SetInternalField(0, eina::js::compatibility_new<v8::External>(args.GetIsolate(), eo));
               }
-            else if(arg_0->IsObject() && (function = v8::Function::Cast(*obj_arg0->GetInternalField(0))))
+            else if((std::cout << "else" << std::endl),arg_0->IsObject() && (function = v8::Function::Cast(*arg_0)))
               {
+                 std::cout << "param is lambda" << std::endl;
                  eo = _efl_add_internal_start(__FILE__, __LINE__, kls, NULL, EINA_TRUE, EINA_TRUE);
                  self->SetInternalField(0, eina::js::compatibility_new<v8::External>(args.GetIsolate(), eo));
                  
@@ -62,6 +66,7 @@ inline eina::js::compatibility_return_type constructor(eina::js::compatibility_c
                 // TypeError
               }
             self->SetInternalField(0, eina::js::compatibility_new<v8::External>(args.GetIsolate(), _efl_add_end(eo, EINA_TRUE, EINA_TRUE)));
+            std::cout << "set internal field" << std::endl;
             return eina::js::compatibility_return();
          }
        // constructor with parent and lambda
diff --git a/src/bindings/js/eo_js/eo_js_namespace_accessor.hh b/src/bindings/js/eo_js/eo_js_namespace_accessor.hh
index 901173be0e..371b355932 100644
--- a/src/bindings/js/eo_js/eo_js_namespace_accessor.hh
+++ b/src/bindings/js/eo_js/eo_js_namespace_accessor.hh
@@ -9,10 +9,10 @@ inline void accessor_get(v8::Local<v8::Name> name, v8::PropertyCallbackInfo<v8::
   
 }
 
-inline v8::Local<v8::Object> create_namespace_object()
-{
+// inline v8::Local<v8::Object> create_namespace_object()
+// {
   
-}
+// }
 
       
 } } }
diff --git a/src/bindings/js/eo_js/eo_js_namespace_tree.hh b/src/bindings/js/eo_js/eo_js_namespace_tree.hh
index ca0aec1988..325eb810a3 100644
--- a/src/bindings/js/eo_js/eo_js_namespace_tree.hh
+++ b/src/bindings/js/eo_js/eo_js_namespace_tree.hh
@@ -73,7 +73,7 @@ struct class_object
   typedef Name name;
   typedef Registration registration;
 };
-      
+
 template <typename NameLhs, typename NameRhs>
 struct name_less;
 
@@ -129,6 +129,29 @@ struct name_less_predicate
   {};
 };
 
+struct name_size_predicate
+{
+  template <typename A0, typename A1>
+  struct apply;
+
+  template <typename Name1, typename Name2, typename...Others1, typename...Others2>
+  struct apply<namespace_object<Name1, Others1...>, namespace_object<Name2, Others2...>>
+    : std::integral_constant<bool, (name_size<Name1>::value < name_size<Name2>::value)>
+  {};
+  template <typename Name1, typename Name2, typename...Others1, typename...Others2>
+  struct apply<class_object<Name1, Others1...>, class_object<Name2, Others2...>>
+    : std::integral_constant<bool, (name_size<Name1>::value < name_size<Name2>::value)>
+  {};
+  template <typename Name1, typename Name2, typename...Others1, typename...Others2>
+  struct apply<namespace_object<Name1, Others1...>, class_object<Name2, Others2...>>
+    : std::integral_constant<bool, (name_size<Name1>::value < name_size<Name2>::value)>
+  {};
+  template <typename Name1, typename Name2, typename...Others1, typename...Others2>
+  struct apply<class_object<Name1, Others1...>, namespace_object<Name2, Others2...>>
+    : std::integral_constant<bool, (name_size<Name1>::value < name_size<Name2>::value)>
+  {};
+};
+      
 template <typename A0, typename A1>
 struct pair
 {
@@ -143,22 +166,68 @@ struct map_op
   struct apply;
 
   template <typename A0>
-  struct apply<list<>, A0>
+  struct apply<list<>, A0
+               , typename std::enable_if
+               <
+                   (Index < name_size<typename A0::name>::value)
+               >::type
+               >
   {
     typedef list<pair<name_at_c<Index, typename A0::name>
                      , list<A0>>> type;
   };
 
+  // Ignore A0
+  template <typename A0>
+  struct apply<list<>, A0
+               , typename std::enable_if
+               <
+                   (Index >= name_size<typename A0::name>::value)
+               >::type
+               >
+  {
+    typedef list<> type;
+  };
+  
+  template <typename C, typename A0, typename Enable = void>
+  struct apply2;
+
   template <typename C, typename...Items, typename...Pairs, typename A0>
   struct apply<list<pair<C, list<Items...>>, Pairs...>, A0
-               , typename std::enable_if<(name_at_c<Index, typename A0::name>::value == C::value)>::type>
+               , typename std::enable_if
+               <
+                   (Index < name_size<typename A0::name>::value)
+               >::type>
+    : apply2<list<pair<C, list<Items...>>, Pairs...>, A0>
+  {};
+
+  // Ignore A0
+  template <typename C, typename...Items, typename...Pairs, typename A0>
+  struct apply<list<pair<C, list<Items...>>, Pairs...>, A0
+               , typename std::enable_if
+               <
+                   (Index >= name_size<typename A0::name>::value)
+               >::type>
+  {
+    typedef list<pair<C, list<Items...>>, Pairs...> type;
+  };
+  
+  template <typename C, typename...Items, typename...Pairs, typename A0>
+  struct apply2<list<pair<C, list<Items...>>, Pairs...>, A0
+               , typename std::enable_if
+               <
+                   (name_at_c<Index, typename A0::name>::value == C::value)
+               >::type>
   {
     typedef list<pair<C, list<A0, Items...>>, Pairs...> type;
   };
 
   template <typename C, typename List, typename...Pairs, typename A0>
-  struct apply<list<pair<C, List>, Pairs...>, A0
-               , typename std::enable_if<!(name_at_c<Index, typename A0::name>::value == C::value)>::type>
+  struct apply2<list<pair<C, List>, Pairs...>, A0
+               , typename std::enable_if
+               <
+                   !(name_at_c<Index, typename A0::name>::value == C::value)
+               >::type>
   {
     typedef list<pair<name_at_c<Index, typename A0::name>, list<A0>>, pair<C, List>, Pairs...> type;
   };
@@ -217,12 +286,32 @@ struct switch_case_call
       template <typename F>
       constexpr void operator()(eina::string_view string, F const f) const
       {
-        std::cout << "Found character " << C << std::endl;
+        std::cout << "Found character " << C << " size " << string.size() << std::endl;
         typedef typename list_find_if<Map, find_char_pair>::type type;
         typedef typename type::second objects;
-        typedef typename list_max<name_less_predicate, objects>::type max_type;
-
-        search_separate_switch_case<Index+1>(string, objects{}
+        typedef typename list_max<name_size_predicate, objects>::type max_type;
+        typedef typename list_min<name_size_predicate, objects>::type min_type;
+
+        static_assert(name_size<typename min_type::name>::value <=
+                      name_size<typename max_type::name>::value);
+        
+        if(string.size() < name_size<typename min_type::name>::value)
+          {
+            std::cout << "failed min size " <<  name_size<typename min_type::name>::value
+                      << " min is " << typeid(min_type).name() << " all "
+                      << typeid(objects).name() << std::endl;
+            f(empty{});
+            return;
+          }
+        
+        // hope for ellision
+        if(name_size<typename min_type::name>::value == Index+1)
+          {
+            if(string.size() == name_size<typename min_type::name>::value)
+                return f(min_type{});
+          }
+
+          search_separate_switch_case<Index+1>(string, objects{}
           , f
           , std::integral_constant<bool, (name_size<typename max_type::name>::value == Index+1)>{});
       }
@@ -251,6 +340,7 @@ void search_separate_switch_case(eina::string_view string, list<Objects...>
                                  , F const f
                                  , std::false_type)
 {
+  // typedef typename list_sort<name_less_predicate, list<Objects...>>::type sorted_list;
   typedef typename map_chars<Index, list<Objects...>>::type map;
   typedef typename create_switch<map>::type switch_type;
 
diff --git a/src/lib/eolian_cxx/grammar/attribute_conditional.hpp b/src/lib/eolian_cxx/grammar/attribute_conditional.hpp
index 5934564014..59d86fa837 100644
--- a/src/lib/eolian_cxx/grammar/attribute_conditional.hpp
+++ b/src/lib/eolian_cxx/grammar/attribute_conditional.hpp
@@ -5,7 +5,7 @@
 
 namespace efl { namespace eolian { namespace grammar {
 
-template <typename F, typename G>
+template <typename F, typename G, typename SpecificAttribute>
 struct functional_attribute_conditional_generator
 {
    template <typename OutputIterator, typename Attribute, typename Context>
@@ -21,11 +21,11 @@ struct functional_attribute_conditional_generator
    G g;
 };
 
-template <typename F>
+template <typename F, typename SpecificAttribute>
 struct functional_attribute_conditional_directive
 {
   template <typename G>
-  functional_attribute_conditional_generator<F, G> operator[](G g) const
+  functional_attribute_conditional_generator<F, G, SpecificAttribute> operator[](G g) const
   {
     return {f, g};
   }
@@ -39,32 +39,48 @@ struct functional_attribute_conditional_directive
   F f;
 };
 
-struct attribute_conditional_terminal
+// struct attribute_conditional_terminal
+// {
+//   template <typename F>
+//   functional_attribute_conditional_directive<F> operator()(F f) const
+//   {
+//     return {f};
+//   }
+// } const attribute_conditional = {};
+
+template <typename SpecificAttribute = void, typename F = void>
+functional_attribute_conditional_directive<F, SpecificAttribute>
+attribute_conditional(F f)
 {
-  template <typename F>
-  functional_attribute_conditional_directive<F> operator()(F f) const
-  {
-    return {f};
-  }
-} const attribute_conditional = {};
+  return {f};
+}
 
-template <typename F, typename G>
-struct is_eager_generator<functional_attribute_conditional_generator<F, G>> : std::true_type {};
-template <typename F>
-struct is_eager_generator<functional_attribute_conditional_directive<F>> : std::true_type {};
-template <typename F, typename G>
-struct is_generator<functional_attribute_conditional_generator<F, G>> : std::true_type {};
-template <typename F>
-struct is_generator<functional_attribute_conditional_directive<F>> : std::true_type {};
+template <typename F, typename G, typename SpecificAttribute>
+struct is_eager_generator<functional_attribute_conditional_generator<F, G, SpecificAttribute>> : std::true_type {};
+template <typename F, typename SpecificAttribute>
+struct is_eager_generator<functional_attribute_conditional_directive<F, SpecificAttribute>> : std::true_type {};
+template <typename F, typename G, typename SpecificAttribute>
+struct is_generator<functional_attribute_conditional_generator<F, G, SpecificAttribute>> : std::true_type {};
+template <typename F, typename SpecificAttribute>
+struct is_generator<functional_attribute_conditional_directive<F, SpecificAttribute>> : std::true_type {};
       
 namespace type_traits {
-template <typename F, typename G>
-struct attributes_needed<functional_attribute_conditional_generator<F, G>>
+template <typename F, typename G, typename SpecificAttribute>
+struct attributes_needed<functional_attribute_conditional_generator<F, G, SpecificAttribute>>
   : std::conditional<(attributes_needed<G>::value >= 1)
                      , attributes_needed<G>
                      , std::integral_constant<int, 1>>::type {};  
-template <typename F>
-struct attributes_needed<functional_attribute_conditional_directive<F>> : std::integral_constant<int, 1> {};  
+template <typename F, typename SpecificAttribute>
+struct attributes_needed<functional_attribute_conditional_directive<F, SpecificAttribute>> : std::integral_constant<int, 1> {};  
+template <typename F, typename G, typename SpecificAttribute>
+struct accepts_specific_tuple<functional_attribute_conditional_generator<F, G, SpecificAttribute>, SpecificAttribute> : std::true_type {};
+template <typename F, typename G, typename SpecificAttribute, typename Attribute>
+struct accepts_specific_tuple<functional_attribute_conditional_generator<F, G, SpecificAttribute>, Attribute>
+  : accepts_specific_tuple<G, Attribute> {};
+template <typename F, typename G, typename SpecificAttribute>
+struct accepts_tuple<functional_attribute_conditional_generator<F, G, SpecificAttribute>>
+  : accepts_tuple<G> {};
+
 }
       
 } } }
diff --git a/src/lib/eolian_cxx/grammar/attribute_reorder.hpp b/src/lib/eolian_cxx/grammar/attribute_reorder.hpp
index a14e3a9203..57836a4bf8 100644
--- a/src/lib/eolian_cxx/grammar/attribute_reorder.hpp
+++ b/src/lib/eolian_cxx/grammar/attribute_reorder.hpp
@@ -9,6 +9,7 @@ namespace efl { namespace eolian { namespace grammar {
 template <typename Tuple, int...S>
 struct reorder_tuple
 {
+  static_assert(type_traits::is_tuple<Tuple>::value);
   Tuple* tuple;
 };
 
@@ -41,7 +42,7 @@ struct tuple_element<N, reorder_tuple<Tuple, S...>>
   template <int I>
   static type const& get_impl(reorder_tuple<Tuple, S...> const& t
                               , std::integral_constant<int, I>)
-  { using std::get; return get<index::value>(*t.tuple); }
+  { using std::get; using attributes::get; return get<index::value>(*t.tuple); }
   static type const& get(reorder_tuple<Tuple, S...> const& t)
   { return get_impl(t, index{}); }
 };
@@ -82,6 +83,8 @@ template <int...S, typename Tuple>
 struct is_explicit_tuple<reorder_tuple<Tuple, S...>> : std::true_type {};
 template <int...S, typename Tuple>
 struct is_tuple<reorder_tuple<Tuple, S...>> : std::true_type {};
+template <typename G, int...S>
+struct accepts_tuple<attribute_reorder_generator<G, S...>> : std::true_type {};
 }
       
 } } }
diff --git a/src/lib/eolian_cxx/grammar/attributed.hpp b/src/lib/eolian_cxx/grammar/attributed.hpp
new file mode 100644
index 0000000000..e51ffe0ac7
--- /dev/null
+++ b/src/lib/eolian_cxx/grammar/attributed.hpp
@@ -0,0 +1,66 @@
+#ifndef EOLIAN_CXX_ATTRIBUTED_HH
+#define EOLIAN_CXX_ATTRIBUTED_HH
+
+#include "grammar/generator.hpp"
+
+namespace efl { namespace eolian { namespace grammar {
+
+template <typename Attr, typename G>
+struct attributed_generator
+{
+   template <typename OutputIterator, typename Attribute, typename Context>
+   bool generate(OutputIterator sink, Attribute const&, Context const& ctx) const
+   {
+     return as_generator(g).generate(sink, attr, ctx);
+   }
+
+   Attr attr;
+   G g;
+};
+
+template <typename Attr>
+struct attributed_directive
+{
+  template <typename G>
+  attributed_generator<Attr, G> operator[](G g) const
+  {
+    return {attr, g};
+  }
+
+  template <typename OutputIterator, typename Attribute, typename Context>
+  bool generate(OutputIterator, Attribute const& attribute, Context const&) const
+  {
+    return f(attribute);
+  }
+  
+  Attr attr;
+};
+
+template <typename Attr, typename G>
+struct is_eager_generator<attributed_generator<Attr, G>> : std::true_type {};
+template <typename Attr>
+struct is_eager_generator<attributed_directive<Attr>> : std::true_type {};
+template <typename Attr, typename G>
+struct is_generator<attributed_generator<Attr, G>> : std::true_type {};
+template <typename Attr>
+struct is_generator<attributed_directive<Attr>> : std::true_type {};
+      
+struct attributed_terminal
+{
+  template <typename Attr>
+  attributed_directive<Attr> operator()(Attr attr) const
+  {
+    return {attr};
+  }
+} const attributed = {};
+
+namespace type_traits {
+template <typename Attr, typename G>
+struct attributes_needed<attributed_generator<Attr, G>> : attributes_needed<G> {};  
+template <typename Attr>
+struct attributes_needed<attributed_directive<Attr>> : std::integral_constant<int, 0> {};  
+}
+      
+} } }
+
+#endif
diff --git a/src/lib/eolian_cxx/grammar/attributes.hpp b/src/lib/eolian_cxx/grammar/attributes.hpp
index d33fcf2de7..48ab6af927 100644
--- a/src/lib/eolian_cxx/grammar/attributes.hpp
+++ b/src/lib/eolian_cxx/grammar/attributes.hpp
@@ -84,6 +84,19 @@ get(infinite_tuple<T> const& tuple)
 {
   return tuple_element<N, infinite_tuple<T>>::get(tuple);
 }
+
+template <int N, typename T, typename Enable = typename std::enable_if<type_traits::is_tuple<T>::value>::type>
+typename tuple_element<N, T>::type&
+get(T& tuple)
+{
+  return tuple_element<N, T>::get(tuple);
+}
+template <int N, typename T, typename Enable = typename std::enable_if<type_traits::is_tuple<T>::value>::type>
+typename tuple_element<N, T const>::type&
+get(T const& tuple)
+{
+  return tuple_element<N, T const>::get(tuple);
+}
   
 }
 
@@ -141,19 +154,23 @@ lazy_offset_tuple<N + I, Tuple> pop_front_n(lazy_offset_tuple<N, Tuple> tuple, t
 template <typename Generator, typename OutputIterator, typename Attribute, typename Context>
 bool generate(Generator const& gen, OutputIterator sink, Attribute const& attribute, Context const& context
               , typename std::enable_if
-              <type_traits::is_explicit_tuple<Attribute>::value
+              <type_traits::is_tuple<Attribute>::value
               && !type_traits::accepts_tuple<Generator>::value
+              && !type_traits::accepts_specific_tuple<Generator, Attribute>::value
               && type_traits::attributes_needed<Generator>::value != 0
               >::type* = 0)
 {
+   using attributes::get;
+   using std::get;
    return gen.generate(sink, get<0>(attribute), context);
 }
 
 template <typename Generator, typename OutputIterator, typename Attribute, typename Context>
 bool generate(Generator const& gen, OutputIterator sink, Attribute const& attribute, Context const& context
               , typename std::enable_if
-              <type_traits::is_explicit_tuple<Attribute>::value
-              && type_traits::accepts_tuple<Generator>::value
+              <type_traits::is_tuple<Attribute>::value
+              && (type_traits::accepts_tuple<Generator>::value
+                  || type_traits::accepts_specific_tuple<Generator, Attribute>::value)
               && type_traits::attributes_needed<Generator>::value != 0
               >::type* = 0)
 {
@@ -173,13 +190,13 @@ bool generate(Generator const& gen, OutputIterator sink, Attribute const&
 template <typename Generator, typename OutputIterator, typename Attribute, typename Context>
 bool generate(Generator const& gen, OutputIterator sink, Attribute const& attribute, Context const& context
               , typename std::enable_if
-              <!type_traits::is_explicit_tuple<Attribute>::value
+              <!type_traits::is_tuple<Attribute>::value
               && type_traits::attributes_needed<Generator>::value != 0
               >::type* = 0)
 {
    return gen.generate(sink, attribute, context);
 }
-  
+
 } } } }
 
 #endif
diff --git a/src/lib/eolian_cxx/grammar/class_definition.hpp b/src/lib/eolian_cxx/grammar/class_definition.hpp
index b282f71bf9..3a800d6cf2 100644
--- a/src/lib/eolian_cxx/grammar/class_definition.hpp
+++ b/src/lib/eolian_cxx/grammar/class_definition.hpp
@@ -161,8 +161,9 @@ struct class_definition_generator
                 << scope_tab << scope_tab << "static Efl_Event_Description const* description()\n"
                 << scope_tab << scope_tab << "{ return " << string << "; }\n"
                 << scope_tab << scope_tab << "typedef "
-                << (attribute_conditional([] (eina::optional<attributes::type_def> const& t) { return !!t; })
-                    [attribute_replace([] (eina::optional<attributes::type_def> const& t) { return *t; }) [type]]
+                << (attribute_conditional<eina::optional<attributes::type_def>>
+                    ([] (eina::optional<attributes::type_def> const& t) { return !!t; })
+                    [ attribute_replace([] (eina::optional<attributes::type_def> const& t) { return *t; }) [type]]
                     | "void")
                 << " parameter_type;\n"
                 << scope_tab << "} const " << string_replace(',', '_') << "_event;\n"
diff --git a/src/lib/eolian_cxx/grammar/function_definition.hpp b/src/lib/eolian_cxx/grammar/function_definition.hpp
index 9b646efc9c..db954f3420 100644
--- a/src/lib/eolian_cxx/grammar/function_definition.hpp
+++ b/src/lib/eolian_cxx/grammar/function_definition.hpp
@@ -84,23 +84,27 @@ struct function_definition_generator
         return false;
 
       auto out_declaration =
-        attribute_conditional([] (attributes::parameter_def const& p) -> bool
-                              { return p.direction == attributes::parameter_direction::out; })
+        attribute_conditional<attributes::parameter_def>
+        ([] (attributes::parameter_def const& p) -> bool
+         { return p.direction == attributes::parameter_direction::out; })
         [
           attribute_reorder<1, 2>
           (scope_tab <<
-           (attribute_conditional([] (attributes::type_def const& p) -> bool
-                                 { return p != attributes::void_; })
+           (attribute_conditional<attributes::type_def>
+            ([] (attributes::type_def const& p) -> bool
+             { return p != attributes::void_; })
             [c_type] | "void*")
            << " __out_param_" << string << " = {};\n")
         ]
-        | attribute_conditional([] (attributes::parameter_def const& p) -> bool
-                                { return p.direction == attributes::parameter_direction::inout; })
+        | attribute_conditional<attributes::parameter_def>
+        ([] (attributes::parameter_def const& p) -> bool
+         { return p.direction == attributes::parameter_direction::inout; })
         [
           attribute_reorder<1, 2, 1, 1, 2>
           (scope_tab <<
-           (attribute_conditional([] (attributes::type_def const& p) -> bool
-                                 { return p != attributes::void_; })
+           (attribute_conditional<attributes::type_def>
+            ([] (attributes::type_def const& p) -> bool
+             { return p != attributes::void_; })
             [c_type] | "void*")
            << " __out_param_" << string << " = ::efl::eolian::convert_inout<" << c_type
            << ", " << type << ">(" << string << ");\n")
@@ -127,8 +131,9 @@ struct function_definition_generator
             "\n" << scope_tab << scope_tab << ", "
             <<
             (
-             attribute_conditional([] (attributes::parameter_def const& p)
-             { return p.direction == attributes::parameter_direction::in; })
+             attribute_conditional<attributes::parameter_def>
+             ([] (attributes::parameter_def const& p)
+              { return p.direction == attributes::parameter_direction::in; })
              [converting_argument]
              | ("& __out_param_" << attribute_reorder<2>(string))
             )
@@ -138,8 +143,9 @@ struct function_definition_generator
         return false;
 
       auto out_assignments =
-        attribute_conditional([] (attributes::parameter_def const& p) -> bool
-                              { return p.direction != attributes::parameter_direction::in; })
+        attribute_conditional<attributes::parameter_def>
+        ([] (attributes::parameter_def const& p) -> bool
+         { return p.direction != attributes::parameter_direction::in; })
         [
           attribute_reorder<-1, 1, 1, 2, 2>
           (
diff --git a/src/lib/eolian_cxx/grammar/klass_def.hpp b/src/lib/eolian_cxx/grammar/klass_def.hpp
index 16d15b6f24..f2a86bd28b 100644
--- a/src/lib/eolian_cxx/grammar/klass_def.hpp
+++ b/src/lib/eolian_cxx/grammar/klass_def.hpp
@@ -747,6 +747,27 @@ struct tuple_element<2ul, function_def>
    static type const& get(function_def const& f) { return f.parameters; }
 };
 
+template <>
+struct tuple_element<0ul, function_def const>
+{
+   typedef type_def const type;
+   static type const& get(function_def const& f) { return f.return_type; }
+};
+
+template <>
+struct tuple_element<1ul, function_def const>
+{
+   typedef std::string const type;
+   static type const& get(function_def const& f) { return f.name; }
+};
+
+template <>
+struct tuple_element<2ul, function_def const>
+{
+   typedef std::vector<parameter_def> const type;
+   static type const& get(function_def const& f) { return f.parameters; }
+};
+
 // template <int N>
 // struct tuple_element<N, function_def const> : tuple_element<N, function_def> {};
 // template <int N>
@@ -1261,7 +1282,11 @@ namespace type_traits {
 template <>
 struct is_tuple<attributes::parameter_def> : std::true_type {};
 template <>
+struct is_tuple<attributes::function_def> : std::true_type {};
+template <>
 struct is_tuple<attributes::event_def> : std::true_type {};
+template <>
+struct is_tuple<attributes::klass_name> : std::true_type {};
   
 }
 
diff --git a/src/lib/eolian_cxx/grammar/parameter.hpp b/src/lib/eolian_cxx/grammar/parameter.hpp
index e06cfeaaf0..20273c8fd0 100644
--- a/src/lib/eolian_cxx/grammar/parameter.hpp
+++ b/src/lib/eolian_cxx/grammar/parameter.hpp
@@ -95,6 +95,8 @@ struct is_generator<parameter_as_argument_generator> : std::true_type {};
 namespace type_traits {
 template <>
 struct attributes_needed<parameter_as_argument_generator> : std::integral_constant<int, 1> {};
+template <>
+struct accepts_specific_tuple<parameter_as_argument_generator, attributes::parameter_def> : std::true_type {};
 }
 parameter_as_argument_generator const parameter_as_argument = {};
       
diff --git a/src/lib/eolian_cxx/grammar/sequence.hpp b/src/lib/eolian_cxx/grammar/sequence.hpp
index dfffbf3394..3e5c3385cb 100644
--- a/src/lib/eolian_cxx/grammar/sequence.hpp
+++ b/src/lib/eolian_cxx/grammar/sequence.hpp
@@ -13,7 +13,7 @@ struct sequence_size : std::integral_constant<int, 0> {};
 
 template <typename L, typename R>
 struct sequence_size<sequence_generator<L, R>> : std::integral_constant<int, 1 + sequence_size<L>::value> {};
-      
+
 template <typename L, typename R, typename OutputIterator, typename Attribute, typename Context>
 bool generate_sequence(L const& l, R const& r
                        , OutputIterator sink, Attribute const& attr, Context const& context
@@ -23,9 +23,10 @@ bool generate_sequence(L const& l, R const& r
    bool b = attributes::generate(gen_left, sink, attr, context);
    if(b)
      {
-        return attributes::generate(as_generator(r), sink
-                                    , attributes::pop_front_n<type_traits::attributes_needed<decltype(gen_left)>::value>
-                                    (attr), context);
+        return attributes::generate
+          (as_generator(r), sink
+           , attributes::pop_front_n<type_traits::attributes_needed<decltype(gen_left)>::value>
+           (attr), context);
      }
    else
      return false;
diff --git a/src/lib/eolian_cxx/grammar/type_traits.hpp b/src/lib/eolian_cxx/grammar/type_traits.hpp
index 8e5e52e34b..a60659df46 100644
--- a/src/lib/eolian_cxx/grammar/type_traits.hpp
+++ b/src/lib/eolian_cxx/grammar/type_traits.hpp
@@ -57,6 +57,9 @@ struct is_tuple<T volatile&> : is_tuple<T> {};
 
 template <typename T>
 struct is_tuple<T, typename std::enable_if<!std::is_const<T>::value && is_std_tuple<T>::value>::type> : std::true_type {};
+
+template <typename Generator, typename Tuple, typename Enable = void>
+struct accepts_specific_tuple : std::false_type {};
   
 } } } }
author	Felipe Magno de Almeida <felipe@expertisesolutions.com.br>	2018-01-17 13:36:59 -0200
committer	Felipe Magno de Almeida <felipe@expertisesolutions.com.br>	2018-01-17 13:36:59 -0200
commit	166c371e93505adfcc6217c706ec704c30b99450 (patch)
tree	2b11f1e704a4f7c2400b882fd8ab6202eb5b0d4b
parent	f8e36dce771c6ff0b44e4714437dc143b9354c9a (diff)
download	efl-166c371e93505adfcc6217c706ec704c30b99450.tar.gz