#include "pp.h"



int Path_constraint_exp::isThruAltEdgeInTheList( Vertex*  s,Term*  t )
{
  DEM_TRACE("Path_constraint_exp","int Path_constraint_exp::isThruAltEdgeInTheList(Vertex*  s,Term*  t)");
  int return_val;

  this->isThruAltEdgeInTheList_( return_val, s ,  t  );
  return return_val;
}
void Path_constraint_exp::isThruAltEdgeInTheList_( int& return_val, Vertex*  s,Term*  t )
{
  DEM_TRACE("Path_constraint_exp","void Path_constraint_exp::isThruAltEdgeInTheList_(int& return_val,Vertex*  s,Term*  t)");
  // prefix class wrappers

    return_val = 0;


  // suffix class wrappers

}

int Require_through::isThruAltEdgeInTheList( Vertex*  s,Term*  t )
{
  DEM_TRACE("Require_through","int Require_through::isThruAltEdgeInTheList(Vertex*  s,Term*  t)");
  int return_val;

  this->isThruAltEdgeInTheList_( return_val, s ,  t  );
  return return_val;
}
void Require_through::isThruAltEdgeInTheList_( int& return_val, Vertex*  s,Term*  t )
{
  DEM_TRACE("Require_through","void Require_through::isThruAltEdgeInTheList_(int& return_val,Vertex*  s,Term*  t)");
  // prefix class wrappers

   return_val = through->isThruAltEdgeInTheList(s, t);


  // suffix class wrappers

}

int Require_bypassing::isThruAltEdgeInTheList( Vertex*  s,Term*  t )
{
  DEM_TRACE("Require_bypassing","int Require_bypassing::isThruAltEdgeInTheList(Vertex*  s,Term*  t)");
  int return_val;

  this->isThruAltEdgeInTheList_( return_val, s ,  t  );
  return return_val;
}
void Require_bypassing::isThruAltEdgeInTheList_( int& return_val, Vertex*  s,Term*  t )
{
  DEM_TRACE("Require_bypassing","void Require_bypassing::isThruAltEdgeInTheList_(int& return_val,Vertex*  s,Term*  t)");
  // prefix class wrappers

   if (through)
     return_val = through->isThruAltEdgeInTheList(s, t);
   else
     return_val = 0;


  // suffix class wrappers

}

int Through_path_constraint::isThruAltEdgeInTheList( Vertex*  s,Term*  t )
{
  DEM_TRACE("Through_path_constraint","int Through_path_constraint::isThruAltEdgeInTheList(Vertex*  s,Term*  t)");
  int return_val;

  this->isThruAltEdgeInTheList_( return_val, s ,  t  );
  return return_val;
}
void Through_path_constraint::isThruAltEdgeInTheList_( int& return_val, Vertex*  s,Term*  t )
{
  DEM_TRACE("Through_path_constraint","void Through_path_constraint::isThruAltEdgeInTheList_(int& return_val,Vertex*  s,Term*  t)");
  // prefix class wrappers

   return_val = through->isAltEdgeInTheList(s, t);


  // suffix class wrappers

}

int Path_constraint_exp::isXAltEdgeInTheList( Vertex*  s,Term*  t )
{
  DEM_TRACE("Path_constraint_exp","int Path_constraint_exp::isXAltEdgeInTheList(Vertex*  s,Term*  t)");
  int return_val;

  this->isXAltEdgeInTheList_( return_val, s ,  t  );
  return return_val;
}
void Path_constraint_exp::isXAltEdgeInTheList_( int& return_val, Vertex*  s,Term*  t )
{
  DEM_TRACE("Path_constraint_exp","void Path_constraint_exp::isXAltEdgeInTheList_(int& return_val,Vertex*  s,Term*  t)");
  // prefix class wrappers

    return_val = 0;


  // suffix class wrappers

}

int Require_through::isXAltEdgeInTheList( Vertex*  s,Term*  t )
{
  DEM_TRACE("Require_through","int Require_through::isXAltEdgeInTheList(Vertex*  s,Term*  t)");
  int return_val;

  this->isXAltEdgeInTheList_( return_val, s ,  t  );
  return return_val;
}
void Require_through::isXAltEdgeInTheList_( int& return_val, Vertex*  s,Term*  t )
{
  DEM_TRACE("Require_through","void Require_through::isXAltEdgeInTheList_(int& return_val,Vertex*  s,Term*  t)");
  // prefix class wrappers

   if (bypassing)
     return_val = bypassing->isXAltEdgeInTheList(s, t);
   else
     return_val = 0;


  // suffix class wrappers

}

int Require_bypassing::isXAltEdgeInTheList( Vertex*  s,Term*  t )
{
  DEM_TRACE("Require_bypassing","int Require_bypassing::isXAltEdgeInTheList(Vertex*  s,Term*  t)");
  int return_val;

  this->isXAltEdgeInTheList_( return_val, s ,  t  );
  return return_val;
}
void Require_bypassing::isXAltEdgeInTheList_( int& return_val, Vertex*  s,Term*  t )
{
  DEM_TRACE("Require_bypassing","void Require_bypassing::isXAltEdgeInTheList_(int& return_val,Vertex*  s,Term*  t)");
  // prefix class wrappers

   return_val = bypassing->isXAltEdgeInTheList(s, t);


  // suffix class wrappers

}

int Bypassing_path_constraint::isXAltEdgeInTheList( Vertex*  s,Term*  t )
{
  DEM_TRACE("Bypassing_path_constraint","int Bypassing_path_constraint::isXAltEdgeInTheList(Vertex*  s,Term*  t)");
  int return_val;

  this->isXAltEdgeInTheList_( return_val, s ,  t  );
  return return_val;
}
void Bypassing_path_constraint::isXAltEdgeInTheList_( int& return_val, Vertex*  s,Term*  t )
{
  DEM_TRACE("Bypassing_path_constraint","void Bypassing_path_constraint::isXAltEdgeInTheList_(int& return_val,Vertex*  s,Term*  t)");
  // prefix class wrappers

   return_val = bypassing->isAltEdgeInTheList(s, t);


  // suffix class wrappers

}

int Meta_edge_Commalist::isAltEdgeInTheList( Vertex*  s,Term*  t )
{
  DEM_TRACE("Meta_edge_Commalist","int Meta_edge_Commalist::isAltEdgeInTheList(Vertex*  s,Term*  t)");
  int return_val;

  this->isAltEdgeInTheList_( return_val, s ,  t  );
  return return_val;
}
void Meta_edge_Commalist::isAltEdgeInTheList_( int& return_val, Vertex*  s,Term*  t )
{
  DEM_TRACE("Meta_edge_Commalist","void Meta_edge_Commalist::isAltEdgeInTheList_(int& return_val,Vertex*  s,Term*  t)");
  // prefix class wrappers

    Meta_edge_list_iterator   next(*this);
    Meta_edge*                each;
    while (each = next())
      if (each->isAltEdgeInTheList(s,t))
	 break;
    if (each)
      return_val = 1;
    else
      return_val = 0;


  // suffix class wrappers

}

int Meta_edge::isAltEdgeInTheList( Vertex*  s,Term*  t )
{
  DEM_TRACE("Meta_edge","int Meta_edge::isAltEdgeInTheList(Vertex*  s,Term*  t)");
  int return_val;

  this->isAltEdgeInTheList_( return_val, s ,  t  );
  return return_val;
}
void Meta_edge::isAltEdgeInTheList_( int& return_val, Vertex*  s,Term*  t )
{
  DEM_TRACE("Meta_edge","void Meta_edge::isAltEdgeInTheList_(int& return_val,Vertex*  s,Term*  t)");
  // prefix class wrappers

   return_val = 0;


  // suffix class wrappers

}

int Meta_alternation_edge::isAltEdgeInTheList( Vertex*  s,Term*  t )
{
  DEM_TRACE("Meta_alternation_edge","int Meta_alternation_edge::isAltEdgeInTheList(Vertex*  s,Term*  t)");
  int return_val;

  this->isAltEdgeInTheList_( return_val, s ,  t  );
  return return_val;
}
void Meta_alternation_edge::isAltEdgeInTheList_( int& return_val, Vertex*  s,Term*  t )
{
  DEM_TRACE("Meta_alternation_edge","void Meta_alternation_edge::isAltEdgeInTheList_(int& return_val,Vertex*  s,Term*  t)");
  // prefix class wrappers

   int matched = 0;
   this->get_from()->match_vertex(s,matched);
   if (matched == 0)
     {
       return_val = 0;
     }
   else
     {
       matched = 0;
       this->get_to()->match_vertex(t,matched);
       return_val = matched;
     }


  // suffix class wrappers

}

int Path_constraint_exp::isXConsEdgeInTheList( Vertex*  s,DemIdent*  l,Term*  t )
{
  DEM_TRACE("Path_constraint_exp","int Path_constraint_exp::isXConsEdgeInTheList(Vertex*  s,DemIdent*  l,Term*  t)");
  int return_val;

  this->isXConsEdgeInTheList_( return_val, s ,  l ,  t  );
  return return_val;
}
void Path_constraint_exp::isXConsEdgeInTheList_( int& return_val, Vertex*  s,DemIdent*  l,Term*  t )
{
  DEM_TRACE("Path_constraint_exp","void Path_constraint_exp::isXConsEdgeInTheList_(int& return_val,Vertex*  s,DemIdent*  l,Term*  t)");
  // prefix class wrappers

    return_val = 0;


  // suffix class wrappers

}

int Require_through::isXConsEdgeInTheList( Vertex*  s,DemIdent*  l,Term*  t )
{
  DEM_TRACE("Require_through","int Require_through::isXConsEdgeInTheList(Vertex*  s,DemIdent*  l,Term*  t)");
  int return_val;

  this->isXConsEdgeInTheList_( return_val, s ,  l ,  t  );
  return return_val;
}
void Require_through::isXConsEdgeInTheList_( int& return_val, Vertex*  s,DemIdent*  l,Term*  t )
{
  DEM_TRACE("Require_through","void Require_through::isXConsEdgeInTheList_(int& return_val,Vertex*  s,DemIdent*  l,Term*  t)");
  // prefix class wrappers

   if (bypassing)
     return_val = bypassing->isXConsEdgeInTheList(s, l, t);
   else
     return_val = 0;


  // suffix class wrappers

}

int Require_bypassing::isXConsEdgeInTheList( Vertex*  s,DemIdent*  l,Term*  t )
{
  DEM_TRACE("Require_bypassing","int Require_bypassing::isXConsEdgeInTheList(Vertex*  s,DemIdent*  l,Term*  t)");
  int return_val;

  this->isXConsEdgeInTheList_( return_val, s ,  l ,  t  );
  return return_val;
}
void Require_bypassing::isXConsEdgeInTheList_( int& return_val, Vertex*  s,DemIdent*  l,Term*  t )
{
  DEM_TRACE("Require_bypassing","void Require_bypassing::isXConsEdgeInTheList_(int& return_val,Vertex*  s,DemIdent*  l,Term*  t)");
  // prefix class wrappers

   return_val = bypassing->isXConsEdgeInTheList(s, l, t);


  // suffix class wrappers

}

int Bypassing_path_constraint::isXConsEdgeInTheList( Vertex*  s,DemIdent*  l,Term*  t )
{
  DEM_TRACE("Bypassing_path_constraint","int Bypassing_path_constraint::isXConsEdgeInTheList(Vertex*  s,DemIdent*  l,Term*  t)");
  int return_val;

  this->isXConsEdgeInTheList_( return_val, s ,  l ,  t  );
  return return_val;
}
void Bypassing_path_constraint::isXConsEdgeInTheList_( int& return_val, Vertex*  s,DemIdent*  l,Term*  t )
{
  DEM_TRACE("Bypassing_path_constraint","void Bypassing_path_constraint::isXConsEdgeInTheList_(int& return_val,Vertex*  s,DemIdent*  l,Term*  t)");
  // prefix class wrappers

   return_val = bypassing->isConsEdgeInTheList(s, l, t);


  // suffix class wrappers

}

int Path_constraint_exp::isThruConsEdgeInTheList( Vertex*  s,DemIdent*  l,Term*  t )
{
  DEM_TRACE("Path_constraint_exp","int Path_constraint_exp::isThruConsEdgeInTheList(Vertex*  s,DemIdent*  l,Term*  t)");
  int return_val;

  this->isThruConsEdgeInTheList_( return_val, s ,  l ,  t  );
  return return_val;
}
void Path_constraint_exp::isThruConsEdgeInTheList_( int& return_val, Vertex*  s,DemIdent*  l,Term*  t )
{
  DEM_TRACE("Path_constraint_exp","void Path_constraint_exp::isThruConsEdgeInTheList_(int& return_val,Vertex*  s,DemIdent*  l,Term*  t)");
  // prefix class wrappers

    return_val = 0;


  // suffix class wrappers

}

int Require_through::isThruConsEdgeInTheList( Vertex*  s,DemIdent*  l,Term*  t )
{
  DEM_TRACE("Require_through","int Require_through::isThruConsEdgeInTheList(Vertex*  s,DemIdent*  l,Term*  t)");
  int return_val;

  this->isThruConsEdgeInTheList_( return_val, s ,  l ,  t  );
  return return_val;
}
void Require_through::isThruConsEdgeInTheList_( int& return_val, Vertex*  s,DemIdent*  l,Term*  t )
{
  DEM_TRACE("Require_through","void Require_through::isThruConsEdgeInTheList_(int& return_val,Vertex*  s,DemIdent*  l,Term*  t)");
  // prefix class wrappers

   return_val = through->isThruConsEdgeInTheList(s, l, t);


  // suffix class wrappers

}

int Require_bypassing::isThruConsEdgeInTheList( Vertex*  s,DemIdent*  l,Term*  t )
{
  DEM_TRACE("Require_bypassing","int Require_bypassing::isThruConsEdgeInTheList(Vertex*  s,DemIdent*  l,Term*  t)");
  int return_val;

  this->isThruConsEdgeInTheList_( return_val, s ,  l ,  t  );
  return return_val;
}
void Require_bypassing::isThruConsEdgeInTheList_( int& return_val, Vertex*  s,DemIdent*  l,Term*  t )
{
  DEM_TRACE("Require_bypassing","void Require_bypassing::isThruConsEdgeInTheList_(int& return_val,Vertex*  s,DemIdent*  l,Term*  t)");
  // prefix class wrappers

   if (through)
     return_val = through->isThruConsEdgeInTheList(s, l, t);
   else
     return_val = 0;


  // suffix class wrappers

}

int Through_path_constraint::isThruConsEdgeInTheList( Vertex*  s,DemIdent*  l,Term*  t )
{
  DEM_TRACE("Through_path_constraint","int Through_path_constraint::isThruConsEdgeInTheList(Vertex*  s,DemIdent*  l,Term*  t)");
  int return_val;

  this->isThruConsEdgeInTheList_( return_val, s ,  l ,  t  );
  return return_val;
}
void Through_path_constraint::isThruConsEdgeInTheList_( int& return_val, Vertex*  s,DemIdent*  l,Term*  t )
{
  DEM_TRACE("Through_path_constraint","void Through_path_constraint::isThruConsEdgeInTheList_(int& return_val,Vertex*  s,DemIdent*  l,Term*  t)");
  // prefix class wrappers

   return_val = through->isConsEdgeInTheList(s, l, t);


  // suffix class wrappers

}

int Meta_edge_Commalist::isConsEdgeInTheList( Vertex*  s,DemIdent*  l,Term*  t )
{
  DEM_TRACE("Meta_edge_Commalist","int Meta_edge_Commalist::isConsEdgeInTheList(Vertex*  s,DemIdent*  l,Term*  t)");
  int return_val;

  this->isConsEdgeInTheList_( return_val, s ,  l ,  t  );
  return return_val;
}
void Meta_edge_Commalist::isConsEdgeInTheList_( int& return_val, Vertex*  s,DemIdent*  l,Term*  t )
{
  DEM_TRACE("Meta_edge_Commalist","void Meta_edge_Commalist::isConsEdgeInTheList_(int& return_val,Vertex*  s,DemIdent*  l,Term*  t)");
  // prefix class wrappers

    Meta_edge_list_iterator   next(*this);
    Meta_edge*                each;
    while (each = next())
      if (each->isConsEdgeInTheList(s,l,t))
	break;
    if (each)
       return_val = 1;
    else
       return_val = 0;


  // suffix class wrappers

}

int Meta_edge::isConsEdgeInTheList( Vertex*  s,DemIdent*  l,Term*  t )
{
  DEM_TRACE("Meta_edge","int Meta_edge::isConsEdgeInTheList(Vertex*  s,DemIdent*  l,Term*  t)");
  int return_val;

  this->isConsEdgeInTheList_( return_val, s ,  l ,  t  );
  return return_val;
}
void Meta_edge::isConsEdgeInTheList_( int& return_val, Vertex*  s,DemIdent*  l,Term*  t )
{
  DEM_TRACE("Meta_edge","void Meta_edge::isConsEdgeInTheList_(int& return_val,Vertex*  s,DemIdent*  l,Term*  t)");
  // prefix class wrappers

   return_val = 0;


  // suffix class wrappers

}

int Meta_construction_edge::isConsEdgeInTheList( Vertex*  s,DemIdent*  l,Term*  t )
{
  DEM_TRACE("Meta_construction_edge","int Meta_construction_edge::isConsEdgeInTheList(Vertex*  s,DemIdent*  l,Term*  t)");
  int return_val;

  this->isConsEdgeInTheList_( return_val, s ,  l ,  t  );
  return return_val;
}
void Meta_construction_edge::isConsEdgeInTheList_( int& return_val, Vertex*  s,DemIdent*  l,Term*  t )
{
  DEM_TRACE("Meta_construction_edge","void Meta_construction_edge::isConsEdgeInTheList_(int& return_val,Vertex*  s,DemIdent*  l,Term*  t)");
  // prefix class wrappers

   int matched = 0;
   this->get_from()->match_vertex(s,matched);
   if (matched == 0)
     {
       return_val = 0;
     }
   else
     {
       matched = 0;
       this->get_to()->match_vertex(t,matched);
       if (matched == 0)
         return_val = 0;
       else
         {
           matched = 0;
           this->get_edge_label()->match_label(l,matched);
           return_val = matched;
         }
     }


  // suffix class wrappers

}

int Path_constraint_exp::isXInhEdgeInTheList( Vertex*  s,Vertex*  t )
{
  DEM_TRACE("Path_constraint_exp","int Path_constraint_exp::isXInhEdgeInTheList(Vertex*  s,Vertex*  t)");
  int return_val;

  this->isXInhEdgeInTheList_( return_val, s ,  t  );
  return return_val;
}
void Path_constraint_exp::isXInhEdgeInTheList_( int& return_val, Vertex*  s,Vertex*  t )
{
  DEM_TRACE("Path_constraint_exp","void Path_constraint_exp::isXInhEdgeInTheList_(int& return_val,Vertex*  s,Vertex*  t)");
  // prefix class wrappers

    return_val = 0;


  // suffix class wrappers

}

int Require_through::isXInhEdgeInTheList( Vertex*  s,Vertex*  t )
{
  DEM_TRACE("Require_through","int Require_through::isXInhEdgeInTheList(Vertex*  s,Vertex*  t)");
  int return_val;

  this->isXInhEdgeInTheList_( return_val, s ,  t  );
  return return_val;
}
void Require_through::isXInhEdgeInTheList_( int& return_val, Vertex*  s,Vertex*  t )
{
  DEM_TRACE("Require_through","void Require_through::isXInhEdgeInTheList_(int& return_val,Vertex*  s,Vertex*  t)");
  // prefix class wrappers

   if (bypassing)
     return_val = bypassing->isXInhEdgeInTheList(s, t);
   else
     return_val = 0;


  // suffix class wrappers

}

int Require_bypassing::isXInhEdgeInTheList( Vertex*  s,Vertex*  t )
{
  DEM_TRACE("Require_bypassing","int Require_bypassing::isXInhEdgeInTheList(Vertex*  s,Vertex*  t)");
  int return_val;

  this->isXInhEdgeInTheList_( return_val, s ,  t  );
  return return_val;
}
void Require_bypassing::isXInhEdgeInTheList_( int& return_val, Vertex*  s,Vertex*  t )
{
  DEM_TRACE("Require_bypassing","void Require_bypassing::isXInhEdgeInTheList_(int& return_val,Vertex*  s,Vertex*  t)");
  // prefix class wrappers

   return_val = bypassing->isXInhEdgeInTheList(s, t);


  // suffix class wrappers

}

int Bypassing_path_constraint::isXInhEdgeInTheList( Vertex*  s,Vertex*  t )
{
  DEM_TRACE("Bypassing_path_constraint","int Bypassing_path_constraint::isXInhEdgeInTheList(Vertex*  s,Vertex*  t)");
  int return_val;

  this->isXInhEdgeInTheList_( return_val, s ,  t  );
  return return_val;
}
void Bypassing_path_constraint::isXInhEdgeInTheList_( int& return_val, Vertex*  s,Vertex*  t )
{
  DEM_TRACE("Bypassing_path_constraint","void Bypassing_path_constraint::isXInhEdgeInTheList_(int& return_val,Vertex*  s,Vertex*  t)");
  // prefix class wrappers

   return_val = bypassing->isInhEdgeInTheList(s, t);


  // suffix class wrappers

}

int Meta_edge_Commalist::isInhEdgeInTheList( Vertex*  s,Vertex*  t )
{
  DEM_TRACE("Meta_edge_Commalist","int Meta_edge_Commalist::isInhEdgeInTheList(Vertex*  s,Vertex*  t)");
  int return_val;

  this->isInhEdgeInTheList_( return_val, s ,  t  );
  return return_val;
}
void Meta_edge_Commalist::isInhEdgeInTheList_( int& return_val, Vertex*  s,Vertex*  t )
{
  DEM_TRACE("Meta_edge_Commalist","void Meta_edge_Commalist::isInhEdgeInTheList_(int& return_val,Vertex*  s,Vertex*  t)");
  // prefix class wrappers

    Meta_edge_list_iterator   next(*this);
    Meta_edge*                each;
    while (each = next())
      if (each->isInhEdgeInTheList(s,t))
	break;
    if (each)
      return_val = 1;
    else
      return_val = 0;


  // suffix class wrappers

}

int Meta_edge::isInhEdgeInTheList( Vertex*  s,Vertex*  t )
{
  DEM_TRACE("Meta_edge","int Meta_edge::isInhEdgeInTheList(Vertex*  s,Vertex*  t)");
  int return_val;

  this->isInhEdgeInTheList_( return_val, s ,  t  );
  return return_val;
}
void Meta_edge::isInhEdgeInTheList_( int& return_val, Vertex*  s,Vertex*  t )
{
  DEM_TRACE("Meta_edge","void Meta_edge::isInhEdgeInTheList_(int& return_val,Vertex*  s,Vertex*  t)");
  // prefix class wrappers

   return_val = 0;


  // suffix class wrappers

}

int Meta_inheritance_edge::isInhEdgeInTheList( Vertex*  s,Vertex*  t )
{
  DEM_TRACE("Meta_inheritance_edge","int Meta_inheritance_edge::isInhEdgeInTheList(Vertex*  s,Vertex*  t)");
  int return_val;

  this->isInhEdgeInTheList_( return_val, s ,  t  );
  return return_val;
}
void Meta_inheritance_edge::isInhEdgeInTheList_( int& return_val, Vertex*  s,Vertex*  t )
{
  DEM_TRACE("Meta_inheritance_edge","void Meta_inheritance_edge::isInhEdgeInTheList_(int& return_val,Vertex*  s,Vertex*  t)");
  // prefix class wrappers

   int matched = 0;
   this->get_from()->match_vertex(s,matched);
   if (matched == 0)
       return_val = 0;
   else
     {
       matched = 0;
       this->get_to()->match_vertex(t,matched);
       return_val = matched;
     }


  // suffix class wrappers

}

int Meta_edge_Commalist::isRepEdgeInTheList( Vertex*  s,Term*  t )
{
  DEM_TRACE("Meta_edge_Commalist","int Meta_edge_Commalist::isRepEdgeInTheList(Vertex*  s,Term*  t)");
  int return_val;

  this->isRepEdgeInTheList_( return_val, s ,  t  );
  return return_val;
}
void Meta_edge_Commalist::isRepEdgeInTheList_( int& return_val, Vertex*  s,Term*  t )
{
  DEM_TRACE("Meta_edge_Commalist","void Meta_edge_Commalist::isRepEdgeInTheList_(int& return_val,Vertex*  s,Term*  t)");
  // prefix class wrappers

    Meta_edge_list_iterator   next(*this);
    Meta_edge*                each;
    while (each = next())
      if (each->isRepEdgeInTheList(s,t))
        break;

    if (each)
       return_val = 1;
    else
       return_val = 0;


  // suffix class wrappers

}

int Meta_edge::isRepEdgeInTheList( Vertex*  s,Term*  t )
{
  DEM_TRACE("Meta_edge","int Meta_edge::isRepEdgeInTheList(Vertex*  s,Term*  t)");
  int return_val;

  this->isRepEdgeInTheList_( return_val, s ,  t  );
  return return_val;
}
void Meta_edge::isRepEdgeInTheList_( int& return_val, Vertex*  s,Term*  t )
{
  DEM_TRACE("Meta_edge","void Meta_edge::isRepEdgeInTheList_(int& return_val,Vertex*  s,Term*  t)");
  // prefix class wrappers

   return_val = 0;


  // suffix class wrappers

}

int Meta_repetition_edge::isRepEdgeInTheList( Vertex*  s,Term*  t )
{
  DEM_TRACE("Meta_repetition_edge","int Meta_repetition_edge::isRepEdgeInTheList(Vertex*  s,Term*  t)");
  int return_val;

  this->isRepEdgeInTheList_( return_val, s ,  t  );
  return return_val;
}
void Meta_repetition_edge::isRepEdgeInTheList_( int& return_val, Vertex*  s,Term*  t )
{
  DEM_TRACE("Meta_repetition_edge","void Meta_repetition_edge::isRepEdgeInTheList_(int& return_val,Vertex*  s,Term*  t)");
  // prefix class wrappers

   int matched = 0;
   this->get_from()->match_vertex(s,matched);
   if (matched == 0)
     return_val = 0;
   else
     {
        matched = 0;
        this->get_to()->match_vertex(t,matched);
        return_val = matched;
     }


  // suffix class wrappers

}

int Path_constraint_exp::isXRepEdgeInTheList( Vertex*  s,Term*  t )
{
  DEM_TRACE("Path_constraint_exp","int Path_constraint_exp::isXRepEdgeInTheList(Vertex*  s,Term*  t)");
  int return_val;

  this->isXRepEdgeInTheList_( return_val, s ,  t  );
  return return_val;
}
void Path_constraint_exp::isXRepEdgeInTheList_( int& return_val, Vertex*  s,Term*  t )
{
  DEM_TRACE("Path_constraint_exp","void Path_constraint_exp::isXRepEdgeInTheList_(int& return_val,Vertex*  s,Term*  t)");
  // prefix class wrappers

    return_val = 0;


  // suffix class wrappers

}

int Require_through::isXRepEdgeInTheList( Vertex*  s,Term*  t )
{
  DEM_TRACE("Require_through","int Require_through::isXRepEdgeInTheList(Vertex*  s,Term*  t)");
  int return_val;

  this->isXRepEdgeInTheList_( return_val, s ,  t  );
  return return_val;
}
void Require_through::isXRepEdgeInTheList_( int& return_val, Vertex*  s,Term*  t )
{
  DEM_TRACE("Require_through","void Require_through::isXRepEdgeInTheList_(int& return_val,Vertex*  s,Term*  t)");
  // prefix class wrappers

   if (bypassing)
     return_val = bypassing->isXRepEdgeInTheList(s, t);
   else
     return_val = 0;


  // suffix class wrappers

}

int Require_bypassing::isXRepEdgeInTheList( Vertex*  s,Term*  t )
{
  DEM_TRACE("Require_bypassing","int Require_bypassing::isXRepEdgeInTheList(Vertex*  s,Term*  t)");
  int return_val;

  this->isXRepEdgeInTheList_( return_val, s ,  t  );
  return return_val;
}
void Require_bypassing::isXRepEdgeInTheList_( int& return_val, Vertex*  s,Term*  t )
{
  DEM_TRACE("Require_bypassing","void Require_bypassing::isXRepEdgeInTheList_(int& return_val,Vertex*  s,Term*  t)");
  // prefix class wrappers

   return_val = bypassing->isXRepEdgeInTheList(s, t);


  // suffix class wrappers

}

int Bypassing_path_constraint::isXRepEdgeInTheList( Vertex*  s,Term*  t )
{
  DEM_TRACE("Bypassing_path_constraint","int Bypassing_path_constraint::isXRepEdgeInTheList(Vertex*  s,Term*  t)");
  int return_val;

  this->isXRepEdgeInTheList_( return_val, s ,  t  );
  return return_val;
}
void Bypassing_path_constraint::isXRepEdgeInTheList_( int& return_val, Vertex*  s,Term*  t )
{
  DEM_TRACE("Bypassing_path_constraint","void Bypassing_path_constraint::isXRepEdgeInTheList_(int& return_val,Vertex*  s,Term*  t)");
  // prefix class wrappers

   return_val = bypassing->isRepEdgeInTheList(s, t);


  // suffix class wrappers

}

int Path_constraint_exp::isThruRepEdgeInTheList( Vertex*  s,Term*  t )
{
  DEM_TRACE("Path_constraint_exp","int Path_constraint_exp::isThruRepEdgeInTheList(Vertex*  s,Term*  t)");
  int return_val;

  this->isThruRepEdgeInTheList_( return_val, s ,  t  );
  return return_val;
}
void Path_constraint_exp::isThruRepEdgeInTheList_( int& return_val, Vertex*  s,Term*  t )
{
  DEM_TRACE("Path_constraint_exp","void Path_constraint_exp::isThruRepEdgeInTheList_(int& return_val,Vertex*  s,Term*  t)");
  // prefix class wrappers

    return_val = 0;


  // suffix class wrappers

}

int Require_through::isThruRepEdgeInTheList( Vertex*  s,Term*  t )
{
  DEM_TRACE("Require_through","int Require_through::isThruRepEdgeInTheList(Vertex*  s,Term*  t)");
  int return_val;

  this->isThruRepEdgeInTheList_( return_val, s ,  t  );
  return return_val;
}
void Require_through::isThruRepEdgeInTheList_( int& return_val, Vertex*  s,Term*  t )
{
  DEM_TRACE("Require_through","void Require_through::isThruRepEdgeInTheList_(int& return_val,Vertex*  s,Term*  t)");
  // prefix class wrappers

   return_val = through->isThruRepEdgeInTheList(s, t);


  // suffix class wrappers

}

int Require_bypassing::isThruRepEdgeInTheList( Vertex*  s,Term*  t )
{
  DEM_TRACE("Require_bypassing","int Require_bypassing::isThruRepEdgeInTheList(Vertex*  s,Term*  t)");
  int return_val;

  this->isThruRepEdgeInTheList_( return_val, s ,  t  );
  return return_val;
}
void Require_bypassing::isThruRepEdgeInTheList_( int& return_val, Vertex*  s,Term*  t )
{
  DEM_TRACE("Require_bypassing","void Require_bypassing::isThruRepEdgeInTheList_(int& return_val,Vertex*  s,Term*  t)");
  // prefix class wrappers

   if (through)
     return_val = through->isThruRepEdgeInTheList(s, t);
   else
     return_val = 0;


  // suffix class wrappers

}

int Through_path_constraint::isThruRepEdgeInTheList( Vertex*  s,Term*  t )
{
  DEM_TRACE("Through_path_constraint","int Through_path_constraint::isThruRepEdgeInTheList(Vertex*  s,Term*  t)");
  int return_val;

  this->isThruRepEdgeInTheList_( return_val, s ,  t  );
  return return_val;
}
void Through_path_constraint::isThruRepEdgeInTheList_( int& return_val, Vertex*  s,Term*  t )
{
  DEM_TRACE("Through_path_constraint","void Through_path_constraint::isThruRepEdgeInTheList_(int& return_val,Vertex*  s,Term*  t)");
  // prefix class wrappers

   return_val = through->isRepEdgeInTheList(s, t);


  // suffix class wrappers

}