package foo.bar.goo

import foo

public protected private internal
abstract
open
open
annotation
override
open
abstract
private
protected
public
internal
in
out
suspend
 class Bar<abstract, abstract enum : T, out open,
    public protected private internal abstract
    open
    enum
    open
    annotation
    override
    open
    abstract
    private
    protected
    public
    internal open
 > (a : B) : A by b {
    public protected private internal val abstract
    val open
    val enum
    val open
    val annotation
    val override
    val open
    val abstract
    val private
    val protected
    val public
    val internal
    val lazy
    val wraps
    val import
    val where
    val by
    val get
    val set
    val public
    val private
    val protected
    val internal
    val field
    val property
    val receiver
    val param
    val setparam
    val lateinit
    val const
    val suspend
    val coroutine
      get() = a
      set(S : s) {}


    public protected private internal
    fun abstract  () : abstract
    fun open   () : open
    fun enum      () : enum
    fun open      () : open
    fun annotation () : annotation
    fun override  () : override
    fun open   () : open
    fun abstract  () : abstract
    fun private   () : private
    fun protected () : protected
    fun public    () : public
    fun internal  () : internal
    fun lazy      () : lazy
    fun wraps     () : wraps
    fun import    () : import
    fun where     () : where
    fun by        () : by
    fun get       () : get
    fun set       () : set
    fun public    () : public
    fun private   () : private
    fun protected () : protected
    fun internal  () : internal
    fun field  () : field
    fun property  () : property
    fun receiver  () : receiver
    fun param  () : param
    fun setparam  () : setparam
    fun lateinit  () : lateinit
    fun const  () : const

    fun test(
        abstract  : t,
        open   : t,
        enum      : t,
        open      : t,
        annotation : t,
        override  : t,
        open   : t,
        abstract  : t,
        private   : t,
        protected : t,
        public    : t,
        internal  : t,
        lazy      : t,
        wraps     : t,
        import    : t,
        where     : t,
        by        : t,
        get       : t,
        set       : t,
        public    : t,
        private   : t,
        protected : t,
        internal  : t,
        field     : t,
        property  : t,
        receiver  : t,
        param     : t,
        setparam    : t,
        lateinit  : t,
        const     : t,
    public protected private internal abstract
    open
    enum
    open
    annotation
    override
    open
    abstract
    private
    protected
    public
    internal open : t

     )

}


class F(val foo : bar,
        abstract  : t,
        open   : t,
        enum      : t,
        open      : t,
        annotation : t,
        override  : t,
        open   : t,
        abstract  : t,
        private   : t,
        protected : t,
        public    : t,
        internal  : t,
        lazy      : t,
        wraps     : t,
        import    : t,
        where     : t,
        by        : t,
        get       : t,
        set       : t,
        public    : t,
        private   : t,
        protected : t,
        internal  : t,
        field     : t,
        property  : t,
        receiver  : t,
        param     : t,
        setparam    : t,
        lateinit  : t,
        const     : t,
    public protected private internal abstract
    open
    enum
    open
    annotation
    override
    open
    abstract
    private
    protected
    public
    internal open : b
) {

}