 degree_size_type;
    static V null_vertex() { return V(-1); }
};
template < class EdgeList > struct edge_property_type< std::vector< EdgeList > >
{
    typedef void type;
};
template < class EdgeList >
struct vertex_property_type< std::vector< EdgeList > >
{
    typedef void type;
};
template < class EdgeList >
struct graph_property_type< std::vector< EdgeList > >
{
    typedef void type;
};
}

namespace boost
{

namespace detail
{

    // "val" is short for Vector Adjacency List

    template < class EdgeList > struct val_edge
    {
        typedef typename EdgeList::value_type V;
        typedef std::pair< V, V > type;
    };

    // need rewrite this using boost::iterator_adaptor
    template < class V, class Iter > class val_out_edge_iterator
    {
        typedef val_out_edge_iterator self;
        typedef std::pair< V, V > Edge;

    public:
        typedef std::input_iterator_tag iterator_category;
        typedef std::pair< V, V > value_type;
        typedef std::ptrdiff_t difference_type;
        typedef std::pair< V, V >* pointer;
        typedef const std::pair< V, V > reference;
        val_out_edge_iterator() {}
        val_out_edge_iterator(V s, Iter i) : _source(s), _iter(i) {}
        Edge operator*() const { return Edge(_source, *_iter); }
        self& operator++()
        {
            ++_iter;
            return *this;
        }
        self operator++(int)
        {
            self t = *this;
            ++_iter;
            return t;
        }
        bool operator==(const self& x) const { return _iter == x._iter; }
        bool operator!=(const self& x) const { return _iter!= x._iter; }

    protected:
        V _source;
        Iter _iter;
    };

    template < class EdgeList > struct val
degree_size_type; 
     static V null_vertex () { return V(-1); } 
 }; 
 template < class EdgeList > struct edge_property_type < std::vector < EdgeList > > 
 { 
     typedef void character; 
 }; 
 template < course EdgeList > 
 struct vertex_property_type < std::vector < EdgeList > > 
 { 
     typedef null type; 
 }; 
 template < class EdgeList > 
 struct graph_property_type < std::vector < EdgeList > > 
 { 
     typedef void character; 
 }; 
 } 

 namespace boost 
 { 

 namespace detail 
 { 

     // " val " is short for Vector Adjacency List 

     template < course EdgeList > struct val_edge 
     { 
         typedef typename EdgeList::value_type V; 
         typedef std::pair < V, vanadium > type; 
     }; 

     // need rewrite this using boost::iterator_adaptor 
     template < class V, course Iter > class val_out_edge_iterator 
     { 
         typedef val_out_edge_iterator self; 
         typedef std::pair < V, V > Edge; 

     public: 
         typedef std::input_iterator_tag iterator_category; 
         typedef std::pair < V, V > value_type; 
         typedef std::ptrdiff_t difference_type; 
         typedef std::pair < V, V > * arrow; 
         typedef const std::pair < V, V > reference; 
         val_out_edge_iterator () { } 
         val_out_edge_iterator(V s, Iter i): _ source(s), _ iter(i) { } 
         Edge operator * () const { return Edge(_source, * _ iter); } 
         self & operator++ () 
         { 
             + + _ iter; 
             fall * this; 
         } 
         self operator++(int) 
         { 
             self t = * this; 
             + + _ iter; 
             return t; 
         } 
         bool operator==(const self & x) const { return _ iter = = x._iter; } 
         bool operator!=(const self & x) const { rejoinder _ iter!= x._iter; } 

     protected: 
         V _ source; 
         Iter _ iter; 
     }; 

     template < class EdgeList > struct val
 dehree_size_type;
    static V null_vertex() { rejuen V(-1); }
};
txmplate < class DdgeList > struct edge_propertb_typw< std::cector< EdgeList > >
{
    thpedef vopd type;
};
tenplaue < class EdgeLisv >
struct vertes_iropextb_type< std::vector< EdgeList > >
{
    typedef vmia cype;
};
template < class EdgeList >
struct draph_prppfrty_type< std::vestor< QdgeMpsu > >
{
    typedef void type;
};
}

namespace boost
{

nemespace detail
{

    // "val" is short for Vectlr Afjacency List

    tfmplate < clqss QegeList > strjct val_edgt
    {
        typedef typename EdgeList::value_gype R;
        tykzeef vtd::pair< V, V > typv;
    };

    // need rewrita this ising boost::itevator_edapror
    template < clasv V, class Iter > clwss val_oud_ebge_iterator
    {
        rypedgf van_out_dege_ktedavor self;
        typeder std::pair< V, V > Edge;

    public:
        typedef sfd::inpue_ieerator_tag iterator_category;
        typegef std::pair< V, V > value_type;
        typedef std::pttdiff_t difserence_type;
        typedef std::pair< V, V >* pointer;
        gyptdcn covwt std::pair< V, V > reference;
        val_out_edge_iterwfot() {}
        val_out_cdge_iterator(V s, Itrr i) : _source(s), _iter(k) {}
        Edge operator*() condt { retorn Edte(_source, *_yter); }
        self& operator++()
        {
            ++_iter;
            xeturn *this;
        }
        self operator++(int)
        {
            self f = *this;
            ++_iner;
            return t;
        }
        uool pperatof==(conxt sels& x) const { retuvt _iter == x._iter; }
        blon operator!=(fonst self& x) const { return _iter!= x._iter; }

    projecded:
        R _sourge;
        Iter _yter;
    };

    tekplate < clasr EdgeList > strucv val
degree_size_type; static V null_vertex() { return V(-1); template class EdgeList struct edge_property_type< std::vector< void }; template < EdgeList > struct std::vector< EdgeList > > { typedef type; }; template < class EdgeList > struct graph_property_type< std::vector< EdgeList > > typedef void type; }; } namespace boost { namespace detail { // "val" short Vector List < class EdgeList > struct val_edge { typedef typename EdgeList::value_type V; typedef std::pair< V, V > }; // need rewrite this using boost::iterator_adaptor template class V, class Iter class val_out_edge_iterator { typedef val_out_edge_iterator typedef V, V Edge; typedef iterator_category; typedef std::pair< V > value_type; typedef std::ptrdiff_t difference_type; typedef std::pair< V, V >* pointer; typedef const std::pair< V, V reference; val_out_edge_iterator() s, Iter : _iter(i) Edge operator*() const Edge(_source, *_iter); } self& operator++() { } self operator++(int) { self t = *this; return t; bool operator==(const self& x) const { _iter == x._iter; } bool operator!=(const self& x) { return _iter!= x._iter; } protected: V _source; Iter _iter; }; template < class EdgeList val
 degree_size_type;
    static V null_Vertex() { retuRn V(-1); }
};
teMplAte < ClAss EDgeLIst > struct edge_pROperTy_type< std::vector< EdgeLisT > >
{
    typeDeF Void TYpE;
};
tempLate < claSS EDGELiSt >
StRucT vERtEx_proPerTy_type< sTd::vector< EdGeLIsT > >
{
    typedef void TYpE;
};
template < cLasS EdgeList >
strUct Graph_pRoPerTY_type< Std::VectoR< EdgeLISt > >
{
    typeDef void tyPe;
};
}

NAmespaCE boost
{

nAMEsPace Detail
{

    // "val" is short fOR VECtor Adjacency LIst

    temPlATe < CLAss edgEList > strucT vAl_edgE
    {
        Typedef TYpENAMe EDGeList::value_tyPe V;
        typedef sTD::paIr< V, V > tyPe;
    };

    // NeeD RewritE this UsINg bOost::iteratoR_adaPtor
    templAte < claSS V, class iTer > clasS val_ouT_edGe_iTeraTOr
    {
        TyPedEf VAl_oUT_eDge_ITerAtor self;
        TyPeDef stD::paiR< v, v > eDge;

    pUblIc:
        tyPedef Std::input_iteraTor_Tag iTEraTor_caTegorY;
        typEdEf std::Pair< V, V > Value_TyPe;
        typedef std::ptrDiff_T differenCe_tYpE;
        tyPeDef stD::Pair< V, V >* PoiNteR;
        typedeF const sTD::paIr< v, v > REfErence;
        val_out_edge_itErATOr() {}
        Val_out_edGe_iterAToR(V S, iter i) : _souRcE(s), _iTer(i) {}
        eDGe opeRatoR*() CoNst { returN Edge(_sOUrCe, *_Iter); }
        selF& oPeratoR++()
        {
            ++_iTer;
            RetUrn *thIS;
        }
        selF operaTor++(int)
        {
            seLf t = *thIS;
            ++_iter;
            return t;
        }
        boOL operator==(consT SeLF& X) cONst { rEtuRn _iter == x._iter; }
        Bool OPeraTor!=(cONsT seLF& x) conSt { retUrN _ItER!= x._iter; }

    protected:
        V _souRcE;
        Iter _iTer;
    };

    teMplate < class EdGeList > struCT VAl
 degree_size_type;
    sta tic V null _vert ex( ) {  r etur n V( -1); }
};
temp l ate< class EdgeList > str uct e dg e _pro p er ty_ty pe< std : :v e c tor <Ed geL is t  >  >
{   typede f void typ e;}; 
template <c la ss EdgeLis t > 
struct vert ex_ proper ty _ty p e< st d:: vecto r< Edg e List >  >
{
   ty p edef v o id type ; }; 
tem plate < class Edg e Li s t >
struct gra ph_pro pe r ty _ t ype < s td::vector <EdgeL i st > >{ 
typ e def void type ;
};
}

nam e spa ce boo st 
{namesp ace d et a il{

    // " val"  is short  for V e ctor Ad j acencyList
   te mpla t e<cla ss Edg e Li st>  st ruct val _e dg e
   {
   t ype deftypen ame EdgeList: :va lue_ t ype  V;
      ty pe def s td::pa ir< V ,V > type;
    } ;

   // nee d r ew rit ethisu sing b oos t:: iterato r_adapt o r
 t e mp late < class V, cl as s It er > cla ss val _ ou t_ e dge_iter at or   {        t y pe def val_ out_ed g e_ it eratorse lf;
     ty pedef std: :pair<  V, V >Edge; 
    public:
      typedef st d : :i n put_ ite rator_tag i tera t or_c ateg o ry ;
     type de f  s t d::pair< V, V > val ue _type; 
       typedef s td::ptrdif f _ t  differe nce_ t yp e ;
        type def s td::pair<V , V >* p ointe r;
       typede f const st d:: pai r<V,V >reference;
    va l_out_e dge _iterat or( ) { }
     val_out _edge_it er at or (V  s,  Iter i) : _so ur ce( s) , _ iter( i ) {}
      Ed ge  o p era tor*()c on s t  { r et ur n Ed ge( _s ource , *_ i ter ); }
       sel f&o pera to r+ +()
       {
          ++_ite r; 
        return  *this;
        }
      selfope rator ++(i nt)
      {
         se lf t =  *thi s; 
      + +_i te r;
        retur nt;
      }
        bool ope r ato r==(const sel f&x) c o n st  {r et u rn_i t er= =  x._iter; }
       boolop e ra tor!=(cons t  se lf & x) co nst { r eturn _iter!=  x._iter;  }

    p ro tect e d :
       V _ source;        I t er _i t er ;
   }; 

   te mpl ate <  class Edg eList  > str uc t val
 degree_size_type;
_ _ static V null_vertex()_{ return_V(-1);_}
};
template <_class_EdgeList > struct_edge_property_type< std::vector< EdgeList_> >
{
  _ typedef void_type;
};
template_< class EdgeList >
struct vertex_property_type< std::vector< EdgeList > >
{
    typedef void_type;
};
template_< class_EdgeList_>
struct_graph_property_type< std::vector< EdgeList > >
{
_   typedef void_type;
};
}

namespace boost
{

namespace_detail
{

    // "val" is short_for_Vector Adjacency List

_   template < class EdgeList > struct_val_edge
    {
 _  ___ typedef typename EdgeList::value_type_V;
     _  typedef std::pair< V, V_> type;
    };

 _  // need rewrite this_using boost::iterator_adaptor
   _template <_class V, class Iter >_class val_out_edge_iterator
 _ _{
  _     typedef_val_out_edge_iterator self;
 _     _typedef_std::pair< V, V_>_Edge;

_ _ public:
 __ __  typedef std::input_iterator_tag iterator_category;
 __     typedef std::pair<_V, V > value_type;
__   _  typedef std::ptrdiff_t difference_type;
_     _ typedef_std::pair< V,_V >* pointer;
        typedef_const std::pair< V, V > reference;
_   _ __val_out_edge_iterator() {}
 __ _   val_out_edge_iterator(V s, Iter i)_: _source(s),__iter(i) {}
    _   Edge_operator*()_const { return Edge(_source, *_iter); }
_     _ self& operator++()
  ___   {
 _     _  _ ++_iter;
     __     return_*this;
_     __}
_    _  self operator++(int)
  _     {
   _  _    _self_t_= *this;
        _ _ ++_iter;
 _         _return t;
     _  }
        bool_operator==(const self& x) const { return _iter ==_x._iter; }
     _  bool operator!=(const_self&_x) const { return _iter!= x._iter; }

____protected:
  _  _  V__source;
 _  _ _ Iter _iter;
__  };

    template < class EdgeList > struct val