pub fn read_pg<R: Read>(reader: R) -> Result<ParityGame, MercError> {

    info!("Reading parity game in .pg format...");

    let mut lines = LineIterator::new(reader);

    lines.advance();

    let header = lines

        .get()

        .ok_or(IOError::InvalidHeader("The first line should be the header"))?;

    let header_regex = Regex::new(r#"parity\s+([0-9]+)\s*;"#).expect("Regex compilation should not fail");

    let (_, [num_of_vertices_txt]) = header_regex

        .captures(header)

        .ok_or(IOError::InvalidHeader("does not match parity <num_of_vertices>;"))?

        .extract();

    let num_of_vertices: usize = num_of_vertices_txt.parse()?;

    let progress = TimeProgress::new(

    let mut builder = ParityGameBuilder::with_capacity(VertexIndex::new(0), num_of_vertices);

    if num_of_vertices > 0 {

        builder.add_vertex(VertexIndex::new(num_of_vertices - 1), Player::Even, Priority::new(0));

    }

    let mut vertex_count = 0;

    while let Some(line) = lines.next() {

        let mut parts = line.split_whitespace();

        let index: usize = parts

            .next()

            .ok_or(IOError::InvalidLine("Expected at least <index> ...;"))?

            .parse()?;

        let vertex_priority: usize = parts

            .next()

            .ok_or(IOError::InvalidLine("Expected at least <index> <priority> ...;"))?

            .parse()?;

        let vertex_owner: u8 = parts

            .next()

            .ok_or(IOError::InvalidLine(

                "Expected at least <index> <priority> <owner> ...;",

            ))?

            .parse()?;

        let vertex = VertexIndex::new(index);

        let owner =

            Player::try_from_index(vertex_owner).ok_or(IOError::InvalidLine("owner must be 0 (even) or 1 (odd)"))?;

        builder.add_vertex(vertex, owner, Priority::new(vertex_priority));

        for successors in parts {

            for successor in successors

                .trim_end_matches(';')

                .split(',')

                .filter(|s| !s.trim().is_empty())

                .map(|s| s.trim().parse())

                let successor = successor?;

                builder.add_edge(vertex, VertexIndex::new(successor));

        progress.print((vertex_count + 1, num_of_vertices));

        vertex_count += 1;

    Ok(builder.finish(true, true))

}

pub fn write_pg<W: Write, G: PG>(writer: W, game: &G) -> Result<(), MercError> {

    info!("Writing parity game to .pg format...");

    let mut writer = BufWriter::new(writer);

    let progress = TimeProgress::new(

    writeln!(writer, "parity {};", game.num_of_vertices())?;

    for v in game.iter_vertices() {

        let prio = game.priority(v);

        let owner = game.owner(v).to_index();

        write!(writer, "{} {} {} ", v.value(), prio.value(), owner)?;

        write!(

            writer,

            game.outgoing_edges(v).map(|edge| edge.to().value()).format(", ")

        writeln!(writer, ";")?;

        progress.print((v.value() + 1, game.num_of_vertices()));

    Ok(())

}

    fn test_read_pg() {

        let parity_game = read_pg(include_bytes!("../../../../examples/vpg/example.pg") as &[u8]).unwrap();

        assert_eq!(parity_game.num_of_vertices(), 3002);

        assert_eq!(parity_game.num_of_edges(), 3968);

    }

    fn test_random_io_pg() {

        random_test(100, |rng| {

            let game = random_parity_game(rng, true, 50, 10, 5);

            let mut buffer = Vec::new();

            write_pg(&mut buffer, &game).unwrap();

            let read_game = read_pg(buffer.as_slice()).unwrap();

            assert_eq!(game.num_of_vertices(), read_game.num_of_vertices());

            assert_eq!(game.num_of_edges(), read_game.num_of_edges());

            for vertex in game.iter_vertices() {

                let original_successors: Vec<_> = game.outgoing_edges(vertex).map(|e| e.to()).collect();

                let read_successors: Vec<_> = read_game.outgoing_edges(vertex).map(|e| e.to()).collect();

                assert_eq!(original_successors.len(), read_successors.len());

                assert_eq!(

                    original_successors.into_iter().sorted().collect::<Vec<_>>(),

                    read_successors.into_iter().sorted().collect::<Vec<_>>()

        });

    }