// Generated from "supermethodcall/Child.java"
@file:Suppress(
 "ALWAYS_NULL",
 "PARAMETER_NAME_CHANGED_ON_OVERRIDE",
 "SENSELESS_COMPARISON",
 "UNCHECKED_CAST",
 "UNNECESSARY_LATEINIT",
 "UNNECESSARY_NOT_NULL_ASSERTION",
 "UNREACHABLE_CODE",
 "UNUSED_ANONYMOUS_PARAMETER",
 "UNUSED_PARAMETER",
 "UNUSED_VARIABLE",
 "USELESS_CAST",
 "VARIABLE_IN_SINGLETON_WITHOUT_THREAD_LOCAL",
 "VARIABLE_WITH_REDUNDANT_INITIALIZER",
 "REDUNDANT_ELSE_IN_WHEN")

package supermethodcall

import javaemul.lang.*
import kotlin.Any
import kotlin.Int
import kotlin.String
import kotlin.Suppress

interface GrandParentInterface {
 fun defaultGrandParent() {}
}

interface ParentInterface {
 fun defaultParent() {}
}

open class GrandParent internal constructor() {
 open fun grandParentSimplest() {}

 open fun grandParentWithParams(foo: Int) {}

 open fun grandParentWithChangingReturn(): Any? {
  return null
 }

 open fun defaultParent() {}

 open fun defaultGrandParent() {}
}

open class Parent internal constructor(): GrandParent(), ParentInterface {
 open fun parentSimplest() {}

 open fun parentWithParams(foo: Int) {}

 open fun parentWithChangingReturn(): Any? {
  return null
 }

 override fun defaultParent() {
  super<GrandParent>.defaultParent()
  super<ParentInterface>.defaultParent()
 }
}

open class Child: Parent(), GrandParentInterface {
 override fun parentSimplest() {
  super<Parent>.parentSimplest()
 }

 override fun parentWithParams(foo: Int) {
  super<Parent>.parentWithParams(foo)
 }

 override fun parentWithChangingReturn(): Child? {
  super<Parent>.parentWithChangingReturn()
  return this
 }

 override fun grandParentSimplest() {
  super<Parent>.grandParentSimplest()
 }

 override fun grandParentWithParams(foo: Int) {
  super<Parent>.grandParentWithParams(foo)
 }

 override fun grandParentWithChangingReturn(): Child? {
  super<Parent>.grandParentWithChangingReturn()
  return this
 }

 override fun defaultGrandParent() {
  super<Parent>.defaultGrandParent()
  super<GrandParentInterface>.defaultGrandParent()
 }
}

interface I1 {
 fun m() {}
}

fun interface I2 {
 fun m()
}

interface I3: I1

open class Super internal constructor() {
 open fun m() {}
}

open class Sub internal constructor(): Super(), I2, I3 {
 override fun m() {
  super<I3>.m()
 }
}

abstract class SuperToStringTest internal constructor(): I1 {
 override fun toString(): String {
  return super.toString()
 }
}
