open annotation class MyAnnotation : Annotation {
  constructor() /* primary */ {
    super/*Any*/()
    /* <init>() */

  }

}

open class A {
  @MyAnnotation
  open val a: Int
    field = 1
    open get

  @MyAnnotation
  constructor(i: Int) {
    super/*Any*/()
    /* <init>() */

  }

  @MyAnnotation
  open fun foo(@MyAnnotation a: Int) {
  }

  open var b: Int
    @MyAnnotation
    open get(): Int {
      return 10
    }
    @MyAnnotation
    open set(value: Int) {
    }

}

class B : Java1 {
  constructor() /* primary */ {
    super/*Java1*/(i = 1)
    /* <init>() */

  }

}

class C : Java1 {
  constructor() /* primary */ {
    super/*Java1*/(i = 1)
    /* <init>() */

  }

  override fun foo(a: Int) {
  }

  override val a: Int
    override get(): Int {
      return 10
    }

  override var b: Int
    override get(): Int {
      return 11
    }
    override set(value: Int) {
    }

}

class D : Java2 {
  constructor() /* primary */ {
    super/*Java2*/(i = 2)
    /* <init>() */

  }

}

class E : Java2 {
  override var b: Int
    field = 0
    override get(): Int {
      return 11
    }
    override set

  constructor() /* primary */ {
    super/*Java2*/(i = 2)
    /* <init>() */

  }

  override fun foo(a: Int) {
  }

  override val a: Int
    override get(): Int {
      return 10
    }

}

abstract class F : Java1, Java3 {
  constructor() /* primary */ {
    super/*Java1*/(i = 1)
    /* <init>() */

  }

}

class G : Java1, Java3 {
  constructor() /* primary */ {
    super/*Java1*/(i = 1)
    /* <init>() */

  }

  override fun foo(a: Int) {
  }

  override fun setA(a: Int) {
  }

}

class H : Java1, KotlinInterface {
  constructor() /* primary */ {
    super/*Java1*/(i = 1)
    /* <init>() */

  }

}

class I : Java1, KotlinInterface {
  constructor() /* primary */ {
    super/*Java1*/(i = 1)
    /* <init>() */

  }

  override fun foo(a: Int) {
  }

  override val a: Int
    override get(): Int {
      return 2
    }

  override var b: Int
    override get(): Int {
      return 2
    }
    override set(value: Int) {
    }

}

interface KotlinInterface {
  abstract fun foo(a: Int)

  abstract val a: Int
    abstract get

  abstract val b: Int
    abstract get

}

fun test(b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) {
  b.<get-a>() /*~> Unit */
  b.<get-b>() /*~> Unit */
  b.foo(a = 1)
  c.<get-a>() /*~> Unit */
  c.<get-b>() /*~> Unit */
  c.foo(a = 1)
  d.<get-a>() /*~> Unit */
  d.<get-b>() /*~> Unit */
  d.foo(a = 1)
  e.<get-a>() /*~> Unit */
  e.<get-b>() /*~> Unit */
  e.foo(a = 1)
  f.<get-a>() /*~> Unit */
  f.<get-b>() /*~> Unit */
  f.foo(a = 1)
  g.<get-a>() /*~> Unit */
  g.<get-b>() /*~> Unit */
  g.foo(a = 1)
  h.<get-a>() /*~> Unit */
  h.<get-b>() /*~> Unit */
  h.foo(a = 1)
  i.<get-a>() /*~> Unit */
  i.<get-b>() /*~> Unit */
  i.foo(a = 1)
}