namespace <root>

// <namespace name="b">
namespace b

internal open class b.A : jet.Any {
    public final /*constructor*/ fun <init>(): b.A
    internal open fun foo(): jet.Tuple0
}
internal final class b.B : b.A {
    public final /*constructor*/ fun <init>(): b.B
    protected open override /*1*/ fun foo(): jet.Tuple0
}
internal final class b.C : b.A {
    public final /*constructor*/ fun <init>(): b.C
    internal open override /*1*/ fun foo(): jet.Tuple0
}
internal open class b.D : jet.Any {
    public final /*constructor*/ fun <init>(): b.D
    private open fun self(): b.D
}
internal final class b.E : b.D {
    public final /*constructor*/ fun <init>(): b.E
    internal open fun self(): b.E
    internal final fun test(): jet.Tuple0
}
internal open class b.F : jet.Any {
    public final /*constructor*/ fun <init>(): b.F
    protected open fun protected_fun(): jet.Tuple0
}
internal final class b.G : b.F {
    public final /*constructor*/ fun <init>(): b.G
    protected open override /*1*/ fun protected_fun(): jet.Tuple0
}
internal open class b.H : jet.Any {
    public final /*constructor*/ fun <init>(): b.H
    protected open fun pi_fun(): jet.Tuple0
}
internal final class b.I : b.H {
    public final /*constructor*/ fun <init>(): b.I
    protected open override /*1*/ fun pi_fun(): jet.Tuple0
}
internal final class b.J : b.H {
    public final /*constructor*/ fun <init>(): b.J
    internal open override /*1*/ fun pi_fun(): jet.Tuple0
}
internal final class b.K : b.H {
    public final /*constructor*/ fun <init>(): b.K
    public open override /*1*/ fun pi_fun(): jet.Tuple0
}
internal open class b.L : b.T {
    public final /*constructor*/ fun <init>(): b.L
    public open override /*1*/ fun foo(): jet.Tuple0
}
internal final class b.M : b.L {
    public final /*constructor*/ fun <init>(): b.M
    internal open override /*1*/ fun foo(): jet.Tuple0
}
internal abstract trait b.P : b.R {
    internal open override /*1*/ fun foo(): jet.Tuple0
}
internal abstract trait b.Q : b.R {
    protected open override /*1*/ fun foo(): jet.Tuple0
}
internal abstract trait b.R : jet.Any {
    protected open fun foo(): jet.Tuple0
}
internal final class b.S : b.P, b.Q {
    public final /*constructor*/ fun <init>(): b.S
    internal open override /*2*/ fun foo(): jet.Tuple0
}
internal abstract trait b.T : jet.Any {
    public open fun foo(): jet.Tuple0
}
internal final fun test_fun_stays_protected(/*0*/ g: b.G): jet.Tuple0
// </namespace name="b">
