class A : Java1 {
  constructor() /* primary */ {
    super/*Java1*/()
    /* <init>() */

  }

}

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

  }

  override fun overloadMethod(first: String, second: String, third: Int) {
  }

}

class C : Java2 {
  constructor() /* primary */ {
    super/*Java2*/()
    /* <init>() */

  }

}

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

  }

  override fun overloadMethod(first: String, second: String, third: Int) {
  }

  override val a: String
    override get(): String {
      return "3"
    }

}

abstract class E : Java1, Java3 {
  constructor() /* primary */ {
    super/*Java1*/()
    /* <init>() */

  }

}

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

  }

  override fun foo() {
  }

  override fun getC(): String {
    return "5"
  }

  override fun setB(text: String) {
  }

  override fun setC(text: String) {
  }

}

abstract class G : Java1, KotlinInterface {
  constructor() /* primary */ {
    super/*Java1*/()
    /* <init>() */

  }

}

class H : Java1, KotlinInterface {
  override val b: String
    field = b
    override get

  constructor(b: String) /* primary */ {
    super/*Java1*/()
    /* <init>() */

  }

  override fun foo() {
  }

  override fun overloadMethod(first: String) {
  }

}

open class KotlinClass {
  val a: String
    field = "1"
    get

  var c: String
    field = "1"
    @JvmName(name = "getText")
    get
    @JvmName(name = "setText")
    set

  companion object Companion {
    private constructor() /* primary */ {
      super/*Any*/()
      /* <init>() */

    }

    @JvmStatic
    fun foo() {
    }

  }

  constructor() /* primary */ {
    super/*Any*/()
    /* <init>() */

  }

  @JvmName(name = "getBJava")
  fun getB(): String {
    return "b"
  }

  @JvmOverloads
  open fun overloadMethod(first: String, second: String = "text", third: Int = 10) {
  }

}

interface KotlinInterface {
  abstract fun foo()

  abstract fun overloadMethod(first: String)

  abstract val a: String
    abstract get

  abstract val b: String
    abstract get

  abstract var c: String
    abstract get
    abstract set

}

fun test(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) {
  a.<get-a>() /*~> Unit */
  a.<get-c>() /*~> Unit */
  a.<set-c>(<set-?> = "2")
  a.overloadMethod(first = "")
  b.<get-a>() /*~> Unit */
  b.<get-c>() /*~> Unit */
  b.<set-c>(<set-?> = "2")
  b.overloadMethod(first = "", second = "2", third = 3)
  c.<get-a>() /*~> Unit */
  c.<get-c>() /*~> Unit */
  c.<set-c>(<set-?> = "2")
  c.overloadMethod(first = "")
  c.overloadMethod(first = "", second = "", third = 1)
  d.<get-a>() /*~> Unit */
  d.<get-c>() /*~> Unit */
  d.<set-c>(<set-?> = "2")
  d.overloadMethod(first = "")
  d.overloadMethod(first = "", second = "", third = 1)
  e.<get-a>() /*~> Unit */
  e.getB() /*~> Unit */
  e.<get-c>() /*~> Unit */
  e.<set-c>(<set-?> = "2")
  e.setB(text = "2")
  e.overloadMethod(first = "")
  f.<get-a>() /*~> Unit */
  f.getB() /*~> Unit */
  f.<get-c>() /*~> Unit */
  f.<set-c>(<set-?> = "2")
  f.setB(text = "2")
  f.overloadMethod(first = "")
  g.<get-a>() /*~> Unit */
  g.<get-b>() /*~> Unit */
  g.<get-c>() /*~> Unit */
  g.<set-c>(<set-?> = "2")
  g.overloadMethod(first = "")
  h.<get-a>() /*~> Unit */
  h.<get-b>() /*~> Unit */
  h.<get-c>() /*~> Unit */
  h.overloadMethod(first = "")
  h.overloadMethod(first = "", second = "", third = 1)
}