Index: doc/groups.dox
===================================================================
--- doc/groups.dox	(revision 1221)
+++ doc/groups.dox	(revision 1254)
@@ -498,5 +498,5 @@
 time is exponential.
 Both \ref KarpMmc "Karp" and \ref HartmannOrlinMmc "Hartmann-Orlin" algorithms
-run in time O(ne) and use space O(n<sup>2</sup>+e).
+run in time O(nm) and use space O(n<sup>2</sup>+m).
 */
 
Index: lemon/bellman_ford.h
===================================================================
--- lemon/bellman_ford.h	(revision 1250)
+++ lemon/bellman_ford.h	(revision 1254)
@@ -150,5 +150,5 @@
   /// This class provides an efficient implementation of the Bellman-Ford
   /// algorithm. The maximum time complexity of the algorithm is
-  /// <tt>O(ne)</tt>.
+  /// <tt>O(nm)</tt>.
   ///
   /// The Bellman-Ford algorithm solves the single-source shortest path
Index: lemon/capacity_scaling.h
===================================================================
--- lemon/capacity_scaling.h	(revision 1250)
+++ lemon/capacity_scaling.h	(revision 1254)
@@ -70,5 +70,5 @@
   /// \cite edmondskarp72theoretical. It is an efficient dual
   /// solution method, which runs in polynomial time
-  /// \f$O(e\log U (n+e)\log n)\f$, where <i>U</i> denotes the maximum
+  /// \f$O(m\log U (n+m)\log n)\f$, where <i>U</i> denotes the maximum
   /// of node supply and arc capacity values.
   ///
@@ -647,5 +647,5 @@
     ///
     /// This function returns the total cost of the found flow.
-    /// Its complexity is O(e).
+    /// Its complexity is O(m).
     ///
     /// \note The return type of the function can be specified as a
Index: lemon/core.h
===================================================================
--- lemon/core.h	(revision 1253)
+++ lemon/core.h	(revision 1239)
@@ -39,10 +39,4 @@
 
 #ifdef __GNUC__
-#define GCC_VERSION (__GNUC__ * 10000                   \
-                     + __GNUC_MINOR__ * 100             \
-                     + __GNUC_PATCHLEVEL__)
-#endif
-
-#if GCC_VERSION >= 40800
 // Needed by the [DI]GRAPH_TYPEDEFS marcos for gcc 4.8
 #pragma GCC diagnostic ignored "-Wunused-local-typedefs"
Index: lemon/cost_scaling.h
===================================================================
--- lemon/cost_scaling.h	(revision 1250)
+++ lemon/cost_scaling.h	(revision 1254)
@@ -98,5 +98,5 @@
   /// "preflow push-relabel" algorithm for the maximum flow problem.
   /// It is a polynomial algorithm, its running time complexity is
-  /// \f$O(n^2e\log(nK))\f$, where <i>K</i> denotes the maximum arc cost.
+  /// \f$O(n^2m\log(nK))\f$, where <i>K</i> denotes the maximum arc cost.
   ///
   /// In general, \ref NetworkSimplex and \ref CostScaling are the fastest
@@ -671,5 +671,5 @@
     ///
     /// This function returns the total cost of the found flow.
-    /// Its complexity is O(e).
+    /// Its complexity is O(m).
     ///
     /// \note The return type of the function can be specified as a
Index: lemon/cycle_canceling.h
===================================================================
--- lemon/cycle_canceling.h	(revision 1241)
+++ lemon/cycle_canceling.h	(revision 1254)
@@ -52,5 +52,5 @@
   /// The most efficent one is the \ref CANCEL_AND_TIGHTEN
   /// "Cancel-and-Tighten" algorithm, thus it is the default method.
-  /// It runs in strongly polynomial time O(n<sup>2</sup>e<sup>2</sup>log(n)),
+  /// It runs in strongly polynomial time O(n<sup>2</sup>m<sup>2</sup>log(n)),
   /// but in practice, it is typically orders of magnitude slower than
   /// the scaling algorithms and \ref NetworkSimplex.
@@ -134,5 +134,5 @@
       /// \cite goldberg89cyclecanceling. It improves along a
       /// \ref min_mean_cycle "minimum mean cycle" in each iteration.
-      /// Its running time complexity is O(n<sup>2</sup>e<sup>3</sup>log(n)).
+      /// Its running time complexity is O(n<sup>2</sup>m<sup>3</sup>log(n)).
       MINIMUM_MEAN_CYCLE_CANCELING,
       /// The "Cancel-and-Tighten" algorithm, which can be viewed as an
@@ -140,5 +140,5 @@
       /// \cite goldberg89cyclecanceling.
       /// It is faster both in theory and in practice, its running time
-      /// complexity is O(n<sup>2</sup>e<sup>2</sup>log(n)).
+      /// complexity is O(n<sup>2</sup>m<sup>2</sup>log(n)).
       CANCEL_AND_TIGHTEN
     };
@@ -577,5 +577,5 @@
     ///
     /// This function returns the total cost of the found flow.
-    /// Its complexity is O(e).
+    /// Its complexity is O(m).
     ///
     /// \note The return type of the function can be specified as a
Index: lemon/gomory_hu.h
===================================================================
--- lemon/gomory_hu.h	(revision 956)
+++ lemon/gomory_hu.h	(revision 1254)
@@ -47,5 +47,5 @@
   ///
   /// The algorithm calculates \e n-1 distinct minimum cuts (currently with
-  /// the \ref Preflow algorithm), thus it has \f$O(n^3\sqrt{e})\f$ overall
+  /// the \ref Preflow algorithm), thus it has \f$O(n^3\sqrt{m})\f$ overall
   /// time complexity. It calculates a rooted Gomory-Hu tree.
   /// The structure of the tree and the edge weights can be
Index: lemon/graph_to_eps.h
===================================================================
--- lemon/graph_to_eps.h	(revision 1249)
+++ lemon/graph_to_eps.h	(revision 1159)
@@ -223,5 +223,5 @@
   using T::_copyright;
 
-  using T::NodeTextColorType;
+  using typename T::NodeTextColorType;
   using T::CUST_COL;
   using T::DIST_COL;
Index: lemon/hartmann_orlin_mmc.h
===================================================================
--- lemon/hartmann_orlin_mmc.h	(revision 1250)
+++ lemon/hartmann_orlin_mmc.h	(revision 1254)
@@ -103,5 +103,5 @@
   /// applies an early termination scheme. It makes the algorithm
   /// significantly faster for some problem instances, but slower for others.
-  /// The algorithm runs in time O(ne) and uses space O(n<sup>2</sup>+e).
+  /// The algorithm runs in time O(nm) and uses space O(n<sup>2</sup>+m).
   ///
   /// \tparam GR The type of the digraph the algorithm runs on.
Index: lemon/karp_mmc.h
===================================================================
--- lemon/karp_mmc.h	(revision 1250)
+++ lemon/karp_mmc.h	(revision 1254)
@@ -100,5 +100,5 @@
   /// cycle of minimum mean cost in a digraph
   /// \cite karp78characterization, \cite dasdan98minmeancycle.
-  /// It runs in time O(ne) and uses space O(n<sup>2</sup>+e).
+  /// It runs in time O(nm) and uses space O(n<sup>2</sup>+m).
   ///
   /// \tparam GR The type of the digraph the algorithm runs on.
Index: lemon/lp_base.h
===================================================================
--- lemon/lp_base.h	(revision 1252)
+++ lemon/lp_base.h	(revision 1250)
@@ -1008,5 +1008,5 @@
   public:
 
-    ///Unsupported file format exception
+    ///\e \ 
     class UnsupportedFormatError : public Exception
     {
Index: lemon/min_cost_arborescence.h
===================================================================
--- lemon/min_cost_arborescence.h	(revision 1250)
+++ lemon/min_cost_arborescence.h	(revision 1254)
@@ -102,5 +102,5 @@
   /// the minimum cost subgraph that is the union of arborescences with the
   /// given sources and spans all the nodes which are reachable from the
-  /// sources. The time complexity of the algorithm is O(n<sup>2</sup>+e).
+  /// sources. The time complexity of the algorithm is O(n<sup>2</sup>+m).
   ///
   /// The algorithm also provides an optimal dual solution, therefore
Index: lemon/network_simplex.h
===================================================================
--- lemon/network_simplex.h	(revision 1241)
+++ lemon/network_simplex.h	(revision 1254)
@@ -974,5 +974,5 @@
     ///
     /// This function returns the total cost of the found flow.
-    /// Its complexity is O(e).
+    /// Its complexity is O(m).
     ///
     /// \note The return type of the function can be specified as a
Index: lemon/preflow.h
===================================================================
--- lemon/preflow.h	(revision 1250)
+++ lemon/preflow.h	(revision 1254)
@@ -108,5 +108,5 @@
   /// flow algorithms. The current implementation uses a mixture of the
   /// \e "highest label" and the \e "bound decrease" heuristics.
-  /// The worst case time complexity of the algorithm is \f$O(n^2\sqrt{e})\f$.
+  /// The worst case time complexity of the algorithm is \f$O(n^2\sqrt{m})\f$.
   ///
   /// The algorithm consists of two phases. After the first phase
Index: lemon/suurballe.h
===================================================================
--- lemon/suurballe.h	(revision 1250)
+++ lemon/suurballe.h	(revision 1254)
@@ -683,5 +683,5 @@
     /// This function returns the total length of the found paths, i.e.
     /// the total cost of the found flow.
-    /// The complexity of the function is O(e).
+    /// The complexity of the function is O(m).
     ///
     /// \pre \ref run() or \ref findFlow() must be called before using
Index: test/lp_test.cc
===================================================================
--- test/lp_test.cc	(revision 1247)
+++ test/lp_test.cc	(revision 1232)
@@ -199,10 +199,5 @@
       c = c <= 4;
       LP::Constr c2;
-#if ( __GNUC__ == 4 ) && ( __GNUC_MINOR__ == 3 )
-      c2 = ( -3 <= v ) <= 4;
-#else
       c2 = -3 <= v <= 4;
-#endif
-
     }
 
