static void skipPreSection(std::istream& is, int& line_num) {

       enum skip_state_type { skip, after_endl };

       skip_state_type skip_state = after_endl;

       char c;

       while ((c = is.get()) != EOF) {

 	if (c == '\n') ++line_num;

 	switch (skip_state) {

 	case skip:

 	  if (c == '\n') skip_state = after_endl;

 	  break;

 	case after_endl:

 	  switch (c) {

 	  case '@':

 	    is.putback(c);

 	    return;

 	  case '\n':

 	    continue;

 	  default:

 	    if (!isspace(c)) {

 	      skip_state = skip;

 	    }

 	    break;

 	  }

 	}	

       }

     }

       skipPreSection(*is, line_num);

 	      skipPreSection(*is, line_num);

   /// \ingroup section_io

   /// \brief SectionReader for reading a bipartite graph's nodeset.

   ///

   /// The lemon format can store multiple bipartite graph nodesets

   /// with several maps. The bipartite graph nodeset section's header

   /// line is \c \@bpnodeset \c bpnodeset_name, but the \c bpnodeset_name

   /// may be empty.

   ///

   /// The first line of the section contains \c "&anodeset" and the

   /// the names of the A-node maps and regular maps separated with

   /// white spaces. Each next lines describes an A-node in the anodeset,

   /// and contains the mapped values for each map. If one of the line

   /// starts with \c "&bnodeset" then this line contains the names of

   /// the B-node maps and the regular node maps. And the remaining lines

   /// contains the mapped values to the B-nodes.

   ///

   /// If there is "label" named map then it should be defined in both

   /// nodeset, and it will be regarded as id map. This map should

   /// contain only unique values and when the \c readLabel() member

   /// will read a value from the given stream it will give back that

   /// node which is mapped to this value.

   ///

   /// \relates LemonReader

   template <typename _Graph, typename _Traits = DefaultReaderTraits>

   class BpNodeSetReader : public LemonReader::SectionReader {

     typedef LemonReader::SectionReader Parent;

   public:

     typedef _Graph Graph;

     typedef _Traits Traits;

     typedef typename Graph::Node Node;

     typedef typename Traits::Skipper DefaultSkipper;

     /// \brief Constructor.

     ///

     /// Constructor for BpNodeSetReader. It creates the BpNodeSetReader and

     /// attach it into the given LemonReader. The nodeset reader will

     /// add the read nodes to the given Graph. The reader will read

     /// the section when the \c section_name and the \c _name are the same. 

     BpNodeSetReader(LemonReader& _reader, 

 		  Graph& _graph, 

 		  const std::string& _name = std::string(),

 		  const DefaultSkipper& _skipper = DefaultSkipper()) 

       : Parent(_reader), graph(_graph), name(_name), skipper(_skipper) {} 

     /// \brief Destructor.

     ///

     /// Destructor for BpNodeSetReader.

     virtual ~BpNodeSetReader() {

       for (typename MapReaders::iterator it = readers.begin(); 

 	   it != readers.end(); ++it) {

 	delete it->second;

       }

     }

   private:

     BpNodeSetReader(const BpNodeSetReader&);

     void operator=(const BpNodeSetReader&);

   public:

     /// \brief Add a new node map reader command for the reader.

     ///

     /// Add a new node map reader command for the reader.

     template <typename Map>

     BpNodeSetReader& readNodeMap(std::string label, Map& map) {

       return _readMap<

 	typename Traits::template Reader<typename Map::Value>, Map,

 	typename _reader_bits::Arg<Map>::Type>(label, map);

     }

     template <typename Map>

     BpNodeSetReader& readNodeMap(std::string label, const Map& map) {

       return _readMap<

 	typename Traits::template Reader<typename Map::Value>, Map,

 	typename _reader_bits::Arg<Map>::Type>(label, map);

     }

     /// \brief Add a new node map reader command for the reader.

     ///

     /// Add a new node map reader command for the reader.

     template <typename ItemReader, typename Map>

     BpNodeSetReader& readNodeMap(std::string label, Map& map, 

 			       const ItemReader& ir = ItemReader()) {

       return _readMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type>

 	(label, map, ir);

     }

     template <typename ItemReader, typename Map>

     BpNodeSetReader& readNodeMap(std::string label, const Map& map, 

 			       const ItemReader& ir = ItemReader()) {

       return _readMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type>

 	(label, map, ir);

     }

   private:

     template <typename ItemReader, typename Map, typename MapParameter>

     BpNodeSetReader& _readMap(std::string label, MapParameter map, 

 			    const ItemReader& ir = ItemReader()) {

       checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();

       checkConcept<_reader_bits::ItemReader<typename Map::Value>, ItemReader>();

       if (areaders.find(label) != areaders.end() ||

 	  breaders.find(label) != breaders.end() ||

 	  readers.find(label) != readers.end()) {

 	ErrorMessage msg;

 	msg << "Multiple read rule for node map: " << label;

 	throw IoParameterError(msg.message());

       }      

       readers.insert(make_pair(label, new _reader_bits::

 		  MapReader<Node, Map, ItemReader>(map, ir)));

       return *this;

     }

   public:

     /// \brief Add a new A-node map reader command for the reader.

     ///

     /// Add a new A-node map reader command for the reader.

     template <typename Map>

     BpNodeSetReader& readANodeMap(std::string label, Map& map) {

       return _readAMap<

 	typename Traits::template Reader<typename Map::Value>, Map,

 	typename _reader_bits::Arg<Map>::Type>(label, map);

     }

     template <typename Map>

     BpNodeSetReader& readANodeMap(std::string label, const Map& map) {

       return _readAMap<

 	typename Traits::template Reader<typename Map::Value>, Map,

 	typename _reader_bits::Arg<Map>::Type>(label, map);

     }

     /// \brief Add a new A-node map reader command for the reader.

     ///

     /// Add a new A-node map reader command for the reader.

     template <typename ItemReader, typename Map>

     BpNodeSetReader& readANodeMap(std::string label, Map& map, 

 			       const ItemReader& ir = ItemReader()) {

       return _readAMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type>

 	(label, map, ir);

     }

     template <typename ItemReader, typename Map>

     BpNodeSetReader& readANodeMap(std::string label, const Map& map, 

 			       const ItemReader& ir = ItemReader()) {

       return _readAMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type>

 	(label, map, ir);

     }

   private:

     template <typename ItemReader, typename Map, typename MapParameter>

     BpNodeSetReader& _readAMap(std::string label, MapParameter map, 

 			    const ItemReader& ir = ItemReader()) {

       checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();

       checkConcept<_reader_bits::ItemReader<typename Map::Value>, ItemReader>();

       if (label == "label") {

 	throw IoParameterError("Label cannot be A-node map");

       }

       if (areaders.find(label) != areaders.end() ||

 	  readers.find(label) != readers.end()) {

 	ErrorMessage msg;

 	msg << "Multiple read rule for A-node map: " << label;

 	throw IoParameterError(msg.message());

       }

       areaders.insert(make_pair(label, new _reader_bits::

 				MapReader<Node, Map, ItemReader>(map, ir)));

       return *this;

     }

   public:

     /// \brief Add a new B-node map reader command for the reader.

     ///

     /// Add a new B-node map reader command for the reader.

     template <typename Map>

     BpNodeSetReader& readBNodeMap(std::string label, Map& map) {

       return _readBMap<

 	typename Traits::template Reader<typename Map::Value>, Map,

 	typename _reader_bits::Arg<Map>::Type>(label, map);

     }

     template <typename Map>

     BpNodeSetReader& readBNodeMap(std::string label, const Map& map) {

       return _readBMap<

 	typename Traits::template Reader<typename Map::Value>, Map,

 	typename _reader_bits::Arg<Map>::Type>(label, map);

     }

     /// \brief Add a new B-node map reader command for the reader.

     ///

     /// Add a new B-node map reader command for the reader.

     template <typename ItemReader, typename Map>

     BpNodeSetReader& readBNodeMap(std::string label, Map& map, 

 			       const ItemReader& ir = ItemReader()) {

       return _readBMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type>

 	(label, map, ir);

     }

     template <typename ItemReader, typename Map>

     BpNodeSetReader& readBNodeMap(std::string label, const Map& map, 

 			       const ItemReader& ir = ItemReader()) {

       return _readBMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type>

 	(label, map, ir);

     }

   private:

     template <typename ItemReader, typename Map, typename MapParameter>

     BpNodeSetReader& _readBMap(std::string label, MapParameter map, 

 			    const ItemReader& ir = ItemReader()) {

       checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();

       checkConcept<_reader_bits::ItemReader<typename Map::Value>, ItemReader>();

       if (label == "label") {

 	throw IoParameterError("Label cannot be B-node map");

       }

       if (breaders.find(label) != breaders.end() ||

 	  readers.find(label) != readers.end()) {

 	ErrorMessage msg;

 	msg << "Multiple read rule for B-node map: " << label;

 	throw IoParameterError(msg.message());

       }

       breaders.insert(make_pair(label, new _reader_bits::

 				MapReader<Node, Map, ItemReader>(map, ir)));

       return *this;

     }

   public:

     /// \brief Add a new node map skipper command for the reader.

     ///

     /// Add a new node map skipper command for the reader.

     template <typename ItemReader>

     BpNodeSetReader& skipNodeMap(std::string label, 

 				 const ItemReader& ir = ItemReader()) {

       if (areaders.find(label) != areaders.end() ||

 	  breaders.find(label) != breaders.end() ||

 	  readers.find(label) != readers.end()) {

 	ErrorMessage msg;

 	msg << "Multiple read rule for node map: " << label;

 	throw IoParameterError(msg.message());

       }

       readers.insert(make_pair(label, new _reader_bits::

 			       SkipReader<Node, ItemReader>(ir)));

       return *this;

     }

     /// \brief Add a new A-node map skipper command for the reader.

     ///

     /// Add a new A-node map skipper command for the reader.

     template <typename ItemReader>

     BpNodeSetReader& skipANodeMap(std::string label, 

 				  const ItemReader& ir = ItemReader()) {

       if (label == "label") {

 	throw IoParameterError("Label cannot be A-node map");

       }

       if (areaders.find(label) != areaders.end() ||

 	  readers.find(label) != readers.end()) {

 	ErrorMessage msg;

 	msg << "Multiple read rule for A-node map: " << label;

 	throw IoParameterError(msg.message());

       }

       areaders.insert(make_pair(label, new _reader_bits::

 				SkipReader<Node, ItemReader>(ir)));

       return *this;

     }

     /// \brief Add a new B-node map skipper command for the reader.

     ///

     /// Add a new B-node map skipper command for the reader.

     template <typename ItemReader>

     BpNodeSetReader& skipBNodeMap(std::string label, 

 				  const ItemReader& ir = ItemReader()) {

       if (label == "label") {

 	throw IoParameterError("Label cannot be B-node map");

       }

       if (breaders.find(label) != breaders.end() ||

 	  readers.find(label) != readers.end()) {

 	ErrorMessage msg;

 	msg << "Multiple read rule for B-node map: " << label;

 	throw IoParameterError(msg.message());

       }

       breaders.insert(make_pair(label, new _reader_bits::

 				SkipReader<Node, ItemReader>(ir)));

       return *this;

     }

   protected:

     /// \brief Gives back true when the SectionReader can process 

     /// the section with the given header line.

     ///

     /// It gives back true when the header line starts with \c \@nodeset,

     /// and the header line's name and the nodeset's name are the same.

     virtual bool header(const std::string& line) {

       std::istringstream ls(line);

       std::string command;

       std::string id;

       ls >> command >> id;

       return command == "@bpnodeset" && name == id;

     }

     /// \brief Reader function of the section.

     ///

     /// It reads the content of the section.

     virtual void read(std::istream& is) {

       std::string line;

       {

 	std::vector<_reader_bits::MapReaderBase<Node>* > index;

 	{

 	  getline(is, line);

 	  std::istringstream ls(line);

 	  std::string id;

 	  ls >> id;

 	  if (id != "&anodeset") {

 	    throw IoParameterError("Cannot find &anodeset subsection");

 	  }

 	  while (ls >> id) {

 	    typename MapReaders::iterator it = readers.find(id);

 	    typename MapReaders::iterator ait = areaders.find(id);

 	    if (it != readers.end()) {

 	      it->second->touch();

 	      index.push_back(it->second);

 	    } else if (ait != areaders.end()) {

 	      ait->second->touch();

 	      index.push_back(ait->second);

 	    }

 	    if (id == "label") {

 	      inverter.reset(index.back()->getInverter());

 	      index.back() = inverter.get();

 	    }

 	  }

 	}

 	for (typename MapReaders::iterator it = areaders.begin();

 	     it != areaders.end(); ++it) {

 	  if (!it->second->touched()) {

 	    ErrorMessage msg;

 	    msg << "Map not found in file: " << it->first;

 	    throw IoParameterError(msg.message());

 	  }

 	}

 	for (typename MapReaders::iterator it = readers.begin();

 	     it != readers.end(); ++it) {

 	  if (!it->second->touched()) {

 	    ErrorMessage msg;

 	    msg << "Map not found in file: " << it->first;

 	    throw IoParameterError(msg.message());

 	  }

 	  it->second->touch(false);

 	}

 	while (getline(is, line)) {

 	  if (line[0] == '&') {

 	    std::istringstream ls(line);

 	    std::string id;

 	    ls >> id;

 	    if (id == "&bnodeset") break;

 	  }

 	  Node node = graph.addANode();

 	  std::istringstream ls(line);

 	  for (int i = 0; i < int(index.size()); ++i) {

 	    index[i]->read(ls, node);

 	  }

 	}

       }

       {

 	std::vector<_reader_bits::MapReaderBase<Node>* > index;

 	{

 	  std::istringstream ls(line);

 	  std::string id;

 	  ls >> id;

 	  if (id != "&bnodeset") {

 	    throw IoParameterError("Cannot find &bnodeset subsection");

 	  }

 	  while (ls >> id) {

 	    typename MapReaders::iterator it = readers.find(id);

 	    typename MapReaders::iterator bit = breaders.find(id);

 	    if (it != readers.end()) {

 	      it->second->touch();

 	      index.push_back(it->second);

 	    } else if (bit != breaders.end()) {

 	      bit->second->touch();

 	      index.push_back(bit->second);

 	    }

 	    if (id == "label" && inverter.get() != 0) {

 	      index.back() = inverter.get();

 	    }

 	  }

 	}

 	for (typename MapReaders::iterator it = breaders.begin();

 	     it != breaders.end(); ++it) {

 	  if (!it->second->touched()) {

 	    ErrorMessage msg;

 	    msg << "Map not found in file: " << it->first;

 	    throw IoParameterError(msg.message());

 	  }

 	}

 	for (typename MapReaders::iterator it = readers.begin();

 	     it != readers.end(); ++it) {

 	  if (!it->second->touched()) {

 	    ErrorMessage msg;

 	    msg << "Map not found in file: " << it->first;

 	    throw IoParameterError(msg.message());

 	  }

 	}

 	while (getline(is, line)) {	

 	  Node node = graph.addBNode();

 	  std::istringstream ls(line);

 	  for (int i = 0; i < int(index.size()); ++i) {

 	    index[i]->read(ls, node);

 	  }

 	}

       }

     }

     virtual void missing() {

       if (readers.empty()) return;

       ErrorMessage msg;

       msg << "BpNodeSet section not found in file: @bpnodeset " << name;

       throw IoParameterError(msg.message());

     }

   public:

     /// \brief Returns true if the nodeset can give back the node by its label.

     ///

     /// Returns true if the nodeset can give back the node by its label.

     /// It is possible only if an "label" named map was read.

     bool isLabelReader() const {

       return inverter.get() != 0;

     }

     /// \brief Gives back the node by its label.

     ///

     /// It reads an id from the stream and gives back which node belongs to

     /// it. It is possible only if there was read an "label" named map.

     void readLabel(std::istream& is, Node& node) const {

       node = inverter->read(is);

     } 

   private:

     typedef std::map<std::string, _reader_bits::MapReaderBase<Node>*> 

     MapReaders;

     MapReaders areaders, breaders, readers;

     Graph& graph;

     std::string name;

     _reader_bits::SkipReader<Node, DefaultSkipper> skipper;

     std::auto_ptr<_reader_bits::MapInverterBase<Node> > inverter;

   };