enum class TestEnum1 : Enum<TestEnum1> {
  private constructor() /* primary */ {
    super/*Enum*/<TestEnum1>()
    /* <init>() */

  }

  TEST1 = TestEnum1()

  TEST2 = TestEnum1()

  fun values(): Array<TestEnum1> /* Synthetic body for ENUM_VALUES */

  fun valueOf(value: String): TestEnum1 /* Synthetic body for ENUM_VALUEOF */

  val entries: EnumEntries<TestEnum1>
    get(): EnumEntries<TestEnum1> /* Synthetic body for ENUM_ENTRIES */

}

enum class TestEnum2 : Enum<TestEnum2> {
  private constructor(x: Int) /* primary */ {
    super/*Enum*/<TestEnum2>()
    /* <init>() */

  }

  val x: Int
    field = x
    get

  TEST1 = TestEnum2(x = 1)

  TEST2 = TestEnum2(x = 2)

  TEST3 = TestEnum2(x = 3)

  fun values(): Array<TestEnum2> /* Synthetic body for ENUM_VALUES */

  fun valueOf(value: String): TestEnum2 /* Synthetic body for ENUM_VALUEOF */

  val entries: EnumEntries<TestEnum2>
    get(): EnumEntries<TestEnum2> /* Synthetic body for ENUM_ENTRIES */

}

abstract enum class TestEnum3 : Enum<TestEnum3> {
  private constructor() /* primary */ {
    super/*Enum*/<TestEnum3>()
    /* <init>() */

  }

  TEST = TEST()
  private enum entry class TEST : TestEnum3 {
    private constructor() /* primary */ {
      super/*TestEnum3*/() /*~> Unit */
      /* <init>() */

    }

    override fun foo() {
      println(message = "Hello, world!")
    }

  }

  abstract fun foo()

  fun values(): Array<TestEnum3> /* Synthetic body for ENUM_VALUES */

  fun valueOf(value: String): TestEnum3 /* Synthetic body for ENUM_VALUEOF */

  val entries: EnumEntries<TestEnum3>
    get(): EnumEntries<TestEnum3> /* Synthetic body for ENUM_ENTRIES */

}

abstract enum class TestEnum4 : Enum<TestEnum4> {
  private constructor(x: Int) /* primary */ {
    super/*Enum*/<TestEnum4>()
    /* <init>() */

  }

  val x: Int
    field = x
    get

  TEST1 = TEST1()
  private enum entry class TEST1 : TestEnum4 {
    private constructor() /* primary */ {
      super/*TestEnum4*/(x = 1) /*~> Unit */
      /* <init>() */

    }

    override fun foo() {
      println(message = TestEnum4.TEST1)
    }

  }

  TEST2 = TEST2()
  private enum entry class TEST2 : TestEnum4 {
    private constructor() /* primary */ {
      super/*TestEnum4*/(x = 2) /*~> Unit */
      /* <init>() */

    }

    val z: Int
      get

    init {
      <this>.#z = <this>.<get-x>()
    }

    override fun foo() {
      println(message = TestEnum4.TEST2)
    }

  }

  abstract fun foo()

  fun values(): Array<TestEnum4> /* Synthetic body for ENUM_VALUES */

  fun valueOf(value: String): TestEnum4 /* Synthetic body for ENUM_VALUEOF */

  val entries: EnumEntries<TestEnum4>
    get(): EnumEntries<TestEnum4> /* Synthetic body for ENUM_ENTRIES */

}

enum class TestEnum5 : Enum<TestEnum5> {
  private constructor(x: Int = 0) /* primary */ {
    super/*Enum*/<TestEnum5>()
    /* <init>() */

  }

  val x: Int
    field = x
    get

  TEST1 = TestEnum5()

  TEST2 = TestEnum5()

  TEST3 = TestEnum5(x = 0)

  fun values(): Array<TestEnum5> /* Synthetic body for ENUM_VALUES */

  fun valueOf(value: String): TestEnum5 /* Synthetic body for ENUM_VALUEOF */

  val entries: EnumEntries<TestEnum5>
    get(): EnumEntries<TestEnum5> /* Synthetic body for ENUM_ENTRIES */

}

fun f(): Int {
  return 1
}

enum class TestEnum6 : Enum<TestEnum6> {
  private constructor(x: Int, y: Int) /* primary */ {
    super/*Enum*/<TestEnum6>()
    /* <init>() */

  }

  val x: Int
    field = x
    get

  val y: Int
    field = y
    get

  TEST = { // BLOCK
    val tmp0_y: Int = f()
    val tmp1_x: Int = f()
    TestEnum6(x = tmp1_x, y = tmp0_y)
  }

  fun values(): Array<TestEnum6> /* Synthetic body for ENUM_VALUES */

  fun valueOf(value: String): TestEnum6 /* Synthetic body for ENUM_VALUEOF */

  val entries: EnumEntries<TestEnum6>
    get(): EnumEntries<TestEnum6> /* Synthetic body for ENUM_ENTRIES */

}