#include <vector>

 #include <vector>

 #include <limits>

 #include <limits>

 #include <algorithm>

 #include <algorithm>

 #include <lemon/math.h>

 #include <lemon/math.h>

 namespace lemon {

 namespace lemon {

   /// \addtogroup min_cost_flow

   /// \addtogroup min_cost_flow

     };

     };

   private:

   private:

     // References for the original data

     // References for the original data

     const LowerMap *_orig_lower;

     const LowerMap *_orig_lower;

     const CapacityMap &_orig_cap;

     const CapacityMap &_orig_cap;

     const CostMap &_orig_cost;

     const CostMap &_orig_cost;

     const SupplyMap *_orig_supply;

     const SupplyMap *_orig_supply;

     Node _orig_source;

     Node _orig_source;

     Node _orig_target;

     Node _orig_target;

     Capacity _orig_flow_value;

     Capacity _orig_flow_value;

     // Result maps

     // Result maps

     bool _local_flow;

     bool _local_flow;

     bool _local_potential;

     bool _local_potential;

     // The number of nodes and arcs in the original graph

     // The number of nodes and arcs in the original graph

     int _node_num;

     int _node_num;

     int _arc_num;

     int _arc_num;

     // Node and arc maps

     // Node and arc maps

     CapacityVector _cap;

     CapacityVector _cap;

     CostVector _cost;

     CostVector _cost;

     CostVector _supply;

     CostVector _supply;

     CapacityVector _flow;

     CapacityVector _flow;

     CostVector _pi;

     CostVector _pi;

     IntVector _depth;

     IntVector _depth;

     IntVector _parent;

     IntVector _parent;

     IntVector _pred;

     IntVector _pred;

     IntVector _thread;

     IntVector _thread;

     BoolVector _forward;

     BoolVector _forward;

     IntVector _state;

     IntVector _state;

     int _root;

     int _root;

     // Temporary data used in the current pivot iteration

     // Temporary data used in the current pivot iteration

     int stem, par_stem, new_stem;

     int stem, par_stem, new_stem;

     Capacity delta;

     Capacity delta;

   private:

   private:

     class FirstEligiblePivotRule

     class FirstEligiblePivotRule

     {

     {

     private:

     private:

       // References to the NetworkSimplex class

       // References to the NetworkSimplex class

       const IntVector  &_source;

       const IntVector  &_source;

       const IntVector  &_target;

       const IntVector  &_target;

       const CostVector &_cost;

       const CostVector &_cost;

       const IntVector  &_state;

       const IntVector  &_state;

       const CostVector &_pi;

       const CostVector &_pi;

     public:

     public:

       /// Constructor

       /// Constructor

       FirstEligiblePivotRule(NetworkSimplex &ns) :

       FirstEligiblePivotRule(NetworkSimplex &ns) :

         _cost(ns._cost), _state(ns._state), _pi(ns._pi),

         _cost(ns._cost), _state(ns._state), _pi(ns._pi),

       {}

       {}

       /// Find next entering arc

       /// Find next entering arc

       bool findEnteringArc() {

       bool findEnteringArc() {

         Cost c;

         Cost c;

     class BestEligiblePivotRule

     class BestEligiblePivotRule

     {

     {

     private:

     private:

       // References to the NetworkSimplex class

       // References to the NetworkSimplex class

       const IntVector  &_source;

       const IntVector  &_source;

       const IntVector  &_target;

       const IntVector  &_target;

       const CostVector &_cost;

       const CostVector &_cost;

       const IntVector  &_state;

       const IntVector  &_state;

       const CostVector &_pi;

       const CostVector &_pi;

     public:

     public:

       /// Constructor

       /// Constructor

       BestEligiblePivotRule(NetworkSimplex &ns) :

       BestEligiblePivotRule(NetworkSimplex &ns) :

         _cost(ns._cost), _state(ns._state), _pi(ns._pi),

         _cost(ns._cost), _state(ns._state), _pi(ns._pi),

       {}

       {}

       /// Find next entering arc

       /// Find next entering arc

       bool findEnteringArc() {

       bool findEnteringArc() {

         Cost c, min = 0;

         Cost c, min = 0;

     class BlockSearchPivotRule

     class BlockSearchPivotRule

     {

     {

     private:

     private:

       // References to the NetworkSimplex class

       // References to the NetworkSimplex class

       const IntVector  &_source;

       const IntVector  &_source;

       const IntVector  &_target;

       const IntVector  &_target;

       const CostVector &_cost;

       const CostVector &_cost;

       const IntVector  &_state;

       const IntVector  &_state;

       const CostVector &_pi;

       const CostVector &_pi;

     public:

     public:

       /// Constructor

       /// Constructor

       BlockSearchPivotRule(NetworkSimplex &ns) :

       BlockSearchPivotRule(NetworkSimplex &ns) :

         _cost(ns._cost), _state(ns._state), _pi(ns._pi),

         _cost(ns._cost), _state(ns._state), _pi(ns._pi),

       {

       {

         // The main parameters of the pivot rule

         // The main parameters of the pivot rule

         const double BLOCK_SIZE_FACTOR = 2.0;

         const double BLOCK_SIZE_FACTOR = 2.0;

         const int MIN_BLOCK_SIZE = 10;

         const int MIN_BLOCK_SIZE = 10;

     class CandidateListPivotRule

     class CandidateListPivotRule

     {

     {

     private:

     private:

       // References to the NetworkSimplex class

       // References to the NetworkSimplex class

       const IntVector  &_source;

       const IntVector  &_source;

       const IntVector  &_target;

       const IntVector  &_target;

       const CostVector &_cost;

       const CostVector &_cost;

       const IntVector  &_state;

       const IntVector  &_state;

       const CostVector &_pi;

       const CostVector &_pi;

     public:

     public:

       /// Constructor

       /// Constructor

       CandidateListPivotRule(NetworkSimplex &ns) :

       CandidateListPivotRule(NetworkSimplex &ns) :

         _cost(ns._cost), _state(ns._state), _pi(ns._pi),

         _cost(ns._cost), _state(ns._state), _pi(ns._pi),

       {

       {

         // The main parameters of the pivot rule

         // The main parameters of the pivot rule

         const double LIST_LENGTH_FACTOR = 1.0;

         const double LIST_LENGTH_FACTOR = 1.0;

         const int MIN_LIST_LENGTH = 10;

         const int MIN_LIST_LENGTH = 10;

         const double MINOR_LIMIT_FACTOR = 0.1;

         const double MINOR_LIMIT_FACTOR = 0.1;

     class AlteringListPivotRule

     class AlteringListPivotRule

     {

     {

     private:

     private:

       // References to the NetworkSimplex class

       // References to the NetworkSimplex class

       const IntVector  &_source;

       const IntVector  &_source;

       const IntVector  &_target;

       const IntVector  &_target;

       const CostVector &_cost;

       const CostVector &_cost;

       const IntVector  &_state;

       const IntVector  &_state;

       const CostVector &_pi;

       const CostVector &_pi;

     public:

     public:

       /// Constructor

       /// Constructor

       AlteringListPivotRule(NetworkSimplex &ns) :

       AlteringListPivotRule(NetworkSimplex &ns) :

         _cost(ns._cost), _state(ns._state), _pi(ns._pi),

         _cost(ns._cost), _state(ns._state), _pi(ns._pi),

         _next_arc(0), _cand_cost(ns._arc_num), _sort_func(_cand_cost)

         _next_arc(0), _cand_cost(ns._arc_num), _sort_func(_cand_cost)

       {

       {

         // The main parameters of the pivot rule

         // The main parameters of the pivot rule

         const double BLOCK_SIZE_FACTOR = 1.5;

         const double BLOCK_SIZE_FACTOR = 1.5;

         const int MIN_BLOCK_SIZE = 10;

         const int MIN_BLOCK_SIZE = 10;

           }

           }

         }

         }

         // Extend the list

         // Extend the list

         int cnt = _block_size;

         int cnt = _block_size;

         int limit = _head_length;

         int limit = _head_length;

         for (int e = _next_arc; e < _arc_num; ++e) {

         for (int e = _next_arc; e < _arc_num; ++e) {

           _cand_cost[e] = _state[e] *

           _cand_cost[e] = _state[e] *

             (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);

             (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);

           if (_cand_cost[e] < 0) {

           if (_cand_cost[e] < 0) {

             _candidates[_curr_length++] = e;

             _candidates[_curr_length++] = e;

           }

           }

           if (--cnt == 0) {

           if (--cnt == 0) {

             if (_curr_length > limit) break;

             if (_curr_length > limit) break;

             limit = 0;

             limit = 0;

             cnt = _block_size;

             cnt = _block_size;

           for (int e = 0; e < _next_arc; ++e) {

           for (int e = 0; e < _next_arc; ++e) {

             _cand_cost[e] = _state[e] *

             _cand_cost[e] = _state[e] *

               (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);

               (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);

             if (_cand_cost[e] < 0) {

             if (_cand_cost[e] < 0) {

               _candidates[_curr_length++] = e;

               _candidates[_curr_length++] = e;

             }

             }

             if (--cnt == 0) {

             if (--cnt == 0) {

               if (_curr_length > limit) break;

               if (_curr_length > limit) break;

               limit = 0;

               limit = 0;

               cnt = _block_size;

               cnt = _block_size;

             }

             }

           }

           }

         }

         }

         if (_curr_length == 0) return false;

         if (_curr_length == 0) return false;

         // Make heap of the candidate list (approximating a partial sort)

         // Make heap of the candidate list (approximating a partial sort)

         make_heap( _candidates.begin(), _candidates.begin() + _curr_length,

         make_heap( _candidates.begin(), _candidates.begin() + _curr_length,

                    _sort_func );

                    _sort_func );

     /// \brief General constructor (with lower bounds).

     /// \brief General constructor (with lower bounds).

     ///

     ///

     /// General constructor (with lower bounds).

     /// General constructor (with lower bounds).

     ///

     ///

     /// \param lower The lower bounds of the arcs.

     /// \param lower The lower bounds of the arcs.

     /// \param capacity The capacities (upper bounds) of the arcs.

     /// \param capacity The capacities (upper bounds) of the arcs.

     /// \param cost The cost (length) values of the arcs.

     /// \param cost The cost (length) values of the arcs.

     /// \param supply The supply values of the nodes (signed).

     /// \param supply The supply values of the nodes (signed).

                     const LowerMap &lower,

                     const LowerMap &lower,

                     const CapacityMap &capacity,

                     const CapacityMap &capacity,

                     const CostMap &cost,

                     const CostMap &cost,

                     const SupplyMap &supply ) :

                     const SupplyMap &supply ) :

       _orig_cost(cost), _orig_supply(&supply),

       _orig_cost(cost), _orig_supply(&supply),

       _local_flow(false), _local_potential(false),

       _local_flow(false), _local_potential(false),

     {}

     {}

     /// \brief General constructor (without lower bounds).

     /// \brief General constructor (without lower bounds).

     ///

     ///

     /// General constructor (without lower bounds).

     /// General constructor (without lower bounds).

     ///

     ///

     /// \param capacity The capacities (upper bounds) of the arcs.

     /// \param capacity The capacities (upper bounds) of the arcs.

     /// \param cost The cost (length) values of the arcs.

     /// \param cost The cost (length) values of the arcs.

     /// \param supply The supply values of the nodes (signed).

     /// \param supply The supply values of the nodes (signed).

                     const CapacityMap &capacity,

                     const CapacityMap &capacity,

                     const CostMap &cost,

                     const CostMap &cost,

                     const SupplyMap &supply ) :

                     const SupplyMap &supply ) :

       _orig_cost(cost), _orig_supply(&supply),

       _orig_cost(cost), _orig_supply(&supply),

       _local_flow(false), _local_potential(false),

       _local_flow(false), _local_potential(false),

     {}

     {}

     /// \brief Simple constructor (with lower bounds).

     /// \brief Simple constructor (with lower bounds).

     ///

     ///

     /// Simple constructor (with lower bounds).

     /// Simple constructor (with lower bounds).

     ///

     ///

     /// \param lower The lower bounds of the arcs.

     /// \param lower The lower bounds of the arcs.

     /// \param capacity The capacities (upper bounds) of the arcs.

     /// \param capacity The capacities (upper bounds) of the arcs.

     /// \param cost The cost (length) values of the arcs.

     /// \param cost The cost (length) values of the arcs.

     /// \param s The source node.

     /// \param s The source node.

     /// \param t The target node.

     /// \param t The target node.

     /// \param flow_value The required amount of flow from node \c s

     /// \param flow_value The required amount of flow from node \c s

     /// to node \c t (i.e. the supply of \c s and the demand of \c t).

     /// to node \c t (i.e. the supply of \c s and the demand of \c t).

                     const LowerMap &lower,

                     const LowerMap &lower,

                     const CapacityMap &capacity,

                     const CapacityMap &capacity,

                     const CostMap &cost,

                     const CostMap &cost,

                     Node s, Node t,

                     Node s, Node t,

                     Capacity flow_value ) :

                     Capacity flow_value ) :

       _orig_cost(cost), _orig_supply(NULL),

       _orig_cost(cost), _orig_supply(NULL),

       _orig_source(s), _orig_target(t), _orig_flow_value(flow_value),

       _orig_source(s), _orig_target(t), _orig_flow_value(flow_value),

       _local_flow(false), _local_potential(false),

       _local_flow(false), _local_potential(false),

     {}

     {}

     /// \brief Simple constructor (without lower bounds).

     /// \brief Simple constructor (without lower bounds).

     ///

     ///

     /// Simple constructor (without lower bounds).

     /// Simple constructor (without lower bounds).

     ///

     ///

     /// \param capacity The capacities (upper bounds) of the arcs.

     /// \param capacity The capacities (upper bounds) of the arcs.

     /// \param cost The cost (length) values of the arcs.

     /// \param cost The cost (length) values of the arcs.

     /// \param s The source node.

     /// \param s The source node.

     /// \param t The target node.

     /// \param t The target node.

     /// \param flow_value The required amount of flow from node \c s

     /// \param flow_value The required amount of flow from node \c s

     /// to node \c t (i.e. the supply of \c s and the demand of \c t).

     /// to node \c t (i.e. the supply of \c s and the demand of \c t).

                     const CapacityMap &capacity,

                     const CapacityMap &capacity,

                     const CostMap &cost,

                     const CostMap &cost,

                     Node s, Node t,

                     Node s, Node t,

                     Capacity flow_value ) :

                     Capacity flow_value ) :

       _orig_cost(cost), _orig_supply(NULL),

       _orig_cost(cost), _orig_supply(NULL),

       _orig_source(s), _orig_target(t), _orig_flow_value(flow_value),

       _orig_source(s), _orig_target(t), _orig_flow_value(flow_value),

       _local_flow(false), _local_potential(false),

       _local_flow(false), _local_potential(false),

     {}

     {}

     /// Destructor.

     /// Destructor.

     ~NetworkSimplex() {

     ~NetworkSimplex() {

     }

     }

     /// \brief Set the flow map.

     /// \brief Set the flow map.

     ///

     ///

     /// This function sets the flow map.

     /// This function sets the flow map.

     ///

     ///

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

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

     NetworkSimplex& flowMap(FlowMap &map) {

     NetworkSimplex& flowMap(FlowMap &map) {

       if (_local_flow) {

       if (_local_flow) {

         _local_flow = false;

         _local_flow = false;

       }

       }

       return *this;

       return *this;

     }

     }

     /// \brief Set the potential map.

     /// \brief Set the potential map.

     ///

     ///

     /// This function sets the potential map.

     /// This function sets the potential map.

     ///

     ///

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

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

     NetworkSimplex& potentialMap(PotentialMap &map) {

     NetworkSimplex& potentialMap(PotentialMap &map) {

       if (_local_potential) {

       if (_local_potential) {

         _local_potential = false;

         _local_potential = false;

       }

       }

       return *this;

       return *this;

     }

     }

     /// \name Execution control

     /// \name Execution control

     /// The algorithm can be executed using the

     /// The algorithm can be executed using the

     /// This function returns a const reference to an arc map storing

     /// This function returns a const reference to an arc map storing

     /// the found flow.

     /// the found flow.

     ///

     ///

     /// \pre \ref run() must be called before using this function.

     /// \pre \ref run() must be called before using this function.

     const FlowMap& flowMap() const {

     const FlowMap& flowMap() const {

     }

     }

     /// \brief Return a const reference to the potential map

     /// \brief Return a const reference to the potential map

     /// (the dual solution).

     /// (the dual solution).

     ///

     ///

     /// This function returns a const reference to a node map storing

     /// This function returns a const reference to a node map storing

     /// the found potentials (the dual solution).

     /// the found potentials (the dual solution).

     ///

     ///

     /// \pre \ref run() must be called before using this function.

     /// \pre \ref run() must be called before using this function.

     const PotentialMap& potentialMap() const {

     const PotentialMap& potentialMap() const {

     }

     }

     /// \brief Return the flow on the given arc.

     /// \brief Return the flow on the given arc.

     ///

     ///

     /// This function returns the flow on the given arc.

     /// This function returns the flow on the given arc.

     ///

     ///

     /// \pre \ref run() must be called before using this function.

     /// \pre \ref run() must be called before using this function.

     Capacity flow(const Arc& arc) const {

     Capacity flow(const Arc& arc) const {

     }

     }

     /// \brief Return the potential of the given node.

     /// \brief Return the potential of the given node.

     ///

     ///

     /// This function returns the potential of the given node.

     /// This function returns the potential of the given node.

     ///

     ///

     /// \pre \ref run() must be called before using this function.

     /// \pre \ref run() must be called before using this function.

     Cost potential(const Node& node) const {

     Cost potential(const Node& node) const {

     }

     }

     /// \brief Return the total cost of the found flow.

     /// \brief Return the total cost of the found flow.

     ///

     ///

     /// This function returns the total cost of the found flow.

     /// This function returns the total cost of the found flow.

     /// The complexity of the function is \f$ O(e) \f$.

     /// The complexity of the function is \f$ O(e) \f$.

     ///

     ///

     /// \pre \ref run() must be called before using this function.

     /// \pre \ref run() must be called before using this function.

     Cost totalCost() const {

     Cost totalCost() const {

       Cost c = 0;

       Cost c = 0;

       return c;

       return c;

     }

     }

     /// @}

     /// @}

   private:

   private:

     // Initialize internal data structures

     // Initialize internal data structures

     bool init() {

     bool init() {

       // Initialize result maps

       // Initialize result maps

         _local_flow = true;

         _local_flow = true;

       }

       }

         _local_potential = true;

         _local_potential = true;

       }

       }

       // Initialize vectors

       // Initialize vectors

       int all_node_num = _node_num + 1;

       int all_node_num = _node_num + 1;

       _supply.resize(all_node_num);

       _supply.resize(all_node_num);

       _pi.resize(all_node_num, 0);

       _pi.resize(all_node_num, 0);

       _depth.resize(all_node_num);

       _depth.resize(all_node_num);

       _parent.resize(all_node_num);

       _parent.resize(all_node_num);

       _pred.resize(all_node_num);

       _pred.resize(all_node_num);

       _thread.resize(all_node_num);

       _thread.resize(all_node_num);

       // Initialize node related data

       // Initialize node related data

       bool valid_supply = true;

       bool valid_supply = true;

       if (_orig_supply) {

       if (_orig_supply) {

         Supply sum = 0;

         Supply sum = 0;

         int i = 0;

         int i = 0;

           _node_id[n] = i;

           _node_id[n] = i;

           _supply[i] = (*_orig_supply)[n];

           _supply[i] = (*_orig_supply)[n];

           sum += _supply[i];

           sum += _supply[i];

         }

         }

         valid_supply = (sum == 0);

         valid_supply = (sum == 0);

       } else {

       } else {

         int i = 0;

         int i = 0;

           _node_id[n] = i;

           _node_id[n] = i;

           _supply[i] = 0;

           _supply[i] = 0;

         }

         }

         _supply[_node_id[_orig_source]] =  _orig_flow_value;

         _supply[_node_id[_orig_source]] =  _orig_flow_value;

         _supply[_node_id[_orig_target]] = -_orig_flow_value;

         _supply[_node_id[_orig_target]] = -_orig_flow_value;

       _pi[_root] = 0;

       _pi[_root] = 0;

       // Store the arcs in a mixed order

       // Store the arcs in a mixed order

       int k = std::max(int(sqrt(_arc_num)), 10);

       int k = std::max(int(sqrt(_arc_num)), 10);

       int i = 0;

       int i = 0;

         if ((i += k) >= _arc_num) i = (i % k) + 1;

         if ((i += k) >= _arc_num) i = (i % k) + 1;

       }

       }

       // Initialize arc maps

       // Initialize arc maps

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

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

         _cost[i] = _orig_cost[e];

         _cost[i] = _orig_cost[e];

         _cap[i] = _orig_cap[e];

         _cap[i] = _orig_cap[e];

       }

       }

       // Remove non-zero lower bounds

       // Remove non-zero lower bounds

       if (_orig_lower) {

       if (_orig_lower) {

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

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

           if (c != 0) {

           if (c != 0) {

             _cap[i] -= c;

             _cap[i] -= c;

             _supply[_source[i]] -= c;

             _supply[_source[i]] -= c;

             _supply[_target[i]] += c;

             _supply[_target[i]] += c;

           }

           }

       return true;

       return true;

     }

     }

     // Find the join node

     // Find the join node

     void findJoinNode() {

     void findJoinNode() {

       while (_depth[u] > _depth[v]) u = _parent[u];

       while (_depth[u] > _depth[v]) u = _parent[u];

       while (_depth[v] > _depth[u]) v = _parent[v];

       while (_depth[v] > _depth[u]) v = _parent[v];

       while (u != v) {

       while (u != v) {

         u = _parent[u];

         u = _parent[u];

         v = _parent[v];

         v = _parent[v];

     // Find the leaving arc of the cycle and returns true if the

     // Find the leaving arc of the cycle and returns true if the

     // leaving arc is not the same as the entering arc

     // leaving arc is not the same as the entering arc

     bool findLeavingArc() {

     bool findLeavingArc() {

       // Initialize first and second nodes according to the direction

       // Initialize first and second nodes according to the direction

       // of the cycle

       // of the cycle

       } else {

       } else {

       int result = 0;

       int result = 0;

       Capacity d;

       Capacity d;

       int e;

       int e;

       // Search the cycle along the path form the first node to the root

       // Search the cycle along the path form the first node to the root

     // Change _flow and _state vectors

     // Change _flow and _state vectors

     void changeFlow(bool change) {

     void changeFlow(bool change) {

       // Augment along the cycle

       // Augment along the cycle

       if (delta > 0) {

       if (delta > 0) {

           _flow[_pred[u]] += _forward[u] ? -val : val;

           _flow[_pred[u]] += _forward[u] ? -val : val;

         }

         }

           _flow[_pred[u]] += _forward[u] ? val : -val;

           _flow[_pred[u]] += _forward[u] ? val : -val;

         }

         }

       }

       }

       // Update the state of the entering and leaving arcs

       // Update the state of the entering and leaving arcs

       if (change) {

       if (change) {

         _state[_pred[u_out]] =

         _state[_pred[u_out]] =

           (_flow[_pred[u_out]] == 0) ? STATE_LOWER : STATE_UPPER;

           (_flow[_pred[u_out]] == 0) ? STATE_LOWER : STATE_UPPER;

       } else {

       } else {

       }

       }

     }

     }

     // Update _thread and _parent vectors

     // Update _thread and _parent vectors

     void updateThreadParent() {

     void updateThreadParent() {

         v = _parent[u];

         v = _parent[u];

         _pred[u] = _pred[v];

         _pred[u] = _pred[v];

         _forward[u] = !_forward[v];

         _forward[u] = !_forward[v];

         u = v;

         u = v;

       }

       }

     }

     }

     // Update _depth and _potential vectors

     // Update _depth and _potential vectors

     void updateDepthPotential() {

     void updateDepthPotential() {

       _depth[u_in] = _depth[v_in] + 1;

       _depth[u_in] = _depth[v_in] + 1;

       // Check if the flow amount equals zero on all the artificial arcs

       // Check if the flow amount equals zero on all the artificial arcs

       for (int e = _arc_num; e != _arc_num + _node_num; ++e) {

       for (int e = _arc_num; e != _arc_num + _node_num; ++e) {

         if (_flow[e] > 0) return false;

         if (_flow[e] > 0) return false;

       }

       }

       if (_orig_lower) {

       if (_orig_lower) {

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

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

         }

         }

       } else {

       } else {

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

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

       }

       }

       return true;

       return true;

     }

     }