Index: CMakeLists.txt
===================================================================
--- CMakeLists.txt	(revision 511)
+++ CMakeLists.txt	(revision 502)
@@ -40,5 +40,4 @@
 ADD_SUBDIRECTORY(lemon)
 ADD_SUBDIRECTORY(demo)
-ADD_SUBDIRECTORY(tools)
 ADD_SUBDIRECTORY(doc)
 ADD_SUBDIRECTORY(test)
@@ -58,9 +57,8 @@
     "${PROJECT_NAME} ${PROJECT_VERSION}")
 
-  SET(CPACK_COMPONENTS_ALL headers library html_documentation bin)
+  SET(CPACK_COMPONENTS_ALL headers library html_documentation)
 
   SET(CPACK_COMPONENT_HEADERS_DISPLAY_NAME "C++ headers")
   SET(CPACK_COMPONENT_LIBRARY_DISPLAY_NAME "Dynamic-link library")
-  SET(CPACK_COMPONENT_BIN_DISPLAY_NAME "Command line utilities")
   SET(CPACK_COMPONENT_HTML_DOCUMENTATION_DISPLAY_NAME "HTML documentation")
 
@@ -69,6 +67,4 @@
   SET(CPACK_COMPONENT_LIBRARY_DESCRIPTION
     "DLL and import library")
-  SET(CPACK_COMPONENT_BIN_DESCRIPTION
-    "Command line utilities")
   SET(CPACK_COMPONENT_HTML_DOCUMENTATION_DESCRIPTION
     "Doxygen generated documentation")
Index: lemon/Makefile.am
===================================================================
--- lemon/Makefile.am	(revision 513)
+++ lemon/Makefile.am	(revision 506)
@@ -84,5 +84,4 @@
 	lemon/math.h \
 	lemon/max_matching.h \
-	lemon/min_cost_arborescence.h \
 	lemon/nauty_reader.h \
 	lemon/path.h \
Index: lemon/bits/path_dump.h
===================================================================
--- lemon/bits/path_dump.h	(revision 503)
+++ lemon/bits/path_dump.h	(revision 514)
@@ -17,6 +17,6 @@
  */
 
-#ifndef LEMON_BITS_PRED_MAP_PATH_H
-#define LEMON_BITS_PRED_MAP_PATH_H
+#ifndef LEMON_BITS_PATH_DUMP_H
+#define LEMON_BITS_PATH_DUMP_H
 
 #include <lemon/core.h>
Index: lemon/bits/windows.h
===================================================================
--- lemon/bits/windows.h	(revision 491)
+++ lemon/bits/windows.h	(revision 514)
@@ -17,6 +17,6 @@
  */
 
-#ifndef LEMON_WINDOWS_H
-#define LEMON_WINDOWS_H
+#ifndef LEMON_BITS_WINDOWS_H
+#define LEMON_BITS_WINDOWS_H
 
 #include <string>
Index: lemon/concepts/digraph.h
===================================================================
--- lemon/concepts/digraph.h	(revision 440)
+++ lemon/concepts/digraph.h	(revision 514)
@@ -17,6 +17,6 @@
  */
 
-#ifndef LEMON_CONCEPT_DIGRAPH_H
-#define LEMON_CONCEPT_DIGRAPH_H
+#ifndef LEMON_CONCEPTS_DIGRAPH_H
+#define LEMON_CONCEPTS_DIGRAPH_H
 
 ///\ingroup graph_concepts
@@ -485,3 +485,3 @@
 
 
-#endif // LEMON_CONCEPT_DIGRAPH_H
+#endif
Index: lemon/concepts/graph.h
===================================================================
--- lemon/concepts/graph.h	(revision 440)
+++ lemon/concepts/graph.h	(revision 514)
@@ -21,9 +21,8 @@
 ///\brief The concept of Undirected Graphs.
 
-#ifndef LEMON_CONCEPT_GRAPH_H
-#define LEMON_CONCEPT_GRAPH_H
+#ifndef LEMON_CONCEPTS_GRAPH_H
+#define LEMON_CONCEPTS_GRAPH_H
 
 #include <lemon/concepts/graph_components.h>
-#include <lemon/concepts/graph.h>
 #include <lemon/core.h>
 
Index: lemon/concepts/graph_components.h
===================================================================
--- lemon/concepts/graph_components.h	(revision 440)
+++ lemon/concepts/graph_components.h	(revision 514)
@@ -22,6 +22,6 @@
 
 
-#ifndef LEMON_CONCEPT_GRAPH_COMPONENTS_H
-#define LEMON_CONCEPT_GRAPH_COMPONENTS_H
+#ifndef LEMON_CONCEPTS_GRAPH_COMPONENTS_H
+#define LEMON_CONCEPTS_GRAPH_COMPONENTS_H
 
 #include <lemon/core.h>
Index: lemon/concepts/heap.h
===================================================================
--- lemon/concepts/heap.h	(revision 503)
+++ lemon/concepts/heap.h	(revision 514)
@@ -21,6 +21,6 @@
 ///\brief The concept of heaps.
 
-#ifndef LEMON_CONCEPT_HEAP_H
-#define LEMON_CONCEPT_HEAP_H
+#ifndef LEMON_CONCEPTS_HEAP_H
+#define LEMON_CONCEPTS_HEAP_H
 
 #include <lemon/core.h>
@@ -244,3 +244,3 @@
   } // namespace lemon
 }
-#endif // LEMON_CONCEPT_PATH_H
+#endif
Index: lemon/concepts/maps.h
===================================================================
--- lemon/concepts/maps.h	(revision 440)
+++ lemon/concepts/maps.h	(revision 514)
@@ -17,6 +17,6 @@
  */
 
-#ifndef LEMON_CONCEPT_MAPS_H
-#define LEMON_CONCEPT_MAPS_H
+#ifndef LEMON_CONCEPTS_MAPS_H
+#define LEMON_CONCEPTS_MAPS_H
 
 #include <lemon/core.h>
@@ -214,3 +214,3 @@
 } //namespace lemon
 
-#endif // LEMON_CONCEPT_MAPS_H
+#endif
Index: lemon/concepts/path.h
===================================================================
--- lemon/concepts/path.h	(revision 440)
+++ lemon/concepts/path.h	(revision 514)
@@ -22,6 +22,6 @@
 ///
 
-#ifndef LEMON_CONCEPT_PATH_H
-#define LEMON_CONCEPT_PATH_H
+#ifndef LEMON_CONCEPTS_PATH_H
+#define LEMON_CONCEPTS_PATH_H
 
 #include <lemon/core.h>
@@ -306,3 +306,3 @@
 } // namespace lemon
 
-#endif // LEMON_CONCEPT_PATH_H
+#endif
Index: lemon/dimacs.h
===================================================================
--- lemon/dimacs.h	(revision 509)
+++ lemon/dimacs.h	(revision 440)
@@ -296,22 +296,7 @@
   }
 
-  template<typename Graph>
-  typename enable_if<lemon::UndirectedTagIndicator<Graph>,void>::type
-  _addArcEdge(Graph &g, typename Graph::Node s, typename Graph::Node t,
-              dummy<0> = 0)
-  {
-    g.addEdge(s,t);
-  }
-  template<typename Graph>
-  typename disable_if<lemon::UndirectedTagIndicator<Graph>,void>::type
-  _addArcEdge(Graph &g, typename Graph::Node s, typename Graph::Node t,
-              dummy<1> = 1)
-  {
-    g.addArc(s,t);
-  }
-  
-  /// DIMACS plain (di)graph reader function.
-  ///
-  /// This function reads a (di)graph without any designated nodes and
+  /// DIMACS plain digraph reader function.
+  ///
+  /// This function reads a digraph without any designated nodes and
   /// maps from DIMACS format, i.e. from DIMACS files having a line
   /// starting with
@@ -323,36 +308,13 @@
   /// If the file type was previously evaluated by dimacsType(), then
   /// the descriptor struct should be given by the \c dest parameter.
-  template<typename Graph>
-  void readDimacsMat(std::istream& is, Graph &g,
-                     DimacsDescriptor desc=DimacsDescriptor())
-  {
+  template<typename Digraph>
+  void readDimacsMat(std::istream& is, Digraph &g,
+                     DimacsDescriptor desc=DimacsDescriptor()) {
+    typename Digraph::Node u,v;
+    NullMap<typename Digraph::Arc, int> n;
     if(desc.type==DimacsDescriptor::NONE) desc=dimacsType(is);
     if(desc.type!=DimacsDescriptor::MAT)
       throw FormatError("Problem type mismatch");
-
-    g.clear();
-    std::vector<typename Graph::Node> nodes;
-    char c;
-    int i, j;
-    std::string str;
-    nodes.resize(desc.nodeNum + 1);
-    for (int k = 1; k <= desc.nodeNum; ++k) {
-      nodes[k] = g.addNode();
-    }
-    
-    while (is >> c) {
-      switch (c) {
-      case 'c': // comment line
-        getline(is, str);
-        break;
-      case 'n': // node definition line
-        break;
-      case 'a': // arc (arc) definition line
-        is >> i >> j;
-        getline(is, str);
-        _addArcEdge(g,nodes[i], nodes[j]);
-        break;
-      }
-    }
+    _readDimacs(is, g, n, u, v, desc);
   }
 
Index: lemon/lp_skeleton.h
===================================================================
--- lemon/lp_skeleton.h	(revision 459)
+++ lemon/lp_skeleton.h	(revision 514)
@@ -17,6 +17,6 @@
  */
 
-#ifndef LEMON_LP_SKELETON
-#define LEMON_LP_SKELETON
+#ifndef LEMON_LP_SKELETON_H
+#define LEMON_LP_SKELETON_H
 
 #include <lemon/lp_base.h>
@@ -227,3 +227,3 @@
 } //namespace lemon
 
-#endif // LEMON_LP_SKELETON
+#endif
Index: mon/min_cost_arborescence.h
===================================================================
--- lemon/min_cost_arborescence.h	(revision 512)
+++ 	(revision )
@@ -1,796 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2008
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_MIN_COST_ARBORESCENCE_H
-#define LEMON_MIN_COST_ARBORESCENCE_H
-
-///\ingroup spantree
-///\file
-///\brief Minimum Cost Arborescence algorithm.
-
-#include <vector>
-
-#include <lemon/list_graph.h>
-#include <lemon/bin_heap.h>
-#include <lemon/assert.h>
-
-namespace lemon {
-
-
-  /// \brief Default traits class for MinCostArborescence class.
-  ///
-  /// Default traits class for MinCostArborescence class.
-  /// \param _Digraph Digraph type.
-  /// \param _CostMap Type of cost map.
-  template <class _Digraph, class _CostMap>
-  struct MinCostArborescenceDefaultTraits{
-
-    /// \brief The digraph type the algorithm runs on.
-    typedef _Digraph Digraph;
-
-    /// \brief The type of the map that stores the arc costs.
-    ///
-    /// The type of the map that stores the arc costs.
-    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
-    typedef _CostMap CostMap;
-
-    /// \brief The value type of the costs.
-    ///
-    /// The value type of the costs.
-    typedef typename CostMap::Value Value;
-
-    /// \brief The type of the map that stores which arcs are in the
-    /// arborescence.
-    ///
-    /// The type of the map that stores which arcs are in the
-    /// arborescence.  It must meet the \ref concepts::WriteMap
-    /// "WriteMap" concept.  Initially it will be set to false on each
-    /// arc. After it will set all arborescence arcs once.
-    typedef typename Digraph::template ArcMap<bool> ArborescenceMap;
-
-    /// \brief Instantiates a ArborescenceMap.
-    ///
-    /// This function instantiates a \ref ArborescenceMap.
-    /// \param digraph is the graph, to which we would like to
-    /// calculate the ArborescenceMap.
-    static ArborescenceMap *createArborescenceMap(const Digraph &digraph){
-      return new ArborescenceMap(digraph);
-    }
-
-    /// \brief The type of the PredMap
-    ///
-    /// The type of the PredMap. It is a node map with an arc value type.
-    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
-
-    /// \brief Instantiates a PredMap.
-    ///
-    /// This function instantiates a \ref PredMap.
-    /// \param _digraph is the digraph, to which we would like to define the
-    /// PredMap.
-    static PredMap *createPredMap(const Digraph &digraph){
-      return new PredMap(digraph);
-    }
-
-  };
-
-  /// \ingroup spantree
-  ///
-  /// \brief %MinCostArborescence algorithm class.
-  ///
-  /// This class provides an efficient implementation of
-  /// %MinCostArborescence algorithm. The arborescence is a tree
-  /// which is directed from a given source node of the digraph. One or
-  /// more sources should be given for the algorithm and it will calculate
-  /// the minimum cost subgraph which are 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 \f$ O(n^2+e) \f$.
-  ///
-  /// The algorithm provides also an optimal dual solution, therefore
-  /// the optimality of the solution can be checked.
-  ///
-  /// \param _Digraph The digraph type the algorithm runs on. The default value
-  /// is \ref ListDigraph.
-  /// \param _CostMap This read-only ArcMap determines the costs of the
-  /// arcs. It is read once for each arc, so the map may involve in
-  /// relatively time consuming process to compute the arc cost if
-  /// it is necessary. The default map type is \ref
-  /// concepts::Digraph::ArcMap "Digraph::ArcMap<int>".
-  /// \param _Traits Traits class to set various data types used
-  /// by the algorithm. The default traits class is
-  /// \ref MinCostArborescenceDefaultTraits
-  /// "MinCostArborescenceDefaultTraits<_Digraph, _CostMap>".  See \ref
-  /// MinCostArborescenceDefaultTraits for the documentation of a
-  /// MinCostArborescence traits class.
-  ///
-  /// \author Balazs Dezso
-#ifndef DOXYGEN
-  template <typename _Digraph = ListDigraph,
-            typename _CostMap = typename _Digraph::template ArcMap<int>,
-            typename _Traits =
-            MinCostArborescenceDefaultTraits<_Digraph, _CostMap> >
-#else
-  template <typename _Digraph, typename _CostMap, typedef _Traits>
-#endif
-  class MinCostArborescence {
-  public:
-
-    /// The traits.
-    typedef _Traits Traits;
-    /// The type of the underlying digraph.
-    typedef typename Traits::Digraph Digraph;
-    /// The type of the map that stores the arc costs.
-    typedef typename Traits::CostMap CostMap;
-    ///The type of the costs of the arcs.
-    typedef typename Traits::Value Value;
-    ///The type of the predecessor map.
-    typedef typename Traits::PredMap PredMap;
-    ///The type of the map that stores which arcs are in the arborescence.
-    typedef typename Traits::ArborescenceMap ArborescenceMap;
-
-    typedef MinCostArborescence Create;
-
-  private:
-
-    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-
-    struct CostArc {
-
-      Arc arc;
-      Value value;
-
-      CostArc() {}
-      CostArc(Arc _arc, Value _value) : arc(_arc), value(_value) {}
-
-    };
-
-    const Digraph *_digraph;
-    const CostMap *_cost;
-
-    PredMap *_pred;
-    bool local_pred;
-
-    ArborescenceMap *_arborescence;
-    bool local_arborescence;
-
-    typedef typename Digraph::template ArcMap<int> ArcOrder;
-    ArcOrder *_arc_order;
-
-    typedef typename Digraph::template NodeMap<int> NodeOrder;
-    NodeOrder *_node_order;
-
-    typedef typename Digraph::template NodeMap<CostArc> CostArcMap;
-    CostArcMap *_cost_arcs;
-
-    struct StackLevel {
-
-      std::vector<CostArc> arcs;
-      int node_level;
-
-    };
-
-    std::vector<StackLevel> level_stack;
-    std::vector<Node> queue;
-
-    typedef std::vector<typename Digraph::Node> DualNodeList;
-
-    DualNodeList _dual_node_list;
-
-    struct DualVariable {
-      int begin, end;
-      Value value;
-
-      DualVariable(int _begin, int _end, Value _value)
-        : begin(_begin), end(_end), value(_value) {}
-
-    };
-
-    typedef std::vector<DualVariable> DualVariables;
-
-    DualVariables _dual_variables;
-
-    typedef typename Digraph::template NodeMap<int> HeapCrossRef;
-
-    HeapCrossRef *_heap_cross_ref;
-
-    typedef BinHeap<int, HeapCrossRef> Heap;
-
-    Heap *_heap;
-
-  protected:
-
-    MinCostArborescence() {}
-
-  private:
-
-    void createStructures() {
-      if (!_pred) {
-        local_pred = true;
-        _pred = Traits::createPredMap(*_digraph);
-      }
-      if (!_arborescence) {
-        local_arborescence = true;
-        _arborescence = Traits::createArborescenceMap(*_digraph);
-      }
-      if (!_arc_order) {
-        _arc_order = new ArcOrder(*_digraph);
-      }
-      if (!_node_order) {
-        _node_order = new NodeOrder(*_digraph);
-      }
-      if (!_cost_arcs) {
-        _cost_arcs = new CostArcMap(*_digraph);
-      }
-      if (!_heap_cross_ref) {
-        _heap_cross_ref = new HeapCrossRef(*_digraph, -1);
-      }
-      if (!_heap) {
-        _heap = new Heap(*_heap_cross_ref);
-      }
-    }
-
-    void destroyStructures() {
-      if (local_arborescence) {
-        delete _arborescence;
-      }
-      if (local_pred) {
-        delete _pred;
-      }
-      if (_arc_order) {
-        delete _arc_order;
-      }
-      if (_node_order) {
-        delete _node_order;
-      }
-      if (_cost_arcs) {
-        delete _cost_arcs;
-      }
-      if (_heap) {
-        delete _heap;
-      }
-      if (_heap_cross_ref) {
-        delete _heap_cross_ref;
-      }
-    }
-
-    Arc prepare(Node node) {
-      std::vector<Node> nodes;
-      (*_node_order)[node] = _dual_node_list.size();
-      StackLevel level;
-      level.node_level = _dual_node_list.size();
-      _dual_node_list.push_back(node);
-      for (InArcIt it(*_digraph, node); it != INVALID; ++it) {
-        Arc arc = it;
-        Node source = _digraph->source(arc);
-        Value value = (*_cost)[it];
-        if (source == node || (*_node_order)[source] == -3) continue;
-        if ((*_cost_arcs)[source].arc == INVALID) {
-          (*_cost_arcs)[source].arc = arc;
-          (*_cost_arcs)[source].value = value;
-          nodes.push_back(source);
-        } else {
-          if ((*_cost_arcs)[source].value > value) {
-            (*_cost_arcs)[source].arc = arc;
-            (*_cost_arcs)[source].value = value;
-          }
-        }
-      }
-      CostArc minimum = (*_cost_arcs)[nodes[0]];
-      for (int i = 1; i < int(nodes.size()); ++i) {
-        if ((*_cost_arcs)[nodes[i]].value < minimum.value) {
-          minimum = (*_cost_arcs)[nodes[i]];
-        }
-      }
-      _arc_order->set(minimum.arc, _dual_variables.size());
-      DualVariable var(_dual_node_list.size() - 1,
-                       _dual_node_list.size(), minimum.value);
-      _dual_variables.push_back(var);
-      for (int i = 0; i < int(nodes.size()); ++i) {
-        (*_cost_arcs)[nodes[i]].value -= minimum.value;
-        level.arcs.push_back((*_cost_arcs)[nodes[i]]);
-        (*_cost_arcs)[nodes[i]].arc = INVALID;
-      }
-      level_stack.push_back(level);
-      return minimum.arc;
-    }
-
-    Arc contract(Node node) {
-      int node_bottom = bottom(node);
-      std::vector<Node> nodes;
-      while (!level_stack.empty() &&
-             level_stack.back().node_level >= node_bottom) {
-        for (int i = 0; i < int(level_stack.back().arcs.size()); ++i) {
-          Arc arc = level_stack.back().arcs[i].arc;
-          Node source = _digraph->source(arc);
-          Value value = level_stack.back().arcs[i].value;
-          if ((*_node_order)[source] >= node_bottom) continue;
-          if ((*_cost_arcs)[source].arc == INVALID) {
-            (*_cost_arcs)[source].arc = arc;
-            (*_cost_arcs)[source].value = value;
-            nodes.push_back(source);
-          } else {
-            if ((*_cost_arcs)[source].value > value) {
-              (*_cost_arcs)[source].arc = arc;
-              (*_cost_arcs)[source].value = value;
-            }
-          }
-        }
-        level_stack.pop_back();
-      }
-      CostArc minimum = (*_cost_arcs)[nodes[0]];
-      for (int i = 1; i < int(nodes.size()); ++i) {
-        if ((*_cost_arcs)[nodes[i]].value < minimum.value) {
-          minimum = (*_cost_arcs)[nodes[i]];
-        }
-      }
-      _arc_order->set(minimum.arc, _dual_variables.size());
-      DualVariable var(node_bottom, _dual_node_list.size(), minimum.value);
-      _dual_variables.push_back(var);
-      StackLevel level;
-      level.node_level = node_bottom;
-      for (int i = 0; i < int(nodes.size()); ++i) {
-        (*_cost_arcs)[nodes[i]].value -= minimum.value;
-        level.arcs.push_back((*_cost_arcs)[nodes[i]]);
-        (*_cost_arcs)[nodes[i]].arc = INVALID;
-      }
-      level_stack.push_back(level);
-      return minimum.arc;
-    }
-
-    int bottom(Node node) {
-      int k = level_stack.size() - 1;
-      while (level_stack[k].node_level > (*_node_order)[node]) {
-        --k;
-      }
-      return level_stack[k].node_level;
-    }
-
-    void finalize(Arc arc) {
-      Node node = _digraph->target(arc);
-      _heap->push(node, (*_arc_order)[arc]);
-      _pred->set(node, arc);
-      while (!_heap->empty()) {
-        Node source = _heap->top();
-        _heap->pop();
-        _node_order->set(source, -1);
-        for (OutArcIt it(*_digraph, source); it != INVALID; ++it) {
-          if ((*_arc_order)[it] < 0) continue;
-          Node target = _digraph->target(it);
-          switch(_heap->state(target)) {
-          case Heap::PRE_HEAP:
-            _heap->push(target, (*_arc_order)[it]);
-            _pred->set(target, it);
-            break;
-          case Heap::IN_HEAP:
-            if ((*_arc_order)[it] < (*_heap)[target]) {
-              _heap->decrease(target, (*_arc_order)[it]);
-              _pred->set(target, it);
-            }
-            break;
-          case Heap::POST_HEAP:
-            break;
-          }
-        }
-        _arborescence->set((*_pred)[source], true);
-      }
-    }
-
-
-  public:
-
-    /// \name Named template parameters
-
-    /// @{
-
-    template <class T>
-    struct DefArborescenceMapTraits : public Traits {
-      typedef T ArborescenceMap;
-      static ArborescenceMap *createArborescenceMap(const Digraph &)
-      {
-        LEMON_ASSERT(false, "ArborescenceMap is not initialized");
-        return 0; // ignore warnings
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for
-    /// setting ArborescenceMap type
-    ///
-    /// \ref named-templ-param "Named parameter" for setting
-    /// ArborescenceMap type
-    template <class T>
-    struct DefArborescenceMap
-      : public MinCostArborescence<Digraph, CostMap,
-                                   DefArborescenceMapTraits<T> > {
-    };
-
-    template <class T>
-    struct DefPredMapTraits : public Traits {
-      typedef T PredMap;
-      static PredMap *createPredMap(const Digraph &)
-      {
-        LEMON_ASSERT(false, "PredMap is not initialized");
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for
-    /// setting PredMap type
-    ///
-    /// \ref named-templ-param "Named parameter" for setting
-    /// PredMap type
-    template <class T>
-    struct DefPredMap
-      : public MinCostArborescence<Digraph, CostMap, DefPredMapTraits<T> > {
-    };
-
-    /// @}
-
-    /// \brief Constructor.
-    ///
-    /// \param _digraph The digraph the algorithm will run on.
-    /// \param _cost The cost map used by the algorithm.
-    MinCostArborescence(const Digraph& digraph, const CostMap& cost)
-      : _digraph(&digraph), _cost(&cost), _pred(0), local_pred(false),
-        _arborescence(0), local_arborescence(false),
-        _arc_order(0), _node_order(0), _cost_arcs(0),
-        _heap_cross_ref(0), _heap(0) {}
-
-    /// \brief Destructor.
-    ~MinCostArborescence() {
-      destroyStructures();
-    }
-
-    /// \brief Sets the arborescence map.
-    ///
-    /// Sets the arborescence map.
-    /// \return \c (*this)
-    MinCostArborescence& arborescenceMap(ArborescenceMap& m) {
-      if (local_arborescence) {
-        delete _arborescence;
-      }
-      local_arborescence = false;
-      _arborescence = &m;
-      return *this;
-    }
-
-    /// \brief Sets the arborescence map.
-    ///
-    /// Sets the arborescence map.
-    /// \return \c (*this)
-    MinCostArborescence& predMap(PredMap& m) {
-      if (local_pred) {
-        delete _pred;
-      }
-      local_pred = false;
-      _pred = &m;
-      return *this;
-    }
-
-    /// \name Query Functions
-    /// The result of the %MinCostArborescence algorithm can be obtained
-    /// using these functions.\n
-    /// Before the use of these functions,
-    /// either run() or start() must be called.
-
-    /// @{
-
-    /// \brief Returns a reference to the arborescence map.
-    ///
-    /// Returns a reference to the arborescence map.
-    const ArborescenceMap& arborescenceMap() const {
-      return *_arborescence;
-    }
-
-    /// \brief Returns true if the arc is in the arborescence.
-    ///
-    /// Returns true if the arc is in the arborescence.
-    /// \param arc The arc of the digraph.
-    /// \pre \ref run() must be called before using this function.
-    bool arborescence(Arc arc) const {
-      return (*_pred)[_digraph->target(arc)] == arc;
-    }
-
-    /// \brief Returns a reference to the pred map.
-    ///
-    /// Returns a reference to the pred map.
-    const PredMap& predMap() const {
-      return *_pred;
-    }
-
-    /// \brief Returns the predecessor arc of the given node.
-    ///
-    /// Returns the predecessor arc of the given node.
-    Arc pred(Node node) const {
-      return (*_pred)[node];
-    }
-
-    /// \brief Returns the cost of the arborescence.
-    ///
-    /// Returns the cost of the arborescence.
-    Value arborescenceValue() const {
-      Value sum = 0;
-      for (ArcIt it(*_digraph); it != INVALID; ++it) {
-        if (arborescence(it)) {
-          sum += (*_cost)[it];
-        }
-      }
-      return sum;
-    }
-
-    /// \brief Indicates that a node is reachable from the sources.
-    ///
-    /// Indicates that a node is reachable from the sources.
-    bool reached(Node node) const {
-      return (*_node_order)[node] != -3;
-    }
-
-    /// \brief Indicates that a node is processed.
-    ///
-    /// Indicates that a node is processed. The arborescence path exists
-    /// from the source to the given node.
-    bool processed(Node node) const {
-      return (*_node_order)[node] == -1;
-    }
-
-    /// \brief Returns the number of the dual variables in basis.
-    ///
-    /// Returns the number of the dual variables in basis.
-    int dualNum() const {
-      return _dual_variables.size();
-    }
-
-    /// \brief Returns the value of the dual solution.
-    ///
-    /// Returns the value of the dual solution. It should be
-    /// equal to the arborescence value.
-    Value dualValue() const {
-      Value sum = 0;
-      for (int i = 0; i < int(_dual_variables.size()); ++i) {
-        sum += _dual_variables[i].value;
-      }
-      return sum;
-    }
-
-    /// \brief Returns the number of the nodes in the dual variable.
-    ///
-    /// Returns the number of the nodes in the dual variable.
-    int dualSize(int k) const {
-      return _dual_variables[k].end - _dual_variables[k].begin;
-    }
-
-    /// \brief Returns the value of the dual variable.
-    ///
-    /// Returns the the value of the dual variable.
-    const Value& dualValue(int k) const {
-      return _dual_variables[k].value;
-    }
-
-    /// \brief Lemon iterator for get a dual variable.
-    ///
-    /// Lemon iterator for get a dual variable. This class provides
-    /// a common style lemon iterator which gives back a subset of
-    /// the nodes.
-    class DualIt {
-    public:
-
-      /// \brief Constructor.
-      ///
-      /// Constructor for get the nodeset of the variable.
-      DualIt(const MinCostArborescence& algorithm, int variable)
-        : _algorithm(&algorithm)
-      {
-        _index = _algorithm->_dual_variables[variable].begin;
-        _last = _algorithm->_dual_variables[variable].end;
-      }
-
-      /// \brief Conversion to node.
-      ///
-      /// Conversion to node.
-      operator Node() const {
-        return _algorithm->_dual_node_list[_index];
-      }
-
-      /// \brief Increment operator.
-      ///
-      /// Increment operator.
-      DualIt& operator++() {
-        ++_index;
-        return *this;
-      }
-
-      /// \brief Validity checking
-      ///
-      /// Checks whether the iterator is invalid.
-      bool operator==(Invalid) const {
-        return _index == _last;
-      }
-
-      /// \brief Validity checking
-      ///
-      /// Checks whether the iterator is valid.
-      bool operator!=(Invalid) const {
-        return _index != _last;
-      }
-
-    private:
-      const MinCostArborescence* _algorithm;
-      int _index, _last;
-    };
-
-    /// @}
-
-    /// \name Execution control
-    /// The simplest way to execute the algorithm is to use
-    /// one of the member functions called \c run(...). \n
-    /// If you need more control on the execution,
-    /// first you must call \ref init(), then you can add several
-    /// source nodes with \ref addSource().
-    /// Finally \ref start() will perform the arborescence
-    /// computation.
-
-    ///@{
-
-    /// \brief Initializes the internal data structures.
-    ///
-    /// Initializes the internal data structures.
-    ///
-    void init() {
-      createStructures();
-      _heap->clear();
-      for (NodeIt it(*_digraph); it != INVALID; ++it) {
-        (*_cost_arcs)[it].arc = INVALID;
-        _node_order->set(it, -3);
-        _heap_cross_ref->set(it, Heap::PRE_HEAP);
-        _pred->set(it, INVALID);
-      }
-      for (ArcIt it(*_digraph); it != INVALID; ++it) {
-        _arborescence->set(it, false);
-        _arc_order->set(it, -1);
-      }
-      _dual_node_list.clear();
-      _dual_variables.clear();
-    }
-
-    /// \brief Adds a new source node.
-    ///
-    /// Adds a new source node to the algorithm.
-    void addSource(Node source) {
-      std::vector<Node> nodes;
-      nodes.push_back(source);
-      while (!nodes.empty()) {
-        Node node = nodes.back();
-        nodes.pop_back();
-        for (OutArcIt it(*_digraph, node); it != INVALID; ++it) {
-          Node target = _digraph->target(it);
-          if ((*_node_order)[target] == -3) {
-            (*_node_order)[target] = -2;
-            nodes.push_back(target);
-            queue.push_back(target);
-          }
-        }
-      }
-      (*_node_order)[source] = -1;
-    }
-
-    /// \brief Processes the next node in the priority queue.
-    ///
-    /// Processes the next node in the priority queue.
-    ///
-    /// \return The processed node.
-    ///
-    /// \warning The queue must not be empty!
-    Node processNextNode() {
-      Node node = queue.back();
-      queue.pop_back();
-      if ((*_node_order)[node] == -2) {
-        Arc arc = prepare(node);
-        Node source = _digraph->source(arc);
-        while ((*_node_order)[source] != -1) {
-          if ((*_node_order)[source] >= 0) {
-            arc = contract(source);
-          } else {
-            arc = prepare(source);
-          }
-          source = _digraph->source(arc);
-        }
-        finalize(arc);
-        level_stack.clear();
-      }
-      return node;
-    }
-
-    /// \brief Returns the number of the nodes to be processed.
-    ///
-    /// Returns the number of the nodes to be processed.
-    int queueSize() const {
-      return queue.size();
-    }
-
-    /// \brief Returns \c false if there are nodes to be processed.
-    ///
-    /// Returns \c false if there are nodes to be processed.
-    bool emptyQueue() const {
-      return queue.empty();
-    }
-
-    /// \brief Executes the algorithm.
-    ///
-    /// Executes the algorithm.
-    ///
-    /// \pre init() must be called and at least one node should be added
-    /// with addSource() before using this function.
-    ///
-    ///\note mca.start() is just a shortcut of the following code.
-    ///\code
-    ///while (!mca.emptyQueue()) {
-    ///  mca.processNextNode();
-    ///}
-    ///\endcode
-    void start() {
-      while (!emptyQueue()) {
-        processNextNode();
-      }
-    }
-
-    /// \brief Runs %MinCostArborescence algorithm from node \c s.
-    ///
-    /// This method runs the %MinCostArborescence algorithm from
-    /// a root node \c s.
-    ///
-    /// \note mca.run(s) is just a shortcut of the following code.
-    /// \code
-    /// mca.init();
-    /// mca.addSource(s);
-    /// mca.start();
-    /// \endcode
-    void run(Node node) {
-      init();
-      addSource(node);
-      start();
-    }
-
-    ///@}
-
-  };
-
-  /// \ingroup spantree
-  ///
-  /// \brief Function type interface for MinCostArborescence algorithm.
-  ///
-  /// Function type interface for MinCostArborescence algorithm.
-  /// \param digraph The Digraph that the algorithm runs on.
-  /// \param cost The CostMap of the arcs.
-  /// \param source The source of the arborescence.
-  /// \retval arborescence The bool ArcMap which stores the arborescence.
-  /// \return The cost of the arborescence.
-  ///
-  /// \sa MinCostArborescence
-  template <typename Digraph, typename CostMap, typename ArborescenceMap>
-  typename CostMap::Value minCostArborescence(const Digraph& digraph,
-                                              const CostMap& cost,
-                                              typename Digraph::Node source,
-                                              ArborescenceMap& arborescence) {
-    typename MinCostArborescence<Digraph, CostMap>
-      ::template DefArborescenceMap<ArborescenceMap>
-      ::Create mca(digraph, cost);
-    mca.arborescenceMap(arborescence);
-    mca.run(source);
-    return mca.arborescenceValue();
-  }
-
-}
-
-#endif
Index: test/CMakeLists.txt
===================================================================
--- test/CMakeLists.txt	(revision 513)
+++ test/CMakeLists.txt	(revision 506)
@@ -30,5 +30,4 @@
   maps_test
   max_matching_test
-  min_cost_arborescence_test
   path_test
   preflow_test
Index: test/Makefile.am
===================================================================
--- test/Makefile.am	(revision 513)
+++ test/Makefile.am	(revision 506)
@@ -26,5 +26,4 @@
 	test/maps_test \
 	test/max_matching_test \
-	test/min_cost_arborescence_test \
 	test/path_test \
 	test/preflow_test \
@@ -68,5 +67,4 @@
 test_mip_test_SOURCES = test/mip_test.cc
 test_max_matching_test_SOURCES = test/max_matching_test.cc
-test_min_cost_arborescence_test_SOURCES = test/min_cost_arborescence_test.cc
 test_path_test_SOURCES = test/path_test.cc
 test_preflow_test_SOURCES = test/preflow_test.cc
Index: st/min_cost_arborescence_test.cc
===================================================================
--- test/min_cost_arborescence_test.cc	(revision 512)
+++ 	(revision )
@@ -1,146 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2008
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#include <iostream>
-#include <set>
-#include <vector>
-#include <iterator>
-
-#include <lemon/smart_graph.h>
-#include <lemon/min_cost_arborescence.h>
-#include <lemon/lgf_reader.h>
-
-#include "test_tools.h"
-
-using namespace lemon;
-using namespace std;
-
-const char test_lgf[] =
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "5\n"
-  "6\n"
-  "7\n"
-  "8\n"
-  "9\n"
-  "@arcs\n"
-  "     label  cost\n"
-  "1 8  0      107\n"
-  "0 3  1      70\n"
-  "2 1  2      46\n"
-  "4 1  3      28\n"
-  "4 4  4      91\n"
-  "3 9  5      76\n"
-  "9 8  6      61\n"
-  "8 1  7      39\n"
-  "9 8  8      74\n"
-  "8 0  9      39\n"
-  "4 3  10     45\n"
-  "2 2  11     34\n"
-  "0 1  12     100\n"
-  "6 3  13     95\n"
-  "4 1  14     22\n"
-  "1 1  15     31\n"
-  "7 2  16     51\n"
-  "2 6  17     29\n"
-  "8 3  18     115\n"
-  "6 9  19     32\n"
-  "1 1  20     60\n"
-  "0 3  21     40\n"
-  "@attributes\n"
-  "source 0\n";
-
-int main() {
-  typedef SmartDigraph Digraph;
-  DIGRAPH_TYPEDEFS(Digraph);
-
-  typedef Digraph::ArcMap<double> CostMap;
-
-  Digraph digraph;
-  CostMap cost(digraph);
-  Node source;
-
-  std::istringstream is(test_lgf);
-  digraphReader(digraph, is).
-    arcMap("cost", cost).
-    node("source", source).run();
-
-  MinCostArborescence<Digraph, CostMap> mca(digraph, cost);
-  mca.run(source);
-
-  vector<pair<double, set<Node> > > dualSolution(mca.dualNum());
-
-  for (int i = 0; i < mca.dualNum(); ++i) {
-    dualSolution[i].first = mca.dualValue(i);
-    for (MinCostArborescence<Digraph, CostMap>::DualIt it(mca, i);
-         it != INVALID; ++it) {
-      dualSolution[i].second.insert(it);
-    }
-  }
-
-  for (ArcIt it(digraph); it != INVALID; ++it) {
-    if (mca.reached(digraph.source(it))) {
-      double sum = 0.0;
-      for (int i = 0; i < int(dualSolution.size()); ++i) {
-        if (dualSolution[i].second.find(digraph.target(it))
-            != dualSolution[i].second.end() &&
-            dualSolution[i].second.find(digraph.source(it))
-            == dualSolution[i].second.end()) {
-          sum += dualSolution[i].first;
-        }
-      }
-      if (mca.arborescence(it)) {
-        check(sum == cost[it], "INVALID DUAL");
-      }
-      check(sum <= cost[it], "INVALID DUAL");
-    }
-  }
-
-
-  check(mca.dualValue() == mca.arborescenceValue(), "INVALID DUAL");
-
-  check(mca.reached(source), "INVALID ARBORESCENCE");
-  for (ArcIt a(digraph); a != INVALID; ++a) {
-    check(!mca.reached(digraph.source(a)) ||
-          mca.reached(digraph.target(a)), "INVALID ARBORESCENCE");
-  }
-
-  for (NodeIt n(digraph); n != INVALID; ++n) {
-    if (!mca.reached(n)) continue;
-    int cnt = 0;
-    for (InArcIt a(digraph, n); a != INVALID; ++a) {
-      if (mca.arborescence(a)) {
-        check(mca.pred(n) == a, "INVALID ARBORESCENCE");
-        ++cnt;
-      }
-    }
-    check((n == source ? cnt == 0 : cnt == 1), "INVALID ARBORESCENCE");
-  }
-
-  Digraph::ArcMap<bool> arborescence(digraph);
-  check(mca.arborescenceValue() ==
-        minCostArborescence(digraph, cost, source, arborescence),
-        "WRONG FUNCTION");
-
-  return 0;
-}
Index: ols/CMakeLists.txt
===================================================================
--- tools/CMakeLists.txt	(revision 511)
+++ 	(revision )
@@ -1,28 +1,0 @@
-INCLUDE_DIRECTORIES(
-  ${CMAKE_SOURCE_DIR}
-  ${CMAKE_BINARY_DIR}
-)
-
-LINK_DIRECTORIES(${CMAKE_BINARY_DIR}/lemon)
-
-ADD_EXECUTABLE(lgf-gen lgf-gen.cc)
-TARGET_LINK_LIBRARIES(lgf-gen lemon)
-
-ADD_EXECUTABLE(dimacs-to-lgf dimacs-to-lgf.cc)
-TARGET_LINK_LIBRARIES(dimacs-to-lgf lemon)
-
-ADD_EXECUTABLE(dimacs-solver dimacs-solver.cc)
-TARGET_LINK_LIBRARIES(dimacs-solver lemon)
-
-INSTALL(
-  TARGETS lgf-gen dimacs-to-lgf dimacs-solver
-  RUNTIME DESTINATION bin
-  COMPONENT bin
-)
-
-IF(NOT WIN32)
-  INSTALL(
-    FILES ${CMAKE_CURRENT_SOURCE_DIR}/lemon-0.x-to-1.x.sh
-    RUNTIME DESTINATION bin
-    COMPONENT bin)
-ENDIF(NOT WIN32)
Index: tools/Makefile.am
===================================================================
--- tools/Makefile.am	(revision 510)
+++ tools/Makefile.am	(revision 507)
@@ -2,5 +2,4 @@
 
 bin_PROGRAMS += \
-	tools/dimacs-solver \
 	tools/dimacs-to-lgf \
 	tools/lgf-gen
@@ -10,5 +9,4 @@
 endif WANT_TOOLS
 
-tools_dimacs_solver_SOURCES = tools/dimacs-solver.cc
 tools_dimacs_to_lgf_SOURCES = tools/dimacs-to-lgf.cc
 tools_lgf_gen_SOURCES = tools/lgf-gen.cc
Index: ols/dimacs-solver.cc
===================================================================
--- tools/dimacs-solver.cc	(revision 510)
+++ 	(revision )
@@ -1,233 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2009
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-///\ingroup tools
-///\file
-///\brief DIMACS to LGF converter.
-///
-/// This program converts various DIMACS formats to the LEMON Digraph Format
-/// (LGF).
-///
-/// See
-/// \verbatim
-///  dimacs-solver --help
-/// \endverbatim
-/// for more info on usage.
-///
-
-#include <iostream>
-#include <fstream>
-#include <cstring>
-
-#include <lemon/smart_graph.h>
-#include <lemon/dimacs.h>
-#include <lemon/lgf_writer.h>
-#include <lemon/time_measure.h>
-
-#include <lemon/arg_parser.h>
-#include <lemon/error.h>
-
-#include <lemon/dijkstra.h>
-#include <lemon/preflow.h>
-#include <lemon/max_matching.h>
-
-using namespace lemon;
-typedef SmartDigraph Digraph;
-DIGRAPH_TYPEDEFS(Digraph);
-typedef SmartGraph Graph;
-
-template<class Value>
-void solve_sp(ArgParser &ap, std::istream &is, std::ostream &,
-              DimacsDescriptor &desc)
-{
-  bool report = !ap.given("q");
-  Digraph g;
-  Node s;
-  Digraph::ArcMap<Value> len(g);
-  Timer t;
-  t.restart();
-  readDimacsSp(is, g, len, s, desc);
-  if(report) std::cerr << "Read the file: " << t << '\n';
-  t.restart();
-  Dijkstra<Digraph, Digraph::ArcMap<Value> > dij(g,len);
-  if(report) std::cerr << "Setup Dijkstra class: " << t << '\n';
-  t.restart();
-  dij.run(s);
-  if(report) std::cerr << "Run Dijkstra: " << t << '\n';
-}
-
-template<class Value>
-void solve_max(ArgParser &ap, std::istream &is, std::ostream &,
-              DimacsDescriptor &desc)
-{
-  bool report = !ap.given("q");
-  Digraph g;
-  Node s,t;
-  Digraph::ArcMap<Value> cap(g);
-  Timer ti;
-  ti.restart();
-  readDimacsMax(is, g, cap, s, t, desc);
-  if(report) std::cerr << "Read the file: " << ti << '\n';
-  ti.restart();
-  Preflow<Digraph, Digraph::ArcMap<Value> > pre(g,cap,s,t);
-  if(report) std::cerr << "Setup Preflow class: " << ti << '\n';
-  ti.restart();
-  pre.run();
-  if(report) std::cerr << "Run Preflow: " << ti << '\n';
-  if(report) std::cerr << "\nMax flow value: " << pre.flowValue() << '\n';  
-}
-
-void solve_mat(ArgParser &ap, std::istream &is, std::ostream &,
-              DimacsDescriptor &desc)
-{
-  bool report = !ap.given("q");
-  Graph g;
-  Timer ti;
-  ti.restart();
-  readDimacsMat(is, g, desc);
-  if(report) std::cerr << "Read the file: " << ti << '\n';
-  ti.restart();
-  MaxMatching<Graph> mat(g);
-  if(report) std::cerr << "Setup MaxMatching class: " << ti << '\n';
-  ti.restart();
-  mat.run();
-  if(report) std::cerr << "Run MaxMatching: " << ti << '\n';
-  if(report) std::cerr << "\nCardinality of max matching: "
-                       << mat.matchingSize() << '\n';  
-}
-
-
-template<class Value>
-void solve(ArgParser &ap, std::istream &is, std::ostream &os,
-           DimacsDescriptor &desc)
-{
-  switch(desc.type)
-    {
-    case DimacsDescriptor::MIN:
-      std::cerr <<
-        "\n\n Sorry, the min. cost flow solver is not yet available.\n"
-                << std::endl;
-      break;
-    case DimacsDescriptor::MAX:
-      solve_max<Value>(ap,is,os,desc);
-      break;
-    case DimacsDescriptor::SP:
-      solve_sp<Value>(ap,is,os,desc);
-      break;
-    case DimacsDescriptor::MAT:
-      solve_mat(ap,is,os,desc);
-      break;
-    default:
-      break;
-    }
-}
-
-int main(int argc, const char *argv[]) {
-  typedef SmartDigraph Digraph;
-
-  typedef Digraph::Arc Arc;
-  typedef Digraph::Node Node;
-  typedef Digraph::ArcIt ArcIt;
-  typedef Digraph::NodeIt NodeIt;
-  typedef Digraph::ArcMap<double> DoubleArcMap;
-  typedef Digraph::NodeMap<double> DoubleNodeMap;
-
-  std::string inputName;
-  std::string outputName;
-
-  ArgParser ap(argc, argv);
-  ap.other("[INFILE [OUTFILE]]",
-           "If either the INFILE or OUTFILE file is missing the standard\n"
-           "     input/output will be used instead.")
-    .boolOption("q", "Do not print any report")
-    .boolOption("int","Use 'int' for capacities, costs etc. (default)")
-    .optionGroup("datatype","int")
-#ifdef HAVE_LONG_LONG
-    .boolOption("long","Use 'long long' for capacities, costs etc.")
-    .optionGroup("datatype","long")
-#endif
-    .boolOption("double","Use 'double' for capacities, costs etc.")
-    .optionGroup("datatype","double")
-    .boolOption("ldouble","Use 'long double' for capacities, costs etc.")
-    .optionGroup("datatype","ldouble")
-    .onlyOneGroup("datatype")
-    .run();
-
-  std::ifstream input;
-  std::ofstream output;
-
-  switch(ap.files().size())
-    {
-    case 2:
-      output.open(ap.files()[1].c_str());
-      if (!output) {
-        throw IoError("Cannot open the file for writing", ap.files()[1]);
-      }
-    case 1:
-      input.open(ap.files()[0].c_str());
-      if (!input) {
-        throw IoError("File cannot be found", ap.files()[0]);
-      }
-    case 0:
-      break;
-    default:
-      std::cerr << ap.commandName() << ": too many arguments\n";
-      return 1;
-  }
-  std::istream& is = (ap.files().size()<1 ? std::cin : input);
-  std::ostream& os = (ap.files().size()<2 ? std::cout : output);
-
-  DimacsDescriptor desc = dimacsType(is);
-  
-  if(!ap.given("q"))
-    {
-      std::cout << "Problem type: ";
-      switch(desc.type)
-        {
-        case DimacsDescriptor::MIN:
-          std::cout << "min";
-          break;
-        case DimacsDescriptor::MAX:
-          std::cout << "max";
-          break;
-        case DimacsDescriptor::SP:
-          std::cout << "sp";
-        case DimacsDescriptor::MAT:
-          std::cout << "mat";
-          break;
-        default:
-          exit(1);
-          break;
-        }
-      std::cout << "\nNum of nodes: " << desc.nodeNum;
-      std::cout << "\nNum of arcs:  " << desc.edgeNum;
-      std::cout << '\n' << std::endl;
-    }
-    
-  if(ap.given("double"))
-    solve<double>(ap,is,os,desc);
-  else if(ap.given("ldouble"))
-    solve<long double>(ap,is,os,desc);
-#ifdef HAVE_LONG_LONG
-  else if(ap.given("long"))
-    solve<long long>(ap,is,os,desc);
-#endif
-  else solve<int>(ap,is,os,desc);
-
-  return 0;
-}
