diff --git a/src/Am/AcousticModel.hh b/src/Am/AcousticModel.hh
index 1929ed24c..57803e435 100644
--- a/src/Am/AcousticModel.hh
+++ b/src/Am/AcousticModel.hh
@@ -65,7 +65,8 @@ public:
 
 public:
     AcousticModel(const Core::Configuration& c)
-            : Core::Component(c), Mc::Component(c) {}
+            : Core::Component(c),
+              Mc::Component(c) {}
     virtual ~AcousticModel() {}
 
     virtual void load(Mode mode = complete) = 0;
diff --git a/src/Am/AcousticModelAdaptor.cc b/src/Am/AcousticModelAdaptor.cc
index d7ad9e4df..41b6c2886 100644
--- a/src/Am/AcousticModelAdaptor.cc
+++ b/src/Am/AcousticModelAdaptor.cc
@@ -17,7 +17,8 @@
 using namespace Am;
 
 MixtureSetAdaptor::MixtureSetAdaptor(const Core::Configuration& c, Core::Ref<AcousticModel> toAdapt)
-        : Component(c), Precursor(c, toAdapt) {
+        : Component(c),
+          Precursor(c, toAdapt) {
     Core::Ref<Mm::MixtureSet> mixtureSet = Mm::Module::instance().readMixtureSet(select("mixture-set"));
     if (!mixtureSet || !setMixtureSet(mixtureSet))
         criticalError("failed to initialize mixture set.");
diff --git a/src/Am/AcousticModelAdaptor.hh b/src/Am/AcousticModelAdaptor.hh
index 2c268f501..af4ffe55f 100644
--- a/src/Am/AcousticModelAdaptor.hh
+++ b/src/Am/AcousticModelAdaptor.hh
@@ -29,7 +29,8 @@ protected:
 
 public:
     AcousticModelAdaptor(const Core::Configuration& c, Core::Ref<AcousticModel> toAdapt)
-            : Component(c), toAdapt_(toAdapt) {
+            : Component(c),
+              toAdapt_(toAdapt) {
         require(toAdapt_);
     }
     virtual ~AcousticModelAdaptor() {}
diff --git a/src/Am/ClassicAcousticModel.cc b/src/Am/ClassicAcousticModel.cc
index 5963a12f4..11ca85829 100644
--- a/src/Am/ClassicAcousticModel.cc
+++ b/src/Am/ClassicAcousticModel.cc
@@ -168,6 +168,7 @@ bool ClassicAcousticModel::loadTransitionModel() {
         transitionModel_->setParentScale(scale());
         return true;
     }
+
     return false;
 }
 
diff --git a/src/Am/ClassicAcousticModel.hh b/src/Am/ClassicAcousticModel.hh
index 3e35b0f74..5cdf8cc02 100644
--- a/src/Am/ClassicAcousticModel.hh
+++ b/src/Am/ClassicAcousticModel.hh
@@ -136,16 +136,20 @@ public:
         return (*transitionModel_)[i];
     }
     virtual StateTransitionIndex stateTransitionIndex(AllophoneState phone, s8 subState = 0) const {
-        if (allophoneStateAlphabet()->isSilence(phone))
+        if (allophoneStateAlphabet()->isSilence(phone)) {
             return TransitionModel::silence;
-        else
+        }
+        else {
             return transitionModel_->classify(phone, subState);
+        }
     }
     virtual StateTransitionIndex stateTransitionIndex(AllophoneStateIndex e, s8 subState = 0) const {
-        if (silenceAllophoneStateIndex_ != Fsa::InvalidLabelId and e == silenceAllophoneStateIndex_)
+        if (silenceAllophoneStateIndex_ != Fsa::InvalidLabelId and e == silenceAllophoneStateIndex_) {
             return TransitionModel::silence;
-        else
+        }
+        else {
             return transitionModel_->classifyIndex(e, subState);
+        }
     }
 
     virtual const ClassicHmmTopology* hmmTopology(Bliss::Phoneme::Id phoneme) const {
diff --git a/src/Am/ClassicHmmTopologySet.hh b/src/Am/ClassicHmmTopologySet.hh
index 6177045cb..d9725a23c 100644
--- a/src/Am/ClassicHmmTopologySet.hh
+++ b/src/Am/ClassicHmmTopologySet.hh
@@ -30,7 +30,8 @@ class ClassicHmmTopology {
 
 public:
     ClassicHmmTopology(int nPhoneStates, int nSubStates)
-            : nPhoneStates_(nPhoneStates), nSubStates_(nSubStates) {}
+            : nPhoneStates_(nPhoneStates),
+              nSubStates_(nSubStates) {}
     int nPhoneStates() const {
         return nPhoneStates_;
     }
diff --git a/src/Am/ClassicStateModel.cc b/src/Am/ClassicStateModel.cc
index 12df00935..17bb0d303 100644
--- a/src/Am/ClassicStateModel.cc
+++ b/src/Am/ClassicStateModel.cc
@@ -531,8 +531,9 @@ std::string AllophoneAlphabet::symbol(Fsa::LabelId id) const {
 
 Fsa::LabelId AllophoneAlphabet::index(const std::string& symbol) const {
     Fsa::LabelId lid = specialIndex(symbol);
-    if (lid == Fsa::InvalidLabelId)
+    if (lid == Fsa::InvalidLabelId) {
         lid = index(fromString(symbol));
+    }
     return lid;
 }
 
@@ -798,7 +799,8 @@ struct IndexedAllophoneState {
     Am::AllophoneState allophoneState;
     IndexedAllophoneState() {}
     IndexedAllophoneState(Fsa::LabelId id, Am::AllophoneState allophoneState)
-            : id(id), allophoneState(allophoneState) {}
+            : id(id),
+              allophoneState(allophoneState) {}
     bool operator<(const IndexedAllophoneState& i) const {
         return id < i.id;
     }
diff --git a/src/Am/ClassicStateModel.hh b/src/Am/ClassicStateModel.hh
index 417b1ebb6..f10fd2163 100644
--- a/src/Am/ClassicStateModel.hh
+++ b/src/Am/ClassicStateModel.hh
@@ -56,9 +56,11 @@ struct Allophone : public Phonology::Allophone {
     Allophone()
             : Precursor() {}
     Allophone(Bliss::Phoneme::Id phoneme, s16 b)
-            : Precursor(phoneme), boundary(b) {}
+            : Precursor(phoneme),
+              boundary(b) {}
     Allophone(const Phonology::Allophone& a, s16 b)
-            : Precursor(a), boundary(b) {}
+            : Precursor(a),
+              boundary(b) {}
 
     bool operator==(const Allophone& allo) const {
         return (boundary == allo.boundary) && Precursor::operator==(allo);
@@ -66,7 +68,8 @@ struct Allophone : public Phonology::Allophone {
 
     struct Hash {
         Phonology::Allophone::Hash ah;
-        u32                        operator()(const Allophone& a) const {
+
+        u32 operator()(const Allophone& a) const {
             return ah(a) ^ (u32(a.boundary) << 13);
         }
     };
@@ -103,7 +106,8 @@ public:
 private:
     struct AllophonePtrHash {
         Allophone::Hash h;
-        size_t          operator()(const Allophone* const a) const {
+
+        size_t operator()(const Allophone* const a) const {
             return h(*a);
         }
     };
@@ -228,11 +232,13 @@ private:
 
 private:
     AllophoneState(const Allophone* allo, s16 state)
-            : allo_(allo), state_(state) {}
+            : allo_(allo),
+              state_(state) {}
 
 public:
     AllophoneState()
-            : allo_(0), state_(0) {}
+            : allo_(0),
+              state_(0) {}
 
     operator const Allophone*() const {
         require(allo_);
@@ -258,13 +264,15 @@ public:
         require(allo_);
         return allo_;
     }
+
     s16 state() const {
         return state_;
     }
 
     struct Hash {
         Allophone::Hash ah;
-        u32             operator()(const AllophoneState& alloState) const {
+
+        u32 operator()(const AllophoneState& alloState) const {
             return ah(alloState) ^ (u32(alloState.state()) << 21);
         }
     };
diff --git a/src/Am/ClassicStateTying.hh b/src/Am/ClassicStateTying.hh
index ad16cfea1..c1f8cf21f 100644
--- a/src/Am/ClassicStateTying.hh
+++ b/src/Am/ClassicStateTying.hh
@@ -38,7 +38,8 @@ private:
 
 public:
     EmissionAlphabet(Mm::MixtureIndex nMixtures = 0)
-            : nMixtures_(nMixtures), nDisambiguators_(0) {}
+            : nMixtures_(nMixtures),
+              nDisambiguators_(0) {}
     Mm::MixtureIndex nMixtures() const {
         return nMixtures_;
     }
diff --git a/src/Am/ClassicTransducerBuilder.cc b/src/Am/ClassicTransducerBuilder.cc
index 821ea64b2..7431a385b 100644
--- a/src/Am/ClassicTransducerBuilder.cc
+++ b/src/Am/ClassicTransducerBuilder.cc
@@ -31,7 +31,8 @@ class ClassicTransducerBuilder::Statistics {
         bool isCoarticulated;
         PhoneBoundaryStateSetDescriptor(
                 const PhoneBoundaryStateDescriptor& pbsd)
-                : phoneBoundaryFlag(pbsd.flag), isCoarticulated(pbsd.isCoarticulated()) {
+                : phoneBoundaryFlag(pbsd.flag),
+                  isCoarticulated(pbsd.isCoarticulated()) {
         }
 
         Core::XmlOpen xmlAttributes(const Core::XmlOpen&) const;
@@ -140,7 +141,10 @@ static const Core::ParameterBool paramFixAllophoneContextAtWordBoundaries(
 ClassicTransducerBuilder::ClassicTransducerBuilder(Core::Ref<
                                                    const ClassicAcousticModel>
                                                            model)
-        : TransducerBuilder(), model_(model), silencesAndNoises_(0), allophoneSuffixes_(2500, AllophoneSuffix::Hash(this), AllophoneSuffix::Equality(this)) {
+        : TransducerBuilder(),
+          model_(model),
+          silencesAndNoises_(0),
+          allophoneSuffixes_(2500, AllophoneSuffix::Hash(this), AllophoneSuffix::Equality(this)) {
     require(model);
     allophones_      = model_->allophoneAlphabet();
     allophoneList_   = &model_->allophoneAlphabet()->allophones();
@@ -649,8 +653,7 @@ Fsa::ConstAutomatonRef ClassicTransducerBuilder::applyTransitionModel(
 
     const Allophone* silenceAllophone = allophones_->allophone(Allophone(
             Phonology::Allophone(model_->silence_), Allophone::isInitialPhone | Allophone::isFinalPhone));
-    AllophoneState   silenceState     = allophoneStates_->allophoneState(
-            silenceAllophone, 0);
+    AllophoneState   silenceState     = allophoneStates_->allophoneState(silenceAllophone, 0);
 
     Fsa::LabelId silenceLabel = Fsa::InvalidLabelId;
     if (ff->inputAlphabet() == allophoneStates_)
@@ -921,15 +924,21 @@ struct PhoneContext : public Phones {
     bool         boundary_;
     Fsa::LabelId disambiguator_;
     PhoneContext(size_t n, bool boundary = false, Fsa::LabelId disambiguator = Fsa::Epsilon)
-            : Phones(n, Bliss::Phoneme::term), boundary_(boundary), disambiguator_(disambiguator) {
+            : Phones(n, Bliss::Phoneme::term),
+              boundary_(boundary),
+              disambiguator_(disambiguator) {
     }
     PhoneContext(const Phones& phones, bool boundary = false,
                  Fsa::LabelId disambiguator = Fsa::Epsilon)
-            : Phones(phones), boundary_(boundary), disambiguator_(disambiguator) {
+            : Phones(phones),
+              boundary_(boundary),
+              disambiguator_(disambiguator) {
     }
     PhoneContext(Phones::const_iterator pBegin, Phones::const_iterator pEnd,
                  bool boundary = false, Fsa::LabelId disambiguator = Fsa::Epsilon)
-            : Phones(pBegin, pEnd), boundary_(boundary), disambiguator_(disambiguator) {
+            : Phones(pBegin, pEnd),
+              boundary_(boundary),
+              disambiguator_(disambiguator) {
     }
 };
 
@@ -949,7 +958,9 @@ struct NoCoartBoundary {
     Fsa::LabelId input_, phoneDisambiguator_;
     NoCoartBoundary(Fsa::State* state, Fsa::LabelId input,
                     Fsa::LabelId phoneDisambiguator)
-            : state_(state), input_(input), phoneDisambiguator_(phoneDisambiguator) {
+            : state_(state),
+              input_(input),
+              phoneDisambiguator_(phoneDisambiguator) {
     }
 };
 
@@ -1005,10 +1016,10 @@ Fsa::ConstAutomatonRef ClassicTransducerBuilder::createMinimizedContextDependenc
 
     Fsa::Hash<PhoneContext, PhoneContextHash> stateMap;
     PhoneContext                              pc(maxHistory + maxFuture, true);
-    Fsa::State*                               initial = new Fsa::State(stateMap.insert(pc),
-                                         model_->isAcrossWordModelEnabled() ? Fsa::StateTagFinal
-                                                                                                          : Fsa::StateTagNone,
-                                                                       semiring->one());
+
+    Fsa::State* initial = new Fsa::State(stateMap.insert(pc),
+                                         model_->isAcrossWordModelEnabled() ? Fsa::StateTagFinal : Fsa::StateTagNone,
+                                         semiring->one());
     _c->setState(initial);
     _c->setInitialStateId(initial->id());
     if (model_->isAcrossWordModelEnabled()) {
diff --git a/src/Am/ClassicTransducerBuilder.hh b/src/Am/ClassicTransducerBuilder.hh
index c8e4a4af7..5a9898715 100644
--- a/src/Am/ClassicTransducerBuilder.hh
+++ b/src/Am/ClassicTransducerBuilder.hh
@@ -76,21 +76,27 @@ private:  // internal
     struct PhoneBoundaryStateDescriptor {
         Phonology::Context context;
         u8                 flag;  // PhoneBoundaryFlags
-        bool               isWordStart() const {
+
+        bool isWordStart() const {
             return (flag & wordStart);
         }
+
         bool isWordEnd() const {
             return (flag & wordEnd);
         }
+
         bool isCoarticulated() const {
             return (!context.history.empty() && !context.future.empty());
         }
+
         bool operator==(const PhoneBoundaryStateDescriptor& r) const {
             return (context == r.context) && (flag == r.flag);
         }
+
         struct Hash {
             Phonology::Context::Hash ch;
-            u32                      operator()(const PhoneBoundaryStateDescriptor& pbsd) const {
+
+            u32 operator()(const PhoneBoundaryStateDescriptor& pbsd) const {
                 return ch(pbsd.context) ^ (u32(pbsd.flag) << 13);
             }
         };
@@ -114,8 +120,10 @@ private:  // internal
 
         struct Hash {
             ClassicTransducerBuilder* model;
+
             Hash(ClassicTransducerBuilder* mm)
                     : model(mm) {}
+
             size_t operator()(const AllophoneSuffix& as) const {
                 if (!as.hash_) {
                     as.hash_ = model->hashSequence(as);
@@ -128,20 +136,21 @@ private:  // internal
 
         struct Equality {
             ClassicTransducerBuilder* model;
+
             Equality(ClassicTransducerBuilder* mm)
                     : model(mm) {}
+
             bool operator()(const AllophoneSuffix& l, const AllophoneSuffix& r) const {
                 return model->compareSequences(l, r) == 0;
             }
         };
     };
+
     size_t hashSequence(const AllophoneSuffix&);
     int    compareSequences(const AllophoneSuffix&, const AllophoneSuffix&);
-    typedef std::unordered_map<
-            AllophoneSuffix,
-            Fsa::StateId,
-            AllophoneSuffix::Hash, AllophoneSuffix::Equality>
-                       AllophoneSuffixMap;
+
+    typedef std::unordered_map<AllophoneSuffix, Fsa::StateId, AllophoneSuffix::Hash, AllophoneSuffix::Equality> AllophoneSuffixMap;
+
     AllophoneSuffixMap allophoneSuffixes_;
 
     class Statistics;
diff --git a/src/Am/StateModel.hh b/src/Am/StateModel.hh
index 74dd0de61..24a692488 100644
--- a/src/Am/StateModel.hh
+++ b/src/Am/StateModel.hh
@@ -34,18 +34,23 @@ private:
 
 public:
     EmissionAlphabet(Mm::MixtureIndex nMixtures = 0)
-            : nMixtures_(nMixtures), nDisambiguators_(0) {}
+            : nMixtures_(nMixtures),
+              nDisambiguators_(0) {}
+
     Mm::MixtureIndex nMixtures() const {
         return nMixtures_;
     }
+
     u32 nDisambiguators() const {
         return nDisambiguators_;
     }
+
     Fsa::LabelId disambiguator(u32 d) const {
         if (nDisambiguators_ >= d)
             nDisambiguators_ = d + 1;
         return nMixtures_ + d;
     }
+
     virtual bool isDisambiguator(Fsa::LabelId m) const {
         return m >= Fsa::LabelId(nMixtures_);
     }
@@ -53,6 +58,7 @@ public:
     virtual const_iterator end() const {
         return const_iterator(Fsa::ConstAlphabetRef(this), nMixtures_ + nDisambiguators_);
     }
+
     virtual std::string symbol(Fsa::LabelId) const;
     virtual void        writeXml(Core::XmlWriter&) const;
 };
@@ -66,10 +72,13 @@ struct Allophone : public Phonology::Allophone {
     static const u8              isFinalPhone   = 2;
     Allophone() {}
     Allophone(const Phonology::Allophone& a, s16 b)
-            : Phonology::Allophone(a), boundary(b) {}
+            : Phonology::Allophone(a),
+              boundary(b) {}
+
     struct Hash {
         Phonology::Allophone::Hash ah;
-        u32                        operator()(const Allophone& a) const {
+
+        u32 operator()(const Allophone& a) const {
             return ah(a) ^ (u32(a.boundary) << 13);
         }
     };
@@ -80,16 +89,20 @@ struct AllophoneState : public Allophone {
     s16               state;
     AllophoneState() {}
     AllophoneState(const Allophone& a, s16 s)
-            : Precursor(a), state(s) {}
+            : Precursor(a),
+              state(s) {}
     AllophoneState(const AllophoneState& as)
-            : Precursor(as), state(as.state) {}
+            : Precursor(as),
+              state(as.state) {}
 
     bool operator==(const AllophoneState& rhs) const {
         return Precursor::operator==(rhs) && state == rhs.state;
     }
+
     struct Hash {
         Precursor::Hash ah;
-        u32             operator()(const AllophoneState& a) const {
+
+        u32 operator()(const AllophoneState& a) const {
             return ah(a) ^ (u32(a.state) << 21);
         }
     };
@@ -113,23 +126,30 @@ public:
     AllophoneStateAlphabet();
     explicit AllophoneStateAlphabet(Core::Ref<const Bliss::PhonemeInventory>,
                                     u32 contextLength = 0, u32 nStates = 0);
-    void                                     set(Core::Ref<const Bliss::PhonemeInventory>, u32 contextLength, u32 nStates);
+
+    void set(Core::Ref<const Bliss::PhonemeInventory>, u32 contextLength, u32 nStates);
+
     Core::Ref<const Bliss::PhonemeInventory> phonemeInventory() const {
         return pi_;
     }
+
     Fsa::LabelId nClasses() const {
         return nClasses_;
     }
+
     Fsa::LabelId   index(const AllophoneState&) const;
     AllophoneState allophoneState(Fsa::LabelId) const;
-    u32            nDisambiguators() const {
+
+    u32 nDisambiguators() const {
         return nDisambiguators_;
     }
+
     Fsa::LabelId disambiguator(u32 d) const {
         if (nDisambiguators_ >= d)
             nDisambiguators_ = d + 1;
         return nClasses_ + 1 + d;
     }
+
     virtual bool isDisambiguator(Fsa::LabelId m) const {
         return m > Fsa::LabelId(nClasses_);
     }
@@ -137,9 +157,11 @@ public:
     virtual const_iterator end() const {
         return const_iterator(Fsa::ConstAlphabetRef(this), nClasses_ + 1 + nDisambiguators_);
     }
+
     virtual Fsa::LabelId next(Fsa::LabelId id) const {
         return ++id;
     }
+
     virtual std::string symbol(Fsa::LabelId) const;
     virtual void        writeXml(Core::XmlWriter& os) const;
 };
@@ -148,9 +170,11 @@ class EmissionToPhonemeTransducer : public Fsa::StaticAutomaton {
 public:
     EmissionToPhonemeTransducer() {}
     EmissionToPhonemeTransducer(u32 nMixtures, Core::Ref<const Bliss::PhonemeAlphabet>);
+
     const EmissionAlphabet* emissionAlphabet() const {
         return dynamic_cast<const EmissionAlphabet*>(getInputAlphabet().get());
     }
+
     const Bliss::PhonemeAlphabet* phonemeAlphabet() const {
         return dynamic_cast<const Bliss::PhonemeAlphabet*>(getOutputAlphabet().get());
     }
@@ -160,9 +184,11 @@ class AllophoneStateToPhonemeTransducer : public Fsa::StaticAutomaton {
 public:
     AllophoneStateToPhonemeTransducer() {}
     AllophoneStateToPhonemeTransducer(Core::Ref<const Bliss::PhonemeInventory>);
+
     const AllophoneStateAlphabet* allophoneStateAlphabet() const {
         return dynamic_cast<const AllophoneStateAlphabet*>(getInputAlphabet().get());
     }
+
     const Bliss::PhonemeAlphabet* phonemeAlphabet() const {
         return dynamic_cast<const Bliss::PhonemeAlphabet*>(getOutputAlphabet().get());
     }
@@ -178,14 +204,19 @@ protected:
 
 public:
     StateTying(const Core::Configuration& c, const AllophoneStateAlphabet& a)
-            : Component(c), alphabet_(a) {}
+            : Component(c),
+              alphabet_(a) {}
     virtual ~StateTying() {}
-    virtual void                  getDependencies(Core::DependencySet&) const {}
+
+    virtual void getDependencies(Core::DependencySet&) const {}
+
     const AllophoneStateAlphabet& allophoneStateAlphabet() const {
         return alphabet_;
     }
+
     virtual Mm::MixtureIndex nClasses() const                         = 0;
     virtual Mm::MixtureIndex classify(const AllophoneState& as) const = 0;
+
     virtual Mm::MixtureIndex classifyIndex(AllophoneStateAlphabet::Index index) const {
         CacheMap::const_iterator iter = classifyIndexCache_.find(index);
         if (iter == classifyIndexCache_.end()) {
@@ -202,14 +233,17 @@ public:
 class NoStateTying : public StateTying {
 public:
     NoStateTying(const Core::Configuration& c, const AllophoneStateAlphabet& a)
-            : Component(c), StateTying(c, a) {}
+            : Component(c),
+              StateTying(c, a) {}
 
     virtual Mm::MixtureIndex nClasses() const {
         return alphabet_.nClasses();
     }
+
     virtual Mm::MixtureIndex classifyIndex(AllophoneStateAlphabet::Index i) const {
         return i;
     }
+
     virtual Mm::MixtureIndex classify(const AllophoneState& as) const {
         return alphabet_.index(as);
     }
diff --git a/src/Am/TransitionModel.cc b/src/Am/TransitionModel.cc
index b079d4300..70c372a85 100644
--- a/src/Am/TransitionModel.cc
+++ b/src/Am/TransitionModel.cc
@@ -139,7 +139,10 @@ struct ApplicatorState {
     }
 
     ApplicatorState(Mask m, Fsa::LabelId e, StateType t, Fsa::StateId r)
-            : mask(m), emission(e), weights(t), right(r) {}
+            : mask(m),
+              emission(e),
+              weights(t),
+              right(r) {}
 
     struct Equality {
         bool operator()(ApplicatorState const& ll, ApplicatorState const& rr) const {
@@ -248,7 +251,8 @@ class AbstractApplicator : public Applicator {
         }
 
         StateDegrees(Fsa::ConstAutomatonRef ff, Fsa::ConstAlphabetRef aa)
-                : Fsa::DfsState(ff), alphabet_(aa) {}
+                : Fsa::DfsState(ff),
+                  alphabet_(aa) {}
 
         const Degree& operator[](Fsa::StateId ii) const {
             return degrees_[ii];
@@ -258,7 +262,8 @@ class AbstractApplicator : public Applicator {
     struct StackItem : AppState {
         Fsa::StateRef result;
         StackItem(AppState const& state, Fsa::StateRef _result)
-                : AppState(state), result(_result) {}
+                : AppState(state),
+                  result(_result) {}
     };
 
     typedef std::stack<StackItem>                                                                            StateStack;
@@ -954,7 +959,9 @@ Am::TransitionModel* Am::TransitionModel::createTransitionModel(const Core::Conf
 // ===========================================================================
 ScaledTransitionModel::ScaledTransitionModel(const Core::Configuration& c,
                                              ClassicStateModelRef       stateModel)
-        : Core::Component(c), Mc::Component(c), transitionModel_(0) {
+        : Core::Component(c),
+          Mc::Component(c),
+          transitionModel_(0) {
     transitionModel_ = TransitionModel::createTransitionModel(c, stateModel);
 }
 
diff --git a/src/Am/TransitionModel.hh b/src/Am/TransitionModel.hh
index 24608a33a..c1327cb5a 100644
--- a/src/Am/TransitionModel.hh
+++ b/src/Am/TransitionModel.hh
@@ -94,7 +94,8 @@ public:
 
 protected:
     std::vector<StateTransitionModel*> transitionModels_;
-    void                               dump(Core::XmlWriter&) const;
+
+    void dump(Core::XmlWriter&) const;
 
 public:
     TransitionModel(const Core::Configuration&);
@@ -107,9 +108,11 @@ public:
      *  @return is false if correction was necessary.
      */
     bool correct();
-    u32  nModels() const {
+
+    u32 nModels() const {
         return transitionModels_.size();
     }
+
     const StateTransitionModel* operator[](int i) const {
         require_(0 <= i && i < (int)transitionModels_.size() && transitionModels_[i] != 0);
         return transitionModels_[i];
diff --git a/src/Audio/Ffmpeg.cc b/src/Audio/Ffmpeg.cc
index 13d1f8811..0eca0e0fe 100644
--- a/src/Audio/Ffmpeg.cc
+++ b/src/Audio/Ffmpeg.cc
@@ -117,7 +117,12 @@ struct FfmpegInputNode::Internal {
 };
 
 FfmpegInputNode::FfmpegInputNode(const Core::Configuration& c)
-        : Core::Component(c), Node(c), Precursor(c), internal_(new Internal()), buffer_(nullptr), resampleRate_(paramResampleRate(c)) {
+        : Core::Component(c),
+          Node(c),
+          Precursor(c),
+          internal_(new Internal()),
+          buffer_(nullptr),
+          resampleRate_(paramResampleRate(c)) {
     std::call_once(FfmpegInputNode::ffmpeg_initialized, av_register_all);
 }
 
diff --git a/src/Audio/Flac.cc b/src/Audio/Flac.cc
index 1d0676a04..779fe8607 100644
--- a/src/Audio/Flac.cc
+++ b/src/Audio/Flac.cc
@@ -21,7 +21,10 @@ using namespace Audio;
 // ===========================================================================
 
 FlacInputNode::FlacInputNode(const Core::Configuration& c)
-        : Core::Component(c), Node(c), SourceNode(c), fd_(0) {}
+        : Core::Component(c),
+          Node(c),
+          SourceNode(c),
+          fd_(0) {}
 
 bool FlacInputNode::openFile_() {
     fd_ = new FlacDecoder();
diff --git a/src/Audio/Node.cc b/src/Audio/Node.cc
index 89e117f40..9f42e2752 100644
--- a/src/Audio/Node.cc
+++ b/src/Audio/Node.cc
@@ -30,7 +30,12 @@ const Core::ParameterString Node::paramFilename(
         "file", "name of audio file");
 
 Node::Node(const Core::Configuration& c)
-        : Core::Component(c), Flow::Node(c), sampleRate_(0), sampleSize_(0), trackCount_(0), sampleCount_(0) {
+        : Core::Component(c),
+          Flow::Node(c),
+          sampleRate_(0),
+          sampleSize_(0),
+          trackCount_(0),
+          sampleCount_(0) {
     filename_ = paramFilename(config);
 }
 
@@ -58,7 +63,8 @@ const Core::ParameterFloat SourceNode::paramEndTime(
         Core::Type<Flow::Time>::max, 0.0);
 
 SourceNode::SourceNode(const Core::Configuration& c)
-        : Core::Component(c), Node(c) {
+        : Core::Component(c),
+          Node(c) {
     addOutput(0);
     blockSize_        = paramBlockSize(config);
     startTime_        = paramStartTime(config);
@@ -183,7 +189,8 @@ bool SourceNode::work(Flow::PortId out) {
 
 // ===========================================================================
 Audio::SinkNode::SinkNode(const Core::Configuration& c)
-        : Core::Component(c), Node(c) {
+        : Core::Component(c),
+          Node(c) {
     addInput(0);
     addOutput(0);
 }
diff --git a/src/Audio/Node.hh b/src/Audio/Node.hh
index 0f53d5bc8..ae59c95e5 100644
--- a/src/Audio/Node.hh
+++ b/src/Audio/Node.hh
@@ -52,13 +52,15 @@ public:
     }
 
     virtual bool isFileOpen() const;
-    bool         openFile() {
+
+    bool openFile() {
         require(!isFileOpen());
         bool result  = openFile_();
         sampleCount_ = 0;
         ensure(result == isFileOpen());
         return result;
     }
+
     void closeFile() {
         require(isFileOpen());
         closeFile_();
@@ -78,6 +80,7 @@ public:
         if (isFileOpen())
             closeFile();
     }
+
     virtual bool setParameter(const std::string& name, const std::string& value);
 };
 
@@ -124,11 +127,14 @@ protected:
 
     /** @return is sample position of startTime_. */
     SampleCount getStartSample() const;
+
     /** @return is sample position of endTime_. */
     SampleCount getEndSample() const;
-    void        setBlockSize(u32 blockSize) {
+
+    void setBlockSize(u32 blockSize) {
         blockSize_ = blockSize;
     }
+
     u32 blockSize() const {
         return blockSize_;
     }
diff --git a/src/Audio/Oss.cc b/src/Audio/Oss.cc
index 87edaf011..b9fbe445d 100644
--- a/src/Audio/Oss.cc
+++ b/src/Audio/Oss.cc
@@ -29,7 +29,9 @@ const Core::ParameterString Audio::OpenSoundSystemDevice::paramDevice(
         "device", "name of audio device", "/dev/dsp");
 
 OpenSoundSystemDevice::OpenSoundSystemDevice(const Core::Configuration& c)
-        : Core::Component(c), Node(c), fd_(-1) {
+        : Core::Component(c),
+          Node(c),
+          fd_(-1) {
     filename_ = paramDevice(config);
 }
 
@@ -143,7 +145,10 @@ void OpenSoundSystemDevice::setTrackCount(u8 _trackCount) {
 
 // ===========================================================================
 OpenSoundSystemInputNode::OpenSoundSystemInputNode(const Core::Configuration& c)
-        : Core::Component(c), Node(c), RawSourceNode(c), OpenSoundSystemDevice(c) {}
+        : Core::Component(c),
+          Node(c),
+          RawSourceNode(c),
+          OpenSoundSystemDevice(c) {}
 
 bool OpenSoundSystemInputNode::openFile_() {
     return openDevice();
@@ -183,7 +188,10 @@ u32 OpenSoundSystemInputNode::read(u32 nSamples, Flow::Timestamp*& d) {
 
 // ===========================================================================
 OpenSoundSystemOutputNode::OpenSoundSystemOutputNode(const Core::Configuration& c)
-        : Core::Component(c), Node(c), SinkNode(c), OpenSoundSystemDevice(c) {}
+        : Core::Component(c),
+          Node(c),
+          SinkNode(c),
+          OpenSoundSystemDevice(c) {}
 
 bool OpenSoundSystemOutputNode::openFile_() {
     return openDevice();
diff --git a/src/Audio/Oss.hh b/src/Audio/Oss.hh
index 380e99348..2dfcccef9 100644
--- a/src/Audio/Oss.hh
+++ b/src/Audio/Oss.hh
@@ -45,13 +45,17 @@ protected:
 
 public:
     static const Core::ParameterString paramDevice;
-    static std::string                 filterName() {
+
+    static std::string filterName() {
         return "audio-input-device-oss";
     }
+
     OpenSoundSystemDevice(const Core::Configuration&);
+
     virtual bool isFileOpen() const {
         return isDeviceOpen();
     }
+
     virtual void setSampleRate(Flow::Time _sampleRate);
     virtual void setSampleSize(u8 _sampleSize);
     virtual void setTrackCount(u8 _trackCount);
diff --git a/src/Audio/Raw.cc b/src/Audio/Raw.cc
index eaa4e6a20..33633a9c6 100644
--- a/src/Audio/Raw.cc
+++ b/src/Audio/Raw.cc
@@ -31,7 +31,9 @@ const Core::ParameterInt RawSourceNode::paramTracks(
         "track-count", "number of tracks", 1, 1);
 
 RawSourceNode::RawSourceNode(const Core::Configuration& c)
-        : Core::Component(c), Node(c), SourceNode(c) {
+        : Core::Component(c),
+          Node(c),
+          SourceNode(c) {
     sampleRate_ = paramSampleRate(config);
     sampleSize_ = paramSampleSize(config);
     trackCount_ = paramTracks(config);
@@ -57,7 +59,9 @@ const Core::ParameterInt RawFileInputNode::paramOffset(
         "offset", "number of bytes to skip at start of file", 0, 0);
 
 RawFileInputNode::RawFileInputNode(const Core::Configuration& c)
-        : Core::Component(c), Node(c), RawSourceNode(c) {
+        : Core::Component(c),
+          Node(c),
+          RawSourceNode(c) {
     offset_ = paramOffset(c);
 }
 
diff --git a/src/Audio/Wav.hh b/src/Audio/Wav.hh
index cd0034451..6e722c6be 100644
--- a/src/Audio/Wav.hh
+++ b/src/Audio/Wav.hh
@@ -67,6 +67,7 @@ public:
         return "audio-output-file-wav";
     }
     WavOutputNode(const Core::Configuration& c);
+
     virtual ~WavOutputNode() {
         if (isFileOpen())
             closeFile_();
diff --git a/src/Bliss/CorpusDescription.cc b/src/Bliss/CorpusDescription.cc
index 84f270539..8fd343b92 100644
--- a/src/Bliss/CorpusDescription.cc
+++ b/src/Bliss/CorpusDescription.cc
@@ -335,7 +335,9 @@ void CorpusDescription::SegmentPartitionVisitorAdaptor::loadSegmentList(const st
 
 // ---------------------------------------------------------------------------
 ProgressReportingVisitorAdaptor::ProgressReportingVisitorAdaptor(Core::XmlChannel& ch, bool reportOrth)
-        : visitor_(0), channel_(ch), reportSegmentOrth_(reportOrth) {}
+        : visitor_(0),
+          channel_(ch),
+          reportSegmentOrth_(reportOrth) {}
 
 void ProgressReportingVisitorAdaptor::enterCorpus(Corpus* c) {
     channel_ << Core::XmlOpen((c->level()) ? "subcorpus" : "corpus") + Core::XmlAttribute("name", c->name()) + Core::XmlAttribute("full-name", c->fullName());
@@ -432,7 +434,9 @@ class CorpusDescription::ProgressIndicationVisitorAdaptor : public CorpusVisitor
 
 public:
     ProgressIndicationVisitorAdaptor()
-            : nSegments_(0), visitor_(0), pi_("traversing corpus", "segments") {}
+            : nSegments_(0),
+              visitor_(0),
+              pi_("traversing corpus", "segments") {}
     void setVisitor(CorpusVisitor* v) {
         visitor_ = v;
     }
diff --git a/src/Bliss/CorpusDescription.hh b/src/Bliss/CorpusDescription.hh
index 6c853542c..9407f6a06 100644
--- a/src/Bliss/CorpusDescription.hh
+++ b/src/Bliss/CorpusDescription.hh
@@ -93,10 +93,12 @@ class Speaker : public NamedCorpusEntity {
     friend class SpeakerDescriptionElement;
 
 public:
-    enum Gender { unknown,
-                  male,
-                  female,
-                  nGenders };
+    enum Gender {
+        unknown,
+        male,
+        female,
+        nGenders
+    };
     static const char* genderId[nGenders];
 
 private:
@@ -320,9 +322,11 @@ class Segment : public ParentEntity {
     friend class CorpusDescriptionParser;
 
 public:
-    enum Type { typeSpeech,
-                typeOther,
-                nTypes };
+    enum Type {
+        typeSpeech,
+        typeOther,
+        nTypes
+    };
     static const char* typeId[nTypes];
 
 private:
@@ -563,9 +567,11 @@ private:
 
     ProgressReportingVisitorAdaptor* reporter_;
 
-    enum ProgressIndcationMode { noProgress,
-                                 localProgress,
-                                 globalProgress };
+    enum ProgressIndcationMode {
+        noProgress,
+        localProgress,
+        globalProgress
+    };
     static const Core::Choice          progressIndicationChoice;
     static const Core::ParameterChoice paramProgressIndication;
     ProgressIndcationMode              progressIndicationMode_;
diff --git a/src/Bliss/CorpusParser.cc b/src/Bliss/CorpusParser.cc
index 16c043abe..a9a2e6ec2 100644
--- a/src/Bliss/CorpusParser.cc
+++ b/src/Bliss/CorpusParser.cc
@@ -298,7 +298,8 @@ void CorpusDescriptionParser::initSchema() {
 }
 
 CorpusDescriptionParser::CorpusDescriptionParser(const Configuration& c)
-        : XmlSchemaParser(c), progressIndicator_(paramProgress(c) ? new Core::ProgressIndicator("CorpusDescriptionParser", "segments") : 0) {
+        : XmlSchemaParser(c),
+          progressIndicator_(paramProgress(c) ? new Core::ProgressIndicator("CorpusDescriptionParser", "segments") : 0) {
     initSchema();
 
     isSubParser_    = false;
@@ -312,7 +313,8 @@ CorpusDescriptionParser::CorpusDescriptionParser(const Configuration& c)
 }
 
 CorpusDescriptionParser::CorpusDescriptionParser(const Configuration& c, Corpus* _corpus)
-        : XmlSchemaParser(c), progressIndicator_(paramProgress(c) ? new Core::ProgressIndicator("CorpusDescriptionParser", "segments") : 0) {
+        : XmlSchemaParser(c),
+          progressIndicator_(paramProgress(c) ? new Core::ProgressIndicator("CorpusDescriptionParser", "segments") : 0) {
     initSchema();
 
     isSubParser_    = true;
diff --git a/src/Bliss/CorpusStatistics.hh b/src/Bliss/CorpusStatistics.hh
index 60725d3e2..0b94e4264 100644
--- a/src/Bliss/CorpusStatistics.hh
+++ b/src/Bliss/CorpusStatistics.hh
@@ -61,7 +61,8 @@ private:
         unsigned int nSegments;
         Time         totalDuration;
         SpeakerStatistics()
-                : nSegments(0), totalDuration(0.0) {}
+                : nSegments(0),
+                  totalDuration(0.0) {}
     };
     void                                           writeSpeakerStatistics(const SpeakerStatistics&, Core::XmlWriter&) const;
     typedef Core::StringHashMap<SpeakerStatistics> SpeakerStatisticsMap;
@@ -86,7 +87,8 @@ private:
         unsigned int nSegments;
         Time         totalDuration;
         ConditionStatistics()
-                : nSegments(0), totalDuration(0.0) {}
+                : nSegments(0),
+                  totalDuration(0.0) {}
     };
     void                                             writeConditionStatistics(const ConditionStatistics&, Core::XmlWriter&) const;
     typedef Core::StringHashMap<ConditionStatistics> ConditionStatisticsMap;
diff --git a/src/Bliss/EditDistance.cc b/src/Bliss/EditDistance.cc
index bafdeb33a..9a145b181 100644
--- a/src/Bliss/EditDistance.cc
+++ b/src/Bliss/EditDistance.cc
@@ -127,7 +127,8 @@ struct EditDistance::Trace : public Core::ReferenceCounted,
 
 struct EditDistance::State {
     Fsa::StateId a, b;
-    bool         operator==(const State& rhs) const {
+
+    bool operator==(const State& rhs) const {
         return a == rhs.a && b == rhs.b;
     }
 
@@ -445,10 +446,18 @@ void ErrorStatistic::clear() {
 }
 
 ErrorStatistic::ErrorStatistic()
-        : nLeftTokens_(0), nRightTokens_(0), nInsertions_(0), nDeletions_(0), nSubstitutions_(0) {}
+        : nLeftTokens_(0),
+          nRightTokens_(0),
+          nInsertions_(0),
+          nDeletions_(0),
+          nSubstitutions_(0) {}
 
 ErrorStatistic::ErrorStatistic(const EditDistance::Alignment& a)
-        : nLeftTokens_(0), nRightTokens_(0), nInsertions_(0), nDeletions_(0), nSubstitutions_(0) {
+        : nLeftTokens_(0),
+          nRightTokens_(0),
+          nInsertions_(0),
+          nDeletions_(0),
+          nSubstitutions_(0) {
     *this += a;
 }
 
diff --git a/src/Bliss/EditDistance.hh b/src/Bliss/EditDistance.hh
index bba4f4d8d..18f24ac2e 100644
--- a/src/Bliss/EditDistance.hh
+++ b/src/Bliss/EditDistance.hh
@@ -62,23 +62,29 @@ namespace Bliss {
 
 class EditDistance : public Core::Component {
 public:
-    typedef enum { Deletion,
-                   Insertion,
-                   Substitution,
-                   Correct,
-                   Empty } EditOperation;
+    typedef enum {
+        Deletion,
+        Insertion,
+        Substitution,
+        Correct,
+        Empty
+    } EditOperation;
     typedef f32                            Score;
     typedef u32                            Cost;
     typedef std::pair<EditOperation, Cost> EditCost;
 
-    typedef enum { FormatBliss,
-                   FormatNist } AlignmentFormat;
+    typedef enum {
+        FormatBliss,
+        FormatNist
+    } AlignmentFormat;
 
     struct AlignmentItem {
         const Token * a, *b;
         EditOperation op;
         AlignmentItem(const Bliss::Token* _a, const Bliss::Token* _b, EditOperation _op)
-                : a(_a), b(_b), op(_op) {}
+                : a(_a),
+                  b(_b),
+                  op(_op) {}
 
         void                 write(std::ostream& o) const;
         friend std::ostream& operator<<(std::ostream& o, const AlignmentItem& a) {
@@ -99,7 +105,9 @@ public:
 
     public:
         Alignment(AlignmentFormat format = FormatBliss)
-                : format_(format), score(0), cost(0) {}
+                : format_(format),
+                  score(0),
+                  cost(0) {}
         void clear();
         void write(Core::XmlWriter& xml) const;
     };
@@ -155,21 +163,27 @@ public:
     void operator+=(const EditDistance::Alignment&);
     void operator+=(const ErrorStatistic&);
     void write(Core::XmlWriter&) const;
-    u32  nLeftTokens() const {
+
+    u32 nLeftTokens() const {
         return nLeftTokens_;
     }
+
     u32 nRightTokens() const {
         return nLeftTokens_ - nDeletions_ + nInsertions_;
     }
+
     u32 nInsertions() const {
         return nInsertions_;
     }
+
     u32 nDeletions() const {
         return nDeletions_;
     }
+
     u32 nSubstitutions() const {
         return nSubstitutions_;
     }
+
     u32 nErrors() const {
         return nInsertions_ + nDeletions_ + nSubstitutions_;
     }
diff --git a/src/Bliss/Fsa.cc b/src/Bliss/Fsa.cc
index 02a0c19b0..c2cc83ae6 100644
--- a/src/Bliss/Fsa.cc
+++ b/src/Bliss/Fsa.cc
@@ -19,10 +19,14 @@
 using namespace Bliss;
 
 TokenAlphabet::TokenAlphabet(const TokenInventory& ti)
-        : lexicon_(), tokens_(ti), nDisambiguators_(0) {}
+        : lexicon_(),
+          tokens_(ti),
+          nDisambiguators_(0) {}
 
 TokenAlphabet::TokenAlphabet(LexiconRef l, const TokenInventory& ti)
-        : lexicon_(l), tokens_(ti), nDisambiguators_(0) {}
+        : lexicon_(l),
+          tokens_(ti),
+          nDisambiguators_(0) {}
 
 TokenAlphabet::~TokenAlphabet() {}
 
diff --git a/src/Bliss/Fsa.hh b/src/Bliss/Fsa.hh
index 9b271e81e..86de1e1e7 100644
--- a/src/Bliss/Fsa.hh
+++ b/src/Bliss/Fsa.hh
@@ -116,7 +116,8 @@ private:
     friend class Lexicon;
     mutable u32 nDisambiguators_;
     LemmaPronunciationAlphabet(LexiconRef l)
-            : lexicon_(l), nDisambiguators_(0) {}
+            : lexicon_(l),
+              nDisambiguators_(0) {}
 
 public:
     Fsa::LabelId index(const LemmaPronunciation* l) const {
diff --git a/src/Bliss/Lexicon.cc b/src/Bliss/Lexicon.cc
index ef091a569..fd353bfd8 100644
--- a/src/Bliss/Lexicon.cc
+++ b/src/Bliss/Lexicon.cc
@@ -56,7 +56,8 @@ bool Lemma::hasPronunciation(const Pronunciation* pron) const {
 
 // ===========================================================================
 Pronunciation::Pronunciation(const Phoneme::Id* _phonemes)
-        : lemmas_(0), phonemes_(_phonemes) {}
+        : lemmas_(0),
+          phonemes_(_phonemes) {}
 
 Pronunciation::~Pronunciation() {}
 
@@ -128,8 +129,7 @@ struct Lexicon::Internal {
 Lexicon::Lexicon(const Configuration& c)
         : Component(c),
           symbolSequences_(symbols_),
-          internal_(0) {
-    internal_ = new Internal;
+          internal_(new Internal) {
 }
 
 Lexicon::~Lexicon() {
@@ -199,9 +199,9 @@ void Lexicon::setOrthographicForms(Lemma* lemma, const std::vector<std::string>&
         require(isWhitespaceNormalized(*orth));
         const char *cc, *nc;
         for (cc = nc = orth->c_str(); *cc; cc = nc) {
-            do
+            do {
                 ++nc;
-            while (*nc && utf8::byteType(*nc) == utf8::multiByteTail);
+            } while (*nc && utf8::byteType(*nc) == utf8::multiByteTail);
             letter(std::string(cc, nc));
         }
     }
@@ -222,6 +222,14 @@ void Lexicon::setDefaultLemmaName(Lemma* lemma) {
     lemmas_.link(lemma->name(), lemma);
 }
 
+void Lexicon::setLemmaName(Lemma* lemma, Symbol symbol) {
+    require(lemma);
+    require(!lemma->hasName());
+    verify(isWhitespaceNormalized(symbol.str()));
+    lemma->setName(symbol);
+    lemmas_.link(lemma->name(), lemma);
+}
+
 const Letter* Lexicon::letter(const std::string& letter) const {
     Token* token = letters_[letter.c_str()];
     if (!token) {
@@ -294,6 +302,11 @@ Core::Status Lexicon::getPronunciation(const std::string& phon, Pronunciation*&
     return status;
 }
 
+Pronunciation* Lexicon::getPronunciation(const std::vector<Phoneme::Id>& phonemes) {
+    require(phonemeInventory());
+    return getOrCreatePronunciation(phonemes);
+}
+
 void Lexicon::addPronunciation(Lemma* lemma, Pronunciation* pron, f32 weight) {
     require(lemma);
     require(pron);
@@ -350,6 +363,20 @@ void Lexicon::setSyntacticTokenSequence(Lemma* lemma, const std::vector<std::str
     lemma->setSyntacticTokenSequence(tokenSequence);
 }
 
+void Lexicon::setSyntacticTokenSequence(Lemma* lemma, const std::vector<Token::Id>& synt_ids) {
+    require(lemma);
+    synts_.start();
+    for (Token::Id id : synt_ids) {
+        SyntacticToken* token = static_cast<SyntacticToken*>(syntacticTokens_[id]);
+        // SyntacticToken* token = syntacticTokens_[id];
+        synts_.grow(token);
+        token->addLemma(lemma);
+    }
+    SyntacticTokenSequence tokenSequence(synts_.currentBegin(), synts_.currentEnd());
+    synts_.finish();
+    lemma->setSyntacticTokenSequence(tokenSequence);
+}
+
 void Lexicon::setDefaultSyntacticToken(Lemma* lemma) {
     require(lemma);
     require(lemma->nOrthographicForms());
@@ -381,6 +408,18 @@ void Lexicon::addEvaluationTokenSequence(Lemma* lemma, const std::vector<std::st
     lemma->addEvaluationTokenSequence(tokenSequence);
 }
 
+void Lexicon::addEvaluationTokenSequence(Lemma* lemma, const std::vector<Token::Id>& ids) {
+    require(lemma);
+    evals_.start();
+    for (auto id : ids) {
+        EvaluationToken* token = static_cast<EvaluationToken*>(evaluationTokens_[id]);
+        evals_.grow(token);
+    }
+    EvaluationTokenSequence tokenSequence(evals_.currentBegin(), evals_.currentEnd());
+    evals_.finish();
+    lemma->addEvaluationTokenSequence(tokenSequence);
+}
+
 void Lexicon::setDefaultEvaluationToken(Lemma* lemma) {
     require(lemma);
     require(lemma->nOrthographicForms());
@@ -392,14 +431,32 @@ void Lexicon::setDefaultEvaluationToken(Lemma* lemma) {
 }
 
 void Lexicon::defineSpecialLemma(const std::string& name, Lemma* lemma) {
-    require(!specialLemma(name));
     require(lemma);
-    specialLemmas_[name] = lemma;
+
+    specialLemmas_[name].insert(lemma);
 }
 
+void Lexicon::removeSpecialLemma(const Lemma* lemma) {
+    for (SpecialLemmaMap::iterator iter = specialLemmas_.begin(); iter != specialLemmas_.end(); ++iter)
+        if (iter->second.count(lemma) > 0) {
+            iter->second.erase(lemma);
+            break;
+        }
+}
+
+// Note: we only return the first lemma (mostly just one for internal specified special names)
 const Lemma* Lexicon::specialLemma(const std::string& name) const {
-    LemmaMap::const_iterator i = specialLemmas_.find(name);
-    return (i == specialLemmas_.end()) ? 0 : i->second;
+    SpecialLemmaMap::const_iterator i = specialLemmas_.find(name);
+    return (i == specialLemmas_.end()) ? 0 : *(i->second.begin());
+}
+
+std::string Lexicon::getSpecialLemmaName(const Lemma* lemma) const {
+    for (const auto it : specialLemmas_) {
+        if (it.second.count(lemma) > 0)
+            return it.first;
+    }
+
+    return "";
 }
 
 void Lexicon::writeXml(Core::XmlWriter& os) const {
@@ -410,12 +467,7 @@ void Lexicon::writeXml(Core::XmlWriter& os) const {
     for (tie(l, l_end) = lemmas(); l != l_end; ++l) {
         const Lemma* lemma(*l);
 
-        std::string specialName = "";
-        for (LemmaMap::const_iterator i = specialLemmas_.begin();
-             i != specialLemmas_.end(); ++i) {
-            if (i->second->id() == lemma->id())
-                specialName = i->first;
-        }
+        std::string specialName = getSpecialLemmaName(lemma);
         if (specialName.length() == 0)
             os << Core::XmlOpen("lemma");
         else
diff --git a/src/Bliss/Lexicon.hh b/src/Bliss/Lexicon.hh
index dd2955226..83967d26f 100644
--- a/src/Bliss/Lexicon.hh
+++ b/src/Bliss/Lexicon.hh
@@ -32,6 +32,7 @@
 #include <Core/Status.hh>
 #include <Core/StringUtilities.hh>
 #include <Core/Types.hh>
+#include <Core/robin_hood.h>
 
 #include "Phoneme.hh"
 #include "Symbol.hh"
@@ -418,6 +419,10 @@ protected:
         lemmas_.push_back(lemma);
     }
 
+    void reduceLemma() {
+        lemmas_.pop_back();  // only size matter, not order
+    }
+
 public:
     /** The number of lemmata this token occurs in. */
     u32 nLemmas() const {
@@ -516,9 +521,11 @@ protected:
 
     // lemmas
     friend class Bliss::LemmaAlphabet;
-    TokenInventory                      lemmas_;
-    typedef Core::StringHashMap<Lemma*> LemmaMap;
-    LemmaMap                            specialLemmas_;
+    TokenInventory lemmas_;
+
+    typedef robin_hood::unordered_map<std::string, robin_hood::unordered_set<const Lemma*>> SpecialLemmaMap;
+    SpecialLemmaMap                                                                         specialLemmas_;
+    typedef Core::StringHashMap<Lemma*>                                                     LemmaMap;
 
     friend class Bliss::LemmaPronunciationAlphabet;
     typedef std::vector<const LemmaPronunciation*> LemmaPronunciationList;
@@ -575,13 +582,15 @@ public:
      * Set the unique name of a lemma.
      */
     void setDefaultLemmaName(Lemma* lemma);
+    void setLemmaName(Lemma* lemma, Symbol symbol);
 
     /**
      * Get a pronunciation for a string representation.
      * @param phon a string containing a white-space separate list
      * of phoneme symbols.
      */
-    Core::Status getPronunciation(const std::string& phon, Pronunciation*& out);
+    Core::Status   getPronunciation(const std::string& phon, Pronunciation*& out);
+    Pronunciation* getPronunciation(const std::vector<Phoneme::Id>& phonemes);
 
     /**
      * Add a pronunciation to a lemma.
@@ -599,12 +608,14 @@ public:
      * Set the a syntactic token sequence for a lemma.
      */
     void setSyntacticTokenSequence(Lemma* lemma, const std::vector<std::string>& synt);
+    void setSyntacticTokenSequence(Lemma* lemma, const std::vector<Token::Id>& synt);
     void setDefaultSyntacticToken(Lemma* lemma);
 
     /**
      * Set the a evaluation token sequence for a lemma.
      */
     void addEvaluationTokenSequence(Lemma* lemma, const std::vector<std::string>& eval);
+    void addEvaluationTokenSequence(Lemma* lemma, const std::vector<Token::Id>& ids);
     void setDefaultEvaluationToken(Lemma* lemma);
 
     /**
@@ -615,6 +626,8 @@ public:
      */
     void defineSpecialLemma(const std::string& name, Lemma* lemma);
 
+    void removeSpecialLemma(const Lemma* lemma);
+
     /**
      * Load lexicon from XML or txt file.
      */
@@ -706,6 +719,14 @@ public:
      */
     const Lemma* specialLemma(const std::string& name) const;
 
+    /**
+     * If a lemma is declared as special, return the string specified
+     * in the "special" attribute (<lemma special="foo">).
+     * @return empty string if a lemma is not special, or the
+     * special attribute specified in the lexicon.
+     */
+    std::string getSpecialLemmaName(const Lemma* lemma) const;
+
     Core::Ref<const LemmaAlphabet> lemmaAlphabet() const;
 
     // -------------------------------------------------------------------
diff --git a/src/Bliss/Phoneme.cc b/src/Bliss/Phoneme.cc
index 21853948f..35e5669c8 100644
--- a/src/Bliss/Phoneme.cc
+++ b/src/Bliss/Phoneme.cc
@@ -22,7 +22,8 @@ using namespace Bliss;
 const Phoneme::Id Phoneme::term;
 
 Phoneme::Phoneme()
-        : Token(), isContextDependent_(true) {}
+        : Token(),
+          isContextDependent_(true) {}
 
 struct PhonemeInventory::Internal {
     SymbolSet                            symbols_;
diff --git a/src/Bliss/Phonology.cc b/src/Bliss/Phonology.cc
index fe42c0b49..499b982dd 100644
--- a/src/Bliss/Phonology.cc
+++ b/src/Bliss/Phonology.cc
@@ -28,7 +28,7 @@ bool ContextPhonology::SemiContext::empty() const {
     }
     else if ((*begin()) == Phoneme::term) {
         // The 'term' element cannot be followed by not 'term' element.
-        verify(std::find_if(begin(), end(), std::bind2nd(std::not_equal_to<Phoneme::Id>(), Phoneme::term)) == end());
+        verify(std::find_if(begin(), end(), std::bind(std::not_equal_to<Phoneme::Id>(), std::placeholders::_1, Phoneme::term)) == end());
         return true;
     }
     return false;
diff --git a/src/Bliss/Phonology.hh b/src/Bliss/Phonology.hh
index 5e54d28e7..1ffa34723 100644
--- a/src/Bliss/Phonology.hh
+++ b/src/Bliss/Phonology.hh
@@ -91,7 +91,8 @@ public:
         SemiContext history, future;
         Context() {}
         Context(const SemiContext& h, const SemiContext& f)
-                : history(h), future(f) {}
+                : history(h),
+                  future(f) {}
         bool operator==(const Context& rhs) const {
             return history == rhs.history && future == rhs.future;
         }
@@ -164,7 +165,8 @@ public:
     PhonemeInContext()
             : phoneme_(Phoneme::term){};
     PhonemeInContext(Phoneme::Id phoneme, const SemiContext& history = SemiContext(), const SemiContext& future = SemiContext())
-            : phoneme_(phoneme), context_(history, future) {}
+            : phoneme_(phoneme),
+              context_(history, future) {}
 
     bool operator==(const PhonemeInContext& rhs) const {
         return phoneme_ == rhs.phoneme_ && context_ == rhs.context_;
diff --git a/src/Bliss/SegmentOrdering.cc b/src/Bliss/SegmentOrdering.cc
index 682c68d5e..f101d0d03 100644
--- a/src/Bliss/SegmentOrdering.cc
+++ b/src/Bliss/SegmentOrdering.cc
@@ -264,7 +264,10 @@ void SegmentOrderingVisitor::leaveCorpus(Corpus* corpus) {
 }
 
 SegmentOrderingVisitor::CustomCorpusGuide::CustomCorpusGuide(SegmentOrderingVisitor* parent, Corpus* rootCorpus)
-        : parent_(parent), rootCorpus_(rootCorpus), curCorpus_(rootCorpus_), curRecording_(0) {
+        : parent_(parent),
+          rootCorpus_(rootCorpus),
+          curCorpus_(rootCorpus_),
+          curRecording_(0) {
     // Enter the root corpus.
     parent_->visitor_->enterCorpus(rootCorpus_);
 }
diff --git a/src/Bliss/Symbol.hh b/src/Bliss/Symbol.hh
index 70d924341..01a0b7848 100644
--- a/src/Bliss/Symbol.hh
+++ b/src/Bliss/Symbol.hh
@@ -165,11 +165,13 @@ private:
 
 protected:
     Token(Id _id, Bliss::Symbol _symbol)
-            : id_(_id), symbol_(_symbol) {}
+            : id_(_id),
+              symbol_(_symbol) {}
     Token(Id _id)
             : id_(_id) {}
     Token(Bliss::Symbol _symbol)
-            : id_(invalidId), symbol_(_symbol) {}
+            : id_(invalidId),
+              symbol_(_symbol) {}
     Token()
             : id_(invalidId) {}
     friend class TokenInventory;
@@ -240,7 +242,8 @@ public:
     }
 
     typedef Token* const* Iterator;
-    Iterator              begin() const {
+
+    Iterator begin() const {
         return &(*list_.begin());
     }
 
@@ -311,13 +314,16 @@ protected:
 
 public:  // FIXME
     SymbolSequence(const Symbol* _begin, const Symbol* _end)
-            : begin_(_begin), end_(_end) {}
+            : begin_(_begin),
+              end_(_end) {}
 
 public:
     SymbolSequence()
-            : begin_(0), end_(0) {}
+            : begin_(0),
+              end_(0) {}
     SymbolSequence(const SymbolSequence& o)
-            : begin_(o.begin_), end_(o.end_) {}
+            : begin_(o.begin_),
+              end_(o.end_) {}
 
     bool valid() const {
         return begin_ != 0;
diff --git a/src/Cart/DecisionTree.hh b/src/Cart/DecisionTree.hh
index 4bd325039..7cac5ecb0 100644
--- a/src/Cart/DecisionTree.hh
+++ b/src/Cart/DecisionTree.hh
@@ -69,7 +69,9 @@ public:
 public:
     Question(PropertyMapRef     map,
              const std::string& desc = "")
-            : map_(map), desc_(desc), index(InvalidQuestionIndex) {}
+            : map_(map),
+              desc_(desc),
+              index(InvalidQuestionIndex) {}
     virtual ~Question() {}
 
     virtual Answer operator()(const Properties& props) const = 0;
diff --git a/src/Cart/DecisionTreeTrainer.hh b/src/Cart/DecisionTreeTrainer.hh
index 9a19161bf..96a2d702a 100644
--- a/src/Cart/DecisionTreeTrainer.hh
+++ b/src/Cart/DecisionTreeTrainer.hh
@@ -43,7 +43,8 @@ struct ExamplePtrRange {
     ExamplePtrList::const_iterator begin;
     ExamplePtrList::const_iterator end;
     ExamplePtrRange(ExamplePtrList::const_iterator begin, ExamplePtrList::const_iterator end)
-            : begin(begin), end(end) {}
+            : begin(begin),
+              end(end) {}
     size_t size() const {
         return end - begin;
     }
@@ -73,10 +74,10 @@ public:
             const ExamplePtrRange& leftExamples, const ExamplePtrRange& rightExamples,
             const Score fatherScore,
             Score& leftChildScore, Score& rightChildScore) const = 0;
-    virtual void operator()(
-            const ExamplePtrRange& examples,
-            Score&                 score) const {
+
+    virtual void operator()(const ExamplePtrRange& examples, Score& score) const {
         Score dummy;
+
         operator()(examples, ExamplePtrRange(ExamplePtrList::const_iterator(), ExamplePtrList::const_iterator()), 0.0, score, dummy);
     }
 };
diff --git a/src/Cart/Example.hh b/src/Cart/Example.hh
index 16712ebe9..ca5a9423d 100644
--- a/src/Cart/Example.hh
+++ b/src/Cart/Example.hh
@@ -59,7 +59,8 @@ public:
 
     public:
         row_vector_iterator(f64* begin, size_t size)
-                : ptr_(begin), size_(size) {}
+                : ptr_(begin),
+                  size_(size) {}
 
         row_iterator begin() {
             return ptr_;
@@ -99,7 +100,8 @@ public:
 
     public:
         const_row_vector_iterator(f64* begin, size_t size)
-                : ptr_(begin), size_(size) {}
+                : ptr_(begin),
+                  size_(size) {}
 
         const_row_iterator begin() const {
             return ptr_;
@@ -132,7 +134,8 @@ public:
 
     public:
         column_iterator(f64* begin, size_t offset)
-                : ptr_(begin), offset_(offset) {}
+                : ptr_(begin),
+                  offset_(offset) {}
 
         f64& operator*() {
             return *ptr_;
@@ -155,7 +158,8 @@ public:
 
     public:
         const_column_iterator(f64* begin, size_t offset)
-                : ptr_(begin), offset_(offset) {}
+                : ptr_(begin),
+                  offset_(offset) {}
 
         f64 operator*() const {
             return *ptr_;
@@ -179,7 +183,9 @@ public:
 
     public:
         column_vector_iterator(f64* begin, size_t size, size_t overall_size)
-                : ptr_(begin), size_(size), overall_size_(overall_size) {}
+                : ptr_(begin),
+                  size_(size),
+                  overall_size_(overall_size) {}
 
         column_iterator begin() {
             return column_iterator(ptr_, size_);
@@ -220,7 +226,9 @@ public:
 
     public:
         const_column_vector_iterator(f64* begin, size_t size, size_t overall_size)
-                : ptr_(begin), size_(size), overall_size_(overall_size) {}
+                : ptr_(begin),
+                  size_(size),
+                  overall_size_(overall_size) {}
 
         const_column_iterator begin() const {
             return const_column_iterator(ptr_, size_);
diff --git a/src/Cart/Properties.hh b/src/Cart/Properties.hh
index d6abe4131..2011d69ba 100644
--- a/src/Cart/Properties.hh
+++ b/src/Cart/Properties.hh
@@ -271,7 +271,8 @@ public:
 
     struct PtrHashFcn {
         HashFcn hasher;
-        size_t  operator()(const Properties* const props) const {
+
+        size_t operator()(const Properties* const props) const {
             return hasher(*props);
         }
     };
diff --git a/src/Core/Archive.cc b/src/Core/Archive.cc
index 7de1d64aa..07d5905c1 100644
--- a/src/Core/Archive.cc
+++ b/src/Core/Archive.cc
@@ -27,7 +27,9 @@
 using namespace Core;
 
 Archive::Archive(const Core::Configuration& config, const std::string& path, AccessMode access)
-        : Component(config), path_(path), access_(access) {
+        : Component(config),
+          path_(path),
+          access_(access) {
 }
 
 bool Archive::hasFile(const std::string& name) const {
@@ -361,7 +363,10 @@ class ArchiveWriterBuffer : public std::streambuf {
 }  // namespace
 
 ArchiveWriter::ArchiveWriter(Archive& archive, const std::string& path, bool compress)
-        : std::ostream(new ArchiveWriterBuffer(buffer_)), archive_(archive), path_(path), compress_(compress) {
+        : std::ostream(new ArchiveWriterBuffer(buffer_)),
+          archive_(archive),
+          path_(path),
+          compress_(compress) {
     isOpen_ = true;
 }
 
diff --git a/src/Core/Archive.hh b/src/Core/Archive.hh
index 5bdf4590c..f86f65b24 100644
--- a/src/Core/Archive.hh
+++ b/src/Core/Archive.hh
@@ -37,10 +37,12 @@ public:
     /**
      * Different types of archives handled by this class.
      **/
-    enum Type { TypeUnknown,
-                TypeDirectory,
-                TypeFile,
-                TypeBundle };
+    enum Type {
+        TypeUnknown,
+        TypeDirectory,
+        TypeFile,
+        TypeBundle
+    };
 
     /**
      * Different access types to archives.
@@ -59,7 +61,8 @@ public:
 
     public:
         Sizes(u32 uncompressed = 0, u32 compressed = 0)
-                : uncompressed_(uncompressed), compressed_(compressed) {}
+                : uncompressed_(uncompressed),
+                  compressed_(compressed) {}
         void setUncompressed(u32 uncompressed) {
             uncompressed_ = uncompressed;
         }
@@ -83,9 +86,11 @@ public:
         virtual ~_const_iterator() {}
         virtual _const_iterator& operator++()          = 0;
         virtual                  operator bool() const = 0;
-        const std::string&       name() {
+
+        const std::string& name() {
             return name_;
         }
+
         const Sizes& sizes() {
             return sizes_;
         }
diff --git a/src/Core/BinaryStream.cc b/src/Core/BinaryStream.cc
index 6cab20a45..9f1e19ce6 100644
--- a/src/Core/BinaryStream.cc
+++ b/src/Core/BinaryStream.cc
@@ -22,7 +22,8 @@ using namespace Core;
 // class BinaryOutputStream
 
 BinaryStreamIos::BinaryStreamIos(Endianess endianess)
-        : ios_(0), fstream_(0) {
+        : ios_(0),
+          fstream_(0) {
     ios_ = fstream_ = new std::fstream;
     setEndianess(endianess);
 }
@@ -36,7 +37,8 @@ BinaryStreamIos::BinaryStreamIos(std::ios& i, Endianess endianess)
 BinaryStreamIos::BinaryStreamIos(const std::string&      fileName,
                                  std::ios_base::openmode mode,
                                  Endianess               endianess)
-        : ios_(0), fstream_(0) {
+        : ios_(0),
+          fstream_(0) {
     mode |= std::ios::binary;
     fstream_ = new std::fstream(fileName.c_str(), mode);
     ios_     = fstream_;
diff --git a/src/Core/BinaryStream.hh b/src/Core/BinaryStream.hh
index 6b92d6eae..316dc9c9d 100644
--- a/src/Core/BinaryStream.hh
+++ b/src/Core/BinaryStream.hh
@@ -57,9 +57,11 @@ namespace Core {
 class BinaryStreamIos {
 public:
     typedef std::ios_base::iostate iostate;
-    enum Endianess { bigEndian,
-                     littleEndian,
-                     nativeByteOrder };
+    enum Endianess {
+        bigEndian,
+        littleEndian,
+        nativeByteOrder
+    };
     static const Endianess defaultEndianess = littleEndian;
 
 protected:
@@ -149,9 +151,11 @@ public:
 
 public:
     BinaryOutputStream(Endianess endianess = defaultEndianess)
-            : BinaryStreamIos(endianess), os_(fstream_) {}
+            : BinaryStreamIos(endianess),
+              os_(fstream_) {}
     explicit BinaryOutputStream(std::ostream& stream, Endianess endianess = defaultEndianess)
-            : BinaryStreamIos(stream, endianess), os_(&stream) {}
+            : BinaryStreamIos(stream, endianess),
+              os_(&stream) {}
     explicit BinaryOutputStream(const std::string&      fileName,
                                 std::ios_base::openmode mode      = std::ios::out,
                                 Endianess               endianess = defaultEndianess)
@@ -269,9 +273,11 @@ public:
 
 public:
     BinaryInputStream(Endianess endianess = defaultEndianess)
-            : BinaryStreamIos(endianess), is_(fstream_) {}
+            : BinaryStreamIos(endianess),
+              is_(fstream_) {}
     BinaryInputStream(std::istream& stream, Endianess endianess = defaultEndianess)
-            : BinaryStreamIos(stream, endianess), is_(&stream) {}
+            : BinaryStreamIos(stream, endianess),
+              is_(&stream) {}
     BinaryInputStream(const std::string&      fileName,
                       std::ios_base::openmode mode      = std::ios::in,
                       Endianess               endianess = defaultEndianess)
diff --git a/src/Core/BinaryTree.hh b/src/Core/BinaryTree.hh
index 6f8537f07..86b579c87 100644
--- a/src/Core/BinaryTree.hh
+++ b/src/Core/BinaryTree.hh
@@ -36,9 +36,11 @@ public:
         LeafNumber leafNumber;
 
         TreeStructureEntry()
-                : id(0), leafNumber(0){};
+                : id(0),
+                  leafNumber(0){};
         TreeStructureEntry(Id i, LeafNumber n)
-                : id(i), leafNumber(n){};
+                : id(i),
+                  leafNumber(n){};
 
         void read(Core::BinaryInputStream& i) {
             i >> id >> leafNumber;
@@ -58,7 +60,11 @@ public:
         u16   leafNumber_;
 
         Node()
-                : left_(0), right_(0), previous_(0), id_(0), leafNumber_(0){};
+                : left_(0),
+                  right_(0),
+                  previous_(0),
+                  id_(0),
+                  leafNumber_(0){};
     };
     typedef std::list<const Node*> LeafList;
 
diff --git a/src/Core/BitStream.hh b/src/Core/BitStream.hh
index 4aabe7297..5875fa2fe 100644
--- a/src/Core/BitStream.hh
+++ b/src/Core/BitStream.hh
@@ -74,7 +74,10 @@ constexpr size_t bitsizeof() {
 
 template<typename T>
 BitStream<T>::BitStream()
-        : posg_(0ul), posp_(0ul), size_(0ul), store_() {
+        : posg_(0ul),
+          posp_(0ul),
+          size_(0ul),
+          store_() {
 }
 
 template<typename T>
diff --git a/src/Core/Channel.cc b/src/Core/Channel.cc
index e5ee3591f..c5e5d27c4 100644
--- a/src/Core/Channel.cc
+++ b/src/Core/Channel.cc
@@ -101,7 +101,11 @@ const Core::ParameterBool Channel::Target::paramAddSprintTags(
         true);
 
 Channel::Target::Target(const Core::Configuration& c, bool isXmlDocument, const std::string& defaultFilename, std::streambuf* defaultStreamBuf)
-        : Core::Configurable(c), isTty_(false), xml_(*this), isXmlDocument_(isXmlDocument), defaultStreamBuf_(defaultStreamBuf) {
+        : Core::Configurable(c),
+          isTty_(false),
+          xml_(*this),
+          isXmlDocument_(isXmlDocument),
+          defaultStreamBuf_(defaultStreamBuf) {
     open(paramFilename(config, defaultFilename));
     setup();
 }
@@ -133,7 +137,11 @@ class FileStreamBuffer : public std::filebuf {
 #endif
 
 Channel::Target::Target(const Core::Configuration& c, bool isXmlDocument, std::ostream* defaultStream)
-        : Core::Configurable(c), isTty_(false), xml_(*this), isXmlDocument_(isXmlDocument), defaultStreamBuf_(defaultStream->rdbuf()) {
+        : Core::Configurable(c),
+          isTty_(false),
+          xml_(*this),
+          isXmlDocument_(isXmlDocument),
+          defaultStreamBuf_(defaultStream->rdbuf()) {
     require(defaultStream);
     std::string filename = paramFilename(config);
     if (filename.size()) {
diff --git a/src/Core/Channel.hh b/src/Core/Channel.hh
index f965e83d8..00114df8d 100644
--- a/src/Core/Channel.hh
+++ b/src/Core/Channel.hh
@@ -106,11 +106,15 @@ namespace Core {
 
 class Channel : public std::ostream {
 public:
-    enum TargetType { plainTarget,
-                      xmlTarget };
-    enum Default { disabled,
-                   standard,
-                   error };
+    enum TargetType {
+        plainTarget,
+        xmlTarget
+    };
+    enum Default {
+        disabled,
+        standard,
+        error
+    };
     static const Core::ParameterString paramTargets;
 
 private:
diff --git a/src/Core/Choice.cc b/src/Core/Choice.cc
index 2912f75e0..b072c6c4c 100644
--- a/src/Core/Choice.cc
+++ b/src/Core/Choice.cc
@@ -21,7 +21,8 @@ using namespace Core;
 
 const Choice::Value Choice::IllegalValue      = -1;
 const char* const   Choice::IllegalIdentifier = "";
-const char*         Choice::endMark() {
+
+const char* Choice::endMark() {
     return (const char*)0;
 }
 
diff --git a/src/Core/Choice.hh b/src/Core/Choice.hh
index b58e1d178..638e24dc0 100644
--- a/src/Core/Choice.hh
+++ b/src/Core/Choice.hh
@@ -48,16 +48,21 @@ private:
 
     public:
         Item(const char* ident, const Value value)
-                : ident_(ident), value_(value) {}
+                : ident_(ident),
+                  value_(value) {}
+
         const std::string& ident() const {
             return ident_;
         }
+
         Value value() const {
             return value_;
         }
+
         bool operator<(const Item& item) const {
             return ident_.compare(item.ident_) < 0;
         }
+
         bool operator==(const Item& item) const {
             return (value_ == item.value_) && (ident_ == item.ident_);
         }
@@ -151,9 +156,11 @@ public:
      * Iterator
      **/
     typedef std::set<Item>::const_iterator const_iterator;
-    const_iterator                         begin() const {
+
+    const_iterator begin() const {
         return items_by_ident.begin();
     }
+
     const_iterator end() const {
         return items_by_ident.end();
     }
diff --git a/src/Core/Component.hh b/src/Core/Component.hh
index d8d90ddfc..f50fb0322 100644
--- a/src/Core/Component.hh
+++ b/src/Core/Component.hh
@@ -202,7 +202,9 @@ public:
     private:
         friend class Component;
         Message(const Component* c, ErrorType type, XmlChannel* ch)
-                : ostream_(ch), component_(c), type_(type) {}
+                : ostream_(ch),
+                  component_(c),
+                  type_(type) {}
 
     public:
         operator XmlWriter&() const {
@@ -218,7 +220,9 @@ public:
                 __attribute__((format(printf, 2, 3)));
 
         Message(const Message& m)
-                : ostream_(m.ostream_), component_(m.component_), type_(m.type_) {
+                : ostream_(m.ostream_),
+                  component_(m.component_),
+                  type_(m.type_) {
             const_cast<Message&>(m).component_ = 0;
         }
 
diff --git a/src/Core/CompressedStream.cc b/src/Core/CompressedStream.cc
index 2d57d3f10..c531acb94 100644
--- a/src/Core/CompressedStream.cc
+++ b/src/Core/CompressedStream.cc
@@ -27,10 +27,14 @@ namespace Core {
 // ***************************************************************************
 
 CompressedInputStream::CompressedInputStream()
-        : std::istream(0), file_buf_(nullptr), buf_(nullptr) {}
+        : std::istream(0),
+          file_buf_(nullptr),
+          buf_(nullptr) {}
 
 CompressedInputStream::CompressedInputStream(const std::string& name)
-        : std::istream(0), file_buf_(nullptr), buf_(nullptr) {
+        : std::istream(0),
+          file_buf_(nullptr),
+          buf_(nullptr) {
     open(name);
 }
 
@@ -67,10 +71,14 @@ void CompressedInputStream::close() {
 // ***************************************************************************
 
 CompressedOutputStream::CompressedOutputStream()
-        : std::ostream(0), file_buf_(nullptr), buf_(nullptr) {}
+        : std::ostream(0),
+          file_buf_(nullptr),
+          buf_(nullptr) {}
 
 CompressedOutputStream::CompressedOutputStream(const std::string& name)
-        : std::ostream(0), file_buf_(nullptr), buf_(nullptr) {
+        : std::ostream(0),
+          file_buf_(nullptr),
+          buf_(nullptr) {
     open(name);
 }
 
diff --git a/src/Core/Configuration.cc b/src/Core/Configuration.cc
index ac8346d1f..e034b2a7c 100644
--- a/src/Core/Configuration.cc
+++ b/src/Core/Configuration.cc
@@ -105,7 +105,7 @@ class Configuration::Resource {
 
     /**
      * Determine if the resource matches a configurtion path.
-     * @param components the coponents of the configuration path
+     * @param components the components of the configuration path
      * @return the number of path components matched by the resource,
      * or -1 of the resource does not match.
      */
@@ -168,7 +168,6 @@ void Configuration::Resource::writeUsage(XmlWriter& os) const {
 /**
  * Central storage place for all resources.
  */
-
 class Configuration::ResourceDataBase : public ReferenceCounted {
 private:
     std::set<Resource> resources;
@@ -750,8 +749,10 @@ std::vector<std::string> Configuration::setFromCommandline(
         const SourceDescriptor*         source) {
     std::string              option;
     std::vector<std::string> unparsed;
-    enum { Option,
-           Argument } state = Option;
+    enum {
+        Option,
+        Argument
+    } state = Option;
 
     if (arguments.size() == 0)
         return unparsed;
diff --git a/src/Core/Debug.cc b/src/Core/Debug.cc
index 011b646f8..350f1a565 100644
--- a/src/Core/Debug.cc
+++ b/src/Core/Debug.cc
@@ -192,7 +192,7 @@ void stackTrace(std::ostream& os, int cutoff) {
 
 #else
     os << "Creating stack trace (innermost first):" << std::endl;
-    static const size_t maxTraces = 100;
+    static const size_t maxTraces = 256;
     void*               array[maxTraces];
     size_t              nTraces = backtrace(array, maxTraces);
     char**              strings = backtrace_symbols(array, nTraces);
diff --git a/src/Core/Delegation.hh b/src/Core/Delegation.hh
index ef816b0b1..bd0c325a2 100644
--- a/src/Core/Delegation.hh
+++ b/src/Core/Delegation.hh
@@ -50,7 +50,8 @@ public:
         TargetMethod tm;
 
         Forward(TargetClass& tc, TargetMethod tm)
-                : tc(tc), tm(tm) {}
+                : tc(tc),
+                  tm(tm) {}
         inline void operator()(T t) {
             (tc.*tm)(t);
         }
diff --git a/src/Core/Dependency.cc b/src/Core/Dependency.cc
index 1858e4021..f64d2720e 100644
--- a/src/Core/Dependency.cc
+++ b/src/Core/Dependency.cc
@@ -64,7 +64,8 @@ class Parser : public XmlSchemaParser {
 
 public:
     Parser(const Configuration& c, DependencySet& dependencySet)
-            : XmlSchemaParser(c), dependencySet_(dependencySet) {
+            : XmlSchemaParser(c),
+              dependencySet_(dependencySet) {
         XmlRegularElement* dependency = new XmlRegularElementRelay("dependency", this,
                                                                    XmlRegularElementRelay::startHandler(&Self::startDependency),
                                                                    XmlRegularElementRelay::endHandler(&Self::endDependency));
diff --git a/src/Core/Directory.cc b/src/Core/Directory.cc
index 5c291ec70..b4e83eca5 100644
--- a/src/Core/Directory.cc
+++ b/src/Core/Directory.cc
@@ -249,7 +249,8 @@ struct dirent* DirectoryFileIterator::nextEntry() {
 }
 
 DirectoryFileIterator::DirectoryFileIterator(const std::string& path, const Filter* filter)
-        : end_(false), filter_(filter) {
+        : end_(false),
+          filter_(filter) {
     uid_  = getuid();
     gid_  = getgid();
     base_ = path;
diff --git a/src/Core/Directory.hh b/src/Core/Directory.hh
index 36d380815..332380cc1 100644
--- a/src/Core/Directory.hh
+++ b/src/Core/Directory.hh
@@ -156,7 +156,8 @@ public:
 
     public:
         FileNameFilter(const std::string& name, bool exactMatch = false)
-                : name_(name), exactMatch_(exactMatch) {}
+                : name_(name),
+                  exactMatch_(exactMatch) {}
 
         virtual bool operator()(const std::string& path, const struct stat64& state, uid_t uid, gid_t gid) const;
     };
diff --git a/src/Core/DirectoryArchive.hh b/src/Core/DirectoryArchive.hh
index 6b71ff117..721e06f65 100644
--- a/src/Core/DirectoryArchive.hh
+++ b/src/Core/DirectoryArchive.hh
@@ -33,7 +33,8 @@ private:
 
     public:
         _const_iterator(const DirectoryArchive& a)
-                : iter_(a.path(), &DirectoryFileIterator::fileFilter), a_(a) {
+                : iter_(a.path(), &DirectoryFileIterator::fileFilter),
+                  a_(a) {
             if (iter_)
                 if (a_.probe(iter_.path(), iter_.state(), sizes_))
                     name_ = iter_.path();
diff --git a/src/Core/Extensions.hh b/src/Core/Extensions.hh
index 80b995dd3..e5caa0d72 100644
--- a/src/Core/Extensions.hh
+++ b/src/Core/Extensions.hh
@@ -36,7 +36,7 @@ using __gnu_cxx::select2nd;
 #else
 
 template<typename T>
-struct identity : public std::unary_function<T, T> {
+struct identity {
     const T& operator()(const T& v) const {
         return v;
     }
@@ -46,8 +46,7 @@ struct identity : public std::unary_function<T, T> {
 };
 
 template<typename BinaryFun, typename UnaryFun1, typename UnaryFun2 = UnaryFun1>
-struct binary_compose
-        : public std::unary_function<typename UnaryFun1::argument_type, typename BinaryFun::result_type> {
+struct binary_compose {
     typename BinaryFun::result_type operator()(const typename UnaryFun1::argument_type& x) const {
         return f(g(x), h(x));
     }
@@ -58,16 +57,14 @@ struct binary_compose
 };
 
 template<typename pair_type>
-struct select1st
-        : public std::unary_function<const pair_type&, const typename pair_type::first_type&> {
+struct select1st {
     const typename pair_type::first_type& operator()(const pair_type& v) const {
         return v.first;
     }
 };
 
 template<typename pair_type>
-struct select2nd
-        : public std::unary_function<const pair_type&, const typename pair_type::second_type&> {
+struct select2nd {
     const typename pair_type::second_type& operator()(const pair_type& v) const {
         return v.second;
     }
diff --git a/src/Core/FileArchive.cc b/src/Core/FileArchive.cc
index 04277fcda..b5b68535a 100644
--- a/src/Core/FileArchive.cc
+++ b/src/Core/FileArchive.cc
@@ -94,7 +94,9 @@ struct FileArchive::FileInfo {
     Sizes       sizes;
 
     FileInfo(const std::string& n, u64 p, const Sizes& s)
-            : name(n), position(p), sizes(s) {}
+            : name(n),
+              position(p),
+              sizes(s) {}
 
     void clear() {
         name.clear();
@@ -105,7 +107,7 @@ struct FileArchive::FileInfo {
         return (name.empty() && position == 0);
     }
 
-    struct Empty : public std::unary_function<FileInfo, bool> {
+    struct Empty {
         bool operator()(const FileInfo& f) const {
             return f.isEmpty();
         }
@@ -120,7 +122,8 @@ class FileArchive::_const_iterator : public Archive::_const_iterator {
 
 public:
     _const_iterator(const FileArchive& a)
-            : iter_(a.files_.begin()), a_(a) {
+            : iter_(a.files_.begin()),
+              a_(a) {
         if (iter_ != a_.files_.end()) {
             name_  = iter_->name;
             sizes_ = iter_->sizes;
diff --git a/src/Core/Hash.hh b/src/Core/Hash.hh
index e84ffab62..63d6c7768 100644
--- a/src/Core/Hash.hh
+++ b/src/Core/Hash.hh
@@ -77,7 +77,7 @@ struct StringHash {
     }
 };
 
-struct StringEquality : std::binary_function<const char*, const char*, bool> {
+struct StringEquality {
     bool operator()(const char* s, const char* t) const {
         return (s == t) || (std::strcmp(s, t) == 0);
     }
diff --git a/src/Core/MapParser.hh b/src/Core/MapParser.hh
index 21ba5d26a..92d75f579 100644
--- a/src/Core/MapParser.hh
+++ b/src/Core/MapParser.hh
@@ -103,7 +103,8 @@ class XmlMapDocument : public XmlSchemaParser {
 private:
     XmlMapElement<Map>* mapElement_;
     Map&                map_;
-    Map*                pseudoCreateMap(const XmlAttributes atts) {
+
+    Map* pseudoCreateMap(const XmlAttributes atts) {
         return &map_;
     }
 
diff --git a/src/Core/MappedArchive.cc b/src/Core/MappedArchive.cc
index 9445b8448..c88413a6f 100644
--- a/src/Core/MappedArchive.cc
+++ b/src/Core/MappedArchive.cc
@@ -38,7 +38,9 @@
  * */
 
 std::string hostAndProcessId() {
-    enum { Len = 1000 };
+    enum {
+        Len = 1000
+    };
     char buf[Len];
     gethostname(buf, Len);
     u64                pid = getpid();
diff --git a/src/Core/MappedArchive.hh b/src/Core/MappedArchive.hh
index 3dd58843f..8f990b5ce 100644
--- a/src/Core/MappedArchive.hh
+++ b/src/Core/MappedArchive.hh
@@ -102,7 +102,8 @@ private:
 
     struct MappedItem {
         MappedItem()
-                : data(0), size(0) {
+                : data(0),
+                  size(0) {
         }
 
         std::string name;
@@ -153,10 +154,12 @@ template<class T>
 class ConstantVector {
 public:
     ConstantVector()
-            : data_(0), size_(0) {}
+            : data_(0),
+              size_(0) {}
 
     ConstantVector(const T* mapped, size_t size)
-            : data_(mapped), size_(size) {}
+            : data_(mapped),
+              size_(size) {}
 
     ConstantVector(const std::vector<T>& data)
             : editable_(data),
diff --git a/src/Core/MatrixParser.hh b/src/Core/MatrixParser.hh
index ff079c2cb..78ce21d6e 100644
--- a/src/Core/MatrixParser.hh
+++ b/src/Core/MatrixParser.hh
@@ -35,11 +35,8 @@ class XmlMatrixElement : public XmlBuilderElement<Math::Matrix<T>,
                                                   XmlElement,
                                                   CreateByContext> {
 public:
-    typedef XmlBuilderElement<Math::Matrix<T>,
-                              XmlElement,
-                              CreateByContext>
-                                Predecessor;
-    typedef XmlMatrixElement<T> Self;
+    typedef XmlBuilderElement<Math::Matrix<T>, XmlElement, CreateByContext> Predecessor;
+    typedef XmlMatrixElement<T>                                             Self;
     typedef Math::Matrix<T>* (XmlContext::*CreationHandler)(const XmlAttributes atts);
 
 private:
@@ -124,7 +121,8 @@ class XmlMatrixDocument : public XmlSchemaParser {
 private:
     XmlMatrixElement<T>* matrixElement_;
     Math::Matrix<T>&     matrix_;
-    Math::Matrix<T>*     pseudoCreateMatrix(const XmlAttributes atts) {
+
+    Math::Matrix<T>* pseudoCreateMatrix(const XmlAttributes atts) {
         return &matrix_;
     }
 
diff --git a/src/Core/MemoryInfo.cc b/src/Core/MemoryInfo.cc
index 3a4f5af54..8da0fc165 100644
--- a/src/Core/MemoryInfo.cc
+++ b/src/Core/MemoryInfo.cc
@@ -22,7 +22,13 @@
 using namespace Core;
 
 MemoryInfo::MemoryInfo()
-        : size_(0), rss_(0), share_(0), text_(0), lib_(0), data_(0), pageSize_(0) {
+        : size_(0),
+          rss_(0),
+          share_(0),
+          text_(0),
+          lib_(0),
+          data_(0),
+          pageSize_(0) {
     update();
 }
 
diff --git a/src/Core/ObjectCache.hh b/src/Core/ObjectCache.hh
index 7df0f390d..4c6f33ef2 100644
--- a/src/Core/ObjectCache.hh
+++ b/src/Core/ObjectCache.hh
@@ -46,7 +46,8 @@ private:
 
 public:
     ObjectCacheItem(Data* data)
-            : data_(data), dirty_(true) {
+            : data_(data),
+              dirty_(true) {
         ensure(data);
     }
     ~ObjectCacheItem() {
diff --git a/src/Core/Parameter.cc b/src/Core/Parameter.cc
index 9f5cdee6c..fb716d06a 100644
--- a/src/Core/Parameter.cc
+++ b/src/Core/Parameter.cc
@@ -42,7 +42,8 @@ AbstractParameter::AbstractParameter(const char* _ident,
                                      const char* _short_desc,
                                      const char* _long_desc,
                                      bool        needs_arg)
-        : ident(_ident), g_param_max_ident(0) {
+        : ident(_ident),
+          g_param_max_ident(0) {
     require(!ident.empty());
     require(ident.find(Configuration::resource_wildcard_char) == std::string::npos);
     require(ident.find(Configuration::resource_separation_char) == std::string::npos);
@@ -339,10 +340,11 @@ VectorParameter<T>::VectorParameter(const char*       ident,
           maxValue_(maxValue),
           minSize_(minSize),
           maxSize_(maxSize) {
-    if (delimiter_ == "")
+    if (delimiter_ == "") {
         delimiter_ = " ";
-    require(minValue_ <= maxValue_);
-    require(minSize_ <= maxSize_);
+    }
+    require_le(minValue_, maxValue_);
+    require_le(minSize_, maxSize_);
 }
 
 template<class T>
diff --git a/src/Core/PriorityQueue.hh b/src/Core/PriorityQueue.hh
index c66b8c40e..181fb1a58 100644
--- a/src/Core/PriorityQueue.hh
+++ b/src/Core/PriorityQueue.hh
@@ -42,7 +42,8 @@ public:
     PriorityQueueBase(u32 maxSize = Type<u32>::max)
             : maxSize_(maxSize) {}
     PriorityQueueBase(const PriorityFunction& precedes, u32 maxSize = Type<u32>::max)
-            : maxSize_(maxSize), precedes_(precedes) {}
+            : maxSize_(maxSize),
+              precedes_(precedes) {}
 
     /** Return reference to top-most item in the queue */
     const Item& top() const {
@@ -127,7 +128,8 @@ public:
 
 protected:
     std::vector<Item> heap_;
-    bool              invariant() const {
+
+    bool invariant() const {
         return true;
     }
 
diff --git a/src/Core/ProgressIndicator.cc b/src/Core/ProgressIndicator.cc
index c4e757cc0..9927bbb80 100644
--- a/src/Core/ProgressIndicator.cc
+++ b/src/Core/ProgressIndicator.cc
@@ -220,7 +220,13 @@ void ProgressIndicator::sigWinchHandler(int sig) {
 
 ProgressIndicator::ProgressIndicator(const std::string& task,
                                      const std::string& unit)
-        : align_(Left), task_(task), unit_(unit), done_(0), isVisible_(false), draw(0), write_return_val_(0) {}
+        : align_(Left),
+          task_(task),
+          unit_(unit),
+          done_(0),
+          isVisible_(false),
+          draw(0),
+          write_return_val_(0) {}
 
 ProgressIndicator::~ProgressIndicator() {
     if (activeInstance == this)
diff --git a/src/Core/ProgressIndicator.hh b/src/Core/ProgressIndicator.hh
index 10893a910..9017a80ef 100644
--- a/src/Core/ProgressIndicator.hh
+++ b/src/Core/ProgressIndicator.hh
@@ -64,8 +64,10 @@ namespace Core {
 
 class ProgressIndicator {
 public:
-    enum Alignment { Left,
-                     Right };
+    enum Alignment {
+        Left,
+        Right
+    };
 
 private:
     static const int defaultLength;
diff --git a/src/Core/ReferenceCounting.cc b/src/Core/ReferenceCounting.cc
index 1192e835c..f5adfef93 100644
--- a/src/Core/ReferenceCounting.cc
+++ b/src/Core/ReferenceCounting.cc
@@ -13,6 +13,9 @@
  *  limitations under the License.
  */
 #include "ReferenceCounting.hh"
+
+#include <mutex>
+
 #include "Hash.hh"
 #include "Utility.hh"
 
diff --git a/src/Core/ReferenceCounting.hh b/src/Core/ReferenceCounting.hh
index ac423b05b..ac7127f6a 100644
--- a/src/Core/ReferenceCounting.hh
+++ b/src/Core/ReferenceCounting.hh
@@ -67,9 +67,11 @@ protected:
 
 public:
     ReferenceCounted()
-            : referenceCount_(0), weak_refs_(nullptr) {}
+            : referenceCount_(0),
+              weak_refs_(nullptr) {}
     ReferenceCounted(const ReferenceCounted&)
-            : referenceCount_(0), weak_refs_(nullptr) {}
+            : referenceCount_(0),
+              weak_refs_(nullptr) {}
     ReferenceCounted& operator=(const ReferenceCounted&) {
         return *this;
     }
diff --git a/src/Core/ResourceUsageInfo.cc b/src/Core/ResourceUsageInfo.cc
index 81433b86d..0813fd4c1 100644
--- a/src/Core/ResourceUsageInfo.cc
+++ b/src/Core/ResourceUsageInfo.cc
@@ -20,7 +20,15 @@
 using namespace Core;
 
 ResourceUsageInfo::ResourceUsageInfo()
-        : maxrss_(0), minflt_(0), majflt_(0), inblock_(0), outblock_(0), nvcsw_(0), nicsw_(0), utime_(0), stime_(0) {
+        : maxrss_(0),
+          minflt_(0),
+          majflt_(0),
+          inblock_(0),
+          outblock_(0),
+          nvcsw_(0),
+          nicsw_(0),
+          utime_(0),
+          stime_(0) {
     update();
 }
 
diff --git a/src/Core/StringExpression.hh b/src/Core/StringExpression.hh
index 55ccd16ae..4ff26074f 100644
--- a/src/Core/StringExpression.hh
+++ b/src/Core/StringExpression.hh
@@ -44,7 +44,8 @@ private:
         Token()
                 : set_(false) {}
         Token(const std::string& value)
-                : set_(true), value_(value) {}
+                : set_(true),
+                  value_(value) {}
 
         void operator=(const std::string& v) {
             set_   = true;
@@ -134,7 +135,9 @@ public:
     StringExpressionParser(StringExpression&  toBuild,
                            const std::string& openTag  = "$(",
                            const std::string& closeTag = ")")
-            : toBuild_(toBuild), openTag_(openTag), closeTag_(closeTag) {}
+            : toBuild_(toBuild),
+              openTag_(openTag),
+              closeTag_(closeTag) {}
 
     bool accept(const std::string& stringExpression);
 };
diff --git a/src/Core/TextStream.cc b/src/Core/TextStream.cc
index c3d32ca57..404dc19f8 100644
--- a/src/Core/TextStream.cc
+++ b/src/Core/TextStream.cc
@@ -42,9 +42,11 @@ class TextOutputStream::Buffer : public std::streambuf {
     void                         chooseFastPath();
     std::string                  pre_;  /**< unformatted */
     std::string                  pend_; /**< formatted */
-    enum { startOfLine,
-           leftMarginOfLine,
-           withinLine } lineState_;
+    enum {
+        startOfLine,
+        leftMarginOfLine,
+        withinLine
+    } lineState_;
     u32  protection_; /**< number of times "protect" has been seen */
     u32  position_, length_;
     void startNewLine();
@@ -301,13 +303,15 @@ std::streamsize TextOutputStream::Buffer::xsputn(const char* s, std::streamsize
 
 // ===========================================================================
 TextOutputStream::TextOutputStream()
-        : std::ostream(new Buffer(this)), output_(0) {
+        : std::ostream(new Buffer(this)),
+          output_(0) {
     buffer_ = dynamic_cast<Buffer*>(rdbuf());
     setEncoding();
 }
 
 TextOutputStream::TextOutputStream(std::ostream* s)
-        : std::ostream(new Buffer(this)), output_(s) {
+        : std::ostream(new Buffer(this)),
+          output_(s) {
     buffer_ = dynamic_cast<Buffer*>(rdbuf());
     buffer_->setOutput(output_->rdbuf());
     setEncoding();
@@ -475,13 +479,15 @@ int TextInputStream::Buffer::underflow() {
 
 // ===========================================================================
 TextInputStream::TextInputStream()
-        : std::istream(new Buffer(this)), input_(0) {
+        : std::istream(new Buffer(this)),
+          input_(0) {
     buffer_ = dynamic_cast<Buffer*>(rdbuf());
     setEncoding();
 }
 
 TextInputStream::TextInputStream(std::istream* s)
-        : std::istream(new Buffer(this)), input_(s) {
+        : std::istream(new Buffer(this)),
+          input_(s) {
     buffer_ = dynamic_cast<Buffer*>(rdbuf());
     buffer_->setInput(input_->rdbuf());
     setEncoding();
diff --git a/src/Core/Thread.hh b/src/Core/Thread.hh
index 0d5146458..434727122 100644
--- a/src/Core/Thread.hh
+++ b/src/Core/Thread.hh
@@ -194,7 +194,8 @@ template<class T>
 class LockingPointer {
 public:
     LockingPointer(volatile T& obj, const volatile Mutex& mutex)
-            : obj_(const_cast<T*>(&obj)), mutex_(const_cast<Mutex*>(&mutex)) {
+            : obj_(const_cast<T*>(&obj)),
+              mutex_(const_cast<Mutex*>(&mutex)) {
         mutex_->lock();
     }
     ~LockingPointer() {
diff --git a/src/Core/ThreadPool.hh b/src/Core/ThreadPool.hh
index e29d60d8d..73a32f6f9 100644
--- a/src/Core/ThreadPool.hh
+++ b/src/Core/ThreadPool.hh
@@ -60,7 +60,8 @@ public:
     typedef typename Pool::Mapper Mapper;
 
     ThreadPoolThread(Pool* pool, Mapper* mapper)
-            : pool_(pool), mapper_(mapper) {}
+            : pool_(pool),
+              mapper_(mapper) {}
     virtual ~ThreadPoolThread() {}
 
     void run() {
@@ -92,7 +93,9 @@ public:
     typedef ThreadPoolThread<Self>  WorkerThread;
 
     ThreadPoolImpl()
-            : active_threads_(0), running_threads_(0), terminate_(false) {}
+            : active_threads_(0),
+              running_threads_(0),
+              terminate_(false) {}
     ~ThreadPoolImpl() {
         for (typename std::vector<WorkerThread*>::iterator t = threads_.begin(); t != threads_.end(); ++t) {
             delete (*t)->getMapper();
diff --git a/src/Core/ThreadSafeReference.hh b/src/Core/ThreadSafeReference.hh
index a1e52c68f..192d963ad 100644
--- a/src/Core/ThreadSafeReference.hh
+++ b/src/Core/ThreadSafeReference.hh
@@ -38,10 +38,6 @@ private:
     mutable Core::Mutex mutex_;
 
 private:
-    static inline ThreadSafeReferenceCounted* sentinel() {
-        static ThreadSafeReferenceCounted sentinel_(1);
-        return &sentinel_;
-    }
     static bool isSentinel(const ThreadSafeReferenceCounted* object) {
         return object == sentinel();
     }
@@ -50,6 +46,10 @@ private:
     }
 
 protected:
+    static inline ThreadSafeReferenceCounted* sentinel() {
+        static ThreadSafeReferenceCounted sentinel_(1);
+        return &sentinel_;
+    }
     virtual void free() const {
         verify_(isNotSentinel(this));
         delete this;
@@ -118,7 +118,7 @@ protected:
             verify_(Object::isNotSentinel(object_));
             object_->release();
             object_->free();
-            (object_ = sentinel())->increment();
+            object_ = sentinel();
         }
         else
             object_->release();
diff --git a/src/Core/Tokenizer.cc b/src/Core/Tokenizer.cc
index 1e73e7dda..1b69759e3 100644
--- a/src/Core/Tokenizer.cc
+++ b/src/Core/Tokenizer.cc
@@ -20,15 +20,20 @@ using namespace Core;
 const std::string StringTokenizer::whiteSpace_ = " \t\n\r\f\v";
 
 StringTokenizer::Iterator::Iterator()
-        : parent_(), begin_(0), end_(0) {}
+        : parent_(),
+          begin_(0),
+          end_(0) {}
 
 StringTokenizer::Iterator::Iterator(const StringTokenizer* parent)
-        : parent_(parent), begin_(0) {
+        : parent_(parent),
+          begin_(0) {
     end_ = findNext(begin_);
 }
 
 StringTokenizer::Iterator::Iterator(const StringTokenizer* parent, size_type begin, size_type end)
-        : parent_(parent), begin_(begin), end_(end) {}
+        : parent_(parent),
+          begin_(begin),
+          end_(end) {}
 
 inline StringTokenizer::Iterator::size_type StringTokenizer::Iterator::findStart(size_type begin) const {
     return parent_->str_.find_first_not_of(parent_->delim_, begin);
@@ -65,10 +70,16 @@ std::string StringTokenizer::Iterator::operator*() const {
 }
 
 StringTokenizer::StringTokenizer(const std::string& text, const std::string& delimiter, bool trim)
-        : str_(text), delim_(delimiter), trim_(trim), endIterator_(this, std::string::npos, std::string::npos) {}
+        : str_(text),
+          delim_(delimiter),
+          trim_(trim),
+          endIterator_(this, std::string::npos, std::string::npos) {}
 
 StringTokenizer::StringTokenizer(const std::string& text)
-        : str_(text), delim_(whiteSpace_), trim_(true), endIterator_(this, std::string::npos, std::string::npos) {}
+        : str_(text),
+          delim_(whiteSpace_),
+          trim_(true),
+          endIterator_(this, std::string::npos, std::string::npos) {}
 
 StringTokenizer::Iterator StringTokenizer::begin() const {
     return Iterator(this);
diff --git a/src/Core/Unicode.hh b/src/Core/Unicode.hh
index bd9c79fb9..63f4f1c12 100644
--- a/src/Core/Unicode.hh
+++ b/src/Core/Unicode.hh
@@ -84,10 +84,12 @@ const char whitespace[] = " \t\n\r\f\v";
  * bytes.  The two byte values 0xfe and 0xff are illegal, they can
  * never occur in a UTF-8 string.
  */
-enum ByteType { singleByte,
-                multiByteHead,
-                multiByteTail,
-                illegal };
+enum ByteType {
+    singleByte,
+    multiByteHead,
+    multiByteTail,
+    illegal
+};
 inline ByteType byteType(char u) {
     if ((u & 0x80) == 0x00)
         return singleByte;
diff --git a/src/Core/Utility.hh b/src/Core/Utility.hh
index 68074f040..dc5296fc1 100644
--- a/src/Core/Utility.hh
+++ b/src/Core/Utility.hh
@@ -72,7 +72,7 @@ namespace Core {
 
 /** Generic unary functor for type conversion. */
 template<typename S, typename T>
-struct conversion : public std::unary_function<S, T> {
+struct conversion {
     T operator()(S s) const {
         return T(s);
     }
@@ -87,7 +87,8 @@ template<class A, class B>
 class tied {
 public:
     inline tied(A& a, B& b)
-            : a_(a), b_(b) {}
+            : a_(a),
+              b_(b) {}
     template<class U, class V>
     inline tied& operator=(const std::pair<U, V>& p) {
         a_ = p.first;
@@ -132,7 +133,7 @@ T abs(const std::complex<T>& v) {
 
 /** absoluteValue: functor for absolute value */
 template<class T>
-struct absoluteValue : public std::unary_function<T, T> {
+struct absoluteValue {
     T operator()(T v) const {
         return Core::abs(v);
     }
@@ -171,7 +172,7 @@ T maxAbsoluteElement(const std::vector<std::complex<T>>& v) {
 
 /** power: functor for pow function */
 template<class T>
-struct power : public std::binary_function<T, T, T> {
+struct power {
     T operator()(T x, T y) const {
         return pow(x, y);
     }
@@ -179,7 +180,7 @@ struct power : public std::binary_function<T, T, T> {
 
 /** min: functor for min function */
 template<class T>
-struct minimum : public std::binary_function<T, T, T> {
+struct minimum {
     T operator()(T x, T y) const {
         return std::min(x, y);
     }
@@ -187,7 +188,7 @@ struct minimum : public std::binary_function<T, T, T> {
 
 /** max: functor for max function */
 template<class T>
-struct maximum : public std::binary_function<T, T, T> {
+struct maximum {
     T operator()(T x, T y) const {
         return std::max(x, y);
     }
@@ -274,10 +275,7 @@ bool isMalformed(InputIterator begin, InputIterator end) {
 
 /** Functor for f(g(x), h(y)) */
 template<class F, class G, class H>
-class composedBinaryFunction
-        : public std::binary_function<typename G::argument_type,
-                                      typename H::argument_type,
-                                      typename F::result_type> {
+class composedBinaryFunction {
 protected:
     F f_;
     G g_;
@@ -285,8 +283,11 @@ protected:
 
 public:
     composedBinaryFunction(const F& f, const G& g, const H& h)
-            : f_(f), g_(g), h_(h) {}
-    typename F::result_type operator()(const typename G::argument_type& x, const typename H::argument_type& y) const {
+            : f_(f),
+              g_(g),
+              h_(h) {}
+    template<typename X, typename Y>
+    auto operator()(const X& x, const Y& y) const -> decltype(f_(g_(x), h_(y))) {
         return f_(g_(x), h_(y));
     }
 };
diff --git a/src/Core/XTermUtilities.hh b/src/Core/XTermUtilities.hh
index 695a27c01..69afe38c7 100644
--- a/src/Core/XTermUtilities.hh
+++ b/src/Core/XTermUtilities.hh
@@ -68,7 +68,8 @@ struct Command {
 struct move : public Command {
     u16 row, col;
     move(u16 row = 0, u16 col = 0)
-            : row(row), col(col) {}
+            : row(row),
+              col(col) {}
     inline void write(std::ostream& out) const {
         out << "\033[" << row << ";" << col << "H";
     }
diff --git a/src/Core/XmlBuilder.hh b/src/Core/XmlBuilder.hh
index 81604a102..ec7abd731 100644
--- a/src/Core/XmlBuilder.hh
+++ b/src/Core/XmlBuilder.hh
@@ -55,7 +55,8 @@ public:
     }
 
     XmlBuilderElementTemplate(const char* _name, XmlContext* _context, Handler _handler = 0)
-            : Precursor(_name, _context), handler_(_handler) {}
+            : Precursor(_name, _context),
+              handler_(_handler) {}
 };
 
 struct CreateStatic {};
diff --git a/src/Core/check.cc b/src/Core/check.cc
index ac916f505..a139b181f 100644
--- a/src/Core/check.cc
+++ b/src/Core/check.cc
@@ -38,9 +38,11 @@ using namespace Core;
 
 class Tester : public Component {
 public:
-    enum Flavour { vanilla,
-                   strawberry,
-                   chocolate };
+    enum Flavour {
+        vanilla,
+        strawberry,
+        chocolate
+    };
     static const Choice flavourChoice;
 
     static const ParameterBool   paramBoolean;
diff --git a/src/Core/robin_hood.h b/src/Core/robin_hood.h
new file mode 100644
index 000000000..0af031f5f
--- /dev/null
+++ b/src/Core/robin_hood.h
@@ -0,0 +1,2544 @@
+//                 ______  _____                 ______                _________
+//  ______________ ___  /_ ___(_)_______         ___  /_ ______ ______ ______  /
+//  __  ___/_  __ \__  __ \__  / __  __ \        __  __ \_  __ \_  __ \_  __  /
+//  _  /    / /_/ /_  /_/ /_  /  _  / / /        _  / / // /_/ // /_/ // /_/ /
+//  /_/     \____/ /_.___/ /_/   /_/ /_/ ________/_/ /_/ \____/ \____/ \__,_/
+//                                      _/_____/
+//
+// Fast & memory efficient hashtable based on robin hood hashing for C++11/14/17/20
+// https://github.com/martinus/robin-hood-hashing
+//
+// Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2018-2021 Martin Ankerl <http://martin.ankerl.com>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#ifndef ROBIN_HOOD_H_INCLUDED
+#define ROBIN_HOOD_H_INCLUDED
+
+// see https://semver.org/
+#define ROBIN_HOOD_VERSION_MAJOR 3  // for incompatible API changes
+#define ROBIN_HOOD_VERSION_MINOR 11 // for adding functionality in a backwards-compatible manner
+#define ROBIN_HOOD_VERSION_PATCH 5  // for backwards-compatible bug fixes
+
+#include <algorithm>
+#include <cstdlib>
+#include <cstring>
+#include <functional>
+#include <limits>
+#include <memory> // only to support hash of smart pointers
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <utility>
+#if __cplusplus >= 201703L
+#    include <string_view>
+#endif
+
+// #define ROBIN_HOOD_LOG_ENABLED
+#ifdef ROBIN_HOOD_LOG_ENABLED
+#    include <iostream>
+#    define ROBIN_HOOD_LOG(...) \
+        std::cout << __FUNCTION__ << "@" << __LINE__ << ": " << __VA_ARGS__ << std::endl;
+#else
+#    define ROBIN_HOOD_LOG(x)
+#endif
+
+// #define ROBIN_HOOD_TRACE_ENABLED
+#ifdef ROBIN_HOOD_TRACE_ENABLED
+#    include <iostream>
+#    define ROBIN_HOOD_TRACE(...) \
+        std::cout << __FUNCTION__ << "@" << __LINE__ << ": " << __VA_ARGS__ << std::endl;
+#else
+#    define ROBIN_HOOD_TRACE(x)
+#endif
+
+// #define ROBIN_HOOD_COUNT_ENABLED
+#ifdef ROBIN_HOOD_COUNT_ENABLED
+#    include <iostream>
+#    define ROBIN_HOOD_COUNT(x) ++counts().x;
+namespace robin_hood {
+struct Counts {
+    uint64_t shiftUp{};
+    uint64_t shiftDown{};
+};
+inline std::ostream& operator<<(std::ostream& os, Counts const& c) {
+    return os << c.shiftUp << " shiftUp" << std::endl << c.shiftDown << " shiftDown" << std::endl;
+}
+
+static Counts& counts() {
+    static Counts counts{};
+    return counts;
+}
+} // namespace robin_hood
+#else
+#    define ROBIN_HOOD_COUNT(x)
+#endif
+
+// all non-argument macros should use this facility. See
+// https://www.fluentcpp.com/2019/05/28/better-macros-better-flags/
+#define ROBIN_HOOD(x) ROBIN_HOOD_PRIVATE_DEFINITION_##x()
+
+// mark unused members with this macro
+#define ROBIN_HOOD_UNUSED(identifier)
+
+// bitness
+#if SIZE_MAX == UINT32_MAX
+#    define ROBIN_HOOD_PRIVATE_DEFINITION_BITNESS() 32
+#elif SIZE_MAX == UINT64_MAX
+#    define ROBIN_HOOD_PRIVATE_DEFINITION_BITNESS() 64
+#else
+#    error Unsupported bitness
+#endif
+
+// endianess
+#ifdef _MSC_VER
+#    define ROBIN_HOOD_PRIVATE_DEFINITION_LITTLE_ENDIAN() 1
+#    define ROBIN_HOOD_PRIVATE_DEFINITION_BIG_ENDIAN() 0
+#else
+#    define ROBIN_HOOD_PRIVATE_DEFINITION_LITTLE_ENDIAN() \
+        (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+#    define ROBIN_HOOD_PRIVATE_DEFINITION_BIG_ENDIAN() (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+#endif
+
+// inline
+#ifdef _MSC_VER
+#    define ROBIN_HOOD_PRIVATE_DEFINITION_NOINLINE() __declspec(noinline)
+#else
+#    define ROBIN_HOOD_PRIVATE_DEFINITION_NOINLINE() __attribute__((noinline))
+#endif
+
+// exceptions
+#if !defined(__cpp_exceptions) && !defined(__EXCEPTIONS) && !defined(_CPPUNWIND)
+#    define ROBIN_HOOD_PRIVATE_DEFINITION_HAS_EXCEPTIONS() 0
+#else
+#    define ROBIN_HOOD_PRIVATE_DEFINITION_HAS_EXCEPTIONS() 1
+#endif
+
+// count leading/trailing bits
+#if !defined(ROBIN_HOOD_DISABLE_INTRINSICS)
+#    ifdef _MSC_VER
+#        if ROBIN_HOOD(BITNESS) == 32
+#            define ROBIN_HOOD_PRIVATE_DEFINITION_BITSCANFORWARD() _BitScanForward
+#        else
+#            define ROBIN_HOOD_PRIVATE_DEFINITION_BITSCANFORWARD() _BitScanForward64
+#        endif
+#        include <intrin.h>
+#        pragma intrinsic(ROBIN_HOOD(BITSCANFORWARD))
+#        define ROBIN_HOOD_COUNT_TRAILING_ZEROES(x)                                       \
+            [](size_t mask) noexcept -> int {                                             \
+                unsigned long index;                                                      \
+                return ROBIN_HOOD(BITSCANFORWARD)(&index, mask) ? static_cast<int>(index) \
+                                                                : ROBIN_HOOD(BITNESS);    \
+            }(x)
+#    else
+#        if ROBIN_HOOD(BITNESS) == 32
+#            define ROBIN_HOOD_PRIVATE_DEFINITION_CTZ() __builtin_ctzl
+#            define ROBIN_HOOD_PRIVATE_DEFINITION_CLZ() __builtin_clzl
+#        else
+#            define ROBIN_HOOD_PRIVATE_DEFINITION_CTZ() __builtin_ctzll
+#            define ROBIN_HOOD_PRIVATE_DEFINITION_CLZ() __builtin_clzll
+#        endif
+#        define ROBIN_HOOD_COUNT_LEADING_ZEROES(x) ((x) ? ROBIN_HOOD(CLZ)(x) : ROBIN_HOOD(BITNESS))
+#        define ROBIN_HOOD_COUNT_TRAILING_ZEROES(x) ((x) ? ROBIN_HOOD(CTZ)(x) : ROBIN_HOOD(BITNESS))
+#    endif
+#endif
+
+// fallthrough
+#ifndef __has_cpp_attribute // For backwards compatibility
+#    define __has_cpp_attribute(x) 0
+#endif
+#if __has_cpp_attribute(clang::fallthrough)
+#    define ROBIN_HOOD_PRIVATE_DEFINITION_FALLTHROUGH() [[clang::fallthrough]]
+#elif __has_cpp_attribute(gnu::fallthrough)
+#    define ROBIN_HOOD_PRIVATE_DEFINITION_FALLTHROUGH() [[gnu::fallthrough]]
+#else
+#    define ROBIN_HOOD_PRIVATE_DEFINITION_FALLTHROUGH()
+#endif
+
+// likely/unlikely
+#ifdef _MSC_VER
+#    define ROBIN_HOOD_LIKELY(condition) condition
+#    define ROBIN_HOOD_UNLIKELY(condition) condition
+#else
+#    define ROBIN_HOOD_LIKELY(condition) __builtin_expect(condition, 1)
+#    define ROBIN_HOOD_UNLIKELY(condition) __builtin_expect(condition, 0)
+#endif
+
+// detect if native wchar_t type is availiable in MSVC
+#ifdef _MSC_VER
+#    ifdef _NATIVE_WCHAR_T_DEFINED
+#        define ROBIN_HOOD_PRIVATE_DEFINITION_HAS_NATIVE_WCHART() 1
+#    else
+#        define ROBIN_HOOD_PRIVATE_DEFINITION_HAS_NATIVE_WCHART() 0
+#    endif
+#else
+#    define ROBIN_HOOD_PRIVATE_DEFINITION_HAS_NATIVE_WCHART() 1
+#endif
+
+// detect if MSVC supports the pair(std::piecewise_construct_t,...) consructor being constexpr
+#ifdef _MSC_VER
+#    if _MSC_VER <= 1900
+#        define ROBIN_HOOD_PRIVATE_DEFINITION_BROKEN_CONSTEXPR() 1
+#    else
+#        define ROBIN_HOOD_PRIVATE_DEFINITION_BROKEN_CONSTEXPR() 0
+#    endif
+#else
+#    define ROBIN_HOOD_PRIVATE_DEFINITION_BROKEN_CONSTEXPR() 0
+#endif
+
+// workaround missing "is_trivially_copyable" in g++ < 5.0
+// See https://stackoverflow.com/a/31798726/48181
+#if defined(__GNUC__) && __GNUC__ < 5
+#    define ROBIN_HOOD_IS_TRIVIALLY_COPYABLE(...) __has_trivial_copy(__VA_ARGS__)
+#else
+#    define ROBIN_HOOD_IS_TRIVIALLY_COPYABLE(...) std::is_trivially_copyable<__VA_ARGS__>::value
+#endif
+
+// helpers for C++ versions, see https://gcc.gnu.org/onlinedocs/cpp/Standard-Predefined-Macros.html
+#define ROBIN_HOOD_PRIVATE_DEFINITION_CXX() __cplusplus
+#define ROBIN_HOOD_PRIVATE_DEFINITION_CXX98() 199711L
+#define ROBIN_HOOD_PRIVATE_DEFINITION_CXX11() 201103L
+#define ROBIN_HOOD_PRIVATE_DEFINITION_CXX14() 201402L
+#define ROBIN_HOOD_PRIVATE_DEFINITION_CXX17() 201703L
+
+#if ROBIN_HOOD(CXX) >= ROBIN_HOOD(CXX17)
+#    define ROBIN_HOOD_PRIVATE_DEFINITION_NODISCARD() [[nodiscard]]
+#else
+#    define ROBIN_HOOD_PRIVATE_DEFINITION_NODISCARD()
+#endif
+
+namespace robin_hood {
+
+#if ROBIN_HOOD(CXX) >= ROBIN_HOOD(CXX14)
+#    define ROBIN_HOOD_STD std
+#else
+
+// c++11 compatibility layer
+namespace ROBIN_HOOD_STD {
+template <class T>
+struct alignment_of
+    : std::integral_constant<std::size_t, alignof(typename std::remove_all_extents<T>::type)> {};
+
+template <class T, T... Ints>
+class integer_sequence {
+public:
+    using value_type = T;
+    static_assert(std::is_integral<value_type>::value, "not integral type");
+    static constexpr std::size_t size() noexcept {
+        return sizeof...(Ints);
+    }
+};
+template <std::size_t... Inds>
+using index_sequence = integer_sequence<std::size_t, Inds...>;
+
+namespace detail_ {
+template <class T, T Begin, T End, bool>
+struct IntSeqImpl {
+    using TValue = T;
+    static_assert(std::is_integral<TValue>::value, "not integral type");
+    static_assert(Begin >= 0 && Begin < End, "unexpected argument (Begin<0 || Begin<=End)");
+
+    template <class, class>
+    struct IntSeqCombiner;
+
+    template <TValue... Inds0, TValue... Inds1>
+    struct IntSeqCombiner<integer_sequence<TValue, Inds0...>, integer_sequence<TValue, Inds1...>> {
+        using TResult = integer_sequence<TValue, Inds0..., Inds1...>;
+    };
+
+    using TResult =
+        typename IntSeqCombiner<typename IntSeqImpl<TValue, Begin, Begin + (End - Begin) / 2,
+                                                    (End - Begin) / 2 == 1>::TResult,
+                                typename IntSeqImpl<TValue, Begin + (End - Begin) / 2, End,
+                                                    (End - Begin + 1) / 2 == 1>::TResult>::TResult;
+};
+
+template <class T, T Begin>
+struct IntSeqImpl<T, Begin, Begin, false> {
+    using TValue = T;
+    static_assert(std::is_integral<TValue>::value, "not integral type");
+    static_assert(Begin >= 0, "unexpected argument (Begin<0)");
+    using TResult = integer_sequence<TValue>;
+};
+
+template <class T, T Begin, T End>
+struct IntSeqImpl<T, Begin, End, true> {
+    using TValue = T;
+    static_assert(std::is_integral<TValue>::value, "not integral type");
+    static_assert(Begin >= 0, "unexpected argument (Begin<0)");
+    using TResult = integer_sequence<TValue, Begin>;
+};
+} // namespace detail_
+
+template <class T, T N>
+using make_integer_sequence = typename detail_::IntSeqImpl<T, 0, N, (N - 0) == 1>::TResult;
+
+template <std::size_t N>
+using make_index_sequence = make_integer_sequence<std::size_t, N>;
+
+template <class... T>
+using index_sequence_for = make_index_sequence<sizeof...(T)>;
+
+} // namespace ROBIN_HOOD_STD
+
+#endif
+
+namespace detail {
+
+// make sure we static_cast to the correct type for hash_int
+#if ROBIN_HOOD(BITNESS) == 64
+using SizeT = uint64_t;
+#else
+using SizeT = uint32_t;
+#endif
+
+template <typename T>
+T rotr(T x, unsigned k) {
+    return (x >> k) | (x << (8U * sizeof(T) - k));
+}
+
+// This cast gets rid of warnings like "cast from 'uint8_t*' {aka 'unsigned char*'} to
+// 'uint64_t*' {aka 'long unsigned int*'} increases required alignment of target type". Use with
+// care!
+template <typename T>
+inline T reinterpret_cast_no_cast_align_warning(void* ptr) noexcept {
+    return reinterpret_cast<T>(ptr);
+}
+
+template <typename T>
+inline T reinterpret_cast_no_cast_align_warning(void const* ptr) noexcept {
+    return reinterpret_cast<T>(ptr);
+}
+
+// make sure this is not inlined as it is slow and dramatically enlarges code, thus making other
+// inlinings more difficult. Throws are also generally the slow path.
+template <typename E, typename... Args>
+[[noreturn]] ROBIN_HOOD(NOINLINE)
+#if ROBIN_HOOD(HAS_EXCEPTIONS)
+    void doThrow(Args&&... args) {
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-array-to-pointer-decay)
+    throw E(std::forward<Args>(args)...);
+}
+#else
+    void doThrow(Args&&... ROBIN_HOOD_UNUSED(args) /*unused*/) {
+    abort();
+}
+#endif
+
+template <typename E, typename T, typename... Args>
+T* assertNotNull(T* t, Args&&... args) {
+    if (ROBIN_HOOD_UNLIKELY(nullptr == t)) {
+        doThrow<E>(std::forward<Args>(args)...);
+    }
+    return t;
+}
+
+template <typename T>
+inline T unaligned_load(void const* ptr) noexcept {
+    // using memcpy so we don't get into unaligned load problems.
+    // compiler should optimize this very well anyways.
+    T t;
+    std::memcpy(&t, ptr, sizeof(T));
+    return t;
+}
+
+// Allocates bulks of memory for objects of type T. This deallocates the memory in the destructor,
+// and keeps a linked list of the allocated memory around. Overhead per allocation is the size of a
+// pointer.
+template <typename T, size_t MinNumAllocs = 4, size_t MaxNumAllocs = 256>
+class BulkPoolAllocator {
+public:
+    BulkPoolAllocator() noexcept = default;
+
+    // does not copy anything, just creates a new allocator.
+    BulkPoolAllocator(const BulkPoolAllocator& ROBIN_HOOD_UNUSED(o) /*unused*/) noexcept
+        : mHead(nullptr)
+        , mListForFree(nullptr) {}
+
+    BulkPoolAllocator(BulkPoolAllocator&& o) noexcept
+        : mHead(o.mHead)
+        , mListForFree(o.mListForFree) {
+        o.mListForFree = nullptr;
+        o.mHead = nullptr;
+    }
+
+    BulkPoolAllocator& operator=(BulkPoolAllocator&& o) noexcept {
+        reset();
+        mHead = o.mHead;
+        mListForFree = o.mListForFree;
+        o.mListForFree = nullptr;
+        o.mHead = nullptr;
+        return *this;
+    }
+
+    BulkPoolAllocator&
+    // NOLINTNEXTLINE(bugprone-unhandled-self-assignment,cert-oop54-cpp)
+    operator=(const BulkPoolAllocator& ROBIN_HOOD_UNUSED(o) /*unused*/) noexcept {
+        // does not do anything
+        return *this;
+    }
+
+    ~BulkPoolAllocator() noexcept {
+        reset();
+    }
+
+    // Deallocates all allocated memory.
+    void reset() noexcept {
+        while (mListForFree) {
+            T* tmp = *mListForFree;
+            ROBIN_HOOD_LOG("std::free")
+            std::free(mListForFree);
+            mListForFree = reinterpret_cast_no_cast_align_warning<T**>(tmp);
+        }
+        mHead = nullptr;
+    }
+
+    // allocates, but does NOT initialize. Use in-place new constructor, e.g.
+    //   T* obj = pool.allocate();
+    //   ::new (static_cast<void*>(obj)) T();
+    T* allocate() {
+        T* tmp = mHead;
+        if (!tmp) {
+            tmp = performAllocation();
+        }
+
+        mHead = *reinterpret_cast_no_cast_align_warning<T**>(tmp);
+        return tmp;
+    }
+
+    // does not actually deallocate but puts it in store.
+    // make sure you have already called the destructor! e.g. with
+    //  obj->~T();
+    //  pool.deallocate(obj);
+    void deallocate(T* obj) noexcept {
+        *reinterpret_cast_no_cast_align_warning<T**>(obj) = mHead;
+        mHead = obj;
+    }
+
+    // Adds an already allocated block of memory to the allocator. This allocator is from now on
+    // responsible for freeing the data (with free()). If the provided data is not large enough to
+    // make use of, it is immediately freed. Otherwise it is reused and freed in the destructor.
+    void addOrFree(void* ptr, const size_t numBytes) noexcept {
+        // calculate number of available elements in ptr
+        if (numBytes < ALIGNMENT + ALIGNED_SIZE) {
+            // not enough data for at least one element. Free and return.
+            ROBIN_HOOD_LOG("std::free")
+            std::free(ptr);
+        } else {
+            ROBIN_HOOD_LOG("add to buffer")
+            add(ptr, numBytes);
+        }
+    }
+
+    void swap(BulkPoolAllocator<T, MinNumAllocs, MaxNumAllocs>& other) noexcept {
+        using std::swap;
+        swap(mHead, other.mHead);
+        swap(mListForFree, other.mListForFree);
+    }
+
+private:
+    // iterates the list of allocated memory to calculate how many to alloc next.
+    // Recalculating this each time saves us a size_t member.
+    // This ignores the fact that memory blocks might have been added manually with addOrFree. In
+    // practice, this should not matter much.
+    ROBIN_HOOD(NODISCARD) size_t calcNumElementsToAlloc() const noexcept {
+        auto tmp = mListForFree;
+        size_t numAllocs = MinNumAllocs;
+
+        while (numAllocs * 2 <= MaxNumAllocs && tmp) {
+            auto x = reinterpret_cast<T***>(tmp);
+            tmp = *x;
+            numAllocs *= 2;
+        }
+
+        return numAllocs;
+    }
+
+    // WARNING: Underflow if numBytes < ALIGNMENT! This is guarded in addOrFree().
+    void add(void* ptr, const size_t numBytes) noexcept {
+        const size_t numElements = (numBytes - ALIGNMENT) / ALIGNED_SIZE;
+
+        auto data = reinterpret_cast<T**>(ptr);
+
+        // link free list
+        auto x = reinterpret_cast<T***>(data);
+        *x = mListForFree;
+        mListForFree = data;
+
+        // create linked list for newly allocated data
+        auto* const headT =
+            reinterpret_cast_no_cast_align_warning<T*>(reinterpret_cast<char*>(ptr) + ALIGNMENT);
+
+        auto* const head = reinterpret_cast<char*>(headT);
+
+        // Visual Studio compiler automatically unrolls this loop, which is pretty cool
+        for (size_t i = 0; i < numElements; ++i) {
+            *reinterpret_cast_no_cast_align_warning<char**>(head + i * ALIGNED_SIZE) =
+                head + (i + 1) * ALIGNED_SIZE;
+        }
+
+        // last one points to 0
+        *reinterpret_cast_no_cast_align_warning<T**>(head + (numElements - 1) * ALIGNED_SIZE) =
+            mHead;
+        mHead = headT;
+    }
+
+    // Called when no memory is available (mHead == 0).
+    // Don't inline this slow path.
+    ROBIN_HOOD(NOINLINE) T* performAllocation() {
+        size_t const numElementsToAlloc = calcNumElementsToAlloc();
+
+        // alloc new memory: [prev |T, T, ... T]
+        size_t const bytes = ALIGNMENT + ALIGNED_SIZE * numElementsToAlloc;
+        ROBIN_HOOD_LOG("std::malloc " << bytes << " = " << ALIGNMENT << " + " << ALIGNED_SIZE
+                                      << " * " << numElementsToAlloc)
+        add(assertNotNull<std::bad_alloc>(std::malloc(bytes)), bytes);
+        return mHead;
+    }
+
+    // enforce byte alignment of the T's
+#if ROBIN_HOOD(CXX) >= ROBIN_HOOD(CXX14)
+    static constexpr size_t ALIGNMENT =
+        (std::max)(std::alignment_of<T>::value, std::alignment_of<T*>::value);
+#else
+    static const size_t ALIGNMENT =
+        (ROBIN_HOOD_STD::alignment_of<T>::value > ROBIN_HOOD_STD::alignment_of<T*>::value)
+            ? ROBIN_HOOD_STD::alignment_of<T>::value
+            : +ROBIN_HOOD_STD::alignment_of<T*>::value; // the + is for walkarround
+#endif
+
+    static constexpr size_t ALIGNED_SIZE = ((sizeof(T) - 1) / ALIGNMENT + 1) * ALIGNMENT;
+
+    static_assert(MinNumAllocs >= 1, "MinNumAllocs");
+    static_assert(MaxNumAllocs >= MinNumAllocs, "MaxNumAllocs");
+    static_assert(ALIGNED_SIZE >= sizeof(T*), "ALIGNED_SIZE");
+    static_assert(0 == (ALIGNED_SIZE % sizeof(T*)), "ALIGNED_SIZE mod");
+    static_assert(ALIGNMENT >= sizeof(T*), "ALIGNMENT");
+
+    T* mHead{nullptr};
+    T** mListForFree{nullptr};
+};
+
+template <typename T, size_t MinSize, size_t MaxSize, bool IsFlat>
+struct NodeAllocator;
+
+// dummy allocator that does nothing
+template <typename T, size_t MinSize, size_t MaxSize>
+struct NodeAllocator<T, MinSize, MaxSize, true> {
+
+    // we are not using the data, so just free it.
+    void addOrFree(void* ptr, size_t ROBIN_HOOD_UNUSED(numBytes) /*unused*/) noexcept {
+        ROBIN_HOOD_LOG("std::free")
+        std::free(ptr);
+    }
+};
+
+template <typename T, size_t MinSize, size_t MaxSize>
+struct NodeAllocator<T, MinSize, MaxSize, false> : public BulkPoolAllocator<T, MinSize, MaxSize> {};
+
+// c++14 doesn't have is_nothrow_swappable, and clang++ 6.0.1 doesn't like it either, so I'm making
+// my own here.
+namespace swappable {
+#if ROBIN_HOOD(CXX) < ROBIN_HOOD(CXX17)
+using std::swap;
+template <typename T>
+struct nothrow {
+    static const bool value = noexcept(swap(std::declval<T&>(), std::declval<T&>()));
+};
+#else
+template <typename T>
+struct nothrow {
+    static const bool value = std::is_nothrow_swappable<T>::value;
+};
+#endif
+} // namespace swappable
+
+} // namespace detail
+
+struct is_transparent_tag {};
+
+// A custom pair implementation is used in the map because std::pair is not is_trivially_copyable,
+// which means it would  not be allowed to be used in std::memcpy. This struct is copyable, which is
+// also tested.
+template <typename T1, typename T2>
+struct pair {
+    using first_type = T1;
+    using second_type = T2;
+
+    template <typename U1 = T1, typename U2 = T2,
+              typename = typename std::enable_if<std::is_default_constructible<U1>::value &&
+                                                 std::is_default_constructible<U2>::value>::type>
+    constexpr pair() noexcept(noexcept(U1()) && noexcept(U2()))
+        : first()
+        , second() {}
+
+    // pair constructors are explicit so we don't accidentally call this ctor when we don't have to.
+    explicit constexpr pair(std::pair<T1, T2> const& o) noexcept(
+        noexcept(T1(std::declval<T1 const&>())) && noexcept(T2(std::declval<T2 const&>())))
+        : first(o.first)
+        , second(o.second) {}
+
+    // pair constructors are explicit so we don't accidentally call this ctor when we don't have to.
+    explicit constexpr pair(std::pair<T1, T2>&& o) noexcept(noexcept(
+        T1(std::move(std::declval<T1&&>()))) && noexcept(T2(std::move(std::declval<T2&&>()))))
+        : first(std::move(o.first))
+        , second(std::move(o.second)) {}
+
+    constexpr pair(T1&& a, T2&& b) noexcept(noexcept(
+        T1(std::move(std::declval<T1&&>()))) && noexcept(T2(std::move(std::declval<T2&&>()))))
+        : first(std::move(a))
+        , second(std::move(b)) {}
+
+    template <typename U1, typename U2>
+    constexpr pair(U1&& a, U2&& b) noexcept(noexcept(T1(std::forward<U1>(
+        std::declval<U1&&>()))) && noexcept(T2(std::forward<U2>(std::declval<U2&&>()))))
+        : first(std::forward<U1>(a))
+        , second(std::forward<U2>(b)) {}
+
+    template <typename... U1, typename... U2>
+    // MSVC 2015 produces error "C2476: ‘constexpr’ constructor does not initialize all members"
+    // if this constructor is constexpr
+#if !ROBIN_HOOD(BROKEN_CONSTEXPR)
+    constexpr
+#endif
+        pair(std::piecewise_construct_t /*unused*/, std::tuple<U1...> a,
+             std::tuple<U2...>
+                 b) noexcept(noexcept(pair(std::declval<std::tuple<U1...>&>(),
+                                           std::declval<std::tuple<U2...>&>(),
+                                           ROBIN_HOOD_STD::index_sequence_for<U1...>(),
+                                           ROBIN_HOOD_STD::index_sequence_for<U2...>())))
+        : pair(a, b, ROBIN_HOOD_STD::index_sequence_for<U1...>(),
+               ROBIN_HOOD_STD::index_sequence_for<U2...>()) {
+    }
+
+    // constructor called from the std::piecewise_construct_t ctor
+    template <typename... U1, size_t... I1, typename... U2, size_t... I2>
+    pair(std::tuple<U1...>& a, std::tuple<U2...>& b, ROBIN_HOOD_STD::index_sequence<I1...> /*unused*/, ROBIN_HOOD_STD::index_sequence<I2...> /*unused*/) noexcept(
+        noexcept(T1(std::forward<U1>(std::get<I1>(
+            std::declval<std::tuple<
+                U1...>&>()))...)) && noexcept(T2(std::
+                                                     forward<U2>(std::get<I2>(
+                                                         std::declval<std::tuple<U2...>&>()))...)))
+        : first(std::forward<U1>(std::get<I1>(a))...)
+        , second(std::forward<U2>(std::get<I2>(b))...) {
+        // make visual studio compiler happy about warning about unused a & b.
+        // Visual studio's pair implementation disables warning 4100.
+        (void)a;
+        (void)b;
+    }
+
+    void swap(pair<T1, T2>& o) noexcept((detail::swappable::nothrow<T1>::value) &&
+                                        (detail::swappable::nothrow<T2>::value)) {
+        using std::swap;
+        swap(first, o.first);
+        swap(second, o.second);
+    }
+
+    T1 first;  // NOLINT(misc-non-private-member-variables-in-classes)
+    T2 second; // NOLINT(misc-non-private-member-variables-in-classes)
+};
+
+template <typename A, typename B>
+inline void swap(pair<A, B>& a, pair<A, B>& b) noexcept(
+    noexcept(std::declval<pair<A, B>&>().swap(std::declval<pair<A, B>&>()))) {
+    a.swap(b);
+}
+
+template <typename A, typename B>
+inline constexpr bool operator==(pair<A, B> const& x, pair<A, B> const& y) {
+    return (x.first == y.first) && (x.second == y.second);
+}
+template <typename A, typename B>
+inline constexpr bool operator!=(pair<A, B> const& x, pair<A, B> const& y) {
+    return !(x == y);
+}
+template <typename A, typename B>
+inline constexpr bool operator<(pair<A, B> const& x, pair<A, B> const& y) noexcept(noexcept(
+    std::declval<A const&>() < std::declval<A const&>()) && noexcept(std::declval<B const&>() <
+                                                                     std::declval<B const&>())) {
+    return x.first < y.first || (!(y.first < x.first) && x.second < y.second);
+}
+template <typename A, typename B>
+inline constexpr bool operator>(pair<A, B> const& x, pair<A, B> const& y) {
+    return y < x;
+}
+template <typename A, typename B>
+inline constexpr bool operator<=(pair<A, B> const& x, pair<A, B> const& y) {
+    return !(x > y);
+}
+template <typename A, typename B>
+inline constexpr bool operator>=(pair<A, B> const& x, pair<A, B> const& y) {
+    return !(x < y);
+}
+
+inline size_t hash_bytes(void const* ptr, size_t len) noexcept {
+    static constexpr uint64_t m = UINT64_C(0xc6a4a7935bd1e995);
+    static constexpr uint64_t seed = UINT64_C(0xe17a1465);
+    static constexpr unsigned int r = 47;
+
+    auto const* const data64 = static_cast<uint64_t const*>(ptr);
+    uint64_t h = seed ^ (len * m);
+
+    size_t const n_blocks = len / 8;
+    for (size_t i = 0; i < n_blocks; ++i) {
+        auto k = detail::unaligned_load<uint64_t>(data64 + i);
+
+        k *= m;
+        k ^= k >> r;
+        k *= m;
+
+        h ^= k;
+        h *= m;
+    }
+
+    auto const* const data8 = reinterpret_cast<uint8_t const*>(data64 + n_blocks);
+    switch (len & 7U) {
+    case 7:
+        h ^= static_cast<uint64_t>(data8[6]) << 48U;
+        ROBIN_HOOD(FALLTHROUGH); // FALLTHROUGH
+    case 6:
+        h ^= static_cast<uint64_t>(data8[5]) << 40U;
+        ROBIN_HOOD(FALLTHROUGH); // FALLTHROUGH
+    case 5:
+        h ^= static_cast<uint64_t>(data8[4]) << 32U;
+        ROBIN_HOOD(FALLTHROUGH); // FALLTHROUGH
+    case 4:
+        h ^= static_cast<uint64_t>(data8[3]) << 24U;
+        ROBIN_HOOD(FALLTHROUGH); // FALLTHROUGH
+    case 3:
+        h ^= static_cast<uint64_t>(data8[2]) << 16U;
+        ROBIN_HOOD(FALLTHROUGH); // FALLTHROUGH
+    case 2:
+        h ^= static_cast<uint64_t>(data8[1]) << 8U;
+        ROBIN_HOOD(FALLTHROUGH); // FALLTHROUGH
+    case 1:
+        h ^= static_cast<uint64_t>(data8[0]);
+        h *= m;
+        ROBIN_HOOD(FALLTHROUGH); // FALLTHROUGH
+    default:
+        break;
+    }
+
+    h ^= h >> r;
+
+    // not doing the final step here, because this will be done by keyToIdx anyways
+    // h *= m;
+    // h ^= h >> r;
+    return static_cast<size_t>(h);
+}
+
+inline size_t hash_int(uint64_t x) noexcept {
+    // tried lots of different hashes, let's stick with murmurhash3. It's simple, fast, well tested,
+    // and doesn't need any special 128bit operations.
+    x ^= x >> 33U;
+    x *= UINT64_C(0xff51afd7ed558ccd);
+    x ^= x >> 33U;
+
+    // not doing the final step here, because this will be done by keyToIdx anyways
+    // x *= UINT64_C(0xc4ceb9fe1a85ec53);
+    // x ^= x >> 33U;
+    return static_cast<size_t>(x);
+}
+
+// A thin wrapper around std::hash, performing an additional simple mixing step of the result.
+template <typename T, typename Enable = void>
+struct hash : public std::hash<T> {
+    size_t operator()(T const& obj) const
+        noexcept(noexcept(std::declval<std::hash<T>>().operator()(std::declval<T const&>()))) {
+        // call base hash
+        auto result = std::hash<T>::operator()(obj);
+        // return mixed of that, to be save against identity has
+        return hash_int(static_cast<detail::SizeT>(result));
+    }
+};
+
+template <typename CharT>
+struct hash<std::basic_string<CharT>> {
+    size_t operator()(std::basic_string<CharT> const& str) const noexcept {
+        return hash_bytes(str.data(), sizeof(CharT) * str.size());
+    }
+};
+
+#if ROBIN_HOOD(CXX) >= ROBIN_HOOD(CXX17)
+template <typename CharT>
+struct hash<std::basic_string_view<CharT>> {
+    size_t operator()(std::basic_string_view<CharT> const& sv) const noexcept {
+        return hash_bytes(sv.data(), sizeof(CharT) * sv.size());
+    }
+};
+#endif
+
+template <class T>
+struct hash<T*> {
+    size_t operator()(T* ptr) const noexcept {
+        return hash_int(reinterpret_cast<detail::SizeT>(ptr));
+    }
+};
+
+template <class T>
+struct hash<std::unique_ptr<T>> {
+    size_t operator()(std::unique_ptr<T> const& ptr) const noexcept {
+        return hash_int(reinterpret_cast<detail::SizeT>(ptr.get()));
+    }
+};
+
+template <class T>
+struct hash<std::shared_ptr<T>> {
+    size_t operator()(std::shared_ptr<T> const& ptr) const noexcept {
+        return hash_int(reinterpret_cast<detail::SizeT>(ptr.get()));
+    }
+};
+
+template <typename Enum>
+struct hash<Enum, typename std::enable_if<std::is_enum<Enum>::value>::type> {
+    size_t operator()(Enum e) const noexcept {
+        using Underlying = typename std::underlying_type<Enum>::type;
+        return hash<Underlying>{}(static_cast<Underlying>(e));
+    }
+};
+
+#define ROBIN_HOOD_HASH_INT(T)                           \
+    template <>                                          \
+    struct hash<T> {                                     \
+        size_t operator()(T const& obj) const noexcept { \
+            return hash_int(static_cast<uint64_t>(obj)); \
+        }                                                \
+    }
+
+#if defined(__GNUC__) && !defined(__clang__)
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wuseless-cast"
+#endif
+// see https://en.cppreference.com/w/cpp/utility/hash
+ROBIN_HOOD_HASH_INT(bool);
+ROBIN_HOOD_HASH_INT(char);
+ROBIN_HOOD_HASH_INT(signed char);
+ROBIN_HOOD_HASH_INT(unsigned char);
+ROBIN_HOOD_HASH_INT(char16_t);
+ROBIN_HOOD_HASH_INT(char32_t);
+#if ROBIN_HOOD(HAS_NATIVE_WCHART)
+ROBIN_HOOD_HASH_INT(wchar_t);
+#endif
+ROBIN_HOOD_HASH_INT(short);
+ROBIN_HOOD_HASH_INT(unsigned short);
+ROBIN_HOOD_HASH_INT(int);
+ROBIN_HOOD_HASH_INT(unsigned int);
+ROBIN_HOOD_HASH_INT(long);
+ROBIN_HOOD_HASH_INT(long long);
+ROBIN_HOOD_HASH_INT(unsigned long);
+ROBIN_HOOD_HASH_INT(unsigned long long);
+#if defined(__GNUC__) && !defined(__clang__)
+#    pragma GCC diagnostic pop
+#endif
+namespace detail {
+
+template <typename T>
+struct void_type {
+    using type = void;
+};
+
+template <typename T, typename = void>
+struct has_is_transparent : public std::false_type {};
+
+template <typename T>
+struct has_is_transparent<T, typename void_type<typename T::is_transparent>::type>
+    : public std::true_type {};
+
+// using wrapper classes for hash and key_equal prevents the diamond problem when the same type
+// is used. see https://stackoverflow.com/a/28771920/48181
+template <typename T>
+struct WrapHash : public T {
+    WrapHash() = default;
+    explicit WrapHash(T const& o) noexcept(noexcept(T(std::declval<T const&>())))
+        : T(o) {}
+};
+
+template <typename T>
+struct WrapKeyEqual : public T {
+    WrapKeyEqual() = default;
+    explicit WrapKeyEqual(T const& o) noexcept(noexcept(T(std::declval<T const&>())))
+        : T(o) {}
+};
+
+// A highly optimized hashmap implementation, using the Robin Hood algorithm.
+//
+// In most cases, this map should be usable as a drop-in replacement for std::unordered_map, but
+// be about 2x faster in most cases and require much less allocations.
+//
+// This implementation uses the following memory layout:
+//
+// [Node, Node, ... Node | info, info, ... infoSentinel ]
+//
+// * Node: either a DataNode that directly has the std::pair<key, val> as member,
+//   or a DataNode with a pointer to std::pair<key,val>. Which DataNode representation to use
+//   depends on how fast the swap() operation is. Heuristically, this is automatically choosen
+//   based on sizeof(). there are always 2^n Nodes.
+//
+// * info: Each Node in the map has a corresponding info byte, so there are 2^n info bytes.
+//   Each byte is initialized to 0, meaning the corresponding Node is empty. Set to 1 means the
+//   corresponding node contains data. Set to 2 means the corresponding Node is filled, but it
+//   actually belongs to the previous position and was pushed out because that place is already
+//   taken.
+//
+// * infoSentinel: Sentinel byte set to 1, so that iterator's ++ can stop at end() without the
+//   need for a idx variable.
+//
+// According to STL, order of templates has effect on throughput. That's why I've moved the
+// boolean to the front.
+// https://www.reddit.com/r/cpp/comments/ahp6iu/compile_time_binary_size_reductions_and_cs_future/eeguck4/
+template <bool IsFlat, size_t MaxLoadFactor100, typename Key, typename T, typename Hash,
+          typename KeyEqual>
+class Table
+    : public WrapHash<Hash>,
+      public WrapKeyEqual<KeyEqual>,
+      detail::NodeAllocator<
+          typename std::conditional<
+              std::is_void<T>::value, Key,
+              robin_hood::pair<typename std::conditional<IsFlat, Key, Key const>::type, T>>::type,
+          4, 16384, IsFlat> {
+public:
+    static constexpr bool is_flat = IsFlat;
+    static constexpr bool is_map = !std::is_void<T>::value;
+    static constexpr bool is_set = !is_map;
+    static constexpr bool is_transparent =
+        has_is_transparent<Hash>::value && has_is_transparent<KeyEqual>::value;
+
+    using key_type = Key;
+    using mapped_type = T;
+    using value_type = typename std::conditional<
+        is_set, Key,
+        robin_hood::pair<typename std::conditional<is_flat, Key, Key const>::type, T>>::type;
+    using size_type = size_t;
+    using hasher = Hash;
+    using key_equal = KeyEqual;
+    using Self = Table<IsFlat, MaxLoadFactor100, key_type, mapped_type, hasher, key_equal>;
+
+private:
+    static_assert(MaxLoadFactor100 > 10 && MaxLoadFactor100 < 100,
+                  "MaxLoadFactor100 needs to be >10 && < 100");
+
+    using WHash = WrapHash<Hash>;
+    using WKeyEqual = WrapKeyEqual<KeyEqual>;
+
+    // configuration defaults
+
+    // make sure we have 8 elements, needed to quickly rehash mInfo
+    static constexpr size_t InitialNumElements = sizeof(uint64_t);
+    static constexpr uint32_t InitialInfoNumBits = 5;
+    static constexpr uint8_t InitialInfoInc = 1U << InitialInfoNumBits;
+    static constexpr size_t InfoMask = InitialInfoInc - 1U;
+    static constexpr uint8_t InitialInfoHashShift = 0;
+    using DataPool = detail::NodeAllocator<value_type, 4, 16384, IsFlat>;
+
+    // type needs to be wider than uint8_t.
+    using InfoType = uint32_t;
+
+    // DataNode ////////////////////////////////////////////////////////
+
+    // Primary template for the data node. We have special implementations for small and big
+    // objects. For large objects it is assumed that swap() is fairly slow, so we allocate these
+    // on the heap so swap merely swaps a pointer.
+    template <typename M, bool>
+    class DataNode {};
+
+    // Small: just allocate on the stack.
+    template <typename M>
+    class DataNode<M, true> final {
+    public:
+        template <typename... Args>
+        explicit DataNode(M& ROBIN_HOOD_UNUSED(map) /*unused*/, Args&&... args) noexcept(
+            noexcept(value_type(std::forward<Args>(args)...)))
+            : mData(std::forward<Args>(args)...) {}
+
+        DataNode(M& ROBIN_HOOD_UNUSED(map) /*unused*/, DataNode<M, true>&& n) noexcept(
+            std::is_nothrow_move_constructible<value_type>::value)
+            : mData(std::move(n.mData)) {}
+
+        // doesn't do anything
+        void destroy(M& ROBIN_HOOD_UNUSED(map) /*unused*/) noexcept {}
+        void destroyDoNotDeallocate() noexcept {}
+
+        value_type const* operator->() const noexcept {
+            return &mData;
+        }
+        value_type* operator->() noexcept {
+            return &mData;
+        }
+
+        const value_type& operator*() const noexcept {
+            return mData;
+        }
+
+        value_type& operator*() noexcept {
+            return mData;
+        }
+
+        template <typename VT = value_type>
+        ROBIN_HOOD(NODISCARD)
+        typename std::enable_if<is_map, typename VT::first_type&>::type getFirst() noexcept {
+            return mData.first;
+        }
+        template <typename VT = value_type>
+        ROBIN_HOOD(NODISCARD)
+        typename std::enable_if<is_set, VT&>::type getFirst() noexcept {
+            return mData;
+        }
+
+        template <typename VT = value_type>
+        ROBIN_HOOD(NODISCARD)
+        typename std::enable_if<is_map, typename VT::first_type const&>::type
+            getFirst() const noexcept {
+            return mData.first;
+        }
+        template <typename VT = value_type>
+        ROBIN_HOOD(NODISCARD)
+        typename std::enable_if<is_set, VT const&>::type getFirst() const noexcept {
+            return mData;
+        }
+
+        template <typename MT = mapped_type>
+        ROBIN_HOOD(NODISCARD)
+        typename std::enable_if<is_map, MT&>::type getSecond() noexcept {
+            return mData.second;
+        }
+
+        template <typename MT = mapped_type>
+        ROBIN_HOOD(NODISCARD)
+        typename std::enable_if<is_set, MT const&>::type getSecond() const noexcept {
+            return mData.second;
+        }
+
+        void swap(DataNode<M, true>& o) noexcept(
+            noexcept(std::declval<value_type>().swap(std::declval<value_type>()))) {
+            mData.swap(o.mData);
+        }
+
+    private:
+        value_type mData;
+    };
+
+    // big object: allocate on heap.
+    template <typename M>
+    class DataNode<M, false> {
+    public:
+        template <typename... Args>
+        explicit DataNode(M& map, Args&&... args)
+            : mData(map.allocate()) {
+            ::new (static_cast<void*>(mData)) value_type(std::forward<Args>(args)...);
+        }
+
+        DataNode(M& ROBIN_HOOD_UNUSED(map) /*unused*/, DataNode<M, false>&& n) noexcept
+            : mData(std::move(n.mData)) {}
+
+        void destroy(M& map) noexcept {
+            // don't deallocate, just put it into list of datapool.
+            mData->~value_type();
+            map.deallocate(mData);
+        }
+
+        void destroyDoNotDeallocate() noexcept {
+            mData->~value_type();
+        }
+
+        value_type const* operator->() const noexcept {
+            return mData;
+        }
+
+        value_type* operator->() noexcept {
+            return mData;
+        }
+
+        const value_type& operator*() const {
+            return *mData;
+        }
+
+        value_type& operator*() {
+            return *mData;
+        }
+
+        template <typename VT = value_type>
+        ROBIN_HOOD(NODISCARD)
+        typename std::enable_if<is_map, typename VT::first_type&>::type getFirst() noexcept {
+            return mData->first;
+        }
+        template <typename VT = value_type>
+        ROBIN_HOOD(NODISCARD)
+        typename std::enable_if<is_set, VT&>::type getFirst() noexcept {
+            return *mData;
+        }
+
+        template <typename VT = value_type>
+        ROBIN_HOOD(NODISCARD)
+        typename std::enable_if<is_map, typename VT::first_type const&>::type
+            getFirst() const noexcept {
+            return mData->first;
+        }
+        template <typename VT = value_type>
+        ROBIN_HOOD(NODISCARD)
+        typename std::enable_if<is_set, VT const&>::type getFirst() const noexcept {
+            return *mData;
+        }
+
+        template <typename MT = mapped_type>
+        ROBIN_HOOD(NODISCARD)
+        typename std::enable_if<is_map, MT&>::type getSecond() noexcept {
+            return mData->second;
+        }
+
+        template <typename MT = mapped_type>
+        ROBIN_HOOD(NODISCARD)
+        typename std::enable_if<is_map, MT const&>::type getSecond() const noexcept {
+            return mData->second;
+        }
+
+        void swap(DataNode<M, false>& o) noexcept {
+            using std::swap;
+            swap(mData, o.mData);
+        }
+
+    private:
+        value_type* mData;
+    };
+
+    using Node = DataNode<Self, IsFlat>;
+
+    // helpers for insertKeyPrepareEmptySpot: extract first entry (only const required)
+    ROBIN_HOOD(NODISCARD) key_type const& getFirstConst(Node const& n) const noexcept {
+        return n.getFirst();
+    }
+
+    // in case we have void mapped_type, we are not using a pair, thus we just route k through.
+    // No need to disable this because it's just not used if not applicable.
+    ROBIN_HOOD(NODISCARD) key_type const& getFirstConst(key_type const& k) const noexcept {
+        return k;
+    }
+
+    // in case we have non-void mapped_type, we have a standard robin_hood::pair
+    template <typename Q = mapped_type>
+    ROBIN_HOOD(NODISCARD)
+    typename std::enable_if<!std::is_void<Q>::value, key_type const&>::type
+        getFirstConst(value_type const& vt) const noexcept {
+        return vt.first;
+    }
+
+    // Cloner //////////////////////////////////////////////////////////
+
+    template <typename M, bool UseMemcpy>
+    struct Cloner;
+
+    // fast path: Just copy data, without allocating anything.
+    template <typename M>
+    struct Cloner<M, true> {
+        void operator()(M const& source, M& target) const {
+            auto const* const src = reinterpret_cast<char const*>(source.mKeyVals);
+            auto* tgt = reinterpret_cast<char*>(target.mKeyVals);
+            auto const numElementsWithBuffer = target.calcNumElementsWithBuffer(target.mMask + 1);
+            std::copy(src, src + target.calcNumBytesTotal(numElementsWithBuffer), tgt);
+        }
+    };
+
+    template <typename M>
+    struct Cloner<M, false> {
+        void operator()(M const& s, M& t) const {
+            auto const numElementsWithBuffer = t.calcNumElementsWithBuffer(t.mMask + 1);
+            std::copy(s.mInfo, s.mInfo + t.calcNumBytesInfo(numElementsWithBuffer), t.mInfo);
+
+            for (size_t i = 0; i < numElementsWithBuffer; ++i) {
+                if (t.mInfo[i]) {
+                    ::new (static_cast<void*>(t.mKeyVals + i)) Node(t, *s.mKeyVals[i]);
+                }
+            }
+        }
+    };
+
+    // Destroyer ///////////////////////////////////////////////////////
+
+    template <typename M, bool IsFlatAndTrivial>
+    struct Destroyer {};
+
+    template <typename M>
+    struct Destroyer<M, true> {
+        void nodes(M& m) const noexcept {
+            m.mNumElements = 0;
+        }
+
+        void nodesDoNotDeallocate(M& m) const noexcept {
+            m.mNumElements = 0;
+        }
+    };
+
+    template <typename M>
+    struct Destroyer<M, false> {
+        void nodes(M& m) const noexcept {
+            m.mNumElements = 0;
+            // clear also resets mInfo to 0, that's sometimes not necessary.
+            auto const numElementsWithBuffer = m.calcNumElementsWithBuffer(m.mMask + 1);
+
+            for (size_t idx = 0; idx < numElementsWithBuffer; ++idx) {
+                if (0 != m.mInfo[idx]) {
+                    Node& n = m.mKeyVals[idx];
+                    n.destroy(m);
+                    n.~Node();
+                }
+            }
+        }
+
+        void nodesDoNotDeallocate(M& m) const noexcept {
+            m.mNumElements = 0;
+            // clear also resets mInfo to 0, that's sometimes not necessary.
+            auto const numElementsWithBuffer = m.calcNumElementsWithBuffer(m.mMask + 1);
+            for (size_t idx = 0; idx < numElementsWithBuffer; ++idx) {
+                if (0 != m.mInfo[idx]) {
+                    Node& n = m.mKeyVals[idx];
+                    n.destroyDoNotDeallocate();
+                    n.~Node();
+                }
+            }
+        }
+    };
+
+    // Iter ////////////////////////////////////////////////////////////
+
+    struct fast_forward_tag {};
+
+    // generic iterator for both const_iterator and iterator.
+    template <bool IsConst>
+    // NOLINTNEXTLINE(hicpp-special-member-functions,cppcoreguidelines-special-member-functions)
+    class Iter {
+    private:
+        using NodePtr = typename std::conditional<IsConst, Node const*, Node*>::type;
+
+    public:
+        using difference_type = std::ptrdiff_t;
+        using value_type = typename Self::value_type;
+        using reference = typename std::conditional<IsConst, value_type const&, value_type&>::type;
+        using pointer = typename std::conditional<IsConst, value_type const*, value_type*>::type;
+        using iterator_category = std::forward_iterator_tag;
+
+        // default constructed iterator can be compared to itself, but WON'T return true when
+        // compared to end().
+        Iter() = default;
+
+        // Rule of zero: nothing specified. The conversion constructor is only enabled for
+        // iterator to const_iterator, so it doesn't accidentally work as a copy ctor.
+
+        // Conversion constructor from iterator to const_iterator.
+        template <bool OtherIsConst,
+                  typename = typename std::enable_if<IsConst && !OtherIsConst>::type>
+        // NOLINTNEXTLINE(hicpp-explicit-conversions)
+        Iter(Iter<OtherIsConst> const& other) noexcept
+            : mKeyVals(other.mKeyVals)
+            , mInfo(other.mInfo) {}
+
+        Iter(NodePtr valPtr, uint8_t const* infoPtr) noexcept
+            : mKeyVals(valPtr)
+            , mInfo(infoPtr) {}
+
+        Iter(NodePtr valPtr, uint8_t const* infoPtr,
+             fast_forward_tag ROBIN_HOOD_UNUSED(tag) /*unused*/) noexcept
+            : mKeyVals(valPtr)
+            , mInfo(infoPtr) {
+            fastForward();
+        }
+
+        template <bool OtherIsConst,
+                  typename = typename std::enable_if<IsConst && !OtherIsConst>::type>
+        Iter& operator=(Iter<OtherIsConst> const& other) noexcept {
+            mKeyVals = other.mKeyVals;
+            mInfo = other.mInfo;
+            return *this;
+        }
+
+        // prefix increment. Undefined behavior if we are at end()!
+        Iter& operator++() noexcept {
+            mInfo++;
+            mKeyVals++;
+            fastForward();
+            return *this;
+        }
+
+        Iter operator++(int) noexcept {
+            Iter tmp = *this;
+            ++(*this);
+            return tmp;
+        }
+
+        reference operator*() const {
+            return **mKeyVals;
+        }
+
+        pointer operator->() const {
+            return &**mKeyVals;
+        }
+
+        template <bool O>
+        bool operator==(Iter<O> const& o) const noexcept {
+            return mKeyVals == o.mKeyVals;
+        }
+
+        template <bool O>
+        bool operator!=(Iter<O> const& o) const noexcept {
+            return mKeyVals != o.mKeyVals;
+        }
+
+    private:
+        // fast forward to the next non-free info byte
+        // I've tried a few variants that don't depend on intrinsics, but unfortunately they are
+        // quite a bit slower than this one. So I've reverted that change again. See map_benchmark.
+        void fastForward() noexcept {
+            size_t n = 0;
+            while (0U == (n = detail::unaligned_load<size_t>(mInfo))) {
+                mInfo += sizeof(size_t);
+                mKeyVals += sizeof(size_t);
+            }
+#if defined(ROBIN_HOOD_DISABLE_INTRINSICS)
+            // we know for certain that within the next 8 bytes we'll find a non-zero one.
+            if (ROBIN_HOOD_UNLIKELY(0U == detail::unaligned_load<uint32_t>(mInfo))) {
+                mInfo += 4;
+                mKeyVals += 4;
+            }
+            if (ROBIN_HOOD_UNLIKELY(0U == detail::unaligned_load<uint16_t>(mInfo))) {
+                mInfo += 2;
+                mKeyVals += 2;
+            }
+            if (ROBIN_HOOD_UNLIKELY(0U == *mInfo)) {
+                mInfo += 1;
+                mKeyVals += 1;
+            }
+#else
+#    if ROBIN_HOOD(LITTLE_ENDIAN)
+            auto inc = ROBIN_HOOD_COUNT_TRAILING_ZEROES(n) / 8;
+#    else
+            auto inc = ROBIN_HOOD_COUNT_LEADING_ZEROES(n) / 8;
+#    endif
+            mInfo += inc;
+            mKeyVals += inc;
+#endif
+        }
+
+        friend class Table<IsFlat, MaxLoadFactor100, key_type, mapped_type, hasher, key_equal>;
+        NodePtr mKeyVals{nullptr};
+        uint8_t const* mInfo{nullptr};
+    };
+
+    ////////////////////////////////////////////////////////////////////
+
+    // highly performance relevant code.
+    // Lower bits are used for indexing into the array (2^n size)
+    // The upper 1-5 bits need to be a reasonable good hash, to save comparisons.
+    template <typename HashKey>
+    void keyToIdx(HashKey&& key, size_t* idx, InfoType* info) const {
+        // In addition to whatever hash is used, add another mul & shift so we get better hashing.
+        // This serves as a bad hash prevention, if the given data is
+        // badly mixed.
+        auto h = static_cast<uint64_t>(WHash::operator()(key));
+
+        h *= mHashMultiplier;
+        h ^= h >> 33U;
+
+        // the lower InitialInfoNumBits are reserved for info.
+        *info = mInfoInc + static_cast<InfoType>((h & InfoMask) >> mInfoHashShift);
+        *idx = (static_cast<size_t>(h) >> InitialInfoNumBits) & mMask;
+    }
+
+    // forwards the index by one, wrapping around at the end
+    void next(InfoType* info, size_t* idx) const noexcept {
+        *idx = *idx + 1;
+        *info += mInfoInc;
+    }
+
+    void nextWhileLess(InfoType* info, size_t* idx) const noexcept {
+        // unrolling this by hand did not bring any speedups.
+        while (*info < mInfo[*idx]) {
+            next(info, idx);
+        }
+    }
+
+    // Shift everything up by one element. Tries to move stuff around.
+    void
+    shiftUp(size_t startIdx,
+            size_t const insertion_idx) noexcept(std::is_nothrow_move_assignable<Node>::value) {
+        auto idx = startIdx;
+        ::new (static_cast<void*>(mKeyVals + idx)) Node(std::move(mKeyVals[idx - 1]));
+        while (--idx != insertion_idx) {
+            mKeyVals[idx] = std::move(mKeyVals[idx - 1]);
+        }
+
+        idx = startIdx;
+        while (idx != insertion_idx) {
+            ROBIN_HOOD_COUNT(shiftUp)
+            mInfo[idx] = static_cast<uint8_t>(mInfo[idx - 1] + mInfoInc);
+            if (ROBIN_HOOD_UNLIKELY(mInfo[idx] + mInfoInc > 0xFF)) {
+                mMaxNumElementsAllowed = 0;
+            }
+            --idx;
+        }
+    }
+
+    void shiftDown(size_t idx) noexcept(std::is_nothrow_move_assignable<Node>::value) {
+        // until we find one that is either empty or has zero offset.
+        // TODO(martinus) we don't need to move everything, just the last one for the same
+        // bucket.
+        mKeyVals[idx].destroy(*this);
+
+        // until we find one that is either empty or has zero offset.
+        while (mInfo[idx + 1] >= 2 * mInfoInc) {
+            ROBIN_HOOD_COUNT(shiftDown)
+            mInfo[idx] = static_cast<uint8_t>(mInfo[idx + 1] - mInfoInc);
+            mKeyVals[idx] = std::move(mKeyVals[idx + 1]);
+            ++idx;
+        }
+
+        mInfo[idx] = 0;
+        // don't destroy, we've moved it
+        // mKeyVals[idx].destroy(*this);
+        mKeyVals[idx].~Node();
+    }
+
+    // copy of find(), except that it returns iterator instead of const_iterator.
+    template <typename Other>
+    ROBIN_HOOD(NODISCARD)
+    size_t findIdx(Other const& key) const {
+        size_t idx{};
+        InfoType info{};
+        keyToIdx(key, &idx, &info);
+
+        do {
+            // unrolling this twice gives a bit of a speedup. More unrolling did not help.
+            if (info == mInfo[idx] &&
+                ROBIN_HOOD_LIKELY(WKeyEqual::operator()(key, mKeyVals[idx].getFirst()))) {
+                return idx;
+            }
+            next(&info, &idx);
+            if (info == mInfo[idx] &&
+                ROBIN_HOOD_LIKELY(WKeyEqual::operator()(key, mKeyVals[idx].getFirst()))) {
+                return idx;
+            }
+            next(&info, &idx);
+        } while (info <= mInfo[idx]);
+
+        // nothing found!
+        return mMask == 0 ? 0
+                          : static_cast<size_t>(std::distance(
+                                mKeyVals, reinterpret_cast_no_cast_align_warning<Node*>(mInfo)));
+    }
+
+    void cloneData(const Table& o) {
+        Cloner<Table, IsFlat && ROBIN_HOOD_IS_TRIVIALLY_COPYABLE(Node)>()(o, *this);
+    }
+
+    // inserts a keyval that is guaranteed to be new, e.g. when the hashmap is resized.
+    // @return True on success, false if something went wrong
+    void insert_move(Node&& keyval) {
+        // we don't retry, fail if overflowing
+        // don't need to check max num elements
+        if (0 == mMaxNumElementsAllowed && !try_increase_info()) {
+            throwOverflowError();
+        }
+
+        size_t idx{};
+        InfoType info{};
+        keyToIdx(keyval.getFirst(), &idx, &info);
+
+        // skip forward. Use <= because we are certain that the element is not there.
+        while (info <= mInfo[idx]) {
+            idx = idx + 1;
+            info += mInfoInc;
+        }
+
+        // key not found, so we are now exactly where we want to insert it.
+        auto const insertion_idx = idx;
+        auto const insertion_info = static_cast<uint8_t>(info);
+        if (ROBIN_HOOD_UNLIKELY(insertion_info + mInfoInc > 0xFF)) {
+            mMaxNumElementsAllowed = 0;
+        }
+
+        // find an empty spot
+        while (0 != mInfo[idx]) {
+            next(&info, &idx);
+        }
+
+        auto& l = mKeyVals[insertion_idx];
+        if (idx == insertion_idx) {
+            ::new (static_cast<void*>(&l)) Node(std::move(keyval));
+        } else {
+            shiftUp(idx, insertion_idx);
+            l = std::move(keyval);
+        }
+
+        // put at empty spot
+        mInfo[insertion_idx] = insertion_info;
+
+        ++mNumElements;
+    }
+
+public:
+    using iterator = Iter<false>;
+    using const_iterator = Iter<true>;
+
+    Table() noexcept(noexcept(Hash()) && noexcept(KeyEqual()))
+        : WHash()
+        , WKeyEqual() {
+        ROBIN_HOOD_TRACE(this)
+    }
+
+    // Creates an empty hash map. Nothing is allocated yet, this happens at the first insert.
+    // This tremendously speeds up ctor & dtor of a map that never receives an element. The
+    // penalty is payed at the first insert, and not before. Lookup of this empty map works
+    // because everybody points to DummyInfoByte::b. parameter bucket_count is dictated by the
+    // standard, but we can ignore it.
+    explicit Table(
+        size_t ROBIN_HOOD_UNUSED(bucket_count) /*unused*/, const Hash& h = Hash{},
+        const KeyEqual& equal = KeyEqual{}) noexcept(noexcept(Hash(h)) && noexcept(KeyEqual(equal)))
+        : WHash(h)
+        , WKeyEqual(equal) {
+        ROBIN_HOOD_TRACE(this)
+    }
+
+    template <typename Iter>
+    Table(Iter first, Iter last, size_t ROBIN_HOOD_UNUSED(bucket_count) /*unused*/ = 0,
+          const Hash& h = Hash{}, const KeyEqual& equal = KeyEqual{})
+        : WHash(h)
+        , WKeyEqual(equal) {
+        ROBIN_HOOD_TRACE(this)
+        insert(first, last);
+    }
+
+    Table(std::initializer_list<value_type> initlist,
+          size_t ROBIN_HOOD_UNUSED(bucket_count) /*unused*/ = 0, const Hash& h = Hash{},
+          const KeyEqual& equal = KeyEqual{})
+        : WHash(h)
+        , WKeyEqual(equal) {
+        ROBIN_HOOD_TRACE(this)
+        insert(initlist.begin(), initlist.end());
+    }
+
+    Table(Table&& o) noexcept
+        : WHash(std::move(static_cast<WHash&>(o)))
+        , WKeyEqual(std::move(static_cast<WKeyEqual&>(o)))
+        , DataPool(std::move(static_cast<DataPool&>(o))) {
+        ROBIN_HOOD_TRACE(this)
+        if (o.mMask) {
+            mHashMultiplier = std::move(o.mHashMultiplier);
+            mKeyVals = std::move(o.mKeyVals);
+            mInfo = std::move(o.mInfo);
+            mNumElements = std::move(o.mNumElements);
+            mMask = std::move(o.mMask);
+            mMaxNumElementsAllowed = std::move(o.mMaxNumElementsAllowed);
+            mInfoInc = std::move(o.mInfoInc);
+            mInfoHashShift = std::move(o.mInfoHashShift);
+            // set other's mask to 0 so its destructor won't do anything
+            o.init();
+        }
+    }
+
+    Table& operator=(Table&& o) noexcept {
+        ROBIN_HOOD_TRACE(this)
+        if (&o != this) {
+            if (o.mMask) {
+                // only move stuff if the other map actually has some data
+                destroy();
+                mHashMultiplier = std::move(o.mHashMultiplier);
+                mKeyVals = std::move(o.mKeyVals);
+                mInfo = std::move(o.mInfo);
+                mNumElements = std::move(o.mNumElements);
+                mMask = std::move(o.mMask);
+                mMaxNumElementsAllowed = std::move(o.mMaxNumElementsAllowed);
+                mInfoInc = std::move(o.mInfoInc);
+                mInfoHashShift = std::move(o.mInfoHashShift);
+                WHash::operator=(std::move(static_cast<WHash&>(o)));
+                WKeyEqual::operator=(std::move(static_cast<WKeyEqual&>(o)));
+                DataPool::operator=(std::move(static_cast<DataPool&>(o)));
+
+                o.init();
+
+            } else {
+                // nothing in the other map => just clear us.
+                clear();
+            }
+        }
+        return *this;
+    }
+
+    Table(const Table& o)
+        : WHash(static_cast<const WHash&>(o))
+        , WKeyEqual(static_cast<const WKeyEqual&>(o))
+        , DataPool(static_cast<const DataPool&>(o)) {
+        ROBIN_HOOD_TRACE(this)
+        if (!o.empty()) {
+            // not empty: create an exact copy. it is also possible to just iterate through all
+            // elements and insert them, but copying is probably faster.
+
+            auto const numElementsWithBuffer = calcNumElementsWithBuffer(o.mMask + 1);
+            auto const numBytesTotal = calcNumBytesTotal(numElementsWithBuffer);
+
+            ROBIN_HOOD_LOG("std::malloc " << numBytesTotal << " = calcNumBytesTotal("
+                                          << numElementsWithBuffer << ")")
+            mHashMultiplier = o.mHashMultiplier;
+            mKeyVals = static_cast<Node*>(
+                detail::assertNotNull<std::bad_alloc>(std::malloc(numBytesTotal)));
+            // no need for calloc because clonData does memcpy
+            mInfo = reinterpret_cast<uint8_t*>(mKeyVals + numElementsWithBuffer);
+            mNumElements = o.mNumElements;
+            mMask = o.mMask;
+            mMaxNumElementsAllowed = o.mMaxNumElementsAllowed;
+            mInfoInc = o.mInfoInc;
+            mInfoHashShift = o.mInfoHashShift;
+            cloneData(o);
+        }
+    }
+
+    // Creates a copy of the given map. Copy constructor of each entry is used.
+    // Not sure why clang-tidy thinks this doesn't handle self assignment, it does
+    // NOLINTNEXTLINE(bugprone-unhandled-self-assignment,cert-oop54-cpp)
+    Table& operator=(Table const& o) {
+        ROBIN_HOOD_TRACE(this)
+        if (&o == this) {
+            // prevent assigning of itself
+            return *this;
+        }
+
+        // we keep using the old allocator and not assign the new one, because we want to keep
+        // the memory available. when it is the same size.
+        if (o.empty()) {
+            if (0 == mMask) {
+                // nothing to do, we are empty too
+                return *this;
+            }
+
+            // not empty: destroy what we have there
+            // clear also resets mInfo to 0, that's sometimes not necessary.
+            destroy();
+            init();
+            WHash::operator=(static_cast<const WHash&>(o));
+            WKeyEqual::operator=(static_cast<const WKeyEqual&>(o));
+            DataPool::operator=(static_cast<DataPool const&>(o));
+
+            return *this;
+        }
+
+        // clean up old stuff
+        Destroyer<Self, IsFlat && std::is_trivially_destructible<Node>::value>{}.nodes(*this);
+
+        if (mMask != o.mMask) {
+            // no luck: we don't have the same array size allocated, so we need to realloc.
+            if (0 != mMask) {
+                // only deallocate if we actually have data!
+                ROBIN_HOOD_LOG("std::free")
+                std::free(mKeyVals);
+            }
+
+            auto const numElementsWithBuffer = calcNumElementsWithBuffer(o.mMask + 1);
+            auto const numBytesTotal = calcNumBytesTotal(numElementsWithBuffer);
+            ROBIN_HOOD_LOG("std::malloc " << numBytesTotal << " = calcNumBytesTotal("
+                                          << numElementsWithBuffer << ")")
+            mKeyVals = static_cast<Node*>(
+                detail::assertNotNull<std::bad_alloc>(std::malloc(numBytesTotal)));
+
+            // no need for calloc here because cloneData performs a memcpy.
+            mInfo = reinterpret_cast<uint8_t*>(mKeyVals + numElementsWithBuffer);
+            // sentinel is set in cloneData
+        }
+        WHash::operator=(static_cast<const WHash&>(o));
+        WKeyEqual::operator=(static_cast<const WKeyEqual&>(o));
+        DataPool::operator=(static_cast<DataPool const&>(o));
+        mHashMultiplier = o.mHashMultiplier;
+        mNumElements = o.mNumElements;
+        mMask = o.mMask;
+        mMaxNumElementsAllowed = o.mMaxNumElementsAllowed;
+        mInfoInc = o.mInfoInc;
+        mInfoHashShift = o.mInfoHashShift;
+        cloneData(o);
+
+        return *this;
+    }
+
+    // Swaps everything between the two maps.
+    void swap(Table& o) {
+        ROBIN_HOOD_TRACE(this)
+        using std::swap;
+        swap(o, *this);
+    }
+
+    // Clears all data, without resizing.
+    void clear() {
+        ROBIN_HOOD_TRACE(this)
+        if (empty()) {
+            // don't do anything! also important because we don't want to write to
+            // DummyInfoByte::b, even though we would just write 0 to it.
+            return;
+        }
+
+        Destroyer<Self, IsFlat && std::is_trivially_destructible<Node>::value>{}.nodes(*this);
+
+        auto const numElementsWithBuffer = calcNumElementsWithBuffer(mMask + 1);
+        // clear everything, then set the sentinel again
+        uint8_t const z = 0;
+        std::fill(mInfo, mInfo + calcNumBytesInfo(numElementsWithBuffer), z);
+        mInfo[numElementsWithBuffer] = 1;
+
+        mInfoInc = InitialInfoInc;
+        mInfoHashShift = InitialInfoHashShift;
+    }
+
+    // Destroys the map and all it's contents.
+    ~Table() {
+        ROBIN_HOOD_TRACE(this)
+        destroy();
+    }
+
+    // Checks if both tables contain the same entries. Order is irrelevant.
+    bool operator==(const Table& other) const {
+        ROBIN_HOOD_TRACE(this)
+        if (other.size() != size()) {
+            return false;
+        }
+        for (auto const& otherEntry : other) {
+            if (!has(otherEntry)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    bool operator!=(const Table& other) const {
+        ROBIN_HOOD_TRACE(this)
+        return !operator==(other);
+    }
+
+    template <typename Q = mapped_type>
+    typename std::enable_if<!std::is_void<Q>::value, Q&>::type operator[](const key_type& key) {
+        ROBIN_HOOD_TRACE(this)
+        auto idxAndState = insertKeyPrepareEmptySpot(key);
+        switch (idxAndState.second) {
+        case InsertionState::key_found:
+            break;
+
+        case InsertionState::new_node:
+            ::new (static_cast<void*>(&mKeyVals[idxAndState.first]))
+                Node(*this, std::piecewise_construct, std::forward_as_tuple(key),
+                     std::forward_as_tuple());
+            break;
+
+        case InsertionState::overwrite_node:
+            mKeyVals[idxAndState.first] = Node(*this, std::piecewise_construct,
+                                               std::forward_as_tuple(key), std::forward_as_tuple());
+            break;
+
+        case InsertionState::overflow_error:
+            throwOverflowError();
+        }
+
+        return mKeyVals[idxAndState.first].getSecond();
+    }
+
+    template <typename Q = mapped_type>
+    typename std::enable_if<!std::is_void<Q>::value, Q&>::type operator[](key_type&& key) {
+        ROBIN_HOOD_TRACE(this)
+        auto idxAndState = insertKeyPrepareEmptySpot(key);
+        switch (idxAndState.second) {
+        case InsertionState::key_found:
+            break;
+
+        case InsertionState::new_node:
+            ::new (static_cast<void*>(&mKeyVals[idxAndState.first]))
+                Node(*this, std::piecewise_construct, std::forward_as_tuple(std::move(key)),
+                     std::forward_as_tuple());
+            break;
+
+        case InsertionState::overwrite_node:
+            mKeyVals[idxAndState.first] =
+                Node(*this, std::piecewise_construct, std::forward_as_tuple(std::move(key)),
+                     std::forward_as_tuple());
+            break;
+
+        case InsertionState::overflow_error:
+            throwOverflowError();
+        }
+
+        return mKeyVals[idxAndState.first].getSecond();
+    }
+
+    template <typename Iter>
+    void insert(Iter first, Iter last) {
+        for (; first != last; ++first) {
+            // value_type ctor needed because this might be called with std::pair's
+            insert(value_type(*first));
+        }
+    }
+
+    void insert(std::initializer_list<value_type> ilist) {
+        for (auto&& vt : ilist) {
+            insert(std::move(vt));
+        }
+    }
+
+    template <typename... Args>
+    std::pair<iterator, bool> emplace(Args&&... args) {
+        ROBIN_HOOD_TRACE(this)
+        Node n{*this, std::forward<Args>(args)...};
+        auto idxAndState = insertKeyPrepareEmptySpot(getFirstConst(n));
+        switch (idxAndState.second) {
+        case InsertionState::key_found:
+            n.destroy(*this);
+            break;
+
+        case InsertionState::new_node:
+            ::new (static_cast<void*>(&mKeyVals[idxAndState.first])) Node(*this, std::move(n));
+            break;
+
+        case InsertionState::overwrite_node:
+            mKeyVals[idxAndState.first] = std::move(n);
+            break;
+
+        case InsertionState::overflow_error:
+            n.destroy(*this);
+            throwOverflowError();
+            break;
+        }
+
+        return std::make_pair(iterator(mKeyVals + idxAndState.first, mInfo + idxAndState.first),
+                              InsertionState::key_found != idxAndState.second);
+    }
+
+    template <typename... Args>
+    iterator emplace_hint(const_iterator position, Args&&... args) {
+        (void)position;
+        return emplace(std::forward<Args>(args)...).first;
+    }
+
+    template <typename... Args>
+    std::pair<iterator, bool> try_emplace(const key_type& key, Args&&... args) {
+        return try_emplace_impl(key, std::forward<Args>(args)...);
+    }
+
+    template <typename... Args>
+    std::pair<iterator, bool> try_emplace(key_type&& key, Args&&... args) {
+        return try_emplace_impl(std::move(key), std::forward<Args>(args)...);
+    }
+
+    template <typename... Args>
+    iterator try_emplace(const_iterator hint, const key_type& key, Args&&... args) {
+        (void)hint;
+        return try_emplace_impl(key, std::forward<Args>(args)...).first;
+    }
+
+    template <typename... Args>
+    iterator try_emplace(const_iterator hint, key_type&& key, Args&&... args) {
+        (void)hint;
+        return try_emplace_impl(std::move(key), std::forward<Args>(args)...).first;
+    }
+
+    template <typename Mapped>
+    std::pair<iterator, bool> insert_or_assign(const key_type& key, Mapped&& obj) {
+        return insertOrAssignImpl(key, std::forward<Mapped>(obj));
+    }
+
+    template <typename Mapped>
+    std::pair<iterator, bool> insert_or_assign(key_type&& key, Mapped&& obj) {
+        return insertOrAssignImpl(std::move(key), std::forward<Mapped>(obj));
+    }
+
+    template <typename Mapped>
+    iterator insert_or_assign(const_iterator hint, const key_type& key, Mapped&& obj) {
+        (void)hint;
+        return insertOrAssignImpl(key, std::forward<Mapped>(obj)).first;
+    }
+
+    template <typename Mapped>
+    iterator insert_or_assign(const_iterator hint, key_type&& key, Mapped&& obj) {
+        (void)hint;
+        return insertOrAssignImpl(std::move(key), std::forward<Mapped>(obj)).first;
+    }
+
+    std::pair<iterator, bool> insert(const value_type& keyval) {
+        ROBIN_HOOD_TRACE(this)
+        return emplace(keyval);
+    }
+
+    iterator insert(const_iterator hint, const value_type& keyval) {
+        (void)hint;
+        return emplace(keyval).first;
+    }
+
+    std::pair<iterator, bool> insert(value_type&& keyval) {
+        return emplace(std::move(keyval));
+    }
+
+    iterator insert(const_iterator hint, value_type&& keyval) {
+        (void)hint;
+        return emplace(std::move(keyval)).first;
+    }
+
+    // Returns 1 if key is found, 0 otherwise.
+    size_t count(const key_type& key) const { // NOLINT(modernize-use-nodiscard)
+        ROBIN_HOOD_TRACE(this)
+        auto kv = mKeyVals + findIdx(key);
+        if (kv != reinterpret_cast_no_cast_align_warning<Node*>(mInfo)) {
+            return 1;
+        }
+        return 0;
+    }
+
+    template <typename OtherKey, typename Self_ = Self>
+    // NOLINTNEXTLINE(modernize-use-nodiscard)
+    typename std::enable_if<Self_::is_transparent, size_t>::type count(const OtherKey& key) const {
+        ROBIN_HOOD_TRACE(this)
+        auto kv = mKeyVals + findIdx(key);
+        if (kv != reinterpret_cast_no_cast_align_warning<Node*>(mInfo)) {
+            return 1;
+        }
+        return 0;
+    }
+
+    bool contains(const key_type& key) const { // NOLINT(modernize-use-nodiscard)
+        return 1U == count(key);
+    }
+
+    template <typename OtherKey, typename Self_ = Self>
+    // NOLINTNEXTLINE(modernize-use-nodiscard)
+    typename std::enable_if<Self_::is_transparent, bool>::type contains(const OtherKey& key) const {
+        return 1U == count(key);
+    }
+
+    // Returns a reference to the value found for key.
+    // Throws std::out_of_range if element cannot be found
+    template <typename Q = mapped_type>
+    // NOLINTNEXTLINE(modernize-use-nodiscard)
+    typename std::enable_if<!std::is_void<Q>::value, Q&>::type at(key_type const& key) {
+        ROBIN_HOOD_TRACE(this)
+        auto kv = mKeyVals + findIdx(key);
+        if (kv == reinterpret_cast_no_cast_align_warning<Node*>(mInfo)) {
+            doThrow<std::out_of_range>("key not found");
+        }
+        return kv->getSecond();
+    }
+
+    // Returns a reference to the value found for key.
+    // Throws std::out_of_range if element cannot be found
+    template <typename Q = mapped_type>
+    // NOLINTNEXTLINE(modernize-use-nodiscard)
+    typename std::enable_if<!std::is_void<Q>::value, Q const&>::type at(key_type const& key) const {
+        ROBIN_HOOD_TRACE(this)
+        auto kv = mKeyVals + findIdx(key);
+        if (kv == reinterpret_cast_no_cast_align_warning<Node*>(mInfo)) {
+            doThrow<std::out_of_range>("key not found");
+        }
+        return kv->getSecond();
+    }
+
+    const_iterator find(const key_type& key) const { // NOLINT(modernize-use-nodiscard)
+        ROBIN_HOOD_TRACE(this)
+        const size_t idx = findIdx(key);
+        return const_iterator{mKeyVals + idx, mInfo + idx};
+    }
+
+    template <typename OtherKey>
+    const_iterator find(const OtherKey& key, is_transparent_tag /*unused*/) const {
+        ROBIN_HOOD_TRACE(this)
+        const size_t idx = findIdx(key);
+        return const_iterator{mKeyVals + idx, mInfo + idx};
+    }
+
+    template <typename OtherKey, typename Self_ = Self>
+    typename std::enable_if<Self_::is_transparent, // NOLINT(modernize-use-nodiscard)
+                            const_iterator>::type  // NOLINT(modernize-use-nodiscard)
+    find(const OtherKey& key) const {              // NOLINT(modernize-use-nodiscard)
+        ROBIN_HOOD_TRACE(this)
+        const size_t idx = findIdx(key);
+        return const_iterator{mKeyVals + idx, mInfo + idx};
+    }
+
+    iterator find(const key_type& key) {
+        ROBIN_HOOD_TRACE(this)
+        const size_t idx = findIdx(key);
+        return iterator{mKeyVals + idx, mInfo + idx};
+    }
+
+    template <typename OtherKey>
+    iterator find(const OtherKey& key, is_transparent_tag /*unused*/) {
+        ROBIN_HOOD_TRACE(this)
+        const size_t idx = findIdx(key);
+        return iterator{mKeyVals + idx, mInfo + idx};
+    }
+
+    template <typename OtherKey, typename Self_ = Self>
+    typename std::enable_if<Self_::is_transparent, iterator>::type find(const OtherKey& key) {
+        ROBIN_HOOD_TRACE(this)
+        const size_t idx = findIdx(key);
+        return iterator{mKeyVals + idx, mInfo + idx};
+    }
+
+    iterator begin() {
+        ROBIN_HOOD_TRACE(this)
+        if (empty()) {
+            return end();
+        }
+        return iterator(mKeyVals, mInfo, fast_forward_tag{});
+    }
+    const_iterator begin() const { // NOLINT(modernize-use-nodiscard)
+        ROBIN_HOOD_TRACE(this)
+        return cbegin();
+    }
+    const_iterator cbegin() const { // NOLINT(modernize-use-nodiscard)
+        ROBIN_HOOD_TRACE(this)
+        if (empty()) {
+            return cend();
+        }
+        return const_iterator(mKeyVals, mInfo, fast_forward_tag{});
+    }
+
+    iterator end() {
+        ROBIN_HOOD_TRACE(this)
+        // no need to supply valid info pointer: end() must not be dereferenced, and only node
+        // pointer is compared.
+        return iterator{reinterpret_cast_no_cast_align_warning<Node*>(mInfo), nullptr};
+    }
+    const_iterator end() const { // NOLINT(modernize-use-nodiscard)
+        ROBIN_HOOD_TRACE(this)
+        return cend();
+    }
+    const_iterator cend() const { // NOLINT(modernize-use-nodiscard)
+        ROBIN_HOOD_TRACE(this)
+        return const_iterator{reinterpret_cast_no_cast_align_warning<Node*>(mInfo), nullptr};
+    }
+
+    iterator erase(const_iterator pos) {
+        ROBIN_HOOD_TRACE(this)
+        // its safe to perform const cast here
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
+        return erase(iterator{const_cast<Node*>(pos.mKeyVals), const_cast<uint8_t*>(pos.mInfo)});
+    }
+
+    // Erases element at pos, returns iterator to the next element.
+    iterator erase(iterator pos) {
+        ROBIN_HOOD_TRACE(this)
+        // we assume that pos always points to a valid entry, and not end().
+        auto const idx = static_cast<size_t>(pos.mKeyVals - mKeyVals);
+
+        shiftDown(idx);
+        --mNumElements;
+
+        if (*pos.mInfo) {
+            // we've backward shifted, return this again
+            return pos;
+        }
+
+        // no backward shift, return next element
+        return ++pos;
+    }
+
+    size_t erase(const key_type& key) {
+        ROBIN_HOOD_TRACE(this)
+        size_t idx{};
+        InfoType info{};
+        keyToIdx(key, &idx, &info);
+
+        // check while info matches with the source idx
+        do {
+            if (info == mInfo[idx] && WKeyEqual::operator()(key, mKeyVals[idx].getFirst())) {
+                shiftDown(idx);
+                --mNumElements;
+                return 1;
+            }
+            next(&info, &idx);
+        } while (info <= mInfo[idx]);
+
+        // nothing found to delete
+        return 0;
+    }
+
+    // reserves space for the specified number of elements. Makes sure the old data fits.
+    // exactly the same as reserve(c).
+    void rehash(size_t c) {
+        // forces a reserve
+        reserve(c, true);
+    }
+
+    // reserves space for the specified number of elements. Makes sure the old data fits.
+    // Exactly the same as rehash(c). Use rehash(0) to shrink to fit.
+    void reserve(size_t c) {
+        // reserve, but don't force rehash
+        reserve(c, false);
+    }
+
+    // If possible reallocates the map to a smaller one. This frees the underlying table.
+    // Does not do anything if load_factor is too large for decreasing the table's size.
+    void compact() {
+        ROBIN_HOOD_TRACE(this)
+        auto newSize = InitialNumElements;
+        while (calcMaxNumElementsAllowed(newSize) < mNumElements && newSize != 0) {
+            newSize *= 2;
+        }
+        if (ROBIN_HOOD_UNLIKELY(newSize == 0)) {
+            throwOverflowError();
+        }
+
+        ROBIN_HOOD_LOG("newSize > mMask + 1: " << newSize << " > " << mMask << " + 1")
+
+        // only actually do anything when the new size is bigger than the old one. This prevents to
+        // continuously allocate for each reserve() call.
+        if (newSize < mMask + 1) {
+            rehashPowerOfTwo(newSize, true);
+        }
+    }
+
+    size_type size() const noexcept { // NOLINT(modernize-use-nodiscard)
+        ROBIN_HOOD_TRACE(this)
+        return mNumElements;
+    }
+
+    size_type max_size() const noexcept { // NOLINT(modernize-use-nodiscard)
+        ROBIN_HOOD_TRACE(this)
+        return static_cast<size_type>(-1);
+    }
+
+    ROBIN_HOOD(NODISCARD) bool empty() const noexcept {
+        ROBIN_HOOD_TRACE(this)
+        return 0 == mNumElements;
+    }
+
+    float max_load_factor() const noexcept { // NOLINT(modernize-use-nodiscard)
+        ROBIN_HOOD_TRACE(this)
+        return MaxLoadFactor100 / 100.0F;
+    }
+
+    // Average number of elements per bucket. Since we allow only 1 per bucket
+    float load_factor() const noexcept { // NOLINT(modernize-use-nodiscard)
+        ROBIN_HOOD_TRACE(this)
+        return static_cast<float>(size()) / static_cast<float>(mMask + 1);
+    }
+
+    ROBIN_HOOD(NODISCARD) size_t mask() const noexcept {
+        ROBIN_HOOD_TRACE(this)
+        return mMask;
+    }
+
+    ROBIN_HOOD(NODISCARD) size_t calcMaxNumElementsAllowed(size_t maxElements) const noexcept {
+        if (ROBIN_HOOD_LIKELY(maxElements <= (std::numeric_limits<size_t>::max)() / 100)) {
+            return maxElements * MaxLoadFactor100 / 100;
+        }
+
+        // we might be a bit inprecise, but since maxElements is quite large that doesn't matter
+        return (maxElements / 100) * MaxLoadFactor100;
+    }
+
+    ROBIN_HOOD(NODISCARD) size_t calcNumBytesInfo(size_t numElements) const noexcept {
+        // we add a uint64_t, which houses the sentinel (first byte) and padding so we can load
+        // 64bit types.
+        return numElements + sizeof(uint64_t);
+    }
+
+    ROBIN_HOOD(NODISCARD)
+    size_t calcNumElementsWithBuffer(size_t numElements) const noexcept {
+        auto maxNumElementsAllowed = calcMaxNumElementsAllowed(numElements);
+        return numElements + (std::min)(maxNumElementsAllowed, (static_cast<size_t>(0xFF)));
+    }
+
+    // calculation only allowed for 2^n values
+    ROBIN_HOOD(NODISCARD) size_t calcNumBytesTotal(size_t numElements) const {
+#if ROBIN_HOOD(BITNESS) == 64
+        return numElements * sizeof(Node) + calcNumBytesInfo(numElements);
+#else
+        // make sure we're doing 64bit operations, so we are at least safe against 32bit overflows.
+        auto const ne = static_cast<uint64_t>(numElements);
+        auto const s = static_cast<uint64_t>(sizeof(Node));
+        auto const infos = static_cast<uint64_t>(calcNumBytesInfo(numElements));
+
+        auto const total64 = ne * s + infos;
+        auto const total = static_cast<size_t>(total64);
+
+        if (ROBIN_HOOD_UNLIKELY(static_cast<uint64_t>(total) != total64)) {
+            throwOverflowError();
+        }
+        return total;
+#endif
+    }
+
+private:
+    template <typename Q = mapped_type>
+    ROBIN_HOOD(NODISCARD)
+    typename std::enable_if<!std::is_void<Q>::value, bool>::type has(const value_type& e) const {
+        ROBIN_HOOD_TRACE(this)
+        auto it = find(e.first);
+        return it != end() && it->second == e.second;
+    }
+
+    template <typename Q = mapped_type>
+    ROBIN_HOOD(NODISCARD)
+    typename std::enable_if<std::is_void<Q>::value, bool>::type has(const value_type& e) const {
+        ROBIN_HOOD_TRACE(this)
+        return find(e) != end();
+    }
+
+    void reserve(size_t c, bool forceRehash) {
+        ROBIN_HOOD_TRACE(this)
+        auto const minElementsAllowed = (std::max)(c, mNumElements);
+        auto newSize = InitialNumElements;
+        while (calcMaxNumElementsAllowed(newSize) < minElementsAllowed && newSize != 0) {
+            newSize *= 2;
+        }
+        if (ROBIN_HOOD_UNLIKELY(newSize == 0)) {
+            throwOverflowError();
+        }
+
+        ROBIN_HOOD_LOG("newSize > mMask + 1: " << newSize << " > " << mMask << " + 1")
+
+        // only actually do anything when the new size is bigger than the old one. This prevents to
+        // continuously allocate for each reserve() call.
+        if (forceRehash || newSize > mMask + 1) {
+            rehashPowerOfTwo(newSize, false);
+        }
+    }
+
+    // reserves space for at least the specified number of elements.
+    // only works if numBuckets if power of two
+    // True on success, false otherwise
+    void rehashPowerOfTwo(size_t numBuckets, bool forceFree) {
+        ROBIN_HOOD_TRACE(this)
+
+        Node* const oldKeyVals = mKeyVals;
+        uint8_t const* const oldInfo = mInfo;
+
+        const size_t oldMaxElementsWithBuffer = calcNumElementsWithBuffer(mMask + 1);
+
+        // resize operation: move stuff
+        initData(numBuckets);
+        if (oldMaxElementsWithBuffer > 1) {
+            for (size_t i = 0; i < oldMaxElementsWithBuffer; ++i) {
+                if (oldInfo[i] != 0) {
+                    // might throw an exception, which is really bad since we are in the middle of
+                    // moving stuff.
+                    insert_move(std::move(oldKeyVals[i]));
+                    // destroy the node but DON'T destroy the data.
+                    oldKeyVals[i].~Node();
+                }
+            }
+
+            // this check is not necessary as it's guarded by the previous if, but it helps
+            // silence g++'s overeager "attempt to free a non-heap object 'map'
+            // [-Werror=free-nonheap-object]" warning.
+            if (oldKeyVals != reinterpret_cast_no_cast_align_warning<Node*>(&mMask)) {
+                // don't destroy old data: put it into the pool instead
+                if (forceFree) {
+                    std::free(oldKeyVals);
+                } else {
+                    DataPool::addOrFree(oldKeyVals, calcNumBytesTotal(oldMaxElementsWithBuffer));
+                }
+            }
+        }
+    }
+
+    ROBIN_HOOD(NOINLINE) void throwOverflowError() const {
+#if ROBIN_HOOD(HAS_EXCEPTIONS)
+        throw std::overflow_error("robin_hood::map overflow");
+#else
+        abort();
+#endif
+    }
+
+    template <typename OtherKey, typename... Args>
+    std::pair<iterator, bool> try_emplace_impl(OtherKey&& key, Args&&... args) {
+        ROBIN_HOOD_TRACE(this)
+        auto idxAndState = insertKeyPrepareEmptySpot(key);
+        switch (idxAndState.second) {
+        case InsertionState::key_found:
+            break;
+
+        case InsertionState::new_node:
+            ::new (static_cast<void*>(&mKeyVals[idxAndState.first])) Node(
+                *this, std::piecewise_construct, std::forward_as_tuple(std::forward<OtherKey>(key)),
+                std::forward_as_tuple(std::forward<Args>(args)...));
+            break;
+
+        case InsertionState::overwrite_node:
+            mKeyVals[idxAndState.first] = Node(*this, std::piecewise_construct,
+                                               std::forward_as_tuple(std::forward<OtherKey>(key)),
+                                               std::forward_as_tuple(std::forward<Args>(args)...));
+            break;
+
+        case InsertionState::overflow_error:
+            throwOverflowError();
+            break;
+        }
+
+        return std::make_pair(iterator(mKeyVals + idxAndState.first, mInfo + idxAndState.first),
+                              InsertionState::key_found != idxAndState.second);
+    }
+
+    template <typename OtherKey, typename Mapped>
+    std::pair<iterator, bool> insertOrAssignImpl(OtherKey&& key, Mapped&& obj) {
+        ROBIN_HOOD_TRACE(this)
+        auto idxAndState = insertKeyPrepareEmptySpot(key);
+        switch (idxAndState.second) {
+        case InsertionState::key_found:
+            mKeyVals[idxAndState.first].getSecond() = std::forward<Mapped>(obj);
+            break;
+
+        case InsertionState::new_node:
+            ::new (static_cast<void*>(&mKeyVals[idxAndState.first])) Node(
+                *this, std::piecewise_construct, std::forward_as_tuple(std::forward<OtherKey>(key)),
+                std::forward_as_tuple(std::forward<Mapped>(obj)));
+            break;
+
+        case InsertionState::overwrite_node:
+            mKeyVals[idxAndState.first] = Node(*this, std::piecewise_construct,
+                                               std::forward_as_tuple(std::forward<OtherKey>(key)),
+                                               std::forward_as_tuple(std::forward<Mapped>(obj)));
+            break;
+
+        case InsertionState::overflow_error:
+            throwOverflowError();
+            break;
+        }
+
+        return std::make_pair(iterator(mKeyVals + idxAndState.first, mInfo + idxAndState.first),
+                              InsertionState::key_found != idxAndState.second);
+    }
+
+    void initData(size_t max_elements) {
+        mNumElements = 0;
+        mMask = max_elements - 1;
+        mMaxNumElementsAllowed = calcMaxNumElementsAllowed(max_elements);
+
+        auto const numElementsWithBuffer = calcNumElementsWithBuffer(max_elements);
+
+        // malloc & zero mInfo. Faster than calloc everything.
+        auto const numBytesTotal = calcNumBytesTotal(numElementsWithBuffer);
+        ROBIN_HOOD_LOG("std::calloc " << numBytesTotal << " = calcNumBytesTotal("
+                                      << numElementsWithBuffer << ")")
+        mKeyVals = reinterpret_cast<Node*>(
+            detail::assertNotNull<std::bad_alloc>(std::malloc(numBytesTotal)));
+        mInfo = reinterpret_cast<uint8_t*>(mKeyVals + numElementsWithBuffer);
+        std::memset(mInfo, 0, numBytesTotal - numElementsWithBuffer * sizeof(Node));
+
+        // set sentinel
+        mInfo[numElementsWithBuffer] = 1;
+
+        mInfoInc = InitialInfoInc;
+        mInfoHashShift = InitialInfoHashShift;
+    }
+
+    enum class InsertionState { overflow_error, key_found, new_node, overwrite_node };
+
+    // Finds key, and if not already present prepares a spot where to pot the key & value.
+    // This potentially shifts nodes out of the way, updates mInfo and number of inserted
+    // elements, so the only operation left to do is create/assign a new node at that spot.
+    template <typename OtherKey>
+    std::pair<size_t, InsertionState> insertKeyPrepareEmptySpot(OtherKey&& key) {
+        for (int i = 0; i < 256; ++i) {
+            size_t idx{};
+            InfoType info{};
+            keyToIdx(key, &idx, &info);
+            nextWhileLess(&info, &idx);
+
+            // while we potentially have a match
+            while (info == mInfo[idx]) {
+                if (WKeyEqual::operator()(key, mKeyVals[idx].getFirst())) {
+                    // key already exists, do NOT insert.
+                    // see http://en.cppreference.com/w/cpp/container/unordered_map/insert
+                    return std::make_pair(idx, InsertionState::key_found);
+                }
+                next(&info, &idx);
+            }
+
+            // unlikely that this evaluates to true
+            if (ROBIN_HOOD_UNLIKELY(mNumElements >= mMaxNumElementsAllowed)) {
+                if (!increase_size()) {
+                    return std::make_pair(size_t(0), InsertionState::overflow_error);
+                }
+                continue;
+            }
+
+            // key not found, so we are now exactly where we want to insert it.
+            auto const insertion_idx = idx;
+            auto const insertion_info = info;
+            if (ROBIN_HOOD_UNLIKELY(insertion_info + mInfoInc > 0xFF)) {
+                mMaxNumElementsAllowed = 0;
+            }
+
+            // find an empty spot
+            while (0 != mInfo[idx]) {
+                next(&info, &idx);
+            }
+
+            if (idx != insertion_idx) {
+                shiftUp(idx, insertion_idx);
+            }
+            // put at empty spot
+            mInfo[insertion_idx] = static_cast<uint8_t>(insertion_info);
+            ++mNumElements;
+            return std::make_pair(insertion_idx, idx == insertion_idx
+                                                     ? InsertionState::new_node
+                                                     : InsertionState::overwrite_node);
+        }
+
+        // enough attempts failed, so finally give up.
+        return std::make_pair(size_t(0), InsertionState::overflow_error);
+    }
+
+    bool try_increase_info() {
+        ROBIN_HOOD_LOG("mInfoInc=" << mInfoInc << ", numElements=" << mNumElements
+                                   << ", maxNumElementsAllowed="
+                                   << calcMaxNumElementsAllowed(mMask + 1))
+        if (mInfoInc <= 2) {
+            // need to be > 2 so that shift works (otherwise undefined behavior!)
+            return false;
+        }
+        // we got space left, try to make info smaller
+        mInfoInc = static_cast<uint8_t>(mInfoInc >> 1U);
+
+        // remove one bit of the hash, leaving more space for the distance info.
+        // This is extremely fast because we can operate on 8 bytes at once.
+        ++mInfoHashShift;
+        auto const numElementsWithBuffer = calcNumElementsWithBuffer(mMask + 1);
+
+        for (size_t i = 0; i < numElementsWithBuffer; i += 8) {
+            auto val = unaligned_load<uint64_t>(mInfo + i);
+            val = (val >> 1U) & UINT64_C(0x7f7f7f7f7f7f7f7f);
+            std::memcpy(mInfo + i, &val, sizeof(val));
+        }
+        // update sentinel, which might have been cleared out!
+        mInfo[numElementsWithBuffer] = 1;
+
+        mMaxNumElementsAllowed = calcMaxNumElementsAllowed(mMask + 1);
+        return true;
+    }
+
+    // True if resize was possible, false otherwise
+    bool increase_size() {
+        // nothing allocated yet? just allocate InitialNumElements
+        if (0 == mMask) {
+            initData(InitialNumElements);
+            return true;
+        }
+
+        auto const maxNumElementsAllowed = calcMaxNumElementsAllowed(mMask + 1);
+        if (mNumElements < maxNumElementsAllowed && try_increase_info()) {
+            return true;
+        }
+
+        ROBIN_HOOD_LOG("mNumElements=" << mNumElements << ", maxNumElementsAllowed="
+                                       << maxNumElementsAllowed << ", load="
+                                       << (static_cast<double>(mNumElements) * 100.0 /
+                                           (static_cast<double>(mMask) + 1)))
+
+        if (mNumElements * 2 < calcMaxNumElementsAllowed(mMask + 1)) {
+            // we have to resize, even though there would still be plenty of space left!
+            // Try to rehash instead. Delete freed memory so we don't steadyily increase mem in case
+            // we have to rehash a few times
+            nextHashMultiplier();
+            rehashPowerOfTwo(mMask + 1, true);
+        } else {
+            // we've reached the capacity of the map, so the hash seems to work nice. Keep using it.
+            rehashPowerOfTwo((mMask + 1) * 2, false);
+        }
+        return true;
+    }
+
+    void nextHashMultiplier() {
+        // adding an *even* number, so that the multiplier will always stay odd. This is necessary
+        // so that the hash stays a mixing function (and thus doesn't have any information loss).
+        mHashMultiplier += UINT64_C(0xc4ceb9fe1a85ec54);
+    }
+
+    void destroy() {
+        if (0 == mMask) {
+            // don't deallocate!
+            return;
+        }
+
+        Destroyer<Self, IsFlat && std::is_trivially_destructible<Node>::value>{}
+            .nodesDoNotDeallocate(*this);
+
+        // This protection against not deleting mMask shouldn't be needed as it's sufficiently
+        // protected with the 0==mMask check, but I have this anyways because g++ 7 otherwise
+        // reports a compile error: attempt to free a non-heap object 'fm'
+        // [-Werror=free-nonheap-object]
+        if (mKeyVals != reinterpret_cast_no_cast_align_warning<Node*>(&mMask)) {
+            ROBIN_HOOD_LOG("std::free")
+            std::free(mKeyVals);
+        }
+    }
+
+    void init() noexcept {
+        mKeyVals = reinterpret_cast_no_cast_align_warning<Node*>(&mMask);
+        mInfo = reinterpret_cast<uint8_t*>(&mMask);
+        mNumElements = 0;
+        mMask = 0;
+        mMaxNumElementsAllowed = 0;
+        mInfoInc = InitialInfoInc;
+        mInfoHashShift = InitialInfoHashShift;
+    }
+
+    // members are sorted so no padding occurs
+    uint64_t mHashMultiplier = UINT64_C(0xc4ceb9fe1a85ec53);                // 8 byte  8
+    Node* mKeyVals = reinterpret_cast_no_cast_align_warning<Node*>(&mMask); // 8 byte 16
+    uint8_t* mInfo = reinterpret_cast<uint8_t*>(&mMask);                    // 8 byte 24
+    size_t mNumElements = 0;                                                // 8 byte 32
+    size_t mMask = 0;                                                       // 8 byte 40
+    size_t mMaxNumElementsAllowed = 0;                                      // 8 byte 48
+    InfoType mInfoInc = InitialInfoInc;                                     // 4 byte 52
+    InfoType mInfoHashShift = InitialInfoHashShift;                         // 4 byte 56
+                                                    // 16 byte 56 if NodeAllocator
+};
+
+} // namespace detail
+
+// map
+
+template <typename Key, typename T, typename Hash = hash<Key>,
+          typename KeyEqual = std::equal_to<Key>, size_t MaxLoadFactor100 = 80>
+using unordered_flat_map = detail::Table<true, MaxLoadFactor100, Key, T, Hash, KeyEqual>;
+
+template <typename Key, typename T, typename Hash = hash<Key>,
+          typename KeyEqual = std::equal_to<Key>, size_t MaxLoadFactor100 = 80>
+using unordered_node_map = detail::Table<false, MaxLoadFactor100, Key, T, Hash, KeyEqual>;
+
+template <typename Key, typename T, typename Hash = hash<Key>,
+          typename KeyEqual = std::equal_to<Key>, size_t MaxLoadFactor100 = 80>
+using unordered_map =
+    detail::Table<sizeof(robin_hood::pair<Key, T>) <= sizeof(size_t) * 6 &&
+                      std::is_nothrow_move_constructible<robin_hood::pair<Key, T>>::value &&
+                      std::is_nothrow_move_assignable<robin_hood::pair<Key, T>>::value,
+                  MaxLoadFactor100, Key, T, Hash, KeyEqual>;
+
+// set
+
+template <typename Key, typename Hash = hash<Key>, typename KeyEqual = std::equal_to<Key>,
+          size_t MaxLoadFactor100 = 80>
+using unordered_flat_set = detail::Table<true, MaxLoadFactor100, Key, void, Hash, KeyEqual>;
+
+template <typename Key, typename Hash = hash<Key>, typename KeyEqual = std::equal_to<Key>,
+          size_t MaxLoadFactor100 = 80>
+using unordered_node_set = detail::Table<false, MaxLoadFactor100, Key, void, Hash, KeyEqual>;
+
+template <typename Key, typename Hash = hash<Key>, typename KeyEqual = std::equal_to<Key>,
+          size_t MaxLoadFactor100 = 80>
+using unordered_set = detail::Table<sizeof(Key) <= sizeof(size_t) * 6 &&
+                                        std::is_nothrow_move_constructible<Key>::value &&
+                                        std::is_nothrow_move_assignable<Key>::value,
+                                    MaxLoadFactor100, Key, void, Hash, KeyEqual>;
+
+} // namespace robin_hood
+
+#endif
diff --git a/src/Flf/Archive.cc b/src/Flf/Archive.cc
index 506f26a44..f7160cd04 100644
--- a/src/Flf/Archive.cc
+++ b/src/Flf/Archive.cc
@@ -217,7 +217,8 @@ class LatticeArchiveReaderNode : public Node {
 
 public:
     LatticeArchiveReaderNode(const std::string& name, const Core::Configuration& config)
-            : Precursor(name, config), reader_(0) {}
+            : Precursor(name, config),
+              reader_(0) {}
     virtual ~LatticeArchiveReaderNode() {}
 
     virtual void init(const std::vector<std::string>& arguments) {
@@ -285,7 +286,8 @@ class LatticeArchiveWriterNode : public Node {
 
 public:
     LatticeArchiveWriterNode(const std::string& name, const Core::Configuration& config)
-            : Precursor(name, config), writer_(0) {}
+            : Precursor(name, config),
+              writer_(0) {}
     virtual ~LatticeArchiveWriterNode() {}
 
     virtual void init(const std::vector<std::string>& arguments) {
@@ -407,7 +409,8 @@ ConfusionNetworkArchive::ConfusionNetworkArchive(
         const Core::Configuration& config,
         const std::string&         pathname,
         CnFormat                   format)
-        : Precursor(config, pathname), format(format) {
+        : Precursor(config, pathname),
+          format(format) {
     encoding = paramEncoding(config);
 }
 
@@ -586,7 +589,8 @@ class ConfusionNetworkArchiveReaderNode : public Node {
 
 public:
     ConfusionNetworkArchiveReaderNode(const std::string& name, const Core::Configuration& config)
-            : Precursor(name, config), archiveReader_(0) {
+            : Precursor(name, config),
+              archiveReader_(0) {
         isValid_ = false;
     }
     virtual ~ConfusionNetworkArchiveReaderNode() {}
@@ -644,7 +648,8 @@ class ConfusionNetworkArchiveWriterNode : public Node {
 
 public:
     ConfusionNetworkArchiveWriterNode(const std::string& name, const Core::Configuration& config)
-            : Precursor(name, config), archiveWriter_(0) {}
+            : Precursor(name, config),
+              archiveWriter_(0) {}
     virtual ~ConfusionNetworkArchiveWriterNode() {}
     virtual void init(const std::vector<std::string>& arguments) {
         if (!connected(0))
@@ -706,7 +711,8 @@ PosteriorCnArchive::PosteriorCnArchive(
         const Core::Configuration& config,
         const std::string&         pathname,
         PosteriorCnFormat          format)
-        : Precursor(config, pathname), format(format) {
+        : Precursor(config, pathname),
+          format(format) {
     encoding = paramEncoding(config);
 }
 
@@ -884,7 +890,8 @@ class PosteriorCnArchiveReaderNode : public Node {
 
 public:
     PosteriorCnArchiveReaderNode(const std::string& name, const Core::Configuration& config)
-            : Precursor(name, config), archiveReader_(0) {
+            : Precursor(name, config),
+              archiveReader_(0) {
         isValid_ = false;
     }
     virtual ~PosteriorCnArchiveReaderNode() {}
@@ -946,7 +953,9 @@ class PosteriorCnArchiveWriterNode : public Node {
 
 public:
     PosteriorCnArchiveWriterNode(const std::string& name, const Core::Configuration& config)
-            : Precursor(name, config), archiveWriter_(0), flowCache_(0) {}
+            : Precursor(name, config),
+              archiveWriter_(0),
+              flowCache_(0) {}
     virtual ~PosteriorCnArchiveWriterNode() {
         delete archiveWriter_;
         delete flowCache_;
diff --git a/src/Flf/Best.cc b/src/Flf/Best.cc
index 950d40eb8..a6225cdb9 100644
--- a/src/Flf/Best.cc
+++ b/src/Flf/Best.cc
@@ -192,9 +192,11 @@ struct StateIdPair : public std::pair<Fsa::StateId, Fsa::StateId> {
     typedef std::pair<Fsa::StateId, Fsa::StateId> Precursor;
     StateIdPair(Fsa::StateId first, Fsa::StateId second)
             : Precursor(first, second) {}
+
     struct Hash : public std::hash<Fsa::StateId> {
         typedef std::hash<Fsa::StateId> Precursor;
-        size_t                          operator()(const StateIdPair& pair) const {
+
+        size_t operator()(const StateIdPair& pair) const {
             return Precursor::operator()(pair.first | ~pair.second);
         }
     };
@@ -213,7 +215,8 @@ class AllPairsShortestDistance::Internal : public std::unordered_map<StateIdPair
 
 public:
     Internal()
-            : Precursor(), distance_(0) {}
+            : Precursor(),
+              distance_(0) {}
     ~Internal() {
         delete[] distance_;
     }
@@ -265,7 +268,8 @@ struct StateIdScorePair {
     Fsa::StateId sid;
     Score        score;
     StateIdScorePair(Fsa::StateId sid, Score score)
-            : sid(sid), score(score) {}
+            : sid(sid),
+              score(score) {}
     bool operator<(const StateIdScorePair& pair) const {
         return sid < pair.sid;
     }
@@ -346,7 +350,9 @@ class DumpAllPairsShortestDistanceNode : public FilterNode {
 
 public:
     DumpAllPairsShortestDistanceNode(const std::string& name, const Core::Configuration& config)
-            : Precursor(name, config), dump_(config, "dump"), hasDumped_(false) {}
+            : Precursor(name, config),
+              dump_(config, "dump"),
+              hasDumped_(false) {}
     ~DumpAllPairsShortestDistanceNode() {}
     virtual void init(const std::vector<std::string>& arguments) {
         f32 tmp = paramTimeThreshold(config);
diff --git a/src/Flf/CenterFrameConfusionNetworkBuilder.cc b/src/Flf/CenterFrameConfusionNetworkBuilder.cc
index 1f19125b0..0228b8bda 100644
--- a/src/Flf/CenterFrameConfusionNetworkBuilder.cc
+++ b/src/Flf/CenterFrameConfusionNetworkBuilder.cc
@@ -120,7 +120,8 @@ class CenterFrameCn : public Core::ReferenceCounted {
 
     public:
         StateIndexBuilder(ConstLatticeRef l, Core::Vector<Fsa::StateId>& stateIndex)
-                : TraverseState(l), stateIndex(stateIndex) {}
+                : TraverseState(l),
+                  stateIndex(stateIndex) {}
 
         void build() {
             if (l->getTopologicalSort())
@@ -469,7 +470,8 @@ class CenterFrameCnBuilder : public Core::ReferenceCounted {
         Properties props;
         IdList     arcIds;
         Frame()
-                : t(0.0), updated(true) {}
+                : t(0.0),
+                  updated(true) {}
     };
     typedef std::vector<Frame> FrameList;
 
@@ -718,7 +720,9 @@ class CenterFrameCnBuilder : public Core::ReferenceCounted {
     }
 
     CenterFrameCnBuilder()
-            : staticL_(0), staticB_(0), feCn_(0) {}
+            : staticL_(0),
+              staticB_(0),
+              feCn_(0) {}
 
 public:
     ~CenterFrameCnBuilder() {}
@@ -911,7 +915,8 @@ class CenterFrameCnBuilderNode : public Node {
 
 public:
     CenterFrameCnBuilderNode(const std::string& name, const Core::Configuration& config)
-            : Node(name, config), n_(0) {
+            : Node(name, config),
+              n_(0) {
         confidenceId_ = Semiring::InvalidId;
     }
     virtual ~CenterFrameCnBuilderNode() {}
diff --git a/src/Flf/Combination.cc b/src/Flf/Combination.cc
index 774801845..379a2a883 100644
--- a/src/Flf/Combination.cc
+++ b/src/Flf/Combination.cc
@@ -31,7 +31,8 @@ class SemiringCombinationHelper::Internal {
 
 public:
     Internal(const KeyList& comboKeys, const ScoreList& comboScales)
-            : comboKeys(comboKeys), comboScales(comboScales) {}
+            : comboKeys(comboKeys),
+              comboScales(comboScales) {}
     virtual ~Internal() {}
 
     virtual bool update(const ConstSemiringRefList& semirings) = 0;
diff --git a/src/Flf/Compose.cc b/src/Flf/Compose.cc
index 0480d73d5..18c77071f 100644
--- a/src/Flf/Compose.cc
+++ b/src/Flf/Compose.cc
@@ -41,7 +41,9 @@ class UnweightLattice : public SlaveLattice {
 
 public:
     UnweightLattice(ConstLatticeRef l, ConstSemiringRef semiring)
-            : Precursor(l), semiring_(semiring), one_(semiring->one()) {
+            : Precursor(l),
+              semiring_(semiring),
+              one_(semiring->one()) {
         setBoundaries(InvalidBoundaries);
     }
     virtual ~UnweightLattice() {}
diff --git a/src/Flf/Concatenate.cc b/src/Flf/Concatenate.cc
index 6b88a2ec5..0c2f0b4c3 100644
--- a/src/Flf/Concatenate.cc
+++ b/src/Flf/Concatenate.cc
@@ -45,7 +45,10 @@ struct BoundedSegment {
     Time                 offset;
     s32                  startFrame, endFrame;
     BoundedSegment()
-            : segment(), offset(0), startFrame(Core::Type<s32>::max), endFrame(Core::Type<s32>::max) {}
+            : segment(),
+              offset(0),
+              startFrame(Core::Type<s32>::max),
+              endFrame(Core::Type<s32>::max) {}
 };
 typedef std::vector<BoundedSegment> BoundedSegmentList;
 s32                                 startFrame, endFrame;
@@ -227,7 +230,8 @@ class ConcatenateNode : public Node {
 
 public:
     ConcatenateNode(const std::string& name, const Core::Configuration& config)
-            : Node(name, config), dump_(config, "dump") {}
+            : Node(name, config),
+              dump_(config, "dump") {}
     virtual ~ConcatenateNode() {}
 
     virtual ConstSegmentRef sendSegment(Port to) {
@@ -346,7 +350,11 @@ class ConcatenateLatticesNode : public ConcatenateNode {
 
     public:
         ConcatenatedLatticeBuilder()
-                : s_(0), b_(0), maxSid_(0), finalSid_(0), endTime_(0) {}
+                : s_(0),
+                  b_(0),
+                  maxSid_(0),
+                  finalSid_(0),
+                  endTime_(0) {}
         ~ConcatenatedLatticeBuilder() {
             delete s_;
         }
@@ -383,7 +391,8 @@ class ConcatenateLatticesNode : public ConcatenateNode {
 
 public:
     ConcatenateLatticesNode(const std::string& name, const Core::Configuration& config)
-            : Precursor(name, config), reader_(0) {}
+            : Precursor(name, config),
+              reader_(0) {}
     virtual ~ConcatenateLatticesNode() {}
 
     virtual void init(const std::vector<std::string>& arguments) {
@@ -466,7 +475,8 @@ class ConcatenateFCnsNode : public ConcatenateNode {
 
 public:
     ConcatenateFCnsNode(const std::string& name, const Core::Configuration& config)
-            : Precursor(name, config), reader_(0) {}
+            : Precursor(name, config),
+              reader_(0) {}
     virtual ~ConcatenateFCnsNode() {}
 
     virtual void init(const std::vector<std::string>& arguments) {
diff --git a/src/Flf/ConfusionNetworkCombination.cc b/src/Flf/ConfusionNetworkCombination.cc
index bb717cd69..e81eb858f 100644
--- a/src/Flf/ConfusionNetworkCombination.cc
+++ b/src/Flf/ConfusionNetworkCombination.cc
@@ -51,7 +51,8 @@ class ConfusionNetworkAlignment {
 
     public:
         Cost()
-                : refPtr_(0), hypPtr_(0) {}
+                : refPtr_(0),
+                  hypPtr_(0) {}
         virtual ~Cost() {}
         // called before the alignment of ref and hyp starts, i.e. before the first call to the cost functions
         virtual void init(const ConfusionNetwork& ref, const ConfusionNetwork& hyp) const {
@@ -499,7 +500,12 @@ class ConfusionNetworkCombination : public ConfusionNetworkAlignment, public Cor
 
     public:
         WeightedCost()
-                : refWeight(0.5), hypWeight(0.5), refNorm(1.0), hypNorm(1.0), refNormedWeight(0.5), hypNormedWeight(0.5) {}
+                : refWeight(0.5),
+                  hypWeight(0.5),
+                  refNorm(1.0),
+                  hypNorm(1.0),
+                  refNormedWeight(0.5),
+                  hypNormedWeight(0.5) {}
         virtual ~WeightedCost() {}
         void setPosteriorIds(ScoreId refPosteriorId, ScoreId hypPosteriorId) {
             verify((refPosteriorId != Semiring::InvalidId) && (hypPosteriorId != Semiring::InvalidId));
@@ -1102,7 +1108,9 @@ class RoverCombination : public ConfusionNetworkAlignment, public Core::Referenc
 
     public:
         NistScliteCost(std::string null = "@")
-                : Precursor(), null(null), nullLabel(Fsa::Epsilon) {}
+                : Precursor(),
+                  null(null),
+                  nullLabel(Fsa::Epsilon) {}
 
         void setAlphabet(Fsa::ConstAlphabetRef alphabet) {
             this->alphabet = alphabet;
@@ -1229,14 +1237,12 @@ class RoverCombination : public ConfusionNetworkAlignment, public Core::Referenc
         virtual Score delCost(u32 refId) const {
             const ConfusionNetwork::Slot& ref = refSlot(refId);
             verify(!ref.empty());
-            Score        cost = Infinity, tmpCost = 0.0;
-            Fsa::LabelId label = Fsa::InvalidLabelId;
+            Score cost = Infinity, tmpCost = 0.0;
             for (ConfusionNetwork::Slot::const_iterator itRef = ref.begin(), endRef = ref.end(); itRef != endRef; ++itRef) {
                 const ConfusionNetwork::Arc& refArc = *itRef;
                 tmpCost                             = (refArc.label == Fsa::Epsilon) ? 0.002 : Score(refArc.duration) / 100.0 + 0.003;
                 if (tmpCost < cost) {
-                    label = refArc.label;
-                    cost  = tmpCost;
+                    cost = tmpCost;
                 }
             }
             return cost;
@@ -1251,8 +1257,7 @@ class RoverCombination : public ConfusionNetworkAlignment, public Core::Referenc
                 cost = delCost(refId) - 0.001;
             }
             else {
-                Score        tmpCost = 0.0;
-                Fsa::LabelId label   = Fsa::InvalidLabelId;
+                Score tmpCost = 0.0;
                 for (ConfusionNetwork::Slot::const_iterator itRef = ref.begin(), endRef = ref.end(); itRef != endRef; ++itRef) {
                     const ConfusionNetwork::Arc& refArc = *itRef;
                     if (refArc.label != Fsa::Epsilon) {
@@ -1266,8 +1271,7 @@ class RoverCombination : public ConfusionNetworkAlignment, public Core::Referenc
                         if (refArc.label != hypArc.label)
                             tmpCost += 0.001;
                         if (tmpCost < cost) {
-                            label = refArc.label;
-                            cost  = tmpCost;
+                            cost = tmpCost;
                         }
                     }
                 }
@@ -1844,7 +1848,8 @@ class OracleAlignment : public ConfusionNetworkAlignment, public Core::Reference
 
     public:
         WeightedOracleCost(f64 alpha)
-                : PosteriorCost(), alpha_(alpha) {}
+                : PosteriorCost(),
+                  alpha_(alpha) {}
 
         virtual std::string describe() const {
             return Core::form("weighted-oracle-cost(alpha=%.2f)", alpha_);
diff --git a/src/Flf/ConfusionNetworkIo.cc b/src/Flf/ConfusionNetworkIo.cc
index 282e3dd1d..2461acbe1 100644
--- a/src/Flf/ConfusionNetworkIo.cc
+++ b/src/Flf/ConfusionNetworkIo.cc
@@ -48,7 +48,9 @@ class CnSortingIterator {
 
 private:
     CnSortingIterator(ConstConfusionNetworkRef cn)
-            : cn_(cn), posteriorId_(Semiring::InvalidId), slot_(0) {
+            : cn_(cn),
+              posteriorId_(Semiring::InvalidId),
+              slot_(0) {
         verify(cn);
         if (cn->isNormalized()) {
             posteriorId_ = cn->normalizedProperties->posteriorId;
@@ -428,7 +430,8 @@ class ConfusionNetworkXmlParser : public Core::XmlSchemaParser {
 
 public:
     ConfusionNetworkXmlParser(const Core::Configuration& config)
-            : Precursor(config), cn_(0) {
+            : Precursor(config),
+              cn_(0) {
         oracleAlignment_                     = 0;
         semiringXmlElement_                  = Semiring::xmlElement(this);
         oracleSemiringXmlElement_            = Semiring::xmlElement(this);
diff --git a/src/Flf/Convert.cc b/src/Flf/Convert.cc
index 992555723..a1c4c5505 100644
--- a/src/Flf/Convert.cc
+++ b/src/Flf/Convert.cc
@@ -32,14 +32,15 @@ class SymbolicMapping : public std::vector<KeyList> {
             : Precursor(capacity) {}
 
     static const Core::ParameterStringVector paramRow;
-    static SymbolicMapping                   loadSymbolicMapping(const Core::Configuration& config, ConstSemiringRef target) {
+
+    static SymbolicMapping loadSymbolicMapping(const Core::Configuration& config, ConstSemiringRef target) {
         SymbolicMapping           symbolicMapping(target->size());
         SymbolicMapping::iterator itSymbolicMapping = symbolicMapping.begin();
         for (KeyList::const_iterator itKey = target->keys().begin();
              itKey != target->keys().end(); ++itKey, ++itSymbolicMapping) {
             if (itKey->empty())
                 Core::Application::us()->warning("Dimension with no symbolic identifier in \"%s\"",
-                                                                   target->name().c_str());
+                                                 target->name().c_str());
             else
                 *itSymbolicMapping = paramRow(Core::Configuration(config, *itKey));
         }
@@ -57,7 +58,8 @@ class MappingBuilder {
 
 public:
     MappingBuilder(ConstSemiringRef source, ConstSemiringRef target)
-            : source_(source), target_(target) {}
+            : source_(source),
+              target_(target) {}
 
     ProjectionMatrix buildLinearMapping(ScoreId offset = 0, bool scaled = true) const {
         ProjectionMatrix           scaledMapping(target_->size());
@@ -114,7 +116,9 @@ class ProjectSemiringLattice : public ModifyLattice {
 
 public:
     ProjectSemiringLattice(ConstLatticeRef l, ConstSemiringRef targetSemiring, const ProjectionMatrix& mapping)
-            : Precursor(l), semiring_(targetSemiring), mapping_(mapping) {}
+            : Precursor(l),
+              semiring_(targetSemiring),
+              mapping_(mapping) {}
     virtual ~ProjectSemiringLattice() {}
 
     virtual ConstSemiringRef semiring() const {
@@ -240,7 +244,9 @@ class FsaToLattice : public Lattice {
 
     public:
         WeightToScoresMap(ConstSemiringRef semiring, ScoreId id, ScoresRef scores)
-                : semiring_(semiring), id_(id), scores_(scores) {
+                : semiring_(semiring),
+                  id_(id),
+                  scores_(scores) {
             verify(id < semiring->size());
         }
         virtual ScoresRef operator()(Fsa::Weight w) const {
@@ -274,7 +280,12 @@ class FsaToLattice : public Lattice {
     FsaToLattice(Fsa::ConstAutomatonRef fsa,
                  ConstSemiringRef semiring, WeightMapRef weightMap,
                  Lexicon::AlphabetMapRef inputMap, Lexicon::AlphabetMapRef outputMap)
-            : fsa_(fsa), isAcceptor_(fsa->type() == Fsa::TypeAcceptor), semiring_(semiring), weightMap_(weightMap), inputMap_(inputMap), outputMap_(outputMap) {
+            : fsa_(fsa),
+              isAcceptor_(fsa->type() == Fsa::TypeAcceptor),
+              semiring_(semiring),
+              weightMap_(weightMap),
+              inputMap_(inputMap),
+              outputMap_(outputMap) {
         setProperties(fsa->knownProperties(), fsa->properties());
     }
 
diff --git a/src/Flf/Copy.cc b/src/Flf/Copy.cc
index d8083fa51..31402d281 100644
--- a/src/Flf/Copy.cc
+++ b/src/Flf/Copy.cc
@@ -264,7 +264,9 @@ class BoundariesCopyBuilder : public TraverseState {
 
 public:
     BoundariesCopyBuilder(ConstLatticeRef l, StaticBoundaries* staticBoundaries)
-            : Precursor(l), boundaries_(l->getBoundaries()), staticBoundaries_(staticBoundaries) {
+            : Precursor(l),
+              boundaries_(l->getBoundaries()),
+              staticBoundaries_(staticBoundaries) {
         staticBoundaries->clear();
         traverse();
     }
diff --git a/src/Flf/CorpusProcessor.cc b/src/Flf/CorpusProcessor.cc
index 5aff35a30..69488dd76 100644
--- a/src/Flf/CorpusProcessor.cc
+++ b/src/Flf/CorpusProcessor.cc
@@ -89,7 +89,8 @@ void CorpusProcessor::processSpeechSegment(Bliss::SpeechSegment* segment) {
 
 // -------------------------------------------------------------------------
 SpeechSegmentNode::SpeechSegmentNode(const std::string& name, const Core::Configuration& config)
-        : Node(name, config), blissSpeechSegment_(0) {}
+        : Node(name, config),
+          blissSpeechSegment_(0) {}
 
 void SpeechSegmentNode::init(const std::vector<std::string>& arguments) {
     if (!in().empty())
diff --git a/src/Flf/CorpusProcessor.hh b/src/Flf/CorpusProcessor.hh
index 14606a24c..c01e94d21 100644
--- a/src/Flf/CorpusProcessor.hh
+++ b/src/Flf/CorpusProcessor.hh
@@ -60,15 +60,19 @@ public:
     SpeechSegmentNode(const std::string& name, const Core::Configuration& config);
     virtual void init(const std::vector<std::string>& arguments);
     virtual void sync();
-    bool         synced() const {
+
+    bool synced() const {
         return !blissSpeechSegment_;
     }
+
     virtual bool good() {
         return true;
     }
+
     void setSpeechSegment(Bliss::SpeechSegment* blissSpeechSegment) {
         blissSpeechSegment_ = blissSpeechSegment;
     }
+
     virtual ConstSegmentRef sendSegment(Port to);
     virtual const void*     sendData(Port to);
 };
diff --git a/src/Flf/Determinize.cc b/src/Flf/Determinize.cc
index 814cea05c..659f28af1 100644
--- a/src/Flf/Determinize.cc
+++ b/src/Flf/Determinize.cc
@@ -60,7 +60,8 @@ class DeterminizeNode : public FilterNode {
 
 public:
     DeterminizeNode(const std::string& name, const Core::Configuration& config)
-            : FilterNode(name, config), toLogSemiring_(false) {}
+            : FilterNode(name, config),
+              toLogSemiring_(false) {}
     ~DeterminizeNode() {}
     virtual void init(const std::vector<std::string>& arguments) {
         toLogSemiring_ = paramToLogSemiring(config);
diff --git a/src/Flf/EpsilonRemoval.cc b/src/Flf/EpsilonRemoval.cc
index 4eaa8cf8b..07d07020d 100644
--- a/src/Flf/EpsilonRemoval.cc
+++ b/src/Flf/EpsilonRemoval.cc
@@ -57,7 +57,8 @@ class ArcSortLattice : public ModifyLattice {
 
 public:
     ArcSortLattice(ConstLatticeRef l)
-            : ModifyLattice(l), weakOrder_(l) {
+            : ModifyLattice(l),
+              weakOrder_(l) {
         this->setProperties(Fsa::PropertySorted, WeakOrder::properties());
     }
     virtual ~ArcSortLattice() {}
@@ -199,7 +200,8 @@ class ArcRemovalNode : public FilterNode {
 
 public:
     ArcRemovalNode(const std::string& name, const Core::Configuration& config)
-            : FilterNode(name, config), toLogSemiring_(false) {}
+            : FilterNode(name, config),
+              toLogSemiring_(false) {}
     ~ArcRemovalNode() {}
     virtual void init(const std::vector<std::string>& arguments) {
         toLogSemiring_ = paramToLogSemiring(config);
@@ -295,7 +297,9 @@ class NullArcFilter {
         const Boundaries& boundaries;
         const Time        t;
         Filter(ConstLatticeRef l, ConstStateRef sr)
-                : l(l), boundaries(*l->getBoundaries()), t(l->getBoundaries()->get(sr->id()).time()) {}
+                : l(l),
+                  boundaries(*l->getBoundaries()),
+                  t(l->getBoundaries()->get(sr->id()).time()) {}
         bool operator()(const Arc& a) const {
             if (boundaries.get(a.target()).time() == t) {
                 if ((a.input() != Fsa::Epsilon) || (a.output() != Fsa::Epsilon))
@@ -312,7 +316,8 @@ class NullArcFilter {
         const Boundaries& boundaries;
         Time              t;
         WeakOrder(ConstLatticeRef l)
-                : l(l), boundaries(*l->getBoundaries()) {}
+                : l(l),
+                  boundaries(*l->getBoundaries()) {}
         bool operator()(const Arc& a1, const Arc& a2) const {
             Time t1 = boundaries.get(a1.target()).time(), t2 = boundaries.get(a1.target()).time();
             if (t1 < t2)
diff --git a/src/Flf/Evaluate.cc b/src/Flf/Evaluate.cc
index 7ac0e1061..27a111e3c 100644
--- a/src/Flf/Evaluate.cc
+++ b/src/Flf/Evaluate.cc
@@ -242,7 +242,8 @@ class EvaluatorNode : public FilterNode {
 
 public:
     EvaluatorNode(const std::string& name, const Core::Configuration& config)
-            : Precursor(name, config), evaluator_(0) {
+            : Precursor(name, config),
+              evaluator_(0) {
         validReference_ = false;
     }
     virtual ~EvaluatorNode() {
diff --git a/src/Flf/Filter.cc b/src/Flf/Filter.cc
index a31573eb5..caf73bb69 100644
--- a/src/Flf/Filter.cc
+++ b/src/Flf/Filter.cc
@@ -30,7 +30,8 @@ class ArcFilterLattice : public SlaveLattice {
 
 public:
     ArcFilterLattice(ConstLatticeRef l, const ArcFilter& filter)
-            : Precursor(l), filter_(filter) {}
+            : Precursor(l),
+              filter_(filter) {}
     virtual ~ArcFilterLattice() {}
 
     virtual ConstStateRef getState(Fsa::StateId sid) const {
@@ -56,7 +57,8 @@ struct InputFilter {
     Fsa::ConstAlphabetRef alphabet;
     Fsa::LabelId          input;
     InputFilter(Fsa::ConstAlphabetRef alphabet, Fsa::LabelId input)
-            : alphabet(alphabet), input(input) {}
+            : alphabet(alphabet),
+              input(input) {}
     bool operator()(const Arc& a) const {
         return a.input() == input;
     }
@@ -82,7 +84,8 @@ struct OutputFilter {
     Fsa::ConstAlphabetRef alphabet;
     Fsa::LabelId          output;
     OutputFilter(Fsa::ConstAlphabetRef alphabet, Fsa::LabelId output)
-            : alphabet(alphabet), output(output) {}
+            : alphabet(alphabet),
+              output(output) {}
     bool operator()(const Arc& a) const {
         return a.output() == output;
     }
diff --git a/src/Flf/FlfCore/Basic.cc b/src/Flf/FlfCore/Basic.cc
index c3cf0942d..33ea78929 100644
--- a/src/Flf/FlfCore/Basic.cc
+++ b/src/Flf/FlfCore/Basic.cc
@@ -58,7 +58,9 @@ class ProjectSemiringLattice : public ModifyLattice {
 
 public:
     ProjectSemiringLattice(ConstLatticeRef l, ConstSemiringRef targetSemiring, const ProjectionMatrix& mapping)
-            : Precursor(l), semiring_(targetSemiring), mapping_(mapping) {
+            : Precursor(l),
+              semiring_(targetSemiring),
+              mapping_(mapping) {
         verify(mapping_.size() <= targetSemiring->size());
         ConstSemiringRef sourceSemiring = l->semiring();
         for (ProjectionMatrix::const_iterator itScales = mapping_.begin(); itScales != mapping_.end(); ++itScales)
@@ -95,7 +97,9 @@ struct FsaWeightToScores {
     ScoresRef        defaultScore;
     ScoreId          id;
     FsaWeightToScores(ConstSemiringRef semiring, ScoresRef defaultScore, ScoreId id)
-            : semiring(semiring), defaultScore(defaultScore), id(id) {}
+            : semiring(semiring),
+              defaultScore(defaultScore),
+              id(id) {}
     ScoresRef operator()(const Fsa::Weight& w) const {
         ScoresRef score = semiring->clone(defaultScore);
         score->set(id, Score(w));
@@ -125,7 +129,11 @@ class FsaVectorLattice : public Lattice {
 
 public:
     FsaVectorLattice(const std::vector<Fsa::ConstAutomatonRef>& fsas, ConstSemiringRef semiring)
-            : Precursor(), fsas_(fsas), semiring_(semiring), tmpStates_(0), tmpArcIterators_(0) {
+            : Precursor(),
+              fsas_(fsas),
+              semiring_(semiring),
+              tmpStates_(0),
+              tmpArcIterators_(0) {
         verify((fsas_.size() > 0) && (fsas_.size() == semiring_->size()));
         tmpStates_.resize(fsas_.size());
         tmpArcIterators_.resize(fsas_.size());
@@ -199,7 +207,8 @@ struct FsaWeightToConstant {
     ConstSemiringRef semiring;
     ScoresRef        constScore;
     FsaWeightToConstant(ConstSemiringRef semiring, ScoresRef constScore)
-            : semiring(semiring), constScore(constScore) {}
+            : semiring(semiring),
+              constScore(constScore) {}
     ScoresRef operator()(const Fsa::Weight& w) const {
         return constScore;
     }
@@ -242,7 +251,8 @@ struct Projection {
     ScoreId id;
     Score   scale;
     Projection(ScoreId id, Score scale = Score(1))
-            : id(id), scale(scale) {}
+            : id(id),
+              scale(scale) {}
     Fsa::Weight operator()(const ScoresRef& a) const {
         return Fsa::Weight(scale * a->get(id));
     }
@@ -295,7 +305,9 @@ class TopologicalOrderBuilder : protected DfsState {
 
 public:
     TopologicalOrderBuilder(ConstLatticeRef l, Core::Ref<StateMap> map)
-            : DfsState(l), map_(map), isCyclic_(false) {}
+            : DfsState(l),
+              map_(map),
+              isCyclic_(false) {}
     bool isCyclic() const {
         return isCyclic_;
     }
@@ -351,7 +363,8 @@ class FindTopologicalOrder : public TopologicalOrderBuilder {
 
 public:
     FindTopologicalOrder(ConstLatticeRef l, Core::Ref<StateMap> map)
-            : TopologicalOrderBuilder(l, map), time_(0) {
+            : TopologicalOrderBuilder(l, map),
+              time_(0) {
         dfs();
         if (time_ > 0) {
             if (!isCyclic()) {
@@ -397,15 +410,19 @@ ConstStateMapRef findTopologicalOrder(ConstLatticeRef l) {
 struct ChronologicalWeakOrder {
     const Boundaries& boundaries;
     const StateMap&   topologicalOrder;
-    bool              operator()(Fsa::StateId sid1, Fsa::StateId sid2) const {
+
+    bool operator()(Fsa::StateId sid1, Fsa::StateId sid2) const {
         if (boundaries.time(sid1) == boundaries.time(sid2))
             return topologicalOrder[sid1] < topologicalOrder[sid2];
         else
             return boundaries.time(sid1) < boundaries.time(sid2);
     }
+
     ChronologicalWeakOrder(const Boundaries& boundaries, const StateMap& topologicalOrder)
-            : boundaries(boundaries), topologicalOrder(topologicalOrder) {}
+            : boundaries(boundaries),
+              topologicalOrder(topologicalOrder) {}
 };
+
 ConstStateMapRef sortChronologically(ConstLatticeRef l) {
     ConstStateMapRef topologicalSort = sortTopologically(l);
     verify(topologicalSort);
@@ -429,7 +446,8 @@ class TopologicalOrderLattice : public SlaveLattice {
         ConstStateMapRef   topologicalSort_;  // order = new-sid -> old-sid
     public:
         TopologicalOrderBoundaries(ConstBoundariesRef boundaries, ConstStateMapRef topologicalSort)
-                : boundaries_(boundaries), topologicalSort_(topologicalSort) {}
+                : boundaries_(boundaries),
+                  topologicalSort_(topologicalSort) {}
         virtual ~TopologicalOrderBoundaries() {}
         bool valid() const {
             return boundaries_->valid();
@@ -536,7 +554,9 @@ class ScoreAppendLattice : public SlaveLattice {
 
 public:
     ScoreAppendLattice(ConstLatticeRef l1, ConstLatticeRef l2, ConstSemiringRef semiring)
-            : Precursor(l1), appendL_(l2), semiring_(semiring) {
+            : Precursor(l1),
+              appendL_(l2),
+              semiring_(semiring) {
         const Semiring& semiring1 = *l1->semiring();
         n1_                       = semiring1.size();
         const Semiring& semiring2 = *l2->semiring();
diff --git a/src/Flf/FlfCore/Boundaries.hh b/src/Flf/FlfCore/Boundaries.hh
index 9c88abd73..e595d72b9 100644
--- a/src/Flf/FlfCore/Boundaries.hh
+++ b/src/Flf/FlfCore/Boundaries.hh
@@ -70,9 +70,11 @@ public:
     Boundary()
             : time_(Speech::InvalidTimeframeIndex) {}
     Boundary(Speech::TimeframeIndex time)
-            : time_(time), transit_() {}
+            : time_(time),
+              transit_() {}
     Boundary(Speech::TimeframeIndex time, const Transit& transit)
-            : time_(time), transit_(transit) {}
+            : time_(time),
+              transit_(transit) {}
 
     void setTime(Speech::TimeframeIndex time) {
         time_ = time;
@@ -164,7 +166,8 @@ private:
 
 public:
     MappedBoundaries(ConstBoundariesRef boundaries, Fsa::ConstMappingRef map)
-            : boundaries_(boundaries), map_(map) {}
+            : boundaries_(boundaries),
+              map_(map) {}
     virtual ~MappedBoundaries() {}
 
     virtual bool valid() const {
diff --git a/src/Flf/FlfCore/Lattice.cc b/src/Flf/FlfCore/Lattice.cc
index cb2785d12..9f21b9d2c 100644
--- a/src/Flf/FlfCore/Lattice.cc
+++ b/src/Flf/FlfCore/Lattice.cc
@@ -21,7 +21,8 @@ namespace Flf {
 Lattice::nLattices = 0;
 
 Lattice::Lattice()
-        : Precursor(), boundaries_(InvalidBoundaries) {
+        : Precursor(),
+          boundaries_(InvalidBoundaries) {
     ++nLattices;
 }
 
@@ -30,7 +31,8 @@ Lattice::~Lattice() {
 }
 #else
 Lattice::Lattice()
-        : Precursor(), boundaries_(InvalidBoundaries) {}
+        : Precursor(),
+          boundaries_(InvalidBoundaries) {}
 
 Lattice::~Lattice() {}
 #endif
diff --git a/src/Flf/FlfCore/Lattice.hh b/src/Flf/FlfCore/Lattice.hh
index 220121650..bc73cad5a 100644
--- a/src/Flf/FlfCore/Lattice.hh
+++ b/src/Flf/FlfCore/Lattice.hh
@@ -40,9 +40,15 @@ struct Arc {
     Fsa::LabelId output_;
     Arc() {}
     Arc(Fsa::StateId target, ScoresRef a, Fsa::LabelId input)
-            : target_(target), weight_(a), input_(input), output_(input) {}
+            : target_(target),
+              weight_(a),
+              input_(input),
+              output_(input) {}
     Arc(Fsa::StateId target, ScoresRef a, Fsa::LabelId input, Fsa::LabelId output)
-            : target_(target), weight_(a), input_(input), output_(output) {}
+            : target_(target),
+              weight_(a),
+              input_(input),
+              output_(output) {}
     ~Arc() {}
     Fsa::StateId target() const {
         return target_;
@@ -102,11 +108,14 @@ public:
 
 public:
     StateMap()
-            : Precursor(), maxSid(Fsa::InvalidStateId) {}
+            : Precursor(),
+              maxSid(Fsa::InvalidStateId) {}
     StateMap(size_t n)
-            : Precursor(n), maxSid(Fsa::InvalidStateId) {}
+            : Precursor(n),
+              maxSid(Fsa::InvalidStateId) {}
     StateMap(size_t n, Fsa::StateId def)
-            : Precursor(n, def), maxSid(Fsa::InvalidStateId) {}
+            : Precursor(n, def),
+              maxSid(Fsa::InvalidStateId) {}
 };
 typedef Core::Ref<StateMap>       StateMapRef;
 typedef Core::Ref<const StateMap> ConstStateMapRef;
@@ -179,11 +188,26 @@ struct Arc {
         from = to = Core::Type<u32>::max;
     }
     Arc(Label label, ScoresRef scores)
-            : label(label), scores(scores), begin(Speech::InvalidTimeframeIndex), duration(0), from(Core::Type<u32>::max), to(Core::Type<u32>::max) {}
+            : label(label),
+              scores(scores),
+              begin(Speech::InvalidTimeframeIndex),
+              duration(0),
+              from(Core::Type<u32>::max),
+              to(Core::Type<u32>::max) {}
     Arc(Label label, ScoresRef scores, Time begin, Time duration)
-            : label(label), scores(scores), begin(begin), duration(duration), from(Core::Type<u32>::max), to(Core::Type<u32>::max) {}
+            : label(label),
+              scores(scores),
+              begin(begin),
+              duration(duration),
+              from(Core::Type<u32>::max),
+              to(Core::Type<u32>::max) {}
     Arc(Label label, ScoresRef scores, Time begin, Time duration, u32 from, u32 to)
-            : label(label), scores(scores), begin(begin), duration(duration), from(from), to(to) {}
+            : label(label),
+              scores(scores),
+              begin(begin),
+              duration(duration),
+              from(from),
+              to(to) {}
     inline bool operator<(const Arc& a) const {
         return label < a.label;
     }
@@ -194,7 +218,8 @@ struct PosteriorArc {
     Probability score;
     PosteriorArc() {}
     PosteriorArc(Label label, Probability score)
-            : label(label), score(score) {}
+            : label(label),
+              score(score) {}
     inline bool operator<(const PosteriorArc& a) const {
         return label < a.label;
     }
@@ -281,7 +306,8 @@ public:
             Fsa::StateId sid;
             Fsa::StateId aid;
             Mapping(Fsa::StateId sid, Fsa::StateId aid)
-                    : sid(sid), aid(aid) {}
+                    : sid(sid),
+                      aid(aid) {}
         };
         static const Mapping               InvalidMapping;
         typedef std::vector<Mapping>       Map;
diff --git a/src/Flf/FlfCore/LatticeInternal.cc b/src/Flf/FlfCore/LatticeInternal.cc
index 73bd44a08..2a3d7dca8 100644
--- a/src/Flf/FlfCore/LatticeInternal.cc
+++ b/src/Flf/FlfCore/LatticeInternal.cc
@@ -44,7 +44,9 @@ class RescoreLattice::StateRescorer {
 
 public:
     StateRescorer(const RescoreLattice* l)
-            : l(*l), predecessor(*l->fsa_), semiring(*l->semiring()) {}
+            : l(*l),
+              predecessor(*l->fsa_),
+              semiring(*l->semiring()) {}
     virtual ~StateRescorer() {}
     virtual ConstStateRef operator()(Fsa::StateId sid) const = 0;
 };
diff --git a/src/Flf/FlfCore/Semiring.hh b/src/Flf/FlfCore/Semiring.hh
index 89ba7c621..46e5ad158 100644
--- a/src/Flf/FlfCore/Semiring.hh
+++ b/src/Flf/FlfCore/Semiring.hh
@@ -116,13 +116,17 @@ public:
      * scales
      **/
     virtual void setScales(const ScoreList& scales) const;
-    ScoreList&   scales() const {
+
+    ScoreList& scales() const {
         return scales_;
     }
+
     virtual void setScale(ScoreId id, Score scale) const;
-    Score        scale(ScoreId id) const {
+
+    Score scale(ScoreId id) const {
         return scales_[id];
     }
+
     /*
      * return value:
      * 0 scales are equal
diff --git a/src/Flf/FlfCore/TopologicalOrderQueue.hh b/src/Flf/FlfCore/TopologicalOrderQueue.hh
index 86ecfbb24..7bdc959b9 100644
--- a/src/Flf/FlfCore/TopologicalOrderQueue.hh
+++ b/src/Flf/FlfCore/TopologicalOrderQueue.hh
@@ -43,7 +43,8 @@ private:
 
 public:
     TopologicalOrderQueue(const WeakTopologicalOrder& weakOrder)
-            : Precursor(weakOrder), topologicalOrder_(weakOrder.topologicalOrder) {}
+            : Precursor(weakOrder),
+              topologicalOrder_(weakOrder.topologicalOrder) {}
     ConstStateMapRef getTopologicalOrder() const {
         return topologicalOrder_;
     }
@@ -74,7 +75,8 @@ private:
 
 public:
     ReverseTopologicalOrderQueue(const WeakReverseTopologicalOrder& weakOrder)
-            : Precursor(weakOrder), topologicalOrder_(weakOrder.topologicalOrder) {}
+            : Precursor(weakOrder),
+              topologicalOrder_(weakOrder.topologicalOrder) {}
     ConstStateMapRef getTopologicalOrder() const {
         return topologicalOrder_;
     }
diff --git a/src/Flf/FlfCore/Utility.cc b/src/Flf/FlfCore/Utility.cc
index 97224021e..8df76effa 100644
--- a/src/Flf/FlfCore/Utility.cc
+++ b/src/Flf/FlfCore/Utility.cc
@@ -117,8 +117,7 @@ const TextFileParser::StringList& TextFileParser::next() {
         n_++;
         std::string line;
         std::getline(tis_, line);
-        bool        isEscaped = false;
-        const char* comment   = 0;
+        bool isEscaped = false;
         for (const char* c = line.c_str();;) {
             for (; (*c != '\0') && ::isspace(*c); ++c)
                 ;
@@ -166,7 +165,6 @@ const TextFileParser::StringList& TextFileParser::next() {
                         isEscaped = true;
                     }
                     else if ((*c == '#') || ((*c == ';') && (*(c + 1) == ';'))) {
-                        comment = c;
                         if (columns_.back().empty())
                             columns_.pop_back();
                         isBreak = true;
diff --git a/src/Flf/FlfExt/AcousticAlignment.cc b/src/Flf/FlfExt/AcousticAlignment.cc
index 50553b0b8..8c970d330 100644
--- a/src/Flf/FlfExt/AcousticAlignment.cc
+++ b/src/Flf/FlfExt/AcousticAlignment.cc
@@ -50,7 +50,10 @@ struct AlignedCoarticulatedLemmaPronunciation {
 
         Key(
                 const CoarticulatedLemmaPronunciation& coLp, Time beginTime, Time endTime)
-                : coLp(coLp), id(coLp.object().id()), beginTime(beginTime), endTime(endTime) {}
+                : coLp(coLp),
+                  id(coLp.object().id()),
+                  beginTime(beginTime),
+                  endTime(endTime) {}
     };
 };
 struct AlignedCoarticulatedLemmaPronunciation::Key::Hash {
@@ -168,7 +171,11 @@ Time SubWordAlignment::duration() const {
 
 // -------------------------------------------------------------------------
 LatticeAlignment::LatticeAlignment(ConstLatticeRef l, AcousticPhonemeSequenceAligner* aligner, const LabelMapList& subwordMaps)
-        : l_(l), isLemma_(false), aligner_(aligner), subwordMaps_(subwordMaps), size_(aligner->features()->size()) {
+        : l_(l),
+          isLemma_(false),
+          aligner_(aligner),
+          subwordMaps_(subwordMaps),
+          size_(aligner->features()->size()) {
     switch (Lexicon::us()->alphabetId(l_->getInputAlphabet())) {
         case Lexicon::LemmaAlphabetId:
             isLemma_ = true;
@@ -432,7 +439,8 @@ struct SubwordArcAligner {
     const LatticeAlignment& latticeAlignment;
     u32                     i_;
     SubwordArcAligner(const LatticeAlignment& latticeAlignment, u32 i)
-            : latticeAlignment(latticeAlignment), i_(i) {}
+            : latticeAlignment(latticeAlignment),
+              i_(i) {}
     Fsa::ConstAlphabetRef alphabet() const {
         return Lexicon::us()->lemmaPronunciationAlphabet();
     }
@@ -519,7 +527,10 @@ class LatticeFromLatticeAlignmentBuilder : public TraverseState {
     }
 
     LatticeFromLatticeAlignmentBuilder(ConstLatticeRef l, const ArcAligner& arcAligner, StaticLattice* s, StaticBoundaries* b)
-            : TraverseState(l), arcAligner_(arcAligner), s_(s), b_(b) {
+            : TraverseState(l),
+              arcAligner_(arcAligner),
+              s_(s),
+              b_(b) {
         semiring_               = l->semiring();
         boundaries_             = l->getBoundaries();
         Fsa::StateId initialSid = l->initialStateId();
@@ -726,7 +737,9 @@ ConstPosteriorCnRef LatticeAlignment::subwordFramePosteriorCn(ConstFwdBwdRef fb,
 
 // -------------------------------------------------------------------------
 LatticeAlignmentBuilder::LatticeAlignmentBuilder(const Core::Configuration& config, AcousticPhonemeSequenceAligner* aligner, const LabelMapList& subwordMaps)
-        : Core::Component(config), aligner_(aligner), subwordMaps_(subwordMaps) {
+        : Core::Component(config),
+          aligner_(aligner),
+          subwordMaps_(subwordMaps) {
     if (aligner_->acousticModel()->hmmTopologySet()->getDefault().nPhoneStates() < 3)
         Core::Application::us()->warning("Default HMM has less than 3 states; proper function of phoneme/sub-word-unit alignment cannot be guaranted.");
     for (LabelMapList::const_iterator itMap = subwordMaps.begin(); itMap != subwordMaps.end(); ++itMap) {
@@ -851,7 +864,12 @@ class ExtendByAcousticScoreLattice : public RescoreLattice {
             Score                    maxScore,
             bool                     scoreEpsArcs,
             RescoreMode              rescoreMode)
-            : Precursor(l, rescoreMode), latticeAlignment_(latticeAlignment), id_(id), scale_(scale), maxScore_(maxScore), scoreEpsArcs_(scoreEpsArcs) {
+            : Precursor(l, rescoreMode),
+              latticeAlignment_(latticeAlignment),
+              id_(id),
+              scale_(scale),
+              maxScore_(maxScore),
+              scoreEpsArcs_(scoreEpsArcs) {
         require(latticeAlignment);
     }
     virtual ~ExtendByAcousticScoreLattice() {}
@@ -1063,7 +1081,10 @@ class PosteriorCnFeatureLattice : public RescoreLattice {
     PosteriorCnFeatureLattice(
             ConstLatticeRef l, RescoreMode rescoreMode, const Configuration& config,
             ConstLatticeAlignmentRef latticeAlignment, ConstPosteriorCnRef phonemeCn)
-            : Precursor(l, rescoreMode), config_(config), latticeAlignment_(latticeAlignment), phonemeCn_(phonemeCn) {}
+            : Precursor(l, rescoreMode),
+              config_(config),
+              latticeAlignment_(latticeAlignment),
+              phonemeCn_(phonemeCn) {}
 
     virtual void rescore(State* sp) const {
         const Boundaries& boundaries = *fsa_->getBoundaries();
@@ -1277,7 +1298,8 @@ ConstLatticeRef OrthographyAlignment::lattice() const {
 
 // -------------------------------------------------------------------------
 OrthographyAlignmentBuilder::OrthographyAlignmentBuilder(const Core::Configuration& config, AcousticOrthographyAligner* aligner)
-        : Core::Component(config), aligner_(aligner) {}
+        : Core::Component(config),
+          aligner_(aligner) {}
 
 OrthographyAlignmentBuilder::~OrthographyAlignmentBuilder() {
     delete aligner_;
diff --git a/src/Flf/FlfExt/AcousticAlignment.hh b/src/Flf/FlfExt/AcousticAlignment.hh
index de756ee3b..ac5302f74 100644
--- a/src/Flf/FlfExt/AcousticAlignment.hh
+++ b/src/Flf/FlfExt/AcousticAlignment.hh
@@ -36,9 +36,15 @@ struct SubWord {
     Time               duration;
     Bliss::Phoneme::Id leftContext, rightContext;
     SubWord(Fsa::LabelId label, Time duration)
-            : label(label), duration(duration), leftContext(Bliss::Phoneme::term), rightContext(Bliss::Phoneme::term) {}
+            : label(label),
+              duration(duration),
+              leftContext(Bliss::Phoneme::term),
+              rightContext(Bliss::Phoneme::term) {}
     SubWord(Fsa::LabelId label, Time duration, Bliss::Phoneme::Id leftContext, Bliss::Phoneme::Id rightContext)
-            : label(label), duration(duration), leftContext(leftContext), rightContext(rightContext) {}
+            : label(label),
+              duration(duration),
+              leftContext(leftContext),
+              rightContext(rightContext) {}
 };
 
 class SubWordAlignment : public std::vector<SubWord>, public Core::ReferenceCounted {
@@ -50,11 +56,14 @@ private:
 
 public:
     SubWordAlignment()
-            : Precursor(), label_(Fsa::InvalidLabelId) {}
+            : Precursor(),
+              label_(Fsa::InvalidLabelId) {}
     SubWordAlignment(Fsa::LabelId label)
-            : Precursor(), label_(label) {}
+            : Precursor(),
+              label_(label) {}
     SubWordAlignment(Fsa::LabelId label, const SubWord& sw)
-            : Precursor(1, sw), label_(label) {}
+            : Precursor(1, sw),
+              label_(label) {}
     void setLabel(Fsa::LabelId label) {
         label_ = label;
     }
@@ -88,7 +97,8 @@ public:
     void setNonWordLemmaPronunciations(const Lexicon::ConstLemmaPronunciationPtrList& nonWordLemmaProns);
 
     const AcousticPhonemeSequenceAligner* aligner() const;
-    u32                                   size() const {
+
+    u32 size() const {
         return size_;
     }
 
diff --git a/src/Flf/FlfExt/MtConfusionNetwork.cc b/src/Flf/FlfExt/MtConfusionNetwork.cc
index 94291aa52..ad1754fa7 100644
--- a/src/Flf/FlfExt/MtConfusionNetwork.cc
+++ b/src/Flf/FlfExt/MtConfusionNetwork.cc
@@ -53,7 +53,9 @@ class MtCnFeatureLattice : public RescoreLattice {
 
 public:
     MtCnFeatureLattice(ConstLatticeRef l, ConstConfusionNetworkRef cn, RescoreMode rescoreMode, const FeatureIds& ids)
-            : Precursor(l, rescoreMode), cn_(cn), ids_(ids) {
+            : Precursor(l, rescoreMode),
+              cn_(cn),
+              ids_(ids) {
         verify(cn_->hasMap());
         if ((ids_.confidenceId != Semiring::InvalidId) || (ids_.scoreId != Semiring::InvalidId) || (ids_.slotEntropyId != Semiring::InvalidId) || (ids_.nonEpsSlotId != Semiring::InvalidId))
             normalizedCn_ = (cn_->isNormalized()) ? cn_ : normalizeCn(cn_, ids_.cnPosteriorId);
@@ -190,7 +192,9 @@ class MtCnFeatureNode : public RescoreNode {
         Fsa::StateId bptr;
         Fsa::StateId aid;
         TraceElement()
-                : score(Semiring::Max), bptr(Fsa::InvalidStateId), aid(Fsa::InvalidStateId) {}
+                : score(Semiring::Max),
+                  bptr(Fsa::InvalidStateId),
+                  aid(Fsa::InvalidStateId) {}
     };
     typedef std::vector<TraceElement> Traceback;
 
@@ -294,7 +298,8 @@ class MtCnFeatureNode : public RescoreNode {
 
 public:
     MtCnFeatureNode(const std::string& name, const Core::Configuration& config)
-            : Precursor(name, config), alignedBestChannel_(config, "best") {}
+            : Precursor(name, config),
+              alignedBestChannel_(config, "best") {}
     ~MtCnFeatureNode() {}
 
     void init(const std::vector<std::string>& arguments) {
diff --git a/src/Flf/FlfExt/WindowedLevenshteinDistanceDecoder.cc b/src/Flf/FlfExt/WindowedLevenshteinDistanceDecoder.cc
index f041b19b0..66fdae350 100644
--- a/src/Flf/FlfExt/WindowedLevenshteinDistanceDecoder.cc
+++ b/src/Flf/FlfExt/WindowedLevenshteinDistanceDecoder.cc
@@ -16,7 +16,9 @@ namespace Flf {
 
 // -------------------------------------------------------------------------
 ConditionalPosterior::Value::Value(Fsa::LabelId label, Score condPosteriorScore, Score tuplePosteriorScore)
-        : label(label), condPosteriorScore(condPosteriorScore), tuplePosteriorScore(tuplePosteriorScore) {}
+        : label(label),
+          condPosteriorScore(condPosteriorScore),
+          tuplePosteriorScore(tuplePosteriorScore) {}
 
 class ConditionalPosterior::Internal {
     friend class ConditionalPosteriorBuilder;
@@ -30,7 +32,9 @@ class ConditionalPosterior::Internal {
             Fsa::LabelId label;
             u32          begin, end;
             Node(Fsa::LabelId label, u32 begin, u32 end)
-                    : label(label), begin(begin), end(end) {}
+                    : label(label),
+                      begin(begin),
+                      end(end) {}
         };
         typedef std::vector<Node> NodeList;
 
@@ -85,7 +89,8 @@ class ConditionalPosterior::Internal {
 
 private:
     Internal(ConstLatticeRef l, u32 windowSize)
-            : l_(l), windowSize_(windowSize) {}
+            : l_(l),
+              windowSize_(windowSize) {}
 
 public:
     inline u32 windowSize() const {
@@ -234,7 +239,9 @@ class ConditionalPosteriorBuilder : public Core::ReferenceCounted {
         u32             arcPtrIdx;
         ConstArcPtrList arcPtrs;
         Hypothesis(Node* node, Score score, u32 nReserve)
-                : node(node), score(score), arcPtrIdx(0) {
+                : node(node),
+                  score(score),
+                  arcPtrIdx(0) {
             arcPtrs.reserve(nReserve);
         }
     };
@@ -275,7 +282,9 @@ class ConditionalPosteriorBuilder : public Core::ReferenceCounted {
 
 public:
     ConditionalPosteriorBuilder(u32 windowSize, bool compact)
-            : windowSize_(windowSize), compact_(compact), prune_(false) {}
+            : windowSize_(windowSize),
+              compact_(compact),
+              prune_(false) {}
 
     /*
      * Pruning requires a compact CN (necessary due to practical/technical issues; see below)
@@ -338,7 +347,8 @@ class ConditionalPosteriorBuilder::PruningFilter : public ConditionalPosteriorBu
     ConstConfusionNetworkRef cn;
     const Fsa::LabelId       invalidLabel;
     PruningFilter(ConstConfusionNetworkRef cn, Fsa::LabelId invalidLabel)
-            : cn(cn), invalidLabel(invalidLabel) {}
+            : cn(cn),
+              invalidLabel(invalidLabel) {}
     virtual bool keep(const Fsa::LabelId label) const {
         return (label == Fsa::Epsilon) ? false : true;
     }
@@ -983,7 +993,8 @@ class ConditionalPosteriorsNode : public FilterNode {
 
 public:
     ConditionalPosteriorsNode(const std::string& name, const Core::Configuration& config)
-            : FilterNode(name, config), dumpChannel_(config, "dump") {}
+            : FilterNode(name, config),
+              dumpChannel_(config, "dump") {}
     virtual ~ConditionalPosteriorsNode() {}
 
     virtual void init(const std::vector<std::string>& arguments) {
@@ -1107,9 +1118,12 @@ class WindowedLevenshteinDistanceDecoder : public Core::ReferenceCounted {
             BackpointerRef backptr;
             BackpointerRef sideptr;
             Backpointer()
-                    : hypLabel(Fsa::InvalidLabelId), refLabel(Fsa::InvalidLabelId) {}
+                    : hypLabel(Fsa::InvalidLabelId),
+                      refLabel(Fsa::InvalidLabelId) {}
             Backpointer(BackpointerRef backptr, Fsa::LabelId hypLabel, Fsa::LabelId refLabel)
-                    : hypLabel(hypLabel), refLabel(refLabel), backptr(backptr) {}
+                    : hypLabel(hypLabel),
+                      refLabel(refLabel),
+                      backptr(backptr) {}
 
             static BackpointerRef create();
             static BackpointerRef extend(BackpointerRef backptr, Fsa::LabelId hypLabel, Fsa::LabelId refLabel);
@@ -2087,7 +2101,9 @@ struct WindowedLevenshteinDistanceDecoder::AlignmentHelper {
         Fsa::StateId   fromSid, toSid;
         BackpointerRef bptr;
         Arc(Fsa::StateId fromSid, Fsa::StateId toSid, BackpointerRef bptr)
-                : fromSid(fromSid), toSid(toSid), bptr(bptr) {}
+                : fromSid(fromSid),
+                  toSid(toSid),
+                  bptr(bptr) {}
     };
     typedef std::vector<Arc> ArcList;
 
diff --git a/src/Flf/FlfIo.cc b/src/Flf/FlfIo.cc
index 646167fe5..2ac67211a 100644
--- a/src/Flf/FlfIo.cc
+++ b/src/Flf/FlfIo.cc
@@ -539,7 +539,11 @@ class FlfDescriptorXmlParser : public Core::XmlSchemaParser {
 
 public:
     FlfDescriptorXmlParser(const Core::Configuration& config)
-            : Precursor(config), desc_(0), n_(0), id_(0), hasId_(-1) {
+            : Precursor(config),
+              desc_(0),
+              n_(0),
+              id_(0),
+              hasId_(-1) {
         Core::XmlMixedElement* rootElement = new Core::XmlMixedElementRelay("lattice", this, startHandler(&Self::lattice), 0, 0,
                                                                             XML_CHILD(new Core::XmlIgnoreElement(
                                                                                     "head", this)),
@@ -617,7 +621,8 @@ const Core::ParameterFloat FlfReader::paramScale(
         Semiring::DefaultScale);
 
 FlfReader::FlfReader(const Core::Configuration& config)
-        : Precursor(config), contextHandling_(UpdateContext) {
+        : Precursor(config),
+          contextHandling_(UpdateContext) {
     context_ = FlfContextRef(new FlfContext());
     Core::Choice::Value contextHandling =
             ContextModeChoice[paramContextMode(config)];
@@ -630,7 +635,9 @@ FlfReader::FlfReader(const Core::Configuration& config)
 }
 
 FlfReader::FlfReader(const Core::Configuration& config, FlfContextRef context, u32 contextHandling)
-        : Precursor(config), contextHandling_(contextHandling), context_(context) {
+        : Precursor(config),
+          contextHandling_(contextHandling),
+          context_(context) {
     require(context_);
     init();
 }
diff --git a/src/Flf/FlfIo.hh b/src/Flf/FlfIo.hh
index 2c15a0281..b1eee2e43 100644
--- a/src/Flf/FlfIo.hh
+++ b/src/Flf/FlfIo.hh
@@ -65,7 +65,8 @@ struct FsaDescriptor {
 
     FsaDescriptor() {}
     FsaDescriptor(const std::string& format, const std::string& file)
-            : format(format), file(file) {}
+            : format(format),
+              file(file) {}
     FsaDescriptor(const std::string& qualifiedFile);
     FsaDescriptor(const Core::Configuration& config);
     FsaDescriptor& operator=(const FsaDescriptor& desc) {
@@ -98,6 +99,7 @@ struct BoundariesDescriptor {
     BoundariesDescriptor() {}
     BoundariesDescriptor(const std::string& file)
             : file(file) {}
+
     std::string operator()(const std::string& root = "") const;
     operator bool() const {
         return !file.empty();
diff --git a/src/Flf/FwdBwd.cc b/src/Flf/FwdBwd.cc
index 3bd63b226..f6d5e1427 100644
--- a/src/Flf/FwdBwd.cc
+++ b/src/Flf/FwdBwd.cc
@@ -36,7 +36,8 @@ namespace Flf {
 typedef Core::Ref<FwdBwd> FwdBwdRef;
 
 FwdBwd::State::State()
-        : begin_(0), end_(0) {}
+        : begin_(0),
+          end_(0) {}
 
 FwdBwd::Arc::Arc() {}
 
@@ -46,7 +47,12 @@ struct FwdBwd::Internal {
     FwdBwd::Arc*         arcs;
     f64                  min, max, sum;
     Internal(const ConstSemiringRefList& semirings)
-            : semirings(semirings), states(0), arcs(0), min(Core::Type<f64>::max), max(Core::Type<f64>::min), sum(Core::Type<f64>::min) {}
+            : semirings(semirings),
+              states(0),
+              arcs(0),
+              min(Core::Type<f64>::max),
+              max(Core::Type<f64>::min),
+              sum(Core::Type<f64>::min) {}
     ~Internal() {
         delete[] states;
         delete[] arcs;
@@ -99,7 +105,11 @@ class FwdBwd::Builder {
         Core::Vector<Fsa::StateId>        finalStateIds;
         Core::Ref<StateMap>               topologicalSort;
         Properties()
-                : offset(0), nInitialArcs(0), nArcs(0), startTime(0), endTime(0) {}
+                : offset(0),
+                  nInitialArcs(0),
+                  nArcs(0),
+                  startTime(0),
+                  endTime(0) {}
     };
 
     class TraverseLatticeProperties : protected DfsState {
@@ -1030,7 +1040,8 @@ class FwdBwdBuilder::Internal : public Core::Component {
     struct SingleConfiguration {
         ConstSemiringRef   semiring;
         FwdBwd::Parameters params;
-        void               dump(std::ostream& os) const {
+
+        void dump(std::ostream& os) const {
             if (semiring) {
                 os << "Target semiring is \"" << semiring->name() << "\"." << std::endl;
                 if (params.scoreId != Semiring::InvalidId)
@@ -1060,7 +1071,8 @@ class FwdBwdBuilder::Internal : public Core::Component {
 
     struct CombinationConfiguration {
         FwdBwd::CombinationParameters params;
-        void                          dump(std::ostream& os) const {
+
+        void dump(std::ostream& os) const {
             if (params.combination) {
                 os << "Target semiring is \"" << params.combination->semiring()->name() << "\"." << std::endl;
                 if (params.scoreId != Semiring::InvalidId)
@@ -1293,7 +1305,8 @@ class FwdBwdBuilderNode : public Node {
 
 public:
     FwdBwdBuilderNode(const std::string& name, const Core::Configuration& config)
-            : Node(name, config), n_(0) {}
+            : Node(name, config),
+              n_(0) {}
     virtual ~FwdBwdBuilderNode() {}
 
     virtual void init(const std::vector<std::string>& arguments) {
diff --git a/src/Flf/FwdBwd.hh b/src/Flf/FwdBwd.hh
index 4d66fb477..e32eb1b8c 100644
--- a/src/Flf/FwdBwd.hh
+++ b/src/Flf/FwdBwd.hh
@@ -70,9 +70,11 @@ public:
         }
 
         typedef const Arc* const_iterator;
-        const_iterator     begin() const {
+
+        const_iterator begin() const {
             return begin_;
         }
+
         const_iterator end() const {
             return end_;
         }
@@ -99,7 +101,8 @@ public:
     f64 sum() const;
 
     const State& state(Fsa::StateId sid) const;
-    const Arc&   arc(ConstStateRef sr, Flf::State::const_iterator a) const {
+
+    const Arc& arc(ConstStateRef sr, Flf::State::const_iterator a) const {
         return *(state(sr->id()).begin() + (a - sr->begin()));
     }
 
diff --git a/src/Flf/HtkSlfIo.cc b/src/Flf/HtkSlfIo.cc
index acec93343..98263fdbb 100644
--- a/src/Flf/HtkSlfIo.cc
+++ b/src/Flf/HtkSlfIo.cc
@@ -266,7 +266,11 @@ class HtkSlfBuilder : public Core::Component {
         TransitState       transit;
         Bliss::Phoneme::Id initialPhonemeId, finalPhonemeId;
         Node()
-                : sp(0), labelId(Fsa::InvalidLabelId), transit(TransitUnchecked), initialPhonemeId(InvalidPhonemeId), finalPhonemeId(InvalidPhonemeId) {}
+                : sp(0),
+                  labelId(Fsa::InvalidLabelId),
+                  transit(TransitUnchecked),
+                  initialPhonemeId(InvalidPhonemeId),
+                  finalPhonemeId(InvalidPhonemeId) {}
     };
     typedef std::vector<Node> NodeList;
 
diff --git a/src/Flf/HtkSlfIo.hh b/src/Flf/HtkSlfIo.hh
index 99225a620..c1f9672e0 100644
--- a/src/Flf/HtkSlfIo.hh
+++ b/src/Flf/HtkSlfIo.hh
@@ -37,8 +37,10 @@ namespace Flf {
  * - time field is compulsory
  */
 
-typedef enum { HtkSlfForward,
-               HtkSlfBackward } HtkSlfType;
+typedef enum {
+    HtkSlfForward,
+    HtkSlfBackward
+} HtkSlfType;
 
 class HtkSlfContext;
 typedef Core::Ref<HtkSlfContext> HtkSlfContextRef;
@@ -69,72 +71,88 @@ public:
         return silId_;
     }
 
-    void       setType(HtkSlfType type);
+    void setType(HtkSlfType type);
+
     HtkSlfType type() const {
         return type_;
     }
 
     void setFps(f32 fps);
-    f32  fps() const {
+
+    f32 fps() const {
         return fps_;
     }
 
     void setCapitalize(bool isCapitalize);
+
     bool capitalize() const {
         return isCapitalize_;
     }
 
     void setMergePenalties(bool mergePenalty);
+
     bool mergePenalty() const {
         return mergePenalty_;
     }
 
     void setBase(f32 base);
-    f32  base() const {
+
+    f32 base() const {
         return base_;
     }
 
-    void               setEpsSymbol(const std::string&);
+    void setEpsSymbol(const std::string&);
+
     const std::string& epsSymbol() const {
         return epsSymbol_;
     }
 
-    void             setSemiring(ConstSemiringRef semiring);
+    void setSemiring(ConstSemiringRef semiring);
+
     ConstSemiringRef semiring() const {
         return semiring_;
     }
+
     ScoreId amId() const {
         return amId_;
     }
+
     ScoreId lmId() const {
         return lmId_;
     }
+
     ScoreId penaltyId() const {
         return penaltyId_;
     }
 
     // if silPenalty is not given or invalid, silPenalty = wrdPenalty
     void setPenalties(Score wrdPenalty, Score silPenalty = Semiring::Invalid);
+
     bool hasPenalties() const {
         return wrdPenalty_ != Semiring::Invalid;
     }
+
     Score wordPenalty() const {
         return wrdPenalty_;
     }
+
     Score silPenalty() const {
         return silPenalty_;
     }
 
-    void               setLmName(const std::string& lmName);
+    void setLmName(const std::string& lmName);
+
     const std::string& lmName() const {
         return lmName_;
     }
+
     bool cmpLm(const std::string& lmName) const {
         return lmName_ == lmName;
     }
 
     std::string info() const;
-    void        clear();
+
+    void clear();
 
     static HtkSlfContextRef create(const Core::Configuration& config);
 };
@@ -227,7 +245,8 @@ public:
         StateIdList       htk2fsa;
         StateIdList       fsa2htk;
         ConstStateRefList finals;
-        void              clear() {
+
+        void clear() {
             htk2fsa.clear();
             fsa2htk.clear();
             finals.clear();
diff --git a/src/Flf/IncrementalRecognizer.cc b/src/Flf/IncrementalRecognizer.cc
index aee35e55f..cac73e0fe 100644
--- a/src/Flf/IncrementalRecognizer.cc
+++ b/src/Flf/IncrementalRecognizer.cc
@@ -53,14 +53,17 @@ namespace Flf {
 struct ForwardBackwardAlignment {
     struct Word {
         Word()
-                : amScore(Core::Type<Score>::max), lmScore(Core::Type<Score>::max) {}
+                : amScore(Core::Type<Score>::max),
+                  lmScore(Core::Type<Score>::max) {}
         const Bliss::LemmaPronunciation* pron;
         u32                              start, end;
         Fsa::StateId                     originState;
         Score                            amScore, lmScore;
-        bool                             intersects(const Word& rhs) const {
+
+        bool intersects(const Word& rhs) const {
             return end >= rhs.start && start <= rhs.end && rhs.end >= start && rhs.start <= end;
         }
+
         bool equals(const Word& rhs) const {
             return pron == rhs.pron && end == rhs.end && start == rhs.start;
         }
@@ -603,7 +606,8 @@ class IncrementalRecognizer : public Speech::Recognizer {
 
     Core::Timer globalTimer_;
     u32         segmentFeatureCount_;
-    f32         globalRtf() const {
+
+    f32 globalRtf() const {
         if (segmentFeatureCount_ == 0)
             return 0;
         else
@@ -636,6 +640,7 @@ class IncrementalRecognizer : public Speech::Recognizer {
     u32                                                lmContextLength_;
 
     f32  relaxPruningFactor_, relaxPruningOffset_, latticeRelaxPruningFactor_, latticeRelaxPruningOffset_, adaptInitialUpdateRate_, adaptRelaxPruningFactor_, adaptRelaxPruningOffset_;
+    u32  latticeRelaxPruningInterval_;
     s32  adaptCorrectionRatio_;
     f32  scoreTolerance_;
     f32  adaptPruningFactor_;
@@ -645,7 +650,6 @@ class IncrementalRecognizer : public Speech::Recognizer {
     bool onlyEnforceMinimumSearchSpace_;
     bool correctStrictInitial_;
     f32  maximumRtf_;
-    u32  latticeRelaxPruningInterval_;
 
     const Bliss::SpeechSegment* segment_;
     // Current sub-segment index, if partial lattices were returned by the decoder
@@ -1511,11 +1515,12 @@ class IncrementalRecognizer : public Speech::Recognizer {
                 l                      = persistent(l);
             }
             if (fwdBwdThreshold_ >= 0 || minArcsPerSecond_ || maxArcsPerSecond_ < Core::Type<f32>::max) {
-                l                               = pruneByFwdBwdScores(l,
-                                                                      fb,
+                l = pruneByFwdBwdScores(l,
+                                        fb,
                                         fwdBwdThreshold_ < 0 ? (fb->max() - fb->min()) : fwdBwdThreshold_,
-                                                                      minArcsPerSecond_,
-                                                                      maxArcsPerSecond_);
+                                        minArcsPerSecond_,
+                                        maxArcsPerSecond_);
+
                 StaticLatticeRef trimmedLattice = StaticLatticeRef(new StaticLattice);
                 copy(l, trimmedLattice.get(), 0);
                 trimInPlace(trimmedLattice);
@@ -1558,15 +1563,16 @@ class IncrementalRecognizer : public Speech::Recognizer {
               mc_(mc),
               modelAdaptor_(SegmentwiseModelAdaptorRef(new SegmentwiseModelAdaptor(mc))),
               tracebackChannel_(config, "traceback"),
+              segmentFeatureCount_(0),
               lmContextLength_(paramLmContextLength(config)),
               relaxPruningFactor_(paramRelaxPruningFactor(config)),
               relaxPruningOffset_(paramRelaxPruningOffset(config)),
               latticeRelaxPruningFactor_(paramLatticeRelaxPruningFactor(config)),
               latticeRelaxPruningOffset_(paramLatticeRelaxPruningOffset(config)),
-              latticeRelaxPruningInterval_(paramLatticeRelaxPruningInterval(config)),
               adaptInitialUpdateRate_(paramAdaptInitialUpdateRate(config)),
               adaptRelaxPruningFactor_(paramAdaptRelaxPruningFactor(config)),
               adaptRelaxPruningOffset_(paramAdaptRelaxPruningOffset(config)),
+              latticeRelaxPruningInterval_(paramLatticeRelaxPruningInterval(config)),
               adaptCorrectionRatio_(paramAdaptCorrectionRatio(config)),
               scoreTolerance_(paramScoreTolerance(config) * mc->languageModel()->scale()),
               adaptPruningFactor_(paramAdaptPruningFactor(config)),
@@ -1577,7 +1583,6 @@ class IncrementalRecognizer : public Speech::Recognizer {
               correctStrictInitial_(paramCorrectStrictInitial(config)),
               maximumRtf_(paramMaxRtf(config)),
               segment_(0),
-              segmentFeatureCount_(0),
               subSegment_(0),
               verboseRefinement_(paramVerboseRefinement(config)),
               considerSentenceBegin_(paramConsiderSentenceBegin(config)),
@@ -1843,7 +1848,8 @@ class IncrementalRecognizer : public Speech::Recognizer {
             if (preCacheAllFrames_) {
                 struct PreCacher : public Search::SearchAlgorithm {
                     PreCacher()
-                            : SearchAlgorithm(Core::Configuration()), Core::Component(Core::Configuration()) {}
+                            : Core::Component(Core::Configuration()),
+                              SearchAlgorithm(Core::Configuration()) {}
                     virtual void feed(const Mm::FeatureScorer::Scorer& scorer) {
                         dynamic_cast<const Mm::CachedFeatureScorer::CachedContextScorerOverlay*>(scorer.get())->precache();
                     }
@@ -1858,6 +1864,9 @@ class IncrementalRecognizer : public Speech::Recognizer {
                     virtual bool setModelCombination(const Speech::ModelCombination& modelCombination) {
                         return false;
                     }
+                    virtual bool setLanguageModel(Core::Ref<const Lm::ScaledLanguageModel>) {
+                        defect();
+                    }
                 } precacher;
                 Core::Timer                    timer;
                 Speech::RecognizerDelayHandler handler(&precacher, acousticModel_, contextScorerCache_);
@@ -2228,7 +2237,9 @@ class IncrementalRecognizerNode : public Node {
 
 public:
     IncrementalRecognizerNode(const std::string& name, const Core::Configuration& config)
-            : Node(name, config), mc_(), recognizer_(0) {}
+            : Node(name, config),
+              mc_(),
+              recognizer_(0) {}
     virtual ~IncrementalRecognizerNode() {
         delete recognizer_;
     }
diff --git a/src/Flf/Info.cc b/src/Flf/Info.cc
index d64c83a61..bde4e46d4 100644
--- a/src/Flf/Info.cc
+++ b/src/Flf/Info.cc
@@ -108,7 +108,15 @@ struct LatticeStatistics {
     u32  nFinalStates;
     Time minTime, maxTime;
     LatticeStatistics()
-            : nInputEpsilonArcs(0), nInputNonWordArcs(0), nInputWordArcs(0), nOutputEpsilonArcs(0), nOutputNonWordArcs(0), nOutputWordArcs(0), nFinalStates(0), minTime(Core::Type<Time>::max), maxTime(Core::Type<Time>::min) {}
+            : nInputEpsilonArcs(0),
+              nInputNonWordArcs(0),
+              nInputWordArcs(0),
+              nOutputEpsilonArcs(0),
+              nOutputNonWordArcs(0),
+              nOutputWordArcs(0),
+              nFinalStates(0),
+              minTime(Core::Type<Time>::max),
+              maxTime(Core::Type<Time>::min) {}
 };
 struct BestStatistics : public LatticeStatistics {
     ScoresRef scores;
@@ -134,7 +142,8 @@ struct TraceElement {
     Fsa::StateId bptr;
     Arc          arc;
     TraceElement()
-            : score(Semiring::Max), bptr(Fsa::InvalidStateId) {}
+            : score(Semiring::Max),
+              bptr(Fsa::InvalidStateId) {}
 };
 typedef std::vector<TraceElement> Traceback;
 }  // namespace
diff --git a/src/Flf/Io.cc b/src/Flf/Io.cc
index fe4503fe6..33c3d77d9 100644
--- a/src/Flf/Io.cc
+++ b/src/Flf/Io.cc
@@ -51,7 +51,9 @@ std::pair<std::string, bool> stripExtension(const std::string& filename) {
 
 // -------------------------------------------------------------------------
 InputStream::InputStream(const std::string& path, Core::Archive* archive)
-        : ar(0), cis(0), is(0) {
+        : ar(0),
+          cis(0),
+          is(0) {
     std::string filename = Core::normalizePath(path);
     if (archive) {
         ar = new Core::ArchiveReader(*archive, filename);
@@ -93,7 +95,9 @@ std::istream* InputStream::steal() {
 
 // -------------------------------------------------------------------------
 OutputStream::OutputStream(const std::string& path, Core::Archive* archive)
-        : aw(0), cos(0), os(0) {
+        : aw(0),
+          cos(0),
+          os(0) {
     std::string filename = Core::normalizePath(path);
     if (archive) {
         aw = new Core::ArchiveWriter(*archive, filename, true);
@@ -409,7 +413,8 @@ class LatticeReaderNode : public ReaderNode {
 
 public:
     LatticeReaderNode(const std::string& name, const Core::Configuration& config)
-            : Precursor(name, config), reader_(0) {}
+            : Precursor(name, config),
+              reader_(0) {}
     virtual ~LatticeReaderNode() {
         delete reader_;
     }
@@ -870,7 +875,8 @@ class LatticeWriterNode : public WriterNode {
 
 public:
     LatticeWriterNode(const std::string& name, const Core::Configuration& config)
-            : Precursor(name, config), writer_(0) {}
+            : Precursor(name, config),
+              writer_(0) {}
     virtual ~LatticeWriterNode() {
         delete writer_;
     }
diff --git a/src/Flf/LanguageModel.cc b/src/Flf/LanguageModel.cc
index 59d05867b..c76bc1929 100644
--- a/src/Flf/LanguageModel.cc
+++ b/src/Flf/LanguageModel.cc
@@ -52,7 +52,8 @@ class LmComposeLattice : public SlaveLattice {
         Lm::History  history;
 
         InternalState(Fsa::StateId _sid, Lm::History _history)
-                : sid(_sid), history(_history) {}
+                : sid(_sid),
+                  history(_history) {}
 
         struct Hash {
             size_t operator()(const InternalState& s) const {
diff --git a/src/Flf/LatticeAdaptor.hh b/src/Flf/LatticeAdaptor.hh
index b76c386bc..226887b77 100644
--- a/src/Flf/LatticeAdaptor.hh
+++ b/src/Flf/LatticeAdaptor.hh
@@ -37,9 +37,11 @@ public:
 
     bool                write(const std::string& id, Search::LatticeHandler* handler) const;
     ConstWordLatticeRef wordLattice(const Search::LatticeHandler* handler) const;
-    virtual bool        empty() const {
+
+    virtual bool empty() const {
         return l_;
     }
+
     ConstLatticeRef get() const {
         return l_;
     }
diff --git a/src/Flf/Lexicon.cc b/src/Flf/Lexicon.cc
index 1841714eb..e87e2641f 100644
--- a/src/Flf/Lexicon.cc
+++ b/src/Flf/Lexicon.cc
@@ -117,8 +117,7 @@ Lexicon::Lexicon(const Core::Configuration& config)
     else
         insertionChannel_ = 0;
     nLemmaUpdates_ = 0;
-    emptyPron_     = Precursor::getOrCreatePronunciation(
-            std::vector<Bliss::Phoneme::Id>(1, Bliss::Phoneme::term));
+    emptyPron_     = Precursor::getOrCreatePronunciation(std::vector<Bliss::Phoneme::Id>(1, Bliss::Phoneme::term));
     initSpecialLemmas();
 }
 
@@ -486,7 +485,9 @@ std::pair<const Lemma*, s32> Lexicon::lemmaPronunciationVariant(const Bliss::Lem
 }
 
 Lexicon::SymbolMap::SymbolMap(Fsa::ConstAlphabetRef alphabet, IndexFcn indexFcn)
-        : lexicon_(Lexicon::us().get()), index_(indexFcn), alphabet_(alphabet) {}
+        : lexicon_(Lexicon::us().get()),
+          index_(indexFcn),
+          alphabet_(alphabet) {}
 
 void Lexicon::SymbolMap::indices(const std::string& str, std::vector<Fsa::LabelId>& ids) const {
     const char *b = str.c_str(), *c;
@@ -756,7 +757,8 @@ class WordListExtractorNode : public FilterNode {
 
     public:
         WordListExtractor(ConstLatticeRef l, Core::Vector<bool>& hasLid)
-                : TraverseState(l), hasLid_(hasLid) {
+                : TraverseState(l),
+                  hasLid_(hasLid) {
             traverse();
         }
         virtual ~WordListExtractor() {}
@@ -781,7 +783,9 @@ class WordListExtractorNode : public FilterNode {
 
 public:
     WordListExtractorNode(const std::string& name, const Core::Configuration& config)
-            : FilterNode(name, config), dump_(config, "dump"), hasLid_(0) {}
+            : FilterNode(name, config),
+              dump_(config, "dump"),
+              hasLid_(0) {}
     ~WordListExtractorNode() {}
 
     virtual void init(const std::vector<std::string>& arguments) {}
@@ -801,7 +805,8 @@ NodeRef createWordListExtractorNode(const std::string& name, const Core::Configu
 
 // -------------------------------------------------------------------------
 EditDistance::EditDistance(Fsa::ConstAlphabetRef alphabet, const Bliss::TokenAlphabet* toks)
-        : alphabet_(alphabet), toks_(toks) {
+        : alphabet_(alphabet),
+          toks_(toks) {
     lengthD_ = 256;
     D_       = new Cost[lengthD_];
 }
diff --git a/src/Flf/Lexicon.hh b/src/Flf/Lexicon.hh
index 11c047712..9a077f37c 100644
--- a/src/Flf/Lexicon.hh
+++ b/src/Flf/Lexicon.hh
@@ -81,7 +81,8 @@ public:
 
     public:
         SymbolMap()
-                : lexicon_(0), index_(0) {}
+                : lexicon_(0),
+                  index_(0) {}
         SymbolMap(Fsa::ConstAlphabetRef alphabet, IndexFcn indexFcn);
         Fsa::ConstAlphabetRef alphabet() const {
             return alphabet_;
diff --git a/src/Flf/LocalCostDecoder.cc b/src/Flf/LocalCostDecoder.cc
index 6149a2bad..6ddbac738 100644
--- a/src/Flf/LocalCostDecoder.cc
+++ b/src/Flf/LocalCostDecoder.cc
@@ -160,7 +160,9 @@ class LocalCostDecoder::RiskBuilder : public Core::ReferenceCounted {
 
 public:
     RiskBuilder()
-            : offsets(0), risks(0), confidences(0) {}
+            : offsets(0),
+              risks(0),
+              confidences(0) {}
     virtual ~RiskBuilder() {}
 
     void set(Core::Vector<u32>* offsets, ScoreList* risks, ScoreList* confidences) {
@@ -305,7 +307,9 @@ class LocalCostDecoder::LocalOverlapRiskBuilder : public LocalCostDecoder::RiskB
 
 public:
     LocalOverlapRiskBuilder(f64 alpha = 0.5)
-            : Precursor(), hypWeight_(alpha), refWeight_(1.0 - alpha) {}
+            : Precursor(),
+              hypWeight_(alpha),
+              refWeight_(1.0 - alpha) {}
     void        build(ConstLatticeRef hypSpaceL, ConstLatticeRef sumSpaceL, ConstFwdBwdRef sumSpaceFb);
     std::string name() const {
         return Core::form("local-time-overlap(alpha=%.2f)", hypWeight_);
@@ -442,7 +446,11 @@ class LocalCostDecoder::LocalAlignmentRiskBuilder : public LocalCostDecoder::Ris
             // accuracy aka confidence
             f64 accuracy;
             Path()
-                    : target(Core::Type<u32>::max), fbScore(Core::Type<f64>::max), nToken(0.0), nCorrect(0.0), accuracy(0.0) {}
+                    : target(Core::Type<u32>::max),
+                      fbScore(Core::Type<f64>::max),
+                      nToken(0.0),
+                      nCorrect(0.0),
+                      accuracy(0.0) {}
         };
 
         typedef std::vector<Path> PathList;
@@ -516,7 +524,8 @@ class LocalCostDecoder::LocalAlignmentRiskBuilder::ContinousCostScorer1 : public
 
 public:
     ContinousCostScorer1(f64 alpha = 1.0)
-            : Precursor(), alpha_(alpha) {}
+            : Precursor(),
+              alpha_(alpha) {}
 
     void initialize(Closure::Path& path, const HypothesisSpace::Arc& hypArc, const f64 hypProp, const SummationSpace::Arc& refArc, const f64 refProp) const {
         // insertion
@@ -553,7 +562,8 @@ class LocalCostDecoder::LocalAlignmentRiskBuilder::ContinousCostScorer2 : public
 
 public:
     ContinousCostScorer2(f64 alpha = 0.5)
-            : Precursor(), alpha_(alpha) {}
+            : Precursor(),
+              alpha_(alpha) {}
 
     void initialize(Closure::Path& path, const HypothesisSpace::Arc& hypArc, const f64 hypProp, const SummationSpace::Arc& refArc, const f64 refProp) const {
         // insertion
@@ -605,7 +615,8 @@ class LocalCostDecoder::LocalAlignmentRiskBuilder::DiscreteCostScorer : public L
 
 public:
     DiscreteCostScorer(f64 alpha = 0.5)
-            : Precursor(), alpha_(alpha) {}
+            : Precursor(),
+              alpha_(alpha) {}
 
     void initialize(Closure::Path& path, const HypothesisSpace::Arc& hypArc, const f64 hypProp, const SummationSpace::Arc& refArc, const f64 refProp) const {
         // insertion
@@ -739,7 +750,8 @@ void LocalCostDecoder::LocalAlignmentRiskBuilder::build(ConstLatticeRef hypSpace
 
 // -------------------------------------------------------------------------
 LocalCostDecoder::LocalCostDecoder(LocalCostDecoder::RiskBuilderRef riskBuilder, Score wordPenalty)
-        : riskBuilder_(riskBuilder), wordPenalty_(wordPenalty) {
+        : riskBuilder_(riskBuilder),
+          wordPenalty_(wordPenalty) {
     verify(riskBuilder_);
     riskBuilder_->set(&offsets_, &risks_, &confidences_);
 }
@@ -1039,7 +1051,10 @@ class ExtendByLocalRiskLattice : public RescoreLattice {
     ExtendByLocalRiskLattice(
             ConstLatticeRef l, ConstLocalCostDecoderRef scorer,
             ScoreId scoreId, ScoreId confidenceId, RescoreMode rescoreMode)
-            : RescoreLattice(l, rescoreMode), scorer_(scorer), scoreId_(scoreId), confidenceId_(confidenceId) {
+            : RescoreLattice(l, rescoreMode),
+              scorer_(scorer),
+              scoreId_(scoreId),
+              confidenceId_(confidenceId) {
         verify(scorer_);
     }
     virtual ~ExtendByLocalRiskLattice() {}
@@ -1175,7 +1190,8 @@ class LocalCostDecoderNode : public Node {
 
 public:
     LocalCostDecoderNode(const std::string& name, const Core::Configuration& config)
-            : Node(name, config), n_(0) {
+            : Node(name, config),
+              n_(0) {
         scoreId_ = confidenceId_ = Semiring::InvalidId;
     }
     ~LocalCostDecoderNode() {}
diff --git a/src/Flf/Map.cc b/src/Flf/Map.cc
index 947806206..8909db5e2 100644
--- a/src/Flf/Map.cc
+++ b/src/Flf/Map.cc
@@ -812,7 +812,9 @@ class CompoundWordSplittingMap : public LabelMap {
 
 public:
     CompoundWordSplittingMap(Fsa::ConstAlphabetRef alphabet)
-            : LabelMap(alphabet, alphabet), alphabet_(alphabet), lexicon_(Lexicon::us().get()) {
+            : LabelMap(alphabet, alphabet),
+              alphabet_(alphabet),
+              lexicon_(Lexicon::us().get()) {
         description = "split-compound-words";
     }
 };
@@ -1063,7 +1065,8 @@ class OneToOneLabelMappingLattice : public ModifyLattice {
 
 public:
     OneToOneLabelMappingLattice(ConstLatticeRef l, LabelMapRef labelMap)
-            : Precursor(l), labelMap_(labelMap) {
+            : Precursor(l),
+              labelMap_(labelMap) {
         isAcceptor_ = (l->type() == Fsa::TypeAcceptor);
     }
     virtual ~OneToOneLabelMappingLattice() {}
@@ -1229,7 +1232,10 @@ class LabelMapper : protected TraverseState {
 public:
     LabelMapper(ConstLatticeRef l, StaticLatticeRef s, StaticBoundariesRef b,
                 LabelMapRef labelMap)
-            : TraverseState(l), s_(s), b_(b), labelMap_(labelMap) {
+            : TraverseState(l),
+              s_(s),
+              b_(b),
+              labelMap_(labelMap) {
         isAcceptor_ = (l->type() == Fsa::TypeAcceptor);
         semiring_   = l->semiring();
         traverse();
diff --git a/src/Flf/Map.hh b/src/Flf/Map.hh
index c42a908d3..81318f876 100644
--- a/src/Flf/Map.hh
+++ b/src/Flf/Map.hh
@@ -83,9 +83,15 @@ public:
         Bliss::Phoneme::Id initial, final;
         ExtendedLabel() {}
         ExtendedLabel(Fsa::LabelId label, f32 length)
-                : label(label), length(length), initial(Boundary::Transit::InvalidId), final(Boundary::Transit::InvalidId) {}
+                : label(label),
+                  length(length),
+                  initial(Boundary::Transit::InvalidId),
+                  final(Boundary::Transit::InvalidId) {}
         ExtendedLabel(Fsa::LabelId label, f32 length, Bliss::Phoneme::Id initial, Bliss::Phoneme::Id final)
-                : label(label), length(length), initial(initial), final(final) {}
+                : label(label),
+                  length(length),
+                  initial(initial),
+                  final(final) {}
     };
     typedef Core::Vector<ExtendedLabel> Mapping;
 
@@ -107,7 +113,9 @@ protected:
 
 public:
     LabelMap(Fsa::ConstAlphabetRef from, Fsa::ConstAlphabetRef to)
-            : from(from), to(to), mappings(0) {}
+            : from(from),
+              to(to),
+              mappings(0) {}
     const Mapping& operator[](Fsa::LabelId label);
     u32            nMappings() const;
     const Mapping& identity() const {
diff --git a/src/Flf/Miscellaneous.cc b/src/Flf/Miscellaneous.cc
index 8f6ff2f4a..27da728cf 100644
--- a/src/Flf/Miscellaneous.cc
+++ b/src/Flf/Miscellaneous.cc
@@ -296,7 +296,10 @@ class FittingLattice : public SlaveLattice {
 
 public:
     FittingLattice(ConstLatticeRef l, s32 startTime, s32 endTime, bool forceSentenceEndSymbol)
-            : SlaveLattice(l), startTime_(startTime), endTime_(endTime), forceSentenceEndSymbol_(forceSentenceEndSymbol) {
+            : SlaveLattice(l),
+              startTime_(startTime),
+              endTime_(endTime),
+              forceSentenceEndSymbol_(forceSentenceEndSymbol) {
         topologicalOrderMap_ = findTopologicalOrder(l);
         verify(topologicalOrderMap_ && (topologicalOrderMap_->maxSid != Fsa::InvalidStateId));
         if (startTime_ == Core::Type<s32>::max)
@@ -467,11 +470,13 @@ bool isFinite(ConstSemiringRef semiring, ScoresRef scores) {
     return true;
 }
 namespace {
-typedef enum { None,
-               White,
-               Gray,
-               Black } Color;
-}
+typedef enum {
+    None,
+    White,
+    Gray,
+    Black
+} Color;
+}  // namespace
 StaticLatticeRef cleanUp(ConstLatticeRef l) {
     if (l->initialStateId() == Fsa::InvalidStateId)
         return StaticLatticeRef();
diff --git a/src/Flf/Module.cc b/src/Flf/Module.cc
index 108c2e7f4..4852c64a1 100644
--- a/src/Flf/Module.cc
+++ b/src/Flf/Module.cc
@@ -21,7 +21,9 @@
 namespace Flf {
 
 Module_::Module_()
-        : lexicon_(0), network_(0), processor_(0) {}
+        : lexicon_(0),
+          network_(0),
+          processor_(0) {}
 Module_::~Module_() {
     delete lexicon_;
 }
diff --git a/src/Flf/NBest.cc b/src/Flf/NBest.cc
index 3ca9614db..d7cc28b75 100644
--- a/src/Flf/NBest.cc
+++ b/src/Flf/NBest.cc
@@ -158,10 +158,12 @@ class BinaryPriorityQueue {
     Heap      heap_;  // for the sake of simple index arithmetic the first element in the heap must never be used (aka pseudo sentinel), i.e. heap_[0] == T()
 public:
     BinaryPriorityQueue(const WeakOrder& lessThan = WeakOrder())
-            : lessThan_(lessThan), heap_(1, T()) {}
+            : lessThan_(lessThan),
+              heap_(1, T()) {}
 
     BinaryPriorityQueue(const Heap& heap, const WeakOrder& lessThan = WeakOrder())
-            : lessThan_(lessThan), heap_(heap) {}
+            : lessThan_(lessThan),
+              heap_(heap) {}
 
     Heap& heap() {
         return heap_;
@@ -306,18 +308,22 @@ class NBestBuilder {
             Node*        to;
             Fsa::LabelId label;
             Arc(Fsa::LabelId label)
-                    : to(0), label(label) {}
+                    : to(0),
+                      label(label) {}
             Arc(Node* to, Fsa::LabelId label)
-                    : to(to), label(label) {}
+                    : to(to),
+                      label(label) {}
             bool operator<(const Arc& a) const {
                 return label < a.label;
             }
         };
+
         struct Node {
             typedef std::vector<Arc> ArcList;
             ArcList                  arcs;
             StateIdList              suffixes;
-            std::pair<Node*, bool>   add(Fsa::LabelId label) {
+
+            std::pair<Node*, bool> add(Fsa::LabelId label) {
                 if (label == Fsa::Epsilon)
                     return std::make_pair(this, false);
                 ArcList::iterator itArc = std::lower_bound(arcs.begin(), arcs.end(), Arc(label));
@@ -329,6 +335,7 @@ class NBestBuilder {
                 else
                     return std::make_pair(itArc->to, false);
             }
+
             bool addSuffix(Fsa::StateId suffixSid) {
                 StateIdList::iterator itSuffix = std::lower_bound(suffixes.begin(), suffixes.end(), suffixSid);
                 if ((itSuffix == suffixes.end()) || (*itSuffix != suffixSid)) {
@@ -382,7 +389,11 @@ class NBestBuilder {
         Score          fwdScore, bwdScore;
         DissenterList* dissenters;
         Node()
-                : begin(0), end(0), fwdScore(Core::Type<Score>::max), bwdScore(Core::Type<Score>::max), dissenters(0) {}
+                : begin(0),
+                  end(0),
+                  fwdScore(Core::Type<Score>::max),
+                  bwdScore(Core::Type<Score>::max),
+                  dissenters(0) {}
         ~Node() {
             delete dissenters;
         }
@@ -405,9 +416,15 @@ class NBestBuilder {
         Score      detourScore;
         const Arc* dissenter;
         Path()
-                : n(0), fatherId(0), detourScore(0.0), dissenter(0) {}
+                : n(0),
+                  fatherId(0),
+                  detourScore(0.0),
+                  dissenter(0) {}
         Path(Number n, u32 fatherId, Score detourScore, const Arc* dissenter, bool isDuplicate)
-                : n(n), fatherId(fatherId), detourScore(detourScore), dissenter(dissenter) {}
+                : n(n),
+                  fatherId(fatherId),
+                  detourScore(detourScore),
+                  dissenter(dissenter) {}
     };
     typedef std::vector<Path> PathList;
     typedef std::vector<u32>  PathIdList;
@@ -495,7 +512,13 @@ class NBestBuilder {
 
     public:
         Detour(Fsa::StateId initialNid, PrefixTree::Node* initialPrefix, u32 pathId, Score pathScore, const DissenterList* dissenters, const ForkList& forks)
-                : initialNid_(initialNid), initialPrefix_(initialPrefix), pathId_(pathId), pathScore_(pathScore), dissenters_(dissenters), forks_(forks), i_(0) {
+                : initialNid_(initialNid),
+                  initialPrefix_(initialPrefix),
+                  pathId_(pathId),
+                  pathScore_(pathScore),
+                  dissenters_(dissenters),
+                  forks_(forks),
+                  i_(0) {
             update();
         }
         // const member access
@@ -558,7 +581,9 @@ class NBestBuilder {
 
 public:
     NBestBuilder(ConstLatticeRef l, u32 n, bool removeDuplicates = true, bool ignoreNonWords = true)
-            : l_(), removeDuplicates_(removeDuplicates), nUniquePaths_(0) {
+            : l_(),
+              removeDuplicates_(removeDuplicates),
+              nUniquePaths_(0) {
         ensure(l);
         l_         = persistent(l);
         nodes_     = 0;
@@ -1067,7 +1092,7 @@ ConstLatticeRef nbest(ConstLatticeRef l, u32 n, bool removeDuplicates, NBestAlgo
 namespace {
 const Core::Choice choiceNBestAlgorithm(
         "eppstein", Eppstein,
-        "more", Mori,
+        "mori", Mori,
         Core::Choice::endMark());
 const Core::ParameterString paramNBestAlgorithm(
         "algorithm",
@@ -1301,7 +1326,8 @@ class DumpNBestNode : public FilterNode {
 
 public:
     DumpNBestNode(const std::string& name, const Core::Configuration& config)
-            : Precursor(name, config), dump_(config, "dump") {}
+            : Precursor(name, config),
+              dump_(config, "dump") {}
     virtual ~DumpNBestNode() {}
     virtual void init(const std::vector<std::string>& arguments) {
         scoreKeys_ = paramScoreKeys(config);
diff --git a/src/Flf/Network.cc b/src/Flf/Network.cc
index dad58b112..557d26ce9 100644
--- a/src/Flf/Network.cc
+++ b/src/Flf/Network.cc
@@ -269,14 +269,17 @@ class NetworkParser : public NodeFactory {
     static const Core::ParameterStringVector paramLinks;
 
 private:
-    typedef enum { White,
-                   Gray,
-                   Black } Color;
+    typedef enum {
+        White,
+        Gray,
+        Black
+    } Color;
     struct ColoredNode {
         NodeRef node;
         Color   color;
         ColoredNode(NodeRef node, Color color)
-                : node(node), color(color) {}
+                : node(node),
+                  color(color) {}
     };
     typedef std::unordered_map<std::string, ColoredNode, Core::StringHash> ColoredNodeMap;
 
@@ -713,7 +716,8 @@ class SegmentBuilderNode : public Node {
 
 public:
     SegmentBuilderNode(const std::string& name, const Core::Configuration& config)
-            : Node(name, config), progressChannel_(config, "progress") {}
+            : Node(name, config),
+              progressChannel_(config, "progress") {}
     virtual ~SegmentBuilderNode() {}
 
     virtual void init(const std::vector<std::string>& arguments) {
diff --git a/src/Flf/Network.hh b/src/Flf/Network.hh
index 0eb858f55..4c0dcda33 100644
--- a/src/Flf/Network.hh
+++ b/src/Flf/Network.hh
@@ -67,7 +67,9 @@ public:
         Link()
                 : node(0) {}
         Link(Node* node, Port from, Port to)
-                : node(node), from(from), to(to) {}
+                : node(node),
+                  from(from),
+                  to(to) {}
     };
     typedef Core::Vector<Link> LinkList;
 
diff --git a/src/Flf/NodeFactory.hh b/src/Flf/NodeFactory.hh
index 17df83456..76de18e8f 100644
--- a/src/Flf/NodeFactory.hh
+++ b/src/Flf/NodeFactory.hh
@@ -35,7 +35,9 @@ struct NodeCreator {
     NodeCreatorFcn    f;
     // old, deprecated
     NodeCreator(const std::string& name, const std::string& desc, NodeCreatorFcn f)
-            : name(name), generalDesc(desc), f(f) {
+            : name(name),
+              generalDesc(desc),
+              f(f) {
         require(f);
     }
     // new
@@ -44,7 +46,11 @@ struct NodeCreator {
                 const std::string& configDesc,
                 const std::string& portDesc,
                 NodeCreatorFcn     f)
-            : name(name), generalDesc(generalDesc), configDesc(configDesc), portDesc(portDesc), f(f) {
+            : name(name),
+              generalDesc(generalDesc),
+              configDesc(configDesc),
+              portDesc(portDesc),
+              f(f) {
         require(f);
     }
     NodeRef operator()(const std::string& name, const Core::Configuration& config) {
diff --git a/src/Flf/NonWordFilter.cc b/src/Flf/NonWordFilter.cc
index d1bd85062..9a6f0facc 100644
--- a/src/Flf/NonWordFilter.cc
+++ b/src/Flf/NonWordFilter.cc
@@ -36,7 +36,9 @@ struct Hyp {
     Fsa::StateId          bptr;
     State::const_iterator a;
     Hyp()
-            : visited(false), score(Semiring::Max), bptr(Fsa::InvalidStateId) {}
+            : visited(false),
+              score(Semiring::Max),
+              bptr(Fsa::InvalidStateId) {}
 };
 typedef Core::Vector<Hyp>          HypList;
 typedef Core::Vector<Fsa::StateId> StateIdList;
diff --git a/src/Flf/PivotArcConfusionNetworkBuilder.cc b/src/Flf/PivotArcConfusionNetworkBuilder.cc
index 5186885d5..afa89da68 100644
--- a/src/Flf/PivotArcConfusionNetworkBuilder.cc
+++ b/src/Flf/PivotArcConfusionNetworkBuilder.cc
@@ -50,7 +50,9 @@ class PivotArcCn : public Core::ReferenceCounted {
         // state: 0 pending, 1 pivot, 2 member
         u8 state;
         Arc()
-                : slotDist(Core::Type<Score>::max), slotId(Core::Type<u32>::max), state(0) {}
+                : slotDist(Core::Type<Score>::max),
+                  slotId(Core::Type<u32>::max),
+                  state(0) {}
         struct SortByTime {
             bool operator()(const Arc* a1, const Arc* a2) const {
                 return a1->start < a2->start;
@@ -128,7 +130,8 @@ class PivotArcCn : public Core::ReferenceCounted {
 
     public:
         StateIndexBuilder(ConstLatticeRef l, Core::Vector<Fsa::StateId>& stateIndex)
-                : TraverseState(l), stateIndex(stateIndex) {}
+                : TraverseState(l),
+                  stateIndex(stateIndex) {}
 
         void build() {
             if (l->getTopologicalSort())
@@ -453,9 +456,11 @@ class PivotArcCnBuilder : public Core::ReferenceCounted {
     class Distance : public Core::ReferenceCounted {
     public:
         virtual ~Distance() {}
-        virtual std::string describe() const                                                       = 0;
-        virtual Score       distance(const PivotArcCn::Arc& ref, const PivotArcCn::Arc& hyp) const = 0;
-        virtual Score       distance(const PivotArcCn::Slot& slot, const PivotArcCn::Arc& arc) const {
+        virtual std::string describe() const = 0;
+
+        virtual Score distance(const PivotArcCn::Arc& ref, const PivotArcCn::Arc& hyp) const = 0;
+
+        virtual Score distance(const PivotArcCn::Slot& slot, const PivotArcCn::Arc& arc) const {
             Score minDist = Core::Type<Score>::max;
             Time  start = std::max(arc.start, slot.start), end = std::min(arc.end, slot.end);
             if (start < end) {
@@ -477,7 +482,8 @@ class PivotArcCnBuilder : public Core::ReferenceCounted {
 
     public:
         WeightedTimeDistance(Score impact, ConstEditDistanceRef editDist)
-                : impact(impact), editDist(editDist) {}
+                : impact(impact),
+                  editDist(editDist) {}
         virtual std::string describe() const {
             return Core::form("weighted time, impact=%f, edit-distance=%s", impact, ((editDist) ? "yes" : "no"));
         }
@@ -635,10 +641,14 @@ class PivotArcCnBuilder : public Core::ReferenceCounted {
         Fsa::StateId     bptr;
         PivotArcCn::Arc* arc;
         TraceElement()
-                : score(Semiring::Max), bptr(Fsa::InvalidStateId), arc(0) {}
+                : score(Semiring::Max),
+                  bptr(Fsa::InvalidStateId),
+                  arc(0) {}
     };
+
     typedef std::vector<TraceElement> Traceback;
-    u32                               init(ConstLatticeRef l, ConstFwdBwdRef fb) const {
+
+    u32 init(ConstLatticeRef l, ConstFwdBwdRef fb) const {
         LabelMapRef      nonWordToEpsilonMap = LabelMap::createNonWordToEpsilonMap(Lexicon::us()->alphabetId(l->getInputAlphabet(), true));
         ConstStateMapRef topologicalSort     = sortTopologically(l);
         Fsa::StateId     initialSid          = topologicalSort->front();
@@ -902,7 +912,8 @@ class PivotArcCnBuilder : public Core::ReferenceCounted {
 
 private:
     PivotArcCnBuilder(ConstDistanceRef distFcn, bool fast)
-            : distFcn_(distFcn), fast_(fast) {}
+            : distFcn_(distFcn),
+              fast_(fast) {}
     ~PivotArcCnBuilder() {}
 
 public:
@@ -1106,7 +1117,8 @@ class PivotArcCnBuilderNode : public Node {
 
 public:
     PivotArcCnBuilderNode(const std::string& name, const Core::Configuration& config)
-            : Node(name, config), n_(0) {
+            : Node(name, config),
+              n_(0) {
         confidenceId_ = Semiring::InvalidId;
     }
     virtual ~PivotArcCnBuilderNode() {}
diff --git a/src/Flf/Processor.cc b/src/Flf/Processor.cc
index ad5426c68..df6c5e0c2 100644
--- a/src/Flf/Processor.cc
+++ b/src/Flf/Processor.cc
@@ -21,7 +21,8 @@ namespace Flf {
 
 // -------------------------------------------------------------------------
 Processor::Processor(const Core::Configuration& config, Network* network)
-        : Core::Component(config), network_(network) {
+        : Core::Component(config),
+          network_(network) {
     crawler_ = NetworkCrawlerRef(new NetworkCrawler(network));
 }
 
diff --git a/src/Flf/Prune.cc b/src/Flf/Prune.cc
index 674a32ae1..c963198eb 100644
--- a/src/Flf/Prune.cc
+++ b/src/Flf/Prune.cc
@@ -38,7 +38,9 @@ class FwdBwdPruningLattice : public SlaveLattice {
 
 public:
     FwdBwdPruningLattice(ConstLatticeRef l, ConstFwdBwdRef fb, Score threshold)
-            : SlaveLattice(l), fb_(fb), threshold_(threshold) {}
+            : SlaveLattice(l),
+              fb_(fb),
+              threshold_(threshold) {}
     virtual ~FwdBwdPruningLattice() {}
 
     virtual ConstStateRef getState(Fsa::StateId sid) const {
diff --git a/src/Flf/PushForwardRescoring.cc b/src/Flf/PushForwardRescoring.cc
index 86c3ed789..28831409d 100644
--- a/src/Flf/PushForwardRescoring.cc
+++ b/src/Flf/PushForwardRescoring.cc
@@ -151,7 +151,10 @@ class ReplaceSingleDimensionLattice : public SlaveLattice {
 };
 
 ReplaceSingleDimensionLattice::ReplaceSingleDimensionLattice(ConstLatticeRef l, std::vector<size_t> const& state_offsets, std::vector<Score> const& scores, ScoreId id)
-        : Precursor(l), state_offsets_(state_offsets), scores_(scores), id_(id) {
+        : Precursor(l),
+          state_offsets_(state_offsets),
+          scores_(scores),
+          id_(id) {
 }
 
 ConstStateRef ReplaceSingleDimensionLattice::getState(Fsa::StateId sid) const {
@@ -338,8 +341,6 @@ ConstLatticeRef PushForwardRescorer::rescore(ConstLatticeRef l, ScoreId id) {
         state_end.push_back(traceback.size());
     }
 
-    log("num expansions: ") << static_cast<double>(num_expansions) / static_cast<double>(total_num_arcs);
-
     ConstLatticeRef result;
 
     // do traceback
@@ -498,14 +499,15 @@ ConstLatticeRef PushForwardRescorer::rescore(ConstLatticeRef l, ScoreId id) {
             defect();
         }
     }
-
+    log("num expansions: ") << static_cast<double>(num_expansions) / static_cast<double>(total_num_arcs);
     return result;
 }
 
 // ----------------------------------------------------------------------
 
 PushForwardRescoringNode::PushForwardRescoringNode(std::string const& name, Core::Configuration const& config)
-        : Precursor(name, config), rescorer_(nullptr) {
+        : Precursor(name, config),
+          rescorer_(nullptr) {
 }
 
 void PushForwardRescoringNode::init(const std::vector<std::string>& arguments) {
diff --git a/src/Flf/Recognizer.cc b/src/Flf/Recognizer.cc
index 19f5acfac..77b12caf0 100644
--- a/src/Flf/Recognizer.cc
+++ b/src/Flf/Recognizer.cc
@@ -104,10 +104,12 @@ class Recognizer : public Speech::Recognizer {
         traceback_.write(os, lexicon_->phonemeInventory());
         os << Core::XmlClose("traceback");
         os << Core::XmlOpen("orth") + Core::XmlAttribute("source", "recognized");
-        for (u32 i = 0; i < traceback_.size(); ++i)
-            if (traceback_[i].pronunciation)
+        for (u32 i = 0; i < traceback_.size(); ++i) {
+            if (traceback_[i].pronunciation) {
                 os << traceback_[i].pronunciation->lemma()->preferredOrthographicForm()
                    << Core::XmlBlank();
+            }
+        }
         os << Core::XmlClose("orth");
         if (tracebackChannel_.isOpen()) {
             logTraceback(traceback_);
@@ -710,7 +712,10 @@ class RecognizerNode : public Node {
 
 public:
     RecognizerNode(const std::string& name, const Core::Configuration& config)
-            : Node(name, config), mc_(), recognizer_(0), grammarChannel_(Core::Configuration(config, "grammar"), "log") {}
+            : Node(name, config),
+              mc_(),
+              recognizer_(0),
+              grammarChannel_(Core::Configuration(config, "grammar"), "log") {}
     virtual ~RecognizerNode() {
         delete recognizer_;
     }
diff --git a/src/Flf/Rescore.cc b/src/Flf/Rescore.cc
index 20a0dfe3e..daf7b2db5 100644
--- a/src/Flf/Rescore.cc
+++ b/src/Flf/Rescore.cc
@@ -50,7 +50,9 @@ class ReduceScoresLattice : public RescoreLattice {
 
 public:
     ReduceScoresLattice(ConstLatticeRef l, const ScoreIdList& fromIds, ScoreId toId, RescoreMode rescoreMode)
-            : Precursor(l, rescoreMode), fromIds_(fromIds), toId_(toId) {
+            : Precursor(l, rescoreMode),
+              fromIds_(fromIds),
+              toId_(toId) {
         const ScoreList& srScales(l->semiring()->scales());
         scales_.resize(srScales.size(), 0.0);
         for (ScoreIdList::const_iterator it = fromIds_.begin(); it != fromIds_.end(); ++it)
@@ -136,7 +138,9 @@ class ArithmeticLattice : public RescoreLattice {
 
 public:
     ArithmeticLattice(ConstLatticeRef l, ScoreId id, Score c, RescoreMode rescoreMode)
-            : Precursor(l, rescoreMode), id_(id), f_(c) {}
+            : Precursor(l, rescoreMode),
+              id_(id),
+              f_(c) {}
     virtual ~ArithmeticLattice() {}
 
     virtual void rescore(State* sp) const {
@@ -320,7 +324,10 @@ class ExtendByPenaltyLattice : public RescoreLattice {
 
 public:
     ExtendByPenaltyLattice(ConstLatticeRef l, Score penalty, ScoreId id, Score scale, RescoreMode rescoreMode)
-            : Precursor(l, rescoreMode), penalty_(penalty), id_(id), scale_(scale) {}
+            : Precursor(l, rescoreMode),
+              penalty_(penalty),
+              id_(id),
+              scale_(scale) {}
     virtual ~ExtendByPenaltyLattice() {}
 
     virtual void rescore(State* sp) const {
@@ -392,7 +399,11 @@ class ExtendByLemmaSpecificPenaltyLattice : public RescoreLattice {
 
 public:
     ExtendByLemmaSpecificPenaltyLattice(ConstLatticeRef l, Score defaultPenalty, PenaltyMapRef penalties, ScoreId id, Score scale, RescoreMode rescoreMode)
-            : Precursor(l, rescoreMode), defaultPenalty_(defaultPenalty), penalties_(penalties), id_(id), scale_(scale) {
+            : Precursor(l, rescoreMode),
+              defaultPenalty_(defaultPenalty),
+              penalties_(penalties),
+              id_(id),
+              scale_(scale) {
         require(penalties);
         lAlphabet_  = Lexicon::us()->lemmaAlphabet();
         lpAlphabet_ = Lexicon::us()->lemmaPronunciationAlphabet();
@@ -514,7 +525,10 @@ class ExtendByPronunciationScoreLattice : public RescoreLattice {
             ScoreId                                            id,
             Score                                              scale,
             RescoreMode                                        rescoreMode)
-            : Precursor(l, rescoreMode), lpAlphabet_(lpAlphabet), id_(id), scale_(scale) {
+            : Precursor(l, rescoreMode),
+              lpAlphabet_(lpAlphabet),
+              id_(id),
+              scale_(scale) {
         require(lpAlphabet);
     }
     virtual ~ExtendByPronunciationScoreLattice() {}
diff --git a/src/Flf/RescoreInternal.hh b/src/Flf/RescoreInternal.hh
index 54b0ce0cf..495ac8bca 100644
--- a/src/Flf/RescoreInternal.hh
+++ b/src/Flf/RescoreInternal.hh
@@ -72,9 +72,11 @@ private:
 
 protected:
     virtual bool init_(NetworkCrawler& crawler, const std::vector<std::string>& arguments);
-    Score        scale() const {
+
+    Score scale() const {
         return scoreScale_;
     }
+
     virtual ConstLatticeRef rescore(ConstLatticeRef l);
     virtual ConstLatticeRef rescore(ConstLatticeRef l, ScoreId id) = 0;
 
diff --git a/src/Flf/SegmentwiseSpeechProcessor.cc b/src/Flf/SegmentwiseSpeechProcessor.cc
index 0f42fff39..2b67cb4ec 100644
--- a/src/Flf/SegmentwiseSpeechProcessor.cc
+++ b/src/Flf/SegmentwiseSpeechProcessor.cc
@@ -38,7 +38,9 @@ ModelCombinationRef getModelCombination(const Core::Configuration& config, Acous
 
 // -------------------------------------------------------------------------
 SegmentwiseFeatureExtractor::SegmentwiseFeatureExtractor(const Core::Configuration& config, DataSourceRef dataSource)
-        : Core::Component(config), dataSource_(dataSource), statisticsChannel_(config, "statistics") {
+        : Core::Component(config),
+          dataSource_(dataSource),
+          statisticsChannel_(config, "statistics") {
     dataSource_->respondToDelayedErrors();
     nRecordings_ = nSegments_ = 0;
 }
@@ -142,7 +144,8 @@ SegmentwiseSpeechProcessor::SegmentwiseSpeechProcessor(const Core::Configuration
 }
 
 SegmentwiseSpeechProcessor::SegmentwiseSpeechProcessor(SegmentwiseFeatureExtractorRef featureExtractor, SegmentwiseModelAdaptorRef modelAdaptor)
-        : featureExtractor_(featureExtractor), modelAdaptor_(modelAdaptor) {}
+        : featureExtractor_(featureExtractor),
+          modelAdaptor_(modelAdaptor) {}
 
 SegmentwiseSpeechProcessor::~SegmentwiseSpeechProcessor() {}
 
diff --git a/src/Flf/SegmentwiseSpeechProcessor.hh b/src/Flf/SegmentwiseSpeechProcessor.hh
index 0357acaab..5d7f69fa9 100644
--- a/src/Flf/SegmentwiseSpeechProcessor.hh
+++ b/src/Flf/SegmentwiseSpeechProcessor.hh
@@ -52,7 +52,8 @@ private:
 
 public:
     SegmentwiseModelAdaptor(ModelCombinationRef modelCombination)
-            : modelCombination_(modelCombination), acousticModel_(modelCombination->acousticModel()) {}
+            : modelCombination_(modelCombination),
+              acousticModel_(modelCombination->acousticModel()) {}
 
     ModelCombinationRef modelCombination() {
         return modelCombination_;
diff --git a/src/Flf/StateClusterConfusionNetworkBuilder.cc b/src/Flf/StateClusterConfusionNetworkBuilder.cc
index 12f9d6e16..a97ca1198 100644
--- a/src/Flf/StateClusterConfusionNetworkBuilder.cc
+++ b/src/Flf/StateClusterConfusionNetworkBuilder.cc
@@ -125,7 +125,8 @@ class ClusterBuilder : public Core::Component, public Core::ReferenceCounted {
 
 public:
     ClusterBuilder(const Core::Configuration& config)
-            : Core::Component(config), statisticsChannel_(config, "statistics") {
+            : Core::Component(config),
+              statisticsChannel_(config, "statistics") {
         allowBwdMatch_ = paramBwdMatch(config);
     }
     virtual ~ClusterBuilder() {}
@@ -206,11 +207,14 @@ class ClusteredLattice : public Core::ReferenceCounted {
         ArcCluster *prev, *next;
         ClusterId   id;
         StateCluster()
-                : prev(0), next(0) {}
+                : prev(0),
+                  next(0) {}
         StateCluster(ArcCluster* prev)
-                : prev(prev), next(0) {}
+                : prev(prev),
+                  next(0) {}
         StateCluster(ArcCluster* prev, ArcCluster* next)
-                : prev(prev), next(next) {}
+                : prev(prev),
+                  next(next) {}
         void add(StateId sid, State& state) {
             push_back(sid);
             state.cluster = this;
@@ -234,11 +238,14 @@ class ClusteredLattice : public Core::ReferenceCounted {
         StateCluster *prev, *next;
         ClusterId     id;
         ArcCluster()
-                : prev(0), next(0) {}
+                : prev(0),
+                  next(0) {}
         ArcCluster(StateCluster* prev)
-                : prev(prev), next(0) {}
+                : prev(prev),
+                  next(0) {}
         ArcCluster(StateCluster* prev, StateCluster* next)
-                : prev(prev), next(next) {}
+                : prev(prev),
+                  next(next) {}
         void add(ArcId aid, Arc& arc) {
             push_back(aid);
             arc.cluster = this;
@@ -247,18 +254,22 @@ class ClusteredLattice : public Core::ReferenceCounted {
 
     struct LabelWeakOrder {
         const ArcList& arcs;
-        bool           operator()(ArcId aid1, ArcId aid2) const {
+
+        bool operator()(ArcId aid1, ArcId aid2) const {
             return arcs[aid1].label < arcs[aid2].label;
         }
+
         LabelWeakOrder(const ArcList& arcs)
                 : arcs(arcs) {}
     };
 
     struct BeginWeakOrder {
         const ArcList& arcs;
-        bool           operator()(ArcId aid1, ArcId aid2) const {
+
+        bool operator()(ArcId aid1, ArcId aid2) const {
             return arcs[aid1].begin < arcs[aid2].begin;
         }
+
         BeginWeakOrder(const ArcList& arcs)
                 : arcs(arcs) {}
     };
@@ -334,7 +345,8 @@ class ClusteredLattice : public Core::ReferenceCounted {
         Score score;
         ArcId id;
         Match()
-                : score(Core::Type<Score>::min), id(InvalidArcId) {}
+                : score(Core::Type<Score>::min),
+                  id(InvalidArcId) {}
     };
     inline void updateFwdMatch(const ArcId hypId, const Arc& hyp, const ArcId refId, const Arc& ref, Match& bestFwdMatch) const {
         Score score = similarity(hyp, ref);
@@ -484,7 +496,6 @@ bool ClusteredLattice::checkPostCondition(const StateCluster* initial, bool verb
             Core::Application::us()->warning("Arc cluster %d is empty.", cluster->next->id);
             good = false;
         }
-        ClusterId prevToClusterId  = 0;
         ClusterId maxFromClusterId = 0, minToClusterId = Core::Type<ClusterId>::max;
         for (ArcCluster::const_iterator a = cluster->next->begin(), a_end = cluster->next->end(); a != a_end; ++a) {
             const Arc& arc = arcs_[*a];
@@ -506,14 +517,6 @@ bool ClusteredLattice::checkPostCondition(const StateCluster* initial, bool verb
                 Core::Application::us()->warning("Arc cluster out of bounds: %d not in (%d,%d].", arc.cluster->id, fromClusterId, toClusterId);
                 good = false;
             }
-            /*
-             * Allow any order
-             *
-             * if (toClusterId < prevToClusterId)
-             * Core::Application::us()->criticalError(
-             * "Inner arc cluster order violation: expected %d < %d.", prevToClusterId, toClusterId);
-             */
-            prevToClusterId  = toClusterId;
             maxFromClusterId = std::max(maxFromClusterId, fromClusterId);
             minToClusterId   = std::min(minToClusterId, toClusterId);
         }
@@ -1294,7 +1297,8 @@ class StateIndexBuilder : public TraverseState {
 
 public:
     StateIndexBuilder(ConstLatticeRef l, Core::Vector<Fsa::StateId>& stateIndex)
-            : TraverseState(l), stateIndex(stateIndex) {}
+            : TraverseState(l),
+              stateIndex(stateIndex) {}
 
     void build() {
         if (l->getTopologicalSort())
@@ -1526,7 +1530,8 @@ class StateClusterCnBuilderNode : public Node {
 
 public:
     StateClusterCnBuilderNode(const std::string& name, const Core::Configuration& config)
-            : Node(name, config), n_(0) {}
+            : Node(name, config),
+              n_(0) {}
     virtual ~StateClusterCnBuilderNode() {}
 
     virtual void init(const std::vector<std::string>& arguments) {
diff --git a/src/Flf/TimeAlignment.cc b/src/Flf/TimeAlignment.cc
index 08468dbe1..f0caa7648 100644
--- a/src/Flf/TimeAlignment.cc
+++ b/src/Flf/TimeAlignment.cc
@@ -38,7 +38,9 @@ class StaticScoreLattice : public ModifyLattice {
 
 public:
     StaticScoreLattice(ConstLatticeRef l, ConstSemiringRef semiring, ScoresRef weight)
-            : Precursor(l), semiring_(semiring), weight_(weight) {}
+            : Precursor(l),
+              semiring_(semiring),
+              weight_(weight) {}
     virtual ~StaticScoreLattice() {}
 
     virtual ConstSemiringRef semiring() const {
@@ -79,7 +81,9 @@ class TimeAlignmentBuilder::Internal : public Core::Component {
         u32 nIntersections;
         u32 nFrameAlignments;
         Statistics()
-                : n(0), nIntersections(0), nFrameAlignments(0) {}
+                : n(0),
+                  nIntersections(0),
+                  nFrameAlignments(0) {}
     };
 
 private:
@@ -107,7 +111,9 @@ class TimeAlignmentBuilder::Internal : public Core::Component {
 
 public:
     Internal(const Core::Configuration& config, FwdBwdBuilderRef fbBuilder)
-            : Core::Component(config), statisticsChannel_(config, "statistics"), fbBuilder_(fbBuilder) {
+            : Core::Component(config),
+              statisticsChannel_(config, "statistics"),
+              fbBuilder_(fbBuilder) {
         if (!fbBuilder_)
             fbBuilder_ = FwdBwdBuilder::create(select("fb"));
         tryIntersection_ = paramTryIntersection(config);
@@ -277,9 +283,8 @@ class TimeAlignmentBuilder::Internal : public Core::Component {
             for (ConstStateRef sr = lHyp->getState(lHyp->initialStateId()); sr->hasArcs();
                  sr               = lHyp->getState(sr->begin()->target()))
                 if (sr->nArcs() != 1)
-                    criticalError(
-                            "Cannot align \"%s\" is not linear; lattice is not linear.",
-                            lHyp->describe().c_str());
+                    criticalError("Cannot align \"%s\" is not linear; lattice is not linear.",
+                                                lHyp->describe().c_str());
             lHyp->addProperties(Fsa::PropertyLinear);
         }
         lHyp->setBoundaries(InvalidBoundaries);
@@ -370,7 +375,8 @@ class TimeAlignmentNode : public FilterNode {
 
 public:
     TimeAlignmentNode(const std::string& name, const Core::Configuration& config)
-            : FilterNode(name, config), aligner_() {}
+            : FilterNode(name, config),
+              aligner_() {}
     virtual ~TimeAlignmentNode() {}
     virtual void init(const std::vector<std::string>& arguments) {
         if (!connected(1) && !connected(2))
diff --git a/src/Flf/TimeframeConfusionNetwork.cc b/src/Flf/TimeframeConfusionNetwork.cc
index d3959fce7..f27ab3cbd 100644
--- a/src/Flf/TimeframeConfusionNetwork.cc
+++ b/src/Flf/TimeframeConfusionNetwork.cc
@@ -194,7 +194,8 @@ class FramePosteriorCnFeatures::Internal {
 
 public:
     Internal(ConstPosteriorCnRef cn)
-            : cn_(cn), label_(Fsa::InvalidLabelId) {}
+            : cn_(cn),
+              label_(Fsa::InvalidLabelId) {}
 
     void update(Fsa::LabelId label, Time begin, Time duration) {
         label_ = label;
@@ -289,7 +290,8 @@ class ExtendByFramePosteriorConfidenceLattice : public RescoreLattice {
 
 public:
     ExtendByFramePosteriorConfidenceLattice(ConstLatticeRef l, ConstPosteriorCnRef cn, ScoreId id, RescoreMode rescoreMode)
-            : RescoreLattice(l, rescoreMode), id_(id) {
+            : RescoreLattice(l, rescoreMode),
+              id_(id) {
         verify(cn);
         features_ = FramePosteriorCnFeatures::create(cn);
     }
@@ -380,7 +382,8 @@ class FramePosteriorCnFeatureLattice : public RescoreLattice {
 
 public:
     FramePosteriorCnFeatureLattice(ConstLatticeRef l, ConstPosteriorCnRef cn, const FeatureIds& featureIds, RescoreMode rescoreMode)
-            : Precursor(l, rescoreMode), featureIds_(featureIds) {
+            : Precursor(l, rescoreMode),
+              featureIds_(featureIds) {
         verify(cn);
         features_ = FramePosteriorCnFeatures::create(cn);
     }
diff --git a/src/Flf/TimeframeConfusionNetworkBuilder.cc b/src/Flf/TimeframeConfusionNetworkBuilder.cc
index 0516679cb..94d81bbff 100644
--- a/src/Flf/TimeframeConfusionNetworkBuilder.cc
+++ b/src/Flf/TimeframeConfusionNetworkBuilder.cc
@@ -94,7 +94,11 @@ class FramewiseCollector : public TraverseState {
             PosteriorCn&     cn,
             ConstLatticeRef  l,
             const ArcScores& arcScores)
-            : TraverseState(l), arcScores_(arcScores), cn_(cn), begin_(Core::Type<Time>::max), end_(0) {
+            : TraverseState(l),
+              arcScores_(arcScores),
+              cn_(cn),
+              begin_(Core::Type<Time>::max),
+              end_(0) {
         if (!l->getBoundaries()->valid())
             Core::Application::us()->criticalError("FramewiseCollector: Lattice \"%s\" has no time boundaries", l->describe().c_str());
         traverse();
@@ -150,7 +154,8 @@ class PrecalculatedArcScores {
         State::const_iterator itArc;
         ScoreId               id;
         const_iterator(State::const_iterator itArc, ScoreId id)
-                : itArc(itArc), id(id) {}
+                : itArc(itArc),
+                  id(id) {}
         void operator++() {
             ++itArc;
         }
@@ -171,7 +176,8 @@ class PrecalculatedArcScores {
 
 public:
     PrecalculatedArcScores(ConstLatticeRef l, ScoreId id)
-            : l_(l), id_(id) {}
+            : l_(l),
+              id_(id) {}
     std::pair<const_iterator, const_iterator>
             operator()(Fsa::StateId sid) const {
         ConstStateRef sr = l_->getState(sid);
@@ -231,7 +237,8 @@ class FramePosteriorCnBuilderNode : public Node {
 
 public:
     FramePosteriorCnBuilderNode(const std::string& name, const Core::Configuration& config)
-            : Node(name, config), n_(0) {}
+            : Node(name, config),
+              n_(0) {}
     virtual ~FramePosteriorCnBuilderNode() {}
 
     virtual void init(const std::vector<std::string>& arguments) {
diff --git a/src/Flf/TimeframeConfusionNetworkCombination.cc b/src/Flf/TimeframeConfusionNetworkCombination.cc
index 66005b682..332a63e5c 100644
--- a/src/Flf/TimeframeConfusionNetworkCombination.cc
+++ b/src/Flf/TimeframeConfusionNetworkCombination.cc
@@ -233,7 +233,8 @@ class FramePosteriorCnCombinationNode : public Node {
 
 public:
     FramePosteriorCnCombinationNode(const std::string& name, const Core::Configuration& config)
-            : Node(name, config), weightingScheme_(WeightingSchemeStatic) {}
+            : Node(name, config),
+              weightingScheme_(WeightingSchemeStatic) {}
     virtual ~FramePosteriorCnCombinationNode() {}
 
     virtual void init(const std::vector<std::string>& arguments) {
diff --git a/src/Flf/TimeframeConfusionNetworkIo.cc b/src/Flf/TimeframeConfusionNetworkIo.cc
index 476830666..8751e9705 100644
--- a/src/Flf/TimeframeConfusionNetworkIo.cc
+++ b/src/Flf/TimeframeConfusionNetworkIo.cc
@@ -51,7 +51,8 @@ class PosteriorCnSortingIterator {
 
 private:
     PosteriorCnSortingIterator(ConstPosteriorCnRef cn)
-            : cn_(cn), slot_(0) {
+            : cn_(cn),
+              slot_(0) {
         verify(cn);
     }
 
@@ -246,7 +247,8 @@ class PosteriorCnXmlParser : public Core::XmlSchemaParser {
 
 public:
     PosteriorCnXmlParser(const Core::Configuration& config)
-            : Precursor(config), cn_(0) {
+            : Precursor(config),
+              cn_(0) {
         Core::XmlMixedElement* headerElement = new Core::XmlMixedElementRelay(
                 "head", this, 0, endHandler(&Self::endHeader), 0,
                 XML_CHILD(new Core::XmlMixedElementRelay(
diff --git a/src/Flf/TimeframeError.cc b/src/Flf/TimeframeError.cc
index d6ce6b4d4..ab8436f25 100644
--- a/src/Flf/TimeframeError.cc
+++ b/src/Flf/TimeframeError.cc
@@ -225,7 +225,8 @@ class TimeframeErrorNode : public FilterNode {
 
 public:
     TimeframeErrorNode(const std::string& name, const Core::Configuration& config)
-            : FilterNode(name, config), xml_(config, "dump") {}
+            : FilterNode(name, config),
+              xml_(config, "dump") {}
     virtual ~TimeframeErrorNode() {}
 
     virtual void init(const std::vector<std::string>& arguments) {
@@ -848,7 +849,9 @@ class MinimumFrameWerDecoderNode : public Node {
 
 public:
     MinimumFrameWerDecoderNode(const std::string& name, const Core::Configuration& config)
-            : Node(name, config), n_(0), decoder_(0) {}
+            : Node(name, config),
+              n_(0),
+              decoder_(0) {}
     virtual ~MinimumFrameWerDecoderNode() {
         delete decoder_;
     }
diff --git a/src/Flf/Traceback.cc b/src/Flf/Traceback.cc
index 87f7ec017..673d5db41 100644
--- a/src/Flf/Traceback.cc
+++ b/src/Flf/Traceback.cc
@@ -211,7 +211,10 @@ class DumpTracebackNode : public FilterNode {
         std::string   tail;
 
         CtmPrinter(std::ostream& os)
-                : os(os), name("unknown"), track(1), scoreIds() {}
+                : os(os),
+                  name("unknown"),
+                  track(1),
+                  scoreIds() {}
         void printHeader(ConstSegmentRef segment) {
             printAsText(os << ";; ", segment) << tail << std::endl;
         }
@@ -343,6 +346,7 @@ class DumpTracebackNode : public FilterNode {
             if (dumpPhonemeAlignment_ || dumpSubwordAlignment_) {
                 latticeAlignment = getLatticeAlignment(l);
             }
+
             ConstStateRef initialSr = l->getState(l->initialStateId());
             if (!l->hasProperty(Fsa::PropertyLinear))
                 printAsText(os << ";; ", segment_) << " [1.." << initialSr->nArcs() << "]-best" << std::endl;
@@ -368,6 +372,7 @@ class DumpTracebackNode : public FilterNode {
                 }
                 cp.printHeader(segment_);
                 header_printed = true;
+
                 for (; sr->hasArcs(); sr = p->getState(sr->begin()->target())) {
                     verify(sr->nArcs() == 1);
                     const Arc&      a            = *sr->begin();
@@ -555,7 +560,9 @@ class DumpTracebackNode : public FilterNode {
 
 public:
     DumpTracebackNode(const std::string& name, const Core::Configuration& config)
-            : Precursor(name, config), dump_(config, "dump"), dumpXmlWriter_(0) {}
+            : Precursor(name, config),
+              dump_(config, "dump"),
+              dumpXmlWriter_(0) {}
     virtual ~DumpTracebackNode() {
         delete dumpXmlWriter_;
     }
@@ -694,6 +701,4 @@ const Core::ParameterFloat DumpTracebackNode::paramFrameShiftTime(
 NodeRef createDumpTracebackNode(const std::string& name, const Core::Configuration& config) {
     return NodeRef(new DumpTracebackNode(name, config));
 }
-// -------------------------------------------------------------------------
-
 }  // namespace Flf
diff --git a/src/Flf/Union.cc b/src/Flf/Union.cc
index 21bbef92f..df07046be 100644
--- a/src/Flf/Union.cc
+++ b/src/Flf/Union.cc
@@ -40,7 +40,9 @@ class UnionBoundaries : public Boundaries {
 
 public:
     UnionBoundaries(const ConstLatticeRefList& lats)
-            : Boundaries(), nLats_(lats.size()), boundaries_(lats.size()) {
+            : Boundaries(),
+              nLats_(lats.size()),
+              boundaries_(lats.size()) {
         boundaries_[0]   = lats[0]->getBoundaries();
         initialBoundary_ = boundaries_[0]->get(lats[0]->initialStateId());
         for (u32 i = 1; i < nLats_; ++i) {
@@ -93,7 +95,10 @@ class UnionLattice : public SlaveLattice {
 
 public:
     UnionLattice(const ConstLatticeRefList& lats, ConstSemiringRef semiring)
-            : SlaveLattice(lats[0]), nLats_(lats.size()), lats_(lats), semiring_(semiring) {
+            : SlaveLattice(lats[0]),
+              nLats_(lats.size()),
+              lats_(lats),
+              semiring_(semiring) {
         verify(semiring);
         bool hasBoundaries = false;
         for (u32 i = 0; i < nLats_; ++i) {
@@ -240,7 +245,8 @@ NodeRef createUnionNode(const std::string& name, const Core::Configuration& conf
 namespace {
 struct MeshedFullBoundaryBuilder {
     typedef Fsa::Hash<Boundary, Boundary::Hash, Boundary::Equal> HashList;
-    Boundary                                                     operator()(const Boundary& b) const {
+
+    Boundary operator()(const Boundary& b) const {
         return b;
     }
 };
@@ -251,13 +257,16 @@ struct MeshedTimeBoundaryBuilder {
             return size_t(b.time());
         }
     };
+
     struct BoundaryTimeEqual {
         bool operator()(const Boundary& b1, const Boundary& b2) const {
             return b1.time() == b2.time();
         }
     };
+
     typedef Fsa::Hash<Boundary, Boundary::Hash, Boundary::Equal> HashList;
-    Boundary                                                     operator()(const Boundary& b) const {
+
+    Boundary operator()(const Boundary& b) const {
         return Boundary(b.time());
     }
 };
@@ -294,8 +303,6 @@ ConstLatticeRef expandTransits(ConstLatticeRef lat, Bliss::Phoneme::Id leftConte
         std::multimap<int, u32>           initialPhoneArcs;
         std::set<int>                     finalPhones, initialPhones;
 
-        bool hasRealInArcs = false;
-
         for (Hypotheses::const_iterator inHypIt = inArcs.begin();
              inHypIt != inHypEnd; ++inHypIt) {
             Bliss::Phoneme::Id final = Bliss::Phoneme::term;
@@ -305,8 +312,7 @@ ConstLatticeRef expandTransits(ConstLatticeRef lat, Bliss::Phoneme::Id leftConte
             else {
                 const Bliss::LemmaPronunciation* pron = lpAlphabet->lemmaPronunciation(inHypIt->second.second.input());
                 if (pron && pron->pronunciation()->length()) {
-                    hasRealInArcs = true;
-                    final         = pron->pronunciation()->phonemes()[pron->pronunciation()->length() - 1];
+                    final = pron->pronunciation()->phonemes()[pron->pronunciation()->length() - 1];
                 }
             }
             if (final != Bliss::Phoneme::term && lexicon->phonemeInventory()->phoneme(final)->isContextDependent()) {
diff --git a/src/Flf/check.cc b/src/Flf/check.cc
index 2eb1a5f44..a146d6014 100644
--- a/src/Flf/check.cc
+++ b/src/Flf/check.cc
@@ -50,6 +50,6 @@ class MyApplication : public Core::Application {
         std::cout << semiring->describe(semiring->uncompress(vIt), Fsa::HintShowDetails) << std::endl;
         return 0;
     }
-} app;  // <- You have to create ONE instance of the application
+};
 
 APPLICATION(MyApplication)
diff --git a/src/Flow/Aggregate.hh b/src/Flow/Aggregate.hh
index a147e9b9a..3890354a3 100644
--- a/src/Flow/Aggregate.hh
+++ b/src/Flow/Aggregate.hh
@@ -53,7 +53,8 @@ public:
             : Timestamp(type()) {}
     template<class InputIterator>
     Aggregate(InputIterator begin, InputIterator end)
-            : Timestamp(type()), Precursor(begin, end) {}
+            : Timestamp(type()),
+              Precursor(begin, end) {}
     virtual ~Aggregate() {}
 
     virtual Data* clone() const {
@@ -75,7 +76,7 @@ public:
     template<class T>
     bool get(std::vector<DataPtr<T>>& d) {
         std::vector<DataPtr<T>> dd(begin(), end());
-        if (std::find_if(dd.begin(), dd.end(), std::bind2nd(std::equal_to<bool>(), false)) != dd.end())
+        if (std::find_if(dd.begin(), dd.end(), std::bind(std::equal_to<bool>(), std::placeholders::_1, false)) != dd.end())
             return false;
         d = dd;
         return true;
@@ -98,7 +99,8 @@ public:
         return std::string("generic-aggregation");
     }
     AggregationNode(const Core::Configuration& c)
-            : Core::Component(c), Precursor(c) {}
+            : Core::Component(c),
+              Precursor(c) {}
     virtual ~AggregationNode() {}
 
     virtual bool configure();
diff --git a/src/Flow/Cache.cc b/src/Flow/Cache.cc
index 8725703b8..376a66b94 100644
--- a/src/Flow/Cache.cc
+++ b/src/Flow/Cache.cc
@@ -22,7 +22,8 @@ using namespace Flow;
 /******************************************************************************/
 
 CacheReader::CacheReader(Cache* cache, const std::string& name)
-        : Cached(cache, name), reader(*cache->archive_, name) {
+        : Cached(cache, name),
+          reader(*cache->archive_, name) {
     data_.resize(0);
     position_ = 0;
 }
@@ -70,7 +71,9 @@ Data* CacheReader::getData() {
 /******************************************************************************/
 
 CacheWriter::CacheWriter(Cache* cache, const std::string& name)
-        : Cached(cache, name), writer(*cache->archive_, name, cache->compress_), datatype_(0) {
+        : Cached(cache, name),
+          writer(*cache->archive_, name, cache->compress_),
+          datatype_(0) {
 }
 
 /******************************************************************************/
diff --git a/src/Flow/Cache.hh b/src/Flow/Cache.hh
index e23552b66..c4fb4057e 100644
--- a/src/Flow/Cache.hh
+++ b/src/Flow/Cache.hh
@@ -52,7 +52,8 @@ protected:
 
 public:
     Cached(Cache* cache, const std::string& name)
-            : name_(name), cache_(cache) {}
+            : name_(name),
+              cache_(cache) {}
 };
 
 class CacheReader : public Cached {
@@ -62,9 +63,11 @@ private:
 
 public:
     CacheReader(Cache* cache, const std::string& name);
+
     void  readData();
     Data* getData();
-    bool  isOpen() const {
+
+    bool isOpen() const {
         return reader.isOpen();
     }
 };
@@ -125,6 +128,7 @@ public:
         return path_;
     }
     void setPath(const std::string& path) {
+        log("path = %s", path.c_str());
         path_ = path;
     }
     void setPrefix(const std::string& prefix) {
diff --git a/src/Flow/Collector.hh b/src/Flow/Collector.hh
index ebb9136c2..5c34e2f0c 100644
--- a/src/Flow/Collector.hh
+++ b/src/Flow/Collector.hh
@@ -122,7 +122,7 @@ bool CollectorNode<I, O>::putNullData() {
     if (checkSameLength_) {
         typename std::vector<InputFrame>::iterator hasData =
                 std::find_if(inputData_.begin(), inputData_.end(),
-                             std::bind2nd(std::equal_to<bool>(), true));
+                             std::bind(std::equal_to<bool>(), std::placeholders::_1, true));
 
         if (hasData != inputData_.end())
             criticalError("Input streams have different length.");
@@ -130,7 +130,7 @@ bool CollectorNode<I, O>::putNullData() {
 
     typename std::vector<InputFrame>::iterator noData =
             std::find_if(inputData_.begin(), inputData_.end(),
-                         std::bind2nd(std::equal_to<bool>(), false));
+                         std::bind(std::equal_to<bool>(), std::placeholders::_1, false));
 
     if (noData == inputData_.end())
         return putEos(0);
diff --git a/src/Flow/CorpusKeyMap.hh b/src/Flow/CorpusKeyMap.hh
index 1f91ec5c6..ab6525fdb 100644
--- a/src/Flow/CorpusKeyMap.hh
+++ b/src/Flow/CorpusKeyMap.hh
@@ -30,26 +30,27 @@ private:
     static const Core::ParameterFloat  paramEndTime;
 
 private:
-    bool sent_;
-    bool send(const std::string& value);
+    typedef Core::StringHashMap<std::string> Map;
 
+    bool        sent_;
     std::string key_;
-    void        setKey(const std::string& key);
+    Map         map_;
+    std::string defaultOutput_;
+    Time        startTime_;
+    Time        endTime_;
 
-    typedef Core::StringHashMap<std::string> Map;
-    Map                                      map_;
-    void                                     setMapFile(const std::string& filename);
+    bool send(const std::string& value);
+    void setKey(const std::string& key);
+    void setMapFile(const std::string& filename);
 
-    std::string defaultOutput_;
-    void        setDefaultOutput(const std::string& defaultOutput) {
+    void setDefaultOutput(const std::string& defaultOutput) {
         defaultOutput_ = defaultOutput;
     }
 
-    Time startTime_;
     void setStartTime(Time time) {
         startTime_ = time;
     }
-    Time endTime_;
+
     void setEndTime(Time time) {
         endTime_ = time;
     }
diff --git a/src/Flow/Data.hh b/src/Flow/Data.hh
index f07765320..7243c4608 100644
--- a/src/Flow/Data.hh
+++ b/src/Flow/Data.hh
@@ -47,19 +47,10 @@ private:
 
 private:
     Data(u32 rc)
-            : Precursor(rc), datatype_(type()) {}
+            : Precursor(rc),
+              datatype_(type()) {}
     static const Datatype* type();
 
-    /** sentinel for void pointer
-     *  Note: Precursor::Sentinel is overriden to create a sentinel of Data
-     *  instead the precursor class. In this way, all the sentinels are Data objects and can be
-     *  handled equally. @see dump method as an example.
-     */
-    static inline Data* sentinel() {
-        static Data sentinel_(1);
-        return &sentinel_;
-    }
-
 protected:
     virtual void free() const;
 
@@ -108,10 +99,12 @@ public:
 
     // enable support for ascii output (dump filter)
     virtual Core::XmlWriter& dump(Core::XmlWriter&) const;
-    virtual bool             read(Core::BinaryInputStream&) {
+
+    virtual bool read(Core::BinaryInputStream&) {
         defect();
         return false;
     }
+
     virtual bool write(Core::BinaryOutputStream&) const {
         defect();
         return false;
@@ -185,6 +178,7 @@ public:
             : Precursor(p) {}
     template<class S>
     explicit DataPtr(const DataPtr<S>& p) {
+        this->unreference();
         Precursor::object_ = convert(p._get());
         Precursor::reference();
     }
@@ -207,6 +201,9 @@ public:
      *  Remark: overriding of the precursor function is necessary because
      *  in comparisons the compiler uses Precursor::operator bool() instead of Precursor::operator==.
      */
+    operator bool() const {
+        return T::isNotSentinel(Precursor::object_);
+    }
     bool operator==(const DataPtr& r) const {
         return Precursor::operator==(r);
     }
diff --git a/src/Flow/DataAdaptor.hh b/src/Flow/DataAdaptor.hh
index c9cd3a23e..a5c5de91b 100644
--- a/src/Flow/DataAdaptor.hh
+++ b/src/Flow/DataAdaptor.hh
@@ -51,7 +51,8 @@ public:
     DataAdaptor()
             : NetworkData(type()){};
     explicit DataAdaptor(const Type& d)
-            : NetworkData(type()), data_(d) {}
+            : NetworkData(type()),
+              data_(d) {}
     virtual ~DataAdaptor() {}
 
     static const Datatype* type() {
diff --git a/src/Flow/Demo.cc b/src/Flow/Demo.cc
index 8ddba5948..03940a40d 100644
--- a/src/Flow/Demo.cc
+++ b/src/Flow/Demo.cc
@@ -25,7 +25,12 @@ const Core::ParameterInt DemoNode::paramMaxInputs_("max-input-nodes", "maximum n
 // =======================================================
 
 DemoNode::DemoNode(const Core::Configuration& c)
-        : Core::Component(c), Precursor(c), demoChannel_(c, "demo-info"), maxInputs_(1), isFirstInPort_(true), isFirstOutPort_(true) {
+        : Core::Component(c),
+          Precursor(c),
+          demoChannel_(c, "demo-info"),
+          maxInputs_(1),
+          isFirstInPort_(true),
+          isFirstOutPort_(true) {
     // note that attributesChannel_ and dataChannel_ are inherited from base class Flow::Node
     // and can be set using dump-attributes = <file> and dump-data = <file>
     // i.e. if you just want to dump the attributes and the data seen by the demo node and not of all nodes use
diff --git a/src/Flow/Dump.hh b/src/Flow/Dump.hh
index dd4e5a67e..e3a7d3bc7 100644
--- a/src/Flow/Dump.hh
+++ b/src/Flow/Dump.hh
@@ -57,7 +57,9 @@ private:
 
 public:
     VectorAbsValDumpNode(const Core::Configuration& c)
-            : Core::Component(c), DumpNode(c), normFunction_(c) {}
+            : Core::Component(c),
+              DumpNode(c),
+              normFunction_(c) {}
 
     virtual bool configure() {
         Core::Ref<const Attributes> a = getInputAttributes(0);
diff --git a/src/Flow/InputNode.cc b/src/Flow/InputNode.cc
index abe312446..213f5df79 100644
--- a/src/Flow/InputNode.cc
+++ b/src/Flow/InputNode.cc
@@ -1,18 +1,21 @@
 #include "InputNode.hh"
+
 #include "Timestamp.hh"
 #include "Vector.hh"
 
-using namespace Flow;
-
 namespace {
+
 template<typename T>
 Flow::Timestamp* createTimestamp(T const* data, unsigned num_samples) {
     Flow::Vector<T>* out = new Flow::Vector<T>(num_samples);
     std::copy(data, data + num_samples, out->data());
     return out;
 }
+
 }  // namespace
 
+namespace Flow {
+
 const Core::ParameterInt    InputNode::paramSampleRate("sample-rate", "sample rate of input data", 1, 1);
 const Core::Choice          InputNode::choiceSampleType("s8", static_cast<unsigned>(Flow::SampleType::SampleTypeS8),
                                                         "u8", static_cast<unsigned>(Flow::SampleType::SampleTypeU8),
@@ -88,17 +91,20 @@ bool InputNode::configure() {
 
 bool InputNode::work(Flow::PortId out) {
     unsigned sample_size = static_cast<unsigned>(sampleType_) & 0xFF;
+
     if ((not(eos_ and not eosReceived_)) and (queue_.size() < blockSize_ * sample_size)) {
         do {  // at least once call byteStreamAppender because it might remove the eos status
             byteStreamAppender_(queue_);
         } while (queue_.size() < blockSize_ * sample_size and not eos_);
     }
+
     if (queue_.empty()) {
         if (resetSampleCount_) {
             sampleCount_ = 0ul;
         }
         return putEos(out);
     }
+
     // remove possible partial samples at EOS
     unsigned full_samples = queue_.size() / sample_size;
     if (eos_ and queue_.size() % sample_size != 0ul) {
@@ -111,6 +117,7 @@ bool InputNode::work(Flow::PortId out) {
             queue_.resize(full_samples * sample_size);
         }
     }
+
     unsigned          num_samples = std::min<unsigned>(blockSize_, full_samples);
     std::vector<char> buffer(num_samples * sample_size);
     std::copy(queue_.begin(), queue_.begin() + num_samples * sample_size, buffer.begin());
@@ -118,6 +125,7 @@ bool InputNode::work(Flow::PortId out) {
         queue_.front() = 0;  // erase data
         queue_.pop_front();
     }
+
     Flow::Timestamp* v = nullptr;
     switch (sampleType_) {
         case Flow::SampleType::SampleTypeS8:
@@ -139,11 +147,16 @@ bool InputNode::work(Flow::PortId out) {
             error("unsupported sample type: %d", static_cast<unsigned>(sampleType_));
             return false;
     }
+
     for (unsigned i = 0ul; i < num_samples; i++) {
         std::fill(buffer.begin(), buffer.end(), 0);  // erase data
     }
+
     v->setStartTime(Flow::Time(sampleCount_) / Flow::Time(sampleRate_) / Flow::Time(trackCount_));
     sampleCount_ += num_samples;
     v->setEndTime(Flow::Time(sampleCount_) / Flow::Time(sampleRate_) / Flow::Time(trackCount_));
+
     return putData(out, v);
 }
+
+}  // namespace Flow
diff --git a/src/Flow/InputNode.hh b/src/Flow/InputNode.hh
index 9e7ed351b..30c99d4c8 100644
--- a/src/Flow/InputNode.hh
+++ b/src/Flow/InputNode.hh
@@ -1,40 +1,49 @@
 #ifndef STREAMING_INPUT_NODE_HH
 #define STREAMING_INPUT_NODE_HH
+
 #include <functional>
 #include <queue>
-#include "Node.hh"
 
-using ByteStreamAppender = std::function<void(std::deque<char>&)>;
+#include "Node.hh"
 
 namespace Flow {
 
+using ByteStreamAppender = std::function<void(std::deque<char>&)>;
+
+/** Flow node for streaming */
 class InputNode : public Flow::SourceNode {
 public:
     using Precursor = Flow::SourceNode;
+
     static const Core::ParameterInt    paramSampleRate;
     static const Core::Choice          choiceSampleType;
     static const Core::ParameterChoice paramSampleType;
     static const Core::ParameterInt    paramTrackCount;
     static const Core::ParameterInt    paramBlockSize;
-    static std::string                 filterName();
+
+    static std::string filterName();
+
     InputNode(const Core::Configuration& c);
     virtual ~InputNode() = default;
+
     virtual bool setParameter(const std::string& name, const std::string& value);
     virtual bool configure();
     virtual bool work(Flow::PortId out);
-    void         setByteStreamAppender(ByteStreamAppender const& bsa);
-    bool         getEOS() const;
-    void         setEOS(bool eos);
-    bool         getEOSReceived() const;
-    void         setEOSReceived(bool eosReceived);
-    bool         getResetSampleCount() const;
-    void         setResetSampleCount(bool resetSampleCount);
+
+    void setByteStreamAppender(ByteStreamAppender const& bsa);
+    bool getEOS() const;
+    void setEOS(bool eos);
+    bool getEOSReceived() const;
+    void setEOSReceived(bool eosReceived);
+    bool getResetSampleCount() const;
+    void setResetSampleCount(bool resetSampleCount);
 
 private:
-    unsigned           sampleRate_;
-    Flow::SampleType   sampleType_;
-    unsigned           trackCount_;
-    unsigned           blockSize_;
+    unsigned         sampleRate_;
+    Flow::SampleType sampleType_;
+    unsigned         trackCount_;
+    unsigned         blockSize_;
+
     ByteStreamAppender byteStreamAppender_;
     std::deque<char>   queue_;
     unsigned           sampleCount_;
@@ -44,27 +53,35 @@ private:
 };
 
 // ---------- inline implementations ----------
+
 inline std::string InputNode::filterName() {
     return "stream-input";
 }
+
 inline void InputNode::setByteStreamAppender(ByteStreamAppender const& bsa) {
     byteStreamAppender_ = bsa;
 }
+
 inline bool InputNode::getEOS() const {
     return eos_;
 }
+
 inline void InputNode::setEOS(bool eos) {
     eos_ = eos;
 }
+
 inline bool InputNode::getEOSReceived() const {
     return eosReceived_;
 }
+
 inline void InputNode::setEOSReceived(bool eosReceived) {
     eosReceived_ = eosReceived;
 }
+
 inline bool InputNode::getResetSampleCount() const {
     return resetSampleCount_;
 }
+
 inline void InputNode::setResetSampleCount(bool resetSampleCount) {
     resetSampleCount_ = resetSampleCount;
 }
diff --git a/src/Flow/Link.hh b/src/Flow/Link.hh
index 7d43e6b54..0a003616b 100644
--- a/src/Flow/Link.hh
+++ b/src/Flow/Link.hh
@@ -76,14 +76,15 @@ public:
                 fast_data_ = sentinelEmpty();
             }
             else {
-                // Link is fast and empty: it tipically happens if the "from" node
+                // Link is fast and empty: it typically happens if the "from" node
                 // did not produce a data in the last call to its work method.
                 verify(!queue_.isEmpty());
                 queue_.get(d);
             }
         }
-        else
+        else {
             queue_.getBlocking(d);
+        }
 
         return d;
     }
diff --git a/src/Flow/Makefile b/src/Flow/Makefile
index 3362c3044..7e4328227 100644
--- a/src/Flow/Makefile
+++ b/src/Flow/Makefile
@@ -20,6 +20,7 @@ LIBSPRINTFLOW_O	= $(OBJDIR)/AbstractNode.o \
 		  $(OBJDIR)/Datatype.o \
 		  $(OBJDIR)/Demo.o \
 		  $(OBJDIR)/Dump.o \
+		  $(OBJDIR)/InputNode.o \
 		  $(OBJDIR)/Link.o \
 		  $(OBJDIR)/Module.o \
 		  $(OBJDIR)/Network.o \
@@ -33,8 +34,7 @@ LIBSPRINTFLOW_O	= $(OBJDIR)/AbstractNode.o \
 		  $(OBJDIR)/Synchronization.o \
 		  $(OBJDIR)/Timestamp.o \
 		  $(OBJDIR)/Vector.o \
-		  $(OBJDIR)/VectorTextInput.o \
-		  $(OBJDIR)/InputNode.o
+		  $(OBJDIR)/VectorTextInput.o
 
 CHECK_O		= $(OBJDIR)/check.o \
                   libSprintFlow.$(a) \
diff --git a/src/Flow/Module.cc b/src/Flow/Module.cc
index c0ca1911c..b929f118c 100644
--- a/src/Flow/Module.cc
+++ b/src/Flow/Module.cc
@@ -141,11 +141,15 @@ Module_::Module_() {
     registry.registerFilter<SequenceFilterNode>();
     registry.registerFilter<WarpTimeFilterNode>();
 
+    registry.registerFilter<Flow::InputNode>();
+
     // register datatypes
     registry.registerDatatype<Timestamp>();
     registry.registerDatatype<Float32>();
     registry.registerDatatype<Float64>();
+    registry.registerDatatype<Vector<u8>>();
     registry.registerDatatype<Vector<s8>>();
+    registry.registerDatatype<Vector<u16>>();
     registry.registerDatatype<Vector<s16>>();
     registry.registerDatatype<Vector<u32>>();
     registry.registerDatatype<Vector<f32>>();
@@ -160,6 +164,4 @@ Module_::Module_() {
     registry.registerDatatype<TypedAggregate<Vector<f32>>>();
     registry.registerDatatype<Flow::DataAdaptor<Math::Matrix<f32>>>();
     registry.registerDatatype<Flow::DataAdaptor<Math::Matrix<f64>>>();
-
-    registry.registerFilter<Flow::InputNode>();
 }
diff --git a/src/Flow/Network.cc b/src/Flow/Network.cc
index 9375baf4a..783c723f3 100644
--- a/src/Flow/Network.cc
+++ b/src/Flow/Network.cc
@@ -815,32 +815,26 @@ bool Network::dump(const bool initialCall, Core::XmlChannel& dumpChannel, std::s
 /******************************************************************************/
 
 std::ostream& Flow::operator<<(std::ostream& o, const Network& n) {
-    bool dumped = false;
-
     if (!n.name().empty()) {
         o << "network: '" << n.name() << "'";
         if (n.isThreaded())
             o << " threaded ";
-        dumped = true;
         o << std::endl;
     }
     if (n.params_.size()) {
         o << "param(s): ";
         std::copy(n.params_.begin(), n.params_.end(),
                   std::ostream_iterator<Network::Parameter>(o, "\n"));
-        dumped = true;
     }
     if (n.inputs_.size()) {
         o << "input(s): ";
         std::copy(n.inputs_.begin(), n.inputs_.end(),
                   std::ostream_iterator<Network::Port>(o, "\n"));
-        dumped = true;
     }
     if (n.outputs_.size()) {
         o << "output(s): ";
         std::copy(n.outputs_.begin(), n.outputs_.end(),
                   std::ostream_iterator<Network::Port>(o, "\n"));
-        dumped = true;
     }
     o << "node(s):" << std::endl;
     std::copy(n.nodes_.begin(), n.nodes_.end(), std::ostream_iterator<AbstractNode*>(o, "\n"));
diff --git a/src/Flow/Network.hh b/src/Flow/Network.hh
index 0a1196afa..abbb0d3af 100644
--- a/src/Flow/Network.hh
+++ b/src/Flow/Network.hh
@@ -70,7 +70,8 @@ private:
             AbstractNode* by;
             std::string   as;
             Use(AbstractNode* _by, const std::string& _as)
-                    : by(_by), as(_as) {}
+                    : by(_by),
+                      as(_as) {}
         };
 
     private:
@@ -408,17 +409,6 @@ public:
     /** Resets all links and nodes. */
     void reset();
 
-    void go();
-
-    friend std::ostream& operator<<(std::ostream& o, const Network& n);
-
-    void setFilename(const std::string& f) {
-        filename_ = f;
-    }
-    const std::string& filename() const {
-        return filename_;
-    }
-
     void configureAll() {
         for (auto n : nodes_) {
             auto* network = dynamic_cast<Flow::Network*>(n);
@@ -429,6 +419,17 @@ public:
         }
     }
 
+    void go();
+
+    friend std::ostream& operator<<(std::ostream& o, const Network& n);
+
+    void setFilename(const std::string& f) {
+        filename_ = f;
+    }
+
+    const std::string& filename() const {
+        return filename_;
+    }
 };  // class Network
 
 /*****************************************************************************/
diff --git a/src/Flow/NetworkParser.cc b/src/Flow/NetworkParser.cc
index fe7bb2c8e..45aa2ef35 100644
--- a/src/Flow/NetworkParser.cc
+++ b/src/Flow/NetworkParser.cc
@@ -15,6 +15,7 @@
 #include "NetworkParser.hh"
 #include <Core/CacheManager.hh>
 #include <Core/Directory.hh>
+#include <Core/IoUtilities.hh>
 #include <Modules.hh>
 #include <cstdlib>
 #include "Filter.hh"
@@ -275,14 +276,11 @@ bool NodeBuilder::findNetworkFile(const std::string& pathname, std::string& foun
     std::vector<std::string> paths;
     paths.push_back(currentDirectory_);
     paths.push_back(paramNetworkFilePath(config));
-    char* ret;
 
     for (std::vector<std::string>::const_iterator p = paths.begin(); p != paths.end(); ++p) {
         std::string result = Core::joinPaths(*p, pathnameWithExtension);
         if (Core::isRegularFile(result)) {
-            char realname[PATH_MAX + 1];
-            ret           = realpath(result.c_str(), realname);  // absolute path
-            foundPathname = std::string(realname);
+            foundPathname = Core::realPath(result);
             return true;
         }
     }
diff --git a/src/Flow/Node.hh b/src/Flow/Node.hh
index b704830d3..e2940f370 100644
--- a/src/Flow/Node.hh
+++ b/src/Flow/Node.hh
@@ -188,7 +188,8 @@ public:
 class SinkNode : public Node {
 public:
     SinkNode(const Core::Configuration& c)
-            : Core::Component(c), Node(c) {
+            : Core::Component(c),
+              Node(c) {
         addInput(0);
     }
     virtual PortId getInput(const std::string& name) {
@@ -201,7 +202,8 @@ public:
 class SourceNode : public Node {
 public:
     SourceNode(const Core::Configuration& c)
-            : Core::Component(c), Node(c) {
+            : Core::Component(c),
+              Node(c) {
         addOutput(0);
     }
     virtual PortId getOutput(const std::string& name) {
@@ -212,7 +214,8 @@ public:
 class SleeveNode : public Node {
 public:
     SleeveNode(const Core::Configuration& c)
-            : Core::Component(c), Node(c) {
+            : Core::Component(c),
+              Node(c) {
         addInput(0);
         addOutput(0);
     }
diff --git a/src/Flow/Pipe.hh b/src/Flow/Pipe.hh
index d48d89269..1c2601370 100644
--- a/src/Flow/Pipe.hh
+++ b/src/Flow/Pipe.hh
@@ -37,7 +37,10 @@ public:
         return "generic-pipe";
     }
     PipeNode(const Core::Configuration& c)
-            : Core::Component(c), SourceNode(c), changed_(true), pipe_(0) {}
+            : Core::Component(c),
+              SourceNode(c),
+              changed_(true),
+              pipe_(0) {}
     virtual ~PipeNode() {
         if (pipe_)
             pclose(pipe_);
diff --git a/src/Flow/QuantizedVector.hh b/src/Flow/QuantizedVector.hh
index c86de75ad..c3d794310 100644
--- a/src/Flow/QuantizedVector.hh
+++ b/src/Flow/QuantizedVector.hh
@@ -37,9 +37,11 @@ public:
     Vector()
             : Data(&Datatype<Self>::type){};
     Vector(int size)
-            : Data(&Datatype<Self>::type), std::vector<T>(size) {}
+            : Data(&Datatype<Self>::type),
+              std::vector<T>(size) {}
     Vector(const std::vector<T>& v)
-            : Data(&Datatype<Self>::type), std::vector<T>(v) {}
+            : Data(&Datatype<Self>::type),
+              std::vector<T>(v) {}
     virtual ~Vector() {}
 
     virtual Data* clone() {
@@ -97,9 +99,12 @@ private:
 
 public:
     NamedVector(const std::string& name = "")
-            : Data(&Datatype<Self>::type), name_(name) {}
+            : Data(&Datatype<Self>::type),
+              name_(name) {}
     NamedVector(const std::string& name, int size)
-            : Data(&Datatype<Self>::type), Vector<T>(size), name_(name) {}
+            : Data(&Datatype<Self>::type),
+              Vector<T>(size),
+              name_(name) {}
     virtual ~NamedVector() {}
 
     const std::string name() const {
diff --git a/src/Flow/SimpleFunction.hh b/src/Flow/SimpleFunction.hh
index c1b7d9c61..66dd49ac7 100644
--- a/src/Flow/SimpleFunction.hh
+++ b/src/Flow/SimpleFunction.hh
@@ -88,7 +88,7 @@ class VectorLnFunctionSave : public SimpleFunction<Vector<T>, T> {
 public:
     void apply(Vector<T>& v, T) {
         const T tinyValue = 1.175494e-38;
-        std::transform(v.begin(), v.end(), v.begin(), std::bind2nd(std::plus<T>(), tinyValue));
+        std::transform(v.begin(), v.end(), v.begin(), std::bind(std::plus<T>(), std::placeholders::_1, tinyValue));
         std::transform(v.begin(), v.end(), v.begin(), static_cast<T (*)(T)>(std::log));
     }
     static std::string name() {
@@ -402,7 +402,7 @@ public:
         T maxValue = *std::max_element(v.begin(), v.end());
         /* v[i] = v[i] - MAX(v) */
         std::transform(v.begin(), v.end(), v.begin(),
-                       std::bind2nd(std::plus<T>(), -maxValue));
+                       std::bind(std::plus<T>(), std::placeholders::_1, -maxValue));
         /* v[i] = exp( v[i] - MAX(v) )*/
         std::transform(v.begin(), v.end(), v.begin(), static_cast<T (*)(T)>(std::exp));
 
@@ -410,7 +410,7 @@ public:
         T sumValue = std::accumulate(v.begin(), v.end(), (T)0);
         /* exp( (v[i] - MAX(v)) ) / sum( exp( (v[i] - MAX(v)) ) ) */
         std::transform(v.begin(), v.end(), v.begin(),
-                       std::bind2nd(std::multiplies<T>(), (T)1 / sumValue));
+                       std::bind(std::multiplies<T>(), std::placeholders::_1, (T)1 / sumValue));
     }
 
     static std::string name() {
@@ -471,7 +471,8 @@ public:
 
 template<class Function>
 SimpleFunctionNode<Function>::SimpleFunctionNode(const Core::Configuration& c)
-        : Component(c), SleeveNode(c) {
+        : Component(c),
+          SleeveNode(c) {
     setFunctionParameter(paramSimpleFunctionParameter(c));
 }
 
diff --git a/src/Flow/Synchronization.cc b/src/Flow/Synchronization.cc
index f0485f35c..05ba3d8f7 100644
--- a/src/Flow/Synchronization.cc
+++ b/src/Flow/Synchronization.cc
@@ -32,7 +32,7 @@ bool Synchronization::work(const Timestamp& time, DataPointer& dataPointer) {
         }
     } while (Core::isSignificantlyGreater(startTime, in->startTime(), timeTolerance));
 
-    if (!Core::isAlmostEqual(startTime, in->startTime(), timeTolerance)) {
+    if (!Core::isAlmostEqualUlp(startTime, in->startTime(), timeToleranceUlp)) {
         lastError_ = Core::form("Input stream has no element with the start-time %f.", startTime);
         return false;
     }
diff --git a/src/Flow/TypeConverter.hh b/src/Flow/TypeConverter.hh
index 8ccfa275d..67e1fc238 100644
--- a/src/Flow/TypeConverter.hh
+++ b/src/Flow/TypeConverter.hh
@@ -123,7 +123,9 @@ public:
         return std::string("generic-convert-") + In::type()->name() + "-to-" + Out::type()->name();
     }
     TypeConverterNode(const Core::Configuration& c)
-            : Component(c), SleeveNode(c), converter_(c) {}
+            : Component(c),
+              SleeveNode(c),
+              converter_(c) {}
     virtual ~TypeConverterNode() {}
 
     virtual bool configure();
diff --git a/src/Flow/TypedAggregate.hh b/src/Flow/TypedAggregate.hh
index 36b57f574..5e5686fec 100644
--- a/src/Flow/TypedAggregate.hh
+++ b/src/Flow/TypedAggregate.hh
@@ -46,7 +46,8 @@ public:
     TypedAggregate()
             : Timestamp(type()) {}
     TypedAggregate(PrecursorVector& v)
-            : Timestamp(type()), PrecursorVector(v) {}
+            : Timestamp(type()),
+              PrecursorVector(v) {}
     virtual ~TypedAggregate() {}
 
     virtual Data* clone() const {
@@ -110,7 +111,8 @@ public:
         return std::string("generic-aggregation-" + DataType::type()->name());
     }
     TypedAggregateNode(const Core::Configuration& c)
-            : Core::Component(c), Precursor(c) {}
+            : Core::Component(c),
+              Precursor(c) {}
     virtual ~TypedAggregateNode() {}
 
     virtual TypedAggregate<DataType>* merge(std::vector<DataPtr<DataType>>& inputData) {
@@ -128,7 +130,8 @@ public:
         return std::string("generic-disaggregation-" + DataType::type()->name());
     }
     TypedDisaggregateNode(const Core::Configuration& c)
-            : Core::Component(c), Precursor(c) {
+            : Core::Component(c),
+              Precursor(c) {
         addInput(0);
     }
     virtual ~TypedDisaggregateNode() {}
diff --git a/src/Flow/Vector.hh b/src/Flow/Vector.hh
index f3914d4a2..594bd19cc 100644
--- a/src/Flow/Vector.hh
+++ b/src/Flow/Vector.hh
@@ -48,16 +48,19 @@ public:
     Vector()
             : Timestamp(type()){};
     Vector(size_t size)
-            : Timestamp(type()), std::vector<T>(size) {}
+            : Timestamp(type()),
+              std::vector<T>(size) {}
     Vector(size_t n, const T& t)
-            : Timestamp(type()), std::vector<T>(n, t) {}
+            : Timestamp(type()),
+              std::vector<T>(n, t) {}
     Vector(const std::vector<T>& v)
             : Timestamp(type()), std::vector<T>(v) {}
     Vector(const std::vector<T>& v, Time start, Time end)
             : Timestamp(start, end), std::vector<T>(v) {}
     template<class InputIterator>
     Vector(InputIterator begin, InputIterator end)
-            : Timestamp(type()), std::vector<T>(begin, end) {}
+            : Timestamp(type()),
+              std::vector<T>(begin, end) {}
 
     virtual ~Vector() {}
 
diff --git a/src/Flow/VectorConcat.hh b/src/Flow/VectorConcat.hh
index bca05144f..b54dcd17e 100644
--- a/src/Flow/VectorConcat.hh
+++ b/src/Flow/VectorConcat.hh
@@ -45,7 +45,9 @@ public:
         return std::string("generic-vector-") + Core::NameHelper<T>() + "-concat";
     }
     VectorConcatNode(const Core::Configuration& c)
-            : Core::Component(c), Precursor(c), output_size_(0) {}
+            : Core::Component(c),
+              Precursor(c),
+              output_size_(0) {}
     virtual ~VectorConcatNode() {}
 
     virtual bool configure() {
diff --git a/src/Flow/VectorInterleave.hh b/src/Flow/VectorInterleave.hh
index 3f6d03425..fd972fd38 100644
--- a/src/Flow/VectorInterleave.hh
+++ b/src/Flow/VectorInterleave.hh
@@ -52,7 +52,8 @@ public:
         return std::string("generic-vector-") + Core::Type<T>::name + "-interleave";
     }
     VectorInterleaveNode(const Core::Configuration& c)
-            : Core::Component(c), Precursor(c) {}
+            : Core::Component(c),
+              Precursor(c) {}
     virtual ~VectorInterleaveNode() {}
 
     virtual Vector<T>* merge(std::vector<DataPtr<Vector<T>>>& inputData) {
diff --git a/src/Flow/VectorMalformed.hh b/src/Flow/VectorMalformed.hh
index 31001243b..34b4580c9 100644
--- a/src/Flow/VectorMalformed.hh
+++ b/src/Flow/VectorMalformed.hh
@@ -113,7 +113,8 @@ public:
         return std::string("generic-vector-") + Core::Type<T>::name + "-" + Policy::name() + "-malformed";
     }
     VectorMalformedNode(const Core::Configuration& c)
-            : Core::Component(c), SleeveNode(c) {}
+            : Core::Component(c),
+              SleeveNode(c) {}
     virtual ~VectorMalformedNode() {}
 
     virtual bool configure() {
diff --git a/src/Flow/VectorMultiplicationNode.hh b/src/Flow/VectorMultiplicationNode.hh
index 0c8a5c232..cca57bed3 100644
--- a/src/Flow/VectorMultiplicationNode.hh
+++ b/src/Flow/VectorMultiplicationNode.hh
@@ -29,7 +29,8 @@ public:
         return std::string("generic-vector-vector") + Core::Type<T>::name + "-multiplication";
     }
     VectorMultNode(const Core::Configuration& c)
-            : Core::Component(c), Precursor(c) {}
+            : Core::Component(c),
+              Precursor(c) {}
     virtual ~VectorMultNode() {}
 
     /**
diff --git a/src/Flow/VectorScalarFunction.hh b/src/Flow/VectorScalarFunction.hh
index 93aec254a..e869806d8 100644
--- a/src/Flow/VectorScalarFunction.hh
+++ b/src/Flow/VectorScalarFunction.hh
@@ -128,7 +128,9 @@ public:
 
 template<class Function>
 VectorScalarFunctionNode<Function>::VectorScalarFunctionNode(const Core::Configuration& c)
-        : Component(c), SleeveNode(c), function_(c) {
+        : Component(c),
+          SleeveNode(c),
+          function_(c) {
     setFunctionParameter(paramVectorScalarFunctionParameter(c));
 }
 
diff --git a/src/Flow/VectorSelect.hh b/src/Flow/VectorSelect.hh
index 2cc6c9452..d279b1be3 100644
--- a/src/Flow/VectorSelect.hh
+++ b/src/Flow/VectorSelect.hh
@@ -80,7 +80,8 @@ const Core::ParameterIntVector VectorSelectNode<T>::paramFeatureSelectTemp(
 
 template<class T>
 VectorSelectNode<T>::VectorSelectNode(const Core::Configuration& c)
-        : Core::Component(c), Precursor(c) {
+        : Core::Component(c),
+          Precursor(c) {
     setFeatureRange(paramFeatureSelect(c));
 }
 
diff --git a/src/Flow/VectorSequence.hh b/src/Flow/VectorSequence.hh
index 14c83da8b..bd6a03c1a 100644
--- a/src/Flow/VectorSequence.hh
+++ b/src/Flow/VectorSequence.hh
@@ -51,7 +51,10 @@ private:
 
 public:
     VectorSequenceNode(const Core::Configuration& c)
-            : Core::Component(c), Precursor(c), reverse_(false), timestamp_(false) {
+            : Core::Component(c),
+              Precursor(c),
+              reverse_(false),
+              timestamp_(false) {
         reverse_   = paramVectorSequenceNodeReverse(c);
         timestamp_ = paramVectorSequenceNodeTimeStamp(c);
     }
diff --git a/src/Flow/VectorSplit.hh b/src/Flow/VectorSplit.hh
index 26127b6fe..ddca3b6d8 100644
--- a/src/Flow/VectorSplit.hh
+++ b/src/Flow/VectorSplit.hh
@@ -52,7 +52,10 @@ public:
         return std::string("generic-vector-") + Core::Type<T>::name + "-split";
     }
     VectorSplitNode(const Core::Configuration& c)
-            : Core::Component(c), SinkNode(c), reverse_(false), timestamp_(false) {
+            : Core::Component(c),
+              SinkNode(c),
+              reverse_(false),
+              timestamp_(false) {
         reverse_   = paramVectorSplitNodeReverse(c);
         timestamp_ = paramVectorSplitNodeTimeStamp(c);
     }
diff --git a/src/Flow/VectorSum.hh b/src/Flow/VectorSum.hh
index ec55a3b36..b221a21ae 100644
--- a/src/Flow/VectorSum.hh
+++ b/src/Flow/VectorSum.hh
@@ -31,7 +31,8 @@ public:
         return std::string("generic-vector-") + Core::Type<T>::name + "-sum";
     }
     VectorSumNode(const Core::Configuration& c)
-            : Core::Component(c), Precursor(c) {}
+            : Core::Component(c),
+              Precursor(c) {}
     virtual ~VectorSumNode() {}
 
     /**
diff --git a/src/Flow/VectorTextInput.cc b/src/Flow/VectorTextInput.cc
index ef9466dfe..2b7ec03d0 100644
--- a/src/Flow/VectorTextInput.cc
+++ b/src/Flow/VectorTextInput.cc
@@ -73,7 +73,8 @@ class VectorTextInputNodeBase::Parser : public Core::XmlParser {
 
 public:
     Parser(const Core::Configuration& c, VectorTextInputNodeBase* n)
-            : Core::XmlParser(c), n_(n) {}
+            : Core::XmlParser(c),
+              n_(n) {}
 };
 
 const Core::ParameterString VectorTextInputNodeBase::paramFileName(
@@ -89,7 +90,14 @@ const Core::ParameterInt VectorTextInputNodeBase::paramSampleRate(
 
 VectorTextInputNodeBase::VectorTextInputNodeBase(
         const Core::Configuration& c, const Datatype* type)
-        : Core::Component(c), SourceNode(c), timeInS_(0), shiftInS_(0), lengthInS_(0), sampleRate_(0), type_(type), fileinfoChannel_(c, "text-file-info") {
+        : Core::Component(c),
+          SourceNode(c),
+          timeInS_(0),
+          shiftInS_(0),
+          lengthInS_(0),
+          sampleRate_(0),
+          type_(type),
+          fileinfoChannel_(c, "text-file-info") {
     parser_     = new Parser(c, this);
     fileName_   = paramFileName(c);
     shiftInS_   = paramShift(c);
diff --git a/src/Flow/VectorTextInput.hh b/src/Flow/VectorTextInput.hh
index 1d04bef9a..49441ccf4 100644
--- a/src/Flow/VectorTextInput.hh
+++ b/src/Flow/VectorTextInput.hh
@@ -97,7 +97,9 @@ public:
         return std::string("generic-vector-") + Core::Type<T>::name + "-text-input";
     }
     VectorTextInputNode(const Core::Configuration& c)
-            : Core::Component(c), VectorTextInputNodeBase(c, Vector<T>::type()), givenSize_(0) {}
+            : Core::Component(c),
+              VectorTextInputNodeBase(c, Vector<T>::type()),
+              givenSize_(0) {}
     virtual ~VectorTextInputNode() {}
 };
 
diff --git a/src/Fsa/Alphabet.hh b/src/Fsa/Alphabet.hh
index 9bcecf67d..a10cf247a 100644
--- a/src/Fsa/Alphabet.hh
+++ b/src/Fsa/Alphabet.hh
@@ -56,7 +56,8 @@ public:
 
     public:
         explicit const_iterator(Core::Ref<const Alphabet> a, LabelId i)
-                : alphabet_(a), label_(i) {
+                : alphabet_(a),
+                  label_(i) {
         }
         const_iterator& operator++() {
             label_ = alphabet_->next(label_);
@@ -221,7 +222,8 @@ private:
         // Symbol(const std::string &name, bool isDisambiguator = false) :
         //   name_(name), tag_(isDisambiguator ? disambiguatorTag : 0) {}
         Symbol(const std::string& name, AlphabetTag tag = 0)
-                : name_(name), tag_(tag) {}
+                : name_(name),
+                  tag_(tag) {}
     };
     Core::Vector<Symbol>                                       symbols_;
     std::unordered_map<std::string, LabelId, Core::StringHash> indices_;
diff --git a/src/Fsa/AlphabetUtility.hh b/src/Fsa/AlphabetUtility.hh
index 2fa58f839..cc0ebf60e 100644
--- a/src/Fsa/AlphabetUtility.hh
+++ b/src/Fsa/AlphabetUtility.hh
@@ -32,7 +32,9 @@ public:
 
 public:
     AlphabetCounts()
-            : maxLabelId_(0), nLabels_(0), nDisambiguators_(0) {}
+            : maxLabelId_(0),
+              nLabels_(0),
+              nDisambiguators_(0) {}
 };
 
 /**
diff --git a/src/Fsa/AlphabetXml.cc b/src/Fsa/AlphabetXml.cc
index fed2ed47e..d4624a26f 100644
--- a/src/Fsa/AlphabetXml.cc
+++ b/src/Fsa/AlphabetXml.cc
@@ -51,7 +51,8 @@ void AlphabetXmlParser::alphabetCharacters(const char* ch, int len) {
 
 AlphabetXmlParser::AlphabetXmlParser(
         const char* name, Core::XmlContext* context, Core::Ref<StaticAlphabet> a)
-        : Core::XmlRegularElement(name, context), a_(a) {
+        : Core::XmlRegularElement(name, context),
+          a_(a) {
     XmlElement* symbol = new Core::XmlMixedElementRelay("symbol", this, startHandler(&Self::symbolStart), endHandler(&Self::symbolEnd),
                                                         charactersHandler(&Self::alphabetCharacters),
                                                         XML_CHILD(new Core::XmlEmptyElementRelay("disambiguator", this, startHandler(&Self::symbolDisambiguatorStart))),
diff --git a/src/Fsa/Arithmetic.cc b/src/Fsa/Arithmetic.cc
index 55fa1fccb..1ea2ff080 100644
--- a/src/Fsa/Arithmetic.cc
+++ b/src/Fsa/Arithmetic.cc
@@ -81,7 +81,8 @@ class ExtendByFsaAutomaton : public ModifyAutomaton {
 
 public:
     ExtendByFsaAutomaton(ConstAutomatonRef f1, ConstAutomatonRef f2)
-            : ModifyAutomaton(f1), fsa2_(f2) {
+            : ModifyAutomaton(f1),
+              fsa2_(f2) {
         require(f1->semiring() == f2->semiring());
     }
     virtual ~ExtendByFsaAutomaton() {}
diff --git a/src/Fsa/Hash.hh b/src/Fsa/Hash.hh
index 3fe4cba1c..a01720273 100644
--- a/src/Fsa/Hash.hh
+++ b/src/Fsa/Hash.hh
@@ -43,7 +43,8 @@ private:
 
     public:
         Element(Cursor next, const T& data)
-                : next_(next), data_(data) {}
+                : next_(next),
+                  data_(data) {}
     };
     HashKey              hashKey_;
     HashEqual            hashEqual_;
@@ -67,7 +68,8 @@ public:
         bins_.resize(defaultSize, InvalidCursor);
     }
     Hash(const HashKey& key, const HashEqual& equal, u32 defaultSize = 10)
-            : hashKey_(key), hashEqual_(equal) {
+            : hashKey_(key),
+              hashEqual_(equal) {
         bins_.resize(defaultSize, InvalidCursor);
     }
     void clear() {
diff --git a/src/Fsa/Levenshtein.cc b/src/Fsa/Levenshtein.cc
index 8bcb17ccc..eb749595c 100644
--- a/src/Fsa/Levenshtein.cc
+++ b/src/Fsa/Levenshtein.cc
@@ -36,7 +36,8 @@ class LevenshteinAutomaton : public Automaton {
 
 public:
     LevenshteinAutomaton(ConstAlphabetRef ref, ConstAlphabetRef test, f32 delCost, f32 insCost, f32 subCost, f32 corCost)
-            : inputAlphabet_(ref), outputAlphabet_(test) {
+            : inputAlphabet_(ref),
+              outputAlphabet_(test) {
         setProperties(PropertyStorage, PropertyStorage);
 
         AlphabetMapping mapping;
diff --git a/src/Fsa/Packed.hh b/src/Fsa/Packed.hh
index c88c49411..80b9afecd 100644
--- a/src/Fsa/Packed.hh
+++ b/src/Fsa/Packed.hh
@@ -34,23 +34,28 @@ public:
     PackedAutomaton();
     PackedAutomaton(const std::string& str);
     virtual ~PackedAutomaton();
+
     virtual void          clear();
     virtual bool          hasState(StateId sid) const;
     virtual void          setState(State* sp);
     virtual void          deleteState(StateId);
     virtual ConstStateRef getState(StateId s) const;
-    virtual StateId       maxStateId() const {
+
+    virtual StateId maxStateId() const {
         return states_.size() - 1;
     }
+
     virtual StateId size() const {
         return states_.size();
     }
-    virtual void        normalize() {}
-    virtual size_t      getMemoryUsed() const;
-    float               getStateRatio() const;
-    float               getArcRatio() const;
-    float               getRatio() const;
-    void                dumpMemoryUsage(Core::XmlWriter& o) const;
+
+    virtual void   normalize() {}
+    virtual size_t getMemoryUsed() const;
+    float          getStateRatio() const;
+    float          getArcRatio() const;
+    float          getRatio() const;
+    void           dumpMemoryUsage(Core::XmlWriter& o) const;
+
     virtual std::string describe() const {
         return "packed";
     }
diff --git a/src/Fsa/Permute.hh b/src/Fsa/Permute.hh
index 1312b500b..e210918de 100644
--- a/src/Fsa/Permute.hh
+++ b/src/Fsa/Permute.hh
@@ -35,11 +35,13 @@ private:
 
 public:
     Bitvector(const Bitvector& v, size_t flipPos)
-            : size_(v.size_), bits_(v.bits_) {
+            : size_(v.size_),
+              bits_(v.bits_) {
         flip(flipPos);
     }
     Bitvector(size_t size, bool value = false)
-            : size_(size), bits_((size + 31) / 32, value ? ~u32(0) : 0) {}
+            : size_(size),
+              bits_((size + 31) / 32, value ? ~u32(0) : 0) {}
     size_t size() const {
         return size_;
     }
@@ -110,7 +112,11 @@ struct LogWeighting {
     std::vector<f32> logProbabilitiesForReorderedPaths;
     std::vector<f32> logProbabilitiesWitoutOrderedPath;
     LogWeighting(ConstSemiringRef semiring, f32 baseProbability, u32 windowSize)
-            : baseProbability_(baseProbability), semiring_(semiring), windowSize_(windowSize), logProbabilitiesForReorderedPaths(windowSize_ + 1), logProbabilitiesWitoutOrderedPath(windowSize_ + 1) {
+            : baseProbability_(baseProbability),
+              semiring_(semiring),
+              windowSize_(windowSize),
+              logProbabilitiesForReorderedPaths(windowSize_ + 1),
+              logProbabilitiesWitoutOrderedPath(windowSize_ + 1) {
         logBaseProbability_ = -log(baseProbability_);
         for (u32 i = 1; i <= windowSize_; ++i) {
             logProbabilitiesForReorderedPaths[i] = -log((1 - baseProbability_) / (i - 1));
@@ -168,7 +174,8 @@ protected:
 
 public:
     PermuteAutomatonBase(ConstAutomatonRef f, u32 windowSize, Processing* processing)
-            : DfsState(cache(f)), processing_(processing) {
+            : DfsState(cache(f)),
+              processing_(processing) {
         if (!hasProperties(fsa_, PropertyLinear))
             std::cerr << "permute is defined properly for linear automata only." << std::endl;
         setProperties(PropertyAcyclic, PropertyAcyclic);
@@ -227,7 +234,8 @@ protected:
         u32       depth_;
         Bitvector used_;
         State_(u32 depth, const Bitvector& used)
-                : depth_(depth), used_(used) {}
+                : depth_(depth),
+                  used_(used) {}
         bool operator==(const State_& s) const {
             return (used_ == s.used_);
         }
@@ -300,7 +308,7 @@ public:
         u32     upperLimit = std::min(size_t(Precursor::states_[s].depth_ + Precursor::windowSize_), Precursor::states_[s].used_.size());
         Precursor::processing_->processState(Precursor::states_[s].used_, lowerLimit, upperLimit);
         for (u32 i = lowerLimit; i < upperLimit; ++i)
-            if (!Precursor::states_[s].used_[i] && (size_t(abs(i - Precursor::states_[s].depth_)) < Precursor::distortionLimit_)) {  // !!! LIMIT
+            if (!Precursor::states_[s].used_[i] && (size_t(abs(static_cast<int>(i - Precursor::states_[s].depth_)) < Precursor::distortionLimit_))) {  // !!! LIMIT
                 u32  depth = Precursor::states_[s].depth_ + 1;
                 Arc* a     = sp->newArc();
                 *a         = Precursor::arcs_[i];
@@ -359,7 +367,8 @@ public:
         Precursor::processing_->processState(Precursor::states_[s].used_, firstBitNotSet,
                                              (Precursor::states_[s].depth_ - firstBitNotSet < Precursor::windowSize_) ? Precursor::states_[s].used_.size() : firstBitNotSet + 1);
         // monotone transition
-        if (size_t(abs(firstBitNotSet - Precursor::states_[s].depth_)) < Precursor::distortionLimit_) {
+        //
+        if (size_t(abs(static_cast<int>(firstBitNotSet - Precursor::states_[s].depth_)) < Precursor::distortionLimit_)) {
             Arc* a     = sp->newArc();
             *a         = Precursor::arcs_[firstBitNotSet];
             a->target_ = Precursor::insertState(Precursor::states_[s].depth_ + 1, Precursor::states_[s].used_, firstBitNotSet);
@@ -367,9 +376,10 @@ public:
         }
         if (Precursor::states_[s].depth_ - firstBitNotSet < Precursor::windowSize_) {  // if we can do non-monotone transitions
             for (u32 i = firstBitNotSet + 1; i < Precursor::states_[s].used_.size(); i++) {
-                if (!Precursor::states_[s].used_[i] && (size_t(abs(i - Precursor::states_[s].depth_)) < Precursor::distortionLimit_)) {  // DISTORTION LIMIT HERE !
-                    Arc* a     = sp->newArc();
-                    *a         = Precursor::arcs_[i];
+                if (!Precursor::states_[s].used_[i] && (size_t(abs(static_cast<int>(i - Precursor::states_[s].depth_)) < Precursor::distortionLimit_))) {  // DISTORTION LIMIT HERE !
+                    Arc* a = sp->newArc();
+                    *a     = Precursor::arcs_[i];
+
                     a->target_ = Precursor::insertState(Precursor::states_[s].depth_ + 1, Precursor::states_[s].used_, i);
                     Precursor::processing_->processArc(i - Precursor::states_[s].depth_, a);
                 }
@@ -501,9 +511,14 @@ private:
         Spans     spans_;
 
         State_(u32 depth, const State_& x, u32 newpos)
-                : depth_(depth), used_(x.used_, newpos), last_((depth < used_.size() ? newpos : -2)), spans_(x.spans_, newpos) {}
+                : depth_(depth),
+                  used_(x.used_, newpos),
+                  last_((depth < used_.size() ? newpos : -2)),
+                  spans_(x.spans_, newpos) {}
         State_(u32 depth, const Bitvector& used)
-                : depth_(depth), used_(used), last_(-1) {}
+                : depth_(depth),
+                  used_(used),
+                  last_(-1) {}
 
         bool operator==(const State_& s) const {
             return (used_ == s.used_ && spans_ == s.spans_ && (last_ == s.last_ || (last_ < s.last_ ? used_.isCovered(last_, s.last_) : used_.isCovered(s.last_, last_))));
diff --git a/src/Fsa/Search.hh b/src/Fsa/Search.hh
index 5c854425a..3aa1e6cb3 100644
--- a/src/Fsa/Search.hh
+++ b/src/Fsa/Search.hh
@@ -128,7 +128,9 @@ private:
         Trace   trace_;
         Token() {}
         Token(StateId state, Score score, Trace trace)
-                : state_(state), score_(score), trace_(trace) {}
+                : state_(state),
+                  score_(score),
+                  trace_(trace) {}
     };
     typedef Core::Vector<Token> ActiveTokens;
 
@@ -136,9 +138,11 @@ private:
         Score score_;
         Trace trace_;
         ExpandedToken()
-                : score_(Core::Type<Score>::max), trace_(InvalidStateId) {}
+                : score_(Core::Type<Score>::max),
+                  trace_(InvalidStateId) {}
         ExpandedToken(Score score, Trace trace)
-                : score_(score), trace_(trace) {}
+                : score_(score),
+                  trace_(trace) {}
     };
     typedef Core::Vector<ExpandedToken> ExpandedTokens;
 
@@ -153,9 +157,11 @@ private:
     Score                  threshold_, finalThreshold_, minFinalScore_, minScore_, minThreshold_;
 
 private:
-    enum ExpandType { ExpandTypeNone    = 0,
-                      ExpandTypeUpdated = 1,
-                      ExpandTypeNew     = 2 };
+    enum ExpandType {
+        ExpandTypeNone    = 0,
+        ExpandTypeUpdated = 1,
+        ExpandTypeNew     = 2
+    };
     ExpandType expandToken(Score score, Trace trace, StateId target, LabelId output) {
         if (output != Epsilon)
             trace = tracer_->add(trace, output, score);
@@ -274,7 +280,9 @@ private:
 
 public:
     Search(const StaticAutomaton* fsa, Score threshold)
-            : fsa_(fsa), statesBeforePruning_("states before pruning"), statesAfterPruning_("states after pruning") {
+            : fsa_(fsa),
+              statesBeforePruning_("states before pruning"),
+              statesAfterPruning_("states after pruning") {
         // TODO: test for epsilon cycles?
 
         // require(fsa->hasProperty(PropertySortedByInput));
diff --git a/src/Fsa/Search.stack.hh b/src/Fsa/Search.stack.hh
index 86cef7e5e..f8cb0b7ba 100644
--- a/src/Fsa/Search.stack.hh
+++ b/src/Fsa/Search.stack.hh
@@ -59,7 +59,9 @@ private:
             Trace   trace_;
             Token() {}
             Token(StateId state, Score score, Trace trace)
-                    : state_(state), score_(score), trace_(trace) {}
+                    : state_(state),
+                      score_(score),
+                      trace_(trace) {}
         };
         typedef Stack<Token> TokenSet;
 
@@ -69,7 +71,8 @@ private:
             ExpandedToken()
                     : score_(Core::Type<Score>::max) {}
             ExpandedToken(Score score, Trace trace)
-                    : score_(score), trace_(trace) {}
+                    : score_(score),
+                      trace_(trace) {}
         };
         typedef Core::Vector<ExpandedToken> ExpandedTokens;
 
@@ -83,7 +86,17 @@ private:
     public:
         Slice(const StaticAutomaton* fsa, ExpandedTokens& expandedTokens, StaticAutomaton* trace,
               Score threshold, Score finalThreshold)
-                : fsa_(fsa), inputEpsilon_(fsa->getInputAlphabet()->epsilon()), outputEpsilon_(fsa->getOutputAlphabet()->epsilon()), semiring_(fsa->semiring()), bestFinalTrace_(InvalidStateId), trace_(trace), expandedTokens_(expandedTokens), threshold_(threshold), finalThreshold_(finalThreshold), statesBeforePruning_("states before pruning"), statesAfterPruning_("states after pruning") {}
+                : fsa_(fsa),
+                  inputEpsilon_(fsa->getInputAlphabet()->epsilon()),
+                  outputEpsilon_(fsa->getOutputAlphabet()->epsilon()),
+                  semiring_(fsa->semiring()),
+                  bestFinalTrace_(InvalidStateId),
+                  trace_(trace),
+                  expandedTokens_(expandedTokens),
+                  threshold_(threshold),
+                  finalThreshold_(finalThreshold),
+                  statesBeforePruning_("states before pruning"),
+                  statesAfterPruning_("states after pruning") {}
 
         void start() {
             tokens_.clear();
@@ -194,7 +207,12 @@ private:
 
 public:
     Search(const StaticAutomaton* fsa, Score threshold)
-            : fsa_(fsa), trace_(new StaticAutomaton()), traceRef_(trace_), expandedTokens_(fsa->size()), slice0_(fsa_, expandedTokens_, trace_, threshold, 190), slice1_(fsa_, expandedTokens_, trace_, threshold, 190) {
+            : fsa_(fsa),
+              trace_(new StaticAutomaton()),
+              traceRef_(trace_),
+              expandedTokens_(fsa->size()),
+              slice0_(fsa_, expandedTokens_, trace_, threshold, 190),
+              slice1_(fsa_, expandedTokens_, trace_, threshold, 190) {
         restart();
     };
     void restart() {
diff --git a/src/Fsa/Semiring.cc b/src/Fsa/Semiring.cc
index 9d3640c8a..d665441df 100644
--- a/src/Fsa/Semiring.cc
+++ b/src/Fsa/Semiring.cc
@@ -224,6 +224,8 @@ ConstSemiringRef getSemiring(SemiringType type) {
             return CountSemiring;
         case SemiringTypeProbability:
             return ProbabilitySemiring;
+        case SemiringTypeExpectation:
+            return ConstSemiringRef();
     }
     return ConstSemiringRef();
 }
diff --git a/src/Fsa/Sssp.cc b/src/Fsa/Sssp.cc
index 3442ee339..5414a29a4 100644
--- a/src/Fsa/Sssp.cc
+++ b/src/Fsa/Sssp.cc
@@ -77,14 +77,17 @@ class StatePotentials64DfsState : public Fsa::DfsState {
     virtual ~StatePotentials64DfsState() {}
 
     virtual void finishState(StateId s);
-    f64          totalFlow() const {
+
+    f64 totalFlow() const {
         return totalFlow_;
     }
 };
 
 StatePotentials64DfsState::StatePotentials64DfsState(
         ConstAutomatonRef transposed, StatePotentials64& potentials)
-        : DfsState(transposed), potentials_(potentials), totalFlow_(0.0) {
+        : DfsState(transposed),
+          potentials_(potentials),
+          totalFlow_(0.0) {
     require(fsa_->semiring() == LogSemiring);
     potentials_.clear();
 }
@@ -328,7 +331,9 @@ class PosteriorEAutomaton : public Posterior64Automaton {
 };
 
 PosteriorEAutomaton::PosteriorEAutomaton(ConstAutomatonRef f, ConstAutomatonRef r, bool vNormalized, s32 tol)
-        : Posterior64Automaton(f), r_(r), normalization_(0) {
+        : Posterior64Automaton(f),
+          r_(r),
+          normalization_(0) {
     ConstAutomatonRef transposed = transpose(fsa_);
     ssspE(transposed, transpose(r_), forwardPotentials_, generalizedForwardPotentials_);
     ssspE(fsa_, r_, backwardPotentials_, generalizedBackwardPotentials_);
diff --git a/src/Fsa/Types.hh b/src/Fsa/Types.hh
index ab77b2e24..901dd0f70 100644
--- a/src/Fsa/Types.hh
+++ b/src/Fsa/Types.hh
@@ -52,9 +52,11 @@ static const LabelId Failure        = 2147483647 - 2;  // if no other arc matche
 static const LabelId Any            = 2147483647 - 1;  // any of the own alphabet
 static const LabelId InvalidLabelId = Core::Type<LabelId>::max;
 
-typedef enum { TypeUnknown    = 0,
-               TypeAcceptor   = 1,
-               TypeTransducer = 2 } Type;
+typedef enum {
+    TypeUnknown    = 0,
+    TypeAcceptor   = 1,
+    TypeTransducer = 2
+} Type;
 extern Core::Choice TypeChoice;
 
 /**
diff --git a/src/Fsa/check.cc b/src/Fsa/check.cc
index c3f8b3fbe..fdc3e14e1 100644
--- a/src/Fsa/check.cc
+++ b/src/Fsa/check.cc
@@ -91,6 +91,6 @@ class MyApplication : public Fsa::Application {
 
         return 0;
     }
-} app;  // <- You have to create ONE instance of the application
+};
 
-APPLICATION
+APPLICATION(MyApplication)
diff --git a/src/Fsa/hInfo.hh b/src/Fsa/hInfo.hh
index c9d37b6b9..1316c1dad 100644
--- a/src/Fsa/hInfo.hh
+++ b/src/Fsa/hInfo.hh
@@ -37,7 +37,16 @@ public:
 
 public:
     AutomatonCounts()
-            : maxStateId_(InvalidStateId), nStates_(0), nFinals_(0), nArcs_(0), nIoEps_(0), nIEps_(0), nOEps_(0), nIoFail_(0), nIFail_(0), nOFail_(0) {}
+            : maxStateId_(InvalidStateId),
+              nStates_(0),
+              nFinals_(0),
+              nArcs_(0),
+              nIoEps_(0),
+              nIEps_(0),
+              nOEps_(0),
+              nIoFail_(0),
+              nIFail_(0),
+              nOFail_(0) {}
 };
 }  // namespace Fsa
 
diff --git a/src/Fsa/hSort.hh b/src/Fsa/hSort.hh
index 396e9aab9..b5b46b06f 100644
--- a/src/Fsa/hSort.hh
+++ b/src/Fsa/hSort.hh
@@ -32,7 +32,7 @@ typedef enum {
 
 namespace Ftl {
 template<class _Automaton>
-struct byArc : public std::binary_function<typename _Automaton::Arc, typename _Automaton::Arc, bool> {
+struct byArc {
     typename _Automaton::ConstSemiringRef semiring_;
     byArc(typename _Automaton::ConstSemiringRef semiring)
             : semiring_(semiring) {}
@@ -50,21 +50,21 @@ struct byArc : public std::binary_function<typename _Automaton::Arc, typename _A
 };
 
 template<class _Automaton>
-struct byInput : public std::binary_function<typename _Automaton::Arc, typename _Automaton::Arc, bool> {
+struct byInput {
     bool operator()(const typename _Automaton::Arc& a, const typename _Automaton::Arc& b) const {
         return a.input() < b.input();
     }
 };
 
 template<class _Automaton>
-struct byOutput : public std::binary_function<typename _Automaton::Arc, typename _Automaton::Arc, bool> {
+struct byOutput {
     bool operator()(const typename _Automaton::Arc& a, const typename _Automaton::Arc& b) const {
         return a.output() < b.output();
     }
 };
 
 template<class _Automaton>
-struct byInputAndTarget : public std::binary_function<typename _Automaton::Arc, typename _Automaton::Arc, bool> {
+struct byInputAndTarget {
     bool operator()(const typename _Automaton::Arc& a, const typename _Automaton::Arc& b) const {
         if (a.input() < b.input())
             return true;
@@ -75,7 +75,7 @@ struct byInputAndTarget : public std::binary_function<typename _Automaton::Arc,
 };
 
 template<class _Automaton>
-struct byInputAndOutput : public std::binary_function<typename _Automaton::Arc, typename _Automaton::Arc, bool> {
+struct byInputAndOutput {
     bool operator()(const typename _Automaton::Arc& a, const typename _Automaton::Arc& b) const {
         if (a.input() < b.input())
             return true;
@@ -86,7 +86,7 @@ struct byInputAndOutput : public std::binary_function<typename _Automaton::Arc,
 };
 
 template<class _Automaton>
-struct byInputAndOutputAndTarget : public std::binary_function<typename _Automaton::Arc, typename _Automaton::Arc, bool> {
+struct byInputAndOutputAndTarget {
     bool operator()(const typename _Automaton::Arc& a, const typename _Automaton::Arc& b) const {
         if (a.input() < b.input())
             return true;
@@ -101,7 +101,7 @@ struct byInputAndOutputAndTarget : public std::binary_function<typename _Automat
 };
 
 template<class _Automaton>
-struct byWeight : public std::binary_function<typename _Automaton::Arc, typename _Automaton::Arc, bool> {
+struct byWeight {
     typename _Automaton::ConstSemiringRef semiring_;
     byWeight(typename _Automaton::ConstSemiringRef semiring)
             : semiring_(semiring) {}
diff --git a/src/Fsa/hSssp.hh b/src/Fsa/hSssp.hh
index 8ae5715b6..4509c65b6 100644
--- a/src/Fsa/hSssp.hh
+++ b/src/Fsa/hSssp.hh
@@ -42,7 +42,8 @@ struct SsspArcFilter {
     SsspArcFilter() {}
     virtual ~SsspArcFilter() {}
     typedef typename _Automaton::Arc _Arc;
-    virtual bool                     operator()(const _Arc& a) const {
+
+    virtual bool operator()(const _Arc& a) const {
         return true;
     }
 };
diff --git a/src/Fsa/tAccessible.cc b/src/Fsa/tAccessible.cc
index 77ce1a7b8..7c9f1bd9b 100644
--- a/src/Fsa/tAccessible.cc
+++ b/src/Fsa/tAccessible.cc
@@ -22,7 +22,9 @@ namespace Ftl {
 
 template<class _Automaton>
 CoaccessibleDfsState<_Automaton>::CoaccessibleDfsState(_ConstAutomatonRef f)
-        : Precursor(f), time_(0), scc_(0) {}
+        : Precursor(f),
+          time_(0),
+          scc_(0) {}
 
 template<class _Automaton>
 void CoaccessibleDfsState<_Automaton>::discoverState(_ConstStateRef sp) {
diff --git a/src/Fsa/tAlphabet.cc b/src/Fsa/tAlphabet.cc
index 1ec33974d..09796a3f7 100644
--- a/src/Fsa/tAlphabet.cc
+++ b/src/Fsa/tAlphabet.cc
@@ -31,7 +31,8 @@ class ChangeInputAlphabetAutomaton : public SlaveAutomaton<_Automaton> {
 
 public:
     ChangeInputAlphabetAutomaton(ConstAutomatonRef f, const Fsa::ConstAlphabetRef a)
-            : Precursor(f), inputAlphabet_(a) {}
+            : Precursor(f),
+              inputAlphabet_(a) {}
     virtual Fsa::ConstAlphabetRef getInputAlphabet() const {
         return inputAlphabet_;
     }
@@ -56,7 +57,8 @@ class ChangeOutputAlphabetAutomaton : public SlaveAutomaton<_Automaton> {
 
 public:
     ChangeOutputAlphabetAutomaton(ConstAutomatonRef f, const Fsa::ConstAlphabetRef a)
-            : Precursor(f), outputAlphabet_(a) {}
+            : Precursor(f),
+              outputAlphabet_(a) {}
     virtual Fsa::ConstAlphabetRef getOutputAlphabet() const {
         return outputAlphabet_;
     }
@@ -81,7 +83,8 @@ class ChangeInputOutputAlphabetAutomaton : public SlaveAutomaton<_Automaton> {
 
 public:
     ChangeInputOutputAlphabetAutomaton(ConstAutomatonRef f, const Fsa::ConstAlphabetRef a)
-            : Precursor(f), alphabet_(a) {}
+            : Precursor(f),
+              alphabet_(a) {}
     virtual Fsa::ConstAlphabetRef getInputAlphabet() const {
         return alphabet_;
     }
diff --git a/src/Fsa/tArithmetic.cc b/src/Fsa/tArithmetic.cc
index 68d525d11..0414d72f4 100644
--- a/src/Fsa/tArithmetic.cc
+++ b/src/Fsa/tArithmetic.cc
@@ -35,7 +35,8 @@ class CollectAutomaton : public ModifyAutomaton<_Automaton> {
 
 public:
     CollectAutomaton(_ConstAutomatonRef f, _Weight value)
-            : Precursor(f), value_(value) {}
+            : Precursor(f),
+              value_(value) {}
     virtual void modifyState(_State* sp) const {
         if (sp->hasTags(Fsa::StateTagFinal))
             sp->weight_ = this->semiring()->collect(sp->weight_, value_);
@@ -67,7 +68,8 @@ class ExtendAutomaton : public ModifyAutomaton<_Automaton> {
 
 public:
     ExtendAutomaton(_ConstAutomatonRef f, _Weight value)
-            : Precursor(f), value_(value) {}
+            : Precursor(f),
+              value_(value) {}
     virtual void modifyState(_State* sp) const {
         if (sp->hasTags(Fsa::StateTagFinal))
             sp->weight_ = this->semiring()->extend(sp->weight_, value_);
@@ -100,7 +102,8 @@ class ExtendFinalAutomaton : public SlaveAutomaton<_Automaton> {
 
 public:
     ExtendFinalAutomaton(_ConstAutomatonRef f, _Weight value)
-            : Precursor(f), value_(value) {
+            : Precursor(f),
+              value_(value) {
         require(hasProperties(this->fsa_, Fsa::PropertyAcyclic));
     }
     virtual _ConstStateRef getState(Fsa::StateId s) const {
@@ -137,7 +140,8 @@ class WeightModifyAutomaton : public ModifyAutomaton<_Automaton> {
 
 public:
     WeightModifyAutomaton(_ConstAutomatonRef f, const Modifier& m)
-            : Precursor(f), m_(m) {}
+            : Precursor(f),
+              m_(m) {}
     virtual void modifyState(_State* sp) const {
         if (sp->hasTags(Fsa::StateTagFinal))
             sp->weight_ = m_(sp->weight_);
diff --git a/src/Fsa/tAutomaton.hh b/src/Fsa/tAutomaton.hh
index efa908ef2..b5fc3355d 100644
--- a/src/Fsa/tAutomaton.hh
+++ b/src/Fsa/tAutomaton.hh
@@ -47,7 +47,10 @@ struct Arc {
 
     Arc(Fsa::StateId target, Weight weight, Fsa::LabelId input,
         Fsa::LabelId output)
-            : target_(target), weight_(weight), input_(input), output_(output) {}
+            : target_(target),
+              weight_(weight),
+              input_(input),
+              output_(output) {}
 
     ~Arc() {}
 
@@ -133,7 +136,8 @@ private:
 
 public:
     ArrayArcContainer()
-            : arcs_(0), nArcs_(0) {}
+            : arcs_(0),
+              nArcs_(0) {}
     ArrayArcContainer(const ArrayArcContainer<_Arc>&);
     ~ArrayArcContainer() {
         clear();
@@ -231,7 +235,9 @@ public:
     ~State() {}
 
     State(const Self& o)
-            : idAndTags_(o.idAndTags_), arcs_(o.arcs_), weight_(o.weight_) {}
+            : idAndTags_(o.idAndTags_),
+              arcs_(o.arcs_),
+              weight_(o.weight_) {}
 
     template<template<typename> class _OtherArcContainer>
     State(const State<_Arc, _OtherArcContainer>& o)
@@ -405,7 +411,8 @@ protected:
 
 protected:
     Automaton()
-            : knownProperties_(0), properties_(0) {
+            : knownProperties_(0),
+              properties_(0) {
     }
 
     virtual void copyProperties(ConstRef      f,
@@ -512,7 +519,8 @@ public:
      *    if the automaton provides no input alphabet
      **/
     virtual Fsa::ConstAlphabetRef getInputAlphabet() const = 0;
-    Fsa::ConstAlphabetRef         inputAlphabet() const {
+
+    Fsa::ConstAlphabetRef inputAlphabet() const {
         return getInputAlphabet();
     }
 
@@ -707,7 +715,8 @@ protected:
 
 public:
     ModifyAutomaton(_ConstAutomatonRef f)
-            : Precursor(f), lastState_(new _State()) {
+            : Precursor(f),
+              lastState_(new _State()) {
         this->setProperties(Fsa::PropertyStorage | Fsa::PropertyCached, 0);
     }
     virtual void           modifyState(_State* sp) const = 0;
diff --git a/src/Fsa/tBasic.cc b/src/Fsa/tBasic.cc
index 2dfa02edc..23fb882e0 100644
--- a/src/Fsa/tBasic.cc
+++ b/src/Fsa/tBasic.cc
@@ -87,7 +87,8 @@ class NormalizeMapping : public Fsa::Mapping {
 
 public:
     NormalizeMapping(_ConstAutomatonRef f)
-            : fsa_(f), nFsa_(dynamic_cast<const _NormalizeAutomaton*>(f.get())) {
+            : fsa_(f),
+              nFsa_(dynamic_cast<const _NormalizeAutomaton*>(f.get())) {
         require(nFsa_);
     }
     Fsa::StateId map(Fsa::StateId target) const {
@@ -183,9 +184,13 @@ class PartialAutomaton : public SlaveAutomaton<_Automaton> {
 
 public:
     PartialAutomaton(_ConstAutomatonRef f, Fsa::StateId newInitialStateId)
-            : Precursor(f), newInitialStateId_(newInitialStateId), additionalFinalWeight_(f->semiring()->one()) {}
+            : Precursor(f),
+              newInitialStateId_(newInitialStateId),
+              additionalFinalWeight_(f->semiring()->one()) {}
     PartialAutomaton(_ConstAutomatonRef f, Fsa::StateId newInitialStateId, typename _Automaton::Weight additionalFinalWeight)
-            : Precursor(f), newInitialStateId_(newInitialStateId), additionalFinalWeight_(additionalFinalWeight) {}
+            : Precursor(f),
+              newInitialStateId_(newInitialStateId),
+              additionalFinalWeight_(additionalFinalWeight) {}
     virtual Fsa::StateId initialStateId() const {
         return newInitialStateId_;
     }
@@ -228,7 +233,8 @@ class HypothesisAutomaton : public ModifyAutomaton<_Automaton> {
 
 public:
     HypothesisAutomaton(_ConstAutomatonRef f, Fsa::StateId n)
-            : Precursor(f), n_(n) {}
+            : Precursor(f),
+              n_(n) {}
     virtual Fsa::StateId initialStateId() const {
         return n_;
     }
@@ -261,7 +267,8 @@ class ChangeSemiringAutomaton : public SlaveAutomaton<_Automaton> {
 
 public:
     ChangeSemiringAutomaton(_ConstAutomatonRef f, _ConstSemiringRef semiring)
-            : Precursor(f), semiring_(semiring) {}
+            : Precursor(f),
+              semiring_(semiring) {}
     virtual _ConstSemiringRef semiring() const {
         return semiring_;
     }
@@ -306,7 +313,9 @@ class ConverterAutomaton : public WrapperAutomaton<_AutomatonFrom, _AutomatonTo>
 
 public:
     ConverterAutomaton(_ConstFromAutomatonRef f, _ConstSemiringRef semiring, const _Mapping& map)
-            : Precursor(f), semiring_(semiring), map_(map) {}
+            : Precursor(f),
+              semiring_(semiring),
+              map_(map) {}
     virtual _ConstSemiringRef semiring() const {
         return semiring_;
     }
diff --git a/src/Fsa/tBest.cc b/src/Fsa/tBest.cc
index a0ee1f72e..97752cd52 100644
--- a/src/Fsa/tBest.cc
+++ b/src/Fsa/tBest.cc
@@ -44,13 +44,15 @@ class BestAutomaton : public SlaveAutomaton<_Automaton> {
 
 public:
     BestAutomaton(_ConstAutomatonRef f)
-            : Precursor(f), potentials_(sssp<_Automaton>(transpose<_Automaton>(f, false))) {
+            : Precursor(f),
+              potentials_(sssp<_Automaton>(transpose<_Automaton>(f, false))) {
         this->setProperties(Fsa::PropertyStorage | Fsa::PropertyCached, Fsa::PropertyNone);
         this->addProperties(Fsa::PropertySorted);
         this->addProperties(Fsa::PropertyLinear | Fsa::PropertyAcyclic);
     }
     BestAutomaton(_ConstAutomatonRef f, const _StatePotentials& backward)
-            : Precursor(f), potentials_(backward) {
+            : Precursor(f),
+              potentials_(backward) {
         this->setProperties(Fsa::PropertyStorage | Fsa::PropertyCached, Fsa::PropertyNone);
         this->addProperties(Fsa::PropertySorted);
         this->addProperties(Fsa::PropertyLinear | Fsa::PropertyAcyclic);
@@ -131,7 +133,10 @@ struct Trace {
             Fsa::LabelId input       = Fsa::InvalidLabelId,
             Fsa::LabelId output      = Fsa::InvalidLabelId,
             u32          predecessor = 0)
-            : input_(input), output_(output), count_(1), predecessor_(predecessor) {}
+            : input_(input),
+              output_(output),
+              count_(1),
+              predecessor_(predecessor) {}
 };
 
 class TraceCache : public Core::Vector<Trace> {
@@ -189,14 +194,17 @@ class NBestTraces {
         u32          trace_;
         Hyp() {}
         Hyp(Fsa::StateId state, _Weight potential, u32 trace)
-                : state_(state), potential_(potential), trace_(trace) {}
+                : state_(state),
+                  potential_(potential),
+                  trace_(trace) {}
     };
 
     struct PriorityFunction {
         _ConstSemiringRef       semiring_;
         const _StatePotentials& potentials_;
         PriorityFunction(_ConstSemiringRef semiring, const _StatePotentials& potentials)
-                : semiring_(semiring), potentials_(potentials) {}
+                : semiring_(semiring),
+                  potentials_(potentials) {}
         bool operator()(const Hyp& h1, const Hyp& h2) const {
             return (semiring_->compare(semiring_->extend(h1.potential_, potentials_[h1.state_]),
                                        semiring_->extend(h2.potential_, potentials_[h2.state_])) < 0);
@@ -209,7 +217,8 @@ class NBestTraces {
 
 public:
     NBestTraces(_ConstAutomatonRef f, size_t n, bool bestSequences)
-            : traces_(n), finals_() {
+            : traces_(n),
+              finals_() {
         // check for tropical semiring (or for at least a semiring with property 'ordered')
         if (bestSequences) {
             if (f->type() & Fsa::TypeAcceptor)
@@ -362,14 +371,16 @@ class FirstBestAutomaton : public SlaveAutomaton<_Automaton> {
         Fsa::StateId state;
         s32          arc;
         Step(Fsa::StateId _state, s32 _arc)
-                : state(_state), arc(_arc) {}
+                : state(_state),
+                  arc(_arc) {}
     };
 
     struct Trace : Step {
         typedef u32 Id;
         Id          back;
         Trace(Id _back, Fsa::StateId _state, s32 _arc)
-                : Step(_state, _arc), back(_back) {}
+                : Step(_state, _arc),
+                  back(_back) {}
     };
     typedef typename Trace::Id TraceId;
 
@@ -407,10 +418,9 @@ class FirstBestAutomaton : public SlaveAutomaton<_Automaton> {
     };
 
     TraceId search(TracePool& traces) {
-        typename Hyp::Priority precedes(this->semiring());
-        Core::TracedPriorityQueue<Hyp, Fsa::StateId, typename Hyp::Key, typename Hyp::Priority>
-                                                  stack(precedes);
-        std::unordered_map<Fsa::StateId, _Weight> closed;
+        typename Hyp::Priority                                                                  precedes(this->semiring());
+        Core::TracedPriorityQueue<Hyp, Fsa::StateId, typename Hyp::Key, typename Hyp::Priority> stack(precedes);
+        std::unordered_map<Fsa::StateId, _Weight>                                               closed;
 
         Hyp newHyp;
         newHyp.state  = Precursor::fsa_->initialStateId();
@@ -454,7 +464,8 @@ class FirstBestAutomaton : public SlaveAutomaton<_Automaton> {
     }
 
     std::unordered_map<Fsa::StateId, u32> path_;
-    void                                  traceback(TracePool& traces, TraceId trace) {
+
+    void traceback(TracePool& traces, TraceId trace) {
         while (trace) {
             path_[traces[trace].state] = traces[trace].arc;
             trace                      = traces[trace].back;
diff --git a/src/Fsa/tCache.cc b/src/Fsa/tCache.cc
index ac6075ca4..a6b482a68 100644
--- a/src/Fsa/tCache.cc
+++ b/src/Fsa/tCache.cc
@@ -36,7 +36,9 @@ class CacheAutomaton : public SlaveAutomaton<_Automaton> {
 
 public:
     CacheAutomaton(_ConstAutomatonRef f, u32 maxAge)
-            : Precursor(f), maxAge_(maxAge), age_(0) {
+            : Precursor(f),
+              maxAge_(maxAge),
+              age_(0) {
         this->setProperties(Fsa::PropertyCached | Fsa::PropertyStorage, Fsa::PropertyCached);
     }
     virtual ~CacheAutomaton() {
diff --git a/src/Fsa/tCompose.cc b/src/Fsa/tCompose.cc
index 734eb0433..73d8561d8 100644
--- a/src/Fsa/tCompose.cc
+++ b/src/Fsa/tCompose.cc
@@ -71,7 +71,8 @@ class GeneralComposeAutomaton : public ComposeAutomaton<_Automaton> {
 
     public:
         State_(Fsa::StateId l, Fsa::StateId f, Fsa::StateId r)
-                : l_(l | (f << Fsa::StateIdBits)), r_(r) {}
+                : l_(l | (f << Fsa::StateIdBits)),
+                  r_(r) {}
         Fsa::StateId l() const {
             return l_ & Fsa::StateIdMask;
         }
diff --git a/src/Fsa/tCopy.cc b/src/Fsa/tCopy.cc
index 51ba82e0e..ccd429688 100644
--- a/src/Fsa/tCopy.cc
+++ b/src/Fsa/tCopy.cc
@@ -33,7 +33,8 @@ class CopyDfsState : public DfsState<_Automaton> {
 
 public:
     CopyDfsState(StorageAutomaton<_Automaton>* f, _ConstAutomatonRef f2)
-            : Precursor(f2), fsa_(f) {
+            : Precursor(f2),
+              fsa_(f) {
     }
     virtual void discoverState(_ConstStateRef sp) {
         fsa_->setState(new _State(*sp));
@@ -107,7 +108,6 @@ template<class _Automaton>
 void copy(StorageAutomaton<_Automaton>*                   f,
           const Fsa::Hash<std::string, Core::StringHash>& tokens,
           u32                                             sausage) {
-    typedef typename _Automaton::Arc   _Arc;
     typedef typename _Automaton::State _State;
 
     f->setType(Fsa::TypeAcceptor);
diff --git a/src/Fsa/tDeterminize.cc b/src/Fsa/tDeterminize.cc
index 6271cecb5..02703e2b2 100644
--- a/src/Fsa/tDeterminize.cc
+++ b/src/Fsa/tDeterminize.cc
@@ -70,9 +70,17 @@ class DeterminizeAutomaton : public _Automaton {
         bool                    disconnect_;
         Substate() {}
         Substate(Fsa::StateId state, Fsa::LabelIdStrings::Id output, Weight weight)
-                : predecessor_(NoPredecessor), state_(state), output_(output), weight_(weight), disconnect_(false) {}
+                : predecessor_(NoPredecessor),
+                  state_(state),
+                  output_(output),
+                  weight_(weight),
+                  disconnect_(false) {}
         Substate(Cursor predecessor, Fsa::StateId state, Fsa::LabelIdStrings::Id output, Weight weight)
-                : predecessor_(predecessor), state_(state), output_(output), weight_(weight), disconnect_(false) {}
+                : predecessor_(predecessor),
+                  state_(state),
+                  output_(output),
+                  weight_(weight),
+                  disconnect_(false) {}
         bool operator<(const Substate& s) const {
             return (state_ < s.state_) || ((state_ == s.state_) && (output_ < s.output_));
         }
@@ -116,7 +124,8 @@ class DeterminizeAutomaton : public _Automaton {
             Cursor                 current_, skip_;
             Substate               substate_;
             const_iterator(const Substates& container, Cursor i)
-                    : container_(container), current_(i) {
+                    : container_(container),
+                      current_(i) {
                 substate_.weight_ = container_.semiring_->one();
                 uncompress();
             }
@@ -337,7 +346,8 @@ class DeterminizeAutomaton : public _Automaton {
         typename Substates::Cursor subset_;  // state label: subset of state and weights
         Fsa::LabelIdStrings::Id    output_;  // hash index
         State_(typename Substates::Cursor subset, Fsa::LabelIdStrings::Id output)
-                : subset_(subset), output_(output) {}
+                : subset_(subset),
+                  output_(output) {}
     };
     struct StateHashKey_ {
         const Self& d_;
@@ -389,7 +399,11 @@ class DeterminizeAutomaton : public _Automaton {
         Fsa::LabelId               start_;
         Arc_() {}
         Arc_(typename Substates::Cursor predecessor, Fsa::LabelId input, Fsa::StateId target, Weight weight, Fsa::LabelId start)
-                : predecessor_(predecessor), input_(input), target_(target), weight_(weight), start_(start) {}
+                : predecessor_(predecessor),
+                  input_(input),
+                  target_(target),
+                  weight_(weight),
+                  start_(start) {}
         bool operator<(const Arc_& a) const {
             return input_ < a.input_;
         }
@@ -399,7 +413,9 @@ class DeterminizeAutomaton : public _Automaton {
 
 public:
     DeterminizeAutomaton(_ConstAutomatonRef f, bool disambiguate)
-            : disambiguate_(disambiguate), substates_(f->semiring()), states_(StateHashKey_(*this), StateHashEqual_(*this)) {
+            : disambiguate_(disambiguate),
+              substates_(f->semiring()),
+              states_(StateHashKey_(*this), StateHashEqual_(*this)) {
         fsa_ = sort<_Automaton>(f, Fsa::SortTypeByInput);
         this->unsetProperties(Fsa::PropertyAll);
         this->setProperties(f->knownProperties(), f->properties());
diff --git a/src/Fsa/tDraw.cc b/src/Fsa/tDraw.cc
index a6de6a9c7..7ac509d31 100644
--- a/src/Fsa/tDraw.cc
+++ b/src/Fsa/tDraw.cc
@@ -46,7 +46,8 @@ class DrawDotDfsState : public DfsState<_Automaton> {
 
 public:
     DrawDotDfsState(DotDrawer<_Automaton>& dd, _ConstAutomatonRef f)
-            : Precursor(f), dd_(dd) {
+            : Precursor(f),
+              dd_(dd) {
         if (dd_.hints_ & Fsa::HintMarkBest) {
             potentials_            = sssp<_Automaton>(transpose<_Automaton>(Precursor::fsa_, false));
             _ConstAutomatonRef tmp = best<_Automaton>(Precursor::fsa_, potentials_);
@@ -133,7 +134,9 @@ class DrawDotDfsState : public DfsState<_Automaton> {
 
 template<class _Automaton>
 DotDrawer<_Automaton>::DotDrawer(std::ostream& os, Fsa::Hint hints, bool progress)
-        : os_(os), hints_(hints), progress_(progress) {}
+        : os_(os),
+          hints_(hints),
+          progress_(progress) {}
 
 template<class _Automaton>
 bool DotDrawer<_Automaton>::draw(typename _Automaton::ConstRef f) {
diff --git a/src/Fsa/tInfo.cc b/src/Fsa/tInfo.cc
index 6bcd75f22..f37ad4e8f 100644
--- a/src/Fsa/tInfo.cc
+++ b/src/Fsa/tInfo.cc
@@ -113,7 +113,9 @@ class CountLinearStatesDfsState : public DfsState<_Automaton> {
 
 public:
     CountLinearStatesDfsState(ConstAutomatonRef f, const Core::Vector<u32>& nInDegree)
-            : Precursor(f), nLinearStates_(0), nInDegree_(nInDegree) {
+            : Precursor(f),
+              nLinearStates_(0),
+              nInDegree_(nInDegree) {
     }
     size_t nLinearStates() const {
         return nLinearStates_;
@@ -161,7 +163,11 @@ class CountInputDfsState : public DfsState<_Automaton> {
 
 public:
     CountInputDfsState(ConstAutomatonRef f, Fsa::LabelId label)
-            : Precursor(f), nArcs_(0), nMatched_(0), nEpsilons_(0), label_(label) {
+            : Precursor(f),
+              nArcs_(0),
+              nMatched_(0),
+              nEpsilons_(0),
+              label_(label) {
     }
     virtual void discoverState(ConstStateRef sp) {
         for (typename State::const_iterator a = sp->begin(); a != sp->end(); ++a) {
@@ -204,7 +210,11 @@ class CountOutputDfsState : public DfsState<_Automaton> {
 
 public:
     CountOutputDfsState(ConstAutomatonRef f, Fsa::LabelId label)
-            : Precursor(f), nArcs_(0), nMatched_(0), nEpsilons_(0), label_(label) {
+            : Precursor(f),
+              nArcs_(0),
+              nMatched_(0),
+              nEpsilons_(0),
+              label_(label) {
     }
     virtual void discoverState(ConstStateRef sp) {
         for (typename State::const_iterator a = sp->begin(); a != sp->end(); ++a) {
diff --git a/src/Fsa/tMinimize.cc b/src/Fsa/tMinimize.cc
index c08bade69..819a3c61d 100644
--- a/src/Fsa/tMinimize.cc
+++ b/src/Fsa/tMinimize.cc
@@ -42,7 +42,8 @@ class StateMappedAutomaton : public SlaveAutomaton<A> {
             : Precursor(f) {
     }
     StateMappedAutomaton(_ConstAutomatonRef f, const Fsa::StateMap& map)
-            : Precursor(f), map_(map) {
+            : Precursor(f),
+              map_(map) {
     }
 
 public:
@@ -91,7 +92,8 @@ class MinimizeAutomaton : public StateMappedAutomaton<A> {
         Fsa::StateId id_;
         ClassId      class_;
         ClassEntry(Fsa::StateId id, ClassId c)
-                : id_(id), class_(c) {
+                : id_(id),
+                  class_(c) {
         }
         bool operator<(const ClassEntry& e) const {
             return class_ < e.class_;
@@ -111,7 +113,11 @@ class MinimizeAutomaton : public StateMappedAutomaton<A> {
         HashTargetMappedAndLabels(_ConstAutomatonRef              f,
                                   const ClassMap&                 classMap,
                                   const StatePotentials<_Weight>& statePotentials)
-                : transducer_(f->type() == Fsa::TypeTransducer), fsa_(f), classMap_(classMap), semiring_(f->semiring()), statePotentials_(statePotentials) {}
+                : transducer_(f->type() == Fsa::TypeTransducer),
+                  fsa_(f),
+                  classMap_(classMap),
+                  semiring_(f->semiring()),
+                  statePotentials_(statePotentials) {}
         size_t operator()(Fsa::StateId s) const {
             const _ConstStateRef sp  = fsa_->getState(s);
             size_t               key = 100003 * semiring_->hash(statePotentials_[s]) + sp->nArcs();
@@ -136,7 +142,10 @@ class MinimizeAutomaton : public StateMappedAutomaton<A> {
         EqualTargetMappedAndLabels(_ConstAutomatonRef              f,
                                    const ClassMap&                 classMap,
                                    const StatePotentials<_Weight>& statePotentials)
-                : fsa_(f), classMap_(classMap), semiring_(f->semiring()), statePotentials_(statePotentials) {
+                : fsa_(f),
+                  classMap_(classMap),
+                  semiring_(f->semiring()),
+                  statePotentials_(statePotentials) {
         }
         bool operator()(Fsa::StateId as, Fsa::StateId bs) const {
             if (semiring_->compare(statePotentials_[as],
diff --git a/src/Fsa/tOutput.cc b/src/Fsa/tOutput.cc
index 2d4470e77..451dea39a 100644
--- a/src/Fsa/tOutput.cc
+++ b/src/Fsa/tOutput.cc
@@ -76,7 +76,10 @@ class WriteAttDfsState : public DfsState<_Automaton> {
 
 public:
     WriteAttDfsState(_ConstAutomatonRef f, std::ostream& o)
-            : Precursor(f), o_(o), input_(f->getInputAlphabet()), output_(f->getOutputAlphabet()) {}
+            : Precursor(f),
+              o_(o),
+              input_(f->getInputAlphabet()),
+              output_(f->getOutputAlphabet()) {}
     void discoverState(_ConstStateRef sp) {
         if (sp->isFinal()) {
             o_ << sp->id();
@@ -161,7 +164,8 @@ class WriteBinaryDfsState : public DfsState<_Automaton> {
 
 public:
     WriteBinaryDfsState(_ConstAutomatonRef f, Core::BinaryOutputStream& o)
-            : Precursor(f), o_(o) {}
+            : Precursor(f),
+              o_(o) {}
     void discoverState(_ConstStateRef sp) {
         Fsa::StateId idAndTags = sp->id() | sp->tags();
         if (!(o_ << idAndTags))
@@ -256,7 +260,12 @@ class WriteLinearDfsState : public DfsState<_Automaton> {
 
 public:
     WriteLinearDfsState(_ConstAutomatonRef f, std::ostream& o, bool printAll = false)
-            : Precursor(f), first_(true), o_(o), input_(Precursor::fsa_->getInputAlphabet()), output_(Precursor::fsa_->getOutputAlphabet()), printAll_(printAll) {}
+            : Precursor(f),
+              first_(true),
+              o_(o),
+              input_(Precursor::fsa_->getInputAlphabet()),
+              output_(Precursor::fsa_->getOutputAlphabet()),
+              printAll_(printAll) {}
     void discoverState(_ConstStateRef sp) {
         for (typename _State::const_iterator a = sp->begin(); a != sp->end(); ++a) {
             std::string out;
@@ -328,7 +337,8 @@ class WriteXmlDfsState : public DfsState<_Automaton> {
 
 public:
     WriteXmlDfsState(_ConstAutomatonRef f, Core::XmlWriter& o)
-            : Precursor(f), o_(o) {}
+            : Precursor(f),
+              o_(o) {}
     void discoverState(_ConstStateRef sp) {
         o_ << Core::XmlOpen("state") + Core::XmlAttribute("id", sp->id());
         if (sp->isFinal())
@@ -433,7 +443,9 @@ class NodeTrWGWriter : public DfsState<_Automaton> {
 
 public:
     NodeTrWGWriter(_ConstAutomatonRef f, std::ostream& o)
-            : Precursor(f), o_(o), max_id_(0) {}
+            : Precursor(f),
+              o_(o),
+              max_id_(0) {}
 
     virtual void discoverState(_ConstStateRef sp) {
         if (max_id_ < sp->id())
@@ -492,7 +504,9 @@ class EdgeTrWGWriter : public DfsState<_Automaton> {
 
 public:
     EdgeTrWGWriter(_ConstAutomatonRef f, NodeTrWGWriter<_Automaton>& nw, std::ostream& o)
-            : Precursor(f), nw_(nw), o_(o) {
+            : Precursor(f),
+              nw_(nw),
+              o_(o) {
         inAlpha_ = f->getInputAlphabet();
     }
 
diff --git a/src/Fsa/tPrune.cc b/src/Fsa/tPrune.cc
index 0958a4882..0e9920827 100644
--- a/src/Fsa/tPrune.cc
+++ b/src/Fsa/tPrune.cc
@@ -59,7 +59,14 @@ class PosteriorPruneAutomaton : public SlaveAutomaton<_Automaton>, public DfsSta
 
 public:
     PosteriorPruneAutomaton(_ConstAutomatonRef f, const _Weight& threshold, bool relative)
-            : Precursor(f), DfsState<_Automaton>(f), threshold_(threshold), fw_(new _StatePotentials), bw_(new _StatePotentials), forward_(*fw_), backward_(*bw_), relative_(relative) {
+            : Precursor(f),
+              DfsState<_Automaton>(f),
+              threshold_(threshold),
+              fw_(new _StatePotentials),
+              bw_(new _StatePotentials),
+              forward_(*fw_),
+              backward_(*bw_),
+              relative_(relative) {
         this->setProperties(Fsa::PropertyStorage | Fsa::PropertyCached, Fsa::PropertyNone);
         Fsa::StateId initial = f->initialStateId();
         if (initial != Fsa::InvalidStateId) {
@@ -70,7 +77,14 @@ class PosteriorPruneAutomaton : public SlaveAutomaton<_Automaton>, public DfsSta
     }
 
     PosteriorPruneAutomaton(_ConstAutomatonRef f, const _Weight& threshold, const _StatePotentials& fw, const _StatePotentials& bw, bool relative)
-            : Precursor(f), DfsState<_Automaton>(f), threshold_(threshold), fw_(0), bw_(0), forward_(fw), backward_(bw), relative_(relative) {
+            : Precursor(f),
+              DfsState<_Automaton>(f),
+              threshold_(threshold),
+              fw_(0),
+              bw_(0),
+              forward_(fw),
+              backward_(bw),
+              relative_(relative) {
         this->setProperties(Fsa::PropertyStorage | Fsa::PropertyCached, Fsa::PropertyNone);
         setMinWeight(threshold);
     }
@@ -160,7 +174,9 @@ class SyncPruneAutomaton : public SlaveAutomaton<_Automaton> {
 
 public:
     SyncPruneAutomaton(_ConstAutomatonRef f, const _Weight& threshold)
-            : Precursor(f), threshold_(threshold), maxWeight_(Precursor::fsa_->semiring()->max()) {
+            : Precursor(f),
+              threshold_(threshold),
+              maxWeight_(Precursor::fsa_->semiring()->max()) {
         this->setProperties(Fsa::PropertyStorage | Fsa::PropertyCached, Fsa::PropertyNone);
         Fsa::StateId initial = f->initialStateId();
         slice_.grow(initial, Fsa::InvalidStateId);
diff --git a/src/Fsa/tRational.cc b/src/Fsa/tRational.cc
index d77cb4b33..d7fda8566 100644
--- a/src/Fsa/tRational.cc
+++ b/src/Fsa/tRational.cc
@@ -58,7 +58,8 @@ class ClosureAutomaton : public ModifyAutomaton<_Automaton> {
 
 public:
     ClosureAutomaton(_ConstAutomatonRef f)
-            : Precursor(f), initial_(f->initialStateId()) {
+            : Precursor(f),
+              initial_(f->initialStateId()) {
     }
     /*! \todo existing loop weight should be collected with final weight. */
     virtual void modifyState(_State* sp) const {
@@ -98,7 +99,8 @@ class KleeneClosureAutomaton : public SlaveAutomaton<_Automaton> {
 
 public:
     KleeneClosureAutomaton(_ConstAutomatonRef f)
-            : Precursor(closure(f)), initialIsFinal_(false) {
+            : Precursor(closure(f)),
+              initialIsFinal_(false) {
     }
     virtual Fsa::StateId initialStateId() const {
         if (Precursor::fsa_->initialStateId() != Fsa::InvalidStateId) {
@@ -283,35 +285,43 @@ class ConcatUnionAutomaton : public _Automaton {
     }
 
     virtual std::string name() const = 0;
-    virtual Fsa::Type   type() const {
+
+    virtual Fsa::Type type() const {
         return type_;
     }
+
     virtual _ConstSemiringRef semiring() const {
         return semiring_;
     }
+
     virtual Fsa::ConstAlphabetRef getInputAlphabet() const {
         return input_;
     }
+
     virtual Fsa::ConstAlphabetRef getOutputAlphabet() const {
         return output_;
     }
+
     virtual void dumpState(Fsa::StateId s, std::ostream& o) const {
         u32 k = subAutomaton(s);
         o << k << ",";
         fsa_[k]->dumpState(subStateId(s), o);
-    };
+    }
+
     virtual size_t getMemoryUsed() const {
         size_t memoryUsed = 0;
         for (typename Core::Vector<_ConstAutomatonRef>::const_iterator i = fsa_.begin(); i != fsa_.end(); ++i)
             memoryUsed += (*i)->getMemoryUsed();
         return memoryUsed;
     }
+
     virtual void dumpMemoryUsage(Core::XmlWriter& o) const {
         o << Core::XmlOpen(name());
         for (typename Core::Vector<_ConstAutomatonRef>::const_iterator i = fsa_.begin(); i != fsa_.end(); ++i)
             (*i)->dumpMemoryUsage(o);
         o << Core::XmlClose(name());
     }
+
     virtual std::string describe() const {
         std::string result = name() + "(";
         for (size_t i = 0; i < fsa_.size(); ++i) {
@@ -322,11 +332,13 @@ class ConcatUnionAutomaton : public _Automaton {
         result += ")";
         return result;
     }
+
     // State ids are interleaved.  We reserve 0 for the initial state.
     /** Index of sub-automaton. */
     u32 subAutomaton(Fsa::StateId s) const {
         return (s - 1) % fsa_.size();
     }
+
     /** Id of state in sub-automaton. */
     Fsa::StateId subStateId(Fsa::StateId s) const {
         return (s - 1) / fsa_.size();
@@ -410,7 +422,8 @@ class UnionAutomaton : public ConcatUnionAutomaton<_Automaton> {
 public:
     UnionAutomaton(const Core::Vector<_ConstAutomatonRef>&          fsa,
                    const Core::Vector<typename _Automaton::Weight>& initialWeights)
-            : Precursor(fsa), initialWeights_(initialWeights) {
+            : Precursor(fsa),
+              initialWeights_(initialWeights) {
         if (initialWeights_.empty())
             initialWeights_.resize(fsa.size(), Precursor::semiring_->one());
         else
@@ -474,7 +487,8 @@ class UniteMapping : public Fsa::Mapping {
 
 public:
     UniteMapping(_ConstAutomatonRef f, u32 subAutomaton)
-            : uFsa_(dynamic_cast<const _UniteAutomaton*>(f.get())), subAutomaton_(subAutomaton) {
+            : uFsa_(dynamic_cast<const _UniteAutomaton*>(f.get())),
+              subAutomaton_(subAutomaton) {
         require(uFsa_);
     }
     virtual ~UniteMapping() {}
@@ -709,7 +723,8 @@ class AllPrefixesAutomaton : public ModifyAutomaton<_Automaton> {
         typedef typename _Automaton::Arc _Arc;
 
         ProductiveStateFinder(_ConstAutomatonRef f, std::vector<bool>& productive_states)
-                : Precursor(f), productiveStates_(productive_states) {}
+                : Precursor(f),
+                  productiveStates_(productive_states) {}
 
         virtual void discoverState(_ConstStateRef sp) {
             Fsa::StateTag tags = sp->tags();
@@ -792,7 +807,8 @@ class AllSuffixesAutomaton : public ModifyAutomaton<_Automaton> {
         typedef typename _Automaton::Arc _Arc;
 
         ReachableStateFinder(_ConstAutomatonRef f, std::vector<bool>& reachable_states)
-                : Precursor(f), reachableStates_(reachable_states) {}
+                : Precursor(f),
+                  reachableStates_(reachable_states) {}
 
         virtual void discoverState(_ConstStateRef sp) {
             if (sp->id() >= reachableStates_.size()) {
diff --git a/src/Fsa/tRealSemiring.hh b/src/Fsa/tRealSemiring.hh
index 37304e755..c7da7a1b2 100644
--- a/src/Fsa/tRealSemiring.hh
+++ b/src/Fsa/tRealSemiring.hh
@@ -34,13 +34,17 @@ protected:
 public:
     LogSemiring();
     LogSemiring(s32 tolerance);
+
     virtual std::string name() const;
-    _Weight             create() const {
+
+    _Weight create() const {
         return _Weight();
     }
+
     _Weight clone(const _Weight& a) const {
         return _Weight(_Type(a));
     }
+
     virtual _Weight       invalid() const;
     virtual _Weight       zero() const;
     virtual _Weight       one() const;
@@ -49,9 +53,11 @@ public:
     virtual _Accumulator* getExtender(const _Weight& initial) const;
     virtual _Weight       collect(const _Weight& a, const _Weight& b) const;
     virtual _Weight       invCollect(const _Weight& a, const _Weight& b) const;
-    virtual bool          hasInvCollect() const {
+
+    virtual bool hasInvCollect() const {
         return true;
     }
+
     virtual _Accumulator* getCollector(const _Weight& initial) const;
     virtual _Weight       invert(const _Weight& a) const;
     virtual int           compare(const _Weight& a, const _Weight& b) const;
@@ -81,15 +87,19 @@ public:
 public:
     TropicalSemiring();
     TropicalSemiring(s32 tolerance);
+
     virtual std::string name() const;
     virtual _Weight     collect(const _Weight& a, const _Weight& b) const;
-    virtual _Weight     invCollect(const _Weight& a, const _Weight& b) const {
+
+    virtual _Weight invCollect(const _Weight& a, const _Weight& b) const {
         std::cerr << "method \"invCollect\" is not supported" << std::endl;
         return this->invalid();
     }
+
     virtual bool hasInvCollect() const {
         return false;
     }
+
     virtual _Accumulator* getCollector(const _Weight& initial) const;
 };
 
diff --git a/src/Fsa/tResources.hh b/src/Fsa/tResources.hh
index 1bd6f5baf..5b17f7eed 100644
--- a/src/Fsa/tResources.hh
+++ b/src/Fsa/tResources.hh
@@ -44,9 +44,15 @@ public:
         Reader            reader;
         Writer            writer;
         Format(const std::string& name, const std::string& desc)
-                : name(name), desc(desc), reader(0), writer(0) {}
+                : name(name),
+                  desc(desc),
+                  reader(0),
+                  writer(0) {}
         Format(const std::string& name, const std::string& desc, Reader reader, Writer writer)
-                : name(name), desc(desc), reader(reader), writer(writer) {}
+                : name(name),
+                  desc(desc),
+                  reader(reader),
+                  writer(writer) {}
     };
 
 private:
diff --git a/src/Fsa/tSemiring.hh b/src/Fsa/tSemiring.hh
index 7761a5e0a..6e68a942d 100644
--- a/src/Fsa/tSemiring.hh
+++ b/src/Fsa/tSemiring.hh
@@ -69,13 +69,16 @@ public:
     virtual _Weight     max() const                                       = 0;
     virtual _Weight     extend(const _Weight& a, const _Weight& b) const  = 0;
     virtual _Weight     collect(const _Weight& a, const _Weight& b) const = 0;
-    virtual _Weight     invCollect(const _Weight& a, const _Weight& b) const {
+
+    virtual _Weight invCollect(const _Weight& a, const _Weight& b) const {
         std::cerr << "method \"invCollect\" is not supported" << std::endl;
         return invalid();
     }
+
     virtual bool hasInvCollect() const {
         return false;
     }
+
     virtual _Weight invert(const _Weight& a) const                    = 0;
     virtual int     compare(const _Weight& a, const _Weight& b) const = 0;
     virtual size_t  hash(const _Weight& a) const                      = 0;
@@ -109,7 +112,9 @@ protected:
         Function    f;
         _Weight     w;
         AnchoredAccumulator(const Self* self, Function f, const _Weight& init)
-                : self(self), f(f), w(init) {
+                : self(self),
+                  f(f),
+                  w(init) {
             self->acquireReference();
         }
         virtual ~AnchoredAccumulator() {
diff --git a/src/Fsa/tSort.cc b/src/Fsa/tSort.cc
index 124aee839..f1fd01343 100644
--- a/src/Fsa/tSort.cc
+++ b/src/Fsa/tSort.cc
@@ -239,7 +239,9 @@ class TopologicallySortDfsState : public DfsState<_Automaton> {
 
 public:
     TopologicallySortDfsState(_ConstAutomatonRef f)
-            : Precursor(f), time_(0), isCyclic_(false) {}
+            : Precursor(f),
+              time_(0),
+              isCyclic_(false) {}
     virtual void finishState(Fsa::StateId s) {
         map_.grow(s, Fsa::InvalidStateId);
         map_[s] = time_++;
diff --git a/src/Fsa/tSssp.cc b/src/Fsa/tSssp.cc
index 381e85bdc..00d0032c0 100644
--- a/src/Fsa/tSssp.cc
+++ b/src/Fsa/tSssp.cc
@@ -35,9 +35,13 @@ class SsspQueue {
 
 public:
     SsspQueue()
-            : head_(Fsa::InvalidStateId), tail_(Fsa::InvalidStateId), n_(0) {}
+            : head_(Fsa::InvalidStateId),
+              tail_(Fsa::InvalidStateId),
+              n_(0) {}
     SsspQueue(Fsa::StateId maxStateId)
-            : head_(Fsa::InvalidStateId), tail_(Fsa::InvalidStateId), n_(0) {
+            : head_(Fsa::InvalidStateId),
+              tail_(Fsa::InvalidStateId),
+              n_(0) {
         next_.grow(maxStateId, Fsa::InvalidStateId);
     }
 
@@ -107,7 +111,8 @@ class TopologicalSsspQueue : public SsspQueue {
 
 public:
     TopologicalSsspQueue(const Fsa::StateMap& s2t)
-            : SsspQueue(s2t.size() - 1), s2t_(s2t) {}
+            : SsspQueue(s2t.size() - 1),
+              s2t_(s2t) {}
 
     virtual ~TopologicalSsspQueue() {}
 
@@ -419,7 +424,8 @@ class PosteriorAutomaton : public ModifyAutomaton<_Automaton> {
         totalInv_           = this->semiring()->invert(backwardPotentials_[f->initialStateId()]);
     }
     PosteriorAutomaton(_ConstAutomatonRef f, const _StatePotentials& forward)
-            : Precursor(f), forwardPotentials_(forward) {
+            : Precursor(f),
+              forwardPotentials_(forward) {
         backwardPotentials_ = sssp<_Automaton>(transpose<_Automaton>(f));
         totalInv_           = this->semiring()->invert(backwardPotentials_[f->initialStateId()]);
     }
diff --git a/src/Fsa/tSssp4SpecialSymbols.cc b/src/Fsa/tSssp4SpecialSymbols.cc
index ae0ee8717..ac8b973d3 100644
--- a/src/Fsa/tSssp4SpecialSymbols.cc
+++ b/src/Fsa/tSssp4SpecialSymbols.cc
@@ -67,7 +67,7 @@ Fsa::ConstSemiring64Ref convertSemiring<Fsa::ConstSemiring64Ref>(Fsa::ConstSemir
 }
 
 template<class _leftArc, class _rightArc>
-struct byInputAndOutput : public std::binary_function<_leftArc, _rightArc, bool> {
+struct byInputAndOutput {
     static bool cmp(const _leftArc& a, const _rightArc& b) {
         if (a.input() < b.input())
             return true;
@@ -183,10 +183,11 @@ class SsspBackward4SpecialSymbols : public DfsState<_Automaton> {
         inline static _Weight failArc(const _Arc* arc, DirectHits& directHits, _Accumulator* collector, const bool firstLevel, _SsspBackward4SpecialSymbols* owner) {
             Fsa::StateId ts = arc->target();
             _Weight      failWeight, update;
+
             failWeight = owner->processState<AddArc>(ts, directHits);
-            update     = owner->semiring_->extend(
-                    sssp4SpecialSymbolsHelper::convertWeight<_AutomataWeight, _Weight>(arc->weight()),
-                    failWeight);
+            update     = owner->semiring_->extend(sssp4SpecialSymbolsHelper::convertWeight<_AutomataWeight, _Weight>(arc->weight()),
+                                                  failWeight);
+
             collector->feed(update);
             return failWeight;
         }
diff --git a/src/Fsa/tStatic.hh b/src/Fsa/tStatic.hh
index 3d7a3c265..c7f382f65 100644
--- a/src/Fsa/tStatic.hh
+++ b/src/Fsa/tStatic.hh
@@ -41,14 +41,21 @@ private:
 
 public:
     StaticAutomaton(Fsa::Type type = Fsa::TypeUnknown)
-            : Precursor(type), desc_("static"), memoryUsed_(0) {}
+            : Precursor(type),
+              desc_("static"),
+              memoryUsed_(0) {}
     StaticAutomaton(const std::string& desc, Fsa::Type type = Fsa::TypeUnknown)
-            : Precursor(type), desc_(desc), memoryUsed_(0) {}
+            : Precursor(type),
+              desc_(desc),
+              memoryUsed_(0) {}
     virtual ~StaticAutomaton();
+
     virtual void clear();
-    void         setDescription(const std::string& desc) {
+
+    void setDescription(const std::string& desc) {
         desc_ = desc;
     }
+
     virtual bool hasState(Fsa::StateId sid) const;
     _State*      newState(Fsa::StateId tags = 0);
     _State*      newState(Fsa::StateId tags, const _Weight& finalWeight);
@@ -56,27 +63,35 @@ public:
     void         setStateFinal(_State*, const _Weight& finalWeight);
     void         setStateFinal(_State*);
     _StateRef    state(Fsa::StateId s);
-    _State*      fastState(Fsa::StateId s) {
+
+    _State* fastState(Fsa::StateId s) {
         return states_[s].get();
     }
+
     const _State* fastState(Fsa::StateId s) const {
         return states_[s].get();
     }
+
     virtual void           setState(_State* sp);
     virtual void           deleteState(Fsa::StateId);
     virtual _ConstStateRef getState(Fsa::StateId s) const;
     virtual void           normalize();
-    virtual Fsa::StateId   maxStateId() const {
+
+    virtual Fsa::StateId maxStateId() const {
         return states_.size() - 1;
     }
+
     virtual Fsa::StateId size() const {
         return states_.size();
     }
-    virtual size_t      getMemoryUsed() const;
-    virtual void        dumpMemoryUsage(Core::XmlWriter& o) const;
+
+    virtual size_t getMemoryUsed() const;
+    virtual void   dumpMemoryUsage(Core::XmlWriter& o) const;
+
     virtual std::string describe() const {
         return desc_;
     }
+
     void compact(Fsa::StateMap& mapping);
 };
 }  // namespace Ftl
diff --git a/src/Fsa/tStaticAlgorithm.cc b/src/Fsa/tStaticAlgorithm.cc
index b2a19788f..3b70836e7 100644
--- a/src/Fsa/tStaticAlgorithm.cc
+++ b/src/Fsa/tStaticAlgorithm.cc
@@ -62,7 +62,8 @@ class IsInvalidArc {
 
 public:
     IsInvalidArc(Fsa::ConstSemiringRef sr)
-            : invalid_(sr->invalid()), zero_(sr->zero()) {}
+            : invalid_(sr->invalid()),
+              zero_(sr->zero()) {}
     bool operator()(const Fsa::Arc& a) {
         return (a.weight() == invalid_) or (a.weight() == zero_);
     }
diff --git a/src/Fsa/tStorage.hh b/src/Fsa/tStorage.hh
index 2cb694889..7bca234ef 100644
--- a/src/Fsa/tStorage.hh
+++ b/src/Fsa/tStorage.hh
@@ -40,17 +40,21 @@ protected:
 
 public:
     StorageAutomaton(Fsa::Type type = Fsa::TypeUnknown);
-    virtual Fsa::Type         type() const;
-    virtual void              setType(Fsa::Type type);
-    virtual void              addProperties(Fsa::Property properties) const;
-    virtual void              setProperties(Fsa::Property knownProperties, Fsa::Property properties) const;
-    virtual void              unsetProperties(Fsa::Property unknownProperties) const;
+    virtual Fsa::Type type() const;
+    virtual void      setType(Fsa::Type type);
+    virtual void      addProperties(Fsa::Property properties) const;
+    virtual void      setProperties(Fsa::Property knownProperties, Fsa::Property properties) const;
+    virtual void      unsetProperties(Fsa::Property unknownProperties) const;
+
     virtual _ConstSemiringRef semiring() const;
-    virtual void              setSemiring(_ConstSemiringRef semiring) {
+
+    virtual void setSemiring(_ConstSemiringRef semiring) {
         semiring_ = semiring;
     }
+
     virtual Fsa::StateId initialStateId() const;
-    virtual void         setInitialStateId(Fsa::StateId initial) {
+
+    virtual void setInitialStateId(Fsa::StateId initial) {
         initial_ = initial;
     }
 
diff --git a/src/Fsa/tStorageXml.hh b/src/Fsa/tStorageXml.hh
index 7d3b5740a..ad1f6f422 100644
--- a/src/Fsa/tStorageXml.hh
+++ b/src/Fsa/tStorageXml.hh
@@ -213,7 +213,9 @@ private:
 
 public:
     StorageAutomatonXmlParser(const _Resources& resources, _StorageAutomaton* fsa)
-            : Precursor(resources.getConfiguration()), resources_(resources), fsa_(fsa) {
+            : Precursor(resources.getConfiguration()),
+              resources_(resources),
+              fsa_(fsa) {
         fsa_->setType(Fsa::TypeTransducer);
         Core::XmlMixedElement* arcElement   = new Core::XmlMixedElementRelay("arc", this, startHandler(&Self::startArc), 0, 0,
                                                                              XML_CHILD(new Core::XmlMixedElementRelay("in", this, startHandler(&Self::startIn),
diff --git a/src/Lattice/Accumulator.hh b/src/Lattice/Accumulator.hh
index 79e768cc3..3a18490e3 100644
--- a/src/Lattice/Accumulator.hh
+++ b/src/Lattice/Accumulator.hh
@@ -37,10 +37,10 @@ protected:
     Trainer*   trainer_;
 
 protected:
-    virtual void accumulate(Core::Ref<const Mm::Feature::Vector> f, Mm::MixtureIndex m, Mm::Weight w) {
+    virtual void accumulate(Mm::Feature::VectorRef f, Mm::MixtureIndex m, Mm::Weight w) {
         defect();
     }
-    virtual void accumulate(Core::Ref<const Mm::Feature::Vector> f, const PosteriorsAndDensities& p) {
+    virtual void accumulate(Mm::Feature::VectorRef f, const PosteriorsAndDensities& p) {
         defect();
     }
     /*
@@ -87,9 +87,11 @@ protected:
 
 protected:
     virtual const Alignment* getAlignment(Fsa::ConstStateRef from, const Fsa::Arc& a);
-    virtual void             process(TimeframeIndex t, Mm::MixtureIndex m, Mm::Weight w) {
+
+    virtual void process(TimeframeIndex t, Mm::MixtureIndex m, Mm::Weight w) {
         this->accumulate((*accumulationFeatures_)[t]->mainStream(), m, w);
     }
+
     virtual void reset() {}
 
 public:
@@ -100,7 +102,8 @@ public:
     virtual ~AcousticAccumulator() {}
 
     virtual void discoverState(Fsa::ConstStateRef sp);
-    void         setAccumulationFeatures(ConstSegmentwiseFeaturesRef accumulationFeatures) {
+
+    void setAccumulationFeatures(ConstSegmentwiseFeaturesRef accumulationFeatures) {
         accumulationFeatures_ = accumulationFeatures;
     }
 };
@@ -112,7 +115,8 @@ struct Key {
     Speech::TimeframeIndex t;
     Mm::MixtureIndex       m;
     Key(Speech::TimeframeIndex _t, Mm::MixtureIndex _m)
-            : t(_t), m(_m) {}
+            : t(_t),
+              m(_m) {}
 };
 struct KeyHash {
     size_t operator()(const Key& k) const {
diff --git a/src/Lattice/Accuracy.cc b/src/Lattice/Accuracy.cc
index 5a084e7c8..01d82ecb6 100644
--- a/src/Lattice/Accuracy.cc
+++ b/src/Lattice/Accuracy.cc
@@ -309,7 +309,8 @@ class ApproximateAccuracyAutomaton : public ModifyWordLattice {
     struct TimeInterval {
         Speech::TimeframeIndex startTime, endTime;
         TimeInterval(Speech::TimeframeIndex _startTime, Speech::TimeframeIndex _endTime)
-                : startTime(_startTime), endTime(_endTime) {}
+                : startTime(_startTime),
+                  endTime(_endTime) {}
     };
     struct TimeIntervalHash {
         size_t operator()(const TimeInterval& i) const {
@@ -324,7 +325,8 @@ class ApproximateAccuracyAutomaton : public ModifyWordLattice {
     struct Hypothesis : public TimeInterval {
         Fsa::LabelId label;
         Hypothesis(Fsa::LabelId _label, Speech::TimeframeIndex _startTime, Speech::TimeframeIndex _endTime)
-                : TimeInterval(_startTime, _endTime), label(_label) {}
+                : TimeInterval(_startTime, _endTime),
+                  label(_label) {}
     };
     typedef std::unordered_set<TimeInterval, TimeIntervalHash, TimeIntervalEquality> TimeIntervals;
     typedef std::unordered_map<Fsa::LabelId, TimeIntervals>                          States;
@@ -1052,11 +1054,12 @@ class WeightedFramePhoneAccuracyAutomaton : public ApproximatePhoneAccuracyAutom
     class SetDerivativesDfsState : public DfsState {
     private:
         // without constant factor @param beta
-        struct diffSigmoid : public std::unary_function<f64, f64> {
+        struct diffSigmoid {
             const f64            beta, marginFactor;
             static constexpr s64 tol = 45035996274LL;  // = Core::differenceUlp(1, 1.00001)
             static constexpr f64 inf = 1e9;
-            f32                  operator()(f64 x) const {
+
+            f32 operator()(f64 x) const {
                 require(!Core::isSignificantlyLessUlp(x, 0, tol) && !Core::isSignificantlyLessUlp(1, x, tol));
                 if (beta != 1) {
                     if (Core::isAlmostEqualUlp(x, 0, tol) || Core::isAlmostEqualUlp(x, 1, tol)) {
@@ -1072,8 +1075,10 @@ class WeightedFramePhoneAccuracyAutomaton : public ApproximatePhoneAccuracyAutom
                     return 1;
                 }
             }
+
             diffSigmoid(f64 _beta, f64 _margin)
-                    : beta(_beta), marginFactor(exp(beta * _margin)) {
+                    : beta(_beta),
+                      marginFactor(exp(beta * _margin)) {
                 require(beta > 0);
             }
         };
diff --git a/src/Lattice/Archive.cc b/src/Lattice/Archive.cc
index c43ddd6a0..8d5ebb542 100644
--- a/src/Lattice/Archive.cc
+++ b/src/Lattice/Archive.cc
@@ -43,7 +43,7 @@ enum LatticeFormat {
     formatSourceFile,
     formatWolfgang
 };
-}
+}  // namespace Lattice
 
 namespace Lattice {
 class FsaArchiveReader;
@@ -85,7 +85,7 @@ enum Alphabet {
     evaluationTokenAlphabet,
     noLexiconCheck
 };
-}
+}  // namespace Lattice
 
 const Core::Choice Archive::alphabetChoice(
         "unknown", unknownAlphabet,
diff --git a/src/Lattice/Basic.cc b/src/Lattice/Basic.cc
index 192b476e6..1e62db9b7 100644
--- a/src/Lattice/Basic.cc
+++ b/src/Lattice/Basic.cc
@@ -59,7 +59,8 @@ struct Cutter {
     Fsa::StateId initial;
     Fsa::Weight  finalWeight;
     Cutter(Fsa::StateId _initial, Fsa::Weight _finalWeight)
-            : initial(_initial), finalWeight(_finalWeight) {}
+            : initial(_initial),
+              finalWeight(_finalWeight) {}
     Fsa::ConstAutomatonRef modify(Fsa::ConstAutomatonRef fsa) {
         return Fsa::partial(fsa, initial, finalWeight);
     }
@@ -165,7 +166,9 @@ class LatticeCounts : public DfsState {
 
 public:
     LatticeCounts(ConstWordLatticeRef lattice, Predicate p)
-            : DfsState(lattice), pred(p), nArcs(0) {}
+            : DfsState(lattice),
+              pred(p),
+              nArcs(0) {}
 
     virtual void discoverState(Fsa::ConstStateRef sp) {
         nArcs += std::count_if(sp->begin(), sp->end(), pred);
diff --git a/src/Lattice/Best.hh b/src/Lattice/Best.hh
index 8ddae5039..edcd6aca4 100644
--- a/src/Lattice/Best.hh
+++ b/src/Lattice/Best.hh
@@ -50,28 +50,37 @@ public:
     virtual ~NBestListExtractor();
 
     ConstWordLatticeRef getNBestList(ConstWordLatticeRef);
-    void                initialize(Bliss::LexiconRef);
-    void                setNumberOfHypotheses(u32 nHypotheses) {
+
+    void initialize(Bliss::LexiconRef);
+
+    void setNumberOfHypotheses(u32 nHypotheses) {
         targetNHypotheses_ = nHypotheses;
     }
+
     void setMinPruningThreshold(f32 minThreshold) {
         minThreshold_ = minThreshold;
     }
+
     void setMaxPruningThreshold(f32 maxThreshold) {
         maxThreshold_ = maxThreshold;
     }
+
     void setPruningIncrement(f32 thresholdIncrement) {
         thresholdIncrement_ = thresholdIncrement;
     }
+
     void setWorkOnOutput(bool workOnOutput) {
         workOnOutput_ = workOnOutput;
     }
+
     void setLatticeIsDeterministic(bool isDeterministic) {
         latticeIsDeterministic_ = isDeterministic;
     }
+
     void setHasFailArcs(bool hasFailArcs) {
         hasFailArcs_ = hasFailArcs;
     }
+
     void setNormalize(bool normalize) {
         normalize_ = normalize;
     }
diff --git a/src/Lattice/Lattice.cc b/src/Lattice/Lattice.cc
index 4b49d9ba9..65f86b903 100644
--- a/src/Lattice/Lattice.cc
+++ b/src/Lattice/Lattice.cc
@@ -325,7 +325,7 @@ class TimeConditionedWordLattice : public Fsa::SlaveAutomaton,
      */
     mutable Core::Ref<WordBoundaries> timeConditionedWordBoundaries_;
 
-    struct ByInputAndTarget : public std::binary_function<Fsa::Arc, Fsa::Arc, bool> {
+    struct ByInputAndTarget {
         bool operator()(const Fsa::Arc& a, const Fsa::Arc& b) const {
             return ((a.input() < b.input()) || ((a.input() == b.input()) && (a.target() < b.target())));
         }
diff --git a/src/Lattice/Lattice.hh b/src/Lattice/Lattice.hh
index 99f2f4854..299bc9a10 100644
--- a/src/Lattice/Lattice.hh
+++ b/src/Lattice/Lattice.hh
@@ -35,9 +35,11 @@ public:
                 : final(Bliss::Phoneme::term),
                   initial(Bliss::Phoneme::term) {}
         Transit(const std::pair<Bliss::Phoneme::Id, Bliss::Phoneme::Id>& transit)
-                : final(transit.first), initial(transit.second) {}
+                : final(transit.first),
+                  initial(transit.second) {}
         Transit(Bliss::Phoneme::Id _final, Bliss::Phoneme::Id _initial)
-                : final(_final), initial(_initial) {}
+                : final(_final),
+                  initial(_initial) {}
 
         bool operator==(const Transit& rhs) const {
             return final == rhs.final && initial == rhs.initial;
@@ -54,10 +56,12 @@ public:
     WordBoundary(Speech::TimeframeIndex time = Speech::InvalidTimeframeIndex)
             : time_(time) {}
     WordBoundary(Speech::TimeframeIndex time, const Transit& transit)
-            : time_(time), transit_(transit) {}
+            : time_(time),
+              transit_(transit) {}
     WordBoundary(Speech::TimeframeIndex                                   time,
                  const std::pair<Bliss::Phoneme::Id, Bliss::Phoneme::Id>& transit)
-            : time_(time), transit_(transit) {}
+            : time_(time),
+              transit_(transit) {}
 
     void setTime(Speech::TimeframeIndex time) {
         time_ = time;
@@ -244,17 +248,22 @@ public:
     void setWordBoundaries(Core::Ref<const WordBoundaries> wordBoundaries) {
         wordBoundaries_ = wordBoundaries;
     }
+
     Core::Ref<const WordBoundaries> wordBoundaries() const {
         return wordBoundaries_;
     }
+
     const WordBoundary& wordBoundary(Fsa::StateId id) const {
         return (*wordBoundaries_)[id];
     }
+
     Speech::TimeframeIndex time(Fsa::StateId id) const {
         return (*wordBoundaries_)[id].time();
     }
+
     Speech::TimeframeIndex maximumTime() const;
-    bool                   hasPart(const std::string& name) const {
+
+    bool hasPart(const std::string& name) const {
         return parts_[name] != Core::Choice::IllegalValue;
     }
 };
diff --git a/src/Lattice/Makefile b/src/Lattice/Makefile
index 569258d84..fb1a54fee 100644
--- a/src/Lattice/Makefile
+++ b/src/Lattice/Makefile
@@ -7,8 +7,7 @@ include $(TOPDIR)/Makefile.cfg
 # -----------------------------------------------------------------------------
 
 SUBDIRS 		=
-#TARGETS			= libSprintLattice.$(a) check$(exe)
-TARGETS			= libSprintLattice.$(a)
+TARGETS			= libSprintLattice.$(a) check$(exe)
 
 LIBSPRINTLATTICE_O	= \
 			  $(OBJDIR)/Archive.o \
@@ -63,7 +62,20 @@ LIBSPRINTLATTICE_O += $(OBJDIR)/HtkWriter.o
 endif
 
 ifdef MODULE_MATH_NR
-CHECK_O += ../Math/Nr/libSprintMathNr$(a)
+CHECK_O += ../Math/Nr/libSprintMathNr.$(a)
+endif
+
+ifdef MODULE_NN_SEQUENCE_TRAINING
+CHECK_O += ../Nn/libSprintNn.$(a)
+endif
+ifdef MODULE_PYTHON
+CHECK_O += ../Python/libSprintPython.$(a)
+endif
+
+ifdef MODULE_TENSORFLOW
+CHECK_O += ../Tensorflow/libSprintTensorflow.$(a)
+CXXFLAGS += $(TF_CXXFLAGS)
+LDFLAGS  += $(TF_LDFLAGS)
 endif
 
 # -----------------------------------------------------------------------------
diff --git a/src/Lattice/Merge.cc b/src/Lattice/Merge.cc
index 5e08ac483..728207f3c 100644
--- a/src/Lattice/Merge.cc
+++ b/src/Lattice/Merge.cc
@@ -67,14 +67,17 @@ struct ContextEquality {
 
 struct ArcWithContext : public Fsa::Arc {
     Context rightContext_;
-    bool    operator==(const ArcWithContext& rhs) const {
+
+    bool operator==(const ArcWithContext& rhs) const {
         return input_ == rhs.input_ && output_ == rhs.output_ && rightContext_ == rhs.rightContext_;
     }
+
     ArcWithContext(Fsa::StateId target, Fsa::Weight weight,
                    Fsa::LabelId input, Fsa::LabelId output,
                    const Context& rightContext)
             : Fsa::Arc(target, weight, input, output),
               rightContext_(rightContext) {}
+
     const Context& rightContext() const {
         return rightContext_;
     }
@@ -235,10 +238,13 @@ class MergeWordLattice : public Fsa::SlaveAutomaton {
     virtual Fsa::StateId initialStateId() const {
         return 0;
     }
+
     virtual Fsa::ConstStateRef getState(Fsa::StateId s) const;
-    virtual std::string        describe() const {
+
+    virtual std::string describe() const {
         return Core::form("merge(%s)", fsa_->describe().c_str());
     }
+
     Core::Ref<const WordBoundaries> wordBoundaries() const {
         return wordBoundaries_;
     }
@@ -345,7 +351,9 @@ class TurnOffCompetingHypothesesLattice : public ModifyWordLattice {
         InitializeCorrectHypothesesDfsState(
                 Fsa::ConstAutomatonRef fsa, Fsa::ConstMappingRef mapping,
                 CorrectHypotheses& hypotheses)
-                : Fsa::DfsState(fsa), mapping_(mapping), hypotheses_(hypotheses) {}
+                : Fsa::DfsState(fsa),
+                  mapping_(mapping),
+                  hypotheses_(hypotheses) {}
 
         virtual ~InitializeCorrectHypothesesDfsState() {}
 
diff --git a/src/Lattice/TimeframeError.cc b/src/Lattice/TimeframeError.cc
index 128dab24a..4b7628685 100644
--- a/src/Lattice/TimeframeError.cc
+++ b/src/Lattice/TimeframeError.cc
@@ -54,7 +54,8 @@ class LemmaMapping : public Mapping {
 
 public:
     LemmaMapping(const ShortPauses& shortPauses, Core::Ref<const Bliss::LemmaPronunciationAlphabet> alphabet)
-            : Mapping(shortPauses), alphabet_(alphabet) {}
+            : Mapping(shortPauses),
+              alphabet_(alphabet) {}
     virtual ~LemmaMapping() {}
 
     virtual Fsa::LabelId map(Fsa::LabelId pronId) const {
diff --git a/src/Lattice/WeightedAccumulator.hh b/src/Lattice/WeightedAccumulator.hh
index 627f9d4f6..da0611ac5 100644
--- a/src/Lattice/WeightedAccumulator.hh
+++ b/src/Lattice/WeightedAccumulator.hh
@@ -93,8 +93,8 @@ protected:
     Core::Ref<Mm::StatePosteriorFeatureScorer> posteriorFeatureScorer_;
 
 protected:
-    virtual void accumulate(Core::Ref<const Mm::Feature::Vector> f, Mm::MixtureIndex m, Mm::Weight w) {}
-    virtual void accumulate(Core::Ref<const Mm::Feature::Vector> f, const PosteriorsAndDensities& p) {}
+    virtual void accumulate(Mm::Feature::VectorRef f, Mm::MixtureIndex m, Mm::Weight w) {}
+    virtual void accumulate(Mm::Feature::VectorRef f, const PosteriorsAndDensities& p) {}
     virtual void accumulate(Core::Ref<const Sparse::Feature::SparseVector> sf, Mm::MixtureIndex m, Mm::Weight w) {}
 
 public:
@@ -102,8 +102,10 @@ public:
                                      typename Precursor::AlignmentGeneratorRef,
                                      Trainer*, Mm::Weight, Core::Ref<const Am::AcousticModel>);
     virtual ~DensityCachedAcousticAccumulator() {}
+
     virtual void finish();
-    void         setFeatureScorer(Core::Ref<Mm::StatePosteriorFeatureScorer> fs) {
+
+    void setFeatureScorer(Core::Ref<Mm::StatePosteriorFeatureScorer> fs) {
         posteriorFeatureScorer_ = fs;
     }
 };
@@ -130,8 +132,10 @@ public:
                    Trainer*, Mm::Weight,
                    Core::Ref<const Am::AcousticModel>);
     virtual ~TdpAccumulator() {}
+
     virtual void discoverState(Fsa::ConstStateRef sp);
-    void         setTransitionFeatures(Core::Ref<TransitionFeatures> transitions) {
+
+    void setTransitionFeatures(Core::Ref<TransitionFeatures> transitions) {
         transitions_ = transitions;
     }
 };
@@ -156,10 +160,13 @@ protected:
 public:
     LmAccumulator(Trainer*, Mm::Weight, Core::Ref<const Lm::LanguageModel>);
     virtual ~LmAccumulator() {}
+
     virtual void discoverState(Fsa::ConstStateRef sp);
-    void         setMgramFeatures(Core::Ref<MgramFeatures> mgrams) {
+
+    void setMgramFeatures(Core::Ref<MgramFeatures> mgrams) {
         mgrams_ = mgrams;
     }
+
     virtual void setFsa(Fsa::ConstAutomatonRef);
 };
 
diff --git a/src/Lattice/check.cc b/src/Lattice/check.cc
index 4f95f7a31..1d2959223 100644
--- a/src/Lattice/check.cc
+++ b/src/Lattice/check.cc
@@ -52,7 +52,7 @@ class TestApplication : public Application {
                 continue;
             if (it.name() == Lattice::Archive::latticeConfigFilename)
                 continue;
-            if (it.name() == Fsa::ArchiveReader::alphabetFilename)
+            if (it.name() == Fsa::Archive::paramAlphabetFilename(config))
                 continue;
             log("read \"%s\"", it.name().c_str());
             Fsa::ConstAutomatonRef f =
@@ -68,6 +68,6 @@ class TestApplication : public Application {
         delete archiveReader;
         return 0;
     }
-} app;  // <- You have to create ONE instance of the application
+};
 
-APPLICATION
+APPLICATION(TestApplication)
diff --git a/src/Lm/AbstractStateManager.hh b/src/Lm/AbstractStateManager.hh
new file mode 100644
index 000000000..d64dd0ab2
--- /dev/null
+++ b/src/Lm/AbstractStateManager.hh
@@ -0,0 +1,71 @@
+#ifndef _LM_ABSTRACT_STATE_MANAGER_HH
+#define _LM_ABSTRACT_STATE_MANAGER_HH
+
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <Core/Component.hh>
+#ifdef MODULE_LM_ONNX
+#include <Onnx/Value.hh>
+#endif
+#ifdef MODULE_LM_TFRNN
+#include <Tensorflow/Graph.hh>
+#include <Tensorflow/Tensor.hh>
+#endif
+
+#include "CompressedVector.hh"
+#ifdef MODULE_LM_ONNX
+#include <Onnx/OnnxStateVariable.hh>
+#endif
+
+namespace Lm {
+
+template<typename value_t, typename state_variable_t>
+class AbstractStateManager : public Core::Component {
+public:
+    using Precursor      = Core::Component;
+    using FeedDict       = std::vector<std::pair<std::string, value_t>>;
+    using TargetList     = std::vector<std::string>;
+    using StateVariables = std::vector<state_variable_t>;
+    using HistoryState   = std::vector<CompressedVectorPtr<float>>;
+
+    AbstractStateManager(Core::Configuration const& config);
+    virtual ~AbstractStateManager() = default;
+
+    virtual bool requiresAllParentStates() const;
+
+    virtual HistoryState initialState(StateVariables const& vars, CompressedVectorFactory<float> const& vector_factory) = 0;
+
+    virtual void mergeStates(StateVariables const&                   vars,
+                             std::vector<size_t>&                    prefix_lengths,
+                             std::vector<HistoryState const*> const& prefix_states,
+                             FeedDict&                               feed_dict,
+                             TargetList&                             targets) = 0;
+
+    virtual std::vector<HistoryState> splitStates(StateVariables const&                 vars,
+                                                  std::vector<size_t>&                  suffix_lengths,
+                                                  std::vector<value_t> const&           state_tensors,
+                                                  CompressedVectorFactory<float> const& vector_factory) = 0;
+};
+
+#ifdef MODULE_LM_ONNX
+using OnnxStateManager = AbstractStateManager<Onnx::Value, Onnx::OnnxStateVariable>;
+#endif
+#ifdef MODULE_LM_TFRNN
+using TFStateManager = AbstractStateManager<Tensorflow::Tensor, Tensorflow::Variable>;
+#endif
+
+template<typename value_t, typename state_variable_t>
+inline bool AbstractStateManager<value_t, state_variable_t>::requiresAllParentStates() const {
+    return false;
+}
+
+template<typename value_t, typename state_variable_t>
+inline AbstractStateManager<value_t, state_variable_t>::AbstractStateManager(Core::Configuration const& config)
+        : Precursor(config) {
+}
+
+}  // namespace Lm
+
+#endif  // _LM_ABSTRACT_STATE_MANAGER_HH
diff --git a/src/Lm/ClassLm.cc b/src/Lm/ClassLm.cc
index cd65d5b6c..93b425c60 100644
--- a/src/Lm/ClassLm.cc
+++ b/src/Lm/ClassLm.cc
@@ -39,12 +39,14 @@ class ClassTokenAlphabet : public Bliss::TokenAlphabet {
 
 public:
     ClassTokenAlphabet(ConstClassMappingRef mapping)
-            : Bliss::TokenAlphabet(mapping->tokenInventory()), mapping_(mapping) {}
+            : Bliss::TokenAlphabet(mapping->tokenInventory()),
+              mapping_(mapping) {}
     virtual ~ClassTokenAlphabet() {}
 };
 
 ClassMapping::ClassMapping(const Core::Configuration& config, Bliss::LexiconRef lexicon)
-        : Core::Component(config), lexicon_(lexicon) {
+        : Core::Component(config),
+          lexicon_(lexicon) {
     tokenAlphabet_ = Fsa::ConstAlphabetRef(new ClassTokenAlphabet(Core::ref(this)));
 }
 
diff --git a/src/Lm/CombineLm.cc b/src/Lm/CombineLm.cc
index ef43e0868..647cca944 100644
--- a/src/Lm/CombineLm.cc
+++ b/src/Lm/CombineLm.cc
@@ -22,7 +22,8 @@ namespace {
 class CombineHistoryManager : public Lm::HistoryManager {
 public:
     CombineHistoryManager(size_t numLms)
-            : Lm::HistoryManager(), numLms_(numLms) {
+            : Lm::HistoryManager(),
+              numLms_(numLms) {
     }
     virtual ~CombineHistoryManager() = default;
 
@@ -90,7 +91,14 @@ Core::ParameterFloat CombineLanguageModel::paramSkipThreshold(
         "skip-threshold", "if this LM's (unscaled) score is greater than this threshold successive LMs are not evaluated", std::numeric_limits<Score>::max());
 
 CombineLanguageModel::CombineLanguageModel(Core::Configuration const& c, Bliss::LexiconRef l)
-        : Core::Component(c), CombineLanguageModel::Precursor(c, l), lms_(), unscaled_lms_(), linear_combination_(paramLinearCombination(c)), lookahead_lm_(paramLookaheadLM(config)), recombination_lm_(paramRecombinationLM(config)) {
+        : Core::Component(c),
+          CombineLanguageModel::Precursor(c, l),
+          lms_(),
+          unscaled_lms_(),
+          linear_combination_(paramLinearCombination(c)),
+          lookahead_lm_(paramLookaheadLM(config)),
+          recombination_lm_(paramRecombinationLM(config)),
+          staticRequestSize_(0) {
     size_t num_lms = paramNumLms(c);
     for (size_t i = 0ul; i < num_lms; i++) {
         Core::Configuration sub_config = select(std::string("lm-") + std::to_string(i + 1));
@@ -98,6 +106,7 @@ CombineLanguageModel::CombineLanguageModel(Core::Configuration const& c, Bliss::
         unscaled_lms_.push_back(lms_.back()->unscaled());
         ssa_lms_.push_back(dynamic_cast<SearchSpaceAwareLanguageModel const*>(unscaled_lms_.back().get()));
         skip_thresholds_.push_back(paramSkipThreshold(sub_config));
+        lmIds_.push_back(i);
     }
     historyManager_ = new CombineHistoryManager(num_lms);
 }
@@ -162,48 +171,37 @@ History CombineLanguageModel::reducedHistory(History const& history, u32 limit)
     return h;
 }
 
-Score CombineLanguageModel::score(History const& history, Token w) const {
+History CombineLanguageModel::reduceHistoryByN(History const& history, u32 n) const {
+    require(history.isManagedBy(historyManager_));
+    History const* prev_hist = reinterpret_cast<History const*>(history.handle());
+    History*       new_hist  = new History[lms_.size()];
+    for (size_t i = 0ul; i < lms_.size(); i++) {
+        new_hist[i] = lms_[i]->reduceHistoryByN(prev_hist[i], n);
+    }
+    History h = this->history(new_hist);
+    delete[] new_hist;
+    return h;
+}
+
+std::string CombineLanguageModel::formatHistory(const History& h) const {
+    const History* hist = reinterpret_cast<const History*>(h.handle());
+
+    std::stringstream ss;
+    ss << "CombinedHistory<";
+    for (size_t i = 0ul; i < lms_.size(); i++) {
+        ss << " h" << i << ": " << unscaled_lms_[i]->formatHistory(hist[i]);
+    }
+    ss << " >";
+    return ss.str();
+}
+
+Score CombineLanguageModel::score(const History& history, Token w) const {
     require(history.isManagedBy(historyManager_));
-    History const* hist           = reinterpret_cast<History const*>(history.handle());
-    Score          prev_score     = 0.0;
-    bool           override_score = false;
     if (linear_combination_) {
-        Score s(std::numeric_limits<Score>::infinity());
-        for (size_t i = 0ul; i < lms_.size(); i++) {
-            Score raw_score = 0.0;
-            if (not override_score) {
-                raw_score  = unscaled_lms_[i]->score(hist[i], w);
-                prev_score = raw_score;
-                override_score |= raw_score >= skip_thresholds_[i];
-            }
-            else {
-                raw_score = prev_score;
-                if (unscaled_lms_[i]->scoreCached(history, w)) {
-                    raw_score = unscaled_lms_[i]->score(hist[i], w);
-                }
-            }
-            s = Math::scoreSum(s, raw_score - std::log(lms_[i]->scale()));
-        }
-        return s;
+        return score_<true>(history, w, lmIds_);
     }
     else {
-        Score s(0.0);
-        for (size_t i = 0ul; i < lms_.size(); i++) {
-            Score raw_score = unscaled_lms_[i]->score(hist[i], w);
-            if (not override_score) {
-                raw_score  = unscaled_lms_[i]->score(hist[i], w);
-                prev_score = raw_score;
-                override_score |= raw_score >= skip_thresholds_[i];
-            }
-            else {
-                raw_score = prev_score;
-                if (unscaled_lms_[i]->scoreCached(history, w)) {
-                    raw_score = unscaled_lms_[i]->score(hist[i], w);
-                }
-            }
-            s += raw_score * lms_[i]->scale();
-        }
-        return s;
+        return score_<false>(history, w, lmIds_);
     }
 }
 
@@ -226,6 +224,127 @@ Score CombineLanguageModel::sentenceEndScore(const History& history) const {
     }
 }
 
+void CombineLanguageModel::getBatch(const History& h, const CompiledBatchRequest* cbr, std::vector<f32>& result) const {
+    if (cacheHist_.empty() || cacheScores_.empty() || !matchCacheHistory(h)) {
+        Precursor::getBatch(h, cbr, result);
+        return;
+    }
+
+    // apply update on partial sparse LMs' tokens only, others are cached and operated in same scheme
+    require(h.isManagedBy(historyManager_));
+    const History*                 hist    = reinterpret_cast<const History*>(h.handle());
+    const NonCompiledBatchRequest* ncbr    = required_cast(const NonCompiledBatchRequest*, cbr);
+    const BatchRequest&            request = ncbr->request;
+
+    std::unordered_set<u32> tokens;
+    Score                   backoff = 0;
+    if (linear_combination_) {
+        backoff = std::numeric_limits<Score>::infinity();
+    }
+    for (u32 i = 0; i < lms_.size(); ++i) {
+        if (cacheHist_[i].isValid()) {
+            continue;
+        }
+        HistorySuccessors subSuccessors = unscaled_lms_[i]->getHistorySuccessors(hist[i]);
+        for (const WordScore& ws : subSuccessors) {
+            tokens.insert(ws.token());
+        }
+        if (linear_combination_) {
+            backoff = Math::scoreSum(backoff, subSuccessors.backOffScore - std::log(lms_[i]->scale()));
+        }
+        else {
+            backoff += subSuccessors.backOffScore * lms_[i]->scale();
+        }
+    }
+
+    // non-existing tokens' scores based on cached scores and backoff
+    verify(result.size() == cacheScores_.size());
+    if (linear_combination_) {
+        result = cacheScores_;  // assume 0-prob. here
+    }
+    else {
+        std::transform(cacheScores_.begin(), cacheScores_.end(), result.begin(), std::bind(std::plus<f32>(), std::placeholders::_1, backoff * ncbr->scale()));
+    }
+
+    // full combined score for these existing tokens (Note: further simplified to first token only)
+    for (std::unordered_set<u32>::const_iterator tokId = tokens.begin(); tokId != tokens.end(); ++tokId) {
+        std::vector<u32>& rqsts    = token2Requests_.at(*tokId);
+        Score             tokScore = score(h, request[rqsts.front()].tokens[0]) * ncbr->scale();
+        for (std::vector<u32>::const_iterator reqId = rqsts.begin(); reqId != rqsts.end(); ++reqId) {
+            const Request& r   = request[*reqId];
+            Score          sco = tokScore + r.offset;
+            if (result[r.target] > sco) {
+                result[r.target] = sco;
+            }
+        }
+    }
+}
+
+void CombineLanguageModel::cacheBatch(const History& h, const CompiledBatchRequest* cbr, u32 size) const {
+    verify(h.isValid());
+    if (linear_combination_) {
+        cacheBatch_<true>(h, cbr, size);
+    }
+    else {
+        cacheBatch_<false>(h, cbr, size);
+    }
+}
+
+bool CombineLanguageModel::fixedHistory(s32 limit) const {
+    for (u32 i = 0; i < lms_.size(); ++i) {
+        if (!unscaled_lms_[i]->fixedHistory(limit)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+bool CombineLanguageModel::isSparse(const History& h) const {
+    // combineLM itself is used for lookahead: only true if all subLMs are sparse
+    if (!h.isValid()) {
+        for (u32 i = 0; i < lms_.size(); ++i) {
+            if (!lms_[i]->isSparse(h)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    require(h.isManagedBy(historyManager_));
+    const History* hist = reinterpret_cast<const History*>(h.handle());
+    for (u32 i = 0; i < lms_.size(); ++i) {
+        if (!lms_[i]->isSparse(hist[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+
+HistorySuccessors CombineLanguageModel::getHistorySuccessors(const History& h) const {
+    if (linear_combination_) {
+        return getCombinedHistorySuccessors<true>(h);
+    }
+    else {
+        return getCombinedHistorySuccessors<false>(h);
+    }
+}
+
+Score CombineLanguageModel::getBackOffScore(const History& h) const {
+    require(h.isManagedBy(historyManager_));
+    const History* hist    = reinterpret_cast<const History*>(h.handle());
+    Score          backoff = linear_combination_ ? std::numeric_limits<Score>::infinity() : 0;
+
+    for (u32 i = 0; i < lms_.size(); ++i) {
+        if (linear_combination_) {
+            backoff = Math::scoreSum(backoff, unscaled_lms_[i]->getBackOffScore(hist[i]) - std::log(lms_[i]->scale()));
+        }
+        else {
+            backoff += unscaled_lms_[i]->getBackOffScore(hist[i]) * lms_[i]->scale();
+        }
+    }
+    return backoff;
+}
+
 Core::Ref<const LanguageModel> CombineLanguageModel::lookaheadLanguageModel() const {
     if (lookahead_lm_ > 0) {
         require_le(static_cast<unsigned>(lookahead_lm_), unscaled_lms_.size());
@@ -265,4 +384,202 @@ void CombineLanguageModel::setInfo(History const& hist, SearchSpaceInformation c
     }
 }
 
+// combine sparse scores with closest behavior as actual scoring
+// one HistorySuccessors for each subLM where tokens are not requested to be the same
+// combined HistorySuccessors is a super-set of all sub HistorySuccessors with score combined
+// in the same way as scoring (use backoff score if a token does not exist)
+// TODO test efficiency and maybe improve
+template<bool linear>
+HistorySuccessors CombineLanguageModel::getCombinedHistorySuccessors(const History& h) const {
+    require(h.isManagedBy(historyManager_));
+    const History* hist = reinterpret_cast<const History*>(h.handle());
+
+    TokenScoreMap              combineSuccessors;
+    std::set<Bliss::Token::Id> combineTokens;
+    Score                      backoff = 0;
+    if (linear) {
+        backoff = std::numeric_limits<Score>::infinity();
+    }
+
+    for (u32 i = 0; i < lms_.size(); ++i) {
+        HistorySuccessors          subSuccessors = unscaled_lms_[i]->getHistorySuccessors(hist[i]);
+        std::set<Bliss::Token::Id> subTokens;
+        for (const WordScore& ws : subSuccessors) {
+            subTokens.insert(ws.token());
+            TokenScoreMap::iterator iter = combineSuccessors.insert(std::make_pair(ws.token(), backoff)).first;
+            if (linear) {
+                iter->second = Math::scoreSum(iter->second, ws.score() - std::log(lms_[i]->scale()));
+            }
+            else {
+                iter->second += ws.score() * lms_[i]->scale();
+            }
+        }
+
+        if (combineTokens.empty()) {
+            combineTokens.swap(subTokens);
+        }
+        else if (subTokens.empty()) {
+            for (TokenScoreMap::iterator iter = combineSuccessors.begin(); iter != combineSuccessors.end(); ++iter) {
+                if (linear) {
+                    iter->second = Math::scoreSum(iter->second, subSuccessors.backOffScore - std::log(lms_[i]->scale()));
+                }
+                else {
+                    iter->second += subSuccessors.backOffScore * lms_[i]->scale();
+                }
+            }
+        }
+        else {
+            std::set<Bliss::Token::Id> missTokens;
+            std::set_difference(combineTokens.begin(), combineTokens.end(), subTokens.begin(), subTokens.end(), std::inserter(missTokens, missTokens.begin()));
+            for (std::set<Bliss::Token::Id>::const_iterator it = missTokens.begin(); it != missTokens.end(); ++it) {
+                Score& s = combineSuccessors[*it];
+                if (linear) {
+                    s = Math::scoreSum(s, subSuccessors.backOffScore - std::log(lms_[i]->scale()));
+                }
+                else {
+                    s += subSuccessors.backOffScore * lms_[i]->scale();
+                }
+            }
+            if (subTokens.size() > missTokens.size()) {
+                subTokens.insert(missTokens.begin(), missTokens.end());
+                combineTokens.swap(subTokens);
+            }
+            else {
+                missTokens.insert(subTokens.begin(), subTokens.end());
+                combineTokens.swap(missTokens);
+            }
+        }
+
+        if (linear) {
+            backoff = Math::scoreSum(backoff, subSuccessors.backOffScore - std::log(lms_[i]->scale()));
+        }
+        else {
+            backoff += subSuccessors.backOffScore * lms_[i]->scale();
+        }
+    }
+
+    HistorySuccessors res;
+    res.backOffScore = backoff;
+    res.reserve(combineSuccessors.size());
+    for (TokenScoreMap::const_iterator iter = combineSuccessors.begin(); iter != combineSuccessors.end(); ++iter) {
+        res.emplace_back(iter->first, iter->second);
+    }
+    return res;
+}
+
+template<bool linear>
+Score CombineLanguageModel::score_(const History& history, Token w, const std::vector<u32>& lmIds) const {
+    History const* hist = reinterpret_cast<History const*>(history.handle());
+
+    Score prev_score     = 0.0;
+    bool  override_score = false;
+    Score comb_score     = linear ? std::numeric_limits<Score>::infinity() : 0.0;
+
+    for (std::vector<u32>::const_iterator it = lmIds.begin(); it != lmIds.end(); ++it) {
+        Score raw_score = 0.0;
+        if (!override_score) {
+            raw_score  = unscaled_lms_[*it]->score(hist[*it], w);
+            prev_score = raw_score;
+            override_score |= raw_score >= skip_thresholds_[*it];
+        }
+        else {
+            raw_score = prev_score;
+            if (unscaled_lms_[*it]->scoreCached(history, w)) {
+                raw_score = unscaled_lms_[*it]->score(hist[*it], w);
+            }
+        }
+        if (linear) {
+            comb_score = Math::scoreSum(comb_score, raw_score - std::log(lms_[*it]->scale()));
+        }
+        else {
+            comb_score += raw_score * lms_[*it]->scale();
+        }
+    }
+    return comb_score;
+}
+
+template<bool linear>
+void CombineLanguageModel::cacheBatch_(const History& h, const CompiledBatchRequest* cbr, u32 size) const {
+    cacheHist_.clear();
+    cacheScores_.clear();
+    verify(matchCacheHistory(h));
+    // partial non-sparse LMs to be cached
+    std::vector<u32> cacheLmIds;
+    for (u32 i = 0; i < lms_.size(); ++i) {
+        if (cacheHist_[i].isValid()) {
+            cacheLmIds.push_back(i);
+        }
+    }
+    if (cacheLmIds.empty() || cacheLmIds.size() == lms_.size()) {
+        cacheHist_.clear();
+        return;
+    }
+
+    // cached LMs combined scoring + token to request mapping
+    const NonCompiledBatchRequest* ncbr    = required_cast(const NonCompiledBatchRequest*, cbr);
+    const BatchRequest&            request = ncbr->request;
+    cacheScores_.resize(size, Core::Type<Score>::max);
+
+    u32 startIdx = 0;
+    if (token2Requests_.empty() && staticToken2Requests_.empty()) {
+        staticRequestSize_ = request.size();
+    }
+    else if (!staticToken2Requests_.empty()) {
+        verify(staticRequestSize_ > 0 && request.size() >= staticRequestSize_);
+        token2Requests_ = staticToken2Requests_;
+        startIdx        = staticRequestSize_;
+    }
+    token2Requests_.resize(lexicon()->nSyntacticTokens());
+
+    for (u32 idx = 0; idx < request.size(); ++idx) {
+        const Request& r   = request[idx];
+        Score          sco = 0.0;
+        if (r.tokens.length() >= 1) {
+            // first token only: mostly should be just single mapping
+            if (idx >= startIdx) {
+                token2Requests_.at(r.tokens[0]->id()).push_back(idx);
+            }
+            sco += score_<linear>(h, r.tokens[0], cacheLmIds);
+            if (r.tokens.length() > 1) {
+                History hh = extendedHistory(h, r.tokens[0]);
+                for (u32 ti = 1;; ++ti) {
+                    Token st = r.tokens[ti];
+                    sco += score_<linear>(hh, st, cacheLmIds);
+                    if (ti + 1 >= r.tokens.length()) {
+                        break;
+                    }
+                    hh = extendedHistory(hh, st);
+                }
+            }
+        }
+        sco *= ncbr->scale();
+        sco += r.offset;
+        if (cacheScores_[r.target] > sco) {
+            cacheScores_[r.target] = sco;
+        }
+    }
+}
+
+bool CombineLanguageModel::matchCacheHistory(const History& h) const {
+    const History* hist = reinterpret_cast<const History*>(h.handle());
+    if (cacheHist_.empty()) {
+        for (u32 i = 0; i < lms_.size(); ++i) {
+            if (unscaled_lms_[i]->isSparse(hist[i])) {
+                cacheHist_.emplace_back();
+            }
+            else {
+                cacheHist_.emplace_back(hist[i]);
+            }
+        }
+    }
+    else {
+        for (u32 i = 0; i < lms_.size(); ++i) {
+            if (!unscaled_lms_[i]->isSparse(hist[i]) && !(hist[i] == cacheHist_[i])) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
 }  // namespace Lm
diff --git a/src/Lm/CombineLm.hh b/src/Lm/CombineLm.hh
index 48e100c3f..02bed9817 100644
--- a/src/Lm/CombineLm.hh
+++ b/src/Lm/CombineLm.hh
@@ -41,18 +41,45 @@ public:
     virtual Lm::Score sentenceBeginScore() const;
     virtual void      getDependencies(Core::DependencySet& dependencies) const;
 
-    virtual History                        startHistory() const;
-    virtual History                        extendedHistory(History const& history, Token w) const;
-    virtual History                        reducedHistory(History const& history, u32 limit) const;
-    virtual Score                          score(History const& history, Token w) const;
-    virtual Score                          sentenceEndScore(const History& history) const;
+    virtual History     startHistory() const;
+    virtual History     extendedHistory(History const& history, Token w) const;
+    virtual History     reducedHistory(History const& history, u32 limit) const;
+    virtual History     reduceHistoryByN(History const&, u32 n) const;
+    virtual std::string formatHistory(const History&) const;
+    virtual Score       score(const History& history, Token w) const;
+    virtual Score       sentenceEndScore(const History& history) const;
+
+    virtual void getBatch(const History& h, const CompiledBatchRequest* cbr, std::vector<f32>& result) const;
+    virtual void cacheBatch(const History& h, const CompiledBatchRequest* cbr, u32 size) const;
+
+    virtual bool              fixedHistory(s32 limit) const;
+    virtual bool              isSparse(const History& h) const;
+    virtual HistorySuccessors getHistorySuccessors(const History& h) const;
+    virtual Score             getBackOffScore(const History& h) const;
+
     virtual Core::Ref<const LanguageModel> lookaheadLanguageModel() const;
     virtual Core::Ref<const LanguageModel> recombinationLanguageModel() const;
-    virtual void                           setSegment(Bliss::SpeechSegment const* s);
+
+    virtual void setSegment(Bliss::SpeechSegment const* s);
 
     virtual void startFrame(Search::TimeframeIndex time) const;
     virtual void setInfo(History const& hist, SearchSpaceInformation const& info) const;
 
+protected:
+    typedef std::unordered_map<Bliss::Token::Id, Score> TokenScoreMap;
+
+    template<bool linear>
+    HistorySuccessors getCombinedHistorySuccessors(const History& h) const;
+
+    // also support partial LMs combined scoring
+    template<bool linear>
+    Score score_(const History& h, Token w, const std::vector<u32>& lmIds) const;
+
+    template<bool linear>
+    void cacheBatch_(const History& h, const CompiledBatchRequest* cbr, u32 size) const;
+
+    bool matchCacheHistory(const History& h) const;
+
 private:
     std::vector<Core::Ref<ScaledLanguageModel>>       lms_;
     std::vector<Core::Ref<const LanguageModel>>       unscaled_lms_;
@@ -62,6 +89,20 @@ private:
     bool linear_combination_;
     int  lookahead_lm_;
     int  recombination_lm_;
+
+    std::vector<u32> lmIds_;
+
+    // cached scores for partial sparse lookahead (so far only single history cache: unigram)
+    mutable std::vector<History> cacheHist_;
+    mutable std::vector<Score>   cacheScores_;
+    // lexicon tokenId to requests mapping
+    mutable std::vector<std::vector<u32>> token2Requests_;
+
+    mutable u32 staticRequestSize_;
+
+    std::vector<History>          staticCacheHist_;
+    std::vector<Score>            staticCacheScores_;
+    std::vector<std::vector<u32>> staticToken2Requests_;
 };
 
 }  // namespace Lm
diff --git a/src/Lm/Compose.cc b/src/Lm/Compose.cc
index d622bdb66..8c148d29b 100644
--- a/src/Lm/Compose.cc
+++ b/src/Lm/Compose.cc
@@ -35,7 +35,8 @@ class ComposeAutomaton : public Lm::ComposeAutomaton {
         Lm::History  right;
 
         State(Fsa::StateId ll, Lm::History rr)
-                : left(ll), right(rr) {}
+                : left(ll),
+                  right(rr) {}
 
         struct Hash {
             size_t operator()(const State& st) const {
@@ -67,7 +68,10 @@ class ComposeAutomaton : public Lm::ComposeAutomaton {
             Fsa::ConstAutomatonRef             left,
             Core::Ref<const Lm::LanguageModel> right,
             Score lmScale, Score syntaxEmissionScale)
-            : left_(left), right_(right), lmScale_(lmScale), syntaxEmissionScale_(syntaxEmissionScale) {
+            : left_(left),
+              right_(right),
+              lmScale_(lmScale),
+              syntaxEmissionScale_(syntaxEmissionScale) {
         setProperties(Fsa::PropertyStorage | Fsa::PropertyCached, 0);
         setProperties(Fsa::PropertyAcyclic, Fsa::hasProperties(left_, Fsa::PropertyAcyclic));
     }
diff --git a/src/Lm/FixedQuantizationCompressedVectorFactory.hh b/src/Lm/FixedQuantizationCompressedVectorFactory.hh
index cf36cc20e..d7939fb83 100644
--- a/src/Lm/FixedQuantizationCompressedVectorFactory.hh
+++ b/src/Lm/FixedQuantizationCompressedVectorFactory.hh
@@ -178,7 +178,9 @@ std::vector<T> const& QuantizedFloatVectorFixedBits<T>::data() const {
 }
 
 inline FixedQuantizationCompressedVectorFactory::FixedQuantizationCompressedVectorFactory(Core::Configuration const& config)
-        : Precursor(config), bits_per_val_(paramBitsPerVal(config)), epsilon_(paramEpsilon(config)) {
+        : Precursor(config),
+          bits_per_val_(paramBitsPerVal(config)),
+          epsilon_(paramEpsilon(config)) {
     switch (bits_per_val_) {
         case 8:
         case 16:
diff --git a/src/Lm/IndexMap.hh b/src/Lm/IndexMap.hh
index a9b33c322..5af27f70f 100644
--- a/src/Lm/IndexMap.hh
+++ b/src/Lm/IndexMap.hh
@@ -42,7 +42,8 @@ protected:
     void               initializeMapping(InternalClassIndex nInternalClasses);
     InternalClassIndex newClass();
     void               mapToken(Token, InternalClassIndex idx);
-    bool               isTokenMapped(Token t) const {
+
+    bool isTokenMapped(Token t) const {
         return tokenMap_[t] != invalidClass;
     }
     void finalizeMapping();
diff --git a/src/Lm/LanguageModel.cc b/src/Lm/LanguageModel.cc
index 38c515eda..40fcee21b 100644
--- a/src/Lm/LanguageModel.cc
+++ b/src/Lm/LanguageModel.cc
@@ -200,8 +200,9 @@ void LanguageModel::getBatch(const History& history, const CompiledBatchRequest*
         sco *= ncbr->scale();
         sco += r->offset;
 
-        if (result[r->target] > sco)
+        if (result[r->target] > sco) {
             result[r->target] = sco;
+        }
     }
 }
 
diff --git a/src/Lm/LanguageModel.hh b/src/Lm/LanguageModel.hh
index 3ce99d236..1e652521a 100644
--- a/src/Lm/LanguageModel.hh
+++ b/src/Lm/LanguageModel.hh
@@ -184,7 +184,9 @@ struct Request {
     Score                         offset;
     Request() {}
     Request(const Bliss::SyntacticTokenSequence& s, u32 t, Score o = 0.0)
-            : tokens(s), target(t), offset(o) {}
+            : tokens(s),
+              target(t),
+              offset(o) {}
 };
 typedef std::vector<Request> BatchRequest;
 
diff --git a/src/Lm/LstmStateManager.hh b/src/Lm/LstmStateManager.hh
index 1ff448538..087c6b1df 100644
--- a/src/Lm/LstmStateManager.hh
+++ b/src/Lm/LstmStateManager.hh
@@ -15,35 +15,127 @@
 #ifndef _LM_LSTM_STATE_MANAGER_HH
 #define _LM_LSTM_STATE_MANAGER_HH
 
-#include "StateManager.hh"
+#include "AbstractStateManager.hh"
+#include "CompressedVector.hh"
 
 namespace Lm {
 
-class LstmStateManager : public StateManager {
+template<typename value_t, typename state_variable_t>
+class LstmStateManager : public AbstractStateManager<value_t, state_variable_t> {
 public:
-    using Precursor = StateManager;
+    using Precursor = AbstractStateManager<value_t, state_variable_t>;
 
     LstmStateManager(Core::Configuration const& config);
     virtual ~LstmStateManager() = default;
 
-    virtual HistoryState              initialState(StateVariables const& vars, CompressedVectorFactory<float> const& vector_factory);
-    virtual void                      mergeStates(StateVariables const&                   vars,
-                                                  std::vector<size_t>&                    prefix_lengths,
-                                                  std::vector<HistoryState const*> const& prefix_states,
-                                                  FeedDict&                               feed_dict,
-                                                  TargetList&                             targets);
-    virtual std::vector<HistoryState> splitStates(StateVariables const&                  vars,
-                                                  std::vector<size_t>&                   suffix_lengths,
-                                                  std::vector<Tensorflow::Tensor> const& state_tensors,
-                                                  CompressedVectorFactory<float> const&  vector_factory);
-};
+    virtual typename Precursor::HistoryState initialState(typename Precursor::StateVariables const& vars, CompressedVectorFactory<float> const& vector_factory);
+
+    virtual void mergeStates(typename Precursor::StateVariables const&                   vars,
+                             std::vector<size_t>&                                        prefix_lengths,
+                             std::vector<typename Precursor::HistoryState const*> const& prefix_states,
+                             typename Precursor::FeedDict&                               feed_dict,
+                             typename Precursor::TargetList&                             targets);
+
+    virtual std::vector<typename Precursor::HistoryState> splitStates(
+            typename Precursor::StateVariables const& vars,
+            std::vector<size_t>&                      suffix_lengths,
+            std::vector<value_t> const&               state_tensors,
+            CompressedVectorFactory<float> const&     vector_factory);
 
-// inline implementations
+protected:
+    virtual void extendFeedDict(typename Precursor::FeedDict& feed_dict, state_variable_t const& state_var, value_t& var) = 0;
+    virtual void extendTargets(typename Precursor::TargetList& targets, state_variable_t const& state_var)                = 0;
+};
 
-inline LstmStateManager::LstmStateManager(Core::Configuration const& config)
+template<typename value_t, typename state_variable_t>
+LstmStateManager<value_t, state_variable_t>::LstmStateManager(Core::Configuration const& config)
         : Precursor(config) {
 }
 
+template<typename value_t, typename state_variable_t>
+typename LstmStateManager<value_t, state_variable_t>::Precursor::HistoryState LstmStateManager<value_t, state_variable_t>::initialState(
+        typename Precursor::StateVariables const& vars,
+        CompressedVectorFactory<float> const&     vector_factory) {
+    typename Precursor::HistoryState result;
+    result.reserve(vars.size());
+
+    for (auto const& var : vars) {
+        require_gt(var.shape.size(), 0ul);
+        s64 state_size = var.shape.back();
+        require_ge(state_size, 0);  // variable must not be of unknown size
+        std::vector<float> vec(state_size, 0.0f);
+        auto               compression_param_estimator = vector_factory.getEstimator();
+        compression_param_estimator->accumulate(vec.data(), vec.size());
+        auto compression_params = compression_param_estimator->estimate();
+        result.emplace_back(vector_factory.compress(vec.data(), vec.size(), compression_params.get()));
+    }
+
+    return result;
+}
+
+template<typename value_t, typename state_variable_t>
+void LstmStateManager<value_t, state_variable_t>::mergeStates(
+        typename LstmStateManager<value_t, state_variable_t>::Precursor::StateVariables const&                   vars,
+        std::vector<size_t>&                                                                                     prefix_lengths,
+        std::vector<typename LstmStateManager<value_t, state_variable_t>::Precursor::HistoryState const*> const& prefix_states,
+        typename LstmStateManager<value_t, state_variable_t>::Precursor::FeedDict&                               feed_dict,
+        typename LstmStateManager<value_t, state_variable_t>::Precursor::TargetList&                             targets) {
+    require_eq(prefix_states.size(), prefix_lengths.size());
+    feed_dict.reserve(vars.size());
+    targets.reserve(vars.size());
+
+    s64 batch_size = prefix_lengths.size();
+
+    for (size_t v = 0ul; v < vars.size(); v++) {
+        s64     state_size = prefix_states.front()->at(v)->size();
+        value_t var_tensor = value_t::template zeros<float>({batch_size, state_size});
+        float*  data       = var_tensor.template data<f32>();
+
+        for (size_t b = 0ul; b < static_cast<size_t>(batch_size); b++) {
+            auto const& compressed_state = prefix_states[b]->at(v);
+            require_eq(compressed_state->size(), static_cast<size_t>(state_size));
+            compressed_state->uncompress(data + b * state_size, state_size);
+        }
+
+        extendFeedDict(feed_dict, vars[v], var_tensor);
+        extendTargets(targets, vars[v]);
+    }
+}
+
+template<typename value_t, typename state_variable_t>
+std::vector<typename LstmStateManager<value_t, state_variable_t>::Precursor::HistoryState> LstmStateManager<value_t, state_variable_t>::splitStates(
+        typename LstmStateManager<value_t, state_variable_t>::Precursor::StateVariables const& vars,
+        std::vector<size_t>&                                                                   suffix_lengths,
+        std::vector<value_t> const&                                                            state_tensors,
+        CompressedVectorFactory<float> const&                                                  vector_factory) {
+    require_eq(vars.size(), state_tensors.size());
+
+    std::vector<typename Precursor::HistoryState> result(suffix_lengths.size());
+
+    for (size_t r = 0ul; r < suffix_lengths.size(); r++) {
+        result[r].reserve(vars.size());
+        suffix_lengths[r] = 1ul;
+    }
+
+    for (size_t v = 0ul; v < vars.size(); v++) {
+        value_t const& tensor = state_tensors[v];
+        require_eq(tensor.numDims(), 2);
+        size_t batch_size = tensor.dimSize(0);
+        size_t state_size = tensor.dimSize(1);
+        require_eq(batch_size, suffix_lengths.size());
+
+        for (size_t b = 0ul; b < batch_size; b++) {
+            auto         compression_param_estimator = vector_factory.getEstimator();
+            float const* data                        = tensor.template data<f32>(b, 0);
+            compression_param_estimator->accumulate(data, state_size);
+            auto compression_params = compression_param_estimator->estimate();
+            result[b].emplace_back(vector_factory.compress(data, state_size, compression_params.get()).release());
+        }
+    }
+
+    return result;
+}
+
 }  // namespace Lm
 
 #endif  // _LM_LSTM_STATE_MANAGER_HH
diff --git a/src/Lm/Makefile b/src/Lm/Makefile
index 861ead682..9602d5765 100644
--- a/src/Lm/Makefile
+++ b/src/Lm/Makefile
@@ -15,46 +15,58 @@ LIBSPRINTLM_O	= \
 		$(OBJDIR)/ClassLm.o \
 		$(OBJDIR)/CombineLm.o \
 		$(OBJDIR)/Compose.o \
+		$(OBJDIR)/CompressedVector.o \
 		$(OBJDIR)/CorpusStatistics.o \
+		$(OBJDIR)/FixedQuantizationCompressedVectorFactory.o \
 		$(OBJDIR)/IndexMap.o \
 		$(OBJDIR)/LanguageModel.o \
 		$(OBJDIR)/Module.o \
 		$(OBJDIR)/NNHistoryManager.o \
+		$(OBJDIR)/QuantizedCompressedVectorFactory.o \
+		$(OBJDIR)/RecurrentLanguageModel.o \
+		$(OBJDIR)/ReducedPrecisionCompressedVectorFactory.o \
 		$(OBJDIR)/ReverseArpaLm.o \
 		$(OBJDIR)/ScaledLanguageModel.o \
 		$(OBJDIR)/WordlistInterface.o
 
+#MODF AbstractStateManager.hh
+#MODF DummyCompressedVectorFactory.hh
 
 ifdef MODULE_LM_ARPA
 LIBSPRINTLM_O += $(OBJDIR)/ArpaLm.o
 endif
+
 ifdef MODULE_LM_FSA
 LIBSPRINTLM_O += $(OBJDIR)/FsaLm.o
 LIBSPRINTLM_O += $(OBJDIR)/CheatingSegmentLm.o
 endif
+
 ifdef MODULE_LM_ZEROGRAM
 LIBSPRINTLM_O += $(OBJDIR)/Zerogram.o
 endif
 ifdef MODULE_LM_TFRNN
-LIBSPRINTLM_O += $(OBJDIR)/BlasNceSoftmaxAdapter.o
-LIBSPRINTLM_O += $(OBJDIR)/CompressedVector.o
-LIBSPRINTLM_O += $(OBJDIR)/FixedQuantizationCompressedVectorFactory.o
-LIBSPRINTLM_O += $(OBJDIR)/LstmStateManager.o
-LIBSPRINTLM_O += $(OBJDIR)/NceSoftmaxAdapter.o
-LIBSPRINTLM_O += $(OBJDIR)/PassthroughSoftmaxAdapter.o
-LIBSPRINTLM_O += $(OBJDIR)/QuantizedBlasNceSoftmaxAdapter.o
-LIBSPRINTLM_O += $(OBJDIR)/QuantizedCompressedVectorFactory.o
-LIBSPRINTLM_O += $(OBJDIR)/ReducedPrecisionCompressedVectorFactory.o
-LIBSPRINTLM_O += $(OBJDIR)/TransformerStateManager.o
+LIBSPRINTLM_O += $(OBJDIR)/TFBlasNceSoftmaxAdapter.o
+LIBSPRINTLM_O += $(OBJDIR)/TFLstmStateManager.o
+LIBSPRINTLM_O += $(OBJDIR)/TFNceSoftmaxAdapter.o
+LIBSPRINTLM_O += $(OBJDIR)/TFPassthroughSoftmaxAdapter.o
+LIBSPRINTLM_O += $(OBJDIR)/TFQuantizedBlasNceSoftmaxAdapter.o
 LIBSPRINTLM_O += $(OBJDIR)/TFRecurrentLanguageModel.o
-#MODF DummyCompressedVectorFactory.hh
-#MODF SoftmaxAdapter.hh
-#MODF StateManager.hh
+LIBSPRINTLM_O += $(OBJDIR)/TFTransformerStateManager.o
+#MODF TFSoftmaxAdapter.hh
 
 CXXFLAGS += $(TF_CXXFLAGS)
 LDFLAGS  += $(TF_LDFLAGS)
 endif
 
+ifdef MODULE_LM_ONNX
+LIBSPRINTLM_O += $(OBJDIR)/OnnxLstmStateManager.o
+LIBSPRINTLM_O += $(OBJDIR)/OnnxPassthroughSoftmaxAdapter.o
+LIBSPRINTLM_O += $(OBJDIR)/OnnxNceSoftmaxAdapter.o
+LIBSPRINTLM_O += $(OBJDIR)/OnnxRecurrentLanguageModel.o
+#MODF OnnxStateVariable.hh
+#MODF OnnxSoftmaxAdapter.hh
+endif
+
 CHECK_O		= $(OBJDIR)/check.o			\
 		  ../Flf/libSprintFlf.$(a) \
 		  ../Flf/FlfCore/libSprintFlfCore.$(a) \
@@ -63,7 +75,6 @@ CHECK_O		= $(OBJDIR)/check.o			\
 		  ../Mc/libSprintMc.$(a) \
 		  ../Bliss/libSprintBliss.$(a) \
 		  ../Nn/libSprintNn.$(a) \
-		  ../Me/libSprintMe.$(a) \
 		  ../Mm/libSprintMm.$(a) \
 		  ../Signal/libSprintSignal.$(a) \
 		  ../Flow/libSprintFlow.$(a) \
@@ -79,15 +90,24 @@ CHECK_O += ../Core/libSprintCore.$(a)
 ifdef MODULE_CART
 CHECK_O += ../Cart/libSprintCart.$(a)
 endif
+ifdef MODULE_FLF_EXT
+CHECK_O += ../Flf/FlfExt/libSprintFlfExt.$(a)
+endif
 ifdef MODULE_MATH_NR
 CHECK_O += ../Math/Nr/libSprintMathNr.$(a)
 endif
 ifdef MODULE_PYTHON
 CHECK_O += ../Python/libSprintPython.$(a)
 endif
+ifdef MODULE_FLF_EXT
+CHECK_O 	+= ../Flf/FlfExt/libSprintFlfExt.$(a)
+endif
 ifdef MODULE_LM_TFRNN
 CHECK_O += ../Tensorflow/libSprintTensorflow.$(a)
 endif
+ifdef MODULE_LM_ONNX
+CHECK_O += ../Onnx/libSprintOnnx.$(a)
+endif
 
 # -----------------------------------------------------------------------------
 
diff --git a/src/Lm/Module.cc b/src/Lm/Module.cc
index 1862c9ad4..877fa99f3 100644
--- a/src/Lm/Module.cc
+++ b/src/Lm/Module.cc
@@ -13,9 +13,17 @@
  *  limitations under the License.
  */
 #include "Module.hh"
+
 #include <Core/Application.hh>
 #include <Modules.hh>
 #include "ClassLm.hh"
+#include "CombineLm.hh"
+#include "DummyCompressedVectorFactory.hh"
+#include "FixedQuantizationCompressedVectorFactory.hh"
+#include "QuantizedCompressedVectorFactory.hh"
+#include "ReducedPrecisionCompressedVectorFactory.hh"
+#include "SimpleHistoryLm.hh"
+
 #ifdef MODULE_LM_ARPA
 #include "ArpaLm.hh"
 #endif
@@ -29,17 +37,10 @@
 #ifdef MODULE_LM_TFRNN
 #include "TFRecurrentLanguageModel.hh"
 #endif
-#include "CombineLm.hh"
-
-#ifdef MODULE_LM_TFRNN
-#include "DummyCompressedVectorFactory.hh"
-#include "FixedQuantizationCompressedVectorFactory.hh"
-#include "QuantizedCompressedVectorFactory.hh"
-#include "ReducedPrecisionCompressedVectorFactory.hh"
+#ifdef MODULE_LM_ONNX
+#include "OnnxRecurrentLanguageModel.hh"
 #endif
 
-#include "SimpleHistoryLm.hh"
-
 using namespace Lm;
 
 namespace Lm {
@@ -50,10 +51,11 @@ enum LanguageModelType {
     lmTypeZerogram,
     lmTypeCombine,
     lmTypeTFRNN,
+    lmTypeOnnx,
     lmTypeCheatingSegment,
     lmTypeSimpleHistory
 };
-}
+}  // namespace Lm
 
 const Core::Choice Module_::lmTypeChoice(
         "ARPA", lmTypeArpa,
@@ -62,6 +64,7 @@ const Core::Choice Module_::lmTypeChoice(
         "zerogram", lmTypeZerogram,
         "combine", lmTypeCombine,
         "tfrnn", lmTypeTFRNN,
+        "onnx", lmTypeOnnx,
         "cheating-segment", lmTypeCheatingSegment,
         "simple-history", lmTypeSimpleHistory,
         Core::Choice::endMark());
@@ -89,6 +92,9 @@ Core::Ref<LanguageModel> Module_::createLanguageModel(
         case lmTypeCombine: result = Core::ref(new CombineLanguageModel(c, l)); break;
 #ifdef MODULE_LM_TFRNN
         case lmTypeTFRNN: result = Core::ref(new TFRecurrentLanguageModel(c, l)); break;
+#endif
+#ifdef MODULE_LM_ONNX
+        case lmTypeOnnx: result = Core::ref(new OnnxRecurrentLanguageModel(c, l)); break;
 #endif
         case lmTypeSimpleHistory: result = Core::ref(new SimpleHistoryLm(c, l)); break;
         default:
@@ -105,7 +111,6 @@ Core::Ref<ScaledLanguageModel> Module_::createScaledLanguageModel(
     return languageModel ? Core::Ref<ScaledLanguageModel>(new LanguageModelScaling(c, languageModel)) : Core::Ref<ScaledLanguageModel>();
 }
 
-#ifdef MODULE_LM_TFRNN
 enum CompressedVectorFactoryType {
     DummyCompressedVectorFactoryType,
     FixedQuantizationCompressedVectorFactoryType,
@@ -134,5 +139,3 @@ Lm::CompressedVectorFactoryPtr<float> Module_::createCompressedVectorFactory(Cor
         default: defect();
     }
 }
-
-#endif
diff --git a/src/Lm/Module.hh b/src/Lm/Module.hh
index 053e583f6..a9c3243fa 100644
--- a/src/Lm/Module.hh
+++ b/src/Lm/Module.hh
@@ -16,12 +16,10 @@
 #define _LM_MODULE_HH
 
 #include <Core/Singleton.hh>
-#include "LanguageModel.hh"
-#include "ScaledLanguageModel.hh"
 
-#ifdef MODULE_LM_TFRNN
 #include "CompressedVector.hh"
-#endif
+#include "LanguageModel.hh"
+#include "ScaledLanguageModel.hh"
 
 namespace Lm {
 
@@ -30,10 +28,9 @@ private:
     static const Core::Choice          lmTypeChoice;
     static const Core::ParameterChoice lmTypeParam;
 
-#ifdef MODULE_LM_TFRNN
     static const Core::Choice          compressedVectorFactoryTypeChoice;
     static const Core::ParameterChoice compressedVectorFactoryTypeParam;
-#endif
+
 public:
     Module_() {}
 
@@ -65,9 +62,7 @@ public:
         return createScaledLanguageModel(c, createLanguageModel(c, l));
     }
 
-#ifdef MODULE_LM_TFRNN
     Lm::CompressedVectorFactoryPtr<float> createCompressedVectorFactory(Core::Configuration const& config);
-#endif
 };
 
 typedef Core::SingletonHolder<Module_> Module;
diff --git a/src/Lm/OnnxLstmStateManager.cc b/src/Lm/OnnxLstmStateManager.cc
new file mode 100644
index 000000000..40db31091
--- /dev/null
+++ b/src/Lm/OnnxLstmStateManager.cc
@@ -0,0 +1,13 @@
+#include "OnnxLstmStateManager.hh"
+
+namespace Lm {
+
+void OnnxLstmStateManager::extendFeedDict(FeedDict& feed_dict, Onnx::OnnxStateVariable const& state_var, Onnx::Value& var) {
+    feed_dict.emplace_back(state_var.input_state_key, std::move(var));
+}
+
+void OnnxLstmStateManager::extendTargets(TargetList& targets, Onnx::OnnxStateVariable const& state_var) {
+    targets.emplace_back(state_var.output_state_key);
+}
+
+}  // namespace Lm
diff --git a/src/Lm/OnnxLstmStateManager.hh b/src/Lm/OnnxLstmStateManager.hh
new file mode 100644
index 000000000..a3b81a793
--- /dev/null
+++ b/src/Lm/OnnxLstmStateManager.hh
@@ -0,0 +1,31 @@
+#ifndef _LM_ONNX_LSTM_STATE_MANAGER_HH
+#define _LM_ONNX_LSTM_STATE_MANAGER_HH
+
+#include <Onnx/OnnxStateVariable.hh>
+#include <Onnx/Value.hh>
+
+#include "LstmStateManager.hh"
+
+namespace Lm {
+
+class OnnxLstmStateManager : public LstmStateManager<Onnx::Value, Onnx::OnnxStateVariable> {
+public:
+    using Precursor = LstmStateManager<Onnx::Value, Onnx::OnnxStateVariable>;
+
+    OnnxLstmStateManager(Core::Configuration const& config);
+    virtual ~OnnxLstmStateManager() = default;
+
+protected:
+    virtual void extendFeedDict(FeedDict& feed_dict, Onnx::OnnxStateVariable const& state_var, Onnx::Value& var);
+    virtual void extendTargets(TargetList& targets, Onnx::OnnxStateVariable const& state_var);
+};
+
+// inline implementations
+
+inline OnnxLstmStateManager::OnnxLstmStateManager(Core::Configuration const& config)
+        : Precursor(config) {
+}
+
+}  // namespace Lm
+
+#endif  // _LM_ONNX_LSTM_STATE_MANAGER_HH
diff --git a/src/Lm/OnnxNceSoftmaxAdapter.cc b/src/Lm/OnnxNceSoftmaxAdapter.cc
new file mode 100644
index 000000000..78530f100
--- /dev/null
+++ b/src/Lm/OnnxNceSoftmaxAdapter.cc
@@ -0,0 +1,64 @@
+#include "OnnxNceSoftmaxAdapter.hh"
+
+#include <Math/Blas.hh>
+
+#include "DummyCompressedVectorFactory.hh"
+
+namespace Lm {
+
+const Core::ParameterString OnnxNceSoftmaxAdapter::paramWeightsFile("weights-file", "output embedding file", "");
+const Core::ParameterString OnnxNceSoftmaxAdapter::paramBiasFile("bias-file", "output bias file", "");
+
+void OnnxNceSoftmaxAdapter::init(Onnx::Session& session, Onnx::IOMapping& mapping) {
+    Core::BinaryInputStream weight_stream(weightsFile_);
+    weights_.read(weight_stream);
+
+    Core::BinaryInputStream bias_stream(biasFile_);
+
+    u32 numRows;
+    bias_stream >> numRows;
+
+    std::vector<float> elem(numRows);
+    bias_stream.read<float>(elem.data(), numRows);
+
+    bias_.resize(numRows, 0.0f, true);
+
+    for (size_t i = 0; i < numRows; i++) {
+        bias_[i] = elem[i];
+    }
+}
+
+Score OnnxNceSoftmaxAdapter::get_score(Lm::CompressedVectorPtr<float> const& nn_out, size_t output_idx) {
+    std::vector<float>                   nn_output;
+    float const*                         data;
+    Lm::UncompressedVector<float> const* vec = dynamic_cast<Lm::UncompressedVector<float> const*>(nn_out.get());
+
+    if (vec != nullptr) {
+        data = vec->data();
+    }
+    else {
+        nn_output.resize(nn_out->size());
+        nn_out->uncompress(nn_output.data(), nn_output.size());
+        data = nn_output.data();
+    }
+
+    float result = Math::dot(nn_out->size(), data, 1, &weights_(0, output_idx), 1);
+    result += bias_[output_idx];
+
+    return result;
+}
+
+std::vector<Score> OnnxNceSoftmaxAdapter::get_scores(Lm::CompressedVectorPtr<float> const& nn_out, std::vector<size_t> const& output_idxs) {
+    std::vector<float> nn_output(nn_out->size());
+    nn_out->uncompress(nn_output.data(), nn_output.size());
+
+    std::vector<Score> result(output_idxs.size());
+    for (size_t i = 0ul; i < output_idxs.size(); i++) {
+        result[i] = Math::dot(nn_output.size(), nn_output.data(), 1, &weights_(0, output_idxs[i]), 1);
+        result[i] += bias_[output_idxs[i]];
+    }
+
+    return result;
+}
+
+}  // namespace Lm
diff --git a/src/Lm/OnnxNceSoftmaxAdapter.hh b/src/Lm/OnnxNceSoftmaxAdapter.hh
new file mode 100644
index 000000000..707832e81
--- /dev/null
+++ b/src/Lm/OnnxNceSoftmaxAdapter.hh
@@ -0,0 +1,40 @@
+#ifndef _LM_ONNX_NCE_SOFTMAX_ADAPTER_HH
+#define _LM_ONNX_NCE_SOFTMAX_ADAPTER_HH
+
+#include <Onnx/Session.hh>
+
+#include "OnnxSoftmaxAdapter.hh"
+
+namespace Lm {
+
+class OnnxNceSoftmaxAdapter : public OnnxSoftmaxAdapter {
+public:
+    using Precursor = OnnxSoftmaxAdapter;
+
+    static const Core::ParameterString paramWeightsFile;
+    static const Core::ParameterString paramBiasFile;
+
+    OnnxNceSoftmaxAdapter(Core::Configuration const& config);
+    virtual ~OnnxNceSoftmaxAdapter() = default;
+
+    virtual void               init(Onnx::Session& session, Onnx::IOMapping& mapping);
+    virtual Score              get_score(Lm::CompressedVectorPtr<float> const& nn_out, size_t output_idx);
+    virtual std::vector<Score> get_scores(Lm::CompressedVectorPtr<float> const& nn_out, std::vector<size_t> const& output_idxs);
+
+private:
+    const std::string weightsFile_;
+    const std::string biasFile_;
+
+    Math::FastMatrix<float> weights_;
+    Math::FastVector<float> bias_;
+};
+
+inline OnnxNceSoftmaxAdapter::OnnxNceSoftmaxAdapter(Core::Configuration const& config)
+        : Precursor(config),
+          weightsFile_(paramWeightsFile(config)),
+          biasFile_(paramBiasFile(config)) {
+}
+
+}  // namespace Lm
+
+#endif  // _LM_ONNX_NCE_SOFTMAX_ADAPTER_HH
diff --git a/src/Lm/OnnxPassthroughSoftmaxAdapter.cc b/src/Lm/OnnxPassthroughSoftmaxAdapter.cc
new file mode 100644
index 000000000..19b0f03b3
--- /dev/null
+++ b/src/Lm/OnnxPassthroughSoftmaxAdapter.cc
@@ -0,0 +1,12 @@
+#include "OnnxPassthroughSoftmaxAdapter.hh"
+
+namespace Lm {
+
+void OnnxPassthroughSoftmaxAdapter::init(Onnx::Session& session, Onnx::IOMapping& mapping) {
+}
+
+Score OnnxPassthroughSoftmaxAdapter::get_score(Lm::CompressedVectorPtr<float> const& nn_out, size_t output_idx) {
+    return nn_out->get(output_idx);
+}
+
+}  // namespace Lm
diff --git a/src/Lm/OnnxPassthroughSoftmaxAdapter.hh b/src/Lm/OnnxPassthroughSoftmaxAdapter.hh
new file mode 100644
index 000000000..212f0e75f
--- /dev/null
+++ b/src/Lm/OnnxPassthroughSoftmaxAdapter.hh
@@ -0,0 +1,31 @@
+#ifndef _LM_ONNX_PASSTHROUGH_SOFTMAX_ADAPTER_HH
+#define _LM_ONNX_PASSTHROUGH_SOFTMAX_ADAPTER_HH
+
+#include <Onnx/Session.hh>
+
+#include "OnnxSoftmaxAdapter.hh"
+
+namespace Lm {
+
+class OnnxPassthroughSoftmaxAdapter : public OnnxSoftmaxAdapter {
+public:
+    using Precursor = OnnxSoftmaxAdapter;
+
+    OnnxPassthroughSoftmaxAdapter(Core::Configuration const& config);
+    virtual ~OnnxPassthroughSoftmaxAdapter() = default;
+
+    virtual void  init(Onnx::Session& session, Onnx::IOMapping& mapping);
+    virtual Score get_score(Lm::CompressedVectorPtr<float> const& nn_out, size_t output_idx);
+
+private:
+};
+
+// inline implementations
+
+inline OnnxPassthroughSoftmaxAdapter::OnnxPassthroughSoftmaxAdapter(Core::Configuration const& config)
+        : Precursor(config) {
+}
+
+}  // namespace Lm
+
+#endif /* _LM_ONNX_PASSTHROUGH_SOFTMAX_ADAPTER_HH */
diff --git a/src/Lm/OnnxRecurrentLanguageModel.cc b/src/Lm/OnnxRecurrentLanguageModel.cc
new file mode 100644
index 000000000..7af03faa9
--- /dev/null
+++ b/src/Lm/OnnxRecurrentLanguageModel.cc
@@ -0,0 +1,113 @@
+#include "OnnxRecurrentLanguageModel.hh"
+
+#include "OnnxLstmStateManager.hh"
+#include "OnnxNceSoftmaxAdapter.hh"
+#include "OnnxPassthroughSoftmaxAdapter.hh"
+
+namespace {
+
+std::vector<Onnx::IOSpecification> getIOSpec(int64_t num_classes) {
+    return std::vector<Onnx::IOSpecification>({
+            Onnx::IOSpecification{"word", Onnx::IODirection::INPUT, false, {Onnx::ValueType::TENSOR}, {Onnx::ValueDataType::INT32}, {{-1, -1}}},
+            Onnx::IOSpecification{"word-length", Onnx::IODirection::INPUT, false, {Onnx::ValueType::TENSOR}, {Onnx::ValueDataType::INT32}, {{-1}}},
+            Onnx::IOSpecification{"nn-output", Onnx::IODirection::OUTPUT, false, {Onnx::ValueType::TENSOR}, {Onnx::ValueDataType::FLOAT}, {{-1, -1, num_classes}}},
+    });
+}
+
+}  // namespace
+
+namespace Lm {
+
+enum OnnxStateManagerType {
+    OnnxLstmStateManagerType,
+    OnnxTransformerStateManagerType,
+    OnnxTransformerStateManager16BitType,
+    OnnxTransformerStateManager8BitType,
+    OnnxTransformerStateManagerWithCommonPrefixType,
+    OnnxTransformerStateManagerWithCommonPrefix16BitType,
+    OnnxTransformerStateManagerWithCommonPrefix8BitType,
+};
+
+const Core::Choice stateManagerTypeChoice(
+        "lstm", OnnxLstmStateManagerType,
+        Core::Choice::endMark());
+
+const Core::ParameterChoice stateManagerTypeParam(
+        "type", &stateManagerTypeChoice,
+        "type of the state manager",
+        OnnxLstmStateManagerType);
+
+std::unique_ptr<OnnxStateManager> createOnnxStateManager(Core::Configuration const& config) {
+    OnnxStateManager* res = nullptr;
+    switch (stateManagerTypeParam(config)) {
+        case OnnxLstmStateManagerType: res = new Lm::OnnxLstmStateManager(config); break;
+        default: defect();
+    }
+    return std::unique_ptr<OnnxStateManager>(res);
+}
+
+enum OnnxSoftmaxAdapterType {
+    OnnxPassthroughSoftmaxAdapterType,
+    OnnxNceSoftmaxAdapterType,
+};
+
+const Core::Choice softmaxAdapterTypeChoice(
+        "passthrough", OnnxPassthroughSoftmaxAdapterType,
+        "nce", OnnxNceSoftmaxAdapterType,
+        Core::Choice::endMark());
+
+const Core::ParameterChoice softmaxAdapterTypeParam(
+        "type", &softmaxAdapterTypeChoice,
+        "type of the softmax adapter",
+        OnnxPassthroughSoftmaxAdapterType);
+
+std::unique_ptr<OnnxSoftmaxAdapter> createOnnxSoftmaxAdapter(Core::Configuration const& config) {
+    switch (softmaxAdapterTypeParam(config)) {
+        case OnnxPassthroughSoftmaxAdapterType: return std::unique_ptr<OnnxSoftmaxAdapter>(new Lm::OnnxPassthroughSoftmaxAdapter(config));
+        case OnnxNceSoftmaxAdapterType: return std::unique_ptr<OnnxSoftmaxAdapter>(new Lm::OnnxNceSoftmaxAdapter(config));
+        default: defect();
+    }
+}
+
+OnnxRecurrentLanguageModel::OnnxRecurrentLanguageModel(Core::Configuration const& c, Bliss::LexiconRef l)
+        : Core::Component(c),
+          Precursor(c, l, createOnnxStateManager(select("state-manager"))),
+          session_(select("session")),
+          ioSpec_(getIOSpec(-2)),
+          mapping_(select("io-map"), ioSpec_),
+          validator_(select("validator")),
+          softmax_adapter_(createOnnxSoftmaxAdapter(select("softmax-adapter"))) {
+    state_variables_ = session_.getStateVariablesMetadata();
+
+    setEmptyHistory();
+
+    softmax_adapter_->init(session_, mapping_);
+    validator_.validate(ioSpec_, mapping_, session_);
+}
+
+void OnnxRecurrentLanguageModel::setState(std::vector<std::pair<std::string, Onnx::Value>> const& inputs, std::vector<std::string> const& targets) const {
+}
+
+void OnnxRecurrentLanguageModel::extendInputs(std::vector<std::pair<std::string, Onnx::Value>>& inputs, Math::FastMatrix<s32> const& words, Math::FastVector<s32> const& word_lengths, std::vector<s32> const& state_lengths) const {
+    inputs.emplace_back(mapping_.getOnnxName("word"), Onnx::Value::create(words));
+    inputs.emplace_back(mapping_.getOnnxName("word-length"), Onnx::Value::create(word_lengths));
+}
+
+void OnnxRecurrentLanguageModel::extendTargets(std::vector<std::string>& targets) const {
+    targets.emplace(targets.begin(), mapping_.getOnnxName("nn-output"));
+}
+
+void OnnxRecurrentLanguageModel::getOutputs(std::vector<std::pair<std::string, Onnx::Value>>& inputs, std::vector<Onnx::Value>& outputs, std::vector<std::string> const& targets) const {
+    session_.run(std::move(inputs), targets, outputs);
+}
+
+std::vector<Onnx::Value> OnnxRecurrentLanguageModel::fetchStates(std::vector<Onnx::Value>& outputs) const {
+    std::vector<Onnx::Value> state_vars(std::make_move_iterator(outputs.begin() + 1), std::make_move_iterator(outputs.end()));
+    return state_vars;
+}
+
+Score OnnxRecurrentLanguageModel::transformOutput(Lm::CompressedVectorPtr<float> const& nn_output, size_t index) const {
+    return softmax_adapter_->get_score(nn_output, index);
+}
+
+}  // namespace Lm
diff --git a/src/Lm/OnnxRecurrentLanguageModel.hh b/src/Lm/OnnxRecurrentLanguageModel.hh
new file mode 100644
index 000000000..7485a493a
--- /dev/null
+++ b/src/Lm/OnnxRecurrentLanguageModel.hh
@@ -0,0 +1,40 @@
+#ifndef _LM_ONNX_RECURRENT_LANGUAGE_MODEL_HXX
+#define _LM_ONNX_RECURRENT_LANGUAGE_MODEL_HXX
+
+#include <Onnx/IOSpecification.hh>
+#include <Onnx/OnnxStateVariable.hh>
+#include <Onnx/Value.hh>
+
+#include "OnnxSoftmaxAdapter.hh"
+#include "RecurrentLanguageModel.hh"
+
+namespace Lm {
+
+class OnnxRecurrentLanguageModel : public RecurrentLanguageModel<Onnx::Value, Onnx::OnnxStateVariable> {
+public:
+    using Precursor = RecurrentLanguageModel<Onnx::Value, Onnx::OnnxStateVariable>;
+
+    OnnxRecurrentLanguageModel(Core::Configuration const& c, Bliss::LexiconRef l);
+    virtual ~OnnxRecurrentLanguageModel() {}
+
+protected:
+    virtual void                     setState(std::vector<std::pair<std::string, Onnx::Value>> const& inputs, std::vector<std::string> const& targets) const;
+    virtual void                     extendInputs(std::vector<std::pair<std::string, Onnx::Value>>& inputs, Math::FastMatrix<s32> const& words, Math::FastVector<s32> const& word_lengths, std::vector<s32> const& state_lengths) const;
+    virtual void                     extendTargets(std::vector<std::string>& targets) const;
+    virtual void                     getOutputs(std::vector<std::pair<std::string, Onnx::Value>>& inputs, std::vector<Onnx::Value>& outputs, std::vector<std::string> const& targets) const;
+    virtual std::vector<Onnx::Value> fetchStates(std::vector<Onnx::Value>& outputs) const;
+
+    virtual Score transformOutput(Lm::CompressedVectorPtr<float> const& nn_output, size_t index) const;
+
+private:
+    mutable Onnx::Session              session_;
+    std::vector<Onnx::IOSpecification> ioSpec_;
+    Onnx::IOMapping                    mapping_;
+    Onnx::IOValidator                  validator_;
+
+    std::unique_ptr<OnnxSoftmaxAdapter> softmax_adapter_;
+};
+
+}  // namespace Lm
+
+#endif  // _LM_ONNX_RECURRENT_LANGUAGE_MODEL_HXX
diff --git a/src/Lm/OnnxSoftmaxAdapter.hh b/src/Lm/OnnxSoftmaxAdapter.hh
new file mode 100644
index 000000000..ed9218b10
--- /dev/null
+++ b/src/Lm/OnnxSoftmaxAdapter.hh
@@ -0,0 +1,45 @@
+#ifndef _LM_ONNX_SOFTMAX_ADAPTER_HH
+#define _LM_ONNX_SOFTMAX_ADAPTER_HH
+
+#include <Core/Component.hh>
+#include <Onnx/IOSpecification.hh>
+#include <Onnx/Session.hh>
+
+#include "CompressedVector.hh"
+
+namespace Lm {
+
+using Score = float;
+
+class OnnxSoftmaxAdapter : public Core::Component {
+public:
+    using Precursor = Core::Component;
+
+    OnnxSoftmaxAdapter(Core::Configuration const& config);
+    virtual ~OnnxSoftmaxAdapter() = default;
+
+    virtual void               init(Onnx::Session& session, Onnx::IOMapping& mapping)                     = 0;
+    virtual Score              get_score(Lm::CompressedVectorPtr<float> const& nn_out, size_t output_idx) = 0;
+    virtual std::vector<Score> get_scores(Lm::CompressedVectorPtr<float> const& nn_out, std::vector<size_t> const& output_idxs);
+
+private:
+};
+
+// inline implementations
+
+inline OnnxSoftmaxAdapter::OnnxSoftmaxAdapter(Core::Configuration const& config)
+        : Precursor(config) {
+}
+
+inline std::vector<Score> OnnxSoftmaxAdapter::get_scores(Lm::CompressedVectorPtr<float> const& nn_out, std::vector<size_t> const& output_idxs) {
+    std::vector<Score> scores;
+    scores.reserve(output_idxs.size());
+    for (size_t output_idx : output_idxs) {
+        scores.push_back(get_score(nn_out, output_idx));
+    }
+    return scores;
+}
+
+}  // namespace Lm
+
+#endif /* _LM_ONNX_SOFTMAX_ADAPTER_HH */
diff --git a/src/Lm/OnnxStateVariable.hh b/src/Lm/OnnxStateVariable.hh
new file mode 100644
index 000000000..a74f03294
--- /dev/null
+++ b/src/Lm/OnnxStateVariable.hh
@@ -0,0 +1,18 @@
+#ifndef _LM_ONNX_STATE_VARIABLE_HH
+#define _LM_ONNX_STATE_VARIABLE_HH
+
+#include <Core/Types.hh>
+
+#include <string>
+
+namespace Lm {
+
+struct OnnxStateVariable {
+    std::string      input_state_key;
+    std::string      output_state_key;
+    std::vector<s64> shape;
+};
+
+}  // namespace Lm
+
+#endif  // _LM_ONNX_STATE_VARIABLE_HH
\ No newline at end of file
diff --git a/src/Lm/QuantizedCompressedVectorFactory.hh b/src/Lm/QuantizedCompressedVectorFactory.hh
index d05045edf..d0bec1d61 100644
--- a/src/Lm/QuantizedCompressedVectorFactory.hh
+++ b/src/Lm/QuantizedCompressedVectorFactory.hh
@@ -59,7 +59,8 @@ private:
 
 struct QuantizedCompressionParameters : public CompressionParameters {
     QuantizedCompressionParameters(float min_val, float max_val)
-            : min_val(min_val), max_val(max_val) {}
+            : min_val(min_val),
+              max_val(max_val) {}
     virtual ~QuantizedCompressionParameters() = default;
 
     float min_val;
@@ -89,7 +90,8 @@ public:
     static const Core::ParameterInt paramBitsPerVal;
 
     QuantizedCompressedVectorFactory(Core::Configuration const& config)
-            : Precursor(config), bits_per_val_(paramBitsPerVal(config)) {}
+            : Precursor(config),
+              bits_per_val_(paramBitsPerVal(config)) {}
     virtual ~QuantizedCompressedVectorFactory() = default;
 
     virtual CompressionParameterEstimatorPtr<float> getEstimator() const;
diff --git a/src/Lm/RecurrentLanguageModel.cc b/src/Lm/RecurrentLanguageModel.cc
new file mode 100644
index 000000000..77a6ca0a4
--- /dev/null
+++ b/src/Lm/RecurrentLanguageModel.cc
@@ -0,0 +1,146 @@
+#include "RecurrentLanguageModel.hh"
+
+namespace Lm::detail {
+
+void RequestGraph::add_cache(ScoresWithContext* cache) {
+    std::vector<ScoresWithContext*> request_chain;
+    request_chain.push_back(cache);
+    ScoresWithContext* parent = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(cache->parent.handle()));
+    request_chain.push_back(parent);
+    while (parent->state.empty()) {
+        parent = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(parent->parent.handle()));
+        request_chain.push_back(parent);
+    }
+
+    std::vector<size_t>* child_idxs = &roots;
+    while (not request_chain.empty()) {
+        // find root node
+        size_t child_idx = child_idxs->size();
+        for (size_t c = 0ul; c < child_idxs->size(); c++) {
+            if (entries[child_idxs->at(c)] == request_chain.back()) {
+                child_idx = c;
+                break;
+            }
+        }
+        size_t next_child_idx = 0ul;
+        if (child_idx == child_idxs->size()) {
+            child_idxs->push_back(entries.size());
+            entries.push_back(request_chain.back());
+            next_child_idx = child_idxs->at(child_idx);
+            children.emplace_back();  // can invalidate child_idxs
+        }
+        else {
+            next_child_idx = child_idxs->at(child_idx);
+        }
+        child_idxs = &children[next_child_idx];
+        request_chain.pop_back();
+    }
+}
+
+void RequestGraph::get_requests_dfs(std::vector<FwdRequest>& requests, ScoresWithContext* initial, size_t entry, size_t length) const {
+    if (children[entry].empty()) {
+        requests.emplace_back(FwdRequest{initial, entries[entry], length});
+    }
+    else {
+        for (size_t e : children[entry]) {
+            get_requests_dfs(requests, initial, e, length + 1ul);
+        }
+    }
+}
+
+std::vector<FwdRequest> RequestGraph::get_requests() const {
+    std::vector<FwdRequest> result;
+    for (size_t r : roots) {
+        for (size_t c : children[r]) {
+            get_requests_dfs(result, entries[r], c, 1ul);
+        }
+    }
+    return result;
+}
+
+void dump_scores(ScoresWithContext const& cache, std::string const& prefix) {
+    std::stringstream path;
+    path << prefix;
+    for (auto token : *cache.history) {
+        path << "_" << token;
+    }
+    std::ofstream out(path.str(), std::ios::out | std::ios::trunc);
+    out << "nn_output:\n";
+    std::vector<float> nn_output(cache.nn_output->size());
+    cache.nn_output->uncompress(nn_output.data(), nn_output.size());
+    for (auto nn_out : nn_output) {
+        out << nn_out << '\n';
+    }
+    for (size_t s = 0ul; s < cache.state.size(); s++) {
+        out << "state " << s << ":\n";
+        std::vector<float> state_data(cache.state[s]->size());
+        cache.state[s]->uncompress(state_data.data(), state_data.size());
+        for (auto v : state_data) {
+            out << v << '\n';
+        }
+    }
+}
+
+TimeStatistics TimeStatistics::operator+(TimeStatistics const& other) const {
+    TimeStatistics res;
+
+    res.total_duration          = total_duration + other.total_duration;
+    res.early_request_duration  = early_request_duration + other.early_request_duration;
+    res.request_duration        = request_duration + other.request_duration;
+    res.prepare_duration        = prepare_duration + other.prepare_duration;
+    res.merge_state_duration    = merge_state_duration + other.merge_state_duration;
+    res.set_state_duration      = set_state_duration + other.set_state_duration;
+    res.run_nn_output_duration  = run_nn_output_duration + other.run_nn_output_duration;
+    res.set_nn_output_duration  = set_nn_output_duration + other.set_nn_output_duration;
+    res.get_new_state_duration  = get_new_state_duration + other.get_new_state_duration;
+    res.split_state_duration    = split_state_duration + other.split_state_duration;
+    res.softmax_output_duration = softmax_output_duration + other.softmax_output_duration;
+
+    return res;
+}
+
+TimeStatistics& TimeStatistics::operator+=(TimeStatistics const& other) {
+    total_duration += other.total_duration;
+    early_request_duration += other.early_request_duration;
+    request_duration += other.request_duration;
+    prepare_duration += other.prepare_duration;
+    merge_state_duration += other.merge_state_duration;
+    set_state_duration += other.set_state_duration;
+    run_nn_output_duration += other.run_nn_output_duration;
+    set_nn_output_duration += other.set_nn_output_duration;
+    get_new_state_duration += other.get_new_state_duration;
+    split_state_duration += other.split_state_duration;
+    softmax_output_duration += other.softmax_output_duration;
+
+    return *this;
+}
+
+void TimeStatistics::write(Core::XmlChannel& channel) const {
+    channel << Core::XmlOpen("total-duration") + Core::XmlAttribute("unit", "milliseconds") << total_duration.count() << Core::XmlClose("total-duration");
+    channel << Core::XmlOpen("early-request-duration") + Core::XmlAttribute("unit", "milliseconds") << early_request_duration.count() << Core::XmlClose("early-request-duration");
+    channel << Core::XmlOpen("request-duration") + Core::XmlAttribute("unit", "milliseconds") << request_duration.count() << Core::XmlClose("request-duration");
+    channel << Core::XmlOpen("prepare-duration") + Core::XmlAttribute("unit", "milliseconds") << prepare_duration.count() << Core::XmlClose("prepare-duration");
+    channel << Core::XmlOpen("merge-state-duration") + Core::XmlAttribute("unit", "milliseconds") << merge_state_duration.count() << Core::XmlClose("merge-state-duration");
+    channel << Core::XmlOpen("set-state-duration") + Core::XmlAttribute("unit", "milliseconds") << set_state_duration.count() << Core::XmlClose("set-state-duration");
+    channel << Core::XmlOpen("run-nn-output-duration") + Core::XmlAttribute("unit", "milliseconds") << run_nn_output_duration.count() << Core::XmlClose("run-nn-output-duration");
+    channel << Core::XmlOpen("set-nn-output-duration") + Core::XmlAttribute("unit", "milliseconds") << set_nn_output_duration.count() << Core::XmlClose("set-nn-output-duration");
+    channel << Core::XmlOpen("get-new-state-duration") + Core::XmlAttribute("unit", "milliseconds") << get_new_state_duration.count() << Core::XmlClose("get-new-state-duration");
+    channel << Core::XmlOpen("split-state-duration") + Core::XmlAttribute("unit", "milliseconds") << split_state_duration.count() << Core::XmlClose("split-state-duration");
+    channel << Core::XmlOpen("softmax-output-duration") + Core::XmlAttribute("unit", "milliseconds") << softmax_output_duration.count() << Core::XmlClose("softmax-output-duration");
+}
+
+void TimeStatistics::write(std::ostream& out) const {
+    out << "fwd: " << total_duration.count()
+        << " er:" << early_request_duration.count()
+        << " r:" << request_duration.count()
+        << " p:" << prepare_duration.count()
+        << " ms: " << merge_state_duration.count()
+        << " sst:" << set_state_duration.count()
+        << " rs:" << run_nn_output_duration.count()
+        << " sno:" << set_nn_output_duration.count()
+        << " gns:" << get_new_state_duration.count()
+        << " ss: " << split_state_duration.count()
+        << " smo:" << softmax_output_duration.count();
+}
+
+}  // namespace Lm::detail
diff --git a/src/Lm/RecurrentLanguageModel.hh b/src/Lm/RecurrentLanguageModel.hh
new file mode 100644
index 000000000..a1780e557
--- /dev/null
+++ b/src/Lm/RecurrentLanguageModel.hh
@@ -0,0 +1,887 @@
+#ifndef _LM_RECURRENT_LANGUAGE_MODEL_HH
+#define _LM_RECURRENT_LANGUAGE_MODEL_HH
+
+#include <deque>
+#include <future>
+#include <thread>
+#include <vector>
+
+#include <Math/FastMatrix.hh>
+#include <Core/readerwriterqueue.h>
+
+#include "AbstractNNLanguageModel.hh"
+#include "AbstractStateManager.hh"
+#include "Module.hh"
+#include "SearchSpaceAwareLanguageModel.hh"
+
+namespace Lm {
+template<typename value_t, typename state_variable_t>
+class RecurrentLanguageModel;
+
+namespace detail {
+
+struct ScoresWithContext : public Lm::NNCacheWithStats {
+    virtual ~ScoresWithContext() = default;
+
+    std::atomic<bool>                           computed;
+    Lm::History                                 parent;
+    Lm::CompressedVectorPtr<float>              nn_output;
+    std::vector<Lm::CompressedVectorPtr<float>> state;
+    Lm::SearchSpaceInformation                  info;
+    Search::TimeframeIndex                      last_used;
+    Search::TimeframeIndex                      last_info;
+    bool                                        was_expanded;
+};
+
+struct FwdRequest {
+    ScoresWithContext* initial_cache;
+    ScoresWithContext* final_cache;
+    size_t             length;
+
+    bool operator==(FwdRequest const& other) const {
+        return final_cache == other.final_cache;
+    }
+};
+
+struct RequestGraph {
+    std::vector<ScoresWithContext*>  entries;
+    std::vector<std::vector<size_t>> children;
+    std::vector<size_t>              roots;
+
+    void                    add_cache(ScoresWithContext* cache);
+    void                    get_requests_dfs(std::vector<FwdRequest>& requests, ScoresWithContext* initial, size_t entry, size_t length) const;
+    std::vector<FwdRequest> get_requests() const;
+};
+
+void dump_scores(ScoresWithContext const& cache, std::string const& prefix);
+
+template<typename value_t, typename state_variable_t>
+void clear_queue(typename Lm::RecurrentLanguageModel<value_t, state_variable_t>::HistoryQueue& queue) {
+    Lm::History const* hist = nullptr;
+    while (queue.try_dequeue(hist)) {
+        delete hist;
+    }
+}
+
+struct TimeStatistics {
+    std::chrono::duration<double, std::milli> total_duration;
+    std::chrono::duration<double, std::milli> early_request_duration;
+    std::chrono::duration<double, std::milli> request_duration;
+    std::chrono::duration<double, std::milli> prepare_duration;
+    std::chrono::duration<double, std::milli> merge_state_duration;
+    std::chrono::duration<double, std::milli> set_state_duration;
+    std::chrono::duration<double, std::milli> run_nn_output_duration;
+    std::chrono::duration<double, std::milli> set_nn_output_duration;
+    std::chrono::duration<double, std::milli> get_new_state_duration;
+    std::chrono::duration<double, std::milli> split_state_duration;
+    std::chrono::duration<double, std::milli> softmax_output_duration;
+
+    TimeStatistics  operator+(TimeStatistics const& other) const;
+    TimeStatistics& operator+=(TimeStatistics const& other);
+    void            write(Core::XmlChannel& channel) const;
+    void            write(std::ostream& out) const;
+};
+
+}  // namespace detail
+
+template<typename value_t, typename state_variable_t>
+class RecurrentLanguageModel : public AbstractNNLanguageModel, public SearchSpaceAwareLanguageModel {
+public:
+    typedef AbstractNNLanguageModel                               Precursor;
+    typedef moodycamel::BlockingReaderWriterQueue<History const*> HistoryQueue;
+
+    static const Core::ParameterBool   paramTransformOuputLog;
+    static const Core::ParameterBool   paramTransformOuputNegate;
+    static const Core::ParameterInt    paramMinBatchSize;
+    static const Core::ParameterInt    paramOptBatchSize;
+    static const Core::ParameterInt    paramMaxBatchSize;
+    static const Core::ParameterInt    paramHistoryPruningThreshold;
+    static const Core::ParameterInt    paramPrunedHistoryLength;
+    static const Core::ParameterFloat  paramBatchPruningThreshold;
+    static const Core::ParameterBool   paramAllowReducedHistory;
+    static const Core::ParameterBool   paramDumpInputs;
+    static const Core::ParameterString paramDumpInputsPrefix;
+    static const Core::ParameterBool   paramDumpScores;
+    static const Core::ParameterString paramDumpScoresPrefix;
+    static const Core::ParameterBool   paramLogMemory;
+    static const Core::ParameterBool   paramFreeMemory;
+    static const Core::ParameterInt    paramFreeMemoryDelay;
+    static const Core::ParameterBool   paramAsync;
+    static const Core::ParameterBool   paramSingleStepOnly;
+    static const Core::ParameterBool   paramVerbose;
+
+    RecurrentLanguageModel(Core::Configuration const& c, Bliss::LexiconRef l, std::unique_ptr<AbstractStateManager<value_t, state_variable_t>> state_manager);
+    virtual ~RecurrentLanguageModel();
+
+    virtual History startHistory() const;
+    virtual History extendedHistory(History const& hist, Token w) const;
+    virtual History extendedHistory(History const& hist, Bliss::Token::Id w) const;
+    virtual History reducedHistory(History const& hist, u32 limit) const;
+    virtual History reduceHistoryByN(History const&, u32 n) const;
+    virtual Score   score(History const& hist, Token w) const;
+    virtual bool    scoreCached(History const& hist, Token w) const;
+
+    virtual void startFrame(Search::TimeframeIndex time) const;
+    virtual void setInfo(History const& hist, SearchSpaceInformation const& info) const;
+
+protected:
+    virtual void load();
+
+    virtual void                 setState(std::vector<std::pair<std::string, value_t>> const& inputs, std::vector<std::string> const& targets) const                                                                            = 0;
+    virtual void                 extendInputs(std::vector<std::pair<std::string, value_t>>& inputs, Math::FastMatrix<s32> const& words, Math::FastVector<s32> const& word_lengths, std::vector<s32> const& state_lengths) const = 0;
+    virtual void                 extendTargets(std::vector<std::string>& targets) const                                                                                                                                         = 0;
+    virtual void                 getOutputs(std::vector<std::pair<std::string, value_t>>& inputs, std::vector<value_t>& outputs, std::vector<std::string> const& targets) const                                                 = 0;
+    virtual std::vector<value_t> fetchStates(std::vector<value_t>& outputs) const                                                                                                                                               = 0;
+    virtual Score                transformOutput(Lm::CompressedVectorPtr<float> const& nn_output, size_t index) const                                                                                                           = 0;
+
+    std::vector<state_variable_t> state_variables_;
+
+    void setEmptyHistory();
+
+private:
+    using ScoresWithContext = detail::ScoresWithContext;
+
+    bool                   transform_output_log_;
+    bool                   transform_output_negate_;
+    size_t                 min_batch_size_;
+    size_t                 opt_batch_size_;
+    size_t                 max_batch_size_;
+    size_t                 history_pruning_threshold_;
+    size_t                 pruned_history_length_;
+    Score                  batch_pruning_threshold_;
+    bool                   allow_reduced_history_;
+    bool                   dump_inputs_;
+    std::string            dump_inputs_prefix_;
+    bool                   dump_scores_;
+    std::string            dump_scores_prefix_;
+    bool                   log_memory_;
+    bool                   free_memory_;
+    Search::TimeframeIndex free_memory_delay_;
+    bool                   single_step_only_;
+    bool                   verbose_;
+
+    mutable Core::XmlChannel       statistics_;
+    mutable Search::TimeframeIndex current_time_;
+    mutable std::vector<double>    run_time_;
+    mutable std::vector<size_t>    run_count_;
+    mutable double                 total_wait_time_;
+    mutable double                 total_start_frame_time_;
+    mutable double                 total_expand_hist_time_;
+    mutable detail::TimeStatistics fwd_statistics_;
+    mutable size_t                 dump_inputs_counter_;
+
+    std::unique_ptr<AbstractStateManager<value_t, state_variable_t>> state_manager_;
+
+    std::function<Score(Score)>       output_transform_function_;
+    CompressedVectorFactoryPtr<float> state_comp_vec_factory_;
+    CompressedVectorFactoryPtr<float> nn_output_comp_vec_factory_;
+
+    History empty_history_;  // a history used to provide the previous (all zero) state to the first real history (1 sentence-begin token)
+
+    // members for async forwarding
+    bool        should_stop_;
+    std::thread background_forwarder_thread_;
+    bool        async_;
+
+    void background_forward() const;
+
+    mutable std::atomic<History const*>  to_fwd_;
+    mutable std::promise<History const*> to_fwd_finished_;
+
+    mutable std::vector<History const*> pending_;
+    mutable HistoryQueue                fwd_queue_;
+    mutable HistoryQueue                finished_queue_;
+
+    History extendHistoryWithOutputIdx(History const& hist, size_t w) const;
+
+    template<bool async>
+    void forward(Lm::History const* hist) const;
+};
+
+template<typename value_t, typename state_variable_t>
+const Core::ParameterBool RecurrentLanguageModel<value_t, state_variable_t>::paramTransformOuputLog("transform-output-log", "apply log to tensorflow output", false);
+
+template<typename value_t, typename state_variable_t>
+const Core::ParameterBool RecurrentLanguageModel<value_t, state_variable_t>::paramTransformOuputNegate("transform-output-negate", "negate tensorflow output (after log)", false);
+
+template<typename value_t, typename state_variable_t>
+const Core::ParameterInt RecurrentLanguageModel<value_t, state_variable_t>::paramMinBatchSize("min-batch-size", "minimum number of histories forwarded in one go", 32);
+
+template<typename value_t, typename state_variable_t>
+const Core::ParameterInt RecurrentLanguageModel<value_t, state_variable_t>::paramOptBatchSize("opt-batch-size", "optimum number of histories forwarded in one go", 128);
+
+template<typename value_t, typename state_variable_t>
+const Core::ParameterInt RecurrentLanguageModel<value_t, state_variable_t>::paramMaxBatchSize("max-batch-size", "maximum number of histories forwarded in one go", 2048);
+
+template<typename value_t, typename state_variable_t>
+const Core::ParameterInt RecurrentLanguageModel<value_t, state_variable_t>::paramHistoryPruningThreshold("history-pruning-threshold", "if the history is longer than this parameter it will be pruned", std::numeric_limits<int>::max(), 0);
+
+template<typename value_t, typename state_variable_t>
+const Core::ParameterInt RecurrentLanguageModel<value_t, state_variable_t>::paramPrunedHistoryLength("pruned-history-length", "length of the pruned history (should be smaller than history-pruning-threshold)", std::numeric_limits<int>::max(), 0);
+
+template<typename value_t, typename state_variable_t>
+const Core::ParameterFloat RecurrentLanguageModel<value_t, state_variable_t>::paramBatchPruningThreshold("batch-pruning-threshold", "pruning threshold for all hypothesis beyond min-batch-size during eager forwarding", 10.0);
+
+template<typename value_t, typename state_variable_t>
+const Core::ParameterBool RecurrentLanguageModel<value_t, state_variable_t>::paramAllowReducedHistory("allow-reduced-history", "wether this LM will actually reduce the history length", false);
+
+template<typename value_t, typename state_variable_t>
+const Core::ParameterBool RecurrentLanguageModel<value_t, state_variable_t>::paramDumpInputs("dump-inputs", "write all inputs from this LM to disk", false);
+
+template<typename value_t, typename state_variable_t>
+const Core::ParameterString RecurrentLanguageModel<value_t, state_variable_t>::paramDumpInputsPrefix("dump-inputs-prefix", "prefix for the input dumps", "inputs");
+
+template<typename value_t, typename state_variable_t>
+const Core::ParameterBool RecurrentLanguageModel<value_t, state_variable_t>::paramDumpScores("dump-scores", "write all scores from this LM to disk", false);
+
+template<typename value_t, typename state_variable_t>
+const Core::ParameterString RecurrentLanguageModel<value_t, state_variable_t>::paramDumpScoresPrefix("dump-scores-prefix", "prefix for the score dumps", "scores");
+
+template<typename value_t, typename state_variable_t>
+const Core::ParameterBool RecurrentLanguageModel<value_t, state_variable_t>::paramLogMemory("log-memory", "wether memory usage from nn-outputs / states should be logged", false);
+
+template<typename value_t, typename state_variable_t>
+const Core::ParameterBool RecurrentLanguageModel<value_t, state_variable_t>::paramFreeMemory("free-memory", "wether nn-outputs should be deleted after some delay", false);
+
+template<typename value_t, typename state_variable_t>
+const Core::ParameterInt RecurrentLanguageModel<value_t, state_variable_t>::paramFreeMemoryDelay("free-memory-delay", "how many time frames without usage before nn-outputs are deleted", 40);
+
+template<typename value_t, typename state_variable_t>
+const Core::ParameterBool RecurrentLanguageModel<value_t, state_variable_t>::paramAsync("async", "wether to forward histories in a separate thread", false);
+
+template<typename value_t, typename state_variable_t>
+const Core::ParameterBool RecurrentLanguageModel<value_t, state_variable_t>::paramSingleStepOnly("single-step-only", "workaround for some bug that results in wrong scores when recombination is done in combination with async evaluation", false);
+
+template<typename value_t, typename state_variable_t>
+const Core::ParameterBool RecurrentLanguageModel<value_t, state_variable_t>::paramVerbose("verbose", "wether to print detailed statistics to stderr", false);
+
+template<typename value_t, typename state_variable_t>
+RecurrentLanguageModel<value_t, state_variable_t>::RecurrentLanguageModel(Core::Configuration const& c, Bliss::LexiconRef l, std::unique_ptr<AbstractStateManager<value_t, state_variable_t>> state_manager)
+        : Core::Component(c),
+          Precursor(c, l),
+          transform_output_log_(paramTransformOuputLog(config)),
+          transform_output_negate_(paramTransformOuputNegate(config)),
+          min_batch_size_(paramMinBatchSize(config)),
+          opt_batch_size_(paramOptBatchSize(config)),
+          max_batch_size_(paramMaxBatchSize(config)),
+          history_pruning_threshold_(paramHistoryPruningThreshold(config)),
+          pruned_history_length_(paramPrunedHistoryLength(config)),
+          batch_pruning_threshold_(paramBatchPruningThreshold(config)),
+          allow_reduced_history_(paramAllowReducedHistory(config)),
+          dump_inputs_(paramDumpInputs(config)),
+          dump_inputs_prefix_(paramDumpInputsPrefix(config)),
+          dump_scores_(paramDumpScores(config)),
+          dump_scores_prefix_(paramDumpScoresPrefix(config)),
+          log_memory_(paramLogMemory(config)),
+          free_memory_(paramFreeMemory(config)),
+          free_memory_delay_(paramFreeMemoryDelay(config)),
+          single_step_only_(paramSingleStepOnly(config)),
+          verbose_(paramVerbose(config)),
+          statistics_(config, "statistics"),
+          current_time_(0u),
+          run_time_(max_batch_size_, 0.0),
+          run_count_(max_batch_size_, 0ul),
+          total_wait_time_(0.0),
+          total_start_frame_time_(0.0),
+          total_expand_hist_time_(0.0),
+          fwd_statistics_(),
+          dump_inputs_counter_(0ul),
+          state_manager_(std::move(state_manager)),
+          output_transform_function_(),
+          state_comp_vec_factory_(Lm::Module::instance().createCompressedVectorFactory(select("state-compression"))),
+          nn_output_comp_vec_factory_(Lm::Module::instance().createCompressedVectorFactory(select("nn-output-compression"))),
+          empty_history_(),
+          should_stop_(false),
+          background_forwarder_thread_(),
+          async_(paramAsync(config)),
+          to_fwd_(nullptr),
+          to_fwd_finished_(),
+          pending_(),
+          fwd_queue_(32768),
+          finished_queue_(32768) {
+    if (transform_output_log_ and transform_output_negate_) {
+        output_transform_function_ = [](Score v) {
+            return -std::log(v);
+        };
+    }
+    else if (transform_output_log_) {
+        output_transform_function_ = [](Score v) {
+            return std::log(v);
+        };
+    }
+    else if (transform_output_negate_) {
+        output_transform_function_ = [](Score v) {
+            return -v;
+        };
+    }
+
+    if (async_) {
+        background_forwarder_thread_ = std::thread(std::bind(&RecurrentLanguageModel<value_t, state_variable_t>::background_forward, this));
+    }
+
+    require_le(pruned_history_length_, history_pruning_threshold_);
+}
+
+template<typename value_t, typename state_variable_t>
+RecurrentLanguageModel<value_t, state_variable_t>::~RecurrentLanguageModel() {
+    detail::clear_queue<value_t, state_variable_t>(finished_queue_);
+
+    if (async_) {
+        should_stop_ = true;
+        background_forwarder_thread_.join();
+    }
+
+    size_t total_run_count = 0ul;
+    size_t total_fwd_hist  = 0ul;
+    double total_run_time  = 0.0;
+
+    statistics_ << Core::XmlOpen("fwd-time");
+    for (size_t i = 0ul; i < run_count_.size(); i++) {
+        if (run_count_[i] > 0ul) {
+            statistics_ << (i + 1) << " " << run_count_[i] << " " << run_time_[i] << "\n";
+            total_run_count += run_count_[i];
+            total_fwd_hist += (i + 1) * run_count_[i];
+            total_run_time += run_time_[i];
+        }
+    }
+    statistics_ << Core::XmlClose("fwd-time");
+
+    statistics_ << Core::XmlOpen("fwd-summary");
+    statistics_ << Core::XmlOpen("total-run-count") << total_run_count << Core::XmlClose("total-run-count");
+    statistics_ << Core::XmlOpen("total-fwd-hist") << total_fwd_hist << Core::XmlClose("total-fwd-hist");
+    statistics_ << Core::XmlOpen("total-run-time") + Core::XmlAttribute("unit", "milliseconds") << total_run_time << Core::XmlClose("total-run-time");
+    statistics_ << Core::XmlOpen("total-wait-time") + Core::XmlAttribute("unit", "milliseconds") << total_wait_time_ << Core::XmlClose("total-wait-time");
+    statistics_ << Core::XmlOpen("total-start-frame-time") + Core::XmlAttribute("unit", "milliseconds") << total_start_frame_time_ << Core::XmlClose("total-start-frame-time");
+    statistics_ << Core::XmlOpen("total-expand-hist-time") + Core::XmlAttribute("unit", "milliseconds") << total_expand_hist_time_ << Core::XmlClose("total-expand-hist-time");
+    statistics_ << Core::XmlOpen("fwd-times");
+    fwd_statistics_.write(statistics_);
+    statistics_ << Core::XmlClose("fwd-times");
+    statistics_ << Core::XmlClose("fwd-summary");
+}
+
+template<typename value_t, typename state_variable_t>
+History RecurrentLanguageModel<value_t, state_variable_t>::startHistory() const {
+    NNHistoryManager*  hm = dynamic_cast<NNHistoryManager*>(historyManager_);
+    TokenIdSequence    ts(1ul, lexicon_mapping_[sentenceBeginToken()->id()]);
+    HistoryHandle      h     = hm->get<ScoresWithContext>(ts);
+    ScoresWithContext* cache = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(h));
+    cache->parent            = empty_history_;
+    History hist(history(h));
+    return hist;
+}
+
+template<typename value_t, typename state_variable_t>
+void RecurrentLanguageModel<value_t, state_variable_t>::setEmptyHistory() {
+    NNHistoryManager*  hm = dynamic_cast<NNHistoryManager*>(historyManager_);
+    TokenIdSequence    ts;
+    HistoryHandle      h     = hm->get<ScoresWithContext>(ts);
+    ScoresWithContext* cache = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(h));
+    cache->state             = state_manager_->initialState(state_variables_, *state_comp_vec_factory_);
+
+    if (cache->state.empty()) {
+        error("LM has no state variables. Did you forget to compile with 'initial_state': 'keep_over_epoch_no_init' for TensorFlow or 'initial_state': 'placeholder' for Onnx?");
+    }
+
+    std::vector<f32> temp(1);
+    auto             compression_param_estimator = nn_output_comp_vec_factory_->getEstimator();
+    compression_param_estimator->accumulate(temp.data(), temp.size());
+    auto compression_params = compression_param_estimator->estimate();
+    // pretend this history has already been evaluated
+    cache->nn_output = nn_output_comp_vec_factory_->compress(temp.data(), temp.size(), compression_params.get());
+    cache->computed.store(true);
+    cache->last_used = std::numeric_limits<Search::TimeframeIndex>::max();
+    empty_history_   = history(h);
+}
+
+template<typename value_t, typename state_variable_t>
+History RecurrentLanguageModel<value_t, state_variable_t>::extendedHistory(History const& hist, Token w) const {
+    return extendedHistory(hist, w->id());
+}
+
+template<typename value_t, typename state_variable_t>
+History RecurrentLanguageModel<value_t, state_variable_t>::extendedHistory(History const& hist, Bliss::Token::Id w) const {
+    return extendHistoryWithOutputIdx(hist, lexicon_mapping_[w]);
+}
+
+template<typename value_t, typename state_variable_t>
+History RecurrentLanguageModel<value_t, state_variable_t>::reducedHistory(History const& hist, u32 limit) const {
+    ScoresWithContext const* sc = reinterpret_cast<ScoresWithContext const*>(hist.handle());
+    if (not allow_reduced_history_ or sc->history->size() <= limit) {
+        return hist;
+    }
+    History h = startHistory();
+    for (u32 w = limit; w > 0; w--) {
+        h = extendHistoryWithOutputIdx(h, sc->history->at(sc->history->size() - w));
+    }
+    return h;
+}
+
+template<typename value_t, typename state_variable_t>
+History RecurrentLanguageModel<value_t, state_variable_t>::reduceHistoryByN(History const& hist, u32 n) const {
+    if (not allow_reduced_history_) {
+        return hist;
+    }
+    ScoresWithContext const* sc = reinterpret_cast<ScoresWithContext const*>(hist.handle());
+    History                  h  = startHistory();
+    for (u32 w = n; w < sc->history->size(); w++) {
+        h = extendHistoryWithOutputIdx(h, sc->history->at(w));
+    }
+    return h;
+}
+
+template<typename value_t, typename state_variable_t>
+Score RecurrentLanguageModel<value_t, state_variable_t>::score(History const& hist, Token w) const {
+    ScoresWithContext* sc = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(hist.handle()));
+
+    if (not sc->computed.load()) {
+        auto start = std::chrono::steady_clock::now();
+        if (async_) {
+            // promise should only be used once
+            to_fwd_finished_                   = std::promise<History const*>();
+            std::future<History const*> future = to_fwd_finished_.get_future();
+            to_fwd_.store(&hist);
+            future.wait();
+        }
+        else {
+            forward<false>(&hist);
+        }
+        auto   end       = std::chrono::steady_clock::now();
+        double wait_time = std::chrono::duration<double, std::milli>(end - start).count();
+        total_wait_time_ += wait_time;
+        if (verbose_) {
+            std::cerr << "wait: " << wait_time << " " << sc->info.numStates << " " << sc->info.bestScoreOffset << std::endl;
+        }
+    }
+
+    require(sc->computed.load());
+
+    size_t output_idx = lexicon_mapping_[w->id()];
+    useOutput(*sc, output_idx);
+    sc->last_used  = current_time_;
+    auto  start    = std::chrono::steady_clock::now();
+    Score score    = output_transform_function_(transformOutput(sc->nn_output, output_idx));
+    auto  end      = std::chrono::steady_clock::now();
+    auto  duration = std::chrono::duration<double, std::milli>(end - start);
+    fwd_statistics_.softmax_output_duration += duration;
+    fwd_statistics_.total_duration += duration;
+    return score;
+}
+
+template<typename value_t, typename state_variable_t>
+bool RecurrentLanguageModel<value_t, state_variable_t>::scoreCached(History const& hist, Token w) const {
+    ScoresWithContext const* sc = reinterpret_cast<ScoresWithContext const*>(hist.handle());
+    return sc->computed.load();
+}
+
+template<typename value_t, typename state_variable_t>
+void RecurrentLanguageModel<value_t, state_variable_t>::load() {
+    loadVocabulary();
+}
+
+template<typename value_t, typename state_variable_t>
+void RecurrentLanguageModel<value_t, state_variable_t>::startFrame(Search::TimeframeIndex time) const {
+    auto timer_start = std::chrono::steady_clock::now();
+
+    current_time_ = time;
+
+    size_t nn_output_cache_size = 0ul;
+    size_t state_cache_size     = 0ul;
+    size_t num_histories        = 0ul;
+
+    detail::clear_queue<value_t, state_variable_t>(finished_queue_);
+
+    NNHistoryManager* hm = dynamic_cast<NNHistoryManager*>(historyManager_);
+    hm->visit([&](HistoryHandle h) {
+        num_histories += 1ul;
+        ScoresWithContext* c        = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(h));
+        bool               computed = c->computed.load();
+        if (free_memory_ and computed and c->was_expanded and c->info.numStates == 0 and c->last_used < current_time_ - std::min(free_memory_delay_, current_time_)) {
+            c->nn_output->clear();
+            c->computed.store(false);
+        }
+        else if (async_ and not computed and not(c->was_expanded and c->info.numStates == 0)) {
+            fwd_queue_.enqueue(new History(history(h)));
+        }
+        if (c->nn_output) {
+            nn_output_cache_size += c->nn_output->usedMemory();
+        }
+        for (auto const& state_vec : c->state) {
+            if (state_vec) {
+                state_cache_size += state_vec->usedMemory();
+            }
+        }
+    });
+
+    if (log_memory_ and statistics_.isOpen()) {
+        statistics_ << Core::XmlOpen("memory-usage") + Core::XmlAttribute("time-frame", current_time_);
+        statistics_ << Core::XmlOpen("nn-output-cache-size") + Core::XmlAttribute("unit", "MB") << (nn_output_cache_size / (1024. * 1024.)) << Core::XmlClose("nn-output-cache-size");
+        statistics_ << Core::XmlOpen("state-cache-size") + Core::XmlAttribute("unit", "MB") << (state_cache_size / (1024. * 1024.)) << Core::XmlClose("state-cache-size");
+        statistics_ << Core::XmlOpen("num-histories") << num_histories << Core::XmlClose("num-histories");
+        statistics_ << Core::XmlClose("memory-usage");
+    }
+
+    auto   timer_end            = std::chrono::steady_clock::now();
+    double start_frame_duration = std::chrono::duration<double, std::milli>(timer_end - timer_start).count();
+    total_start_frame_time_ += start_frame_duration;
+}
+
+template<typename value_t, typename state_variable_t>
+void RecurrentLanguageModel<value_t, state_variable_t>::setInfo(History const& hist, SearchSpaceInformation const& info) const {
+    ScoresWithContext* sc = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(hist.handle()));
+    sc->info              = info;
+    sc->last_info         = current_time_;
+}
+
+template<typename value_t, typename state_variable_t>
+History RecurrentLanguageModel<value_t, state_variable_t>::extendHistoryWithOutputIdx(History const& hist, size_t w) const {
+    auto                     timer_start = std::chrono::steady_clock::now();
+    NNHistoryManager*        hm          = dynamic_cast<NNHistoryManager*>(historyManager_);
+    ScoresWithContext const* sc          = reinterpret_cast<ScoresWithContext const*>(hist.handle());
+    TokenIdSequence          ts(*sc->history);
+    ts.push_back(w);
+    HistoryHandle      h     = hm->get<ScoresWithContext>(ts);
+    ScoresWithContext* cache = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(h));
+    if (cache->parent.handle() == nullptr) {
+        cache->parent                   = hist;
+        ScoresWithContext* parent_cache = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(hist.handle()));
+        parent_cache->was_expanded      = true;
+        if (async_) {
+            fwd_queue_.enqueue(new History(history(h)));
+        }
+    }
+    History ext_hist(history(h));
+    if (cache->history->size() > history_pruning_threshold_) {
+        ext_hist = reducedHistory(ext_hist, pruned_history_length_);
+    }
+    auto   timer_end        = std::chrono::steady_clock::now();
+    double expand_hist_time = std::chrono::duration<double, std::milli>(timer_end - timer_start).count();
+    total_expand_hist_time_ += expand_hist_time;
+    return ext_hist;
+}
+
+template<typename value_t, typename state_variable_t>
+void RecurrentLanguageModel<value_t, state_variable_t>::background_forward() const {
+    while (not should_stop_) {
+        forward<true>(to_fwd_.exchange(nullptr));
+    }
+    History const* h = nullptr;
+    while (fwd_queue_.try_dequeue(h)) {
+        finished_queue_.enqueue(h);
+    }
+    for (History const* h : pending_) {
+        finished_queue_.enqueue(h);
+    }
+    pending_.clear();
+}
+
+template<typename value_t, typename state_variable_t>
+template<bool async>
+void RecurrentLanguageModel<value_t, state_variable_t>::forward(Lm::History const* hist) const {
+    ScoresWithContext* sc = nullptr;
+    if (hist != nullptr) {
+        sc = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(hist->handle()));
+    }
+    if (async and sc != nullptr and sc->computed.load()) {  // nothing to do (only happens in async case)
+        to_fwd_finished_.set_value(hist);
+        return;
+    }
+    auto start = std::chrono::steady_clock::now();
+
+    detail::RequestGraph request_graph;
+    if (sc != nullptr) {
+        request_graph.add_cache(const_cast<ScoresWithContext*>(sc));
+    }
+
+    std::vector<detail::FwdRequest> requests;
+    std::vector<Lm::History>        request_histories;  // make sure none of the request caches go away while we compute the scores
+    size_t                          max_length = 0ul;
+
+    size_t                          num_pending_requests = pending_.size();
+    std::unordered_set<void const*> handles;  // only relevant in async case
+    handles.reserve(pending_.size());
+    std::vector<ScoresWithContext*> early_requests;
+    std::vector<History const*>     early_request_histories;  // make sure none of the request caches go away while we compute the scores (only relevant in async case)
+
+    if (async) {
+        auto process_hist = [&](History const* hist) {
+            ScoresWithContext* c        = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(hist->handle()));
+            ScoresWithContext* parent_c = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(c->parent.handle()));
+            if (handles.find(hist->handle()) == handles.end() and not c->computed.load() and c != sc and c->parent.handle() != nullptr and c->ref_count > 1 and (not single_step_only_ or parent_c->computed.load())) {
+                early_requests.emplace_back(c);
+                early_request_histories.emplace_back(hist);
+                handles.insert(hist->handle());
+            }
+            else {
+                finished_queue_.enqueue(hist);
+            }
+        };
+
+        std::for_each(pending_.begin(), pending_.end(), process_hist);
+        pending_.clear();
+
+        History const* hist_buf = nullptr;
+        bool           success  = false;
+        bool           first    = true;
+        do {
+            if (first) {
+                success = fwd_queue_.wait_dequeue_timed(hist_buf, 1000);
+            }
+            else {
+                success = fwd_queue_.try_dequeue(hist_buf);
+            }
+            if (success) {
+                process_hist(hist_buf);
+                first = false;
+            }
+        } while (success);
+    }
+    else {
+        NNHistoryManager* hm = dynamic_cast<NNHistoryManager*>(historyManager_);
+        hm->visit([&](HistoryHandle h) {
+            ScoresWithContext* c = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(h));
+            if (not c->computed.load() and c != sc and not(c->was_expanded and c->info.numStates == 0)) {
+                early_requests.emplace_back(c);
+            }
+        });
+    }
+
+    size_t num_early_requests = early_requests.size();
+
+    auto end_early_requests = std::chrono::steady_clock::now();
+
+    if (async and sc == nullptr and early_requests.empty()) {
+        // can only happen in async case
+        return;
+    }
+
+    // because the scores can be updated while we are sorting we need to store them, so we get a consistent view
+    std::vector<std::pair<unsigned, Score>> idxs;
+    idxs.reserve(early_requests.size());
+    for (size_t i = 0ul; i < early_requests.size(); i++) {
+        idxs.emplace_back(i, early_requests[i]->info.minLabelDistance * 1000 + early_requests[i]->info.bestScoreOffset);
+    }
+    std::sort(idxs.begin(), idxs.end(), [](std::pair<size_t, Score> const& a, std::pair<size_t, Score> const& b) {
+        return a.second < b.second;
+    });
+
+    for (auto idx : idxs) {
+        request_graph.add_cache(early_requests[idx.first]);
+    }
+
+    // we do not need early_requests anymore
+    early_requests.clear();
+    idxs.clear();
+
+    requests = request_graph.get_requests();
+
+    // prune requests
+    if (min_batch_size_ > 0ul and requests.size() > min_batch_size_) {
+        size_t i         = min_batch_size_;
+        Score  ref_score = requests.front().final_cache->info.bestScoreOffset + batch_pruning_threshold_;
+        if (not Math::isinf(ref_score)) {
+            while ((i + 1) < requests.size() and requests[i + 1].final_cache->info.bestScoreOffset <= ref_score) {
+                i += 1ul;
+            }
+            requests.resize(i);
+        }
+    }
+
+    if (min_batch_size_ > 0ul and opt_batch_size_ > 0ul and requests.size() > opt_batch_size_ + min_batch_size_) {
+        requests.resize(opt_batch_size_);
+    }
+    if (max_batch_size_ > 0ul and requests.size() > max_batch_size_) {
+        requests.resize(max_batch_size_);
+    }
+
+    Score worst_score = std::numeric_limits<Score>::min();
+    for (auto const& r : requests) {
+        max_length  = std::max(max_length, r.length);
+        worst_score = std::max(worst_score, r.final_cache->info.bestScoreOffset);
+    }
+
+    auto end_requests = std::chrono::steady_clock::now();
+
+    // prepare the data in Sprint Datastructures
+    Math::FastMatrix<s32> words(requests.size(), max_length);
+    Math::FastVector<s32> word_lengths(requests.size());
+    for (size_t r = 0ul; r < requests.size(); r++) {
+        auto&  history = *(requests[r].final_cache->history);
+        size_t offset  = history.size() - requests[r].length;
+        for (size_t w = 0u; w < requests[r].length; w++) {
+            words.at(r, w) = static_cast<s32>(history[offset + w]);
+        }
+        for (size_t w = requests[r].length; w < max_length; w++) {
+            words.at(r, w) = 0;
+        }
+        word_lengths[r]                  = requests[r].length;
+        ScoresWithContext* initial_cache = requests[r].initial_cache;
+        require(initial_cache != nullptr);
+        require_eq(state_variables_.size(), initial_cache->state.size());
+    }
+
+    bool   full_prefix_required = state_manager_->requiresAllParentStates();
+    size_t total_prefix_length  = 0ul;
+    size_t total_suffix_length  = 0ul;
+
+    std::vector<size_t> prefix_lengths(requests.size());
+    std::vector<size_t> suffix_lengths(requests.size());
+    for (size_t r = 0ul; r < requests.size(); r++) {
+        prefix_lengths[r] = requests[r].initial_cache->history->size();
+        suffix_lengths[r] = requests[r].length;
+        total_prefix_length += prefix_lengths[r];
+        total_suffix_length += suffix_lengths[r];
+    }
+
+    std::vector<typename AbstractStateManager<value_t, state_variable_t>::HistoryState const*> prefix_states(full_prefix_required ? total_prefix_length : requests.size());
+    size_t                                                                                     current_offset = 0ul;
+    for (size_t r = 0ul; r < requests.size(); r++) {
+        ScoresWithContext* current_cache = requests[r].initial_cache;
+        if (full_prefix_required) {
+            size_t prefix_length = prefix_lengths[r];
+            for (size_t i = 0ul; i < prefix_length; i++) {
+                prefix_states[current_offset + prefix_length - i - 1] = &current_cache->state;
+                current_cache                                         = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(current_cache->parent.handle()));
+            }
+            current_offset += prefix_length;
+        }
+        else {
+            prefix_states[r] = &current_cache->state;
+        }
+    }
+
+    auto end_prepare = std::chrono::steady_clock::now();
+
+    // build tensors + set state variables
+    std::vector<std::pair<std::string, value_t>> inputs;
+    std::vector<std::string>                     targets;
+    state_manager_->mergeStates(state_variables_, prefix_lengths, prefix_states, inputs, targets);
+
+    std::vector<s32> state_lengths(prefix_lengths.begin(), prefix_lengths.end());
+
+    if (dump_inputs_) {
+        std::string out = dump_inputs_prefix_ + "_" + std::to_string(dump_inputs_counter_) + "_state_";
+        for (size_t i = 0ul; i < inputs.size(); i++) {
+            inputs[i].second.template save<s16>(out + std::to_string(i));
+        }
+    }
+
+    auto end_merge_state = std::chrono::steady_clock::now();
+
+    setState(inputs, targets);
+
+    auto end_set_state = std::chrono::steady_clock::now();
+
+    extendInputs(inputs, words, word_lengths, state_lengths);
+    extendTargets(targets);
+
+    std::vector<value_t> outputs;
+    getOutputs(inputs, outputs, targets);
+
+    if (dump_inputs_) {
+        std::string out = dump_inputs_prefix_ + "_" + std::to_string(dump_inputs_counter_) + "_nn_in_";
+        for (size_t i = 0ul; i < inputs.size(); i++) {
+            inputs[i].second.template save<s32>(out + std::to_string(i));
+        }
+        out = dump_inputs_prefix_ + "_" + std::to_string(dump_inputs_counter_) + "_nn_out_";
+        for (size_t i = 0ul; i < outputs.size(); i++) {
+            outputs[i].template save<f32>(out + std::to_string(i));
+        }
+        dump_inputs_counter_ += 1ul;
+    }
+
+    auto end_nn_output = std::chrono::steady_clock::now();
+
+    // store outputs in caches
+    for (size_t r = 0ul; r < requests.size(); r++) {
+        ScoresWithContext* cache = requests[r].final_cache;
+        // only final cache get the states
+        for (size_t w = requests[r].length; w > 0;) {
+            --w;
+            cache->last_used                         = current_time_;
+            int          num_outputs                 = outputs[0ul].dimSize(2);
+            auto         compression_param_estimator = nn_output_comp_vec_factory_->getEstimator();
+            float const* data                        = outputs[0ul].template data<f32>(r, w, 0);
+            compression_param_estimator->accumulate(data, num_outputs);
+            auto compression_params = compression_param_estimator->estimate();
+            cache->nn_output        = nn_output_comp_vec_factory_->compress(data, num_outputs, compression_params.get());
+            cache->computed.store(true);
+            cache = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(cache->parent.handle()));
+        }
+        require_eq(cache, requests[r].initial_cache);
+    }
+
+    auto end_set_nn_output = std::chrono::steady_clock::now();
+
+    // fetch new values of state variables, needs to be done in separate Session::run call (for GPU devices)
+    std::vector<value_t> state_vars = fetchStates(outputs);
+
+    auto end_get_new_state = std::chrono::steady_clock::now();
+
+    auto split_states = state_manager_->splitStates(state_variables_, suffix_lengths, state_vars, *state_comp_vec_factory_);
+
+    size_t output_offset = 0ul;
+    for (size_t r = 0ul; r < requests.size(); r++) {
+        ScoresWithContext* current_cache = requests[r].final_cache;
+        size_t             suffix_length = suffix_lengths[r];
+        while (suffix_length > 0ul) {
+            current_cache->state = std::move(split_states[output_offset + suffix_length - 1]);
+            current_cache        = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(current_cache->parent.handle()));
+            suffix_length -= 1ul;
+        }
+        output_offset += suffix_lengths[r];
+    }
+
+    auto end_split_state = std::chrono::steady_clock::now();
+
+    std::chrono::duration<double, std::milli> duration = end_split_state - end_prepare;
+    size_t                                    bucket   = requests.size() - 1;
+    run_time_.at(bucket) += duration.count();
+    run_count_.at(bucket) += 1ul;
+
+    if (dump_scores_) {
+        for (auto const& r : requests) {
+            detail::dump_scores(*r.final_cache, dump_scores_prefix_);
+        }
+    }
+
+    if (async) {
+        for (auto hist : early_request_histories) {
+            ScoresWithContext* c = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(hist->handle()));
+            if (c->computed.load() or c->ref_count == 1ul or c->info.numStates == 0) {
+                finished_queue_.enqueue(hist);
+            }
+            else {
+                pending_.push_back(hist);
+            }
+        }
+        if (sc != nullptr) {
+            to_fwd_finished_.set_value(hist);
+        }
+    }
+
+    auto end = std::chrono::steady_clock::now();
+
+    detail::TimeStatistics stats;
+    stats.total_duration          = std::chrono::duration<double, std::milli>(end - start);
+    stats.early_request_duration  = std::chrono::duration<double, std::milli>(end_early_requests - start);
+    stats.request_duration        = std::chrono::duration<double, std::milli>(end_requests - end_early_requests);
+    stats.prepare_duration        = std::chrono::duration<double, std::milli>(end_prepare - end_requests);
+    stats.merge_state_duration    = std::chrono::duration<double, std::milli>(end_merge_state - end_prepare);
+    stats.set_state_duration      = std::chrono::duration<double, std::milli>(end_set_state - end_merge_state);
+    stats.run_nn_output_duration  = std::chrono::duration<double, std::milli>(end_nn_output - end_set_state);
+    stats.set_nn_output_duration  = std::chrono::duration<double, std::milli>(end_set_nn_output - end_nn_output);
+    stats.get_new_state_duration  = std::chrono::duration<double, std::milli>(end_get_new_state - end_set_nn_output);
+    stats.split_state_duration    = std::chrono::duration<double, std::milli>(end_split_state - end_get_new_state);
+    stats.softmax_output_duration = std::chrono::duration<double, std::milli>();
+    if (verbose_) {
+        stats.write(std::cerr);
+        std::cerr << " #pr:" << num_pending_requests
+                  << " #er:" << num_early_requests
+                  << " #r:" << requests.size() << std::endl;
+    }
+    fwd_statistics_ += stats;
+}
+
+}  // namespace Lm
+
+#endif  // _LM_RECURRENT_LANGUAGE_MODEL_HH
diff --git a/src/Lm/ReducedPrecisionCompressedVectorFactory.hh b/src/Lm/ReducedPrecisionCompressedVectorFactory.hh
index a4732f8d6..21563e117 100644
--- a/src/Lm/ReducedPrecisionCompressedVectorFactory.hh
+++ b/src/Lm/ReducedPrecisionCompressedVectorFactory.hh
@@ -24,7 +24,8 @@ namespace Lm {
 class ReducedBitsFloatVector : public CompressedVector<float> {
 public:
     ReducedBitsFloatVector(unsigned drop_bits)
-            : drop_bits_(drop_bits), bits_per_val_(sizeof(float) * 8 - drop_bits_) {
+            : drop_bits_(drop_bits),
+              bits_per_val_(sizeof(float) * 8 - drop_bits_) {
     }
 
     virtual size_t size() const;
@@ -49,7 +50,8 @@ public:
     static const Core::ParameterInt paramDropBits;
 
     ReducedPrecisionCompressedVectorFactory(Core::Configuration const& config)
-            : Precursor(config), drop_bits_(paramDropBits(config)) {}
+            : Precursor(config),
+              drop_bits_(paramDropBits(config)) {}
     virtual ~ReducedPrecisionCompressedVectorFactory() = default;
 
     virtual CompressedVectorPtr<float> compress(float const* data, size_t size, CompressionParameters const* params) const;
diff --git a/src/Lm/StateManager.hh b/src/Lm/StateManager.hh
deleted file mode 100644
index 0efb14143..000000000
--- a/src/Lm/StateManager.hh
+++ /dev/null
@@ -1,63 +0,0 @@
-/** Copyright 2020 RWTH Aachen University. All rights reserved.
- *
- *  Licensed under the RWTH ASR License (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *      http://www.hltpr.rwth-aachen.de/rwth-asr/rwth-asr-license.html
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-#ifndef _LM_STATE_MANAGER_HH
-#define _LM_STATE_MANAGER_HH
-
-#include <Core/Component.hh>
-#include <Tensorflow/Graph.hh>
-#include <Tensorflow/Tensor.hh>
-
-#include "CompressedVector.hh"
-
-namespace Lm {
-
-class StateManager : public Core::Component {
-public:
-    using Precursor      = Core::Component;
-    using FeedDict       = std::vector<std::pair<std::string, Tensorflow::Tensor>>;
-    using TargetList     = std::vector<std::string>;
-    using StateVariables = std::vector<Tensorflow::Variable>;
-    using HistoryState   = std::vector<CompressedVectorPtr<float>>;
-
-    StateManager(Core::Configuration const& config);
-    virtual ~StateManager() = default;
-
-    virtual bool requiresAllParentStates() const;
-
-    virtual HistoryState              initialState(StateVariables const& vars, CompressedVectorFactory<float> const& vector_factory) = 0;
-    virtual void                      mergeStates(StateVariables const&                   vars,
-                                                  std::vector<size_t>&                    prefix_lengths,
-                                                  std::vector<HistoryState const*> const& prefix_states,
-                                                  FeedDict&                               feed_dict,
-                                                  TargetList&                             targets)                                                               = 0;
-    virtual std::vector<HistoryState> splitStates(StateVariables const&                  vars,
-                                                  std::vector<size_t>&                   suffix_lengths,
-                                                  std::vector<Tensorflow::Tensor> const& state_tensors,
-                                                  CompressedVectorFactory<float> const&  vector_factory)                              = 0;
-};
-
-// inline implementations
-
-inline bool StateManager::requiresAllParentStates() const {
-    return false;
-}
-
-inline StateManager::StateManager(Core::Configuration const& config)
-        : Precursor(config) {
-}
-
-}  // namespace Lm
-
-#endif  // _LM_STATE_MANAGER_HH
diff --git a/src/Lm/BlasNceSoftmaxAdapter.cc b/src/Lm/TFBlasNceSoftmaxAdapter.cc
similarity index 81%
rename from src/Lm/BlasNceSoftmaxAdapter.cc
rename to src/Lm/TFBlasNceSoftmaxAdapter.cc
index b8e188e3b..02a51f0c7 100644
--- a/src/Lm/BlasNceSoftmaxAdapter.cc
+++ b/src/Lm/TFBlasNceSoftmaxAdapter.cc
@@ -12,7 +12,7 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
-#include "BlasNceSoftmaxAdapter.hh"
+#include "TFBlasNceSoftmaxAdapter.hh"
 
 #include <Math/Blas.hh>
 
@@ -20,13 +20,13 @@
 
 namespace Lm {
 
-void BlasNceSoftmaxAdapter::init(Tensorflow::Session& session, Tensorflow::TensorInputMap const& input_map, Tensorflow::TensorOutputMap const& output_map) {
+void TFBlasNceSoftmaxAdapter::init(Tensorflow::Session& session, Tensorflow::TensorInputMap const& input_map, Tensorflow::TensorOutputMap const& output_map) {
     auto const& weight_tensor_info = output_map.get_info("weights");
     auto const& bias_tensor_info   = output_map.get_info("bias");
     session.run({}, {weight_tensor_info.tensor_name(), bias_tensor_info.tensor_name()}, {}, tensors_);
 }
 
-Score BlasNceSoftmaxAdapter::get_score(Lm::CompressedVectorPtr<float> const& nn_out, size_t output_idx) {
+Score TFBlasNceSoftmaxAdapter::get_score(Lm::CompressedVectorPtr<float> const& nn_out, size_t output_idx) {
     std::vector<float>                   nn_output;
     float const*                         data;
     Lm::UncompressedVector<float> const* vec = dynamic_cast<Lm::UncompressedVector<float> const*>(nn_out.get());
@@ -46,7 +46,7 @@ Score BlasNceSoftmaxAdapter::get_score(Lm::CompressedVectorPtr<float> const& nn_
     return result;
 }
 
-std::vector<Score> BlasNceSoftmaxAdapter::get_scores(Lm::CompressedVectorPtr<float> const& nn_out, std::vector<size_t> const& output_idxs) {
+std::vector<Score> TFBlasNceSoftmaxAdapter::get_scores(Lm::CompressedVectorPtr<float> const& nn_out, std::vector<size_t> const& output_idxs) {
     std::vector<float> nn_output(nn_out->size());
     nn_out->uncompress(nn_output.data(), nn_output.size());
 
diff --git a/src/Lm/BlasNceSoftmaxAdapter.hh b/src/Lm/TFBlasNceSoftmaxAdapter.hh
similarity index 79%
rename from src/Lm/BlasNceSoftmaxAdapter.hh
rename to src/Lm/TFBlasNceSoftmaxAdapter.hh
index c62de4e56..226adbb36 100644
--- a/src/Lm/BlasNceSoftmaxAdapter.hh
+++ b/src/Lm/TFBlasNceSoftmaxAdapter.hh
@@ -15,16 +15,16 @@
 #ifndef _LM_BLAS_NCE_SOFTMAX_ADAPTER_HH
 #define _LM_BLAS_NCE_SOFTMAX_ADAPTER_HH
 
-#include "SoftmaxAdapter.hh"
+#include "TFSoftmaxAdapter.hh"
 
 namespace Lm {
 
-class BlasNceSoftmaxAdapter : public SoftmaxAdapter {
+class TFBlasNceSoftmaxAdapter : public TFSoftmaxAdapter {
 public:
-    using Precursor = SoftmaxAdapter;
+    using Precursor = TFSoftmaxAdapter;
 
-    BlasNceSoftmaxAdapter(Core::Configuration const& config);
-    virtual ~BlasNceSoftmaxAdapter() = default;
+    TFBlasNceSoftmaxAdapter(Core::Configuration const& config);
+    virtual ~TFBlasNceSoftmaxAdapter() = default;
 
     virtual void               init(Tensorflow::Session& session, Tensorflow::TensorInputMap const& input_map, Tensorflow::TensorOutputMap const& output_map);
     virtual Score              get_score(Lm::CompressedVectorPtr<float> const& nn_out, size_t output_idx);
@@ -36,7 +36,7 @@ private:
 
 // inline implementations
 
-inline BlasNceSoftmaxAdapter::BlasNceSoftmaxAdapter(Core::Configuration const& config)
+inline TFBlasNceSoftmaxAdapter::TFBlasNceSoftmaxAdapter(Core::Configuration const& config)
         : Precursor(config) {
 }
 
diff --git a/src/Lm/TFLstmStateManager.cc b/src/Lm/TFLstmStateManager.cc
new file mode 100644
index 000000000..8b3f258dd
--- /dev/null
+++ b/src/Lm/TFLstmStateManager.cc
@@ -0,0 +1,14 @@
+
+#include "TFLstmStateManager.hh"
+
+namespace Lm {
+
+void TFLstmStateManager::extendFeedDict(FeedDict& feed_dict, Tensorflow::Variable const& state_var, Tensorflow::Tensor& var) {
+    feed_dict.emplace_back(state_var.initial_value_name, var);
+}
+
+void TFLstmStateManager::extendTargets(TargetList& targets, Tensorflow::Variable const& state_var) {
+    targets.emplace_back(state_var.initializer_name);
+}
+
+}  // namespace Lm
diff --git a/src/Lm/TFLstmStateManager.hh b/src/Lm/TFLstmStateManager.hh
new file mode 100644
index 000000000..342920870
--- /dev/null
+++ b/src/Lm/TFLstmStateManager.hh
@@ -0,0 +1,31 @@
+#ifndef _LM_TF_LSTM_STATE_MANAGER_HH
+#define _LM_TF_LSTM_STATE_MANAGER_HH
+
+#include <Tensorflow/Graph.hh>
+#include <Tensorflow/Tensor.hh>
+
+#include "LstmStateManager.hh"
+
+namespace Lm {
+
+class TFLstmStateManager : public LstmStateManager<Tensorflow::Tensor, Tensorflow::Variable> {
+public:
+    using Precursor = LstmStateManager<Tensorflow::Tensor, Tensorflow::Variable>;
+
+    TFLstmStateManager(Core::Configuration const& config);
+    virtual ~TFLstmStateManager() = default;
+
+protected:
+    virtual void extendFeedDict(FeedDict& feed_dict, Tensorflow::Variable const& state_var, Tensorflow::Tensor& var);
+    virtual void extendTargets(TargetList& targets, Tensorflow::Variable const& state_var);
+};
+
+// inline implementations
+
+inline TFLstmStateManager::TFLstmStateManager(Core::Configuration const& config)
+        : Precursor(config) {
+}
+
+}  // namespace Lm
+
+#endif  // _LM_TF_LSTM_STATE_MANAGER_HH
diff --git a/src/Lm/NceSoftmaxAdapter.cc b/src/Lm/TFNceSoftmaxAdapter.cc
similarity index 82%
rename from src/Lm/NceSoftmaxAdapter.cc
rename to src/Lm/TFNceSoftmaxAdapter.cc
index 948a5c2c9..20758ce45 100644
--- a/src/Lm/NceSoftmaxAdapter.cc
+++ b/src/Lm/TFNceSoftmaxAdapter.cc
@@ -12,22 +12,22 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
-#include "NceSoftmaxAdapter.hh"
+#include "TFNceSoftmaxAdapter.hh"
 
 namespace Lm {
 
-void NceSoftmaxAdapter::init(Tensorflow::Session& session, Tensorflow::TensorInputMap const& input_map, Tensorflow::TensorOutputMap const& output_map) {
+void TFNceSoftmaxAdapter::init(Tensorflow::Session& session, Tensorflow::TensorInputMap const& input_map, Tensorflow::TensorOutputMap const& output_map) {
     session_    = &session;
     input_map_  = &input_map;
     output_map_ = &output_map;
 }
 
-Score NceSoftmaxAdapter::get_score(Lm::CompressedVectorPtr<float> const& nn_out, size_t output_idx) {
+Score TFNceSoftmaxAdapter::get_score(Lm::CompressedVectorPtr<float> const& nn_out, size_t output_idx) {
     std::vector<size_t> output_idxs(1, output_idx);
     return get_scores(nn_out, output_idxs)[0];
 }
 
-std::vector<Score> NceSoftmaxAdapter::get_scores(Lm::CompressedVectorPtr<float> const& nn_out, std::vector<size_t> const& output_idxs) {
+std::vector<Score> TFNceSoftmaxAdapter::get_scores(Lm::CompressedVectorPtr<float> const& nn_out, std::vector<size_t> const& output_idxs) {
     auto const& output_idx_tensor_info = input_map_->get_info("output_idxs");
     auto const& nn_output_tensor_info  = input_map_->get_info("nn_output");
     auto const& softmax_tensor_info    = output_map_->get_info("nce_softmax");
diff --git a/src/Lm/NceSoftmaxAdapter.hh b/src/Lm/TFNceSoftmaxAdapter.hh
similarity index 81%
rename from src/Lm/NceSoftmaxAdapter.hh
rename to src/Lm/TFNceSoftmaxAdapter.hh
index 68d686277..6e6f23ea8 100644
--- a/src/Lm/NceSoftmaxAdapter.hh
+++ b/src/Lm/TFNceSoftmaxAdapter.hh
@@ -15,16 +15,16 @@
 #ifndef _LM_NCE_SOFTMAX_ADAPTER_HH
 #define _LM_NCE_SOFTMAX_ADAPTER_HH
 
-#include "SoftmaxAdapter.hh"
+#include "TFSoftmaxAdapter.hh"
 
 namespace Lm {
 
-class NceSoftmaxAdapter : public SoftmaxAdapter {
+class TFNceSoftmaxAdapter : public TFSoftmaxAdapter {
 public:
-    using Precursor = SoftmaxAdapter;
+    using Precursor = TFSoftmaxAdapter;
 
-    NceSoftmaxAdapter(Core::Configuration const& config);
-    virtual ~NceSoftmaxAdapter() = default;
+    TFNceSoftmaxAdapter(Core::Configuration const& config);
+    virtual ~TFNceSoftmaxAdapter() = default;
 
     virtual void               init(Tensorflow::Session& session, Tensorflow::TensorInputMap const& input_map, Tensorflow::TensorOutputMap const& output_map);
     virtual Score              get_score(Lm::CompressedVectorPtr<float> const& nn_out, size_t output_idx);
@@ -38,7 +38,7 @@ private:
 
 // inline implementations
 
-inline NceSoftmaxAdapter::NceSoftmaxAdapter(Core::Configuration const& config)
+inline TFNceSoftmaxAdapter::TFNceSoftmaxAdapter(Core::Configuration const& config)
         : Precursor(config) {
 }
 
diff --git a/src/Lm/PassthroughSoftmaxAdapter.cc b/src/Lm/TFPassthroughSoftmaxAdapter.cc
similarity index 69%
rename from src/Lm/PassthroughSoftmaxAdapter.cc
rename to src/Lm/TFPassthroughSoftmaxAdapter.cc
index 565975c9f..c50a412ff 100644
--- a/src/Lm/PassthroughSoftmaxAdapter.cc
+++ b/src/Lm/TFPassthroughSoftmaxAdapter.cc
@@ -12,14 +12,14 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
-#include "PassthroughSoftmaxAdapter.hh"
+#include "TFPassthroughSoftmaxAdapter.hh"
 
 namespace Lm {
 
-void PassthroughSoftmaxAdapter::init(Tensorflow::Session& session, Tensorflow::TensorInputMap const& input_map, Tensorflow::TensorOutputMap const& output_map) {
+void TFPassthroughSoftmaxAdapter::init(Tensorflow::Session& session, Tensorflow::TensorInputMap const& input_map, Tensorflow::TensorOutputMap const& output_map) {
 }
 
-Score PassthroughSoftmaxAdapter::get_score(Lm::CompressedVectorPtr<float> const& nn_out, size_t output_idx) {
+Score TFPassthroughSoftmaxAdapter::get_score(Lm::CompressedVectorPtr<float> const& nn_out, size_t output_idx) {
     return nn_out->get(output_idx);
 }
 
diff --git a/src/Lm/PassthroughSoftmaxAdapter.hh b/src/Lm/TFPassthroughSoftmaxAdapter.hh
similarity index 76%
rename from src/Lm/PassthroughSoftmaxAdapter.hh
rename to src/Lm/TFPassthroughSoftmaxAdapter.hh
index 031666662..a65f4743c 100644
--- a/src/Lm/PassthroughSoftmaxAdapter.hh
+++ b/src/Lm/TFPassthroughSoftmaxAdapter.hh
@@ -15,16 +15,16 @@
 #ifndef _LM_PASSTHROUGH_SOFTMAX_ADAPTER_HH
 #define _LM_PASSTHROUGH_SOFTMAX_ADAPTER_HH
 
-#include "SoftmaxAdapter.hh"
+#include "TFSoftmaxAdapter.hh"
 
 namespace Lm {
 
-class PassthroughSoftmaxAdapter : public SoftmaxAdapter {
+class TFPassthroughSoftmaxAdapter : public TFSoftmaxAdapter {
 public:
-    using Precursor = SoftmaxAdapter;
+    using Precursor = TFSoftmaxAdapter;
 
-    PassthroughSoftmaxAdapter(Core::Configuration const& config);
-    virtual ~PassthroughSoftmaxAdapter() = default;
+    TFPassthroughSoftmaxAdapter(Core::Configuration const& config);
+    virtual ~TFPassthroughSoftmaxAdapter() = default;
 
     virtual void  init(Tensorflow::Session& session, Tensorflow::TensorInputMap const& input_map, Tensorflow::TensorOutputMap const& output_map);
     virtual Score get_score(Lm::CompressedVectorPtr<float> const& nn_out, size_t output_idx);
@@ -34,7 +34,7 @@ private:
 
 // inline implementations
 
-inline PassthroughSoftmaxAdapter::PassthroughSoftmaxAdapter(Core::Configuration const& config)
+inline TFPassthroughSoftmaxAdapter::TFPassthroughSoftmaxAdapter(Core::Configuration const& config)
         : Precursor(config) {
 }
 
diff --git a/src/Lm/QuantizedBlasNceSoftmaxAdapter.cc b/src/Lm/TFQuantizedBlasNceSoftmaxAdapter.cc
similarity index 90%
rename from src/Lm/QuantizedBlasNceSoftmaxAdapter.cc
rename to src/Lm/TFQuantizedBlasNceSoftmaxAdapter.cc
index 5dabe35b4..c9b672bcf 100644
--- a/src/Lm/QuantizedBlasNceSoftmaxAdapter.cc
+++ b/src/Lm/TFQuantizedBlasNceSoftmaxAdapter.cc
@@ -12,7 +12,7 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
-#include "QuantizedBlasNceSoftmaxAdapter.hh"
+#include "TFQuantizedBlasNceSoftmaxAdapter.hh"
 
 #include <immintrin.h>
 
@@ -50,19 +50,19 @@ float quantized_dot_16bit(size_t size, float scale, s16 const* a, s16 const* b)
 namespace Lm {
 
 template<>
-const Core::ParameterFloat QuantizedBlasNceSoftmaxAdapter16Bit::paramNNOutputEpsilon(
+const Core::ParameterFloat TFQuantizedBlasNceSoftmaxAdapter16Bit::paramNNOutputEpsilon(
         "nn-output-epsilon",
         "if the nn-output vector is not quantized, use this scale for quantization",
         0.001, 0.0);
 
 template<>
-const Core::ParameterFloat QuantizedBlasNceSoftmaxAdapter16Bit::paramWeightsBiasEpsilon(
+const Core::ParameterFloat TFQuantizedBlasNceSoftmaxAdapter16Bit::paramWeightsBiasEpsilon(
         "weights-bias-epsilon",
         "if the nn-output vector is not quantized, use this scale for quantization",
         0.001, 0.0);
 
 template<>
-Score QuantizedBlasNceSoftmaxAdapter16Bit::get_score(Lm::CompressedVectorPtr<float> const& nn_out, size_t output_idx) {
+Score TFQuantizedBlasNceSoftmaxAdapter16Bit::get_score(Lm::CompressedVectorPtr<float> const& nn_out, size_t output_idx) {
     std::vector<s16>                  nn_output;
     s16 const*                        data;
     float                             scale;
diff --git a/src/Lm/QuantizedBlasNceSoftmaxAdapter.hh b/src/Lm/TFQuantizedBlasNceSoftmaxAdapter.hh
similarity index 74%
rename from src/Lm/QuantizedBlasNceSoftmaxAdapter.hh
rename to src/Lm/TFQuantizedBlasNceSoftmaxAdapter.hh
index afc03aeaa..21465469b 100644
--- a/src/Lm/QuantizedBlasNceSoftmaxAdapter.hh
+++ b/src/Lm/TFQuantizedBlasNceSoftmaxAdapter.hh
@@ -18,20 +18,20 @@
 #include <Math/FastMatrix.hh>
 #include <Math/FastVector.hh>
 
-#include "SoftmaxAdapter.hh"
+#include "TFSoftmaxAdapter.hh"
 
 namespace Lm {
 
 template<typename T>
-class QuantizedBlasNceSoftmaxAdapter : public SoftmaxAdapter {
+class TFQuantizedBlasNceSoftmaxAdapter : public TFSoftmaxAdapter {
 public:
-    using Precursor = SoftmaxAdapter;
+    using Precursor = TFSoftmaxAdapter;
 
     static const Core::ParameterFloat paramNNOutputEpsilon;
     static const Core::ParameterFloat paramWeightsBiasEpsilon;
 
-    QuantizedBlasNceSoftmaxAdapter(Core::Configuration const& config);
-    virtual ~QuantizedBlasNceSoftmaxAdapter() = default;
+    TFQuantizedBlasNceSoftmaxAdapter(Core::Configuration const& config);
+    virtual ~TFQuantizedBlasNceSoftmaxAdapter() = default;
 
     virtual void  init(Tensorflow::Session& session, Tensorflow::TensorInputMap const& input_map, Tensorflow::TensorOutputMap const& output_map);
     virtual Score get_score(Lm::CompressedVectorPtr<float> const& nn_out, size_t output_idx);
@@ -44,18 +44,20 @@ private:
     Math::FastVector<float> bias_;
 };
 
-using QuantizedBlasNceSoftmaxAdapter16Bit = QuantizedBlasNceSoftmaxAdapter<s16>;
-using QuantizedBlasNceSoftmaxAdapter8Bit  = QuantizedBlasNceSoftmaxAdapter<s8>;
+using TFQuantizedBlasNceSoftmaxAdapter16Bit = TFQuantizedBlasNceSoftmaxAdapter<s16>;
+using TFQuantizedBlasNceSoftmaxAdapter8Bit  = TFQuantizedBlasNceSoftmaxAdapter<s8>;
 
 // inline implementations
 
 template<typename T>
-inline QuantizedBlasNceSoftmaxAdapter<T>::QuantizedBlasNceSoftmaxAdapter(Core::Configuration const& config)
-        : Precursor(config), nnOutputEpsilon_(paramNNOutputEpsilon(config)), weightsBiasEpsilon_(paramWeightsBiasEpsilon(config)) {
+inline TFQuantizedBlasNceSoftmaxAdapter<T>::TFQuantizedBlasNceSoftmaxAdapter(Core::Configuration const& config)
+        : Precursor(config),
+          nnOutputEpsilon_(paramNNOutputEpsilon(config)),
+          weightsBiasEpsilon_(paramWeightsBiasEpsilon(config)) {
 }
 
 template<typename T>
-inline void QuantizedBlasNceSoftmaxAdapter<T>::init(Tensorflow::Session& session, Tensorflow::TensorInputMap const& input_map, Tensorflow::TensorOutputMap const& output_map) {
+inline void TFQuantizedBlasNceSoftmaxAdapter<T>::init(Tensorflow::Session& session, Tensorflow::TensorInputMap const& input_map, Tensorflow::TensorOutputMap const& output_map) {
     auto const&                     weight_tensor_info = output_map.get_info("weights");
     auto const&                     bias_tensor_info   = output_map.get_info("bias");
     std::vector<Tensorflow::Tensor> tensors;
diff --git a/src/Lm/TFRecurrentLanguageModel.cc b/src/Lm/TFRecurrentLanguageModel.cc
index b465599fb..4b759fd47 100644
--- a/src/Lm/TFRecurrentLanguageModel.cc
+++ b/src/Lm/TFRecurrentLanguageModel.cc
@@ -1,145 +1,12 @@
-/** Copyright 2020 RWTH Aachen University. All rights reserved.
- *
- *  Licensed under the RWTH ASR License (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *      http://www.hltpr.rwth-aachen.de/rwth-asr/rwth-asr-license.html
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
 #include "TFRecurrentLanguageModel.hh"
 
-#include <functional>
-
-#include "BlasNceSoftmaxAdapter.hh"
-#include "LstmStateManager.hh"
-#include "Module.hh"
-#include "NceSoftmaxAdapter.hh"
-#include "PassthroughSoftmaxAdapter.hh"
-#include "QuantizedBlasNceSoftmaxAdapter.hh"
-#include "TransformerStateManager.hh"
-
-namespace {
-struct ScoresWithContext : public Lm::NNCacheWithStats {
-    virtual ~ScoresWithContext() = default;
-
-    std::atomic<bool>                           computed;
-    Lm::History                                 parent;
-    Lm::CompressedVectorPtr<float>              nn_output;
-    std::vector<Lm::CompressedVectorPtr<float>> state;
-    Lm::SearchSpaceInformation                  info;
-    Search::TimeframeIndex                      last_used;
-    Search::TimeframeIndex                      last_info;
-    bool                                        was_expanded;
-};
-
-struct FwdRequest {
-    ScoresWithContext* initial_cache;
-    ScoresWithContext* final_cache;
-    size_t             length;
-
-    bool operator==(FwdRequest const& other) const {
-        return final_cache == other.final_cache;
-    }
-};
-
-struct RequestGraph {
-    std::vector<ScoresWithContext*>  entries;
-    std::vector<std::vector<size_t>> children;
-    std::vector<size_t>              roots;
-
-    void add_cache(ScoresWithContext* cache) {
-        std::vector<ScoresWithContext*> request_chain;
-        request_chain.push_back(cache);
-        ScoresWithContext* parent = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(cache->parent.handle()));
-        request_chain.push_back(parent);
-        while (parent->state.empty()) {
-            parent = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(parent->parent.handle()));
-            request_chain.push_back(parent);
-        }
-
-        std::vector<size_t>* child_idxs = &roots;
-        while (not request_chain.empty()) {
-            // find root node
-            size_t child_idx = child_idxs->size();
-            for (size_t c = 0ul; c < child_idxs->size(); c++) {
-                if (entries[child_idxs->at(c)] == request_chain.back()) {
-                    child_idx = c;
-                    break;
-                }
-            }
-            size_t next_child_idx = 0ul;
-            if (child_idx == child_idxs->size()) {
-                child_idxs->push_back(entries.size());
-                entries.push_back(request_chain.back());
-                next_child_idx = child_idxs->at(child_idx);
-                children.emplace_back();  // can invalidate child_idxs
-            }
-            else {
-                next_child_idx = child_idxs->at(child_idx);
-            }
-            child_idxs = &children[next_child_idx];
-            request_chain.pop_back();
-        }
-    }
-
-    void get_requests_dfs(std::vector<FwdRequest>& requests, ScoresWithContext* initial, size_t entry, size_t length) {
-        if (children[entry].empty()) {
-            requests.emplace_back(FwdRequest{initial, entries[entry], length});
-        }
-        else {
-            for (size_t e : children[entry]) {
-                get_requests_dfs(requests, initial, e, length + 1ul);
-            }
-        }
-    }
-
-    std::vector<FwdRequest> get_requests() {
-        std::vector<FwdRequest> result;
-        for (size_t r : roots) {
-            for (size_t c : children[r]) {
-                get_requests_dfs(result, entries[r], c, 1ul);
-            }
-        }
-        return result;
-    }
-};
-
-void dump_scores(ScoresWithContext const& cache, std::string const& prefix) {
-    std::stringstream path;
-    path << prefix;
-    for (auto token : *cache.history) {
-        path << "_" << token;
-    }
-    std::ofstream out(path.str(), std::ios::out | std::ios::trunc);
-    out << "nn_output:\n";
-    std::vector<float> nn_output(cache.nn_output->size());
-    cache.nn_output->uncompress(nn_output.data(), nn_output.size());
-    for (auto nn_out : nn_output) {
-        out << nn_out << '\n';
-    }
-    for (size_t s = 0ul; s < cache.state.size(); s++) {
-        out << "state " << s << ":\n";
-        std::vector<float> state_data(cache.state[s]->size());
-        cache.state[s]->uncompress(state_data.data(), state_data.size());
-        for (auto v : state_data) {
-            out << v << '\n';
-        }
-    }
-}
-
-void clear_queue(Lm::TFRecurrentLanguageModel::HistoryQueue& queue) {
-    Lm::History const* hist = nullptr;
-    while (queue.try_dequeue(hist)) {
-        delete hist;
-    }
-}
-}  // namespace
+#include "TFBlasNceSoftmaxAdapter.hh"
+#include "TFLstmStateManager.hh"
+#include "TFNceSoftmaxAdapter.hh"
+#include "TFPassthroughSoftmaxAdapter.hh"
+#include "TFQuantizedBlasNceSoftmaxAdapter.hh"
+#include "TFSoftmaxAdapter.hh"
+#include "TFTransformerStateManager.hh"
 
 namespace Lm {
 
@@ -168,187 +35,66 @@ const Core::ParameterChoice stateManagerTypeParam(
         "type of the state manager",
         LstmStateManagerType);
 
-std::unique_ptr<StateManager> createStateManager(Core::Configuration const& config) {
-    StateManager* res = nullptr;
+std::unique_ptr<TFStateManager> createStateManager(Core::Configuration const& config) {
+    TFStateManager* res = nullptr;
     switch (stateManagerTypeParam(config)) {
-        case LstmStateManagerType: res = new Lm::LstmStateManager(config); break;
-        case TransformerStateManagerType: res = new Lm::TransformerStateManager<float>(config); break;
-        case TransformerStateManager16BitType: res = new Lm::TransformerStateManager<int16_t>(config); break;
-        case TransformerStateManager8BitType: res = new Lm::TransformerStateManager<int8_t>(config); break;
-        case TransformerStateManagerWithCommonPrefixType: res = new Lm::TransformerStateManagerWithCommonPrefix<float>(config); break;
-        case TransformerStateManagerWithCommonPrefix16BitType: res = new Lm::TransformerStateManagerWithCommonPrefix<int16_t>(config); break;
-        case TransformerStateManagerWithCommonPrefix8BitType: res = new Lm::TransformerStateManagerWithCommonPrefix<int8_t>(config); break;
+        case LstmStateManagerType: res = new Lm::TFLstmStateManager(config); break;
+        case TransformerStateManagerType: res = new Lm::TFTransformerStateManager<float>(config); break;
+        case TransformerStateManager16BitType: res = new Lm::TFTransformerStateManager<int16_t>(config); break;
+        case TransformerStateManager8BitType: res = new Lm::TFTransformerStateManager<int8_t>(config); break;
+        case TransformerStateManagerWithCommonPrefixType: res = new Lm::TFTransformerStateManagerWithCommonPrefix<float>(config); break;
+        case TransformerStateManagerWithCommonPrefix16BitType: res = new Lm::TFTransformerStateManagerWithCommonPrefix<int16_t>(config); break;
+        case TransformerStateManagerWithCommonPrefix8BitType: res = new Lm::TFTransformerStateManagerWithCommonPrefix<int8_t>(config); break;
         default: defect();
     }
-    return std::unique_ptr<StateManager>(res);
+    return std::unique_ptr<TFStateManager>(res);
 }
 
 enum SoftmaxAdapterType {
-    BlasNceSoftmaxAdapterType,
-    NceSoftmaxAdapterType,
-    PassthroughSoftmaxAdapterType,
-    QuantizedBlasNceSoftmaxAdapter16BitType
+    TFBlasNceSoftmaxAdapterType,
+    TFNceSoftmaxAdapterType,
+    TFPassthroughSoftmaxAdapterType,
+    TFQuantizedBlasNceSoftmaxAdapter16BitType
 };
 
 const Core::Choice softmaxAdapterTypeChoice(
-        "blas_nce", BlasNceSoftmaxAdapterType,  // included for backward compatibility
-        "blas-nce", BlasNceSoftmaxAdapterType,  // more consistent with RASR conventions
-        "nce", NceSoftmaxAdapterType,
-        "passthrough", PassthroughSoftmaxAdapterType,
-        "quantized-blas-nce-16bit", QuantizedBlasNceSoftmaxAdapter16BitType,
+        "blas_nce", TFBlasNceSoftmaxAdapterType,  // included for backward compatibility
+        "blas-nce", TFBlasNceSoftmaxAdapterType,  // more consistent with RASR conventions
+        "nce", TFNceSoftmaxAdapterType,
+        "passthrough", TFPassthroughSoftmaxAdapterType,
+        "quantized-blas-nce-16bit", TFQuantizedBlasNceSoftmaxAdapter16BitType,
         Core::Choice::endMark());
 
 const Core::ParameterChoice softmaxAdapterTypeParam(
         "type", &softmaxAdapterTypeChoice,
         "type of the softmax adapter",
-        PassthroughSoftmaxAdapterType);
+        TFPassthroughSoftmaxAdapterType);
 
-std::unique_ptr<SoftmaxAdapter> createSoftmaxAdapter(Core::Configuration const& config) {
+std::unique_ptr<TFSoftmaxAdapter> createSoftmaxAdapter(Core::Configuration const& config) {
     switch (softmaxAdapterTypeParam(config)) {
-        case BlasNceSoftmaxAdapterType: return std::unique_ptr<SoftmaxAdapter>(new Lm::BlasNceSoftmaxAdapter(config));
-        case NceSoftmaxAdapterType: return std::unique_ptr<SoftmaxAdapter>(new Lm::NceSoftmaxAdapter(config));
-        case PassthroughSoftmaxAdapterType: return std::unique_ptr<SoftmaxAdapter>(new Lm::PassthroughSoftmaxAdapter(config));
-        case QuantizedBlasNceSoftmaxAdapter16BitType: return std::unique_ptr<SoftmaxAdapter>(new Lm::QuantizedBlasNceSoftmaxAdapter16Bit(config));
+        case TFBlasNceSoftmaxAdapterType: return std::unique_ptr<TFSoftmaxAdapter>(new Lm::TFBlasNceSoftmaxAdapter(config));
+        case TFNceSoftmaxAdapterType: return std::unique_ptr<TFSoftmaxAdapter>(new Lm::TFNceSoftmaxAdapter(config));
+        case TFPassthroughSoftmaxAdapterType: return std::unique_ptr<TFSoftmaxAdapter>(new Lm::TFPassthroughSoftmaxAdapter(config));
+        case TFQuantizedBlasNceSoftmaxAdapter16BitType: return std::unique_ptr<TFSoftmaxAdapter>(new Lm::TFQuantizedBlasNceSoftmaxAdapter16Bit(config));
         default: defect();
     }
 }
 
-TFRecurrentLanguageModel::TimeStatistics TFRecurrentLanguageModel::TimeStatistics::operator+(TimeStatistics const& other) const {
-    TimeStatistics res;
-
-    res.total_duration          = total_duration + other.total_duration;
-    res.early_request_duration  = early_request_duration + other.early_request_duration;
-    res.request_duration        = request_duration + other.request_duration;
-    res.prepare_duration        = prepare_duration + other.prepare_duration;
-    res.merge_state_duration    = merge_state_duration + other.merge_state_duration;
-    res.set_state_duration      = set_state_duration + other.set_state_duration;
-    res.run_nn_output_duration  = run_nn_output_duration + other.run_nn_output_duration;
-    res.set_nn_output_duration  = set_nn_output_duration + other.set_nn_output_duration;
-    res.get_new_state_duration  = get_new_state_duration + other.get_new_state_duration;
-    res.split_state_duration    = split_state_duration + other.split_state_duration;
-    res.softmax_output_duration = softmax_output_duration + other.softmax_output_duration;
-
-    return res;
-}
-
-TFRecurrentLanguageModel::TimeStatistics& TFRecurrentLanguageModel::TimeStatistics::operator+=(TimeStatistics const& other) {
-    total_duration += other.total_duration;
-    early_request_duration += other.early_request_duration;
-    request_duration += other.request_duration;
-    prepare_duration += other.prepare_duration;
-    merge_state_duration += other.merge_state_duration;
-    set_state_duration += other.set_state_duration;
-    run_nn_output_duration += other.run_nn_output_duration;
-    set_nn_output_duration += other.set_nn_output_duration;
-    get_new_state_duration += other.get_new_state_duration;
-    split_state_duration += other.split_state_duration;
-    softmax_output_duration += other.softmax_output_duration;
-
-    return *this;
-}
-
-void TFRecurrentLanguageModel::TimeStatistics::write(Core::XmlChannel& channel) const {
-    channel << Core::XmlOpen("total-duration") + Core::XmlAttribute("unit", "milliseconds") << total_duration.count() << Core::XmlClose("total-duration");
-    channel << Core::XmlOpen("early-request-duration") + Core::XmlAttribute("unit", "milliseconds") << early_request_duration.count() << Core::XmlClose("early-request-duration");
-    channel << Core::XmlOpen("request-duration") + Core::XmlAttribute("unit", "milliseconds") << request_duration.count() << Core::XmlClose("request-duration");
-    channel << Core::XmlOpen("prepare-duration") + Core::XmlAttribute("unit", "milliseconds") << prepare_duration.count() << Core::XmlClose("prepare-duration");
-    channel << Core::XmlOpen("merge-state-duration") + Core::XmlAttribute("unit", "milliseconds") << merge_state_duration.count() << Core::XmlClose("merge-state-duration");
-    channel << Core::XmlOpen("set-state-duration") + Core::XmlAttribute("unit", "milliseconds") << set_state_duration.count() << Core::XmlClose("set-state-duration");
-    channel << Core::XmlOpen("run-nn-output-duration") + Core::XmlAttribute("unit", "milliseconds") << run_nn_output_duration.count() << Core::XmlClose("run-nn-output-duration");
-    channel << Core::XmlOpen("set-nn-output-duration") + Core::XmlAttribute("unit", "milliseconds") << set_nn_output_duration.count() << Core::XmlClose("set-nn-output-duration");
-    channel << Core::XmlOpen("get-new-state-duration") + Core::XmlAttribute("unit", "milliseconds") << get_new_state_duration.count() << Core::XmlClose("get-new-state-duration");
-    channel << Core::XmlOpen("split-state-duration") + Core::XmlAttribute("unit", "milliseconds") << split_state_duration.count() << Core::XmlClose("split-state-duration");
-    channel << Core::XmlOpen("softmax-output-duration") + Core::XmlAttribute("unit", "milliseconds") << softmax_output_duration.count() << Core::XmlClose("softmax-output-duration");
-}
-
-void TFRecurrentLanguageModel::TimeStatistics::write(std::ostream& out) const {
-    out << "fwd: " << total_duration.count()
-        << " er:" << early_request_duration.count()
-        << " r:" << request_duration.count()
-        << " p:" << prepare_duration.count()
-        << " ms: " << merge_state_duration.count()
-        << " sst:" << set_state_duration.count()
-        << " rs:" << run_nn_output_duration.count()
-        << " sno:" << set_nn_output_duration.count()
-        << " gns:" << get_new_state_duration.count()
-        << " ss: " << split_state_duration.count()
-        << " smo:" << softmax_output_duration.count();
-}
-
-const Core::ParameterBool   TFRecurrentLanguageModel::paramTransformOuputLog("transform-output-log", "apply log to tensorflow output", false);
-const Core::ParameterBool   TFRecurrentLanguageModel::paramTransformOuputNegate("transform-output-negate", "negate tensorflow output (after log)", false);
-const Core::ParameterInt    TFRecurrentLanguageModel::paramMinBatchSize("min-batch-size", "minimum number of histories forwarded in one go", 32);
-const Core::ParameterInt    TFRecurrentLanguageModel::paramOptBatchSize("opt-batch-size", "optimum number of histories forwarded in one go", 128);
-const Core::ParameterInt    TFRecurrentLanguageModel::paramMaxBatchSize("max-batch-size", "maximum number of histories forwarded in one go", 2048);
-const Core::ParameterInt    TFRecurrentLanguageModel::paramHistoryPruningThreshold("history-pruning-threshold", "if the history is longer than this parameter it will be pruned", std::numeric_limits<int>::max(), 0);
-const Core::ParameterInt    TFRecurrentLanguageModel::paramPrunedHistoryLength("pruned-history-length", "length of the pruned history (should be smaller than history-pruning-threshold)", std::numeric_limits<int>::max(), 0);
-const Core::ParameterFloat  TFRecurrentLanguageModel::paramBatchPruningThreshold("batch-pruning-threshold", "pruning threshold for all hypothesis beyond min-batch-size during eager forwarding", 10.0);
-const Core::ParameterBool   TFRecurrentLanguageModel::paramAllowReducedHistory("allow-reduced-history", "wether this LM will actually reduce the history length", false);
-const Core::ParameterBool   TFRecurrentLanguageModel::paramDumpInputs("dump-inputs", "write all inputs from this LM to disk", false);
-const Core::ParameterString TFRecurrentLanguageModel::paramDumpInputsPrefix("dump-inputs-prefix", "prefix for the input dumps", "inputs");
-const Core::ParameterBool   TFRecurrentLanguageModel::paramDumpScores("dump-scores", "write all scores from this LM to disk", false);
-const Core::ParameterString TFRecurrentLanguageModel::paramDumpScoresPrefix("dump-scores-prefix", "prefix for the score dumps", "scores");
-const Core::ParameterBool   TFRecurrentLanguageModel::paramLogMemory("log-memory", "wether memory usage from nn-outputs / states should be logged", false);
-const Core::ParameterBool   TFRecurrentLanguageModel::paramFreeMemory("free-memory", "wether nn-outputs should be deleted after some delay", false);
-const Core::ParameterInt    TFRecurrentLanguageModel::paramFreeMemoryDelay("free-memory-delay", "how many time frames without usage before nn-outputs are deleted", 40);
-const Core::ParameterBool   TFRecurrentLanguageModel::paramAsync("async", "wether to forward histories in a separate thread", false);
-const Core::ParameterBool   TFRecurrentLanguageModel::paramSingleStepOnly("single-step-only", "workaround for some bug that results in wrong scores when recombination is done in combination with async evaluation", false);
-const Core::ParameterBool   TFRecurrentLanguageModel::paramVerbose("verbose", "wether to print detailed statistics to stderr", false);
-
 TFRecurrentLanguageModel::TFRecurrentLanguageModel(Core::Configuration const& c, Bliss::LexiconRef l)
         : Core::Component(c),
-          Precursor(c, l),
-          transform_output_log_(paramTransformOuputLog(config)),
-          transform_output_negate_(paramTransformOuputNegate(config)),
-          min_batch_size_(paramMinBatchSize(config)),
-          opt_batch_size_(paramOptBatchSize(config)),
-          max_batch_size_(paramMaxBatchSize(config)),
-          history_pruning_threshold_(paramHistoryPruningThreshold(config)),
-          pruned_history_length_(paramPrunedHistoryLength(config)),
-          batch_pruning_threshold_(paramBatchPruningThreshold(config)),
-          allow_reduced_history_(paramAllowReducedHistory(config)),
-          dump_inputs_(paramDumpInputs(config)),
-          dump_inputs_prefix_(paramDumpInputsPrefix(config)),
-          dump_scores_(paramDumpScores(config)),
-          dump_scores_prefix_(paramDumpScoresPrefix(config)),
-          log_memory_(paramLogMemory(config)),
-          free_memory_(paramFreeMemory(config)),
-          free_memory_delay_(paramFreeMemoryDelay(config)),
-          async_(paramAsync(config)),
-          single_step_only_(paramSingleStepOnly(config)),
-          verbose_(paramVerbose(config)),
+          Precursor(c, l, createStateManager(select("state-manager"))),
           session_(select("session")),
           loader_(Tensorflow::Module::instance().createGraphLoader(select("loader"))),
           graph_(loader_->load_graph()),
           tensor_input_map_(select("input-map")),
           tensor_output_map_(select("output-map")),
-          state_comp_vec_factory_(Lm::Module::instance().createCompressedVectorFactory(select("state-compression"))),
-          nn_output_comp_vec_factory_(Lm::Module::instance().createCompressedVectorFactory(select("nn-output-compression"))),
-          state_manager_(createStateManager(select("state-manager"))),
-          softmax_adapter_(createSoftmaxAdapter(select("softmax-adapter"))),
-          statistics_(config, "statistics"),
-          current_time_(0u),
-          run_time_(max_batch_size_, 0.0),
-          run_count_(max_batch_size_, 0ul),
-          total_wait_time_(0.0),
-          total_start_frame_time_(0.0),
-          total_expand_hist_time_(0.0),
-          fwd_statistics_(),
-          dump_inputs_counter_(0ul),
-          background_forwarder_thread_(),
-          should_stop_(false),
-          to_fwd_(nullptr),
-          to_fwd_finished_(),
-          pending_(),
-          fwd_queue_(32768),
-          finished_queue_(32768) {
-    require_le(pruned_history_length_, history_pruning_threshold_);
+          softmax_adapter_(createSoftmaxAdapter(select("softmax-adapter"))) {
     session_.addGraph(*graph_);
     loader_->initialize(session_);
 
     auto const& softmax_info = tensor_output_map_.get_info("softmax");
     output_tensor_names_.push_back(softmax_info.tensor_name());
-    state_variables_.reserve(state_variables_.size());
+    state_variables_.reserve(graph_->state_vars().size());
     for (std::string const& s : graph_->state_vars()) {
         auto const& var = graph_->variables().find(s)->second;
         state_variables_.emplace_back(var);
@@ -356,443 +102,20 @@ TFRecurrentLanguageModel::TFRecurrentLanguageModel(Core::Configuration const& c,
         read_vars_tensor_names_.push_back(var.snapshot_name);
     }
 
-    if (transform_output_log_ and transform_output_negate_) {
-        output_transform_function_ = [](Score v) { return -std::log(v); };
-    }
-    else if (transform_output_log_) {
-        output_transform_function_ = [](Score v) { return std::log(v); };
-    }
-    else if (transform_output_negate_) {
-        output_transform_function_ = [](Score v) { return -v; };
+    if (state_variables_.empty()) {
+        error("No recurrent state variables found in tensorflow graph of recurrent language model.");
     }
 
-    NNHistoryManager*  hm = dynamic_cast<NNHistoryManager*>(historyManager_);
-    TokenIdSequence    ts;
-    HistoryHandle      h     = hm->get<ScoresWithContext>(ts);
-    ScoresWithContext* cache = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(h));
-    cache->state             = state_manager_->initialState(state_variables_, *state_comp_vec_factory_);
-
-    if (cache->state.empty()) {
-        error("LM has no state variables. Did you forget to compile with 'initial_state': 'keep_over_epoch_no_init'?");
-    }
-
-    std::vector<f32> temp(1);
-    auto             compression_param_estimator = nn_output_comp_vec_factory_->getEstimator();
-    compression_param_estimator->accumulate(temp.data(), temp.size());
-    auto compression_params = compression_param_estimator->estimate();
-    // pretend this history has already been evaluated
-    cache->nn_output = nn_output_comp_vec_factory_->compress(temp.data(), temp.size(), compression_params.get());
-    cache->computed.store(true);
-    cache->last_used = std::numeric_limits<Search::TimeframeIndex>::max();
-    empty_history_   = history(h);
+    setEmptyHistory();
 
     softmax_adapter_->init(session_, tensor_input_map_, tensor_output_map_);
-
-    if (async_) {
-        background_forwarder_thread_ = std::thread(std::bind(&TFRecurrentLanguageModel::background_forward, this));
-    }
-}
-
-TFRecurrentLanguageModel::~TFRecurrentLanguageModel() {
-    clear_queue(finished_queue_);
-
-    if (async_) {
-        should_stop_ = true;
-        background_forwarder_thread_.join();
-    }
-
-    size_t total_run_count = 0ul;
-    size_t total_fwd_hist  = 0ul;
-    double total_run_time  = 0.0;
-
-    statistics_ << Core::XmlOpen("fwd-time");
-    for (size_t i = 0ul; i < run_count_.size(); i++) {
-        if (run_count_[i] > 0ul) {
-            statistics_ << (i + 1) << " " << run_count_[i] << " " << run_time_[i] << "\n";
-            total_run_count += run_count_[i];
-            total_fwd_hist += (i + 1) * run_count_[i];
-            total_run_time += run_time_[i];
-        }
-    }
-    statistics_ << Core::XmlClose("fwd-time");
-
-    statistics_ << Core::XmlOpen("fwd-summary");
-    statistics_ << Core::XmlOpen("total-run-count") << total_run_count << Core::XmlClose("total-run-count");
-    statistics_ << Core::XmlOpen("total-fwd-hist") << total_fwd_hist << Core::XmlClose("total-fwd-hist");
-    statistics_ << Core::XmlOpen("total-run-time") + Core::XmlAttribute("unit", "milliseconds") << total_run_time << Core::XmlClose("total-run-time");
-    statistics_ << Core::XmlOpen("total-wait-time") + Core::XmlAttribute("unit", "milliseconds") << total_wait_time_ << Core::XmlClose("total-wait-time");
-    statistics_ << Core::XmlOpen("total-start-frame-time") + Core::XmlAttribute("unit", "milliseconds") << total_start_frame_time_ << Core::XmlClose("total-start-frame-time");
-    statistics_ << Core::XmlOpen("total-expand-hist-time") + Core::XmlAttribute("unit", "milliseconds") << total_expand_hist_time_ << Core::XmlClose("total-expand-hist-time");
-    statistics_ << Core::XmlOpen("fwd-times");
-    fwd_statistics_.write(statistics_);
-    statistics_ << Core::XmlClose("fwd-times");
-    statistics_ << Core::XmlClose("fwd-summary");
-}
-
-History TFRecurrentLanguageModel::startHistory() const {
-    NNHistoryManager*  hm = dynamic_cast<NNHistoryManager*>(historyManager_);
-    TokenIdSequence    ts(1ul, lexicon_mapping_[sentenceBeginToken()->id()]);
-    HistoryHandle      h     = hm->get<ScoresWithContext>(ts);
-    ScoresWithContext* cache = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(h));
-    cache->parent            = empty_history_;
-    History hist(history(h));
-    return hist;
-}
-
-History TFRecurrentLanguageModel::extendedHistory(History const& hist, Token w) const {
-    return extendedHistory(hist, w->id());
-}
-
-History TFRecurrentLanguageModel::extendedHistory(History const& hist, Bliss::Token::Id w) const {
-    return extendHistoryWithOutputIdx(hist, lexicon_mapping_[w]);
-}
-
-History TFRecurrentLanguageModel::reducedHistory(History const& hist, u32 limit) const {
-    ScoresWithContext const* sc = reinterpret_cast<ScoresWithContext const*>(hist.handle());
-    if (not allow_reduced_history_ or sc->history->size() <= limit) {
-        return hist;
-    }
-    History h = startHistory();
-    for (u32 w = limit; w > 0; w--) {
-        h = extendHistoryWithOutputIdx(h, sc->history->at(sc->history->size() - w));
-    }
-    return h;
-}
-
-Score TFRecurrentLanguageModel::score(History const& hist, Token w) const {
-    ScoresWithContext* sc = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(hist.handle()));
-
-    if (not sc->computed.load()) {
-        auto start = std::chrono::steady_clock::now();
-        if (async_) {
-            // promise should only be used once
-            to_fwd_finished_                   = std::promise<History const*>();
-            std::future<History const*> future = to_fwd_finished_.get_future();
-            to_fwd_.store(&hist);
-            future.wait();
-        }
-        else {
-            forward<false>(&hist);
-        }
-        auto   end       = std::chrono::steady_clock::now();
-        double wait_time = std::chrono::duration<double, std::milli>(end - start).count();
-        total_wait_time_ += wait_time;
-        if (verbose_) {
-            std::cerr << "wait: " << wait_time << " " << sc->info.numStates << " " << sc->info.bestScoreOffset << std::endl;
-        }
-    }
-
-    require(sc->computed.load());
-
-    size_t output_idx = lexicon_mapping_[w->id()];
-    useOutput(*sc, output_idx);
-    sc->last_used  = current_time_;
-    auto  start    = std::chrono::steady_clock::now();
-    Score score    = output_transform_function_(softmax_adapter_->get_score(sc->nn_output, output_idx));
-    auto  end      = std::chrono::steady_clock::now();
-    auto  duration = std::chrono::duration<double, std::milli>(end - start);
-    fwd_statistics_.softmax_output_duration += duration;
-    fwd_statistics_.total_duration += duration;
-    return score;
-}
-
-bool TFRecurrentLanguageModel::scoreCached(History const& hist, Token w) const {
-    ScoresWithContext const* sc = reinterpret_cast<ScoresWithContext const*>(hist.handle());
-    return sc->computed.load();
-}
-
-void TFRecurrentLanguageModel::load() {
-    loadVocabulary();
-}
-
-void TFRecurrentLanguageModel::startFrame(Search::TimeframeIndex time) const {
-    auto timer_start = std::chrono::steady_clock::now();
-
-    current_time_ = time;
-
-    size_t nn_output_cache_size = 0ul;
-    size_t state_cache_size     = 0ul;
-    size_t num_histories        = 0ul;
-
-    clear_queue(finished_queue_);
-
-    NNHistoryManager* hm = dynamic_cast<NNHistoryManager*>(historyManager_);
-    hm->visit([&](HistoryHandle h) {
-        num_histories += 1ul;
-        ScoresWithContext* c        = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(h));
-        bool               computed = c->computed.load();
-        if (free_memory_ and computed and c->was_expanded and c->info.numStates == 0 and c->last_used < current_time_ - std::min(free_memory_delay_, current_time_)) {
-            c->nn_output->clear();
-            c->computed.store(false);
-        }
-        else if (async_ and not computed and not(c->was_expanded and c->info.numStates == 0)) {
-            fwd_queue_.enqueue(new History(history(h)));
-        }
-        if (c->nn_output) {
-            nn_output_cache_size += c->nn_output->usedMemory();
-        }
-        for (auto const& state_vec : c->state) {
-            if (state_vec) {
-                state_cache_size += state_vec->usedMemory();
-            }
-        }
-    });
-
-    if (log_memory_ and statistics_.isOpen()) {
-        statistics_ << Core::XmlOpen("memory-usage") + Core::XmlAttribute("time-frame", current_time_);
-        statistics_ << Core::XmlOpen("nn-output-cache-size") + Core::XmlAttribute("unit", "MB") << (nn_output_cache_size / (1024. * 1024.)) << Core::XmlClose("nn-output-cache-size");
-        statistics_ << Core::XmlOpen("state-cache-size") + Core::XmlAttribute("unit", "MB") << (state_cache_size / (1024. * 1024.)) << Core::XmlClose("state-cache-size");
-        statistics_ << Core::XmlOpen("num-histories") << num_histories << Core::XmlClose("num-histories");
-        statistics_ << Core::XmlClose("memory-usage");
-    }
-
-    auto   timer_end            = std::chrono::steady_clock::now();
-    double start_frame_duration = std::chrono::duration<double, std::milli>(timer_end - timer_start).count();
-    total_start_frame_time_ += start_frame_duration;
-}
-
-void TFRecurrentLanguageModel::setInfo(History const& hist, SearchSpaceInformation const& info) const {
-    ScoresWithContext* sc = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(hist.handle()));
-    sc->info              = info;
-    sc->last_info         = current_time_;
-}
-
-History TFRecurrentLanguageModel::extendHistoryWithOutputIdx(History const& hist, size_t w) const {
-    auto                     timer_start = std::chrono::steady_clock::now();
-    NNHistoryManager*        hm          = dynamic_cast<NNHistoryManager*>(historyManager_);
-    ScoresWithContext const* sc          = reinterpret_cast<ScoresWithContext const*>(hist.handle());
-    TokenIdSequence          ts(*sc->history);
-    ts.push_back(w);
-    HistoryHandle      h     = hm->get<ScoresWithContext>(ts);
-    ScoresWithContext* cache = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(h));
-    if (cache->parent.handle() == nullptr) {
-        cache->parent                   = hist;
-        ScoresWithContext* parent_cache = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(hist.handle()));
-        parent_cache->was_expanded      = true;
-        if (async_) {
-            fwd_queue_.enqueue(new History(history(h)));
-        }
-    }
-    History ext_hist(history(h));
-    if (cache->history->size() > history_pruning_threshold_) {
-        ext_hist = reducedHistory(ext_hist, pruned_history_length_);
-    }
-    auto   timer_end        = std::chrono::steady_clock::now();
-    double expand_hist_time = std::chrono::duration<double, std::milli>(timer_end - timer_start).count();
-    total_expand_hist_time_ += expand_hist_time;
-    return ext_hist;
-}
-
-void TFRecurrentLanguageModel::background_forward() const {
-    while (not should_stop_) {
-        forward<true>(to_fwd_.exchange(nullptr));
-    }
-    History const* h = nullptr;
-    while (fwd_queue_.try_dequeue(h)) {
-        finished_queue_.enqueue(h);
-    }
-    for (History const* h : pending_) {
-        finished_queue_.enqueue(h);
-    }
-    pending_.clear();
 }
 
-template<bool async>
-void TFRecurrentLanguageModel::forward(Lm::History const* hist) const {
-    ScoresWithContext* sc = nullptr;
-    if (hist != nullptr) {
-        sc = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(hist->handle()));
-    }
-    if (async and sc != nullptr and sc->computed.load()) {  // nothing to do (only happens in async case)
-        to_fwd_finished_.set_value(hist);
-        return;
-    }
-    auto start = std::chrono::steady_clock::now();
-
-    RequestGraph request_graph;
-    if (sc != nullptr) {
-        request_graph.add_cache(const_cast<ScoresWithContext*>(sc));
-    }
-
-    std::vector<FwdRequest>  requests;
-    std::vector<Lm::History> request_histories;  // make sure none of the request caches go away while we compute the scores
-    size_t                   max_length = 0ul;
-
-    size_t                          num_pending_requests = pending_.size();
-    std::unordered_set<void const*> handles;  // only relevant in async case
-    handles.reserve(pending_.size());
-    std::vector<ScoresWithContext*> early_requests;
-    std::vector<History const*>     early_request_histories;  // make sure none of the request caches go away while we compute the scores (only relevant in async case)
-
-    if (async) {
-        auto process_hist = [&](History const* hist) {
-            ScoresWithContext* c        = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(hist->handle()));
-            ScoresWithContext* parent_c = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(c->parent.handle()));
-            if (handles.find(hist->handle()) == handles.end() and not c->computed.load() and c != sc and c->parent.handle() != nullptr and c->ref_count > 1 and (not single_step_only_ or parent_c->computed.load())) {
-                early_requests.emplace_back(c);
-                early_request_histories.emplace_back(hist);
-                handles.insert(hist->handle());
-            }
-            else {
-                finished_queue_.enqueue(hist);
-            }
-        };
-
-        std::for_each(pending_.begin(), pending_.end(), process_hist);
-        pending_.clear();
-
-        History const* hist_buf = nullptr;
-        bool           success  = false;
-        bool           first    = true;
-        do {
-            if (first) {
-                success = fwd_queue_.wait_dequeue_timed(hist_buf, 1000);
-            }
-            else {
-                success = fwd_queue_.try_dequeue(hist_buf);
-            }
-            if (success) {
-                process_hist(hist_buf);
-                first = false;
-            }
-        } while (success);
-    }
-    else {
-        NNHistoryManager* hm = dynamic_cast<NNHistoryManager*>(historyManager_);
-        hm->visit([&](HistoryHandle h) {
-            ScoresWithContext* c = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(h));
-            if (not c->computed.load() and c != sc and not(c->was_expanded and c->info.numStates == 0)) {
-                early_requests.emplace_back(c);
-            }
-        });
-    }
-
-    size_t num_early_requests = early_requests.size();
-
-    auto end_early_requests = std::chrono::steady_clock::now();
-
-    if (async and sc == nullptr and early_requests.empty()) {
-        // can only happen in async case
-        return;
-    }
-
-    // because the scores can be updated while we are sorting we need to store them, so we get a consistent view
-    std::vector<std::pair<unsigned, Score>> idxs;
-    idxs.reserve(early_requests.size());
-    for (size_t i = 0ul; i < early_requests.size(); i++) {
-        idxs.emplace_back(i, early_requests[i]->info.minLabelDistance * 1000 + early_requests[i]->info.bestScoreOffset);
-    }
-    std::sort(idxs.begin(), idxs.end(), [](std::pair<size_t, Score> const& a, std::pair<size_t, Score> const& b) {
-        return a.second < b.second;
-    });
-
-    for (auto idx : idxs) {
-        request_graph.add_cache(early_requests[idx.first]);
-    }
-
-    // we do not need early_requests anymore
-    early_requests.clear();
-    idxs.clear();
-
-    requests = request_graph.get_requests();
-
-    // prune requests
-    if (min_batch_size_ > 0ul and requests.size() > min_batch_size_) {
-        size_t i         = min_batch_size_;
-        Score  ref_score = requests.front().final_cache->info.bestScoreOffset + batch_pruning_threshold_;
-        if (not Math::isinf(ref_score)) {
-            while ((i + 1) < requests.size() and requests[i + 1].final_cache->info.bestScoreOffset <= ref_score) {
-                i += 1ul;
-            }
-            requests.resize(i);
-        }
-    }
-
-    if (min_batch_size_ > 0ul and opt_batch_size_ > 0ul and requests.size() > opt_batch_size_ + min_batch_size_) {
-        requests.resize(opt_batch_size_);
-    }
-    if (max_batch_size_ > 0ul and requests.size() > max_batch_size_) {
-        requests.resize(max_batch_size_);
-    }
-
-    Score worst_score = std::numeric_limits<Score>::min();
-    for (auto const& r : requests) {
-        max_length  = std::max(max_length, r.length);
-        worst_score = std::max(worst_score, r.final_cache->info.bestScoreOffset);
-    }
-
-    auto end_requests = std::chrono::steady_clock::now();
-
-    // prepare the data in Sprint Datastructures
-    Math::FastMatrix<s32> words(requests.size(), max_length);
-    Math::FastVector<s32> word_lengths(requests.size());
-    for (size_t r = 0ul; r < requests.size(); r++) {
-        auto&  history = *(requests[r].final_cache->history);
-        size_t offset  = history.size() - requests[r].length;
-        for (size_t w = 0u; w < requests[r].length; w++) {
-            words.at(r, w) = static_cast<s32>(history[offset + w]);
-        }
-        for (size_t w = requests[r].length; w < max_length; w++) {
-            words.at(r, w) = 0;
-        }
-        word_lengths[r]                  = requests[r].length;
-        ScoresWithContext* initial_cache = requests[r].initial_cache;
-        require(initial_cache != nullptr);
-        require_eq(state_variables_.size(), initial_cache->state.size());
-    }
-
-    bool   full_prefix_required = state_manager_->requiresAllParentStates();
-    size_t total_prefix_length  = 0ul;
-    size_t total_suffix_length  = 0ul;
-
-    std::vector<size_t> prefix_lengths(requests.size());
-    std::vector<size_t> suffix_lengths(requests.size());
-    for (size_t r = 0ul; r < requests.size(); r++) {
-        prefix_lengths[r] = requests[r].initial_cache->history->size();
-        suffix_lengths[r] = requests[r].length;
-        total_prefix_length += prefix_lengths[r];
-        total_suffix_length += suffix_lengths[r];
-    }
-
-    std::vector<StateManager::HistoryState const*> prefix_states(full_prefix_required ? total_prefix_length : requests.size());
-    size_t                                         current_offset = 0ul;
-    for (size_t r = 0ul; r < requests.size(); r++) {
-        ScoresWithContext* current_cache = requests[r].initial_cache;
-        if (full_prefix_required) {
-            size_t prefix_length = prefix_lengths[r];
-            for (size_t i = 0ul; i < prefix_length; i++) {
-                prefix_states[current_offset + prefix_length - i - 1] = &current_cache->state;
-                current_cache                                         = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(current_cache->parent.handle()));
-            }
-            current_offset += prefix_length;
-        }
-        else {
-            prefix_states[r] = &current_cache->state;
-        }
-    }
-
-    auto end_prepare = std::chrono::steady_clock::now();
-
-    // build tensors + set state variables
-    std::vector<std::pair<std::string, Tensorflow::Tensor>> inputs;
-    std::vector<std::string>                                targets;
-    state_manager_->mergeStates(state_variables_, prefix_lengths, prefix_states, inputs, targets);
-    std::vector<s32> state_lengths(prefix_lengths.begin(), prefix_lengths.end());
-
-    if (dump_inputs_) {
-        std::string out = dump_inputs_prefix_ + "_" + std::to_string(dump_inputs_counter_) + "_state_";
-        for (size_t i = 0ul; i < inputs.size(); i++) {
-            inputs[i].second.save<s16>(out + std::to_string(i));
-        }
-    }
-
-    auto end_merge_state = std::chrono::steady_clock::now();
-
+void TFRecurrentLanguageModel::setState(std::vector<std::pair<std::string, Tensorflow::Tensor>> const& inputs, std::vector<std::string> const& targets) const {
     session_.run(inputs, targets);
+}
 
-    auto end_set_state = std::chrono::steady_clock::now();
-
-    // run nn-output calculation
+void TFRecurrentLanguageModel::extendInputs(std::vector<std::pair<std::string, Tensorflow::Tensor>>& inputs, Math::FastMatrix<s32> const& words, Math::FastVector<s32> const& word_lengths, std::vector<s32> const& state_lengths) const {
     inputs.clear();
     auto const& word_info = tensor_input_map_.get_info("word");
     inputs.emplace_back(std::make_pair(word_info.tensor_name(), Tensorflow::Tensor::create(words)));
@@ -803,111 +126,22 @@ void TFRecurrentLanguageModel::forward(Lm::History const* hist) const {
         auto const& state_lengths_info = tensor_input_map_.get_info("state-lengths");
         inputs.emplace_back(std::make_pair(state_lengths_info.tensor_name(), Tensorflow::Tensor::create(state_lengths)));
     }
-    std::vector<Tensorflow::Tensor> outputs;
-    session_.run(inputs, output_tensor_names_, graph_->update_ops(), outputs);
-
-    if (dump_inputs_) {
-        std::string out = dump_inputs_prefix_ + "_" + std::to_string(dump_inputs_counter_) + "_nn_in_";
-        for (size_t i = 0ul; i < inputs.size(); i++) {
-            inputs[i].second.save<s32>(out + std::to_string(i));
-        }
-        out = dump_inputs_prefix_ + "_" + std::to_string(dump_inputs_counter_) + "_nn_out_";
-        for (size_t i = 0ul; i < outputs.size(); i++) {
-            outputs[i].save<f32>(out + std::to_string(i));
-        }
-        dump_inputs_counter_ += 1ul;
-    }
-
-    auto end_nn_output = std::chrono::steady_clock::now();
+}
 
-    // store outputs in caches
-    for (size_t r = 0ul; r < requests.size(); r++) {
-        ScoresWithContext* cache = requests[r].final_cache;
-        for (size_t w = requests[r].length; w > 0;) {
-            --w;
-            cache->last_used                         = current_time_;
-            int          num_outputs                 = outputs[0ul].dimSize(2);
-            auto         compression_param_estimator = nn_output_comp_vec_factory_->getEstimator();
-            float const* data                        = outputs[0ul].data<f32>(r, w, 0);
-            compression_param_estimator->accumulate(data, num_outputs);
-            auto compression_params = compression_param_estimator->estimate();
-            cache->nn_output        = nn_output_comp_vec_factory_->compress(data, num_outputs, compression_params.get());
-            cache->computed.store(true);
-            cache = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(cache->parent.handle()));
-        }
-        require_eq(cache, requests[r].initial_cache);
-    }
+void TFRecurrentLanguageModel::extendTargets(std::vector<std::string>& targets) const {
+}
 
-    auto end_set_nn_output = std::chrono::steady_clock::now();
+void TFRecurrentLanguageModel::getOutputs(std::vector<std::pair<std::string, Tensorflow::Tensor>>& inputs, std::vector<Tensorflow::Tensor>& outputs, std::vector<std::string> const& targets) const {
+    session_.run(inputs, output_tensor_names_, graph_->update_ops(), outputs);
+}
 
-    // fetch new values of state variables, needs to be done in separate Session::run call (for GPU devices)
+std::vector<Tensorflow::Tensor> TFRecurrentLanguageModel::fetchStates(std::vector<Tensorflow::Tensor>& outputs) const {
     session_.run({}, read_vars_tensor_names_, {}, outputs);
+    return outputs;
+}
 
-    auto end_get_new_state = std::chrono::steady_clock::now();
-
-    auto split_states = state_manager_->splitStates(state_variables_, suffix_lengths, outputs, *state_comp_vec_factory_);
-
-    size_t output_offset = 0ul;
-    for (size_t r = 0ul; r < requests.size(); r++) {
-        ScoresWithContext* current_cache = requests[r].final_cache;
-        size_t             suffix_length = suffix_lengths[r];
-        while (suffix_length > 0ul) {
-            current_cache->state = std::move(split_states[output_offset + suffix_length - 1]);
-            current_cache        = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(current_cache->parent.handle()));
-            suffix_length -= 1ul;
-        }
-        output_offset += suffix_lengths[r];
-    }
-
-    auto end_split_state = std::chrono::steady_clock::now();
-
-    std::chrono::duration<double, std::milli> duration = end_split_state - end_prepare;
-    size_t                                    bucket   = requests.size() - 1;
-    run_time_.at(bucket) += duration.count();
-    run_count_.at(bucket) += 1ul;
-
-    if (dump_scores_) {
-        for (auto const& r : requests) {
-            dump_scores(*r.final_cache, dump_scores_prefix_);
-        }
-    }
-
-    if (async) {
-        for (auto hist : early_request_histories) {
-            ScoresWithContext* c = const_cast<ScoresWithContext*>(reinterpret_cast<ScoresWithContext const*>(hist->handle()));
-            if (c->computed.load() or c->ref_count == 1ul or c->info.numStates == 0) {
-                finished_queue_.enqueue(hist);
-            }
-            else {
-                pending_.push_back(hist);
-            }
-        }
-        if (sc != nullptr) {
-            to_fwd_finished_.set_value(hist);
-        }
-    }
-
-    auto end = std::chrono::steady_clock::now();
-
-    TimeStatistics stats;
-    stats.total_duration          = std::chrono::duration<double, std::milli>(end - start);
-    stats.early_request_duration  = std::chrono::duration<double, std::milli>(end_early_requests - start);
-    stats.request_duration        = std::chrono::duration<double, std::milli>(end_requests - end_early_requests);
-    stats.prepare_duration        = std::chrono::duration<double, std::milli>(end_prepare - end_requests);
-    stats.merge_state_duration    = std::chrono::duration<double, std::milli>(end_merge_state - end_prepare);
-    stats.set_state_duration      = std::chrono::duration<double, std::milli>(end_set_state - end_merge_state);
-    stats.run_nn_output_duration  = std::chrono::duration<double, std::milli>(end_nn_output - end_set_state);
-    stats.set_nn_output_duration  = std::chrono::duration<double, std::milli>(end_set_nn_output - end_nn_output);
-    stats.get_new_state_duration  = std::chrono::duration<double, std::milli>(end_get_new_state - end_set_nn_output);
-    stats.split_state_duration    = std::chrono::duration<double, std::milli>(end_split_state - end_get_new_state);
-    stats.softmax_output_duration = std::chrono::duration<double, std::milli>();
-    if (verbose_) {
-        stats.write(std::cerr);
-        std::cerr << " #pr:" << num_pending_requests
-                  << " #er:" << num_early_requests
-                  << " #r:" << requests.size() << std::endl;
-    }
-    fwd_statistics_ += stats;
+Score TFRecurrentLanguageModel::transformOutput(Lm::CompressedVectorPtr<float> const& nn_output, size_t index) const {
+    return softmax_adapter_->get_score(nn_output, index);
 }
 
 }  // namespace Lm
diff --git a/src/Lm/TFRecurrentLanguageModel.hh b/src/Lm/TFRecurrentLanguageModel.hh
index 6f8fd069f..d7659d759 100644
--- a/src/Lm/TFRecurrentLanguageModel.hh
+++ b/src/Lm/TFRecurrentLanguageModel.hh
@@ -1,166 +1,46 @@
-/** Copyright 2020 RWTH Aachen University. All rights reserved.
- *
- *  Licensed under the RWTH ASR License (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *      http://www.hltpr.rwth-aachen.de/rwth-asr/rwth-asr-license.html
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
 #ifndef _LM_TF_RECURRENT_LANGUAGE_MODEL_HH
 #define _LM_TF_RECURRENT_LANGUAGE_MODEL_HH
 
-#include <deque>
-#include <future>
-#include <thread>
-
+#include <Tensorflow/Graph.hh>
 #include <Tensorflow/GraphLoader.hh>
 #include <Tensorflow/Module.hh>
 #include <Tensorflow/Session.hh>
+#include <Tensorflow/Tensor.hh>
 #include <Tensorflow/TensorMap.hh>
-#include <Core/readerwriterqueue.h>
 
-#include "AbstractNNLanguageModel.hh"
-#include "CompressedVector.hh"
-#include "SearchSpaceAwareLanguageModel.hh"
-#include "SoftmaxAdapter.hh"
-#include "StateManager.hh"
+#include "RecurrentLanguageModel.hh"
+#include "TFSoftmaxAdapter.hh"
 
 namespace Lm {
 
-class TFRecurrentLanguageModel : public AbstractNNLanguageModel, public SearchSpaceAwareLanguageModel {
+class TFRecurrentLanguageModel : public RecurrentLanguageModel<Tensorflow::Tensor, Tensorflow::Variable> {
 public:
-    struct TimeStatistics {
-        std::chrono::duration<double, std::milli> total_duration;
-        std::chrono::duration<double, std::milli> early_request_duration;
-        std::chrono::duration<double, std::milli> request_duration;
-        std::chrono::duration<double, std::milli> prepare_duration;
-        std::chrono::duration<double, std::milli> merge_state_duration;
-        std::chrono::duration<double, std::milli> set_state_duration;
-        std::chrono::duration<double, std::milli> run_nn_output_duration;
-        std::chrono::duration<double, std::milli> set_nn_output_duration;
-        std::chrono::duration<double, std::milli> get_new_state_duration;
-        std::chrono::duration<double, std::milli> split_state_duration;
-        std::chrono::duration<double, std::milli> softmax_output_duration;
-
-        TimeStatistics  operator+(TimeStatistics const& other) const;
-        TimeStatistics& operator+=(TimeStatistics const& other);
-
-        void write(Core::XmlChannel& channel) const;
-        void write(std::ostream& out) const;
-    };
-
-    typedef AbstractNNLanguageModel                               Precursor;
-    typedef moodycamel::BlockingReaderWriterQueue<History const*> HistoryQueue;
-
-    static const Core::ParameterBool   paramTransformOuputLog;
-    static const Core::ParameterBool   paramTransformOuputNegate;
-    static const Core::ParameterInt    paramMinBatchSize;
-    static const Core::ParameterInt    paramOptBatchSize;
-    static const Core::ParameterInt    paramMaxBatchSize;
-    static const Core::ParameterInt    paramHistoryPruningThreshold;
-    static const Core::ParameterInt    paramPrunedHistoryLength;
-    static const Core::ParameterFloat  paramBatchPruningThreshold;
-    static const Core::ParameterBool   paramAllowReducedHistory;
-    static const Core::ParameterBool   paramDumpInputs;
-    static const Core::ParameterString paramDumpInputsPrefix;
-    static const Core::ParameterBool   paramDumpScores;
-    static const Core::ParameterString paramDumpScoresPrefix;
-    static const Core::ParameterBool   paramLogMemory;
-    static const Core::ParameterBool   paramFreeMemory;
-    static const Core::ParameterInt    paramFreeMemoryDelay;
-    static const Core::ParameterBool   paramAsync;
-    static const Core::ParameterBool   paramSingleStepOnly;
-    static const Core::ParameterBool   paramVerbose;
+    using Precursor = RecurrentLanguageModel<Tensorflow::Tensor, Tensorflow::Variable>;
 
     TFRecurrentLanguageModel(Core::Configuration const& c, Bliss::LexiconRef l);
-    virtual ~TFRecurrentLanguageModel();
-
-    virtual History startHistory() const;
-    virtual History extendedHistory(History const& hist, Token w) const;
-    virtual History extendedHistory(History const& hist, Bliss::Token::Id w) const;
-    virtual History reducedHistory(History const& hist, u32 limit) const;
-    virtual Score   score(History const& hist, Token w) const;
-    virtual bool    scoreCached(History const& hist, Token w) const;
-
-    virtual void startFrame(Search::TimeframeIndex time) const;
-    virtual void setInfo(History const& hist, SearchSpaceInformation const& info) const;
+    virtual ~TFRecurrentLanguageModel() {}
 
 protected:
-    virtual void load();
+    virtual void                            setState(std::vector<std::pair<std::string, Tensorflow::Tensor>> const& inputs, std::vector<std::string> const& targets) const;
+    virtual void                            extendInputs(std::vector<std::pair<std::string, Tensorflow::Tensor>>& inputs, Math::FastMatrix<s32> const& words, Math::FastVector<s32> const& word_lengths, std::vector<s32> const& state_lengths) const;
+    virtual void                            extendTargets(std::vector<std::string>& targets) const;
+    virtual void                            getOutputs(std::vector<std::pair<std::string, Tensorflow::Tensor>>& inputs, std::vector<Tensorflow::Tensor>& outputs, std::vector<std::string> const& targets) const;
+    virtual std::vector<Tensorflow::Tensor> fetchStates(std::vector<Tensorflow::Tensor>& outputs) const;
 
-private:
-    bool                        transform_output_log_;
-    bool                        transform_output_negate_;
-    std::function<Score(Score)> output_transform_function_;
-    size_t                      min_batch_size_;
-    size_t                      opt_batch_size_;
-    size_t                      max_batch_size_;
-    size_t                      history_pruning_threshold_;
-    size_t                      pruned_history_length_;
-    Score                       batch_pruning_threshold_;
-    bool                        allow_reduced_history_;
-    bool                        dump_inputs_;
-    std::string                 dump_inputs_prefix_;
-    bool                        dump_scores_;
-    std::string                 dump_scores_prefix_;
-    bool                        log_memory_;
-    bool                        free_memory_;
-    Search::TimeframeIndex      free_memory_delay_;
-    bool                        async_;
-    bool                        single_step_only_;
-    bool                        verbose_;
+    virtual Score transformOutput(Lm::CompressedVectorPtr<float> const& nn_output, size_t index) const;
 
+private:
     mutable Tensorflow::Session              session_;
     std::unique_ptr<Tensorflow::GraphLoader> loader_;
     std::unique_ptr<Tensorflow::Graph>       graph_;
     Tensorflow::TensorInputMap               tensor_input_map_;
     Tensorflow::TensorOutputMap              tensor_output_map_;
 
-    CompressedVectorFactoryPtr<float> state_comp_vec_factory_;
-    CompressedVectorFactoryPtr<float> nn_output_comp_vec_factory_;
-
-    std::vector<Tensorflow::Variable> state_variables_;
-    std::unique_ptr<StateManager>     state_manager_;
-    std::unique_ptr<SoftmaxAdapter>   softmax_adapter_;
+    std::unique_ptr<TFSoftmaxAdapter> softmax_adapter_;
 
     std::vector<std::string> initializer_tensor_names_;
     std::vector<std::string> output_tensor_names_;
     std::vector<std::string> read_vars_tensor_names_;
-
-    History empty_history_;  // a history used to provide the previous (all zero) state to the first real history (1 sentence-begin token)
-
-    mutable Core::XmlChannel       statistics_;
-    mutable Search::TimeframeIndex current_time_;
-    mutable std::vector<double>    run_time_;
-    mutable std::vector<size_t>    run_count_;
-    mutable double                 total_wait_time_;
-    mutable double                 total_start_frame_time_;
-    mutable double                 total_expand_hist_time_;
-    mutable TimeStatistics         fwd_statistics_;
-    mutable size_t                 dump_inputs_counter_;
-
-    // members for async forwarding
-    std::thread background_forwarder_thread_;
-    bool        should_stop_;
-
-    mutable std::atomic<History const*>  to_fwd_;
-    mutable std::promise<History const*> to_fwd_finished_;
-
-    mutable std::vector<History const*> pending_;
-    mutable HistoryQueue                fwd_queue_;
-    mutable HistoryQueue                finished_queue_;
-
-    History extendHistoryWithOutputIdx(History const& hist, size_t w) const;
-
-    void background_forward() const;
-    template<bool async>
-    void forward(Lm::History const* hist) const;
 };
 
 }  // namespace Lm
diff --git a/src/Lm/SoftmaxAdapter.hh b/src/Lm/TFSoftmaxAdapter.hh
similarity index 82%
rename from src/Lm/SoftmaxAdapter.hh
rename to src/Lm/TFSoftmaxAdapter.hh
index c5e1adb45..989ee4b4c 100644
--- a/src/Lm/SoftmaxAdapter.hh
+++ b/src/Lm/TFSoftmaxAdapter.hh
@@ -25,12 +25,12 @@ namespace Lm {
 
 using Score = float;
 
-class SoftmaxAdapter : public Core::Component {
+class TFSoftmaxAdapter : public Core::Component {
 public:
     using Precursor = Core::Component;
 
-    SoftmaxAdapter(Core::Configuration const& config);
-    virtual ~SoftmaxAdapter() = default;
+    TFSoftmaxAdapter(Core::Configuration const& config);
+    virtual ~TFSoftmaxAdapter() = default;
 
     virtual void               init(Tensorflow::Session& session, Tensorflow::TensorInputMap const& input_map, Tensorflow::TensorOutputMap const& output_map) = 0;
     virtual Score              get_score(Lm::CompressedVectorPtr<float> const& nn_out, size_t output_idx)                                                     = 0;
@@ -41,11 +41,11 @@ private:
 
 // inline implementations
 
-inline SoftmaxAdapter::SoftmaxAdapter(Core::Configuration const& config)
+inline TFSoftmaxAdapter::TFSoftmaxAdapter(Core::Configuration const& config)
         : Precursor(config) {
 }
 
-inline std::vector<Score> SoftmaxAdapter::get_scores(Lm::CompressedVectorPtr<float> const& nn_out, std::vector<size_t> const& output_idxs) {
+inline std::vector<Score> TFSoftmaxAdapter::get_scores(Lm::CompressedVectorPtr<float> const& nn_out, std::vector<size_t> const& output_idxs) {
     std::vector<Score> scores;
     scores.reserve(output_idxs.size());
     for (size_t output_idx : output_idxs) {
diff --git a/src/Lm/TransformerStateManager.cc b/src/Lm/TFTransformerStateManager.cc
similarity index 61%
rename from src/Lm/TransformerStateManager.cc
rename to src/Lm/TFTransformerStateManager.cc
index 2bce463fd..cdd25e727 100644
--- a/src/Lm/TransformerStateManager.cc
+++ b/src/Lm/TFTransformerStateManager.cc
@@ -12,7 +12,7 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
-#include "TransformerStateManager.hh"
+#include "TFTransformerStateManager.hh"
 
 #include "FixedQuantizationCompressedVectorFactory.hh"
 
@@ -72,28 +72,28 @@ void uncompress(Lm::CompressedVector<float> const* vec, int8_t* dst, B const& b)
 
 namespace Lm {
 
-/* ----------------------------------- TransformerStateManager ---------------------------------- */
+/* ----------------------------------- TFTransformerStateManager ---------------------------------- */
 
 template<typename T>
-const Core::ParameterInt          TransformerStateManager<T>::paramMaxHistoryLength("max-history",
-                                                                                    "maximum length of the history to feed to the transformer",
-                                                                                    std::numeric_limits<int>::max(),
-                                                                                    0);
-template const Core::ParameterInt TransformerStateManager<float>::paramMaxHistoryLength;
-template const Core::ParameterInt TransformerStateManager<int16_t>::paramMaxHistoryLength;
-template const Core::ParameterInt TransformerStateManager<int8_t>::paramMaxHistoryLength;
+const Core::ParameterInt          TFTransformerStateManager<T>::paramMaxHistoryLength("max-history",
+                                                                                      "maximum length of the history to feed to the transformer",
+                                                                                      std::numeric_limits<int>::max(),
+                                                                                      0);
+template const Core::ParameterInt TFTransformerStateManager<float>::paramMaxHistoryLength;
+template const Core::ParameterInt TFTransformerStateManager<int16_t>::paramMaxHistoryLength;
+template const Core::ParameterInt TFTransformerStateManager<int8_t>::paramMaxHistoryLength;
 
 template<typename T>
-const Core::ParameterBool          TransformerStateManager<T>::paramAlwaysIncludeFirstTokenState("always-include-first-token-state",
-                                                                                                 "wether to always include the state of the first token, even if history is restricted by max-history",
-                                                                                                 false);
-template const Core::ParameterBool TransformerStateManager<float>::paramAlwaysIncludeFirstTokenState;
-template const Core::ParameterBool TransformerStateManager<int16_t>::paramAlwaysIncludeFirstTokenState;
-template const Core::ParameterBool TransformerStateManager<int8_t>::paramAlwaysIncludeFirstTokenState;
+const Core::ParameterBool          TFTransformerStateManager<T>::paramAlwaysIncludeFirstTokenState("always-include-first-token-state",
+                                                                                                   "wether to always include the state of the first token, even if history is restricted by max-history",
+                                                                                                   false);
+template const Core::ParameterBool TFTransformerStateManager<float>::paramAlwaysIncludeFirstTokenState;
+template const Core::ParameterBool TFTransformerStateManager<int16_t>::paramAlwaysIncludeFirstTokenState;
+template const Core::ParameterBool TFTransformerStateManager<int8_t>::paramAlwaysIncludeFirstTokenState;
 
 template<typename T>
-typename TransformerStateManager<T>::HistoryState TransformerStateManager<T>::initialState(StateVariables const& vars, CompressedVectorFactory<float> const& vector_factory) {
-    TransformerStateManager::HistoryState result;
+typename TFTransformerStateManager<T>::HistoryState TFTransformerStateManager<T>::initialState(StateVariables const& vars, CompressedVectorFactory<float> const& vector_factory) {
+    TFTransformerStateManager::HistoryState result;
     result.reserve(vars.size());
 
     std::vector<float> vec(0, 0.0f);
@@ -107,16 +107,16 @@ typename TransformerStateManager<T>::HistoryState TransformerStateManager<T>::in
 
     return result;
 }
-template typename TransformerStateManager<float>::HistoryState   TransformerStateManager<float>::initialState(StateVariables const& vars, CompressedVectorFactory<float> const& vector_factory);
-template typename TransformerStateManager<int16_t>::HistoryState TransformerStateManager<int16_t>::initialState(StateVariables const& vars, CompressedVectorFactory<float> const& vector_factory);
-template typename TransformerStateManager<int8_t>::HistoryState  TransformerStateManager<int8_t>::initialState(StateVariables const& vars, CompressedVectorFactory<float> const& vector_factory);
+template typename TFTransformerStateManager<float>::HistoryState   TFTransformerStateManager<float>::initialState(StateVariables const& vars, CompressedVectorFactory<float> const& vector_factory);
+template typename TFTransformerStateManager<int16_t>::HistoryState TFTransformerStateManager<int16_t>::initialState(StateVariables const& vars, CompressedVectorFactory<float> const& vector_factory);
+template typename TFTransformerStateManager<int8_t>::HistoryState  TFTransformerStateManager<int8_t>::initialState(StateVariables const& vars, CompressedVectorFactory<float> const& vector_factory);
 
 template<typename T>
-void TransformerStateManager<T>::mergeStates(StateVariables const&                   vars,
-                                             std::vector<size_t>&                    prefix_lengths,
-                                             std::vector<HistoryState const*> const& prefix_states,
-                                             FeedDict&                               feed_dict,
-                                             TargetList&                             targets) {
+void TFTransformerStateManager<T>::mergeStates(StateVariables const&                   vars,
+                                               std::vector<size_t>&                    prefix_lengths,
+                                               std::vector<HistoryState const*> const& prefix_states,
+                                               FeedDict&                               feed_dict,
+                                               TargetList&                             targets) {
     std::vector<size_t> original_prefix_lengths(prefix_lengths);
 
     size_t max_prefix = 0ul;
@@ -180,28 +180,28 @@ void TransformerStateManager<T>::mergeStates(StateVariables const&
     }
 }
 
-template void TransformerStateManager<float>::mergeStates(StateVariables const&                   vars,
-                                                          std::vector<size_t>&                    prefix_lengths,
-                                                          std::vector<HistoryState const*> const& prefix_states,
-                                                          FeedDict&                               feed_dict,
-                                                          TargetList&                             targets);
-template void TransformerStateManager<int16_t>::mergeStates(StateVariables const&                   vars,
+template void TFTransformerStateManager<float>::mergeStates(StateVariables const&                   vars,
                                                             std::vector<size_t>&                    prefix_lengths,
                                                             std::vector<HistoryState const*> const& prefix_states,
                                                             FeedDict&                               feed_dict,
                                                             TargetList&                             targets);
-template void TransformerStateManager<int8_t>::mergeStates(StateVariables const&                   vars,
-                                                           std::vector<size_t>&                    prefix_lengths,
-                                                           std::vector<HistoryState const*> const& prefix_states,
-                                                           FeedDict&                               feed_dict,
-                                                           TargetList&                             targets);
+template void TFTransformerStateManager<int16_t>::mergeStates(StateVariables const&                   vars,
+                                                              std::vector<size_t>&                    prefix_lengths,
+                                                              std::vector<HistoryState const*> const& prefix_states,
+                                                              FeedDict&                               feed_dict,
+                                                              TargetList&                             targets);
+template void TFTransformerStateManager<int8_t>::mergeStates(StateVariables const&                   vars,
+                                                             std::vector<size_t>&                    prefix_lengths,
+                                                             std::vector<HistoryState const*> const& prefix_states,
+                                                             FeedDict&                               feed_dict,
+                                                             TargetList&                             targets);
 
 template<typename T>
-std::vector<typename TransformerStateManager<T>::HistoryState>
-        TransformerStateManager<T>::splitStates(StateVariables const&                  vars,
-                                                std::vector<size_t>&                   suffix_lengths,
-                                                std::vector<Tensorflow::Tensor> const& state_tensors,
-                                                CompressedVectorFactory<float> const&  vector_factory) {
+std::vector<typename TFTransformerStateManager<T>::HistoryState>
+        TFTransformerStateManager<T>::splitStates(StateVariables const&                  vars,
+                                                  std::vector<size_t>&                   suffix_lengths,
+                                                  std::vector<Tensorflow::Tensor> const& state_tensors,
+                                                  CompressedVectorFactory<float> const&  vector_factory) {
     require_eq(vars.size(), state_tensors.size());
 
     size_t max_suffix = *std::max_element(suffix_lengths.begin(), suffix_lengths.end());
@@ -258,78 +258,78 @@ std::vector<typename TransformerStateManager<T>::HistoryState>
     return result;
 }
 
-template std::vector<typename TransformerStateManager<float>::HistoryState>
-        TransformerStateManager<float>::splitStates(StateVariables const&                  vars,
-                                                    std::vector<size_t>&                   suffix_lengths,
-                                                    std::vector<Tensorflow::Tensor> const& state_tensors,
-                                                    CompressedVectorFactory<float> const&  vector_factory);
-template std::vector<typename TransformerStateManager<int16_t>::HistoryState>
-        TransformerStateManager<int16_t>::splitStates(StateVariables const&                  vars,
+template std::vector<typename TFTransformerStateManager<float>::HistoryState>
+        TFTransformerStateManager<float>::splitStates(StateVariables const&                  vars,
                                                       std::vector<size_t>&                   suffix_lengths,
                                                       std::vector<Tensorflow::Tensor> const& state_tensors,
                                                       CompressedVectorFactory<float> const&  vector_factory);
-template std::vector<typename TransformerStateManager<int8_t>::HistoryState>
-        TransformerStateManager<int8_t>::splitStates(StateVariables const&                  vars,
-                                                     std::vector<size_t>&                   suffix_lengths,
-                                                     std::vector<Tensorflow::Tensor> const& state_tensors,
-                                                     CompressedVectorFactory<float> const&  vector_factory);
-
-/* ----------------------------------- TransformerStateManagerWithCommonPrefix ---------------------------------- */
+template std::vector<typename TFTransformerStateManager<int16_t>::HistoryState>
+        TFTransformerStateManager<int16_t>::splitStates(StateVariables const&                  vars,
+                                                        std::vector<size_t>&                   suffix_lengths,
+                                                        std::vector<Tensorflow::Tensor> const& state_tensors,
+                                                        CompressedVectorFactory<float> const&  vector_factory);
+template std::vector<typename TFTransformerStateManager<int8_t>::HistoryState>
+        TFTransformerStateManager<int8_t>::splitStates(StateVariables const&                  vars,
+                                                       std::vector<size_t>&                   suffix_lengths,
+                                                       std::vector<Tensorflow::Tensor> const& state_tensors,
+                                                       CompressedVectorFactory<float> const&  vector_factory);
+
+/* ----------------------------------- TFTransformerStateManagerWithCommonPrefix ---------------------------------- */
 
 template<typename T>
-const Core::ParameterString          TransformerStateManagerWithCommonPrefix<T>::paramVarName("var-name", "the name of the original state variable", "");
-template const Core::ParameterString TransformerStateManagerWithCommonPrefix<float>::paramVarName;
-template const Core::ParameterString TransformerStateManagerWithCommonPrefix<int16_t>::paramVarName;
-template const Core::ParameterString TransformerStateManagerWithCommonPrefix<int8_t>::paramVarName;
+const Core::ParameterString          TFTransformerStateManagerWithCommonPrefix<T>::paramVarName("var-name", "the name of the original state variable", "");
+template const Core::ParameterString TFTransformerStateManagerWithCommonPrefix<float>::paramVarName;
+template const Core::ParameterString TFTransformerStateManagerWithCommonPrefix<int16_t>::paramVarName;
+template const Core::ParameterString TFTransformerStateManagerWithCommonPrefix<int8_t>::paramVarName;
 
 template<typename T>
-const Core::ParameterString          TransformerStateManagerWithCommonPrefix<T>::paramCommonPrefixInitialValue("common-prefix-initial-value", "the name the initial-value of the corresponding common-prefix variable", "");
-template const Core::ParameterString TransformerStateManagerWithCommonPrefix<float>::paramCommonPrefixInitialValue;
-template const Core::ParameterString TransformerStateManagerWithCommonPrefix<int16_t>::paramCommonPrefixInitialValue;
-template const Core::ParameterString TransformerStateManagerWithCommonPrefix<int8_t>::paramCommonPrefixInitialValue;
+const Core::ParameterString          TFTransformerStateManagerWithCommonPrefix<T>::paramCommonPrefixInitialValue("common-prefix-initial-value", "the name the initial-value of the corresponding common-prefix variable", "");
+template const Core::ParameterString TFTransformerStateManagerWithCommonPrefix<float>::paramCommonPrefixInitialValue;
+template const Core::ParameterString TFTransformerStateManagerWithCommonPrefix<int16_t>::paramCommonPrefixInitialValue;
+template const Core::ParameterString TFTransformerStateManagerWithCommonPrefix<int8_t>::paramCommonPrefixInitialValue;
 
 template<typename T>
-const Core::ParameterString          TransformerStateManagerWithCommonPrefix<T>::paramCommonPrefixInitializer("common-prefix-initializer", "the name of the initializer of the corresponding common-prefix variable", "");
-template const Core::ParameterString TransformerStateManagerWithCommonPrefix<float>::paramCommonPrefixInitializer;
-template const Core::ParameterString TransformerStateManagerWithCommonPrefix<int16_t>::paramCommonPrefixInitializer;
-template const Core::ParameterString TransformerStateManagerWithCommonPrefix<int8_t>::paramCommonPrefixInitializer;
+const Core::ParameterString          TFTransformerStateManagerWithCommonPrefix<T>::paramCommonPrefixInitializer("common-prefix-initializer", "the name of the initializer of the corresponding common-prefix variable", "");
+template const Core::ParameterString TFTransformerStateManagerWithCommonPrefix<float>::paramCommonPrefixInitializer;
+template const Core::ParameterString TFTransformerStateManagerWithCommonPrefix<int16_t>::paramCommonPrefixInitializer;
+template const Core::ParameterString TFTransformerStateManagerWithCommonPrefix<int8_t>::paramCommonPrefixInitializer;
 
 template<typename T>
-const Core::ParameterBool          TransformerStateManagerWithCommonPrefix<T>::paramCachePrefix("cache-prefix", "wether to reuse the prefix if it's the same", false);
-template const Core::ParameterBool TransformerStateManagerWithCommonPrefix<float>::paramCachePrefix;
-template const Core::ParameterBool TransformerStateManagerWithCommonPrefix<int16_t>::paramCachePrefix;
-template const Core::ParameterBool TransformerStateManagerWithCommonPrefix<int8_t>::paramCachePrefix;
+const Core::ParameterBool          TFTransformerStateManagerWithCommonPrefix<T>::paramCachePrefix("cache-prefix", "wether to reuse the prefix if it's the same", false);
+template const Core::ParameterBool TFTransformerStateManagerWithCommonPrefix<float>::paramCachePrefix;
+template const Core::ParameterBool TFTransformerStateManagerWithCommonPrefix<int16_t>::paramCachePrefix;
+template const Core::ParameterBool TFTransformerStateManagerWithCommonPrefix<int8_t>::paramCachePrefix;
 
 template<typename T>
-const Core::ParameterInt          TransformerStateManagerWithCommonPrefix<T>::paramMinBatchSize("min-batch-size",
-                                                                                                "for batches smaller than the given size we set the common-prefix length to 0",
-                                                                                                2, 0);
-template const Core::ParameterInt TransformerStateManagerWithCommonPrefix<float>::paramMinBatchSize;
-template const Core::ParameterInt TransformerStateManagerWithCommonPrefix<int16_t>::paramMinBatchSize;
-template const Core::ParameterInt TransformerStateManagerWithCommonPrefix<int8_t>::paramMinBatchSize;
+const Core::ParameterInt          TFTransformerStateManagerWithCommonPrefix<T>::paramMinBatchSize("min-batch-size",
+                                                                                                  "for batches smaller than the given size we set the common-prefix length to 0",
+                                                                                                  2, 0);
+template const Core::ParameterInt TFTransformerStateManagerWithCommonPrefix<float>::paramMinBatchSize;
+template const Core::ParameterInt TFTransformerStateManagerWithCommonPrefix<int16_t>::paramMinBatchSize;
+template const Core::ParameterInt TFTransformerStateManagerWithCommonPrefix<int8_t>::paramMinBatchSize;
 
 template<typename T>
-const Core::ParameterInt          TransformerStateManagerWithCommonPrefix<T>::paramMinCommonPrefixLength("min-common-prefix-length",
-                                                                                                         "if the common-prefix length is smaller than this value, set it to 0",
-                                                                                                         1, 0);
-template const Core::ParameterInt TransformerStateManagerWithCommonPrefix<float>::paramMinCommonPrefixLength;
-template const Core::ParameterInt TransformerStateManagerWithCommonPrefix<int16_t>::paramMinCommonPrefixLength;
-template const Core::ParameterInt TransformerStateManagerWithCommonPrefix<int8_t>::paramMinCommonPrefixLength;
+const Core::ParameterInt          TFTransformerStateManagerWithCommonPrefix<T>::paramMinCommonPrefixLength("min-common-prefix-length",
+                                                                                                           "if the common-prefix length is smaller than this value, set it to 0",
+                                                                                                           1, 0);
+template const Core::ParameterInt TFTransformerStateManagerWithCommonPrefix<float>::paramMinCommonPrefixLength;
+template const Core::ParameterInt TFTransformerStateManagerWithCommonPrefix<int16_t>::paramMinCommonPrefixLength;
+template const Core::ParameterInt TFTransformerStateManagerWithCommonPrefix<int8_t>::paramMinCommonPrefixLength;
 
 template<typename T>
-const Core::ParameterInt          TransformerStateManagerWithCommonPrefix<T>::paramMaxCommonPrefixLength("max-common-prefix-length",
-                                                                                                         "Truncate the common prefix to this length. Observes always-include-first-token-state.",
-                                                                                                         std::numeric_limits<int>::max(), 0);
-template const Core::ParameterInt TransformerStateManagerWithCommonPrefix<float>::paramMaxCommonPrefixLength;
-template const Core::ParameterInt TransformerStateManagerWithCommonPrefix<int16_t>::paramMaxCommonPrefixLength;
-template const Core::ParameterInt TransformerStateManagerWithCommonPrefix<int8_t>::paramMaxCommonPrefixLength;
+const Core::ParameterInt          TFTransformerStateManagerWithCommonPrefix<T>::paramMaxCommonPrefixLength("max-common-prefix-length",
+                                                                                                           "Truncate the common prefix to this length. Observes always-include-first-token-state.",
+                                                                                                           std::numeric_limits<int>::max(), 0);
+template const Core::ParameterInt TFTransformerStateManagerWithCommonPrefix<float>::paramMaxCommonPrefixLength;
+template const Core::ParameterInt TFTransformerStateManagerWithCommonPrefix<int16_t>::paramMaxCommonPrefixLength;
+template const Core::ParameterInt TFTransformerStateManagerWithCommonPrefix<int8_t>::paramMaxCommonPrefixLength;
 
 template<typename T>
-void TransformerStateManagerWithCommonPrefix<T>::mergeStates(typename Precursor::StateVariables const&                   vars,
-                                                             std::vector<size_t>&                                        prefix_lengths,
-                                                             std::vector<typename Precursor::HistoryState const*> const& prefix_states,
-                                                             typename Precursor::FeedDict&                               feed_dict,
-                                                             typename Precursor::TargetList&                             targets) {
+void TFTransformerStateManagerWithCommonPrefix<T>::mergeStates(typename Precursor::StateVariables const&                   vars,
+                                                               std::vector<size_t>&                                        prefix_lengths,
+                                                               std::vector<typename Precursor::HistoryState const*> const& prefix_states,
+                                                               typename Precursor::FeedDict&                               feed_dict,
+                                                               typename Precursor::TargetList&                             targets) {
     std::vector<size_t> original_prefix_lengths(prefix_lengths);
     std::vector<size_t> batch_offsets;
     batch_offsets.reserve(prefix_lengths.size() + 1ul);
@@ -464,20 +464,20 @@ void TransformerStateManagerWithCommonPrefix<T>::mergeStates(typename Precursor:
     }
 }
 
-template void TransformerStateManagerWithCommonPrefix<float>::mergeStates(StateVariables const&                   vars,
-                                                                          std::vector<size_t>&                    prefix_lengths,
-                                                                          std::vector<HistoryState const*> const& prefix_states,
-                                                                          FeedDict&                               feed_dict,
-                                                                          TargetList&                             targets);
-template void TransformerStateManagerWithCommonPrefix<int16_t>::mergeStates(StateVariables const&                   vars,
+template void TFTransformerStateManagerWithCommonPrefix<float>::mergeStates(StateVariables const&                   vars,
                                                                             std::vector<size_t>&                    prefix_lengths,
                                                                             std::vector<HistoryState const*> const& prefix_states,
                                                                             FeedDict&                               feed_dict,
                                                                             TargetList&                             targets);
-template void TransformerStateManagerWithCommonPrefix<int8_t>::mergeStates(StateVariables const&                   vars,
-                                                                           std::vector<size_t>&                    prefix_lengths,
-                                                                           std::vector<HistoryState const*> const& prefix_states,
-                                                                           FeedDict&                               feed_dict,
-                                                                           TargetList&                             targets);
+template void TFTransformerStateManagerWithCommonPrefix<int16_t>::mergeStates(StateVariables const&                   vars,
+                                                                              std::vector<size_t>&                    prefix_lengths,
+                                                                              std::vector<HistoryState const*> const& prefix_states,
+                                                                              FeedDict&                               feed_dict,
+                                                                              TargetList&                             targets);
+template void TFTransformerStateManagerWithCommonPrefix<int8_t>::mergeStates(StateVariables const&                   vars,
+                                                                             std::vector<size_t>&                    prefix_lengths,
+                                                                             std::vector<HistoryState const*> const& prefix_states,
+                                                                             FeedDict&                               feed_dict,
+                                                                             TargetList&                             targets);
 
 }  // namespace Lm
diff --git a/src/Lm/TransformerStateManager.hh b/src/Lm/TFTransformerStateManager.hh
similarity index 82%
rename from src/Lm/TransformerStateManager.hh
rename to src/Lm/TFTransformerStateManager.hh
index cfafbc806..5fac61dd6 100644
--- a/src/Lm/TransformerStateManager.hh
+++ b/src/Lm/TFTransformerStateManager.hh
@@ -15,22 +15,25 @@
 #ifndef _LM_TRANSFORMER_STATE_MANAGER_HH
 #define _LM_TRANSFORMER_STATE_MANAGER_HH
 
-#include "StateManager.hh"
+#include "AbstractStateManager.hh"
+
+#include <Tensorflow/Graph.hh>
+#include <Tensorflow/Tensor.hh>
 
 #include <Bliss/Symbol.hh>
 
 namespace Lm {
 
 template<typename T>
-class TransformerStateManager : public StateManager {
+class TFTransformerStateManager : public AbstractStateManager<Tensorflow::Tensor, Tensorflow::Variable> {
 public:
-    using Precursor = StateManager;
+    using Precursor = AbstractStateManager<Tensorflow::Tensor, Tensorflow::Variable>;
 
     static const Core::ParameterInt  paramMaxHistoryLength;
     static const Core::ParameterBool paramAlwaysIncludeFirstTokenState;
 
-    TransformerStateManager(Core::Configuration const& config);
-    virtual ~TransformerStateManager() = default;
+    TFTransformerStateManager(Core::Configuration const& config);
+    virtual ~TFTransformerStateManager() = default;
 
     virtual bool requiresAllParentStates() const;
 
@@ -51,9 +54,9 @@ protected:
 };
 
 template<typename T>
-class TransformerStateManagerWithCommonPrefix : public TransformerStateManager<T> {
+class TFTransformerStateManagerWithCommonPrefix : public TFTransformerStateManager<T> {
 public:
-    using Precursor = TransformerStateManager<T>;
+    using Precursor = TFTransformerStateManager<T>;
 
     static const Core::ParameterString paramVarName;
     static const Core::ParameterString paramCommonPrefixInitialValue;
@@ -63,8 +66,8 @@ public:
     static const Core::ParameterInt    paramMinCommonPrefixLength;
     static const Core::ParameterInt    paramMaxCommonPrefixLength;
 
-    TransformerStateManagerWithCommonPrefix(Core::Configuration const& config);
-    virtual ~TransformerStateManagerWithCommonPrefix() = default;
+    TFTransformerStateManagerWithCommonPrefix(Core::Configuration const& config);
+    virtual ~TFTransformerStateManagerWithCommonPrefix() = default;
 
     virtual void mergeStates(typename Precursor::StateVariables const&                   vars,
                              std::vector<size_t>&                                        prefix_lengths,
@@ -86,19 +89,19 @@ protected:
 // inline implementations
 
 template<typename T>
-inline TransformerStateManager<T>::TransformerStateManager(Core::Configuration const& config)
+inline TFTransformerStateManager<T>::TFTransformerStateManager(Core::Configuration const& config)
         : Precursor(config),
           maxHistory_(paramMaxHistoryLength(config)),
           alwaysIncludeFirstTokenState_(paramAlwaysIncludeFirstTokenState(config)) {
 }
 
 template<typename T>
-inline bool TransformerStateManager<T>::requiresAllParentStates() const {
+inline bool TFTransformerStateManager<T>::requiresAllParentStates() const {
     return true;
 }
 
 template<typename T>
-inline TransformerStateManagerWithCommonPrefix<T>::TransformerStateManagerWithCommonPrefix(Core::Configuration const& config)
+inline TFTransformerStateManagerWithCommonPrefix<T>::TFTransformerStateManagerWithCommonPrefix(Core::Configuration const& config)
         : Precursor(config),
           cachePrefix_(paramCachePrefix(config)),
           minBatchSize_(paramMinBatchSize(config)),
diff --git a/src/Lm/Zerogram.cc b/src/Lm/Zerogram.cc
index b8bb67118..441e71283 100644
--- a/src/Lm/Zerogram.cc
+++ b/src/Lm/Zerogram.cc
@@ -19,7 +19,8 @@
 using namespace Lm;
 
 Zerogram::Zerogram(const Core::Configuration& c, Bliss::LexiconRef l)
-        : Core::Component(c), LanguageModel(c, l) {
+        : Core::Component(c),
+          LanguageModel(c, l) {
     historyManager_ = this;
     log("Zerogram LM probability is 1/%d", lexicon()->nSyntacticTokens());
     score_ = ::log(f64(lexicon()->nSyntacticTokens()));
diff --git a/src/Lm/Zerogram.hh b/src/Lm/Zerogram.hh
index 2a62a2578..c7ee95fe8 100644
--- a/src/Lm/Zerogram.hh
+++ b/src/Lm/Zerogram.hh
@@ -30,13 +30,17 @@ private:
 
 public:
     Zerogram(const Core::Configuration& c, Bliss::LexiconRef);
+
     virtual Fsa::ConstAutomatonRef getFsa() const;
-    virtual History                startHistory() const {
+
+    virtual History startHistory() const {
         return history(0);
     }
+
     virtual History extendedHistory(const History& h, Token) const {
         return h;
     }
+
     virtual Score score(const History&, Token) const {
         return score_;
     }
diff --git a/src/Lm/patch-philips-lm b/src/Lm/patch-philips-lm
deleted file mode 100755
index e020ef92f..000000000
--- a/src/Lm/patch-philips-lm
+++ /dev/null
@@ -1,31 +0,0 @@
-#!/bin/bash
-# $Id$
-
-# This utility program patches an original Philips language model file
-# to use it with Sprint/Lm
-#
-# The following adaptations are performed:
-# - Certain keywords in the class LM are changed to their non-class
-#   equivalents.
-# - German TeX-style umlauts are converted to UTF-8.
-# - Should any non-ASCII characters occur, they are interpreted as
-#   ISO-8859-1 and consequently converted to UTF-8.
-
-if [ $# -eq 2 ]; then
-    orig=$1
-    out=$2
-else
-    echo "Usage: $0 <input> <output>"
-    echo "input: original Philips language model file"
-    echo "output: patched Philips LM for use with Sprint/Lm"
-    exit 1
-fi
-
-echo "reading Philips language model file from $orig"
-echo "writing patched LM to $out"
-
-cat $orig \
-| sed 's/"a/ä/g; s/"o/ö/g; s/"u/ü/g; s/"A/Ä/g; s/"O/Ö/g; s/"U/Ü/g; s/"s/ß/g;' \
-| sed 's/VMClassMgramScore/WordMGramScore/; s/ClassList/Vocabulary/;' \
-| iconv --from-code=ISO-8859-1 --to-code=UTF-8 \
-> $out
diff --git a/src/Math/AcousticalAnalyticFunctions.hh b/src/Math/AcousticalAnalyticFunctions.hh
index 45cc3e141..27a64cc34 100644
--- a/src/Math/AcousticalAnalyticFunctions.hh
+++ b/src/Math/AcousticalAnalyticFunctions.hh
@@ -90,7 +90,8 @@ struct BilinearTransform : public UnaryAnalyticFunction {
 
 public:
     BilinearTransform(Argument a, Argument T)
-            : a_(a), T_(T) {
+            : a_(a),
+              T_(T) {
         require(Core::abs(a) < 1);
         require(T > 0);
     }
diff --git a/src/Math/AnalyticFunction.hh b/src/Math/AnalyticFunction.hh
index 718108a93..2839eafbf 100644
--- a/src/Math/AnalyticFunction.hh
+++ b/src/Math/AnalyticFunction.hh
@@ -56,7 +56,8 @@ protected:
 
 public:
     AnalyticUnaryComposition(UnaryAnalyticFunctionRef f, UnaryAnalyticFunctionRef g)
-            : f_(f), g_(g) {
+            : f_(f),
+              g_(g) {
         require(f_);
         require(g_);
     }
diff --git a/src/Math/Complex.hh b/src/Math/Complex.hh
index b0ece3e86..6f97268f6 100644
--- a/src/Math/Complex.hh
+++ b/src/Math/Complex.hh
@@ -24,7 +24,11 @@ namespace Math {
 
 /** functor for the template constructor std::complex<T>::complex */
 template<class T>
-struct makeComplex : public std::binary_function<T, T, const std::complex<T>> {
+struct makeComplex {
+    using first_argument_type  = T;
+    using second_argument_type = T;
+    using result_type          = const std::complex<T>;
+
     std::complex<T> operator()(T real, T imaginary) const {
         return std::complex<T>(real, imaginary);
     }
@@ -32,15 +36,32 @@ struct makeComplex : public std::binary_function<T, T, const std::complex<T>> {
 
 /** function pointer functor to the template function abs(const std::complex<T> &) */
 template<class T>
-struct pointerAbs : public std::unary_function<const std::complex<T>, T> {
+struct pointerAbs {
+    using argument_type = const std::complex<T>;
+    using result_type   = T;
+
     T operator()(const std::complex<T>& v) const {
         return Core::abs(v);
     }
 };
 
+/** function pointer functor to the template function power(const std::complex<T> &) */
+template<class T>
+struct pointerAbsSqr {
+    using argument_type = const std::complex<T>;
+    using result_type   = T;
+
+    T operator()(const std::complex<T>& v) const {
+        return Core::abs(v) * Core::abs(v);
+    }
+};
+
 /** function pointer functor to the template function arg(const std::complex<T> &) */
 template<class T>
-struct pointerArg : public std::unary_function<const std::complex<T>, T> {
+struct pointerArg {
+    using argument_type = const std::complex<T>;
+    using result_type   = T;
+
     T operator()(const std::complex<T>& v) const {
         return arg(v);
     }
@@ -48,17 +69,23 @@ struct pointerArg : public std::unary_function<const std::complex<T>, T> {
 
 /** function pointer functor to the template function real(const std::complex<T> &) */
 template<class T>
-struct pointerReal : public std::unary_function<const std::complex<T>, T> {
+struct pointerReal {
+    using argument_type = const std::complex<T>;
+    using result_type   = T;
+
     T operator()(const std::complex<T>& v) const {
-        return real(v);
+        return std::real(v);
     }
 };
 
 /** function pointer functor to the template function imag(const std::complex<T> &) */
 template<class T>
-struct pointerImag : public std::unary_function<const std::complex<T>, T> {
+struct pointerImag {
+    using argument_type = const std::complex<T>;
+    using result_type   = T;
+
     T operator()(const std::complex<T>& v) const {
-        return imag(v);
+        return std::imag(v);
     }
 };
 
@@ -69,7 +96,7 @@ struct pointerImag : public std::unary_function<const std::complex<T>, T> {
  *	Alternating complex numbers are first transformed to a complex<InputType> object.
  *  Operation is transforms the complex<InputType> object:
  *     operation must support the function: OutputType operator()(const complex<InputType> &).
- * Operation is a unary function (derived from std::unary_function):
+ * Operation is a unary function:
  *  Argument must have a constructor with two parameters
  *  Result is of arbitrary type
  */
@@ -88,7 +115,7 @@ void transformAlternatingComplex(InputIterator first, InputIterator last,
 /** tranforms a vector of arbitrary type into an alternating complex vector
  * (Alternating complex vectors are stored in a standard container
  * by storing the real and the imaginary parts alternating.)
- * Operation is a unary function (derived from std::unary_function):
+ * Operation is a unary function:
  *  Argument is of arbitrary type
  *  For the result type the functions real and imag must exist.
  *
@@ -97,10 +124,10 @@ template<class InputIterator, class OutputIterator, class Operation>
 void transformToAlternatingComplex(InputIterator first, InputIterator last,
                                    OutputIterator result, Operation operation) {
     for (; first != last; result += 2, ++first) {
-        typename Operation::result_type r = operation(*first);
+        auto r = operation(*first);
 
-        *result       = real(r);
-        *(result + 1) = imag(r);
+        *result       = std::real(r);
+        *(result + 1) = std::imag(r);
     }
 }
 
@@ -108,7 +135,7 @@ void transformToAlternatingComplex(InputIterator first, InputIterator last,
  * (Alternating complex vectors are stored in a standard container
  * by storing the real and the imaginary parts alternating.)
  *
- * Operation is a binary function derived from std::binary_function:
+ * Operation is a binary function:
  *  Arguments must have a constructor with two parameters
  *  For the result type the functions real and imag must exist.
  */
@@ -124,14 +151,18 @@ void transformAlternatingComplexToAlternatingComplex(InputIterator first1, Input
                 typename Operation::first_argument_type(*real1, *imaginary1),
                 typename Operation::second_argument_type(*real2, *imaginary2));
 
-        *result       = real(r);
-        *(result + 1) = imag(r);
+        *result       = std::real(r);
+        *(result + 1) = std::imag(r);
     }
 }
 
 /** functors for x * conjugate(y) */
 template<class T>
-struct conjugateMultiplies : public std::binary_function<std::complex<T>, std::complex<T>, std::complex<T>> {
+struct conjugateMultiplies {
+    using first_argument_type  = std::complex<T>;
+    using second_argument_type = std::complex<T>;
+    using result_type          = std::complex<T>;
+
     std::complex<T> operator()(const std::complex<T>& x, const std::complex<T>& y) const {
         return x * conj(y);
     }
@@ -143,7 +174,7 @@ namespace Core {
 /** binary output for std::complex<T> */
 template<class T>
 Core::BinaryOutputStream& operator<<(Core::BinaryOutputStream& o, const std::complex<T>& c) {
-    return o << real(c) << imag(c);
+    return o << std::real(c) << std::imag(c);
 }
 
 /** binary input for std::complex<T> */
diff --git a/src/Math/CudaMatrixKernels.cu b/src/Math/CudaMatrixKernels.cu
index e1834dcde..91e2387be 100644
--- a/src/Math/CudaMatrixKernels.cu
+++ b/src/Math/CudaMatrixKernels.cu
@@ -751,7 +751,7 @@ __global__ void __cuda_addToAllColumnsWithOffset(T* data, T* datab, unsigned int
 }
 
 template<typename T>
-void _cuda_addToAllColumnsWithOffset(T* data, T* datab, unsigned int nRowsMat, unsigned nRowsVec, unsigned int nColumns, T alpha) {
+void _cuda_addToAllColumnsWithOffset(T* data, T* datab, unsigned int nRowsMat, unsigned int nRowsVec, unsigned int nColumns, T alpha) {
     // TODO implement kernel without % operator (slow on GPU)
     unsigned int nElements = nRowsVec * nColumns;
     int          gridSize  = (int)ceil((float)nElements / THREADS_PER_BLOCK);
diff --git a/src/Math/CudaVector.hh b/src/Math/CudaVector.hh
index 08c856ad8..3a18fcb5d 100644
--- a/src/Math/CudaVector.hh
+++ b/src/Math/CudaVector.hh
@@ -837,7 +837,7 @@ template<typename T>
 T CudaVector<T>::normEuclidean() const {
     require(isComputing_);
     if (gpuMode_) {
-        T result;
+        T result = 0;
         Cuda::nrm2(cublasHandle, nRows_, d_elem_, 1, &result);
         return result;
     }
diff --git a/src/Math/FastMatrix.hh b/src/Math/FastMatrix.hh
index a16f37eb1..6501e201b 100644
--- a/src/Math/FastMatrix.hh
+++ b/src/Math/FastMatrix.hh
@@ -520,24 +520,26 @@ s32 FastMatrix<T>::initialize() {
     return maxThreads;
 }
 
-/**	Allocate the memory for the matrix.
+/** Allocate the memory for the matrix.
  *
- * 	Allocate the memory for the matrix. If the size is 0 the pointer
- * 	is ZERO.
+ *  Allocate the memory for the matrix. If the size is 0 the pointer
+ *  is ZERO.
  */
 template<typename T>
 bool FastMatrix<T>::allocate(bool minimalSize) {
     if ((capacity_ < nRows_ * nColumns_) || (minimalSize && (capacity_ > nRows_ * nColumns_))) {
-        if (elem_)
+        if (elem_) {
             delete[] elem_;
-        try {
-            elem_     = nRows_ * nColumns_ > 0 ? new T[nRows_ * nColumns_] : 0;
-            capacity_ = nRows_ * nColumns_;
-            return true;
+            capacity_ = 0;
         }
-        catch (std::bad_alloc& ba) {
+
+        elem_ = nRows_ * nColumns_ > 0 ? new (std::nothrow) T[nRows_ * nColumns_] : nullptr;
+        if (elem_ == nullptr) {
             return false;
         }
+        capacity_ = nRows_ * nColumns_;
+
+        return true;
     }
     else
         return true;
@@ -1347,7 +1349,7 @@ void FastMatrix<T>::elementwiseDivision(const FastMatrix<T>& X) {
 
 template<typename T>
 void FastMatrix<T>::addConstantElementwise(T c) {
-    std::transform(elem_, elem_ + nRows_ * nColumns_, elem_, std::bind2nd(std::plus<T>(), c));
+    std::transform(elem_, elem_ + nRows_ * nColumns_, elem_, std::bind(std::plus<T>(), std::placeholders::_1, c));
 }
 
 template<typename T>
@@ -1394,7 +1396,7 @@ void FastMatrix<T>::addToAllRows(const FastVector<T>& v, T alpha) {
 #pragma omp parallel for
     for (u32 j = 0; j < nColumns_; j++) {
         T value = alpha * v.at(j);
-        std::transform(elem_ + j * nRows_, elem_ + (j + 1) * nRows_, elem_ + j * nRows_, std::bind2nd(std::plus<T>(), value));
+        std::transform(elem_ + j * nRows_, elem_ + (j + 1) * nRows_, elem_ + j * nRows_, std::bind(std::plus<T>(), std::placeholders::_1, value));
     }
 }
 
diff --git a/src/Math/FastVector.hh b/src/Math/FastVector.hh
index 534c56f1c..2940c39e3 100644
--- a/src/Math/FastVector.hh
+++ b/src/Math/FastVector.hh
@@ -62,6 +62,8 @@ protected:
 public:
     FastVector(u32 nRows = 0);  // constructor with memory allocation
 
+    FastVector(u32 nRows, T value);  // constructor with memory allocation with specified value
+
     FastVector(const FastVector<T>& vector);  // (deep) copy constructor
 
     // destructor
@@ -139,7 +141,7 @@ public:
 
     // add a constant to each element of the vector
     void addConstantElementwise(T c) {
-        std::transform(begin(), end(), begin(), std::bind2nd(std::plus<T>(), c));
+        std::transform(begin(), end(), begin(), std::bind(std::plus<T>(), std::placeholders::_1, c));
     }
 
     // scaling of the vector
@@ -270,6 +272,13 @@ FastVector<T>::FastVector(u32 size)
     resize(size, 0, true);
 }
 
+template<typename T>
+FastVector<T>::FastVector(u32 size, T value)
+        : nRows_(0),
+          elem_(0) {
+    resize(size, value, false);
+}
+
 /**	Copy constructor
  */
 template<typename T>
@@ -300,11 +309,8 @@ void FastVector<T>::resize(u32 newSize, T value, bool allocOnly) {
     }
     else {
         // allocate new array
-        T* newElem = 0;
-        try {
-            newElem = new T[newSize];
-        }
-        catch (std::bad_alloc& ba) {
+        T* newElem = new (std::nothrow) T[newSize];
+        if (newElem == nullptr) {
             Core::Application::us()->criticalError("failed to allocate memory for vector of size ") << nRows_;
         }
         if (!allocOnly) {
diff --git a/src/Math/Lapack/Matrix.hh b/src/Math/Lapack/Matrix.hh
index 0a3447199..e0f8f603a 100644
--- a/src/Math/Lapack/Matrix.hh
+++ b/src/Math/Lapack/Matrix.hh
@@ -29,7 +29,8 @@ private:
 
 public:
     MatrixStorageScheme(size_t nRows = 0, size_t nColumns = 0)
-            : nRows_(nRows), nColumns_(nColumns) {}
+            : nRows_(nRows),
+              nColumns_(nColumns) {}
 
     size_t nRows() const {
         return nRows_;
diff --git a/src/Math/Lapack/MatrixTools.hh b/src/Math/Lapack/MatrixTools.hh
index dd3e0e375..d6fba22db 100644
--- a/src/Math/Lapack/MatrixTools.hh
+++ b/src/Math/Lapack/MatrixTools.hh
@@ -12,8 +12,8 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
-#ifndef _MATH_MATRIX_TOOLS_HH_
-#define _MATH_MATRIX_TOOLS_HH_
+#ifndef _MATH_LAPACK_MATRIX_TOOLS_HH_
+#define _MATH_LAPACK_MATRIX_TOOLS_HH_
 
 #include <Core/Application.hh>
 #include <Math/Matrix.hh>
@@ -189,4 +189,4 @@ T determinant(const Math::Matrix<T, P>& mat, bool critical = true) {
 }  // namespace Lapack
 }  // namespace Math
 
-#endif  // _MATH_MATRIX_TOOLS_HH_
+#endif  // _MATH_LAPACK_MATRIX_TOOLS_HH_
diff --git a/src/Math/Lapack/Vector.hh b/src/Math/Lapack/Vector.hh
index 084bd5914..c5206f379 100644
--- a/src/Math/Lapack/Vector.hh
+++ b/src/Math/Lapack/Vector.hh
@@ -43,11 +43,13 @@ private:
 
 public:
     Vector(u32 n = 0)
-            : buffer_(0), size_(0) {
+            : buffer_(0),
+              size_(0) {
         resize(n);
     }
     Vector(const Vector& vector)
-            : buffer_(0), size_(0) {
+            : buffer_(0),
+              size_(0) {
         operator=(vector);
     }
     ~Vector() {
diff --git a/src/Math/Lapack/check.cc b/src/Math/Lapack/check.cc
index d21d8e154..b51a96954 100644
--- a/src/Math/Lapack/check.cc
+++ b/src/Math/Lapack/check.cc
@@ -31,7 +31,6 @@ class TestApplication : public Core::Application {
     int main(const std::vector<std::string>& arguments) {
         return 0;
     }
-
-} app;
+};
 
 APPLICATION(TestApplication);
diff --git a/src/Math/LbfgsSolver.hh b/src/Math/LbfgsSolver.hh
index 9cdabeba9..5f9caa34d 100644
--- a/src/Math/LbfgsSolver.hh
+++ b/src/Math/LbfgsSolver.hh
@@ -40,12 +40,15 @@ protected:
 public:
     LbfgsSolver()
             : historySize_(-1){};
+
     virtual void solve(const S& in, S& out);
     void         setIterate(u32 i, S* iterate);
     void         setGradient(u32 i, S* gradient);
-    void         setHistorySize(int historyLength) {
+
+    void setHistorySize(int historyLength) {
         historySize_ = historyLength;
     }
+
     int getHistorySize() {
         return historySize_ == -1 ? iterates_.size() - 1 : historySize_;
     }
diff --git a/src/Math/Matrix.hh b/src/Math/Matrix.hh
index 8070389cf..9867fd9db 100644
--- a/src/Math/Matrix.hh
+++ b/src/Math/Matrix.hh
@@ -71,16 +71,21 @@ public:
     size_t nRows() const {
         return nRows_;
     }
+
     Vector<T, P> row(size_t row) const {
         return elem_[row];
     }
+
     size_t nColumns() const {
         return nColumns_;
     }
+
     Vector<T, P> column(size_t col) const;
-    bool         empty() const {
+
+    bool empty() const {
         return nRows() == 0 || nColumns() == 0;
     }
+
     size_t size() const {
         return nRows_ * nColumns_;
     }
diff --git a/src/Math/MultithreadingHelper.hh b/src/Math/MultithreadingHelper.hh
index f14838f8c..aa3ba45d0 100644
--- a/src/Math/MultithreadingHelper.hh
+++ b/src/Math/MultithreadingHelper.hh
@@ -15,6 +15,8 @@
 #ifndef MULTITHREADINGHELPER_HH_
 #define MULTITHREADINGHELPER_HH_
 
+#include <algorithm>
+
 namespace Math {
 
 /**
diff --git a/src/Math/Random.hh b/src/Math/Random.hh
index 450c642c3..364261f29 100644
--- a/src/Math/Random.hh
+++ b/src/Math/Random.hh
@@ -39,8 +39,10 @@ inline void random_shuffle(Iter begin, Iter end) {
 class RandomVectorGenerator {
 public:
     typedef f32 DataType;
-    enum Type { typeUniformIndependent,
-                typeGaussIndependent };
+    enum Type {
+        typeUniformIndependent,
+        typeGaussIndependent
+    };
 
 public:
     static const Core::Choice          choiceType;
diff --git a/src/Math/SimpleAnalyticFunctions.hh b/src/Math/SimpleAnalyticFunctions.hh
index b3a5a7ef3..1700f52e1 100644
--- a/src/Math/SimpleAnalyticFunctions.hh
+++ b/src/Math/SimpleAnalyticFunctions.hh
@@ -16,6 +16,8 @@
 #define _MATH_SIMPLE_ANALYTIC_FUNCTION_HH
 
 #include <algorithm>
+#include <functional>
+
 #include "AnalyticFunction.hh"
 
 namespace Math {
@@ -52,13 +54,17 @@ class PiecewiseConstantFunction : public UnaryAnalyticFunction,
 private:
     typedef Precursor::value_type LimitAndValue;
 
-    struct greaterOrEqual : public std::binary_function<LimitAndValue, Argument, bool> {
+    struct greaterOrEqual {
+        using first_argument_type  = LimitAndValue;
+        using second_argument_type = const Argument;
+        using result_type          = bool;
+
         bool operator()(const LimitAndValue& x, const Argument& limit) const {
             return x.first >= limit;
         }
     };
     std::vector<LimitAndValue>::const_iterator findSegment(const Argument& limit) const {
-        return std::find_if(begin(), end(), std::bind2nd(greaterOrEqual(), limit));
+        return std::find_if(begin(), end(), std::bind(greaterOrEqual(), std::placeholders::_1, limit));
     }
 
 public:
@@ -67,12 +73,12 @@ public:
             : Precursor(limitsAndValues) {}
 
     void insert(const LimitAndValue& limitAndValue) {
-        iterator pos = std::find_if(begin(), end(), std::bind2nd(greaterOrEqual(), limitAndValue.first));
+        iterator pos = std::find_if(begin(), end(), std::bind(greaterOrEqual(), std::placeholders::_1, limitAndValue.first));
         Precursor::insert(pos, limitAndValue);
     }
 
     virtual Result value(Argument x) const {
-        const_iterator result = std::find_if(begin(), end(), std::bind2nd(greaterOrEqual(), x));
+        const_iterator result = std::find_if(begin(), end(), std::bind(greaterOrEqual(), std::placeholders::_1, x));
         ensure(result != end());
         return result->second;
     }
diff --git a/src/Math/Utilities.hh b/src/Math/Utilities.hh
index 01e6591de..c0be75359 100644
--- a/src/Math/Utilities.hh
+++ b/src/Math/Utilities.hh
@@ -28,7 +28,7 @@ namespace Math {
  * @return |x - y|
  */
 template<class T>
-struct absoluteDifference : public std::binary_function<T, T, T> {
+struct absoluteDifference {
     T operator()(T x, T y) {
         return Core::abs(x - y);
     }
@@ -38,7 +38,7 @@ struct absoluteDifference : public std::binary_function<T, T, T> {
  * @return |x - y|^power
  */
 template<class T>
-class absoluteDifferencePower : public std::binary_function<T, T, T> {
+class absoluteDifferencePower {
 private:
     f64 power_;
 
@@ -55,7 +55,7 @@ public:
  * @return |x - y|^0.5
  */
 template<class T>
-struct absoluteDifferenceSquareRoot : public std::binary_function<T, T, T> {
+struct absoluteDifferenceSquareRoot {
     T operator()(T x, T y) {
         return (T)sqrt(Core::abs(x - y));
     }
@@ -65,7 +65,7 @@ struct absoluteDifferenceSquareRoot : public std::binary_function<T, T, T> {
  * @return |x - y|^2
  */
 template<class T>
-struct absoluteDifferenceSquare : public std::binary_function<T, T, T> {
+struct absoluteDifferenceSquare {
     T operator()(T x, T y) {
         return (x - y) * (x - y);
     }
diff --git a/src/Mc/Utilities.hh b/src/Mc/Utilities.hh
index caec32014..9b09d3a48 100644
--- a/src/Mc/Utilities.hh
+++ b/src/Mc/Utilities.hh
@@ -21,7 +21,7 @@ namespace Mc {
 
 /** x + y*factor */
 template<class T>
-struct plusWeight : public std::binary_function<T, T, T> {
+struct plusWeight {
     const T weight;
     plusWeight<T>(const T& _weight)
             : weight(_weight) {}
@@ -32,7 +32,7 @@ struct plusWeight : public std::binary_function<T, T, T> {
 
 /** min(x,y) */
 template<class T>
-struct minimum : public std::binary_function<T, T, T> {
+struct minimum {
     T operator()(T x, T y) const {
         return std::min(x, y);
     }
@@ -40,7 +40,7 @@ struct minimum : public std::binary_function<T, T, T> {
 
 /** max(x,y) */
 template<class T>
-struct maximum : public std::binary_function<T, T, T> {
+struct maximum {
     T operator()(T x, T y) const {
         return std::max(x, y);
     }
diff --git a/src/Mm/AbstractAdaptationAccumulator.hh b/src/Mm/AbstractAdaptationAccumulator.hh
index 515c203da..9dce3b8b6 100644
--- a/src/Mm/AbstractAdaptationAccumulator.hh
+++ b/src/Mm/AbstractAdaptationAccumulator.hh
@@ -29,27 +29,30 @@ namespace Mm {
  */
 class AbstractAdaptationAccumulator : public Core::ReferenceCounted {
 public:
-    virtual void accumulate(Core::Ref<const Feature::Vector>,
+    virtual void accumulate(Feature::VectorRef,
                             DensityIndex,
                             MixtureIndex,
                             Core::Ref<MixtureSet>) = 0;
 
-    virtual void accumulate(Core::Ref<const Feature::Vector>,
+    virtual void accumulate(Feature::VectorRef,
                             DensityIndex,
                             MixtureIndex,
                             Core::Ref<MixtureSet>,
                             Mm::Weight) = 0;
 
     virtual std::string typeName() const = 0;
-    virtual u32         featureDimension() {
+
+    virtual u32 featureDimension() {
         return 0;
     };
+
     virtual void combine(AbstractAdaptationAccumulator&, Mm::Weight) {
         defect();
     };
 
     virtual bool read(Core::BinaryInputStream& i)         = 0;
     virtual bool write(Core::BinaryOutputStream& o) const = 0;
+
     virtual void dump(Core::XmlOutputStream&) {
         defect();
     };
diff --git a/src/Mm/AbstractMixtureSetEstimator.cc b/src/Mm/AbstractMixtureSetEstimator.cc
index de759de39..6b84f1a42 100644
--- a/src/Mm/AbstractMixtureSetEstimator.cc
+++ b/src/Mm/AbstractMixtureSetEstimator.cc
@@ -114,7 +114,7 @@ void AbstractMixtureSetEstimator::setTopology(Core::Ref<const MixtureSet> topolo
     }
 }
 
-void AbstractMixtureSetEstimator::accumulate(MixtureIndex mixtureIndex, Core::Ref<const Feature::Vector> featureVector) {
+void AbstractMixtureSetEstimator::accumulate(MixtureIndex mixtureIndex, Feature::VectorRef featureVector) {
     if (viterbi_) {
         DensityIndex index = densityIndex(mixtureIndex, featureVector);
         mixtureEstimators_[mixtureIndex]->accumulate(index, *featureVector);
@@ -124,7 +124,7 @@ void AbstractMixtureSetEstimator::accumulate(MixtureIndex mixtureIndex, Core::Re
     }
 }
 
-void AbstractMixtureSetEstimator::accumulate(MixtureIndex mixtureIndex, Core::Ref<const Feature::Vector> featureVector, Weight weight) {
+void AbstractMixtureSetEstimator::accumulate(MixtureIndex mixtureIndex, Feature::VectorRef featureVector, Weight weight) {
     if (viterbi_) {
         DensityIndex index = densityIndex(mixtureIndex, featureVector);
         mixtureEstimators_[mixtureIndex]->accumulate(index, *featureVector, weight);
@@ -367,8 +367,8 @@ void AbstractMixtureSetEstimator::removeDensitiesWithLowWeight(Weight minObserva
     }
 }
 
-DensityIndex AbstractMixtureSetEstimator::densityIndex(MixtureIndex                     mixtureIndex,
-                                                       Core::Ref<const Feature::Vector> featureVector) {
+DensityIndex AbstractMixtureSetEstimator::densityIndex(MixtureIndex       mixtureIndex,
+                                                       Feature::VectorRef featureVector) {
     verify_(mixtureIndex < mixtureEstimators_.size());
 
     DensityIndex densityIndex = 0;
@@ -383,9 +383,9 @@ DensityIndex AbstractMixtureSetEstimator::densityIndex(MixtureIndex
     return densityIndex;
 }
 
-void AbstractMixtureSetEstimator::getDensityPosteriorProbabilities(MixtureIndex                     mixtureIndex,
-                                                                   Core::Ref<const Feature::Vector> featureVector,
-                                                                   std::vector<Mm::Weight>&         posteriors) {
+void AbstractMixtureSetEstimator::getDensityPosteriorProbabilities(MixtureIndex             mixtureIndex,
+                                                                   Feature::VectorRef       featureVector,
+                                                                   std::vector<Mm::Weight>& posteriors) {
     verify_(mixtureIndex < mixtureEstimators_.size());
 
     if (assigningFeatureScorer_) {
@@ -422,7 +422,7 @@ void AbstractMixtureSetEstimator::writeHeader(Core::BinaryOutputStream& os) {
 void AbstractMixtureSetEstimator::checkEventsWithZeroWeight() {
     for (MixtureIndex mixture = 0; mixture < mixtureEstimators_.size(); ++mixture) {
         if (mixtureEstimators_[mixture]->getWeight() == 0)
-            criticalError("Mixture ") << mixture << " has zero weight.";
+            criticalError("Mixture %d has zero weight.", mixture);
 
         std::string message = Core::form("In mixture %d: ", mixture);
         if (!mixtureEstimators_[mixture]->checkEventsWithZeroWeight(message))
diff --git a/src/Mm/AbstractMixtureSetEstimator.hh b/src/Mm/AbstractMixtureSetEstimator.hh
index 3e1ea06a1..61910fe06 100644
--- a/src/Mm/AbstractMixtureSetEstimator.hh
+++ b/src/Mm/AbstractMixtureSetEstimator.hh
@@ -83,8 +83,8 @@ protected:
 
     void         removeDensitiesWithZeroWeight();
     void         removeDensitiesWithLowWeight(Weight minObservationWeight, Weight minRelativeWeight);
-    DensityIndex densityIndex(MixtureIndex, Core::Ref<const Feature::Vector>);
-    void         getDensityPosteriorProbabilities(MixtureIndex, Core::Ref<const Feature::Vector>, std::vector<Mm::Weight>&);
+    DensityIndex densityIndex(MixtureIndex, Feature::VectorRef);
+    void         getDensityPosteriorProbabilities(MixtureIndex, Feature::VectorRef, std::vector<Mm::Weight>&);
     void         readHeader(Core::BinaryInputStream&);
     void         writeHeader(Core::BinaryOutputStream&);
 
@@ -132,8 +132,8 @@ public:
     void setAssigningFeatureScorer(Core::Ref<const AssigningFeatureScorer> assigningFeatureScorer) {
         assigningFeatureScorer_ = assigningFeatureScorer;
     }
-    void         accumulate(MixtureIndex mixtureIndex, Core::Ref<const Feature::Vector>);
-    void         accumulate(MixtureIndex mixtureIndex, Core::Ref<const Feature::Vector>, Weight);
+    void         accumulate(MixtureIndex mixtureIndex, Feature::VectorRef);
+    void         accumulate(MixtureIndex mixtureIndex, Feature::VectorRef, Weight);
     virtual bool accumulate(const AbstractMixtureSetEstimator&);
     virtual bool accumulate(Core::BinaryInputStreams& is, Core::BinaryOutputStream& os);
     virtual void reset();
@@ -224,9 +224,11 @@ public:
     /** loads a white-space separated mixture-to-mixture id mapping file */
     virtual bool load(const std::string& filename);
     virtual bool save(const std::string& filename) const;
-    u32          nMixtures() const {
+
+    u32 nMixtures() const {
         return size();
     }
+
     u32 nMappedMixtures() const {
         return nOfMappedMixtures_;
     }
diff --git a/src/Mm/AffineFeatureTransformAccumulator.cc b/src/Mm/AffineFeatureTransformAccumulator.cc
index 7fcd79dde..d599eb3a7 100644
--- a/src/Mm/AffineFeatureTransformAccumulator.cc
+++ b/src/Mm/AffineFeatureTransformAccumulator.cc
@@ -37,7 +37,7 @@ AffineFeatureTransformAccumulator::AffineFeatureTransformAccumulator(size_t feat
     }
 }
 
-void AffineFeatureTransformAccumulator::accumulate(Core::Ref<const Feature::Vector> feature,
+void AffineFeatureTransformAccumulator::accumulate(Feature::VectorRef feature,
                                                    DensityIndex density, Core::Ref<MixtureSet> mixture) {
     verify(featureDimension_ != 0);
 
@@ -79,7 +79,7 @@ void AffineFeatureTransformAccumulator::accumulate(Core::Ref<const Feature::Vect
     }
 }
 
-void AffineFeatureTransformAccumulator::accumulate(Core::Ref<const Feature::Vector> feature,
+void AffineFeatureTransformAccumulator::accumulate(Feature::VectorRef feature,
                                                    DensityIndex density, Core::Ref<MixtureSet> mixture, Mm::Weight weight) {
     verify(featureDimension_ != 0);
 
@@ -201,7 +201,7 @@ Math::Matrix<FeatureType> AffineFeatureTransformAccumulator::estimate(int
     hope(transform.nColumns() == featureDimension_ + 1);
     hope(transform.nRows() == targetDimension);
 
-    if (criterion != naive & beta_ < minObsWeight)
+    if (criterion != naive && beta_ < minObsWeight)
         return transform;
 
     if (hldaCriterion) {
diff --git a/src/Mm/AffineFeatureTransformAccumulator.hh b/src/Mm/AffineFeatureTransformAccumulator.hh
index e543b5c46..0c614bcce 100644
--- a/src/Mm/AffineFeatureTransformAccumulator.hh
+++ b/src/Mm/AffineFeatureTransformAccumulator.hh
@@ -39,9 +39,11 @@ public:
     typedef std::vector<Math::Matrix<Sum>> GMatrixAccumulator;
     typedef std::vector<Math::Vector<Sum>> KVectorAccumulator;
     typedef Math::Matrix<FeatureType>      Transform;
-    enum Criterion { naive,
-                     mmiPrime,
-                     hlda };
+    enum Criterion {
+        naive,
+        mmiPrime,
+        hlda
+    };
 
 private:
     u32                       featureDimension_;
@@ -61,12 +63,12 @@ public:
     AffineFeatureTransformAccumulator(size_t featureDimension, size_t modelDimension_,
                                       const std::string& key);
 
-    void accumulate(Core::Ref<const Feature::Vector>, DensityIndex, Core::Ref<MixtureSet>);
-    void accumulate(Core::Ref<const Feature::Vector>, DensityIndex, Core::Ref<MixtureSet>, Mm::Weight);
-    void accumulate(Core::Ref<const Feature::Vector> f, DensityIndex di, MixtureIndex mi, Core::Ref<MixtureSet> m) {
+    void accumulate(Feature::VectorRef, DensityIndex, Core::Ref<MixtureSet>);
+    void accumulate(Feature::VectorRef, DensityIndex, Core::Ref<MixtureSet>, Mm::Weight);
+    void accumulate(Feature::VectorRef f, DensityIndex di, MixtureIndex mi, Core::Ref<MixtureSet> m) {
         accumulate(f, di, m);
     }
-    void accumulate(Core::Ref<const Feature::Vector> f, DensityIndex di, MixtureIndex mi, Core::Ref<MixtureSet> m, Mm::Weight w) {
+    void accumulate(Feature::VectorRef f, DensityIndex di, MixtureIndex mi, Core::Ref<MixtureSet> m, Mm::Weight w) {
         accumulate(f, di, m, w);
     }
     void      finalize();
diff --git a/src/Mm/AssigningFeatureScorer.hh b/src/Mm/AssigningFeatureScorer.hh
index 652d1fbf0..889200ed1 100644
--- a/src/Mm/AssigningFeatureScorer.hh
+++ b/src/Mm/AssigningFeatureScorer.hh
@@ -50,7 +50,8 @@ protected:
 
 public:
     AssigningFeatureScorer(const Core::Configuration& c)
-            : Core::Component(c), Precursor(c) {}
+            : Core::Component(c),
+              Precursor(c) {}
     virtual ~AssigningFeatureScorer() {}
 
     virtual void getFeatureDescription(FeatureDescription& description) const {
@@ -60,24 +61,31 @@ public:
     virtual Scorer getScorer(Core::Ref<const Feature> f) const {
         return getAssigningScorer(f);
     }
+
     virtual Scorer getScorer(const FeatureVector& featureVector) const {
         return getAssigningScorer(featureVector);
     }
+
     typedef Core::Ref<const AssigningContextScorer> AssigningScorer;
-    virtual AssigningScorer                         getAssigningScorer(Core::Ref<const Feature> feature) const {
+
+    virtual AssigningScorer getAssigningScorer(Core::Ref<const Feature> feature) const {
         return getAssigningScorer(*feature->mainStream());
     }
+
     virtual AssigningScorer getAssigningScorer(const FeatureVector&) const = 0;
     virtual ComponentIndex  dimension() const                              = 0;
-    virtual DensityIndex    nDensities() const {
+
+    virtual DensityIndex nDensities() const {
         criticalError("nDensities() not available");
         return 0;
     }
+
     virtual const MixtureFeatureScorerElement& mixture(MixtureIndex) const {
         criticalError("mixture() not available");
         static MixtureFeatureScorerElement tmp;
         return tmp;
     }
+
     virtual const std::vector<DensityIndex>& densitiesInMixture(MixtureIndex) const {
         criticalError("densitiesInMixture() not available");
         static std::vector<DensityIndex> tmp;
@@ -104,34 +112,42 @@ protected:
 
     public:
         virtual ~CachedAssigningContextScorer() {}
+
         EmissionIndex nEmissions() const {
             return cache_.size();
         }
+
         virtual Score score(EmissionIndex e) const {
             require_(0 <= e && e < nEmissions());
             if (!cache_.isCalculated(e))
                 return cache_.set(e, featureScorer_->calculateScoreAndDensity(this, e)).score;
             return cache_[e].score;
         }
+
         virtual DensityInMixture bestDensity(EmissionIndex e) const {
             require_(0 <= e && e < nEmissions());
             if (!cache_.isCalculated(e))
                 return cache_.set(e, featureScorer_->calculateScoreAndDensity(this, e)).bestDensity;
             return cache_[e].bestDensity;
         }
+
         virtual Score score(EmissionIndex e, DensityIndex dnsInMix) const {
             require_(0 <= e && e < nEmissions());
             return featureScorer_->calculateScore(this, e, dnsInMix);
         }
+
         virtual void getDensityPosteriorProbabilities(EmissionIndex e, std::vector<Mm::Weight>& result) const {
             featureScorer_->calculateDensityPosteriorProbabilities(this, score(e), e, result);
         }
     };
+
     virtual ScoreAndBestDensity calculateScoreAndDensity(const CachedAssigningContextScorer*, MixtureIndex) const = 0;
-    virtual Score               calculateScore(const CachedAssigningContextScorer*, MixtureIndex, DensityIndex) const {
+
+    virtual Score calculateScore(const CachedAssigningContextScorer*, MixtureIndex, DensityIndex) const {
         criticalError("This feature scorer does not support the calculation of scores given a density in the mixture");
         return Core::Type<Score>::max;
     }
+
     virtual void calculateDensityPosteriorProbabilities(const CachedAssigningContextScorer*, Score logDenominator,
                                                         EmissionIndex e, std::vector<Mm::Weight>& result) const {
         criticalError("This feature scorer does not support the calculation of density posterior probabilities");
@@ -139,7 +155,8 @@ protected:
 
 public:
     CachedAssigningFeatureScorer(const Core::Configuration& c)
-            : Core::Component(c), Precursor(c) {}
+            : Core::Component(c),
+              Precursor(c) {}
     virtual ~CachedAssigningFeatureScorer() {}
 };
 
@@ -154,7 +171,9 @@ protected:
 
     protected:
         ContextScorer(const DensitySpecificCachedAssigningFeatureScorer* featureScorer, EmissionIndex nEmissions)
-                : CachedAssigningContextScorer(featureScorer, nEmissions), featureScorer_(featureScorer), scoreCache_(nEmissions) {
+                : CachedAssigningContextScorer(featureScorer, nEmissions),
+                  featureScorer_(featureScorer),
+                  scoreCache_(nEmissions) {
         }
 
     public:
@@ -176,7 +195,8 @@ protected:
 
 public:
     DensitySpecificCachedAssigningFeatureScorer(const Core::Configuration& c)
-            : Core::Component(c), Precursor(c) {
+            : Core::Component(c),
+              Precursor(c) {
     }
     virtual ~DensitySpecificCachedAssigningFeatureScorer() {
     }
diff --git a/src/Mm/BatchFeatureScorer.cc b/src/Mm/BatchFeatureScorer.cc
index 69cfd914a..14c5d623f 100644
--- a/src/Mm/BatchFeatureScorer.cc
+++ b/src/Mm/BatchFeatureScorer.cc
@@ -29,7 +29,16 @@ const Core::ParameterInt BatchFeatureScorerBase::paramBufferSize(
         "buffer-size", "number of pre-calculated scores", 4, 0);
 
 BatchFeatureScorerBase::BatchFeatureScorerBase(const Core::Configuration& c)
-        : Core::Component(c), FeatureScorer(c), scores_(0), paddedDimension_(0), dimension_(0), nMixtures_(0), nDensities_(0), currentFeature_(0), buffered_(0), bufferSize_(paramBufferSize(c)) {
+        : Core::Component(c),
+          FeatureScorer(c),
+          scores_(0),
+          paddedDimension_(0),
+          dimension_(0),
+          nMixtures_(0),
+          nDensities_(0),
+          currentFeature_(0),
+          buffered_(0),
+          bufferSize_(paramBufferSize(c)) {
     log("batch feature scorer using buffer size %d", bufferSize_);
 }
 
@@ -120,11 +129,21 @@ struct BatchFeatureScorerBase::AllDensitySelector {
 const size_t BatchFloatFeatureScorer::BlockSize = 8;
 
 BatchFloatFeatureScorer::BatchFloatFeatureScorer(const Core::Configuration& c)
-        : Core::Component(c), BatchFeatureScorerBase(c), features_(0), means_(0), variance_(0), constants_(0) {}
+        : Core::Component(c),
+          BatchFeatureScorerBase(c),
+          features_(0),
+          means_(0),
+          variance_(0),
+          constants_(0) {}
 
 BatchFloatFeatureScorer::BatchFloatFeatureScorer(const Core::Configuration&  c,
                                                  Core::Ref<const MixtureSet> mixtureSet)
-        : Core::Component(c), BatchFeatureScorerBase(c), features_(0), means_(0), variance_(0), constants_(0) {
+        : Core::Component(c),
+          BatchFeatureScorerBase(c),
+          features_(0),
+          means_(0),
+          variance_(0),
+          constants_(0) {
     init(*mixtureSet);
 }
 
@@ -136,7 +155,7 @@ BatchFloatFeatureScorer::~BatchFloatFeatureScorer() {
 }
 
 void BatchFloatFeatureScorer::setFeature(size_t pos, const FeatureVector& f) const {
-    verify(pos < bufferSize_);
+    verify(int(pos) < bufferSize_);
     f32* feature = features_ + (pos * paddedDimension_);
     memset(feature, 0, sizeof(f32) * paddedDimension_);
     std::transform(f.begin(), f.end(), variance_, feature, std::multiplies<f32>());
@@ -237,12 +256,18 @@ void BatchFloatFeatureScorer::fillScoreCacheTpl(EmissionIndex e, u32 featureInde
 
 BatchPreselectionFloatFeatureScorer::BatchPreselectionFloatFeatureScorer(
         const Core::Configuration& c)
-        : Core::Component(c), BatchFloatFeatureScorer(c), clustering_(new FloatDensityClustering(select("density-clustering"))), activeClusters_(new bool[bufferSize_ * clustering_->nClusters()]) {}
+        : Core::Component(c),
+          BatchFloatFeatureScorer(c),
+          clustering_(new FloatDensityClustering(select("density-clustering"))),
+          activeClusters_(new bool[bufferSize_ * clustering_->nClusters()]) {}
 
 BatchPreselectionFloatFeatureScorer::BatchPreselectionFloatFeatureScorer(
         const Core::Configuration&  c,
         Core::Ref<const MixtureSet> mixtureSet)
-        : Core::Component(c), BatchFloatFeatureScorer(c), clustering_(new FloatDensityClustering(select("density-clustering"))), activeClusters_(new bool[bufferSize_ * clustering_->nClusters()]) {
+        : Core::Component(c),
+          BatchFloatFeatureScorer(c),
+          clustering_(new FloatDensityClustering(select("density-clustering"))),
+          activeClusters_(new bool[bufferSize_ * clustering_->nClusters()]) {
     init(*mixtureSet);
 }
 
@@ -267,7 +292,8 @@ void BatchPreselectionFloatFeatureScorer::setFeature(size_t pos, const FeatureVe
 class BatchPreselectionFloatFeatureScorer::ClusterDensitySelection {
 public:
     ClusterDensitySelection(const bool* activeClusters, const DensityClusteringBase& clustering)
-            : activeClusters_(activeClusters), clustering_(clustering) {}
+            : activeClusters_(activeClusters),
+              clustering_(clustering) {}
 
     bool operator()(u32 bufferIndex, size_t density) const {
         return activeClusters_[bufferIndex * clustering_.nClusters() + clustering_.clusterIndexForDensity(density)];
@@ -300,12 +326,22 @@ struct BatchIntFeatureScorer::MultiplyAndQuantize {
 
 BatchIntFeatureScorer::BatchIntFeatureScorer(
         const Core::Configuration& c)
-        : Core::Component(c), BatchFeatureScorerBase(c), features_(0), means_(0), variance_(0), constants_(0) {}
+        : Core::Component(c),
+          BatchFeatureScorerBase(c),
+          features_(0),
+          means_(0),
+          variance_(0),
+          constants_(0) {}
 
 BatchIntFeatureScorer::BatchIntFeatureScorer(
         const Core::Configuration&  c,
         Core::Ref<const MixtureSet> mixtureSet)
-        : Core::Component(c), BatchFeatureScorerBase(c), features_(0), means_(0), variance_(0), constants_(0) {
+        : Core::Component(c),
+          BatchFeatureScorerBase(c),
+          features_(0),
+          means_(0),
+          variance_(0),
+          constants_(0) {
     init(*mixtureSet);
 }
 
@@ -355,7 +391,7 @@ void BatchIntFeatureScorer::init(const MixtureSet& mixtureSet) {
     f32 scaleSquared = scale * scale;
     scale_           = 2.0 * scaleSquared;
     std::transform(variance_, variance_ + paddedDimension_, variance_,
-                   std::bind2nd(std::multiplies<f32>(), scale));
+                   std::bind(std::multiplies<f32>(), std::placeholders::_1, scale));
     const float logNormFactor = covariance.logNormalizationFactor() * scaleSquared;
 
     // allocate feature buffer and means in the same memory area.
@@ -477,12 +513,18 @@ void BatchIntFeatureScorer::fillScoreCache(EmissionIndex e, u32 featureIndex, u3
 
 BatchPreselectionIntFeatureScorer::BatchPreselectionIntFeatureScorer(
         const Core::Configuration& c)
-        : Core::Component(c), BatchIntFeatureScorer(c), clustering_(new IntDensityClustering(select("density-clustering"))), activeClusters_(0) {}
+        : Core::Component(c),
+          BatchIntFeatureScorer(c),
+          clustering_(new IntDensityClustering(select("density-clustering"))),
+          activeClusters_(0) {}
 
 BatchPreselectionIntFeatureScorer::BatchPreselectionIntFeatureScorer(
         const Core::Configuration&  c,
         Core::Ref<const MixtureSet> mixtureSet)
-        : Core::Component(c), BatchIntFeatureScorer(c), clustering_(new IntDensityClustering(select("density-clustering"))), activeClusters_(0) {
+        : Core::Component(c),
+          BatchIntFeatureScorer(c),
+          clustering_(new IntDensityClustering(select("density-clustering"))),
+          activeClusters_(0) {
     init(*mixtureSet);
 }
 
@@ -508,7 +550,9 @@ void BatchPreselectionIntFeatureScorer::setFeature(size_t pos, const FeatureVect
 class BatchPreselectionIntFeatureScorer::ClusterIterator {
 public:
     ClusterIterator(const bool* activeClusters, const DensityClusteringBase& clustering)
-            : activeClusters_(activeClusters), clustering_(clustering), offset_(0) {}
+            : activeClusters_(activeClusters),
+              clustering_(clustering),
+              offset_(0) {}
 
     void seek(u32 bufferIndex, size_t firstDensity) const {
         offset_  = bufferIndex * clustering_.nClusters();
@@ -538,12 +582,14 @@ const size_t BatchUnrolledIntFeatureScorer::Dimension = 3 * BatchUnrolledIntFeat
 
 BatchUnrolledIntFeatureScorer::BatchUnrolledIntFeatureScorer(
         const Core::Configuration& c)
-        : Core::Component(c), BatchIntFeatureScorer(c) {}
+        : Core::Component(c),
+          BatchIntFeatureScorer(c) {}
 
 BatchUnrolledIntFeatureScorer::BatchUnrolledIntFeatureScorer(
         const Core::Configuration&  c,
         Core::Ref<const MixtureSet> mixtureSet)
-        : Core::Component(c), BatchIntFeatureScorer(c) {
+        : Core::Component(c),
+          BatchIntFeatureScorer(c) {
     init(*mixtureSet);
 }
 
diff --git a/src/Mm/CachedAssigningTransformingFeatureScorer.hh b/src/Mm/CachedAssigningTransformingFeatureScorer.hh
index 790127f72..792a0d468 100644
--- a/src/Mm/CachedAssigningTransformingFeatureScorer.hh
+++ b/src/Mm/CachedAssigningTransformingFeatureScorer.hh
@@ -41,7 +41,9 @@ public:
 
     protected:
         CachedAssigningTransformingContextScorer(const CachedAssigningTransformingFeatureScorer* featureScorer, EmissionIndex nEmissions)
-                : ContextPrecursor(featureScorer, nEmissions), featureScorer_(featureScorer), transformedFeatureCache_(nEmissions) {
+                : ContextPrecursor(featureScorer, nEmissions),
+                  featureScorer_(featureScorer),
+                  transformedFeatureCache_(nEmissions) {
         }
 
     public:
@@ -73,7 +75,8 @@ public:
 
 public:
     CachedAssigningTransformingFeatureScorer(const Core::Configuration& c)
-            : Core::Component(c), Precursor(c) {
+            : Core::Component(c),
+              Precursor(c) {
     }
     virtual ~CachedAssigningTransformingFeatureScorer() {
     }
diff --git a/src/Mm/CombinedFeatureScorer.cc b/src/Mm/CombinedFeatureScorer.cc
index e154a74e7..4b269f651 100644
--- a/src/Mm/CombinedFeatureScorer.cc
+++ b/src/Mm/CombinedFeatureScorer.cc
@@ -102,8 +102,7 @@ bool CombinedFeatureScorer::verifyMixtureIndexTable() {
 void CombinedFeatureScorer::getFeatureDescription(FeatureDescription& description) const {
     for (size_t m = 0; m < nModels(); ++m) {
         FeatureDescription::Stream& stream(description[m]);
-        FeatureDescription          d(FeatureDescription::prepareName(
-                fullName(), "sub-feature-description"));
+        FeatureDescription          d(FeatureDescription::prepareName(fullName(), "sub-feature-description"));
         featureScorers_[m]->getFeatureDescription(d);
         ensure(d.nStreams() == 1);
         stream = d.mainStream();
diff --git a/src/Mm/CovarianceFeatureScorerElement.cc b/src/Mm/CovarianceFeatureScorerElement.cc
index fc78d3627..77f38c17d 100644
--- a/src/Mm/CovarianceFeatureScorerElement.cc
+++ b/src/Mm/CovarianceFeatureScorerElement.cc
@@ -39,13 +39,13 @@ void CovarianceFeatureScorerElement::calculateNormalizationFactor(
 
 bool CovarianceFeatureScorerElement::checkDiagonal(const std::vector<VarianceType>& diagonal) {
     return (std::find_if(diagonal.begin(), diagonal.end(),
-                         std::bind2nd(std::less_equal<VarianceType>(), 0)) == diagonal.end());
+                         std::bind(std::less_equal<VarianceType>(), std::placeholders::_1, 0)) == diagonal.end());
 }
 
 void CovarianceFeatureScorerElement::scale(VarianceType factor) {
     std::transform(inverseSquareRootDiagonal_.begin(), inverseSquareRootDiagonal_.end(),
                    inverseSquareRootDiagonal_.begin(),
-                   std::bind2nd(std::multiplies<VarianceType>(), factor));
+                   std::bind(std::multiplies<VarianceType>(), std::placeholders::_1, factor));
 
     logNormalizationFactor_ *= factor * factor;
 }
diff --git a/src/Mm/CovarianceWeightedFeatureScorerElement.cc b/src/Mm/CovarianceWeightedFeatureScorerElement.cc
index e9a8f4d5c..3f0cd08c6 100644
--- a/src/Mm/CovarianceWeightedFeatureScorerElement.cc
+++ b/src/Mm/CovarianceWeightedFeatureScorerElement.cc
@@ -42,13 +42,13 @@ void CovarianceWeightedFeatureScorerElement::calculateNormalizationFactor(const
 
 bool CovarianceWeightedFeatureScorerElement::checkDiagonal(const std::vector<VarianceType>& diagonal) {
     return (std::find_if(diagonal.begin(), diagonal.end(),
-                         std::bind2nd(std::less_equal<VarianceType>(), 0)) == diagonal.end());
+                         std::bind(std::less_equal<VarianceType>(), std::placeholders::_1, 0)) == diagonal.end());
 }
 
 void CovarianceWeightedFeatureScorerElement::scale(VarianceType factor) {
     std::transform(inverseSquareRootDiagonal_.begin(), inverseSquareRootDiagonal_.end(),
                    inverseSquareRootDiagonal_.begin(),
-                   std::bind2nd(std::multiplies<VarianceType>(), factor));
+                   std::bind(std::multiplies<VarianceType>(), std::placeholders::_1, factor));
 
     logNormalizationFactor_ *= factor * factor;
 }
diff --git a/src/Mm/DensityClustering.tcc b/src/Mm/DensityClustering.tcc
index 719857dd1..e5a670503 100644
--- a/src/Mm/DensityClustering.tcc
+++ b/src/Mm/DensityClustering.tcc
@@ -109,7 +109,7 @@ f64 DensityClustering<F, D>::updateClusterMeans(const FeatureType* densities, De
             std::transform(sums.begin(), sums.end(), density, sums.begin(), std::plus<f64>());
         }
         std::transform(sums.begin(), sums.end(), meanForCluster(cluster),
-                       std::bind2nd(std::divides<f64>(), assignedDensities.size()));
+                       std::bind(std::divides<f64>(), std::placeholders::_1, assignedDensities.size()));
         for (u32 assigned = 0; assigned < assignedDensities.size(); ++assigned)
             totalAssignmentDistance += unrolledVectorDistance<FeatureType, DistanceType>(
                     meanForCluster(cluster),
diff --git a/src/Mm/DiscriminativeMixtureSetEstimator.cc b/src/Mm/DiscriminativeMixtureSetEstimator.cc
index 30738fe61..26898ad61 100644
--- a/src/Mm/DiscriminativeMixtureSetEstimator.cc
+++ b/src/Mm/DiscriminativeMixtureSetEstimator.cc
@@ -185,7 +185,7 @@ bool DiscriminativeMixtureSetEstimator::accumulate(const AbstractMixtureSetEstim
 }
 
 void DiscriminativeMixtureSetEstimator::accumulateDenominator(
-        MixtureIndex mixtureIndex, Core::Ref<const Feature::Vector> featureVector, Weight weight) {
+        MixtureIndex mixtureIndex, Feature::VectorRef featureVector, Weight weight) {
     if (viterbi_) {
         DensityIndex index = densityIndex(mixtureIndex, featureVector);
         mixtureEstimator(mixtureIndex).accumulateDenominator(index, *featureVector, weight);
diff --git a/src/Mm/DiscriminativeMixtureSetEstimator.hh b/src/Mm/DiscriminativeMixtureSetEstimator.hh
index c45611a09..d74ec829c 100644
--- a/src/Mm/DiscriminativeMixtureSetEstimator.hh
+++ b/src/Mm/DiscriminativeMixtureSetEstimator.hh
@@ -59,11 +59,13 @@ public:
 
     virtual bool accumulate(Core::BinaryInputStreams& is, Core::BinaryOutputStream& os);
     virtual bool accumulate(const AbstractMixtureSetEstimator&);
-    void         accumulateDenominator(MixtureIndex mixtureIndex, Core::Ref<const Feature::Vector>, Weight);
+    void         accumulateDenominator(MixtureIndex mixtureIndex, Feature::VectorRef, Weight);
     void         accumulateObjectiveFunction(Score);
-    Sum          objectiveFunction() const {
+
+    Sum objectiveFunction() const {
         return objectiveFunction_;
     }
+
     bool distributePreviousMixtureSet(const MixtureSet&);
 };
 
diff --git a/src/Mm/EbwDiscriminativeGaussDensityEstimator.cc b/src/Mm/EbwDiscriminativeGaussDensityEstimator.cc
index fb04ddcc5..eb3c4a72c 100644
--- a/src/Mm/EbwDiscriminativeGaussDensityEstimator.cc
+++ b/src/Mm/EbwDiscriminativeGaussDensityEstimator.cc
@@ -79,7 +79,7 @@ Mean* EbwDiscriminativeMeanEstimator::estimate() {
                        buffer.begin(), plusWeighted<Sum>(iterationConstant()));
         Mean* result = new Mean(accumulator_.size());
         std::transform(buffer.begin(), buffer.end(), result->begin(),
-                       std::bind2nd(std::divides<Accumulator::SumType>(), weight));
+                       std::bind(std::divides<Accumulator::SumType>(), std::placeholders::_1, weight));
         return result;
     }
     else {
@@ -188,7 +188,7 @@ Covariance* EbwDiscriminativeCovarianceEstimator::estimate(const CovarianceToMea
     }
     verify(weight > 0);
     std::transform(buffer.begin(), buffer.end(),
-                   buffer.begin(), std::bind2nd(std::divides<Sum>(), weight));
+                   buffer.begin(), std::bind(std::divides<Sum>(), std::placeholders::_1, weight));
     std::vector<VarianceType> buffer32(dimension);
     std::copy(buffer.begin(), buffer.end(), buffer32.begin());
     DiagonalCovariance* result = new DiagonalCovariance(buffer32);
diff --git a/src/Mm/EbwDiscriminativeGaussDensityEstimator.hh b/src/Mm/EbwDiscriminativeGaussDensityEstimator.hh
index df9455f2e..0c0acbdf5 100644
--- a/src/Mm/EbwDiscriminativeGaussDensityEstimator.hh
+++ b/src/Mm/EbwDiscriminativeGaussDensityEstimator.hh
@@ -68,17 +68,22 @@ public:
     const std::vector<Accumulator::SumType>& denSum() const {
         return denAccumulator_.sum();
     }
+
     virtual std::vector<Accumulator::SumType> dtSum() const;
-    Weight                                    denWeight() const {
+
+    Weight denWeight() const {
         return denAccumulator_.weight();
     }
+
     virtual Weight dtWeight() const {
         return weight() - denWeight();
     }
+
     IterationConstant iterationConstant() const {
         verify(iterationConstant_ > 0);
         return iterationConstant_;
     }
+
     void setIterationConstant(IterationConstant);
 };
 
@@ -99,7 +104,8 @@ public:
     EbwDiscriminativeMeanEstimatorWithISmoothing(ComponentIndex dimension = 0);
 
     virtual std::vector<Accumulator::SumType> dtSum() const;
-    virtual Weight                            dtWeight() const {
+
+    virtual Weight dtWeight() const {
         return Precursor::dtWeight() + ISmoothing::constant();
     }
 };
@@ -136,10 +142,13 @@ public:
     const std::vector<Accumulator::SumType>& denSum() const {
         return denAccumulator_.sum();
     }
+
     virtual std::vector<Accumulator::SumType> dtSum(const CovarianceToMeanSetMap::MeanSet&) const;
-    Weight                                    denWeight() const {
+
+    Weight denWeight() const {
         return denAccumulator_.weight();
     }
+
     virtual Weight dtWeight() const {
         return weight() - denWeight();
     }
diff --git a/src/Mm/EbwDiscriminativeMixtureEstimator.cc b/src/Mm/EbwDiscriminativeMixtureEstimator.cc
index 71544353d..d897109d4 100644
--- a/src/Mm/EbwDiscriminativeMixtureEstimator.cc
+++ b/src/Mm/EbwDiscriminativeMixtureEstimator.cc
@@ -76,7 +76,7 @@ void EbwDiscriminativeMixtureEstimator::estimateMixtureWeights(
                 Weight sum = std::accumulate(weights.begin(), weights.end(), Weight(0));
                 if (sum > Core::Type<Weight>::delta) {
                     std::transform(weights.begin(), weights.end(),
-                                   weights.begin(), std::bind2nd(std::divides<Weight>(), sum));
+                                   weights.begin(), std::bind(std::divides<Weight>(), std::placeholders::_1, sum));
                 }
                 else {
                     Core::Application::us()->warning("cannot normalize mixture weights because of vanishing sum");
diff --git a/src/Mm/Feature.cc b/src/Mm/Feature.cc
index 3a2df2e85..06cf81bd9 100644
--- a/src/Mm/Feature.cc
+++ b/src/Mm/Feature.cc
@@ -17,10 +17,10 @@
 using namespace Mm;
 
 //=============================================================================================
-void Feature::add(size_t newIndex, const Core::Ref<const Vector>& v) {
+void Feature::add(size_t newIndex, const VectorRef& v) {
     if (newIndex >= nStreams())
         streams_.resize(newIndex + 1);
-    Core::Ref<const Vector>& s(streams_[newIndex]);
+    VectorRef& s(streams_[newIndex]);
     require_(!s);
     s = v;
 }
diff --git a/src/Mm/Feature.hh b/src/Mm/Feature.hh
index caa7c9232..3f8bca077 100644
--- a/src/Mm/Feature.hh
+++ b/src/Mm/Feature.hh
@@ -19,6 +19,7 @@
 #include <Core/Dependency.hh>
 #include <Core/Description.hh>
 #include <Core/ReferenceCounting.hh>
+#include <Core/ThreadSafeReference.hh>
 #include <Mm/PointerVector.hh>
 #include "Types.hh"
 
@@ -31,7 +32,7 @@ namespace Mm {
  */
 class Feature : public Core::ReferenceCounted {
 public:
-    class Vector : public FeatureVector, public Core::ReferenceCounted {
+    class Vector : public FeatureVector, public Core::ThreadSafeReferenceCounted {
         typedef FeatureVector Precursor;
 
     public:
@@ -41,16 +42,17 @@ public:
         Vector(const Precursor& v)
                 : Precursor(v) {}
     };
+    typedef Core::TsRef<const Vector> VectorRef;
 
-    typedef std::vector<Core::Ref<const Vector>>::const_iterator Iterator;
+    typedef std::vector<VectorRef>::const_iterator Iterator;
 
 public:
-    static Core::Ref<const Vector> convert(const FeatureVector& f) {
-        return Core::Ref<const Vector>(new Vector(f));
+    static VectorRef convert(const FeatureVector& f) {
+        return VectorRef(new Vector(f));
     }
 
 private:
-    std::vector<Core::Ref<const Vector>> streams_;
+    std::vector<VectorRef> streams_;
 
 public:
     /** Creates an empty feature with @param nStreams streams */
@@ -58,7 +60,7 @@ public:
             : streams_(nStreams) {}
 
     /** Creates a feature with a single stream containing the feature vector @param f. */
-    explicit Feature(const Core::Ref<const Vector>& f)
+    explicit Feature(const VectorRef& f)
             : streams_(1) {
         set(0, f);
     }
@@ -71,22 +73,22 @@ public:
     /** Creates a new stream with @param v
      *  @return is the new stream index.
      */
-    size_t add(const Core::Ref<const Vector>& v) {
+    size_t add(const VectorRef& v) {
         streams_.push_back(v);
         return streams_.size() - 1;
     }
 
     /** Creates a new stream at index @param newIndex with @param v */
-    void add(size_t newIndex, const Core::Ref<const Vector>& v);
+    void add(size_t newIndex, const VectorRef& v);
 
     /** Changes value of the stream at index @param newIndex to @param v */
-    void set(size_t streamIndex, const Core::Ref<const Vector>& v) {
+    void set(size_t streamIndex, const VectorRef& v) {
         require_(streamIndex < nStreams());
         streams_[streamIndex] = v;
     }
 
     /** Changes value of the stream at indices @param indices to @param v */
-    void set(const std::vector<size_t>& indices, const Core::Ref<const Vector>& v) {
+    void set(const std::vector<size_t>& indices, const VectorRef& v) {
         for (std::vector<size_t>::const_iterator i = indices.begin(); i != indices.end(); ++i)
             set(*i, v);
     }
@@ -104,14 +106,14 @@ public:
     }
 
     /** @return is value of the stream @param streamIndex */
-    Core::Ref<const Vector> operator[](size_t streamIndex) const {
+    VectorRef operator[](size_t streamIndex) const {
         return streams_[streamIndex];
     }
 
     /** Main stream is used in application working only with one stream.
      *  For example: training, basic feature scorer, etc.
      */
-    Core::Ref<const Vector> mainStream() const {
+    VectorRef mainStream() const {
         return streams_.front();
     }
 
diff --git a/src/Mm/FeatureScorer.hh b/src/Mm/FeatureScorer.hh
index 7df0f762e..490a7d638 100644
--- a/src/Mm/FeatureScorer.hh
+++ b/src/Mm/FeatureScorer.hh
@@ -38,7 +38,8 @@ public:
 
         virtual EmissionIndex nEmissions() const           = 0;
         virtual Score         score(EmissionIndex e) const = 0;
-        virtual Score         score(EmissionIndex e, u32 modelIndex) {
+
+        virtual Score score(EmissionIndex e, u32 modelIndex) {
             return 0.0;
         }
     };
@@ -48,17 +49,20 @@ public:
             : Core::Component(c) {}
     virtual ~FeatureScorer() {}
 
-    virtual EmissionIndex nMixtures() const                                            = 0;
-    virtual void          getFeatureDescription(FeatureDescription& description) const = 0;
-    virtual void          getDependencies(Core::DependencySet& dependencies) const {
+    virtual EmissionIndex nMixtures() const = 0;
+
+    virtual void getFeatureDescription(FeatureDescription& description) const = 0;
+
+    virtual void getDependencies(Core::DependencySet& dependencies) const {
         FeatureDescription description(*this);
         getFeatureDescription(description);
         description.getDependencies(dependencies);
     }
 
     typedef Core::Ref<const ContextScorer> Scorer;
-    virtual Scorer                         getScorer(Core::Ref<const Feature>) const = 0;
-    virtual Scorer                         getScorer(const FeatureVector&) const     = 0;
+
+    virtual Scorer getScorer(Core::Ref<const Feature>) const = 0;
+    virtual Scorer getScorer(const FeatureVector&) const     = 0;
 
     /**
      * reset should be overloaded/defined in/for
@@ -175,7 +179,8 @@ protected:
 
     protected:
         CachedContextScorer(const CachedFeatureScorer* featureScorer, EmissionIndex nEmissions)
-                : featureScorer_(featureScorer), cache_(nEmissions) {}
+                : featureScorer_(featureScorer),
+                  cache_(nEmissions) {}
 
     public:
         virtual ~CachedContextScorer() {}
@@ -201,7 +206,8 @@ public:
 
     public:
         CachedContextScorerOverlay(u32 nEmissions)
-                : cache_(nEmissions), precached_(false) {}
+                : cache_(nEmissions),
+                  precached_(false) {}
         virtual ~CachedContextScorerOverlay() {}
         virtual EmissionIndex nEmissions() const {
             return cache_.size();
@@ -235,7 +241,8 @@ public:
 
 public:
     CachedFeatureScorer(const Core::Configuration& c)
-            : Core::Component(c), Precursor(c) {}
+            : Core::Component(c),
+              Precursor(c) {}
     virtual ~CachedFeatureScorer() {}
 };
 
@@ -251,7 +258,8 @@ class ContextScorerCache : public Core::ReferenceCounted {
 
 public:
     ContextScorerCache(u64 maxSize)
-            : maxSize_(maxSize), epoch_(0) {
+            : maxSize_(maxSize),
+              epoch_(0) {
     }
 
     // Every returned cached scorer must be released by calling uncacheScorer as soon as it is not needed any more
diff --git a/src/Mm/GaussDensity.hh b/src/Mm/GaussDensity.hh
index 8460072e9..114b5f1fb 100644
--- a/src/Mm/GaussDensity.hh
+++ b/src/Mm/GaussDensity.hh
@@ -102,14 +102,17 @@ public:
      *  Remark: output type is const reference for the moment, might need to get changed.
      */
     virtual const std::vector<VarianceType>& diagonal() const = 0;
+
     /**
      *  Returns weights of the features.
      */
     virtual const std::vector<f64>& weights() const = 0;
+
     /**
      *  set weights of the features.
      */
     virtual void setFeatureWeights(const std::vector<f64>& w) = 0;
+
     /**
      *  1 / 2 { N * log(2 * pi) + log(determinant) }.
      *  Remark: default implementation uses only the diagonal elements.
@@ -119,12 +122,17 @@ public:
     }
 
     virtual Covariance* clone() const = 0;
-    virtual void        setOffset(ComponentIndex offset) {
+
+    virtual void setOffset(ComponentIndex offset) {
         verify(0); /* not implemented in this covariance type */
     }
-    virtual void           setDimension(ComponentIndex size) = 0;
-    virtual ComponentIndex dimension() const                 = 0;
-    virtual bool           isPositiveDefinite() const        = 0;
+
+    virtual void setDimension(ComponentIndex size) = 0;
+
+    virtual ComponentIndex dimension() const = 0;
+
+    virtual bool isPositiveDefinite() const = 0;
+
     /**
      * print/scan methods for std::iostreams
      * used in operator<< resp. operator>>
@@ -134,6 +142,7 @@ public:
         Core::Application::us()->error("write() not yet implented for (inherited) Covariance");
         return false;
     }
+
     virtual bool read(std::istream& i) {
         Core::Application::us()->error("read() not yet implented for (inherited) Covariance");
         return false;
@@ -165,7 +174,8 @@ public:
         setDimension(dimension);
     }
     DiagonalCovariance(const std::vector<VarianceType>& v, const std::vector<f64>& w)
-            : buffer_(v), featureWeights_(w) {}
+            : buffer_(v),
+              featureWeights_(w) {}
     DiagonalCovariance(const std::vector<VarianceType>& v)
             : buffer_(v) {
         featureWeights_.resize(v.size(), 1.0);
@@ -204,7 +214,7 @@ public:
     }
     virtual bool isPositiveDefinite() const {
         return std::find_if(diagonal().begin(), diagonal().end(),
-                            std::bind2nd(std::less_equal<VarianceType>(), 0)) == diagonal().end();
+                            std::bind(std::less_equal<VarianceType>(), std::placeholders::_1, 0)) == diagonal().end();
     }
     virtual bool write(std::ostream& o) const;
     virtual bool read(std::istream& i);
diff --git a/src/Mm/GaussDensityEstimator.cc b/src/Mm/GaussDensityEstimator.cc
index 185b5813d..eb36c28dd 100644
--- a/src/Mm/GaussDensityEstimator.cc
+++ b/src/Mm/GaussDensityEstimator.cc
@@ -151,7 +151,7 @@ Mean* MeanEstimator::estimate() {
 
     Mean* result = new Mean(accumulator_.size());
     std::transform(accumulator_.sum().begin(), accumulator_.sum().end(), result->begin(),
-                   std::bind2nd(std::divides<Accumulator::SumType>(), accumulator_.weight()));
+                   std::bind(std::divides<Accumulator::SumType>(), std::placeholders::_1, accumulator_.weight()));
     return result;
 }
 
diff --git a/src/Mm/GaussDensityEstimator.hh b/src/Mm/GaussDensityEstimator.hh
index 15d959a89..796940e7d 100644
--- a/src/Mm/GaussDensityEstimator.hh
+++ b/src/Mm/GaussDensityEstimator.hh
@@ -107,7 +107,8 @@ public:
     virtual void write(Core::XmlWriter&) const          = 0;
 
     virtual bool operator==(const Self&) const = 0;
-    bool         operator!=(const Self& other) const {
+
+    bool operator!=(const Self& other) const {
         return !(*this == other);
     }
 };
diff --git a/src/Mm/ISmoothingGaussDensityEstimator.cc b/src/Mm/ISmoothingGaussDensityEstimator.cc
index d8efb5858..706db5eaa 100644
--- a/src/Mm/ISmoothingGaussDensityEstimator.cc
+++ b/src/Mm/ISmoothingGaussDensityEstimator.cc
@@ -59,7 +59,7 @@ ISmoothingCovarianceEstimator::Accumulator::SumType ISmoothingCovarianceEstimato
         iSum_ = new std::vector<Accumulator::SumType>(iCovariance().size());
         std::copy(iCovariance().begin(), iCovariance().end(), iSum_->begin());
         std::transform(iSum_->begin(), iSum_->end(), iSum_->begin(),
-                       std::bind2nd(std::multiplies<Accumulator::SumType>(), meanSet.size()));
+                       std::bind(std::multiplies<Accumulator::SumType>(), std::placeholders::_1, meanSet.size()));
         CovarianceToMeanSetMap::MeanSet::const_iterator m = meanSet.begin();
         for (; m != meanSet.end(); ++m) {
             const ISmoothingMeanEstimator* meanEstimator = dynamic_cast<const ISmoothingMeanEstimator*>(m->get());
diff --git a/src/Mm/ISmoothingGaussDensityEstimator.hh b/src/Mm/ISmoothingGaussDensityEstimator.hh
index 8e6d266fe..fa7b4b406 100644
--- a/src/Mm/ISmoothingGaussDensityEstimator.hh
+++ b/src/Mm/ISmoothingGaussDensityEstimator.hh
@@ -81,19 +81,25 @@ public:
     void set(Core::Ref<DiscriminativeCovarianceEstimator> parent) {
         parent_ = parent;
     }
-    void                             reset();
-    void                             setICovariance(const Covariance*);
+
+    void reset();
+    void setICovariance(const Covariance*);
+
     const std::vector<VarianceType>& iCovariance() const {
         return iCovariance_;
     }
+
     VarianceType iCovariance(const CovarianceToMeanSetMap::MeanSet&, ComponentIndex i) const {
         return iCovariance_[i];
     }
+
     Accumulator::SumType iSum(const CovarianceToMeanSetMap::MeanSet&, ComponentIndex i) const;
     Sum                  getObjectiveFunction(const CovarianceToMeanSetMap&);
-    void                 setConstant(Weight constant) {
+
+    void setConstant(Weight constant) {
         constant_ = constant;
     }
+
     Weight constant() const {
         return constant_;
     }
diff --git a/src/Mm/IntelOptimization.hh b/src/Mm/IntelOptimization.hh
index 94a07e9ac..e5e62b669 100644
--- a/src/Mm/IntelOptimization.hh
+++ b/src/Mm/IntelOptimization.hh
@@ -42,14 +42,18 @@ private:
 #if defined(__SSE__)
 #if defined(__SSE2__)
     SSE2L2NormCodeGenerator l2norm_;
-    enum {BlockSize = 16};
+    enum {
+            BlockSize = 16};
 #else
     IntelMMXL2NormCodeGenerator l2norm_;
     IntelMMXResetCodeGenerator  reset_;
-    enum {BlockSize = 8};
+    enum {
+            BlockSize = 8};
 #endif  // __SSE2__
 #else
-    enum { BlockSize = 8 };
+    enum {
+        BlockSize = 8
+    };
 #endif  //__SSE__
 
 private:
diff --git a/src/Mm/IterationConstants.cc b/src/Mm/IterationConstants.cc
index 28b7158e3..42dd9a4e8 100644
--- a/src/Mm/IterationConstants.cc
+++ b/src/Mm/IterationConstants.cc
@@ -31,12 +31,12 @@ struct AugmentedDensityEstimator {
 /**
  * DensitySet
  */
-struct AugmentedDensityEstimatorHash : public std::unary_function<size_t, AugmentedDensityEstimator> {
+struct AugmentedDensityEstimatorHash {
     size_t operator()(const AugmentedDensityEstimator& d) const {
         return reinterpret_cast<size_t>(d.densityEstimator.get());
     }
 };
-struct AugmentedDensityEstimatorEquality : public std::unary_function<size_t, AugmentedDensityEstimator> {
+struct AugmentedDensityEstimatorEquality {
     bool operator()(const AugmentedDensityEstimator& lhs,
                     const AugmentedDensityEstimator& rhs) const {
         return lhs.densityEstimator.get() == rhs.densityEstimator.get();
@@ -133,7 +133,7 @@ CovarianceToDensitySetMap::CovarianceToDensitySetMap(const AbstractMixtureSetEst
 /*
  * Xi
  *
- *         / beta/[1+(Gamma_max-1) · Gamma_max/gamma_max] : Gamma_max < gamma_max
+ *         / beta/[1+(Gamma_max-1) * Gamma_max/gamma_max] : Gamma_max < gamma_max
  * xi_s = <
  *         \ beta                                         : otherwise
  */
@@ -202,13 +202,13 @@ IterationConstant Xi::denominator(Core::Ref<AbstractMixtureEstimator> mixtureEst
 /**
  * iteration constants b
  *
- * t1 := -Gamma_{s,l}(x_d^2) + sigma_min·Gamma_{s,l}(1)
- * t2 := 2·Gamma_{s,l}(x_d) - Gamma_{s,l}(1)·mu_{s,l,d}
- * t3 := Gamma_{s,l}(x_d) - Gamma_{s,l}(1)·mu_{s,l,d}
+ * t1 := -Gamma_{s,l}(x_d^2) + sigma_min*Gamma_{s,l}(1)
+ * t2 := 2*Gamma_{s,l}(x_d) - Gamma_{s,l}(1)*mu_{s,l,d}
+ * t3 := Gamma_{s,l}(x_d) - Gamma_{s,l}(1)*mu_{s,l,d}
  *
- *                   sum_{s*,l*} [ t1 + t2·mu_{s,l,d} + xi_s·t3^2 ]
+ *                   sum_{s*,l*} [ t1 + t2*mu_{s,l,d} + xi_s*t3^2 ]
  * D_k^min = max_d { ---------------------------------------------- }
- *                   sum_{s*,l*} [ c_{s,l}·(sigma*^2-sigma_min) ]
+ *                   sum_{s*,l*} [ c_{s,l}*(sigma*^2-sigma_min) ]
  *
  *     with sigma*^2 in {sigma_{s,l,d}^2, sigma_{s_d}^2, sigma_d^2}
  */
@@ -366,7 +366,7 @@ GlobalIcb::GlobalIcb(const Core::Configuration&       c,
         IterationConstant                      ic      = default_;
 
         /**
-         * D_k = h · max_{s*,l*} { 1/c_{s,l} · (1/xi_s - Gamma_{s,l}(1)), D_k^min }
+         * D_k = h * max_{s*,l*} { 1/c_{s,l} * (1/xi_s - Gamma_{s,l}(1)), D_k^min }
          */
         const DensitySet&          densitySet = it->second;
         DensitySet::const_iterator d          = densitySet.begin();
@@ -418,7 +418,7 @@ LocalIcb::LocalIcb(const Core::Configuration&       c,
         const IterationConstant D_k_min = minimumDk(it, meanSet);
 
         /**
-         * D_k = h · max_{s*,l*} { 1/c_{s,l} · (1/xi_s - Gamma_{s,l}(1)), D_k^min }
+         * D_k = h * max_{s*,l*} { 1/c_{s,l} * (1/xi_s - Gamma_{s,l}(1)), D_k^min }
          */
         const DensitySet&          densitySet = it->second;
         DensitySet::const_iterator d          = densitySet.begin();
diff --git a/src/Mm/IterationConstants.hh b/src/Mm/IterationConstants.hh
index 560ccd28f..46f9a24d3 100644
--- a/src/Mm/IterationConstants.hh
+++ b/src/Mm/IterationConstants.hh
@@ -38,9 +38,11 @@ protected:
     typedef AbstractMixtureSetEstimator::MixtureEstimators MixtureEstimators;
 
 private:
-    enum Type { globalRwth,
-                localRwth,
-                cambridge };
+    enum Type {
+        globalRwth,
+        localRwth,
+        cambridge
+    };
     static Core::Choice               choiceType;
     static Core::ParameterChoice      paramType;
     static const Core::ParameterFloat paramBeta;
diff --git a/src/Mm/Mixture.cc b/src/Mm/Mixture.cc
index 14cbbbfdb..807c811e8 100644
--- a/src/Mm/Mixture.cc
+++ b/src/Mm/Mixture.cc
@@ -70,7 +70,7 @@ void Mixture::normalizeWeights() {
         return;
     Weight logNorm = logExpNorm(logWeights_.begin(), logWeights_.end());
     std::transform(logWeights_.begin(), logWeights_.end(),
-                   logWeights_.begin(), std::bind2nd(std::minus<Weight>(), logNorm));
+                   logWeights_.begin(), std::bind(std::minus<Weight>(), std::placeholders::_1, logNorm));
 }
 
 void Mixture::clear() {
diff --git a/src/Mm/MixtureEstimator.cc b/src/Mm/MixtureEstimator.cc
index bec6a4152..b6ece7b7c 100644
--- a/src/Mm/MixtureEstimator.cc
+++ b/src/Mm/MixtureEstimator.cc
@@ -22,8 +22,8 @@ using namespace Mm;
  */
 void AbstractMixtureEstimator::addDensity(Core::Ref<GaussDensityEstimator> densityEstimator) {
     require(std::find_if(densityEstimators_.begin(), densityEstimators_.end(),
-                         std::bind2nd(std::equal_to<Core::Ref<GaussDensityEstimator>>(),
-                                      densityEstimator)) == densityEstimators_.end());
+                         std::bind(std::equal_to<Core::Ref<GaussDensityEstimator>>(),
+                                   std::placeholders::_1, densityEstimator)) == densityEstimators_.end());
 
     densityEstimators_.push_back(densityEstimator);
     weights_.resize(densityEstimators_.size());
@@ -202,8 +202,8 @@ void AbstractMixtureEstimator::addMixture(const AbstractMixtureEstimator& toAdd)
     for (DensityIndex i = 0; i < toAdd.nDensities(); ++i) {
         Core::Ref<GaussDensityEstimator> densityEstimator = toAdd.densityEstimators()[i];
         require(std::find_if(densityEstimators_.begin(), densityEstimators_.end(),
-                             std::bind2nd(std::equal_to<Core::Ref<GaussDensityEstimator>>(),
-                                          densityEstimator)) == densityEstimators_.end());
+                             std::bind(std::equal_to<Core::Ref<GaussDensityEstimator>>(),
+                                       std::placeholders::_1, densityEstimator)) == densityEstimators_.end());
 
         densityEstimators_.push_back(densityEstimator);
         weights_.push_back(toAdd.weights()[i]);
diff --git a/src/Mm/MixtureEstimator.hh b/src/Mm/MixtureEstimator.hh
index be602a619..456e1c895 100644
--- a/src/Mm/MixtureEstimator.hh
+++ b/src/Mm/MixtureEstimator.hh
@@ -61,18 +61,23 @@ public:
     virtual void reset();
 
     virtual Mixture* estimate(const ReferenceIndexMap<GaussDensityEstimator>& densityMap, bool normalizeWeights = true);
-    Weight           getWeight() const {
+
+    Weight getWeight() const {
         return std::accumulate(weights_.begin(), weights_.end(), 0.0);
     }
+
     size_t nDensities() const {
         return densityEstimators_.size();
     }
+
     const DensityEstimators& densityEstimators() const {
         return densityEstimators_;
     }
+
     std::vector<Weight>& weights() {
         return weights_;
     }
+
     const std::vector<Weight>& weights() const {
         return weights_;
     }
@@ -92,9 +97,10 @@ public:
                        const ReferenceIndexMap<GaussDensityEstimator>&,
                        std::string label = "") const;
 
-    bool         equalTopology(const AbstractMixtureEstimator&                 toCompare,
-                               const ReferenceIndexMap<GaussDensityEstimator>& densityMap,
-                               const ReferenceIndexMap<GaussDensityEstimator>& densityMapToCompare) const;
+    bool equalTopology(const AbstractMixtureEstimator&                 toCompare,
+                       const ReferenceIndexMap<GaussDensityEstimator>& densityMap,
+                       const ReferenceIndexMap<GaussDensityEstimator>& densityMapToCompare) const;
+
     virtual bool equalWeights(const AbstractMixtureEstimator& toCompare) const {
         return weights_ == toCompare.weights_;
     }
diff --git a/src/Mm/MixtureFeatureScorerElement.cc b/src/Mm/MixtureFeatureScorerElement.cc
index 8a49180d3..42dd32cbb 100644
--- a/src/Mm/MixtureFeatureScorerElement.cc
+++ b/src/Mm/MixtureFeatureScorerElement.cc
@@ -29,5 +29,5 @@ void MixtureFeatureScorerElement::operator=(const Mixture& mixture) {
 
 void MixtureFeatureScorerElement::scale(Score scale) {
     std::transform(minus2LogWeights_.begin(), minus2LogWeights_.end(),
-                   minus2LogWeights_.begin(), std::bind2nd(std::multiplies<Score>(), scale));
+                   minus2LogWeights_.begin(), std::bind(std::multiplies<Score>(), std::placeholders::_1, scale));
 }
diff --git a/src/Mm/MixtureSetTopology.hh b/src/Mm/MixtureSetTopology.hh
index b54aa6070..050dbe9ca 100644
--- a/src/Mm/MixtureSetTopology.hh
+++ b/src/Mm/MixtureSetTopology.hh
@@ -32,7 +32,8 @@ private:
 
 public:
     GaussDensityTopology(MeanIndex meanIndex, CovarianceIndex covarianceIndex)
-            : meanIndex_(meanIndex), covarianceIndex_(covarianceIndex) {}
+            : meanIndex_(meanIndex),
+              covarianceIndex_(covarianceIndex) {}
     virtual ~GaussDensityTopology() {}
 
     void setMeanIndex(MeanIndex index) {
diff --git a/src/Mm/MllrAdaptation.cc b/src/Mm/MllrAdaptation.cc
index e8c0481af..aee5549ee 100644
--- a/src/Mm/MllrAdaptation.cc
+++ b/src/Mm/MllrAdaptation.cc
@@ -378,10 +378,10 @@ void ShiftAdaptorViterbiEstimator::estimateWMatrices() {
     }
 }
 
-void ShiftAdaptorViterbiEstimator::accumulate(Core::Ref<const Feature::Vector> feature,
-                                              DensityIndex                     density,
-                                              MixtureIndex                     mixture,
-                                              Core::Ref<MixtureSet>            mixtureSet) {
+void ShiftAdaptorViterbiEstimator::accumulate(Feature::VectorRef    feature,
+                                              DensityIndex          density,
+                                              MixtureIndex          mixture,
+                                              Core::Ref<MixtureSet> mixtureSet) {
     MeanIndex       meanIndex = mixtureSet->density(density)->meanIndex();
     const Mm::Mean& mean      = *(mixtureSet->mean(meanIndex));
 
@@ -396,11 +396,11 @@ void ShiftAdaptorViterbiEstimator::accumulate(Core::Ref<const Feature::Vector> f
     }
 }
 
-void ShiftAdaptorViterbiEstimator::accumulate(Core::Ref<const Feature::Vector> feature,
-                                              DensityIndex                     density,
-                                              MixtureIndex                     mixture,
-                                              Core::Ref<MixtureSet>            mixtureSet,
-                                              Mm::Weight                       weight) {
+void ShiftAdaptorViterbiEstimator::accumulate(Feature::VectorRef    feature,
+                                              DensityIndex          density,
+                                              MixtureIndex          mixture,
+                                              Core::Ref<MixtureSet> mixtureSet,
+                                              Mm::Weight            weight) {
     MeanIndex       meanIndex = mixtureSet->density(density)->meanIndex();
     const Mm::Mean& mean      = *(mixtureSet->mean(meanIndex));
 
@@ -690,10 +690,10 @@ void FullAdaptorViterbiEstimator::estimateWMatrices() {
     }
 }
 
-void FullAdaptorViterbiEstimator::accumulate(Core::Ref<const Feature::Vector> feature,
-                                             DensityIndex                     density,
-                                             MixtureIndex                     mixture,
-                                             Core::Ref<MixtureSet>            mixtureSet) {
+void FullAdaptorViterbiEstimator::accumulate(Feature::VectorRef    feature,
+                                             DensityIndex          density,
+                                             MixtureIndex          mixture,
+                                             Core::Ref<MixtureSet> mixtureSet) {
     MeanIndex       meanIndex = mixtureSet->density(density)->meanIndex();
     const Mm::Mean& mean      = *(mixtureSet->mean(meanIndex));
 
@@ -701,11 +701,11 @@ void FullAdaptorViterbiEstimator::accumulate(Core::Ref<const Feature::Vector> fe
     leafGAccumulators_[(*leafIndex_)[mixture]].accumulate(mean);
 }
 
-void FullAdaptorViterbiEstimator::accumulate(Core::Ref<const Feature::Vector> feature,
-                                             DensityIndex                     density,
-                                             MixtureIndex                     mixture,
-                                             Core::Ref<MixtureSet>            mixtureSet,
-                                             Mm::Weight                       weight) {
+void FullAdaptorViterbiEstimator::accumulate(Feature::VectorRef    feature,
+                                             DensityIndex          density,
+                                             MixtureIndex          mixture,
+                                             Core::Ref<MixtureSet> mixtureSet,
+                                             Mm::Weight            weight) {
     MeanIndex       meanIndex = mixtureSet->density(density)->meanIndex();
     const Mm::Mean& mean      = *(mixtureSet->mean(meanIndex));
 
diff --git a/src/Mm/MllrAdaptation.hh b/src/Mm/MllrAdaptation.hh
index 38262c2e4..9926a85d3 100644
--- a/src/Mm/MllrAdaptation.hh
+++ b/src/Mm/MllrAdaptation.hh
@@ -45,10 +45,10 @@ struct IdSetEntry {
     NodeId id;
     bool   isActive;
     IdSetEntry(NodeId i, bool a = true)
-            : id(i), isActive(a){};
+            : id(i),
+              isActive(a){};
 };
-struct IdSetEntryLess
-        : public std::binary_function<const IdSetEntry&, const IdSetEntry&, bool> {
+struct IdSetEntryLess {
     bool operator()(const IdSetEntry& a, const IdSetEntry& b) const {
         return a.id < b.id;
     }
@@ -192,29 +192,35 @@ public:
     const ClusterId& clusterId() const {
         return clusterId_;
     }
+
     virtual Sum                minAdaptationObservations() = 0;
     virtual Core::Ref<Adaptor> adaptor(void)               = 0;
-    virtual void               accumulate(
-            Core::Ref<const Feature::Vector>,
+
+    virtual void accumulate(
+            Feature::VectorRef,
             DensityIndex,
             MixtureIndex,
             Core::Ref<MixtureSet>) = 0;
+
     virtual void accumulate(
-            Core::Ref<const Feature::Vector>,
+            Feature::VectorRef,
             DensityIndex,
             MixtureIndex,
             Core::Ref<MixtureSet>,
             Mm::Weight) = 0;
+
     virtual void accumulate(
             const Speech::Alignment&,
             const std::vector<Core::Ref<const Mm::Feature>>&,
             Core::Ref<const Am::MixtureSetAdaptor>,
             Core::Ref<const Mm::AssigningFeatureScorer>) = 0;
 
-    virtual void        reset() = 0;
+    virtual void reset() = 0;
+
     virtual std::string typeName() const {
         return "adaptor-estimator";
     }
+
     virtual bool read(Core::BinaryInputStream& i);
     virtual bool write(Core::BinaryOutputStream& o) const;
 };
@@ -271,16 +277,16 @@ public:
     }
     virtual Core::Ref<Adaptor> adaptor(void);
     virtual void               accumulate(
-                          Core::Ref<const Feature::Vector> feature,
-                          DensityIndex                     density,
-                          MixtureIndex                     mixture,
-                          Core::Ref<MixtureSet>            mixtureSet);
+                          Feature::VectorRef    feature,
+                          DensityIndex          density,
+                          MixtureIndex          mixture,
+                          Core::Ref<MixtureSet> mixtureSet);
     virtual void accumulate(
-            Core::Ref<const Feature::Vector> feature,
-            DensityIndex                     density,
-            MixtureIndex                     mixture,
-            Core::Ref<MixtureSet>            mixtureSet,
-            Mm::Weight                       weight);
+            Feature::VectorRef    feature,
+            DensityIndex          density,
+            MixtureIndex          mixture,
+            Core::Ref<MixtureSet> mixtureSet,
+            Mm::Weight            weight);
     virtual void accumulate(
             const Speech::Alignment&                         alignment,
             const std::vector<Core::Ref<const Mm::Feature>>& featureSequence,
@@ -378,16 +384,16 @@ public:
     }
     virtual Core::Ref<Adaptor> adaptor(void);
     virtual void               accumulate(
-                          Core::Ref<const Feature::Vector> feature,
-                          DensityIndex                     density,
-                          MixtureIndex                     mixture,
-                          Core::Ref<MixtureSet>            mixtureSet);
+                          Feature::VectorRef    feature,
+                          DensityIndex          density,
+                          MixtureIndex          mixture,
+                          Core::Ref<MixtureSet> mixtureSet);
     virtual void accumulate(
-            Core::Ref<const Feature::Vector> feature,
-            DensityIndex                     density,
-            MixtureIndex                     mixture,
-            Core::Ref<MixtureSet>            mixtureSet,
-            Mm::Weight                       weight);
+            Feature::VectorRef    feature,
+            DensityIndex          density,
+            MixtureIndex          mixture,
+            Core::Ref<MixtureSet> mixtureSet,
+            Mm::Weight            weight);
     virtual void accumulate(
             const Speech::Alignment&                         alignment,
             const std::vector<Core::Ref<const Mm::Feature>>& featureSequence,
diff --git a/src/Mm/RpropDiscriminativeGaussDensityEstimator.hh b/src/Mm/RpropDiscriminativeGaussDensityEstimator.hh
index a62eb5f21..5fa3faf35 100644
--- a/src/Mm/RpropDiscriminativeGaussDensityEstimator.hh
+++ b/src/Mm/RpropDiscriminativeGaussDensityEstimator.hh
@@ -71,16 +71,21 @@ public:
     RpropDiscriminativeMeanEstimator(ComponentIndex dimension = 0);
 
     virtual Mean* estimate();
-    void          setStepSizes(const Mean* mean) {
+
+    void setStepSizes(const Mean* mean) {
         Rprop::setStepSizes(*mean);
     }
+
     void setStepSizes(MeanType stepSize) {
         Rprop::setStepSizes(accumulator_.size(), stepSize);
     }
+
     Mean* collectStepSizes();
-    void  setPreviousToPreviousMean(const Mean* mean) {
+
+    void setPreviousToPreviousMean(const Mean* mean) {
         Rprop::setPreviousToPrevious(*mean);
     }
+
     void setCovarianceEstimator(Core::Ref<DiscriminativeCovarianceEstimator> covarianceEstimator) {
         covarianceEstimator_ = covarianceEstimator;
     }
@@ -145,11 +150,14 @@ public:
     void setStepSizes(const Covariance* covariance) {
         Rprop::setStepSizes(covariance->diagonal());
     }
+
     void setStepSizes(VarianceType stepSize) {
         Rprop::setStepSizes(accumulator_.size(), stepSize);
     }
+
     Covariance* collectStepSizes();
-    void        setPreviousToPreviousCovariance(const Covariance* covariance) {
+
+    void setPreviousToPreviousCovariance(const Covariance* covariance) {
         Rprop::setPreviousToPrevious(covariance->diagonal());
     }
 };
diff --git a/src/Mm/RpropOptimization.hh b/src/Mm/RpropOptimization.hh
index 4235b9a9c..c6c4b44cb 100644
--- a/src/Mm/RpropOptimization.hh
+++ b/src/Mm/RpropOptimization.hh
@@ -58,9 +58,11 @@ public:
     typedef RpropSettings<T> Settings;
 
 private:
-    enum Action { decrease,
-                  increase,
-                  hold };
+    enum Action {
+        decrease,
+        increase,
+        hold
+    };
 
 private:
     Settings settings_;
diff --git a/src/Mm/ScaledFeatureScorer.hh b/src/Mm/ScaledFeatureScorer.hh
index 09ce47cd1..aa63ac95f 100644
--- a/src/Mm/ScaledFeatureScorer.hh
+++ b/src/Mm/ScaledFeatureScorer.hh
@@ -26,7 +26,9 @@ class ScaledFeatureScorer : public FeatureScorer,
                             public Mc::Component {
 public:
     ScaledFeatureScorer(const Core::Configuration& c)
-            : Core::Component(c), FeatureScorer(c), Component(c) {}
+            : Core::Component(c),
+              FeatureScorer(c),
+              Component(c) {}
     virtual ~ScaledFeatureScorer() {}
     virtual void getDependencies(Core::DependencySet& dependencies) const {
         FeatureScorer::getDependencies(dependencies);
@@ -51,7 +53,8 @@ public:
 
     protected:
         ScaledContextScorer(Scorer scorer, Score scale)
-                : scorer_(scorer), scale_(scale) {}
+                : scorer_(scorer),
+                  scale_(scale) {}
 
     public:
         virtual ~ScaledContextScorer() {}
diff --git a/src/Mm/SemiTiedAdaptation.cc b/src/Mm/SemiTiedAdaptation.cc
index 20f9da4b7..7f96b491b 100644
--- a/src/Mm/SemiTiedAdaptation.cc
+++ b/src/Mm/SemiTiedAdaptation.cc
@@ -271,7 +271,12 @@ bool SemiTiedEstimator::read(Core::BinaryInputStream& i) {
 SemiTiedOptimizationFunction::SemiTiedOptimizationFunction(ComponentIndex d, const Math::Vector<Matrix>& G,
                                                            const Math::Vector<Matrix>&                   Z,
                                                            const std::map<NodeId, Math::Vector<double>>& l)
-        : dimension_(d), G_(G), Z_(Z), lambda_(l), f1_(dimension_), f2_(dimension_) {}
+        : dimension_(d),
+          G_(G),
+          Z_(Z),
+          lambda_(l),
+          f1_(dimension_),
+          f2_(dimension_) {}
 
 SemiTiedOptimizationFunction::ResultType SemiTiedOptimizationFunction::operator()(const ArgumentType& x) const {
     convert2Matrices(x, lambda_, U_, V_, dimension_);
diff --git a/src/Mm/StatePosteriorFeatureScorer.hh b/src/Mm/StatePosteriorFeatureScorer.hh
index 4dc44dbf4..f50647b53 100644
--- a/src/Mm/StatePosteriorFeatureScorer.hh
+++ b/src/Mm/StatePosteriorFeatureScorer.hh
@@ -75,14 +75,19 @@ public:
             return map_.size();
         }
     };
+
     typedef Core::Ref<Filter>       FilterRef;
     typedef Core::Ref<const Filter> ConstFilterRef;
+
     struct IndexAndWeight {
         MixtureIndex e;
         Weight       w;  // -log(x)
+
         IndexAndWeight(MixtureIndex _e, Weight _w)
-                : e(_e), w(_w) {}
+                : e(_e),
+                  w(_w) {}
     };
+
     typedef std::vector<IndexAndWeight> IndicesAndWeights;
 
 public:
diff --git a/src/Mm/Utilities.hh b/src/Mm/Utilities.hh
index 7a0796722..5e877c412 100644
--- a/src/Mm/Utilities.hh
+++ b/src/Mm/Utilities.hh
@@ -25,7 +25,7 @@ namespace Mm {
 
 /** Creates hash key from a pointer by casting to unsigned int. */
 template<class Referenced>
-struct hashReference : std::unary_function<Core::Ref<Referenced>, size_t> {
+struct hashReference {
     size_t operator()(Core::Ref<Referenced> x) const {
         return (size_t)x.get();
     }
@@ -33,7 +33,7 @@ struct hashReference : std::unary_function<Core::Ref<Referenced>, size_t> {
 
 /** @return is *x == *y */
 template<class Pointer>
-struct equalReferenced : public std::binary_function<Pointer, Pointer, bool> {
+struct equalReferenced {
     bool operator()(Pointer x, Pointer y) const {
         return *x == *y;
     }
@@ -84,7 +84,7 @@ double gaussLogNormFactor(InputIterator beginDiagonal, InputIterator endDiagonal
 
 /** 1 / sqrt(x) */
 template<class T>
-struct inverseSquareRoot : public std::unary_function<T, T> {
+struct inverseSquareRoot {
     T operator()(T x) const {
         return (T)1 / (T)sqrt(x);
     }
@@ -92,7 +92,7 @@ struct inverseSquareRoot : public std::unary_function<T, T> {
 
 /** (x - y) / normalization */
 template<class T>
-class normalizedMinus : public std::binary_function<T, T, T> {
+class normalizedMinus {
     T normalization_;
 
 public:
@@ -107,7 +107,7 @@ public:
 
 /** x + weight*y */
 template<class T>
-struct plusWeighted : public std::binary_function<T, T, T> {
+struct plusWeighted {
     T weight_;
 
 private:
@@ -123,7 +123,10 @@ public:
 
 /** x + y^2 */
 template<class T>
-struct plusSquare : public std::binary_function<T, T, T> {
+struct plusSquare {
+    using first_argument_type  = T;
+    using second_argument_type = T;
+
     T operator()(T x, T y) const {
         return x + y * y;
     }
@@ -131,36 +134,44 @@ struct plusSquare : public std::binary_function<T, T, T> {
 
 /** x + weight*y^2 */
 template<class T>
-struct plusSquareWeighted : public std::binary_function<T, T, T> {
-    T weight_;
-
-private:
-    plusSquareWeighted() {}
-
+struct plusSquareWeighted {
 public:
+    using first_argument_type  = T;
+    using second_argument_type = T;
+
     plusSquareWeighted(T weight)
             : weight_(weight) {}
+
     T operator()(T x, T y) const {
         return x + weight_ * y * y;
     }
+
+    T weight_;
+
+private:
+    plusSquareWeighted() {}
 };
 
 /** x + y^2 / normalization_ */
 template<class T>
-class plusNormalizedSquare : public std::binary_function<T, T, T> {
-    T normalization_;
-
+class plusNormalizedSquare {
 public:
+    using first_argument_type  = T;
+    using second_argument_type = T;
+
     plusNormalizedSquare(T normalization)
             : normalization_(normalization) {}
+
     T operator()(T x, T y) const {
         return x + y * y / normalization_;
     }
+
+    T normalization_;
 };
 
 /** -factor * log (x) */
 template<class T>
-class minusLog : public std::unary_function<T, T> {
+class minusLog {
     T factor_;
 
 public:
@@ -177,7 +188,7 @@ public:
  *  Remark: mean{x} is expected to be 0, so offset is simply to half of the integer interval.
  */
 template<class ValueType, class QuantizedType>
-class quantize : public std::unary_function<ValueType, QuantizedType> {
+class quantize {
     QuantizedType clip(int x) {
         return std::min(std::max(x, int(Core::Type<QuantizedType>::min)),
                         int(Core::Type<QuantizedType>::max));
@@ -452,9 +463,11 @@ private:
 
 public:
     DynamicCache()
-            : isCalculated_(), objects_() {}
+            : isCalculated_(),
+              objects_() {}
     DynamicCache(size_t size)
-            : isCalculated_(size, false), objects_(size, Type()) {}
+            : isCalculated_(size, false),
+              objects_(size, Type()) {}
     ~DynamicCache() {}
 
     const Type& set(size_t index, const Type& obj) {
diff --git a/src/Mm/VectorAccumulator.hh b/src/Mm/VectorAccumulator.hh
index 65b291700..269e1183f 100644
--- a/src/Mm/VectorAccumulator.hh
+++ b/src/Mm/VectorAccumulator.hh
@@ -41,7 +41,8 @@ public:
         resize(size);
     }
     VectorAccumulator(const std::vector<SumType>& sum, Weight weight)
-            : sum_(sum), weight_(weight) {}
+            : sum_(sum),
+              weight_(weight) {}
 
     void resize(ComponentIndex size) {
         sum_.resize(size);
diff --git a/src/Nn/ActivationLayer.cc b/src/Nn/ActivationLayer.cc
index 4111422cc..35175d947 100644
--- a/src/Nn/ActivationLayer.cc
+++ b/src/Nn/ActivationLayer.cc
@@ -23,7 +23,8 @@ using namespace Nn;
 /*===========================================================================*/
 template<typename T>
 IdentityLayer<T>::IdentityLayer(const Core::Configuration& config)
-        : Core::Component(config), NeuralNetworkLayer<T>(config) {}
+        : Core::Component(config),
+          NeuralNetworkLayer<T>(config) {}
 
 template<typename T>
 IdentityLayer<T>::~IdentityLayer() {}
@@ -54,7 +55,8 @@ void IdentityLayer<T>::backpropagateActivations(const NnMatrix& errorSignalIn,
 /*===========================================================================*/
 template<typename T>
 TanhLayer<T>::TanhLayer(const Core::Configuration& config)
-        : Core::Component(config), NeuralNetworkLayer<T>(config) {}
+        : Core::Component(config),
+          NeuralNetworkLayer<T>(config) {}
 
 template<typename T>
 TanhLayer<T>::~TanhLayer() {}
diff --git a/src/Nn/ActivationLayer.hh b/src/Nn/ActivationLayer.hh
index 3989dd3e4..5f83e8017 100644
--- a/src/Nn/ActivationLayer.hh
+++ b/src/Nn/ActivationLayer.hh
@@ -83,7 +83,8 @@ private:
 protected:
     static const Core::ParameterFloat paramScaleGamma;
     static const Core::ParameterBool  paramLogOutput;
-    T                                 getGamma() const {
+
+    T getGamma() const {
         return gamma_;
     }
 
diff --git a/src/Nn/AllophoneStateFsaExporter.cc b/src/Nn/AllophoneStateFsaExporter.cc
index c155326be..92904423f 100644
--- a/src/Nn/AllophoneStateFsaExporter.cc
+++ b/src/Nn/AllophoneStateFsaExporter.cc
@@ -27,9 +27,15 @@ namespace {
 
 struct Edge {
     Edge()
-            : from(0u), to(0u), emission_idx(0u), weight(0.0f) {}
+            : from(0u),
+              to(0u),
+              emission_idx(0u),
+              weight(0.0f) {}
     Edge(Fsa::StateId from, Fsa::StateId to, Am::AcousticModel::EmissionIndex emission_idx, float cost)
-            : from(from), to(to), emission_idx(emission_idx), weight(cost) {}
+            : from(from),
+              to(to),
+              emission_idx(emission_idx),
+              weight(cost) {}
 
     Fsa::StateId                     from;
     Fsa::StateId                     to;
diff --git a/src/Nn/BufferedFeatureExtractor.hh b/src/Nn/BufferedFeatureExtractor.hh
index 9cb74a3c5..0da17aaf6 100644
--- a/src/Nn/BufferedFeatureExtractor.hh
+++ b/src/Nn/BufferedFeatureExtractor.hh
@@ -133,7 +133,8 @@ public:
 
     // this needs to be virtual, since AlignedNeuralNetworkTrainer overrides the function to create a supervised trainer
     virtual NeuralNetworkTrainer<T>* createTrainer(const Core::Configuration& config);
-    virtual void                     signOn(Speech::CorpusVisitor& corpusVisitor) {
+
+    virtual void signOn(Speech::CorpusVisitor& corpusVisitor) {
         Speech::DataExtractor::signOn(corpusVisitor);
     }
 
diff --git a/src/Nn/BufferedSegmentFeatureProcessor.cc b/src/Nn/BufferedSegmentFeatureProcessor.cc
index 49cc49fa9..ae851f90c 100644
--- a/src/Nn/BufferedSegmentFeatureProcessor.cc
+++ b/src/Nn/BufferedSegmentFeatureProcessor.cc
@@ -36,8 +36,7 @@ BufferedSegmentFeatureProcessor<FloatT>::~BufferedSegmentFeatureProcessor() {
 // The NN must also know about the segment transcription, though.
 template<typename FloatT>
 void BufferedSegmentFeatureProcessor<FloatT>::processBuffer() {
-    typedef typename Math::FastMatrix<FloatT> FastMatrix;
-    typedef typename Precursor::NnMatrix      NnMatrix;
+    typedef typename Precursor::NnMatrix NnMatrix;
 
     // We expect that the underlying BufferedFeatureProcessor
     // is in utterance buffer mode and this is only called indirectly
diff --git a/src/Nn/EmissionLatticeRescorer.hh b/src/Nn/EmissionLatticeRescorer.hh
index 2564c4999..5456f92db 100644
--- a/src/Nn/EmissionLatticeRescorer.hh
+++ b/src/Nn/EmissionLatticeRescorer.hh
@@ -61,9 +61,11 @@ protected:
 protected:
     virtual Lattice::ConstWordLatticeRef work(Lattice::ConstWordLatticeRef, Bliss::SpeechSegment*);
     void                                 logProperties() const;
-    NeuralNetwork<f32>&                  network() const {
+
+    NeuralNetwork<f32>& network() const {
         return SharedNeuralNetwork::network();
     }
+
     const ClassLabelWrapper& labelWrapper() const {
         return SharedNeuralNetwork::labelWrapper();
     }
diff --git a/src/Nn/Estimator.hh b/src/Nn/Estimator.hh
index 8f3310b52..24dd532e9 100644
--- a/src/Nn/Estimator.hh
+++ b/src/Nn/Estimator.hh
@@ -106,7 +106,8 @@ class DryRunEstimator : public Estimator<T> {
 
 public:
     DryRunEstimator(const Core::Configuration& config)
-            : Core::Component(config), Precursor(config) {}
+            : Core::Component(config),
+              Precursor(config) {}
     virtual std::string type() const {
         return "dry-run";
     }
diff --git a/src/Nn/LabelScorer/DataView.cc b/src/Nn/LabelScorer/DataView.cc
index 6e149aa3e..eb98e990a 100644
--- a/src/Nn/LabelScorer/DataView.cc
+++ b/src/Nn/LabelScorer/DataView.cc
@@ -31,7 +31,7 @@ DataView::DataView(std::shared_ptr<f32 const[]> const& ptr, size_t size, size_t
     dataPtr_ = std::shared_ptr<f32 const[]>(ptr, ptr.get() + offset);
 }
 
-DataView::DataView(Core::Ref<Mm::Feature::Vector const> const& featureVectorRef)
+DataView::DataView(Core::TsRef<Mm::Feature::Vector const> const& featureVectorRef)
         : size_(featureVectorRef->size()) {
     // Copy Ref in custom deleter to keep it alive
     dataPtr_ = std::shared_ptr<f32 const[]>(
diff --git a/src/Nn/LabelScorer/DataView.hh b/src/Nn/LabelScorer/DataView.hh
index f651c6d3b..7a5109787 100644
--- a/src/Nn/LabelScorer/DataView.hh
+++ b/src/Nn/LabelScorer/DataView.hh
@@ -38,14 +38,14 @@ namespace Nn {
  * it stays valid as long as the view is alive.
  *
  * It can be initialized using various data containers such as a
- * Core::Ref<Mm::Feature::Vector>, another shared_ptr, an Onnx::Value
+ * Core::TsRef<Mm::Feature::Vector>, another shared_ptr, an Onnx::Value
  * or a pybind11::array_t.
  */
 class DataView {
 public:
     DataView(DataView const& dataView);
     DataView(DataView const& dataView, size_t size, size_t offset = 0ul);
-    DataView(Core::Ref<Mm::Feature::Vector const> const& featureVectorRef);
+    DataView(Core::TsRef<Mm::Feature::Vector const> const& featureVectorRef);
     DataView(std::shared_ptr<f32 const[]> const& ptr, size_t size, size_t offset = 0ul);
 
 #ifdef MODULE_ONNX
diff --git a/src/Nn/LinearAndActivationLayer.cc b/src/Nn/LinearAndActivationLayer.cc
index c262b8bc8..b39c8a661 100644
--- a/src/Nn/LinearAndActivationLayer.cc
+++ b/src/Nn/LinearAndActivationLayer.cc
@@ -103,6 +103,12 @@ inline void LinearAndSoftmaxLayer<T>::_forward(const std::vector<NnMatrix*>& inp
     PrecursorLinear::_forward(input, output, reset);
     if (evaluateSoftmax_)
         PrecursorSoftmax::_forward(output, output);
+
+    if (PrecursorSoftmax::dataChannel_.isOpen()) {
+        PrecursorSoftmax::dataChannel_ << Core::XmlOpen("layer-output-data");
+        output.write(PrecursorSoftmax::dataChannel_);
+        PrecursorSoftmax::dataChannel_ << Core::XmlClose("layer-output-data");
+    }
 }
 
 template<typename T>
diff --git a/src/Nn/MeanNormalizedSgdEstimator.cc b/src/Nn/MeanNormalizedSgdEstimator.cc
index a314e7edd..803bd88f9 100644
--- a/src/Nn/MeanNormalizedSgdEstimator.cc
+++ b/src/Nn/MeanNormalizedSgdEstimator.cc
@@ -45,7 +45,7 @@ void MeanNormalizedSgd<T>::checkForStatistics(NeuralNetwork<T>& network) {
 
 /**
  * estimation with mean-normalized SGD
- * see Wiesler, Richard, Schlüter & Ney: Mean-Normalized SGD, ICASSP 2014
+ * see Wiesler, Richard, Schlueter & Ney: Mean-Normalized SGD, ICASSP 2014
  */
 template<typename T>
 void MeanNormalizedSgd<T>::estimate(NeuralNetwork<T>& network, Statistics<T>& statistics) {
diff --git a/src/Nn/Module.hh b/src/Nn/Module.hh
index 94e1948d2..28e391af4 100644
--- a/src/Nn/Module.hh
+++ b/src/Nn/Module.hh
@@ -36,7 +36,9 @@ class Module_ {
 public:
     Module_();
     ~Module_();
-    enum { FeatureScorerTypeOffset = 0x300 };
+    enum {
+        FeatureScorerTypeOffset = 0x300
+    };
     enum FeatureScorerType {
         nnOnDemanHybrid        = FeatureScorerTypeOffset,
         nnFullHybrid           = FeatureScorerTypeOffset + 1,
diff --git a/src/Nn/NeuralNetwork.hh b/src/Nn/NeuralNetwork.hh
index f44935195..d4721c45c 100644
--- a/src/Nn/NeuralNetwork.hh
+++ b/src/Nn/NeuralNetwork.hh
@@ -110,24 +110,29 @@ public:
     // access methods
     NeuralNetworkLayer<T>&       getLayer(u32 index);
     const NeuralNetworkLayer<T>& getLayer(u32 index) const;
-    u32                          getLayerIdByName(const std::string& name) {
+
+    u32 getLayerIdByName(const std::string& name) {
         return topology_.layerElement(name)->topologicalId();
     }
 
     NeuralNetworkLayer<T>&       getTopLayer();
     const NeuralNetworkLayer<T>& getTopLayer() const;
-    NnMatrix&                    getTopLayerOutput() {
+
+    NnMatrix& getTopLayerOutput() {
         require_gt(layers_.size(), 0);
         return activations_.getOutput(nLayers() - 1);
     }
+
     NnMatrix& getLayerOutput(u32 layer) {
         require_le(layer, layers_.size());
         return activations_.getOutput(layer);
     }
+
     std::vector<NnMatrix*>& getLayerInput(u32 layer) {
         require_le(layer, layers_.size());
         return activations_.getInput(layer);
     }
+
     void resetPreviousActivations();
     // remove top layer from network
     NeuralNetworkLayer<T>* popLayer();
diff --git a/src/Nn/NeuralNetworkLayer.cc b/src/Nn/NeuralNetworkLayer.cc
index dab68b4ae..513db5d2c 100644
--- a/src/Nn/NeuralNetworkLayer.cc
+++ b/src/Nn/NeuralNetworkLayer.cc
@@ -150,7 +150,8 @@ NeuralNetworkLayer<T>::NeuralNetworkLayer(const Core::Configuration& config)
           nObservations_(0),
           activationStatisticsNeedInit_(true),
           refreshMean_(true),
-          refreshVariance_(true) {
+          refreshVariance_(true),
+          dataChannel_(config, "dump-activations", Core::Channel::disabled) {
     // this is necessary if initializeNetwork(u32 batchSize) is called instead of initializeNetwork(u32 batchSize, std::vector<u32>& streamSizes)
     inputDimensions_.push_back(paramDimensionIn(config));
 }
diff --git a/src/Nn/NeuralNetworkLayer.hh b/src/Nn/NeuralNetworkLayer.hh
index 4f6664cd0..0070d0aa9 100644
--- a/src/Nn/NeuralNetworkLayer.hh
+++ b/src/Nn/NeuralNetworkLayer.hh
@@ -168,6 +168,8 @@ protected:
     bool     refreshMean_;
     bool     refreshVariance_;
 
+    Core::XmlChannel dataChannel_;
+
 public:
     NeuralNetworkLayer(const Core::Configuration& config);
     virtual ~NeuralNetworkLayer() {}
@@ -294,7 +296,8 @@ public:
     }
     virtual NnVector& getActivationMean();
     virtual NnVector& getActivationVariance();
-    virtual bool      hasActivationStatistics() const {
+
+    virtual bool hasActivationStatistics() const {
         return statisticsSmoothing_ != noStatistics;
     }
 
@@ -307,7 +310,8 @@ public:
 
     virtual void initComputation(bool sync = true) const {}
     virtual void finishComputation(bool sync = true) const {}
-    bool         isComputing() const {
+
+    bool isComputing() const {
         return isComputing_;
     }
 
diff --git a/src/Nn/Prior.cc b/src/Nn/Prior.cc
index 67d1b69d6..33632817e 100644
--- a/src/Nn/Prior.cc
+++ b/src/Nn/Prior.cc
@@ -186,8 +186,12 @@ void Prior<T>::setFromMixtureSet(Core::Ref<const Mm::MixtureSet> mixtureSet, con
 
     for (u32 c = 0; c < logPrior_.size(); ++c)
         logPrior_.at(c) = std::log(logPrior_.at(c) / observationWeight);
-    if (statisticsChannel_.isOpen())
-        statisticsChannel_ << logPrior_;
+    if (statisticsChannel_.isOpen()) {
+        std::stringstream ss;
+        for (u32 c = 0; c < std::min(logPrior_.size(), 10u); ++c)
+            ss << logPrior_.at(c) << " ";
+        statisticsChannel_ << "first state prior values: " << ss.str() << " ...";
+    }
     // sync to GPU memory. train() expects it to be up-to-date
     logPrior_.initComputation(true);
     logPrior_.finishComputation(false);
diff --git a/src/Nn/PythonControl.cc b/src/Nn/PythonControl.cc
index e7d350541..9d626539f 100644
--- a/src/Nn/PythonControl.cc
+++ b/src/Nn/PythonControl.cc
@@ -89,7 +89,9 @@ struct AlignmentToPython {
     Math::FastMatrix<f32>*                 features_;  // optional. dim * time
 
     AlignmentToPython()
-            : nSkippedAlignmentFrames_(0), parent_(NULL), features_(NULL) {}
+            : nSkippedAlignmentFrames_(0),
+              parent_(NULL),
+              features_(NULL) {}
 
     bool _alignmentLabelIndex(const Speech::Alignment& alignment, Fsa::LabelId emissionIndex, u32& index) {
         u32 labelIndex = emissionIndex;
@@ -206,7 +208,8 @@ struct AlignmentToPython {
 
 struct BuildSegmentToOrthMapVisitor : public Bliss::CorpusVisitor {
     BuildSegmentToOrthMapVisitor()
-            : Bliss::CorpusVisitor(), map_(new Core::StringHashMap<std::string>()) {}
+            : Bliss::CorpusVisitor(),
+              map_(new Core::StringHashMap<std::string>()) {}
 
     virtual void visitSpeechSegment(Bliss::SpeechSegment* s) {
         (*map_)[s->fullName()] = s->orth();
@@ -945,11 +948,14 @@ static const Core::ParameterString paramAlignmentPortName(
 
 struct NoneFeatureExtractor : public Speech::CorpusProcessor {
     typedef Speech::CorpusProcessor Precursor;
-    Core::Ref<Speech::DataSource>   dataSource() const {
+
+    Core::Ref<Speech::DataSource> dataSource() const {
         return Core::Ref<Speech::DataSource>();
     }
+
     NoneFeatureExtractor(const Core::Configuration& c)
-            : Core::Component(c), Precursor(c) {}
+            : Core::Component(c),
+              Precursor(c) {}
 };
 
 // See Speech::AligningFeatureExtractor.
diff --git a/src/Nn/PythonLayer.cc b/src/Nn/PythonLayer.cc
index 15e3f2d70..531aff3fe 100644
--- a/src/Nn/PythonLayer.cc
+++ b/src/Nn/PythonLayer.cc
@@ -37,7 +37,10 @@ static const Core::ParameterString paramPyModConfig(
 
 template<typename T>
 PythonLayer<T>::PythonLayer(const Core::Configuration& config)
-        : Core::Component(config), Precursor(config), timeForward_(0), timeBackward_(0) {
+        : Core::Component(config),
+          Precursor(config),
+          timeForward_(0),
+          timeBackward_(0) {
     pythonInitializer_.init();
 
     // Get us the CPython GIL. However, when we return here,
@@ -129,7 +132,7 @@ template<typename T>
 void PythonLayer<T>::initializeNetworkParameters() {
     Python::ScopedGIL gil;
     Python::PyCallKw_IgnRet_HandleError(getPythonCriticalErrorFunc(),
-                                        pyObject_, "initializeNetworkParameters", "");
+                                        pyObject_, "initializeNetworkParameters", "{}");
 }
 
 template<typename T>
@@ -152,7 +155,7 @@ template<typename T>
 bool PythonLayer<T>::isTrainable() const {
     Python::ScopedGIL gil;
     Python::ObjRef    res;
-    res.takeOver(Python::PyCallKw(pyObject_, "isTrainable", ""));
+    res.takeOver(Python::PyCallKw(pyObject_, "isTrainable", "{}"));
     if (!res) {
         pythonCriticalError("PythonLayer: exception occured while calling 'isTrainable'");
         return false;
@@ -255,7 +258,7 @@ void PythonLayer<T>::finalize() {
         Python::ScopedGIL gil;
         Python::PyCallKw_IgnRet_HandleError(
                 getPythonCriticalErrorFunc(),
-                pyObject_, "finalize", "");
+                pyObject_, "finalize", "{}");
     }
     if (this->measureTime_) {
         this->log("Python layer: Time for forward pass: ") << timeForward_;
@@ -268,7 +271,7 @@ template<typename T>
 u32 PythonLayer<T>::getNumberOfFreeParameters() const {
     Python::ScopedGIL gil;
     Python::ObjRef    res;
-    res.takeOver(Python::PyCallKw(pyObject_, "getNumberOfFreeParameters", ""));
+    res.takeOver(Python::PyCallKw(pyObject_, "getNumberOfFreeParameters", "{}"));
     if (!res) {
         pythonCriticalError("PythonLayer: exception occured while calling 'getNumberOfFreeParameters'");
         return false;
diff --git a/src/Nn/Statistics.hh b/src/Nn/Statistics.hh
index e17e76329..7f643e54d 100644
--- a/src/Nn/Statistics.hh
+++ b/src/Nn/Statistics.hh
@@ -89,43 +89,58 @@ public:
     Statistics(u32 nTrainableLayers, u32 statisticTypes);
     Statistics(const Statistics<T>& statistics, bool onlyStructure = false);
     virtual ~Statistics() {}
+
     /** resets the statistics to 0, but keeps sizes of matrices */
     void reset();
+
     /** transformation to a minimization problem and normalization */
     void finalize(bool normalizeByNOfObservations = true);
+
     void incClassificationErrors(u32 increment = 1) {
         nClassificationErrors_ += increment;
     }
+
     void incObservations(u32 increment = 1) {
         nObservations_ += increment;
     }
+
     void decObservations(u32 decrement = 1) {
         nObservations_ -= decrement;
     }
+
     void addToTotalWeight(T weight) {
         totalWeight_ += weight;
     }
+
     void incClassCount(u32 label, u32 increment = 1);
+
     void addToObjectiveFunction(T value) {
         objectiveFunction_ += value;
     }
+
     void addToEntropy(T value) {
         entropy_ += value;
     }
+
     T objectiveFunction() const {
         return objectiveFunction_;
     }
+
     T classificationError() const {
         return (T)nClassificationErrors_ / nObservations_;
     }
+
     u32 nObservations() const {
         return nObservations_;
     }
+
     T totalWeight() const {
         return totalWeight_;
     }
+
     u32 classCount(u32 label) const;
-    T   entropy() const {
+
+    T entropy() const {
         return entropy_ / nObservations_;
     }
 
@@ -133,6 +148,7 @@ public:
     NnVector& featureSum() {
         return sum_;
     }
+
     NnVector& squaredFeatureSum() {
         return sumOfSquares_;
     }
@@ -142,18 +158,22 @@ public:
     std::vector<NnMatrix>& gradientWeights(u32 layer) {
         return gradientWeights_.at(layerIndexToTrainableLayerIndex_.at(layer));
     }
+
     NnVector& gradientBias(u32 layer) {
         return gradientBias_.at(layerIndexToTrainableLayerIndex_.at(layer));
     }
+
     /** computes the l1 norm of the gradient*/
     T gradientL1Norm() const;
 
     bool hasClassCounts() const {
         return hasClassCounts_;
     }
+
     bool hasBaseStatistics() const {
         return hasBaseStatistics_;
     }
+
     bool hasGradient() const {
         return hasGradient_;
     }
diff --git a/src/Nn/TrainerFeatureScorer.cc b/src/Nn/TrainerFeatureScorer.cc
index 5dc5f7534..82db1caed 100644
--- a/src/Nn/TrainerFeatureScorer.cc
+++ b/src/Nn/TrainerFeatureScorer.cc
@@ -40,6 +40,9 @@ static const Core::ParameterInt paramOutputDimension(
 static const Core::ParameterBool paramReturnScoresInNegLog(
         "return-scores-in-neg-log", "return scores in -log space (default)", true);
 
+static const Core::ParameterBool paramApplyLog(
+        "apply-log", "apply log (default)", true);
+
 TrainerFeatureScorer::TrainerFeatureScorer(const Core::Configuration& config, Core::Ref<const Mm::MixtureSet> mixtureSet)
         : Core::Component(config),
           Mm::FeatureScorer(config),
@@ -47,6 +50,7 @@ TrainerFeatureScorer::TrainerFeatureScorer(const Core::Configuration& config, Co
           currentFeature_(0),
           scoresComputed_(false),
           returnScoresInNegLog_(paramReturnScoresInNegLog(config)),
+          applyLog_(paramApplyLog(config)),
           nClasses_(mixtureSet->nMixtures()),
           inputDimension_(paramFeatureDimension(config)),
           batchIteration_(0),
@@ -71,7 +75,7 @@ TrainerFeatureScorer::TrainerFeatureScorer(const Core::Configuration& config, Co
     if (!labelWrapper_->isOneToOneMapping())
         error("no one-to-one correspondence between network outputs and classes!");
 
-    require_eq(trainer_->getClassLabelPosteriorDimension(), labelWrapper_->nClassesToAccumulate());
+    require_eq(u32(trainer_->getClassLabelPosteriorDimension()), labelWrapper_->nClassesToAccumulate());
 
     std::vector<u32> streamSizes(1 /* one single stream */, inputDimension_);
     trainer_->initializeTrainer(1000 /* dummy buffer size, will be resized automatically */, streamSizes);
@@ -193,8 +197,11 @@ Mm::Score TrainerFeatureScorer::getScore(Mm::EmissionIndex e, u32 position) cons
         u32 idx = labelWrapper_->getOutputIndexFromClassIndex(e);
         // Get score in std space.
         score = trainer_->getClassLabelPosteriors().at(idx, position);
+        if (applyLog_) {
+            score = Core::log(score);
+        }
         if (returnScoresInNegLog_) {
-            score = -Core::log(score);  // transfer to -log space
+            score = -score;
             if (prior_.scale() != 0)
                 score -= -prior_.at(idx) * prior_.scale();  // priors are in +log space. substract them
         }
diff --git a/src/Nn/TrainerFeatureScorer.hh b/src/Nn/TrainerFeatureScorer.hh
index 7eb4bd541..14cea2d05 100644
--- a/src/Nn/TrainerFeatureScorer.hh
+++ b/src/Nn/TrainerFeatureScorer.hh
@@ -42,6 +42,7 @@ protected:
     mutable std::deque<Mm::FeatureVector> buffer_;
     mutable bool                          scoresComputed_;
     bool                                  returnScoresInNegLog_;
+    bool                                  applyLog_;
     u32                                   nClasses_;
     u32                                   inputDimension_;
     mutable u32                           batchIteration_;
diff --git a/src/Onnx/BLstmStateManager.cc b/src/Onnx/BLstmStateManager.cc
new file mode 100644
index 000000000..dbb42397e
--- /dev/null
+++ b/src/Onnx/BLstmStateManager.cc
@@ -0,0 +1,39 @@
+#include "BLstmStateManager.hh"
+
+namespace Onnx {
+
+BLstmStateManager::BLstmStateManager(Core::Configuration const& config)
+        : Precursor(config) {
+}
+
+void BLstmStateManager::setInitialStates(std::vector<OnnxStateVariable> const& state_vars) {
+    state_values_.clear();
+
+    for (auto state_var : state_vars) {
+        state_values_.emplace_back(Value::zeros<f32>({1, state_var.shape.back()}));  // batch size fixed to be 1
+    }
+}
+
+void BLstmStateManager::extendFeedDict(FeedDict& feed_dict, std::vector<OnnxStateVariable> const& state_vars) {
+    for (size_t i = 0; i < state_vars.size(); i++) {
+        feed_dict.emplace_back(state_vars[i].input_state_key, state_values_[i]);
+    }
+}
+
+void BLstmStateManager::extendTargets(TargetList& targets, std::vector<OnnxStateVariable> const& state_vars) {
+    for (auto state_var : state_vars) {
+        targets.push_back(state_var.output_state_key);
+    }
+}
+
+void BLstmStateManager::updateStates(std::vector<Value>& states) {
+    require_eq(states.size(), state_values_.size());
+
+    state_values_.clear();
+
+    for (size_t i = 0ul; i < states.size(); i++) {
+        state_values_.push_back(Value(std::move(states[i])));
+    }
+}
+
+}  // namespace Onnx
diff --git a/src/Onnx/BLstmStateManager.hh b/src/Onnx/BLstmStateManager.hh
new file mode 100644
index 000000000..f64e1ac1b
--- /dev/null
+++ b/src/Onnx/BLstmStateManager.hh
@@ -0,0 +1,34 @@
+#ifndef _ONNX_BLSTM_CARRYOVER_STATE_MANAGER_HH
+#define _ONNX_BLSTM_CARRYOVER_STATE_MANAGER_HH
+
+#include "StateManager.hh"
+
+namespace Onnx {
+
+class BLstmStateManager : public StateManager {
+public:
+    using Precursor  = StateManager;
+    using FeedDict   = StateManager::FeedDict;
+    using TargetList = StateManager::TargetList;
+
+public:
+    BLstmStateManager(Core::Configuration const& config);
+
+    virtual ~BLstmStateManager() = default;
+
+public:
+    void setInitialStates(std::vector<OnnxStateVariable> const& state_var) override;
+
+    void extendFeedDict(FeedDict& feed_dict, std::vector<OnnxStateVariable> const& state_vars) override;
+
+    void extendTargets(TargetList& targets, std::vector<OnnxStateVariable> const& state_vars) override;
+
+    void updateStates(std::vector<Value>& states) override;
+
+private:
+    std::vector<Value> state_values_;
+};
+
+}  // namespace Onnx
+
+#endif
diff --git a/src/Onnx/ConformerStateManager.cc b/src/Onnx/ConformerStateManager.cc
new file mode 100644
index 000000000..9c41ea6d7
--- /dev/null
+++ b/src/Onnx/ConformerStateManager.cc
@@ -0,0 +1,85 @@
+#include "ConformerStateManager.hh"
+
+namespace Onnx {
+
+const Core::ParameterInt ConformerStateManager::paramAttentionContextSize("attention-context-size", "left-context size (in frames)", 100, 0);
+const Core::ParameterInt ConformerStateManager::paramConvContextSize("conv-context-size", "left-context size (in frames)", 100, 0);
+const Core::ParameterInt ConformerStateManager::paramDiscardSuffixLength("discard-suffix-length", "how many frames to drop from the end of the new state (usefull for overlapping chunks)", 0, 0);
+
+ConformerStateManager::ConformerStateManager(Core::Configuration const& config)
+        : Precursor(config),
+          att_context_size_(paramAttentionContextSize(config)),
+          conv_context_size_(paramConvContextSize(config)),
+          discard_suffix_length_(paramDiscardSuffixLength(config)) {
+}
+
+void ConformerStateManager::setInitialStates(std::vector<OnnxStateVariable> const& state_vars) {
+    states_.clear();
+    for (auto state_var : state_vars) {
+        std::vector<int64_t> shape;
+        int                  time_axis = -1;
+        for (size_t i = 0ul; i < state_var.shape.size(); i++) {
+            // we assume the first axis is the batch axis and the next dynamic shape axis is the time axis
+            if (i != 0 && (state_var.shape[i] == -1 || state_var.shape[i] == -2)) {
+                shape.push_back(0);
+                if (time_axis == -1) {
+                    time_axes_.push_back(i);
+                    time_axis = i;
+                }
+            }
+            else {
+                shape.push_back(state_var.shape[i]);
+            }
+        }
+        shape[0] = 1;  // set batch dimension to 1
+        states_.emplace_back(Value::zeros<f32>(shape));
+    }
+}
+
+void ConformerStateManager::extendFeedDict(FeedDict& feed_dict, std::vector<OnnxStateVariable> const& state_vars) {
+    require_eq(state_vars.size(), states_.size());
+
+    for (size_t i = 0ul; i < state_vars.size(); i++) {
+        OnnxStateVariable state_var = state_vars[i];
+        Value&            state     = states_[i];
+        Value             input_state;
+        int64_t           dim_size = state.dimSize(time_axes_[i]);
+
+        if (state_var.input_state_key.find("mhsa") != std::string::npos) {
+            // trim the MHSA module state tensor
+            int64_t slice_start = std::max(dim_size - discard_suffix_length_ - att_context_size_, 0l);
+            int64_t slice_end   = std::max(dim_size - discard_suffix_length_, 0l);
+
+            input_state = state.slice(slice_start, slice_end, time_axes_[i]);
+        }
+        else if (state_var.input_state_key.find("conv") != std::string::npos) {
+            // trim the convolution module state tensor
+            int64_t slice_start = std::max(dim_size - discard_suffix_length_ - conv_context_size_, 0l);
+            int64_t slice_end   = std::max(dim_size - discard_suffix_length_, 0l);
+
+            input_state = state.slice(slice_start, slice_end, time_axes_[i]);
+        }
+        else {
+            input_state = Value(std::move(state));
+        }
+        feed_dict.emplace_back(state_var.input_state_key + ":size1",
+                               Value::create(std::vector<s32>{static_cast<s32>(input_state.dimSize((this->time_axes_)[i]))}));
+        feed_dict.emplace_back(state_var.input_state_key, std::move(input_state));
+    }
+}
+
+void ConformerStateManager::extendTargets(TargetList& targets, std::vector<OnnxStateVariable> const& state_vars) {
+    for (auto state_var : state_vars) {
+        targets.emplace_back(state_var.output_state_key);
+    }
+}
+
+void ConformerStateManager::updateStates(std::vector<Value>& states) {
+    require_eq(states.size(), states_.size());
+    states_.clear();
+    for (size_t i = 0ul; i < states.size(); i++) {
+        states_.push_back(Value(std::move(states[i])));
+    }
+}
+
+}  // namespace Onnx
diff --git a/src/Onnx/ConformerStateManager.hh b/src/Onnx/ConformerStateManager.hh
new file mode 100644
index 000000000..995ab7a16
--- /dev/null
+++ b/src/Onnx/ConformerStateManager.hh
@@ -0,0 +1,38 @@
+#ifndef _ONNX_CONFORMERSTATEMANAGER_HH
+#define _ONNX_CONFORMERSTATEMANAGER_HH
+
+#include "StateManager.hh"
+
+namespace Onnx {
+
+class ConformerStateManager : public StateManager {
+public:
+    using Precursor  = StateManager;
+    using FeedDict   = std::vector<std::pair<std::string, Value>>;
+    using TargetList = std::vector<std::string>;
+
+    static const Core::ParameterInt paramAttentionContextSize;
+    static const Core::ParameterInt paramConvContextSize;
+    static const Core::ParameterInt paramPrefixLength;
+    static const Core::ParameterInt paramDiscardSuffixLength;
+
+    ConformerStateManager(Core::Configuration const& config);
+    virtual ~ConformerStateManager() = default;
+
+    virtual void setInitialStates(std::vector<OnnxStateVariable> const& state_vars);
+    virtual void extendFeedDict(FeedDict& feed_dict, std::vector<OnnxStateVariable> const& state_vars);
+    virtual void extendTargets(TargetList& targets, std::vector<OnnxStateVariable> const& state_vars);
+    virtual void updateStates(std::vector<Value>& states);
+
+private:
+    const unsigned att_context_size_;
+    const unsigned conv_context_size_;
+    const unsigned discard_suffix_length_;
+
+    std::vector<Value> states_;
+    std::vector<int>   time_axes_;
+};
+
+}  // namespace Onnx
+
+#endif  // _ONNX_CONFORMERSTATEMANAGER_HHw
diff --git a/src/Onnx/DummyStateManager.cc b/src/Onnx/DummyStateManager.cc
new file mode 100644
index 000000000..fd141e4b1
--- /dev/null
+++ b/src/Onnx/DummyStateManager.cc
@@ -0,0 +1,18 @@
+#include "DummyStateManager.hh"
+
+namespace Onnx {
+
+DummyStateManager::DummyStateManager(Core::Configuration const& config)
+        : Precursor(config) {
+}
+
+void DummyStateManager::setInitialStates(std::vector<OnnxStateVariable> const& state_vars) {
+}
+void DummyStateManager::extendFeedDict(FeedDict& feed_dict, std::vector<OnnxStateVariable> const& state_vars) {
+}
+void DummyStateManager::extendTargets(TargetList& targets, std::vector<OnnxStateVariable> const& state_vars) {
+}
+void DummyStateManager::updateStates(std::vector<Value>& states) {
+}
+
+}  // namespace Onnx
diff --git a/src/Onnx/DummyStateManager.hh b/src/Onnx/DummyStateManager.hh
new file mode 100644
index 000000000..0bbfb3b6d
--- /dev/null
+++ b/src/Onnx/DummyStateManager.hh
@@ -0,0 +1,25 @@
+#ifndef _ONNX_DUMMYSTATEMANAGER_HH
+#define _ONNX_DUMMYSTATEMANAGER_HH
+
+#include "StateManager.hh"
+
+namespace Onnx {
+
+class DummyStateManager : public StateManager {
+public:
+    using Precursor  = StateManager;
+    using FeedDict   = Precursor::FeedDict;
+    using TargetList = Precursor::TargetList;
+
+    DummyStateManager(Core::Configuration const& config);
+    virtual ~DummyStateManager() = default;
+
+    virtual void setInitialStates(std::vector<OnnxStateVariable> const& state_vars);
+    virtual void extendFeedDict(FeedDict& feed_dict, std::vector<OnnxStateVariable> const& state_vars);
+    virtual void extendTargets(TargetList& targets, std::vector<OnnxStateVariable> const& state_vars);
+    virtual void updateStates(std::vector<Value>& states);
+};
+
+}  // namespace Onnx
+
+#endif  // _ONNX_DUMMYSTATEMANAGER_HH
diff --git a/src/Onnx/IOSpecification.hh b/src/Onnx/IOSpecification.hh
index e121aab4d..b873c8a1d 100644
--- a/src/Onnx/IOSpecification.hh
+++ b/src/Onnx/IOSpecification.hh
@@ -86,7 +86,8 @@ inline std::string IOMapping::getOnnxName(std::string const& param) const {
 }
 
 inline IOValidator::IOValidator(Core::Configuration const& config)
-        : Precursor(config), strict_(paramStrict(config)) {
+        : Precursor(config),
+          strict_(paramStrict(config)) {
 }
 
 }  // namespace Onnx
diff --git a/src/Onnx/Makefile b/src/Onnx/Makefile
index 6ddb9ec07..bf93618e0 100644
--- a/src/Onnx/Makefile
+++ b/src/Onnx/Makefile
@@ -9,14 +9,19 @@ include $(TOPDIR)/Makefile.cfg
 SUBDIRS		=
 TARGETS		= libSprintOnnx.$(a) check$(exe)
 
-LIBSPRINTONNX_O = $(OBJDIR)/Session.o \
-				  $(OBJDIR)/IOSpecification.o \
-				  $(OBJDIR)/Model.o \
-				  $(OBJDIR)/Module.o \
-				  $(OBJDIR)/OnnxEncoder.o \
-				  $(OBJDIR)/OnnxFeatureScorer.o \
-				  $(OBJDIR)/OnnxForwardNode.o \
-                  $(OBJDIR)/Value.o
+LIBSPRINTONNX_O = \
+		$(OBJDIR)/BLstmStateManager.o \
+		$(OBJDIR)/ConformerStateManager.o \
+		$(OBJDIR)/DummyStateManager.o \
+		$(OBJDIR)/IOSpecification.o \
+		$(OBJDIR)/Model.o \
+		$(OBJDIR)/Module.o \
+		$(OBJDIR)/OnnxEncoder.o \
+		$(OBJDIR)/OnnxFeatureScorer.o \
+		$(OBJDIR)/OnnxForwardNode.o \
+		$(OBJDIR)/Session.o \
+		$(OBJDIR)/StateManager.o \
+		$(OBJDIR)/Value.o
 
 CHECK_O = $(OBJDIR)/check.o \
           libSprintOnnx.$(a) \
diff --git a/src/Onnx/Module.cc b/src/Onnx/Module.cc
index 44f2ea5e6..4d3fdf2a9 100644
--- a/src/Onnx/Module.cc
+++ b/src/Onnx/Module.cc
@@ -16,6 +16,8 @@ namespace Onnx {
 Module_::Module_() {
     Mm::Module::instance().featureScorerFactory()->registerFeatureScorer<OnnxFeatureScorer, Mm::MixtureSet, Mm::AbstractMixtureSetLoader>(
             0x400 + 0, "onnx-feature-scorer");  // TODO enum value
+    Mm::Module::instance().featureScorerFactory()->registerFeatureScorer<OnnxFeatureScorer, Mm::MixtureSet, Mm::EmptyMixtureSetLoader>(
+            0x400 + 1, "onnx-feature-scorer-no-mixture");  // TODO enum value
 
     Flow::Registry::instance().registerFilter<OnnxForwardNode>();
 
diff --git a/src/Onnx/OnnxFeatureScorer.cc b/src/Onnx/OnnxFeatureScorer.cc
index 1b0e986f8..7454010b8 100644
--- a/src/Onnx/OnnxFeatureScorer.cc
+++ b/src/Onnx/OnnxFeatureScorer.cc
@@ -3,15 +3,15 @@
  */
 #include "OnnxFeatureScorer.hh"
 
-// #include "Module.hh"
+#include "Value.hh"
 
 namespace {
 
-std::vector<Onnx::IOSpecification> getIOSpec(int64_t num_features, int64_t num_classes) {
+std::vector<Onnx::IOSpecification> getIOSpec(bool static_dims, int64_t num_features, int64_t num_classes) {
     return std::vector<Onnx::IOSpecification>({
-            Onnx::IOSpecification{"features", Onnx::IODirection::INPUT, false, {Onnx::ValueType::TENSOR}, {Onnx::ValueDataType::FLOAT}, {{-1, -1, num_features}, {1, -1, num_features}}},
+            Onnx::IOSpecification{"features", Onnx::IODirection::INPUT, false, {Onnx::ValueType::TENSOR}, {Onnx::ValueDataType::FLOAT}, {{-1, -1, num_features}, {1, static_dims ? -2 : -1, num_features}}},
             Onnx::IOSpecification{"features-size", Onnx::IODirection::INPUT, true, {Onnx::ValueType::TENSOR}, {Onnx::ValueDataType::INT32}, {{-1}}},
-            Onnx::IOSpecification{"output", Onnx::IODirection::OUTPUT, false, {Onnx::ValueType::TENSOR}, {Onnx::ValueDataType::FLOAT}, {{-1, -1, num_classes}, {1, -1, num_classes}}},
+            Onnx::IOSpecification{"output", Onnx::IODirection::OUTPUT, false, {Onnx::ValueType::TENSOR}, {Onnx::ValueDataType::FLOAT}, {{-1, static_dims ? -2 : -1, num_classes}, {1, static_dims ? -2 : -1, num_classes}}},
     });
 }
 
@@ -46,15 +46,21 @@ class OnnxFeatureScorer::ContextScorer : public FeatureScorer::ContextScorer {
     u32                      batchIteration_;
 };
 
+const Core::ParameterBool OnnxFeatureScorer::paramAllowStaticDimensions("allow-static-dimensions", "whether to allow static input/output dimensions for the time axis", false);
+
 const Core::ParameterBool OnnxFeatureScorer::paramApplyLogOnOutput("apply-log-on-output", "whether to apply the log-function on the output, usefull if the model outputs softmax instead of log-softmax", false);
 
-const Core::ParameterBool OnnxFeatureScorer::paramNegateOutput("negate-output", "wheter negate output (because the model outputs log softmax and not negative log softmax", true);
+const Core::ParameterBool OnnxFeatureScorer::paramNegateOutput("negate-output", "wether to negate output (because the model outputs log softmax and not negative log softmax", true);
+const Core::ParameterBool OnnxFeatureScorer::paramUseOutputAsIs(
+        "use-output-as-is", "return the output of the neural network without modification", false);
 
 OnnxFeatureScorer::OnnxFeatureScorer(const Core::Configuration& config, Core::Ref<const Mm::MixtureSet> mixtureSet)
         : Core::Component(config),
           Mm::FeatureScorer(config),
+          allowStaticDimensions_(paramAllowStaticDimensions(config)),
           applyLogOnOutput_(paramApplyLogOnOutput(config)),
           negateOutput_(paramNegateOutput(config)),
+          useOutputAsIs_(paramUseOutputAsIs(config)),
           prior_(config),
           labelWrapper_(),
           expectedFeatureDim_(0l),
@@ -65,9 +71,10 @@ OnnxFeatureScorer::OnnxFeatureScorer(const Core::Configuration& config, Core::Re
           scoresComputed_(false),
           scores_(new Math::FastMatrix<Float>()),
           session_(select("session")),
-          ioSpec_(getIOSpec(-2, -2)),
+          ioSpec_(getIOSpec(allowStaticDimensions_, -2, -2)),
           mapping_(select("io-map"), ioSpec_),
-          validator_(select("validator")) {
+          validator_(select("validator")),
+          state_manager_() {
     bool valid = validator_.validate(ioSpec_, mapping_, session_);
     if (not valid) {
         log("Failed to validate input model");
@@ -84,12 +91,20 @@ OnnxFeatureScorer::OnnxFeatureScorer(const Core::Configuration& config, Core::Re
         if (prior_.fileName() != "") {
             prior_.read();
         }
-        else {
+        else if (mixtureSet->nDensities() > 0) {  // is not empty mixture set
             prior_.setFromMixtureSet(mixtureSet, *labelWrapper_);
         }
+        else {
+            prior_.initUniform(expectedOutputDim_);
+        }
+
         // The prior classes are the NN output classes.
         require_eq(labelWrapper_->nClassesToAccumulate(), prior_.size());
     }
+
+    state_manager_   = StateManager::create(select("state-manager"));
+    state_variables_ = session_.getStateVariablesMetadata();
+    state_manager_->setInitialStates(state_variables_);
 }
 
 Mm::EmissionIndex OnnxFeatureScorer::nMixtures() const {
@@ -107,34 +122,30 @@ Mm::FeatureScorer::Scorer OnnxFeatureScorer::getScorer(const Mm::FeatureVector&
 }
 
 Mm::Score OnnxFeatureScorer::getScore(Mm::EmissionIndex e, u32 position) const {
-    size_t num_frames = inputBuffer_.size();
-    require_lt(position, num_frames);
-    // process buffer if needed
-    if (!scoresComputed_) {
-        std::vector<std::pair<std::string, Value>> inputs;
-        std::vector<std::string>                   output_names;
+    const_cast<OnnxFeatureScorer*>(this)->computeScoresInternal();
+    require_lt(position, scores_->nRows());
 
-        inputs.emplace_back(mapping_.getOnnxName("features"), createInputValue());
-        if (mapping_.hasOnnxName("features-size")) {
-            inputs.emplace_back(mapping_.getOnnxName("features-size"),
-                                Value::create(std::vector<s32>{static_cast<s32>(num_frames)}));
-        }
-        output_names.push_back(mapping_.getOnnxName("output"));
-
-        auto t_start = std::chrono::steady_clock::now();
-
-        std::vector<Value> output;
-        session_.run(std::move(inputs), output_names, output);
-        output[0].get<>(0, *scores_);
+    Mm::Score score = Core::Type<Mm::Score>::max;
 
-        auto t_end     = std::chrono::steady_clock::now();
-        auto t_elapsed = std::chrono::duration_cast<std::chrono::duration<double>>(t_end - t_start).count();
-        log("num_frames: %zu elapsed: %f AM_RTF: %f", num_frames, t_elapsed, t_elapsed / (num_frames / 100.0));
+    if (labelWrapper_->isClassToAccumulate(e)) {
+        u32 idx = labelWrapper_->getOutputIndexFromClassIndex(e);
+        score   = scores_->at(position, idx);
+        if (useOutputAsIs_) {
+            return score;
+        }
+        if (applyLogOnOutput_) {
+            score = Core::log(score);
+        }
+        if (negateOutput_) {
+            score = -score;
+        }
 
-        // mark computed
-        scoresComputed_ = true;
+        if (prior_.scale() != 0.0f) {
+            score -= -prior_.at(idx) * prior_.scale();  // priors are in +log space. substract them
+        }
     }
-    return getScoreFromOutput(e, position);
+
+    return score;
 }
 
 void OnnxFeatureScorer::reset() const {
@@ -148,18 +159,20 @@ void OnnxFeatureScorer::reset() const {
 }
 
 void OnnxFeatureScorer::finalize() const {
+    state_manager_->setInitialStates(state_variables_);
 }
 
 void OnnxFeatureScorer::addFeature(const Mm::FeatureVector& f) const {
     // Lazily call reset() when flush() went through all the buffer before.
-    if (currentFeature_ > 0 && currentFeature_ >= inputBuffer_.size()) {
+    if (currentFeature_ > 0 && scoresComputed_ && currentFeature_ >= scores_->nRows()) {
         reset();
     }
     addFeatureInternal(f);
 }
 
 Mm::FeatureScorer::Scorer OnnxFeatureScorer::flush() const {
-    require_lt(currentFeature_, inputBuffer_.size());
+    const_cast<OnnxFeatureScorer*>(this)->computeScoresInternal();
+    require_lt(currentFeature_, scores_->nRows());
     Scorer scorer(new ContextScorer(this, currentFeature_, batchIteration_));
     currentFeature_++;
     // We must not call reset() here because the calls to getScore() will be delayed.
@@ -167,7 +180,8 @@ Mm::FeatureScorer::Scorer OnnxFeatureScorer::flush() const {
 }
 
 Mm::FeatureScorer::Scorer OnnxFeatureScorer::getTimeIndexedScorer(u32 time) const {
-    require_lt(time, inputBuffer_.size());
+    const_cast<OnnxFeatureScorer*>(this)->computeScoresInternal();
+    require_lt(time, scores_->nRows());
     Scorer scorer(new ContextScorer(this, time, batchIteration_));
     return scorer;
 }
@@ -182,6 +196,46 @@ void OnnxFeatureScorer::addFeatureInternal(const Mm::FeatureVector& f) const {
     inputBuffer_.push_back(f);
 }
 
+void OnnxFeatureScorer::computeScoresInternal() {
+    if (!scoresComputed_) {
+        size_t                                     num_frames = inputBuffer_.size();
+        std::vector<std::pair<std::string, Value>> inputs;
+        std::vector<std::string>                   output_names;
+
+        // input features and output scores
+        inputs.emplace_back(mapping_.getOnnxName("features"), createInputValue());
+        if (mapping_.hasOnnxName("features-size")) {
+            inputs.emplace_back(mapping_.getOnnxName("features-size"),
+                                Value::create(std::vector<s32>{static_cast<s32>(num_frames)}));
+        }
+        output_names.push_back(mapping_.getOnnxName("output"));
+
+        // input and output states
+        state_manager_->extendFeedDict(inputs, state_variables_);
+        state_manager_->extendTargets(output_names, state_variables_);
+
+        auto t_start = std::chrono::steady_clock::now();
+
+        std::vector<Value> output;
+        session_.run(std::move(inputs), output_names, output);
+        output[0].get<>(0, *scores_);  // output scores
+
+        // get new states
+        std::vector<Value> output_states;
+        for (size_t i = 1ul; i < output.size(); i++) {  // other model outputs
+            output_states.emplace_back(std::move(output[i]));
+        }
+        state_manager_->updateStates(output_states);
+
+        auto t_end     = std::chrono::steady_clock::now();
+        auto t_elapsed = std::chrono::duration_cast<std::chrono::duration<double>>(t_end - t_start).count();
+        log("num_frames: %zu elapsed: %f AM_RTF: %f", num_frames, t_elapsed, t_elapsed / (num_frames / 100.0));
+
+        // mark computed
+        scoresComputed_ = true;
+    }
+}
+
 Value OnnxFeatureScorer::createInputValue() const {
     // copy from deque into a matrix
     size_t num_frames = inputBuffer_.size();
@@ -197,25 +251,4 @@ Value OnnxFeatureScorer::createInputValue() const {
     return Value::create(nnBuffer, true);
 }
 
-Mm::Score OnnxFeatureScorer::getScoreFromOutput(Mm::EmissionIndex e, u32 position) const {
-    Mm::Score score = Core::Type<Mm::Score>::max;
-
-    if (labelWrapper_->isClassToAccumulate(e)) {
-        u32 idx = labelWrapper_->getOutputIndexFromClassIndex(e);
-        score   = scores_->at(position, idx);
-        if (applyLogOnOutput_) {
-            score = Core::log(score);
-        }
-        if (negateOutput_) {
-            score = -score;
-        }
-
-        if (prior_.scale() != 0.0f) {
-            score -= -prior_.at(idx) * prior_.scale();  // priors are in +log space. substract them
-        }
-    }
-
-    return score;
-}
-
 }  // namespace Onnx
diff --git a/src/Onnx/OnnxFeatureScorer.hh b/src/Onnx/OnnxFeatureScorer.hh
index 9bf35ec5e..2cf9a92a9 100644
--- a/src/Onnx/OnnxFeatureScorer.hh
+++ b/src/Onnx/OnnxFeatureScorer.hh
@@ -16,7 +16,9 @@
 #include <Nn/Types.hh>
 
 #include "IOSpecification.hh"
+#include "OnnxStateVariable.hh"
 #include "Session.hh"
+#include "StateManager.hh"
 
 namespace Onnx {
 
@@ -25,8 +27,10 @@ public:
     using Precursor = Mm::FeatureScorer;
     using Scorer    = Core::Ref<const ContextScorer>;
 
+    static const Core::ParameterBool paramAllowStaticDimensions;
     static const Core::ParameterBool paramApplyLogOnOutput;
     static const Core::ParameterBool paramNegateOutput;
+    static const Core::ParameterBool paramUseOutputAsIs;
 
     OnnxFeatureScorer(const Core::Configuration& c, Core::Ref<const Mm::MixtureSet> mixtureSet);
     virtual ~OnnxFeatureScorer() = default;
@@ -110,8 +114,10 @@ protected:
     using Float = Mm::Score;
     class ContextScorer;
 
+    const bool allowStaticDimensions_;
     const bool applyLogOnOutput_;
     const bool negateOutput_;
+    const bool useOutputAsIs_;
 
     Nn::Prior<Float>                       prior_;
     std::unique_ptr<Nn::ClassLabelWrapper> labelWrapper_;
@@ -129,10 +135,12 @@ protected:
     std::vector<Onnx::IOSpecification> ioSpec_;
     IOMapping                          mapping_;
     IOValidator                        validator_;
+    std::unique_ptr<StateManager>      state_manager_;
+    std::vector<OnnxStateVariable>     state_variables_;
 
-    void      addFeatureInternal(const Mm::FeatureVector& f) const;
-    Value     createInputValue() const;
-    Mm::Score getScoreFromOutput(Mm::EmissionIndex e, u32 position) const;
+    void         addFeatureInternal(const Mm::FeatureVector& f) const;
+    virtual void computeScoresInternal();
+    Value        createInputValue() const;
 };
 
 // inline implementations
@@ -154,7 +162,7 @@ inline bool OnnxFeatureScorer::bufferFilled() const {
 }
 
 inline bool OnnxFeatureScorer::bufferEmpty() const {
-    return currentFeature_ >= inputBuffer_.size();
+    return scoresComputed_ && currentFeature_ >= scores_->nRows();
 }  // == cannot call flush() anymore
 
 inline u32 OnnxFeatureScorer::bufferSize() const {
diff --git a/src/Onnx/OnnxStateVariable.hh b/src/Onnx/OnnxStateVariable.hh
new file mode 100644
index 000000000..9c41ef00c
--- /dev/null
+++ b/src/Onnx/OnnxStateVariable.hh
@@ -0,0 +1,18 @@
+#ifndef _ONNX_ONNX_STATE_VARIABLE_HH
+#define _ONNX_ONNX_STATE_VARIABLE_HH
+
+#include <string>
+
+#include <Core/Types.hh>
+
+namespace Onnx {
+
+struct OnnxStateVariable {
+    std::string      input_state_key;
+    std::string      output_state_key;
+    std::vector<s64> shape;
+};
+
+}  // namespace Onnx
+
+#endif  // _ONNX_ONNX_STATE_VARIABLE_HH
diff --git a/src/Onnx/Session.cc b/src/Onnx/Session.cc
index d09b8d39f..63994441e 100644
--- a/src/Onnx/Session.cc
+++ b/src/Onnx/Session.cc
@@ -33,11 +33,21 @@ const Core::Choice Session::executionProviderChoice(
 const Core::ParameterChoice Session::paramExecutionProviderType(
         "execution-provider-type", &Session::executionProviderChoice, "type of execution provider", ExecutionProviderType::cpu);
 
+const Core::ParameterString Session::paramStatePrefix("state-prefix",
+                                                      "Prefix for the state keys in the metadata to distinguish from other metadata",
+                                                      "STATE_");
+
+const Core::ParameterBool Session::paramRemovePrefixFromKey("remove-prefix-from-key",
+                                                            "Whether to remove the prefix from the state keys for the node name lookup",
+                                                            true);
+
 Session::Session(Core::Configuration const& config)
         : Precursor(config),
           file_(paramFile(config)),
           intraOpNumThreads_(paramIntraOpNumThreads(config)),
           interOpNumThreads_(paramInterOpNumThreads(config)),
+          statePrefix_(paramStatePrefix(config)),
+          removePrefixFromKey_(paramRemovePrefixFromKey(config)),
           allocator_(),
           env_(ORT_LOGGING_LEVEL_WARNING),
           session_(nullptr),
@@ -120,6 +130,8 @@ Session::Session(Core::Configuration const& config)
         customMetadataKeys_.emplace_back(key);
         customMetadata_[key] = std::string(value.get());
     }
+
+    initializeStateVariablesMetadata();
 }
 
 bool Session::hasInput(std::string const& name) const {
@@ -244,4 +256,34 @@ std::vector<std::string> const& Session::getCustomMetadataKeys() const {
     return customMetadataKeys_;
 }
 
+void Session::initializeStateVariablesMetadata() {
+    for (std::string const& key : customMetadataKeys_) {
+        auto state_pos = key.find(statePrefix_);
+
+        if (state_pos != 0) {
+            continue;
+        }
+
+        OnnxStateVariable state_variable;
+
+        if (removePrefixFromKey_) {
+            state_variable.input_state_key = key.substr(statePrefix_.size());
+        }
+        else {
+            state_variable.input_state_key = key;
+        }
+
+        state_variable.output_state_key = getCustomMetadata(key);
+        state_variable.shape            = getInputShape(state_variable.input_state_key);
+
+        log("State: input_state_key=%s output_state_key=%s", state_variable.input_state_key.c_str(), state_variable.output_state_key.c_str());
+
+        stateVariables_.push_back(state_variable);
+    }
+}
+
+std::vector<OnnxStateVariable> const& Session::getStateVariablesMetadata() const {
+    return stateVariables_;
+}
+
 }  // namespace Onnx
diff --git a/src/Onnx/Session.hh b/src/Onnx/Session.hh
index 30db2d9ae..743b9eda0 100644
--- a/src/Onnx/Session.hh
+++ b/src/Onnx/Session.hh
@@ -10,6 +10,7 @@
 
 #include <Core/Component.hh>
 
+#include "OnnxStateVariable.hh"
 #include "Value.hh"
 
 namespace Onnx {
@@ -26,6 +27,8 @@ public:
     static const Core::ParameterString paramFile;
     static const Core::ParameterInt    paramIntraOpNumThreads;
     static const Core::ParameterInt    paramInterOpNumThreads;
+    static const Core::ParameterString paramStatePrefix;
+    static const Core::ParameterBool   paramRemovePrefixFromKey;
 
     static const Core::Choice          executionProviderChoice;
     static const Core::ParameterChoice paramExecutionProviderType;
@@ -49,10 +52,14 @@ public:
     std::string                     getCustomMetadata(std::string const& key) const;
     std::vector<std::string> const& getCustomMetadataKeys() const;
 
+    std::vector<OnnxStateVariable> const& getStateVariablesMetadata() const;
+
 private:
     const std::string file_;
     const size_t      intraOpNumThreads_;
     const size_t      interOpNumThreads_;
+    const std::string statePrefix_;
+    const bool        removePrefixFromKey_;
 
     Ort::AllocatorWithDefaultOptions allocator_;
     Ort::Env                         env_;
@@ -63,6 +70,10 @@ private:
 
     std::unordered_map<std::string, std::string> customMetadata_;
     std::vector<std::string>                     customMetadataKeys_;
+
+    std::vector<OnnxStateVariable> stateVariables_;
+
+    void initializeStateVariablesMetadata();
 };
 
 }  // namespace Onnx
diff --git a/src/Onnx/StateManager.cc b/src/Onnx/StateManager.cc
new file mode 100644
index 000000000..5c20c018b
--- /dev/null
+++ b/src/Onnx/StateManager.cc
@@ -0,0 +1,42 @@
+#include "StateManager.hh"
+#include "BLstmStateManager.hh"
+#include "ConformerStateManager.hh"
+#include "DummyStateManager.hh"
+
+namespace {
+enum StateManagerType : int {
+    Dummy,
+    Conformer,
+    BLstm,
+};
+
+const Core::Choice stateManagerTypeChoice(
+        "dummy", StateManagerType::Dummy,
+        "conformer", StateManagerType::Conformer,
+        "blstm", StateManagerType::BLstm,
+        Core::Choice::endMark());
+
+const Core::ParameterChoice stateManagerTypeParam(
+        "type", &stateManagerTypeChoice, "type of stateManager", StateManagerType::Dummy);
+
+}  // namespace
+
+namespace Onnx {
+
+std::unique_ptr<StateManager> StateManager::create(Core::Configuration const& config) {
+    switch (stateManagerTypeParam(config)) {
+        case Conformer:
+            return std::unique_ptr<StateManager>(new ConformerStateManager(config));
+        case BLstm:
+            return std::unique_ptr<StateManager>(new BLstmStateManager(config));
+        case Dummy:
+        default:
+            return std::unique_ptr<StateManager>(new DummyStateManager(config));
+    }
+    return std::unique_ptr<StateManager>();
+}
+
+StateManager::StateManager(Core::Configuration const& config)
+        : Precursor(config) {}
+
+}  // namespace Onnx
diff --git a/src/Onnx/StateManager.hh b/src/Onnx/StateManager.hh
new file mode 100644
index 000000000..be91367f3
--- /dev/null
+++ b/src/Onnx/StateManager.hh
@@ -0,0 +1,30 @@
+#ifndef _ONNX_STATEMANAGER_HH
+#define _ONNX_STATEMANAGER_HH
+
+#include <Core/Component.hh>
+
+#include "OnnxStateVariable.hh"
+#include "Value.hh"
+
+namespace Onnx {
+
+class StateManager : public Core::Component {
+public:
+    using Precursor  = Core::Component;
+    using FeedDict   = std::vector<std::pair<std::string, Value>>;
+    using TargetList = std::vector<std::string>;
+
+    static std::unique_ptr<StateManager> create(Core::Configuration const& config);
+
+    StateManager(Core::Configuration const& config);
+    virtual ~StateManager() = default;
+
+    virtual void setInitialStates(std::vector<OnnxStateVariable> const& state_vars)                    = 0;
+    virtual void extendFeedDict(FeedDict& feed_dict, std::vector<OnnxStateVariable> const& state_vars) = 0;
+    virtual void extendTargets(TargetList& targets, std::vector<OnnxStateVariable> const& state_vars)  = 0;
+    virtual void updateStates(std::vector<Value>& states)                                              = 0;
+};
+
+}  // namespace Onnx
+
+#endif  // _ONNX_STATEMANAGER_HH
diff --git a/src/Onnx/Value.cc b/src/Onnx/Value.cc
index 3a115db1a..8519fcb8d 100644
--- a/src/Onnx/Value.cc
+++ b/src/Onnx/Value.cc
@@ -35,6 +35,23 @@ DEFINE_ONNX_TENSOR_TYPE_MAPING(std::complex<float>, ONNX_TENSOR_ELEMENT_DATA_TYP
 DEFINE_ONNX_TENSOR_TYPE_MAPING(std::complex<double>, ONNX_TENSOR_ELEMENT_DATA_TYPE_COMPLEX128)
 DEFINE_ONNX_TENSOR_TYPE_MAPING(Ort::BFloat16_t, ONNX_TENSOR_ELEMENT_DATA_TYPE_BFLOAT16)
 
+/*
+ * num_blocks: number of incontinious blocks to each take from array a and array b
+ * block_size_a: number of continious elements from array a to take per block
+ * block_size_b: number of continious elements from array b to take per block
+ */
+template<typename T>
+void dynamic_rank_concat(Ort::Value& out, Ort::Value const& a, Ort::Value const& b, int64_t num_blocks, int64_t block_size_a, int64_t block_size_b) {
+    T*       data_out = out.GetTensorMutableData<T>();
+    T const* data_a   = a.GetTensorData<T>();
+    T const* data_b   = b.GetTensorData<T>();
+
+    for (int64_t i = 0ul; i < num_blocks; i++) {
+        std::copy(data_a + block_size_a * i, data_a + block_size_a * (i + 1), data_out + (block_size_a + block_size_b) * i);
+        std::copy(data_b + block_size_b * i, data_b + block_size_b * (i + 1), data_out + (block_size_a + block_size_b) * i + block_size_a);
+    }
+}
+
 /*
  * num_blocks: number of incontinious blocks to each take from the arrays
  * block_sizes: number of continuous elements from each array to take per block
@@ -62,6 +79,25 @@ void dynamic_rank_concat(Ort::Value& out, std::vector<Ort::Value const*> const&
     }
 }
 
+/*
+ * num_blocks: number of incontinious blocks to take
+ * block_size: number of continious elements to take per block
+ */
+template<typename T>
+void dynamic_rank_slice(Ort::Value& left, Ort::Value const& right, int64_t start, int64_t size, int64_t num_blocks, int64_t block_size) {
+    T*       data_left  = left.GetTensorMutableData<T>();
+    T const* data_right = right.GetTensorData<T>();
+
+    int64_t offset_head;
+    int64_t offset_tail;
+    for (int64_t i = 0; i < num_blocks; i++) {
+        offset_head = (i + start) * block_size;
+        offset_tail = offset_head + size * block_size;
+
+        std::copy(data_right + offset_head, data_right + offset_tail, data_left + i * size * block_size);
+    }
+}
+
 }  // namespace
 
 namespace Onnx {
@@ -158,6 +194,88 @@ template Value Value::zeros<u16>(std::vector<int64_t> const& dim);
 template Value Value::zeros<s8>(std::vector<int64_t> const& dim);
 template Value Value::zeros<u8>(std::vector<int64_t> const& dim);
 
+Value Value::concat(Value const& a, Value const& b, int axis) {
+    require_eq(a.numDims(), b.numDims());
+    require_eq(a.value_.GetTensorTypeAndShapeInfo().GetElementType(), b.value_.GetTensorTypeAndShapeInfo().GetElementType());
+
+    if (axis < 0) {
+        axis = a.numDims() + axis;
+    }
+    require_lt(axis, a.numDims());
+    std::vector<int64_t> new_shape(a.numDims());
+    for (int i = 0; i < a.numDims(); i++) {
+        if (i != axis) {
+            require_eq(a.dimSize(i), b.dimSize(i));
+            new_shape[i] = a.dimSize(i);
+        }
+        else {
+            new_shape[i] = a.dimSize(i) + b.dimSize(i);
+        }
+    }
+
+    int64_t num_blocks   = 1l;
+    int64_t block_size_a = 1l;
+    int64_t block_size_b = 1l;
+    for (int i = 0; i < axis; i++) {
+        num_blocks *= a.dimSize(i);
+    }
+    for (int i = axis; i < a.numDims(); i++) {
+        block_size_a *= a.dimSize(i);
+        block_size_b *= b.dimSize(i);
+    }
+
+    Value res;
+
+    switch (a.dataType()) {
+        case ValueDataType::FLOAT: {
+            Value res = Value::zeros<f32>(new_shape);
+            dynamic_rank_concat<f32>(res.value_, a.value_, b.value_, num_blocks, block_size_a, block_size_b);
+            return res;
+        }
+        case ValueDataType::DOUBLE: {
+            Value res = Value::zeros<f64>(new_shape);
+            dynamic_rank_concat<f64>(res.value_, a.value_, b.value_, num_blocks, block_size_a, block_size_b);
+            return res;
+        }
+        case ValueDataType::INT64: {
+            Value res = Value::zeros<s64>(new_shape);
+            dynamic_rank_concat<s64>(res.value_, a.value_, b.value_, num_blocks, block_size_a, block_size_b);
+            return res;
+        }
+        case ValueDataType::UINT64: {
+            Value res = Value::zeros<u64>(new_shape);
+            dynamic_rank_concat<u64>(res.value_, a.value_, b.value_, num_blocks, block_size_a, block_size_b);
+            return res;
+        }
+        case ValueDataType::INT32: {
+            Value res = Value::zeros<s32>(new_shape);
+            dynamic_rank_concat<s32>(res.value_, a.value_, b.value_, num_blocks, block_size_a, block_size_b);
+            return res;
+        }
+        case ValueDataType::UINT32: {
+            Value res = Value::zeros<u32>(new_shape);
+            dynamic_rank_concat<u32>(res.value_, a.value_, b.value_, num_blocks, block_size_a, block_size_b);
+            return res;
+        }
+        case ValueDataType::INT16: {
+            Value res = Value::zeros<s16>(new_shape);
+            dynamic_rank_concat<s16>(res.value_, a.value_, b.value_, num_blocks, block_size_a, block_size_b);
+            return res;
+        }
+        case ValueDataType::UINT16: {
+            Value res = Value::zeros<u16>(new_shape);
+            dynamic_rank_concat<u16>(res.value_, a.value_, b.value_, num_blocks, block_size_a, block_size_b);
+            return res;
+        }
+        case ValueDataType::INT8: {
+            Value res = Value::zeros<s8>(new_shape);
+            dynamic_rank_concat<s8>(res.value_, a.value_, b.value_, num_blocks, block_size_a, block_size_b);
+            return res;
+        }
+        default: defect();
+    }
+}
+
 Value Value::concat(std::vector<Value const*> const& values, int axis) {
     require(values.size() > 0);
 
@@ -928,6 +1046,109 @@ template u16 const* Value::data<u16>(size_t, size_t, size_t) const;
 template s8 const*  Value::data<s8>(size_t, size_t, size_t) const;
 template u8 const*  Value::data<u8>(size_t, size_t, size_t) const;
 
+Value Value::slice(int64_t start, int64_t end, int axis) {
+    start = start >= 0 ? start : dimSize(axis) + start;
+    end   = end >= 0 ? end : dimSize(axis) + 1 + end;
+
+    require_ge(start, 0);
+    require_le(start, end);
+    require_le(end, dimSize(axis));
+
+    if (end - start >= dimSize(axis)) {  // no enough data for slicing
+        return Value(*this);
+    }
+
+    std::vector<int64_t> new_shape(numDims());
+    for (int i = 0; i < numDims(); i++) {
+        if (dimSize(i) == 0) {
+            return Value(*this);
+        }
+        if (i == axis) {
+            new_shape[i] = end - start;
+        }
+        else {
+            new_shape[i] = dimSize(i);
+        }
+    }
+
+    // index offset per position shift
+    std::vector<int64_t> strides;
+    int64_t              factor = 1l;
+    for (int i = numDims() - 1; i >= 0; i--) {
+        strides.push_back(factor);
+        factor *= dimSize(i);
+    }
+    std::reverse(strides.begin(), strides.end());
+
+    int64_t num_blocks = strides[0] * dimSize(0) / strides[axis - 1];
+    int64_t block_size = strides[axis];
+
+    Value res;
+    if (numDims() > 0) {
+        switch (dataType()) {
+            case ValueDataType::FLOAT: {
+                Value res = Value::zeros<f32>(new_shape);
+                dynamic_rank_slice<f32>(res.value_, value_, start, end - start, num_blocks, block_size);
+                return res;
+            }
+            case ValueDataType::DOUBLE: {
+                Value res = Value::zeros<f64>(new_shape);
+                dynamic_rank_slice<f64>(res.value_, value_, start, end - start, num_blocks, block_size);
+                return res;
+            }
+            case ValueDataType::INT64: {
+                Value res = Value::zeros<s64>(new_shape);
+                dynamic_rank_slice<s64>(res.value_, value_, start, end - start, num_blocks, block_size);
+                return res;
+            }
+            case ValueDataType::UINT64: {
+                Value res = Value::zeros<u64>(new_shape);
+                dynamic_rank_slice<u64>(res.value_, value_, start, end - start, num_blocks, block_size);
+                return res;
+            }
+            case ValueDataType::INT32: {
+                Value res = Value::zeros<s32>(new_shape);
+                dynamic_rank_slice<s32>(res.value_, value_, start, end - start, num_blocks, block_size);
+                return res;
+            }
+            case ValueDataType::UINT32: {
+                Value res = Value::zeros<u32>(new_shape);
+                dynamic_rank_slice<u32>(res.value_, value_, start, end - start, num_blocks, block_size);
+                return res;
+            }
+            case ValueDataType::INT16: {
+                Value res = Value::zeros<s16>(new_shape);
+                dynamic_rank_slice<s16>(res.value_, value_, start, end - start, num_blocks, block_size);
+                return res;
+            }
+            case ValueDataType::UINT16: {
+                Value res = Value::zeros<u16>(new_shape);
+                dynamic_rank_slice<u16>(res.value_, value_, start, end - start, num_blocks, block_size);
+                return res;
+            }
+            case ValueDataType::INT8: {
+                Value res = Value::zeros<s8>(new_shape);
+                dynamic_rank_slice<s8>(res.value_, value_, start, end - start, num_blocks, block_size);
+                return res;
+            }
+            default: defect();
+        }
+    }
+
+    return res;
+}
+
+Value Value::slice(std::vector<int64_t> const& start, std::vector<int64_t> const& end) {
+    require_le(static_cast<int>(start.size()), numDims());
+    require_eq(start.size(), end.size());
+
+    Value res(*this);
+    for (int i = 0; i < numDims(); i++) {
+        res = res.slice(start[i], end[i], i);
+    }
+    return res;
+}
+
 /* ------------------------- Setters ------------------------- */
 
 template<typename T>
diff --git a/src/Onnx/Value.hh b/src/Onnx/Value.hh
index 136009505..2ef48bc3a 100644
--- a/src/Onnx/Value.hh
+++ b/src/Onnx/Value.hh
@@ -64,11 +64,12 @@ public:
     template<typename T>
     static Value zeros(std::vector<int64_t> const& dim);
 
+    static Value concat(Value const& a, Value const& b, int axis);
     static Value concat(std::vector<Value const*> const& values, int axis);
 
     Value();
-    Value(Value&& other);
     Value(Value const& other);
+    Value(Value&& value);
     ~Value() = default;
 
     bool empty() const;
@@ -151,6 +152,10 @@ public:
     template<typename T>
     T const* data(size_t dim0_idx, size_t dim1_idx, size_t dim2_idx) const;
 
+    Value slice(int64_t start, int64_t end, int axis);
+
+    Value slice(std::vector<int64_t> const& start, std::vector<int64_t> const& end);
+
     /* -------------------- Setters -------------------- */
 
     template<typename T>
@@ -175,10 +180,10 @@ public:
     void save(std::string const& path) const;
 
 protected:
-    Value(Ort::Value&& value);
-
     Ort::Value value_;
 
+    Value(Ort::Value&& value);
+
     template<typename T>
     void copyFrom(Ort::Value const& v);
 
diff --git a/src/OpenFst/Encode.hh b/src/OpenFst/Encode.hh
index 798961af4..c25d89546 100644
--- a/src/OpenFst/Encode.hh
+++ b/src/OpenFst/Encode.hh
@@ -90,11 +90,11 @@ public:
         return mapper_.table();
     }
 
-    bool Write(std::ostream& strm, const string& source) {
+    bool Write(std::ostream& strm, const std::string& source) {
         return mapper_.Write(strm, source);
     }
 
-    bool Write(const string& filename) {
+    bool Write(const std::string& filename) {
         return mapper_.Write(filename);
     }
 
diff --git a/src/OpenFst/FsaMapper.hh b/src/OpenFst/FsaMapper.hh
index 326b53d64..9e414864d 100644
--- a/src/OpenFst/FsaMapper.hh
+++ b/src/OpenFst/FsaMapper.hh
@@ -191,7 +191,7 @@ public:
             return impl_->Properties(mask);
         }
     }
-    virtual const string& Type() const {
+    virtual const std::string& Type() const {
         return impl_->Type();
     }
     virtual Self* Copy(bool reset = false) const {
@@ -229,7 +229,8 @@ class FsaMapperStateIteratorBase : public FstLib::StateIteratorBase<typename F::
 public:
     typedef typename F::StateId StateId;
     explicit FsaMapperStateIteratorBase(typename F::ConstAutomatonRef f)
-            : fsa_(f), s_(0) {}
+            : fsa_(f),
+              s_(0) {}
     virtual ~FsaMapperStateIteratorBase() {}
 
     virtual bool Done() const {
@@ -294,7 +295,8 @@ private:
     const F&         parent_;
     std::vector<Arc> arcs_;
     size_t           i;
-    void             createArcs(ConstStateRef state) {
+
+    void createArcs(ConstStateRef state) {
         arcs_.resize(state->nArcs());
         typename std::vector<Arc>::iterator fstArc = arcs_.begin();
         for (typename F::FsaType::State::const_iterator a = state->begin(); a != state->end(); ++a, ++fstArc) {
diff --git a/src/OpenFst/FstMapper.hh b/src/OpenFst/FstMapper.hh
index 3f9905ae4..e90d679dc 100644
--- a/src/OpenFst/FstMapper.hh
+++ b/src/OpenFst/FstMapper.hh
@@ -44,7 +44,9 @@ protected:
 
 public:
     FstMapperAutomatonImpl(const FstAutomaton* fst, ConstSemiringRef semiring, WeightConverterType converter)
-            : fst_(fst), semiring_(semiring), weightConverter_(converter) {
+            : fst_(fst),
+              semiring_(semiring),
+              weightConverter_(converter) {
         init();
     }
 
@@ -121,9 +123,11 @@ protected:
 
 public:
     FstMapperAutomaton(const FstAutomaton* fst, WeightConverterType converter = WeightConverterType())
-            : FsaAutomaton(), impl_(new Impl(fst, Fsa::ConstSemiringRef(), converter)) {}
+            : FsaAutomaton(),
+              impl_(new Impl(fst, Fsa::ConstSemiringRef(), converter)) {}
     FstMapperAutomaton(const FstAutomaton* fst, _ConstSemiringRef semiring, WeightConverterType converter = WeightConverterType())
-            : FsaAutomaton(), impl_(new Impl(fst, semiring, converter)) {}
+            : FsaAutomaton(),
+              impl_(new Impl(fst, semiring, converter)) {}
     virtual ~FstMapperAutomaton() {
         delete impl_;
     }
@@ -182,9 +186,11 @@ protected:
 
 public:
     FstMapperAutomaton(const FstAutomaton* fst, WeightConverterType converter = WeightConverterType())
-            : FsaAutomaton(), impl_(new Impl(fst, Fsa::ConstSemiringRef(), converter)) {}
+            : FsaAutomaton(),
+              impl_(new Impl(fst, Fsa::ConstSemiringRef(), converter)) {}
     FstMapperAutomaton(const FstAutomaton* fst, _ConstSemiringRef semiring, WeightConverterType converter = WeightConverterType())
-            : FsaAutomaton(), impl_(new Impl(fst, semiring, converter)) {}
+            : FsaAutomaton(),
+              impl_(new Impl(fst, semiring, converter)) {}
     virtual ~FstMapperAutomaton() {
         delete impl_;
     }
diff --git a/src/OpenFst/Output.hh b/src/OpenFst/Output.hh
index a97a61866..71c2852fc 100644
--- a/src/OpenFst/Output.hh
+++ b/src/OpenFst/Output.hh
@@ -90,7 +90,8 @@ private:
 
 public:
     ConvertFsaDfsState(_ConstAutomatonRef f, VectorFst* fst)
-            : Precursor(f), fst_(fst) {
+            : Precursor(f),
+              fst_(fst) {
         inputSymbolMap_.insert(std::make_pair(Fsa::Epsilon, Epsilon));
         outputSymbolMap_.insert(std::make_pair(Fsa::Epsilon, Epsilon));
     }
diff --git a/src/OpenFst/ReplaceFst.hh b/src/OpenFst/ReplaceFst.hh
index 6b9a78a97..bebd419b5 100644
--- a/src/OpenFst/ReplaceFst.hh
+++ b/src/OpenFst/ReplaceFst.hh
@@ -36,10 +36,14 @@ struct CompactReplaceStateTuple {
     StateId                  nextState_;
 
     CompactReplaceStateTuple(PartId id, StateId state, StateId nextState)
-            : fstId_(id), state_(state), nextState_(nextState) {}
+            : fstId_(id),
+              state_(state),
+              nextState_(nextState) {}
 
     CompactReplaceStateTuple()
-            : fstId_(0), state_(FstLib::kNoStateId), nextState_(FstLib::kNoStateId) {}
+            : fstId_(0),
+              state_(FstLib::kNoStateId),
+              nextState_(FstLib::kNoStateId) {}
 
     bool operator==(const CompactReplaceStateTuple& other) const {
         return fstId_ == other.fstId_ && state_ == other.state_ &&
@@ -542,7 +546,8 @@ public:
             : CacheStateIterator<OpenFst::CompactReplaceFst<A>>(fst, const_cast<OpenFst::CompactReplaceFstImpl<A>*>(fst.GetImpl())) {}
 
 private:
-    DISALLOW_COPY_AND_ASSIGN(StateIterator);
+    StateIterator(StateIterator&) = delete;
+    void operator=(StateIterator) = delete;
 };
 
 template<class A>
@@ -556,7 +561,15 @@ public:
     typedef OpenFst::CompactReplaceFstImpl<A>               Impl;
 
     ArcIterator(const OpenFst::CompactReplaceFst<A>& fst, StateId s)
-            : fst_(fst), arcs_(0), hasFinal_(false), state_(s), pos_(0), flags_(0), dataFlags_(0), finalFlags_(0), nArcs_(0) {
+            : fst_(fst),
+              arcs_(0),
+              hasFinal_(false),
+              state_(s),
+              pos_(0),
+              flags_(0),
+              dataFlags_(0),
+              finalFlags_(0),
+              nArcs_(0) {
         cacheData_.ref_count = 0;
         localData_.ref_count = 0;
         if (fst_.GetImpl()->HasArcs(state_)) {
@@ -689,7 +702,8 @@ private:
     mutable uint32                       dataFlags_, finalFlags_;
     ssize_t                              nArcs_;  // Number of arcs at state_
     Tuple                                tuple_;
-    DISALLOW_COPY_AND_ASSIGN(ArcIterator);
+    ArcIterator(ArcIterator&)   = delete;
+    void operator=(ArcIterator) = delete;
 };
 
 }  // namespace fst
diff --git a/src/Python/AllophoneStateFsaBuilder.cc b/src/Python/AllophoneStateFsaBuilder.cc
index b8a487169..1a92b3f65 100644
--- a/src/Python/AllophoneStateFsaBuilder.cc
+++ b/src/Python/AllophoneStateFsaBuilder.cc
@@ -17,7 +17,8 @@ namespace py = pybind11;
 
 struct BuildSegmentToOrthMapVisitor : public Bliss::CorpusVisitor {
     BuildSegmentToOrthMapVisitor()
-            : Bliss::CorpusVisitor(), map_(new Core::StringHashMap<std::string>()) {}
+            : Bliss::CorpusVisitor(),
+              map_(new Core::StringHashMap<std::string>()) {}
 
     virtual void visitSpeechSegment(Bliss::SpeechSegment* s) {
         (*map_)[s->fullName()] = s->orth();
diff --git a/src/Python/Init.cc b/src/Python/Init.cc
index 9b087e786..d56c478ee 100644
--- a/src/Python/Init.cc
+++ b/src/Python/Init.cc
@@ -13,8 +13,12 @@
  *  limitations under the License.
  */
 #include "Init.hh"
-#include <Core/Debug.hh>
+
 #include <cstdlib>
+#include <signal.h>
+
+#include <Core/Debug.hh>
+
 #include "Numpy.hh"
 #include "Utilities.hh"
 
@@ -85,12 +89,23 @@ void Initializer::init() {
     else
         Core::printWarning("Python::Initializer: no Application instance found, cannot load parameters");
 
+    // Pythons signal module will overwrite signal handlers that are set to SIG_DFL (default).
+    // The signal module is imported when we init numpy, but to be on the safe side we already save
+    // signal handlers here.
+    std::vector<struct sigaction> handlers(_NSIG);
+    for (int i = 0; i < _NSIG; i++) {
+        sigaction(i, nullptr, &handlers[i]);
+    }
+
     // Init CPython if not yet initialized. Safe to be called multiple times.
     Py_InitializeEx(0 /* don't install signal handlers */);
 
+#if PY_VERSION_HEX < 0x03090000
     // Start the CPython interpreter's thread-awareness, if not yet done.
     // Safe to be called multiple times.
+    // This function was deprecated in python 3.9
     PyEval_InitThreads();
+#endif
 
     // Note that we expect that we have the CPython GIL acquired
     // at this moment. If we initialized CPython above, this is the case.
@@ -102,13 +117,20 @@ void Initializer::init() {
 
     // See comment in AtExitUninitHandler().
     std::atexit(AtExitUninitHandler);
-    if (Core::Application::us())
+    if (Core::Application::us()) {
         Core::Application::us()->atexit(AtExitUninitHandler);
+    }
 
-    // Acquire the GIL to do some further initing.
-    ScopedGIL gil;
+    {
+        // Acquire the GIL to do some further initing.
+        ScopedGIL gil;
+        initNumpy();
+    }
 
-    initNumpy();
+    // restore handlers
+    for (int i = 0; i < _NSIG; i++) {
+        sigaction(i, &handlers[i], nullptr);
+    }
 }
 
 void Initializer::uninit() {
diff --git a/src/Search/AdvancedTreeSearch/AcousticLookAhead.cc b/src/Search/AdvancedTreeSearch/AcousticLookAhead.cc
index bd6aa6633..73b6929c1 100644
--- a/src/Search/AdvancedTreeSearch/AcousticLookAhead.cc
+++ b/src/Search/AdvancedTreeSearch/AcousticLookAhead.cc
@@ -129,7 +129,9 @@ std::string AcousticLookAhead::getMixtureSetFilename(const Core::Configuration&
 }
 
 AcousticLookAhead::AcousticLookAhead(const Core::Configuration& _config, u32 checksum, bool load)
-        : loaded_(false), checksum_(checksum), config_(select(_config)) {
+        : loaded_(false),
+          checksum_(checksum),
+          config_(select(_config)) {
     minCacheKey_ = nextCacheKey_ = 1;
 
     perDepthFactor_      = paramAcousticLookaheadPerDepthFactor(config_);
@@ -686,7 +688,11 @@ struct Stats {
     size_t cached, computed;
     size_t cacheSizeBefore, cacheSize, cacheSizeSamples;
     Stats()
-            : cached(0), computed(0), cacheSizeBefore(0), cacheSize(0), cacheSizeSamples(0) {
+            : cached(0),
+              computed(0),
+              cacheSizeBefore(0),
+              cacheSize(0),
+              cacheSizeSamples(0) {
     }
     ~Stats() {
         if (cached || computed) {
diff --git a/src/Search/AdvancedTreeSearch/AcousticLookAhead.hh b/src/Search/AdvancedTreeSearch/AcousticLookAhead.hh
index bc021b6c3..d08f8fc8a 100644
--- a/src/Search/AdvancedTreeSearch/AcousticLookAhead.hh
+++ b/src/Search/AdvancedTreeSearch/AcousticLookAhead.hh
@@ -228,16 +228,21 @@ private:
         int                        simpleCacheTimeframe_;
 
         CacheForTimeframe(int maxDepth)
-                : maxDepth_(maxDepth), simpleCacheTimeframe_(-1) {
+                : maxDepth_(maxDepth),
+                  simpleCacheTimeframe_(-1) {
             clear();
         }
 
         struct CacheValue {
             CacheValue()
-                    : timeframe(-1), cacheKey(0), score(0.0f) {
+                    : timeframe(-1),
+                      cacheKey(0),
+                      score(0.0f) {
             }
             CacheValue(int t, u32 c, Score s)
-                    : timeframe(t), cacheKey(c), score(s) {
+                    : timeframe(t),
+                      cacheKey(c),
+                      score(s) {
             }
             int   timeframe;
             u32   cacheKey;
diff --git a/src/Search/AdvancedTreeSearch/AdvancedTreeSearch.cc b/src/Search/AdvancedTreeSearch/AdvancedTreeSearch.cc
index 246ef90ea..f9d5dde5d 100644
--- a/src/Search/AdvancedTreeSearch/AdvancedTreeSearch.cc
+++ b/src/Search/AdvancedTreeSearch/AdvancedTreeSearch.cc
@@ -34,11 +34,12 @@
 using namespace Search;
 using Core::Ref;
 using Core::tie;
+using Core::TsRef;
 
 // ===========================================================================
 // Bookkeeping
 
-void AdvancedTreeSearchManager::traceback(Ref<Trace> end, Traceback& result, Ref<Trace> boundary) const {
+void AdvancedTreeSearchManager::traceback(TsRef<Trace> end, Traceback& result, TsRef<Trace> boundary) const {
     result.clear();
     for (; end && end != boundary; end = end->predecessor) {
         result.push_back(*end);
@@ -136,6 +137,10 @@ AdvancedTreeSearchManager::AdvancedTreeSearchManager(
     }
 }
 
+void AdvancedTreeSearchManager::reconfigure(const Core::Configuration& config) {
+    ss_->reconfigure(config);
+}
+
 void AdvancedTreeSearchManager::setGrammar(Fsa::ConstAutomatonRef g) {
     log("Set grammar");
 #ifdef MODULE_LM_FSA
@@ -171,17 +176,38 @@ bool AdvancedTreeSearchManager::setModelCombination(const Speech::ModelCombinati
     return true;
 }
 
-void AdvancedTreeSearchManager::restart() {
+bool AdvancedTreeSearchManager::setLanguageModel(Core::Ref<const Lm::ScaledLanguageModel> lm) {
+    auto t_start = std::chrono::system_clock::now();
+
+    lm_ = lm;
+    clearSearchSpace(true);
+    startSearchSpace();
+
+    auto t_end     = std::chrono::system_clock::now();
+    auto t_elapsed = std::chrono::duration_cast<std::chrono::duration<double>>(t_end - t_start).count();
+    log("AdvancedTreeSearchManager::setLanguageModel() finished in [s]: ") << t_elapsed;
+    return true;
+}
+
+void AdvancedTreeSearchManager::clearSearchSpace(bool rebuild, bool buildBatches) {
+    if (rebuild) {
+        delete ss_;
+        ss_ = nullptr;
+    }
     if (!ss_) {
         verify(lexicon_);  // setModelCombination must have been called already
-
         ss_ = new SearchSpace(config, acousticModel_, lexicon_, lm_, wpScale_);
-        ss_->initialize();
+        ss_->initialize(buildBatches);
         dynamicBeamPruningStrategy_ = createDynamicBeamPruningStrategy(select("dynamic-beam-pruning-strategy"), ss_->describePruning());
     }
     else {
         ss_->clear();
     }
+}
+
+void AdvancedTreeSearchManager::startSearchSpace() {
+    verify(ss_);
+    dynamicBeamPruningStrategy_ = createDynamicBeamPruningStrategy(select("dynamic-beam-pruning-strategy"), ss_->describePruning());
 
     time_                = 0;
     currentSegmentStart_ = 0;
@@ -197,6 +223,11 @@ void AdvancedTreeSearchManager::restart() {
     segmentStartTime_ = std::chrono::steady_clock::now();
 }
 
+void AdvancedTreeSearchManager::restart() {
+    clearSearchSpace();
+    startSearchSpace();
+}
+
 void AdvancedTreeSearchManager::setSegment(Bliss::SpeechSegment const* segment) {
     const_cast<Lm::ScaledLanguageModel*>(lm_.get())->setSegment(segment);
 }
@@ -269,6 +300,12 @@ void AdvancedTreeSearchManager::feed(const Mm::FeatureScorer::Scorer& emissionSc
         ss_->statistics->wordEndsAfterSecondPruning += 0;
     }
 
+    ss_->pruneActiveInstances();
+
+    // has to be done here as the request for partial results occurrs at the end of feed
+    ss_->maximumStableDelayPruning();
+    ss_->maximumMutableSuffixPruning();
+
     if (dynamicBeamPruningStrategy_) {
         auto feed_end       = std::chrono::steady_clock::now();
         f64  frame_duration = std::chrono::duration<f64, std::milli>(feed_end - feed_start).count();
@@ -281,28 +318,39 @@ void AdvancedTreeSearchManager::feed(const Mm::FeatureScorer::Scorer& emissionSc
     }
 }
 
-Ref<Trace> AdvancedTreeSearchManager::getCorrectedCommonPrefix() {
-    Core::Ref<Trace> t = ss_->getCommonPrefix();
-    if (t->pronunciation == epsilonLemmaPronunciation())
+TsRef<Trace> AdvancedTreeSearchManager::getCommonPrefix() const {
+    return ss_->getCommonPrefix();
+}
+
+TsRef<Trace> AdvancedTreeSearchManager::getCorrectedCommonPrefix() const {
+    Core::TsRef<Trace> t = ss_->getCommonPrefix();
+    if (t->pronunciation == epsilonLemmaPronunciation()) {
         t = t->predecessor;
+    }
     mergeEpsilonTraces(t);
+
     return t;
 }
 
 void AdvancedTreeSearchManager::getPartialSentence(Traceback& result) {
-    Ref<Trace> t = getCorrectedCommonPrefix();
+    TsRef<Trace> t = getCommonPrefix();
+
     traceback(t, result, lastPartialTrace_);
     lastPartialTrace_ = t;
 }
 
 struct Correction {
     Correction(const Trace* _trace = 0, int _timeOffset = 0, Score _scoreOffset = 0, Lattice::WordBoundary::Transit _transit = Lattice::WordBoundary::Transit())
-            : trace(_trace), timeOffset(_timeOffset), scoreOffset(_scoreOffset), transit(_transit) {}
+            : trace(_trace),
+              timeOffset(_timeOffset),
+              scoreOffset(_scoreOffset),
+              transit(_transit) {}
     const Trace*                   trace;
     int                            timeOffset;
     Score                          scoreOffset;
     Lattice::WordBoundary::Transit transit;
-    bool                           operator==(const Correction& rhs) const {
+
+    bool operator==(const Correction& rhs) const {
         return trace == rhs.trace && timeOffset == rhs.timeOffset && scoreOffset == rhs.scoreOffset && transit == rhs.transit;
     }
 
@@ -325,7 +373,7 @@ struct Correction {
     };
 };
 
-Ref<Trace> AdvancedTreeSearchManager::sentenceEnd() const {
+TsRef<Trace> AdvancedTreeSearchManager::sentenceEnd() const {
     if (ss_->nWordEndHypotheses() == 0 && startTreesInterval_ > 1) {
         ss_->findWordEnds();
         // pruneWordEnds is required to transform _early_ word-end-hypotheses into real word-end-hypotheses
@@ -336,7 +384,6 @@ Ref<Trace> AdvancedTreeSearchManager::sentenceEnd() const {
     if (!sentenceEnd_) {
         sentenceEnd_ = ss_->getSentenceEnd(time_ + 1, shallCreateLattice_);
         if (!sentenceEnd_) {
-            warning("No active word end hypothesis at sentence end.");
             if (allowSentenceEndFallBack_) {
                 sentenceEnd_ = ss_->getSentenceEndFallBack(time_ + 1, shallCreateLattice_);
             }
@@ -351,7 +398,7 @@ Ref<Trace> AdvancedTreeSearchManager::sentenceEnd() const {
         }
 
         // Eventually log the path-trace
-        Ref<Trace> current = sentenceEnd_;
+        TsRef<Trace> current = sentenceEnd_;
         while (current) {
             current->pathTrace.log(*this, current->pronunciation != epsilonLemmaPronunciation() ? current->pronunciation : current->predecessor->pronunciation);
             current = current->predecessor;
@@ -363,15 +410,15 @@ Ref<Trace> AdvancedTreeSearchManager::sentenceEnd() const {
     return sentenceEnd_;
 }
 
-void AdvancedTreeSearchManager::mergeEpsilonTraces(Ref<Trace> trace) const {
+void AdvancedTreeSearchManager::mergeEpsilonTraces(TsRef<Trace> trace) const {
     verify(trace->pronunciation != epsilonLemmaPronunciation());
     if (!trace->predecessor)
         return;
     // Merge correcting epsilon trace entries into their corresponding predecessor trace entries,
     // to create a valid lattice.
-    typedef std::unordered_map<Correction, Ref<Trace>, Correction::Hash> CorrectionHash;
-    CorrectionHash                                                       corrections;
-    std::stack<Ref<Trace>>                                               stack;
+    typedef std::unordered_map<Correction, TsRef<Trace>, Correction::Hash> CorrectionHash;
+    CorrectionHash                                                         corrections;
+    std::stack<TsRef<Trace>>                                               stack;
     stack.push(trace);
 
     std::unordered_map<const Trace*, bool, Core::conversion<const Trace*, size_t>> visited;
@@ -380,8 +427,8 @@ void AdvancedTreeSearchManager::mergeEpsilonTraces(Ref<Trace> trace) const {
         stack.pop();
         if (visited.count(trace.get()))
             continue;
-        for (Ref<Trace> arcTrace = trace; arcTrace; arcTrace = arcTrace->sibling) {
-            Ref<Trace> temp = arcTrace;  // For security
+        for (TsRef<Trace> arcTrace = trace; arcTrace; arcTrace = arcTrace->sibling) {
+            TsRef<Trace> temp = arcTrace;  // For security
             verify(arcTrace);
             visited[arcTrace.get()] = true;
             verify(arcTrace->predecessor);  // We don't put traces without predecessor onto the stack
@@ -396,26 +443,26 @@ void AdvancedTreeSearchManager::mergeEpsilonTraces(Ref<Trace> trace) const {
                 verify(correction.timeOffset >= 0);
                 verify(corrections.find(correction) == corrections.end() || corrections[correction] == arcTrace);
                 corrections[correction] = arcTrace;
-                Ref<Trace> oldpre       = arcTrace->predecessor;
+                TsRef<Trace> oldpre     = arcTrace->predecessor;
                 *arcTrace               = *oldpre;
 
-                Core::Ref<Trace> currentTrace = arcTrace;
+                Core::TsRef<Trace> currentTrace = arcTrace;
                 while (currentTrace) {
                     verify(currentTrace->pronunciation != epsilonLemmaPronunciation());
                     currentTrace->score.acoustic += correction.scoreOffset;
                     currentTrace->time += correction.timeOffset;
                     currentTrace->transit = correction.transit;
                     if (currentTrace->sibling) {
-                        currentTrace->sibling = Core::Ref<Trace>(new Trace(*currentTrace->sibling));
+                        currentTrace->sibling = Core::TsRef<Trace>(new Trace(*currentTrace->sibling));
                         currentTrace          = currentTrace->sibling;
                     }
                     else {
-                        currentTrace = Core::Ref<Trace>();
+                        currentTrace = Core::TsRef<Trace>();
                     }
                 }
             }
             verify(arcTrace->pronunciation != epsilonLemmaPronunciation());
-            Ref<Trace> preTrace = arcTrace->predecessor;
+            TsRef<Trace> preTrace = arcTrace->predecessor;
             if (preTrace->predecessor) {
                 if (preTrace->pronunciation == epsilonLemmaPronunciation()) {
                     // Share another correction
@@ -443,8 +490,19 @@ void AdvancedTreeSearchManager::mergeEpsilonTraces(Ref<Trace> trace) const {
     }
 }
 
+void AdvancedTreeSearchManager::getCurrentBestTrace(Traceback& result) const {
+    TsRef<Trace> t;
+    t = ss_->getSentenceEnd(time_ + 1, shallCreateLattice_);
+
+    if (!t && allowSentenceEndFallBack_)
+        t = ss_->getSentenceEndFallBack(time_ + 1, shallCreateLattice_);
+    if (!t)
+        return;
+    traceback(t, result);
+}
+
 void AdvancedTreeSearchManager::getCurrentBestSentence(Traceback& result) const {
-    Ref<Trace> t = sentenceEnd();
+    TsRef<Trace> t = sentenceEnd();
     if (!t) {
         error("Cannot determine sentence hypothesis: No active word end hypothesis.");
         result.clear();
@@ -454,7 +512,7 @@ void AdvancedTreeSearchManager::getCurrentBestSentence(Traceback& result) const
 }
 
 void AdvancedTreeSearchManager::getCurrentBestSentencePartial(Traceback& result) const {
-    Ref<Trace> t = sentenceEnd();
+    TsRef<Trace> t = sentenceEnd();
     if (!t) {
         result.clear();
         return;
@@ -462,7 +520,7 @@ void AdvancedTreeSearchManager::getCurrentBestSentencePartial(Traceback& result)
     traceback(t, result, lastPartialTrace_);
 }
 
-Core::Ref<const LatticeAdaptor> AdvancedTreeSearchManager::buildLatticeForTrace(Ref<Trace> trace) const {
+Core::Ref<const LatticeAdaptor> AdvancedTreeSearchManager::buildLatticeForTrace(TsRef<Trace> trace) const {
     if (!trace) {
         warning("Cannot create word lattice.");
         // should not abort, as it can be fixed by incremental decoding
@@ -480,11 +538,11 @@ Core::Ref<const LatticeAdaptor> AdvancedTreeSearchManager::buildLatticeForTrace(
 
     Core::Ref<Lattice::StandardWordLattice> result(new Lattice::StandardWordLattice(lexicon_));
     Core::Ref<Lattice::WordBoundaries>      wordBoundaries(new Lattice::WordBoundaries);
-    Ref<Trace>                              initialTrace;
+    TsRef<Trace>                            initialTrace;
 
     std::unordered_map<const Trace*, Fsa::State*, Core::conversion<const Trace*, size_t>> state;
     state[trace.get()] = result->finalState();
-    std::stack<Ref<Trace>> stack;
+    std::stack<TsRef<Trace>> stack;
     stack.push(trace);
 
     Fsa::State *previousState, *currentState;
@@ -494,9 +552,9 @@ Core::Ref<const LatticeAdaptor> AdvancedTreeSearchManager::buildLatticeForTrace(
         currentState = state[trace.get()];
         wordBoundaries->set(currentState->id(), Lattice::WordBoundary(trace->time, trace->transit));
 
-        for (Ref<Trace> arcTrace = trace; arcTrace; arcTrace = arcTrace->sibling) {
+        for (TsRef<Trace> arcTrace = trace; arcTrace; arcTrace = arcTrace->sibling) {
             verify(arcTrace->pronunciation != epsilonLemmaPronunciation());
-            Ref<Trace> preTrace = arcTrace->predecessor;
+            TsRef<Trace> preTrace = arcTrace->predecessor;
             if (preTrace->predecessor) {
                 if (state.find(preTrace.get()) == state.end()) {
                     previousState = state[preTrace.get()] = result->newState();
@@ -531,11 +589,11 @@ Core::Ref<const LatticeAdaptor> AdvancedTreeSearchManager::getCurrentWordLattice
 Core::Ref<const LatticeAdaptor> AdvancedTreeSearchManager::getPartialWordLattice() {
     Core::Ref<const LatticeAdaptor> ret;
     if ((time_ % 100) == 0 && time_ - currentSegmentStart_ > (onlineSegmentationLength_ * 1.0 / onlineSegmentationTolerance_) * 100) {
-        Ref<Trace> t = getCorrectedCommonPrefix();
+        TsRef<Trace> t = getCorrectedCommonPrefix();
 
-        std::vector<std::pair<Ref<Trace>, Ref<Trace>>> gaps;
-        Ref<Trace>                                     current = t;
-        bool                                           isGap   = false;
+        std::vector<std::pair<TsRef<Trace>, TsRef<Trace>>> gaps;
+        TsRef<Trace>                                       current = t;
+        bool                                               isGap   = false;
         while (current) {
             if (current->pronunciation && !pronunciationHasEvaluationTokens(current->pronunciation)) {
                 if (isGap) {
@@ -553,9 +611,9 @@ Core::Ref<const LatticeAdaptor> AdvancedTreeSearchManager::getPartialWordLattice
         }
         log() << "online segmentation: found " << gaps.size() << " gaps between " << currentSegmentStart_ << " and " << time_;
 
-        f32                               bestGapLength = 0;
-        std::pair<Ref<Trace>, Ref<Trace>> bestGap;
-        for (std::vector<std::pair<Ref<Trace>, Ref<Trace>>>::const_iterator it = gaps.begin(); it != gaps.end(); ++it) {
+        f32                                   bestGapLength = 0;
+        std::pair<TsRef<Trace>, TsRef<Trace>> bestGap;
+        for (std::vector<std::pair<TsRef<Trace>, TsRef<Trace>>>::const_iterator it = gaps.begin(); it != gaps.end(); ++it) {
             f32 startTime = it->first->predecessor->time;
             f32 endTime   = it->second->time;
             f32 length    = endTime - startTime;
@@ -573,7 +631,7 @@ Core::Ref<const LatticeAdaptor> AdvancedTreeSearchManager::getPartialWordLattice
                   << " -> " << bestGap.second->time << " (" << bestGap.second->time - bestGap.first->predecessor->time << ")";
             ret = buildLatticeForTrace(onlineSegmentationIncludeGap_ ? bestGap.first : bestGap.first->predecessor);
 
-            Ref<Trace> newInitialTrace;
+            TsRef<Trace> newInitialTrace;
             if (bestGap.second != bestGap.first && onlineSegmentationIncludeGap_) {
                 newInitialTrace = bestGap.second->predecessor;
             }
diff --git a/src/Search/AdvancedTreeSearch/AdvancedTreeSearch.hh b/src/Search/AdvancedTreeSearch/AdvancedTreeSearch.hh
index 40868b958..25a00fd17 100644
--- a/src/Search/AdvancedTreeSearch/AdvancedTreeSearch.hh
+++ b/src/Search/AdvancedTreeSearch/AdvancedTreeSearch.hh
@@ -19,6 +19,7 @@
 
 #include <Core/Component.hh>
 #include <Core/ReferenceCounting.hh>
+#include <Core/ThreadSafeReference.hh>
 #include <Mm/Types.hh>
 #include <Search/Histogram.hh>
 #include <Search/LatticeAdaptor.hh>
@@ -79,29 +80,36 @@ private:
     mutable Core::XmlChannel statisticsChannel_;
 
 private:
-    mutable Core::Ref<Trace> sentenceEnd_;
+    mutable Core::TsRef<Trace> sentenceEnd_;
 
-    Core::Ref<Trace> lastPartialTrace_;
+    Core::TsRef<Trace> lastPartialTrace_;
 
-    Core::Ref<Trace> sentenceEnd() const;
+    Core::TsRef<Trace> sentenceEnd() const;
 
-    void mergeEpsilonTraces(Core::Ref<Trace> trace) const;
+    void mergeEpsilonTraces(Core::TsRef<Trace> trace) const;
 
     bool shouldComputeWordEnds();
 
-    Core::Ref<Trace> getCorrectedCommonPrefix();
+    Core::TsRef<Trace> getCommonPrefix() const;
+    Core::TsRef<Trace> getCorrectedCommonPrefix() const;
 
-    Core::Ref<const LatticeAdaptor> buildLatticeForTrace(Core::Ref<Trace> trace) const;
+    Core::Ref<const LatticeAdaptor> buildLatticeForTrace(Core::TsRef<Trace> trace) const;
 
-    void traceback(Core::Ref<Trace>, Traceback& result, Core::Ref<Trace> boundary = Core::Ref<Trace>()) const;
+    void traceback(Core::TsRef<Trace>, Traceback& result, Core::TsRef<Trace> boundary = Core::TsRef<Trace>()) const;
+
+    void clearSearchSpace(bool rebuild = false, bool buildBatches = true);
+
+    void startSearchSpace();
 
 public:
     AdvancedTreeSearchManager(const Core::Configuration&);
     virtual ~AdvancedTreeSearchManager();
     AdvancedTreeSearchManager(const AdvancedTreeSearchManager& rhs);
+    virtual void reconfigure(const Core::Configuration& config);
 
     virtual void                            setAllowHmmSkips(bool allow);
     virtual bool                            setModelCombination(const Speech::ModelCombination& modelCombination);
+    virtual bool                            setLanguageModel(Core::Ref<const Lm::ScaledLanguageModel>);
     virtual void                            setGrammar(Fsa::ConstAutomatonRef);
     virtual void                            restart();
     virtual void                            setSegment(Bliss::SpeechSegment const* segment);
@@ -109,6 +117,7 @@ public:
     virtual void                            getPartialSentence(Traceback& result);
     virtual void                            getCurrentBestSentencePartial(Traceback& result) const;
     virtual void                            getCurrentBestSentence(Traceback& result) const;
+    virtual void                            getCurrentBestTrace(Traceback& result) const;  // jiang
     virtual Core::Ref<const LatticeAdaptor> getCurrentWordLattice() const;
     virtual Core::Ref<const LatticeAdaptor> getPartialWordLattice();
     virtual void                            resetStatistics();
diff --git a/src/Search/AdvancedTreeSearch/ApproxLinearIntHash.hh b/src/Search/AdvancedTreeSearch/ApproxLinearIntHash.hh
index e44f160f5..e55ea07e7 100644
--- a/src/Search/AdvancedTreeSearch/ApproxLinearIntHash.hh
+++ b/src/Search/AdvancedTreeSearch/ApproxLinearIntHash.hh
@@ -31,7 +31,8 @@ template<class Key, Key invalidKey, bool useHashChain = false>
 class ApproxLinearIntHash {
     struct Value {
         Value()
-                : value(U16_MAX), mark(0) {
+                : value(U16_MAX),
+                  mark(0) {
         }
         u16 value;
         u16 mark;
@@ -42,7 +43,8 @@ class ApproxLinearIntHash {
 
 public:
     ApproxLinearIntHash()
-            : size_(0), mask_(0) {
+            : size_(0),
+              mask_(0) {
     }
 
     u32 hashSize() const {
diff --git a/src/Search/AdvancedTreeSearch/DynamicBeamPruningStrategy.hh b/src/Search/AdvancedTreeSearch/DynamicBeamPruningStrategy.hh
index cc50b6deb..7d9887e75 100644
--- a/src/Search/AdvancedTreeSearch/DynamicBeamPruningStrategy.hh
+++ b/src/Search/AdvancedTreeSearch/DynamicBeamPruningStrategy.hh
@@ -73,7 +73,8 @@ private:
 // iniline implementations
 
 inline DynamicBeamPruningStrategy::DynamicBeamPruningStrategy(Core::Configuration const& config, SearchAlgorithm::PruningRef initialPruning)
-        : Precursor(config), initialPruning_(initialPruning) {
+        : Precursor(config),
+          initialPruning_(initialPruning) {
 }
 
 inline SearchAlgorithm::PruningRef DynamicBeamPruningStrategy::startNewSegment() {
diff --git a/src/Search/AdvancedTreeSearch/Helpers.hh b/src/Search/AdvancedTreeSearch/Helpers.hh
index f3b96e0bd..5664cdb69 100644
--- a/src/Search/AdvancedTreeSearch/Helpers.hh
+++ b/src/Search/AdvancedTreeSearch/Helpers.hh
@@ -205,7 +205,9 @@ template<class T>
 class AsymmetricIntersectionIterator {
 public:
     AsymmetricIntersectionIterator(const std::vector<T>& array1, const std::vector<T>& array2)
-            : a_(array1.size() < array2.size() ? array1 : array2), b_(array1.size() < array2.size() ? array2 : array1), ready_(false) {
+            : a_(array1.size() < array2.size() ? array1 : array2),
+              b_(array1.size() < array2.size() ? array2 : array1),
+              ready_(false) {
         stack_.reserve(50);
         assert(a_.size() <= b_.size());
 
diff --git a/src/Search/AdvancedTreeSearch/PathRecombination.cc b/src/Search/AdvancedTreeSearch/PathRecombination.cc
index 6acde5982..053fb12c9 100644
--- a/src/Search/AdvancedTreeSearch/PathRecombination.cc
+++ b/src/Search/AdvancedTreeSearch/PathRecombination.cc
@@ -69,7 +69,12 @@ void PathRecombination::logStatistics() {
 }
 
 PathRecombination::PathRecombination(const Search::PersistentStateTree& network, const Core::Configuration& config)
-        : network_(network), distancesPtr_(0), offsetAndDistanceStateForStatePtr_(0), currentVisits_(0), nVisits_(0), totalVisits_(0) {
+        : network_(network),
+          distancesPtr_(0),
+          offsetAndDistanceStateForStatePtr_(0),
+          currentVisits_(0),
+          nVisits_(0),
+          totalVisits_(0) {
     convergenceFactor_          = paramConvergenceFactor(config);
     delta_                      = paramDelta(config);
     cache_                      = paramCache(config);
@@ -273,7 +278,9 @@ struct VisitManager {
 
 struct SuccessorPlan {
     SuccessorPlan(StateId _state = 0, u32 _distance = 0, bool _direct = false)
-            : state(_state), distance(_distance), direct(_direct) {
+            : state(_state),
+              distance(_distance),
+              direct(_direct) {
     }
     StateId state;
     u32     distance;
diff --git a/src/Search/AdvancedTreeSearch/PathRecombination.hh b/src/Search/AdvancedTreeSearch/PathRecombination.hh
index ed0848255..11f577682 100644
--- a/src/Search/AdvancedTreeSearch/PathRecombination.hh
+++ b/src/Search/AdvancedTreeSearch/PathRecombination.hh
@@ -81,7 +81,8 @@ private:
 
     struct RecombinationState {
         RecombinationState()
-                : state(0), loop(false) {
+                : state(0),
+                  loop(false) {
         }
         // The network-state this recombination-state is assigned to
         StateId state;
@@ -89,7 +90,9 @@ private:
 
         struct Successor {
             Successor()
-                    : shortestDistance(Core::Type<u32>::max), longestDistance(0), state(0) {
+                    : shortestDistance(Core::Type<u32>::max),
+                      longestDistance(0),
+                      state(0) {
             }
             u32     shortestDistance;
             u32     longestDistance;
diff --git a/src/Search/AdvancedTreeSearch/PathRecombinationApproximation.cc b/src/Search/AdvancedTreeSearch/PathRecombinationApproximation.cc
index 330c922b7..1701eb2b1 100644
--- a/src/Search/AdvancedTreeSearch/PathRecombinationApproximation.cc
+++ b/src/Search/AdvancedTreeSearch/PathRecombinationApproximation.cc
@@ -24,7 +24,8 @@ const int maxIterations      = 3;
 const int switchRandomModulo = 10;
 
 PathRecombinationApproximation::PathRecombinationApproximation(const PersistentStateTree& network, const Core::Configuration& config, const PathRecombination& pathrec)
-        : network_(network), pathrec_(pathrec) {
+        : network_(network),
+          pathrec_(pathrec) {
     cliqueSizes_ = paramCliqueSizes(config);
     initialize();
 }
diff --git a/src/Search/AdvancedTreeSearch/Pruning.hh b/src/Search/AdvancedTreeSearch/Pruning.hh
index dd8a6417b..e39db6874 100644
--- a/src/Search/AdvancedTreeSearch/Pruning.hh
+++ b/src/Search/AdvancedTreeSearch/Pruning.hh
@@ -127,6 +127,71 @@ struct SearchSpace::PerInstanceAcousticPruning {
     InstanceKey  prevInstance_;
 };
 
+struct SearchSpace::ActiveInstanceLimitPruning {
+    struct InstanceStats {
+        InstanceKey key;
+        Score       score;
+        bool        prune;
+    };
+
+    ActiveInstanceLimitPruning(unsigned numInstances)
+            : numInstances_(numInstances),
+              instanceStats_(),
+              instanceMap_(),
+              curInstance_(0ul) {
+    }
+
+    ~ActiveInstanceLimitPruning() = default;
+
+    void startInstance(InstanceKey const& key) {
+        curInstance_ = instanceStats_.size();
+        auto iter    = instanceMap_.find(key);
+        if (iter != instanceMap_.end()) {
+            curInstance_ = iter->second;
+        }
+        else {
+            instanceMap_[key] = instanceStats_.size();
+            curInstance_      = instanceStats_.size();
+            instanceStats_.emplace_back(InstanceStats{key, Core::Type<Score>::max, false});
+        }
+    }
+
+    void prepare(const StateHypothesis& hyp) {
+        if (hyp.prospect < instanceStats_[curInstance_].score) {
+            instanceStats_[curInstance_].score = hyp.prospect;
+        }
+    }
+
+    void calculatePruning() {
+        std::sort(instanceStats_.begin(), instanceStats_.end(), [](InstanceStats const& a, InstanceStats const& b) { return a.score < b.score; });
+
+        for (size_t i = numInstances_; i < instanceStats_.size(); i++) {
+            instanceStats_[i].prune = true;
+        }
+
+        for (size_t i = 0ul; i < instanceStats_.size(); i++) {
+            instanceMap_[instanceStats_[i].key] = i;
+        }
+    }
+
+    bool prune(const StateHypothesis& hyp) const {
+        return instanceStats_[curInstance_].prune;
+    }
+
+    bool prune(const TraceManager&, const StateHypothesis& hyp) const {
+        return prune(hyp);
+    }
+
+    enum {
+        CanPrune = 1
+    };
+
+    unsigned                                                   numInstances_;
+    std::vector<InstanceStats>                                 instanceStats_;
+    std::unordered_map<InstanceKey, size_t, InstanceKey::Hash> instanceMap_;
+    size_t                                                     curInstance_;
+};
+
 struct SearchSpace::RecordMinimum {
     RecordMinimum(SearchSpace& ss)
             : ss_(ss),
@@ -227,9 +292,9 @@ struct SearchSpace::BestTracePruning {
     std::unordered_set<TraceId> live_traces;
     std::unordered_set<TraceId> dead_traces;
 
-    BestTracePruning(Core::Ref<Trace> root)
+    BestTracePruning(Core::TsRef<Trace> root)
             : root_ptr(reinterpret_cast<uintptr_t>(root.get())) {
-        root_ptr = root->pruningMark;
+        root->pruningMark = root_ptr;
     }
 
     inline void startInstance(InstanceKey const& key) {}
diff --git a/src/Search/AdvancedTreeSearch/SearchNetworkTransformation.hh b/src/Search/AdvancedTreeSearch/SearchNetworkTransformation.hh
index 91b763197..48cadec2f 100644
--- a/src/Search/AdvancedTreeSearch/SearchNetworkTransformation.hh
+++ b/src/Search/AdvancedTreeSearch/SearchNetworkTransformation.hh
@@ -42,7 +42,8 @@ public:
     }
 
     StateWithSuccessors(const Search::StateTree::StateDesc& _desc, const std::set<Search::StateId>& _successors)
-            : desc_(_desc), successors_(_successors) {
+            : desc_(_desc),
+              successors_(_successors) {
         buildHash();
     }
 
diff --git a/src/Search/AdvancedTreeSearch/SearchSpace.cc b/src/Search/AdvancedTreeSearch/SearchSpace.cc
index 6e2435ec8..6c18f1420 100644
--- a/src/Search/AdvancedTreeSearch/SearchSpace.cc
+++ b/src/Search/AdvancedTreeSearch/SearchSpace.cc
@@ -83,6 +83,12 @@ const Core::ParameterInt paramWordEndPruningLimit(
    20000 is a good default value, reduce it more if the runtime becomes too slow for some segments.",
         Core::Type<s32>::max, 1);
 
+const Core::ParameterInt paramActiveInstanceLimit(
+        "active-instance-limit",
+        "maximum number of active instances, enforced by sorting instances by their best score, \
+   helps with noisy parts where a lot of new instances are created.",
+        Core::Type<s32>::max, 1);
+
 const Core::ParameterFloat paramLmPruning(
         "lm-pruning",
         "DEPRECATED: Use word-end-pruning instead (difference: word-end-pruning is relative to the lm-scale, while this value is absolute).",
@@ -237,6 +243,17 @@ const Core::ParameterInt paramMaximumMutableSuffixPruningInterval(
         "perform mutable-suffix-pruning every n frames",
         0, 0);
 
+const Core::ParameterInt paramMaximumStableDelay(
+        "maximum-stable-delay",
+        "Introduce a cutoff point at `current-time` - `delay`. Every hypothesis that disagrees with the current best anywhere before the cutoff gets pruned. This way words in the traceback become stable after at most `delay` frames."
+        "maximum number of frames before results are required to be stable",
+        Core::Type<int>::max, 0);
+
+const Core::ParameterInt paramMaximumStableDelayPruningInterval(
+        "maximum-stable-delay-pruning-interval",
+        "perform stable-delay-pruning every n frames",
+        0, 0);
+
 const Core::ParameterBool paramExtendedStatistics(
         "expensive-statistics",
         "add additional performance-wise expensive statistics",
@@ -361,12 +378,15 @@ template<class From, class To>
 void truncate(const std::vector<From>& source, std::vector<To>& to) {
     to.clear();
     for (typename std::vector<From>::const_iterator it = source.begin(); it != source.end(); ++it) {
-        if (*it < Core::Type<To>::min)
+        if (*it < Core::Type<To>::min) {
             to.push_back(Core::Type<To>::min);
-        else if (*it > Core::Type<To>::max)
+        }
+        else if (*it > Core::Type<To>::max) {
             to.push_back(Core::Type<To>::max);
-        else
+        }
+        else {
             to.push_back(*it);
+        }
     }
 }
 }  // namespace
@@ -378,7 +398,9 @@ StaticSearchAutomaton::StaticSearchAutomaton(Core::Configuration config, Core::R
           network(config, acousticModel, lexicon, std::bind(&Module_::createTreeBuilder, &Search::Module::instance(), std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5)),
           prefixFilter(nullptr),
           acousticModel_(acousticModel),
-          lexicon_(lexicon) {}
+          lexicon_(lexicon) {
+    dependencies_.add("network", network.getDependencies());
+}
 
 StaticSearchAutomaton::~StaticSearchAutomaton() {
     if (prefixFilter) {
@@ -386,11 +408,14 @@ StaticSearchAutomaton::~StaticSearchAutomaton() {
     }
 }
 
-void StaticSearchAutomaton::buildNetwork() {
+bool StaticSearchAutomaton::buildNetwork() {
     /// @todo Track the TreeBuilder configuration in transformation if minimizedTree
-    int transformation = minimized ? 32 : 0;
+    int  transformation = minimized ? 32 : 0;
+    bool build          = false;
     if (!network.read(transformation)) {
         log() << "persistent network image could not be loaded, building it";
+        // this is a building process, read tree-builder image for dynamic update later
+        build = true;
 
         std::unique_ptr<AbstractTreeBuilder> builder = Search::Module::instance().createTreeBuilder(config, *lexicon_, *acousticModel_, network);
         if (not builder or not minimized) {
@@ -409,6 +434,7 @@ void StaticSearchAutomaton::buildNetwork() {
             log() << "writing network image failed";
         }
     }
+    return build;
 }
 
 void StaticSearchAutomaton::buildDepths(bool onlyFromRoot) {
@@ -438,8 +464,9 @@ void StaticSearchAutomaton::buildDepths(bool onlyFromRoot) {
                 log() << "offsetting depths by " << depth;
                 offsetted = true;
                 for (u32 a = 1; a < stateDepths.size(); ++a)
-                    if (stateDepths[a] != Core::Type<int>::min)
+                    if (stateDepths[a] != Core::Type<int>::min) {
                         stateDepths[a] += -depth;
+                    }
                 depth = 0;
             }
             else if (depth == Core::Type<int>::max) {
@@ -636,16 +663,19 @@ void StaticSearchAutomaton::buildBatches() {
 
         for (HMMStateNetwork::SuccessorIterator successorIt = network.structure.successors(state); successorIt; ++successorIt) {
             if (successorIt.isLabel()) {
-                if (successorIt.isLastBatch())
+                if (successorIt.isLastBatch()) {
                     ++continuousLabelLists;
-                else
+                }
+                else {
                     ++discontinuousLabelLists;
+                }
                 continue;
             }
 
             for (HMMStateNetwork::SuccessorIterator successorIt2 = network.structure.successors(*successorIt); successorIt2; ++successorIt2) {
-                if (successorIt2.isLabel())
+                if (successorIt2.isLabel()) {
                     continue;
+                }
 
                 int t = *successorIt2;
                 if (firstSecondOrderSuccessor == -1) {
@@ -688,22 +718,27 @@ void StaticSearchAutomaton::buildBatches() {
             }
             else {
                 ++multiExits;
-                if (!labelsContinuous)
+                if (!labelsContinuous) {
                     ++nonContinuousExits;
+                }
             }
         }
 
-        if (!hadLabels)
+        if (!hadLabels) {
             singleLabels.push_back(-1);
-        else if (singleLabel != Core::Type<u32>::max)
+        }
+        else if (singleLabel != Core::Type<u32>::max) {
             singleLabels.push_back(singleLabel);
-        else if (labelsContinuous)
+        }
+        else if (labelsContinuous) {
             singleLabels.push_back(-2);
+        }
         else {
             singleLabels.push_back(-(3 + slowLabelBatches.size()));
             for (HMMStateNetwork::SuccessorIterator successorIt = network.structure.successors(state); successorIt; ++successorIt)
-                if (successorIt.isLabel())
+                if (successorIt.isLabel()) {
                     slowLabelBatches.push_back(successorIt.label());
+                }
             slowLabelBatches.push_back(-1);
         }
 
@@ -719,11 +754,13 @@ void StaticSearchAutomaton::buildBatches() {
     log() << "continuous label lists: " << continuousLabelLists << " discontinuous label lists: " << discontinuousLabelLists;
     log() << "single-label lists: " << singleExits << " multi-label lists: " << multiExits;
     log() << "irregular exit-list items: " << slowLabelBatches.size();
-    if (symmetrizedSecondOrderBatches)
+    if (symmetrizedSecondOrderBatches) {
         log() << "symmetrized states (skips forbidden): " << symmetrizedSecondOrderBatches;
+    }
 
-    if (!paramDumpDotGraph(config).empty())
+    if (!paramDumpDotGraph(config).empty()) {
         network.dumpDotGraph(paramDumpDotGraph(config), stateDepths);
+    }
 
     // Print some useful statistics about pushed and unpushed labels
     verify(network.coarticulatedRootStates.empty() || !network.unpushedCoarticulatedRootStates.empty());
@@ -754,6 +791,13 @@ void StaticSearchAutomaton::buildBatches() {
     network.removeOutputs();
 }
 
+void StaticSearchAutomaton::clearBatches() {
+    secondOrderEdgeSuccessorBatches.clear();
+    singleLabels.clear();
+    quickLabelBatches.clear();
+    slowLabelBatches.clear();
+}
+
 // ------------------------------- Search Space --------------------------------
 
 SearchSpace::SearchSpace(const Core::Configuration&               config,
@@ -787,6 +831,8 @@ SearchSpace::SearchSpace(const Core::Configuration&               config,
           onTheFlyRescoringMaxHistories_(paramOnTheFlyRescoringMaxHistories(config)),
           maximumMutableSuffixLength_(paramMaximumMutableSuffixLength(config)),
           maximumMutableSuffixPruningInterval_(paramMaximumMutableSuffixPruningInterval(config)),
+          maximumStableDelay_(paramMaximumStableDelay(config)),
+          maximumStableDelayPruningInterval_(paramMaximumStableDelayPruningInterval(config)),
           acousticPruning_(0),
           acousticPruningLimit_(0),
           wordEndPruning_(0),
@@ -841,8 +887,9 @@ SearchSpace::SearchSpace(const Core::Configuration&               config,
         log() << "generating mesh-lattice with " << WordEndHypothesis::meshHistoryPhones << " history-phones";
     }
 
-    if (fullLookAheadDominanceMinimum_)
+    if (fullLookAheadDominanceMinimum_) {
         log() << "activating context-dependent LM look-ahead only for instances with dominance above " << fullLookAheadDominanceMinimum_;
+    }
 
     log() << "HMM length of a phoneme: " << automaton_->hmmLength;
 
@@ -871,15 +918,36 @@ SearchSpace::SearchSpace(const Core::Configuration&               config,
         recombinationLm_ = lm_;
     }
 
-    if (sparseLookahead_ && !dynamic_cast<const Lm::BackingOffLm*>(lookaheadLm_->unscaled().get())) {
-        warning() << "Not using sparse LM lookahead, because the LM is not a backing-off LM! Memory- and runtime efficiency will be worse.";
+    if (sparseLookahead_ && !lookaheadLm_->isSparse(Lm::History())) {
+        // currently: BackingOffLM, FsaLM or CombineLM with all sparse sub LMs
+        warning() << "Not using sparse LM lookahead, because the LM can not be sparse ! Memory- and runtime efficiency will be worse.";
         sparseLookahead_ = false;
     }
+    if (sparseLookahead_) {
+        log() << "using sparse LM lookahead";
+    }
+
+    if (earlyBackoff_ and not dynamic_cast<const Lm::BackingOffLm*>(lookaheadLm_->unscaled().get())) {
+        warning() << "Cannot use early backoff without an BackingOffLm";
+        earlyBackoff_ = false;
+    }
 
     statesOnDepth_.initialize(100, 100);
     statesOnInvertedDepth_.initialize(100, 100);
 }
 
+void SearchSpace::reconfigure(const Core::Configuration& config) {
+    maximumMutableSuffixLength_          = paramMaximumMutableSuffixLength(config);
+    maximumMutableSuffixPruningInterval_ = paramMaximumMutableSuffixPruningInterval(config);
+    maximumStableDelay_                  = paramMaximumStableDelay(config);
+    maximumStableDelayPruningInterval_   = paramMaximumStableDelayPruningInterval(config);
+
+    log("reconfigure maximum-mutable-suffix-length: ") << maximumMutableSuffixLength_;
+    log("reconfigure maximum-mutable-suffix-pruning-interval: ") << maximumMutableSuffixPruningInterval_;
+    log("reconfigure maximum-stable-delay: ") << maximumStableDelay_;
+    log("reconfigure maximum-stable-delay-pruning-interval: ") << maximumStableDelayPruningInterval_;
+}
+
 void SearchSpace::setAllowHmmSkips(bool allow) {
     allowSkips_ = allow;
 }
@@ -920,7 +988,7 @@ void SearchSpace::initializePruning() {
             log() << "ignoring configured acoustic-pruning because beam-pruning was set too. the configured acoustic-pruning value WOULD correspond to beam-pruning=" << (acousticPruning_ / lm_->scale());
         }
 
-        acousticPruning_ = beamPruning * lm_->scale();
+        acousticPruning_ = beamPruning * (lm_->scale() > 0.0 ? lm_->scale() : 1.0);
         log() << "set acoustic-pruning to " << acousticPruning_ << " from beam-pruning " << beamPruning << " with lm-scale " << lm_->scale();
     }
 
@@ -930,42 +998,52 @@ void SearchSpace::initializePruning() {
 
     wordEndPruning_ = paramWordEndPruning(config);
     if (wordEndPruning_ != Core::Type<f32>::max) {
-        if (wordEndPruning_ > 1.0)
+        if (wordEndPruning_ > 1.0 and lm_->scale() > 0.0) {
             wordEndPruning_ *= lm_->scale();
-        if (paramLmPruning(config) != Core::Type<f32>::max)
+        }
+        if (paramLmPruning(config) != Core::Type<f32>::max) {
             warning() << "lm-pruning and word-end-pruning were set at the same time. using word-end-pruning, because lm-pruning is DEPRECATED";
+        }
     }
     else {
         wordEndPruning_ = paramLmPruning(config);
     }
 
-    if (wordEndPruning_ <= 1.0)
+    if (wordEndPruning_ <= 1.0) {
         wordEndPruning_ *= acousticPruning_;
+    }
 
     wordEndPruningLimit_ = std::min(paramWordEndPruningLimit(config), paramLmPruningLimit(config));
 
     log() << "using word end pruning " << wordEndPruning_ << " limit " << wordEndPruningLimit_;
 
+    activeInstanceLimit_ = paramActiveInstanceLimit(config);
+    log() << "limiting number of active instances to: " << activeInstanceLimit_;
+
     lmStatePruning_ = lmStatePruning(config);
     if (lmStatePruning_ != Core::Type<f32>::max) {
-        if (lmStatePruning_ > 1.0)
+        if (lmStatePruning_ > 1.0) {
             lmStatePruning_ *= lm_->scale();
-        else
+        }
+        else {
             lmStatePruning_ *= wordEndPruning_;
+        }
         log() << "using lm state pruning " << lmStatePruning_;
     }
 
     wordEndPhonemePruningThreshold_ = paramWordEndPhonemePruningThreshold(config);
     if (wordEndPhonemePruningThreshold_ != Core::Type<Score>::max) {
-        if (wordEndPhonemePruningThreshold_ > 1.0)
+        if (wordEndPhonemePruningThreshold_ > 1.0) {
             wordEndPhonemePruningThreshold_ *= lm_->scale();
-        else
+        }
+        else {
             wordEndPhonemePruningThreshold_ *= wordEndPruning_;
+        }
         log() << "using word end phoneme pruning " << wordEndPhonemePruningThreshold_;
     }
 }
 
-void SearchSpace::initialize() {
+void SearchSpace::initialize(bool buildBatches) {
     PerformanceCounter perf(*statistics, "initialize");
 
     getTransitionModels();
@@ -973,8 +1051,8 @@ void SearchSpace::initialize() {
 
     StaticSearchAutomaton* automaton = const_cast<StaticSearchAutomaton*>(automaton_);
 
-    PersistentStateTree& net = automaton->network;
-    automaton->buildNetwork();
+    PersistentStateTree& net   = automaton->network;
+    bool                 build = automaton->buildNetwork();
 
     automaton->buildDepths();
     log() << "depth of root-state: " << automaton->stateDepths[net.rootState] << " hmm-length " << automaton->hmmLength;
@@ -998,14 +1076,17 @@ void SearchSpace::initialize() {
     }
 
     acousticLookAhead_ = new AdvancedTreeSearch::AcousticLookAhead(config, net.getChecksum());
-    if (acousticLookAhead_->isEnabled() && !acousticLookAhead_->loaded())
+    if (acousticLookAhead_->isEnabled() && !acousticLookAhead_->loaded()) {
         acousticLookAhead_->initializeModelsFromNetwork(net);
+    }
 
     initializeLanguageModel();
 
     // Initialization of the search network cuts away the outputs from the network
     // and puts them into the outputBatches_ data structures instead.
-    automaton->buildBatches();
+    if (buildBatches) {
+        automaton->buildBatches();
+    }
 
     stateHypothesisRecombinationArray.resize(net.structure.stateCount());
 }
@@ -1024,8 +1105,8 @@ void SearchSpace::initializeLanguageModel() {
                                                   net.structure,
                                                   net.rootState,
                                                   net.exits,
-                                                  acousticModel_);
-
+                                                  acousticModel_,
+                                                  sparseLookahead_);
         std::set<LanguageModelLookahead::LookaheadId> rootStates;
 
         rootStates.insert(lmLookahead_->lookaheadId(net.rootState));
@@ -1044,12 +1125,24 @@ void SearchSpace::initializeLanguageModel() {
                   << "  (deduced from relative depth " << reduceBeforeDepth << ")";
         }
 
+        // 0-limit history may still be different, e.g. (contain) fsaLM
+        // if partial not-sparse, then frequent full scoring with possible redundant computation
+        // usually combineLM: cache-scheme for partial sparse unigram lookahead to speed up
+        if (lmLookahead_->historyLimit() == 0 && !lookaheadLm_->unscaled()->fixedHistory(0)) {
+            if (sparseLookahead_ && !lookaheadLm_->isSparse(unigramHistory_)) {
+                log() << "lm-lookahead history with limit 0 is not fixed, apply caching for partial sparse unigram lookahead";
+                lmLookahead_->cacheBatch(unigramHistory_);
+            }
+        }
+
         unigramLookAhead_ = lmLookahead_->getLookahead(unigramHistory_);
 
-        if (paramDisableUnigramLookahead(config))
+        if (paramDisableUnigramLookahead(config)) {
             lmLookahead_->fillZero(unigramLookAhead_);
-        else
+        }
+        else {
             lmLookahead_->fill(unigramLookAhead_);
+        }
 
         automaton->lookAheadIds.resize(net.structure.stateCount(), std::make_pair(0u, 0u));
         automaton->lookAheadIdAndHash.resize(net.structure.stateCount(), std::make_pair(0u, 0u));
@@ -1088,8 +1181,8 @@ void SearchSpace::clear() {
     stateHypotheses.clear();
     newStateHypotheses.clear();
     for (u32 t = 0; t < activeInstances.size(); ++t) {
-        activeInstances[t]->backOffInstance = 0;  // Disable cross-instance dependency
-        activeInstances[t]->backOffParent   = 0;
+        activeInstances[t]->backOffInstance = nullptr;  // Disable cross-instance dependency
+        activeInstances[t]->backOffParent   = nullptr;
         delete activeInstances[t];
     }
     activeInstanceMap.clear();
@@ -1107,8 +1200,9 @@ void SearchSpace::clear() {
 }
 
 inline bool SearchSpace::eventuallyDeactivateTree(Instance* at, bool increaseInactiveCounter) {
-    if (not at->mayDeactivate())
+    if (not at->mayDeactivate()) {
         return false;
+    }
 
     if (!at->states.empty()) {
         at->inactive = 0;
@@ -1116,8 +1210,9 @@ inline bool SearchSpace::eventuallyDeactivateTree(Instance* at, bool increaseIna
     }
     else {
         if (at->inactive < instanceDeletionLatency_) {
-            if (increaseInactiveCounter)
+            if (increaseInactiveCounter) {
                 ++(at->inactive);
+            }
             return false;
         }
         else {
@@ -1217,8 +1312,9 @@ void SearchSpace::expandStateSlow(const Search::StateHypothesis& hyp) {
         if (successors.first != -1) {
             // Fast iteration
             for (StateId successor = successors.first; successor != successors.second; ++successor) {
-                if (expandForward)
+                if (expandForward) {
                     activateOrUpdateStateHypothesisTransition(hyp, forwardScore, successor);  // Already covered by expandState?
+                }
 
                 if (expandSkip && doSkip)  // TODO: only doSkip is sufficient
                 {                          // Second order expansion (successors of successor).
@@ -1239,11 +1335,11 @@ void SearchSpace::expandStateSlow(const Search::StateHypothesis& hyp) {
             for (HMMStateNetwork::SuccessorIterator successorIt = net.structure.batchSuccessors(state.successors); successorIt; ++successorIt) {
                 StateId successor = *successorIt;
 
-                if (expandForward)
+                if (expandForward) {
                     activateOrUpdateStateHypothesisTransition(hyp, forwardScore, successor);
+                }
 
-                if (expandSkip && doSkip)  // TODO: only doSkip is sufficient
-                {
+                if (expandSkip && doSkip) {  // TODO: only doSkip is sufficient
                     for (HMMStateNetwork::SuccessorIterator skipSuccessorIt = net.structure.successors(successor); skipSuccessorIt; ++skipSuccessorIt)
                         activateOrUpdateStateHypothesisTransition(hyp, skipScore, *skipSuccessorIt);
                 }
@@ -1273,8 +1369,9 @@ inline void SearchSpace::expandState(const Search::StateHypothesis& hyp) {
     // loops
     Score loopScore = hyp.score + tdp[Am::StateTransitionModel::loop];
 
-    if (loopScore < Core::Type<Score>::max)
+    if (loopScore < Core::Type<Score>::max) {
         activateOrUpdateStateHypothesisLoop(hyp, loopScore);
+    }
 
     // forward transition
     if ((state.successors & SingleSuccessorBatchMask) == SingleSuccessorBatchMask) {
@@ -1284,8 +1381,9 @@ inline void SearchSpace::expandState(const Search::StateHypothesis& hyp) {
 
         Score forwardScore = hyp.score + tdp[Am::StateTransitionModel::forward];
 
-        if (forwardScore < Core::Type<Score>::max)
+        if (forwardScore < Core::Type<Score>::max) {
             activateOrUpdateStateHypothesisTransition(hyp, forwardScore, forwardSuccessor);
+        }
     }
     else {
         // There are multiple successors
@@ -1299,9 +1397,11 @@ inline void SearchSpace::expandState(const Search::StateHypothesis& hyp) {
 
         Score forwardScore = hyp.score + tdp[Am::StateTransitionModel::forward];
 
-        if (forwardScore < Core::Type<Score>::max)
-            for (int successor = successors.first; successor < successors.second; ++successor)
+        if (forwardScore < Core::Type<Score>::max) {
+            for (int successor = successors.first; successor < successors.second; ++successor) {
                 activateOrUpdateStateHypothesisTransition(hyp, forwardScore, successor);
+            }
+        }
     }
 
     if (allowSkip) {
@@ -1311,9 +1411,11 @@ inline void SearchSpace::expandState(const Search::StateHypothesis& hyp) {
         if (secondStart != secondEnd) {
             Score skipScore = hyp.score + tdp[Am::StateTransitionModel::skip];
 
-            if (skipScore < Core::Type<Score>::max)
-                for (StateId successor2 = secondStart; successor2 < secondEnd; ++successor2)
+            if (skipScore < Core::Type<Score>::max) {
+                for (StateId successor2 = secondStart; successor2 < secondEnd; ++successor2) {
                     activateOrUpdateStateHypothesisTransition(hyp, skipScore, successor2);
+                }
+            }
         }
         else if (secondStart == 0) {
             // The secondOrderEdgeSuccessorBatches_ structure can not hold the successors, so use slow expansion to expand the second-order followers
@@ -1352,8 +1454,9 @@ void SearchSpace::expandHmm() {
         }
 
         if (earlyBackoff_ && instance.rootStateHypotheses.size()) {
-            if (!instance.backOffInstance)
+            if (!instance.backOffInstance) {
                 getBackOffInstance(&instance);
+            }
 
             if (instance.backOffInstance) {
                 for (u32 i = 0; i < instance.rootStateHypotheses.size(); ++i)
@@ -1426,8 +1529,9 @@ void SearchSpace::applyLookaheadInInstanceInternal(Instance* _instance, Acoustic
 
     verify(instance.states.empty() || instance.states.end <= newStateHypotheses.size());
 
-    if (instance.states.empty())
+    if (instance.states.empty()) {
         return;
+    }
 
     StateHypothesesList::iterator sh_begin = newStateHypotheses.begin() + instance.states.begin;
     StateHypothesesList::iterator sh_end   = newStateHypotheses.begin() + instance.states.end;
@@ -1456,14 +1560,17 @@ void SearchSpace::applyLookaheadInInstanceInternal(Instance* _instance, Acoustic
     f32 backOffOffset = 0.0f;
 
     if (!instance.lookahead.get()) {
-        if (useBackOffOffset)
-            backOffOffset = static_cast<const Lm::BackingOffLm*>(lookaheadLm_->unscaled().get())->getAccumulatedBackOffScore(instance.lookaheadHistory, 1) * unigramLookaheadBackoffFactor_ * lookaheadLm_->scale();
+        if (useBackOffOffset) {
+            backOffOffset = static_cast<const Lm::BackingOffLm*>(lookaheadLm_->unscaled().get())->getAccumulatedBackOffScore(instance.lookaheadHistory, 1);
+            backOffOffset *= unigramLookaheadBackoffFactor_ * lmLookahead_->getLookaheadScale();
+        }
 
         bool shouldIncreaseLookAheadOrder = false;
         {
             u32 combinedTreeStateCount = instance.states.size();
-            if (sparseLookAhead)
+            if (sparseLookAhead) {
                 combinedTreeStateCount = instance.backOffChainStates();
+            }
 
             shouldIncreaseLookAheadOrder = combinedTreeStateCount >= currentLookaheadInstanceStateThreshold_;
         }
@@ -1489,6 +1596,7 @@ void SearchSpace::applyLookaheadInInstanceInternal(Instance* _instance, Acoustic
                         break;  // We will continue in the optimized loop without this check
                     }
 
+                    // TODO this has no effect except maybe the pruning threshold
                     sh->prospect = sh->score +
                                    unigramLookAhead_->scoreForLookAheadIdNormal(ids.first) +
                                    acousticLookAhead(ids.second, sh->state) +
@@ -1507,10 +1615,12 @@ void SearchSpace::applyLookaheadInInstanceInternal(Instance* _instance, Acoustic
     }
 
     const LanguageModelLookahead::ContextLookahead* la(instance.lookahead.get());
-    if (!la)
+    if (!la) {
         la = unigramLookAhead_.get();
-    else
+    }
+    else {
         backOffOffset = 0;
+    }
 
     if (la->isSparse()) {
         applyLookaheadSparsePerf_->start();
@@ -1518,7 +1628,6 @@ void SearchSpace::applyLookaheadInInstanceInternal(Instance* _instance, Acoustic
 
         if (!instance.backOffInstance && sh != sh_end) {
             instance.backOffInstance = getBackOffInstance(&instance);
-            verify(instance.backOffInstance);
         }
         Score offset = instance.backOffScore;
 
@@ -1528,9 +1637,12 @@ void SearchSpace::applyLookaheadInInstanceInternal(Instance* _instance, Acoustic
             Score lmScore = 0;
             bool  fail    = false;
 
-            fail = !la->getScoreForLookAheadHashSparse(ids.first, lmScore);
+            fail                       = !la->getScoreForLookAheadHashSparse(ids.first, lmScore);
+            static int success_counter = 0;
+            static int fail_counter    = 0;
 
             if (fail) {
+                fail_counter += 1;
                 // This state needs to transfer into the back-off network
 
                 // Set the prospect to max, so this state will be pruned away from this network
@@ -1539,13 +1651,14 @@ void SearchSpace::applyLookaheadInInstanceInternal(Instance* _instance, Acoustic
                 if (earlyBackoff_) {
                     sh->score = F32_MAX;
                 }
-                else {
+                else if (instance.backOffInstance != nullptr) {  // FsaLm does not have a backoff instance yet should still participate in sparse-lm logic
                     sh->score += offset;
                     // Transfer the state into the back-off network
                     instance.backOffInstance->transfer.push_back(sh - newStateHypotheses.begin());
                 }
             }
             else {
+                success_counter += 1;
                 sh->prospect = sh->score + lmScore + acousticLookAhead(ids.second, sh->state);
                 pruning.prepare(*sh);
             }
@@ -1571,16 +1684,20 @@ void SearchSpace::applyLookaheadInInstanceInternal(Instance* _instance, Acoustic
 template<class Pruning, class AcousticLookAhead>
 void SearchSpace::applyLookaheadInInstanceWithAcoustic(Instance* network, AcousticLookAhead& acousticLookAhead, Pruning& pruning) {
     if (sparseLookahead_) {
-        if (unigramLookaheadBackoffFactor_ != 0)
+        if (unigramLookaheadBackoffFactor_ != 0) {
             applyLookaheadInInstanceInternal<true, true, AcousticLookAhead, Pruning>(network, acousticLookAhead, pruning);
-        else
+        }
+        else {
             applyLookaheadInInstanceInternal<true, false, AcousticLookAhead, Pruning>(network, acousticLookAhead, pruning);
+        }
     }
     else {
-        if (unigramLookaheadBackoffFactor_ != 0)
+        if (unigramLookaheadBackoffFactor_ != 0) {
             applyLookaheadInInstanceInternal<false, true>(network, acousticLookAhead, pruning);
-        else
+        }
+        else {
             applyLookaheadInInstanceInternal<false, false>(network, acousticLookAhead, pruning);
+        }
     }
 }
 
@@ -1623,8 +1740,9 @@ void SearchSpace::addAcousticScoresInternal(Instance const& instance, Pruning& p
     if (scorerCache) {
         // Omit overhead of a virtual function-call for cached scores by calling the score function directly with qualification
         for (; sh != sh_end; ++sh) {
-            if (sh->prospect == F32_MAX)
+            if (sh->prospect == F32_MAX) {
                 continue;  // This state will be pruned
+            }
 
             const HMMState&  state = network().structure.state(sh->state);
             Mm::MixtureIndex mix   = state.stateDesc.acousticModel;
@@ -1641,8 +1759,9 @@ void SearchSpace::addAcousticScoresInternal(Instance const& instance, Pruning& p
     }
     else {
         for (; sh != sh_end; ++sh) {
-            if (sh->prospect == F32_MAX)
+            if (sh->prospect == F32_MAX) {
                 continue;  // This state will be pruned
+            }
 
             const HMMState&  state = network().structure.state(sh->state);
             Mm::MixtureIndex mix   = state.stateDesc.acousticModel;
@@ -1681,8 +1800,9 @@ void SearchSpace::addAcousticScores() {
 }
 
 void SearchSpace::activateLmLookahead(Search::Instance& instance, bool compute) {
-    if (instance.lookahead.get())
+    if (instance.lookahead.get()) {
         return;
+    }
 
     if (instance.key.isTimeKey()) {
         instance.lookahead = unigramLookAhead_;
@@ -1700,8 +1820,9 @@ void SearchSpace::activateLmLookahead(Search::Instance& instance, bool compute)
 
             if (!wt.lookahead && (wt.lookaheadHistory.isValid() || wt.key.history.isValid())) {
                 Lm::History h = wt.lookaheadHistory;
-                if (!h.isValid())
+                if (!h.isValid()) {
                     h = wt.key.history;
+                }
 
                 if (h == unigramHistory_) {
                     wt.lookahead = unigramLookAhead_;
@@ -1714,10 +1835,12 @@ void SearchSpace::activateLmLookahead(Search::Instance& instance, bool compute)
             computeLookaheadPerf_->stop();
         }
         else {
-            if (wt.lookaheadHistory == unigramHistory_)
+            if (wt.lookaheadHistory == unigramHistory_) {
                 instance.lookahead = unigramLookAhead_;
-            else
+            }
+            else {
                 instance.lookahead = lmLookahead_->tryToGetLookahead(wt.lookaheadHistory.isValid() ? wt.lookaheadHistory : wt.key.history);
+            }
         }
     }
 }
@@ -1725,8 +1848,9 @@ void SearchSpace::activateLmLookahead(Search::Instance& instance, bool compute)
 Score SearchSpace::bestProspect() const {
     if (bestProspect_ == Core::Type<Score>::max) {
         StateHypothesesList::const_iterator hyp = bestProspectStateHypothesis();
-        if (hyp != stateHypotheses.end())
+        if (hyp != stateHypotheses.end()) {
             bestProspect_ = (*hyp).prospect;
+        }
     }
     return bestProspect_;
 }
@@ -1734,8 +1858,9 @@ Score SearchSpace::bestProspect() const {
 Score SearchSpace::bestScore() const {
     if (bestScore_ == Core::Type<Score>::max) {
         StateHypothesesList::const_iterator hyp = bestScoreStateHypothesis();
-        if (hyp != stateHypotheses.end())
+        if (hyp != stateHypotheses.end()) {
             bestScore_ = (*hyp).score;
+        }
     }
     return bestScore_;
 }
@@ -1745,8 +1870,9 @@ SearchSpace::StateHypothesesList::const_iterator
     StateHypothesesList::const_iterator ret       = stateHypotheses.begin();
     Score                               bestScore = Core::Type<Score>::max;
     for (StateHypothesesList::const_iterator sh = stateHypotheses.begin(); sh != stateHypotheses.end(); ++sh)
-        if (bestScore > sh->score)
+        if (bestScore > sh->score) {
             bestScore = (ret = sh)->score;
+        }
 
     return ret;
 }
@@ -1756,8 +1882,9 @@ SearchSpace::StateHypothesesList::const_iterator
     StateHypothesesList::const_iterator ret       = stateHypotheses.begin();
     Score                               bestScore = Core::Type<Score>::max;
     for (StateHypothesesList::const_iterator sh = stateHypotheses.begin(); sh != stateHypotheses.end(); ++sh) {
-        if (bestScore > sh->prospect)
+        if (bestScore > sh->prospect) {
             bestScore = (ret = sh)->prospect;
+        }
     }
 
     return ret;
@@ -1814,15 +1941,15 @@ void SearchSpace::pruneStatesPerLmState() {
 
                 StateHypothesisIndex bestHypIndex = stateHypothesisRecombinationArray[hypIn->state] - stateHypothesesSize;  // get index of the best per-state hypothesis
 
-                if (bestHypIndex == hypIn - stateHypotheses.begin())  // compare to the encoded number (a, the best per-state hypothesis)
-                {
+                if (bestHypIndex == hypIn - stateHypotheses.begin()) {  // compare to the encoded number (a, the best per-state hypothesis)
                     // This is the best hypothesis. Update the index so it points to the moved (compressed) state hypothesis
                     stateHypothesisRecombinationArray[hypIn->state] = (hypOut - stateHypotheses.begin()) + stateHypothesesSize;  // is this updated index only needed for the third pass?
                     *(hypOut++)                                     = *hypIn;
                 }
                 else {  // prune all other hypotheses
-                    if (hypIn->prospect <= stateHypotheses[bestHypIndex].prospect + lmStatePruning_)
+                    if (hypIn->prospect <= stateHypotheses[bestHypIndex].prospect + lmStatePruning_) {
                         *(hypOut++) = *hypIn;
+                    }
                 }
             }
 
@@ -1860,8 +1987,9 @@ void SearchSpace::pruneStates(Pruning& pruning) {
 
         for (instHypEnd = hypBegin + at->states.end; hypIn < instHypEnd; ++hypIn) {
             verify_(hypIn < stateHypotheses.end());
-            if (!pruning.prune(trace_manager_, *hypIn))
+            if (!pruning.prune(trace_manager_, *hypIn)) {
                 *(hypOut++) = *hypIn;
+            }
         }
 
         at->states.end = hypOut - hypBegin;
@@ -1904,62 +2032,11 @@ void SearchSpace::filterStates() {
     pruneStates(*automaton_->prefixFilter);
 }
 
-void SearchSpace::enforceCommonPrefix() {
-    if (maximumMutableSuffixPruningInterval_ <= 0 or timeFrame_ % maximumMutableSuffixPruningInterval_ != maximumMutableSuffixPruningInterval_ - 1) {
-        return;
-    }
-
-    PerformanceCounter perf(*statistics, "enforce common prefix");
-
-    // find best trace
-    Score   best_prospect = Core::Type<Score>::max;
-    TraceId best_trace    = invalidTraceId;
-    for (StateHypothesis const& hyp : stateHypotheses) {
-        if (hyp.prospect < best_prospect) {
-            best_prospect = hyp.prospect;
-            best_trace    = hyp.trace;
-        }
-    }
-    if (best_trace == invalidTraceId) {
-        return;
-    }
-
-    // find root trace for all surviving
-    int              remaining_lemmas = maximumMutableSuffixLength_;
-    Core::Ref<Trace> root             = trace_manager_.traceItem(best_trace).trace;
-    while (root) {
-        size_t                           max_length = 0;
-        Bliss::LemmaPronunciation const* pron       = root->pronunciation;
-        if (pron and reinterpret_cast<uintptr_t>(pron) != 1) {
-            Bliss::Lemma const* lemma = pron->lemma();
-            if (lemma->hasEvaluationTokenSequence()) {
-                for (auto eval_seqs = lemma->evaluationTokenSequences(); eval_seqs.first != eval_seqs.second; ++eval_seqs.first) {
-                    max_length = std::max(max_length, eval_seqs.first->size());
-                }
-            }
-        }
-        remaining_lemmas -= max_length;
-        if (remaining_lemmas > 0 or max_length == 0) {
-            root = root->predecessor;
-        }
-        else {
-            break;
-        }
-    }
-
-    if (not root) {
-        return;  // nothing to do, utterance shorter than maximumMutableSuffixLength_
-    }
-
-    PerformanceCounter perf2(*statistics, "enforce common prefix - pruning");
-    BestTracePruning   pruning(root);
-    pruneStates<BestTracePruning>(pruning);
-}
-
 // early acoustic pruning
 void SearchSpace::pruneStatesEarly() {
-    if (!earlyBeamPruning_)
+    if (!earlyBeamPruning_) {
         return;
+    }
 
     PerformanceCounter perf(*statistics, "early acoustic pruning");
 
@@ -1976,7 +2053,6 @@ void SearchSpace::pruneAndAddScores() {
     doStateStatisticsBeforePruning();
 
     filterStates();  // pruneStates using automaton_->prefixFilter -> necessary for incremental decoding of partial segments, where we initialize the prefix
-    enforceCommonPrefix();
     // works with pruneStates() on stateHypotheses
     pruneStatesEarly();  // before applying acoustic scores, uses pruneStates() with score AcousticPruning_
 
@@ -2031,8 +2107,9 @@ void SearchSpace::pruneAndAddScores() {
 }
 
 void SearchSpace::correctPushedTransitions() {
-    if (!correctPushedBoundaryTimes_ || !automaton_->minimized)
+    if (!correctPushedBoundaryTimes_ || !automaton_->minimized) {
         return;
+    }
 
     PersistentStateTree const& net = network();
     PerformanceCounter         perf(*statistics, "correct pushed boundaries");
@@ -2104,10 +2181,12 @@ void SearchSpace::rescale(Score offset, bool ignoreWordEnds) {
     verify(newStateHypotheses.empty());
 
     globalScoreOffset_ += offset;
-    if (bestProspect_ != Core::Type<Score>::max)
+    if (bestProspect_ != Core::Type<Score>::max) {
         bestProspect_ -= offset;
-    if (bestScore_ != Core::Type<Score>::max)
+    }
+    if (bestScore_ != Core::Type<Score>::max) {
         bestScore_ -= offset;
+    }
 }
 
 Score SearchSpace::minimumWordEndScore() const {
@@ -2117,15 +2196,16 @@ Score SearchSpace::minimumWordEndScore() const {
 Score SearchSpace::quantileWordEndScore(Score minScore, Score maxScore, u32 nHyps) const {
     wordEndHistogram_.clear();
     wordEndHistogram_.setLimits(minScore, maxScore);
-    for (WordEndHypothesisList::const_iterator weh = wordEndHypotheses.begin(); weh != wordEndHypotheses.end(); ++weh)
+    for (WordEndHypothesisList::const_iterator weh = wordEndHypotheses.begin(); weh != wordEndHypotheses.end(); ++weh) {
         wordEndHistogram_ += weh->score;
+    }
 
     return wordEndHistogram_.quantile(nHyps);
 }
 
-inline Core::Ref<Trace> SearchSpace::getModifiedTrace(TraceId traceId, const Bliss::Phoneme::Id initial) const {
-    TraceItem const& item(trace_manager_.traceItem(traceId));
-    Core::Ref<Trace> trace = item.trace;
+inline Core::TsRef<Trace> SearchSpace::getModifiedTrace(TraceId traceId, const Bliss::Phoneme::Id initial) const {
+    TraceItem const&   item(trace_manager_.traceItem(traceId));
+    Core::TsRef<Trace> trace = item.trace;
 
     if (trace_manager_.isModified(traceId)) {
         bool encodeState = this->encodeState();
@@ -2138,8 +2218,9 @@ inline Core::Ref<Trace> SearchSpace::getModifiedTrace(TraceId traceId, const Bli
             TimeframeIndex time = trace->time + offsets.first;
             verify(time <= timeFrame_);
             ScoreVector score = trace->score;
-            if (offsets.second)
+            if (offsets.second) {
                 score.acoustic += reinterpret_cast<Search::Score&>(offsets.second);
+            }
 
             if (encodeState) {
                 transit = describeRootState(offsets.third);
@@ -2151,7 +2232,7 @@ inline Core::Ref<Trace> SearchSpace::getModifiedTrace(TraceId traceId, const Bli
                     transit.initial = initial;
                 }
             }
-            trace = Core::Ref<Trace>(new Trace(trace, epsilonLemmaPronunciation(), time, score, transit));
+            trace = Core::TsRef<Trace>(new Trace(trace, epsilonLemmaPronunciation(), time, score, transit));
         }
     }
     return trace;
@@ -2210,8 +2291,9 @@ void SearchSpace::pruneEarlyWordEnds() {
                 groupCount[group] += 1;
                 groups.push_back(group);
                 verify(group >= 0 && group < thresholdsPerGroup.size());
-                if (thresholdsPerGroup[group] > in->score)
+                if (thresholdsPerGroup[group] > in->score) {
                     thresholdsPerGroup[group] = in->score;
+                }
             }
 
             wordEndHypotheses.push_back(end);
@@ -2228,8 +2310,9 @@ void SearchSpace::pruneEarlyWordEnds() {
         for (u32 i = 0; i < nPhonemes; ++i) {
             u32 count = groupCount[i];
             phoneSum += count;
-            if (count > phoneMost)
+            if (count > phoneMost) {
                 phoneMost = count;
+            }
         }
 
         statistics->customStatistics("unpushed word-ends before first-phoneme pruning") += phoneSum;
@@ -2242,10 +2325,12 @@ void SearchSpace::pruneEarlyWordEnds() {
 
         for (u32 i = 0; i < nPhonemes; ++i) {
             if (thresholdsPerGroup[i] != Core::Type<Score>::max) {
-                if (wordEndPhonemePruningThreshold_ < wordEndPruning_)
+                if (wordEndPhonemePruningThreshold_ < wordEndPruning_) {
                     thresholdsPerGroup[i] += wordEndPhonemePruningThreshold_;
-                else
+                }
+                else {
                     thresholdsPerGroup[i] = Core::Type<Score>::max;
+                }
             }
         }
 
@@ -2254,8 +2339,9 @@ void SearchSpace::pruneEarlyWordEnds() {
         WordEndHypothesisList::iterator out = wordEndHypotheses.begin();
         for (WordEndHypothesisList::iterator in = wordEndHypotheses.begin(); in != wordEndHypotheses.end(); ++in) {
             int group = groups[in - wordEndHypotheses.begin()];
-            if (in->score < thresholdsPerGroup[group])
+            if (in->score < thresholdsPerGroup[group]) {
                 *(out++) = *in;
+            }
         }
 
         statistics->customStatistics("word-ends removed by first-phoneme pruning") += (wordEndHypotheses.end() - out);
@@ -2281,8 +2367,35 @@ void SearchSpace::pruneEarlyWordEnds() {
 void SearchSpace::pruneWordEnds(Score absoluteScoreThreshold) {
     WordEndHypothesisList::iterator in, out;
     for (in = out = wordEndHypotheses.begin(); in != wordEndHypotheses.end(); ++in)
-        if (in->score <= absoluteScoreThreshold)
+        if (in->score <= absoluteScoreThreshold) {
+            *(out++) = *in;
+        }
+
+    wordEndHypotheses.erase(out, wordEndHypotheses.end());
+}
+
+void SearchSpace::pruneToCommonTrace(Core::TsRef<Trace> root) {
+    // StateHypothesis pruning
+    BestTracePruning pruning(root);
+    pruneStates<BestTracePruning>(pruning);
+
+    // WordEndHypothesis pruning
+    WordEndHypothesisList::iterator in, out;
+    for (in = out = wordEndHypotheses.begin(); in != wordEndHypotheses.end(); ++in) {
+        bool keepHyp = false;
+
+        auto current = in->trace;
+        while (current and current->time >= root->time) {
+            if (current == root) {
+                keepHyp = true;
+                break;
+            }
+            current = current->predecessor;
+        }
+        if (keepHyp) {
             *(out++) = *in;
+        }
+    }
 
     wordEndHypotheses.erase(out, wordEndHypotheses.end());
 }
@@ -2291,7 +2404,7 @@ void SearchSpace::createTraces(TimeframeIndex time) {
     // Eventually extend the lm states too
     for (WordEndHypothesisList::iterator weh = wordEndHypotheses.begin(); weh != wordEndHypotheses.end(); ++weh) {
         if (weh->pronunciation) {
-            weh->trace = Core::ref(new Trace(weh->trace, weh->pronunciation, time, weh->score, describeRootState(weh->transitState)));
+            weh->trace = Core::tsRef(new Trace(weh->trace, weh->pronunciation, time, weh->score, describeRootState(weh->transitState)));
             weh->trace->score.acoustic += globalScoreOffset_;
 
             // Don't allow negative per-word LM scores (may happen in conjunction with negative pronunciation scores)
@@ -2357,8 +2470,9 @@ void SearchSpace::hypothesizeEpsilonPronunciations(Score bestScore) {
                 /// @todo Un-copy this code
                 const PersistentStateTree::Exit& wordEnd       = net.exits[exit];
                 const Bliss::LemmaPronunciation* pronunciation = lexicon_->lemmaPronunciation(wordEnd.pronunciation);
-                if (!pronunciation)
+                if (!pronunciation) {
                     continue;
+                }
 
                 WordEndHypothesis weh(wordEndHypotheses[w]);
                 weh.pronunciation = pronunciation;
@@ -2379,7 +2493,7 @@ void SearchSpace::hypothesizeEpsilonPronunciations(Score bestScore) {
                 if (weh.score <= threshold) {
                     extendHistoryByLemma(weh, weh.pronunciation->lemma());
 
-                    weh.trace = Core::ref(new Trace(weh.trace, weh.pronunciation, weh.trace->time, weh.score, describeRootState(wordEnd.transitState)));
+                    weh.trace = Core::tsRef(new Trace(weh.trace, weh.pronunciation, weh.trace->time, weh.score, describeRootState(wordEnd.transitState)));
                     weh.trace->score.acoustic += globalScoreOffset_;
                     wordEndHypotheses.push_back(weh);
                 }
@@ -2391,8 +2505,9 @@ void SearchSpace::hypothesizeEpsilonPronunciations(Score bestScore) {
         for (u32 exit = exitsStart; exit != exitsEnd; ++exit) {
             const PersistentStateTree::Exit& wordEnd       = net.exits[exit];
             const Bliss::LemmaPronunciation* pronunciation = lexicon_->lemmaPronunciation(wordEnd.pronunciation);
-            if (!pronunciation)
+            if (!pronunciation) {
                 continue;
+            }
 
             WordEndHypothesis weh(wordEndHypotheses[w]);
             weh.pronunciation = pronunciation;
@@ -2413,7 +2528,7 @@ void SearchSpace::hypothesizeEpsilonPronunciations(Score bestScore) {
             if (weh.score <= threshold) {
                 extendHistoryByLemma(weh, weh.pronunciation->lemma());
 
-                weh.trace = Core::ref(new Trace(weh.trace, weh.pronunciation, weh.trace->time, weh.score, describeRootState(wordEnd.transitState)));
+                weh.trace = Core::tsRef(new Trace(weh.trace, weh.pronunciation, weh.trace->time, weh.score, describeRootState(wordEnd.transitState)));
                 weh.trace->score.acoustic += globalScoreOffset_;
                 wordEndHypotheses.push_back(weh);
             }
@@ -2428,12 +2543,14 @@ void SearchSpace::hypothesizeEpsilonPronunciations(Score bestScore) {
  * Remove sibling traces that are silence.
  */
 void SearchSpace::pruneSilenceSiblingTraces(
-        Core::Ref<Trace> trace, const Bliss::Lemma* silence) {
-    for (Core::Ref<Trace> tr = trace; tr->sibling;) {
-        if (tr->sibling->pronunciation->lemma() == silence)
+        Core::TsRef<Trace> trace, const Bliss::Lemma* silence) {
+    for (Core::TsRef<Trace> tr = trace; tr->sibling;) {
+        if (tr->sibling->pronunciation->lemma() == silence) {
             tr->sibling = tr->sibling->sibling;
-        else
+        }
+        else {
             tr = tr->sibling;
+        }
     }
 }
 
@@ -2453,8 +2570,9 @@ void SearchSpace::optimizeSilenceInWordLattice(
 StateId SearchSpace::rootForCoarticulation(std::pair<Bliss::Phoneme::Id, Bliss::Phoneme::Id> coarticulation) const {
     PersistentStateTree const& net = automaton_->network;  // TODO(beck): change to network() once this function is const
 
-    if (coarticulation.first == Bliss::Phoneme::term && coarticulation.second == Bliss::Phoneme::term)
+    if (coarticulation.first == Bliss::Phoneme::term && coarticulation.second == Bliss::Phoneme::term) {
         return net.rootState;
+    }
 
     //   std::cout << "coarticulation " << coarticulation.first << " " << coarticulation.second << std::endl;
 
@@ -2507,14 +2625,15 @@ void SearchSpace::addStartupWordEndHypothesis(TimeframeIndex time) {
 
     StateId rootState = rootForCoarticulation(recognitionContext_.coarticulation);
 
-    if (rootState == 0)
+    if (rootState == 0) {
         Core::Application::us()->error() << "failed finding coarticulated root-state for coarticulation";
+    }
 
     verify(rch.isValid());
     verify(lah.isValid());
     verify(sch.isValid());
-    ScoreVector      score(0.0, 0.0);
-    Core::Ref<Trace> t(new Trace(time, score, describeRootState(rootState)));
+    ScoreVector        score(0.0, 0.0);
+    Core::TsRef<Trace> t(new Trace(time, score, describeRootState(rootState)));
     t->score.acoustic += globalScoreOffset_;
     wordEndHypotheses.push_back(WordEndHypothesis(rch, lah, sch, rootState, 0, score, t, Core::Type<u32>::max, PathTrace()));
 }
@@ -2546,10 +2665,139 @@ std::pair<Bliss::Phoneme::Id, Bliss::Phoneme::Id> SearchSpace::describeRootState
         return std::make_pair(coart.first, coart.second);
     }
     std::map<StateId, std::pair<Bliss::Phoneme::Id, Bliss::Phoneme::Id>>::const_iterator it = net.rootTransitDescriptions.find(state);
-    if (it != net.rootTransitDescriptions.end())
+    if (it != net.rootTransitDescriptions.end()) {
         return (*it).second;
-    else
+    }
+    else {
         return std::make_pair(Bliss::Phoneme::term, Bliss::Phoneme::term);
+    }
+}
+
+void SearchSpace::maximumStableDelayPruning() {
+    if (timeFrame_ + 1 <= maximumStableDelay_) {
+        return;
+    }
+    if (maximumStableDelayPruningInterval_ <= 0 or timeFrame_ % maximumStableDelayPruningInterval_ != maximumStableDelayPruningInterval_ - 1) {
+        return;
+    }
+
+    PerformanceCounter perf(*statistics, "maximum stable delay");
+
+    auto cutoff = timeFrame_ + 1 - maximumStableDelay_;
+
+    // Find trace of current best hypothesis that has a recent word-end within the limit
+    auto               bestHyp   = stateHypotheses.end();
+    Score              bestScore = Core::Type<Score>::max;
+    Core::TsRef<Trace> root;
+
+    for (auto sh = stateHypotheses.begin(); sh != stateHypotheses.end(); ++sh) {
+        auto trace = trace_manager_.traceItem(sh->trace).trace;
+        if (sh->prospect < bestScore and trace->time >= cutoff) {
+            bestScore = sh->prospect;
+            bestHyp   = sh;
+            root      = trace;
+        }
+    }
+
+    for (auto weh = wordEndHypotheses.begin(); weh != wordEndHypotheses.end(); ++weh) {
+        if (weh->score < bestScore) {
+            bestScore = weh->score;
+            root      = weh->trace;
+        }
+    }
+
+    // No Hypothesis with a recent word-end was found so just take the overall best as fallback
+    if (not root) {
+        root = trace_manager_.traceItem(bestProspectStateHypothesis()->trace).trace;
+        warning() << "Most recent word in best hypothesis is before cutoff point for maximum-stable-delay-pruning so the limit will be surpassed";
+    }
+
+    // Determine the right predecessor of best trace for pruning. `root->time` should be after the cutoff and `root->predecessor->time` before the cutoff
+    Core::TsRef<Trace> preRoot = root->predecessor;
+
+    while (preRoot and preRoot->time >= cutoff) {
+        root    = preRoot;
+        preRoot = preRoot->predecessor;
+    }
+
+    // Perform pruning on root
+    PerformanceCounter perf2(*statistics, "maximum stable delay - pruning");
+    size_t             beforeStates = stateHypotheses.size();
+    size_t             beforeWords  = wordEndHypotheses.size();
+    pruneToCommonTrace(root);
+    size_t prunedStates = beforeStates - stateHypotheses.size();
+    size_t prunedWords  = beforeWords - wordEndHypotheses.size();
+    if (prunedStates > 0 or prunedWords > 0) {
+        log() << "Performed maximum stable delay pruning at time " << timeFrame_ + 1 << " to root trace at time " << root->time << ". Pruned " << prunedStates << " / " << beforeStates << " state hyps and " << prunedWords << " / " << beforeWords << " word end hyps";
+    }
+}
+
+void SearchSpace::maximumMutableSuffixPruning() {
+    if (maximumMutableSuffixPruningInterval_ <= 0 or timeFrame_ % maximumMutableSuffixPruningInterval_ != maximumMutableSuffixPruningInterval_ - 1) {
+        return;
+    }
+
+    PerformanceCounter perf(*statistics, "maximum mutable suffix");
+
+    // find root trace for all surviving
+    int                remaining_lemmas = maximumMutableSuffixLength_;
+    Core::TsRef<Trace> best             = getSentenceEnd(timeFrame_ + 1, false);
+    Core::TsRef<Trace> root             = best;
+    while (root) {
+        size_t                           max_length = 0;
+        Bliss::LemmaPronunciation const* pron       = root->pronunciation;
+        if (pron and pron != epsilonLemmaPronunciation()) {
+            Bliss::Lemma const* lemma = pron->lemma();
+            if (lemma->hasEvaluationTokenSequence()) {
+                for (auto eval_seqs = lemma->evaluationTokenSequences(); eval_seqs.first != eval_seqs.second; ++eval_seqs.first) {
+                    max_length = std::max(max_length, eval_seqs.first->size());
+                }
+            }
+        }
+        remaining_lemmas -= max_length;
+        root = root->predecessor;
+        if (remaining_lemmas <= 0) {
+            break;
+        }
+    }
+
+    if (not root) {
+        return;  // nothing to do, utterance shorter than maximumMutableSuffixLength_
+    }
+
+    PerformanceCounter perf2(*statistics, "maximum mutable suffix - pruning");
+    BestTracePruning   pruning(root);
+    pruneStates<BestTracePruning>(pruning);
+}
+
+void SearchSpace::pruneActiveInstances() {
+    statistics->activeInstancesBeforePruning += activeInstances.size();
+
+    if (activeInstances.size() <= activeInstanceLimit_) {
+        statistics->activeInstancesAfterPruning += activeInstances.size();
+        return;
+    }
+
+    ActiveInstanceLimitPruning pruning(activeInstanceLimit_);
+    for (u32 treeIdx = 0; treeIdx < activeInstances.size(); ++treeIdx) {
+        Instance& instance(*activeInstances[treeIdx]);
+        pruning.startInstance(instance.key);
+
+        const u32 start = instance.states.begin;
+        const u32 end   = instance.states.end;
+
+        for (auto& sh : instance.rootStateHypotheses) {
+            pruning.prepare(sh);
+        }
+        for (auto sh = stateHypotheses.begin() + start; sh != stateHypotheses.begin() + end; ++sh) {
+            pruning.prepare(*sh);
+        }
+    }
+
+    pruning.calculatePruning();
+    pruneStates(pruning);
+
+    statistics->activeInstancesAfterPruning += activeInstances.size();
 }
 
 /**
@@ -2563,33 +2811,37 @@ std::pair<Bliss::Phoneme::Id, Bliss::Phoneme::Id> SearchSpace::describeRootState
  * has siblings corresponding to sub-optimal sentence ends.
  */
 
-Core::Ref<Trace> SearchSpace::getSentenceEnd(TimeframeIndex time, bool shallCreateLattice) {
+Core::TsRef<Trace> SearchSpace::getSentenceEnd(TimeframeIndex time, bool shallCreateLattice) {
     PersistentStateTree const& net = network();
 
-    if (recognitionContext_.latticeMode == SearchAlgorithm::RecognitionContext::No)
+    if (recognitionContext_.latticeMode == SearchAlgorithm::RecognitionContext::No) {
         shallCreateLattice = false;
-    else if (recognitionContext_.latticeMode == SearchAlgorithm::RecognitionContext::Yes)
+    }
+    else if (recognitionContext_.latticeMode == SearchAlgorithm::RecognitionContext::Yes) {
         shallCreateLattice = true;
+    }
 
-    Core::Ref<Trace> best;
-    Score            bestScore = Core::Type<Score>::max;
+    Core::TsRef<Trace> best;
+    Score              bestScore = Core::Type<Score>::max;
 
     StateId forceRoot = 0;
-    if (recognitionContext_.finalCoarticulation.first != Bliss::Phoneme::term || recognitionContext_.finalCoarticulation.second != Bliss::Phoneme::term)
+    if (recognitionContext_.finalCoarticulation.first != Bliss::Phoneme::term || recognitionContext_.finalCoarticulation.second != Bliss::Phoneme::term) {
         forceRoot = rootForCoarticulation(recognitionContext_.finalCoarticulation);
+    }
 
     for (WordEndHypothesisList::const_iterator weh = wordEndHypotheses.begin(); weh != wordEndHypotheses.end(); ++weh) {
         if (forceRoot)  // Either we force all hypotheses to be in a certain state
         {
-            if (weh->transitState != forceRoot)
+            if (weh->transitState != forceRoot) {
                 continue;  // do not allow mismatching sentence end
+            }
         }
         else {
             if (weh->transitState != net.rootState && weh->transitState != net.ciRootState &&
                 !net.uncoarticulatedWordEndStates.count(weh->transitState))
                 continue;  // do not allow coarticulated sentence end
         }
-        Core::Ref<Trace> t(new Trace(weh->trace, 0, time, weh->score, describeRootState(weh->transitState)));
+        Core::TsRef<Trace> t(new Trace(weh->trace, 0, time, weh->score, describeRootState(weh->transitState)));
 
         t->score.acoustic += globalScoreOffset_;
 
@@ -2604,8 +2856,9 @@ Core::Ref<Trace> SearchSpace::getSentenceEnd(TimeframeIndex time, bool shallCrea
         t->pathTrace = weh->pathTrace;
 
         if (!best || best->score > t->score) {  // Make the selection deterministic if scores are equal
-            if (shallCreateLattice)
+            if (shallCreateLattice) {
                 t->sibling = best;
+            }
             best      = t;
             bestScore = t->score;
         }
@@ -2616,7 +2869,7 @@ Core::Ref<Trace> SearchSpace::getSentenceEnd(TimeframeIndex time, bool shallCrea
                     best->sibling = t;
                 }
                 else {  // sorted siblings for on the fly rescoring
-                    Core::Ref<Trace> trace = best;
+                    Core::TsRef<Trace> trace = best;
                     while (trace->sibling and trace->sibling->score < t->score) {
                         trace = trace->sibling;
                     }
@@ -2641,27 +2894,30 @@ Core::Ref<Trace> SearchSpace::getSentenceEnd(TimeframeIndex time, bool shallCrea
 
             for (StateHypothesesList::iterator it = stateHypotheses.begin() + at.states.begin; it != stateHypotheses.begin() + at.states.end; ++it) {
                 if (forceRoot) {
-                    if (it->state != forceRoot)
+                    if (it->state != forceRoot) {
                         continue;
+                    }
                 }
                 else {
-                    if (!net.uncoarticulatedWordEndStates.count((*it).state))
+                    if (!net.uncoarticulatedWordEndStates.count((*it).state)) {
                         continue;
-                    else
+                    }
+                    else {
                         ++activeUncoartic;
+                    }
                 }
                 Score       score = (*it).score + globalScoreOffset_;
                 ScoreVector scores(trace_manager_.traceItem((*it).trace).trace->score);
                 scores.acoustic = score - scores.lm - at.totalBackOffOffset;
 
                 // Append score- and time correcting epsilon item
-                Core::Ref<Trace> t(new Trace(trace_manager_.traceItem((*it).trace).trace,
-                                             epsilonLemmaPronunciation(),
-                                             time - 1,
-                                             scores,
-                                             encodeState ? describeRootState(it->state) : TracebackItem::Transit()));
+                Core::TsRef<Trace> t(new Trace(trace_manager_.traceItem((*it).trace).trace,
+                                               epsilonLemmaPronunciation(),
+                                               time - 1,
+                                               scores,
+                                               encodeState ? describeRootState(it->state) : TracebackItem::Transit()));
                 // Append sentence-end epsilon arc
-                t = Core::Ref<Trace>(new Trace(t, 0, time, t->score, describeRootState(net.rootState)));
+                t = Core::TsRef<Trace>(new Trace(t, 0, time, t->score, describeRootState(net.rootState)));
 
                 Lm::History h(trace_manager_.traceItem((*it).trace).scoreHistory);
                 verify(h.isValid());
@@ -2671,9 +2927,12 @@ Core::Ref<Trace> SearchSpace::getSentenceEnd(TimeframeIndex time, bool shallCrea
 
                 t->score.lm += lm_->sentenceEndScore(h);
 
-                if (t->score < bestScore) {
-                    if (shallCreateLattice)
+                // Fixed sentenceEnd() crash when wordEndHypotheses is empty
+                // Adding a !best check here
+                if (!best || t->score < bestScore) {
+                    if (shallCreateLattice) {
                         t->sibling = best;
+                    }
                     // Create sentence-end trace item, and store it as best
                     bestScore = t->score;
                     best      = t;
@@ -2684,7 +2943,7 @@ Core::Ref<Trace> SearchSpace::getSentenceEnd(TimeframeIndex time, bool shallCrea
                         best->sibling = t;
                     }
                     else {  // sorted siblings for on the fly rescoring
-                        Core::Ref<Trace> trace = best;
+                        Core::TsRef<Trace> trace = best;
                         while (trace->sibling and trace->sibling->score < t->score) {
                             trace = trace->sibling;
                         }
@@ -2710,15 +2969,17 @@ Core::Ref<Trace> SearchSpace::getSentenceEnd(TimeframeIndex time, bool shallCrea
  * network and consider it as a "word end" without a pronunciation.
  */
 
-Core::Ref<Trace> SearchSpace::getSentenceEndFallBack(TimeframeIndex time, bool shallCreateLattice) {
+Core::TsRef<Trace> SearchSpace::getSentenceEndFallBack(TimeframeIndex time, bool shallCreateLattice) {
     PersistentStateTree const& net = network();
 
-    Core::Ref<Trace> best;
+    Core::TsRef<Trace> best;
 
-    if (recognitionContext_.latticeMode == SearchAlgorithm::RecognitionContext::No)
+    if (recognitionContext_.latticeMode == SearchAlgorithm::RecognitionContext::No) {
         shallCreateLattice = false;
-    else if (recognitionContext_.latticeMode == SearchAlgorithm::RecognitionContext::Yes)
+    }
+    else if (recognitionContext_.latticeMode == SearchAlgorithm::RecognitionContext::Yes) {
         shallCreateLattice = true;
+    }
 
     if (shallCreateLattice) {
         Core::Application::us()->warning() << "Lattice requested, but not creating it";
@@ -2741,8 +3002,8 @@ Core::Ref<Trace> SearchSpace::getSentenceEndFallBack(TimeframeIndex time, bool s
         if (bestHypIndex >= at->states.begin && bestHypIndex < at->states.end) {
             Score score = bestHyp->score;
 
-            Core::Ref<Trace> pre(trace_manager_.traceItem(activeTrace).trace);
-            best                 = Core::Ref<Trace>(new Trace(pre, 0, time, pre->score, describeRootState(net.rootState)));
+            Core::TsRef<Trace> pre(trace_manager_.traceItem(activeTrace).trace);
+            best                 = Core::TsRef<Trace>(new Trace(pre, 0, time, pre->score, describeRootState(net.rootState)));
             best->score.acoustic = globalScoreOffset_ + score - pre->score.lm;
 
             Lm::History h = trace_manager_.traceItem(bestHyp->trace).scoreHistory;
@@ -2762,23 +3023,37 @@ Core::Ref<Trace> SearchSpace::getSentenceEndFallBack(TimeframeIndex time, bool s
 
 class RootTraceSearcher {
 public:
-    RootTraceSearcher(std::vector<Core::Ref<Trace>> traces)
+    RootTraceSearcher(std::vector<Core::TsRef<Trace>> traces)
             : rootTrace_(0) {
-        for (std::vector<Core::Ref<Trace>>::const_iterator it = traces.begin(); it != traces.end(); ++it)
+        for (std::vector<Core::TsRef<Trace>>::const_iterator it = traces.begin(); it != traces.end(); ++it) {
             addTrace(it->get(), 0, true);
+        }
 
         for (std::map<Trace*, TraceDesc>::iterator it = traces_.begin(); it != traces_.end(); ++it) {
-            if ((*it).second.length == 1) {
+            if (it->second.length == 1) {
                 // This is "the" root trace
-                verify(rootTrace_ == 0);
-                rootTrace_      = it->first;
-                TraceDesc& desc = traces_[rootTrace_];
-                while (desc.followers.size() == 1) {  // can not be sure if current root trace still have active states
-                    if (desc.isEndTrace)
-                        break;
-                    rootTrace_ = desc.followers.front();
-                    desc       = traces_[rootTrace_];
-                }
+                require_eq(rootTrace_, 0);
+                rootTrace_ = it->first;
+            }
+        }
+
+        TraceDesc desc       = traces_[rootTrace_];
+        Trace*    prev_trace = rootTrace_;
+        while (desc.followers.size() == 1 && !desc.has_active_hyps) {  // can not be sure if current root trace still have active state
+            Trace* follower = desc.followers.front();
+            if (traces_[follower].has_active_hyps) {
+                break;
+            }
+            prev_trace = rootTrace_;
+            rootTrace_ = follower;
+            desc       = traces_[rootTrace_];
+        }
+
+        for (Trace* follower : desc.followers) {
+            // when follower is an epsilon transition, the trace is not yet stable
+            if (follower->pronunciation == epsilonLemmaPronunciation()) {
+                rootTrace_ = prev_trace;
+                break;
             }
         }
     }
@@ -2788,26 +3063,30 @@ class RootTraceSearcher {
     }
 
 private:
-    int addTrace(Trace* trace, Trace* follower, bool isEndTrace = false) {
+    int addTrace(Trace* trace, Trace* follower, bool has_active_hyps = false) {
         std::map<Trace*, TraceDesc>::iterator it = traces_.find(trace);
 
         if (it != traces_.end()) {
             // Already there, just add follower
             TraceDesc& desc((*it).second);
-            if (follower)
+            desc.has_active_hyps |= has_active_hyps;
+            if (follower) {
                 desc.followers.push_back(follower);
+            }
             return desc.length;
         }
         else {
             // Add the predecessors, compute the length, and add the new trace + follower
             int length = 1;
-            if (trace->predecessor)
-                length += addTrace(trace->predecessor.get(), trace);
+            if (trace->predecessor) {
+                length += addTrace(trace->predecessor.get(), trace, false);
+            }
             TraceDesc desc;
-            desc.length     = length;
-            desc.isEndTrace = isEndTrace;
-            if (follower)
+            desc.length          = length;
+            desc.has_active_hyps = has_active_hyps;
+            if (follower) {
                 desc.followers.push_back(follower);
+            }
             traces_.insert(std::make_pair(trace, desc));
             return length;
         }
@@ -2816,50 +3095,55 @@ class RootTraceSearcher {
     struct TraceDesc {
         int                 length;
         std::vector<Trace*> followers;
-        bool                isEndTrace;
+        bool                has_active_hyps;
     };
 
     std::map<Trace*, TraceDesc> traces_;
     Trace*                      rootTrace_;
 };
 
-Core::Ref<Trace>
-        SearchSpace::getCommonPrefix() const {
+Core::TsRef<Trace> SearchSpace::getCommonPrefix() const {
     std::set<TraceId> considerTraceIds;
-    for (std::vector<StateHypothesis>::const_iterator it = stateHypotheses.begin(); it != stateHypotheses.end(); ++it)
+    for (std::vector<StateHypothesis>::const_iterator it = stateHypotheses.begin(); it != stateHypotheses.end(); ++it) {
         considerTraceIds.insert(it->trace);
+    }
 
     // Find the trace where all traces merge
-
-    std::vector<Core::Ref<Trace>> traces;
+    std::vector<Core::TsRef<Trace>> traces;
     for (std::set<TraceId>::iterator it = considerTraceIds.begin(); it != considerTraceIds.end(); ++it) {
-        Core::Ref<Trace> trace = trace_manager_.traceItem(*it).trace;
+        Core::TsRef<Trace> trace = trace_manager_.traceItem(*it).trace;
         traces.push_back(trace);
     }
 
-    for (WordEndHypothesisList::const_iterator it = wordEndHypotheses.begin(); it != wordEndHypotheses.end(); ++it)
+    for (WordEndHypothesisList::const_iterator it = wordEndHypotheses.begin(); it != wordEndHypotheses.end(); ++it) {
         traces.push_back(it->trace);
+    }
 
     RootTraceSearcher searcher(traces);
     verify(searcher.rootTrace());
-    return Core::Ref<Trace>(searcher.rootTrace());
+
+    return Core::TsRef<Trace>(searcher.rootTrace());
 }
 
 class InitialTraceChanger {
 public:
-    InitialTraceChanger(Core::Ref<Trace> initialTrace)
-            : kept(0), killed(0), initialTrace_(initialTrace), baseScore_(initialTrace->score) {
+    InitialTraceChanger(Core::TsRef<Trace> initialTrace)
+            : kept(0),
+              killed(0),
+              initialTrace_(initialTrace),
+              baseScore_(initialTrace->score) {
     }
 
-    bool check(const Core::Ref<Trace>& trace) {
-        if (!trace)
+    bool check(const Core::TsRef<Trace>& trace) {
+        if (!trace) {
             return false;
+        }
 
-        std::stack<Core::Ref<Trace>> stack;
+        std::stack<Core::TsRef<Trace>> stack;
         stack.push(trace);
 
         while (stack.size()) {
-            Core::Ref<Trace> current = stack.top();
+            Core::TsRef<Trace> current = stack.top();
 
             if (!keepTraces_.count(current.get())) {
                 if (current->sibling && !keepTraces_.count(current->sibling.get())) {
@@ -2884,15 +3168,18 @@ class InitialTraceChanger {
                         verify(current->score.lm >= -0.01);
                     }
 
-                    if (current->sibling && !keepTraces_[current->sibling.get()])
+                    if (current->sibling && !keepTraces_[current->sibling.get()]) {
                         current->sibling = current->sibling->sibling;
+                    }
 
                     verify(!current->sibling || keepTraces_[current->sibling.get()]);
 
-                    if (keep)
+                    if (keep) {
                         ++kept;
-                    else
+                    }
+                    else {
                         ++killed;
+                    }
                 }
             }
 
@@ -2908,11 +3195,11 @@ class InitialTraceChanger {
 
 private:
     std::map<Trace*, bool> keepTraces_;
-    Core::Ref<Trace>       initialTrace_;
+    Core::TsRef<Trace>     initialTrace_;
     ScoreVector            baseScore_;
 };
 
-void SearchSpace::changeInitialTrace(Core::Ref<Trace> trace) {
+void SearchSpace::changeInitialTrace(Core::TsRef<Trace> trace) {
     verify(trace);
     trace->sibling.reset();
     trace->predecessor.reset();
@@ -2937,8 +3224,8 @@ void SearchSpace::changeInitialTrace(Core::Ref<Trace> trace) {
 
     for (StateHypothesesList::iterator sh = stateHypotheses.begin(); sh != stateHypotheses.end(); ++sh) {
         verify(sh->score > -0.01);
-        Core::Ref<Trace> trace = trace_manager_.traceItem(sh->trace).trace;
-        bool             ok    = changer.check(trace);
+        Core::TsRef<Trace> trace = trace_manager_.traceItem(sh->trace).trace;
+        bool               ok    = changer.check(trace);
         verify(ok);
     }
 
@@ -2970,8 +3257,9 @@ u32 SearchSpace::nActiveTrees() const {
 }
 
 void SearchSpace::doStateStatisticsBeforePruning() {
-    if (!extendStatistics_)
+    if (!extendStatistics_) {
         return;
+    }
 
     const Lm::BackingOffLm* backOffLm = dynamic_cast<const Lm::BackingOffLm*>(lookaheadLm_->unscaled().get());
 
@@ -2983,10 +3271,12 @@ void SearchSpace::doStateStatisticsBeforePruning() {
             // Do statistics over the count of states in back-off instances
             Instance& mt = dynamic_cast<Instance&>(**it);
 
-            if (mt.lookahead.get())
+            if (mt.lookahead.get()) {
                 statesInTreesWithLookAhead += mt.states.size();
-            else
+            }
+            else {
                 statesInTreesWithoutLookAhead += mt.states.size();
+            }
         }
     }
 
@@ -3001,8 +3291,9 @@ void SearchSpace::doStateStatistics() {
             (*it).pathTrace.maximizeOffset("acoustic-pruning", (*it).prospect - best);
     }
 
-    if (!extendStatistics_)
+    if (!extendStatistics_) {
         return;
+    }
 
     if (!automaton_->stateDepths.empty()) {
         {
@@ -3010,8 +3301,9 @@ void SearchSpace::doStateStatistics() {
 
             for (StateHypothesisIndex idx = 0; idx < stateHypotheses.size(); ++idx) {
                 u32 depth = automaton_->stateDepths[stateHypotheses[idx].state];
-                if (depth >= perDepth.size())
+                if (depth >= perDepth.size()) {
                     perDepth.resize(depth + 1, 0);
+                }
                 ++perDepth[depth];
             }
 
@@ -3022,12 +3314,14 @@ void SearchSpace::doStateStatistics() {
             std::vector<u32> perDepth;
 
             for (InstanceList::iterator it = activeInstances.begin(); it != activeInstances.end(); ++it) {
-                if (!static_cast<Instance&>(**it).lookahead.get())
+                if (!static_cast<Instance&>(**it).lookahead.get()) {
                     continue;
+                }
                 for (StateHypothesisIndex idx = (*it)->states.begin; idx < (*it)->states.end; ++idx) {
                     u32 depth = automaton_->stateDepths[stateHypotheses[idx].state];
-                    if (depth >= perDepth.size())
+                    if (depth >= perDepth.size()) {
                         perDepth.resize(depth + 1, 0);
+                    }
                     ++perDepth[depth];
                 }
             }
@@ -3040,8 +3334,9 @@ void SearchSpace::doStateStatistics() {
 
             for (StateHypothesisIndex idx = 0; idx < stateHypotheses.size(); ++idx) {
                 u32 depth = automaton_->invertedStateDepths[stateHypotheses[idx].state];
-                if (depth >= perDepth.size())
+                if (depth >= perDepth.size()) {
                     perDepth.resize(depth + 1, 0);
+                }
                 ++perDepth[depth];
             }
 
@@ -3052,12 +3347,14 @@ void SearchSpace::doStateStatistics() {
             std::vector<u32> perDepth;
 
             for (InstanceList::iterator it = activeInstances.begin(); it != activeInstances.end(); ++it) {
-                if (!static_cast<Instance&>(**it).lookahead.get())
+                if (!static_cast<Instance&>(**it).lookahead.get()) {
                     continue;
+                }
                 for (StateHypothesisIndex idx = (*it)->states.begin; idx < (*it)->states.end; ++idx) {
                     u32 depth = automaton_->invertedStateDepths[stateHypotheses[idx].state];
-                    if (depth >= perDepth.size())
+                    if (depth >= perDepth.size()) {
                         perDepth.resize(depth + 1, 0);
+                    }
                     ++perDepth[depth];
                 }
             }
@@ -3078,16 +3375,20 @@ void SearchSpace::doStateStatistics() {
 
             int len = 0;
 
-            if (h.isValid())
+            if (h.isValid()) {
                 len = backOffLm->historyLength(h);
+            }
 
-            if (mt.lookahead.get())
+            if (mt.lookahead.get()) {
                 statesInTreesWithLookAhead += mt.states.size();
-            else
+            }
+            else {
                 statesInTreesWithoutLookAhead += mt.states.size();
+            }
 
-            if (len >= statesInTreesWithLookAheadHistory.size())
+            if (len >= statesInTreesWithLookAheadHistory.size()) {
                 statesInTreesWithLookAheadHistory.resize(len + 1, 0);
+            }
 
             statesInTreesWithLookAheadHistory[len] += mt.states.size();
         }
@@ -3148,7 +3449,7 @@ inline void SearchSpace::recombineTwoHypotheses(WordEndHypothesis& a, WordEndHyp
                 b.trace->sibling = a.trace;
             }
             else {  // for on the fly-rescoring we require sorted siblings
-                Core::Ref<Trace> t = b.trace;
+                Core::TsRef<Trace> t = b.trace;
                 while (t->sibling and t->sibling->score < a.trace->score) {
                     t = t->sibling;
                 }
@@ -3181,10 +3482,12 @@ template<bool onTheFlyRescoring>
 void SearchSpace::recombineWordEndsInternal(bool shallCreateLattice) {
     PerformanceCounter perf(*statistics, "recombine word-ends");
 
-    if (recognitionContext_.latticeMode == SearchAlgorithm::RecognitionContext::No)
+    if (recognitionContext_.latticeMode == SearchAlgorithm::RecognitionContext::No) {
         shallCreateLattice = false;
-    else if (recognitionContext_.latticeMode == SearchAlgorithm::RecognitionContext::Yes)
+    }
+    else if (recognitionContext_.latticeMode == SearchAlgorithm::RecognitionContext::Yes) {
         shallCreateLattice = true;
+    }
 
     WordEndHypothesisList::iterator in, out;
 
@@ -3255,25 +3558,31 @@ void SearchSpace::recombineWordEndsInternal(bool shallCreateLattice) {
 void SearchSpace::doWordEndStatistics() {
     PersistentStateTree const& net = network();
 
-    if (lmLookahead_)
+    if (lmLookahead_) {
         lmLookahead_->collectStatistics();
+    }
 
     {
         std::unordered_map<Bliss::Lemma::Id, bool> wordEndLemmas;
 
-        for (std::vector<WordEndHypothesis>::iterator it = wordEndHypotheses.begin(); it != wordEndHypotheses.end(); ++it)
-            if (it->pronunciation && it->pronunciation->lemma() && it->pronunciation->lemma()->syntacticTokenSequence().size())
+        for (std::vector<WordEndHypothesis>::iterator it = wordEndHypotheses.begin(); it != wordEndHypotheses.end(); ++it) {
+            if (it->pronunciation && it->pronunciation->lemma() && it->pronunciation->lemma()->syntacticTokenSequence().size()) {
                 wordEndLemmas.insert(std::make_pair(it->pronunciation->lemma()->id(), true));
+            }
+        }
         currentWordLemmasAfterRecombination += wordEndLemmas.size();
         statistics->customStatistics("word lemmas after recombination") += wordEndLemmas.size();
     }
 
-    if (PathTrace::Enabled)
-        for (std::vector<WordEndHypothesis>::iterator it = wordEndHypotheses.begin(); it != wordEndHypotheses.end(); ++it)
+    if (PathTrace::Enabled) {
+        for (std::vector<WordEndHypothesis>::iterator it = wordEndHypotheses.begin(); it != wordEndHypotheses.end(); ++it) {
             (*it).trace->pathTrace.maximizeOffset("word-end-pruning", (*it).score - minWordEndScore_);
+        }
+    }
 
-    if (!extendStatistics_)
+    if (!extendStatistics_) {
         return;
+    }
 
     typedef std::unordered_map<Lm::History, Score, Lm::History::Hash> BestHash;
     BestHash                                                          bestWordEnds;
@@ -3282,14 +3591,18 @@ void SearchSpace::doWordEndStatistics() {
 
     for (WordEndHypothesisList::const_iterator weh = wordEndHypotheses.begin();
          weh != wordEndHypotheses.end(); ++weh) {
-        if (weh->pronunciation->lemma() == 0 || !weh->pronunciation->lemma()->hasSyntacticTokenSequence())
+        if (weh->pronunciation->lemma() == 0 || !weh->pronunciation->lemma()->hasSyntacticTokenSequence()) {
             ++specialWordEnds;
-        if (weh->transitState == net.rootState)
+        }
+        if (weh->transitState == net.rootState) {
             ++rootWordEnds;
-        else if (weh->transitState == net.ciRootState)
+        }
+        else if (weh->transitState == net.ciRootState) {
             ++ciWordEnds;
-        else
+        }
+        else {
             ++coarticulatedWordEnds;
+        }
     }
 
     statistics->customStatistics("coarticulated word ends") += coarticulatedWordEnds;
@@ -3302,8 +3615,9 @@ void SearchSpace::doWordEndStatistics() {
         int maxTreeStateCount = 0;
 
         for (std::vector<Instance*>::const_iterator it = activeInstances.begin(); it != activeInstances.end(); ++it)
-            if ((*it)->states.size() > maxTreeStateCount)
+            if ((*it)->states.size() > maxTreeStateCount) {
                 maxTreeStateCount = (*it)->states.size();
+            }
 
         if (maxTreeStateCount) {
             for (std::vector<Instance*>::const_iterator it = activeInstances.begin(); it != activeInstances.end(); ++it)
@@ -3320,8 +3634,9 @@ void SearchSpace::setCurrentTimeFrame(TimeframeIndex timeFrame, const Mm::Featur
     timeFrame_ = timeFrame;
     scorer_    = scorer;
 
-    if (currentPruning_.get() && currentPruning_->haveTimeDependentPruning())
+    if (currentPruning_.get() && currentPruning_->haveTimeDependentPruning()) {
         setMasterBeam(currentPruning_->beamForTime(timeFrame) * lm_->scale());
+    }
 
     PerformanceCounter perf(*statistics, "initialize acoustic lookahead");
 
@@ -3339,11 +3654,13 @@ Instance* SearchSpace::createTreeInstance(const Search::InstanceKey& key) {
 
 Instance* SearchSpace::instanceForKey(bool create, const InstanceKey& key, Lm::History const& lookaheadHistory, Lm::History const& scoreHistory) {
     std::unordered_map<InstanceKey, Instance*, InstanceKey::Hash>::iterator it = activeInstanceMap.find(key);
-    if (it != activeInstanceMap.end())
+    if (it != activeInstanceMap.end()) {
         return it->second;
+    }
 
-    if (!create)
+    if (!create) {
         return 0;
+    }
 
     Instance* t         = createTreeInstance(key);
     t->lookaheadHistory = lookaheadHistory;
@@ -3388,10 +3705,11 @@ void SearchSpace::setLookAhead(const std::deque<Core::Ref<const Speech::Feature>
 }
 
 void SearchSpace::logStatistics(Core::XmlChannel& channel) const {
-    statistics->write(channel);
+    statistics->write(channel, Core::Component::getTime(logTiming_));
 
-    if (lmLookahead_)
+    if (lmLookahead_) {
         lmLookahead_->logStatistics();
+    }
 
     if (extendStatistics_) {
         channel << "states on hmm-depth: " << statesOnDepth_.print();
@@ -3424,8 +3742,9 @@ bool SearchSpace::relaxPruning(f32 factor, f32 offset) {
             return false;
         }
         u32 newLimit = acousticPruningLimit_ * factor + offset;
-        if (newLimit > maximumAcousticPruningLimit_)
+        if (newLimit > maximumAcousticPruningLimit_) {
             newLimit = maximumAcousticPruningLimit_;
+        }
         setMasterBeam(newLimit * lm_->scale());
         return true;
     }
@@ -3473,8 +3792,9 @@ void SearchSpace::setMasterBeam(Score value) {
 
         if (oldAcousticPruningLimit != acousticPruningLimit_) {
             std::cout << "t=" << timeFrame_ << " hp -> " << acousticPruningLimit_ << std::endl;
-            if (wordEndPruningLimit_ < oldAcousticPruningLimit)
+            if (wordEndPruningLimit_ < oldAcousticPruningLimit) {
                 wordEndPruningLimit_ = wordEndPruningLimit_ * (acousticPruningLimit_ / oldAcousticPruningLimit);
+            }
         }
     }
     else {
@@ -3486,18 +3806,19 @@ void SearchSpace::setMasterBeam(Score value) {
         verify(acousticPruning_ < Core::Type<f32>::max);
 
         acousticPruning_ = value;
-        /*if (oldAcousticPruning != acousticPruning_)
-            std::cout << "t=" << timeFrame_ << ": bp -> " << acousticPruning_ / lm_->scale() << " (previous " << oldAcousticPruning / lm_->scale() << ")" << std::endl;*/
         verify(acousticPruning_ != 0);
 
-        if (wordEndPruning_ < Core::Type<f32>::max)
+        if (wordEndPruning_ < Core::Type<f32>::max) {
             wordEndPruning_ = oldWordEndPruning * (acousticPruning_ / oldAcousticPruning);
+        }
 
-        if (lmStatePruning_ < Core::Type<f32>::max)
+        if (lmStatePruning_ < Core::Type<f32>::max) {
             lmStatePruning_ = oldLmStatePruning * (acousticPruning_ / oldAcousticPruning);
+        }
 
-        if (wordEndPhonemePruningThreshold_ < Core::Type<f32>::max)
+        if (wordEndPhonemePruningThreshold_ < Core::Type<f32>::max) {
             wordEndPhonemePruningThreshold_ = oldWordEndPhonemePruning * (acousticPruning_ / oldAcousticPruning);
+        }
     }
 }
 
@@ -3540,8 +3861,9 @@ void SearchSpace::resetPruning(SearchAlgorithm::PruningRef pruning) {
     verify(newPruning->beam != Core::Type<Score>::max);
     setMasterBeam(newPruning->beam * lm_->scale());
     currentPruning_ = Core::Ref<PruningDesc>(newPruning);
-    if (!currentPruning_->haveTimeDependentPruning())
+    if (!currentPruning_->haveTimeDependentPruning()) {
         currentPruning_.reset();  // No reason to keep it around
+    }
 }
 
 void SearchSpace::startNewTrees() {
@@ -3553,26 +3875,28 @@ void SearchSpace::startNewTrees() {
         Instance* instance = activateOrUpdateTree(weh->trace, weh->recombinationHistory, weh->lookaheadHistory, weh->scoreHistory, weh->transitState, weh->score);
         verify(instance);
         allEnteredTrees.insert(instance);
-        if (lmLookahead_)
+        if (lmLookahead_) {
             instance->lookaheadHistory = lmLookahead_->getReducedHistory(weh->lookaheadHistory);
+        }
     }
 
     wordEndHypotheses.reserve(wordEndHypotheses.size());
     wordEndHypotheses.clear();
 }
 
-Instance* SearchSpace::activateOrUpdateTree(const Core::Ref<Trace>& trace,
-                                            Lm::History             recombinationHistory,
-                                            Lm::History             lookaheadHistory,
-                                            Lm::History             scoreHistory,
-                                            StateId                 entry,
-                                            Score                   score) {
+Instance* SearchSpace::activateOrUpdateTree(const Core::TsRef<Trace>& trace,
+                                            Lm::History               recombinationHistory,
+                                            Lm::History               lookaheadHistory,
+                                            Lm::History               scoreHistory,
+                                            StateId                   entry,
+                                            Score                     score) {
     /// TODO (Nolden): getLastSyntacticToken is inefficient for long sequences. A simple rule would be better: Stay in same instance, or follow most recent pron.
     InstanceKey key(recombinationHistory, conditionPredecessorWord_ ? getLastSyntacticToken(trace) : Bliss::LemmaPronunciation::invalidId);
     Instance*   instance = instanceForKey(true, key, lookaheadHistory, scoreHistory);
 
-    if (!instance)
+    if (!instance) {
         return 0;
+    }
     verify(dynamic_cast<Instance*>(instance));
 
     Instance* at = static_cast<Instance*>(instance);
@@ -3611,7 +3935,7 @@ void SearchSpace::processOneWordEnd(Instance const& at, StateHypothesis const& h
     }
 
     if (onTheFlyRescoring) {
-        Core::Ref<Trace> trace = item.trace;
+        Core::TsRef<Trace> trace = item.trace;
         for (AlternativeHistory const& h : trace->alternativeHistories.container()) {
             ScoreVector newScore = oldScore + h.offset;
             if (we->pronunciation != Bliss::LemmaPronunciation::invalidId) {
@@ -3695,7 +4019,6 @@ void SearchSpace::findWordEndsInternal() {
 }
 
 void SearchSpace::findWordEnds() {
-    // std::cerr << "best hyp: " << bestScore() << std::endl;
     if (earlyWordEndPruning_) {
         if (onTheFlyRescoring_) {
             findWordEndsInternal<true, true>();
@@ -3715,38 +4038,32 @@ void SearchSpace::findWordEnds() {
 }
 
 Instance* SearchSpace::getBackOffInstance(Instance* instance) {
-    if (instance->backOffInstance || !lmLookahead_)
+    if (instance->backOffInstance || !lmLookahead_) {
         return instance->backOffInstance;
-
-    const Lm::BackingOffLm* lm = dynamic_cast<const Lm::BackingOffLm*>(lookaheadLm_->unscaled().get());
-    verify(lm);
+    }
 
     Lm::History useHistory = instance->lookaheadHistory;
+    if (lookaheadLm_->isSparse(useHistory)) {
+        Lm::History reduced = lookaheadLm_->reduceHistoryByN(useHistory, 1);
 
-    int length = lm->historyLength(useHistory);
-
-    if (length == 0)
-        return 0;
-
-    // Create a back-off network for history-length length-1
-    Lm::History reduced = lm->reducedHistory(useHistory, length - 1);
-
-    verify(lm->historyLength(reduced) == length - 1);
+        if (reduced == useHistory) {
+            return nullptr;
+        }
 
-    verify(reduced.isValid());
+        activeInstances.push_back(new Instance(instance->key, instance));
+        verify(instance->backOffInstance == activeInstances.back());
 
-    activeInstances.push_back(new Instance(instance->key, instance));
-    verify(instance->backOffInstance == activeInstances.back());  // beck: how can this ever be true?
-    /// @todo Möglicherweise wird der falsche backoff-score angewandt. Es sollte der score für die verkürzte history benutzt werden.
-    instance->backOffScore = lm->getBackOffScores(useHistory).backOffScore;
+        instance->backOffScore                      = lookaheadLm_->unscaled()->getBackOffScore(useHistory);
+        instance->backOffInstance->scoreHistory     = instance->scoreHistory;
+        instance->backOffInstance->lookaheadHistory = reduced;
 
-    instance->backOffInstance->scoreHistory     = instance->scoreHistory;
-    instance->backOffInstance->lookaheadHistory = reduced;
+        verify(instance->backOffInstance);
+        verify(instance->backOffInstance->backOffParent == instance);
 
-    verify(instance->backOffInstance);
-    verify(instance->backOffInstance->backOffParent == instance);
+        return instance->backOffInstance;
+    }
 
-    return instance->backOffInstance;
+    return nullptr;
 }
 
 }  // namespace Search
diff --git a/src/Search/AdvancedTreeSearch/SearchSpace.hh b/src/Search/AdvancedTreeSearch/SearchSpace.hh
index 9fc641de6..0f5445e56 100644
--- a/src/Search/AdvancedTreeSearch/SearchSpace.hh
+++ b/src/Search/AdvancedTreeSearch/SearchSpace.hh
@@ -92,7 +92,7 @@ public:
     StaticSearchAutomaton(Core::Configuration config, Core::Ref<const Am::AcousticModel> acousticModel, Bliss::LexiconRef lexicon);
     ~StaticSearchAutomaton();
 
-    void buildNetwork();
+    bool buildNetwork();
 
     // Assigns a depth in the automaton_.stateDepths array to each state
     // If onlyFromRoot is true, then the depths are only computed behind the root state,
@@ -117,9 +117,13 @@ public:
     // Creates fast look-up structures like singleOutputs_, quickOutputBatches_ and secondOrderEdgeTargetBatches_.
     void buildBatches();
 
+    void clearBatches();
+    u32  getChecksum();
+
 private:
     Core::Ref<const Am::AcousticModel> acousticModel_;
     Bliss::LexiconRef                  lexicon_;
+    Core::DependencySet                dependencies_;
 };
 
 class SearchSpace : public Core::Component {
@@ -176,12 +180,15 @@ protected:
     unsigned onTheFlyRescoringMaxHistories_;
     unsigned maximumMutableSuffixLength_;
     unsigned maximumMutableSuffixPruningInterval_;
+    unsigned maximumStableDelay_;
+    unsigned maximumStableDelayPruningInterval_;
 
     /// Pruning thresholds
     Score acousticPruning_;       // main pruning threshold (log-scores)
     u32   acousticPruningLimit_;  // maximum number of hypotheses for Histogram pruning
     Score wordEndPruning_;
     u32   wordEndPruningLimit_;
+    u32   activeInstanceLimit_;
     f64   lmStatePruning_;
     f32   wordEndPhonemePruningThreshold_;
     f32   acousticProspectFactor_;
@@ -275,7 +282,7 @@ protected:
     Search::SearchAlgorithm::RecognitionContext recognitionContext_;
 
     /// Memory Leak workaround
-    std::vector<Core::WeakRef<Trace>> altHistTraces_;
+    std::vector<Core::TsRef<Trace>> altHistTraces_;  // TODO ebeck: used to be WeakRef, but it does not work with TsRef, maybe broken now
 
 public:
     /// ----------- Public interface during search --------------:
@@ -304,11 +311,14 @@ public:
     void pruneEarlyWordEnds();
 
     // Applies time-, score- and transit-modification to the given trace-id, and returns the corrected trace item (as successor of the original trace item)
-    inline Core::Ref<Trace> getModifiedTrace(TraceId trace, Bliss::Phoneme::Id initialPhone) const;
+    inline Core::TsRef<Trace> getModifiedTrace(TraceId trace, Bliss::Phoneme::Id initialPhone) const;
 
     // Prunes the normal word end hypotheses regarding their score (remove all hypotheses with score worse than absoluteScoreThreshold)
     void pruneWordEnds(Search::Score absoluteScoreThreshold);
 
+    // Prune all state hypotheses and word end hypotheses that don't originate from the given trace
+    void pruneToCommonTrace(Core::TsRef<Trace> trace);
+
     // Adds the recognized word to the traces of all word end hypotheses
     void createTraces(TimeframeIndex time);
 
@@ -338,19 +348,25 @@ public:
     // Optimize the lattice, removing redundant silence occurrences
     void optimizeSilenceInWordLattice(const Bliss::Lemma* silence);
 
-    Core::Ref<Trace> getSentenceEnd(TimeframeIndex time, bool shallCreateLattice);
+    // make sure that a prefix of the current best hyp is the prefix for all hyps
+    void maximumStableDelayPruning();
+    void maximumMutableSuffixPruning();
+
+    void pruneActiveInstances();
+
+    Core::TsRef<Trace> getSentenceEnd(TimeframeIndex time, bool shallCreateLattice);
 
-    Core::Ref<Trace> getSentenceEndFallBack(TimeframeIndex time, bool shallCreateLattice);
+    Core::TsRef<Trace> getSentenceEndFallBack(TimeframeIndex time, bool shallCreateLattice);
 
     // Returns the prefix trace which is common to all active hypotheses
-    Core::Ref<Trace> getCommonPrefix() const;
+    Core::TsRef<Trace> getCommonPrefix() const;
 
     // Modifies the search space so that the given trace is the initial trace
     // The score of the given trace will be changed to zero, it will have no pronunciations
     // and no siblings. The search space will be modified so that it is correct relative to this
     // initial trace. All trace (i.e. lattice) paths not leading towards this trace are truncated.
     // Timesstamps are _not_ changed.
-    void changeInitialTrace(Core::Ref<Trace> trace);
+    void changeInitialTrace(Core::TsRef<Trace> trace);
 
     u32 nStateHypotheses() const;
     u32 nEarlyWordEndHypotheses() const;
@@ -381,8 +397,6 @@ protected:
 
     // Apply special search space filtering
     void filterStates();
-    // make sure that a prefix of the current best hyp is the prefix for all hyps
-    void enforceCommonPrefix();
     // Applies state-pruning _before_ acoustic scores are added
     void pruneStatesEarly();
     void pruneStatesPerLmState();
@@ -455,7 +469,7 @@ protected:
     template<bool onTheFlyRescoring>
     void recombineWordEndsInternal(bool shallCreateLattice);
 
-    u32 getLastSyntacticToken(const Core::Ref<Trace>& _trace) {
+    u32 getLastSyntacticToken(const Core::TsRef<Trace>& _trace) {
         const Trace* trace = _trace.get();
         while (trace) {
             if (trace->pronunciation &&
@@ -472,7 +486,7 @@ protected:
         return Core::Type<u32>::max;
     }
 
-    Instance* activateOrUpdateTree(const Core::Ref<Trace>&, Lm::History, Lm::History, Lm::History, StateId, Score);
+    Instance* activateOrUpdateTree(const Core::TsRef<Trace>&, Lm::History, Lm::History, Lm::History, StateId, Score);
 
     Instance* getBackOffInstance(Instance* instance);
 
@@ -509,7 +523,7 @@ protected:
     template<bool recombinationSetPruning, class RecombinationPruning, class Base>
     struct RecombinationSet;
 
-    void pruneSilenceSiblingTraces(Core::Ref<Trace>, const Bliss::Lemma* silence);
+    void pruneSilenceSiblingTraces(Core::TsRef<Trace>, const Bliss::Lemma* silence);
     void dumpWordEnds(std::ostream&, Core::Ref<const Bliss::PhonemeInventory>) const;
     void extendHistoryByLemma(WordEndHypothesis& weh, const Bliss::Lemma* lemma) const;
 
@@ -526,6 +540,7 @@ public:
     SearchSpace(const Core::Configuration& configuration, Core::Ref<const Am::AcousticModel> acousticModel,
                 Bliss::LexiconRef lexicon, Core::Ref<const Lm::ScaledLanguageModel> lm, Score wpScale);
 
+    void reconfigure(const Core::Configuration& config);
     class PruningDesc : public SearchAlgorithm::Pruning {
     public:
         virtual Core::Ref<SearchAlgorithm::Pruning> clone() const {
@@ -653,7 +668,7 @@ public:
     void setMasterBeam(Score value);
 
     // Must be called after creation, after the above functions were called
-    virtual void initialize();
+    virtual void initialize(bool buildBatches = true);
 
     void initializePruning();
 
@@ -663,6 +678,7 @@ private:
     // These are implemented in Pruning.hh
     struct AcousticPruning;
     struct PerInstanceAcousticPruning;
+    struct ActiveInstanceLimitPruning;
     struct RecordMinimum;
     struct RecordMinimumPerInstance;
     struct NoPruning;
diff --git a/src/Search/AdvancedTreeSearch/SearchSpaceHelpers.cc b/src/Search/AdvancedTreeSearch/SearchSpaceHelpers.cc
index 23e062e9b..a4eb0c55c 100644
--- a/src/Search/AdvancedTreeSearch/SearchSpaceHelpers.cc
+++ b/src/Search/AdvancedTreeSearch/SearchSpaceHelpers.cc
@@ -26,7 +26,7 @@ Instance::~Instance() {
     }
 }
 
-void Instance::enter(TraceManager& trace_manager, Core::Ref<Trace> trace, StateId entryNode, Score score) {
+void Instance::enter(TraceManager& trace_manager, Core::TsRef<Trace> trace, StateId entryNode, Score score) {
     rootStateHypotheses.push_back(StateHypothesis(entryNode, trace_manager.getTrace(TraceItem(trace, key.history, lookaheadHistory, scoreHistory)), score));
 }
 
diff --git a/src/Search/AdvancedTreeSearch/SearchSpaceHelpers.hh b/src/Search/AdvancedTreeSearch/SearchSpaceHelpers.hh
index d2f8e855b..caf0cdd1c 100644
--- a/src/Search/AdvancedTreeSearch/SearchSpaceHelpers.hh
+++ b/src/Search/AdvancedTreeSearch/SearchSpaceHelpers.hh
@@ -139,7 +139,8 @@ struct Instance {
 
     struct StateRange {  // actually, StateHypothesisRange.
         StateRange()
-                : begin(0), end(0) {
+                : begin(0),
+                  end(0) {
         }
         StateHypothesisIndex begin, end;
 
@@ -160,7 +161,7 @@ struct Instance {
     std::vector<StateHypothesis> rootStateHypotheses;
 
     /// Enter this tree with the given trace, entry-node and score
-    void enter(TraceManager& trace_manager, Core::Ref<Trace> trace, StateId entryNode, Score score);
+    void enter(TraceManager& trace_manager, Core::TsRef<Trace> trace, StateId entryNode, Score score);
 
     /// Enter this tree with the given StateHypothesis whose trace can have longer histories than tree's
     void enterWithState(const StateHypothesis& st);
@@ -210,10 +211,15 @@ struct EarlyWordEndHypothesis {
     PathTrace   pathTrace;
 
     EarlyWordEndHypothesis(TraceId _trace, const ScoreVector& _score, u32 _exit, PathTrace _pathTrace)
-            : trace(_trace), score(_score), exit(_exit), pathTrace(_pathTrace) {
+            : trace(_trace),
+              score(_score),
+              exit(_exit),
+              pathTrace(_pathTrace) {
     }
     EarlyWordEndHypothesis()
-            : trace(0), score(0, 0), exit(0) {
+            : trace(0),
+              score(0, 0),
+              exit(0) {
     }
 };
 
@@ -224,13 +230,13 @@ struct WordEndHypothesis {
     StateId                          transitState;
     const Bliss::LemmaPronunciation* pronunciation;
     ScoreVector                      score;
-    Core::Ref<Trace>                 trace;
+    Core::TsRef<Trace>               trace;
     u32                              endExit;  // Exit from which this word end hypothesis was constructed
     PathTrace                        pathTrace;
 
     WordEndHypothesis(const Lm::History& rch, const Lm::History& lah, const Lm::History& sch, StateId e,
                       const Bliss::LemmaPronunciation* p, ScoreVector s,
-                      const Core::Ref<Trace>& t, u32 _endExit, PathTrace _pathTrace)
+                      const Core::TsRef<Trace>& t, u32 _endExit, PathTrace _pathTrace)
             : recombinationHistory(rch),
               lookaheadHistory(lah),
               scoreHistory(sch),
diff --git a/src/Search/AdvancedTreeSearch/SearchSpaceStatistics.cc b/src/Search/AdvancedTreeSearch/SearchSpaceStatistics.cc
index b8a66d869..aaa1b2ce2 100644
--- a/src/Search/AdvancedTreeSearch/SearchSpaceStatistics.cc
+++ b/src/Search/AdvancedTreeSearch/SearchSpaceStatistics.cc
@@ -16,7 +16,7 @@
 
 using namespace Search;
 
-void SearchSpaceStatistics::write(Core::XmlWriter& os) const {
+void SearchSpaceStatistics::write(Core::XmlWriter& os, const std::string& time) const {
     os << Core::XmlOpen("search-space-statistics")
        << treesBeforePruning
        << treesAfterPrePruning
@@ -29,6 +29,8 @@ void SearchSpaceStatistics::write(Core::XmlWriter& os) const {
        << epsilonWordEndsAdded
        << wordEndsAfterRecombination
        << wordEndsAfterSecondPruning
+       << activeInstancesBeforePruning
+       << activeInstancesAfterPruning
        << acousticHistogramPruningThreshold
        << lmHistogramPruningThreshold
        << entryStateHypotheses
@@ -40,6 +42,10 @@ void SearchSpaceStatistics::write(Core::XmlWriter& os) const {
     for (std::map<std::string, Core::HistogramStatistics*>::const_iterator it = customHistogramStatistics_.begin(); it != customHistogramStatistics_.end(); ++it)
         os << *(*it).second;
 
+    if (!time.empty()) {
+        os << Core::XmlFull("time", time);
+    }
+    os << Core::XmlFull("frames", statesBeforePruning.nObservations());
     os << Core::XmlClose("search-space-statistics");
 }
 
@@ -55,6 +61,8 @@ SearchSpaceStatistics::SearchSpaceStatistics()
           epsilonWordEndsAdded("epsilon word ends added"),
           wordEndsAfterRecombination("ending words after recombi"),
           wordEndsAfterSecondPruning("ending words after 2nd pruning"),
+          activeInstancesBeforePruning("active instances before pruning"),
+          activeInstancesAfterPruning("active instances after pruning"),
           acousticHistogramPruningThreshold("acoustic histogram pruning threshold"),
           lmHistogramPruningThreshold("lm histogram pruning threshold"),
           entryStateHypotheses("entry state hypotheses"),
@@ -72,6 +80,8 @@ void SearchSpaceStatistics::clear() {
     epsilonWordEndsAdded.clear();
     wordEndsAfterRecombination.clear();
     wordEndsAfterSecondPruning.clear();
+    activeInstancesBeforePruning.clear();
+    activeInstancesAfterPruning.clear();
     acousticHistogramPruningThreshold.clear();
     lmHistogramPruningThreshold.clear();
     entryStateHypotheses.clear();
diff --git a/src/Search/AdvancedTreeSearch/SearchSpaceStatistics.hh b/src/Search/AdvancedTreeSearch/SearchSpaceStatistics.hh
index aeb1a9451..4e25e994b 100644
--- a/src/Search/AdvancedTreeSearch/SearchSpaceStatistics.hh
+++ b/src/Search/AdvancedTreeSearch/SearchSpaceStatistics.hh
@@ -31,7 +31,8 @@ struct SearchSpaceStatistics {
     Core::Statistics<u32> treesBeforePruning, treesAfterPrePruning, treesAfterPruning,
             statesBeforePruning, statesAfterPrePruning, statesAfterPruning,
             wordEndsBeforePruning, wordEndsAfterPruning,
-            epsilonWordEndsAdded, wordEndsAfterRecombination, wordEndsAfterSecondPruning;
+            epsilonWordEndsAdded, wordEndsAfterRecombination, wordEndsAfterSecondPruning,
+            activeInstancesBeforePruning, activeInstancesAfterPruning;
 
     Core::Statistics<Score> acousticHistogramPruningThreshold, lmHistogramPruningThreshold;
 
@@ -40,7 +41,7 @@ struct SearchSpaceStatistics {
 
     SearchSpaceStatistics();
     void clear();
-    void write(Core::XmlWriter&) const;
+    void write(Core::XmlWriter&, const std::string& time) const;
 
 private:
     std::map<std::string, Core::Statistics<f32>*>     customStatistics_;
diff --git a/src/Search/AdvancedTreeSearch/SimpleThreadPool.cc b/src/Search/AdvancedTreeSearch/SimpleThreadPool.cc
index cba181022..b13674b25 100644
--- a/src/Search/AdvancedTreeSearch/SimpleThreadPool.cc
+++ b/src/Search/AdvancedTreeSearch/SimpleThreadPool.cc
@@ -32,7 +32,9 @@ class SimpleThreadPool::Thread : public Core::Thread {
 };
 
 SimpleThreadPool::Thread::Thread()
-        : job_(0), jobReady_(false), waiting_(false) {
+        : job_(0),
+          jobReady_(false),
+          waiting_(false) {
 }
 
 void SimpleThreadPool::Thread::stopThread() {
diff --git a/src/Search/AdvancedTreeSearch/Trace.cc b/src/Search/AdvancedTreeSearch/Trace.cc
index c814e1dba..a654ab22a 100644
--- a/src/Search/AdvancedTreeSearch/Trace.cc
+++ b/src/Search/AdvancedTreeSearch/Trace.cc
@@ -34,12 +34,14 @@ void Trace::write(std::ostream& os, Core::Ref<const Bliss::PhonemeInventory> phi
 Trace::Trace(SearchAlgorithm::TimeframeIndex t, ScoreVector s, const Search::TracebackItem::Transit& transit)
         : TracebackItem(0, t, s, transit) {}
 
-Trace::Trace(const Core::Ref<Trace>&               pre,
+Trace::Trace(const Core::TsRef<Trace>&             pre,
              const Bliss::LemmaPronunciation*      p,
              SearchAlgorithm::TimeframeIndex       t,
              ScoreVector                           s,
              const Search::TracebackItem::Transit& transit)
-        : TracebackItem(p, t, s, transit), predecessor(pre), pruningMark(0) {}
+        : TracebackItem(p, t, s, transit),
+          predecessor(pre),
+          pruningMark(0) {}
 
 void Trace::getLemmaSequence(std::vector<Bliss::Lemma*>& lemmaSequence) const {
     if (predecessor) {
diff --git a/src/Search/AdvancedTreeSearch/Trace.hh b/src/Search/AdvancedTreeSearch/Trace.hh
index b99b55a1d..72037b80d 100644
--- a/src/Search/AdvancedTreeSearch/Trace.hh
+++ b/src/Search/AdvancedTreeSearch/Trace.hh
@@ -16,6 +16,7 @@
 #define CONDITIONEDTREESEARCHTRACE_HH
 
 #include <Core/ReferenceCounting.hh>
+#include <Core/ThreadSafeReference.hh>
 #include <Search/Search.hh>
 #include <Search/StateTree.hh>
 #include <Search/Traceback.hh>
@@ -25,9 +26,9 @@
 namespace Search {
 
 struct AlternativeHistory {
-    Lm::History            hist;
-    ScoreVector            offset;
-    Core::Ref<class Trace> trace;
+    Lm::History              hist;
+    ScoreVector              offset;
+    Core::TsRef<class Trace> trace;
 };
 
 struct AlternativeHistoryCompare {
@@ -49,18 +50,18 @@ public:
 
 using AlternativeHistoryQueue = AccessiblePriorityQueue<AlternativeHistory, std::vector<AlternativeHistory>, AlternativeHistoryCompare>;
 
-class Trace : public Core::ReferenceCounted,
+class Trace : public Core::ThreadSafeReferenceCounted,
               public TracebackItem {
 public:
-    Core::Ref<Trace> predecessor;
-    Core::Ref<Trace> sibling;
-    PathTrace        pathTrace;
-    uintptr_t        pruningMark;  // used by BestTracePruning
-    bool             mark;
+    Core::TsRef<Trace> predecessor;
+    Core::TsRef<Trace> sibling;
+    PathTrace          pathTrace;
+    uintptr_t          pruningMark;  // used by BestTracePruning
+    bool               mark;
 
     AlternativeHistoryQueue alternativeHistories;
 
-    Trace(Core::Ref<Trace> const&          pre,
+    Trace(Core::TsRef<Trace> const&        pre,
           Bliss::LemmaPronunciation const* p,
           TimeframeIndex                   t,
           ScoreVector                      s,
diff --git a/src/Search/AdvancedTreeSearch/TraceManager.hh b/src/Search/AdvancedTreeSearch/TraceManager.hh
index 8fc3cd864..937a9530c 100644
--- a/src/Search/AdvancedTreeSearch/TraceManager.hh
+++ b/src/Search/AdvancedTreeSearch/TraceManager.hh
@@ -15,7 +15,7 @@
 #ifndef SEARCH_TRACEMANAGER_HH
 #define SEARCH_TRACEMANAGER_HH
 
-#include <Core/ReferenceCounting.hh>
+#include <Core/ThreadSafeReference.hh>
 #include "Trace.hh"
 
 namespace Search {
@@ -26,8 +26,11 @@ static const TraceId invalidTraceId = Core::Type<TraceId>::max;
 
 struct TraceItem final {
 public:
-    TraceItem(Core::Ref<Trace> t, Lm::History rch, Lm::History lah, Lm::History sch)
-            : trace(t), recombinationHistory(rch), lookaheadHistory(lah), scoreHistory(sch) {
+    TraceItem(Core::TsRef<Trace> t, Lm::History rch, Lm::History lah, Lm::History sch)
+            : trace(t),
+              recombinationHistory(rch),
+              lookaheadHistory(lah),
+              scoreHistory(sch) {
     }
     TraceItem() {
     }
@@ -50,10 +53,10 @@ public:
         return *this;
     }
 
-    Core::Ref<Trace> trace;
-    Lm::History      recombinationHistory;
-    Lm::History      lookaheadHistory;
-    Lm::History      scoreHistory;
+    Core::TsRef<Trace> trace;
+    Lm::History        recombinationHistory;
+    Lm::History        lookaheadHistory;
+    Lm::History        scoreHistory;
 
 private:
     friend class TraceManager;
@@ -214,7 +217,6 @@ public:
 
     /// Returns the unmodified version of the given trace.
     inline TraceId getUnmodified(TraceId trace) const {
-        verify_(isModified(trace));
         if ((trace & ModifyMask) == ModifyMask) {
             return modifications_[trace & UnModifyMask].first;
         }
@@ -223,7 +225,6 @@ public:
         }
     }
     inline TraceId getUnmodified(TraceId trace) {
-        verify_(isModified(trace));
         if ((trace & ModifyMask) == ModifyMask) {
             return modifications_[trace & UnModifyMask].first;
         }
diff --git a/src/Search/Aligner.cc b/src/Search/Aligner.cc
index b9e498869..64275a8b0 100644
--- a/src/Search/Aligner.cc
+++ b/src/Search/Aligner.cc
@@ -59,7 +59,11 @@ class Aligner::SearchSpace : public Core::Component {
         Am::AllophoneStateIndex emission;
         s32                     nRefs; /**< number of references by traceback arcs in the following timeframe */
         StateHypothesis(StateId si, Score sc, Trace tr, Am::AllophoneStateIndex em)
-                : state(si), score(sc), trace(tr), emission(em), nRefs(0) {}
+                : state(si),
+                  score(sc),
+                  trace(tr),
+                  emission(em),
+                  nRefs(0) {}
     };
 
     TimeframeIndex                       time_;
@@ -102,7 +106,12 @@ class Aligner::SearchSpace : public Core::Component {
 };
 
 Aligner::SearchSpace::SearchSpace(const Core::Configuration& c)
-        : Core::Component(c), viterbi_(true), logVariability_(paramLogVariability(c)), time_(0), traceback_(new Fsa::StaticAutomaton), tracebackRef_(Core::ref(traceback_)) {}
+        : Core::Component(c),
+          viterbi_(true),
+          logVariability_(paramLogVariability(c)),
+          time_(0),
+          traceback_(new Fsa::StaticAutomaton),
+          tracebackRef_(Core::ref(traceback_)) {}
 
 void Aligner::SearchSpace::setViterbi(bool viterbi) {
     viterbi_ = viterbi;
@@ -803,7 +812,9 @@ class Aligner::WordLatticeBuilder::AddWordBoundaryDisambiguatorsAutomaton : publ
 
 public:
     AddWordBoundaryDisambiguatorsAutomaton(Fsa::ConstAutomatonRef f, Fsa::LabelId disambiguator)
-            : Precursor(f), disambiguator_(disambiguator), one_(f->semiring()->one()) {}
+            : Precursor(f),
+              disambiguator_(disambiguator),
+              one_(f->semiring()->one()) {}
 
     virtual Fsa::StateId initialStateId() const {
         return mapStateId(fsa_->initialStateId());
diff --git a/src/Search/Aligner.hh b/src/Search/Aligner.hh
index 08b74bf1f..fbca24924 100644
--- a/src/Search/Aligner.hh
+++ b/src/Search/Aligner.hh
@@ -169,9 +169,11 @@ public:
     void                                           getAlignment(Speech::Alignment&, std::pair<Fsa::ConstAutomatonRef, Fsa::Weight> alignmentPosteriorFsa) const;
     void                                           getAlignment(Speech::Alignment&) const;
     Score                                          alignmentScore() const;
-    bool                                           reachedFinalState() const {
+
+    bool reachedFinalState() const {
         return alignmentScore() != Core::Type<Score>::max;
     }
+
     void selectMode(Mode);
     void selectMode();
     Mode getMode() const;
diff --git a/src/Search/ApproxLinearMiniHash.hh b/src/Search/ApproxLinearMiniHash.hh
index f81890c61..5f53ad073 100644
--- a/src/Search/ApproxLinearMiniHash.hh
+++ b/src/Search/ApproxLinearMiniHash.hh
@@ -57,7 +57,8 @@ class ApproxLinearMiniHash {
 
 public:
     ApproxLinearMiniHash()
-            : size_(0), mask_(0) {
+            : size_(0),
+              mask_(0) {
         verify(sizeof(float) == sizeof(u32));  // Expected in all of the code
     }
 
diff --git a/src/Search/ArchiveIO.hh b/src/Search/ArchiveIO.hh
new file mode 100644
index 000000000..3c44de0a0
--- /dev/null
+++ b/src/Search/ArchiveIO.hh
@@ -0,0 +1,99 @@
+#ifndef ARCHIVE_IO
+#define ARCHIVE_IO
+
+#include <Core/Hash.hh>
+#include <Core/MappedArchive.hh>
+
+// -- reader --
+template<class T>
+Core::MappedArchiveReader& operator>>(Core::MappedArchiveReader& reader, std::unordered_set<T>& target) {
+    target.clear();
+    std::vector<T> vec;
+    reader >> vec;
+    target.insert(vec.begin(), vec.end());
+    return reader;
+}
+
+template<class T>
+Core::MappedArchiveReader& operator>>(Core::MappedArchiveReader& reader, std::set<T>& target) {
+    target.clear();
+    std::vector<T> vec;
+    reader >> vec;
+    target.insert(vec.begin(), vec.end());
+    return reader;
+}
+
+template<class T, class T2>
+Core::MappedArchiveReader& operator>>(Core::MappedArchiveReader& reader, std::unordered_map<T, T2>& target) {
+    target.clear();
+    std::vector<std::pair<T, T2>> vec;
+    reader >> vec;
+    target.insert(vec.begin(), vec.end());
+    return reader;
+}
+
+template<class T, class T2>
+Core::MappedArchiveReader& operator>>(Core::MappedArchiveReader& reader, std::map<T, T2>& target) {
+    target.clear();
+    std::vector<std::pair<T, T2>> vec;
+    reader >> vec;
+    target.insert(vec.begin(), vec.end());
+    return reader;
+}
+
+template<class T, class T2>
+Core::MappedArchiveReader& operator>>(Core::MappedArchiveReader& reader, Core::HashMap<T, T2>& target) {
+    target.clear();
+    std::vector<std::pair<T, T2>> vec;
+    reader >> vec;
+    target.insert(vec.begin(), vec.end());
+    return reader;
+}
+
+template<class T, class T2>
+Core::MappedArchiveReader& operator>>(Core::MappedArchiveReader& reader, Core::HashMap<T, T2, typename T::Hash>& target) {
+    target.clear();
+    std::vector<std::pair<T, T2>> vec;
+    reader >> vec;
+    target.insert(vec.begin(), vec.end());
+    return reader;
+}
+
+// -- writer --
+template<class T>
+Core::MappedArchiveWriter& operator<<(Core::MappedArchiveWriter& writer, const std::unordered_set<T>& set) {
+    writer << std::vector<T>(set.begin(), set.end());
+    return writer;
+}
+
+template<class T>
+Core::MappedArchiveWriter& operator<<(Core::MappedArchiveWriter& writer, const std::set<T>& set) {
+    writer << std::vector<T>(set.begin(), set.end());
+    return writer;
+}
+
+template<class T, class T2>
+Core::MappedArchiveWriter& operator<<(Core::MappedArchiveWriter& writer, const std::unordered_map<T, T2>& map) {
+    writer << std::vector<std::pair<T, T2>>(map.begin(), map.end());
+    return writer;
+}
+
+template<class T, class T2>
+Core::MappedArchiveWriter& operator<<(Core::MappedArchiveWriter& writer, const std::map<T, T2>& map) {
+    writer << std::vector<std::pair<T, T2>>(map.begin(), map.end());
+    return writer;
+}
+
+template<class T, class T2>
+Core::MappedArchiveWriter& operator<<(Core::MappedArchiveWriter& writer, const Core::HashMap<T, T2>& map) {
+    writer << std::vector<std::pair<T, T2>>(map.begin(), map.end());
+    return writer;
+}
+
+template<class T, class T2>
+Core::MappedArchiveWriter& operator<<(Core::MappedArchiveWriter& writer, const Core::HashMap<T, T2, typename T::Hash>& map) {
+    writer << std::vector<std::pair<T, T2>>(map.begin(), map.end());
+    return writer;
+}
+
+#endif
diff --git a/src/Search/BatchManager.hh b/src/Search/BatchManager.hh
index 47f5987bc..0d2239037 100644
--- a/src/Search/BatchManager.hh
+++ b/src/Search/BatchManager.hh
@@ -76,7 +76,10 @@ private:
 
 public:
     BatchPointerIterator(BatchIdType batchId, std::vector<NodeIdType>& batches, std::vector<NodeType>& values)
-            : batches_(batches), nodes_(values), batchId_(batchId), valid_(true) {
+            : batches_(batches),
+              nodes_(values),
+              batchId_(batchId),
+              valid_(true) {
         if (batchId_ == invalidBatch_) {
             valid_ = false;
             return;
@@ -424,7 +427,8 @@ public:
     }
 
     BatchBuilder(std::vector<NodeIdType>& batches, std::vector<NodeType>& nodes)
-            : batches_(batches), nodes_(nodes) {
+            : batches_(batches),
+              nodes_(nodes) {
     }
 
     ~BatchBuilder() {}
diff --git a/src/Search/LanguageModelLookahead.cc b/src/Search/LanguageModelLookahead.cc
index 5044991d6..eb9fb6edc 100644
--- a/src/Search/LanguageModelLookahead.cc
+++ b/src/Search/LanguageModelLookahead.cc
@@ -22,6 +22,7 @@
 #include <Core/Utility.hh>
 #include <Lm/BackingOff.hh>
 #include <Lm/FsaLm.hh>
+#include <Search/ArchiveIO.hh>
 #include <Search/Helpers.hh>
 #include <Search/Types.hh>
 
@@ -292,7 +293,8 @@ LanguageModelLookahead::LanguageModelLookahead(
         HMMStateNetwork const&                        tree,
         StateId                                       rootNode,
         std::vector<PersistentStateTree::Exit> const& exits,
-        Core::Ref<const Am::AcousticModel>            acousticModel)
+        Core::Ref<const Am::AcousticModel>            acousticModel,
+        bool                                          sparse)
         : Core::Component(c),
           wpScale_(wpScale),
           maxDepth_(0),
@@ -1797,6 +1799,18 @@ bool LanguageModelLookahead::computeScoresSparse(LanguageModelLookahead::Context
         waitingLookaheadNodesByDepth_[nodes_[nodeIdx].depth].push_back(std::make_pair(nodeIdx, (Score)0));
     }
 
+    for (const Lm::WordScore& successor : successors) {
+        Score score = successor.score() * scale;
+
+        TokenNodeScore::const_iterator node    = nodeForToken_.begin() + firstNodeForToken_[successor.token()],
+                                       nodeEnd = nodeForToken_.begin() + firstNodeForToken_[successor.token() + 1];
+        for (; node != nodeEnd; ++node) {
+            Score       endScore = score + (*node).second;
+            LookaheadId nodeId   = (*node).first;
+            waitingLookaheadNodesByDepth_[nodes_[nodeId].depth].push_back(std::make_pair(nodeId, endScore));
+        }
+    }
+
     if (nodeRecombination_.empty()) {
         nodeRecombination_.resize(nEntries_, 0);
     }
diff --git a/src/Search/LanguageModelLookahead.hh b/src/Search/LanguageModelLookahead.hh
index b576b5138..fa6ce5f3a 100644
--- a/src/Search/LanguageModelLookahead.hh
+++ b/src/Search/LanguageModelLookahead.hh
@@ -171,7 +171,7 @@ public:
                            Search::HMMStateNetwork const&                        tree,
                            Search::StateId                                       rootNode,
                            std::vector<Search::PersistentStateTree::Exit> const& exits,
-                           Core::Ref<const Am::AcousticModel>);
+                           Core::Ref<const Am::AcousticModel>, bool sparse = false);
 
     ~LanguageModelLookahead();
 
diff --git a/src/Search/LatticeHandler.hh b/src/Search/LatticeHandler.hh
index 6a5015547..552cc9f1a 100644
--- a/src/Search/LatticeHandler.hh
+++ b/src/Search/LatticeHandler.hh
@@ -55,9 +55,11 @@ protected:
     typedef Lattice::ConstWordLatticeRef     ConstWordLatticeRef;
 
 public:
-    enum LatticeFormat { formatDefault,
-                         formatFlf,
-                         formatOpenFst };
+    enum LatticeFormat {
+        formatDefault,
+        formatFlf,
+        formatOpenFst
+    };
 
     LatticeHandler(const Core::Configuration& c)
             : Core::Component(c),
diff --git a/src/Search/LinearMiniHash.hh b/src/Search/LinearMiniHash.hh
index 744349f89..f85aa3fbc 100644
--- a/src/Search/LinearMiniHash.hh
+++ b/src/Search/LinearMiniHash.hh
@@ -51,7 +51,9 @@ class LinearMiniHash {
 
 public:
     LinearMiniHash(Value defaultValue)
-            : size_(0), mask_(0), defaultValue_(defaultValue) {
+            : size_(0),
+              mask_(0),
+              defaultValue_(defaultValue) {
     }
 
     void read(Core::MappedArchiveReader reader) {
diff --git a/src/Search/LinearPrediction.hh b/src/Search/LinearPrediction.hh
index eab343b72..e0bcb4028 100644
--- a/src/Search/LinearPrediction.hh
+++ b/src/Search/LinearPrediction.hh
@@ -90,7 +90,8 @@ public:
 private:
     struct Stat {
         Stat(u32 c = 0, u32 s = 0)
-                : count(c), sum(s) {
+                : count(c),
+                  sum(s) {
         }
 
         u32 count;
diff --git a/src/Search/LinearSearch.cc b/src/Search/LinearSearch.cc
index ab44e89f2..58c7634c6 100644
--- a/src/Search/LinearSearch.cc
+++ b/src/Search/LinearSearch.cc
@@ -112,7 +112,10 @@ class WordPronunciationState : public Core::ReferenceCounted {
     typedef std::vector<Hypo> HypoVector;
 
     WordPronunciationState(const Bliss::LemmaPronunciation* const lemma, const Am::AcousticModel* const acousticModel, Score unigramScore)
-            : pron_(new LinearSearch::Pronunciation(lemma, acousticModel)), position_(0), unigramScore_(unigramScore), irregularChain_(false) {
+            : pron_(new LinearSearch::Pronunciation(lemma, acousticModel)),
+              position_(0),
+              unigramScore_(unigramScore),
+              irregularChain_(false) {
         hyp_.resize(pron_->nMixtures() + 1);
         HypoVector::iterator it = hyp_.begin();
         it->mixture             = 0;
@@ -186,7 +189,10 @@ class WordPronunciationState : public Core::ReferenceCounted {
 };
 
 LinearSearch::LinearSearch(const Core::Configuration& conf)
-        : Core::Component(conf), SearchAlgorithm(conf), singleWordRecognition_(paramSingleWordRecognition_(conf)), time_(0) {
+        : Core::Component(conf),
+          SearchAlgorithm(conf),
+          singleWordRecognition_(paramSingleWordRecognition_(conf)),
+          time_(0) {
     log("using linear search");
     if (singleWordRecognition_)
         log("using new single-word-recognition");
@@ -461,6 +467,10 @@ void LinearSearch::getCurrentBestSentence(Traceback& result) const {
     std::reverse(result.begin(), result.end());
 }
 
+void LinearSearch::getCurrentBestTrace(Traceback& result) const {  // jiang
+    defect();
+}
+
 void LinearSearch::getPartialSentence(Traceback& result) {
     getCurrentBestSentence(result);
     restart();
@@ -475,7 +485,11 @@ void LinearSearch::resetStatistics() {}
 void LinearSearch::logStatistics() const {}
 
 LinearSearch::Book::Book()
-        : score(Core::Type<Score>::max), lmScore(0), hadRegularWord(false), bkp(0), time(0) {
+        : score(Core::Type<Score>::max),
+          lmScore(0),
+          hadRegularWord(false),
+          bkp(0),
+          time(0) {
 }
 
 LinearSearch::Book::~Book() {
diff --git a/src/Search/LinearSearch.hh b/src/Search/LinearSearch.hh
index 599c5b392..7d108f601 100644
--- a/src/Search/LinearSearch.hh
+++ b/src/Search/LinearSearch.hh
@@ -81,6 +81,9 @@ public:
     virtual ~LinearSearch();
 
     virtual bool setModelCombination(const Speech::ModelCombination& modelCombination);
+    virtual bool setLanguageModel(Core::Ref<const Lm::ScaledLanguageModel>) {
+        defect();
+    }
 
     virtual void setGrammar(Fsa::ConstAutomatonRef);
 
@@ -88,6 +91,7 @@ public:
     virtual void                            feed(const Mm::FeatureScorer::Scorer&);
     virtual void                            getPartialSentence(Traceback& result);
     virtual void                            getCurrentBestSentence(Traceback& result) const;
+    virtual void                            getCurrentBestTrace(Traceback& result) const;  // jiang
     virtual Core::Ref<const LatticeAdaptor> getCurrentWordLattice() const;
     virtual void                            resetStatistics();
     virtual void                            logStatistics() const;
diff --git a/src/Search/PersistentStateTree.cc b/src/Search/PersistentStateTree.cc
index adcbdfb76..9948605c4 100644
--- a/src/Search/PersistentStateTree.cc
+++ b/src/Search/PersistentStateTree.cc
@@ -25,6 +25,9 @@
 #include "StateTree.hh"
 #include "TreeStructure.hh"
 
+#include "ArchiveIO.hh"
+#include "TreeBuilder.hh"
+
 using namespace Search;
 using namespace Core;
 
@@ -50,7 +53,9 @@ struct ConvertTree {
     std::map<StateId, std::pair<Bliss::Phoneme::Id, Bliss::Phoneme::Id>> rootTransitDescriptions;
 
     ConvertTree(const Search::StateTree* _tree, HMMStateNetwork& _subtrees)
-            : tree(_tree), subtrees(_subtrees), lostNodeIndices(0) {
+            : tree(_tree),
+              subtrees(_subtrees),
+              lostNodeIndices(0) {
     }
 
     void convert() {
@@ -260,36 +265,6 @@ bool PersistentStateTree::write(int transformation) {
     return writer.good();
 }
 
-template<class T>
-MappedArchiveReader& operator>>(MappedArchiveReader& reader, std::set<T>& target) {
-    target.clear();
-    std::vector<T> vec;
-    reader >> vec;
-    target.insert(vec.begin(), vec.end());
-    return reader;
-}
-
-template<class T>
-MappedArchiveWriter& operator<<(MappedArchiveWriter& writer, const std::set<T>& set) {
-    writer << std::vector<T>(set.begin(), set.end());
-    return writer;
-}
-
-template<class T, class T2>
-MappedArchiveReader& operator>>(MappedArchiveReader& reader, std::map<T, T2>& target) {
-    target.clear();
-    std::vector<std::pair<T, T2>> vec;
-    reader >> vec;
-    target.insert(vec.begin(), vec.end());
-    return reader;
-}
-
-template<class T, class T2>
-MappedArchiveWriter& operator<<(MappedArchiveWriter& writer, const std::map<T, T2>& set) {
-    writer << std::vector<std::pair<T, T2>>(set.begin(), set.end());
-    return writer;
-}
-
 void PersistentStateTree::write(Core::MappedArchiveWriter out) {
     out << formatVersion << (u32)dependencies_.getChecksum();
 
@@ -376,7 +351,7 @@ void PersistentStateTree::removeOutputs() {
 
     for (std::unordered_map<StateId, StateId>::const_iterator it = cleanupResult.nodeMap.begin(); it != cleanupResult.nodeMap.end(); ++it) {
         if (it->first != it->second)
-            std::cout << "mapped " << it->first << " to " << it->second << std::endl;
+            Core::Application::us()->log() << "mapped " << it->first << " to " << it->second;
         verify(it->first == it->second);
     }
 }
@@ -537,4 +512,9 @@ void PersistentStateTree::dumpDotGraph(std::string file, const std::vector<int>&
 
     os << "}" << std::endl;
 }
+
+Core::DependencySet PersistentStateTree::getDependencies() {
+    return dependencies_;
+}
+
 }  // namespace Search
diff --git a/src/Search/PersistentStateTree.hh b/src/Search/PersistentStateTree.hh
index a200ce9b2..cda2c9aa5 100644
--- a/src/Search/PersistentStateTree.hh
+++ b/src/Search/PersistentStateTree.hh
@@ -70,6 +70,14 @@ public:
     /// Dump the search network as a dot graph into the given file
     void dumpDotGraph(std::string file, const std::vector<int>& nodeDepths = {});
 
+    bool isRoot(StateId node) const {
+        return node == rootState || node == ciRootState || coarticulatedRootStates.count(node);
+    }
+
+    Core::DependencySet getDependencies();
+
+    /**  ----- types: ------  */
+
     struct Exit {
         Bliss::LemmaPronunciation::Id pronunciation;
         StateId                       transitState;
@@ -91,10 +99,6 @@ public:
         }
     };
 
-    bool isRoot(StateId node) const {
-        return node == rootState || node == ciRootState || coarticulatedRootStates.count(node);
-    }
-
     typedef std::map<Search::StateId, std::pair<Bliss::Phoneme::Id, Bliss::Phoneme::Id>> RootTransitDescriptions;
 
     /**  ----- state tree data: ------  */
diff --git a/src/Search/Search.hh b/src/Search/Search.hh
index 5774db674..4134b48a5 100644
--- a/src/Search/Search.hh
+++ b/src/Search/Search.hh
@@ -15,6 +15,8 @@
 #ifndef _SEARCH_SEARCHALGORITHM_HH
 #define _SEARCH_SEARCHALGORITHM_HH
 
+#include <memory>
+
 #include <Am/AcousticModel.hh>
 #include <Bliss/Lexicon.hh>
 #include <Core/Component.hh>
@@ -22,6 +24,7 @@
 #include <Lm/LanguageModel.hh>
 #include <Search/LatticeAdaptor.hh>
 #include <Speech/ModelCombination.hh>
+
 #include "Traceback.hh"
 #include "Types.hh"
 
@@ -41,8 +44,10 @@ public:
     SearchAlgorithm(const Core::Configuration&);
     virtual ~SearchAlgorithm() {}
 
+    virtual void                           reconfigure(const Core::Configuration& config) {};
     virtual Speech::ModelCombination::Mode modelCombinationNeeded() const;
     virtual bool                           setModelCombination(const Speech::ModelCombination& modelCombination) = 0;
+    virtual bool                           setLanguageModel(Core::Ref<const Lm::ScaledLanguageModel>)            = 0;
 
     virtual void setGrammar(Fsa::ConstAutomatonRef) = 0;
 
diff --git a/src/Search/StateTree.cc b/src/Search/StateTree.cc
index b71641bca..0aa3d5db3 100644
--- a/src/Search/StateTree.cc
+++ b/src/Search/StateTree.cc
@@ -418,9 +418,11 @@ class StateTree::SuffixSet {
     ItemList items_;
 
     bool hasUniqueHead_;
-    mutable enum { dirty,
-                   sorted,
-                   hashValid } consolidation_;
+    mutable enum {
+        dirty,
+        sorted,
+        hashValid
+    } consolidation_;
 
 private:
     void sort() {
@@ -429,10 +431,12 @@ class StateTree::SuffixSet {
     }
 
     mutable u32 hash_;
-    void        updateHash(const PronunciationSuffix& s) const {
+
+    void updateHash(const PronunciationSuffix& s) const {
         hash_ = (hash_ << 5) | (hash_ >> 27);
         hash_ ^= PronunciationSuffix::Hash(model_)(s);
     }
+
     void updateHash() const {
         verify(consolidation_ >= sorted);
         hash_ = 0;
@@ -653,9 +657,11 @@ std::pair<Bliss::Phoneme::Id, Bliss::Phoneme::Id> StateTree::describeRootState(S
  */
 struct StateTree::BuildRequest {
     Depth depth;
-    enum RequestType { unknown,
-                       batchRequest,
-                       leapRequest };
+    enum RequestType {
+        unknown,
+        batchRequest,
+        leapRequest
+    };
     RequestType type;
     BuildRequest(RequestType t)
             : type(t) {}
@@ -789,10 +795,13 @@ class StateTree::StraightRequestQueue : public RequestQueue {
 public:
     StraightRequestQueue(StateTree*);
     virtual ~StraightRequestQueue() {}
+
     virtual void submit(BatchRequest*);
-    virtual u32  size() const {
+
+    virtual u32 size() const {
         return queue_.size();
     }
+
     virtual BuildRequest* pop();
 };
 
@@ -833,10 +842,13 @@ class StateTree::RecombiningRequestQueue : public RequestQueue {
 public:
     RecombiningRequestQueue(StateTree*);
     virtual ~RecombiningRequestQueue() {}
+
     virtual void submit(BatchRequest*);
-    virtual u32  size() const {
+
+    virtual u32 size() const {
         return size_;
     }
+
     virtual BuildRequest* pop();
 };
 
@@ -1323,7 +1335,9 @@ void StateTree::createSecondOrderBatches() {
 struct StateTree::LevelStatistics {
     u32 nStates, nChildren, nExits;
     LevelStatistics()
-            : nStates(0), nChildren(0), nExits(0) {}
+            : nStates(0),
+              nChildren(0),
+              nExits(0) {}
 };
 
 void StateTree::logStatistics() const {
diff --git a/src/Search/StateTree.hh b/src/Search/StateTree.hh
index a588caecb..67c13a9b9 100644
--- a/src/Search/StateTree.hh
+++ b/src/Search/StateTree.hh
@@ -134,7 +134,8 @@ public:
         ModelIndex transitionModelIndex : TM_WIDTH;
 
         StateDesc()
-                : acousticModel(0), transitionModelIndex(0) {
+                : acousticModel(0),
+                  transitionModelIndex(0) {
         }
 
         StateDesc(ModelIndex ami, TransitionModelIndex tmi)
diff --git a/src/Search/StateTreeIo.cc b/src/Search/StateTreeIo.cc
index 8e98746db..64694b76d 100644
--- a/src/Search/StateTreeIo.cc
+++ b/src/Search/StateTreeIo.cc
@@ -108,7 +108,8 @@ void StateTreeIo::write<StateTree::CoarticulationStructure::PhonemePair>(
 const std::string StateTreeIo::magic = "SPRINT-ST";
 
 StateTreeIo::StateTreeIo(Bliss::LexiconRef lexicon, Am::AcousticModelRef acousticModel)
-        : lexicon_(lexicon), acousticModel_(acousticModel) {
+        : lexicon_(lexicon),
+          acousticModel_(acousticModel) {
     getDependencies();
 }
 
diff --git a/src/Search/TreeBuilder.cc b/src/Search/TreeBuilder.cc
index d114ec623..cdc29b156 100644
--- a/src/Search/TreeBuilder.cc
+++ b/src/Search/TreeBuilder.cc
@@ -20,6 +20,7 @@
 #include <Bliss/Lexicon.hh>
 #include <Core/Configuration.hh>
 
+#include "ArchiveIO.hh"
 #include "Helpers.hh"
 #include "PersistentStateTree.hh"
 #include "StateTree.hh"
diff --git a/src/Search/TreeBuilder.hh b/src/Search/TreeBuilder.hh
index 78b0c829d..93f550454 100644
--- a/src/Search/TreeBuilder.hh
+++ b/src/Search/TreeBuilder.hh
@@ -81,6 +81,7 @@ protected:
     struct HMMSequence {
         HMMSequence()
                 : length(0) {}
+
         enum {
             MaxLength = 12
         };
diff --git a/src/Search/TreeStructure.cc b/src/Search/TreeStructure.cc
index 1ac4d2b3c..1042c9a49 100644
--- a/src/Search/TreeStructure.cc
+++ b/src/Search/TreeStructure.cc
@@ -17,7 +17,9 @@
 
 namespace Search {
 HMMStateNetwork::HMMStateNetwork()
-        : subTreeManager_(subTreeListBatches_, states_), edgeTargetManager_(edgeTargetBatches_, states_), tree_() {
+        : subTreeManager_(subTreeListBatches_, states_),
+          edgeTargetManager_(edgeTargetBatches_, states_),
+          tree_() {
     // The zero index is reserved as "invalid", so push one dummy item into all arrays
     states_.push_back(HMMState());
     subTreeListBatches_.push_back(0);
@@ -120,7 +122,7 @@ bool HMMStateNetwork::write(Core::MappedArchiveWriter writer) {
 }
 
 bool HMMStateNetwork::read(Core::MappedArchiveReader reader) {
-    u32 version = 0;
+    u32 version = 0u;
     reader >> version;
 
     if (version == DiskFormatVersionV1) {
@@ -209,7 +211,7 @@ HMMStateNetwork::CleanupResult HMMStateNetwork::cleanup(std::list<Search::StateI
 
     Core::Application::us()->log() << "total nodes before cleanup: " << states_.size();
 
-    CleanupResult       ret;
+    CleanupResult       ret(states_.size());
     CountSizeTreeWalker counter(*this);
     if (onlyBatches) {
         for (StateId node = 1; node < states_.size(); ++node)
@@ -276,7 +278,9 @@ HMMStateNetwork::CleanupResult HMMStateNetwork::cleanup(std::list<Search::StateI
                 }
             }
         }
-        std::vector<StateId>        ordered;
+
+        std::vector<StateId> ordered;
+        ordered.reserve(states_.size());
         std::unordered_set<StateId> had;
 
         {
diff --git a/src/Search/TreeStructure.hh b/src/Search/TreeStructure.hh
index 4d781ce1e..db2729d13 100644
--- a/src/Search/TreeStructure.hh
+++ b/src/Search/TreeStructure.hh
@@ -231,13 +231,13 @@ public:
 
     /// Do not keep pointers to the returned state, the address may change when the network is manipulated
     inline_ HMMState& state(StateId state) {
-        verify_(state > 0 && state < (int)states_.size());
+        verify_(state >= 0 && state < (int)states_.size());
         return states_[state];
     }
 
     /// Do not keep pointers to the returned state, the address may change when the network is manipulated
     inline const HMMState& state(StateId state) const {
-        verify_(state > 0 && state < (int)states_.size());
+        verify_(state >= 0 && state < (int)states_.size());
         return states_[state];
     }
 
@@ -268,6 +268,9 @@ public:
         Core::HashMap<StateId, StateId> nodeMap;
 
         std::set<StateId> mapNodes(const std::set<StateId>& nodes) const;
+        CleanupResult(size_t nstates) {
+            nodeMap.reserve(nstates);
+        }
     };
 
     /// Completely removes all nodes that are not reachable from the given start-nodes, compressing the structure
@@ -329,11 +332,13 @@ public:
 
     private:
         ChangePlan(HMMStateNetwork& _structure, StateId _node)
-                : node(_node), structure(&_structure) {
+                : node(_node),
+                  structure(&_structure) {
         }
 
         ChangePlan()
-                : node(0), structure(0) {
+                : node(0),
+                  structure(0) {
         }
 
         std::set<int> add;
diff --git a/src/Search/TreeWalker.hh b/src/Search/TreeWalker.hh
index a373d7c67..61501b8db 100644
--- a/src/Search/TreeWalker.hh
+++ b/src/Search/TreeWalker.hh
@@ -29,6 +29,7 @@ class SubTreeWalker : public Base {
 public:
     SubTreeWalker(HMMStateNetwork& _tree)
             : tree(_tree) {
+        reserve();
     }
 
     /// Visits the nodes and all its followers, in the correct order
@@ -53,12 +54,18 @@ public:
             this->nodeVisited(node, token);
     }
 
+    void reserve() {
+        Base::visited.reserve(tree.stateCount());
+    }
+
     HMMStateNetwork& tree;
 };
 
 struct CountSizeTreeWalkerBackend {
     CountSizeTreeWalkerBackend()
-            : totalVisited(0), stopAtVisited(false), visitedFinalOutputs(0) {
+            : totalVisited(0),
+              stopAtVisited(false),
+              visitedFinalOutputs(0) {
     }
 
     void nodeVisited(StateId /*node*/, int /*token*/) {
diff --git a/src/Search/Wfst/AutomatonAdapter.hh b/src/Search/Wfst/AutomatonAdapter.hh
index 42929fc73..fb192ecc7 100644
--- a/src/Search/Wfst/AutomatonAdapter.hh
+++ b/src/Search/Wfst/AutomatonAdapter.hh
@@ -39,7 +39,9 @@ public:
     typedef Automaton*           AutomatonRef;
 
     AutomatonAdapter(const Automaton* f)
-            : f_(f), nArcs_(0), nEpsArcs_(0) {}
+            : f_(f),
+              nArcs_(0),
+              nEpsArcs_(0) {}
 
     StateId        initialStateId() const;
     bool           isFinal(StateId s) const;
@@ -50,12 +52,15 @@ public:
     OpenFst::Label arcInput(const Arc& arc) const;
     OpenFst::Label arcOutput(const Arc& arc) const;
     StateId        arcTarget(const Arc& arc) const;
-    u32            nStates() const;
-    u32            nArcs() const {
+
+    u32 nStates() const;
+
+    u32 nArcs() const {
         if (!nArcs_)
             countArcs();
         return nArcs_;
     }
+
     u32 nEpsilonArcs() const {
         if (!nArcs_)
             countArcs();
diff --git a/src/Search/Wfst/BookKeeping.hh b/src/Search/Wfst/BookKeeping.hh
index d6cb37977..b4c6c6329 100644
--- a/src/Search/Wfst/BookKeeping.hh
+++ b/src/Search/Wfst/BookKeeping.hh
@@ -120,15 +120,25 @@ protected:
         bool                 active;
         bool                 used;
         Trace()
-                : active(false), used(false) {}
+                : active(false),
+                  used(false) {}
         Trace(const TraceRef _predecessor, Label _output, TimeframeIndex _time,
               Score _score, bool _wordEnd)
-                : predecessor(_predecessor), sibling(InvalidTraceRef), output(_output), input(0), time(_time), score(_score), wordEnd(_wordEnd), active(true), used(true) {}
+                : predecessor(_predecessor),
+                  sibling(InvalidTraceRef),
+                  output(_output),
+                  input(0),
+                  time(_time),
+                  score(_score),
+                  wordEnd(_wordEnd),
+                  active(true),
+                  used(true) {}
     };
 
 public:
     FirstBestTraceRecorder(bool createLattice = false)
-            : next_(0), createLattice_(createLattice) {}
+            : next_(0),
+              createLattice_(createLattice) {}
     virtual ~FirstBestTraceRecorder() {}
 
     void setCreateLattice(bool create) {
diff --git a/src/Search/Wfst/Builder.hh b/src/Search/Wfst/Builder.hh
index 82ea808ce..4d08b4013 100644
--- a/src/Search/Wfst/Builder.hh
+++ b/src/Search/Wfst/Builder.hh
@@ -89,7 +89,9 @@ public:
 
 public:
     Operation(const Core::Configuration& c, Resources& r)
-            : Core::Component(c), resources_(r), timerChannel_(config, "time") {}
+            : Core::Component(c),
+              resources_(r),
+              timerChannel_(config, "time") {}
     /**
      * number of automata required as input
      */
@@ -144,7 +146,8 @@ protected:
 class SleeveOperation : public virtual Operation {
 public:
     SleeveOperation(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), input_(0) {}
+            : Operation(c, r),
+              input_(0) {}
     virtual u32 nInputAutomata() const {
         return 1;
     }
@@ -176,9 +179,11 @@ protected:
         outputLemmas,
         outputSyntacticTokens
     };
+
     static const Core::ParameterChoice paramOutputType;
     static const Core::Choice          choiceOutputType;
-    OutputType                         outputType() const {
+
+    OutputType outputType() const {
         return static_cast<OutputType>(paramOutputType(config));
     }
 
@@ -220,8 +225,10 @@ protected:
 public:
     LabelTypeDependent(const Core::Configuration& c)
             : Core::Configurable(c) {}
-    enum LabelType { Input,
-                     Output };
+    enum LabelType {
+        Input,
+        Output
+    };
     LabelType labelType() const {
         return static_cast<LabelType>(paramLabel(config));
     }
@@ -238,7 +245,8 @@ protected:
 
 public:
     DisambiguatorDependentOperation(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), nDisambiguators_(paramDisambiguators(config)) {}
+            : Operation(c, r),
+              nDisambiguators_(paramDisambiguators(config)) {}
     virtual u32  nInputAutomata() const;
     virtual bool addInput(AutomatonRef f);
 };
@@ -249,7 +257,8 @@ public:
 class Pop : public SleeveOperation {
 public:
     Pop(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r) {}
+            : Operation(c, r),
+              SleeveOperation(c, r) {}
     virtual bool hasOutput() const {
         return false;
     }
diff --git a/src/Search/Wfst/ComposedNetwork.cc b/src/Search/Wfst/ComposedNetwork.cc
index 75ad2e98e..c8a902629 100644
--- a/src/Search/Wfst/ComposedNetwork.cc
+++ b/src/Search/Wfst/ComposedNetwork.cc
@@ -45,7 +45,13 @@ const Core::ParameterChoice ComposedNetwork::paramGrammarType_(
         AbstractGrammarFst::TypeVector);
 
 ComposedNetwork::ComposedNetwork(const Core::Configuration& c)
-        : Precursor(c), l_(0), r_(0), stateTable_(0), resetCount_(0), resetInterval_(paramResetInterval_(config)), cacheSize_(paramStateCache_(config)) {
+        : Precursor(c),
+          l_(0),
+          r_(0),
+          stateTable_(0),
+          resetCount_(0),
+          resetInterval_(paramResetInterval_(config)),
+          cacheSize_(paramStateCache_(config)) {
 }
 
 ComposedNetwork::~ComposedNetwork() {
diff --git a/src/Search/Wfst/ComposedNetwork.hh b/src/Search/Wfst/ComposedNetwork.hh
index 1ed48f439..b88dc5c5b 100644
--- a/src/Search/Wfst/ComposedNetwork.hh
+++ b/src/Search/Wfst/ComposedNetwork.hh
@@ -46,21 +46,28 @@ protected:
 public:
     ComposedNetwork(const Core::Configuration&);
     virtual ~ComposedNetwork();
+
     virtual bool init();
-    virtual u32  nStates() const {
+
+    virtual u32 nStates() const {
         return 0;
     }
+
     static bool hasGrammarState() {
         return true;
     }
+
     StateIndex grammarState(StateIndex s) const {
         return stateTable_->rightState(s);
     }
+
     StateIndex lexiconState(StateIndex s) const {
         return stateTable_->leftState(s);
     }
+
     virtual void reset();
-    void         setLexicon(Bliss::LexiconRef lexicon) {
+
+    void setLexicon(Bliss::LexiconRef lexicon) {
         lexicon_ = lexicon;
     }
 
diff --git a/src/Search/Wfst/CompressedNetwork.cc b/src/Search/Wfst/CompressedNetwork.cc
index 00bd2c070..5ed17449b 100644
--- a/src/Search/Wfst/CompressedNetwork.cc
+++ b/src/Search/Wfst/CompressedNetwork.cc
@@ -24,8 +24,10 @@
 using namespace Search::Wfst;
 using Search::Score;
 
-enum AutomatonType { AutomatonTypeFsa,
-                     AutomatonTypeFst };
+enum AutomatonType {
+    AutomatonTypeFsa,
+    AutomatonTypeFst
+};
 
 template<class Automaton>
 class CompressedNetwork::Builder {
@@ -200,7 +202,13 @@ const CompressedNetwork::ArcIndex CompressedNetwork::InvalidArcIndex = Core::Typ
 const Score                       CompressedNetwork::NonFinalWeight  = static_cast<Score>(0xffffffff);
 
 CompressedNetwork::CompressedNetwork(const Core::Configuration& c, bool loadNetwork)
-        : Core::Component(c), states_(0), arcs_(0), epsilonArcs_(0), mmap_(0), mmapSize_(0), loadNetwork_(loadNetwork) {
+        : Core::Component(c),
+          states_(0),
+          arcs_(0),
+          epsilonArcs_(0),
+          mmap_(0),
+          mmapSize_(0),
+          loadNetwork_(loadNetwork) {
 }
 
 CompressedNetwork::~CompressedNetwork() {
diff --git a/src/Search/Wfst/CompressedNetwork.hh b/src/Search/Wfst/CompressedNetwork.hh
index 8c77c8790..880c536e5 100644
--- a/src/Search/Wfst/CompressedNetwork.hh
+++ b/src/Search/Wfst/CompressedNetwork.hh
@@ -55,7 +55,10 @@ public:
         InternalLabel ilabel;     // input;
         Arc(Fsa::StateId _target,
             Label _input, Label _output, Score _weight)
-                : weight(_weight), nextstate(_target), olabel(_output), ilabel(_input) {}
+                : weight(_weight),
+                  nextstate(_target),
+                  olabel(_output),
+                  ilabel(_input) {}
     };
     typedef Arc* Arcs;
 
@@ -64,7 +67,9 @@ public:
         InternalLabel olabel;     // output;
         Fsa::StateId  nextstate;  // target;
         EpsilonArc(Fsa::StateId _target, Label _output, Score _weight)
-                : weight(_weight), olabel(_output), nextstate(_target) {}
+                : weight(_weight),
+                  olabel(_output),
+                  nextstate(_target) {}
     };
     typedef EpsilonArc* EpsilonArcs;
 
@@ -76,7 +81,11 @@ public:
         // bool final;
         Score weight;
         State(bool f = false, Score weight = 0)
-                : begin(InvalidArcIndex), epsilonArcsBegin(InvalidArcIndex), nArcs(0), nEpsilonArcs(0), weight(f ? weight : NonFinalWeight) {}
+                : begin(InvalidArcIndex),
+                  epsilonArcsBegin(InvalidArcIndex),
+                  nArcs(0),
+                  nEpsilonArcs(0),
+                  weight(f ? weight : NonFinalWeight) {}
     };
     typedef State* States;
 
diff --git a/src/Search/Wfst/ContextTransducerBuilder.cc b/src/Search/Wfst/ContextTransducerBuilder.cc
index 2d5e21df5..6a9dfc8ea 100644
--- a/src/Search/Wfst/ContextTransducerBuilder.cc
+++ b/src/Search/Wfst/ContextTransducerBuilder.cc
@@ -88,7 +88,10 @@ class ContextTransducerBuilder::Builder {
 
         TriphoneContextAndBoundary(Bliss::Phoneme::Id h, Bliss::Phoneme::Id c,
                                    u8 disambiguator, bool boundary)
-                : boundary_(boundary), disambiguator_(disambiguator), history_(h), central_(c) {}
+                : boundary_(boundary),
+                  disambiguator_(disambiguator),
+                  history_(h),
+                  central_(c) {}
     };
 
 protected:
@@ -104,21 +107,18 @@ class ContextTransducerBuilder::Builder {
     OpenFst::Label   getAllophoneLabel(const Allophone* allophone);
     OpenFst::Label   getAllophoneDisambiguator(u32 disambiguator);
     OpenFst::Label   getPhoneLabel(Bliss::Phoneme::Id phone, bool initialPhone) const;
-    void             addArc(OpenFst::StateId from, OpenFst::StateId to,
-                            const Allophone* input, Bliss::Phoneme::Id output,
-                            bool initialPhone);
-    void             addArc(OpenFst::StateId from, OpenFst::StateId to,
-                            Fsa::LabelId input, Fsa::LabelId output);
-    void             addOutputDisambiguatorArc(OpenFst::StateId from, OpenFst::StateId to,
-                                               Fsa::LabelId input, u32 disambiguator);
-    void             addWordDisambiguatorArc(OpenFst::StateId from, OpenFst::StateId to,
-                                             Fsa::LabelId input, u32 disambiguator);
-    void             addInputDisambiguatorArc(OpenFst::StateId from, OpenFst::StateId to,
-                                              u32 disambiguator, Fsa::LabelId output);
-    void             addDisambiguatorArcs(OpenFst::StateId from, OpenFst::StateId to, const Allophone* input = 0);
-    bool             isCiPhone(Bliss::Phoneme::Id phone) const {
+
+    void addArc(OpenFst::StateId from, OpenFst::StateId to, const Allophone* input, Bliss::Phoneme::Id output, bool initialPhone);
+    void addArc(OpenFst::StateId from, OpenFst::StateId to, Fsa::LabelId input, Fsa::LabelId output);
+    void addOutputDisambiguatorArc(OpenFst::StateId from, OpenFst::StateId to, Fsa::LabelId input, u32 disambiguator);
+    void addWordDisambiguatorArc(OpenFst::StateId from, OpenFst::StateId to, Fsa::LabelId input, u32 disambiguator);
+    void addInputDisambiguatorArc(OpenFst::StateId from, OpenFst::StateId to, u32 disambiguator, Fsa::LabelId output);
+    void addDisambiguatorArcs(OpenFst::StateId from, OpenFst::StateId to, const Allophone* input = 0);
+
+    bool isCiPhone(Bliss::Phoneme::Id phone) const {
         return ciPhones_.find(phone) != ciPhones_.end();
     }
+
     OpenFst::Label getSequenceEndSymbol() const {
         if (sequenceEndSymbol_.empty()) {
             return OpenFst::Epsilon;
@@ -163,7 +163,11 @@ class ContextTransducerBuilder::Builder {
 
 ContextTransducerBuilder::Builder::Builder(Core::Ref<const Am::AcousticModel> model,
                                            Core::Ref<const Bliss::Lexicon>    lexicon)
-        : model_(model), nonWordTokens_(0), disambiguatorOffset_(-1), nWordDisambiguators_(-1), initialPhoneOffset_(-1) {
+        : model_(model),
+          nonWordTokens_(0),
+          disambiguatorOffset_(-1),
+          nWordDisambiguators_(-1),
+          initialPhoneOffset_(-1) {
     allophones_        = model_->allophoneAlphabet();
     allophoneList_     = &model_->allophoneAlphabet()->allophones();
     phonemes_          = lexicon->phonemeInventory()->phonemeAlphabet();
@@ -707,7 +711,8 @@ class ContextTransducerBuilder::AcrossWordBuilder : public ContextTransducerBuil
 class ContextTransducerBuilder::NonDeterministicBuilder : public ContextTransducerBuilder::Builder {
 public:
     NonDeterministicBuilder(Core::Ref<const Am::AcousticModel> m, Core::Ref<const Bliss::Lexicon> l)
-            : Builder(m, l), iInitial_(OpenFst::InvalidStateId) {}
+            : Builder(m, l),
+              iInitial_(OpenFst::InvalidStateId) {}
 
     virtual void prepare() {
         stateMap_.clear();
@@ -785,7 +790,8 @@ class ContextTransducerBuilder::NonDeterministicBuilder : public ContextTransduc
 class ContextTransducerBuilder::WithinWordBuilder : public ContextTransducerBuilder::Builder {
 public:
     WithinWordBuilder(Core::Ref<const Am::AcousticModel> m, Core::Ref<const Bliss::Lexicon> l)
-            : Builder(m, l), exploitDisambiguators_(false) {}
+            : Builder(m, l),
+              exploitDisambiguators_(false) {}
 
     void setExploitDisambiguators(bool exploit) {
         exploitDisambiguators_ = exploit;
diff --git a/src/Search/Wfst/CreateOperations.cc b/src/Search/Wfst/CreateOperations.cc
index b3a552189..2f6bb29c4 100644
--- a/src/Search/Wfst/CreateOperations.cc
+++ b/src/Search/Wfst/CreateOperations.cc
@@ -460,8 +460,7 @@ OpenFst::Label AddNonWordTokens::getLabel(const Bliss::Lemma* lemma) const {
         case outputLemmaPronunciations: {
             verify(lemma->nPronunciations() == 1);
             Bliss::Lemma::LemmaPronunciationRange pron = lemma->pronunciations();
-            label                                      = resources_.lexicon()->lemmaPronunciationAlphabet()->index(
-                    pron.first);
+            label                                      = resources_.lexicon()->lemmaPronunciationAlphabet()->index(pron.first);
         } break;
         case outputSyntacticTokens: {
             const Bliss::SyntacticTokenSequence& tokens = lemma->syntacticTokenSequence();
diff --git a/src/Search/Wfst/CreateOperations.hh b/src/Search/Wfst/CreateOperations.hh
index 0c4818465..fca27f8c9 100644
--- a/src/Search/Wfst/CreateOperations.hh
+++ b/src/Search/Wfst/CreateOperations.hh
@@ -36,7 +36,8 @@ protected:
 
 public:
     BuildGrammar(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), OutputTypeDependent(c) {}
+            : Operation(c, r),
+              OutputTypeDependent(c) {}
 
 protected:
     virtual AutomatonRef process();
@@ -63,7 +64,9 @@ public:
 
 public:
     BuildLexicon(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), DisambiguatorDependentOperation(c, r), OutputTypeDependent(c) {}
+            : Operation(c, r),
+              DisambiguatorDependentOperation(c, r),
+              OutputTypeDependent(c) {}
     virtual bool consumeInput() const {
         return false;
     }
@@ -89,7 +92,8 @@ public:
 class BuildOldLexicon : public BuildLexicon {
 public:
     BuildOldLexicon(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), BuildLexicon(c, r) {}
+            : Operation(c, r),
+              BuildLexicon(c, r) {}
 
 protected:
     virtual AutomatonRef process();
@@ -106,7 +110,8 @@ public:
 class CloseLexicon : public SleeveOperation {
 public:
     CloseLexicon(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r) {}
+            : Operation(c, r),
+              SleeveOperation(c, r) {}
 
 protected:
     virtual AutomatonRef process();
@@ -119,15 +124,18 @@ public:
 
 class LemmaMapping : public DisambiguatorDependentOperation {
 protected:
-    enum MapType { LemmaPronunciationToLemma,
-                   LemmaToSyntacticToken };
+    enum MapType {
+        LemmaPronunciationToLemma,
+        LemmaToSyntacticToken
+    };
     static const Core::Choice          mapChoice;
     static const Core::ParameterChoice paramMapType;
     static const Core::ParameterFloat  paramScale;
 
 public:
     LemmaMapping(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), DisambiguatorDependentOperation(c, r) {}
+            : Operation(c, r),
+              DisambiguatorDependentOperation(c, r) {}
     virtual u32 nInputAutomata() const {
         return 0;
     }
@@ -147,7 +155,8 @@ protected:
 
 public:
     AddPronunciationWeight(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), DisambiguatorDependentOperation(c, r) {}
+            : Operation(c, r),
+              DisambiguatorDependentOperation(c, r) {}
     virtual u32 nInputAutomata() const {
         return 0;
     }
@@ -167,7 +176,8 @@ public:
 class RestoreOutputSymbols : public SleeveOperation {
 public:
     RestoreOutputSymbols(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r) {}
+            : Operation(c, r),
+              SleeveOperation(c, r) {}
 
 protected:
     virtual AutomatonRef process();
@@ -184,7 +194,9 @@ public:
 class RemovePhoneDisambiguators : public DisambiguatorDependentOperation, public SleeveOperation {
 public:
     RemovePhoneDisambiguators(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), DisambiguatorDependentOperation(c, r), SleeveOperation(c, r) {}
+            : Operation(c, r),
+              DisambiguatorDependentOperation(c, r),
+              SleeveOperation(c, r) {}
 
 protected:
     virtual u32 nInputAutomata() const {
@@ -206,7 +218,8 @@ public:
 class PushOutputLabels : public SleeveOperation {
 public:
     PushOutputLabels(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r) {}
+            : Operation(c, r),
+              SleeveOperation(c, r) {}
 
 protected:
     virtual AutomatonRef process();
@@ -222,7 +235,8 @@ class CheckLabels : public SleeveOperation {
 
 public:
     CheckLabels(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r) {}
+            : Operation(c, r),
+              SleeveOperation(c, r) {}
 
 protected:
     virtual AutomatonRef process();
@@ -250,7 +264,10 @@ class AddNonWordTokens : public OutputTypeDependent, public SleeveOperation {
 
 public:
     AddNonWordTokens(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), OutputTypeDependent(c), SleeveOperation(c, r), renormalize_(paramRenormalize(Operation::config)) {}
+            : Operation(c, r),
+              OutputTypeDependent(c),
+              SleeveOperation(c, r),
+              renormalize_(paramRenormalize(Operation::config)) {}
     virtual u32 nInputAutomata() const {
         return SleeveOperation::nInputAutomata();
     }
@@ -281,7 +298,8 @@ public:
 class RemoveEmptyPath : public SleeveOperation {
 public:
     RemoveEmptyPath(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r) {}
+            : Operation(c, r),
+              SleeveOperation(c, r) {}
 
 protected:
     virtual AutomatonRef process();
@@ -303,7 +321,9 @@ class CreateSubwordGrammar : public OutputTypeDependent, public SleeveOperation
 
 public:
     CreateSubwordGrammar(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), OutputTypeDependent(c), SleeveOperation(c, r) {}
+            : Operation(c, r),
+              OutputTypeDependent(c),
+              SleeveOperation(c, r) {}
 
 protected:
     virtual AutomatonRef             process();
@@ -324,7 +344,8 @@ public:
 class ContextBuilder : public SleeveOperation {
 public:
     ContextBuilder(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r) {}
+            : Operation(c, r),
+              SleeveOperation(c, r) {}
     bool consumeInput() const {
         return false;
     }
@@ -345,7 +366,8 @@ public:
 class HmmBuilder : public DisambiguatorDependentOperation {
 public:
     HmmBuilder(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), DisambiguatorDependentOperation(c, r) {}
+            : Operation(c, r),
+              DisambiguatorDependentOperation(c, r) {}
     virtual bool consumeInput() const {
         return false;
     }
@@ -369,7 +391,9 @@ protected:
 
 public:
     CreateStateSequences(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r), filename_(paramFilename(config)) {}
+            : Operation(c, r),
+              SleeveOperation(c, r),
+              filename_(paramFilename(config)) {}
 
 protected:
     virtual bool         precondition() const;
@@ -388,7 +412,8 @@ protected:
 
 public:
     NonWordDependentOperation(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), addNonWords_(paramAddNonWords(c)) {}
+            : Operation(c, r),
+              addNonWords_(paramAddNonWords(c)) {}
 
 protected:
     u32  numSpecialSymbols() const;
@@ -405,7 +430,9 @@ protected:
 
 public:
     Factorize(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r), NonWordDependentOperation(c, r) {}
+            : Operation(c, r),
+              SleeveOperation(c, r),
+              NonWordDependentOperation(c, r) {}
 
 protected:
     virtual AutomatonRef process();
@@ -425,7 +452,9 @@ class ExpandStates : public SleeveOperation, public NonWordDependentOperation {
 
 public:
     ExpandStates(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r), NonWordDependentOperation(c, r) {}
+            : Operation(c, r),
+              SleeveOperation(c, r),
+              NonWordDependentOperation(c, r) {}
 
 protected:
     virtual AutomatonRef process();
@@ -454,10 +483,13 @@ protected:
 public:
     ConvertStateSequences(const Core::Configuration& c, Resources& r)
             : Operation(c, r) {}
+
     virtual bool precondition() const;
-    virtual u32  nInputAutomata() const {
+
+    virtual u32 nInputAutomata() const {
         return 0;
     }
+
     virtual bool hasOutput() const {
         return false;
     }
diff --git a/src/Search/Wfst/DynamicLmFst.cc b/src/Search/Wfst/DynamicLmFst.cc
index 219eb19a9..8b7b0f7e6 100644
--- a/src/Search/Wfst/DynamicLmFst.cc
+++ b/src/Search/Wfst/DynamicLmFst.cc
@@ -24,7 +24,8 @@ class DynamicLmFstScoreCache {
 public:
     typedef std::vector<float> Cache;
     DynamicLmFstScoreCache(size_t maxElements)
-            : maxElements_(maxElements), elements_(0) {}
+            : maxElements_(maxElements),
+              elements_(0) {}
     ~DynamicLmFstScoreCache();
     Cache* Get(u32 s) {
         if (s < data_.size()) {
@@ -95,7 +96,15 @@ void DynamicLmFstScoreCache::CleanCache(bool freeRecent) {
 }
 
 DynamicLmFstImpl::DynamicLmFstImpl(const DynamicLmFstOptions& opts)
-        : CacheImpl(opts), lm_(opts.lm), lemmas_(lm_->lexicon()->lemmaAlphabet()), wpScale_(opts.pronunciationScale), nCalculated_(0), nCached_(0), silenceWeight_(opts.silenceWeight), batchRequest_(0), scoreCache_(new DynamicLmFstScoreCache(MaxScoreCaches)) {
+        : CacheImpl(opts),
+          lm_(opts.lm),
+          lemmas_(lm_->lexicon()->lemmaAlphabet()),
+          wpScale_(opts.pronunciationScale),
+          nCalculated_(0),
+          nCached_(0),
+          silenceWeight_(opts.silenceWeight),
+          batchRequest_(0),
+          scoreCache_(new DynamicLmFstScoreCache(MaxScoreCaches)) {
     require(lm_);
     SetType("dynamic-lm");
     OpenFst::SymbolTable* symbols = 0;
@@ -119,7 +128,19 @@ DynamicLmFstImpl::DynamicLmFstImpl(const DynamicLmFstOptions& opts)
 }
 
 DynamicLmFstImpl::DynamicLmFstImpl(const DynamicLmFstImpl& impl)
-        : CacheImpl(impl), lm_(impl.lm_), lemmas_(impl.lemmas_), lemmaProns_(impl.lemmaProns_), wpScale_(impl.wpScale_), nLabels_(impl.nLabels_), nArcs_(impl.nArcs_), nCalculated_(0), nCached_(0), silence_(impl.silence_), silenceLabel_(impl.silenceLabel_), batchRequest_(0), scoreCache_(new DynamicLmFstScoreCache(MaxScoreCaches)) {
+        : CacheImpl(impl),
+          lm_(impl.lm_),
+          lemmas_(impl.lemmas_),
+          lemmaProns_(impl.lemmaProns_),
+          wpScale_(impl.wpScale_),
+          nLabels_(impl.nLabels_),
+          nArcs_(impl.nArcs_),
+          nCalculated_(0),
+          nCached_(0),
+          silence_(impl.silence_),
+          silenceLabel_(impl.silenceLabel_),
+          batchRequest_(0),
+          scoreCache_(new DynamicLmFstScoreCache(MaxScoreCaches)) {
     SetType("dynamic-lm");
     SetProperties(impl.Properties(), FstLib::kCopyProperties);
     SetInputSymbols(impl.InputSymbols());
diff --git a/src/Search/Wfst/DynamicLmFst.hh b/src/Search/Wfst/DynamicLmFst.hh
index 07ed615db..00e12bf12 100644
--- a/src/Search/Wfst/DynamicLmFst.hh
+++ b/src/Search/Wfst/DynamicLmFst.hh
@@ -33,7 +33,10 @@ struct DynamicLmFstOptions : public FstLib::CacheOptions {
     DynamicLmFstOptions(Core::Ref<Lm::LanguageModel> languageModel = Core::Ref<Lm::LanguageModel>(),
                         OutputType wordType = OutputLemma, f32 pronScale = 0.0,
                         OpenFst::Weight silWeight = OpenFst::Weight::One())
-            : lm(languageModel), outputType(wordType), pronunciationScale(pronScale), silenceWeight(silWeight) {}
+            : lm(languageModel),
+              outputType(wordType),
+              pronunciationScale(pronScale),
+              silenceWeight(silWeight) {}
     DynamicLmFstOptions(const FstLib::CacheOptions& opts)
             : FstLib::CacheOptions(opts) {}
     Core::Ref<Lm::LanguageModel> lm;
@@ -260,7 +263,8 @@ public:
             : CacheStateIterator<Search::Wfst::DynamicLmFst>(fst, const_cast<Search::Wfst::DynamicLmFstImpl*>(fst.GetImpl())) {}
 
 private:
-    DISALLOW_COPY_AND_ASSIGN(StateIterator);
+    StateIterator(StateIterator&) = delete;
+    void operator=(StateIterator) = delete;
 };
 
 /**
@@ -275,7 +279,12 @@ public:
     typedef Arc::StateId                    StateId;
 
     ArcIterator(const Search::Wfst::DynamicLmFst& fst, StateId s)
-            : fst_(fst), state_(s), pos_(1), end_(fst.NumArcs(s)), flags_(FstLib::kArcValueFlags), scores_(0) {
+            : fst_(fst),
+              state_(s),
+              pos_(1),
+              end_(fst.NumArcs(s)),
+              flags_(FstLib::kArcValueFlags),
+              scores_(0) {
         if ((haveCachedArcs_ = fst_.GetImpl()->HasArcs(s))) {
             fst_.GetImpl()->InitArcIterator(s, &cachedArcs_);
             end_ = cachedArcs_.narcs;
@@ -381,7 +390,8 @@ private:
     bool                                                      haveCachedArcs_;
     mutable const Search::Wfst::DynamicLmFstImpl::ScoreCache* scores_;
 
-    DISALLOW_COPY_AND_ASSIGN(ArcIterator);
+    ArcIterator(ArcIterator&)   = delete;
+    void operator=(ArcIterator) = delete;
 };
 
 }  // namespace fst
@@ -403,10 +413,20 @@ public:
     typedef Arc::Weight       Weight;
 
     DynamicLmFstMatcher(const DynamicLmFst& fst, FstLib::MatchType matchType)
-            : fst_(fst.Copy()), arcRead_(true), aiter_(0), mtype_(matchType), state_(FstLib::kNoStateId), loop_(FstLib::kNoLabel, 0, Weight::One(), FstLib::kNoStateId) {}
+            : fst_(fst.Copy()),
+              arcRead_(true),
+              aiter_(0),
+              mtype_(matchType),
+              state_(FstLib::kNoStateId),
+              loop_(FstLib::kNoLabel, 0, Weight::One(), FstLib::kNoStateId) {}
 
     DynamicLmFstMatcher(const DynamicLmFstMatcher& m, bool safe)
-            : fst_(m.fst_->Copy(safe)), arcRead_(true), aiter_(0), mtype_(m.mtype_), state_(FstLib::kNoStateId), loop_(m.loop_) {}
+            : fst_(m.fst_->Copy(safe)),
+              arcRead_(true),
+              aiter_(0),
+              mtype_(m.mtype_),
+              state_(FstLib::kNoStateId),
+              loop_(m.loop_) {}
 
     virtual ~DynamicLmFstMatcher() {
         delete aiter_;
diff --git a/src/Search/Wfst/ExpandingFsaSearch.cc b/src/Search/Wfst/ExpandingFsaSearch.cc
index 73776d8d1..d67e6b1b1 100644
--- a/src/Search/Wfst/ExpandingFsaSearch.cc
+++ b/src/Search/Wfst/ExpandingFsaSearch.cc
@@ -123,7 +123,14 @@ const Core::ParameterChoice ExpandingFsaSearch::paramLatticeType(
         "lattice-type", &choiceLatticeType, "type of generated lattices", LatticeTraceRecorder::HmmLattice);
 
 ExpandingFsaSearch::ExpandingFsaSearch(const Core::Configuration& c)
-        : Core::Component(c), SearchAlgorithm(c), statisticsChannel_(c, "statistics"), memoryInfoChannel_(c, "memory-info"), searchSpace_(0), createLattice_(paramCreateLattice(config)), labelMap_(0), stateSequences_(0) {
+        : Core::Component(c),
+          SearchAlgorithm(c),
+          statisticsChannel_(c, "statistics"),
+          memoryInfoChannel_(c, "memory-info"),
+          searchSpace_(0),
+          createLattice_(paramCreateLattice(config)),
+          labelMap_(0),
+          stateSequences_(0) {
     searchSpace_ = createSearchSpace();
     outputType_  = static_cast<OutputType>(paramOutputType_(config));
     log("output type: %s", choiceOutputType[outputType_].c_str());
@@ -247,6 +254,10 @@ void ExpandingFsaSearch::getCurrentBestSentence(Traceback& result) const {
     }
 }
 
+void ExpandingFsaSearch::getCurrentBestTrace(Traceback& result) const {  // jiang
+    defect();
+}
+
 Core::Ref<const Search::LatticeAdaptor> ExpandingFsaSearch::getCurrentWordLattice() const {
     if (!createLattice_)
         return Core::ref(new WfstLatticeAdaptor);
diff --git a/src/Search/Wfst/ExpandingFsaSearch.hh b/src/Search/Wfst/ExpandingFsaSearch.hh
index 5a9cb99ca..862822346 100644
--- a/src/Search/Wfst/ExpandingFsaSearch.hh
+++ b/src/Search/Wfst/ExpandingFsaSearch.hh
@@ -87,6 +87,7 @@ public:
     virtual Speech::ModelCombination::Mode modelCombinationNeeded() const;
     virtual bool                           setModelCombination(const Speech::ModelCombination& modelCombination);
     virtual void                           setGrammar(Fsa::ConstAutomatonRef) {}
+    virtual bool                           setLanguageModel(Core::Ref<const Lm::ScaledLanguageModel>) {}
 
     virtual void                                    init();
     virtual void                                    restart();
@@ -94,6 +95,7 @@ public:
     virtual void                                    feed(const Mm::FeatureScorer::Scorer&);
     virtual void                                    getPartialSentence(Traceback& result);
     virtual void                                    getCurrentBestSentence(Traceback& result) const;
+    virtual void                                    getCurrentBestTrace(Traceback& result) const;  // jiang
     virtual Core::Ref<const Search::LatticeAdaptor> getCurrentWordLattice() const;
     virtual void                                    resetStatistics();
     virtual void                                    logStatistics() const;
diff --git a/src/Search/Wfst/FstOperations.hh b/src/Search/Wfst/FstOperations.hh
index f0acb0e52..7c1a21926 100644
--- a/src/Search/Wfst/FstOperations.hh
+++ b/src/Search/Wfst/FstOperations.hh
@@ -31,7 +31,9 @@ class Minimize : public SleeveOperation, public SemiringDependent {
 
 public:
     Minimize(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r), SemiringDependent(c) {}
+            : Operation(c, r),
+              SleeveOperation(c, r),
+              SemiringDependent(c) {}
 
 protected:
     virtual AutomatonRef process();
@@ -52,7 +54,9 @@ public:
 class Determinize : public SleeveOperation, public SemiringDependent {
 public:
     Determinize(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r), SemiringDependent(c) {}
+            : Operation(c, r),
+              SleeveOperation(c, r),
+              SemiringDependent(c) {}
 
 protected:
     virtual AutomatonRef process();
@@ -69,7 +73,8 @@ public:
 class ArcInputSort : public SleeveOperation {
 public:
     ArcInputSort(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r) {}
+            : Operation(c, r),
+              SleeveOperation(c, r) {}
 
 protected:
     virtual AutomatonRef process();
@@ -86,7 +91,8 @@ public:
 class ArcOutputSort : public SleeveOperation {
 public:
     ArcOutputSort(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r) {}
+            : Operation(c, r),
+              SleeveOperation(c, r) {}
 
 protected:
     virtual AutomatonRef process();
@@ -107,7 +113,9 @@ protected:
 
 public:
     Compose(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r), right_(0) {}
+            : Operation(c, r),
+              SleeveOperation(c, r),
+              right_(0) {}
     virtual u32 nInputAutomata() const {
         return 2;
     }
@@ -133,7 +141,8 @@ protected:
 
 public:
     LabelCoding(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r) {}
+            : Operation(c, r),
+              SleeveOperation(c, r) {}
 };
 
 /**
@@ -146,7 +155,8 @@ class LabelEncode : public LabelCoding {
 
 public:
     LabelEncode(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), LabelCoding(c, r) {}
+            : Operation(c, r),
+              LabelCoding(c, r) {}
 
 protected:
     virtual AutomatonRef process();
@@ -171,7 +181,8 @@ public:
 class LabelDecode : public LabelCoding {
 public:
     LabelDecode(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), LabelCoding(c, r) {}
+            : Operation(c, r),
+              LabelCoding(c, r) {}
 
 protected:
     virtual AutomatonRef process();
@@ -190,7 +201,8 @@ public:
 class WeightEncode : public LabelEncode {
 public:
     WeightEncode(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), LabelEncode(c, r) {}
+            : Operation(c, r),
+              LabelEncode(c, r) {}
 
 protected:
     virtual AutomatonRef process();
@@ -210,7 +222,8 @@ class Relabel : public SleeveOperation {
 
 public:
     Relabel(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r) {}
+            : Operation(c, r),
+              SleeveOperation(c, r) {}
 
 protected:
     virtual AutomatonRef process();
@@ -233,7 +246,9 @@ public:
 class PushWeights : public SleeveOperation, public SemiringDependent {
 public:
     PushWeights(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r), SemiringDependent(c) {}
+            : Operation(c, r),
+              SleeveOperation(c, r),
+              SemiringDependent(c) {}
 
 protected:
     virtual AutomatonRef process();
@@ -252,7 +267,8 @@ class PushLabels : public SleeveOperation {
 
 public:
     PushLabels(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r) {}
+            : Operation(c, r),
+              SleeveOperation(c, r) {}
 
 protected:
     virtual AutomatonRef process();
@@ -269,7 +285,9 @@ public:
 class NormalizeEpsilon : public SleeveOperation, public LabelTypeDependent {
 public:
     NormalizeEpsilon(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r), LabelTypeDependent(c) {}
+            : Operation(c, r),
+              SleeveOperation(c, r),
+              LabelTypeDependent(c) {}
 
 protected:
     virtual AutomatonRef process();
@@ -286,7 +304,9 @@ public:
 class Project : public SleeveOperation, public LabelTypeDependent {
 public:
     Project(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r), LabelTypeDependent(c) {}
+            : Operation(c, r),
+              SleeveOperation(c, r),
+              LabelTypeDependent(c) {}
 
 protected:
     virtual AutomatonRef process();
@@ -305,7 +325,9 @@ class RemoveEpsilon : public SleeveOperation, public SemiringDependent
 {
 public:
     RemoveEpsilon(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r), SemiringDependent(c) {}
+            : Operation(c, r),
+              SleeveOperation(c, r),
+              SemiringDependent(c) {}
 
 protected:
     virtual AutomatonRef process();
@@ -322,7 +344,9 @@ public:
 class Synchronize : public SleeveOperation, public SemiringDependent {
 public:
     Synchronize(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r), SemiringDependent(c) {}
+            : Operation(c, r),
+              SleeveOperation(c, r),
+              SemiringDependent(c) {}
 
 protected:
     virtual AutomatonRef process();
@@ -339,7 +363,8 @@ public:
 class Invert : public SleeveOperation {
 public:
     Invert(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r) {}
+            : Operation(c, r),
+              SleeveOperation(c, r) {}
 
 protected:
     virtual AutomatonRef process();
@@ -365,7 +390,9 @@ protected:
 
 public:
     CreateLookahead(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), WriteOperation(c, r), toRelabel_(0) {}
+            : Operation(c, r),
+              WriteOperation(c, r),
+              toRelabel_(0) {}
     virtual bool consumeInput() const {
         return false;
     }
@@ -393,14 +420,17 @@ public:
  * applies composition using a label lookahead matcher.
  */
 class ReachableCompose : public Compose {
-    enum LookAheadType { LabelLookAhead,
-                         ArcLookAhead };
+    enum LookAheadType {
+        LabelLookAhead,
+        ArcLookAhead
+    };
     static const Core::Choice          lookAheadChoice;
     static const Core::ParameterChoice paramLookAheadType;
 
 public:
     ReachableCompose(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), Compose(c, r) {}
+            : Operation(c, r),
+              Compose(c, r) {}
 
 protected:
     virtual AutomatonRef process();
@@ -419,7 +449,8 @@ class ScaleWeights : public SleeveOperation {
 
 public:
     ScaleWeights(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r) {}
+            : Operation(c, r),
+              SleeveOperation(c, r) {}
 
 protected:
     virtual AutomatonRef process();
@@ -439,7 +470,8 @@ class ScaleLabelWeights : public SleeveOperation {
 
 public:
     ScaleLabelWeights(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r) {}
+            : Operation(c, r),
+              SleeveOperation(c, r) {}
 
 protected:
     virtual AutomatonRef process();
@@ -456,7 +488,8 @@ public:
 class RemoveWeights : public SleeveOperation {
 public:
     RemoveWeights(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r) {}
+            : Operation(c, r),
+              SleeveOperation(c, r) {}
 
 protected:
     virtual AutomatonRef process();
diff --git a/src/Search/Wfst/GrammarFst.hh b/src/Search/Wfst/GrammarFst.hh
index ecc72e50f..04a8359e7 100644
--- a/src/Search/Wfst/GrammarFst.hh
+++ b/src/Search/Wfst/GrammarFst.hh
@@ -71,14 +71,16 @@ protected:
  */
 class AbstractGrammarFst {
 public:
-    enum GrammarType { TypeAny,
-                       TypeVector,
-                       TypeConst,
-                       TypeCompact,
-                       TypeCombine,
-                       TypeCompose,
-                       TypeDynamic,
-                       TypeFailArc };
+    enum GrammarType {
+        TypeAny,
+        TypeVector,
+        TypeConst,
+        TypeCompact,
+        TypeCombine,
+        TypeCompose,
+        TypeDynamic,
+        TypeFailArc
+    };
 
     AbstractGrammarFst() {}
     virtual ~AbstractGrammarFst() {}
@@ -167,13 +169,17 @@ typedef GrammarFstTpl<FstLib::StdConstFst,
 class CombinedGrammarFst : public AbstractGrammarFst, public Core::Component {
 public:
     CombinedGrammarFst(const Core::Configuration& c)
-            : Core::Component(c), fst_(0), rootFst_(0) {}
+            : Core::Component(c),
+              fst_(0),
+              rootFst_(0) {}
     virtual ~CombinedGrammarFst();
+
     bool                  load(const std::string& root);
     void                  relabel(const GrammarRelabelerBase& relabeler);
     const FstLib::StdFst* getFst() const;
     void                  reset();
-    GrammarType           type() const {
+
+    GrammarType type() const {
         return TypeCombine;
     }
 
@@ -200,7 +206,13 @@ class ComposedGrammarFst : public AbstractGrammarFst, public Core::Component {
 
 public:
     ComposedGrammarFst(const Core::Configuration& c)
-            : Core::Component(c), cfst_(0), pfst_(0), rfst_(0), table_(0), rootFst_(0), addOnFst_(0) {}
+            : Core::Component(c),
+              cfst_(0),
+              pfst_(0),
+              rfst_(0),
+              table_(0),
+              rootFst_(0),
+              addOnFst_(0) {}
     virtual ~ComposedGrammarFst();
     bool                  load(const std::string& root);
     void                  relabel(const GrammarRelabelerBase& relabeler);
@@ -227,7 +239,8 @@ protected:
 class DynamicGrammarFst : public AbstractGrammarFst, public Core::Component {
 public:
     DynamicGrammarFst(const Core::Configuration& c)
-            : Core::Component(c), fst_(0) {}
+            : Core::Component(c),
+              fst_(0) {}
     virtual ~DynamicGrammarFst();
     void setLexicon(Bliss::LexiconRef lexicon) {
         lexicon_ = lexicon;
diff --git a/src/Search/Wfst/IoOperations.hh b/src/Search/Wfst/IoOperations.hh
index 7772a9730..0186cdb06 100644
--- a/src/Search/Wfst/IoOperations.hh
+++ b/src/Search/Wfst/IoOperations.hh
@@ -29,10 +29,12 @@ protected:
     static const Core::ParameterString paramFilename;
     static const Core::Choice          choiceType;
     static const Core::ParameterChoice paramType;
-    enum FileType { TypeVector,
-                    TypeConst,
-                    TypeCompact,
-                    TypeNGram };
+    enum FileType {
+        TypeVector,
+        TypeConst,
+        TypeCompact,
+        TypeNGram
+    };
     std::string filename() const;
 
 public:
@@ -46,7 +48,8 @@ protected:
 class ReadOperation : public FileOperation {
 public:
     ReadOperation(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), FileOperation(c, r) {}
+            : Operation(c, r),
+              FileOperation(c, r) {}
 
 protected:
     static const Core::ParameterStringVector paramAttributes;
@@ -59,7 +62,8 @@ protected:
 class ReadFst : public ReadOperation {
 public:
     ReadFst(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), ReadOperation(c, r) {}
+            : Operation(c, r),
+              ReadOperation(c, r) {}
 
 protected:
     virtual AutomatonRef process();
@@ -76,7 +80,8 @@ public:
 class ReadFsa : public ReadOperation {
 public:
     ReadFsa(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), ReadOperation(c, r) {}
+            : Operation(c, r),
+              ReadOperation(c, r) {}
 
 protected:
     virtual AutomatonRef process();
@@ -93,7 +98,9 @@ public:
 class WriteOperation : public SleeveOperation, protected FileOperation {
 public:
     WriteOperation(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r), FileOperation(c, r) {}
+            : Operation(c, r),
+              SleeveOperation(c, r),
+              FileOperation(c, r) {}
 
 protected:
     virtual bool precondition() const;
@@ -105,7 +112,8 @@ protected:
 class WriteFst : public WriteOperation {
 public:
     WriteFst(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), WriteOperation(c, r) {}
+            : Operation(c, r),
+              WriteOperation(c, r) {}
 
 protected:
     virtual AutomatonRef process();
@@ -126,7 +134,8 @@ public:
 class WriteFsa : public WriteOperation {
 public:
     WriteFsa(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), WriteOperation(c, r) {}
+            : Operation(c, r),
+              WriteOperation(c, r) {}
 
 protected:
     virtual AutomatonRef process();
@@ -145,7 +154,8 @@ public:
 class Compress : public WriteOperation {
 public:
     Compress(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), WriteOperation(c, r) {}
+            : Operation(c, r),
+              WriteOperation(c, r) {}
 
 protected:
     virtual AutomatonRef process();
diff --git a/src/Search/Wfst/LabelMapper.hh b/src/Search/Wfst/LabelMapper.hh
index a9f9d3fe0..b01da94e7 100644
--- a/src/Search/Wfst/LabelMapper.hh
+++ b/src/Search/Wfst/LabelMapper.hh
@@ -34,7 +34,8 @@ class RestoreOutputLabelMapper {
 
 public:
     RestoreOutputLabelMapper(int wordLabelOffset, int disambiguatorOffset)
-            : wordLabelOffset_(wordLabelOffset), disambiguatorStart_(disambiguatorOffset) {}
+            : wordLabelOffset_(wordLabelOffset),
+              disambiguatorStart_(disambiguatorOffset) {}
 
     Arc operator()(const Arc& arc) const {
         // transform only acceptors
@@ -78,7 +79,8 @@ class RemoveDisambiguatorMapper {
 
 public:
     RemoveDisambiguatorMapper(int disambiguatorMin, int disambiguatorMax)
-            : disambiguatorMin_(disambiguatorMin), disambiguatorMax_(disambiguatorMax) {}
+            : disambiguatorMin_(disambiguatorMin),
+              disambiguatorMax_(disambiguatorMax) {}
 
     Arc operator()(const Arc& arc) const {
         if (arc.ilabel >= disambiguatorMin_ && arc.ilabel <= disambiguatorMax_) {
diff --git a/src/Search/Wfst/Lattice.hh b/src/Search/Wfst/Lattice.hh
index 577c45493..b6a10b6ac 100644
--- a/src/Search/Wfst/Lattice.hh
+++ b/src/Search/Wfst/Lattice.hh
@@ -57,8 +57,8 @@ public:
         return one;
     }
 
-    static const string& Type() {
-        static const string type = "lattice-" + TropicalWeight::Type();
+    static const std::string& Type() {
+        static const std::string type = "lattice-" + TropicalWeight::Type();
         return type;
     }
 
@@ -137,11 +137,15 @@ public:
     Lattice()
             : outputType_(DefaultOutput) {}
     explicit Lattice(const Lattice& o)
-            : VectorFst(o), wordBoundaries_(o.wordBoundaries_), outputType_(DefaultOutput) {}
+            : VectorFst(o),
+              wordBoundaries_(o.wordBoundaries_),
+              outputType_(DefaultOutput) {}
     explicit Lattice(const VectorFst& o)
-            : VectorFst(o), outputType_(DefaultOutput) {}
+            : VectorFst(o),
+              outputType_(DefaultOutput) {}
     explicit Lattice(const FstLib::Fst<LatticeArc>& o)
-            : VectorFst(o), outputType_(DefaultOutput) {}
+            : VectorFst(o),
+              outputType_(DefaultOutput) {}
     virtual ~Lattice() {}
 
     Lattice* Copy(bool safe = false) const {
diff --git a/src/Search/Wfst/LatticeArchive.hh b/src/Search/Wfst/LatticeArchive.hh
index c6faa49bd..9f1998a8a 100644
--- a/src/Search/Wfst/LatticeArchive.hh
+++ b/src/Search/Wfst/LatticeArchive.hh
@@ -31,9 +31,13 @@ class LatticeArchive : public Core::Component {
 
 public:
     LatticeArchive(const Core::Configuration& c)
-            : Core::Component(c), archive_(0), path_(paramPath(c)) {}
+            : Core::Component(c),
+              archive_(0),
+              path_(paramPath(c)) {}
     LatticeArchive(const Core::Configuration& c, const std::string& path)
-            : Core::Component(c), archive_(0), path_(path) {}
+            : Core::Component(c),
+              archive_(0),
+              path_(path) {}
     virtual ~LatticeArchive();
     bool                   write(const std::string& id, const Search::Wfst::Lattice* l);
     Search::Wfst::Lattice* read(const std::string& id, bool readBoundaries = true);
diff --git a/src/Search/Wfst/LatticeGenerator.cc b/src/Search/Wfst/LatticeGenerator.cc
index dce29253a..b3b95b9b3 100644
--- a/src/Search/Wfst/LatticeGenerator.cc
+++ b/src/Search/Wfst/LatticeGenerator.cc
@@ -44,7 +44,9 @@ class SilenceLabelVisitor {
 
     SilenceLabelVisitor(Label ilabel, Label olabel,
                         std::vector<bool>* silence_states)
-            : states_(silence_states), ilabel_(ilabel), olabel_(olabel) {}
+            : states_(silence_states),
+              ilabel_(ilabel),
+              olabel_(olabel) {}
 
     void InitVisit(const FstLib::Fst<Arc>& fst) {}
     bool InitState(StateId s, StateId root) {
@@ -103,7 +105,12 @@ LatticeTraceRecorder* LatticeTraceRecorder::create(LatticeType type, const State
 }
 
 LatticeTraceRecorder::LatticeTraceRecorder(const StateSequenceList& hmms)
-        : hmmsBegin_(&hmms.front()), lattice_(new Lattice), silence_(OpenFst::InvalidLabelId), silenceOutput_(OpenFst::InvalidLabelId), mergeSilence_(true), pruningThreshold_(Core::Type<Score>::max) {}
+        : hmmsBegin_(&hmms.front()),
+          lattice_(new Lattice),
+          silence_(OpenFst::InvalidLabelId),
+          silenceOutput_(OpenFst::InvalidLabelId),
+          mergeSilence_(true),
+          pruningThreshold_(Core::Type<Score>::max) {}
 
 LatticeTraceRecorder::~LatticeTraceRecorder() {
     delete lattice_;
diff --git a/src/Search/Wfst/LatticeGenerator.hh b/src/Search/Wfst/LatticeGenerator.hh
index 390f2aa5c..438ac7c29 100644
--- a/src/Search/Wfst/LatticeGenerator.hh
+++ b/src/Search/Wfst/LatticeGenerator.hh
@@ -34,11 +34,13 @@ protected:
     LatticeTraceRecorder(const StateSequenceList& hmms);
 
 public:
-    enum LatticeType { HmmLattice,
-                       DetermisticHmmLattice,
-                       SimpleWordLattice,
-                       SimpleNonDetWordLattice,
-                       WordLattice };
+    enum LatticeType {
+        HmmLattice,
+        DetermisticHmmLattice,
+        SimpleWordLattice,
+        SimpleNonDetWordLattice,
+        WordLattice
+    };
 
     /**
      * Set input and output label of silence arcs
diff --git a/src/Search/Wfst/LatticeNetwork.hh b/src/Search/Wfst/LatticeNetwork.hh
index 22d5d06f4..65a79b61d 100644
--- a/src/Search/Wfst/LatticeNetwork.hh
+++ b/src/Search/Wfst/LatticeNetwork.hh
@@ -49,7 +49,10 @@ class LatticeNetwork : public StaticNetwork {
 
 public:
     LatticeNetwork(const Core::Configuration& c)
-            : StaticNetwork(c), l_(0), g_(0), archive_(0) {}
+            : StaticNetwork(c),
+              l_(0),
+              g_(0),
+              archive_(0) {}
     virtual ~LatticeNetwork();
     virtual bool init();
     virtual void reset() {}
diff --git a/src/Search/Wfst/LatticeReader.cc b/src/Search/Wfst/LatticeReader.cc
index f93c461ce..9db5a76bb 100644
--- a/src/Search/Wfst/LatticeReader.cc
+++ b/src/Search/Wfst/LatticeReader.cc
@@ -72,12 +72,12 @@ void FlfConverter::createSemiring() {
 Flf::ConstLatticeRef FlfConverter::convert(const Search::Wfst::Lattice& lattice,
                                            Fsa::ConstAlphabetRef        inputAlphabet,
                                            Fsa::ConstAlphabetRef        outputAlphabet) {
-    typedef Search::Wfst::Lattice::WordBoundaries WordBoundaries;
+    typedef Search::Wfst::Lattice::WordBoundaries                                                    WordBoundaries;
+    typedef OpenFst::FstMapperAutomaton<Flf::Semiring, LatticeArc, FlfWeightConverter, Flf::Lattice> Mapper;
 
     createSemiring();
-    typedef OpenFst::FstMapperAutomaton<Flf::Semiring, LatticeArc, FlfWeightConverter, Flf::Lattice> Mapper;
-    Mapper*                                                                                          mapper = new Mapper(
-            &lattice, semiring_, FlfWeightConverter<LatticeWeight, Flf::Semiring::Weight>(semiring_));
+
+    Mapper* mapper = new Mapper(&lattice, semiring_, FlfWeightConverter<LatticeWeight, Flf::Semiring::Weight>(semiring_));
     mapper->setInputAlphabet(inputAlphabet);
     mapper->setOutputAlphabet(outputAlphabet);
     Flf::StaticLattice* flfLattice = new Flf::StaticLattice();
diff --git a/src/Search/Wfst/LexiconFst.hh b/src/Search/Wfst/LexiconFst.hh
index dafc40562..dd4bcb0ad 100644
--- a/src/Search/Wfst/LexiconFst.hh
+++ b/src/Search/Wfst/LexiconFst.hh
@@ -48,9 +48,11 @@ class LexicalFstFactory : public Core::Component {
     typedef StdFst::Arc                     Arc;
 
 public:
-    enum AccumulatorType { DefaultAccumulator,
-                           LogAccumulator,
-                           FastLogAccumulator };
+    enum AccumulatorType {
+        DefaultAccumulator,
+        LogAccumulator,
+        FastLogAccumulator
+    };
 
     struct Options {
         AccumulatorType accumulatorType;
diff --git a/src/Search/Wfst/Network.hh b/src/Search/Wfst/Network.hh
index 3cca80e37..717449968 100644
--- a/src/Search/Wfst/Network.hh
+++ b/src/Search/Wfst/Network.hh
@@ -27,10 +27,12 @@ namespace Search {
 namespace Wfst {
 
 /*! @todo: move this type out of global scope */
-enum NetworkType { NetworkTypeCompressed,
-                   NetworkTypeStatic,
-                   NetworkTypeComposed,
-                   NetworkTypeLattice };
+enum NetworkType {
+    NetworkTypeCompressed,
+    NetworkTypeStatic,
+    NetworkTypeComposed,
+    NetworkTypeLattice
+};
 
 /**
  * base class for OpenFst based networks
@@ -40,7 +42,8 @@ class FstNetwork : public Core::Component {
 protected:
     typedef F Fst;
     Fst*      f_;
-    Fst*      automaton() const {
+
+    Fst* automaton() const {
         return f_;
     }
 
@@ -55,16 +58,21 @@ public:
     u32 nArcs() const {
         return 0;
     }
+
     u32 nEpsilonArcs() const {
         return 0;
     }
+
     virtual u32 nStates() const = 0;
-    size_t      memStates() const {
+
+    size_t memStates() const {
         return 0;
     }
+
     size_t memArcs() const {
         return 0;
     }
+
     size_t memEpsilonArcs() const {
         return 0;
     }
@@ -103,14 +111,17 @@ public:
 
 protected:
     FstNetwork(const Core::Configuration& c)
-            : Core::Component(c), f_(0), memUsageChannel_(c, "memory-info") {}
+            : Core::Component(c),
+              f_(0),
+              memUsageChannel_(c, "memory-info") {}
     virtual ~FstNetwork() {
         delete f_;
     }
 
 protected:
     mutable Core::XmlChannel memUsageChannel_;
-    void                     logMemoryUsage() const {
+
+    void logMemoryUsage() const {
         if (memUsageChannel_.isOpen()) {
             Core::MemoryInfo meminfo;
             memUsageChannel_ << meminfo;
@@ -130,13 +141,17 @@ private:
 public:
     StaticNetwork(const Core::Configuration&);
     virtual ~StaticNetwork() {}
+
     virtual bool init();
-    virtual u32  nStates() const {
+
+    virtual u32 nStates() const {
         return f_->NumStates();
     }
+
     static bool hasGrammarState() {
         return false;
     }
+
     StateIndex grammarState(StateIndex) const {
         return 0;
     }
@@ -145,7 +160,8 @@ public:
     class ArcIterator {
     public:
         ArcIterator(const StaticNetwork* network, StateIndex s)
-                : a_(*network->f_, s), offset_(network->f_->NumInputEpsilons(s)) {
+                : a_(*network->f_, s),
+                  offset_(network->f_->NumInputEpsilons(s)) {
             reset();
         }
         void next() {
diff --git a/src/Search/Wfst/NonWordTokens.hh b/src/Search/Wfst/NonWordTokens.hh
index 2915b918a..06f546e1a 100644
--- a/src/Search/Wfst/NonWordTokens.hh
+++ b/src/Search/Wfst/NonWordTokens.hh
@@ -37,7 +37,9 @@ public:
     typedef std::map<Bliss::Phoneme::Id, const Am::Allophone*> AllophoneMap;
 
     NonWordTokens(const Core::Configuration& c, const Bliss::Lexicon& lexicon)
-            : Core::Component(c), lexicon_(lexicon), phoneOffset_(0) {}
+            : Core::Component(c),
+              lexicon_(lexicon),
+              phoneOffset_(0) {}
     ~NonWordTokens();
     bool init();
 
diff --git a/src/Search/Wfst/SearchSpace.cc b/src/Search/Wfst/SearchSpace.cc
index 383b728a3..f62516145 100644
--- a/src/Search/Wfst/SearchSpace.cc
+++ b/src/Search/Wfst/SearchSpace.cc
@@ -126,30 +126,39 @@ class SearchSpace : public SearchSpaceBase {
     virtual ~SearchSpace() {
         delete network_;
     }
+
     void feed(const Mm::FeatureScorer::Scorer& scorer);
     void reset();
+
     void setSegment(const std::string& name) {
         network_->setSegment(name);
     }
+
     void     getTraceback(BestPath* path);
     Lattice* createLattice(OutputType type);
-    void     setStatistics(bool detailed) {
+
+    void setStatistics(bool detailed) {
         require(!statisticsCollector_);
         if (detailed)
             statisticsCollector_ = new Statistics::DetailedCollector<Self>(this);
         else
             statisticsCollector_ = new Statistics::DefaultCollector(this);
     }
+
     u32 nActiveStates() const {
         return activeStates_.size();
     }
+
     bool init(std::string& msg);
-    u32  nStates() const {
+
+    u32 nStates() const {
         return network_->nStates();
     }
+
     u32 nArcs() const {
         return network_->nArcs();
     }
+
     u32 nEpsilonArcs() const {
         return network_->nEpsilonArcs();
     }
@@ -158,7 +167,9 @@ class SearchSpace : public SearchSpaceBase {
     typedef typename Network::ArcIterator        ArcIterator;
     typedef typename Network::EpsilonArcIterator EpsilonArcIterator;
 
-    enum { NumIncomingHyps = 1 + UseSkips };
+    enum {
+        NumIncomingHyps = 1 + UseSkips
+    };
     /**
      * active state
      */
@@ -194,14 +205,20 @@ class SearchSpace : public SearchSpaceBase {
         Score      score;
         TraceRef   trace[NumIncomingHyps];
         EpsilonArcHyp(StateIndex _target, Label _output, Score _score)
-                : target(_target), output(_output), score(_score) {}
+                : target(_target),
+                  output(_output),
+                  score(_score) {}
         EpsilonArcHyp(StateIndex _target, Label _output, Score _score, const IncomingHyp* _in)
-                : target(_target), output(_output), score(_score) {
+                : target(_target),
+                  output(_output),
+                  score(_score) {
             for (u32 i = 0; i < NumIncomingHyps; ++i)
                 trace[i] = _in[i].trace;
         }
         EpsilonArcHyp(StateIndex _target, Label _output, Score _score, const TraceRef* _trace)
-                : target(_target), output(_output), score(_score) {
+                : target(_target),
+                  output(_output),
+                  score(_score) {
             for (u32 i = 0; i < NumIncomingHyps; ++i)
                 trace[i] = _trace[i];
         }
@@ -210,7 +227,8 @@ class SearchSpace : public SearchSpaceBase {
     class StateHypIterator {
     public:
         StateHypIterator(const StateHypotheses& states)
-                : iter_(states.begin()), end_(states.end()) {
+                : iter_(states.begin()),
+                  end_(states.end()) {
             update();
         }
         bool done() const {
@@ -867,11 +885,9 @@ void SearchSpace<N, S>::pruneWordEnds(Score threshold) {
  * create a new StateHyp (corresponding to @c stateIndex) in activeStates_ if does not already exist
  */
 template<class N, bool S>
-inline typename SearchSpace<N, S>::StateHyp*
-        SearchSpace<N, S>::getStateHyp(StateIndex stateIndex) {
+inline typename SearchSpace<N, S>::StateHyp* SearchSpace<N, S>::getStateHyp(StateIndex stateIndex) {
     StateHyp*                      stateHyp = 0;
-    typename StateToHypMap::Cursor i        = stateToHyp_.find(
-            StateToHypElement(stateIndex, 0));
+    typename StateToHypMap::Cursor i        = stateToHyp_.find(StateToHypElement(stateIndex, 0));
     if (i == StateToHypMap::InvalidCursor) {
         stateToHyp_.insert(StateToHypElement(stateIndex, activeStates_.size()));
         activeStates_.push_back(StateHyp(stateIndex));
diff --git a/src/Search/Wfst/SearchSpace.hh b/src/Search/Wfst/SearchSpace.hh
index c8934cb8d..cbcd4a3a6 100644
--- a/src/Search/Wfst/SearchSpace.hh
+++ b/src/Search/Wfst/SearchSpace.hh
@@ -40,78 +40,101 @@ class SearchSpaceBase {
 public:
     typedef Wfst::Lattice Lattice;
 
+    virtual ~SearchSpaceBase();
+
     virtual void     feed(const Mm::FeatureScorer::Scorer& scorer) = 0;
     virtual void     reset()                                       = 0;
     virtual void     setSegment(const std::string& name)           = 0;
     virtual void     getTraceback(BestPath*)                       = 0;
     virtual Lattice* createLattice(OutputType)                     = 0;
-    void             setPruningThreshold(Score threshold) {
+
+    void setPruningThreshold(Score threshold) {
         pruningThreshold_ = threshold;
     }
+
     void setPruningLimit(u32 limit) {
         pruningLimit_ = limit;
     }
+
     void setPurgeInterval(u32 interval) {
         purgeInterval_ = interval;
     }
+
     void setPruningBins(u32 bins) {
         stateHistogram_.setBins(bins);
     }
+
     void setInitialEpsilonPruning(bool prune) {
         initialEpsPruning_ = prune;
     }
+
     void setEpsilonPruning(bool prune) {
         epsilonArcPruning_ = prune;
     }
+
     void setProspectivePruning(bool prune) {
         prospectivePruning_ = prune;
     }
+
     void setLatticePruning(Score threshold) {
         latticePruning_ = threshold;
     }
+
     void setMergeEpsilonPaths(bool merge) {
         mergeEpsPaths_ = merge;
     }
+
     void setCreateLattice(bool create, LatticeTraceRecorder::LatticeType type) {
         createLattice_ = create;
         latticeType_   = type;
     }
+
     void setMergeSilenceLatticeArcs(bool merge) {
         mergeSilenceArcs_ = merge;
     }
+
     void setWordEndPruning(bool prune, Score threshold) {
         wordEndPruning_   = prune;
         wordEndThreshold_ = threshold;
     }
+
     void setWordEndType(WordEndDetector::WordEndType type) {
         wordEnds_.setType(type);
     }
+
     void setIgnoreLastOutput(bool ignore) {
         ignoreLastOutput_ = ignore;
     }
+
     void setStateSequences(const StateSequenceList* list) {
         stateSequences_ = list;
     }
+
     void setWeightScale(f32 scale) {
         weightScale_ = scale;
     }
+
     void setTransitionModel(Core::Ref<const Am::AcousticModel>);
     bool setNonWordPhones(Core::Ref<const Am::AcousticModel> am, const std::vector<std::string>& phones);
     void setUseNonWordModels(u32 nNonWordModels);
+
     void setSilence(const StateSequence* hmm, OpenFst::Label olabel) {
         silence_       = hmm;
         silenceOutput_ = olabel;
     }
+
     void setLexicon(Bliss::LexiconRef lexicon) {
         lexicon_ = lexicon;
     }
+
     virtual void setStatistics(bool detailed) = 0;
     virtual u32  nActiveStates() const        = 0;
-    u32          nActiveHyps() const {
+
+    u32 nActiveHyps() const {
         return nActiveHmmStateHyps_;
     }
+
     virtual bool init(std::string& msg);
-    virtual ~SearchSpaceBase();
 
     static SearchSpaceBase* create(NetworkType networkType, bool allowSkips, const Core::Configuration& c);
 
diff --git a/src/Search/Wfst/StateSequence.cc b/src/Search/Wfst/StateSequence.cc
index 3f56f625e..e39ed1937 100644
--- a/src/Search/Wfst/StateSequence.cc
+++ b/src/Search/Wfst/StateSequence.cc
@@ -146,7 +146,10 @@ AllophoneToAlloponeStateSequenceMap::AllophoneToAlloponeStateSequenceMap(Core::R
                                                                          bool                               removeDisambiguators,
                                                                          bool                               tieAllophones,
                                                                          bool                               ignoreFlags)
-        : model_(model), stateSequences_(0), removeDisambiguators_(removeDisambiguators), nDisambiguators_(0) {
+        : model_(model),
+          stateSequences_(0),
+          removeDisambiguators_(removeDisambiguators),
+          nDisambiguators_(0) {
     allophoneAlphabet_      = model_->allophoneAlphabet();
     allophoneStateAlphabet_ = model_->allophoneStateAlphabet();
     if (tieAllophones) {
@@ -204,7 +207,13 @@ const Core::ParameterBool StateSequenceBuilder::paramAddNonWords(
 StateSequenceBuilder::StateSequenceBuilder(const Core::Configuration&         c,
                                            Core::Ref<const Am::AcousticModel> am,
                                            Bliss::LexiconRef                  lexicon)
-        : Core::Component(c), am_(am), lexicon_(lexicon), nDisambiguators_(0), map_(new AllophoneToAlloponeStateSequenceMap(am, paramRemoveDisambiguators(config), paramTiedAllophones(config), paramIgnoreFlags(config))), addNonWords_(paramAddNonWords(config)), nonWordTokens_(0) {
+        : Core::Component(c),
+          am_(am),
+          lexicon_(lexicon),
+          nDisambiguators_(0),
+          map_(new AllophoneToAlloponeStateSequenceMap(am, paramRemoveDisambiguators(config), paramTiedAllophones(config), paramIgnoreFlags(config))),
+          addNonWords_(paramAddNonWords(config)),
+          nonWordTokens_(0) {
     log("tied allophones: %s", paramTiedAllophones(config) ? "true" : "false");
     log("ignore flags: %s", paramIgnoreFlags(config) ? "true" : "false");
     log("add non words: %s", addNonWords_ ? "true" : "false");
diff --git a/src/Search/Wfst/StateSequence.hh b/src/Search/Wfst/StateSequence.hh
index 7a091ba49..32de8d986 100644
--- a/src/Search/Wfst/StateSequence.hh
+++ b/src/Search/Wfst/StateSequence.hh
@@ -45,10 +45,12 @@ private:
         Am::AcousticModel::StateTransitionIndex transition_;
 
         State(Am::AcousticModel::EmissionIndex e, Am::AcousticModel::StateTransitionIndex t)
-                : emission_(e), transition_(t) {
+                : emission_(e),
+                  transition_(t) {
         }
         State()
-                : emission_(0), transition_(0) {
+                : emission_(0),
+                  transition_(0) {
         }
         bool operator==(const State& o) const {
             return (emission_ == o.emission_ && transition_ == o.transition_);
@@ -333,7 +335,10 @@ class HmmListConverter : public Core::Component {
 
 public:
     HmmListConverter(const Core::Configuration& c)
-            : Core::Component(c), hmmSyms_(0), stateSyms_(0), silencePhone_(paramSilencePhone(config)) {}
+            : Core::Component(c),
+              hmmSyms_(0),
+              stateSyms_(0),
+              silencePhone_(paramSilencePhone(config)) {}
 
     void setHmmSymbols(const OpenFst::SymbolTable* hmmSyms) {
         hmmSyms_ = hmmSyms;
@@ -391,7 +396,8 @@ class StateSequenceResolver {
 public:
     StateSequenceResolver(Core::Ref<const Am::AcousticModel> am,
                           const StateSequenceList&           states)
-            : am_(am), states_(states) {}
+            : am_(am),
+              states_(states) {}
     const StateSequence* find(const std::string& phone, u8 boundary) const;
     const StateSequence* find(const Bliss::Phoneme::Id phone, u8 boundary) const;
     const StateSequence* find(const Bliss::Phoneme* phone, u8 boundary) const;
diff --git a/src/Search/Wfst/StateTree.hh b/src/Search/Wfst/StateTree.hh
index 4eae2c40b..cd69e55e0 100644
--- a/src/Search/Wfst/StateTree.hh
+++ b/src/Search/Wfst/StateTree.hh
@@ -27,9 +27,11 @@ class StateSequenceList;
 class TiedStateSequenceMap;
 
 class StateTreeConverter : public Core::Component {
-    enum CompressionType { CompressionNone,
-                           CompressionFactorized,
-                           CompressionHmmLabel };
+    enum CompressionType {
+        CompressionNone,
+        CompressionFactorized,
+        CompressionHmmLabel
+    };
     static const Core::Choice          choiceCompression;
     static const Core::ParameterChoice paramCompression;
     static const Core::ParameterBool   paramEpsilonArcs;
diff --git a/src/Search/Wfst/Statistics.hh b/src/Search/Wfst/Statistics.hh
index 37e81a029..cd0523412 100644
--- a/src/Search/Wfst/Statistics.hh
+++ b/src/Search/Wfst/Statistics.hh
@@ -113,19 +113,24 @@ public:
     virtual ~DetailedStatistic() {
         delete base_;
     }
+
     void log(Core::XmlChannel& channel) const {
         base_->log(channel);
     }
+
     void reset() {
         base_->reset();
     }
+
     virtual void startProcessing() {}
     virtual void endProcessing() {}
     virtual void processArc(const ArcHyp& arc) {}
     virtual void processHmmStateHyp(const ArcHyp& arc, const HmmStateHyp& hyp, bool isActive, u32 hmmState) {}
-    void         add(u32 value) {
+
+    void add(u32 value) {
         base_->add(value);
     }
+
     void add(f32 value) {
         base_->add(value);
     }
@@ -146,10 +151,12 @@ public:
  */
 class AbstractCollector {
 public:
-    enum EventType { beforePruning,
-                     afterPruning,
-                     afterArcExpansion,
-                     nEvents };
+    enum EventType {
+        beforePruning,
+        afterPruning,
+        afterArcExpansion,
+        nEvents
+    };
     static const char* EventNames[nEvents];
     AbstractCollector() {
         eventNames_[beforePruning]     = "before pruning";
@@ -196,7 +203,8 @@ protected:
 class ActiveArcsStatistic : public SearchSpaceStatistic<u32> {
 public:
     ActiveArcsStatistic(AbstractCollector::EventType eventType, const std::string& eventName)
-            : SearchSpaceStatistic<u32>("active network arcs " + eventName), event_(eventType) {}
+            : SearchSpaceStatistic<u32>("active network arcs " + eventName),
+              event_(eventType) {}
     void process(const SearchSpaceBase& ss) {
         u32 nArcs = SearchSpaceData(ss).nArcs(event_ == AbstractCollector::beforePruning);
         add(nArcs);
@@ -227,7 +235,8 @@ public:
 class NumHypsStatistic : public SearchSpaceStatistic<u32> {
 public:
     NumHypsStatistic(AbstractCollector::EventType eventType, const std::string& eventName)
-            : SearchSpaceStatistic<u32>("total hmm states" + eventName), event_(eventType) {}
+            : SearchSpaceStatistic<u32>("total hmm states" + eventName),
+              event_(eventType) {}
     void process(const SearchSpaceBase& ss) {
         u32 nStates = SearchSpaceData(ss).nHyps(event_ == AbstractCollector::beforePruning);
         add(nStates);
@@ -380,7 +389,8 @@ protected:
 
 public:
     GrammarStateStatistic(const std::string& name)
-            : StateStatistic(name), network_(0) {}
+            : StateStatistic(name),
+              network_(0) {}
     void process(const SearchSpaceBase& ss) {
         const S& searchSpace = dynamic_cast<const S&>(ss);
         network_             = searchSpace.network_;
diff --git a/src/Search/Wfst/Traceback.hh b/src/Search/Wfst/Traceback.hh
index 3698f44ca..d40f9aef9 100644
--- a/src/Search/Wfst/Traceback.hh
+++ b/src/Search/Wfst/Traceback.hh
@@ -36,11 +36,17 @@ public:
         TimeframeIndex time;
         ScoreVector    score;
         Item(Label w, TimeframeIndex t, Score s)
-                : word(w), time(t), score(s, 0) {}
+                : word(w),
+                  time(t),
+                  score(s, 0) {}
         Item(Label w, TimeframeIndex t, Score a, Score l)
-                : word(w), time(t), score(a, l) {}
+                : word(w),
+                  time(t),
+                  score(a, l) {}
         Item(Label w, TimeframeIndex t, const ScoreVector& s)
-                : word(w), time(t), score(s) {}
+                : word(w),
+                  time(t),
+                  score(s) {}
     };
     struct CompareTime {
         bool operator()(const Item& a, const Item& b) const {
diff --git a/src/Search/Wfst/Types.hh b/src/Search/Wfst/Types.hh
index 996a7071c..1f9ccc49c 100644
--- a/src/Search/Wfst/Types.hh
+++ b/src/Search/Wfst/Types.hh
@@ -18,9 +18,11 @@
 namespace Search {
 namespace Wfst {
 
-enum OutputType { OutputLemmaPronunciation,
-                  OutputLemma,
-                  OutputSyntacticToken };
+enum OutputType {
+    OutputLemmaPronunciation,
+    OutputLemma,
+    OutputSyntacticToken
+};
 
 enum LookAheadFlags {
     NoLookAheadFlag    = 0,
diff --git a/src/Search/Wfst/UtilityOperations.hh b/src/Search/Wfst/UtilityOperations.hh
index 8c62020ae..f9d452200 100644
--- a/src/Search/Wfst/UtilityOperations.hh
+++ b/src/Search/Wfst/UtilityOperations.hh
@@ -32,7 +32,8 @@ namespace Builder {
 class RemoveHmmDisambiguators : public SleeveOperation {
 public:
     RemoveHmmDisambiguators(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r) {}
+            : Operation(c, r),
+              SleeveOperation(c, r) {}
 
 protected:
     virtual AutomatonRef process();
@@ -49,7 +50,8 @@ public:
 class Info : public SleeveOperation {
 public:
     Info(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r) {}
+            : Operation(c, r),
+              SleeveOperation(c, r) {}
 
 protected:
     virtual AutomatonRef process();
@@ -65,7 +67,8 @@ class Count : public SleeveOperation {
 
 public:
     Count(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r) {}
+            : Operation(c, r),
+              SleeveOperation(c, r) {}
 
 protected:
     virtual AutomatonRef process();
@@ -82,7 +85,8 @@ class CreateStateSequenceSymbols : public SleeveOperation {
 
 public:
     CreateStateSequenceSymbols(const Core::Configuration& c, Resources& r)
-            : Operation(c, r), SleeveOperation(c, r) {}
+            : Operation(c, r),
+              SleeveOperation(c, r) {}
 
 protected:
     virtual AutomatonRef process();
diff --git a/src/Search/Wfst/WordEnd.hh b/src/Search/Wfst/WordEnd.hh
index b3d6fdc8b..e23ea5f36 100644
--- a/src/Search/Wfst/WordEnd.hh
+++ b/src/Search/Wfst/WordEnd.hh
@@ -23,8 +23,10 @@ namespace Wfst {
 
 class WordEndDetector {
 public:
-    enum WordEndType { WordEndHmm,
-                       WordEndOutput };
+    enum WordEndType {
+        WordEndHmm,
+        WordEndOutput
+    };
 
     WordEndDetector()
             : wordEndType_(WordEndHmm) {}
diff --git a/src/Search/Wfst/check.cc b/src/Search/Wfst/check.cc
index 87b22c1c3..cb33ed5e1 100644
--- a/src/Search/Wfst/check.cc
+++ b/src/Search/Wfst/check.cc
@@ -49,9 +49,7 @@ class TestApplication : public virtual Core::Application {
         return 0;
 
         return EXIT_SUCCESS;
-    }  // end main
-
-protected:
+    }
 };
 
 APPLICATION(TestApplication)
diff --git a/src/Signal/AllPolesPowerSpectrum.cc b/src/Signal/AllPolesPowerSpectrum.cc
index 94ce2e4da..59665718a 100644
--- a/src/Signal/AllPolesPowerSpectrum.cc
+++ b/src/Signal/AllPolesPowerSpectrum.cc
@@ -24,7 +24,11 @@ const Core::ParameterFloat AllPolesPowerSpectrumNode::paramContinuousTotalLength
         "continuous-total-length", "total length of power spectrum in continuous units", 0, 0);
 
 AllPolesPowerSpectrumNode::AllPolesPowerSpectrumNode(const Core::Configuration& c)
-        : Core::Component(c), Precursor(c), discreteTotalLength_(0), continuousTotalLength_(0), totalLength_(0) {
+        : Core::Component(c),
+          Precursor(c),
+          discreteTotalLength_(0),
+          continuousTotalLength_(0),
+          totalLength_(0) {
     discreteTotalLength_   = paramDiscreteTotalLength(c);
     continuousTotalLength_ = paramContinuousTotalLength(c);
 }
@@ -81,7 +85,7 @@ bool AllPolesPowerSpectrumNode::work(Flow::PortId p) {
         out->setTimestamp(*arCoefficients);
         allPolesPowerSpectrum(arCoefficients->gain(), arCoefficients->a(), totalLength_, *out);
         std::transform(out->begin(), out->end(), out->begin(),
-                       std::bind2nd(std::divides<f32>(), sampleRate_ * sampleRate_));
+                       std::bind(std::divides<f32>(), std::placeholders::_1, sampleRate_ * sampleRate_));
         return putData(0, out);
     }
     return putData(0, arCoefficients.get());
diff --git a/src/Signal/AprioriProbability.hh b/src/Signal/AprioriProbability.hh
index 5a9fc8397..cb8be7f92 100644
--- a/src/Signal/AprioriProbability.hh
+++ b/src/Signal/AprioriProbability.hh
@@ -42,7 +42,10 @@ private:
 
 public:
     UniformAprioriProbability(const Core::Configuration& c)
-            : Component(c), AprioriProbability(c), nClasses_(0), logNClasses_(0) {}
+            : Component(c),
+              AprioriProbability(c),
+              nClasses_(0),
+              logNClasses_(0) {}
     virtual ~UniformAprioriProbability() {}
 
     virtual bool  setClasses(const std::vector<std::string>& classLabels);
diff --git a/src/Signal/ArEstimator.hh b/src/Signal/ArEstimator.hh
index 864c37a78..9536d85cd 100644
--- a/src/Signal/ArEstimator.hh
+++ b/src/Signal/ArEstimator.hh
@@ -68,7 +68,8 @@ public:
         return &dt;
     }
     AutoregressiveCoefficients()
-            : Precursor(type()), gain_(0) {}
+            : Precursor(type()),
+              gain_(0) {}
     virtual ~AutoregressiveCoefficients() {}
     virtual Data* clone() const {
         return new AutoregressiveCoefficients(*this);
@@ -101,7 +102,8 @@ public:
         return std::string("signal-autocorrelation-to-autoregression");
     }
     AutocorrelationToAutoregressionNode(const Core::Configuration& c)
-            : Core::Component(c), Precursor(c) {}
+            : Core::Component(c),
+              Precursor(c) {}
     virtual ~AutocorrelationToAutoregressionNode() {}
 
     virtual bool configure();
diff --git a/src/Signal/AutoregressionToCepstrum.cc b/src/Signal/AutoregressionToCepstrum.cc
index d954ab8ce..3c058f13b 100644
--- a/src/Signal/AutoregressionToCepstrum.cc
+++ b/src/Signal/AutoregressionToCepstrum.cc
@@ -40,7 +40,10 @@ const Core::ParameterInt AutoregressionToCepstrumNode::paramOutputSize(
         "nr-outputs", "number of outputs");
 
 AutoregressionToCepstrumNode::AutoregressionToCepstrumNode(const Core::Configuration& c)
-        : Core::Component(c), Precursor(c), outputSize_(0), needInit_(true) {
+        : Core::Component(c),
+          Precursor(c),
+          outputSize_(0),
+          needInit_(true) {
     setOutputSize(paramOutputSize(c));
 }
 
diff --git a/src/Signal/AutoregressionToSpectrum.cc b/src/Signal/AutoregressionToSpectrum.cc
index b24f7a380..ba589d089 100644
--- a/src/Signal/AutoregressionToSpectrum.cc
+++ b/src/Signal/AutoregressionToSpectrum.cc
@@ -26,7 +26,10 @@ const Core::ParameterBool AutoregressionToSpectrumNode::paramSlimSpectrum(
         "slim", "slim spectrum to skip bad band/channels (yes/no)", true);
 
 AutoregressionToSpectrumNode::AutoregressionToSpectrumNode(const Core::Configuration& c)
-        : Core::Component(c), Precursor(c), outputSize_(0), needInit_(true) {
+        : Core::Component(c),
+          Precursor(c),
+          outputSize_(0),
+          needInit_(true) {
     setOutputSize(paramOutputSize(c));
     setSlimSpectrum(paramSlimSpectrum(c));
 }
diff --git a/src/Signal/BayesClassification.cc b/src/Signal/BayesClassification.cc
index 7af8ba5b0..d7c1d801d 100644
--- a/src/Signal/BayesClassification.cc
+++ b/src/Signal/BayesClassification.cc
@@ -419,7 +419,9 @@ const Core::ParameterBool BayesClassificationScoreNode::paramSingleFrameClassifi
         "single-frame-classification", "classify single frames", false);
 
 BayesClassificationScoreNode::BayesClassificationScoreNode(const Core::Configuration& c)
-        : Component(c), Precursor(c), singleFrames_(paramSingleFrameClassification(c)) {
+        : Component(c),
+          Precursor(c),
+          singleFrames_(paramSingleFrameClassification(c)) {
     if (nClasses() == 0)
         setClassLabels(paramNumberOfClasses(c));
 }
diff --git a/src/Signal/BayesClassification.hh b/src/Signal/BayesClassification.hh
index 9381f23c7..9a8b19cd2 100644
--- a/src/Signal/BayesClassification.hh
+++ b/src/Signal/BayesClassification.hh
@@ -44,8 +44,12 @@ public:
     typedef Flow::Time                      Time;
     typedef std::pair<Time, Time>           StartEndTime;
 
-    enum AprioriProbabilityType { Uniform };
-    enum LikelihoodFunctionType { IndependentSequence };
+    enum AprioriProbabilityType {
+        Uniform
+    };
+    enum LikelihoodFunctionType {
+        IndependentSequence
+    };
 
 private:
     std::vector<std::string> classLabels_;
@@ -136,7 +140,8 @@ public:
     void setClassLabels(u32 nClasses);
     void setNumUsedFeatures(u32 nFeatures);
     void setUseSlidingWindow(bool useWindow, int windowLength, int windowRight);
-    u32  nClasses() const {
+
+    u32 nClasses() const {
         return classLabels_.size();
     }
 
diff --git a/src/Signal/ComplexVectorFunction.hh b/src/Signal/ComplexVectorFunction.hh
index 5b2b136ea..06c1a0f7b 100644
--- a/src/Signal/ComplexVectorFunction.hh
+++ b/src/Signal/ComplexVectorFunction.hh
@@ -27,7 +27,10 @@ namespace Signal {
  *  length of output is set according to the number of input complex numbers
  */
 template<class T>
-struct alternatingComplexVectorAmplitude : std::unary_function<T, T> {
+struct alternatingComplexVectorAmplitude {
+    using argument_type = T;
+    using result_type   = T;
+
     static std::string name() {
         return std::string("vector-alternating-complex-") + Core::Type<T>::name + "-amplitude";
     }
@@ -43,11 +46,38 @@ struct alternatingComplexVectorAmplitude : std::unary_function<T, T> {
     }
 };
 
+/** returns the absolute square vector of the input alternating complex vector
+ *  length of output is set according to the number of input complex numbers
+ */
+template<class T>
+struct alternatingComplexVectorAbsoluteSquare {
+    using argument_type = T;
+    using result_type   = T;
+
+    static std::string name() {
+        return std::string("vector-alternating-complex-") + Core::Type<T>::name + "-absolute-square";
+    }
+
+    /** x and result can be one object */
+    void operator()(const std::vector<T>& x, std::vector<T>& result) {
+        if (&x != &result) {
+            result.resize(x.size() / 2);
+        }
+
+        Math::transformAlternatingComplex(x.begin(), x.end(), result.begin(), Math::pointerAbsSqr<T>());
+
+        result.resize(x.size() / 2);
+    }
+};
+
 /** returns the phase vector of the input alternating complex vector
  *  length of output is set according to the number of input complex numbers
  */
 template<class T>
-struct alternatingComplexVectorPhase : std::unary_function<T, T> {
+struct alternatingComplexVectorPhase {
+    using argument_type = T;
+    using result_type   = T;
+
     static std::string name() {
         return std::string("vector-alternating-complex-") + Core::Type<T>::name + "-phase";
     }
@@ -67,7 +97,10 @@ struct alternatingComplexVectorPhase : std::unary_function<T, T> {
  *  length of output is set according to the number of input complex numbers
  */
 template<class T>
-struct alternatingComplexVectorRealPart : std::unary_function<T, T> {
+struct alternatingComplexVectorRealPart {
+    using argument_type = T;
+    using result_type   = T;
+
     static std::string name() {
         return std::string("vector-alternating-complex-") + Core::Type<T>::name + "-real-part";
     }
@@ -87,7 +120,10 @@ struct alternatingComplexVectorRealPart : std::unary_function<T, T> {
  *  length of output is set according to the number of input complex numbers
  */
 template<class T>
-struct alternatingComplexVectorImaginaryPart : std::unary_function<T, T> {
+struct alternatingComplexVectorImaginaryPart {
+    using argument_type = T;
+    using result_type   = T;
+
     static std::string name() {
         return std::string("vector-alternating-complex-") + Core::Type<T>::name + "-imaginary-part";
     }
@@ -108,7 +144,10 @@ struct alternatingComplexVectorImaginaryPart : std::unary_function<T, T> {
  *  length of output is set according to the size of input.
  */
 template<class T>
-struct vectorToAlternatingComplexVector : std::unary_function<T, T> {
+struct vectorToAlternatingComplexVector {
+    using argument_type = T;
+    using result_type   = T;
+
     static std::string name() {
         return std::string("vector-") + Core::Type<T>::name +
                "-to-vector-alternating-complex-" + Core::Type<T>::name;
@@ -116,7 +155,7 @@ struct vectorToAlternatingComplexVector : std::unary_function<T, T> {
     void operator()(const std::vector<T>& x, std::vector<T>& result) {
         result.resize(x.size() * 2);
 
-        Math::transformToAlternatingComplex(x.begin(), x.end(), result.begin(), std::bind2nd(Math::makeComplex<T>(), 0));
+        Math::transformToAlternatingComplex(x.begin(), x.end(), result.begin(), std::bind(Math::makeComplex<T>(), std::placeholders::_1, 0));
     }
 };
 
@@ -124,7 +163,10 @@ struct vectorToAlternatingComplexVector : std::unary_function<T, T> {
  *  length of output is set according to the number of input complex numbers.
  */
 template<class T>
-struct alternatingComplexVectorToComplexVector : std::unary_function<T, std::complex<T>> {
+struct alternatingComplexVectorToComplexVector {
+    using argument_type = T;
+    using result_type   = std::complex<T>;
+
     static std::string name() {
         return std::string("vector-alternating-complex-") + Core::Type<T>::name +
                "-to-vector-complex-" + Core::Type<T>::name;
@@ -140,7 +182,10 @@ struct alternatingComplexVectorToComplexVector : std::unary_function<T, std::com
  *  length of output is set according to the number size of input.
  */
 template<class T>
-struct complexVectorToAlternatingComplexVector : std::unary_function<std::complex<T>, T> {
+struct complexVectorToAlternatingComplexVector {
+    using argument_type = std::complex<T>;
+    using result_type   = T;
+
     static std::string name() {
         return std::string("vector-complex-") + Core::Type<T>::name +
                "-to-vector-alternating-complex-" + Core::Type<T>::name;
@@ -153,7 +198,7 @@ struct complexVectorToAlternatingComplexVector : std::unary_function<std::comple
 };
 
 /** ComplexVectorFunctionNode is a node class
- *  for different complex unary functions (derived from std::unary_function)
+ *  for different complex unary functions
  */
 template<class Function>
 class ComplexVectorFunctionNode : public SleeveNode {
@@ -170,7 +215,8 @@ public:
     }
 
     ComplexVectorFunctionNode(const Core::Configuration& c)
-            : Core::Component(c), SleeveNode(c) {}
+            : Core::Component(c),
+              SleeveNode(c) {}
 
     virtual ~ComplexVectorFunctionNode() {}
 
diff --git a/src/Signal/CosineTransform.cc b/src/Signal/CosineTransform.cc
index 384987eb6..b6dec6379 100644
--- a/src/Signal/CosineTransform.cc
+++ b/src/Signal/CosineTransform.cc
@@ -18,7 +18,8 @@ using namespace Signal;
 
 //==================================================================================================
 CosineTransform::CosineTransform()
-        : N_(0), normalize_(false) {}
+        : N_(0),
+          normalize_(false) {}
 
 void CosineTransform::init(InputType                      inputType,
                            size_t                         inputSize,
@@ -77,7 +78,7 @@ void CosineTransform::apply(const std::vector<Value>& in, std::vector<Value>& ou
     out = transformation_ * in;
     if (normalize_) {
         verify_(N_ > 0);
-        std::transform(out.begin(), out.end(), out.begin(), std::bind2nd(std::divides<Value>(), N_));
+        std::transform(out.begin(), out.end(), out.begin(), std::bind(std::divides<Value>(), std::placeholders::_1, N_));
     }
 }
 
diff --git a/src/Signal/CosineTransform.hh b/src/Signal/CosineTransform.hh
index b83a306ee..8fa55701e 100644
--- a/src/Signal/CosineTransform.hh
+++ b/src/Signal/CosineTransform.hh
@@ -27,8 +27,10 @@ class CosineTransform {
 public:
     typedef f32 Value;
 
-    enum InputType { NplusOneData,
-                     evenAboutNminusHalf };
+    enum InputType {
+        NplusOneData,
+        evenAboutNminusHalf
+    };
 
 private:
     Math::Matrix<Value> transformation_;
@@ -145,7 +147,8 @@ private:
     f64 timeDomainSampleRate(size_t inputSize);
 
     Math::UnaryAnalyticFunctionRef createWarpingFunction(f64 sampleRate);
-    void                           setWarpDifferentialUnit(bool should) {
+
+    void setWarpDifferentialUnit(bool should) {
         if (shouldWarpDifferenctialUnit_ != should) {
             shouldWarpDifferenctialUnit_ = should;
             needInit_                    = true;
diff --git a/src/Signal/CrossCorrelation.cc b/src/Signal/CrossCorrelation.cc
index c5cc8bfd3..85072b4e1 100644
--- a/src/Signal/CrossCorrelation.cc
+++ b/src/Signal/CrossCorrelation.cc
@@ -21,7 +21,12 @@ using namespace Signal;
 
 //========================================================================================================
 CrossCorrelation::CrossCorrelation()
-        : begin_(0), end_(0), similarityFunctionType_(Multiplication), power_(1.0), normalizationType_(None), useFastFourierTransform_(true) {}
+        : begin_(0),
+          end_(0),
+          similarityFunctionType_(Multiplication),
+          power_(1.0),
+          normalizationType_(None),
+          useFastFourierTransform_(true) {}
 
 void CrossCorrelation::crossCorrelation(const std::vector<Data>& x,
                                         const std::vector<Data>& y,
@@ -198,7 +203,13 @@ const ParameterChoice CrossCorrelationNode::paramNormalizationType("normalizatio
 const ParameterBool CrossCorrelationNode::paramUseFastFourierTransform("use-fft", "use/not FFT for correlation", true);
 
 CrossCorrelationNode::CrossCorrelationNode(const Core::Configuration& c)
-        : Core::Component(c), Node(c), continuousBegin_(0), continuousEnd_(0), sampleRate_(0), nCoefficients_(0), needInit_(true) {
+        : Core::Component(c),
+          Node(c),
+          continuousBegin_(0),
+          continuousEnd_(0),
+          sampleRate_(0),
+          nCoefficients_(0),
+          needInit_(true) {
     setContinuousBegin(paramBegin(c));
     setContinuousEnd(paramEnd(c));
     setNumberOfCoefficients(paramNumberOfCoefficients(c));
diff --git a/src/Signal/CrossCorrelation.hh b/src/Signal/CrossCorrelation.hh
index eea2b1b6e..176acab6e 100644
--- a/src/Signal/CrossCorrelation.hh
+++ b/src/Signal/CrossCorrelation.hh
@@ -31,13 +31,14 @@ namespace Signal {
  * Leads to the so called unbiased estimate of the cross-correaltion function
  */
 template<class Argument>
-class normalizeCrossCorrelationEstimate : std::binary_function<Argument, s32, Argument> {
+class normalizeCrossCorrelationEstimate {
     s32 sizeX_;
     s32 sizeY_;
 
 public:
     normalizeCrossCorrelationEstimate(const std::vector<Argument>& x, const std::vector<Argument>& y)
-            : sizeX_((s32)x.size()), sizeY_((s32)y.size()) {}
+            : sizeX_((s32)x.size()),
+              sizeY_((s32)y.size()) {}
 
     Argument operator()(Argument element, s32 m) {
         s32 N = std::min(sizeX_ - m, sizeY_) - std::max(0, -m);
@@ -53,7 +54,7 @@ public:
  *   of their autocorrelation is 1.
  */
 template<class Argument>
-class normalizeCrossCorrelationUpperBound : std::binary_function<Argument, s32, Argument> {
+class normalizeCrossCorrelationUpperBound {
     Argument upperBound_;
 
 public:
@@ -70,7 +71,7 @@ public:
  *   0 <= Qxy(m) / (sqrt(Rxx(0)) + sqrt(Ryy(0)))^2 <= 1
  */
 template<class Argument>
-class normalizeCrossSquareDifferenceUpperBound : std::binary_function<Argument, s32, Argument> {
+class normalizeCrossSquareDifferenceUpperBound {
     Argument upperBound_;
 
 public:
@@ -89,7 +90,7 @@ public:
  *   0 <= Dxy(m) / [sum( abs(x(t)) ) + sum( abs(y(t)) )] <= 1
  */
 template<class Argument>
-class normalizeCrossAbsoluteDifferenceUpperBound : std::binary_function<Argument, s32, Argument> {
+class normalizeCrossAbsoluteDifferenceUpperBound {
     Argument upperBound_;
 
 public:
@@ -129,11 +130,15 @@ class CrossCorrelation {
 public:
     typedef f32 Data;
 
-    enum SimilarityFunctionType { Multiplication,
-                                  AbsoluteDifference };
-    enum NormalizationType { None,
-                             UnbiasedEstimate,
-                             UpperBound };
+    enum SimilarityFunctionType {
+        Multiplication,
+        AbsoluteDifference
+    };
+    enum NormalizationType {
+        None,
+        UnbiasedEstimate,
+        UpperBound
+    };
 
 private:
     std::vector<Data> X_;
diff --git a/src/Signal/DcDetection.cc b/src/Signal/DcDetection.cc
index eefa974d7..9efcd80d7 100644
--- a/src/Signal/DcDetection.cc
+++ b/src/Signal/DcDetection.cc
@@ -248,7 +248,8 @@ ParameterInt DcDetectionNode::paramMaximalOutputSize(
         "maximal-output-size", "maximal size of output", 4096, 1);
 
 DcDetectionNode::DcDetectionNode(const Core::Configuration& c)
-        : Component(c), Predecessor(c) {
+        : Component(c),
+          Predecessor(c) {
     setMinDcLengthInS(paramMinDcLength(c));
     setMaxDcIncrement(paramMaxDcIncrement(c));
     setMinNonDcSegmentLengthInS(paramMinNonDcSegmentLength(c));
diff --git a/src/Signal/Delimiter.hh b/src/Signal/Delimiter.hh
index 4b302c298..bbc63f386 100644
--- a/src/Signal/Delimiter.hh
+++ b/src/Signal/Delimiter.hh
@@ -51,6 +51,7 @@ public:
         M_.clear();
         M_.push_back(0);
     }
+
     void feed(f64 xx) {
         M_.push_back(M_.back() + xx);
         if (f_ > 0) {
@@ -62,8 +63,10 @@ public:
         if (Q_.back() > Core::Type<f64>::max)
             error("delimit overflow => segment to long?");
     }
+
     virtual Delimitation getDelimitation() const;
-    const u32            nFeatures() const {
+
+    const u32 nFeatures() const {
         verify(Q_.size() == M_.size());
         return Q_.size() - 1;
     }
diff --git a/src/Signal/FastFourierTransform.cc b/src/Signal/FastFourierTransform.cc
index f67bfdd78..5ff58ccce 100644
--- a/src/Signal/FastFourierTransform.cc
+++ b/src/Signal/FastFourierTransform.cc
@@ -20,7 +20,9 @@ using namespace Signal;
 
 FastFourierTransform::FastFourierTransform(u32 length, Data sampleRate)
         : length_(0),
-          sampleRate_(0) {
+          sampleRate_(0),
+          applyScale_(true),
+          rightPadding_(true) {
     setLength(length);
     setInputSampleRate(sampleRate);
 }
@@ -38,17 +40,34 @@ u32 FastFourierTransform::setLength(u32 length) {
     return (length_ = (1 << (u32)power));
 }
 
+void FastFourierTransform::setApplyScale(bool applyScale) {
+    applyScale_ = applyScale;
+}
+
+void FastFourierTransform::setPaddingType(bool rightPadding) {
+    rightPadding_ = rightPadding;
+}
+
 bool FastFourierTransform::zeroPadding(std::vector<Data>& data) {
     require_(data.size() <= maximalInputSize());
     data.resize(maximalInputSize(), 0);
     return true;
 }
 
+bool FastFourierTransform::zeroLeftRightPadding(std::vector<Data>& data) {
+    require_(data.size() <= maximalInputSize());
+    size_t left_pad_len  = (maximalInputSize() - data.size()) / 2;
+    size_t right_pad_len = maximalInputSize() - data.size() - left_pad_len;
+    data.insert(data.begin(), left_pad_len, 0);
+    data.insert(data.end(), right_pad_len, 0);
+    return true;
+}
+
 bool FastFourierTransform::estimateContinuous(std::vector<Data>& data) {
     verify_(sampleRate_ > 0);
     if (sampleRate_ != 1) {
         std::transform(data.begin(), data.end(), data.begin(),
-                       std::bind2nd(std::multiplies<Data>(), 1 / (Data)sampleRate_));
+                       std::bind(std::multiplies<Data>(), std::placeholders::_1, 1 / (Data)sampleRate_));
     }
     return true;
 }
@@ -60,9 +79,7 @@ bool FastFourierTransform::transform(std::vector<Data>& data) {
         return false;
     }
 
-    return zeroPadding(data) &&
-           applyAlgorithm(data) &&
-           estimateContinuous(data);
+    return (rightPadding_ ? zeroPadding(data) : zeroLeftRightPadding(data)) && applyAlgorithm(data) && (applyScale_ ? estimateContinuous(data) : true);
 }
 
 // RealFastFourierTransform
@@ -109,7 +126,7 @@ bool RealInverseFastFourierTransform::estimateContinuous(std::vector<Data>& data
     verify_(sampleRate_ > 0);
     if (sampleRate_ != 2) {
         std::transform(data.begin(), data.end(), data.begin(),
-                       std::bind2nd(std::multiplies<Data>(), 2 / (Data)sampleRate_));
+                       std::bind(std::multiplies<Data>(), std::placeholders::_1, 2 / (Data)sampleRate_));
     }
     return true;
 }
@@ -132,3 +149,9 @@ const Core::ParameterInt Signal::paramFftLength(
 
 const Core::ParameterFloat Signal::paramFftMaximumInputSize(
         "maximum-input-size", "number of FFT points = max-input-size * sampe-rate", 0, 0);
+
+const Core::ParameterBool Signal::paramApplyScale(
+        "apply-scale", "wether to scale FFT result", true);
+
+const Core::ParameterBool Signal::paramRightPadding(
+        "right-padding", "wether to add padding in the tail", true);
diff --git a/src/Signal/FastFourierTransform.hh b/src/Signal/FastFourierTransform.hh
index 0c0a008ad..24d7b5fd4 100644
--- a/src/Signal/FastFourierTransform.hh
+++ b/src/Signal/FastFourierTransform.hh
@@ -31,11 +31,14 @@ protected:
     u32 length_;
     /** sample rate of input vector. */
     f64                        sampleRate_;
+    bool                       applyScale_;
+    bool                       rightPadding_;
     Math::FastFourierTransform fft_;
     std::string                lastError_;
 
 protected:
     virtual bool zeroPadding(std::vector<Data>& data);
+    bool         zeroLeftRightPadding(std::vector<Data>& data);
     virtual bool applyAlgorithm(std::vector<Data>& data) = 0;
     /** Calculates an estimation of the continuous values.
      *  Each element is multiplied by {\Delta t} resp. {\Delta \omega}.
@@ -61,6 +64,14 @@ public:
      */
     u32 setLength(u32 length);
 
+    /** sets wether scale the FFT results by dividing with sample rate
+     */
+    void setApplyScale(bool applyScale);
+
+    /** sets wether padding must be inserted in the tail
+     */
+    void setPaddingType(bool rightPadding);
+
     /** @return maximum input size for the number of FFT points.
      */
     virtual u32 maximalInputSize() const = 0;
@@ -209,6 +220,8 @@ public:
 
 extern const Core::ParameterInt   paramFftLength;
 extern const Core::ParameterFloat paramFftMaximumInputSize;
+extern const Core::ParameterBool  paramApplyScale;
+extern const Core::ParameterBool  paramRightPadding;
 
 /** FastFourierTransformNode
  */
@@ -217,8 +230,11 @@ class FastFourierTransformNode : public SleeveNode {
 private:
     Algorithm algorithm_;
 
-    u32 length_;
-    f64 maximumInputSize_;
+    u32  length_;
+    f64  maximumInputSize_;
+    bool applyScale_;
+    bool rightPadding_;
+
     u32 length(f64 sampleRate) const;
 
 public:
@@ -239,7 +255,9 @@ FastFourierTransformNode<Algorithm>::FastFourierTransformNode(const Core::Config
         : Component(c),
           SleeveNode(c),
           length_(paramFftLength(c)),
-          maximumInputSize_(paramFftMaximumInputSize(c)) {}
+          maximumInputSize_(paramFftMaximumInputSize(c)),
+          applyScale_(paramApplyScale(c)),
+          rightPadding_(paramRightPadding(c)) {}
 
 template<class Algorithm>
 bool FastFourierTransformNode<Algorithm>::setParameter(
@@ -248,6 +266,10 @@ bool FastFourierTransformNode<Algorithm>::setParameter(
         length_ = paramFftLength(value);
     else if (paramFftMaximumInputSize.match(name))
         maximumInputSize_ = paramFftMaximumInputSize(value);
+    else if (paramApplyScale.match(name))
+        applyScale_ = paramApplyScale(value);
+    else if (paramRightPadding.match(name))
+        rightPadding_ = paramRightPadding(value);
     else
         return false;
     return true;
@@ -266,6 +288,8 @@ bool FastFourierTransformNode<Algorithm>::configure() {
 
     algorithm_.setInputSampleRate(sampleRate);
     algorithm_.setLength(length(sampleRate));
+    algorithm_.setApplyScale(applyScale_);
+    algorithm_.setPaddingType(rightPadding_);
     a->set("sample-rate", algorithm_.outputSampleRate());
 
     return putOutputAttributes(0, a);
diff --git a/src/Signal/FastHartleyTransform.cc b/src/Signal/FastHartleyTransform.cc
index c65ba8ae5..3389ed095 100644
--- a/src/Signal/FastHartleyTransform.cc
+++ b/src/Signal/FastHartleyTransform.cc
@@ -301,7 +301,7 @@ void FastHartleyTransform::transform(std::vector<Data>& data) const {
 
     if (sampleRate_ != 1) {
         std::transform(data.begin(), data.end(), data.begin(),
-                       std::bind2nd(std::multiplies<Data>(), 1 / (Data)sampleRate_));
+                       std::bind(std::multiplies<Data>(), std::placeholders::_1, 1 / (Data)sampleRate_));
     }
 }
 
@@ -311,7 +311,7 @@ void FastHartleyTransform::inverseTransform(std::vector<Data>& data) const {
     hartleyTransform(data);
 
     std::transform(data.begin(), data.end(), data.begin(),
-                   std::bind2nd(std::multiplies<Data>(), (Data)sampleRate_ / (Data)length()));
+                   std::bind(std::multiplies<Data>(), std::placeholders::_1, (Data)sampleRate_ / (Data)length()));
 }
 
 void hartleyToFourier(const std::vector<f32>& hartley, std::vector<f32>& fourier) {
diff --git a/src/Signal/Filterbank.cc b/src/Signal/Filterbank.cc
index 3e551dffc..326c73cbe 100644
--- a/src/Signal/Filterbank.cc
+++ b/src/Signal/Filterbank.cc
@@ -42,7 +42,9 @@ class FilterBank::Filter : public Core::ReferenceCounted {
 };
 
 FilterBank::Filter::Filter(size_t start, size_t end, const std::vector<FilterWeight>& weights)
-        : start_(start), end_(end), weights_(weights) {
+        : start_(start),
+          end_(end),
+          weights_(weights) {
     require(end_ >= start_);
     require(end_ - start_ == weights_.size());
 }
@@ -56,7 +58,7 @@ void FilterBank::Filter::normalize(FilterBank::NormalizationType normalizationTy
         else
             defect();
         std::transform(weights_.begin(), weights_.end(), weights_.begin(),
-                       std::bind2nd(std::divides<FilterWeight>(), normalizationTerm));
+                       std::bind(std::divides<FilterWeight>(), std::placeholders::_1, normalizationTerm));
     }
 }
 
@@ -223,7 +225,8 @@ class SymmetricalTriangularFilterBuilder : public FilterBank::FilterBuilder {
 
 public:
     SymmetricalTriangularFilterBuilder(const Core::Configuration& c)
-            : Core::Component(c), FilterBank::FilterBuilder(c) {}
+            : Core::Component(c),
+              FilterBank::FilterBuilder(c) {}
 
     virtual FilterBank::Frequency normalizedCenterPosition() const {
         return 0.5;
@@ -254,7 +257,8 @@ class TrapezeFilterBuilder : public FilterBank::FilterBuilder {
 
 public:
     TrapezeFilterBuilder(const Core::Configuration& c)
-            : Core::Component(c), FilterBank::FilterBuilder(c) {}
+            : Core::Component(c),
+              FilterBank::FilterBuilder(c) {}
 
     virtual FilterBank::Frequency normalizedCenterPosition() const {
         return 2.5 / (1.3 - (-2.5));
@@ -291,7 +295,8 @@ class TrapezeRastaFilterBuilder : public FilterBank::FilterBuilder {
 
 public:
     TrapezeRastaFilterBuilder(const Core::Configuration& c)
-            : Core::Component(c), FilterBank::FilterBuilder(c) {}
+            : Core::Component(c),
+              FilterBank::FilterBuilder(c) {}
 
     virtual FilterBank::Frequency normalizedCenterPosition() const {
         return 2.5 / (1.3 - (-2.5));
@@ -479,7 +484,8 @@ class IncludeBoundary : public FilterBank::Boundary {
 
 public:
     IncludeBoundary(const Core::Configuration& c)
-            : Core::Component(c), FilterBank::Boundary(c) {}
+            : Core::Component(c),
+              FilterBank::Boundary(c) {}
     virtual Frequency center(size_t filterIndex) const {
         return warpingFunction_->value(spacing_ * (filterIndex + 1));
     }
@@ -515,7 +521,8 @@ class StretchToCover : public FilterBank::Boundary {
 
 public:
     StretchToCover(const Core::Configuration& c)
-            : Core::Component(c), FilterBank::Boundary(c) {}
+            : Core::Component(c),
+              FilterBank::Boundary(c) {}
 
     virtual bool init(Frequency                      filterWidth,
                       Frequency                      spacing,
@@ -571,7 +578,8 @@ class EmphasizeBoundary : public FilterBank::Boundary {
 
 public:
     EmphasizeBoundary(const Core::Configuration& c)
-            : Core::Component(c), FilterBank::Boundary(c) {}
+            : Core::Component(c),
+              FilterBank::Boundary(c) {}
 
     virtual Frequency center(size_t filterIndex) const {
         return warpingFunction_->value(spacing_ * filterIndex);
diff --git a/src/Signal/Filterbank.hh b/src/Signal/Filterbank.hh
index f2a907a23..04d00a02c 100644
--- a/src/Signal/Filterbank.hh
+++ b/src/Signal/Filterbank.hh
@@ -52,14 +52,20 @@ public:
     typedef f64  Frequency;
     typedef f32  Data;
     typedef Data FilterWeight;
-    enum FilterType { typeTriangular,
-                      typeTrapeze,
-                      typeRastaTrapeze };
-    enum BoundaryType { includeBoundary,
-                        stretchToCover,
-                        emphasizeBoundary };
-    enum NormalizationType { normalizeNone,
-                             normalizeSurface };
+    enum FilterType {
+        typeTriangular,
+        typeTrapeze,
+        typeRastaTrapeze
+    };
+    enum BoundaryType {
+        includeBoundary,
+        stretchToCover,
+        emphasizeBoundary
+    };
+    enum NormalizationType {
+        normalizeNone,
+        normalizeSurface
+    };
 
 public:
     class Filter;
@@ -156,7 +162,8 @@ public:
     void      apply(const std::vector<Data>& in, std::vector<Data>& out);
     Frequency outputSampleRate();
     void      dump(Core::XmlWriter&);
-    bool      isConfigurationAllowed() {
+
+    bool isConfigurationAllowed() {
         return !needInit_ || init();
     }
 };
diff --git a/src/Signal/Formant.hh b/src/Signal/Formant.hh
index 6c05137c8..396f9a845 100644
--- a/src/Signal/Formant.hh
+++ b/src/Signal/Formant.hh
@@ -34,7 +34,10 @@ public:
     _float energy_;
 
     Formant()
-            : frequency_(0), amplitude_(0), bandwidth_(0), energy_(0) {}
+            : frequency_(0),
+              amplitude_(0),
+              bandwidth_(0),
+              energy_(0) {}
 
     Core::XmlWriter& dump(Core::XmlWriter& o) {
         return o << Core::XmlEmpty("formant") + Core::XmlAttribute("frequency", frequency_) + Core::XmlAttribute("amplitude", amplitude_) + Core::XmlAttribute("bandwidth", bandwidth_) + Core::XmlAttribute("energy", energy_);
@@ -64,7 +67,9 @@ protected:
 
 public:
     FormantExtraction(const Core::Configuration& c)
-            : Component(c), sample_rate_(0), max_nr_formant_(0) {}
+            : Component(c),
+              sample_rate_(0),
+              max_nr_formant_(0) {}
     virtual ~FormantExtraction() {}
 
     u8 getMaxNrFormant() {
diff --git a/src/Signal/FrameInterpolation.hh b/src/Signal/FrameInterpolation.hh
index f37449b41..a77838945 100644
--- a/src/Signal/FrameInterpolation.hh
+++ b/src/Signal/FrameInterpolation.hh
@@ -41,7 +41,8 @@ public:
 
 template<class Algorithm>
 FrameInterpolationNode<Algorithm>::FrameInterpolationNode(const Core::Configuration& c)
-        : Core::Component(c), Precursor(c) {
+        : Core::Component(c),
+          Precursor(c) {
     this->setOrder(paramFrameInterpolationOrder(c));
 }
 
diff --git a/src/Signal/FramePrediction.hh b/src/Signal/FramePrediction.hh
index 53f5ab4b0..18815d5c2 100644
--- a/src/Signal/FramePrediction.hh
+++ b/src/Signal/FramePrediction.hh
@@ -49,7 +49,8 @@ public:
 
 template<class Algorithm>
 FramePredictionNode<Algorithm>::FramePredictionNode(const Core::Configuration& c)
-        : Core::Component(c), Precursor(c) {
+        : Core::Component(c),
+          Precursor(c) {
     this->setPredictOnlyMissing(paramPredictOnlyMissing(c));
     this->setSyncEndTimes(paramSyncEndTimes(c));
 }
diff --git a/src/Signal/GammaTone.hh b/src/Signal/GammaTone.hh
index 17d47391c..4ece227cb 100644
--- a/src/Signal/GammaTone.hh
+++ b/src/Signal/GammaTone.hh
@@ -84,8 +84,10 @@ public:
     };
 
     // Type of center frequency distribution mode
-    enum CenterFrequencyModeType { Human,
-                                   Erb };
+    enum CenterFrequencyModeType {
+        Human,
+        Erb
+    };
 
 private:
     WarpingFunction warp_;
@@ -197,12 +199,15 @@ public:
 
     // calls the other private init() function
     virtual void init();  // There is no check, whether GammaTone is OK. The child object has to do this.
-    void         reset() {
+
+    void reset() {
         needInit_ = true;
     }
+
     bool checkParam() {
         return warp_.checkParam();
     }
+
     void apply(const Flow::Vector<f32>& in, Flow::Vector<Flow::Vector<f32>>& out);
 };  // class GammaTone
 
@@ -235,7 +240,8 @@ private:
 
 public:
     typedef Flow::Vector<Flow::Vector<f32>> BasiliarMembraneData;
-    static std::string                      filterName() {
+
+    static std::string filterName() {
         return "signal-gammatone";
     }
 
diff --git a/src/Signal/GenericWarping.cc b/src/Signal/GenericWarping.cc
index 2c42289d7..67dfd853e 100644
--- a/src/Signal/GenericWarping.cc
+++ b/src/Signal/GenericWarping.cc
@@ -21,7 +21,10 @@ const Core::ParameterString GenericWarpingNode::paramWarpingFunction(
         "warping-function", "warping function declaration");
 
 GenericWarpingNode::GenericWarpingNode(const Core::Configuration& c)
-        : Component(c), Node(c), WarpingNode(c), Flow::StringExpressionNode(c, 1) {
+        : Component(c),
+          Node(c),
+          WarpingNode(c),
+          Flow::StringExpressionNode(c, 1) {
     Flow::StringExpressionNode::setTemplate(paramWarpingFunction(c));
 }
 
diff --git a/src/Signal/HarmonicSum.cc b/src/Signal/HarmonicSum.cc
index a3afd8523..f17071f1c 100644
--- a/src/Signal/HarmonicSum.cc
+++ b/src/Signal/HarmonicSum.cc
@@ -25,7 +25,13 @@ ParameterFloat HarmonicSumNode::paramSize("size", "size in continous unit depend
 ParameterInt HarmonicSumNode::paramH("H", "max number of harmonics (0: use all harmonics)", 0, 0);
 
 HarmonicSumNode::HarmonicSumNode(const Configuration& c)
-        : Core::Component(c), SleeveNode(c), continuousSize_(0), size_(0), H_(0), sampleRate_(0), needInit_(true) {
+        : Core::Component(c),
+          SleeveNode(c),
+          continuousSize_(0),
+          size_(0),
+          H_(0),
+          sampleRate_(0),
+          needInit_(true) {
     setContinuousSize(paramSize(c));
     setH(paramH(c));
 }
diff --git a/src/Signal/HarmonicSum.hh b/src/Signal/HarmonicSum.hh
index 6ca4cac90..bc23168c0 100644
--- a/src/Signal/HarmonicSum.hh
+++ b/src/Signal/HarmonicSum.hh
@@ -174,7 +174,8 @@ public:
     }
 
     HarmonicProductNode(const Core::Configuration& c)
-            : Core::Component(c), Precursor(c) {}
+            : Core::Component(c),
+              Precursor(c) {}
 
     virtual ~HarmonicProductNode() {}
 };
diff --git a/src/Signal/Histogram.hh b/src/Signal/Histogram.hh
index 073f690e8..960a67320 100644
--- a/src/Signal/Histogram.hh
+++ b/src/Signal/Histogram.hh
@@ -76,7 +76,7 @@ void Histogram<Value>::getCdf(LookupTable<Probability, Value>& cdf) const {
     cdf = *this;
     std::partial_sum(cdf.begin(), cdf.end(), cdf.begin());
     std::transform(cdf.begin(), cdf.end(), cdf.begin(),
-                   std::bind2nd(std::divides<Probability>(), this->sum()));
+                   std::bind(std::divides<Probability>(), std::placeholders::_1, this->sum()));
 }
 
 /**
diff --git a/src/Signal/HistogramNormalization.cc b/src/Signal/HistogramNormalization.cc
index def27aaf3..d50547fb3 100644
--- a/src/Signal/HistogramNormalization.cc
+++ b/src/Signal/HistogramNormalization.cc
@@ -76,9 +76,9 @@ void HistogramNormalization::apply(const std::vector<Value>& in, std::vector<Val
 
 bool HistogramNormalization::areScalesWellDefined(const std::vector<HistogramWeight>& scales) {
     // 0 <= scale <= 1
-    if (std::find_if(scales.begin(), scales.end(), std::bind2nd(std::less<HistogramWeight>(), 0)) != scales.end())
+    if (std::find_if(scales.begin(), scales.end(), std::bind(std::less<HistogramWeight>(), std::placeholders::_1, 0)) != scales.end())
         return false;
-    if (std::find_if(scales.begin(), scales.end(), std::bind2nd(std::greater<HistogramWeight>(), 1)) != scales.end())
+    if (std::find_if(scales.begin(), scales.end(), std::bind(std::greater<HistogramWeight>(), std::placeholders::_1, 1)) != scales.end())
         return false;
     return true;
 }
diff --git a/src/Signal/LikelihoodFunction.hh b/src/Signal/LikelihoodFunction.hh
index 6aac58503..19b759fb9 100644
--- a/src/Signal/LikelihoodFunction.hh
+++ b/src/Signal/LikelihoodFunction.hh
@@ -35,7 +35,8 @@ private:
 
 public:
     LikelihoodFunction(const Core::Configuration& c)
-            : Component(c), sumOfWeights_(0) {}
+            : Component(c),
+              sumOfWeights_(0) {}
     virtual ~LikelihoodFunction() {}
 
     virtual bool setClasses(const std::vector<std::string>& classLabels) = 0;
@@ -83,7 +84,8 @@ private:
 private:
     /** Copying of Mm::FeatureScorer not supported. */
     IndependentSequenceLikelihood(const IndependentSequenceLikelihood& v)
-            : Component(v.getConfiguration()), Precursor(v.getConfiguration()) {}
+            : Component(v.getConfiguration()),
+              Precursor(v.getConfiguration()) {}
     IndependentSequenceLikelihood& operator=(const IndependentSequenceLikelihood&) {
         return *this;
     }
diff --git a/src/Signal/LinearFilter.cc b/src/Signal/LinearFilter.cc
index bec28a524..a613e2c48 100644
--- a/src/Signal/LinearFilter.cc
+++ b/src/Signal/LinearFilter.cc
@@ -50,7 +50,8 @@ Core::ParameterString LinearFilterNode::paramY0("y0", "y0 polinom y(-1) ... y(-n
 Core::ParameterInt    LinearFilterNode::paramZeroInputLength("zero-input-length",
                                                              "length of an artificial zero input", 0, 0);
 LinearFilterNode::LinearFilterNode(const Core::Configuration& c)
-        : Core::Component(c), SleeveNode(c) {
+        : Core::Component(c),
+          SleeveNode(c) {
     std::vector<f32> v;
     if (parsePolinom(paramB(c), v))
         setB(v);
diff --git a/src/Signal/LookupTable.hh b/src/Signal/LookupTable.hh
index e15c235bb..bdcbd0ec9 100644
--- a/src/Signal/LookupTable.hh
+++ b/src/Signal/LookupTable.hh
@@ -80,7 +80,9 @@ public:
      *  Creates a lookup table with variable amount of buckets.
      */
     LookupTable(const Index bucketSize = 0)
-            : bucketSize_(bucketSize), offset_(0), grow_(true) {}
+            : bucketSize_(bucketSize),
+              offset_(0),
+              grow_(true) {}
     /**
      *  Creates a lookup table with constant amount of buckets.
      *  Index values smaller than min or larger than max will be set back to min resp. max.
@@ -164,7 +166,9 @@ public:
 
 template<class Value, class Index>
 LookupTable<Value, Index>::LookupTable(const Index bucketSize, const Index min, const Index max)
-        : bucketSize_(bucketSize), offset_(0), grow_(true) {
+        : bucketSize_(bucketSize),
+          offset_(0),
+          grow_(true) {
     require(bucketSize > 0);
     insert(min);
     insert(max);
@@ -201,7 +205,7 @@ template<class Value, class Index>
 void LookupTable<Value, Index>::normalizeSurface() {
     Value s = surface();
     require(s != 0);
-    std::transform(begin(), end(), begin(), std::bind2nd(std::divides<Value>(), s));
+    std::transform(begin(), end(), begin(), std::bind(std::divides<Value>(), std::placeholders::_1, s));
 }
 
 template<class Value, class Index>
@@ -280,7 +284,7 @@ template<class Value, class Index>
 LookupTable<Value, Index>&
         LookupTable<Value, Index>::operator*=(const Value scalar) {
     std::transform(begin(), end(), begin(),
-                   std::bind2nd(std::multiplies<Value>(), scalar));
+                   std::bind(std::multiplies<Value>(), std::placeholders::_1, scalar));
     return *this;
 }
 
diff --git a/src/Signal/Lse.hh b/src/Signal/Lse.hh
index bba5f1d4f..9ac40bb6f 100644
--- a/src/Signal/Lse.hh
+++ b/src/Signal/Lse.hh
@@ -52,7 +52,9 @@ public:
 
     public:
         iterator(T* buffer = 0, u8 row_size = 0, u32 column_size = 0)
-                : buffer_(buffer), row_size_(row_size), column_size_(column_size){};
+                : buffer_(buffer),
+                  row_size_(row_size),
+                  column_size_(column_size){};
 
         operator bool() {
             return buffer_ != 0;
@@ -91,7 +93,13 @@ protected:
 
 public:
     LeastSquares()
-            : nr_sample_(0), nr_parameter_(0), X_(0), y_(0), work_(0), lwork_(0), need_init_(true){};
+            : nr_sample_(0),
+              nr_parameter_(0),
+              X_(0),
+              y_(0),
+              work_(0),
+              lwork_(0),
+              need_init_(true){};
     virtual ~LeastSquares() {
         freeBuffers();
     };
@@ -356,7 +364,10 @@ private:
 
 public:
     LeastSquaresBuilder(LeastSquares<T>& least_squares)
-            : least_squares_(least_squares), order_B_(0), order_A_(0), need_init_(true){};
+            : least_squares_(least_squares),
+              order_B_(0),
+              order_A_(0),
+              need_init_(true){};
 
     void setOrder_B(u8 order_B) {
         if (order_B_ != order_B) {
@@ -468,7 +479,10 @@ private:
 
 public:
     CovarianceBuilder(LeastSquares<T>& least_squares)
-            : least_squares_(least_squares), order_B_(0), order_A_(0), need_init_(true) {}
+            : least_squares_(least_squares),
+              order_B_(0),
+              order_A_(0),
+              need_init_(true) {}
 
     void setOrder_B(u8 order_B) {
         if (order_B_ != order_B) {
@@ -592,7 +606,10 @@ private:
 
 public:
     InstrumentalVariablesBuilder(LeastSquares<T>& least_squares)
-            : least_squares_(least_squares), order_B_(0), order_A_(0), need_init_(true) {}
+            : least_squares_(least_squares),
+              order_B_(0),
+              order_A_(0),
+              need_init_(true) {}
 
     void setOrder_B(u8 order_B) {
         if (order_B_ != order_B) {
diff --git a/src/Signal/MatrixMult.hh b/src/Signal/MatrixMult.hh
index 38ae76f5e..379fcb811 100644
--- a/src/Signal/MatrixMult.hh
+++ b/src/Signal/MatrixMult.hh
@@ -102,7 +102,11 @@ public:
 
 template<class T>
 MatrixMultiplicationNode<T>::MatrixMultiplicationNode(const Core::Configuration& c)
-        : Component(c), Node(c), StringExpressionNode(c, paramMultipleDataProcessing(c)), matrixCache_(0), multiData_(paramMultipleDataProcessing(c)) {
+        : Component(c),
+          Node(c),
+          StringExpressionNode(c, paramMultipleDataProcessing(c)),
+          matrixCache_(0),
+          multiData_(paramMultipleDataProcessing(c)) {
     Flow::StringExpressionNode::setTemplate(paramMatrixMultiplicationFileName(c));
     activateCache(paramMatrixMultiplicationUseCache(c));
     ignoreTimestamps_ = paramIgnoreTimestamps(c);
diff --git a/src/Signal/MeanEstimator.cc b/src/Signal/MeanEstimator.cc
index 145015f10..80f3e4266 100644
--- a/src/Signal/MeanEstimator.cc
+++ b/src/Signal/MeanEstimator.cc
@@ -54,7 +54,7 @@ bool MeanEstimator::finalize(Math::Vector<Data>& mean) const {
         return false;
     }
     mean.resize(featureDimension_);
-    std::transform(vectorSum_.begin(), vectorSum_.end(), mean.begin(), std::bind2nd(std::divides<Sum>(), count_));
+    std::transform(vectorSum_.begin(), vectorSum_.end(), mean.begin(), std::bind(std::divides<Sum>(), std::placeholders::_1, count_));
     return true;
 }
 
diff --git a/src/Signal/MeanEstimator.hh b/src/Signal/MeanEstimator.hh
index 0e7ece234..4cfef3938 100644
--- a/src/Signal/MeanEstimator.hh
+++ b/src/Signal/MeanEstimator.hh
@@ -69,7 +69,9 @@ class MeanEstimatorNode : public Flow::SleeveNode,
 
 public:
     MeanEstimatorNode(const Core::Configuration& c)
-            : Core::Component(c), Precursor(c), MeanEstimator(c) {}
+            : Core::Component(c),
+              Precursor(c),
+              MeanEstimator(c) {}
     virtual ~MeanEstimatorNode() {}
     bool               configure();
     bool               work(Flow::PortId p);
diff --git a/src/Signal/Mrasta.cc b/src/Signal/Mrasta.cc
index 2dddd2bf6..e290111b8 100644
--- a/src/Signal/Mrasta.cc
+++ b/src/Signal/Mrasta.cc
@@ -110,7 +110,7 @@ inline void MrastaFiltering::normalizeFilterResponse(Math::Matrix<Value>& G, int
                                *std::max_element(vector.begin(), vector.end()));
     // normalize vector and write back into the matrix
     std::transform(vector.begin(), vector.end(), vector.begin(),
-                   std::bind2nd(std::multiplies<Value>(), (Value)1 / maxAbsVal));
+                   std::bind(std::multiplies<Value>(), std::placeholders::_1, (Value)1 / maxAbsVal));
     G.setRow(filter_num, vector);
 }
 
@@ -213,7 +213,12 @@ const Core::ParameterInt MrastaFilteringNode::paramGaussFilters(
         "gauss-filter", "number of Gaussian filters", 6);
 
 MrastaFilteringNode::MrastaFilteringNode(const Core::Configuration& c)
-        : Core::Component(c), Precursor(c), contextLength_(0), nDerivatives_(0), nGaussFilters_(0), needInit_(true) {}
+        : Core::Component(c),
+          Precursor(c),
+          contextLength_(0),
+          nDerivatives_(0),
+          nGaussFilters_(0),
+          needInit_(true) {}
 
 MrastaFilteringNode::~MrastaFilteringNode() {}
 
diff --git a/src/Signal/Node.hh b/src/Signal/Node.hh
index 1958c5ae8..2b14fb85b 100644
--- a/src/Signal/Node.hh
+++ b/src/Signal/Node.hh
@@ -33,7 +33,8 @@ private:
 
 public:
     SleeveNode(const Core::Configuration& c)
-            : Core::Component(c), Flow::SleeveNode(c) {}
+            : Core::Component(c),
+              Flow::SleeveNode(c) {}
     virtual ~SleeveNode() {}
 
 protected:
diff --git a/src/Signal/Normalization.hh b/src/Signal/Normalization.hh
index 03695ebf1..399cd4f37 100644
--- a/src/Signal/Normalization.hh
+++ b/src/Signal/Normalization.hh
@@ -100,7 +100,8 @@ protected:
 
 public:
     LevelNormalization(size_t index)
-            : index_(index), max_(0) {}
+            : index_(index),
+              max_(0) {}
 };
 
 /** Arithmetic average of the sliding window is substracted from the output.
@@ -227,7 +228,12 @@ private:
 private:
     Normalization* algorithm_;
 
-    Type type_;
+    Type   type_;
+    size_t length_;
+    size_t right_;
+    size_t levelIndex_;
+    f32    norm_;
+
     void setType(Type type) {
         if (type_ != type) {
             type_     = type;
@@ -235,31 +241,27 @@ private:
         }
     }
 
-    size_t length_;
-    void   setLength(size_t length) {
+    void setLength(size_t length) {
         if (length_ != length) {
             length_   = length;
             needInit_ = true;
         }
     }
 
-    size_t right_;
-    void   setRight(size_t right) {
+    void setRight(size_t right) {
         if (right_ != right) {
             right_    = right;
             needInit_ = true;
         }
     }
 
-    size_t levelIndex_;
-    void   setLevelIndex(size_t index) {
+    void setLevelIndex(size_t index) {
         if (levelIndex_ != index) {
             levelIndex_ = index;
             needInit_   = true;
         }
     }
 
-    f32  norm_;
     void setNorm(f32 norm) {
         if (norm_ != norm) {
             norm_     = norm;
diff --git a/src/Signal/NthOrderFeatures.hh b/src/Signal/NthOrderFeatures.hh
index bb532bd5f..534af5722 100644
--- a/src/Signal/NthOrderFeatures.hh
+++ b/src/Signal/NthOrderFeatures.hh
@@ -80,7 +80,7 @@ protected:
 
 protected:
     template<class T>
-    struct power : public std::unary_function<T, T> {
+    struct power {
     private:
         T n_;
 
diff --git a/src/Signal/PeakDetection.cc b/src/Signal/PeakDetection.cc
index 990d5eda2..a791c31a6 100644
--- a/src/Signal/PeakDetection.cc
+++ b/src/Signal/PeakDetection.cc
@@ -293,7 +293,8 @@ ParameterFloat PeakDetectionNode::paramWidthHeightFactor("width-height-factor",
 ParameterBool PeakDetectionNode::paramMountainWidth("use-mountain-width", "peak/mountain (includes close peaks) width for width confidence", true);
 
 PeakDetectionNode::PeakDetectionNode(const Configuration& c)
-        : Core::Component(c), Node(c) {
+        : Core::Component(c),
+          Node(c) {
     setContinuousMinPosition(paramMinPosition(c));
     setContinuousMaxPosition(paramMaxPosition(c));
     setContinuousMaxWidth(paramMaxWidth(c));
diff --git a/src/Signal/ProjectionNode.hh b/src/Signal/ProjectionNode.hh
index 5c49606c2..b8b14bf47 100644
--- a/src/Signal/ProjectionNode.hh
+++ b/src/Signal/ProjectionNode.hh
@@ -59,7 +59,8 @@ const Core::ParameterString ProjectionNode<T>::paramProjectionComponents(
 
 template<class T>
 ProjectionNode<T>::ProjectionNode(const Core::Configuration& c)
-        : Component(c), SleeveNode(c) {
+        : Component(c),
+          SleeveNode(c) {
     log() << "Initializing projection";
     addInput(0);
     addOutput(0);
diff --git a/src/Signal/QuantileEqualization.hh b/src/Signal/QuantileEqualization.hh
index 83d6672ec..a34d46781 100644
--- a/src/Signal/QuantileEqualization.hh
+++ b/src/Signal/QuantileEqualization.hh
@@ -291,7 +291,8 @@ public:
         return "signal-quantile-equalization";
     }
     QuantileEqualizationNode(const Core::Configuration& c)
-            : Core::Component(c), SleeveNode(c) {
+            : Core::Component(c),
+              SleeveNode(c) {
         setQuantileEqualization(paramQuantileEqualization(c));
         setCombineNeighbors(paramCombineNeighbors(c));
         setQuantileEstimation(paramQuantileEstimation(c));
diff --git a/src/Signal/RandomVector.cc b/src/Signal/RandomVector.cc
index 944b93909..934512bb4 100644
--- a/src/Signal/RandomVector.cc
+++ b/src/Signal/RandomVector.cc
@@ -26,7 +26,14 @@ const Core::ParameterFloat RandomVectorNode::paramFrameShift(
         "frame-shift", "difference between the start time of two subsequent vectors", 1);
 
 RandomVectorNode::RandomVectorNode(const Core::Configuration& c)
-        : Core::Component(c), Precursor(c), randomVectorGenerator_(0), size_(0), sampleRate_(1), startTime_(0), frameShift_(1), nOutputs_(0) {
+        : Core::Component(c),
+          Precursor(c),
+          randomVectorGenerator_(0),
+          size_(0),
+          sampleRate_(1),
+          startTime_(0),
+          frameShift_(1),
+          nOutputs_(0) {
     setType((Math::RandomVectorGenerator::Type)Math::RandomVectorGenerator::paramType(c));
     size_       = paramSize(c);
     sampleRate_ = paramSampleRate(c);
diff --git a/src/Signal/RandomVector.hh b/src/Signal/RandomVector.hh
index 8ebcee52d..32282778d 100644
--- a/src/Signal/RandomVector.hh
+++ b/src/Signal/RandomVector.hh
@@ -53,7 +53,8 @@ private:
 private:
     void                setType(Math::RandomVectorGenerator::Type);
     Flow::Vector<Data>* createOutput() const;
-    void                reset() {
+
+    void reset() {
         nOutputs_ = 0;
     }
 
diff --git a/src/Signal/Regression.cc b/src/Signal/Regression.cc
index 3b72dc4a1..1fcf7578a 100644
--- a/src/Signal/Regression.cc
+++ b/src/Signal/Regression.cc
@@ -68,7 +68,8 @@ const Core::ParameterInt RegressionNode::parameterOrder(
         "order", "order of derivative to calculate", 1, 0);
 
 RegressionNode::RegressionNode(const Core::Configuration& c)
-        : Core::Component(c), Precursor(c) {
+        : Core::Component(c),
+          Precursor(c) {
     order_ = parameterOrder(config);
 }
 
diff --git a/src/Signal/SegmentClustering.hh b/src/Signal/SegmentClustering.hh
index 5d3caeb09..7cc0be84f 100644
--- a/src/Signal/SegmentClustering.hh
+++ b/src/Signal/SegmentClustering.hh
@@ -162,14 +162,18 @@ private:
 
 public:
     BICFullCovMonoGaussianModel(u32 dim)
-            : FullCovMonoGaussianModel::FullCovMonoGaussianModel(dim), glr_(0) {}
+            : FullCovMonoGaussianModel::FullCovMonoGaussianModel(dim),
+              glr_(0) {}
     BICFullCovMonoGaussianModel(u32 dim, f32 alpha)
-            : FullCovMonoGaussianModel::FullCovMonoGaussianModel(dim), glr_(0) {}
+            : FullCovMonoGaussianModel::FullCovMonoGaussianModel(dim),
+              glr_(0) {}
 
     BICFullCovMonoGaussianModel(u32 dim, const std::vector<BICFullCovMonoGaussianModel>& models)
-            : FullCovMonoGaussianModel::FullCovMonoGaussianModel(dim), glr_(0) {}
+            : FullCovMonoGaussianModel::FullCovMonoGaussianModel(dim),
+              glr_(0) {}
     BICFullCovMonoGaussianModel(u32 dim, f32 alpha, const std::vector<BICFullCovMonoGaussianModel>& models)
-            : FullCovMonoGaussianModel::FullCovMonoGaussianModel(dim), glr_(0) {}
+            : FullCovMonoGaussianModel::FullCovMonoGaussianModel(dim),
+              glr_(0) {}
 
     /** @return the N(logDeterminant(variance)) likelihood */
     const f32 likelihood() const {
@@ -222,14 +226,18 @@ private:
 
 public:
     KL2FullCovMonoGaussianModel(u32 dim)
-            : BICFullCovMonoGaussianModel::BICFullCovMonoGaussianModel(dim), kl2_(0) {}
+            : BICFullCovMonoGaussianModel::BICFullCovMonoGaussianModel(dim),
+              kl2_(0) {}
     KL2FullCovMonoGaussianModel(u32 dim, f32 alpha)
-            : BICFullCovMonoGaussianModel::BICFullCovMonoGaussianModel(dim), kl2_(0) {}
+            : BICFullCovMonoGaussianModel::BICFullCovMonoGaussianModel(dim),
+              kl2_(0) {}
 
     KL2FullCovMonoGaussianModel(u32 dim, const std::vector<KL2FullCovMonoGaussianModel>& models)
-            : BICFullCovMonoGaussianModel::BICFullCovMonoGaussianModel(dim), kl2_(0) {}
+            : BICFullCovMonoGaussianModel::BICFullCovMonoGaussianModel(dim),
+              kl2_(0) {}
     KL2FullCovMonoGaussianModel(u32 dim, f32 alpha, const std::vector<KL2FullCovMonoGaussianModel>& models)
-            : BICFullCovMonoGaussianModel::BICFullCovMonoGaussianModel(dim), kl2_(0) {}
+            : BICFullCovMonoGaussianModel::BICFullCovMonoGaussianModel(dim),
+              kl2_(0) {}
 
     /** @return the KL2 distance */
     const f32 score() const {
@@ -442,8 +450,8 @@ public:
             : Core::Component(c),
               bestscore_(-99999.9),
               totalframes_(0),
-              infoChannel_(c, "cluster-info"),
-              minframes_(0){};
+              minframes_(0),
+              infoChannel_(c, "cluster-info"){};
     virtual ~SegmentClustering() {}
 
     /** minimum number of frames to consider the segment for segment clustering */
diff --git a/src/Signal/SegmentEstimator.hh b/src/Signal/SegmentEstimator.hh
index da67592fa..ace1bee22 100644
--- a/src/Signal/SegmentEstimator.hh
+++ b/src/Signal/SegmentEstimator.hh
@@ -33,7 +33,8 @@ protected:
 
 public:
     SegmentwiseEstimator()
-            : current_segment_begin_(-1), current_segment_end_(-1){};
+            : current_segment_begin_(-1),
+              current_segment_end_(-1){};
     virtual ~SegmentwiseEstimator(){};
 
     bool setSegment(s32 segment_begin, s32 segment_end) {
diff --git a/src/Signal/SegmentwiseFormantExtraction.cc b/src/Signal/SegmentwiseFormantExtraction.cc
index f6bc803d1..796b48829 100644
--- a/src/Signal/SegmentwiseFormantExtraction.cc
+++ b/src/Signal/SegmentwiseFormantExtraction.cc
@@ -135,7 +135,9 @@ Core::ParameterInt SegmentwiseFormantExtractionNode::paramStep("step", "devide f
 Core::ParameterInt SegmentwiseFormantExtractionNode::paramMaxFrequency("max-frequency", "frequency range to search", 5000, 0);
 
 SegmentwiseFormantExtractionNode::SegmentwiseFormantExtractionNode(const Core::Configuration& c)
-        : Core::Component(c), SleeveNode(c), SegmentwiseFormantExtraction(c) {
+        : Core::Component(c),
+          SleeveNode(c),
+          SegmentwiseFormantExtraction(c) {
     setOrder(paramOrder(c));
     setMaxNumberOfSegments(paramMaxNumberOfSegments(c));
     setStep(paramStep(c));
diff --git a/src/Signal/SegmentwiseFormantExtraction.hh b/src/Signal/SegmentwiseFormantExtraction.hh
index 7c255be3f..fb41de729 100644
--- a/src/Signal/SegmentwiseFormantExtraction.hh
+++ b/src/Signal/SegmentwiseFormantExtraction.hh
@@ -28,8 +28,12 @@ namespace Signal {
 class SegmentwiseFormantExtraction : public FormantExtraction {
 public:
     typedef f32 _float;
-    enum DomainType { frequency };
-    enum SegmentEstimatorType { dynamic_programing };
+    enum DomainType {
+        frequency
+    };
+    enum SegmentEstimatorType {
+        dynamic_programing
+    };
 
 private:
     u8  order_;
@@ -46,7 +50,13 @@ private:
 
 public:
     SegmentwiseFormantExtraction(const Core::Configuration& c)
-            : Core::Component(c), FormantExtraction(c), order_(0), max_nr_segment_(0), step_(0), segmentwise_estimator_(0), segment_estimator_(0) {}
+            : Core::Component(c),
+              FormantExtraction(c),
+              order_(0),
+              max_nr_segment_(0),
+              step_(0),
+              segmentwise_estimator_(0),
+              segment_estimator_(0) {}
     virtual ~SegmentwiseFormantExtraction() {
         if (segmentwise_estimator_)
             delete segmentwise_estimator_;
@@ -109,7 +119,9 @@ public:
 
 class SegmentwiseFormantExtractionNode : public SleeveNode, public SegmentwiseFormantExtraction {
 public:
-    enum FormantExtractionType { segmentwise };
+    enum FormantExtractionType {
+        segmentwise
+    };
 
 private:
     static Core::Choice          domain_choice;
diff --git a/src/Signal/SilenceDetection.hh b/src/Signal/SilenceDetection.hh
index b6996531a..4cc180e08 100644
--- a/src/Signal/SilenceDetection.hh
+++ b/src/Signal/SilenceDetection.hh
@@ -35,9 +35,11 @@ namespace Signal {
 class SilenceDetection {
 public:
     typedef f32 Float;
-    enum SilenceType { silence,
-                       speech,
-                       unsure };
+    enum SilenceType {
+        silence,
+        speech,
+        unsure
+    };
 
 protected:
     // Frame
@@ -52,9 +54,12 @@ protected:
 
     public:
         Frame()
-                : energy_(0), silence_(unsure) {}
+                : energy_(0),
+                  silence_(unsure) {}
         Frame(const Flow::DataPtr<Flow::Vector<Float>>& data, const Float energyScalingFactor)
-                : Flow::DataPtr<Flow::Vector<Float>>(data), energy_(0), silence_(unsure) {
+                : Flow::DataPtr<Flow::Vector<Float>>(data),
+                  energy_(0),
+                  silence_(unsure) {
             energy_ = getEnergy(energyScalingFactor);
         }
 
@@ -79,7 +84,8 @@ private:
     Float threshold_;
     void  updateThreshold();
     u32   fractile(f32 percent /*[0..1]*/) const;
-    u32   bin(Float v) const {
+
+    u32 bin(Float v) const {
         return (u32)(v < 0 ? 0 : (v > energyHistogram_.size() ? energyHistogram_.size() - 1 : v));
     }
 
@@ -110,7 +116,8 @@ private:
 
 public:
     SilenceDetection()
-            : energyHistogram_(270), need_init_(true) {}
+            : energyHistogram_(270),
+              need_init_(true) {}
     ~SilenceDetection() {}
 
     void setHistogramBufferSize(const u32 size) {
@@ -222,7 +229,8 @@ public:
     }
 
     SilenceDetectionNode(const Core::Configuration& c)
-            : Core::Component(c), SleeveNode(c) {
+            : Core::Component(c),
+              SleeveNode(c) {
         setHistogramBufferSize(paramHistogramBufferSize(c));
         setHistogramBufferDelay(paramHistogramBufferDelay(c));
         setBlockSize(paramBlockSize(c));
diff --git a/src/Signal/SilenceNormalization.cc b/src/Signal/SilenceNormalization.cc
index f61d57fa6..89970205a 100644
--- a/src/Signal/SilenceNormalization.cc
+++ b/src/Signal/SilenceNormalization.cc
@@ -25,7 +25,14 @@ using namespace Signal;
 class GaussianDensity {
 public:
     GaussianDensity(f32 bias = 1.0)
-            : mean_(0), variance_(0), sigma_(0), offset_(0), energySum_(0), energySquareSum_(0), energyCount_(0), bias_(bias) {
+            : mean_(0),
+              variance_(0),
+              sigma_(0),
+              offset_(0),
+              energySum_(0),
+              energySquareSum_(0),
+              energyCount_(0),
+              bias_(bias) {
     }
 
     // Returns the score regarding the gaussian distribution
@@ -454,7 +461,8 @@ ParameterInt SilenceNormalizationNode::paramEMIterations(
         "em-iterations", "number of expectation maximization iterations", 20);
 
 SilenceNormalizationNode::SilenceNormalizationNode(const Core::Configuration& c)
-        : Component(c), Predecessor(c) {
+        : Component(c),
+          Predecessor(c) {
     setSilenceFraction(paramSilenceFraction(c));
     setMinSurroundingSilence(paramMinSurroundingSilence(c));
     setInitializationFraction(paramInitializationFraction(c));
diff --git a/src/Signal/SlidingWindow.hh b/src/Signal/SlidingWindow.hh
index e1751cc88..a73251f80 100644
--- a/src/Signal/SlidingWindow.hh
+++ b/src/Signal/SlidingWindow.hh
@@ -45,10 +45,12 @@ public:
     typedef typename Precursor::reverse_iterator       ReverseIterator;
 
 public:
-    enum MarginPolicyType { marginPolicyCopy,
-                            marginPolicyMean,
-                            marginPolicyZero,
-                            marginPolicyOne };
+    enum MarginPolicyType {
+        marginPolicyCopy,
+        marginPolicyMean,
+        marginPolicyZero,
+        marginPolicyOne
+    };
     /** Base class for margin policies creating missing elements. */
     class marginPolicy {
     protected:
@@ -105,15 +107,14 @@ public:
 
             // ... normalize the sum to get the mean Values
             std::transform(vec.begin(), vec.end(), vec.begin(),
-                           std::bind2nd(std::divides<V>(), (validLast + validFirst + 1)));
+                           std::bind(std::divides<V>(), std::placeholders::_1, (validLast + validFirst + 1)));
 
             return (Flow::DataPtr<Flow::Vector<V>>)(&vec);
         }
 
         virtual void get(int relativeIndex, T& out) const {
             Flow::Vector<f32>* meanVec = new Flow::Vector<f32>();
-            out                        = setMean(
-                    *meanVec);
+            out                        = setMean(*meanVec);
         }
     };
 
diff --git a/src/Signal/SpectralIntegration.hh b/src/Signal/SpectralIntegration.hh
index a31babb24..8c6c2a609 100644
--- a/src/Signal/SpectralIntegration.hh
+++ b/src/Signal/SpectralIntegration.hh
@@ -53,12 +53,14 @@ public:
     void setWindowFunction(WindowFunction* windowFunction);
 
     void setLength(u32 length);
-    u32  length() const {
+
+    u32 length() const {
         return length_;
     }
 
     void setShift(u32 shift);
-    u32  shift() const {
+
+    u32 shift() const {
         return shift_;
     }
 };
diff --git a/src/Signal/TempoRAlPattern.cc b/src/Signal/TempoRAlPattern.cc
index 5ada5cd91..632f2b54d 100644
--- a/src/Signal/TempoRAlPattern.cc
+++ b/src/Signal/TempoRAlPattern.cc
@@ -101,7 +101,9 @@ const Core::ParameterInt TemporalPatternNode::paramOutputSize(
         "output-size", "number of final frames", 16);
 
 TemporalPatternNode::TemporalPatternNode(const Core::Configuration& c)
-        : Core::Component(c), Precursor(c), needInit_(true) {
+        : Core::Component(c),
+          Precursor(c),
+          needInit_(true) {
     setOutputSize(paramOutputSize(c));
     setContextLength(paramContextLength(c));
 }
diff --git a/src/Signal/TempoRAlPattern.hh b/src/Signal/TempoRAlPattern.hh
index 31fdc5fe7..e99075674 100644
--- a/src/Signal/TempoRAlPattern.hh
+++ b/src/Signal/TempoRAlPattern.hh
@@ -120,19 +120,22 @@ class TemporalPatternNode : public Flow::SleeveNode, TemporalPattern {
     typedef f32              Value;
 
 private:
-    bool                            needInit_;
-    void                            init(size_t length);
-    size_t                          contextLength_;
+    bool   needInit_;
+    void   init(size_t length);
+    size_t contextLength_;
+    size_t outputSize_;
+
+    static const Core::ParameterInt paramOutputSize;
     static const Core::ParameterInt paramContextLength;
-    void                            setContextLength(size_t length) {
+
+    void setContextLength(size_t length) {
         if (contextLength_ != length) {
             contextLength_ = length;
             needInit_      = true;
         }
     };
-    size_t                          outputSize_;
-    static const Core::ParameterInt paramOutputSize;
-    void                            setOutputSize(size_t size) {
+
+    void setOutputSize(size_t size) {
         if (outputSize_ != size) {
             outputSize_ = size;
             needInit_   = true;
diff --git a/src/Signal/TemporalIntegration.cc b/src/Signal/TemporalIntegration.cc
index 54e8a8de8..f66ebbd84 100644
--- a/src/Signal/TemporalIntegration.cc
+++ b/src/Signal/TemporalIntegration.cc
@@ -95,7 +95,8 @@ const Core::ParameterBool TemporalIntegrationNode::paramFlushBeforeGap(
         "flush-before-gap", "if true, flushes before a gap in the input samples", true);
 
 TemporalIntegrationNode::TemporalIntegrationNode(const Core::Configuration& c)
-        : Component(c), Predecessor(c) {
+        : Component(c),
+          Predecessor(c) {
     setWindowFunction(WindowFunction::create((WindowFunction::Type)WindowFunction::paramType(c)));
     setShiftInS(paramShift(c));
     setLengthInS(paramLength(c));
diff --git a/src/Signal/TimeWindowBuffer.hh b/src/Signal/TimeWindowBuffer.hh
index 6a2053d32..9e1145f6e 100644
--- a/src/Signal/TimeWindowBuffer.hh
+++ b/src/Signal/TimeWindowBuffer.hh
@@ -34,9 +34,11 @@ template<typename T>
 class TimeWindowBuffer {
 public:
     typedef Flow::Time Time;
-    enum FlushPolicy { SendRest,
-                       PadRest,
-                       DiscardRest };
+    enum FlushPolicy {
+        SendRest,
+        PadRest,
+        DiscardRest
+    };
     typedef Flow::Vector<T> InputData;
     typedef Flow::Vector<T> OutputData;
 
diff --git a/src/Signal/VectorCut.hh b/src/Signal/VectorCut.hh
index 6ebae38e5..a5ac0ec05 100644
--- a/src/Signal/VectorCut.hh
+++ b/src/Signal/VectorCut.hh
@@ -66,7 +66,9 @@ public:
     }
 
     VectorCutLength()
-            : first_(0), last_(0), sampleRate_(0) {}
+            : first_(0),
+              last_(0),
+              sampleRate_(0) {}
 
     virtual ~VectorCutLength() {}
 
@@ -184,7 +186,7 @@ protected:
         T limit = integral_.back() * this->first_;
         return std::distance(integral_.begin(),
                              find_if(integral_.begin(), integral_.end(),
-                                     std::bind2nd(std::greater_equal<Value>(), limit)));
+                                     std::bind(std::greater_equal<Value>(), std::placeholders::_1, limit)));
     }
 
     /** last
@@ -200,7 +202,7 @@ protected:
         T limit = integral_.back() * this->last_;
         return std::distance(integral_.begin(),
                              find_if(integral_.begin(), integral_.end(),
-                                     std::bind2nd(std::greater_equal<Value>(), limit)));
+                                     std::bind(std::greater_equal<Value>(), std::placeholders::_1, limit)));
     }
 
 public:
@@ -226,7 +228,8 @@ public:
     }
 
     VectorCutNode(const Core::Configuration& c)
-            : Core::Component(c), SleeveNode(c) {
+            : Core::Component(c),
+              SleeveNode(c) {
         this->setFirst(paramVectorCutFirst(c));
         this->setLast(paramVectorCutLast(c));
     }
diff --git a/src/Signal/VectorNormalization.hh b/src/Signal/VectorNormalization.hh
index 5c8bbebd8..1d657102a 100644
--- a/src/Signal/VectorNormalization.hh
+++ b/src/Signal/VectorNormalization.hh
@@ -45,7 +45,7 @@ public:
         Value squareMeanEnergy = sqrt(std::inner_product(v.begin(), v.end(), v.begin(), 0.0) / v.size());
 
         std::transform(v.begin(), v.end(), v.begin(),
-                       std::bind2nd(std::multiplies<T>(), (Value)1 / squareMeanEnergy));
+                       std::bind(std::multiplies<T>(), std::placeholders::_1, (Value)1 / squareMeanEnergy));
     }
 };
 
@@ -70,7 +70,7 @@ public:
         Value squareEnergy = sqrt(std::inner_product(v.begin(), v.end(), v.begin(), 0.0));
 
         std::transform(v.begin(), v.end(), v.begin(),
-                       std::bind2nd(std::multiplies<T>(), (Value)1 / squareEnergy));
+                       std::bind(std::multiplies<T>(), std::placeholders::_1, (Value)1 / squareEnergy));
     }
 };
 
@@ -102,7 +102,7 @@ public:
                                   T((v.size() - 1) * 2));
 
         std::transform(v.begin(), v.end(), v.begin(),
-                       std::bind2nd(std::multiplies<T>(), (Value)1 / squareEnergy));
+                       std::bind(std::multiplies<T>(), std::placeholders::_1, (Value)1 / squareEnergy));
     }
 };
 
@@ -121,7 +121,7 @@ public:
         Value mean = std::accumulate(v.begin(), v.end(), 0.0) / v.size();
 
         std::transform(v.begin(), v.end(), v.begin(),
-                       std::bind2nd(std::plus<T>(), -mean));
+                       std::bind(std::plus<T>(), std::placeholders::_1, -mean));
     }
 };
 
@@ -144,10 +144,10 @@ public:
         Value deviation = sqrt((sumSquare - sum * sum / v.size()) / v.size());
 
         std::transform(v.begin(), v.end(), v.begin(),
-                       std::bind2nd(std::plus<T>(), -mean));
+                       std::bind(std::plus<T>(), std::placeholders::_1, -mean));
 
         std::transform(v.begin(), v.end(), v.begin(),
-                       std::bind2nd(std::multiplies<T>(), (Value)1 / deviation));
+                       std::bind(std::multiplies<T>(), std::placeholders::_1, (Value)1 / deviation));
     }
 };
 
@@ -166,7 +166,7 @@ public:
         Value maximum = *std::max_element(v.begin(), v.end());
 
         std::transform(v.begin(), v.end(), v.begin(),
-                       std::bind2nd(std::multiplies<T>(), (Value)1 / maximum));
+                       std::bind(std::multiplies<T>(), std::placeholders::_1, (Value)1 / maximum));
     }
 };
 
@@ -183,7 +183,8 @@ public:
     }
 
     VectorNormalizationNode(const Core::Configuration& c)
-            : Core::Component(c), SleeveNode(c) {}
+            : Core::Component(c),
+              SleeveNode(c) {}
 
     virtual ~VectorNormalizationNode() {}
 
diff --git a/src/Signal/VectorResize.hh b/src/Signal/VectorResize.hh
index 42b9456d3..dd1fd0246 100644
--- a/src/Signal/VectorResize.hh
+++ b/src/Signal/VectorResize.hh
@@ -49,7 +49,9 @@ public:
         return std::string("signal-vector-") + Core::Type<T>::name + "-resize";
     }
     VectorResizeNode(const Core::Configuration& c)
-            : Core::Component(c), Precursor(c), newSize_(0) {
+            : Core::Component(c),
+              Precursor(c),
+              newSize_(0) {
         continuousNewSize_ = paramVectorResizeNewSize(c);
         discreteNewSize_   = paramVectorResizeNewDiscreteSize(c);
         initialValue_      = paramVectorResizeInitialValue(c);
diff --git a/src/Signal/VectorSequenceAggregation.hh b/src/Signal/VectorSequenceAggregation.hh
index 149cce9bd..4ed2ee3df 100644
--- a/src/Signal/VectorSequenceAggregation.hh
+++ b/src/Signal/VectorSequenceAggregation.hh
@@ -62,7 +62,8 @@ public:
 
 template<class T>
 VectorSequenceAggregation<T>::VectorSequenceAggregation(const Core::Configuration& c)
-        : Component(c), Precursor(c) {
+        : Component(c),
+          Precursor(c) {
     expandTimestamp_ = paramVectorSequenceAggregationExpandTimestamp(c);
     addOutput(0);
 }
diff --git a/src/Signal/VectorSequenceConcatenation.hh b/src/Signal/VectorSequenceConcatenation.hh
index 11ca01f08..eed1d5f03 100644
--- a/src/Signal/VectorSequenceConcatenation.hh
+++ b/src/Signal/VectorSequenceConcatenation.hh
@@ -59,7 +59,8 @@ public:
 
 template<class T>
 VectorSequenceConcatenation<T>::VectorSequenceConcatenation(const Core::Configuration& c)
-        : Component(c), Precursor(c) {
+        : Component(c),
+          Precursor(c) {
     expandTimestamp_ = paramVectorSequenceConcatExpandTimestamp(c);
     addOutput(0);
 }
diff --git a/src/Signal/Warping.hh b/src/Signal/Warping.hh
index 400a43e19..3ead9d674 100644
--- a/src/Signal/Warping.hh
+++ b/src/Signal/Warping.hh
@@ -32,11 +32,15 @@ public:
     typedef f32                     Data;
     typedef f64                     FloatIndex;
     typedef std::vector<FloatIndex> WarpingFunction;
-    enum MergeType { AritmeticMean,
-                     SelectBegin };
-    enum InterpolationType { KeepEnd,
-                             InsertZero,
-                             LinearInterpolation };
+    enum MergeType {
+        AritmeticMean,
+        SelectBegin
+    };
+    enum InterpolationType {
+        KeepEnd,
+        InsertZero,
+        LinearInterpolation
+    };
     static const f64 copyTolerance;
 
 private:
@@ -77,7 +81,8 @@ private:
 
     public:
         AritmeticMeanInverseItem(u32 begin, u32 end)
-                : begin_(begin), end_(end) {}
+                : begin_(begin),
+                  end_(end) {}
         virtual ~AritmeticMeanInverseItem() {}
 
         virtual Data apply(const std::vector<Data>& in) const {
diff --git a/src/Signal/WindowBuffer.hh b/src/Signal/WindowBuffer.hh
index f8c3108b2..8ba335413 100644
--- a/src/Signal/WindowBuffer.hh
+++ b/src/Signal/WindowBuffer.hh
@@ -28,9 +28,11 @@ class WindowBuffer {
 public:
     typedef Flow::Time Time;
     typedef f32        Sample;
-    enum FlushPolicy { SendRest,
-                       PadRest,
-                       DiscardRest };
+    enum FlushPolicy {
+        SendRest,
+        PadRest,
+        DiscardRest
+    };
     typedef Flow::Vector<Sample> InputData;
     typedef Flow::Vector<Sample> OutputData;
 
diff --git a/src/Signal/WindowFunction.hh b/src/Signal/WindowFunction.hh
index 60c265614..a7f774123 100644
--- a/src/Signal/WindowFunction.hh
+++ b/src/Signal/WindowFunction.hh
@@ -30,13 +30,15 @@ namespace Signal {
 class WindowFunction {
 public:
     typedef f32 Float;
-    enum Type { Rectangular,
-                Hamming,
-                Hanning,
-                PeriodicHanning,
-                Bartlett,
-                Blackman,
-                Kaiser };
+    enum Type {
+        Rectangular,
+        Hamming,
+        Hanning,
+        PeriodicHanning,
+        Bartlett,
+        Blackman,
+        Kaiser
+    };
 
     static Core::Choice          typeChoice;
     static Core::ParameterChoice paramType;
diff --git a/src/Sparse/Vector.hh b/src/Sparse/Vector.hh
index 0120793b1..0cae25a40 100644
--- a/src/Sparse/Vector.hh
+++ b/src/Sparse/Vector.hh
@@ -60,14 +60,16 @@ public:
 
     /** Creates a new sparse vector. */
     Vector()
-            : Flow::Timestamp(type()), Precursor(){};
+            : Flow::Timestamp(type()),
+              Precursor(){};
 
     /**
      * Creates a new sparse vector with given size.
      * @param size Initial size.
      */
     Vector(int size)
-            : Flow::Timestamp(type()), Precursor(size) {}
+            : Flow::Timestamp(type()),
+              Precursor(size) {}
 
     /**
      * Creates a new sparse vector with given size and content.
@@ -75,21 +77,24 @@ public:
      * @param contentToFill Content to fill the sparse vector with.
      */
     Vector(int size, T contentToFill)
-            : Flow::Timestamp(type()), Precursor(size, contentToFill) {}
+            : Flow::Timestamp(type()),
+              Precursor(size, contentToFill) {}
 
     /**
      * Copy constructor
      * @param v Original data.
      */
     Vector(const Vector<T>& v)
-            : Flow::Timestamp(type()), Precursor(v) {}
+            : Flow::Timestamp(type()),
+              Precursor(v) {}
 
     /**
      * Copy constructor from Precursor.
      * @param v Original data.
      */
     Vector(const Precursor& v)
-            : Flow::Timestamp(type()), Precursor(v) {}
+            : Flow::Timestamp(type()),
+              Precursor(v) {}
 
     /** Destroys the sparse vector. */
     virtual ~Vector() {}
diff --git a/src/Speech/AbstractSegmentwiseTrainer.hh b/src/Speech/AbstractSegmentwiseTrainer.hh
index 8d6ffac48..69baa06ce 100644
--- a/src/Speech/AbstractSegmentwiseTrainer.hh
+++ b/src/Speech/AbstractSegmentwiseTrainer.hh
@@ -75,7 +75,8 @@ protected:
 
 protected:
     Lattice::ConstWordLatticeRef extractNumerator(const std::string& orth, Lattice::ConstWordLatticeRef denominator) const;
-    Mm::Weight                   weightThreshold() const {
+
+    Mm::Weight weightThreshold() const {
         return weightThreshold_;
     }
 
diff --git a/src/Speech/AccuracyFsaBuilder.hh b/src/Speech/AccuracyFsaBuilder.hh
index 9f5350f38..85fc1b7d1 100644
--- a/src/Speech/AccuracyFsaBuilder.hh
+++ b/src/Speech/AccuracyFsaBuilder.hh
@@ -47,7 +47,9 @@ public:
         Functor(MetricFsaBuilder&  builder,
                 const std::string& id,
                 BuilderInput       builderInput)
-                : builder_(builder), id_(id), builderInput_(builderInput) {}
+                : builder_(builder),
+                  id_(id),
+                  builderInput_(builderInput) {}
 
         const std::string& id() const {
             return id_;
diff --git a/src/Speech/AcousticModelRescorer.hh b/src/Speech/AcousticModelRescorer.hh
index 36fcb0e6a..dd9975572 100644
--- a/src/Speech/AcousticModelRescorer.hh
+++ b/src/Speech/AcousticModelRescorer.hh
@@ -35,7 +35,9 @@ private:
 
 public:
     AcousticModelRescorer(const Core::Configuration& c)
-            : Core::Configurable(c), scorer_(0), rescorer_(0) {
+            : Core::Configurable(c),
+              scorer_(0),
+              rescorer_(0) {
         beamCount_ = 0;
     }
     ~AcousticModelRescorer() {
diff --git a/src/Speech/AcousticModelTrainer.cc b/src/Speech/AcousticModelTrainer.cc
index 289d8445f..57ddb93dd 100644
--- a/src/Speech/AcousticModelTrainer.cc
+++ b/src/Speech/AcousticModelTrainer.cc
@@ -159,7 +159,7 @@ void TiedTextDependentMixtureSetTrainer::setFeatureDescription(const Mm::Feature
             }
 
             void collectEmissions() {
-                for (int e = 0; e < nodes.size(); ++e) {
+                for (size_t e = 0; e < nodes.size(); ++e) {
                     verify(nodes[e]);
                     verify(!nodes[e]->leftChild_ && !nodes[e]->rightChild_);
                     emissions_.push_back(std::vector<std::pair<u32, float>>());
@@ -222,7 +222,7 @@ void TiedTextDependentMixtureSetTrainer::setFeatureDescription(const Mm::Feature
                                                   Core::select2nd<std::pair<u32, f32>>(),
                                                   Core::select2nd<std::pair<u32, f32>>()));
 
-            if (tiedEmissions_[i].size() > maxEmissions_) {
+            if (int(tiedEmissions_[i].size()) > maxEmissions_) {
                 removedEmissions += maxEmissions_ - tiedEmissions_[i].size();
                 tiedEmissions_[i].resize(maxEmissions_);
             }
diff --git a/src/Speech/AcousticSegmentwiseTrainer.hh b/src/Speech/AcousticSegmentwiseTrainer.hh
index a6463d58c..b01198053 100644
--- a/src/Speech/AcousticSegmentwiseTrainer.hh
+++ b/src/Speech/AcousticSegmentwiseTrainer.hh
@@ -35,9 +35,11 @@ class AbstractAcousticSegmentwiseTrainer : public AbstractSegmentwiseTrainer {
     typedef AbstractSegmentwiseTrainer Precursor;
 
 public:
-    enum ModelType { gaussianMixture,
-                     maximumEntropy,
-                     neuralNetwork };
+    enum ModelType {
+        gaussianMixture,
+        maximumEntropy,
+        neuralNetwork
+    };
     static Core::Choice          choiceModelType;
     static Core::ParameterChoice paramModelType;
 
@@ -163,7 +165,9 @@ protected:
 
 public:
     AcousticSegmentwiseTrainer(const Core::Configuration& c)
-            : Core::Component(c), Precursor(c), acc_(0) {}
+            : Core::Component(c),
+              Precursor(c),
+              acc_(0) {}
     virtual ~AcousticSegmentwiseTrainer() {
         delete acc_;
     }
diff --git a/src/Speech/AdvancedLatticeExtractor.cc b/src/Speech/AdvancedLatticeExtractor.cc
index fad1dd9b2..1d63bf7c8 100644
--- a/src/Speech/AdvancedLatticeExtractor.cc
+++ b/src/Speech/AdvancedLatticeExtractor.cc
@@ -545,7 +545,10 @@ class RestoreScoresLatticeRescorerAutomaton : public LatticeRescorerAutomaton {
         History        history;
         Context(TimeframeIndex _begtim, TimeframeIndex _endtim,
                 Fsa::LabelId _label, const History& _history)
-                : begtim(_begtim), endtim(_endtim), label(_label), history(_history) {}
+                : begtim(_begtim),
+                  endtim(_endtim),
+                  label(_label),
+                  history(_history) {}
     };
     struct ContextHash {
         size_t operator()(const Context& c) const {
diff --git a/src/Speech/AlignedFeatureCache.hh b/src/Speech/AlignedFeatureCache.hh
index 649ce1e6b..a3dc94fae 100644
--- a/src/Speech/AlignedFeatureCache.hh
+++ b/src/Speech/AlignedFeatureCache.hh
@@ -17,9 +17,11 @@ protected:
 
 public:
     SortedCache()
-            : cacheDir_("."), bufferSize_(0) {}
+            : cacheDir_("."),
+              bufferSize_(0) {}
     SortedCache(const std::string& cacheDir, u32 bufferSize)
-            : cacheDir_(cacheDir), bufferSize_(bufferSize) {}
+            : cacheDir_(cacheDir),
+              bufferSize_(bufferSize) {}
 
     /**
      * Set the directory for feature cache files
@@ -96,7 +98,8 @@ protected:
 
 public:
     SortedCacheReader()
-            : open_(false), featureType_(0) {}
+            : open_(false),
+              featureType_(0) {}
     SortedCacheReader(const std::string& cacheDir, u32 bufferSize)
             : SortedCache(cacheDir, bufferSize),
               open_(false),
diff --git a/src/Speech/Alignment.hh b/src/Speech/Alignment.hh
index ecadf970d..66cdc7ed6 100644
--- a/src/Speech/Alignment.hh
+++ b/src/Speech/Alignment.hh
@@ -33,9 +33,13 @@ struct AlignmentItem {
     Fsa::LabelId   emission;
     Mm::Weight     weight;
     AlignmentItem()
-            : time(0), emission(0), weight(0) {}
+            : time(0),
+              emission(0),
+              weight(0) {}
     AlignmentItem(TimeframeIndex t, Am::AllophoneStateIndex e, Mm::Weight w = 1.0)
-            : time(t), emission(e), weight(w) {}
+            : time(t),
+              emission(e),
+              weight(w) {}
     bool operator==(const AlignmentItem& other) const {
         return (time == other.time && emission == other.emission && weight == other.weight);
     }
@@ -59,8 +63,10 @@ Core::BinaryOutputStream& operator<<(Core::BinaryOutputStream&, const Alignment&
 class Alignment : public std::vector<AlignmentItem> {
 public:
     typedef std::pair<Alignment::iterator, Alignment::iterator> Frame;
-    enum LabelType { allophoneStateIds,
-                     emissionIds };
+    enum LabelType {
+        allophoneStateIds,
+        emissionIds
+    };
 
 private:
     typedef std::vector<AlignmentItem> Precursor;
diff --git a/src/Speech/AlignmentNode.hh b/src/Speech/AlignmentNode.hh
index 201a86ab2..d6bb4ad2b 100644
--- a/src/Speech/AlignmentNode.hh
+++ b/src/Speech/AlignmentNode.hh
@@ -136,8 +136,10 @@ protected:
     std::string                        filename_;
     std::string                        segmentId_;
     Core::Ref<const Am::AcousticModel> acousticModel_;
-    enum AlignmentType { standard,
-                         plainText };
+    enum AlignmentType {
+        standard,
+        plainText
+    };
     AlignmentType                    alignmentType_;
     Core::StringHashMap<std::string> parameters_;
     Flow::Attributes::Parser         attributesParser_;
@@ -162,9 +164,11 @@ public:
     }
     Core::ArchiveWriter* newWriter(const std::string& name);
     Core::ArchiveReader* newReader(const std::string& name);
-    bool                 hasAccess(Core::Archive::AccessMode a) const {
+
+    bool hasAccess(Core::Archive::AccessMode a) const {
         return (archive_) ? archive_->hasAccess(a) : false;
     }
+
     bool open(Core::Archive::AccessMode access);
     void close();
     bool isOpen() const {
diff --git a/src/Speech/AlignmentWithLinearSegmentation.cc b/src/Speech/AlignmentWithLinearSegmentation.cc
index 09e5c2fa0..a10b82c9c 100644
--- a/src/Speech/AlignmentWithLinearSegmentation.cc
+++ b/src/Speech/AlignmentWithLinearSegmentation.cc
@@ -57,6 +57,7 @@ class LinearSegmenter::Delimiter : public Core::Component {
         M_.clear();
         M_.push_back(0);
     }
+
     void feed(f64 xx) {
         M_.push_back(M_.back() + xx);
         if (f_ > 0) {
@@ -68,8 +69,10 @@ class LinearSegmenter::Delimiter : public Core::Component {
         if (Q_.back() > Core::Type<f64>::max)
             error("delimit overflow => segment to long?");
     }
+
     virtual Delimitation getDelimitation() const;
-    u32                  nFeatures() const {
+
+    u32 nFeatures() const {
         verify(Q_.size() == M_.size());
         return Q_.size() - 1;
     }
diff --git a/src/Speech/AllophoneStateGraphBuilder.hh b/src/Speech/AllophoneStateGraphBuilder.hh
index d864abbdd..1742139b1 100644
--- a/src/Speech/AllophoneStateGraphBuilder.hh
+++ b/src/Speech/AllophoneStateGraphBuilder.hh
@@ -64,7 +64,9 @@ public:
         FunctorBase(AllophoneStateGraphBuilder& builder,
                     const std::string&          id,
                     BuilderInput... builderInput)
-                : builder_(builder), id_(id), builderInput_(builderInput...) {}
+                : builder_(builder),
+                  id_(id),
+                  builderInput_(builderInput...) {}
 
         const std::string& id() const {
             return id_;
@@ -210,8 +212,10 @@ public:
         return Functor<const std::string>(*this, s.fullName(), s.orth());
     }
     /** Builds allophone state acceptor for phoneme loops, cf. phoneme recognition. */
-    enum InputLevel { lemma,
-                      phone };
+    enum InputLevel {
+        lemma,
+        phone
+    };
     AllophoneStateGraphRef build(const InputLevel& level);
     AllophoneStateGraphRef build(std::tuple<const InputLevel&> const& t) {
         return build(std::get<0>(t));
diff --git a/src/Speech/AuxiliarySegmentwiseTrainer.hh b/src/Speech/AuxiliarySegmentwiseTrainer.hh
index fe0a50e4e..5f582b9de 100644
--- a/src/Speech/AuxiliarySegmentwiseTrainer.hh
+++ b/src/Speech/AuxiliarySegmentwiseTrainer.hh
@@ -49,6 +49,7 @@ public:
 struct PosteriorFsa {
     Fsa::ConstAutomatonRef fsa;
     Fsa::Weight            totalInv;
+
     operator bool() const {
         return fsa;
     }
diff --git a/src/Speech/CovarianceEstimator.cc b/src/Speech/CovarianceEstimator.cc
index 2043672c6..774f9b6c4 100644
--- a/src/Speech/CovarianceEstimator.cc
+++ b/src/Speech/CovarianceEstimator.cc
@@ -19,7 +19,10 @@
 using namespace Speech;
 
 CovarianceEstimator::CovarianceEstimator(const Core::Configuration& c)
-        : Component(c), Extractor(c), Estimator(c), needResize_(true) {
+        : Component(c),
+          Extractor(c),
+          Estimator(c),
+          needResize_(true) {
 }
 
 void CovarianceEstimator::processFeature(Core::Ref<const Speech::Feature> feature) {
diff --git a/src/Speech/DataExtractor.hh b/src/Speech/DataExtractor.hh
index e45a73bbb..0007f1941 100644
--- a/src/Speech/DataExtractor.hh
+++ b/src/Speech/DataExtractor.hh
@@ -84,7 +84,8 @@ protected:
 
 public:
     FeatureExtractor(const Core::Configuration& c, bool loadFromFile = true)
-            : Core::Component(c), Precursor(c, loadFromFile) {}
+            : Core::Component(c),
+              Precursor(c, loadFromFile) {}
     virtual ~FeatureExtractor() {}
 
     virtual void processSegment(Bliss::Segment* segment);
@@ -111,11 +112,12 @@ protected:
     }
     /** Override this function to achieve the feature vectors extracted form data source one-by-one.
      */
-    virtual void processFeatureVector(Core::Ref<const Feature::Vector>) {}
+    virtual void processFeatureVector(Feature::VectorRef) {}
 
 public:
     FeatureVectorExtractor(const Core::Configuration& c)
-            : Core::Component(c), Precursor(c) {}
+            : Core::Component(c),
+              Precursor(c) {}
     virtual ~FeatureVectorExtractor() {}
 };
 
diff --git a/src/Speech/DecisionTreeTrainer.cc b/src/Speech/DecisionTreeTrainer.cc
index 146c494e1..d8f2f9e45 100644
--- a/src/Speech/DecisionTreeTrainer.cc
+++ b/src/Speech/DecisionTreeTrainer.cc
@@ -167,11 +167,13 @@ Cart::Score StateTyingDecisionTreeTrainer::LogLikelihoodGain::logLikelihood(
                 }
             }
 
-#pragma omp critical  // if slow create e.g. std::vector<std::vector<f64> > mus_private(threadnum, std::vector<f64>(d, 0.0)) and merge them \
-                      // with an omp for over dimension                                                                                     \
-                      // and also merge with next for loop                                                                                  \
-                      // order is not defined, non-deterministic sum-up!
+#pragma omp critical
             {
+                /**
+                 * if slow create e.g. std::vector<std::vector<f64>> mus_private(threadnum, std::vector<f64>(d, 0.0)) and merge them
+                 * with an 'omp for' over dimension and also merge with next for loop;
+                 * order is not defined, non-deterministic sum-up!
+                 */
                 std::vector<f64>::iterator itMu_private          = mu_private.begin();
                 std::vector<f64>::iterator itSigmaSquare_private = sigmaSquare_private.begin();
                 std::vector<f64>::iterator itMu                  = mu_.begin();
diff --git a/src/Speech/DelayedRecognizer.cc b/src/Speech/DelayedRecognizer.cc
index e28af9782..2f3316fad 100644
--- a/src/Speech/DelayedRecognizer.cc
+++ b/src/Speech/DelayedRecognizer.cc
@@ -122,8 +122,13 @@ Core::Ref<const Feature> RecognizerDelayHandler::flush() {
             currentScorer = scorer->getScorer(featureBuffer_[featureScorerOffset_]);
         }
         else {
-            verify_(scorer->isBuffered());
-            currentScorer = scorer->flush();
+            if (scorer->isBuffered() and not scorer->bufferEmpty()) {
+                currentScorer = scorer->flush();
+            }
+            else {
+                // there are less number of score frames than input feature frames
+                return Core::Ref<const Feature>();
+            }
         }
     }
     Core::Ref<const Feature> currentFeature = featureBuffer_.front();
diff --git a/src/Speech/DiscriminativeMixtureSetTrainer.cc b/src/Speech/DiscriminativeMixtureSetTrainer.cc
index 1371cc1fa..c1884bb56 100644
--- a/src/Speech/DiscriminativeMixtureSetTrainer.cc
+++ b/src/Speech/DiscriminativeMixtureSetTrainer.cc
@@ -26,7 +26,7 @@ DiscriminativeMixtureSetTrainer::DiscriminativeMixtureSetTrainer(const Core::Con
 
 DiscriminativeMixtureSetTrainer::~DiscriminativeMixtureSetTrainer() {}
 
-void DiscriminativeMixtureSetTrainer::accumulateDenominator(Core::Ref<const Feature::Vector> f, Mm::MixtureIndex m, Mm::Weight w) {
+void DiscriminativeMixtureSetTrainer::accumulateDenominator(Feature::VectorRef f, Mm::MixtureIndex m, Mm::Weight w) {
     required_cast(Mm::DiscriminativeMixtureSetEstimator*, estimator_)->accumulateDenominator(m, f, w);
 }
 void DiscriminativeMixtureSetTrainer::accumulateObjectiveFunction(Mm::Score f) {
diff --git a/src/Speech/DiscriminativeMixtureSetTrainer.hh b/src/Speech/DiscriminativeMixtureSetTrainer.hh
index 7291388f6..dbcd1fe11 100644
--- a/src/Speech/DiscriminativeMixtureSetTrainer.hh
+++ b/src/Speech/DiscriminativeMixtureSetTrainer.hh
@@ -31,7 +31,7 @@ public:
     DiscriminativeMixtureSetTrainer(const Core::Configuration&);
     virtual ~DiscriminativeMixtureSetTrainer();
 
-    void accumulateDenominator(Core::Ref<const Feature::Vector> f, Mm::MixtureIndex m, Mm::Weight w);
+    void accumulateDenominator(Feature::VectorRef f, Mm::MixtureIndex m, Mm::Weight w);
     void accumulateObjectiveFunction(Mm::Score f);
 
     static DiscriminativeMixtureSetTrainer* createDiscriminativeMixtureSetTrainer(const Core::Configuration&, bool iSmoothing);
diff --git a/src/Speech/Feature.cc b/src/Speech/Feature.cc
index f24e47845..97f8f0ade 100644
--- a/src/Speech/Feature.cc
+++ b/src/Speech/Feature.cc
@@ -16,12 +16,12 @@
 
 using namespace Speech;
 
-Core::Ref<const Mm::Feature::Vector> Feature::convert(Flow::DataPtr<FlowVector>& v) {
+Mm::Feature::VectorRef Feature::convert(Flow::DataPtr<FlowVector>& v) {
     v.makePrivate();
     Vector* r = new Mm::Feature::Vector;
     std::swap(*r, *v.get());
     delete v.release();
-    return Core::ref(r);
+    return Mm::Feature::VectorRef(r);
 }
 
 void Feature::take(Flow::DataPtr<FlowVector>& v) {
diff --git a/src/Speech/Feature.hh b/src/Speech/Feature.hh
index 60618f2c3..09260a389 100644
--- a/src/Speech/Feature.hh
+++ b/src/Speech/Feature.hh
@@ -42,7 +42,7 @@ private:
     Flow::Timestamp timestamp_;
 
 private:
-    static Core::Ref<const Vector> convert(Flow::DataPtr<FlowVector>&);
+    static VectorRef convert(Flow::DataPtr<FlowVector>&);
 
 public:
     Feature() {}
diff --git a/src/Speech/HistogramEstimator.hh b/src/Speech/HistogramEstimator.hh
index 032a36384..0d68e8814 100644
--- a/src/Speech/HistogramEstimator.hh
+++ b/src/Speech/HistogramEstimator.hh
@@ -32,15 +32,17 @@ public:
     static const Core::ParameterFloat paramBucketSize;
 
 private:
-    Core::Ref<Bliss::CorpusKey>            corpusKey_;
     typedef Signal::HistogramVector<Value> HistogramVector;
-    HistogramVector*                       currentHistogramVector_;
+    typedef Core::ObjectCache<Core::MruObjectCacheList<
+            std::string, HistogramVector, Core::StringHash, Core::StringEquality>>
+            HistogramVectorCache;
+
+    Core::Ref<Bliss::CorpusKey> corpusKey_;
+    HistogramVector*            currentHistogramVector_;
 
     size_t featureDimension_;
     Value  bucketSize_;
-    typedef Core::ObjectCache<Core::MruObjectCacheList<
-            std::string, HistogramVector, Core::StringHash, Core::StringEquality>>
-                         HistogramVectorCache;
+
     HistogramVectorCache histogramVectorCache_;
 
 private:
@@ -48,7 +50,7 @@ private:
 
 protected:
     virtual void setFeatureVectorDescription(const Mm::FeatureDescription::Stream&);
-    virtual void processFeatureVector(Core::Ref<const Feature::Vector> f) {
+    virtual void processFeatureVector(Feature::VectorRef f) {
         verify_(currentHistogramVector_ != 0);
         currentHistogramVector_->accumulate(*f);
     }
diff --git a/src/Speech/KeyedEstimator.hh b/src/Speech/KeyedEstimator.hh
index a89777970..dcd48b138 100644
--- a/src/Speech/KeyedEstimator.hh
+++ b/src/Speech/KeyedEstimator.hh
@@ -41,9 +41,11 @@ public:
             Core::StringHash,
             Core::StringEquality>>
             AccumulatorCache;
-    enum Operation { estimate,
-                     calculate,
-                     combines };
+    enum Operation {
+        estimate,
+        calculate,
+        combines
+    };
 
 public:
     static const Core::ParameterFloat  paramCombinationWeight;
diff --git a/src/Speech/LatticeArcAccumulator.hh b/src/Speech/LatticeArcAccumulator.hh
index b240f0568..43f7d835b 100644
--- a/src/Speech/LatticeArcAccumulator.hh
+++ b/src/Speech/LatticeArcAccumulator.hh
@@ -87,7 +87,8 @@ private:
 
 public:
     ArcWeightAccumulator(Fsa::ConstAutomatonRef f, std::unordered_map<Fsa::LabelId, f32>* sums)
-            : Fsa::DfsState(f), Sums_(sums) {
+            : Fsa::DfsState(f),
+              Sums_(sums) {
         dfs();
     }
     virtual ~ArcWeightAccumulator() {}
diff --git a/src/Speech/LatticeExtractor.hh b/src/Speech/LatticeExtractor.hh
index a41b7360c..50a60d7a8 100644
--- a/src/Speech/LatticeExtractor.hh
+++ b/src/Speech/LatticeExtractor.hh
@@ -267,7 +267,8 @@ class ApproximateDistanceLatticeRescorer : public DistanceLatticeRescorer {
 
 protected:
     virtual Lattice::ConstWordLatticeRef work(Lattice::ConstWordLatticeRef, Bliss::SpeechSegment*);
-    virtual Fsa::ConstAutomatonRef       getDistanceFsa(Lattice::ConstWordLatticeRef, Bliss::SpeechSegment*) {
+
+    virtual Fsa::ConstAutomatonRef getDistanceFsa(Lattice::ConstWordLatticeRef, Bliss::SpeechSegment*) {
         return Fsa::ConstAutomatonRef();
     }
 
diff --git a/src/Speech/LatticeNodes.hh b/src/Speech/LatticeNodes.hh
index 3a8b58d81..a9af67691 100644
--- a/src/Speech/LatticeNodes.hh
+++ b/src/Speech/LatticeNodes.hh
@@ -288,6 +288,7 @@ public:
     static std::string filterName() {
         return "lattice-expm";
     }
+
     LatticeExpmNode(const Core::Configuration&);
 };
 
@@ -303,9 +304,11 @@ protected:
 
 public:
     static const Core::ParameterBool paramNormalize;
-    static std::string               filterName() {
+
+    static std::string filterName() {
         return "lattice-expectation-posterior";
     }
+
     LatticeExpectationPosteriorNode(const Core::Configuration&);
 };
 
@@ -317,6 +320,7 @@ public:
     static std::string filterName() {
         return "lattice-nbest";
     }
+
     LatticeNBestNode(const Core::Configuration&);
     virtual ~LatticeNBestNode() {}
 
diff --git a/src/Speech/LatticeSetExtractor.hh b/src/Speech/LatticeSetExtractor.hh
index bb040bfed..36d6fed65 100644
--- a/src/Speech/LatticeSetExtractor.hh
+++ b/src/Speech/LatticeSetExtractor.hh
@@ -70,8 +70,10 @@ class LatticeSetGenerator : public LatticeSetProcessor,
     typedef Core::Ref<PhonemeSequenceAlignmentGenerator> AlignmentGeneratorRef;
 
 private:
-    enum SearchType { exactMatch,
-                      fullSearch };
+    enum SearchType {
+        exactMatch,
+        fullSearch
+    };
     static Core::Choice                choiceSearchType;
     static const Core::ParameterChoice paramSearchType;
     static const Core::ParameterBool   paramShareAcousticModel;
diff --git a/src/Speech/MeanEstimator.cc b/src/Speech/MeanEstimator.cc
index 760418523..24facf1c6 100644
--- a/src/Speech/MeanEstimator.cc
+++ b/src/Speech/MeanEstimator.cc
@@ -23,7 +23,10 @@ const Core::ParameterString MeanEstimator::paramFile(
         "file", "output filename for mean");
 
 MeanEstimator::MeanEstimator(const Core::Configuration& c)
-        : Component(c), Extractor(c), Estimator(c), needResize_(true) {}
+        : Component(c),
+          Extractor(c),
+          Estimator(c),
+          needResize_(true) {}
 
 MeanEstimator::~MeanEstimator() {}
 
diff --git a/src/Speech/MinimumBayesRiskSearch.hh b/src/Speech/MinimumBayesRiskSearch.hh
index 8913822d0..cf8d23f93 100644
--- a/src/Speech/MinimumBayesRiskSearch.hh
+++ b/src/Speech/MinimumBayesRiskSearch.hh
@@ -36,7 +36,7 @@ class MinimumBayesRiskSearchNode : public LatticeSetProcessor {
     typedef LatticeSetProcessor Precursor;
 
     /** Registered actions to perform for minimum Bayes risk. */
-    typedef enum SearchMethod {
+    enum SearchMethod {
         searchDryRun,
         searchMap,
         searchNBestListNaive,
diff --git a/src/Speech/MixtureSetTrainer.cc b/src/Speech/MixtureSetTrainer.cc
index 5cb4e9ee5..af2412a02 100644
--- a/src/Speech/MixtureSetTrainer.cc
+++ b/src/Speech/MixtureSetTrainer.cc
@@ -148,9 +148,6 @@ bool MixtureSetTrainer::combine(const std::vector<std::string>& toCombine) {
 }
 
 bool MixtureSetTrainer::combinePartitions(const std::vector<std::string>& toCombine) {
-    typedef Mm::AbstractMixtureSetEstimator::MixtureEstimators MixtureEstimators;
-    typedef Mm::AbstractMixtureEstimator::DensityEstimators    DensityEstimators;
-
     verify(!estimator_);
     estimator_                                    = createMixtureSetEstimator();
     std::vector<std::string>::const_iterator file = toCombine.begin();
diff --git a/src/Speech/MixtureSetTrainer.hh b/src/Speech/MixtureSetTrainer.hh
index 6cc3fae27..e73641e5e 100644
--- a/src/Speech/MixtureSetTrainer.hh
+++ b/src/Speech/MixtureSetTrainer.hh
@@ -64,11 +64,11 @@ public:
     void initializeAccumulation(size_t nMixtures, size_t dimension,
                                 Core::Ref<const Mm::AssigningFeatureScorer> assigningFeatureScorer = Core::Ref<Mm::AssigningFeatureScorer>(),
                                 Core::Ref<Mm::MixtureSet>                   mixtureSet             = Core::Ref<Mm::MixtureSet>());
-    void accumulate(Core::Ref<const Feature::Vector> f, Mm::MixtureIndex m) {
+    void accumulate(Feature::VectorRef f, Mm::MixtureIndex m) {
         verify_(estimator_ != 0);
         estimator_->accumulate(m, f);
     }
-    void accumulate(Core::Ref<const Feature::Vector> f, Mm::MixtureIndex m, Mm::Weight w) {
+    void accumulate(Feature::VectorRef f, Mm::MixtureIndex m, Mm::Weight w) {
         verify_(estimator_ != 0);
         estimator_->accumulate(m, f, w);
     }
diff --git a/src/Speech/ModelCombination.cc b/src/Speech/ModelCombination.cc
index 4ea30423b..5d19c9691 100644
--- a/src/Speech/ModelCombination.cc
+++ b/src/Speech/ModelCombination.cc
@@ -67,7 +67,6 @@ ModelCombination::ModelCombination(const Core::Configuration& c,
             criticalError("Failed to initialize language model");
         }
     }
-
     if (mode & useLabelScorer) {
         setLabelScorer(Nn::Module::instance().labelScorerFactory().createLabelScorer(select("label-scorer")));
         if (!labelScorer_) {
diff --git a/src/Speech/ModelTransformEstimator.hh b/src/Speech/ModelTransformEstimator.hh
index 2e59eeb88..f75433852 100644
--- a/src/Speech/ModelTransformEstimator.hh
+++ b/src/Speech/ModelTransformEstimator.hh
@@ -39,10 +39,12 @@ class ModelTransformEstimator : public KeyedEstimator {
 public:
     static const Core::Choice          mllrModelingChoice;
     static const Core::ParameterChoice paramMllrModeling;
-    enum MllrModelingMode { fullMllr,
-                            semiTiedMllr,
-                            bandMllr,
-                            shiftMllr };
+    enum MllrModelingMode {
+        fullMllr,
+        semiTiedMllr,
+        bandMllr,
+        shiftMllr
+    };
 
 private:
     Core::Ref<Am::AdaptationTree> adaptationTree_;
diff --git a/src/Speech/PhonemeSequenceAlignmentGenerator.cc b/src/Speech/PhonemeSequenceAlignmentGenerator.cc
index 33c676588..498831d03 100644
--- a/src/Speech/PhonemeSequenceAlignmentGenerator.cc
+++ b/src/Speech/PhonemeSequenceAlignmentGenerator.cc
@@ -454,7 +454,8 @@ class LatticeToAlignment : public Flf::DfsState {
 };
 
 LatticeToAlignment::LatticeToAlignment(PhonemeSequenceAlignmentGenerator* alignmentGenerator, Flf::ConstLatticeRef lattice)
-        : Flf::DfsState(lattice), alignmentGenerator_(alignmentGenerator) {}
+        : Flf::DfsState(lattice),
+          alignmentGenerator_(alignmentGenerator) {}
 
 void LatticeToAlignment::discoverState(Flf::ConstStateRef sp) {
     const TimeframeIndex begtime = fsa_->boundary(sp->id()).time();
diff --git a/src/Speech/PhonemeSequenceAlignmentGenerator.hh b/src/Speech/PhonemeSequenceAlignmentGenerator.hh
index 981e44f8b..661914404 100644
--- a/src/Speech/PhonemeSequenceAlignmentGenerator.hh
+++ b/src/Speech/PhonemeSequenceAlignmentGenerator.hh
@@ -42,7 +42,11 @@ public:
         Key() {}
         Key(const Bliss::Coarticulated<Bliss::LemmaPronunciation>& p,
             TimeframeIndex tbeg, TimeframeIndex tend)
-                : _id(p.object().id()), _tbeg(tbeg), _tend(tend), _leftContext(p.leftContext()), _rightContext(p.rightContext()) {}
+                : _id(p.object().id()),
+                  _tbeg(tbeg),
+                  _tend(tend),
+                  _leftContext(p.leftContext()),
+                  _rightContext(p.rightContext()) {}
         std::string string() const {
             return Core::form("%d|%d|%d|%d|%d", _id, _tbeg, _tend, _leftContext, _rightContext);
         }
@@ -64,7 +68,7 @@ public:
         }
     };
 
-    struct KeyEquality : std::binary_function<const char*, const char*, bool> {
+    struct KeyEquality {
         bool operator()(const Key& k1, const Key& k2) const {
             return (k1 == k2);
         }
@@ -155,7 +159,8 @@ public:
                                   TimeframeIndex tbeg, TimeframeIndex tend);
     const Alignment* getAlignment(const Bliss::Coarticulated<Bliss::LemmaPronunciation>&,
                                   TimeframeIndex tbeg, TimeframeIndex tend);
-    void             useAlignmentCache(bool use) {
+
+    void useAlignmentCache(bool use) {
         useAlignmentCache_ = use;
     }
 
diff --git a/src/Speech/PruningLatticeSetNode.hh b/src/Speech/PruningLatticeSetNode.hh
index 1a699ef82..5120ebbfa 100644
--- a/src/Speech/PruningLatticeSetNode.hh
+++ b/src/Speech/PruningLatticeSetNode.hh
@@ -32,8 +32,10 @@ private:
     Fsa::Weight                       threshold_;
     bool                              thresholdIsRelative_;
     bool                              hasFailArcs_;
-    enum PruningType { forwardBackward,
-                       forward };
+    enum PruningType {
+        forwardBackward,
+        forward
+    };
     static Core::Choice                choicePruningType;
     static const Core::ParameterChoice paramPruningType;
     PruningType                        pruningType_;
diff --git a/src/Speech/ScatterMatricesEstimator.cc b/src/Speech/ScatterMatricesEstimator.cc
index 91aa483ea..7764d5b6f 100644
--- a/src/Speech/ScatterMatricesEstimator.cc
+++ b/src/Speech/ScatterMatricesEstimator.cc
@@ -41,10 +41,14 @@ void TextDependentScatterMatricesEstimator::setFeatureDescription(const Mm::Feat
 
 // ----------------------------------------------------------------------------------------
 TextIndependentScatterMatricesEstimator::TextIndependentScatterMatricesEstimator(const Core::Configuration& c)
-        : Component(c), LabeledFeatureProcessor(c), estimator_(new Signal::ScatterMatricesEstimator(c)) {}
+        : Component(c),
+          LabeledFeatureProcessor(c),
+          estimator_(new Signal::ScatterMatricesEstimator(c)) {}
 
 TextIndependentScatterMatricesEstimator::TextIndependentScatterMatricesEstimator(const Core::Configuration& c, Core::Ref<Signal::ScatterMatricesEstimator> estimator)
-        : Component(c), LabeledFeatureProcessor(c), estimator_(estimator) {}
+        : Component(c),
+          LabeledFeatureProcessor(c),
+          estimator_(estimator) {}
 
 void TextIndependentScatterMatricesEstimator::setFeatureDescription(const Mm::FeatureDescription& description) {
     description.verifyNumberOfStreams(1);
diff --git a/src/Speech/SegmentwiseFeatureExtractor.hh b/src/Speech/SegmentwiseFeatureExtractor.hh
index 58f635158..3aa7b8a8b 100644
--- a/src/Speech/SegmentwiseFeatureExtractor.hh
+++ b/src/Speech/SegmentwiseFeatureExtractor.hh
@@ -44,9 +44,11 @@ public:
     Flow::PortId                addPort(const std::string&);
     void                        checkCompatibility(Flow::PortId, Core::Ref<const Am::AcousticModel>) const;
     ConstSegmentwiseFeaturesRef features(Flow::PortId) const;
-    bool                        valid(Flow::PortId port) const {
+
+    bool valid(Flow::PortId port) const {
         return (featureStreams_.find(port) != featureStreams_.end()) && !featureStreams_.find(port)->second->empty();
     }
+
     bool         valid() const;
     virtual void processSegment(Bliss::Segment*);
 };
diff --git a/src/Speech/SegmentwiseGmmTrainer.cc b/src/Speech/SegmentwiseGmmTrainer.cc
index 31ca80639..aa2082002 100644
--- a/src/Speech/SegmentwiseGmmTrainer.cc
+++ b/src/Speech/SegmentwiseGmmTrainer.cc
@@ -68,7 +68,7 @@ namespace InternalGmm {
 
 class NumeratorAccumulator : public GmmAccumulator {
 protected:
-    virtual void accumulate(Core::Ref<const Feature::Vector> f, Mm::MixtureIndex m, Mm::Weight w) {
+    virtual void accumulate(Feature::VectorRef f, Mm::MixtureIndex m, Mm::Weight w) {
         trainer_->accumulate(f, m, w);
     }
 
@@ -79,7 +79,7 @@ class NumeratorAccumulator : public GmmAccumulator {
 
 class DenominatorAccumulator : public GmmAccumulator {
 protected:
-    virtual void accumulate(Core::Ref<const Feature::Vector> f, Mm::MixtureIndex m, Mm::Weight w) {
+    virtual void accumulate(Feature::VectorRef f, Mm::MixtureIndex m, Mm::Weight w) {
         trainer_->accumulateDenominator(f, m, w);
     }
 
diff --git a/src/Speech/TextDependentSequenceFiltering.hh b/src/Speech/TextDependentSequenceFiltering.hh
index dcef35a74..2667b47d6 100644
--- a/src/Speech/TextDependentSequenceFiltering.hh
+++ b/src/Speech/TextDependentSequenceFiltering.hh
@@ -83,7 +83,8 @@ private:
 
     protected:
         virtual void setSymbols(const std::vector<std::string>&) = 0;
-        bool         complementIfRequired(bool contains) const {
+
+        bool complementIfRequired(bool contains) const {
             return shallComplement_ ? !contains : contains;
         }
 
@@ -100,9 +101,11 @@ private:
         virtual bool setParameter(const std::string& name, const std::string& value);
 
         virtual bool contains(const Am::AllophoneState& as, s16 position = 0) const = 0;
-        bool         contains(Am::AllophoneStateIndex emission, s16 position = 0) const {
+
+        bool contains(Am::AllophoneStateIndex emission, s16 position = 0) const {
             return contains(allophoneStateAlphabet_->allophoneState(emission), position);
         }
+
         virtual bool empty() const = 0;
     };
     typedef std::vector<Core::Ref<Set>> Sets;
@@ -133,7 +136,9 @@ private:
 
     public:
         PhonemeSet(const Core::Configuration& c)
-                : Precursor(c), phonemeMap_(0), empty_(true) {}
+                : Precursor(c),
+                  phonemeMap_(0),
+                  empty_(true) {}
         virtual ~PhonemeSet() {
             delete phonemeMap_;
         }
diff --git a/src/Tensorflow/DummyStateManager.cc b/src/Tensorflow/DummyStateManager.cc
new file mode 100644
index 000000000..be8b081f7
--- /dev/null
+++ b/src/Tensorflow/DummyStateManager.cc
@@ -0,0 +1,23 @@
+#include "DummyStateManager.hh"
+
+namespace Tensorflow {
+
+DummyStateManager::DummyStateManager(Core::Configuration const& config, Graph const& graph, Session& session)
+        : Precursor(config, graph, session) {
+}
+
+void DummyStateManager::setInitialState() {
+}
+
+std::vector<std::string> DummyStateManager::getOutputs() const {
+    return std::vector<std::string>();
+}
+
+std::vector<std::string> DummyStateManager::getTargets() const {
+    return std::vector<std::string>();
+}
+
+void DummyStateManager::updateState(std::vector<Tensor> const& state_tensors) {
+}
+
+}  // namespace Tensorflow
diff --git a/src/Tensorflow/DummyStateManager.hh b/src/Tensorflow/DummyStateManager.hh
new file mode 100644
index 000000000..67598a3f8
--- /dev/null
+++ b/src/Tensorflow/DummyStateManager.hh
@@ -0,0 +1,23 @@
+#ifndef _TENSORFLOW_DUMMYSTATEMANAGER_HH
+#define _TENSORFLOW_DUMMYSTATEMANAGER_HH
+
+#include "StateManager.hh"
+
+namespace Tensorflow {
+
+class DummyStateManager : public StateManager {
+public:
+    using Precursor = StateManager;
+
+    DummyStateManager(Core::Configuration const& config, Graph const& graph, Session& session);
+    virtual ~DummyStateManager() = default;
+
+    virtual void                     setInitialState();
+    virtual std::vector<std::string> getOutputs() const;
+    virtual std::vector<std::string> getTargets() const;
+    virtual void                     updateState(std::vector<Tensor> const& state_tensors);
+};
+
+}  // namespace Tensorflow
+
+#endif  // _TENSORFLOW_DUMMYSTATEMANAGER_HH
diff --git a/src/Tensorflow/Graph.hh b/src/Tensorflow/Graph.hh
index 227739a4f..3a8d55b7f 100644
--- a/src/Tensorflow/Graph.hh
+++ b/src/Tensorflow/Graph.hh
@@ -15,6 +15,7 @@
 #ifndef _TENSORFLOW_GRAPH_HH
 #define _TENSORFLOW_GRAPH_HH
 
+#include <sys/stat.h>  // for stat()
 #include <tensorflow/core/framework/graph.pb.h>
 
 #include <Core/Types.hh>
@@ -45,7 +46,7 @@ public:
     Graph()          = default;
     virtual ~Graph() = default;
 
-    void addLibrary(std::string const& l);
+    bool addLibrary(std::string const& l);
     void addInput(std::string const& i);
     void addUpdateOp(std::string const& uo);
     void addStateVar(std::string const& sv);
@@ -96,8 +97,10 @@ protected:
     void setGraphDef(tf::GraphDef const& graph_def);
 };
 
-inline void Graph::addLibrary(std::string const& l) {
+inline bool Graph::addLibrary(std::string const& l) {
     libraries_.push_back(l);
+    struct stat buffer;
+    return stat(l.c_str(), &buffer) == 0;
 }
 
 inline void Graph::addInput(std::string const& i) {
diff --git a/src/Tensorflow/GraphLoader.hh b/src/Tensorflow/GraphLoader.hh
index 367e35b54..697ad3574 100644
--- a/src/Tensorflow/GraphLoader.hh
+++ b/src/Tensorflow/GraphLoader.hh
@@ -16,6 +16,8 @@
 #define _TENSORFLOW_GRAPH_LOADER_HH
 
 #include <Core/Component.hh>
+#include <tensorflow/core/public/version.h>
+#include <tensorflow/core/util/port.h>
 #include "Graph.hh"
 
 namespace Tensorflow {
@@ -39,7 +41,11 @@ protected:
 };
 
 inline GraphLoader::GraphLoader(Core::Configuration const& config)
-        : Precursor(config), required_libraries_(paramRequiredLibraries(config)) {
+        : Precursor(config),
+          required_libraries_(paramRequiredLibraries(config)) {
+    log("TF version: %s\nTF_GRAPH_DEF_VERSION: %d\nCUDA/MKL: %d/%d",
+        TF_VERSION_STRING, TF_GRAPH_DEF_VERSION,
+        tensorflow::IsGoogleCudaEnabled(), tensorflow::IsMklEnabled());
 }
 
 inline void GraphLoader::setGraphDef(Graph& graph, tf::GraphDef const& graph_def) {
diff --git a/src/Tensorflow/Makefile b/src/Tensorflow/Makefile
index d6d317abc..63f635e37 100644
--- a/src/Tensorflow/Makefile
+++ b/src/Tensorflow/Makefile
@@ -12,14 +12,19 @@ LDFLAGS  += $(TF_LDFLAGS)
 SUBDIRS		=
 TARGETS		= libSprintTensorflow.$(a) check$(exe)
 
-LIBSPRINTTENSORFLOW_O = $(OBJDIR)/Graph.o \
+LIBSPRINTTENSORFLOW_O = $(OBJDIR)/DummyStateManager.o \
+                        $(OBJDIR)/Graph.o \
                         $(OBJDIR)/GraphLoader.o \
                         $(OBJDIR)/MetaGraphLoader.o \
                         $(OBJDIR)/Module.o \
                         $(OBJDIR)/Session.o \
+                        $(OBJDIR)/StateManager.o \
                         $(OBJDIR)/Tensor.o \
                         $(OBJDIR)/TensorflowForwardNode.o \
+                        $(OBJDIR)/TensorflowFeatureScorer.o \
+                        $(OBJDIR)/TensorflowFeatureScorerStateCarryover.o \
                         $(OBJDIR)/TensorMap.o \
+                        $(OBJDIR)/TransformerStateManager.o \
                         $(OBJDIR)/VanillaGraphLoader.o
 
 CHECK_O = $(OBJDIR)/check.o \
diff --git a/src/Tensorflow/MetaGraphLoader.cc b/src/Tensorflow/MetaGraphLoader.cc
index 39bc2e2a1..d6e82aff1 100644
--- a/src/Tensorflow/MetaGraphLoader.cc
+++ b/src/Tensorflow/MetaGraphLoader.cc
@@ -63,7 +63,9 @@ std::unique_ptr<Graph> MetaGraphLoader::load_graph() {
     setGraphDef(*result, graph_def);
 
     for (std::string const& lib : required_libraries_) {
-        result->addLibrary(lib);
+        bool success = result->addLibrary(lib);
+        if (!success)
+            criticalError("Could not add library '%s': file not found.", lib.c_str());
     }
 
     std::unordered_map<std::string, Variable> vars;
diff --git a/src/Tensorflow/MetaGraphLoader.hh b/src/Tensorflow/MetaGraphLoader.hh
index 89d7744b0..a6472a8ff 100644
--- a/src/Tensorflow/MetaGraphLoader.hh
+++ b/src/Tensorflow/MetaGraphLoader.hh
@@ -42,7 +42,10 @@ private:
 };
 
 inline MetaGraphLoader::MetaGraphLoader(Core::Configuration const& config)
-        : Core::Component(config), MetaGraphLoader::Precursor(config), meta_graph_file_(paramMetaGraphFile(config)), saved_model_file_(paramSavedModelFile(config)) {
+        : Core::Component(config),
+          MetaGraphLoader::Precursor(config),
+          meta_graph_file_(paramMetaGraphFile(config)),
+          saved_model_file_(paramSavedModelFile(config)) {
 }
 
 }  // namespace Tensorflow
diff --git a/src/Tensorflow/Module.cc b/src/Tensorflow/Module.cc
index a1040488b..64dd34023 100644
--- a/src/Tensorflow/Module.cc
+++ b/src/Tensorflow/Module.cc
@@ -15,8 +15,12 @@
 #include "Module.hh"
 
 #include <Flow/Registry.hh>
+#include <Mm/FeatureScorerFactory.hh>
+#include <Mm/Module.hh>
 
 #include "MetaGraphLoader.hh"
+#include "TensorflowFeatureScorer.hh"
+#include "TensorflowFeatureScorerStateCarryover.hh"
 #include "TensorflowForwardNode.hh"
 #include "VanillaGraphLoader.hh"
 
@@ -26,7 +30,7 @@ enum GraphLoaderChoice {
     graphLoaderVanilla,
     graphLoaderMeta
 };
-}
+}  // namespace
 
 namespace Tensorflow {
 
@@ -41,6 +45,11 @@ Module_::Module_() {
 
     registry.registerFilter<TensorflowForwardNode>();
     registry.registerFilter<TensorflowOverlappingForwardNode>();
+
+    Mm::Module::instance().featureScorerFactory()->registerFeatureScorer<TensorflowFeatureScorer, Mm::MixtureSet, Mm::AbstractMixtureSetLoader>(
+            0x300 + 7, "tf-feature-scorer");  // TODO enum value
+    Mm::Module::instance().featureScorerFactory()->registerFeatureScorer<TensorflowFeatureScorerStateCarryover, Mm::MixtureSet, Mm::AbstractMixtureSetLoader>(
+            0x300 + 8, "tf-feature-scorer-state-carryover");  // TODO enum value
 }
 
 std::unique_ptr<GraphLoader> Module_::createGraphLoader(Core::Configuration const& config) {
diff --git a/src/Tensorflow/Session.hh b/src/Tensorflow/Session.hh
index c6efee420..ace8db4fd 100644
--- a/src/Tensorflow/Session.hh
+++ b/src/Tensorflow/Session.hh
@@ -64,7 +64,10 @@ private:
 // Inline implementations of simple functions
 
 inline Session::Session(Core::Configuration const& config)
-        : Precursor(config), profileRun_(paramProfileRun(config)), profilePrefix_(paramProfilePrefix(config)), profileCounter_(0ul) {
+        : Precursor(config),
+          profileRun_(paramProfileRun(config)),
+          profilePrefix_(paramProfilePrefix(config)),
+          profileCounter_(0ul) {
     tf::SessionOptions options;
     options.config.set_log_device_placement(paramLogDevicePlacement(config));
     options.config.set_intra_op_parallelism_threads(paramIntraOpParallelismThreads(config));
@@ -76,7 +79,8 @@ inline Session::Session(Core::Configuration const& config)
 
 inline Session::~Session() {
     if (session_.get() != nullptr) {
-        session_->Close();
+        tsl::Status unused = session_->Close();
+        (void)unused;
     }
 }
 
diff --git a/src/Tensorflow/StateManager.cc b/src/Tensorflow/StateManager.cc
new file mode 100644
index 000000000..716befd06
--- /dev/null
+++ b/src/Tensorflow/StateManager.cc
@@ -0,0 +1,42 @@
+#include "StateManager.hh"
+
+#include "DummyStateManager.hh"
+#include "TransformerStateManager.hh"
+
+namespace {
+enum StateManagerType : int {
+    Dummy,
+    Transformer
+};
+
+const Core::Choice stateManagerTypeChoice(
+        "dummy", StateManagerType::Dummy,
+        "transformer", StateManagerType::Transformer,
+        Core::Choice::endMark());
+
+const Core::ParameterChoice stateManagerTypeParam(
+        "type", &stateManagerTypeChoice, "type of stateManager", StateManagerType::Dummy);
+
+}  // namespace
+
+namespace Tensorflow {
+
+std::unique_ptr<StateManager> StateManager::create(Core::Configuration const& config, Graph const& graph, Session& session) {
+    switch (stateManagerTypeParam(config)) {
+        case Transformer:
+            return std::unique_ptr<StateManager>(new TransformerStateManager(config, graph, session));
+        case Dummy:
+        default:
+            return std::unique_ptr<StateManager>(new DummyStateManager(config, graph, session));
+    }
+
+    return std::unique_ptr<StateManager>();
+}
+
+StateManager::StateManager(Core::Configuration const& config, Graph const& graph, Session& session)
+        : Precursor(config),
+          graph_(graph),
+          session_(session) {
+}
+
+}  // namespace Tensorflow
diff --git a/src/Tensorflow/StateManager.hh b/src/Tensorflow/StateManager.hh
new file mode 100644
index 000000000..f16b42952
--- /dev/null
+++ b/src/Tensorflow/StateManager.hh
@@ -0,0 +1,31 @@
+#ifndef _TENSORFLOW_STATEMANAGER_HH
+#define _TENSORFLOW_STATEMANAGER_HH
+
+#include "Session.hh"
+#include "Tensor.hh"
+#include "TensorMap.hh"
+
+namespace Tensorflow {
+
+class StateManager : public Core::Component {
+public:
+    using Precursor = Core::Component;
+
+    static std::unique_ptr<StateManager> create(Core::Configuration const& config, Graph const& graph, Session& session);
+
+    StateManager(Core::Configuration const& config, Graph const& graph, Session& session);
+    virtual ~StateManager() = default;
+
+    virtual void                     setInitialState()                                     = 0;
+    virtual std::vector<std::string> getOutputs() const                                    = 0;
+    virtual std::vector<std::string> getTargets() const                                    = 0;
+    virtual void                     updateState(std::vector<Tensor> const& state_tensors) = 0;
+
+protected:
+    Graph const& graph_;
+    Session&     session_;
+};
+
+}  // namespace Tensorflow
+
+#endif  // _TENSORFLOW_STATEMANAGER_HH
diff --git a/src/Tensorflow/Tensor.cc b/src/Tensorflow/Tensor.cc
index e0dfb6f93..260a35eec 100644
--- a/src/Tensorflow/Tensor.cc
+++ b/src/Tensorflow/Tensor.cc
@@ -527,6 +527,42 @@ template void Tensor::get<bool>(bool&) const;
 
 // getters for a subset of the data (1-dim subset)
 
+template<typename T>
+void Tensor::get(size_t dim0_idx, Math::FastMatrix<T>& mat, bool transpose) const {
+    tf::DataType expected_dtype = ToDataType<T>::tf_type;
+    require(not empty());
+    require_eq(tensor_->dims(), 3);
+    require_eq(tensor_->dtype(), expected_dtype);
+    require_gt(tensor_->dim_size(0), static_cast<s64>(dim0_idx));
+
+    auto tensor_map = tensor_->flat_outer_dims<typename ToDataType<T>::cpp_type, 3>();
+    u32  rows       = static_cast<u32>(tensor_->dim_size(transpose ? 2 : 1));
+    u32  cols       = static_cast<u32>(tensor_->dim_size(transpose ? 1 : 2));
+
+    mat.resize(rows, cols);
+    if (transpose) {
+        for (u32 c = 0u; c < mat.nColumns(); c++) {
+            for (u32 r = 0u; r < mat.nRows(); r++) {
+                mat.at(r, c) = tensor_map(dim0_idx, c, r);
+            }
+        }
+    }
+    else {
+        for (u32 c = 0u; c < mat.nColumns(); c++) {
+            for (u32 r = 0u; r < mat.nRows(); r++) {
+                mat.at(r, c) = tensor_map(dim0_idx, r, c);
+            }
+        }
+    }
+}
+
+template void Tensor::get<f32>(size_t, Math::FastMatrix<f32>&, bool) const;
+template void Tensor::get<f64>(size_t, Math::FastMatrix<f64>&, bool) const;
+template void Tensor::get<s32>(size_t, Math::FastMatrix<s32>&, bool) const;
+template void Tensor::get<u32>(size_t, Math::FastMatrix<u32>&, bool) const;
+template void Tensor::get<s64>(size_t, Math::FastMatrix<s64>&, bool) const;
+template void Tensor::get<u64>(size_t, Math::FastMatrix<u64>&, bool) const;
+
 template<typename T>
 void Tensor::get(size_t dim0_idx, Math::FastVector<T>& vec) const {
     tf::DataType expected_dtype = ToDataType<T>::tf_type;
@@ -878,11 +914,66 @@ template s8 const*      Tensor::data<s8>(size_t, size_t, size_t) const;
 template u8 const*      Tensor::data<u8>(size_t, size_t, size_t) const;
 template tstring const* Tensor::data<tstring>(size_t, size_t, size_t) const;
 
+template<typename T>
+T* Tensor::data(size_t dim0_idx, size_t dim1_idx, size_t dim2_idx, size_t dim3_idx) {
+    tf::DataType expected_dtype = ToDataType<T>::tf_type;
+    require(not empty());
+    require_ge(tensor_->dims(), 4);
+    require_eq(tensor_->dtype(), expected_dtype);
+    require_gt(tensor_->dim_size(0), static_cast<s64>(dim0_idx));
+    require_gt(tensor_->dim_size(1), static_cast<s64>(dim1_idx));
+    require_gt(tensor_->dim_size(2), static_cast<s64>(dim2_idx));
+    require_gt(tensor_->dim_size(3), static_cast<s64>(dim3_idx));
+
+    auto tensor_map = tensor_->flat_outer_dims<typename ToDataType<T>::cpp_type, 4>();
+    return reinterpret_cast<T*>(&tensor_map(static_cast<s64>(dim0_idx), static_cast<s64>(dim1_idx), static_cast<s64>(dim2_idx), static_cast<s64>(dim3_idx)));
+}
+
+template f32*     Tensor::data<f32>(size_t, size_t, size_t, size_t);
+template f64*     Tensor::data<f64>(size_t, size_t, size_t, size_t);
+template s64*     Tensor::data<s64>(size_t, size_t, size_t, size_t);
+template u64*     Tensor::data<u64>(size_t, size_t, size_t, size_t);
+template s32*     Tensor::data<s32>(size_t, size_t, size_t, size_t);
+template u32*     Tensor::data<u32>(size_t, size_t, size_t, size_t);
+template s16*     Tensor::data<s16>(size_t, size_t, size_t, size_t);
+template u16*     Tensor::data<u16>(size_t, size_t, size_t, size_t);
+template s8*      Tensor::data<s8>(size_t, size_t, size_t, size_t);
+template u8*      Tensor::data<u8>(size_t, size_t, size_t, size_t);
+template tstring* Tensor::data<tstring>(size_t, size_t, size_t, size_t);
+
+template<typename T>
+T const* Tensor::data(size_t dim0_idx, size_t dim1_idx, size_t dim2_idx, size_t dim3_idx) const {
+    tf::DataType expected_dtype = ToDataType<T>::tf_type;
+    require(not empty());
+    require_ge(tensor_->dims(), 4);
+    require_eq(tensor_->dtype(), expected_dtype);
+    require_gt(tensor_->dim_size(0), static_cast<s64>(dim0_idx));
+    require_gt(tensor_->dim_size(1), static_cast<s64>(dim1_idx));
+    require_gt(tensor_->dim_size(2), static_cast<s64>(dim2_idx));
+    require_gt(tensor_->dim_size(3), static_cast<s64>(dim3_idx));
+
+    auto tensor_map = tensor_->flat_outer_dims<typename ToDataType<T>::cpp_type, 4>();
+    return reinterpret_cast<T*>(&tensor_map(static_cast<s64>(dim0_idx), static_cast<s64>(dim1_idx), static_cast<s64>(dim2_idx), static_cast<s64>(dim3_idx)));
+}
+
+template f32 const*     Tensor::data<f32>(size_t, size_t, size_t, size_t) const;
+template f64 const*     Tensor::data<f64>(size_t, size_t, size_t, size_t) const;
+template s64 const*     Tensor::data<s64>(size_t, size_t, size_t, size_t) const;
+template u64 const*     Tensor::data<u64>(size_t, size_t, size_t, size_t) const;
+template s32 const*     Tensor::data<s32>(size_t, size_t, size_t, size_t) const;
+template u32 const*     Tensor::data<u32>(size_t, size_t, size_t, size_t) const;
+template s16 const*     Tensor::data<s16>(size_t, size_t, size_t, size_t) const;
+template u16 const*     Tensor::data<u16>(size_t, size_t, size_t, size_t) const;
+template s8 const*      Tensor::data<s8>(size_t, size_t, size_t, size_t) const;
+template u8 const*      Tensor::data<u8>(size_t, size_t, size_t, size_t) const;
+template tstring const* Tensor::data<tstring>(size_t, size_t, size_t, size_t) const;
+
 Tensor Tensor::slice(std::vector<int> const& start, std::vector<int> const& end) {
     require_le(static_cast<int>(start.size()), numDims());
     require_eq(start.size(), end.size());
 
-    u32                nDim = numDims();
+    bool               empty = false;
+    u32                nDim  = numDims();
     std::vector<int64> start_vec(nDim);
     std::vector<int64> size_vec(nDim);
     for (size_t i = 0ul; i < nDim; ++i) {
@@ -896,25 +987,28 @@ Tensor Tensor::slice(std::vector<int> const& start, std::vector<int> const& end)
         }
         start_vec[i] = dim_start;
         size_vec[i]  = dim_end - dim_start;
+        empty |= size_vec[i] == 0;
         require_ge(size_vec[i], 0);
     }
 
     Tensor res;
     res.tensor_.reset(new tf::Tensor(tensor_->dtype(), tf::TensorShape(size_vec)));
 
-    switch (tensor_->dtype()) {
-        case tf::DT_FLOAT: dynamic_rank_slice<tf::EnumToDataType<tf::DT_FLOAT>::Type>(*res.tensor_, *tensor_, start_vec, size_vec); break;
-        case tf::DT_DOUBLE: dynamic_rank_slice<tf::EnumToDataType<tf::DT_DOUBLE>::Type>(*res.tensor_, *tensor_, start_vec, size_vec); break;
-        case tf::DT_INT64: dynamic_rank_slice<tf::EnumToDataType<tf::DT_INT64>::Type>(*res.tensor_, *tensor_, start_vec, size_vec); break;
-        case tf::DT_UINT64: dynamic_rank_slice<tf::EnumToDataType<tf::DT_UINT64>::Type>(*res.tensor_, *tensor_, start_vec, size_vec); break;
-        case tf::DT_INT32: dynamic_rank_slice<tf::EnumToDataType<tf::DT_INT32>::Type>(*res.tensor_, *tensor_, start_vec, size_vec); break;
-        case tf::DT_UINT32: dynamic_rank_slice<tf::EnumToDataType<tf::DT_UINT32>::Type>(*res.tensor_, *tensor_, start_vec, size_vec); break;
-        case tf::DT_INT16: dynamic_rank_slice<tf::EnumToDataType<tf::DT_INT16>::Type>(*res.tensor_, *tensor_, start_vec, size_vec); break;
-        case tf::DT_UINT16: dynamic_rank_slice<tf::EnumToDataType<tf::DT_UINT16>::Type>(*res.tensor_, *tensor_, start_vec, size_vec); break;
-        case tf::DT_INT8: dynamic_rank_slice<tf::EnumToDataType<tf::DT_INT8>::Type>(*res.tensor_, *tensor_, start_vec, size_vec); break;
-        case tf::DT_UINT8: dynamic_rank_slice<tf::EnumToDataType<tf::DT_UINT8>::Type>(*res.tensor_, *tensor_, start_vec, size_vec); break;
-        case tf::DT_BOOL: dynamic_rank_slice<tf::EnumToDataType<tf::DT_BOOL>::Type>(*res.tensor_, *tensor_, start_vec, size_vec); break;
-        default: defect();
+    if (not empty) {
+        switch (tensor_->dtype()) {
+            case tf::DT_FLOAT: dynamic_rank_slice<tf::EnumToDataType<tf::DT_FLOAT>::Type>(*res.tensor_, *tensor_, start_vec, size_vec); break;
+            case tf::DT_DOUBLE: dynamic_rank_slice<tf::EnumToDataType<tf::DT_DOUBLE>::Type>(*res.tensor_, *tensor_, start_vec, size_vec); break;
+            case tf::DT_INT64: dynamic_rank_slice<tf::EnumToDataType<tf::DT_INT64>::Type>(*res.tensor_, *tensor_, start_vec, size_vec); break;
+            case tf::DT_UINT64: dynamic_rank_slice<tf::EnumToDataType<tf::DT_UINT64>::Type>(*res.tensor_, *tensor_, start_vec, size_vec); break;
+            case tf::DT_INT32: dynamic_rank_slice<tf::EnumToDataType<tf::DT_INT32>::Type>(*res.tensor_, *tensor_, start_vec, size_vec); break;
+            case tf::DT_UINT32: dynamic_rank_slice<tf::EnumToDataType<tf::DT_UINT32>::Type>(*res.tensor_, *tensor_, start_vec, size_vec); break;
+            case tf::DT_INT16: dynamic_rank_slice<tf::EnumToDataType<tf::DT_INT16>::Type>(*res.tensor_, *tensor_, start_vec, size_vec); break;
+            case tf::DT_UINT16: dynamic_rank_slice<tf::EnumToDataType<tf::DT_UINT16>::Type>(*res.tensor_, *tensor_, start_vec, size_vec); break;
+            case tf::DT_INT8: dynamic_rank_slice<tf::EnumToDataType<tf::DT_INT8>::Type>(*res.tensor_, *tensor_, start_vec, size_vec); break;
+            case tf::DT_UINT8: dynamic_rank_slice<tf::EnumToDataType<tf::DT_UINT8>::Type>(*res.tensor_, *tensor_, start_vec, size_vec); break;
+            case tf::DT_BOOL: dynamic_rank_slice<tf::EnumToDataType<tf::DT_BOOL>::Type>(*res.tensor_, *tensor_, start_vec, size_vec); break;
+            default: defect();
+        }
     }
 
     return res;
diff --git a/src/Tensorflow/Tensor.hh b/src/Tensorflow/Tensor.hh
index 543570d8b..5d4381188 100644
--- a/src/Tensorflow/Tensor.hh
+++ b/src/Tensorflow/Tensor.hh
@@ -88,6 +88,9 @@ public:
 
     // getters for a subset of the data (1-dim subset)
 
+    template<typename T>
+    void get(size_t dim0_idx, Math::FastMatrix<T>& mat, bool transpose = false) const;
+
     template<typename T>
     void get(size_t dim0_idx, Math::FastVector<T>& vec) const;
 
@@ -134,6 +137,12 @@ public:
     template<typename T>
     T const* data(size_t dim0_idx, size_t dim1_idx, size_t dim2_idx) const;
 
+    template<typename T>
+    T* data(size_t dim0_idx, size_t dim1_idx, size_t dim2_idx, size_t dim3_idx);
+
+    template<typename T>
+    T const* data(size_t dim0_idx, size_t dim1_idx, size_t dim2_idx, size_t dim3_idx) const;
+
     Tensor slice(std::vector<int> const& start, std::vector<int> const& end);
 
     /* -------------------- Setters -------------------- */
diff --git a/src/Tensorflow/TensorMap.hh b/src/Tensorflow/TensorMap.hh
index 4a65797fe..c291a5345 100644
--- a/src/Tensorflow/TensorMap.hh
+++ b/src/Tensorflow/TensorMap.hh
@@ -82,7 +82,10 @@ typedef TensorMap<TensorOutputInfo> TensorOutputMap;
 // ---------- TensorInfo ----------
 
 inline TensorInfo::TensorInfo(Core::Configuration const& config)
-        : Precursor(config), param_name_(paramParamName(config)), tensor_name_(paramTensorName(config)), seq_length_tensor_name_(paramSeqLengthTensorName(config)) {
+        : Precursor(config),
+          param_name_(paramParamName(config)),
+          tensor_name_(paramTensorName(config)),
+          seq_length_tensor_name_(paramSeqLengthTensorName(config)) {
 }
 
 inline std::string const& TensorInfo::param_name() const {
diff --git a/src/Tensorflow/TensorflowFeatureScorer.cc b/src/Tensorflow/TensorflowFeatureScorer.cc
new file mode 100644
index 000000000..bc0ed1cee
--- /dev/null
+++ b/src/Tensorflow/TensorflowFeatureScorer.cc
@@ -0,0 +1,305 @@
+/** Copyright 2018 RWTH Aachen University. All rights reserved.
+ *
+ *  Licensed under the RWTH ASR License (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.hltpr.rwth-aachen.de/rwth-asr/rwth-asr-license.html
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+#include "TensorflowFeatureScorer.hh"
+#include <thread>
+
+#include "Module.hh"
+/*
+ * TensorflowFeatureScorer is based on Nn/TrainerFeatureScorer.cc.
+ * Instead of instantiating a trainer, it feeds features through a TF graph
+ */
+namespace Tensorflow {
+
+static const Core::ParameterInt paramFeatureDimension(
+        "feature-dimension", "feature = input dimension");
+
+static const Core::ParameterInt paramOutputDimension(
+        "trainer-feature-scorer-output-dimension", "if set, will ignore the number of mixtures", -1);
+
+static const Core::ParameterBool paramUseOutputAsIs(
+        "use-output-as-is", "return the output of the neural network without modification (except prior)", false);
+
+static const Core::ParameterBool paramReturnScoresInNegLog(
+        "return-scores-in-neg-log", "return scores in -log space (default)", true);
+
+static const Core::ParameterBool paramAsyncInitalization(
+        "async-initialization", "initializa tensorflow asynchronously", false);
+
+TensorflowFeatureScorer::TensorflowFeatureScorer(const Core::Configuration& config, Core::Ref<const Mm::MixtureSet> mixtureSet)
+        : Core::Component(config),
+          Mm::FeatureScorer(config),
+          nClasses_(mixtureSet->nMixtures()),
+          inputDimension_(paramFeatureDimension(config)),
+          useOutputAsIs_(paramUseOutputAsIs(config)),
+          returnScoresInNegLog_(paramReturnScoresInNegLog(config)),
+          asyncInitialization_(paramAsyncInitalization(config)),
+          prior_(config),
+          currentFeature_(0),
+          scoresComputed_(false),
+          batchIteration_(0),
+          session_(select("session")),
+          loader_(Module::instance().createGraphLoader(select("loader"))),
+          graph_(loader_->load_graph()),
+          tensor_input_map_(select("input-map")),
+          tensor_output_map_(select("output-map")),
+          state_manager_() {
+    if (asyncInitialization_) {
+        std::thread t(&TensorflowFeatureScorer::initializeTensorflow, this);
+        t.detach();
+    }
+    else {
+        initializeTensorflow();
+    }
+    // no need to resize as Tensor::get() will resize on demand
+    scores_ = std::unique_ptr<Math::FastMatrix<Float>>(new Math::FastMatrix<Float>);
+
+    log("initialize tf-feature-scorer with feature dimension %i", inputDimension_);
+    require_gt(inputDimension_, 0);
+
+    int outputDim = paramOutputDimension(config);
+    if (outputDim >= 0) {
+        log("tf-feature-scorer will ignore mixture-set number of classes %i but use %i instead", nClasses_, outputDim);
+        nClasses_ = outputDim;
+    }
+
+    labelWrapper_ = std::unique_ptr<Nn::ClassLabelWrapper>(new Nn::ClassLabelWrapper(select("class-labels"), nClasses_));
+    if (!labelWrapper_->isOneToOneMapping())
+        error("no one-to-one correspondence between network outputs and classes!");
+
+    if (prior_.scale() != 0) {
+        if (prior_.fileName() != "")
+            prior_.read();
+        else
+            prior_.setFromMixtureSet(mixtureSet, *labelWrapper_);
+        // The prior classes are the NN output classes.
+        require_eq(labelWrapper_->nClassesToAccumulate(), prior_.size());
+    }
+}
+
+void TensorflowFeatureScorer::initializeTensorflow() {
+    session_.addGraph(*graph_);
+    loader_->initialize(session_);
+
+    state_manager_ = StateManager::create(select("state-manager"), *graph_, session_);
+    state_manager_->setInitialState();
+
+    output_tensor_names_.push_back(tensor_output_map_.get_info("posterior").tensor_name());
+
+    auto state_outputs = state_manager_->getOutputs();
+
+    output_tensor_names_.insert(output_tensor_names_.end(), state_outputs.begin(), state_outputs.end());
+    target_tensor_names_ = state_manager_->getTargets();
+
+    tensorflowInitialized_.store(true);
+}
+
+/**
+ * Stores the current feature and the number of buffered features.
+ * All computations are done in TensorflowFeatureScorer.
+ * This class is used only because it is required by the
+ * FeatureScorer interface.
+ */
+class TensorflowFeatureScorer::ContextScorer : public FeatureScorer::ContextScorer {
+public:
+    ContextScorer(const TensorflowFeatureScorer* parent, u32 currentFeature, u32 batchIteration)
+            : parent_(parent),
+              currentFeature_(currentFeature),
+              batchIteration_(batchIteration) {}
+    virtual ~ContextScorer() {}
+    virtual Mm::EmissionIndex nEmissions() const {
+        return parent_->nMixtures();
+    }
+    virtual Mm::Score score(Mm::EmissionIndex e) const {
+        require_eq(batchIteration_, parent_->batchIteration_);
+        return parent_->getScore(e, currentFeature_);
+    }
+
+private:
+    const TensorflowFeatureScorer* parent_;
+    u32                            currentFeature_;
+    u32                            batchIteration_;
+};
+
+void TensorflowFeatureScorer::_addFeature(const Mm::FeatureVector& f) const {
+    require(!bufferFilled());
+    require(!scoresComputed_);
+    if (inputDimension_ != f.size()) {
+        criticalError("feature-scorer was configured with input dimension %i but we got features with dimension %zu",
+                      inputDimension_, f.size());
+    }
+    buffer_.push_back(f);
+}
+
+void TensorflowFeatureScorer::addFeature(const Mm::FeatureVector& f) const {
+    // Lazily call reset() when flush() went through all the buffer before.
+    if (currentFeature_ > 0 && scoresComputed_ && currentFeature_ >= scores_->nRows()) {
+        reset();
+    }
+    _addFeature(f);
+}
+
+void TensorflowFeatureScorer::reset() const {
+    if (!buffer_.empty()) {
+        buffer_.clear();
+        buffer_.shrink_to_fit();
+    }
+    scoresComputed_ = false;
+    currentFeature_ = 0;
+    batchIteration_++;
+}
+
+void TensorflowFeatureScorer::finalize() const {
+    waitForInitialization();
+    state_manager_->setInitialState();
+}
+
+Mm::EmissionIndex TensorflowFeatureScorer::nMixtures() const {
+    require_gt(nClasses_, 0);
+    return nClasses_;
+}
+
+void TensorflowFeatureScorer::getFeatureDescription(Mm::FeatureDescription& description) const {
+    require_gt(inputDimension_, 0);
+    description.mainStream().setValue(Mm::FeatureDescription::nameDimension, inputDimension_);
+}
+
+// See comment in header. The scorer is not for `f`.
+Mm::FeatureScorer::Scorer TensorflowFeatureScorer::getScorer(const Mm::FeatureVector& f) const {
+    _addFeature(f);  // Don't reset() yet.
+    return flush();
+}
+
+Mm::FeatureScorer::Scorer TensorflowFeatureScorer::flush() const {
+    const_cast<TensorflowFeatureScorer*>(this)->_compute();
+    require_lt(currentFeature_, scores_->nRows());
+    Scorer scorer(new ContextScorer(this, currentFeature_, batchIteration_));
+    currentFeature_++;
+    // We must not call reset() here because the calls to getScore() will be delayed.
+    return scorer;
+}
+
+Tensor TensorflowFeatureScorer::_createInputTensor() const {
+    // copy from deque into a matrix
+    size_t num_frames = buffer_.size();
+    require_gt(num_frames, 0);
+    std::vector<Math::FastMatrix<f32>> nnBuffer(1);  // single "batch"
+    nnBuffer[0].resize(buffer_[0].size(), num_frames);
+
+    for (u32 t = 0; t < num_frames; ++t) {
+        for (u32 i = 0; i < buffer_[0].size(); ++i) {
+            nnBuffer[0].at(i, t) = buffer_[t].at(i);
+        }
+    }
+    return Tensor::create(nnBuffer, true);
+}
+
+void TensorflowFeatureScorer::_compute() {
+    if (!scoresComputed_) {
+        size_t                                      num_frames = buffer_.size();
+        std::vector<std::pair<std::string, Tensor>> inputs;
+        auto const&                                 tensor_info = tensor_input_map_.get_info("features");
+        inputs.push_back({tensor_info.tensor_name(), _createInputTensor()});
+        if (not tensor_info.seq_length_tensor_name().empty()) {
+            inputs.push_back({tensor_info.seq_length_tensor_name(),
+                              Tensor::create(std::vector<s32>{static_cast<s32>(num_frames)})});
+        }
+
+        auto                t_start = std::chrono::system_clock::now();
+        std::vector<Tensor> tf_output;
+
+        waitForInitialization();
+
+        // evaluate graph
+        session_.run(inputs, output_tensor_names_, target_tensor_names_, tf_output);
+
+        tf_output[0].get<>(0, *scores_);
+
+        std::vector<Tensor> state_vars(tf_output.size() - 1ul);
+        for (size_t i = 1ul; i < tf_output.size(); i++) {
+            state_vars.emplace_back(std::move(tf_output[i]));
+        }
+        state_manager_->updateState(state_vars);
+
+        auto t_end     = std::chrono::system_clock::now();
+        auto t_elapsed = std::chrono::duration_cast<std::chrono::duration<double>>(t_end - t_start).count();
+        printf("num_frames: %zu elapsed: %f AM_RTF: %f\n", num_frames, t_elapsed, t_elapsed / (num_frames / 100.0));
+
+        // mark computed
+        scoresComputed_ = true;
+    }
+}
+
+Mm::Score TensorflowFeatureScorer::getScore(Mm::EmissionIndex e, u32 position) const {
+    const_cast<TensorflowFeatureScorer*>(this)->_compute();
+    require_lt(position, scores_->nRows());
+
+    Mm::Score score = 0.0;
+    if (labelWrapper_->isClassToAccumulate(e)) {
+        u32 idx = labelWrapper_->getOutputIndexFromClassIndex(e);
+        score   = -scores_->at(position, idx); /* note the minus! this requires the output layer to use activation = 'log_softmax' */
+
+        if (useOutputAsIs_) {
+            score = -score;
+        }
+        else if (returnScoresInNegLog_) {
+            score = -Core::log(-score);  // transfer to -log space
+        }
+
+        if (prior_.scale() != 0) {
+            score -= -prior_.at(idx) * prior_.scale();  // priors are in +log space. substract them
+        }
+    }
+    else {
+        if (returnScoresInNegLog_) {
+            score = Core::Type<Mm::Score>::max;  // = score 0 in std space
+        }
+        else {
+            score = 0;
+        }
+    }
+    return score;
+}
+
+Mm::FeatureScorer::Scorer TensorflowFeatureScorer::getTimeIndexedScorer(u32 time) const {
+    const_cast<TensorflowFeatureScorer*>(this)->_compute();
+    require_lt(time, scores_->nRows());
+    Scorer scorer(new ContextScorer(this, time, batchIteration_));
+    return scorer;
+}
+
+// Must never be full. We want to support segments of any len, and we want to
+// get all features in advance before we calculate the scores (to support bi-RNNs).
+bool TensorflowFeatureScorer::bufferFilled() const {
+    return false;
+}  // == cannot call addFeature() anymore
+
+bool TensorflowFeatureScorer::bufferEmpty() const {
+    return scoresComputed_ && currentFeature_ >= scores_->nRows();
+}  // == cannot call flush() anymore
+
+u32 TensorflowFeatureScorer::bufferSize() const {
+    return std::numeric_limits<u32>::max();
+}
+
+void TensorflowFeatureScorer::waitForInitialization() const {
+    if (not asyncInitialization_) {
+        return;
+    }
+    while (not tensorflowInitialized_.load()) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(5));
+    }
+}
+
+}  // namespace Tensorflow
diff --git a/src/Tensorflow/TensorflowFeatureScorer.hh b/src/Tensorflow/TensorflowFeatureScorer.hh
new file mode 100644
index 000000000..48a0fffcb
--- /dev/null
+++ b/src/Tensorflow/TensorflowFeatureScorer.hh
@@ -0,0 +1,163 @@
+/** Copyright 2018 RWTH Aachen University. All rights reserved.
+ *
+ *  Licensed under the RWTH ASR License (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.hltpr.rwth-aachen.de/rwth-asr/rwth-asr-license.html
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+#ifndef NN_TENSORFLOWFEATURESCORER_HH
+#define NN_TENSORFLOWFEATURESCORER_HH
+
+#include <Core/Types.hh>
+#include <Mm/Feature.hh>
+#include <Mm/FeatureScorer.hh>
+#include <Mm/MixtureSet.hh>
+#include <Mm/Types.hh>
+#include <Nn/ClassLabelWrapper.hh>
+#include <Nn/Prior.hh>
+#include <Nn/Types.hh>
+#include <deque>
+
+#include "GraphLoader.hh"
+#include "Session.hh"
+#include "StateManager.hh"
+#include "Tensor.hh"
+#include "TensorMap.hh"
+
+namespace Tensorflow {
+
+// We use a TF graph to calculate posterior scores and wrap those in a Mm::FeatureScorer.
+// Otherwise, it's quite similar to the Nn::BatchFeatureScorer.
+class TensorflowFeatureScorer : public Mm::FeatureScorer {
+protected:
+    using Float = Mm::Score;
+    class ContextScorer;
+
+    u32        nClasses_;
+    const u32  inputDimension_;
+    const bool useOutputAsIs_;
+    const bool returnScoresInNegLog_;
+    const bool asyncInitialization_;
+
+    Nn::Prior<Float>                       prior_;
+    mutable u32                            currentFeature_; /* pointer to current position in buffer */
+    mutable std::deque<Mm::FeatureVector>  buffer_;
+    mutable bool                           scoresComputed_;
+    mutable u32                            batchIteration_;
+    std::unique_ptr<Nn::ClassLabelWrapper> labelWrapper_;
+    std::atomic<bool>                      tensorflowInitialized_;
+
+    void         _addFeature(const Mm::FeatureVector& f) const;
+    Tensor       _createInputTensor() const;
+    virtual void _compute();
+    void         initializeTensorflow();
+    void         waitForInitialization() const;
+
+    // tensorflow related members
+    std::vector<std::string>                 output_tensor_names_;
+    std::vector<std::string>                 target_tensor_names_;
+    mutable Session                          session_;
+    std::unique_ptr<GraphLoader>             loader_;
+    std::unique_ptr<Tensorflow::Graph>       graph_;
+    TensorInputMap                           tensor_input_map_;
+    TensorOutputMap                          tensor_output_map_;
+    std::unique_ptr<StateManager>            state_manager_;
+    std::unique_ptr<Math::FastMatrix<Float>> scores_;
+
+public:
+    TensorflowFeatureScorer(const Core::Configuration& c, Core::Ref<const Mm::MixtureSet> mixtureSet);
+    virtual ~TensorflowFeatureScorer() = default;
+
+    virtual Mm::EmissionIndex nMixtures() const;
+    virtual void              getFeatureDescription(Mm::FeatureDescription& description) const;
+
+    typedef Core::Ref<const ContextScorer> Scorer;
+    /**
+     * Return a scorer for the current feature and append the
+     * given feature to the buffer.
+     * The current feature may not be the same as f
+     * because of the feature buffering.
+     * Requires bufferFilled() == true.
+     */
+    virtual FeatureScorer::Scorer getScorer(Core::Ref<const Mm::Feature> f) const {
+        return getScorer(*f->mainStream());
+    }
+    virtual FeatureScorer::Scorer getScorer(const Mm::FeatureVector& f) const;
+
+    virtual Mm::Score getScore(Mm::EmissionIndex e, u32 position) const;
+
+    /**
+     * reset should be overloaded/defined in/for
+     * featurescorer related to sign language recognition
+     * especially the tracking part
+     *
+     */
+    virtual void reset() const;
+
+    /**
+     * finalize should be overloaded/defined in classes using
+     * embedded flow networks to sent final end of sequence token
+     * if necessary
+     */
+    virtual void finalize() const;
+
+    /**
+     * Return true if the feature scorer buffers features.
+     */
+    virtual bool isBuffered() const {
+        return true;
+    }
+
+    /**
+     * Add a feature to the feature buffer.
+     */
+    virtual void addFeature(const Mm::FeatureVector& f) const;
+    virtual void addFeature(Core::Ref<const Mm::Feature> f) const {
+        addFeature(*f->mainStream());
+    }
+
+    /**
+     * Return a scorer for the current feature without adding a
+     * new feature to the buffer.
+     * Should be called until bufferEmpty() == true.
+     * Requires bufferEmpty() == false.
+     * Implementation required if isBuffered() == true
+     */
+    virtual Mm::FeatureScorer::Scorer flush() const;
+
+    /**
+     * Return true if the feature buffer is full.
+     */
+    virtual bool bufferFilled() const;
+
+    /**
+     * Return true if the feature buffer is empty.
+     */
+    virtual bool bufferEmpty() const;
+
+    /**
+     * Return the number of buffered features required to
+     * execute getScorer().
+     * This will be MAX_INT for this class, because there is no limit.
+     * Normally, you would just use bufferFilled()/bufferEmpy() instead.
+     */
+    virtual u32 bufferSize() const;
+
+    /**
+     * Like CachedNeuralNetworkFeatureScorer, used in SegmentwiseAlignmentGenerator.
+     */
+    virtual bool hasTimeIndexedCache() const {
+        return true;
+    }
+    virtual FeatureScorer::Scorer getTimeIndexedScorer(u32 time) const;
+};
+}  // namespace Tensorflow
+
+#endif  // NN_TENSORFLOWFEATURESCORER_HH
diff --git a/src/Tensorflow/TensorflowFeatureScorerStateCarryover.cc b/src/Tensorflow/TensorflowFeatureScorerStateCarryover.cc
new file mode 100644
index 000000000..517364c1b
--- /dev/null
+++ b/src/Tensorflow/TensorflowFeatureScorerStateCarryover.cc
@@ -0,0 +1,110 @@
+/** Copyright 2018 RWTH Aachen University. All rights reserved.
+ *
+ *  Licensed under the RWTH ASR License (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.hltpr.rwth-aachen.de/rwth-asr/rwth-asr-license.html
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+#include "TensorflowFeatureScorerStateCarryover.hh"
+#include "Module.hh"
+
+namespace Tensorflow {
+
+static const Core::ParameterInt paramSaveStatePosition(
+        "save-state-position", "save hidden state from this position in time; default = last timestamp", Core::Type<u32>::max);
+
+TensorflowFeatureScorerStateCarryover::TensorflowFeatureScorerStateCarryover(const Core::Configuration& config, Core::Ref<const Mm::MixtureSet> mixtureSet)
+        : Core::Component(config),
+          TensorflowFeatureScorer(config, mixtureSet),
+          save_state_position_(paramSaveStatePosition(config)) {
+    log("Initializing tf-feature-scorer-state-carryover. Will save hidden states in position t=%zu for the following variables", save_state_position_);
+    for (std::string const& s : graph_->state_vars()) {
+        // will only get variables of layers with initial_state = keep_over_epoch_no_init in returnn config
+        auto const& var = graph_->variables().find(s)->second;
+        initializer_tensor_names_.push_back(var.initializer_name);
+
+        SavedState state(var);
+        saved_state_map_[state.initializer_name] = state;
+        output_tensor_names_.push_back(state.lstm_output);
+        log("SavedState: initial_value_name=%s initializer_name=%s lstm_output=%s dim=%zu\n",
+            var.initial_value_name.c_str(), state.initializer_name.c_str(), state.lstm_output.c_str(), state.dim);
+    }
+}
+
+void TensorflowFeatureScorerStateCarryover::_compute() {
+    size_t num_frames = buffer_.size();
+    // process buffer if needed
+    if (!scoresComputed_) {
+        scores_->resize(nClasses_, num_frames);
+        std::vector<std::pair<std::string, Tensor>> inputs;
+        std::vector<Tensor>                         tf_output;
+
+        // 1. Initialize hidden states from saved values
+        for (const auto& it : saved_state_map_) {
+            const SavedState& state = it.second;
+            inputs.emplace_back(std::make_pair(state.initial_value_name, Tensorflow::Tensor::create(state.state, true)));
+        }
+        session_.run(inputs, initializer_tensor_names_);
+
+        // 2. Feed input features through the graph
+        inputs.clear();
+        auto const& tensor_info = tensor_input_map_.get_info("features");
+        inputs.push_back({tensor_info.tensor_name(), _createInputTensor()});
+        if (not tensor_info.seq_length_tensor_name().empty()) {
+            inputs.push_back({tensor_info.seq_length_tensor_name(),
+                              Tensor::create(std::vector<s32>{static_cast<s32>(num_frames)})});
+        }
+
+        auto t_start = std::chrono::system_clock::now();
+        session_.run(inputs, output_tensor_names_, {}, tf_output);
+        tf_output[0].get<>(0, *scores_);
+
+        auto t_end     = std::chrono::system_clock::now();
+        auto t_elapsed = std::chrono::duration_cast<std::chrono::duration<double>>(t_end - t_start).count();
+        log("num_frames: %zu elapsed: %f AM_RTF: %f\n", num_frames, t_elapsed, t_elapsed / (num_frames / 100.0));
+
+        // mark computed
+        scoresComputed_ = true;
+
+        // 3. save hidden states
+        if (save_state_position_ < num_frames) {
+            for (size_t s = 1 /* 0 = softmax */; s < output_tensor_names_.size(); ++s) {
+                if (output_tensor_names_[s].find("NativeLstm2:2") == std::string::npos)
+                    continue;
+
+                SavedState& h = saved_state_map_[initializer_tensor_names_[s - 1]];
+                SavedState& c = saved_state_map_[initializer_tensor_names_[s - 2]];
+                require(c.dim == h.dim);
+                Math::FastMatrix<f32> memory_cell(c.dim * 4, 1);
+                Math::FastMatrix<f32> output_gate(c.dim, 1);
+
+                tf_output[s - 1].get<>(save_state_position_, c.state, true);
+                c.state.resizeRowsAndKeepContent(c.dim);
+
+                tf_output[s - 1].get<>(save_state_position_, h.state, true);
+                h.state.resizeRowsAndKeepContent(h.dim);
+                h.state.tanh();
+
+                tf_output[s].get<>(save_state_position_, memory_cell, true);
+                output_gate.copyBlockFromMatrix(memory_cell, c.dim * 3, 0, 0, 0, c.dim, 1);
+                h.state.elementwiseMultiplication(output_gate);
+            }
+        }
+    }
+}
+
+void TensorflowFeatureScorerStateCarryover::finalize() const {
+    for (auto& it : saved_state_map_) {
+        SavedState& state = it.second;
+        state.resetState();
+    }
+}
+
+}  // namespace Tensorflow
diff --git a/src/Tensorflow/TensorflowFeatureScorerStateCarryover.hh b/src/Tensorflow/TensorflowFeatureScorerStateCarryover.hh
new file mode 100644
index 000000000..aaa89c21e
--- /dev/null
+++ b/src/Tensorflow/TensorflowFeatureScorerStateCarryover.hh
@@ -0,0 +1,91 @@
+/** Copyright 2018 RWTH Aachen University. All rights reserved.
+ *
+ *  Licensed under the RWTH ASR License (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.hltpr.rwth-aachen.de/rwth-asr/rwth-asr-license.html
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+#ifndef NN_TENSORFLOWFEATURESCORERSTATECARRYOVER_HH
+#define NN_TENSORFLOWFEATURESCORERSTATECARRYOVER_HH
+
+#include "TensorflowFeatureScorer.hh"
+
+namespace Tensorflow {
+
+/**
+ * This scorer is similar to TensorflowFeatureScorer but additionally keeps track
+ * of the hidden states in order to initialize the next round of scoring.
+ */
+class TensorflowFeatureScorerStateCarryover : public TensorflowFeatureScorer {
+private:
+    /**
+     * SavedState wraps the names of the initializer tensor and NativeLstm2 LSTM
+     * cell output tensors corresponding to C and H; see
+     * https://returnn.readthedocs.io/en/latest/api/NativeOp.html#NativeOp.NativeLstm2 and
+     * https://github.com/rwth-i6/returnn/blob/master/NativeOp.py#L1364-L1769
+     *
+     * initializer_name   is of the form "my_nativelstm2_fw_layer_name/rec/keep_state_{c,h}/Assign"
+     * initial_value_name is of the form "my_nativelstm2_fw_layer_name/rec/zeros:0"
+     * lstm_output is the name of the tensor that corresponds to NativeLstm2's C and H, e.g.
+     *                                   "my_nativelstm2_fw_layer_name/rec/NativeLstm2:1"
+     */
+    struct SavedState {
+        size_t                dim;
+        std::string           initializer_name, initial_value_name;
+        std::string           lstm_output;
+        Math::FastMatrix<f32> state;
+
+        SavedState() {}
+        SavedState(const Tensorflow::Variable& var)
+                : dim(var.shape.back()),
+                  initializer_name(var.initializer_name),
+                  initial_value_name(var.initial_value_name) {
+            require_gt(dim, 0);
+            size_t pos = initializer_name.find("/keep_state_");
+            require(pos != std::string::npos);
+            lstm_output = initializer_name.substr(0, pos + 1);
+
+            if (initializer_name.find("keep_state_c") != std::string::npos) {
+                lstm_output += "NativeLstm2:1";
+            }
+            else if (initializer_name.find("keep_state_h") != std::string::npos) {
+                lstm_output += "NativeLstm2:2";
+            }
+            else {
+                Core::Application::us()->error("can't parse initializer_name '%s'", initializer_name.c_str());
+            }
+            state.resize(dim, 1);
+            resetState();
+        }
+
+        void resetState() {
+            state.setToZero();
+        }
+    };
+
+    virtual void _compute();
+
+    size_t save_state_position_;
+    // mutable, because we modify it from getScore() and finalize()
+    mutable std::map<std::string, SavedState> saved_state_map_;
+    std::vector<std::string>                  initializer_tensor_names_;
+
+public:
+    TensorflowFeatureScorerStateCarryover(const Core::Configuration& c, Core::Ref<const Mm::MixtureSet> mixtureSet);
+    virtual ~TensorflowFeatureScorerStateCarryover() = default;
+
+    /**
+     * This is called at the end of each segment. Will reset saved states back to zero.
+     */
+    virtual void finalize() const;
+};
+}  // namespace Tensorflow
+
+#endif  // NN_TENSORFLOWFEATURESCORERSTATECARRYOVER_HH
diff --git a/src/Tensorflow/TensorflowForwardNode.cc b/src/Tensorflow/TensorflowForwardNode.cc
index 074d88541..da200ce8a 100644
--- a/src/Tensorflow/TensorflowForwardNode.cc
+++ b/src/Tensorflow/TensorflowForwardNode.cc
@@ -13,6 +13,7 @@
  *  limitations under the License.
  */
 #include "TensorflowForwardNode.hh"
+#include <chrono>
 
 #include <Flow/Vector.hh>
 
@@ -132,9 +133,16 @@ bool TensorflowForwardNode::work(Flow::PortId p) {
             }
         }
 
+        auto t_start = std::chrono::steady_clock::now();
+
         std::vector<Tensor> tf_output;
         session_.run(inputs, output_tensor_names_, {}, tf_output);
 
+        auto   t_end      = std::chrono::steady_clock::now();
+        auto   t_elapsed  = std::chrono::duration_cast<std::chrono::duration<double>>(t_end - t_start).count();
+        size_t num_frames = data[0].size();  // use first input for reporting
+        log("num_frames: %zu elapsed: %f AM_RTF: %f", num_frames, t_elapsed, t_elapsed / (num_frames / 100.0));
+
         for (size_t i = 0ul; i < tf_output.size(); i++) {
             appendToOutput(tf_output[i], start_frame, outputs_[i]);
         }
@@ -247,7 +255,10 @@ Core::ParameterInt TensorflowOverlappingForwardNode::paramMaxBufferSize_(
         "max-buffer-size", "Maximum number of input features to be forwarded in one run.", 1000, 1);
 
 TensorflowOverlappingForwardNode::TensorflowOverlappingForwardNode(Core::Configuration const& c)
-        : Core::Component(c), Precursor(c), contextSize_(paramContextSize_(config)), maxBufferSize_(paramMaxBufferSize_(config)) {
+        : Core::Component(c),
+          Precursor(c),
+          contextSize_(paramContextSize_(config)),
+          maxBufferSize_(paramMaxBufferSize_(config)) {
     require_gt(maxBufferSize_, 2 * contextSize_);
 }
 
diff --git a/src/Tensorflow/TransformerStateManager.cc b/src/Tensorflow/TransformerStateManager.cc
new file mode 100644
index 000000000..03fc39762
--- /dev/null
+++ b/src/Tensorflow/TransformerStateManager.cc
@@ -0,0 +1,109 @@
+#include "TransformerStateManager.hh"
+
+namespace Tensorflow {
+
+const Core::ParameterInt TransformerStateManager::paramContextSize("context-size", "left-context size (in frames)", 100, 0);
+const Core::ParameterInt TransformerStateManager::paramPrefixLength("prefix-length", "left-context to always keep", 0, 0);
+const Core::ParameterInt TransformerStateManager::paramDiscardSuffixLength("discard-suffix-length", "how many frames to drop from the end of the new state (usefull for overlapping chunks)", 0, 0);
+
+TransformerStateManager::TransformerStateManager(Core::Configuration const& config, Graph const& graph, Session& session)
+        : Precursor(config, graph, session),
+          context_size_(paramContextSize(config)),
+          prefix_length_(paramPrefixLength(config)),
+          discard_suffix_length_(paramDiscardSuffixLength(config)) {
+    auto const& var_map = graph.variables();
+    for (std::string const& name : graph.state_vars()) {
+        auto const& var = var_map.find(name)->second;
+        state_fetches_.push_back(var.snapshot_name);
+        state_setters_.push_back(var.initializer_name);
+        state_setter_values_.push_back(var.initial_value_name);
+        for (size_t i = 1; i < var.shape.size(); i++) {
+            if (var.shape[i] == -1) {
+                time_axis_.push_back(i);
+                break;
+            }
+        }
+    }
+}
+
+void TransformerStateManager::setInitialState() {
+    FeedDict   feed_dict;
+    TargetList targets;
+
+    state_.clear();
+
+    auto const& var_map = graph_.variables();
+    for (std::string const& name : graph_.state_vars()) {
+        auto const&        var = var_map.find(name)->second;
+        std::vector<int64> shape(var.shape.begin(), var.shape.end());
+        shape[0] = 1l;  // set batch dim to 1 (assuming dim 0 is batch-dim)
+        for (size_t i = 1ul; i < shape.size(); i++) {
+            if (shape[i] < 0) {
+                shape[i] = 0l;
+            }
+        }
+        feed_dict.emplace_back(std::make_pair(var.initial_value_name, Tensor::zeros<float>(shape)));
+        state_.push_back(feed_dict.back().second);
+        targets.push_back(var.initializer_name);
+    }
+
+    session_.run(feed_dict, targets);
+}
+
+std::vector<std::string> TransformerStateManager::getOutputs() const {
+    return std::vector<std::string>();
+}
+
+std::vector<std::string> TransformerStateManager::getTargets() const {
+    return graph_.update_ops();
+}
+
+void TransformerStateManager::updateState(std::vector<Tensor> const& state_tensors) {
+    // state_tensors is empty as we need to fetch the vars after the first session.run
+    std::vector<Tensor> new_state;
+    session_.run({}, state_fetches_, {}, new_state);
+
+    for (size_t i = 0ul; i < new_state.size(); i++) {
+        auto&     s                = new_state[i];
+        int       time_axis        = time_axis_[i];
+        tf::int64 new_state_length = s.dimSize(time_axis);
+        // prefix_length_-long prefix is part of the context_size_-long context
+        if (new_state_length > context_size_ || discard_suffix_length_ > 0) {
+            std::vector<int> first_start;
+            std::vector<int> first_end;
+            std::vector<int> main_start;
+            std::vector<int> main_end;
+            for (tf::int64 dim = 0; dim < state_[i].numDims(); dim++) {
+                first_start.push_back(0);
+                if (dim == time_axis) {
+                    first_end.push_back((new_state_length - discard_suffix_length_ > context_size_) ? prefix_length_ : 0);
+                    main_start.push_back((new_state_length - discard_suffix_length_ > context_size_) ? new_state_length - discard_suffix_length_ - context_size_ + prefix_length_ : 0);
+                }
+                else {
+                    first_end.push_back(s.dimSize(dim));
+                    main_start.push_back(0);
+                }
+                main_end.push_back(dim == time_axis ? std::max(static_cast<int>(new_state_length) - discard_suffix_length_, 0) : s.dimSize(dim));
+            }
+            Tensor first;
+            if (prefix_length_ > 0) {
+                first = s.slice(first_start, first_end);
+            }
+            s = s.slice(main_start, main_end);
+            if (prefix_length_ > 0) {
+                s = Tensor::concat(first, s, time_axis);
+            }
+        }
+
+        state_[i] = s;
+    }
+
+    require_eq(state_setter_values_.size(), state_.size());
+    FeedDict feed_dict;
+    for (size_t i = 0ul; i < state_setter_values_.size(); i++) {
+        feed_dict.emplace_back(std::make_pair(state_setter_values_[i], state_[i]));
+    }
+    session_.run(feed_dict, state_setters_);
+}
+
+}  // namespace Tensorflow
diff --git a/src/Tensorflow/TransformerStateManager.hh b/src/Tensorflow/TransformerStateManager.hh
new file mode 100644
index 000000000..283db8867
--- /dev/null
+++ b/src/Tensorflow/TransformerStateManager.hh
@@ -0,0 +1,40 @@
+#ifndef _TENSORFLOW_TRANSFORMERSTATEMANAGER_HH
+#define _TENSORFLOW_TRANSFORMERSTATEMANAGER_HH
+
+#include "StateManager.hh"
+
+namespace Tensorflow {
+
+class TransformerStateManager : public StateManager {
+public:
+    using Precursor  = StateManager;
+    using FeedDict   = std::vector<std::pair<std::string, Tensor>>;
+    using TargetList = std::vector<std::string>;
+
+    static const Core::ParameterInt paramContextSize;
+    static const Core::ParameterInt paramPrefixLength;
+    static const Core::ParameterInt paramDiscardSuffixLength;
+
+    TransformerStateManager(Core::Configuration const& config, Graph const& graph, Session& session);
+    virtual ~TransformerStateManager() = default;
+
+    virtual void                     setInitialState();
+    virtual std::vector<std::string> getOutputs() const;
+    virtual std::vector<std::string> getTargets() const;
+    virtual void                     updateState(std::vector<Tensor> const& state_tensors);
+
+private:
+    const int context_size_;
+    const int prefix_length_;
+    const int discard_suffix_length_;
+
+    std::vector<std::string> state_fetches_;
+    std::vector<std::string> state_setters_;
+    std::vector<std::string> state_setter_values_;
+    std::vector<int>         time_axis_;
+    std::vector<Tensor>      state_;
+};
+
+}  // namespace Tensorflow
+
+#endif  // _TENSORFLOW_TRANSFORMERSTATEMANAGER_HH
diff --git a/src/Tensorflow/VanillaGraphLoader.hh b/src/Tensorflow/VanillaGraphLoader.hh
index 18de560b0..062f8c3f7 100644
--- a/src/Tensorflow/VanillaGraphLoader.hh
+++ b/src/Tensorflow/VanillaGraphLoader.hh
@@ -35,7 +35,9 @@ private:
 };
 
 inline VanillaGraphLoader::VanillaGraphLoader(Core::Configuration const& config)
-        : Core::Component(config), VanillaGraphLoader::Precursor(config), file_(paramFile(config)) {
+        : Core::Component(config),
+          VanillaGraphLoader::Precursor(config),
+          file_(paramFile(config)) {
 }
 
 }  // namespace Tensorflow
diff --git a/src/Test/Bliss_SegmentOrdering.cc b/src/Test/Bliss_SegmentOrdering.cc
index c1816b9dd..8ce2f0e20 100644
--- a/src/Test/Bliss_SegmentOrdering.cc
+++ b/src/Test/Bliss_SegmentOrdering.cc
@@ -19,7 +19,8 @@
 class TestCorpusVisitor : public Bliss::CorpusVisitor {
 public:
     TestCorpusVisitor()
-            : lCorpus_(0), lRecording_(0) {}
+            : lCorpus_(0),
+              lRecording_(0) {}
     void enterCorpus(Bliss::Corpus* corpus) {
         ++lCorpus_;
         corpus_.push_back(corpus->fullName());
diff --git a/src/Test/Core_Tbb.cc b/src/Test/Core_Tbb.cc
index afa8d2ebe..d5c7c9700 100644
--- a/src/Test/Core_Tbb.cc
+++ b/src/Test/Core_Tbb.cc
@@ -31,9 +31,11 @@ class Sum {
 
 public:
     Sum(const std::vector<T>& data)
-            : data_(data), sum_(0) {}
+            : data_(data),
+              sum_(0) {}
     Sum(const Sum& o, tbb::split)
-            : data_(o.data_), sum_(0) {}
+            : data_(o.data_),
+              sum_(0) {}
     T result() const {
         return sum_;
     }
@@ -57,7 +59,8 @@ class Plus {
 
 public:
     Plus(T* const data, T inc)
-            : data_(data), increment_(inc) {}
+            : data_(data),
+              increment_(inc) {}
     void operator()(tbb::blocked_range<size_t>& range) const {
         size_t end = range.end();
         for (size_t i = range.begin(); i != end; ++i)
diff --git a/src/Test/Lm_ArpaLm.cc b/src/Test/Lm_ArpaLm.cc
new file mode 100644
index 000000000..d33d2dd23
--- /dev/null
+++ b/src/Test/Lm_ArpaLm.cc
@@ -0,0 +1,37 @@
+#include <Bliss/Lexicon.hh>
+#include <Lm/Module.hh>
+#include <Test/UnitTest.hh>
+
+class TestArpaLm : public Test::Fixture {
+public:
+    void setUp();
+
+protected:
+    Core::Configuration base_lex_config_;
+    Core::Configuration shuffle_lex_config_;
+    Core::Configuration lm_config_;
+    Bliss::LexiconRef   base_lex_;
+    Bliss::LexiconRef   shuffle_lex_;
+};
+
+void TestArpaLm::setUp() {
+    base_lex_config_.set("*.lexicon.file", "data/arpa_lm/base.xml.gz");
+    base_lex_ = Bliss::Lexicon::create(Core::Configuration(base_lex_config_, "lexicon"));
+
+    shuffle_lex_config_.set("*.lexicon.file", "data/arpa_lm/shuffle.xml.gz");
+    shuffle_lex_ = Bliss::Lexicon::create(Core::Configuration(shuffle_lex_config_, "lexicon"));
+
+    lm_config_.set("*.lm.type", "ARPA");
+    lm_config_.set("*.lm.file", "data/arpa_lm/unigram.arpa.gz");
+    lm_config_.set("*.lm.image", "");
+}
+
+TEST_F(Test, TestArpaLm, TestShuffle) {
+    auto m = Lm::Module::instance();
+    lm_config_.set("*.lm.image", "data/arpa_lm/unigram.image");
+    Core::Ref<Lm::LanguageModel> base_lm    = m.createLanguageModel(Core::Configuration(lm_config_, "lm"), base_lex_);
+    Core::Ref<Lm::LanguageModel> shuffle_lm = m.createLanguageModel(Core::Configuration(lm_config_, "lm"), shuffle_lex_);
+
+    Lm::History base_h    = base_lm->startHistory();
+    Lm::History shuffle_h = shuffle_lm->startHistory();
+}
diff --git a/src/Test/Makefile b/src/Test/Makefile
index bf26b77d1..88b769133 100644
--- a/src/Test/Makefile
+++ b/src/Test/Makefile
@@ -21,13 +21,14 @@ TEST_O += $(OBJDIR)/Core_StringUtilities.o
 TEST_O += $(OBJDIR)/Core_Thread.o 
 TEST_O += $(OBJDIR)/Core_ThreadPool.o 
 TEST_O += $(OBJDIR)/Fsa_Sssp4SpecialSymbols.o
+TEST_O += $(OBJDIR)/Lm_ArpaLm.o
 TEST_O += $(OBJDIR)/Math_Utilities.o
 TEST_O += $(OBJDIR)/Math_Blas.o 
 TEST_O += $(OBJDIR)/Math_FastVectorOperations.o 
 TEST_O += $(OBJDIR)/Math_CudaVector.o 
 TEST_O += $(OBJDIR)/Math_CudaMatrix.o 
 TEST_O += $(OBJDIR)/Math_FastMatrix.o 
-#TEST_O += $(OBJDIR)/Math_LinearConjugateGradient.o 
+TEST_O += $(OBJDIR)/Math_LinearConjugateGradient.o
 TEST_O += $(OBJDIR)/Test_File.o 
 TEST_O += $(OBJDIR)/Test_Lexicon.o 
 
@@ -105,6 +106,9 @@ UNIT_TEST_O += ../Tensorflow/libSprintTensorflow.$(a)
 CXXFLAGS += $(TF_CXXFLAGS)
 LDFLAGS  += $(TF_LDFLAGS)
 endif
+ifdef MODULE_ONNX
+UNIT_TEST_O += ../Onnx/libSprintOnnx.$(a)
+endif
 
 # -----------------------------------------------------------------------------
 
diff --git a/src/Test/Nn_LinearAndActivationLayer.cc b/src/Test/Nn_LinearAndActivationLayer.cc
index f7b21088c..f7ffe2d4d 100644
--- a/src/Test/Nn_LinearAndActivationLayer.cc
+++ b/src/Test/Nn_LinearAndActivationLayer.cc
@@ -23,7 +23,9 @@ class LinearAndSigmoidLayer : public Nn::LinearAndSigmoidLayer<T> {
 public:
     using Precursor::setParameters;
     LinearAndSigmoidLayer(const Core::Configuration& c)
-            : Core::Component(c), Nn::NeuralNetworkLayer<T>(c), Precursor(c) {}
+            : Core::Component(c),
+              Nn::NeuralNetworkLayer<T>(c),
+              Precursor(c) {}
 };
 
 template<typename T>
@@ -33,7 +35,9 @@ class LinearAndSoftmaxLayer : public Nn::LinearAndSoftmaxLayer<T> {
 public:
     using Precursor::setParameters;
     LinearAndSoftmaxLayer(const Core::Configuration& c)
-            : Core::Component(c), Nn::NeuralNetworkLayer<T>(c), Precursor(c) {}
+            : Core::Component(c),
+              Nn::NeuralNetworkLayer<T>(c),
+              Precursor(c) {}
 };
 
 class TestLinearAndSigmoidLayer : public Test::ConfigurableFixture {
diff --git a/src/Test/Nn_LinearLayer.cc b/src/Test/Nn_LinearLayer.cc
index d19a93056..8146670b9 100644
--- a/src/Test/Nn_LinearLayer.cc
+++ b/src/Test/Nn_LinearLayer.cc
@@ -26,7 +26,9 @@ class LinearLayer : public Nn::LinearLayer<T> {
 public:
     using Precursor::setParameters;
     LinearLayer(const Core::Configuration& c)
-            : Core::Component(c), Nn::NeuralNetworkLayer<T>(c), Precursor(c) {}
+            : Core::Component(c),
+              Nn::NeuralNetworkLayer<T>(c),
+              Precursor(c) {}
 };
 
 class TestLinearLayer : public Test::ConfigurableFixture {
diff --git a/src/Test/Nn_NeuralNetwork.cc b/src/Test/Nn_NeuralNetwork.cc
index cc0d5b05f..f07c5a351 100644
--- a/src/Test/Nn_NeuralNetwork.cc
+++ b/src/Test/Nn_NeuralNetwork.cc
@@ -24,7 +24,8 @@ class NeuralNetwork : public Nn::NeuralNetwork<T> {
 
 public:
     NeuralNetwork(Core::Configuration& c)
-            : Core::Component(c), Nn::NeuralNetwork<T>(c) {}
+            : Core::Component(c),
+              Nn::NeuralNetwork<T>(c) {}
 };
 
 class TestNeuralNetwork : public Test::ConfigurableFixture {
diff --git a/src/Test/Nn_NeuralNetworkLayer.cc b/src/Test/Nn_NeuralNetworkLayer.cc
index 5d89a6fe3..4adbdee39 100644
--- a/src/Test/Nn_NeuralNetworkLayer.cc
+++ b/src/Test/Nn_NeuralNetworkLayer.cc
@@ -19,7 +19,8 @@
 class NeuralNetworkLayer : public Nn::NeuralNetworkLayer<f64> {
 public:
     NeuralNetworkLayer(const Core::Configuration& config)
-            : Core::Component(config), Nn::NeuralNetworkLayer<f64>(config) {}
+            : Core::Component(config),
+              Nn::NeuralNetworkLayer<f64>(config) {}
     virtual void forward(const std::vector<NnMatrix*>& input, NnMatrix& output) {}
 };
 
diff --git a/src/Test/Test_Lexicon.cc b/src/Test/Test_Lexicon.cc
index 0c0da4611..0787c895d 100644
--- a/src/Test/Test_Lexicon.cc
+++ b/src/Test/Test_Lexicon.cc
@@ -18,44 +18,62 @@
 
 #include <Test/Lexicon.hh>
 #include <Test/UnitTest.hh>
+#include <memory>
+
+#include <Bliss/Fsa.hh>
+#include <Bliss/LexiconParser.hh>
 
 class TestLexicon : public Test::Fixture {
 public:
     void setUp();
 
 protected:
-    Test::Lexicon lexicon_;
+    std::shared_ptr<Test::Lexicon> lexicon_;
 };
 
 void TestLexicon::setUp() {
-    lexicon_.addPhoneme("si", false);
-    lexicon_.addPhoneme("a");
-    lexicon_.addPhoneme("b");
-    lexicon_.addPhoneme("c");
-    lexicon_.addLemma("A", "a");
-    lexicon_.addLemma("[SILENCE]", "si", "silence");
-    lexicon_.addLemma("AC", "a  c");
+    lexicon_ = std::make_shared<Test::Lexicon>();
+    lexicon_->addPhoneme("si", false);
+    lexicon_->addPhoneme("a");
+    lexicon_->addPhoneme("b");
+    lexicon_->addPhoneme("c");
+    lexicon_->addLemma("A", "a");
+    lexicon_->addLemma("[SILENCE]", "si", "silence");
+    lexicon_->addLemma("AC", "a  c");
+    lexicon_->addLemma("CUSTOMWORD", "", "custom_pronunciation");
 }
 
 TEST_F(Test, TestLexicon, AddPhoneme) {
-    EXPECT_NE(lexicon_.phonemeInventory()->phoneme("a"), 0);
-    EXPECT_FALSE(lexicon_.addPhoneme("a"));
+    EXPECT_NE(lexicon_->phonemeInventory()->phoneme("a"), 0);
+    EXPECT_FALSE(lexicon_->addPhoneme("a"));
 }
 
 TEST_F(Test, TestLexicon, SpecialLemma) {
-    EXPECT_NE(lexicon_.specialLemma("silence"), 0);
+    EXPECT_NE(lexicon_->specialLemma("silence"), 0);
+    EXPECT_TRUE(lexicon_->specialLemma("AC") == nullptr);
+    EXPECT_TRUE(lexicon_->specialLemma("xxx") == nullptr);
+}
+
+TEST_F(Test, TestLexicon, SpecialLemmaName) {
+    const Bliss::Lemma* l_regular   = lexicon_->lemma("AC");
+    const Bliss::Lemma* l_spec_sil  = lexicon_->specialLemma("silence");
+    const Bliss::Lemma* l_spec_cust = lexicon_->specialLemma("custom_pronunciation");
+
+    EXPECT_EQ(lexicon_->getSpecialLemmaName(l_regular), std::string(""));
+    EXPECT_EQ(lexicon_->getSpecialLemmaName(l_spec_sil), std::string("silence"));
+    EXPECT_EQ(lexicon_->getSpecialLemmaName(l_spec_cust), std::string("custom_pronunciation"));
 }
 
 TEST_F(Test, TestLexicon, Lemma) {
-    const Bliss::Lemma* l = lexicon_.lemma("AC");
+    const Bliss::Lemma* l = lexicon_->lemma("AC");
     EXPECT_NE(l, 0);
     EXPECT_EQ(std::string(l->preferredOrthographicForm()), std::string("AC"));
     Bliss::Lemma::LemmaPronunciationRange lpr = l->pronunciations();
     EXPECT_NE(lpr.first, lpr.second);
     const Bliss::Pronunciation* pron = lpr.first->pronunciation();
     EXPECT_EQ(pron->length(), u32(2));
-    EXPECT_EQ((*pron)[0], Bliss::Phoneme::Id(lexicon_.phonemeInventory()->phoneme("a")->id()));
-    EXPECT_EQ((*pron)[1], Bliss::Phoneme::Id(lexicon_.phonemeInventory()->phoneme("c")->id()));
+    EXPECT_EQ((*pron)[0], Bliss::Phoneme::Id(lexicon_->phonemeInventory()->phoneme("a")->id()));
+    EXPECT_EQ((*pron)[1], Bliss::Phoneme::Id(lexicon_->phonemeInventory()->phoneme("c")->id()));
     ++lpr.first;
     EXPECT_EQ(lpr.first, lpr.second);
 }
diff --git a/src/Test/data/arpa_lm/base.xml.gz b/src/Test/data/arpa_lm/base.xml.gz
new file mode 100644
index 000000000..8cfcd70f4
Binary files /dev/null and b/src/Test/data/arpa_lm/base.xml.gz differ
diff --git a/src/Test/data/arpa_lm/lm_data b/src/Test/data/arpa_lm/lm_data
new file mode 100644
index 000000000..600047734
--- /dev/null
+++ b/src/Test/data/arpa_lm/lm_data
@@ -0,0 +1,7 @@
+ABA ABA ABA ABA ABA ABA
+AAA AAA AAA AAA AAA
+ABC ABC ABC ABC
+BBC BBC BBC
+BBA
+BBA
+CC
diff --git a/src/Test/data/arpa_lm/shuffle.xml.gz b/src/Test/data/arpa_lm/shuffle.xml.gz
new file mode 100644
index 000000000..897c50cc5
Binary files /dev/null and b/src/Test/data/arpa_lm/shuffle.xml.gz differ
diff --git a/src/Test/data/arpa_lm/unigram.arpa.gz b/src/Test/data/arpa_lm/unigram.arpa.gz
new file mode 100644
index 000000000..c4fdada7f
Binary files /dev/null and b/src/Test/data/arpa_lm/unigram.arpa.gz differ
diff --git a/src/Test/data/arpa_lm/unigram.image b/src/Test/data/arpa_lm/unigram.image
new file mode 100644
index 000000000..3a88ed790
Binary files /dev/null and b/src/Test/data/arpa_lm/unigram.image differ
diff --git a/src/Tools/AcousticModelTrainer/AcousticModelTrainer.cc b/src/Tools/AcousticModelTrainer/AcousticModelTrainer.cc
index 9d81d7d5c..2e8849289 100644
--- a/src/Tools/AcousticModelTrainer/AcousticModelTrainer.cc
+++ b/src/Tools/AcousticModelTrainer/AcousticModelTrainer.cc
@@ -15,36 +15,36 @@
 #include "AcousticModelTrainer.hh"
 #include <Am/Module.hh>
 #include <Audio/Module.hh>
+#ifdef MODULE_CART
+#include <Cart/Cluster.hh>
+#include <Cart/DecisionTree.hh>
+#include <Cart/Example.hh>
+#include <Cart/Parser.hh>
+#include <Speech/DecisionTreeTrainer.hh>
+#endif
 #include <Flow/Module.hh>
 #include <Lm/Module.hh>
 #include <Math/Module.hh>
 #include <Mm/Module.hh>
-#include <Signal/Module.hh>
-#include <Speech/AverageFeatureScorerActivation.hh>
-#include <Speech/Module.hh>
 #ifdef MODULE_NN
 #include <Nn/Module.hh>
 #endif
 #ifdef MODULE_ONNX
 #include <Onnx/Module.hh>
 #endif
+#include <Signal/Module.hh>
 #include <Speech/AcousticModelTrainer.hh>
 #include <Speech/AlignerModelAcceptor.hh>
 #include <Speech/AligningFeatureExtractor.hh>
+#include <Speech/AverageFeatureScorerActivation.hh>
 #include <Speech/FeatureScorer.hh>
 #include <Speech/LabelingFeatureExtractor.hh>
 #include <Speech/LatticeSetExtractor.hh>
 #include <Speech/LatticeSetProcessor.hh>
 #include <Speech/MixtureSetTrainer.hh>
+#include <Speech/Module.hh>
 #include <Speech/ScatterMatricesEstimator.hh>
 #include <Speech/TextIndependentMixtureSetTrainer.hh>
-#ifdef MODULE_CART
-#include <Cart/Cluster.hh>
-#include <Cart/DecisionTree.hh>
-#include <Cart/Example.hh>
-#include <Cart/Parser.hh>
-#include <Speech/DecisionTreeTrainer.hh>
-#endif
 #ifdef MODULE_SPEECH_DT_ADVANCED
 #include <Speech/ClusterMixtureSetTrainer.hh>
 #endif
diff --git a/src/Tools/AcousticModelTrainer/Makefile b/src/Tools/AcousticModelTrainer/Makefile
index a940a07b0..2004c19f9 100644
--- a/src/Tools/AcousticModelTrainer/Makefile
+++ b/src/Tools/AcousticModelTrainer/Makefile
@@ -61,7 +61,10 @@ endif
 ifdef MODULE_TENSORFLOW
 ACOUSTIC_MODEL_TRAINER_O += ../../Tensorflow/libSprintTensorflow.$(a)
 CXXFLAGS += $(TF_CXXFLAGS)
-LDFLAGS  += $(TF_LDFLAGS)
+LDFLAGS  := $(TF_LDFLAGS) $(LDFLAGS)
+endif
+ifdef MODULE_LM_ONNX
+ACOUSTIC_MODEL_TRAINER_O += ../../Onnx/libSprintOnnx.$(a)
 endif
 
 # -----------------------------------------------------------------------------
diff --git a/src/Tools/Aligner/Aligner.cc b/src/Tools/Aligner/Aligner.cc
index 0cfacb3a6..d0cd097fc 100644
--- a/src/Tools/Aligner/Aligner.cc
+++ b/src/Tools/Aligner/Aligner.cc
@@ -88,7 +88,17 @@ std::string Aligner::getUsage() const {
 }
 
 Aligner::Aligner()
-        : order_(0), reordering_(0), perplexity_(0.0), userTime_(0.0), sentences_(0), oovs_(0), words_(0), arcs_(0), maxMemory_(0), segmentStart_(0), segmentEnd_(0) {
+        : order_(0),
+          reordering_(0),
+          perplexity_(0.0),
+          userTime_(0.0),
+          sentences_(0),
+          oovs_(0),
+          words_(0),
+          arcs_(0),
+          maxMemory_(0),
+          segmentStart_(0),
+          segmentEnd_(0) {
     setTitle("aligner");
     setDefaultLoadConfigurationFile(false);
     setDefaultOutputXmlHeader(false);
diff --git a/src/Tools/Aligner/ConditionalAlignAutomaton.hh b/src/Tools/Aligner/ConditionalAlignAutomaton.hh
index 610b1908e..fe62d9234 100644
--- a/src/Tools/Aligner/ConditionalAlignAutomaton.hh
+++ b/src/Tools/Aligner/ConditionalAlignAutomaton.hh
@@ -20,9 +20,11 @@
 namespace Fsa {
 class ConditionalAlignAutomaton : public AlignAutomaton {
 private:
-    typedef enum { diagonal   = 0,
-                   horizontal = 1,
-                   vertical   = 2 } Transitions;
+    typedef enum {
+        diagonal   = 0,
+        horizontal = 1,
+        vertical   = 2
+    } Transitions;
     Translation::ConstConditionalLexiconRef lexicon_;
     u32                                     I;
     u32                                     J;
diff --git a/src/Tools/Aligner/FirstOrderAlignAutomaton.hh b/src/Tools/Aligner/FirstOrderAlignAutomaton.hh
index adf9f2238..9d4cbafcd 100644
--- a/src/Tools/Aligner/FirstOrderAlignAutomaton.hh
+++ b/src/Tools/Aligner/FirstOrderAlignAutomaton.hh
@@ -20,9 +20,11 @@
 namespace Fsa {
 class FirstOrderAlignAutomaton : public AlignAutomaton {
 private:
-    typedef enum { diagonal   = 0,
-                   horizontal = 1,
-                   vertical   = 2 } Transitions;
+    typedef enum {
+        diagonal   = 0,
+        horizontal = 1,
+        vertical   = 2
+    } Transitions;
     const TranslationLexicon* lexicon_;
     const TranslationLexicon* horizontal_lexicon_;
     const TranslationLexicon* vertical_lexicon_;
diff --git a/src/Tools/Aligner/NBestReordering.hh b/src/Tools/Aligner/NBestReordering.hh
index 77ae0708b..5d3381512 100644
--- a/src/Tools/Aligner/NBestReordering.hh
+++ b/src/Tools/Aligner/NBestReordering.hh
@@ -29,7 +29,12 @@ private:
 
 public:
     nBestAutomaton(const std::string& source, const std::string& target, const TranslationLexicon* lex)
-            : source_(Core::split(source, " ")), target_(Core::split(target, " ")), inputSentence_(), outputSentence_(), lexicon_(lex), state_(new State) {
+            : source_(Core::split(source, " ")),
+              target_(Core::split(target, " ")),
+              inputSentence_(),
+              outputSentence_(),
+              lexicon_(lex),
+              state_(new State) {
         std::vector<std::string> numberedSource = numberTokensVector(source_);
         StaticAlphabet*          ia             = new StaticAlphabet();
         for (std::vector<std::string>::const_iterator i = numberedSource.begin(); i != numberedSource.end(); ++i) {
diff --git a/src/Tools/Aligner/PooledFirstOrderAlignAutomaton.hh b/src/Tools/Aligner/PooledFirstOrderAlignAutomaton.hh
index bb5406462..69ab38992 100644
--- a/src/Tools/Aligner/PooledFirstOrderAlignAutomaton.hh
+++ b/src/Tools/Aligner/PooledFirstOrderAlignAutomaton.hh
@@ -22,9 +22,11 @@ namespace Fsa {
 
 class PooledFirstOrderAlignAutomaton : public AlignAutomaton {
 private:
-    typedef enum { diagonal   = 0,
-                   horizontal = 1,
-                   vertical   = 2 } Transitions;
+    typedef enum {
+        diagonal   = 0,
+        horizontal = 1,
+        vertical   = 2
+    } Transitions;
     Translation::ConstConditionalLexiconRef lexicon_;
     u32                                     I;
     u32                                     J;
diff --git a/src/Tools/Aligner/SimpleAlignAutomaton.hh b/src/Tools/Aligner/SimpleAlignAutomaton.hh
index e0de59b35..838e8b6f3 100644
--- a/src/Tools/Aligner/SimpleAlignAutomaton.hh
+++ b/src/Tools/Aligner/SimpleAlignAutomaton.hh
@@ -81,10 +81,13 @@ public:
                          const double                            factorLexicon    = 1.0,
                          const double                            factorTransition = 1.0,
                          const unsigned                          order            = 0);
+
     virtual ConstStateRef getState(StateId s) const;
-    virtual Fsa::StateId  initialStateId() const {
+
+    virtual Fsa::StateId initialStateId() const {
         return Fsa::StateId(0);
     };
+
     virtual std::string describe() const {
         return std::string("SimpleAlignAutomaton()");
     }
diff --git a/src/Tools/Aligner/ZeroOrderAlignAutomaton.hh b/src/Tools/Aligner/ZeroOrderAlignAutomaton.hh
index 352982bfd..d460f7805 100644
--- a/src/Tools/Aligner/ZeroOrderAlignAutomaton.hh
+++ b/src/Tools/Aligner/ZeroOrderAlignAutomaton.hh
@@ -21,14 +21,18 @@
 namespace Fsa {
 class ZeroOrderAlignAutomaton : public AlignAutomaton {
 private:
-    typedef enum { diagonal   = 0,
-                   horizontal = 1,
-                   vertical   = 2 } Transitions;
+    typedef enum {
+        diagonal   = 0,
+        horizontal = 1,
+        vertical   = 2
+    } Transitions;
+
     Translation::ConstConditionalLexiconRef lexicon_;
-    u32                                     I;
-    u32                                     J;
-    u32                                     M;
-    u32                                     maxIndex;
+
+    u32 I;
+    u32 J;
+    u32 M;
+    u32 maxIndex;
 
 public:
     ZeroOrderAlignAutomaton(Core::Configuration&                    config,
@@ -40,7 +44,8 @@ public:
                             const double                            factorTransition = 1.0);
 
     virtual ConstStateRef getState(StateId s) const;
-    virtual std::string   describe() const {
+
+    virtual std::string describe() const {
         return std::string("zeroOrderAlignAutomaton()");
     }
 };
diff --git a/src/Tools/Aligner/ZeroOrderNoEmptyAlignAutomaton.hh b/src/Tools/Aligner/ZeroOrderNoEmptyAlignAutomaton.hh
index 65d85c325..651658e5b 100644
--- a/src/Tools/Aligner/ZeroOrderNoEmptyAlignAutomaton.hh
+++ b/src/Tools/Aligner/ZeroOrderNoEmptyAlignAutomaton.hh
@@ -20,9 +20,11 @@
 namespace Fsa {
 class ZeroOrderNoEmptyAlignAutomaton : public AlignAutomaton {
 private:
-    typedef enum { diagonal   = 0,
-                   horizontal = 1,
-                   vertical   = 2 } Transitions;
+    typedef enum {
+        diagonal   = 0,
+        horizontal = 1,
+        vertical   = 2
+    } Transitions;
     const TranslationLexicon* lexicon_;
     u32                       I;
     u32                       J;
diff --git a/src/Tools/Aligner/ZeroOrderSimpleAlignAutomaton.hh b/src/Tools/Aligner/ZeroOrderSimpleAlignAutomaton.hh
index 05a8f0e73..cbbb86e6b 100644
--- a/src/Tools/Aligner/ZeroOrderSimpleAlignAutomaton.hh
+++ b/src/Tools/Aligner/ZeroOrderSimpleAlignAutomaton.hh
@@ -34,7 +34,8 @@ public:
                                   const TranslationLexicon* lex,
                                   const double              factorLexicon = 1.0);
     virtual ConstStateRef getState(StateId s) const;
-    virtual std::string   describe() const {
+
+    virtual std::string describe() const {
         return std::string("zeroOrderSimpleAlignAutomaton()");
     }
 };
diff --git a/src/Tools/Archiver/Archiver.cc b/src/Tools/Archiver/Archiver.cc
index ed3efe9de..5f9e09b30 100644
--- a/src/Tools/Archiver/Archiver.cc
+++ b/src/Tools/Archiver/Archiver.cc
@@ -38,15 +38,17 @@
 using namespace Core;
 using Core::select2nd;
 
-enum Mode { Add,
-            Combine,
-            Copy,
-            Extract,
-            ExtractAll,
-            List,
-            Recover,
-            Remove,
-            Show };
+enum Mode {
+    Add,
+    Combine,
+    Copy,
+    Extract,
+    ExtractAll,
+    List,
+    Recover,
+    Remove,
+    Show
+};
 static const Choice modeChoice_(
         "add", Add,
         "combine", Combine,
@@ -58,11 +60,13 @@ static const Choice modeChoice_(
         "remove", Remove,
         "show", Show,
         Choice::endMark());
-enum FileType { Ascii,
-                Feat,
-                Align,
-                BinMatrix,
-                FlowCache };
+enum FileType {
+    Ascii,
+    Feat,
+    Align,
+    BinMatrix,
+    FlowCache
+};
 static const Choice typeChoice_(
         "ascii", Ascii,
         "feat", Feat,
@@ -78,6 +82,7 @@ static const ParameterBool   p_quiet_("quiet", "less output", false);
 static const ParameterChoice p_type_("type", &typeChoice_, "file type to serialize", Feat);
 static const ParameterBool   p_full_prec("full-precision", "output with full precision", false);
 static const ParameterString p_allophones_("allophone-file", "allophone file for serialization of alignments", "");
+static const ParameterString p_lut_("lut", "state tying lookup table file for serialization of alignments", "");
 
 enum OverwriteMode {
     overwriteKeepFirst,
@@ -111,15 +116,16 @@ typedef std::vector<std::string>                  StringVector;
 
 class ArchiverApplication : public Core::Application {
 private:
-    Mode                     mode_;
-    bool                     verbose_;
-    bool                     quiet_;
-    bool                     compress_;
-    FileType                 type_;
-    bool                     fullPrecision_;
-    std::vector<std::string> allophones_;
-    OverwriteMode            overwrite_;
-    std::string              prefix_;
+    Mode                       mode_;
+    bool                       verbose_;
+    bool                       quiet_;
+    bool                       compress_;
+    FileType                   type_;
+    bool                       fullPrecision_;
+    std::vector<std::string>   allophones_;
+    std::map<std::string, u32> state_tying_lut_;
+    OverwriteMode              overwrite_;
+    std::string                prefix_;
 
 private:
     std::string getUsage() const {
@@ -158,7 +164,11 @@ class ArchiverApplication : public Core::Application {
 
 public:
     ArchiverApplication()
-            : mode_(List), verbose_(false), compress_(false), type_(Feat), fullPrecision_(false) {
+            : mode_(List),
+              verbose_(false),
+              compress_(false),
+              type_(Feat),
+              fullPrecision_(false) {
         setTitle("archiver");
         setDefaultLoadConfigurationFile(false);
     }
@@ -308,7 +318,7 @@ class ArchiverApplication : public Core::Application {
                         std::cout << i.name() << ": could not add file to archive" << std::endl;
                 }
                 else
-                    error("could not open file '%s' in archive %s for reading", i.name().c_str(), name.c_str());
+                    error("could not open file '%s' in archive %s for reading", i.name().c_str(), a->path().c_str());
             }
             delete src;
         }
@@ -318,7 +328,7 @@ class ArchiverApplication : public Core::Application {
     bool extractFile(Archive* a, const std::string& name, const std::string outputName = "") {
         Core::ArchiveReader src(*a, name);
         if (!src.isOpen())
-            error("could not open file '%s' in archive %s for reading", name.c_str(), name.c_str());
+            error("could not open file '%s' in archive %s for reading", name.c_str(), a->path().c_str());
         respondToDelayedErrors();
         std::string targetName = (outputName.empty() ? name : outputName);
         if (targetName.size() > 3 && targetName.substr(targetName.size() - 3) == ".gz")
@@ -434,6 +444,10 @@ class ArchiverApplication : public Core::Application {
                         std::cout << "\tallophone=\t" << allophones_[allo] << "\t"
                                   << "index=\t" << allo << "\t"
                                   << "state=\t" << state;
+                        if (state_tying_lut_.size() > 0) {
+                            std::string sym = Core::form("%s.%d", allophones_[allo].c_str(), state);
+                            std::cout << "\ttied=\t" << state_tying_lut_[sym] << "\t";
+                        }
                     }
                     std::cout << ((i->weight != 1.0) ? Core::form("\tweight\t= %f", i->weight) : "")
                               << std::endl;
@@ -543,6 +557,19 @@ class ArchiverApplication : public Core::Application {
                 allophones_.push_back(buf);
             }
         }
+        std::string lut_file = p_lut_(config);
+        if (lut_file != "") {
+            std::ifstream is(lut_file.c_str());
+            std::string   buf;
+            while (Core::getline(is, buf) != EOF) {
+                if ((buf.size() == 0) || (buf.at(0) == '#'))
+                    continue;
+                Core::normalizeWhitespace(buf);
+                Core::suppressTrailingBlank(buf);
+                std::vector<std::string> fields = Core::split(buf, " ");
+                state_tying_lut_[fields[0]]     = atoi(fields[1].c_str());
+            }
+        }
 
         overwrite_ = OverwriteMode(paramOverwrite(config));
         prefix_    = paramPrefix(config);
diff --git a/src/Tools/Archiver/Makefile b/src/Tools/Archiver/Makefile
index a9a8e13d5..6200ad5fd 100644
--- a/src/Tools/Archiver/Makefile
+++ b/src/Tools/Archiver/Makefile
@@ -46,6 +46,9 @@ ARCHIVER_O += ../../Tensorflow/libSprintTensorflow.$(a)
 CXXFLAGS += $(TF_CXXFLAGS)
 LDFLAGS  += $(TF_LDFLAGS)
 endif
+ifdef MODULE_LM_ONNX
+ARCHIVER_O += ../../Onnx/libSprintOnnx.$(a)
+endif
 
 # -----------------------------------------------------------------------------
 
diff --git a/src/Tools/Bliss/corpus.py b/src/Tools/Bliss/corpus.py
index f79135695..a973584cf 100644
--- a/src/Tools/Bliss/corpus.py
+++ b/src/Tools/Bliss/corpus.py
@@ -6,17 +6,17 @@
 
 class NamedCorpusEntity(object):
     def __init__(self):
-	self.parent = None
-	self.name = None
+        self.parent = None
+        self.name = None
 
     def setName(self, name):
-	self.name = name
+        self.name = name
 
     def getFullName(self):
-	if self.parent:
-	    return self.parent.fullName + '/' + self.name
-	else:
-	    return self.name
+        if self.parent:
+            return self.parent.fullName + '/' + self.name
+        else:
+            return self.name
     fullName = property(getFullName)
 
 class Speaker(NamedCorpusEntity):
@@ -27,25 +27,25 @@ class AcousticCondition(NamedCorpusEntity):
 
 class ParentEntity(NamedCorpusEntity):
     def __init__(self):
-	super(ParentEntity, self).__init__()
-	self.childrensNames = set()
+        super(ParentEntity, self).__init__()
+        self.childrensNames = set()
 
     def isNameReserved(self, name):
-	return name in self.childrensNames
+        return name in self.childrensNames
 
     def reserveName(self, name):
-	self.childrensNames.add(name)
+        self.childrensNames.add(name)
 
 class CorpusSection(ParentEntity):
     def __init__(self, parent):
-	super(CorpusSection, self).__init__()
-	self.parent = parent
-	if parent:
-	    self.level = parent.level + 1
-	else:
-	    self.level = 0
-	self.speakers = {}
-	self.conditions = {}
+        super(CorpusSection, self).__init__()
+        self.parent = parent
+        if parent:
+            self.level = parent.level + 1
+        else:
+            self.level = 0
+        self.speakers = {}
+        self.conditions = {}
 
 class Corpus(CorpusSection):
     pass
@@ -69,218 +69,218 @@ def visitSegment(self, segment): pass
 
 class OrthographyElement(XmlMixedElement):
     def __init__(self, handler):
-	super(OrthographyElement, self).__init__('orth')
-	self.flattenUnknownElements()
-	self.handler = handler
+        super(OrthographyElement, self).__init__('orth')
+        self.flattenUnknownElements()
+        self.handler = handler
 
     def start(self, atts):
-	self.data = []
+        self.data = []
 
     def characters(self, data):
-	self.data.append(data)
+        self.data.append(data)
 
     def end(self):
-	orth = ' '.join((''.join(self.data)).split())
-	self.handler(orth)
+        orth = ' '.join((''.join(self.data)).split())
+        self.handler(orth)
 
 
 class CorpusDescriptionParser(XmlSchemaParser):
     visitor = None
 
     def __init__(self, description):
-	super(CorpusDescriptionParser, self).__init__()
-	self.initSchema()
-	self.description = description
-	self.isSubParser = False
-	self.superCorpus = None
+        super(CorpusDescriptionParser, self).__init__()
+        self.initSchema()
+        self.description = description
+        self.isSubParser = False
+        self.superCorpus = None
 
     def initSchema(self):
-	speakerDesc = XmlIgnoreElement('speaker-description')
-	conditionDesc = XmlIgnoreElement('condition-description')
-
-	orth = OrthographyElement(self.setOrth)
-	orth.flattenUnknownElements()
-
-	segment = XmlRegularElement(
-	    'segment',
-	    self.startSegment, self.endSegment)
-	segment.addTransition(segment.initial, segment.initial, orth)
-	segment.addFinalState(segment.initial)
-	segment.ignoreUnknownElements()
-
-	recording = XmlRegularElement(
-	    'recording',
-	    self.startRecording, self.endRecording)
-	recording.addTransition(recording.initial, recording.initial, segment)
-	recording.addFinalState(recording.initial)
-	recording.ignoreUnknownElements()
-
-	include = XmlEmptyElement('include', self.include)
-
-	# should use XmlRegularElement, but cannot due to nesting restriction
-	subcorpus = XmlMixedElement(
-	    "subcorpus", self.startSubcorpus, self.endSubcorpus)
-	subcorpus.addChild(subcorpus)
-	subcorpus.addChild(include)
-	subcorpus.addChild(speakerDesc)
-	subcorpus.addChild(conditionDesc)
-	subcorpus.addChild(recording)
-	subcorpus.ignoreUnknownElements()
-
-	corpus = XmlRegularElement(
-	    'corpus', self.startCorpus, self.endCorpus)
-	corpus.addTransition(corpus.initial, corpus.initial, subcorpus)
-	corpus.addTransition(corpus.initial, corpus.initial, include)
-	corpus.addTransition(corpus.initial, corpus.initial, speakerDesc)
-	corpus.addTransition(corpus.initial, corpus.initial, conditionDesc)
-	corpus.addTransition(corpus.initial, corpus.initial, recording)
-	corpus.addFinalState(corpus.initial)
-	corpus.ignoreUnknownElements()
-
-	self.setRoot(corpus)
+        speakerDesc = XmlIgnoreElement('speaker-description')
+        conditionDesc = XmlIgnoreElement('condition-description')
+
+        orth = OrthographyElement(self.setOrth)
+        orth.flattenUnknownElements()
+
+        segment = XmlRegularElement(
+            'segment',
+            self.startSegment, self.endSegment)
+        segment.addTransition(segment.initial, segment.initial, orth)
+        segment.addFinalState(segment.initial)
+        segment.ignoreUnknownElements()
+
+        recording = XmlRegularElement(
+            'recording',
+            self.startRecording, self.endRecording)
+        recording.addTransition(recording.initial, recording.initial, segment)
+        recording.addFinalState(recording.initial)
+        recording.ignoreUnknownElements()
+
+        include = XmlEmptyElement('include', self.include)
+
+        # should use XmlRegularElement, but cannot due to nesting restriction
+        subcorpus = XmlMixedElement(
+            "subcorpus", self.startSubcorpus, self.endSubcorpus)
+        subcorpus.addChild(subcorpus)
+        subcorpus.addChild(include)
+        subcorpus.addChild(speakerDesc)
+        subcorpus.addChild(conditionDesc)
+        subcorpus.addChild(recording)
+        subcorpus.ignoreUnknownElements()
+
+        corpus = XmlRegularElement(
+            'corpus', self.startCorpus, self.endCorpus)
+        corpus.addTransition(corpus.initial, corpus.initial, subcorpus)
+        corpus.addTransition(corpus.initial, corpus.initial, include)
+        corpus.addTransition(corpus.initial, corpus.initial, speakerDesc)
+        corpus.addTransition(corpus.initial, corpus.initial, conditionDesc)
+        corpus.addTransition(corpus.initial, corpus.initial, recording)
+        corpus.addFinalState(corpus.initial)
+        corpus.ignoreUnknownElements()
+
+        self.setRoot(corpus)
 
     def includeFile(self, relativeFilename):
-	filename = os.path.join(self.corpusDir, relativeFilename)
-	subParser = CorpusDescriptionParser(self.description)
-	subParser.isSubParser = True
-	subParser.corpus = self.corpus
-	subParser.accept(filename, self.visitor)
+        filename = os.path.join(self.corpusDir, relativeFilename)
+        subParser = CorpusDescriptionParser(self.description)
+        subParser.isSubParser = True
+        subParser.corpus = self.corpus
+        subParser.accept(filename, self.visitor)
 
     def include(self, atts):
-	corpus = atts.get('file')
-	if corpus:
-	    self.includeFile(corpus)
-	else:
-	    self.error("attribute \"file\" missing in \"include\" tag")
-	    return
+        corpus = atts.get('file')
+        if corpus:
+            self.includeFile(corpus)
+        else:
+            self.error("attribute \"file\" missing in \"include\" tag")
+            return
 
     def startCorpus(self, atts):
-	name = atts.get('name')
-	if not name:
-	    error("attribute 'name' missing in 'corpus' tag")
-	    return
-	if self.isSubParser:
-	    if name != self.corpus.name:
-		warning('name mismatch on included corpus: "%s" instead of "%s"' % (
-		    name, self.corpus.name))
-		return
-	else:
-	    assert not self.superCorpus
-	    self.corpus = Corpus(None)
-	    self.corpus.name = name
-	    if self.visitor:
-		self.visitor.enterCorpus(self.corpus)
-	self.currentSection = self.corpus
+        name = atts.get('name')
+        if not name:
+            self.error("attribute 'name' missing in 'corpus' tag")
+            return
+        if self.isSubParser:
+            if name != self.corpus.name:
+                self.warning('name mismatch on included corpus: "%s" instead of "%s"' % (
+                    name, self.corpus.name))
+                return
+        else:
+            assert not self.superCorpus
+            self.corpus = Corpus(None)
+            self.corpus.name = name
+            if self.visitor:
+                self.visitor.enterCorpus(self.corpus)
+        self.currentSection = self.corpus
 
     def startSubcorpus(self, atts):
-	name = atts.get('name')
-	if not name:
-	    error("attribute 'name' missing in 'subcorpus' tag")
-	    return
-	self.superCorpus = self.corpus
-	self.corpus = Corpus(self.superCorpus)
-	if self.superCorpus.isNameReserved(name):
-	    error('subcorpus "%s" already defined in the section' % name)
-	else:
-	    self.superCorpus.reserveName(name)
-	    self.corpus.name = name
-	self.currentSection = self.corpus
-	if self.visitor:
-	    self.visitor.enterCorpus(self.corpus)
+        name = atts.get('name')
+        if not name:
+            self.error("attribute 'name' missing in 'subcorpus' tag")
+            return
+        self.superCorpus = self.corpus
+        self.corpus = Corpus(self.superCorpus)
+        if self.superCorpus.isNameReserved(name):
+            self.error('subcorpus "%s" already defined in the section' % name)
+        else:
+            self.superCorpus.reserveName(name)
+            self.corpus.name = name
+        self.currentSection = self.corpus
+        if self.visitor:
+            self.visitor.enterCorpus(self.corpus)
 
     def startRecording(self, atts):
-	name = atts.get('name')
-	audio = atts.get('audio')
-
-	self.recording = Recording(self.corpus)
-
-	if not name:
-	    self.error('attribute "name" missing in "recording" tag')
-	else:
-	    if self.corpus.isNameReserved(name):
-		self.error('recording "%s" already defined in the section' % name)
-	    else:
-		self.corpus.reserveName(name)
-		self.recording.name = name
-	if not audio:
-	    self.error('attribute "audio" missing in "recording" tag')
-	else:
-	    audioFilename = os.path.join(self.description.audioDir, audio)
-	    self.recording.audio = audioFilename
-	self.currentSection = self.recording
-	self.segmentNum = 0
-	if self.visitor:
-	    self.visitor.enterRecording(self.recording)
+        name = atts.get('name')
+        audio = atts.get('audio')
+
+        self.recording = Recording(self.corpus)
+
+        if not name:
+            self.error('attribute "name" missing in "recording" tag')
+        else:
+            if self.corpus.isNameReserved(name):
+                self.error('recording "%s" already defined in the section' % name)
+            else:
+                self.corpus.reserveName(name)
+                self.recording.name = name
+        if not audio:
+            self.error('attribute "audio" missing in "recording" tag')
+        else:
+            audioFilename = os.path.join(self.description.audioDir, audio)
+            self.recording.audio = audioFilename
+        self.currentSection = self.recording
+        self.segmentNum = 0
+        if self.visitor:
+            self.visitor.enterRecording(self.recording)
 
     def startSegment(self, atts):
-	assert self.recording
-
-	name = atts.get('name')
-	self.segment = Segment(self.recording)
-	self.segmentNum += 1
-	if name:
-	    if self.recording.isNameReserved(name):
-		self.error('segment "%s" already defined in the section' % name)
-	    else:
-		self.recording.reserveName(name)
-		self.segment.setName(name)
-	else:
-	    autoName = "%d" % self.segmentNum
-	    while self.recording.isNameReserved(autoName):
-		autoName += "+"
-	    self.recording.reserveName(autoName)
-	    self.segment.name = autoName
-	self.segment.startTime = atts.get('start')
-	self.segment.endTime = atts.get('end')
+        assert self.recording
+
+        name = atts.get('name')
+        self.segment = Segment(self.recording)
+        self.segmentNum += 1
+        if name:
+            if self.recording.isNameReserved(name):
+                self.error('segment "%s" already defined in the section' % name)
+            else:
+                self.recording.reserveName(name)
+                self.segment.setName(name)
+        else:
+            autoName = "%d" % self.segmentNum
+            while self.recording.isNameReserved(autoName):
+                autoName += "+"
+            self.recording.reserveName(autoName)
+            self.segment.name = autoName
+        self.segment.startTime = atts.get('start')
+        self.segment.endTime = atts.get('end')
 
     def setOrth(self, orth):
-	assert self.segment
-	if self.description.shallCaptializeTranscriptions:
-	    orth = orth.upper()
-	self.segment.orth = orth
+        assert self.segment
+        if self.description.shallCaptializeTranscriptions:
+            orth = orth.upper()
+        self.segment.orth = orth
 
     def endSegment(self):
-	if self.visitor:
-	    self.visitor.visitSegment(self.segment)
-	self.segment = None
+        if self.visitor:
+            self.visitor.visitSegment(self.segment)
+        self.segment = None
 
     def endRecording(self):
-	if self.visitor:
-	    self.visitor.leaveRecording(self.recording)
-	self.recording = None
-	self.currentSection = self.corpus
+        if self.visitor:
+            self.visitor.leaveRecording(self.recording)
+        self.recording = None
+        self.currentSection = self.corpus
 
     def endSubcorpus(self):
-	if self.visitor:
-	    self.visitor.leaveCorpus(self.corpus)
-	assert self.superCorpus
-	self.corpus = self.superCorpus
-	self.superCorpus = self.corpus.parent
-	self.currentSection = self.corpus
+        if self.visitor:
+            self.visitor.leaveCorpus(self.corpus)
+        assert self.superCorpus
+        self.corpus = self.superCorpus
+        self.superCorpus = self.corpus.parent
+        self.currentSection = self.corpus
 
     def endCorpus(self):
-	if not self.isSubParser:
-	    assert not self.superCorpus
-	    if self.visitor:
-		self.visitor.leaveCorpus(self.corpus)
-	    self.corpus = None
-	    self.currentSection = None
+        if not self.isSubParser:
+            assert not self.superCorpus
+            if self.visitor:
+                self.visitor.leaveCorpus(self.corpus)
+            self.corpus = None
+            self.currentSection = None
 
     def accept(self, filename, visitor):
-	self.visitor = visitor
-	self.corpusDir = os.path.dirname(filename)
-	self.parse(zopen(filename).read())
-	self.visitor = None
+        self.visitor = visitor
+        self.corpusDir = os.path.dirname(filename)
+        self.parse(zopen(filename).read())
+        self.visitor = None
 
 
 from miscLib import zopen
 
 class CorpusDescription:
     def __init__(self, filename):
-	self.filename = filename
-	self.audioDir = ''
-	self.shallCaptializeTranscriptions = False
+        self.filename = filename
+        self.audioDir = ''
+        self.shallCaptializeTranscriptions = False
 
     def accept(self, visitor):
-	parser = CorpusDescriptionParser(self)
-	parser.accept(self.filename, visitor)
+        parser = CorpusDescriptionParser(self)
+        parser.accept(self.filename, visitor)
diff --git a/src/Tools/CorpusStatistics/Makefile b/src/Tools/CorpusStatistics/Makefile
index b4579a286..297239e5b 100644
--- a/src/Tools/CorpusStatistics/Makefile
+++ b/src/Tools/CorpusStatistics/Makefile
@@ -48,6 +48,9 @@ CORPUS_STATISTICS_O += ../../Tensorflow/libSprintTensorflow.$(a)
 CXXFLAGS += $(TF_CXXFLAGS)
 LDFLAGS  += $(TF_LDFLAGS)
 endif
+ifdef MODULE_LM_ONNX
+CORPUS_STATISTICS_O += ../../Onnx/libSprintOnnx.$(a)
+endif
 
 # -----------------------------------------------------------------------------
 
diff --git a/src/Tools/FeatureExtraction/FeatureExtraction.cc b/src/Tools/FeatureExtraction/FeatureExtraction.cc
index c648bd79f..b11148d65 100644
--- a/src/Tools/FeatureExtraction/FeatureExtraction.cc
+++ b/src/Tools/FeatureExtraction/FeatureExtraction.cc
@@ -34,9 +34,11 @@
 
 class ExtractionApplication : public Core::Application {
 private:
-    enum Format { noFormat,
-                  sietillFormat,
-                  mm2Format };
+    enum Format {
+        noFormat,
+        sietillFormat,
+        mm2Format
+    };
     static const Core::Choice          choiceFormat;
     static const Core::ParameterChoice paramFormat;
     static const Core::ParameterBool   paramVerbose;
diff --git a/src/Tools/FeatureExtraction/FeatureExtractor.hh b/src/Tools/FeatureExtraction/FeatureExtractor.hh
index 294fb9927..486bba2e9 100644
--- a/src/Tools/FeatureExtraction/FeatureExtractor.hh
+++ b/src/Tools/FeatureExtraction/FeatureExtractor.hh
@@ -29,7 +29,9 @@ protected:
 
 public:
     FeatureExtractor(const Core::Configuration& c)
-            : Core::Component(c), Precursor(c), frameShift_(0) {}
+            : Core::Component(c),
+              Precursor(c),
+              frameShift_(0) {}
     virtual ~FeatureExtractor() {}
 
     Flow::Time frameShift() {
diff --git a/src/Tools/FeatureExtraction/Makefile b/src/Tools/FeatureExtraction/Makefile
index a5eee0592..211029da4 100644
--- a/src/Tools/FeatureExtraction/Makefile
+++ b/src/Tools/FeatureExtraction/Makefile
@@ -54,7 +54,9 @@ FEATURE_EXTRACTION_O += ../../Tensorflow/libSprintTensorflow.$(a)
 CXXFLAGS += $(TF_CXXFLAGS)
 LDFLAGS  += $(TF_LDFLAGS)
 endif
-
+ifdef MODULE_LM_ONNX
+FEATURE_EXTRACTION_O += ../../Onnx/libSprintOnnx.$(a)
+endif
 
 # -----------------------------------------------------------------------------
 
diff --git a/src/Tools/FeatureStatistics/Makefile b/src/Tools/FeatureStatistics/Makefile
index 7ab3285b3..38a429b1b 100644
--- a/src/Tools/FeatureStatistics/Makefile
+++ b/src/Tools/FeatureStatistics/Makefile
@@ -51,6 +51,9 @@ FEATURE_STATISTICS_O += ../../Tensorflow/libSprintTensorflow.$(a)
 CXXFLAGS += $(TF_CXXFLAGS)
 LDFLAGS  += $(TF_LDFLAGS)
 endif
+ifdef MODULE_LM_ONNX
+FEATURE_STATISTICS_O += ../../Onnx/libSprintOnnx.$(a)
+endif
 
 
 # -----------------------------------------------------------------------------
diff --git a/src/Tools/Flf/FlfTool.cc b/src/Tools/Flf/FlfTool.cc
index 53fc9d6d9..8e1dba6d8 100644
--- a/src/Tools/Flf/FlfTool.cc
+++ b/src/Tools/Flf/FlfTool.cc
@@ -122,10 +122,13 @@ class FlfTool : public Core::Application {
     }
 
     int main(const std::vector<std::string>& arguments) {
-        enum { Run,
-               Init,
-               Parse,
-               Help } cmd             = Run;
+        enum {
+            Run,
+            Init,
+            Parse,
+            Help
+        } cmd = Run;
+
         Flf::Module::Instance& flfApp = Flf::Module::instance();
         if (!arguments.empty()) {
             if ((arguments.front() == "init") ||
diff --git a/src/Tools/Flf/Makefile b/src/Tools/Flf/Makefile
index ef83971ea..ce178f5aa 100644
--- a/src/Tools/Flf/Makefile
+++ b/src/Tools/Flf/Makefile
@@ -52,7 +52,10 @@ endif
 ifdef MODULE_TENSORFLOW
 FLF_TOOL_O += ../../Tensorflow/libSprintTensorflow.$(a)
 CXXFLAGS += $(TF_CXXFLAGS)
-LDFLAGS  += $(TF_LDFLAGS)
+LDFLAGS  := $(TF_LDFLAGS) $(LDFLAGS)
+endif
+ifdef MODULE_LM_ONNX
+FLF_TOOL_O += ../../Onnx/libSprintOnnx.$(a)
 endif
 
 # -----------------------------------------------------------------------------
diff --git a/src/Tools/Flow/flowdraw.py b/src/Tools/Flow/flowdraw.py
index 3c97a2e1a..06b39e27f 100755
--- a/src/Tools/Flow/flowdraw.py
+++ b/src/Tools/Flow/flowdraw.py
@@ -1,119 +1,127 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 import sys, tempfile, os
 from xml.dom.minidom import parse
 
+
 def clean(s):
-	s = s.replace("-", "_")
-	s = s.replace("~", "_")
-	return s
+    s = s.replace("-", "_")
+    s = s.replace("~", "_")
+    return s
+
 
 def main(argv):
-	if len(argv) < 2: usage(argv[0])
-
-	dom = parse(argv[1])
-	nodes = dom.getElementsByTagName('node')
-	links = dom.getElementsByTagName('link')
-	inputs = dom.getElementsByTagName('in')
-	outputs = dom.getElementsByTagName('out')
-	params = dom.getElementsByTagName('param')
-	network = dom.getElementsByTagName('network')[0]
-
-	out, outname = tempfile.mkstemp()
-	out = open(outname, 'w')
-	print >> out, "digraph flow {"
-
-	att = lambda n, a: n.getAttribute(a)
-
-	txt = ""
-	netname = att(network, "name")
-	if not netname: netname="network"
-
-	for i in inputs+outputs:
-		i = att(i, "name")
-		print >> out, """%s [shape=plaintext
-			label = "%s:%s"];""" %(i, netname, i)
-
-	for n in nodes:
-		name = att(n, "name")
-		atts = n.attributes
-		inp = ""
-		#inp = []
-		#for l in links:
-		#	to = att(l, "to")
-		#	if to.startswith(name) and ":" in to:
-		#		port = to.split(":")[1]
-		#		inp.append(port)
-
-		#print inp
-		#if len(inp)>0:
-		#	txt = "<TR><TD COLSPAN='2'><TABLE CELLSPACING='0'><TR>"
-		#	for i in inp:
-		#		txt+= "<TD>%s</TD>" % i
-		#	txt += "</TR></TABLE></TD></TR>"
-		#	inp = txt
-		#else:
-		#	inp = ""
-
-
-		label = "<FONT FACE='svg'><TABLE CELLSPACING='0'>%s<TR><TD COLSPAN='2'>%s</TD></TR>" % (inp, name)
-		for i in range(len(atts)):
-			key = atts.item(i).name
-			value = att(n, key)
-#			value = clean(value)
-			if key=="name": continue
-			if key=="filter":
-				if value[-5:] == ".flow":
-					value="<FONT COLOR='RED'>%s</FONT>" % value
-				elif value[0]!="$":
-					value="<FONT COLOR='DARKGREEN'>%s</FONT>" % value
-			if value[0]=="$":
-				value="<FONT COLOR='BLUE'>%s</FONT>" % value
-
-			label += "<TR><TD ALIGN='LEFT'>%s</TD><TD ALIGN='LEFT'>%s</TD></TR>" % (key, value)
-
-		label += "</TABLE></FONT>"
-		name = clean(name)
-
-		print >> out, """%s [shape=plaintext
+    if len(argv) < 2:
+        usage(argv[0])
+
+    dom = parse(argv[1])
+    nodes = dom.getElementsByTagName("node")
+    links = dom.getElementsByTagName("link")
+    inputs = dom.getElementsByTagName("in")
+    outputs = dom.getElementsByTagName("out")
+    params = dom.getElementsByTagName("param")
+    network = dom.getElementsByTagName("network")[0]
+
+    out, outname = tempfile.mkstemp()
+    out = open(outname, "w")
+    print("digraph flow {", file=out)
+
+    att = lambda n, a: n.getAttribute(a)
+
+    txt = ""
+    netname = att(network, "name")
+    if not netname:
+        netname = "network"
+
+    for i in inputs + outputs:
+        i = att(i, "name")
+        print(
+            """%s [shape=plaintext
+			label = "%s:%s"];"""
+            % (i, netname, i),
+            file=out,
+        )
+
+    for n in nodes:
+        name = att(n, "name")
+        atts = n.attributes
+        inp = ""
+
+        label = (
+            "<FONT FACE='svg'><TABLE CELLSPACING='0'>%s<TR><TD COLSPAN='2'>%s</TD></TR>"
+            % (inp, name)
+        )
+        for i in range(len(atts)):
+            key = atts.item(i).name
+            value = att(n, key)
+            # 			value = clean(value)
+            if key == "name":
+                continue
+            if key == "filter":
+                if value[-5:] == ".flow":
+                    value = "<FONT COLOR='RED'>%s</FONT>" % value
+                elif value[0] != "$":
+                    value = "<FONT COLOR='DARKGREEN'>%s</FONT>" % value
+            if value[0] == "$":
+                value = "<FONT COLOR='BLUE'>%s</FONT>" % value
+
+            label += "<TR><TD ALIGN='LEFT'>%s</TD><TD ALIGN='LEFT'>%s</TD></TR>" % (
+                key,
+                value,
+            )
+
+        label += "</TABLE></FONT>"
+        name = clean(name)
+
+        print(
+            """%s [shape=plaintext
 		label = <%s>
-		];""" % (name, label)
+		];"""
+            % (name, label),
+            file=out,
+        )
 
-	for l in links:
+    for l in links:
 
-		fr = att(l, "from")
-		to = att(l, "to")
+        fr = att(l, "from")
+        to = att(l, "to")
 
-		fr = clean(fr)
-		to = clean(to)
+        fr = clean(fr)
+        to = clean(to)
 
-		if fr.startswith(netname+":"): fr=fr.split(":")[1]
-		if to.startswith(netname+":"): to=to.split(":")[1]
+        if fr.startswith(netname + ":"):
+            fr = fr.split(":")[1]
+        if to.startswith(netname + ":"):
+            to = to.split(":")[1]
 
-		label = ""
-		if ":" in fr or ":" in to:
-			port1 = ""
-			port2 = ""
-			if ":" in fr: port1 = fr.split(":")[1]
-			if ":" in to: port2 = to.split(":")[1]
-			label = ' [label="%s->%s", fontname="svg"]' % (port1, port2)
+        label = ""
+        if ":" in fr or ":" in to:
+            port1 = ""
+            port2 = ""
+            if ":" in fr:
+                port1 = fr.split(":")[1]
+            if ":" in to:
+                port2 = to.split(":")[1]
+            label = ' [label="%s->%s", fontname="svg"]' % (port1, port2)
 
-		print >> out, "%s -> %s %s;" % (fr, to, label)
+        print("%s -> %s %s;" % (fr, to, label), file=out)
 
-	print >> out, "}"
-	#print "dot -Tpng < %s > %s.png; eog %s.png " % (outname, outname, outname)
-	out.close()
+    print("}", file=out)
+    # print "dot -Tpng < %s > %s.png; eog %s.png " % (outname, outname, outname)
+    out.close()
 
-	if len(argv) == 3:
-		pic = argv[2]
-	else:
-		pic = "%s.png" % outname
+    if len(argv) == 3:
+        pic = argv[2]
+    else:
+        pic = "%s.png" % outname
+
+    os.system("dot -Tpng < %s > %s" % (outname, pic))
+    print("Plot written to %s" % pic)
 
-	os.system("dot -Tpng < %s > %s" % (outname, pic))
-	print "Plot written to %s" % pic
 
 def usage(prog):
-	print "USAGE: %s file.flow [plot.png]" % prog
-	sys.exit(-1)
+    print("USAGE: %s file.flow [plot.png]" % prog)
+    sys.exit(-1)
+
 
 if __name__ == "__main__":
-	main(sys.argv)
+    main(sys.argv)
diff --git a/src/Tools/LatticeProcessor/LatticeProcessor.cc b/src/Tools/LatticeProcessor/LatticeProcessor.cc
index 33f1f653c..241f7b6ca 100644
--- a/src/Tools/LatticeProcessor/LatticeProcessor.cc
+++ b/src/Tools/LatticeProcessor/LatticeProcessor.cc
@@ -361,13 +361,14 @@ std::string LatticeProcessor::getApplicationDescription() const {
 }
 
 std::string LatticeProcessor::getParameterDescription() const {
-    std::string         tmp     = "\n"
-                                  "supported actions:\n"
-                                  "\n"
-                                  "\t\"not-given\": do nothing\n"
-                                  "\t[*.selection]\n"
-                                  "\t# nothing to configurate\n"
-                                  "\t\n";
+    std::string tmp = "\n"
+                      "supported actions:\n"
+                      "\n"
+                      "\t\"not-given\": do nothing\n"
+                      "\t[*.selection]\n"
+                      "\t# nothing to configurate\n"
+                      "\t\n";
+
     std::vector<Action> actions = processorFactory_.identifiers();
     for (std::vector<Action>::const_iterator a = actions.begin(); a != actions.end(); ++a) {
         std::string name = choiceAction[*a];
@@ -468,8 +469,7 @@ APPLICATION(LatticeProcessor)
 /**
  * Parse the actions and selections statements in the configuration
  */
-void LatticeProcessor::parseActionsSelections(
-        std::vector<Action>& actions, std::vector<Selection>& selections) {
+void LatticeProcessor::parseActionsSelections(std::vector<Action>& actions, std::vector<Selection>& selections) {
     require(actions.empty() && selections.empty());
     std::vector<std::string> _actions = paramActions(config);
     selections                        = paramSelections(config);
diff --git a/src/Tools/LatticeProcessor/LatticeProcessor.hh b/src/Tools/LatticeProcessor/LatticeProcessor.hh
index fd911dc29..fe90ef8b8 100644
--- a/src/Tools/LatticeProcessor/LatticeProcessor.hh
+++ b/src/Tools/LatticeProcessor/LatticeProcessor.hh
@@ -115,7 +115,9 @@ private:
     static const Core::Choice                choiceAction;
     static const Core::ParameterStringVector paramActions;
     static const Core::ParameterStringVector paramSelections;
-    enum CorpusType { bliss };
+    enum CorpusType {
+        bliss
+    };
     static const Core::Choice          choiceCorpusType;
     static const Core::ParameterChoice paramCorpusType;
     enum ApplicationType {
diff --git a/src/Tools/LatticeProcessor/Makefile b/src/Tools/LatticeProcessor/Makefile
index a360a95b1..3fa2009e3 100644
--- a/src/Tools/LatticeProcessor/Makefile
+++ b/src/Tools/LatticeProcessor/Makefile
@@ -25,8 +25,8 @@ LATTICE_PROCESSOR_O = $(OBJDIR)/LatticeProcessor.o \
 		../../Core/libSprintCore.$(a) \
 		../../Fsa/libSprintFsa.$(a) \
 		../../Flf/FlfCore/libSprintFlfCore.$(a)
-		
-LATTICE_PROCESSOR_O += $(subst src,../..,$(LIBS_SEARCH))		
+
+LATTICE_PROCESSOR_O += $(subst src,../..,$(LIBS_SEARCH))
 
 ifdef MODULE_CART
 LATTICE_PROCESSOR_O += ../../Cart/libSprintCart.$(a)
@@ -48,6 +48,9 @@ LATTICE_PROCESSOR_O += ../../Tensorflow/libSprintTensorflow.$(a)
 CXXFLAGS += $(TF_CXXFLAGS)
 LDFLAGS  += $(TF_LDFLAGS)
 endif
+ifdef MODULE_LM_ONNX
+LATTICE_PROCESSOR_O += ../../Onnx/libSprintOnnx.$(a)
+endif
 # -----------------------------------------------------------------------------
 
 build: $(TARGETS)
diff --git a/src/Tools/LibRASR/LibRASR.cc b/src/Tools/LibRASR/LibRASR.cc
index ee676611b..76c6694da 100644
--- a/src/Tools/LibRASR/LibRASR.cc
+++ b/src/Tools/LibRASR/LibRASR.cc
@@ -8,14 +8,14 @@
 #include <Math/Module.hh>
 #include <Mm/Module.hh>
 #include <Modules.hh>
-#include <Signal/Module.hh>
-#include <Speech/Module.hh>
 #ifdef MODULE_NN
 #include <Nn/Module.hh>
 #endif
 #ifdef MODULE_ONNX
 #include <Onnx/Module.hh>
 #endif
+#include <Signal/Module.hh>
+#include <Speech/Module.hh>
 #ifdef MODULE_TENSORFLOW
 #include <Tensorflow/Module.hh>
 #endif
diff --git a/src/Tools/Lm/LmUtilityTool.cc b/src/Tools/Lm/LmUtilityTool.cc
index e8d320ff8..c1b7ce6e7 100644
--- a/src/Tools/Lm/LmUtilityTool.cc
+++ b/src/Tools/Lm/LmUtilityTool.cc
@@ -136,15 +136,37 @@ void LmUtilityTool::computePerplexityFromTextFile() {
     Core::TextInputStream  tis(new Core::CompressedInputStream(paramFile(config)));
     Core::TextOutputStream out;
 
+    log("reading text from '%s'", paramFile(config).c_str());
     tis.setEncoding(paramEncoding(config));
+    out.setEncoding(paramEncoding(config));
     std::string out_file = paramScoreFile(config);
     if (not out_file.empty()) {
         out.open(out_file);
+        log("saving scores to '%s'", out_file.c_str());
     }
 
     std::vector<LMRequest> requests;
     size_t                 num_tokens   = 0;
+    size_t                 num_lines    = 0;
+    size_t                 num_unks     = 0;
+    size_t                 num_eos      = 0;
     Lm::Score              corpus_score = 0.0;
+    Lm::Score              eos_scores   = 0.0;
+    Lm::Score              unks_scores  = 0.0;
+
+    Bliss::Lemma const* eos_lemma = lexicon->specialLemma("sentence-boundary");
+    if (eos_lemma == nullptr) {
+        eos_lemma = lexicon->specialLemma("sentence-end");
+    }
+    require_ne(eos_lemma, nullptr);
+
+    Bliss::Lemma const* sos_lemma = lexicon->specialLemma("sentence-begin");
+    if (sos_lemma == nullptr) {
+        warning("sentence-begin not found, using unigram probability instead\n");
+    }
+
+    Bliss::Lemma const* unk_lemma = lexicon->specialLemma("unknown");
+    require_ne(unk_lemma, nullptr);
 
     do {
         std::string line;
@@ -165,17 +187,25 @@ void LmUtilityTool::computePerplexityFromTextFile() {
                     h = lm->extendedHistory(h, t);
                 }
             }
-            Bliss::Lemma const* lemma  = lexicon->specialLemma("sentence-end");
-            auto const          tokens = lemma->syntacticTokenSequence();
+            auto const tokens = eos_lemma->syntacticTokenSequence();
             for (auto const& t : tokens) {
-                requests.emplace_back(LMRequest({"\\n", lemma, t, h, 0.0f}));
+                requests.emplace_back(LMRequest({"\\n", eos_lemma, t, h, 0.0f}));
                 h = lm->extendedHistory(h, t);
             }
+            ++num_lines;
         }
 
         if (not tis.good() or requests.size() >= batch_size) {
             computeAllScores(requests, lm, renormalize);
             for (auto const& r : requests) {
+                if (r.lemma == eos_lemma) {
+                    eos_scores += r.score;
+                    num_eos += 1ul;
+                }
+                if (r.lemma == unk_lemma) {
+                    unks_scores += r.score;
+                    num_unks += 1ul;
+                }
                 corpus_score += r.score;
                 num_tokens += 1ul;
                 if (out.good()) {
@@ -186,9 +216,18 @@ void LmUtilityTool::computePerplexityFromTextFile() {
         }
     } while (tis.good());
 
-    Lm::Score ppl = std::exp(corpus_score / num_tokens);
+    Lm::Score ppl                = std::exp(corpus_score / num_tokens);
+    Lm::Score ppl_wo_eos         = std::exp((corpus_score - eos_scores) / (num_tokens - num_eos));
+    Lm::Score ppl_wo_unks        = std::exp((corpus_score - unks_scores) / (num_tokens - num_unks));
+    Lm::Score ppl_wo_eos_wo_unks = std::exp((corpus_score - unks_scores - eos_scores) / (num_tokens - num_unks - num_eos));
 
     log() << Core::XmlOpen("corpus-score") << corpus_score << Core::XmlClose("corpus-score")
           << Core::XmlOpen("num-tokens") << num_tokens << Core::XmlClose("num-tokens")
-          << Core::XmlOpen("perplexity") << ppl << Core::XmlClose("perplexity");
+          << Core::XmlOpen("num-unks") << num_unks << Core::XmlClose("num-unks")
+          << Core::XmlOpen("unk-ratio") << static_cast<float>(num_unks) / static_cast<float>(num_tokens) << Core::XmlClose("unk-ratio")
+          << Core::XmlOpen("num-lines") << num_lines << Core::XmlClose("num-lines")
+          << Core::XmlOpen("perplexity") << ppl << Core::XmlClose("perplexity")
+          << Core::XmlOpen("perplexity-without-eos") << ppl_wo_eos << Core::XmlClose("perplexity-without-eos")
+          << Core::XmlOpen("perplexity-without-unknowns") << ppl_wo_unks << Core::XmlClose("perplexity-without-unknowns")
+          << Core::XmlOpen("perplexity-without-eos-without-unknowns") << ppl_wo_eos_wo_unks << Core::XmlClose("perplexity-without-eos-without-unknowns");
 }
diff --git a/src/Tools/Lm/Makefile b/src/Tools/Lm/Makefile
index f4982659a..9a52b6c87 100644
--- a/src/Tools/Lm/Makefile
+++ b/src/Tools/Lm/Makefile
@@ -52,6 +52,9 @@ LM_UTIL_TOOL_O += ../../Tensorflow/libSprintTensorflow.$(a)
 CXXFLAGS += $(TF_CXXFLAGS)
 LDFLAGS  += $(TF_LDFLAGS)
 endif
+ifdef MODULE_LM_ONNX
+LM_UTIL_TOOL_O += ../../Onnx/libSprintOnnx.$(a)
+endif
 
 # -----------------------------------------------------------------------------
 
diff --git a/src/Tools/NnTrainer/Makefile b/src/Tools/NnTrainer/Makefile
index f2df495ce..6a9a227bc 100644
--- a/src/Tools/NnTrainer/Makefile
+++ b/src/Tools/NnTrainer/Makefile
@@ -48,6 +48,9 @@ NN_TRAINER_O += ../../Tensorflow/libSprintTensorflow.$(a)
 CXXFLAGS += $(TF_CXXFLAGS)
 LDFLAGS  += $(TF_LDFLAGS)
 endif
+ifdef MODULE_LM_ONNX
+NN_TRAINER_O += ../../Onnx/libSprintOnnx.$(a)
+endif
 
 # -----------------------------------------------------------------------------
 
diff --git a/src/Tools/SpeechRecognizer/Makefile b/src/Tools/SpeechRecognizer/Makefile
index c8b79024c..0c7607c62 100644
--- a/src/Tools/SpeechRecognizer/Makefile
+++ b/src/Tools/SpeechRecognizer/Makefile
@@ -22,6 +22,8 @@ COMMON_O	= ../../Speech/libSprintSpeech.$(a) \
 		  ../../Math/libSprintMath.$(a) \
 		  ../../Math/Lapack/libSprintMathLapack.$(a) \
 		  ../../Core/libSprintCore.$(a) \
+		  ../../Flf/libSprintFlf.$(a) \
+		  ../../Flf/FlfCore/libSprintFlfCore.$(a) \
 		  ../../Fsa/libSprintFsa.$(a)
 
 COMMON_O += $(subst src,../..,$(LIBS_SEARCH))
@@ -29,8 +31,8 @@ COMMON_O += $(subst src,../..,$(LIBS_SEARCH))
 ifdef MODULE_CART
 COMMON_O += ../../Cart/libSprintCart.$(a)
 endif
-ifdef MODULE_FLF_CORE
-COMMON_O += ../../Flf/FlfCore/libSprintFlfCore.$(a)
+ifdef MODULE_FLF_EXT
+COMMON_O += ../../Flf/FlfExt/libSprintFlfExt.$(a)
 endif
 ifdef MODULE_OPENFST
 ifeq ($(OS),darwin)
@@ -56,7 +58,7 @@ endif
 ifdef MODULE_TENSORFLOW
 COMMON_O += ../../Tensorflow/libSprintTensorflow.$(a)
 CXXFLAGS += $(TF_CXXFLAGS)
-LDFLAGS  += $(TF_LDFLAGS)
+LDFLAGS  := $(TF_LDFLAGS) $(LDFLAGS)
 endif
 
 # -----------------------------------------------------------------------------