int _res_node_num;

     int _res_node_num;

     int _res_arc_num;

     int _res_arc_num;

     int _root;

     int _root;

     // Parameters of the problem

     // Parameters of the problem

     Value _sum_supply;

     Value _sum_supply;

     // Data structures for storing the digraph

     // Data structures for storing the digraph

     IntNodeMap _node_id;

     IntNodeMap _node_id;

     IntArcMap _arc_idf;

     IntArcMap _arc_idf;

     /// of the algorithm.

     /// of the algorithm.

     ///

     ///

     /// \return <tt>(*this)</tt>

     /// \return <tt>(*this)</tt>

     template <typename LowerMap>

     template <typename LowerMap>

     CycleCanceling& lowerMap(const LowerMap& map) {

     CycleCanceling& lowerMap(const LowerMap& map) {

       for (ArcIt a(_graph); a != INVALID; ++a) {

       for (ArcIt a(_graph); a != INVALID; ++a) {

         _lower[_arc_idf[a]] = map[a];

         _lower[_arc_idf[a]] = map[a];

       }

       }

       return *this;

       return *this;

     }

     }

         _lower[j] = 0;

         _lower[j] = 0;

         _upper[j] = INF;

         _upper[j] = INF;

         _cost[j] = 0;

         _cost[j] = 0;

         _cost[_reverse[j]] = 0;

         _cost[_reverse[j]] = 0;

       }

       }

       return *this;

       return *this;

     }

     }

     /// \brief Reset the internal data structures and all the parameters

     /// \brief Reset the internal data structures and all the parameters

     /// that have been given before.

     /// that have been given before.

       ValueVector excess(_supply);

       ValueVector excess(_supply);

       // Remove infinite upper bounds and check negative arcs

       // Remove infinite upper bounds and check negative arcs

       const Value MAX = std::numeric_limits<Value>::max();

       const Value MAX = std::numeric_limits<Value>::max();

       int last_out;

       int last_out;

         for (int i = 0; i != _root; ++i) {

         for (int i = 0; i != _root; ++i) {

           last_out = _first_out[i+1];

           last_out = _first_out[i+1];

           for (int j = _first_out[i]; j != last_out; ++j) {

           for (int j = _first_out[i]; j != last_out; ++j) {

             if (_forward[j]) {

             if (_forward[j]) {

               Value c = _cost[j] < 0 ? _upper[j] : _lower[j];

               Value c = _cost[j] < 0 ? _upper[j] : _lower[j];

       ValueArcMap cap(_graph), flow(_graph);

       ValueArcMap cap(_graph), flow(_graph);

       ValueNodeMap sup(_graph);

       ValueNodeMap sup(_graph);

       for (NodeIt n(_graph); n != INVALID; ++n) {

       for (NodeIt n(_graph); n != INVALID; ++n) {

         sup[n] = _supply[_node_id[n]];

         sup[n] = _supply[_node_id[n]];

       }

       }

         for (ArcIt a(_graph); a != INVALID; ++a) {

         for (ArcIt a(_graph); a != INVALID; ++a) {

           int j = _arc_idf[a];

           int j = _arc_idf[a];

           Value c = _lower[j];

           Value c = _lower[j];

           cap[a] = _upper[j] - c;

           cap[a] = _upper[j] - c;

           sup[_graph.source(a)] -= c;

           sup[_graph.source(a)] -= c;

         bf.init(0);

         bf.init(0);

         bf.start();

         bf.start();

       }

       }

       // Handle non-zero lower bounds

       // Handle non-zero lower bounds

         int limit = _first_out[_root];

         int limit = _first_out[_root];

         for (int j = 0; j != limit; ++j) {

         for (int j = 0; j != limit; ++j) {

           if (_forward[j]) _res_cap[_reverse[j]] += _lower[j];

           if (_forward[j]) _res_cap[_reverse[j]] += _lower[j];

         }

         }

       }

       }