//# publish
module 0x1.M {
    struct S<T> { b: bool }

    a<T>() {
    label b0:
        Self.b<Self.S<T>, u64>();
        return;
    }

    b<T1, T2>() {
    label b0:
        Self.f<T1>();
        Self.c<Self.S<T2>, bool>();
        return;
    }

    c<T1, T2>() {
    label b0:
        Self.c<u64, T1>();
        Self.d<T2>();
        Self.e<T2>();
        return;
    }

    d<T>() {
    label b0:
        Self.b<u64, T>();
        return;
    }

    e<T>() {
    label b0:
        return;
    }

    f<T>() {
    label b0:
        Self.g<T>();
        return;
    }

    g<T>() {
    label b0:
        Self.f<Self.S<T>>();
        return;
    }
}
// There are two disjoint loops in the resulting graph, but only one error
// loop: f#T --> g#T --S<T>--> f#T
// loop: c#T1 --> c#T2 --> d#T --> b#T2 --S<T2>--> c#T1

//# publish
module 0x1.M2 {
    struct S<T> { b: bool }

    f<T>() {
    label b0:
        Self.g<T>();
        return;
    }

    g<T>() {
    label b0:
        Self.f<Self.S<T>>();
        return;
    }
}
// loop: f#T --> g#T --S<T>--> f#T
// check: LOOP_IN_INSTANTIATION_GRAPH

//# publish

module 0x1.M3 {
    struct S<T> { b: bool }

    a<T>() {
    label b0:
        Self.b<Self.S<T>, u64>();
        return;
    }

    b<T1, T2>() {
    label b0:
        Self.f<T1>();
        Self.c<Self.S<T2>, bool>();
        return;
    }

    c<T1, T2>() {
    label b0:
        Self.c<u64, T1>();
        Self.d<T2>();
        Self.e<T2>();
        return;
    }

    d<T>() {
    label b0:
        Self.b<u64, T>();
        return;
    }

    e<T>() {
    label b0:
        return;
    }

    f<T>() {
    label b0:
        Self.g<T>();
        return;
    }

    g<T>() {
    label b0:
        // Switched to just <T> to isolate the loop
        Self.f<T>();
        return;
    }
}
// loop: c#T1 --> c#T2 --> d#T --> b#T2 --S<T2>--> c#T1