// RUN_PIPELINE_TILL: BACKEND
enum class EnumerationAAA() {
    ENTRY
}

enum class EnumerationAAB() {
    ENTRY;
}

enum class EnumerationAAC() {
    ENTRY1,
    ENTRY2;
}

enum class EnumerationAAD() {
    ENTRY1,
    ENTRY2();
}

enum class EnumerationAAE() {
    ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },
    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
    abstract fun abstractFunc()
}

enum class EnumerationABA(arg: UserKlass = UserKlass()) {
    ENTRY
}

enum class EnumerationABB(arg: UserKlass = UserKlass()) {
    ENTRY;
}

enum class EnumerationABC(arg: UserKlass = UserKlass()) {
    ENTRY1,
    ENTRY2;
}

enum class EnumerationABD(arg: UserKlass = UserKlass()) {
    ENTRY1,
    ENTRY2();
}

enum class EnumerationABE(arg: UserKlass = UserKlass()) {
    ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },
    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
    abstract fun abstractFunc()
}

enum class EnumerationACA(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
    ENTRY
}

enum class EnumerationACB(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
    ENTRY;
}

enum class EnumerationACC(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
    ENTRY1,
    ENTRY2;
}

enum class EnumerationACD(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
    ENTRY1,
    ENTRY2();
}

enum class EnumerationACE(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
    ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },
    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
    abstract fun abstractFunc()
}

enum class EnumerationADA(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY;<!>
    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
}

enum class EnumerationADB(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY2;<!>
    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
}

enum class EnumerationADC(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
    ENTRY2();
    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
}

enum class EnumerationADD(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },<!>
    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
    abstract fun abstractFunc()
}

enum class EnumerationAEA(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY;<!>
    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
    constructor() : this(UserKlass(), UserKlass())
}

enum class EnumerationAEB(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY2;<!>
    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
    constructor() : this(UserKlass(), UserKlass())
}

enum class EnumerationAEC(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
    ENTRY2();
    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
    constructor() : this(UserKlass(), UserKlass())
}

enum class EnumerationAED(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },<!>
    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
    constructor() : this(UserKlass(), UserKlass())
    abstract fun abstractFunc()
}

enum class EnumerationBAA constructor() {
    ENTRY
}

enum class EnumerationBAB constructor() {
    ENTRY;
}

enum class EnumerationBAC constructor() {
    ENTRY1,
    ENTRY2;
}

enum class EnumerationBAD constructor() {
    ENTRY1,
    ENTRY2();
}

enum class EnumerationBAE constructor() {
    ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },
    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
    abstract fun abstractFunc()
}

enum class EnumerationBBA constructor(arg: UserKlass = UserKlass()) {
    ENTRY
}

enum class EnumerationBBB constructor(arg: UserKlass = UserKlass()) {
    ENTRY;
}

enum class EnumerationBBC constructor(arg: UserKlass = UserKlass()) {
    ENTRY1,
    ENTRY2;
}

enum class EnumerationBBD constructor(arg: UserKlass = UserKlass()) {
    ENTRY1,
    ENTRY2();
}

enum class EnumerationBBE constructor(arg: UserKlass = UserKlass()) {
    ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },
    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
    abstract fun abstractFunc()
}

enum class EnumerationBCA constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
    ENTRY
}

enum class EnumerationBCB constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
    ENTRY;
}

enum class EnumerationBCC constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
    ENTRY1,
    ENTRY2;
}

enum class EnumerationBCD constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
    ENTRY1,
    ENTRY2();
}

enum class EnumerationBCE constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
    ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },
    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
    abstract fun abstractFunc()
}

enum class EnumerationBDA constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY;<!>
    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
}

enum class EnumerationBDB constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY2;<!>
    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
}

enum class EnumerationBDC constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
    ENTRY2();
    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
}

enum class EnumerationBDD constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },<!>
    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
    abstract fun abstractFunc()
}

enum class EnumerationBEA constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY;<!>
    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
    constructor() : this(UserKlass(), UserKlass())
}

enum class EnumerationBEB constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY2;<!>
    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
    constructor() : this(UserKlass(), UserKlass())
}

enum class EnumerationBEC constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
    ENTRY2();
    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
    constructor() : this(UserKlass(), UserKlass())
}

enum class EnumerationBED constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass()) {
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },<!>
    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
    constructor(arg: UserKlass = UserKlass()) : this(arg, UserKlass())
    constructor() : this(UserKlass(), UserKlass())
    abstract fun abstractFunc()
}

enum class EnumerationCAA {
    ENTRY;
    constructor()
}

enum class EnumerationCAB {
    ENTRY1,
    ENTRY2;
    constructor()
}

enum class EnumerationCAC {
    ENTRY1,
    ENTRY2();
    constructor()
}

enum class EnumerationCAD {
    ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },
    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
    constructor()
    abstract fun abstractFunc()
}

enum class EnumerationCBA {
    ENTRY;
    constructor(arg: UserKlass = UserKlass())
}

enum class EnumerationCBB {
    ENTRY1,
    ENTRY2;
    constructor(arg: UserKlass = UserKlass())
}

enum class EnumerationCBC {
    ENTRY1,
    ENTRY2();
    constructor(arg: UserKlass = UserKlass())
}

enum class EnumerationCBD {
    ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },
    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
    constructor(arg: UserKlass = UserKlass())
    abstract fun abstractFunc()
}

enum class EnumerationCCA {
    ENTRY;
    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
}

enum class EnumerationCCB {
    ENTRY1,
    ENTRY2;
    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
}

enum class EnumerationCCC {
    ENTRY1,
    ENTRY2();
    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
}

enum class EnumerationCCD {
    ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },
    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
    abstract fun abstractFunc()
}

enum class EnumerationCDA {
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY;<!>
    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
    constructor(arg: UserKlass = UserKlass())
}

enum class EnumerationCDB {
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY2;<!>
    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
    constructor(arg: UserKlass = UserKlass())
}

enum class EnumerationCDC {
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
    ENTRY2();
    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
    constructor(arg: UserKlass = UserKlass())
}

enum class EnumerationCDD {
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },<!>
    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
    constructor(arg: UserKlass = UserKlass())
    abstract fun abstractFunc()
}

enum class EnumerationCEA {
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY;<!>
    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
    constructor(arg: UserKlass = UserKlass())
    constructor()
}

enum class EnumerationCEB {
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY2;<!>
    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
    constructor(arg: UserKlass = UserKlass())
    constructor()
}

enum class EnumerationCEC {
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1,<!>
    ENTRY2();
    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
    constructor(arg: UserKlass = UserKlass())
    constructor()
}

enum class EnumerationCED {
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },<!>
    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
    constructor(arg1: UserKlass = UserKlass(), arg2: UserKlass = UserKlass())
    constructor(arg: UserKlass = UserKlass())
    constructor()
    abstract fun abstractFunc()
}

enum class EnumerationDA {
    ENTRY
}

enum class EnumerationDB {
    ENTRY;
}

enum class EnumerationDC {
    ENTRY1,
    ENTRY2;
}

enum class EnumerationDD {
    ENTRY1,
    ENTRY2();
}

enum class EnumerationDE {
    ENTRY1 { override fun abstractFunc() { TODO("Not yet implemented") } },
    ENTRY2() { override fun abstractFunc() { TODO("Not yet implemented") } };
    abstract fun abstractFunc()
}


class UserKlass

/* GENERATED_FIR_TAGS: classDeclaration, enumDeclaration, enumEntry, functionDeclaration, primaryConstructor,
secondaryConstructor */
