min_infmachine_lltk 0.1.0

use min_infmachine_lltk::table_opt::*;
use min_infmachine_lltk::*;

#[test]
fn test_only_visited_states() {
    assert_eq!(
        (
            vec![
                MinInfInstr::new_func01(MINF_MARF, 1, 2),
                MinInfInstr::new_func01(MINF_TBRF, 1, 2),
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 2, 3),
                MinInfInstr::new_func01(MINF_MRW0, 4, 4),
                MinInfInstr::new_func01(MINF_MARW0, 1, 0),
            ],
            vec![(0, 3), (1, 4)]
        ),
        only_visited_states(
            vec![
                MinInfInstr::new_func01(MINF_MARF, 1, 2),
                MinInfInstr::new_func01(MINF_TBRF, 1, 2),
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 2, 3),
                MinInfInstr::new_func01(MINF_MRW0, 4, 4),
                MinInfInstr::new_func01(MINF_MARW0, 1, 0),
                MinInfInstr::default(),
                MinInfInstr::default(),
                MinInfInstr::default(),
            ],
            (0, false),
            vec![(0, 3), (1, 4)]
        )
    );
    assert_eq!(
        (
            vec![
                MinInfInstr::new_func01(MINF_MARF, 1, 0),
                MinInfInstr::new_func01(MINF_TBRF, 1, 2),
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 0, 3),
                MinInfInstr::new_func01(MINF_MARW0, 1, 0),
            ],
            vec![(0, 1), (2, 3)]
        ),
        only_visited_states(
            vec![
                MinInfInstr::new_func01(MINF_MARF, 1, 3),
                MinInfInstr::new_func01(MINF_TBRF, 1, 2),
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 0, 4),
                MinInfInstr::new_func01(MINF_MRW0, 4, 4),
                MinInfInstr::new_func01(MINF_MARW0, 1, 0),
            ],
            (0, false),
            vec![(0, 1), (1, 3), (2, 4)]
        )
    );
    assert_eq!(
        (
            vec![
                MinInfInstr::new_func01(MINF_MARF, 1, 3),
                MinInfInstr::new_func01(MINF_TBRF, 1, 2),
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 0, 4),
                MinInfInstr::new_func01(MINF_MRW0, 4, 4),
                MinInfInstr::new_func01(MINF_MARW0, 1, 0),
            ],
            vec![(0, 1), (1, 3), (2, 4)]
        ),
        only_visited_states(
            vec![
                MinInfInstr::new_func01(MINF_MARF, 1, 3),
                MinInfInstr::new_func01(MINF_TBRF, 1, 2),
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 0, 4),
                MinInfInstr::new_func01(MINF_MRW0, 4, 4),
                MinInfInstr::new_func01(MINF_MARW0, 1, 0),
            ],
            (0, true),
            vec![(0, 1), (1, 3), (2, 4)]
        )
    );
    // next testcases
    assert_eq!(
        (
            vec![
                MinInfInstr::new_func01(MINF_MARF, 1, 3),
                MinInfInstr::new_func01(MINF_TBRF, 1, 2),
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 0, 3),
                MinInfInstr::new_func01(MINF_STOP, 0, 0),
            ],
            vec![(0, 1), (1, 3)]
        ),
        only_visited_states(
            vec![
                MinInfInstr::new_func01(MINF_MARF, 1, 3),
                MinInfInstr::new_func01(MINF_TBRF, 1, 2),
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 0, 3),
                MinInfInstr::new_func01(MINF_STOP, 4, 4),
                MinInfInstr::new_func01(MINF_MARW0, 1, 0),
            ],
            (0, false),
            vec![(0, 1), (1, 3), (2, 4)]
        )
    );
    assert_eq!(
        (
            vec![
                MinInfInstr::new_func01(MINF_MARF, 0, 1),
                MinInfInstr::new_func01(MINF_STOP, 0, 0),
            ],
            vec![(1, 1)]
        ),
        only_visited_states(
            vec![
                MinInfInstr::new_func01(MINF_MARF, 4, 3),
                MinInfInstr::new_func01(MINF_TBRF, 1, 2),
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 0, 3),
                MinInfInstr::new_func01(MINF_STOP, 4, 4),
                MinInfInstr::new_func01(MINF_MARW0, 1, 0),
            ],
            (0, true),
            vec![(0, 1), (1, 3), (2, 4)]
        )
    );
    // next testcases
    let code0 = vec![
        MinInfInstr::new(MINF_MARF, MINF_MR, 2, 0),
        MinInfInstr::new(MINF_MRW0, MINF_MRW1, 0, 3),
        MinInfInstr::new(MINF_MAB, MINF_MAR, 0, 2),
        MinInfInstr::new(MINF_MARW0, MINF_MARW1, 4, 5),
        MinInfInstr::new(MINF_TBRF, MINF_TBR, 6, 7),
        MinInfInstr::new(MINF_TBRW0, MINF_TBRW1, 8, 9),
        MinInfInstr::new(MINF_MARF, MINF_STOP2, 6, 1),
        MinInfInstr::new(MINF_STOP3, MINF_MRW1, 0, 7),
        MinInfInstr::new(MINF_MAB, MINF_STOP2, 8, 1),
        MinInfInstr::new(MINF_STOP, MINF_STOP, 4, 5),
    ];
    let map0 = (0..10).map(|x| (x, x)).collect::<Vec<_>>();
    assert_eq!(
        (
            vec![
                MinInfInstr::new(MINF_MARF, MINF_MR, 2, 0),
                MinInfInstr::new(MINF_MRW0, MINF_MRW1, 0, 0),
                MinInfInstr::new(MINF_MAB, MINF_MAR, 0, 2),
            ],
            vec![(0, 0), (1, 1), (2, 2)]
        ),
        only_visited_states(code0.clone(), (1, false), map0.clone())
    );
    assert_eq!(
        (
            vec![
                MinInfInstr::new(MINF_MRW0, MINF_MRW1, 0, 1),
                MinInfInstr::new(MINF_MARW0, MINF_MARW1, 2, 3),
                MinInfInstr::new(MINF_TBRF, MINF_TBR, 4, 5),
                MinInfInstr::new(MINF_TBRW0, MINF_TBRW1, 6, 7),
                MinInfInstr::new(MINF_MARF, MINF_STOP2, 4, 0),
                MinInfInstr::new(MINF_STOP3, MINF_MRW1, 0, 5),
                MinInfInstr::new(MINF_MAB, MINF_STOP2, 6, 0),
                MinInfInstr::new(MINF_STOP, MINF_STOP, 2, 3),
            ],
            vec![
                (1, 0),
                (3, 1),
                (4, 2),
                (5, 3),
                (6, 4),
                (7, 5),
                (8, 6),
                (9, 7)
            ]
        ),
        only_visited_states(code0.clone(), (1, true), map0.clone())
    );
    assert_eq!(
        (
            vec![
                MinInfInstr::new(MINF_MARW0, MINF_MARW1, 1, 0),
                MinInfInstr::new(MINF_TBRF, MINF_TBR, 2, 3),
                MinInfInstr::new(MINF_MARF, MINF_STOP2, 2, 0),
                MinInfInstr::new(MINF_STOP3, MINF_MRW1, 0, 3),
            ],
            vec![(3, 0), (4, 1), (6, 2), (7, 3)]
        ),
        only_visited_states(code0.clone(), (3, false), map0.clone())
    );
    assert_eq!(
        (
            vec![
                MinInfInstr::new(MINF_MARW0, MINF_MARW1, 0, 1),
                MinInfInstr::new(MINF_TBRW0, MINF_TBRW1, 2, 3),
                MinInfInstr::new(MINF_MAB, MINF_STOP2, 2, 0),
                MinInfInstr::new(MINF_STOP, MINF_STOP, 0, 1),
            ],
            vec![(3, 0), (5, 1), (8, 2), (9, 3)]
        ),
        only_visited_states(code0.clone(), (3, true), map0.clone())
    );
}

#[test]
fn test_remove_no_impacts() {
    assert_eq!(
        (
            vec![
                MinInfInstr::new_func01(MINF_MARF, 1, 2),
                MinInfInstr::new_func01(MINF_TBRF, 1, 2),
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 2, 3),
                MinInfInstr::new_func01(MINF_MRW0, 4, 4),
                MinInfInstr::new_func01(MINF_MARW0, 1, 0),
            ],
            vec![(0, 3), (1, 4)]
        ),
        remove_no_impacts(
            vec![
                MinInfInstr::new_func01(MINF_MARF, 1, 2),
                MinInfInstr::new_func01(MINF_TBRF, 1, 2),
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 2, 3),
                MinInfInstr::new_func01(MINF_MRW0, 4, 4),
                MinInfInstr::new_func01(MINF_MARW0, 1, 0),
                MinInfInstr::default(),
                MinInfInstr::default(),
                MinInfInstr::default(),
            ],
            (0, false),
            vec![(0, 3), (1, 4)]
        )
    );
    assert_eq!(
        (
            vec![
                MinInfInstr::new(MINF_TBRF, MINF_MAR, 1, 1),
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 1, 2),
                MinInfInstr::new_01(MINF_MRW0, 3),
                MinInfInstr::new_func01(MINF_MARW0, 2, 1),
            ],
            vec![(0, 0), (2, 2), (3, 3)]
        ),
        remove_no_impacts(
            vec![
                MinInfInstr::new_func01(MINF_MAR, 1, 2),
                MinInfInstr::new_01(MINF_TBRF, 2),
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 2, 3),
                MinInfInstr::new_01(MINF_MRW0, 4),
                MinInfInstr::new_func01(MINF_MARW0, 3, 2),
                MinInfInstr::default(),
                MinInfInstr::default(),
                MinInfInstr::default(),
            ],
            (0, false),
            vec![(0, 0), (1, 1), (2, 3), (3, 4)]
        )
    );
    assert_eq!(
        (
            vec![
                MinInfInstr::new_01(MINF_MRW0, 1),
                MinInfInstr::new(MINF_MARW0, MINF_MARW1, 5, 2),
                MinInfInstr::new(MINF_TBRF, MINF_MARW0, 3, 5),
                MinInfInstr::new(MINF_TBRF, MINF_MARW0, 4, 5),
                MinInfInstr::new_next01(MINF_MARW0, MINF_TBB, 5),
                MinInfInstr::new_01(MINF_STOP, 0),
            ],
            vec![(0, 0), (1, 1), (2, 3), (3, 4), (5, 5)]
        ),
        remove_no_impacts(
            vec![
                MinInfInstr::new_01(MINF_MRW0, 1),
                MinInfInstr::new(MINF_MAR, MINF_MARW1, 5, 2),
                MinInfInstr::new(MINF_TBRF, MINF_MARW0, 3, 5),
                MinInfInstr::new(MINF_TBRF, MINF_TBR, 4, 5),
                MinInfInstr::new(MINF_MARW1, MINF_TBB, 5, 6),
                MinInfInstr::new_func01(MINF_MARW0, 6, 6),
                MinInfInstr::new_01(MINF_STOP, 0),
            ],
            (0, false),
            vec![(0, 0), (1, 1), (2, 3), (3, 4), (4, 5), (5, 6)]
        )
    );
    assert_eq!(
        (
            vec![
                MinInfInstr::new_01(MINF_MRW0, 1),
                MinInfInstr::new(MINF_MARW0, MINF_MARW1, 6, 2),
                MinInfInstr::new(MINF_TBRF, MINF_MARW0, 3, 6),
                MinInfInstr::new(MINF_TBRF, MINF_TBRW1, 4, 5),
                MinInfInstr::new_next01(MINF_MARW0, MINF_TBB, 6),
                MinInfInstr::new_func01(MINF_MARW0, 6, 6),
                MinInfInstr::new_01(MINF_STOP, 0),
            ],
            vec![(0, 0), (1, 1), (2, 3), (3, 4)]
        ),
        remove_no_impacts(
            vec![
                MinInfInstr::new_01(MINF_MRW0, 1),
                MinInfInstr::new(MINF_MAR, MINF_MARW1, 5, 2),
                MinInfInstr::new(MINF_TBRF, MINF_MARW0, 3, 5),
                MinInfInstr::new(MINF_TBRF, MINF_TBRW1, 4, 5),
                MinInfInstr::new(MINF_MARW1, MINF_TBB, 5, 6),
                MinInfInstr::new_func01(MINF_MARW0, 6, 6),
                MinInfInstr::new_01(MINF_STOP, 0),
            ],
            (0, false),
            vec![(0, 0), (1, 1), (2, 3), (3, 4)]
        )
    );
    // remove two instructions
    assert_eq!(
        (
            vec![
                MinInfInstr::new_01(MINF_MRW0, 1),
                MinInfInstr::new_01(MINF_STOP, 0),
            ],
            vec![(0, 0), (1, 1)]
        ),
        remove_no_impacts(
            vec![
                MinInfInstr::new_01(MINF_MRW0, 1),
                MinInfInstr::new_01(MINF_TBRF, 2),
                MinInfInstr::new_01(MINF_TBB, 3),
                MinInfInstr::new_01(MINF_STOP, 0),
            ],
            (0, false),
            vec![(0, 0), (1, 1), (2, 3)]
        )
    );
    assert_eq!(
        (
            vec![
                MinInfInstr::new_01(MINF_MRW0, 1),
                MinInfInstr::new_01(MINF_STOP, 0),
            ],
            vec![(0, 0), (1, 1)]
        ),
        remove_no_impacts(
            vec![
                MinInfInstr::new_01(MINF_MRW0, 1),
                MinInfInstr::new(MINF_TBRF, MINF_MARF, 2, 3),
                MinInfInstr::new_01(MINF_TBB, 4),
                MinInfInstr::new_01(MINF_MAB, 4),
                MinInfInstr::new_01(MINF_STOP, 0),
            ],
            (0, false),
            vec![(0, 0), (1, 1), (2, 3)]
        )
    );
    assert_eq!(
        (
            vec![
                MinInfInstr::new_01(MINF_MRW0, 1),
                MinInfInstr::new(MINF_STOP, MINF_MARF, 0, 2),
                MinInfInstr::new_01(MINF_STOP, 0),
            ],
            vec![(0, 0), (1, 1), (2, 2)]
        ),
        remove_no_impacts(
            vec![
                MinInfInstr::new_01(MINF_MRW0, 1),
                MinInfInstr::new(MINF_TBRF, MINF_MARF, 2, 3),
                MinInfInstr::new_01(MINF_TBB, 4),
                MinInfInstr::new_01(MINF_MAR, 4),
                MinInfInstr::new_01(MINF_STOP, 0),
            ],
            (0, false),
            vec![(0, 0), (1, 1), (2, 3)]
        )
    );
    assert_eq!(
        (
            vec![
                MinInfInstr::new_01(MINF_MRW0, 1),
                MinInfInstr::new(MINF_TBRF, MINF_MARF, 2, 3),
                MinInfInstr::new(MINF_TBB, MINF_STOP, 4, 0),
                MinInfInstr::new_01(MINF_STOP, 0),
                MinInfInstr::new_01(MINF_STOP, 0),
            ],
            vec![(0, 0), (1, 1), (2, 3)]
        ),
        remove_no_impacts(
            vec![
                MinInfInstr::new_01(MINF_MRW0, 1),
                MinInfInstr::new(MINF_TBRF, MINF_MARF, 2, 3),
                MinInfInstr::new_next01(MINF_TBB, MINF_TBR, 4),
                MinInfInstr::new_01(MINF_MAR, 4),
                MinInfInstr::new_01(MINF_STOP, 0),
            ],
            (0, false),
            vec![(0, 0), (1, 1), (2, 3)]
        )
    );
    // remove two instructions (2_2_0)
    assert_eq!(
        (
            vec![
                MinInfInstr::new_01(MINF_MARW0, 1),
                MinInfInstr::new_01(MINF_STOP, 0),
            ],
            vec![(0, 0), (1, 1)]
        ),
        remove_no_impacts(
            vec![
                MinInfInstr::new_01(MINF_MARW0, 1),
                MinInfInstr::new_01(MINF_MR, 2),
                MinInfInstr::new_next01(MINF_MRW0, MINF_MRW1, 3),
                MinInfInstr::new_01(MINF_STOP, 0),
            ],
            (0, false),
            vec![(0, 0), (1, 1), (2, 3)]
        )
    );
    assert_eq!(
        (
            vec![
                MinInfInstr::new_01(MINF_MRW0, 1),
                MinInfInstr::new_01(MINF_STOP, 0),
            ],
            vec![(0, 0), (1, 1)]
        ),
        remove_no_impacts(
            vec![
                MinInfInstr::new_01(MINF_MRW0, 1),
                MinInfInstr::new_01(MINF_MAR, 2),
                MinInfInstr::new_next01(MINF_MARW0, MINF_MARW1, 3),
                MinInfInstr::new_01(MINF_STOP, 0),
            ],
            (0, false),
            vec![(0, 0), (1, 1), (2, 3)]
        )
    );
    assert_eq!(
        (
            vec![
                MinInfInstr::new_01(MINF_MRW0, 1),
                MinInfInstr::new_01(MINF_STOP, 0),
            ],
            vec![(0, 0), (1, 1)]
        ),
        remove_no_impacts(
            vec![
                MinInfInstr::new_01(MINF_MRW0, 1),
                MinInfInstr::new_01(MINF_TBR, 2),
                MinInfInstr::new_next01(MINF_TBRW0, MINF_TBRW1, 3),
                MinInfInstr::new_01(MINF_STOP, 0),
            ],
            (0, false),
            vec![(0, 0), (1, 1), (2, 3)]
        )
    );
}

#[test]
fn test_remove_no_impacts_many() {
    assert_eq!(
        (
            vec![
                MinInfInstr::new_01(MINF_MARW1, 1),
                MinInfInstr::new_01(MINF_STOP, 2),
                MinInfInstr::new_01(MINF_TBRW0, 3),
                MinInfInstr::new_01(MINF_MARF, 4),
                MinInfInstr::new_next01(MINF_MRW0, MINF_MRW1, 0),
            ],
            vec![(0, 0), (2, 1)]
        ),
        remove_no_impacts_many(
            vec![
                MinInfInstr::new_01(MINF_MR, 1),
                MinInfInstr::new_01(MINF_TBR, 2),
                MinInfInstr::new_01(MINF_MARW1, 3),
                MinInfInstr::new_01(MINF_STOP, 4),
                MinInfInstr::new_01(MINF_TBRW0, 5),
                MinInfInstr::new_01(MINF_MARF, 6),
                MinInfInstr::new_next01(MINF_MRW0, MINF_MRW1, 0),
            ],
            (4, false),
            vec![(0, 0), (1, 1), (2, 3)],
            3,
        )
    );
}

#[test]
fn test_dedup_subgraphs() {
    assert_eq!(
        (
            vec![
                MinInfInstr::new_func01(MINF_MARF, 1, 2),
                MinInfInstr::new_func01(MINF_TBRF, 1, 2),
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 2, 3),
                MinInfInstr::new_func01(MINF_MRW0, 4, 4),
                MinInfInstr::new_func01(MINF_MARW0, 1, 0),
            ],
            vec![(0, 3), (1, 4)]
        ),
        dedup_subgraphs(
            vec![
                MinInfInstr::new_func01(MINF_MARF, 1, 2),
                MinInfInstr::new_func01(MINF_TBRF, 1, 2),
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 2, 3),
                MinInfInstr::new_func01(MINF_MRW0, 4, 4),
                MinInfInstr::new_func01(MINF_MARW0, 1, 0),
            ],
            vec![(0, 3), (1, 4)],
            None,
            None
        )
    );
    assert_eq!(
        (
            vec![
                MinInfInstr::new_func01(MINF_TBRF, 1, 1),
                MinInfInstr::new_01(MINF_TBRW0, 2),
                MinInfInstr::new_01(MINF_TBRF, 3),
                MinInfInstr::new_01(MINF_TBRW0, 4),
                MinInfInstr::new_01(MINF_STOP, 0),
                MinInfInstr::new_01(MINF_MARW0, 6),
                MinInfInstr::new_01(MINF_MARW1, 5),
            ],
            vec![(0, 3), (1, 4), (2, 2), (4, 3), (5, 6)]
        ),
        dedup_subgraphs(
            vec![
                MinInfInstr::new_func01(MINF_TBRF, 1, 5),
                MinInfInstr::new_01(MINF_TBRW0, 2),
                MinInfInstr::new_01(MINF_TBRF, 3),
                MinInfInstr::new_01(MINF_TBRW0, 4),
                MinInfInstr::new_01(MINF_STOP, 0),
                MinInfInstr::new_01(MINF_TBRW0, 6),
                MinInfInstr::new_01(MINF_TBRF, 7),
                MinInfInstr::new_01(MINF_TBRW0, 4),
                // test correct translation in map
                MinInfInstr::new_01(MINF_MARW0, 9),
                MinInfInstr::new_01(MINF_MARW1, 8),
            ],
            vec![(0, 3), (1, 4), (2, 6), (4, 7), (5, 9)], // last entry must be mapped correctly
            None,
            None
        )
    );
    assert_eq!(
        (
            vec![
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 1, 1),    // 0
                MinInfInstr::new(MINF_MARW0, MINF_MARW1, 2, 9), // 1
                MinInfInstr::new(MINF_MARW0, MINF_MARW1, 3, 6), // 2
                MinInfInstr::new(MINF_MRW1, MINF_MRW0, 4, 5),   // 3
                MinInfInstr::new(MINF_TBRW0, MINF_TBRW1, 8, 8), // 4
                MinInfInstr::new(MINF_MARW1, MINF_MARF, 8, 8),  // 5
                MinInfInstr::new(MINF_MRW0, MINF_MRW0, 4, 7),   // 6
                MinInfInstr::new(MINF_MRW1, MINF_MARF, 8, 8),   // 7
                MinInfInstr::new(MINF_STOP, MINF_STOP, 0, 0),   // 8
                MinInfInstr::new(MINF_TBRF, MINF_MARF, 10, 8),  // 9
                MinInfInstr::new(MINF_TBB, MINF_MAB, 8, 8),     // 10
            ],
            vec![
                (0, 3),
                (1, 4),
                (2, 6),
                (4, 4),
                (5, 8),
                (7, 9),
                (8, 6),
                (9, 4),
                (10, 7)
            ],
        ),
        dedup_subgraphs(
            vec![
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 1, 12),     // 0
                MinInfInstr::new(MINF_MARW0, MINF_MARW1, 2, 10),  // 1
                MinInfInstr::new(MINF_MARW0, MINF_MARW1, 3, 6),   // 2
                MinInfInstr::new(MINF_MRW1, MINF_MRW0, 4, 5),     // 3
                MinInfInstr::new(MINF_TBRW0, MINF_TBRW1, 9, 9),   // 4
                MinInfInstr::new(MINF_MARW1, MINF_MARF, 9, 9),    // 5
                MinInfInstr::new(MINF_MRW0, MINF_MRW0, 7, 8),     // 6
                MinInfInstr::new(MINF_TBRW0, MINF_TBRW1, 9, 9),   // 7
                MinInfInstr::new(MINF_MRW1, MINF_MARF, 9, 9),     // 8
                MinInfInstr::new(MINF_STOP, MINF_STOP, 0, 0),     // 9
                MinInfInstr::new(MINF_TBRF, MINF_MARF, 11, 9),    // 10
                MinInfInstr::new(MINF_TBB, MINF_MAB, 9, 9),       // 11
                MinInfInstr::new(MINF_MARW0, MINF_MARW1, 21, 14), // 12
                MinInfInstr::new(MINF_TBB, MINF_MAB, 9, 9),       // 13
                MinInfInstr::new(MINF_TBRF, MINF_MARF, 13, 9),    // 14
                MinInfInstr::new(MINF_MRW0, MINF_MRW0, 16, 17),   // 15
                MinInfInstr::new(MINF_TBRW0, MINF_TBRW1, 9, 9),   // 16
                MinInfInstr::new(MINF_MRW1, MINF_MARF, 9, 9),     // 17
                MinInfInstr::new(MINF_MRW1, MINF_MRW0, 19, 20),   // 18
                MinInfInstr::new(MINF_TBRW0, MINF_TBRW1, 9, 9),   // 19
                MinInfInstr::new(MINF_MARW1, MINF_MARF, 9, 9),    // 20
                MinInfInstr::new(MINF_MARW0, MINF_MARW1, 18, 15), // 21
            ],
            vec![
                (0, 3),
                (1, 4),
                (2, 6),
                (4, 7),
                (5, 9),
                (7, 14),
                (8, 15),
                (9, 19),
                (10, 17)
            ],
            None,
            None
        )
    );
    assert_eq!(
        (
            vec![
                MinInfInstr::new_func01(MINF_TBRF, 1, 1), // 0
                MinInfInstr::new_func01(MINF_TBRF, 2, 2), // 1
                MinInfInstr::new_01(MINF_TBRW0, 3),       // 2
                MinInfInstr::new_01(MINF_TBRF, 4),        // 3
                MinInfInstr::new_01(MINF_TBRW0, 5),       // 4
                MinInfInstr::new_01(MINF_STOP, 0),        // 5
            ],
            vec![(0, 2), (1, 3), (2, 5), (4, 2), (5, 4)]
        ),
        dedup_subgraphs(
            vec![
                MinInfInstr::new_func01(MINF_TBRF, 1, 2),   // 0
                MinInfInstr::new_func01(MINF_TBRF, 3, 7),   // 1
                MinInfInstr::new_func01(MINF_TBRF, 10, 13), // 2
                MinInfInstr::new_01(MINF_TBRW0, 4),         // 3
                MinInfInstr::new_01(MINF_TBRF, 5),          // 4
                MinInfInstr::new_01(MINF_TBRW0, 6),         // 5
                MinInfInstr::new_01(MINF_STOP, 0),          // 6
                MinInfInstr::new_01(MINF_TBRW0, 8),         // 7
                MinInfInstr::new_01(MINF_TBRF, 9),          // 8
                MinInfInstr::new_01(MINF_TBRW0, 6),         // 9
                MinInfInstr::new_01(MINF_TBRW0, 11),        // 10
                MinInfInstr::new_01(MINF_TBRF, 12),         // 11
                MinInfInstr::new_01(MINF_TBRW0, 6),         // 12
                MinInfInstr::new_01(MINF_TBRW0, 14),        // 13
                MinInfInstr::new_01(MINF_TBRF, 15),         // 14
                MinInfInstr::new_01(MINF_TBRW0, 6),         // 15
            ],
            vec![(0, 3), (1, 4), (2, 6), (4, 7), (5, 9)],
            None,
            None
        )
    );
    assert_eq!(
        (
            vec![
                MinInfInstr::new_func01(MINF_TBRF, 1, 2),   // 0
                MinInfInstr::new_func01(MINF_TBRF, 3, 7),   // 1
                MinInfInstr::new_func01(MINF_TBRF, 10, 10), // 2
                MinInfInstr::new_01(MINF_TBRW0, 4),         // 3
                MinInfInstr::new_01(MINF_TBRF, 5),          // 4
                MinInfInstr::new_01(MINF_TBRW0, 6),         // 5
                MinInfInstr::new_01(MINF_STOP, 0),          // 6
                MinInfInstr::new_01(MINF_TBRW0, 8),         // 7
                MinInfInstr::new_01(MINF_TBRF, 9),          // 8
                MinInfInstr::new_01(MINF_TBRW0, 7),         // 9
                MinInfInstr::new_01(MINF_TBRW0, 8),         // 10
            ],
            vec![
                (0, 3),
                (1, 4),
                (2, 6),
                (4, 7),
                (5, 9),
                (6, 10),
                (7, 9),
                (8, 8)
            ]
        ),
        dedup_subgraphs(
            vec![
                MinInfInstr::new_func01(MINF_TBRF, 1, 2),   // 0
                MinInfInstr::new_func01(MINF_TBRF, 3, 7),   // 1
                MinInfInstr::new_func01(MINF_TBRF, 10, 13), // 2
                MinInfInstr::new_01(MINF_TBRW0, 4),         // 3
                MinInfInstr::new_01(MINF_TBRF, 5),          // 4
                MinInfInstr::new_01(MINF_TBRW0, 6),         // 5
                MinInfInstr::new_01(MINF_STOP, 0),          // 6
                MinInfInstr::new_01(MINF_TBRW0, 8),         // 7
                MinInfInstr::new_01(MINF_TBRF, 9),          // 8
                MinInfInstr::new_01(MINF_TBRW0, 7),         // 9
                MinInfInstr::new_01(MINF_TBRW0, 11),        // 10
                MinInfInstr::new_01(MINF_TBRF, 12),         // 11
                MinInfInstr::new_01(MINF_TBRW0, 7),         // 12
                MinInfInstr::new_01(MINF_TBRW0, 14),        // 13
                MinInfInstr::new_01(MINF_TBRF, 15),         // 14
                MinInfInstr::new_01(MINF_TBRW0, 7),         // 15
            ],
            vec![
                (0, 3),
                (1, 4),
                (2, 6),
                (4, 7),
                (5, 9),
                (6, 10),
                (7, 12),
                (8, 14)
            ],
            None,
            None
        )
    );
    // multiple paths dedup
    assert_eq!(
        (
            vec![
                MinInfInstr::new_func01(MINF_MR, 1, 2),   // 0: d0
                MinInfInstr::new_func01(MINF_MR, 3, 4),   // 1: d1
                MinInfInstr::new_func01(MINF_MR, 5, 6),   // 2: d1
                MinInfInstr::new_func01(MINF_MR, 7, 15),  // 3: d2
                MinInfInstr::new_func01(MINF_MR, 16, 19), // 4: d2
                MinInfInstr::new_func01(MINF_MR, 20, 25), // 5: d2
                MinInfInstr::new_func01(MINF_MR, 26, 29), // 6: d2
                MinInfInstr::new_01(MINF_TBRW0, 8),       // 7: e0
                MinInfInstr::new_01(MINF_TBRF, 9),        // 8: e0
                MinInfInstr::new_01(MINF_TBRW0, 10),      // 9: e0
                MinInfInstr::new_01(MINF_TBRF, 11),       // 10: e0
                MinInfInstr::new_01(MINF_TBRW0, 12),      // 11: e0
                MinInfInstr::new_01(MINF_TBRF, 13),       // 12: e0
                MinInfInstr::new_01(MINF_MRW0, 14),       // 13: call
                MinInfInstr::new_01(MINF_STOP, 0),        // 14: call
                MinInfInstr::new_01(MINF_TBRW1, 8),       // 15: e1
                MinInfInstr::new_01(MINF_TBRW0, 17),      // 16: e2
                MinInfInstr::new_01(MINF_TBRF, 18),       // 17: e2
                MinInfInstr::new_01(MINF_TBRW1, 10),      // 18: e2
                MinInfInstr::new_01(MINF_TBRW1, 17),      // 19: e3
                MinInfInstr::new_01(MINF_TBRW0, 21),      // 20: e4
                MinInfInstr::new_01(MINF_TBRF, 22),       // 21: e4
                MinInfInstr::new_01(MINF_TBRW0, 23),      // 22: e4
                MinInfInstr::new_01(MINF_TBRF, 24),       // 23: e4
                MinInfInstr::new_01(MINF_TBRW1, 12),      // 24: e4
                MinInfInstr::new_01(MINF_TBRW1, 21),      // 25: e5
                MinInfInstr::new_01(MINF_TBRW0, 27),      // 26: e6
                MinInfInstr::new_01(MINF_TBRF, 28),       // 27: e6
                MinInfInstr::new_01(MINF_TBRW1, 23),      // 28: e6
                MinInfInstr::new_01(MINF_TBRW1, 27),      // 29: e7
            ],
            vec![(0, 7), (1, 10), (2, 18), (4, 23), (5, 29), (4, 22)],
        ),
        dedup_subgraphs(
            vec![
                MinInfInstr::new_func01(MINF_MR, 1, 2),   // 0: d0
                MinInfInstr::new_func01(MINF_MR, 3, 4),   // 1: d1
                MinInfInstr::new_func01(MINF_MR, 5, 6),   // 2: d1
                MinInfInstr::new_func01(MINF_MR, 7, 15),  // 3: d2
                MinInfInstr::new_func01(MINF_MR, 21, 27), // 4: d2
                MinInfInstr::new_func01(MINF_MR, 33, 39), // 5: d2
                MinInfInstr::new_func01(MINF_MR, 45, 51), // 6: d2
                MinInfInstr::new_01(MINF_TBRW0, 8),       // 7: e0
                MinInfInstr::new_01(MINF_TBRF, 9),        // 8: e0
                MinInfInstr::new_01(MINF_TBRW0, 10),      // 9: e0
                MinInfInstr::new_01(MINF_TBRF, 11),       // 10: e0
                MinInfInstr::new_01(MINF_TBRW0, 12),      // 11: e0
                MinInfInstr::new_01(MINF_TBRF, 13),       // 12: e0
                MinInfInstr::new_01(MINF_MRW0, 14),       // 13: call
                MinInfInstr::new_01(MINF_STOP, 0),        // 14: call
                MinInfInstr::new_01(MINF_TBRW1, 16),      // 15: e1
                MinInfInstr::new_01(MINF_TBRF, 17),       // 16: e1
                MinInfInstr::new_01(MINF_TBRW0, 18),      // 17: e1
                MinInfInstr::new_01(MINF_TBRF, 19),       // 18: e1
                MinInfInstr::new_01(MINF_TBRW0, 20),      // 19: e1
                MinInfInstr::new_01(MINF_TBRF, 13),       // 20: e1
                MinInfInstr::new_01(MINF_TBRW0, 22),      // 21: e2
                MinInfInstr::new_01(MINF_TBRF, 23),       // 22: e2
                MinInfInstr::new_01(MINF_TBRW1, 24),      // 23: e2
                MinInfInstr::new_01(MINF_TBRF, 25),       // 24: e2
                MinInfInstr::new_01(MINF_TBRW0, 26),      // 25: e2
                MinInfInstr::new_01(MINF_TBRF, 13),       // 26: e2
                MinInfInstr::new_01(MINF_TBRW1, 28),      // 27: e3
                MinInfInstr::new_01(MINF_TBRF, 29),       // 28: e3
                MinInfInstr::new_01(MINF_TBRW1, 30),      // 29: e3
                MinInfInstr::new_01(MINF_TBRF, 31),       // 30: e3
                MinInfInstr::new_01(MINF_TBRW0, 32),      // 31: e3
                MinInfInstr::new_01(MINF_TBRF, 13),       // 32: e3
                MinInfInstr::new_01(MINF_TBRW0, 34),      // 33: e4
                MinInfInstr::new_01(MINF_TBRF, 35),       // 34: e4
                MinInfInstr::new_01(MINF_TBRW0, 36),      // 35: e4
                MinInfInstr::new_01(MINF_TBRF, 37),       // 36: e4
                MinInfInstr::new_01(MINF_TBRW1, 38),      // 37: e4
                MinInfInstr::new_01(MINF_TBRF, 13),       // 38: e4
                MinInfInstr::new_01(MINF_TBRW1, 40),      // 39: e5
                MinInfInstr::new_01(MINF_TBRF, 41),       // 40: e5
                MinInfInstr::new_01(MINF_TBRW0, 42),      // 41: e5
                MinInfInstr::new_01(MINF_TBRF, 43),       // 42: e5
                MinInfInstr::new_01(MINF_TBRW1, 44),      // 43: e5
                MinInfInstr::new_01(MINF_TBRF, 13),       // 44: e5
                MinInfInstr::new_01(MINF_TBRW0, 46),      // 45: e6
                MinInfInstr::new_01(MINF_TBRF, 47),       // 46: e6
                MinInfInstr::new_01(MINF_TBRW1, 48),      // 47: e6
                MinInfInstr::new_01(MINF_TBRF, 49),       // 48: e6
                MinInfInstr::new_01(MINF_TBRW1, 50),      // 49: e6
                MinInfInstr::new_01(MINF_TBRF, 13),       // 50: e6
                MinInfInstr::new_01(MINF_TBRW1, 52),      // 51: e7
                MinInfInstr::new_01(MINF_TBRF, 53),       // 52: e7
                MinInfInstr::new_01(MINF_TBRW1, 54),      // 53: e7
                MinInfInstr::new_01(MINF_TBRF, 55),       // 54: e7
                MinInfInstr::new_01(MINF_TBRW1, 56),      // 55: e7
                MinInfInstr::new_01(MINF_TBRF, 13),       // 56: e7
            ],
            vec![(0, 7), (1, 18), (2, 23), (4, 42), (5, 51), (4, 35)],
            None,
            None
        )
    );
    assert_eq!(
        (
            vec![
                MinInfInstr::new_func01(MINF_MR, 1, 2),   // 0: d0
                MinInfInstr::new_func01(MINF_MR, 3, 4),   // 1: d1
                MinInfInstr::new_func01(MINF_MR, 5, 6),   // 2: d1
                MinInfInstr::new_func01(MINF_MR, 7, 15),  // 3: d2
                MinInfInstr::new_func01(MINF_MR, 20, 23), // 4: d2
                MinInfInstr::new_func01(MINF_MR, 26, 27), // 5: d2
                MinInfInstr::new_func01(MINF_MR, 28, 29), // 6: d2
                MinInfInstr::new_01(MINF_TBRW0, 8),       // 7: e0
                MinInfInstr::new_01(MINF_TBRF, 9),        // 8: e0
                MinInfInstr::new_01(MINF_TBRW0, 10),      // 9: e0
                MinInfInstr::new_01(MINF_TBRF, 11),       // 10: e0
                MinInfInstr::new_01(MINF_TBRW0, 12),      // 11: e0
                MinInfInstr::new_01(MINF_TBRF, 13),       // 12: e0
                MinInfInstr::new_01(MINF_MRW0, 14),       // 13: call
                MinInfInstr::new_01(MINF_STOP, 0),        // 14: call
                MinInfInstr::new_01(MINF_TBRW0, 16),      // 15: e1
                MinInfInstr::new_01(MINF_TBRF, 17),       // 16: e1
                MinInfInstr::new_01(MINF_TBRW0, 18),      // 17: e1
                MinInfInstr::new_01(MINF_TBRF, 19),       // 18: e1
                MinInfInstr::new_01(MINF_TBRW1, 12),      // 19: e1
                MinInfInstr::new_01(MINF_TBRW0, 21),      // 20: e2
                MinInfInstr::new_01(MINF_TBRF, 22),       // 21: e2
                MinInfInstr::new_01(MINF_TBRW1, 10),      // 22: e2
                MinInfInstr::new_01(MINF_TBRW0, 24),      // 23: e3
                MinInfInstr::new_01(MINF_TBRF, 25),       // 24: e3
                MinInfInstr::new_01(MINF_TBRW1, 18),      // 25: e3
                MinInfInstr::new_01(MINF_TBRW1, 8),       // 26: e4
                MinInfInstr::new_01(MINF_TBRW1, 16),      // 27: e5
                MinInfInstr::new_01(MINF_TBRW1, 21),      // 28: e6
                MinInfInstr::new_01(MINF_TBRW1, 24),      // 29: e7
            ],
            vec![(0, 7), (1, 18), (2, 22), (4, 18), (5, 29), (4, 9)],
        ),
        dedup_subgraphs(
            vec![
                MinInfInstr::new_func01(MINF_MR, 1, 2),   // 0: d0
                MinInfInstr::new_func01(MINF_MR, 3, 4),   // 1: d1
                MinInfInstr::new_func01(MINF_MR, 5, 6),   // 2: d1
                MinInfInstr::new_func01(MINF_MR, 7, 15),  // 3: d2
                MinInfInstr::new_func01(MINF_MR, 21, 27), // 4: d2
                MinInfInstr::new_func01(MINF_MR, 33, 39), // 5: d2
                MinInfInstr::new_func01(MINF_MR, 45, 51), // 6: d2
                MinInfInstr::new_01(MINF_TBRW0, 8),       // 7: e0
                MinInfInstr::new_01(MINF_TBRF, 9),        // 8: e0
                MinInfInstr::new_01(MINF_TBRW0, 10),      // 9: e0
                MinInfInstr::new_01(MINF_TBRF, 11),       // 10: e0
                MinInfInstr::new_01(MINF_TBRW0, 12),      // 11: e0
                MinInfInstr::new_01(MINF_TBRF, 13),       // 12: e0
                MinInfInstr::new_01(MINF_MRW0, 14),       // 13: call
                MinInfInstr::new_01(MINF_STOP, 0),        // 14: call
                MinInfInstr::new_01(MINF_TBRW0, 16),      // 15: e1
                MinInfInstr::new_01(MINF_TBRF, 17),       // 16: e1
                MinInfInstr::new_01(MINF_TBRW0, 18),      // 17: e1
                MinInfInstr::new_01(MINF_TBRF, 19),       // 18: e1
                MinInfInstr::new_01(MINF_TBRW1, 20),      // 19: e1
                MinInfInstr::new_01(MINF_TBRF, 13),       // 20: e1
                MinInfInstr::new_01(MINF_TBRW0, 22),      // 21: e2
                MinInfInstr::new_01(MINF_TBRF, 23),       // 22: e2
                MinInfInstr::new_01(MINF_TBRW1, 24),      // 23: e2
                MinInfInstr::new_01(MINF_TBRF, 25),       // 24: e2
                MinInfInstr::new_01(MINF_TBRW0, 26),      // 25: e2
                MinInfInstr::new_01(MINF_TBRF, 13),       // 26: e2
                MinInfInstr::new_01(MINF_TBRW0, 28),      // 27: e3
                MinInfInstr::new_01(MINF_TBRF, 29),       // 28: e3
                MinInfInstr::new_01(MINF_TBRW1, 30),      // 29: e3
                MinInfInstr::new_01(MINF_TBRF, 31),       // 30: e3
                MinInfInstr::new_01(MINF_TBRW1, 32),      // 31: e3
                MinInfInstr::new_01(MINF_TBRF, 13),       // 32: e3
                MinInfInstr::new_01(MINF_TBRW1, 34),      // 33: e4
                MinInfInstr::new_01(MINF_TBRF, 35),       // 34: e4
                MinInfInstr::new_01(MINF_TBRW0, 36),      // 35: e4
                MinInfInstr::new_01(MINF_TBRF, 37),       // 36: e4
                MinInfInstr::new_01(MINF_TBRW0, 38),      // 37: e4
                MinInfInstr::new_01(MINF_TBRF, 13),       // 38: e4
                MinInfInstr::new_01(MINF_TBRW1, 40),      // 39: e5
                MinInfInstr::new_01(MINF_TBRF, 41),       // 40: e5
                MinInfInstr::new_01(MINF_TBRW0, 42),      // 41: e5
                MinInfInstr::new_01(MINF_TBRF, 43),       // 42: e5
                MinInfInstr::new_01(MINF_TBRW1, 44),      // 43: e5
                MinInfInstr::new_01(MINF_TBRF, 13),       // 44: e5
                MinInfInstr::new_01(MINF_TBRW1, 46),      // 45: e6
                MinInfInstr::new_01(MINF_TBRF, 47),       // 46: e6
                MinInfInstr::new_01(MINF_TBRW1, 48),      // 47: e6
                MinInfInstr::new_01(MINF_TBRF, 49),       // 48: e6
                MinInfInstr::new_01(MINF_TBRW0, 50),      // 49: e6
                MinInfInstr::new_01(MINF_TBRF, 13),       // 50: e6
                MinInfInstr::new_01(MINF_TBRW1, 52),      // 51: e7
                MinInfInstr::new_01(MINF_TBRF, 53),       // 52: e7
                MinInfInstr::new_01(MINF_TBRW1, 54),      // 53: e7
                MinInfInstr::new_01(MINF_TBRF, 55),       // 54: e7
                MinInfInstr::new_01(MINF_TBRW1, 56),      // 55: e7
                MinInfInstr::new_01(MINF_TBRF, 13),       // 56: e7
            ],
            vec![(0, 7), (1, 18), (2, 23), (4, 42), (5, 51), (4, 35)],
            None,
            None
        )
    );
    // multiple depth subgraphs
    assert_eq!(
        (
            vec![
                MinInfInstr::new(MINF_MR, MINF_MR, 1, 2),   // 0
                MinInfInstr::new(MINF_MR, MINF_MR, 3, 4),   // 1
                MinInfInstr::new(MINF_MR, MINF_MR, 5, 5),   // 2
                MinInfInstr::new(MINF_MR, MINF_MR, 6, 6),   // 3
                MinInfInstr::new(MINF_MR, MINF_MR, 6, 12),  // 4
                MinInfInstr::new(MINF_MR, MINF_MR, 12, 14), // 5
                // copy 0
                MinInfInstr::new(MINF_MARW0, MINF_TBRF, 7, 8), // 6
                MinInfInstr::new(MINF_TBRW1, MINF_MAB, 9, 7),  // 7
                MinInfInstr::new(MINF_MRW1, MINF_TBRW1, 10, 8), // 8
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 11, 10), // 9
                MinInfInstr::new(MINF_TBRW0, MINF_MARW1, 6, 11), // 10
                MinInfInstr::new_01(MINF_STOP, 0),             // 11
                // copy 3
                MinInfInstr::new(MINF_MARW0, MINF_TBRW1, 13, 6), // 12
                MinInfInstr::new(MINF_TBRW0, MINF_TBB, 6, 7),    // 13
                // copy 5
                MinInfInstr::new(MINF_MAB, MINF_TBB, 15, 16), // 14
                MinInfInstr::new(MINF_MARF, MINF_TBRF, 16, 12), // 15
                MinInfInstr::new(MINF_MRW1, MINF_TBRW0, 12, 12), // 16
            ],
            vec![
                (0, 6),
                (1, 10),
                (2, 8),
                (3, 10),
                (4, 9),
                (5, 10),
                (6, 8),
                (7, 13),
                (8, 7),
                (9, 15),
                (10, 16),
                (11, 7),
                (12, 9),
                (13, 10)
            ]
        ),
        dedup_subgraphs(
            vec![
                MinInfInstr::new(MINF_MR, MINF_MR, 1, 2),   // 0
                MinInfInstr::new(MINF_MR, MINF_MR, 3, 4),   // 1
                MinInfInstr::new(MINF_MR, MINF_MR, 5, 5),   // 2
                MinInfInstr::new(MINF_MR, MINF_MR, 6, 12),  // 3
                MinInfInstr::new(MINF_MR, MINF_MR, 21, 22), // 4
                MinInfInstr::new(MINF_MR, MINF_MR, 29, 36), // 5
                // copy 0
                MinInfInstr::new(MINF_MARW0, MINF_TBRF, 7, 8), // 6
                MinInfInstr::new(MINF_TBRW1, MINF_MAB, 9, 7),  // 7
                MinInfInstr::new(MINF_MRW1, MINF_TBRW1, 10, 8), // 8
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 11, 10), // 9
                MinInfInstr::new(MINF_TBRW0, MINF_MARW1, 6, 11), // 10
                MinInfInstr::new_01(MINF_STOP, 0),             // 11
                // copy 1
                MinInfInstr::new(MINF_MARW0, MINF_TBRF, 13, 14), // 12
                MinInfInstr::new(MINF_TBRW1, MINF_MAB, 16, 13),  // 13
                MinInfInstr::new(MINF_MRW1, MINF_TBRW1, 15, 14), // 14
                MinInfInstr::new(MINF_TBRW0, MINF_MARW1, 12, 11), // 15
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 11, 15),   // 16
                // copy 2
                MinInfInstr::new(MINF_TBRW1, MINF_MAB, 19, 17), // 17: 7
                MinInfInstr::new(MINF_TBRW0, MINF_MARW1, 21, 11), // 18: 10
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 11, 18),  // 19: 9
                MinInfInstr::new(MINF_MRW1, MINF_TBRW1, 18, 20), // 20: 8
                MinInfInstr::new(MINF_MARW0, MINF_TBRF, 17, 20), // 21: 6
                // copy 3
                MinInfInstr::new(MINF_MARW0, MINF_TBRW1, 23, 28), // 22
                MinInfInstr::new(MINF_TBRW0, MINF_TBB, 28, 24),   // 23
                MinInfInstr::new(MINF_TBRW1, MINF_MAB, 26, 24),   // 24: 7
                MinInfInstr::new(MINF_TBRW0, MINF_MARW1, 28, 11), // 25: 10
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 11, 25),    // 26: 9
                MinInfInstr::new(MINF_MRW1, MINF_TBRW1, 25, 27),  // 27: 8
                MinInfInstr::new(MINF_MARW0, MINF_TBRF, 24, 27),  // 28: 6
                // copy 4
                MinInfInstr::new(MINF_MARW0, MINF_TBRW1, 30, 31), // 29
                MinInfInstr::new(MINF_TBRW0, MINF_TBB, 31, 32),   // 30
                MinInfInstr::new(MINF_MARW0, MINF_TBRF, 32, 33),  // 31
                MinInfInstr::new(MINF_TBRW1, MINF_MAB, 34, 32),   // 32
                MinInfInstr::new(MINF_MRW1, MINF_TBRW1, 35, 33),  // 33
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 11, 35),    // 34
                MinInfInstr::new(MINF_TBRW0, MINF_MARW1, 31, 11), // 35
                // copy 5
                MinInfInstr::new(MINF_MAB, MINF_TBB, 37, 38), // 36
                MinInfInstr::new(MINF_MARF, MINF_TBRF, 38, 39), // 37
                MinInfInstr::new(MINF_MRW1, MINF_TBRW0, 39, 39), // 38
                MinInfInstr::new(MINF_MARW0, MINF_TBRW1, 40, 41), // 39
                MinInfInstr::new(MINF_TBRW0, MINF_TBB, 41, 42), // 40
                MinInfInstr::new(MINF_MARW0, MINF_TBRF, 42, 43), // 41
                MinInfInstr::new(MINF_TBRW1, MINF_MAB, 44, 42), // 42
                MinInfInstr::new(MINF_MRW1, MINF_TBRW1, 45, 43), // 43
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 11, 45), // 44
                MinInfInstr::new(MINF_TBRW0, MINF_MARW1, 41, 11), // 45
            ],
            vec![
                (0, 6),
                (1, 18),
                (2, 14),
                (3, 18),
                (4, 19),
                (5, 25),
                (6, 27),
                (7, 30),
                (8, 32),
                (9, 37),
                (10, 38),
                (11, 42),
                (12, 44),
                (13, 45)
            ],
            None,
            None
        )
    );
    // multiple depth subgraphs: some changes in copies
    assert_eq!(
        (
            vec![
                MinInfInstr::new(MINF_MR, MINF_MR, 1, 2),         // 0: 0
                MinInfInstr::new(MINF_MR, MINF_MR, 3, 4),         // 1: 1
                MinInfInstr::new(MINF_MR, MINF_MR, 5, 5),         // 2: 2
                MinInfInstr::new(MINF_MR, MINF_MR, 6, 6),         // 3: 3
                MinInfInstr::new(MINF_MR, MINF_MR, 16, 17),       // 4: 4
                MinInfInstr::new(MINF_MR, MINF_MR, 24, 26),       // 5: 5
                MinInfInstr::new(MINF_MARW0, MINF_TBRF, 7, 8),    // 6: 6, 31
                MinInfInstr::new(MINF_TBRW1, MINF_MAB, 9, 7),     // 7: 7, 32
                MinInfInstr::new(MINF_MRW1, MINF_TBRW1, 10, 8),   // 8: 8, 33
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 11, 10),    // 9: 9, 34
                MinInfInstr::new(MINF_TBRW0, MINF_MARW1, 6, 11),  // 10: 10, 34
                MinInfInstr::new(MINF_STOP, MINF_STOP, 0, 0),     // 11: 11
                MinInfInstr::new(MINF_TBRW1, MINF_MAB, 14, 12),   // 12: 17
                MinInfInstr::new(MINF_TBRW0, MINF_MARW1, 16, 11), // 13: 18
                MinInfInstr::new(MINF_TBRF, MINF_TBR, 11, 13),    // 14: 19
                MinInfInstr::new(MINF_MRW1, MINF_TBRW1, 13, 15),  // 15: 20
                MinInfInstr::new(MINF_MARW0, MINF_TBRF, 12, 15),  // 16: 21
                MinInfInstr::new(MINF_MARW0, MINF_TBRW1, 18, 23), // 17: 22
                MinInfInstr::new(MINF_TBRW0, MINF_TBB, 23, 19),   // 18: 23
                MinInfInstr::new(MINF_TBRW1, MINF_MAB, 21, 19),   // 19: 24
                MinInfInstr::new(MINF_TBRW0, MINF_MARW1, 23, 11), // 20: 25
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 11, 20),    // 21: 26
                MinInfInstr::new(MINF_MRW0, MINF_TBRW1, 20, 22),  // 22: 27
                MinInfInstr::new(MINF_MARW0, MINF_TBRF, 19, 22),  // 23: 28
                MinInfInstr::new(MINF_MARW0, MINF_TBRW1, 25, 6),  // 24: 29
                MinInfInstr::new(MINF_TBRW0, MINF_TBB, 6, 7),     // 25: 30
                MinInfInstr::new(MINF_MAB, MINF_TBB, 27, 28),     // 26: 36
                MinInfInstr::new(MINF_MAR, MINF_TBRF, 28, 24),    // 27: 37
                MinInfInstr::new(MINF_MRW1, MINF_TBRW0, 24, 24),  // 28: 38
            ],
            vec![
                (0, 6),
                (1, 13),
                (2, 8),
                (3, 13),
                (4, 14),
                (5, 20),
                (6, 22),
                (7, 25),
                (8, 7),
                (9, 27),
                (10, 28),
                (11, 7),
                (12, 9),
                (13, 10),
            ]
        ),
        dedup_subgraphs(
            vec![
                MinInfInstr::new(MINF_MR, MINF_MR, 1, 2),   // 0
                MinInfInstr::new(MINF_MR, MINF_MR, 3, 4),   // 1
                MinInfInstr::new(MINF_MR, MINF_MR, 5, 5),   // 2
                MinInfInstr::new(MINF_MR, MINF_MR, 6, 12),  // 3
                MinInfInstr::new(MINF_MR, MINF_MR, 21, 22), // 4
                MinInfInstr::new(MINF_MR, MINF_MR, 29, 36), // 5
                // copy 0
                MinInfInstr::new(MINF_MARW0, MINF_TBRF, 7, 8), // 6
                MinInfInstr::new(MINF_TBRW1, MINF_MAB, 9, 7),  // 7
                MinInfInstr::new(MINF_MRW1, MINF_TBRW1, 10, 8), // 8
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 11, 10), // 9
                MinInfInstr::new(MINF_TBRW0, MINF_MARW1, 6, 11), // 10
                MinInfInstr::new_01(MINF_STOP, 0),             // 11
                // copy 1
                MinInfInstr::new(MINF_MARW0, MINF_TBRF, 13, 14), // 12
                MinInfInstr::new(MINF_TBRW1, MINF_MAB, 16, 13),  // 13
                MinInfInstr::new(MINF_MRW1, MINF_TBRW1, 15, 14), // 14
                MinInfInstr::new(MINF_TBRW0, MINF_MARW1, 12, 11), // 15
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 11, 15),   // 16
                // copy 2
                MinInfInstr::new(MINF_TBRW1, MINF_MAB, 19, 17), // 17: 7
                MinInfInstr::new(MINF_TBRW0, MINF_MARW1, 21, 11), // 18: 10
                MinInfInstr::new(MINF_TBRF, MINF_TBR, 11, 18),  // 19: 9
                MinInfInstr::new(MINF_MRW1, MINF_TBRW1, 18, 20), // 20: 8
                MinInfInstr::new(MINF_MARW0, MINF_TBRF, 17, 20), // 21: 6
                // copy 3
                MinInfInstr::new(MINF_MARW0, MINF_TBRW1, 23, 28), // 22
                MinInfInstr::new(MINF_TBRW0, MINF_TBB, 28, 24),   // 23
                MinInfInstr::new(MINF_TBRW1, MINF_MAB, 26, 24),   // 24: 7
                MinInfInstr::new(MINF_TBRW0, MINF_MARW1, 28, 11), // 25: 10
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 11, 25),    // 26: 9
                MinInfInstr::new(MINF_MRW0, MINF_TBRW1, 25, 27),  // 27: 8
                MinInfInstr::new(MINF_MARW0, MINF_TBRF, 24, 27),  // 28: 6
                // copy 4
                MinInfInstr::new(MINF_MARW0, MINF_TBRW1, 30, 31), // 29
                MinInfInstr::new(MINF_TBRW0, MINF_TBB, 31, 32),   // 30
                MinInfInstr::new(MINF_MARW0, MINF_TBRF, 32, 33),  // 31
                MinInfInstr::new(MINF_TBRW1, MINF_MAB, 34, 32),   // 32
                MinInfInstr::new(MINF_MRW1, MINF_TBRW1, 35, 33),  // 33
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 11, 35),    // 34
                MinInfInstr::new(MINF_TBRW0, MINF_MARW1, 31, 11), // 35
                // copy 5
                MinInfInstr::new(MINF_MAB, MINF_TBB, 37, 38), // 36
                MinInfInstr::new(MINF_MAR, MINF_TBRF, 38, 39), // 37
                MinInfInstr::new(MINF_MRW1, MINF_TBRW0, 39, 39), // 38
                MinInfInstr::new(MINF_MARW0, MINF_TBRW1, 40, 41), // 39
                MinInfInstr::new(MINF_TBRW0, MINF_TBB, 41, 42), // 40
                MinInfInstr::new(MINF_MARW0, MINF_TBRF, 42, 43), // 41
                MinInfInstr::new(MINF_TBRW1, MINF_MAB, 44, 42), // 42
                MinInfInstr::new(MINF_MRW1, MINF_TBRW1, 45, 43), // 43
                MinInfInstr::new(MINF_TBRF, MINF_TBB, 11, 45), // 44
                MinInfInstr::new(MINF_TBRW0, MINF_MARW1, 41, 11), // 45
            ],
            vec![
                (0, 6),
                (1, 18),
                (2, 14),
                (3, 18),
                (4, 19),
                (5, 25),
                (6, 27),
                (7, 30),
                (8, 32),
                (9, 37),
                (10, 38),
                (11, 42),
                (12, 44),
                (13, 45)
            ],
            None,
            None
        )
    );
    // STOPs deduplication
    assert_eq!(
        (
            vec![
                MinInfInstr::new_func01(MINF_TBRF, 1, 1),
                MinInfInstr::new_01(MINF_TBRW0, 2),
                MinInfInstr::new_01(MINF_TBRF, 3),
                MinInfInstr::new_01(MINF_TBRW0, 4),
                MinInfInstr::new_01(MINF_STOP, 0),
            ],
            vec![(0, 3), (1, 4), (2, 2), (4, 3)]
        ),
        dedup_subgraphs(
            vec![
                MinInfInstr::new_func01(MINF_TBRF, 1, 5),
                MinInfInstr::new_01(MINF_TBRW0, 2),
                MinInfInstr::new_01(MINF_TBRF, 3),
                MinInfInstr::new_01(MINF_TBRW0, 4),
                MinInfInstr::new_01(MINF_STOP, 0),
                MinInfInstr::new_01(MINF_TBRW0, 6),
                MinInfInstr::new_01(MINF_TBRF, 7),
                MinInfInstr::new_01(MINF_TBRW0, 8),
                MinInfInstr::new_01(MINF_STOP, 0),
            ],
            vec![(0, 3), (1, 4), (2, 6), (4, 7)],
            None,
            None
        )
    );
    // STOPs deduplication
    assert_eq!(
        (
            vec![
                MinInfInstr::new_func01(MINF_TBRF, 1, 1),
                MinInfInstr::new_01(MINF_TBRW0, 2),
                MinInfInstr::new_01(MINF_TBRF, 3),
                MinInfInstr::new_01(MINF_TBRW1, 4),
                MinInfInstr::new_01(MINF_STOP, 0),
            ],
            vec![(0, 3), (1, 4), (2, 2), (4, 3)]
        ),
        dedup_subgraphs(
            vec![
                MinInfInstr::new_func01(MINF_TBRF, 1, 5),
                MinInfInstr::new_01(MINF_TBRW0, 2),
                MinInfInstr::new_01(MINF_TBRF, 3),
                MinInfInstr::new_01(MINF_TBRW1, 4),
                MinInfInstr::new_01(MINF_STOP, 0),
                MinInfInstr::new_01(MINF_TBRW0, 6),
                MinInfInstr::new_01(MINF_TBRF, 7),
                MinInfInstr::new_01(MINF_TBRW1, 8),
                MinInfInstr::new_01(MINF_STOP, 0),
            ],
            vec![(0, 3), (1, 4), (2, 6), (4, 7)],
            None,
            None
        )
    );
    // no different STOPs reduction
    assert_eq!(
        (
            vec![
                MinInfInstr::new_func01(MINF_TBRF, 1, 5),
                MinInfInstr::new_01(MINF_TBRW0, 2),
                MinInfInstr::new_01(MINF_TBRF, 3),
                MinInfInstr::new_01(MINF_TBRW0, 4),
                MinInfInstr::new_01(MINF_STOP, 0),
                MinInfInstr::new_01(MINF_TBRW0, 6),
                MinInfInstr::new_01(MINF_TBRF, 7),
                MinInfInstr::new_01(MINF_TBRW0, 8),
                MinInfInstr::new_01(MINF_STOP2, 0),
            ],
            vec![(0, 3), (1, 4), (2, 6), (4, 7)]
        ),
        dedup_subgraphs(
            vec![
                MinInfInstr::new_func01(MINF_TBRF, 1, 5),
                MinInfInstr::new_01(MINF_TBRW0, 2),
                MinInfInstr::new_01(MINF_TBRF, 3),
                MinInfInstr::new_01(MINF_TBRW0, 4),
                MinInfInstr::new_01(MINF_STOP, 0),
                MinInfInstr::new_01(MINF_TBRW0, 6),
                MinInfInstr::new_01(MINF_TBRF, 7),
                MinInfInstr::new_01(MINF_TBRW0, 8),
                MinInfInstr::new_01(MINF_STOP2, 0),
            ],
            vec![(0, 3), (1, 4), (2, 6), (4, 7)],
            None,
            None
        )
    );
    // nested duplicates
    assert_eq!(
        (
            vec![
                MinInfInstr::new_func01(MINF_MAB, 1, 1),
                MinInfInstr::new_func01(MINF_TBRW0, 2, 2),
                MinInfInstr::new_01(MINF_TBRF, 3),
                MinInfInstr::new_01(MINF_MARF, 4),
                MinInfInstr::new_01(MINF_STOP, 0),
            ],
            vec![(0, 3), (1, 2), (2, 4), (4, 1), (5, 2), (6, 3)]
        ),
        dedup_subgraphs(
            vec![
                MinInfInstr::new_func01(MINF_MAB, 1, 7),
                MinInfInstr::new_func01(MINF_TBRW0, 2, 4),
                MinInfInstr::new_01(MINF_TBRF, 3),
                MinInfInstr::new_01(MINF_MARF, 6),
                MinInfInstr::new_01(MINF_TBRF, 5),
                MinInfInstr::new_01(MINF_MARF, 6),
                MinInfInstr::new_01(MINF_STOP, 0),
                MinInfInstr::new_func01(MINF_TBRW0, 8, 10),
                MinInfInstr::new_01(MINF_TBRF, 9),
                MinInfInstr::new_01(MINF_MARF, 12),
                MinInfInstr::new_01(MINF_TBRF, 11),
                MinInfInstr::new_01(MINF_MARF, 12),
                MinInfInstr::new_01(MINF_STOP, 0),
            ],
            vec![(0, 3), (1, 4), (2, 6), (4, 7), (5, 10), (6, 11)],
            None,
            None
        )
    );
    assert_eq!(
        (
            vec![
                MinInfInstr::new_func01(MINF_MAB, 1, 1),
                MinInfInstr::new_func01(MINF_MAB, 2, 2),
                MinInfInstr::new_func01(MINF_TBRW0, 3, 3),
                MinInfInstr::new_01(MINF_TBRF, 4),
                MinInfInstr::new_01(MINF_MARF, 5),
                MinInfInstr::new_01(MINF_STOP, 0),
            ],
            vec![
                (0, 3),
                (1, 4),
                (2, 4),
                (4, 5),
                (5, 4),
                (6, 3),
                (7, 5),
                (8, 5)
            ]
        ),
        dedup_subgraphs(
            vec![
                MinInfInstr::new_func01(MINF_MAB, 1, 14),    // 0
                MinInfInstr::new_func01(MINF_MAB, 2, 8),     // 1
                MinInfInstr::new_func01(MINF_TBRW0, 3, 5),   // 2
                MinInfInstr::new_01(MINF_TBRF, 4),           // 3
                MinInfInstr::new_01(MINF_MARF, 7),           // 4
                MinInfInstr::new_01(MINF_TBRF, 6),           // 5
                MinInfInstr::new_01(MINF_MARF, 7),           // 6
                MinInfInstr::new_01(MINF_STOP, 0),           // 7
                MinInfInstr::new_func01(MINF_TBRW0, 9, 11),  // 8
                MinInfInstr::new_01(MINF_TBRF, 10),          // 9
                MinInfInstr::new_01(MINF_MARF, 13),          // 10
                MinInfInstr::new_01(MINF_TBRF, 12),          // 11
                MinInfInstr::new_01(MINF_MARF, 13),          // 12
                MinInfInstr::new_01(MINF_STOP, 0),           // 13
                MinInfInstr::new_func01(MINF_MAB, 15, 21),   // 14
                MinInfInstr::new_func01(MINF_TBRW0, 16, 18), // 15
                MinInfInstr::new_01(MINF_TBRF, 17),          // 16
                MinInfInstr::new_01(MINF_MARF, 20),          // 17
                MinInfInstr::new_01(MINF_TBRF, 19),          // 18
                MinInfInstr::new_01(MINF_MARF, 20),          // 19
                MinInfInstr::new_01(MINF_STOP, 0),           // 20
                MinInfInstr::new_func01(MINF_TBRW0, 22, 24), // 21
                MinInfInstr::new_01(MINF_TBRF, 23),          // 22
                MinInfInstr::new_01(MINF_MARF, 26),          // 23
                MinInfInstr::new_01(MINF_TBRF, 25),          // 24
                MinInfInstr::new_01(MINF_MARF, 26),          // 25
                MinInfInstr::new_01(MINF_STOP, 0),           // 26
            ],
            vec![
                (0, 3),
                (1, 4),
                (2, 6),
                (4, 7),
                (5, 10),
                (6, 11),
                (7, 20),
                (8, 26)
            ],
            None,
            None
        )
    );
}