diff --git a/aconversions/src/rg2fa/AbstractRGtoFAConverter.cpp b/aconversions/src/rg2fa/AbstractRGtoFAConverter.cpp
index a6b56bdd8a5c1c9c195d6ce331c8cf9eb53f93fd..c7439b614ea9ffce7cc6765f2dc23f2641dc9011 100644
--- a/aconversions/src/rg2fa/AbstractRGtoFAConverter.cpp
+++ b/aconversions/src/rg2fa/AbstractRGtoFAConverter.cpp
@@ -1,13 +1,9 @@
 #include "AbstractRGtoFAConverter.h"
 
-using namespace alphabet;
-using namespace automaton;
-using namespace grammar;
-
 namespace conversions
 {
 
-AbstractRGtoFAConverter::AbstractRGtoFAConverter( const RegularGrammar& grammar ) : m_grammar( grammar )
+AbstractRGtoFAConverter::AbstractRGtoFAConverter( void )
 {
 
 }
@@ -17,16 +13,4 @@ AbstractRGtoFAConverter::~AbstractRGtoFAConverter( void )
 
 }
 
-void AbstractRGtoFAConverter::createInputAlphabet( void )
-{
-    for( set<Symbol>::const_iterator i = m_grammar.getTerminalSymbols().begin(); i != m_grammar.getTerminalSymbols().end(); i++ )
-        m_automaton . addInputSymbol( *i );
-}
-
-void AbstractRGtoFAConverter::createStates( void )
-{
-    for( set<Symbol>::const_iterator i = m_grammar.getNonTerminalSymbols().begin(); i != m_grammar.getNonTerminalSymbols().end(); i++ )
-        m_automaton . addState( State( i-> getSymbol() ) );
-}
-
 } /* namespace conversions */
diff --git a/aconversions/src/rg2fa/AbstractRGtoFAConverter.h b/aconversions/src/rg2fa/AbstractRGtoFAConverter.h
index 8555e31f75a7b4c07342fd4990e8fbb66e98ff63..226fff1e31f242660d3493d7f4186ce77daf449f 100644
--- a/aconversions/src/rg2fa/AbstractRGtoFAConverter.h
+++ b/aconversions/src/rg2fa/AbstractRGtoFAConverter.h
@@ -2,8 +2,6 @@
 #define __ABSTRACTRGTOFACONVERTER_H__
 
 #include <automaton/FSM/FSM.h>
-#include <grammar/Regular/RegularGrammar.h>
-
 #include <AlibException.h>
 
 #include "../include/macros.h"
@@ -19,11 +17,8 @@ public:
     virtual ~AbstractRGtoFAConverter( void );
 
 protected:
-    AbstractRGtoFAConverter( const grammar::RegularGrammar& grammar );
-    void createStates( void );
-    void createInputAlphabet( void );
+    AbstractRGtoFAConverter( void );
 
-    const grammar::RegularGrammar& m_grammar;
     automaton::FSM m_automaton;
 };
 
diff --git a/aconversions/src/rg2fa/lrg2fa/AbstractLRGtoFAConverter.cpp b/aconversions/src/rg2fa/lrg2fa/AbstractLRGtoFAConverter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3fe26c9770e867ad7d3c7714064c194c7c3b428e
--- /dev/null
+++ b/aconversions/src/rg2fa/lrg2fa/AbstractLRGtoFAConverter.cpp
@@ -0,0 +1,25 @@
+/*
+ * AbstractLRGtoFAConverter.cpp
+ *
+ *  Created on: 16. 3. 2014
+ *      Author: tomas
+ */
+
+#include "AbstractLRGtoFAConverter.h"
+
+using namespace grammar;
+
+namespace conversions
+{
+
+AbstractLRGtoFAConverter::AbstractLRGtoFAConverter( const LeftRegularGrammar & lrg ) : m_grammar( lrg )
+{
+
+}
+
+AbstractLRGtoFAConverter::~AbstractLRGtoFAConverter( void )
+{
+
+}
+
+} /* namespace conversions */
diff --git a/aconversions/src/rg2fa/lrg2fa/AbstractLRGtoFAConverter.h b/aconversions/src/rg2fa/lrg2fa/AbstractLRGtoFAConverter.h
new file mode 100644
index 0000000000000000000000000000000000000000..4960994ad892fdae2f26eec73a6008fcf493f887
--- /dev/null
+++ b/aconversions/src/rg2fa/lrg2fa/AbstractLRGtoFAConverter.h
@@ -0,0 +1,31 @@
+/*
+ * AbstractLRGtoFAConverter.h
+ *
+ *  Created on: 16. 3. 2014
+ *      Author: tomas
+ */
+
+#ifndef ABSTRACTLRGTOFACONVERTER_H_
+#define ABSTRACTLRGTOFACONVERTER_H_
+
+#include <grammar/Regular/LeftRegularGrammar.h>
+
+#include "../AbstractRGtoFAConverter.h"
+
+namespace conversions
+{
+
+class AbstractLRGtoFAConverter: public AbstractRGtoFAConverter
+{
+public:
+    ~AbstractLRGtoFAConverter( void );
+
+protected:
+    AbstractLRGtoFAConverter( const grammar::LeftRegularGrammar & lrg );
+    const grammar::LeftRegularGrammar & m_grammar;
+
+};
+
+} /* namespace conversions */
+
+#endif /* ABSTRACTLRGTOFACONVERTER_H_ */
diff --git a/aconversions/src/rg2fa/LRGtoFAConverter.cpp b/aconversions/src/rg2fa/lrg2fa/LRGtoFAConverter.cpp
similarity index 84%
rename from aconversions/src/rg2fa/LRGtoFAConverter.cpp
rename to aconversions/src/rg2fa/lrg2fa/LRGtoFAConverter.cpp
index fdea21b7a2aea75fffae7c475898b165bdb33d53..53d0c68b11dac2e3fc70d8f54623392629bc407d 100644
--- a/aconversions/src/rg2fa/LRGtoFAConverter.cpp
+++ b/aconversions/src/rg2fa/lrg2fa/LRGtoFAConverter.cpp
@@ -7,7 +7,7 @@ using namespace grammar;
 namespace conversions
 {
 
-LRGtoFAConverter::LRGtoFAConverter( const LeftRegularGrammar & grammar ) : AbstractRGtoFAConverter( grammar )
+LRGtoFAConverter::LRGtoFAConverter( const LeftRegularGrammar & grammar ) : AbstractLRGtoFAConverter( grammar )
 {
     //TODO: if is not LRG throw Exception
 }
@@ -19,8 +19,11 @@ LRGtoFAConverter::~LRGtoFAConverter( void )
 
 FSM LRGtoFAConverter::convert( void )
 {
-    createInputAlphabet( );
-    createStates( );
+    for( const auto & symbol : m_grammar.getTerminalSymbols( ) )
+        m_automaton.addInputSymbol( symbol );
+
+    for( const auto & symbol : m_grammar.getNonTerminalSymbols( ) )
+        m_automaton.addState( State( symbol.getSymbol( ) ) );
 
     const State & startState = m_automaton.createUniqueState( "q0", true );
 
diff --git a/aconversions/src/rg2fa/LRGtoFAConverter.h b/aconversions/src/rg2fa/lrg2fa/LRGtoFAConverter.h
similarity index 63%
rename from aconversions/src/rg2fa/LRGtoFAConverter.h
rename to aconversions/src/rg2fa/lrg2fa/LRGtoFAConverter.h
index f0f9a39b9e687f49f0c3c09b2bc6eb60ae1ea532..f36e9df91808cff28a6038c587dcfa56102a2ad8 100644
--- a/aconversions/src/rg2fa/LRGtoFAConverter.h
+++ b/aconversions/src/rg2fa/lrg2fa/LRGtoFAConverter.h
@@ -1,15 +1,12 @@
 #ifndef __LRGTOFACONVERTER_H__
 #define __LRGTOFACONVERTER_H__
 
-#include <automaton/FSM/FSM.h>
-#include <grammar/Regular/LeftRegularGrammar.h>
-
-#include "AbstractRGtoFAConverter.h"
+#include "AbstractLRGtoFAConverter.h"
 
 namespace conversions
 {
 
-class LRGtoFAConverter : public AbstractRGtoFAConverter
+class LRGtoFAConverter : public AbstractLRGtoFAConverter
 {
 public:
     LRGtoFAConverter( const grammar::LeftRegularGrammar & grammar );
diff --git a/aconversions/src/rg2fa/rrg2fa/AbstractRRGtoFAConverter.cpp b/aconversions/src/rg2fa/rrg2fa/AbstractRRGtoFAConverter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c67474eb5058a25a39d01358416d8104ea02621f
--- /dev/null
+++ b/aconversions/src/rg2fa/rrg2fa/AbstractRRGtoFAConverter.cpp
@@ -0,0 +1,25 @@
+/*
+ * AbstractRRGtoFAConverter.cpp
+ *
+ *  Created on: 16. 3. 2014
+ *      Author: tomas
+ */
+
+#include "AbstractRRGtoFAConverter.h"
+
+using namespace grammar;
+
+namespace conversions
+{
+
+AbstractRRGtoFAConverter::AbstractRRGtoFAConverter( const RightRegularGrammar & rrg ) : m_grammar( rrg )
+{
+
+}
+
+AbstractRRGtoFAConverter::~AbstractRRGtoFAConverter()
+{
+
+}
+
+} /* namespace conversions */
diff --git a/aconversions/src/rg2fa/rrg2fa/AbstractRRGtoFAConverter.h b/aconversions/src/rg2fa/rrg2fa/AbstractRRGtoFAConverter.h
new file mode 100644
index 0000000000000000000000000000000000000000..c1bf9528dadee746001ba7997c63128e50ce8087
--- /dev/null
+++ b/aconversions/src/rg2fa/rrg2fa/AbstractRRGtoFAConverter.h
@@ -0,0 +1,30 @@
+/*
+ * AbstractRRGtoFAConverter.h
+ *
+ *  Created on: 16. 3. 2014
+ *      Author: tomas
+ */
+
+#ifndef ABSTRACTRRGTOFACONVERTER_H_
+#define ABSTRACTRRGTOFACONVERTER_H_
+
+#include <grammar/Regular/RightRegularGrammar.h>
+
+#include "../AbstractRGtoFAConverter.h"
+
+namespace conversions
+{
+
+class AbstractRRGtoFAConverter: public conversions::AbstractRGtoFAConverter
+{
+public:
+    virtual ~AbstractRRGtoFAConverter( void );
+
+protected:
+    AbstractRRGtoFAConverter( const grammar::RightRegularGrammar & rrg );
+    const grammar::RightRegularGrammar & m_grammar;
+};
+
+} /* namespace conversions */
+
+#endif /* ABSTRACTRRGTOFACONVERTER_H_ */
diff --git a/aconversions/src/rg2fa/RRGtoFAConverter.cpp b/aconversions/src/rg2fa/rrg2fa/RRGtoFAConverter.cpp
similarity index 84%
rename from aconversions/src/rg2fa/RRGtoFAConverter.cpp
rename to aconversions/src/rg2fa/rrg2fa/RRGtoFAConverter.cpp
index ffe18ba402d300560510bf6419b36030e07eac49..9788b5f3e7fc47189c31e6f84dcd60319113c9e7 100644
--- a/aconversions/src/rg2fa/RRGtoFAConverter.cpp
+++ b/aconversions/src/rg2fa/rrg2fa/RRGtoFAConverter.cpp
@@ -7,7 +7,7 @@ using namespace grammar;
 namespace conversions
 {
 
-RRGtoFAConverter::RRGtoFAConverter( const RightRegularGrammar & grammar ) : AbstractRGtoFAConverter( grammar )
+RRGtoFAConverter::RRGtoFAConverter( const RightRegularGrammar & grammar ) : AbstractRRGtoFAConverter( grammar )
 {
     //TODO: if is not RRG throw Exception
 }
@@ -20,8 +20,11 @@ RRGtoFAConverter::~RRGtoFAConverter( void )
 
 FSM RRGtoFAConverter::convert( void )
 {
-    createInputAlphabet( );
-    createStates( );
+    for( const auto & symbol : m_grammar.getTerminalSymbols( ) )
+        m_automaton.addInputSymbol( symbol );
+
+    for( const auto & symbol : m_grammar.getNonTerminalSymbols( ) )
+        m_automaton.addState( State( symbol.getSymbol( ) ) );
 
     const State & AState = m_automaton.createUniqueState( "A", true );
 
diff --git a/aconversions/src/rg2fa/RRGtoFAConverter.h b/aconversions/src/rg2fa/rrg2fa/RRGtoFAConverter.h
similarity index 63%
rename from aconversions/src/rg2fa/RRGtoFAConverter.h
rename to aconversions/src/rg2fa/rrg2fa/RRGtoFAConverter.h
index f8230cbe839f34a00dc337abb60620e70def06db..32d5117e134ed8990c88d3d4a16982f63f0226da 100644
--- a/aconversions/src/rg2fa/RRGtoFAConverter.h
+++ b/aconversions/src/rg2fa/rrg2fa/RRGtoFAConverter.h
@@ -1,15 +1,12 @@
 #ifndef __RRGTOFACONVERTER_H__
 #define __RRGTOFACONVERTER_H__
 
-#include <grammar/Regular/RightRegularGrammar.h>
-#include <automaton/FSM/FSM.h>
-
-#include "AbstractRGtoFAConverter.h"
+#include "AbstractRRGtoFAConverter.h"
 
 namespace conversions
 {
 
-class RRGtoFAConverter : public AbstractRGtoFAConverter
+class RRGtoFAConverter : public AbstractRRGtoFAConverter
 {
 public:
     RRGtoFAConverter( const grammar::RightRegularGrammar & grammar );
diff --git a/aconversions/src/rg2re/AbstractRGtoREConverter.cpp b/aconversions/src/rg2re/AbstractRGtoREConverter.cpp
index 95fb644460a43cbb7ffa6f820411f0b2cf6717e8..60bae347d1021ee6066a20e4afb6eca2dd8f8a15 100644
--- a/aconversions/src/rg2re/AbstractRGtoREConverter.cpp
+++ b/aconversions/src/rg2re/AbstractRGtoREConverter.cpp
@@ -7,12 +7,10 @@
 
 #include "AbstractRGtoREConverter.h"
 
-using namespace grammar;
-
 namespace conversions
 {
 
-AbstractRGtoREConverter::AbstractRGtoREConverter( const RegularGrammar & grammar ) : m_grammar( grammar )
+AbstractRGtoREConverter::AbstractRGtoREConverter( void )
 {
 
 }
diff --git a/aconversions/src/rg2re/AbstractRGtoREConverter.h b/aconversions/src/rg2re/AbstractRGtoREConverter.h
index 7eda2748b1f772c9565264b9f3fb5ffcb3cf320f..a333f37ae2e16844d6181c96485a9ddd366fd3ce 100644
--- a/aconversions/src/rg2re/AbstractRGtoREConverter.h
+++ b/aconversions/src/rg2re/AbstractRGtoREConverter.h
@@ -8,7 +8,6 @@
 #ifndef ABSTRACTRGTORECONVERTER_H_
 #define ABSTRACTRGTORECONVERTER_H_
 
-#include <grammar/Regular/RegularGrammar.h>
 #include <regexp/RegExp.h>
 
 #include "../abstract/Conversion.h"
@@ -23,9 +22,8 @@ public:
     virtual ~AbstractRGtoREConverter( void );
 
 protected:
-    AbstractRGtoREConverter( const grammar::RegularGrammar& grammar );
+    AbstractRGtoREConverter( void );
 
-    const grammar::RegularGrammar& m_grammar;
     regexp::RegExp m_re;
 };
 
diff --git a/aconversions/src/rg2re/lrg2re/AbstractLRGtoREConverter.cpp b/aconversions/src/rg2re/lrg2re/AbstractLRGtoREConverter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..10e34c2d20eda3f79c716f373a143bf4358660ff
--- /dev/null
+++ b/aconversions/src/rg2re/lrg2re/AbstractLRGtoREConverter.cpp
@@ -0,0 +1,25 @@
+/*
+ * AbstractLRGtoREConverter.cpp
+ *
+ *  Created on: 16. 3. 2014
+ *      Author: tomas
+ */
+
+#include "AbstractLRGtoREConverter.h"
+
+using namespace grammar;
+
+namespace conversions
+{
+
+AbstractLRGtoREConverter::AbstractLRGtoREConverter( const LeftRegularGrammar & lrg ) : m_grammar( lrg )
+{
+
+}
+
+AbstractLRGtoREConverter::~AbstractLRGtoREConverter( void )
+{
+
+}
+
+} /* namespace conversions */
diff --git a/aconversions/src/rg2re/lrg2re/AbstractLRGtoREConverter.h b/aconversions/src/rg2re/lrg2re/AbstractLRGtoREConverter.h
new file mode 100644
index 0000000000000000000000000000000000000000..67c2620ae2bb0ee29c0e6b72f323a7d39a5ba2b9
--- /dev/null
+++ b/aconversions/src/rg2re/lrg2re/AbstractLRGtoREConverter.h
@@ -0,0 +1,30 @@
+/*
+ * AbstractLRGtoREConverter.h
+ *
+ *  Created on: 16. 3. 2014
+ *      Author: tomas
+ */
+
+#ifndef ABSTRACTLRGTORECONVERTER_H_
+#define ABSTRACTLRGTORECONVERTER_H_
+
+#include <grammar/Regular/LeftRegularGrammar.h>
+
+#include "../AbstractRGtoREConverter.h"
+
+namespace conversions
+{
+
+class AbstractLRGtoREConverter: public AbstractRGtoREConverter
+{
+public:
+    virtual ~AbstractLRGtoREConverter( void );
+
+protected:
+    AbstractLRGtoREConverter( const grammar::LeftRegularGrammar & lrg );
+    const grammar::LeftRegularGrammar & m_grammar;
+};
+
+} /* namespace conversions */
+
+#endif /* ABSTRACTLRGTORECONVERTER_H_ */
diff --git a/aconversions/src/rg2re/LRGAlgebraic.cpp b/aconversions/src/rg2re/lrg2re/LRGAlgebraic.cpp
similarity index 97%
rename from aconversions/src/rg2re/LRGAlgebraic.cpp
rename to aconversions/src/rg2re/lrg2re/LRGAlgebraic.cpp
index 909a47320af903155549af01def8b134af181fe4..deb33731f0cf1fcdc59ab89e85bba7951562c887 100644
--- a/aconversions/src/rg2re/LRGAlgebraic.cpp
+++ b/aconversions/src/rg2re/lrg2re/LRGAlgebraic.cpp
@@ -14,7 +14,7 @@ using namespace regexp;
 namespace conversions
 {
 
-LRGAlgebraic::LRGAlgebraic( const LeftRegularGrammar & rg ) : AbstractRGtoREConverter( rg )
+LRGAlgebraic::LRGAlgebraic( const LeftRegularGrammar & rg ) : AbstractLRGtoREConverter( rg )
 {
 
 }
diff --git a/aconversions/src/rg2re/LRGAlgebraic.h b/aconversions/src/rg2re/lrg2re/LRGAlgebraic.h
similarity index 64%
rename from aconversions/src/rg2re/LRGAlgebraic.h
rename to aconversions/src/rg2re/lrg2re/LRGAlgebraic.h
index e1cec275f6373127262f93d59cd6229c5dc7eddf..e0abf34ada5a77b763fd7fd90aed6e1d0fa8ff57 100644
--- a/aconversions/src/rg2re/LRGAlgebraic.h
+++ b/aconversions/src/rg2re/lrg2re/LRGAlgebraic.h
@@ -8,16 +8,13 @@
 #ifndef LRGALGEBRAIC_H_
 #define LRGALGEBRAIC_H_
 
-#include <grammar/Regular/LeftRegularGrammar.h>
-#include <regexp/RegExp.h>
-
-#include "../shared/equations/LeftRegularEquationSolver.h"
-#include "AbstractRGtoREConverter.h"
+#include "../../shared/equations/LeftRegularEquationSolver.h"
+#include "AbstractLRGtoREConverter.h"
 
 namespace conversions
 {
 
-class LRGAlgebraic: public AbstractRGtoREConverter
+class LRGAlgebraic: public AbstractLRGtoREConverter
 {
 public:
     LRGAlgebraic( const grammar::LeftRegularGrammar & rg );
diff --git a/aconversions/src/rg2re/rrg2re/AbstractRRGtoREConverter.cpp b/aconversions/src/rg2re/rrg2re/AbstractRRGtoREConverter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0a3c41ad1041a5f3772ccdc1e2f0623ff51cf325
--- /dev/null
+++ b/aconversions/src/rg2re/rrg2re/AbstractRRGtoREConverter.cpp
@@ -0,0 +1,25 @@
+/*
+ * AbstractRRGtoREConverter.cpp
+ *
+ *  Created on: 16. 3. 2014
+ *      Author: tomas
+ */
+
+#include "AbstractRRGtoREConverter.h"
+
+using namespace grammar;
+
+namespace conversions
+{
+
+AbstractRRGtoREConverter::AbstractRRGtoREConverter( const RightRegularGrammar & rrg ) : m_grammar( rrg )
+{
+
+}
+
+AbstractRRGtoREConverter::~AbstractRRGtoREConverter( void )
+{
+
+}
+
+} /* namespace conversions */
diff --git a/aconversions/src/rg2re/rrg2re/AbstractRRGtoREConverter.h b/aconversions/src/rg2re/rrg2re/AbstractRRGtoREConverter.h
new file mode 100644
index 0000000000000000000000000000000000000000..2dea0db5181c9ce5f97d6f27e6677d3ae52e8cb8
--- /dev/null
+++ b/aconversions/src/rg2re/rrg2re/AbstractRRGtoREConverter.h
@@ -0,0 +1,31 @@
+/*
+ * AbstractRRGtoREConverter.h
+ *
+ *  Created on: 16. 3. 2014
+ *      Author: tomas
+ */
+
+#ifndef ABSTRACTRRGTORECONVERTER_H_
+#define ABSTRACTRRGTORECONVERTER_H_
+
+#include <grammar/Regular/RightRegularGrammar.h>
+
+#include "../AbstractRGtoREConverter.h"
+
+namespace conversions
+{
+
+class AbstractRRGtoREConverter: public AbstractRGtoREConverter
+{
+public:
+    virtual ~AbstractRRGtoREConverter( void );
+
+protected:
+    AbstractRRGtoREConverter( const grammar::RightRegularGrammar & rrg );
+
+    const grammar::RightRegularGrammar & m_grammar;
+};
+
+} /* namespace conversions */
+
+#endif /* ABSTRACTRRGTORECONVERTER_H_ */
diff --git a/aconversions/src/rg2re/RRGAlgebraic.cpp b/aconversions/src/rg2re/rrg2re/RRGAlgebraic.cpp
similarity index 97%
rename from aconversions/src/rg2re/RRGAlgebraic.cpp
rename to aconversions/src/rg2re/rrg2re/RRGAlgebraic.cpp
index d0f7cbdf4fc328eaa3d1821f623b610cabbdb91b..87a2b7a2d543853b9b4b37353ddba0e208abf7cf 100644
--- a/aconversions/src/rg2re/RRGAlgebraic.cpp
+++ b/aconversions/src/rg2re/rrg2re/RRGAlgebraic.cpp
@@ -14,7 +14,7 @@ using namespace regexp;
 namespace conversions
 {
 
-RRGAlgebraic::RRGAlgebraic( const RightRegularGrammar & rg ) : AbstractRGtoREConverter( rg )
+RRGAlgebraic::RRGAlgebraic( const RightRegularGrammar & rg ) : AbstractRRGtoREConverter( rg )
 {
 
 }
diff --git a/aconversions/src/rg2re/RRGAlgebraic.h b/aconversions/src/rg2re/rrg2re/RRGAlgebraic.h
similarity index 64%
rename from aconversions/src/rg2re/RRGAlgebraic.h
rename to aconversions/src/rg2re/rrg2re/RRGAlgebraic.h
index b1f59bba91ca9da5074fb557e8a0a9a44cc0a1ce..85b907effbd71e9f2f4c0f52f1e1d75d1ff7f1b3 100644
--- a/aconversions/src/rg2re/RRGAlgebraic.h
+++ b/aconversions/src/rg2re/rrg2re/RRGAlgebraic.h
@@ -8,16 +8,13 @@
 #ifndef RRGALGEBRAIC_H_
 #define RRGALGEBRAIC_H_
 
-#include <grammar/Regular/RightRegularGrammar.h>
-#include <regexp/RegExp.h>
-
-#include "../shared/equations/RightRegularEquationSolver.h"
-#include "AbstractRGtoREConverter.h"
+#include "../../shared/equations/RightRegularEquationSolver.h"
+#include "AbstractRRGtoREConverter.h"
 
 namespace conversions
 {
 
-class RRGAlgebraic: public AbstractRGtoREConverter
+class RRGAlgebraic: public AbstractRRGtoREConverter
 {
 public:
     RRGAlgebraic( const grammar::RightRegularGrammar & rg );