// Generated from "j2ktnewobjcname/MethodExample.java"
@file:OptIn(ExperimentalObjCName::class)
@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 j2ktnewobjcname

import javaemul.lang.*
import kotlin.Any
import kotlin.Array
import kotlin.Boolean
import kotlin.Byte
import kotlin.Char
import kotlin.Double
import kotlin.Float
import kotlin.Int
import kotlin.Long
import kotlin.LongArray
import kotlin.OptIn
import kotlin.Short
import kotlin.String
import kotlin.Suppress
import kotlin.experimental.ExperimentalObjCName
import kotlin.jvm.JvmStatic
import kotlin.native.ObjCName

open class MethodExample {
 companion object {
  @JvmStatic
  fun main(vararg args: String?) {
   val args_1: Array<String?>? = args as Array<String?>?
  }
 }

 open class Foo

 open class Default {
  open fun instanceMethod(i: Int) {}

  open fun instanceMethod(i: Int, l: LongArray?) {}

  open fun instanceMethod(i: Int, l: Array<LongArray?>?) {}

  open fun instanceMethod(i: Int, id: Any?) {}

  open fun instanceMethod(foo: Foo?) {}

  open fun instanceMethod(foo: Array<Foo?>?) {}

  open fun instanceMethod(foo: Array<Array<Foo?>?>?) {}

  open fun <T> instanceMethod(t: T) {}

  open fun <S: String?> instanceMethod(s: S) {}

  companion object {
   @JvmStatic
   fun staticMethod(i: Int) {}

   @JvmStatic
   fun staticMethod(i: Int, l: LongArray?) {}

   @JvmStatic
   fun staticMethod(i: Int, l: Array<LongArray?>?) {}

   @JvmStatic
   fun staticMethod(i: Int, id: Any?) {}

   @JvmStatic
   fun staticMethod(foo: Foo?) {}

   @JvmStatic
   fun staticMethod(foo: Array<Foo?>?) {}

   @JvmStatic
   fun staticMethod(foo: Array<Array<Foo?>?>?) {}

   @JvmStatic
   fun <T> staticMethod(t: T) {}

   @JvmStatic
   fun <S: String?> staticMethod(s: S) {}
  }
 }

 open class Custom {
  @ObjCName("newFoo")
  open fun foo() {}

  @ObjCName("newProtectedFoo")
  open fun protectedFoo() {}

  @ObjCName("implicitParams")
  open fun implicitParams() {}

  @ObjCName("implicitParams")
  open fun implicitParams(
   @ObjCName("withInt", swiftName = "with") i: Int
  ) {}

  @ObjCName("implicitParams")
  open fun implicitParams(
   @ObjCName("withInt", swiftName = "with") i: Int,
   @ObjCName("withNSString", swiftName = "with") s: String?
  ) {}

  @ObjCName("explicitParams")
  open fun explicitParams() {}

  @ObjCName("explicitParams")
  open fun explicitParams(
   @ObjCName("WithIndex") i: Int
  ) {}

  @ObjCName("explicitParams")
  open fun explicitParams(
   @ObjCName("WithIndex") i: Int,
   @ObjCName("name") s: String?
  ) {}
 }

 class Special {
  class WithBoolean {
   fun get(x: Boolean) {}
  }

  class WithChar {
   fun get(x: Char) {}
  }

  class WithByte {
   fun get(x: Byte) {}
  }

  class WithShort {
   fun get(x: Short) {}
  }

  class WithInt {
   fun get(x: Int) {}
  }

  class WithLong {
   fun get(x: Long) {}
  }

  class WithFloat {
   fun get(x: Float) {}
  }

  class WithDouble {
   fun get(x: Double) {}
  }

  class WithObject {
   fun get(x: Any?) {}
  }

  class WithString {
   fun get(x: String?) {}
  }

  class WithFoo {
   fun get(x: Foo?) {}
  }
 }
}
