pub fn new<I, F>(

        initial_state: StateIndex,

        num_of_states: Option<usize>,

        mut transition_iter: F,

        labels: Vec<Label>,

    ) -> LabelledTransitionSystem<Label>

    where

        F: FnMut() -> I,

        I: Iterator<Item = (StateIndex, LabelIndex, StateIndex)>,

        let mut states = ByteCompressedVec::new();

        if let Some(num_of_states) = num_of_states {

            states.resize_with(num_of_states, Default::default);

            debug_assert!(

                initial_state.value() < num_of_states,

        }

        let mut num_of_transitions = 0;

        for (from, _, to) in transition_iter() {

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

                states.resize_with(*from.max(to) + 1, || 0);

            }

            states.update(*from, |start| *start += 1);

            num_of_transitions += 1;

            if let Some(num_of_states) = num_of_states {

                debug_assert!(

                    *from < num_of_states && *to < num_of_states,

            }

        if initial_state.value() >= states.len() {

        }

        states.fold(0, |count, start| {

            let result = count + *start;

            *start = count;

            result

        });

        let mut transition_labels = bytevec![LabelIndex::new(labels.len()); num_of_transitions];

        let mut transition_to = bytevec![StateIndex::new(states.len()); num_of_transitions];

        for (from, label, to) in transition_iter() {

            states.update(*from, |start| {

                transition_labels.set(*start, label);

                transition_to.set(*start, to);

                *start += 1

            });

        states.fold(0, |previous, start| {

            let result = *start;

            *start = previous;

            result

        });

        debug_assert!(

            initial_state.value() < states.len(),

        states.push(transition_labels.len());

        LabelledTransitionSystem {

            initial_state,

            labels,

            states,

            transition_labels,

            transition_to,

        }

    }

    fn merge_disjoint_impl(mut self, other: &impl LTS<Label = Label>) -> (Self, StateIndex) {

        let mut all_labels = self.labels().to_vec();

        for label in other.labels() {

            if !all_labels.contains(label) {

                all_labels.push(label.clone());

            }

        let label_indices: HashMap<Label, TagIndex<usize, LabelTag>> = HashMap::from_iter(

            all_labels

                .iter()

                .enumerate()

                .map(|(i, label)| (label.clone(), LabelIndex::new(i))),

        let total_number_of_states = self.num_of_states() + other.num_of_states();

        self.states

            .reserve(other.num_of_states(), total_number_of_states.bytes_required());

        self.transition_labels

            .reserve(other.num_of_transitions(), all_labels.len().bytes_required());

        self.transition_to

            .reserve(other.num_of_transitions(), total_number_of_states.bytes_required());

        let offset = self.num_of_states();

        self.states.pop();

        for state_index in other.iter_states() {

            self.states.push(self.num_of_transitions());

            for transition in other.outgoing_transitions(state_index) {

                // Add the transitions of the other LTS, offsetting the state indices

                self.transition_to.push(StateIndex::new(transition.to.value() + offset));

                // Map the label to the new index in all_labels

                let label_name = &other.labels()[transition.label.value()];

                self.transition_labels

                    .push(*label_indices.get(label_name).expect("Label should exist in all_labels"));

            }

        self.states.push(self.num_of_transitions());

        debug_assert_eq!(self.num_of_states(), total_number_of_states);

        (

            Self {

                initial_state: self.initial_state,

                labels: all_labels,

                states: self.states,

                transition_labels: self.transition_labels,

                transition_to: self.transition_to,

            },

            StateIndex::new(offset + other.initial_state_index().value()),

        )

    }

    pub fn new_from_permutation<P>(lts: Self, permutation: P) -> Self

    where

        P: Fn(StateIndex) -> StateIndex + Copy,

        let mut states = bytevec![0; lts.num_of_states()];

        for state_index in lts.iter_states() {

            let new_state_index = permutation(state_index);

            let state = lts.states.index(*state_index);

            states.update(*new_state_index, |entry| {

                *entry = state;

            });

        states.push(lts.num_of_transitions());

        LabelledTransitionSystem {

            initial_state: permutation(lts.initial_state),

            labels: lts.labels,

            states,

            transition_labels: lts.transition_labels,

            transition_to: lts.transition_to,

        }

    }

    fn initial_state_index(&self) -> StateIndex {

        self.initial_state

    }

    fn outgoing_transitions(&self, state_index: StateIndex) -> impl Iterator<Item = Transition> + '_ {

        let start = self.states.index(*state_index);

        let end = self.states.index(*state_index + 1);

        (start..end).map(move |i| Transition {

            label: self.transition_labels.index(i),

            to: self.transition_to.index(i),

        })

    }

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

        (0..self.num_of_states()).map(StateIndex::new)

    }

    fn num_of_states(&self) -> usize {

        self.states.len() - 1

    }

    fn num_of_labels(&self) -> usize {

        self.labels.len()

    }

    fn num_of_transitions(&self) -> usize {

        self.transition_labels.len()

    }

    fn labels(&self) -> &[Self::Label] {

        &self.labels[0..]

    }

    fn is_hidden_label(&self, label_index: LabelIndex) -> bool {

        label_index.value() == 0

    }

    fn merge_disjoint<T: LTS<Label = Self::Label>>(self, other: &T) -> (Self, StateIndex) {

        self.merge_disjoint_impl(other)

    }

pub fn check_equivalent<L: LTS>(lts: &L, lts_read: &L) {

    println!("LTS labels: {:?}", lts.labels());

    println!("Read LTS labels: {:?}", lts_read.labels());

    let mapping = lts

        .labels()

        .iter()

        .enumerate()

        .map(|(_i, label)| lts_read.labels().iter().position(|l| l == label))

        .collect::<Vec<_>>();

    for (i, m) in mapping.iter().enumerate() {

        println!("Label {} mapped to {:?}", i, m);

    }

    assert_eq!(lts.num_of_states(), lts_read.num_of_states());

    assert_eq!(lts.num_of_transitions(), lts_read.num_of_transitions());

    for state_index in lts.iter_states() {

        let transitions: Vec<_> = lts.outgoing_transitions(state_index).collect();

        let transitions_read: Vec<_> = lts_read.outgoing_transitions(state_index).collect();

        transitions.iter().for_each(|t| {

            let mapped_label = mapping[t.label.value()].expect(&format!("Label {} should be found", t.label));

            assert!(

                transitions_read

                    .iter()

                    .any(|tr| tr.to == t.to && tr.label.value() == mapped_label)

        });

}

    fn test_labelled_transition_system_merge() {

        random_test(100, |rng| {

            let mut files = DumpFiles::new("test_labelled_transition_system_merge");

            let left = random_lts(rng, 5, 5, 10);

            let right = random_lts(rng, 5, 10, 10);

            files.dump("left.aut", |f| write_aut(f, &left)).unwrap();

            files.dump("right.aut", |f| write_aut(f, &right)).unwrap();

            let (merged, _offset) = left.clone().merge_disjoint_impl(&right);

            files.dump("merged.aut", |f| write_aut(f, &merged)).unwrap();

        })

    }