diff --git a/requirements.txt b/requirements.txt
index 703f684..9f5087d 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,4 +1,5 @@
 click
 pytest
 pytest-ordering
-http://www.opengrm.org/twiki/pub/GRM/PyniniDownload/pynini-2.0.5.tar.gz#egg=pynini
+Cython
+http://www.opengrm.org/twiki/pub/GRM/PyniniDownload/pynini-2.1.3.tar.gz#egg=pynini
diff --git a/timur/fsts/deko_fst.py b/timur/fsts/deko_fst.py
index 3662efd..d5fff72 100644
--- a/timur/fsts/deko_fst.py
+++ b/timur/fsts/deko_fst.py
@@ -349,7 +349,7 @@ def __construct_del_ge(self):
     Case-dependent deletion of the ge marker
     '''
 
-    # delete <ge> at certain suffixes like 'ver'
+    # delete <ge> at certain prefixes like 'ver'
     return pynini.concat(
         pynini.transducer("<no-ge>", "", input_token_type=self.__syms.alphabet),
         pynini.concat(
diff --git a/timur/fsts/map_fst.py b/timur/fsts/map_fst.py
index 0c1947b..4de63f3 100644
--- a/timur/fsts/map_fst.py
+++ b/timur/fsts/map_fst.py
@@ -11,236 +11,211 @@ class MapFst:
   '''
 
   def __init__(self, syms):
+    
+    with pynini.default_token_type(syms.alphabet):
+
+      # store alphabet
+      self.__syms = syms
+
+      # delete initial features
+      del_initial_features = pynini.cross("", syms.initial_features)
+
+      # delete categories
+      del_cat_ext = pynini.cross("", pynini.union(syms.categories, syms.disjunctive_categories))
+
+      # delete stem types
+      del_stem_types = pynini.cross("", syms.stem_types)
+
+      # delete prefix/suffix marker
+      del_prefix_suffix_marker = pynini.cross("", syms.prefix_suffix_marker)
+
+      # insert prefix/suffix marker
+      insert_prefix_suffix_marker = pynini.cross(syms.prefix_suffix_marker, "")
+
+      # delete stem type features
+      del_stem_type_feats = pynini.cross("", syms.stem_type_features)
+
+      # delete origin features
+      del_origin_feats = pynini.cross("", syms.origin_features)
+
+      # delete complexity agreement features
+      del_complexity_agreement_feats = pynini.cross("", syms.complexity_agreement_features)
+
+      # delete word complexity features
+      del_complex_lex_entries = pynini.cross("", syms.complexity_entry_features)
+
+      # insert word complexity features
+      insert_complex_lex_entries = pynini.cross(syms.complexity_entry_features, "")
+
+      # inflection classes
+      del_infl_classes = pynini.cross("", syms.inflection_classes)
+
+      # disjunctive features
+      disjunctive_feat_list = ["<CARD,DIGCARD,NE>", "<ADJ,CARD>", "<ADJ,NN>", "<CARD,NN>",
+      "<CARD,NE>", "<ABK,ADJ,NE,NN>", "<ADJ,NE,NN>", "<ABK,NE,NN>",
+      "<NE,NN>", "<ABK,CARD,NN>", "<ABK,NN>", "<ADJ,CARD,NN,V>",
+      "<ADJ,NN,V>", "<ABK,ADJ,NE,NN,V>", "<ADJ,NE,NN,V>", "<ADV,NE,NN,V>",
+      "<ABK,NE,NN,V>", "<NE,NN,V>", "<ABK,NN,V>", "<NN,V>", 
+      "<frei,fremd,gebunden>", "<frei,fremd,gebunden,kurz>", "<frei,fremd,gebunden,lang>", 
+      "<fremd,gebunden,lang>", "<frei,fremd,kurz>", "<frei,fremd,lang>", "<frei,gebunden>", 
+      "<frei,gebunden,kurz,lang>", "<frei,gebunden,lang>", "<frei,lang>", "<klassisch,nativ>", 
+      "<fremd,klassisch,nativ>", "<fremd,klassisch>", "<frei,nativ>", "<frei,fremd,nativ>", 
+      "<fremd,nativ>","<nativ,prefnativ>","<frei,nativ,prefnativ>",
+      "<komposit,prefderiv,simplex,suffderiv>", "<prefderiv,suffderiv>", 
+      "<komposit,prefderiv,simplex>", "<komposit,simplex,suffderiv>", "<komposit,simplex>", 
+      "<prefderiv,simplex,suffderiv>", "<prefderiv,simplex>", "<simplex,suffderiv>"]
+      disjunctive_feats = pynini.string_map(disjunctive_feat_list).project("input").optimize()
+      del_disjunctive_feats = pynini.cross("", disjunctive_feats)
+
+      # short cut: map_helper1
+      map_helper1 = pynini.union(
+        syms.characters,
+        pynini.accep("<FB>"),
+        pynini.accep("<SS>"),
+        pynini.cross("e", "<Ge-Nom>"),
+        pynini.cross("n", "<n>"),
+        pynini.cross("e", "<e>"),
+        pynini.cross("d", "<d>"),
+        pynini.cross("", "<~n>"),
+        pynini.cross("", "<UL>"),
+        del_stem_types,
+        syms.prefix_suffix_marker,
+        del_stem_type_feats,
+        pynini.cross("", "<ge>"),
+        del_origin_feats,
+        del_complexity_agreement_feats,
+        del_complex_lex_entries,
+        del_infl_classes,
+        del_disjunctive_feats,
+        ).closure().optimize()
+
+      # short cut: map_helper2
+      map_helper2 = pynini.concat(
+        map_helper1,
+        pynini.concat(
+          pynini.concat(
+            syms.characters,
+            pynini.union(
+              pynini.union(
+                syms.characters,
+                pynini.accep("<SUFF>"),
+                pynini.accep("<CONV>")
+                ),
+              syms.categories
+              ).closure(),
+            ).closure(0, 1),
+          map_helper1
+          )
+        ).optimize()
 
-    # store alphabet
-    self.__syms = syms
-
-    # delete initial features
-    del_initial_features = pynini.transducer("", syms.initial_features)
-
-    # delete categories
-    del_cat_ext = pynini.transducer("", pynini.union(syms.categories, syms.disjunctive_categories))
-
-    # delete stem types
-    del_stem_types = pynini.transducer("", syms.stem_types)
-
-    # delete prefix/suffix marker
-    del_prefix_suffix_marker = pynini.transducer("", syms.prefix_suffix_marker)
-
-    # insert prefix/suffix marker
-    insert_prefix_suffix_marker = pynini.transducer(syms.prefix_suffix_marker, "")
-
-    # delete stem type features
-    del_stem_type_feats = pynini.transducer("", syms.stem_type_features)
-
-    # delete origin features
-    del_origin_feats = pynini.transducer("", syms.origin_features)
-
-    # delete complexity agreement features
-    del_complexity_agreement_feats = pynini.transducer("", syms.complexity_agreement_features)
-
-    # delete word complexity features
-    del_complex_lex_entries = pynini.transducer("", syms.complexity_entry_features)
-
-    # insert word complexity features
-    insert_complex_lex_entries = pynini.transducer(syms.complexity_entry_features, "")
-
-    # inflection classes
-    del_infl_classes = pynini.transducer("", syms.inflection_classes)
-
-    # disjunctive features
-    disjunctive_feat_list = ["<CARD,DIGCARD,NE>", "<ADJ,CARD>", "<ADJ,NN>", "<CARD,NN>",
-    "<CARD,NE>", "<ABK,ADJ,NE,NN>", "<ADJ,NE,NN>", "<ABK,NE,NN>",
-    "<NE,NN>", "<ABK,CARD,NN>", "<ABK,NN>", "<ADJ,CARD,NN,V>",
-    "<ADJ,NN,V>", "<ABK,ADJ,NE,NN,V>", "<ADJ,NE,NN,V>", "<ADV,NE,NN,V>",
-    "<ABK,NE,NN,V>", "<NE,NN,V>", "<ABK,NN,V>", "<NN,V>", 
-    "<frei,fremd,gebunden>", "<frei,fremd,gebunden,kurz>", "<frei,fremd,gebunden,lang>", 
-    "<fremd,gebunden,lang>", "<frei,fremd,kurz>", "<frei,fremd,lang>", "<frei,gebunden>", 
-    "<frei,gebunden,kurz,lang>", "<frei,gebunden,lang>", "<frei,lang>", "<klassisch,nativ>", 
-    "<fremd,klassisch,nativ>", "<fremd,klassisch>", "<frei,nativ>", "<frei,fremd,nativ>", 
-    "<fremd,nativ>","<nativ,prefnativ>","<frei,nativ,prefnativ>",
-    "<komposit,prefderiv,simplex,suffderiv>", "<prefderiv,suffderiv>", 
-    "<komposit,prefderiv,simplex>", "<komposit,simplex,suffderiv>", "<komposit,simplex>", 
-    "<prefderiv,simplex,suffderiv>", "<prefderiv,simplex>", "<simplex,suffderiv>"]
-    disjunctive_feats = pynini.string_map(disjunctive_feat_list, input_token_type=syms.alphabet, output_token_type=syms.alphabet).project().optimize()
-    del_disjunctive_feats = pynini.transducer("", disjunctive_feats)
-
-    # short cut: map_helper1
-    map_helper1 = pynini.union(
-      syms.characters,
-      pynini.acceptor("<FB>", token_type=syms.alphabet),
-      pynini.acceptor("<SS>", token_type=syms.alphabet),
-      pynini.transducer("e", "<Ge-Nom>", input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("n", "<n>", input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("e", "<e>", input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("d", "<d>", input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("", "<~n>", output_token_type=syms.alphabet),
-      pynini.transducer("", "<UL>", output_token_type=syms.alphabet),
-      del_stem_types,
-      syms.prefix_suffix_marker,
-      del_stem_type_feats,
-      pynini.transducer("", "<ge>", output_token_type=syms.alphabet),
-      del_origin_feats,
-      del_complexity_agreement_feats,
-      del_complex_lex_entries,
-      del_infl_classes,
-      del_disjunctive_feats,
-      ).closure().optimize()
-
-    # short cut: map_helper2
-    map_helper2 = pynini.concat(
-      map_helper1,
-      pynini.concat(
+      # 
+      self.__map1 = pynini.concat(
+        del_initial_features.closure(),
         pynini.concat(
-          syms.characters,
           pynini.union(
-            pynini.union(
-              syms.characters,
-              pynini.acceptor("<SUFF>", token_type=syms.alphabet),
-              pynini.acceptor("<CONV>", token_type=syms.alphabet)
+            pynini.concat(
+              pynini.cross("", pynini.string_map(["<Base_Stems>", "<Pref_Stems>"]).project("input")),
+              pynini.concat(map_helper2, del_cat_ext)
               ),
-            syms.categories
-            ).closure(),
-          ).closure(0, 1),
-        map_helper1
-        )
-      ).optimize()
-
-    # 
-    self.__map1 = pynini.concat(
-      del_initial_features.closure(),
-      pynini.concat(
-        pynini.union(
-          pynini.concat(
-            pynini.transducer("", pynini.string_map(["<Base_Stems>", "<Pref_Stems>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project()),
-            pynini.concat(map_helper2, del_cat_ext)
-            ),
-          pynini.concat(
-            pynini.transducer("", pynini.string_map(["<Deriv_Stems>", "<Kompos_Stems>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project()),
-            pynini.concat(map_helper2, syms.categories)
-            ),
-          pynini.concat(
-            pynini.transducer("", "<Pref_Stems>", output_token_type=syms.alphabet),
-            map_helper1,
-            del_cat_ext
-            ),
-          pynini.concat(
-            pynini.transducer("", "<Suff_Stems>", output_token_type=syms.alphabet),
-            map_helper1,
-            del_cat_ext,
-            map_helper1,
-            syms.categories,
-            pynini.transducer("", "<base>", output_token_type=syms.alphabet)
-            ),
-          pynini.concat(
-            pynini.transducer("", "<Suff_Stems>", output_token_type=syms.alphabet),
-            map_helper1,
-            del_cat_ext,
             pynini.concat(
-              map_helper1,
-              del_cat_ext,
-              pynini.acceptor("<SUFF>", token_type=syms.alphabet)
-              ).closure(1),
-              pynini.transducer("", "<base>", output_token_type=syms.alphabet)
+              pynini.cross("", pynini.string_map(["<Deriv_Stems>", "<Kompos_Stems>"]).project("input")),
+              pynini.concat(map_helper2, syms.categories)
+              ),
+            pynini.cross("", "<Pref_Stems>") + map_helper1 + del_cat_ext,
+            pynini.cross("", "<Suff_Stems>") + map_helper1 + del_cat_ext
+              + map_helper1 + syms.categories + pynini.cross("", "<base>"),
+            pynini.cross("", "<Suff_Stems>") + map_helper1 + del_cat_ext
+              + pynini.concat(map_helper1, del_cat_ext + pynini.accep("<SUFF>")).closure(1) 
+              + pynini.cross("", "<base>"),
+            pynini.cross("", "<Suff_Stems>") + map_helper1 + del_cat_ext
+              + pynini.concat(map_helper1, syms.categories + pynini.accep("<SUFF>")).closure(1)
+              + pynini.cross("", pynini.string_map(["<deriv>", "<kompos>"]).project("input"))
             ),
-          pynini.concat(
-            pynini.transducer("", "<Suff_Stems>", output_token_type=syms.alphabet),
-            map_helper1,
-            del_cat_ext,
-            pynini.concat(
-              map_helper1,
-              syms.categories,
-              pynini.acceptor("<SUFF>", token_type=syms.alphabet)
-              ).closure(1),
-            pynini.transducer("", pynini.string_map(["<deriv>", "<kompos>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project())
-            )
-          ),
-        map_helper1,
-      )
-    ).optimize()
-
-    split_origin_features = pynini.union(
-      pynini.transducer("<NGeo-0-$er-$er>", pynini.string_map(["<NGeo-0-Name-Neut_s>", "<NGeo-$er-NMasc_s_0>", "<NGeo-$er-Adj0-Up>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-0-$er-$isch>", pynini.string_map(["<NGeo-0-Name-Neut_s>", "<NGeo-$er-NMasc_s_0>", "<NGeo-$isch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-0-aner-aner>", pynini.string_map(["<NGeo-0-Name-Neut_s>", "<NGeo-aner-NMasc_s_0>", "<NGeo-aner-Adj0-Up>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-0-aner-anisch>", pynini.string_map(["<NGeo-0-Name-Neut_s>", "<NGeo-aner-NMasc_s_0>", "<NGeo-anisch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-0-e-isch>", pynini.string_map(["<NGeo-0-Name-Neut_s>", "<NGeo-e-NMasc_n_n>", "<NGeo-isch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-0-er-er>", pynini.string_map(["<NGeo-0-Name-Neut_s>", "<NGeo-er-NMasc_s_0>", "<NGeo-er-Adj0-Up>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-0-0-0>", pynini.string_map(["<NGeo-0-Name-Neut_s>", "<NGeo-0-NMasc_s_0>", "<NGeo-0-Adj0-Up>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-0-er-erisch>", pynini.string_map(["<NGeo-0-Name-Neut_s>", "<NGeo-er-NMasc_s_0>", "<NGeo-erisch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-0-er-isch>", pynini.string_map(["<NGeo-0-Name-Neut_s>", "<NGeo-er-NMasc_s_0>", "<NGeo-isch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-0-ese-esisch>", pynini.string_map(["<NGeo-0-Name-Neut_s>", "<NGeo-ese-NMasc_n_n>", "<NGeo-esisch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-0-ianer-ianisch>", pynini.string_map(["<NGeo-0-Name-Neut_s>", "<NGeo-ianer-NMasc_s_0>", "<NGeo-ianisch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-0-ner-isch>", pynini.string_map(["<NGeo-0-Name-Neut_s>", "<NGeo-ner-NMasc_s_0>", "<NGeo-isch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-0-ner-nisch>", pynini.string_map(["<NGeo-0-Name-Neut_s>", "<NGeo-ner-NMasc_s_0>", "<NGeo-nisch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-0fem-er-erisch>", pynini.string_map(["<NGeo-0-Name-Fem_0>", "<NGeo-er-NMasc_s_0>", "<NGeo-erisch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-0masc-er-isch>", pynini.string_map(["<NGeo-0-Name-Masc_s>", "<NGeo-er-NMasc_s_0>", "<NGeo-isch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-0masc-ese-esisch>", pynini.string_map(["<NGeo-0-Name-Masc_s>", "<NGeo-ese-NMasc_n_n>", "<NGeo-esisch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-a-er-isch>", pynini.string_map(["<NGeo-a-Name-Neut_s>", "<NGeo-er-NMasc_s_0>", "<NGeo-isch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-a-ese-esisch>", pynini.string_map(["<NGeo-a-Name-Neut_s>", "<NGeo-ese-NMasc_n_n>", "<NGeo-esisch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-afem-er-isch>", pynini.string_map(["<NGeo-a-Name-Fem_s>", "<NGeo-er-NMasc_s_0>", "<NGeo-isch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-e-er-er>", pynini.string_map(	["<NGeo-e-Name-Neut_s>", "<NGeo-er-NMasc_s_0>", "<NGeo-er-Adj0-Up>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-e-er-isch>", pynini.string_map(["<NGeo-e-Name-Neut_s>", "<NGeo-er-NMasc_s_0>", "<NGeo-isch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-efem-er-isch>", pynini.string_map(["<NGeo-e-Name-Fem_0>", "<NGeo-er-NMasc_s_0>", "<NGeo-isch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-ei-e-isch>", pynini.string_map(["<NGeo-ei-Name-Fem_0>", "<NGeo-e-NMasc_n_n>", "<NGeo-isch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-en-aner-anisch>", pynini.string_map(["<NGeo-en-Name-Neut_s>", "<NGeo-aner-NMasc_s_0>", "<NGeo-anisch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-en-e-$isch>", pynini.string_map(["<NGeo-en-Name-Neut_s>", "<NGeo-e-NMasc_n_n>", "<NGeo-$isch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-en-e-isch>", pynini.string_map(["<NGeo-en-Name-Neut_s>", "<NGeo-e-NMasc_n_n>", "<NGeo-isch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-en-er-er>", pynini.string_map(["<NGeo-en-Name-Neut_s>", "<NGeo-er-NMasc_s_0>", "<NGeo-er-Adj0-Up>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-en-er-isch>", pynini.string_map(["<NGeo-en-Name-Neut_s>", "<NGeo-er-NMasc_s_0>", "<NGeo-isch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-ien-e-isch>", pynini.string_map(["<NGeo-ien-Name-Neut_s>", "<NGeo-e-NMasc_n_n>", "<NGeo-isch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-ien-er-isch>", pynini.string_map(["<NGeo-ien-Name-Neut_s>", "<NGeo-er-NMasc_s_0>", "<NGeo-isch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-ien-ese-esisch>", pynini.string_map(["<NGeo-ien-Name-Neut_s>", "<NGeo-ese-NMasc_n_n>", "<NGeo-esisch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-ien-ianer-ianisch>", pynini.string_map(["<NGeo-ien-Name-Neut_s>", "<NGeo-ianer-NMasc_s_0>", "<NGeo-ianisch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-ien-ier-isch>", pynini.string_map(["<NGeo-ien-Name-Neut_s>", "<NGeo-ier-NMasc_s_0>", "<NGeo-isch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-istan-e-isch>", pynini.string_map(["<NGeo-istan-Name-Neut_s>", "<NGeo-e-NMasc_n_n>", "<NGeo-isch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-land-$er-$er>", pynini.string_map(["<NGeo-land-Name-Neut_s>", "<NGeo-$er-NMasc_s_0>", "<NGeo-$er-Adj0-Up>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-land-e-isch>", pynini.string_map(["<NGeo-land-Name-Neut_s>", "<NGeo-e-NMasc_n_n>", "<NGeo-isch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet),
-      pynini.transducer("<NGeo-land-e-nisch>", pynini.string_map(["<NGeo-land-Name-Neut_s>", "<NGeo-e-NMasc_n_n>", "<NGeo-nisch-Adj+>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(), input_token_type=syms.alphabet, output_token_type=syms.alphabet)
-      ).optimize()
-
-    map_helper3 = pynini.union(
-      syms.characters,
-      syms.circumfix_features,
-      syms.initial_features,
-      syms.stem_types,
-      syms.categories,
-      insert_prefix_suffix_marker,
-      syms.stem_type_features,
-      syms.origin_features,
-      syms.complexity_agreement_features,
-      insert_complex_lex_entries,
-      syms.inflection_classes,
-      self.__split_disjunctive_feats(disjunctive_feat_list),
-      split_origin_features
+          map_helper1,
+        )
       ).optimize()
 
-    self.__map2 = pynini.concat(
-      map_helper3.closure(),
-      pynini.concat(
-        pynini.transducer("e", "<e>", input_token_type=syms.alphabet, output_token_type=syms.alphabet),
+      split_origin_features = pynini.union(
+        pynini.cross("<NGeo-0-$er-$er>", pynini.string_map(["<NGeo-0-Name-Neut_s>", "<NGeo-$er-NMasc_s_0>", "<NGeo-$er-Adj0-Up>"]).project("input")),
+        pynini.cross("<NGeo-0-$er-$isch>", pynini.string_map(["<NGeo-0-Name-Neut_s>", "<NGeo-$er-NMasc_s_0>", "<NGeo-$isch-Adj+>"]).project("input")),
+        pynini.cross("<NGeo-0-aner-aner>", pynini.string_map(["<NGeo-0-Name-Neut_s>", "<NGeo-aner-NMasc_s_0>", "<NGeo-aner-Adj0-Up>"]).project("input")),
+        pynini.cross("<NGeo-0-aner-anisch>", pynini.string_map(["<NGeo-0-Name-Neut_s>", "<NGeo-aner-NMasc_s_0>", "<NGeo-anisch-Adj+>"]).project("input")),
+        pynini.cross("<NGeo-0-e-isch>", pynini.string_map(["<NGeo-0-Name-Neut_s>", "<NGeo-e-NMasc_n_n>", "<NGeo-isch-Adj+>"]).project("input")),
+        pynini.cross("<NGeo-0-er-er>", pynini.string_map(["<NGeo-0-Name-Neut_s>", "<NGeo-er-NMasc_s_0>", "<NGeo-er-Adj0-Up>"]).project("input")),
+        pynini.cross("<NGeo-0-0-0>", pynini.string_map(["<NGeo-0-Name-Neut_s>", "<NGeo-0-NMasc_s_0>", "<NGeo-0-Adj0-Up>"]).project("input")),
+        pynini.cross("<NGeo-0-er-erisch>", pynini.string_map(["<NGeo-0-Name-Neut_s>", "<NGeo-er-NMasc_s_0>", "<NGeo-erisch-Adj+>"]).project("input")),
+        pynini.cross("<NGeo-0-er-isch>", pynini.string_map(["<NGeo-0-Name-Neut_s>", "<NGeo-er-NMasc_s_0>", "<NGeo-isch-Adj+>"]).project("input")),
+        pynini.cross("<NGeo-0-ese-esisch>", pynini.string_map(["<NGeo-0-Name-Neut_s>", "<NGeo-ese-NMasc_n_n>", "<NGeo-esisch-Adj+>"]).project("input")),
+        pynini.cross("<NGeo-0-ianer-ianisch>", pynini.string_map(["<NGeo-0-Name-Neut_s>", "<NGeo-ianer-NMasc_s_0>", "<NGeo-ianisch-Adj+>"]).project("input")),
+        pynini.cross("<NGeo-0-ner-isch>", pynini.string_map(["<NGeo-0-Name-Neut_s>", "<NGeo-ner-NMasc_s_0>", "<NGeo-isch-Adj+>"]).project("input")),
+        pynini.cross("<NGeo-0-ner-nisch>", pynini.string_map(["<NGeo-0-Name-Neut_s>", "<NGeo-ner-NMasc_s_0>", "<NGeo-nisch-Adj+>"]).project("input")),
+        pynini.cross("<NGeo-0fem-er-erisch>", pynini.string_map(["<NGeo-0-Name-Fem_0>", "<NGeo-er-NMasc_s_0>", "<NGeo-erisch-Adj+>"]).project("input")),
+        pynini.cross("<NGeo-0masc-er-isch>", pynini.string_map(["<NGeo-0-Name-Masc_s>", "<NGeo-er-NMasc_s_0>", "<NGeo-isch-Adj+>"]).project("input")),
+        pynini.cross("<NGeo-0masc-ese-esisch>", pynini.string_map(["<NGeo-0-Name-Masc_s>", "<NGeo-ese-NMasc_n_n>", "<NGeo-esisch-Adj+>"]).project("input")),
+        pynini.cross("<NGeo-a-er-isch>", pynini.string_map(["<NGeo-a-Name-Neut_s>", "<NGeo-er-NMasc_s_0>", "<NGeo-isch-Adj+>"]).project("input")),
+        pynini.cross("<NGeo-a-ese-esisch>", pynini.string_map(["<NGeo-a-Name-Neut_s>", "<NGeo-ese-NMasc_n_n>", "<NGeo-esisch-Adj+>"]).project("input")),
+        pynini.cross("<NGeo-afem-er-isch>", pynini.string_map(["<NGeo-a-Name-Fem_s>", "<NGeo-er-NMasc_s_0>", "<NGeo-isch-Adj+>"]).project("input")),
+        pynini.cross("<NGeo-e-er-er>", pynini.string_map(	["<NGeo-e-Name-Neut_s>", "<NGeo-er-NMasc_s_0>", "<NGeo-er-Adj0-Up>"]).project("input")),
+        pynini.cross("<NGeo-e-er-isch>", pynini.string_map(["<NGeo-e-Name-Neut_s>", "<NGeo-er-NMasc_s_0>", "<NGeo-isch-Adj+>"]).project("input")),
+        pynini.cross("<NGeo-efem-er-isch>", pynini.string_map(["<NGeo-e-Name-Fem_0>", "<NGeo-er-NMasc_s_0>", "<NGeo-isch-Adj+>"]).project("input")),
+        pynini.cross("<NGeo-ei-e-isch>", pynini.string_map(["<NGeo-ei-Name-Fem_0>", "<NGeo-e-NMasc_n_n>", "<NGeo-isch-Adj+>"]).project("input")),
+        pynini.cross("<NGeo-en-aner-anisch>", pynini.string_map(["<NGeo-en-Name-Neut_s>", "<NGeo-aner-NMasc_s_0>", "<NGeo-anisch-Adj+>"]).project("input")),
+        pynini.cross("<NGeo-en-e-$isch>", pynini.string_map(["<NGeo-en-Name-Neut_s>", "<NGeo-e-NMasc_n_n>", "<NGeo-$isch-Adj+>"]).project("input")),
+        pynini.cross("<NGeo-en-e-isch>", pynini.string_map(["<NGeo-en-Name-Neut_s>", "<NGeo-e-NMasc_n_n>", "<NGeo-isch-Adj+>"]).project("input")),
+        pynini.cross("<NGeo-en-er-er>", pynini.string_map(["<NGeo-en-Name-Neut_s>", "<NGeo-er-NMasc_s_0>", "<NGeo-er-Adj0-Up>"]).project("input")),
+        pynini.cross("<NGeo-en-er-isch>", pynini.string_map(["<NGeo-en-Name-Neut_s>", "<NGeo-er-NMasc_s_0>", "<NGeo-isch-Adj+>"]).project("input")),
+        pynini.cross("<NGeo-ien-e-isch>", pynini.string_map(["<NGeo-ien-Name-Neut_s>", "<NGeo-e-NMasc_n_n>", "<NGeo-isch-Adj+>"]).project("input")),
+        pynini.cross("<NGeo-ien-er-isch>", pynini.string_map(["<NGeo-ien-Name-Neut_s>", "<NGeo-er-NMasc_s_0>", "<NGeo-isch-Adj+>"]).project("input")),
+        pynini.cross("<NGeo-ien-ese-esisch>", pynini.string_map(["<NGeo-ien-Name-Neut_s>", "<NGeo-ese-NMasc_n_n>", "<NGeo-esisch-Adj+>"]).project("input")),
+        pynini.cross("<NGeo-ien-ianer-ianisch>", pynini.string_map(["<NGeo-ien-Name-Neut_s>", "<NGeo-ianer-NMasc_s_0>", "<NGeo-ianisch-Adj+>"]).project("input")),
+        pynini.cross("<NGeo-ien-ier-isch>", pynini.string_map(["<NGeo-ien-Name-Neut_s>", "<NGeo-ier-NMasc_s_0>", "<NGeo-isch-Adj+>"]).project("input")),
+        pynini.cross("<NGeo-istan-e-isch>", pynini.string_map(["<NGeo-istan-Name-Neut_s>", "<NGeo-e-NMasc_n_n>", "<NGeo-isch-Adj+>"]).project("input")),
+        pynini.cross("<NGeo-land-$er-$er>", pynini.string_map(["<NGeo-land-Name-Neut_s>", "<NGeo-$er-NMasc_s_0>", "<NGeo-$er-Adj0-Up>"]).project("input")),
+        pynini.cross("<NGeo-land-e-isch>", pynini.string_map(["<NGeo-land-Name-Neut_s>", "<NGeo-e-NMasc_n_n>", "<NGeo-isch-Adj+>"]).project("input")),
+        pynini.cross("<NGeo-land-e-nisch>", pynini.string_map(["<NGeo-land-Name-Neut_s>", "<NGeo-e-NMasc_n_n>", "<NGeo-nisch-Adj+>"]).project("input"))
+        ).optimize()
+
+      map_helper3 = pynini.union(
+        syms.characters,
+        syms.circumfix_features,
+        syms.initial_features,
+        syms.stem_types,
+        syms.categories,
+        insert_prefix_suffix_marker,
+        syms.stem_type_features,
+        syms.origin_features,
+        syms.complexity_agreement_features,
+        insert_complex_lex_entries,
+        syms.inflection_classes,
+        self.__split_disjunctive_feats(disjunctive_feat_list),
+        split_origin_features
+        ).optimize()
+
+      self.__map2 = pynini.concat(
+        map_helper3.closure(),
         pynini.concat(
-          pynini.string_map(["l", "r"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project(),
+          pynini.cross("e", "<e>"),
           pynini.concat(
-            pynini.string_map(["<ADJ>", "<NE>", "<NN>", "<V>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project().closure(0,1),
+            pynini.string_map(["l", "r"]).project("input"),
             pynini.concat(
-              pynini.acceptor("<V>", token_type=syms.alphabet),
+              pynini.string_map(["<ADJ>", "<NE>", "<NN>", "<V>"]).project("input").closure(0,1),
               pynini.concat(
-                pynini.string_map(["<SUFF>", "<CONV>"], input_token_type=syms.alphabet, output_token_type=syms.alphabet).project().closure(0,1),
+                pynini.accep("<V>"),
                 pynini.concat(
-                  pynini.acceptor("<base> <nativ>", token_type=syms.alphabet),
+                  pynini.string_map(["<SUFF>", "<CONV>"]).project("input").closure(0,1),
                   pynini.concat(
-                    insert_complex_lex_entries.closure(0,1),
-                    pynini.acceptor("<VVReg-el/er>", token_type=syms.alphabet)
+                    pynini.accep("<base> <nativ>"),
+                    pynini.concat(
+                      insert_complex_lex_entries.closure(0,1),
+                      pynini.accep("<VVReg-el/er>")
+                      )
                     )
                   )
                 )
               )
             )
-          )
-        ).closure(0,1)
-      ).optimize()
-
+          ).closure(0,1)
+        ).optimize()
 
   @property
   def map1(self):
@@ -251,10 +226,11 @@ def map2(self):
     return self.__map2
 
   def __split_disjunctive_feats(self, disjunctive_feat_list):
-    single_splits = []
-    for disjunctive_feat in disjunctive_feat_list:
-      splitted = []
-      for cat in disjunctive_feat[1:-1].split(","):
-        splitted.append("<" + cat + ">")
-        single_splits.append(pynini.transducer(disjunctive_feat, pynini.string_map(splitted, input_token_type=self.__syms.alphabet, output_token_type=self.__syms.alphabet), input_token_type=self.__syms.alphabet, output_token_type=self.__syms.alphabet))
-    return pynini.union(*(single_splits)).optimize()
+    with pynini.default_token_type(self.__syms.alphabet):
+      single_splits = []
+      for disjunctive_feat in disjunctive_feat_list:
+        splitted = []
+        for cat in disjunctive_feat[1:-1].split(","):
+          splitted.append("<" + cat + ">")
+          single_splits.append(pynini.cross(disjunctive_feat, pynini.string_map(splitted)))
+      return pynini.union(*(single_splits)).optimize()
diff --git a/timur/fsts/sublexica.py b/timur/fsts/sublexica.py
index f6bc203..0c0bd63 100644
--- a/timur/fsts/sublexica.py
+++ b/timur/fsts/sublexica.py
@@ -12,48 +12,50 @@ class Sublexica:
 
   def __init__(self, syms, lexicon):
 
-    #
-    # store alphabet
-    self.__syms = syms
-
-    #
-    # store lexicon
-    self.__lex = lexicon
-
-
-    #
-    # (private) helpers
-    self.__sigma_star = pynini.union(
-        syms.characters,
-        syms.categories,
-        syms.stem_types,
-        syms.stem_type_features,
-        syms.origin_features,
-        syms.circumfix_features,
-        syms.inflection_classes,
-        syms.geo_inflection_classes,
-        pynini.acceptor("<ge>", token_type=syms.alphabet) # for word-internal <ge> (ausgewertet)
-        ).closure().optimize()
-
-    #
-    # NoDef2NULL
-    self.__nodef_to_null = pynini.union(
-        self.__sigma_star,
-        syms.origin_features,
-        pynini.transducer("<NoDef>", "", input_token_type=self.__syms.alphabet),
-        syms.stem_types
-        ).closure().optimize()
-
-    #
-    # sublexica
-    self.__bdk_stems = self.__construct_bdk_stems()
-    self.__base_stems = self.__construct_base_stems()
-    self.__pref_stems = self.__construct_pref_stems()
-    self.__verbal_pref_stems = self.__construct_verbal_pref_stems()
-    self.__simplex_suff_stems = self.__construct_simplex_suff_stems()
-    self.__suff_deriv_suff_stems = self.__construct_suff_deriv_suff_stems()
-    self.__pref_deriv_suff_stems = self.__construct_pref_deriv_suff_stems()
-    self.__quant_suff_stems = self.__construct_quant_suff_stems()
+    with pynini.default_token_type(syms.alphabet):
+
+      #
+      # store alphabet
+      self.__syms = syms
+
+      #
+      # store lexicon
+      self.__lex = lexicon
+
+
+      #
+      # (private) helpers
+      self.__sigma_star = pynini.union(
+          syms.characters,
+          syms.categories,
+          syms.stem_types,
+          syms.stem_type_features,
+          syms.origin_features,
+          syms.circumfix_features,
+          syms.inflection_classes,
+          syms.geo_inflection_classes,
+          pynini.accep("<ge>") # for word-internal <ge> (ausgewertet)
+          ).closure().optimize()
+
+      #
+      # NoDef2NULL
+      self.__nodef_to_null = pynini.union(
+          self.__sigma_star,
+          syms.origin_features,
+          pynini.cross("<NoDef>", ""),
+          syms.stem_types
+          ).closure().optimize()
+
+      #
+      # sublexica
+      self.__bdk_stems = self.__construct_bdk_stems()
+      self.__base_stems = self.__construct_base_stems()
+      self.__pref_stems = self.__construct_pref_stems()
+      self.__verbal_pref_stems = self.__construct_verbal_pref_stems()
+      self.__simplex_suff_stems = self.__construct_simplex_suff_stems()
+      self.__suff_deriv_suff_stems = self.__construct_suff_deriv_suff_stems()
+      self.__pref_deriv_suff_stems = self.__construct_pref_deriv_suff_stems()
+      self.__quant_suff_stems = self.__construct_quant_suff_stems()
 
   @property
   def nodef_to_null(self):
@@ -122,109 +124,117 @@ def __construct_bdk_stems(self):
     '''
     Base, derivation and compound stems (without derivation suffixes)
     '''
-    return pynini.compose(
-        self.__lex,
-        pynini.concat(
-          self.__syms.initial_features.closure(),
-          pynini.string_map(["<Base_Stems>", "<Deriv_Stems>", "<Kompos_Stems>"], input_token_type=self.__syms.alphabet, output_token_type=self.__syms.alphabet).project(),
-          self.__sigma_star
-          )
-        ).optimize()
+    with pynini.default_token_type(self.__syms.alphabet):
+      return pynini.compose(
+          self.__lex,
+          pynini.concat(
+            self.__syms.initial_features.closure(),
+            pynini.string_map(["<Base_Stems>", "<Deriv_Stems>", "<Kompos_Stems>"]).project("input"),
+            self.__sigma_star
+            )
+          ).optimize()
 
   def __construct_base_stems(self):
     '''
     Base stems
     '''
-    return pynini.compose(
-        self.__bdk_stems,
-        pynini.concat(
-          self.__syms.initial_features.closure(),
-          pynini.acceptor("<Base_Stems>", token_type=self.__syms.alphabet),
-          self.__sigma_star
-          )
-        ).optimize()
+    with pynini.default_token_type(self.__syms.alphabet):
+      return pynini.compose(
+          self.__bdk_stems,
+          pynini.concat(
+            self.__syms.initial_features.closure(),
+            pynini.accep("<Base_Stems>"),
+            self.__sigma_star
+            )
+          ).optimize()
 
   def __construct_pref_stems(self):
     '''
     Prefix stems
     '''
-    return pynini.compose(
-        self.__lex,
-        pynini.concat(
-          self.__syms.initial_features.closure(),
-          pynini.acceptor("<Pref_Stems>", token_type=self.__syms.alphabet),
-          self.__sigma_star
-          )
-        ).optimize()
+    with pynini.default_token_type(self.__syms.alphabet):
+      return pynini.compose(
+          self.__lex,
+          pynini.concat(
+            self.__syms.initial_features.closure(),
+            pynini.accep("<Pref_Stems>"),
+            self.__sigma_star
+            )
+          ).optimize()
 
   def __construct_verbal_pref_stems(self):
     '''
     Verbal prefix stems
     '''
-    return pynini.compose(
-        self.__pref_stems,
-        pynini.concat(
-          self.__syms.initial_features.closure(),
-          pynini.acceptor("<Pref_Stems>", token_type=self.__syms.alphabet),
-          self.__sigma_star,
-          pynini.acceptor("<V>", token_type=self.__syms.alphabet),
-          self.__sigma_star
-          )
-        ).optimize()
+    with pynini.default_token_type(self.__syms.alphabet):
+      return pynini.compose(
+          self.__pref_stems,
+          pynini.concat(
+            self.__syms.initial_features.closure(),
+            pynini.accep("<Pref_Stems>"),
+            self.__sigma_star,
+            pynini.accep("<V>", token_type=self.__syms.alphabet),
+            self.__sigma_star
+            )
+          ).optimize()
 
   def __construct_simplex_suff_stems(self):
     '''
     Derivation suffixes which combine with simplex stems
     '''
-    return pynini.compose(
-        self.__lex,
-        pynini.concat(
-          self.__syms.initial_features.closure(),
-          pynini.acceptor("<Suff_Stems>", token_type=self.__syms.alphabet),
-          pynini.transducer("<simplex>", "", input_token_type=self.__syms.alphabet),
-          self.__sigma_star
-          )
-        ).optimize()
+    with pynini.default_token_type(self.__syms.alphabet):
+      return pynini.compose(
+          self.__lex,
+          pynini.concat(
+            self.__syms.initial_features.closure(),
+            pynini.accep("<Suff_Stems>"),
+            pynini.cross("<simplex>", ""),
+            self.__sigma_star
+            )
+          ).optimize()
 
   def __construct_suff_deriv_suff_stems(self):
     '''
     Derivation suffixes which combine with suffixed stems
     '''
-    return pynini.compose(
-        self.__lex,
-        pynini.concat(
-          self.__syms.initial_features.closure(),
-          pynini.acceptor("<Suff_Stems>", token_type=self.__syms.alphabet),
-          pynini.transducer("<suffderiv>", "", input_token_type=self.__syms.alphabet),
-          self.__sigma_star
-          )
-        ).optimize()
+    with pynini.default_token_type(self.__syms.alphabet):
+      return pynini.compose(
+          self.__lex,
+          pynini.concat(
+            self.__syms.initial_features.closure(),
+            pynini.accep("<Suff_Stems>"),
+            pynini.cross("<suffderiv>", ""),
+            self.__sigma_star
+            )
+          ).optimize()
 
   def __construct_pref_deriv_suff_stems(self):
     '''
     Derivation suffixes which combine with prefixed stems
     '''
-    return pynini.compose(
-        self.__lex,
-        pynini.concat(
-          self.__syms.initial_features.closure(),
-          pynini.acceptor("<Suff_Stems>", token_type=self.__syms.alphabet),
-          pynini.transducer("<prefderiv>", "", input_token_type=self.__syms.alphabet),
-          self.__sigma_star
-          )
-        ).optimize()
+    with pynini.default_token_type(self.__syms.alphabet):
+      return pynini.compose(
+          self.__lex,
+          pynini.concat(
+            self.__syms.initial_features.closure(),
+            pynini.accep("<Suff_Stems>"),
+            pynini.cross("<prefderiv>", ""),
+            self.__sigma_star
+            )
+          ).optimize()
 
   def __construct_quant_suff_stems(self):
     '''
     Derivation suffixes which combine with a number and a simplex stem
     '''
-    return pynini.compose(
-        self.__lex,
-        pynini.concat(
-          pynini.transducer("<QUANT>", "", input_token_type=self.__syms.alphabet),
-          self.__syms.initial_features.closure(),
-          pynini.acceptor("<Suff_Stems>", token_type=self.__syms.alphabet),
-          pynini.transducer("<simplex>", "", input_token_type=self.__syms.alphabet),
-          self.__sigma_star
-          )
-        ).optimize()
+    with pynini.default_token_type(self.__syms.alphabet):
+      return pynini.compose(
+          self.__lex,
+          pynini.concat(
+            pynini.cross("<QUANT>", ""),
+            self.__syms.initial_features.closure(),
+            pynini.accep("<Suff_Stems>"),
+            pynini.cross("<simplex>", ""),
+            self.__sigma_star
+            )
+          ).optimize()
diff --git a/timur/fsts/timur_fst.py b/timur/fsts/timur_fst.py
index 92ac693..ed9ed03 100644
--- a/timur/fsts/timur_fst.py
+++ b/timur/fsts/timur_fst.py
@@ -106,7 +106,7 @@ def build(self, lexicon_stream):
     mappings = fsts.MapFst(self.__syms)
 
     # delete certain symbols on the upper and lower level
-    lex = mappings.map1 * lex * mappings.map2
+    lex = mappings.map1 @ lex @ mappings.map2
     lex.draw("lex_map.dot", portrait=True)
 
     #
diff --git a/timur/helpers/helpers.py b/timur/helpers/helpers.py
index 9df555b..be379b3 100644
--- a/timur/helpers/helpers.py
+++ b/timur/helpers/helpers.py
@@ -23,9 +23,11 @@ def load_lexicon(source, symbol_table):
       tmp.set_final(start)
       for token in tokenizer.findall(line):
         if token[1]:
-          tmp = pynini.concat(tmp, pynini.transducer(token[0], token[1], input_token_type=symbol_table, output_token_type=symbol_table))
+          tmp1 = pynini.concat(tmp, pynini.accep(token[0], token_type=symbol_table))
+          tmp2 = pynini.concat(tmp, pynini.accep(token[1], token_type=symbol_table))
+          tmp = pynini.concat(tmp, pynini.cross(tmp1, tmp2))
         else:
-          tmp = pynini.concat(tmp, pynini.acceptor(token[0], token_type=symbol_table))
+          tmp = pynini.concat(tmp, pynini.accep(token[0], token_type=symbol_table))
       lex = pynini.union(lex, tmp)
   return lex
 
diff --git a/timur/symbols/symbols.py b/timur/symbols/symbols.py
index 5b62bc9..b493880 100644
--- a/timur/symbols/symbols.py
+++ b/timur/symbols/symbols.py
@@ -43,44 +43,44 @@ def __init__(self, alphabet):
         else:
           chars_to_lower.append((symbol, symbol))
           chars_to_upper.append((symbol, symbol))
-    self.__characters = pynini.string_map(chars, input_token_type=alphabet, output_token_type=alphabet).project().optimize()
-    self.__characters_upper = pynini.string_map(chars_upper, input_token_type=alphabet, output_token_type=alphabet).project().optimize()
-    self.__characters_lower = pynini.string_map(chars_lower, input_token_type=alphabet, output_token_type=alphabet).project().optimize()
+    self.__characters = pynini.string_map(chars, input_token_type=alphabet, output_token_type=alphabet).project("input").optimize()
+    self.__characters_upper = pynini.string_map(chars_upper, input_token_type=alphabet, output_token_type=alphabet).project("input").optimize()
+    self.__characters_lower = pynini.string_map(chars_lower, input_token_type=alphabet, output_token_type=alphabet).project("input").optimize()
     self.__characters_to_upper = pynini.string_map(chars_to_upper, input_token_type=alphabet, output_token_type=alphabet).optimize()
     self.__characters_to_lower = pynini.string_map(chars_to_lower, input_token_type=alphabet, output_token_type=alphabet).optimize()
 
-    self.__consonants_lower = pynini.string_map(["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z", "ß"], input_token_type=alphabet, output_token_type=alphabet).project().optimize()
+    self.__consonants_lower = pynini.string_map(["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z", "ß"], input_token_type=alphabet, output_token_type=alphabet).project("input").optimize()
 
-    self.__consonants_upper = pynini.string_map(["B", "C", "D", "F", "G", "H", "J", "K", "L", "M", "N", "P", "Q", "R", "S", "T", "V", "W", "X", "Y", "Z"], input_token_type=alphabet, output_token_type=alphabet).project().optimize()
+    self.__consonants_upper = pynini.string_map(["B", "C", "D", "F", "G", "H", "J", "K", "L", "M", "N", "P", "Q", "R", "S", "T", "V", "W", "X", "Y", "Z"], input_token_type=alphabet, output_token_type=alphabet).project("input").optimize()
 
     self.__consonants = self.__consonants_lower | self.__consonants_upper
 
-    self.__inititial_features = pynini.string_map(["<QUANT>", "<Initial>", "<NoHy>", "<ge>", "<no-ge>", "<NoPref>", "<NoDef>"], input_token_type=alphabet, output_token_type=alphabet).project().optimize()
+    self.__inititial_features = pynini.string_map(["<QUANT>", "<Initial>", "<NoHy>", "<ge>", "<no-ge>", "<NoPref>", "<NoDef>"], input_token_type=alphabet, output_token_type=alphabet).project("input").optimize()
 
-    self.__categories = pynini.string_map(["<ABK>", "<ADJ>", "<ADV>", "<CARD>", "<DIGCARD>", "<NE>", "<NN>", "<PRO>", "<V>", "<ORD>", "<OTHER>", "<KSF>", "<FT>"], input_token_type=alphabet, output_token_type=alphabet).project().optimize()
+    self.__categories = pynini.string_map(["<ABK>", "<ADJ>", "<ADV>", "<CARD>", "<DIGCARD>", "<NE>", "<NN>", "<PRO>", "<V>", "<ORD>", "<OTHER>", "<KSF>", "<FT>"], input_token_type=alphabet, output_token_type=alphabet).project("input").optimize()
 
-    self.__disjunctive_categories = pynini.string_map(["<CARD,DIGCARD,NE>", "<ADJ,CARD>", "<ADJ,NN>", "<CARD,NN>", "<CARD,NE>", "<ABK,ADJ,NE,NN>", "<ADJ,NE,NN>", "<ABK,NE,NN>", "<NE,NN>", "<ABK,CARD,NN>", "<ABK,NN>", "<ADJ,CARD,NN,V>", "<ADJ,NN,V>", "<ABK,ADJ,NE,NN,V>", "<ADJ,NE,NN,V>", "<ADV,NE,NN,V>", "<ABK,NE,NN,V>", "<NE,NN,V>", "<ABK,NN,V>", "<NN,V>"], input_token_type=alphabet, output_token_type=alphabet).project().optimize()
+    self.__disjunctive_categories = pynini.string_map(["<CARD,DIGCARD,NE>", "<ADJ,CARD>", "<ADJ,NN>", "<CARD,NN>", "<CARD,NE>", "<ABK,ADJ,NE,NN>", "<ADJ,NE,NN>", "<ABK,NE,NN>", "<NE,NN>", "<ABK,CARD,NN>", "<ABK,NN>", "<ADJ,CARD,NN,V>", "<ADJ,NN,V>", "<ABK,ADJ,NE,NN,V>", "<ADJ,NE,NN,V>", "<ADV,NE,NN,V>", "<ABK,NE,NN,V>", "<NE,NN,V>", "<ABK,NN,V>", "<NN,V>"], input_token_type=alphabet, output_token_type=alphabet).project("input").optimize()
 
-    self.__base_stem_types = pynini.string_map(["<Base_Stems>", "<Kompos_Stems>", "<Deriv_Stems>"], input_token_type=alphabet, output_token_type=alphabet).project().optimize()
+    self.__base_stem_types = pynini.string_map(["<Base_Stems>", "<Kompos_Stems>", "<Deriv_Stems>"], input_token_type=alphabet, output_token_type=alphabet).project("input").optimize()
 
-    self.__stem_types = pynini.string_map(["<Base_Stems>", "<Kompos_Stems>", "<Deriv_Stems>", "<Suff_Stems>", "<Pref_Stems>"], input_token_type=alphabet, output_token_type=alphabet).project().optimize()
+    self.__stem_types = pynini.string_map(["<Base_Stems>", "<Kompos_Stems>", "<Deriv_Stems>", "<Suff_Stems>", "<Pref_Stems>"], input_token_type=alphabet, output_token_type=alphabet).project("input").optimize()
 
-    self.__prefix_suffix_marker = pynini.string_map(["<VPART>", "<VPREF>", "<PREF>", "<SUFF>", "<CONV>"], input_token_type=alphabet, output_token_type=alphabet).project().optimize()
+    self.__prefix_suffix_marker = pynini.string_map(["<VPART>", "<VPREF>", "<PREF>", "<SUFF>", "<CONV>"], input_token_type=alphabet, output_token_type=alphabet).project("input").optimize()
 
-    self.__stem_type_features = pynini.string_map(["<base>", "<deriv>", "<kompos>"], input_token_type=alphabet, output_token_type=alphabet).project().optimize()
+    self.__stem_type_features = pynini.string_map(["<base>", "<deriv>", "<kompos>"], input_token_type=alphabet, output_token_type=alphabet).project("input").optimize()
 
-    self.__complexity_agreement_features = pynini.string_map(["<simplex>", "<komposit>", "<suffderiv>", "<prefderiv>"], input_token_type=alphabet, output_token_type=alphabet).project().optimize()
+    self.__complexity_agreement_features = pynini.string_map(["<simplex>", "<komposit>", "<suffderiv>", "<prefderiv>"], input_token_type=alphabet, output_token_type=alphabet).project("input").optimize()
 
-    self.__complexity_entry_features = pynini.string_map(["<Simplex>", "<Komplex>", "<Komplex_abstrakt>", "<Komplex_semi>", "<Nominalisierung>", "<Kurzwort>"], input_token_type=alphabet, output_token_type=alphabet).project().optimize()
+    self.__complexity_entry_features = pynini.string_map(["<Simplex>", "<Komplex>", "<Komplex_abstrakt>", "<Komplex_semi>", "<Nominalisierung>", "<Kurzwort>"], input_token_type=alphabet, output_token_type=alphabet).project("input").optimize()
 
-    self.__origin_features = pynini.string_map(["<nativ>", "<frei>", "<gebunden>", "<kurz>", "<lang>", "<fremd>", "<klassisch>", "<prefnativ>"], input_token_type=alphabet, output_token_type=alphabet).project().optimize()
+    self.__origin_features = pynini.string_map(["<nativ>", "<frei>", "<gebunden>", "<kurz>", "<lang>", "<fremd>", "<klassisch>", "<prefnativ>"], input_token_type=alphabet, output_token_type=alphabet).project("input").optimize()
 
-    self.__circumfix_features = pynini.string_map(["<Ge-Nom>"], input_token_type=alphabet, output_token_type=alphabet).project().optimize()
+    self.__circumfix_features = pynini.string_map(["<Ge-Nom>"], input_token_type=alphabet, output_token_type=alphabet).project("input").optimize()
 
     self.__ns_features = pynini.string_map(["<NSNeut_es_e>",
       "<NSFem_0_n>", "<NSFem_0_en>",
       "<NSMasc_es_e>", "<NSMasc_es_$e>", "<NSMasc-s/$sse>"],
-      input_token_type=alphabet, output_token_type=alphabet).project().optimize()
+      input_token_type=alphabet, output_token_type=alphabet).project("input").optimize()
 
     self.__geo_inflection_classes = pynini.string_map(["<NSNeut_es_e>",
       "<NSFem_0_n>", "<NSFem_0_en>",
@@ -132,7 +132,7 @@ def __init__(self, alphabet):
       "<NGeo-ien-ianer-ianisch>",
       "<NGeo-ien-ier-isch>",
       "<NGeo-istan-e-isch>",
-      "<NGeo-land-$er-$er>", "<NGeo-land-e-isch>", "<NGeo-land-e-nisch>"], input_token_type=alphabet, output_token_type=alphabet).project().optimize()
+      "<NGeo-land-$er-$er>", "<NGeo-land-e-isch>", "<NGeo-land-e-nisch>"], input_token_type=alphabet, output_token_type=alphabet).project("input").optimize()
 
     self.__inflection_classes = pynini.string_map([
       "<Abk_ADJ>", "<Abk_ADV>", "<Abk_ART>", "<Abk_DPRO>",
@@ -192,9 +192,9 @@ def __init__(self, alphabet):
       "<VVPastKonjReg>", "<VVPastKonjStr>", "<VVPastStr>", "<VVPres1+Imp>",
       "<VVPres1>", "<VVPres2+Imp0>", "<VVPres2+Imp>", "<VVPres2>",
       "<VVPres2t>", "<VVPres>", "<VVPresPl>", "<VVPresSg>",
-      "<VVReg-el/er>", "<VVReg>", "<WAdv>"], input_token_type=alphabet, output_token_type=alphabet).project().optimize()
+      "<VVReg-el/er>", "<VVReg>", "<WAdv>"], input_token_type=alphabet, output_token_type=alphabet).project("input").optimize()
 
-    self.__gender = pynini.string_map(["<Masc>", "<Fem>", "<Neut>", "<NoGend>"], input_token_type=alphabet, output_token_type=alphabet).project().optimize()
+    self.__gender = pynini.string_map(["<Masc>", "<Fem>", "<Neut>", "<NoGend>"], input_token_type=alphabet, output_token_type=alphabet).project("input").optimize()
 
   #
   # access to the alphabet (pynini.SymbolTable)