enum class A : Enum<A> {
  private constructor() /* primary */ {
    TODO("IrEnumConstructorCall")
        /* InstanceInitializerCall */

  }

  V1 init = TODO("IrEnumConstructorCall")






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

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

}

fun testVariableAssignment_throws(a: A) {
  val x: Int
  { // BLOCK
    val tmp0_subject: A = a
    when {
      EQEQ(arg0 = tmp0_subject, arg1 = A) -> x = 11
      true -> noWhenBranchMatchedException()
    }
  }
}

fun testStatement_empty(a: A) {
  { // BLOCK
    val tmp0_subject: A = a
    when {
      EQEQ(arg0 = tmp0_subject, arg1 = A) -> 1 /*~> Unit */
    }
  }
}

fun testParenthesized_throwsJvm(a: A) {
  { // BLOCK
    val tmp0_subject: A = a
    when {
      EQEQ(arg0 = tmp0_subject, arg1 = A) -> 1 /*~> Unit */
    }
  }
}

fun testAnnotated_throwsJvm(a: A) {
  { // BLOCK
    val tmp0_subject: A = a
    when {
      EQEQ(arg0 = tmp0_subject, arg1 = A) -> 1 /*~> Unit */
    }
  }
}

fun testExpression_throws(a: A): Int {
  return { // BLOCK
    val tmp0_subject: A = a
    when {
      EQEQ(arg0 = tmp0_subject, arg1 = A) -> 1
      true -> noWhenBranchMatchedException()
    }
  }
}

fun testIfTheElseStatement_empty(a: A, flag: Boolean) {
  when {
    flag -> 0 /*~> Unit */
    true -> { // BLOCK
      { // BLOCK
        val tmp0_subject: A = a
        when {
          EQEQ(arg0 = tmp0_subject, arg1 = A) -> 1 /*~> Unit */
        }
      }
    }
  }
}

fun testIfTheElseParenthesized_throwsJvm(a: A, flag: Boolean) {
  when {
    flag -> 0 /*~> Unit */
    true -> { // BLOCK
      { // BLOCK
        val tmp0_subject: A = a
        when {
          EQEQ(arg0 = tmp0_subject, arg1 = A) -> 1 /*~> Unit */
        }
      }
    }
  }
}

fun testIfTheElseAnnotated_throwsJvm(a: A, flag: Boolean) {
  when {
    flag -> 0 /*~> Unit */
    true -> { // BLOCK
      { // BLOCK
        val tmp0_subject: A = a
        when {
          EQEQ(arg0 = tmp0_subject, arg1 = A) -> 1 /*~> Unit */
        }
      }
    }
  }
}

fun testLambdaResultExpression_throws(a: A) {
    local fun <anonymous>(): Int {
    return { // BLOCK
      val tmp0_subject: A = a
      when {
        EQEQ(arg0 = tmp0_subject, arg1 = A) -> 1
        true -> noWhenBranchMatchedException()
      }
    }
  }
.invoke() /*~> Unit */
}

