Index: lemon/bellman_ford.h
===================================================================
--- lemon/bellman_ford.h	(revision 1875)
+++ lemon/bellman_ford.h	(revision 1946)
@@ -545,9 +545,9 @@
     ///
     /// \note d.run(s) is just a shortcut of the following code.
-    /// \code
+    ///\code
     ///  d.init();
     ///  d.addSource(s);
     ///  d.start();
-    /// \endcode
+    ///\endcode
     void run(Node s) {
       init();
@@ -566,9 +566,9 @@
     ///
     /// \note d.run(s, len) is just a shortcut of the following code.
-    /// \code
+    ///\code
     ///  d.init();
     ///  d.addSource(s);
     ///  d.limitedStart(len);
-    /// \endcode
+    ///\endcode
     void run(Node s, int len) {
       init();
@@ -929,7 +929,7 @@
   /// The following
   /// example shows how to use these parameters.
-  /// \code
+  ///\code
   /// bellmanford(g,length,source).predMap(preds).run();
-  /// \endcode
+  ///\endcode
   /// \warning Don't forget to put the \ref BellmanFordWizard::run() "run()"
   /// to the end of the parameter list.
Index: lemon/bits/alteration_notifier.h
===================================================================
--- lemon/bits/alteration_notifier.h	(revision 1910)
+++ lemon/bits/alteration_notifier.h	(revision 1946)
@@ -21,5 +21,5 @@
 #include <algorithm>
 
-///\ingroin graphmapfactory
+///\ingroup graphmapfactory
 ///\file
 ///\brief Observer registry for graph alteration observers.
Index: lemon/bits/array_map.h
===================================================================
--- lemon/bits/array_map.h	(revision 1910)
+++ lemon/bits/array_map.h	(revision 1946)
@@ -24,5 +24,5 @@
 #include <lemon/concept/maps.h>
 
-/// \ingroin graphmapfactory
+/// \ingroup graphmapfactory
 /// \file
 /// \brief Graph maps that construct and destruct
@@ -31,5 +31,5 @@
 namespace lemon {
 
-  /// \ingroin graphmapfactory
+  /// \ingroup graphmapfactory
   ///
   /// \brief Graph map based on the array storage.
Index: lemon/bits/default_map.h
===================================================================
--- lemon/bits/default_map.h	(revision 1910)
+++ lemon/bits/default_map.h	(revision 1946)
@@ -22,5 +22,5 @@
 #include <lemon/bits/vector_map.h>
 
-///\ingroin graphmapfactory
+///\ingroup graphmapfactory
 ///\file
 ///\brief Graph maps that construct and destruct
Index: lemon/bits/item_reader.h
===================================================================
--- lemon/bits/item_reader.h	(revision 1910)
+++ lemon/bits/item_reader.h	(revision 1946)
@@ -16,5 +16,5 @@
 
 /// @defgroin item_io Item Readers and Writers
-/// @ingroin io_groin
+/// @ingroup io_groin
 /// \brief Item Readers and Writers
 /// 
@@ -23,5 +23,5 @@
 /// read some way. The module make possible to do this.  
 
-/// \ingroin item_io
+/// \ingroup item_io
 /// \file
 /// \brief Item reader bits for lemon input.
@@ -43,5 +43,5 @@
   class DefaultReader;
 
-  /// \ingroin item_io
+  /// \ingroup item_io
   ///
   /// \brief Reader class for quoted strings.
@@ -158,5 +158,5 @@
   };
 
-  /// \ingroin item_io
+  /// \ingroup item_io
   /// \brief Reader for standard containers.
   ///
@@ -205,5 +205,5 @@
   };
 
-  /// \ingroin item_io
+  /// \ingroup item_io
   ///
   /// \brief Reader for standard containers.
@@ -253,5 +253,5 @@
   };
 
-  /// \ingroin item_io
+  /// \ingroup item_io
   /// \brief Reader for parsed string.
   ///
@@ -301,5 +301,5 @@
   };
 
-  /// \ingroin item_io
+  /// \ingroup item_io
   /// \brief Reader for read the whole line.
   ///
@@ -331,5 +331,5 @@
   };
 
-  /// \ingroin item_io
+  /// \ingroup item_io
   /// \brief Reader for std::pair.
   ///
@@ -385,5 +385,5 @@
   };
 
-  /// \ingroin item_io
+  /// \ingroup item_io
   /// 
   /// \brief The default item reader template class.
@@ -472,5 +472,5 @@
     : public PairReader<std::pair<First, Second> > {};
 
-  /// \ingroin item_io
+  /// \ingroup item_io
   /// 
   /// \brief The default item reader for skipping a value in the stream.
@@ -481,5 +481,5 @@
   class DefaultSkipper : public DefaultReader<std::string> {};
 
-  /// \ingroin item_io  
+  /// \ingroup item_io  
   /// \brief Standard ReaderTraits for the GraphReader class.
   ///
Index: lemon/bits/item_writer.h
===================================================================
--- lemon/bits/item_writer.h	(revision 1910)
+++ lemon/bits/item_writer.h	(revision 1946)
@@ -15,5 +15,5 @@
  */
 
-/// \ingroin item_io
+/// \ingroup item_io
 /// \file
 /// \brief Item writer bits for lemon output.
@@ -35,5 +35,5 @@
   class DefaultWriter;
 
-  /// \ingroin item_io
+  /// \ingroup item_io
   /// \brief Writer class for quoted strings.
   ///
@@ -118,5 +118,5 @@
   };
 
-  /// \ingroin item_io
+  /// \ingroup item_io
   /// \brief Writer class for quoted char array.
   ///
@@ -146,5 +146,5 @@
 
 
-  /// \ingroin item_io
+  /// \ingroup item_io
   ///
   /// \brief Writer for standard containers.
@@ -188,10 +188,10 @@
   };
 
-  /// \ingroin item_io
+  /// \ingroup item_io
   ///
   /// \brief Writer for standard pairs.
   ///
   /// Writer for standard pairs. The representation of a pair is
-  /// \code ( first_value => second_value ) \endcode.
+  ///\code ( first_value => second_value ) \endcode.
   /// \author Balazs Dezso
   template <typename _Pair, 
@@ -235,5 +235,5 @@
   };
 
-  /// \ingroin item_io
+  /// \ingroup item_io
   /// 
   /// \brief The default item writer template class.
@@ -308,5 +308,5 @@
     : public PairWriter<std::pair<First, Second> > {};
 
-  /// \ingroin item_io
+  /// \ingroup item_io
   /// \brief Standard WriterTraits for the section writers.
   ///
Index: lemon/bits/static_map.h
===================================================================
--- lemon/bits/static_map.h	(revision 1910)
+++ lemon/bits/static_map.h	(revision 1946)
@@ -28,5 +28,5 @@
 #include <lemon/concept/maps.h>
 
-/// \ingroin graphmaps
+/// \ingroup graphmaps
 ///
 ///\file
@@ -35,5 +35,5 @@
 namespace lemon {
 
-  /// \ingroin graphmaps
+  /// \ingroup graphmaps
   ///
   /// \brief Graph map with static sized storage.
Index: lemon/bits/vector_map.h
===================================================================
--- lemon/bits/vector_map.h	(revision 1910)
+++ lemon/bits/vector_map.h	(revision 1946)
@@ -27,5 +27,5 @@
 #include <lemon/concept/maps.h>
 
-/// \ingroin graphmapfactory
+/// \ingroup graphmapfactory
 ///
 ///\file
@@ -34,5 +34,5 @@
 namespace lemon {
 
-  /// \ingroin graphmapfactory
+  /// \ingroup graphmapfactory
   ///
   /// \brief Graph map based on the std::vector storage.
Index: lemon/concept/bpugraph.h
===================================================================
--- lemon/concept/bpugraph.h	(revision 1933)
+++ lemon/concept/bpugraph.h	(revision 1946)
@@ -245,8 +245,8 @@
       /// Its usage is quite simple, for example you can count the number
       /// of nodes in graph \c g of type \c Graph like this:
-      /// \code
+      ///\code
       /// int count=0;
       /// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count;
-      /// \endcode
+      ///\endcode
       class NodeIt : public Node {
       public:
@@ -290,8 +290,8 @@
       /// Its usage is quite simple, for example you can count the number
       /// of nodes in graph \c g of type \c Graph like this:
-      /// \code
+      ///\code
       /// int count=0;
       /// for (Graph::ANodeIt n(g); n!=INVALID; ++n) ++count;
-      /// \endcode
+      ///\endcode
       class ANodeIt : public ANode {
       public:
@@ -335,8 +335,8 @@
       /// Its usage is quite simple, for example you can count the number
       /// of nodes in graph \c g of type \c Graph like this:
-      /// \code
+      ///\code
       /// int count=0;
       /// for (Graph::BNodeIt n(g); n!=INVALID; ++n) ++count;
-      /// \endcode
+      ///\endcode
       class BNodeIt : public BNode {
       public:
@@ -426,8 +426,8 @@
       /// Its usage is quite simple, for example you can count the number
       /// of undirected edges in a graph \c g of type \c Graph as follows:
-      /// \code
+      ///\code
       /// int count=0;
       /// for(Graph::UEdgeIt e(g); e!=INVALID; ++e) ++count;
-      /// \endcode
+      ///\endcode
       class UEdgeIt : public UEdge {
       public:
@@ -474,8 +474,8 @@
       /// of incident edges of a node \c n
       /// in graph \c g of type \c Graph as follows.
-      /// \code
+      ///\code
       /// int count=0;
       /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count;
-      /// \endcode
+      ///\endcode
       class IncEdgeIt : public UEdge {
       public:
@@ -563,8 +563,8 @@
       /// Its usage is quite simple, for example you can count the number
       /// of edges in a graph \c g of type \c Graph as follows:
-      /// \code
+      ///\code
       /// int count=0;
       /// for(Graph::EdgeIt e(g); e!=INVALID; ++e) ++count;
-      /// \endcode
+      ///\endcode
       class EdgeIt : public Edge {
       public:
@@ -608,8 +608,8 @@
       /// of outgoing edges of a node \c n
       /// in graph \c g of type \c Graph as follows.
-      /// \code
+      ///\code
       /// int count=0;
       /// for (Graph::OutEdgeIt e(g, n); e!=INVALID; ++e) ++count;
-      /// \endcode
+      ///\endcode
     
       class OutEdgeIt : public Edge {
@@ -660,8 +660,8 @@
       /// of outgoing edges of a node \c n
       /// in graph \c g of type \c Graph as follows.
-      /// \code
+      ///\code
       /// int count=0;
       /// for(Graph::InEdgeIt e(g, n); e!=INVALID; ++e) ++count;
-      /// \endcode
+      ///\endcode
 
       class InEdgeIt : public Edge {
Index: lemon/concept/graph.h
===================================================================
--- lemon/concept/graph.h	(revision 1909)
+++ lemon/concept/graph.h	(revision 1946)
@@ -193,8 +193,8 @@
       /// Its usage is quite simple, for example you can count the number
       /// of nodes in graph \c g of type \c Graph like this:
-      /// \code
+      ///\code
       /// int count=0;
       /// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count;
-      /// \endcode
+      ///\endcode
       class NodeIt : public Node {
       public:
@@ -286,8 +286,8 @@
       /// of outgoing edges of a node \c n
       /// in graph \c g of type \c Graph as follows.
-      /// \code
+      ///\code
       /// int count=0;
       /// for (Graph::OutEdgeIt e(g, n); e!=INVALID; ++e) ++count;
-      /// \endcode
+      ///\endcode
     
       class OutEdgeIt : public Edge {
@@ -333,8 +333,8 @@
       /// of outgoing edges of a node \c n
       /// in graph \c g of type \c Graph as follows.
-      /// \code
+      ///\code
       /// int count=0;
       /// for(Graph::InEdgeIt e(g, n); e!=INVALID; ++e) ++count;
-      /// \endcode
+      ///\endcode
 
       class InEdgeIt : public Edge {
@@ -377,8 +377,8 @@
       /// Its usage is quite simple, for example you can count the number
       /// of edges in a graph \c g of type \c Graph as follows:
-      /// \code
+      ///\code
       /// int count=0;
       /// for(Graph::EdgeIt e(g); e!=INVALID; ++e) ++count;
-      /// \endcode
+      ///\endcode
       class EdgeIt : public Edge {
       public:
Index: lemon/concept/ugraph.h
===================================================================
--- lemon/concept/ugraph.h	(revision 1910)
+++ lemon/concept/ugraph.h	(revision 1946)
@@ -305,8 +305,8 @@
       /// Its usage is quite simple, for example you can count the number
       /// of nodes in graph \c g of type \c Graph like this:
-      /// \code
+      ///\code
       /// int count=0;
       /// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count;
-      /// \endcode
+      ///\endcode
       class NodeIt : public Node {
       public:
@@ -396,8 +396,8 @@
       /// Its usage is quite simple, for example you can count the number
       /// of undirected edges in a graph \c g of type \c Graph as follows:
-      /// \code
+      ///\code
       /// int count=0;
       /// for(Graph::UEdgeIt e(g); e!=INVALID; ++e) ++count;
-      /// \endcode
+      ///\endcode
       class UEdgeIt : public UEdge {
       public:
@@ -444,8 +444,8 @@
       /// of incident edges of a node \c n
       /// in graph \c g of type \c Graph as follows.
-      /// \code
+      ///\code
       /// int count=0;
       /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count;
-      /// \endcode
+      ///\endcode
       class IncEdgeIt : public UEdge {
       public:
@@ -533,8 +533,8 @@
       /// Its usage is quite simple, for example you can count the number
       /// of edges in a graph \c g of type \c Graph as follows:
-      /// \code
+      ///\code
       /// int count=0;
       /// for(Graph::EdgeIt e(g); e!=INVALID; ++e) ++count;
-      /// \endcode
+      ///\endcode
       class EdgeIt : public Edge {
       public:
@@ -578,8 +578,8 @@
       /// of outgoing edges of a node \c n
       /// in graph \c g of type \c Graph as follows.
-      /// \code
+      ///\code
       /// int count=0;
       /// for (Graph::OutEdgeIt e(g, n); e!=INVALID; ++e) ++count;
-      /// \endcode
+      ///\endcode
     
       class OutEdgeIt : public Edge {
@@ -630,8 +630,8 @@
       /// of outgoing edges of a node \c n
       /// in graph \c g of type \c Graph as follows.
-      /// \code
+      ///\code
       /// int count=0;
       /// for(Graph::InEdgeIt e(g, n); e!=INVALID; ++e) ++count;
-      /// \endcode
+      ///\endcode
 
       class InEdgeIt : public Edge {
Index: lemon/dag_shortest_path.h
===================================================================
--- lemon/dag_shortest_path.h	(revision 1912)
+++ lemon/dag_shortest_path.h	(revision 1946)
@@ -117,5 +117,6 @@
     /// 
     /// This function instantiates a \ref PredMap. 
-    /// \param G is the graph, to which we would like to define the PredMap.
+    /// \param graph is the graph, to which we would
+    /// like to define the PredMap.
     /// \todo The graph alone may be insufficient for the initialization
     static PredMap *createPredMap(const _Graph& graph) {
@@ -134,5 +135,5 @@
     ///
     /// This function instantiates a \ref DistMap. 
-    /// \param G is the graph, to which we would like to define the 
+    /// \param graph is the graph, to which we would like to define the 
     /// \ref DistMap
     static DistMap *createDistMap(const _Graph& graph) {
@@ -228,5 +229,6 @@
     /// 
     /// This function instantiates a \ref PredMap. 
-    /// \param G is the graph, to which we would like to define the PredMap.
+    /// \param graph is the graph,
+    /// to which we would like to define the PredMap.
     /// \todo The graph alone may be insufficient for the initialization
     static PredMap *createPredMap(const _Graph& graph) {
@@ -245,5 +247,5 @@
     ///
     /// This function instantiates a \ref DistMap. 
-    /// \param G is the graph, to which we would like to define the 
+    /// \param graph is the graph, to which we would like to define the 
     /// \ref DistMap
     static DistMap *createDistMap(const _Graph& graph) {
@@ -682,9 +684,9 @@
     ///
     /// \note d.run(s) is just a shortcut of the following code.
-    /// \code
+    ///\code
     ///  d.init();
     ///  d.addSource(s);
     ///  d.start();
-    /// \endcode
+    ///\endcode
     void run(Node s) {
       init();
@@ -978,5 +980,5 @@
     ///
     /// Runs DagShortestPath algorithm from the given node.
-    /// \param s is the given source.
+    /// \param source is the given source.
     void run(Node source) {
       Base::_source = source;
@@ -1043,5 +1045,5 @@
     ///
     /// Sets the source node, from which the DagShortestPath algorithm runs.
-    /// \param s is the source node.
+    /// \param source is the source node.
     DagShortestPathWizard<_Traits>& source(Node source) {
       Base::_source = source;
@@ -1061,7 +1063,7 @@
   /// The following
   /// example shows how to use these parameters.
-  /// \code
+  ///\code
   /// dagShortestPath(g,length,source).predMap(preds).run();
-  /// \endcode
+  ///\endcode
   /// \warning Don't forget to put the \ref DagShortestPathWizard::run() "run()"
   /// to the end of the parameter list.
Index: lemon/dfs.h
===================================================================
--- lemon/dfs.h	(revision 1875)
+++ lemon/dfs.h	(revision 1946)
@@ -1443,9 +1443,9 @@
     /// This method runs the %DFS algorithm from a root node \c s.
     /// \note d.run(s) is just a shortcut of the following code.
-    /// \code
+    ///\code
     ///   d.init();
     ///   d.addSource(s);
     ///   d.start();
-    /// \endcode
+    ///\endcode
     void run(Node s) {
       init();
Index: lemon/dimacs.h
===================================================================
--- lemon/dimacs.h	(revision 1875)
+++ lemon/dimacs.h	(revision 1946)
@@ -45,7 +45,7 @@
   /// This function reads a min cost flow instance from dimacs format,
   /// i.e. from dimacs files having a line starting with
-  /// \code
+  ///\code
   /// p "min"
-  /// \endcode
+  ///\endcode
   /// At the beginning \c g is cleared by \c g.clear(). The edge
   /// capacities are written to \c capacity, \c s and \c t are set to
@@ -125,7 +125,7 @@
   /// This function reads a max flow instance from dimacs format,
   /// i.e. from dimacs files having a line starting with
-  /// \code
+  ///\code
   /// p "max"
-  /// \endcode
+  ///\endcode
   ///At the beginning \c g is cleared by \c g.clear(). The
   /// edge capacities are written to \c capacity and \c s and \c t are
@@ -145,7 +145,7 @@
   /// This function reads a shortest path instance from dimacs format,
   /// i.e. from dimacs files having a line starting with
-  /// \code
+  ///\code
   /// p "sp"
-  /// \endcode
+  ///\endcode
   /// At the beginning \c g is cleared by \c g.clear(). The edge
   /// capacities are written to \c capacity and \c s is set to the
@@ -181,7 +181,7 @@
   /// maps from dimacs format, i.e. from dimacs files having a line
   /// starting with
-  /// \code
+  ///\code
   /// p "mat"
-  /// \endcode
+  ///\endcode
   /// At the beginning \c g is cleared
   /// by \c g.clear().
Index: lemon/floyd_warshall.h
===================================================================
--- lemon/floyd_warshall.h	(revision 1875)
+++ lemon/floyd_warshall.h	(revision 1946)
@@ -118,5 +118,6 @@
     /// 
     /// This function instantiates a \ref PredMap. 
-    /// \param G is the graph, to which we would like to define the PredMap.
+    /// \param graph is the graph,
+    /// to which we would like to define the PredMap.
     /// \todo The graph alone may be insufficient for the initialization
     static PredMap *createPredMap(const _Graph& graph) {
@@ -134,5 +135,5 @@
     ///
     /// This function instantiates a \ref DistMap. 
-    /// \param G is the graph, to which we would like to define the 
+    /// \param graph is the graph, to which we would like to define the 
     /// \ref DistMap
     static DistMap *createDistMap(const _Graph& graph) {
@@ -455,8 +456,8 @@
     ///
     /// \note d.run(s) is just a shortcut of the following code.
-    /// \code
+    ///\code
     ///  d.init();
     ///  d.start();
-    /// \endcode
+    ///\endcode
     void run() {
       init();
Index: lemon/fredman_tarjan.h
===================================================================
--- lemon/fredman_tarjan.h	(revision 1912)
+++ lemon/fredman_tarjan.h	(revision 1946)
@@ -66,5 +66,5 @@
 
     ///This function instantiates a \ref TreeMap.
-    ///\param g is the graph, to which
+    ///\param _graph is the graph, to which
     ///we would like to define the \ref TreeMap
     static TreeMap *createTreeMap(const GR &_graph){
Index: lemon/graph_adaptor.h
===================================================================
--- lemon/graph_adaptor.h	(revision 1909)
+++ lemon/graph_adaptor.h	(revision 1946)
@@ -189,7 +189,7 @@
   /// suppose that a graph instange \c g of type 
   /// \c ListGraph implements \f$G\f$.
-  /// \code
+  ///\code
   /// ListGraph g;
-  /// \endcode
+  ///\endcode
   /// For each directed edge 
   /// \f$e\in A\f$, let \f$\bar e\f$ denote the edge obtained by 
@@ -200,8 +200,9 @@
   /// reversing the orientation of its edges. The following code shows how 
   /// such an instance can be constructed.
-  /// \code
+  ///\code
   /// RevGraphAdaptor<ListGraph> gw(g);
-  /// \endcode
+  ///\endcode
   ///\author Marton Makai
+
   template<typename _Graph>
   class RevGraphAdaptor : 
@@ -1279,16 +1280,16 @@
   /// For blocking flows.
 
-  ///\warning Graph adaptors are in even more experimental state than the other
+  ///\warning Graph adaptors are in even more
+  ///experimental state than the other
   ///parts of the lib. Use them at you own risk.
   ///
-  /// This graph adaptor is used for on-the-fly 
-  /// Dinits blocking flow computations.
-  /// For each node, an out-edge is stored which is used when the 
-  /// \code 
-  /// OutEdgeIt& first(OutEdgeIt&, const Node&)
-  /// \endcode
-  /// is called. 
+  ///This graph adaptor is used for on-the-fly 
+  ///Dinits blocking flow computations.
+  ///For each node, an out-edge is stored which is used when the 
+  ///\code OutEdgeIt& first(OutEdgeIt&, const Node&)\endcode
+  ///is called. 
   ///
-  /// \author Marton Makai
+  ///\author Marton Makai
+  ///
   template <typename _Graph, typename FirstOutEdgesMap>
   class ErasingFirstGraphAdaptor : 
Index: lemon/graph_reader.h
===================================================================
--- lemon/graph_reader.h	(revision 1935)
+++ lemon/graph_reader.h	(revision 1946)
@@ -55,7 +55,7 @@
   /// it should skip the values when the string representation contains spaces.
   ///
-  /// \code
+  ///\code
   /// GraphReader<ListGraph> reader(std::cin, graph);
-  /// \endcode
+  ///\endcode
   ///
   /// The \c readNodeMap() function reads a map from the \c \@nodeset section.
@@ -65,5 +65,5 @@
   /// parameters.
   ///
-  /// \code
+  ///\code
   /// reader.readNodeMap("coords", coords);
   ///
@@ -71,23 +71,23 @@
   ///
   /// reader.readNodeMap("color", colorMap);
-  /// \endcode
+  ///\endcode
   ///
   /// With the \c readEdgeMap() member function you can give an edge map
   /// reading command similar to the NodeMaps. 
   ///
-  /// \code
+  ///\code
   /// reader.readEdgeMap("weight", weightMap);
   /// reader.readEdgeMap("label", labelMap);
-  /// \endcode
+  ///\endcode
   ///
   /// With \c readNode() and \c readEdge() functions you can read 
   /// labeled Nodes and Edges.
   ///
-  /// \code
+  ///\code
   /// reader.readNode("source", sourceNode);
   /// reader.readNode("target", targetNode);
   ///
   /// reader.readEdge("observed", edge);
-  /// \endcode
+  ///\endcode
   ///
   /// With the \c readAttribute() functions you can read an attribute
@@ -98,7 +98,7 @@
   /// function, which executes all the commands.
   ///
-  /// \code
+  ///\code
   /// reader.run();
-  /// \endcode
+  ///\endcode
   ///
   /// \see DefaultReaderTraits
@@ -399,7 +399,7 @@
   /// it should skip the values when the string representation contains spaces.
   ///
-  /// \code
+  ///\code
   /// UGraphReader<ListUGraph> reader(std::cin, graph);
-  /// \endcode
+  ///\endcode
   ///
   /// The \c readNodeMap() function reads a map from the \c \@nodeset section.
@@ -409,5 +409,5 @@
   /// parameters.
   ///
-  /// \code
+  ///\code
   /// reader.readNodeMap("coords", coords);
   ///
@@ -415,12 +415,12 @@
   ///
   /// reader.readNodeMap("color", colorMap);
-  /// \endcode
+  ///\endcode
   ///
   /// With the \c readUEdgeMap() member function you can give an 
   /// uedge map reading command similar to the NodeMaps. 
   ///
-  /// \code
+  ///\code
   /// reader.readUEdgeMap("capacity", capacityMap);
-  /// \endcode
+  ///\endcode
   ///
   /// The reading of the directed edge maps is just a syntactical sugar.
@@ -429,17 +429,17 @@
   /// \c '-' character and the same.
   ///
-  /// \code
+  ///\code
   /// reader.readEdgeMap("flow", flowMap);
-  /// \endcode 
+  ///\endcode 
   ///
   /// With \c readNode() and \c readUEdge() functions you can read 
   /// labeled Nodes and UEdges.
   ///
-  /// \code
+  ///\code
   /// reader.readNode("source", sourceNode);
   /// reader.readNode("target", targetNode);
   ///
   /// reader.readUEdge("observed", uEdge);
-  /// \endcode
+  ///\endcode
   ///
   /// With the \c readAttribute() functions you can read an attribute
@@ -450,7 +450,7 @@
   /// function, which execute all the commands.
   ///
-  /// \code
+  ///\code
   /// reader.run();
-  /// \endcode
+  ///\endcode
   ///
   /// \see GraphReader
Index: lemon/graph_utils.h
===================================================================
--- lemon/graph_utils.h	(revision 1931)
+++ lemon/graph_utils.h	(revision 1946)
@@ -259,9 +259,9 @@
   ///
   /// Thus you can iterate through each edge from \c u to \c v as it follows.
-  /// \code
+  ///\code
   /// for(Edge e=findEdge(g,u,v);e!=INVALID;e=findEdge(g,u,v,e)) {
   ///   ...
   /// }
-  /// \endcode
+  ///\endcode
   // /// \todo We may want to use the "GraphBase" 
   // /// interface here...
@@ -279,9 +279,9 @@
   /// higher level interface for the findEdge() function. You can
   /// use it the following way:
-  /// \code
+  ///\code
   /// for (ConEdgeIt<Graph> it(g, src, trg); it != INVALID; ++it) {
   ///   ...
   /// }
-  /// \endcode
+  ///\endcode
   ///
   /// \author Balazs Dezso 
@@ -361,10 +361,10 @@
   ///
   /// Thus you can iterate through each edge from \c u to \c v as it follows.
-  /// \code
+  ///\code
   /// for(UEdge e = findUEdge(g,u,v); e != INVALID; 
   ///     e = findUEdge(g,u,v,e)) {
   ///   ...
   /// }
-  /// \endcode
+  ///\endcode
   // /// \todo We may want to use the "GraphBase" 
   // /// interface here...
@@ -383,9 +383,9 @@
   /// higher level interface for the findUEdge() function. You can
   /// use it the following way:
-  /// \code
+  ///\code
   /// for (ConUEdgeIt<Graph> it(g, src, trg); it != INVALID; ++it) {
   ///   ...
   /// }
-  /// \endcode
+  ///\endcode
   ///
   /// \author Balazs Dezso 
@@ -581,7 +581,7 @@
   /// The usage of the function:
   /// 
-  /// \code
+  ///\code
   /// copyGraph(trg, src).nodeRef(nr).edgeCrossRef(ecr);
-  /// \endcode
+  ///\endcode
   /// 
   /// After the copy the \c nr map will contain the mapping from the
@@ -793,7 +793,7 @@
   /// The usage of the function:
   /// 
-  /// \code
+  ///\code
   /// copyGraph(trg, src).nodeRef(nr).edgeCrossRef(ecr);
-  /// \endcode
+  ///\endcode
   /// 
   /// After the copy the \c nr map will contain the mapping from the
Index: lemon/graph_writer.h
===================================================================
--- lemon/graph_writer.h	(revision 1909)
+++ lemon/graph_writer.h	(revision 1946)
@@ -48,7 +48,7 @@
   /// Edge writing.
   ///
-  /// \code
+  ///\code
   /// GraphWriter<ListGraph> writer(std::cout, graph);
-  /// \endcode
+  ///\endcode
   ///
   /// The \c writeNodeMap() function declares a \c NodeMap writing 
@@ -58,5 +58,5 @@
   /// is regarded as label map (such a map is essential if the graph has edges).
   ///
-  /// \code
+  ///\code
   /// IdMap<ListGraph, Node> nodeLabelMap;
   /// writer.writeNodeMap("label", nodeLabelMap);
@@ -64,10 +64,10 @@
   /// writer.writeNodeMap("coords", coords);
   /// writer.writeNodeMap("color", colorMap);
-  /// \endcode
+  ///\endcode
   ///
   /// With the \c writeEdgeMap() member function you can give an edge map
   /// writing command similar to the NodeMaps.
   ///
-  /// \code
+  ///\code
   /// DescriptorMap<ListGraph, Edge, ListGraph::EdgeMap<int> > 
   ///   edgeDescMap(graph);
@@ -76,5 +76,5 @@
   /// writer.writeEdgeMap("weight", weightMap);
   /// writer.writeEdgeMap("label", labelMap);
-  /// \endcode
+  ///\endcode
   ///
   /// With \c writeNode() and \c writeEdge() functions you can 
@@ -82,17 +82,17 @@
   /// write out the source and target of a maximum flow instance.
   ///
-  /// \code
+  ///\code
   /// writer.writeNode("source", sourceNode);
   /// writer.writeNode("target", targetNode);
   ///
   /// writer.writeEdge("observed", edge);
-  /// \endcode
+  ///\endcode
   ///
   /// After you give all write commands you must call the \c run() member
   /// function, which executes all the writing commands.
   ///
-  /// \code
+  ///\code
   /// writer.run();
-  /// \endcode
+  ///\endcode
   ///
   /// \see DefaultWriterTraits
@@ -321,7 +321,7 @@
   /// writing and labeled Node, Edge or UEdge writing.
   ///
-  /// \code
+  ///\code
   /// UGraphWriter<ListUGraph> writer(std::cout, graph);
-  /// \endcode
+  ///\endcode
   ///
   /// The \c writeNodeMap() function declares a \c NodeMap writing 
@@ -331,5 +331,5 @@
   /// is regarded as label map.
   ///
-  /// \code
+  ///\code
   /// IdMap<ListUGraph, Node> nodeLabelMap;
   /// writer.writeNodeMap("label", nodeLabelMap);
@@ -337,10 +337,10 @@
   /// writer.writeNodeMap("coords", coords);
   /// writer.writeNodeMap("color", colorMap);
-  /// \endcode
+  ///\endcode
   ///
   /// With the \c writeUEdgeMap() member function you can give an 
   /// undirected edge map writing command similar to the NodeMaps.
   ///
-  /// \code
+  ///\code
   /// DescriptorMap<ListGraph, Edge, ListGraph::EdgeMap<int> > 
   ///   edgeDescMap(graph);
@@ -349,12 +349,12 @@
   /// writer.writeUEdgeMap("weight", weightMap);
   /// writer.writeUEdgeMap("label", labelMap);
-  /// \endcode
+  ///\endcode
   /// 
   /// The EdgeMap handling is just a syntactical sugar. It writes
   /// two undirected edge map with '+' and '-' prefix in the name.
   ///
-  /// \code
+  ///\code
   /// writer.writeEdgeMap("capacity", capacityMap);
-  /// \endcode
+  ///\endcode
   ///
   ///
@@ -363,17 +363,17 @@
   /// write out the source and target of the graph.
   ///
-  /// \code
+  ///\code
   /// writer.writeNode("source", sourceNode);
   /// writer.writeNode("target", targetNode);
   ///
   /// writer.writeUEdge("observed", uEdge);
-  /// \endcode
+  ///\endcode
   ///
   /// After you give all write commands you must call the \c run() member
   /// function, which executes all the writing commands.
   ///
-  /// \code
+  ///\code
   /// writer.run();
-  /// \endcode
+  ///\endcode
   ///
   /// \see DefaultWriterTraits
Index: lemon/grid_graph.h
===================================================================
--- lemon/grid_graph.h	(revision 1909)
+++ lemon/grid_graph.h	(revision 1946)
@@ -355,5 +355,5 @@
   ///
   /// The graph can be indiced in the following way:
-  /// \code
+  ///\code
   /// GridGraph graph(w, h);
   /// GridGraph::NodeMap<int> val(graph); 
@@ -363,5 +363,5 @@
   ///   }
   /// }
-  /// \endcode
+  ///\endcode
   ///
   /// The graph type is fully conform to the \ref concept::UGraph
Index: lemon/hypercube_graph.h
===================================================================
--- lemon/hypercube_graph.h	(revision 1909)
+++ lemon/hypercube_graph.h	(revision 1946)
@@ -277,5 +277,5 @@
     /// should be the dimension number of the graph.
     /// 
-    /// \code
+    ///\code
     /// const int DIM = 3;
     /// HyperCubeGraph graph(DIM);
@@ -287,5 +287,5 @@
     /// HyperCubeGraph::HyperMap<xy<double> > 
     ///   pos(graph, base, base + DIM, xy<double>(0.0, 0.0));
-    /// \endcode
+    ///\endcode
     ///
     /// \see HyperCubeGraph
Index: lemon/johnson.h
===================================================================
--- lemon/johnson.h	(revision 1916)
+++ lemon/johnson.h	(revision 1946)
@@ -609,8 +609,8 @@
     ///
     /// \note d.run(s) is just a shortcut of the following code.
-    /// \code
+    ///\code
     ///  d.init();
     ///  d.start();
-    /// \endcode
+    ///\endcode
     void run() {
       init();
Index: lemon/kruskal.h
===================================================================
--- lemon/kruskal.h	(revision 1942)
+++ lemon/kruskal.h	(revision 1946)
@@ -78,13 +78,13 @@
   /// say 53 edges, then
   /// we can put its edges into a STL vector \c tree with a code like this.
-  /// \code
+  ///\code
   /// std::vector<Edge> tree(53);
   /// kruskal(g,cost,tree.begin());
-  /// \endcode
+  ///\endcode
   /// Or if we don't know in advance the size of the tree, we can write this.
-  /// \code
+  ///\code
   /// std::vector<Edge> tree;
   /// kruskal(g,cost,std::back_inserter(tree));
-  /// \endcode
+  ///\endcode
   ///
   /// \return The cost of the found tree.
@@ -301,8 +301,8 @@
   ///
   /// A typical usage:
-  /// \code
+  ///\code
   /// std::vector<Graph::Edge> v;
   /// kruskal(g, input, makeKruskalSequenceOutput(back_inserter(v)));
-  /// \endcode
+  ///\endcode
   /// 
   /// For the most common case, when the input is given by a simple edge
@@ -397,13 +397,13 @@
 //   say 53 edges, then
 //   we can put its edges into a STL vector \c tree with a code like this.
-//   \code
+//\code
 //   std::vector<Edge> tree(53);
 //   kruskal(g,cost,tree.begin());
-//   \endcode
+//\endcode
 //   Or if we don't know in advance the size of the tree, we can write this.
-//   \code
+//\code
 //   std::vector<Edge> tree;
 //   kruskal(g,cost,std::back_inserter(tree));
-//   \endcode
+//\endcode
 //  
 //   \return The cost of the found tree.
Index: lemon/lemon_reader.h
===================================================================
--- lemon/lemon_reader.h	(revision 1909)
+++ lemon/lemon_reader.h	(revision 1946)
@@ -1963,9 +1963,9 @@
   /// to know which sections, maps and items are in the file
   /// use the next code:
-  /// \code
+  ///\code
   /// LemonReader reader("input.lgf");
   /// ContentReader content(reader);
   /// reader.run();
-  /// \endcode
+  ///\endcode
   class ContentReader : public LemonReader::SectionReader {
     typedef LemonReader::SectionReader Parent;
