// Generated from "jsvarargs/Main.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 jsvarargs

import javaemul.lang.*
import jsinterop.annotations.JsConstructor
import jsinterop.annotations.JsFunction
import jsinterop.annotations.JsMethod
import jsinterop.annotations.JsPackage
import jsinterop.annotations.JsType
import kotlin.Any
import kotlin.Array
import kotlin.Int
import kotlin.IntArray
import kotlin.Suppress
import kotlin.arrayOf
import kotlin.collections.MutableList
import kotlin.intArrayOf
import kotlin.jvm.JvmField
import kotlin.jvm.JvmStatic

open class Main {
 @JvmField
 internal var field_pp_jsvarargs: Int = 0

 constructor(f: Int) {
  this.field_pp_jsvarargs = f
 }

 @JsMethod
 open fun f3(m: Int, vararg numbers: Int): Int {
  return this.field_pp_jsvarargs + m + numbers!![1]
 }

 @JsMethod
 open fun f4(vararg numbers: Int): Int {
  return this.field_pp_jsvarargs + numbers!![1]
 }

 open fun testStaticMethodNotFirst() {
  Main.f1(1, 1, 2)
  Main.f1(1, 1, 2)
  Main.f1(1)
  Main.f1(1)
  Main.f1(
   1,
   *intArrayOf(1, 2),
  )
  Main.f1(
   1,
   *intArrayOf(1, 2),
  )
  Main.f1(
   1,
   *intArrayOf(),
  )
  Main.f1(
   1,
   *intArrayOf(),
  )
  val ints: IntArray = intArrayOf(1, 2)
  Main.f1(
   1,
   *ints,
  )
  Main.f1(
   1,
   *ints,
  )
  Main.f1(
   1,
   *null!!,
  )
 }

 open fun testStaticMethodFirst() {
  Main.f2(1, 2)
  Main.generics<Int?>(1, 2)
  Main.f2(1, 2)
  Main.generics<Int?>(1, 2)
  Main.f2()
  Main.generics<Any?>()
  Main.f2()
  Main.generics<Any?>()
  Main.generics<Int?>()
  Main.f2(
   *intArrayOf(1, 2),
  )
  Main.f2(
   *intArrayOf(1, 2),
  )
  Main.generics<IntArray?>(
   intArrayOf(1, 2),
  )
  Main.generics<Int?>(
   *arrayOf<Int?>(1, 2),
  )
  Main.f2(
   *intArrayOf(),
  )
  Main.f2(
   *intArrayOf(),
  )
  Main.generics<IntArray?>(
   intArrayOf(),
  )
  val ints: IntArray = intArrayOf(1, 2)
  val integers: Array<Int?> = arrayOf<Int?>(1, 2)
  Main.f2(
   *ints,
  )
  Main.f2(
   *ints,
  )
  Main.generics<Int?>(
   *integers,
  )
 }

 open fun testInstanceMethodNotFirst() {
  val m: Main = Main(1)
  m.f3(1, 1, 2)
  m.f3(1)
  m.f3(
   1,
   *intArrayOf(1, 2),
  )
  m.f3(
   1,
   *intArrayOf(),
  )
  val ints: IntArray = intArrayOf(1, 2)
  m.f3(
   1,
   *ints,
  )
 }

 open fun testInstanceMethodFirst() {
  val m: Main = Main(1)
  m.f4(1, 2)
  m.f4()
  m.f4(
   *intArrayOf(1, 2),
  )
  m.f4(
   *intArrayOf(),
  )
  val ints: IntArray = intArrayOf(1, 2)
  m.f4(
   *ints,
  )
 }

 open fun testJsFunction() {
  val a: AFunction = AFunction()
  val o1: Any = Any()
  val o2: Any = Any()
  a.f1(0, o1, o2)
  a.f1(0)
  a.f1(
   0,
   *arrayOf<Any?>(o1, o2),
  )
  a.f1(
   0,
   *arrayOf<Any?>(),
  )
  val os: Array<Any?> = arrayOf<Any?>(o1, o2)
  a.f1(
   0,
   *os,
  )
 }

 open fun testSideEffect() {
  val ints: IntArray = intArrayOf(1, 2)
  Main(1).f3(
   1,
   *ints,
  )
 }

 open fun testNullJsVarargs() {
  val ints: IntArray? = null
  Main.f2(
   *ints!!,
  )
 }

 open fun <U> testGenericJsFunctionWithVarags() {
  val function: GenericFunction<U> = GenericFunction { n: U, param: Array<out U>? ->
   val param_1: Array<U>? = param as Array<U>?
   return@GenericFunction param_1
  }
 }

 companion object {
  @JvmStatic
  @JsMethod
  fun f1(multiplier: Int, vararg numbers: Int): Int {
   return numbers!!.size + numbers!![0] + multiplier
  }

  @JvmStatic
  @JsMethod
  fun f2(vararg numbers: Int): Int {
   return numbers!!.size + numbers!![0]
  }

  @JvmStatic
  @JsMethod
  fun <T> generics(vararg elements: T): T {
   val elements_1: Array<T>? = elements as Array<T>?
   return elements_1!![0]
  }

  @JvmStatic
  @JsMethod
  fun parameterizedType(vararg elements: MutableList<Main?>?): Main? {
   val elements_1: Array<MutableList<Main?>?>? = elements as Array<MutableList<Main?>?>?
   return elements_1!![0]!!.get(0)
  }

  @JvmStatic
  @JsMethod
  fun <T> parameterizedByT(vararg elements: MutableList<T>?): T {
   val elements_1: Array<MutableList<T>?>? = elements as Array<MutableList<T>?>?
   return elements_1!![0]!!.get(0)
  }
 }

 @JsType(name = "Object", namespace = JsPackage.GLOBAL, isNative = true)
 open class NativeObject {
  constructor(vararg pars: Any?)
 }

 open class SubVarargsConstructorClass: NativeObject {
  @JsConstructor
  constructor(i: Int, vararg args: Any?): super(
   *(args as Array<Any?>?)!!,
  ) {
   val args_1: Array<Any?>? = args as Array<Any?>?
  }
 }

 @JsFunction
 fun interface Function {
  fun f1(i: Int, vararg args: Any?): Any?
 }

 @JsType
 abstract class AbstractMethodWithVarargs {
  abstract fun abstractMethod(vararg args: Int)
 }

 @JsType
 interface StaticInterfaceMethodWithVarargs {
  companion object {
   @JvmStatic
   fun staticMethod(vararg args: Int) {}
  }
 }

 class AFunction internal constructor(): Function {
  override fun f1(i: Int, vararg args: Any?): Any? {
   val args_1: Array<Any?>? = args as Array<Any?>?
   return args_1!![i]
  }
 }

 open class SubMain: Main {
  constructor(): super(10)

  override fun f3(m: Int, vararg numbers: Int): Int {
   var a: Int = super<Main>.f3(1, 1, 2)
   a = a + super<Main>.f3(1)
   a = a + super<Main>.f3(
    1,
    *intArrayOf(1, 2),
   )
   a = a + super<Main>.f3(
    1,
    *intArrayOf(),
   )
   val ints: IntArray = intArrayOf(1, 2)
   a = a + super<Main>.f3(
    1,
    *ints,
   )
   return a
  }
 }

 @JsFunction
 fun interface GenericFunction<T> {
  fun m(i: T, vararg args: T): Any?
 }
}
