pub fn from_edges<F, I>(

        initial_vertex: VertexIndex,

        owner: Vec<Player>,

        mut priority: Vec<Priority>,

        make_total: bool,

        mut edges: F,

    ) -> Self

    where

        F: FnMut() -> I,

        I: Iterator<Item = (VertexIndex, VertexIndex)>,

        let num_of_vertices = owner.len();

        debug_assert_eq!(

            priority.len(),

        let mut vertices = Vec::new();

        vertices.resize_with(num_of_vertices, Default::default);

        debug_assert!(

            initial_vertex.value() < num_of_vertices,

        let mut num_of_edges = 0;

        for (from, to) in edges() {

            if vertices.len() <= *from.max(to) {

            }

            vertices[*from] += 1;

            num_of_edges += 1;

            debug_assert!(

                *from < num_of_vertices && *to < num_of_vertices,

        if initial_vertex.value() >= vertices.len() {

        }

        if make_total {

            for count in vertices.iter_mut() {

                if *count == 0 {

                    *count = 1;

                    num_of_edges += 1;

                }

        }

        vertices.iter_mut().fold(0, |count, start| {

            let result = count + *start;

            *start = count;

            result

        });

        let mut edges_to = vec![VertexIndex::new(0); num_of_edges];

        for (from, to) in edges() {

            let start = &mut vertices[*from];

            edges_to[*start] = to;

            *start += 1;

        }

        if make_total {

            for vertex_idx in 0..num_of_vertices {

                let start = vertices[vertex_idx];

                let previous = if vertex_idx > 0 { vertices[vertex_idx - 1] } else { 0 };

                if start == previous {

                    // No outgoing edges, add self-loop

                    edges_to[start] = VertexIndex::new(vertex_idx);

                    vertices[vertex_idx] += 1; // Increment end offset

                    // Change the priority of the vertex such that the self-loop is winning for the opponent.

                    priority[vertex_idx] = Priority::new(owner[vertex_idx].opponent().to_index());

                }

        }

        vertices.iter_mut().fold(0, |previous, start| {

            let result = *start;

            *start = previous;

            result

        });

        vertices.push(num_of_edges); // Sentinel vertex

        Self::new(initial_vertex, owner, priority, vertices, edges_to)

    }

    pub(crate) fn new(

        initial_vertex: VertexIndex,

        owner: Vec<Player>,

        priority: Vec<Priority>,

        vertices: Vec<usize>,

        edges_to: Vec<VertexIndex>,

    ) -> Self {

        let result = Self {

            owner,

            priority,

            vertices,

            edges_to,

            initial_vertex,

        };

        result.assert_consistent();

        result

    }

    pub(crate) fn vertices(&self) -> &Vec<usize> {

        &self.vertices

    }

    pub(crate) fn edges_to(&self) -> &Vec<VertexIndex> {

        &self.edges_to

    }

    pub(crate) fn owners(&self) -> &Vec<Player> {

        &self.owner

    }

    pub(crate) fn priorities(&self) -> &Vec<Priority> {

        &self.priority

    }

    fn assert_consistent(&self) {

        debug_assert_eq!(

            self.owner.len(),

            self.priority.len(),

        debug_assert_eq!(

            self.vertices.len(),

            self.owner.len() + 1,

        debug_assert_eq!(self.initial_vertex, 0, "The initial vertex should be vertex 0");

            let mut seen = HashSet::new();

            for vertex in self.iter_vertices() {

                seen.clear();

                for edge in self.outgoing_edges(vertex) {

                    if !seen.insert(edge.to()) {

                    }

    }

    fn initial_vertex(&self) -> VertexIndex {

        self.initial_vertex

    }

    fn num_of_vertices(&self) -> usize {

        self.owner.len()

    }

    fn num_of_edges(&self) -> usize {

        self.edges_to.len()

    }

    fn iter_vertices(&self) -> impl Iterator<Item = VertexIndex> + '_ {

        (0..self.num_of_vertices()).map(VertexIndex::new)

    }

    fn outgoing_edges<'a>(&'a self, state_index: VertexIndex) -> impl Iterator<Item = Edge<'a, ()>> + 'a {

        let start = self.vertices[*state_index];

        let end = self.vertices[*state_index + 1];

        (start..end).map(move |i| Edge::new(&(), self.edges_to[i]))

    }

    fn owner(&self, vertex: VertexIndex) -> Player {

        self.owner[*vertex]

    }

    fn priority(&self, vertex: VertexIndex) -> Priority {

        self.priority[*vertex]

    }

    fn highest_priority(&self) -> Priority {

        self.priority.iter().fold(Priority::new(0), |max, p| max.max(*p))

    }

    fn is_total(&self) -> bool {

        self.iter_vertices().all(|v| self.outgoing_edges(v).next().is_some())

    }

    pub fn new(label: &'a L, to: VertexIndex) -> Self {

        Self { label, to }

    }

    pub fn label(&self) -> &'a L {

        self.label

    }

    pub fn to(&self) -> VertexIndex {

        self.to

    }

    fn num_of_vertices(&self) -> usize {

        self.0.num_of_vertices()

    }

    fn iter_vertices(&self) -> impl Iterator<Item = Self::VertexIndex> {

        self.0.iter_vertices()

    }

    fn outgoing_edges(

        &self,

        vertex: <Self as Graph>::VertexIndex,

    ) -> impl Iterator<Item = (Self::LabelIndex, Self::VertexIndex)> {

        self.0.outgoing_edges(vertex).map(|edge| ((), edge.to()))

    }

    fn test_random_parity_game_make_total() {

        random_test(100, |rng| {

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

            assert!(game.is_total());

        });

    }