import java.util.Set;

    /**

     * Kind of symbols.

     *

     * IMPORTANT: This is an ordered type.  The ordering of

     * declarations in this enum matters.  Be careful when changing

     * it.

    public enum Kind {

        NIL(Category.BASIC, KindSelector.NIL),

        PCK(Category.BASIC, KindName.PACKAGE, KindSelector.PCK),

        TYP(Category.BASIC, KindName.CLASS, KindSelector.TYP),

        VAR(Category.BASIC, KindName.VAR, KindSelector.VAR),

        MTH(Category.BASIC, KindName.METHOD, KindSelector.MTH),

        POLY(Category.BASIC, KindSelector.POLY),

        ERR(Category.ERROR, KindSelector.ERR),

        AMBIGUOUS(Category.OVERLOAD),

        HIDDEN(Category.OVERLOAD),

        STATICERR(Category.OVERLOAD),

        MISSING_ENCL(Category.OVERLOAD),

        ABSENT_VAR(Category.OVERLOAD, KindName.VAR),

        WRONG_MTHS(Category.OVERLOAD, KindName.METHOD),

        WRONG_MTH(Category.OVERLOAD, KindName.METHOD),

        ABSENT_MTH(Category.OVERLOAD, KindName.METHOD),

        ABSENT_TYP(Category.OVERLOAD, KindName.CLASS),

        WRONG_STATICNESS(Category.OVERLOAD, KindName.METHOD);

        // There are essentially two "levels" to the Kind datatype.

        // The first is a totally-ordered set of categories of

        // solutions.  Within each category, we have more

        // possibilities.

        private enum Category {

            BASIC, ERROR, OVERLOAD;

        }

        private final KindName kindName;

        private final KindName absentKind;

        private final KindSelector selector;

        private final Category category;

        private Kind(Category category) {

            this(category, null, null, null);

        }

        private Kind(Category category,

                     KindSelector selector) {

            this(category, null, null, selector);

        }

        private Kind(Category category,

                     KindName absentKind) {

            this(category, null, absentKind, null);

        }

        private Kind(Category category,

                     KindName kindName,

                     KindSelector selector) {

            this(category, kindName, null, selector);

        }

        private Kind(Category category,

                     KindName kindName,

                     KindName absentKind,

                     KindSelector selector) {

            this.category = category;

            this.kindName = kindName;

            this.absentKind = absentKind;

            this.selector = selector;

        }

        public KindSelector toSelector() {

            return selector;

        }

        public boolean matches(KindSelector kindSelectors) {

            return selector.contains(kindSelectors);

        }

        public boolean isOverloadError() {

            return category == Category.OVERLOAD;

        }

        public boolean isValid() {

            return category == Category.BASIC;

        }

        public boolean betterThan(Kind other) {

            return ordinal() < other.ordinal();

        }

        public KindName kindName() {

            if (kindName == null) {

                throw new AssertionError("Unexpected kind: " + this);

            } else {

                return kindName;

            }

        }

        public KindName absentKind() {

            if (absentKind == null) {

                throw new AssertionError("Unexpected kind: " + this);

            } else {

                return absentKind;

            }

        }

    }

    public static class KindSelector {

        //basic selectors

        public static final KindSelector NIL = new KindSelector(0);

        public static final KindSelector PCK = new KindSelector(0x01);

        public static final KindSelector TYP = new KindSelector(0x02);

        public static final KindSelector VAR = new KindSelector(0x04);

        public static final KindSelector VAL = new KindSelector(0x0c);

        public static final KindSelector MTH = new KindSelector(0x10);

        public static final KindSelector ERR = new KindSelector(0x3f);

        public static final KindSelector POLY = new KindSelector(0x20);

        //common derived selectors

        public static final KindSelector TYP_PCK = of(TYP, PCK);

        public static final KindSelector VAL_MTH = of(VAL, MTH);

        public static final KindSelector VAL_POLY = of(VAL, POLY);

        public static final KindSelector VAL_TYP = of(VAL, TYP);

        public static final KindSelector VAL_TYP_PCK = of(VAL, TYP, PCK);

        private final byte data;

        private KindSelector(int data) {

            this.data = (byte) data;

        }

        public static KindSelector of(KindSelector... kindSelectors) {

            byte newData = 0;

            for (KindSelector kindSel : kindSelectors) {

                newData |= kindSel.data;

            }

            return new KindSelector(newData);

        }

        public boolean subset(KindSelector other) {

            return (data & ~other.data) == 0;

        }

        public boolean contains(KindSelector other) {

            return (data & other.data) != 0;

        }

        /** A set of KindName(s) representing a set of symbol's kinds. */

        public Set<KindName> kindNames() {

            EnumSet<KindName> kinds = EnumSet.noneOf(KindName.class);

            if ((data & VAL.data) != 0) {

                if ((data & VAL.data) == VAR.data) kinds.add(KindName.VAR);

                else kinds.add(KindName.VAL);

            }

            if ((data & MTH.data) != 0) kinds.add(KindName.METHOD);

            if ((data & TYP.data) != 0) kinds.add(KindName.CLASS);

            if ((data & PCK.data) != 0) kinds.add(KindName.PACKAGE);

            return kinds;

        }

    }